src/vapiCameraCalibrate.c

Ir para a documentação deste ficheiro.

#include <stdio.h>
#include "vapiTypes.h"
#include "vapi.h"
#include "vapiAux.h"
#include "vapiString.h"
#include "vapiImagesAux.h"
#include "vapiMacro.h"
#include "vapiOperationList.h"
#include "vapiOperationOptions.h"
#include "vapiCameraCalibrate.h"
#include "vapiGtkAuxWindow.h"   /* isto deve ser removido */

void
vapiCalibrateCameraCreateMacro (vOperationList * OperationList,
                                vMacro * Macro, vapi3Options * Options,
                                vBoolean CalculateConstant)
{
        vEffect *tempOperation;
        vOptions *tempOptions;

        /*
         * Filtro de Cor
         */
        tempOperation = vapiOperationListSelectOperation
                (OperationList, "Filtro de Cor");

        vapiMacroAddItem (Macro, tempOperation, Options->Option0);

        /*
         * Binarizar
         */
        tempOperation = vapiOperationListSelectOperation
                (OperationList, "Binarizar");

        tempOptions = vapiOperationOptionsInit (tempOperation);
        tempOptions->ints[0] = 0;

        vapiMacroAddItem (Macro, tempOperation, tempOptions);

        /*
         * Filtro de Pontos isolados
         */
        tempOperation = vapiOperationListSelectOperation
                (OperationList, "Filtro de Pontos Isolados");

        tempOptions = vapiOperationOptionsInit (tempOperation);

        vapiMacroAddItem (Macro, tempOperation, tempOptions);
        //vOptionsFree(tempOptions, tempOperation);
        /*
         * Erode
         */
        if (((vEffectOptions *) Options->Option1->CustomOptions)->times != 0)
        {
                tempOperation = vapiOperationListSelectOperation
                        (OperationList, "Erode");

                vapiMacroAddItem (Macro, tempOperation, Options->Option1);
        }
        /*
         * Dilate
         */
        if (((vEffectOptions *) Options->Option2->CustomOptions)->times != 0)
        {
                tempOperation = vapiOperationListSelectOperation
                        (OperationList, "Dilate");

                vapiMacroAddItem (Macro, tempOperation, Options->Option2);
        }
        /*
         * Centro Geométrico
         */
        tempOperation = vapiOperationListSelectOperation
                (OperationList, "Contagem de objectos");
        tempOptions = vapiOperationOptionsInit (tempOperation);
        /*
         * Se não vamos calcular a constante, não vale a pena detectar pontos.
         * Esta é uma maneira de prevenir durante testes que se encontrem 
         * milhares de pontos.
         */
        tempOptions->booleans[0] = CalculateConstant;

        vapiMacroAddItem (Macro, tempOperation, tempOptions);


}



