/*
  * Khoros: $Id$
  */

#if !defined(__lint) && !defined(__CODECENTER__)
static char rcsid[] = "Khoros: $Id$";
#endif

/*
 * Copyright (C) 1997, INPE. Sergio Donizete Faria, Gerald Jean Francis Banon
 * All rights reserved.  See $K_PROG/repos/license/License.
 */

/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<
   >>>> 
   >>>> 	Main program for kminmaxmed
   >>>> 
   >>>>  Private: 
   >>>> 	main
   >>>> 
   >>>>   Static: 
   >>>>   Public: 
   >>>> 
   >>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<< */


#include "kminmaxmed.h"

clui_info_struct *clui_info = NULL;

/*-----------------------------------------------------------
|
|  Routine Name: main() - Compare two images and find the min max between them (nomr. by median)
|
|       Purpose: main program for kminmaxmed
|
|         Input:
|		char *clui_info->i_img_file; {Search image}
|		int   clui_info->i_img_flag; {TRUE if -i_img specified}
|
|		char *clui_info->t_img_file; {Template image}
|		int   clui_info->t_img_flag; {TRUE if -t_img specified}
|
|		char *clui_info->o_img_file; {Resulting output image}
|		int   clui_info->o_img_flag; {TRUE if -o_img specified}
|
|        Output:
|       Returns:
|
|    Written By: Sergio Donizete Faria
|          Date: November 5, 1997
| Modifications:
|
------------------------------------------------------------*/

