FMSliceEngine.h

Go to the documentation of this file.

// Copyright (C) 2002-2015, 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 Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2015 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
#include "FMProfile3D.h"
#include "FMGeometry.h"
#include "FMGeometryDebug.h"
#include "Modeler/FMMdlBody.h"
#include "Modeler/FMMdlFace.h"
#include "Modeler/FMMdlEdge.h"
#include "Modeler/FMMdlIterators.h"
#include "Contours/FMEdgeGraph.h"
#include "Contours/FMEdgeGraph.h"
#include "Contours/FMSliceContourBuilder.h"
#include "Modeler/FMMdlSlicerBaseImpl.h"
 
#include "Ge/GePlane.h"
#include "Ge/GeLineSeg3d.h"
#include <UInt32Array.h>
#include "Si/SiSpatialIndex.h"
#include "Si/SiShapePlane.h"
#include "Ge/GeLine3d.h"
#include "FMDebugDraw.h"
//#include "../sampleapplications/TADebugTx/Debug.h"
 
namespace FacetModeler
{
 
struct SpatialFaceData : public OdSiEntity {
  Face*                 m_pFace;
  AecTagType            m_savedTag;
  mutable OdGeExtents3d m_ext;
  const Face* face() const { return m_pFace; }
 
  void detach() {
    m_pFace->setTag( m_savedTag );
    m_pFace = 0;
  }
 
  inline void attach( Face* pFace ) {
    m_pFace = pFace;
    m_savedTag = pFace->tag();
    pFace->setTag( (AecTagType)this );
    extents( pFace, m_ext );
  }
 
  static void extents( const Face* pFace, OdGeExtents3d& extents ) {
    Edge* pEdge = pFace->edge();
    Edge* pEnd = pEdge;
    const OdGePoint3d& pt = pEdge->vertex()->point();
    extents.set( pt, pt );
    do {
      pEdge = pEdge->next();
      extents.addPoint( pEdge->vertex()->point() );
    }
    while( pEdge != pEnd );
  }
 
  bool extents(OdGeExtents3d& extents) const {
    extents = m_ext;
    return true;
  }
 
  bool contains( const OdGeExtents3d& , bool , const OdGeTol& ) const {
    return false;
  }
};
 
 
template<class TSpatFData = SpatialFaceData>
class FaceSpatialIndex {
protected:
  OdSiSpatialIndexPtr   m_pFacesIndex;
  OdArray<TSpatFData>   m_spatialDataArray;
private:
  FaceSpatialIndex& operator = (const FaceSpatialIndex& ) { return *this; }
public:
  ~FaceSpatialIndex() {
    destroy( true );
  }
  OdSiSpatialIndex& build( const Body* pBody, double eps ) {
    destroy();
    OdUInt32 n = pBody->faceCount();
    if ( n ) {
      m_pFacesIndex = OdSiSpatialIndex::createObject( false, 0, 30, 20, eps );
      m_spatialDataArray.resize( n );
      TSpatFData* pSFD = m_spatialDataArray.asArrayPtr();
      FaceIterator iter( pBody );
      while( !iter.done() ) {
        pSFD->attach( iter.get() );
        m_pFacesIndex->insert( pSFD );
        iter.next();
        ++pSFD;
      }
    }
    return *m_pFacesIndex.get();
  }
  void destroy( bool bRestoreFaceTags = true ) {
    m_pFacesIndex.release();
    if( bRestoreFaceTags ) {
      while( m_spatialDataArray.size() ) {
        m_spatialDataArray.last().detach();
        m_spatialDataArray.removeLast();
      }
    }
    else {
      m_spatialDataArray.clear();
    }
  }
 
  OdSiSpatialIndex& index() {
    ODA_ASSERT( !m_pFacesIndex.isNull() ); 
    return *m_pFacesIndex; 
  }
 
  const OdSiSpatialIndex& index() const { 
    ODA_ASSERT( !m_pFacesIndex.isNull() );
    return *m_pFacesIndex;
  }
 
