ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-29 02:40:35 +05:00
Code Issues Packages Projects Releases Wiki Activity

0022124: [CEA 763] Projection 1D does not work with Netgen 1D2D

Browse Source 
Move struct AlgoData from SMESH_Gen.cxx to struct SMESH_Algo::Features
This commit is contained in:
eap 2013-02-26 10:37:45 +00:00
parent a1c4092296
commit 27bf438fc0
3 changed files with 131 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
src/SMESH/SMESH_Algo.cxx
View File

@ -49,6 +49,7 @@
#include <GCPnts_AbscissaPoint.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <Geom_Surface.hxx>
#include <LDOMParser.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopLoc_Location.hxx>
@ -73,6 +74,98 @@
using namespace std;
//================================================================================
/*!
* \brief Returns \a true if two algorithms (described by \a this and the given
* algo data) are compatible by their output and input types of elements.
*/
//================================================================================
bool SMESH_Algo::Features::IsCompatible( const SMESH_Algo::Features& algo2 ) const
{
if ( _dim > algo2._dim ) return algo2.IsCompatible( *this );
// algo2 is of highter dimension
if ( _outElemTypes.empty() || algo2._inElemTypes.empty() )
return false;
bool compatible = true;
set<SMDSAbs_GeometryType>::const_iterator myOutType = _outElemTypes.begin();
for ( ; myOutType != _outElemTypes.end() && compatible; ++myOutType )
compatible = algo2._inElemTypes.count( *myOutType );
return compatible;
}
//================================================================================
/*!
* \brief Return Data of the algorithm
*/
//================================================================================
const SMESH_Algo::Features& SMESH_Algo::GetFeatures( const std::string& algoType )
{
static map< string, SMESH_Algo::Features > theFeaturesByName;
if ( theFeaturesByName.empty() )
{
// Read Plugin.xml files
vector< string > xmlPaths = SMESH_Gen::GetPluginXMLPaths();
LDOMParser xmlParser;
for ( size_t iXML = 0; iXML < xmlPaths.size(); ++iXML )
{
bool error = xmlParser.parse( xmlPaths[iXML].c_str() );
if ( error )
{
TCollection_AsciiString data;
INFOS( xmlParser.GetError(data) );
continue;
}
// <algorithm type="Regular_1D"
// ...
// input="EDGE"
// output="QUAD,TRIA">
//
LDOM_Document xmlDoc = xmlParser.getDocument();
LDOM_NodeList algoNodeList = xmlDoc.getElementsByTagName( "algorithm" );
for ( int i = 0; i < algoNodeList.getLength(); ++i )
{
LDOM_Node algoNode = algoNodeList.item( i );
LDOM_Element& algoElem = (LDOM_Element&) algoNode;
TCollection_AsciiString algoType = algoElem.getAttribute("type");
TCollection_AsciiString input = algoElem.getAttribute("input");
TCollection_AsciiString output = algoElem.getAttribute("output");
TCollection_AsciiString dim = algoElem.getAttribute("dim");
TCollection_AsciiString label = algoElem.getAttribute("label-id");
if ( algoType.IsEmpty() ) continue;
Features & data = theFeaturesByName[ algoType.ToCString() ];
data._dim = dim.IntegerValue();
data._label = label.ToCString();
for ( int isInput = 0; isInput < 2; ++isInput )
{
TCollection_AsciiString& typeStr = isInput ? input : output;
set<SMDSAbs_GeometryType>& typeSet = isInput ? data._inElemTypes : data._outElemTypes;
int beg = 1, end;
while ( beg <= typeStr.Length() )
{
while ( beg < typeStr.Length() && !isalpha( typeStr.Value( beg ) ))
++beg;
end = beg;
while ( end < typeStr.Length() && isalpha( typeStr.Value( end + 1 ) ))
++end;
if ( end > beg )
{
TCollection_AsciiString typeName = typeStr.SubString( beg, end );
if ( typeName == "EDGE" ) typeSet.insert( SMDSGeom_EDGE );
else if ( typeName == "TRIA" ) typeSet.insert( SMDSGeom_TRIANGLE );
else if ( typeName == "QUAD" ) typeSet.insert( SMDSGeom_QUADRANGLE );
}
beg = end + 1;
}
}
}
}
}
return theFeaturesByName[ algoType ];
}
//=============================================================================
/*!
*

35
src/SMESH/SMESH_Algo.hxx
View File

@ -30,9 +30,10 @@
#include "SMESH_SMESH.hxx"
#include "SMESH_Hypothesis.hxx"
#include "SMESH_ComputeError.hxx"
#include "SMDSAbs_ElementType.hxx"
#include "SMESH_Comment.hxx"
#include "SMESH_ComputeError.hxx"
#include "SMESH_Hypothesis.hxx"
#include <TopoDS_Shape.hxx>
#include <TopoDS_Edge.hxx>
@ -42,6 +43,7 @@
#include <vector>
#include <list>
#include <map>
#include <set>
class SMDS_MeshNode;
class SMESHDS_Mesh;
@ -60,6 +62,7 @@ class gp_XYZ;
typedef std::map< SMESH_subMesh*, std::vector<int> > MapShapeNbElems;
typedef std::map< SMESH_subMesh*, std::vector<int> >::iterator MapShapeNbElemsItr;
// ==================================================================================
/*!
* \brief Root of all algorithms
*
@ -69,9 +72,33 @@ typedef std::map< SMESH_subMesh*, std::vector<int> >::iterator MapShapeNbElemsIt
* - methods related to dependencies between sub-meshes imposed by the algorith
* - static utilities, like EdgeLength()
*/
class SMESH_EXPORT SMESH_Algo:public SMESH_Hypothesis
// ==================================================================================
class SMESH_EXPORT SMESH_Algo : public SMESH_Hypothesis
{
public:
public:
//==================================================================================
/*!
* \brief Structure describing algorithm features
*/
// --------------------------------------------------------------------------------
struct Features
{
int _dim;
std::set<SMDSAbs_GeometryType> _inElemTypes; // acceptable types of input mesh element
std::set<SMDSAbs_GeometryType> _outElemTypes; // produced types of mesh elements
std::string _label; // GUI type name
bool IsCompatible( const Features& algo2 ) const;
};
/*!
* \brief Returns a structure describing algorithm features
*/
static const Features& GetFeatures( const std::string& algoType );
const Features& GetFeatures() const { return GetFeatures( _name ); }
public:
//==================================================================================
/*!
* \brief Creates algorithm
* \param hypId - algorithm ID

107
src/SMESH/SMESH_Gen.cxx
View File

@ -43,13 +43,12 @@
#include "Utils_ExceptHandlers.hxx"
#include <TopoDS_Iterator.hxx>
#include <LDOMParser.hxx>
#include "memoire.h"
#ifdef WNT
#include <windows.h>
#endif
#endif
using namespace std;
@ -998,100 +997,6 @@ std::vector< std::string > SMESH_Gen::GetPluginXMLPaths()
return xmlPaths;
}
//=======================================================================
namespace // Access to type of input and output of an algorithm
//=======================================================================
{
struct AlgoData
{
int _dim;
set<SMDSAbs_GeometryType> _inElemTypes; // acceptable types of input mesh element
set<SMDSAbs_GeometryType> _outElemTypes; // produced types of mesh elements
bool IsCompatible( const AlgoData& algo2 ) const
{
if ( _dim > algo2._dim ) return algo2.IsCompatible( *this );
// algo2 is of highter dimension
if ( _outElemTypes.empty() || algo2._inElemTypes.empty() )
return false;
bool compatible = true;
set<SMDSAbs_GeometryType>::const_iterator myOutType = _outElemTypes.begin();
for ( ; myOutType != _outElemTypes.end() && compatible; ++myOutType )
compatible = algo2._inElemTypes.count( *myOutType );
return compatible;
}
};
//================================================================================
/*!
* \brief Return AlgoData of the algorithm
*/
//================================================================================
const AlgoData& getAlgoData( const SMESH_Algo* algo )
{
static map< string, AlgoData > theDataByName;
if ( theDataByName.empty() )
{
// Read Plugin.xml files
vector< string > xmlPaths = SMESH_Gen::GetPluginXMLPaths();
LDOMParser xmlParser;
for ( size_t iXML = 0; iXML < xmlPaths.size(); ++iXML )
{
bool error = xmlParser.parse( xmlPaths[iXML].c_str() );
if ( error )
{
TCollection_AsciiString data;
INFOS( xmlParser.GetError(data) );
continue;
}
// <algorithm type="Regular_1D"
// ...
// input="EDGE"
// output="QUAD,TRIA">
//
LDOM_Document xmlDoc = xmlParser.getDocument();
LDOM_NodeList algoNodeList = xmlDoc.getElementsByTagName( "algorithm" );
for ( int i = 0; i < algoNodeList.getLength(); ++i )
{
LDOM_Node algoNode = algoNodeList.item( i );
LDOM_Element& algoElem = (LDOM_Element&) algoNode;
TCollection_AsciiString algoType = algoElem.getAttribute("type");
TCollection_AsciiString input = algoElem.getAttribute("input");
TCollection_AsciiString output = algoElem.getAttribute("output");
TCollection_AsciiString dim = algoElem.getAttribute("dim");
if ( algoType.IsEmpty() ) continue;
AlgoData & data = theDataByName[ algoType.ToCString() ];
data._dim = dim.IntegerValue();
for ( int isInput = 0; isInput < 2; ++isInput )
{
TCollection_AsciiString& typeStr = isInput ? input : output;
set<SMDSAbs_GeometryType>& typeSet = isInput ? data._inElemTypes : data._outElemTypes;
int beg = 1, end;
while ( beg <= typeStr.Length() )
{
while ( beg < typeStr.Length() && !isalpha( typeStr.Value( beg ) ))
++beg;
end = beg;
while ( end < typeStr.Length() && isalpha( typeStr.Value( end + 1 ) ))
++end;
if ( end > beg )
{
TCollection_AsciiString typeName = typeStr.SubString( beg, end );
if ( typeName == "EDGE" ) typeSet.insert( SMDSGeom_EDGE );
else if ( typeName == "TRIA" ) typeSet.insert( SMDSGeom_TRIANGLE );
else if ( typeName == "QUAD" ) typeSet.insert( SMDSGeom_QUADRANGLE );
}
beg = end + 1;
}
}
}
}
}
return theDataByName[ algo->GetName() ];
}
}
//=============================================================================
/*!
* Finds algo to mesh a shape. Optionally returns a shape the found algo is bound to
@ -1105,6 +1010,8 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh & aMesh,
SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() );
filter.And( filter.IsApplicableTo( aShape ));
typedef SMESH_Algo::Features AlgoData;
TopoDS_Shape assignedToShape;
SMESH_Algo* algo =
(SMESH_Algo*) aMesh.GetHypothesis( aShape, filter, true, &assignedToShape );
@ -1144,10 +1051,10 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh & aMesh,
// check compatibility of algos
if ( algos3D.size() > 1 )
{
const AlgoData& algoData = getAlgoData( algo );
const AlgoData& algoData2 = getAlgoData( algo2 );
const AlgoData& algoData3d0 = getAlgoData( algos3D[0] );
const AlgoData& algoData3d1 = getAlgoData( algos3D[1] );
const AlgoData& algoData = algo->SMESH_Algo::GetFeatures();
const AlgoData& algoData2 = algo2->SMESH_Algo::GetFeatures();
const AlgoData& algoData3d0 = algos3D[0]->SMESH_Algo::GetFeatures();
const AlgoData& algoData3d1 = algos3D[1]->SMESH_Algo::GetFeatures();
if (( algoData2.IsCompatible( algoData3d0 ) &&
algoData2.IsCompatible( algoData3d1 ))
&&