/*****************************************************************************
** FILE IDENTIFICATION
**
**   Name:          scanner.cpp
**   Purpose:       Classes for CT scanner
**   Programmer:    Kevin Rosenberg
**   Date Started:  1984
**
**  This is part of the CTSim program
**  Copyright (c) 1983-2009 Kevin Rosenberg
**
**  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
**  published by the Free Software Foundation.
**
**  This program is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program; if not, write to the Free Software
**  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
******************************************************************************/

#include "ct.h"


const int Scanner::GEOMETRY_INVALID = -1;
const int Scanner::GEOMETRY_PARALLEL = 0;
const int Scanner::GEOMETRY_EQUIANGULAR = 1;
const int Scanner::GEOMETRY_EQUILINEAR = 2;
const int Scanner::GEOMETRY_LINOGRAM = 3;

const char* const Scanner::s_aszGeometryName[] =
{
  "parallel",
  "equiangular",
  "equilinear",
  "linogram",
};

const char* const Scanner::s_aszGeometryTitle[] =
{
  "Parallel",
  "Equiangular",
  "Equilinear",
  "Linogram",
};

const int Scanner::s_iGeometryCount = sizeof(s_aszGeometryName) / sizeof(const char*);


// NAME
//   DetectorArray       Construct a DetectorArray

DetectorArray::DetectorArray (const int nDet)
{
  m_nDet = nDet;
  m_detValues = new DetectorValue [m_nDet];
}


// NAME
//   ~DetectorArray             Free memory allocated to a detector array

DetectorArray::~DetectorArray (void)
{
  delete [] m_detValues;
}



/* NAME
*   Scanner::Scanner            Construct a user specified detector structure
*
* SYNOPSIS
*   Scanner (phm, nDet, nView, nSample)
*   Phantom& phm                PHANTOM that we are making detector for
*   int geomety                Geometry of detector
*   int nDet                    Number of detector along detector array
*   int nView                   Number of rotated views
*   int nSample         Number of rays per detector
*/

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);

}

Scanner::~Scanner (void)
{
}


const char*
Scanner::convertGeometryIDToName (const int geomID)
{
  const char *name = "";

  if (geomID >= 0 && geomID < s_iGeometryCount)
    return (s_aszGeometryName[geomID]);

  return (name);
}

const char*
Scanner::convertGeometryIDToTitle (const int geomID)
{
  const char *title = "";

  if (geomID >= 0 && geomID < s_iGeometryCount)
    return (s_aszGeometryName[geomID]);

  return (title);
}

int
Scanner::convertGeometryNameToID (const char* const geomName)
{
  int id = GEOMETRY_INVALID;

  for (int i = 0; i < s_iGeometryCount; i++) {
    if (strcasecmp (geomName, s_aszGeometryName[i]) == 0) {
      id = i;
      break;
    }
  }
  return (id);
}


/* NAME
*   collectProjections          Calculate projections for a Phantom
*
* SYNOPSIS
*   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 trace, SGP* pSGP)
{
  collectProjections (proj, phm, m_startView, proj.nView(), m_iOffsetView, true, trace, pSGP);
}

void
Scanner::collectProjections (Projections& proj, const Phantom& phm, const int iStartView,
                             const int iNumViews, const int iOffsetView,  bool bStoreAtViewPosition,
                             const int trace, SGP* pSGP)
{
  int iStorageOffset = (bStoreAtViewPosition ? iStartView : 0);
  collectProjections (proj, phm, iStartView, iNumViews, iOffsetView, iStorageOffset, trace, pSGP);
}

static void mtx2_offset_rot (GRFMTX_2D m, double angle, double x, double y) {
  GRFMTX_2D temp;
  xlat_mtx2 (m, -x, -y);
  rot_mtx2 (temp, angle);
  mult_mtx2 (m, temp, m);
  xlat_mtx2 (temp, x, y);
  mult_mtx2 (m, temp, m);
}

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();

#ifdef HAVE_OPENMP
  #pragma omp parallel for
#endif
  
  for (int iView = 0;  iView < iNumViews; iView++) {
    double viewAngle = start_angle + (iView * proj.rotInc());
    
    // With OpenMP, need to calculate source and detector positions at each view
    GRFMTX_2D rotmtx;
    mtx2_offset_rot (rotmtx, viewAngle, m_dXCenter, m_dYCenter);
    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, xd1, yd1);      // rotate detector endpoints
      xform_mtx2 (rotmtx, xd2, yd2);      // to initial view_angle
    }
    
    double xs1 = m_initPos.xs1, ys1 = m_initPos.ys1;
    double xs2 = m_initPos.xs2, ys2 = m_initPos.ys2;
    xform_mtx2 (rotmtx, xs1, ys1);      // rotate source endpoints to
    xform_mtx2 (rotmtx, xs2, ys2);      // initial view angle
    
    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);

      
      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

  } /* for each iView */
}


