AECDbSpaceTools.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 __AECDBSPACETOOLS_H__
#define __AECDBSPACETOOLS_H__
 
#include "DbEntity/AECDbSpace.h"
#include "AECDbOpeningBase.h"
#include "Ge/GeMatrix2d.h"
 
namespace AECSpaceRegen
{
 
    class AECARCHBASE_API BlockRefPath
    {
        class Data;
        Data* m_pData;
    public:
        BlockRefPath( ) : m_pData(0) { }
        explicit BlockRefPath( const std::vector<OdDbObjectId>& vecBlockRefs );
        BlockRefPath( const BlockRefPath& rPath );
        ~BlockRefPath( );
 
        BlockRefPath& operator =  ( const BlockRefPath& rPath );
        //BlockRefPath& operator += ( const OdDbObjectId& idLastRef );
        //BlockRefPath& operator += ( const BlockRefPath& rPath );
 
        bool                                IsEmpty() const;
        const std::vector< OdDbObjectId >&  GetBlockRefs() const;
        const OdGeMatrix3d&                 GetTransform() const;
 
        AECARCHBASE_API_STATIC static const BlockRefPath kNull;
    };
 
 
    inline bool operator == (const BlockRefPath& rA, const BlockRefPath& rB )
    {
        return &rA == &rB || rA.GetBlockRefs() == rB.GetBlockRefs();
    }
        
    inline bool operator != (const BlockRefPath& rA, const BlockRefPath& rB )
    {
        return !( rA == rB );
    }
 
 
 
 
    class AECARCHBASE_API EntityReference
    {
        OdDbObjectId m_idTarget;
        BlockRefPath m_Path;
    public:
        EntityReference() { }
        explicit EntityReference( const OdDbObjectId& idTarget ) : m_idTarget(idTarget) { }
        EntityReference( const OdDbObjectId& idTarget, const BlockRefPath& rPath )
            : m_idTarget(idTarget), m_Path( rPath ) { }
 
        EntityReference& set( const OdDbObjectId& idTarget, const BlockRefPath& rPath=BlockRefPath::kNull )
        {
            m_idTarget = idTarget;
            m_Path = rPath;
            return *this;
        }
 
        inline const OdDbObjectId& GetTarget() const { return m_idTarget; }
        inline const BlockRefPath& GetPath()   const { return m_Path; }
 
        AECARCHBASE_API_STATIC static const EntityReference kNull;
    };
 
    inline bool operator == (const EntityReference& rA, const EntityReference& rB )
    {
        return rA.GetTarget() == rB.GetTarget() && rA.GetPath() == rB.GetPath();
    }
        
    inline bool operator != (const EntityReference& rA, const EntityReference& rB )
    {
        return !( rA == rB );
    }
 
 
 
    enum BoundingMode
    {
      ebmAll,
      ebmWallCenterLines
    };
 
    class BoundaryVectorizer;
 
    class AECARCHBASE_API BoundingEnt
    {
    public:
        BoundingEnt(): m_pImpl(0) { }
        //explicit BoundingEnt( const OdDbObjectId& idEnt );
        //BoundingEnt( const EntityReference& rEntRef );
        //BoundingEnt& operator = (const OdDbObjectId& idEnt );
        //BoundingEnt& operator = (const EntityReference& rEntRef );
        BoundingEnt( const EntityReference& rEntRef, BoundaryVectorizer* pVect );
 
        // copying
        BoundingEnt( const BoundingEnt& rBEnt );
        BoundingEnt& operator = (const BoundingEnt& rBEnt);
 
        ~BoundingEnt();
 
        enum BoundaryType
        { 
            ebtInvalid = 0,
            ebtWall,
            ebtCurtainWall,
            ebtDoor,
            ebtLines,
            ebtOther
        };
 
        bool IsNull() const;
 
        BoundaryType GetType() const;
 
        const EntityReference& GetEntRef() const;
 
        const FacetModeler::Profile2D& GetGeometry() const;
 
        AECARCHBASE_API_STATIC static const BoundingEnt kNull;
 
        class Impl;
    private:
        Impl* m_pImpl;
    };
 
    inline bool operator == (const BoundingEnt& rA, const BoundingEnt& rB )
    {
        return &rA == &rB || rA.GetEntRef() == rB.GetEntRef();
    }
 
    inline bool operator != (const BoundingEnt& rA, const BoundingEnt& rB )
    {
        return !( rA == rB );
    }
 
} 
 
typedef std::map<OdDbObjectId, AECDbSpacePtr> TBoundingEntityIdToBoundedSpacePtrMap;
 
class SpaceBoundary
{
public:
  bool HasBoundaryWithEntity(OdDbObjectId idObj)
  {
    return ( m_boundingEntsIds.find(idObj) != m_boundingEntsIds.end() );
  }
  
