DbGeomRef.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, 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-2024 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 DbGeomRef_INCLUDED_
#define DbGeomRef_INCLUDED_ 
 
#include "DbSubentId.h"
#include "DbCompoundObjectId.h"
#include "Ge/GeCurve3d.h"
#include "RxObjectImpl.h"
 
#include "TD_PackPush.h"
 
class OdDbEntity;
typedef OdSmartPtr<OdDbEntity> OdDbEntityPtr;
 

class DBENT_EXPORT OdDbGeomRef : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdDbGeomRef);

  virtual ~OdDbGeomRef();

  virtual void reset();

  virtual bool isValid() const;

  virtual bool isEmpty() const;

  virtual OdDbEntityPtr createEntity() const;

  virtual OdResult  evaluateAndCacheGeometry();
};

typedef OdSmartPtr<OdDbGeomRef> OdDbGeomRefPtr;
 

class DBENT_EXPORT OdDbSubentRef : public OdDbGeomRef
{
public:
  ODRX_DECLARE_MEMBERS(OdDbSubentRef);

  OdDbSubentRef();

  OdDbSubentRef(const OdDbCompoundObjectId& compId, 
                const OdDbSubentId& subent = OdDbSubentId()); 

  static OdSmartPtr<OdDbSubentRef> createObject( const OdDbCompoundObjectId& compId,
                const OdDbSubentId& subent = OdDbSubentId() );

  static OdSmartPtr<OdDbSubentRef> createObject( const OdDbCompoundObjectId* pid,
                const OdDbSubentId& subentid = OdDbSubentId() )
  {
    return createObject( *pid, subentid );
  }

  OdDbSubentRef& operator =(const OdDbSubentRef& src);

  virtual void copyFrom(const OdRxObject* src);

  virtual void reset();

  virtual bool isValid() const;

  virtual bool isEmpty() const;

  virtual const OdDbCompoundObjectId& entity() const;

  virtual OdDbSubentId subentId() const;

  virtual OdDbEntityPtr createEntity() const;

  virtual OdResult evaluateAndCacheGeometry(); 
 
protected:
  void setEntity(const OdDbCompoundObjectId& entityId);
 
  void setSubent(const OdDbSubentId& subentId);

  void setFromSubentPath(const OdDbFullSubentPath& pathSubEnt);
 
private:
  OdDbCompoundObjectId m_entityId;
  OdDbSubentId m_SubentId;
};

typedef OdSmartPtr<OdDbSubentRef> OdDbSubentRefPtr;
 

class DBENT_EXPORT OdDbFaceRef : public OdRxObjectImpl<OdDbSubentRef>
{
public:
  ODRX_DECLARE_MEMBERS(OdDbFaceRef);

  OdDbFaceRef();

  OdDbFaceRef(const OdDbCompoundObjectId& compId, 
              const OdDbSubentId& = OdDbSubentId(), 
              void *pBody = NULL); 

  OdDbFaceRef(const OdDbFaceRef& faceRef);

  virtual ~OdDbFaceRef();

  OdDbFaceRef& operator =(const OdDbFaceRef& src);

  virtual void copyFrom(const OdRxObject* src);

  virtual void reset();

  virtual bool isValid() const;

  virtual bool isEmpty() const;

  void* asmBody() const;

  virtual OdDbEntityPtr createEntity() const;

  virtual OdResult evaluateAndCacheGeometry();
 
private:
  void* m_pAsmBody;
};

typedef OdSmartPtr<OdDbFaceRef> OdDbFaceRefPtr;
 

class DBENT_EXPORT OdDbEdgeRef : public OdRxObjectImpl<OdDbSubentRef>
{
public:
  ODRX_DECLARE_MEMBERS(OdDbEdgeRef);

  OdDbEdgeRef();
  
  OdDbEdgeRef(const OdDbFullSubentPath& path);
  
  OdDbEdgeRef(const OdDbCompoundObjectId& comId,
              const OdDbSubentId& edgeSubentId = OdDbSubentId(),
              const OdDbSubentId& faceSubentId = OdDbSubentId(),
              const OdGeCurve3d* pCurve = NULL);
  OdDbEdgeRef(const OdGeCurve3d* pGeCurve);

