src/vapiOperationsDefault.c

Ir para a documentação deste ficheiro.

#include <cv.h>
#include <cxcore.h>
#include <highgui.h>
#include <stdio.h>
#include "vapiTypes.h"
#include "vapiAux.h"
#include "vapiString.h"
#include "vapiImages.h"
#include "vapiImagesAux.h"
#include "vapiOptions.h"
#include "vapi.h"
#include "vapiCameraAcquisition.h"
#include "vapiOperationsDefault.h"
#include "vapiGtkMemory.h"
#include "vapiResult.h"
#include "vapiOperationOptions.h"
#include "vapiCameraAcquisition.h"
#include "vapiCameraSettings.h"
#include "vapiIOCom.h"
#ifndef VAPI_OS_LINUX
#include <process.h>
#include <stdlib.h>
#else
#include <unistd.h>
#endif
#ifndef VAPI_WITHOUT_INTERFACE
#include "vapiGtkAuxWindow.h"
#endif

void
vapiApplyOperation (vImages * Images, vEffect * Operation,
                    vOptions * Options, vMacroResult * PreviousResult)
{
        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);
        }


}

void
vapiThreshold (vImages * Images, vOptions * options,
               vMacroResult * PreviousResult)
{
        cvThreshold (Images->Actual, Images->Actual,
                     vapiOptionsGetInts (options, 0), 255, CV_THRESH_BINARY);
}

void
vapiGrayscale (vImages * Images, vOptions * options,
               vMacroResult * PreviousResult)
{
        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);
}

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

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

        vapiThreshold (Images, options, NULL);

}

void
vapiSmooth (vImages * Images, vOptions * options,
            vMacroResult * PreviousResult)
{
        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);
}

void
vapiFlip (vImages * Images, vOptions * options, vMacroResult * PreviousResult)
{
        IplImage *tempImage;

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

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

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

        cvReleaseImage (&tempImage);


}

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

        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);

}

void
vapiLaplace (vImages * Images, vOptions * options,
             vMacroResult * PreviousResult)
{
        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);


}

void
vapiCanny (vImages * Images, vOptions * options,
           vMacroResult * PreviousResult)
{
        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);

}


/*
 * Erosão
 */
void
vapiErode (vImages * Images, vOptions * options,
           vMacroResult * PreviousResult)
{
        if (!vapiImagesCheckChannels (Images, 1))
        {
                return;
        }

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

}

/*
 * Dilatação
 */
void
vapiDilate (vImages * Images, vOptions * options,
            vMacroResult * PreviousResult)
{
        if (!vapiImagesCheckChannels (Images, 1))
                return;

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

}

void
vapiColourFilter (vImages * Images, vOptions * options,
                  vMacroResult * PreviousResult)
{
        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);
}

void
vapiGeometricCenter (vImages * Images, vOptions * options,
                     vMacroResult * PreviousResult)
{
        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);
}

/*
 * Função para detectar a existência de objectos.
 */
void
vapiObjectExists (vImages * Images, vOptions * options,
                  vMacroResult * PreviousResult)
{
        if (!vapiImagesCheckChannels (Images, 1))
        {
                return;
        }

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

void
vapiJumpToConditional (vImages * Images, vOptions * options,
                       vMacroResult * PreviousResult)
{
        if (vapiResultGetDecision (PreviousResult))
        {
                vapiResultSetJumpTo (PreviousResult,
                                     vapiOptionsGetInts (options, 0));
        }
        else
        {
                vapiResultSetJumpTo (PreviousResult,
                                     vapiOptionsGetInts (options, 1));
        }
}
void
vapiEndExecution (vImages * Images, vOptions * options,
                  vMacroResult * PreviousResult)
{
        vapiResultSetEnd (PreviousResult);

}

void
vapiCountObjects (vImages * Images, vOptions * options,
                  vMacroResult * PreviousResult)
{
        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);
}

void
vapiMarkPoints (vImages * Images, vOptions * options,
                vMacroResult * PreviousResult)
{
        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);

        }
}

void
vapiCompareInt (vImages * Images, vOptions * options,
                vMacroResult * PreviousResult)
{
        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;
        }
        }
}
void
vapiCompareFloat (vImages * Images, vOptions * options,
                  vMacroResult * PreviousResult)
{
        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;
        }
        }
}

void
vapiTemplateMatch (vImages * Images, vOptions * options,
                   vMacroResult * PreviousResult)
{
        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);
}

void
vapiOCR (vImages * Images, vOptions * options, vMacroResult * PreviousResult)
{
        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");

}

void
vapiSelectRegion (vImages * Images, vOptions * options,
                  vMacroResult * PreviousResult)
{
        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);
}

void
vapiEraseIsolatedPixels (vImages * Images, vOptions * options,
                         vMacroResult * PreviousResult)
{
        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);


}

void
vapiNot (vImages * Images, vOptions * options, vMacroResult * PreviousResult)
{
        IplImage *finalImage;
        if (!vapiImagesCheckChannels (Images, 1))
        {
                return;
        }

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

        cvNot (Images->Actual, finalImage);

        vapiImagesSetActual (Images, finalImage);


}

void
vapiResultResetPoints (vImages * Images, vOptions * options,
                       vMacroResult * PreviousResult)
{
        vResultResetPoints (PreviousResult);
}

void
vapiResultResetInts (vImages * Images, vOptions * options,
                     vMacroResult * PreviousResult)
{
        vResultResetInts (PreviousResult);
}

void
vapiTeste (vImages * Images, vOptions * options,
           vMacroResult * PreviousResult)
{
        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");
        }
}

---