#include <Transform3D.h>

Inheritance diagram for HepGeom::Transform3D:

Data Structures
class	Transform3D_row

Public Member Functions
	Transform3D ()

	Transform3D (const CLHEP::HepRotation &m, const CLHEP::Hep3Vector &v)

	Transform3D (const Point3D< double > &fr0, const Point3D< double > &fr1, const Point3D< double > &fr2, const Point3D< double > &to0, const Point3D< double > &to1, const Point3D< double > &to2)

	Transform3D (const Transform3D &m)

	~Transform3D ()

const Transform3D_row	operator[] (int) const

double	operator() (int, int) const

double	xx () const

double	xy () const

double	xz () const

double	yx () const

double	yy () const

double	yz () const

double	zx () const

double	zy () const

double	zz () const

double	dx () const

double	dy () const

double	dz () const

Transform3D &	operator= (const Transform3D &m)

void	setIdentity ()

Transform3D	inverse () const

Transform3D	operator* (const Transform3D &b) const

void	getDecomposition (Scale3D &scale, Rotate3D &rotation, Translate3D &translation) const

bool	isNear (const Transform3D &t, double tolerance=2.2E-14) const

CLHEP::HepRotation	getRotation () const

CLHEP::Hep3Vector	getTranslation () const

bool	operator== (const Transform3D &transform) const

bool	operator!= (const Transform3D &transform) const

Static Public Attributes
static const Transform3D	Identity = Transform3D ()

Protected Member Functions
	Transform3D (double XX, double XY, double XZ, double DX, double YX, double YY, double YZ, double DY, double ZX, double ZY, double ZZ, double DZ)

void	setTransform (double XX, double XY, double XZ, double DX, double YX, double YY, double YZ, double DY, double ZX, double ZY, double ZZ, double DZ)

Protected Attributes
double	xx_

double	xy_

double	xz_

double	dx_

double	yx_

double	yy_

double	yz_

double	dy_

double	zx_

double	zy_

double	zz_

double	dz_

Detailed Description

Class for transformation of 3D geometrical objects. It allows different translations, rotations, scalings and reflections. Several specialized classes are derived from it:

TranslateX3D, TranslateY3D, TranslateZ3D, Translate3D,
RotateX3D, RotateY3D, RotateZ3D, Rotate3D,
ScaleX3D, ScaleY3D, ScaleZ3D, Scale3D,
ReflectX3D, ReflectY3D, ReflectZ3D, Reflect3D.

The idea behind these classes is to provide some additional constructors for Transform3D, they normally should not be used as separate classes.

Example:

HepGeom::Transform3D m;

m = HepGeom::TranslateX3D(10.*cm);

Remark: For the reason that the operator* is left associative, the notation

v2 = m3*(m2*(m1*v1));

is much more effective then the notation

v2 = m3*m2*m1*v1;

In the first case three operations Transform3D*Vector3D are executed, in the second case two operations Transform3D*Transform3D and one Transform3D*Vector3D are performed. Transform3D*Transform3D is roughly three times slower than Transform3D*Vector3D.

Author: Evgue.nosp@m.ni.T.nosp@m.chern.nosp@m.iaev.nosp@m.@cern.nosp@m..ch

Definition at line 171 of file Transform3D.h.

Constructor & Destructor Documentation

HepGeom::Transform3D::Transform3D	(	double	XX,
		double	XY,
		double	XZ,
		double	DX,
		double	YX,
		double	YY,
		double	YZ,
		double	DY,
		double	ZX,
		double	ZY,
		double	ZZ,
		double	DZ
	)

inlineprotected

Definition at line 178 of file Transform3D.h.

       : xx_(XX), xy_(XY), xz_(XZ), dx_(DX),
     yx_(YX), yy_(YY), yz_(YZ), dy_(DY),
     zx_(ZX), zy_(ZY), zz_(ZZ), dz_(DZ) {}

