src/vapiCameraAcquisition.c

Ir para a documentação deste ficheiro.

#include <stdio.h>
#include <cxcore.h>
#include <cv.h>
#include <highgui.h>
#include <cvaux.h>
#include "vapiCameraAcquisition.h"
#include "vapiAux.h"
#include "vapiImagesAux.h"
#include "vapiGtkAux.h"
#include "vapi.h"
#include "vapiTypes.h"
#include "vapiOperationsDefault.h"
#include "vapiCameraSettings.h"
#ifndef VAPI_WITHOUT_INTERFACE
#include "vapiGtkInterface.h"
#endif

static double NUMBER_OF_ACQUISITION_STEPS;

int
vapiGetSnapshotLocalCamera (vImages * Images,
                            vCameraSettings * CameraSettings)
{

        IplImage *frame;
        int camera;

        v_debug ("Inicio de Captura com Câmara Local ");

        camera = vapiCameraSettingsGetLocalCameraNumber (CameraSettings);

        if (camera == -2)
        {
                v_debug ("Saiu Com Erro ");

                return 1;
        }

        vapiCameraAcquisitionLoadingStatus ("A iniciar Câmara",
                                            (1.0 /
                                             NUMBER_OF_ACQUISITION_STEPS));

        if (CameraSettings->LocalCameraFirstCapture)
        {
                v_debug ("Primeira Captura");

                vapiCameraSettingsSetCapture (CameraSettings,
                                              cvCaptureFromCAM (camera));
        }


        if (!cvGrabFrame (vapiCameraSettingsGetCapture (CameraSettings)))
        {
                vapiCameraSettingsSetNoCapture (CameraSettings);
                return 1;
        }
        v_debug ("Vai descarregar a frame da Câmara");

        //Grab frame
        vapiCameraAcquisitionLoadingStatus ("A Descarregar a Frame",
                                            (1.0 /
                                             NUMBER_OF_ACQUISITION_STEPS));

        frame = cvRetrieveFrame (vapiCameraSettingsGetCapture
                                 (CameraSettings));
        v_debug ("já tem a frame");

        if (!frame)
        {
                vapiCameraSettingsSetNoCapture (CameraSettings);
                cvReleaseImage (&frame);
                return 1;
        }

        //Copy frame

        v_debug ("Tem a Frame, vai converter na imagem ");

        Images->Original = vapiImagesSameSize (frame, frame->nChannels);

        //check if frame is upside down
        if (frame->origin == IPL_ORIGIN_TL)
        {
                cvCopy (frame, Images->Original, NULL);
        }
        else
        {
                cvFlip (frame, Images->Original, 0);
        }
        //cvReleaseImage(&frame);

        return 0;



}

int
vapiGetSnapshotLocalFile (vImages * Images, vCameraSettings * CameraSettings)
{

        char *FileName;

        vapiCameraAcquisitionLoadingStatus ("A abrir o Ficheiro", (1.0 /
                                                                   NUMBER_OF_ACQUISITION_STEPS));

        FileName = vapiCameraSettingsGetLocalFilename (CameraSettings);
        if (FileName == NULL
            || !vapiFileIsReadable (CameraSettings->LocalFileName))
        {
                return 1;
        }
        Images->Original = cvLoadImage (FileName, 3);

        return 0;
}

int
vapiGetSnapshot (vImages * Images, vCameraSettings * CameraSettings)
{
        int CameraERROR = 1;
        extern vBoolean HaveAcquisitionLoadingProgress;
        extern double NUMBER_OF_ACQUISITION_STEPS;

        if (MainLoadDone && HaveAcquisitionLoadingProgress)
        {
                vapi_loading_progress_reset ();
        }

        switch (CameraSettings->CameraType)
        {
        case vCameraLocal:
        {
                NUMBER_OF_ACQUISITION_STEPS = 3;
                CameraERROR =
                        vapiGetSnapshotLocalCamera (Images, CameraSettings);
                break;
        }
        case vCameraLocalFile:
        {
                NUMBER_OF_ACQUISITION_STEPS = 2;
                CameraERROR =
                        vapiGetSnapshotLocalFile (Images, CameraSettings);

        }
        }
        if (CameraERROR)
        {
                NUMBER_OF_ACQUISITION_STEPS = 2;
                vapiCameraAcquisitionLoadingStatus
                        ("Erro a Carregar Imagem", 1.0 /
                         NUMBER_OF_ACQUISITION_STEPS);
                Images->Original =
                        cvLoadImage ("pixmaps/vapiErroDeCamara.png", 3);
        }

        vapiCameraAcquisitionLoadingStatus
                ("Captura Terminada", (1.0 / NUMBER_OF_ACQUISITION_STEPS));

        HaveAcquisitionLoadingProgress = vFALSE;

        return CameraERROR;
}


int
vapiGetHowManyCameras ()
{

        IplImage *frame;
        CvCapture *capture;
        int i = 0;

        for (;;)
        {

                //capture init
                capture = cvCaptureFromCAM (i);


                if (!cvGrabFrame (capture))
                {
                        cvReleaseCapture (&capture);
                        return i;
                }

                //Grab frame
                frame = cvRetrieveFrame (capture);

                if (!frame)
                {
                        cvReleaseCapture (&capture);
                        cvReleaseImage (&frame);
                        return i;
                }
                cvReleaseCapture (&capture);

                ++i;
        }
}


void
vapiCameraAcquisitionLoadingStatus (const char *Message, double steps)
{
        extern vBoolean MainLoadDone;
        extern vBoolean HaveAcquisitionLoadingProgress;

        if (MainLoadDone && HaveAcquisitionLoadingProgress)
        {
                vapi_loading_progress_step (Message, steps);
        }

        if (!MainLoadDone)
        {

                vapi_loading_progress_main_steps (Message, steps);
        }
}

---