X-Git-Url: http://git.kpe.io/?a=blobdiff_plain;f=libctsim%2Ffilter.cpp;h=d7d8b973c61a41f233d5a03a7c1dd3b894a5f8fc;hb=d158a6da6ec776fe98961f73f2ea74cf55de4700;hp=a0638b2a1b9538b313d22188f47246a26e7a32c6;hpb=27a474e0622ebb7229fd5705552021f63d8f932d;p=ctsim.git

diff --git a/libctsim/filter.cpp b/libctsim/filter.cpp
index a0638b2..d7d8b97 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.24 2000/08/03 09:57: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,115 @@
 
 #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_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
-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*);
+
+
+const int SignalFilter::FREQUENCY_FILTER_INVALID = -1;
+const int SignalFilter::FREQUENCY_FILTER_DIRECT_FREQUENCY = 0;
+const int SignalFilter::FREQUENCY_FILTER_INVERSE_SPATIAL = 1;
+    
+const char* SignalFilter::s_aszFrequencyFilterName[] = {
+  {"direct_frequency"},
+  {"inverse_spatial"},
+};
+
+const char* SignalFilter::s_aszFrequencyFilterTitle[] = {
+  {"Direct Frequency"},
+  {"Inverse Spatial"},
+};
+
+const int SignalFilter::s_iFrequencyFilterCount = sizeof(s_aszFrequencyFilterName) / sizeof(const char*);
 
 
 /* NAME
@@ -94,11 +152,9 @@ const char SignalFilter::DOMAIN_SPATIAL_TITLE_STR[] = "Spatial";
  *   int domain		FREQUENCY or SPATIAL domain wanted
  */
 
-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)
+SignalFilter::SignalFilter (const char* filterName, const char* filterMethodName, double bw, double signalIncrement, int nSignalPoints, double param, const char* domainName, const char* frequencyFilterName, 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;
@@ -120,22 +176,28 @@ SignalFilter::SignalFilter (const char* filterName, const char* filterMethodName
     m_failMessage += domainName;
     return;
   }
-  init (m_idFilter, m_idFilterMethod, bw, signalIncrement, nSignalPoints, param, m_idDomain, zeropad, preinterpolationFactor);
+  m_idFrequencyFilter = convertFrequencyFilterNameToID (frequencyFilterName);
+  if (m_idFrequencyFilter == FREQUENCY_FILTER_INVALID) {
+    m_fail = true;
+    m_failMessage = "Invalid frequency filter name ";
+    m_failMessage += frequencyFilterName;
+    return;
+  }
+  init (m_idFilter, m_idFilterMethod, bw, signalIncrement, nSignalPoints, param, m_idDomain, m_idFrequencyFilter, 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 frequencyFilterID, 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);
+  init (filterID, filterMethodID, bw, signalIncrement, nSignalPoints, param, domainID, frequencyFilterID, 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) {
@@ -154,13 +216,14 @@ 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, const int frequencyFilterID, int zeropad, int preinterpolationFactor)
 {
   m_bw = bw;
   m_idFilter = filterID;
   m_idDomain = domainID;
   m_idFilterMethod = filterMethodID;
-  if (m_idFilter == FILTER_INVALID || m_idDomain == DOMAIN_INVALID || m_idFilterMethod == FILTER_METHOD_INVALID) {
+  m_idFrequencyFilter = frequencyFilterID;
+  if (m_idFilter == FILTER_INVALID || m_idDomain == DOMAIN_INVALID || m_idFilterMethod == FILTER_METHOD_INVALID || m_idFrequencyFilter == FREQUENCY_FILTER_INVALID) {
     m_fail = true;
     return;
   }
@@ -168,7 +231,7 @@ 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_nameFrequencyFilter = convertFrequencyFilterIDToName (m_idFrequencyFilter);
   m_nSignalPoints = nSignalPoints;
   m_signalInc = signalIncrement;
   m_filterParam = filterParam;  
@@ -280,11 +343,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;
@@ -316,132 +384,146 @@ 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_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)
+{
+  static const char *name = "";
+
+  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);
+}
+
+int
+SignalFilter::convertFrequencyFilterNameToID (const char* const ffName)
+{
+  int ffID = FREQUENCY_FILTER_INVALID;
+
+  for (int i = 0; i < s_iFrequencyFilterCount; i++)
+   if (strcasecmp (ffName, s_aszFrequencyFilterName[i]) == 0) {
+      ffID = i;
+      break;
+    }
+
+  return (ffID);
+}
+
+const char *
+SignalFilter::convertFrequencyFilterIDToName (const int ffID)
+{
+  static const char *name = "";
+
+  if (ffID >= 0 && ffID < s_iFrequencyFilterCount)
+      return (s_aszFrequencyFilterName [ffID]);
+
+  return (name);
+}
+
+const char *
+SignalFilter::convertFrequencyFilterIDToTitle (const int ffID)
 {
-  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 (ffID >= 0 && ffID < s_iFrequencyFilterCount)
+      return (s_aszFrequencyFilterTitle [ffID]);
 
   return (name);
 }
@@ -530,7 +612,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 +642,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 +686,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 +771,7 @@ SignalFilter::spatialResponseAnalytic (double x, double param) const
 }
 
 const bool
-SignalFilter::haveAnalyticSpatial (FilterID filterID)
+SignalFilter::haveAnalyticSpatial (int filterID)
 {
   bool haveAnalytic = false;
 
@@ -713,7 +795,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;