TridSketches.cxx

Go to the documentation of this file.

#include "TridSketches.h"

#include "MessageService/MsgService.h"

#include "TROOT.h"
#include "TGX11.h"
#include "TVirtualX.h"
#include "TMath.h"
#include "KeySymbols.h"

#include <GL/gl.h>
#include <GL/glx.h>
#include <GL/glu.h>
#include "glf.h"
#include <iostream>
using namespace std;

CVSID("$Id: TridSketches.cxx,v 1.22 2007/09/14 14:12:19 tagg Exp $");

ClassImp(TridSketch)

unsigned int TridSketch::fgSketchIdCounter = 1;
TVector3     TridSketch::fgDefaultColor = TVector3( 1,1,1 );
float        TridSketch::fgDefaultTrans = 1.0;
Bool_t       TridSketch::fgScenery = false;

TridSketch::TridSketch( int type, TVector3 center ) :
  fType( type ),
  fHighlighted( false ),
  fToggle( true ),
  fScenery( fgScenery ),
  fTime( -999. ),
  fCallList( 0 ),
  fCenter( center )
{
  // Default constructor for base clase. 
  //
  fId = fgSketchIdCounter;
  fgSketchIdCounter++;

  fColor = fgDefaultColor;
  fTransparency = fgDefaultTrans;
}

/*
TridSketch::TridSketch( float red, float green, float blue, float trans) :
  fType( kNull ),
  fColor(red,green,blue),
  fTransparency(trans),
  fHighlighted( false ),
  fToggle( true ),
  fTime( -999. ),
  fCallList(0)
{
  // Default constructor for base clase. 
  //
  fId = fgSketchIdCounter;
  fgSketchIdCounter++;
}
*/

TridSketch::~TridSketch( void )
{
  glDeleteLists(fCallList,1);
}

void 
TridSketch::SetDirty( void ) 
{
  glDeleteLists(fCallList,1);
  fCallList = 0;
}

Bool_t
TridSketch::Draw( double timestart, double timeend ) 
{
  // Interface to specific drawing routines.
  // Handles some things common to all sketches.

  // Returns true if something actually got drawn.
  if(fToggle) {
    if( (fScenery) || // Scenery is always drawn
        ( ( fTime >= timestart ) && ( fTime < timeend ) ) // Other things get time-chopped.
        ) {
      
      // Change color:
      glColor4f(fColor.x(),fColor.y(),fColor.z(),fTransparency);
      
      if(fCallList == 0) {
        // Create the cached draw commands.
        fCallList = glGenLists(1);
        if(fCallList) {
          glNewList(fCallList,GL_COMPILE_AND_EXECUTE);
          glLoadName(fId);      
          this->DrawSelf();
          glEndList();
        } else {
          glLoadName(fId);
          this->DrawSelf();
          // Call list was not generated.. create an error
          MSG("TriD",Msg::kWarning) << "OpenGL problem: Could not create a new display list." << endl;
        }
      } else {
        glCallList(fCallList);
      }
      
      return true;
      
    }
  }
  return false;
}


void TridSketch::GlVertexTVector( TVector3& vect )
{
  //
  // Orders a glVertex given a ROOT 3-vector
  //
  glVertex3d(vect.x(), vect.y(), vect.z() );
}

double TridSketch::ComputeApparentZ(double* modelViewMatrix)
{
  fApparentZ = 
    modelViewMatrix[2] *fCenter.x() +
    modelViewMatrix[6] *fCenter.y() +
    modelViewMatrix[10]*fCenter.z()*10000.;  
  return fApparentZ;
}

 

ClassImp(TridSketchLine)

TridSketchLine::TridSketchLine( float x1, float y1, float z1, float x2, float y2, float z2 )
  : TridSketch(kLine, TVector3((x1+x2)*0.5,(y1+y2)*0.5,(z1+z2)*0.5) )
  , fWidth(1.0), fStipple(-1)
{
  //
  // Defines a line using the x,y,z coords of the two endpoints.
  //
  p[0].SetXYZ(x1,y1,z1);
  p[1].SetXYZ(x2,y2,z2);
}

TridSketchLine::TridSketchLine( const TVector3& inp1, const TVector3& inp2 )
  : TridSketch( kLine, (inp1 + inp2)*0.5 )
  , fWidth(1.0), fStipple(-1)
{
  //
  // Defines a line using 3-vectors of the two endpoints.
  //
  p[0] = inp1;
  p[1] = inp2;
}

