X-Git-Url: http://git.kpe.io/?p=ctsim.git;a=blobdiff_plain;f=libctsim%2Ffilter.cpp;h=1eda2366ef5da6f70616562edb32a15a2df0c1f6;hp=a0638b2a1b9538b313d22188f47246a26e7a32c6;hb=286d655a25df2668bd65ad365676c6ecc94415a1;hpb=04c6595c9b3a36151671fd8f697f8a9a38dce735

diff --git a/libctsim/filter.cpp b/libctsim/filter.cpp
index a0638b2..1eda236 100644
--- a/libctsim/filter.cpp
+++ b/libctsim/filter.cpp
@@ -9,7 +9,7 @@
 **  This is part of the CTSim program
 **  Copyright (C) 1983-2000 Kevin Rosenberg
 **
-**  $Id: filter.cpp,v 1.19 2000/07/20 11:17:31 kevin Exp $
+**  $Id: filter.cpp,v 1.20 2000/07/22 15:45:33 kevin Exp $
 **
 **  This program is free software; you can redistribute it and/or modify
 **  it under the terms of the GNU General Public License (version 2) as
@@ -27,57 +27,98 @@
 
 #include "ct.h"
 
-
 int SignalFilter::N_INTEGRAL=500;  //static member
 
-// Filters
-const char SignalFilter::FILTER_ABS_BANDLIMIT_STR[] = "abs_bandlimit";
-const char SignalFilter::FILTER_ABS_SINC_STR[] = "abs_sinc";
-const char SignalFilter::FILTER_ABS_COS_STR[] = "abs_cos";
-const char SignalFilter::FILTER_ABS_HAMMING_STR[] = "abs_hamming";
-const char SignalFilter::FILTER_SHEPP_STR[] = "shepp";
-const char SignalFilter::FILTER_BANDLIMIT_STR[] = "bandlimit";
-const char SignalFilter::FILTER_SINC_STR[] = "sinc";
-const char SignalFilter::FILTER_COS_STR[] = "cos";
-const char SignalFilter::FILTER_HAMMING_STR[] = "hamming";
-const char SignalFilter::FILTER_TRIANGLE_STR[] = "triangle";
-
-const char SignalFilter::FILTER_ABS_BANDLIMIT_TITLE_STR[] = "Abs(w) * Bandlimit";
-const char SignalFilter::FILTER_ABS_SINC_TITLE_STR[] = "Abs(w) * Sinc";
-const char SignalFilter::FILTER_ABS_COS_TITLE_STR[] = "Abs(w) * Cos";
-const char SignalFilter::FILTER_ABS_HAMMING_TITLE_STR[] = "Abs(w) * Hamming";
-const char SignalFilter::FILTER_SHEPP_TITLE_STR[] = "Shepp";
-const char SignalFilter::FILTER_BANDLIMIT_TITLE_STR[] = "Bandlimit";
-const char SignalFilter::FILTER_SINC_TITLE_STR[] = "Sinc";
-const char SignalFilter::FILTER_COS_TITLE_STR[] = "Cos";
-const char SignalFilter::FILTER_HAMMING_TITLE_STR[] = "Hamming";
-const char SignalFilter::FILTER_TRIANGLE_TITLE_STR[] = "Triangle";
-    
-// Filter Methods
-const char SignalFilter::FILTER_METHOD_CONVOLUTION_STR[] = "convolution";
-const char SignalFilter::FILTER_METHOD_FOURIER_STR[] = "fourier";
-const char SignalFilter::FILTER_METHOD_FOURIER_TABLE_STR[] = "fourier_table";
-const char SignalFilter::FILTER_METHOD_FFT_STR[] = "fft";
+const int SignalFilter::FILTER_INVALID = -1 ;
+const int SignalFilter::FILTER_BANDLIMIT = 0;
+const int SignalFilter::FILTER_SINC = 1;
+const int SignalFilter::FILTER_G_HAMMING = 2;
+const int SignalFilter::FILTER_COSINE = 3;
+const int SignalFilter::FILTER_TRIANGLE = 4;
+const int SignalFilter::FILTER_ABS_BANDLIMIT = 5; 	// filter times |x = |
+const int SignalFilter::FILTER_ABS_SINC = 6;
+const int SignalFilter::FILTER_ABS_G_HAMMING = 7;
+const int SignalFilter::FILTER_ABS_COSINE = 8;
+const int SignalFilter::FILTER_SHEPP = 9;
+
+const char* SignalFilter::s_aszFilterName[] = {
+  {"bandlimit"},
+  {"sinc"},
+  {"hamming"},
+  {"cosine"},
+  {"triangle"},
+  {"abs_bandlimit"},
+  {"abs_sinc"},
+  {"abs_hamming"},
+  {"abs_cosine"},
+  {"shepp"},
+};
+
+const char* SignalFilter::s_aszFilterTitle[] = {
+  {"Bandlimit"},
+  {"Sinc"},
+  {"Hamming"},
+  {"Cosine"},
+  {"Triangle"},
+  {"Abs(w) * Bandlimit"},
+  {"Abs(w) * Sinc"},
+  {"Abs(w) * Hamming"},
+  {"Abs(w) * Cosine"},
+  {"Shepp"},
+};
+
+const int SignalFilter::s_iFilterCount = sizeof(s_aszFilterName) / sizeof(const char*);
+
+const int SignalFilter::FILTER_METHOD_INVALID = -1;
+const int SignalFilter::FILTER_METHOD_CONVOLUTION = 0;
+const int SignalFilter::FILTER_METHOD_FOURIER = 1;
+const int SignalFilter::FILTER_METHOD_FOURIER_TABLE = 2;
+const int SignalFilter::FILTER_METHOD_FFT = 3;
+#if HAVE_FFTW
+const int SignalFilter::FILTER_METHOD_FFTW = 4;
+const int SignalFilter::FILTER_METHOD_RFFTW =5 ;
+#endif
+
+const char* SignalFilter::s_aszFilterMethodName[] = {
+  {"convolution"},
+  {"fourier"},
+  {"fouier_table"},
+  {"fft"},
 #if HAVE_FFTW
-const char SignalFilter::FILTER_METHOD_FFTW_STR[] = "fftw";
-const char SignalFilter::FILTER_METHOD_RFFTW_STR[] = "rfftw";
+  {"fftw"},
+  {"rfftw"},
 #endif
+};
 
