// 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;
}
/* 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;
}
ControlImagenes::ControlImagenes()
{
//Inicilizacion
// m_Milsistema = M_NULL;
m_Milaplicacion = M_NULL;
m_Mildisplay = M_NULL;
m_Miloverlay = M_NULL;
m_lut_overlay = M_NULL;
m_numImagenes = 0;
m_nAnchoImagen = -1;
m_nAltoImagen = -1;
for (int i=0;i<MAX_NUM_IMAGENES;i++)
m_Milimagen[i] = M_NULL;
m_MilRGB = M_NULL;
M_Clasificacion = M_NULL;
m_bufClasificacionSelectiva = NULL;
m_bDefiniendoArea = false;
m_bPintandoRect = false;
MappAlloc(M_DEFAULT, &m_Milaplicacion); // Selecciono la aplicación MIL.
if ( m_Milaplicacion == M_NULL ) {
AfxMessageBox("Error: No se pudo inicilizar MIL", MB_ICONERROR | MB_OK);
}
// Pregunto al sistema la versión de la librería de control de proceso de imagen
//MappInquire(M_VERSION, &m_Milversion);
// pruebas MIL 8
// MsysAlloc(M_SYSTEM_METEOR_II_1394, M_DEV0, M_DEFAULT, &M_sistema); // Selecciono un sistema hardware
// if ( M_sistema == M_NULL ) {
// AfxMessageBox("Error: No se pudo inicilizar MIL", MB_ICONERROR | MB_OK);
// }
// Display normal para las imágenes adquiridas y procesadas.
MdispAlloc(M_DEFAULT_HOST, M_DEFAULT, "M_DEFAULT", M_WINDOWED + M_GDI_OVERLAY, &m_Mildisplay);
if ( m_Mildisplay == M_NULL ) {
AfxMessageBox("Error: No se pudo inicilizar MIL", MB_ICONERROR | MB_OK);
}
// El texto tiene color de fondo transparente
MgraControl(M_DEFAULT, M_BACKGROUND_MODE, M_TRANSPARENT);
// OVERLAY (diferente para MIL 8 y anteriores
if (M_MIL_CURRENT_VERSION >= 8.0)
{
// Inicializar colores para pintar areas
m_listaColor[NEGRO_POS] = M_RGB888(NEGRO_R,NEGRO_G,NEGRO_B);
m_listaColor[MARRON_POS] = M_RGB888(MARRON_R,MARRON_G,MARRON_B);
m_listaColor[ROJO_POS] = M_RGB888(ROJO_R,ROJO_G,ROJO_B);
m_listaColor[CYAN_POS] = M_RGB888(CYAN_R,CYAN_G,CYAN_B);
m_listaColor[NARANJA_POS] = M_RGB888(NARANJA_R,NARANJA_G,NARANJA_B);
m_listaColor[VERDE_POS] = M_RGB888(VERDE_R,VERDE_G,VERDE_B);
m_listaColor[AZUL_POS] = M_RGB888(AZUL_R,AZUL_G,AZUL_B);
m_listaColor[MORADO_POS] = M_RGB888(MORADO_R,MORADO_G,MORADO_B);
m_listaColor[GRIS_POS] = M_RGB888(GRIS_R,GRIS_G,GRIS_B);
m_listaColor[ORO_POS] = M_RGB888(ORO_R,ORO_G,ORO_B);
m_listaColor[ROSA_POS] = M_RGB888(ROSA_R,ROSA_G,ROSA_B);
MdispControl(m_Mildisplay, M_OVERLAY, M_ENABLE);
// Establezco TRANSPARENTE como color transparente
MdispControl(m_Mildisplay, M_TRANSPARENT_COLOR, TRANSPARENTE);
//Tipo de interpolacion para el redimensionamiento de la imagen en el display
//Si se activa en MIL 8, quedan lineas de color transparernte en el overlay cuando el zoom no es 1
//MdispControl(m_Mildisplay, M_INTERPOLATION_MODE, M_NEAREST_NEIGHBOR);
}
else
{
// Inicializar colores para pintar areas
m_listaColor[0] = NEGRO ;
m_listaColor[1] = ROJO_OSC ;
m_listaColor[2] = ROJO ;
m_listaColor[3] = CYAN ;
m_listaColor[4] = AMARILLO;
m_listaColor[5] = VERDE ;
m_listaColor[6] = AZUL ;
m_listaColor[7] = MAGENTA_OSC ;
m_listaColor[8] = GRIS ;
m_listaColor[9] = AMARILLO_OSC ;
m_listaColor[10] = GRIS_CLA ;
// LUT
MbufAllocColor(M_DEFAULT_HOST, 3L, 256L, 1L, 8L+M_UNSIGNED, M_LUT, &m_lut_overlay);
if ( m_lut_overlay == M_NULL) {
AfxMessageBox("Error: No se pudo inicilizar MIL", MB_ICONERROR | MB_OK);
}
crea_LUT_overlay(m_lut_overlay, 0); // Genera LUT color y corrección de gamma
configura_overlay(m_Mildisplay, M_NULL, &m_Miloverlay, 1); // repartido entre aqui y CargarImagen // M_NULL, antes ponia M_imagen1 que ya no esta disponible en Analisis, seguramente falle
// Asocio la LUT de pseudo-color al display de overlay
MdispControl(m_Mildisplay, M_OVERLAY_LUT, m_lut_overlay);
// Modifico la configuración del display: m_Mildisplay_normal.
// - Deshabilito el menú de tareas.
// - Deshabilito la barra del título.
// - Fijo la posición de la ventana en 0,0.
MdispControl(m_Mildisplay, M_WINDOW_MENU_BAR, M_DISABLE);
MdispControl(m_Mildisplay, M_WINDOW_TITLE_BAR, M_DISABLE);
MdispControl(m_Mildisplay, M_WINDOW_INITIAL_POSITION_X, 0 );
MdispControl(m_Mildisplay, M_WINDOW_INITIAL_POSITION_Y, 0 );
// Establezco TRANSPARENTE como color transparente
MdispOverlayKey(m_Mildisplay, M_KEY_ON_COLOR, M_EQUAL, 0xff, TRANSPARENTE);
}
// Bitmap de fondo para poner siempre que no haya mas imagenes
BYTE bBits[] = {0xd8,0xe9,0xec};
m_backgound_bitmap.CreateBitmap(1,1,1,32,bBits);
}
