Referência ao ficheiro src/vapiOperationsDefault.h

#include <cxcore.h>
#include "vapiOperation.h"
#include "vapiImages.h"
#include "vapiOptions.h"
#include "vapiResult.h"

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

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

Ir para o código fonte deste ficheiro.

Funções
void	vapiApplyOperation (vImages *Images, vEffect *Operation, vOptions *Options, vMacroResult *PreviousResult)
	Executa uma operação.
void	vapiBinarizar (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiCanny (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiColourFilter (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiCompareFloat (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiCompareInt (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiCountObjects (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiDilate (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiEndExecution (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiEraseIsolatedPixels (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiErode (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiFlip (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiGeometricCenter (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiGrayscale (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiJumpToConditional (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiLaplace (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiMarkPoints (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiNot (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiObjectExists (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiOCR (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiResultResetInts (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiResultResetPoints (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiSelectRegion (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiSmooth (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiSobel (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiTemplateMatch (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiTeste (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
void	vapiThreshold (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
	Função para efectuar a binarização.

---

Documentação das funções

void vapiApplyOperation	(	vImages *	Images,
		vEffect *	Operation,
		vOptions *	Options,
		vMacroResult *	PreviousResult
	)

Executa uma operação.

Parâmetros:

	Images	estrtura de imagens.
	Operation	Operação a executar.
	Options	Opções para a operação.
	PreviousResult	Estrutura de Resultados.

Opções e verificações a executar préviamente.

Se a Operação suporta repetição própria Interna

Definido na linha 42 do ficheiro vapiOperationsDefault.c.

Referências _vOptions::CustomOptions, _vEffect::func, _vEffect::name, _vEffect::OptionsSettings, v_debug e vapiCheckOptOriginal().

Referenciado por vapiApplyMacro(), vapiApplyMacroUntil(), vapiGtkMacroSelectNext() e vapiGtkOperationApply().

{
        int i;
        vapiCheckOptOriginal (Images, Options);

        v_debug ("ApplyOperation: %s", Operation->name);

        if (((vEffectSettings *) Operation->OptionsSettings->
             CustomOptionsSettings)->repeatInside)
        {
                Operation->func (Images, Options, PreviousResult);
                return;
        }

        for (i = 0;
             i < ((vEffectOptions *) Options->CustomOptions)->times; i++)
        {
                Operation->func (Images, Options, PreviousResult);
        }


}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiBinarizar	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 132 do ficheiro vapiOperationsDefault.c.

Referências vapiGrayscale() e vapiThreshold().

Referenciado por vapiAvailableEfects().

{

        /*
         * Primeiro, mete-se em escala de cinzentos
         */
        vapiGrayscale (Images, options, NULL);
        /*
         * Depois binariza-se
         */

        vapiThreshold (Images, options, NULL);

}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiCanny	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Função para detecção de arestas

Definido na linha 277 do ficheiro vapiOperationsDefault.c.

Referências vapiImagesCheckChannels().

Referenciado por vapiAvailableEfects().

{
        if (!vapiImagesCheckChannels (Images, 1))
                return;

        /*
         * FIXME: Énecessário poder definir na interface os parâmetros da função.
         */
        cvCanny (Images->Actual, Images->Actual, 50, 105, 3);

}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiColourFilter	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 324 do ficheiro vapiOperationsDefault.c.

Referências v_debug, vapiImagesCheckChannels(), vapiImagesSameSize(), vapiImagesSetActual() e vapiOptionsGetFloats().

Referenciado por vapiAvailableEfects().

{
        IplImage *tempImage, *imagesHSV[3], *resultHSV[3], *finalMask;
        int width, height;

        double HUEMAX, HUEMIN, VALUEMIN, VALUEMAX, SATMIN, SATMAX;

        if (!vapiImagesCheckChannels (Images, 3))
        {
                return;
        }

        /*
         * Colocar os valores de HSV de um modo mais utilizável.
         */
        HUEMIN = vapiOptionsGetFloats (options, 0);
        HUEMAX = vapiOptionsGetFloats (options, 1);
        SATMIN = vapiOptionsGetFloats (options, 2);
        SATMAX = vapiOptionsGetFloats (options, 3);
        VALUEMIN = vapiOptionsGetFloats (options, 4);
        VALUEMAX = vapiOptionsGetFloats (options, 5);

        v_debug ("HUEMIN %f, HUEMAX %f", HUEMIN, HUEMAX);

        /*
         * Converter da escala normalizada 0...1 para 0..180 e 
         *  deslocamento de escala.
         */
        /*
         * cvInRange faz < MAX, o que significa que quando max =1, 
         *  ele deita fora resultados;
         */

        HUEMAX = HUEMAX * 180 + 1;

        HUEMIN = HUEMIN * 180;

        SATMAX = SATMAX * 255 + 1;
        SATMIN = SATMIN * 255;
        VALUEMIN = VALUEMIN * 255;
        VALUEMAX = VALUEMAX * 255 + 1;

        v_debug ("HUEMIN %f, HUEMAX %f", HUEMIN, HUEMAX);

        /*
         * Criar Imagens Temporárias.
         * tempImage : conversão de RGB para HSV.
         * imagesHSV : array de imagens, uma para cada canal, H S V .
         */
        tempImage = vapiImagesSameSize (Images->Actual, 3);
        imagesHSV[0] = vapiImagesSameSize (Images->Actual, 1);
        imagesHSV[1] = vapiImagesSameSize (Images->Actual, 1);
        imagesHSV[2] = vapiImagesSameSize (Images->Actual, 1);
        resultHSV[0] = vapiImagesSameSize (Images->Actual, 1);
        resultHSV[1] = vapiImagesSameSize (Images->Actual, 1);
        resultHSV[2] = vapiImagesSameSize (Images->Actual, 1);
        finalMask = vapiImagesSameSize (Images->Actual, 1);




        /*
         * Converter a imagem para HSV.
         *
         */
        cvCvtColor (Images->Actual, tempImage, CV_RGB2HSV);
        cvSplit (tempImage, imagesHSV[0], imagesHSV[1], imagesHSV[2], NULL);

        /*
         * tempImage já não é necessária para o processamento, servirá 
         *  agora para guardar a mascara de filtragem.
         */

        cvReleaseImage (&tempImage);
        tempImage = vapiImagesSameSize (Images->Actual, 3);

        /*
         * Ciclo de filtro;
         */
        width = Images->Actual->width;
        height = Images->Actual->height;

        cvInRangeS (imagesHSV[0], cvScalarAll (HUEMIN), cvScalarAll (HUEMAX),
                    resultHSV[0]);
        cvInRangeS (imagesHSV[1], cvScalarAll (SATMIN), cvScalarAll (SATMAX),
                    resultHSV[1]);
        cvInRangeS (imagesHSV[2], cvScalarAll (VALUEMIN),
                    cvScalarAll (VALUEMAX), resultHSV[2]);
        cvAnd (resultHSV[0], resultHSV[1], finalMask, resultHSV[2]);

        /*
         * Copiar a imagem baseada na máscara.
         */
        cvReleaseImage (&imagesHSV[0]);
        cvReleaseImage (&imagesHSV[1]);
        cvReleaseImage (&imagesHSV[2]);
        cvReleaseImage (&resultHSV[0]);
        cvReleaseImage (&resultHSV[1]);
        cvReleaseImage (&resultHSV[2]);
        /*
         * Cópia da imagem actual.
         */
        cvCopy (Images->Actual, tempImage, finalMask);
        vapiImagesSetActual (Images, tempImage);
        cvReleaseImage (&finalMask);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiCompareFloat	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 694 do ficheiro vapiOperationsDefault.c.

Referências _vMacroResult::Decision, _vMacroResult::floatsNumber, vapiOptionsGetChoices(), vapiOptionsGetFloats(), vapiOptionsGetInts(), vapiResultGetFloat(), vFALSE e vTRUE.

Referenciado por vapiAvailableEfects().

{
        double result, testValue;
        if (PreviousResult->floatsNumber == 0)
        {
                return;
        }
        result = vapiResultGetFloat (PreviousResult,
                                     vapiOptionsGetInts (options, 0));
        testValue = vapiOptionsGetFloats (options, 0);
        switch (vapiOptionsGetChoices (options, 0))
        {
        case 0:
        {
                if (result > testValue)
                {
                        PreviousResult->Decision = vTRUE;
                }
                else
                {
                        PreviousResult->Decision = vFALSE;
                }
                break;
        }
        case 1:
        {
                if (result >= testValue)
                {
                        PreviousResult->Decision = vTRUE;
                }
                else
                {
                        PreviousResult->Decision = vFALSE;
                }
                break;
        }
        case 2:
        {
                if (result == testValue)
                {
                        PreviousResult->Decision = vTRUE;
                }
                else
                {
                        PreviousResult->Decision = vFALSE;
                }
                break;
        }
        case 3:
        {
                if (result <= testValue)
                {
                        PreviousResult->Decision = vTRUE;
                }
                else
                {
                        PreviousResult->Decision = vFALSE;
                }
                break;
        }
        case 4:
        {
                if (result < testValue)
                {
                        PreviousResult->Decision = vTRUE;
                }
                else
                {
                        PreviousResult->Decision = vFALSE;
                }
                break;
        }
        case 5:
        {
                if (result != testValue)
                {
                        PreviousResult->Decision = vTRUE;
                }
                else
                {
                        PreviousResult->Decision = vFALSE;
                }
                break;
        }
        }
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiCompareInt	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 605 do ficheiro vapiOperationsDefault.c.

Referências _vMacroResult::Decision, _vMacroResult::intsNumber, vapiOptionsGetChoices(), vapiOptionsGetInts(), vapiResultGetInt(), vFALSE e vTRUE.

{
        int result, testValue;
        if (PreviousResult->intsNumber == 0)
        {
                return;
        }
        result = vapiResultGetInt (PreviousResult,
                                   vapiOptionsGetInts (options, 0));

        testValue = vapiOptionsGetInts (options, 1);
        switch (vapiOptionsGetChoices (options, 0))
        {
        case 0:
        {
                if (result > testValue)
                {
                        PreviousResult->Decision = vTRUE;
                }
                else
                {
                        PreviousResult->Decision = vFALSE;
                }
                break;
        }
        case 1:
        {
                if (result >= testValue)
                {
                        PreviousResult->Decision = vTRUE;
                }
                else
                {
                        PreviousResult->Decision = vFALSE;
                }
                break;
        }
        case 2:
        {
                if (result == testValue)
                {
                        PreviousResult->Decision = vTRUE;
                }
                else
                {
                        PreviousResult->Decision = vFALSE;
                }
                break;
        }
        case 3:
        {
                if (result <= testValue)
                {
                        PreviousResult->Decision = vTRUE;
                }
                else
                {
                        PreviousResult->Decision = vFALSE;
                }
                break;
        }
        case 4:
        {
                if (result < testValue)
                {
                        PreviousResult->Decision = vTRUE;
                }
                else
                {
                        PreviousResult->Decision = vFALSE;
                }
                break;
        }
        case 5:
        {
                if (result != testValue)
                {
                        PreviousResult->Decision = vTRUE;
                }
                else
                {
                        PreviousResult->Decision = vFALSE;
                }
                break;
        }
        }
}

Grafo de chamadas desta função:

void vapiCountObjects	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 516 do ficheiro vapiOperationsDefault.c.

Referências _vImages::Actual, _vMacroResult::pointsNumber, vapiGeometricCenter(), vapiImagesCheckChannels(), vapiOptionsGetBooleans() e vImagesInit().

Referenciado por vapiAvailableEfects().

{
        int line, column, objectCount = 0;
        CvScalar pixelValue, NewValue;
        CvConnectedComp comp_tmp;
        int connectivity_tmp = 4, new = 255;
        int flags_tmp = connectivity_tmp + (new << 8);
        IplImage *tempImage;
        vImages *tempImages = vImagesInit ();

        NewValue = cvScalarAll (0);
        tempImage = cvCloneImage (Images->Actual);
        tempImages->Actual = cvCloneImage (Images->Actual);

        if (!vapiImagesCheckChannels (Images, 1))
        {
                return;
        }
        for (line = 0; line < Images->Actual->height; line++)
        {
                for (column = 0; column < Images->Actual->width; column++)
                {
                        pixelValue = cvGet2D (tempImage, line, column);
                        if (pixelValue.val[0] == 255)
                        {
                                objectCount++;
                                cvCopy (tempImage, tempImages->Actual, NULL);
                                cvFloodFill (tempImage,
                                             cvPoint (column, line), NewValue,
                                             cvScalarAll (20),
                                             cvScalarAll (20), &comp_tmp,
                                             flags_tmp, NULL);

                                cvSub (tempImages->Actual, tempImage,
                                       tempImages->Actual, NULL);
                                if (vapiOptionsGetBooleans (options, 0)
                                    && PreviousResult->pointsNumber <
                                    (tempImages->Actual->width *
                                     tempImages->Actual->height * 0.03))
                                {
                                        vapiGeometricCenter (tempImages, NULL,
                                                             PreviousResult);
                                }
                        }

                }
        }
        vImagesFreeActual (tempImages);
        free (tempImages);
        cvReleaseImage (&tempImage);
        vapiResultAddInt (PreviousResult, objectCount);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiDilate	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 312 do ficheiro vapiOperationsDefault.c.

Referências vapiImagesCheckChannels() e vapiOptionsGetTimes().

Referenciado por vapiAvailableEfects().

{
        if (!vapiImagesCheckChannels (Images, 1))
                return;

        cvDilate (Images->Actual, Images->Actual, NULL,
                  vapiOptionsGetTimes (options));

}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiEndExecution	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 508 do ficheiro vapiOperationsDefault.c.

Referências vapiResultSetEnd().

Referenciado por vapiAvailableEfects().

{
        vapiResultSetEnd (PreviousResult);

}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiEraseIsolatedPixels	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 956 do ficheiro vapiOperationsDefault.c.

Referências vapiImagesCheckChannels() e vapiImagesSameSize().

Referenciado por vapiAvailableEfects().

{
        double Filter[] = {
                -0.1, -0.1, -0.1, -0.1, 0.8, -0.1, -0.1, -0.1, -0.1
        };
        CvMat kernel = cvMat (3, 3, CV_32F, Filter);
        IplImage *mask, *filterResult;

        if (!vapiImagesCheckChannels (Images, 1))
        {
                return;
        }
        mask = vapiImagesSameSize (Images->Actual, 1);
        filterResult = vapiImagesSameSize (Images->Actual, 1);

        cvFilter2D (Images->Actual, filterResult, &kernel, cvPoint (-1, -1));

        /*
         * Existe um limite maximo de 255, para o valor na imagem.
         *  por exemplo, 8*255 ultrapassaria esse valor, ficando = 255,
         * Decidiu-se então utilizar os pesos divididos por 10,
         *  em que o áximo é 204.
         */
        cvInRangeS (filterResult, cvScalarAll (204), cvScalarAll (205), mask);

        cvSub (Images->Actual, mask, Images->Actual, NULL);

        cvReleaseImage (&mask);
        cvReleaseImage (&filterResult);


}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiErode	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 295 do ficheiro vapiOperationsDefault.c.

Referências vapiImagesCheckChannels() e vapiOptionsGetTimes().

Referenciado por vapiAvailableEfects().

{
        if (!vapiImagesCheckChannels (Images, 1))
        {
                return;
        }

        cvErode (Images->Actual, Images->Actual, NULL,
                 vapiOptionsGetTimes (options));

}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiFlip	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 208 do ficheiro vapiOperationsDefault.c.

Referências _vImages::Actual, vapiImagesSameSize() e vapiOptionsGetInts().

Referenciado por vapiAvailableEfects().

{
        IplImage *tempImage;

        tempImage = vapiImagesSameSize (Images->Actual, 0);

        cvFlip (Images->Actual, tempImage, vapiOptionsGetInts (options, 0));

        cvCopy (tempImage, Images->Actual, NULL);

        cvReleaseImage (&tempImage);


}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiGeometricCenter	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 433 do ficheiro vapiOperationsDefault.c.

Referências vapiImagesCheckChannels().

Referenciado por vapiAvailableEfects() e vapiCountObjects().

{
        int linha, coluna, somaC = 0, somaL = 0, n = 0;
        CvScalar pixelValue;


        if (!vapiImagesCheckChannels (Images, 1))
        {
                return;
        }
        if (!(cvCountNonZero (Images->Actual) > 0))
        {
                return;
        }

        for (coluna = 0; coluna < Images->Actual->width; coluna++)
        {
                for (linha = 0; linha < Images->Actual->height; linha++)
                {
                        pixelValue = cvGet2D (Images->Actual, linha, coluna);

                        if (pixelValue.val[0])
                        {
                                somaC += coluna;
                                somaL += linha;
                                n++;
                        }
                }

        }
        coluna = somaC / n;
        linha = somaL / n;

        vapiResultAddPoint (PreviousResult, coluna, linha);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiGrayscale	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 90 do ficheiro vapiOperationsDefault.c.

Referências vapiImagesCheckChannels(), vapiImagesSameSize() e vapiImagesSetActual().

Referenciado por vapiAvailableEfects() e vapiBinarizar().

{
        IplImage *tempImage;


        /*
         * Caso o numero de canais seja diferente de 3,
         * ou já é grayscale ou não é RGB.
         */
        if (!vapiImagesCheckChannels (Images, 3))
                return;

        /*
         * cria-se então uma imagem temporária com apenas 1 canal
         */

        tempImage = vapiImagesSameSize (Images->Actual, 1);

        /* Transformar a imagem em grayscale */
        cvCvtColor (Images->Actual, tempImage, CV_RGB2GRAY);

        /*
         * Recria-se a imagem Actual, em branco
         */
        vapiImagesSetActual (Images, vapiImagesSameSize (tempImage, 1));

        /*
         * Copia-se a Imagem temporária para a Actual
         */
        cvCopy (tempImage, Images->Actual, NULL);

        cvReleaseImage (&tempImage);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiJumpToConditional	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 493 do ficheiro vapiOperationsDefault.c.

Referências vapiOptionsGetInts(), vapiResultGetDecision() e vapiResultSetJumpTo().

Referenciado por vapiAvailableEfects().

{
        if (vapiResultGetDecision (PreviousResult))
        {
                vapiResultSetJumpTo (PreviousResult,
                                     vapiOptionsGetInts (options, 0));
        }
        else
        {
                vapiResultSetJumpTo (PreviousResult,
                                     vapiOptionsGetInts (options, 1));
        }
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiLaplace	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 252 do ficheiro vapiOperationsDefault.c.

Referências vapiCheckOptOriginal(), vapiImagesCheckChannels() e vapiImagesSameSize16().

Referenciado por vapiAvailableEfects().

{
        IplImage *tempImage;

        if (!vapiImagesCheckChannels (Images, 1))
                return;

        vapiCheckOptOriginal (Images, options);

        tempImage = vapiImagesSameSize16 (Images->Actual, 0);

        cvLaplace (Images->Actual, tempImage, 3);

        cvConvertScaleAbs (tempImage, Images->Actual, 1, 0);

        cvReleaseImage (&tempImage);


}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiMarkPoints	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 577 do ficheiro vapiOperationsDefault.c.

Referências _vImages::Actual, vapiImagesDrawCross(), vapiOptionsGetInts(), vapiResultGetPoint() e vapiResultGetPointsNumber().

Referenciado por vapiAvailableEfects().

{
        vPoint workPoint;
        int i, color[3] = { vapiOptionsGetInts (options, 0),
                vapiOptionsGetInts (options, 1), vapiOptionsGetInts (options,
                                                                     2)
        };
        int PointsNumber;
        PointsNumber = vapiResultGetPointsNumber (PreviousResult);
        if (!(PointsNumber > 0))
        {
                return;
        }

        for (i = 0; i < PointsNumber; i++)
        {
                workPoint = vapiResultGetPoint (PreviousResult, i);

                vapiImagesDrawCross (Images->Actual, workPoint.y,
                                     workPoint.x, vapiOptionsGetInts (options,
                                                                      3), 2,
                                     color);

        }
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiNot	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 991 do ficheiro vapiOperationsDefault.c.

Referências vapiImagesCheckChannels(), vapiImagesSameSize() e vapiImagesSetActual().

{
        IplImage *finalImage;
        if (!vapiImagesCheckChannels (Images, 1))
        {
                return;
        }

        finalImage = vapiImagesSameSize (Images->Actual, 1);

        cvNot (Images->Actual, finalImage);

        vapiImagesSetActual (Images, finalImage);


}

Grafo de chamadas desta função:

void vapiObjectExists	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 474 do ficheiro vapiOperationsDefault.c.

Referências vapiImagesCheckChannels(), vapiResultSetDecision(), vFALSE e vTRUE.

Referenciado por vapiAvailableEfects().

{
        if (!vapiImagesCheckChannels (Images, 1))
        {
                return;
        }

        if (cvCountNonZero (Images->Actual) > 0)
        {
                vapiResultSetDecision (PreviousResult, vTRUE);
        }
        else
        {
                vapiResultSetDecision (PreviousResult, vFALSE);
        }
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiOCR	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 853 do ficheiro vapiOperationsDefault.c.

Referências v_info(), vapiImagesCheckChannels() e vapiResultAddChar().

Referenciado por vapiAvailableEfects().

{
        FILE *resultFile;
        char textFromImage[200];
        /*
         * O tesseract apenas suporta ficheiros de 1 canal.
         */
        if (!vapiImagesCheckChannels (Images, 1))
        {
                return;
        }

        cvSaveImage ("temp1.tif", Images->Actual);
        v_info ("existe o temp1");
#ifndef VAPI_OS_LINUX
        system ("bin\\tesseract\\tesseract.exe temp1.tif vapiOCR batch");
#else
        system ("tesseract temp1.tif vapiOCR batch");
#endif

        resultFile = fopen ("vapiOCR.txt", "r");

        fscanf (resultFile, "%s", textFromImage);
        v_info ("lido: %s", textFromImage);

        vapiResultAddChar (PreviousResult, textFromImage);


        fclose (resultFile);
        /*
         * Eliminar os ficheiros criados.
         */
        vapiResultAddChar (PreviousResult, textFromImage);
        unlink ("temp1.tif");
        unlink ("vapiOCR.txt");
        unlink ("vapiOCR.map");
        unlink ("vapiOCR.raw");

}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiResultResetInts	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 1016 do ficheiro vapiOperationsDefault.c.

Referências vResultResetInts().

Referenciado por vapiAvailableEfects().

{
        vResultResetInts (PreviousResult);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiResultResetPoints	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 1009 do ficheiro vapiOperationsDefault.c.

Referências vResultResetPoints().

Referenciado por vapiAvailableEfects().

{
        vResultResetPoints (PreviousResult);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiSelectRegion	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 894 do ficheiro vapiOperationsDefault.c.

Referências _vImages::Actual, vapiImagesSameSize(), vapiImagesSetActual(), vapiOptionsGetBooleans() e vapiOptionsGetInts().

Referenciado por vapiAvailableEfects().

{
        IplImage *mask, *copyResult;
        CvPoint vertices[4];
        int lineThickness = 1, i;
        int connectivity_tmp = 4, new = 255;
        int flags_tmp = connectivity_tmp + (new << 8);
        int intOption;

        for (i = 0; i < 8; i++)
        {
                intOption = vapiOptionsGetInts (options, i);
                if (intOption < 0 || intOption < 0)
                {
                        return;
                }
        }

        mask = vapiImagesSameSize (Images->Actual, 1);
        cvSetZero (mask);

        for (i = 0; i < 4; i++)
        {
                vertices[i].x = vapiOptionsGetInts (options, i * 2);
                vertices[i].y = vapiOptionsGetInts (options, i * 2 + 1);
                if (i > 0)
                {
                        cvLine (mask,
                                vertices[i - 1],
                                vertices[i],
                                CV_RGB (255, 255, 255), lineThickness, 8, 0);
                }
                if (i == 3)
                {
                        cvLine (mask,
                                vertices[i],
                                vertices[0],
                                CV_RGB (255, 255, 255), lineThickness, 8, 0);
                }

        }

        cvFloodFill (mask,
                     cvPoint (vertices[0].x + 2, vertices[0].y + 2),
                     cvScalarAll (255), cvScalarAll (20), cvScalarAll (20),
                     NULL, flags_tmp, NULL);

        if (vapiOptionsGetBooleans (options, 0))
        {
                cvNot (mask, mask);

        }
        copyResult =
                vapiImagesSameSize (Images->Actual,
                                    Images->Actual->nChannels);
        cvCopy (Images->Actual, copyResult, mask);
        vapiImagesSetActual (Images, copyResult);
        cvReleaseImage (&mask);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiSmooth	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 149 do ficheiro vapiOperationsDefault.c.

Referências _vImages::Actual, vapiImagesSameSize(), vapiOptionsGetChoices() e vapiOptionsGetInts().

Referenciado por vapiAvailableEfects().

{
        IplImage *tempImage;
        int smoothType;

        switch (vapiOptionsGetChoices (options, 0))
        {
        case 0:
        {
                smoothType = CV_BLUR_NO_SCALE;
                break;
        }
        case 1:
        {
                smoothType = CV_BLUR;
                break;
        }
        case 2:
        {
                smoothType = CV_GAUSSIAN;
                break;
        }
        case 3:
        {
                smoothType = CV_MEDIAN;
                break;
        }
        case 4:
        {
                smoothType = CV_BILATERAL;
                break;
        }
        default:
        {
                smoothType = CV_MEDIAN;
                break;
        }

        }

        tempImage = vapiImagesSameSize (Images->Actual, 0);

#ifdef VAPI_OS_LINUX
        cvSmooth (Images->Actual, tempImage, smoothType,
                  vapiOptionsGetInts (options, 0),
                  vapiOptionsGetInts (options, 1), 0);
#else
        cvSmooth (Images->Actual, tempImage, smoothType,
                  vapiOptionsGetInts (options, 0),
                  vapiOptionsGetInts (options, 1), 0, 0);
#endif

        cvCopy (tempImage, Images->Actual, NULL);

        cvReleaseImage (&tempImage);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiSobel	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 224 do ficheiro vapiOperationsDefault.c.

Referências vapiImagesCheckChannels(), vapiImagesSameSize(), vapiImagesSameSize16() e vapiImagesSetActual().

Referenciado por vapiAvailableEfects().

{

        IplImage *tempImage;

        /*
         * Apenas pode ser efectuado em imagens com apenas 1 canal
         */

        if (!vapiImagesCheckChannels (Images, 1))
        {
                return;
        }

        tempImage = vapiImagesSameSize16 (Images->Actual, 0);

        cvSobel (Images->Actual, tempImage, 1, 1, 3);

        vapiImagesSetActual (Images, vapiImagesSameSize (tempImage, 0));

        cvConvertScaleAbs (tempImage, Images->Actual, 1, 0);

        cvReleaseImage (&tempImage);

}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiTemplateMatch	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 783 do ficheiro vapiOperationsDefault.c.

Referências _vImages::Actual, v_info(), vapiImagesCheckChannels(), vapiImagesSameSize(), vapiImagesSetActual(), vapiOptionsGetFloats(), vapiOptionsGetTemplate() e vapiResultAddInt().

Referenciado por vapiAvailableEfects().

{
        IplImage *result, *template, *OriginalTemplate;
        int resultWidth, resultHeight, width, height;

        OriginalTemplate = vapiOptionsGetTemplate (options);

        if ((OriginalTemplate->width > Images->Actual->width)
            || (OriginalTemplate->height > Images->Actual->height))
        {
                v_info ("TemplateMatch: Medidas do template superior às da imagem");
                return;
        }
        //vapiShowImage ("template", options->Template);

        /*
         * Definição da largura da Matriz de resultados
         */
        width = Images->Actual->width;
        height = Images->Actual->height;
        resultWidth = width - OriginalTemplate->width + 1;
        resultHeight = height - OriginalTemplate->height + 1;

        result = cvCreateImage (cvSize (resultWidth, resultHeight),
                                IPL_DEPTH_32F, 1);


        /*
         * O template e a imagem t�m que ter o mesmo n�mero de canais.
         */
        if (!vapiImagesCheckChannels (Images, OriginalTemplate->nChannels))
        {
                cvReleaseImage (&result);
                return;
        }

        /* Finalmente, fazer o match. */
        cvMatchTemplate (Images->Actual,
                         OriginalTemplate, result, CV_TM_CCORR_NORMED);


        template = vapiImagesSameSize (result, 1);

        cvInRangeS (result, cvScalarAll (vapiOptionsGetFloats (options, 0)),
                    cvScalarAll (1.1), template);

        vapiResultAddInt (PreviousResult, cvCountNonZero (template));

        vapiImagesSetActual (Images,
                             cvCreateImage (cvSize (width, height),
                                            IPL_DEPTH_8U, 1));
        cvZero (Images->Actual);

        cvSetImageROI (Images->Actual,
                       cvRect (((OriginalTemplate->width / 2)),
                               ((OriginalTemplate->height / 2)),
                               result->width, result->height));

        cvCopy (template, Images->Actual, NULL);
        cvResetImageROI (Images->Actual);

        /*
         * Libertar memória de componentes temporários
         */
        cvReleaseImage (&result);
        cvReleaseImage (&template);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiTeste	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Definido na linha 1023 do ficheiro vapiOperationsDefault.c.

Referências v_debug e v_input_NULL_boolean().

Referenciado por vapiAvailableEfects().

{
        vBoolean *Input;
        if ((Input = v_input_NULL_boolean (1)) == NULL)
        {       
                v_debug("erro");
                return;
        }
        if (Input[0])
        {
                free(Input);
                v_debug ("É verdadeiro");
        }
        else
        {
                free(Input);
                v_debug ("É falso");
        }
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiThreshold	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

Função para efectuar a binarização.

Definido na linha 77 do ficheiro vapiOperationsDefault.c.

Referências _vImages::Actual e vapiOptionsGetInts().

Referenciado por vapiAvailableEfects() e vapiBinarizar().

{
        cvThreshold (Images->Actual, Images->Actual,
                     vapiOptionsGetInts (options, 0), 255, CV_THRESH_BINARY);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

---