-const char SignalFilter::FILTER_METHOD_CONVOLUTION_TITLE_STR[] = "Convolution";
-const char SignalFilter::FILTER_METHOD_FOURIER_TITLE_STR[] = "Direct Fourier";
-const char SignalFilter::FILTER_METHOD_FOURIER_TABLE_TITLE_STR[] = "Fourier Trig Table";
-const char SignalFilter::FILTER_METHOD_FFT_TITLE_STR[] = "FFT";
+const char* SignalFilter::s_aszFilterMethodTitle[] = {
+  {"Convolution"},
+  {"Direct Fourier"},
+  {"Fouier Trigometric Table Lookout"},
+  {"FFT"},
 #if HAVE_FFTW
-const char SignalFilter::FILTER_METHOD_FFTW_TITLESTR[] = "FFTW";
-const char SignalFilter::FILTER_METHOD_RFFTW_TITLE_STR[] = "Real FFTW";
+  {"FFTW"},
+  {"Real/Half-Complex FFTW"},
 #endif
+};
 
-// Domains
-const char SignalFilter::DOMAIN_FREQUENCY_STR[] = "frequency";
-const char SignalFilter::DOMAIN_SPATIAL_STR[] = "spatial";
+const int SignalFilter::s_iFilterMethodCount = sizeof(s_aszFilterMethodName) / sizeof(const char*);
 
