void MdispGtkView::GraphicsAnnotations( bool on )
{
if(m_MilDisplay)
{
m_isGraphicsAnnotationsEnabled = on;
if(m_isGraphicsAnnotationsEnabled)
{
if(!m_MilGraphContext && !m_MilGraphList)
{
MIL_INT BufSizeX = 0, BufSizeY = 0;
MIL_INT LogoCellSize = 12;
MIL_INT LogoSize = 6 * LogoCellSize;
MIL_INT Offset = 10;
MgraAlloc(((MdispGtkApp*)dispGtkApp())->m_MilSystem, &m_MilGraphContext);
MgraAllocList(((MdispGtkApp*)dispGtkApp())->m_MilSystem, M_DEFAULT, &m_MilGraphList);
MdispControl(m_MilDisplay, M_DISPLAY_GRAPHIC_LIST, m_MilGraphList);
MdispControl(m_MilDisplay, M_UPDATE_GRAPHIC_LIST, M_DISABLE);
MbufInquire(m_MilImage, M_SIZE_X, &BufSizeX);
MbufInquire(m_MilImage, M_SIZE_Y, &BufSizeY);
MgraClear(m_MilGraphContext, m_MilGraphList);
GraphicLogo(Offset , Offset , LogoCellSize);
GraphicLogo(BufSizeX - (LogoSize/2), Offset , LogoCellSize);
GraphicLogo(Offset , BufSizeY + Offset, LogoCellSize);
MgraColor(m_MilGraphContext, M_COLOR_LIGHT_BLUE);
MgraLine(m_MilGraphContext, m_MilGraphList, Offset + (LogoSize/2), Offset + LogoSize, Offset + LogoSize/2, BufSizeY + Offset);
MgraLine(m_MilGraphContext, m_MilGraphList, Offset + LogoSize, Offset + (LogoSize/2), BufSizeX - (LogoSize/2), Offset + (LogoSize/2));
MgraColor(m_MilGraphContext, M_COLOR_GRAY);
MgraText(m_MilGraphContext, m_MilGraphList, Offset, (2*Offset)+LogoSize, MT("Mil Graphic"));
MgraText(m_MilGraphContext, m_MilGraphList, Offset, (4*Offset)+LogoSize, MT("Annotations"));
MdispControl(m_MilDisplay, M_UPDATE_GRAPHIC_LIST, M_ENABLE);
}
}
else
{
MdispControl(m_MilDisplay, M_DISPLAY_GRAPHIC_LIST, M_NULL);
if(m_MilGraphList)
{
MgraFree(m_MilGraphList);
m_MilGraphList = M_NULL;
}
if(m_MilGraphContext)
{
MgraFree(m_MilGraphContext);
m_MilGraphContext = M_NULL;
}
}
}
}
// 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;
}
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;
}
bool MdispGtkView::load(const char *filename)
{
//Import image in buffer [CALL TO MIL]
MbufImport(filename,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)
{
Initialize();
m_imageSizeX = MbufInquire(m_MilImage,M_SIZE_X,M_NULL);
m_imageSizeY = MbufInquire(m_MilImage,M_SIZE_Y,M_NULL);
m_filename = g_strdup(g_path_get_basename(filename));
UpdateContentSize();
return true;
}
else
{
return false;
}
}
/************************** 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;
}
/************************** calcula_valores_linea *************************
Calcula los valores de nivel de gris de una determinada línea.
(horizontal o vertical).
*****************************************************************************/
int calcula_valores_linea(MIL_ID M_fb, int posX, int posY, int linea)
{
BYTE val_pixel_h[MAX_ANCHO_IMAGEN], val_pixel_v[MAX_ALTO_IMAGEN];
int altoImagen, anchoImagen;
MbufCopy(M_fb, M_imagen6);
/* Compruebo que los valores a calcular no están fuera de los límites definidos por
el buffer. */
anchoImagen = MbufInquire(M_imagen6, M_SIZE_X, M_NULL);
altoImagen = MbufInquire(M_imagen6, M_SIZE_Y, M_NULL);
posX = (posX < 0)? 0 : posX;
posX = (posX > anchoImagen)? anchoImagen : posX;
posY = (posY < 0)? 0 : posY;
posY = (posY > altoImagen)? altoImagen : posY;
// Línea horizontal.
if (linea == L_HORIZ) {
MbufGetLine(M_imagen6, 0, posY, anchoImagen-1, posY, M_DEFAULT, M_NULL, &val_pixel_h);
dibuja_analisis_linea(val_pixel_h, linea, altoImagen, anchoImagen);
}
// Línea vertical.
else if (linea == L_VERT) {
MbufGetLine(M_imagen6, posX, 0, posX, altoImagen-1, M_DEFAULT, M_NULL, &val_pixel_v);
dibuja_analisis_linea(val_pixel_v, linea, altoImagen, anchoImagen);
}
else {
error_leve("calcula_valores_linea", "no se puede mostrar el análisis de la línea");
return -1;
}
return 0;
}
/************************** 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;
}
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.");
}
}
/************************** 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;
}
void MdispGtkView::InitializeOverlay()
{
MIL_TEXT_CHAR chText[80];
// Initialize overlay if not already done
if ((!m_isOverlayInitialized) && (m_MilDisplay))
{
//Only do it on a valid windowed display [CALL TO MIL]
if (m_MilImage && m_MilDisplay )
{
// Prepare overlay buffer //
////////////////////////////
// Enable display overlay annotations.
MdispControl(m_MilDisplay, M_OVERLAY, M_ENABLE);
// Inquire the Overlay buffer associated with the displayed buffer [CALL TO MIL]
MdispInquire(m_MilDisplay, M_OVERLAY_ID, &m_MilOverlayImage);
// Clear the overlay to transparent.
MdispControl(m_MilDisplay, M_OVERLAY_CLEAR, M_DEFAULT);
// Disable the overlay display update to accelerate annotations.
MdispControl(m_MilDisplay, M_OVERLAY_SHOW, M_DISABLE);
// Draw MIL monochrome overlay annotation *
//*****************************************
// Inquire MilOverlayImage size x and y [CALL TO MIL]
long imageWidth = MbufInquire(m_MilOverlayImage,M_SIZE_X,M_NULL);
long imageHeight = MbufInquire(m_MilOverlayImage,M_SIZE_Y,M_NULL);
// Set graphic text to transparent background. [CALL TO MIL]
MgraControl(M_DEFAULT, M_BACKGROUND_MODE, M_TRANSPARENT);
// Set drawing color to white. [CALL TO MIL]
MgraColor(M_DEFAULT, M_COLOR_WHITE);
// Print a string in the overlay image buffer. [CALL TO MIL]
MgraText(M_DEFAULT, m_MilOverlayImage, imageWidth/9, imageHeight/5, " -------------------- ");
MgraText(M_DEFAULT, m_MilOverlayImage, imageWidth/9, imageHeight/5+25, " - MIL Overlay Text - ");
MgraText(M_DEFAULT, m_MilOverlayImage, imageWidth/9, imageHeight/5+50, " -------------------- ");
// Print a green string in the green component overlay image buffer. [CALL TO MIL]
MgraColor(M_DEFAULT, M_COLOR_GREEN);
MgraText(M_DEFAULT, m_MilOverlayImage, imageWidth*11/18, imageHeight/5, " -------------------- ");
MgraText(M_DEFAULT, m_MilOverlayImage, imageWidth*11/18, imageHeight/5+25, " - MIL Overlay Text - ");
MgraText(M_DEFAULT, m_MilOverlayImage, imageWidth*11/18, imageHeight/5+50, " -------------------- ");
// Draw GDI color overlay annotation *
//************************************
// Disable hook to MIL error because control might not be supported
MappControl(M_ERROR_HOOKS, M_DISABLE);
// Create a device context to draw in the overlay buffer with GDI. [CALL TO MIL]
MbufControl(m_MilOverlayImage, M_XPIXMAP_ALLOC, M_COMPENSATION_ENABLE);
// Reenable hook to MIL error
MappControl(M_ERROR_HOOKS, M_ENABLE);
// Retrieve the XPIXMAP of the overlay [CALL TO MIL]
Pixmap XPixmap = (Pixmap)MbufInquire(m_MilOverlayImage, M_XPIXMAP_HANDLE, M_NULL);
/* convert it to gdkpixmap */
GdkPixmap *gdkpixmap = gdk_pixmap_foreign_new(XPixmap);
if(gdkpixmap)
{
GdkPoint Hor[2];
GdkPoint Ver[2];
GdkColor color[3];
GdkFont *font = NULL;
font = gdk_font_load ("-misc-*-*-r-*-*-*-140-*-*-*-*-*-1");
int i;
/* get graphic context from pixmap*/
GdkGC *gc = gdk_gc_new(gdkpixmap);
/* allocate colors */
gdk_color_parse("blue",&color[0]);
gdk_color_parse("red",&color[1]);
gdk_color_parse("yellow",&color[2]);
for(i=0;i<3;i++)
gdk_color_alloc(gdk_colormap_get_system(), &color[i]);
/* set the foreground to our color */
gdk_gc_set_foreground(gc, &color[0]);
// Draw a blue cross in the overlay buffer.
Hor[0].x = 0;
Hor[0].y = imageHeight/2;
Hor[1].x = imageWidth;
Hor[1].y = imageHeight/2;
gdk_draw_lines(gdkpixmap,gc,Hor,2);
Ver[0].x = imageWidth/2;
Ver[0].y = 0;
Ver[1].x = imageWidth/2;
Ver[1].y = imageHeight;
gdk_draw_lines(gdkpixmap,gc,Ver,2);
// Write Red text in the overlay buffer.
MosStrcpy(chText, 80, "X Overlay Text ");
gdk_gc_set_foreground(gc, &color[1]);
gdk_draw_string(gdkpixmap,
font,
gc,
imageWidth*3/18,
imageHeight*4/6,
chText);
// Write Yellow text in the overlay buffer.
gdk_gc_set_foreground(gc, &color[2]);
gdk_draw_string(gdkpixmap,
font,
gc,
imageWidth*12/18,
imageHeight*4/6,
chText);
/* flush */
gdk_display_flush(gdk_display_get_default());
/* Free graphic context.*/
g_object_unref(gc);
// Delete created Pixmap. [CALL TO MIL]
MbufControl(m_MilOverlayImage, M_XPIXMAP_FREE, M_DEFAULT);
// Signal MIL that the overlay buffer was modified. [CALL TO MIL]
MbufControl(m_MilOverlayImage, M_MODIFIED, M_DEFAULT);
}
// Now that overlay buffer is correctly prepared, we can show it [CALL TO MIL]
MdispControl(m_MilDisplay, M_OVERLAY_SHOW, M_ENABLE);
// Overlay is now initialized
m_isOverlayInitialized = true;
}
}
}
