AECECS.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance").
// All rights reserved.
//
// This software and its documentation and related materials are owned by
// the Alliance. The software may only be incorporated into application
// programs owned by members of the Alliance, subject to a signed
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable
// trade secrets of the Alliance and its suppliers. The software is also
// protected by copyright law and international treaty provisions. Application
// programs incorporating this software must include the following statement
// with their copyright notices:
//
//   This application incorporates Open Design Alliance software pursuant to a
//   license agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance.
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you
// acknowledge and accept the above terms.
 
#ifndef __AECECS_H__
#define __AECECS_H__
 
#include "AECBase.h"
#include "Ge/GeGbl.h"
#include "Ge/GeMatrix2d.h"
#include "Ge/GePoint3d.h"
#include "Ge/GeMatrix3d.h"
 
class OdGeLine3d;
class OdGeVector3d;
class OdGePlane;
class OdGeTol;
class OdGeScale3d;
 
 
class AECBASE_API AECECS
{
public:
  AECECS();
  AECECS( const OdGeMatrix3d& m );
  AECECS( const OdGePoint3d& origin, 
          const OdGeVector3d& xAxis,
          const OdGeVector3d& yAxis, 
          const OdGeVector3d& zAxis );
 
  static const AECECS kIdentity;
 
  AECECS& setToIdentity( );
 
  void validateZero( const OdGeTol& tol = OdGeContext::gTol );
 
  // Multiplication.
  //
 
  AECECS operator * ( const AECECS& matrix ) const;
 
  AECECS& operator *= ( const AECECS& matrix );
  AECECS& preMultBy( const AECECS& leftSide );
 
  AECECS& postMultBy( const AECECS& rightSide );
 
  AECECS& setToProduct( const AECECS& m1, const AECECS& m2);
 
  // Multiplicative inverse.
  //
 
  AECECS& invert();
 
 
  // Test if it is a singular matrix. A singular matrix is not invertible.
  //
 
  bool isSingular( const OdGeTol& tol = OdGeContext::gTol ) const;
 
  // Tests for equivalence using the infinity norm.
  //
 
  bool operator == ( const AECECS& matrix ) const { return isEqualTo(matrix); }
  bool operator != ( const AECECS& matrix) const { return !isEqualTo(matrix); }
 
  bool isEqualTo( const AECECS& matrix, const OdGeTol& tol = OdGeContext::gTol ) const;
 
  bool isUniScaledOrtho( const OdGeTol& tol = OdGeContext::gTol ) const;
 
  bool isScaledOrtho( const OdGeTol& tol = OdGeContext::gTol ) const;
 
  double det() const;
 
 
  AECECS& setTranslation( const OdGeVector3d& vect );
 
 
  // Set/get coordinate system
  //
 
  AECECS& setCoordSystem(
    const OdGePoint3d& origin, 
    const OdGeVector3d& xAxis,
    const OdGeVector3d& yAxis, 
    const OdGeVector3d& zAxis);
 
  void getCoordSystem(
    OdGePoint3d& origin, 
    OdGeVector3d& xAxis, 
    OdGeVector3d& yAxis, 
    OdGeVector3d& zAxis) const;
 
    const OdGePoint3d& getCsOrigin( ) const;
 
    const OdGeVector3d& getCsXAxis( ) const;
 
    const OdGeVector3d& getCsYAxis( ) const;
    const OdGeVector3d& getCsZAxis( ) const;
 
  // Set the matrix to be a specified transformation
  //
 
  AECECS& setToTranslation( const OdGeVector3d& vect );
 
  AECECS& setToRotation( double angle, const OdGeVector3d& axis,
    const OdGePoint3d& center = OdGePoint3d::kOrigin );
 
  AECECS& setToScaling( double scale,
    const OdGePoint3d& center = OdGePoint3d::kOrigin );
  AECECS& setToScaling( const OdGeScale3d& scale,
    const OdGePoint3d& center = OdGePoint3d::kOrigin );
 
  AECECS& setToMirroring( const OdGePlane& mirrorPlane );
  AECECS& setToMirroring( const OdGePoint3d& mirrorPoint );
  AECECS& setToMirroring( const OdGeLine3d& mirrorLine );
 
  AECECS& setToProjection(
    const OdGePlane& projectionPlane,
    const OdGeVector3d& projectDir);
 
