// Initialize camera input
bool CvCaptureCAM_MIL::open( int wIndex )
{
close();
if( g_Mil.MilApplication == M_NULL )
{
assert(g_Mil.MilUser == 0);
MappAlloc(M_DEFAULT, &(g_Mil.MilApplication) );
g_Mil.MilUser = 1;
}
else
{
assert(g_Mil.MilUser>0);
g_Mil.MilUser++;
}
int dev_table[16] = { M_DEV0, M_DEV1, M_DEV2, M_DEV3,
M_DEV4, M_DEV5, M_DEV6, M_DEV7,
M_DEV8, M_DEV9, M_DEV10, M_DEV11,
M_DEV12, M_DEV13, M_DEV14, M_DEV15 };
//set default window size
int w = 320;
int h = 240;
for( ; wIndex < 16; wIndex++ )
{
MsysAlloc( M_SYSTEM_SETUP, //we use default system,
//if this does not work
//try to define exact board
//e.g.M_SYSTEM_METEOR,M_SYSTEM_METEOR_II...
dev_table[wIndex],
M_DEFAULT,
&MilSystem );
if( MilSystem != M_NULL )
break;
}
if( MilSystem != M_NULL )
{
MdigAlloc(MilSystem,M_DEFAULT,
M_CAMERA_SETUP, //default. May be M_NTSC or other
M_DEFAULT,&MilDigitizer);
rgb_frame = cvCreateImage(cvSize(w,h), IPL_DEPTH_8U, 3 );
MdigControl(MilDigitizer, M_GRAB_SCALE, 1.0 / 2);
/*below line enables getting image vertical orientation
consistent with VFW but it introduces some image corruption
on MeteorII, so we left the image as is*/
//MdigControl(MilDigitizer, M_GRAB_DIRECTION_Y, M_REVERSE );
MilImage = MbufAllocColor(MilSystem, 3, w, h,
8+M_UNSIGNED, M_IMAGE + M_GRAB, M_NULL);
}
return MilSystem != M_NULL;
}
/*************************** configura_digitalizador *************************
Función para configurar el digitalizador para el formato de imagen que
se desea emplear en la adquisición.
*****************************************************************************/
int configura_digitalizador(int formato)
{
static bool bConfigurado = false;
// Compruebo si los digitalizadores son iguales. Si no son iguales
// libero el digitalizador antiguo, para reservarlo según las nuevas
// especificaciones.
if ( strcmp(paramAux->Cam.formatoDig, paramAux->Cam.formatoDig_e) || !bConfigurado)
{
// Si el digitalizador esta reservado, libero la memoria reservada, para
// poder configurarlo.
if ( M_digitalizador != M_NULL ) libera_digitalizador();
switch (formato) {
case FORMATO_NORMAL:
MdigAlloc (M_sistema, M_DEV0, paramAux->Cam.formatoDig, M_DEFAULT, &M_digitalizador);
break;
case FORMATO_ENFOQUE:
MdigAlloc (M_sistema, M_DEV0, paramAux->Cam.formatoDig_e, M_DEFAULT, &M_digitalizador);
break;
default:
error_fatal("configura_digitalizador", "Formato de digitalización inaceptable", 0);
return 1;
}
// Fijamos los parámetros de adquisición, según los datos leidos del fichero ini.
MdigControl(M_digitalizador, M_BRIGHTNESS, paramAux->Cam.brillo);
MdigControl(M_digitalizador, M_GAIN, paramAux->Cam.ganancia);
ModificaExposicion(paramAux->Rueda.exposicion[paramAux->Rueda.posFiltro]);
ModificaBaseExposicion(paramAux->Rueda.base_exp[paramAux->Rueda.posFiltro]);
}
if (paramAux->Cam.anchoImagen != paramAux->Cam.anchoImagen_e ||
paramAux->Cam.altoImagen != paramAux->Cam.altoImagen_e ||
!bConfigurado)
{
// Selecciono la configuración del digitalizador.
MdigControl(M_digitalizador, M_SOURCE_OFFSET_X, 0); // Necesario para evitar salirnos del cuadro
MdigControl(M_digitalizador, M_SOURCE_OFFSET_Y, 0); // al modificar el tamaño de la captura
switch (formato) {
case FORMATO_NORMAL:
MdigControl(M_digitalizador, M_SOURCE_SIZE_X, paramAux->Cam.anchoImagen);
MdigControl(M_digitalizador, M_SOURCE_OFFSET_X, (limCam.anchoDig - paramAux->Cam.anchoImagen) / 2);
MdigControl(M_digitalizador, M_SOURCE_SIZE_Y, paramAux->Cam.altoImagen);
MdigControl(M_digitalizador, M_SOURCE_OFFSET_Y, (limCam.altoDig - paramAux->Cam.altoImagen) / 2);
// ModificaExposicion(paramAux->Cam.exposicion[paramAux->Mtb.posFiltro]);
break;
case FORMATO_ENFOQUE:
MdigControl(M_digitalizador, M_SOURCE_SIZE_X, paramAux->Cam.anchoImagen_e);
MdigControl(M_digitalizador, M_SOURCE_OFFSET_X, (limCam.anchoDig_e - paramAux->Cam.anchoImagen_e) / 2);
MdigControl(M_digitalizador, M_SOURCE_SIZE_Y, paramAux->Cam.altoImagen_e);
MdigControl(M_digitalizador, M_SOURCE_OFFSET_Y, (limCam.altoDig_e - paramAux->Cam.altoImagen_e) / 2);
// ModificaExposicion(paramAux->Cam.exposicion[paramAux->Mtb.posFiltro]);
break;
}
}
// Nos aseguramos de que lo anterior sólo se ejecuta una vez si el formato y las dimensiones
// del digitalizador son iguales para adquisición normal y autoenfoque
bConfigurado = true;
return 0;
}
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
// validate the command string
if(nrhs < 1 || mxIsChar(prhs[0]) != 1 || mxGetM(prhs[0]) != 1) {
mexErrMsgTxt("Missing command string.");
}
// get the command
int cmdlen = mxGetN(prhs[0]) + 1;
char* command = (char*)mxCalloc(cmdlen, sizeof(char));
if(mxGetString(prhs[0], command, cmdlen) != 0) {
mexErrMsgTxt("Get command string failed.");
}
// startup
if(strcmp(command, "init") == 0) {
// set things up so a clear will also clean up
mexAtExit(cleanup);
if(nrhs > 1) {
if(!mxIsChar(prhs[1]) || mxGetM(prhs[1]) != 1) {
mexErrMsgTxt("init argument should be the name of a dcf file.");
}
int nmlen = mxGetN(prhs[1]) + 1;
char* dcfname = (char*)mxCalloc(nmlen, sizeof(char));
mxGetString(prhs[1], dcfname, nmlen);
MappAllocDefault(M_SETUP, &MilApplication, &MilSystem,
M_NULL, M_NULL, M_NULL);
if(MdigAlloc(MilSystem, M_DEV0, dcfname, M_DEFAULT, &MilDigitizer) == M_NULL) {
mexErrMsgTxt("init failed.");
}
} else {
/* Allocate defaults. */
MappAllocDefault(M_SETUP, &MilApplication, &MilSystem,
M_NULL, &MilDigitizer, M_NULL);
}
MBands = (int)MdigInquire(MilDigitizer, M_SIZE_BAND, M_NULL);
for(int i=0; i<MBands; i++)
band_is_selected[i] = true;
bands_selected = MBands;
MappTimer(M_TIMER_RESET, M_NULL);
grab_scale_x = grab_scale_y = 1;
MdigControl(MilDigitizer, M_GRAB_MODE, M_ASYNCHRONOUS);
MdigControl(MilDigitizer, M_GRAB_SCALE_X, grab_scale_x);
MdigControl(MilDigitizer, M_GRAB_SCALE_Y, grab_scale_y);
// wrapup
} else if(strcmp(command, "quit") == 0) {
cleanup();
// set the x and y scaling factor
} else if(strcmp(command, "setscale") == 0) {
// check the parameters
if(nrhs != 3 || !mxIsDouble(prhs[1]) || !mxIsDouble(prhs[2])) {
mexErrMsgTxt("setscale expects 2 arguments.");
}
grab_scale_x = mxGetScalar(prhs[1]);
grab_scale_y = mxGetScalar(prhs[2]);
MdigControl(MilDigitizer, M_GRAB_SCALE_X, grab_scale_x);
MdigControl(MilDigitizer, M_GRAB_SCALE_Y, grab_scale_y);
// select which bands to return for multiband sources
} else if(strcmp(command, "selectbands") == 0) {
// check to see if it's legal
if(MBands == 1) {
mexErrMsgTxt("selectbands only works for multiband sources.");
}
// check the argument
if(nrhs != 2 || !mxIsDouble(prhs[1]) || mxGetM(prhs[1]) != 1) {
mexErrMsgTxt("selectbands expects a row vector of band numbers.");
}
int nbands = mxGetN(prhs[1]);
if(nbands == 0 || nbands > MBands) {
mexErrMsgTxt("selectbands allows only 1 to 3 bands.");
}
double* bp = mxGetPr(prhs[1]);
for(int i=0; i<3; i++) {
band_is_selected[i] = false;
}
bands_selected = 0;
for(i=0; i<nbands; i++) {
int bnd = int(bp[i]);
if(bnd < 0 || bnd > 2) {
mexErrMsgTxt("selectbands allows bands numbered 0 to 2.");
}
if(!band_is_selected[bnd]) {
band_is_selected[bnd] = true;
bands_selected++;
}
}
// grab a sequence in one call
} else if(strcmp(command, "grabframes") == 0) {
// check the parameters
if(nrhs < 4 || !mxIsDouble(prhs[1]) || !mxIsDouble(prhs[2]) || !mxIsDouble(prhs[3])) {
mexErrMsgTxt("grabframes expects 3 or 4 arguments.");
}
int width = int(mxGetScalar(prhs[1]));
int height = int(mxGetScalar(prhs[2]));
int frames = int(mxGetScalar(prhs[3]));
// indicates whether this is a continuation of a previous grab
bool grab_continue = false;
if(nrhs == 5 && mxIsDouble(prhs[4]) && mxGetScalar(prhs[4]) > 0) {
grab_continue = true;
}
// space to record per frame times if requested
mxArray *time_array = 0;
double* time_data = 0;
if(nlhs > 1) {
time_array = mxCreateDoubleMatrix(frames, 1, mxREAL);
time_data = mxGetPr(time_array);
}
// allocate a matlab multidimensional array to return the image
int dims[4];
int ndims = 3;
dims[0] = height;
dims[1] = width;
if(bands_selected > 1) {
dims[2] = bands_selected;
dims[3] = frames;
ndims = 4;
} else {
dims[2] = frames;
}
mxArray *res = mxCreateNumericArray(ndims, dims, mxUINT8_CLASS, mxREAL);
int frameelements = width*height*MBands;
unsigned char* pmat = (unsigned char*)mxGetPr(res);
// free buffers if they are the wrong size
if(MilImageX != 0 && (width != MilImageX || height != MilImageY)) {
MdigGrabWait(MilDigitizer, M_GRAB_END);
for(int n=0; n<nmilbuff; n++) {
MbufFree(MilImage[n]);
}
MilImageX = MilImageY = 0;
}
// allocate a few MIL buffers if we don't already have them
if(MilImageX == 0) {
for (int n=0; n<nmilbuff; n++)
{
MbufAllocColor(MilSystem,
MBands,
width,
height,
8L+M_UNSIGNED,
M_IMAGE+M_GRAB, &MilImage[n]);
if (MilImage[n] == 0)
{
mexErrMsgTxt("MbufAllocColor failed.");
}
}
MilImageX = width;
MilImageY = height;
}
// grab the frames
if(!grab_continue) {
// if you're not continuing a previous grab, then you want a fresh first frame
MdigGrab(MilDigitizer, MilImage[MilImageNdx]);
}
for(int i = 0; i < frames; i++)
{
int ndx0 = MilImageNdx;
MilImageNdx = (MilImageNdx + 1) % nmilbuff;
MdigGrab(MilDigitizer, MilImage[MilImageNdx]);
if(time_array)
MappTimer(M_TIMER_READ, &time_data[i]);
// copy the completed buff to the matlab array
if(MBands == 1) { // easy
// get a pointer to the buffer
unsigned char* pmil;
MbufInquire(MilImage[ndx0], M_HOST_ADDRESS, &pmil);
if(pmil == M_NULL) {
mexErrMsgTxt("no access to mil buffer.");
}
// copy the pixels exchanging x and y coordinates to suit matlab
for(int y=0; y<height; y++) {
for(int x=0; x<width; x++) {
pmat[y+x*height] = pmil[x+y*width];
}
}
pmat += width*height;
} else { // harder
// I bet there is some smarter way to do this...
// for each band
for(int b=0; b<MBands; b++) {
if(band_is_selected[b]) {
// allocate a child buffer on the band.
MIL_ID child = MbufChildColor(MilImage[ndx0], b, M_NULL);
if(child == M_NULL) {
mexErrMsgTxt("no child");
}
// get a pointer to the child
unsigned char* pmil;
MbufInquire(child, M_HOST_ADDRESS, &pmil);
if(pmil == M_NULL) {
MbufFree(child);
mexErrMsgTxt("no access to mil buffer.");
}
// do the copy, twizzling the indicies around...
for(int y=0; y<height; y++) {
for(int x=0; x<width; x++) {
pmat[(y + x*height)] = pmil[x+y*width];
}
}
pmat += width*height;
// release the child
MbufFree(child);
}
}
}
}
plhs[0] = res;
if(time_array)
plhs[1] = time_array;
} else {
mexErrMsgTxt("Unknown command string.");
}
}
/* Main function. */
int MosMain(void)
{
MIL_ID MilApplication;
MIL_ID MilSystem;
MIL_ID MilDigitizer[2];
MIL_ID MilDisplay[2];
MIL_ID MilImageDisp[2];
/* Allocations. */
MappAlloc(M_DEFAULT, &MilApplication);
MsysAlloc(MIL_TEXT("M_DEFAULT"), M_DEFAULT, M_DEFAULT, &MilSystem);
MdigAlloc(MilSystem, M_DEV0, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDigitizer[0]);
MdigAlloc(MilSystem, M_DEV1, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDigitizer[1]);
MdispAlloc(MilSystem, M_DEFAULT, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDisplay[0]);
MdispAlloc(MilSystem, M_DEFAULT, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDisplay[1]);
/* Allocate 2 display buffers and clear them. */
MbufAlloc2d(MilSystem,
(MIL_INT)(MdigInquire(MilDigitizer[0], M_SIZE_X, M_NULL)*GRAB_SCALE),
(MIL_INT)(MdigInquire(MilDigitizer[0], M_SIZE_Y, M_NULL)*GRAB_SCALE),
8L+M_UNSIGNED,
M_IMAGE+M_GRAB+M_PROC+M_DISP, &MilImageDisp[0]);
MbufClear(MilImageDisp[0], 0x0);
MbufAlloc2d(MilSystem,
(MIL_INT)(MdigInquire(MilDigitizer[1], M_SIZE_X, M_NULL)*GRAB_SCALE),
(MIL_INT)(MdigInquire(MilDigitizer[1], M_SIZE_Y, M_NULL)*GRAB_SCALE),
8L+M_UNSIGNED,
M_IMAGE+M_GRAB+M_PROC+M_DISP, &MilImageDisp[1]);
MbufClear(MilImageDisp[1], 0x80);
/* Display the buffers. */
MdispSelect(MilDisplay[0], MilImageDisp[0]);
MdispSelect(MilDisplay[1], MilImageDisp[1]);
/* Grab continuously on displays at the specified scale. */
MdigControl(MilDigitizer[0], M_GRAB_SCALE, GRAB_SCALE);
MdigGrabContinuous(MilDigitizer[0],MilImageDisp[0]);
MdigControl(MilDigitizer[1], M_GRAB_SCALE, GRAB_SCALE);
MdigGrabContinuous(MilDigitizer[1],MilImageDisp[1]);
/* Print a message. */
MosPrintf(MIL_TEXT("Press <Enter> to stop continuous grab.\n"));
MosGetch();
/* Halt continuous grab. */
MdigHalt(MilDigitizer[0]);
MdigHalt(MilDigitizer[1]);
/* Print a message. */
MosPrintf(MIL_TEXT("Press <Enter> to end.\n"));
MosGetch();
/* Free allocations. */
MbufFree(MilImageDisp[0]);
MbufFree(MilImageDisp[1]);
MdispFree(MilDisplay[0]);
MdispFree(MilDisplay[1]);
MdigFree(MilDigitizer[0]);
MdigFree(MilDigitizer[1]);
MsysFree(MilSystem);
MappFree(MilApplication);
return 0;
}
/* -------------- */
int MosMain(void)
{
MIL_ID MilApplication;
MIL_ID MilSystem ;
MIL_ID MilDigitizer ;
MIL_ID MilDisplay ;
MIL_ID MilImageDisp ;
MIL_ID GrabBufferList[GRAB_BUFFER_NUMBER];
MIL_ID ProcSystemList[PROCESSING_SYSTEM_NUMBER];
MIL_ID SrcProcBufferList[BUFFER_NUMBER];
MIL_ID DstProcBufferList[BUFFER_NUMBER];
MIL_INT SizeX, SizeY, SizeBand;
MIL_TEXT_CHAR SystemDescriptor[SYSTEM_DESCRIPTOR_SIZE];
long NbSystem = 0, NbSystemToAllocate = PROCESSING_SYSTEM_NUMBER;
MIL_INT GrabFrameCount, n;
double SingleSystemProcessingRate, MultipleSystemProcessingRate;
ProcessingDataStruct ProcessingData;
/* Allocations and setup. */
/* ---------------------- */
/* MIL application allocation. */
MappAlloc(M_DEFAULT, &MilApplication);
/* Allocations on the default grab system. */
MsysAlloc(M_SYSTEM_DEFAULT, M_DEFAULT, M_DEFAULT, &MilSystem);
MdispAlloc(MilSystem, M_DEV0, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDisplay);
MdigAlloc(MilSystem, M_DEV0, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDigitizer);
/* Inquire the digitizer's size. */
SizeX = ProcessingData.SizeX = (MIL_INT)(MdigInquire(MilDigitizer, M_SIZE_X, M_NULL)*BUFFER_SCALE);
SizeY = ProcessingData.SizeY = (MIL_INT)(MdigInquire(MilDigitizer, M_SIZE_Y, M_NULL)*BUFFER_SCALE);
SizeBand = ProcessingData.SizeBand = (MIL_INT)(MdigInquire(MilDigitizer, M_SIZE_BAND, M_NULL));
/* Allocate a display buffer and clear it. */
MbufAllocColor(MilSystem, SizeBand, SizeX, SizeY, 8L+M_UNSIGNED, M_IMAGE+M_GRAB+M_DISP, &MilImageDisp);
MbufClear(MilImageDisp, 0x0);
/* Display the processing result if activated (might be the limiting factor for speed). */
if (DISPLAY_EACH_IMAGE_PROCESSED)
MdispSelect(MilDisplay, MilImageDisp);
/* Allocate the grab buffers. */
for (n=0; n< GRAB_BUFFER_NUMBER; n++)
MbufAllocColor(MilSystem, SizeBand, SizeX, SizeY, 8L+M_UNSIGNED, M_IMAGE+M_GRAB, &GrabBufferList[n]);
/* Allocate and order the required processing systems. */
if (USE_GRAB_SYSTEM_AS_ONE_PROCESSOR)
NbSystemToAllocate--;
for (n=0; n<NbSystemToAllocate; n++)
{
/* Create a system descriptor: (Protocol://Address/System (Ex: dmiltcp://127.0.0.1/M_SYSTEM_HOST)) */
MosSprintf(SystemDescriptor, SYSTEM_DESCRIPTOR_SIZE, MT("%s://%s/%s"),
DISTRIBUTED_MIL_PROTOCOL, SYSTEM_ADDRESSES[n], PROCESSING_SYSTEM_TYPE);
/* Allocate the system. */
MsysAlloc(SystemDescriptor, M_DEFAULT, M_DEFAULT, &ProcSystemList[n]);
/* Count the sucessfully allocated processing systems. */
if (ProcSystemList[n])
NbSystem++;
}
/* If the grab system is used to process, we add it at the end of the processing system list .
This permits to dispatch the job to the other remote systems before to use the grab system
itself to process synchronously.
*/
if (USE_GRAB_SYSTEM_AS_ONE_PROCESSOR)
{
ProcSystemList[NbSystem] = MilSystem;
NbSystem++;
}
/* Allocate and order the source and destination processing buffers alternating the target system. */
for (n=0; n<(NbSystem*BUFFER_PER_PROCESSOR); n++)
{
MbufAllocColor(ProcSystemList[n%NbSystem], SizeBand, SizeX, SizeY, 8L+M_UNSIGNED,
M_IMAGE+M_PROC, &SrcProcBufferList[n]);
MbufAllocColor(ProcSystemList[n%NbSystem], SizeBand, SizeX, SizeY, 8L+M_UNSIGNED,
M_IMAGE+M_PROC, &DstProcBufferList[n]);
}
/* Set the specified grab scale. */
MdigControl(MilDigitizer, M_GRAB_SCALE, BUFFER_SCALE);
/* Single system processing. */
/* ------------------------- */
/* Print a message. */
/* Print a message. */
MosPrintf(MIL_TEXT("\nDISTRIBUTED MIL PROCESSING:\n"));
MosPrintf(MIL_TEXT("---------------------------\n\n"));
MosPrintf(MIL_TEXT("1 System processing:\n"));
/* Initialize processing variables. */
ProcessingData.NbSystem = 1;
ProcessingData.ProcessEachImageOnAllSystems = M_NO;
ProcessingData.NbProc = 0;
ProcessingData.MilDigitizer = MilDigitizer;
ProcessingData.DispBuffer = MilImageDisp;
ProcessingData.SrcProcBufferListPtr = SrcProcBufferList;
ProcessingData.DstProcBufferListPtr = DstProcBufferList;
/* Start processing the buffers. */
MdigProcess(MilDigitizer, GrabBufferList, GRAB_BUFFER_NUMBER, M_START, M_DEFAULT,
ProcessingFunction, &ProcessingData);
/* Wait for a key and stop the processing. */
MosPrintf(MIL_TEXT("Press <Enter> to stop.\n\n"));
MosGetch();
MdigProcess(MilDigitizer, GrabBufferList, GRAB_BUFFER_NUMBER, M_STOP+M_WAIT, M_DEFAULT,
ProcessingFunction, &ProcessingData);
/* Print statistics. */
if (ProcessingData.NbProc != 0)
{
SingleSystemProcessingRate = ProcessingData.NbProc/ProcessingData.Time;
MdigInquire(MilDigitizer, M_PROCESS_FRAME_COUNT, &GrabFrameCount);
MosPrintf(MIL_TEXT("%ld Frames grabbed, %ld Frames processed at %.1f frames/sec (%.1f ms/frame).\n"),
GrabFrameCount, ProcessingData.NbProc, SingleSystemProcessingRate, 1000.0/SingleSystemProcessingRate);
}
else
MosPrintf(MIL_TEXT("No frame has been grabbed.\n"));
MosPrintf(MIL_TEXT("Press <Enter> to continue.\n\n"));
MosGetch();
/* Multiple systems processing. */
/* ---------------------------- */
/* Print a message. */
MosPrintf(MIL_TEXT("%ld Systems processing:\n"), NbSystem);
/* Halt continuous grab. */
MdigHalt(MilDigitizer);
/* Initialize processing variables. */
ProcessingData.NbSystem = NbSystem;
ProcessingData.ProcessEachImageOnAllSystems = PROCESS_EACH_IMAGE_ON_ALL_SYSTEMS;
ProcessingData.NbProc = 0;
ProcessingData.DispBuffer = MilImageDisp;
ProcessingData.SrcProcBufferListPtr = SrcProcBufferList;
ProcessingData.DstProcBufferListPtr = DstProcBufferList;
/* Start processing the buffers. */
MdigProcess(MilDigitizer, GrabBufferList, GRAB_BUFFER_NUMBER, M_START, M_DEFAULT,
ProcessingFunction, &ProcessingData);
/* Wait for a key and stop the processing. */
MosPrintf(MIL_TEXT("Press <Enter> to stop.\n\n"));
MosGetch();
MdigProcess(MilDigitizer, GrabBufferList, GRAB_BUFFER_NUMBER, M_STOP+M_WAIT, M_DEFAULT,
ProcessingFunction, &ProcessingData);
/* Print statistics. */
if (ProcessingData.NbProc != 0)
{
MultipleSystemProcessingRate = ProcessingData.NbProc/ProcessingData.Time;
MdigInquire(MilDigitizer, M_PROCESS_FRAME_COUNT, &GrabFrameCount);
MosPrintf(MIL_TEXT("%ld Frames grabbed, %ld Frames processed at %.1f frames/sec (%.1f ms/frame).\n\n"),
GrabFrameCount, ProcessingData.NbProc, MultipleSystemProcessingRate, 1000.0/MultipleSystemProcessingRate);
MosPrintf(MIL_TEXT("Speedup factor: %.1f.\n\n"),MultipleSystemProcessingRate/SingleSystemProcessingRate);
if (DISPLAY_EACH_IMAGE_PROCESSED && ((long)((MultipleSystemProcessingRate/SingleSystemProcessingRate)+0.1) < NbSystem))
MosPrintf(MIL_TEXT("Warning: Display might limit the processing speed. Disable it and retry.\n\n"));
}
else
MosPrintf(MIL_TEXT("No frame has been grabbed.\n"));
MosPrintf(MIL_TEXT("Press <Enter> to end.\n\n"));
MosGetch();
/* Free allocations. */
/* ----------------- */
for (n=0; n<GRAB_BUFFER_NUMBER; n++)
MbufFree(GrabBufferList[n]);
for (n=0; n<BUFFER_NUMBER; n++)
{
MbufFree(SrcProcBufferList[n]);
MbufFree(DstProcBufferList[n]);
}
if (USE_GRAB_SYSTEM_AS_ONE_PROCESSOR)
NbSystem--;
for (n=0; n<NbSystem; n++)
MsysFree(ProcSystemList[n]);
MbufFree(MilImageDisp);
MdispFree(MilDisplay);
MdigFree(MilDigitizer);
MsysFree(MilSystem);
MappFree(MilApplication);
return 0;
}
/*****************************************************************************
Modifica la exposicion
*****************************************************************************/
void ModificaExposicion(int exposicion)
{
MdigControl(M_digitalizador, M_SHUTTER,exposicion);
}
