+ for (iView = 0; iView < m_nView; iView++)
+ delete [] ppcDetValue[iView];
+ delete [] ppcDetValue;
+
+ return bError;
+#endif
+}
+
+
+bool
+Projections::calcArrayPolarCoordinates (unsigned int nx, unsigned int ny, double** ppdView, double** ppdDet)
+{
+ double xMin = -phmLen() / 2;
+ double xMax = xMin + phmLen();
+ double yMin = -phmLen() / 2;
+ double yMax = yMin + phmLen();
+
+ 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
+
+ // 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 >= 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;
+ }
+ }
+
+ return true;
+}
+
+void
+Projections::interpolatePolar (ImageFileArray& v, ImageFileArray& vImag,
+ unsigned int nx, unsigned int ny, std::complex<double>** ppcDetValue,
+ double** ppdView, double** ppdDet, unsigned int nView, unsigned int nDet, int iInterpolationID)
+{
+ 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<int> (ppdView[ix][iy]);
+ unsigned int iDet = nearest<int> (ppdDet[ix][iy]);
+ if (iView == nView) {
+ iView = 0;
+ // iDet = m_nDet - iDet;
+ }
+ if (iDet >= 0 && iDet < nDet && 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]);
+ v[ix][iy] = 0;
+ }
+ } else if (iInterpolationID == POLAR_INTERP_BILINEAR) {
+ unsigned int iFloorView = static_cast<int>(ppdView[ix][iy]);
+ double dFracView = ppdView[ix][iy] - iFloorView;
+ unsigned int iFloorDet = static_cast<int>(ppdDet[ix][iy]);
+ double dFracDet = ppdDet[ix][iy] - iFloorDet;
+
+ if (iFloorDet >= 0 && iFloorView >= 0) {
+ std::complex<double> v1 = ppcDetValue[iFloorView][iFloorDet];
+ std::complex<double> 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<double> 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;
+ }
+ } else if (iInterpolationID == POLAR_INTERP_BICUBIC) {
+ v[ix][iy] =0;
+ if (vImag)
+ vImag[ix][iy] = 0;
+ }
+ }
+ }
+}
+
+
+bool
+Projections::initFromSomatomAR_STAR (int iNViews, int iNDets, unsigned char* pData, unsigned long lDataLength)
+{
+ init (iNViews, iNDets);
+ m_geometry = Scanner::GEOMETRY_EQUIANGULAR;
+ m_dFanBeamAngle = iNDets * convertDegreesToRadians (3.06976 / 60);
+ m_dFocalLength = 51;
+ m_dSourceDetectorLength = 89;
+ m_detInc = convertDegreesToRadians (3.06976 / 60);
+ m_detStart = -m_dFanBeamAngle / 2;
+ m_rotInc = TWOPI / static_cast<double>(iNViews);
+ m_rotStart = HALFPI;
+ m_dViewDiameter = sin (m_dFanBeamAngle / 2) * m_dFocalLength * 2;
+
+ if (iNDets != 1024)
+ return false;
+ bool bValid = (iNViews == 750 && lDataLength == 1560000L) || (iNViews == 950 && lDataLength == 1976000L) || (iNViews == 1500 && lDataLength == 3120000);
+ if (! bValid)
+ return false;
+
+ long lDataPos = 0;
+ for (int iv = 0; iv < iNViews; iv++) {
+ unsigned char* pArgBase = pData + lDataPos;
+ unsigned char* p = pArgBase+0;
+#ifndef WORDS_BIGENDIAN
+ SwapBytes4 (p);
+#endif
+ long lProjNumber = *reinterpret_cast<long*>(p);
+
+ p = pArgBase+20;
+#ifndef WORDS_BIGENDIAN
+ SwapBytes4 (p);
+#endif
+ long lEscale = *reinterpret_cast<long*>(p);
+
+ p = pArgBase+28;
+#ifndef WORDS_BIGENDIAN
+ SwapBytes4 (p);
+#endif
+ long lTime = *reinterpret_cast<long*>(p);
+
+ p = pArgBase + 4;
+#ifndef WORDS_BIGENDIAN
+ SwapBytes4 (p);
+#endif
+ double dAlpha = *reinterpret_cast<float*>(p) + HALFPI;
+
+ p = pArgBase+12;
+#ifndef WORDS_BIGENDIAN
+ SwapBytes4 (p);
+#endif
+ double dAlign = *reinterpret_cast<float*>(p);
+
+ p = pArgBase + 16;
+#ifndef WORDS_BIGENDIAN
+ SwapBytes4 (p);
+#endif
+ double dMaxValue = *reinterpret_cast<float*>(p);
+
+ lDataPos += 32;
+ double dEScale = pow (2.0, -lEscale);
+ double dBetaInc = convertDegreesToRadians (3.06976 / 60);
+ int iCenter = (iNDets + 1) / 2;
+
+ DetectorArray& detArray = getDetectorArray( iv );
+ detArray.setViewAngle (dAlpha);
+ DetectorValue* detval = detArray.detValues();
+
+ double dTempScale = 2294.4871 * dEScale;
+ for (int id = 0; id < iNDets; id++) {
+ int iV = pData[lDataPos+1] + 256 * pData[lDataPos];
+ if (iV > 32767) // two's complement signed conversion
+ iV = iV - 65536;
+ double dCosScale = cos ((id + 1 - iCenter) * dBetaInc);
+ detval[id] = iV / (dTempScale * dCosScale);
+ lDataPos += 2;
+ }
+ }
+
+ return true;
+}
+
+
+ParallelRaysums::ParallelRaysums (Projections* pProjections)
+: m_ppCoordinates(NULL), m_iNumCoordinates(0)
+{
+ int nDet = pProjections->nDet();
+ int nView = pProjections->nView();
+ int iGeometry = pProjections->geometry();
+ double dDetInc = pProjections->detInc();
+ double dDetStart = pProjections->detStart();
+ double dFocalLength = pProjections->focalLength();
+
+ m_iNumCoordinates = nDet * nView;
+ m_ppCoordinates = new ParallelRaysumCoordinate* [m_iNumCoordinates];
+ for (int i = 0; i < m_iNumCoordinates; i++)
+ m_ppCoordinates[i] = new ParallelRaysumCoordinate;
+
+ ParallelRaysumCoordinate** ppCurrentCoordinate = m_ppCoordinates;
+
+ for (int iV = 0; iV < nView; iV++) {
+ double dViewAngle = pProjections->getDetectorArray(iV).viewAngle();
+ for (int iD = 0; iD < nDet; iD++) {
+ ParallelRaysumCoordinate* pC = *ppCurrentCoordinate;
+ if (iGeometry == Scanner::GEOMETRY_PARALLEL) {
+ pC->m_dTheta = dViewAngle;
+ pC->m_dT = dDetStart + (iD * dDetInc);
+ } else if (iGeometry == Scanner::GEOMETRY_EQUILINEAR) {
+ double dDetPos = dDetStart + (iD * dDetInc);
+ double dFanAngle = atan (dDetPos / pProjections->sourceDetectorLength());
+ pC->m_dTheta = dViewAngle + dFanAngle;
+ pC->m_dT = dFocalLength * sin(dFanAngle);
+ } else if (iGeometry == Scanner::GEOMETRY_EQUIANGULAR) {
+ double dFanAngle = dDetStart + (iD * dDetInc);
+ pC->m_dTheta = dViewAngle + dFanAngle;
+ pC->m_dT = dFocalLength * sin(dFanAngle);
+ }
+ ++ppCurrentCoordinate;
+ }
+ }
+}
+
+ParallelRaysums::~ParallelRaysums()
+{
+ for (int i = 0; i < m_iNumCoordinates; i++)
+ delete m_ppCoordinates[i];
+
+ delete m_ppCoordinates;
+}
+
+void
+ParallelRaysums::getLimits (double* dMinT, double* dMaxT, double* dMinTheta, double* dMaxTheta) const
+{
+ if (m_iNumCoordinates <= 0)
+ return;
+
+ *dMinT = *dMaxT = m_ppCoordinates[0]->m_dT;
+ *dMinTheta = *dMaxTheta = m_ppCoordinates[0]->m_dTheta;
+
+ for (int i = 0; i < m_iNumCoordinates; i++) {
+ double dT = m_ppCoordinates[i]->m_dT;
+ double dTheta = m_ppCoordinates[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;
+ }
+}