+// 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<int>((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<int> ((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<int>((PI+fanAngle)/dbeta);
+
+ }
+ int last_interp_view = static_cast<int> ((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<int>((beta + 2*gamma - PI)/dbeta);
+ //newiView = static_cast<int>(( (iView*dbeta) + 2*(iDet-(m_nDet-1)/2)*dgamma - PI)/dbeta);
+ newiView = nearest<int>(( (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<int>(( 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<int>((beta2 + 2*gamma2 - PI)/dbeta);
+ iView1 = nearest<int>(( (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);
+}
+