** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: scanner.cpp,v 1.8 2000/07/31 14:48:35 kevin Exp $
+** $Id: scanner.cpp,v 1.18 2000/12/16 02:31:00 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 Scanner::GEOMETRY_INVALID = -1;
const int Scanner::GEOMETRY_PARALLEL = 0;
-const int Scanner::GEOMETRY_EQUILINEAR = 1;
-const int Scanner::GEOMETRY_EQUIANGULAR = 2;
+const int Scanner::GEOMETRY_EQUIANGULAR = 1;
+const int Scanner::GEOMETRY_EQUILINEAR = 2;
const char* Scanner::s_aszGeometryName[] =
{
{"parallel"},
- {"equilinear"},
{"equiangular"},
+ {"equilinear"},
};
const char* Scanner::s_aszGeometryTitle[] =
{
{"Parallel"},
- {"Equilinear"},
{"Equiangular"},
+ {"Equilinear"},
};
const int Scanner::s_iGeometryCount = sizeof(s_aszGeometryName) / sizeof(const char*);
* int nSample Number of rays per detector
*/
-Scanner::Scanner (const Phantom& phm, const char* const geometryName, int nDet, int nView, int nSample, const double rot_anglen)
+Scanner::Scanner (const Phantom& phm, const char* const geometryName, int nDet, int nView, int nSample, const double rot_anglen, const double dFocalLengthRatio, const double dFieldOfViewRatio)
{
m_phmLen = phm.maxAxisLength(); // maximal length along an axis
return;
}
- if (nView < 1)
- nView = 1;
+ if (nView < 1 || nDet < 1) {
+ m_fail = true;
+ m_failMessage = "nView & nDet must be greater than 0";
+ return;
+ }
if (nSample < 1)
m_nSample = 1;
- if (nDet < 1)
- nDet = 1;
- if ((nDet % 2) == 0)
- ++nDet; // ensure odd number of detectors
m_nDet = nDet;
m_nView = nView;
m_nSample = nSample;
- m_detLen = SQRT2 * m_phmLen * ((m_nDet + N_EXTRA_DETECTORS) / static_cast<double>(m_nDet));
-
- m_rotLen = rot_anglen;
-
- m_radius = m_detLen / 2;
- m_detInc = m_detLen / m_nDet;
+ m_dFocalLengthRatio = dFocalLengthRatio;
+ m_dFieldOfViewRatio = dFieldOfViewRatio;
+ m_dFocalLength = (m_phmLen * SQRT2 / 2) * dFocalLengthRatio;
+ m_dFieldOfView = m_phmLen * SQRT2 * dFieldOfViewRatio;
+
+ 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_detLen = m_dFieldOfView;
+ m_detInc = m_detLen / m_nDet;
+ if (m_nDet % 2 == 0) // Adjust for Even number of detectors
+ m_detInc = m_detLen / (m_nDet - 1); // center detector = (nDet/2)-1
+
+ double dHalfDetLen = m_detLen / 2;
+ m_initPos.xs1 = m_dXCenter - dHalfDetLen;
+ m_initPos.ys1 = m_dYCenter + m_dFocalLength;
+ m_initPos.xs2 = m_dXCenter + dHalfDetLen;
+ m_initPos.ys2 = m_dYCenter + m_dFocalLength;
+ m_initPos.xd1 = m_dXCenter - dHalfDetLen;
+ m_initPos.yd1 = m_dYCenter - m_dFocalLength;
+ m_initPos.xd2 = m_dXCenter + dHalfDetLen;
+ m_initPos.yd2 = m_dYCenter - m_dFocalLength;
+ m_initPos.angle = 0.0;
+ } else if (m_idGeometry == GEOMETRY_EQUILINEAR) {
+#if 0
+ double dAngle = (m_dFieldOfView / 2) / cos (asin (m_dFieldOfView / 2 / m_dFocalLength));
+#else
+ double dHalfSquare = m_dFieldOfView / SQRT2 / 2;
+ double dFocalPastPhm = m_dFocalLength - dHalfSquare;
+ if (dFocalPastPhm <= 0.) {
+ m_fail = true;
+ m_failMessage = "Focal Point inside of phantom";
+ return;
+ }
+ double dAngle = atan( dHalfSquare / dFocalPastPhm );
+#endif
+ double dHalfDetLen = 2 * m_dFocalLength * tan (dAngle);
- m_initPos.xd1 = m_detLen / 2;
- m_initPos.yd1 = -m_detLen / 2;
- m_initPos.xd2 = m_detLen / 2;
- m_initPos.yd2 = m_detLen / 2;
- m_initPos.xs1 = -m_detLen / 2;
- m_initPos.ys1 = -m_detLen / 2;
- m_initPos.xs2 = -m_detLen / 2;
- m_initPos.ys2 = m_detLen / 2;
- m_initPos.angle = 0.0;
+ m_detLen = dHalfDetLen * 2;
+ m_detInc = m_detLen / m_nDet;
+ if (m_nDet % 2 == 0) // Adjust for Even number of detectors
+ m_detInc = m_detLen / (m_nDet - 1); // center detector = (nDet/2)-1
+
+ m_initPos.angle = 0.0;
+ 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_dFocalLength;
+ m_initPos.xd2 = m_dXCenter + dHalfDetLen;
+ m_initPos.yd2 = m_dYCenter - m_dFocalLength;
+ m_initPos.angle = 0.0;
+ } else if (m_idGeometry == GEOMETRY_EQUIANGULAR) {
+#if 0
+ double dAngle = atan ((m_dFieldOfView / 2) / m_dFocalLength);
+#else
+ double dHalfSquare = m_dFieldOfView / SQRT2 / 2;
+ double dFocalPastPhm = m_dFocalLength - dHalfSquare;
+ if (dFocalPastPhm <= 0.) {
+ m_fail = true;
+ m_failMessage = "Focal Point inside of phantom";
+ return;
+ }
+ double dAngle = atan ( dHalfSquare / dFocalPastPhm );
+#endif
+ m_detLen = 2 * dAngle;
+ m_detInc = m_detLen / m_nDet;
+ if (m_nDet % 2 == 0) // Adjust for Even number of detectors
+ m_detInc = m_detLen / (m_nDet - 1); // center detector = (nDet/2)-1
+ m_dAngularDetIncrement = m_detInc * 2; // Angular Position 2x gamma angle
+ m_dAngularDetLen = m_detLen * 2;
+ m_initPos.dAngularDet = -m_dAngularDetLen / 2;
+
+ m_initPos.angle = 0;
+ m_initPos.xs1 = m_dXCenter;
+ m_initPos.ys1 = m_dYCenter + m_dFocalLength;;
+ m_initPos.xs2 = m_dXCenter;
+ m_initPos.ys2 = m_dYCenter + m_dFocalLength;
+ }
+
+ // 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);
+
}
Scanner::~Scanner (void)
/* NAME
- * raysum_collect Calculate ray sums for a Phantom
+ * collectProjections Calculate projections for a Phantom
*
* SYNOPSIS
- * rs = raysum_collect (det, phm, start_view, trace, unit_pulse)
- * Scanner& det Scanner specifications**
- * RAYSUM *rs Calculated ray sum matrix
- * Phantom& phm Phantom we are taking ray sums of
- * int trace Boolean flag to signal ray sum tracing
+ * collectProjections (proj, phm, start_view, nView, bStoreViewPos, trace)
+ * Projectrions& proj Projection storage
+ * Phantom& phm Phantom for which we collect projections
+ * bool bStoreViewPos TRUE then storage proj at normal view position
+ * int trace Trace level
*/
+
void
-Scanner::collectProjections (Projections& proj, const Phantom& phm, const int start_view, const int trace = TRACE_NONE, SGP* pSGP = NULL)
+Scanner::collectProjections (Projections& proj, const Phantom& phm, const int trace, SGP* pSGP)
{
- GRFMTX_2D rotmtx_initial, temp;
- GRFMTX_2D rotmtx_incr;
-
- double start_angle = start_view * proj.rotInc();
- double xcent = phm.xmin() + (phm.xmax() - phm.xmin()) / 2;
- double ycent = phm.ymin() + (phm.ymax() - phm.ymin()) / 2;
-
- double xd1 = xcent + m_initPos.xd1;
- double yd1 = ycent + m_initPos.yd1;
- double xd2 = xcent + m_initPos.xd2;
- double yd2 = ycent + m_initPos.yd2;
- double xs1 = xcent + m_initPos.xs1;
- double ys1 = ycent + m_initPos.ys1;
- double xs2 = xcent + m_initPos.xs2;
- double ys2 = ycent + m_initPos.ys2;
-
- m_trace = trace;
+ collectProjections (proj, phm, 0, proj.nView(), true, trace, pSGP);
+}
-#ifdef HAVE_SGP
- if (pSGP && m_trace >= TRACE_PHM) {
- double wsize = 1.42 * m_phmLen / 2; /* sqrt(2) * radius */
-
- pSGP->setColor (C_LTBLUE);
- pSGP->setWindow (xcent - wsize, ycent - wsize, xcent + wsize, ycent + wsize);
- pSGP->setColor (C_BROWN);
-#if RADIUS
- pSGP->drawCircle (m_phmLen / 2);
-#else
- pSGP->drawRect (xcent - m_phmLen / 2, ycent - m_phmLen / 2,
- xcent + m_phmLen / 2, ycent + m_phmLen / 2);
-#endif
- pSGP->setColor (C_BROWN);
- pSGP->moveAbs (0., 0.);
- pSGP->drawCircle (wsize);
- // raysum_trace_menu_column = (crt->xsize * crt->asp) / 8 + 3;
- traceShowParam ("X-Ray Simulator", "%s", RAYSUM_TRACE_ROW_TITLE, C_BLACK, " ");
- traceShowParam ("---------------", "%s", RAYSUM_TRACE_ROW_TITLE2, C_BLACK, " ");
- traceShowParam ("Phantom:", "%s", RAYSUM_TRACE_ROW_PHANT_ID, C_YELLOW, " Herman");
- traceShowParam ("Chomaticity :", "%s", RAYSUM_TRACE_ROW_CHROMATIC, C_LTGREEN, "Mono");
- traceShowParam ("Scatter :", "%5.1f", RAYSUM_TRACE_ROW_SCATTER, C_LTGREEN, 0.);
- traceShowParam ("Photon Uncert:", "%5.1f", RAYSUM_TRACE_ROW_PHOT_STAT, C_LTGREEN, 0.);
- traceShowParam ("Num Scanners:", "%5d", RAYSUM_TRACE_ROW_NDET, C_LTRED, proj.nDet());
- traceShowParam ("Num Views :", "%5d", RAYSUM_TRACE_ROW_NVIEW, C_LTRED, proj.nView());
- traceShowParam ("Samples / Ray:", "%5d", RAYSUM_TRACE_ROW_SAMPLES, C_LTRED, m_nSample);
-
- pSGP->setColor (C_LTGREEN);
- phm.draw (*pSGP);
-
- pSGP->setMarker (SGP::MARK_BDIAMOND, C_LTGREEN);
- }
-#endif
+void
+Scanner::collectProjections (Projections& proj, const Phantom& phm, const int iStartView, const int iNumViews, bool bStoreAtViewPosition, const int trace, SGP* pSGP)
+{
+ m_trace = trace;
+ double start_angle = iStartView * proj.rotInc();
-/* Calculate initial rotation matrix */
- xlat_mtx2 (rotmtx_initial, -xcent, -ycent);
+ // 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, xcent, ycent);
+ xlat_mtx2 (temp, m_dXCenter, m_dYCenter);
mult_mtx2 (rotmtx_initial, temp, rotmtx_initial);
- xform_mtx2 (rotmtx_initial, xd1, yd1); /* rotate detector endpoints */
- xform_mtx2 (rotmtx_initial, xd2, yd2); /* to initial view_angle */
- xform_mtx2 (rotmtx_initial, xs1, ys1);
- xform_mtx2 (rotmtx_initial, xs2, ys2);
-
-/* Calculate incrementatal rotation matrix */
- xlat_mtx2 (rotmtx_incr, -xcent, -ycent);
- rot_mtx2 (temp, proj.rotInc());
- mult_mtx2 (rotmtx_incr, temp, rotmtx_incr);
- xlat_mtx2 (temp, xcent, ycent);
- mult_mtx2 (rotmtx_incr, temp, rotmtx_incr);
+ 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
+ }
- int iview;
+ 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 < proj.nView(); iview++, viewAngle += proj.rotInc()) {
- DetectorArray& detArray = proj.getDetectorArray( iview );
+ for (iView = 0, viewAngle = start_angle; iView < iNumViews; iView++, viewAngle += proj.rotInc()) {
+ int iStoragePosition = iView;
+ if (bStoreAtViewPosition)
+ iStoragePosition += iStartView;
+
+ DetectorArray& detArray = proj.getDetectorArray( iStoragePosition );
+
+#ifdef HAVE_SGP
+ if (pSGP && m_trace >= Trace::TRACE_PHANTOM) {
+ m_pSGP = pSGP;
+ m_pSGP->eraseWindow();
+ double dWindowSize = max(m_detLen, m_dFocalLength * 2) * SQRT2;
+ double dHalfWindowSize = dWindowSize / 2;
+ m_dXMinWin = m_dXCenter - dHalfWindowSize;
+ m_dXMaxWin = m_dXCenter + dHalfWindowSize;
+ m_dYMinWin = m_dYCenter - dHalfWindowSize;
+ m_dYMaxWin = m_dYCenter + dHalfWindowSize;
+ double dHalfPhmLen = m_phmLen / 2;
+
+ m_pSGP->eraseWindow ();
+ 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->drawRect (m_dXCenter - dHalfPhmLen, m_dYCenter - dHalfPhmLen, m_dXCenter + dHalfPhmLen, m_dYCenter + dHalfPhmLen);
+ m_pSGP->moveAbs (0., 0.);
+ m_pSGP->drawCircle (m_dFocalLength);
+ m_pSGP->setColor (C_BLUE);
+ 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::MARK_BDIAMOND, C_LTGREEN);
+ }
+#endif
#ifdef HAVE_SGP
- if (pSGP && m_trace >= TRACE_PHM) {
- pSGP->setColor (C_RED);
- pSGP->moveAbs (xd1, yd1);
- pSGP->lineAbs (xd2, yd2);
- pSGP->moveAbs (xs1, ys1);
- pSGP->lineAbs (xs2, ys2);
+ 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_dFocalLength, 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)
- traceShowParam ("Current View :", "%5d", RAYSUM_TRACE_ROW_CURR_VIEW, C_LTMAGENTA, iview);
-
- projectSingleView (phm, detArray, xd1, yd1, xd2, yd2, xs1, ys1, xs2, ys2, pSGP);
+ if (m_trace == Trace::TRACE_CONSOLE)
+ cout << "Current View: " << iView+iStartView << endl;
+
+ projectSingleView (phm, detArray, xd1, yd1, xd2, yd2, xs1, ys1, xs2, ys2, viewAngle + 3 * HALFPI);
detArray.setViewAngle (viewAngle);
#ifdef HAVE_SGP
- if (pSGP && m_trace >= TRACE_PHM) {
- // rs_plot (detArray, xd1, yd1, xcent, ycent, theta);
- pSGP->setColor (C_RED);
- pSGP->moveAbs (xd1, yd1);
- pSGP->lineAbs (xd2, yd2);
- pSGP->moveAbs (xs1, ys1);
- pSGP->lineAbs (xs2, ys2);
+ if (m_pSGP && m_trace >= Trace::TRACE_PHANTOM) {
+ // rs_plot (detArray, xd1, yd1, dXCenter, dYCenter, theta);
}
#endif
- xform_mtx2 (rotmtx_incr, xd1, yd1); // rotate detector endpoints
- xform_mtx2 (rotmtx_incr, xd2, yd2);
- xform_mtx2 (rotmtx_incr, xs1, ys1);
- xform_mtx2 (rotmtx_incr, xs2, ys2);
- } /* for each iview */
+ 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 */
}
*/
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, SGP* pSGP)
+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 ddx = (xd2 - xd1) / detArray.nDet(); // change in coords between detectors
- double ddy = (yd2 - yd1) / detArray.nDet();
- double sdx = (xs2 - xs1) / detArray.nDet(); // change in coords between source
- double sdy = (ys2 - ys1) / detArray.nDet();
-
- double ddx2 = ddx / m_nSample; // Incr. between rays with detector cell
- double ddy2 = ddy / m_nSample; // Doesn't include detector endpoints
- double ddx2_ofs = ddx2 / 2; // offset of 1st ray from start of detector cell
- double ddy2_ofs = ddy2 / 2;
-
- double xd_maj = xd1 + ddx2_ofs; // Incr. between detector cells
- double yd_maj = yd1 + ddy2_ofs;
+
+ 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
else
detval[d] = 0;
} else {
- for (int d = 0; d < detArray.nDet(); d++) {
- double xd = xd_maj;
- double yd = yd_maj;
+ 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_dFocalLength * cos (dAngle);
+ yd = m_dFocalLength * sin (dAngle);
+ }
+
#ifdef HAVE_SGP
- if (pSGP && m_trace >= TRACE_RAYS) {
- pSGP->setColor (C_LTBLUE);
- pSGP->moveAbs (xs, ys);
- pSGP->lineAbs (xd, yd);
+ 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, pSGP);
-
- if (m_trace >= TRACE_RAYS)
- traceShowParam ("Attenuation :", "%5.2f", RAYSUM_TRACE_ROW_ATTEN, C_LTMAGENTA, "sum");
+ sum += projectSingleLine (phm, xd, yd, xs, ys);
+
#ifdef HAVE_SGP
- if (pSGP && m_trace >= TRACE_RAYS) {
- pSGP->setColor (C_LTBLUE);
- pSGP->moveAbs (xs, ys);
- pSGP->lineAbs (xd, yd);
- }
+ // 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
- xd += ddx2;
- yd += ddy2;
- }
+ if (m_idGeometry == GEOMETRY_EQUIANGULAR)
+ dAngle += dAngleSampleInc;
+ else {
+ xd += ddx2;
+ yd += ddy2;
+ }
+ } // for each sample in detector
detval[d] = sum / m_nSample;
- xd_maj += ddx;
- yd_maj += ddy;
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::traceShowParam (const char *label, const char *fmt, int row, int color, ...)
+Scanner::traceShowParam (const char *szLabel, const char *fmt, int row, int color, ...)
{
- char s[80];
va_list arg;
+ va_start(arg, color);
+#ifdef HAVE_SGP
+ traceShowParamRasterOp (RO_COPY, szLabel, fmt, row, color, arg);
+#else
+ traceShowParamRasterOp (0, szLabel, fmt, row, color, arg);
+#endif
+ va_end(arg);
+}
+void
+Scanner::traceShowParamXOR (const char *szLabel, const char *fmt, int row, int color, ...)
+{
+ va_list arg;
va_start(arg, color);
+#ifdef HAVE_SGP
+ traceShowParamRasterOp (RO_XOR, szLabel, fmt, row, color, arg);
+#else
+ traceShowParamRasterOp (0, szLabel, fmt, row, color, arg);
+#endif
+ va_end(arg);
+}
+
+void
+Scanner::traceShowParamRasterOp (int iRasterOp, const char *szLabel, const char *fmt, int row, int color, va_list args)
+{
+ char szValue[256];
+
+#ifdef MSVC
+ vsprintf (szValue, fmt, args);
+#else
+ vsnprintf (szValue, sizeof(szValue), fmt, args);
+#endif
+
// cio_set_cpos (raysum_trace_menu_column, row);
- snprintf (s, sizeof(s), label, "%s");
// cio_set_text_clr (color - 8, 0);
- cio_put_str (s);
- vsnprintf (s, sizeof(s), fmt, arg);
// cio_set_text_clr (color, 0);
- cio_put_str (s);
- cout << "\n";
- va_end(arg);
+
+#ifdef HAVE_SGP
+ if (m_pSGP) {
+ m_pSGP->setRasterOp (iRasterOp);
+ double dYPos = m_dYMaxWin - (row * m_dTextHeight);
+ m_pSGP->moveAbs (m_dXMinWin, dYPos);
+ m_pSGP->setTextColor (color, -1);
+ m_pSGP->drawText (szLabel);
+ double dValueOffset = (m_dXMaxWin - m_dXMinWin) / 4;
+ m_pSGP->moveAbs (m_dXMinWin + dValueOffset, dYPos);
+ m_pSGP->drawText (szValue);
+ } else
+#endif
+ {
+ cio_put_str (szLabel);
+ cio_put_str (szValue);
+ cio_put_str ("\n");
+ }
}
+
/* NAME
* projectSingleLine INTERNAL: Calculates raysum along a line for a Phantom
*
*/
double
-Scanner::projectSingleLine (const Phantom& phm, const double x1, const double y1, const double x2, const double y2, SGP* pSGP)
+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, pSGP);
+ rsum += projectLineAgainstPElem (**i, x1, y1, x2, y2);
return (rsum);
}
*/
double
-Scanner::projectLineAgainstPElem (const PhantomElement& pelem, double x1, double y1, double x2, double y2, SGP* pSGP)
+Scanner::projectLineAgainstPElem (const PhantomElement& pelem, double x1, double y1, double x2, double y2)
{
if (! pelem.clipLineWorldCoords (x1, y1, x2, y2)) {
- if (m_trace == TRACE_CLIPPING)
+ if (m_trace == Trace::TRACE_CLIPPING)
cio_tone (1000., 0.05);
return (0.0);
}
#ifdef HAVE_SGP
- if (pSGP && m_trace == TRACE_CLIPPING) {
- pSGP->moveAbs (x1, y1);
- pSGP->lineAbs (x2, y2);
+ if (m_pSGP && m_trace == Trace::TRACE_CLIPPING) {
+ m_pSGP->setRasterOp (RO_XOR);
+ m_pSGP->moveAbs (x1, y1);
+ m_pSGP->lineAbs (x2, y2);
cio_tone (8000., 0.05);
- pSGP->moveAbs (x1, y1);
- pSGP->lineAbs (x2, y2);
+ m_pSGP->moveAbs (x1, y1);
+ m_pSGP->lineAbs (x2, y2);
+ m_pSGP->setRasterOp (RO_SET);
}
#endif
projects / ctsim.git / blobdiff