  OdDbEdgeRef(const OdDbEdgeRef& src);

  static OdSmartPtr<OdDbEdgeRef> createObject( const OdDbCompoundObjectIdPtr & pid, const OdGeCurve3d* pCurve ) {
    return createObject( *pid, pCurve );
  }

  static OdSmartPtr<OdDbEdgeRef> createObject( const OdDbCompoundObjectId& compId, const OdGeCurve3d* pCurve );

  static OdSmartPtr<OdDbEdgeRef> createObject( const OdDbEntity* pEnt );

  static OdSmartPtr<OdDbEdgeRef> createObject( const OdGeCurve3d* pCurve );

  virtual ~OdDbEdgeRef();

  OdDbEdgeRef& operator =(const OdDbEdgeRef& src);

  virtual void copyFrom(const OdRxObject* src);

  virtual void reset();

  virtual bool isValid() const;

  virtual bool isEmpty() const;

  void setFaceSubentity(const OdDbSubentId& faceSubentId);

  OdDbSubentId faceSubentId() const;

  const OdGeCurve3d* curve() const;

  virtual OdResult evaluateCurve(OdGeCurve3d*& src) const;

  virtual OdDbEntityPtr createEntity() const;

  virtual OdResult evaluateAndCacheGeometry(); 
 
  
  void setCurve(const OdGeCurve3d* pCurve);
 
private:
  //  Sets the constant three-dimensional curve to be hold by this edge reference.
  //*/
  //void setCurve(const OdGeCurve3d* pCurve);
  OdDbSubentId m_FaceSubentId;
  OdGeCurve3dPtr m_pCurve;
};

typedef OdSmartPtr<OdDbEdgeRef> OdDbEdgeRefPtr;
 

class DBENT_EXPORT OdDbVertexRef : public OdRxObjectImpl<OdDbSubentRef>
{
public:
  ODRX_DECLARE_MEMBERS(OdDbVertexRef);

  enum ImpliedType
  {
    kExplicitVertex,
    kUnknownType,
    kEdgeStart,
    kEdgeEnd,
    kEdgeMid,
    kEdgeCenter,
    kEdgeSplineControlPoint,
    kEdgeSplineFitPoint,
  };

  OdDbVertexRef();
  
  OdDbVertexRef(const OdDbCompoundObjectId& comId,
                const OdDbSubentId& subentId = OdDbSubentId(),
                const OdGePoint3d& point3d = OdGePoint3d::kOrigin);

  OdDbVertexRef(const OdDbFullSubentPath& fullPath);

  OdDbVertexRef(const OdDbEntity* pEnt);
  
  OdDbVertexRef(const OdGePoint3d& point3d);

  OdDbVertexRef(ImpliedType implType, 
                const OdDbEdgeRef& edgeRef,
                int controlOrFitPointIndex = 0,
                const OdGePoint3d& point3d = OdGePoint3d::kOrigin);

  OdDbVertexRef(const OdDbVertexRef& src);

  static OdSmartPtr<OdDbVertexRef> createObject( const OdGePoint3d& );

  static OdSmartPtr<OdDbVertexRef> createObject( const OdDbObjectId entId, const OdDbSubentId subId, const OdGePoint3d& point );

  virtual ~OdDbVertexRef();

  OdDbVertexRef& operator =(const OdDbVertexRef& other);

  virtual void copyFrom(const OdRxObject* src);

  virtual void reset();

  virtual bool isValid() const;

  virtual const OdDbCompoundObjectId& entity() const;

  virtual OdDbSubentId subentId() const;

  ImpliedType impliedType() const;

  const OdDbGeomRef* referencedRef() const;

  int index() const;

  OdGePoint3d point() const;

  virtual OdResult evaluatePoint(OdGePoint3d& point) const;

  OdDbEntityPtr createEntity()const;

  virtual OdResult evaluateAndCacheGeometry(); 
 
private:
  void setReferencedRef(OdDbGeomRefPtr pReferencedRef);

  ImpliedType m_ImpliedType;
  OdDbGeomRefPtr m_pReferencedRef;
  int m_Index;
  OdGePoint3d m_Point; 
};

typedef OdSmartPtr<OdDbVertexRef> OdDbVertexRefPtr;
 