HepGeom::Transform3D::Transform3D ( )

inline

Default constructor - sets the Identity transformation.

Definition at line 211 of file Transform3D.h.

Referenced by inverse(), and operator*().

       : xx_(1), xy_(0), xz_(0), dx_(0),
     yx_(0), yy_(1), yz_(0), dy_(0),
     zx_(0), zy_(0), zz_(1), dz_(0) {}

HepGeom::Transform3D::Transform3D	(	const CLHEP::HepRotation &	m,
		const CLHEP::Hep3Vector &	v
	)

inline

Constructor: rotation and then translation.

HepGeom::Transform3D::Transform3D	(	const Point3D< double > &	fr0,
		const Point3D< double > &	fr1,
		const Point3D< double > &	fr2,
		const Point3D< double > &	to0,
		const Point3D< double > &	to1,
		const Point3D< double > &	to2
	)

Constructor: transformation of basis (assumed - no reflection).

Definition at line 63 of file Transform3D.cc.

References HepGeom::BasicVector3D< T >::cross(), setIdentity(), setTransform(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

   {
     Vector3D<double> x1,y1,z1, x2,y2,z2;
     x1 = (fr1 - fr0).unit();
     y1 = (fr2 - fr0).unit();
     x2 = (to1 - to0).unit();
     y2 = (to2 - to0).unit();
     
     //   C H E C K   A N G L E S
     
     double cos1, cos2;
     cos1 = x1*y1;
     cos2 = x2*y2;
     
     if (std::abs(1.0-cos1) <= 0.000001 || std::abs(1.0-cos2) <= 0.000001) {
       std::cerr << "Transform3D: zero angle between axes" << std::endl;
       setIdentity();
     }else{
       if (std::abs(cos1-cos2) > 0.000001) {
     std::cerr << "Transform3D: angles between axes are not equal"
           << std::endl;
       }
       
       //   F I N D   R O T A T I O N   M A T R I X
       
       z1 = (x1.cross(y1)).unit();
       y1  = z1.cross(x1);
     
       z2 = (x2.cross(y2)).unit();
       y2  = z2.cross(x2);
       
       double detxx =  (y1.y()*z1.z() - z1.y()*y1.z());
       double detxy = -(y1.x()*z1.z() - z1.x()*y1.z());
       double detxz =  (y1.x()*z1.y() - z1.x()*y1.y());
       double detyx = -(x1.y()*z1.z() - z1.y()*x1.z());
       double detyy =  (x1.x()*z1.z() - z1.x()*x1.z());
       double detyz = -(x1.x()*z1.y() - z1.x()*x1.y());
       double detzx =  (x1.y()*y1.z() - y1.y()*x1.z());
       double detzy = -(x1.x()*y1.z() - y1.x()*x1.z());
       double detzz =  (x1.x()*y1.y() - y1.x()*x1.y());
  
       double txx = x2.x()*detxx + y2.x()*detyx + z2.x()*detzx; 
       double txy = x2.x()*detxy + y2.x()*detyy + z2.x()*detzy; 
       double txz = x2.x()*detxz + y2.x()*detyz + z2.x()*detzz; 
       double tyx = x2.y()*detxx + y2.y()*detyx + z2.y()*detzx; 
       double tyy = x2.y()*detxy + y2.y()*detyy + z2.y()*detzy; 
       double tyz = x2.y()*detxz + y2.y()*detyz + z2.y()*detzz; 
       double tzx = x2.z()*detxx + y2.z()*detyx + z2.z()*detzx; 
       double tzy = x2.z()*detxy + y2.z()*detyy + z2.z()*detzy; 
       double tzz = x2.z()*detxz + y2.z()*detyz + z2.z()*detzz; 
 
       //   S E T    T R A N S F O R M A T I O N 
 
       double dx1 = fr0.x(), dy1 = fr0.y(), dz1 = fr0.z();
       double dx2 = to0.x(), dy2 = to0.y(), dz2 = to0.z();
 
       setTransform(txx, txy, txz, dx2-txx*dx1-txy*dy1-txz*dz1,
            tyx, tyy, tyz, dy2-tyx*dx1-tyy*dy1-tyz*dz1,
            tzx, tzy, tzz, dz2-tzx*dx1-tzy*dy1-tzz*dz1);
     }
   }

HepGeom::Transform3D::Transform3D ( const Transform3D & m )

inline

Copy constructor.

Definition at line 231 of file Transform3D.h.

       : xx_(m.xx_), xy_(m.xy_), xz_(m.xz_), dx_(m.dx_),
     yx_(m.yx_), yy_(m.yy_), yz_(m.yz_), dy_(m.dy_),
     zx_(m.zx_), zy_(m.zy_), zz_(m.zz_), dz_(m.dz_) {}

HepGeom::Transform3D::~Transform3D ( )

inline

Destructor. Virtual for now as some persistency mechanism needs that, in future releases this might go away again.

Definition at line 241 of file Transform3D.h.

241 { /* nop */ }

Member Function Documentation

double HepGeom::Transform3D::dx ( ) const

inline

Gets dx-element of the transformation matrix.

Definition at line 279 of file Transform3D.h.

References dx_.

Referenced by G4PhysicalVolumeModel::DescribeAndDescend(), dor94di(), dor94fs(), dor94fv(), dor94ho(), dor94lo(), fluini(), hijcsc(), lmprin(), lzp(), HepGeom::operator*(), plot(), pygamm(), pygrvd(), pygrvl(), pygrvm(), pygrvs(), pygrvv(), pymsin(), pyqqbh(), qgaus(), quench(), rtsafe(), HepGeom::Point3D< float >::transform(), HepGeom::Point3D< double >::transform(), vahmsd(), and vegas().

279 { return dx_; }

HepGeom::Transform3D::dx_

double dx_

Definition: Transform3D.h:173

double HepGeom::Transform3D::dy ( ) const

inline

Gets dy-element of the transformation matrix.

Definition at line 282 of file Transform3D.h.

References dy_.

Referenced by G4PhysicalVolumeModel::DescribeAndDescend(), diadif(), dispt(), distcm(), distr(), distrc(), hatest(), hijcsc(), HepGeom::operator*(), plot(), pymsin(), pyplot(), quench(), HepGeom::Point3D< float >::transform(), and HepGeom::Point3D< double >::transform().

282 { return dy_; }

HepGeom::Transform3D::dy_

double dy_

Definition: Transform3D.h:173

double HepGeom::Transform3D::dz ( ) const

inline

Gets dz-element of the transformation matrix.

Definition at line 285 of file Transform3D.h.

References dz_.

Referenced by btocho2(), G4PhysicalVolumeModel::DescribeAndDescend(), hijcsc(), lzp(), HepGeom::operator*(), HepGeom::Point3D< float >::transform(), and HepGeom::Point3D< double >::transform().

285 { return dz_; }

HepGeom::Transform3D::dz_

double dz_

Definition: Transform3D.h:173

void HepGeom::Transform3D::getDecomposition	(	Scale3D &	scale,
		Rotate3D &	rotation,
		Translate3D &	translation
	)		const

Decomposition of general transformation. This function gets decomposition of the transformation in three consequentive specific transformations: Scale3D, then Rotate3D, then Translate3, i.e.

Transform3D = Translate3D * Rotate3D * Scale3D

Parameters

scale	output: scaling transformation; if there was a reflection, then scale factor for z-component (scale(2,2)) will be negative.
rotation	output: rotation transformaion.
translation	output: translation transformaion.

Definition at line 174 of file Transform3D.cc.

Referenced by G4AssemblyVolume::AddPlacedAssembly(), G4AssemblyVolume::AddPlacedVolume(), G4PhysicalVolumeModel::DescribeAndDescend(), G4GDMLWriteStructure::PhysvolWrite(), and G4ReflectionFactory::Place().

   {
     double sx = std::sqrt(xx_*xx_ + yx_*yx_ + zx_*zx_);
     double sy = std::sqrt(xy_*xy_ + yy_*yy_ + zy_*zy_);
     double sz = std::sqrt(xz_*xz_ + yz_*yz_ + zz_*zz_);
 
     if (xx_*(yy_*zz_-yz_*zy_) -
     xy_*(yx_*zz_-yz_*zx_) +
     xz_*(yx_*zy_-yy_*zx_) < 0) sz = -sz;
     scale.setTransform(sx,0,0,0,  0,sy,0,0, 0,0,sz,0);
     rotation.setTransform(xx_/sx,xy_/sy,xz_/sz,0,
               yx_/sx,yy_/sy,yz_/sz,0,
               zx_/sx,zy_/sy,zz_/sz,0); 
     translation.setTransform(1,0,0,dx_, 0,1,0,dy_, 0,0,1,dz_);
   }

CLHEP::HepRotation HepGeom::Transform3D::getRotation ( ) const

inline

Extracts the rotation matrix. This functions is obsolete - use getDecomposition() instead.

Referenced by G4AssemblyVolume::AddPlacedAssembly(), G4AssemblyVolume::AddPlacedVolume(), G4GMocrenFileSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::EndSavingGdd(), G4DisplacedSolid::G4DisplacedSolid(), G4PVPlacement::G4PVPlacement(), operator<<(), G4GDMLWriteStructure::PhysvolWrite(), G4VisCommandSceneAddLogo::SetNewValue(), and G4VisCommandSceneAddScale::SetNewValue().

CLHEP::Hep3Vector HepGeom::Transform3D::getTranslation ( ) const

inline

Extracts the translation vector. This functions is obsolete - use getDecomposition() instead.

Referenced by G4AssemblyVolume::AddPlacedAssembly(), G4AssemblyVolume::AddPlacedVolume(), G4GMocrenFileSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::EndSavingGdd(), G4DisplacedSolid::G4DisplacedSolid(), G4ReflectedSolid::G4ReflectedSolid(), operator<<(), G4GDMLWriteStructure::PhysvolWrite(), G4VisCommandSceneAddLogo::SetNewValue(), and G4VisCommandSceneAddScale::SetNewValue().

Transform3D HepGeom::Transform3D::inverse ( ) const

Returns the inverse transformation.

Definition at line 142 of file Transform3D.cc.

References dx_, dy_, dz_, Transform3D(), xx_, xy_, xz_, yx_, yy_, yz_, zx_, zy_, and zz_.

Referenced by G4PhysicalVolumeModel::CalculateExtent(), G4PhysicalVolumeModel::DescribeAndDescend(), G4PhysicalVolumeModel::DescribeSolid(), G4ScoringCylinder::Draw(), G4ScoringBox::Draw(), G4ScoringCylinder::DrawColumn(), G4ScoringBox::DrawColumn(), G3toG4BuildPVTree(), G3toG4MANY(), G4ReflectedSolid::G4ReflectedSolid(), GetTransform3D(), G4ReflectionFactory::Place(), SubstractSolids(), and G4GDMLWriteStructure::TraverseVolumeTree().

   {
     double detxx = yy_*zz_-yz_*zy_;
     double detxy = yx_*zz_-yz_*zx_;
     double detxz = yx_*zy_-yy_*zx_;
     double det   = xx_*detxx - xy_*detxy + xz_*detxz;
     if (det == 0) {
       std::cerr << "Transform3D::inverse error: zero determinant" << std::endl;
       return Transform3D();
     }
     det = 1./det; detxx *= det; detxy *= det; detxz *= det;
     double detyx = (xy_*zz_ - xz_*zy_)*det;
     double detyy = (xx_*zz_ - xz_*zx_)*det;
     double detyz = (xx_*zy_ - xy_*zx_)*det;
     double detzx = (xy_*yz_ - xz_*yy_)*det;
     double detzy = (xx_*yz_ - xz_*yx_)*det;
     double detzz = (xx_*yy_ - xy_*yx_)*det;
     return Transform3D
       (detxx, -detyx,  detzx, -detxx*dx_+detyx*dy_-detzx*dz_,
       -detxy,  detyy, -detzy,  detxy*dx_-detyy*dy_+detzy*dz_,
        detxz, -detyz,  detzz, -detxz*dx_+detyz*dy_-detzz*dz_);
   }

bool HepGeom::Transform3D::isNear	(	const Transform3D &	t,
		double	tolerance = `2.2E-14`
	)		const

Returns true if the difference between corresponding matrix elements is less than the tolerance.

Definition at line 204 of file Transform3D.cc.

References dx_, dy_, dz_, xx_, xy_, xz_, yx_, yy_, yz_, zx_, zy_, and zz_.

   { 
     return ( (std::abs(xx_ - t.xx_) <= tolerance) && 
          (std::abs(xy_ - t.xy_) <= tolerance) &&
          (std::abs(xz_ - t.xz_) <= tolerance) &&
          (std::abs(dx_ - t.dx_) <= tolerance) &&
          (std::abs(yx_ - t.yx_) <= tolerance) &&
          (std::abs(yy_ - t.yy_) <= tolerance) &&
          (std::abs(yz_ - t.yz_) <= tolerance) &&
          (std::abs(dy_ - t.dy_) <= tolerance) &&
          (std::abs(zx_ - t.zx_) <= tolerance) &&
          (std::abs(zy_ - t.zy_) <= tolerance) &&
          (std::abs(zz_ - t.zz_) <= tolerance) &&
          (std::abs(dz_ - t.dz_) <= tolerance) );
   }

bool HepGeom::Transform3D::operator!= ( const Transform3D & transform ) const

inline

Test for inequality.

Definition at line 353 of file Transform3D.h.

References operator==().

                                                            {
       return ! operator==(transform);
     }

double HepGeom::Transform3D::operator()	(	int	i,
		int	j
	)		const

Fortran-style subscripting: returns (i,j) element of the matrix.

Definition at line 24 of file Transform3D.cc.

References dx_, dy_, dz_, xx_, xy_, xz_, yx_, yy_, yz_, zx_, zy_, and zz_.

                                                      {
     if (i == 0) {
       if (j == 0) { return xx_; }
       if (j == 1) { return xy_; }
       if (j == 2) { return xz_; } 
       if (j == 3) { return dx_; } 
     } else if (i == 1) {
       if (j == 0) { return yx_; }
       if (j == 1) { return yy_; }
       if (j == 2) { return yz_; } 
       if (j == 3) { return dy_; } 
     } else if (i == 2) {
       if (j == 0) { return zx_; }
       if (j == 1) { return zy_; }
       if (j == 2) { return zz_; } 
       if (j == 3) { return dz_; } 
     } else if (i == 3) {
       if (j == 0) { return 0.0; }
       if (j == 1) { return 0.0; }
       if (j == 2) { return 0.0; } 
       if (j == 3) { return 1.0; } 
     } 
     std::cerr << "Transform3D subscripting: bad indeces "
           << "(" << i << "," << j << ")" << std::endl;
     return 0.0;
   }

Transform3D HepGeom::Transform3D::operator* ( const Transform3D & b ) const

Transformation by another Transform3D.

Definition at line 52 of file Transform3D.cc.

References dx_, dy_, dz_, Transform3D(), xx_, xy_, xz_, yx_, yy_, yz_, zx_, zy_, and zz_.

                                                                 {
     return Transform3D
       (xx_*b.xx_+xy_*b.yx_+xz_*b.zx_, xx_*b.xy_+xy_*b.yy_+xz_*b.zy_,
        xx_*b.xz_+xy_*b.yz_+xz_*b.zz_, xx_*b.dx_+xy_*b.dy_+xz_*b.dz_+dx_,
        yx_*b.xx_+yy_*b.yx_+yz_*b.zx_, yx_*b.xy_+yy_*b.yy_+yz_*b.zy_,
        yx_*b.xz_+yy_*b.yz_+yz_*b.zz_, yx_*b.dx_+yy_*b.dy_+yz_*b.dz_+dy_,
        zx_*b.xx_+zy_*b.yx_+zz_*b.zx_, zx_*b.xy_+zy_*b.yy_+zz_*b.zy_,
        zx_*b.xz_+zy_*b.yz_+zz_*b.zz_, zx_*b.dx_+zy_*b.dy_+zz_*b.dz_+dz_);
   }

Transform3D& HepGeom::Transform3D::operator= ( const Transform3D & m )

inline

Assignment.

Definition at line 289 of file Transform3D.h.

References dx_, dy_, dz_, xx_, xy_, xz_, yx_, yy_, yz_, zx_, zy_, and zz_.

                                                   {
       xx_= m.xx_; xy_= m.xy_; xz_= m.xz_; dx_= m.dx_;
       yx_= m.yx_; yy_= m.yy_; yz_= m.yz_; dy_= m.dy_;
       zx_= m.zx_; zy_= m.zy_; zz_= m.zz_; dz_= m.dz_;
       return *this;
     }

bool HepGeom::Transform3D::operator== ( const Transform3D & transform ) const

Test for equality.

Definition at line 221 of file Transform3D.cc.

References dx_, dy_, dz_, xx_, xy_, xz_, yx_, yy_, yz_, zx_, zy_, and zz_.

Referenced by operator!=().

   {
     return (this == &t) ? true :
       (xx_==t.xx_ && xy_==t.xy_ && xz_==t.xz_ && dx_==t.dx_ && 
        yx_==t.yx_ && yy_==t.yy_ && yz_==t.yz_ && dy_==t.dy_ &&
        zx_==t.zx_ && zy_==t.zy_ && zz_==t.zz_ && dz_==t.dz_ );
   }

const Transform3D_row HepGeom::Transform3D::operator[] ( int ) const

inline

Returns object of the helper class for C-style subscripting r[i][j]

void HepGeom::Transform3D::setIdentity ( )

inline

Sets the Identity transformation.

Definition at line 298 of file Transform3D.h.

References dx_, dy_, dz_, xx_, xy_, xz_, yx_, yy_, yz_, zx_, zy_, and zz_.

Referenced by HepGeom::Reflect3D::Reflect3D(), and Transform3D().

                        { 
       xy_= xz_= dx_= yx_= yz_= dy_= zx_= zy_= dz_= 0; xx_= yy_= zz_= 1;
     }

void HepGeom::Transform3D::setTransform	(	double	XX,
		double	XY,
		double	XZ,
		double	DX,
		double	YX,
		double	YY,
		double	YZ,
		double	DY,
		double	ZX,
		double	ZY,
		double	ZZ,
		double	DZ
	)

inlineprotected

Definition at line 186 of file Transform3D.h.

References dx_, dy_, dz_, xx_, xy_, xz_, yx_, yy_, yz_, zx_, zy_, and zz_.

Referenced by HepGeom::Reflect3D::Reflect3D(), HepGeom::Rotate3D::Rotate3D(), HepGeom::RotateX3D::RotateX3D(), HepGeom::RotateY3D::RotateY3D(), HepGeom::RotateZ3D::RotateZ3D(), and Transform3D().

                                                           {
       xx_ = XX; xy_ = XY; xz_ = XZ; dx_ = DX;
       yx_ = YX; yy_ = YY; yz_ = YZ; dy_ = DY;
       zx_ = ZX; zy_ = ZY; zz_ = ZZ; dz_ = DZ;
     }