** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: procsignal.cpp,v 1.7 2000/09/07 14:29: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
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, int iTraceLevel, int iGeometry, double dFocalLength, SGP* pSGP)
-{
+{\r
+ int i;
m_idFilter = idFilter;
m_idDomain = idDomain;
m_idFilterMethod = idFilterMethod;
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* adFrequencyFilter = new double [m_nFilterPoints];
filter.copyFilterData (adFrequencyFilter, 0, m_nFilterPoints);
#ifdef HAVE_SGP
EZPlot* pEZPlot = NULL;
}
#endif
ProcessSignal::finiteFourierTransform (adFrequencyFilter, m_adFilter, m_nFilterPoints, -1);
+ delete adFrequencyFilter;\r
#ifdef HAVE_SGP
if (pEZPlot && m_traceLevel >= Trace::TRACE_PLOT) {
pEZPlot->ezset ("title Inverse Fourier Frequency: Fourier Order");
delete pEZPlot;
}
#endif
- for (int i = 0; i < m_nFilterPoints; i++) {
+ for (i = 0; i < m_nFilterPoints; i++) {
m_adFilter[i] /= m_dSignalInc;
}
}
if (m_idGeometry == Scanner::GEOMETRY_EQUILINEAR) {
- for (int i = 0; i < m_nFilterPoints; i++)
+ for (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++) {
+ 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)
m_nFilterPoints = 1 << nextPowerOf2;
#ifdef DEBUG
if (m_traceLevel >= Trace::TRACE_CONSOLE)
- cout << "nFilterPoints = " << m_nFilterPoints << endl;
+ std::cout << "nFilterPoints = " << m_nFilterPoints << endl;
#endif
}
m_nOutputPoints = m_nFilterPoints * m_iPreinterpolationFactor;
// 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++)
+ for (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++) {
+ 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)
m_nOutputPoints = m_nFilterPoints * m_iPreinterpolationFactor;
#ifdef DEBUG
if (m_traceLevel >= Trace::TRACE_CONSOLE)
- cout << "nFilterPoints = " << m_nFilterPoints << endl;
+ std::cout << "nFilterPoints = " << m_nFilterPoints << endl;
#endif
- double adSpatialFilter [m_nFilterPoints];
+ double* adSpatialFilter = new double [m_nFilterPoints];\r
SignalFilter filter (m_idFilter, m_dFilterMin, m_dFilterMax, nSpatialPoints, m_dBandwidth, m_dFilterParam, SignalFilter::DOMAIN_SPATIAL);
filter.copyFilterData (adSpatialFilter, 0, nSpatialPoints);
#ifdef HAVE_SGP
}
#endif
if (m_idGeometry == Scanner::GEOMETRY_EQUILINEAR) {
- for (int i = 0; i < m_nFilterPoints; i++)
+ for (i = 0; i < m_nFilterPoints; i++)
adSpatialFilter[i] *= 0.5;
} else if (m_idGeometry == Scanner::GEOMETRY_EQUIANGULAR) {
- for (int i = 0; i < m_nFilterPoints; i++) {
+ 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)
double dScale = 0.5 * sinScale * sinScale;
adSpatialFilter[i] *= dScale;
}
- }
- for (int i = nSpatialPoints; i < m_nFilterPoints; i++)
+ }\r
+ for (i = nSpatialPoints; i < m_nFilterPoints; i++)
adSpatialFilter[i] = 0;
m_adFilter = new double [m_nFilterPoints];
- complex<double> acInverseFilter [m_nFilterPoints];
+ std::complex<double>* acInverseFilter = new std::complex<double> [m_nFilterPoints];\r
finiteFourierTransform (adSpatialFilter, acInverseFilter, m_nFilterPoints, 1);
- for (int i = 0; i < m_nFilterPoints; i++)
- m_adFilter[i] = abs(acInverseFilter[i]) * m_dSignalInc;
+ delete adSpatialFilter;\r
+ for (i = 0; i < m_nFilterPoints; i++)
+ m_adFilter[i] = std::abs(acInverseFilter[i]) * m_dSignalInc;
+ delete acInverseFilter;\r
#ifdef HAVE_SGP
if (pEZPlot && m_traceLevel >= Trace::TRACE_PLOT) {
pEZPlot->ezset ("title Spatial Filter: Inverse");
pEZPlot->ezset ("yporigin 0.50");
pEZPlot->addCurve (m_adFilter, m_nFilterPoints);
pEZPlot->plot();
- delete pEZPlot;
+ delete pEZPlot;\r
}
#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;
#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;
}
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
void
ProcessSignal::filterSignal (const float constInput[], double output[]) const
{
- double input [m_nSignalPoints];
- for (int i = 0; i < m_nSignalPoints; i++)
+ double* input = new double [m_nSignalPoints];
+ int i;\r
+ for (i = 0; i < m_nSignalPoints; i++)
input[i] = constInput[i];
if (m_idGeometry == Scanner::GEOMETRY_EQUILINEAR) {
int iDetFromCenter = i - (m_nSignalPoints / 2);
input[i] *= m_dFocalLength * cos (iDetFromCenter * m_dSignalInc);
}
- }
+ }\r
if (m_idFilterMethod == FILTER_METHOD_CONVOLUTION) {
- for (int i = 0; i < m_nSignalPoints; i++)
+ 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<double> fftSignal[m_nFilterPoints];
- finiteFourierTransform (inputSignal, fftSignal, m_nFilterPoints, -1);
- for (int i = 0; i < m_nFilterPoints; i++)
+ std::complex<double>* fftSignal = new std::complex<double> [m_nFilterPoints];
+ finiteFourierTransform (inputSignal, fftSignal, m_nFilterPoints, -1);\r
+ 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);\r
+ delete fftSignal;
+ for (i = 0; i < m_nSignalPoints; i++)
+ output[i] = inverseFourier[i];\r
+ 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<double> fftSignal[m_nFilterPoints];
- finiteFourierTransform (inputSignal, fftSignal, -1);
- for (int i = 0; i < m_nFilterPoints; i++)
+ std::complex<double>* fftSignal = new std::complex<double> [m_nFilterPoints];
+ finiteFourierTransform (inputSignal, fftSignal, -1);\r
+ 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);\r
+ delete fftSignal;
+ for (i = 0; i < m_nSignalPoints; i++)
+ output[i] = inverseFourier[i];\r
+ 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];\r
+ 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];\r
+ 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 ];
+ }\r
+ 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;\r
+ delete [] ifftOutput;
}
-#endif
+#endif\r
+ delete input;
}
void
ProcessSignal::finiteFourierTransform (const double input[], double output[], const int n, int direction)
{
- complex<double> complexOutput[n];
+ std::complex<double>* complexOutput = new std::complex<double> [n];
finiteFourierTransform (input, complexOutput, n, direction);
for (int i = 0; i < n; i++)
- output[i] = complexOutput[i].real();
+ output[i] = complexOutput[i].real();\r
+ delete [] complexOutput;
}
void
-ProcessSignal::finiteFourierTransform (const double input[], complex<double> output[], const int n, int direction)
+ProcessSignal::finiteFourierTransform (const double input[], std::complex<double> output[], const int n, int direction)
{
if (direction < 0)
direction = -1;
sumReal /= n;
sumImag /= n;
}
- output[i] = complex<double> (sumReal, sumImag);
+ output[i] = std::complex<double> (sumReal, sumImag);
}
}
void
-ProcessSignal::finiteFourierTransform (const complex<double> input[], complex<double> output[], const int n, int direction)
+ProcessSignal::finiteFourierTransform (const std::complex<double> input[], std::complex<double> output[], const int n, int direction)
{
if (direction < 0)
direction = -1;
double angleIncrement = direction * 2 * PI / n;
for (int i = 0; i < n; i++) {
- complex<double> sum (0,0);
+ std::complex<double> sum (0,0);
for (int j = 0; j < n; j++) {
double angle = i * j * angleIncrement;
- complex<double> exponentTerm (cos(angle), sin(angle));
+ std::complex<double> exponentTerm (cos(angle), sin(angle));
sum += input[j] * exponentTerm;
}
if (direction < 0) {
}
void
-ProcessSignal::finiteFourierTransform (const complex<double> input[], double output[], const int n, int direction)
+ProcessSignal::finiteFourierTransform (const std::complex<double> input[], double output[], const int n, int direction)
{
if (direction < 0)
direction = -1;
// Table-based routines
void
-ProcessSignal::finiteFourierTransform (const double input[], complex<double> output[], int direction) const
+ProcessSignal::finiteFourierTransform (const double input[], std::complex<double> output[], int direction) const
{
if (direction < 0)
direction = -1;
sumReal /= m_nFilterPoints;
sumImag /= m_nFilterPoints;
}
- output[i] = complex<double> (sumReal, sumImag);
+ output[i] = std::complex<double> (sumReal, sumImag);
}
}
// (a+bi) * (c + di) = (ac - bd) + (ad + bc)i
void
-ProcessSignal::finiteFourierTransform (const complex<double> input[], complex<double> output[], int direction) const
+ProcessSignal::finiteFourierTransform (const std::complex<double> input[], std::complex<double> output[], int direction) const
{
if (direction < 0)
direction = -1;
sumReal /= m_nFilterPoints;
sumImag /= m_nFilterPoints;
}
- output[i] = complex<double> (sumReal, sumImag);
+ output[i] = std::complex<double> (sumReal, sumImag);
}
}
void
-ProcessSignal::finiteFourierTransform (const complex<double> input[], double output[], int direction) const
+ProcessSignal::finiteFourierTransform (const std::complex<double> input[], double output[], int direction) const
{
if (direction < 0)
direction = -1;
void
ProcessSignal::shuffleNaturalToFourierOrder (double* pdVector, const int n)
{
- double* pdTemp = new double [n];
+ double* pdTemp = new double [n];\r
+ int i;
if (n % 2) { // Odd
int iHalfN = (n - 1) / 2;
pdTemp[0] = pdVector[iHalfN];
- for (int i = 0; i < iHalfN; i++)
+ for (i = 0; i < iHalfN; i++)
pdTemp[i + 1] = pdVector[i + 1 + iHalfN];
- for (int i = 0; i < iHalfN; i++)
+ for (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++)
+ for (i = 0; i < iHalfN; i++)
pdTemp[i + 1] = pdVector[i + iHalfN];
- for (int i = 0; i < iHalfN - 1; i++)
+ 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;
}
void
ProcessSignal::shuffleFourierToNaturalOrder (double* pdVector, const int n)
{
- double* pdTemp = new double [n];
+ double* pdTemp = new double [n];\r
+ int i;
if (n % 2) { // Odd
int iHalfN = (n - 1) / 2;
- pdTemp[iHalfN] = pdVector[0];
- for (int i = 0; i < iHalfN; i++)
+ pdTemp[iHalfN] = pdVector[0];\r
+ for (i = 0; i < iHalfN; i++)
pdTemp[i + 1 + iHalfN] = pdVector[i + 1];
- for (int i = 0; i < iHalfN; i++)
+ for (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++)
+ for (i = 0; i < iHalfN; i++)
pdTemp[i] = pdVector[i + iHalfN];
- for (int i = 0; i < iHalfN - 1; i++)
+ 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;
}