  AECECS& setToAlignCoordSys (
    const OdGePoint3d& fromOrigin,
    const OdGeVector3d& fromXAxis,
    const OdGeVector3d& fromYAxis,
    const OdGeVector3d& fromZAxis,
    const OdGePoint3d& toOrigin,
    const OdGeVector3d& toXAxis,
    const OdGeVector3d& toYAxis,
    const OdGeVector3d& toZAxis);
 
 
      AECECS& setToWorldToPlane( const OdGeVector3d& normal );
  AECECS& setToWorldToPlane( const OdGePlane& plane );
 
      AECECS& setToPlaneToWorld( const OdGeVector3d& normal );
  AECECS& setToPlaneToWorld( const OdGePlane& plane );
 
  // Similar to above, but creates matrix on the stack.
  //
  
  static AECECS translation( const OdGeVector3d& vect );
  const OdGeVector3d& translation() const;
  
  static AECECS rotation(
    double angle, const OdGeVector3d& axis,
    const OdGePoint3d& center = OdGePoint3d::kOrigin );
    
  static AECECS scaling( double scale,
    const OdGePoint3d& center = OdGePoint3d::kOrigin );
  static AECECS scaling( const OdGeScale3d& scale,
    const OdGePoint3d& center = OdGePoint3d::kOrigin );
 
 
  static AECECS mirroring( const OdGePlane& mirrorPlane );
  static AECECS mirroring( const OdGePoint3d& mirrorPoint );
  static AECECS mirroring( const OdGeLine3d& mirrorLine );
 
  static AECECS projection(
    const OdGePlane& projectionPlane,
    const OdGeVector3d& projectDir);
 
  static AECECS alignCoordSys (
    const OdGePoint3d& fromOrigin,
    const OdGeVector3d& fromXAxis,
    const OdGeVector3d& fromYAxis,
    const OdGeVector3d& fromZAxis,
    const OdGePoint3d& toOrigin,
    const OdGeVector3d& toXAxis,
    const OdGeVector3d& toYAxis,
    const OdGeVector3d& toZAxis);
 
      static AECECS worldToPlane( const OdGeVector3d& normal );
  static AECECS worldToPlane( const OdGePlane& plane );
    
      static AECECS planeToWorld( const OdGeVector3d& normal );
  static AECECS planeToWorld( const OdGePlane& plane );
 
  double scale() const;
 
  double norm() const;
 
  OdGeMatrix2d convertToLocal( OdGeVector3d& normal, double& elevation ) const;
 
  OdGeMatrix2d convertToLocalXY() const;
 
  AECECS inverse( ) const;
 
  bool inverse( AECECS& inverseMatrix, double tol ) const;
 
  // For convenient access to the data.
  //
 
  void geMatrix( OdGeMatrix3d& result ) const;
  operator OdGeMatrix3d () const;
  AECECS& operator = (const OdGeMatrix3d& m );
 
  // The components of the matrix.
  //
  OdGePoint3d   m_origin;
  OdGeVector3d  m_xAxis;
  OdGeVector3d  m_yAxis;
  OdGeVector3d  m_zAxis;
};
 
AECBASE_API OdGePoint3d operator * ( const AECECS& matrix, const OdGePoint3d& point );
AECBASE_API OdGeVector3d operator * ( const AECECS& matrix, const OdGeVector3d& vector );
 
inline AECECS::AECECS()
  : m_xAxis( OdGeVector3d::kXAxis )
  , m_yAxis( OdGeVector3d::kYAxis )
  , m_zAxis( OdGeVector3d::kZAxis )
{
}
 
inline AECECS::AECECS( const OdGePoint3d& origin, 
                      const OdGeVector3d& xAxis,
                      const OdGeVector3d& yAxis, 
                      const OdGeVector3d& zAxis )
  : m_origin( origin )
  , m_xAxis( xAxis )
  , m_yAxis( yAxis )
  , m_zAxis( zAxis )
{
}
 
inline AECECS::AECECS( const OdGeMatrix3d& m ) {
  m.getCoordSystem( m_origin, m_xAxis, m_yAxis, m_zAxis );
  ODA_ASSERT(//Value of AECECS is not equivalint to value OdGeMatrix3d.
      OdZero(m[3][0], 1e-100) &&
      OdZero(m[3][1], 1e-100) &&
      OdZero(m[3][2], 1e-100) &&
      OdEqual( m[3][3], 1.0, 1e-100)
    );
}
 
