** This is part of the CTSim program
** Copyright (c) 1983-2001 Kevin Rosenberg
**
-** $Id: projections.cpp,v 1.47 2001/02/08 06:25:07 kevin Exp $
+** $Id: projections.cpp,v 1.63 2001/03/13 08:24:41 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
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"},
m_rotInc = scanner.rotInc();
m_detInc = scanner.detInc();
+ m_detStart = scanner.detStart();
m_geometry = scanner.geometry();
m_dFocalLength = scanner.focalLength();
+ m_dSourceDetectorLength = scanner.sourceDetectorLength();
m_dViewDiameter = scanner.viewDiameter();
m_rotStart = 0;
- m_detStart = -(scanner.detLen() / 2);
m_dFanBeamAngle = scanner.fanBeamAngle();
}
kfloat64 _detInc = m_detInc;
kfloat64 _viewDiameter = m_dViewDiameter;
kfloat64 _focalLength = m_dFocalLength;
+ kfloat64 _sourceDetectorLength = m_dSourceDetectorLength;
kfloat64 _fanBeamAngle = m_dFanBeamAngle;
fs.seekp(0);
fs.writeFloat64 (_detInc);
fs.writeFloat64 (_viewDiameter);
fs.writeFloat64 (_focalLength);
+ fs.writeFloat64 (_sourceDetectorLength);
fs.writeFloat64 (_fanBeamAngle);
fs.writeInt16 (_year);
fs.writeInt16 (_month);
{
kuint16 _hsize, _signature, _year, _month, _day, _hour, _minute, _second, _remarksize = 0;
kuint32 _nView, _nDet, _geom;
- kfloat64 _calcTime, _rotStart, _rotInc, _detStart, _detInc, _focalLength, _viewDiameter, _fanBeamAngle;
+ kfloat64 _calcTime, _rotStart, _rotInc, _detStart, _detInc, _focalLength, _sourceDetectorLength, _viewDiameter, _fanBeamAngle;
fs.seekg(0);
if (! fs)
fs.readFloat64 (_detInc);
fs.readFloat64 (_viewDiameter);
fs.readFloat64 (_focalLength);
+ fs.readFloat64 (_sourceDetectorLength);
fs.readFloat64 (_fanBeamAngle);
fs.readInt16 (_year);
fs.readInt16 (_month);
m_detStart = _detStart;
m_detInc = _detInc;
m_dFocalLength = _focalLength;
+ m_dSourceDetectorLength = _sourceDetectorLength;
m_dViewDiameter = _viewDiameter;
m_dFanBeamAngle = _fanBeamAngle;
m_year = _year;
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 ViewDiameter = %8.4f\n", m_dFocalLength, m_dViewDiameter);
- printf("fanBeamAngle= %8.4f\n", convertRadiansToDegrees(m_dFanBeamAngle));
- 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;
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";
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<double> adView (nx, ny);
Array2d<double> adDet (nx, ny);
double** ppdView = adView.getArray();
double** ppdDet = adDet.getArray();
- calcArrayPolarCoordinates (nx, ny, ppdView, ppdDet);
+ if (! pProj->calcArrayPolarCoordinates (nx, ny, ppdView, ppdDet))
+ return false;
std::complex<double>** ppcDetValue = new std::complex<double>* [m_nView];
unsigned int iView;
for (iView = 0; iView < m_nView; iView++) {
ppcDetValue[iView] = new std::complex<double> [m_nDet];
for (unsigned int iDet = 0; iDet < m_nDet; iDet++)
- ppcDetValue[iView][iDet] = std::complex<double>(getDetectorArray (iView).detValues()[iDet], 0);
+ ppcDetValue[iView][iDet] = std::complex<double>(pProj->getDetectorArray (iView).detValues()[iDet], 0);
}
- interpolatePolar (v, vImag, nx, ny, ppcDetValue, ppdView, ppdDet, m_nView, m_nDet, iInterpolationID);
+ pProj->interpolatePolar (v, vImag, nx, ny, ppcDetValue, ppdView, ppdDet, pProj->m_nView, pProj->m_nDet, iInterpolationID);
for (iView = 0; iView < m_nView; iView++)
delete [] ppcDetValue[iView];
delete [] ppcDetValue;
+ if (m_geometry == Scanner::GEOMETRY_EQUIANGULAR || m_geometry == Scanner::GEOMETRY_EQUILINEAR)
+ delete pProj;
+
return true;
}
if (! v || nx == 0 || ny == 0)
return false;
+ if (m_geometry != Scanner::GEOMETRY_PARALLEL) {
+ sys_error (ERR_WARNING, "convertFFTPolar supports Parallel only");
+ return false;
+ }
+
#ifndef HAVE_FFT
return false;
#else
fftw_destroy_plan (plan);
delete [] pcIn;
- calcArrayPolarCoordinates (nx, ny, ppdView, ppdDet);
+ bool bError = calcArrayPolarCoordinates (nx, ny, ppdView, ppdDet);
- interpolatePolar (v, vImag, nx, ny, ppcDetValue, ppdView, ppdDet, m_nView, m_nDet, iInterpolationID);
+ if (! bError)
+ interpolatePolar (v, vImag, nx, ny, ppcDetValue, ppdView, ppdDet, m_nView, m_nDet, iInterpolationID);
for (iView = 0; iView < m_nView; iView++)
delete [] ppcDetValue[iView];
delete [] ppcDetValue;
- return true;
+ return bError;
#endif
}
-void
+bool
Projections::calcArrayPolarCoordinates (unsigned int nx, unsigned int ny, double** ppdView, double** ppdDet)
{
double xMin = -phmLen() / 2;
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;
- }
-
// 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++) {
ppdDet[ix][iy] = (r / m_detInc) + iDetCenter;
}
}
+
+ return true;
}
void
for (unsigned int ix = 0; ix < ny; ix++) {
for (unsigned int iy = 0; iy < ny; iy++) {
if (iInterpolationID == POLAR_INTERP_NEAREST) {
- int iView = nearest<int> (ppdView[ix][iy]);
- int iDet = nearest<int> (ppdDet[ix][iy]);
+ 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;
v[ix][iy] = 0;
}
} else if (iInterpolationID == POLAR_INTERP_BILINEAR) {
- int iFloorView = static_cast<int>(ppdView[ix][iy]);
+ unsigned int iFloorView = static_cast<int>(ppdView[ix][iy]);
double dFracView = ppdView[ix][iy] - iFloorView;
- int iFloorDet = static_cast<int>(ppdDet[ix][iy]);
+ unsigned int iFloorDet = static_cast<int>(ppdDet[ix][iy]);
double dFracDet = ppdDet[ix][iy] - iFloorDet;
if (iFloorDet >= 0 && iFloorView >= 0) {
}
}
+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 + 1) * m_detInc;
+ 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 (! ((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<long*>(p);
+
+ p = pArgBase+20; SwapBytes4IfLittleEndian (p);
+ long lEscale = *reinterpret_cast<long*>(p);
+
+ p = pArgBase+28; SwapBytes4IfLittleEndian (p);
+ long lTime = *reinterpret_cast<long*>(p);
+
+ p = pArgBase + 4; SwapBytes4IfLittleEndian (p);
+ double dAlpha = *reinterpret_cast<float*>(p) + HALFPI;
+
+ p = pArgBase+12; SwapBytes4IfLittleEndian (p);
+ double dAlign = *reinterpret_cast<float*>(p);
+
+ p = pArgBase + 16; SwapBytes4IfLittleEndian (p);
+ double dMaxValue = *reinterpret_cast<float*>(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;
+ }
+ }
+
+ delete pdCosScale;
+ return true;
+}
+
+Projections*
+Projections::interpolateToParallel () const
+{
+ if (m_geometry == Scanner::GEOMETRY_PARALLEL)
+ return const_cast<Projections*>(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 (nDet % 2 == 0) // 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();
+
+ detValues[iD] = parallel.interpolate (pdThetaValuesForT, pdRaysumsForT, pProjNew->nView(), 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;
+ for (int iD = 0; iD < pProjNew->nDet(); iD++, dDetPos += pProjNew->m_detInc) {
+ detValues[iD] = parallel.interpolate (pdOriginalDetPositions, pdDetValueCopy, pProjNew->nDet(), 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;
+ }
+}
+
+// locate by bisection, O(log2(n))
+// iLastFloor is used when sequential calls to interpolate have monotonically increasing dX
+double
+ParallelRaysums::interpolate (double* pdX, double* pdY, int n, double dX, int* iLastFloor)
+{
+ int iLower = -1;
+ int iUpper = n;
+ if (iLastFloor && *iLastFloor >= 0 && pdX[*iLastFloor] < dX)
+ iLower = *iLastFloor;
+
+ while (iUpper - iLower > 1) {
+ int iMiddle = (iUpper + iLower) >> 1;
+ if (dX >= pdX[iMiddle])
+ iLower = iMiddle;
+ else
+ iUpper = iMiddle;
+ }
+ if (dX <= pdX[0])
+ return pdY[0];
+ else if (dX >= pdX[n-1])
+ return pdY[1];
+
+ if (iLower < 0 || iLower >= n) {
+ sys_error (ERR_SEVERE, "Coordinate out of range [locateThetaBase]");
+ return 0;
+ }
+
+ if (iLastFloor)
+ *iLastFloor = iLower;
+ return pdY[iLower] + (pdY[iUpper] - pdY[iLower]) * ((dX - pdX[iLower]) / (pdX[iUpper] - pdX[iLower]));
+}
projects / ctsim.git / blobdiff