-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "SMESH_Utils.hxx"
-#include <SMDS_MeshNode.hxx>
+#include "SMDS_SetIterator.hxx"
+#include "SMDS_MeshNode.hxx"
#include <gp_XYZ.hxx>
+#include <gp_XY.hxx>
#include <map>
#include <list>
#include <set>
#include <cassert>
+#include <boost/make_shared.hpp>
+
+typedef std::map<const SMDS_MeshElement*,
+ std::list<const SMDS_MeshElement*>, TIDCompare > TElemOfElemListMap;
typedef std::map<const SMDS_MeshElement*,
- std::list<const SMDS_MeshElement*> > TElemOfElemListMap;
-typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*> TNodeNodeMap;
+ std::list<const SMDS_MeshNode*>, TIDCompare > TElemOfNodeListMap;
+typedef std::map<const SMDS_MeshNode*,
+ const SMDS_MeshNode*, TIDCompare> TNodeNodeMap;
//!< Set of elements sorted by ID, to be used to assure predictability of edition
typedef std::set< const SMDS_MeshElement*, TIDCompare > TIDSortedElemSet;
typedef std::pair< const SMDS_MeshNode*, const SMDS_MeshNode* > NLink;
+struct FaceQuadStruct; // defined in StdMeshers_Quadrangle_2D.hxx
+typedef boost::shared_ptr<FaceQuadStruct> TFaceQuadStructPtr;
+
namespace SMESHUtils
{
TVECTOR v2( vec );
vec.swap( v2 );
}
+ /*!
+ * \brief Auto pointer
+ */
+ template <typename TOBJ>
+ struct Deleter
+ {
+ TOBJ* _obj;
+ explicit Deleter( TOBJ* obj = (TOBJ*)NULL ): _obj( obj ) {}
+ ~Deleter() { delete _obj; _obj = 0; }
+ TOBJ& operator*() const { return *_obj; }
+ TOBJ* operator->() const { return _obj; }
+ operator bool() const { return _obj; }
+ private:
+ Deleter( const Deleter& );
+ };
+ /*!
+ * \brief Auto pointer to array
+ */
+ template <typename TOBJ>
+ struct ArrayDeleter
+ {
+ TOBJ* _obj;
+ ArrayDeleter( TOBJ* obj ): _obj( obj ) {}
+ ~ArrayDeleter() { delete [] _obj; _obj = 0; }
+ private:
+ ArrayDeleter( const ArrayDeleter& );
+ };
+
+ template < class ELEM_SET >
+ SMDS_ElemIteratorPtr elemSetIterator( const ELEM_SET& elements )
+ {
+ typedef SMDS_SetIterator
+ < SMDS_pElement, typename ELEM_SET::const_iterator> TSetIterator;
+ return boost::make_shared< TSetIterator >( elements.begin(), elements.end() );
+ }
}
//=======================================================================
{ if ( first->GetID() < second->GetID() ) std::swap( first, second ); }
const SMDS_MeshNode* node1() const { return first; }
const SMDS_MeshNode* node2() const { return second; }
+
+ // methods for usage of SMESH_TLink as a hasher in NCollection maps
+ static int HashCode(const SMESH_TLink& link, int aLimit)
+ {
+ return ::HashCode( link.node1()->GetID() + link.node2()->GetID(), aLimit );
+ }
+ static Standard_Boolean IsEqual(const SMESH_TLink& l1, const SMESH_TLink& l2)
+ {
+ return ( l1.node1() == l2.node1() && l1.node2() == l2.node2() );
+ }
};
+typedef SMESH_TLink SMESH_Link;
//=======================================================================
/*!
//------------------------------------------
/*!
- * \brief SMDS_MeshNode -> gp_XYZ convertor
+ * \brief SMDS_MeshNode -> gp_XYZ converter
*/
//------------------------------------------
struct SMESH_TNodeXYZ : public gp_XYZ
{
const SMDS_MeshNode* _node;
- double _xyz[3];
- SMESH_TNodeXYZ( const SMDS_MeshElement* e):gp_XYZ(0,0,0),_node(0) {
+ SMESH_TNodeXYZ( const SMDS_MeshElement* e=0):gp_XYZ(0,0,0),_node(0)
+ {
+ Set(e);
+ }
+ bool Set( const SMDS_MeshElement* e=0 )
+ {
if (e) {
assert( e->GetType() == SMDSAbs_Node );
_node = static_cast<const SMDS_MeshNode*>(e);
- _node->GetXYZ(_xyz); // - thread safe getting coords
- SetCoord( _xyz[0], _xyz[1], _xyz[2] );
+ _node->GetXYZ( ChangeData() ); // - thread safe getting coords
+ return true;
}
+ return false;
}
+ const SMDS_MeshNode* Node() const { return _node; }
double Distance(const SMDS_MeshNode* n) const { return (SMESH_TNodeXYZ( n )-*this).Modulus(); }
double SquareDistance(const SMDS_MeshNode* n) const { return (SMESH_TNodeXYZ( n )-*this).SquareModulus(); }
- bool operator==(const SMESH_TNodeXYZ& other) const { return _node == other._node; }
+ bool operator==(const SMESH_TNodeXYZ& other) const { return _node == other._node; }
+ bool operator!=(const SMESH_TNodeXYZ& other) const { return _node != other._node; }
+ bool operator!() const { return !_node; }
+ const SMDS_MeshNode* operator->() const { return _node; }
+};
+typedef SMESH_TNodeXYZ SMESH_NodeXYZ;
+
+// --------------------------------------------------------------------------------
+// SMESH_Hasher provide methods needed to put mesh data to NCollection maps
+
+struct SMESH_Hasher
+{
+ static Standard_Integer HashCode(const SMDS_MeshElement* e, const Standard_Integer upper)
+ {
+ return ::HashCode( e->GetID(), upper );
+ }
+ static Standard_Boolean IsEqual( const SMDS_MeshElement* e1, const SMDS_MeshElement* e2 )
+ {
+ return ( e1 == e2 );
+ }
};
//--------------------------------------------------
double x, y; // 2d parameter, normalized [0,1]
const SMDS_MeshNode * node;
+ uvPtStruct(): node(NULL) {}
+
+ inline gp_XY UV() const { return gp_XY( u, v ); }
+ inline void SetUV( const gp_XY& uv ) { u = uv.X(); v = uv.Y(); }
+
struct NodeAccessor // accessor to iterate on nodes in UVPtStructVec
{
static const SMDS_MeshNode* value(std::vector< uvPtStruct >::const_iterator it)
// --------------------------------------------------------------------------------
// class SMESH_SequenceOfElemPtr
-#include <NCollection_DefineSequence.hxx>
-
-class SMDS_MeshElement;
-
-typedef const SMDS_MeshElement* SMDS_MeshElementPtr;
-
-DEFINE_BASECOLLECTION (SMESH_BaseCollectionElemPtr, SMDS_MeshElementPtr)
-DEFINE_SEQUENCE (SMESH_SequenceOfElemPtr, SMESH_BaseCollectionElemPtr, SMDS_MeshElementPtr)
+typedef std::vector< const SMDS_MeshElement* > SMESH_SequenceOfElemPtr;
// --------------------------------------------------------------------------------
// class SMESH_SequenceOfNode
+#include <NCollection_DefineSequence.hxx>
typedef const SMDS_MeshNode* SMDS_MeshNodePtr;
-DEFINE_BASECOLLECTION (SMESH_BaseCollectionNodePtr, SMDS_MeshNodePtr)
DEFINE_SEQUENCE(SMESH_SequenceOfNode,
SMESH_BaseCollectionNodePtr, SMDS_MeshNodePtr)
-// --------------------------------------------------------------------------------
-// #include "SMESHDS_DataMapOfShape.hxx"
-
-// #include <NCollection_DefineIndexedMap.hxx>
-
-// #include <TopoDS_Shape.hxx>
-
-/// Class SMESH_IndexedMapOfShape
-
-// DEFINE_BASECOLLECTION (SMESH_BaseCollectionShape, TopoDS_Shape)
-// DEFINE_INDEXEDMAP (SMESH_IndexedMapOfShape, SMESH_BaseCollectionShape, TopoDS_Shape)
-
-/// Class SMESH_IndexedDataMapOfShapeIndexedMapOfShape
-
-// DEFINE_BASECOLLECTION (SMESH_BaseCollectionIndexedMapOfShape, SMESH_IndexedMapOfShape)
-// DEFINE_INDEXEDDATAMAP (SMESH_IndexedDataMapOfShapeIndexedMapOfShape,
-// SMESH_BaseCollectionIndexedMapOfShape, TopoDS_Shape,
-// SMESH_IndexedMapOfShape)
-
-// --------------------------------------------------------------------------------
-// class SMESH_DataMapOfElemPtrSequenceOfElemPtr
-
-// SMESHUtils_EXPORT
-// inline Standard_Integer HashCode(SMDS_MeshElementPtr theElem,
-// const Standard_Integer theUpper)
-// {
-// void* anElem = (void*) theElem;
-// return HashCode(anElem,theUpper);
-// }
-
-// SMESHUtils_EXPORT
-// inline Standard_Boolean IsEqual(SMDS_MeshElementPtr theOne,
-// SMDS_MeshElementPtr theTwo)
-// {
-// return theOne == theTwo;
-// }
-
-// DEFINE_BASECOLLECTION (SMESH_BaseCollectionSequenceOfElemPtr, SMESH_SequenceOfElemPtr)
-// DEFINE_DATAMAP (SMESH_DataMapOfElemPtrSequenceOfElemPtr,
-// SMESH_BaseCollectionSequenceOfElemPtr,
-// SMDS_MeshElementPtr, SMESH_SequenceOfElemPtr)
-
#endif