-const char SignalFilter::DOMAIN_FREQUENCY_TITLE_STR[] = "Frequency";
-const char SignalFilter::DOMAIN_SPATIAL_TITLE_STR[] = "Spatial";
+
+const int SignalFilter::DOMAIN_INVALID = -1;
+const int SignalFilter::DOMAIN_FREQUENCY = 0;
+const int SignalFilter::DOMAIN_SPATIAL = 1;
+    
+const char* SignalFilter::s_aszDomainName[] = {
+  {"frequency"},
+  {"spatial"},
+};
+
+const char* SignalFilter::s_aszDomainTitle[] = {
+  {"Frequency"},
+  {"Spatial"},
+};
+
+const int SignalFilter::s_iDomainCount = sizeof(s_aszDomainName) / sizeof(const char*);
 
 
 /* NAME
@@ -123,7 +164,7 @@ SignalFilter::SignalFilter (const char* filterName, const char* filterMethodName
   init (m_idFilter, m_idFilterMethod, bw, signalIncrement, nSignalPoints, param, m_idDomain, zeropad, preinterpolationFactor);
 }
 
-SignalFilter::SignalFilter (const FilterID filterID, const FilterMethodID filterMethodID, double bw, double signalIncrement, int nSignalPoints, double param, const DomainID domainID, int zeropad = 0, int preinterpolationFactor = 1)
+SignalFilter::SignalFilter (const int filterID, const int filterMethodID, double bw, double signalIncrement, int nSignalPoints, double param, const int domainID, int zeropad = 0, int preinterpolationFactor = 1)
 {
   init (filterID, filterMethodID, bw, signalIncrement, nSignalPoints, param, domainID, zeropad, preinterpolationFactor);
 }
@@ -154,7 +195,7 @@ SignalFilter::SignalFilter (const char* filterName, const char* domainName, doub
 }
 
 void
-SignalFilter::init (const FilterID filterID, const FilterMethodID filterMethodID, double bw, double signalIncrement, int nSignalPoints, double filterParam, const DomainID domainID, int zeropad, int preinterpolationFactor)
+SignalFilter::init (const int filterID, const int filterMethodID, double bw, double signalIncrement, int nSignalPoints, double filterParam, const int domainID, int zeropad, int preinterpolationFactor)
 {
   m_bw = bw;
   m_idFilter = filterID;
@@ -316,136 +357,114 @@ SignalFilter::~SignalFilter (void)
 }
 
 
-const SignalFilter::FilterID
+int
 SignalFilter::convertFilterNameToID (const char *filterName)
 {
-  FilterID filterID = FILTER_INVALID;
-
-  if (strcasecmp (filterName, FILTER_BANDLIMIT_STR) == 0)
-    filterID = FILTER_BANDLIMIT;
-  else if (strcasecmp (filterName, FILTER_HAMMING_STR) == 0)
-    filterID = FILTER_G_HAMMING;
-  else if (strcasecmp (filterName, FILTER_SINC_STR) == 0)
-    filterID = FILTER_SINC;
-  else if (strcasecmp (filterName, FILTER_COS_STR) == 0)
-    filterID = FILTER_COSINE;
-  else if (strcasecmp (filterName, FILTER_TRIANGLE_STR) == 0)
-    filterID = FILTER_TRIANGLE;
-  else if (strcasecmp (filterName, FILTER_ABS_BANDLIMIT_STR) == 0)
-    filterID = FILTER_ABS_BANDLIMIT;
-  else if (strcasecmp (filterName, FILTER_ABS_HAMMING_STR) == 0)
-    filterID = FILTER_ABS_G_HAMMING;
-  else if (strcasecmp (filterName, FILTER_ABS_SINC_STR) == 0)
-    filterID = FILTER_ABS_SINC;
-  else if (strcasecmp (filterName, FILTER_ABS_COS_STR) == 0)
-    filterID = FILTER_ABS_COSINE;
-  else if (strcasecmp (filterName, FILTER_SHEPP_STR) == 0)
-    filterID = FILTER_SHEPP;
+  int filterID = FILTER_INVALID;
+
+  for (int i = 0; i < s_iFilterCount; i++)
+      if (strcasecmp (filterName, s_aszFilterName[i]) == 0) {
+	filterID = i;
+	break;
+      }
 
   return (filterID);
 }
 
 const char *
-SignalFilter::convertFilterIDToName (const FilterID filterID)
+SignalFilter::convertFilterIDToName (const int filterID)
 {
-  const char *name = "";
-
-  if (filterID == FILTER_SHEPP)
-    name = FILTER_SHEPP_STR;
-  else if (filterID == FILTER_ABS_COSINE)
-    name = FILTER_ABS_COS_STR;
-  else if (filterID == FILTER_ABS_SINC)
-    name = FILTER_ABS_SINC_STR;
-  else if (filterID == FILTER_ABS_G_HAMMING)
-    name = FILTER_ABS_HAMMING_STR;
-  else if (filterID == FILTER_ABS_BANDLIMIT)
-    name = FILTER_ABS_BANDLIMIT_STR;
-  else if (filterID == FILTER_COSINE)
-    name = FILTER_COS_STR;
-  else if (filterID == FILTER_SINC)
-    name = FILTER_SINC_STR;
-  else if (filterID == FILTER_G_HAMMING)
-    name = FILTER_HAMMING_STR;
-  else if (filterID == FILTER_BANDLIMIT)
-    name = FILTER_BANDLIMIT_STR;
-  else if (filterID == FILTER_TRIANGLE)
-    name = FILTER_TRIANGLE_STR;
-	    
+  static const char *name = "";
+ 
+  if (filterID >= 0 && filterID < s_iFilterCount)
+      return (s_aszFilterName [filterID]);
+
   return (name);
 }
+
+const char *
+SignalFilter::convertFilterIDToTitle (const int filterID)
+{
+  static const char *title = "";
+ 
+  if (filterID >= 0 && filterID < s_iFilterCount)
+      return (s_aszFilterTitle [filterID]);
+
+  return (title);
+}
       
-const SignalFilter::FilterMethodID
+int
 SignalFilter::convertFilterMethodNameToID (const char* const filterMethodName)
 {
-  FilterMethodID fmID = FILTER_METHOD_INVALID;
-
-  if (strcasecmp (filterMethodName, FILTER_METHOD_CONVOLUTION_STR) == 0)
-    fmID = FILTER_METHOD_CONVOLUTION;
-  else if (strcasecmp (filterMethodName, FILTER_METHOD_FOURIER_STR) == 0)
-    fmID = FILTER_METHOD_FOURIER;
-  else if (strcasecmp (filterMethodName, FILTER_METHOD_FOURIER_TABLE_STR) == 0)
-    fmID = FILTER_METHOD_FOURIER_TABLE;
-  else if (strcasecmp (filterMethodName, FILTER_METHOD_FFT_STR) == 0)
-    fmID = FILTER_METHOD_FFT;
-#if HAVE_FFTW
-  else if (strcasecmp (filterMethodName, FILTER_METHOD_FFTW_STR) == 0)
-    fmID = FILTER_METHOD_FFTW;
-  else if (strcasecmp (filterMethodName, FILTER_METHOD_RFFTW_STR) == 0)
-    fmID = FILTER_METHOD_RFFTW;
-#endif
+  int fmID = FILTER_METHOD_INVALID;
+
+  for (int i = 0; i < s_iFilterMethodCount; i++)
+   if (strcasecmp (filterMethodName, s_aszFilterMethodName[i]) == 0) {
+      fmID = i;
+      break;
+    }
 
   return (fmID);
 }
 
 const char *
-SignalFilter::convertFilterMethodIDToName (const FilterMethodID fmID)
+SignalFilter::convertFilterMethodIDToName (const int fmID)
 {
-  const char *name = "";
-
-  if (fmID == FILTER_METHOD_CONVOLUTION)
-    return (FILTER_METHOD_CONVOLUTION_STR);
-  else if (fmID == FILTER_METHOD_FOURIER)
-    return (FILTER_METHOD_FOURIER_STR);
-  else if (fmID == FILTER_METHOD_FOURIER_TABLE)
-    return (FILTER_METHOD_FOURIER_TABLE_STR);
-  else if (fmID == FILTER_METHOD_FFT)
-    return (FILTER_METHOD_FFT_STR);
-#if HAVE_FFTW
-  else if (fmID == FILTER_METHOD_FFTW)
-    return (FILTER_METHOD_FFTW_STR);
-  else if (fmID == FILTER_METHOD_RFFTW)
-    return (FILTER_METHOD_RFFTW_STR);
-#endif
+  static const char *name = "";
+
+  if (fmID >= 0 && fmID < s_iFilterMethodCount)
+      return (s_aszFilterName [fmID]);
 
   return (name);
 }
 
-const SignalFilter::DomainID
+const char *
+SignalFilter::convertFilterMethodIDToTitle (const int fmID)
+{
+  static const char *title = "";
+
+  if (fmID >= 0 && fmID < s_iFilterMethodCount)
+      return (s_aszFilterTitle [fmID]);
+
+  return (title);
+}
+
+int
 SignalFilter::convertDomainNameToID (const char* const domainName)
 {
-  DomainID dID = DOMAIN_INVALID;
+  int dID = DOMAIN_INVALID;
 
-  if (strcasecmp (domainName, DOMAIN_SPATIAL_STR) == 0)
-    dID = DOMAIN_SPATIAL;
-  else if (strcasecmp (domainName, DOMAIN_FREQUENCY_STR) == 0)
-    dID = DOMAIN_FREQUENCY;
+  for (int i = 0; i < s_iDomainCount; i++)
+   if (strcasecmp (domainName, s_aszDomainName[i]) == 0) {
+      dID = i;
+      break;
+    }
 
   return (dID);
 }
 
 const char *
-SignalFilter::convertDomainIDToName (const DomainID domain)
+SignalFilter::convertDomainIDToName (const int domainID)
 {
-  const char *name = "";
+  static const char *name = "";
 
-  if (domain == DOMAIN_SPATIAL)
-    return (DOMAIN_SPATIAL_STR);
-  else if (domain == DOMAIN_FREQUENCY)
-    return (DOMAIN_FREQUENCY_STR);
+  if (domainID >= 0 && domainID < s_iDomainCount)
+      return (s_aszDomainName [domainID]);
 
   return (name);
 }
 
+const char *
+SignalFilter::convertDomainIDToTitle (const int domainID)
+{
+  static const char *title = "";
+
+  if (domainID >= 0 && domainID < s_iDomainCount)
+      return (s_aszDomainTitle [domainID]);
+
+  return (title);
+}
+
 void
 SignalFilter::filterSignal (const float input[], double output[]) const
 {
@@ -530,7 +549,7 @@ SignalFilter::response (double x)
 
 
 double 
-SignalFilter::spatialResponse (FilterID filterID, double bw, double x, double param)
+SignalFilter::spatialResponse (int filterID, double bw, double x, double param)
 {
   if (haveAnalyticSpatial(filterID))
     return spatialResponseAnalytic (filterID, bw, x, param);
@@ -560,7 +579,7 @@ SignalFilter::spatialResponseCalc (double x, double param) const
 }
 
 double 
-SignalFilter::spatialResponseCalc (FilterID filterID, double bw, double x, double param, int n)
+SignalFilter::spatialResponseCalc (int filterID, double bw, double x, double param, int n)
 {
   double zmin, zmax;
 
@@ -604,7 +623,7 @@ SignalFilter::frequencyResponse (double u, double param) const
 
 
 double 
-SignalFilter::frequencyResponse (FilterID filterID, double bw, double u, double param)
+SignalFilter::frequencyResponse (int filterID, double bw, double u, double param)
 {
   double q;
   double au = fabs (u);
@@ -689,7 +708,7 @@ SignalFilter::spatialResponseAnalytic (double x, double param) const
 }
 
 const bool
-SignalFilter::haveAnalyticSpatial (FilterID filterID)
+SignalFilter::haveAnalyticSpatial (int filterID)
 {
   bool haveAnalytic = false;
 
@@ -713,7 +732,7 @@ SignalFilter::haveAnalyticSpatial (FilterID filterID)
 }
 
 double 
-SignalFilter::spatialResponseAnalytic (FilterID filterID, double bw, double x, double param)
+SignalFilter::spatialResponseAnalytic (int filterID, double bw, double x, double param)
 {
   double q, temp;
   double u = TWOPI * x;