  bool GetBoundaryOverlappedWith( const FacetModeler::Segment2D& aBoundarySeg, 
                                  OdDbObjectId idBE, 
                                  FacetModeler::Segment2D& segOverlappedPart );
 
  AECSpaceRegen::BoundingEnt GetBEForSegment(const FacetModeler::Segment2D& seg)
  {
    OdIntPtr iBeIdx = seg.metadata();
    const AECSpaceRegen::BoundingEnt be = m_boundingEnts[iBeIdx];
 
    return be;
  }
 
public:
  AECDbSpacePtr m_ptrSpace;
  FacetModeler::Profile2D rBoundary;
  std::vector< AECSpaceRegen::BoundingEnt > m_boundingEnts;
  std::set<OdDbObjectId> m_boundingEntsIds;
};
 
typedef std::vector<SpaceBoundary> SpaceBoundaryCollection;
 
struct AdjacentBoundaryChunk
{
  FacetModeler::Segment2D segChunk;
  AECDbSpacePtr ptrAdjacentSpace;
};
 
typedef std::vector<AdjacentBoundaryChunk> AdjacentBoundaryChunks;
 
class AECARCHBASE_API AECSpaceCalculator
{
public:
  typedef void (AECSpaceCalculator::*RULES_FUNCTION)( const AECSpaceRegen::BoundingEnt &be, const bool isAdjacentToOtherSpace, FacetModeler::Segment2D& curSeg, AECDbSpacePtr& ptrSpace, AECDbSpacePtr& ptrAdjacentSpace ); 
 
    public:
        AECSpaceCalculator( const OdGeMatrix3d& mUCS,
            const OdDbObjectId& idRootBlock,
            AECDefs::SpaceBoundaryFilter eFilter );
 
        ~AECSpaceCalculator();
 
        void Reset();
 
        void Reset( const OdGeMatrix3d& mUCS,
            const OdDbObjectId& idRootBlock,
            AECDefs::SpaceBoundaryFilter eFilter );
 
    public:
        void AppendToBoundarySet(
            const OdDbObjectId& idEntity );
 
    public:
        bool FindBoundary( const OdGePoint2d& ptHitTest, double dGap, bool bIgnoreHoles,
            FacetModeler::Profile2D& rBoundary ) const;
 
        bool FindInnerBoundary( const OdGePoint2d& ptHitTest, double dGap, bool bIgnoreHoles,
          FacetModeler::Profile2D& rBoundary ) const;
        bool FindOuterBoundary( const OdGePoint2d& ptHitTest, double dGap, bool bIgnoreHoles,
          FacetModeler::Profile2D& rBoundary ) const;
        bool FindCenterlinesBoundary( const OdGePoint2d& ptHitTest, double dGap, bool bIgnoreHoles,
          FacetModeler::Profile2D& rBoundary ) const;
 
        // 
        bool ApplyRulesFuncToBaseBoundary( AECDbSpacePtr& ptrSpace, const OdGePoint2d& ptHitTest, double dGap, bool bIgnoreHoles,
          FacetModeler::Profile2D& rBoundary, RULES_FUNCTION pRuleFunc, AECSpaceRegen::BoundingMode ebm = AECSpaceRegen::ebmWallCenterLines);
        
        // Basic standard
        bool FindGrossBoundaryBasic( AECDbSpacePtr& ptrSpace, const OdGePoint2d& ptHitTest, double dGap, bool bIgnoreHoles,
          FacetModeler::Profile2D& rBoundary );
 
        void ApplyBasicGrossRules( const AECSpaceRegen::BoundingEnt &be, const bool isAdjacentToOtherSpace,
          FacetModeler::Segment2D& curSeg, AECDbSpacePtr& ptrSpace, AECDbSpacePtr& ptrAdjacentSpace ); 
        
        // DIN277 standard
        bool FindGrossBoundaryDIN277( AECDbSpacePtr& ptrSpace, const OdGePoint2d& ptHitTest, double dGap, bool bIgnoreHoles,
          FacetModeler::Profile2D& rBoundary );
        void ApplyDIN277GrossRules( const AECSpaceRegen::BoundingEnt &be, const bool isAdjacentToOtherSpace,
          FacetModeler::Segment2D& curSeg, AECDbSpacePtr& ptrSpace, AECDbSpacePtr& ptrAdjacentSpace );
 
        // SIS standard
        bool FindNetBoundarySIS(const OdGePoint2d& ptHitTest, double dGap, bool bIgnoreHoles,
          FacetModeler::Profile2D& rBoundary);
        bool FindUsableBoundarySIS(AECDbSpacePtr& ptrSpace, const OdGePoint2d& ptHitTest, double dGap, bool bIgnoreHoles,
          FacetModeler::Profile2D& rBoundary);
 
