ContourFollower.cpp File Reference

#include "FirstIncludes.h"
#include <stdlib.h>
#include <memory>
#include <math.h>
#include <complex>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include "MemoryDebug.h"
#include "kku_fftw.h"
#include "ContourFollower.h"
#include "Raster.h"
#include "KKStr.h"

Go to the source code of this file.

Functions
float	CalcMagnitude (KK_DFT1D_Float::DftComplexType *dest, kkint32 index)
ComplexDouble **	GetFourierOneDimMask (kkint32 size)
ComplexDouble **	GetRevFourierOneDimMask (kkint32 size)

Variables
const MovDir	movements [8]

Function Documentation

float CalcMagnitude	(	KK_DFT1D_Float::DftComplexType *	dest,
		kkint32	index
	)

Definition at line 204 of file ContourFollower.cpp.

  {
    double rp = (float)dest[index].real ();
    double ip = (float)dest[index].imag ();
    return (float)sqrt (rp * rp + ip * ip);
  }  /* CalcMagnitude */

ComplexDouble** GetFourierOneDimMask

(

kkint32

size

)

Definition at line 842 of file ContourFollower.cpp.

{
  static  
  kkint32  curMaskSize = 0;

  static  
  ComplexDouble**  fourierMask = NULL;

  if  (size == curMaskSize)
    return  fourierMask;

  ComplexDouble  N(size, 0);
  ComplexDouble  M(size, 0);

  kkint32  x;

  if  (fourierMask)
  {
    for  (x = 0;  x < curMaskSize;  x++)
    {
      delete  fourierMask[x];
      fourierMask[x] = NULL;
    }

    delete[]  fourierMask;
    fourierMask = NULL;
  }

  fourierMask = new ComplexDouble*[size];
  for  (x = 0;  x < size;  x++)
  {
    fourierMask[x] = new ComplexDouble[size];
  }
  curMaskSize = size;


  ComplexDouble  j;
  ComplexDouble  MinusOne (-1, 0);
  j = sqrt (MinusOne);

  ComplexDouble  Pi  (3.14159265359, 0);
  ComplexDouble  One (1.0, 0);
  ComplexDouble  Two (2.0, 0);

  for  (kkint32 m = 0;  m < size;  m++)
  {
    complex<double>  mc (m, 0);

    for  (kkint32 k = 0; k < size; k++)
    {
      complex<double>  kc (k, 0);

      // double  xxx = 2 * 3.14159265359 * (double)k * (double)m / (double)size;

      // fourierMask[m][k] = exp (MinusOne * j * Two * Pi * kc * mc / M);
      fourierMask[m][k] = exp (MinusOne * j * Two * Pi * kc * mc / M);

      double  exponetPart = 2.0 * 3.14159265359 * (double)k * (double)m / (double)size;
      double  realPart = cos (exponetPart);
      double  imgPart  = -sin (exponetPart);

      if  (realPart != fourierMask[m][k].real ())
      {
        continue;
      }

      if  (imgPart != fourierMask[m][k].imag ())
      {
        continue;
      }
    }
  }

  return  fourierMask;
}  /* GetFourierOneDimMask */

ComplexDouble** GetRevFourierOneDimMask

(

kkint32

size

)

Definition at line 921 of file ContourFollower.cpp.

{
  static  
  kkint32  curRevMaskSize = 0;

  static  
  ComplexDouble**  revFourierMask = NULL;


  if  (size == curRevMaskSize)
    return  revFourierMask;

  ComplexDouble  N(size, 0);
  ComplexDouble  M(size, 0);

  kkint32  x;
  

  if  (revFourierMask)
  {
    for  (x = 0;  x < curRevMaskSize;  x++)
    {
      delete  revFourierMask[x];
      revFourierMask[x] = NULL;
    }

    delete[]  revFourierMask;
    revFourierMask = NULL;
  }


  revFourierMask = new ComplexDouble*[size];
  for  (x = 0;  x < size;  x++)
  {
    revFourierMask[x] = new ComplexDouble[size];
  }
  curRevMaskSize = size;

  ComplexDouble  j;
  ComplexDouble  MinusOne (-1, 0);
  ComplexDouble  PositiveOne (1, 0);
  j = sqrt (MinusOne);

  ComplexDouble  Pi  (3.1415926, 0);
  ComplexDouble  One (1.0, 0);
  ComplexDouble  Two (2.0, 0);

  for  (kkint32 m = 0;  m < size;  m++)
  {
    complex<double>  mc (m, 0);

    for  (kkint32 k = 0; k < size; k++)
    {
      complex<double>  kc (k, 0);

      // double  xxx = 2 * 3.14159265359 * (double)k * (double)m / (double)size;

      // fourierMask[m][k] = exp (MinusOne * j * Two * Pi * kc * mc / M);
      revFourierMask[m][k] = exp (PositiveOne * j * Two * Pi * kc * mc / M);


      double  exponetPart = 2.0 * 3.14159265359 * (double)k * (double)m / (double)size;
      double  realPart = cos (exponetPart);
      double  imgPart  = sin (exponetPart);

      if  (realPart != revFourierMask[m][k].real ())
      {
        continue;
      }

      if  (imgPart != revFourierMask[m][k].imag ())
      {
        continue;
      }
    }
  }

  return  revFourierMask;
}  /* GetRevFourierOneDimMask */

Variable Documentation

const MovDir movements[8]

Initial value:

= {{-1,  0}, 
                          {-1,  1}, 
                          { 0,  1}, 
                          { 1,  1}, 
                          { 1,  0}, 
                          { 1, -1}, 
                          { 0, -1}, 
                          {-1, -1}  
                         }

Definition at line 34 of file ContourFollower.cpp.