int main(
   int  argc,
   char **argv)
{

/* -main_variable_list */
        kobject src;            /* source object - input search image */
        kobject template;       /* source object - input template image */
        kobject dest;           /* destination object - output image */
        kobject src_median  ;   /* destination object - source median */
        kobject template_median;/* destination object - template median */
        int src_width;          /* input image width (num cols) */
        int src_height;         /* input image height (num rows) */
        int src_depth;          /* depth and time give number of input images */
        int src_time;           
        int src_bands;          /* number of bands per input image */        
        int template_width;     /* template image width (num cols) */
        int template_height;    /* template image height (num rows) */
        int template_depth;     /* depth and time give number of template 
                                   images */
        int template_time;          
        int template_bands;     /* number of bands per template image */
        int num_row_template;
        int num_col_template;
        int size_template;
        int rep, num_regions;
        int i1, k0, k1, n;
        int hh, ii, jj, kk;
        int ii0, ii1;
        int index01, index1, aux1;
        int cen_win_src, cen_win_template;
        long src_norm, min_max; 
        long *template_data=NULL;
        long *template_median_data=NULL;
        long *src_data=NULL;
        long *src_median_data=NULL;
        long *dest_data=NULL;
/* -main_variable_list_end */

	khoros_init(argc, argv, "MATCHING", PRODUCT_RELEASE_DATE,
	            PRODUCT_RELEASE_NAME, PRODUCT_RELEASE_VERSION,
	            PRODUCT_RELEASE_MAJOR, PRODUCT_RELEASE_MINOR,
	            "$MATCHING/objects/kroutine/kminmaxmed");
	kexit_handler(kminmaxmed_free_args, NULL);

/* -main_get_args_call */
	kclui_init("MATCHING", "kminmaxmed", KGEN_KROUTINE,  &clui_uis_spec,
		   kminmaxmed_usage_additions, kminmaxmed_get_args,
 		   kminmaxmed_free_args);
/* -main_get_args_call_end */

/* -main_before_lib_call */
        /*
         * Open the source (src and template) and destination (dest) data
         * objects using kpds_open_input_object and kpds_open_output_object 
         * calls.These calls will open the source and destination data object 
         * with the flags set correctly. If an open fails, report the error 
         * using kerror, close opened objects if necessary, and exit the program
         * using kexit call.
         */

        if ((src = kpds_open_input_object (clui_info->i_img_file))
                == KOBJECT_INVALID)
          { 
           kerror(NULL, "kminmaxmed", "Cannot open source object src.");
           kexit(KEXIT_FAILURE);
          }

        if ((template = kpds_open_input_object (clui_info->t_img_file))
                == KOBJECT_INVALID)
          { 
           kerror(NULL, "kminmaxmed", "Cannot open source object template.");
           kexit(KEXIT_FAILURE);
           kpds_close_object(src);
          }

        if ((dest = kpds_open_output_object (clui_info->o_img_file))
                == KOBJECT_INVALID)
          { 
           kerror(NULL, "kminmaxmed", "Cannot open destination object.");
           kpds_close_object(src);
           kpds_close_object(template);
           kexit(KEXIT_FAILURE);
          }

        /*
         * Create data objects using kpds_create_object. If create fails,
         * report the error using kerror and exit the program using kexit call.
         */

        if ((src_median = kpds_create_object ())
                == KOBJECT_INVALID)
          { 
           kerror(NULL, "kminmaxmed", "Cannot create object src_median.");
           kexit(KEXIT_FAILURE);
          }
        if ((template_median = kpds_create_object ())
                == KOBJECT_INVALID)
          { 
           kerror(NULL, "kminmaxmed", "Cannot create object template_median.");
           kexit(KEXIT_FAILURE);
          }

        /*
         * Copy the search image object (src) to objects dest and src_median.
         * If the copy function fails, report the error and exit. The object
         * will be closed by kexit. Since, the exit status is KEXIT FAILURE the 
         * output object will not be writen to a perminent transport. 
         */

        if (! kpds_copy_object (src, dest))
          { 
           kerror(NULL, "kminmaxmed", "kpds_copy_object failed");
           kexit(KEXIT_FAILURE);
          }
        if (! kpds_copy_object (src, src_median))
          { 
           kerror(NULL, "kminmaxmed", "kpds_copy_object failed");
           kexit(KEXIT_FAILURE);
          }

        /*
         * Copy the image object (template) to object template_median.
         * If the copy function fails, report the error and exit. The object
         * will be closed by kexit (). Since, the exit status is KEXIT FAILURE
         * the output object will not be writen to a perminent transport. 
         */

        if (! kpds_copy_object (template, template_median))
          { 
           kerror(NULL, "kminmaxmed", "kpds_copy_object failed");
           kexit(KEXIT_FAILURE);
          }

        /*
         * Get the KPDS_VALUE_SIZE attribute of the source object (src) which  
         * provides the information about number of data elements in each
         * direction of source object.
         */

        if (! kpds_get_attribute (src, KPDS_VALUE_SIZE, &src_width, &src_height,
                                  &src_depth, &src_time, &src_bands))         
          { 
           kerror(NULL,"kminmaxmed",
                  "kpds_get_attribute failed for KPDS_VALUE_SIZE");
           kexit(KEXIT_FAILURE);
          }

        /*
         * Get the KPDS_VALUE__SIZE attribute of the template object which 
         * provides the information about number of data elements in each
         * direction of this object.
         */

        if (! kpds_get_attribute (template, KPDS_VALUE_SIZE, &template_width,
                                  &template_height, &template_depth, 
                                  &template_time, &template_bands))
          { 
           kerror(NULL,"kminmaxmed",
                  "kpds_get_attribute failed for KPDS_VALUE_SIZE");
           kexit(KEXIT_FAILURE);
          }


        /*
         * Specifying the size of the region to process by selection a set of
         * rows from the source image as the region process.
         * Set this region size to:
         *   - src_width       = width of region (width source image)
         *   - template_height = height of region
         *   - template_depth  = depth size of region
         *   - template_time   = time size of region
         *   - template_bands  = number of bands in the region 
         */

        if (! kpds_set_attribute (src, KPDS_VALUE_REGION_SIZE, src_width,
                                  template_height, template_depth, 
                                  template_time, template_bands))
          { 
           kerror("NULL", "kminmaxmed", 
                  "kpds_get_attribute failed for KPDS_VALUE_REGION_SIZE");
           kexit(KEXIT_FAILURE);
          }

        if (! kpds_set_attribute (dest, KPDS_VALUE_REGION_SIZE, src_width,
                                  template_height, template_depth, 
                                  template_time, template_bands))
          { 
           kerror("NULL", "kminmaxmed", 
                 "kpds_get_attribute failed for KPDS_VALUE_REGION_SIZE (dest)");
           kexit(KEXIT_FAILURE);
          }

        /*
         * Call routine to calculte the median of source image and template
         * image.
         */

          num_row_template = template_height;
          num_col_template = template_width;
          rep = 1;

          if (!limedian(src, num_col_template, num_row_template, rep,
                       src_median))
          kexit(KEXIT_FAILURE);

          if (!limedian(template, num_col_template, num_row_template, rep,
                       template_median))
          kexit(KEXIT_FAILURE);

        /*
         ***********************************************************************
         *                      Major loop for processing                      *
         ***********************************************************************
         */

        /*
         * Outer loops: variable h and i are the number of images in input
         * object.
         */

        cen_win_template = (template_height * template_width)/2;

        for (hh = 0; hh < src_time; hh++)
          {
	   for (ii = 0; ii < src_depth; ii++)
             {

	      /*
	       * 1st Middle loop: variable is the number of bands (elements)
	       * to process.
	       *   - src_bands = number of bands (elements) per image in source
               *                 object
	       */

	      for ( kk = 0; kk < src_bands; kk++) 
                {

                 /*
		  * Get a region of template data.
		  */

	         kpds_set_attribute(template,KPDS_VALUE_POSITION,0,0,ii,hh,kk);

		 template_data = (long *)(kpds_get_data(template,KPDS_VALUE_ALL,
                                                        template_data));
	         if (template_data == NULL)
                   {
	            kerror("NULL", "kminmaxmed",
                         "kpds_get_data failed for KPDS_VALUE_ALL (template).");
		    kexit(KEXIT_FAILURE);
		   }

                 kpds_set_attribute(template_median, KPDS_VALUE_POSITION, 0, 0,
                                    ii, hh, kk);
		 template_median_data = (long *) (kpds_get_data
                       (template_median, KPDS_VALUE_ALL, template_median_data));

	         if (template_median_data == NULL)
                   {
	            kerror("NULL", "kminmaxmed",
                  "kpds_get_data failed for KPDS_VALUE_ALL (template_median).");
		    kexit(KEXIT_FAILURE);
		   }

                  size_template = num_row_template * num_col_template;
                  cen_win_template = (template_height * template_width)/2;

                  for (i1 = 0; i1 < size_template; i1++)
                    {		      
                     template_data[i1] = template_data[i1] -
                                         template_median_data[cen_win_template];
                    }

                 /*
		  * 2nd Middle loop: variable is the number of regions to
                  * process
		  *   - num_regions = number of rows (height) of source object
		  */

	         num_regions = src_height;
                 jj = 0;

                 for (ii1 = template_height - 1; ii1<num_regions; ii1++)
                   {

		    /*
		     * Get a region of data and apply the operator across     
                     * that region.
		     */

		    kpds_set_attribute(src, KPDS_VALUE_POSITION, 0, jj, ii,
                                       hh, kk);
		    src_data = (long *)(kpds_get_data(src, KPDS_VALUE_REGION, 
					                src_data));
		    if (src_data == NULL)
                      {
		       kerror("NULL", "kminmaxmed",
                           "kpds_get_data failed for KPDS_VALUE_REGION (src).");
		       kexit(KEXIT_FAILURE);
		      }

		    kpds_set_attribute(src_median, KPDS_VALUE_POSITION, 0, jj,
                                       ii, hh, kk);
		    src_median_data = (long *)(kpds_get_data(src_median,
                                           KPDS_VALUE_REGION, src_median_data));
		    if (src_data == NULL)
                      {
		       kerror("NULL", "kminmaxmed",
                    "kpds_get_data failed for KPDS_VALUE_REGION (src_median).");
		       kexit(KEXIT_FAILURE);
		      }

		    /*
		     * Get a region of data in which temporarily store the     
                     * results of operator.
		     */

		    kpds_set_attribute(dest,KPDS_VALUE_POSITION,0,jj,ii,hh,kk);

		    dest_data = (long *) (kpds_get_data (dest,KPDS_VALUE_REGION,
                                                         dest_data));
		    if (dest_data == NULL)
                      {
		       kerror("NULL", "kminmaxmed",
                            "kpds_get_data failed for KPDS_VALUE_REGION dest.");
		       kexit(KEXIT_FAILURE);
		      }

		    /*
		     * Inner loop: variable is the number of columns of region 
                     * to be processed.
		     *   - src_width      = width of source object (input image)
                     *   - template_width = width of template image
 		     */

                    /*
		     *  Minimum Maxima Operator (normalized by median)
		     */

	            cen_win_src = template_height/2 * src_width +
                                  template_width/2;

                    for (ii0 = template_width - 1; ii0 < src_width; ii0++)
                      {
                       index1 = template_height - 1;
                       min_max = 0;
                       for (k1 = 0; k1 < template_height; k1++)
                         {
                          index01 = index1 * src_width + ii0;
                          for (k0 = 0; k0 < template_width; k0++)
                            {
                             n = template_width * template_height -
                                 template_width * k1 - k0 - 1;
                             src_norm = src_data[index01] -
                                        src_median_data[cen_win_src];
                             if (src_norm >= template_data[n])
                               {
                                if (src_norm < min_max) 
                                  {
                                   min_max = src_norm;
                                  }
                               }
                             else
                                if (template_data[n] < min_max)
                                  {
                                   min_max = template_data[n];
                                  }

                             index01--;
                            }
                          index1--;
                         }           
                       aux1 = ii0 - (((template_width - 1)/2) - 1) +
                                    (((template_width - 1)/2) * src_width - 1);
                       dest_data[aux1] = min_max;
                       cen_win_src ++;
                      }
                        
 	            if (! kpds_put_data(dest, KPDS_VALUE_REGION, dest_data))
                      {
	               kerror("NULL", "kminmaxmed",
                              "kpds_put_data failed for destination object.");
		       kexit(KEXIT_FAILURE);
                      }

                    jj++;
                  }
                } 
             }
          }/* end of loop */
/* -main_before_lib_call_end */

/* -main_library_call */
/* -main_library_call_end */

/* -main_after_lib_call */
       /* add history to the output object */

        if (!kpds_set_attribute(dest, KPDS_HISTORY, kpds_history_string()))
          {
           kerror("kminmaxmed", "main",
                  "Unable to set history on the destination object");
           kexit(KEXIT_FAILURE);
          }

       /*
        * If the library call succeeded, close the source, kernel and
        * destination data objects using kpds_close_object and exit
        * using kexit.
        */

        kpds_close_object(src);
        kpds_close_object(template);
        kpds_close_object(dest);
        kpds_close_object(src_median);
        kpds_close_object(template_median); 
/* -main_after_lib_call_end */


	kexit(KEXIT_SUCCESS);
        return KEXIT_SUCCESS;
}


