AECGrConstraintImpl.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 __AECGRIP_CONSTRAINT_IMPL_H__
#define __AECGRIP_CONSTRAINT_IMPL_H__
 
#include "Grips/AECGrConstraint.h"
#include "Grips/AECGripManager.h"
#include "FMContour3D.h"
#include <Ge/GeLineSeg3d.h>
#include <Ge/GeLine3d.h>
#include <Ge/GeCircArc3d.h>
 
class OdGeRay3dExt : public OdGeRay3d
{
    public:
      OdGeRay3dExt() : OdGeRay3d()
      {}
      OdGeRay3dExt(
        const OdGePoint3d& point, 
        const OdGeVector3d& vect) : OdGeRay3d( point, vect )
      {}
 
        virtual bool hasStartPoint( OdGePoint3d& pt ) const
        { pt = pointOnLine(); return true; }
 
        virtual bool hasEndPoint( OdGePoint3d& ) const
        { return false; }
 
        virtual OdGePoint3d evalPoint( double param, int numDeriv, OdGeVector3dArray& derivatives ) const
        {
            OdGePoint3d ptRes = pointOnLine() + direction() * param;
            OdUInt32 i, iSize = numDeriv;
            derivatives.resize( iSize );
            for( i = 0; i < iSize; i++ )
                derivatives[ i ] = OdGeVector3d::kIdentity;
            return ptRes;
        }
};
 
class AECBASE_API AECGripConstraintNone : public AECGripConstraint
{
    ODRX_DECLARE_MEMBERS( AECGripConstraintNone );
 
    public:
        virtual AECGr::Result apply( const OdGeVector3d& vViewDir,
            const OdGePoint3d& ptGrip, OdGePoint3d& ptNew );
};
typedef OdSmartPtr<AECGripConstraintNone> AECGripConstraintNonePtr;
 
class AECBASE_API AECGripConstraintCursorBased : public AECGripConstraint
{
    ODRX_DECLARE_MEMBERS( AECGripConstraintCursorBased );
 
    public:
        virtual void transformBy( const OdGeMatrix3d& mTr ) = 0;
};
typedef OdSmartPtr<AECGripConstraintCursorBased> AECGripConstraintCursorBasedPtr;
 
class AECBASE_API AECGripConstraintToPlane : public AECGripConstraintCursorBased
{
    ODRX_DECLARE_MEMBERS( AECGripConstraintToPlane );
 
    public:
        void setPlane( const OdGePlane& cPlane ) { m_cPlane = cPlane; }
        virtual AECGr::Result apply( const OdGeVector3d& vViewDir,
            const OdGePoint3d& ptGrip, OdGePoint3d& ptNew );
 
        virtual void transformBy( const OdGeMatrix3d& mTr )
        {
            m_cPlane.transformBy( mTr );
        }
 
    private:
        OdGePlane m_cPlane;
};
typedef OdSmartPtr<AECGripConstraintToPlane> AECGripConstraintToPlanePtr;
 
class AECBASE_API AECGripConstraintToLineRay : public AECGripConstraintCursorBased
{
    ODRX_DECLARE_MEMBERS( AECGripConstraintToLineRay );
 
    public:
        void setRay( const OdGeRay3dExt& cRay ) { m_cRay = cRay; }
        virtual AECGr::Result apply( const OdGeVector3d& vViewDir,
            const OdGePoint3d& ptGrip, OdGePoint3d& ptNew );
        virtual void transformBy( const OdGeMatrix3d& mTr )
        {
            m_cRay.transformBy( mTr );
        }
 
    private:
        OdGeRay3dExt m_cRay;
};
typedef OdSmartPtr<AECGripConstraintToLineRay> AECGripConstraintToLineRayPtr;
 
class AECBASE_API AECGripConstraintToLine : public AECGripConstraintCursorBased
{
    ODRX_DECLARE_MEMBERS( AECGripConstraintToLine );
 
    public:
        void setLine( const OdGeLine3d& cLine ) { m_cLine = cLine; }
        virtual AECGr::Result apply( const OdGeVector3d& vViewDir,
            const OdGePoint3d& ptGrip, OdGePoint3d& ptNew );
        virtual void transformBy( const OdGeMatrix3d& mTr )
        {
            m_cLine.transformBy( mTr );
        }
 
    private:
        OdGeLine3d m_cLine;
};
typedef OdSmartPtr<AECGripConstraintToLine> AECGripConstraintToLinePtr;
 
class AECBASE_API AECGripConstraintToLineSegment : public AECGripConstraintCursorBased
{
    ODRX_DECLARE_MEMBERS( AECGripConstraintToLineSegment );
 
