TPolyLineShape.cxx

Go to the documentation of this file.

// @(#)root/table:$Id$
// Author: Valeri Fine 1999
 
/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#include "TPolyLineShape.h"
 
#include "TPoints3D.h"
#include "TVolume.h"
#include "TVolumePosition.h"
#include "TTUBE.h"
#include "TBRIK.h"
#include "TSPHE.h"
#include "TView.h"
#include "TVirtualPad.h"
#include "TTablePadView3D.h"
#include "TPoint.h"
#include "TVirtualPS.h"
#include "TMath.h"
 
//////////////////////////////////////////////////////////////////////////////////////
//                                                                                  //
//                           STAR 3D geometry Object Model                          //
//                           =============================                          //
//                                                                                  //
//                           TDataSet            Legend:                            //
//                              |                  "classA"                         //
//                              |                     |     "classB" is derived from//
//                              v                     v       the "classA"          //
//                           TVolume               "classB"                         //
//                              ^                                                   //
//                              |                  "classQ"                         //
//                              |                      ^     "classQ" has a pointer //
//                            TShape                   |       to "classT"          //
//                              |                   "classT"                        //
//                              v                                                   //
//           -----------------------------------------------------                  //
//           |               |      |                     |      |                  //
//           |               |      |     .    .    .     |      |                  //
//           |               |      |                     |      |                  //
//           V               v      v                     v      v                  //
//      TPolyLineShape     TBRIK  TTUBE                 TPCON  TTRD1                //
//       |        ^                                                                 //
//       |        |       <a href="http://root.cern.ch/root/html/TShape.html#TShape:description">R  O  O  T        S  H  A  P  E  S</a>                          //
//       V        |       (see <a href="https://cern-tex.web.cern.ch/cern-tex/geant_html3/node109.html#SECTION041000000000000000000000">GEANT 3.21 shapes</a> as well)                           //
// St_PolyLine3D  |                                                                 //
//                |                                                                 //
//           TPoints3DABC                                                           //
//                |                                                                 //
//                |                                                                 //
//                v                                                                 //
//      --------------------------------------------------------                    //
//      |                 |                 |                  |                    //
//      |                 |                 |                  |                    //
//      |                 |                 |                  |                    //
//      V                 v                 v                  v                    //
//StHits3DPoints   StHelix3DPoints   TTable3Points          TPoints3D               //
//      ^                 ^                 ^                  ^                    //
//      |                 |                 |                  |                    //
//      |                 |                 |                  |                    //
//  StObjArray    StTrack / StHelixD  TTableSorter       flat floating              //
//                                          ^              point array              //
//                                          |        (see St_PolyLine3D as well)    //
//                                          |                                       //
//                                        TTable                                    //
//                                                                                  //
//                                                                                  //
//                     S  T  A  R    S  H  A  P  E  S                               //
//                     -------------------------------                              //
//                                                                                  //
//////////////////////////////////////////////////////////////////////////////////////
 