vapiCalibrateCameraReturn *
vapiCalibrateCameraGetConstant (vOperationList * OperationList,
                                vImages * Images,
                                vapi3Options * OptionsA,
                                vapi3Options * OptionsB,
                                double distanceRealA, double distanceRealB,
                                vBoolean CalculateConstant)
{
        vMacroHeader *MacroA = vapiMacroNew ("A");
        vMacroHeader *MacroB = vapiMacroNew ("B");
        vMacroResult *ResultA, *ResultB;
        vapiCalibrateCameraReturn *OutResults =
                malloc (sizeof (vapiCalibrateCameraReturn));
        int distanceImageA1, distanceImageA2, distanceImageA;
        int distanceImageB1, distanceImageB2, distanceImageB;
        double kA, kB, k;

        ResultA = vapiMacroResultInit ();
        ResultB = vapiMacroResultInit ();

        /*
         * Criar Macro
         */
        vapiCalibrateCameraCreateMacro (OperationList,
                                        MacroA->Macro, OptionsA,
                                        CalculateConstant);
        vapiCalibrateCameraCreateMacro (OperationList,
                                        MacroB->Macro, OptionsB,
                                        CalculateConstant);
        /*
         * Executar Tarefas, colocar sempre a original.
         */
        vImagesFreeActual (Images);
        vapiOriginal2Actual (Images);
        vapiApplyMacro (MacroA, Images, vFALSE, vFALSE);
        OutResults->imResultA = Images->Actual;
        vapiOriginal2Actual (Images);
        vapiApplyMacro (MacroB, Images, vFALSE, vFALSE);
        OutResults->imResultB = Images->Actual;
        vapiOriginal2Actual (Images);
        /*
         * calcular as distâncias, em Pixeis.
         */
        if (!CalculateConstant)
        {
                goto FreeAndReturn;
        }
        /*
         * Verificar que temos 2 pontos em cada Resultado.
         */
        if (MacroA->PreviousResult->pointsNumber != 2)
        {
                v_info ("CalibrateCamera: Numero de Pontos no resultado A diferente de 2");
                goto FreeAndReturn;
        }
        if (MacroB->PreviousResult->pointsNumber != 2)
        {
                v_info ("CalibrateCamera: Numero de Pontos no resultado B diferente de 2");
                goto FreeAndReturn;
        }
        /*
         * Par A.
         */
        distanceImageA1 =
                MacroA->PreviousResult->points[0].x -
                MacroA->PreviousResult->points[1].x;
        if (distanceImageA1 < 0)
        {
                distanceImageA1 = distanceImageA1 * (-1);
        }
        distanceImageA2 =
                MacroA->PreviousResult->points[0].y -
                MacroA->PreviousResult->points[1].y;
        if (distanceImageA2 < 0)
        {
                distanceImageA2 = distanceImageA2 * (-1);
        }

        v_debug ("distanceA %d, %d", distanceImageA1, distanceImageA2);

        if (distanceImageA2 > distanceImageA1)
        {
                distanceImageA = distanceImageA2;
        }
        else
        {
                distanceImageA = distanceImageA1;
        }
        /*
         * Par B.
         */
        distanceImageB1 =
                MacroB->PreviousResult->points[0].x -
                MacroB->PreviousResult->points[1].x;
        if (distanceImageB1 < 0)
        {
                distanceImageB1 = distanceImageB1 * (-1);
        }
        distanceImageB2 =
                MacroB->PreviousResult->points[0].y -
                MacroB->PreviousResult->points[1].y;
        if (distanceImageB2 < 0)
        {
                distanceImageB2 = distanceImageB2 * (-1);
        }

        v_debug ("distanceB %d, %d", distanceImageB1, distanceImageB2);

        if (distanceImageB2 > distanceImageB1)
        {
                distanceImageB = distanceImageB2;
        }
        else
        {
                distanceImageB = distanceImageB1;
        }

        v_debug ("distancia A: %d , distancia B: %d", distanceImageA,
                 distanceImageB);

        /*
         * Calcular Constantes e constante média
         */
        if (!(distanceRealA > 0) || !(distanceRealB > 0))
        {
                goto FreeAndReturn;
        }

        v_debug ("distancia Real A: %1.2f , distancia Real B: %1.2f",
                 distanceRealA, distanceRealB);

        /*
         * Cor A.
         */
        kA = distanceImageA / distanceRealA;
        /*
         * Cor B.
         */
        kB = distanceImageB / distanceRealB;

        v_debug ("valor da constante kA %1.2f e kB %1.2f", kA, kB);

        /*
         * Média.
         */

        k = (kB + kA) / 2;

        v_debug ("valor da constante %1.2f", k);

        OutResults->constant = k;
        /*
         * Libertar Espaço e encerrar função.
         */

      FreeAndReturn:
        vapiMacroDelete (MacroA);
        vapiMacroDelete (MacroB);
        vResultFree (ResultA);
        vResultFree (ResultB);
        return OutResults;
}

vapi3Options *
vapi3OptionsInit ()
{
        vapi3Options *Options = malloc (sizeof (vapi3Options));
        return Options;
}

void
v3OptionsFree (vapi3Options * Options)
{
        free (Options);
}

void
vCalibrateCamerReturnFree (vapiCalibrateCameraReturn * calibrateReturn)
{
        cvReleaseImage (&calibrateReturn->imResultA);
        cvReleaseImage (&calibrateReturn->imResultB);
        free (calibrateReturn);
}

---