TridSketchLine::TridSketchLine( const TVector3 &x0, const TVector3 &v1, float half_length )
  : TridSketch( kLine, x0 )
  , fWidth(1.0), fStipple(-1)
{
  // 
  // Defines a line using the 3-vector of the center point, the direciton vector,
  // and the half length.
  //
  p[0] = x0+(v1*half_length);
  p[1] = x0-(v1*half_length);
}

void TridSketchLine::DrawSelf( void ) 
{
  // Draws a line in the current OpenGL context.

  glLineWidth(fWidth);
  if(fStipple>0) {
    glLineStipple(fStipple, 0xAAAA);
    glEnable(GL_LINE_STIPPLE);    
  }
  glBegin(GL_LINES);
  GlVertexTVector( p[0] );
  GlVertexTVector( p[1] );
  glEnd();
  glLineWidth(1.0);
  if(fStipple>0) {
    glDisable(GL_LINE_STIPPLE);    
  }
  
  int error;
  while ((error = glGetError()) != GL_NO_ERROR)  
    MSG("TriD",Msg::kError) << "TridSketchLine::DrawSelf.  GL error: "
                            << "(" << error << ")"
                            <<  gluErrorString(error)
                            << endl;

}



ClassImp(TridSketchPlane)

TridSketchPlane::TridSketchPlane( void )
  : TridSketch(kPlane, TVector3())
{
}

TridSketchPlane::TridSketchPlane( const TVector3& p1, const TVector3& p2, const TVector3& p3, const TVector3& p4 )
  : TridSketch( kPlane, (p1 + p2 + p3 + p4)*0.25 )
{
  //
  // Defines a plane using the four corner positions.
  // Vertices must be given in rotational order.
  //
  p[0] = p1;
  p[1] = p2;
  p[2] = p3;
  p[3] = p4;
}

TridSketchPlane::TridSketchPlane( const TVector3& x0, 
                                  const TVector3& v1, float half_length, 
                                  const TVector3& v2, float half_width )
  : TridSketch( kPlane, x0 )
{
  //
  // Defines a plane using the center, two width direction vectors, and half-widths.
  //
  p[0] = x0 + v1*half_length + v2*half_width;
  p[1] = x0 - v1*half_length + v2*half_width;
  p[2] = x0 - v1*half_length - v2*half_width;
  p[3] = x0 + v1*half_length - v2*half_width;
  fCenter = x0;
}

void TridSketchPlane::DrawSelf( void )
{
  // Draws a plane in the current context.

  glBegin(GL_QUADS);
  GlVertexTVector(p[0]);
  GlVertexTVector(p[1]);
  GlVertexTVector(p[2]);
  GlVertexTVector(p[3]);
  glEnd();

}


ClassImp(TridSketchBox)

TridSketchBox::TridSketchBox( void )
  : TridSketch( kBox, TVector3() )
{
  //
  // Default constructor for a box.
  //
  cout << "TridSketchBox:: Wrong constructor!" << endl;
  for(int i=0;i<8;i++) {
    cout << "Box " << fId << "\t" << i << "\t" << p[i].x() << "\t" << p[i].y() << "\t" << p[i].z() << endl;
  }
}

TridSketchBox::TridSketchBox( const TVector3& p0, const TVector3& p1, const TVector3& p2, const TVector3& p3,
                              const TVector3& p4, const TVector3& p5, const TVector3& p6, const TVector3& p7 )
  : TridSketch( kBox, (p1+p2+p3+p4+p5+p6+p7)*(1.0/8.0) )
{
  //
  // Defines a box using the 8 corner vertices.
  // Note that the corner vertices must be in order:
  // top-nw top-ne top-se top-sw bottom-nw bottom-ne bottom-se,bottom-sw
  //
  p[0] = p0;
  p[1] = p1;
  p[2] = p2;
  p[3] = p3;
  p[4] = p4;
  p[5] = p5;
  p[6] = p6;
  p[7] = p7;
}

TridSketchBox::TridSketchBox( const TVector3& x0, const TVector3& v1, float half_length, 
                              const TVector3& v2, float half_width,
                              const TVector3& v3, float half_depth )
  : TridSketch( kBox, x0 )
{
  //
  // Defines a box the center, the 3 normal vectors, and a set of half-widths.
  //
  p[0] = x0 + v1*half_length + v2*half_width + v3*half_depth;
  p[1] = x0 + v1*half_length - v2*half_width + v3*half_depth;
  p[2] = x0 + v1*half_length - v2*half_width - v3*half_depth;
  p[3] = x0 + v1*half_length + v2*half_width - v3*half_depth;
  p[4] = x0 - v1*half_length + v2*half_width + v3*half_depth;
  p[5] = x0 - v1*half_length - v2*half_width + v3*half_depth;
  p[6] = x0 - v1*half_length - v2*half_width - v3*half_depth;
  p[7] = x0 - v1*half_length + v2*half_width - v3*half_depth;
}


