X-Git-Url: http://git.kpe.io/?a=blobdiff_plain;ds=sidebyside;f=libctsim%2Ffilter.cpp;h=84d2e7b4e080f877d9d162973d548e70131be084;hb=980bef9b95bef1ab728634181a5672088fd47066;hp=1c9e95bc37c03e372147f3349ea6dea4b75fcad7;hpb=e4c1f7f8eb87558c3abf3bf1d20732361f425351;p=ctsim.git

diff --git a/libctsim/filter.cpp b/libctsim/filter.cpp
index 1c9e95b..84d2e7b 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.18 2000/07/15 08:36:13 kevin Exp $
+**  $Id: filter.cpp,v 1.23 2000/07/31 14:48:35 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,9 +27,100 @@
 
 #include "ct.h"
 
-
 int SignalFilter::N_INTEGRAL=500;  //static member
 
+const int SignalFilter::FILTER_INVALID = -1 ;
+const int SignalFilter::FILTER_ABS_BANDLIMIT = 0; 	// filter times |x = |
+const int SignalFilter::FILTER_ABS_SINC = 1;
+const int SignalFilter::FILTER_ABS_G_HAMMING = 2;
+const int SignalFilter::FILTER_ABS_COSINE = 3;
+const int SignalFilter::FILTER_SHEPP = 4;
+const int SignalFilter::FILTER_BANDLIMIT = 5;
+const int SignalFilter::FILTER_SINC = 6;
+const int SignalFilter::FILTER_G_HAMMING = 7;
+const int SignalFilter::FILTER_COSINE = 8;
+const int SignalFilter::FILTER_TRIANGLE = 9;
+
+const char* SignalFilter::s_aszFilterName[] = {
+  {"abs_bandlimit"},
+  {"abs_sinc"},
+  {"abs_hamming"},
+  {"abs_cosine"},
+  {"shepp"},
+  {"bandlimit"},
+  {"sinc"},
+  {"hamming"},
+  {"cosine"},
+  {"triangle"},
+};
+
+const char* SignalFilter::s_aszFilterTitle[] = {
+  {"Abs(w) * Bandlimit"},
+  {"Abs(w) * Sinc"},
+  {"Abs(w) * Hamming"},
+  {"Abs(w) * Cosine"},
+  {"Shepp"},
+  {"Bandlimit"},
+  {"Sinc"},
+  {"Hamming"},
+  {"Cosine"},
+  {"Triangle"},
+};
+
+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
+  {"fftw"},
+  {"rfftw"},
+#endif
+};
+
+const char* SignalFilter::s_aszFilterMethodTitle[] = {
+  {"Convolution"},
+  {"Direct Fourier"},
+  {"Fouier Trigometric Table Lookout"},
+  {"FFT"},
+#if HAVE_FFTW
+  {"FFTW"},
+  {"Real/Half-Complex FFTW"},
+#endif
+};
+
+const int SignalFilter::s_iFilterMethodCount = sizeof(s_aszFilterMethodName) / sizeof(const char*);
+
+
+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
  *   SignalFilter::SignalFilter     Construct a signal
  *
@@ -45,10 +136,8 @@ int SignalFilter::N_INTEGRAL=500;  //static member
  */
 
 SignalFilter::SignalFilter (const char* filterName, const char* filterMethodName, double bw, double signalIncrement, int nSignalPoints, double param, const char* domainName, int zeropad = 0, int preinterpolationFactor = 1)
+  : m_vecFilter(NULL), m_vecFourierCosTable(NULL), m_vecFourierSinTable(NULL), m_fail(false)
 {
-  m_vecFilter = NULL;
-  m_vecFourierCosTable = NULL;
-  m_vecFourierSinTable = NULL;
   m_idFilter = convertFilterNameToID (filterName);
   if (m_idFilter == FILTER_INVALID) {
     m_fail = true;
@@ -73,19 +162,18 @@ 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)
+  : m_vecFilter(NULL), m_vecFourierCosTable(NULL), m_vecFourierSinTable(NULL), m_fail(false)
 {
   init (filterID, filterMethodID, bw, signalIncrement, nSignalPoints, param, domainID, zeropad, preinterpolationFactor);
 }
 
 SignalFilter::SignalFilter (const char* filterName, const char* domainName, double bw, double param)
+  : m_vecFilter(NULL), m_vecFourierCosTable(NULL), m_vecFourierSinTable(NULL), m_fail(false)
 {
   m_bw = bw;
   m_nSignalPoints = 0;
   m_nFilterPoints = 0;
-  m_vecFilter = NULL;
-  m_vecFourierCosTable = NULL;
-  m_vecFourierSinTable = NULL;
   m_filterParam = param;  
   m_idFilter = convertFilterNameToID (filterName);
   if (m_idFilter == FILTER_INVALID) {
@@ -104,7 +192,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;
@@ -118,7 +206,6 @@ SignalFilter::init (const FilterID filterID, const FilterMethodID filterMethodID
   m_nameFilter = convertFilterIDToName (m_idFilter);
   m_nameDomain = convertDomainIDToName (m_idDomain);
   m_nameFilterMethod = convertFilterMethodIDToName (m_idFilterMethod);
-  m_fail = false;
   m_nSignalPoints = nSignalPoints;
   m_signalInc = signalIncrement;
   m_filterParam = filterParam;  
@@ -230,11 +317,16 @@ SignalFilter::init (const FilterID filterID, const FilterMethodID filterMethodID
     } else if (m_idDomain == DOMAIN_SPATIAL) {
       double x;
       int i;
-      for (x = m_filterMin, i = 0; i < m_nFilterPoints; x += m_filterInc, i++)
+      for (x = m_filterMin, i = 0; i < m_nFilterPoints; x += m_filterInc, i++) {
 	if (haveAnalyticSpatial(m_idFilter))
 	  m_vecFilter[i] = spatialResponseAnalytic (x, m_filterParam);
 	else
 	  m_vecFilter[i] = spatialResponseCalc (x, m_filterParam);
+#if LIMIT_BANDWIDTH_TRIAL
+	if (i < m_nFilterPoints / 4 || i > (m_nFilterPoints * 3) / 4)
+	  m_vecFilter[i] = 0;
+#endif
+      }
     } else {
       m_failMessage = "Illegal domain name ";
       m_failMessage += m_idDomain;
@@ -266,136 +358,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)
-{
-  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;
-	    
+SignalFilter::convertFilterIDToName (const int filterID)
+{
+  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;
+  int 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
+  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)
-{
-  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
+SignalFilter::convertFilterMethodIDToName (const int fmID)
+{
+  static const char *name = "";
+
+  if (fmID >= 0 && fmID < s_iFilterMethodCount)
+      return (s_aszFilterMethodName [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
 {
@@ -480,7 +550,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);
@@ -510,7 +580,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;
 
@@ -554,7 +624,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);
@@ -639,7 +709,7 @@ SignalFilter::spatialResponseAnalytic (double x, double param) const
 }
 
 const bool
-SignalFilter::haveAnalyticSpatial (FilterID filterID)
+SignalFilter::haveAnalyticSpatial (int filterID)
 {
   bool haveAnalytic = false;
 
@@ -663,7 +733,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;