TPolyLine3D

class TPolyLine3D : public TObject, public TAttLine, public TAtt3D

    public:

                        TPolyLine3D()
                        TPolyLine3D(Int_t n, Option_t* option)
                        TPolyLine3D(Int_t n, Float_t* p, Option_t* option)
                        TPolyLine3D(Int_t n, Double_t* p, Option_t* option)
                        TPolyLine3D(Int_t n, Float_t* x, Float_t* y, Float_t* z, Option_t* option)
                        TPolyLine3D(Int_t n, Double_t* x, Double_t* y, Double_t* z, Option_t* option)
                        TPolyLine3D(const TPolyLine3D& polylin)
                virtual ~TPolyLine3D()
         static TClass* Class()
           virtual void Copy(TObject& polyline) const
          virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
           virtual void Draw(Option_t* option)
            static void DrawOutlineCube(TList* outline, Double_t* rmin, Double_t* rmax)
           virtual void DrawPolyLine(Int_t n, Float_t* p, Option_t* option)
           virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
                  Int_t GetLastPoint() const
                  Int_t GetN() const
      virtual Option_t* GetOption() const
               Float_t* GetP() const
        virtual TClass* IsA() const
           virtual void ls(Option_t* option) const
          virtual Int_t Merge(TCollection* list)
           virtual void Paint(Option_t* option)
           virtual void PaintPolyLine(Int_t n, Float_t* p, Option_t* option)
           virtual void PaintPolyLine(Int_t n, Double_t* p, Option_t* option)
           virtual void Print(Option_t* option) const
           virtual void SavePrimitive(ofstream& out, Option_t* option)
          virtual Int_t SetNextPoint(Double_t x, Double_t y, Double_t z)
           virtual void SetOption(Option_t* option)
           virtual void SetPoint(Int_t point, Double_t x, Double_t y, Double_t z)
           virtual void SetPolyLine(Int_t n, Option_t* option)
           virtual void SetPolyLine(Int_t n, Float_t* p, Option_t* option)
           virtual void SetPolyLine(Int_t n, Double_t* p, Option_t* option)
           virtual void ShowMembers(TMemberInspector& insp, char* parent)
          virtual Int_t Size() const
           virtual void Sizeof3D() const
           virtual void Streamer(TBuffer& b)
                   void StreamerNVirtual(TBuffer& b)

Data Members

    protected:

         Int_t fN          Number of points
      Float_t* fP          [3*fN] Array of 3-D coordinates  (x,y,z)
       TString fOption     options
        UInt_t fGLList     !The list number for OpenGL view
         Int_t fLastPoint  The index of the last filled point

See also

THelix

Class Description

 PolyLine3D is a 3-dimensional polyline. It has 4 different constructors.

   First one, without any parameters TPolyLine3D(), we call 'default
 constructor' and it's used in a case that just an initialisation is
 needed (i.e. pointer declaration).

       Example:
                 TPolyLine3D *pl1 = new TPolyLine3D;


   Second one is 'normal constructor' with, usually, one parameter
 n (number of points), and it just allocates a space for the points.

       Example:
                 TPolyLine3D pl1(150);


   Third one allocates a space for the points, and also makes
 initialisation from the given array.

       Example:
                 TPolyLine3D pl1(150, pointerToAnArray);


   Fourth one is, almost, similar to the constructor above, except
 initialisation is provided with three independent arrays (array of
 x coordinates, y coordinates and z coordinates).

       Example:
                 TPolyLine3D pl1(150, xArray, yArray, zArray);

 Example:
   void pl3() {
      TCanvas *c1 = new TCanvas("c1");
      TView *view = new TView(1);
      view->SetRange(0,0,0,2,2,2);
      const Int_t n = 100;
      TPolyLine3D *l = new TPolyLine3D(n);
      for (Int_t i=0;i<n;i++) {
         Double_t x = 2*gRandom->Rndm();
         Double_t y = 2*gRandom->Rndm();
         Double_t z = 2*gRandom->Rndm();
         l->SetPoint(i,x,y,z);
      }
      l->Draw();
   }

 3-D polyline default constructor.

 3-D polyline normal constructor with initialization to 0.
 If n < 0 the default size (2 points) is set.

 3-D polyline normal constructor. Polyline is intialized with p.
 If n < 0 the default size (2 points) is set.

 3-D polyline normal constructor. Polyline is initialized with p
 (cast to float). If n < 0 the default size (2 points) is set.

 3-D polyline normal constructor. Polyline is initialized withe the
 x, y ,z arrays. If n < 0 the default size (2 points) is set.

 3-D polyline normal constructor. Polyline is initialized withe the
 x, y, z arrays (which are cast to float).
 If n < 0 the default size (2 points) is set.

 3-D polyline destructor.

 3-D polyline copy ctor.

 Copy polyline to polyline obj.

 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.

 Draw this 3-D polyline with its current attributes.

 Draw cube outline with 3d polylines.

      x = fRmin[0]        X = fRmax[0]
      y = fRmin[1]        Y = fRmax[1]
      z = fRmin[2]        Z = fRmax[2]


            (x,Y,Z) +---------+ (X,Y,Z)
                   /         /|
                  /         / |
                 /         /  |
        (x,y,Z) +---------+   |
                |         |   + (X,Y,z)
                |         |  
                |         | 
                |         |
                +---------+
             (x,y,z)   (X,y,z)

 Draw 3-D polyline with new coordinates. Creates a new polyline which
 will be adopted by the pad in which it is drawn. Does not change the
 original polyline (should be static method).

 Execute action corresponding to one event.

 List this 3-D polyline.

 Merge polylines in the collection in this polyline

 Paint this 3-D polyline with its current attributes.
 Option could be 'x3d', and it means that output
 will be performed by X3D package.

 Draw this 3-D polyline with new coordinates from p. Does not change
 original polyline. Should be static method.

 Draw this 3-D polyline with new coordinates from p. Does not change
 original polyline. Should be static method.

 Dump this 3-D polyline with its attributes on stdout.

 Save primitive as a C++ statement(s) on output stream.

 Set point following LastPoint to x, y, z.
 Returns index of the point (new last point).

 Set point n to x, y, z.
 If n is more then the current TPolyLine3D size (n > fN) then
 the polyline will be resized to contain at least n points.

 Re-initialize polyline with n points (0,0,0).

 Re-initialize polyline with n points from p. If p=0 initialize with 0.

 Re-initialize polyline with n points from p. If p=0 initialize with 0.

 Return total X3D size of this 3-D polyline with its attributes.

 Stream a 3-D polyline object.

Inline Functions

              Int_t GetLastPoint() const
              Int_t GetN() const
           Float_t* GetP() const
          Option_t* GetOption() const
               void SetOption(Option_t* option)
              Int_t Size() const
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void StreamerNVirtual(TBuffer& b)