// 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 CFormTomaUnica::OnShowWindow(BOOL bShow, UINT nStatus)
{
CDialog::OnShowWindow(bShow, nStatus);
if (nStatus == 0)
{
if (bShow == TRUE)
{
MdispSelectWindow(M_display_normal,M_imagen1,m_imagen);
// Leemos el ratio configurado y lo aplicamos
CString csRatio;
csRatio.Format("%.2f",theApp.m_configuracion.m_ratio_inicial);
m_ratio.SetWindowText(csRatio);
MostrarFiltro(theApp.Rueda.GetFilter()); //Actualizamos el filtro actual
ActualizarEscala(); //en dialogo usando theApp.m_CorreccionGeometrica.m_dEscalaObjetivo
// El display tiene que ajustarse al tamaño de imagen y el zoom actual
long anchoImagen = (long)floor(theApp.m_ParamIni.Cam.anchoImagen * theApp.m_configuracion.m_ratio_inicial + 0.5);
long altoImagen = (long)floor(theApp.m_ParamIni.Cam.altoImagen * theApp.m_configuracion.m_ratio_inicial + 0.5);
//Ajustamos la ventana principal tambien
m_imagen.SetWindowPos(NULL,0,0,anchoImagen,altoImagen, SWP_NOMOVE | SWP_NOZORDER); //primero imagen para que OnSize funciones correctamente
//Ajustamos la ventana principal tambien
SetWindowPos(NULL,0,0,anchoImagen+m_anchoResto,altoImagen+m_altoResto, SWP_NOMOVE | SWP_NOZORDER | SWP_NOSENDCHANGING | SWP_NOACTIVATE);
}
else
{
MdispDeselect(M_display_normal,M_imagen1);
}
}
}
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 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);
}
// 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::RemoveFromDisplay()
{
//Halt grab if in process in THIS view
if ((((MdispGtkApp*)dispGtkApp())->m_pGrabView == this) &&
((MdispGtkApp*)dispGtkApp())->m_isGrabStarted)
{
//Ask the digitizer to halt the grab [CALL TO MIL]
MdigHalt(((MdispGtkApp*)dispGtkApp())->m_MilDigitizer);
((MdispGtkApp*)dispGtkApp())->m_isGrabStarted = false;
}
if (m_MilImage && m_MilDisplay)
{
//Deselect the buffer from it's display object and given window [CALL TO MIL]
MdispDeselect(m_MilDisplay,m_MilImage);
if(m_isROISupported)
{
// Uninstall hooks for ROI info in status bar and to keep current status
// in toolbar [CALL TO MIL]
MdispHookFunction(m_MilDisplay, M_ROI_CHANGE+M_UNHOOK, ROIChangeFct, (void*)this);
MdispHookFunction(m_MilDisplay, M_ROI_CHANGE_END+M_UNHOOK, ROIChangeEndFct, (void*)this);
}
// Hook from mouse-movement event.
MdispHookFunction(m_MilDisplay, M_MOUSE_MOVE+M_UNHOOK, MouseFct, (void*)this);
//Free the display [CALL TO MIL]
if(m_MilGraphList)
{
MgraFree(m_MilGraphList);
m_MilGraphList = M_NULL;
}
if(m_MilGraphContext)
{
MgraFree(m_MilGraphContext);
m_MilGraphContext = M_NULL;
}
//Free the display [CALL TO MIL]
MdispFree(m_MilDisplay);
m_MilDisplay = M_NULL;
}
}
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();
}
// Se elimina la imagen correspondiente al filtro "numFiltro", liberando la memoria del buffer
// Se muestra la imagen correspondiente al primer filtro anterior o posterior disponible
// Devuelve el nuevo filtro que se muestra o -1 si no hay mas
int ControlImagenes::EliminarImagen(int numFiltro, CStatic& m_control)
{
int filtroAnterior = EncontrarFiltroAnterior(numFiltro);
if (filtroAnterior == -1)
{
// No hay ningun filtro
MdispDeselect(m_Mildisplay,m_Milimagen[numFiltro-1]);
m_control.SetBitmap((HBITMAP)m_backgound_bitmap);
//al quitar el fondo, se queda lo ultimo (es decir m_backgound_bitmap)
//y ademas se veran las imagenes MIL cuando haya
m_control.SetBitmap(NULL);
}
else
{
MdispSelectWindow(m_Mildisplay,m_Milimagen[filtroAnterior-1],m_control);
}
MbufFree(m_Milimagen[numFiltro-1]);
m_Milimagen[numFiltro-1] = M_NULL;
m_numImagenes--;
return filtroAnterior;
}
// 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;
}
