Referência ao ficheiro src/vapiCameraCalibrate.h

#include "vapiTypes.h"
#include "vapiCameraSettings.h"

Diagrama de dependências de inclusão para vapiCameraCalibrate.h:

Este grafo mostra quais são os ficheiros que incluem directamente ou indirectamente este ficheiro:

Ir para o código fonte deste ficheiro.

Estruturas de Dados
struct	_vapi3Options
struct	_vapiCalibrateCameraReturn
Definições de tipos
typedef _vapi3Options	vapi3Options
typedef _vapiCalibrateCameraReturn	vapiCalibrateCameraReturn
Funções
void	v3OptionsFree (vapi3Options *Options)
vapi3Options *	vapi3OptionsInit ()
vapiCalibrateCameraReturn *	vapiCalibrateCameraGetConstant (vOperationList *OperationList, vImages *Images, vapi3Options *OptionsA, vapi3Options *OptionsB, double distanceRealA, double distanceRealB, vBoolean CalculateConstant)
void	vCalibrateCamerReturnFree (vapiCalibrateCameraReturn *calibrateReturn)

---

Documentação dos tipos

typedef struct _vapi3Options vapi3Options

typedef struct _vapiCalibrateCameraReturn vapiCalibrateCameraReturn

---

Documentação das funções

void v3OptionsFree

(

vapi3Options *

Options

)

Definido na linha 272 do ficheiro vapiCameraCalibrate.c.

Referenciado por vapiGtkWindowCalibrateCameraGetImages().

{
        free (Options);
}

Here is the caller graph for this function:

vapi3Options* vapi3OptionsInit

(

)

Definido na linha 265 do ficheiro vapiCameraCalibrate.c.

Referenciado por vapiCalibrateCameraGetColourAOptions() e vapiCalibrateCameraGetColourBOptions().

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

Here is the caller graph for this function:

vapiCalibrateCameraReturn* vapiCalibrateCameraGetConstant	(	vOperationList *	OperationList,
		vImages *	Images,
		vapi3Options *	OptionsA,
		vapi3Options *	OptionsB,
		double	distanceRealA,
		double	distanceRealB,
		vBoolean	CalculateConstant
	)

Definido na linha 102 do ficheiro vapiCameraCalibrate.c.

Referências _vImages::Actual, _vapiCalibrateCameraReturn::constant, _vapiCalibrateCameraReturn::imResultA, _vapiCalibrateCameraReturn::imResultB, _vMacroHeader::Macro, OperationList, _vMacroResult::points, _vMacroResult::pointsNumber, _vMacroHeader::PreviousResult, v_debug, v_info(), vapiApplyMacro(), vapiCalibrateCameraCreateMacro(), vapiMacroDelete(), vapiMacroNew(), vapiMacroResultInit(), vapiOriginal2Actual(), vFALSE, vImagesFreeActual() e vResultFree().

Referenciado por vapiGtkWindowCalibrateCameraGetImages().

{
        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;
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vCalibrateCamerReturnFree

(

vapiCalibrateCameraReturn *

calibrateReturn

)

Definido na linha 278 do ficheiro vapiCameraCalibrate.c.

Referências _vapiCalibrateCameraReturn::imResultA e _vapiCalibrateCameraReturn::imResultB.

Referenciado por vapiGtkWindowCalibrateCameraGetImages().

{
        cvReleaseImage (&calibrateReturn->imResultA);
        cvReleaseImage (&calibrateReturn->imResultB);
        free (calibrateReturn);
}

Here is the caller graph for this function:

---