src/views.cpp

   1 /*****************************************************************************
   2 ** FILE IDENTIFICATION
   3 **
   4 **   Name:          view.cpp
   5 **   Purpose:       View & Canvas 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-2000 Kevin Rosenberg
  11 **
  12 **  $Id: views.cpp,v 1.71 2001/01/26 05:37:24 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 // For compilers that support precompilation, includes "wx/wx.h".
  29 #include "wx/wxprec.h"
  30
  31 #ifdef __BORLANDC__
  32 #pragma hdrstop
  33 #endif
  34
  35 #ifndef WX_PRECOMP
  36 #include "wx/wx.h"
  37 #endif
  38
  39 #if !wxUSE_DOC_VIEW_ARCHITECTURE
  40 #error You must set wxUSE_DOC_VIEW_ARCHITECTURE to 1 in setup.h!
  41 #endif
  42
  43 #include "wx/image.h"
  44 #include "wx/progdlg.h"
  45
  46 #include "ct.h"
  47 #include "ctsim.h"
  48 #include "docs.h"
  49 #include "views.h"
  50 #include "dialogs.h"
  51 #include "dlgprojections.h"
  52 #include "dlgreconstruct.h"
  53 #include "backprojectors.h"
  54 #include "reconstruct.h"
  55 #include "timer.h"
  56
  57 #if defined(MSVC) || HAVE_SSTREAM
  58 #include <sstream>
  59 #else
  60 #include <sstream_subst>
  61 #endif
  62
  63
  64 // ImageFileCanvas
  65
  66 BEGIN_EVENT_TABLE(ImageFileCanvas, wxScrolledWindow)
  67 EVT_MOUSE_EVENTS(ImageFileCanvas::OnMouseEvent)
  68 END_EVENT_TABLE()
  69
  70
  71 ImageFileCanvas::ImageFileCanvas (ImageFileView* v, wxFrame *frame, const wxPoint& pos, const wxSize& size, const long style)
  72 : wxScrolledWindow(frame, -1, pos, size, style)
  73 {
  74   m_pView = v;
  75   m_xCursor = -1;
  76   m_yCursor = -1;
  77 }
  78
  79 ImageFileCanvas::~ImageFileCanvas()
  80 {
  81   if (m_pView) {
  82     wxMenu* pMenu = m_pView->getFileMenu();
  83     theApp->getDocManager()->FileHistoryRemoveMenu (pMenu);
  84     m_pView->canvasClosed();
  85     m_pView = NULL;
  86   }
  87 }
  88
  89 void
  90 ImageFileCanvas::OnDraw(wxDC& dc)
  91 {
  92   if (m_pView)
  93     m_pView->OnDraw(& dc);
  94 }
  95
  96 void
  97 ImageFileCanvas::DrawRubberBandCursor (wxDC& dc, int x, int y)
  98 {
  99   const ImageFile& rIF = m_pView->GetDocument()->getImageFile();
 100   int nx = rIF.nx();
 101   int ny = rIF.ny();
 102
 103   int yPt = ny - y - 1;
 104   dc.SetLogicalFunction (wxINVERT);
 105   dc.SetPen (*wxGREEN_PEN);
 106   dc.DrawLine (0, yPt, nx, yPt);
 107   dc.DrawLine (x, 0, x, ny);
 108   dc.SetLogicalFunction (wxCOPY);
 109 }
 110
 111 bool
 112 ImageFileCanvas::GetCurrentCursor (int& x, int& y)
 113 {
 114   x = m_xCursor;
 115   y = m_yCursor;
 116
 117   if (m_xCursor >= 0 && m_yCursor >= 0)
 118     return true;
 119   else
 120     return false;
 121 }
 122
 123 void
 124 ImageFileCanvas::OnMouseEvent(wxMouseEvent& event)
 125 {
 126   if (! m_pView)
 127     return;
 128
 129   wxClientDC dc(this);
 130   PrepareDC(dc);
 131
 132   wxPoint pt(event.GetLogicalPosition(dc));
 133
 134   const ImageFileDocument* pIFDoc = m_pView->GetDocument();
 135   if (! pIFDoc)
 136     return;
 137   const ImageFile& rIF = pIFDoc->getImageFile();
 138   ImageFileArrayConst v = rIF.getArray();
 139   int nx = rIF.nx();
 140   int ny = rIF.ny();
 141   const int yPt = ny - 1 - pt.y;
 142   if (event.RightIsDown()) {
 143     if (pt.x >= 0 && pt.x < nx && pt.y >= 0 && pt.y < ny) {
 144       std::ostringstream os;
 145       os << "Image value (" << pt.x << "," << yPt << ") = " << v[pt.x][yPt];
 146       if (rIF.isComplex()) {
 147         double dImag = rIF.getImaginaryArray()[pt.x][yPt];
 148         if (dImag < 0)
 149           os << " - " << -dImag;
 150         else
 151           os << " + " << dImag;
 152         os << "i\n";
 153       } else
 154         os << "\n";
 155       *theApp->getLog() << os.str().c_str();
 156     } else
 157       *theApp->getLog() << "Mouse out of image range (" << pt.x << "," << yPt << ")\n";
 158   }
 159   else if (event.LeftIsDown() || event.LeftUp() || event.RightUp()) {
 160     if (pt.x >= 0 && pt.x < nx && pt.y >= 0 && pt.y < ny) {
 161       if (m_xCursor >= 0 && m_yCursor >= 0) {
 162         DrawRubberBandCursor (dc, m_xCursor, m_yCursor);
 163       }
 164       DrawRubberBandCursor (dc, pt.x, yPt);
 165       m_xCursor = pt.x;
 166       m_yCursor = yPt;
 167     } else
 168       *theApp->getLog() << "Mouse out of image range (" << pt.x << "," << yPt << ")\n";
 169   }
 170   if (event.LeftUp()) {
 171     std::ostringstream os;
 172     os << "Selected column " << pt.x << " , row " << yPt << "\n";
 173     *theApp->getLog() << os.str().c_str();
 174   }
 175 }
 176
 177 wxSize
 178 ImageFileCanvas::GetBestSize() const
 179 {
 180   if (! m_pView)
 181     return wxSize(0,0);
 182
 183   const ImageFile& rIF = m_pView->GetDocument()->getImageFile();
 184   return wxSize (rIF.nx(), rIF.ny());
 185 }
 186
 187
 188 // ImageFileView
 189
 190 IMPLEMENT_DYNAMIC_CLASS(ImageFileView, wxView)
 191
 192 BEGIN_EVENT_TABLE(ImageFileView, wxView)
 193 EVT_MENU(IFMENU_FILE_EXPORT, ImageFileView::OnExport)
 194 EVT_MENU(IFMENU_FILE_PROPERTIES, ImageFileView::OnProperties)
 195 EVT_MENU(IFMENU_VIEW_SCALE_MINMAX, ImageFileView::OnScaleMinMax)
 196 EVT_MENU(IFMENU_VIEW_SCALE_AUTO, ImageFileView::OnScaleAuto)
 197 EVT_MENU(IFMENU_VIEW_SCALE_FULL, ImageFileView::OnScaleFull)
 198 EVT_MENU(IFMENU_COMPARE_IMAGES, ImageFileView::OnCompare)
 199 EVT_MENU(IFMENU_COMPARE_ROW, ImageFileView::OnCompareRow)
 200 EVT_MENU(IFMENU_COMPARE_COL, ImageFileView::OnCompareCol)
 201 EVT_MENU(IFMENU_FILTER_INVERTVALUES, ImageFileView::OnInvertValues)
 202 EVT_MENU(IFMENU_FILTER_SQUARE, ImageFileView::OnSquare)
 203 EVT_MENU(IFMENU_FILTER_SQRT, ImageFileView::OnSquareRoot)
 204 EVT_MENU(IFMENU_FILTER_LOG, ImageFileView::OnLog)
 205 EVT_MENU(IFMENU_FILTER_EXP, ImageFileView::OnExp)
 206 EVT_MENU(IFMENU_FILTER_FOURIER, ImageFileView::OnFourier)
 207 EVT_MENU(IFMENU_FILTER_INVERSE_FOURIER, ImageFileView::OnInverseFourier)
 208 EVT_MENU(IFMENU_FILTER_SHUFFLEFOURIERTONATURALORDER, ImageFileView::OnShuffleFourierToNaturalOrder)
 209 EVT_MENU(IFMENU_FILTER_SHUFFLENATURALTOFOURIERORDER, ImageFileView::OnShuffleNaturalToFourierOrder)
 210 EVT_MENU(IFMENU_IMAGE_ADD, ImageFileView::OnAdd)
 211 EVT_MENU(IFMENU_IMAGE_SUBTRACT, ImageFileView::OnSubtract)
 212 EVT_MENU(IFMENU_IMAGE_MULTIPLY, ImageFileView::OnMultiply)
 213 EVT_MENU(IFMENU_IMAGE_DIVIDE, ImageFileView::OnDivide)
 214 EVT_MENU(IFMENU_IMAGE_SCALESIZE, ImageFileView::OnScaleSize)
 215 #ifdef HAVE_FFT
 216 EVT_MENU(IFMENU_FILTER_FFT, ImageFileView::OnFFT)
 217 EVT_MENU(IFMENU_FILTER_IFFT, ImageFileView::OnIFFT)
 218 EVT_MENU(IFMENU_FILTER_FFT_ROWS, ImageFileView::OnFFTRows)
 219 EVT_MENU(IFMENU_FILTER_IFFT_ROWS, ImageFileView::OnIFFTRows)
 220 EVT_MENU(IFMENU_FILTER_FFT_COLS, ImageFileView::OnFFTCols)
 221 EVT_MENU(IFMENU_FILTER_IFFT_COLS, ImageFileView::OnIFFTCols)
 222 #endif
 223 EVT_MENU(IFMENU_FILTER_MAGNITUDE, ImageFileView::OnMagnitude)
 224 EVT_MENU(IFMENU_FILTER_PHASE, ImageFileView::OnPhase)
 225 EVT_MENU(IFMENU_PLOT_ROW, ImageFileView::OnPlotRow)
 226 EVT_MENU(IFMENU_PLOT_COL, ImageFileView::OnPlotCol)
 227 #ifdef HAVE_FFT
 228 EVT_MENU(IFMENU_PLOT_FFT_ROW, ImageFileView::OnPlotFFTRow)
 229 EVT_MENU(IFMENU_PLOT_FFT_COL, ImageFileView::OnPlotFFTCol)
 230 #endif
 231 EVT_MENU(IFMENU_PLOT_HISTOGRAM, ImageFileView::OnPlotHistogram)
 232 END_EVENT_TABLE()
 233
 234 ImageFileView::ImageFileView(void)
 235 : wxView(), m_canvas(NULL), m_frame(NULL), m_bMinSpecified(false), m_bMaxSpecified(false), m_pFileMenu(0)
 236 {
 237   m_iDefaultExportFormatID = ImageFile::FORMAT_PNG;
 238 }
 239
 240 ImageFileView::~ImageFileView(void)
 241 {
 242 }
 243
 244 void
 245 ImageFileView::OnProperties (wxCommandEvent& event)
 246 {
 247   const ImageFile& rIF = GetDocument()->getImageFile();
 248   if (rIF.nx() == 0 || rIF.ny() == 0)
 249     *theApp->getLog() << "Properties: empty imagefile\n";
 250   else {
 251     const std::string& rFilename = rIF.getFilename();
 252     std::ostringstream os;
 253     double min, max, mean, mode, median, stddev;
 254     rIF.statistics (rIF.getArray(), min, max, mean, mode, median, stddev);
 255     os << "Filename: " << rFilename << "\n";
 256     os << "Size: (" << rIF.nx() << "," << rIF.ny() << ")\n";
 257     os << "Data type: ";
 258     if (rIF.isComplex())
 259       os << "Complex\n";
 260     else
 261       os << "Real\n";
 262     os << "\nMinimum: "<<min<<"\nMaximum: "<<max<<"\nMean: "<<mean<<"\nMedian: "<<median<<"\nMode: "<<mode<<"\nStandard Deviation: "<<stddev << "\n";
 263     if (rIF.isComplex()) {
 264       rIF.statistics (rIF.getImaginaryArray(), min, max, mean, mode, median, stddev);
 265       os << "\nImaginary: min: "<<min<<"\nmax: "<<max<<"\nmean: "<<mean<<"\nmedian: "<<median<<"\nmode: "<<mode<<"\nstddev: "<<stddev << "\n";
 266     }
 267     if (rIF.nLabels() > 0) {
 268       os << "\n";
 269       rIF.printLabelsBrief (os);
 270     }
 271     *theApp->getLog() << os.str().c_str();
 272     wxMessageDialog dialogMsg (getFrameForChild(), os.str().c_str(), "Imagefile Properties", wxOK | wxICON_INFORMATION);
 273     dialogMsg.ShowModal();
 274   }
 275 }
 276
 277 void
 278 ImageFileView::OnScaleAuto (wxCommandEvent& event)
 279 {
 280   const ImageFile& rIF = GetDocument()->getImageFile();
 281   double min, max, mean, mode, median, stddev;
 282   rIF.statistics(min, max, mean, mode, median, stddev);
 283   DialogAutoScaleParameters dialogAutoScale (getFrameForChild(), mean, mode, median, stddev, m_dAutoScaleFactor);
 284   int iRetVal = dialogAutoScale.ShowModal();
 285   if (iRetVal == wxID_OK) {
 286     m_bMinSpecified = true;
 287     m_bMaxSpecified = true;
 288     double dMin, dMax;
 289     if (dialogAutoScale.getMinMax (&dMin, &dMax)) {
 290       m_dMinPixel = dMin;
 291       m_dMaxPixel = dMax;
 292       m_dAutoScaleFactor = dialogAutoScale.getAutoScaleFactor();
 293       OnUpdate (this, NULL);
 294     }
 295   }
 296 }
 297
 298 void
 299 ImageFileView::OnScaleMinMax (wxCommandEvent& event)
 300 {
 301   const ImageFile& rIF = GetDocument()->getImageFile();
 302   double min, max;
 303   if (! m_bMinSpecified && ! m_bMaxSpecified)
 304     rIF.getMinMax (min, max);
 305
 306   if (m_bMinSpecified)
 307     min = m_dMinPixel;
 308   if (m_bMaxSpecified)
 309     max = m_dMaxPixel;
 310
 311   DialogGetMinMax dialogMinMax (getFrameForChild(), "Set Image Minimum & Maximum", min, max);
 312   int retVal = dialogMinMax.ShowModal();
 313   if (retVal == wxID_OK) {
 314     m_bMinSpecified = true;
 315     m_bMaxSpecified = true;
 316     m_dMinPixel = dialogMinMax.getMinimum();
 317     m_dMaxPixel = dialogMinMax.getMaximum();
 318     OnUpdate (this, NULL);
 319   }
 320 }
 321
 322 void
 323 ImageFileView::OnScaleFull (wxCommandEvent& event)
 324 {
 325   if (m_bMinSpecified || m_bMaxSpecified) {
 326     m_bMinSpecified = false;
 327     m_bMaxSpecified = false;
 328     OnUpdate (this, NULL);
 329   }
 330 }
 331
 332 void
 333 ImageFileView::OnCompare (wxCommandEvent& event)
 334 {
 335   std::vector<ImageFileDocument*> vecIF;
 336   theApp->getCompatibleImages (GetDocument(), vecIF);
 337
 338   if (vecIF.size() == 0) {
 339     wxMessageBox("There are no compatible image files open for comparision", "No comparison images");
 340   } else {
 341     DialogGetComparisonImage dialogGetCompare(getFrameForChild(), "Get Comparison Image", vecIF, true);
 342
 343     if (dialogGetCompare.ShowModal() == wxID_OK) {
 344       const ImageFile& rIF = GetDocument()->getImageFile();
 345       ImageFileDocument* pCompareDoc = dialogGetCompare.getImageFileDocument();
 346       const ImageFile& rCompareIF = pCompareDoc->getImageFile();
 347       std::ostringstream os;
 348       double min, max, mean, mode, median, stddev;
 349       rIF.statistics (min, max, mean, mode, median, stddev);
 350       os << GetFrame()->GetTitle().c_str() << ": minimum=" << min << ", maximum=" << max << ", mean=" << mean << ", mode=" << mode << ", median=" << median << ", stddev=" << stddev << "\n";
 351       rCompareIF.statistics (min, max, mean, mode, median, stddev);
 352       os << pCompareDoc->GetFirstView()->GetFrame()->GetTitle().c_str() << ": minimum=" << min << ", maximum=" << max << ", mean=" << mean << ", mode=" << mode << ", median=" << median << ", stddev=" << stddev << "\n";
 353       os << "\n";
 354       double d, r, e;
 355       rIF.comparativeStatistics (rCompareIF, d, r, e);
 356       os << "Comparative Statistics: d=" << d << ", r=" << r << ", e=" << e << "\n";
 357       *theApp->getLog() << os.str().c_str();
 358       if (dialogGetCompare.getMakeDifferenceImage()) {
 359         ImageFileDocument* pDifferenceDoc = theApp->newImageDoc();
 360         if (! pDifferenceDoc) {
 361           sys_error (ERR_SEVERE, "Unable to create image file");
 362           return;
 363         }
 364         ImageFile& differenceImage = pDifferenceDoc->getImageFile();
 365
 366         differenceImage.setArraySize (rIF.nx(), rIF.ny());
 367         if (! rIF.subtractImages (rCompareIF, differenceImage)) {
 368           pDifferenceDoc->DeleteAllViews();
 369           return;
 370         }
 371
 372         wxString s = GetFrame()->GetTitle() + ": ";
 373         differenceImage.labelsCopy (rIF, s.c_str());
 374         s = pCompareDoc->GetFirstView()->GetFrame()->GetTitle() + ": ";
 375         differenceImage.labelsCopy (rCompareIF, s.c_str());
 376         std::ostringstream osLabel;
 377         osLabel << "Compare image " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str()
 378           << " and " << pCompareDoc->GetFirstView()->GetFrame()->GetTitle().c_str() << ": "
 379           << os.str().c_str();
 380         differenceImage.labelAdd (os.str().c_str());
 381         if (theApp->getSetModifyNewDocs())
 382           pDifferenceDoc->Modify(true);
 383         pDifferenceDoc->UpdateAllViews(this);
 384         pDifferenceDoc->GetFirstView()->OnUpdate (this, NULL);
 385       }
 386       wxMessageBox(os.str().c_str(), "Image Comparison");
 387     }
 388   }
 389 }
 390
 391 void
 392 ImageFileView::OnInvertValues (wxCommandEvent& event)
 393 {
 394   ImageFile& rIF = GetDocument()->getImageFile();
 395   rIF.invertPixelValues (rIF);
 396   rIF.labelAdd ("Invert Pixel Values");
 397   if (theApp->getSetModifyNewDocs())
 398     GetDocument()->Modify(TRUE);
 399   GetDocument()->UpdateAllViews(this);
 400 }
 401
 402 void
 403 ImageFileView::OnSquare (wxCommandEvent& event)
 404 {
 405   ImageFile& rIF = GetDocument()->getImageFile();
 406   rIF.square (rIF);
 407   rIF.labelAdd ("Square Pixel Values");
 408   if (theApp->getSetModifyNewDocs())
 409     GetDocument()->Modify(TRUE);
 410   GetDocument()->UpdateAllViews(this);
 411 }
 412
 413 void
 414 ImageFileView::OnSquareRoot (wxCommandEvent& event)
 415 {
 416   ImageFile& rIF = GetDocument()->getImageFile();
 417   rIF.sqrt (rIF);
 418   rIF.labelAdd ("Square-root Pixel Values");
 419   if (theApp->getSetModifyNewDocs())
 420     GetDocument()->Modify(TRUE);
 421   GetDocument()->UpdateAllViews(this);
 422 }
 423
 424 void
 425 ImageFileView::OnLog (wxCommandEvent& event)
 426 {
 427   ImageFile& rIF = GetDocument()->getImageFile();
 428   rIF.log (rIF);
 429   rIF.labelAdd ("Logrithm base-e Pixel Values");
 430   if (theApp->getSetModifyNewDocs())
 431     GetDocument()->Modify(TRUE);
 432   GetDocument()->UpdateAllViews(this);
 433 }
 434
 435 void
 436 ImageFileView::OnExp (wxCommandEvent& event)
 437 {
 438   ImageFile& rIF = GetDocument()->getImageFile();
 439   rIF.exp (rIF);
 440   rIF.labelAdd ("Exponent base-e Pixel Values");
 441   if (theApp->getSetModifyNewDocs())
 442     GetDocument()->Modify(TRUE);
 443   GetDocument()->UpdateAllViews(this);
 444 }
 445
 446 void
 447 ImageFileView::OnAdd (wxCommandEvent& event)
 448 {
 449   std::vector<ImageFileDocument*> vecIF;
 450   theApp->getCompatibleImages (GetDocument(), vecIF);
 451
 452   if (vecIF.size() == 0) {
 453     wxMessageBox ("There are no compatible image files open for comparision", "No comparison images");
 454   } else {
 455     DialogGetComparisonImage dialogGetCompare (getFrameForChild(), "Get Image to Add", vecIF, false);
 456
 457     if (dialogGetCompare.ShowModal() == wxID_OK) {
 458       ImageFile& rIF = GetDocument()->getImageFile();
 459       ImageFileDocument* pRHSDoc = dialogGetCompare.getImageFileDocument();
 460       const ImageFile& rRHSIF = pRHSDoc->getImageFile();
 461       ImageFileDocument* pNewDoc = theApp->newImageDoc();
 462       if (! pNewDoc) {
 463         sys_error (ERR_SEVERE, "Unable to create image file");
 464         return;
 465       }
 466       ImageFile& newImage = pNewDoc->getImageFile();
 467       newImage.setArraySize (rIF.nx(), rIF.ny());
 468       rIF.addImages (rRHSIF, newImage);
 469       std::ostringstream os;
 470       os << "Add image " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str() << " and "
 471         << pRHSDoc->GetFirstView()->GetFrame()->GetTitle().c_str();
 472       wxString s = GetDocument()->GetFirstView()->GetFrame()->GetTitle() + ": ";
 473       newImage.labelsCopy (rIF, s.c_str());
 474       s = pRHSDoc->GetFirstView()->GetFrame()->GetTitle() + ": ";
 475       newImage.labelsCopy (rRHSIF, s.c_str());
 476       newImage.labelAdd (os.str().c_str());
 477       *theApp->getLog() << os.str().c_str() << "\n";
 478       if (theApp->getSetModifyNewDocs())
 479         pNewDoc->Modify(TRUE);
 480       pNewDoc->UpdateAllViews(this);
 481       pNewDoc->GetFirstView()->OnUpdate (this, NULL);
 482     }
 483   }
 484 }
 485
 486 void
 487 ImageFileView::OnSubtract (wxCommandEvent& event)
 488 {
 489   std::vector<ImageFileDocument*> vecIF;
 490   theApp->getCompatibleImages (GetDocument(), vecIF);
 491
 492   if (vecIF.size() == 0) {
 493     wxMessageBox ("There are no compatible image files open for comparision", "No comparison images");
 494   } else {
 495     DialogGetComparisonImage dialogGetCompare (getFrameForChild(), "Get Image to Subtract", vecIF, false);
 496
 497     if (dialogGetCompare.ShowModal() == wxID_OK) {
 498       ImageFile& rIF = GetDocument()->getImageFile();
 499       ImageFileDocument* pRHSDoc = dialogGetCompare.getImageFileDocument();
 500       const ImageFile& rRHSIF = pRHSDoc->getImageFile();
 501       ImageFileDocument* pNewDoc = theApp->newImageDoc();
 502       if (! pNewDoc) {
 503         sys_error (ERR_SEVERE, "Unable to create image file");
 504         return;
 505       }
 506       ImageFile& newImage = pNewDoc->getImageFile();
 507       newImage.setArraySize (rIF.nx(), rIF.ny());
 508       rIF.subtractImages (rRHSIF, newImage);
 509       std::ostringstream os;
 510       os << "Subtract image " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str() << " and "
 511         << pRHSDoc->GetFirstView()->GetFrame()->GetTitle().c_str();
 512       wxString s = GetDocument()->GetFirstView()->GetFrame()->GetTitle() + ": ";
 513       newImage.labelsCopy (rIF, s.c_str());
 514       s = pRHSDoc->GetFirstView()->GetFrame()->GetTitle() + ": ";
 515       newImage.labelsCopy (rRHSIF, s.c_str());
 516       newImage.labelAdd (os.str().c_str());
 517       *theApp->getLog() << os.str().c_str() << "\n";
 518       if (theApp->getSetModifyNewDocs())
 519         pNewDoc->Modify(TRUE);
 520       pNewDoc->UpdateAllViews(this);
 521       pNewDoc->GetFirstView()->OnUpdate (this, NULL);
 522     }
 523   }
 524 }
 525
 526 void
 527 ImageFileView::OnMultiply (wxCommandEvent& event)
 528 {
 529   std::vector<ImageFileDocument*> vecIF;
 530   theApp->getCompatibleImages (GetDocument(), vecIF);
 531
 532   if (vecIF.size() == 0) {
 533     wxMessageBox ("There are no compatible image files open for comparision", "No comparison images");
 534   } else {
 535     DialogGetComparisonImage dialogGetCompare (getFrameForChild(), "Get Image to Multiply", vecIF, false);
 536
 537     if (dialogGetCompare.ShowModal() == wxID_OK) {
 538       ImageFile& rIF = GetDocument()->getImageFile();
 539       ImageFileDocument* pRHSDoc = dialogGetCompare.getImageFileDocument();
 540       const ImageFile& rRHSIF = pRHSDoc->getImageFile();
 541       ImageFileDocument* pNewDoc = theApp->newImageDoc();
 542       if (! pNewDoc) {
 543         sys_error (ERR_SEVERE, "Unable to create image file");
 544         return;
 545       }
 546       ImageFile& newImage = pNewDoc->getImageFile();
 547       newImage.setArraySize (rIF.nx(), rIF.ny());
 548       rIF.multiplyImages (rRHSIF, newImage);
 549       std::ostringstream os;
 550       os << "Multiply image " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str() << " and "
 551         << pRHSDoc->GetFirstView()->GetFrame()->GetTitle().c_str();
 552       wxString s = GetDocument()->GetFirstView()->GetFrame()->GetTitle() + ": ";
 553       newImage.labelsCopy (rIF, s.c_str());
 554       s = pRHSDoc->GetFirstView()->GetFrame()->GetTitle() + ": ";
 555       newImage.labelsCopy (rRHSIF, s.c_str());
 556       newImage.labelAdd (os.str().c_str());
 557       *theApp->getLog() << os.str().c_str() << "\n";
 558       if (theApp->getSetModifyNewDocs())
 559         pNewDoc->Modify(TRUE);
 560       pNewDoc->UpdateAllViews(this);
 561       pNewDoc->GetFirstView()->OnUpdate (this, NULL);
 562     }
 563   }
 564 }
 565
 566 void
 567 ImageFileView::OnDivide (wxCommandEvent& event)
 568 {
 569   std::vector<ImageFileDocument*> vecIF;
 570   theApp->getCompatibleImages (GetDocument(), vecIF);
 571
 572   if (vecIF.size() == 0) {
 573     wxMessageBox ("There are no compatible image files open for comparision", "No comparison images");
 574   } else {
 575     DialogGetComparisonImage dialogGetCompare (getFrameForChild(), "Get Image to Divide", vecIF, false);
 576
 577     if (dialogGetCompare.ShowModal() == wxID_OK) {
 578       ImageFile& rIF = GetDocument()->getImageFile();
 579       ImageFileDocument* pRHSDoc = dialogGetCompare.getImageFileDocument();
 580       const ImageFile& rRHSIF = pRHSDoc->getImageFile();
 581       ImageFileDocument* pNewDoc = theApp->newImageDoc();
 582       if (! pNewDoc) {
 583         sys_error (ERR_SEVERE, "Unable to create image file");
 584         return;
 585       }
 586       ImageFile& newImage = pNewDoc->getImageFile();
 587       newImage.setArraySize (rIF.nx(), rIF.ny());
 588       rIF.divideImages (rRHSIF, newImage);
 589       std::ostringstream os;
 590       os << "Divide image " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str() << " by "
 591         << pRHSDoc->GetFirstView()->GetFrame()->GetTitle().c_str();
 592       wxString s = GetDocument()->GetFirstView()->GetFrame()->GetTitle() + ": ";
 593       newImage.labelsCopy (rIF, s.c_str());
 594       s = pRHSDoc->GetFirstView()->GetFrame()->GetTitle() + ": ";
 595       newImage.labelsCopy (rRHSIF, s.c_str());
 596       newImage.labelAdd (os.str().c_str());
 597       *theApp->getLog() << os.str().c_str() << "\n";
 598       if (theApp->getSetModifyNewDocs())
 599         pNewDoc->Modify(TRUE);
 600       pNewDoc->UpdateAllViews(this);
 601       pNewDoc->GetFirstView()->OnUpdate (this, NULL);
 602     }
 603   }
 604 }
 605
 606
 607 #ifdef HAVE_FFT
 608 void
 609 ImageFileView::OnFFT (wxCommandEvent& event)
 610 {
 611   ImageFile& rIF = GetDocument()->getImageFile();
 612   rIF.fft (rIF);
 613   rIF.labelAdd ("FFT Image");
 614   m_bMinSpecified = false;
 615   m_bMaxSpecified = false;
 616   if (theApp->getSetModifyNewDocs())
 617     GetDocument()->Modify(TRUE);
 618   GetDocument()->UpdateAllViews(this);
 619 }
 620
 621 void
 622 ImageFileView::OnIFFT (wxCommandEvent& event)
 623 {
 624   ImageFile& rIF = GetDocument()->getImageFile();
 625   rIF.ifft (rIF);
 626   rIF.labelAdd ("IFFT Image");
 627   m_bMinSpecified = false;
 628   m_bMaxSpecified = false;
 629   if (theApp->getSetModifyNewDocs())
 630     GetDocument()->Modify(TRUE);
 631   GetDocument()->UpdateAllViews(this);
 632 }
 633
 634 void
 635 ImageFileView::OnFFTRows (wxCommandEvent& event)
 636 {
 637   ImageFile& rIF = GetDocument()->getImageFile();
 638   rIF.fftRows (rIF);
 639   rIF.labelAdd ("FFT Rows");
 640   m_bMinSpecified = false;
 641   m_bMaxSpecified = false;
 642   if (theApp->getSetModifyNewDocs())
 643     GetDocument()->Modify(TRUE);
 644   GetDocument()->UpdateAllViews(this);
 645 }
 646
 647 void
 648 ImageFileView::OnIFFTRows (wxCommandEvent& event)
 649 {
 650   ImageFile& rIF = GetDocument()->getImageFile();
 651   rIF.ifftRows (rIF);
 652   rIF.labelAdd ("IFFT Rows");
 653   m_bMinSpecified = false;
 654   m_bMaxSpecified = false;
 655   if (theApp->getSetModifyNewDocs())
 656     GetDocument()->Modify(TRUE);
 657   GetDocument()->UpdateAllViews(this);
 658 }
 659
 660 void
 661 ImageFileView::OnFFTCols (wxCommandEvent& event)
 662 {
 663   ImageFile& rIF = GetDocument()->getImageFile();
 664   rIF.fftCols (rIF);
 665   rIF.labelAdd ("FFT Columns");
 666   m_bMinSpecified = false;
 667   m_bMaxSpecified = false;
 668   if (theApp->getSetModifyNewDocs())
 669     GetDocument()->Modify(TRUE);
 670   GetDocument()->UpdateAllViews(this);
 671 }
 672
 673 void
 674 ImageFileView::OnIFFTCols (wxCommandEvent& event)
 675 {
 676   ImageFile& rIF = GetDocument()->getImageFile();
 677   rIF.ifftCols (rIF);
 678   rIF.labelAdd ("IFFT Columns");
 679   m_bMinSpecified = false;
 680   m_bMaxSpecified = false;
 681   if (theApp->getSetModifyNewDocs())
 682     GetDocument()->Modify(TRUE);
 683   GetDocument()->UpdateAllViews(this);
 684 }
 685 #endif
 686
 687 void
 688 ImageFileView::OnFourier (wxCommandEvent& event)
 689 {
 690   ImageFile& rIF = GetDocument()->getImageFile();
 691   wxProgressDialog dlgProgress (wxString("Fourier"), wxString("Fourier Progress"), 1, getFrameForChild(), wxPD_APP_MODAL);
 692   rIF.fourier (rIF);
 693   rIF.labelAdd ("Fourier Image");
 694   m_bMinSpecified = false;
 695   m_bMaxSpecified = false;
 696   if (theApp->getSetModifyNewDocs())
 697     GetDocument()->Modify(TRUE);
 698   GetDocument()->UpdateAllViews(this);
 699 }
 700
 701 void
 702 ImageFileView::OnInverseFourier (wxCommandEvent& event)
 703 {
 704   ImageFile& rIF = GetDocument()->getImageFile();
 705   wxProgressDialog dlgProgress (wxString("Inverse Fourier"), wxString("Inverse Fourier Progress"), 1, getFrameForChild(), wxPD_APP_MODAL);
 706   rIF.inverseFourier (rIF);
 707   rIF.labelAdd ("Inverse Fourier Image");
 708   m_bMinSpecified = false;
 709   m_bMaxSpecified = false;
 710   if (theApp->getSetModifyNewDocs())
 711     GetDocument()->Modify(TRUE);
 712   GetDocument()->UpdateAllViews(this);
 713 }
 714
 715 void
 716 ImageFileView::OnShuffleNaturalToFourierOrder (wxCommandEvent& event)
 717 {
 718   ImageFile& rIF = GetDocument()->getImageFile();
 719   Fourier::shuffleNaturalToFourierOrder (rIF);
 720   rIF.labelAdd ("Shuffle Natural To Fourier Order");
 721   m_bMinSpecified = false;
 722   m_bMaxSpecified = false;
 723   if (theApp->getSetModifyNewDocs())
 724     GetDocument()->Modify(TRUE);
 725   GetDocument()->UpdateAllViews(this);
 726 }
 727
 728 void
 729 ImageFileView::OnShuffleFourierToNaturalOrder (wxCommandEvent& event)
 730 {
 731   ImageFile& rIF = GetDocument()->getImageFile();
 732   Fourier::shuffleFourierToNaturalOrder (rIF);
 733   rIF.labelAdd ("Shuffle Fourier To Natural Order");
 734   m_bMinSpecified = false;
 735   m_bMaxSpecified = false;
 736   if (theApp->getSetModifyNewDocs())
 737     GetDocument()->Modify(TRUE);
 738   GetDocument()->UpdateAllViews(this);
 739 }
 740
 741 void
 742 ImageFileView::OnMagnitude (wxCommandEvent& event)
 743 {
 744   ImageFile& rIF = GetDocument()->getImageFile();
 745   if (rIF.isComplex()) {
 746     rIF.magnitude (rIF);
 747     rIF.labelAdd ("Magnitude of complex-image");
 748     m_bMinSpecified = false;
 749     m_bMaxSpecified = false;
 750     if (theApp->getSetModifyNewDocs())
 751       GetDocument()->Modify(TRUE);
 752     GetDocument()->UpdateAllViews(this);
 753   }
 754 }
 755
 756 void
 757 ImageFileView::OnPhase (wxCommandEvent& event)
 758 {
 759   ImageFile& rIF = GetDocument()->getImageFile();
 760   if (rIF.isComplex()) {
 761     rIF.phase (rIF);
 762     rIF.labelAdd ("Phase of complex-image");
 763     m_bMinSpecified = false;
 764     m_bMaxSpecified = false;
 765     if (theApp->getSetModifyNewDocs())
 766       GetDocument()->Modify(TRUE);
 767     GetDocument()->UpdateAllViews(this);
 768   }
 769 }
 770
 771
 772 ImageFileCanvas*
 773 ImageFileView::CreateCanvas (wxView *view, wxFrame *parent)
 774 {
 775   ImageFileCanvas* pCanvas;
 776   int width, height;
 777   parent->GetClientSize(&width, &height);
 778
 779   pCanvas = new ImageFileCanvas (dynamic_cast<ImageFileView*>(view), parent, wxPoint(0, 0), wxSize(width, height), 0);
 780
 781   pCanvas->SetScrollbars(20, 20, 50, 50);
 782   pCanvas->SetBackgroundColour(*wxWHITE);
 783   pCanvas->Clear();
 784
 785   return pCanvas;
 786 }
 787
 788 wxFrame*
 789 ImageFileView::CreateChildFrame(wxDocument *doc, wxView *view)
 790 {
 791 #if CTSIM_MDI
 792   wxDocMDIChildFrame* subframe = new wxDocMDIChildFrame (doc, view, theApp->getMainFrame(), -1, "ImageFile Frame", wxPoint(-1, -1), wxSize(0, 0), wxDEFAULT_FRAME_STYLE);
 793 #else
 794   wxDocChildFrame* subframe = new wxDocChildFrame (doc, view, theApp->getMainFrame(), -1, "ImageFile Frame", wxPoint(-1, -1), wxSize(0, 0), wxDEFAULT_FRAME_STYLE);
 795 #endif
 796   theApp->setIconForFrame (subframe);
 797
 798   wxMenu *m_pFileMenu = new wxMenu;
 799
 800   m_pFileMenu->Append(MAINMENU_FILE_CREATE_PHANTOM, "Cr&eate Phantom...\tCtrl-P");
 801   m_pFileMenu->Append(MAINMENU_FILE_CREATE_FILTER, "Create &Filter...\tCtrl-F");
 802   m_pFileMenu->Append(wxID_OPEN, "&Open...\tCtrl-O");
 803   m_pFileMenu->Append(wxID_SAVE, "&Save\tCtrl-S");
 804   m_pFileMenu->Append(wxID_SAVEAS, "Save &As...");
 805   m_pFileMenu->Append(wxID_CLOSE, "&Close\tCtrl-W");
 806
 807   m_pFileMenu->AppendSeparator();
 808   m_pFileMenu->Append(IFMENU_FILE_PROPERTIES, "P&roperties");
 809   m_pFileMenu->Append(IFMENU_FILE_EXPORT, "&Export...");
 810
 811   m_pFileMenu->AppendSeparator();
 812   m_pFileMenu->Append(wxID_PRINT, "&Print...");
 813   m_pFileMenu->Append(wxID_PRINT_SETUP, "Print &Setup...");
 814   m_pFileMenu->Append(wxID_PREVIEW, "Print Pre&view");
 815 #ifdef CTSIM_MDI
 816   m_pFileMenu->AppendSeparator();
 817   m_pFileMenu->Append(MAINMENU_FILE_EXIT, "E&xit");
 818 #endif
 819   theApp->getDocManager()->FileHistoryAddFilesToMenu(m_pFileMenu);
 820   theApp->getDocManager()->FileHistoryUseMenu(m_pFileMenu);
 821
 822   wxMenu *view_menu = new wxMenu;
 823   view_menu->Append(IFMENU_VIEW_SCALE_MINMAX, "Display Scale S&et...\tCtrl-E");
 824   view_menu->Append(IFMENU_VIEW_SCALE_AUTO, "Display Scale &Auto...\tCtrl-A");
 825   view_menu->Append(IFMENU_VIEW_SCALE_FULL, "Display F&ull Scale\tCtrl-U");
 826
 827   wxMenu* filter_menu = new wxMenu;
 828   filter_menu->Append (IFMENU_FILTER_INVERTVALUES, "&Invert Values");
 829   filter_menu->Append (IFMENU_FILTER_SQUARE, "&Square");
 830   filter_menu->Append (IFMENU_FILTER_SQRT, "Square &Root");
 831   filter_menu->Append (IFMENU_FILTER_LOG, "&Log");
 832   filter_menu->Append (IFMENU_FILTER_EXP, "&Exp");
 833   filter_menu->AppendSeparator();
 834 #ifdef HAVE_FFT
 835   filter_menu->Append (IFMENU_FILTER_FFT, "2D &FFT");
 836   filter_menu->Append (IFMENU_FILTER_IFFT, "2D &IFFT");
 837   filter_menu->Append (IFMENU_FILTER_FFT_ROWS, "FFT Rows");
 838   filter_menu->Append (IFMENU_FILTER_IFFT_ROWS, "IFFT Rows");
 839   filter_menu->Append (IFMENU_FILTER_FFT_COLS, "FFT Columns");
 840   filter_menu->Append (IFMENU_FILTER_IFFT_COLS, "IFFT Columns");
 841   filter_menu->Append (IFMENU_FILTER_FOURIER, "F&ourier");
 842   filter_menu->Append (IFMENU_FILTER_INVERSE_FOURIER, "Inverse Fo&urier");
 843 #else
 844   filter_menu->Append (IFMENU_FILTER_FOURIER, "&Fourier");
 845   filter_menu->Append (IFMENU_FILTER_INVERSE_FOURIER, "&Inverse Fourier");
 846 #endif
 847   filter_menu->Append (IFMENU_FILTER_SHUFFLEFOURIERTONATURALORDER, "S&huffle Fourier to Natural Order");
 848   filter_menu->Append (IFMENU_FILTER_SHUFFLENATURALTOFOURIERORDER, "Shu&ffle Natural to Fourier Order");
 849   filter_menu->Append (IFMENU_FILTER_MAGNITUDE, "&Magnitude");
 850   filter_menu->Append (IFMENU_FILTER_PHASE, "&Phase");
 851
 852   wxMenu* image_menu = new wxMenu;
 853   image_menu->Append (IFMENU_IMAGE_ADD, "&Add...");
 854   image_menu->Append (IFMENU_IMAGE_SUBTRACT, "&Subtract...");
 855   image_menu->Append (IFMENU_IMAGE_MULTIPLY, "&Multiply...");
 856   image_menu->Append (IFMENU_IMAGE_DIVIDE, "&Divide...");
 857   image_menu->AppendSeparator();
 858   image_menu->Append (IFMENU_IMAGE_SCALESIZE, "S&cale Size...");
 859
 860   wxMenu *analyze_menu = new wxMenu;
 861   analyze_menu->Append (IFMENU_PLOT_ROW, "Plot &Row");
 862   analyze_menu->Append (IFMENU_PLOT_COL, "Plot &Column");
 863   analyze_menu->Append (IFMENU_PLOT_HISTOGRAM, "Plot &Histogram");
 864   analyze_menu->AppendSeparator();
 865   analyze_menu->Append (IFMENU_PLOT_FFT_ROW, "Plot FFT Row");
 866   analyze_menu->Append (IFMENU_PLOT_FFT_COL, "Plot FFT Column");
 867   analyze_menu->AppendSeparator();
 868   analyze_menu->Append (IFMENU_COMPARE_IMAGES, "Compare &Images...");
 869   analyze_menu->Append (IFMENU_COMPARE_ROW, "Compare &Row");
 870   analyze_menu->Append (IFMENU_COMPARE_COL, "Compare &Column");
 871
 872   wxMenu *help_menu = new wxMenu;
 873   help_menu->Append(MAINMENU_HELP_CONTENTS, "&Contents\tF1");
 874   help_menu->Append(MAINMENU_HELP_TOPICS, "&Topics\tCtrl-H");
 875   help_menu->Append(MAINMENU_HELP_ABOUT, "&About");
 876
 877   wxMenuBar *menu_bar = new wxMenuBar;
 878
 879   menu_bar->Append(m_pFileMenu, "&File");
 880   menu_bar->Append(view_menu, "&View");
 881   menu_bar->Append(image_menu, "&Image");
 882   menu_bar->Append(filter_menu, "Fi&lter");
 883   menu_bar->Append(analyze_menu, "&Analyze");
 884   menu_bar->Append(help_menu, "&Help");
 885
 886   subframe->SetMenuBar(menu_bar);
 887
 888   subframe->Centre(wxBOTH);
 889
 890   wxAcceleratorEntry accelEntries[10];
 891   accelEntries[0].Set (wxACCEL_CTRL, static_cast<int>('O'), wxID_OPEN);
 892   accelEntries[1].Set (wxACCEL_CTRL, static_cast<int>('S'), wxID_SAVE);
 893   accelEntries[2].Set (wxACCEL_CTRL, static_cast<int>('W'), wxID_CLOSE);
 894   accelEntries[3].Set (wxACCEL_CTRL, static_cast<int>('H'), MAINMENU_HELP_TOPICS);
 895   accelEntries[4].Set (wxACCEL_CTRL, static_cast<int>('P'), MAINMENU_FILE_CREATE_PHANTOM);
 896   accelEntries[5].Set (wxACCEL_CTRL, static_cast<int>('F'), MAINMENU_FILE_CREATE_FILTER);
 897   accelEntries[6].Set (wxACCEL_NORMAL, WXK_F1, MAINMENU_HELP_CONTENTS);
 898   accelEntries[7].Set (wxACCEL_CTRL, static_cast<int>('A'), IFMENU_VIEW_SCALE_AUTO);
 899   accelEntries[8].Set (wxACCEL_CTRL, static_cast<int>('U'), IFMENU_VIEW_SCALE_FULL);
 900   accelEntries[9].Set (wxACCEL_CTRL, static_cast<int>('E'), IFMENU_VIEW_SCALE_MINMAX);
 901   wxAcceleratorTable accelTable (10, accelEntries);
 902   subframe->SetAcceleratorTable (accelTable);
 903
 904   return subframe;
 905 }
 906
 907
 908 bool
 909 ImageFileView::OnCreate (wxDocument *doc, long WXUNUSED(flags) )
 910 {
 911   m_frame = CreateChildFrame(doc, this);
 912   SetFrame (m_frame);
 913
 914   m_bMinSpecified = false;
 915   m_bMaxSpecified = false;
 916   m_dAutoScaleFactor = 1.;
 917
 918   int width, height;
 919   m_frame->GetClientSize (&width, &height);
 920   m_frame->SetTitle("ImageFileView");
 921   m_canvas = CreateCanvas (this, m_frame);
 922
 923   int x, y;  // X requires a forced resize
 924   m_frame->GetSize(&x, &y);
 925   m_frame->SetSize(-1, -1, x, y);
 926   m_frame->SetFocus();
 927   m_frame->Show(true);
 928   Activate(true);
 929
 930   return true;
 931 }
 932
 933 void
 934 ImageFileView::OnDraw (wxDC* dc)
 935 {
 936   wxSize sizeWindow = m_frame->GetClientSize();
 937   wxSize sizeBest = m_canvas->GetBestSize();
 938   if (sizeWindow.x > sizeBest.x || sizeWindow.y > sizeBest.y)
 939     m_frame->SetClientSize (sizeBest);
 940
 941   if (m_bitmap.Ok())
 942     dc->DrawBitmap(m_bitmap, 0, 0, false);
 943
 944   int xCursor, yCursor;
 945   if (m_canvas->GetCurrentCursor (xCursor, yCursor))
 946     m_canvas->DrawRubberBandCursor (*dc, xCursor, yCursor);
 947 }
 948
 949
 950 void
 951 ImageFileView::OnUpdate (wxView *WXUNUSED(sender), wxObject *WXUNUSED(hint) )
 952 {
 953   const ImageFile& rIF = dynamic_cast<ImageFileDocument*>(GetDocument())->getImageFile();
 954   ImageFileArrayConst v = rIF.getArray();
 955   int nx = rIF.nx();
 956   int ny = rIF.ny();
 957   if (v != NULL && nx != 0 && ny != 0) {
 958     if (! m_bMinSpecified || ! m_bMaxSpecified) {
 959       double min, max;
 960       rIF.getMinMax (min, max);
 961       if (! m_bMinSpecified)
 962         m_dMinPixel = min;
 963       if (! m_bMaxSpecified)
 964         m_dMaxPixel = max;
 965     }
 966     double scaleWidth = m_dMaxPixel - m_dMinPixel;
 967
 968     unsigned char* imageData = new unsigned char [nx * ny * 3];
 969     for (int ix = 0; ix < nx; ix++) {
 970       for (int iy = 0; iy < ny; iy++) {
 971         double scaleValue = ((v[ix][iy] - m_dMinPixel) / scaleWidth) * 255;
 972         int intensity = static_cast<int>(scaleValue + 0.5);
 973         intensity = clamp (intensity, 0, 255);
 974         int baseAddr = ((ny - 1 - iy) * nx + ix) * 3;
 975         imageData[baseAddr] = imageData[baseAddr+1] = imageData[baseAddr+2] = intensity;
 976       }
 977     }
 978     wxImage image (nx, ny, imageData, true);
 979     m_bitmap = image.ConvertToBitmap();
 980     delete imageData;
 981     int xSize = nx;
 982     int ySize = ny;
 983     ySize = clamp (ySize, 0, 800);
 984     m_frame->SetClientSize (xSize, ySize);
 985     m_canvas->SetScrollbars(20, 20, nx/20, ny/20);
 986     m_canvas->SetBackgroundColour(*wxWHITE);
 987   }
 988
 989   if (m_canvas)
 990     m_canvas->Refresh();
 991 }
 992
 993 bool
 994 ImageFileView::OnClose (bool deleteWindow)
 995 {
 996   if (!GetDocument()->Close())
 997     return false;
 998
 999 //  m_canvas->Clear();
1000 //  m_canvas->setView(NULL);
1001   m_canvas = NULL;
1002   wxString s(theApp->GetAppName());
1003 //  if (m_frame)
1004 //    m_frame->SetTitle(s);
1005   SetFrame(NULL);
1006
1007   Activate(false);
1008
1009   if (deleteWindow) {
1010     delete m_frame;
1011     return true;
1012   }
1013   return true;
1014 }
1015
1016 void
1017 ImageFileView::OnExport (wxCommandEvent& event)
1018 {
1019   ImageFile& rIF = dynamic_cast<ImageFileDocument*>(GetDocument())->getImageFile();
1020   ImageFileArrayConst v = rIF.getArray();
1021   int nx = rIF.nx();
1022   int ny = rIF.ny();
1023   if (v != NULL && nx != 0 && ny != 0) {
1024     if (! m_bMinSpecified || ! m_bMaxSpecified) {
1025       double min, max;
1026       rIF.getMinMax (min, max);
1027       if (! m_bMinSpecified)
1028         m_dMinPixel = min;
1029       if (! m_bMaxSpecified)
1030         m_dMaxPixel = max;
1031     }
1032
1033     DialogExportParameters dialogExport (getFrameForChild(), m_iDefaultExportFormatID);
1034     if (dialogExport.ShowModal() == wxID_OK) {
1035       wxString strFormatName (dialogExport.getFormatName ());
1036       m_iDefaultExportFormatID = ImageFile::convertFormatNameToID (strFormatName.c_str());
1037
1038       wxString strExt;
1039       wxString strWildcard;
1040       if (m_iDefaultExportFormatID == ImageFile::FORMAT_PGM || m_iDefaultExportFormatID == ImageFile::FORMAT_PGMASCII) {
1041         strExt = ".pgm";
1042         strWildcard = "PGM Files (*.pgm)|*.pgm";
1043       }
1044 #ifdef HAVE_PNG
1045       else if (m_iDefaultExportFormatID == ImageFile::FORMAT_PNG || m_iDefaultExportFormatID == ImageFile::FORMAT_PNG16) {
1046         strExt = ".png";
1047         strWildcard = "PNG Files (*.png)|*.png";
1048       }
1049 #endif
1050
1051       const wxString& strFilename = wxFileSelector (wxString("Export Filename"), wxString(""),
1052         wxString(""), strExt, strWildcard, wxOVERWRITE_PROMPT | wxHIDE_READONLY | wxSAVE);
1053       if (strFilename) {
1054         rIF.exportImage (strFormatName.c_str(), strFilename.c_str(), 1, 1, m_dMinPixel, m_dMaxPixel);
1055         *theApp->getLog() << "Exported file " << strFilename << "\n";
1056       }
1057     }
1058   }
1059 }
1060
1061 void
1062 ImageFileView::OnScaleSize (wxCommandEvent& event)
1063 {
1064   ImageFile& rIF = GetDocument()->getImageFile();
1065   unsigned int iOldNX = rIF.nx();
1066   unsigned int iOldNY = rIF.ny();
1067
1068   DialogGetXYSize dialogGetXYSize (getFrameForChild(), "Set New X & Y Dimensions", iOldNX, iOldNY);
1069   if (dialogGetXYSize.ShowModal() == wxID_OK) {
1070     unsigned int iNewNX = dialogGetXYSize.getXSize();
1071     unsigned int iNewNY = dialogGetXYSize.getYSize();
1072     std::ostringstream os;
1073     os << "Scale Size from (" << iOldNX << "," << iOldNY << ") to (" << iNewNX << "," << iNewNY << ")";
1074     ImageFileDocument* pScaledDoc = theApp->newImageDoc();
1075     if (! pScaledDoc) {
1076       sys_error (ERR_SEVERE, "Unable to create image file");
1077       return;
1078     }
1079     ImageFile& rScaledIF = pScaledDoc->getImageFile();
1080     rScaledIF.setArraySize (iNewNX, iNewNY);
1081     rScaledIF.labelsCopy (rIF);
1082     rScaledIF.labelAdd (os.str().c_str());
1083     rIF.scaleImage (rScaledIF);
1084     *theApp->getLog() << os.str().c_str() << "\n";
1085     if (theApp->getSetModifyNewDocs())
1086       pScaledDoc->Modify(TRUE);
1087     pScaledDoc->UpdateAllViews (this);
1088     pScaledDoc->GetFirstView()->OnUpdate (this, NULL);
1089   }
1090 }
1091
1092 void
1093 ImageFileView::OnPlotRow (wxCommandEvent& event)
1094 {
1095   int xCursor, yCursor;
1096   if (! m_canvas->GetCurrentCursor (xCursor, yCursor)) {
1097     wxMessageBox ("No row selected. Please use left mouse button on image to select column","Error");
1098     return;
1099   }
1100
1101   const ImageFile& rIF = dynamic_cast<ImageFileDocument*>(GetDocument())->getImageFile();
1102   ImageFileArrayConst v = rIF.getArray();
1103   ImageFileArrayConst vImag = rIF.getImaginaryArray();
1104   int nx = rIF.nx();
1105   int ny = rIF.ny();
1106
1107   if (v != NULL && yCursor < ny) {
1108     double* pX = new double [nx];
1109     double* pYReal = new double [nx];
1110     double *pYImag = NULL;
1111     double *pYMag = NULL;
1112     if (rIF.isComplex()) {
1113       pYImag = new double [nx];
1114       pYMag = new double [nx];
1115     }
1116     for (int i = 0; i < nx; i++) {
1117       pX[i] = i;
1118       pYReal[i] = v[i][yCursor];
1119       if (rIF.isComplex()) {
1120         pYImag[i] = vImag[i][yCursor];
1121         pYMag[i] = ::sqrt (v[i][yCursor] * v[i][yCursor] + vImag[i][yCursor] * vImag[i][yCursor]);
1122       }
1123     }
1124     PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1125     if (! pPlotDoc) {
1126       sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1127     } else {
1128       PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1129       std::ostringstream os;
1130       os << "Row " << yCursor;
1131       std::string title("title ");
1132       title += os.str();
1133       rPlotFile.addEzsetCommand (title.c_str());
1134       rPlotFile.addEzsetCommand ("xlabel Column");
1135       rPlotFile.addEzsetCommand ("ylabel Pixel Value");
1136       rPlotFile.addEzsetCommand ("lxfrac 0");
1137       rPlotFile.addEzsetCommand ("box");
1138       rPlotFile.addEzsetCommand ("grid");
1139       rPlotFile.addEzsetCommand ("curve 1");
1140       rPlotFile.addEzsetCommand ("color 1");
1141       if (rIF.isComplex()) {
1142         rPlotFile.addEzsetCommand ("dash 1");
1143         rPlotFile.addEzsetCommand ("curve 2");
1144         rPlotFile.addEzsetCommand ("color 4");
1145         rPlotFile.addEzsetCommand ("dash 3");
1146         rPlotFile.addEzsetCommand ("curve 3");
1147         rPlotFile.addEzsetCommand ("color 0");
1148         rPlotFile.addEzsetCommand ("solid");
1149         rPlotFile.setCurveSize (4, nx);
1150       } else
1151         rPlotFile.setCurveSize (2, nx);
1152       rPlotFile.addColumn (0, pX);
1153       rPlotFile.addColumn (1, pYReal);
1154       if (rIF.isComplex()) {
1155         rPlotFile.addColumn (2, pYImag);
1156         rPlotFile.addColumn (3, pYMag);
1157       }
1158       for (unsigned int iL = 0; iL < rIF.nLabels(); iL++)
1159         rPlotFile.addDescription (rIF.labelGet(iL).getLabelString().c_str());
1160       os << " Plot of " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1161       *theApp->getLog() << os.str().c_str() << "\n";
1162       rPlotFile.addDescription (os.str().c_str());
1163     }
1164     delete pX;
1165     delete pYReal;
1166     if (rIF.isComplex()) {
1167       delete pYImag;
1168       delete pYMag;
1169     }
1170     if (theApp->getSetModifyNewDocs())
1171       pPlotDoc->Modify(true);
1172     pPlotDoc->UpdateAllViews();
1173   }
1174 }
1175
1176 void
1177 ImageFileView::OnPlotCol (wxCommandEvent& event)
1178 {
1179   int xCursor, yCursor;
1180   if (! m_canvas->GetCurrentCursor (xCursor, yCursor)) {
1181     wxMessageBox ("No column selected. Please use left mouse button on image to select column","Error");
1182     return;
1183   }
1184
1185   const ImageFile& rIF = dynamic_cast<ImageFileDocument*>(GetDocument())->getImageFile();
1186   ImageFileArrayConst v = rIF.getArray();
1187   ImageFileArrayConst vImag = rIF.getImaginaryArray();
1188   int nx = rIF.nx();
1189   int ny = rIF.ny();
1190
1191   if (v != NULL && xCursor < nx) {
1192     double* pX = new double [ny];
1193     double* pYReal = new double [ny];
1194     double* pYImag = NULL;
1195     double* pYMag = NULL;
1196     if (rIF.isComplex()) {
1197       pYImag = new double [ny];
1198       pYMag = new double [ny];
1199     }
1200     for (int i = 0; i < ny; i++) {
1201       pX[i] = i;
1202       pYReal[i] = v[xCursor][i];
1203       if (rIF.isComplex()) {
1204         pYImag[i] = vImag[xCursor][i];
1205         pYMag[i] = ::sqrt (v[xCursor][i] * v[xCursor][i] + vImag[xCursor][i] * vImag[xCursor][i]);
1206       }
1207     }
1208     PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1209     if (! pPlotDoc) {
1210       sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1211     } else {
1212       PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1213       std::ostringstream os;
1214       os << "Column " << xCursor;
1215       std::string title("title ");
1216       title += os.str();
1217       rPlotFile.addEzsetCommand (title.c_str());
1218       rPlotFile.addEzsetCommand ("xlabel Row");
1219       rPlotFile.addEzsetCommand ("ylabel Pixel Value");
1220       rPlotFile.addEzsetCommand ("lxfrac 0");
1221       rPlotFile.addEzsetCommand ("box");
1222       rPlotFile.addEzsetCommand ("grid");
1223       rPlotFile.addEzsetCommand ("curve 1");
1224       rPlotFile.addEzsetCommand ("color 1");
1225       if (rIF.isComplex()) {
1226         rPlotFile.addEzsetCommand ("dash 1");
1227         rPlotFile.addEzsetCommand ("curve 2");
1228         rPlotFile.addEzsetCommand ("color 4");
1229         rPlotFile.addEzsetCommand ("dash 3");
1230         rPlotFile.addEzsetCommand ("curve 3");
1231         rPlotFile.addEzsetCommand ("color 0");
1232         rPlotFile.addEzsetCommand ("solid");
1233         rPlotFile.setCurveSize (4, ny);
1234       } else
1235         rPlotFile.setCurveSize (2, ny);
1236       rPlotFile.addColumn (0, pX);
1237       rPlotFile.addColumn (1, pYReal);
1238       if (rIF.isComplex()) {
1239         rPlotFile.addColumn (2, pYImag);
1240         rPlotFile.addColumn (3, pYMag);
1241       }
1242       for (unsigned int iL = 0; iL < rIF.nLabels(); iL++)
1243         rPlotFile.addDescription (rIF.labelGet(iL).getLabelString().c_str());
1244       os << " Plot of " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1245       *theApp->getLog() << os.str().c_str() << "\n";
1246       rPlotFile.addDescription (os.str().c_str());
1247     }
1248     delete pX;
1249     delete pYReal;
1250     if (rIF.isComplex()) {
1251       delete pYImag;
1252       delete pYMag;
1253     }
1254     if (theApp->getSetModifyNewDocs())
1255       pPlotDoc->Modify(true);
1256     pPlotDoc->UpdateAllViews();
1257   }
1258 }
1259
1260 #ifdef HAVE_FFT
1261 void
1262 ImageFileView::OnPlotFFTRow (wxCommandEvent& event)
1263 {
1264   int xCursor, yCursor;
1265   if (! m_canvas->GetCurrentCursor (xCursor, yCursor)) {
1266     wxMessageBox ("No row selected. Please use left mouse button on image to select column","Error");
1267     return;
1268   }
1269
1270   const ImageFile& rIF = dynamic_cast<ImageFileDocument*>(GetDocument())->getImageFile();
1271   ImageFileArrayConst v = rIF.getArray();
1272   ImageFileArrayConst vImag = rIF.getImaginaryArray();
1273   int nx = rIF.nx();
1274   int ny = rIF.ny();
1275
1276   if (v != NULL && yCursor < ny) {
1277     fftw_complex* pcIn = new fftw_complex [nx];
1278
1279     int i;
1280     for (i = 0; i < nx; i++) {
1281       pcIn[i].re = v[i][yCursor];
1282       if (rIF.isComplex())
1283         pcIn[i].im = vImag[i][yCursor];
1284       else
1285         pcIn[i].im = 0;
1286     }
1287
1288     fftw_plan plan = fftw_create_plan (nx, FFTW_FORWARD, FFTW_IN_PLACE);
1289     fftw_one (plan, pcIn, NULL);
1290     fftw_destroy_plan (plan);
1291
1292     double* pX = new double [nx];
1293     double* pYReal = new double [nx];
1294     double* pYImag = new double [nx];
1295     double* pYMag = new double [nx];
1296     for (i = 0; i < nx; i++) {
1297       pX[i] = i;
1298       pYReal[i] = pcIn[i].re;
1299       pYImag[i] = pcIn[i].im;
1300       pYMag[i] = ::sqrt (pcIn[i].re * pcIn[i].re + pcIn[i].im * pcIn[i].im);
1301     }
1302     Fourier::shuffleFourierToNaturalOrder (pYReal, nx);
1303     Fourier::shuffleFourierToNaturalOrder (pYImag, nx);
1304     Fourier::shuffleFourierToNaturalOrder (pYMag, nx);
1305
1306     PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1307     if (! pPlotDoc) {
1308       sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1309     } else {
1310       PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1311       std::ostringstream os;
1312       os << "Row " << yCursor;
1313       std::string title("title ");
1314       title += os.str();
1315       rPlotFile.addEzsetCommand (title.c_str());
1316       rPlotFile.addEzsetCommand ("xlabel Column");
1317       rPlotFile.addEzsetCommand ("ylabel Pixel Value");
1318       rPlotFile.addEzsetCommand ("lxfrac 0");
1319       rPlotFile.addEzsetCommand ("curve 1");
1320       rPlotFile.addEzsetCommand ("color 1");
1321       rPlotFile.addEzsetCommand ("dash 1");
1322       rPlotFile.addEzsetCommand ("curve 2");
1323       rPlotFile.addEzsetCommand ("color 4");
1324       rPlotFile.addEzsetCommand ("dash 3");
1325       rPlotFile.addEzsetCommand ("curve 3");
1326       rPlotFile.addEzsetCommand ("color 0");
1327       rPlotFile.addEzsetCommand ("solid");
1328       rPlotFile.addEzsetCommand ("box");
1329       rPlotFile.addEzsetCommand ("grid");
1330       rPlotFile.setCurveSize (4, nx);
1331       rPlotFile.addColumn (0, pX);
1332       rPlotFile.addColumn (1, pYReal);
1333       rPlotFile.addColumn (2, pYImag);
1334       rPlotFile.addColumn (3, pYMag);
1335       for (int iL = 0; iL < rIF.nLabels(); iL++)
1336         rPlotFile.addDescription (rIF.labelGet(iL).getLabelString().c_str());
1337       os << " FFT Plot of " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1338       *theApp->getLog() << os.str().c_str() << "\n";
1339       rPlotFile.addDescription (os.str().c_str());
1340     }
1341     delete pX;
1342     delete pYReal;
1343     delete pYImag;
1344     delete pYMag;
1345     delete [] pcIn;
1346
1347     if (theApp->getSetModifyNewDocs())
1348       pPlotDoc->Modify(true);
1349     pPlotDoc->UpdateAllViews();
1350   }
1351 }
1352
1353 void
1354 ImageFileView::OnPlotFFTCol (wxCommandEvent& event)
1355 {
1356   int xCursor, yCursor;
1357   if (! m_canvas->GetCurrentCursor (xCursor, yCursor)) {
1358     wxMessageBox ("No column selected. Please use left mouse button on image to select column","Error");
1359     return;
1360   }
1361
1362   const ImageFile& rIF = dynamic_cast<ImageFileDocument*>(GetDocument())->getImageFile();
1363   ImageFileArrayConst v = rIF.getArray();
1364   ImageFileArrayConst vImag = rIF.getImaginaryArray();
1365   int nx = rIF.nx();
1366   int ny = rIF.ny();
1367
1368   if (v != NULL && xCursor < nx) {
1369     fftw_complex* pcIn = new fftw_complex [ny];
1370     double *pdTemp = new double [ny];
1371
1372     int i;
1373     for (i = 0; i < ny; i++)
1374       pdTemp[i] = v[xCursor][i];
1375     Fourier::shuffleNaturalToFourierOrder (pdTemp, ny);
1376     for (i = 0; i < ny; i++)
1377       pcIn[i].re = pdTemp[i];
1378
1379     for (i = 0; i < ny; i++) {
1380       if (rIF.isComplex())
1381         pdTemp[i] = vImag[xCursor][i];
1382       else
1383         pdTemp[i] = 0;
1384     }
1385     Fourier::shuffleNaturalToFourierOrder (pdTemp, ny);
1386     for (i = 0; i < ny; i++)
1387       pcIn[i].im = pdTemp[i];
1388
1389     fftw_plan plan = fftw_create_plan (ny, FFTW_BACKWARD, FFTW_IN_PLACE);
1390     fftw_one (plan, pcIn, NULL);
1391     fftw_destroy_plan (plan);
1392
1393     double* pX = new double [ny];
1394     double* pYReal = new double [ny];
1395     double* pYImag = new double [ny];
1396     double* pYMag = new double [ny];
1397     for (i = 0; i < ny; i++) {
1398       pX[i] = i;
1399       pYReal[i] = pcIn[i].re;
1400       pYImag[i] = pcIn[i].im;
1401       pYMag[i] = ::sqrt (pcIn[i].re * pcIn[i].re + pcIn[i].im * pcIn[i].im);
1402     }
1403
1404     PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1405     if (! pPlotDoc) {
1406       sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1407     } else {
1408       PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1409       std::ostringstream os;
1410       os << "Column " << xCursor;
1411       std::string title("title ");
1412       title += os.str();
1413       rPlotFile.addEzsetCommand (title.c_str());
1414       rPlotFile.addEzsetCommand ("xlabel Column");
1415       rPlotFile.addEzsetCommand ("ylabel Pixel Value");
1416       rPlotFile.addEzsetCommand ("lxfrac 0");
1417       rPlotFile.addEzsetCommand ("curve 1");
1418       rPlotFile.addEzsetCommand ("color 1");
1419       rPlotFile.addEzsetCommand ("dash 1");
1420       rPlotFile.addEzsetCommand ("curve 2");
1421       rPlotFile.addEzsetCommand ("color 4");
1422       rPlotFile.addEzsetCommand ("dash 3");
1423       rPlotFile.addEzsetCommand ("curve 3");
1424       rPlotFile.addEzsetCommand ("color 0");
1425       rPlotFile.addEzsetCommand ("solid");
1426       rPlotFile.addEzsetCommand ("box");
1427       rPlotFile.addEzsetCommand ("grid");
1428       rPlotFile.setCurveSize (4, ny);
1429       rPlotFile.addColumn (0, pX);
1430       rPlotFile.addColumn (1, pYReal);
1431       rPlotFile.addColumn (2, pYImag);
1432       rPlotFile.addColumn (3, pYMag);
1433       for (int iL = 0; iL < rIF.nLabels(); iL++)
1434         rPlotFile.addDescription (rIF.labelGet(iL).getLabelString().c_str());
1435       os << " FFT Plot of " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1436       *theApp->getLog() << os.str().c_str() << "\n";
1437       rPlotFile.addDescription (os.str().c_str());
1438     }
1439     delete pX;
1440     delete pYReal;
1441     delete pYImag;
1442     delete pYMag;
1443     delete pdTemp;
1444     delete [] pcIn;
1445
1446     if (theApp->getSetModifyNewDocs())
1447       pPlotDoc->Modify(true);
1448     pPlotDoc->UpdateAllViews();
1449   }
1450 }
1451 #endif
1452
1453 void
1454 ImageFileView::OnCompareCol (wxCommandEvent& event)
1455 {
1456   int xCursor, yCursor;
1457   if (! m_canvas->GetCurrentCursor (xCursor, yCursor)) {
1458     wxMessageBox ("No column selected. Please use left mouse button on image to select column","Error");
1459     return;
1460   }
1461
1462   std::vector<ImageFileDocument*> vecIFDoc;
1463   theApp->getCompatibleImages (GetDocument(), vecIFDoc);
1464   if (vecIFDoc.size() == 0) {
1465     wxMessageBox ("No compatible images for Column Comparison", "Error");
1466     return;
1467   }
1468   DialogGetComparisonImage dialogGetCompare (getFrameForChild(), "Get Comparison Image", vecIFDoc, false);
1469
1470   if (dialogGetCompare.ShowModal() == wxID_OK) {
1471     ImageFileDocument* pCompareDoc = dialogGetCompare.getImageFileDocument();
1472     const ImageFile& rIF = GetDocument()->getImageFile();
1473     const ImageFile& rCompareIF = pCompareDoc->getImageFile();
1474
1475     ImageFileArrayConst v1 = rIF.getArray();
1476     ImageFileArrayConst v2 = rCompareIF.getArray();
1477     int nx = rIF.nx();
1478     int ny = rIF.ny();
1479
1480     if (v1 != NULL && xCursor < nx) {
1481       double* pX = new double [ny];
1482       double* pY1 = new double [ny];
1483       double* pY2 = new double [ny];
1484       for (int i = 0; i < ny; i++) {
1485         pX[i] = i;
1486         pY1[i] = v1[xCursor][i];
1487         pY2[i] = v2[xCursor][i];
1488       }
1489       PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1490       if (! pPlotDoc) {
1491         sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1492       } else {
1493         PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1494         std::ostringstream os;
1495         os << "Column " << xCursor << " Comparison";
1496         std::string title("title ");
1497         title += os.str();
1498         rPlotFile.addEzsetCommand (title.c_str());
1499         rPlotFile.addEzsetCommand ("xlabel Row");
1500         rPlotFile.addEzsetCommand ("ylabel Pixel Value");
1501         rPlotFile.addEzsetCommand ("lxfrac 0");
1502         rPlotFile.addEzsetCommand ("curve 1");
1503         rPlotFile.addEzsetCommand ("color 2");
1504         rPlotFile.addEzsetCommand ("curve 2");
1505         rPlotFile.addEzsetCommand ("color 4");
1506         rPlotFile.addEzsetCommand ("dash 5");
1507         rPlotFile.addEzsetCommand ("box");
1508         rPlotFile.addEzsetCommand ("grid");
1509         rPlotFile.setCurveSize (3, ny);
1510         rPlotFile.addColumn (0, pX);
1511         rPlotFile.addColumn (1, pY1);
1512         rPlotFile.addColumn (2, pY2);
1513
1514         unsigned int iL;
1515         for (iL = 0; iL < rIF.nLabels(); iL++) {
1516           std::string s = GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1517           s += ": ";
1518           s += rIF.labelGet(iL).getLabelString();
1519           rPlotFile.addDescription (s.c_str());
1520         }
1521         for (iL = 0; iL < rCompareIF.nLabels(); iL++) {
1522           std::string s = pCompareDoc->GetFirstView()->GetFrame()->GetTitle().c_str();
1523           s += ": ";
1524           s += rCompareIF.labelGet(iL).getLabelString();
1525           rPlotFile.addDescription (s.c_str());
1526         }
1527         os << " Between " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str() << " and "
1528           << pCompareDoc->GetFirstView()->GetFrame()->GetTitle().c_str();
1529         *theApp->getLog() << os.str().c_str() << "\n";
1530         rPlotFile.addDescription (os.str().c_str());
1531       }
1532       delete pX;
1533       delete pY1;
1534       delete pY2;
1535       if (theApp->getSetModifyNewDocs())
1536         pPlotDoc->Modify(true);
1537       pPlotDoc->UpdateAllViews();
1538     }
1539   }
1540 }
1541
1542 void
1543 ImageFileView::OnCompareRow (wxCommandEvent& event)
1544 {
1545   int xCursor, yCursor;
1546   if (! m_canvas->GetCurrentCursor (xCursor, yCursor)) {
1547     wxMessageBox ("No column selected. Please use left mouse button on image to select column","Error");
1548     return;
1549   }
1550
1551   std::vector<ImageFileDocument*> vecIFDoc;
1552   theApp->getCompatibleImages (GetDocument(), vecIFDoc);
1553
1554   if (vecIFDoc.size() == 0) {
1555     wxMessageBox ("No compatible images for Row Comparison", "Error");
1556     return;
1557   }
1558
1559   DialogGetComparisonImage dialogGetCompare (getFrameForChild(), "Get Comparison Image", vecIFDoc, false);
1560
1561   if (dialogGetCompare.ShowModal() == wxID_OK) {
1562     ImageFileDocument* pCompareDoc = dialogGetCompare.getImageFileDocument();
1563     const ImageFile& rIF = GetDocument()->getImageFile();
1564     const ImageFile& rCompareIF = pCompareDoc->getImageFile();
1565
1566     ImageFileArrayConst v1 = rIF.getArray();
1567     ImageFileArrayConst v2 = rCompareIF.getArray();
1568     int nx = rIF.nx();
1569     int ny = rIF.ny();
1570
1571     if (v1 != NULL && yCursor < ny) {
1572       double* pX = new double [nx];
1573       double* pY1 = new double [nx];
1574       double* pY2 = new double [nx];
1575       for (int i = 0; i < nx; i++) {
1576         pX[i] = i;
1577         pY1[i] = v1[i][yCursor];
1578         pY2[i] = v2[i][yCursor];
1579       }
1580       PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1581       if (! pPlotDoc) {
1582         sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1583       } else {
1584         PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1585         std::ostringstream os;
1586         os << "Row " << yCursor << " Comparison";
1587         std::string title("title ");
1588         title += os.str();
1589         rPlotFile.addEzsetCommand (title.c_str());
1590         rPlotFile.addEzsetCommand ("xlabel Column");
1591         rPlotFile.addEzsetCommand ("ylabel Pixel Value");
1592         rPlotFile.addEzsetCommand ("lxfrac 0");
1593         rPlotFile.addEzsetCommand ("curve 1");
1594         rPlotFile.addEzsetCommand ("color 2");
1595         rPlotFile.addEzsetCommand ("curve 2");
1596         rPlotFile.addEzsetCommand ("color 4");
1597         rPlotFile.addEzsetCommand ("dash 5");
1598         rPlotFile.addEzsetCommand ("box");
1599         rPlotFile.addEzsetCommand ("grid");
1600         rPlotFile.setCurveSize (3, nx);
1601         rPlotFile.addColumn (0, pX);
1602         rPlotFile.addColumn (1, pY1);
1603         rPlotFile.addColumn (2, pY2);
1604         unsigned int iL;
1605         for (iL = 0; iL < rIF.nLabels(); iL++) {
1606           std::string s = GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1607           s += ": ";
1608           s += rIF.labelGet(iL).getLabelString();
1609           rPlotFile.addDescription (s.c_str());
1610         }
1611         for (iL = 0; iL < rCompareIF.nLabels(); iL++) {
1612           std::string s = pCompareDoc->GetFirstView()->GetFrame()->GetTitle().c_str();
1613           s += ": ";
1614           s += rCompareIF.labelGet(iL).getLabelString();
1615           rPlotFile.addDescription (s.c_str());
1616         }
1617         os << " Between " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str() << " and "
1618           << pCompareDoc->GetFirstView()->GetFrame()->GetTitle().c_str();
1619         *theApp->getLog() << os.str().c_str() << "\n";
1620         rPlotFile.addDescription (os.str().c_str());
1621       }
1622       delete pX;
1623       delete pY1;
1624       delete pY2;
1625       if (theApp->getSetModifyNewDocs())
1626         pPlotDoc->Modify(true);
1627       pPlotDoc->UpdateAllViews();
1628     }
1629   }
1630 }
1631
1632 static int NUMBER_HISTOGRAM_BINS = 256;
1633
1634 void
1635 ImageFileView::OnPlotHistogram (wxCommandEvent& event)
1636 {
1637   const ImageFile& rIF = dynamic_cast<ImageFileDocument*>(GetDocument())->getImageFile();
1638   ImageFileArrayConst v = rIF.getArray();
1639   int nx = rIF.nx();
1640   int ny = rIF.ny();
1641
1642   if (v != NULL && nx > 0 && ny > 0) {
1643     PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1644     if (! pPlotDoc) {
1645       sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1646       return;
1647     }
1648
1649     double* pX = new double [NUMBER_HISTOGRAM_BINS];
1650     double* pY = new double [NUMBER_HISTOGRAM_BINS];
1651     double dMin, dMax;
1652     rIF.getMinMax (dMin, dMax);
1653     double dBinWidth = (dMax - dMin) / NUMBER_HISTOGRAM_BINS;
1654
1655     for (int i = 0; i < NUMBER_HISTOGRAM_BINS; i++) {
1656       pX[i] = dMin + (i + 0.5) * dBinWidth;
1657       pY[i] = 0;
1658     }
1659     for (int ix = 0; ix < nx; ix++)
1660       for (int iy = 0; iy < ny; iy++) {
1661         int iBin = nearest<int> ((v[ix][iy] - dMin) / dBinWidth);
1662         if (iBin >= 0 && iBin < NUMBER_HISTOGRAM_BINS)
1663           pY[iBin] += 1;
1664       }
1665
1666       PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1667       std::ostringstream os;
1668       os << "Histogram";
1669       std::string title("title ");
1670       title += os.str();
1671       rPlotFile.addEzsetCommand (title.c_str());
1672       rPlotFile.addEzsetCommand ("xlabel Pixel Value");
1673       rPlotFile.addEzsetCommand ("ylabel Count");
1674       rPlotFile.addEzsetCommand ("box");
1675       rPlotFile.addEzsetCommand ("grid");
1676       rPlotFile.setCurveSize (2, NUMBER_HISTOGRAM_BINS);
1677       rPlotFile.addColumn (0, pX);
1678       rPlotFile.addColumn (1, pY);
1679       for (unsigned int iL = 0; iL < rIF.nLabels(); iL++) {
1680         std::string s = GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1681         s += ": ";
1682         s += rIF.labelGet(iL).getLabelString();
1683         rPlotFile.addDescription (s.c_str());
1684       }
1685       os << " Plot of " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1686       *theApp->getLog() << os.str().c_str() << "\n";
1687       rPlotFile.addDescription (os.str().c_str());
1688       delete pX;
1689       delete pY;
1690       if (theApp->getSetModifyNewDocs())
1691         pPlotDoc->Modify(true);
1692       pPlotDoc->UpdateAllViews();
1693   }
1694 }
1695
1696
1697 // PhantomCanvas
1698
1699 PhantomCanvas::PhantomCanvas (PhantomFileView* v, wxFrame *frame, const wxPoint& pos, const wxSize& size, const long style)
1700 : wxScrolledWindow(frame, -1, pos, size, style)
1701 {
1702   m_pView = v;
1703 }
1704
1705 PhantomCanvas::~PhantomCanvas ()
1706 {
1707   if (m_pView) {
1708     wxMenu* pMenu = m_pView->getFileMenu();
1709     theApp->getDocManager()->FileHistoryRemoveMenu (pMenu);
1710     m_pView->canvasClosed();
1711     m_pView = NULL;
1712   }
1713 }
1714
1715 void
1716 PhantomCanvas::OnDraw (wxDC& dc)
1717 {
1718   if (m_pView)
1719     m_pView->OnDraw(& dc);
1720 }
1721
1722
1723 // PhantomFileView
1724
1725 IMPLEMENT_DYNAMIC_CLASS(PhantomFileView, wxView)
1726
1727 BEGIN_EVENT_TABLE(PhantomFileView, wxView)
1728 EVT_MENU(PHMMENU_FILE_PROPERTIES, PhantomFileView::OnProperties)
1729 EVT_MENU(PHMMENU_PROCESS_RASTERIZE, PhantomFileView::OnRasterize)
1730 EVT_MENU(PHMMENU_PROCESS_PROJECTIONS, PhantomFileView::OnProjections)
1731 END_EVENT_TABLE()
1732
1733 PhantomFileView::PhantomFileView(void)
1734 : wxView(), m_canvas(NULL), m_frame(NULL), m_pFileMenu(0)
1735 {
1736   m_iDefaultNDet = 367;
1737   m_iDefaultNView = 320;
1738   m_iDefaultNSample = 2;
1739   m_dDefaultRotation = 1;
1740   m_dDefaultFocalLength = 2;
1741   m_dDefaultFieldOfView = 1;
1742   m_iDefaultGeometry = Scanner::GEOMETRY_PARALLEL;
1743   m_iDefaultTrace = Trace::TRACE_NONE;
1744
1745   m_iDefaultRasterNX = 256;
1746   m_iDefaultRasterNY = 256;
1747   m_iDefaultRasterNSamples = 2;
1748 }
1749
1750 PhantomFileView::~PhantomFileView()
1751 {
1752 }
1753
1754 void
1755 PhantomFileView::OnProperties (wxCommandEvent& event)
1756 {
1757   const int idPhantom = GetDocument()->getPhantomID();
1758   const wxString& namePhantom = GetDocument()->getPhantomName();
1759   std::ostringstream os;
1760   os << "Phantom " << namePhantom.c_str() << " (" << idPhantom << ")" << "\n";
1761   const Phantom& rPhantom = GetDocument()->getPhantom();
1762   rPhantom.printDefinitions (os);
1763 #if DEBUG
1764   rPhantom.print (os);
1765 #endif
1766   *theApp->getLog() << os.str().c_str() << "\n";
1767   wxMessageBox (os.str().c_str(), "Phantom Properties");
1768 }
1769
1770
1771 void
1772 PhantomFileView::OnProjections (wxCommandEvent& event)
1773 {
1774   DialogGetProjectionParameters dialogProjection (getFrameForChild(), m_iDefaultNDet, m_iDefaultNView, m_iDefaultNSample, m_dDefaultRotation, m_dDefaultFocalLength, m_dDefaultFieldOfView, m_iDefaultGeometry, m_iDefaultTrace);
1775   int retVal = dialogProjection.ShowModal();
1776   if (retVal == wxID_OK) {
1777     m_iDefaultNDet = dialogProjection.getNDet();
1778     m_iDefaultNView = dialogProjection.getNView();
1779     m_iDefaultNSample = dialogProjection.getNSamples();
1780     m_iDefaultTrace = dialogProjection.getTrace();
1781     m_dDefaultRotation = dialogProjection.getRotAngle();
1782     m_dDefaultFocalLength = dialogProjection.getFocalLengthRatio();
1783     m_dDefaultFieldOfView = dialogProjection.getFieldOfViewRatio();
1784     wxString sGeometry = dialogProjection.getGeometry();
1785     m_iDefaultGeometry = Scanner::convertGeometryNameToID (sGeometry.c_str());
1786
1787     if (m_iDefaultNDet > 0 && m_iDefaultNView > 0 && sGeometry != "") {
1788       const Phantom& rPhantom = GetDocument()->getPhantom();
1789       ProjectionFileDocument* pProjectionDoc = theApp->newProjectionDoc();
1790       if (! pProjectionDoc) {
1791         sys_error (ERR_SEVERE, "Unable to create projection document");
1792         return;
1793       }
1794       Projections& rProj = pProjectionDoc->getProjections();
1795       Scanner theScanner (rPhantom, sGeometry.c_str(), m_iDefaultNDet, m_iDefaultNView, m_iDefaultNSample, m_dDefaultRotation, m_dDefaultFocalLength, m_dDefaultFieldOfView);
1796       if (theScanner.fail()) {
1797         *theApp->getLog() << "Failed making scanner: " << theScanner.failMessage().c_str() << "\n";
1798         return;
1799       }
1800       rProj.initFromScanner (theScanner);
1801       m_dDefaultRotation /= PI;  // convert back to PI units
1802
1803       Timer timer;
1804       if (m_iDefaultTrace > Trace::TRACE_CONSOLE) {
1805         ProjectionsDialog dialogProjections (theScanner, rProj, rPhantom, m_iDefaultTrace, dynamic_cast<wxWindow*>(getFrameForChild()));
1806         for (int iView = 0; iView < rProj.nView(); iView++) {
1807           ::wxYield();
1808           ::wxYield();
1809           if (dialogProjections.isCancelled() || ! dialogProjections.projectView (iView)) {
1810             pProjectionDoc->DeleteAllViews();
1811             return;
1812           }
1813           ::wxYield();
1814           ::wxYield();
1815           while (dialogProjections.isPaused()) {
1816             ::wxYield();
1817             ::wxUsleep(50);
1818           }
1819         }
1820       } else {
1821         wxProgressDialog dlgProgress (wxString("Projection"), wxString("Projection Progress"), rProj.nView() + 1, getFrameForChild(), wxPD_CAN_ABORT);
1822         for (int i = 0; i < rProj.nView(); i++) {
1823           theScanner.collectProjections (rProj, rPhantom, i, 1, true, m_iDefaultTrace);
1824           if (! dlgProgress.Update (i+1)) {
1825             pProjectionDoc->DeleteAllViews();
1826             return;
1827           }
1828         }
1829       }
1830
1831       std::ostringstream os;
1832       os << "Projections for " << rPhantom.name() << ": nDet=" << m_iDefaultNDet << ", nView=" << m_iDefaultNView << ", nSamples=" << m_iDefaultNSample << ", RotAngle=" << m_dDefaultRotation << ", FocalLengthRatio=" << m_dDefaultFocalLength << ", FieldOfViewRatio=" << m_dDefaultFieldOfView << ", Geometry=" << sGeometry.c_str();
1833       rProj.setCalcTime (timer.timerEnd());
1834       rProj.setRemark (os.str());
1835       *theApp->getLog() << os.str().c_str() << "\n";
1836
1837       m_frame->Lower();
1838       ::wxYield();
1839       ProjectionFileView* projView = dynamic_cast<ProjectionFileView*>(pProjectionDoc->GetFirstView());
1840       if (projView) {
1841         projView->getFrame()->SetFocus();
1842         projView->OnUpdate (projView, NULL);
1843       }
1844       if (wxView* pView = pProjectionDoc->GetFirstView()) {
1845         if (wxFrame* pFrame = pView->GetFrame()) {
1846           pFrame->SetFocus();
1847           pFrame->Raise();
1848         }
1849         theApp->getDocManager()->ActivateView (pView, true, false);
1850       }
1851       ::wxYield();
1852       if (theApp->getSetModifyNewDocs())
1853         pProjectionDoc->Modify(true);
1854       pProjectionDoc->UpdateAllViews(this);
1855     }
1856   }
1857 }
1858
1859
1860 void
1861 PhantomFileView::OnRasterize (wxCommandEvent& event)
1862 {
1863   DialogGetRasterParameters dialogRaster (getFrameForChild(), m_iDefaultRasterNX, m_iDefaultRasterNY, m_iDefaultRasterNSamples);
1864   int retVal = dialogRaster.ShowModal();
1865   if (retVal == wxID_OK) {
1866     m_iDefaultRasterNX = dialogRaster.getXSize();
1867     m_iDefaultRasterNY  = dialogRaster.getYSize();
1868     m_iDefaultRasterNSamples = dialogRaster.getNSamples();
1869     if (m_iDefaultRasterNSamples < 1)
1870       m_iDefaultRasterNSamples = 1;
1871     if (m_iDefaultRasterNX > 0 && m_iDefaultRasterNY > 0) {
1872       const Phantom& rPhantom = GetDocument()->getPhantom();
1873       ImageFileDocument* pRasterDoc = theApp->newImageDoc();
1874       if (! pRasterDoc) {
1875         sys_error (ERR_SEVERE, "Unable to create image file");
1876         return;
1877       }
1878       ImageFile& imageFile = pRasterDoc->getImageFile();
1879
1880       imageFile.setArraySize (m_iDefaultRasterNX, m_iDefaultRasterNX);
1881       wxProgressDialog dlgProgress (wxString("Rasterize"), wxString("Rasterization Progress"), imageFile.nx() + 1, getFrameForChild(), wxPD_CAN_ABORT);
1882       Timer timer;
1883       for (unsigned int i = 0; i < imageFile.nx(); i++) {
1884         rPhantom.convertToImagefile (imageFile, m_iDefaultRasterNSamples, Trace::TRACE_NONE, i, 1, true);
1885         if (! dlgProgress.Update(i+1)) {
1886           pRasterDoc->DeleteAllViews();
1887           return;
1888         }
1889       }
1890       if (theApp->getSetModifyNewDocs())
1891         pRasterDoc->Modify(true);
1892       pRasterDoc->UpdateAllViews(this);
1893       std::ostringstream os;
1894       os << "Rasterize Phantom " << rPhantom.name() << ": XSize=" << m_iDefaultRasterNX << ", YSize="
1895         << m_iDefaultRasterNY << ", nSamples=" << m_iDefaultRasterNSamples;
1896       *theApp->getLog() << os.str().c_str() << "\n";
1897       imageFile.labelAdd (os.str().c_str(), timer.timerEnd());
1898       ImageFileView* rasterView = dynamic_cast<ImageFileView*>(pRasterDoc->GetFirstView());
1899       if (rasterView) {
1900         rasterView->getFrame()->SetFocus();
1901         rasterView->OnUpdate (rasterView, NULL);
1902       }
1903
1904     }
1905   }
1906 }
1907
1908
1909 PhantomCanvas*
1910 PhantomFileView::CreateCanvas (wxView *view, wxFrame *parent)
1911 {
1912   PhantomCanvas* pCanvas;
1913   int width, height;
1914   parent->GetClientSize(&width, &height);
1915
1916   pCanvas = new PhantomCanvas (dynamic_cast<PhantomFileView*>(view), parent, wxPoint(0, 0), wxSize(width, height), 0);
1917
1918   pCanvas->SetBackgroundColour(*wxWHITE);
1919   pCanvas->Clear();
1920
1921   return pCanvas;
1922 }
1923
1924 wxFrame*
1925 PhantomFileView::CreateChildFrame(wxDocument *doc, wxView *view)
1926 {
1927 #if CTSIM_MDI
1928   wxDocMDIChildFrame *subframe = new wxDocMDIChildFrame (doc, view, theApp->getMainFrame(), -1, "Phantom Frame", wxPoint(10, 10), wxSize(256, 256), wxDEFAULT_FRAME_STYLE);
1929 #else
1930   wxDocChildFrame *subframe = new wxDocChildFrame (doc, view, theApp->getMainFrame(), -1, "Phantom Frame", wxPoint(10, 10), wxSize(256, 256), wxDEFAULT_FRAME_STYLE);
1931 #endif
1932   theApp->setIconForFrame (subframe);
1933
1934   wxMenu *m_pFileMenu = new wxMenu;
1935
1936   m_pFileMenu->Append(MAINMENU_FILE_CREATE_PHANTOM, "Cr&eate Phantom...\tCtrl-P");
1937   m_pFileMenu->Append(MAINMENU_FILE_CREATE_FILTER, "Create &Filter...\tCtrl-F");
1938   m_pFileMenu->Append(wxID_OPEN, "&Open...\tCtrl-O");
1939   m_pFileMenu->Append(wxID_SAVEAS, "Save &As...");
1940   m_pFileMenu->Append(wxID_CLOSE, "&Close");
1941
1942   m_pFileMenu->AppendSeparator();
1943   m_pFileMenu->Append(PHMMENU_FILE_PROPERTIES, "P&roperties");
1944
1945   m_pFileMenu->AppendSeparator();
1946   m_pFileMenu->Append(wxID_PRINT, "&Print...");
1947   m_pFileMenu->Append(wxID_PRINT_SETUP, "Print &Setup...");
1948   m_pFileMenu->Append(wxID_PREVIEW, "Print Pre&view");
1949 #ifdef CTSIM_MDI
1950   m_pFileMenu->AppendSeparator();
1951   m_pFileMenu->Append(MAINMENU_FILE_EXIT, "E&xit");
1952 #endif
1953   theApp->getDocManager()->FileHistoryAddFilesToMenu(m_pFileMenu);
1954   theApp->getDocManager()->FileHistoryUseMenu(m_pFileMenu);
1955
1956   wxMenu *process_menu = new wxMenu;
1957   process_menu->Append(PHMMENU_PROCESS_RASTERIZE, "&Rasterize...\tCtrl-R");
1958   process_menu->Append(PHMMENU_PROCESS_PROJECTIONS, "&Projections...\tCtrl-J");
1959
1960   wxMenu *help_menu = new wxMenu;
1961   help_menu->Append(MAINMENU_HELP_CONTENTS, "&Contents\tF1");
1962   help_menu->Append(MAINMENU_HELP_TOPICS, "&Topics\tCtrl-H");
1963   help_menu->Append(MAINMENU_HELP_ABOUT, "&About");
1964
1965   wxMenuBar *menu_bar = new wxMenuBar;
1966
1967   menu_bar->Append(m_pFileMenu, "&File");
1968   menu_bar->Append(process_menu, "&Process");
1969   menu_bar->Append(help_menu, "&Help");
1970
1971   subframe->SetMenuBar(menu_bar);
1972   subframe->Centre(wxBOTH);
1973
1974   wxAcceleratorEntry accelEntries[8];
1975   accelEntries[0].Set (wxACCEL_CTRL, static_cast<int>('O'), wxID_OPEN);
1976   accelEntries[1].Set (wxACCEL_CTRL, static_cast<int>('S'), wxID_SAVE);
1977   accelEntries[2].Set (wxACCEL_CTRL, static_cast<int>('H'), MAINMENU_HELP_TOPICS);
1978   accelEntries[3].Set (wxACCEL_CTRL, static_cast<int>('P'), MAINMENU_FILE_CREATE_PHANTOM);
1979   accelEntries[4].Set (wxACCEL_CTRL, static_cast<int>('F'), MAINMENU_FILE_CREATE_FILTER);
1980   accelEntries[5].Set (wxACCEL_NORMAL, WXK_F1, MAINMENU_HELP_CONTENTS);
1981   accelEntries[6].Set (wxACCEL_CTRL, static_cast<int>('J'), PHMMENU_PROCESS_PROJECTIONS);
1982   accelEntries[7].Set (wxACCEL_CTRL, static_cast<int>('R'), PHMMENU_PROCESS_RASTERIZE);
1983   wxAcceleratorTable accelTable (8, accelEntries);
1984   subframe->SetAcceleratorTable (accelTable);
1985
1986   return subframe;
1987 }
1988
1989
1990 bool
1991 PhantomFileView::OnCreate(wxDocument *doc, long WXUNUSED(flags) )
1992 {
1993   m_frame = CreateChildFrame(doc, this);
1994   SetFrame(m_frame);
1995
1996   int width, height;
1997   m_frame->GetClientSize(&width, &height);
1998   m_frame->SetTitle("PhantomFileView");
1999   m_canvas = CreateCanvas (this, m_frame);
2000
2001 #ifdef __X__
2002   int x, y;  // X requires a forced resize
2003   m_frame->GetSize(&x, &y);
2004   m_frame->SetSize(-1, -1, x, y);
2005 #endif
2006
2007   m_frame->Show(true);
2008   Activate(true);
2009
2010   return true;
2011 }
2012
2013 void
2014 PhantomFileView::OnUpdate(wxView *WXUNUSED(sender), wxObject *WXUNUSED(hint) )
2015 {
2016   if (m_canvas)
2017     m_canvas->Refresh();
2018 }
2019
2020 bool
2021 PhantomFileView::OnClose (bool deleteWindow)
2022 {
2023   if (!GetDocument()->Close())
2024     return false;
2025
2026 //  m_canvas->Clear();
2027 //  m_canvas->setView(NULL);
2028   m_canvas = NULL;
2029   wxString s(wxTheApp->GetAppName());
2030   if (m_frame)
2031     m_frame->SetTitle(s);
2032   SetFrame(NULL);
2033
2034   Activate(false);
2035
2036   if (deleteWindow) {
2037     delete m_frame;
2038     m_frame = NULL;
2039   }
2040
2041   return true;
2042 }
2043
2044 void
2045 PhantomFileView::OnDraw (wxDC* dc)
2046 {
2047   int xsize, ysize;
2048   m_canvas->GetClientSize (&xsize, &ysize);
2049   SGPDriver driver (dc, xsize, ysize);
2050   SGP sgp (driver);
2051   const Phantom& rPhantom = GetDocument()->getPhantom();
2052   sgp.setColor (C_RED);
2053   rPhantom.show (sgp);
2054 }
2055
2056 // ProjectionCanvas
2057
2058 ProjectionFileCanvas::ProjectionFileCanvas (ProjectionFileView* v, wxFrame *frame, const wxPoint& pos, const wxSize& size, const long style)
2059 : wxScrolledWindow(frame, -1, pos, size, style)
2060 {
2061   m_pView = v;
2062 }
2063
2064 ProjectionFileCanvas::~ProjectionFileCanvas ()
2065 {
2066   if (m_pView) {
2067     wxMenu* pMenu = m_pView->getFileMenu();
2068     theApp->getDocManager()->FileHistoryRemoveMenu (pMenu);
2069     m_pView->canvasClosed();
2070     m_pView = NULL;
2071   }
2072 }
2073
2074 void
2075 ProjectionFileCanvas::OnDraw(wxDC& dc)
2076 {
2077   if (m_pView)
2078     m_pView->OnDraw(& dc);
2079 }
2080
2081 wxSize
2082 ProjectionFileCanvas::GetBestSize () const
2083 {
2084   wxSize best (0, 0);
2085   if (m_pView) {
2086     Projections& rProj = m_pView->GetDocument()->getProjections();
2087     best.Set (rProj.nDet(), rProj.nView());
2088   }
2089
2090   return best;
2091 }
2092
2093
2094 // ProjectionFileView
2095
2096 IMPLEMENT_DYNAMIC_CLASS(ProjectionFileView, wxView)
2097
2098 BEGIN_EVENT_TABLE(ProjectionFileView, wxView)
2099 EVT_MENU(PJMENU_FILE_PROPERTIES, ProjectionFileView::OnProperties)
2100 EVT_MENU(PJMENU_RECONSTRUCT_FBP, ProjectionFileView::OnReconstructFBP)
2101 EVT_MENU(PJMENU_CONVERT_POLAR, ProjectionFileView::OnConvertPolar)
2102 EVT_MENU(PJMENU_CONVERT_FFT_POLAR, ProjectionFileView::OnConvertFFTPolar)
2103 END_EVENT_TABLE()
2104
2105 ProjectionFileView::ProjectionFileView(void)
2106 : wxView(), m_canvas(NULL), m_frame(NULL), m_pFileMenu(0)
2107 {
2108   m_iDefaultNX = 256;
2109   m_iDefaultNY = 256;
2110   m_iDefaultFilter = SignalFilter::FILTER_ABS_BANDLIMIT;
2111   m_dDefaultFilterParam = 1.;
2112 #if HAVE_FFTW
2113   m_iDefaultFilterMethod = ProcessSignal::FILTER_METHOD_RFFTW;
2114   m_iDefaultFilterGeneration = ProcessSignal::FILTER_GENERATION_INVERSE_FOURIER;
2115 #else
2116   m_iDefaultFilterMethod = ProcessSignal::FILTER_METHOD_CONVOLUTION;
2117   m_iDefaultFilterGeneration = ProcessSignal::FILTER_GENERATION_DIRECT;
2118 #endif
2119   m_iDefaultZeropad = 1;
2120   m_iDefaultBackprojector = Backprojector::BPROJ_IDIFF3;
2121   m_iDefaultInterpolation = Backprojector::INTERP_LINEAR;
2122   m_iDefaultInterpParam = 1;
2123   m_iDefaultTrace = Trace::TRACE_NONE;
2124
2125   m_iDefaultPolarNX = 256;
2126   m_iDefaultPolarNY = 256;
2127   m_iDefaultPolarInterpolation = Projections::POLAR_INTERP_BILINEAR;
2128   m_iDefaultPolarZeropad = 1;
2129 }
2130
2131 ProjectionFileView::~ProjectionFileView(void)
2132 {
2133 }
2134
2135 void
2136 ProjectionFileView::OnProperties (wxCommandEvent& event)
2137 {
2138   const Projections& rProj = GetDocument()->getProjections();
2139   std::ostringstream os;
2140   rProj.printScanInfo(os);
2141   *theApp->getLog() << os.str().c_str();
2142   wxMessageDialog dialogMsg (getFrameForChild(), os.str().c_str(), "Projection File Properties", wxOK | wxICON_INFORMATION);
2143   dialogMsg.ShowModal();
2144 }
2145
2146
2147 void
2148 ProjectionFileView::OnConvertPolar (wxCommandEvent& event)
2149 {
2150   Projections& rProj = GetDocument()->getProjections();
2151   DialogGetConvertPolarParameters dialogPolar (getFrameForChild(), "Convert Polar", m_iDefaultPolarNX, m_iDefaultPolarNY,
2152     m_iDefaultPolarInterpolation, -1);
2153   if (dialogPolar.ShowModal() == wxID_OK) {
2154     wxString strInterpolation (dialogPolar.getInterpolationName());
2155     m_iDefaultPolarNX = dialogPolar.getXSize();
2156     m_iDefaultPolarNY = dialogPolar.getYSize();
2157     ImageFileDocument* pPolarDoc = theApp->newImageDoc();
2158     ImageFile& rIF = pPolarDoc->getImageFile();
2159     if (! pPolarDoc) {
2160       sys_error (ERR_SEVERE, "Unable to create image file");
2161       return;
2162     }
2163     rIF.setArraySize (m_iDefaultPolarNX, m_iDefaultPolarNY);
2164     m_iDefaultPolarInterpolation = Projections::convertInterpNameToID (strInterpolation.c_str());
2165     rProj.convertPolar (rIF, m_iDefaultPolarInterpolation);
2166     rIF.labelAdd (rProj.getLabel().getLabelString().c_str(), rProj.calcTime());
2167     std::ostringstream os;
2168     os << "Convert projection file " << GetFrame()->GetTitle().c_str() << " to polar image: xSize="
2169       << m_iDefaultPolarNX << ", ySize=" << m_iDefaultPolarNY << ", interpolation="
2170       << strInterpolation.c_str();
2171     *theApp->getLog() << os.str().c_str() << "\n";
2172     rIF.labelAdd (os.str().c_str());
2173     if (theApp->getSetModifyNewDocs())
2174       pPolarDoc->Modify(true);
2175     pPolarDoc->UpdateAllViews();
2176     pPolarDoc->GetFirstView()->OnUpdate (this, NULL);
2177   }
2178 }
2179
2180 void
2181 ProjectionFileView::OnConvertFFTPolar (wxCommandEvent& event)
2182 {
2183   Projections& rProj = GetDocument()->getProjections();
2184   DialogGetConvertPolarParameters dialogPolar (getFrameForChild(), "Convert to FFT Polar", m_iDefaultPolarNX, m_iDefaultPolarNY,
2185     m_iDefaultPolarInterpolation, m_iDefaultPolarZeropad);
2186   if (dialogPolar.ShowModal() == wxID_OK) {
2187     wxString strInterpolation (dialogPolar.getInterpolationName());
2188     m_iDefaultPolarNX = dialogPolar.getXSize();
2189     m_iDefaultPolarNY = dialogPolar.getYSize();
2190     m_iDefaultPolarZeropad = dialogPolar.getZeropad();
2191     ImageFileDocument* pPolarDoc = theApp->newImageDoc();
2192     ImageFile& rIF = pPolarDoc->getImageFile();
2193     if (! pPolarDoc) {
2194       sys_error (ERR_SEVERE, "Unable to create image file");
2195       return;
2196     }
2197     rIF.setArraySize (m_iDefaultPolarNX, m_iDefaultPolarNY);
2198     m_iDefaultPolarInterpolation = Projections::convertInterpNameToID (strInterpolation.c_str());
2199     rProj.convertFFTPolar (rIF, m_iDefaultPolarInterpolation, m_iDefaultPolarZeropad);
2200     rIF.labelAdd (rProj.getLabel().getLabelString().c_str(), rProj.calcTime());
2201     std::ostringstream os;
2202     os << "Convert projection file " << GetFrame()->GetTitle().c_str() << " to FFT polar image: xSize="
2203       << m_iDefaultPolarNX << ", ySize=" << m_iDefaultPolarNY << ", interpolation="
2204       << strInterpolation.c_str() << ", zeropad=" << m_iDefaultPolarZeropad;
2205     *theApp->getLog() << os.str().c_str() << "\n";
2206     rIF.labelAdd (os.str().c_str());
2207     if (theApp->getSetModifyNewDocs())
2208       pPolarDoc->Modify(true);
2209     pPolarDoc->UpdateAllViews();
2210     pPolarDoc->GetFirstView()->OnUpdate (this, NULL);
2211 }}
2212
2213 void
2214 ProjectionFileView::OnReconstructFourier (wxCommandEvent& event)
2215 {
2216   wxMessageBox ("Fourier Reconstruction is not yet supported", "Unimplemented function");
2217 }
2218
2219 void
2220 ProjectionFileView::OnReconstructFBP (wxCommandEvent& event)
2221 {
2222   DialogGetReconstructionParameters dialogReconstruction (getFrameForChild(), m_iDefaultNX, m_iDefaultNY, m_iDefaultFilter, m_dDefaultFilterParam, m_iDefaultFilterMethod, m_iDefaultFilterGeneration, m_iDefaultZeropad, m_iDefaultInterpolation, m_iDefaultInterpParam, m_iDefaultBackprojector, m_iDefaultTrace);
2223
2224   int retVal = dialogReconstruction.ShowModal();
2225   if (retVal == wxID_OK) {
2226     m_iDefaultNX = dialogReconstruction.getXSize();
2227     m_iDefaultNY = dialogReconstruction.getYSize();
2228     wxString optFilterName = dialogReconstruction.getFilterName();
2229     m_iDefaultFilter = SignalFilter::convertFilterNameToID (optFilterName.c_str());
2230     m_dDefaultFilterParam = dialogReconstruction.getFilterParam();
2231     wxString optFilterMethodName = dialogReconstruction.getFilterMethodName();
2232     m_iDefaultFilterMethod = ProcessSignal::convertFilterMethodNameToID(optFilterMethodName.c_str());
2233     m_iDefaultZeropad = dialogReconstruction.getZeropad();
2234     wxString optFilterGenerationName = dialogReconstruction.getFilterGenerationName();
2235     m_iDefaultFilterGeneration = ProcessSignal::convertFilterGenerationNameToID (optFilterGenerationName.c_str());
2236     wxString optInterpName = dialogReconstruction.getInterpName();
2237     m_iDefaultInterpolation = Backprojector::convertInterpNameToID (optInterpName.c_str());
2238     m_iDefaultInterpParam = dialogReconstruction.getInterpParam();
2239     wxString optBackprojectName = dialogReconstruction.getBackprojectName();
2240     m_iDefaultBackprojector = Backprojector::convertBackprojectNameToID (optBackprojectName.c_str());
2241     m_iDefaultTrace = dialogReconstruction.getTrace();
2242     if (m_iDefaultNX > 0 && m_iDefaultNY > 0) {
2243       ImageFileDocument* pReconDoc = theApp->newImageDoc();
2244       if (! pReconDoc) {
2245         sys_error (ERR_SEVERE, "Unable to create image file");
2246         return;
2247       }
2248       ImageFile& imageFile = pReconDoc->getImageFile();
2249       const Projections& rProj = GetDocument()->getProjections();
2250       imageFile.setArraySize (m_iDefaultNX, m_iDefaultNY);
2251
2252       Reconstructor* pReconstruct = new Reconstructor (rProj, imageFile, optFilterName.c_str(), m_dDefaultFilterParam, optFilterMethodName.c_str(), m_iDefaultZeropad, optFilterGenerationName.c_str(), optInterpName.c_str(), m_iDefaultInterpParam, optBackprojectName.c_str(), m_iDefaultTrace);
2253
2254       Timer timerRecon;
2255       if (m_iDefaultTrace > Trace::TRACE_CONSOLE) {
2256         ReconstructDialog* pDlgReconstruct = new ReconstructDialog (*pReconstruct, rProj, imageFile, m_iDefaultTrace, getFrameForChild());
2257         for (int iView = 0; iView < rProj.nView(); iView++) {
2258           ::wxYield();
2259           ::wxYield();
2260           if (pDlgReconstruct->isCancelled() || ! pDlgReconstruct->reconstructView (iView)) {
2261             delete pDlgReconstruct;
2262             delete pReconstruct;
2263             pReconDoc->DeleteAllViews();
2264             return;
2265           }
2266           ::wxYield();
2267           ::wxYield();
2268           while (pDlgReconstruct->isPaused()) {
2269             ::wxYield();
2270             ::wxUsleep(50);
2271           }
2272         }
2273         delete pDlgReconstruct;
2274       } else {
2275         wxProgressDialog dlgProgress (wxString("Reconstruction"), wxString("Reconstruction Progress"), rProj.nView() + 1, getFrameForChild(), wxPD_CAN_ABORT);
2276         for (int i = 0; i < rProj.nView(); i++) {
2277           pReconstruct->reconstructView (i, 1);
2278           if (! dlgProgress.Update(i + 1)) {
2279             delete pReconstruct;
2280             pReconDoc->DeleteAllViews();
2281             return;
2282           }
2283         }
2284       }
2285       delete pReconstruct;
2286       if (theApp->getSetModifyNewDocs())
2287         pReconDoc->Modify(true);
2288       pReconDoc->UpdateAllViews(this);
2289       ImageFileView* rasterView = dynamic_cast<ImageFileView*>(pReconDoc->GetFirstView());
2290       if (rasterView) {
2291         rasterView->getFrame()->SetFocus();
2292         rasterView->OnUpdate (rasterView, NULL);
2293       }
2294       std::ostringstream os;
2295       os << "Reconstruct " << rProj.getFilename() << ": xSize=" << m_iDefaultNX << ", ySize=" << m_iDefaultNY << ", Filter=" << optFilterName.c_str() << ", FilterParam=" << m_dDefaultFilterParam << ", FilterMethod=" << optFilterMethodName.c_str() << ", FilterGeneration=" << optFilterGenerationName.c_str() << ", Zeropad=" << m_iDefaultZeropad << ", Interpolation=" << optInterpName.c_str() << ", InterpolationParam=" << m_iDefaultInterpParam << ", Backprojection=" << optBackprojectName.c_str();
2296       *theApp->getLog() << os.str().c_str() << "\n";
2297       imageFile.labelAdd (rProj.getLabel());
2298       imageFile.labelAdd (os.str().c_str(), timerRecon.timerEnd());
2299     }
2300   }
2301 }
2302
2303
2304 ProjectionFileCanvas*
2305 ProjectionFileView::CreateCanvas (wxView *view, wxFrame *parent)
2306 {
2307   ProjectionFileCanvas* pCanvas;
2308   int width, height;
2309   parent->GetClientSize(&width, &height);
2310
2311   pCanvas = new ProjectionFileCanvas (dynamic_cast<ProjectionFileView*>(view), parent, wxPoint(0, 0), wxSize(width, height), 0);
2312
2313   pCanvas->SetScrollbars(20, 20, 50, 50);
2314   pCanvas->SetBackgroundColour(*wxWHITE);
2315   pCanvas->Clear();
2316
2317   return pCanvas;
2318 }
2319
2320 wxFrame*
2321 ProjectionFileView::CreateChildFrame(wxDocument *doc, wxView *view)
2322 {
2323 #ifdef CTSIM_MDI
2324   wxDocMDIChildFrame *subframe = new wxDocMDIChildFrame (doc, view, theApp->getMainFrame(), -1, "Projection Frame", wxPoint(10, 10), wxSize(0, 0), wxDEFAULT_FRAME_STYLE);
2325 #else
2326   wxDocChildFrame *subframe = new wxDocChildFrame (doc, view, theApp->getMainFrame(), -1, "Projection Frame", wxPoint(10, 10), wxSize(0, 0), wxDEFAULT_FRAME_STYLE);
2327 #endif
2328   theApp->setIconForFrame (subframe);
2329
2330   wxMenu *m_pFileMenu = new wxMenu;
2331
2332   m_pFileMenu->Append(MAINMENU_FILE_CREATE_PHANTOM, "Cr&eate Phantom...\tCtrl-P");
2333   m_pFileMenu->Append(MAINMENU_FILE_CREATE_FILTER, "Create &Filter...\tCtrl-F");
2334   m_pFileMenu->Append(wxID_OPEN, "&Open...\tCtrl-O");
2335   m_pFileMenu->Append(wxID_SAVE, "&Save\tCtrl-S");
2336   m_pFileMenu->Append(wxID_SAVEAS, "Save &As...");
2337   m_pFileMenu->Append(wxID_CLOSE, "&Close\tCtrl-W");
2338
2339   m_pFileMenu->AppendSeparator();
2340   m_pFileMenu->Append(PJMENU_FILE_PROPERTIES, "P&roperties");
2341
2342   m_pFileMenu->AppendSeparator();
2343   m_pFileMenu->Append(wxID_PRINT, "&Print...");
2344   m_pFileMenu->Append(wxID_PRINT_SETUP, "Print &Setup...");
2345   m_pFileMenu->Append(wxID_PREVIEW, "Print Pre&view");
2346 #ifdef CTSIM_MDI
2347   m_pFileMenu->AppendSeparator();
2348   m_pFileMenu->Append(MAINMENU_FILE_EXIT, "E&xit");
2349 #endif
2350   theApp->getDocManager()->FileHistoryAddFilesToMenu(m_pFileMenu);
2351   theApp->getDocManager()->FileHistoryUseMenu(m_pFileMenu);
2352
2353   wxMenu *convert_menu = new wxMenu;
2354   convert_menu->Append (PJMENU_CONVERT_POLAR, "&Polar Image...\tCtrl-L");
2355   convert_menu->Append (PJMENU_CONVERT_FFT_POLAR, "&FFT->Polar Image...\tCtrl-I");
2356
2357   wxMenu *reconstruct_menu = new wxMenu;
2358   reconstruct_menu->Append (PJMENU_RECONSTRUCT_FBP, "&Filtered Backprojection...\tCtrl-R");
2359   reconstruct_menu->Append (PJMENU_RECONSTRUCT_FOURIER, "&Fourier...\tCtrl-E");
2360
2361   wxMenu *help_menu = new wxMenu;
2362   help_menu->Append(MAINMENU_HELP_CONTENTS, "&Contents\tF1");
2363   help_menu->Append(MAINMENU_HELP_TOPICS, "&Topics\tCtrl-H");
2364   help_menu->Append(MAINMENU_HELP_ABOUT, "&About");
2365
2366   wxMenuBar *menu_bar = new wxMenuBar;
2367
2368   menu_bar->Append (m_pFileMenu, "&File");
2369   menu_bar->Append (convert_menu, "&Convert");
2370   menu_bar->Append (reconstruct_menu, "&Reconstruct");
2371   menu_bar->Append (help_menu, "&Help");
2372
2373   subframe->SetMenuBar(menu_bar);
2374   subframe->Centre(wxBOTH);
2375
2376   wxAcceleratorEntry accelEntries[11];
2377   accelEntries[0].Set (wxACCEL_CTRL, static_cast<int>('O'), wxID_OPEN);
2378   accelEntries[1].Set (wxACCEL_CTRL, static_cast<int>('S'), wxID_SAVE);
2379   accelEntries[2].Set (wxACCEL_CTRL, static_cast<int>('W'), wxID_CLOSE);
2380   accelEntries[3].Set (wxACCEL_CTRL, static_cast<int>('H'), MAINMENU_HELP_TOPICS);
2381   accelEntries[4].Set (wxACCEL_CTRL, static_cast<int>('P'), MAINMENU_FILE_CREATE_PHANTOM);
2382   accelEntries[5].Set (wxACCEL_CTRL, static_cast<int>('F'), MAINMENU_FILE_CREATE_FILTER);
2383   accelEntries[6].Set (wxACCEL_NORMAL, WXK_F1, MAINMENU_HELP_CONTENTS);
2384   accelEntries[7].Set (wxACCEL_CTRL, static_cast<int>('L'), PJMENU_CONVERT_POLAR);
2385   accelEntries[8].Set (wxACCEL_CTRL, static_cast<int>('I'), PJMENU_CONVERT_FFT_POLAR);
2386   accelEntries[9].Set (wxACCEL_CTRL, static_cast<int>('R'), PJMENU_RECONSTRUCT_FBP);
2387   accelEntries[10].Set (wxACCEL_CTRL, static_cast<int>('E'), PJMENU_RECONSTRUCT_FOURIER);
2388   wxAcceleratorTable accelTable (11, accelEntries);
2389   subframe->SetAcceleratorTable (accelTable);
2390
2391   return subframe;
2392 }
2393
2394
2395 bool
2396 ProjectionFileView::OnCreate(wxDocument *doc, long WXUNUSED(flags) )
2397 {
2398   m_frame = CreateChildFrame(doc, this);
2399   SetFrame(m_frame);
2400
2401   int width, height;
2402   m_frame->GetClientSize(&width, &height);
2403   m_frame->SetTitle("ProjectionFileView");
2404   m_canvas = CreateCanvas(this, m_frame);
2405
2406 #ifdef __X__
2407   int x, y;  // X requires a forced resize
2408   m_frame->GetSize(&x, &y);
2409   m_frame->SetSize(-1, -1, x, y);
2410 #endif
2411
2412   m_frame->Show(true);
2413   Activate(true);
2414
2415   return true;
2416 }
2417
2418 void
2419 ProjectionFileView::OnDraw (wxDC* dc)
2420 {
2421   wxSize clientSize = m_frame->GetClientSize();
2422   wxSize bestSize = m_canvas->GetBestSize();
2423
2424   if (clientSize.x > bestSize.x || clientSize.y > bestSize.y)
2425     m_frame->SetClientSize (bestSize);
2426
2427   if (m_bitmap.Ok())
2428     dc->DrawBitmap (m_bitmap, 0, 0, false);
2429 }
2430
2431
2432 void
2433 ProjectionFileView::OnUpdate(wxView *WXUNUSED(sender), wxObject *WXUNUSED(hint) )
2434 {
2435   const Projections& rProj = GetDocument()->getProjections();
2436   const int nDet = rProj.nDet();
2437   const int nView = rProj.nView();
2438   if (nDet != 0 && nView != 0) {
2439     const DetectorArray& detarray = rProj.getDetectorArray(0);
2440     const DetectorValue* detval = detarray.detValues();
2441     double min = detval[0];
2442     double max = detval[0];
2443     for (int iy = 0; iy < nView; iy++) {
2444       const DetectorArray& detarray = rProj.getDetectorArray(iy);
2445       const DetectorValue* detval = detarray.detValues();
2446       for (int ix = 0; ix < nDet; ix++) {
2447         if (min > detval[ix])
2448           min = detval[ix];
2449         else if (max < detval[ix])
2450           max = detval[ix];
2451       }
2452     }
2453
2454     unsigned char* imageData = new unsigned char [nDet * nView * 3];
2455     double scale = (max - min) / 255;
2456     for (int iy2 = 0; iy2 < nView; iy2++) {
2457       const DetectorArray& detarray = rProj.getDetectorArray (iy2);
2458       const DetectorValue* detval = detarray.detValues();
2459       for (int ix = 0; ix < nDet; ix++) {
2460         int intensity = static_cast<int>(((detval[ix] - min) / scale) + 0.5);
2461         intensity = clamp(intensity, 0, 255);
2462         int baseAddr = (iy2 * nDet + ix) * 3;
2463         imageData[baseAddr] = imageData[baseAddr+1] = imageData[baseAddr+2] = intensity;
2464       }
2465     }
2466     wxImage image (nDet, nView, imageData, true);
2467     m_bitmap = image.ConvertToBitmap();
2468     delete imageData;
2469     int xSize = nDet;
2470     int ySize = nView;
2471     xSize = clamp (xSize, 0, 800);
2472     ySize = clamp (ySize, 0, 800);
2473     m_frame->SetClientSize (xSize, ySize);
2474     m_canvas->SetScrollbars (20, 20, nDet/20, nView/20);
2475   }
2476
2477   if (m_canvas)
2478     m_canvas->Refresh();
2479 }
2480
2481 bool
2482 ProjectionFileView::OnClose (bool deleteWindow)
2483 {
2484   if (!GetDocument()->Close())
2485     return false;
2486
2487   //m_canvas->Clear();
2488   //m_canvas->setView(NULL);
2489   m_canvas = NULL;
2490 //  wxString s(wxTheApp->GetAppName());
2491 //  if (m_frame)
2492 //    m_frame->SetTitle(s);
2493   SetFrame(NULL);
2494
2495   Activate(false);
2496
2497   if (deleteWindow) {
2498     delete m_frame;
2499     return true;
2500   }
2501   return true;
2502 }
2503
2504
2505
2506 // PlotFileCanvas
2507 PlotFileCanvas::PlotFileCanvas (PlotFileView* v, wxFrame *frame, const wxPoint& pos, const wxSize& size, const long style)
2508 : wxScrolledWindow(frame, -1, pos, size, style)
2509 {
2510   m_pView = v;
2511 }
2512
2513 PlotFileCanvas::~PlotFileCanvas ()
2514 {
2515   if (m_pView) {
2516     wxMenu* pMenu = m_pView->getFileMenu();
2517     theApp->getDocManager()->FileHistoryRemoveMenu (pMenu);
2518     m_pView->canvasClosed();
2519     m_pView = NULL;
2520   }
2521 }
2522
2523 void
2524 PlotFileCanvas::OnDraw(wxDC& dc)
2525 {
2526   if (m_pView)
2527     m_pView->OnDraw(& dc);
2528 }
2529
2530
2531 // PlotFileView
2532
2533 IMPLEMENT_DYNAMIC_CLASS(PlotFileView, wxView)
2534
2535 BEGIN_EVENT_TABLE(PlotFileView, wxView)
2536 EVT_MENU(PJMENU_FILE_PROPERTIES, PlotFileView::OnProperties)
2537 EVT_MENU(PLOTMENU_VIEW_SCALE_MINMAX, PlotFileView::OnScaleMinMax)
2538 EVT_MENU(PLOTMENU_VIEW_SCALE_AUTO, PlotFileView::OnScaleAuto)
2539 EVT_MENU(PLOTMENU_VIEW_SCALE_FULL, PlotFileView::OnScaleFull)
2540 END_EVENT_TABLE()
2541
2542 PlotFileView::PlotFileView(void)
2543 : wxView(), m_canvas(NULL), m_frame(NULL), m_pEZPlot(NULL), m_pFileMenu(0)
2544 {
2545   m_bMinSpecified = false;
2546   m_bMaxSpecified = false;
2547 }
2548
2549 PlotFileView::~PlotFileView(void)
2550 {
2551   if (m_pEZPlot)
2552     delete m_pEZPlot;
2553 }
2554
2555 void
2556 PlotFileView::OnProperties (wxCommandEvent& event)
2557 {
2558   const PlotFile& rPlot = GetDocument()->getPlotFile();
2559   std::ostringstream os;
2560   os << "Columns: " << rPlot.getNumColumns() << ", Records: " << rPlot.getNumRecords() << "\n";
2561   rPlot.printHeadersBrief (os);
2562   *theApp->getLog() << os.str().c_str();
2563   wxMessageDialog dialogMsg (getFrameForChild(), os.str().c_str(), "Plot File Properties", wxOK | wxICON_INFORMATION);
2564   dialogMsg.ShowModal();
2565 }
2566
2567
2568 void
2569 PlotFileView::OnScaleAuto (wxCommandEvent& event)
2570 {
2571   const PlotFile& rPlotFile = GetDocument()->getPlotFile();
2572   double min, max, mean, mode, median, stddev;
2573   rPlotFile.statistics (1, min, max, mean, mode, median, stddev);
2574   DialogAutoScaleParameters dialogAutoScale (getFrameForChild(), mean, mode, median, stddev, m_dAutoScaleFactor);
2575   int iRetVal = dialogAutoScale.ShowModal();
2576   if (iRetVal == wxID_OK) {
2577     m_bMinSpecified = true;
2578     m_bMaxSpecified = true;
2579     double dMin, dMax;
2580     if (dialogAutoScale.getMinMax (&dMin, &dMax)) {
2581       m_dMinPixel = dMin;
2582       m_dMaxPixel = dMax;
2583       m_dAutoScaleFactor = dialogAutoScale.getAutoScaleFactor();
2584       OnUpdate (this, NULL);
2585     }
2586   }
2587 }
2588
2589 void
2590 PlotFileView::OnScaleMinMax (wxCommandEvent& event)
2591 {
2592   const PlotFile& rPlotFile = GetDocument()->getPlotFile();
2593   double min;
2594   double max;
2595
2596   if (! m_bMinSpecified || ! m_bMaxSpecified) {
2597     if (! rPlotFile.getMinMax (1, min, max)) {
2598       *theApp->getLog() << "Error: unable to find Min/Max\n";
2599       return;
2600     }
2601   }
2602
2603   if (m_bMinSpecified)
2604     min = m_dMinPixel;
2605   if (m_bMaxSpecified)
2606     max = m_dMaxPixel;
2607
2608   DialogGetMinMax dialogMinMax (getFrameForChild(), "Set Y-axis Minimum & Maximum", min, max);
2609   int retVal = dialogMinMax.ShowModal();
2610   if (retVal == wxID_OK) {
2611     m_bMinSpecified = true;
2612     m_bMaxSpecified = true;
2613     m_dMinPixel = dialogMinMax.getMinimum();
2614     m_dMaxPixel = dialogMinMax.getMaximum();
2615     OnUpdate (this, NULL);
2616   }
2617 }
2618
2619 void
2620 PlotFileView::OnScaleFull (wxCommandEvent& event)
2621 {
2622   if (m_bMinSpecified || m_bMaxSpecified) {
2623     m_bMinSpecified = false;
2624     m_bMaxSpecified = false;
2625     OnUpdate (this, NULL);
2626   }
2627 }
2628
2629
2630 PlotFileCanvas*
2631 PlotFileView::CreateCanvas (wxView *view, wxFrame *parent)
2632 {
2633   PlotFileCanvas* pCanvas;
2634   int width, height;
2635   parent->GetClientSize(&width, &height);
2636
2637   pCanvas = new PlotFileCanvas (dynamic_cast<PlotFileView*>(view), parent, wxPoint(0, 0), wxSize(width, height), 0);
2638
2639   pCanvas->SetBackgroundColour(*wxWHITE);
2640   pCanvas->Clear();
2641
2642   return pCanvas;
2643 }
2644
2645 wxFrame*
2646 PlotFileView::CreateChildFrame(wxDocument *doc, wxView *view)
2647 {
2648 #ifdef CTSIM_MDI
2649   wxDocMDIChildFrame *subframe = new wxDocMDIChildFrame (doc, view, theApp->getMainFrame(), -1, "Plot Frame", wxPoint(10, 10), wxSize(500, 300), wxDEFAULT_FRAME_STYLE);
2650 #else
2651   wxDocChildFrame *subframe = new wxDocChildFrame(doc, view, theApp->getMainFrame(), -1, "Plot Frame", wxPoint(10, 10), wxSize(500, 300), wxDEFAULT_FRAME_STYLE);
2652 #endif
2653   theApp->setIconForFrame (subframe);
2654
2655   wxMenu *m_pFileMenu = new wxMenu;
2656
2657   m_pFileMenu->Append(MAINMENU_FILE_CREATE_PHANTOM, "Cr&eate Phantom...\tCtrl-P");
2658   m_pFileMenu->Append(MAINMENU_FILE_CREATE_FILTER, "Create &Filter...\tCtrl-F");
2659   m_pFileMenu->Append(wxID_OPEN, "&Open...\tCtrl-O");
2660   m_pFileMenu->Append(wxID_SAVE, "&Save\tCtrl-S");
2661   m_pFileMenu->Append(wxID_SAVEAS, "Save &As...");
2662   m_pFileMenu->Append(wxID_CLOSE, "&Close\tCtrl-W");
2663
2664   m_pFileMenu->AppendSeparator();
2665   m_pFileMenu->Append(PJMENU_FILE_PROPERTIES, "P&roperties");
2666
2667   m_pFileMenu->AppendSeparator();
2668   m_pFileMenu->Append(wxID_PRINT, "&Print...");
2669   m_pFileMenu->Append(wxID_PRINT_SETUP, "Print &Setup...");
2670   m_pFileMenu->Append(wxID_PREVIEW, "Print Pre&view");
2671 #ifdef CTSIM_MDI
2672   m_pFileMenu->AppendSeparator();
2673   m_pFileMenu->Append(MAINMENU_FILE_EXIT, "E&xit");
2674 #endif
2675   theApp->getDocManager()->FileHistoryAddFilesToMenu(m_pFileMenu);
2676   theApp->getDocManager()->FileHistoryUseMenu(m_pFileMenu);
2677
2678   wxMenu *view_menu = new wxMenu;
2679   view_menu->Append(PLOTMENU_VIEW_SCALE_MINMAX, "Display Scale &Set...\tCtrl-E");
2680   view_menu->Append(PLOTMENU_VIEW_SCALE_AUTO, "Display Scale &Auto...\tCtrl-A");
2681   view_menu->Append(PLOTMENU_VIEW_SCALE_FULL, "Display &Full Scale\tCtrl-U");
2682
2683   wxMenu *help_menu = new wxMenu;
2684   help_menu->Append(MAINMENU_HELP_CONTENTS, "&Contents\tF1");
2685   help_menu->Append(MAINMENU_HELP_TOPICS, "&Topics\tCtrl-H");
2686   help_menu->Append(MAINMENU_HELP_ABOUT, "&About");
2687
2688   wxMenuBar *menu_bar = new wxMenuBar;
2689
2690   menu_bar->Append(m_pFileMenu, "&File");
2691   menu_bar->Append(view_menu, "&View");
2692   menu_bar->Append(help_menu, "&Help");
2693
2694   subframe->SetMenuBar(menu_bar);
2695   subframe->Centre(wxBOTH);
2696
2697   wxAcceleratorEntry accelEntries[10];
2698   accelEntries[0].Set (wxACCEL_CTRL, static_cast<int>('O'), wxID_OPEN);
2699   accelEntries[1].Set (wxACCEL_CTRL, static_cast<int>('S'), wxID_SAVE);
2700   accelEntries[2].Set (wxACCEL_CTRL, static_cast<int>('W'), wxID_CLOSE);
2701   accelEntries[3].Set (wxACCEL_CTRL, static_cast<int>('H'), MAINMENU_HELP_TOPICS);
2702   accelEntries[4].Set (wxACCEL_CTRL, static_cast<int>('P'), MAINMENU_FILE_CREATE_PHANTOM);
2703   accelEntries[5].Set (wxACCEL_CTRL, static_cast<int>('F'), MAINMENU_FILE_CREATE_FILTER);
2704   accelEntries[6].Set (wxACCEL_NORMAL, WXK_F1, MAINMENU_HELP_CONTENTS);
2705   accelEntries[7].Set (wxACCEL_CTRL, static_cast<int>('E'), PLOTMENU_VIEW_SCALE_MINMAX);
2706   accelEntries[8].Set (wxACCEL_CTRL, static_cast<int>('A'), PLOTMENU_VIEW_SCALE_AUTO);
2707   accelEntries[9].Set (wxACCEL_CTRL, static_cast<int>('U'), PLOTMENU_VIEW_SCALE_FULL);
2708   wxAcceleratorTable accelTable (10, accelEntries);
2709   subframe->SetAcceleratorTable (accelTable);
2710
2711   return subframe;
2712 }
2713
2714
2715 bool
2716 PlotFileView::OnCreate (wxDocument *doc, long WXUNUSED(flags) )
2717 {
2718   m_frame = CreateChildFrame(doc, this);
2719   SetFrame(m_frame);
2720
2721   m_bMinSpecified = false;
2722   m_bMaxSpecified = false;
2723   m_dAutoScaleFactor = 1.;
2724
2725   int width, height;
2726   m_frame->GetClientSize(&width, &height);
2727   m_frame->SetTitle ("Plot File");
2728   m_canvas = CreateCanvas (this, m_frame);
2729
2730 #ifdef __X__
2731   int x, y;  // X requires a forced resize
2732   m_frame->GetSize(&x, &y);
2733   m_frame->SetSize(-1, -1, x, y);
2734 #endif
2735
2736   m_frame->Show(true);
2737   Activate(true);
2738
2739   return true;
2740 }
2741
2742 void
2743 PlotFileView::OnDraw (wxDC* dc)
2744 {
2745   const PlotFile& rPlotFile = GetDocument()->getPlotFile();
2746   const int iNColumns = rPlotFile.getNumColumns();
2747   const int iNRecords = rPlotFile.getNumRecords();
2748
2749   if (iNColumns > 0 && iNRecords > 0) {
2750     int xsize, ysize;
2751     m_canvas->GetClientSize (&xsize, &ysize);
2752     SGPDriver driver (dc, xsize, ysize);
2753     SGP sgp (driver);
2754     if (m_pEZPlot)
2755       m_pEZPlot->plot (&sgp);
2756   }
2757 }
2758
2759
2760 void
2761 PlotFileView::OnUpdate (wxView *WXUNUSED(sender), wxObject *WXUNUSED(hint) )
2762 {
2763   const PlotFile& rPlotFile = GetDocument()->getPlotFile();
2764   const int iNColumns = rPlotFile.getNumColumns();
2765   const int iNRecords = rPlotFile.getNumRecords();
2766
2767   if (iNColumns > 0 && iNRecords > 0) {
2768     if (m_pEZPlot)
2769       delete m_pEZPlot;
2770     m_pEZPlot = new EZPlot;
2771
2772     for (unsigned int iEzset = 0; iEzset < rPlotFile.getNumEzsetCommands(); iEzset++)
2773       m_pEZPlot->ezset (rPlotFile.getEzsetCommand (iEzset));
2774
2775     if (m_bMinSpecified) {
2776       std::ostringstream os;
2777       os << "ymin " << m_dMinPixel;
2778       m_pEZPlot->ezset (os.str());
2779     }
2780
2781     if (m_bMaxSpecified) {
2782       std::ostringstream os;
2783       os << "ymax " << m_dMaxPixel;
2784       m_pEZPlot->ezset (os.str());
2785     }
2786
2787     m_pEZPlot->ezset("box");
2788     m_pEZPlot->ezset("grid");
2789
2790     double* pdXaxis = new double [iNRecords];
2791     rPlotFile.getColumn (0, pdXaxis);
2792
2793     double* pdY = new double [iNRecords];
2794     for (int iCol = 1; iCol < iNColumns; iCol++) {
2795       rPlotFile.getColumn (iCol, pdY);
2796       m_pEZPlot->addCurve (pdXaxis, pdY, iNRecords);
2797     }
2798
2799     delete pdXaxis;
2800     delete pdY;
2801   }
2802
2803   if (m_canvas)
2804     m_canvas->Refresh();
2805 }
2806
2807 bool
2808 PlotFileView::OnClose (bool deleteWindow)
2809 {
2810   if (!GetDocument()->Close())
2811     return false;
2812
2813   //m_canvas->Clear();
2814   //m_canvas->setView (NULL);
2815   m_canvas = NULL;
2816 //  wxString s(wxTheApp->GetAppName());
2817 //  if (m_frame)
2818 //    m_frame->SetTitle(s);
2819   SetFrame(NULL);
2820
2821   Activate(false);
2822
2823   if (deleteWindow) {
2824     delete m_frame;
2825     return true;
2826   }
2827   return true;
2828 }
2829
2830
2831 ////////////////////////////////////////////////////////////////
2832
2833
2834 IMPLEMENT_DYNAMIC_CLASS(TextFileView, wxView)
2835
2836 TextFileView::~TextFileView()
2837 {
2838 }
2839
2840 bool TextFileView::OnCreate(wxDocument *doc, long WXUNUSED(flags) )
2841 {
2842   m_pFrame = CreateChildFrame(doc, this);
2843   SetFrame (m_pFrame);
2844
2845   int width, height;
2846   m_pFrame->GetClientSize(&width, &height);
2847   m_pFrame->SetTitle("TextFile");
2848   m_pCanvas = new TextFileCanvas (this, m_pFrame, wxPoint(0, 0), wxSize(width, height), wxTE_MULTILINE | wxTE_READONLY);
2849   m_pFrame->SetTitle("Log");
2850
2851 #ifdef __X__
2852   // X seems to require a forced resize
2853   int x, y;
2854   frame->GetSize(&x, &y);
2855   frame->SetSize(-1, -1, x, y);
2856 #endif
2857
2858   m_pFrame->Show (true);
2859   Activate (true);
2860
2861   return true;
2862 }
2863
2864 // Handled by wxTextWindow
2865 void TextFileView::OnDraw(wxDC *WXUNUSED(dc) )
2866 {
2867 }
2868
2869 void TextFileView::OnUpdate(wxView *WXUNUSED(sender), wxObject *WXUNUSED(hint) )
2870 {
2871 }
2872
2873 bool
2874 TextFileView::OnClose (bool deleteWindow)
2875 {
2876   return false;
2877
2878   if (!GetDocument()->Close())
2879     return false;
2880
2881   Activate(false);
2882
2883   if (deleteWindow)
2884   {
2885     delete m_pFrame;
2886     return TRUE;
2887   }
2888   return TRUE;
2889 }
2890
2891 wxFrame*
2892 TextFileView::CreateChildFrame (wxDocument *doc, wxView *view)
2893 {
2894 #if CTSIM_MDI
2895   wxDocMDIChildFrame* subframe = new wxDocMDIChildFrame (doc, view, theApp->getMainFrame(), -1, "TextFile Frame", wxPoint(-1, -1), wxSize(300, 150), wxDEFAULT_FRAME_STYLE);
2896 #else
2897   wxDocChildFrame* subframe = new wxDocChildFrame (doc, view, theApp->getMainFrame(), -1, "TextFile Frame", wxPoint(-1, -1), wxSize(300, 150), wxDEFAULT_FRAME_STYLE);
2898 #endif
2899   theApp->setIconForFrame (subframe);
2900
2901   wxMenu *m_pFileMenu = new wxMenu;
2902
2903   m_pFileMenu->Append(MAINMENU_FILE_CREATE_PHANTOM, "Cr&eate Phantom...\tCtrl-P");
2904   m_pFileMenu->Append(MAINMENU_FILE_CREATE_FILTER, "Create &Filter...\tCtrl-F");
2905   m_pFileMenu->Append(wxID_OPEN, "&Open...\tCtrl-O");
2906   m_pFileMenu->Append(wxID_SAVE, "&Save\tCtrl-S");
2907   m_pFileMenu->Append(wxID_SAVEAS, "Save &As...");
2908   //  m_pFileMenu->Append(wxID_CLOSE, "&Close\tCtrl-W");
2909
2910   m_pFileMenu->AppendSeparator();
2911   m_pFileMenu->Append(wxID_PRINT, "&Print...");
2912   m_pFileMenu->Append(wxID_PRINT_SETUP, "Print &Setup...");
2913   m_pFileMenu->Append(wxID_PREVIEW, "Print Pre&view");
2914 #ifdef CTSIM_MDI
2915   m_pFileMenu->AppendSeparator();
2916   m_pFileMenu->Append(MAINMENU_FILE_EXIT, "E&xit");
2917 #endif
2918   theApp->getDocManager()->FileHistoryAddFilesToMenu(m_pFileMenu);
2919   theApp->getDocManager()->FileHistoryUseMenu(m_pFileMenu);
2920
2921   wxMenu *help_menu = new wxMenu;
2922   help_menu->Append(MAINMENU_HELP_CONTENTS, "&Contents\tF1");
2923   help_menu->Append(MAINMENU_HELP_TOPICS, "&Topics\tCtrl-H");
2924   help_menu->Append(MAINMENU_HELP_ABOUT, "&About");
2925
2926   wxMenuBar *menu_bar = new wxMenuBar;
2927
2928   menu_bar->Append(m_pFileMenu, "&File");
2929   menu_bar->Append(help_menu, "&Help");
2930
2931   subframe->SetMenuBar(menu_bar);
2932   subframe->Centre(wxBOTH);
2933
2934   wxAcceleratorEntry accelEntries[5];
2935   accelEntries[0].Set (wxACCEL_CTRL, static_cast<int>('O'), wxID_OPEN);
2936   accelEntries[1].Set (wxACCEL_CTRL, static_cast<int>('S'), wxID_SAVE);
2937   accelEntries[2].Set (wxACCEL_CTRL, static_cast<int>('W'), wxID_CLOSE);
2938   accelEntries[3].Set (wxACCEL_CTRL, static_cast<int>('H'), MAINMENU_HELP_TOPICS);
2939   accelEntries[4].Set (wxACCEL_NORMAL, WXK_F1, MAINMENU_HELP_CONTENTS);
2940   wxAcceleratorTable accelTable (5, accelEntries);
2941   subframe->SetAcceleratorTable (accelTable);
2942
2943   return subframe;
2944 }
2945
2946
2947 // Define a constructor for my text subwindow
2948 TextFileCanvas::TextFileCanvas (TextFileView* v, wxFrame* frame, const wxPoint& pos, const wxSize& size, long style)
2949   : wxTextCtrl (frame, -1, "", pos, size, style), m_pView(v)
2950 {
2951 }
2952
2953 TextFileCanvas::~TextFileCanvas ()
2954 {
2955   if (m_pView) {
2956     wxMenu* pMenu = m_pView->getFileMenu();
2957     theApp->getDocManager()->FileHistoryRemoveMenu (pMenu);
2958     m_pView->canvasClosed();
2959     m_pView = NULL;
2960   }
2961 }