/*-----------------------------------------------------------
| 
|  Routine Name: kminmaxmed_usage_additions
| 
|       Purpose: Prints usage additions in kminmaxmed_usage routine
| 
|         Input: None
| 
|        Output: None
|    Written By: ghostwriter -oname kminmaxmed
|          Date: July 1, 1997
| Modifications: 
| 
------------------------------------------------------------*/
void kminmaxmed_usage_additions(void)
{
	kfprintf(kstderr, "\tCompare two images and find the min max between them (nomr.\n");
	kfprintf(kstderr, "\tby median)\n");

/* -usage_additions */
/* -usage_additions_end */

}
/*-----------------------------------------------------------
| 
|  Routine Name: kminmaxmed_free_args
| 
|       Purpose: Frees CLUI struct allocated in kminmaxmed_get_args()
| 
|         Input: None
| 
|        Output: None
|    Written By: ghostwriter -oname kminmaxmed
|          Date: July 1, 1997
| Modifications: 
| 
------------------------------------------------------------*/
/* ARGSUSED */
void
kminmaxmed_free_args(
    kexit_status status,
    kaddr        client_data)
{

	/* do the wild and free thing */
	if (clui_info != NULL)
	{
		kfree_and_NULL(clui_info->i_img_file);
		kfree_and_NULL(clui_info->t_img_file);
		kfree_and_NULL(clui_info->o_img_file);
		kfree_and_NULL(clui_info);
	}

/* -free_handler_additions */
/* -free_handler_additions_end */
}