Location: ROOT » GRAF3D » EVE » TEveProjection

Quick Links: ROOT Homepage Class Index Class Hierarchy Search

Source: header file source file viewCVS header viewCVS 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()
Float_t	GetLimit(Int_t i, Bool_t pos)
const char*	GetName()
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()
Bool_t	GetUsePreScale() const
virtual Float_t	GetValForScreenPos(Int_t ax, Float_t value)
virtual TClass*	IsA() const
TEveProjection&	operator=(const TEveProjection&)
void	PreScalePoint(Float_t& x, Float_t& y)
virtual void	ProjectPoint(Float_t&, Float_t&, Float_t&, TEveProjection::EPProc_e p = kPP_Full)
virtual void	ProjectPointFv(Float_t* v)
virtual void	ProjectVector(TEveVector& v)
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	SetName(const char* 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()

Data Members

public:

enum EPType_e {	kPT_Unknown
	kPT_RPhi
	kPT_RhoZ
	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
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[2]	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 ProjectVector(TEveVector& v)

 Project TEveVector.

void PreScalePoint(Float_t& x, Float_t& y)

 Pre-scale point (v0, v1) in projected coordinates:
   RhoZ ~ (rho, z)
   RPhi ~ (r, phi), scaling phi doesn't make much sense.

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;
  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()

{}

void ProjectPoint(Float_t& , Float_t& , Float_t& , TEveProjection::EPProc_e p = kPP_Full)

void ProjectPointFv(Float_t* v)

{ ProjectPoint(v[0], v[1], v[2]); }

const char* GetName()

{ return fName.Data(); }

void SetName(const char* 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()

{ return fType; }

void SetGeoMode(TEveProjection::EGeoMode_e m)

{ fGeoMode = m; }

EGeoMode_e GetGeoMode()

{ return fGeoMode; }

Bool_t GetUsePreScale()

{ return fUsePreScale; }

void SetUsePreScale(Bool_t x)

{ fUsePreScale = x; }

Float_t GetDistortion()

{ return fDistortion; }

Float_t GetFixR()

{ return fFixR; }

Float_t GetFixZ()

{ return fFixZ; }

Float_t GetPastFixRFac()

{ return fPastFixRFac; }

Float_t GetPastFixZFac()

{ return fPastFixZFac; }

Bool_t AcceptSegment(TEveVector& , TEveVector& , Float_t )

{ return kTRUE; }

Float_t GetLimit(Int_t i, Bool_t pos)

{ return pos ? fUpLimit[i] : fLowLimit[i]; }

Last change: root/eve:$Id: TEveProjections.h 24447 2008-06-20 20:55:53Z matevz $
Last generated: 2008-06-25 08:37
Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.