ROOT logo
ROOT » GRAF3D » EVE » TEveProjection

class TEveProjection

 Base-class for non-linear projections.

 Enables to define an external center of distortion and a scale to
 fixate a bounding box of a projected point.

Function Members (Methods)

    This is an abstract class, constructors will not be documented.
    Look at the header to check for available constructors.

virtual Bool_tAcceptSegment(TEveVector&, TEveVector&, Float_t)
voidAddPreScaleEntry(Int_t coord, Float_t max_val, Float_t scale)
voidChangePreScaleEntry(Int_t coord, Int_t entry, Float_t new_scale)
static TClass*Class()
Float_tGetDistortion() const
Float_tGetFixR() const
Float_tGetFixZ() const
TEveProjection::EGeoMode_eGetGeoMode() const
Float_tGetLimit(Int_t i, Bool_t pos)
Float_tGetMaxTrackStep() const
const Char_t*GetName() const
Float_tGetPastFixRFac() const
Float_tGetPastFixZFac() const
virtual Float_t*GetProjectedCenter()
virtual Float_tGetScreenVal(Int_t ax, Float_t value)
TEveProjection::EPType_eGetType() const
Bool_tGetUsePreScale() const
virtual Float_tGetValForScreenPos(Int_t ax, Float_t value)
virtual Bool_tIs2D() const
virtual Bool_tIs3D() const
virtual TClass*IsA() const
TEveProjection&operator=(const TEveProjection&)
voidPreScalePoint(Float_t& x, Float_t& y)
voidPreScalePoint(Float_t& x, Float_t& y, Float_t& z)
virtual voidProjectPoint(Float_t& x, Float_t& y, Float_t& z, Float_t d, TEveProjection::EPProc_e p = kPP_Full)
virtual voidProjectPointdv(Double_t* v, Float_t d)
virtual voidProjectPointfv(Float_t* v, Float_t d)
virtual voidProjectVector(TEveVector& v, Float_t d)
virtual voidSetCenter(TEveVector& v)
virtual voidSetDirectionalVector(Int_t screenAxis, TEveVector& vec)
voidSetDistortion(Float_t d)
voidSetFixR(Float_t x)
voidSetFixZ(Float_t x)
voidSetGeoMode(TEveProjection::EGeoMode_e m)
voidSetMaxTrackStep(Float_t x)
voidSetName(const Char_t* txt)
voidSetPastFixRFac(Float_t x)
voidSetPastFixZFac(Float_t x)
voidSetType(TEveProjection::EPType_e t)
voidSetUsePreScale(Bool_t x)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual voidUpdateLimit()
voidPreScaleVariable(Int_t dim, Float_t& v)

Data Members

enum EPType_e { kPT_Unknown
enum EPProc_e { kPP_Plane
enum EGeoMode_e { kGM_Unknown
static Float_tfgEpsresolution of projected points
TEveVectorfCentercenter of distortion
Float_tfFixRradius from which scaling remains constant
Float_tfFixZz-coordinate from which scaling remains constant
TEveProjection::EGeoMode_efGeoModestrategy of polygon projection (what to try first)
TEveVectorfLowLimitconvergence of point +infinity
Float_tfMaxTrackStepmaximum distance between two points on a track
Float_tfPastFixRFacrelative scaling factor beyond fFixR as 10^x
Float_tfPastFixRScalerelative scaling beyond fFixR
Float_tfPastFixZFacrelative scaling factor beyond fFixZ as 10^x
Float_tfPastFixZScalerelative scaling beyond fFixZ
vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >fPreScales[3]scaling before the distortion
Float_tfScaleRscale factor to keep projected radius at fFixR fixed
Float_tfScaleZscale factor to keep projected z-coordinate at fFixZ fixed
TEveVectorfUpLimitconvergence of point -infinity
Bool_tfUsePreScaleuse pre-scaling
TEveVectorfZeroPosValprojected origin (0, 0, 0)

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

void ProjectPointfv(Float_t* v, Float_t d)
 Project float array.
void ProjectPointdv(Double_t* v, Float_t d)
 Project double array.
 This is a bit piggish as we convert the doubles to floats and back.
void ProjectVector(TEveVector& v, Float_t d)
 Project TEveVector.
void PreScaleVariable(Int_t dim, Float_t& v)
 Pre-scale single variable with pre-scale entry dim.
void PreScalePoint(Float_t& x, Float_t& y)
 Pre-scale point (x, y) in projected coordinates for 2D projections:
   RhoZ ~ (rho, z)
   RPhi ~ (r, phi), scaling phi doesn't make much sense.
void PreScalePoint(Float_t& x, Float_t& y, Float_t& z)
 Pre-scale point (x, y, z) in projected coordinates for 3D projection.
void AddPreScaleEntry(Int_t coord, Float_t max_val, Float_t scale)
 Add new scaling range for given coordinate.
  coord    0 ~ x, 1 ~ y, 2 ~ z
  value    value of input coordinate from which to apply this scale;
  scale    the scale to apply from value onwards.

