/************************** 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; }
// 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); }
// Se reserva memoria, se carga y se presenta la imagen "nomFich" // Se presupone que no hay otra imagen cargada con el mismo numero de filtro ("numFiltro") // m_control es el control al dialogo // bMostrar indica si debe de mostrarse la imagen en pantalla o solo cargar la imagen en memoria // Se inicializa M_overlay_normal // Se deja el zoom a 0.5 bool ControlImagenes::CargarImagen(char* nomFich, CStatic& m_control, int numFiltro, bool bMostrar) { // Comprobaciones struct stat stFileInfo; if (stat(nomFich,&stFileInfo) != 0) return false; if (m_Milimagen[numFiltro-1] != NULL) return false; long lSizeX, lSizeY; MbufDiskInquire(nomFich,M_SIZE_X, &lSizeX); MbufDiskInquire(nomFich,M_SIZE_Y, &lSizeY); MbufAlloc2d(M_DEFAULT_HOST, lSizeX,lSizeY, 16 + M_UNSIGNED, M_IMAGE + M_DISP + M_PROC, &m_Milimagen[numFiltro-1]); if (MbufImport(nomFich,M_TIFF,M_LOAD,M_NULL,&m_Milimagen[numFiltro-1]) == M_NULL) // if (MbufImport(nomFich,M_TIFF,M_RESTORE,M_DEFAULT_HOST,&m_Milimagen[numFiltro-1]) == M_NULL) return false; if (m_Milimagen[numFiltro-1] == NULL) return false; m_numImagenes++; if (bMostrar) { MdispSelectWindow(m_Mildisplay,m_Milimagen[numFiltro-1],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 if (M_overlay_normal == M_NULL) { MdispInquire(m_Mildisplay, M_OVERLAY_ID, &M_overlay_normal); // Relleno el buffer overlay con el color TRANSPARENTE // MbufClear(M_overlay_normal, TRANSPARENTE ); } // TRUCO para evitar que los rectangulos se pinten con un reborde negro. Pero la carga de imagenes es mas lenta // Se deja el zoom a 0.5 // Los rectangulos se pintan con un reborde negro cuando el zoom esta entre 0.5 y 1 en MIL 8 // por razones desconocidas. Este truco funciona, pero tampoco se sabe porque // MdispZoom(m_Mildisplay, 0.5, 0.5); //En la funcion llamante, se debe actualizar correctamente el zoom } // Solo una vez cada vez que se cargan todas las imagenes if (numFiltro == 2) { // Recuperamos las dimensiones de la imagen MbufInquire(m_Milimagen[1],M_SIZE_X,&m_nAnchoImagen); MbufInquire(m_Milimagen[1],M_SIZE_Y,&m_nAltoImagen); } return true; }
/************************** graba_imagen_campo **************************** Función para efectuar la grabación en disco de una imagen del campo. "nombre" es el nombre del archivo a almacenar. "buffer" es el buffer que quiero copiar a disco. Se espera que este buffer este en 8 o 16 bits reales (dependiendo de la profundidad de la camara) nBits - profundidad en bits en que se grabará la imagen (8,12,16) ****************************************************************************/ int graba_imagen_campo_bits(parametros& param, char *nombre, MIL_ID buffer, int nBits, double dEscala) { int res = 0; if (param.Cam.profundidad == 16 && (nBits == 8 || nBits == 12)) { MIL_ID M_buf16; long altoImagen,anchoImagen; MbufInquire(buffer, M_SIZE_X, &anchoImagen); MbufInquire(buffer, M_SIZE_Y, &altoImagen); MbufAlloc2d(M_sistema, anchoImagen, altoImagen, 16+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC, &M_buf16 ); if (nBits == 8) { MIL_ID M_buf8; MbufAlloc2d(M_sistema, anchoImagen, altoImagen, 8+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC, &M_buf8 ); MimShift(buffer,M_buf16,-8);//conversion a 8 bit MbufCopy(M_buf16, M_buf8); // MimShift(buffer,buffer,4);//conversion a 12 bit. Para que luego los histogramas funcionen correctamente res = graba_imagen_campo(nombre,M_buf8, nBits, dEscala); MbufFree(M_buf8); } else //nBits==12 { MimShift(buffer,M_buf16,-4);//conversion a 12 bit res = graba_imagen_campo(nombre,M_buf16, nBits, dEscala); } MbufFree(M_buf16); } else //Grabar tal cual (imagen origen esta en 8 bit o esta en 16 bit y se quiere dejar en 16 bit) { res = graba_imagen_campo(nombre,buffer, nBits, dEscala); } return res; }
/*************************** ini_control_digitalizador ********************* Función para reservar memoria para los diferentes formatos de digitalizadores que se utilizarán en la toma de imágenes. Previamente, se comprueba que los parámetros iniciales son válidos para el formato y tipo de digitalizador reservado. Seguidamente se reserva el display y los buffers que se utilizan en el proceso de adquisición de imágenes. *****************************************************************************/ int ini_control_digitalizador(parametros *param) { char *fn = "ini_control_digitalizador - "; int i; paramAux = param; //para usar en otras funciones // SI DEFINO UN TAMAÑO DE DIGITALIZADOR DE ENFOQUE... (DIGITALIZADOR) // Reservo memoria para un nuevo display en el que se mostrarán los campos // recorridos y los que se han podido enfocar. if (param->Cam.formatoDig_e[0] != '\0' && strcmp(param->Cam.formatoDig, param->Cam.formatoDig_e) ) { // Configuro el digitalizador en formato enfoque if (M_digitalizador != M_NULL) libera_digitalizador(); if ( MdigAlloc (M_sistema, M_DEV0, param->Cam.formatoDig_e, M_DEFAULT, &M_digitalizador) == M_NULL ) { error_fatal("ini_control_digitalizador", "Formato incorrecto", 0); #if !defined (__BORLANDC__) putch('\a'); #endif return 1; } MdigInquire(M_digitalizador, M_SIZE_X, &limCam.anchoDig_e); if ( limCam.anchoDig_e > MAX_ANCHO_IMAGEN || limCam.anchoDig_e < param->Cam.anchoImagen_e ) { error_fatal(fn, "Error en los parámetros iniciales", 0); #if !defined (__BORLANDC__) putch('\a'); #endif return 1; } MdigInquire(M_digitalizador, M_SIZE_Y, &limCam.altoDig_e); if ( limCam.altoDig_e > MAX_ALTO_IMAGEN || limCam.altoDig_e < param->Cam.altoImagen_e ) { error_fatal(fn, "Error en los parámetros iniciales", 0); #if !defined (__BORLANDC__) putch('\a'); #endif return 1; } } // Configuro el digitalizador en formato normal. if (M_digitalizador != M_NULL) libera_digitalizador(); if ( MdigAlloc (M_sistema, M_DEV0, param->Cam.formatoDig, M_DEFAULT, &M_digitalizador) == M_NULL ) { error_fatal("ini_control_proceso_imagenes", "Formato incorrecto", 0); return 1; } MdigInquire(M_digitalizador, M_SIZE_X, &limCam.anchoDig); if ( limCam.anchoDig > MAX_ANCHO_IMAGEN || limCam.anchoDig < param->Cam.anchoImagen ) { error_fatal(fn, "Error en los parámetros iniciales", 0); #if !defined (__BORLANDC__) putch('\a'); #endif return 1; } MdigInquire(M_digitalizador, M_SIZE_Y, &limCam.altoDig); if ( limCam.altoDig > MAX_ALTO_IMAGEN || limCam.altoDig < param->Cam.altoImagen ) { error_fatal(fn, "Error en los parámetros iniciales", 0); #if !defined (__BORLANDC__) putch('\a'); #endif return 1; } // Si el formato del digitalizador de enfoque es el mismo que el de // captura normal, copiamos las dimensiones porque no se leyeron. if ( strcmp(param->Cam.formatoDig, param->Cam.formatoDig_e) == 0 ) { limCam.anchoDig_e = limCam.anchoDig; limCam.altoDig_e = limCam.altoDig; } // Compruebo los valores iniciales de brillo, ganancia y exposición. if ( info_digitalizador(M_digitalizador) ) { error_fatal(fn, "Error en los parámetros iniciales", 0); return 1; } // Se centra la camara en el caso de que se haya configurado un tamaño de toma diferente al maximo de la camara if ( configura_digitalizador(FORMATO_NORMAL) ) return 1; // Buffer auxiliar de PROFUNDIDAD_ACUMULACION bits para acumular valores. MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, PROFUNDIDAD_ACUMULACION+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC+M_GRAB, &M_imagen_acum); if ( M_imagen_acum == M_NULL ) { error_fatal(fn, "M_imagen_acum", 0); return 1; } // Obtenemos la profundidad de la camara MdigInquire(M_digitalizador, M_SIZE_BIT , ¶m->Cam.profundidad); if ( (BITS_CAMARA > 8 && param->Cam.profundidad <= 8) || (BITS_CAMARA <= 8 && param->Cam.profundidad > 8) ) { error_fatal(fn, "BITS_CAMARA (DEFINE en codigo) y profundidad camara no coherentes", 0); return 1; } //Si la profundidad no es de 8bit, hay que configurar el display. //El display siempre es de 8 bit if (param->Cam.profundidad == 16) { MdispControl(M_display_normal,M_VIEW_MODE,M_BIT_SHIFT); MdispControl(M_display_normal,M_VIEW_BIT_SHIFT,4); //despreciamos los 4 bits menos significativos MdispLut(M_display_normal, M_PSEUDO); //esto es necesario para que la intensidad no sea anormalmente elevada } // Reservamos los buffers donde se almacenarán y procesarán las imágenes. // M_imagen1 será el buffer que normalmente estará asociado al display_normal. // En modo VGA no permite grabar datos en el buffer. long nSD_size; MsysInquire(M_sistema,M_SYSTEM_DESCRIPTOR_SIZE,&nSD_size); char* systemDescriptor = new char[nSD_size]; MsysInquire(M_sistema,M_SYSTEM_DESCRIPTOR,systemDescriptor); if (systemDescriptor == M_SYSTEM_VGA) MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC, &M_imagen1 ); else MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED, M_IMAGE+M_DISP+M_GRAB+M_PROC, &M_imagen1 ); delete [ ] systemDescriptor; if ( M_imagen1 == M_NULL) { error_fatal(fn, "M_imagen1", 0); return -1; } if ( M_imagen1 != M_NULL ) { // Seleccionamos el display para imagen normal, asociando el overlay. #if !defined (__BORLANDC__) configura_overlay(M_display_normal, M_imagen1, &M_overlay_normal, 1); #else configura_overlay(M_display_normal, M_imagen1, HWindow, &M_overlay_normal, 1); borra_buffer(M_imagen1, NEGRO, 0, 0, NULL, NULL); #endif /* */ if (param->Cam.anchoImagen != param->Cam.anchoImagen_e || param->Cam.altoImagen != param->Cam.altoImagen_e) { // Reservo un child buffer de M_imagen1 con el tamaño de enfoque. MbufChild2d(M_imagen1, (param->Cam.anchoImagen - param->Cam.anchoImagen_e) /2, (param->Cam.altoImagen- param->Cam.altoImagen_e) /2, param->Cam.anchoImagen_e, param->Cam.altoImagen_e, &M_centro_imagen); if (M_centro_imagen == M_NULL) { error_fatal(fn, "M_centro_imagen", 0); return -1; } } else M_centro_imagen = M_imagen1; } MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC, &M_imagen2 ); if ( M_imagen2 == M_NULL ) { error_fatal(fn, "M_imagen2", 0); return -1; } MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC, &M_imagen3); if ( M_imagen3 == M_NULL ) { error_fatal(fn, "M_imagen3", 0); return -1; } MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC, &M_imagen4); if ( M_imagen4 == M_NULL ) { error_fatal(fn, "M_imagen4", 0); return -1; } MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC, &M_imagen5); if ( M_imagen5 == M_NULL ) { error_fatal(fn, "M_imagen5", 0); return -1; } MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC, &M_imagen6); if ( M_imagen6 == M_NULL ) { error_fatal(fn, "M_imagen6", 0); return -1; } // Reservo memoria para los buffers utilizados en la adquisición // de las bandas y en la correccion de la iluminación. for (i=0; i < param->nBandas; i++) { MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, param->Cam.profundidad+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC, &M_banda[i]); MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, 32+M_FLOAT, M_IMAGE+M_PROC, &M_correc_denom[i]); MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, 32+M_FLOAT, M_IMAGE+M_PROC, &M_correc_numer[i]); if ( M_banda[i] == M_NULL || M_correc_numer[i] == M_NULL || M_correc_denom[i] == M_NULL ) { error_fatal(fn, "M_banda", 0); return 1; } } //El resto de filtros no usados a NULL for (; i < MAX_FILTROS_DTA; i++) M_banda[i] = M_correc_numer[i] = M_correc_denom[i] = M_NULL; MbufAlloc2d(M_sistema, param->Cam.anchoImagen, param->Cam.altoImagen, 32+M_FLOAT, M_IMAGE+M_PROC, &M_correc_aux); if ( M_correc_aux == M_NULL ) { error_fatal(fn, "M_correc_aux", 0); return 1; } // SI DEFINO UN TAMAÑO DE DIGITALIZADOR DE ENFOQUE... (BUFFERS) // Reservo memoria para los buffers empleados durante el enfoque mediante la funcion determina_contraste2 if ( param->Cam.formatoDig_e[0] != '\0' ) { MbufAlloc2d(M_sistema, param->Cam.anchoImagen_e, param->Cam.altoImagen_e, param->Cam.profundidad+M_UNSIGNED, M_IMAGE+M_DISP+M_GRAB+M_PROC, &M_enfoque); if ( M_enfoque == M_NULL ) { error_fatal(fn, "M_enfoque", 0); return 1; } } 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; }
/************************** carga_imagen_campo **************************** Función para efectuar la carga desde disco de una imagen del campo. Se le pasan a esta función los siguientes argumentos: nombre: nombre del fichero que quiero cargar. buffer: le paso el buffer donde quiero almacenar la imagen a cargar. Esto define el tamaño del mismo. nProfundidad: profundidad (bits) del buffer (8,12,16) Esta función únicamente carga la imagen en el buffer seleccionado, no la muestra en el display. LEE LA PROFUNDIDAD GUARDADA, EL BUFFER ESTA EN nProfundidad ****************************************************************************/ int carga_imagen_campo_bits(char *nombre, MIL_ID buffer, int nProfundidad) { // Leer informacion TIF (escala reflectancia y profundidad) int nProfundidadFichero = -1; double dEscalaFichero; try { CString csNombreImagen; INTERFAZ_LIBTIF::LeerTags(nombre,nProfundidadFichero,dEscalaFichero); //Leemos de la imagen la profundidad en bits y la escala reflectancia-gris if (nProfundidadFichero < 0 ) nProfundidadFichero = 8; // por defecto las imagenes estan en 8 bit } catch(...) { nProfundidadFichero = 8; } if (nProfundidad != nProfundidadFichero) { // Buffer auxiliar de 16 es necesario para poder operar (M_PROC) MIL_ID M_buf16; long altoImagen,anchoImagen; MbufInquire(buffer, M_SIZE_X, &anchoImagen); MbufInquire(buffer, M_SIZE_Y, &altoImagen); MbufAlloc2d(M_DEFAULT_HOST, anchoImagen, altoImagen, 16+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC, &M_buf16 ); if (nProfundidad >= 12 && nProfundidadFichero >= 12) { if (carga_imagen_campo(nombre,M_buf16)) return 1;//ERROR MimShift(M_buf16,buffer,nProfundidad - nProfundidadFichero);//conversion de 12 a 16 bit } else if (nProfundidadFichero == 8) //nProfundidad>8 { MIL_ID M_buf8; MbufAlloc2d(M_DEFAULT_HOST, anchoImagen, altoImagen, 8+M_UNSIGNED, M_IMAGE+M_DISP+M_PROC, &M_buf8 ); if (carga_imagen_campo(nombre,M_buf8)) //ERROR return 1; MbufCopy(M_buf8, M_buf16); MbufFree(M_buf8); MimShift(M_buf16,buffer,nProfundidad - nProfundidadFichero);//conversion de 8 a 12 bit } else //(nProfundidad == 8 && nProfundidadFichero > 8 { if (carga_imagen_campo(nombre,M_buf16)) //ERROR return 1; MimShift(M_buf16,buffer,nProfundidad - nProfundidadFichero);//conversion de 8 a 12 bit } MbufFree(M_buf16); } else { if (carga_imagen_campo(nombre,buffer)) //ERROR return 1; } return 0; }