From 7ab128efcdd7781f4d344c9ca69868a5d6e37a26 Mon Sep 17 00:00:00 2001 From: vsr Date: Fri, 24 Aug 2012 05:32:18 +0000 Subject: [PATCH] Improvement of Python API documentation (SMESH and plugins): - move base Mesh_Algorithm class to the separate python module --- doc/salome/gui/SMESH/doxyfile_py.in | 5 +- src/SMESH_SWIG/Makefile.am | 1 + src/SMESH_SWIG/smeshDC.py | 287 +------------------------ src/SMESH_SWIG/smesh_algorithm.py | 322 ++++++++++++++++++++++++++++ 4 files changed, 333 insertions(+), 282 deletions(-) create mode 100644 src/SMESH_SWIG/smesh_algorithm.py diff --git a/doc/salome/gui/SMESH/doxyfile_py.in b/doc/salome/gui/SMESH/doxyfile_py.in index 04b3b3672..da25d092b 100755 --- a/doc/salome/gui/SMESH/doxyfile_py.in +++ b/doc/salome/gui/SMESH/doxyfile_py.in @@ -99,7 +99,10 @@ EXAMPLE_RECURSIVE = NO #--------------------------------------------------------------------------- #Input related options #--------------------------------------------------------------------------- -INPUT = smesh.py @top_srcdir@/src/SMESH_SWIG/StdMeshersDC.py tmp/smesh.py +INPUT = smesh.py \ + @top_srcdir@/src/SMESH_SWIG/smesh_algorithm.py \ + @top_srcdir@/src/SMESH_SWIG/StdMeshersDC.py \ + tmp/smesh.py FILE_PATTERNS = IMAGE_PATH = @srcdir@/images RECURSIVE = NO diff --git a/src/SMESH_SWIG/Makefile.am b/src/SMESH_SWIG/Makefile.am index 1801d0d35..fd1f9e29c 100644 --- a/src/SMESH_SWIG/Makefile.am +++ b/src/SMESH_SWIG/Makefile.am @@ -29,6 +29,7 @@ include $(top_srcdir)/adm_local/unix/make_common_starter.am dist_salomescript_PYTHON = \ smesh.py \ smeshDC.py \ + smesh_algorithm.py \ StdMeshersDC.py \ batchmode_smesh.py \ batchmode_mefisto.py \ diff --git a/src/SMESH_SWIG/smeshDC.py b/src/SMESH_SWIG/smeshDC.py index 7b99c3519..18b741cba 100644 --- a/src/SMESH_SWIG/smeshDC.py +++ b/src/SMESH_SWIG/smeshDC.py @@ -87,6 +87,7 @@ import geompyDC import SMESH # This is necessary for back compatibility from SMESH import * +from smesh_algorithm import Mesh_Algorithm import SALOME import SALOMEDS @@ -4073,283 +4074,10 @@ class Mesh: def GetSkew(self, elemId): return self._valueFromFunctor(SMESH.FT_Skew, elemId) -## The mother class to define algorithm, it is not recommended to use it directly. + pass # end of Mesh class + +## Helper class for wrapping of SMESH.SMESH_Pattern CORBA class # -# For each meshing algorithm, a python class inheriting from class Mesh_Algorithm -# should be defined. This descendant class sould have two attributes defining the way -# it is created by class Mesh (see e.g. class StdMeshersDC_Segment in StdMeshersDC.py). -# - meshMethod attribute defines name of method of class Mesh by calling which the -# python class of algorithm is created. E.g. if in class MyPlugin_Algorithm -# meshMethod = "MyAlgorithm", then an instance of MyPlugin_Algorithm is created -# by the following code: my_algo = mesh.MyAlgorithm() -# - algoType defines name of algorithm type and is used mostly to discriminate -# algorithms that are created by the same method of class Mesh. E.g. if -# MyPlugin_Algorithm.algoType = "MyPLUGIN" then it's creation code can be: -# my_algo = mesh.MyAlgorithm(algo="MyPLUGIN") -# @ingroup l2_algorithms -class Mesh_Algorithm: - # @class Mesh_Algorithm - # @brief Class Mesh_Algorithm - - #def __init__(self,smesh): - # self.smesh=smesh - def __init__(self): - self.mesh = None - self.geom = None - self.subm = None - self.algo = None - - ## Finds a hypothesis in the study by its type name and parameters. - # Finds only the hypotheses created in smeshpyD engine. - # @return SMESH.SMESH_Hypothesis - def FindHypothesis (self, hypname, args, CompareMethod, smeshpyD): - study = smeshpyD.GetCurrentStudy() - #to do: find component by smeshpyD object, not by its data type - scomp = study.FindComponent(smeshpyD.ComponentDataType()) - if scomp is not None: - res,hypRoot = scomp.FindSubObject(SMESH.Tag_HypothesisRoot) - # Check if the root label of the hypotheses exists - if res and hypRoot is not None: - iter = study.NewChildIterator(hypRoot) - # Check all published hypotheses - while iter.More(): - hypo_so_i = iter.Value() - attr = hypo_so_i.FindAttribute("AttributeIOR")[1] - if attr is not None: - anIOR = attr.Value() - hypo_o_i = salome.orb.string_to_object(anIOR) - if hypo_o_i is not None: - # Check if this is a hypothesis - hypo_i = hypo_o_i._narrow(SMESH.SMESH_Hypothesis) - if hypo_i is not None: - # Check if the hypothesis belongs to current engine - if smeshpyD.GetObjectId(hypo_i) > 0: - # Check if this is the required hypothesis - if hypo_i.GetName() == hypname: - # Check arguments - if CompareMethod(hypo_i, args): - # found!!! - return hypo_i - pass - pass - pass - pass - pass - iter.Next() - pass - pass - pass - return None - - ## Finds the algorithm in the study by its type name. - # Finds only the algorithms, which have been created in smeshpyD engine. - # @return SMESH.SMESH_Algo - def FindAlgorithm (self, algoname, smeshpyD): - study = smeshpyD.GetCurrentStudy() - if not study: return None - #to do: find component by smeshpyD object, not by its data type - scomp = study.FindComponent(smeshpyD.ComponentDataType()) - if scomp is not None: - res,hypRoot = scomp.FindSubObject(SMESH.Tag_AlgorithmsRoot) - # Check if the root label of the algorithms exists - if res and hypRoot is not None: - iter = study.NewChildIterator(hypRoot) - # Check all published algorithms - while iter.More(): - algo_so_i = iter.Value() - attr = algo_so_i.FindAttribute("AttributeIOR")[1] - if attr is not None: - anIOR = attr.Value() - algo_o_i = salome.orb.string_to_object(anIOR) - if algo_o_i is not None: - # Check if this is an algorithm - algo_i = algo_o_i._narrow(SMESH.SMESH_Algo) - if algo_i is not None: - # Checks if the algorithm belongs to the current engine - if smeshpyD.GetObjectId(algo_i) > 0: - # Check if this is the required algorithm - if algo_i.GetName() == algoname: - # found!!! - return algo_i - pass - pass - pass - pass - iter.Next() - pass - pass - pass - return None - - ## If the algorithm is global, returns 0; \n - # else returns the submesh associated to this algorithm. - def GetSubMesh(self): - return self.subm - - ## Returns the wrapped mesher. - def GetAlgorithm(self): - return self.algo - - ## Gets the list of hypothesis that can be used with this algorithm - def GetCompatibleHypothesis(self): - mylist = [] - if self.algo: - mylist = self.algo.GetCompatibleHypothesis() - return mylist - - ## Gets the name of the algorithm - def GetName(self): - GetName(self.algo) - - ## Sets the name to the algorithm - def SetName(self, name): - self.mesh.smeshpyD.SetName(self.algo, name) - - ## Gets the id of the algorithm - def GetId(self): - return self.algo.GetId() - - ## Private method. - def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"): - if geom is None: - raise RuntimeError, "Attemp to create " + hypo + " algoritm on None shape" - algo = self.FindAlgorithm(hypo, mesh.smeshpyD) - if algo is None: - algo = mesh.smeshpyD.CreateHypothesis(hypo, so) - pass - self.Assign(algo, mesh, geom) - return self.algo - - ## Private method - def Assign(self, algo, mesh, geom): - if geom is None: - raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape" - self.mesh = mesh - name = "" - if not geom: - self.geom = mesh.geom - else: - self.geom = geom - AssureGeomPublished( mesh, geom ) - try: - name = GetName(geom) - pass - except: - pass - self.subm = mesh.mesh.GetSubMesh(geom, algo.GetName()) - self.algo = algo - status = mesh.mesh.AddHypothesis(self.geom, self.algo) - TreatHypoStatus( status, algo.GetName(), name, True ) - return - - def CompareHyp (self, hyp, args): - print "CompareHyp is not implemented for ", self.__class__.__name__, ":", hyp.GetName() - return False - - def CompareEqualHyp (self, hyp, args): - return True - - ## Private method - def Hypothesis (self, hyp, args=[], so="libStdMeshersEngine.so", - UseExisting=0, CompareMethod=""): - hypo = None - if UseExisting: - if CompareMethod == "": CompareMethod = self.CompareHyp - hypo = self.FindHypothesis(hyp, args, CompareMethod, self.mesh.smeshpyD) - pass - if hypo is None: - hypo = self.mesh.smeshpyD.CreateHypothesis(hyp, so) - a = "" - s = "=" - for arg in args: - argStr = str(arg) - if isinstance( arg, geompyDC.GEOM._objref_GEOM_Object ): - argStr = arg.GetStudyEntry() - if not argStr: argStr = "GEOM_Obj_%s", arg.GetEntry() - if len( argStr ) > 10: - argStr = argStr[:7]+"..." - if argStr[0] == '[': argStr += ']' - a = a + s + argStr - s = "," - pass - if len(a) > 50: - a = a[:47]+"..." - self.mesh.smeshpyD.SetName(hypo, hyp + a) - pass - geomName="" - if self.geom: - geomName = GetName(self.geom) - status = self.mesh.mesh.AddHypothesis(self.geom, hypo) - TreatHypoStatus( status, GetName(hypo), geomName, 0 ) - return hypo - - ## Returns entry of the shape to mesh in the study - def MainShapeEntry(self): - if not self.mesh or not self.mesh.GetMesh(): return "" - if not self.mesh.GetMesh().HasShapeToMesh(): return "" - shape = self.mesh.GetShape() - return shape.GetStudyEntry() - - ## Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build - # near mesh boundary. This hypothesis can be used by several 3D algorithms: - # NETGEN 3D, GHS3D, Hexahedron(i,j,k) - # @param thickness total thickness of layers of prisms - # @param numberOfLayers number of layers of prisms - # @param stretchFactor factor (>1.0) of growth of layer thickness towards inside of mesh - # @param ignoreFaces list of geometrical faces (or their ids) not to generate layers on - # @ingroup l3_hypos_additi - def ViscousLayers(self, thickness, numberOfLayers, stretchFactor, ignoreFaces=[]): - if not isinstance(self.algo, SMESH._objref_SMESH_3D_Algo): - raise TypeError, "ViscousLayers are supported by 3D algorithms only" - if not "ViscousLayers" in self.GetCompatibleHypothesis(): - raise TypeError, "ViscousLayers are not supported by %s"%self.algo.GetName() - if ignoreFaces and isinstance( ignoreFaces[0], geompyDC.GEOM._objref_GEOM_Object ): - ignoreFaces = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, f) for f in ignoreFaces ] - hyp = self.Hypothesis("ViscousLayers", - [thickness, numberOfLayers, stretchFactor, ignoreFaces]) - hyp.SetTotalThickness(thickness) - hyp.SetNumberLayers(numberOfLayers) - hyp.SetStretchFactor(stretchFactor) - hyp.SetIgnoreFaces(ignoreFaces) - return hyp - - ## Transform a list of ether edges or tuples (edge, 1st_vertex_of_edge) - # into a list acceptable to SetReversedEdges() of some 1D hypotheses - # @ingroup l3_hypos_1dhyps - def ReversedEdgeIndices(self, reverseList): - resList = [] - geompy = self.mesh.geompyD - for i in reverseList: - if isinstance( i, int ): - s = geompy.SubShapes(self.mesh.geom, [i])[0] - if s.GetShapeType() != geompyDC.GEOM.EDGE: - raise TypeError, "Not EDGE index given" - resList.append( i ) - elif isinstance( i, geompyDC.GEOM._objref_GEOM_Object ): - if i.GetShapeType() != geompyDC.GEOM.EDGE: - raise TypeError, "Not an EDGE given" - resList.append( geompy.GetSubShapeID(self.mesh.geom, i )) - elif len( i ) > 1: - e = i[0] - v = i[1] - if not isinstance( e, geompyDC.GEOM._objref_GEOM_Object ) or \ - not isinstance( v, geompyDC.GEOM._objref_GEOM_Object ): - raise TypeError, "A list item must be a tuple (edge, 1st_vertex_of_edge)" - if v.GetShapeType() == geompyDC.GEOM.EDGE and \ - e.GetShapeType() == geompyDC.GEOM.VERTEX: - v,e = e,v - if e.GetShapeType() != geompyDC.GEOM.EDGE or \ - v.GetShapeType() != geompyDC.GEOM.VERTEX: - raise TypeError, "A list item must be a tuple (edge, 1st_vertex_of_edge)" - vFirst = FirstVertexOnCurve( e ) - tol = geompy.Tolerance( vFirst )[-1] - if geompy.MinDistance( v, vFirst ) > 1.5*tol: - resList.append( geompy.GetSubShapeID(self.mesh.geom, e )) - else: - raise TypeError, "Item must be either an edge or tuple (edge, 1st_vertex_of_edge)" - return resList - - class Pattern(SMESH._objref_SMESH_Pattern): def ApplyToMeshFaces(self, theMesh, theFacesIDs, theNodeIndexOnKeyPoint1, theReverse): @@ -4364,13 +4092,9 @@ class Pattern(SMESH._objref_SMESH_Pattern): theMesh.SetParameters(Parameters) return SMESH._objref_SMESH_Pattern.ApplyToHexahedrons( self, theMesh, theVolumesIDs, theNode000Index, theNode001Index ) -#Registering the new proxy for Pattern +# Registering the new proxy for Pattern omniORB.registerObjref(SMESH._objref_SMESH_Pattern._NP_RepositoryId, Pattern) - - - - ## Private class used to bind methods creating algorithms to the class Mesh # class algoCreator: @@ -4414,6 +4138,7 @@ class algoCreator: return None # Private class used to substitute and store variable parameters of hypotheses. +# class hypMethodWrapper: def __init__(self, hyp, method): self.hyp = hyp diff --git a/src/SMESH_SWIG/smesh_algorithm.py b/src/SMESH_SWIG/smesh_algorithm.py new file mode 100644 index 000000000..dfeaba4fb --- /dev/null +++ b/src/SMESH_SWIG/smesh_algorithm.py @@ -0,0 +1,322 @@ +# Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE +# +# 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. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +## @package smesh_algorithm +# Python API for base Mesh_Algorithm class. +# This package is a part of SALOME %Mesh module Python API + +import salome +import geompyDC +import SMESH + +## The base class to define meshing algorithms +# +# @note This class should not be used directly, it is supposed to be sub-classed +# for implementing Python API for specific meshing algorithms +# +# For each meshing algorithm, a python class inheriting from class %Mesh_Algorithm +# should be defined. This descendant class should have two attributes defining the way +# it is created by class Mesh (see e.g. class @ref StdMeshersDC.StdMeshersDC_Segment "StdMeshersDC_Segment" +# in StdMeshersDC package): +# - @c meshMethod attribute defines name of method of class smesh.Mesh by calling which the +# python class of algorithm is created; this method is dynamically added to the smesh.Mesh class +# in runtime. For example, if in @c class MyPlugin_Algorithm this attribute is defined as +# @code +# meshMethod = "MyAlgorithm" +# @endcode +# then an instance of @c MyPlugin_Algorithm can be created by the direct invokation of the function +# of smesh.Mesh class: +# @code +# my_algo = mesh.MyAlgorithm() +# @endcode +# - @c algoType defines type of algorithm and is used mostly to discriminate +# algorithms that are created by the same method of class smesh.Mesh. For example, if this attribute +# is specified in @c MyPlugin_Algorithm class as +# @code +# algoType = "MyPLUGIN" +# @endcode +# then it's creation code can be: +# @code +# my_algo = mesh.MyAlgorithm(algo="MyPLUGIN") +# @endcode +# @ingroup l2_algorithms +class Mesh_Algorithm: + + ## Private constuctor + def __init__(self): + self.mesh = None + self.geom = None + self.subm = None + self.algo = None + pass + + ## Finds a hypothesis in the study by its type name and parameters. + # Finds only the hypotheses created in smeshpyD engine. + # @return SMESH.SMESH_Hypothesis + def FindHypothesis (self, hypname, args, CompareMethod, smeshpyD): + study = smeshpyD.GetCurrentStudy() + #to do: find component by smeshpyD object, not by its data type + scomp = study.FindComponent(smeshpyD.ComponentDataType()) + if scomp is not None: + res,hypRoot = scomp.FindSubObject(SMESH.Tag_HypothesisRoot) + # Check if the root label of the hypotheses exists + if res and hypRoot is not None: + iter = study.NewChildIterator(hypRoot) + # Check all published hypotheses + while iter.More(): + hypo_so_i = iter.Value() + attr = hypo_so_i.FindAttribute("AttributeIOR")[1] + if attr is not None: + anIOR = attr.Value() + hypo_o_i = salome.orb.string_to_object(anIOR) + if hypo_o_i is not None: + # Check if this is a hypothesis + hypo_i = hypo_o_i._narrow(SMESH.SMESH_Hypothesis) + if hypo_i is not None: + # Check if the hypothesis belongs to current engine + if smeshpyD.GetObjectId(hypo_i) > 0: + # Check if this is the required hypothesis + if hypo_i.GetName() == hypname: + # Check arguments + if CompareMethod(hypo_i, args): + # found!!! + return hypo_i + pass + pass + pass + pass + pass + iter.Next() + pass + pass + pass + return None + + ## Finds the algorithm in the study by its type name. + # Finds only the algorithms, which have been created in smeshpyD engine. + # @return SMESH.SMESH_Algo + def FindAlgorithm (self, algoname, smeshpyD): + study = smeshpyD.GetCurrentStudy() + if not study: return None + #to do: find component by smeshpyD object, not by its data type + scomp = study.FindComponent(smeshpyD.ComponentDataType()) + if scomp is not None: + res,hypRoot = scomp.FindSubObject(SMESH.Tag_AlgorithmsRoot) + # Check if the root label of the algorithms exists + if res and hypRoot is not None: + iter = study.NewChildIterator(hypRoot) + # Check all published algorithms + while iter.More(): + algo_so_i = iter.Value() + attr = algo_so_i.FindAttribute("AttributeIOR")[1] + if attr is not None: + anIOR = attr.Value() + algo_o_i = salome.orb.string_to_object(anIOR) + if algo_o_i is not None: + # Check if this is an algorithm + algo_i = algo_o_i._narrow(SMESH.SMESH_Algo) + if algo_i is not None: + # Checks if the algorithm belongs to the current engine + if smeshpyD.GetObjectId(algo_i) > 0: + # Check if this is the required algorithm + if algo_i.GetName() == algoname: + # found!!! + return algo_i + pass + pass + pass + pass + iter.Next() + pass + pass + pass + return None + + ## If the algorithm is global, returns 0; \n + # else returns the submesh associated to this algorithm. + def GetSubMesh(self): + return self.subm + + ## Returns the wrapped mesher. + def GetAlgorithm(self): + return self.algo + + ## Gets the list of hypothesis that can be used with this algorithm + def GetCompatibleHypothesis(self): + mylist = [] + if self.algo: + mylist = self.algo.GetCompatibleHypothesis() + return mylist + + ## Gets the name of the algorithm + def GetName(self): + from smesh import GetName + return GetName(self.algo) + + ## Sets the name to the algorithm + def SetName(self, name): + self.mesh.smeshpyD.SetName(self.algo, name) + + ## Gets the id of the algorithm + def GetId(self): + return self.algo.GetId() + + ## Private method. + def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"): + if geom is None: + raise RuntimeError, "Attemp to create " + hypo + " algoritm on None shape" + algo = self.FindAlgorithm(hypo, mesh.smeshpyD) + if algo is None: + algo = mesh.smeshpyD.CreateHypothesis(hypo, so) + pass + self.Assign(algo, mesh, geom) + return self.algo + + ## Private method + def Assign(self, algo, mesh, geom): + from smesh import AssureGeomPublished, TreatHypoStatus, GetName + if geom is None: + raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape" + self.mesh = mesh + name = "" + if not geom: + self.geom = mesh.geom + else: + self.geom = geom + AssureGeomPublished( mesh, geom ) + try: + name = GetName(geom) + pass + except: + pass + self.subm = mesh.mesh.GetSubMesh(geom, algo.GetName()) + self.algo = algo + status = mesh.mesh.AddHypothesis(self.geom, self.algo) + TreatHypoStatus( status, algo.GetName(), name, True ) + return + + def CompareHyp (self, hyp, args): + print "CompareHyp is not implemented for ", self.__class__.__name__, ":", hyp.GetName() + return False + + def CompareEqualHyp (self, hyp, args): + return True + + ## Private method + def Hypothesis (self, hyp, args=[], so="libStdMeshersEngine.so", + UseExisting=0, CompareMethod=""): + from smesh import TreatHypoStatus, GetName + hypo = None + if UseExisting: + if CompareMethod == "": CompareMethod = self.CompareHyp + hypo = self.FindHypothesis(hyp, args, CompareMethod, self.mesh.smeshpyD) + pass + if hypo is None: + hypo = self.mesh.smeshpyD.CreateHypothesis(hyp, so) + a = "" + s = "=" + for arg in args: + argStr = str(arg) + if isinstance( arg, geompyDC.GEOM._objref_GEOM_Object ): + argStr = arg.GetStudyEntry() + if not argStr: argStr = "GEOM_Obj_%s", arg.GetEntry() + if len( argStr ) > 10: + argStr = argStr[:7]+"..." + if argStr[0] == '[': argStr += ']' + a = a + s + argStr + s = "," + pass + if len(a) > 50: + a = a[:47]+"..." + self.mesh.smeshpyD.SetName(hypo, hyp + a) + pass + geomName="" + if self.geom: + geomName = GetName(self.geom) + status = self.mesh.mesh.AddHypothesis(self.geom, hypo) + TreatHypoStatus( status, GetName(hypo), geomName, 0 ) + return hypo + + ## Returns entry of the shape to mesh in the study + def MainShapeEntry(self): + if not self.mesh or not self.mesh.GetMesh(): return "" + if not self.mesh.GetMesh().HasShapeToMesh(): return "" + shape = self.mesh.GetShape() + return shape.GetStudyEntry() + + ## Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build + # near mesh boundary. This hypothesis can be used by several 3D algorithms: + # NETGEN 3D, GHS3D, Hexahedron(i,j,k) + # @param thickness total thickness of layers of prisms + # @param numberOfLayers number of layers of prisms + # @param stretchFactor factor (>1.0) of growth of layer thickness towards inside of mesh + # @param ignoreFaces list of geometrical faces (or their ids) not to generate layers on + # @ingroup l3_hypos_additi + def ViscousLayers(self, thickness, numberOfLayers, stretchFactor, ignoreFaces=[]): + if not isinstance(self.algo, SMESH._objref_SMESH_3D_Algo): + raise TypeError, "ViscousLayers are supported by 3D algorithms only" + if not "ViscousLayers" in self.GetCompatibleHypothesis(): + raise TypeError, "ViscousLayers are not supported by %s"%self.algo.GetName() + if ignoreFaces and isinstance( ignoreFaces[0], geompyDC.GEOM._objref_GEOM_Object ): + ignoreFaces = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, f) for f in ignoreFaces ] + hyp = self.Hypothesis("ViscousLayers", + [thickness, numberOfLayers, stretchFactor, ignoreFaces]) + hyp.SetTotalThickness(thickness) + hyp.SetNumberLayers(numberOfLayers) + hyp.SetStretchFactor(stretchFactor) + hyp.SetIgnoreFaces(ignoreFaces) + return hyp + + ## Transform a list of ether edges or tuples (edge, 1st_vertex_of_edge) + # into a list acceptable to SetReversedEdges() of some 1D hypotheses + # @ingroup l3_hypos_1dhyps + def ReversedEdgeIndices(self, reverseList): + from smesh import FirstVertexOnCurve + resList = [] + geompy = self.mesh.geompyD + for i in reverseList: + if isinstance( i, int ): + s = geompy.SubShapes(self.mesh.geom, [i])[0] + if s.GetShapeType() != geompyDC.GEOM.EDGE: + raise TypeError, "Not EDGE index given" + resList.append( i ) + elif isinstance( i, geompyDC.GEOM._objref_GEOM_Object ): + if i.GetShapeType() != geompyDC.GEOM.EDGE: + raise TypeError, "Not an EDGE given" + resList.append( geompy.GetSubShapeID(self.mesh.geom, i )) + elif len( i ) > 1: + e = i[0] + v = i[1] + if not isinstance( e, geompyDC.GEOM._objref_GEOM_Object ) or \ + not isinstance( v, geompyDC.GEOM._objref_GEOM_Object ): + raise TypeError, "A list item must be a tuple (edge, 1st_vertex_of_edge)" + if v.GetShapeType() == geompyDC.GEOM.EDGE and \ + e.GetShapeType() == geompyDC.GEOM.VERTEX: + v,e = e,v + if e.GetShapeType() != geompyDC.GEOM.EDGE or \ + v.GetShapeType() != geompyDC.GEOM.VERTEX: + raise TypeError, "A list item must be a tuple (edge, 1st_vertex_of_edge)" + vFirst = FirstVertexOnCurve( e ) + tol = geompy.Tolerance( vFirst )[-1] + if geompy.MinDistance( v, vFirst ) > 1.5*tol: + resList.append( geompy.GetSubShapeID(self.mesh.geom, e )) + else: + raise TypeError, "Item must be either an edge or tuple (edge, 1st_vertex_of_edge)" + return resList + -- 2.30.2