  OdArray<TSpatFData>& faceDataArray() { return m_spatialDataArray; }
  OdUInt32 size() const { 
    if(m_pFacesIndex.isNull())
      return 0;
    return m_spatialDataArray.size(); 
  }
};
 
template<class T>
inline static T mymax( T v1, T v2 ) {
  return v1 > v2 ? v1 : v2;
}
 
typedef OdArray<Vertex*, OdMemoryAllocator<Vertex*> > VertexIndex;
typedef OdArray<Face*, OdMemoryAllocator<Face*> > FacePtrArray;
typedef OdArray<const Face*, OdMemoryAllocator<const Face*> > FaceConstPtrArray;
 
 
 
//typedef OdArray<const Edge*, OdMemoryAllocator<const Edge*> > EdgeConstPtrArray;
 
enum FaceState {
  kInitialFaceState,
  kFaceToClone,
  kFaceToRemove,
  kProcessed
};
 
struct FaceData : SpatialFaceData, OdSiShape
{
  bool contains( const OdGeExtents3d& , bool , const OdGeTol& ) const 
  {
    return false;
  }
 
  bool intersects( const OdGeExtents3d& extents, bool planar, const OdGeTol& tol ) const 
  {
    return !extents.isDisjoint( m_ext, tol );
  }
 
  FaceData() : m_state(kInitialFaceState) {}
  OdUInt32 m_state;
};
 
 
template<class TSpatialFaceData = SpatialFaceData>
class Slicer : public SlicerBaseImpl,
               protected OdSiVisitor
{
  void visit( OdSiEntity* pEntity, bool  ) {
    TSpatialFaceData* pFaceData = static_cast<TSpatialFaceData*>( pEntity );
 
#ifdef _DEBUG
    //IDebugAssist* pAssist = CreateDebugAssistant();
    //pAssist->DebugDrawFace( pFaceData->face(), 0 );
#endif
 
    collect_segments( pFaceData->face() );
  }
public:
  void initSlicerAndFaceIndex( const Body* pBody, FaceSpatialIndex<TSpatialFaceData>& faceSpatialIndex, double eps = OdGeTol().equalVector() ) {
    reserveBuffers( pBody->faceCount() );
    OdGeTol sitol = faceSpatialIndex.build( pBody, eps ).tolerance();
    setTolerance( OdGeTol( sitol.equalPoint() / sitol.equalVector() * eps, eps ) );
  }
 
  void slice( const OdGePlane& cutPlane,
              const FaceSpatialIndex<TSpatialFaceData>& faceSpatial,
              Profile2D* pResultIncludingBoundary, 
              Profile2D* pResultExcludingCoincidingBoundary = 0,
              Profile2D* pResultExcludingOppositeBoundary = 0,
              Profile2D* pResultExcludingBoundary = 0,
              FaceConstPtrArray* pCoincidingFaces = 0,
              FaceConstPtrArray* pOppositeFaces = 0,
              bool bUseReverseEdgeAtMerge = false,
              OdArray<const Edge*>* sourceEdges = 0)
  {
    EdgeGraph::Clear();
    setTolerance(OdGeTol(faceSpatial.index().tolerance().equalPoint(), 1e-5));
    set_cut_plane( cutPlane );
    ReserveBuffers( faceSpatial.size() );
    faceSpatial.index().query( OdSiShapePlane( cutPlane ), *this );
    build_results( pResultIncludingBoundary, 
      pResultExcludingCoincidingBoundary,
      pResultExcludingOppositeBoundary,
      pResultExcludingBoundary,
      pCoincidingFaces, pOppositeFaces, bUseReverseEdgeAtMerge, sourceEdges );
    // algo should not produce duplicates, but it does
    if(pResultExcludingOppositeBoundary != NULL)
    {
      pResultExcludingOppositeBoundary->deleteCoincident(1.e-10);
    }
  }
};
 
}