-2.0.0-b6 - 7/19/00
+2.0.0-b6 - 7/22/00
ctsim program: improved initial size and scroll area for image
and projection files
ctsim program: added rasterization parameters, projections parameters,
and reconstruction parameters dialogs
+ Moved char[] static definition from header files to c++ files
+ Completely reorganized option processing in classes to improve
+ expandability and to assist ctsim graphical user interface.
2.0.0-b5 - 7/17/00
ctsim program: Added dialog to set minimum/maximum display levels
dnl CDPATH=
AC_INIT(src/ctsim.cpp)
-AM_INIT_AUTOMAKE(ctsim,2.0.0-b5)
+AM_INIT_AUTOMAKE(ctsim,2.0.0-b6)
AM_CONFIG_HEADER(config.h)
dnl Checks for programs.
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: backprojectors.h,v 1.11 2000/07/20 11:17:31 kevin Exp $
+** $Id: backprojectors.h,v 1.12 2000/07/22 15:45:33 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
class Backproject;
+class ImageFile;
+class Projections;
class Backprojector
{
public:
- typedef enum {
- BPROJ_INVALID,
- BPROJ_TRIG,
- BPROJ_TABLE,
- BPROJ_DIFF,
- BPROJ_DIFF2,
- BPROJ_IDIFF2,
- BPROJ_IDIFF3
-} BackprojectID;
-
- typedef enum {
- INTERP_INVALID,
- INTERP_NEAREST, // Nearest neighbor
+ static const int BPROJ_INVALID;
+ static const int BPROJ_TRIG;
+ static const int BPROJ_TABLE;
+ static const int BPROJ_DIFF;
+ static const int BPROJ_DIFF2;
+ static const int BPROJ_IDIFF2;
+ static const int BPROJ_IDIFF3;
+
+ static const int INTERP_INVALID;
+ static const int INTERP_NEAREST;
+ static const int INTERP_LINEAR;
+ static const int INTERP_FREQ_PREINTERPOLATION;
#if HAVE_BSPLINE_INTERP
- I_BSPLINE,
- I_1BSPLINE, // 1st order B-Spline
- I_2BSPLINE,
- I_3BSPLINE,
+ static const int INTERP_BSPLINE;
+ static const int INTERP_1BSPLINE;
+ static const int INTERP_2BSPLINE;
+ static const int INTERP_3BSPLINE;
#endif
- INTERP_LINEAR, // Linear interpolation
- INTERP_FREQ_PREINTERPOLATION,
- } InterpolationID;
-
- static const char BPROJ_TRIG_STR[];
- static const char BPROJ_TABLE_STR[];
- static const char BPROJ_DIFF_STR[];
- static const char BPROJ_DIFF2_STR[];
- static const char BPROJ_IDIFF2_STR[];
- static const char BPROJ_IDIFF3_STR[];
-
- static const char BPROJ_TRIG_TITLE_STR[];
- static const char BPROJ_TABLE_TITLE_STR[];
- static const char BPROJ_DIFF_TITLE_STR[];
- static const char BPROJ_DIFF2_TITLE_STR[];
- static const char BPROJ_IDIFF2_TITLE_STR[];
- static const char BPROJ_IDIFF3_TITLE_STR[];
-
- static const char INTERP_NEAREST_STR[];
- static const char INTERP_LINEAR_STR[];
- static const char INTERP_BSPLINE_STR[];
- static const char INTERP_FREQ_PREINTERPOLATION_STR[];
-
- static const char INTERP_NEAREST_TITLE_STR[];
- static const char INTERP_LINEAR_TITLE_STR[];
- static const char INTERP_BSPLINE_TITLE_STR[];
- static const char INTERP_FREQ_PREINTERPOLATION_TITLE_STR[];
Backprojector (const Projections& proj, ImageFile& im, const char* const backprojName, const char* const interpName, const int interpFactor);
- ~Backprojector (void);
+ ~Backprojector ();
void BackprojectView (const double* const viewData, const double viewAngle);
- bool fail(void) const {return m_fail;}
- const string& failMessage(void) const {return m_failMessage;}
+ bool fail() const {return m_fail;}
+ const string& failMessage() const {return m_failMessage;}
+
+ static const int getBackprojectCount() {return s_iBackprojectCount;}
+ static const char** getBackprojectNameArray() {return s_aszBackprojectName;}
+ static const char** getBackprojectTitleArray() {return s_aszBackprojectTitle;}
+ static int convertBackprojectNameToID (const char* const bprojName);
+ static const char* convertBackprojectIDToName (const int bprojID);
+ static const char* convertBackprojectIDToTitle (const int bprojID);
+
+ static const int getInterpCount() {return s_iInterpCount;}
+ static const char** getInterpNameArray() {return s_aszInterpName;}
+ static const char** getInterpTitleArray() {return s_aszInterpTitle;}
+ static int convertInterpNameToID (const char* const interpName);
+ static const char* convertInterpIDToName (const int interpID);
+ static const char* convertInterpIDToTitle (const int interpID);
+
private:
string m_nameBackproject;
string m_nameInterpolation;
- BackprojectID m_idBackproject;
- InterpolationID m_idInterpolation;
+ int m_idBackproject;
+ int m_idInterpolation;
Backproject* m_pBackprojectImplem;
bool m_fail;
string m_failMessage;
- static const InterpolationID convertInterpolationNameToID (const char* const interpName);
- static const char* convertInterpolationIDToName (const InterpolationID interpID);
- static const BackprojectID convertBackprojectNameToID (const char* const bprojName);
- static const char* convertBackprojectIDToName (const BackprojectID bprojID);
+ static const char* s_aszBackprojectName[];
+ static const char* s_aszBackprojectTitle[];
+ static const int s_iBackprojectCount;
+
+ static const char* s_aszInterpName[];
+ static const char* s_aszInterpTitle[];
+ static const int s_iInterpCount;
bool initBackprojector (const Projections& proj, ImageFile& im, const char* const backprojName, const char* const interpName, const int interpFactor);
};
class Backproject
{
public:
- Backproject (const Projections& proj, ImageFile& im, Backprojector::InterpolationID interpType, const int interpFactor);
+ Backproject (const Projections& proj, ImageFile& im, int interpID, const int interpFactor);
virtual ~Backproject ();
virtual void BackprojectView (const double* const viewData, const double viewAngle) {};
protected:
- void ScaleImageByRotIncrement (void);
+ void ScaleImageByRotIncrement ();
void Backproject::errorIndexOutsideDetector (int ix, int iy, double theta, double r, double phi, double L, int ni);
void Backproject::errorIndexOutsideDetector (int ix, int iy, double theta, double L, int ni);
const Projections& proj;
ImageFile& im;
- Backprojector::InterpolationID interpType;
+ int interpType;
ImageFileArray v;
kint32 nx;
kint32 ny;
class BackprojectTrig : public Backproject
{
public:
- BackprojectTrig (const Projections& proj, ImageFile& im, Backprojector::InterpolationID interpType, const int interpFactor)
+ BackprojectTrig (const Projections& proj, ImageFile& im, int interpID, const int interpFactor)
: Backproject::Backproject (proj, im, interpType, interpFactor)
{}
class BackprojectTable : public Backproject
{
public:
- BackprojectTable (const Projections& proj, ImageFile& im, Backprojector::InterpolationID interpType, const int interpFactor);
+ BackprojectTable (const Projections& proj, ImageFile& im, int interpID, const int interpFactor);
~BackprojectTable ();
void BackprojectView (const double* const t, double view_angle);
class BackprojectDiff : public Backproject
{
public:
- BackprojectDiff (const Projections& proj, ImageFile& im, Backprojector::InterpolationID interpType, const int interpFactor);
+ BackprojectDiff (const Projections& proj, ImageFile& im, int interpID, const int interpFactor);
~BackprojectDiff ();
void BackprojectView (const double* const t, double view_angle);
class BackprojectDiff2 : public BackprojectDiff
{
public:
- BackprojectDiff2 (const Projections& proj, ImageFile& im, Backprojector::InterpolationID interpType, const int interpFactor)
+ BackprojectDiff2 (const Projections& proj, ImageFile& im, int interpID, const int interpFactor)
: BackprojectDiff::BackprojectDiff (proj, im, interpType, interpFactor)
{}
class BackprojectIntDiff2 : public BackprojectDiff
{
public:
- BackprojectIntDiff2 (const Projections& proj, ImageFile& im, Backprojector::InterpolationID interpType, const int interpFactor)
+ BackprojectIntDiff2 (const Projections& proj, ImageFile& im, int interpID, const int interpFactor)
: BackprojectDiff::BackprojectDiff (proj, im, interpType, interpFactor)
{}
class BackprojectIntDiff3 : public BackprojectDiff
{
public:
- BackprojectIntDiff3 (const Projections& proj, ImageFile& im, Backprojector::InterpolationID interpType, const int interpFactor)
+ BackprojectIntDiff3 (const Projections& proj, ImageFile& im, int interpType, const int interpFactor)
: BackprojectDiff::BackprojectDiff (proj, im, interpType, interpFactor)
{}
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: filter.h,v 1.15 2000/07/20 11:17:31 kevin Exp $
+** $Id: filter.h,v 1.16 2000/07/22 15:45:33 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
class SignalFilter {
public:
- typedef enum {
- FILTER_INVALID,
- FILTER_BANDLIMIT,
- FILTER_SINC,
- FILTER_G_HAMMING,
- FILTER_COSINE,
- FILTER_TRIANGLE,
- FILTER_ABS_BANDLIMIT, // filter times |x|
- FILTER_ABS_SINC,
- FILTER_ABS_G_HAMMING,
- FILTER_ABS_COSINE,
- FILTER_SHEPP
- } FilterID;
-
- typedef enum {
- FILTER_METHOD_INVALID,
- FILTER_METHOD_CONVOLUTION,
- FILTER_METHOD_FOURIER,
- FILTER_METHOD_FOURIER_TABLE,
- FILTER_METHOD_FFT,
+ static const int FILTER_INVALID;
+ static const int FILTER_BANDLIMIT;
+ static const int FILTER_SINC;
+ static const int FILTER_G_HAMMING;
+ static const int FILTER_COSINE;
+ static const int FILTER_TRIANGLE;
+ static const int FILTER_ABS_BANDLIMIT; // filter times |x|
+ static const int FILTER_ABS_SINC;
+ static const int FILTER_ABS_G_HAMMING;
+ static const int FILTER_ABS_COSINE;
+ static const int FILTER_SHEPP;
+
+ static const int FILTER_METHOD_INVALID;
+ static const int FILTER_METHOD_CONVOLUTION;
+ static const int FILTER_METHOD_FOURIER;
+ static const int FILTER_METHOD_FOURIER_TABLE;
+ static const int FILTER_METHOD_FFT;
#if HAVE_FFTW
- FILTER_METHOD_FFTW,
- FILTER_METHOD_RFFTW,
+ static const int FILTER_METHOD_FFTW;
+ static const int FILTER_METHOD_RFFTW;
#endif
- } FilterMethodID;
- typedef enum {
- DOMAIN_INVALID,
- DOMAIN_FREQUENCY,
- DOMAIN_SPATIAL
- } DomainID;
+ static const int DOMAIN_INVALID;
+ static const int DOMAIN_FREQUENCY;
+ static const int DOMAIN_SPATIAL;
- // Filters
- static const char FILTER_ABS_BANDLIMIT_STR[];
- static const char FILTER_ABS_SINC_STR[];
- static const char FILTER_ABS_COS_STR[];
- static const char FILTER_ABS_HAMMING_STR[];
- static const char FILTER_SHEPP_STR[];
- static const char FILTER_BANDLIMIT_STR[];
- static const char FILTER_SINC_STR[];
- static const char FILTER_COS_STR[];
- static const char FILTER_HAMMING_STR[];
- static const char FILTER_TRIANGLE_STR[];
-
- static const char FILTER_ABS_BANDLIMIT_TITLE_STR[];
- static const char FILTER_ABS_SINC_TITLE_STR[];
- static const char FILTER_ABS_COS_TITLE_STR[];
- static const char FILTER_ABS_HAMMING_TITLE_STR[];
- static const char FILTER_SHEPP_TITLE_STR[];
- static const char FILTER_BANDLIMIT_TITLE_STR[];
- static const char FILTER_SINC_TITLE_STR[];
- static const char FILTER_COS_TITLE_STR[];
- static const char FILTER_HAMMING_TITLE_STR[];
- static const char FILTER_TRIANGLE_TITLE_STR[];
-
- // Filter Methods
- static const char FILTER_METHOD_CONVOLUTION_STR[];
- static const char FILTER_METHOD_FOURIER_STR[];
- static const char FILTER_METHOD_FOURIER_TABLE_STR[];
- static const char FILTER_METHOD_FFT_STR[];
-#if HAVE_FFTW
- static const char FILTER_METHOD_FFTW_STR[];
- static const char FILTER_METHOD_RFFTW_STR[];
-#endif
-
- static const char FILTER_METHOD_CONVOLUTION_TITLE_STR[];
- static const char FILTER_METHOD_FOURIER_TITLE_STR[];
- static const char FILTER_METHOD_FOURIER_TABLE_TITLE_STR[];
- static const char FILTER_METHOD_FFT_TITLE_STR[];
-#if HAVE_FFTW
- static const char FILTER_METHOD_FFTW_TITLESTR[];
- static const char FILTER_METHOD_RFFTW_TITLE_STR[];
-#endif
-
- // Domains
- static const char DOMAIN_FREQUENCY_STR[];
- static const char DOMAIN_SPATIAL_STR[];
-
- static const char DOMAIN_FREQUENCY_TITLE_STR[];
- static const char DOMAIN_SPATIAL_TITLE_STR[];
-
SignalFilter (const char* filterName, const char* filterMethodName,double bw, double signalIncrement, int n, double param, const char* domainName, const int zeropad = 0, const int preinterpolationFactor = 1);
- SignalFilter (const FilterID filt_type, FilterMethodID filterMethodID, double bw, double signalIncrement, int n, double param, const DomainID domain, const int zeropad = 0, const int preinterpolationFactor = 1);
+ SignalFilter (const int filt_type, int filterMethodID, double bw, double signalIncrement, int n, double param, const int domain, const int zeropad = 0, const int preinterpolationFactor = 1);
SignalFilter (const char* filterName, const char* domainName, double bw, double param);
const string& nameFilter(void) const { return m_nameFilter;}
const string& nameDomain(void) const { return m_nameDomain;}
- const FilterID idFilter(void) const { return m_idFilter;}
- const DomainID idDomain(void) const { return m_idDomain;}
+ const int idFilter(void) const { return m_idFilter;}
+ const int idDomain(void) const { return m_idDomain;}
const double getFilterMin(void) const {return m_filterMin;}
const double getFilterMax(void) const {return m_filterMax;}
const double getFilterIncrement(void) const {return m_filterInc;}
double response (double x);
- static double spatialResponse (FilterID fType, double bw, double x, double param);
+ static double spatialResponse (int fType, double bw, double x, double param);
- static double frequencyResponse (FilterID fType, double bw, double u, double param);
+ static double frequencyResponse (int fType, double bw, double u, double param);
- static double spatialResponseAnalytic (FilterID fType, double bw, double x, double param);
+ static double spatialResponseAnalytic (int fType, double bw, double x, double param);
- static double spatialResponseCalc (FilterID fType, double bw, double x, double param, int nIntegral);
+ static double spatialResponseCalc (int fType, double bw, double x, double param, int nIntegral);
static void setNumIntegral(int nIntegral) {N_INTEGRAL = nIntegral;}
+ static const int getFilterCount() {return s_iFilterCount;}
+ static const char** getFilterNameArray() {return s_aszFilterName;}
+ static const char** getFilterTitleArray() {return s_aszFilterTitle;}
+ static int convertFilterNameToID (const char* const filterName);
+ static const char* convertFilterIDToName (const int idFilter);
+ static const char* convertFilterIDToTitle (const int idFilter);
+
+ static const int getFilterMethodCount() {return s_iFilterMethodCount;}
+ static const char** getFilterMethodNameArray() {return s_aszFilterMethodName;}
+ static const char** getFilterMethodTitleArray() {return s_aszFilterMethodTitle;}
+ static int convertFilterMethodNameToID (const char* const filterMethodName);
+ static const char* convertFilterMethodIDToName (const int idFilterMethod);
+ static const char* convertFilterMethodIDToTitle (const int idFilterMethod);
+
+ static const int getDomainCount() {return s_iDomainCount;}
+ static const char** getDomainNameArray() {return s_aszDomainName;}
+ static const char** getDomainTitleArray() {return s_aszDomainTitle;}
+ static int convertDomainNameToID (const char* const domainName);
+ static const char* convertDomainIDToName (const int idDomain);
+ static const char* convertDomainIDToTitle (const int idDomain);
+
+
+
private:
double m_bw;
int m_nFilterPoints;
string m_nameFilter;
string m_nameFilterMethod;
string m_nameDomain;
- FilterID m_idFilter;
- FilterMethodID m_idFilterMethod;
- DomainID m_idDomain;
+ int m_idFilter;
+ int m_idFilterMethod;
+ int m_idDomain;
double m_filterParam;
int m_traceLevel;
int m_zeropad;
int m_nOutputPoints;
int m_preinterpolationFactor;
+ static const char* s_aszFilterName[];
+ static const char* s_aszFilterTitle[];
+ static const int s_iFilterCount;
+ static const char* s_aszFilterMethodName[];
+ static const char* s_aszFilterMethodTitle[];
+ static const int s_iFilterMethodCount;
+ static const char* s_aszDomainName[];
+ static const char* s_aszDomainTitle[];
+ static const int s_iDomainCount;
+
static int N_INTEGRAL;
- static const bool haveAnalyticSpatial (const FilterID filterID);
- static const FilterID convertFilterNameToID (const char* filterName);
- static const char* convertFilterIDToName (const FilterID filterID);
- static const FilterMethodID convertFilterMethodNameToID (const char* filterMethodName);
- static const char* convertFilterMethodIDToName (const FilterMethodID filterMethodID);
- static const DomainID convertDomainNameToID (const char* domainName);
- static const char* convertDomainIDToName (const DomainID domainID);
+ static const bool haveAnalyticSpatial (const int filterID);
- void init (const FilterID filt_type, const FilterMethodID filterMethod, double bw, double signalIncrement, int n, double param, const DomainID domain, const int zeropad, const int preInterpScale);
+ void init (const int filt_type, const int filterMethod, double bw, double signalIncrement, int n, double param, const int domain, const int zeropad, const int preInterpScale);
double spatialResponseCalc (double x, double param) const;
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: phantom.h,v 1.9 2000/07/20 11:17:31 kevin Exp $
+** $Id: phantom.h,v 1.10 2000/07/22 15:45:33 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
#define PHANTOM_H
#include <slist>
+#include "ctsupport.h"
+#include "backprojectors.h"
+class ImageFile;
+
using namespace std;
typedef enum {
public:
PhantomElement (const char* const type, const double cx, const double cy, const double u, const double v, const double rot, const double atten);
- ~PhantomElement (void);
+ ~PhantomElement ();
bool isPointInside (double x, double y, const CoordType coord_type) const;
bool clipLineWorldCoords (double& x1, double& y1, double& x2, double& y2) const;
- const int nOutlinePoints(void) const {return m_nPoints;}
- double* rectLimits(void) {return m_rectLimits;}
+ const int nOutlinePoints() const {return m_nPoints;}
+ double* rectLimits() {return m_rectLimits;}
double* xOutline() {return m_xOutline;}
double* yOutline() {return m_yOutline;}
- const double atten(void) const {return m_atten;}
- const double diameter(void) const {return m_diameter;}
- const double xmin(void) const {return m_xmin;}
- const double xmax(void) const {return m_xmax;}
- const double ymin(void) const {return m_ymin;}
- const double ymax(void) const {return m_ymax;}
- const double rot(void) const {return m_rot;}
- const double cx(void) const {return m_cx;}
- const double cy(void) const {return m_cy;}
- const double u(void) const {return m_u;}
- const double v(void) const {return m_v;}
+ const double atten() const {return m_atten;}
+ const double diameter() const {return m_diameter;}
+ const double xmin() const {return m_xmin;}
+ const double xmax() const {return m_xmax;}
+ const double ymin() const {return m_ymin;}
+ const double ymax() const {return m_ymax;}
+ const double rot() const {return m_rot;}
+ const double cx() const {return m_cx;}
+ const double cy() const {return m_cy;}
+ const double u() const {return m_u;}
+ const double v() const {return m_v;}
private:
PhmElemType m_type; // pelem type (box, ellipse, etc)
static PhmElemType PhantomElement::convertNameToType (const char* const typeName);
- void makeTransformMatrices (void);
+ void makeTransformMatrices ();
- void makeVectorOutline (void);
+ void makeVectorOutline ();
void calcArcPoints (double x[], double y[], const int pts, const double xcent, const double ycent, const double r, const double start, const double stop);
P_FILTER // defined only by this type
} PhantomComposition;
-// Phantom class
+
+//////////////////////////////////////////////////////
+// Phantom Class Declaration
+//////////////////////////////////////////////////////
class Phantom
{
public:
- typedef enum {
- PHM_INVALID,
- PHM_HERMAN, /* Herman head phantom */
- PHM_BHERMAN, /* Bordered Herman head phantom */
- PHM_ROWLAND, /* Rowland head phantom */
- PHM_BROWLAND, /* Bordered Rowland head phantom */
- PHM_UNITPULSE /* Unit pulse phantom */
- } PhantomID;
-
- static const char PHM_HERMAN_STR[];
- static const char PHM_BHERMAN_STR[];
- static const char PHM_ROWLAND_STR[];
- static const char PHM_BROWLAND_STR[];
- static const char PHM_UNITPULSE_STR[];
-
- static const char PHM_HERMAN_TITLE_STR[];
- static const char PHM_BHERMAN_TITLE_STR[];
- static const char PHM_ROWLAND_TITLE_STR[];
- static const char PHM_BROWLAND_TITLE_STR[];
- static const char PHM_UNITPULSE_TITLE_STR[];
-
- Phantom (void);
+ static const int PHM_INVALID;
+ static const int PHM_HERMAN;
+ static const int PHM_BHERMAN;
+ static const int PHM_ROWLAND;
+ static const int PHM_BROWLAND;
+ static const int PHM_UNITPULSE;
+
+ Phantom ();
Phantom (const char* const phmName);
- ~Phantom (void);
+ ~Phantom ();
void setComposition (PhantomComposition composition)
{ m_composition = composition; }
- const PhantomComposition getComposition (void) const
+ const PhantomComposition getComposition () const
{ return m_composition; }
bool createFromPhantom (const char* const phmName);
- bool createFromPhantom (const PhantomID phmid);
+ bool createFromPhantom (const int phmid);
bool createFromFile (const char* const fname);
void convertToImagefile (ImageFile& im, const int in_nsample, const int trace) const;
- bool fail(void) const {return m_fail;}
- const string& failMessage(void) const {return m_failMessage;}
- const string& name(void) const {return m_name;}
- const PhantomID id(void) const {return m_id;}
+ bool fail() const {return m_fail;}
+ const string& failMessage() const {return m_failMessage;}
+ const string& name() const {return m_name;}
+ const int id() const {return m_id;}
#if HAVE_SGP
- void show (void) const;
- void draw (void) const;
+ void show () const;
+ void draw () const;
#endif
- void addStdHerman (void);
- void addStdHermanBordered (void);
- void addStdRowland (void);
- void addStdRowlandBordered (void);
-
- void print (void) const;
-
- const double maxAxisLength (void) const {return (((m_xmax - m_xmin) > (m_ymax - m_ymin)) ? (m_xmax - m_xmin) : (m_ymax - m_ymin));}
-
- const double diameter(void) const {return m_diameter;}
- const double xmin(void) const {return m_xmin;}
- const double xmax(void) const {return m_xmax;}
- const double ymin(void) const {return m_ymin;}
- const double ymax(void) const {return m_ymax;}
- slist<PhantomElement*>& listPElem(void) {return m_listPElem;}
- const slist<PhantomElement*>& listPElem(void) const {return m_listPElem;}
- const int nPElem(void) const {return m_nPElem;}
+ void addStdHerman ();
+ void addStdHermanBordered ();
+ void addStdRowland ();
+ void addStdRowlandBordered ();
+
+ void print () const;
+
+ const double maxAxisLength () const {return (((m_xmax - m_xmin) > (m_ymax - m_ymin)) ? (m_xmax - m_xmin) : (m_ymax - m_ymin));}
+
+ const double diameter() const {return m_diameter;}
+ const double xmin() const {return m_xmin;}
+ const double xmax() const {return m_xmax;}
+ const double ymin() const {return m_ymin;}
+ const double ymax() const {return m_ymax;}
+ slist<PhantomElement*>& listPElem() {return m_listPElem;}
+ const slist<PhantomElement*>& listPElem() const {return m_listPElem;}
+ const int nPElem() const {return m_nPElem;}
+
+ static const int getPhantomCount() {return s_iPhantomCount;}
+ static const char** getPhantomNameArray() {return s_aszPhantomName;}
+ static const char** getPhantomTitleArray() {return s_aszPhantomTitle;}
+ static int convertNameToPhantomID (const char* const phmName);
+ static const char* convertPhantomIDToName (const int phmID);
+ static const char* convertPhantomIDToTitle (const int phmID);
private:
PhantomComposition m_composition;
double m_diameter; // diameter of object
mutable slist<PhantomElement*> m_listPElem; // pelem lists
string m_name;
- PhantomID m_id;
+ int m_id;
bool m_fail;
string m_failMessage;
- // Standard phantomsa
- static PhantomID convertNameToPhantomID (const char* const phmName);
- static const char* convertPhantomIDToName (const PhantomID phmID);
+ static const char* s_aszPhantomName[];
+ static const char* s_aszPhantomTitle[];
+ static const int s_iPhantomCount;
- void init(void);
+ void init();
Phantom (const Phantom& rhs); // copy constructor
Phantom& operator= (const Phantom&); // assignment operator
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: scanner.h,v 1.7 2000/07/20 11:17:31 kevin Exp $
+** $Id: scanner.h,v 1.8 2000/07/22 15:45:33 kevin Exp $
**
**
** This program is free software; you can redistribute it and/or modify
DetectorArray (const DetectorArray& rhs); // copy constructor
};
+
class Scanner
{
public:
- typedef enum {
- GEOMETRY_INVALID,
- GEOMETRY_PARALLEL,
- GEOMETRY_EQUILINEAR,
- GEOMETRY_EQUIANGULAR,
- } GeometryID;
-
- static const char GEOMETRY_PARALLEL_STR[];
- static const char GEOMETRY_EQUILINEAR_STR[];
- static const char GEOMETRY_EQUIANGULAR_STR[];
-
- static const char GEOMETRY_PARALLEL_TITLE_STR[];
- static const char GEOMETRY_EQUILINEAR_TITLE_STR[];
- static const char GEOMETRY_EQUIANGULAR_TITLE_STR[];
+ static const int Scanner::GEOMETRY_INVALID;
+ static const int Scanner::GEOMETRY_PARALLEL;
+ static const int Scanner::GEOMETRY_EQUILINEAR;
+ static const int Scanner::GEOMETRY_EQUIANGULAR;
+
Scanner (const Phantom& phm, const char* const geometryName, int nDet, int nView, int nSample, const double rot_anglen);
~Scanner();
const double detInc(void) const {return m_detInc;}
const double radius(void) const {return m_radius;}
-
+ static const int getGeometryCount() {return s_iGeometryCount;}
+ static const char** getGeometryNameArray() {return s_aszGeometryName;}
+ static const char** getGeometryTitleArray() {return s_aszGeometryTitle;}
+ static int convertGeometryNameToID (const char* const geometryName);
+ static const char* convertGeometryIDToName (const int idGeometry);
+ static const char* convertGeometryIDToTitle (const int idGeometry);
+
private:
bool m_fail;
string m_failMessage;
- GeometryID m_idGeometry;
+ int m_idGeometry;
unsigned int m_nDet; /* Number of detectors in array */
unsigned int m_nView; /* Number of rotated views */
unsigned int m_nSample; /* Number of rays per detector */
double angle; /* Starting angle */
} m_initPos;
+ static const char* s_aszGeometryName[];
+ static const char* s_aszGeometryTitle[];
+ static const int s_iGeometryCount;
static const int N_EXTRA_DETECTORS=4; /* Number of extra detectors widths when calculating detlen */
- static GeometryID convertGeometryNameToID (const char* const geometryName);
-
void projectSingleView (const Phantom& phm, DetectorArray& darray, const double xd1, const double yd1, const double xd2, const double yd2, const double xs1, const double ys1, const double xs2, const double ys2);
double projectSingleLine (const Phantom& phm, const double x1, const double y1, const double x2, const double y2);
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: backprojectors.cpp,v 1.9 2000/07/20 11:17:31 kevin Exp $
+** $Id: backprojectors.cpp,v 1.10 2000/07/22 15:45:33 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
#include "ct.h"
-const char Backprojector::BPROJ_TRIG_STR[]= "trig";
-const char Backprojector::BPROJ_TABLE_STR[]= "table";
-const char Backprojector::BPROJ_DIFF_STR[]= "diff";
-const char Backprojector::BPROJ_DIFF2_STR[]= "diff2";
-const char Backprojector::BPROJ_IDIFF2_STR[]= "idiff2";
-const char Backprojector::BPROJ_IDIFF3_STR[]= "idiff3";
-
-const char Backprojector::BPROJ_TRIG_TITLE_STR[]= "Direc Trigometric";
-const char Backprojector::BPROJ_TABLE_TITLE_STR[]= "Trig Table";
-const char Backprojector::BPROJ_DIFF_TITLE_STR[]= "Diff";
-const char Backprojector::BPROJ_DIFF2_TITLE_STR[]= "Diff2";
-const char Backprojector::BPROJ_IDIFF2_TITLE_STR[]= "Integer Diff2";
-const char Backprojector::BPROJ_IDIFF3_TITLE_STR[]= "Integer Diff3";
-
-const char Backprojector::INTERP_NEAREST_STR[]= "nearest";
-const char Backprojector::INTERP_LINEAR_STR[]= "linear";
-const char Backprojector::INTERP_BSPLINE_STR[]= "bspline";
-const char Backprojector::INTERP_FREQ_PREINTERPOLATION_STR[]= "freq_preinterpolation";
-
-const char Backprojector::INTERP_NEAREST_TITLE_STR[]= "Nearest";
-const char Backprojector::INTERP_LINEAR_TITLE_STR[]= "Linear";
-const char Backprojector::INTERP_BSPLINE_TITLE_STR[]= "B-Spline";
-const char Backprojector::INTERP_FREQ_PREINTERPOLATION_TITLE_STR[]= "Frequency Preinterpolation";
+const int Backprojector::BPROJ_INVALID = -1;
+const int Backprojector::BPROJ_TRIG = 0;
+const int Backprojector::BPROJ_TABLE = 1;
+const int Backprojector::BPROJ_DIFF = 2;
+const int Backprojector::BPROJ_DIFF2 = 3;
+const int Backprojector::BPROJ_IDIFF2 = 4;
+const int Backprojector::BPROJ_IDIFF3 = 5;
+
+const char* Backprojector::s_aszBackprojectName[] =
+{
+ {"trig"},
+ {"table"},
+ {"diff"},
+ {"diff2"},
+ {"idiff2"},
+ {"idiff3"},
+};
+
+const char* Backprojector::s_aszBackprojectTitle[] =
+{
+ {"Direct Trigometric"},
+ {"Trigometric Table"},
+ {"Difference Iteration"},
+ {"Difference Iteration Optimized"},
+ {"Integer Difference Iteration Optimized"},
+ {"Integer Difference Iteration Highly-Optimized"},
+};
+
+const int Backprojector::s_iBackprojectCount = sizeof(s_aszBackprojectName) / sizeof(const char*);
+
+const int Backprojector::INTERP_INVALID = -1;
+const int Backprojector::INTERP_NEAREST = 0;
+const int Backprojector::INTERP_LINEAR = 1;
+const int Backprojector::INTERP_FREQ_PREINTERPOLATION = 2;
+#if HAVE_BSPLINE_INTERP
+const int Backprojector::INTERP_BSPLINE = 3;
+const int Backprojector::INTERP_1BSPLINE = 4;
+const int Backprojector::INTERP_2BSPLINE = 5;
+const int Backprojector::INTERP_3BSPLINE = 6;
+#endif
+
+const char* Backprojector::s_aszInterpName[] =
+{
+ {"nearest"},
+ {"linear"},
+ {"freq_preinterpolationj"},
+#if HAVE_BSPLINE_INTERP
+ {"bspline"},
+ {"1bspline"},
+ {"2bspline"},
+ {"3bspline"},
+#endif
+};
+
+const char* Backprojector::s_aszInterpTitle[] =
+{
+ {"Nearest"},
+ {"Linear"},
+ {"Frequency Preinterpolationj"},
+#if HAVE_BSPLINE_INTERP
+ {"B-Spline"},
+ {"B-Spline 1st Order"},
+ {"B-Spline 2nd Order"},
+ {"B-Spline 3rd Order"},
+#endif
+};
+
+const int Backprojector::s_iInterpCount = sizeof(s_aszInterpName) / sizeof(const char*);
+
Backprojector::Backprojector (const Projections& proj, ImageFile& im, const char* const backprojName, const char* const interpName, const int interpFactor)
m_pBackprojectImplem->BackprojectView (viewData, viewAngle);
}
-Backprojector::~Backprojector (void)
+Backprojector::~Backprojector ()
{
delete m_pBackprojectImplem;
}
m_failMessage = "Invalid backprojection name ";
m_failMessage += backprojName;
}
- m_idInterpolation = convertInterpolationNameToID (interpName);
+ m_idInterpolation = convertInterpNameToID (interpName);
if (m_idInterpolation == INTERP_INVALID) {
m_fail = true;
m_failMessage = "Invalid interpolation name ";
}
-const Backprojector::BackprojectID
+int
Backprojector::convertBackprojectNameToID (const char* const backprojName)
{
- BackprojectID backprojID = BPROJ_INVALID;
-
- if (strcasecmp (backprojName, BPROJ_TRIG_STR) == 0)
- backprojID = BPROJ_TRIG;
- else if (strcasecmp (backprojName, BPROJ_TABLE_STR) == 0)
- backprojID = BPROJ_TABLE;
- else if (strcasecmp (backprojName, BPROJ_DIFF_STR) == 0)
- backprojID = BPROJ_DIFF;
- else if (strcasecmp (backprojName, BPROJ_DIFF2_STR) == 0)
- backprojID = BPROJ_DIFF2;
- else if (strcasecmp (backprojName, BPROJ_IDIFF2_STR) == 0)
- backprojID = BPROJ_IDIFF2;
- else if (strcasecmp (backprojName, BPROJ_IDIFF3_STR) == 0)
- backprojID = BPROJ_IDIFF3;
+ int backprojID = BPROJ_INVALID;
+
+ for (int i = 0; i < s_iBackprojectCount; i++)
+ if (strcasecmp (backprojName, s_aszBackprojectName[i]) == 0) {
+ backprojID = i;
+ break;
+ }
return (backprojID);
}
const char*
-Backprojector::convertBackprojectIDToName (const BackprojectID bprojID)
+Backprojector::convertBackprojectIDToName (int bprojID)
{
- const char *bprojName = "";
-
- if (bprojID == BPROJ_TRIG)
- bprojName = BPROJ_TRIG_STR;
- else if (bprojID == BPROJ_TABLE)
- bprojName = BPROJ_TABLE_STR;
- else if (bprojID == BPROJ_DIFF)
- bprojName = BPROJ_DIFF_STR;
- else if (bprojID == BPROJ_DIFF2)
- bprojName = BPROJ_DIFF2_STR;
- else if (bprojID == BPROJ_IDIFF2)
- bprojName = BPROJ_IDIFF2_STR;
- else if (bprojID == BPROJ_IDIFF3)
- bprojName = BPROJ_IDIFF3_STR;
+ static const char *bprojName = "";
+
+ if (bprojID >= 0 && bprojID < s_iBackprojectCount)
+ return (s_aszBackprojectName[bprojID]);
return (bprojName);
}
+const char*
+Backprojector::convertBackprojectIDToTitle (const int bprojID)
+{
+ static const char *bprojTitle = "";
+
+ if (bprojID >= 0 && bprojID < s_iBackprojectCount)
+ return (s_aszBackprojectTitle[bprojID]);
+
+ return (bprojTitle);
+}
-const Backprojector::InterpolationID
-Backprojector::convertInterpolationNameToID (const char* const interpName)
+int
+Backprojector::convertInterpNameToID (const char* const interpName)
{
- InterpolationID interpID = INTERP_INVALID;
-
- if (strcasecmp (interpName, INTERP_NEAREST_STR) == 0)
- interpID = INTERP_NEAREST;
- else if (strcasecmp (interpName, INTERP_LINEAR_STR) == 0)
- interpID = INTERP_LINEAR;
- else if (strcasecmp (interpName, INTERP_FREQ_PREINTERPOLATION_STR) == 0)
- interpID = INTERP_FREQ_PREINTERPOLATION;
-#if HAVE_BSPLINE_INTERP
- else if (strcasecmp (interpName, INTERP_BSPLINE_STR) == 0)
- interpID = INTERP_BSPLINE;
-#endif
+ int interpID = INTERP_INVALID;
+
+ for (int i = 0; i < s_iInterpCount; i++)
+ if (strcasecmp (interpName, s_aszInterpName[i]) == 0) {
+ interpID = i;
+ break;
+ }
return (interpID);
}
+const char*
+Backprojector::convertInterpIDToName (const int interpID)
+{
+ static const char *interpName = "";
-/* NAME
- * name_of_interp Return name of interpolation method
- *
- * SYNOPSIS
- * name = name_of_interp (interp_type)
- * char *name Name of interpolation method
- * int interp_type Method of interpolation
- *
- * NOTES
- * Returns NULL if interp_type is invalid
- */
+ if (interpID >= 0 && interpID < s_iInterpCount)
+ return (s_aszInterpName[interpID]);
+
+ return (interpName);
+}
const char*
-Backprojector::convertInterpolationIDToName (const InterpolationID interpID)
+Backprojector::convertInterpIDToTitle (const int interpID)
{
- if (interpID == INTERP_NEAREST)
- return (INTERP_NEAREST_STR);
- else if (interpID == INTERP_LINEAR)
- return (INTERP_LINEAR_STR);
- else if (interpID == INTERP_FREQ_PREINTERPOLATION)
- return (INTERP_FREQ_PREINTERPOLATION_STR);
-#if HAVE_BSPLINE_INTERP
- else if (interpID == INTERP_BSPLINE)
- return (INTERP_BSPLINE_STR);
-#endif
- else
- return ("");
+ static const char *interpTitle = "";
+
+ if (interpID >= 0 && interpID < s_iInterpCount)
+ return (s_aszInterpTitle[interpID]);
+
+ return (interpTitle);
}
+
// CLASS IDENTICATION
// Backproject
//
// PURPOSE
// Pure virtual base class for all backprojectors.
-Backproject::Backproject (const Projections& proj, ImageFile& im, const Backprojector::InterpolationID interpType, const int interpFactor)
+Backproject::Backproject (const Projections& proj, ImageFile& im, const int interpType, const int interpFactor)
: proj(proj), im(im), interpType(interpType), m_interpFactor(interpFactor)
{
detInc = proj.detInc();
yInc = (yMax - yMin) / ny;
}
-Backproject::~Backproject (void)
+Backproject::~Backproject ()
{}
void
-Backproject::ScaleImageByRotIncrement (void)
+Backproject::ScaleImageByRotIncrement ()
{
for (int ix = 0; ix < nx; ix++)
for (int iy = 0; iy < ny; iy++)
// PURPOSE
// Precalculates trigometric function value for each point in image for backprojection.
-BackprojectTable::BackprojectTable (const Projections& proj, ImageFile& im, Backprojector::InterpolationID interpType, const int interpFactor)
+BackprojectTable::BackprojectTable (const Projections& proj, ImageFile& im, int interpType, const int interpFactor)
: Backproject::Backproject (proj, im, interpType, interpFactor)
{
arrayR.initSetSize (nx, ny);
}
}
-BackprojectTable::~BackprojectTable (void)
+BackprojectTable::~BackprojectTable ()
{
ScaleImageByRotIncrement();
}
// Backprojects by precalculating the change in L position for each x & y step in the image.
// Iterates in x & y direction by adding difference in L position
-BackprojectDiff::BackprojectDiff (const Projections& proj, ImageFile& im, Backprojector::InterpolationID interpType, const int interpFactor)
+BackprojectDiff::BackprojectDiff (const Projections& proj, ImageFile& im, int interpType, const int interpFactor)
: Backproject::Backproject (proj, im, interpType, interpFactor)
{
// calculate center of first pixel v[0][0]
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: filter.cpp,v 1.19 2000/07/20 11:17:31 kevin Exp $
+** $Id: filter.cpp,v 1.20 2000/07/22 15:45:33 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
#include "ct.h"
-
int SignalFilter::N_INTEGRAL=500; //static member
-// Filters
-const char SignalFilter::FILTER_ABS_BANDLIMIT_STR[] = "abs_bandlimit";
-const char SignalFilter::FILTER_ABS_SINC_STR[] = "abs_sinc";
-const char SignalFilter::FILTER_ABS_COS_STR[] = "abs_cos";
-const char SignalFilter::FILTER_ABS_HAMMING_STR[] = "abs_hamming";
-const char SignalFilter::FILTER_SHEPP_STR[] = "shepp";
-const char SignalFilter::FILTER_BANDLIMIT_STR[] = "bandlimit";
-const char SignalFilter::FILTER_SINC_STR[] = "sinc";
-const char SignalFilter::FILTER_COS_STR[] = "cos";
-const char SignalFilter::FILTER_HAMMING_STR[] = "hamming";
-const char SignalFilter::FILTER_TRIANGLE_STR[] = "triangle";
-
-const char SignalFilter::FILTER_ABS_BANDLIMIT_TITLE_STR[] = "Abs(w) * Bandlimit";
-const char SignalFilter::FILTER_ABS_SINC_TITLE_STR[] = "Abs(w) * Sinc";
-const char SignalFilter::FILTER_ABS_COS_TITLE_STR[] = "Abs(w) * Cos";
-const char SignalFilter::FILTER_ABS_HAMMING_TITLE_STR[] = "Abs(w) * Hamming";
-const char SignalFilter::FILTER_SHEPP_TITLE_STR[] = "Shepp";
-const char SignalFilter::FILTER_BANDLIMIT_TITLE_STR[] = "Bandlimit";
-const char SignalFilter::FILTER_SINC_TITLE_STR[] = "Sinc";
-const char SignalFilter::FILTER_COS_TITLE_STR[] = "Cos";
-const char SignalFilter::FILTER_HAMMING_TITLE_STR[] = "Hamming";
-const char SignalFilter::FILTER_TRIANGLE_TITLE_STR[] = "Triangle";
-
-// Filter Methods
-const char SignalFilter::FILTER_METHOD_CONVOLUTION_STR[] = "convolution";
-const char SignalFilter::FILTER_METHOD_FOURIER_STR[] = "fourier";
-const char SignalFilter::FILTER_METHOD_FOURIER_TABLE_STR[] = "fourier_table";
-const char SignalFilter::FILTER_METHOD_FFT_STR[] = "fft";
+const int SignalFilter::FILTER_INVALID = -1 ;
+const int SignalFilter::FILTER_BANDLIMIT = 0;
+const int SignalFilter::FILTER_SINC = 1;
+const int SignalFilter::FILTER_G_HAMMING = 2;
+const int SignalFilter::FILTER_COSINE = 3;
+const int SignalFilter::FILTER_TRIANGLE = 4;
+const int SignalFilter::FILTER_ABS_BANDLIMIT = 5; // filter times |x = |
+const int SignalFilter::FILTER_ABS_SINC = 6;
+const int SignalFilter::FILTER_ABS_G_HAMMING = 7;
+const int SignalFilter::FILTER_ABS_COSINE = 8;
+const int SignalFilter::FILTER_SHEPP = 9;
+
+const char* SignalFilter::s_aszFilterName[] = {
+ {"bandlimit"},
+ {"sinc"},
+ {"hamming"},
+ {"cosine"},
+ {"triangle"},
+ {"abs_bandlimit"},
+ {"abs_sinc"},
+ {"abs_hamming"},
+ {"abs_cosine"},
+ {"shepp"},
+};
+
+const char* SignalFilter::s_aszFilterTitle[] = {
+ {"Bandlimit"},
+ {"Sinc"},
+ {"Hamming"},
+ {"Cosine"},
+ {"Triangle"},
+ {"Abs(w) * Bandlimit"},
+ {"Abs(w) * Sinc"},
+ {"Abs(w) * Hamming"},
+ {"Abs(w) * Cosine"},
+ {"Shepp"},
+};
+
+const int SignalFilter::s_iFilterCount = sizeof(s_aszFilterName) / sizeof(const char*);
+
+const int SignalFilter::FILTER_METHOD_INVALID = -1;
+const int SignalFilter::FILTER_METHOD_CONVOLUTION = 0;
+const int SignalFilter::FILTER_METHOD_FOURIER = 1;
+const int SignalFilter::FILTER_METHOD_FOURIER_TABLE = 2;
+const int SignalFilter::FILTER_METHOD_FFT = 3;
+#if HAVE_FFTW
+const int SignalFilter::FILTER_METHOD_FFTW = 4;
+const int SignalFilter::FILTER_METHOD_RFFTW =5 ;
+#endif
+
+const char* SignalFilter::s_aszFilterMethodName[] = {
+ {"convolution"},
+ {"fourier"},
+ {"fouier_table"},
+ {"fft"},
#if HAVE_FFTW
-const char SignalFilter::FILTER_METHOD_FFTW_STR[] = "fftw";
-const char SignalFilter::FILTER_METHOD_RFFTW_STR[] = "rfftw";
+ {"fftw"},
+ {"rfftw"},
#endif
+};
-const char SignalFilter::FILTER_METHOD_CONVOLUTION_TITLE_STR[] = "Convolution";
-const char SignalFilter::FILTER_METHOD_FOURIER_TITLE_STR[] = "Direct Fourier";
-const char SignalFilter::FILTER_METHOD_FOURIER_TABLE_TITLE_STR[] = "Fourier Trig Table";
-const char SignalFilter::FILTER_METHOD_FFT_TITLE_STR[] = "FFT";
+const char* SignalFilter::s_aszFilterMethodTitle[] = {
+ {"Convolution"},
+ {"Direct Fourier"},
+ {"Fouier Trigometric Table Lookout"},
+ {"FFT"},
#if HAVE_FFTW
-const char SignalFilter::FILTER_METHOD_FFTW_TITLESTR[] = "FFTW";
-const char SignalFilter::FILTER_METHOD_RFFTW_TITLE_STR[] = "Real FFTW";
+ {"FFTW"},
+ {"Real/Half-Complex FFTW"},
#endif
+};
-// Domains
-const char SignalFilter::DOMAIN_FREQUENCY_STR[] = "frequency";
-const char SignalFilter::DOMAIN_SPATIAL_STR[] = "spatial";
+const int SignalFilter::s_iFilterMethodCount = sizeof(s_aszFilterMethodName) / sizeof(const char*);
-const char SignalFilter::DOMAIN_FREQUENCY_TITLE_STR[] = "Frequency";
-const char SignalFilter::DOMAIN_SPATIAL_TITLE_STR[] = "Spatial";
+
+const int SignalFilter::DOMAIN_INVALID = -1;
+const int SignalFilter::DOMAIN_FREQUENCY = 0;
+const int SignalFilter::DOMAIN_SPATIAL = 1;
+
+const char* SignalFilter::s_aszDomainName[] = {
+ {"frequency"},
+ {"spatial"},
+};
+
+const char* SignalFilter::s_aszDomainTitle[] = {
+ {"Frequency"},
+ {"Spatial"},
+};
+
+const int SignalFilter::s_iDomainCount = sizeof(s_aszDomainName) / sizeof(const char*);
/* NAME
init (m_idFilter, m_idFilterMethod, bw, signalIncrement, nSignalPoints, param, m_idDomain, zeropad, preinterpolationFactor);
}
-SignalFilter::SignalFilter (const FilterID filterID, const FilterMethodID filterMethodID, double bw, double signalIncrement, int nSignalPoints, double param, const DomainID domainID, int zeropad = 0, int preinterpolationFactor = 1)
+SignalFilter::SignalFilter (const int filterID, const int filterMethodID, double bw, double signalIncrement, int nSignalPoints, double param, const int domainID, int zeropad = 0, int preinterpolationFactor = 1)
{
init (filterID, filterMethodID, bw, signalIncrement, nSignalPoints, param, domainID, zeropad, preinterpolationFactor);
}
}
void
-SignalFilter::init (const FilterID filterID, const FilterMethodID filterMethodID, double bw, double signalIncrement, int nSignalPoints, double filterParam, const DomainID domainID, int zeropad, int preinterpolationFactor)
+SignalFilter::init (const int filterID, const int filterMethodID, double bw, double signalIncrement, int nSignalPoints, double filterParam, const int domainID, int zeropad, int preinterpolationFactor)
{
m_bw = bw;
m_idFilter = filterID;
}
-const SignalFilter::FilterID
+int
SignalFilter::convertFilterNameToID (const char *filterName)
{
- FilterID filterID = FILTER_INVALID;
-
- if (strcasecmp (filterName, FILTER_BANDLIMIT_STR) == 0)
- filterID = FILTER_BANDLIMIT;
- else if (strcasecmp (filterName, FILTER_HAMMING_STR) == 0)
- filterID = FILTER_G_HAMMING;
- else if (strcasecmp (filterName, FILTER_SINC_STR) == 0)
- filterID = FILTER_SINC;
- else if (strcasecmp (filterName, FILTER_COS_STR) == 0)
- filterID = FILTER_COSINE;
- else if (strcasecmp (filterName, FILTER_TRIANGLE_STR) == 0)
- filterID = FILTER_TRIANGLE;
- else if (strcasecmp (filterName, FILTER_ABS_BANDLIMIT_STR) == 0)
- filterID = FILTER_ABS_BANDLIMIT;
- else if (strcasecmp (filterName, FILTER_ABS_HAMMING_STR) == 0)
- filterID = FILTER_ABS_G_HAMMING;
- else if (strcasecmp (filterName, FILTER_ABS_SINC_STR) == 0)
- filterID = FILTER_ABS_SINC;
- else if (strcasecmp (filterName, FILTER_ABS_COS_STR) == 0)
- filterID = FILTER_ABS_COSINE;
- else if (strcasecmp (filterName, FILTER_SHEPP_STR) == 0)
- filterID = FILTER_SHEPP;
+ int filterID = FILTER_INVALID;
+
+ for (int i = 0; i < s_iFilterCount; i++)
+ if (strcasecmp (filterName, s_aszFilterName[i]) == 0) {
+ filterID = i;
+ break;
+ }
return (filterID);
}
const char *
-SignalFilter::convertFilterIDToName (const FilterID filterID)
+SignalFilter::convertFilterIDToName (const int filterID)
{
- const char *name = "";
-
- if (filterID == FILTER_SHEPP)
- name = FILTER_SHEPP_STR;
- else if (filterID == FILTER_ABS_COSINE)
- name = FILTER_ABS_COS_STR;
- else if (filterID == FILTER_ABS_SINC)
- name = FILTER_ABS_SINC_STR;
- else if (filterID == FILTER_ABS_G_HAMMING)
- name = FILTER_ABS_HAMMING_STR;
- else if (filterID == FILTER_ABS_BANDLIMIT)
- name = FILTER_ABS_BANDLIMIT_STR;
- else if (filterID == FILTER_COSINE)
- name = FILTER_COS_STR;
- else if (filterID == FILTER_SINC)
- name = FILTER_SINC_STR;
- else if (filterID == FILTER_G_HAMMING)
- name = FILTER_HAMMING_STR;
- else if (filterID == FILTER_BANDLIMIT)
- name = FILTER_BANDLIMIT_STR;
- else if (filterID == FILTER_TRIANGLE)
- name = FILTER_TRIANGLE_STR;
-
+ static const char *name = "";
+
+ if (filterID >= 0 && filterID < s_iFilterCount)
+ return (s_aszFilterName [filterID]);
+
return (name);
}
+
+const char *
+SignalFilter::convertFilterIDToTitle (const int filterID)
+{
+ static const char *title = "";
+
+ if (filterID >= 0 && filterID < s_iFilterCount)
+ return (s_aszFilterTitle [filterID]);
+
+ return (title);
+}
-const SignalFilter::FilterMethodID
+int
SignalFilter::convertFilterMethodNameToID (const char* const filterMethodName)
{
- FilterMethodID fmID = FILTER_METHOD_INVALID;
-
- if (strcasecmp (filterMethodName, FILTER_METHOD_CONVOLUTION_STR) == 0)
- fmID = FILTER_METHOD_CONVOLUTION;
- else if (strcasecmp (filterMethodName, FILTER_METHOD_FOURIER_STR) == 0)
- fmID = FILTER_METHOD_FOURIER;
- else if (strcasecmp (filterMethodName, FILTER_METHOD_FOURIER_TABLE_STR) == 0)
- fmID = FILTER_METHOD_FOURIER_TABLE;
- else if (strcasecmp (filterMethodName, FILTER_METHOD_FFT_STR) == 0)
- fmID = FILTER_METHOD_FFT;
-#if HAVE_FFTW
- else if (strcasecmp (filterMethodName, FILTER_METHOD_FFTW_STR) == 0)
- fmID = FILTER_METHOD_FFTW;
- else if (strcasecmp (filterMethodName, FILTER_METHOD_RFFTW_STR) == 0)
- fmID = FILTER_METHOD_RFFTW;
-#endif
+ int fmID = FILTER_METHOD_INVALID;
+
+ for (int i = 0; i < s_iFilterMethodCount; i++)
+ if (strcasecmp (filterMethodName, s_aszFilterMethodName[i]) == 0) {
+ fmID = i;
+ break;
+ }
return (fmID);
}
const char *
-SignalFilter::convertFilterMethodIDToName (const FilterMethodID fmID)
+SignalFilter::convertFilterMethodIDToName (const int fmID)
{
- const char *name = "";
-
- if (fmID == FILTER_METHOD_CONVOLUTION)
- return (FILTER_METHOD_CONVOLUTION_STR);
- else if (fmID == FILTER_METHOD_FOURIER)
- return (FILTER_METHOD_FOURIER_STR);
- else if (fmID == FILTER_METHOD_FOURIER_TABLE)
- return (FILTER_METHOD_FOURIER_TABLE_STR);
- else if (fmID == FILTER_METHOD_FFT)
- return (FILTER_METHOD_FFT_STR);
-#if HAVE_FFTW
- else if (fmID == FILTER_METHOD_FFTW)
- return (FILTER_METHOD_FFTW_STR);
- else if (fmID == FILTER_METHOD_RFFTW)
- return (FILTER_METHOD_RFFTW_STR);
-#endif
+ static const char *name = "";
+
+ if (fmID >= 0 && fmID < s_iFilterMethodCount)
+ return (s_aszFilterName [fmID]);
return (name);
}
-const SignalFilter::DomainID
+const char *
+SignalFilter::convertFilterMethodIDToTitle (const int fmID)
+{
+ static const char *title = "";
+
+ if (fmID >= 0 && fmID < s_iFilterMethodCount)
+ return (s_aszFilterTitle [fmID]);
+
+ return (title);
+}
+
+int
SignalFilter::convertDomainNameToID (const char* const domainName)
{
- DomainID dID = DOMAIN_INVALID;
+ int dID = DOMAIN_INVALID;
- if (strcasecmp (domainName, DOMAIN_SPATIAL_STR) == 0)
- dID = DOMAIN_SPATIAL;
- else if (strcasecmp (domainName, DOMAIN_FREQUENCY_STR) == 0)
- dID = DOMAIN_FREQUENCY;
+ for (int i = 0; i < s_iDomainCount; i++)
+ if (strcasecmp (domainName, s_aszDomainName[i]) == 0) {
+ dID = i;
+ break;
+ }
return (dID);
}
const char *
-SignalFilter::convertDomainIDToName (const DomainID domain)
+SignalFilter::convertDomainIDToName (const int domainID)
{
- const char *name = "";
+ static const char *name = "";
- if (domain == DOMAIN_SPATIAL)
- return (DOMAIN_SPATIAL_STR);
- else if (domain == DOMAIN_FREQUENCY)
- return (DOMAIN_FREQUENCY_STR);
+ if (domainID >= 0 && domainID < s_iDomainCount)
+ return (s_aszDomainName [domainID]);
return (name);
}
+const char *
+SignalFilter::convertDomainIDToTitle (const int domainID)
+{
+ static const char *title = "";
+
+ if (domainID >= 0 && domainID < s_iDomainCount)
+ return (s_aszDomainTitle [domainID]);
+
+ return (title);
+}
+
void
SignalFilter::filterSignal (const float input[], double output[]) const
{
double
-SignalFilter::spatialResponse (FilterID filterID, double bw, double x, double param)
+SignalFilter::spatialResponse (int filterID, double bw, double x, double param)
{
if (haveAnalyticSpatial(filterID))
return spatialResponseAnalytic (filterID, bw, x, param);
}
double
-SignalFilter::spatialResponseCalc (FilterID filterID, double bw, double x, double param, int n)
+SignalFilter::spatialResponseCalc (int filterID, double bw, double x, double param, int n)
{
double zmin, zmax;
double
-SignalFilter::frequencyResponse (FilterID filterID, double bw, double u, double param)
+SignalFilter::frequencyResponse (int filterID, double bw, double u, double param)
{
double q;
double au = fabs (u);
}
const bool
-SignalFilter::haveAnalyticSpatial (FilterID filterID)
+SignalFilter::haveAnalyticSpatial (int filterID)
{
bool haveAnalytic = false;
}
double
-SignalFilter::spatialResponseAnalytic (FilterID filterID, double bw, double x, double param)
+SignalFilter::spatialResponseAnalytic (int filterID, double bw, double x, double param)
{
double q, temp;
double u = TWOPI * x;
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: phantom.cpp,v 1.9 2000/07/20 11:17:31 kevin Exp $
+** $Id: phantom.cpp,v 1.10 2000/07/22 15:45:33 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
#include "ct.h"
-const char Phantom::PHM_HERMAN_STR[]= "herman";
-const char Phantom::PHM_BHERMAN_STR[]= "bherman";
-const char Phantom::PHM_ROWLAND_STR[]= "rowland";
-const char Phantom::PHM_BROWLAND_STR[]= "browland";
-const char Phantom::PHM_UNITPULSE_STR[]= "unitpulse";
+const int Phantom::PHM_INVALID = -1;
+const int Phantom::PHM_HERMAN = 0;
+const int Phantom::PHM_BHERMAN = 1;
+const int Phantom::PHM_ROWLAND = 2;
+const int Phantom::PHM_BROWLAND = 3;
+const int Phantom::PHM_UNITPULSE = 4;
-const char Phantom::PHM_HERMAN_TITLE_STR[]= "Herman Head";
-const char Phantom::PHM_BHERMAN_TITLE_STR[]= "Herman Head Bordered";
-const char Phantom::PHM_ROWLAND_TITLE_STR[]= "Rowland Head";
-const char Phantom::PHM_BROWLAND_TITLE_STR[]= "Rowland Head Bordered";
-const char Phantom::PHM_UNITPULSE_TITLE_STR[]= "Unit Pulse";
+const char* Phantom::s_aszPhantomName[] =
+{
+ {"herman"},
+ {"bherman"},
+ {"rowland"},
+ {"browland"},
+ {"unitpulse"},
+};
+
+const char* Phantom::s_aszPhantomTitle[] =
+{
+ {"Herman Head"},
+ {"Herman Head Bordered"},
+ {"Rowland Head"},
+ {"Rowland Head Bordered"},
+ {"Unit Pulse"},
+};
+const int Phantom::s_iPhantomCount = sizeof(s_aszPhantomName) / sizeof(const char*);
// CLASS IDENTIFICATION
-// Phanton
+// Phantom
//
-Phantom::Phantom (void)
+Phantom::Phantom ()
{
init ();
}
}
void
-Phantom::init (void)
+Phantom::init ()
{
m_nPElem = 0;
m_xmin = 1E30;
m_id = PHM_INVALID;
}
-Phantom::~Phantom (void)
+Phantom::~Phantom ()
{
for (PElemIterator i = m_listPElem.begin(); i != m_listPElem.end(); i++) {
delete *i;
const char*
-Phantom::convertPhantomIDToName (const PhantomID phmID)
+Phantom::convertPhantomIDToName (int phmID)
{
- const char *name = "";
+ static const char *name = "";
- if (phmID == PHM_HERMAN)
- name = PHM_HERMAN_STR;
- else if (phmID == PHM_BHERMAN)
- name = PHM_BHERMAN_STR;
- else if (phmID == PHM_ROWLAND)
- name = PHM_ROWLAND_STR;
- else if (phmID == PHM_BROWLAND)
- name = PHM_BROWLAND_STR;
- else if (phmID == PHM_UNITPULSE)
- name = PHM_UNITPULSE_STR;
+ if (phmID >= 0 && phmID < s_iPhantomCount)
+ return (s_aszPhantomName[phmID]);
return (name);
}
+
+const char*
+Phantom::convertPhantomIDToTitle (int phmID)
+{
+ static const char *title = "";
+
+ if (phmID >= 0 && phmID < s_iPhantomCount)
+ return (s_aszPhantomName[phmID]);
+
+ return (title);
+}
-Phantom::PhantomID
+int
Phantom::convertNameToPhantomID (const char* const phmName)
{
- PhantomID id = PHM_INVALID;
+ int id = PHM_INVALID;
- if (strcasecmp (phmName, PHM_HERMAN_STR) == 0)
- id = PHM_HERMAN;
- else if (strcasecmp (phmName, PHM_BHERMAN_STR) == 0)
- id = PHM_BHERMAN;
- else if (strcasecmp (phmName, PHM_ROWLAND_STR) == 0)
- id = PHM_ROWLAND;
- else if (strcasecmp (phmName, PHM_BROWLAND_STR) == 0)
- id = PHM_BROWLAND;
- else if (strcasecmp (phmName, PHM_UNITPULSE_STR) == 0)
- id = PHM_UNITPULSE;
+ for (int i = 0; i < s_iPhantomCount; i++)
+ if (strcasecmp (phmName, s_aszPhantomName[i]) == 0) {
+ id = i;
+ break;
+ }
return (id);
}
bool
Phantom::createFromPhantom (const char* const phmName)
{
- PhantomID phmid = convertNameToPhantomID (phmName);
+ int phmid = convertNameToPhantomID (phmName);
if (phmid == PHM_INVALID) {
m_fail = true;
m_failMessage = "Invalid phantom name ";
}
bool
-Phantom::createFromPhantom (const PhantomID phmid)
+Phantom::createFromPhantom (const int phmid)
{
switch (phmid)
{
*/
void
-Phantom::print (void) const
+Phantom::print () const
{
printf("PRINTING Phantom\n\n");
printf("number of pelems in Phantom = %d\n", m_nPElem);
#ifdef HAVE_SGP
void
-Phantom::show (void) const
+Phantom::show () const
{
double wsize = m_xmax - m_xmin;
double xmin = m_xmin;
#ifdef HAVE_SGP
void
-Phantom::draw (void) const
+Phantom::draw () const
{
for (PElemIterator i = m_listPElem.begin(); i != m_listPElem.end(); i++)
sgp2_polyline_abs ((*i)->xOutline(), (*i)->yOutline(), (*i)->nOutlinePoints());
*/
void
-Phantom::addStdRowland (void)
+Phantom::addStdRowland ()
{
addPElem ("ellipse", 0.0000, 0.0000, 0.6900, 0.9200, 0.0, 1.00);
addPElem ("ellipse", 0.0000, -0.0184, 0.6624, 0.8740, 0.0, -0.98);
}
void
-Phantom::addStdRowlandBordered (void)
+Phantom::addStdRowlandBordered ()
{
addStdRowland ();
addPElem ("ellipse", 0.000, 0.0000, 0.7500, 1.000, 0.0, 0.00);
*/
void
-Phantom::addStdHerman (void)
+Phantom::addStdHerman ()
{
addPElem ("ellipse", 0.000, 1.50, 0.375, 0.3000, 90.00, -0.003);
addPElem ("ellipse", 0.675, -0.75, 0.225, 0.1500, 140.00, 0.010);
}
void
-Phantom::addStdHermanBordered (void)
+Phantom::addStdHermanBordered ()
{
addStdHerman();
addPElem ("ellipse", 0.000, 0.000, 8.650, 8.650, 0.00, 0.000);
}
-PhantomElement::~PhantomElement (void)
+PhantomElement::~PhantomElement ()
{
delete m_xOutline;
delete m_yOutline;
}
void
-PhantomElement::makeTransformMatrices (void)
+PhantomElement::makeTransformMatrices ()
{
GRFMTX_2D temp;
*/
void
-PhantomElement::makeVectorOutline (void)
+PhantomElement::makeVectorOutline ()
{
double radius, theta, start, stop;
double xfact, yfact;
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: scanner.cpp,v 1.4 2000/07/20 11:17:31 kevin Exp $
+** $Id: scanner.cpp,v 1.5 2000/07/22 15:45:33 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
#include "ct.h"
-const char Scanner::GEOMETRY_PARALLEL_STR[] = "parallel";
-const char Scanner::GEOMETRY_EQUILINEAR_STR[] = "equilinear";
-const char Scanner::GEOMETRY_EQUIANGULAR_STR[] = "equiangular";
-const char Scanner::GEOMETRY_PARALLEL_TITLE_STR[] = "Parallel";
-const char Scanner::GEOMETRY_EQUILINEAR_TITLE_STR[] = "Equilinear";
-const char Scanner::GEOMETRY_EQUIANGULAR_TITLE_STR[] = "Equiangular";
+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 char* Scanner::s_aszGeometryName[] =
+{
+ {"parallel"},
+ {"equilinear"},
+ {"equiangular"},
+};
+
+const char* Scanner::s_aszGeometryTitle[] =
+{
+ {"Parallel"},
+ {"Equilinear"},
+ {"Equiangular"},
+};
+
+const int Scanner::s_iGeometryCount = sizeof(s_aszGeometryName) / sizeof(const char*);
+
// NAME
// DetectorArray Construct a DetectorArray
}
-Scanner::GeometryID
-Scanner::convertGeometryNameToID (const char* const geometryName)
+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)
{
- GeometryID geometryID = GEOMETRY_INVALID;
+ const char *title = "";
- if (strcasecmp (geometryName, GEOMETRY_PARALLEL_STR) == 0)
- geometryID = GEOMETRY_PARALLEL;
- else if (strcasecmp (geometryName, GEOMETRY_EQUILINEAR_STR) == 0)
- geometryID = GEOMETRY_EQUILINEAR;
- else if (strcasecmp (geometryName, GEOMETRY_EQUIANGULAR_STR) == 0)
- geometryID = GEOMETRY_EQUIANGULAR;
+ if (geomID >= 0 && geomID < s_iGeometryCount)
+ return (s_aszGeometryName[geomID]);
- return (geometryID);
+ 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
* raysum_collect Calculate ray sums for a Phantom
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: ctsim.cpp,v 1.7 2000/07/20 11:17:31 kevin Exp $
+** $Id: ctsim.cpp,v 1.8 2000/07/22 15:45:33 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
void
MainFrame::OnCreatePhantom(wxCommandEvent& WXUNUSED(event))
{
- DialogGetPhantom dialogPhantom (this, Phantom::PHM_HERMAN_STR);
+ DialogGetPhantom dialogPhantom (this, Phantom::PHM_HERMAN);
int dialogReturn = dialogPhantom.ShowModal();
if (dialogReturn == wxID_OK) {
- wxString selection = dialogPhantom.getPhantom();
+ wxString selection (dialogPhantom.getPhantom());
*theApp->getLog() << "Selected phantom " << selection.c_str() << "\n";
wxString filename = selection + ".phm";
theApp->getDocManager()->CreateDocument(filename, wxDOC_SILENT);
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: dialogs.cpp,v 1.4 2000/07/20 11:17:31 kevin Exp $
+** $Id: dialogs.cpp,v 1.5 2000/07/22 15:45:33 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
#include "backprojectors.h"
+StringValueAndTitleListBox::StringValueAndTitleListBox (wxDialog* pParent, int nChoices, const char* aszTitle[], const char* aszValue[])
+ : wxListBox ()
+{
+ wxString asTitle[nChoices];
+ for (int i = 0; i < nChoices; i++)
+ asTitle[i] = aszTitle[i];
-const wxString DialogGetPhantom::s_asPhantom[] =
-{
- wxString(Phantom::PHM_HERMAN_STR),
- wxString(Phantom::PHM_BHERMAN_STR),
- wxString(Phantom::PHM_ROWLAND_STR),
- wxString(Phantom::PHM_BROWLAND_STR),
- wxString(Phantom::PHM_UNITPULSE_STR),
-};
-const wxString DialogGetPhantom::s_asPhantomTitle[] =
-{
- wxString(Phantom::PHM_HERMAN_TITLE_STR),
- wxString(Phantom::PHM_BHERMAN_TITLE_STR),
- wxString(Phantom::PHM_ROWLAND_TITLE_STR),
- wxString(Phantom::PHM_BROWLAND_TITLE_STR),
- wxString(Phantom::PHM_UNITPULSE_TITLE_STR),
+ Create (pParent, -1, wxDefaultPosition, wxDefaultSize, nChoices, asTitle, wxLB_SINGLE | wxLB_NEEDED_SB);
+
+ m_ppszValues = aszValue;
};
-const unsigned int DialogGetPhantom::s_iNumPhantom = sizeof(s_asPhantom) / sizeof(wxString);
+
+const char*
+StringValueAndTitleListBox::getSelectionStringValue (void) const
+{
+ return m_ppszValues[GetSelection()];
+}
-DialogGetPhantom::DialogGetPhantom (wxFrame* pParent, const char* szDefaultPhantom = NULL)
+
+DialogGetPhantom::DialogGetPhantom (wxFrame* pParent, int iDefaultPhantom = Phantom::PHM_HERMAN)
: wxDialog (pParent, -1, "Select Phantom", wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
{
- m_sDefaultPhantom = szDefaultPhantom;
-
wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
pTopSizer->Add (new wxStaticText (this, -1, "Select Phantom"), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
- m_pListBoxPhantom = new wxListBox (this, -1, wxDefaultPosition, wxDefaultSize, s_iNumPhantom, s_asPhantomTitle, wxLB_SINGLE | wxLB_NEEDED_SB);
+ m_pListBoxPhantom = new StringValueAndTitleListBox (this, Phantom::getPhantomCount(), Phantom::getPhantomTitleArray(), Phantom::getPhantomNameArray());
pTopSizer->Add (m_pListBoxPhantom, 0, wxALL | wxALIGN_CENTER | wxEXPAND);
pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
pTopSizer->SetSizeHints (this);
}
-const wxString&
+const char*
DialogGetPhantom::getPhantom(void)
{
- int selection = m_pListBoxPhantom->GetSelection();
- if (selection >= 0)
- return (s_asPhantom[selection]);
-
- return (m_sDefaultPhantom);
+ return m_pListBoxPhantom->getSelectionStringValue();
}
// DialogGetProjectionParameters
/////////////////////////////////////////////////////////////////////
-const wxString DialogGetProjectionParameters::s_asGeometry[] =
-{
- wxString(Scanner::GEOMETRY_PARALLEL_STR),
- wxString(Scanner::GEOMETRY_EQUILINEAR_STR),
- wxString(Scanner::GEOMETRY_EQUIANGULAR_STR),
-};
-const wxString DialogGetProjectionParameters::s_asGeometryTitle[] =
-{
- wxString(Scanner::GEOMETRY_PARALLEL_TITLE_STR),
- wxString(Scanner::GEOMETRY_EQUILINEAR_TITLE_STR),
- wxString(Scanner::GEOMETRY_EQUIANGULAR_TITLE_STR),
-};
-const unsigned int DialogGetProjectionParameters::s_iNumGeometry = sizeof(s_asGeometry) / sizeof(wxString);
-
-DialogGetProjectionParameters::DialogGetProjectionParameters (wxFrame* pParent, int iDefaultNDet = 0, int iDefaultNView = 0, int iDefaultNSamples = 1, double dDefaultRotAngle = 1., const char* szDefaultGeometry = NULL)
+DialogGetProjectionParameters::DialogGetProjectionParameters (wxFrame* pParent, int iDefaultNDet = 0, int iDefaultNView = 0, int iDefaultNSamples = 1, double dDefaultRotAngle = 1., int iDefaultGeometry = Scanner::GEOMETRY_PARALLEL)
: wxDialog (pParent, -1, "Set Projection Parameters", wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
{
wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
- m_pListBoxGeometry = new wxListBox (this, -1, wxDefaultPosition, wxDefaultSize, s_iNumGeometry, s_asGeometryTitle, wxLB_SINGLE | wxLB_NEEDED_SB);
+ m_pListBoxGeometry = new StringValueAndTitleListBox (this, Scanner::getGeometryCount(), Scanner::getGeometryTitleArray(), Scanner::getGeometryNameArray());
pTopSizer->Add (m_pListBoxGeometry, 0, wxALL | wxALIGN_CENTER | wxEXPAND);
ostringstream os;
pGridSizer->Add (new wxStaticText (this, -1, "Rotation Angle (PI units)"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
pGridSizer->Add (m_pTextCtrlRotAngle, 0, wxALIGN_CENTER_VERTICAL);
pTopSizer->Add (pGridSizer, 1, wxALL, 10);
- m_sDefaultGeometry = szDefaultGeometry;
pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
return (m_dDefaultRotAngle);
}
-const wxString&
+const char*
DialogGetProjectionParameters::getGeometry (void)
{
- int selection = m_pListBoxGeometry->GetSelection();
- if (selection >= 0)
- return (s_asGeometry[selection]);
-
- return m_sDefaultGeometry;
+ return m_pListBoxGeometry->getSelectionStringValue();
}
// DialogGetReconstructionParameters
/////////////////////////////////////////////////////////////////////
-const wxString DialogGetReconstructionParameters::s_asFilter[] =
-{
- wxString(SignalFilter::FILTER_ABS_BANDLIMIT_STR),
- wxString(SignalFilter::FILTER_SHEPP_STR),
-};
-const wxString DialogGetReconstructionParameters::s_asFilterTitle[] =
-{
- wxString(SignalFilter::FILTER_ABS_BANDLIMIT_TITLE_STR),
- wxString(SignalFilter::FILTER_SHEPP_TITLE_STR),
-};
-const unsigned int DialogGetReconstructionParameters::s_iNumFilter = sizeof(s_asFilter) / sizeof(wxString);
-
-
-const wxString DialogGetReconstructionParameters::s_asInterp[] =
-{
- wxString(Backprojector::INTERP_NEAREST_STR),
- wxString(Backprojector::INTERP_LINEAR_STR),
-};
-const wxString DialogGetReconstructionParameters::s_asInterpTitle[] =
-{
- wxString(Backprojector::INTERP_NEAREST_TITLE_STR),
- wxString(Backprojector::INTERP_LINEAR_TITLE_STR),
- };
-const unsigned int DialogGetReconstructionParameters::s_iNumInterp = sizeof(s_asInterp) / sizeof(wxString);
-
-DialogGetReconstructionParameters::DialogGetReconstructionParameters (wxFrame* pParent, int iDefaultXSize = 0, int iDefaultYSize = 0, const char* szDefaultFilterName = NULL, double dDefaultFilterParam = 1., const char* szDefaultFilterMethodName = NULL, int iDefaultZeropad = 3, const char* szDefaultInterpName = NULL, int iDefaultInterpParam = 1, const char* szDefaultBackprojName = NULL)
+DialogGetReconstructionParameters::DialogGetReconstructionParameters (wxFrame* pParent, int iDefaultXSize = 0, int iDefaultYSize = 0, int iDefaultFilterID = SignalFilter::FILTER_ABS_BANDLIMIT, double dDefaultFilterParam = 1., int iDefaultFilterMethodID = SignalFilter::FILTER_METHOD_CONVOLUTION, int iDefaultZeropad = 3, int iDefaultInterpID = Backprojector::INTERP_LINEAR, int iDefaultInterpParam = 1, int iDefaultBackprojID = Backprojector::BPROJ_IDIFF3)
: wxDialog (pParent, -1, "Set Reconstruction Parameters", wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
{
wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
- m_pListBoxFilter = new wxListBox (this, -1, wxDefaultPosition, wxDefaultSize, s_iNumFilter, s_asFilterTitle, wxLB_SINGLE | wxLB_NEEDED_SB);
+ m_pListBoxFilter = new StringValueAndTitleListBox (this, SignalFilter::getFilterCount(), SignalFilter::getFilterTitleArray(), SignalFilter::getFilterNameArray());
pTopSizer->Add (m_pListBoxFilter, 0, wxALL | wxALIGN_CENTER | wxEXPAND);
- m_pListBoxInterp = new wxListBox (this, -1, wxDefaultPosition, wxDefaultSize, s_iNumInterp, s_asInterpTitle, wxLB_SINGLE | wxLB_NEEDED_SB);
+ m_pListBoxFilterMethod = new StringValueAndTitleListBox (this, SignalFilter::getFilterMethodCount(), SignalFilter::getFilterMethodTitleArray(), SignalFilter::getFilterMethodNameArray());
+ pTopSizer->Add (m_pListBoxFilterMethod, 0, wxALL | wxALIGN_CENTER | wxEXPAND);
+
+ m_pListBoxBackproject = new StringValueAndTitleListBox (this, Backprojector::getBackprojectCount(), Backprojector::getBackprojectTitleArray(), Backprojector::getBackprojectNameArray());
+ pTopSizer->Add (m_pListBoxBackproject, 0, wxALL | wxALIGN_CENTER | wxEXPAND);
+
+ m_pListBoxInterp = new StringValueAndTitleListBox (this, Backprojector::getInterpCount(), Backprojector::getInterpTitleArray(), Backprojector::getInterpNameArray());
pTopSizer->Add (m_pListBoxInterp, 0, wxALL | wxALIGN_CENTER | wxEXPAND);
ostringstream os;
pGridSizer->Add (m_pTextCtrlInterpParam, 0, wxALIGN_CENTER_VERTICAL);
pTopSizer->Add (pGridSizer, 1, wxALL, 10);
- m_sDefaultFilterName = szDefaultFilterName;
- m_sDefaultFilterMethodName = szDefaultFilterMethodName;
- m_sDefaultInterpName = szDefaultInterpName;
- m_sDefaultBackprojName = szDefaultBackprojName;
-
pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
return (m_dDefaultFilterParam);
}
-const wxString&
+const char*
DialogGetReconstructionParameters::getFilterName (void)
{
- int selection = m_pListBoxFilter->GetSelection();
- if (selection >= 0)
- return (s_asFilter[selection]);
-
- return m_sDefaultFilterName;
+ return m_pListBoxFilter->getSelectionStringValue();
}
-const wxString&
+const char*
DialogGetReconstructionParameters::getFilterMethodName (void)
{
- return m_sDefaultFilterMethodName;
+ return m_pListBoxFilterMethod->getSelectionStringValue();
}
-const wxString&
+const char*
DialogGetReconstructionParameters::getInterpName (void)
{
- int selection = m_pListBoxInterp->GetSelection();
- if (selection >= 0)
- return (s_asInterp[selection]);
-
- return m_sDefaultInterpName;
+ return m_pListBoxInterp->getSelectionStringValue();
}
-const wxString&
-DialogGetReconstructionParameters::getBackprojName (void)
+const char*
+DialogGetReconstructionParameters::getBackprojectName (void)
{
- return m_sDefaultBackprojName;
+ return m_pListBoxBackproject->getSelectionStringValue();
}
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: dialogs.h,v 1.5 2000/07/20 11:17:31 kevin Exp $
+** $Id: dialogs.h,v 1.6 2000/07/22 15:45:33 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
#include "wx/wx.h"
#include <string>
+#include "scanner.h"
+#include "phantom.h"
+#include "filter.h"
+
+// CLASS StringValueAndTitleListBox
+//
+// A superclass of wxListBox that can handle string values and titles
+// and by displaying the title in the list box and returning the string value
+
+class StringValueAndTitleListBox : public wxListBox
+{
+ public:
+ StringValueAndTitleListBox (wxDialog* pParent, int nChoices, const char* aszTitle[], const char* aszValue[]);
+
+ const char* getSelectionStringValue (void) const;
+
+ private:
+ const char** m_ppszValues;
+};
class DialogGetPhantom : public wxDialog
{
public:
- DialogGetPhantom (wxFrame* pParent, const char* szDefaultPhantom);
+ DialogGetPhantom (wxFrame* pParent, int iDefaultPhantom = Phantom::PHM_HERMAN);
virtual ~DialogGetPhantom (void) {}
- const wxString& getPhantom (void);
+ const char* getPhantom (void);
private:
- wxListBox* m_pListBoxPhantom;
- wxString m_sDefaultPhantom;
-
- static const wxString s_asPhantom[];
- static const wxString s_asPhantomTitle[];
- static const unsigned int s_iNumPhantom;
+ StringValueAndTitleListBox* m_pListBoxPhantom;
};
class DialogGetProjectionParameters : public wxDialog
{
public:
- DialogGetProjectionParameters (wxFrame* pParent, int iDefaultNDet = 0, int iDefaultNView = 0, int iDefaultNSamples = 1, double dDefaultRotAngle = 1., const char* szDefaultGeometry = NULL);
+ DialogGetProjectionParameters (wxFrame* pParent, int iDefaultNDet = 0, int iDefaultNView = 0, int iDefaultNSamples = 1, double dDefaultRotAngle = 1., int iDefaultGeometry = Scanner::GEOMETRY_PARALLEL);
~DialogGetProjectionParameters (void);
unsigned int getNDet (void);
unsigned int getNView (void);
unsigned int getNSamples (void);
double getRotAngle (void);
- const wxString& getGeometry(void);
+ const char* getGeometry(void);
private:
wxTextCtrl* m_pTextCtrlNDet;
wxTextCtrl* m_pTextCtrlNView;
wxTextCtrl* m_pTextCtrlNSamples;
wxTextCtrl* m_pTextCtrlRotAngle;
- wxListBox* m_pListBoxGeometry;
+
+ StringValueAndTitleListBox* m_pListBoxGeometry;
int m_iDefaultNDet;
int m_iDefaultNView;
int m_iDefaultNSamples;
double m_dDefaultRotAngle;
- wxString m_sDefaultGeometry;
-
- static const wxString s_asGeometry[];
- static const wxString s_asGeometryTitle[];
- static const unsigned int s_iNumGeometry;
};
class DialogGetReconstructionParameters : public wxDialog
{
public:
- DialogGetReconstructionParameters (wxFrame* pParent, int iDefaultXSize = 0, int iDefaultYSize = 0, const char* szDefaultFilterName = NULL, double dDefaultFilterParam = 1., const char* szDefaultFilterMethodName = NULL, int iDefaultZeropad = 3, const char* szDefaultInterpName = NULL, int iDefaultInterpParam = 1, const char* szDefaultBackprojName = NULL);
+ DialogGetReconstructionParameters (wxFrame* pParent, int iDefaultXSize = 0, int iDefaultYSize = 0, int iDefaultFilterID = SignalFilter::FILTER_ABS_BANDLIMIT, double dDefaultFilterParam = 1., int iDefaultFilterMethodID = SignalFilter::FILTER_METHOD_CONVOLUTION, int iDefaultZeropad = 3, int iDefaultInterpID = Backprojector::INTERP_LINEAR, int iDefaultInterpParam = 1, int iDefaultBackprojID = Backprojector::BPROJ_IDIFF3);
virtual ~DialogGetReconstructionParameters (void);
unsigned int getXSize(void);
unsigned int getYSize(void);
- const wxString& getFilterName(void);
+ const char* getFilterName(void);
double getFilterParam(void);
- const wxString& getFilterMethodName(void);
+ const char* getFilterMethodName(void);
unsigned int getZeropad(void);
- const wxString& getInterpName(void);
+ const char* getInterpName(void);
unsigned int getInterpParam(void);
- const wxString& getBackprojName(void);
+ const char* getBackprojectName(void);
private:
wxTextCtrl* m_pTextCtrlXSize;
wxTextCtrl* m_pTextCtrlFilterParam;
wxTextCtrl* m_pTextCtrlInterpParam;
- wxListBox* m_pListBoxFilter;
- wxListBox* m_pListBoxFilterMethod;
- wxListBox* m_pListBoxInterp;
- wxListBox* m_pListBoxBackproj;
+ StringValueAndTitleListBox* m_pListBoxFilter;
+ StringValueAndTitleListBox* m_pListBoxFilterMethod;
+ StringValueAndTitleListBox* m_pListBoxInterp;
+ StringValueAndTitleListBox* m_pListBoxBackproject;
int m_iDefaultXSize;
int m_iDefaultYSize;
double m_dDefaultFilterParam;
int m_iDefaultZeropad;
int m_iDefaultInterpParam;
- wxString m_sDefaultFilterName;
- wxString m_sDefaultFilterMethodName;
- wxString m_sDefaultInterpName;
- wxString m_sDefaultBackprojName;
-
- static const wxString s_asFilter[];
- static const wxString s_asFilterTitle[];
- static const unsigned int s_iNumFilter;
-
- static const wxString s_asFilterMethod[];
- static const wxString s_asFilterMethodTitle[];
- static const unsigned int s_iNumFilterMethod;
-
- static const wxString s_asInterp[];
- static const wxString s_asInterpTitle[];
- static const unsigned int s_iNumInterp;
-
- static const wxString s_asBackproj[];
- static const wxString s_asBackprojTitle[];
- static const unsigned int s_iNumBackproj;
};
#endif
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: docs.h,v 1.3 2000/07/19 04:33:27 kevin Exp $
+** $Id: docs.h,v 1.4 2000/07/22 15:45:33 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
private:
Phantom m_phantom;
- Phantom::PhantomID m_idPhantom;
+ int m_idPhantom;
wxString m_namePhantom;
public:
~PhantomDocument (void)
{}
- const Phantom::PhantomID getPhantomID (void) const
+ const int getPhantomID (void) const
{ return m_idPhantom; }
const wxString& getPhantomName (void) const
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: views.cpp,v 1.7 2000/07/20 11:17:31 kevin Exp $
+** $Id: views.cpp,v 1.8 2000/07/22 15:45:33 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
void
PhantomView::OnProperties (wxCommandEvent& event)
{
- const Phantom::PhantomID idPhantom = GetDocument()->getPhantomID();
+ const int idPhantom = GetDocument()->getPhantomID();
const string& namePhantom = GetDocument()->getPhantomName();
ostringstream os;
- os << "Phantom " << namePhantom << " (" << static_cast<int>(idPhantom) << ")\n";
+ os << "Phantom " << namePhantom << " (" << idPhantom << ")\n";
*theApp->getLog() << os.str().c_str();
#if DEBUG
const Phantom& rPhantom = GetDocument()->getPhantom();
void
PhantomView::OnProjections (wxCommandEvent& event)
{
- DialogGetProjectionParameters dialogProjection (m_frame, 367, 320, 1, 1., Scanner::GEOMETRY_PARALLEL_STR);
+ DialogGetProjectionParameters dialogProjection (m_frame, 367, 320, 1, 1., Scanner::GEOMETRY_PARALLEL);
int retVal = dialogProjection.ShowModal();
if (retVal == wxID_OK) {
int nDet = dialogProjection.getNDet();
void
ProjectionFileView::OnReconstruct (wxCommandEvent& event)
{
- DialogGetReconstructionParameters dialogReconstruction (m_frame, 256, 256, SignalFilter::FILTER_ABS_BANDLIMIT_STR, 1., SignalFilter::FILTER_METHOD_CONVOLUTION_STR, 3, Backprojector::INTERP_LINEAR_STR, 1, Backprojector::BPROJ_IDIFF3_STR);
+ DialogGetReconstructionParameters dialogReconstruction (m_frame, 256, 256, SignalFilter::FILTER_ABS_BANDLIMIT, 1., SignalFilter::FILTER_METHOD_CONVOLUTION, 3, Backprojector::INTERP_LINEAR, 1, Backprojector::BPROJ_IDIFF3);
int retVal = dialogReconstruction.ShowModal();
if (retVal == wxID_OK) {
int xSize = dialogReconstruction.getXSize();
int optZeropad = dialogReconstruction.getZeropad();
wxString optInterpName = dialogReconstruction.getInterpName();
int optInterpParam = dialogReconstruction.getInterpParam();
- wxString optBackprojectName = dialogReconstruction.getBackprojName();
+ wxString optBackprojectName = dialogReconstruction.getBackprojectName();
if (xSize > 0 && ySize > 0) {
ImageFileDocument* pReconDoc = dynamic_cast<ImageFileDocument*>(theApp->getDocManager()->CreateDocument("untitled.if", wxDOC_SILENT));
ImageFile& imageFile = pReconDoc->getImageFile();
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: phm2if.cpp,v 1.2 2000/07/20 11:17:31 kevin Exp $
+** $Id: phm2if.cpp,v 1.3 2000/07/22 15:45:33 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
Phantom phm;
int opt_nx = 0, opt_ny = 0;
int opt_nsample = 1;
- string optPhmName = Phantom::PHM_HERMAN_STR;
+ string optPhmName (Phantom::convertPhantomIDToName(Phantom::PHM_HERMAN));
string optFilterName;
- string optDomainName = SignalFilter::DOMAIN_SPATIAL_STR;
+ string optDomainName (SignalFilter::convertDomainIDToName (SignalFilter::DOMAIN_SPATIAL));
char *opt_outfile = NULL;
int opt_debug = 0;
string opt_desc;
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: phm2pj.cpp,v 1.2 2000/07/20 11:17:31 kevin Exp $
+** $Id: phm2pj.cpp,v 1.3 2000/07/22 15:45:33 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
phm2pj_main (int argc, char* argv[])
{
Phantom phm;
- string optGeometryName = Scanner::GEOMETRY_PARALLEL_STR;
+ string optGeometryName = Scanner::convertGeometryIDToName(Scanner::GEOMETRY_PARALLEL);
char *opt_outfile = NULL;
string opt_desc;
string optPhmFileName;
int opt_nview;
int opt_nray = 1;
int opt_trace = 0;
- string optPhmName = Phantom::PHM_HERMAN_STR;
+ string optPhmName (Phantom::convertPhantomIDToName(Phantom::PHM_HERMAN));
int opt_verbose = 0;
int opt_debug = 0;
double opt_rotangle = 1;
** This is part of the CTSim program
** Copyright (C) 1983-2000 Kevin Rosenberg
**
-** $Id: pjrec.cpp,v 1.4 2000/07/20 11:38:00 kevin Exp $
+** $Id: pjrec.cpp,v 1.5 2000/07/22 15:45:33 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
int optZeroPad = 0;
int optTrace = TRACE_NONE;
double optFilterParam = -1;
- string optFilterName = SignalFilter::FILTER_ABS_BANDLIMIT_STR;
- string optFilterMethodName = SignalFilter::FILTER_METHOD_CONVOLUTION_STR;
- string optInterpName = Backprojector::INTERP_LINEAR_STR;
- string optBackprojName = Backprojector::BPROJ_IDIFF3_STR;
+ string optFilterName (SignalFilter::convertFilterIDToName (SignalFilter::FILTER_ABS_BANDLIMIT));
+ string optFilterMethodName (SignalFilter::convertFilterMethodIDToName (SignalFilter::FILTER_METHOD_CONVOLUTION));
+ string optInterpName (Backprojector::convertInterpIDToName (Backprojector::INTERP_LINEAR));
+ string optBackprojName (Backprojector::convertBackprojectIDToName (Backprojector::BPROJ_IDIFF3));
int optPreinterpolationFactor = 1;
int nx, ny;
#ifdef HAVE_MPI
projects / ctsim.git / commitdiff