---

com2real.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 separates one "complex" image into two "real" images.      */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void
COM2REAL (IMAGE * in,           /*  I   Pointer to the input image.                           */
          short option,         /*  I   Switch, indicating the type of real images:           */
          /*      REIMAG   -   real and imaginary images are computed.  */
          /*      MAGPHA   -   magnitude and phase images are computed. */
          IMAGE ** out1,        /*  O   Address of a pointer to the output image              */
          /*      containing the real/magnitude component.              */
          IMAGE ** out2         /*  O   Address of a pointer to the output image              */
          /*      containing the imaginary/phase component.             */
/*----------------------------------------------------------------------------*/
  )
{
  register short i, j, k, n;
  char msg[SLEN];
  double re, im;

  if (TIMES)
    TIMING (T_COM2REAL);
  if (NAMES)
    {
      MESSAGE ('I', "");
      MESSAGE ('I', "COM2REAL");
      MESSAGE ('I', "");
      sprintf (msg, " Input image:  %s", in->text);
      MESSAGE ('I', msg);
      if (option == REIMAG)
        {
          MESSAGE ('I', " Real and imaginary images computed");
        }
      else if (option == MAGPHA)
        {
          MESSAGE ('I', " Magnitude and phase images computed");
        }
      MESSAGE ('I', "");
      MESSAGE ('I', " ...............");
    }

  /* check input */
  if (!CHECKIMG (in))
    {
      MESSAGE ('E', " Can't identify image.");
      goto the_end;
    }
  else if (in->npix % 2 != 0)
    {
      MESSAGE ('E', " Number of pixels/line must be even.");
      goto the_end;
    }
  else if (option != REIMAG && option != MAGPHA)
    {
      MESSAGE ('E', " Option must be either REIMAG or MAGPHA.");
      goto the_end;
    }

  /* create image of appropriate size */
  if (!CHECKIMG (*out1))
    GETMEM (in->nbnd, in->nlin, in->npix / 2, out1);
  if (!*out1)
    goto the_end;
  if (!CHECKIMG (*out2))
    GETMEM (in->nbnd, in->nlin, in->npix / 2, out2);
  if (!*out2)
    goto the_end;

  if (option == REIMAG)
    {
      /* separate real and imaginary parts */
      for (i = 0; i < in->nbnd; i++)
        {
          for (j = 0; j < in->nlin; j++)
            {
              for (k = 0, n = 0; k < in->npix / 2; k += 1, n += 2)
                {
                  (*out1)->data[i][j][k] = in->data[i][j][n];
                  (*out2)->data[i][j][k] = in->data[i][j][n + 1];
                }
            }
        }
    }
  else                          /* (option == MAGPHA) */
    {
      /* calculate magnitude and phase parts */
      for (i = 0; i < in->nbnd; i++)
        {
          for (j = 0; j < in->nlin; j++)
            {
              for (k = 0, n = 0; k < in->npix / 2; k += 1, n += 2)
                {
                  re = (double) in->data[i][j][n];
                  im = (double) in->data[i][j][n + 1];
                  (*out1)->data[i][j][k] = (PIXEL) sqrt ((re * re + im * im));
                  if (re == 0.0)
                    {
                      if (im > 0.0)
                        {
                          (*out2)->data[i][j][k] = (PIXEL) (PI / 2.0);
                        }
                      else if (im < 0.0)
                        {
                          (*out2)->data[i][j][k] = (PIXEL) (-PI / 2.0);
                        }
                      else      /* (im == 0.0 ) */
                        {
                          (*out2)->data[i][j][k] = (PIXEL) 0.0;
                        }
                    }
                  else
                    {
                      (*out2)->data[i][j][k] = (PIXEL) atan2 (im, re);
                    }
                }
            }
        }
    }

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

---