void TridSketchBox::DrawSelf( void )
{
  //
  // Draws a box in the current context.
  //
  glBegin(GL_QUADS);
  
  GlVertexTVector(p[0]);  // Top face
  GlVertexTVector(p[1]);
  GlVertexTVector(p[2]);
  GlVertexTVector(p[3]);
  
  GlVertexTVector(p[4]);  // Bottom face
  GlVertexTVector(p[5]);
  GlVertexTVector(p[6]);
  GlVertexTVector(p[7]);

  glEnd();

  glBegin(GL_QUAD_STRIP);

  GlVertexTVector(p[0]);  // North face
  GlVertexTVector(p[4]);
  GlVertexTVector(p[1]);
  GlVertexTVector(p[5]);

  GlVertexTVector(p[2]);  // East face
  GlVertexTVector(p[6]);
  
  GlVertexTVector(p[3]);  // South
  GlVertexTVector(p[7]);
  
  GlVertexTVector(p[0]);  // West
  GlVertexTVector(p[4]);
  
  glEnd();
  
  int error;
  while ((error = glGetError()) != GL_NO_ERROR)  
    MSG("TriD",Msg::kError) << "TridSketchBox::DrawSelf.  GL error: "
                            << "(" << error << ")"
                            <<  gluErrorString(error)
                            << endl;
}



ClassImp(TridSketch3Prism)

TridSketch3Prism::TridSketch3Prism( void ) 
  : TridSketch( k3Prism, TVector3() )
{
  //
  // Default constructor for a box.
  //
  cout << "TridSketch3Prism:: Wrong constructor!" << endl;
  for(int i=0;i<8;i++) {
    cout << "3Prism " << fId << "\t" << i << "\t" << p[i].x() << "\t" << p[i].y() << "\t" << p[i].z() << endl;
  }
}

TridSketch3Prism::TridSketch3Prism( const TVector3& p0, const TVector3& p1, const TVector3& p2, const TVector3& p3,
                              const TVector3& p4, const TVector3& p5  )
  : TridSketch( k3Prism, (p0+p1+p2+p3+p4+p5)*(1.0/6.0) )
{
  //
  // Defines a box using the 8 corner vertices.
  // Note that the corner vertices must be in order:
  // top-nw top-ne top-se top-sw bottom-nw bottom-ne bottom-se,bottom-sw
  //
  p[0] = p0;
  p[1] = p1;
  p[2] = p2;
  p[3] = p3;
  p[4] = p4;
  p[5] = p5;
}

TridSketch3Prism::TridSketch3Prism( const TVector3& x0, 
                                    const TVector3& v1, float half_length, 
                                    const TVector3& v2, float half_width,
                                    const TVector3& v3, float half_depth,
                                    bool up, bool right)
  : TridSketch( k3Prism, x0 )
{
  //
  // Defines a box the center, the 3 normal vectors, and a set of half-widths.
  //
  // Adjust which corner of the box is cut off.
  if(up)    half_length = -half_length;
  if(right) half_width  = -half_width;

  p[0] = x0 - v1*half_length - v2*half_width - v3*half_depth;  
  p[1] = x0 + v1*half_length - v2*half_width - v3*half_depth;
  p[2] = x0 + v1*half_length + v2*half_width - v3*half_depth;

  p[3] = x0 - v1*half_length - v2*half_width + v3*half_depth;
  p[4] = x0 + v1*half_length - v2*half_width + v3*half_depth;
  p[5] = x0 + v1*half_length + v2*half_width + v3*half_depth;
}


void TridSketch3Prism::DrawSelf( void )
{
  //
  // Draws a box in the current context.
  //
  glBegin(GL_TRIANGLES);
  
  GlVertexTVector(p[0]);  // Top face
  GlVertexTVector(p[1]);
  GlVertexTVector(p[2]);
  
  GlVertexTVector(p[3]);  // Bottom face
  GlVertexTVector(p[4]);
  GlVertexTVector(p[5]);

  glEnd();

  glBegin(GL_QUAD_STRIP);

  GlVertexTVector(p[0]);  // North face
  GlVertexTVector(p[3]);
  GlVertexTVector(p[1]);
  GlVertexTVector(p[4]);

  GlVertexTVector(p[2]);  // East face
  GlVertexTVector(p[5]);
  
  GlVertexTVector(p[0]);  // South
  GlVertexTVector(p[3]);
  
  glEnd();
  
  int error;
  while ((error = glGetError()) != GL_NO_ERROR)  
    MSG("TriD",Msg::kError) << "TridSketch3Prism::DrawSelf.  GL error: "
                            << "(" << error << ")"
                            <<  gluErrorString(error)
                            << endl;
}