 NOTE: If pre-scaling is combined with center-displaced then
 the scale of the central region should be 1. This limitation
 can be removed but will cost CPU.
void ChangePreScaleEntry(Int_t coord, Int_t entry, Float_t new_scale)
 Change scale for given entry and coordinate.

 NOTE: If the first entry you created used other value than 0,
 one entry (covering range from 0 to this value) was created
void ClearPreScales()
 Clear all pre-scaling information.
void UpdateLimit()
 Update convergence in +inf and -inf.
void SetDistortion(Float_t d)
 Set distortion.
void SetFixR(Float_t x)
 Set fixed radius.
void SetFixZ(Float_t x)
 Set fixed radius.
void SetPastFixRFac(Float_t x)
 Set 2's-exponent for relative scaling beyond FixR.
void SetPastFixZFac(Float_t x)
 Set 2's-exponent for relative scaling beyond FixZ.
void SetDirectionalVector(Int_t screenAxis, TEveVector& vec)
 Get vector for axis in a projected space.
Float_t GetValForScreenPos(Int_t ax, Float_t value)
 Inverse projection.
Float_t GetScreenVal(Int_t ax, Float_t value)
 Project point on given axis and return projected value.
virtual ~TEveProjection()
Bool_t Is2D() const
Bool_t Is3D() const
void ProjectPoint(Float_t& x, Float_t& y, Float_t& z, Float_t d, TEveProjection::EPProc_e p = kPP_Full)
const Char_t* GetName() const
{ return fName.Data(); }
void SetName(const Char_t* txt)
{ fName = txt; }
void SetCenter(TEveVector& v)
{ fCenter = v; UpdateLimit(); }
Float_t* GetProjectedCenter()
{ return fCenter.Arr(); }
void SetType(TEveProjection::EPType_e t)
{ fType = t; }
EPType_e GetType() const
{ return fType; }
void SetGeoMode(TEveProjection::EGeoMode_e m)
{ fGeoMode = m; }
EGeoMode_e GetGeoMode() const
{ return fGeoMode; }
Bool_t GetUsePreScale() const
{ return fUsePreScale; }
void SetUsePreScale(Bool_t x)
{ fUsePreScale = x; }
Float_t GetDistortion() const
{ return fDistortion; }
Float_t GetFixR() const
{ return fFixR; }
Float_t GetFixZ() const
{ return fFixZ; }
Float_t GetPastFixRFac() const
{ return fPastFixRFac; }
Float_t GetPastFixZFac() const
{ return fPastFixZFac; }
Float_t GetMaxTrackStep() const
{ return fMaxTrackStep; }
void SetMaxTrackStep(Float_t x)
{ fMaxTrackStep = TMath::Max(x, 1.0f); }
Bool_t AcceptSegment(TEveVector& , TEveVector& , Float_t )
{ return kTRUE; }
Float_t GetLimit(Int_t i, Bool_t pos)
{ return pos ? fUpLimit[i] : fLowLimit[i]; }