/************************************************************************************/
/*
 * File name: MdispWindowLeveling.c
 *
 * Synopsis:  This MIL program shows how to display a 10-bit monochrome Medical image
 *            and applies a LUT to do interactive Window Leveling.
 */
#include <mil.h>
#include <conio.h>
#include <stdlib.h>

/* Image file to load. */
#define IMAGE_FILE                     M_IMAGE_PATH MIL_TEXT("ArmsMono10bit.mim")

/* Visible number of bits (8, 10, 12... or ImageSizeBit (for full range). */
#define IMAGE_NUMBER_OF_VISIBLE_BITS   10

/* Draw the LUT shape (if disabled reduces CPU usage). */
#define DRAW_LUT_SHAPE                 M_YES

/* Utility functions. */
long MaxImageValue(MIL_ID MilImage, long NumberOfVisibleBits);
void DrawLutShape(MIL_ID MilDisplay, MIL_ID MilOriginalImage, MIL_ID MilImage, long Start,
             long End, long InflexionIntensity, long ImageMaxValue, long DisplayMaxValue);


void main(void)
{
   MIL_ID MilApplication,       /* Application identifier.    */
          MilSystem,            /* System identifier.         */
          MilDisplay,           /* Display identifier.        */
          MilImage,             /* Image buffer identifier.   */
          MilOriginalImage = 0, /* Image buffer identifier.   */
          MilLut;               /* Lut buffer identifier.     */
   long   ImageSizeX, ImageSizeY, ImageMaxValue;
   long   DisplaySizeBit, DisplayMaxValue;
   long   Start, End, Step, InflectionLevel;
   unsigned char Ch;

   /* Allocate the MIL Application, System and Display. */
   MappAllocDefault(M_SETUP, &MilApplication, &MilSystem, &MilDisplay, M_NULL, M_NULL);

   /* Restore target image from disk. */
   MbufRestore(IMAGE_FILE, MilSystem, &MilImage);

   /* Set the maximum value of the image to indicate to MIL
      how to initialize the default display LUT.
   */
   ImageMaxValue = MaxImageValue(MilImage, IMAGE_NUMBER_OF_VISIBLE_BITS);
   MbufControl(MilImage, M_MAX, ImageMaxValue);

   /* Display the image (to specify a user-defined window, use MdispSelectWindow()). */
   MdispSelect(MilDisplay, MilImage);

   /* Determine the maximum displayable value of the current display. */
   MdispInquire(MilDisplay, M_SIZE_BIT, &DisplaySizeBit);
   DisplayMaxValue = (1<<DisplaySizeBit)-1;

   /* Print key information. */
   printf("\nWINDOW LEVELING:\n");
   printf("----------------\n\n");

   MOs_printf("Image name : %s\n",IMAGE_FILE);

   printf("Image size : %ld x %ld\n", MbufInquire(MilImage, M_SIZE_X, &ImageSizeX), MbufInquire(MilImage, M_SIZE_Y, &ImageSizeY));
   printf("Image max  : %4ld\n",   ImageMaxValue);
   printf("Display max: %4ld\n\n", DisplayMaxValue);
   printf("Press <Enter> to do interactive Window Leveling.\n\n");
   getch();

   /* Allocate a LUT buffer according to the image maximum value and display pixel depth. */
   MbufAlloc1d(MilSystem, ImageMaxValue+1, ((DisplaySizeBit>8) ? 16 : 8)+M_UNSIGNED, M_LUT, &MilLut);

   /* Generate a LUT with a full range ramp and set its maximum value. */
   MgenLutRamp(MilLut, 0, 0, ImageMaxValue, DisplayMaxValue);
   MbufControl(MilLut, M_MAX, DisplayMaxValue);

   /* Set the display LUT. */
   MdispLut(MilDisplay, MilLut);

   /* Interactive Window Leveling using keyboard. */
   printf("Position keys : Left=move Left, Right=move Right, Down=Narrow, Up=Wider.\n");
   printf("Intensity keys: L=Lower,  U=Upper,  R=Reset.\n");
   printf("Press <Enter> to end.\n\n");

   /* Modify LUT shape according to the arrow keys and update it. */
   Ch = 0;
   Start = 0;
   End = ImageMaxValue;
   InflectionLevel = DisplayMaxValue;
   Step = (ImageMaxValue+1)/128;
   Step = max(Step,4);
   while (Ch != '\r')
      {
      switch (Ch)
         {
         /* Left arrow: Move region left. */
         case 0x4B:
            { Start-=Step; End-=Step; break; }

         /* Right arrow: Move region right. */
         case 0x4D:
            { Start+=Step; End+=Step; break; }

         /* Down arrow: Narrow region. */
         case 0x50:
            { Start+=Step; End-=Step; break; }

         /* Up arrow: Widen region. */
         case 0x48:
            { Start-=Step, End+=Step; break; }

         /* L key: Lower inflexion point. */
         case 'L':
         case 'l':
            { InflectionLevel--; break; }

         /* U key: Upper inflexion point. */
         case 'U':
         case 'u':
            { InflectionLevel++; break; }

         /* R key: Reset the LUT to full image range. */
         case 'R':
         case 'r':
            { Start=0; End=ImageMaxValue; InflectionLevel=DisplayMaxValue; break; }

         }

      /* Saturate. */
      End   = min(End,ImageMaxValue);
      Start = min(Start,End);
      End   = max(End,Start);
      Start = max(Start,0);
      End   = max(End,0);
      InflectionLevel = max(InflectionLevel, 0);
      InflectionLevel = min(InflectionLevel, DisplayMaxValue);
      printf("Inflection points: Low=(%ld,0), High=(%ld,%ld).   \r", Start, End, InflectionLevel);

      /* Generate a LUT with 3 slopes and saturated at both ends. */
      MgenLutRamp(MilLut, 0, 0, Start, 0);
      MgenLutRamp(MilLut, Start, 0, End, InflectionLevel);
      MgenLutRamp(MilLut, End, InflectionLevel, ImageMaxValue, DisplayMaxValue);

      /* Update the display LUT. */
      MdispLut(MilDisplay, MilLut);

      /* Draw the current LUT's shape in the image.
         Note: This simple annotation method requires
               significant update and CPU time.
      */
      if (DRAW_LUT_SHAPE)
         {
         if (!MilOriginalImage)
            MbufRestore(IMAGE_FILE, MilSystem, &MilOriginalImage);
         DrawLutShape(MilDisplay, MilOriginalImage, MilImage, Start, End,
                                  InflectionLevel, ImageMaxValue, DisplayMaxValue);
         }

      /* If its an arrow key, get the second code. */
      if ((Ch = getch()) == 0xE0)
           Ch = getch();
      }
   printf("\n\n");

   /* Free all allocations. */
   MbufFree(MilLut);
   MbufFree(MilImage);
   if (MilOriginalImage)
      MbufFree(MilOriginalImage);
   MappFreeDefault(MilApplication, MilSystem, MilDisplay, M_NULL, M_NULL);
}