// Tube

ClassImp(TridSketchTube)

TridSketchTube::TridSketchTube( void )
  : TridSketch(kTube, TVector3() )
{
  //
  // Default constructor for a box.
  //
  p = new TVector3[6];
  cout << "TridSketchTube:: Wrong constructor!" << endl;
  for(int i=0;i<8;i++) {
    cout << "Tube " << fId << "\t" << i << "\t" << p[i].x() << "\t" << p[i].y() << "\t" << p[i].z() << endl;
  }
}


TridSketchTube::TridSketchTube(  const TVector3& end1, const TVector3& end2,
                                 Double_t radius, Int_t nfaces, Bool_t closed )
  : TridSketch(kTube, (end1+end2)*0.5 )
{
  //
  // Defines the center of the faces, the
  //
  fNfaces = nfaces;
  fClosed = closed;
  p = new TVector3[nfaces*2];

  // Find the 2 vectors normal to the length of the tube.
  TVector3 v = end2-end1;
  TVector3 n1=v.Orthogonal();
  TVector3 n2=v.Cross(n1);

  n1.SetMag(1.0);
  n2.SetMag(1.0);

  // Find the points around the ends.
  for(int i=0;i<fNfaces;i++) {
    double angle = (double)i/(double)fNfaces * 2.0*TMath::Pi();
    p[i]         = end1 + n1*cos(angle)*radius + n2*sin(angle)*radius;
    p[i+fNfaces] = end2 + n1*cos(angle)*radius + n2*sin(angle)*radius;
  }
}


void TridSketchTube::DrawSelf( void )
{
  //
  // Draws a box in the current context.
  //
  if(fClosed) {
    // Top Face  
    glBegin(GL_POLYGON);
    for(int i=0;i<fNfaces;i++) 
      GlVertexTVector(p[i]); 
    glEnd();
    
    // Bottom face
    glBegin(GL_POLYGON);
    for(int i=fNfaces;i<fNfaces*2;i++) 
      GlVertexTVector(p[i]); 
    glEnd();
  }

  // Now do each face.
  glBegin(GL_QUAD_STRIP);
    for(int i=0;i<fNfaces+1;i++) { // Add an extra so we go all the way around.
      // Even and odd faces get get treated seperately.
      int iv1 = i%fNfaces;
      int iv2 = i%fNfaces + fNfaces;
      if((i%2)==0) {
        GlVertexTVector(p[iv1]);
        GlVertexTVector(p[iv2]);
      } else {
        GlVertexTVector(p[iv1]);
        GlVertexTVector(p[iv2]);
      }
    }
  glEnd();
  
  int error;
  while ((error = glGetError()) != GL_NO_ERROR)  
    MSG("TriD",Msg::kError) << "TridSketchTube::DrawSelf.  GL error: "
                            << "(" << error << ")"
                            <<  gluErrorString(error)
                            << endl;
}

// Ellipse

ClassImp(TridSketchEllipse)

TridSketchEllipse::TridSketchEllipse( void )
  : TridSketch( kEllipse, TVector3() )
{
  //
  // Default constructor for a box.
  //
  p = new TVector3[6];
  cout << "TridSketchEllipse:: Wrong constructor!" << endl;
  for(int i=0;i<8;i++) {
    cout << "Ellipse " << fId << "\t" << i << "\t" << p[i].x() << "\t" << p[i].y() << "\t" << p[i].z() << endl;
  }
}


TridSketchEllipse::TridSketchEllipse( const TVector3& center, 
                                      const TVector3& axis1, 
                                      const TVector3& axis2, 
                                      Int_t nvertex )
  : TridSketch( kEllipse, center )
{
  //
  // Defines the center of the faces, the
  //
  fNv = nvertex; 
  p = new TVector3[nvertex];

  // Find the points around the ends.
  for(int i=0;i<fNv;i++) {
    double angle = (double)i/(double)fNv * 2.0*TMath::Pi();
    p[i]         = center + axis1*cos(angle) + axis2*sin(angle);
  }
}


