Ignore:
Timestamp:
Mar 5, 2009, 5:37:00 PM (15 years ago)
Author:
garnier
Message:

print methods renaming. See History file

Location:
trunk/source/visualization/OpenGL
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/visualization/OpenGL/History

    r940 r941  
    1 $Id: History,v 1.128 2009/03/05 11:04:20 lgarnier Exp $
     1$Id: History,v 1.129 2009/03/05 16:36:13 lgarnier Exp $
    22-------------------------------------------------------------------
    33
    … …  
    2525   - Suppress some warnings when saving file
    2626   - Changing size is now allowed when saving (to save with better resolution than screen size)
    27  - G4OpenGLViewer: Some renaming for print methods to be more clear about Vectored and non Vectored
    28  - G4OpenGLViewer: Now using Gl2PS method to do PS (changes also in G4OpenGLXViewer and G4OpenGLQtViewer)
     27 - G4OpenGLViewer:
     28  - Some renaming for print methods to be more clear about Vectored and non Vectored
     29  - Now using Gl2PS method to do PS (changes also in G4OpenGLXViewer and G4OpenGLQtViewer)
     30  - Suppress unuseful printX methods (heritated form XViewer)
     31  - Add methods to handle printVectored and NonVector cases
     32 - G4OpenGLViewerMessanger : Changes methods to get new G4OpenGLViewer methods to print
    2933
    30341st March 2009, Laurent Garnier

  • trunk/source/visualization/OpenGL/include/G4OpenGLQtViewer.hh

    r938 r941  
    2525//
    2626//
    27 // $Id: G4OpenGLQtViewer.hh,v 1.15 2009/02/04 16:48:40 lgarnier Exp $
     27// $Id: G4OpenGLQtViewer.hh,v 1.16 2009/03/05 16:36:13 lgarnier Exp $
    2828// GEANT4 tag $Name:  $
    2929//

  • trunk/source/visualization/OpenGL/include/G4OpenGLViewer.hh

    r940 r941  
    2525//
    2626//
    27 // $Id: G4OpenGLViewer.hh,v 1.28 2009/03/05 11:04:20 lgarnier Exp $
     27// $Id: G4OpenGLViewer.hh,v 1.29 2009/03/05 16:36:13 lgarnier Exp $
    2828// GEANT4 tag $Name:  $
    2929//
    … …  
    6868  void Pick(GLdouble x, GLdouble y);
    6969  virtual void CreateFontLists () {}
    70   bool printVectoredEPS();
    7170  void rotateScene (G4double dx, G4double dy,G4double delta);
    7271//////////////////////////////Vectored PostScript production functions///
    … …  
    7473                       unsigned int width,
    7574                       unsigned int height);
    76   int printNonVectoredEPS (int inColour,
    77                            unsigned int width,
    78                            unsigned int height);
    79   bool printGl2PS(unsigned int width,
    80                        unsigned int height);
    81   void printBuffer(GLint, GLfloat*);
    82   GLfloat* spewPrimitiveEPS (FILE*, GLfloat*);
    83   void spewSortedFeedback (FILE*, GLint, GLfloat*);
    84   void spewWireframeEPS (FILE*, GLint, GLfloat*, const char*);
    85   void print3DcolorVertex(GLint, GLint*, GLfloat*);
     75  bool printNonVectoredEPS ();
     76  bool printVectoredEPS();
     77  void printEPS();
    8678  GLdouble getSceneNearWidth();
    8779  GLdouble getSceneFarWidth();
    … …  
    9082  G4bool                            fPrintColour;
    9183  G4bool                            fVectoredPs;
     84  G4int                             fPrintSizeX;
     85  G4int                             fPrintSizeY;
    9286
    9387  G4OpenGLSceneHandler& fOpenGLSceneHandler;
    … …  
    113107private :
    114108  G4float                           fPointSize;
     109  bool printGl2PS();
    115110};
    116111

  • trunk/source/visualization/OpenGL/src/G4OpenGLQtViewer.cc

    r940 r941  
    2525//
    2626//
    27 // $Id: G4OpenGLQtViewer.cc,v 1.37 2009/03/05 11:04:20 lgarnier Exp $
     27// $Id: G4OpenGLQtViewer.cc,v 1.38 2009/03/05 16:36:13 lgarnier Exp $
    2828// GEANT4 tag $Name:  $
    2929//
    … …  
    13241324    if ((exportDialog->getWidth() !=fWindow->width()) ||
    13251325        (exportDialog->getHeight() !=fWindow->height())) {
     1326      fPrintSizeX = exportDialog->getWidth();
     1327      fPrintSizeY = exportDialog->getHeight();
    13261328      if ((format != QString("eps")) && (format != QString("ps"))) {
    13271329      G4cerr << "Export->Change Size : This function is not implemented, to export in another size, please resize your frame to what you need" << G4endl;
    … …  
    13471349    }   
    13481350    if (format == QString("eps")) {
    1349       if (exportDialog->getVectorEPS()) {
    1350         res = printVectoredEPS();
    1351       } else {
    1352         res = printNonVectoredEPS(exportDialog->getNbColor(),(unsigned int)image.width(),(unsigned int)image.height());
    1353       }
     1351      fVectoredPs = exportDialog->getVectorEPS();
     1352      printEPS();
    13541353    } else if (format == "ps") {
    1355       if ((exportDialog->getWidth() !=fWindow->width()) ||
    1356           (exportDialog->getHeight() !=fWindow->height())) {
    1357         res = printGl2PS(exportDialog->getWidth(),exportDialog->getHeight());
    1358       } else {
    1359       res = printGl2PS(fWindow->width(),fWindow->height());
    1360       }
     1354      fVectoredPs = true;
     1355      printEPS();
    13611356    } else if (format == "pdf") {
    13621357
    … …  
    13821377      G4cerr << "This version of G4UI Could not generate the selected format" << G4endl;
    13831378    }
    1384     if (res == false) {
    1385       G4cerr << "Error while saving file... "<<fPrintFilename.c_str()<< G4endl;
    1386     } else {
    1387       G4cout << "File "<<fPrintFilename.c_str()<<" has been saved " << G4endl;
     1379    if ((format == QString("eps")) && (format == QString("ps"))) {
     1380      if (res == false) {
     1381        G4cerr << "Error while saving file... "<<fPrintFilename.c_str()<< G4endl;
     1382      } else {
     1383        G4cout << "File "<<fPrintFilename.c_str()<<" has been saved " << G4endl;
     1384      }
    13881385    }
    13891386   

  • trunk/source/visualization/OpenGL/src/G4OpenGLViewer.cc

    r940 r941  
    2525//
    2626//
    27 // $Id: G4OpenGLViewer.cc,v 1.49 2009/03/05 11:04:20 lgarnier Exp $
     27// $Id: G4OpenGLViewer.cc,v 1.50 2009/03/05 16:36:13 lgarnier Exp $
    2828// GEANT4 tag $Name:  $
    2929//
    … …  
    9090fPrintColour (true),
    9191fVectoredPs (true),
     92fPrintSizeX(0),
     93fPrintSizeY(0),
    9294fOpenGLSceneHandler(scene),
    9395background (G4Colour(0.,0.,0.)),
    … …  
    397399}
    398400
    399 bool G4OpenGLViewer::printVectoredEPS() {
    400 
    401   // Print vectored PostScript
    402  
    403   G4int size = 5000000;
    404   GLfloat* feedback_buffer = new GLfloat[size];
    405   glFeedbackBuffer (size, GL_3D_COLOR, feedback_buffer);
    406   glRenderMode (GL_FEEDBACK);
    407  
    408   DrawView();
    409 
    410   GLint returned;
    411   returned = glRenderMode (GL_RENDER);
    412  
    413   FILE* file;
    414   if (!fPrintFilename.empty()) {
    415     file = fopen (fPrintFilename.c_str(), "w");
    416     if (file) {
    417       spewWireframeEPS (file, returned, feedback_buffer, "rendereps");
    418       fclose(file);
    419     } else {
    420       G4cerr << "Could not open " <<fPrintFilename.c_str() <<" for writing"<< G4endl;
    421       return false;
    422     }
    423   } else {
    424     printBuffer (returned, feedback_buffer);
    425   }
    426 
    427   delete[] feedback_buffer;
    428   return true;
    429 }
    430 
    431 void G4OpenGLViewer::print3DcolorVertex(GLint size, GLint * count, GLfloat * buffer)
    432 {
    433   G4int i;
    434 
    435   printf("  ");
    436   for (i = 0; i < 7; i++) {
    437     printf("%4.2f ", buffer[size - (*count)]);
    438     *count = *count - 1;
    439   }
    440   printf("\n");
    441 }
    442 
    443 void G4OpenGLViewer::spewWireframeEPS (FILE* file, GLint size, GLfloat* buffer, const char* cr) {
    444 
    445   GLfloat EPS_GOURAUD_THRESHOLD=0.1;
    446 
    447   GLfloat clearColor[4], viewport[4];
    448   GLfloat lineWidth;
    449   G4int i;
    450 
    451   glGetFloatv (GL_VIEWPORT, viewport);
    452   glGetFloatv (GL_COLOR_CLEAR_VALUE, clearColor);
    453   glGetFloatv (GL_LINE_WIDTH, &lineWidth);
    454   glGetFloatv (GL_POINT_SIZE, &fPointSize);
    455 
    456   fputs ("%!PS-Adobe-2.0 EPSF-2.0\n", file);
    457   fprintf (file, "%%%%Creator: %s (using OpenGL feedback)\n", cr);
    458   fprintf (file, "%%%%BoundingBox: %g %g %g %g\n", viewport[0], viewport[1], viewport[2], viewport[3]);
    459   fputs ("%%EndComments\n", file);
    460   fputs ("\n", file);
    461   fputs ("gsave\n", file);
    462   fputs ("\n", file);
    463 
    464   fputs ("% the gouraudtriangle PostScript fragment below is free\n", file);
    465   fputs ("% written by Frederic Delhoume (delhoume@ilog.fr)\n", file);
    466   fprintf (file, "/threshold %g def\n", EPS_GOURAUD_THRESHOLD);
    467   for (i=0; gouraudtriangleEPS[i]; i++) {
    468     fprintf (file, "%s\n", gouraudtriangleEPS[i]);
    469   }
    470 
    471   fprintf(file, "\n%g setlinewidth\n", lineWidth);
    472  
    473   fprintf (file, "%g %g %g setrgbcolor\n", clearColor[0], clearColor[1], clearColor[2]);
    474   fprintf (file, "%g %g %g %g rectfill\n\n", viewport[0], viewport[1], viewport[2], viewport[3]);
    475 
    476   spewSortedFeedback (file, size, buffer);
    477 
    478   fputs ("grestore\n\n", file);
    479   fputs ("showpage\n", file);
    480 
    481   fclose(file);
    482 }
    483 
    484 void G4OpenGLViewer::printBuffer (GLint size, GLfloat* buffer) {
    485 
    486   GLint count;
    487   G4int token, nvertices;
    488 
    489   count=size;
    490   while(count) {
    491     token=G4int (buffer[size-count]);
    492     count--;
    493     switch (token) {
    494 
    495     case GL_PASS_THROUGH_TOKEN:
    496       printf ("GL_PASS_THROUGH_TOKEN\n");
    497       printf ("  %4.2f\n", buffer[size-count]);
    498       count--;
    499       break;
    500 
    501     case GL_POINT_TOKEN:
    502       printf ("GL_POINT_TOKEN\n");
    503       print3DcolorVertex (size, &count, buffer);
    504       break;
    505 
    506     case GL_LINE_TOKEN:
    507       printf ("GL_LINE_TOKEN\n");
    508       print3DcolorVertex (size, &count, buffer);
    509       print3DcolorVertex (size, &count, buffer);
    510       break;
    511      
    512     case GL_LINE_RESET_TOKEN:
    513       printf ("GL_LINE_RESET_TOKEN\n");
    514       print3DcolorVertex (size, &count, buffer);
    515       print3DcolorVertex (size, &count, buffer);
    516       break;
    517 
    518     case GL_POLYGON_TOKEN:
    519       printf ("GL_POLYGON_TOKEN\n");
    520       nvertices=G4int (buffer[size-count]);
    521       count--;
    522       for (; nvertices>0; nvertices--) {
    523         print3DcolorVertex (size, &count, buffer);
    524       }
    525     }
    526   }
    527 }
    528 
    529 G4float* G4OpenGLViewer::spewPrimitiveEPS (FILE* file, GLfloat* loc) {
    530  
    531   G4int token;
    532   G4int nvertices, i;
    533   GLfloat red, green, blue, intensity;
    534   G4int smooth;
    535   GLfloat dx, dy, dr, dg, db, absR, absG, absB, colormax;
    536   G4int steps;
    537   Feedback3Dcolor *vertex;
    538   GLfloat xstep(0.), ystep(0.), rstep(0.), gstep(0.), bstep(0.);
    539   GLfloat xnext(0.), ynext(0.), rnext(0.), gnext(0.), bnext(0.), distance(0.);
    540 
    541   token=G4int (*loc);
    542   loc++;
    543   switch (token) {
    544   case GL_LINE_RESET_TOKEN:
    545   case GL_LINE_TOKEN:
    546     vertex=(Feedback3Dcolor*)loc;
    547     dr=vertex[1].red - vertex[0].red;
    548     dg=vertex[1].green - vertex[0].green;
    549     db=vertex[1].blue - vertex[0].blue;
    550 
    551     if (!fPrintColour) {
    552       dr+=(dg+db);
    553       dr/=3.0;
    554       dg=dr;
    555       db=dr;
    556     }
    557 
    558     if (dr!=0 || dg!=0 || db!=0) {
    559       dx=vertex[1].x - vertex[0].x;
    560       dy=vertex[1].y - vertex[0].y;
    561       distance=std::sqrt(dx*dx + dy*dy);
    562 
    563       absR=std::fabs(dr);
    564       absG=std::fabs(dg);
    565       absB=std::fabs(db);
    566 
    567       #define Max(a, b) (((a)>(b))?(a):(b))
    568 
    569       #define EPS_SMOOTH_LINE_FACTOR 0.06
    570 
    571       colormax=Max(absR, Max(absG, absB));
    572       steps=Max(1, G4int (colormax*distance*EPS_SMOOTH_LINE_FACTOR));
    573      
    574       xstep=dx/steps;
    575       ystep=dy/steps;
    576 
    577       rstep=dr/steps;
    578       gstep=dg/steps;
    579       bstep=db/steps;
    580 
    581       xnext=vertex[0].x;
    582       ynext=vertex[0].y;
    583       rnext=vertex[0].red;
    584       gnext=vertex[0].green;
    585       bnext=vertex[0].blue;
    586 
    587       if (!fPrintColour) {
    588         rnext+=(gnext+bnext);
    589         rnext/=3.0;
    590         gnext=rnext;
    591         bnext=rnext;
    592       }
    593 
    594       xnext -= xstep/2.0;
    595       ynext -= ystep/2.0;
    596       rnext -= rstep/2.0;
    597       gnext -= gstep/2.0;
    598       bnext -= bstep/2.0;
    599     } else {
    600       steps=0;
    601     }
    602     if (fPrintColour) {
    603       fprintf (file, "%g %g %g setrgbcolor\n",
    604                vertex[0].red, vertex[0].green, vertex[0].blue);
    605     } else {
    606       intensity = (vertex[0].red + vertex[0].green + vertex[0].blue) / 3.0;
    607       fprintf (file, "%g %g %g setrgbcolor\n",
    608                intensity, intensity, intensity);
    609     }     
    610     fprintf (file, "%g %g moveto\n", vertex[0].x, vertex[0].y);
    611 
    612     for (i=0; i<steps; i++) {
    613 
    614       xnext += xstep;
    615       ynext += ystep;
    616       rnext += rstep;
    617       gnext += gstep;
    618       bnext += bstep;
    619 
    620       fprintf (file, "%g %g lineto stroke\n", xnext, ynext);
    621       fprintf (file, "%g %g %g setrgbcolor\n", rnext, gnext, bnext);
    622       fprintf (file, "%g %g moveto\n", xnext, ynext);
    623     }
    624     fprintf (file, "%g %g lineto stroke\n", vertex[1].x, vertex[1].y);
    625 
    626     loc += 14;
    627     break;
    628 
    629   case GL_POLYGON_TOKEN:
    630     nvertices = G4int (*loc);
    631     loc++;
    632     vertex=(Feedback3Dcolor*)loc;
    633     if (nvertices>0) {
    634       red=vertex[0].red;
    635       green=vertex[0].green;
    636       blue=vertex[0].blue;
    637       smooth=0;
    638      
    639       if (!fPrintColour) {
    640         red+=(green+blue);
    641         red/=3.0;
    642         green=red;
    643         blue=red;
    644       }
    645      
    646       if (fPrintColour) {
    647         for (i=1; i<nvertices; i++) {
    648           if (red!=vertex[i].red || green!=vertex[i].green || blue!=vertex[i].blue) {
    649             smooth=1;
    650             break;
    651           }
    652         }
    653       } else {
    654         for (i=1; i<nvertices; i++) {
    655           intensity = vertex[i].red + vertex[i].green + vertex[i].blue;
    656           intensity/=3.0;
    657           if (red!=intensity) {
    658             smooth=1;
    659             break;
    660           }
    661         }
    662       }
    663 
    664       if (smooth) {
    665         G4int triOffset;
    666         for (i=0; i<nvertices-2; i++) {
    667           triOffset = i*7;
    668           fprintf (file, "[%g %g %g %g %g %g]",
    669                    vertex[0].x, vertex[i+1].x, vertex[i+2].x,
    670                    vertex[0].y, vertex[i+1].y, vertex[i+2].y);
    671           if (fPrintColour) {
    672             fprintf (file, " [%g %g %g] [%g %g %g] [%g %g %g] gouraudtriangle\n",
    673                      vertex[0].red, vertex[0].green, vertex[0].blue,
    674                      vertex[i+1].red, vertex[i+1].green, vertex[i+1].blue,
    675                      vertex[i+2].red, vertex[i+2].green, vertex[i+2].blue);
    676           } else {
    677 
    678             intensity = vertex[0].red + vertex[0].green + vertex[0].blue;
    679             intensity/=3.0;
    680             fprintf (file, " [%g %g %g]", intensity, intensity, intensity);
    681 
    682             intensity = vertex[1].red + vertex[1].green + vertex[1].blue;
    683             intensity/=3.0;
    684             fprintf (file, " [%g %g %g]", intensity, intensity, intensity);
    685 
    686             intensity = vertex[2].red + vertex[2].green + vertex[2].blue;
    687             intensity/=3.0;
    688             fprintf (file, " [%g %g %g] gouraudtriangle\n", intensity, intensity, intensity);
    689           }
    690         }
    691       } else {
    692         fprintf (file, "newpath\n");
    693         fprintf (file, "%g %g %g setrgbcolor\n", red, green, blue);
    694         fprintf (file, "%g %g moveto\n", vertex[0].x, vertex[0].y);
    695         for (i=1; i<nvertices; i++) {
    696           fprintf (file, "%g %g lineto\n", vertex[i].x, vertex[i].y);
    697         }
    698         fprintf (file, "closepath fill\n\n");
    699       }
    700     }
    701     loc += nvertices*7;
    702     break;
    703 
    704   case GL_POINT_TOKEN:
    705     vertex=(Feedback3Dcolor*)loc;
    706     if (fPrintColour) {
    707       fprintf (file, "%g %g %g setrgbcolor\n", vertex[0].red, vertex[0].green, vertex[0].blue);
    708     } else {
    709       intensity = vertex[0].red + vertex[0].green + vertex[0].blue;
    710       intensity/=3.0;
    711       fprintf (file, "%g %g %g setrgbcolor\n", intensity, intensity, intensity);
    712     }     
    713     fprintf(file, "%g %g %g 0 360 arc fill\n\n", vertex[0].x, vertex[0].y, fPointSize / 2.0);
    714     loc += 7;           /* Each vertex element in the feedback
    715                            buffer is 7 GLfloats. */
    716     break;
    717   default:
    718     /* XXX Left as an excersie to the reader. */
    719     static G4bool spewPrimitiveEPSWarned = false;
    720     if (!spewPrimitiveEPSWarned) {
    721       std::ostringstream oss;
    722       oss <<
    723         "Incomplete implementation.  Unexpected token (" << token << ")."
    724         "\n  (Seems to be caused by text.)";
    725       G4Exception("G4OpenGLViewer::spewPrimitiveEPS",
    726                   "Unexpected token",
    727                   JustWarning,
    728                   oss.str().c_str());
    729       spewPrimitiveEPSWarned = true;
    730     }
    731   }
    732   return loc;
    733 }
    734 
    735 typedef struct G4OpenGLViewerDepthIndex {
    736   GLfloat *ptr;
    737   GLfloat depth;
    738 } DepthIndex;
    739 
    740 extern "C" {
    741   int G4OpenGLViewercompare(const void *a, const void *b)
    742   {
    743     const DepthIndex *p1 = (DepthIndex *) a;
    744     const DepthIndex *p2 = (DepthIndex *) b;
    745     GLfloat diff = p2->depth - p1->depth;
    746    
    747     if (diff > 0.0) {
    748       return 1;
    749     } else if (diff < 0.0) {
    750       return -1;
    751     } else {
    752       return 0;
    753     }
    754   }
    755 }
     401
     402
    756403
    757404GLubyte* G4OpenGLViewer::grabPixels (int inColor, unsigned int width, unsigned int height) {
    … …  
    804451}
    805452
    806 int G4OpenGLViewer::printNonVectoredEPS (int inColour,
    807                                 unsigned int width,
    808                                 unsigned int height) {
     453void G4OpenGLViewer::printEPS() {
     454  bool res;
     455  if (fVectoredPs) {
     456    res = printVectoredEPS();
     457  } else {
     458    res = printNonVectoredEPS();
     459  }
     460  if (res == false) {
     461    G4cerr << "Error while saving file... "<<fPrintFilename.c_str()<< G4endl;
     462  } else {
     463    G4cout << "File "<<fPrintFilename.c_str()<<" has been saved " << G4endl;
     464  }
     465}
     466
     467bool G4OpenGLViewer::printVectoredEPS() {
     468  return printGl2PS();
     469}
     470
     471bool G4OpenGLViewer::printNonVectoredEPS () {
     472
     473  int width = 0;
     474  int height = 0;
     475
     476  if (fPrintSizeX == 0) {
     477    width = fWinSize_x;
     478  } else {
     479    width = fPrintSizeX;
     480  }
     481  if (fPrintSizeY == 0) {
     482    height = fWinSize_y;
     483  } else {
     484    height = fPrintSizeY;
     485  }
    809486
    810487  FILE* fp;
    … …  
    813490  int components, pos, i;
    814491
    815   pixels = grabPixels (inColour, width, height);
    816 
    817   if (pixels == NULL)
    818     return 1;
    819   if (inColour) {
     492  pixels = grabPixels (fPrintColour, width, height);
     493
     494  if (pixels == NULL) {
     495      G4cerr << "Failed to get pixels from OpenGl viewport" << G4endl;
     496    return false;
     497  }
     498  if (fPrintColour) {
    820499    components = 3;
    821500  } else {
    … …  
    825504  fp = fopen (fPrintFilename.c_str(), "w");
    826505  if (fp == NULL) {
    827     return 2;
     506    G4cerr << "Can't open filename " << fPrintFilename.c_str() << G4endl;
     507    return false;
    828508  }
    829509 
    … …  
    877557  delete pixels;
    878558  fclose (fp);
    879   return 0;
    880 }
    881 
    882 
    883 bool G4OpenGLViewer::printGl2PS(unsigned int width,unsigned int height) {
     559
     560  // Reset for next time (useful is size change)
     561  fPrintSizeX = 0;
     562  fPrintSizeY = 0;
     563
     564  return true;
     565}
     566
     567
     568bool G4OpenGLViewer::printGl2PS() {
     569
     570  int width = 0;
     571  int height = 0;
     572
     573  if (fPrintSizeX == 0) {
     574    width = fWinSize_x;
     575  } else {
     576    width = fPrintSizeX;
     577  }
     578  if (fPrintSizeY == 0) {
     579    height = fWinSize_y;
     580  } else {
     581    height = fPrintSizeY;
     582  }
    884583
    885584  if (!fGL2PSAction) return false;
    … …  
    901600  fWinSize_y = Y;
    902601  ResizeGLView();
     602
     603  // Reset for next time (useful is size change)
     604  fPrintSizeX = 0;
     605  fPrintSizeY = 0;
    903606
    904607  return true;
    … …  
    944647
    945648
    946 void G4OpenGLViewer::spewSortedFeedback(FILE * file, GLint size, GLfloat * buffer)
    947 {
    948   int token;
    949   GLfloat *loc, *end;
    950   Feedback3Dcolor *vertex;
    951   GLfloat depthSum;
    952   int nprimitives, item;
    953   DepthIndex *prims;
    954   int nvertices, i;
    955 
    956   end = buffer + size;
    957 
    958   /* Count how many primitives there are. */
    959   nprimitives = 0;
    960   loc = buffer;
    961   while (loc < end) {
    962     token = int (*loc);
    963     loc++;
    964     switch (token) {
    965     case GL_LINE_TOKEN:
    966     case GL_LINE_RESET_TOKEN:
    967       loc += 14;
    968       nprimitives++;
    969       break;
    970     case GL_POLYGON_TOKEN:
    971       nvertices = int (*loc);
    972       loc++;
    973       loc += (7 * nvertices);
    974       nprimitives++;
    975       break;
    976     case GL_POINT_TOKEN:
    977       loc += 7;
    978       nprimitives++;
    979       break;
    980     default:
    981       /* XXX Left as an excersie to the reader. */
    982       static G4bool spewSortedFeedbackWarned = false;
    983       if (!spewSortedFeedbackWarned) {
    984         std::ostringstream oss;
    985         oss <<
    986           "Incomplete implementation.  Unexpected token (" << token << ")."
    987           "\n  (Seems to be caused by text.)";
    988         G4Exception("G4OpenGLViewer::spewSortedFeedback",
    989                     "Unexpected token",
    990                     JustWarning,
    991                     oss.str().c_str());
    992         spewSortedFeedbackWarned = true;
    993       }
    994       nprimitives++;
    995     }
    996   }
    997 
    998   /* Allocate an array of pointers that will point back at
    999      primitives in the feedback buffer.  There will be one
    1000      entry per primitive.  This array is also where we keep the
    1001      primitive's average depth.  There is one entry per
    1002      primitive  in the feedback buffer. */
    1003   prims = (DepthIndex *) malloc(sizeof(DepthIndex) * nprimitives);
    1004 
    1005   item = 0;
    1006   loc = buffer;
    1007   while (loc < end) {
    1008     prims[item].ptr = loc;  /* Save this primitive's location. */
    1009     token = int (*loc);
    1010     loc++;
    1011     switch (token) {
    1012     case GL_LINE_TOKEN:
    1013     case GL_LINE_RESET_TOKEN:
    1014       vertex = (Feedback3Dcolor *) loc;
    1015       depthSum = vertex[0].z + vertex[1].z;
    1016       prims[item].depth = depthSum / 2.0;
    1017       loc += 14;
    1018       break;
    1019     case GL_POLYGON_TOKEN:
    1020       nvertices = int (*loc);
    1021       loc++;
    1022       vertex = (Feedback3Dcolor *) loc;
    1023       depthSum = vertex[0].z;
    1024       for (i = 1; i < nvertices; i++) {
    1025         depthSum += vertex[i].z;
    1026       }
    1027       prims[item].depth = depthSum / nvertices;
    1028       loc += (7 * nvertices);
    1029       break;
    1030     case GL_POINT_TOKEN:
    1031       vertex = (Feedback3Dcolor *) loc;
    1032       prims[item].depth = vertex[0].z;
    1033       loc += 7;
    1034       break;
    1035     default:
    1036       /* XXX Left as an excersie to the reader. */
    1037       assert(1);
    1038     }
    1039     item++;
    1040   }
    1041   assert(item == nprimitives);
    1042 
    1043   /* Sort the primitives back to front. */
    1044   qsort(prims, nprimitives, sizeof(DepthIndex), G4OpenGLViewercompare);
    1045 
    1046   /* Understand that sorting by a primitives average depth
    1047      doesn't allow us to disambiguate some cases like self
    1048      intersecting polygons.  Handling these cases would require
    1049      breaking up the primitives.  That's too involved for this
    1050      example.  Sorting by depth is good enough for lots of
    1051      applications. */
    1052 
    1053   /* Emit the Encapsulated PostScript for the primitives in
    1054      back to front order. */
    1055   for (item = 0; item < nprimitives; item++) {
    1056     (void) spewPrimitiveEPS(file, prims[item].ptr);
    1057   }
    1058 
    1059   free(prims);
    1060 }
    1061649
    1062650void G4OpenGLViewer::rotateScene(G4double dx, G4double dy,G4double deltaRotation)

  • trunk/source/visualization/OpenGL/src/G4OpenGLViewerMessenger.cc

    r924 r941  
    2525//
    2626//
    27 // $Id: G4OpenGLViewerMessenger.cc,v 1.14 2009/02/16 15:31:05 lgarnier Exp $
     27// $Id: G4OpenGLViewerMessenger.cc,v 1.15 2009/03/05 16:36:13 lgarnier Exp $
    2828// GEANT4 tag $Name:  $
    2929
    … …  
    261261      pOGLViewer->fPrintFilename = std::string(oss.str().c_str());
    262262      // Print eps file...
    263       pOGLViewer->printVectoredEPS();
     263      pOGLViewer->printEPS();
    264264      // Restore fPrintFilename for Xm...
    265265      pOGLViewer->fPrintFilename = tmp_string;
    … …  
    346346    {
    347347      if (newValue == "vectored") pViewer->fVectoredPs = true;
    348       if (newValue == "pixmap") {
    349         pViewer->fVectoredPs = false;
    350         if (pVisManager->GetVerbosity() >= G4VisManager::warnings) {
    351           G4cout <<
    352             "WARNING: Only implemented for X Windows at present."
    353                  << G4endl;
    354         }
    355       }
     348      if (newValue == "pixmap") pViewer->fVectoredPs = false;
    356349    }
    357350

  • trunk/source/visualization/OpenGL/src/G4OpenGLXViewer.cc

    r940 r941  
    2525//
    2626//
    27 // $Id: G4OpenGLXViewer.cc,v 1.50 2009/03/05 11:04:20 lgarnier Exp $
     27// $Id: G4OpenGLXViewer.cc,v 1.51 2009/03/05 16:36:13 lgarnier Exp $
    2828// GEANT4 tag $Name:  $
    2929//
    … …  
    416416 
    417417  if (fVectoredPs) {
    418 
    419     printGl2PS(fWinSize_x, fWinSize_y);
    420     //    printVectoredEPS();
    421    
     418    printEPS();   
    422419  } else {
    423420
    … …  
    455452    DrawView ();
    456453   
    457     printNonVectoredEPS (fPrintColour,
    458                  fWinSize_x, fWinSize_y);
     454    printEPS ();
    459455   
    460456    win=tmp_win;
Note: See TracChangeset for help on using the changeset viewer.