/* NAME
*    rayview                    Calculate raysums for a view at any angle
*
* SYNOPSIS
*    rayview (phm, detArray, xd1, nSample, yd1, xd2, yd2, xs1, ys1, xs2, ys2)
*    Phantom& phm               Phantom to scan
*    DETARRAY *detArray         Storage of values for detector array
*    Scanner& det               Scanner parameters
*    double xd1, yd1, xd2, yd2  Beginning & ending detector positions
*    double xs1, ys1, xs2, ys2  Beginning & ending source positions
*
* RAY POSITIONING
*         For each detector, have there are a variable number of rays traced.
*     The source of each ray is the center of the source x-ray cell. The
*     detector positions are equally spaced within the cell
*
*         The increments between rays are calculated so that the cells start
*     at the beginning of a detector cell and they end on the endpoint
*     of the cell.  Thus, the last cell starts at (xd2-ddx),(yd2-ddy).
*         The exception to this is if there is only one ray per detector.
*     In that case, the detector position is the center of the detector cell.
*/

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::traceShowParam (const char *szLabel, const char *fmt, int row, int color, ...)
{
  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];

  vsnprintf (szValue, sizeof(szValue), fmt, args);

#ifdef HAVE_SGP
  if (m_pSGP) {
    m_pSGP->setRasterOp (iRasterOp);
    m_pSGP->setTextColor (color, -1);
    double dValueOffset = (m_dXMaxWin - m_dXMinWin) / 4;
    if (row < 4) {
      double dYPos = m_dYMaxWin - (row * m_dTextHeight);
      double dXPos = m_dXMinWin;
      m_pSGP->moveAbs (dXPos, dYPos);
      m_pSGP->drawText (szLabel);
      m_pSGP->moveAbs (dXPos + dValueOffset, dYPos);
      m_pSGP->drawText (szValue);
    } else {
      row -= 4;
      double dYPos = m_dYMaxWin - (row * m_dTextHeight);
      double dXPos = m_dXMinWin + (m_dXMaxWin - m_dXMinWin) * 0.5;
      m_pSGP->moveAbs (dXPos, dYPos);
      m_pSGP->drawText (szLabel);
      m_pSGP->moveAbs (dXPos + 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
*
* SYNOPSIS
*    rsum = phm_ray_attenuation (phm, x1, y1, x2, y2)
*    double rsum                Ray sum of Phantom along given line
*    Phantom& phm;              Phantom from which to calculate raysum
*    double *x1, *y1, *x2, y2   Endpoints of ray path (in Phantom coords)
*/

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);
}


/* NAME
*   pelem_ray_attenuation               Calculate raysum of an pelem along one line
*
* SYNOPSIS
*   rsum = pelem_ray_attenuation (pelem, x1, y1, x2, y2)
*   double rsum         Computed raysum
*   PhantomElement& pelem               Pelem to scan
*   double x1, y1, x2, y2       Endpoints of raysum line
*/

double
Scanner::projectLineAgainstPElem (const PhantomElement& pelem, double x1, double y1, double x2, double y2)
{
  if (! pelem.clipLineWorldCoords (x1, y1, x2, y2)) {
    if (m_trace == Trace::TRACE_CLIPPING)
      cio_tone (1000., 0.05);
    return (0.0);
  }

#ifdef HAVE_SGP
  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);
    m_pSGP->moveAbs (x1, y1);
    m_pSGP->lineAbs (x2, y2);
    m_pSGP->setRasterOp (RO_SET);
  }
#endif

  double len = lineLength (x1, y1, x2, y2);
  return (len * pelem.atten());
}