void TridSketchEllipse::DrawSelf( void )
{
  //
  // Draws 
  //
  glBegin(GL_POLYGON);
  for(int i=0;i<fNv;i++) 
    GlVertexTVector(p[i]); 
  glEnd();
  
  int error;
  while ((error = glGetError()) != GL_NO_ERROR)  
    MSG("TriD",Msg::kError) << "TridSketchEllipse::DrawSelf.  GL error: "
                            << "(" << error << ")"
                            <<  gluErrorString(error)
                            << endl;
}



ClassImp(TridSketchText)

TridSketchText::TridSketchText( 
                               const TVector3& pos, const TVector3& up, const TVector3& norm,
                               const char* text )
  : TridSketch( kText, pos ),
    fPosition(pos),
    fUp(up.Unit()),       // Normalizes
    fNormal(norm.Unit()), // Normalizes
    fScaleHoriz(1),
    fScaleVert(1),
    fThickness(0.1),  
    fText(text),
    fFont(-1),
    fJustify(kCenter)
{
}

void TridSketchText::DrawSelf( void )
{
  //
  // Draws a box in the current context.
  //
  glPushMatrix();
  
  // Translate.
  glTranslated(fPosition.x(),fPosition.y(),fPosition.z());
    
  // Rotation. By default, text is drawn 
  // in the x-y plane, with the normal in z and the up arrow towards y.
  TVector3 stdnorm(0,0,1);
  TVector3 stdup  (0,1,0);

  // Rotate so that the normal is in the correct position.
  // Special case: flip by 180:
  TVector3 rot;
  Double_t ang1;
  if(fNormal == -kv_z) {
    rot = TVector3(0,1,0);
    ang1 = 180.; 
  } else {
    //rot = stdnorm.Cross(fNormal).Unit();
    //ang1 = acos(stdnorm.Dot(fNormal))*57.295779513;
    rot = stdnorm.Cross(fNormal);
    ang1= asin(rot.Mag())*57.295779513;
    if(ang1!=0) rot.SetMag(1.0);
  }

  if(ang1!=0)
    stdup.Rotate(ang1*0.01745329252,rot);  // stdup is y rotated into the new position.

  double ang2 = stdup.Angle(fUp)*57.295779513;

  // Rotate so that the Up vector is correct.
  if(ang2!=0)
    glRotated(ang2, fNormal.x(), fNormal.y(), fNormal.z() );

  // Rotate for normal to be correct.
  if(ang1!=0)
    glRotated(ang1, rot.x(), rot.y(), rot.z() );
  
  // Stretch.
  glScaled(fScaleHoriz, fScaleVert, 1.0);

  // Move to correct local Z
  glTranslated(0.,0.,-1.);
  
  // Set options
  int oldFont = glfGetCurrentFont();
  if(fFont>0) glfSetCurrentFont(fFont);

  glfSetSymbolDepth(fThickness);
  glfStringCentering(true);

  float minx, miny, maxx, maxy;
  glfGetStringBounds(const_cast<char*>(fText.Data()), &minx, &miny, &maxx, &maxy);
  
  // Adjust for stupidities in glf
  minx -= 1.0;
  maxx -= 1.0;

  float halfwidth =  (minx+maxx)*0.5;
  float halfheight = (-miny+maxy)*0.5;

  // Default: center.
  float movex = 0; //halfwidth;
  float movey = 0;

  if(fJustify & kJustifyLeft)   movex  = -halfwidth + minx;
  if(fJustify & kJustifyRight)  movex  = halfwidth - minx;
  if(fJustify & kJustifyTop)    movey += halfheight;
  if(fJustify & kJustifyBottom) movey -= halfheight;

  glTranslatef(-movex,-movey,0.0f);
  /*
    // Draw bounding box.
  glPushMatrix();
  glBegin(GL_LINE_LOOP);
  glColor4f(fColor.x(),fColor.y(),fColor.z(),fTransparency);
  glVertex3f(minx, miny, 1.0 );
  glVertex3f(minx, maxy, 1.0 );
  glVertex3f(maxx, maxy, 1.0 );
  glVertex3f(maxx, miny, 1.0 );
  //glVertex3f(minx, miny, 1.0 );
  glEnd();
  glPopMatrix();
  */

  // Draw.
  glfDraw3DSolidString(const_cast<char*>(fText.Data()));

  glfSetCurrentFont(oldFont);

  // Revert.
  glPopMatrix();

  int error;
  while ((error = glGetError()) != GL_NO_ERROR)  
    MSG("TriD",Msg::kError) << "TridSketchText::DrawSelf.  GL error: "
                            << "(" << error << ")"
                            <<  gluErrorString(error)
                            << endl;

   
}

---