    public:
        void setSegment( const OdGePoint3d& p1, const OdGePoint3d& p2 )
        {
            m_cSeg.set( p1, p2 );
        }
        virtual AECGr::Result apply( const OdGeVector3d& vViewDir,
            const OdGePoint3d& ptGrip, OdGePoint3d& ptNew );
        virtual void transformBy( const OdGeMatrix3d& mTr )
        {
            m_cSeg.transformBy( mTr );
        }
 
    private:
        OdGeLineSeg3d m_cSeg;
};
typedef OdSmartPtr<AECGripConstraintToLineSegment> AECGripConstraintToLineSegmentPtr;
 
class AECBASE_API AECGripConstraintToPlaneRayRay : public AECGripConstraintCursorBased
{
    ODRX_DECLARE_MEMBERS( AECGripConstraintToPlaneRayRay );
 
    public:
        void set( const OdGePoint3d& pt, const OdGeVector3d& v1,  const OdGeVector3d& v2 )
        {
            m_pt = pt;
            m_v1 = v1;
            m_v2 = v2;
        }
        virtual AECGr::Result apply( const OdGeVector3d& vViewDir,
            const OdGePoint3d& ptGrip, OdGePoint3d& ptNew );
        virtual void transformBy( const OdGeMatrix3d& mTr )
        {
            m_pt.transformBy( mTr );
            m_v1.transformBy( mTr );
            m_v2.transformBy( mTr );
        }
 
    private:
        OdGePoint3d m_pt;
        OdGeVector3d m_v1;
        OdGeVector3d m_v2;
};
typedef OdSmartPtr<AECGripConstraintToPlaneRayRay> AECGripConstraintToPlaneRayRayPtr;
 
class AECBASE_API AECGripConstraintToPolyline : public AECGripConstraintCursorBased
{
    ODRX_DECLARE_MEMBERS( AECGripConstraintToPolyline );
 
    public:
        void set( const FacetModeler::Contour2D& cBase )
        {
            m_cBase = FacetModeler::Contour3D( cBase );
        }
        virtual AECGr::Result apply( const OdGeVector3d& vViewDir,
            const OdGePoint3d& ptGrip, OdGePoint3d& ptNew );
        virtual void transformBy( const OdGeMatrix3d& mTr )
        {
            m_cBase.transformBy( mTr );
        }
 
    private:
        FacetModeler::Contour3D m_cBase;
};
typedef OdSmartPtr<AECGripConstraintToPolyline> AECGripConstraintToPolylinePtr;
 
class AECBASE_API AECGripConstraintToCircle : public AECGripConstraintCursorBased
{
    ODRX_DECLARE_MEMBERS( AECGripConstraintToCircle );
 
    public:
        void setCircle( const OdGeCircArc3d& cCircle )
        {
            m_circ = cCircle;
        }
        virtual AECGr::Result apply( const OdGeVector3d& vViewDir,
            const OdGePoint3d& ptGrip, OdGePoint3d& ptNew );
        virtual void transformBy( const OdGeMatrix3d& mTr )
        {
            m_circ.transformBy( mTr );
        }
 
    private:
        OdGeCircArc3d m_circ;
};
typedef OdSmartPtr<AECGripConstraintToCircle> AECGripConstraintToCirclePtr;
 
class AECBASE_API AECGripConstraintToRadialRay : public AECGripConstraintCursorBased
{
    ODRX_DECLARE_MEMBERS( AECGripConstraintToRadialRay );
 
    public:
        void setRadialRay( const OdGeRay3dExt& cRay ) { m_cRay = cRay; }
        virtual AECGr::Result apply( const OdGeVector3d& vViewDir,
            const OdGePoint3d& ptGrip, OdGePoint3d& ptNew );
        virtual void transformBy( const OdGeMatrix3d& mTr )
        {
            m_cRay.transformBy( mTr );
        }
 
    private:
        OdGeRay3dExt m_cRay;
};
typedef OdSmartPtr<AECGripConstraintToRadialRay> AECGripConstraintToRadialRayPtr;
 
class AECBASE_API AECGripConstraintToAcDbCurve : public AECGripConstraintCursorBased
{
    ODRX_DECLARE_MEMBERS( AECGripConstraintToAcDbCurve );
 
    public:
        void set( const OdDbObjectId& idCurve )
        {
            m_idCurve = idCurve;
        }
        virtual AECGr::Result apply( const OdGeVector3d& vViewDir,
            const OdGePoint3d& ptGrip, OdGePoint3d& ptNew );
        virtual void transformBy( const OdGeMatrix3d& )
        {
        }
 
    private:
        OdDbObjectId m_idCurve;
};
typedef OdSmartPtr<AECGripConstraintToAcDbCurve> AECGripConstraintToAcDbCurvePtr;
 
#endif // __AECGRIP_CONSTRAINT_IMPL_H__