X-Git-Url: http://git.kpe.io/?p=ctsim.git;a=blobdiff_plain;f=libctsim%2Fprojections.cpp;h=2ca1ce38e12af9fbf708595028df1f9dc9c3fbc8;hp=edbed03dc8ecbea37166d9ebde3589a16f036053;hb=c0f892798de8f89715266150f7d8e413f2cf29fe;hpb=dc034c9d0b7d9c3874a324a4c2c189a02945adc8 diff --git a/libctsim/projections.cpp b/libctsim/projections.cpp index edbed03..2ca1ce3 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.32 2000/12/16 06:12:47 kevin Exp $ +** $Id: projections.cpp,v 1.77 2002/05/28 18:43:16 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 @@ -25,35 +25,58 @@ ******************************************************************************/ #include "ct.h" - -const kuint16 Projections::m_signature = ('P'*256 + 'J'); + +const kuint16 Projections::m_signature = ('P'*256 + 'J'); + +const int Projections::POLAR_INTERP_INVALID = -1; +const int Projections::POLAR_INTERP_NEAREST = 0; +const int Projections::POLAR_INTERP_BILINEAR = 1; +const int Projections::POLAR_INTERP_BICUBIC = 2; + +const char* const Projections::s_aszInterpName[] = +{ + {"nearest"}, + {"bilinear"}, +// {"bicubic"}, +}; + +const char* const Projections::s_aszInterpTitle[] = +{ + {"Nearest"}, + {"Bilinear"}, +// {"Bicubic"}, +}; + +const int Projections::s_iInterpCount = sizeof(s_aszInterpName) / sizeof(char*); + + /* NAME - * Projections Constructor for projections matrix storage - * - * SYNOPSIS - * proj = projections_create (filename, nView, nDet) - * Projections& proj Allocated projections structure & matrix - * int nView Number of rotated view - * int nDet Number of detectors - * - */ +* Projections Constructor for projections matrix storage +* +* SYNOPSIS +* proj = projections_create (filename, nView, nDet) +* Projections& proj Allocated projections structure & matrix +* int nView Number of rotated view +* int nDet Number of detectors +* +*/ Projections::Projections (const Scanner& scanner) - : m_projData(0) +: m_projData(0) { initFromScanner (scanner); } Projections::Projections (const int nView, const int nDet) - : m_projData(0) +: m_projData(0) { init (nView, nDet); } Projections::Projections (void) - : m_projData(0) +: m_projData(0) { init (0, 0); } @@ -63,6 +86,43 @@ Projections::~Projections (void) deleteProjData(); } +int +Projections::convertInterpNameToID (const char* const interpName) +{ + int interpID = POLAR_INTERP_INVALID; + + for (int i = 0; i < s_iInterpCount; i++) + if (strcasecmp (interpName, s_aszInterpName[i]) == 0) { + interpID = i; + break; + } + + return (interpID); +} + +const char* +Projections::convertInterpIDToName (const int interpID) +{ + static const char *interpName = ""; + + if (interpID >= 0 && interpID < s_iInterpCount) + return (s_aszInterpName[interpID]); + + return (interpName); +} + +const char* +Projections::convertInterpIDToTitle (const int interpID) +{ + static const char *interpTitle = ""; + + if (interpID >= 0 && interpID < s_iInterpCount) + return (s_aszInterpTitle[interpID]); + + return (interpTitle); +} + + void Projections::init (const int nView, const int nDet) @@ -71,6 +131,15 @@ Projections::init (const int nView, const int nDet) m_nView = nView; m_nDet = nDet; newProjData (); + + time_t t = time (NULL); + tm* lt = localtime (&t); + m_year = lt->tm_year; + m_month = lt->tm_mon; + m_day = lt->tm_mday; + m_hour = lt->tm_hour; + m_minute = lt->tm_min; + m_second = lt->tm_sec; } void @@ -79,21 +148,16 @@ Projections::initFromScanner (const Scanner& scanner) m_label.setLabelType (Array2dFileLabel::L_HISTORY); 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_rotStart = 0; - m_detStart = -(scanner.detLen() / 2); -#if 0 - if (m_geometry == Scanner::GEOMETRY_EQUILINEAR) { - m_detInc /= 2; - std::cout << "Kludge: detInc /= 2 in Projections::initFromScanner" << endl; - } -#endif + m_dFocalLength = scanner.focalLength(); + m_dSourceDetectorLength = scanner.sourceDetectorLength(); + m_dViewDiameter = scanner.viewDiameter(); + m_rotStart = scanner.offsetView()*scanner.rotInc(); + m_dFanBeamAngle = scanner.fanBeamAngle(); } void @@ -103,6 +167,277 @@ Projections::setNView (int nView) // used by MPI to reduce # of views init (nView, m_nDet); } +// Helical 180 Linear Interpolation. +// This member function takes a set of helical scan projections and +// performs a linear interpolation between pairs of complementary rays +// to produce a single projection data set approximating what would be +// measured at a single axial plane. +// Complementary rays are rays which traverse the same path through the +// phantom in opposite directions. +// +// For parallel beam geometry, a ray with a given gantry angle beta and a +// detector iDet will have a complementary ray at beta + pi and nDet-iDet +// +// For equiangular or equilinear beam geometry the complementary ray to +// gantry angle beta and fan-beam angle gamma is at +// beta-hat = beta +2*gamma + pi, and gamma-hat = -gamma. +// Note that beta-hat - beta depends on gamma and is not constant. +// +// The algorithm used here is from Crawford and King, Med. Phys. 17(6) +// 1990 p967; what they called method "C", CSH-HH. It uses interpolation only +// between pairs of complementary rays on either side of an image plane. +// Input data must sample gantry angles from zero to +// (2*pi + 2* fan-beam-angle). The data set produced contains gantry +// angles from 0 to Pi+fan-beam-angle. This is a "halfscan" data set, +// which still contains redundant data, and can be used with a half scan +// reconstruction to produce an image. +// In this particular implementation a lower triangle from (beta,gamma) = +// (0,-fanAngle/2)->(2*fanAngle,-fanAngle/2)->(0,fanAngle/2) contains +// zeros, but is actually redundant with data contained in the region +// (pi+fanAngle,-fanAngle/2)->(pi+fanAngle, fanAngle/2) ->(pi-fanAngle, +// fanAngle/2). +// +int +Projections::Helical180LI(int interpolation_view) +{ + if (m_geometry == Scanner::GEOMETRY_INVALID) + { + std::cerr << "Invalid geometry " << m_geometry << std::endl; + return (2); + } + else if (m_geometry == Scanner::GEOMETRY_PARALLEL) + { + std::cerr << "Helical 180LI not yet implemented for PARALLEL geometry" + << std::endl; + return (2); + } + else if (m_geometry == Scanner::GEOMETRY_EQUILINEAR) + { + std::cerr << "Helical 180LI not yet implemented for EQUILINEAR geometry" + << std::endl; + return (2); + } + else if (m_geometry == Scanner::GEOMETRY_EQUIANGULAR) + { + return Helical180LI_Equiangular(interpolation_view); + } + else + { + std::cerr << "Invalid geometry in projection data file" << m_geometry + << std::endl; + return (2); + } +} +int +Projections::Helical180LI_Equiangular(int interpView) +{ + double dbeta = m_rotInc; + double dgamma = m_detInc; + double fanAngle = m_dFanBeamAngle; + int offsetView=0; + + // is there enough data in the data set? Should have 2(Pi+fanAngle) + // coverage minimum + if ( m_nView < static_cast((2*( PI + fanAngle ) ) / dbeta) -1 ){ + std::cerr << "Data set does not include 360 +2*FanBeamAngle views" + << std::endl; + return (1); + } + + if (interpView < 0) // use default position at PI+fanAngle + { + interpView = static_cast ((PI+fanAngle)/dbeta); + } + else + { + // check if there is PI+fanAngle data on either side of the + // of the specified image plane + if ( interpView*dbeta < PI+fanAngle || + interpView*dbeta + PI + fanAngle > m_nView*dbeta) + { + std::cerr << "There isn't PI+fanAngle of data on either side of the requested interpolation view" << std::endl; + return(1); + } + offsetView = interpView - static_cast((PI+fanAngle)/dbeta); + + } + int last_interp_view = static_cast ((PI+fanAngle)/dbeta); + + +// make a new array for data... + class DetectorArray ** newdetarray = new DetectorArray * [last_interp_view+1]; + for ( int i=0 ; i <= last_interp_view ; i++ ){ + newdetarray[i] = new DetectorArray (m_nDet); + newdetarray[i]->setViewAngle((i+offsetView)*dbeta); + DetectorValue* newdetval = (newdetarray[i])->detValues(); + // and initialize the data to zero + for (int j=0; j < m_nDet; j++) + newdetval[j] = 0.; + } + + int last_acq_view = 2*last_interp_view; + for ( int iView = 0 ; iView <= last_acq_view; iView++) { + double beta = iView * dbeta; + + for ( int iDet = 0; iDet < m_nDet; iDet++) { + double gamma = (iDet -(m_nDet-1)/2)* dgamma ; + int newiView, newiDet; + if (beta < PI+fanAngle) { //if (PI +fanAngle - beta > dbeta ) + //newbeta = beta; + //newgamma = gamma; + newiDet = iDet; + newiView = iView; + } + else // (beta > PI+fanAngle) + { + //newbeta = beta +2*gamma - 180; + //newgamma = -gamma; + newiDet = -iDet + (m_nDet -1); + // newiView = nearest((beta + 2*gamma - PI)/dbeta); + //newiView = static_cast(( (iView*dbeta) + 2*(iDet-(m_nDet-1)/2)*dgamma - PI)/dbeta); + newiView = nearest(( (iView*dbeta) + 2*(iDet-(m_nDet-1)/2)*dgamma - PI)/dbeta); + } + +#ifdef DEBUG +//std::cout << beta << " "<< gamma << " " << newbeta << " " << newgamma <<" " << iView-offsetView << " " << iDet << " " << newiView << " " << newiDet << std::endl; +//std::cout << iView-offsetView << " " << iDet << " " << newiView << " " << newiDet << std::endl; +#endif + + if ( ( beta > fanAngle - 2*gamma) + && ( beta < 2*PI + fanAngle -2*gamma) ) + { // not in region 1 or 8 + DetectorValue* detval = (m_projData[iView+offsetView])->detValues(); + DetectorValue* newdetval = (newdetarray[newiView])->detValues(); + if ( beta > fanAngle - 2*gamma + && beta <= 2*fanAngle ) { // in region 2 + newdetval[newiDet] += + (beta +2*gamma - fanAngle)/(PI+2*gamma) + * detval[iDet]; + } else if ( beta > 2*fanAngle + && beta <= PI - 2*gamma) { // in region 3 + newdetval[newiDet] += + (beta +2*gamma - fanAngle)/(PI+2*gamma) + * detval[iDet]; + } + else if ( beta > PI -2*gamma + && beta <= PI + fanAngle ) { // in region 4 + newdetval[newiDet] += + (beta +2*gamma - fanAngle)/(PI+2*gamma) + * detval[iDet]; + } + else if ( beta > PI + fanAngle + && beta <= PI +2*fanAngle -2*gamma) { // in region 5 + newdetval[newiDet] += + (2*PI - beta - 2*gamma + fanAngle)/(PI-2*gamma) + *detval[iDet]; + } + else if ( beta > PI +2*fanAngle -2*gamma + && beta <= 2*PI) { // in region 6 + newdetval[newiDet] += + (2*PI - beta - 2*gamma + fanAngle)/(PI-2*gamma) + *detval[iDet]; + } + else if ( beta > 2*PI + && beta <= 2*PI + fanAngle -2*gamma){ // in region 7 + newdetval[newiDet] += + (2*PI - beta -2*gamma + fanAngle)/(PI-2*gamma) + *detval[iDet]; + } + else + { + ; // outside region of interest + } + } + } + } + deleteProjData(); + m_projData = newdetarray; + m_nView = last_interp_view+1; + + return (0); +} +// HalfScanFeather: +// A HalfScan Projection Data Set for equiangular geometry, +// covering gantry angles from 0 to pi+fanBeamAngle +// and fan angle gamma from -fanBeamAngle/2 to fanBeamAngle/2 +// contains redundant information. If one copy of this data is left as +// zero, (as in the Helical180LI routine above) overweighting is avoided, +// but the discontinuity in the data introduces ringing in the image. +// This routine makes a copy of the data and applies a weighting to avoid +// over-representation, as given in Appendix C of Crawford and King, Med +// Phys 17 1990, p967. +int +Projections::HalfScanFeather(void) +{ + double dbeta = m_rotInc; + double dgamma = m_detInc; + double fanAngle = m_dFanBeamAngle; + +// is there enough data? + if ( m_nView != static_cast(( PI+fanAngle ) / dbeta) +1 ){ + std::cerr << "Data set does seem have enough data to be a halfscan data set" << std::endl; + return (1); + } + if (m_geometry == Scanner::GEOMETRY_INVALID) { + std::cerr << "Invalid geometry " << m_geometry << std::endl; + return (2); + } + + if (m_geometry == Scanner::GEOMETRY_PARALLEL) { + std::cerr << "HalfScanFeather not yet implemented for PARALLEL geometry"<< std::endl; + return (2); + } + + for ( int iView2 = 0 ; iView2 < m_nView; iView2++) { + double beta2 = iView2 * dbeta; + for ( int iDet2 = 0; iDet2 < m_nDet; iDet2++) { + double gamma2 = (iDet2 -(m_nDet-1)/2)* dgamma ; + if ( ( beta2 >= PI - 2*gamma2) ) { // in redundant data region + int iView1, iDet1; + iDet1 = (m_nDet -1) - iDet2; + //iView1 = nearest((beta2 + 2*gamma2 - PI)/dbeta); + iView1 = nearest(( (iView2*dbeta) + + 2*(iDet2-(m_nDet-1)/2)*dgamma - PI)/dbeta); + + + DetectorValue* detval2 = (m_projData[iView2])->detValues(); + DetectorValue* detval1 = (m_projData[iView1])->detValues(); + + detval1[iDet1] = detval2[iDet2] ; + + double x, w1,w2,beta1, gamma1; + beta1= iView1*dbeta; + gamma1 = -gamma2; + if ( beta1 <= (fanAngle - 2*gamma1) ) + x = beta1 / ( fanAngle - 2*gamma1); + else if ( (fanAngle - 2*gamma1 <= beta1 ) && beta1 <= PI - 2*gamma1) + x = 1; + else if ( (PI - 2*gamma1 <= beta1 ) && ( beta1 <=PI + fanAngle) ) + x = (PI +fanAngle - beta1)/(fanAngle + 2*gamma1); + else { + std::cerr << "Shouldn't be here!"<< std::endl; + return(4); + } + w1 = (3*x - 2*x*x)*x; + w2 = 1-w1; + detval1[iDet1] *= w1; + detval2[iDet2] *= w2; + + } + } + } + // heuristic scaling, why this factor? + double scalefactor = m_nView * m_rotInc / PI; + for ( int iView = 0 ; iView < m_nView; iView++) { + DetectorValue* detval = (m_projData[iView])->detValues(); + for ( int iDet = 0; iDet < m_nDet; iDet++) { + detval[iDet] *= scalefactor; + } + } + + return (0); +} + // NAME // newProjData @@ -111,10 +446,10 @@ Projections::newProjData (void) { if (m_projData) sys_error(ERR_WARNING, "m_projData != NULL [newProjData]"); - + if (m_nView > 0 && m_nDet) { m_projData = new DetectorArray* [m_nView]; - + for (int i = 0; i < m_nView; i++) m_projData[i] = new DetectorArray (m_nDet); } @@ -122,12 +457,12 @@ Projections::newProjData (void) /* NAME - * projections_free Free memory allocated to projections - * - * SYNOPSIS - * projections_free(proj) - * Projections& proj Projectionss to be deallocated - */ +* projections_free Free memory allocated to projections +* +* SYNOPSIS +* projections_free(proj) +* Projections& proj Projectionss to be deallocated +*/ void Projections::deleteProjData (void) @@ -135,7 +470,7 @@ Projections::deleteProjData (void) if (m_projData != NULL) { for (int i = 0; i < m_nView; i++) delete m_projData[i]; - + delete m_projData; m_projData = NULL; } @@ -143,9 +478,9 @@ Projections::deleteProjData (void) /* NAME - * Projections::headerWwrite Write data header for projections file - * - */ +* Projections::headerWwrite Write data header for projections file +* +*/ bool Projections::headerWrite (fnetorderstream& fs) @@ -162,20 +497,21 @@ Projections::headerWrite (fnetorderstream& fs) kuint16 _hour = m_hour; kuint16 _minute = m_minute; kuint16 _second = m_second; - + kfloat64 _calcTime = m_calcTime; kfloat64 _rotStart = m_rotStart; 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; - + fs.writeInt16 (_hsize); fs.writeInt16 (_signature); fs.writeInt32 (_nView); @@ -186,9 +522,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); @@ -197,32 +534,32 @@ Projections::headerWrite (fnetorderstream& fs) fs.writeInt16 (_second); fs.writeInt16 (_remarksize); fs.write (m_remark.c_str(), _remarksize); - + m_headerSize = fs.tellp(); _hsize = m_headerSize; fs.seekp(0); fs.writeInt16 (_hsize); if (! fs) - return false; + return false; return true; } /* NAME - * projections_read_header Read data header for projections file - * - */ +* projections_read_header Read data header for projections file +* +*/ bool 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) - return false; - + return false; + fs.readInt16 (_hsize); fs.readInt16 (_signature); fs.readInt32 (_nView); @@ -233,9 +570,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); @@ -243,17 +581,17 @@ Projections::headerRead (fnetorderstream& fs) fs.readInt16 (_minute); fs.readInt16 (_second); fs.readInt16 (_remarksize); - + if (! fs) { - sys_error (ERR_SEVERE, "Error reading header information , _remarksize=%d [projections_read_header]", _remarksize); - return false; + sys_error (ERR_SEVERE, "Error reading header information , _remarksize=%d [projections_read_header]", _remarksize); + return false; } - + if (_signature != m_signature) { sys_error (ERR_SEVERE, "File %s does not have a valid projection file signature", m_filename.c_str()); return false; } - + char* pszRemarkStorage = new char [_remarksize+1]; fs.read (pszRemarkStorage, _remarksize); if (! fs) { @@ -262,12 +600,12 @@ Projections::headerRead (fnetorderstream& fs) } pszRemarkStorage[_remarksize] = 0; m_remark = pszRemarkStorage; - delete pszRemarkStorage; - + delete pszRemarkStorage; + off_t _hsizeread = fs.tellg(); if (!fs || _hsizeread != _hsize) { - sys_error (ERR_WARNING, "File header size read %ld != file header size stored %ld [read_projections_header]\n_remarksize=%ld", (long int) _hsizeread, _hsize, _remarksize); - return false; + sys_error (ERR_WARNING, "File header size read %ld != file header size stored %ld [read_projections_header]\n_remarksize=%ld", (long int) _hsizeread, _hsize, _remarksize); + return false; } m_headerSize = _hsize; @@ -279,21 +617,22 @@ 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; m_hour = _hour; m_minute = _minute; m_second = _second; - + m_label.setLabelType (Array2dFileLabel::L_HISTORY); m_label.setLabelString (m_remark); m_label.setCalcTime (m_calcTime); m_label.setDateTime (m_year, m_month, m_day, m_hour, m_minute, m_second); - + return true; } @@ -307,23 +646,27 @@ Projections::read (const std::string& filename) bool Projections::read (const char* filename) { - frnetorderstream fileRead (filename, ios::in | ios::binary); m_filename = filename; - - if (! fileRead) +#ifdef MSVC + frnetorderstream fileRead (m_filename.c_str(), std::ios::in | std::ios::binary); +#else + frnetorderstream fileRead (m_filename.c_str(), std::ios::in | std::ios::binary); // | std::ios::nocreate); +#endif + + if (fileRead.fail()) return false; - + if (! headerRead (fileRead)) return false; - + deleteProjData (); newProjData(); - + for (int i = 0; i < m_nView; i++) { if (! detarrayRead (fileRead, *m_projData[i], i)) break; } - + fileRead.close(); return true; } @@ -332,15 +675,21 @@ Projections::read (const char* filename) bool Projections::copyViewData (const std::string& filename, std::ostream& os, int startView, int endView) { - return copyViewData (filename.c_str(), os, startView, endView); + return copyViewData (filename.c_str(), os, startView, endView); } bool Projections::copyViewData (const char* const filename, std::ostream& os, int startView, int endView) { - frnetorderstream is (filename, ios::in | ios::binary); + frnetorderstream is (filename, std::ios::in | std::ios::binary); kuint16 sizeHeader, signature; kuint32 _nView, _nDet; + + is.seekg (0); + if (is.fail()) { + sys_error (ERR_SEVERE, "Unable to read projection file %s", filename); + return false; + } is.readInt16 (sizeHeader); is.readInt16 (signature); @@ -348,49 +697,49 @@ Projections::copyViewData (const char* const filename, std::ostream& os, int sta is.readInt32 (_nDet); int nView = _nView; int nDet = _nDet; - + if (signature != m_signature) { - sys_error (ERR_FATAL, "Illegal signature in projection file %s", filename); + sys_error (ERR_SEVERE, "Illegal signature in projection file %s", filename); return false; } - + if (startView < 0) - startView = 0; + startView = 0; if (startView > nView - 1) - startView = nView; + startView = nView; if (endView < 0 || endView > nView - 1) - endView = nView - 1; - + endView = nView - 1; + if (startView > endView) { // swap if start > end - int tempView = endView; - endView = startView; - startView = tempView; + int tempView = endView; + endView = startView; + startView = tempView; } - + int sizeView = 8 /* view_angle */ + 4 /* nDet */ + (4 * nDet); unsigned char* pViewData = new unsigned char [sizeView]; - + for (int i = startView; i <= endView; i++) { - is.seekg (sizeHeader + i * sizeView); - is.read (reinterpret_cast(pViewData), sizeView); - os.write (reinterpret_cast(pViewData), sizeView); - if (is.fail() || os.fail()) - break; + is.seekg (sizeHeader + i * sizeView); + is.read (reinterpret_cast(pViewData), sizeView); + os.write (reinterpret_cast(pViewData), sizeView); + if (is.fail() || os.fail()) + break; } - + delete pViewData; if (is.fail()) - sys_error (ERR_FATAL, "Error reading projection file"); + sys_error (ERR_SEVERE, "Error reading projection file"); if (os.fail()) - sys_error (ERR_FATAL, "Error writing projection file"); - + sys_error (ERR_SEVERE, "Error writing projection file"); + return (! (is.fail() | os.fail())); } bool Projections::copyHeader (const std::string& filename, std::ostream& os) { - return copyHeader (filename.c_str(), os); + return copyHeader (filename.c_str(), os); } bool @@ -402,23 +751,23 @@ Projections::copyHeader (const char* const filename, std::ostream& os) is.readInt16 (signature); is.seekg (0); if (signature != m_signature) { - sys_error (ERR_FATAL, "Illegal signature in projection file %s", filename); + sys_error (ERR_SEVERE, "Illegal signature in projection file %s", filename); return false; } - + unsigned char* pHdrData = new unsigned char [sizeHeader]; is.read (reinterpret_cast(pHdrData), sizeHeader); if (is.fail()) { - sys_error (ERR_FATAL, "Error reading header"); - return false; + sys_error (ERR_SEVERE, "Error reading header"); + return false; } - + os.write (reinterpret_cast(pHdrData), sizeHeader); if (os.fail()) { - sys_error (ERR_FATAL, "Error writing header"); - return false; + sys_error (ERR_SEVERE, "Error writing header"); + return false; } - + return true; } @@ -437,43 +786,32 @@ Projections::write (const char* filename) sys_error (ERR_SEVERE, "Error opening file %s for output [projections_create]", filename); return false; } - -#ifdef HAVE_TIME - time_t t = time(NULL); - tm* lt = localtime(&t); - m_year = lt->tm_year; - m_month = lt->tm_mon; - m_day = lt->tm_mday; - m_hour = lt->tm_hour; - m_minute = lt->tm_min; - m_second = lt->tm_sec; -#endif - + if (! headerWrite (fs)) - return false; - + return false; + if (m_projData != NULL) { for (int i = 0; i < m_nView; i++) { if (! detarrayWrite (fs, *m_projData[i], i)) - break; + break; } } if (! fs) return false; - - fs.close(); - + + fs.close(); + return true; } /* NAME - * detarrayRead Read a Detector Array structure from the disk - * - * SYNOPSIS - * detarrayRead (proj, darray, view_num) - * DETARRAY *darray Detector array storage location to be filled - * int view_num View number to read - */ +* detarrayRead Read a Detector Array structure from the disk +* +* SYNOPSIS +* detarrayRead (proj, darray, view_num) +* DETARRAY *darray Detector array storage location to be filled +* int view_num View number to read +*/ bool Projections::detarrayRead (fnetorderstream& fs, DetectorArray& darray, const int iview) @@ -485,39 +823,39 @@ Projections::detarrayRead (fnetorderstream& fs, DetectorArray& darray, const int DetectorValue* detval_ptr = darray.detValues(); kfloat64 view_angle; kuint32 nDet; - + fs.seekg (start_data); - + fs.readFloat64 (view_angle); fs.readInt32 (nDet); darray.setViewAngle (view_angle); // darray.setNDet ( nDet); for (unsigned int i = 0; i < nDet; i++) { - kfloat32 detval; - fs.readFloat32 (detval); - detval_ptr[i] = detval; + kfloat32 detval; + fs.readFloat32 (detval); + detval_ptr[i] = detval; } if (! fs) return false; - + return true; } /* NAME - * detarrayWrite Write detector array data to the disk - * - * SYNOPSIS - * detarrayWrite (darray, view_num) - * DETARRAY *darray Detector array data to be written - * int view_num View number to write - * - * DESCRIPTION - * This routine writes the detarray data from the disk sequentially to - * the file that was opened with open_projections(). Data is written in - * binary format. - */ +* detarrayWrite Write detector array data to the disk +* +* SYNOPSIS +* detarrayWrite (darray, view_num) +* DETARRAY *darray Detector array data to be written +* int view_num View number to write +* +* DESCRIPTION +* This routine writes the detarray data from the disk sequentially to +* the file that was opened with open_projections(). Data is written in +* binary format. +*/ bool Projections::detarrayWrite (fnetorderstream& fs, const DetectorArray& darray, const int iview) @@ -535,27 +873,27 @@ Projections::detarrayWrite (fnetorderstream& fs, const DetectorArray& darray, co sys_error (ERR_SEVERE, "Error seeking detectory array [detarrayWrite]"); return false; } - + fs.writeFloat64 (view_angle); fs.writeInt32 (nDet); - + for (unsigned int i = 0; i < nDet; i++) { kfloat32 detval = detval_ptr[i]; fs.writeFloat32 (detval); } - + if (! fs) return (false); - + return true; } /* NAME - * printProjectionData Print projections data - * - * SYNOPSIS - * printProjectionData () - */ +* printProjectionData Print projections data +* +* SYNOPSIS +* printProjectionData () +*/ void Projections::printProjectionData () @@ -569,13 +907,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) @@ -584,7 +925,7 @@ Projections::printProjectionData (int startView, int endView) printf("View %d: angle %f\n", ir, m_projData[ir]->viewAngle()); DetectorValue* detval = m_projData[ir]->detValues(); for (int id = 0; id < m_projData[ir]->nDet(); id++) - printf("%8.4f ", detval[id]); + printf("%8.4f ", detval[id]); printf("\n"); } } @@ -594,17 +935,535 @@ 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"; +} + + +bool +Projections::convertPolar (ImageFile& rIF, int iInterpolationID) +{ + unsigned int nx = rIF.nx(); + unsigned int ny = rIF.ny(); + ImageFileArray v = rIF.getArray(); + ImageFileArray vImag = rIF.getImaginaryArray(); + + 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(); + + 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); + } + + pProj->calcArrayPolarCoordinates (nx, ny, ppdView, ppdDet, pProj->m_nDet, 1., pProj->m_detInc); + + 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; +} + + +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(); + if (! rIF.isComplex()) + rIF.convertRealToComplex(); + ImageFileArray vImag = rIF.getImaginaryArray(); + + if (! v || nx == 0 || ny == 0) + return false; + + Projections* pProj = this; + if (m_geometry == Scanner::GEOMETRY_EQUIANGULAR || m_geometry == Scanner::GEOMETRY_EQUILINEAR) + pProj = interpolateToParallel(); + + int iInterpDet = nx; +// int iInterpDet = pProj->m_nDet; + 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* [pProj->m_nView]; + double dInterpScale = (pProj->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 each view, interpolate to nx length, shift to center at origin, and FFt transform + for (unsigned int iView = 0; iView < m_nView; iView++) { + DetectorValue* detval = pProj->getDetectorArray(iView).detValues(); + LinearInterpolator projInterp (detval, pProj->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 [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); + + Array2d adView (nx, ny); + Array2d adDet (nx, ny); + double** ppdView = adView.getArray(); + double** ppdDet = adDet.getArray(); + pProj->calcArrayPolarCoordinates (nx, ny, ppdView, ppdDet, iNumInterpDetWithZeros, dZeropadRatio, + pProj->m_detInc * dInterpScale); + + pProj->interpolatePolar (v, vImag, nx, ny, ppcDetValue, ppdView, ppdDet, pProj->m_nView, pProj->m_nDet, + iNumInterpDetWithZeros, iInterpolationID); + + if (m_geometry == Scanner::GEOMETRY_EQUIANGULAR || m_geometry == Scanner::GEOMETRY_EQUILINEAR) + delete pProj; + + for (int i = 0; i < m_nView; i++) + delete [] ppcDetValue[i]; + delete [] ppcDetValue; + + return true; +#endif +} + + +void +Projections::calcArrayPolarCoordinates (unsigned int nx, unsigned int ny, double** ppdView, double** ppdDet, + int iNumDetWithZeros, double dZeropadRatio, double dDetInc) +{ + 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; + + // +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++) { + double y = yMin + yInc / 2; + for (unsigned int iy = 0; iy < ny; y += yInc, iy++) { + double r = ::sqrt (x * x + y * y); + double phi = atan2 (y, x); + + if (phi < 0) + phi += TWOPI; + if (phi >= PI) { + phi -= PI; + r = -r; + } + + ppdView[ix][iy] = (phi - m_rotStart) / m_rotInc; + 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, 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) { + unsigned int iView = nearest (ppdView[ix][iy]); + unsigned int iDet = nearest (ppdDet[ix][iy]); + if (iView == nView) { + iView = 0; + iDet = m_nDet - iDet; + } + 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 + v[ix][iy] = 0; + + } else if (iInterpolationID == POLAR_INTERP_BILINEAR) { + 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) { + 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; + } +}