src/dialogs.cpp

   1 /*****************************************************************************
   2 ** FILE IDENTIFICATION
   3 **
   4 **   Name:          dialogs.cpp
   5 **   Purpose:       Dialog routines for CTSim program
   6 **   Programmer:    Kevin Rosenberg
   7 **   Date Started:  July 2000
   8 **
   9 **  This is part of the CTSim program
  10 **  Copyright (c) 1983-2001 Kevin Rosenberg
  11 **
  12 **  $Id: dialogs.cpp,v 1.55 2001/09/24 09:40:42 kevin Exp $
  13 **
  14 **  This program is free software; you can redistribute it and/or modify
  15 **  it under the terms of the GNU General Public License (version 2) as
  16 **  published by the Free Software Foundation.
  17 **
  18 **  This program is distributed in the hope that it will be useful,
  19 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 **  GNU General Public License for more details.
  22 **
  23 **  You should have received a copy of the GNU General Public License
  24 **  along with this program; if not, write to the Free Software
  25 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  26 ******************************************************************************/
  27
  28 #ifdef __GNUG__
  29 // #pragma implementation
  30 #endif
  31
  32 #include "wx/wxprec.h"
  33
  34 #ifndef WX_PRECOMP
  35 #include "wx/wx.h"
  36 #endif
  37
  38 #if !wxUSE_DOC_VIEW_ARCHITECTURE
  39 #error You must set wxUSE_DOC_VIEW_ARCHITECTURE to 1 in setup.h!
  40 #endif
  41
  42 #include "wx/statline.h"
  43 #include "wx/sizer.h"
  44 #include "dialogs.h"
  45 #include "ctsim.h"
  46 #include "ct.h"
  47 #include "docs.h"
  48 #include "views.h"
  49 #include "imagefile.h"
  50 #include "projections.h"
  51
  52 #if defined(MSVC) || HAVE_SSTREAM
  53 #include <sstream>
  54 #else
  55 #include <sstream_subst>
  56 #endif
  57
  58
  59 ///////////////////////////////////////////////////////////////////////
  60 // CLASS IMPLEMENTATION
  61 //    StringValueAndTitleListBox
  62 ///////////////////////////////////////////////////////////////////////
  63
  64 StringValueAndTitleListBox::StringValueAndTitleListBox (wxDialog* pParent, int nChoices, const char* const aszTitle[], const char* const aszValue[])
  65 : wxListBox ()
  66 {
  67   wxString* psTitle = new wxString [nChoices];
  68   for (int i = 0; i < nChoices; i++)
  69     psTitle[i] = aszTitle[i];
  70
  71   Create (pParent, -1, wxDefaultPosition, wxSize(-1,-1), nChoices, psTitle, wxLB_SINGLE | wxLB_NEEDED_SB);
  72
  73   m_ppszValues = aszValue;
  74   delete [] psTitle;
  75 };
  76
  77 const char*
  78 StringValueAndTitleListBox::getSelectionStringValue () const
  79 {
  80   return m_ppszValues[GetSelection()];
  81 }
  82
  83 StringValueAndTitleRadioBox::StringValueAndTitleRadioBox (wxDialog* pParent, const wxString& strTitle, int nChoices, const char* const aszTitle[], const char* const aszValue[])
  84 : wxRadioBox ()
  85 {
  86   wxString* psTitle = new wxString [nChoices];
  87   for (int i = 0; i < nChoices; i++)
  88     psTitle[i] = aszTitle[i];
  89
  90   Create (pParent, -1, strTitle, wxDefaultPosition, wxDefaultSize, nChoices, psTitle, 1, wxRA_SPECIFY_COLS);
  91
  92   m_ppszValues = aszValue;
  93   delete [] psTitle;
  94 };
  95
  96 const char*
  97 StringValueAndTitleRadioBox::getSelectionStringValue () const
  98 {
  99   return m_ppszValues[GetSelection()];
 100 }
 101
 102 ///////////////////////////////////////////////////////////////////////
 103 // CLASS IMPLEMENTATION
 104 //    DialogGetPhantom
 105 ///////////////////////////////////////////////////////////////////////
 106
 107 DialogGetPhantom::DialogGetPhantom (wxWindow* pParent, int iDefaultPhantom)
 108 : wxDialog (pParent, -1, _T("Select Phantom"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
 109 {
 110   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
 111
 112   pTopSizer->Add (new wxStaticText (this, -1, "Select Phantom"), 0, wxCENTER | wxALL, 5);
 113
 114   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 115
 116   m_pRadioBoxPhantom = new StringValueAndTitleRadioBox (this, _T("Phantom"), Phantom::getPhantomCount(), Phantom::getPhantomTitleArray(), Phantom::getPhantomNameArray());
 117   m_pRadioBoxPhantom->SetSelection (iDefaultPhantom);
 118   pTopSizer->Add (m_pRadioBoxPhantom, 0, wxALL | wxALIGN_CENTER);
 119
 120   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 121
 122   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
 123   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
 124   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
 125   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
 126   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
 127   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_PHANTOM);
 128   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
 129
 130   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
 131   pButtonOk->SetDefault();
 132
 133   SetAutoLayout (true);
 134   SetSizer (pTopSizer);
 135   pTopSizer->Fit (this);
 136   pTopSizer->SetSizeHints (this);
 137 }
 138
 139 const char*
 140 DialogGetPhantom::getPhantom()
 141 {
 142   return m_pRadioBoxPhantom->getSelectionStringValue();
 143 }
 144
 145
 146 ///////////////////////////////////////////////////////////////////////
 147 // CLASS IMPLEMENTATION
 148 //    DialogGetThetaRange
 149 ///////////////////////////////////////////////////////////////////////
 150
 151 DialogGetThetaRange::DialogGetThetaRange (wxWindow* pParent, int iDefaultThetaRange)
 152 : wxDialog (pParent, -1, _T("Select Phantom"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
 153 {
 154   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
 155
 156   pTopSizer->Add (new wxStaticText (this, -1, "Select Theta Range"), 0, wxCENTER | wxALL, 5);
 157
 158   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 159
 160   wxString asTitle[] = {"Unconstrained", "Normalized to 2pi", "Fold to pi"};
 161
 162   m_pRadioBoxThetaRange = new wxRadioBox (this, -1, _T("Theta Range"), wxDefaultPosition, wxDefaultSize, 3, asTitle, 1, wxRA_SPECIFY_COLS);
 163   if (iDefaultThetaRange == ParallelRaysums::THETA_RANGE_UNCONSTRAINED)
 164     m_pRadioBoxThetaRange->SetSelection (0);
 165   else if (iDefaultThetaRange == ParallelRaysums::THETA_RANGE_NORMALIZE_TO_TWOPI)
 166     m_pRadioBoxThetaRange->SetSelection (1);
 167   else if (iDefaultThetaRange == ParallelRaysums::THETA_RANGE_FOLD_TO_PI)
 168     m_pRadioBoxThetaRange->SetSelection (2);
 169
 170   pTopSizer->Add (m_pRadioBoxThetaRange, 0, wxALL | wxALIGN_CENTER);
 171
 172   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 173
 174   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
 175   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
 176   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
 177   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
 178   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
 179   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_THETA_RANGE);
 180   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
 181
 182   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
 183   pButtonOk->SetDefault();
 184
 185   SetAutoLayout (true);
 186   SetSizer (pTopSizer);
 187   pTopSizer->Fit (this);
 188   pTopSizer->SetSizeHints (this);
 189 }
 190
 191 int
 192 DialogGetThetaRange::getThetaRange()
 193 {
 194   int iSelection = m_pRadioBoxThetaRange->GetSelection();
 195   if (iSelection == 0)
 196     return ParallelRaysums::THETA_RANGE_UNCONSTRAINED;
 197   else if (iSelection == 1)
 198     return ParallelRaysums::THETA_RANGE_NORMALIZE_TO_TWOPI;
 199   else
 200     return ParallelRaysums::THETA_RANGE_FOLD_TO_PI;
 201 }
 202
 203
 204 ///////////////////////////////////////////////////////////////////////
 205 // CLASS IMPLEMENTATION
 206 //    DialogGetComparisonImage
 207 ///////////////////////////////////////////////////////////////////////
 208
 209 DialogGetComparisonImage::DialogGetComparisonImage (wxWindow* pParent, const char* const pszTitle, const std::vector<ImageFileDocument*>& rVecIF, bool bShowMakeDifference)
 210 : wxDialog (pParent, -1, pszTitle, wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION), m_rVecIF(rVecIF)
 211 {
 212   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
 213
 214   pTopSizer->Add (new wxStaticText (this, -1, pszTitle), 0, wxALIGN_CENTER | wxALL, 5);
 215
 216   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxALL, 5);
 217
 218   int iNImages = m_rVecIF.size();
 219   wxString* pstrImages = new wxString [iNImages];
 220   for (int i = 0; i < iNImages; i++) {
 221     ImageFileView* pView = dynamic_cast<ImageFileView*>(m_rVecIF[i]->GetFirstView());
 222     if (pView)
 223       pstrImages[i] = pView->getFrame()->GetTitle();
 224   }
 225
 226   m_pListBoxImageChoices = new wxListBox (this, -1, wxDefaultPosition, wxDefaultSize, iNImages, pstrImages, wxLB_SINGLE);
 227   delete [] pstrImages;
 228
 229   m_pListBoxImageChoices->SetSelection (0);
 230   pTopSizer->Add (m_pListBoxImageChoices, 0, wxALL | wxALIGN_CENTER | wxEXPAND);
 231
 232   if (bShowMakeDifference) {
 233     m_pMakeDifferenceImage = new wxCheckBox (this, -1, "Make Difference Image");
 234     m_pMakeDifferenceImage->SetValue (FALSE);
 235     pTopSizer->Add (m_pMakeDifferenceImage, 0, wxALL | wxALIGN_CENTER | wxEXPAND);
 236   } else
 237     m_pMakeDifferenceImage = NULL;
 238
 239   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 240
 241   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
 242   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
 243   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
 244   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
 245   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
 246   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_COMPARISON);
 247   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
 248
 249   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
 250   pButtonOk->SetDefault();
 251
 252   SetAutoLayout (true);
 253   SetSizer (pTopSizer);
 254   pTopSizer->Fit (this);
 255   pTopSizer->SetSizeHints (this);
 256 }
 257
 258 ImageFileDocument*
 259 DialogGetComparisonImage::getImageFileDocument()
 260 {
 261   return m_rVecIF[ m_pListBoxImageChoices->GetSelection() ];
 262 }
 263
 264 bool
 265 DialogGetComparisonImage::getMakeDifferenceImage()
 266 {
 267   if (m_pMakeDifferenceImage)
 268     return m_pMakeDifferenceImage->GetValue();
 269   else
 270     return false;
 271 }
 272
 273
 274 /////////////////////////////////////////////////////////////////////
 275 // CLASS DiaglogPreferences Implementation
 276 /////////////////////////////////////////////////////////////////////
 277
 278 DialogPreferences::DialogPreferences (wxWindow* pParent, const char* const pszTitle,
 279                    bool bAdvancedOptions, bool bAskDeleteNewDocs, bool bVerboseLogging, bool bStartupTips, bool bUseBackgroundTasks)
 280 : wxDialog (pParent, -1, _T(pszTitle), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
 281 {
 282   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
 283
 284   pTopSizer->Add (new wxStaticText (this, -1, pszTitle), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
 285
 286   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 287
 288   m_pCBAdvancedOptions = new wxCheckBox (this, -1, "Advanced Options", wxDefaultPosition, wxSize(250, 25), 0);
 289   m_pCBAdvancedOptions->SetValue (bAdvancedOptions);
 290   pTopSizer->Add (m_pCBAdvancedOptions, 0, wxALIGN_CENTER_VERTICAL);
 291
 292   m_pCBAskDeleteNewDocs = new wxCheckBox (this, -1, "Ask \"Save New Documents\" Before Closing", wxDefaultPosition, wxSize(250, 25), 0);
 293   m_pCBAskDeleteNewDocs->SetValue (bAskDeleteNewDocs);
 294   pTopSizer->Add (m_pCBAskDeleteNewDocs, 0, wxALIGN_CENTER_VERTICAL);
 295
 296   m_pCBVerboseLogging = new wxCheckBox (this, -1, "Verbose Logging", wxDefaultPosition, wxSize(250, 25), 0);
 297   m_pCBVerboseLogging->SetValue (bVerboseLogging);
 298   pTopSizer->Add (m_pCBVerboseLogging, 0, wxALIGN_CENTER_VERTICAL);
 299
 300   m_pCBStartupTips = new wxCheckBox (this, -1, "Show Tips at Start", wxDefaultPosition, wxSize(250, 25), 0);
 301   m_pCBStartupTips->SetValue (bStartupTips);
 302   pTopSizer->Add (m_pCBStartupTips, 0, wxALIGN_CENTER_VERTICAL);
 303
 304 #ifdef HAVE_WXTHREADS
 305   m_pCBUseBackgroundTasks = new wxCheckBox (this, -1, "Put Tasks in Background", wxDefaultPosition, wxSize(250, 25), 0);
 306   m_pCBUseBackgroundTasks->SetValue (bUseBackgroundTasks);
 307   pTopSizer->Add (m_pCBUseBackgroundTasks, 0, wxALIGN_CENTER_VERTICAL);
 308 #endif
 309
 310   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 311
 312   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
 313   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
 314   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
 315   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
 316   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
 317   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_PREFERENCES);
 318   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
 319
 320   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
 321   pButtonOk->SetDefault();
 322
 323   SetAutoLayout (true);
 324   SetSizer (pTopSizer);
 325   pTopSizer->Fit (this);
 326   pTopSizer->SetSizeHints (this);
 327 }
 328
 329 DialogPreferences::~DialogPreferences ()
 330 {
 331 }
 332
 333 bool
 334 DialogPreferences::getAdvancedOptions ()
 335 {
 336   return static_cast<bool>(m_pCBAdvancedOptions->GetValue());
 337 }
 338
 339 bool
 340 DialogPreferences::getAskDeleteNewDocs ()
 341 {
 342   return static_cast<bool>(m_pCBAskDeleteNewDocs->GetValue());
 343 }
 344
 345 bool
 346 DialogPreferences::getVerboseLogging ()
 347 {
 348   return static_cast<bool>(m_pCBVerboseLogging->GetValue());
 349 }
 350
 351 bool
 352 DialogPreferences::getStartupTips ()
 353 {
 354   return static_cast<bool>(m_pCBStartupTips->GetValue());
 355 }
 356
 357 bool
 358 DialogPreferences::getUseBackgroundTasks ()
 359 {
 360 #ifdef HAVE_WXTHREADS
 361   return static_cast<bool>(m_pCBUseBackgroundTasks->GetValue());
 362 #else
 363   return false;
 364 #endif
 365 }
 366
 367
 368 /////////////////////////////////////////////////////////////////////
 369 // CLASS DiaglogGetMinMax Implementation
 370 /////////////////////////////////////////////////////////////////////
 371
 372 DialogGetMinMax::DialogGetMinMax (wxWindow* pParent, const char* const pszTitle, double dDefaultMin, double dDefaultMax)
 373 : wxDialog (pParent, -1, _T(pszTitle), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
 374 {
 375   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
 376
 377   pTopSizer->Add (new wxStaticText (this, -1, pszTitle), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
 378
 379   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 380
 381   std::ostringstream os;
 382   os << dDefaultMin;
 383   m_pTextCtrlMin = new wxTextCtrl (this, -1, os.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 384   std::ostringstream osMax;
 385   osMax << dDefaultMax;
 386   m_pTextCtrlMax = new wxTextCtrl (this, -1, osMax.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 387
 388   wxFlexGridSizer *pGridSizer = new wxFlexGridSizer (2);
 389   pGridSizer->Add (new wxStaticText (this, -1, "Minimum"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 390   pGridSizer->Add (m_pTextCtrlMin, 0, wxALIGN_CENTER_VERTICAL);
 391   pGridSizer->Add (new wxStaticText (this, -1, "Maximum"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 392   pGridSizer->Add (m_pTextCtrlMax, 0, wxALIGN_CENTER_VERTICAL);
 393   pTopSizer->Add (pGridSizer, 1, wxALL, 10);
 394
 395   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 396
 397   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
 398   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
 399   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
 400   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
 401   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
 402   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_MINMAX);
 403   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
 404
 405   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
 406   pButtonOk->SetDefault();
 407
 408   SetAutoLayout (true);
 409   SetSizer (pTopSizer);
 410   pTopSizer->Fit (this);
 411   pTopSizer->SetSizeHints (this);
 412 }
 413
 414 DialogGetMinMax::~DialogGetMinMax ()
 415 {
 416 }
 417
 418 double
 419 DialogGetMinMax::getMinimum ()
 420 {
 421   wxString strCtrl = m_pTextCtrlMin->GetValue();
 422   double dValue;
 423   if (strCtrl.ToDouble (&dValue))
 424     return dValue;
 425   else
 426     return (m_dDefaultMin);
 427 }
 428
 429 double
 430 DialogGetMinMax::getMaximum ()
 431 {
 432   wxString strCtrl = m_pTextCtrlMax->GetValue();
 433   double dValue;
 434   if (strCtrl.ToDouble (&dValue))
 435     return dValue;
 436   else
 437     return (m_dDefaultMax);
 438 }
 439
 440
 441 /////////////////////////////////////////////////////////////////////
 442 // CLASS DialogAutoScaleParameters IMPLEMENTATION
 443 /////////////////////////////////////////////////////////////////////
 444
 445 DialogAutoScaleParameters::DialogAutoScaleParameters (wxWindow *pParent, double mean, double mode, double median, double stddev, double dDefaultScaleFactor)
 446 : wxDialog (pParent, -1, _T("Auto Scale Parameters"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION), m_dMean(mean), m_dMode(mode), m_dMedian(median), m_dStdDev(stddev)
 447 {
 448   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
 449
 450   pTopSizer->Add (new wxStaticText (this, -1, "Auto Scale Parameters"), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
 451
 452   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 453
 454   wxString asTitle[] = {"Mode", "Median", "Mean"};
 455
 456   m_pRadioBoxCenter = new wxRadioBox (this, -1, _T("Center"), wxDefaultPosition, wxDefaultSize, 3, asTitle, 1, wxRA_SPECIFY_COLS);
 457   m_pRadioBoxCenter->SetSelection (0);
 458   pTopSizer->Add (m_pRadioBoxCenter, 0, wxALL | wxALIGN_CENTER);
 459
 460   wxGridSizer *pGridSizer = new wxGridSizer (2);
 461   pGridSizer->Add (new wxStaticText (this, -1, "Standard Deviation Factor"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 462   std::ostringstream osDefaultFactor;
 463   osDefaultFactor << dDefaultScaleFactor;
 464   m_pTextCtrlStdDevFactor = new wxTextCtrl (this, -1, osDefaultFactor.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 465   pGridSizer->Add (m_pTextCtrlStdDevFactor, 0, wxALIGN_CENTER_VERTICAL);
 466   pTopSizer->Add (pGridSizer, 1, wxALL, 10);
 467
 468   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 469
 470   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
 471   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
 472   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
 473   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
 474   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
 475   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_AUTOSCALE);
 476   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
 477
 478   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
 479   pButtonOk->SetDefault();
 480
 481   SetAutoLayout (true);
 482   SetSizer (pTopSizer);
 483   pTopSizer->Fit (this);
 484   pTopSizer->SetSizeHints (this);
 485 }
 486
 487 bool
 488 DialogAutoScaleParameters::getMinMax (double* pMin, double* pMax)
 489 {
 490   int iCenter = m_pRadioBoxCenter->GetSelection();
 491   double dCenter = m_dMode;
 492   if (iCenter == 1)
 493     dCenter = m_dMedian;
 494   else if (iCenter == 2)
 495     dCenter = m_dMean;
 496
 497   wxString sStddevFactor = m_pTextCtrlStdDevFactor->GetValue();
 498   double dValue;
 499   if (! sStddevFactor.ToDouble (&dValue)) {
 500     *theApp->getLog() << "Error: Non-numeric Standard Deviation Factor of " << sStddevFactor << "\n";
 501     return false;
 502   }
 503   double dHalfWidth = dValue * m_dStdDev / 2;
 504   *pMin = dCenter - dHalfWidth;
 505   *pMax = dCenter + dHalfWidth;
 506   *theApp->getLog() << "Setting minimum to " << *pMin << " and maximum to " << *pMax << "\n";
 507
 508   return true;
 509 }
 510
 511 double
 512 DialogAutoScaleParameters::getAutoScaleFactor ()
 513 {
 514   wxString sStddevFactor = m_pTextCtrlStdDevFactor->GetValue();
 515   double dValue = 1.;
 516   if (! sStddevFactor.ToDouble (&dValue)) {
 517     *theApp->getLog() << "Error: Non-numeric Standard Deviation Factor of " << sStddevFactor << "\n";
 518   }
 519
 520   return dValue;
 521 }
 522
 523
 524
 525 /////////////////////////////////////////////////////////////////////
 526 // CLASS IDENTIFICATION
 527 //
 528 // DialogGetRasterParameters
 529 /////////////////////////////////////////////////////////////////////
 530
 531 DialogGetRasterParameters::DialogGetRasterParameters
 532    (wxWindow* pParent, int iDefaultXSize, int iDefaultYSize, int iDefaultNSamples, double dDefaultViewRatio)
 533 : wxDialog (pParent, -1, _T("Rasterization Parameters"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
 534 {
 535   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
 536
 537   pTopSizer->Add (new wxStaticText (this, -1, "Rasterization Parameters"), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
 538
 539   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 540
 541   wxFlexGridSizer *pGridSizer = new wxFlexGridSizer (2);
 542   std::ostringstream os;
 543   os << iDefaultXSize;
 544   m_pTextCtrlXSize = new wxTextCtrl (this, -1, os.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 545   pGridSizer->Add (new wxStaticText (this, -1, "X Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 546   pGridSizer->Add (m_pTextCtrlXSize, 0, wxALIGN_CENTER_VERTICAL);
 547   std::ostringstream osYSize;
 548   osYSize << iDefaultYSize;
 549   m_pTextCtrlYSize = new wxTextCtrl (this, -1, osYSize.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 550   pGridSizer->Add (new wxStaticText (this, -1, "Y Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 551   pGridSizer->Add (m_pTextCtrlYSize, 0, wxALIGN_CENTER_VERTICAL);
 552   std::ostringstream osViewRatio;
 553   osViewRatio << dDefaultViewRatio;
 554   m_pTextCtrlViewRatio = new wxTextCtrl (this, -1, osViewRatio.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 555   pGridSizer->Add (new wxStaticText (this, -1, "View Ratio"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 556   pGridSizer->Add (m_pTextCtrlViewRatio, 0, wxALIGN_CENTER_VERTICAL);
 557   std::ostringstream osNSamples;
 558   osNSamples << iDefaultNSamples;
 559   m_pTextCtrlNSamples = new wxTextCtrl (this, -1, osNSamples.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 560   pGridSizer->Add (new wxStaticText (this, -1, "Samples per Pixel"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 561   pGridSizer->Add (m_pTextCtrlNSamples, 0, wxALIGN_CENTER_VERTICAL);
 562
 563   pTopSizer->Add (pGridSizer, 1, wxALL, 10);
 564
 565   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 566
 567   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
 568   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
 569   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
 570   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
 571   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
 572   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_RASTERIZE);
 573   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
 574
 575   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
 576   pButtonOk->SetDefault();
 577
 578   SetAutoLayout (true);
 579   SetSizer (pTopSizer);
 580   pTopSizer->Fit (this);
 581   pTopSizer->SetSizeHints (this);
 582 }
 583
 584 DialogGetRasterParameters::~DialogGetRasterParameters ()
 585 {
 586 }
 587
 588
 589 unsigned int
 590 DialogGetRasterParameters::getXSize ()
 591 {
 592   wxString strCtrl = m_pTextCtrlXSize->GetValue();
 593   unsigned long lValue;
 594   if (strCtrl.ToULong (&lValue))
 595     return lValue;
 596   else
 597     return (m_iDefaultXSize);
 598 }
 599
 600 unsigned int
 601 DialogGetRasterParameters::getYSize ()
 602 {
 603   wxString strCtrl = m_pTextCtrlYSize->GetValue();
 604   unsigned long lValue;
 605   if (strCtrl.ToULong (&lValue))
 606     return lValue;
 607   else
 608     return (m_iDefaultYSize);
 609 }
 610
 611 unsigned int
 612 DialogGetRasterParameters::getNSamples ()
 613 {
 614   wxString strCtrl = m_pTextCtrlNSamples->GetValue();
 615   unsigned long lValue;
 616   if (strCtrl.ToULong (&lValue))
 617     return lValue;
 618   else
 619     return (m_iDefaultNSamples);
 620 }
 621
 622 double
 623 DialogGetRasterParameters::getViewRatio ()
 624 {
 625   wxString strCtrl = m_pTextCtrlViewRatio->GetValue();
 626   double dValue;
 627   if (strCtrl.ToDouble (&dValue))
 628     return dValue;
 629   else
 630     return (m_dDefaultViewRatio);
 631 }
 632
 633
 634 /////////////////////////////////////////////////////////////////////
 635 // CLASS IDENTIFICATION
 636 //
 637 // DialogGetProjectionParameters
 638 /////////////////////////////////////////////////////////////////////
 639
 640
 641 DialogGetProjectionParameters::DialogGetProjectionParameters
 642    (wxWindow* pParent, int iDefaultNDet, int iDefaultNView, int iDefaultOffsetView, int iDefaultNSamples,
 643     double dDefaultRotAngle, double dDefaultFocalLength, double dDefaultCenterDetectorLength,
 644     double dDefaultViewRatio, double dDefaultScanRatio, int iDefaultGeometry, int iDefaultTrace)
 645 : wxDialog (pParent, -1, _T("Projection Parameters"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
 646 {
 647   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
 648
 649   m_dDefaultRotAngle = dDefaultRotAngle;
 650   m_dDefaultFocalLength = dDefaultFocalLength;
 651   m_dDefaultCenterDetectorLength = dDefaultCenterDetectorLength;
 652   m_dDefaultViewRatio = dDefaultViewRatio;
 653   m_dDefaultScanRatio = dDefaultScanRatio;
 654   m_iDefaultNSamples = iDefaultNSamples;
 655   m_iDefaultNView = iDefaultNView;
 656   m_iDefaultNDet = iDefaultNDet;
 657   m_iDefaultTrace = iDefaultTrace;
 658   m_iDefaultGeometry = iDefaultGeometry;
 659
 660   pTopSizer->Add (new wxStaticText (this, -1, "Projection Parameters"), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
 661
 662   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 663
 664   wxFlexGridSizer* pGridSizer = new wxFlexGridSizer (2);
 665   m_pRadioBoxGeometry = new StringValueAndTitleRadioBox (this, _T("Geometry"), Scanner::getGeometryCount(), Scanner::getGeometryTitleArray(), Scanner::getGeometryNameArray());
 666   m_pRadioBoxGeometry->SetSelection (iDefaultGeometry);
 667
 668   pGridSizer->Add (m_pRadioBoxGeometry, 0, wxALL | wxALIGN_CENTER | wxEXPAND);
 669
 670   m_pRadioBoxTrace = new StringValueAndTitleRadioBox (this, _T("Trace Level"), Trace::getTraceCount(), Trace::getTraceTitleArray(), Trace::getTraceNameArray());
 671   m_pRadioBoxTrace->SetSelection (iDefaultTrace);
 672   pGridSizer->Add (m_pRadioBoxTrace, 0, wxALL | wxALIGN_CENTER | wxEXPAND);
 673
 674           wxFlexGridSizer* pText1Sizer = new wxFlexGridSizer(2);
 675   std::ostringstream os;
 676   os << iDefaultNDet;
 677   m_pTextCtrlNDet = new wxTextCtrl (this, -1, os.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 678   pText1Sizer->Add (new wxStaticText (this, -1, "Detectors"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 679   pText1Sizer->Add (m_pTextCtrlNDet, 0, wxALIGN_CENTER_VERTICAL);
 680   std::ostringstream osNView;
 681   osNView << iDefaultNView;
 682   m_pTextCtrlNView = new wxTextCtrl (this, -1, osNView.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 683   pText1Sizer->Add (new wxStaticText (this, -1, "Views"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 684   pText1Sizer->Add (m_pTextCtrlNView, 0, wxALIGN_CENTER_VERTICAL);
 685   std::ostringstream osNSamples;
 686   osNSamples << iDefaultNSamples;
 687   m_pTextCtrlNSamples = new wxTextCtrl (this, -1, osNSamples.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 688   pText1Sizer->Add (new wxStaticText (this, -1, "Samples per Detector"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 689   pText1Sizer->Add (m_pTextCtrlNSamples, 0, wxALIGN_CENTER_VERTICAL);
 690
 691   pGridSizer->Add (pText1Sizer);
 692
 693   wxFlexGridSizer* pText2Sizer = new wxFlexGridSizer(2);
 694   std::ostringstream osViewRatio;
 695   osViewRatio << dDefaultViewRatio;
 696   m_pTextCtrlViewRatio = new wxTextCtrl (this, -1, osViewRatio.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 697   pText2Sizer->Add (new wxStaticText (this, -1, "View Ratio"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 698   pText2Sizer->Add (m_pTextCtrlViewRatio, 0, wxALIGN_CENTER_VERTICAL);
 699   std::ostringstream osScanRatio;
 700   osScanRatio << dDefaultScanRatio;
 701   m_pTextCtrlScanRatio = new wxTextCtrl (this, -1, osScanRatio.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 702   pText2Sizer->Add (new wxStaticText (this, -1, "Scan Ratio"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 703   pText2Sizer->Add (m_pTextCtrlScanRatio, 0, wxALIGN_CENTER_VERTICAL);
 704   std::ostringstream osFocalLength;
 705   osFocalLength << dDefaultFocalLength;
 706   m_pTextCtrlFocalLength = new wxTextCtrl (this, -1, osFocalLength.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 707   pText2Sizer->Add (new wxStaticText (this, -1, "Focal Length Ratio"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 708   pText2Sizer->Add (m_pTextCtrlFocalLength, 0, wxALIGN_CENTER_VERTICAL);
 709
 710   if (theApp->getAdvancedOptions()) {
 711     std::ostringstream osCenterDetectorLength;
 712     osCenterDetectorLength << dDefaultCenterDetectorLength;
 713     m_pTextCtrlCenterDetectorLength = new wxTextCtrl (this, -1, osCenterDetectorLength.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 714     pText2Sizer->Add (new wxStaticText (this, -1, "Center-Detector Length Ratio"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 715     pText2Sizer->Add (m_pTextCtrlCenterDetectorLength, 0, wxALIGN_CENTER_VERTICAL);
 716
 717     std::ostringstream osRotAngle;
 718     osRotAngle << dDefaultRotAngle;
 719     m_pTextCtrlRotAngle = new wxTextCtrl (this, -1, osRotAngle.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 720     pText2Sizer->Add (new wxStaticText (this, -1, "Rotation Angle (Fraction of circle)"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 721     pText2Sizer->Add (m_pTextCtrlRotAngle, 0, wxALIGN_CENTER_VERTICAL);
 722
 723     std::ostringstream osOffsetView;
 724     osOffsetView << iDefaultOffsetView;
 725     m_pTextCtrlOffsetView = new wxTextCtrl (this, -1, osOffsetView.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 726     pText2Sizer->Add (new wxStaticText (this, -1, "Gantry offset in units of 'views' "), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 727     pText2Sizer->Add (m_pTextCtrlOffsetView, 0, wxALIGN_CENTER_VERTICAL);
 728
 729   }
 730   pGridSizer->Add (pText2Sizer);
 731
 732   pTopSizer->Add (pGridSizer, 1, wxALL, 10);
 733
 734   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 735
 736   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
 737   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
 738   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
 739   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
 740   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
 741   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_PROJECTIONS);
 742   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
 743
 744   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
 745   pButtonOk->SetDefault();
 746
 747   SetAutoLayout (true);
 748   SetSizer (pTopSizer);
 749   pTopSizer->Fit (this);
 750   pTopSizer->SetSizeHints (this);
 751
 752   m_pRadioBoxGeometry->SetFocus();
 753 }
 754
 755 DialogGetProjectionParameters::~DialogGetProjectionParameters ()
 756 {
 757 }
 758
 759
 760 unsigned int
 761 DialogGetProjectionParameters::getNDet ()
 762 {
 763   wxString strCtrl = m_pTextCtrlNDet->GetValue();
 764   unsigned long lValue;
 765   if (strCtrl.ToULong (&lValue))
 766     return lValue;
 767   else
 768     return (m_iDefaultNDet);
 769 }
 770
 771 unsigned int
 772 DialogGetProjectionParameters::getNView ()
 773 {
 774   wxString strCtrl = m_pTextCtrlNView->GetValue();
 775   unsigned long lValue;
 776   if (strCtrl.ToULong (&lValue))
 777     return lValue;
 778   else
 779     return (m_iDefaultNView);
 780 }
 781
 782 unsigned int
 783 DialogGetProjectionParameters::getOffsetView ()
 784 {
 785         wxString strCtrl = m_pTextCtrlOffsetView->GetValue();
 786         unsigned long lValue;
 787         if (strCtrl.ToULong (&lValue))
 788           return lValue;
 789         else
 790           return (m_iDefaultOffsetView);
 791 }
 792
 793 unsigned int
 794 DialogGetProjectionParameters::getNSamples ()
 795 {
 796   wxString strCtrl = m_pTextCtrlNSamples->GetValue();
 797   unsigned long lValue;
 798   if (strCtrl.ToULong (&lValue))
 799     return lValue;
 800   else
 801     return (m_iDefaultNSamples);
 802 }
 803
 804 double
 805 DialogGetProjectionParameters::getRotAngle ()
 806 {
 807   if (theApp->getAdvancedOptions()) {
 808     wxString strCtrl = m_pTextCtrlRotAngle->GetValue();
 809     double dValue;
 810     if (strCtrl.ToDouble (&dValue))
 811       return (dValue * TWOPI);
 812     else
 813       return (m_dDefaultRotAngle);
 814   } else {
 815     if (Scanner::convertGeometryNameToID (m_pRadioBoxGeometry->getSelectionStringValue()) ==
 816           Scanner::GEOMETRY_PARALLEL)
 817       return (PI);
 818     else
 819       return (TWOPI);
 820   }
 821 }
 822
 823 double
 824 DialogGetProjectionParameters::getFocalLengthRatio ()
 825 {
 826   wxString strCtrl = m_pTextCtrlFocalLength->GetValue();
 827   double dValue;
 828   if (strCtrl.ToDouble (&dValue))
 829     return (dValue);
 830   else
 831     return (m_dDefaultFocalLength);
 832 }
 833
 834 double
 835 DialogGetProjectionParameters::getCenterDetectorLengthRatio ()
 836 {
 837   if (theApp->getAdvancedOptions()) {
 838     wxString strCtrl = m_pTextCtrlCenterDetectorLength->GetValue();
 839     double dValue;
 840     if (strCtrl.ToDouble (&dValue))
 841       return (dValue);
 842     else
 843       return (m_dDefaultCenterDetectorLength);
 844   } else
 845     return getFocalLengthRatio(); // default is to set equal to focal-length
 846 }
 847
 848 double
 849 DialogGetProjectionParameters::getViewRatio ()
 850 {
 851   wxString strCtrl = m_pTextCtrlViewRatio->GetValue();
 852   double dValue;
 853   if (strCtrl.ToDouble (&dValue))
 854     return (dValue);
 855   else
 856     return (m_dDefaultViewRatio);
 857 }
 858
 859 double
 860 DialogGetProjectionParameters::getScanRatio ()
 861 {
 862   wxString strCtrl = m_pTextCtrlScanRatio->GetValue();
 863   double dValue;
 864   if (strCtrl.ToDouble (&dValue))
 865     return (dValue);
 866   else
 867     return (m_dDefaultScanRatio);
 868 }
 869
 870 const char*
 871 DialogGetProjectionParameters::getGeometry ()
 872 {
 873   return m_pRadioBoxGeometry->getSelectionStringValue();
 874 }
 875
 876 int
 877 DialogGetProjectionParameters::getTrace ()
 878 {
 879   return Trace::convertTraceNameToID(m_pRadioBoxTrace->getSelectionStringValue());
 880 }
 881
 882
 883
 884 /////////////////////////////////////////////////////////////////////
 885 // CLASS IDENTIFICATION
 886 //
 887 // DialogGetReconstructionParameters
 888 /////////////////////////////////////////////////////////////////////
 889
 890
 891 DialogGetReconstructionParameters::DialogGetReconstructionParameters (wxWindow* pParent, int iDefaultXSize,
 892                      int iDefaultYSize, int iDefaultFilterID, double dDefaultHammingParam,
 893                      int iDefaultFilterMethodID, int iDefaultFilterGenerationID, int iDefaultZeropad,
 894                      int iDefaultInterpID, int iDefaultInterpParam, int iDefaultBackprojectID, int iTrace,
 895                      ReconstructionROI* pDefaultROI)
 896 : wxDialog (pParent, -1, _T("Reconstruction Parameters"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
 897 {
 898   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
 899
 900   m_iDefaultXSize = iDefaultXSize;
 901   m_iDefaultYSize = iDefaultYSize;
 902   m_dDefaultFilterParam = dDefaultHammingParam;
 903   m_iDefaultZeropad = iDefaultZeropad;
 904   m_iDefaultInterpParam = iDefaultInterpParam;
 905   m_dDefaultRoiXMin = pDefaultROI->m_dXMin;
 906   m_dDefaultRoiXMax = pDefaultROI->m_dXMax;
 907   m_dDefaultRoiYMin = pDefaultROI->m_dYMin;
 908   m_dDefaultRoiYMax = pDefaultROI->m_dYMax;
 909
 910   pTopSizer->Add (new wxStaticText (this, -1, "Filtered Backprojection Parameters"), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
 911   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 912
 913   wxFlexGridSizer* pGridSizer = NULL;
 914   if (theApp->getAdvancedOptions())
 915     pGridSizer = new wxFlexGridSizer (4);
 916   else
 917     pGridSizer = new wxFlexGridSizer (3);
 918
 919   if (theApp->getAdvancedOptions())
 920     m_pRadioBoxFilter = new StringValueAndTitleRadioBox (this, _T("Filter"), SignalFilter::getFilterCount(), SignalFilter::getFilterTitleArray(), SignalFilter::getFilterNameArray());
 921   else
 922     m_pRadioBoxFilter = new StringValueAndTitleRadioBox (this, _T("Filter"), SignalFilter::getReconstructFilterCount(), SignalFilter::getFilterTitleArray(), SignalFilter::getFilterNameArray());
 923   m_pRadioBoxFilter->SetSelection (iDefaultFilterID);
 924   pGridSizer->Add (m_pRadioBoxFilter, 0, wxALL | wxALIGN_LEFT | wxEXPAND);
 925
 926   if (theApp->getAdvancedOptions()) {
 927     m_pRadioBoxFilterMethod = new StringValueAndTitleRadioBox (this, _T("Filter Method"), ProcessSignal::getFilterMethodCount(), ProcessSignal::getFilterMethodTitleArray(), ProcessSignal::getFilterMethodNameArray());
 928     m_pRadioBoxFilterMethod->SetSelection (iDefaultFilterMethodID);
 929     pGridSizer->Add (m_pRadioBoxFilterMethod, 0, wxALL | wxALIGN_LEFT | wxEXPAND);
 930   } else {
 931 #if HAVE_FFTW
 932     static const char* aszFilterMethodTitle[] = {"Convolution", "FFT"};
 933     static const char* aszFilterMethodName[] = {"convolution", "rfftw"};
 934 #else
 935     static const char* aszFilterMethodTitle[] = {"Convolution", "Fourier"};
 936     static const char* aszFilterMethodName[] = {"convolution", "fourier-table"};
 937 #endif
 938       m_pRadioBoxFilterMethod = new StringValueAndTitleRadioBox (this, _T("Filter Method"), 2, aszFilterMethodTitle, aszFilterMethodName);
 939 #if HAVE_FFTW
 940       m_pRadioBoxFilterMethod->SetSelection (1);
 941 #else
 942       m_pRadioBoxFilterMethod->SetSelection (0);
 943 #endif
 944       pGridSizer->Add (m_pRadioBoxFilterMethod, 0, wxALL | wxALIGN_LEFT | wxEXPAND);
 945   }
 946
 947   if (theApp->getAdvancedOptions()) {
 948     m_pRadioBoxFilterGeneration = new StringValueAndTitleRadioBox (this, _T("Filter Generation"), ProcessSignal::getFilterGenerationCount(), ProcessSignal::getFilterGenerationTitleArray(), ProcessSignal::getFilterGenerationNameArray());
 949     m_pRadioBoxFilterGeneration->SetSelection (iDefaultFilterGenerationID);
 950     pGridSizer->Add (m_pRadioBoxFilterGeneration, 0, wxALL | wxALIGN_LEFT | wxEXPAND);
 951
 952     m_pRadioBoxBackproject = new StringValueAndTitleRadioBox (this, _T("Backprojection"), Backprojector::getBackprojectCount(), Backprojector::getBackprojectTitleArray(), Backprojector::getBackprojectNameArray());
 953     m_pRadioBoxBackproject->SetSelection (iDefaultBackprojectID);
 954     pGridSizer->Add (m_pRadioBoxBackproject, 0, wxALL | wxALIGN_RIGHT | wxEXPAND);
 955   }
 956
 957   m_pRadioBoxInterp = new StringValueAndTitleRadioBox (this, _T("Interpolation"), Backprojector::getInterpCount(), Backprojector::getInterpTitleArray(), Backprojector::getInterpNameArray());
 958   m_pRadioBoxInterp->SetSelection (iDefaultInterpID);
 959   pGridSizer->Add (m_pRadioBoxInterp, 0, wxALL | wxALIGN_RIGHT | wxEXPAND);
 960
 961   static const char* aszTraceTitle[] = {"None", "Full"};
 962   static const char* aszTraceName[] = {"none", "full"};
 963   m_pRadioBoxTrace = new StringValueAndTitleRadioBox (this, _T("Trace Level"), 2, aszTraceTitle, aszTraceName);
 964   iTrace = clamp(iTrace, 0, 1);
 965   m_pRadioBoxTrace->SetSelection (iTrace);
 966   pGridSizer->Add (m_pRadioBoxTrace);
 967
 968   wxFlexGridSizer* pTextGridSizer = new wxFlexGridSizer (2);
 969   std::ostringstream os;
 970   os << iDefaultXSize;
 971   m_pTextCtrlXSize = new wxTextCtrl (this, -1, os.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 972   pTextGridSizer->Add (new wxStaticText (this, -1, "X Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 973   pTextGridSizer->Add (m_pTextCtrlXSize, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
 974   std::ostringstream osYSize;
 975   osYSize << iDefaultYSize;
 976   m_pTextCtrlYSize = new wxTextCtrl (this, -1, osYSize.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 977   pTextGridSizer->Add (new wxStaticText (this, -1, "Y Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 978   pTextGridSizer->Add (m_pTextCtrlYSize, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
 979
 980   std::ostringstream osHammingParam;
 981   osHammingParam << dDefaultHammingParam;
 982   m_pTextCtrlFilterParam = new wxTextCtrl (this, -1, osHammingParam.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 983   pTextGridSizer->Add (new wxStaticText (this, -1, "Hamming Parameter"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 984   pTextGridSizer->Add (m_pTextCtrlFilterParam, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
 985
 986   if (theApp->getAdvancedOptions()) {
 987     std::ostringstream osZeropad;
 988     osZeropad << iDefaultZeropad;
 989     m_pTextCtrlZeropad = new wxTextCtrl (this, -1, osZeropad.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 990     pTextGridSizer->Add (new wxStaticText (this, -1, "Zeropad"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 991     pTextGridSizer->Add (m_pTextCtrlZeropad, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
 992   }
 993   pGridSizer->Add (pTextGridSizer);
 994
 995 #if HAVE_FREQ_PREINTERP
 996   std::ostringstream osInterpParam;
 997   osInterpParam << iDefaultInterpParam;
 998   m_pTextCtrlInterpParam = new wxTextCtrl (this, -1, osInterpParam.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 999   pGridSizer->Add (new wxStaticText (this, -1, "Interpolation Parameter"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1000   pGridSizer->Add (m_pTextCtrlInterpParam, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1001 #endif
1002
1003   if (theApp->getAdvancedOptions()) {
1004     wxFlexGridSizer* pROIGridSizer = new wxFlexGridSizer (2);
1005     std::ostringstream osRoiXMin;
1006     osRoiXMin << m_dDefaultRoiXMin;
1007     m_pTextCtrlRoiXMin = new wxTextCtrl (this, -1, osRoiXMin.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1008     pROIGridSizer->Add (new wxStaticText (this, -1, "ROI XMin"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1009     pROIGridSizer->Add (m_pTextCtrlRoiXMin, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1010     std::ostringstream osRoiXMax;
1011     osRoiXMax << m_dDefaultRoiXMax;
1012     m_pTextCtrlRoiXMax = new wxTextCtrl (this, -1, osRoiXMax.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1013     pROIGridSizer->Add (new wxStaticText (this, -1, "ROI XMax"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1014     pROIGridSizer->Add (m_pTextCtrlRoiXMax, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1015     std::ostringstream osRoiYMin;
1016     osRoiYMin << m_dDefaultRoiYMin;
1017     m_pTextCtrlRoiYMin = new wxTextCtrl (this, -1, osRoiYMin.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1018     pROIGridSizer->Add (new wxStaticText (this, -1, "ROI YMin"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1019     pROIGridSizer->Add (m_pTextCtrlRoiYMin, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1020     std::ostringstream osRoiYMax;
1021     osRoiYMax << m_dDefaultRoiYMax;
1022     m_pTextCtrlRoiYMax = new wxTextCtrl (this, -1, osRoiYMax.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1023     pROIGridSizer->Add (new wxStaticText (this, -1, "ROI YMax"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1024     pROIGridSizer->Add (m_pTextCtrlRoiYMax, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1025
1026     pGridSizer->Add (pROIGridSizer);
1027   }
1028
1029   pTopSizer->Add (pGridSizer, 1, wxALL, 3);
1030
1031   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1032
1033   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
1034   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
1035   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
1036   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
1037   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
1038   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_RECONSTRUCTION);
1039   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
1040
1041   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
1042   pButtonOk->SetDefault();
1043
1044   SetAutoLayout (true);
1045   SetSizer (pTopSizer);
1046   pTopSizer->Layout();
1047   pTopSizer->Fit (this);
1048   pTopSizer->SetSizeHints (this);
1049 }
1050
1051 DialogGetReconstructionParameters::~DialogGetReconstructionParameters ()
1052 {
1053 }
1054
1055
1056 unsigned int
1057 DialogGetReconstructionParameters::getXSize ()
1058 {
1059   wxString strCtrl = m_pTextCtrlXSize->GetValue();
1060   unsigned long lValue;
1061   if (strCtrl.ToULong (&lValue))
1062     return lValue;
1063   else
1064     return (m_iDefaultXSize);
1065 }
1066
1067 unsigned int
1068 DialogGetReconstructionParameters::getYSize ()
1069 {
1070   wxString strCtrl = m_pTextCtrlYSize->GetValue();
1071   unsigned long lValue;
1072   if (strCtrl.ToULong (&lValue))
1073     return lValue;
1074   else
1075     return (m_iDefaultYSize);
1076 }
1077
1078 unsigned int
1079 DialogGetReconstructionParameters::getZeropad ()
1080 {
1081   if (theApp->getAdvancedOptions()) {
1082     wxString strCtrl = m_pTextCtrlZeropad->GetValue();
1083     unsigned long lValue;
1084     if (strCtrl.ToULong (&lValue))
1085       return lValue;
1086     else
1087       return (m_iDefaultZeropad);
1088   } else
1089     return 1;
1090 }
1091
1092
1093 unsigned int
1094 DialogGetReconstructionParameters::getInterpParam ()
1095 {
1096 #if HAVE_FREQ_PREINTERP
1097   wxString strCtrl = m_pTextCtrlInterpParam->GetValue();
1098   unsigned long lValue;
1099   if (strCtrl.ToULong (&lValue))
1100     return lValue;
1101   else
1102     return (m_iDefaultInterpParam);
1103 #else
1104   return 1;
1105 #endif
1106 }
1107
1108 double
1109 DialogGetReconstructionParameters::getFilterParam ()
1110 {
1111   wxString strCtrl = m_pTextCtrlFilterParam->GetValue();
1112   double dValue;
1113   if (strCtrl.ToDouble (&dValue))
1114     return (dValue);
1115   else
1116     return (m_dDefaultFilterParam);
1117 }
1118
1119 const char*
1120 DialogGetReconstructionParameters::getFilterName ()
1121 {
1122   return m_pRadioBoxFilter->getSelectionStringValue();
1123 }
1124
1125 const char*
1126 DialogGetReconstructionParameters::getFilterMethodName ()
1127 {
1128   return m_pRadioBoxFilterMethod->getSelectionStringValue();
1129 }
1130
1131 const char*
1132 DialogGetReconstructionParameters::getInterpName ()
1133 {
1134   return m_pRadioBoxInterp->getSelectionStringValue();
1135 }
1136
1137 int
1138 DialogGetReconstructionParameters::getTrace ()
1139 {
1140   int iTrace = 0;
1141   if (strcmp("full", m_pRadioBoxTrace->getSelectionStringValue()) == 0)
1142     iTrace = Trace::TRACE_PLOT;
1143   return iTrace;
1144 }
1145
1146 const char*
1147 DialogGetReconstructionParameters::getBackprojectName ()
1148 {
1149   if (theApp->getAdvancedOptions()) {
1150     return m_pRadioBoxBackproject->getSelectionStringValue();
1151   } else
1152     return "idiff";
1153 }
1154
1155 const char*
1156 DialogGetReconstructionParameters::getFilterGenerationName ()
1157 {
1158   if (theApp->getAdvancedOptions()) {
1159     return m_pRadioBoxFilterGeneration->getSelectionStringValue();
1160   } else {
1161     if (ProcessSignal::convertFilterMethodNameToID(m_pRadioBoxFilterMethod->getSelectionStringValue())
1162         == ProcessSignal::FILTER_METHOD_CONVOLUTION)
1163       return "direct";
1164     else
1165       return "inverse-fourier";
1166   }
1167 }
1168
1169 void
1170 DialogGetReconstructionParameters::getROI (ReconstructionROI* pROI)
1171 {
1172   if (theApp->getAdvancedOptions()) {
1173     double dValue;
1174     if (m_pTextCtrlRoiXMin->GetValue().ToDouble (&dValue))
1175       pROI->m_dXMin = dValue;
1176     else
1177       pROI->m_dXMin = m_dDefaultRoiXMin;
1178
1179     if (m_pTextCtrlRoiXMax->GetValue().ToDouble (&dValue))
1180       pROI->m_dXMax = dValue;
1181     else
1182       pROI->m_dXMax = m_dDefaultRoiXMax;
1183
1184     if (m_pTextCtrlRoiYMin->GetValue().ToDouble (&dValue))
1185       pROI->m_dYMin = dValue;
1186     else
1187       pROI->m_dYMin = m_dDefaultRoiYMin;
1188
1189     if (m_pTextCtrlRoiYMax->GetValue().ToDouble (&dValue))
1190       pROI->m_dYMax = dValue;
1191     else
1192       pROI->m_dYMax = m_dDefaultRoiYMax;
1193   } else {
1194     pROI->m_dXMin = m_dDefaultRoiXMin;
1195     pROI->m_dXMax = m_dDefaultRoiXMax;
1196     pROI->m_dYMin = m_dDefaultRoiYMin;
1197     pROI->m_dYMax = m_dDefaultRoiYMax;
1198   }
1199 }
1200
1201 /////////////////////////////////////////////////////////////////////
1202 // CLASS IDENTIFICATION
1203 //
1204 // DialogGetFilterParameters
1205 /////////////////////////////////////////////////////////////////////
1206
1207
1208
1209 DialogGetFilterParameters::DialogGetFilterParameters (wxWindow* pParent, int iDefaultXSize, int iDefaultYSize, int iDefaultFilterID, double dDefaultFilterParam,  double dDefaultBandwidth, int iDefaultDomainID, double dDefaultInputScale, double dDefaultOutputScale)
1210 : wxDialog (pParent, -1, _T("Filter Parameters"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
1211 {
1212   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
1213
1214   pTopSizer->Add (new wxStaticText (this, -1, "Filter Parameters"), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
1215   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1216
1217   wxFlexGridSizer* pGridSizer = new wxFlexGridSizer (2);
1218
1219   m_pRadioBoxFilter = new StringValueAndTitleRadioBox (this, _T("Filter"), SignalFilter::getFilterCount(), SignalFilter::getFilterTitleArray(), SignalFilter::getFilterNameArray());
1220   m_pRadioBoxFilter->SetSelection (iDefaultFilterID);
1221   pGridSizer->Add (m_pRadioBoxFilter, 0, wxALL | wxALIGN_LEFT | wxEXPAND);
1222
1223   m_pRadioBoxDomain = new StringValueAndTitleRadioBox (this, _T("Domain"), SignalFilter::getDomainCount(), SignalFilter::getDomainTitleArray(), SignalFilter::getDomainNameArray());
1224   m_pRadioBoxDomain->SetSelection (iDefaultDomainID);
1225   pGridSizer->Add (m_pRadioBoxDomain, 0, wxALL | wxALIGN_LEFT | wxEXPAND);
1226
1227   std::ostringstream os;
1228   os << iDefaultXSize;
1229   m_pTextCtrlXSize = new wxTextCtrl (this, -1, os.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1230   pGridSizer->Add (new wxStaticText (this, -1, "X Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1231   pGridSizer->Add (m_pTextCtrlXSize, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1232
1233   std::ostringstream osYSize;
1234   osYSize << iDefaultYSize;
1235   m_pTextCtrlYSize = new wxTextCtrl (this, -1, osYSize.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1236   pGridSizer->Add (new wxStaticText (this, -1, "Y Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1237   pGridSizer->Add (m_pTextCtrlYSize, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1238
1239   std::ostringstream osFilterParam;
1240   osFilterParam << dDefaultFilterParam;
1241   m_pTextCtrlFilterParam = new wxTextCtrl (this, -1, osFilterParam.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1242   pGridSizer->Add (new wxStaticText (this, -1, "Filter Parameter"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1243   pGridSizer->Add (m_pTextCtrlFilterParam, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1244
1245   std::ostringstream osBandwidth;
1246   osBandwidth << dDefaultBandwidth;
1247   m_pTextCtrlBandwidth = new wxTextCtrl (this, -1, osBandwidth.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1248   pGridSizer->Add (new wxStaticText (this, -1, "Bandwidth"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1249   pGridSizer->Add (m_pTextCtrlBandwidth, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1250
1251   std::ostringstream osInputScale;
1252   osInputScale << dDefaultInputScale;
1253   m_pTextCtrlInputScale = new wxTextCtrl (this, -1, osInputScale.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1254   pGridSizer->Add (new wxStaticText (this, -1, "Axis (input) Scale"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1255   pGridSizer->Add (m_pTextCtrlInputScale, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1256
1257   std::ostringstream osOutputScale;
1258   osOutputScale << dDefaultOutputScale;
1259   m_pTextCtrlOutputScale = new wxTextCtrl (this, -1, osOutputScale.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1260   pGridSizer->Add (new wxStaticText (this, -1, "Filter Output Scale"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1261   pGridSizer->Add (m_pTextCtrlOutputScale, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1262
1263   pTopSizer->Add (pGridSizer, 1, wxALL, 3);
1264
1265   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1266
1267   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
1268   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
1269   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
1270   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
1271   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
1272   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_FILTER);
1273   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
1274
1275   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
1276   pButtonOk->SetDefault();
1277
1278   SetAutoLayout (true);
1279   SetSizer (pTopSizer);
1280   pTopSizer->Layout();
1281   pTopSizer->Fit (this);
1282   pTopSizer->SetSizeHints (this);
1283 }
1284
1285 DialogGetFilterParameters::~DialogGetFilterParameters ()
1286 {
1287 }
1288
1289
1290 unsigned int
1291 DialogGetFilterParameters::getXSize ()
1292 {
1293   wxString strCtrl = m_pTextCtrlXSize->GetValue();
1294   unsigned long lValue;
1295   if (strCtrl.ToULong (&lValue))
1296     return lValue;
1297   else
1298     return (m_iDefaultXSize);
1299 }
1300
1301 unsigned int
1302 DialogGetFilterParameters::getYSize ()
1303 {
1304   wxString strCtrl = m_pTextCtrlYSize->GetValue();
1305   unsigned long lValue;
1306   if (strCtrl.ToULong (&lValue))
1307     return lValue;
1308   else
1309     return (m_iDefaultYSize);
1310 }
1311
1312 double
1313 DialogGetFilterParameters::getBandwidth ()
1314 {
1315   wxString strCtrl = m_pTextCtrlBandwidth->GetValue();
1316   double dValue;
1317   if (strCtrl.ToDouble (&dValue))
1318     return dValue;
1319   else
1320     return (m_dDefaultBandwidth);
1321 }
1322
1323 double
1324 DialogGetFilterParameters::getFilterParam ()
1325 {
1326   wxString strCtrl = m_pTextCtrlFilterParam->GetValue();
1327   double dValue;
1328   if (strCtrl.ToDouble (&dValue))
1329     return (dValue);
1330   else
1331     return (m_dDefaultFilterParam);
1332 }
1333
1334 double
1335 DialogGetFilterParameters::getInputScale ()
1336 {
1337   wxString strCtrl = m_pTextCtrlInputScale->GetValue();
1338   double dValue;
1339   if (strCtrl.ToDouble (&dValue))
1340     return dValue;
1341   else
1342     return (m_dDefaultInputScale);
1343 }
1344
1345 double
1346 DialogGetFilterParameters::getOutputScale ()
1347 {
1348   wxString strCtrl = m_pTextCtrlOutputScale->GetValue();
1349   double dValue;
1350   if (strCtrl.ToDouble (&dValue))
1351     return dValue;
1352   else
1353     return (m_dDefaultOutputScale);
1354 }
1355
1356 const char*
1357 DialogGetFilterParameters::getFilterName ()
1358 {
1359   return m_pRadioBoxFilter->getSelectionStringValue();
1360 }
1361
1362 const char*
1363 DialogGetFilterParameters::getDomainName ()
1364 {
1365   return m_pRadioBoxDomain->getSelectionStringValue();
1366 }
1367
1368
1369 ///////////////////////////////////////////////////////////////////////
1370 // CLASS IMPLEMENTATION
1371 //    DialogExportParameters
1372 ///////////////////////////////////////////////////////////////////////
1373
1374 DialogExportParameters::DialogExportParameters (wxWindow* pParent, int iDefaultFormatID)
1375 : wxDialog (pParent, -1, _T("Select ExportParameters"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
1376 {
1377   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
1378
1379   pTopSizer->Add (new wxStaticText (this, -1, "Select Export Format"), 0, wxALIGN_CENTER | wxALL, 5);
1380
1381   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxALL, 5);
1382
1383   m_pRadioBoxFormat = new StringValueAndTitleRadioBox (this, _T("File Type"),
1384     ImageFile::getExportFormatCount(), ImageFile::getExportFormatTitleArray(), ImageFile::getExportFormatNameArray());
1385   m_pRadioBoxFormat->SetSelection (iDefaultFormatID);
1386   pTopSizer->Add (m_pRadioBoxFormat, 0, wxALL | wxALIGN_CENTER);
1387
1388   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1389
1390   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
1391   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
1392   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
1393   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
1394   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
1395   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_EXPORT);
1396   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
1397
1398   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
1399   pButtonOk->SetDefault();
1400
1401   SetAutoLayout (true);
1402   SetSizer (pTopSizer);
1403   pTopSizer->Fit (this);
1404   pTopSizer->SetSizeHints (this);
1405 }
1406
1407 const char*
1408 DialogExportParameters::getFormatName()
1409 {
1410   return m_pRadioBoxFormat->getSelectionStringValue();
1411 }
1412
1413
1414 ///////////////////////////////////////////////////////////////////////
1415 // CLASS IMPLEMENTATION
1416 //    DialogImportParameters
1417 ///////////////////////////////////////////////////////////////////////
1418
1419 DialogImportParameters::DialogImportParameters (wxWindow* pParent, int iDefaultFormatID)
1420 : wxDialog (pParent, -1, _T("Select Import Parameters"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
1421 {
1422   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
1423
1424   pTopSizer->Add (new wxStaticText (this, -1, "Select Import Format"), 0, wxALIGN_CENTER | wxALL, 5);
1425
1426   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxALL, 5);
1427
1428   m_pRadioBoxFormat = new StringValueAndTitleRadioBox (this, _T("File Type"),
1429     ImageFile::getImportFormatCount(), ImageFile::getImportFormatTitleArray(), ImageFile::getImportFormatNameArray());
1430   m_pRadioBoxFormat->SetSelection (iDefaultFormatID);
1431   pTopSizer->Add (m_pRadioBoxFormat, 0, wxALL | wxALIGN_CENTER);
1432
1433   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1434
1435   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
1436   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
1437   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
1438   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
1439   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
1440   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_IMPORT);
1441   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
1442
1443   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
1444   pButtonOk->SetDefault();
1445
1446   SetAutoLayout (true);
1447   SetSizer (pTopSizer);
1448   pTopSizer->Fit (this);
1449   pTopSizer->SetSizeHints (this);
1450 }
1451
1452 const char*
1453 DialogImportParameters::getFormatName()
1454 {
1455   return m_pRadioBoxFormat->getSelectionStringValue();
1456 }
1457
1458
1459 /////////////////////////////////////////////////////////////////////
1460 // CLASS DiaglogGetXYSize Implementation
1461 /////////////////////////////////////////////////////////////////////
1462
1463 DialogGetXYSize::DialogGetXYSize (wxWindow* pParent, const char* const pszTitle, int iDefaultXSize, int iDefaultYSize)
1464 : wxDialog (pParent, -1, _T(pszTitle), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
1465 {
1466   m_iDefaultXSize = iDefaultXSize;
1467   m_iDefaultYSize = iDefaultYSize;
1468
1469   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
1470
1471   pTopSizer->Add (new wxStaticText (this, -1, pszTitle), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
1472
1473   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1474
1475   std::ostringstream os;
1476   os << iDefaultXSize;
1477   m_pTextCtrlXSize = new wxTextCtrl (this, -1, os.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1478   std::ostringstream osYSize;
1479   osYSize << iDefaultYSize;
1480   m_pTextCtrlYSize = new wxTextCtrl (this, -1, osYSize.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1481
1482   wxFlexGridSizer *pGridSizer = new wxFlexGridSizer (2);
1483   pGridSizer->Add (new wxStaticText (this, -1, "X Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1484   pGridSizer->Add (m_pTextCtrlXSize, 0, wxALIGN_CENTER_VERTICAL);
1485   pGridSizer->Add (new wxStaticText (this, -1, "Y Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1486   pGridSizer->Add (m_pTextCtrlYSize, 0, wxALIGN_CENTER_VERTICAL);
1487   pTopSizer->Add (pGridSizer, 1, wxALL, 10);
1488
1489   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1490
1491   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
1492   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
1493   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
1494   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
1495   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
1496
1497   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
1498   pButtonOk->SetDefault();
1499
1500   SetAutoLayout (true);
1501   SetSizer (pTopSizer);
1502   pTopSizer->Fit (this);
1503   pTopSizer->SetSizeHints (this);
1504 }
1505
1506 DialogGetXYSize::~DialogGetXYSize ()
1507 {
1508 }
1509
1510 unsigned int
1511 DialogGetXYSize::getXSize ()
1512 {
1513   wxString strCtrl = m_pTextCtrlXSize->GetValue();
1514   long lValue;
1515   if (strCtrl.ToLong (&lValue))
1516     return lValue;
1517   else
1518     return (m_iDefaultXSize);
1519 }
1520
1521 unsigned int
1522 DialogGetXYSize::getYSize ()
1523 {
1524   wxString strCtrl = m_pTextCtrlYSize->GetValue();
1525   long lValue;
1526   if (strCtrl.ToLong (&lValue))
1527     return lValue;
1528   else
1529     return (m_iDefaultYSize);
1530 }
1531
1532
1533
1534 /////////////////////////////////////////////////////////////////////
1535 // CLASS IDENTIFICATION
1536 //
1537 // DialogGetConvertPolarParameters
1538 /////////////////////////////////////////////////////////////////////
1539
1540 DialogGetConvertPolarParameters::DialogGetConvertPolarParameters (wxWindow* pParent, const char* const pszTitle,
1541        int iDefaultXSize, int iDefaultYSize, int iDefaultInterpolationID, int iDefaultZeropad, int iHelpID)
1542 : wxDialog (pParent, -1, _T(pszTitle), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
1543 {
1544   m_iDefaultXSize = iDefaultXSize;
1545   m_iDefaultYSize = iDefaultYSize;
1546   m_iDefaultZeropad = iDefaultZeropad;
1547
1548   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
1549
1550   pTopSizer->Add (new wxStaticText (this, -1, pszTitle), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
1551   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1552
1553   wxFlexGridSizer* pGridSizer = new wxFlexGridSizer (1);
1554
1555   m_pRadioBoxInterpolation = new StringValueAndTitleRadioBox (this, _T("Interpolation"), Projections::getInterpCount(), Projections::getInterpTitleArray(), Projections::getInterpNameArray());
1556   m_pRadioBoxInterpolation->SetSelection (iDefaultInterpolationID);
1557   pGridSizer->Add (m_pRadioBoxInterpolation, 0, wxALL | wxALIGN_CENTER);
1558
1559   wxFlexGridSizer* pTextGridSizer = new wxFlexGridSizer (2);
1560   std::ostringstream os;
1561   os << iDefaultXSize;
1562   m_pTextCtrlXSize = new wxTextCtrl (this, -1, os.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1563   pTextGridSizer->Add (new wxStaticText (this, -1, "X Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1564   pTextGridSizer->Add (m_pTextCtrlXSize, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1565   std::ostringstream osYSize;
1566   osYSize << iDefaultYSize;
1567   m_pTextCtrlYSize = new wxTextCtrl (this, -1, osYSize.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1568   pTextGridSizer->Add (new wxStaticText (this, -1, "Y Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1569   pTextGridSizer->Add (m_pTextCtrlYSize, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1570   if (m_iDefaultZeropad >= 0) {
1571     std::ostringstream osZeropad;
1572     osZeropad << iDefaultZeropad;
1573     m_pTextCtrlZeropad = new wxTextCtrl (this, -1, osZeropad.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1574     pTextGridSizer->Add (new wxStaticText (this, -1, "Zeropad"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1575     pTextGridSizer->Add (m_pTextCtrlZeropad, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1576   }
1577
1578   pGridSizer->Add (pTextGridSizer, 0, wxALIGN_CENTER | wxALL);
1579
1580   pTopSizer->Add (pGridSizer, 1, wxALL | wxALIGN_CENTER, 3);
1581
1582   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1583
1584   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
1585   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
1586   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
1587   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
1588   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
1589   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, iHelpID);
1590   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
1591
1592   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
1593   pButtonOk->SetDefault();
1594   SetAutoLayout (true);
1595   SetSizer (pTopSizer);
1596   pTopSizer->Layout();
1597   pTopSizer->Fit (this);
1598   pTopSizer->SetSizeHints (this);
1599 }
1600
1601
1602 DialogGetConvertPolarParameters::~DialogGetConvertPolarParameters ()
1603 {
1604 }
1605
1606
1607 unsigned int
1608 DialogGetConvertPolarParameters::getXSize ()
1609 {
1610   wxString strCtrl = m_pTextCtrlXSize->GetValue();
1611   unsigned long lValue;
1612   if (strCtrl.ToULong (&lValue))
1613     return lValue;
1614   else
1615     return (m_iDefaultXSize);
1616 }
1617
1618 unsigned int
1619 DialogGetConvertPolarParameters::getYSize ()
1620 {
1621   wxString strCtrl = m_pTextCtrlYSize->GetValue();
1622   unsigned long lValue;
1623   if (strCtrl.ToULong (&lValue))
1624     return lValue;
1625   else
1626     return (m_iDefaultYSize);
1627 }
1628
1629 unsigned int
1630 DialogGetConvertPolarParameters::getZeropad ()
1631 {
1632   if (m_iDefaultZeropad >= 0) {
1633     wxString strCtrl = m_pTextCtrlZeropad->GetValue();
1634     unsigned long lValue;
1635     if (strCtrl.ToULong (&lValue))
1636       return lValue;
1637     else
1638       return (m_iDefaultZeropad);
1639   } else
1640     return 0;
1641 }
1642
1643 const char*
1644 DialogGetConvertPolarParameters::getInterpolationName ()
1645 {
1646   return m_pRadioBoxInterpolation->getSelectionStringValue();
1647 }
1648