/************************** ini_TomaPatrones ****************************** Reserva de memoria para tomar una serie de imagenes promediadas. *****************************************************************************/ int ini_TomaPatrones(parametros *param) { int i; //Acumuladores for (i=0; i < param->nBandas; i++) { MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, PROFUNDIDAD_ACUMULACION+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC, &M_banda_acum[i]); MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, PROFUNDIDAD_ACUMULACION+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC, &M_banda_enmascarada_acum[i]); MbufClear(M_banda_acum[i], 0); MbufClear(M_banda_enmascarada_acum[i], 0); //Contador MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, 8+M_UNSIGNED, //necesario 32+M_FLOAT para realizar operaciones en coma flotante M_IMAGE+M_PROC, &M_cont_campos[i]); MbufClear(M_cont_campos[i], 0); } //Buffers auxiliares MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, 8+M_UNSIGNED, M_IMAGE+M_PROC, &M_mascara_aux); MbufClear(M_mascara_aux, 0); MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, PROFUNDIDAD_ACUMULACION+M_UNSIGNED, M_IMAGE+M_PROC+M_GRAB, &M_acum_aux); MbufClear(M_acum_aux, 0); return 0; }
/*************************** toma2_acumulada ********************************* Función para la adquisición de una imagen con menor ruido, mediante la acumulacion de un cierto número de tomas buf - buffer donde se devolvera la imagen acumulada nAcum - numero de veces a acumular La imagen acumulada es devuelta en M_imagen1 *****************************************************************************/ void toma2_acumulada(MIL_ID buf, int nAcum) { /* fin_toma(); // tomaContinua = false; if (nAcum == 1) //optimizado { MdigGrab (M_digitalizador, buf); } else { MbufClear(buf, nAcum / 2); // para conseguir que en la división final se produzca un redondeo. int n; for (n = 0; n < nAcum; ++n) { MdigGrab (M_digitalizador, M_imagen1); MimArith (M_imagen1, buf, buf, M_ADD); } } */ // para conseguir que en la división final se produzca un redondeo. if (nAcum != 1) MbufClear(buf, nAcum / 2); else MbufClear(buf, 0); fin_toma(); // tomaContinua = false; int n; for (n = 0; n < nAcum; ++n) { MdigGrab (M_digitalizador, M_imagen1); MimArith (M_imagen1, buf, buf, M_ADD); } }
bool MdispGtkView::newDoc() { // Set buffer attributes if(((MdispGtkApp*)dispGtkApp())->m_numberOfDigitizer) { m_bufferAttributes=M_IMAGE+M_DISP+M_GRAB+M_PROC; m_imageSizeX = ((MdispGtkApp*)dispGtkApp())->m_digitizerSizeX; m_imageSizeY = ((MdispGtkApp*)dispGtkApp())->m_digitizerSizeY; m_NbBands = ((MdispGtkApp*)dispGtkApp())->m_digitizerNbBands; // Allocate a buffer [CALL TO MIL] MbufAllocColor(((MdispGtkApp*)dispGtkApp())->m_MilSystem, m_NbBands, m_imageSizeX, m_imageSizeY, M_DEF_IMAGE_TYPE, m_bufferAttributes, &m_MilImage); // Clear the buffer [CALL TO MIL] MbufClear(m_MilImage,M_COLOR_BLACK); } else { //Import image in buffer [CALL TO MIL] MbufImport(IMAGE_FILE,M_DEFAULT,M_RESTORE,((MdispGtkApp*)dispGtkApp())->m_MilSystem,&m_MilImage); // Set SizeX and SizeY variable to the size of the buffer [CALL TO MIL] if (m_MilImage) { m_imageSizeX = MbufInquire(m_MilImage, M_SIZE_X, M_NULL); m_imageSizeY = MbufInquire(m_MilImage, M_SIZE_Y, M_NULL); m_NbBands = MbufInquire(m_MilImage, M_SIZE_BAND, M_NULL); } } UpdateContentSize(); // If not able to allocate a buffer, do not create a new document if(!m_MilImage) return false; Initialize(); return true; }
void ControlImagenes::EliminarTodas() { if (M_overlay_normal != M_NULL) { MbufClear(M_overlay_normal, TRANSPARENTE );// Relleno el buffer overlay con el color TRANSPARENTE M_overlay_normal = M_NULL; } MIL_ID selected; MdispInquire(m_Mildisplay,M_SELECTED,&selected); if (selected!=M_NULL) MdispDeselect(m_Mildisplay,selected); for (int i=0;i<MAX_NUM_IMAGENES;i++) { if (m_Milimagen[i] != M_NULL) { MbufFree(m_Milimagen[i]); m_Milimagen[i] = M_NULL; } } m_numImagenes = 0; //Liberamos RGB if (m_MilRGB != M_NULL) { MbufFree(m_MilRGB); m_MilRGB = M_NULL; } //Liberamos imagen identificacion if (M_Clasificacion != M_NULL) { MbufFree(M_Clasificacion); M_Clasificacion = M_NULL; } if (m_bufClasificacionSelectiva != NULL) { delete [] m_bufClasificacionSelectiva; m_bufClasificacionSelectiva = NULL; } theApp.clasificacion.Liberar(); }
// A partir de las imagenes guardadas en disco, genera la imagen mosaico void GenerarMosaicos() { char nombre_fich[512]; MIL_ID M_aux; MIL_ID M_mosaico; long lSizeX, lSizeY; //dimensiones imagen // Leer tamaño de primera imagen sprintf(nombre_fich, "%s%s_%03d_%03d_%02d%s", g_csDirectorioBarrido, g_csMuestra, g_nFilaInicio, g_nColumnaInicio, g_arrFiltros[0]+1, ".tif"); MbufDiskInquire(nombre_fich,M_SIZE_X, &lSizeX); MbufDiskInquire(nombre_fich,M_SIZE_Y, &lSizeY); MbufAlloc2d(M_DEFAULT_HOST, lSizeX, lSizeY, 8/*theApp.m_ParamIni.Cam.profundidad*/+M_UNSIGNED, M_IMAGE+M_PROC, &M_aux); MbufAlloc2d(M_DEFAULT_HOST, lSizeX * (g_nColumnaFin - g_nColumnaInicio + 1), lSizeY * (g_nFilaFin - g_nFilaInicio + 1), 8/*theApp.m_ParamIni.Cam.profundidad*/+M_UNSIGNED, M_IMAGE+M_PROC, &M_mosaico); for (int f=0; f < g_nBandas; f++) { MbufClear(M_mosaico,0); for (int i=g_nFilaInicio;i<=g_nFilaFin;i++) { printf("\rComponiendo mosaico filtro %d Fila %d ... ", g_arrFiltros[f], i); for (int j=g_nColumnaInicio;j<=g_nColumnaFin;j++) { sprintf(nombre_fich, "%s%s_%03d_%03d_%02d%s", g_csDirectorioBarrido, g_csMuestra, i, j, g_arrFiltros[f], ".tif"); //carga_imagen_campo8bit(nombre_fich, M_aux, theApp.m_ParamIni.Cam.profundidad); carga_imagen_campo_bits(nombre_fich, M_aux,8); MbufCopyClip(M_aux,M_mosaico,(j-g_nColumnaInicio)*lSizeX,(i-g_nFilaInicio)*lSizeY); } } printf("\rSalvando mosaico filtro %d ... ", g_arrFiltros[f]); sprintf(nombre_fich, "%s%s_%02d%s", g_csDirectorioBarrido, g_csMuestra, g_arrFiltros[f], ".tif"); graba_imagen_campo(nombre_fich, M_mosaico); } printf("\r \n"); MbufFree(M_aux); MbufFree(M_mosaico); }
/************************** perfiles ********************************* Función para iniciar el proceso de análisis, obteniendo las imágenes de disco. *****************************************************************************/ int perfiles(MIL_ID M_fb, parametros *param) { char mensaje[128]; int tecla, posX, posY; MIL_ID M_ancho, M_alto; posX = param->Cam.anchoImagen / 2; // Inicio en la posición central de la imagen posY = param->Cam.altoImagen / 2; M_ancho = MbufInquire(M_fb, M_SIZE_X, M_NULL); // Pregunto sobre el ancho y alto M_alto = MbufInquire(M_fb, M_SIZE_Y, M_NULL); // del buffer seleccionado. do { sprintf(mensaje, " - X: %ld. - Y: %ld. ", posX, posY); sendcont(mensaje); do { dibuja_linea_activa(M_overlay_normal, posX, posY, 0); Sleep(200); // Espera mientras no se pulse una tecla } while (!kbhit()); tecla = getKey(); switch (tecla) { case K_ESC: break; case K_LEFT: /* borro la anterior linea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 1); posX = posX - MOV_LENTO; posX = (posX < 0)? 0 : posX; posY = posY; /* Dibujo la nueva línea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 0); break; case K_RIGHT: /* borro la anterior linea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 1); posX = posX + MOV_LENTO; posX = (posX > M_ancho)? M_ancho : posX; posY = posY; /* Dibujo la nueva línea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 0); break; case K_UP: /* borro la anterior linea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 1); posX = posX; posY = posY - MOV_LENTO; posY = (posY < 0)? 0 : posY; /* Dibujo la nueva línea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 0); break; case K_DOWN: /* borro la anterior linea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 1); posX = posX; posY = posY + MOV_LENTO; posY = (posY > M_alto)? M_alto : posY; /* Dibujo la nueva línea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 0); break; case K_CR_LEFT: /* borro la anterior linea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 1); posX = posX - MOVIMIENTO; posX = (posX < 0)? 0 : posX; // Compruebo que no sobrepaso el límite. posY = posY; /* Dibujo la nueva línea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 0); break; case K_CR_RIGHT: /* borro la anterior linea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 1); posX = posX + MOVIMIENTO; posX = (posX > M_ancho)? M_ancho : posX; posY = posY; /* Dibujo la nueva línea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 0); break; case K_CR_UP: /* borro la anterior linea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 1); posX = posX; posY = posY - MOVIMIENTO; posY = (posY < 0)? 0 : posY; /* Dibujo la nueva línea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 0); break; case K_CR_DOWN: /* borro la anterior linea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 1); posX = posX; posY = posY + MOVIMIENTO; posY = (posY > M_alto)? M_alto : posY; /* Dibujo la nueva línea. */ dibuja_linea_activa(M_overlay_normal, posX, posY, 0); break; case 'H': case 'h': if ( calcula_valores_linea(M_imagen1, posX, posY, L_HORIZ) ) error_leve("perfiles", "No se puede mostrar el análisis solicitado"); break; case 'V': case 'v': calcula_valores_linea(M_imagen1, posX, posY, L_VERT); break; default : putch('\a'); } } while (tecla != K_ESC); MbufClear(M_overlay_normal, TRANSPARENTE); return 0; }
/* 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; }
// Calcula las imagenes monocromas para R, G y B segun los porcentajes dados, // reservando memoria y presentando la imagen RGB // Devuelve true si se ha realizado el calculo, false si no (porque ya se realizó antes) bool ControlImagenes::MostrarImagenRGB(int arrFiltroPorcentajesR[MAX_NUM_IMAGENES], int arrFiltroPorcentajesG[MAX_NUM_IMAGENES], int arrFiltroPorcentajesB[MAX_NUM_IMAGENES], CStatic& m_control, int nTotalR,int nTotalG,int nTotalB, bool bModificado) { MIL_ID selected; MdispInquire(m_Mildisplay,M_SELECTED,&selected); if (selected!=M_NULL) MdispDeselect(m_Mildisplay,selected); DisplayBits(8); //para que el display muestre las imagenes en profundidad 8 bit // Si es la primera vez, reservar la memoria de la imagen RGB if (m_MilRGB == M_NULL) MbufAllocColor(M_DEFAULT_HOST, 3, m_nAnchoImagen, m_nAltoImagen, 8+M_UNSIGNED, M_IMAGE+M_DISP, &m_MilRGB); //16 por si las imagenes estan en 16bit else if (!bModificado) { MdispSelectWindow(m_Mildisplay,m_MilRGB,m_control); return false; } unsigned short* pBuffImagen; //auxiliar para volcar cada imagen de cada filtro, 16 bit unsigned char* pRed; // auxiliar para calcular la banda de color (8 bit) unsigned char* pGreen; // auxiliar para calcular la banda de color (8 bit) unsigned char* pBlue; // auxiliar para calcular la banda de color (8 bit) pBuffImagen = (unsigned short*)calloc(m_nAnchoImagen*m_nAltoImagen, sizeof(unsigned short)); pRed = (unsigned char*)calloc(m_nAnchoImagen*m_nAltoImagen, sizeof(unsigned char)); pGreen = (unsigned char*)calloc(m_nAnchoImagen*m_nAltoImagen, sizeof(unsigned char)); pBlue = (unsigned char*)calloc(m_nAnchoImagen*m_nAltoImagen, sizeof(unsigned char)); for (int i= 0; i<MAX_NUM_IMAGENES;i++) { // Cargar buffers de filtros solo si se necesita en alguna de las bandas if (arrFiltroPorcentajesR[i] != 0 || arrFiltroPorcentajesG[i] != 0 || arrFiltroPorcentajesB[i] != 0) { MbufGet(m_Milimagen[i],pBuffImagen); //Acumular el pocentaje adecuado de este filtro en cada color if(arrFiltroPorcentajesR[i] != 0) { Acumular(pRed, pBuffImagen, ((double)arrFiltroPorcentajesR[i])/nTotalR, m_nAnchoImagen*m_nAltoImagen); } if(arrFiltroPorcentajesG[i] != 0) { Acumular(pGreen, pBuffImagen, ((double)arrFiltroPorcentajesG[i])/nTotalG, m_nAnchoImagen*m_nAltoImagen); } if(arrFiltroPorcentajesB[i] != 0) { Acumular(pBlue, pBuffImagen, ((double)arrFiltroPorcentajesB[i])/nTotalB, m_nAnchoImagen*m_nAltoImagen); } } } // Volcar el array auxiliar calculado al color correspondiente MbufPutColor(m_MilRGB,M_SINGLE_BAND,M_BLUE/*2*/,pBlue); MbufPutColor(m_MilRGB,M_SINGLE_BAND,M_GREEN/*1*/,pGreen); MbufPutColor(m_MilRGB,M_SINGLE_BAND,M_RED/*0*/,pRed); free(pBuffImagen); free(pBlue); free(pGreen); free(pRed); // Mostar la imagen en color MdispSelectWindow(m_Mildisplay,m_MilRGB,m_control); // Inicializar Overlay la primera vez que se carga una imagen // Esto se hace aqui porque no funciona si no hay un buffer asociado con el display // ha de usarse la variable global M_overlay_normal para que funcionen las funciones graficas // y porque puede ser que no se haya hecho al cargar las imagenes pancromaticas (en el caso // de que la primera imagen mostrada sea la pancromatica, ver CAnalisisDlg::AbrirTodas y CargarImagen) if (M_overlay_normal==NULL) { MdispInquire(m_Mildisplay, M_OVERLAY_ID, &M_overlay_normal); // Relleno el buffer overlay con el color TRANSPARENTE MbufClear(M_overlay_normal, TRANSPARENTE ); } return true; }