inline const OdGePoint3d& AECECS::getCsOrigin() const { return m_origin; }
inline const OdGeVector3d& AECECS::getCsXAxis() const { return m_xAxis; }
inline const OdGeVector3d& AECECS::getCsYAxis() const { return m_yAxis; }
inline const OdGeVector3d& AECECS::getCsZAxis() const { return m_zAxis; }
 
inline AECECS& AECECS::setCoordSystem(
  const OdGePoint3d& origin, 
  const OdGeVector3d& xAxis,
  const OdGeVector3d& yAxis, 
  const OdGeVector3d& zAxis)
{
  m_origin = origin;
  m_xAxis = xAxis;
  m_yAxis = yAxis;
  m_zAxis = zAxis;
  return *this;
}
 
inline void AECECS::geMatrix( OdGeMatrix3d& result ) const {
  result.setCoordSystem( m_origin, m_xAxis, m_yAxis, m_zAxis );
}
 
inline AECECS::operator OdGeMatrix3d () const {
  OdGeMatrix3d result;
  geMatrix( result );
  return result;
}
 
inline AECECS& AECECS::operator = (const OdGeMatrix3d& m ) {
  m.getCoordSystem( m_origin, m_xAxis, m_yAxis, m_zAxis );
  return *this;
}
 
inline AECECS& AECECS::postMultBy( const AECECS& right ) {
  return setToProduct( *this, right );
}
 
inline AECECS& AECECS::preMultBy( const AECECS& left ) {
  return setToProduct( left, *this );
}
 
inline AECECS AECECS::operator * ( const AECECS& right ) const {
  return AECECS().setToProduct( *this, right );
}
 
inline AECECS& AECECS::operator *= ( const AECECS& right ) {
  return setToProduct( *this, right );
}
 
inline AECECS& AECECS::invert() {
  return ( *this = inverse() );
}
 
inline AECECS AECECS::inverse() const {
  AECECS res;
  if(!inverse(res, 1.e-300)) {
    GE_ERROR(eDegenerateGeometry);
  }
  return res;
}
 
inline const OdGeVector3d& AECECS::translation() const {
  return getCsOrigin().asVector();
}
 
inline AECECS& AECECS::setTranslation(const OdGeVector3d& vec) {
        m_origin = (const OdGePoint3d&)vec;
        return *this;
}
 
inline AECECS& AECECS::setToTranslation(const OdGeVector3d& vec) {
        setToIdentity();
        setTranslation(vec);
        return *this;
}
 
inline AECECS& AECECS::setToProjection( const OdGePlane& projectionPlane,
                                                                                                                                                                                        const OdGeVector3d& projectDir ) {
  return *this = OdGeMatrix3d::projection( projectionPlane, projectDir );
}
 
inline AECECS& AECECS::setToWorldToPlane( const OdGeVector3d& normal ) {
  setToPlaneToWorld( normal );
  return invert();
}
 
inline void AECECS::validateZero( const OdGeTol& tol ) {
  OdGeMatrix3d m( *this );
  m.validateZero( tol );
  *this = m;
}
 
inline AECECS AECECS::translation(const OdGeVector3d& vec) {
        return AECECS().setToTranslation(vec);
}
 
inline AECECS AECECS::rotation(
  double angle, const OdGeVector3d& axis, const OdGePoint3d& center)
{
        return AECECS().setToRotation(angle, axis, center);
}
 
inline AECECS AECECS::scaling(double scaleAll, const OdGePoint3d& center) {
  return AECECS().setToScaling( scaleAll, center );
}
 
inline AECECS AECECS::scaling(const OdGeScale3d& scale, const OdGePoint3d& center) {
        return AECECS().setToScaling(scale, center);
}
 
inline AECECS& AECECS::setToMirroring( const OdGePlane& pln ) {
  return *this = mirroring(pln);
}
 
inline AECECS& AECECS::setToMirroring( const OdGePoint3d& mirrorPoint ) {
  return *this = mirroring(mirrorPoint);
}
 
inline AECECS& AECECS::setToMirroring( const OdGeLine3d& mirrorLine ) {
  return *this = mirroring(mirrorLine);
}
 
#endif  //__AECECS_H__