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.72 2001/01/26 09:54:31 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   if (m_canvas) {
1000   //  m_canvas->Clear();
1001     m_canvas->setView(NULL);
1002     m_canvas = NULL;
1003   }
1004   wxString s(theApp->GetAppName());
1005 //  if (m_frame)
1006 //    m_frame->SetTitle(s);
1007   SetFrame(NULL);
1008
1009   Activate(false);
1010
1011   if (deleteWindow) {
1012     delete m_frame;
1013     return true;
1014   }
1015   return true;
1016 }
1017
1018 void
1019 ImageFileView::OnExport (wxCommandEvent& event)
1020 {
1021   ImageFile& rIF = dynamic_cast<ImageFileDocument*>(GetDocument())->getImageFile();
1022   ImageFileArrayConst v = rIF.getArray();
1023   int nx = rIF.nx();
1024   int ny = rIF.ny();
1025   if (v != NULL && nx != 0 && ny != 0) {
1026     if (! m_bMinSpecified || ! m_bMaxSpecified) {
1027       double min, max;
1028       rIF.getMinMax (min, max);
1029       if (! m_bMinSpecified)
1030         m_dMinPixel = min;
1031       if (! m_bMaxSpecified)
1032         m_dMaxPixel = max;
1033     }
1034
1035     DialogExportParameters dialogExport (getFrameForChild(), m_iDefaultExportFormatID);
1036     if (dialogExport.ShowModal() == wxID_OK) {
1037       wxString strFormatName (dialogExport.getFormatName ());
1038       m_iDefaultExportFormatID = ImageFile::convertFormatNameToID (strFormatName.c_str());
1039
1040       wxString strExt;
1041       wxString strWildcard;
1042       if (m_iDefaultExportFormatID == ImageFile::FORMAT_PGM || m_iDefaultExportFormatID == ImageFile::FORMAT_PGMASCII) {
1043         strExt = ".pgm";
1044         strWildcard = "PGM Files (*.pgm)|*.pgm";
1045       }
1046 #ifdef HAVE_PNG
1047       else if (m_iDefaultExportFormatID == ImageFile::FORMAT_PNG || m_iDefaultExportFormatID == ImageFile::FORMAT_PNG16) {
1048         strExt = ".png";
1049         strWildcard = "PNG Files (*.png)|*.png";
1050       }
1051 #endif
1052
1053       const wxString& strFilename = wxFileSelector (wxString("Export Filename"), wxString(""),
1054         wxString(""), strExt, strWildcard, wxOVERWRITE_PROMPT | wxHIDE_READONLY | wxSAVE);
1055       if (strFilename) {
1056         rIF.exportImage (strFormatName.c_str(), strFilename.c_str(), 1, 1, m_dMinPixel, m_dMaxPixel);
1057         *theApp->getLog() << "Exported file " << strFilename << "\n";
1058       }
1059     }
1060   }
1061 }
1062
1063 void
1064 ImageFileView::OnScaleSize (wxCommandEvent& event)
1065 {
1066   ImageFile& rIF = GetDocument()->getImageFile();
1067   unsigned int iOldNX = rIF.nx();
1068   unsigned int iOldNY = rIF.ny();
1069
1070   DialogGetXYSize dialogGetXYSize (getFrameForChild(), "Set New X & Y Dimensions", iOldNX, iOldNY);
1071   if (dialogGetXYSize.ShowModal() == wxID_OK) {
1072     unsigned int iNewNX = dialogGetXYSize.getXSize();
1073     unsigned int iNewNY = dialogGetXYSize.getYSize();
1074     std::ostringstream os;
1075     os << "Scale Size from (" << iOldNX << "," << iOldNY << ") to (" << iNewNX << "," << iNewNY << ")";
1076     ImageFileDocument* pScaledDoc = theApp->newImageDoc();
1077     if (! pScaledDoc) {
1078       sys_error (ERR_SEVERE, "Unable to create image file");
1079       return;
1080     }
1081     ImageFile& rScaledIF = pScaledDoc->getImageFile();
1082     rScaledIF.setArraySize (iNewNX, iNewNY);
1083     rScaledIF.labelsCopy (rIF);
1084     rScaledIF.labelAdd (os.str().c_str());
1085     rIF.scaleImage (rScaledIF);
1086     *theApp->getLog() << os.str().c_str() << "\n";
1087     if (theApp->getSetModifyNewDocs())
1088       pScaledDoc->Modify(TRUE);
1089     pScaledDoc->UpdateAllViews (this);
1090     pScaledDoc->GetFirstView()->OnUpdate (this, NULL);
1091   }
1092 }
1093
1094 void
1095 ImageFileView::OnPlotRow (wxCommandEvent& event)
1096 {
1097   int xCursor, yCursor;
1098   if (! m_canvas->GetCurrentCursor (xCursor, yCursor)) {
1099     wxMessageBox ("No row selected. Please use left mouse button on image to select column","Error");
1100     return;
1101   }
1102
1103   const ImageFile& rIF = dynamic_cast<ImageFileDocument*>(GetDocument())->getImageFile();
1104   ImageFileArrayConst v = rIF.getArray();
1105   ImageFileArrayConst vImag = rIF.getImaginaryArray();
1106   int nx = rIF.nx();
1107   int ny = rIF.ny();
1108
1109   if (v != NULL && yCursor < ny) {
1110     double* pX = new double [nx];
1111     double* pYReal = new double [nx];
1112     double *pYImag = NULL;
1113     double *pYMag = NULL;
1114     if (rIF.isComplex()) {
1115       pYImag = new double [nx];
1116       pYMag = new double [nx];
1117     }
1118     for (int i = 0; i < nx; i++) {
1119       pX[i] = i;
1120       pYReal[i] = v[i][yCursor];
1121       if (rIF.isComplex()) {
1122         pYImag[i] = vImag[i][yCursor];
1123         pYMag[i] = ::sqrt (v[i][yCursor] * v[i][yCursor] + vImag[i][yCursor] * vImag[i][yCursor]);
1124       }
1125     }
1126     PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1127     if (! pPlotDoc) {
1128       sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1129     } else {
1130       PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1131       std::ostringstream os;
1132       os << "Row " << yCursor;
1133       std::string title("title ");
1134       title += os.str();
1135       rPlotFile.addEzsetCommand (title.c_str());
1136       rPlotFile.addEzsetCommand ("xlabel Column");
1137       rPlotFile.addEzsetCommand ("ylabel Pixel Value");
1138       rPlotFile.addEzsetCommand ("lxfrac 0");
1139       rPlotFile.addEzsetCommand ("box");
1140       rPlotFile.addEzsetCommand ("grid");
1141       rPlotFile.addEzsetCommand ("curve 1");
1142       rPlotFile.addEzsetCommand ("color 1");
1143       if (rIF.isComplex()) {
1144         rPlotFile.addEzsetCommand ("dash 1");
1145         rPlotFile.addEzsetCommand ("curve 2");
1146         rPlotFile.addEzsetCommand ("color 4");
1147         rPlotFile.addEzsetCommand ("dash 3");
1148         rPlotFile.addEzsetCommand ("curve 3");
1149         rPlotFile.addEzsetCommand ("color 0");
1150         rPlotFile.addEzsetCommand ("solid");
1151         rPlotFile.setCurveSize (4, nx);
1152       } else
1153         rPlotFile.setCurveSize (2, nx);
1154       rPlotFile.addColumn (0, pX);
1155       rPlotFile.addColumn (1, pYReal);
1156       if (rIF.isComplex()) {
1157         rPlotFile.addColumn (2, pYImag);
1158         rPlotFile.addColumn (3, pYMag);
1159       }
1160       for (unsigned int iL = 0; iL < rIF.nLabels(); iL++)
1161         rPlotFile.addDescription (rIF.labelGet(iL).getLabelString().c_str());
1162       os << " Plot of " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1163       *theApp->getLog() << os.str().c_str() << "\n";
1164       rPlotFile.addDescription (os.str().c_str());
1165     }
1166     delete pX;
1167     delete pYReal;
1168     if (rIF.isComplex()) {
1169       delete pYImag;
1170       delete pYMag;
1171     }
1172     if (theApp->getSetModifyNewDocs())
1173       pPlotDoc->Modify(true);
1174     pPlotDoc->UpdateAllViews();
1175   }
1176 }
1177
1178 void
1179 ImageFileView::OnPlotCol (wxCommandEvent& event)
1180 {
1181   int xCursor, yCursor;
1182   if (! m_canvas->GetCurrentCursor (xCursor, yCursor)) {
1183     wxMessageBox ("No column selected. Please use left mouse button on image to select column","Error");
1184     return;
1185   }
1186
1187   const ImageFile& rIF = dynamic_cast<ImageFileDocument*>(GetDocument())->getImageFile();
1188   ImageFileArrayConst v = rIF.getArray();
1189   ImageFileArrayConst vImag = rIF.getImaginaryArray();
1190   int nx = rIF.nx();
1191   int ny = rIF.ny();
1192
1193   if (v != NULL && xCursor < nx) {
1194     double* pX = new double [ny];
1195     double* pYReal = new double [ny];
1196     double* pYImag = NULL;
1197     double* pYMag = NULL;
1198     if (rIF.isComplex()) {
1199       pYImag = new double [ny];
1200       pYMag = new double [ny];
1201     }
1202     for (int i = 0; i < ny; i++) {
1203       pX[i] = i;
1204       pYReal[i] = v[xCursor][i];
1205       if (rIF.isComplex()) {
1206         pYImag[i] = vImag[xCursor][i];
1207         pYMag[i] = ::sqrt (v[xCursor][i] * v[xCursor][i] + vImag[xCursor][i] * vImag[xCursor][i]);
1208       }
1209     }
1210     PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1211     if (! pPlotDoc) {
1212       sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1213     } else {
1214       PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1215       std::ostringstream os;
1216       os << "Column " << xCursor;
1217       std::string title("title ");
1218       title += os.str();
1219       rPlotFile.addEzsetCommand (title.c_str());
1220       rPlotFile.addEzsetCommand ("xlabel Row");
1221       rPlotFile.addEzsetCommand ("ylabel Pixel Value");
1222       rPlotFile.addEzsetCommand ("lxfrac 0");
1223       rPlotFile.addEzsetCommand ("box");
1224       rPlotFile.addEzsetCommand ("grid");
1225       rPlotFile.addEzsetCommand ("curve 1");
1226       rPlotFile.addEzsetCommand ("color 1");
1227       if (rIF.isComplex()) {
1228         rPlotFile.addEzsetCommand ("dash 1");
1229         rPlotFile.addEzsetCommand ("curve 2");
1230         rPlotFile.addEzsetCommand ("color 4");
1231         rPlotFile.addEzsetCommand ("dash 3");
1232         rPlotFile.addEzsetCommand ("curve 3");
1233         rPlotFile.addEzsetCommand ("color 0");
1234         rPlotFile.addEzsetCommand ("solid");
1235         rPlotFile.setCurveSize (4, ny);
1236       } else
1237         rPlotFile.setCurveSize (2, ny);
1238       rPlotFile.addColumn (0, pX);
1239       rPlotFile.addColumn (1, pYReal);
1240       if (rIF.isComplex()) {
1241         rPlotFile.addColumn (2, pYImag);
1242         rPlotFile.addColumn (3, pYMag);
1243       }
1244       for (unsigned int iL = 0; iL < rIF.nLabels(); iL++)
1245         rPlotFile.addDescription (rIF.labelGet(iL).getLabelString().c_str());
1246       os << " Plot of " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1247       *theApp->getLog() << os.str().c_str() << "\n";
1248       rPlotFile.addDescription (os.str().c_str());
1249     }
1250     delete pX;
1251     delete pYReal;
1252     if (rIF.isComplex()) {
1253       delete pYImag;
1254       delete pYMag;
1255     }
1256     if (theApp->getSetModifyNewDocs())
1257       pPlotDoc->Modify(true);
1258     pPlotDoc->UpdateAllViews();
1259   }
1260 }
1261
1262 #ifdef HAVE_FFT
1263 void
1264 ImageFileView::OnPlotFFTRow (wxCommandEvent& event)
1265 {
1266   int xCursor, yCursor;
1267   if (! m_canvas->GetCurrentCursor (xCursor, yCursor)) {
1268     wxMessageBox ("No row selected. Please use left mouse button on image to select column","Error");
1269     return;
1270   }
1271
1272   const ImageFile& rIF = dynamic_cast<ImageFileDocument*>(GetDocument())->getImageFile();
1273   ImageFileArrayConst v = rIF.getArray();
1274   ImageFileArrayConst vImag = rIF.getImaginaryArray();
1275   int nx = rIF.nx();
1276   int ny = rIF.ny();
1277
1278   if (v != NULL && yCursor < ny) {
1279     fftw_complex* pcIn = new fftw_complex [nx];
1280
1281     int i;
1282     for (i = 0; i < nx; i++) {
1283       pcIn[i].re = v[i][yCursor];
1284       if (rIF.isComplex())
1285         pcIn[i].im = vImag[i][yCursor];
1286       else
1287         pcIn[i].im = 0;
1288     }
1289
1290     fftw_plan plan = fftw_create_plan (nx, FFTW_FORWARD, FFTW_IN_PLACE);
1291     fftw_one (plan, pcIn, NULL);
1292     fftw_destroy_plan (plan);
1293
1294     double* pX = new double [nx];
1295     double* pYReal = new double [nx];
1296     double* pYImag = new double [nx];
1297     double* pYMag = new double [nx];
1298     for (i = 0; i < nx; i++) {
1299       pX[i] = i;
1300       pYReal[i] = pcIn[i].re;
1301       pYImag[i] = pcIn[i].im;
1302       pYMag[i] = ::sqrt (pcIn[i].re * pcIn[i].re + pcIn[i].im * pcIn[i].im);
1303     }
1304     Fourier::shuffleFourierToNaturalOrder (pYReal, nx);
1305     Fourier::shuffleFourierToNaturalOrder (pYImag, nx);
1306     Fourier::shuffleFourierToNaturalOrder (pYMag, nx);
1307
1308     PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1309     if (! pPlotDoc) {
1310       sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1311     } else {
1312       PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1313       std::ostringstream os;
1314       os << "Row " << yCursor;
1315       std::string title("title ");
1316       title += os.str();
1317       rPlotFile.addEzsetCommand (title.c_str());
1318       rPlotFile.addEzsetCommand ("xlabel Column");
1319       rPlotFile.addEzsetCommand ("ylabel Pixel Value");
1320       rPlotFile.addEzsetCommand ("lxfrac 0");
1321       rPlotFile.addEzsetCommand ("curve 1");
1322       rPlotFile.addEzsetCommand ("color 1");
1323       rPlotFile.addEzsetCommand ("dash 1");
1324       rPlotFile.addEzsetCommand ("curve 2");
1325       rPlotFile.addEzsetCommand ("color 4");
1326       rPlotFile.addEzsetCommand ("dash 3");
1327       rPlotFile.addEzsetCommand ("curve 3");
1328       rPlotFile.addEzsetCommand ("color 0");
1329       rPlotFile.addEzsetCommand ("solid");
1330       rPlotFile.addEzsetCommand ("box");
1331       rPlotFile.addEzsetCommand ("grid");
1332       rPlotFile.setCurveSize (4, nx);
1333       rPlotFile.addColumn (0, pX);
1334       rPlotFile.addColumn (1, pYReal);
1335       rPlotFile.addColumn (2, pYImag);
1336       rPlotFile.addColumn (3, pYMag);
1337       for (int iL = 0; iL < rIF.nLabels(); iL++)
1338         rPlotFile.addDescription (rIF.labelGet(iL).getLabelString().c_str());
1339       os << " FFT Plot of " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1340       *theApp->getLog() << os.str().c_str() << "\n";
1341       rPlotFile.addDescription (os.str().c_str());
1342     }
1343     delete pX;
1344     delete pYReal;
1345     delete pYImag;
1346     delete pYMag;
1347     delete [] pcIn;
1348
1349     if (theApp->getSetModifyNewDocs())
1350       pPlotDoc->Modify(true);
1351     pPlotDoc->UpdateAllViews();
1352   }
1353 }
1354
1355 void
1356 ImageFileView::OnPlotFFTCol (wxCommandEvent& event)
1357 {
1358   int xCursor, yCursor;
1359   if (! m_canvas->GetCurrentCursor (xCursor, yCursor)) {
1360     wxMessageBox ("No column selected. Please use left mouse button on image to select column","Error");
1361     return;
1362   }
1363
1364   const ImageFile& rIF = dynamic_cast<ImageFileDocument*>(GetDocument())->getImageFile();
1365   ImageFileArrayConst v = rIF.getArray();
1366   ImageFileArrayConst vImag = rIF.getImaginaryArray();
1367   int nx = rIF.nx();
1368   int ny = rIF.ny();
1369
1370   if (v != NULL && xCursor < nx) {
1371     fftw_complex* pcIn = new fftw_complex [ny];
1372     double *pdTemp = new double [ny];
1373
1374     int i;
1375     for (i = 0; i < ny; i++)
1376       pdTemp[i] = v[xCursor][i];
1377     Fourier::shuffleNaturalToFourierOrder (pdTemp, ny);
1378     for (i = 0; i < ny; i++)
1379       pcIn[i].re = pdTemp[i];
1380
1381     for (i = 0; i < ny; i++) {
1382       if (rIF.isComplex())
1383         pdTemp[i] = vImag[xCursor][i];
1384       else
1385         pdTemp[i] = 0;
1386     }
1387     Fourier::shuffleNaturalToFourierOrder (pdTemp, ny);
1388     for (i = 0; i < ny; i++)
1389       pcIn[i].im = pdTemp[i];
1390
1391     fftw_plan plan = fftw_create_plan (ny, FFTW_BACKWARD, FFTW_IN_PLACE);
1392     fftw_one (plan, pcIn, NULL);
1393     fftw_destroy_plan (plan);
1394
1395     double* pX = new double [ny];
1396     double* pYReal = new double [ny];
1397     double* pYImag = new double [ny];
1398     double* pYMag = new double [ny];
1399     for (i = 0; i < ny; i++) {
1400       pX[i] = i;
1401       pYReal[i] = pcIn[i].re;
1402       pYImag[i] = pcIn[i].im;
1403       pYMag[i] = ::sqrt (pcIn[i].re * pcIn[i].re + pcIn[i].im * pcIn[i].im);
1404     }
1405
1406     PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1407     if (! pPlotDoc) {
1408       sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1409     } else {
1410       PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1411       std::ostringstream os;
1412       os << "Column " << xCursor;
1413       std::string title("title ");
1414       title += os.str();
1415       rPlotFile.addEzsetCommand (title.c_str());
1416       rPlotFile.addEzsetCommand ("xlabel Column");
1417       rPlotFile.addEzsetCommand ("ylabel Pixel Value");
1418       rPlotFile.addEzsetCommand ("lxfrac 0");
1419       rPlotFile.addEzsetCommand ("curve 1");
1420       rPlotFile.addEzsetCommand ("color 1");
1421       rPlotFile.addEzsetCommand ("dash 1");
1422       rPlotFile.addEzsetCommand ("curve 2");
1423       rPlotFile.addEzsetCommand ("color 4");
1424       rPlotFile.addEzsetCommand ("dash 3");
1425       rPlotFile.addEzsetCommand ("curve 3");
1426       rPlotFile.addEzsetCommand ("color 0");
1427       rPlotFile.addEzsetCommand ("solid");
1428       rPlotFile.addEzsetCommand ("box");
1429       rPlotFile.addEzsetCommand ("grid");
1430       rPlotFile.setCurveSize (4, ny);
1431       rPlotFile.addColumn (0, pX);
1432       rPlotFile.addColumn (1, pYReal);
1433       rPlotFile.addColumn (2, pYImag);
1434       rPlotFile.addColumn (3, pYMag);
1435       for (int iL = 0; iL < rIF.nLabels(); iL++)
1436         rPlotFile.addDescription (rIF.labelGet(iL).getLabelString().c_str());
1437       os << " FFT Plot of " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1438       *theApp->getLog() << os.str().c_str() << "\n";
1439       rPlotFile.addDescription (os.str().c_str());
1440     }
1441     delete pX;
1442     delete pYReal;
1443     delete pYImag;
1444     delete pYMag;
1445     delete pdTemp;
1446     delete [] pcIn;
1447
1448     if (theApp->getSetModifyNewDocs())
1449       pPlotDoc->Modify(true);
1450     pPlotDoc->UpdateAllViews();
1451   }
1452 }
1453 #endif
1454
1455 void
1456 ImageFileView::OnCompareCol (wxCommandEvent& event)
1457 {
1458   int xCursor, yCursor;
1459   if (! m_canvas->GetCurrentCursor (xCursor, yCursor)) {
1460     wxMessageBox ("No column selected. Please use left mouse button on image to select column","Error");
1461     return;
1462   }
1463
1464   std::vector<ImageFileDocument*> vecIFDoc;
1465   theApp->getCompatibleImages (GetDocument(), vecIFDoc);
1466   if (vecIFDoc.size() == 0) {
1467     wxMessageBox ("No compatible images for Column Comparison", "Error");
1468     return;
1469   }
1470   DialogGetComparisonImage dialogGetCompare (getFrameForChild(), "Get Comparison Image", vecIFDoc, false);
1471
1472   if (dialogGetCompare.ShowModal() == wxID_OK) {
1473     ImageFileDocument* pCompareDoc = dialogGetCompare.getImageFileDocument();
1474     const ImageFile& rIF = GetDocument()->getImageFile();
1475     const ImageFile& rCompareIF = pCompareDoc->getImageFile();
1476
1477     ImageFileArrayConst v1 = rIF.getArray();
1478     ImageFileArrayConst v2 = rCompareIF.getArray();
1479     int nx = rIF.nx();
1480     int ny = rIF.ny();
1481
1482     if (v1 != NULL && xCursor < nx) {
1483       double* pX = new double [ny];
1484       double* pY1 = new double [ny];
1485       double* pY2 = new double [ny];
1486       for (int i = 0; i < ny; i++) {
1487         pX[i] = i;
1488         pY1[i] = v1[xCursor][i];
1489         pY2[i] = v2[xCursor][i];
1490       }
1491       PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1492       if (! pPlotDoc) {
1493         sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1494       } else {
1495         PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1496         std::ostringstream os;
1497         os << "Column " << xCursor << " Comparison";
1498         std::string title("title ");
1499         title += os.str();
1500         rPlotFile.addEzsetCommand (title.c_str());
1501         rPlotFile.addEzsetCommand ("xlabel Row");
1502         rPlotFile.addEzsetCommand ("ylabel Pixel Value");
1503         rPlotFile.addEzsetCommand ("lxfrac 0");
1504         rPlotFile.addEzsetCommand ("curve 1");
1505         rPlotFile.addEzsetCommand ("color 2");
1506         rPlotFile.addEzsetCommand ("curve 2");
1507         rPlotFile.addEzsetCommand ("color 4");
1508         rPlotFile.addEzsetCommand ("dash 5");
1509         rPlotFile.addEzsetCommand ("box");
1510         rPlotFile.addEzsetCommand ("grid");
1511         rPlotFile.setCurveSize (3, ny);
1512         rPlotFile.addColumn (0, pX);
1513         rPlotFile.addColumn (1, pY1);
1514         rPlotFile.addColumn (2, pY2);
1515
1516         unsigned int iL;
1517         for (iL = 0; iL < rIF.nLabels(); iL++) {
1518           std::string s = GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1519           s += ": ";
1520           s += rIF.labelGet(iL).getLabelString();
1521           rPlotFile.addDescription (s.c_str());
1522         }
1523         for (iL = 0; iL < rCompareIF.nLabels(); iL++) {
1524           std::string s = pCompareDoc->GetFirstView()->GetFrame()->GetTitle().c_str();
1525           s += ": ";
1526           s += rCompareIF.labelGet(iL).getLabelString();
1527           rPlotFile.addDescription (s.c_str());
1528         }
1529         os << " Between " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str() << " and "
1530           << pCompareDoc->GetFirstView()->GetFrame()->GetTitle().c_str();
1531         *theApp->getLog() << os.str().c_str() << "\n";
1532         rPlotFile.addDescription (os.str().c_str());
1533       }
1534       delete pX;
1535       delete pY1;
1536       delete pY2;
1537       if (theApp->getSetModifyNewDocs())
1538         pPlotDoc->Modify(true);
1539       pPlotDoc->UpdateAllViews();
1540     }
1541   }
1542 }
1543
1544 void
1545 ImageFileView::OnCompareRow (wxCommandEvent& event)
1546 {
1547   int xCursor, yCursor;
1548   if (! m_canvas->GetCurrentCursor (xCursor, yCursor)) {
1549     wxMessageBox ("No column selected. Please use left mouse button on image to select column","Error");
1550     return;
1551   }
1552
1553   std::vector<ImageFileDocument*> vecIFDoc;
1554   theApp->getCompatibleImages (GetDocument(), vecIFDoc);
1555
1556   if (vecIFDoc.size() == 0) {
1557     wxMessageBox ("No compatible images for Row Comparison", "Error");
1558     return;
1559   }
1560
1561   DialogGetComparisonImage dialogGetCompare (getFrameForChild(), "Get Comparison Image", vecIFDoc, false);
1562
1563   if (dialogGetCompare.ShowModal() == wxID_OK) {
1564     ImageFileDocument* pCompareDoc = dialogGetCompare.getImageFileDocument();
1565     const ImageFile& rIF = GetDocument()->getImageFile();
1566     const ImageFile& rCompareIF = pCompareDoc->getImageFile();
1567
1568     ImageFileArrayConst v1 = rIF.getArray();
1569     ImageFileArrayConst v2 = rCompareIF.getArray();
1570     int nx = rIF.nx();
1571     int ny = rIF.ny();
1572
1573     if (v1 != NULL && yCursor < ny) {
1574       double* pX = new double [nx];
1575       double* pY1 = new double [nx];
1576       double* pY2 = new double [nx];
1577       for (int i = 0; i < nx; i++) {
1578         pX[i] = i;
1579         pY1[i] = v1[i][yCursor];
1580         pY2[i] = v2[i][yCursor];
1581       }
1582       PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1583       if (! pPlotDoc) {
1584         sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1585       } else {
1586         PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1587         std::ostringstream os;
1588         os << "Row " << yCursor << " Comparison";
1589         std::string title("title ");
1590         title += os.str();
1591         rPlotFile.addEzsetCommand (title.c_str());
1592         rPlotFile.addEzsetCommand ("xlabel Column");
1593         rPlotFile.addEzsetCommand ("ylabel Pixel Value");
1594         rPlotFile.addEzsetCommand ("lxfrac 0");
1595         rPlotFile.addEzsetCommand ("curve 1");
1596         rPlotFile.addEzsetCommand ("color 2");
1597         rPlotFile.addEzsetCommand ("curve 2");
1598         rPlotFile.addEzsetCommand ("color 4");
1599         rPlotFile.addEzsetCommand ("dash 5");
1600         rPlotFile.addEzsetCommand ("box");
1601         rPlotFile.addEzsetCommand ("grid");
1602         rPlotFile.setCurveSize (3, nx);
1603         rPlotFile.addColumn (0, pX);
1604         rPlotFile.addColumn (1, pY1);
1605         rPlotFile.addColumn (2, pY2);
1606         unsigned int iL;
1607         for (iL = 0; iL < rIF.nLabels(); iL++) {
1608           std::string s = GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1609           s += ": ";
1610           s += rIF.labelGet(iL).getLabelString();
1611           rPlotFile.addDescription (s.c_str());
1612         }
1613         for (iL = 0; iL < rCompareIF.nLabels(); iL++) {
1614           std::string s = pCompareDoc->GetFirstView()->GetFrame()->GetTitle().c_str();
1615           s += ": ";
1616           s += rCompareIF.labelGet(iL).getLabelString();
1617           rPlotFile.addDescription (s.c_str());
1618         }
1619         os << " Between " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str() << " and "
1620           << pCompareDoc->GetFirstView()->GetFrame()->GetTitle().c_str();
1621         *theApp->getLog() << os.str().c_str() << "\n";
1622         rPlotFile.addDescription (os.str().c_str());
1623       }
1624       delete pX;
1625       delete pY1;
1626       delete pY2;
1627       if (theApp->getSetModifyNewDocs())
1628         pPlotDoc->Modify(true);
1629       pPlotDoc->UpdateAllViews();
1630     }
1631   }
1632 }
1633
1634 static int NUMBER_HISTOGRAM_BINS = 256;
1635
1636 void
1637 ImageFileView::OnPlotHistogram (wxCommandEvent& event)
1638 {
1639   const ImageFile& rIF = dynamic_cast<ImageFileDocument*>(GetDocument())->getImageFile();
1640   ImageFileArrayConst v = rIF.getArray();
1641   int nx = rIF.nx();
1642   int ny = rIF.ny();
1643
1644   if (v != NULL && nx > 0 && ny > 0) {
1645     PlotFileDocument* pPlotDoc = theApp->newPlotDoc();
1646     if (! pPlotDoc) {
1647       sys_error (ERR_SEVERE, "Internal error: unable to create Plot file");
1648       return;
1649     }
1650
1651     double* pX = new double [NUMBER_HISTOGRAM_BINS];
1652     double* pY = new double [NUMBER_HISTOGRAM_BINS];
1653     double dMin, dMax;
1654     rIF.getMinMax (dMin, dMax);
1655     double dBinWidth = (dMax - dMin) / NUMBER_HISTOGRAM_BINS;
1656
1657     for (int i = 0; i < NUMBER_HISTOGRAM_BINS; i++) {
1658       pX[i] = dMin + (i + 0.5) * dBinWidth;
1659       pY[i] = 0;
1660     }
1661     for (int ix = 0; ix < nx; ix++)
1662       for (int iy = 0; iy < ny; iy++) {
1663         int iBin = nearest<int> ((v[ix][iy] - dMin) / dBinWidth);
1664         if (iBin >= 0 && iBin < NUMBER_HISTOGRAM_BINS)
1665           pY[iBin] += 1;
1666       }
1667
1668       PlotFile& rPlotFile = pPlotDoc->getPlotFile();
1669       std::ostringstream os;
1670       os << "Histogram";
1671       std::string title("title ");
1672       title += os.str();
1673       rPlotFile.addEzsetCommand (title.c_str());
1674       rPlotFile.addEzsetCommand ("xlabel Pixel Value");
1675       rPlotFile.addEzsetCommand ("ylabel Count");
1676       rPlotFile.addEzsetCommand ("box");
1677       rPlotFile.addEzsetCommand ("grid");
1678       rPlotFile.setCurveSize (2, NUMBER_HISTOGRAM_BINS);
1679       rPlotFile.addColumn (0, pX);
1680       rPlotFile.addColumn (1, pY);
1681       for (unsigned int iL = 0; iL < rIF.nLabels(); iL++) {
1682         std::string s = GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1683         s += ": ";
1684         s += rIF.labelGet(iL).getLabelString();
1685         rPlotFile.addDescription (s.c_str());
1686       }
1687       os << " Plot of " << GetDocument()->GetFirstView()->GetFrame()->GetTitle().c_str();
1688       *theApp->getLog() << os.str().c_str() << "\n";
1689       rPlotFile.addDescription (os.str().c_str());
1690       delete pX;
1691       delete pY;
1692       if (theApp->getSetModifyNewDocs())
1693         pPlotDoc->Modify(true);
1694       pPlotDoc->UpdateAllViews();
1695   }
1696 }
1697
1698
1699 // PhantomCanvas
1700
1701 PhantomCanvas::PhantomCanvas (PhantomFileView* v, wxFrame *frame, const wxPoint& pos, const wxSize& size, const long style)
1702 : wxScrolledWindow(frame, -1, pos, size, style)
1703 {
1704   m_pView = v;
1705 }
1706
1707 PhantomCanvas::~PhantomCanvas ()
1708 {
1709   if (m_pView) {
1710     wxMenu* pMenu = m_pView->getFileMenu();
1711     theApp->getDocManager()->FileHistoryRemoveMenu (pMenu);
1712     m_pView->canvasClosed();
1713     m_pView = NULL;
1714   }
1715 }
1716
1717 void
1718 PhantomCanvas::OnDraw (wxDC& dc)
1719 {
1720   if (m_pView)
1721     m_pView->OnDraw(& dc);
1722 }
1723
1724
1725 // PhantomFileView
1726
1727 IMPLEMENT_DYNAMIC_CLASS(PhantomFileView, wxView)
1728
1729 BEGIN_EVENT_TABLE(PhantomFileView, wxView)
1730 EVT_MENU(PHMMENU_FILE_PROPERTIES, PhantomFileView::OnProperties)
1731 EVT_MENU(PHMMENU_PROCESS_RASTERIZE, PhantomFileView::OnRasterize)
1732 EVT_MENU(PHMMENU_PROCESS_PROJECTIONS, PhantomFileView::OnProjections)
1733 END_EVENT_TABLE()
1734
1735 PhantomFileView::PhantomFileView(void)
1736 : wxView(), m_canvas(NULL), m_frame(NULL), m_pFileMenu(0)
1737 {
1738   m_iDefaultNDet = 367;
1739   m_iDefaultNView = 320;
1740   m_iDefaultNSample = 2;
1741   m_dDefaultRotation = 1;
1742   m_dDefaultFocalLength = 2;
1743   m_dDefaultFieldOfView = 1;
1744   m_iDefaultGeometry = Scanner::GEOMETRY_PARALLEL;
1745   m_iDefaultTrace = Trace::TRACE_NONE;
1746
1747   m_iDefaultRasterNX = 256;
1748   m_iDefaultRasterNY = 256;
1749   m_iDefaultRasterNSamples = 2;
1750 }
1751
1752 PhantomFileView::~PhantomFileView()
1753 {
1754 }
1755
1756 void
1757 PhantomFileView::OnProperties (wxCommandEvent& event)
1758 {
1759   const int idPhantom = GetDocument()->getPhantomID();
1760   const wxString& namePhantom = GetDocument()->getPhantomName();
1761   std::ostringstream os;
1762   os << "Phantom " << namePhantom.c_str() << " (" << idPhantom << ")" << "\n";
1763   const Phantom& rPhantom = GetDocument()->getPhantom();
1764   rPhantom.printDefinitions (os);
1765 #if DEBUG
1766   rPhantom.print (os);
1767 #endif
1768   *theApp->getLog() << os.str().c_str() << "\n";
1769   wxMessageBox (os.str().c_str(), "Phantom Properties");
1770 }
1771
1772
1773 void
1774 PhantomFileView::OnProjections (wxCommandEvent& event)
1775 {
1776   DialogGetProjectionParameters dialogProjection (getFrameForChild(), m_iDefaultNDet, m_iDefaultNView, m_iDefaultNSample, m_dDefaultRotation, m_dDefaultFocalLength, m_dDefaultFieldOfView, m_iDefaultGeometry, m_iDefaultTrace);
1777   int retVal = dialogProjection.ShowModal();
1778   if (retVal == wxID_OK) {
1779     m_iDefaultNDet = dialogProjection.getNDet();
1780     m_iDefaultNView = dialogProjection.getNView();
1781     m_iDefaultNSample = dialogProjection.getNSamples();
1782     m_iDefaultTrace = dialogProjection.getTrace();
1783     m_dDefaultRotation = dialogProjection.getRotAngle();
1784     m_dDefaultFocalLength = dialogProjection.getFocalLengthRatio();
1785     m_dDefaultFieldOfView = dialogProjection.getFieldOfViewRatio();
1786     wxString sGeometry = dialogProjection.getGeometry();
1787     m_iDefaultGeometry = Scanner::convertGeometryNameToID (sGeometry.c_str());
1788
1789     if (m_iDefaultNDet > 0 && m_iDefaultNView > 0 && sGeometry != "") {
1790       const Phantom& rPhantom = GetDocument()->getPhantom();
1791       ProjectionFileDocument* pProjectionDoc = theApp->newProjectionDoc();
1792       if (! pProjectionDoc) {
1793         sys_error (ERR_SEVERE, "Unable to create projection document");
1794         return;
1795       }
1796       Projections& rProj = pProjectionDoc->getProjections();
1797       Scanner theScanner (rPhantom, sGeometry.c_str(), m_iDefaultNDet, m_iDefaultNView, m_iDefaultNSample, m_dDefaultRotation, m_dDefaultFocalLength, m_dDefaultFieldOfView);
1798       if (theScanner.fail()) {
1799         *theApp->getLog() << "Failed making scanner: " << theScanner.failMessage().c_str() << "\n";
1800         return;
1801       }
1802       rProj.initFromScanner (theScanner);
1803       m_dDefaultRotation /= PI;  // convert back to PI units
1804
1805       Timer timer;
1806       if (m_iDefaultTrace > Trace::TRACE_CONSOLE) {
1807         ProjectionsDialog dialogProjections (theScanner, rProj, rPhantom, m_iDefaultTrace, dynamic_cast<wxWindow*>(getFrameForChild()));
1808         for (int iView = 0; iView < rProj.nView(); iView++) {
1809           ::wxYield();
1810           ::wxYield();
1811           if (dialogProjections.isCancelled() || ! dialogProjections.projectView (iView)) {
1812             pProjectionDoc->DeleteAllViews();
1813             return;
1814           }
1815           ::wxYield();
1816           ::wxYield();
1817           while (dialogProjections.isPaused()) {
1818             ::wxYield();
1819             ::wxUsleep(50);
1820           }
1821         }
1822       } else {
1823         wxProgressDialog dlgProgress (wxString("Projection"), wxString("Projection Progress"), rProj.nView() + 1, getFrameForChild(), wxPD_CAN_ABORT);
1824         for (int i = 0; i < rProj.nView(); i++) {
1825           theScanner.collectProjections (rProj, rPhantom, i, 1, true, m_iDefaultTrace);
1826           if (! dlgProgress.Update (i+1)) {
1827             pProjectionDoc->DeleteAllViews();
1828             return;
1829           }
1830         }
1831       }
1832
1833       std::ostringstream os;
1834       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();
1835       rProj.setCalcTime (timer.timerEnd());
1836       rProj.setRemark (os.str());
1837       *theApp->getLog() << os.str().c_str() << "\n";
1838
1839       m_frame->Lower();
1840       ::wxYield();
1841       ProjectionFileView* projView = dynamic_cast<ProjectionFileView*>(pProjectionDoc->GetFirstView());
1842       if (projView) {
1843         projView->getFrame()->SetFocus();
1844         projView->OnUpdate (projView, NULL);
1845       }
1846       if (wxView* pView = pProjectionDoc->GetFirstView()) {
1847         if (wxFrame* pFrame = pView->GetFrame()) {
1848           pFrame->SetFocus();
1849           pFrame->Raise();
1850         }
1851         theApp->getDocManager()->ActivateView (pView, true, false);
1852       }
1853       ::wxYield();
1854       if (theApp->getSetModifyNewDocs())
1855         pProjectionDoc->Modify(true);
1856       pProjectionDoc->UpdateAllViews(this);
1857     }
1858   }
1859 }
1860
1861
1862 void
1863 PhantomFileView::OnRasterize (wxCommandEvent& event)
1864 {
1865   DialogGetRasterParameters dialogRaster (getFrameForChild(), m_iDefaultRasterNX, m_iDefaultRasterNY, m_iDefaultRasterNSamples);
1866   int retVal = dialogRaster.ShowModal();
1867   if (retVal == wxID_OK) {
1868     m_iDefaultRasterNX = dialogRaster.getXSize();
1869     m_iDefaultRasterNY  = dialogRaster.getYSize();
1870     m_iDefaultRasterNSamples = dialogRaster.getNSamples();
1871     if (m_iDefaultRasterNSamples < 1)
1872       m_iDefaultRasterNSamples = 1;
1873     if (m_iDefaultRasterNX > 0 && m_iDefaultRasterNY > 0) {
1874       const Phantom& rPhantom = GetDocument()->getPhantom();
1875       ImageFileDocument* pRasterDoc = theApp->newImageDoc();
1876       if (! pRasterDoc) {
1877         sys_error (ERR_SEVERE, "Unable to create image file");
1878         return;
1879       }
1880       ImageFile& imageFile = pRasterDoc->getImageFile();
1881
1882       imageFile.setArraySize (m_iDefaultRasterNX, m_iDefaultRasterNX);
1883       wxProgressDialog dlgProgress (wxString("Rasterize"), wxString("Rasterization Progress"), imageFile.nx() + 1, getFrameForChild(), wxPD_CAN_ABORT);
1884       Timer timer;
1885       for (unsigned int i = 0; i < imageFile.nx(); i++) {
1886         rPhantom.convertToImagefile (imageFile, m_iDefaultRasterNSamples, Trace::TRACE_NONE, i, 1, true);
1887         if (! dlgProgress.Update(i+1)) {
1888           pRasterDoc->DeleteAllViews();
1889           return;
1890         }
1891       }
1892       if (theApp->getSetModifyNewDocs())
1893         pRasterDoc->Modify(true);
1894       pRasterDoc->UpdateAllViews(this);
1895       std::ostringstream os;
1896       os << "Rasterize Phantom " << rPhantom.name() << ": XSize=" << m_iDefaultRasterNX << ", YSize="
1897         << m_iDefaultRasterNY << ", nSamples=" << m_iDefaultRasterNSamples;
1898       *theApp->getLog() << os.str().c_str() << "\n";
1899       imageFile.labelAdd (os.str().c_str(), timer.timerEnd());
1900       ImageFileView* rasterView = dynamic_cast<ImageFileView*>(pRasterDoc->GetFirstView());
1901       if (rasterView) {
1902         rasterView->getFrame()->SetFocus();
1903         rasterView->OnUpdate (rasterView, NULL);
1904       }
1905
1906     }
1907   }
1908 }
1909
1910
1911 PhantomCanvas*
1912 PhantomFileView::CreateCanvas (wxView *view, wxFrame *parent)
1913 {
1914   PhantomCanvas* pCanvas;
1915   int width, height;
1916   parent->GetClientSize(&width, &height);
1917
1918   pCanvas = new PhantomCanvas (dynamic_cast<PhantomFileView*>(view), parent, wxPoint(0, 0), wxSize(width, height), 0);
1919
1920   pCanvas->SetBackgroundColour(*wxWHITE);
1921   pCanvas->Clear();
1922
1923   return pCanvas;
1924 }
1925
1926 wxFrame*
1927 PhantomFileView::CreateChildFrame(wxDocument *doc, wxView *view)
1928 {
1929 #if CTSIM_MDI
1930   wxDocMDIChildFrame *subframe = new wxDocMDIChildFrame (doc, view, theApp->getMainFrame(), -1, "Phantom Frame", wxPoint(10, 10), wxSize(256, 256), wxDEFAULT_FRAME_STYLE);
1931 #else
1932   wxDocChildFrame *subframe = new wxDocChildFrame (doc, view, theApp->getMainFrame(), -1, "Phantom Frame", wxPoint(10, 10), wxSize(256, 256), wxDEFAULT_FRAME_STYLE);
1933 #endif
1934   theApp->setIconForFrame (subframe);
1935
1936   wxMenu *m_pFileMenu = new wxMenu;
1937
1938   m_pFileMenu->Append(MAINMENU_FILE_CREATE_PHANTOM, "Cr&eate Phantom...\tCtrl-P");
1939   m_pFileMenu->Append(MAINMENU_FILE_CREATE_FILTER, "Create &Filter...\tCtrl-F");
1940   m_pFileMenu->Append(wxID_OPEN, "&Open...\tCtrl-O");
1941   m_pFileMenu->Append(wxID_SAVEAS, "Save &As...");
1942   m_pFileMenu->Append(wxID_CLOSE, "&Close");
1943
1944   m_pFileMenu->AppendSeparator();
1945   m_pFileMenu->Append(PHMMENU_FILE_PROPERTIES, "P&roperties");
1946
1947   m_pFileMenu->AppendSeparator();
1948   m_pFileMenu->Append(wxID_PRINT, "&Print...");
1949   m_pFileMenu->Append(wxID_PRINT_SETUP, "Print &Setup...");
1950   m_pFileMenu->Append(wxID_PREVIEW, "Print Pre&view");
1951 #ifdef CTSIM_MDI
1952   m_pFileMenu->AppendSeparator();
1953   m_pFileMenu->Append(MAINMENU_FILE_EXIT, "E&xit");
1954 #endif
1955   theApp->getDocManager()->FileHistoryAddFilesToMenu(m_pFileMenu);
1956   theApp->getDocManager()->FileHistoryUseMenu(m_pFileMenu);
1957
1958   wxMenu *process_menu = new wxMenu;
1959   process_menu->Append(PHMMENU_PROCESS_RASTERIZE, "&Rasterize...\tCtrl-R");
1960   process_menu->Append(PHMMENU_PROCESS_PROJECTIONS, "&Projections...\tCtrl-J");
1961
1962   wxMenu *help_menu = new wxMenu;
1963   help_menu->Append(MAINMENU_HELP_CONTENTS, "&Contents\tF1");
1964   help_menu->Append(MAINMENU_HELP_TOPICS, "&Topics\tCtrl-H");
1965   help_menu->Append(MAINMENU_HELP_ABOUT, "&About");
1966
1967   wxMenuBar *menu_bar = new wxMenuBar;
1968
1969   menu_bar->Append(m_pFileMenu, "&File");
1970   menu_bar->Append(process_menu, "&Process");
1971   menu_bar->Append(help_menu, "&Help");
1972
1973   subframe->SetMenuBar(menu_bar);
1974   subframe->Centre(wxBOTH);
1975
1976   wxAcceleratorEntry accelEntries[8];
1977   accelEntries[0].Set (wxACCEL_CTRL, static_cast<int>('O'), wxID_OPEN);
1978   accelEntries[1].Set (wxACCEL_CTRL, static_cast<int>('S'), wxID_SAVE);
1979   accelEntries[2].Set (wxACCEL_CTRL, static_cast<int>('H'), MAINMENU_HELP_TOPICS);
1980   accelEntries[3].Set (wxACCEL_CTRL, static_cast<int>('P'), MAINMENU_FILE_CREATE_PHANTOM);
1981   accelEntries[4].Set (wxACCEL_CTRL, static_cast<int>('F'), MAINMENU_FILE_CREATE_FILTER);
1982   accelEntries[5].Set (wxACCEL_NORMAL, WXK_F1, MAINMENU_HELP_CONTENTS);
1983   accelEntries[6].Set (wxACCEL_CTRL, static_cast<int>('J'), PHMMENU_PROCESS_PROJECTIONS);
1984   accelEntries[7].Set (wxACCEL_CTRL, static_cast<int>('R'), PHMMENU_PROCESS_RASTERIZE);
1985   wxAcceleratorTable accelTable (8, accelEntries);
1986   subframe->SetAcceleratorTable (accelTable);
1987
1988   return subframe;
1989 }
1990
1991
1992 bool
1993 PhantomFileView::OnCreate(wxDocument *doc, long WXUNUSED(flags) )
1994 {
1995   m_frame = CreateChildFrame(doc, this);
1996   SetFrame(m_frame);
1997
1998   int width, height;
1999   m_frame->GetClientSize(&width, &height);
2000   m_frame->SetTitle("PhantomFileView");
2001   m_canvas = CreateCanvas (this, m_frame);
2002
2003 #ifdef __X__
2004   int x, y;  // X requires a forced resize
2005   m_frame->GetSize(&x, &y);
2006   m_frame->SetSize(-1, -1, x, y);
2007 #endif
2008
2009   m_frame->Show(true);
2010   Activate(true);
2011
2012   return true;
2013 }
2014
2015 void
2016 PhantomFileView::OnUpdate(wxView *WXUNUSED(sender), wxObject *WXUNUSED(hint) )
2017 {
2018   if (m_canvas)
2019     m_canvas->Refresh();
2020 }
2021
2022 bool
2023 PhantomFileView::OnClose (bool deleteWindow)
2024 {
2025   if (!GetDocument()->Close())
2026     return false;
2027
2028   if (m_canvas) {
2029     m_canvas->Clear();
2030     m_canvas->setView(NULL);
2031     m_canvas = NULL;
2032   }
2033   wxString s(wxTheApp->GetAppName());
2034   if (m_frame)
2035     m_frame->SetTitle(s);
2036   SetFrame(NULL);
2037
2038   Activate(false);
2039
2040   if (deleteWindow) {
2041     delete m_frame;
2042     m_frame = NULL;
2043   }
2044
2045   return true;
2046 }
2047
2048 void
2049 PhantomFileView::OnDraw (wxDC* dc)
2050 {
2051   int xsize, ysize;
2052   m_canvas->GetClientSize (&xsize, &ysize);
2053   SGPDriver driver (dc, xsize, ysize);
2054   SGP sgp (driver);
2055   const Phantom& rPhantom = GetDocument()->getPhantom();
2056   sgp.setColor (C_RED);
2057   rPhantom.show (sgp);
2058 }
2059
2060 // ProjectionCanvas
2061
2062 ProjectionFileCanvas::ProjectionFileCanvas (ProjectionFileView* v, wxFrame *frame, const wxPoint& pos, const wxSize& size, const long style)
2063 : wxScrolledWindow(frame, -1, pos, size, style)
2064 {
2065   m_pView = v;
2066 }
2067
2068 ProjectionFileCanvas::~ProjectionFileCanvas ()
2069 {
2070   if (m_pView) {
2071     wxMenu* pMenu = m_pView->getFileMenu();
2072     theApp->getDocManager()->FileHistoryRemoveMenu (pMenu);
2073     m_pView->canvasClosed();
2074     m_pView = NULL;
2075   }
2076 }
2077
2078 void
2079 ProjectionFileCanvas::OnDraw(wxDC& dc)
2080 {
2081   if (m_pView)
2082     m_pView->OnDraw(& dc);
2083 }
2084
2085 wxSize
2086 ProjectionFileCanvas::GetBestSize () const
2087 {
2088   wxSize best (0, 0);
2089   if (m_pView) {
2090     Projections& rProj = m_pView->GetDocument()->getProjections();
2091     best.Set (rProj.nDet(), rProj.nView());
2092   }
2093
2094   return best;
2095 }
2096
2097
2098 // ProjectionFileView
2099
2100 IMPLEMENT_DYNAMIC_CLASS(ProjectionFileView, wxView)
2101
2102 BEGIN_EVENT_TABLE(ProjectionFileView, wxView)
2103 EVT_MENU(PJMENU_FILE_PROPERTIES, ProjectionFileView::OnProperties)
2104 EVT_MENU(PJMENU_RECONSTRUCT_FBP, ProjectionFileView::OnReconstructFBP)
2105 EVT_MENU(PJMENU_CONVERT_POLAR, ProjectionFileView::OnConvertPolar)
2106 EVT_MENU(PJMENU_CONVERT_FFT_POLAR, ProjectionFileView::OnConvertFFTPolar)
2107 END_EVENT_TABLE()
2108
2109 ProjectionFileView::ProjectionFileView(void)
2110 : wxView(), m_canvas(NULL), m_frame(NULL), m_pFileMenu(0)
2111 {
2112   m_iDefaultNX = 256;
2113   m_iDefaultNY = 256;
2114   m_iDefaultFilter = SignalFilter::FILTER_ABS_BANDLIMIT;
2115   m_dDefaultFilterParam = 1.;
2116 #if HAVE_FFTW
2117   m_iDefaultFilterMethod = ProcessSignal::FILTER_METHOD_RFFTW;
2118   m_iDefaultFilterGeneration = ProcessSignal::FILTER_GENERATION_INVERSE_FOURIER;
2119 #else
2120   m_iDefaultFilterMethod = ProcessSignal::FILTER_METHOD_CONVOLUTION;
2121   m_iDefaultFilterGeneration = ProcessSignal::FILTER_GENERATION_DIRECT;
2122 #endif
2123   m_iDefaultZeropad = 1;
2124   m_iDefaultBackprojector = Backprojector::BPROJ_IDIFF3;
2125   m_iDefaultInterpolation = Backprojector::INTERP_LINEAR;
2126   m_iDefaultInterpParam = 1;
2127   m_iDefaultTrace = Trace::TRACE_NONE;
2128
2129   m_iDefaultPolarNX = 256;
2130   m_iDefaultPolarNY = 256;
2131   m_iDefaultPolarInterpolation = Projections::POLAR_INTERP_BILINEAR;
2132   m_iDefaultPolarZeropad = 1;
2133 }
2134
2135 ProjectionFileView::~ProjectionFileView(void)
2136 {
2137 }
2138
2139 void
2140 ProjectionFileView::OnProperties (wxCommandEvent& event)
2141 {
2142   const Projections& rProj = GetDocument()->getProjections();
2143   std::ostringstream os;
2144   rProj.printScanInfo(os);
2145   *theApp->getLog() << os.str().c_str();
2146   wxMessageDialog dialogMsg (getFrameForChild(), os.str().c_str(), "Projection File Properties", wxOK | wxICON_INFORMATION);
2147   dialogMsg.ShowModal();
2148 }
2149
2150
2151 void
2152 ProjectionFileView::OnConvertPolar (wxCommandEvent& event)
2153 {
2154   Projections& rProj = GetDocument()->getProjections();
2155   DialogGetConvertPolarParameters dialogPolar (getFrameForChild(), "Convert Polar", m_iDefaultPolarNX, m_iDefaultPolarNY,
2156     m_iDefaultPolarInterpolation, -1);
2157   if (dialogPolar.ShowModal() == wxID_OK) {
2158     wxString strInterpolation (dialogPolar.getInterpolationName());
2159     m_iDefaultPolarNX = dialogPolar.getXSize();
2160     m_iDefaultPolarNY = dialogPolar.getYSize();
2161     ImageFileDocument* pPolarDoc = theApp->newImageDoc();
2162     ImageFile& rIF = pPolarDoc->getImageFile();
2163     if (! pPolarDoc) {
2164       sys_error (ERR_SEVERE, "Unable to create image file");
2165       return;
2166     }
2167     rIF.setArraySize (m_iDefaultPolarNX, m_iDefaultPolarNY);
2168     m_iDefaultPolarInterpolation = Projections::convertInterpNameToID (strInterpolation.c_str());
2169     rProj.convertPolar (rIF, m_iDefaultPolarInterpolation);
2170     rIF.labelAdd (rProj.getLabel().getLabelString().c_str(), rProj.calcTime());
2171     std::ostringstream os;
2172     os << "Convert projection file " << GetFrame()->GetTitle().c_str() << " to polar image: xSize="
2173       << m_iDefaultPolarNX << ", ySize=" << m_iDefaultPolarNY << ", interpolation="
2174       << strInterpolation.c_str();
2175     *theApp->getLog() << os.str().c_str() << "\n";
2176     rIF.labelAdd (os.str().c_str());
2177     if (theApp->getSetModifyNewDocs())
2178       pPolarDoc->Modify(true);
2179     pPolarDoc->UpdateAllViews();
2180     pPolarDoc->GetFirstView()->OnUpdate (this, NULL);
2181   }
2182 }
2183
2184 void
2185 ProjectionFileView::OnConvertFFTPolar (wxCommandEvent& event)
2186 {
2187   Projections& rProj = GetDocument()->getProjections();
2188   DialogGetConvertPolarParameters dialogPolar (getFrameForChild(), "Convert to FFT Polar", m_iDefaultPolarNX, m_iDefaultPolarNY,
2189     m_iDefaultPolarInterpolation, m_iDefaultPolarZeropad);
2190   if (dialogPolar.ShowModal() == wxID_OK) {
2191     wxString strInterpolation (dialogPolar.getInterpolationName());
2192     m_iDefaultPolarNX = dialogPolar.getXSize();
2193     m_iDefaultPolarNY = dialogPolar.getYSize();
2194     m_iDefaultPolarZeropad = dialogPolar.getZeropad();
2195     ImageFileDocument* pPolarDoc = theApp->newImageDoc();
2196     ImageFile& rIF = pPolarDoc->getImageFile();
2197     if (! pPolarDoc) {
2198       sys_error (ERR_SEVERE, "Unable to create image file");
2199       return;
2200     }
2201     rIF.setArraySize (m_iDefaultPolarNX, m_iDefaultPolarNY);
2202     m_iDefaultPolarInterpolation = Projections::convertInterpNameToID (strInterpolation.c_str());
2203     rProj.convertFFTPolar (rIF, m_iDefaultPolarInterpolation, m_iDefaultPolarZeropad);
2204     rIF.labelAdd (rProj.getLabel().getLabelString().c_str(), rProj.calcTime());
2205     std::ostringstream os;
2206     os << "Convert projection file " << GetFrame()->GetTitle().c_str() << " to FFT polar image: xSize="
2207       << m_iDefaultPolarNX << ", ySize=" << m_iDefaultPolarNY << ", interpolation="
2208       << strInterpolation.c_str() << ", zeropad=" << m_iDefaultPolarZeropad;
2209     *theApp->getLog() << os.str().c_str() << "\n";
2210     rIF.labelAdd (os.str().c_str());
2211     if (theApp->getSetModifyNewDocs())
2212       pPolarDoc->Modify(true);
2213     pPolarDoc->UpdateAllViews();
2214     pPolarDoc->GetFirstView()->OnUpdate (this, NULL);
2215 }}
2216
2217 void
2218 ProjectionFileView::OnReconstructFourier (wxCommandEvent& event)
2219 {
2220   wxMessageBox ("Fourier Reconstruction is not yet supported", "Unimplemented function");
2221 }
2222
2223 void
2224 ProjectionFileView::OnReconstructFBP (wxCommandEvent& event)
2225 {
2226   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);
2227
2228   int retVal = dialogReconstruction.ShowModal();
2229   if (retVal == wxID_OK) {
2230     m_iDefaultNX = dialogReconstruction.getXSize();
2231     m_iDefaultNY = dialogReconstruction.getYSize();
2232     wxString optFilterName = dialogReconstruction.getFilterName();
2233     m_iDefaultFilter = SignalFilter::convertFilterNameToID (optFilterName.c_str());
2234     m_dDefaultFilterParam = dialogReconstruction.getFilterParam();
2235     wxString optFilterMethodName = dialogReconstruction.getFilterMethodName();
2236     m_iDefaultFilterMethod = ProcessSignal::convertFilterMethodNameToID(optFilterMethodName.c_str());
2237     m_iDefaultZeropad = dialogReconstruction.getZeropad();
2238     wxString optFilterGenerationName = dialogReconstruction.getFilterGenerationName();
2239     m_iDefaultFilterGeneration = ProcessSignal::convertFilterGenerationNameToID (optFilterGenerationName.c_str());
2240     wxString optInterpName = dialogReconstruction.getInterpName();
2241     m_iDefaultInterpolation = Backprojector::convertInterpNameToID (optInterpName.c_str());
2242     m_iDefaultInterpParam = dialogReconstruction.getInterpParam();
2243     wxString optBackprojectName = dialogReconstruction.getBackprojectName();
2244     m_iDefaultBackprojector = Backprojector::convertBackprojectNameToID (optBackprojectName.c_str());
2245     m_iDefaultTrace = dialogReconstruction.getTrace();
2246     if (m_iDefaultNX > 0 && m_iDefaultNY > 0) {
2247       ImageFileDocument* pReconDoc = theApp->newImageDoc();
2248       if (! pReconDoc) {
2249         sys_error (ERR_SEVERE, "Unable to create image file");
2250         return;
2251       }
2252       ImageFile& imageFile = pReconDoc->getImageFile();
2253       const Projections& rProj = GetDocument()->getProjections();
2254       imageFile.setArraySize (m_iDefaultNX, m_iDefaultNY);
2255
2256       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);
2257
2258       Timer timerRecon;
2259       if (m_iDefaultTrace > Trace::TRACE_CONSOLE) {
2260         ReconstructDialog* pDlgReconstruct = new ReconstructDialog (*pReconstruct, rProj, imageFile, m_iDefaultTrace, getFrameForChild());
2261         for (int iView = 0; iView < rProj.nView(); iView++) {
2262           ::wxYield();
2263           ::wxYield();
2264           if (pDlgReconstruct->isCancelled() || ! pDlgReconstruct->reconstructView (iView)) {
2265             delete pDlgReconstruct;
2266             delete pReconstruct;
2267             pReconDoc->DeleteAllViews();
2268             return;
2269           }
2270           ::wxYield();
2271           ::wxYield();
2272           while (pDlgReconstruct->isPaused()) {
2273             ::wxYield();
2274             ::wxUsleep(50);
2275           }
2276         }
2277         delete pDlgReconstruct;
2278       } else {
2279         wxProgressDialog dlgProgress (wxString("Reconstruction"), wxString("Reconstruction Progress"), rProj.nView() + 1, getFrameForChild(), wxPD_CAN_ABORT);
2280         for (int i = 0; i < rProj.nView(); i++) {
2281           pReconstruct->reconstructView (i, 1);
2282           if (! dlgProgress.Update(i + 1)) {
2283             delete pReconstruct;
2284             pReconDoc->DeleteAllViews();
2285             return;
2286           }
2287         }
2288       }
2289       delete pReconstruct;
2290       if (theApp->getSetModifyNewDocs())
2291         pReconDoc->Modify(true);
2292       pReconDoc->UpdateAllViews(this);
2293       ImageFileView* rasterView = dynamic_cast<ImageFileView*>(pReconDoc->GetFirstView());
2294       if (rasterView) {
2295         rasterView->getFrame()->SetFocus();
2296         rasterView->OnUpdate (rasterView, NULL);
2297       }
2298       std::ostringstream os;
2299       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();
2300       *theApp->getLog() << os.str().c_str() << "\n";
2301       imageFile.labelAdd (rProj.getLabel());
2302       imageFile.labelAdd (os.str().c_str(), timerRecon.timerEnd());
2303     }
2304   }
2305 }
2306
2307
2308 ProjectionFileCanvas*
2309 ProjectionFileView::CreateCanvas (wxView *view, wxFrame *parent)
2310 {
2311   ProjectionFileCanvas* pCanvas;
2312   int width, height;
2313   parent->GetClientSize(&width, &height);
2314
2315   pCanvas = new ProjectionFileCanvas (dynamic_cast<ProjectionFileView*>(view), parent, wxPoint(0, 0), wxSize(width, height), 0);
2316
2317   pCanvas->SetScrollbars(20, 20, 50, 50);
2318   pCanvas->SetBackgroundColour(*wxWHITE);
2319   pCanvas->Clear();
2320
2321   return pCanvas;
2322 }
2323
2324 wxFrame*
2325 ProjectionFileView::CreateChildFrame(wxDocument *doc, wxView *view)
2326 {
2327 #ifdef CTSIM_MDI
2328   wxDocMDIChildFrame *subframe = new wxDocMDIChildFrame (doc, view, theApp->getMainFrame(), -1, "Projection Frame", wxPoint(10, 10), wxSize(0, 0), wxDEFAULT_FRAME_STYLE);
2329 #else
2330   wxDocChildFrame *subframe = new wxDocChildFrame (doc, view, theApp->getMainFrame(), -1, "Projection Frame", wxPoint(10, 10), wxSize(0, 0), wxDEFAULT_FRAME_STYLE);
2331 #endif
2332   theApp->setIconForFrame (subframe);
2333
2334   wxMenu *m_pFileMenu = new wxMenu;
2335
2336   m_pFileMenu->Append(MAINMENU_FILE_CREATE_PHANTOM, "Cr&eate Phantom...\tCtrl-P");
2337   m_pFileMenu->Append(MAINMENU_FILE_CREATE_FILTER, "Create &Filter...\tCtrl-F");
2338   m_pFileMenu->Append(wxID_OPEN, "&Open...\tCtrl-O");
2339   m_pFileMenu->Append(wxID_SAVE, "&Save\tCtrl-S");
2340   m_pFileMenu->Append(wxID_SAVEAS, "Save &As...");
2341   m_pFileMenu->Append(wxID_CLOSE, "&Close\tCtrl-W");
2342
2343   m_pFileMenu->AppendSeparator();
2344   m_pFileMenu->Append(PJMENU_FILE_PROPERTIES, "P&roperties");
2345
2346   m_pFileMenu->AppendSeparator();
2347   m_pFileMenu->Append(wxID_PRINT, "&Print...");
2348   m_pFileMenu->Append(wxID_PRINT_SETUP, "Print &Setup...");
2349   m_pFileMenu->Append(wxID_PREVIEW, "Print Pre&view");
2350 #ifdef CTSIM_MDI
2351   m_pFileMenu->AppendSeparator();
2352   m_pFileMenu->Append(MAINMENU_FILE_EXIT, "E&xit");
2353 #endif
2354   theApp->getDocManager()->FileHistoryAddFilesToMenu(m_pFileMenu);
2355   theApp->getDocManager()->FileHistoryUseMenu(m_pFileMenu);
2356
2357   wxMenu *convert_menu = new wxMenu;
2358   convert_menu->Append (PJMENU_CONVERT_POLAR, "&Polar Image...\tCtrl-L");
2359   convert_menu->Append (PJMENU_CONVERT_FFT_POLAR, "&FFT->Polar Image...\tCtrl-I");
2360
2361   wxMenu *reconstruct_menu = new wxMenu;
2362   reconstruct_menu->Append (PJMENU_RECONSTRUCT_FBP, "&Filtered Backprojection...\tCtrl-R");
2363   reconstruct_menu->Append (PJMENU_RECONSTRUCT_FOURIER, "&Fourier...\tCtrl-E");
2364
2365   wxMenu *help_menu = new wxMenu;
2366   help_menu->Append(MAINMENU_HELP_CONTENTS, "&Contents\tF1");
2367   help_menu->Append(MAINMENU_HELP_TOPICS, "&Topics\tCtrl-H");
2368   help_menu->Append(MAINMENU_HELP_ABOUT, "&About");
2369
2370   wxMenuBar *menu_bar = new wxMenuBar;
2371
2372   menu_bar->Append (m_pFileMenu, "&File");
2373   menu_bar->Append (convert_menu, "&Convert");
2374   menu_bar->Append (reconstruct_menu, "&Reconstruct");
2375   menu_bar->Append (help_menu, "&Help");
2376
2377   subframe->SetMenuBar(menu_bar);
2378   subframe->Centre(wxBOTH);
2379
2380   wxAcceleratorEntry accelEntries[11];
2381   accelEntries[0].Set (wxACCEL_CTRL, static_cast<int>('O'), wxID_OPEN);
2382   accelEntries[1].Set (wxACCEL_CTRL, static_cast<int>('S'), wxID_SAVE);
2383   accelEntries[2].Set (wxACCEL_CTRL, static_cast<int>('W'), wxID_CLOSE);
2384   accelEntries[3].Set (wxACCEL_CTRL, static_cast<int>('H'), MAINMENU_HELP_TOPICS);
2385   accelEntries[4].Set (wxACCEL_CTRL, static_cast<int>('P'), MAINMENU_FILE_CREATE_PHANTOM);
2386   accelEntries[5].Set (wxACCEL_CTRL, static_cast<int>('F'), MAINMENU_FILE_CREATE_FILTER);
2387   accelEntries[6].Set (wxACCEL_NORMAL, WXK_F1, MAINMENU_HELP_CONTENTS);
2388   accelEntries[7].Set (wxACCEL_CTRL, static_cast<int>('L'), PJMENU_CONVERT_POLAR);
2389   accelEntries[8].Set (wxACCEL_CTRL, static_cast<int>('I'), PJMENU_CONVERT_FFT_POLAR);
2390   accelEntries[9].Set (wxACCEL_CTRL, static_cast<int>('R'), PJMENU_RECONSTRUCT_FBP);
2391   accelEntries[10].Set (wxACCEL_CTRL, static_cast<int>('E'), PJMENU_RECONSTRUCT_FOURIER);
2392   wxAcceleratorTable accelTable (11, accelEntries);
2393   subframe->SetAcceleratorTable (accelTable);
2394
2395   return subframe;
2396 }
2397
2398
2399 bool
2400 ProjectionFileView::OnCreate(wxDocument *doc, long WXUNUSED(flags) )
2401 {
2402   m_frame = CreateChildFrame(doc, this);
2403   SetFrame(m_frame);
2404
2405   int width, height;
2406   m_frame->GetClientSize(&width, &height);
2407   m_frame->SetTitle("ProjectionFileView");
2408   m_canvas = CreateCanvas(this, m_frame);
2409
2410 #ifdef __X__
2411   int x, y;  // X requires a forced resize
2412   m_frame->GetSize(&x, &y);
2413   m_frame->SetSize(-1, -1, x, y);
2414 #endif
2415
2416   m_frame->Show(true);
2417   Activate(true);
2418
2419   return true;
2420 }
2421
2422 void
2423 ProjectionFileView::OnDraw (wxDC* dc)
2424 {
2425   wxSize clientSize = m_frame->GetClientSize();
2426   wxSize bestSize = m_canvas->GetBestSize();
2427
2428   if (clientSize.x > bestSize.x || clientSize.y > bestSize.y)
2429     m_frame->SetClientSize (bestSize);
2430
2431   if (m_bitmap.Ok())
2432     dc->DrawBitmap (m_bitmap, 0, 0, false);
2433 }
2434
2435
2436 void
2437 ProjectionFileView::OnUpdate(wxView *WXUNUSED(sender), wxObject *WXUNUSED(hint) )
2438 {
2439   const Projections& rProj = GetDocument()->getProjections();
2440   const int nDet = rProj.nDet();
2441   const int nView = rProj.nView();
2442   if (nDet != 0 && nView != 0) {
2443     const DetectorArray& detarray = rProj.getDetectorArray(0);
2444     const DetectorValue* detval = detarray.detValues();
2445     double min = detval[0];
2446     double max = detval[0];
2447     for (int iy = 0; iy < nView; iy++) {
2448       const DetectorArray& detarray = rProj.getDetectorArray(iy);
2449       const DetectorValue* detval = detarray.detValues();
2450       for (int ix = 0; ix < nDet; ix++) {
2451         if (min > detval[ix])
2452           min = detval[ix];
2453         else if (max < detval[ix])
2454           max = detval[ix];
2455       }
2456     }
2457
2458     unsigned char* imageData = new unsigned char [nDet * nView * 3];
2459     double scale = (max - min) / 255;
2460     for (int iy2 = 0; iy2 < nView; iy2++) {
2461       const DetectorArray& detarray = rProj.getDetectorArray (iy2);
2462       const DetectorValue* detval = detarray.detValues();
2463       for (int ix = 0; ix < nDet; ix++) {
2464         int intensity = static_cast<int>(((detval[ix] - min) / scale) + 0.5);
2465         intensity = clamp(intensity, 0, 255);
2466         int baseAddr = (iy2 * nDet + ix) * 3;
2467         imageData[baseAddr] = imageData[baseAddr+1] = imageData[baseAddr+2] = intensity;
2468       }
2469     }
2470     wxImage image (nDet, nView, imageData, true);
2471     m_bitmap = image.ConvertToBitmap();
2472     delete imageData;
2473     int xSize = nDet;
2474     int ySize = nView;
2475     xSize = clamp (xSize, 0, 800);
2476     ySize = clamp (ySize, 0, 800);
2477     m_frame->SetClientSize (xSize, ySize);
2478     m_canvas->SetScrollbars (20, 20, nDet/20, nView/20);
2479   }
2480
2481   if (m_canvas)
2482     m_canvas->Refresh();
2483 }
2484
2485 bool
2486 ProjectionFileView::OnClose (bool deleteWindow)
2487 {
2488   if (!GetDocument()->Close())
2489     return false;
2490
2491   if (m_canvas) {
2492     //m_canvas->Clear();
2493     m_canvas->setView(NULL);
2494     m_canvas = NULL;
2495   }
2496 //  wxString s(wxTheApp->GetAppName());
2497 //  if (m_frame)
2498 //    m_frame->SetTitle(s);
2499   SetFrame(NULL);
2500
2501   Activate(false);
2502
2503   if (deleteWindow) {
2504     delete m_frame;
2505     return true;
2506   }
2507   return true;
2508 }
2509
2510
2511
2512 // PlotFileCanvas
2513 PlotFileCanvas::PlotFileCanvas (PlotFileView* v, wxFrame *frame, const wxPoint& pos, const wxSize& size, const long style)
2514 : wxScrolledWindow(frame, -1, pos, size, style)
2515 {
2516   m_pView = v;
2517 }
2518
2519 PlotFileCanvas::~PlotFileCanvas ()
2520 {
2521   if (m_pView) {
2522     wxMenu* pMenu = m_pView->getFileMenu();
2523     theApp->getDocManager()->FileHistoryRemoveMenu (pMenu);
2524     m_pView->canvasClosed();
2525     m_pView = NULL;
2526   }
2527 }
2528
2529 void
2530 PlotFileCanvas::OnDraw(wxDC& dc)
2531 {
2532   if (m_pView)
2533     m_pView->OnDraw(& dc);
2534 }
2535
2536
2537 // PlotFileView
2538
2539 IMPLEMENT_DYNAMIC_CLASS(PlotFileView, wxView)
2540
2541 BEGIN_EVENT_TABLE(PlotFileView, wxView)
2542 EVT_MENU(PJMENU_FILE_PROPERTIES, PlotFileView::OnProperties)
2543 EVT_MENU(PLOTMENU_VIEW_SCALE_MINMAX, PlotFileView::OnScaleMinMax)
2544 EVT_MENU(PLOTMENU_VIEW_SCALE_AUTO, PlotFileView::OnScaleAuto)
2545 EVT_MENU(PLOTMENU_VIEW_SCALE_FULL, PlotFileView::OnScaleFull)
2546 END_EVENT_TABLE()
2547
2548 PlotFileView::PlotFileView(void)
2549 : wxView(), m_canvas(NULL), m_frame(NULL), m_pEZPlot(NULL), m_pFileMenu(0)
2550 {
2551   m_bMinSpecified = false;
2552   m_bMaxSpecified = false;
2553 }
2554
2555 PlotFileView::~PlotFileView(void)
2556 {
2557   if (m_pEZPlot)
2558     delete m_pEZPlot;
2559 }
2560
2561 void
2562 PlotFileView::OnProperties (wxCommandEvent& event)
2563 {
2564   const PlotFile& rPlot = GetDocument()->getPlotFile();
2565   std::ostringstream os;
2566   os << "Columns: " << rPlot.getNumColumns() << ", Records: " << rPlot.getNumRecords() << "\n";
2567   rPlot.printHeadersBrief (os);
2568   *theApp->getLog() << os.str().c_str();
2569   wxMessageDialog dialogMsg (getFrameForChild(), os.str().c_str(), "Plot File Properties", wxOK | wxICON_INFORMATION);
2570   dialogMsg.ShowModal();
2571 }
2572
2573
2574 void
2575 PlotFileView::OnScaleAuto (wxCommandEvent& event)
2576 {
2577   const PlotFile& rPlotFile = GetDocument()->getPlotFile();
2578   double min, max, mean, mode, median, stddev;
2579   rPlotFile.statistics (1, min, max, mean, mode, median, stddev);
2580   DialogAutoScaleParameters dialogAutoScale (getFrameForChild(), mean, mode, median, stddev, m_dAutoScaleFactor);
2581   int iRetVal = dialogAutoScale.ShowModal();
2582   if (iRetVal == wxID_OK) {
2583     m_bMinSpecified = true;
2584     m_bMaxSpecified = true;
2585     double dMin, dMax;
2586     if (dialogAutoScale.getMinMax (&dMin, &dMax)) {
2587       m_dMinPixel = dMin;
2588       m_dMaxPixel = dMax;
2589       m_dAutoScaleFactor = dialogAutoScale.getAutoScaleFactor();
2590       OnUpdate (this, NULL);
2591     }
2592   }
2593 }
2594
2595 void
2596 PlotFileView::OnScaleMinMax (wxCommandEvent& event)
2597 {
2598   const PlotFile& rPlotFile = GetDocument()->getPlotFile();
2599   double min;
2600   double max;
2601
2602   if (! m_bMinSpecified || ! m_bMaxSpecified) {
2603     if (! rPlotFile.getMinMax (1, min, max)) {
2604       *theApp->getLog() << "Error: unable to find Min/Max\n";
2605       return;
2606     }
2607   }
2608
2609   if (m_bMinSpecified)
2610     min = m_dMinPixel;
2611   if (m_bMaxSpecified)
2612     max = m_dMaxPixel;
2613
2614   DialogGetMinMax dialogMinMax (getFrameForChild(), "Set Y-axis Minimum & Maximum", min, max);
2615   int retVal = dialogMinMax.ShowModal();
2616   if (retVal == wxID_OK) {
2617     m_bMinSpecified = true;
2618     m_bMaxSpecified = true;
2619     m_dMinPixel = dialogMinMax.getMinimum();
2620     m_dMaxPixel = dialogMinMax.getMaximum();
2621     OnUpdate (this, NULL);
2622   }
2623 }
2624
2625 void
2626 PlotFileView::OnScaleFull (wxCommandEvent& event)
2627 {
2628   if (m_bMinSpecified || m_bMaxSpecified) {
2629     m_bMinSpecified = false;
2630     m_bMaxSpecified = false;
2631     OnUpdate (this, NULL);
2632   }
2633 }
2634
2635
2636 PlotFileCanvas*
2637 PlotFileView::CreateCanvas (wxView *view, wxFrame *parent)
2638 {
2639   PlotFileCanvas* pCanvas;
2640   int width, height;
2641   parent->GetClientSize(&width, &height);
2642
2643   pCanvas = new PlotFileCanvas (dynamic_cast<PlotFileView*>(view), parent, wxPoint(0, 0), wxSize(width, height), 0);
2644
2645   pCanvas->SetBackgroundColour(*wxWHITE);
2646   pCanvas->Clear();
2647
2648   return pCanvas;
2649 }
2650
2651 wxFrame*
2652 PlotFileView::CreateChildFrame(wxDocument *doc, wxView *view)
2653 {
2654 #ifdef CTSIM_MDI
2655   wxDocMDIChildFrame *subframe = new wxDocMDIChildFrame (doc, view, theApp->getMainFrame(), -1, "Plot Frame", wxPoint(10, 10), wxSize(500, 300), wxDEFAULT_FRAME_STYLE);
2656 #else
2657   wxDocChildFrame *subframe = new wxDocChildFrame(doc, view, theApp->getMainFrame(), -1, "Plot Frame", wxPoint(10, 10), wxSize(500, 300), wxDEFAULT_FRAME_STYLE);
2658 #endif
2659   theApp->setIconForFrame (subframe);
2660
2661   wxMenu *m_pFileMenu = new wxMenu;
2662
2663   m_pFileMenu->Append(MAINMENU_FILE_CREATE_PHANTOM, "Cr&eate Phantom...\tCtrl-P");
2664   m_pFileMenu->Append(MAINMENU_FILE_CREATE_FILTER, "Create &Filter...\tCtrl-F");
2665   m_pFileMenu->Append(wxID_OPEN, "&Open...\tCtrl-O");
2666   m_pFileMenu->Append(wxID_SAVE, "&Save\tCtrl-S");
2667   m_pFileMenu->Append(wxID_SAVEAS, "Save &As...");
2668   m_pFileMenu->Append(wxID_CLOSE, "&Close\tCtrl-W");
2669
2670   m_pFileMenu->AppendSeparator();
2671   m_pFileMenu->Append(PJMENU_FILE_PROPERTIES, "P&roperties");
2672
2673   m_pFileMenu->AppendSeparator();
2674   m_pFileMenu->Append(wxID_PRINT, "&Print...");
2675   m_pFileMenu->Append(wxID_PRINT_SETUP, "Print &Setup...");
2676   m_pFileMenu->Append(wxID_PREVIEW, "Print Pre&view");
2677 #ifdef CTSIM_MDI
2678   m_pFileMenu->AppendSeparator();
2679   m_pFileMenu->Append(MAINMENU_FILE_EXIT, "E&xit");
2680 #endif
2681   theApp->getDocManager()->FileHistoryAddFilesToMenu(m_pFileMenu);
2682   theApp->getDocManager()->FileHistoryUseMenu(m_pFileMenu);
2683
2684   wxMenu *view_menu = new wxMenu;
2685   view_menu->Append(PLOTMENU_VIEW_SCALE_MINMAX, "Display Scale &Set...\tCtrl-E");
2686   view_menu->Append(PLOTMENU_VIEW_SCALE_AUTO, "Display Scale &Auto...\tCtrl-A");
2687   view_menu->Append(PLOTMENU_VIEW_SCALE_FULL, "Display &Full Scale\tCtrl-U");
2688
2689   wxMenu *help_menu = new wxMenu;
2690   help_menu->Append(MAINMENU_HELP_CONTENTS, "&Contents\tF1");
2691   help_menu->Append(MAINMENU_HELP_TOPICS, "&Topics\tCtrl-H");
2692   help_menu->Append(MAINMENU_HELP_ABOUT, "&About");
2693
2694   wxMenuBar *menu_bar = new wxMenuBar;
2695
2696   menu_bar->Append(m_pFileMenu, "&File");
2697   menu_bar->Append(view_menu, "&View");
2698   menu_bar->Append(help_menu, "&Help");
2699
2700   subframe->SetMenuBar(menu_bar);
2701   subframe->Centre(wxBOTH);
2702
2703   wxAcceleratorEntry accelEntries[10];
2704   accelEntries[0].Set (wxACCEL_CTRL, static_cast<int>('O'), wxID_OPEN);
2705   accelEntries[1].Set (wxACCEL_CTRL, static_cast<int>('S'), wxID_SAVE);
2706   accelEntries[2].Set (wxACCEL_CTRL, static_cast<int>('W'), wxID_CLOSE);
2707   accelEntries[3].Set (wxACCEL_CTRL, static_cast<int>('H'), MAINMENU_HELP_TOPICS);
2708   accelEntries[4].Set (wxACCEL_CTRL, static_cast<int>('P'), MAINMENU_FILE_CREATE_PHANTOM);
2709   accelEntries[5].Set (wxACCEL_CTRL, static_cast<int>('F'), MAINMENU_FILE_CREATE_FILTER);
2710   accelEntries[6].Set (wxACCEL_NORMAL, WXK_F1, MAINMENU_HELP_CONTENTS);
2711   accelEntries[7].Set (wxACCEL_CTRL, static_cast<int>('E'), PLOTMENU_VIEW_SCALE_MINMAX);
2712   accelEntries[8].Set (wxACCEL_CTRL, static_cast<int>('A'), PLOTMENU_VIEW_SCALE_AUTO);
2713   accelEntries[9].Set (wxACCEL_CTRL, static_cast<int>('U'), PLOTMENU_VIEW_SCALE_FULL);
2714   wxAcceleratorTable accelTable (10, accelEntries);
2715   subframe->SetAcceleratorTable (accelTable);
2716
2717   return subframe;
2718 }
2719
2720
2721 bool
2722 PlotFileView::OnCreate (wxDocument *doc, long WXUNUSED(flags) )
2723 {
2724   m_frame = CreateChildFrame(doc, this);
2725   SetFrame(m_frame);
2726
2727   m_bMinSpecified = false;
2728   m_bMaxSpecified = false;
2729   m_dAutoScaleFactor = 1.;
2730
2731   int width, height;
2732   m_frame->GetClientSize(&width, &height);
2733   m_frame->SetTitle ("Plot File");
2734   m_canvas = CreateCanvas (this, m_frame);
2735
2736 #ifdef __X__
2737   int x, y;  // X requires a forced resize
2738   m_frame->GetSize(&x, &y);
2739   m_frame->SetSize(-1, -1, x, y);
2740 #endif
2741
2742   m_frame->Show(true);
2743   Activate(true);
2744
2745   return true;
2746 }
2747
2748 void
2749 PlotFileView::OnDraw (wxDC* dc)
2750 {
2751   const PlotFile& rPlotFile = GetDocument()->getPlotFile();
2752   const int iNColumns = rPlotFile.getNumColumns();
2753   const int iNRecords = rPlotFile.getNumRecords();
2754
2755   if (iNColumns > 0 && iNRecords > 0) {
2756     int xsize, ysize;
2757     m_canvas->GetClientSize (&xsize, &ysize);
2758     SGPDriver driver (dc, xsize, ysize);
2759     SGP sgp (driver);
2760     if (m_pEZPlot)
2761       m_pEZPlot->plot (&sgp);
2762   }
2763 }
2764
2765
2766 void
2767 PlotFileView::OnUpdate (wxView *WXUNUSED(sender), wxObject *WXUNUSED(hint) )
2768 {
2769   const PlotFile& rPlotFile = GetDocument()->getPlotFile();
2770   const int iNColumns = rPlotFile.getNumColumns();
2771   const int iNRecords = rPlotFile.getNumRecords();
2772
2773   if (iNColumns > 0 && iNRecords > 0) {
2774     if (m_pEZPlot)
2775       delete m_pEZPlot;
2776     m_pEZPlot = new EZPlot;
2777
2778     for (unsigned int iEzset = 0; iEzset < rPlotFile.getNumEzsetCommands(); iEzset++)
2779       m_pEZPlot->ezset (rPlotFile.getEzsetCommand (iEzset));
2780
2781     if (m_bMinSpecified) {
2782       std::ostringstream os;
2783       os << "ymin " << m_dMinPixel;
2784       m_pEZPlot->ezset (os.str());
2785     }
2786
2787     if (m_bMaxSpecified) {
2788       std::ostringstream os;
2789       os << "ymax " << m_dMaxPixel;
2790       m_pEZPlot->ezset (os.str());
2791     }
2792
2793     m_pEZPlot->ezset("box");
2794     m_pEZPlot->ezset("grid");
2795
2796     double* pdXaxis = new double [iNRecords];
2797     rPlotFile.getColumn (0, pdXaxis);
2798
2799     double* pdY = new double [iNRecords];
2800     for (int iCol = 1; iCol < iNColumns; iCol++) {
2801       rPlotFile.getColumn (iCol, pdY);
2802       m_pEZPlot->addCurve (pdXaxis, pdY, iNRecords);
2803     }
2804
2805     delete pdXaxis;
2806     delete pdY;
2807   }
2808
2809   if (m_canvas)
2810     m_canvas->Refresh();
2811 }
2812
2813 bool
2814 PlotFileView::OnClose (bool deleteWindow)
2815 {
2816   if (!GetDocument()->Close())
2817     return false;
2818
2819   if (m_canvas) {
2820     //m_canvas->Clear();
2821     m_canvas->setView (NULL);
2822     m_canvas = NULL;
2823   }
2824 //  wxString s(wxTheApp->GetAppName());
2825 //  if (m_frame)
2826 //    m_frame->SetTitle(s);
2827   SetFrame(NULL);
2828
2829   Activate(false);
2830
2831   if (deleteWindow) {
2832     delete m_frame;
2833     return true;
2834   }
2835   return true;
2836 }
2837
2838
2839 ////////////////////////////////////////////////////////////////
2840
2841
2842 IMPLEMENT_DYNAMIC_CLASS(TextFileView, wxView)
2843
2844 TextFileView::~TextFileView()
2845 {
2846 }
2847
2848 bool TextFileView::OnCreate(wxDocument *doc, long WXUNUSED(flags) )
2849 {
2850   m_pFrame = CreateChildFrame(doc, this);
2851   SetFrame (m_pFrame);
2852
2853   int width, height;
2854   m_pFrame->GetClientSize(&width, &height);
2855   m_pFrame->SetTitle("TextFile");
2856   m_pCanvas = new TextFileCanvas (this, m_pFrame, wxPoint(0, 0), wxSize(width, height), wxTE_MULTILINE | wxTE_READONLY);
2857   m_pFrame->SetTitle("Log");
2858
2859 #ifdef __X__
2860   // X seems to require a forced resize
2861   int x, y;
2862   frame->GetSize(&x, &y);
2863   frame->SetSize(-1, -1, x, y);
2864 #endif
2865
2866   m_pFrame->Show (true);
2867   Activate (true);
2868
2869   return true;
2870 }
2871
2872 // Handled by wxTextWindow
2873 void TextFileView::OnDraw(wxDC *WXUNUSED(dc) )
2874 {
2875 }
2876
2877 void TextFileView::OnUpdate(wxView *WXUNUSED(sender), wxObject *WXUNUSED(hint) )
2878 {
2879 }
2880
2881 bool
2882 TextFileView::OnClose (bool deleteWindow)
2883 {
2884   return false;
2885
2886   if (!GetDocument()->Close())
2887     return false;
2888
2889   Activate(false);
2890
2891   if (deleteWindow)
2892   {
2893     delete m_pFrame;
2894     return TRUE;
2895   }
2896   return TRUE;
2897 }
2898
2899 wxFrame*
2900 TextFileView::CreateChildFrame (wxDocument *doc, wxView *view)
2901 {
2902 #if CTSIM_MDI
2903   wxDocMDIChildFrame* subframe = new wxDocMDIChildFrame (doc, view, theApp->getMainFrame(), -1, "TextFile Frame", wxPoint(-1, -1), wxSize(300, 150), wxDEFAULT_FRAME_STYLE);
2904 #else
2905   wxDocChildFrame* subframe = new wxDocChildFrame (doc, view, theApp->getMainFrame(), -1, "TextFile Frame", wxPoint(-1, -1), wxSize(300, 150), wxDEFAULT_FRAME_STYLE);
2906 #endif
2907   theApp->setIconForFrame (subframe);
2908
2909   wxMenu *m_pFileMenu = new wxMenu;
2910
2911   m_pFileMenu->Append(MAINMENU_FILE_CREATE_PHANTOM, "Cr&eate Phantom...\tCtrl-P");
2912   m_pFileMenu->Append(MAINMENU_FILE_CREATE_FILTER, "Create &Filter...\tCtrl-F");
2913   m_pFileMenu->Append(wxID_OPEN, "&Open...\tCtrl-O");
2914   m_pFileMenu->Append(wxID_SAVE, "&Save\tCtrl-S");
2915   m_pFileMenu->Append(wxID_SAVEAS, "Save &As...");
2916   //  m_pFileMenu->Append(wxID_CLOSE, "&Close\tCtrl-W");
2917
2918   m_pFileMenu->AppendSeparator();
2919   m_pFileMenu->Append(wxID_PRINT, "&Print...");
2920   m_pFileMenu->Append(wxID_PRINT_SETUP, "Print &Setup...");
2921   m_pFileMenu->Append(wxID_PREVIEW, "Print Pre&view");
2922 #ifdef CTSIM_MDI
2923   m_pFileMenu->AppendSeparator();
2924   m_pFileMenu->Append(MAINMENU_FILE_EXIT, "E&xit");
2925 #endif
2926   theApp->getDocManager()->FileHistoryAddFilesToMenu(m_pFileMenu);
2927   theApp->getDocManager()->FileHistoryUseMenu(m_pFileMenu);
2928
2929   wxMenu *help_menu = new wxMenu;
2930   help_menu->Append(MAINMENU_HELP_CONTENTS, "&Contents\tF1");
2931   help_menu->Append(MAINMENU_HELP_TOPICS, "&Topics\tCtrl-H");
2932   help_menu->Append(MAINMENU_HELP_ABOUT, "&About");
2933
2934   wxMenuBar *menu_bar = new wxMenuBar;
2935
2936   menu_bar->Append(m_pFileMenu, "&File");
2937   menu_bar->Append(help_menu, "&Help");
2938
2939   subframe->SetMenuBar(menu_bar);
2940   subframe->Centre(wxBOTH);
2941
2942   wxAcceleratorEntry accelEntries[5];
2943   accelEntries[0].Set (wxACCEL_CTRL, static_cast<int>('O'), wxID_OPEN);
2944   accelEntries[1].Set (wxACCEL_CTRL, static_cast<int>('S'), wxID_SAVE);
2945   accelEntries[2].Set (wxACCEL_CTRL, static_cast<int>('W'), wxID_CLOSE);
2946   accelEntries[3].Set (wxACCEL_CTRL, static_cast<int>('H'), MAINMENU_HELP_TOPICS);
2947   accelEntries[4].Set (wxACCEL_NORMAL, WXK_F1, MAINMENU_HELP_CONTENTS);
2948   wxAcceleratorTable accelTable (5, accelEntries);
2949   subframe->SetAcceleratorTable (accelTable);
2950
2951   return subframe;
2952 }
2953
2954
2955 // Define a constructor for my text subwindow
2956 TextFileCanvas::TextFileCanvas (TextFileView* v, wxFrame* frame, const wxPoint& pos, const wxSize& size, long style)
2957   : wxTextCtrl (frame, -1, "", pos, size, style), m_pView(v)
2958 {
2959 }
2960
2961 TextFileCanvas::~TextFileCanvas ()
2962 {
2963   if (m_pView) {
2964     wxMenu* pMenu = m_pView->getFileMenu();
2965     theApp->getDocManager()->FileHistoryRemoveMenu (pMenu);
2966     m_pView->canvasClosed();
2967     m_pView = NULL;
2968   }
2969 }