bool MdispGtkView::saveROIAs(const char *filename)
{
/////////////////////////////////////////////////////////////////////////
// MIL: Get current ROI in buffer-related coordinates.
/////////////////////////////////////////////////////////////////////////
MIL_INT OffsetX = MdispInquire(m_MilDisplay, M_ROI_BUFFER_OFFSET_X, M_NULL);
MIL_INT OffsetY = MdispInquire(m_MilDisplay, M_ROI_BUFFER_OFFSET_Y, M_NULL);
MIL_INT SizeX = MdispInquire(m_MilDisplay, M_ROI_BUFFER_SIZE_X, M_NULL);
MIL_INT SizeY = MdispInquire(m_MilDisplay, M_ROI_BUFFER_SIZE_Y, M_NULL);
/////////////////////////////////////////////////////////////////////////
// MIL: Create a child of the selected buffer, with the ROI coordinates.
/////////////////////////////////////////////////////////////////////////
MIL_ID ChildBuffer = MbufChildColor2d(m_MilImage,
M_ALL_BANDS,
OffsetX,
OffsetY,
SizeX,
SizeY,
M_NULL);
/////////////////////////////////////////////////////////////////////////
// MIL: Save the buffer in the path given by the user.
/////////////////////////////////////////////////////////////////////////
MbufSave(filename, ChildBuffer);
MbufFree(ChildBuffer);
return true;
}
void MdispGtkView::ROIDefine(bool on)
{
/////////////////////////////////////////////////////////////////////////
// MIL: Write code that will be executed when 'ROI Define '
// menu is clicked. State toggles.
/////////////////////////////////////////////////////////////////////////
if(m_MilDisplay && m_isROISupported)
{
MdispControl(m_MilDisplay, M_ROI_DEFINE, on?(M_START+M_RESET):M_STOP);
m_isInROIDefineMode = on;
// Make sure Interpolation Mode combo box shows current interpolation mode
m_currentInterpolationMode = MdispInquire(m_MilDisplay, M_INTERPOLATION_MODE, M_NULL);
if(MdispInquire(m_MilDisplay, M_DISPLAY_TYPE, M_NULL) & M_EXCLUSIVE)
{
//when ROI mode is active, allow the mouse to be used in the exclusive display monitor
if(m_isInROIDefineMode)
{
MdispControl(m_MilDisplay, M_RESTRICT_CURSOR, M_DISABLE);
}
else
{
MdispControl(m_MilDisplay, M_RESTRICT_CURSOR, M_ENABLE);
}
}
}
}
void MdispGtkView::ChangeAsynchronousMode(bool Enabled, MIL_INT FrameRate)
{
if(Enabled && (FrameRate != m_currentAsynchronousFrameRate))
{
if(m_MilDisplay)
{
// Apply asynchronous frame rate to display [CALL TO MIL]
MdispControl(m_MilDisplay, M_UPDATE_RATE_MAX, FrameRate);
// Check if control worked correctly before considering it successful [CALL TO MIL]
if(MdispInquire(m_MilDisplay, M_UPDATE_RATE_MAX, M_NULL) == FrameRate)
{
m_currentAsynchronousFrameRate = FrameRate;
}
}
}
if((Enabled && !m_isInAsynchronousMode) ||
(!Enabled && m_isInAsynchronousMode))
{
if(m_MilDisplay)
{
// Apply asynchronous update to display [CALL TO MIL]
MdispControl(m_MilDisplay, M_ASYNC_UPDATE, (Enabled ? M_ENABLE : M_DISABLE));
// Check if control worked correctly before considering it successful [CALL TO MIL]
if(MdispInquire(m_MilDisplay, M_ASYNC_UPDATE, M_NULL) == (Enabled ? M_ENABLE : M_DISABLE))
{
m_isInAsynchronousMode = Enabled;
}
}
}
}
RoiPrefsDlg::RoiPrefsDlg(QWidget *parent, MIL_ID MilDisplay) :
QDialog(parent),
ui(new Ui::RoiPrefsDlg),
m_MilDisplay(MilDisplay)
{
QPalette palette;
ui->setupUi(this);
MIL_INT linecolor = MdispInquire(m_MilDisplay, M_ROI_LINE_COLOR, M_NULL);
MIL_INT anchorcolor= MdispInquire(m_MilDisplay, M_ROI_HANDLE_COLOR, M_NULL);
m_LineColor.setRgb(M_RGB888_r(linecolor),
M_RGB888_g(linecolor),
M_RGB888_b(linecolor));
m_AnchorColor.setRgb(M_RGB888_r(anchorcolor),
M_RGB888_g(anchorcolor),
M_RGB888_b(anchorcolor));
palette.setColor(ui->RoiLineButton->backgroundRole(), m_LineColor);
ui->RoiLineButton->setPalette(palette);
ui->RoiLineButton->setAutoFillBackground(true);
ui->RoiLineButton->setFocusPolicy(Qt::NoFocus);
ui->RoiHandlesButton->setPalette(QPalette(m_AnchorColor));
ui->RoiHandlesButton->setAutoFillBackground(true);
ui->RoiHandlesButton->setFocusPolicy(Qt::NoFocus);
connect(ui->RoiOkButton, SIGNAL(clicked()), SLOT(close()));
}
MIL_INT MFTYPE ROIChangeFct(MIL_INT /*HookType*/, MIL_ID /*EventID*/, void MPTYPE *UserDataPtr)
{
MdispGtkView *pCurrentView = (MdispGtkView *)UserDataPtr;
if(pCurrentView)
{
MIL_ID DisplayID = pCurrentView->m_MilDisplay;
MIL_INT OffsetX = MdispInquire(DisplayID, M_ROI_BUFFER_OFFSET_X, M_NULL);
MIL_INT OffsetY = MdispInquire(DisplayID, M_ROI_BUFFER_OFFSET_Y, M_NULL);
MIL_INT SizeX = MdispInquire(DisplayID, M_ROI_BUFFER_SIZE_X, M_NULL);
MIL_INT SizeY = MdispInquire(DisplayID, M_ROI_BUFFER_SIZE_Y, M_NULL);
pCurrentView->UpdateStatusBarWithROI(OffsetX, OffsetY, SizeX, SizeY);
}
return 0;
}
bool MdispGtkView::IsFileSaveRoiAsEnabled()
{
/////////////////////////////////////////////////////////////////////////
// MIL: If no ROI exist, we do not allow user to select this item.
/////////////////////////////////////////////////////////////////////////
if(m_MilDisplay)
{
if(MdispInquire(m_MilDisplay, M_ROI_BUFFER_SIZE_X, M_NULL)&&
MdispInquire(m_MilDisplay, M_ROI_BUFFER_SIZE_Y, M_NULL))
{
return true;
}
}
return false;
}
// interfaz con Clasificacion para clasificar la imagen m_Milimagen (ya cargada y perteneciente a ControlImagen)
// devuelve false, si ha habido un error o si ya se habia clasificado y unicamente se ha mostrado la imagen ya clasificada
bool ControlImagenes::Clasificar(CStatic* pDisplay, list<CMineralClasificado> &listClasificados, unsigned int& nCountOscuros, CRect* pRect, double dRefMin)
{
if (M_Clasificacion == M_NULL) // hace falta clasificar de nuevo, no se hizo con anterioridad
if (!theApp.clasificacion.CargarImagenes(&m_Milimagen[1],m_numImagenes,pRect)) // nos saltamos la banda pancromatica (no usada)
return false;
if (pDisplay!=NULL)
{
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 de la profundidad leida
if (!theApp.clasificacion.InicializaDisplay(pDisplay,m_Mildisplay,M_Clasificacion,M_Confiabilidad,M_Distancia))
{
ASSERT(m_bufClasificacionSelectiva != NULL);
return false;
}
if (m_bufClasificacionSelectiva == NULL)
m_bufClasificacionSelectiva = new BYTE[m_nAnchoImagen*m_nAltoImagen];//buffer para la imagen de salida (clasificada selectivamente)
}
if (!theApp.clasificacion.Clasificar(listClasificados,nCountOscuros,theApp.m_dEscalaReflectancia, theApp.m_nBitsProfundidad, dRefMin))
return false;
return true;
}
void ControlImagenes::Distancia(CStatic& m_control)
{
MIL_ID selected;
MdispInquire(m_Mildisplay,M_SELECTED,&selected);
if (selected!=M_NULL)
MdispDeselect(m_Mildisplay,selected);
MdispSelectWindow(m_Mildisplay, M_Distancia, m_control);
}
void MdispGtkView::UpdateROIWithCurrentState()
{
if(m_MilDisplay)
{
if(MdispInquire(m_MilDisplay, M_ROI_DEFINE, M_NULL) == M_STOP)
m_isInROIDefineMode = false;
else
m_isInROIDefineMode = true;
}
}
void ControlImagenes::Confiabilidad(CStatic& m_control)
{
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
MdispSelectWindow(m_Mildisplay, M_Confiabilidad, m_control);
}
gboolean MdispGtkView::timerEvent(gpointer user_data)
{
MdispGtkView* pCurrentView = (MdispGtkView *) user_data;
if(pCurrentView && pCurrentView->m_MilDisplay)
{
MIL_DOUBLE CurrentFrameRate = M_NULL;
MdispInquire(pCurrentView->m_MilDisplay, M_UPDATE_RATE, &CurrentFrameRate);
g_signal_emit(G_OBJECT(pCurrentView->m_cf->Window()), pCurrentView->m_cf->frameRateChangedSignal(), 0, CurrentFrameRate);
}
return true;
}
// 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;
}
// Se presenta la imagen (previamente cargada) correspondiente al numero de Filtro "numFIltro"
bool ControlImagenes::MostrarImagen(int numFiltro, CStatic& m_control)
{
MIL_ID selected;
MdispInquire(m_Mildisplay,M_SELECTED,&selected);
if (selected!=M_NULL)
MdispDeselect(m_Mildisplay,selected);
DisplayBits(theApp.m_nBitsProfundidad); //para que el display muestre las imagenes de la profundidad de la imagen (puede que no estuviese si se estaba presentando la imagen de clasificacion)
MdispSelectWindow(m_Mildisplay,m_Milimagen[numFiltro-1],m_control);
return true;
}
void MdispGtkView::ChangeCompressionType(MIL_INT CompressionType)
{
if(m_MilDisplay)
{
// Apply compression type to display [CALL TO MIL]
MdispControl(m_MilDisplay, M_COMPRESSION_TYPE, CompressionType);
// Check if control worked correctly before considering it successful [CALL TO MIL]
if(MdispInquire(m_MilDisplay, M_COMPRESSION_TYPE, M_NULL) == CompressionType)
{
m_currentCompressionType = CompressionType;
}
}
}
void MdispGtkView::ChangeQFactor(MIL_INT QFactor)
{
if(m_MilDisplay)
{
// Apply Q factor to display [CALL TO MIL]
MdispControl(m_MilDisplay, M_Q_FACTOR, QFactor);
// Check if control worked correctly before considering it successful [CALL TO MIL]
if(MdispInquire(m_MilDisplay, M_Q_FACTOR, M_NULL) == QFactor)
{
m_currentQFactor = QFactor;
}
}
}
void MdispGtkView::ChangeInterpolationMode(long InterpolationMode)
{
if(m_MilDisplay)
{
//Apply interpolation mode on display [CALL TO MIL]
MdispControl(m_MilDisplay, M_INTERPOLATION_MODE, InterpolationMode);
//Check if control worked correctly before considering it as successful [CALL TO MIL]
if(MdispInquire(m_MilDisplay, M_INTERPOLATION_MODE,M_NULL)==InterpolationMode)
{
//Make sure Interpolation Mode combo box shows current interpolation mode
m_currentInterpolationMode = InterpolationMode;
}
}
}
void MdispGtkView::RestrictCursor(bool on)
{
/////////////////////////////////////////////////////////////////////////
// MIL: Write code that will be executed when 'Restrict Cursor' menu item is clicked
/////////////////////////////////////////////////////////////////////////
if(m_MilDisplay)
{
MdispControl(m_MilDisplay, M_RESTRICT_CURSOR,on?M_ENABLE:M_DISABLE);
// Check if control worked correctly before considering it successful [CALL TO MIL]
MdispInquire(m_MilDisplay, M_RESTRICT_CURSOR, &m_currentRestrictCursor);
}
}
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();
}
void MdispGtkView::ChangeViewMode(long ViewMode,long ShiftValue)
{
if(m_MilDisplay)
{
//Apply view mode on display [CALL TO MIL]
MdispControl(m_MilDisplay, M_VIEW_MODE, ViewMode);
if(ViewMode == M_BIT_SHIFT)
MdispControl(m_MilDisplay, M_VIEW_BIT_SHIFT, ShiftValue);
//Check if control worked correctly before considering it as successful [CALL TO MIL]
if(MdispInquire(m_MilDisplay, M_VIEW_MODE,M_NULL)==ViewMode)
{
//Make sure ViewMode Mode combo box shows current interpolation mode
m_currentViewMode = ViewMode;
m_currentShiftValue = ShiftValue;
}
}
}
void MdispGtkView::NoTearing( bool on )
{
/////////////////////////////////////////////////////////////////////////
// MIL: Write code that will be executed when 'No Tearing' button or menu is clicked
/////////////////////////////////////////////////////////////////////////
// No Notearing in windowed mode in linux
if(m_isWindowed)
return;
if(m_MilDisplay)
{
//Enable/disable No-Tearing mode on display [CALL TO MIL]
MdispControl(m_MilDisplay, M_NO_TEARING, on ? M_ENABLE : M_DISABLE);
//Check if it worked before considering it as enabled [CALL TO MIL]
if(MdispInquire(m_MilDisplay, M_NO_TEARING, M_NULL) == on ? M_ENABLE : M_DISABLE)
{
m_isNoTearingEnabled = on;
}
}
}
ROIDialog::ROIDialog(MIL_INT MilDisplay):m_MilDisplay(MilDisplay)
{
GtkWidget *pickerLine;
GtkWidget *pickerAnchor;
GtkWidget *closeButton;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
MIL_INT linecolor = MdispInquire(m_MilDisplay, M_ROI_LINE_COLOR, M_NULL);
MIL_INT anchorcolor= MdispInquire(m_MilDisplay, M_ROI_HANDLE_COLOR, M_NULL);
m_LineColor.red = M_RGB888_R(linecolor)<<8;
m_LineColor.green = M_RGB888_G(linecolor)<<8;
m_LineColor.blue = M_RGB888_B(linecolor)<<8;
m_AnchorColor.red = M_RGB888_R(anchorcolor)<<8;
m_AnchorColor.green = M_RGB888_G(anchorcolor)<<8;
m_AnchorColor.blue = M_RGB888_B(anchorcolor)<<8;
m_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(m_window), "ROI Preferences");
gtk_container_set_border_width (GTK_CONTAINER (m_window), 0);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (m_window), vbox);
label = gtk_label_new ("Color :");
gtk_container_add (GTK_CONTAINER (vbox), label);
hbox = gtk_hbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
gtk_container_add (GTK_CONTAINER (vbox), hbox);
label = gtk_label_new ("Line Color");
gtk_container_add (GTK_CONTAINER (hbox), label);
pickerLine = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pickerLine), TRUE);
gtk_container_add (GTK_CONTAINER (hbox), pickerLine);
gtk_color_button_set_color(GTK_COLOR_BUTTON(pickerLine),&m_LineColor);
hbox = gtk_hbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
gtk_container_add (GTK_CONTAINER (vbox), hbox);
label = gtk_label_new ("Anchor Color");
gtk_container_add (GTK_CONTAINER (hbox), label);
pickerAnchor = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pickerAnchor), TRUE);
gtk_container_add (GTK_CONTAINER (hbox), pickerAnchor);
gtk_color_button_set_color(GTK_COLOR_BUTTON(pickerAnchor),&m_AnchorColor);
closeButton = gtk_button_new_with_label("Close");
gtk_container_add (GTK_CONTAINER (vbox), closeButton);
//signals
g_signal_connect (closeButton,"clicked",G_CALLBACK(ROIDialog::OnClose),this);
g_signal_connect (pickerAnchor,"color-set",G_CALLBACK(ROIDialog::OnROIAnchorColorChange),this);
g_signal_connect (pickerLine,"color-set",G_CALLBACK(ROIDialog::OnROILineColorChange),this);
g_signal_connect (m_window, "destroy", G_CALLBACK(ROIDialog::OnDestroy), this);
}
void MdispGtkView::Initialize()
{
// Allocate a display [CALL TO MIL]
MdispAlloc(((MdispGtkApp*)dispGtkApp())->m_MilSystem, M_DEFAULT, "M_DEFAULT", M_DEFAULT, &m_MilDisplay);
if(m_MilDisplay)
{
MIL_INT DisplayType = MdispInquire(m_MilDisplay, M_DISPLAY_TYPE, M_NULL);
// Check display type [CALL TO MIL]
if((DisplayType&(M_WINDOWED|M_EXCLUSIVE)) !=M_WINDOWED)
m_isWindowed = false;
if(DisplayType&(M_EXCLUSIVE))
m_isExclusive = true;
// ROI are supported with windowed display
m_isROISupported = (DisplayType&M_WINDOWED) != 0;
// Initially set interpolation mode and view mode to default
ChangeInterpolationMode(M_DEFAULT);
ChangeViewMode(M_DEFAULT);
if(m_isWindowed)
{
#if USE_ANNOTATION
// The connection to the X display must be given to Mil so it
// can update the window when ROI is enabled
MdispControl(m_MilDisplay,M_WINDOW_ANNOTATIONS,M_PTR_TO_DOUBLE(GDK_WINDOW_XDISPLAY(m_window->window)));
#else
m_isROISupported = false;
#endif
}
if(m_isROISupported)
{
// Set ROI-show mode.
ROIShow(m_isInROIShowMode);
// Install hooks for ROI info in status bar and to keep current status
// in toolbar
MdispHookFunction(m_MilDisplay, M_ROI_CHANGE, ROIChangeFct, (void*)this);
MdispHookFunction(m_MilDisplay, M_ROI_CHANGE_END, ROIChangeEndFct, (void*)this);
}
if(IsNetworkedSystem())
{
// Check compression type [CALL TO MIL]
MdispInquire(m_MilDisplay, M_COMPRESSION_TYPE, &m_currentCompressionType);
// Check asynchronous mode [CALL TO MIL]
m_isInAsynchronousMode = (MdispInquire(m_MilDisplay, M_ASYNC_UPDATE, M_NULL) == M_ENABLE);
// Check asynchronous frame rate [CALL TO MIL]
MdispInquire(m_MilDisplay, M_UPDATE_RATE_MAX, &m_currentAsynchronousFrameRate);
// Check Q factor [CALL TO MIL]
MdispInquire(m_MilDisplay, M_Q_FACTOR, &m_currentQFactor);
}
if(m_isExclusive)
{
MdispInquire(m_MilDisplay, M_RESTRICT_CURSOR, &m_currentRestrictCursor);
}
//Select the buffer from it's display object and given window [CALL TO MIL]
MdispSelectWindow(m_MilDisplay, m_MilImage, m_isWindowed?GDK_WINDOW_XID(m_window->window):0);
}
// Hook a function to mouse-movement event, to update cursor position in status bar.
MdispHookFunction(m_MilDisplay, M_MOUSE_MOVE, MouseFct, (void*)this);
/////////////////////////////////////////////////////////////////////////
// MIL: Code that will be executed when a view is first attached to the document
/////////////////////////////////////////////////////////////////////////
}
// 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;
}
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;
}
}
}