/* Function to calculate the maximum value of an image. */
long MaxImageValue(MIL_ID MilImage, long NumberOfVisibleBits)
   {
   MIL_ID MilExtremeResult = M_NULL;
   long ImageMaxValue, ImageSizeBit = 0;

   /* Determine and set the maximum value of the image. */
   #if (M_MIL_LITE)
      {
       /* Relies on the number of bits of the user-specified image but saturates if necessary. */
       MbufInquire(MilImage, M_SIZE_BIT, &ImageSizeBit);
       NumberOfVisibleBits = min(NumberOfVisibleBits, ImageSizeBit);
       ImageMaxValue = (1<<NumberOfVisibleBits)-1;
      }
   #else
      {
      /* Dynamically calculates the maximum value of the image using processing. */
      MimAllocResult(MbufInquire(MilImage, M_OWNER_SYSTEM, M_NULL), 1L,
                                           M_EXTREME_LIST, &MilExtremeResult);
      MimFindExtreme(MilImage, MilExtremeResult, M_MAX_VALUE);
      MimGetResult(MilExtremeResult, M_VALUE, &ImageMaxValue);
      MimFree(MilExtremeResult);
      }
   #endif

    return (ImageMaxValue);
   }

/* Function to draw the current LUT's shape in the image.

   Note: This simple annotation method requires significant update
          and CPU time since it repaints the entire image every time.
*/
void DrawLutShape(MIL_ID MilDisplay, MIL_ID MilOriginalImage, MIL_ID MilImage, long Start,
             long End, long InflectionIntensity, long ImageMaxValue, long DisplayMaxValue)
   {
    double         Xstart, Xend, Xstep, Ymin, Yinf, Ymax, Ystep;
    long           ImageSizeX, ImageSizeY;
    MIL_TEXT_CHAR  String[8];

    /* Inquire image dimensions. */
    MbufInquire(MilImage, M_SIZE_X, &ImageSizeX);
    MbufInquire(MilImage, M_SIZE_Y, &ImageSizeY);

    /* Calculate the drawing parameters. */
    Xstep  = (double)ImageSizeX/(double)ImageMaxValue;
    Xstart = Start*Xstep;
    Xend   = End*Xstep;
    Ystep  = ((double)ImageSizeY/4.0)/(double)DisplayMaxValue;
    Ymin   = (ImageSizeY-2);
    Yinf   = Ymin-(InflectionIntensity*Ystep);
    Ymax   = Ymin-(DisplayMaxValue*Ystep);

    /* To increase speed, disable display update until all annotations are done. */
    MdispControl(MilDisplay, M_UPDATE, M_DISABLE);

    /* Restore the original image. */
    MbufCopy(MilOriginalImage, MilImage);

    /* Draw axis max and min values. */
    MgraColor(M_DEFAULT, ImageMaxValue);
    MgraText(M_DEFAULT, MilImage, 4, (long)Ymin-22, MIL_TEXT("0"));
    MOs_sprintf(String, MIL_TEXT("%ld"), DisplayMaxValue);
    MgraText(M_DEFAULT, MilImage, 4, (long)Ymax-16, String);
    MOs_sprintf(String, MIL_TEXT("%ld"), ImageMaxValue);
    MgraText(M_DEFAULT, MilImage, ImageSizeX-38 , (long)Ymin-22, String);

    /* Draw LUT Shape (X axis is display values and Y is image values). */
    MgraLine(M_DEFAULT, MilImage, 0, (long)Ymin, (long)Xstart, (long)Ymin);
    MgraLine(M_DEFAULT, MilImage, (long)Xstart, (long)Ymin, (long)Xend, (long)Yinf);
    MgraLine(M_DEFAULT, MilImage, (long)Xend, (long)Yinf, ImageSizeX-1, (long)Ymax);

    /* Enable display update to show the result. */
    MdispControl(MilDisplay, M_UPDATE, M_ENABLE);
   }