/*
  * 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 ksmincbsum
   >>>> 
   >>>>  Private: 
   >>>> 	main
   >>>> 
   >>>>   Static: 
   >>>>   Public: 
   >>>> 
   >>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<< */


#include "ksmincbsum.h"

clui_info_struct *clui_info = NULL;

/*-----------------------------------------------------------
|
|  Routine Name: main() - Sum of Minima Normalized by Sum (City Block Distance)
|
|       Purpose: main program for ksmincbsum
|
|         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: June 25, 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 */
        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_regions;
        int h, i, j, k, n;
        int i0, i1, k0, k1;
        int index0, index1, aux1;
        double sum_min; 
        double sum_src_template;
        double summin_div_sumsrctemplate; 
        double *template_data=NULL;
        double *src_data=NULL;
        double *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/ksmincbsum");
	kexit_handler(ksmincbsum_free_args, NULL);

/* -main_get_args_call */
	kclui_init("MATCHING", "ksmincbsum", KGEN_KROUTINE,  &clui_uis_spec,
		   ksmincbsum_usage_additions, ksmincbsum_get_args,
 		   ksmincbsum_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, "ksmincbsum", "Cannot open source object src.");
           kexit(KEXIT_FAILURE);
          }

        if ((template = kpds_open_input_object (clui_info->t_img_file))
                == KOBJECT_INVALID)
          { 
           kerror(NULL, "ksmincbsum", "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, "ksmincbsum", "Cannot open destination object.");
           kpds_close_object(src);
           kpds_close_object(template);
           kexit(KEXIT_FAILURE);
          }

        /*
         * Copy the source object src to destination object. 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, "ksmincbsum", "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,"ksmincbsum",
                  "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,"ksmincbsum",
                  "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", "ksmincbsum",
                  "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", "ksmincbsum",
                 "kpds_get_attribute failed for KPDS_VALUE_REGION_SIZE (dest)");
           kexit(KEXIT_FAILURE);
          }


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

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

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

        for (h = 0; h < src_time; h++)
          {
	   for (i = 0; i < src_depth; i++)
             {
	      /*
	       * 1st Middle loop: variable is the number of bands (elements)
	       * to process.
	       *   - src_bands = number of bands (elements) per image in source
               *                 object
	       */

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

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

	         num_regions = src_height;
                 j = 0;

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

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

		    kpds_set_attribute(src, KPDS_VALUE_POSITION, 0, j, i, h, k);

		    src_data = (double *)(kpds_get_data(src, KPDS_VALUE_REGION, 
					                src_data));
		    if (src_data == NULL)
                      {
		       kerror("NULL", "ksmincbsum",
                             "kpds_get_data failed for KPDS_VALUE_REGION src.");
		       kexit(KEXIT_FAILURE);
		      }

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

		    kpds_set_attribute(dest,KPDS_VALUE_POSITION, 0, j, i, h, k);

		    dest_data = (double *)(kpds_get_data(dest,KPDS_VALUE_REGION,
                                                         dest_data));
		    if (dest_data == NULL)
                      {
		       kerror("NULL", "ksmincbsum",
                            "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
 		     */

                    /*
		     * Sum of Minima Operator.
		     */

                    for (i0 = template_width - 1; i0 < src_width; i0++)
                      {
                       sum_min = 0;
                       sum_src_template = 0;
                       index1 = template_height - 1;
                       for (k1 = 0; k1 < template_height; k1++)
                         {
                          index0 = index1 * src_width + i0;
                          for (k0 = 0; k0 < template_width; k0++)
                            {
                             n = template_width * template_height -
                                 template_width * k1 - k0 - 1;
                             if (src_data[index0] <= template_data[n])
                               {
                                sum_min += src_data[index0];
                               }
                             else
                               {
                                sum_min += template_data[n];
                               }
                             sum_src_template += src_data[index0] + 
                                                 template_data[n]; 
                             index0--;
                            }
                          index1--;
                         }           
                       summin_div_sumsrctemplate = sum_min / sum_src_template;
                       aux1 = i0 - (((template_width - 1)/2) - 1) +
                                   (((template_width - 1)/2) * src_width - 1);
                       dest_data[aux1] = summin_div_sumsrctemplate;
                      }                        
 	            if (! kpds_put_data(dest, KPDS_VALUE_REGION, dest_data))
                      {
	               kerror("NULL", "ksmincbsum",
                              "kpds_put_data failed for destination object.");
		       kexit(KEXIT_FAILURE);
                      }
                    j++;
                  }
                } 
             }
          }/* 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("ksmincbsum", "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);

/* -main_after_lib_call_end */


	kexit(KEXIT_SUCCESS);
        return KEXIT_SUCCESS;
}


/*-----------------------------------------------------------
| 
|  Routine Name: ksmincbsum_usage_additions
| 
|       Purpose: Prints usage additions in ksmincbsum_usage routine
| 
|         Input: None
| 
|        Output: None
|    Written By: ghostwriter -oname ksmincbsum
|          Date: July 1, 1997
| Modifications: 
| 
------------------------------------------------------------*/
void ksmincbsum_usage_additions(void)
{
	kfprintf(kstderr, "\tSum of Minima Normalized by Sum (City Block Distance)\n");

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

}
/*-----------------------------------------------------------
| 
|  Routine Name: ksmincbsum_free_args
| 
|       Purpose: Frees CLUI struct allocated in ksmincbsum_get_args()
| 
|         Input: None
| 
|        Output: None
|    Written By: ghostwriter -oname ksmincbsum
|          Date: July 1, 1997
| Modifications: 
| 
------------------------------------------------------------*/
/* ARGSUSED */
void
ksmincbsum_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 */
}