int main(int argc, char** argv)
{
CrashHandler crash_guard;
QApplication app(argc, argv);
app.setWindowIcon(QIcon(":/phantomjs-icon.png"));
app.setApplicationName("PhantomJS");
app.setOrganizationName("Ofi Labs");
app.setOrganizationDomain("www.ofilabs.com");
app.setApplicationVersion(PHANTOMJS_VERSION_STRING);
// Registering an alternative Message Handler
qInstallMessageHandler(Utils::messageHandler);
#if defined(Q_OS_LINUX)
if (QSslSocket::supportsSsl()) {
// Don't perform on-demand loading of root certificates on Linux
QSslSocket::addDefaultCaCertificates(QSslSocket::systemCaCertificates());
}
#endif
// Get the Phantom singleton
Phantom *phantom = Phantom::instance();
// Start script execution
if (phantom->execute()) {
app.exec();
}
// End script execution: delete the phantom singleton and set execution return value
int retVal = phantom->returnValue();
delete phantom;
return retVal;
}
double
Scanner::projectSingleLine (const Phantom& phm, const double x1, const double y1, const double x2, const double y2)
{
// check ray against each pelem in Phantom
double rsum = 0.0;
for (PElemConstIterator i = phm.listPElem().begin(); i != phm.listPElem().end(); i++)
rsum += projectLineAgainstPElem (**i, x1, y1, x2, y2);
return (rsum);
}
int main(int argc, char** argv, const char** envp)
{
// Setup Google Breakpad exception handler
#ifdef Q_OS_LINUX
google_breakpad::ExceptionHandler eh("/tmp", NULL, Utils::exceptionHandler, NULL, true);
#endif
#ifdef Q_OS_MAC
google_breakpad::ExceptionHandler eh("/tmp", NULL, Utils::exceptionHandler, NULL, true, NULL);
#endif
QApplication app(argc, argv);
app.setWindowIcon(QIcon(":/phantomjs-icon.png"));
app.setApplicationName("PhantomJS");
app.setOrganizationName("Ofi Labs");
app.setOrganizationDomain("www.ofilabs.com");
app.setApplicationVersion(PHANTOMJS_VERSION_STRING);
// Prepare the "env" singleton using the environment variables
Env::instance()->parse(envp);
// Get the Phantom singleton
Phantom *phantom = Phantom::instance();
// Registering an alternative Message Handler
Utils::printDebugMessages = phantom->printDebugMessages();
qInstallMsgHandler(Utils::messageHandler);
signal(SIGALRM, timeout);
FILE *in;
in = fopen("timeout.txt", "r");
if (in) {
int t;
fscanf(in, "%d", &t);
alarm(t);
fclose(in);
}
// Start script execution
if (phantom->execute()) {
app.exec();
}
alarm(0);
// End script execution: delete the phantom singleton and set execution return value
int retVal = phantom->returnValue();
delete phantom;
return retVal;
}
Scanner::Scanner (const Phantom& phm, const char* const geometryName,
int nDet, int nView, int offsetView,
int nSample, const double rot_anglen,
const double dFocalLengthRatio,
const double dCenterDetectorRatio,
const double dViewRatio, const double dScanRatio)
{
m_fail = false;
m_idGeometry = convertGeometryNameToID (geometryName);
if (m_idGeometry == GEOMETRY_INVALID) {
m_fail = true;
m_failMessage = "Invalid geometry name ";
m_failMessage += geometryName;
return;
}
if (nView < 1 || nDet < 1) {
m_fail = true;
m_failMessage = "nView & nDet must be greater than 0";
return;
}
if (nSample < 1)
m_nSample = 1;
m_nDet = nDet;
m_nView = nView;
m_iOffsetView = offsetView;
m_nSample = nSample;
m_dFocalLengthRatio = dFocalLengthRatio;
m_dCenterDetectorRatio = dCenterDetectorRatio;
m_dViewRatio = dViewRatio;
m_dScanRatio = dScanRatio;
m_dViewDiameter = phm.getDiameterBoundaryCircle() * m_dViewRatio;
m_dFocalLength = (m_dViewDiameter / 2) * m_dFocalLengthRatio;
m_dCenterDetectorLength = (m_dViewDiameter / 2) * m_dCenterDetectorRatio;
m_dSourceDetectorLength = m_dFocalLength + m_dCenterDetectorLength;
m_dScanDiameter = m_dViewDiameter * m_dScanRatio;
m_dXCenter = phm.xmin() + (phm.xmax() - phm.xmin()) / 2;
m_dYCenter = phm.ymin() + (phm.ymax() - phm.ymin()) / 2;
m_rotLen = rot_anglen;
m_rotInc = m_rotLen / m_nView;
if (m_idGeometry == GEOMETRY_PARALLEL) {
m_dFanBeamAngle = 0;
m_detLen = m_dScanDiameter;
m_detStart = -m_detLen / 2;
m_detInc = m_detLen / m_nDet;
double dDetectorArrayEndOffset = 0;
// For even number of detectors, make detInc slightly larger so that center lies
// at nDet/2. Also, extend detector array by one detInc so that all of the phantom is scanned
if (isEven (m_nDet)) { // Adjust for Even number of detectors
m_detInc = m_detLen / (m_nDet - 1); // center detector = (nDet/2)
dDetectorArrayEndOffset = m_detInc;
}
double dHalfDetLen = m_detLen / 2;
m_initPos.xs1 = m_dXCenter - dHalfDetLen;
m_initPos.ys1 = m_dYCenter + m_dFocalLength;
m_initPos.xs2 = m_dXCenter + dHalfDetLen + dDetectorArrayEndOffset;
m_initPos.ys2 = m_dYCenter + m_dFocalLength;
m_initPos.xd1 = m_dXCenter - dHalfDetLen;
m_initPos.yd1 = m_dYCenter - m_dCenterDetectorLength;
m_initPos.xd2 = m_dXCenter + dHalfDetLen + dDetectorArrayEndOffset;
m_initPos.yd2 = m_dYCenter - m_dCenterDetectorLength;
m_initPos.angle = m_iOffsetView * m_rotInc;
m_detLen += dDetectorArrayEndOffset;
} else if (m_idGeometry == GEOMETRY_EQUILINEAR) {
if (m_dScanDiameter / 2 >= m_dFocalLength) {
m_fail = true;
m_failMessage = "Invalid geometry: Focal length must be larger than scan length";
return;
}
const double dAngle = asin ((m_dScanDiameter / 2) / m_dFocalLength);
const double dHalfDetLen = m_dSourceDetectorLength * tan (dAngle);
m_detLen = dHalfDetLen * 2;
m_detStart = -dHalfDetLen;
m_detInc = m_detLen / m_nDet;
double dDetectorArrayEndOffset = 0;
if (isEven (m_nDet)) { // Adjust for Even number of detectors
m_detInc = m_detLen / (m_nDet - 1); // center detector = (nDet/2)
dDetectorArrayEndOffset = m_detInc;
m_detLen += dDetectorArrayEndOffset;
}
m_dFanBeamAngle = dAngle * 2;
m_initPos.xs1 = m_dXCenter;
m_initPos.ys1 = m_dYCenter + m_dFocalLength;
m_initPos.xs2 = m_dXCenter;
m_initPos.ys2 = m_dYCenter + m_dFocalLength;
m_initPos.xd1 = m_dXCenter - dHalfDetLen;
m_initPos.yd1 = m_dYCenter - m_dCenterDetectorLength;
m_initPos.xd2 = m_dXCenter + dHalfDetLen + dDetectorArrayEndOffset;
m_initPos.yd2 = m_dYCenter - m_dCenterDetectorLength;
m_initPos.angle = m_iOffsetView * m_rotInc;
} else if (m_idGeometry == GEOMETRY_EQUIANGULAR) {
if (m_dScanDiameter / 2 > m_dFocalLength) {
m_fail = true;
m_failMessage = "Invalid geometry: Focal length must be larger than scan length";
return;
}
const double dAngle = asin ((m_dScanDiameter / 2) / m_dFocalLength);
m_detLen = 2 * dAngle;
m_detStart = -dAngle;
m_detInc = m_detLen / m_nDet;
double dDetectorArrayEndOffset = 0;
if (isEven (m_nDet)) { // Adjust for Even number of detectors
m_detInc = m_detLen / (m_nDet - 1); // center detector = (nDet/2)
dDetectorArrayEndOffset = m_detInc;
}
// adjust for center-detector length
double dA1 = acos ((m_dScanDiameter / 2) / m_dCenterDetectorLength);
double dAngularScale = 2 * (HALFPI + dAngle - dA1) / m_detLen;
m_dAngularDetLen = dAngularScale * (m_detLen + dDetectorArrayEndOffset);
m_dAngularDetIncrement = dAngularScale * m_detInc;
m_initPos.dAngularDet = -m_dAngularDetLen / 2;
m_dFanBeamAngle = dAngle * 2;
m_initPos.angle = m_iOffsetView * m_rotInc;
m_initPos.xs1 = m_dXCenter;
m_initPos.ys1 = m_dYCenter + m_dFocalLength;;
m_initPos.xs2 = m_dXCenter;
m_initPos.ys2 = m_dYCenter + m_dFocalLength;
m_detLen += dDetectorArrayEndOffset;
}
// Calculate incrementatal rotation matrix
GRFMTX_2D temp;
xlat_mtx2 (m_rotmtxIncrement, -m_dXCenter, -m_dYCenter);
rot_mtx2 (temp, m_rotInc);
mult_mtx2 (m_rotmtxIncrement, temp, m_rotmtxIncrement);
xlat_mtx2 (temp, m_dXCenter, m_dYCenter);
mult_mtx2 (m_rotmtxIncrement, temp, m_rotmtxIncrement);
}
void
Scanner::projectSingleView (const Phantom& phm, DetectorArray& detArray, const double xd1, const double yd1, const double xd2, const double yd2, const double xs1, const double ys1, const double xs2, const double ys2, const double dDetAngle)
{
double sdx = (xs2 - xs1) / detArray.nDet(); // change in coords
double sdy = (ys2 - ys1) / detArray.nDet(); // between source
double xs_maj = xs1 + (sdx / 2); // put ray source in center of cell
double ys_maj = ys1 + (sdy / 2);
double ddx=0, ddy=0, ddx2=0, ddy2=0, ddx2_ofs=0, ddy2_ofs=0, xd_maj=0, yd_maj=0;
double dAngleInc=0, dAngleSampleInc=0, dAngleSampleOffset=0, dAngleMajor=0;
if (m_idGeometry == GEOMETRY_EQUIANGULAR) {
dAngleInc = m_dAngularDetIncrement;
dAngleSampleInc = dAngleInc / m_nSample;
dAngleSampleOffset = dAngleSampleInc / 2;
dAngleMajor = dDetAngle - (m_dAngularDetLen/2) + dAngleSampleOffset;
} else {
ddx = (xd2 - xd1) / detArray.nDet(); // change in coords
ddy = (yd2 - yd1) / detArray.nDet(); // between detectors
ddx2 = ddx / m_nSample; // Incr. between rays with detector cell
ddy2 = ddy / m_nSample; // Doesn't include detector endpoints
ddx2_ofs = ddx2 / 2; // offset of 1st ray from start of detector cell
ddy2_ofs = ddy2 / 2;
xd_maj = xd1 + ddx2_ofs; // Incr. between detector cells
yd_maj = yd1 + ddy2_ofs;
}
DetectorValue* detval = detArray.detValues();
if (phm.getComposition() == P_UNIT_PULSE) { // put unit pulse in center of view
for (int d = 0; d < detArray.nDet(); d++)
detval[d] = 0;
detval[ detArray.nDet() / 2 ] = 1;
} else {
for (int d = 0; d < detArray.nDet(); d++) {
double xs = xs_maj;
double ys = ys_maj;
double xd=0, yd=0, dAngle=0;
if (m_idGeometry == GEOMETRY_EQUIANGULAR) {
dAngle = dAngleMajor;
} else {
xd = xd_maj;
yd = yd_maj;
}
double sum = 0.0;
for (unsigned int i = 0; i < m_nSample; i++) {
if (m_idGeometry == GEOMETRY_EQUIANGULAR) {
xd = m_dCenterDetectorLength * cos (dAngle);
yd = m_dCenterDetectorLength * sin (dAngle);
}
#ifdef HAVE_SGP
if (m_pSGP && m_trace >= Trace::TRACE_PROJECTIONS) {
m_pSGP->setColor (C_YELLOW);
m_pSGP->setRasterOp (RO_AND);
m_pSGP->moveAbs (xs, ys);
m_pSGP->lineAbs (xd, yd);
}
#endif
sum += projectSingleLine (phm, xd, yd, xs, ys);
#ifdef HAVE_SGP
// if (m_trace >= Trace::TRACE_CLIPPING) {
// traceShowParam ("Attenuation:", "%s", PROJECTION_TRACE_ROW_ATTEN, C_LTMAGENTA, " ");
// traceShowParam ("Attenuation:", "%.3f", PROJECTION_TRACE_ROW_ATTEN, C_LTMAGENTA, sum);
// }
#endif
if (m_idGeometry == GEOMETRY_EQUIANGULAR)
dAngle += dAngleSampleInc;
else {
xd += ddx2;
yd += ddy2;
}
} // for each sample in detector
detval[d] = sum / m_nSample;
xs_maj += sdx;
ys_maj += sdy;
if (m_idGeometry == GEOMETRY_EQUIANGULAR)
dAngleMajor += dAngleInc;
else {
xd_maj += ddx;
yd_maj += ddy;
}
} /* for each detector */
} /* if not unit pulse */
}
void
Scanner::collectProjections (Projections& proj, const Phantom& phm, const int iStartView,
const int iNumViews, const int iOffsetView, int iStorageOffset,
const int trace, SGP* pSGP)
{
m_trace = trace;
double start_angle = (iStartView + iOffsetView) * proj.rotInc();
// Calculate initial rotation matrix
GRFMTX_2D rotmtx_initial, temp;
xlat_mtx2 (rotmtx_initial, -m_dXCenter, -m_dYCenter);
rot_mtx2 (temp, start_angle);
mult_mtx2 (rotmtx_initial, temp, rotmtx_initial);
xlat_mtx2 (temp, m_dXCenter, m_dYCenter);
mult_mtx2 (rotmtx_initial, temp, rotmtx_initial);
double xd1=0, yd1=0, xd2=0, yd2=0;
if (m_idGeometry != GEOMETRY_EQUIANGULAR) {
xd1 = m_initPos.xd1;
yd1 = m_initPos.yd1;
xd2 = m_initPos.xd2;
yd2 = m_initPos.yd2;
xform_mtx2 (rotmtx_initial, xd1, yd1); // rotate detector endpoints
xform_mtx2 (rotmtx_initial, xd2, yd2); // to initial view_angle
}
double xs1 = m_initPos.xs1;
double ys1 = m_initPos.ys1;
double xs2 = m_initPos.xs2;
double ys2 = m_initPos.ys2;
xform_mtx2 (rotmtx_initial, xs1, ys1); // rotate source endpoints to
xform_mtx2 (rotmtx_initial, xs2, ys2); // initial view angle
int iView;
double viewAngle;
for (iView = 0, viewAngle = start_angle; iView < iNumViews; iView++, viewAngle += proj.rotInc()) {
int iStoragePosition = iView + iStorageOffset;
DetectorArray& detArray = proj.getDetectorArray( iStoragePosition );
#ifdef HAVE_SGP
if (pSGP && m_trace >= Trace::TRACE_PHANTOM) {
m_pSGP = pSGP;
double dWindowSize = dmax (m_detLen, m_dSourceDetectorLength) * 2;
double dHalfWindowSize = dWindowSize / 2;
m_dXMinWin = m_dXCenter - dHalfWindowSize;
m_dXMaxWin = m_dXCenter + dHalfWindowSize;
m_dYMinWin = m_dYCenter - dHalfWindowSize;
m_dYMaxWin = m_dYCenter + dHalfWindowSize;
m_pSGP->setWindow (m_dXMinWin, m_dYMinWin, m_dXMaxWin, m_dYMaxWin);
m_pSGP->setRasterOp (RO_COPY);
m_pSGP->setColor (C_RED);
m_pSGP->moveAbs (0., 0.);
m_pSGP->drawCircle (m_dViewDiameter / 2);
m_pSGP->moveAbs (0., 0.);
m_pSGP->setColor (C_GREEN);
m_pSGP->drawCircle (m_dFocalLength);
m_pSGP->setColor (C_BLUE);
m_pSGP->setTextPointSize (9);
phm.draw (*m_pSGP);
m_dTextHeight = m_pSGP->getCharHeight ();
traceShowParam ("Phantom:", "%s", PROJECTION_TRACE_ROW_PHANT_ID, C_BLACK, phm.name().c_str());
traceShowParam ("Geometry:", "%s", PROJECTION_TRACE_ROW_GEOMETRY, C_BLUE, convertGeometryIDToName(m_idGeometry));
traceShowParam ("Focal Length Ratio:", "%.2f", PROJECTION_TRACE_ROW_FOCAL_LENGTH, C_BLUE, m_dFocalLengthRatio);
// traceShowParam ("Field Of View Ratio:", "%.2f", PROJECTION_TRACE_ROW_FIELD_OF_VIEW, C_BLUE, m_dFieldOfViewRatio);
traceShowParam ("Num Detectors:", "%d", PROJECTION_TRACE_ROW_NDET, C_BLUE, proj.nDet());
traceShowParam ("Num Views:", "%d", PROJECTION_TRACE_ROW_NVIEW, C_BLUE, proj.nView());
traceShowParam ("Samples / Ray:", "%d", PROJECTION_TRACE_ROW_SAMPLES, C_BLUE, m_nSample);
m_pSGP->setMarker (SGP::MARKER_BDIAMOND);
}
#endif
#ifdef HAVE_SGP
if (m_pSGP && m_trace >= Trace::TRACE_PHANTOM) {
m_pSGP->setColor (C_BLACK);
m_pSGP->setPenWidth (2);
if (m_idGeometry == GEOMETRY_PARALLEL) {
m_pSGP->moveAbs (xs1, ys1);
m_pSGP->lineAbs (xs2, ys2);
m_pSGP->moveAbs (xd1, yd1);
m_pSGP->lineAbs (xd2, yd2);
} else if (m_idGeometry == GEOMETRY_EQUILINEAR) {
m_pSGP->setPenWidth (4);
m_pSGP->moveAbs (xs1, ys1);
m_pSGP->lineAbs (xs2, ys2);
m_pSGP->setPenWidth (2);
m_pSGP->moveAbs (xd1, yd1);
m_pSGP->lineAbs (xd2, yd2);
} else if (m_idGeometry == GEOMETRY_EQUIANGULAR) {
m_pSGP->setPenWidth (4);
m_pSGP->moveAbs (xs1, ys1);
m_pSGP->lineAbs (xs2, ys2);
m_pSGP->setPenWidth (2);
m_pSGP->moveAbs (0., 0.);
m_pSGP->drawArc (m_dCenterDetectorLength, viewAngle + 3 * HALFPI - (m_dAngularDetLen/2), viewAngle + 3 * HALFPI + (m_dAngularDetLen/2));
}
m_pSGP->setPenWidth (1);
}
if (m_trace > Trace::TRACE_CONSOLE)
traceShowParam ("Current View:", "%d (%.0f%%)", PROJECTION_TRACE_ROW_CURR_VIEW, C_RED, iView + iStartView, (iView + iStartView) / static_cast<double>(m_nView) * 100.);
#endif
if (m_trace == Trace::TRACE_CONSOLE)
std::cout << "Current View: " << iView+iStartView << std::endl;
projectSingleView (phm, detArray, xd1, yd1, xd2, yd2, xs1, ys1, xs2, ys2, viewAngle + 3 * HALFPI);
detArray.setViewAngle (viewAngle);
#ifdef HAVE_SGP
if (m_pSGP && m_trace >= Trace::TRACE_PHANTOM) {
// rs_plot (detArray, xd1, yd1, dXCenter, dYCenter, theta);
}
#endif
xform_mtx2 (m_rotmtxIncrement, xs1, ys1);
xform_mtx2 (m_rotmtxIncrement, xs2, ys2);
if (m_idGeometry != GEOMETRY_EQUIANGULAR) {
xform_mtx2 (m_rotmtxIncrement, xd1, yd1); // rotate detector endpoints
xform_mtx2 (m_rotmtxIncrement, xd2, yd2);
}
} /* for each iView */
}
int
phm2helix_main (int argc, char* const argv[])
{
Phantom phm;
std::string optGeometryName = Scanner::convertGeometryIDToName(Scanner::GEOMETRY_PARALLEL);
char *opt_outfile = NULL;
std::string opt_desc;
std::string opt_PhmProg;
std::string opt_PhmFileName = "tmpphmfile";
int opt_ndet;
int opt_nview;
int opt_offsetview = 0;
int opt_nray = 1;
double dOptFocalLength = 2.;
double dOptCenterDetectorLength = 2;
double dOptViewRatio = 1.;
double dOptScanRatio = 1.;
int opt_trace = Trace::TRACE_NONE;
int opt_verbose = 0;
int opt_debug = 0;
double opt_rotangle = -1;
char* endptr = NULL;
char* endstr;
Timer timerProgram;
while (1) {
int c = getopt_long(argc, argv, "", phm2helix_options, NULL);
if (c == -1)
break;
switch (c) {
case O_VERBOSE:
opt_verbose = 1;
break;
case O_DEBUG:
opt_debug = 1;
break;
case O_TRACE:
if ((opt_trace = Trace::convertTraceNameToID(optarg))
== Trace::TRACE_INVALID) {
phm2helix_usage(argv[0]);
return (1);
}
break;
case O_PHMFILE:
opt_PhmFileName = optarg;
break;
case O_DESC:
opt_desc = optarg;
break;
case O_ROTANGLE:
opt_rotangle = strtod(optarg, &endptr);
endstr = optarg + strlen(optarg);
if (endptr != endstr) {
std::cerr << "Error setting --rotangle to " << optarg << std::endl;
phm2helix_usage(argv[0]);
return (1);
}
break;
case O_GEOMETRY:
optGeometryName = optarg;
break;
case O_FOCAL_LENGTH:
dOptFocalLength = strtod(optarg, &endptr);
endstr = optarg + strlen(optarg);
if (endptr != endstr) {
std::cerr << "Error setting --focal-length to " << optarg << std::endl;
phm2helix_usage(argv[0]);
return (1);
}
break;
case O_CENTER_DETECTOR_LENGTH:
dOptCenterDetectorLength = strtod(optarg, &endptr);
endstr = optarg + strlen(optarg);
if (endptr != endstr) {
std::cerr << "Error setting --center-detector-length to " << optarg << std::endl;
phm2helix_usage(argv[0]);
return (1);
}
break;
case O_VIEW_RATIO:
dOptViewRatio = strtod(optarg, &endptr);
endstr = optarg + strlen(optarg);
if (endptr != endstr) {
std::cerr << "Error setting --view-ratio to " << optarg << std::endl;
phm2helix_usage(argv[0]);
return (1);
}
break;
case O_SCAN_RATIO:
dOptScanRatio = strtod(optarg, &endptr);
endstr = optarg + strlen(optarg);
if (endptr != endstr) {
std::cerr << "Error setting --scan-ratio to " << optarg << std::endl;
phm2helix_usage(argv[0]);
return (1);
}
break;
case O_NRAY:
opt_nray = strtol(optarg, &endptr, 10);
endstr = optarg + strlen(optarg);
if (endptr != endstr) {
std::cerr << "Error setting --nray to %s" << optarg << std::endl;
phm2helix_usage(argv[0]);
return (1);
}
break;
case O_OFFSETVIEW:
opt_offsetview = strtol(optarg, &endptr, 10);
endstr = optarg + strlen(optarg);
if (endptr != endstr) {
std::cerr << "Error setting --offsetview to %s" << optarg << std::endl;
phm2helix_usage(argv[0]);
return (1);
}
break;
case O_VERSION:
#ifdef VERSION
std::cout << "Version: " << VERSION << std::endl << g_szIdStr << std::endl;
#else
std::cout << "Unknown version number\n";
#endif
return (0);
case O_HELP:
case '?':
phm2helix_usage(argv[0]);
return (0);
default:
phm2helix_usage(argv[0]);
return (1);
} // end of switch
} // end of while loop
if (optind + 4 != argc) {
phm2helix_usage(argv[0]);
return (1);
}
opt_outfile = argv[optind];
opt_ndet = strtol(argv[optind+1], &endptr, 10);
endstr = argv[optind+1] + strlen(argv[optind+1]);
if (endptr != endstr) {
std::cerr << "Error setting --ndet to " << argv[optind+1] << std::endl;
phm2helix_usage(argv[0]);
return (1);
}
opt_nview = strtol(argv[optind+2], &endptr, 10);
endstr = argv[optind+2] + strlen(argv[optind+2]);
if (endptr != endstr) {
std::cerr << "Error setting --nview to " << argv[optind+2] << std::endl;
phm2helix_usage(argv[0]);
return (1);
}
opt_PhmProg = argv[optind+3];
if (opt_rotangle < 0) {
if (optGeometryName.compare ("parallel") == 0)
opt_rotangle = 0.5;
else
opt_rotangle = 1.0;
}
std::ostringstream desc;
desc << "phm2helix: NDet=" << opt_ndet
<< ", Nview=" << opt_nview
<< ", NRay=" << opt_nray
<< ", RotAngle=" << opt_rotangle
<< ", OffsetView =" << opt_offsetview
<< ", Geometry=" << optGeometryName
<< ", PhantomProg=" << opt_PhmProg
<< ", PhmFileName=" << opt_PhmFileName;
if (opt_desc.length()) {
desc << ": " << opt_desc;
}
opt_desc = desc.str();
opt_rotangle *= TWOPI;
int stat;
char extcommand[100];
if(opt_debug != 0)
std::cout << opt_PhmProg << " " << 0 << " " << opt_nview << " " << opt_PhmFileName << std::endl;
//extcommand << opt_PhmProg << " " << 0 << " " << opt_nview << " " << opt_PhmFileName ;
sprintf(extcommand, "%s %d %d %s", opt_PhmProg.c_str(), 0, opt_nview, opt_PhmFileName.c_str() );
stat = system( extcommand );
if (stat != 0 )
std::cerr << "Error executing external phantom program " << opt_PhmProg << " with command " << extcommand << std::endl;
phm.createFromFile (opt_PhmFileName.c_str());
remove(opt_PhmFileName.c_str());
Scanner scanner (phm, optGeometryName.c_str(), opt_ndet, opt_nview,
opt_offsetview, opt_nray, opt_rotangle, dOptFocalLength,
dOptCenterDetectorLength, dOptViewRatio, dOptScanRatio);
if (scanner.fail()) {
std::cout << "Scanner Creation Error: " << scanner.failMessage()
<< std::endl;
return (1);
}
Projections pjGlobal(scanner);
for( int iView = 0; iView < opt_nview; iView++ ){
if(opt_debug != 0)
std::cout << opt_PhmProg << " " << iView << " " << opt_nview << " " << opt_PhmFileName << std::endl;
//extcommand << opt_PhmProg << " " << iView << " " << opt_nview << " " << opt_PhmFileName ;
sprintf(extcommand, "%s %d %d %s",
opt_PhmProg.c_str(), iView, opt_nview,
opt_PhmFileName.c_str() );
stat = system( extcommand );
if (stat != 0 )
std::cerr << "Error executing external phantom program " << opt_PhmProg << " with command " << extcommand << std::endl;
Phantom phmtmp;
phmtmp.createFromFile (opt_PhmFileName.c_str());
scanner.collectProjections (pjGlobal, phmtmp, iView,
1, scanner.offsetView(), true, opt_trace);
remove(opt_PhmFileName.c_str());
}
pjGlobal.setCalcTime (timerProgram.timerEnd());
pjGlobal.setRemark (opt_desc);
pjGlobal.write (opt_outfile);
if (opt_verbose) {
phm.print (std::cout);
std::cout << std::endl;
std::ostringstream os;
pjGlobal.printScanInfo (os);
std::cout << os.str() << std::endl;
std::cout << " Remark: " << pjGlobal.remark() << std::endl;
std::cout << "Run time: " << pjGlobal.calcTime() << " seconds\n";
}
return (0);
}
void run()
{
phantom.read(fn_phantom);
phantom.draw_in(vol());
vol.write(fn_vol);
}
