MdispQtApp::~MdispQtApp()
{
//Free the digitizer [CALL TO MIL]
if(m_MilDigitizer)
MdigFree (m_MilDigitizer);
//Free the system [CALL TO MIL]
if(m_MilSystem)
MsysFree (m_MilSystem);
if(m_MilApplication)
{
// Enable MIL error message to be displayed as the usual way [CALL TO MIL]
MappControl(M_ERROR,M_PRINT_ENABLE);
// Unhook MIL error on function DisplayError() [CALL TO MIL]
if(m_isCurrentlyHookedOnErrors)
{
MappHookFunction(M_ERROR_CURRENT+M_UNHOOK,DisplayErrorExt,M_NULL);
m_isCurrentlyHookedOnErrors = false;
}
// Free the application [CALL TO MIL]
MappFree(m_MilApplication);
}
}
void CvCaptureCAM_MIL::close( CvCaptureCAM_MIL* capture )
{
if( MilSystem != M_NULL )
{
MdigFree( MilDigitizer );
MbufFree( MilImage );
MsysFree( MilSystem );
cvReleaseImage(&rgb_frame );
g_Mil.MilUser--;
if(!g_Mil.MilUser)
MappFree(g_Mil.MilApplication);
MilSystem = M_NULL;
MilDigitizer = M_NULL;
}
}
ControlImagenes::~ControlImagenes()
{
for (int i=0;i<MAX_NUM_IMAGENES;i++)
{
if (m_Milimagen[i] != M_NULL)
MbufFree(m_Milimagen[i]);
}
if (m_MilRGB != M_NULL)
MbufFree(m_MilRGB);
// CLASIFICACION
if(M_Clasificacion!=M_NULL)
MbufFree(M_Clasificacion);
if (m_bufClasificacionSelectiva != NULL)
delete [] m_bufClasificacionSelectiva;
MdispFree(m_Mildisplay);
//MsysFree(m_Milsistema);
MappFree(m_Milaplicacion);
}
void CamMatroxOrionHDManager::freeAPPandSystem()
{
#ifdef SUPPORT_ORION_HD
QMutex mutex;
mutex.lock();
m_camCounter--;
//qDebug()<< "CamMatroxOrionHDManager::freeAPPandSystem()::counter: " << m_camCounter;
if(m_camCounter==0)
{
MsysFree(m_milSystemID);
MappFree(m_milAppID);
m_milAppID = 0;
m_milSystemID = 0;
}
mutex.unlock();
#endif
}
bool MdispGtkApp::ExitInstance()
{
/////////////////////////////////////////////////////////////////////////
// MIL: Write your code that will be executed on application exit
/////////////////////////////////////////////////////////////////////////
//Free the digitizer [CALL TO MIL]
if(m_MilDigitizer)
MdigFree (m_MilDigitizer);
//Free the system [CALL TO MIL]
if(m_MilSystem)
MsysFree (m_MilSystem);
if(m_MilApplication)
{
// Enable MIL error message to be displayed as the usual way [CALL TO MIL]
MappControl(M_ERROR,M_PRINT_ENABLE);
// Unhook MIL error on function DisplayError() [CALL TO MIL]
if(m_isCurrentlyHookedOnErrors)
{
//MappHookFunction(M_ERROR_CURRENT+M_UNHOOK,DisplayErrorExt,pMdispGtkView);
m_isCurrentlyHookedOnErrors = false;
}
// Free the application [CALL TO MIL]
MappFree(m_MilApplication);
}
/////////////////////////////////////////////////////////////////////////
// MIL: Write your code that will be executed on application exit
/////////////////////////////////////////////////////////////////////////
return true;
}
/* 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 _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
// char *raiz_paramIni; // raiz del directorio del fichero inicial
int nRetCode = 0;
/*
// Compongo el nombre de log de la aplicación
sprintf(fichLog, "TomaUnica%s",EXT_LOG);
if ( (fich = fopen(fichLog, "wt")) == NULL ) {
sprintf(mensaje, "NO se puede crear el fichero: %s", fichLog);
error_fatal("TomaUnica.exe", mensaje, 0);
goto final;
}
fclose(fich);
*/
//Inicia MIL
MIL_ID Milaplicacion;
MappAlloc(M_DEFAULT, &Milaplicacion); // Selecciono la aplicación MIL.
if ( Milaplicacion == M_NULL ) {
AfxMessageBox("Error: No se pudo inicilizar MIL", MB_ICONERROR | MB_OK);
}
// Lectura de las variables de inicialización
// Tambien los parametros de correccion geometrica
// if (lee_param() < 0)
// goto final;
// Procesamos los argumentos de la línea de comandos
if (!procesa_argumentos(argc, argv))
{
MappFree(Milaplicacion);
exit(0);
}
// Nos aseguramos de que el ultimo caracter sea '\'
CString csUltimoCaracter = g_csDirectorioBarrido.Right(1);
if (csUltimoCaracter != "\\" && csUltimoCaracter != "/")
g_csDirectorioBarrido += _T("\\");
if (!LeerInfoBarrido(g_csDirectorioBarrido))
{
printf("Error: no se ha encontrado el fichero de informacion de barrido\n");
MappFree(Milaplicacion);
exit(0);
}
printf("\n+- COMPONER MOSAICO---------------------------------------");
printf("\n| Directorio: %s",g_csDirectorioBarrido);
if (g_nFilaInicio > 0)
{
printf("\n| Inicio: %d,%d Fin: %d,%d",g_nFilaInicio,g_nColumnaInicio,g_nFilaFin,g_nColumnaFin);
// Comprobaciones
if (g_nFilaFin > g_nCampos_y || g_nColumnaFin > g_nCampos_x)
{
printf("Error: Fin de mosaico fuera de limites (%d,%d)\n",g_nCampos_y, g_nCampos_x );
MappFree(Milaplicacion);
exit(0);
}
}
else
{
printf("\n| Completo (%d x %d)",g_nCampos_x, g_nCampos_y);
g_nFilaInicio = 1;
g_nColumnaInicio = 1;
g_nFilaFin = g_nCampos_y;
g_nColumnaFin = g_nCampos_x;
}
printf("\n+----------------------------------------------------------\n");
GenerarMosaicos();
/*
int tecla;
if (PideNombreToma(nombreToma))
{
} //PideNombre == true (no se ha pulsado ESC)
*/
MappFree(Milaplicacion);
return nRetCode;
}
int MosMain(void)
{
MIL_ID MilApplication, /* Application Identifier. */
MilSystem, /* System Identifier. */
MilDisplay, /* Display Identifier. */
MilImage; /* Image buffer Identifier. */
long ReturnValue; /* Return Value holder. */
MIL_DOUBLE SynchronousCallTime, /* Timer variable. */
AsynchronousCallTime; /* Timer variable. */
int n; /* Counter. */
/* Allocate application, system and display. */
MappAlloc(M_DEFAULT, &MilApplication);
MsysAlloc(SLAVE_SYSTEM_DESCRIPTOR, M_DEF_SYSTEM_NUM, M_SETUP, &MilSystem);
MdispAlloc(MilSystem, M_DEV0, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDisplay);
/* Restore source image into an automatically allocated image buffer. */
MbufRestore(IMAGE_FILE, MilSystem, &MilImage);
/* Uncomment to display the image. */
/* MdispSelect(MilDisplay, MilImage); */
/* Pause */
MosPrintf(MIL_TEXT("\nMIL DTK:\n"));
MosPrintf(MIL_TEXT("--------\n\n"));
MosPrintf(MIL_TEXT("Custom synchronous and asynchronous MIL functions:\n\n"));
MosPrintf(MIL_TEXT("This example times a synchronous and asynchronous custom function call.\n"));
MosPrintf(MIL_TEXT("Press a key to continue.\n\n"));
MosGetch();
/* Synchronous function call. */
/* -------------------------- */
/* Call the function a first time for more accurate timings later (dll load, ...). */
ReturnValue = SynchronousFunction(MilImage, MilImage, M_DEFAULT);
/* Start the timer */
MappTimer(M_TIMER_RESET+M_SYNCHRONOUS, M_NULL);
/* Loop many times for more precise timing. */
for (n= 0; n < NB_LOOP; n++)
{
/* Call the custom MIL synchronous function. */
ReturnValue = SynchronousFunction(MilImage, MilImage, M_DEFAULT);
}
/* Read the timer. */
MappTimer(M_TIMER_READ+M_SYNCHRONOUS, &SynchronousCallTime);
/* Print the synchronous call time. */
MosPrintf(MIL_TEXT("Synchronous function call time: %.1f us.\n"), SynchronousCallTime*1000000/NB_LOOP);
/* Asynchronous function call. */
/* --------------------------- */
/* Call the function a first time for more accurate timings later (dll load, ...). */
AsynchronousFunction(MilImage, MilImage, M_DEFAULT);
MthrWait(M_DEFAULT, M_THREAD_WAIT, M_NULL);
/* Start the timer */
MappTimer(M_TIMER_RESET+M_SYNCHRONOUS, M_NULL);
/* Loop many times for more precise timing. */
for (n= 0; n < NB_LOOP; n++)
{
/* Call the custom MIL asynchronous function. */
AsynchronousFunction(MilImage, MilImage, M_DEFAULT);
}
/* Read and print the time. */
MappTimer(M_TIMER_READ+M_SYNCHRONOUS, &AsynchronousCallTime);
/* Print the asynchronous call time. */
MosPrintf(MIL_TEXT("Asynchronous function call time: %.1f us.\n"), AsynchronousCallTime*1000000/NB_LOOP);
MosPrintf(MIL_TEXT("Press a key to terminate.\n\n"));
MosGetch();
/* Free all allocations. */
MbufFree(MilImage);
MdispFree(MilDisplay);
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;
}
