ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-27 09:50:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

0022362: EDF SMESH: Quadrangle (mapping) algorithm: enforced vertices

Browse Source
This commit is contained in:
eap 2013-12-17 08:13:40 +00:00
parent 046b185660
commit 9858978294
8 changed files with 2100 additions and 368 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
idl/SMESH_BasicHypothesis.idl
View File

@ -807,6 +807,22 @@ module StdMeshers
* Get the type of quadrangulation
*/
QuadType GetQuadType();
/*!
* Set positions of enforced nodes
*/
void SetEnforcedNodes(in GEOM::ListOfGO vertices, in SMESH::nodes_array points)
raises (SALOME::SALOME_Exception);
/*!
* Returns positions of enforced nodes
*/
void GetEnforcedNodes(out GEOM::ListOfGO vertices, out SMESH::nodes_array points);
/*!
* Returns entries of shapes defining enforced nodes
*/
SMESH::string_array GetEnfVertices();
};
/*!

38
src/SMESH_SWIG/StdMeshersBuilder.py
View File

@ -555,25 +555,53 @@ class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
# will be created while other elements will be quadrangles.
# Vertex can be either a GEOM_Object or a vertex ID within the
# shape to mesh
# @param UseExisting: if ==true - searches for the existing hypothesis created with
# @param enfVertices: list of shapes defining positions where nodes (enforced nodes)
# must be created by the mesher. Shapes can be of any type,
# vertices of given shapes define positions of enforced nodes.
# Only vertices successfully projected to the face are used.
# @param enfPoint: list of points giving positions of enforced nodes.
# Point can be defined either as SMESH.PointStruct's
# ([SMESH.PointStruct(x1,y1,z1), SMESH.PointStruct(x2,y2,z2),...])
# or triples of values ([[x1,y1,z1], [x2,y2,z2], ...]).
# In the case if the defined QuadrangleParameters() refer to a sole face,
# all given points must lie on this face, else the mesher fails.
# @param UseExisting: if \c True - searches for the existing hypothesis created with
# the same parameters, else (default) - creates a new one
# @ingroup l3_hypos_quad
def QuadrangleParameters(self, quadType=StdMeshers.QUAD_STANDARD, triangleVertex=0, UseExisting=0):
import GEOM
def QuadrangleParameters(self, quadType=StdMeshers.QUAD_STANDARD, triangleVertex=0,
enfVertices=[],enfPoints=[],UseExisting=0):
import GEOM, SMESH
vertexID = triangleVertex
if isinstance( triangleVertex, GEOM._objref_GEOM_Object ):
vertexID = self.mesh.geompyD.GetSubShapeID( self.mesh.geom, triangleVertex )
if isinstance( enfVertices, int ) and not enfPoints and not UseExisting:
# a call of old syntax, before inserting enfVertices and enfPoints before UseExisting
UseExisting, enfVertices = enfVertices, []
pStructs, xyz = [], []
for p in enfPoints:
if isinstance( p, SMESH.PointStruct ):
xyz.append(( p.x, p.y, p.z ))
pStructs.append( p )
else:
xyz.append(( p[0], p[1], p[2] ))
pStructs.append( SMESH.PointStruct( p[0], p[1], p[2] ))
if not self.params:
compFun = lambda hyp,args: \
hyp.GetQuadType() == args[0] and \
( hyp.GetTriaVertex()==args[1] or ( hyp.GetTriaVertex()<1 and args[1]<1))
self.params = self.Hypothesis("QuadrangleParams", [quadType,vertexID],
(hyp.GetTriaVertex()==args[1] or ( hyp.GetTriaVertex()<1 and args[1]<1)) and \
((hyp.GetEnforcedNodes()) == (args[2],args[3])) # True w/o enfVertices only
entries = [ shape.GetStudyEntry() for shape in enfVertices ]
self.params = self.Hypothesis("QuadrangleParams", [quadType,vertexID,entries,xyz],
UseExisting = UseExisting, CompareMethod=compFun)
pass
if self.params.GetQuadType() != quadType:
self.params.SetQuadType(quadType)
if vertexID > 0:
self.params.SetTriaVertex( vertexID )
from salome.smesh.smeshBuilder import AssureGeomPublished
for v in enfVertices:
AssureGeomPublished( self.mesh, v )
self.params.SetEnforcedNodes( enfVertices, pStructs )
return self.params
## Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only

80
src/StdMeshers/StdMeshers_QuadrangleParams.cxx
View File

@ -87,6 +87,43 @@ void StdMeshers_QuadrangleParams::SetQuadType (StdMeshers_QuadType type)
}
}
//================================================================================
/*!
* \brief Set positions of enforced nodes
*/
//================================================================================
void StdMeshers_QuadrangleParams::
SetEnforcedNodes( const std::vector< TopoDS_Shape >& shapes,
const std::vector< gp_Pnt >& points )
{
bool isChanged = ( shapes != _enforcedVertices ||
points.size() != _enforcedPoints.size() );
for ( size_t i = 0; i < points.size() && !isChanged; ++i )
isChanged = ( _enforcedPoints[ i ].SquareDistance( points[i] ) > 1e-100 );
if ( isChanged )
{
_enforcedVertices = shapes;
_enforcedPoints = points;
NotifySubMeshesHypothesisModification();
}
}
//================================================================================
/*!
* \brief Returns positions of enforced nodes
*/
//================================================================================
void StdMeshers_QuadrangleParams::
GetEnforcedNodes( std::vector< TopoDS_Shape >& shapes,
std::vector< gp_Pnt >& points ) const
{
shapes = _enforcedVertices;
points = _enforcedPoints;
}
//=============================================================================
/*!
*
@ -98,6 +135,13 @@ ostream & StdMeshers_QuadrangleParams::SaveTo(ostream & save)
save << _triaVertexID << " UNDEFINED " << int(_quadType);
else
save << _triaVertexID << " " << _objEntry << " " << int(_quadType);
save << " " << _enforcedPoints.size();
for ( size_t i = 0; i < _enforcedPoints.size(); ++i )
save << " " << _enforcedPoints[i].X()
<< " " << _enforcedPoints[i].Y()
<< " " << _enforcedPoints[i].Z();
return save;
}
@ -122,29 +166,25 @@ istream & StdMeshers_QuadrangleParams::LoadFrom(istream & load)
if (isOK)
_quadType = StdMeshers_QuadType(type);
// _enforcedVertices are loaded at StdMeshers_I level
// because GEOM objects are referred by study entry.
int nbP = 0;
double x,y,z;
if ( load >> nbP && nbP > 0 )
{
_enforcedPoints.reserve( nbP );
while ( _enforcedPoints.size() < _enforcedPoints.capacity() )
if ( load >> x &&
load >> y &&
load >> z )
_enforcedPoints.push_back( gp_Pnt( x,y,z ));
else
break;
}
return load;
}
//=============================================================================
/*!
*
*/
//=============================================================================
ostream & operator <<(ostream & save, StdMeshers_QuadrangleParams & hyp)
{
return hyp.SaveTo( save );
}
//=============================================================================
/*!
*
*/
//=============================================================================
istream & operator >>(istream & load, StdMeshers_QuadrangleParams & hyp)
{
return hyp.LoadFrom( load );
}
//================================================================================
/*!
* \brief Redifined method

21
src/StdMeshers/StdMeshers_QuadrangleParams.hxx
View File

@ -24,9 +24,12 @@
#define _SMESH_QUADRANGLEPARAMS_HXX_
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include <gp_Pnt.hxx>
#include <vector>
#include <string>
enum StdMeshers_QuadType
{
@ -38,8 +41,7 @@ enum StdMeshers_QuadType
QUAD_NB_TYPES
};
class STDMESHERS_EXPORT StdMeshers_QuadrangleParams:
public SMESH_Hypothesis
class STDMESHERS_EXPORT StdMeshers_QuadrangleParams: public SMESH_Hypothesis
{
public:
StdMeshers_QuadrangleParams(int hypId, int studyId, SMESH_Gen* gen);
@ -54,12 +56,13 @@ public:
void SetQuadType (StdMeshers_QuadType type);
StdMeshers_QuadType GetQuadType() const { return _quadType; }
void SetEnforcedNodes( const std::vector< TopoDS_Shape >& shapes,
const std::vector< gp_Pnt >& points );
void GetEnforcedNodes( std::vector< TopoDS_Shape >& shapes,
std::vector< gp_Pnt >& points ) const;
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
friend std::ostream& operator << (std::ostream & save,
StdMeshers_QuadrangleParams & hyp);
friend std::istream& operator >> (std::istream & load,
StdMeshers_QuadrangleParams & hyp);
/*!
* \brief Initialize start and end length by the mesh built on the geometry
@ -81,6 +84,8 @@ protected:
int _triaVertexID;
std::string _objEntry;
StdMeshers_QuadType _quadType;
std::vector< TopoDS_Shape > _enforcedVertices;
std::vector< gp_Pnt > _enforcedPoints;
};
#endif

1881
src/StdMeshers/StdMeshers_Quadrangle_2D.cxx
View File

File diff suppressed because it is too large Load Diff

112
src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
View File

@ -30,31 +30,77 @@
#include "SMESH_Algo.hxx"
#include "SMESH_ProxyMesh.hxx"
#include "SMESH_StdMeshers.hxx"
#include "StdMeshers_FaceSide.hxx"
#include "StdMeshers_QuadrangleParams.hxx"
#include <TopoDS_Face.hxx>
#include <Bnd_B2d.hxx>
class SMDS_MeshNode;
class SMESH_Mesh;
class SMESH_MesherHelper;
class SMESH_ProxyMesh;
class StdMeshers_FaceSide;
struct uvPtStruct;
enum TSideID { QUAD_BOTTOM_SIDE=0, QUAD_RIGHT_SIDE, QUAD_TOP_SIDE, QUAD_LEFT_SIDE, NB_QUAD_SIDES };
typedef uvPtStruct UVPtStruct;
typedef struct faceQuadStruct
struct FaceQuadStruct
{
std::vector< StdMeshers_FaceSide*> side;
bool isEdgeOut[4]; // true, if an EDGE has more nodes, than an opposite one
UVPtStruct* uv_grid;
struct Side // a side of FaceQuadStruct
{
struct Contact // contact of two sides
{
int point; // index of a grid point of this side where two sides meat
Side* other_side;
int other_point;
};
StdMeshers_FaceSidePtr grid;
int from, to; // indices of grid points used by the quad
std::set<int> forced_nodes; // indices of forced grid points
std::vector<Contact> contacts; // contacts with sides of other quads
int nbNodeOut; // nb of missing nodes on an opposite shorter side
Side(StdMeshers_FaceSidePtr theGrid = StdMeshers_FaceSidePtr());
Side& operator=(const Side& otherSide);
operator StdMeshers_FaceSidePtr() { return grid; }
operator const StdMeshers_FaceSidePtr() const { return grid; }
void AddContact( int ip, Side* side, int iop );
int ToSideIndex( int quadNodeIndex ) const;
int ToQuadIndex( int sideNodeIndex ) const;
bool IsForced( int nodeIndex ) const;
bool IsReversed() const { return nbNodeOut ? false : to < from; }
int NbPoints() const { return Abs( to - from ); }
double Param( int nodeIndex ) const;
double Length( int from=-1, int to=-1) const;
gp_XY Value2d( double x ) const;
// some sortcuts
const vector<UVPtStruct>& GetUVPtStruct(bool isXConst=0, double constValue=0) const
{ return nbNodeOut ?
grid->SimulateUVPtStruct( NbPoints()-nbNodeOut-1, isXConst, constValue ) :
grid->GetUVPtStruct( isXConst, constValue );
}
};
std::vector< Side > side;
std::vector< UVPtStruct> uv_grid;
int iSize, jSize;
TopoDS_Face face;
~faceQuadStruct();
Bnd_B2d uv_box;
FaceQuadStruct ( const TopoDS_Face& F = TopoDS_Face() );
UVPtStruct& UVPt( int i, int j ) { return uv_grid[ i + j * iSize ]; }
void shift ( size_t nb, bool keepUnitOri );
typedef boost::shared_ptr<faceQuadStruct> Ptr;
} FaceQuadStruct;
int & nbNodeOut( int iSide ) { return side[ iSide ].nbNodeOut; }
bool findCell ( const gp_XY& uv, int & i, int & j );
bool isNear ( const gp_XY& uv, int & i, int & j, int nbLoops=1 );
bool isEqual ( const gp_XY& uv, int i, int j );
void normPa2IJ( double x, double y, int & i, int & j );
void updateUV ( const gp_XY& uv, int i, int j, bool isVertical );
typedef boost::shared_ptr<FaceQuadStruct> Ptr;
};
class STDMESHERS_EXPORT StdMeshers_Quadrangle_2D: public SMESH_2D_Algo
{
@ -89,17 +135,18 @@ protected:
std::vector<int>& aNbNodes,
bool& IsQuadratic);
bool setNormalizedGrid(SMESH_Mesh& aMesh,
const TopoDS_Face& aFace,
FaceQuadStruct::Ptr& quad);
bool setNormalizedGrid(FaceQuadStruct::Ptr quad);
void splitQuad(SMESHDS_Mesh *theMeshDS,
void splitQuadFace(SMESHDS_Mesh * theMeshDS,
const int theFaceID,
const SMDS_MeshNode* theNode1,
const SMDS_MeshNode* theNode2,
const SMDS_MeshNode* theNode3,
const SMDS_MeshNode* theNode4);
bool computeQuadDominant(SMESH_Mesh& aMesh,
const TopoDS_Face& aFace);
bool computeQuadDominant(SMESH_Mesh& aMesh,
const TopoDS_Face& aFace,
FaceQuadStruct::Ptr quad);
@ -108,6 +155,10 @@ protected:
const TopoDS_Face& aFace,
FaceQuadStruct::Ptr quad);
bool computeTriangles(SMESH_Mesh& aMesh,
const TopoDS_Face& aFace,
FaceQuadStruct::Ptr quad);
bool evaluateQuadPref(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
std::vector<int>& aNbNodes,
@ -129,20 +180,43 @@ protected:
int & theNbDegenEdges,
const bool considerMesh);
bool getEnforcedUV();
bool addEnforcedNodes();
int splitQuad(FaceQuadStruct::Ptr quad, int i, int j);
typedef std::map< StdMeshers_FaceSidePtr, std::vector< FaceQuadStruct::Ptr > > TQuadsBySide;
void updateSideUV( FaceQuadStruct::Side& side,
int iForced,
const TQuadsBySide& quads,
int * iNext=NULL);
// Fields
// true if QuadranglePreference hypothesis is assigned that forces
// construction of quadrangles if the number of nodes on opposite edges
// is not the same in the case where the global number of nodes on edges
// is even
bool myQuadranglePreference;
bool myTrianglePreference;
int myTriaVertexID;
bool myNeedSmooth;
const StdMeshers_QuadrangleParams* myParams;
StdMeshers_QuadType myQuadType;
SMESH_MesherHelper* myHelper; // tool for working with quadratic elements
SMESH_MesherHelper* myHelper;
SMESH_ProxyMesh::Ptr myProxyMesh;
FaceQuadStruct::Ptr myQuadStruct;
std::list< FaceQuadStruct::Ptr > myQuadList;
struct ForcedPoint
{
gp_XY uv;
gp_XYZ xyz;
TopoDS_Vertex vertex;
double U() const { return uv.X(); }
double V() const { return uv.Y(); }
operator const gp_XY& () { return uv; }
};
std::vector< ForcedPoint > myForcedPnts;
};
#endif

176
src/StdMeshers_I/StdMeshers_QuadrangleParams_i.cxx
View File

@ -21,14 +21,17 @@
// Module : SMESH
#include "StdMeshers_QuadrangleParams_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_PythonDump.hxx"
#include "StdMeshers_ObjRefUlils.hxx"
#include "Utils_CorbaException.hxx"
#include "utilities.h"
#include <Utils_CorbaException.hxx>
#include <utilities.h>
#include <TCollection_AsciiString.hxx>
#include <Standard_ErrorHandler.hxx>
#include "SMESH_TryCatch.hxx"
using namespace std;
@ -82,13 +85,11 @@ void StdMeshers_QuadrangleParams_i::SetTriaVertex(CORBA::Long vertID)
this->GetImpl()->SetTriaVertex( vertID );
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
SALOME::BAD_PARAM );
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
}
// Update Python script
SMESH::TPythonDump() << _this() << ".SetTriaVertex( "
<< vertID << " )";
SMESH::TPythonDump() << _this() << ".SetTriaVertex( " << vertID << " )";
}
//=============================================================================
@ -147,8 +148,7 @@ char* StdMeshers_QuadrangleParams_i::GetObjectEntry()
entry = this->GetImpl()->GetObjectEntry();
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
SALOME::BAD_PARAM );
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
}
return CORBA::string_dup( entry );
}
@ -162,12 +162,6 @@ char* StdMeshers_QuadrangleParams_i::GetObjectEntry()
//=============================================================================
void StdMeshers_QuadrangleParams_i::SetQuadType(StdMeshers::QuadType type)
{
//static char* quadTypes[5] = {"StdMeshers.QUAD_STANDARD",
// "StdMeshers.QUAD_TRIANGLE_PREF",
// "StdMeshers.QUAD_QUADRANGLE_PREF",
// "StdMeshers.QUAD_QUADRANGLE_PREF_REVERSED",
// "StdMeshers.QUAD_REDUCED"};
MESSAGE("StdMeshers_QuadrangleParams_i::SetQuadType");
ASSERT(myBaseImpl);
@ -199,7 +193,6 @@ void StdMeshers_QuadrangleParams_i::SetQuadType(StdMeshers::QuadType type)
quadType = "UNKNOWN";
}
SMESH::TPythonDump() << _this() << ".SetQuadType( " << quadType << " )";
//SMESH::TPythonDump() << _this() << ".SetQuadType( " << quadTypes[int(type)] << " )";
}
//=============================================================================
@ -216,6 +209,100 @@ StdMeshers::QuadType StdMeshers_QuadrangleParams_i::GetQuadType()
return StdMeshers::QuadType(int(this->GetImpl()->GetQuadType()));
}
//================================================================================
/*!
* \brief Set positions of enforced nodes
*/
//================================================================================
void StdMeshers_QuadrangleParams_i::SetEnforcedNodes(const GEOM::ListOfGO& theVertices,
const SMESH::nodes_array& thePoints)
throw ( SALOME::SALOME_Exception )
{
try {
std::vector< TopoDS_Shape > shapes;
std::vector< gp_Pnt > points;
shapes.reserve( theVertices.length() );
points.reserve( thePoints.length() );
myShapeEntries.clear();
for ( size_t i = 0; i < theVertices.length(); ++i )
{
if ( CORBA::is_nil( theVertices[i] ))
continue;
CORBA::String_var entry = theVertices[i]->GetStudyEntry();
if ( !entry.in() || !entry.in()[0] )
THROW_SALOME_CORBA_EXCEPTION( "Not published enforced vertex shape", SALOME::BAD_PARAM );
shapes.push_back( StdMeshers_ObjRefUlils::GeomObjectToShape( theVertices[i].in() ));
myShapeEntries.push_back( entry.in() );
}
for ( size_t i = 0; i < thePoints.length(); ++i )
{
points.push_back( gp_Pnt( thePoints[i].x, thePoints[i].y, thePoints[i].z ));
}
this->GetImpl()->SetEnforcedNodes( shapes, points );
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
}
// Update Python script
SMESH::TPythonDump() << _this() << ".SetEnforcedNodes( "
<< theVertices << ", " << thePoints << " )";
}
//================================================================================
/*!
* \brief Returns positions of enforced nodes
*/
//================================================================================
void StdMeshers_QuadrangleParams_i::GetEnforcedNodes(GEOM::ListOfGO_out theVertices,
SMESH::nodes_array_out thePoints)
{
SMESH_TRY;
std::vector< TopoDS_Shape > shapes;
std::vector< gp_Pnt > points;
this->GetImpl()->GetEnforcedNodes( shapes, points );
theVertices = new GEOM::ListOfGO;
thePoints = new SMESH::nodes_array;
size_t i = 0;
theVertices->length( myShapeEntries.size() );
for ( i = 0; i < myShapeEntries.size(); ++i )
theVertices[i] =
StdMeshers_ObjRefUlils::EntryOrShapeToGeomObject( myShapeEntries[i], shapes[i] );
thePoints->length( points.size() );
for ( i = 0; i < points.size(); ++i )
{
thePoints[i].x = points[i].X();
thePoints[i].y = points[i].Y();
thePoints[i].z = points[i].Z();
}
SMESH_CATCH( SMESH::doNothing );
}
//================================================================================
/*!
* \brief Returns study entries of shapes defining enforced nodes
*/
//================================================================================
SMESH::string_array* StdMeshers_QuadrangleParams_i::GetEnfVertices()
{
SMESH::string_array_var arr = new SMESH::string_array;
arr->length( myShapeEntries.size() );
for ( size_t i = 0; i < myShapeEntries.size(); ++i )
arr[ i ] = myShapeEntries[ i ].c_str();
return arr._retn();
}
//=============================================================================
/*!
* StdMeshers_QuadrangleParams_i::GetImpl
@ -243,3 +330,58 @@ CORBA::Boolean StdMeshers_QuadrangleParams_i::IsDimSupported( SMESH::Dimension t
{
return type == SMESH::DIM_2D;
}
//================================================================================
/*!
* \brief Write parameters in a string
* \retval char* - resulting string
*/
//================================================================================
char* StdMeshers_QuadrangleParams_i::SaveTo()
{
ASSERT( myBaseImpl );
std::ostringstream os;
os << "ENTRIES: " << myShapeEntries.size();
for ( size_t i = 0; i < myShapeEntries.size(); ++i )
StdMeshers_ObjRefUlils::SaveToStream( myShapeEntries[ i ], os );
os << " ";
myBaseImpl->SaveTo( os );
return CORBA::string_dup( os.str().c_str() );
}
//================================================================================
/*!
* \brief Retrieve parameters from the string
* \param theStream - the input string
*/
//================================================================================
void StdMeshers_QuadrangleParams_i::LoadFrom( const char* theStream )
{
ASSERT( myBaseImpl );
bool hasEntries = ( strncmp( "ENTRIES: ", theStream, 9 ) == 0 );
std::istringstream is( theStream + ( hasEntries ? 9 : 0 ));
if ( hasEntries )
{
int nb = 0;
if ( is >> nb && nb > 0 )
{
std::vector< TopoDS_Shape > shapes;
std::vector< gp_Pnt > points;
myShapeEntries.resize( nb );
for ( int i = 0; i < nb; ++i )
shapes.push_back( StdMeshers_ObjRefUlils::LoadFromStream( is, & myShapeEntries[i] ));
GetImpl()->SetEnforcedNodes( shapes, points );
}
}
myBaseImpl->LoadFrom( is );
}

