/************************** dibuja_analisis_linea ************************
Función para mostrar los valores de nivel de gris obtenidos en el análisis
de la línea.
*****************************************************************************/
void dibuja_analisis_linea(BYTE val_pixel[], int linea, int altoImagen, int anchoImagen)
{
int i;
if (linea == L_HORIZ) {
MgraColor(M_DEFAULT, AMARILLO_OSC);
// Represento el corte horizontal
for (i = 0; i < anchoImagen; i++)
MgraLine(M_DEFAULT, M_overlay_normal, i, altoImagen, i, altoImagen - val_pixel[i]);
sendcont("Pulse una tecla para continuar."); // Borro la línea anterior.
getch();
// Borro el corte horizontal
MgraColor(M_DEFAULT, TRANSPARENTE);
for (i = 0; i < altoImagen; i++)
MgraLine(M_DEFAULT, M_overlay_normal, i, altoImagen, i, altoImagen - val_pixel[i]);
}
if (linea == L_VERT) {
// Represento el corte vertical
MgraColor(M_DEFAULT, AMARILLO_OSC);
for (i = 0; i < altoImagen; i++)
MgraLine(M_DEFAULT, M_overlay_normal, 0, i, 0 + val_pixel[i], i);
sendcont("Pulse una tecla para continuar."); // Borro la línea anterior.
getch();
// Borro el corte vertical
MgraColor(M_DEFAULT, TRANSPARENTE);
for (i = 0; i < altoImagen; i++)
MgraLine(M_DEFAULT, M_overlay_normal, 0, i, 0 + val_pixel[i], i);
}
}
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;
}
}
}
}
int MosMain(void)
{
MIL_ID MilApplication, /* Application identifier. */
MilSystem, /* System identifier. */
MilDisplay, /* Display identifier. */
MilImage; /* Image buffer identifier. */
/* Allocate a default MIL application, system, display and image. */
MappAllocDefault(M_SETUP, &MilApplication, &MilSystem, &MilDisplay, M_NULL, &MilImage);
/* If no allocation errors. */
if (!MappGetError(M_GLOBAL, M_NULL))
{
/* Perform graphic operations in the display image. */
MgraColor(M_DEFAULT, 0xF0);
MgraFont(M_DEFAULT, M_FONT_DEFAULT_LARGE);
MgraText(M_DEFAULT, MilImage, 160L, 230L, MIL_TEXT(" Welcome to MIL !!! "));
MgraColor(M_DEFAULT, 0xC0);
MgraRect(M_DEFAULT, MilImage, 100L, 150L, 530L, 340L);
MgraRect(M_DEFAULT, MilImage, 120L, 170L, 510L, 320L);
MgraRect(M_DEFAULT, MilImage, 140L, 190L, 490L, 300L);
/* Print a message. */
MosPrintf(MIL_TEXT("\nSYSTEM ALLOCATION:\n"));
MosPrintf(MIL_TEXT("------------------\n\n"));
MosPrintf(MIL_TEXT("System allocation successful.\n\n"));
MosPrintf(MIL_TEXT(" \"Welcome to MIL !!!\"\n\n"));
}
else
MosPrintf(MIL_TEXT("System allocation error !\n\n"));
/* Wait for a key press. */
MosPrintf(MIL_TEXT("Press <Enter> to end.\n"));
MosGetch();
/* Free defaults. */
MappFreeDefault(MilApplication, MilSystem, MilDisplay, M_NULL, MilImage);
return 0;
}
// Muestra un rectangulo en el overlay teniendo en cuenta el factor de zoom
void ControlImagenes::DibujaRect(CPoint& point_inicial, CPoint& point_final, double color)
{
// MdispOverlayKey(m_Mildisplay, M_KEY_ON_COLOR, M_EQUAL, 0xff, TRANSPARENTE);
//MdispControl(m_Mildisplay, M_KEY_MODE, M_KEY_ON_COLOR);
///*pruebas MIL 8*/ MdispControl(m_Mildisplay, M_TRANSPARENT_COLOR, TRANSPARENTE);
muestra_punto(point_inicial.x,point_inicial.y, 3, TRANSPARENTE,0); // borramos el punto inicial
// MbufGet2d(M_overlay_normal,pos_x,pos_y,1,1, valor_pixel);
// muestra_punto(point_final.x,point_final.y, 3, color,0);
MgraColor(M_DEFAULT, color);
// MgraControl(M_DEFAULT, M_COLOR, M_RGB888(255,0,0) & M_RED);
// MgraControl(M_DEFAULT, M_COLOR, M_RGB888(0,255,0) & M_GREEN);
// MgraControl(M_DEFAULT, M_COLOR, M_RGB888(0,0,255) & M_BLUE);
//Por duplicado para que se vea cuando el factor de zoom sea negativo (display mas pequeño)
MgraRect(M_DEFAULT, M_overlay_normal, point_inicial.x, point_inicial.y, point_final.x, point_final.y);
MgraRect(M_DEFAULT, M_overlay_normal, point_inicial.x+1, point_inicial.y+1, point_final.x+1, point_final.y+1);
/*
MgraRect(M_DEFAULT, M_overlay_normal, point_inicial.x-1, point_inicial.y-1, point_final.x-1, point_final.y-1);
MgraRect(M_DEFAULT, M_overlay_normal, point_inicial.x+2, point_inicial.y+2, point_final.x+2, point_final.y+2);
MgraRect(M_DEFAULT, M_overlay_normal, point_inicial.x-2, point_inicial.y-2, point_final.x-2, point_final.y-2);
*/
}
MIL_INT MFTYPE ProcessingFunction(MIL_INT HookType, MIL_ID EventId, void MPTYPE *CallBackDataPtr)
{
/* Get the grabbed buffer. */
ProcessingDataStruct *ProcessingDataPtr = (ProcessingDataStruct *)CallBackDataPtr;
MIL_ID CurrentProcSrcBufId, CurrentProcDstBufId;
MIL_ID GrabbedBufferId;
MIL_INT GrabbedBufferIndex;
MIL_TEXT_CHAR Text[BUFFER_MAX_STRING_LENGTH];
MIL_DOUBLE RectHalfSizeStep = 0.0;
long RectStep = 0;
long NbSystem = ProcessingDataPtr->NbSystem;
long NbProcInitial = ProcessingDataPtr->NbProc;
long NbBufferToProcess, n;
/* Retrieve the buffer to process and it's index */
MdigGetHookInfo(EventId, M_MODIFIED_BUFFER+M_BUFFER_ID, &GrabbedBufferId);
MdigGetHookInfo(EventId, M_MODIFIED_BUFFER+M_BUFFER_INDEX, &GrabbedBufferIndex);
/* Reset the timer. */
if (ProcessingDataPtr->NbProc == 0)
MappTimer(M_TIMER_RESET+M_SYNCHRONOUS,&ProcessingDataPtr->Time);
/* If PROCESS_EACH_IMAGE_ON_ALL_SYSTEMS is set, each grabbed image is processed on all the systems.
To have each frame processed only once by one system in round robin fashion, set the define to M_NO.
*/
if (ProcessingDataPtr->ProcessEachImageOnAllSystems)
NbBufferToProcess = NbSystem;
else
NbBufferToProcess = 1;
/* Dispatch the job to the target processing system(s) */
for(n=0; n<NbBufferToProcess; n++)
{
/* Calculate target processing buffer. */
CurrentProcSrcBufId = ProcessingDataPtr->SrcProcBufferListPtr[(ProcessingDataPtr->NbProc)%(NbSystem*BUFFER_PER_PROCESSOR)];
CurrentProcDstBufId = ProcessingDataPtr->DstProcBufferListPtr[(ProcessingDataPtr->NbProc)%(NbSystem*BUFFER_PER_PROCESSOR)];
/* Copy the grabbed buffer to a processing platform. */
MbufCopy(GrabbedBufferId, CurrentProcSrcBufId);
/* Draw the buffer index in the source. */
MosSprintf(Text, BUFFER_MAX_STRING_LENGTH, MIL_TEXT("#%ld."), ProcessingDataPtr->NbProc);
MgraText(M_DEFAULT, CurrentProcSrcBufId, 50, 50, Text);
/* Process the buffer. */
#if (!M_MIL_LITE)
{
MimArith(CurrentProcSrcBufId, 0x10, CurrentProcDstBufId, M_SUB_CONST+M_SATURATION);
MimArith(CurrentProcDstBufId, M_NULL, CurrentProcSrcBufId, M_NOT);
MimRotate(CurrentProcSrcBufId, CurrentProcDstBufId,
(ProcessingDataPtr->NbProc*10)%360,
(MIL_DOUBLE) ProcessingDataPtr->SizeX/2,
(MIL_DOUBLE) ProcessingDataPtr->SizeY/2,
(MIL_DOUBLE) ProcessingDataPtr->SizeX/2,
(MIL_DOUBLE) ProcessingDataPtr->SizeY/2,
M_NEAREST_NEIGHBOR);
}
#else
{
RectStep = (ProcessingDataPtr->NbProc % BUFFER_DRAW_RECT_NUMBER);
if(RectStep < BUFFER_DRAW_INWARD_STEP_NUMBER)
RectHalfSizeStep = RectStep * BUFFER_DRAW_RECT_STEP;
else
RectHalfSizeStep = (BUFFER_DRAW_RECT_NUMBER - RectStep) * BUFFER_DRAW_RECT_STEP;
MgraColor(M_DEFAULT, 0xff);
MgraRectFill(M_DEFAULT,
CurrentProcDstBufId,
ProcessingDataPtr->SizeX/2 - RectHalfSizeStep,
ProcessingDataPtr->SizeY/2 - RectHalfSizeStep,
ProcessingDataPtr->SizeX/2 + RectHalfSizeStep,
ProcessingDataPtr->SizeY/2 + RectHalfSizeStep);
}
#endif
/* Count processed buffers. */
ProcessingDataPtr->NbProc++;
MosPrintf(MIL_TEXT("Processing #%ld.\r"), ProcessingDataPtr->NbProc);
}
/* If required, copy back the result buffers from the processing system(s) for display. */
#if (DISPLAY_EACH_IMAGE_PROCESSED)
{
for(n=0; n<NbBufferToProcess; n++)
{
/* Calculate target buffer for display. */
CurrentProcDstBufId = ProcessingDataPtr->DstProcBufferListPtr[(NbProcInitial+n)%(NbSystem*BUFFER_PER_PROCESSOR)];
/* Copy result to display. */
MbufCopy(CurrentProcDstBufId, ProcessingDataPtr->DispBuffer);
}
}
#endif
/* Read the timer. */
MappTimer(M_TIMER_READ+M_SYNCHRONOUS, &ProcessingDataPtr->Time);
#if M_MIL_USE_CE
/* Give execution time to user interface when the digitizer processing queue is full.
If necessary, the Sleep value can be increased to give more execution time to user interface.
*/
if(MdigInquire(ProcessingDataPtr->MilDigitizer, M_PROCESS_PENDING_GRAB_NUM, M_NULL) <= 1)
{
if ((ProcessingDataPtr->NbProc%10) == 0)
Sleep(2);
}
#endif
return(0);
}
/****************************************************************************
Escibe en consola el menu para la TomaUnica
Espera una tecla y la devuelve. Tambien devuelve la posicion cuando la tecla fue pulsada
AUXILIAR
*****************************************************************************/
int menuTomaUnica(point& punto)
{
char mensaje[LONGITUD_TEXTO*2];
sprintf(mensaje,"\n+- TOMA UNICA ------------------------------------------+");
strcat(mensaje, "\n| Posiciónese en la zona donde quiera tomar las imagenes |");
strcat(mensaje, "\n| Presione [A] para realizar enfoque automatico |");
strcat(mensaje, "\n| Presione [ENTER] proceder a la toma sin autoenfoque |");
strcat(mensaje, "\n| [Esc] - Para salir de la aplicacion |");
strcat(mensaje, "\n+----------------------------------------------------------+\n");
CharToOem(mensaje,mensaje);
printf(mensaje);
int tecla;
bool bDefiniendoArea = false;
float x = 0;
float y = 0;
do{
tecla = pideP(&punto);
if (tecla == ' ')
{
// Establecimiento de areas/areas de interes mediante raton
POINT cursorPos;
GetCursorPos(&cursorPos);
if (bDefiniendoArea)
{
muestra_pixel(x,y,NULL,1); //borramos el punto inicial
MgraColor(M_DEFAULT, M_COLOR_YELLOW);
MgraRect(M_DEFAULT, M_overlay_normal, x, y, cursorPos.x, cursorPos.y);
}
else
{
x = cursorPos.x;
y = cursorPos.y;
/*
// Control de posicionamiento fuera de ventana
// Funciona pero no esta en uso
long x_offset= -1,y_offset = -1, size_x = -1, size_y = -1;
MdispInquire(M_display_resul, M_WINDOW_OFFSET_X, &x_offset);
MdispInquire(M_display_resul, M_WINDOW_OFFSET_Y, &y_offset);
MdispInquire(M_display_resul, M_SIZE_X, &size_x);
MdispInquire(M_display_resul, M_SIZE_Y, &size_y);
if (x<x_offset || x>x_offset+size_x ||
y<y_offset || y>y_offset+size_y )
{
//mouse fuera de la ventana
printf("Atencion: mouse fuera de la ventana\r");
}
else
{
muestra_pixel(x-x_offset,y-y_offset,ROJO,0);
}*/
muestra_pixel(x,y,ROJO,0);
}
bDefiniendoArea = !bDefiniendoArea;
}
else if (bDefiniendoArea == true)
{
muestra_pixel(x,y,NULL,1); //borramos el punto inicial
}
} while (tecla != K_ESC && tecla != 'a' && tecla != 'A' && tecla != K_CR);
return tecla;
}
void muestra_aoi(parametros& param)
{
MgraColor(M_DEFAULT, M_COLOR_YELLOW);
MgraRect(M_DEFAULT, M_overlay_normal, param.Cam.anchoImagen/2 - m_nAnchoAOI/2, param.Cam.altoImagen/2 - m_nAnchoAOI/2,
param.Cam.anchoImagen/2 + m_nAnchoAOI/2, param.Cam.altoImagen/2 + m_nAnchoAOI/2);
}
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;
}
}
}
void MdispGtkView::GraphicLogo(MIL_INT PosX, MIL_INT PosY, MIL_INT CellSize)
{
MIL_DOUBLE MILYellow1 = M_RGB888(255, 201, 10);
MIL_DOUBLE MILYellow2 = M_RGB888(254, 189, 17);
MIL_DOUBLE MILYellow3 = M_RGB888(255, 230, 0);
MIL_DOUBLE MILYellow4 = M_RGB888(246, 139, 31);
MIL_DOUBLE MILGreen1 = M_RGB888( 0, 141, 76);
MIL_DOUBLE MILGreen2 = M_RGB888( 0, 101, 49);
MIL_DOUBLE MILGreen3 = M_RGB888( 0, 151, 78);
MIL_DOUBLE MILGreen4 = M_RGB888( 0, 167, 115);
MIL_DOUBLE MILRed1 = M_RGB888(209, 24, 32);
MIL_DOUBLE MILRed2 = M_RGB888(238, 49, 36);
MIL_DOUBLE MILRed3 = M_RGB888(189, 20, 27);
MIL_DOUBLE MILRed4 = M_RGB888(137, 3, 4);
MIL_DOUBLE MILPurple1 = M_RGB888(126, 69, 154);
MIL_DOUBLE MILPurple2 = M_RGB888( 76, 42, 125);
MIL_DOUBLE MILPurple3 = M_RGB888(111, 116, 182);
MIL_DOUBLE MILPurple4 = M_RGB888( 85, 79, 162);
MgraColor(m_MilGraphContext, MILYellow1);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX , PosY , CellSize*3, CellSize*3, 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILYellow2);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize , PosY+CellSize , CellSize , CellSize , 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILYellow3);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize*2, PosY+CellSize , CellSize , CellSize , 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILYellow4);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize , PosY+CellSize*2, CellSize , CellSize , 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILGreen1);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize*3, PosY , CellSize*3, CellSize*3, 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILGreen2);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize*3, PosY+CellSize , CellSize , CellSize , 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILGreen3);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize*4, PosY+CellSize , CellSize , CellSize , 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILGreen4);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize*4, PosY+CellSize*2, CellSize , CellSize , 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILRed1);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX , PosY+CellSize*3, CellSize*3, CellSize*3, 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILRed2);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize , PosY+CellSize*3, CellSize , CellSize , 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILRed3);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize*2, PosY+CellSize*4, CellSize , CellSize , 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILRed4);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize , PosY+CellSize*4, CellSize , CellSize , 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILPurple1);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize*3, PosY+CellSize*3, CellSize*3, CellSize*3, 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILPurple2);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize*4, PosY+CellSize*3, CellSize , CellSize , 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILPurple3);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize*3, PosY+CellSize*4, CellSize , CellSize , 0, M_CORNER_AND_DIMENSION+M_FILLED);
MgraColor(m_MilGraphContext, MILPurple4);
MgraRectAngle(m_MilGraphContext, m_MilGraphList, PosX+CellSize*4, PosY+CellSize*4, CellSize , CellSize , 0, M_CORNER_AND_DIMENSION+M_FILLED);
}
