Quick Links: ROOT Homepage Class Index Class Hierarchy

Source: header file source file viewVC header viewVC source

Sections: class description function members data members class charts

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.

public:

virtual	~TEveProjection()
virtual Bool_t	AcceptSegment(TEveVector&, TEveVector&, Float_t)
void	AddPreScaleEntry(Int_t coord, Float_t max_val, Float_t scale)
void	ChangePreScaleEntry(Int_t coord, Int_t entry, Float_t new_scale)
static TClass*	Class()
void	ClearPreScales()
Float_t	GetDistortion() const
Float_t	GetFixR() const
Float_t	GetFixZ() const
TEveProjection::EGeoMode_e	GetGeoMode() const
Float_t	GetLimit(Int_t i, Bool_t pos)
Float_t	GetMaxTrackStep() const
const Char_t*	GetName() const
Float_t	GetPastFixRFac() const
Float_t	GetPastFixZFac() const
virtual Float_t*	GetProjectedCenter()
virtual Float_t	GetScreenVal(Int_t ax, Float_t value)
TEveProjection::EPType_e	GetType() const
Bool_t	GetUsePreScale() const
virtual Float_t	GetValForScreenPos(Int_t ax, Float_t value)
virtual Bool_t	Is2D() const
virtual Bool_t	Is3D() const
virtual TClass*	IsA() const
TEveProjection&	operator=(const TEveProjection&)
void	PreScalePoint(Float_t& x, Float_t& y)
void	PreScalePoint(Float_t& x, Float_t& y, Float_t& z)
virtual void	ProjectPoint(Float_t& x, Float_t& y, Float_t& z, Float_t d, TEveProjection::EPProc_e p = kPP_Full)
virtual void	ProjectPointdv(Double_t* v, Float_t d)
virtual void	ProjectPointfv(Float_t* v, Float_t d)
virtual void	ProjectVector(TEveVector& v, Float_t d)
virtual void	SetCenter(TEveVector& v)
virtual void	SetDirectionalVector(Int_t screenAxis, TEveVector& vec)
void	SetDistortion(Float_t d)
void	SetFixR(Float_t x)
void	SetFixZ(Float_t x)
void	SetGeoMode(TEveProjection::EGeoMode_e m)
void	SetMaxTrackStep(Float_t x)
void	SetName(const Char_t* txt)
void	SetPastFixRFac(Float_t x)
void	SetPastFixZFac(Float_t x)
void	SetType(TEveProjection::EPType_e t)
void	SetUsePreScale(Bool_t x)
virtual void	ShowMembers(TMemberInspector& insp, char* parent)
virtual void	Streamer(TBuffer& b)
void	StreamerNVirtual(TBuffer& b)
virtual void	UpdateLimit()

protected:

void	PreScaleVariable(Int_t dim, Float_t& v)

Data Members

public:

enum EPType_e {	kPT_Unknown
	kPT_RPhi
	kPT_RhoZ
	kPT_3D
	kPT_End
};
enum EPProc_e {	kPP_Plane
	kPP_Distort
	kPP_Full
};
enum EGeoMode_e {	kGM_Unknown
	kGM_Polygons
	kGM_Segments
};

public:

static Float_t	fgEps	resolution of projected points

protected:

TEveVector	fCenter	center of distortion
Float_t	fDistortion	distortion
Float_t	fFixR	radius from which scaling remains constant
Float_t	fFixZ	z-coordinate from which scaling remains constant
TEveProjection::EGeoMode_e	fGeoMode	strategy of polygon projection (what to try first)
TEveVector	fLowLimit	convergence of point +infinity
Float_t	fMaxTrackStep	maximum distance between two points on a track
TString	fName	name
Float_t	fPastFixRFac	relative scaling factor beyond fFixR as 10^x
Float_t	fPastFixRScale	relative scaling beyond fFixR
Float_t	fPastFixZFac	relative scaling factor beyond fFixZ as 10^x
Float_t	fPastFixZScale	relative scaling beyond fFixZ
vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >	fPreScales[3]	scaling before the distortion
Float_t	fScaleR	scale factor to keep projected radius at fFixR fixed
Float_t	fScaleZ	scale factor to keep projected z-coordinate at fFixZ fixed
TEveProjection::EPType_e	fType	type
TEveVector	fUpLimit	convergence of point -infinity
Bool_t	fUsePreScale	use pre-scaling
TEveVector	fZeroPosVal	projected origin (0, 0, 0)

Class Charts

Inheritance Inherited Members Includes Libraries

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.
 Arguments:
  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
 automatically.

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]; }