28
src/StdMeshers_I/StdMeshers_QuadrangleParams_i.hxx
View File

@ -19,7 +19,6 @@
// File : StdMeshers_QuadrangleParams_i.hxx
// Author : Sergey KUUL, OCC
// Module : SMESH
// $Header$
#ifndef _SMESH_QUADRANGLEPARAMS_I_HXX_
#define _SMESH_QUADRANGLEPARAMS_I_HXX_
@ -47,13 +46,6 @@ public:
// Destructor
virtual ~StdMeshers_QuadrangleParams_i();
// Set length
//void SetLength( CORBA::Double theLength, CORBA::Boolean theIsStart )
// throw ( SALOME::SALOME_Exception );
// Get length
//CORBA::Double GetLength(CORBA::Boolean theIsStart);
// Set base vertex for triangles
void SetTriaVertex (CORBA::Long vertID);
@ -72,11 +64,31 @@ public:
// Get the type of quadrangulation
StdMeshers::QuadType GetQuadType();
// Set positions of enforced nodes
void SetEnforcedNodes(const GEOM::ListOfGO& vertices,
const SMESH::nodes_array& points) throw ( SALOME::SALOME_Exception );
// Returns positions of enforced nodes
void GetEnforcedNodes(GEOM::ListOfGO_out vertices, SMESH::nodes_array_out points);
// Returns entries of shapes defining enforced nodes
SMESH::string_array* GetEnfVertices();
// Get implementation
::StdMeshers_QuadrangleParams* GetImpl();
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Redefined Persistence
virtual char* SaveTo();
virtual void LoadFrom( const char* theStream );
protected:
std::vector<std::string> myShapeEntries;
};
#endif