X-Git-Url: http://git.kpe.io/?a=blobdiff_plain;f=libctsim%2Fprocsignal.cpp;h=5a52c03c300ea3108787bc8ad17dc4356a04c557;hb=ff9c2e8f6e126acbef08e0dfccc6ea112b44ca41;hp=9fdbb682a1fbb07f9aa30022178bd25e5fafd1e7;hpb=e36dfad3f0818b4c3457fbe7277faa6f4ca28dfe;p=ctsim.git diff --git a/libctsim/procsignal.cpp b/libctsim/procsignal.cpp index 9fdbb68..5a52c03 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.7 2000/09/07 14:29:05 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,25 @@ 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) { 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 +137,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 +162,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,63 +170,220 @@ 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]; 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); +#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 (int i = 0; i < m_nFilterPoints; i++) { + m_adFilter[i] /= m_dSignalInc; + } } - m_nOutputPoints = m_nFilterPoints * m_iPreinterpolationFactor; + if (m_idGeometry == Scanner::GEOMETRY_EQUILINEAR) { + for (int i = 0; i < m_nFilterPoints; i++) + m_adFilter[i] *= 0.5; + } else if (m_idGeometry == Scanner::GEOMETRY_EQUIANGULAR) { + for (int 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) + 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 (int i = 0; i < m_nFilterPoints; i++) + m_adFilter[i] *= 0.5; + } else if (m_idGeometry == Scanner::GEOMETRY_EQUIANGULAR) { + for (int 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); + // 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) + cout << "nFilterPoints = " << m_nFilterPoints << endl; +#endif + double adSpatialFilter [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 (int i = 0; i < m_nFilterPoints; i++) - m_adFilter [i] = adInverseFilter[i]; + adSpatialFilter[i] *= 0.5; + } else if (m_idGeometry == Scanner::GEOMETRY_EQUIANGULAR) { + for (int 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 (int i = nSpatialPoints; i < m_nFilterPoints; i++) + adSpatialFilter[i] = 0; + m_adFilter = new double [m_nFilterPoints]; + complex acInverseFilter [m_nFilterPoints]; + finiteFourierTransform (adSpatialFilter, acInverseFilter, m_nFilterPoints, 1); + for (int i = 0; i < m_nFilterPoints; i++) + m_adFilter[i] = abs(acInverseFilter[i]) * m_dSignalInc; +#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; @@ -262,6 +429,7 @@ ProcessSignal::~ProcessSignal (void) { delete [] m_adFourierSinTable; delete [] m_adFourierCosTable; + delete [] m_adFilter; #if HAVE_FFTW if (m_idFilterMethod == FILTER_METHOD_FFTW) { @@ -353,11 +521,26 @@ ProcessSignal::convertFilterGenerationIDToTitle (const int fgID) } void -ProcessSignal::filterSignal (const float input[], double output[]) const +ProcessSignal::filterSignal (const float constInput[], double output[]) const { + double input [m_nSignalPoints]; + for (int 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 (int 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++) @@ -491,7 +674,7 @@ ProcessSignal::finiteFourierTransform (const double input[], double output[], co finiteFourierTransform (input, complexOutput, n, direction); for (int i = 0; i < n; i++) - output[i] = abs(complexOutput[n]); + output[i] = complexOutput[i].real(); } void @@ -670,13 +853,17 @@ ProcessSignal::shuffleNaturalToFourierOrder (double* pdVector, const int n) 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 (int i = 0; i < iHalfN; i++) + pdTemp[i + 1] = pdVector[i + 1 + iHalfN]; + for (int i = 0; i < iHalfN; i++) + pdTemp[i + iHalfN + 1] = pdVector[i]; } else { // Even int iHalfN = n / 2; pdTemp[0] = pdVector[iHalfN]; + for (int i = 0; i < iHalfN; i++) + pdTemp[i + 1] = pdVector[i + iHalfN]; + for (int i = 0; i < iHalfN - 1; i++) + pdTemp[i + iHalfN + 1] = pdVector[i]; } for (int i = 0; i < n; i++) @@ -693,13 +880,17 @@ ProcessSignal::shuffleFourierToNaturalOrder (double* pdVector, const int n) 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]; + for (int i = 0; i < iHalfN; i++) + pdTemp[i + 1 + iHalfN] = pdVector[i + 1]; + for (int i = 0; i < iHalfN; i++) + pdTemp[i] = pdVector[i + iHalfN + 1]; } else { // Even int iHalfN = n / 2; pdTemp[iHalfN] = pdVector[0]; + for (int i = 0; i < iHalfN; i++) + pdTemp[i] = pdVector[i + iHalfN]; + for (int i = 0; i < iHalfN - 1; i++) + pdTemp[i + iHalfN + 1] = pdVector[i+1]; } for (int i = 0; i < n; i++)