ClassImp(TPolyLineShape);
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
TPolyLineShape::TPolyLineShape()
{
   fShape = 0;
   fSmooth = kFALSE;
   fConnection= 0;
   fPoints=0;
   SetWidthFactor();
   fHasDrawn = kFALSE;
   fShapeType = kNULL;
   fSizeX3D   = 0;
   fPointFlag = kFALSE;
   fLineFlag  = kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
///  fShape       = new TTUBE("tube","tube","void",0.5,0.5);
 
TPolyLineShape::TPolyLineShape(TPoints3DABC  *points,Option_t* option)
{
   fShape      = 0;
   fShapeType   = kNULL;
   fSmooth      = kFALSE;
   fConnection  = 0;
   fPoints      = points;
   fHasDrawn    = kFALSE;
   fSizeX3D     = 0;
   // Take in account the current node if any
   if (!fPoints) {
      Error("TPolyLineShape","No polyline is defined");
      return;
   }
   fPointFlag = strchr(option,'P')?kTRUE:kFALSE;
   fLineFlag  = strchr(option,'L')?kTRUE:kFALSE;
 
   SetWidthFactor();
   Create();
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
TPolyLineShape::~TPolyLineShape()
{
   SafeDelete(fShape);
   SafeDelete(fSizeX3D);
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
void TPolyLineShape::Create()
{
   if (!fConnection) SetConnection(kBrik);
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
Size3D *TPolyLineShape::CreateX3DSize(Bool_t marker)
{
   if (!fSizeX3D) fSizeX3D = new Size3D;
   fSizeX3D->numPoints = 0;
   fSizeX3D->numSegs   = 0;
   fSizeX3D->numPolys  = 0;         //NOTE: Because of different structure, our
   if (fPoints) {
      Int_t size = fPoints->Size();
      if (marker) {
         Int_t mode;
         if (size > 10000) mode = 1;         // One line marker    '-'
         else if (size > 3000) mode = 2;     // Two lines marker   '+'
         else mode = 3;                      // Three lines marker '*'
 
         fSizeX3D->numSegs   = size*mode;
         fSizeX3D->numPoints = size*mode*2;
         fSizeX3D->numPolys  = 0;
      } else {
         fSizeX3D->numSegs   = size-1;
         fSizeX3D->numPoints = size;
      }
      fSizeX3D->numPolys  = 0;         //NOTE: Because of different structure, our
   }
   return fSizeX3D;
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
Int_t TPolyLineShape::SetConnection(EShapeTypes connection)
{
   Float_t size = 0.5*GetWidthFactor()*GetLineWidth();
 
   if (fShapeType != connection) {
      SafeDelete(fConnection);
      fShapeType = connection;
      switch (fShapeType) {
         case  kSphere:
            SetConnection(new TSPHE("connection","sphere","void",0,size,0,90,0,360));
            break;
         default:
            SetConnection(new TBRIK("connection","brik","void",size,size,size));
            break;
      };
   }
   return 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute distance from point px,py to a 3-D polyline.
///
/// Compute the closest distance of approach from point px,py to each segment
/// of the polyline.
/// Returns when the distance found is below DistanceMaximum.
/// The distance is computed in pixels units.
 
Int_t TPolyLineShape::DistancetoPrimitive(Int_t px, Int_t py)
{
   if (fPoints) {
      Int_t ret = fPoints->DistancetoPrimitive( px, py);
      if (ret == -1) ret = PointDistancetoPrimitive(px, py);
      return ret;
   }
   return 999999;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute distance from point px,py to a 3-D points.
///
/// Compute the closest distance of approach from point px,py to each segment
/// of the polyline.
/// Returns when the distance found is below DistanceMaximum.
/// The distance is computed in pixels units.
 
Int_t TPolyLineShape::PointDistancetoPrimitive(Int_t px, Int_t py)
{
   const Int_t inaxis = 7;
   Float_t dist = 999999;
 
   Int_t puxmin = gPad->XtoAbsPixel(gPad->GetUxmin());
   Int_t puymin = gPad->YtoAbsPixel(gPad->GetUymin());
   Int_t puxmax = gPad->XtoAbsPixel(gPad->GetUxmax());
   Int_t puymax = gPad->YtoAbsPixel(gPad->GetUymax());
 
   TView *view = 0;
//*-*- return if point is not in the user area
   if (px < puxmin - inaxis) goto END;
   if (py > puymin + inaxis) goto END;
   if (px > puxmax + inaxis) goto END;
   if (py < puymax - inaxis) goto END;
 
   view = gPad->GetView();
   if (view) {
      Int_t i;
      Float_t dpoint;
      Float_t xndc[3];
      Int_t x1,y1;
      Int_t pointSize = fPoints->Size();
      for (i=0;i<pointSize;i++) {
         Float_t thisPoints[3];
         view->WCtoNDC(fPoints->GetXYZ(thisPoints,i), xndc);
         x1     = gPad->XtoAbsPixel(xndc[0]);
         y1     = gPad->YtoAbsPixel(xndc[1]);
         dpoint = (px-x1)*(px-x1) + (py-y1)*(py-y1);
         if (dpoint < dist) dist = dpoint;
      }
      dist = (TMath::Sqrt(dist));
   }
END:
   return Int_t(dist);
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
void TPolyLineShape::Draw(Option_t *)
{
   Create();
   AppendPad();
}
 
////////////////////////////////////////////////////////////////////////////////
/// forward the ExecuteEvent call to the decorated object
 
void TPolyLineShape::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
   if (fPoints) fPoints->ExecuteEvent(event,px, py);
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
Color_t TPolyLineShape::GetColorAttribute() const
{
   return ((TPolyLineShape *)this)->GetLineColor();
}
////////////////////////////////////////////////////////////////////////////////
/// forward the GetName call to the decorated object
 
const char  *TPolyLineShape::GetName()  const
{
   return fPoints ? fPoints->GetName() : TShape::GetName();
}
////////////////////////////////////////////////////////////////////////////////
/// forward the GetObjectInfo call to the decorated object
 
char  *TPolyLineShape::GetObjectInfo(Int_t px, Int_t py) const
{
   return fPoints ? fPoints->GetObjectInfo(px, py) : TShape::GetObjectInfo(px,py);
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
Size_t TPolyLineShape::GetSizeAttribute() const
{
   return ((TPolyLineShape *)this)->GetMarkerSize();
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
Style_t TPolyLineShape::GetStyleAttribute() const
{
   return ((TPolyLineShape *)this)->GetLineStyle();
}
 
////////////////////////////////////////////////////////////////////////////////
/// forward the GetObjectInfo call to the decorated object
 
const char  *TPolyLineShape::GetTitle() const
{
   return fPoints ? fPoints->GetTitle() : TShape::GetTitle();
}
////////////////////////////////////////////////////////////////////////////////
/// Double_t *start - coordinate of the start point of the current segment
/// Double_t *end   - coordinate of the end   point of the current segment
 
void TPolyLineShape::PaintNode(Float_t *start,Float_t *end,Option_t *option)
{
  // Calculate the vector
   const Int_t kDimension = 3;
   Double_t vector[kDimension];
   Double_t nodeposition[kDimension];
   Int_t i=0;
   for (i=0;i<kDimension;i++) {
      vector[i]=end[i]-start[i];
      nodeposition[i]=0.5*(start[i]+end[i]);
   }
   Double_t length = TMath::Normalize(vector);
 
  // Calculate the rotation axis for Axis Oz
 
   Double_t oz[3]={0,0,1};
   Double_t rotate[3];
 
   Double_t sina = TMath::Normalize(TMath::Cross(vector,oz,rotate));
   Double_t cosa = Product(vector,oz);
   Double_t mrot[3][3];
 
   TShape *shape = fShape;
   if (!shape) shape = fConnection;
 
   Gyrot(rotate,cosa,sina,mrot);
 
   Float_t width = GetWidthFactor()*GetLineWidth();
 
   mrot[0][0] *= width;
   mrot[0][1] *= width;
   mrot[0][2] *= width;
 
   mrot[1][0] *= width;
   mrot[1][1] *= width;
   mrot[1][2] *= width;
 
   mrot[2][0] *= length;
   mrot[2][1] *= length;
   mrot[2][2] *= length;
 
   Color_t color = GetLineColor();
 
   TVolume node("SegmentNode","SegmentNode", shape);
   node.SetLineColor(color);
   if (!fShape) node.SetVisibility();
   node.SetLineColor(color);
 
   TRotMatrix matrix ("rotate","rotate",&mrot[0][0]);
   TVolumePosition position(&node,nodeposition[0],nodeposition[1]
                                 ,nodeposition[2],&matrix);
 
   if (!(fSmooth || fConnection))  {
      node.PaintNodePosition(option, &position);
      return;
   }
 
   // Add the connection
 
   memset(mrot,0,9*sizeof(Double_t));
 
   length = width/length;
   mrot[2][2] = length;
   mrot[0][0] = 1;
   mrot[1][1] = 1;
 
   TRotMatrix kneeMatrix("knee","knee",&mrot[0][0]);
   TVolume knee("ConnectionNode","ConnectionNode", fConnection);
   TVolumePosition kneePosition(&knee, 0, 0, 0.5, &kneeMatrix);
   knee.SetLineColor(color);
   node.Add(&knee,&kneePosition);
 
   node.PaintNodePosition(option, &position);
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
void TPolyLineShape::Paint(Option_t *opt)
{
   if (!GetPoints()) return;
 
   Bool_t rangeView = opt && opt[0] && strcmp(opt,"range")==0 ? kTRUE : kFALSE;
   TTablePadView3D *view3D = 0;
   if (!rangeView  && (view3D = (TTablePadView3D*)gPad->GetView3D()) ) {
      TString mode;
 
      mode="";
      if (fLineFlag)  mode  = "L";
      if (fPointFlag) mode += "P";
 
      view3D->SetLineAttr(GetColorAttribute(), (Int_t)GetSizeAttribute());
      view3D->PaintPoints3D(GetPoints(), mode.Data());
   }
   if (opt && !strstr(opt, "x3d")) {
      if (fPointFlag) {
         SetMarkerColor(GetColorAttribute());
         SetMarkerSize(GetSizeAttribute());
         PaintPolyMarker(fPoints->Size());
      }
      if (fLineFlag) {
         SetLineColor(GetColorAttribute());
         SetLineWidth((Width_t)GetSizeAttribute());
         PaintPoints(fPoints->Size());
      }
 
   } else {
      if (fLineFlag) {
         CreateX3DSize(kFALSE); PaintX3DLine(opt);
      } else {
         CreateX3DSize(kTRUE);  PaintX3DMarker(opt);
      }
//     Paint3d(opt);
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Draw this 3-D polyline with new coordinates.
 
void  TPolyLineShape::PaintPoints(Int_t n, Float_t *, Option_t *)
{
   if (n < 2) return;
 
   TAttLine::Modify();  //Change line attributes only if necessary
 
//*-*- Loop on each individual line
   for (Int_t i=1;i<n;i++) {
      Float_t xyz[6];
      fPoints->GetXYZ(&xyz[0],i-1,2);
      gPad->PaintLine3D(xyz, &xyz[3]);
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Paint polymarker in CurrentPad World coordinates.
 
void TPolyLineShape::PaintPolyMarker(Int_t n, Float_t *, Marker_t, Option_t *)
{
   if (n <= 0) return;
 
   TView *view = gPad->GetView();      //Get current 3-D view
   if(!view) return;                   //Check if `view` is valid
 
   //Create temporary storage
   TPoint *pxy = new TPoint[n];
   Float_t *x  = new Float_t[n];
   Float_t *y  = new Float_t[n];
   Float_t xndc[3], ptr[3];
 
//*-*- convert points from world to pixel coordinates
   Int_t nin = 0;
   for (Int_t i = 0; i < n; i++) {
      fPoints->GetXYZ(ptr,i);
      view->WCtoNDC(ptr, xndc);
      if (xndc[0] < gPad->GetX1() || xndc[0] > gPad->GetX2()) continue;
      if (xndc[1] < gPad->GetY1() || xndc[1] > gPad->GetY2()) continue;
      x[nin] = xndc[0];
      y[nin] = xndc[1];
      pxy[nin].fX = gPad->XtoPixel(x[nin]);
      pxy[nin].fY = gPad->YtoPixel(y[nin]);
      nin++;
   }
 
   TAttMarker::Modify();  //Change marker attributes only if necessary
 
//*-*- invoke the graphics subsystem
   if (!gPad->IsBatch()) gVirtualX->DrawPolyMarker(nin, pxy);
 
 
   if (gVirtualPS) {
      gVirtualPS->DrawPolyMarker(nin, x, y);
   }
   delete [] x;
   delete [] y;
 
   delete [] pxy;
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
void TPolyLineShape::Paint3d(Option_t *opt)
{
   if (!fPoints) return;
 
   Create();
 
   struct XYZ { Float_t fValues[3]; } *points;
   points  = (XYZ *)(fPoints->GetP());
   Int_t size      = fPoints->GetN()-1;
 
   for (Int_t i=0;i<size;i++)
      PaintNode((Float_t *)(points+i+1),(Float_t *)(points+i),opt);
   fHasDrawn = kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
void TPolyLineShape::PaintX3DLine(Option_t *)
{
#ifndef WIN32
   Int_t size = 0;
   if (fPoints) size = fPoints->Size();
   if (!size) return;
 
   X3DBuffer *buff = new X3DBuffer;
   if (!buff) return;
 
   fSizeX3D->numPoints = buff->numPoints = size;
   fSizeX3D->numSegs   = buff->numSegs   = size-1;
   fSizeX3D->numPolys  = buff->numPolys  = 0;        //NOTE: Because of different structure, our
 
   buff->polys     = 0;     //      TPolyLine3D can't use polygons
   TPoints3D x3dPoints(size);
   buff->points    = fPoints->GetXYZ(x3dPoints.GetP(),0,size);
 
//        Int_t c = (((fAttributes?fAttributes->GetColorAttribute():0) % 8) - 1) * 4;     // Basic colors: 0, 1, ... 8
   Int_t c = ((GetColorAttribute() % 8) - 1) * 4;     // Basic colors: 0, 1, ... 8
   if (c < 0) c = 0;
 
   //*-* Allocate memory for segments *-*
   buff->segs = new Int_t[buff->numSegs*3];
   if (buff->segs) {
      for (Int_t i = 0; i < buff->numSegs; i++) {
         buff->segs[3*i  ] = c;
         buff->segs[3*i+1] = i;
         buff->segs[3*i+2] = i+1;
      }
   }
 
 
   if (buff && buff->points && buff->segs) //If everything seems to be OK ...
      FillX3DBuffer(buff);
   else {                            // ... something very bad was happened
      gSize3D.numPoints -= buff->numPoints;
      gSize3D.numSegs   -= buff->numSegs;
      gSize3D.numPolys  -= buff->numPolys;
   }
 
   if (buff->segs)     delete [] buff->segs;
   if (buff->polys)    delete [] buff->polys;
   if (buff)           delete    buff;
#endif
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
void TPolyLineShape::PaintX3DMarker(Option_t *)
{
#ifndef WIN32
   Int_t size = 0;
   if (fPoints) size = fPoints->Size();
   if (!size) return;
   Int_t mode;
   Int_t i, j, k, n;
 
   X3DBuffer *buff = new X3DBuffer;
   if(!buff) return;
 
   if (size > 10000) mode = 1;         // One line marker    '-'
   else if (size > 3000) mode = 2;     // Two lines marker   '+'
   else mode = 3;                      // Three lines marker '*'
 
   fSizeX3D->numSegs   = buff->numSegs   = size*mode;
   fSizeX3D->numPoints = buff->numPoints = buff->numSegs*2;
   fSizeX3D->numPolys  = buff->numPolys  = 0;         //NOTE: Because of different structure, our
 
   buff->polys     = 0;      //      TPolyMarker3D can't use polygons
 
 
    //*-* Allocate memory for points *-*
   Float_t delta = 0.002;
 
   buff->points = new Float_t[buff->numPoints*3];
   if (buff->points) {
      for (i = 0; i < size; i++) {
         for (j = 0; j < mode; j++) {
            for (k = 0; k < 2; k++) {
               delta *= -1;
               for (n = 0; n < 3; n++) {
                  Float_t xyz[3];
                  fPoints->GetXYZ(xyz,i);
                  buff->points[mode*6*i+6*j+3*k+n] =
                  xyz[n] * (1 + (j == n ? delta : 0));
               }
            }
         }
      }
   }
 
   Int_t c = ((GetColorAttribute() % 8) - 1) * 4;     // Basic colors: 0, 1, ... 8
   if (c < 0) c = 0;
 
    //*-* Allocate memory for segments *-*
   buff->segs = new Int_t[buff->numSegs*3];
   if (buff->segs) {
      for (i = 0; i < buff->numSegs; i++) {
         buff->segs[3*i  ] = c;
         buff->segs[3*i+1] = 2*i;
         buff->segs[3*i+2] = 2*i+1;
      }
   }
 
   if (buff->points && buff->segs)    //If everything seems to be OK ...
      FillX3DBuffer(buff);
   else {                            // ... something very bad was happened
      gSize3D.numPoints -= buff->numPoints;
      gSize3D.numSegs   -= buff->numSegs;
      gSize3D.numPolys  -= buff->numPolys;
   }
 
   if (buff->points)   delete [] buff->points;
   if (buff->segs)     delete [] buff->segs;
   if (buff->polys)    delete [] buff->polys;
   if (buff)           delete    buff;
#endif
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
Float_t TPolyLineShape::Product(Float_t *v1, Float_t *v2,Int_t ndim)
{
   Float_t p = 0;
   if (v1 && v2 && ndim > 0)
      for (Int_t i=0; i<ndim; i++) p+= v1[i]*v2[i];
   return p;
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
Double_t TPolyLineShape::Product(Double_t *v1, Double_t *v2,Int_t ndim)
{
   Double_t p = 0;
   if (v1 && v2 && ndim > 0)
      for (Int_t i=0;i<ndim;i++) p+= v1[i]*v2[i];
   return p;
}
 
////////////////////////////////////////////////////////////////////////////////
///************************************************************************
///*                                                                      *
///*   call gyrot(dirc,angp,trans,ntrans)                       vp 880722 *
///*                                       revised              vp 921009 *
///*                                       revised (f->c++)     vf 981006 *
///*       routine for filling rotation transformation matrix             *
///*       from axis and rotation angle around                            *
///*                                                                      *
///*   arguments:                                                         *
///*       dirc    direct cosinuses (may be not normalised)               *
///*       cosang, sinang - cos and sin of the rotation angle             *
///*       tranz   rotation & shift matrix 3*3  (input/output)            *
///*    ---------------------------------------------------------------   *
///*  This code is provided by Victor Perevoztchikov                      *
///************************************************************************
 
Double_t *TPolyLineShape::Gyrot(Double_t *dirc, Double_t cosang, Double_t sinang, Double_t trans[3][3])
{
   Double_t ax[3];
 
   memcpy(ax,dirc,3*sizeof(Double_t));
   TMath::Normalize(ax);
 
   Double_t ca  = cosang;
   Double_t sa  = sinang;
   Double_t ca1;
 
   if (ca < 0.5)
      ca1 = 1. - ca ;
   else
      ca1 = (sa*sa)/(1.+ca) ;
 
   Int_t j1 = 0;
   Int_t j2 = 0;
   for(j1 = 0; j1 < 3; j1++) {
      for(j2 = 0; j2 < 3; j2++)
         trans[j1][j2] = ca1*ax[j1]*ax[j2];
      trans[j1][j1]   += ca;
   }
 
   trans[0][1] = trans[0][1] - sa*ax[2];
   trans[1][0] = trans[1][0] + sa*ax[2];
   trans[0][2] = trans[0][2] + sa*ax[1];
   trans[2][0] = trans[2][0] - sa*ax[1];
   trans[1][2] = trans[1][2] - sa*ax[0];
   trans[2][1] = trans[2][1] + sa*ax[0];
 
   return (Double_t *)trans;
 
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
Color_t TPolyLineShape::SetColorAttribute(Color_t color)
{
   Color_t currentColor = GetColorAttribute();
   if (color != currentColor) {
      SetLineColor(color);
      SetMarkerColor(color);
   }
   return currentColor;
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
Size_t TPolyLineShape::SetSizeAttribute(Size_t size)
{
   Size_t currentSize = GetSizeAttribute();
   if (size != currentSize) {
      SetLineWidth(Width_t(size));
      SetMarkerSize(size);
   }
   return currentSize;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set new style for this line.
/// Returns:
///          previous value of the line style
 
Style_t TPolyLineShape::SetStyleAttribute(Style_t style)
{
   Style_t s = 0;
   s = GetStyleAttribute();
   SetLineStyle(style);
   SetMarkerStyle(style);
   return s;
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
void TPolyLineShape::SetShape(TShape *shape)
{
   SafeDelete(fShape)
   fShape = shape;
}
 
////////////////////////////////////////////////////////////////////////////////
///to be documented
 
Int_t TPolyLineShape::Size() const
{
   return fPoints ? fPoints->Size():0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return total X3D size of this shape with its attributes.
 
void TPolyLineShape::Sizeof3D() const
{
   TPolyLineShape *line = (TPolyLineShape *)this;
   if (fLineFlag )
      line->CreateX3DSize(kFALSE);
   else
      line->CreateX3DSize(kTRUE);
   if (fSizeX3D) {
      gSize3D.numPoints += fSizeX3D->numPoints;
      gSize3D.numSegs   += fSizeX3D->numSegs;
      gSize3D.numPolys  += fSizeX3D->numPolys;
   }
   else Error("Sizeof3D()","buffer size has not been defined yet");
}