X-Git-Url: http://git.kpe.io/?a=blobdiff_plain;f=libctsim%2Fprocsignal.cpp;h=7bf2711f0a626190dd01fa297d478b0d5c1a1431;hb=fd1d136a94a6d20013f38d6a997bdfefad0f5e98;hp=9fdbb682a1fbb07f9aa30022178bd25e5fafd1e7;hpb=e36dfad3f0818b4c3457fbe7277faa6f4ca28dfe;p=ctsim.git diff --git a/libctsim/procsignal.cpp b/libctsim/procsignal.cpp index 9fdbb68..7bf2711 100644 --- a/libctsim/procsignal.cpp +++ b/libctsim/procsignal.cpp @@ -9,7 +9,7 @@ ** This is part of the CTSim program ** Copyright (C) 1983-2000 Kevin Rosenberg ** -** $Id: procsignal.cpp,v 1.1 2000/08/19 23:00:05 kevin Exp $ +** $Id: procsignal.cpp,v 1.10 2000/12/16 06:12:47 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 @@ -49,8 +49,8 @@ const char* ProcessSignal::s_aszFilterMethodName[] = { }; const char* ProcessSignal::s_aszFilterMethodTitle[] = { {"Convolution"}, - {"Direct Fourier"}, - {"Fouier Trigometric Table Lookout"}, + {"Fourier"}, + {"Fouier Trigometric Table"}, {"FFT"}, #if HAVE_FFTW {"FFTW"}, @@ -77,7 +77,7 @@ const int ProcessSignal::s_iFilterGenerationCount = sizeof(s_aszFilterGeneration // CLASS IDENTIFICATION // ProcessSignal // -ProcessSignal::ProcessSignal (const char* szFilterName, const char* szFilterMethodName, double dBandwidth, double dSignalIncrement, int nSignalPoints, double dFilterParam, const char* szDomainName, const char* szFilterGenerationName, int iZeropad = 0, int iPreinterpolationFactor = 1) +ProcessSignal::ProcessSignal (const char* szFilterName, const char* szFilterMethodName, double dBandwidth, double dSignalIncrement, int nSignalPoints, double dFilterParam, const char* szDomainName, const char* szFilterGenerationName, int iZeropad, int iPreinterpolationFactor, int iTraceLevel, int iGeometry, double dFocalLength, SGP* pSGP) : m_adFourierCosTable(NULL), m_adFourierSinTable(NULL), m_adFilter(NULL), m_fail(false) { m_idFilterMethod = convertFilterMethodNameToID (szFilterMethodName); @@ -109,22 +109,26 @@ ProcessSignal::ProcessSignal (const char* szFilterName, const char* szFilterMeth return; } - init (m_idFilter, m_idFilterMethod, dBandwidth, dSignalIncrement, nSignalPoints, dFilterParam, m_idDomain, m_idFilterGeneration, iZeropad, iPreinterpolationFactor); + init (m_idFilter, m_idFilterMethod, dBandwidth, dSignalIncrement, nSignalPoints, dFilterParam, m_idDomain, m_idFilterGeneration, iZeropad, iPreinterpolationFactor, iTraceLevel, iGeometry, dFocalLength, pSGP); } void -ProcessSignal::init (const int idFilter, const int idFilterMethod, double dBandwidth, double dSignalIncrement, int nSignalPoints, double dFilterParam, const int idDomain, const int idFilterGeneration, const int iZeropad, const int iPreinterpolationFactor) -{ +ProcessSignal::init (const int idFilter, const int idFilterMethod, double dBandwidth, double dSignalIncrement, int nSignalPoints, double dFilterParam, const int idDomain, const int idFilterGeneration, const int iZeropad, const int iPreinterpolationFactor, int iTraceLevel, int iGeometry, double dFocalLength, SGP* pSGP) +{ + int i; m_idFilter = idFilter; m_idDomain = idDomain; m_idFilterMethod = idFilterMethod; m_idFilterGeneration = idFilterGeneration; + m_idGeometry = iGeometry; + m_dFocalLength = dFocalLength; + if (m_idFilter == SignalFilter::FILTER_INVALID || m_idDomain == SignalFilter::DOMAIN_INVALID || m_idFilterMethod == FILTER_METHOD_INVALID || m_idFilterGeneration == FILTER_GENERATION_INVALID) { m_fail = true; return; } - m_traceLevel = TRACE_NONE; + m_traceLevel = iTraceLevel; m_nameFilterMethod = convertFilterMethodIDToName (m_idFilterMethod); m_nameFilterGeneration = convertFilterGenerationIDToName (m_idFilterGeneration); m_dBandwidth = dBandwidth; @@ -134,6 +138,13 @@ ProcessSignal::init (const int idFilter, const int idFilterMethod, double dBandw m_iZeropad = iZeropad; m_iPreinterpolationFactor = iPreinterpolationFactor; + // scale signalInc/BW to signalInc/2 to adjust for imaginary detector + // through origin of phantom, see Kak-Slaney Fig 3.22, for Collinear + if (m_idGeometry == Scanner::GEOMETRY_EQUILINEAR) { + m_dSignalInc /= 2; + m_dBandwidth *= 2; + } + if (m_idFilterMethod == FILTER_METHOD_FFT) { #if HAVE_FFTW m_idFilterMethod = FILTER_METHOD_RFFTW; @@ -152,7 +163,7 @@ ProcessSignal::init (const int idFilter, const int idFilterMethod, double dBandw if (! m_bFrequencyFiltering) { if (m_idFilterGeneration == FILTER_GENERATION_DIRECT) { - m_nFilterPoints = 2 * m_nSignalPoints - 1; + m_nFilterPoints = 2 * (m_nSignalPoints - 1) + 1; m_dFilterMin = -m_dSignalInc * (m_nSignalPoints - 1); m_dFilterMax = m_dSignalInc * (m_nSignalPoints - 1); m_dFilterInc = (m_dFilterMax - m_dFilterMin) / (m_nFilterPoints - 1); @@ -160,71 +171,231 @@ ProcessSignal::init (const int idFilter, const int idFilterMethod, double dBandw m_adFilter = new double[ m_nFilterPoints ]; filter.copyFilterData (m_adFilter, 0, m_nFilterPoints); } else if (m_idFilterGeneration == FILTER_GENERATION_INVERSE_FOURIER) { - m_nFilterPoints = m_nSignalPoints; + m_nFilterPoints = 2 * (m_nSignalPoints - 1) + 1; m_dFilterMin = -1. / (2 * m_dSignalInc); m_dFilterMax = 1. / (2 * m_dSignalInc); m_dFilterInc = (m_dFilterMax - m_dFilterMin) / (m_nFilterPoints - 1); SignalFilter filter (m_idFilter, m_dFilterMin, m_dFilterMax, m_nFilterPoints, m_dBandwidth, m_dFilterParam, SignalFilter::DOMAIN_FREQUENCY); m_adFilter = new double[ m_nFilterPoints ]; - double adFrequencyFilter [m_nFilterPoints]; - double adInverseFilter [m_nFilterPoints]; + double* adFrequencyFilter = new double [m_nFilterPoints]; filter.copyFilterData (adFrequencyFilter, 0, m_nFilterPoints); +#ifdef HAVE_SGP + EZPlot* pEZPlot = NULL; + if (pSGP && m_traceLevel >= Trace::TRACE_PLOT) { + pEZPlot = new EZPlot (*pSGP); + pEZPlot->ezset ("title Filter Response: Natural Order"); + pEZPlot->ezset ("ylength 0.25"); + pEZPlot->addCurve (adFrequencyFilter, m_nFilterPoints); + pEZPlot->plot(); + } +#endif shuffleNaturalToFourierOrder (adFrequencyFilter, m_nFilterPoints); - ProcessSignal::finiteFourierTransform (adFrequencyFilter, adInverseFilter, m_nFilterPoints, 1); - for (int i = 0; i < m_nFilterPoints; i++) - m_adFilter [i] = adInverseFilter[i]; - } - } - - // Frequency-based filtering - else if (m_bFrequencyFiltering) { - - // calculate number of filter points with zeropadding - m_nFilterPoints = m_nSignalPoints; - if (m_iZeropad > 0) { - double logBase2 = log(m_nSignalPoints) / log(2); - int nextPowerOf2 = static_cast(floor(logBase2)); - if (logBase2 != floor(logBase2)) - nextPowerOf2++; - nextPowerOf2 += (m_iZeropad - 1); - m_nFilterPoints = 1 << nextPowerOf2; - if (m_traceLevel >= TRACE_TEXT) - cout << "nFilterPoints = " << m_nFilterPoints << endl; +#ifdef HAVE_SGP + if (pEZPlot && m_traceLevel >= Trace::TRACE_PLOT) { + pEZPlot->ezset ("title Filter Response: Fourier Order"); + pEZPlot->ezset ("ylength 0.25"); + pEZPlot->ezset ("yporigin 0.25"); + pEZPlot->addCurve (adFrequencyFilter, m_nFilterPoints); + pEZPlot->plot(); + } +#endif + ProcessSignal::finiteFourierTransform (adFrequencyFilter, m_adFilter, m_nFilterPoints, -1); + delete adFrequencyFilter; +#ifdef HAVE_SGP + if (pEZPlot && m_traceLevel >= Trace::TRACE_PLOT) { + pEZPlot->ezset ("title Inverse Fourier Frequency: Fourier Order"); + pEZPlot->ezset ("ylength 0.25"); + pEZPlot->ezset ("yporigin 0.50"); + pEZPlot->addCurve (m_adFilter, m_nFilterPoints); + pEZPlot->plot(); + } +#endif + shuffleFourierToNaturalOrder (m_adFilter, m_nFilterPoints); +#ifdef HAVE_SGP + if (pEZPlot && m_traceLevel >= Trace::TRACE_PLOT) { + pEZPlot->ezset ("title Inverse Fourier Frequency: Natural Order"); + pEZPlot->ezset ("ylength 0.25"); + pEZPlot->ezset ("yporigin 0.75"); + pEZPlot->addCurve (m_adFilter, m_nFilterPoints); + pEZPlot->plot(); + delete pEZPlot; + } +#endif + for (i = 0; i < m_nFilterPoints; i++) { + m_adFilter[i] /= m_dSignalInc; + } } - m_nOutputPoints = m_nFilterPoints * m_iPreinterpolationFactor; + if (m_idGeometry == Scanner::GEOMETRY_EQUILINEAR) { + for (i = 0; i < m_nFilterPoints; i++) + m_adFilter[i] *= 0.5; + } else if (m_idGeometry == Scanner::GEOMETRY_EQUIANGULAR) { + for (i = 0; i < m_nFilterPoints; i++) { + int iDetFromZero = i - ((m_nFilterPoints - 1) / 2); + double sinScale = sin (iDetFromZero * m_dSignalInc); + if (fabs(sinScale) < 1E-7) + sinScale = 1; + else + sinScale = (iDetFromZero * m_dSignalInc) / sinScale; + double dScale = 0.5 * sinScale * sinScale; + m_adFilter[i] *= dScale; + } + } // if (geometry) + } // if (spatial filtering) + + else if (m_bFrequencyFiltering) { // Frequency-based filtering if (m_idFilterGeneration == FILTER_GENERATION_DIRECT) { + // calculate number of filter points with zeropadding + m_nFilterPoints = m_nSignalPoints; + if (m_iZeropad > 0) { + double logBase2 = log(m_nFilterPoints) / log(2); + int nextPowerOf2 = static_cast(floor(logBase2)); + if (logBase2 != floor(logBase2)) + nextPowerOf2++; + nextPowerOf2 += (m_iZeropad - 1); + m_nFilterPoints = 1 << nextPowerOf2; +#ifdef DEBUG + if (m_traceLevel >= Trace::TRACE_CONSOLE) + std::cout << "nFilterPoints = " << m_nFilterPoints << endl; +#endif + } + m_nOutputPoints = m_nFilterPoints * m_iPreinterpolationFactor; + + if (m_nFilterPoints % 2) { // Odd m_dFilterMin = -1. / (2 * m_dSignalInc); m_dFilterMax = 1. / (2 * m_dSignalInc); m_dFilterInc = (m_dFilterMax - m_dFilterMin) / (m_nFilterPoints - 1); - SignalFilter filter (m_idFilter, m_dFilterMin, m_dFilterMax, m_nFilterPoints, m_dBandwidth, m_dFilterParam, SignalFilter::DOMAIN_FREQUENCY); - m_adFilter = new double [m_nFilterPoints]; - filter.copyFilterData (m_adFilter, 0, m_nFilterPoints); - shuffleNaturalToFourierOrder (m_adFilter, m_nFilterPoints); + } else { // Even + m_dFilterMin = -1. / (2 * m_dSignalInc); + m_dFilterMax = 1. / (2 * m_dSignalInc); + m_dFilterInc = (m_dFilterMax - m_dFilterMin) / m_nFilterPoints; + m_dFilterMax -= m_dFilterInc; + } + + SignalFilter filter (m_idFilter, m_dFilterMin, m_dFilterMax, m_nFilterPoints, m_dBandwidth, m_dFilterParam, SignalFilter::DOMAIN_FREQUENCY); + m_adFilter = new double [m_nFilterPoints]; + filter.copyFilterData (m_adFilter, 0, m_nFilterPoints); + + // This doesn't work! + // Need to add filtering for divergent geometries & Frequency/Direct filtering + if (m_idGeometry == Scanner::GEOMETRY_EQUILINEAR) { + for (i = 0; i < m_nFilterPoints; i++) + m_adFilter[i] *= 0.5; + } else if (m_idGeometry == Scanner::GEOMETRY_EQUIANGULAR) { + for (i = 0; i < m_nFilterPoints; i++) { + int iDetFromZero = i - ((m_nFilterPoints - 1) / 2); + double sinScale = sin (iDetFromZero * m_dSignalInc); + if (fabs(sinScale) < 1E-7) + sinScale = 1; + else + sinScale = (iDetFromZero * m_dSignalInc) / sinScale; + double dScale = 0.5 * sinScale * sinScale; + m_adFilter[i] *= dScale; + } + } +#ifdef HAVE_SGP + EZPlot* pEZPlot = NULL; + if (pSGP && m_traceLevel >= Trace::TRACE_PLOT) { + pEZPlot = new EZPlot (*pSGP); + pEZPlot->ezset ("title Filter Filter: Natural Order"); + pEZPlot->ezset ("ylength 0.50"); + pEZPlot->ezset ("yporigin 0.00"); + pEZPlot->addCurve (m_adFilter, m_nFilterPoints); + pEZPlot->plot(); + } +#endif + shuffleNaturalToFourierOrder (m_adFilter, m_nFilterPoints); +#ifdef HAVE_SGP + if (pEZPlot && m_traceLevel >= Trace::TRACE_PLOT) { + pEZPlot->ezset ("title Filter Filter: Fourier Order"); + pEZPlot->ezset ("ylength 0.50"); + pEZPlot->ezset ("yporigin 0.50"); + pEZPlot->addCurve (m_adFilter, m_nFilterPoints); + pEZPlot->plot(); + delete pEZPlot; + } +#endif } else if (m_idFilterGeneration == FILTER_GENERATION_INVERSE_FOURIER) { - m_nFilterPoints = 2 * m_nSignalPoints - 1; - m_dFilterMin = -m_dSignalInc * (m_nSignalPoints - 1); - m_dFilterMax = m_dSignalInc * (m_nSignalPoints - 1); - m_dFilterInc = (m_dFilterMax - m_dFilterMin) / (m_nFilterPoints - 1); - double adSpatialFilter [m_nFilterPoints]; - double adInverseFilter [m_nFilterPoints]; - SignalFilter filter (m_idFilter, m_dFilterMin, m_dFilterMax, m_nFilterPoints, m_dBandwidth, m_dFilterParam, SignalFilter::DOMAIN_SPATIAL); - filter.copyFilterData (adSpatialFilter, 0, m_nFilterPoints); - m_adFilter = new double [m_nFilterPoints]; - finiteFourierTransform (adSpatialFilter, adInverseFilter, m_nFilterPoints, -1); - for (int i = 0; i < m_nFilterPoints; i++) - m_adFilter [i] = adInverseFilter[i]; + // calculate number of filter points with zeropadding + int nSpatialPoints = 2 * (m_nSignalPoints - 1) + 1; + m_dFilterMin = -m_dSignalInc * (m_nSignalPoints - 1); + m_dFilterMax = m_dSignalInc * (m_nSignalPoints - 1); + m_dFilterInc = (m_dFilterMax - m_dFilterMin) / (nSpatialPoints - 1); + m_nFilterPoints = nSpatialPoints; + if (m_iZeropad > 0) { + double logBase2 = log(nSpatialPoints) / log(2); + int nextPowerOf2 = static_cast(floor(logBase2)); + if (logBase2 != floor(logBase2)) + nextPowerOf2++; + nextPowerOf2 += (m_iZeropad - 1); + m_nFilterPoints = 1 << nextPowerOf2; } + m_nOutputPoints = m_nFilterPoints * m_iPreinterpolationFactor; +#ifdef DEBUG + if (m_traceLevel >= Trace::TRACE_CONSOLE) + std::cout << "nFilterPoints = " << m_nFilterPoints << endl; +#endif + double* adSpatialFilter = new double [m_nFilterPoints]; + SignalFilter filter (m_idFilter, m_dFilterMin, m_dFilterMax, nSpatialPoints, m_dBandwidth, m_dFilterParam, SignalFilter::DOMAIN_SPATIAL); + filter.copyFilterData (adSpatialFilter, 0, nSpatialPoints); +#ifdef HAVE_SGP + EZPlot* pEZPlot = NULL; + if (pSGP && m_traceLevel >= Trace::TRACE_PLOT) { + pEZPlot = new EZPlot (*pSGP); + pEZPlot->ezset ("title Spatial Filter: Natural Order"); + pEZPlot->ezset ("ylength 0.50"); + pEZPlot->ezset ("yporigin 0.00"); + pEZPlot->addCurve (adSpatialFilter, nSpatialPoints); + pEZPlot->plot(); + delete pEZPlot; + } +#endif + if (m_idGeometry == Scanner::GEOMETRY_EQUILINEAR) { + for (i = 0; i < m_nFilterPoints; i++) + adSpatialFilter[i] *= 0.5; + } else if (m_idGeometry == Scanner::GEOMETRY_EQUIANGULAR) { + for (i = 0; i < m_nFilterPoints; i++) { + int iDetFromZero = i - ((m_nFilterPoints - 1) / 2); + double sinScale = sin (iDetFromZero * m_dSignalInc); + if (fabs(sinScale) < 1E-7) + sinScale = 1; + else + sinScale = (iDetFromZero * m_dSignalInc) / sinScale; + double dScale = 0.5 * sinScale * sinScale; + adSpatialFilter[i] *= dScale; + } + } + for (i = nSpatialPoints; i < m_nFilterPoints; i++) + adSpatialFilter[i] = 0; + + m_adFilter = new double [m_nFilterPoints]; + std::complex* acInverseFilter = new std::complex [m_nFilterPoints]; + finiteFourierTransform (adSpatialFilter, acInverseFilter, m_nFilterPoints, 1); + delete adSpatialFilter; + for (i = 0; i < m_nFilterPoints; i++) + m_adFilter[i] = std::abs(acInverseFilter[i]) * m_dSignalInc; + delete acInverseFilter; +#ifdef HAVE_SGP + if (pEZPlot && m_traceLevel >= Trace::TRACE_PLOT) { + pEZPlot->ezset ("title Spatial Filter: Inverse"); + pEZPlot->ezset ("ylength 0.50"); + pEZPlot->ezset ("yporigin 0.50"); + pEZPlot->addCurve (m_adFilter, m_nFilterPoints); + pEZPlot->plot(); + delete pEZPlot; + } +#endif } - + } + // precalculate sin and cosine tables for fourier transform if (m_idFilterMethod == FILTER_METHOD_FOURIER_TABLE) { - int nFourier = max(m_nFilterPoints,m_nOutputPoints) * max(m_nFilterPoints, m_nOutputPoints) + 1; + int nFourier = imax (m_nFilterPoints,m_nOutputPoints) * imax (m_nFilterPoints, m_nOutputPoints) + 1; double angleIncrement = (2. * PI) / m_nFilterPoints; m_adFourierCosTable = new double[ nFourier ]; m_adFourierSinTable = new double[ nFourier ]; double angle = 0; - for (int i = 0; i < nFourier; i++) { + for (i = 0; i < nFourier; i++) { m_adFourierCosTable[i] = cos (angle); m_adFourierSinTable[i] = sin (angle); angle += angleIncrement; @@ -233,7 +404,7 @@ ProcessSignal::init (const int idFilter, const int idFilterMethod, double dBandw #if HAVE_FFTW if (m_idFilterMethod == FILTER_METHOD_FFTW || m_idFilterMethod == FILTER_METHOD_RFFTW) { - for (int i = 0; i < m_nFilterPoints; i++) //fftw uses unnormalized fft + for (i = 0; i < m_nFilterPoints; i++) //fftw uses unnormalized fft m_adFilter[i] /= m_nFilterPoints; } @@ -242,16 +413,16 @@ ProcessSignal::init (const int idFilter, const int idFilterMethod, double dBandw m_realPlanBackward = rfftw_create_plan (m_nOutputPoints, FFTW_COMPLEX_TO_REAL, FFTW_ESTIMATE); m_adRealFftInput = new fftw_real [ m_nFilterPoints ]; m_adRealFftSignal = new fftw_real [ m_nOutputPoints ]; - for (int i = 0; i < m_nFilterPoints; i++) + for (i = 0; i < m_nFilterPoints; i++) m_adRealFftInput[i] = 0; } else if (m_idFilterMethod == FILTER_METHOD_FFTW) { m_complexPlanForward = fftw_create_plan (m_nFilterPoints, FFTW_FORWARD, FFTW_ESTIMATE); m_complexPlanBackward = fftw_create_plan (m_nOutputPoints, FFTW_BACKWARD, FFTW_ESTIMATE); m_adComplexFftInput = new fftw_complex [ m_nFilterPoints ]; m_adComplexFftSignal = new fftw_complex [ m_nOutputPoints ]; - for (int i = 0; i < m_nFilterPoints; i++) + for (i = 0; i < m_nFilterPoints; i++) m_adComplexFftInput[i].re = m_adComplexFftInput[i].im = 0; - for (int i = 0; i < m_nOutputPoints; i++) + for (i = 0; i < m_nOutputPoints; i++) m_adComplexFftSignal[i].re = m_adComplexFftSignal[i].im = 0; } #endif @@ -262,6 +433,7 @@ ProcessSignal::~ProcessSignal (void) { delete [] m_adFourierSinTable; delete [] m_adFourierCosTable; + delete [] m_adFilter; #if HAVE_FFTW if (m_idFilterMethod == FILTER_METHOD_FFTW) { @@ -353,72 +525,99 @@ ProcessSignal::convertFilterGenerationIDToTitle (const int fgID) } void -ProcessSignal::filterSignal (const float input[], double output[]) const +ProcessSignal::filterSignal (const float constInput[], double output[]) const { + double* input = new double [m_nSignalPoints]; + int i; + for (i = 0; i < m_nSignalPoints; i++) + input[i] = constInput[i]; + + if (m_idGeometry == Scanner::GEOMETRY_EQUILINEAR) { + for (int i = 0; i < m_nSignalPoints; i++) { + int iDetFromCenter = i - (m_nSignalPoints / 2); + input[i] *= m_dFocalLength / sqrt (m_dFocalLength * m_dFocalLength + iDetFromCenter * iDetFromCenter * m_dSignalInc * m_dSignalInc); + } + } else if (m_idGeometry == Scanner::GEOMETRY_EQUIANGULAR) { + for (int i = 0; i < m_nSignalPoints; i++) { + int iDetFromCenter = i - (m_nSignalPoints / 2); + input[i] *= m_dFocalLength * cos (iDetFromCenter * m_dSignalInc); + } + } if (m_idFilterMethod == FILTER_METHOD_CONVOLUTION) { - for (int i = 0; i < m_nSignalPoints; i++) - output[i] = convolve (input, m_dSignalInc, i, m_nSignalPoints); + for (i = 0; i < m_nSignalPoints; i++) + output[i] = convolve (input, m_dSignalInc, i, m_nSignalPoints); } else if (m_idFilterMethod == FILTER_METHOD_FOURIER) { - double inputSignal[m_nFilterPoints]; - for (int i = 0; i < m_nSignalPoints; i++) + double* inputSignal = new double [m_nFilterPoints]; + for (i = 0; i < m_nSignalPoints; i++) inputSignal[i] = input[i]; - for (int i = m_nSignalPoints; i < m_nFilterPoints; i++) + for (i = m_nSignalPoints; i < m_nFilterPoints; i++) inputSignal[i] = 0; // zeropad - complex fftSignal[m_nFilterPoints]; - finiteFourierTransform (inputSignal, fftSignal, m_nFilterPoints, -1); - for (int i = 0; i < m_nFilterPoints; i++) + std::complex* fftSignal = new std::complex [m_nFilterPoints]; + finiteFourierTransform (inputSignal, fftSignal, m_nFilterPoints, -1); + delete inputSignal; + for (i = 0; i < m_nFilterPoints; i++) fftSignal[i] *= m_adFilter[i]; - double inverseFourier[m_nFilterPoints]; - finiteFourierTransform (fftSignal, inverseFourier, m_nFilterPoints, 1); - for (int i = 0; i < m_nSignalPoints; i++) - output[i] = inverseFourier[i]; + double* inverseFourier = new double [m_nFilterPoints]; + finiteFourierTransform (fftSignal, inverseFourier, m_nFilterPoints, 1); + delete fftSignal; + for (i = 0; i < m_nSignalPoints; i++) + output[i] = inverseFourier[i]; + delete inverseFourier; } else if (m_idFilterMethod == FILTER_METHOD_FOURIER_TABLE) { - double inputSignal[m_nFilterPoints]; - for (int i = 0; i < m_nSignalPoints; i++) + double* inputSignal = new double [m_nFilterPoints]; + for (i = 0; i < m_nSignalPoints; i++) inputSignal[i] = input[i]; - for (int i = m_nSignalPoints; i < m_nFilterPoints; i++) + for (i = m_nSignalPoints; i < m_nFilterPoints; i++) inputSignal[i] = 0; // zeropad - complex fftSignal[m_nFilterPoints]; - finiteFourierTransform (inputSignal, fftSignal, -1); - for (int i = 0; i < m_nFilterPoints; i++) + std::complex* fftSignal = new std::complex [m_nFilterPoints]; + finiteFourierTransform (inputSignal, fftSignal, -1); + delete inputSignal; + for (i = 0; i < m_nFilterPoints; i++) fftSignal[i] *= m_adFilter[i]; - double inverseFourier[m_nFilterPoints]; - finiteFourierTransform (fftSignal, inverseFourier, 1); - for (int i = 0; i < m_nSignalPoints; i++) - output[i] = inverseFourier[i]; + double* inverseFourier = new double [m_nFilterPoints]; + finiteFourierTransform (fftSignal, inverseFourier, 1); + delete fftSignal; + for (i = 0; i < m_nSignalPoints; i++) + output[i] = inverseFourier[i]; + delete inverseFourier; } #if HAVE_FFTW else if (m_idFilterMethod == FILTER_METHOD_RFFTW) { - for (int i = 0; i < m_nSignalPoints; i++) + for (i = 0; i < m_nSignalPoints; i++) m_adRealFftInput[i] = input[i]; - fftw_real fftOutput [ m_nFilterPoints ]; + fftw_real* fftOutput = new fftw_real [ m_nFilterPoints ]; rfftw_one (m_realPlanForward, m_adRealFftInput, fftOutput); - for (int i = 0; i < m_nFilterPoints; i++) - m_adRealFftSignal[i] = m_adFilter[i] * fftOutput[i]; - for (int i = m_nFilterPoints; i < m_nOutputPoints; i++) - m_adRealFftSignal[i] = 0; + for (i = 0; i < m_nFilterPoints; i++) + m_adRealFftSignal[i] = m_adFilter[i] * fftOutput[i]; + delete [] fftOutput; + for (i = m_nFilterPoints; i < m_nOutputPoints; i++) + m_adRealFftSignal[i] = 0; - fftw_real ifftOutput [ m_nOutputPoints ]; + fftw_real* ifftOutput = new fftw_real [ m_nOutputPoints ]; rfftw_one (m_realPlanBackward, m_adRealFftSignal, ifftOutput); - for (int i = 0; i < m_nSignalPoints * m_iPreinterpolationFactor; i++) - output[i] = ifftOutput[i]; + for (i = 0; i < m_nSignalPoints * m_iPreinterpolationFactor; i++) + output[i] = ifftOutput[i]; + delete [] ifftOutput; } else if (m_idFilterMethod == FILTER_METHOD_FFTW) { - for (int i = 0; i < m_nSignalPoints; i++) + for (i = 0; i < m_nSignalPoints; i++) m_adComplexFftInput[i].re = input[i]; - fftw_complex fftOutput [ m_nFilterPoints ]; + fftw_complex* fftOutput = new fftw_complex [ m_nFilterPoints ]; fftw_one (m_complexPlanForward, m_adComplexFftInput, fftOutput); - for (int i = 0; i < m_nFilterPoints; i++) { + for (i = 0; i < m_nFilterPoints; i++) { m_adComplexFftSignal[i].re = m_adFilter[i] * fftOutput[i].re; m_adComplexFftSignal[i].im = m_adFilter[i] * fftOutput[i].im; - } - fftw_complex ifftOutput [ m_nOutputPoints ]; + } + delete [] fftOutput; + fftw_complex* ifftOutput = new fftw_complex [ m_nOutputPoints ]; fftw_one (m_complexPlanBackward, m_adComplexFftSignal, ifftOutput); - for (int i = 0; i < m_nSignalPoints * m_iPreinterpolationFactor; i++) - output[i] = ifftOutput[i].re; + for (i = 0; i < m_nSignalPoints * m_iPreinterpolationFactor; i++) + output[i] = ifftOutput[i].re; + delete [] ifftOutput; } -#endif +#endif + delete input; } @@ -487,15 +686,16 @@ for (int i = 0; i < np; i++) void ProcessSignal::finiteFourierTransform (const double input[], double output[], const int n, int direction) { - complex complexOutput[n]; + std::complex* complexOutput = new std::complex [n]; finiteFourierTransform (input, complexOutput, n, direction); for (int i = 0; i < n; i++) - output[i] = abs(complexOutput[n]); + output[i] = complexOutput[i].real(); + delete [] complexOutput; } void -ProcessSignal::finiteFourierTransform (const double input[], complex output[], const int n, int direction) +ProcessSignal::finiteFourierTransform (const double input[], std::complex output[], const int n, int direction) { if (direction < 0) direction = -1; @@ -515,13 +715,13 @@ ProcessSignal::finiteFourierTransform (const double input[], complex out sumReal /= n; sumImag /= n; } - output[i] = complex (sumReal, sumImag); + output[i] = std::complex (sumReal, sumImag); } } void -ProcessSignal::finiteFourierTransform (const complex input[], complex output[], const int n, int direction) +ProcessSignal::finiteFourierTransform (const std::complex input[], std::complex output[], const int n, int direction) { if (direction < 0) direction = -1; @@ -530,10 +730,10 @@ ProcessSignal::finiteFourierTransform (const complex input[], complex sum (0,0); + std::complex sum (0,0); for (int j = 0; j < n; j++) { double angle = i * j * angleIncrement; - complex exponentTerm (cos(angle), sin(angle)); + std::complex exponentTerm (cos(angle), sin(angle)); sum += input[j] * exponentTerm; } if (direction < 0) { @@ -544,7 +744,7 @@ ProcessSignal::finiteFourierTransform (const complex input[], complex input[], double output[], const int n, int direction) +ProcessSignal::finiteFourierTransform (const std::complex input[], double output[], const int n, int direction) { if (direction < 0) direction = -1; @@ -568,7 +768,7 @@ ProcessSignal::finiteFourierTransform (const complex input[], double out // Table-based routines void -ProcessSignal::finiteFourierTransform (const double input[], complex output[], int direction) const +ProcessSignal::finiteFourierTransform (const double input[], std::complex output[], int direction) const { if (direction < 0) direction = -1; @@ -591,13 +791,13 @@ ProcessSignal::finiteFourierTransform (const double input[], complex out sumReal /= m_nFilterPoints; sumImag /= m_nFilterPoints; } - output[i] = complex (sumReal, sumImag); + output[i] = std::complex (sumReal, sumImag); } } // (a+bi) * (c + di) = (ac - bd) + (ad + bc)i void -ProcessSignal::finiteFourierTransform (const complex input[], complex output[], int direction) const +ProcessSignal::finiteFourierTransform (const std::complex input[], std::complex output[], int direction) const { if (direction < 0) direction = -1; @@ -624,12 +824,12 @@ ProcessSignal::finiteFourierTransform (const complex input[], complex (sumReal, sumImag); + output[i] = std::complex (sumReal, sumImag); } } void -ProcessSignal::finiteFourierTransform (const complex input[], double output[], int direction) const +ProcessSignal::finiteFourierTransform (const std::complex input[], double output[], int direction) const { if (direction < 0) direction = -1; @@ -665,21 +865,26 @@ ProcessSignal::finiteFourierTransform (const complex input[], double out void ProcessSignal::shuffleNaturalToFourierOrder (double* pdVector, const int n) { - double* pdTemp = new double [n]; + double* pdTemp = new double [n]; + int i; if (n % 2) { // Odd int iHalfN = (n - 1) / 2; pdTemp[0] = pdVector[iHalfN]; - for (int i = 1; i <= iHalfN; i++) - pdTemp[i] = pdVector[i+iHalfN]; - for (int i = iHalfN+1; i < n; i++) - pdTemp[i] = pdVector[i-iHalfN]; + for (i = 0; i < iHalfN; i++) + pdTemp[i + 1] = pdVector[i + 1 + iHalfN]; + for (i = 0; i < iHalfN; i++) + pdTemp[i + iHalfN + 1] = pdVector[i]; } else { // Even int iHalfN = n / 2; pdTemp[0] = pdVector[iHalfN]; + for (i = 0; i < iHalfN; i++) + pdTemp[i + 1] = pdVector[i + iHalfN]; + for (i = 0; i < iHalfN - 1; i++) + pdTemp[i + iHalfN + 1] = pdVector[i]; } - for (int i = 0; i < n; i++) + for (i = 0; i < n; i++) pdVector[i] = pdTemp[i]; delete pdTemp; } @@ -688,21 +893,26 @@ ProcessSignal::shuffleNaturalToFourierOrder (double* pdVector, const int n) void ProcessSignal::shuffleFourierToNaturalOrder (double* pdVector, const int n) { - double* pdTemp = new double [n]; + double* pdTemp = new double [n]; + int i; if (n % 2) { // Odd int iHalfN = (n - 1) / 2; - pdTemp[iHalfN] = pdVector[0]; - for (int i = 1; i <= iHalfN; i++) - pdTemp[i] = pdVector[i+iHalfN]; - for (int i = iHalfN+1; i < n; i++) - pdTemp[i] = pdVector[i-iHalfN]; + pdTemp[iHalfN] = pdVector[0]; + for (i = 0; i < iHalfN; i++) + pdTemp[i + 1 + iHalfN] = pdVector[i + 1]; + for (i = 0; i < iHalfN; i++) + pdTemp[i] = pdVector[i + iHalfN + 1]; } else { // Even int iHalfN = n / 2; pdTemp[iHalfN] = pdVector[0]; + for (i = 0; i < iHalfN; i++) + pdTemp[i] = pdVector[i + iHalfN]; + for (i = 0; i < iHalfN - 1; i++) + pdTemp[i + iHalfN + 1] = pdVector[i+1]; } - for (int i = 0; i < n; i++) + for (i = 0; i < n; i++) pdVector[i] = pdTemp[i]; delete pdTemp; }