SiSpatialIndex.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 _SpatialIndex_h_Included_
#define _SpatialIndex_h_Included_
 
#include "OdPlatformSettings.h"
 
#ifdef SPATIALINDEX_DLL_EXPORTS
  #define ODSI_API          OD_TOOLKIT_EXPORT
  #define ODSI_API_STATIC   OD_STATIC_EXPORT
#else
  #define ODSI_API          OD_TOOLKIT_IMPORT
  #define ODSI_API_STATIC   OD_STATIC_IMPORT
#endif

 
#include "RxObject.h"
#include "Ge/GeExtents3d.h"
#include "Ge/GeExtents2d.h"
 
#include "TD_PackPush.h"

struct ODSI_API OdSiShape
{
  virtual bool contains( const OdGeExtents3d& extents, bool planar, const OdGeTol& tol = OdGeContext::gTol ) const = 0;
  virtual bool intersects( const OdGeExtents3d& extents, bool planar, const OdGeTol& tol = OdGeContext::gTol ) const = 0;
 
  virtual ~OdSiShape() {};
  virtual OdSiShape* clone() const { return 0; }
  virtual void transform(const OdGeMatrix3d&) {};
 
  static bool isOverallSpace(const OdSiShape* ptr);
  static bool isNoSpace(const OdSiShape* ptr);
 
  ODSI_API_STATIC static const OdSiShape& kOverallSpace;
  ODSI_API_STATIC static const OdSiShape& kNoSpace;
};

struct OdSiEntity
{
  virtual bool extents(OdGeExtents3d& extents) const = 0;
};

struct OdSiVisitor
{
  virtual void visit( OdSiEntity* entity, bool completelyInside ) = 0;
};
 
class ODSI_API OdSiSpatialIndex;
typedef OdSmartPtr<OdSiSpatialIndex> OdSiSpatialIndexPtr;

class ODSI_API OdSiSpatialIndex : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdSiSpatialIndex);

  enum CreationFlags
  {
    kSiNoFlags       = 0,
 
    kSiPlanar        = (1 << 0), // Create 2D Spatial Index.
    kSiModifyMtAware = (1 << 1), // Protect insert/remove/clear by mutex object.
    kSiAccessMtAware = (1 << 2), // Protect query/extents/tolerance by mutex object.
 
    kSiFullMtAware   = (kSiModifyMtAware | kSiAccessMtAware)
  };

  static OdSiSpatialIndexPtr createObject( OdUInt32 flags, unsigned int initialNumEntity, unsigned int maxDepth = 30, unsigned int maxCount = 20, double eps = 1e-10 );

  virtual void insert( OdSiEntity* entity ) = 0;
  virtual bool remove( OdSiEntity* entity ) = 0;

  virtual void query( const OdSiShape& shape, OdSiVisitor& visitor ) const = 0;
  virtual void clear() = 0;
  virtual void setMaxTreeDepth( unsigned char maxDepth ) = 0;
  virtual void setMaxNodeSize( unsigned char maxCount ) = 0;
  virtual bool extents(OdGeExtents3d& extents) const = 0;

  virtual unsigned maxTreeDepth() const = 0;

  virtual unsigned maxNodeSize() const = 0;

  virtual const OdGeTol& tolerance() const = 0;

  virtual void setTolerance(const OdGeTol& tol) = 0;

  virtual bool isInitialized() const = 0;
};
 
namespace OdSi
{
bool ODSI_API properExtents(const OdGeExtents3d& ext);
}

struct ODSI_API OdSiDynamicShape: public OdSiShape
{
  virtual void update(const OdGeExtents3d& we) const = 0;
};
 
typedef OdArray<OdSiShape*, OdMemoryAllocator<OdSiShape*> > OdSiShapePtrArray;
typedef OdArray<const OdSiShape*, OdMemoryAllocator<const OdSiShape*> > OdSiShapeConstPtrArray;

struct ODSI_API OdSiShapesIntersection: public OdSiShape
{
  OdSiShapesIntersection()
  {
  }
 
  OdSiShapesIntersection(const OdSiShapeConstPtrArray& shapes)
  {
    reset(shapes);
  }
 
  ~OdSiShapesIntersection()
  {
    clear();
  }
 
  const OdSiShapePtrArray& shapes() const
  {
    return m_shapes;
  }
 
  void reset(const OdSiShapeConstPtrArray& shapes)
  {
    clear();
    m_shapes.reserve(shapes.size());
    for(OdSiShapeConstPtrArray::const_iterator it = shapes.begin(); it != shapes.end(); it++)
      m_shapes.push_back((*it)->clone());
  }
 
  void clear()
  {
    for(OdSiShapePtrArray::iterator it = m_shapes.begin(); it != m_shapes.end(); it++)
      delete *it;
    m_shapes.clear();
  }
  virtual bool contains(const OdGeExtents3d& extents, bool planar, const OdGeTol& tol = OdGeContext::gTol) const
  {
    for(OdSiShapePtrArray::const_iterator it = m_shapes.begin(); it != m_shapes.end(); it++)
    {
      if(!(*it)->contains(extents, planar, tol))
        return false;
    }
    return true;
  }
 
  virtual bool intersects( const OdGeExtents3d& extents, bool planar, const OdGeTol& tol = OdGeContext::gTol ) const
  {
    for(OdSiShapePtrArray::const_iterator it = m_shapes.begin(); it != m_shapes.end(); it++)
    {
      if(!(*it)->intersects(extents, planar, tol))
        return false;
    }
    return true;
  }
 
  virtual OdSiShape* clone() const
  {
    OdSiShapeConstPtrArray ar;
    ar.reserve(m_shapes.size());
    for(OdSiShapePtrArray::const_iterator it = m_shapes.begin(); it != m_shapes.end(); it++)
        ar.push_back(*it);
    return new OdSiShapesIntersection(ar);
  }
 
  virtual void transform(const OdGeMatrix3d& tf)
  {
    for(OdSiShapePtrArray::iterator it = m_shapes.begin(); it != m_shapes.end(); it++)
      (*it)->transform(tf);
  }
 
private:
  OdSiShapePtrArray m_shapes;
};
 
#include "TD_PackPop.h"
 
#endif