        void ApplySISUsableRules( const AECSpaceRegen::BoundingEnt &be, const bool isAdjacentToOtherSpace,
          FacetModeler::Segment2D& curSeg, AECDbSpacePtr& ptrSpace, AECDbSpacePtr& ptrAdjacentSpace );
        void ApplyOpeningsToNetUsable_SIS( FacetModeler::Profile2D &rBoundary );
 
        // BOMA standard
        bool FindNetBoundaryBOMA(const OdGePoint2d& ptHitTest, double dGap, bool bIgnoreHoles,
          FacetModeler::Profile2D& rBoundary);
        bool FindUsableBoundaryBOMA(AECDbSpacePtr& ptrSpace, const OdGePoint2d& ptHitTest, double dGap, bool bIgnoreHoles,
          FacetModeler::Profile2D& rBoundary);
        bool FindGrossBoundaryBOMA(AECDbSpacePtr& ptrSpace, const OdGePoint2d& ptHitTest, double dGap, bool bIgnoreHoles,
          FacetModeler::Profile2D& rBoundary);
 
        void ApplyBomaUsableRules( const AECSpaceRegen::BoundingEnt &be, const bool isAdjacentToOtherSpace, 
          FacetModeler::Segment2D& curSeg, AECDbSpacePtr& ptrSpace, AECDbSpacePtr& ptrAdjacentSpace );
        void ApplyBomaGrossRules( const AECSpaceRegen::BoundingEnt &be, const bool isAdjacentToOtherSpace,
          FacetModeler::Segment2D& curSeg, AECDbSpacePtr& ptrSpace, AECDbSpacePtr& ptrAdjacentSpace );        
 
        const AECSpaceRegen::BoundingEnt GetBoundingEnt( OdUInt32 iMetadata ) const;
 
        AECDbSpacePtr CreateSpace( const FacetModeler::Profile2D& rBoundary,
            const OdDbObjectId& idStyle, AECDefs::SpaceGeometryType eType,
            AECDefs::SpaceOffsetBoundaries eOffsets ) const;
 
        bool UpdateSpace( AECDbSpacePtr pSpace ) const;
 
    private:
        AECSpaceCalculator();
        AECSpaceCalculator( const AECSpaceCalculator& );
        AECSpaceCalculator& operator =( const AECSpaceCalculator& );
 
        bool FindBoundingEntitiesForOtherSpacesOnTheDrawing(AECDbSpacePtr& ptrSpace,
                                                            double dGap, bool bIgnoreHoles,
                                                            SpaceBoundaryCollection& rOtherSpacesBounds) const;
        void FillSpaceBoundaryDataForSpace(AECDbSpacePtr& ptrSpace, 
          SpaceBoundary& rSB, OdDbObjectId idOwnerBlock, double dGap, bool bIgnoreHoles) const;
 
        bool ShiftCenterSegmentToInsideOfTheWall( FacetModeler::Segment2D& segCenterline, const AECSpaceRegen::BoundingEnt& be ) const;
        bool ShiftCenterSegmentToOutsideOfTheWall( FacetModeler::Segment2D& segCenterline, const AECSpaceRegen::BoundingEnt& be ) const;
        void MakeClosedLoopFromSegments(std::vector<FacetModeler::Segment2D>& vecSegments, FacetModeler::Contour2D& rResult) const;
 
        AECSpaceRegen::BoundingEnt GetSegmentBoundingEnt(const FacetModeler::Segment2D& seg);
 
    private:
      // debug functions
      void DebugDrawBEGeometry(const AECSpaceRegen::BoundingEnt be, OdUInt16 color = 0) const;
      void DebugDrawWallComponents(const AECSpaceRegen::BoundingEnt be, OdUInt16 color = 1) const;
      void DebugDrawBoundaryAndMetadata(const FacetModeler::Profile2D& rBoundary, OdUInt16 clrBoundary = 1, OdUInt16 clrEnt = 6) const;
      void DebugDrawBoundaryAndMetadata(const std::vector<FacetModeler::Segment2D>& vecSegments, OdUInt16 clrBoundary = 1, OdUInt16 clrEnt = 6) const;
      
      void DebugDrawWallCenterLine(const AECSpaceRegen::BoundingEnt be, OdUInt16 color = 2) const;
      void DebugDrawOpening(AECDbOpeningBasePtr ptrOpeningBase, OdUInt16 color = 2) const;
     
      void FindAdjacentBoundaryPartsForSegment(const FacetModeler::Segment2D& curSeg, SpaceBoundaryCollection& rOtherSpacesBounds, AdjacentBoundaryChunks& adjacentBoundary);
    private:
        // Implementation.
        class AECImpSpaceCalculator* m_pImpl;
};
 
OdGeMatrix3d GetUCSMatrix(OdDbDatabase* pDb);
double GetWallWidth(const AECSpaceRegen::BoundingEnt be);
std::set<OdIntPtr> GetBoundingEntsIdx(FacetModeler::Profile2D& rBoundary);
#endif // __AECDBSPACETOOLS_H__