src/vapiImagesAux.c

Ir para a documentação deste ficheiro.

#include <cxcore.h>
#include <highgui.h>
#include <stdio.h>
#include "vapiTypes.h"
#include "vapiImages.h"
#include "vapiImagesAux.h"


void
vapiOriginal2Actual (vImages * Images)
{
        Images->Actual =vapiImagesCopy(Images->Original);
}

IplImage *
vapiImagesSameSize (IplImage * src, int n_channels)
{
        IplImage *dst;

        if (n_channels == 0)
                n_channels = src->nChannels;

        dst = cvCreateImage (cvSize (src->width,
                                     src->height), IPL_DEPTH_8U, n_channels);
        /*
         * por forma a não ter imagens vazias que causam problemas.
         */
        cvZero (dst);
        return dst;
}

IplImage *
vapiImagesSameSize16 (IplImage * src, int n_channels)
{
        IplImage *dst;

        if (n_channels == 0)
        {
                n_channels = src->nChannels;
        }

        dst = cvCreateImage (cvSize (src->width,
                                     src->height), IPL_DEPTH_16S, n_channels);
        /*
         * por forma a não ter imagens vazias que causam problemas.
         */
        cvZero (dst);
        return (IplImage *) dst;
}

int
vapiImagesCheckChannels (vImages * Images, int nChannels)
{
        if (Images->Actual->nChannels != nChannels)
                return 0;
        else
        {
                return 1;
        }
}

void
vapiImagesDrawCross (IplImage * src, int line, int column, int lenght,
                     int thick, int *color)
{
        cvLine (src, cvPoint (column - lenght, line),
                cvPoint (column + lenght, line), CV_RGB (color[0], color[1],
                                                         color[2]), thick, 1,
                0);
        cvLine (src, cvPoint (column, line - lenght),
                cvPoint (column, line + lenght), CV_RGB (color[0], color[1],
                                                         color[2]), thick, 1,
                0);
}

void
vapiImagesPrint (IplImage * src, double level)
{

        int line, column;
        CvScalar a;
        for (line = 0; line < src->height; line++)
                for (column = 0; column < src->height; column++)
                {
                        a = cvGet2D (src, line, column);
                        if (a.val[0] > level)
                                v_info (" valor %d - %d : %G \n", line,
                                        column, a.val[0]);
                }

}

IplImage *
vapiImagesEnlarge (IplImage * src, int enlarge)
{
        IplImage *dst;
        int n_channels;

        n_channels = src->nChannels;

        dst = cvCreateImage (cvSize (src->width + enlarge,
                                     src->height + enlarge), IPL_DEPTH_8U,
                             n_channels);

        return dst;


}


void
vapiImagesShow (const char *title, IplImage * image)
{
        cvNamedWindow (title, CV_WINDOW_AUTOSIZE);
        cvShowImage (title, image);
}

IplImage *
vapiImagesCopy(IplImage * src)
{
        IplImage * tempImage;
        tempImage=vapiImagesSameSize(src, src->nChannels);
        cvCopy(src, tempImage, NULL);
        
        return tempImage;
        
}

vImages *
vapiImagesAuxCloneImages(vImages * src)
{
        vImages * Images= vImagesInit();
        
        Images->Original = vapiImagesCopy(src->Original);
        Images->Actual = vapiImagesCopy(src->Actual);
        return Images;
}

---