class DBENT_EXPORT OdDbPathRef : public OdRxObjectImpl<OdDbGeomRef>
{
public:
  ODRX_DECLARE_MEMBERS(OdDbPathRef);

  OdDbPathRef();
  OdDbPathRef(const OdArray<OdDbEdgeRef>& edges);

  OdDbPathRef(const OdDbFullSubentPathArray& edgeSubentPathArr,
              const OdDbFullSubentPathArray& faceSubentPathArr);

  OdDbPathRef(const OdDbPathRef& src);

  virtual ~OdDbPathRef();

  OdDbPathRef& operator =(const OdDbPathRef&);

  virtual void copyFrom(const OdRxObject* src);

  virtual void reset();

  virtual bool isValid() const;

  virtual bool isEmpty() const;

  void setEdgeRefs(const OdArray<OdDbEdgeRef>& edges);

  OdResult getEntityArray(OdArray<OdDbEntity*>& entities, bool concatenate) const;

  const OdArray<OdDbEdgeRef>& edgeRefs() const;

  bool isEqualTo(const OdGeCurve3d* pOther);

  bool isReferencePath();

  virtual OdDbEntityPtr createEntity() const;

  virtual OdResult evaluateAndCacheGeometry();
 
private:
  OdArray<OdDbEdgeRef> m_EdgeRefs;
};

typedef OdSmartPtr<OdDbPathRef> OdDbPathRefPtr;
 

class DBENT_EXPORT OdDbVectorRef : public OdRxObjectImpl<OdDbGeomRef>
{
public:
  ODRX_DECLARE_MEMBERS(OdDbVectorRef);

  OdDbVectorRef();

  OdDbVectorRef(const OdGeVector3d& vector);

  OdDbVectorRef(const OdDbVectorRef& src);

  virtual ~OdDbVectorRef();

  OdDbVectorRef& operator =(const OdDbVectorRef& src);

  virtual void copyFrom(const OdRxObject* src);

  virtual void reset();

  virtual bool isValid() const;

  virtual bool isEmpty() const;

  const OdGeVector3d vector() const;

  void set(const OdGeVector3d& vector);

  virtual OdDbEntityPtr createEntity() const;

  virtual OdResult evaluateAndCacheGeometry();
 
private:
  OdGeVector3d m_Vector;
};

typedef OdSmartPtr<OdDbVectorRef> OdDbVectorRefPtr;
 

class DBENT_EXPORT OdDbCoordSystemRef : public OdRxObjectImpl<OdDbGeomRef>
{
public:
  ODRX_DECLARE_MEMBERS(OdDbCoordSystemRef);

  OdDbCoordSystemRef();

  OdDbCoordSystemRef(const OdGeMatrix3d& matrix);
  
  OdDbCoordSystemRef(const OdDbCompoundObjectId& compId, const OdGeMatrix3d& matrix);

  OdDbCoordSystemRef(const OdArray<OdDbSubentRef*>& aSubentRef);

  OdDbCoordSystemRef(const OdDbCoordSystemRef& src);

  virtual ~OdDbCoordSystemRef();

  OdDbCoordSystemRef& operator = (const OdDbCoordSystemRef&);

  virtual void copyFrom(const OdRxObject*);

  virtual void reset();

  virtual bool isValid() const;

  virtual bool isEmpty() const;

  const OdGeMatrix3d& coordSystem() const;

  const OdDbCompoundObjectId& entityId() const;

  const OdArray<OdDbSubentRef*>& subentRefs() const;

  void set(const OdGeMatrix3d& matrix);
  
  void set(const OdDbCompoundObjectId& entId);
  
  void set(const OdArray<OdDbSubentRef*>& subentReferences);

  virtual OdDbEntityPtr createEntity() const;

  virtual OdResult evaluateAndCacheGeometry();
 
private:
  OdGeMatrix3d m_CoordSystem;
  OdDbCompoundObjectId m_entityId;
  OdArray<OdDbSubentRef*> m_SubentRefs;
};

typedef OdSmartPtr<OdDbCoordSystemRef> OdDbCoordSystemRefPtr;
 
#include "TD_PackPop.h"
 
#endif // DbGeomRef_INCLUDED_