src/graph3dview.cpp

   1 /*****************************************************************************
   2 ** FILE IDENTIFICATION
   3 **
   4 **   Name:          graph3dview.cpp
   5 **   Purpose:       3d graph view classes
   6 **   Programmer:    Kevin Rosenberg
   7 **   Date Started:  Jan 2001
   8 **
   9 **  This is part of the CTSim program
  10 **  Copyright (c) 1983-2001 Kevin Rosenberg
  11 **
  12 **  $Id: graph3dview.cpp,v 1.10 2001/02/04 21:28:19 kevin Exp $
  13 **
  14 **  This program is free software; you can redistribute it and/or modify
  15 **  it under the terms of the GNU General Public License (version 2) as
  16 **  published by the Free Software Foundation.
  17 **
  18 **  This program is distributed in the hope that it will be useful,
  19 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 **  GNU General Public License for more details.
  22 **
  23 **  You should have received a copy of the GNU General Public License
  24 **  along with this program; if not, write to the Free Software
  25 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  26 ******************************************************************************/
  27
  28 #ifdef __GNUG__
  29 #pragma implementation
  30 #pragma interface
  31 #endif
  32
  33 // For compilers that support precompilation, includes "wx.h".
  34 #include "wx/wxprec.h"
  35
  36 #ifdef __BORLANDC__
  37 #pragma hdrstop
  38 #endif
  39
  40 #ifndef WX_PRECOMP
  41 #include "wx/wx.h"
  42 #endif
  43
  44 #if wxUSE_GLCANVAS
  45
  46 #if !wxUSE_GLCANVAS
  47 #error Please set wxUSE_GLCANVAS to 1 in setup.h.
  48 #endif
  49
  50 #include "wx/timer.h"
  51 #include "wx/glcanvas.h"
  52
  53 #include <GL/gl.h>
  54 #include <GL/glu.h>
  55
  56 #include "ct.h"
  57 #include "ctsim.h"
  58 #include "docs.h"
  59 #include "views.h"
  60 #include "dialogs.h"
  61 #include "dlgprojections.h"
  62 #include "dlgreconstruct.h"
  63 #include "backprojectors.h"
  64 #include "reconstruct.h"
  65 #include "timer.h"
  66
  67 #if defined(MSVC) || HAVE_SSTREAM
  68 #include <sstream>
  69 #else
  70 #include <sstream_subst>
  71 #endif
  72
  73 void
  74 Graph3dFileView::intensityToColor (double dIntensity, GLfloat* vecColor)
  75 {
  76   if (dIntensity < 0 || dIntensity > 1) {
  77     vecColor[0] = vecColor[1] = vecColor[2] = 1;
  78     return;
  79   }
  80
  81   float fRange = dIntensity * 5;
  82   int iRange = static_cast<int>(floor (fRange));
  83   float fFrac = fRange - iRange;
  84
  85   // Rainbow: Purple->Blue->Cyan->Green->Yellow->Red = (1,0,1)-(0,0,1)-(0,1,1)-(0,1,0)-(1,1,0)-(1,0,0)
  86   switch (iRange) {
  87   case 0:
  88     vecColor[0] = 1.0f - fFrac; vecColor[1] = 0.0f; vecColor[2] = 1.0f;
  89     break;
  90   case 1:
  91     vecColor[0] = 0.0f; vecColor[1] = fFrac; vecColor[2] = 1.0f;
  92     break;
  93   case 2:
  94     vecColor[0] = 0.0f; vecColor[1] = 1.0f; vecColor[2] = 1.0f - fFrac;
  95     break;
  96   case 3:
  97     vecColor[0] = fFrac; vecColor[1] = 1.0f; vecColor[2] = 0.0f;
  98     break;
  99   case 4:
 100     vecColor[0] = 1.0f; vecColor[1] = 1.0f - fFrac; vecColor[2] = 0.0f;
 101     break;
 102   case 5:
 103     vecColor[0] = 1.0f; vecColor[1] = 0.0f; vecColor[2] = 0.0f;
 104     break;
 105   }
 106 }
 107
 108 //***********************************************************************
 109 // Function: CalculateVectorNormal
 110 //
 111 // Purpose: Given three points of a 3D plane, this function calculates
 112 //          the normal vector of that plane.
 113 //
 114 // Parameters:
 115 //     fVert1[]   == array for 1st point (3 elements are x, y, and z).
 116 //     fVert2[]   == array for 2nd point (3 elements are x, y, and z).
 117 //     fVert3[]   == array for 3rd point (3 elements are x, y, and z).
 118 //
 119 // Returns:
 120 //     fNormalX   == X vector for the normal vector
 121 //     fNormalY   == Y vector for the normal vector
 122 //     fNormalZ   == Z vector for the normal vector
 123 //*************************************************************************
 124
 125 void
 126 CalculateVectorNormal (GLfloat fVert1[], GLfloat fVert2[],
 127                        GLfloat fVert3[], GLfloat *fNormalX,
 128                        GLfloat *fNormalY, GLfloat *fNormalZ)
 129 {
 130   GLfloat Qx = fVert2[0] - fVert1[0];
 131   GLfloat Qy = fVert2[1] - fVert1[1];
 132   GLfloat Qz = fVert2[2] - fVert1[2];
 133   GLfloat Px = fVert3[0] - fVert1[0];
 134   GLfloat Py = fVert3[1] - fVert1[1];
 135   GLfloat Pz = fVert3[2] - fVert1[2];
 136
 137   *fNormalX = Py*Qz - Pz*Qy;
 138   *fNormalY = Pz*Qx - Px*Qz;
 139   *fNormalZ = Px*Qy - Py*Qx;
 140
 141 }
 142
 143 void
 144 CalculateVectorNormal (GLdouble fVert1[], GLdouble fVert2[],
 145                        GLdouble fVert3[], GLdouble *fNormalX,
 146                        GLdouble *fNormalY, GLdouble *fNormalZ)
 147 {
 148   GLdouble Qx = fVert2[0] - fVert1[0];
 149   GLdouble Qy = fVert2[1] - fVert1[1];
 150   GLdouble Qz = fVert2[2] - fVert1[2];
 151   GLdouble Px = fVert3[0] - fVert1[0];
 152   GLdouble Py = fVert3[1] - fVert1[1];
 153   GLdouble Pz = fVert3[2] - fVert1[2];
 154
 155   *fNormalX = Py*Qz - Pz*Qy;
 156   *fNormalY = Pz*Qx - Px*Qz;
 157   *fNormalZ = Px*Qy - Py*Qx;
 158
 159 }
 160
 161 IMPLEMENT_DYNAMIC_CLASS(Graph3dFileView, wxView)
 162
 163 BEGIN_EVENT_TABLE(Graph3dFileView, wxView)
 164 EVT_MENU(IFMENU_FILE_PROPERTIES, Graph3dFileView::OnProperties)
 165 EVT_MENU(GRAPH3D_VIEW_LIGHTING, Graph3dFileView::OnLighting)
 166 EVT_MENU(GRAPH3D_VIEW_COLOR, Graph3dFileView::OnColor)
 167 EVT_MENU(GRAPH3D_VIEW_SMOOTH, Graph3dFileView::OnSmooth)
 168 EVT_MENU(GRAPH3D_VIEW_SURFACE, Graph3dFileView::OnSurface)
 169 EVT_MENU(GRAPH3D_VIEW_SCALE_MINMAX, Graph3dFileView::OnScaleSet)
 170 EVT_MENU(GRAPH3D_VIEW_SCALE_AUTO, Graph3dFileView::OnScaleAuto)
 171 EVT_MENU(GRAPH3D_VIEW_SCALE_FULL, Graph3dFileView::OnScaleFull)
 172 END_EVENT_TABLE()
 173
 174 Graph3dFileView::Graph3dFileView ()
 175 : m_pFileMenu(NULL), m_pViewMenu(NULL)
 176 {
 177   m_bDoubleBuffer = true;
 178   m_bSmooth = true;
 179   m_bLighting = true;
 180   m_bSurface = true;
 181   m_bLighting = true;
 182   m_bColor = false;
 183   m_dXRotate = -45;
 184   m_dYRotate = 0;
 185   m_dZRotate = -45;
 186   m_bColorScaleMinSet = false;
 187   m_bColorScaleMaxSet = false;
 188 }
 189
 190 Graph3dFileView::~Graph3dFileView()
 191 {
 192   GetDocumentManager()->FileHistoryRemoveMenu (m_pFileMenu);
 193   GetDocumentManager()->ActivateView(this, false, true);
 194 }
 195
 196 bool
 197 Graph3dFileView::OnCreate (wxDocument *doc, long WXUNUSED(flags) )
 198 {
 199   m_pFrame = CreateChildFrame(doc, this);
 200   (m_pFrame);
 201
 202   int width, height;
 203   m_pFrame->GetClientSize (&width, &height);
 204   m_pFrame->SetTitle("Graph3dFileView");
 205   m_pCanvas = CreateCanvas (m_pFrame);
 206
 207   m_pFrame->Show (true);
 208   m_pCanvas->SetCurrent();
 209
 210   InitGL();
 211
 212   int x, y;  // X requires a forced resize
 213   m_pFrame->GetSize(&x, &y);
 214   m_pFrame->SetSize(-1, -1, x, y);
 215   m_pFrame->SetFocus();
 216   m_pFrame->Show(true);
 217   Activate(true);
 218
 219   m_pViewMenu->Check (GRAPH3D_VIEW_COLOR, m_bColor);
 220   m_pViewMenu->Check (GRAPH3D_VIEW_LIGHTING, m_bLighting);
 221   m_pViewMenu->Check (GRAPH3D_VIEW_SMOOTH, m_bSmooth);
 222   m_pViewMenu->Check (GRAPH3D_VIEW_SURFACE, m_bSurface);
 223   return true;
 224 }
 225
 226 Graph3dFileCanvas*
 227 Graph3dFileView::CreateCanvas (wxFrame* parent)
 228 {
 229   Graph3dFileCanvas* pCanvas;
 230   int width, height;
 231   parent->GetClientSize (&width, &height);
 232
 233 #ifdef __WXMSW__
 234   int *gl_attrib = NULL;
 235 #else
 236   int gl_attrib[20] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1,
 237     GLX_BLUE_SIZE, 1, GLX_DEPTH_SIZE, 1, GLX_DOUBLEBUFFER, None };
 238 #endif
 239
 240   if(! m_bDoubleBuffer) {
 241 #ifdef __WXGTK__
 242     gl_attrib[9] = None;
 243 #endif
 244   }
 245
 246   pCanvas = new Graph3dFileCanvas (this, parent, wxPoint(0, 0), wxSize(200, 200), 0, gl_attrib);
 247
 248   pCanvas->SetBackgroundColour(*wxWHITE);
 249   pCanvas->Clear();
 250
 251   return pCanvas;
 252 }
 253
 254
 255 void
 256 Graph3dFileView::DrawSurface()
 257 {
 258   if (m_bSmooth) {
 259     glShadeModel (GL_SMOOTH);
 260   } else {
 261     glShadeModel (GL_FLAT);
 262   }
 263
 264   if (m_bLighting) {
 265     glEnable (GL_LIGHTING);
 266   } else {
 267     glDisable (GL_LIGHTING);
 268   }
 269
 270   if (m_bSurface)
 271     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 272   else
 273     glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 274
 275   InitMaterials();
 276
 277   if (! GetDocument())
 278     return;
 279
 280   unsigned int nx = GetDocument()->nx();
 281   unsigned int ny = GetDocument()->ny();
 282   glRotated (m_dZRotate, 0.0, 1.0, 0.0);
 283   glTranslated (-static_cast<double>(nx) / 2, 0.0, -static_cast<double>(ny) / 2);
 284   glRotated (m_dYRotate, 1.0, 0.0, 0.0);
 285   glRotated (m_dXRotate, 0.0, 0.0, 1.0);
 286
 287   glCallList (DISPLAYLIST_SURFACE);
 288 }
 289
 290 void
 291 Graph3dFileView::CreateDisplayList()
 292 {
 293   if (! GetDocument())
 294     return;
 295
 296   unsigned int nx = GetDocument()->nx();
 297   unsigned int ny = GetDocument()->ny();
 298   const ImageFileArrayConst v = GetDocument()->getArray();
 299   if (nx == 0 || ny == 0 || ! v)
 300     return;
 301
 302   glNewList (DISPLAYLIST_SURFACE, GL_COMPILE);
 303
 304   double dMin = m_dColorScaleMin;
 305   double dIntensityScale = m_dColorScaleMax - m_dColorScaleMin;
 306   double actOffset = m_dGraphMin;
 307   double actScale = 0.4 * sqrt(nx*nx+ny*ny) / (m_dGraphMax - m_dGraphMin);
 308
 309   if (! m_bColor)
 310     glColor3f (1.0f, 1.0f, 1.0f);
 311
 312   for (unsigned ix = 0; ix < nx - 1; ix++) {
 313     glBegin(GL_QUAD_STRIP);
 314     double p1[3], p2[3], p3[3];
 315     double n1[3];
 316     p1[0] = ix;  p1[1] = actScale * (v[ix][0] + actOffset); p1[2] = 0;
 317     p2[0] = ix+1; p2[1] = actScale * (v[ix+1][0] + actOffset); p2[2] = 0;
 318     p3[0] = ix; p3[1] = actScale * (v[ix][1] + actOffset); p3[2] = 1;
 319     CalculateVectorNormal (p1, p2, p3, &n1[0], &n1[1], &n1[2]);
 320     double dIntensity1, dIntensity2;
 321     if (m_bColor) {
 322       dIntensity1 = (v[ix][0] - dMin) / dIntensityScale;
 323       dIntensity2 = (v[ix+1][0] - dMin) / dIntensityScale;
 324     }
 325     float vecColor[3];
 326     if (m_bColor) {
 327       intensityToColor (dIntensity1, vecColor);
 328       glColor3fv (vecColor);
 329     }
 330     glVertex3dv (p1);
 331     glNormal3dv (n1);
 332     if (m_bColor) {
 333       intensityToColor (dIntensity2, vecColor);
 334       glColor3fv (vecColor);
 335     }
 336     glVertex3dv (p2);
 337     glNormal3dv (n1);
 338     double lastP[3];
 339     lastP[0] = ix; lastP[1] = actScale * (v[ix][0] + actOffset); lastP[2] = 0;
 340     for (unsigned int iy = 1; iy < ny - 1; iy++) {
 341       p1[0] = ix; p1[1] = actScale * (v[ix][iy] + actOffset); p1[2] = iy;
 342       p2[0] = ix+1;  p2[1] = actScale * (v[ix+1][iy] + actOffset); p2[2] = iy;
 343       CalculateVectorNormal (p1, p2, lastP, &n1[0], &n1[1], &n1[2]);
 344       lastP[0] = p1[0]; lastP[1] = p1[1]; lastP[2] = p1[2];
 345       if (m_bColor) {
 346         dIntensity1 = (v[ix][iy] - dMin) / dIntensityScale;
 347         dIntensity2 = (v[ix+1][iy] - dMin) / dIntensityScale;
 348       }
 349       if (m_bColor) {
 350         intensityToColor (dIntensity1, vecColor);
 351         glColor3fv (vecColor);
 352       }
 353       glVertex3dv (p1); glNormal3dv (n1);
 354       if (m_bColor) {
 355         intensityToColor (dIntensity2, vecColor);
 356         glColor3fv (vecColor);
 357       }
 358       glVertex3dv (p2); glNormal3dv (n1);
 359     }
 360     glEnd(); // QUAD_STRIP
 361   }
 362   glEndList();
 363 }
 364
 365
 366 void
 367 Graph3dFileView::OnProperties (wxCommandEvent& event)
 368 {
 369   std::ostringstream os;
 370   *theApp->getLog() << ">>>>\n" << os.str().c_str() << "<<<<\n";
 371   wxMessageDialog dialogMsg (getFrameForChild(), os.str().c_str(), "Imagefile Properties", wxOK | wxICON_INFORMATION);
 372   dialogMsg.ShowModal();
 373 }
 374
 375 void
 376 Graph3dFileView::OnLighting (wxCommandEvent& event)
 377 {
 378   m_bLighting = ! m_bLighting;
 379   m_pViewMenu->Check (GRAPH3D_VIEW_LIGHTING, m_bLighting);
 380
 381   m_pCanvas->Refresh();
 382 }
 383
 384 void
 385 Graph3dFileView::OnSurface (wxCommandEvent& event)
 386 {
 387   m_bSurface = ! m_bSurface;
 388   m_pViewMenu->Check (GRAPH3D_VIEW_SURFACE, m_bSurface);
 389   m_pCanvas->Refresh();
 390 }
 391
 392 void
 393 Graph3dFileView::OnColor (wxCommandEvent& event)
 394 {
 395   m_bColor = ! m_bColor;
 396   m_pViewMenu->Check (GRAPH3D_VIEW_COLOR, m_bColor);
 397   OnUpdate (this, NULL);
 398 }
 399
 400 void
 401 Graph3dFileView::OnSmooth (wxCommandEvent& event)
 402 {
 403   m_bSmooth = ! m_bSmooth;
 404   m_pViewMenu->Check (GRAPH3D_VIEW_SMOOTH, m_bSmooth);
 405   m_pCanvas->Refresh();
 406 }
 407
 408
 409
 410 void
 411 Graph3dFileView::OnDraw (wxDC* dc)
 412 {
 413 #ifndef __WXMOTIF__
 414   if (! m_pCanvas->GetContext()) return;
 415 #endif
 416
 417   m_pCanvas->SwapBuffers();
 418   Draw();
 419   std::ostringstream os;
 420   os << "Xangle=" << m_dXRotate << ", Yangle=" << m_dYRotate << ", Zangle=" << m_dZRotate;
 421   m_pStatusBar->SetStatusText (os.str().c_str());
 422   m_pCanvas->SwapBuffers();
 423 }
 424
 425
 426 void
 427 Graph3dFileView::Draw ()
 428 {
 429   glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 430   glPushMatrix();
 431   DrawSurface();
 432   glPopMatrix();
 433   glFlush();
 434 }
 435
 436
 437 void
 438 Graph3dFileView::InitMaterials()
 439 {
 440   if (! GetDocument())
 441     return;
 442   int nx = GetDocument()->nx();
 443   int ny = GetDocument()->ny();
 444
 445 #if 1
 446   static float ambient[] = {0.1f, 0.1f, 0.1f, 1.0f};
 447   static float diffuse[] = {1.0f, 1.0f, 1.0f, 1.0f};
 448   static float position0[] = {-nx/2, -ny/2, -ny/2, 0.0f, 0.0f};
 449   static float position1[] = {-nx/2, -ny/2, ny/2, 0.0f};
 450   static float ambient1[] = {0.5f, 0.5f, 0.5f, 1.0f};
 451   static float diffuse1[] = {1.0f, 1.0f, 1.0f, 1.0f};
 452   //  static float position0[] = {0.0f, 0.0f, 20.0f, 0.0f};
 453   //  static float position1[] = {0.0f, 0.0f, -20.0f, 0.0f};
 454   static float front_mat_shininess[] = {5.0f};
 455   static float front_mat_specular[] = {0.1f, 0.1f, 0.1f, 1.0f};
 456   static float front_mat_diffuse[] = {0.3f, 0.3f, 0.3f, 1.0f};
 457   /*
 458   static float back_mat_shininess[] = {60.0f};
 459   static float back_mat_specular[] = {0.2f, 0.2f, 0.2f, 1.0f};
 460   static float back_mat_diffuse[] = {1.0f, 1.0f, 1.0f, 1.0f};
 461   */
 462   static float lmodel_ambient[] = {1.0f, 1.0f, 1.0f, 1.0f};
 463   static float lmodel_twoside[] = {GL_FALSE};
 464
 465   glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
 466   glHint(GL_LINE_SMOOTH, GL_DONT_CARE);
 467   glEnable(GL_NORMALIZE);
 468
 469   glLightfv (GL_LIGHT0, GL_AMBIENT, ambient);
 470   glLightfv (GL_LIGHT0, GL_DIFFUSE, diffuse);
 471   glLightfv (GL_LIGHT0, GL_POSITION, position0);
 472   glEnable (GL_LIGHT0);
 473
 474   glLightfv (GL_LIGHT1, GL_AMBIENT, ambient1);
 475   glLightfv (GL_LIGHT1, GL_DIFFUSE, diffuse1);
 476   glLightfv (GL_LIGHT1, GL_POSITION, position1);
 477   glEnable (GL_LIGHT1);
 478
 479   glLightModelfv (GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
 480   glLightModelfv (GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
 481
 482   glMaterialfv (GL_FRONT_AND_BACK, GL_SHININESS, front_mat_shininess);
 483   glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, front_mat_specular);
 484   glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, front_mat_diffuse);
 485
 486   glColorMaterial (GL_FRONT_AND_BACK, GL_DIFFUSE);
 487   //  glColorMaterial (GL_FRONT_AND_BACK, GL_SPECULAR);
 488   glEnable(GL_COLOR_MATERIAL);
 489 #else
 490   GLfloat impLPos[]  = {1.0f, 1.0f, 1.0f, 0.0f};
 491
 492   GLfloat defaultLightAmb   [] = {.2f, .2f, .2f, 1.0f};
 493   GLfloat defaultLightDiff  [] = {.2f, .2f, .2f, 1.0f};
 494   GLfloat defaultLightSpec  [] = { .3f, .3f, .3f, 1.0f};
 495
 496   GLfloat defaultGlobalAmb [] = {.3f, .3f, .3f, 1.0f};
 497   GLfloat defaultGlobalDiff[] = {.3f, .3f, .3f, 1.0f};
 498
 499   GLfloat defaultMatShine[] = {  30.0f };
 500   GLfloat defaultMatSpec[]  = { .4f, .4f, .4f, 1.0f};
 501   GLfloat defaultMatAmb[]   = { .3f, .3f, .3f, 1.0f};
 502   GLfloat defaultMatDiff[]  = { .5f, .5f, .5f, 1.0f};
 503
 504   GLfloat brassMatAmb[]   = { .33f, .22f, .03f, 1.0f};
 505   GLfloat brassMatDiff[]  = { .78f, .57f, .11f, 1.0f};
 506   GLfloat brassMatSpec[]  = { .99f, .91f, .81f, 1.0f};
 507   GLfloat brassMatShine[] = {  27.8f };
 508
 509   GLfloat emeraldMatAmb[]   = { .02f1, .1745f , .021f, 1.0f };
 510   GLfloat emeraldMatDiff[]  = { .075f, .6142f , .075f, 1.0f };
 511   GLfloat emeraldMatSpec[]  = { .633f, .7278f , .633f, 1.0f };
 512   GLfloat emeraldMatShine[] = {  76.8f };
 513
 514   GLfloat slateMatAmb[]   = { .02f, .02f , .02f, 1.0f };
 515   GLfloat slateMatDiff[]  = { .02f, .01f , .01f, 1.0f };
 516   GLfloat slateMatSpec[]  = { .4f,  .4f ,  .4f , 1.0f };
 517   GLfloat slateMatShine[] = { .768f };
 518
 519   //       double opnX = nx, opnY = ny, opnZ = z;
 520   //       eyeX = 1; eyeY = 1, eyeZ = 1;
 521
 522   impLPos[0] = nx/2.; impLPos[1]= ny/2.; impLPos[2] = 0.;
 523   //opnListNum = 1;
 524   //impGraphicsFlag = IMP__3D;
 525
 526   //       glutInitDisplayMode (GLUT_DOUBLE| GLUT_RGB | GLUT_DEPTH | GLUT_ACCUM);
 527   //       glutInitWindowSize (IMP_WIN_X, IMP_WIN_Y);
 528   //  glutInitWindowPosition (100, 100);
 529   //       glutCreateWindow ("- imp3D graphics -" );
 530
 531   glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
 532
 533   glShadeModel (GL_SMOOTH);
 534   glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
 535   glHint(GL_LINE_SMOOTH, GL_DONT_CARE);
 536   glEnable(GL_NORMALIZE);
 537
 538
 539   glEnable(GL_DEPTH_TEST);
 540
 541   glLightfv(GL_LIGHT0, GL_AMBIENT, defaultLightAmb);
 542   glLightfv(GL_LIGHT0, GL_DIFFUSE, defaultLightDiff);
 543   glLightfv(GL_LIGHT0, GL_SPECULAR,defaultLightSpec);
 544
 545   glLightfv(GL_LIGHT1, GL_AMBIENT, defaultLightAmb);
 546   glLightfv(GL_LIGHT1, GL_DIFFUSE, defaultLightDiff);
 547   glLightfv(GL_LIGHT1, GL_SPECULAR,defaultLightSpec);
 548
 549   glLightfv(GL_LIGHT2, GL_AMBIENT , defaultLightAmb);
 550   glLightfv(GL_LIGHT2, GL_DIFFUSE , defaultLightDiff);
 551   glLightfv(GL_LIGHT2, GL_SPECULAR, defaultLightSpec);
 552
 553   glLightfv(GL_LIGHT0, GL_POSITION,impLPos);
 554   glLightfv(GL_LIGHT1, GL_POSITION,impLPos);
 555   glLightfv(GL_LIGHT2, GL_POSITION,impLPos);
 556
 557   glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT  , defaultMatAmb);
 558   glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE  , defaultMatDiff);
 559   glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR , defaultMatSpec);
 560   glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, defaultMatShine);
 561
 562   glLightModelfv(GL_LIGHT_MODEL_AMBIENT, defaultGlobalAmb);
 563
 564   glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
 565
 566   glEnable(GL_COLOR_MATERIAL);
 567
 568   glEnable(GL_LIGHTING);
 569   glEnable(GL_LIGHT1);
 570   glEnable(GL_LIGHT2);
 571   glEnable(GL_LIGHT0);
 572 #endif
 573
 574 }
 575
 576
 577 void
 578 Graph3dFileView::InitGL ()
 579 {
 580   glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
 581
 582   glDisable (GL_CULL_FACE);
 583   glEnable (GL_DEPTH_TEST);
 584
 585 }
 586
 587 void
 588 Graph3dFileView::OnUpdate (wxView *WXUNUSED(sender), wxObject *WXUNUSED(hint) )
 589 {
 590   if (! GetDocument())
 591     return;
 592
 593   int nx = GetDocument()->nx();
 594   int ny = GetDocument()->ny();
 595   const ImageFileArrayConst v = GetDocument()->getArray();
 596   if (v != NULL && nx != 0 && ny != 0) {
 597     double min = v[0][0];
 598     double max = min;
 599     for (unsigned int ix = 0; ix < nx; ix++)
 600       for (unsigned int iy = 0; iy < ny; iy++) {
 601         double dVal = v[ix][iy];
 602         if (min > dVal)
 603           min = dVal;
 604         else if (max < dVal)
 605           max = dVal;
 606       }
 607       m_dGraphMin = min;
 608       m_dGraphMax = max;
 609       if (! m_bColorScaleMinSet)
 610         m_dColorScaleMin = min;
 611       if (! m_bColorScaleMaxSet)
 612         m_dColorScaleMax = max;
 613   }
 614
 615   double dRadius = maxValue<int> (nx, ny) * SQRT2 / 2;
 616   glMatrixMode(GL_PROJECTION);
 617   glLoadIdentity();
 618   glOrtho (-dRadius, dRadius, -dRadius, dRadius, dRadius*5, -dRadius*5);
 619
 620   glMatrixMode(GL_MODELVIEW);
 621   glLoadIdentity();
 622 #if 1
 623   GLfloat eyep[3], lookp[3], up[3];
 624   eyep[0] = -nx/2; eyep[1] = 0; eyep[2] = -ny/2;
 625   lookp[0] = 0; lookp[1] = 0, lookp[2] = 0;
 626   up[0] = 0; up[1] = 1; up[2] = 0;
 627   gluLookAt (eyep[0], eyep[1], eyep[2], lookp[0], lookp[1], lookp[2], up[0], up[1], up[2]);
 628 #endif
 629
 630   CreateDisplayList();
 631
 632   if (m_pCanvas)
 633     m_pCanvas->Refresh();
 634 }
 635
 636 bool
 637 Graph3dFileView::OnClose (bool deleteWindow)
 638 {
 639   if (! GetDocument() || ! GetDocument()->Close())
 640     return false;
 641
 642   Activate (false);
 643   if (m_pCanvas) {
 644     m_pCanvas->setView(NULL);
 645     m_pCanvas = NULL;
 646   }
 647   wxString s(theApp->GetAppName());
 648   if (m_pFrame)
 649     m_pFrame->SetTitle(s);
 650
 651   SetFrame(NULL);
 652
 653   if (deleteWindow) {
 654     delete m_pFrame;
 655     m_pFrame = NULL;
 656   }
 657
 658   return true;
 659 }
 660
 661 void
 662 Graph3dFileView::OnScaleAuto (wxCommandEvent& event)
 663 {
 664 #if 0
 665   const ImageFile& rIF = GetDocument()->getImageFile();
 666   double min, max, mean, mode, median, stddev;
 667   rIF.statistics(min, max, mean, mode, median, stddev);
 668   DialogAutoScaleParameters dialogAutoScale (getFrameForChild(), mean, mode, median, stddev, m_dAutoScaleFactor);
 669   int iRetVal = dialogAutoScale.ShowModal();
 670   if (iRetVal == wxID_OK) {
 671     m_bMinSpecified = true;
 672     m_bMaxSpecified = true;
 673     double dMin, dMax;
 674     if (dialogAutoScale.getMinMax (&dMin, &dMax)) {
 675       m_dMinPixel = dMin;
 676       m_dMaxPixel = dMax;
 677       m_dAutoScaleFactor = dialogAutoScale.getAutoScaleFactor();
 678       OnUpdate (this, NULL);
 679     }
 680   }
 681 #endif
 682 }
 683
 684 void
 685 Graph3dFileView::OnScaleSet (wxCommandEvent& event)
 686 {
 687   if (! GetDocument())
 688     return;
 689
 690   unsigned int nx = GetDocument()->nx();
 691   unsigned int ny = GetDocument()->ny();
 692   const ImageFileArrayConst v = GetDocument()->getArray();
 693   double dMin, dMax;
 694   if (! m_bColorScaleMinSet && ! m_bColorScaleMaxSet) {
 695     dMax = dMin = v[0][0];
 696     for (unsigned ix = 0; ix < nx; ix++)
 697       for (unsigned int iy = 0; iy < ny; iy++)
 698         if (v[ix][iy] < dMin)
 699           dMin = v[ix][iy];
 700         else if (v[ix][iy] > dMax)
 701           dMax = v[ix][iy];
 702   }
 703   if (m_bColorScaleMinSet)
 704     dMin = m_dColorScaleMin;
 705   if (m_bColorScaleMaxSet)
 706     dMax = m_dColorScaleMax;
 707
 708   DialogGetMinMax dialogMinMax (getFrameForChild(), "Set Color Scale Minimum & Maximum", dMin, dMax);
 709   int retVal = dialogMinMax.ShowModal();
 710   if (retVal == wxID_OK) {
 711     m_bColorScaleMinSet = true;
 712     m_bColorScaleMaxSet = true;
 713     m_dColorScaleMin = dialogMinMax.getMinimum();
 714     m_dColorScaleMax = dialogMinMax.getMaximum();
 715     OnUpdate (this, NULL);
 716   }
 717 }
 718
 719 void
 720 Graph3dFileView::OnScaleFull (wxCommandEvent& event)
 721 {
 722   if (m_bColorScaleMinSet || m_bColorScaleMaxSet) {
 723     m_bColorScaleMinSet = false;
 724     m_bColorScaleMaxSet = false;
 725     OnUpdate (this, NULL);
 726   }
 727 }
 728
 729 #if CTSIM_MDI
 730 wxDocMDIChildFrame*
 731 #else
 732 wxDocChildFrame*
 733 #endif
 734 Graph3dFileView::CreateChildFrame (wxDocument *doc, wxView *view)
 735 {
 736 #if CTSIM_MDI
 737   wxDocMDIChildFrame* subframe = new wxDocMDIChildFrame (doc, view, theApp->getMainFrame(), -1, "Graph3dFile Frame", wxPoint(-1, -1), wxSize(0, 0), wxDEFAULT_FRAME_STYLE);
 738 #else
 739   wxDocChildFrame* subframe = new wxDocChildFrame (doc, view, theApp->getMainFrame(), -1, "Graph3dFile Frame", wxPoint(-1, -1), wxSize(0, 0), wxDEFAULT_FRAME_STYLE);
 740 #endif
 741   theApp->setIconForFrame (subframe);
 742
 743   m_pStatusBar = new wxStatusBar (subframe, -1);
 744   subframe->SetStatusBar (m_pStatusBar);
 745
 746   m_pFileMenu = new wxMenu;
 747
 748   m_pFileMenu->Append(MAINMENU_FILE_CREATE_PHANTOM, "Cr&eate Phantom...\tCtrl-P");
 749   m_pFileMenu->Append(MAINMENU_FILE_CREATE_FILTER, "Create &Filter...\tCtrl-F");
 750   m_pFileMenu->Append(wxID_OPEN, "&Open...\tCtrl-O");
 751   m_pFileMenu->Append(wxID_CLOSE, "&Close\tCtrl-W");
 752
 753   m_pFileMenu->AppendSeparator();
 754   m_pFileMenu->Append(IFMENU_FILE_PROPERTIES, "P&roperties");
 755
 756   m_pFileMenu->AppendSeparator();
 757   m_pFileMenu->Append(wxID_PRINT, "&Print...");
 758   m_pFileMenu->Append(wxID_PRINT_SETUP, "Print &Setup...");
 759   m_pFileMenu->Append(wxID_PREVIEW, "Print Preview");
 760 #ifdef CTSIM_MDI
 761   m_pFileMenu->AppendSeparator();
 762   m_pFileMenu->Append(MAINMENU_FILE_EXIT, "E&xit");
 763 #endif
 764   GetDocumentManager()->FileHistoryAddFilesToMenu(m_pFileMenu);
 765   GetDocumentManager()->FileHistoryUseMenu(m_pFileMenu);
 766
 767   m_pViewMenu = new wxMenu;
 768   m_pViewMenu->Append(GRAPH3D_VIEW_SURFACE, "Su&rface\tCtrl-R", "", true);
 769   m_pViewMenu->Append(GRAPH3D_VIEW_SMOOTH, "S&mooth\tCtrl-M", "", true);
 770   m_pViewMenu->Append(GRAPH3D_VIEW_COLOR, "Co&lor\tCtrl-L", "", true);
 771   m_pViewMenu->Append(GRAPH3D_VIEW_LIGHTING, "Li&ghting\tCtrl-G", "", true);
 772   m_pViewMenu->AppendSeparator();
 773   m_pViewMenu->Append(GRAPH3D_VIEW_SCALE_MINMAX, "Color Scale S&et Min/Max...\tCtrl-E");
 774   m_pViewMenu->Append(GRAPH3D_VIEW_SCALE_AUTO, "Color Scale &Auto...\tCtrl-A");
 775   m_pViewMenu->Append(GRAPH3D_VIEW_SCALE_FULL, "Color F&ull Scale\tCtrl-U");
 776
 777
 778   wxMenu *help_menu = new wxMenu;
 779   help_menu->Append(MAINMENU_HELP_CONTENTS, "&Contents\tF1");
 780   help_menu->Append(MAINMENU_HELP_TOPICS, "&Topics\tCtrl-H");
 781   help_menu->Append(MAINMENU_HELP_ABOUT, "&About");
 782
 783   wxMenuBar *menu_bar = new wxMenuBar;
 784
 785   menu_bar->Append(m_pFileMenu, "&File");
 786   menu_bar->Append(m_pViewMenu, "&View");
 787   menu_bar->Append(help_menu, "&Help");
 788
 789   subframe->SetMenuBar(menu_bar);
 790
 791   subframe->Centre(wxBOTH);
 792
 793   wxAcceleratorEntry accelEntries[12];
 794   accelEntries[0].Set (wxACCEL_CTRL, static_cast<int>('O'), wxID_OPEN);
 795   accelEntries[1].Set (wxACCEL_CTRL, static_cast<int>('H'), MAINMENU_HELP_TOPICS);
 796   accelEntries[2].Set (wxACCEL_CTRL, static_cast<int>('P'), MAINMENU_FILE_CREATE_PHANTOM);
 797   accelEntries[3].Set (wxACCEL_CTRL, static_cast<int>('F'), MAINMENU_FILE_CREATE_FILTER);
 798   accelEntries[4].Set (wxACCEL_NORMAL, WXK_F1, MAINMENU_HELP_CONTENTS);
 799   accelEntries[5].Set (wxACCEL_CTRL, static_cast<int>('R'), GRAPH3D_VIEW_SURFACE);
 800   accelEntries[6].Set (wxACCEL_CTRL, static_cast<int>('L'), GRAPH3D_VIEW_COLOR);
 801   accelEntries[7].Set (wxACCEL_CTRL, static_cast<int>('G'), GRAPH3D_VIEW_LIGHTING);
 802   accelEntries[8].Set (wxACCEL_CTRL, static_cast<int>('M'), GRAPH3D_VIEW_SMOOTH);
 803   accelEntries[9].Set (wxACCEL_CTRL, static_cast<int>('E'), GRAPH3D_VIEW_SCALE_MINMAX);
 804   accelEntries[10].Set (wxACCEL_CTRL, static_cast<int>('A'), GRAPH3D_VIEW_SCALE_AUTO);
 805   accelEntries[11].Set (wxACCEL_CTRL, static_cast<int>('U'), GRAPH3D_VIEW_SCALE_FULL);
 806   wxAcceleratorTable accelTable (12, accelEntries);
 807   subframe->SetAcceleratorTable (accelTable);
 808
 809   return subframe;
 810 }
 811
 812
 813
 814 BEGIN_EVENT_TABLE(Graph3dFileCanvas, wxGLCanvas)
 815 EVT_SIZE(Graph3dFileCanvas::OnSize)
 816 EVT_PAINT(Graph3dFileCanvas::OnPaint)
 817 EVT_CHAR(Graph3dFileCanvas::OnChar)
 818 EVT_MOUSE_EVENTS(Graph3dFileCanvas::OnMouseEvent)
 819 EVT_ERASE_BACKGROUND(Graph3dFileCanvas::OnEraseBackground)
 820 END_EVENT_TABLE()
 821
 822
 823
 824
 825 Graph3dFileCanvas::Graph3dFileCanvas (Graph3dFileView* view, wxWindow *parent, const wxPoint& pos,
 826                                       const wxSize& size, long style, int* gl_attrib):
 827 wxGLCanvas (parent, -1, pos, size, style, _T("Graph3dCanvas"), gl_attrib), m_pView(view)
 828 {
 829   parent->Show (true);
 830   SetCurrent();
 831 #if 0
 832   // Make sure server supports the vertex array extension
 833   char* extensions = (char *) glGetString( GL_EXTENSIONS );
 834   if (!extensions || !strstr( extensions, "GL_EXT_vertex_array" )) {
 835     m_pView->m_bUseVertexArrays = GL_FALSE;
 836   }
 837 #endif
 838 }
 839
 840
 841 Graph3dFileCanvas::~Graph3dFileCanvas()
 842 {
 843 }
 844
 845 void
 846 Graph3dFileCanvas::OnDraw (wxDC& dc)
 847 {
 848   if (m_pView)
 849     m_pView->OnDraw(& dc);
 850 }
 851
 852 void
 853 Graph3dFileCanvas::OnSize (wxSizeEvent& event)
 854 {
 855 #ifndef __WXMOTIF__
 856   if (!GetContext()) return;
 857 #endif
 858
 859   SetCurrent();
 860   int width, height;
 861   GetClientSize (&width, &height);
 862   Reshape (width, height);
 863 }
 864
 865 void
 866 Graph3dFileCanvas::OnChar(wxKeyEvent& event)
 867 {
 868   if (! m_pView)
 869     return;
 870
 871   wxCommandEvent dummyEvent;
 872   switch (event.KeyCode()) {
 873   case WXK_LEFT:
 874         m_pView->m_dZRotate += 15.0;
 875     Refresh (false);
 876     break;
 877   case WXK_RIGHT:
 878     m_pView->m_dZRotate -= 15.0;
 879     Refresh (false);
 880     break;
 881   case WXK_UP:
 882     m_pView->m_dXRotate += 15.0;
 883     Refresh (false);
 884     break;
 885   case WXK_DOWN:
 886     m_pView->m_dXRotate -= 15.0;
 887     Refresh (false);
 888     break;
 889   case 'y': case 'Y':
 890     m_pView->m_dYRotate += 15.0;
 891     Refresh (false);
 892     break;
 893   case 't': case 'T':
 894     m_pView->m_dYRotate -= 15.0;
 895     Refresh (false);
 896     break;
 897   case 'r': case 'R':
 898     m_pView->OnSurface (dummyEvent);
 899     break;
 900   case 's': case 'S':
 901     m_pView->OnSmooth (dummyEvent);
 902     break;
 903   case 'l': case 'L':
 904     m_pView->OnLighting (dummyEvent);
 905     break;
 906   case 'c': case 'C':
 907     m_pView->OnColor (dummyEvent);
 908     break;
 909   default:
 910     event.Skip();
 911     return;
 912   }
 913 }
 914
 915 void
 916 Graph3dFileCanvas::Reshape (int width, int height)
 917 {
 918   glViewport (0, 0, (GLint)width, (GLint)height);
 919 }
 920
 921
 922 void
 923 Graph3dFileCanvas::OnMouseEvent(wxMouseEvent& event)
 924 {
 925   static int dragging = 0;
 926   static float last_x, last_y;
 927
 928   if (! m_pView)
 929     return;
 930
 931   if(event.LeftIsDown()) {
 932     if(! dragging) {
 933       dragging = 1;
 934     } else {
 935       m_pView->m_dXRotate -= (event.GetY() - last_y)*1.0;
 936       m_pView->m_dZRotate += (event.GetX() - last_x)*1.0;
 937       Refresh (false);
 938     }
 939     last_x = event.GetX();
 940     last_y = event.GetY();
 941   } else
 942     dragging = 0;
 943 }
 944
 945 void
 946 Graph3dFileCanvas::OnEraseBackground(wxEraseEvent& event)
 947 {
 948   // Do nothing: avoid flashing.
 949 }
 950
 951
 952 #endif // wxUSE_GLCANVAS