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