---

combine.c

Go to the documentation of this file.

#include        "sadie.h"

/*-Copyright Information------------------------------------------------------*/
/* Copyright (c) 1990 by the University of Arizona Digital Image Analysis Lab */
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This function computes a weighted linear combination of two images.      */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
COMBINE (IMAGE * in1,           /*  I   Pointer to the first input image.                     */
         IMAGE * in2,           /*  I   Pointer to the second input image.                    */
         short option,          /*  I   Switch, indicating type of combination operation:     */
         /*      ADD      - Sum of the input images is computed.       */
         /*      SUBTRACT - Difference of the input images is computed. */
         /*      MULTIPLY - Product of the input images is computed.   */
         /*      DIVIDE   - Quotient of the input images is computed.  */
         /*      MINIMUM  - Minimum of the input images is computed.   */
         /*      MAXIMUM  - Maximum of the input images is computed.   */
         double wgt1,           /*  I   Weight on the first input image.                      */
         double wgt2,           /*  I   Weight on the second input image.                     */
         IMAGE ** out           /*  O   Address of a pointer to the output image.             */
         /*      An input image may be overwritten (out = &in1,&in2).  */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k;
  double factor;
  char msg[SLEN];

  if (TIMES)
    TIMING (T_COMBINE);
  if (NAMES)
    {
      MESSAGE ('I', "");
      MESSAGE ('I', "COMBINE");
      MESSAGE ('I', "");
      sprintf (msg, " First input image:        %s", in1->text);
      MESSAGE ('I', msg);
      sprintf (msg, " Second input image:       %s", in2->text);
      MESSAGE ('I', msg);
      if (option == ADD)
        {
          MESSAGE ('I', " Operation:                add");
        }
      else if (option == SUBTRACT)
        {
          MESSAGE ('I', " Operation:                subtract");
        }
      else if (option == MULTIPLY)
        {
          MESSAGE ('I', " Operation:                multiply");
        }
      else if (option == DIVIDE)
        {
          MESSAGE ('I', " Operation:                divide");
        }
      else if (option == MINIMUM)
        {
          MESSAGE ('I', " Operation:                minimum");
        }
      else if (option == MAXIMUM)
        {
          MESSAGE ('I', " Operation:                maximum");
        }
      sprintf (msg, " Weight on first image:  %12.4e", wgt1);
      MESSAGE ('I', msg);
      sprintf (msg, " Weight on second image: %12.4e", wgt2);
      MESSAGE ('I', msg);
      MESSAGE ('I', " ...............");
    }

  /* check input */
  if (!CHECKIMG (in1))
    {
      MESSAGE ('E', " Can't identify first image.");
      goto the_end;
    }
  else if (!CHECKIMG (in2))
    {
      MESSAGE ('E', " Can't identify second image.");
      goto the_end;
    }
  else if (in1->nbnd != in2->nbnd)
    {
      MESSAGE ('E', " Number of bands must be identical in both images.");
      goto the_end;
    }
  else if (in1->nlin != in2->nlin)
    {
      MESSAGE ('E', " Number of lines must be identical in both images.");
      goto the_end;
    }
  else if (in1->npix != in2->npix)
    {
      MESSAGE ('E',
               " Number of pixels/line must be identical in both images.");
      goto the_end;
    }
  else if (option != ADD && option != SUBTRACT && option != MULTIPLY
           && option != DIVIDE && option != MINIMUM && option != MAXIMUM)
    {
      MESSAGE ('E',
               " Option must be one of ADD, SUBTRACT, MULTIPLY, DIVIDE, MINIMUM, or MAXIMUM.");
      goto the_end;
    }
  else if (option == DIVIDE && wgt2 == 0.0)
    {
      MESSAGE ('E', " Denominator weight must not be equal to zero.");
      goto the_end;
    }

  /* create image of appropriate size */
  if (!CHECKIMG (*out))
    GETMEM (in1->nbnd, in1->nlin, in1->npix, out);
  if (!*out)
    goto the_end;

  switch (option)
    {
    case ADD:
      /* add two images */
      for (i = 0; i < in1->nbnd; i++)
        {
          for (j = 0; j < in1->nlin; j++)
            {
              for (k = 0; k < in1->npix; k++)
                {
                  (*out)->data[i][j][k] =
                    (PIXEL) ((double) in1->data[i][j][k] * wgt1 +
                             (double) in2->data[i][j][k] * wgt2);
                }
            }
        }
      break;
    case SUBTRACT:
      /* subtract two images */
      for (i = 0; i < in1->nbnd; i++)
        {
          for (j = 0; j < in1->nlin; j++)
            {
              for (k = 0; k < in1->npix; k++)
                {
                  (*out)->data[i][j][k] =
                    (PIXEL) ((double) in1->data[i][j][k] * wgt1 -
                             (double) in2->data[i][j][k] * wgt2);
                }
            }
        }
      break;
    case MULTIPLY:
      /* multiply two images */
      factor = wgt1 * wgt2;
      for (i = 0; i < in1->nbnd; i++)
        {
          for (j = 0; j < in1->nlin; j++)
            {
              for (k = 0; k < in1->npix; k++)
                {
                  (*out)->data[i][j][k] =
                    (PIXEL) ((double) in1->data[i][j][k] *
                             (double) in2->data[i][j][k] * factor);
                }
            }
        }
      break;
    case DIVIDE:
      /* divide two images */
      factor = wgt1 / wgt2;
      for (i = 0; i < in1->nbnd; i++)
        {
          for (j = 0; j < in1->nlin; j++)
            {
              for (k = 0; k < in1->npix; k++)
                {
                  if (in2->data[i][j][k] == (PIXEL) 0)
                    {
                      (*out)->data[i][j][k] =
                        k == 0 ? (PIXEL) 0 : (*out)->data[i][j][k - 1];
                    }
                  else
                    {
                      (*out)->data[i][j][k] =
                        (PIXEL) ((double) in1->data[i][j][k] /
                                 (double) in2->data[i][j][k] * factor);
                    }
                }
            }
        }
      break;
    case MINIMUM:
      /* find minimum of two images */
      for (i = 0; i < in1->nbnd; i++)
        {
          for (j = 0; j < in1->nlin; j++)
            {
              for (k = 0; k < in1->npix; k++)
                {
                  (*out)->data[i][j][k] =
                    (PIXEL) min ((double) in1->data[i][j][k] * wgt1,
                                 (double) in2->data[i][j][k] * wgt2);
                }
            }
        }
      break;
    case MAXIMUM:
      /* find maximum of two images */
      for (i = 0; i < in1->nbnd; i++)
        {
          for (j = 0; j < in1->nlin; j++)
            {
              for (k = 0; k < in1->npix; k++)
                {
                  (*out)->data[i][j][k] =
                    (PIXEL) max ((double) in1->data[i][j][k] * wgt1,
                                 (double) in2->data[i][j][k] * wgt2);
                }
            }
        }
      break;
    }

the_end:
  if (TIMES)
    TIMING (T_EXIT);
}

---