library: libGraf3d #include "TPolyMarker3D.h"

# TPolyMarker3D

class description - source file - inheritance tree (.ps)

## class TPolyMarker3D : public TObject, public TAttMarker, public TAtt3D

| Inheritance Chart:

`TObject`

`TAttMarker`

`TAtt3D`

<-

`TPolyMarker3D`

        public:

                            TPolyMarker3D()
                            TPolyMarker3D(Int_t n, Marker_t marker = 1, Option_t* option)
                            TPolyMarker3D(Int_t n, Float_t* p, Marker_t marker = 1, Option_t* option)
                            TPolyMarker3D(Int_t n, Double_t* p, Marker_t marker = 1, Option_t* option)
                            TPolyMarker3D(const TPolyMarker3D& polymarker)
                    virtual ~TPolyMarker3D()
             static TClass* Class()
               virtual void Copy(TObject& polymarker) const
              virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
               virtual void Draw(Option_t* option)
               virtual void DrawPolyMarker(Int_t n, Float_t* p, Marker_t marker, Option_t* option)
               virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
              virtual Int_t GetLastPoint() const
              virtual Int_t GetN() const
          virtual Option_t* GetOption() const
           virtual Float_t* GetP() const
            virtual TClass* IsA() const
               virtual void ls(Option_t* option) const
              virtual Int_t Merge(TCollection* list)
             TPolyMarker3D& operator=(const TPolyMarker3D&)
               virtual void Paint(Option_t* option)
                static void PaintH3(TH1* h, Option_t* option)
               virtual void PaintPolyMarker(Int_t n, Float_t* p, Marker_t marker, 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)
                       void SetPoint(Int_t n, Double_t x, Double_t y, Double_t z)
               virtual void SetPolyMarker(Int_t n, Float_t* p, Marker_t marker, Option_t* option)
               virtual void SetPolyMarker(Int_t n, Double_t* p, Marker_t marker, Option_t* option)
               virtual void ShowMembers(TMemberInspector& insp, char* parent)
              virtual Int_t Size() const
               virtual void Sizeof3D() const
                static void SizeofH3(TH1* h)
               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 X,Y,Z coordinates
           TString fOption     options
            UInt_t fGLList     !The list number for OpenGL view
             Int_t fLastPoint  The index of the last filled point

## Class Description

     PolyMarker3D is a 3D polymarker. It has three constructors.

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

           Example:
                     TPolyMarker3D *pm = new TPolyMarker3D;

       Second one, takes, usually, two parameters, n (number of points) and
     marker (marker style). Third parameter is optional.

           Example:
                     TPolyMarker3D (150, 1);

       Third one takes, usually, three parameters, n (number of points), *p
     (pointer to an array of 3D points), and marker (marker style). Fourth
     parameter is optional.

           Example:
                     Float_t *ptr = new Float_t [150*3];
                             ... ... ...
                             ... ... ...
                             ... ... ...

                     TPolyMarker3D (150, ptr, 1);

TPolyMarker3D()

     3-D polymarker default constructor.

TPolyMarker3D(Int_t n, Marker_t marker, Option_t *option)

     3-D polymarker normal constructor with initialization to 0.

TPolyMarker3D(Int_t n, Float_t *p, Marker_t marker, Option_t *option)

     3-D polymarker constructor. Polymarker is initialized with p.

TPolyMarker3D(Int_t n, Double_t *p, Marker_t marker, Option_t *option)

     3-D polymarker constructor. Polymarker is initialized with p
     (cast to float).

~TPolyMarker3D()

     3-D polymarker destructor.

TPolyMarker3D(const TPolyMarker3D &polymarker) : TObject(polymarker), TAttMarker(polymarker), TAtt3D(polymarker)

     3-D polymarker copy ctor.

void Copy(TObject &obj) const

     Copy polymarker to polymarker obj.

Int_t DistancetoPrimitive(Int_t px, Int_t py)

     Compute distance from point px,py to a 3-D polymarker.
     Compute the closest distance of approach from point px,py to each segment
     of the polymarker.
     Returns when the distance found is below DistanceMaximum.
     The distance is computed in pixels units.

void Draw(Option_t *option)

     Draws 3-D polymarker with its current attributes.

void DrawPolyMarker(Int_t n, Float_t *p, Marker_t, Option_t *option)

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

void ExecuteEvent(Int_t event, Int_t px, Int_t py)

     Execute action corresponding to one event.

void ls(Option_t *option) const

     List this 3-D polymarker.

Int_t Merge(TCollection *list)

     Merge polymarkers in the collection in this polymarker

void Paint(Option_t *option)

     Paint this 3-D polymarker.
     Option could be 'x3d', and it means that output
     will be performed by X3D package.

void PaintH3(TH1 *h, Option_t *option)

     Paint 3-d histogram h with 3-d polymarkers.

void PaintPolyMarker(Int_t n, Float_t *p, Marker_t, Option_t *)

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

void Print(Option_t *option) const

     Print 3-D polymarker with its attributes on stdout.

void SavePrimitive(ofstream &out, Option_t *)

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

Int_t SetNextPoint(Double_t x, Double_t y, Double_t z)

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

void SetPoint(Int_t n, Double_t x, Double_t y, Double_t z)

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

void SetPolyMarker(Int_t n, Float_t *p, Marker_t marker, Option_t *option)

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

void SetPolyMarker(Int_t n, Double_t *p, Marker_t marker, Option_t *option)

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

void Sizeof3D() const

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

void SizeofH3(TH1 *h)

     Return total size of 3-D histogram h.

void Streamer(TBuffer &b)

     Stream a 3-D polymarker object.

### Inline Functions

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

Author: Nenad Buncic 21/08/95
Last update: root/g3d:$Name: $:$Id: TPolyMarker3D.cxx,v 1.16 2003/07/02 20:04:01 brun Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *