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.57 2002/05/03 09:57:41 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 #if HAVE_WXTHREADS && MSVC
 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 #if HAVE_WXTHREADS && MSVC
 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   if (theApp->getAdvancedOptions()) {
 786           wxString strCtrl = m_pTextCtrlOffsetView->GetValue();
 787           unsigned long lValue;
 788           if (strCtrl.ToULong (&lValue))
 789             return lValue;
 790           else
 791             return (m_iDefaultOffsetView);
 792   }
 793   else
 794     return 0;
 795 }
 796
 797 unsigned int
 798 DialogGetProjectionParameters::getNSamples ()
 799 {
 800   wxString strCtrl = m_pTextCtrlNSamples->GetValue();
 801   unsigned long lValue;
 802   if (strCtrl.ToULong (&lValue))
 803     return lValue;
 804   else
 805     return (m_iDefaultNSamples);
 806 }
 807
 808 double
 809 DialogGetProjectionParameters::getRotAngle ()
 810 {
 811   if (theApp->getAdvancedOptions()) {
 812     wxString strCtrl = m_pTextCtrlRotAngle->GetValue();
 813     double dValue;
 814     if (strCtrl.ToDouble (&dValue))
 815       return (dValue * TWOPI);
 816     else
 817       return (m_dDefaultRotAngle);
 818   } else {
 819     if (Scanner::convertGeometryNameToID (m_pRadioBoxGeometry->getSelectionStringValue()) ==
 820           Scanner::GEOMETRY_PARALLEL)
 821       return (PI);
 822     else
 823       return (TWOPI);
 824   }
 825 }
 826
 827 double
 828 DialogGetProjectionParameters::getFocalLengthRatio ()
 829 {
 830   wxString strCtrl = m_pTextCtrlFocalLength->GetValue();
 831   double dValue;
 832   if (strCtrl.ToDouble (&dValue))
 833     return (dValue);
 834   else
 835     return (m_dDefaultFocalLength);
 836 }
 837
 838 double
 839 DialogGetProjectionParameters::getCenterDetectorLengthRatio ()
 840 {
 841   if (theApp->getAdvancedOptions()) {
 842     wxString strCtrl = m_pTextCtrlCenterDetectorLength->GetValue();
 843     double dValue;
 844     if (strCtrl.ToDouble (&dValue))
 845       return (dValue);
 846     else
 847       return (m_dDefaultCenterDetectorLength);
 848   } else
 849     return getFocalLengthRatio(); // default is to set equal to focal-length
 850 }
 851
 852 double
 853 DialogGetProjectionParameters::getViewRatio ()
 854 {
 855   wxString strCtrl = m_pTextCtrlViewRatio->GetValue();
 856   double dValue;
 857   if (strCtrl.ToDouble (&dValue))
 858     return (dValue);
 859   else
 860     return (m_dDefaultViewRatio);
 861 }
 862
 863 double
 864 DialogGetProjectionParameters::getScanRatio ()
 865 {
 866   wxString strCtrl = m_pTextCtrlScanRatio->GetValue();
 867   double dValue;
 868   if (strCtrl.ToDouble (&dValue))
 869     return (dValue);
 870   else
 871     return (m_dDefaultScanRatio);
 872 }
 873
 874 const char*
 875 DialogGetProjectionParameters::getGeometry ()
 876 {
 877   return m_pRadioBoxGeometry->getSelectionStringValue();
 878 }
 879
 880 int
 881 DialogGetProjectionParameters::getTrace ()
 882 {
 883   return Trace::convertTraceNameToID(m_pRadioBoxTrace->getSelectionStringValue());
 884 }
 885
 886
 887
 888 /////////////////////////////////////////////////////////////////////
 889 // CLASS IDENTIFICATION
 890 //
 891 // DialogGetReconstructionParameters
 892 /////////////////////////////////////////////////////////////////////
 893
 894
 895 DialogGetReconstructionParameters::DialogGetReconstructionParameters (wxWindow* pParent, int iDefaultXSize,
 896                      int iDefaultYSize, int iDefaultFilterID, double dDefaultHammingParam,
 897                      int iDefaultFilterMethodID, int iDefaultFilterGenerationID, int iDefaultZeropad,
 898                      int iDefaultInterpID, int iDefaultInterpParam, int iDefaultBackprojectID, int iTrace,
 899                      ReconstructionROI* pDefaultROI)
 900 : wxDialog (pParent, -1, _T("Reconstruction Parameters"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
 901 {
 902   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
 903
 904   m_iDefaultXSize = iDefaultXSize;
 905   m_iDefaultYSize = iDefaultYSize;
 906   m_dDefaultFilterParam = dDefaultHammingParam;
 907   m_iDefaultZeropad = iDefaultZeropad;
 908   m_iDefaultInterpParam = iDefaultInterpParam;
 909   m_dDefaultRoiXMin = pDefaultROI->m_dXMin;
 910   m_dDefaultRoiXMax = pDefaultROI->m_dXMax;
 911   m_dDefaultRoiYMin = pDefaultROI->m_dYMin;
 912   m_dDefaultRoiYMax = pDefaultROI->m_dYMax;
 913
 914   pTopSizer->Add (new wxStaticText (this, -1, "Filtered Backprojection Parameters"), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
 915   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
 916
 917   wxFlexGridSizer* pGridSizer = NULL;
 918   if (theApp->getAdvancedOptions())
 919     pGridSizer = new wxFlexGridSizer (4);
 920   else
 921     pGridSizer = new wxFlexGridSizer (3);
 922
 923   if (theApp->getAdvancedOptions())
 924     m_pRadioBoxFilter = new StringValueAndTitleRadioBox (this, _T("Filter"), SignalFilter::getFilterCount(), SignalFilter::getFilterTitleArray(), SignalFilter::getFilterNameArray());
 925   else
 926     m_pRadioBoxFilter = new StringValueAndTitleRadioBox (this, _T("Filter"), SignalFilter::getReconstructFilterCount(), SignalFilter::getFilterTitleArray(), SignalFilter::getFilterNameArray());
 927   m_pRadioBoxFilter->SetSelection (iDefaultFilterID);
 928   pGridSizer->Add (m_pRadioBoxFilter, 0, wxALL | wxALIGN_LEFT | wxEXPAND);
 929
 930   if (theApp->getAdvancedOptions()) {
 931     m_pRadioBoxFilterMethod = new StringValueAndTitleRadioBox (this, _T("Filter Method"), ProcessSignal::getFilterMethodCount(), ProcessSignal::getFilterMethodTitleArray(), ProcessSignal::getFilterMethodNameArray());
 932     m_pRadioBoxFilterMethod->SetSelection (iDefaultFilterMethodID);
 933     pGridSizer->Add (m_pRadioBoxFilterMethod, 0, wxALL | wxALIGN_LEFT | wxEXPAND);
 934   } else {
 935 #if HAVE_FFTW
 936     static const char* aszFilterMethodTitle[] = {"Convolution", "FFT"};
 937     static const char* aszFilterMethodName[] = {"convolution", "rfftw"};
 938 #else
 939     static const char* aszFilterMethodTitle[] = {"Convolution", "Fourier"};
 940     static const char* aszFilterMethodName[] = {"convolution", "fourier-table"};
 941 #endif
 942       m_pRadioBoxFilterMethod = new StringValueAndTitleRadioBox (this, _T("Filter Method"), 2, aszFilterMethodTitle, aszFilterMethodName);
 943 #if HAVE_FFTW
 944       m_pRadioBoxFilterMethod->SetSelection (1);
 945 #else
 946       m_pRadioBoxFilterMethod->SetSelection (0);
 947 #endif
 948       pGridSizer->Add (m_pRadioBoxFilterMethod, 0, wxALL | wxALIGN_LEFT | wxEXPAND);
 949   }
 950
 951   if (theApp->getAdvancedOptions()) {
 952     m_pRadioBoxFilterGeneration = new StringValueAndTitleRadioBox (this, _T("Filter Generation"), ProcessSignal::getFilterGenerationCount(), ProcessSignal::getFilterGenerationTitleArray(), ProcessSignal::getFilterGenerationNameArray());
 953     m_pRadioBoxFilterGeneration->SetSelection (iDefaultFilterGenerationID);
 954     pGridSizer->Add (m_pRadioBoxFilterGeneration, 0, wxALL | wxALIGN_LEFT | wxEXPAND);
 955
 956     m_pRadioBoxBackproject = new StringValueAndTitleRadioBox (this, _T("Backprojection"), Backprojector::getBackprojectCount(), Backprojector::getBackprojectTitleArray(), Backprojector::getBackprojectNameArray());
 957     m_pRadioBoxBackproject->SetSelection (iDefaultBackprojectID);
 958     pGridSizer->Add (m_pRadioBoxBackproject, 0, wxALL | wxALIGN_RIGHT | wxEXPAND);
 959   }
 960
 961   m_pRadioBoxInterp = new StringValueAndTitleRadioBox (this, _T("Interpolation"), Backprojector::getInterpCount(), Backprojector::getInterpTitleArray(), Backprojector::getInterpNameArray());
 962   m_pRadioBoxInterp->SetSelection (iDefaultInterpID);
 963   pGridSizer->Add (m_pRadioBoxInterp, 0, wxALL | wxALIGN_RIGHT | wxEXPAND);
 964
 965   static const char* aszTraceTitle[] = {"None", "Full"};
 966   static const char* aszTraceName[] = {"none", "full"};
 967   m_pRadioBoxTrace = new StringValueAndTitleRadioBox (this, _T("Trace Level"), 2, aszTraceTitle, aszTraceName);
 968   iTrace = clamp(iTrace, 0, 1);
 969   m_pRadioBoxTrace->SetSelection (iTrace);
 970   pGridSizer->Add (m_pRadioBoxTrace);
 971
 972   wxFlexGridSizer* pTextGridSizer = new wxFlexGridSizer (2);
 973   std::ostringstream os;
 974   os << iDefaultXSize;
 975   m_pTextCtrlXSize = new wxTextCtrl (this, -1, os.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 976   pTextGridSizer->Add (new wxStaticText (this, -1, "X Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 977   pTextGridSizer->Add (m_pTextCtrlXSize, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
 978   std::ostringstream osYSize;
 979   osYSize << iDefaultYSize;
 980   m_pTextCtrlYSize = new wxTextCtrl (this, -1, osYSize.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 981   pTextGridSizer->Add (new wxStaticText (this, -1, "Y Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 982   pTextGridSizer->Add (m_pTextCtrlYSize, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
 983
 984   std::ostringstream osHammingParam;
 985   osHammingParam << dDefaultHammingParam;
 986   m_pTextCtrlFilterParam = new wxTextCtrl (this, -1, osHammingParam.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 987   pTextGridSizer->Add (new wxStaticText (this, -1, "Hamming Parameter"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 988   pTextGridSizer->Add (m_pTextCtrlFilterParam, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
 989
 990   if (theApp->getAdvancedOptions()) {
 991     std::ostringstream osZeropad;
 992     osZeropad << iDefaultZeropad;
 993     m_pTextCtrlZeropad = new wxTextCtrl (this, -1, osZeropad.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
 994     pTextGridSizer->Add (new wxStaticText (this, -1, "Zeropad"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
 995     pTextGridSizer->Add (m_pTextCtrlZeropad, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
 996   }
 997   pGridSizer->Add (pTextGridSizer);
 998
 999 #if HAVE_FREQ_PREINTERP
1000   std::ostringstream osInterpParam;
1001   osInterpParam << iDefaultInterpParam;
1002   m_pTextCtrlInterpParam = new wxTextCtrl (this, -1, osInterpParam.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1003   pGridSizer->Add (new wxStaticText (this, -1, "Interpolation Parameter"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1004   pGridSizer->Add (m_pTextCtrlInterpParam, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1005 #endif
1006
1007   if (theApp->getAdvancedOptions()) {
1008     wxFlexGridSizer* pROIGridSizer = new wxFlexGridSizer (2);
1009     std::ostringstream osRoiXMin;
1010     osRoiXMin << m_dDefaultRoiXMin;
1011     m_pTextCtrlRoiXMin = new wxTextCtrl (this, -1, osRoiXMin.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1012     pROIGridSizer->Add (new wxStaticText (this, -1, "ROI XMin"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1013     pROIGridSizer->Add (m_pTextCtrlRoiXMin, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1014     std::ostringstream osRoiXMax;
1015     osRoiXMax << m_dDefaultRoiXMax;
1016     m_pTextCtrlRoiXMax = new wxTextCtrl (this, -1, osRoiXMax.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1017     pROIGridSizer->Add (new wxStaticText (this, -1, "ROI XMax"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1018     pROIGridSizer->Add (m_pTextCtrlRoiXMax, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1019     std::ostringstream osRoiYMin;
1020     osRoiYMin << m_dDefaultRoiYMin;
1021     m_pTextCtrlRoiYMin = new wxTextCtrl (this, -1, osRoiYMin.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1022     pROIGridSizer->Add (new wxStaticText (this, -1, "ROI YMin"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1023     pROIGridSizer->Add (m_pTextCtrlRoiYMin, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1024     std::ostringstream osRoiYMax;
1025     osRoiYMax << m_dDefaultRoiYMax;
1026     m_pTextCtrlRoiYMax = new wxTextCtrl (this, -1, osRoiYMax.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1027     pROIGridSizer->Add (new wxStaticText (this, -1, "ROI YMax"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1028     pROIGridSizer->Add (m_pTextCtrlRoiYMax, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1029
1030     pGridSizer->Add (pROIGridSizer);
1031   }
1032
1033   pTopSizer->Add (pGridSizer, 1, wxALL, 3);
1034
1035   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1036
1037   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
1038   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
1039   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
1040   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
1041   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
1042   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_RECONSTRUCTION);
1043   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
1044
1045   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
1046   pButtonOk->SetDefault();
1047
1048   SetAutoLayout (true);
1049   SetSizer (pTopSizer);
1050   pTopSizer->Layout();
1051   pTopSizer->Fit (this);
1052   pTopSizer->SetSizeHints (this);
1053 }
1054
1055 DialogGetReconstructionParameters::~DialogGetReconstructionParameters ()
1056 {
1057 }
1058
1059
1060 unsigned int
1061 DialogGetReconstructionParameters::getXSize ()
1062 {
1063   wxString strCtrl = m_pTextCtrlXSize->GetValue();
1064   unsigned long lValue;
1065   if (strCtrl.ToULong (&lValue))
1066     return lValue;
1067   else
1068     return (m_iDefaultXSize);
1069 }
1070
1071 unsigned int
1072 DialogGetReconstructionParameters::getYSize ()
1073 {
1074   wxString strCtrl = m_pTextCtrlYSize->GetValue();
1075   unsigned long lValue;
1076   if (strCtrl.ToULong (&lValue))
1077     return lValue;
1078   else
1079     return (m_iDefaultYSize);
1080 }
1081
1082 unsigned int
1083 DialogGetReconstructionParameters::getZeropad ()
1084 {
1085   if (theApp->getAdvancedOptions()) {
1086     wxString strCtrl = m_pTextCtrlZeropad->GetValue();
1087     unsigned long lValue;
1088     if (strCtrl.ToULong (&lValue))
1089       return lValue;
1090     else
1091       return (m_iDefaultZeropad);
1092   } else
1093     return 1;
1094 }
1095
1096
1097 unsigned int
1098 DialogGetReconstructionParameters::getInterpParam ()
1099 {
1100 #if HAVE_FREQ_PREINTERP
1101   wxString strCtrl = m_pTextCtrlInterpParam->GetValue();
1102   unsigned long lValue;
1103   if (strCtrl.ToULong (&lValue))
1104     return lValue;
1105   else
1106     return (m_iDefaultInterpParam);
1107 #else
1108   return 1;
1109 #endif
1110 }
1111
1112 double
1113 DialogGetReconstructionParameters::getFilterParam ()
1114 {
1115   wxString strCtrl = m_pTextCtrlFilterParam->GetValue();
1116   double dValue;
1117   if (strCtrl.ToDouble (&dValue))
1118     return (dValue);
1119   else
1120     return (m_dDefaultFilterParam);
1121 }
1122
1123 const char*
1124 DialogGetReconstructionParameters::getFilterName ()
1125 {
1126   return m_pRadioBoxFilter->getSelectionStringValue();
1127 }
1128
1129 const char*
1130 DialogGetReconstructionParameters::getFilterMethodName ()
1131 {
1132   return m_pRadioBoxFilterMethod->getSelectionStringValue();
1133 }
1134
1135 const char*
1136 DialogGetReconstructionParameters::getInterpName ()
1137 {
1138   return m_pRadioBoxInterp->getSelectionStringValue();
1139 }
1140
1141 int
1142 DialogGetReconstructionParameters::getTrace ()
1143 {
1144   int iTrace = 0;
1145   if (strcmp("full", m_pRadioBoxTrace->getSelectionStringValue()) == 0)
1146     iTrace = Trace::TRACE_PLOT;
1147   return iTrace;
1148 }
1149
1150 const char*
1151 DialogGetReconstructionParameters::getBackprojectName ()
1152 {
1153   if (theApp->getAdvancedOptions()) {
1154     return m_pRadioBoxBackproject->getSelectionStringValue();
1155   } else
1156     return "idiff";
1157 }
1158
1159 const char*
1160 DialogGetReconstructionParameters::getFilterGenerationName ()
1161 {
1162   if (theApp->getAdvancedOptions()) {
1163     return m_pRadioBoxFilterGeneration->getSelectionStringValue();
1164   } else {
1165     if (ProcessSignal::convertFilterMethodNameToID(m_pRadioBoxFilterMethod->getSelectionStringValue())
1166         == ProcessSignal::FILTER_METHOD_CONVOLUTION)
1167       return "direct";
1168     else
1169       return "inverse-fourier";
1170   }
1171 }
1172
1173 void
1174 DialogGetReconstructionParameters::getROI (ReconstructionROI* pROI)
1175 {
1176   if (theApp->getAdvancedOptions()) {
1177     double dValue;
1178     if (m_pTextCtrlRoiXMin->GetValue().ToDouble (&dValue))
1179       pROI->m_dXMin = dValue;
1180     else
1181       pROI->m_dXMin = m_dDefaultRoiXMin;
1182
1183     if (m_pTextCtrlRoiXMax->GetValue().ToDouble (&dValue))
1184       pROI->m_dXMax = dValue;
1185     else
1186       pROI->m_dXMax = m_dDefaultRoiXMax;
1187
1188     if (m_pTextCtrlRoiYMin->GetValue().ToDouble (&dValue))
1189       pROI->m_dYMin = dValue;
1190     else
1191       pROI->m_dYMin = m_dDefaultRoiYMin;
1192
1193     if (m_pTextCtrlRoiYMax->GetValue().ToDouble (&dValue))
1194       pROI->m_dYMax = dValue;
1195     else
1196       pROI->m_dYMax = m_dDefaultRoiYMax;
1197   } else {
1198     pROI->m_dXMin = m_dDefaultRoiXMin;
1199     pROI->m_dXMax = m_dDefaultRoiXMax;
1200     pROI->m_dYMin = m_dDefaultRoiYMin;
1201     pROI->m_dYMax = m_dDefaultRoiYMax;
1202   }
1203 }
1204
1205 /////////////////////////////////////////////////////////////////////
1206 // CLASS IDENTIFICATION
1207 //
1208 // DialogGetFilterParameters
1209 /////////////////////////////////////////////////////////////////////
1210
1211
1212
1213 DialogGetFilterParameters::DialogGetFilterParameters (wxWindow* pParent, int iDefaultXSize, int iDefaultYSize, int iDefaultFilterID, double dDefaultFilterParam,  double dDefaultBandwidth, int iDefaultDomainID, double dDefaultInputScale, double dDefaultOutputScale)
1214 : wxDialog (pParent, -1, _T("Filter Parameters"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
1215 {
1216   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
1217
1218   pTopSizer->Add (new wxStaticText (this, -1, "Filter Parameters"), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
1219   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1220
1221   wxFlexGridSizer* pGridSizer = new wxFlexGridSizer (2);
1222
1223   m_pRadioBoxFilter = new StringValueAndTitleRadioBox (this, _T("Filter"), SignalFilter::getFilterCount(), SignalFilter::getFilterTitleArray(), SignalFilter::getFilterNameArray());
1224   m_pRadioBoxFilter->SetSelection (iDefaultFilterID);
1225   pGridSizer->Add (m_pRadioBoxFilter, 0, wxALL | wxALIGN_LEFT | wxEXPAND);
1226
1227   m_pRadioBoxDomain = new StringValueAndTitleRadioBox (this, _T("Domain"), SignalFilter::getDomainCount(), SignalFilter::getDomainTitleArray(), SignalFilter::getDomainNameArray());
1228   m_pRadioBoxDomain->SetSelection (iDefaultDomainID);
1229   pGridSizer->Add (m_pRadioBoxDomain, 0, wxALL | wxALIGN_LEFT | wxEXPAND);
1230
1231   std::ostringstream os;
1232   os << iDefaultXSize;
1233   m_pTextCtrlXSize = new wxTextCtrl (this, -1, os.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1234   pGridSizer->Add (new wxStaticText (this, -1, "X Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1235   pGridSizer->Add (m_pTextCtrlXSize, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1236
1237   std::ostringstream osYSize;
1238   osYSize << iDefaultYSize;
1239   m_pTextCtrlYSize = new wxTextCtrl (this, -1, osYSize.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1240   pGridSizer->Add (new wxStaticText (this, -1, "Y Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1241   pGridSizer->Add (m_pTextCtrlYSize, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1242
1243   std::ostringstream osFilterParam;
1244   osFilterParam << dDefaultFilterParam;
1245   m_pTextCtrlFilterParam = new wxTextCtrl (this, -1, osFilterParam.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1246   pGridSizer->Add (new wxStaticText (this, -1, "Filter Parameter"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1247   pGridSizer->Add (m_pTextCtrlFilterParam, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1248
1249   std::ostringstream osBandwidth;
1250   osBandwidth << dDefaultBandwidth;
1251   m_pTextCtrlBandwidth = new wxTextCtrl (this, -1, osBandwidth.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1252   pGridSizer->Add (new wxStaticText (this, -1, "Bandwidth"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1253   pGridSizer->Add (m_pTextCtrlBandwidth, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1254
1255   std::ostringstream osInputScale;
1256   osInputScale << dDefaultInputScale;
1257   m_pTextCtrlInputScale = new wxTextCtrl (this, -1, osInputScale.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1258   pGridSizer->Add (new wxStaticText (this, -1, "Axis (input) Scale"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1259   pGridSizer->Add (m_pTextCtrlInputScale, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1260
1261   std::ostringstream osOutputScale;
1262   osOutputScale << dDefaultOutputScale;
1263   m_pTextCtrlOutputScale = new wxTextCtrl (this, -1, osOutputScale.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1264   pGridSizer->Add (new wxStaticText (this, -1, "Filter Output Scale"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1265   pGridSizer->Add (m_pTextCtrlOutputScale, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1266
1267   pTopSizer->Add (pGridSizer, 1, wxALL, 3);
1268
1269   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1270
1271   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
1272   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
1273   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
1274   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
1275   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
1276   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_FILTER);
1277   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
1278
1279   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
1280   pButtonOk->SetDefault();
1281
1282   SetAutoLayout (true);
1283   SetSizer (pTopSizer);
1284   pTopSizer->Layout();
1285   pTopSizer->Fit (this);
1286   pTopSizer->SetSizeHints (this);
1287 }
1288
1289 DialogGetFilterParameters::~DialogGetFilterParameters ()
1290 {
1291 }
1292
1293
1294 unsigned int
1295 DialogGetFilterParameters::getXSize ()
1296 {
1297   wxString strCtrl = m_pTextCtrlXSize->GetValue();
1298   unsigned long lValue;
1299   if (strCtrl.ToULong (&lValue))
1300     return lValue;
1301   else
1302     return (m_iDefaultXSize);
1303 }
1304
1305 unsigned int
1306 DialogGetFilterParameters::getYSize ()
1307 {
1308   wxString strCtrl = m_pTextCtrlYSize->GetValue();
1309   unsigned long lValue;
1310   if (strCtrl.ToULong (&lValue))
1311     return lValue;
1312   else
1313     return (m_iDefaultYSize);
1314 }
1315
1316 double
1317 DialogGetFilterParameters::getBandwidth ()
1318 {
1319   wxString strCtrl = m_pTextCtrlBandwidth->GetValue();
1320   double dValue;
1321   if (strCtrl.ToDouble (&dValue))
1322     return dValue;
1323   else
1324     return (m_dDefaultBandwidth);
1325 }
1326
1327 double
1328 DialogGetFilterParameters::getFilterParam ()
1329 {
1330   wxString strCtrl = m_pTextCtrlFilterParam->GetValue();
1331   double dValue;
1332   if (strCtrl.ToDouble (&dValue))
1333     return (dValue);
1334   else
1335     return (m_dDefaultFilterParam);
1336 }
1337
1338 double
1339 DialogGetFilterParameters::getInputScale ()
1340 {
1341   wxString strCtrl = m_pTextCtrlInputScale->GetValue();
1342   double dValue;
1343   if (strCtrl.ToDouble (&dValue))
1344     return dValue;
1345   else
1346     return (m_dDefaultInputScale);
1347 }
1348
1349 double
1350 DialogGetFilterParameters::getOutputScale ()
1351 {
1352   wxString strCtrl = m_pTextCtrlOutputScale->GetValue();
1353   double dValue;
1354   if (strCtrl.ToDouble (&dValue))
1355     return dValue;
1356   else
1357     return (m_dDefaultOutputScale);
1358 }
1359
1360 const char*
1361 DialogGetFilterParameters::getFilterName ()
1362 {
1363   return m_pRadioBoxFilter->getSelectionStringValue();
1364 }
1365
1366 const char*
1367 DialogGetFilterParameters::getDomainName ()
1368 {
1369   return m_pRadioBoxDomain->getSelectionStringValue();
1370 }
1371
1372
1373 ///////////////////////////////////////////////////////////////////////
1374 // CLASS IMPLEMENTATION
1375 //    DialogExportParameters
1376 ///////////////////////////////////////////////////////////////////////
1377
1378 DialogExportParameters::DialogExportParameters (wxWindow* pParent, int iDefaultFormatID)
1379 : wxDialog (pParent, -1, _T("Select ExportParameters"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
1380 {
1381   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
1382
1383   pTopSizer->Add (new wxStaticText (this, -1, "Select Export Format"), 0, wxALIGN_CENTER | wxALL, 5);
1384
1385   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxALL, 5);
1386
1387   m_pRadioBoxFormat = new StringValueAndTitleRadioBox (this, _T("File Type"),
1388     ImageFile::getExportFormatCount(), ImageFile::getExportFormatTitleArray(), ImageFile::getExportFormatNameArray());
1389   m_pRadioBoxFormat->SetSelection (iDefaultFormatID);
1390   pTopSizer->Add (m_pRadioBoxFormat, 0, wxALL | wxALIGN_CENTER);
1391
1392   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1393
1394   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
1395   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
1396   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
1397   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
1398   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
1399   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_EXPORT);
1400   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
1401
1402   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
1403   pButtonOk->SetDefault();
1404
1405   SetAutoLayout (true);
1406   SetSizer (pTopSizer);
1407   pTopSizer->Fit (this);
1408   pTopSizer->SetSizeHints (this);
1409 }
1410
1411 const char*
1412 DialogExportParameters::getFormatName()
1413 {
1414   return m_pRadioBoxFormat->getSelectionStringValue();
1415 }
1416
1417
1418 ///////////////////////////////////////////////////////////////////////
1419 // CLASS IMPLEMENTATION
1420 //    DialogImportParameters
1421 ///////////////////////////////////////////////////////////////////////
1422
1423 DialogImportParameters::DialogImportParameters (wxWindow* pParent, int iDefaultFormatID)
1424 : wxDialog (pParent, -1, _T("Select Import Parameters"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
1425 {
1426   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
1427
1428   pTopSizer->Add (new wxStaticText (this, -1, "Select Import Format"), 0, wxALIGN_CENTER | wxALL, 5);
1429
1430   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxALL, 5);
1431
1432   m_pRadioBoxFormat = new StringValueAndTitleRadioBox (this, _T("File Type"),
1433     ImageFile::getImportFormatCount(), ImageFile::getImportFormatTitleArray(), ImageFile::getImportFormatNameArray());
1434   m_pRadioBoxFormat->SetSelection (iDefaultFormatID);
1435   pTopSizer->Add (m_pRadioBoxFormat, 0, wxALL | wxALIGN_CENTER);
1436
1437   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1438
1439   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
1440   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
1441   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
1442   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
1443   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
1444   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, IDH_DLG_IMPORT);
1445   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
1446
1447   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
1448   pButtonOk->SetDefault();
1449
1450   SetAutoLayout (true);
1451   SetSizer (pTopSizer);
1452   pTopSizer->Fit (this);
1453   pTopSizer->SetSizeHints (this);
1454 }
1455
1456 const char*
1457 DialogImportParameters::getFormatName()
1458 {
1459   return m_pRadioBoxFormat->getSelectionStringValue();
1460 }
1461
1462
1463 /////////////////////////////////////////////////////////////////////
1464 // CLASS DiaglogGetXYSize Implementation
1465 /////////////////////////////////////////////////////////////////////
1466
1467 DialogGetXYSize::DialogGetXYSize (wxWindow* pParent, const char* const pszTitle, int iDefaultXSize, int iDefaultYSize)
1468 : wxDialog (pParent, -1, _T(pszTitle), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
1469 {
1470   m_iDefaultXSize = iDefaultXSize;
1471   m_iDefaultYSize = iDefaultYSize;
1472
1473   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
1474
1475   pTopSizer->Add (new wxStaticText (this, -1, pszTitle), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
1476
1477   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1478
1479   std::ostringstream os;
1480   os << iDefaultXSize;
1481   m_pTextCtrlXSize = new wxTextCtrl (this, -1, os.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1482   std::ostringstream osYSize;
1483   osYSize << iDefaultYSize;
1484   m_pTextCtrlYSize = new wxTextCtrl (this, -1, osYSize.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1485
1486   wxFlexGridSizer *pGridSizer = new wxFlexGridSizer (2);
1487   pGridSizer->Add (new wxStaticText (this, -1, "X Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1488   pGridSizer->Add (m_pTextCtrlXSize, 0, wxALIGN_CENTER_VERTICAL);
1489   pGridSizer->Add (new wxStaticText (this, -1, "Y Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1490   pGridSizer->Add (m_pTextCtrlYSize, 0, wxALIGN_CENTER_VERTICAL);
1491   pTopSizer->Add (pGridSizer, 1, wxALL, 10);
1492
1493   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1494
1495   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
1496   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
1497   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
1498   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
1499   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
1500
1501   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
1502   pButtonOk->SetDefault();
1503
1504   SetAutoLayout (true);
1505   SetSizer (pTopSizer);
1506   pTopSizer->Fit (this);
1507   pTopSizer->SetSizeHints (this);
1508 }
1509
1510 DialogGetXYSize::~DialogGetXYSize ()
1511 {
1512 }
1513
1514 unsigned int
1515 DialogGetXYSize::getXSize ()
1516 {
1517   wxString strCtrl = m_pTextCtrlXSize->GetValue();
1518   long lValue;
1519   if (strCtrl.ToLong (&lValue))
1520     return lValue;
1521   else
1522     return (m_iDefaultXSize);
1523 }
1524
1525 unsigned int
1526 DialogGetXYSize::getYSize ()
1527 {
1528   wxString strCtrl = m_pTextCtrlYSize->GetValue();
1529   long lValue;
1530   if (strCtrl.ToLong (&lValue))
1531     return lValue;
1532   else
1533     return (m_iDefaultYSize);
1534 }
1535
1536
1537
1538 /////////////////////////////////////////////////////////////////////
1539 // CLASS IDENTIFICATION
1540 //
1541 // DialogGetConvertPolarParameters
1542 /////////////////////////////////////////////////////////////////////
1543
1544 DialogGetConvertPolarParameters::DialogGetConvertPolarParameters (wxWindow* pParent, const char* const pszTitle,
1545        int iDefaultXSize, int iDefaultYSize, int iDefaultInterpolationID, int iDefaultZeropad, int iHelpID)
1546 : wxDialog (pParent, -1, _T(pszTitle), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxCAPTION)
1547 {
1548   m_iDefaultXSize = iDefaultXSize;
1549   m_iDefaultYSize = iDefaultYSize;
1550   m_iDefaultZeropad = iDefaultZeropad;
1551
1552   wxBoxSizer* pTopSizer = new wxBoxSizer (wxVERTICAL);
1553
1554   pTopSizer->Add (new wxStaticText (this, -1, pszTitle), 0, wxALIGN_CENTER | wxTOP | wxLEFT | wxRIGHT, 5);
1555   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1556
1557   wxFlexGridSizer* pGridSizer = new wxFlexGridSizer (1);
1558
1559   m_pRadioBoxInterpolation = new StringValueAndTitleRadioBox (this, _T("Interpolation"), Projections::getInterpCount(), Projections::getInterpTitleArray(), Projections::getInterpNameArray());
1560   m_pRadioBoxInterpolation->SetSelection (iDefaultInterpolationID);
1561   pGridSizer->Add (m_pRadioBoxInterpolation, 0, wxALL | wxALIGN_CENTER);
1562
1563   wxFlexGridSizer* pTextGridSizer = new wxFlexGridSizer (2);
1564   std::ostringstream os;
1565   os << iDefaultXSize;
1566   m_pTextCtrlXSize = new wxTextCtrl (this, -1, os.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1567   pTextGridSizer->Add (new wxStaticText (this, -1, "X Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1568   pTextGridSizer->Add (m_pTextCtrlXSize, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1569   std::ostringstream osYSize;
1570   osYSize << iDefaultYSize;
1571   m_pTextCtrlYSize = new wxTextCtrl (this, -1, osYSize.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1572   pTextGridSizer->Add (new wxStaticText (this, -1, "Y Size"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1573   pTextGridSizer->Add (m_pTextCtrlYSize, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1574   if (m_iDefaultZeropad >= 0) {
1575     std::ostringstream osZeropad;
1576     osZeropad << iDefaultZeropad;
1577     m_pTextCtrlZeropad = new wxTextCtrl (this, -1, osZeropad.str().c_str(), wxDefaultPosition, wxSize(100, 25), 0);
1578     pTextGridSizer->Add (new wxStaticText (this, -1, "Zeropad"), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
1579     pTextGridSizer->Add (m_pTextCtrlZeropad, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
1580   }
1581
1582   pGridSizer->Add (pTextGridSizer, 0, wxALIGN_CENTER | wxALL);
1583
1584   pTopSizer->Add (pGridSizer, 1, wxALL | wxALIGN_CENTER, 3);
1585
1586   pTopSizer->Add (new wxStaticLine (this, -1, wxDefaultPosition, wxSize(3,3), wxHORIZONTAL), 0, wxEXPAND | wxALL, 5);
1587
1588   wxBoxSizer* pButtonSizer = new wxBoxSizer (wxHORIZONTAL);
1589   wxButton* pButtonOk = new wxButton (this, wxID_OK, "Okay");
1590   pButtonSizer->Add (pButtonOk, 0, wxEXPAND | wxALL, 10);
1591   wxButton* pButtonCancel = new wxButton (this, wxID_CANCEL, "Cancel");
1592   pButtonSizer->Add (pButtonCancel, 0, wxEXPAND | wxALL, 10);
1593   CTSimHelpButton* pButtonHelp = new CTSimHelpButton (this, iHelpID);
1594   pButtonSizer->Add (pButtonHelp, 0, wxEXPAND | wxALL, 10);
1595
1596   pTopSizer->Add (pButtonSizer, 0, wxALIGN_CENTER);
1597   pButtonOk->SetDefault();
1598   SetAutoLayout (true);
1599   SetSizer (pTopSizer);
1600   pTopSizer->Layout();
1601   pTopSizer->Fit (this);
1602   pTopSizer->SetSizeHints (this);
1603 }
1604
1605
1606 DialogGetConvertPolarParameters::~DialogGetConvertPolarParameters ()
1607 {
1608 }
1609
1610
1611 unsigned int
1612 DialogGetConvertPolarParameters::getXSize ()
1613 {
1614   wxString strCtrl = m_pTextCtrlXSize->GetValue();
1615   unsigned long lValue;
1616   if (strCtrl.ToULong (&lValue))
1617     return lValue;
1618   else
1619     return (m_iDefaultXSize);
1620 }
1621
1622 unsigned int
1623 DialogGetConvertPolarParameters::getYSize ()
1624 {
1625   wxString strCtrl = m_pTextCtrlYSize->GetValue();
1626   unsigned long lValue;
1627   if (strCtrl.ToULong (&lValue))
1628     return lValue;
1629   else
1630     return (m_iDefaultYSize);
1631 }
1632
1633 unsigned int
1634 DialogGetConvertPolarParameters::getZeropad ()
1635 {
1636   if (m_iDefaultZeropad >= 0) {
1637     wxString strCtrl = m_pTextCtrlZeropad->GetValue();
1638     unsigned long lValue;
1639     if (strCtrl.ToULong (&lValue))
1640       return lValue;
1641     else
1642       return (m_iDefaultZeropad);
1643   } else
1644     return 0;
1645 }
1646
1647 const char*
1648 DialogGetConvertPolarParameters::getInterpolationName ()
1649 {
1650   return m_pRadioBoxInterpolation->getSelectionStringValue();
1651 }
1652