Referência ao ficheiro src/vapiCameraAcquisition.c

#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"
#include "vapiGtkInterface.h"

Diagrama de dependências de inclusão para vapiCameraAcquisition.c:

Ir para o código fonte deste ficheiro.

Funções
void	vapiCameraAcquisitionLoadingStatus (const char *Message, double steps)
	Informs about the Progress of the image Acquisition.
int	vapiGetHowManyCameras ()
	Automatically check how many Cameras are available for the application.
int	vapiGetSnapshot (vImages *Images, vCameraSettings *CameraSettings)
	Get Snapshot from the source.
int	vapiGetSnapshotLocalCamera (vImages *Images, vCameraSettings *CameraSettings)
int	vapiGetSnapshotLocalFile (vImages *Images, vCameraSettings *CameraSettings)
Variáveis
static double	NUMBER_OF_ACQUISITION_STEPS

---

Documentação das funções

void vapiCameraAcquisitionLoadingStatus	(	const char *	Message,
		double	steps
	)

Informs about the Progress of the image Acquisition.

Parâmetros:

	Message	Description of the Action that is ocorring
	steps	Percentage in relation to all acuisition steps 1/(total of steps)

Definido na linha 204 do ficheiro vapiCameraAcquisition.c.

Referências HaveAcquisitionLoadingProgress, MainLoadDone, vapi_loading_progress_main_steps() e vapi_loading_progress_step().

Referenciado por vapiGetSnapshot(), vapiGetSnapshotLocalCamera() e vapiGetSnapshotLocalFile().

{
        extern vBoolean MainLoadDone;
        extern vBoolean HaveAcquisitionLoadingProgress;

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

        if (!MainLoadDone)
        {

                vapi_loading_progress_main_steps (Message, steps);
        }
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

int vapiGetHowManyCameras

(

)

Automatically check how many Cameras are available for the application.

Retorna:

the number of available cameras

Definido na linha 167 do ficheiro vapiCameraAcquisition.c.

{

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

int vapiGetSnapshot	(	vImages *	Images,
		vCameraSettings *	CameraSettings
	)

Get Snapshot from the source.

Parâmetros:

	Images	Destination Image Handler
	CameraSettings	The source Settings

Retorna:

Error code

Definido na linha 119 do ficheiro vapiCameraAcquisition.c.

Referências _vCameraSettings::CameraType, HaveAcquisitionLoadingProgress, MainLoadDone, NUMBER_OF_ACQUISITION_STEPS, _vImages::Original, vapi_loading_progress_reset(), vapiCameraAcquisitionLoadingStatus(), vapiGetSnapshotLocalCamera(), vapiGetSnapshotLocalFile(), vCameraLocal, vCameraLocalFile e vFALSE.

Referenciado por main(), vapiGtkCbLoadStaticImage(), vapiGtkSetOriginWindowTestSaveOrigin(), vapiOriginal() e vapiRefreshImage().

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

Grafo de chamadas desta função:

Here is the caller graph for this function:

int vapiGetSnapshotLocalCamera	(	vImages *	Images,
		vCameraSettings *	CameraSettings
	)

Definido na linha 21 do ficheiro vapiCameraAcquisition.c.

Referências _vCameraSettings::LocalCameraFirstCapture, NUMBER_OF_ACQUISITION_STEPS, _vImages::Original, v_debug, vapiCameraAcquisitionLoadingStatus(), vapiCameraSettingsGetCapture(), vapiCameraSettingsGetLocalCameraNumber(), vapiCameraSettingsSetCapture(), vapiCameraSettingsSetNoCapture() e vapiImagesSameSize().

Referenciado por vapiGetSnapshot().

{

        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;



}

Grafo de chamadas desta função:

Here is the caller graph for this function:

int vapiGetSnapshotLocalFile	(	vImages *	Images,
		vCameraSettings *	CameraSettings
	)

Definido na linha 99 do ficheiro vapiCameraAcquisition.c.

Referências _vCameraSettings::LocalFileName, NUMBER_OF_ACQUISITION_STEPS, _vImages::Original, vapiCameraAcquisitionLoadingStatus(), vapiCameraSettingsGetLocalFilename() e vapiFileIsReadable().

Referenciado por vapiGetSnapshot().

{

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

Grafo de chamadas desta função:

Here is the caller graph for this function:

---

Documentação das variáveis

double NUMBER_OF_ACQUISITION_STEPS [static]

Definido na linha 18 do ficheiro vapiCameraAcquisition.c.

Referenciado por vapiGetSnapshot(), vapiGetSnapshotLocalCamera() e vapiGetSnapshotLocalFile().

---