X-Git-Url: http://git.kpe.io/?p=ctsim.git;a=blobdiff_plain;f=libctsim%2Fprojections.cpp;h=e5c79e7364f67a15a0a1ec5ce4b08f01ed0d2df7;hp=995c1649ec5327da84ad3890d3d6ad12e003b622;hb=728e9fcbe0b785e56e7dcd2bd305786c647050af;hpb=7f8f356151b0c8db0dbbf1c1896cc22630d6c774 diff --git a/libctsim/projections.cpp b/libctsim/projections.cpp index 995c164..e5c79e7 100644 --- a/libctsim/projections.cpp +++ b/libctsim/projections.cpp @@ -6,9 +6,9 @@ ** Date Started: Aug 84 ** ** This is part of the CTSim program -** Copyright (C) 1983-2000 Kevin Rosenberg +** Copyright (c) 1983-2001 Kevin Rosenberg ** -** $Id: projections.cpp,v 1.43 2001/01/12 16:41:56 kevin Exp $ +** $Id: projections.cpp,v 1.72 2001/03/29 21:25:49 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 @@ -33,14 +33,14 @@ const int Projections::POLAR_INTERP_NEAREST = 0; const int Projections::POLAR_INTERP_BILINEAR = 1; const int Projections::POLAR_INTERP_BICUBIC = 2; -const char* Projections::s_aszInterpName[] = +const char* const Projections::s_aszInterpName[] = { {"nearest"}, {"bilinear"}, // {"bicubic"}, }; -const char* Projections::s_aszInterpTitle[] = +const char* const Projections::s_aszInterpTitle[] = { {"Nearest"}, {"Bilinear"}, @@ -50,6 +50,7 @@ const char* Projections::s_aszInterpTitle[] = const int Projections::s_iInterpCount = sizeof(s_aszInterpName) / sizeof(char*); + /* NAME * Projections Constructor for projections matrix storage * @@ -148,14 +149,15 @@ Projections::initFromScanner (const Scanner& scanner) deleteProjData(); init (scanner.nView(), scanner.nDet()); - m_phmLen = scanner.phmLen(); m_rotInc = scanner.rotInc(); m_detInc = scanner.detInc(); + m_detStart = scanner.detStart(); m_geometry = scanner.geometry(); - m_focalLength = scanner.focalLength(); - m_fieldOfView = scanner.fieldOfView(); + m_dFocalLength = scanner.focalLength(); + m_dSourceDetectorLength = scanner.sourceDetectorLength(); + m_dViewDiameter = scanner.viewDiameter(); m_rotStart = 0; - m_detStart = -(scanner.detLen() / 2); + m_dFanBeamAngle = scanner.fanBeamAngle(); } void @@ -230,10 +232,11 @@ Projections::headerWrite (fnetorderstream& fs) kfloat64 _rotInc = m_rotInc; kfloat64 _detStart = m_detStart; kfloat64 _detInc = m_detInc; - kfloat64 _phmLen = m_phmLen; - kfloat64 _fieldOfView = m_fieldOfView; - kfloat64 _focalLength = m_focalLength; - + kfloat64 _viewDiameter = m_dViewDiameter; + kfloat64 _focalLength = m_dFocalLength; + kfloat64 _sourceDetectorLength = m_dSourceDetectorLength; + kfloat64 _fanBeamAngle = m_dFanBeamAngle; + fs.seekp(0); if (! fs) return false; @@ -248,9 +251,10 @@ Projections::headerWrite (fnetorderstream& fs) fs.writeFloat64 (_rotInc); fs.writeFloat64 (_detStart); fs.writeFloat64 (_detInc); - fs.writeFloat64 (_phmLen); + fs.writeFloat64 (_viewDiameter); fs.writeFloat64 (_focalLength); - fs.writeFloat64 (_fieldOfView); + fs.writeFloat64 (_sourceDetectorLength); + fs.writeFloat64 (_fanBeamAngle); fs.writeInt16 (_year); fs.writeInt16 (_month); fs.writeInt16 (_day); @@ -279,7 +283,7 @@ Projections::headerRead (fnetorderstream& fs) { kuint16 _hsize, _signature, _year, _month, _day, _hour, _minute, _second, _remarksize = 0; kuint32 _nView, _nDet, _geom; - kfloat64 _calcTime, _rotStart, _rotInc, _detStart, _detInc, _phmLen, _focalLength, _fieldOfView; + kfloat64 _calcTime, _rotStart, _rotInc, _detStart, _detInc, _focalLength, _sourceDetectorLength, _viewDiameter, _fanBeamAngle; fs.seekg(0); if (! fs) @@ -295,9 +299,10 @@ Projections::headerRead (fnetorderstream& fs) fs.readFloat64 (_rotInc); fs.readFloat64 (_detStart); fs.readFloat64 (_detInc); - fs.readFloat64 (_phmLen); + fs.readFloat64 (_viewDiameter); fs.readFloat64 (_focalLength); - fs.readFloat64 (_fieldOfView); + fs.readFloat64 (_sourceDetectorLength); + fs.readFloat64 (_fanBeamAngle); fs.readInt16 (_year); fs.readInt16 (_month); fs.readInt16 (_day); @@ -341,9 +346,10 @@ Projections::headerRead (fnetorderstream& fs) m_rotInc = _rotInc; m_detStart = _detStart; m_detInc = _detInc; - m_phmLen = _phmLen; - m_focalLength = _focalLength; - m_fieldOfView = _fieldOfView; + m_dFocalLength = _focalLength; + m_dSourceDetectorLength = _sourceDetectorLength; + m_dViewDiameter = _viewDiameter; + m_dFanBeamAngle = _fanBeamAngle; m_year = _year; m_month = _month; m_day = _day; @@ -630,13 +636,16 @@ Projections::printProjectionData (int startView, int endView) printf("Projections Data\n\n"); printf("Description: %s\n", m_remark.c_str()); printf("Geometry: %s\n", Scanner::convertGeometryIDToName (m_geometry)); - printf("nView = %8d nDet = %8d\n", m_nView, m_nDet); - printf("focalLength = %8.4f fieldOfView = %8.4f\n", m_focalLength, m_fieldOfView); - printf("rotStart = %8.4f rotInc = %8.4f\n", m_rotStart, m_rotInc); - printf("detStart = %8.4f detInc = %8.4f\n", m_detStart, m_detInc); + printf("nView = %8d nDet = %8d\n", m_nView, m_nDet); + printf("focalLength = %8.4f ViewDiameter = %8.4f\n", m_dFocalLength, m_dViewDiameter); + printf("fanBeamAngle= %8.4f SourceDetector = %8.4f\n", convertRadiansToDegrees(m_dFanBeamAngle), m_dSourceDetectorLength); + printf("rotStart = %8.4f rotInc = %8.4f\n", m_rotStart, m_rotInc); + printf("detStart = %8.4f detInc = %8.4f\n", m_detStart, m_detInc); if (m_projData != NULL) { if (startView < 0) startView = 0; + if (endView < 0) + endView = m_nView - 1; if (startView > m_nView - 1) startView = m_nView - 1; if (endView > m_nView - 1) @@ -655,16 +664,17 @@ void Projections::printScanInfo (std::ostringstream& os) const { os << "Number of detectors: " << m_nDet << "\n"; - os << " Number of views: " << m_nView<< "\n"; - os << " Remark: " << m_remark.c_str()<< "\n"; - os << " Geometry: " << Scanner::convertGeometryIDToName (m_geometry)<< "\n"; - os << " Focal Length: " << m_focalLength<< "\n"; - os << " Field Of View: " << m_fieldOfView<< "\n"; - os << " phmLen: " << m_phmLen<< "\n"; - os << " detStart: " << m_detStart<< "\n"; - os << " detInc: " << m_detInc<< "\n"; - os << " rotStart: " << m_rotStart<< "\n"; - os << " rotInc: " << m_rotInc<< "\n"; + os << "Number of views: " << m_nView<< "\n"; + os << "Description: " << m_remark.c_str()<< "\n"; + os << "Geometry: " << Scanner::convertGeometryIDToName (m_geometry)<< "\n"; + os << "Focal Length: " << m_dFocalLength<< "\n"; + os << "Source Detector Length: " << m_dSourceDetectorLength << "\n"; + os << "View Diameter: " << m_dViewDiameter<< "\n"; + os << "Fan Beam Angle: " << convertRadiansToDegrees(m_dFanBeamAngle) << "\n"; + os << "detStart: " << m_detStart<< "\n"; + os << "detInc: " << m_detInc<< "\n"; + os << "rotStart: " << m_rotStart<< "\n"; + os << "rotInc: " << m_rotInc<< "\n"; } @@ -678,27 +688,37 @@ Projections::convertPolar (ImageFile& rIF, int iInterpolationID) if (! v || nx == 0 || ny == 0) return false; + + Projections* pProj = this; + if (m_geometry == Scanner::GEOMETRY_EQUIANGULAR || m_geometry == Scanner::GEOMETRY_EQUILINEAR) + pProj = interpolateToParallel(); Array2d adView (nx, ny); Array2d adDet (nx, ny); double** ppdView = adView.getArray(); double** ppdDet = adDet.getArray(); - calcArrayPolarCoordinates (nx, ny, ppdView, ppdDet); - - std::complex** ppcDetValue = new std::complex* [m_nView]; - for (unsigned int iView = 0; iView < m_nView; iView++) { - ppcDetValue[iView] = new std::complex [m_nDet]; - for (unsigned int iDet = 0; iDet < m_nDet; iDet++) - ppcDetValue[iView][iDet] = std::complex(getDetectorArray (iView).detValues()[iDet], 0); + std::complex** ppcDetValue = new std::complex* [pProj->m_nView]; + unsigned int iView; + for (iView = 0; iView < pProj->m_nView; iView++) { + ppcDetValue[iView] = new std::complex [pProj->m_nDet]; + DetectorValue* detval = pProj->getDetectorArray (iView).detValues(); + for (unsigned int iDet = 0; iDet < pProj->m_nDet; iDet++) + ppcDetValue[iView][iDet] = std::complex(detval[iDet], 0); } - interpolatePolar (v, vImag, nx, ny, ppcDetValue, ppdView, ppdDet, m_nView, m_nDet, iInterpolationID); + pProj->calcArrayPolarCoordinates (nx, ny, ppdView, ppdDet, pProj->m_nDet, 1., pProj->m_detInc); - for (iView = 0; iView < m_nView; iView++) + pProj->interpolatePolar (v, vImag, nx, ny, ppcDetValue, ppdView, ppdDet, pProj->m_nView, pProj->m_nDet, + pProj->m_nDet, iInterpolationID); + + for (iView = 0; iView < pProj->m_nView; iView++) delete [] ppcDetValue[iView]; delete [] ppcDetValue; + if (m_geometry == Scanner::GEOMETRY_EQUIANGULAR || m_geometry == Scanner::GEOMETRY_EQUILINEAR) + delete pProj; + return true; } @@ -706,6 +726,10 @@ Projections::convertPolar (ImageFile& rIF, int iInterpolationID) bool Projections::convertFFTPolar (ImageFile& rIF, int iInterpolationID, int iZeropad) { +#ifndef HAVE_FFTW + rIF.arrayDataClear(); + return false; +#else unsigned int nx = rIF.nx(); unsigned int ny = rIF.ny(); ImageFileArray v = rIF.getArray(); @@ -716,42 +740,67 @@ Projections::convertFFTPolar (ImageFile& rIF, int iInterpolationID, int iZeropad if (! v || nx == 0 || ny == 0) return false; -#ifndef HAVE_FFT - return false; -#else - Array2d adView (nx, ny); - Array2d adDet (nx, ny); - double** ppdView = adView.getArray(); - double** ppdDet = adDet.getArray(); + if (m_geometry != Scanner::GEOMETRY_PARALLEL) { + sys_error (ERR_WARNING, "convertFFTPolar supports Parallel only"); + return false; + } + int iInterpDet = nx; + int iNumInterpDetWithZeros = ProcessSignal::addZeropadFactor (iInterpDet, iZeropad); + + double dZeropadRatio = static_cast(iNumInterpDetWithZeros) / static_cast(iInterpDet); + + fftw_plan plan = fftw_create_plan (iNumInterpDetWithZeros, FFTW_FORWARD, FFTW_IN_PLACE | FFTW_ESTIMATE | FFTW_USE_WISDOM); + + fftw_complex* pcIn = new fftw_complex [iNumInterpDetWithZeros]; std::complex** ppcDetValue = new std::complex* [m_nView]; - unsigned int iView; - double* pdDet = new double [m_nDet]; - fftw_complex* pcIn = new fftw_complex [m_nDet]; - fftw_plan plan = fftw_create_plan (m_nDet, FFTW_FORWARD, FFTW_IN_PLACE); - - for (iView = 0; iView < m_nView; iView++) { - unsigned int iDet; - for (iDet = 0; iDet < m_nDet; iDet++) { - pcIn[iDet].re = getDetectorArray(iView).detValues()[iDet]; + double dInterpScale = (m_nDet-1) / static_cast(iInterpDet-1) / SQRT2; + + double dFFTScale = 1. / static_cast(iInterpDet * iInterpDet); + int iMidPoint = iInterpDet / 2; + double dMidPoint = static_cast(iInterpDet) / 2.; + int iZerosAdded = iNumInterpDetWithZeros - iInterpDet; + for (unsigned int iView = 0; iView < m_nView; iView++) { + DetectorValue* detval = getDetectorArray(iView).detValues(); + LinearInterpolator projInterp (detval, m_nDet); + for (unsigned int iDet = 0; iDet < iInterpDet; iDet++) { + double dInterpPos = (m_nDet / 2.) + (iDet - dMidPoint) * dInterpScale; + pcIn[iDet].re = projInterp.interpolate (dInterpPos) * dInterpScale; pcIn[iDet].im = 0; } + Fourier::shuffleFourierToNaturalOrder (pcIn, iInterpDet); + if (iZerosAdded > 0) { + for (unsigned int iDet1 = iMidPoint; iDet1 < iInterpDet; iDet1++) + pcIn[iDet1+iZerosAdded] = pcIn[iDet1]; + for (unsigned int iDet2 = iMidPoint; iDet2 < iMidPoint + iZerosAdded; iDet2++) + pcIn[iDet2].re = pcIn[iDet2].im = 0; + } + fftw_one (plan, pcIn, NULL); - ppcDetValue[iView] = new std::complex [m_nDet]; - for (iDet = 0; iDet < m_nDet; iDet++) - ppcDetValue[iView][iDet] = std::complex (pcIn[iDet].re, pcIn[iDet].im); - Fourier::shuffleFourierToNaturalOrder (ppcDetValue[iView], m_nDet); + + ppcDetValue[iView] = new std::complex [iNumInterpDetWithZeros]; + for (unsigned int iD = 0; iD < iNumInterpDetWithZeros; iD++) { + ppcDetValue[iView][iD] = std::complex (pcIn[iD].re * dFFTScale, pcIn[iD].im * dFFTScale); + } + + Fourier::shuffleFourierToNaturalOrder (ppcDetValue[iView], iNumInterpDetWithZeros); } + delete [] pcIn; fftw_destroy_plan (plan); - delete [] pcIn; - calcArrayPolarCoordinates (nx, ny, ppdView, ppdDet); + Array2d adView (nx, ny); + Array2d adDet (nx, ny); + double** ppdView = adView.getArray(); + double** ppdDet = adDet.getArray(); + calcArrayPolarCoordinates (nx, ny, ppdView, ppdDet, iNumInterpDetWithZeros, dZeropadRatio, + m_detInc * dInterpScale); - interpolatePolar (v, vImag, nx, ny, ppcDetValue, ppdView, ppdDet, m_nView, m_nDet, iInterpolationID); + interpolatePolar (v, vImag, nx, ny, ppcDetValue, ppdView, ppdDet, m_nView, m_nDet, iNumInterpDetWithZeros, + iInterpolationID); - for (iView = 0; iView < m_nView; iView++) - delete [] ppcDetValue[iView]; + for (int i = 0; i < m_nView; i++) + delete [] ppcDetValue[i]; delete [] ppcDetValue; return true; @@ -760,23 +809,31 @@ Projections::convertFFTPolar (ImageFile& rIF, int iInterpolationID, int iZeropad void -Projections::calcArrayPolarCoordinates (unsigned int nx, unsigned int ny, double** ppdView, double** ppdDet) +Projections::calcArrayPolarCoordinates (unsigned int nx, unsigned int ny, double** ppdView, double** ppdDet, + int iNumDetWithZeros, double dZeropadRatio, double dDetInc) { - double xMin = -m_phmLen / 2; - double xMax = xMin + m_phmLen; - double yMin = -m_phmLen / 2; - double yMax = yMin + m_phmLen; - +// double dLength = viewDiameter(); + double dLength = phmLen(); + double xMin = -dLength / 2; + double xMax = xMin + dLength; + double yMin = -dLength / 2; + double yMax = yMin + dLength; + double xCent = (xMin + xMax) / 2; + double yCent = (yMin + yMax) / 2; + + xMin = (xMin - xCent) * dZeropadRatio + xCent; + xMax = (xMax - xCent) * dZeropadRatio + xCent; + yMin = (yMin - yCent) * dZeropadRatio + yCent; + yMax = (yMax - yCent) * dZeropadRatio + yCent; + double xInc = (xMax - xMin) / nx; // size of cells double yInc = (yMax - yMin) / ny; - - int iDetCenter = (m_nDet - 1) / 2; // index refering to L=0 projection - if (m_geometry != Scanner::GEOMETRY_PARALLEL) { - sys_error (ERR_WARNING, "convertPolar supports Parallel only"); - return; - } - + // +1 is correct for frequency data, ndet-1 is correct for projections + int iDetCenter = (iNumDetWithZeros - 1) / 2; // index refering to L=0 projection + if (isEven (iNumDetWithZeros)) + iDetCenter = (iNumDetWithZeros + 1) / 2; + // Calculates polar coordinates (view#, det#) for each point on phantom grid double x = xMin + xInc / 2; // Rectang coords of center of pixel for (unsigned int ix = 0; ix < nx; x += xInc, ix++) { @@ -785,85 +842,351 @@ Projections::calcArrayPolarCoordinates (unsigned int nx, unsigned int ny, double double r = ::sqrt (x * x + y * y); double phi = atan2 (y, x); + if (phi < 0) + phi += TWOPI; if (phi >= PI) { phi -= PI; - } else if (phi < 0) { - phi += PI; - } else r = -r; + } ppdView[ix][iy] = (phi - m_rotStart) / m_rotInc; - ppdDet[ix][iy] = (r / m_detInc) + iDetCenter; + ppdDet[ix][iy] = (r / dDetInc) + iDetCenter; } } } void Projections::interpolatePolar (ImageFileArray& v, ImageFileArray& vImag, - unsigned int nx, unsigned int ny, std::complex** ppcDetValue, - double** ppdView, double** ppdDet, unsigned int nView, unsigned int nDet, int iInterpolationID) + unsigned int nx, unsigned int ny, std::complex** ppcDetValue, double** ppdView, + double** ppdDet, unsigned int nView, unsigned int nDet, unsigned int nDetWithZeros, int iInterpolationID) { + typedef std::complex complexValue; + + BilinearInterpolator* pBilinear; + if (iInterpolationID == POLAR_INTERP_BILINEAR) + pBilinear = new BilinearInterpolator (ppcDetValue, nView, nDetWithZeros); + + BicubicPolyInterpolator* pBicubic; + if (iInterpolationID == POLAR_INTERP_BICUBIC) + pBicubic = new BicubicPolyInterpolator (ppcDetValue, nView, nDetWithZeros); + for (unsigned int ix = 0; ix < ny; ix++) { for (unsigned int iy = 0; iy < ny; iy++) { + if (iInterpolationID == POLAR_INTERP_NEAREST) { - int iView = nearest (ppdView[ix][iy]); - int iDet = nearest (ppdDet[ix][iy]); + unsigned int iView = nearest (ppdView[ix][iy]); + unsigned int iDet = nearest (ppdDet[ix][iy]); if (iView == nView) { iView = 0; - // iDet = m_nDet - iDet; + iDet = m_nDet - iDet; } - if (iDet >= 0 && iDet < nDet && iView >= 0 && iView < nView) { + if (iDet >= 0 && iDet < nDetWithZeros && iView >= 0 && iView < nView) { v[ix][iy] = ppcDetValue[iView][iDet].real(); if (vImag) vImag[ix][iy] = ppcDetValue[iView][iDet].imag(); - } else { - sys_error (ERR_SEVERE, "Can't find projection data for ix=%d,iy=%d with radView=%f and radDet=%f", - ix, iy, ppdView[ix][iy], ppdDet[ix][iy]); + } else v[ix][iy] = 0; - } + } else if (iInterpolationID == POLAR_INTERP_BILINEAR) { - int iFloorView = static_cast(ppdView[ix][iy]); - double dFracView = ppdView[ix][iy] - iFloorView; - int iFloorDet = static_cast(ppdDet[ix][iy]); - double dFracDet = ppdDet[ix][iy] - iFloorDet; - - if (iFloorDet >= 0 && iFloorView >= 0) { - std::complex v1 = ppcDetValue[iFloorView][iFloorDet]; - std::complex v2, v3, v4; - if (iFloorView < nView - 1) - v2 = ppcDetValue[iFloorView + 1][iFloorDet]; - else - v2 = ppcDetValue[0][iFloorDet]; - if (iFloorDet < nDet - 1) - v4 = ppcDetValue[iFloorView][iFloorDet+1]; - else - v4 = v1; - if (iFloorView < nView - 1 && iFloorDet < nDet - 1) - v3 = ppcDetValue [iFloorView+1][iFloorDet+1]; - else if (iFloorView < nView - 1) - v3 = v2; - else - v3 = ppcDetValue[0][iFloorDet+1]; - std::complex vInterp = (1 - dFracView) * (1 - dFracDet) * v1 + - dFracView * (1 - dFracDet) * v2 + dFracView * dFracDet * v3 + - dFracDet * (1 - dFracView) * v4; - v[ix][iy] = vInterp.real(); - if (vImag) - vImag[ix][iy] = vInterp.imag(); - } else { - sys_error (ERR_SEVERE, "Can't find projection data for ix=%d,iy=%d with radView=%f and radDet=%f", - ix, iy, ppdView[ix][iy], ppdDet[ix][iy]); - v[ix][iy] = 0; - if (vImag) - vImag[ix][iy] = 0; - } + std::complex vInterp = pBilinear->interpolate (ppdView[ix][iy], ppdDet[ix][iy]); + v[ix][iy] = vInterp.real(); + if (vImag) + vImag[ix][iy] = vInterp.imag(); } else if (iInterpolationID == POLAR_INTERP_BICUBIC) { - v[ix][iy] =0; - if (vImag) - vImag[ix][iy] = 0; + std::complex vInterp = pBicubic->interpolate (ppdView[ix][iy], ppdDet[ix][iy]); + v[ix][iy] = vInterp.real(); + if (vImag) + vImag[ix][iy] = vInterp.imag(); + } + } + } +} + +bool +Projections::initFromSomatomAR_STAR (int iNViews, int iNDets, unsigned char* pData, unsigned long lDataLength) +{ + init (iNViews, iNDets); + m_geometry = Scanner::GEOMETRY_EQUIANGULAR; + m_dFocalLength = 510; + m_dSourceDetectorLength = 890; + m_detInc = convertDegreesToRadians (3.06976 / 60); + m_dFanBeamAngle = iNDets * m_detInc; + m_detStart = -(m_dFanBeamAngle / 2); + m_rotInc = TWOPI / static_cast(iNViews); + m_rotStart = 0; + m_dViewDiameter = sin (m_dFanBeamAngle / 2) * m_dFocalLength * 2; + + if (! ((iNViews == 750 && lDataLength == 1560000L) || (iNViews == 950 && lDataLength == 1976000L) + || (iNViews == 1500 && lDataLength == 3120000))) + return false; + + double dCenter = (iNDets - 1.) / 2.; // change from (Nm+1)/2 because of 0 vs. 1 indexing + double* pdCosScale = new double [iNDets]; + for (int i = 0; i < iNDets; i++) + pdCosScale[i] = 1. / cos ((i - dCenter) * m_detInc); + + long lDataPos = 0; + for (int iv = 0; iv < iNViews; iv++) { + unsigned char* pArgBase = pData + lDataPos; + unsigned char* p = pArgBase+0; SwapBytes4IfLittleEndian (p); + long lProjNumber = *reinterpret_cast(p); + + p = pArgBase+20; SwapBytes4IfLittleEndian (p); + long lEscale = *reinterpret_cast(p); + + p = pArgBase+28; SwapBytes4IfLittleEndian (p); + long lTime = *reinterpret_cast(p); + + p = pArgBase + 4; SwapBytes4IfLittleEndian (p); + double dAlpha = *reinterpret_cast(p) + HALFPI; + + p = pArgBase+12; SwapBytes4IfLittleEndian (p); + double dAlign = *reinterpret_cast(p); + + p = pArgBase + 16; SwapBytes4IfLittleEndian (p); + double dMaxValue = *reinterpret_cast(p); + + DetectorArray& detArray = getDetectorArray (iv); + detArray.setViewAngle (dAlpha); + DetectorValue* detval = detArray.detValues(); + + double dViewScale = 1. / (2294.4871 * ::pow (2.0, -lEscale)); + lDataPos += 32; + for (int id = 0; id < iNDets; id++) { + int iV = pData[lDataPos+1] + (pData[lDataPos] << 8); + if (iV > 32767) // two's complement signed conversion + iV = iV - 65536; + detval[id] = iV * dViewScale * pdCosScale[id]; + lDataPos += 2; + } +#if 1 + for (int k = iNDets - 2; k >= 0; k--) + detval[k+1] = detval[k]; + detval[0] = 0; +#endif + } + + delete pdCosScale; + return true; +} + +Projections* +Projections::interpolateToParallel () const +{ + if (m_geometry == Scanner::GEOMETRY_PARALLEL) + return const_cast(this); + + int nDet = m_nDet; + int nView = m_nView; + Projections* pProjNew = new Projections (nView, nDet); + pProjNew->m_geometry = Scanner::GEOMETRY_PARALLEL; + pProjNew->m_dFocalLength = m_dFocalLength; + pProjNew->m_dSourceDetectorLength = m_dSourceDetectorLength; + pProjNew->m_dViewDiameter = m_dViewDiameter; + pProjNew->m_dFanBeamAngle = m_dFanBeamAngle; + pProjNew->m_calcTime = 0; + pProjNew->m_remark = m_remark; + pProjNew->m_remark += "; Interpolate to Parallel"; + pProjNew->m_label.setLabelType (Array2dFileLabel::L_HISTORY); + pProjNew->m_label.setLabelString (pProjNew->m_remark); + pProjNew->m_label.setCalcTime (pProjNew->m_calcTime); + pProjNew->m_label.setDateTime (pProjNew->m_year, pProjNew->m_month, pProjNew->m_day, pProjNew->m_hour, pProjNew->m_minute, pProjNew->m_second); + + pProjNew->m_rotStart = 0; +#ifdef CONVERT_PARALLEL_PI + pProjNew->m_rotInc = PI / nView;; +#else + pProjNew->m_rotInc = TWOPI / nView; +#endif + pProjNew->m_detStart = -m_dViewDiameter / 2; + pProjNew->m_detInc = m_dViewDiameter / nDet; + if (isEven (nDet)) // even + pProjNew->m_detInc = m_dViewDiameter / (nDet - 1); + + ParallelRaysums parallel (this, ParallelRaysums::THETA_RANGE_NORMALIZE_TO_TWOPI); + + double* pdThetaValuesForT = new double [pProjNew->nView()]; + double* pdRaysumsForT = new double [pProjNew->nView()]; + + // interpolate to evenly spaced theta (views) + double dDetPos = pProjNew->m_detStart; + for (int iD = 0; iD < pProjNew->nDet(); iD++, dDetPos += pProjNew->m_detInc) { + parallel.getThetaAndRaysumsForT (iD, pdThetaValuesForT, pdRaysumsForT); + + double dViewAngle = m_rotStart; + int iLastFloor = -1; + for (int iV = 0; iV < pProjNew->nView(); iV++, dViewAngle += pProjNew->m_rotInc) { + DetectorValue* detValues = pProjNew->getDetectorArray (iV).detValues(); + LinearInterpolator interp (pdThetaValuesForT, pdRaysumsForT, pProjNew->nView(), false); + detValues[iD] = interp.interpolate (dViewAngle, &iLastFloor); + } + } + delete pdThetaValuesForT; + delete pdRaysumsForT; + + // interpolate to evenly space t (detectors) + double* pdOriginalDetPositions = new double [pProjNew->nDet()]; + parallel.getDetPositions (pdOriginalDetPositions); + + double* pdDetValueCopy = new double [pProjNew->nDet()]; + double dViewAngle = m_rotStart; + for (int iV = 0; iV < pProjNew->nView(); iV++, dViewAngle += pProjNew->m_rotInc) { + DetectorArray& detArray = pProjNew->getDetectorArray (iV); + DetectorValue* detValues = detArray.detValues(); + detArray.setViewAngle (dViewAngle); + + for (int i = 0; i < pProjNew->nDet(); i++) + pdDetValueCopy[i] = detValues[i]; + + double dDetPos = pProjNew->m_detStart; + int iLastFloor = -1; + LinearInterpolator interp (pdOriginalDetPositions, pdDetValueCopy, pProjNew->nDet(), false); + for (int iD = 0; iD < pProjNew->nDet(); iD++, dDetPos += pProjNew->m_detInc) + detValues[iD] = interp.interpolate (dDetPos, &iLastFloor); + } + delete pdDetValueCopy; + delete pdOriginalDetPositions; + + return pProjNew; +} + + +/////////////////////////////////////////////////////////////////////////////// +// +// Class ParallelRaysums +// +// Used for converting divergent beam raysums into Parallel raysums +// +/////////////////////////////////////////////////////////////////////////////// + +ParallelRaysums::ParallelRaysums (const Projections* pProjections, int iThetaRange) +: m_iNumCoordinates(0), m_iNumView(pProjections->nView()), m_iNumDet(pProjections->nDet()), + m_iThetaRange (iThetaRange), m_pCoordinates(NULL) +{ + int iGeometry = pProjections->geometry(); + double dDetInc = pProjections->detInc(); + double dDetStart = pProjections->detStart(); + double dFocalLength = pProjections->focalLength(); + + m_iNumCoordinates = m_iNumView * m_iNumDet; + m_pCoordinates = new ParallelRaysumCoordinate [m_iNumCoordinates]; + m_vecpCoordinates.reserve (m_iNumCoordinates); + for (int i = 0; i < m_iNumCoordinates; i++) + m_vecpCoordinates[i] = m_pCoordinates + i; + + int iCoordinate = 0; + for (int iV = 0; iV < m_iNumView; iV++) { + double dViewAngle = pProjections->getDetectorArray(iV).viewAngle(); + const DetectorValue* detValues = pProjections->getDetectorArray(iV).detValues(); + + double dDetPos = dDetStart; + for (int iD = 0; iD < m_iNumDet; iD++) { + ParallelRaysumCoordinate* pC = m_vecpCoordinates[iCoordinate++]; + + if (iGeometry == Scanner::GEOMETRY_PARALLEL) { + pC->m_dTheta = dViewAngle; + pC->m_dT = dDetPos; + } else if (iGeometry == Scanner::GEOMETRY_EQUILINEAR) { + double dFanAngle = atan (dDetPos / pProjections->sourceDetectorLength()); + pC->m_dTheta = dViewAngle + dFanAngle; + pC->m_dT = dFocalLength * sin(dFanAngle); + + } else if (iGeometry == Scanner::GEOMETRY_EQUIANGULAR) { + // fan angle is same as dDetPos + pC->m_dTheta = dViewAngle + dDetPos; + pC->m_dT = dFocalLength * sin (dDetPos); + } + if (m_iThetaRange != THETA_RANGE_UNCONSTRAINED) { + pC->m_dTheta = normalizeAngle (pC->m_dTheta); + if (m_iThetaRange == THETA_RANGE_FOLD_TO_PI && pC->m_dTheta >= PI) { + pC->m_dTheta -= PI; + pC->m_dT = -pC->m_dT; + } } + pC->m_dRaysum = detValues[iD]; + dDetPos += dDetInc; } } } +ParallelRaysums::~ParallelRaysums() +{ + delete m_pCoordinates; +} + +ParallelRaysums::CoordinateContainer& +ParallelRaysums::getSortedByTheta() +{ + if (m_vecpSortedByTheta.size() == 0) { + m_vecpSortedByTheta.resize (m_iNumCoordinates); + for (int i = 0; i < m_iNumCoordinates; i++) + m_vecpSortedByTheta[i] = m_vecpCoordinates[i]; + std::sort (m_vecpSortedByTheta.begin(), m_vecpSortedByTheta.end(), ParallelRaysumCoordinate::compareByTheta); + } + + return m_vecpSortedByTheta; +} + +ParallelRaysums::CoordinateContainer& +ParallelRaysums::getSortedByT() +{ + if (m_vecpSortedByT.size() == 0) { + m_vecpSortedByT.resize (m_iNumCoordinates); + for (int i = 0; i < m_iNumCoordinates; i++) + m_vecpSortedByT[i] = m_vecpCoordinates[i]; + std::sort (m_vecpSortedByT.begin(), m_vecpSortedByT.end(), ParallelRaysumCoordinate::compareByT); + } + + return m_vecpSortedByT; +} + + +void +ParallelRaysums::getLimits (double* dMinT, double* dMaxT, double* dMinTheta, double* dMaxTheta) const +{ + if (m_iNumCoordinates <= 0) + return; + + *dMinT = *dMaxT = m_vecpCoordinates[0]->m_dT; + *dMinTheta = *dMaxTheta = m_vecpCoordinates[0]->m_dTheta; + for (int i = 0; i < m_iNumCoordinates; i++) { + double dT = m_vecpCoordinates[i]->m_dT; + double dTheta = m_vecpCoordinates[i]->m_dTheta; + + if (dT < *dMinT) + *dMinT = dT; + else if (dT > *dMaxT) + *dMaxT = dT; + + if (dTheta < *dMinTheta) + *dMinTheta = dTheta; + else if (dTheta > *dMaxTheta) + *dMaxTheta = dTheta; + } +} + +void +ParallelRaysums::getThetaAndRaysumsForT (int iTheta, double* pTheta, double* pRaysum) +{ + const CoordinateContainer& coordsT = getSortedByT(); + + int iBase = iTheta * m_iNumView; + for (int i = 0; i < m_iNumView; i++) { + int iPos = iBase + i; + pTheta[i] = coordsT[iPos]->m_dTheta; + pRaysum[i] = coordsT[iPos]->m_dRaysum; + } +} + +void +ParallelRaysums::getDetPositions (double* pdDetPos) +{ + const CoordinateContainer& coordsT = getSortedByT(); + + int iPos = 0; + for (int i = 0; i < m_iNumDet; i++) { + pdDetPos[i] = coordsT[iPos]->m_dT; + iPos += m_iNumView; + } +}