--- /dev/null
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,\r
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS \r
+// \r
+// This library is free software; you can redistribute it and/or \r
+// modify it under the terms of the GNU Lesser General Public \r
+// License as published by the Free Software Foundation; either \r
+// version 2.1 of the License. \r
+// \r
+// This library is distributed in the hope that it will be useful, \r
+// but WITHOUT ANY WARRANTY; without even the implied warranty of \r
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU \r
+// Lesser General Public License for more details. \r
+// \r
+// You should have received a copy of the GNU Lesser General Public \r
+// License along with this library; if not, write to the Free Software \r
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA \r
+// \r
+// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org \r
+//\r
+//\r
+//\r
+// File : SMESH_Filter.idl\r
+// Author : Alexey Petrov, OCC\r
+\r
+#ifndef _SMESH_FILTER_IDL_\r
+#define _SMESH_FILTER_IDL_\r
+\r
+#include "SALOME_Exception.idl"\r
+#include "SALOME_GenericObj.idl"\r
+#include "SMESH_Mesh.idl"\r
+\r
+module SMESH{\r
+\r
+ interface Functor: SALOME::GenericObj{\r
+ void SetMesh(in SMESH_Mesh theMesh);\r
+ };\r
+\r
+ interface NumericalFunctor: Functor{\r
+ double GetValue(in long theElementId);\r
+ };\r
+\r
+ interface MinimumAngle: NumericalFunctor{};\r
+ interface AspectRatio: NumericalFunctor{};\r
+ interface Warping: NumericalFunctor{};\r
+ interface Taper: NumericalFunctor{};\r
+ interface Skew: NumericalFunctor{};\r
+ interface Area: NumericalFunctor{};\r
+ interface Length: NumericalFunctor{};\r
+ interface MultiConnection: NumericalFunctor{};\r
+\r
+ interface Predicate: Functor{\r
+ boolean IsSatisfy(in long thEntityId);\r
+ };\r
+\r
+ interface FreeBorders: Predicate{};\r
+\r
+ interface Comparator: Predicate{\r
+ void SetMargin(in double theValue);\r
+ void SetNumFunctor(in NumericalFunctor theFunct);\r
+ };\r
+\r
+ interface LessThan: Comparator{};\r
+ interface MoreThan: Comparator{};\r
+ interface EqualTo: Comparator{\r
+ void SetTolerance(in double theTolerance );\r
+ };\r
+\r
+ interface Logical: Predicate{};\r
+\r
+ interface LogicalNOT: Logical{\r
+ void SetPredicate(in Predicate thePredicate);\r
+ };\r
+\r
+ interface LogicalBinary: Logical{\r
+ void SetPredicate1(in Predicate thePredicate);\r
+ void SetPredicate2(in Predicate thePredicate);\r
+ };\r
+ \r
+ interface LogicalAND: LogicalBinary{};\r
+ interface LogicalOR: LogicalBinary{};\r
+ interface Filter: SALOME::GenericObj{\r
+ void SetPredicate( in Predicate thePredicate );\r
+ long_array GetElementsId( in SMESH_Mesh theMesh );\r
+ };\r
+\r
+ interface FilterManager: SALOME::GenericObj{\r
+ MinimumAngle CreateMinimumAngle();\r
+ AspectRatio CreateAspectRatio();\r
+ Warping CreateWarping();\r
+ Taper CreateTaper();\r
+ Skew CreateSkew();\r
+ Area CreateArea();\r
+ Length CreateLength();\r
+ MultiConnection CreateMultiConnection();\r
+\r
+ FreeBorders CreateFreeBorders();\r
+\r
+ LessThan CreateLessThan();\r
+ MoreThan CreateMoreThan();\r
+ EqualTo CreateEqualTo();\r
+ \r
+ LogicalNOT CreateLogicalNOT();\r
+ LogicalAND CreateLogicalAND();\r
+ LogicalOR CreateLogicalOR();\r
+ Filter CreateFilter();\r
+ };\r
+ \r
+};\r
+\r
+#endif\r
--- /dev/null
+// Copyright (C) 2004 CEA
+//
+// 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.org
+//
+//
+//
+// File : SMESH_Group.idl
+// Author : Sergey ANIKIN, OCC
+// $Header$
+
+#ifndef _SMESH_GROUP_IDL_
+#define _SMESH_GROUP_IDL_
+
+#include "SALOME_Exception.idl"
+#include "SALOME_GenericObj.idl"
+
+#include "SMESH_Mesh.idl"
+
+module SMESH
+{
+ /*!
+ * SMESH_Group: interface of group object
+ */
+ interface SMESH_Group : SALOME::GenericObj
+ {
+ /*!
+ * Sets group name
+ */
+ void SetName( in string name );
+
+ /*!
+ * Returns group name
+ */
+ string GetName();
+
+ /*!
+ * Returns group type (type of elements in the group)
+ */
+ ElementType GetType();
+
+ /*!
+ * Returns the number of elements in the group
+ */
+ long Size();
+
+ /*!
+ * Returns true if the group does not contain any elements
+ */
+ boolean IsEmpty();
+
+ /*!
+ * Clears the group's contents
+ */
+ void Clear();
+
+ /*!
+ * returns true if the group contains an element with ID == <elem_id>
+ */
+ boolean Contains( in long elem_id );
+
+ /*!
+ * Adds elements to the group
+ */
+ long Add( in long_array elem_ids );
+
+ /*!
+ * Returns ID of an element at position <elem_index>
+ */
+ long GetID( in long elem_index );
+
+ /*!
+ * Returns a sequence of all element IDs in the group
+ */
+ long_array GetListOfID();
+
+ /*!
+ * Removes elements from the group
+ */
+ long Remove( in long_array elem_ids );
+
+ /*!
+ * Returns the mesh object this group belongs to
+ */
+ SMESH_Mesh GetMesh();
+ };
+};
+
+
+#endif
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_NetgenAlgorithm.idl
+// Author : Julia DOROVSKIKH
+// $Header$
+
+#ifndef _SMESH_NETGENALGORITHM_IDL_
+#define _SMESH_NETGENALGORITHM_IDL_
+
+#include "SMESH_Hypothesis.idl"
+
+/*!
+ * NETGENPlugin: interfaces to NETGEN related hypotheses and algorithms
+ */
+module NETGENPlugin
+{
+ /*!
+ * NETGENPlugin_NETGEN_3D: interface of "Tetrahedron (Netgen)" algorithm
+ */
+ interface NETGENPlugin_NETGEN_3D : SMESH::SMESH_3D_Algo
+ {
+ };
+
+};
+
+#endif
--- /dev/null
+language=en
+resources=StdMeshers:NETGENPlugin
\ No newline at end of file
--- /dev/null
+<?xml version='1.0' encoding='us-ascii'?>
+<!DOCTYPE meshers PUBLIC "" "desktop.dtd">
+
+<!-- GUI customization for MESH component -->
+
+<meshers>
+
+<meshers-group name="Standard Meshers"
+ resources="StdMeshers"
+ server-lib="libStdMeshersEngine.so"
+ gui-lib="libStdMeshersGUI.so">
+ <hypotheses>
+
+ <hypothesis type="LocalLength"
+ label-id="Average length"
+ icon-id="mesh_hypo_length.png"/>
+
+ <hypothesis type="LengthFromEdges"
+ label-id="Length From Edges (2D Hyp. for Triangulator)"
+ icon-id="mesh_hypo_length.png"/>
+
+ <hypothesis type="NumberOfSegments"
+ label-id="Nb. Segments"
+ icon-id="mesh_hypo_segment.png"/>
+
+ <hypothesis type="MaxElementArea"
+ label-id="Max. Triangle Area"
+ icon-id="mesh_hypo_area.png"/>
+
+ <hypothesis type="MaxElementVolume"
+ label-id="Max. Hexahedron or Tetrahedron Volume"
+ icon-id="mesh_hypo_volume.png"/>
+
+ <hypothesis type="NotConformAllowed"
+ label-id="Not Conform Mesh Allowed"
+ icon-id="mesh_hypo_length.png"/>
+ </hypotheses>
+
+ <algorithms>
+
+ <algorithm type="Regular_1D"
+ label-id="Wire discretisation"
+ icon-id="mesh_algo_regular.png"/>
+
+ <algorithm type="MEFISTO_2D"
+ label-id="Triangle (Mefisto)"
+ icon-id="mesh_algo_mefisto.png"/>
+
+ <algorithm type="Quadrangle_2D"
+ label-id="Quadrangle (Mapping)"
+ icon-id="mesh_algo_quad.png"/>
+
+ <algorithm type="Hexa_3D"
+ label-id="Hexahedron (i,j,k)"
+ icon-id="mesh_algo_hexa.png"/>
+ </algorithms>
+</meshers-group>
+
+<meshers-group name="Your Meshers Group"
+ resources=""
+ server-lib=""
+ gui-lib="">
+ <hypotheses>
+
+ <hypothesis type=""
+ label-id=""
+ icon-id=""/>
+ </hypotheses>
+
+ <algorithms>
+
+ <algorithm type=""
+ label-id=""
+ icon-id=""/>
+ </algorithms>
+</meshers-group>
+
+</meshers>
--- /dev/null
+<?xml version='1.0' encoding='us-ascii'?>
+<!DOCTYPE meshers PUBLIC "" "desktop.dtd">
+
+<!-- GUI customization for MESH component -->
+
+<meshers>
+
+<meshers-group name="Standard Meshers"
+ resources="StdMeshers"
+ server-lib="libStdMeshersEngine.so"
+ gui-lib="libStdMeshersGUI.so">
+ <hypotheses>
+
+ <hypothesis type="LocalLength"
+ label-id="Average length"
+ icon-id="mesh_hypo_length.png"/>
+
+ <hypothesis type="LengthFromEdges"
+ label-id="Length From Edges (2D Hyp. for Triangulator)"
+ icon-id="mesh_hypo_length.png"/>
+
+ <hypothesis type="NumberOfSegments"
+ label-id="Nb. Segments"
+ icon-id="mesh_hypo_segment.png"/>
+
+ <hypothesis type="MaxElementArea"
+ label-id="Max. Triangle Area"
+ icon-id="mesh_hypo_area.png"/>
+
+ <hypothesis type="MaxElementVolume"
+ label-id="Max. Hexahedron or Tetrahedron Volume"
+ icon-id="mesh_hypo_volume.png"/>
+
+ <hypothesis type="NotConformAllowed"
+ label-id="Not Conform Mesh Allowed"
+ icon-id="mesh_hypo_length.png"/>
+ </hypotheses>
+
+ <algorithms>
+
+ <algorithm type="Regular_1D"
+ label-id="Wire discretisation"
+ icon-id="mesh_algo_regular.png"/>
+
+ <algorithm type="MEFISTO_2D"
+ label-id="Triangle (Mefisto)"
+ icon-id="mesh_algo_mefisto.png"/>
+
+ <algorithm type="Quadrangle_2D"
+ label-id="Quadrangle (Mapping)"
+ icon-id="mesh_algo_quad.png"/>
+
+ <algorithm type="Hexa_3D"
+ label-id="Hexahedron (i,j,k)"
+ icon-id="mesh_algo_hexa.png"/>
+ </algorithms>
+</meshers-group>
+
+<meshers-group name="NETGEN"
+ resources="NETGENPlugin"
+ server-lib="libNETGENEngine.so"
+ gui-lib="">
+ <algorithms>
+ <algorithm type="NETGEN_3D"
+ label-id="Tetrahedron (Netgen)"
+ icon-id="mesh_algo_tetra.png"/>
+ </algorithms>
+</meshers-group>
+
+<meshers-group name="Your Meshers Group"
+ resources=""
+ server-lib=""
+ gui-lib="">
+ <hypotheses>
+
+ <hypothesis type=""
+ label-id=""
+ icon-id=""/>
+ </hypotheses>
+
+ <algorithms>
+
+ <algorithm type=""
+ label-id=""
+ icon-id=""/>
+ </algorithms>
+</meshers-group>
+
+</meshers>
--- /dev/null
+<?xml version='1.0' encoding='us-ascii'?>
+<!DOCTYPE meshers PUBLIC "" "desktop.dtd">
+
+<!-- GUI customization for MESH component -->
+
+<meshers>
+
+<meshers-group name="Standard Meshers"
+ resources="StdMeshers"
+ server-lib="libStdMeshersEngine.so"
+ gui-lib="libStdMeshersGUI.so">
+ <hypotheses>
+
+ <hypothesis type="LocalLength"
+ label-id="Average length"
+ icon-id="mesh_hypo_length.png"/>
+
+ <hypothesis type="LengthFromEdges"
+ label-id="Length From Edges (2D Hyp. for Triangulator)"
+ icon-id="mesh_hypo_length.png"/>
+
+ <hypothesis type="NumberOfSegments"
+ label-id="Nb. Segments"
+ icon-id="mesh_hypo_segment.png"/>
+
+ <hypothesis type="MaxElementArea"
+ label-id="Max. Triangle Area"
+ icon-id="mesh_hypo_area.png"/>
+
+ <hypothesis type="MaxElementVolume"
+ label-id="Max. Hexahedron or Tetrahedron Volume"
+ icon-id="mesh_hypo_volume.png"/>
+
+ <hypothesis type="NotConformAllowed"
+ label-id="Not Conform Mesh Allowed"
+ icon-id="mesh_hypo_length.png"/>
+ </hypotheses>
+
+ <algorithms>
+
+ <algorithm type="Regular_1D"
+ label-id="Wire discretisation"
+ icon-id="mesh_algo_regular.png"/>
+
+ <algorithm type="MEFISTO_2D"
+ label-id="Triangle (Mefisto)"
+ icon-id="mesh_algo_mefisto.png"/>
+
+ <algorithm type="Quadrangle_2D"
+ label-id="Quadrangle (Mapping)"
+ icon-id="mesh_algo_quad.png"/>
+
+ <algorithm type="Hexa_3D"
+ label-id="Hexahedron (i,j,k)"
+ icon-id="mesh_algo_hexa.png"/>
+ </algorithms>
+</meshers-group>
+
+<meshers-group name="Your Meshers Group"
+ resources=""
+ server-lib=""
+ gui-lib="">
+ <hypotheses>
+
+ <hypothesis type=""
+ label-id=""
+ icon-id=""/>
+ </hypotheses>
+
+ <algorithms>
+
+ <algorithm type=""
+ label-id=""
+ icon-id=""/>
+ </algorithms>
+</meshers-group>
+
+</meshers>
--- /dev/null
+# SMESH OBJECT : interactive object for SMESH visualization
+#
+# Copyright (C) 2003 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.
+#
+# 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+#
+#
+#
+# File : Makefile.in
+# Module : SMESH
+
+top_srcdir=@top_srcdir@
+top_builddir=../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl:$(top_builddir)/idl
+
+@COMMENCE@
+
+EXPORT_HEADERS = SMESH_Controls.hxx
+
+
+# Libraries targets
+
+LIB = libSMESHControls.la
+LIB_SRC = SMESH_Controls.cxx
+
+# Executables targets
+BIN = SMESHControls
+BIN_SRC =
+
+CPPFLAGS+=$(OCC_INCLUDES) $(BOOST_CPPFLAGS)
+
+LDFLAGS+=$(OCC_KERNEL_LIBS) -L${KERNEL_ROOT_DIR}/lib/salome -lOpUtil -lSMDS
+
+@CONCLUDE@
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#include "SMESH_Controls.hxx"
+
+int main(int argc, char** argv)
+{
+ using namespace SMESH::Controls;
+ new MinimumAngle();
+ new AspectRatio();
+ new Warping();
+ new Taper();
+ new Skew();
+ new Area();
+ new Length();
+ new MultiConnection();
+ new FreeBorders();
+ new LessThan();
+ new MoreThan();
+ new EqualTo();
+ new LogicalNOT();
+ new LogicalAND();
+ new LogicalOR();
+
+ return 1;
+}
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#include <set>
+
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_XYZ.hxx>
+#include <Precision.hxx>
+#include <TColgp_SequenceOfXYZ.hxx>
+#include <TColStd_MapOfInteger.hxx>
+
+#include "SMDS_Mesh.hxx"
+#include "SMDS_Iterator.hxx"
+#include "SMDS_MeshElement.hxx"
+#include "SMDS_MeshNode.hxx"
+
+#include "SMESH_Controls.hxx"
+
+/*
+ AUXILIARY METHODS
+*/
+
+static inline double getAngle( const gp_XYZ& P1, const gp_XYZ& P2, const gp_XYZ& P3 )
+{
+ return gp_Vec( P1 - P2 ).Angle( gp_Vec( P3 - P2 ) );
+}
+
+static inline double getArea( const gp_XYZ& P1, const gp_XYZ& P2, const gp_XYZ& P3 )
+{
+ gp_Vec aVec1( P2 - P1 );
+ gp_Vec aVec2( P3 - P1 );
+ return ( aVec1 ^ aVec2 ).Magnitude() * 0.5;
+}
+
+static inline double getArea( const gp_Pnt& P1, const gp_Pnt& P2, const gp_Pnt& P3 )
+{
+ return getArea( P1.XYZ(), P2.XYZ(), P3.XYZ() );
+}
+
+static inline double getDistance( const gp_XYZ& P1, const gp_XYZ& P2 )
+{
+ double aDist = gp_Pnt( P1 ).Distance( gp_Pnt( P2 ) );
+ return aDist;
+}
+
+static int getNbMultiConnection( SMDS_Mesh* theMesh, const int theId )
+{
+ if ( theMesh == 0 )
+ return 0;
+
+ const SMDS_MeshElement* anEdge = theMesh->FindElement( theId );
+ if ( anEdge == 0 || anEdge->GetType() != SMDSAbs_Edge || anEdge->NbNodes() != 2 )
+ return 0;
+
+ TColStd_MapOfInteger aMap;
+
+ int aResult = 0;
+ SMDS_ElemIteratorPtr anIter = anEdge->nodesIterator();
+ if ( anIter != 0 )
+ {
+ while( anIter->more() )
+ {
+ const SMDS_MeshNode* aNode = (SMDS_MeshNode*)anIter->next();
+ if ( aNode == 0 )
+ return 0;
+ SMDS_ElemIteratorPtr anElemIter = aNode->GetInverseElementIterator();
+ while( anElemIter->more() )
+ {
+ const SMDS_MeshElement* anElem = anElemIter->next();
+ if ( anElem != 0 && anElem->GetType() != SMDSAbs_Edge )
+ {
+ int anId = anElem->GetID();
+
+ if ( anIter->more() ) // i.e. first node
+ aMap.Add( anId );
+ else if ( aMap.Contains( anId ) )
+ aResult++;
+ }
+ }
+ }
+ }
+
+ return aResult;
+}
+
+
+using namespace SMESH::Controls;
+
+/*
+ FUNCTORS
+*/
+
+/*
+ Class : NumericalFunctor
+ Description : Base class for numerical functors
+*/
+NumericalFunctor::NumericalFunctor():
+ myMesh(NULL)
+{}
+
+void NumericalFunctor::SetMesh( SMDS_Mesh* theMesh )
+{
+ myMesh = theMesh;
+}
+
+bool NumericalFunctor::getPoints( const int theId,
+ TColgp_SequenceOfXYZ& theRes ) const
+{
+ theRes.Clear();
+
+ if ( myMesh == 0 )
+ return false;
+
+ // Get nodes of the face
+ const SMDS_MeshElement* anElem = myMesh->FindElement( theId );
+ if ( anElem == 0 || anElem->GetType() != GetType() )
+ return false;
+
+ int nbNodes = anElem->NbNodes();
+
+ SMDS_ElemIteratorPtr anIter = anElem->nodesIterator();
+ if ( anIter != 0 )
+ {
+ while( anIter->more() )
+ {
+ const SMDS_MeshNode* aNode = (SMDS_MeshNode*)anIter->next();
+ if ( aNode != 0 )
+ theRes.Append( gp_XYZ( aNode->X(), aNode->Y(), aNode->Z() ) );
+ }
+ }
+
+ return true;
+}
+
+
+/*
+ Class : MinimumAngle
+ Description : Functor for calculation of minimum angle
+*/
+double MinimumAngle::GetValue( long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ if ( !getPoints( theId, P ) || P.Length() != 3 && P.Length() != 4 )
+ return 0;
+
+ double aMin;
+
+ if ( P.Length() == 3 )
+ {
+ double A0 = getAngle( P( 3 ), P( 1 ), P( 2 ) );
+ double A1 = getAngle( P( 1 ), P( 2 ), P( 3 ) );
+ double A2 = getAngle( P( 2 ), P( 3 ), P( 1 ) );
+
+ aMin = Min( A0, Min( A1, A2 ) );
+ }
+ else
+ {
+ double A0 = getAngle( P( 4 ), P( 1 ), P( 2 ) );
+ double A1 = getAngle( P( 1 ), P( 2 ), P( 3 ) );
+ double A2 = getAngle( P( 2 ), P( 3 ), P( 4 ) );
+ double A3 = getAngle( P( 3 ), P( 4 ), P( 1 ) );
+
+ aMin = Min( Min( A0, A1 ), Min( A2, A3 ) );
+ }
+
+ return aMin * 180 / PI;
+}
+
+SMDSAbs_ElementType MinimumAngle::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+
+/*
+ Class : AspectRatio
+ Description : Functor for calculating aspect ratio
+*/
+double AspectRatio::GetValue( long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ if ( !getPoints( theId, P ) || P.Length() != 3 && P.Length() != 4 )
+ return 0;
+
+ int nbNodes = P.Length();
+
+ // Compute lengths of the sides
+
+ double aLen[ nbNodes ];
+ for ( int i = 0; i < nbNodes - 1; i++ )
+ aLen[ i ] = getDistance( P( i + 1 ), P( i + 2 ) );
+ aLen[ nbNodes - 1 ] = getDistance( P( 1 ), P( nbNodes ) );
+
+ // Compute aspect ratio
+
+ if ( nbNodes == 3 )
+ {
+ double aMaxLen = Max( aLen[ 0 ], Max( aLen[ 1 ], aLen[ 2 ] ) );
+ double anArea = getArea( P( 1 ), P( 2 ), P( 3 ) );
+ static double aCoef = sqrt( 3. ) / 4;
+
+ return anArea != 0 ? aCoef * aMaxLen * aMaxLen / anArea : 0;
+ }
+ else
+ {
+ double aMaxLen = Max( Max( aLen[ 0 ], aLen[ 1 ] ), Max( aLen[ 2 ], aLen[ 3 ] ) );
+ double aMinLen = Min( Min( aLen[ 0 ], aLen[ 1 ] ), Min( aLen[ 2 ], aLen[ 3 ] ) );
+
+ return aMinLen != 0 ? aMaxLen / aMinLen : 0;
+ }
+}
+
+SMDSAbs_ElementType AspectRatio::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+
+/*
+ Class : Warping
+ Description : Functor for calculating warping
+*/
+double Warping::GetValue( long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ if ( !getPoints( theId, P ) || P.Length() != 4 )
+ return 0;
+
+ gp_XYZ G = ( P( 1 ) + P( 2 ) + P( 3 ) + P( 4 ) ) / 4;
+
+ double A1 = ComputeA( P( 1 ), P( 2 ), P( 3 ), G );
+ double A2 = ComputeA( P( 2 ), P( 3 ), P( 4 ), G );
+ double A3 = ComputeA( P( 3 ), P( 4 ), P( 1 ), G );
+ double A4 = ComputeA( P( 4 ), P( 1 ), P( 2 ), G );
+
+ return Max( Max( A1, A2 ), Max( A3, A4 ) );
+}
+
+double Warping::ComputeA( const gp_XYZ& thePnt1,
+ const gp_XYZ& thePnt2,
+ const gp_XYZ& thePnt3,
+ const gp_XYZ& theG ) const
+{
+ double aLen1 = gp_Pnt( thePnt1 ).Distance( gp_Pnt( thePnt2 ) );
+ double aLen2 = gp_Pnt( thePnt2 ).Distance( gp_Pnt( thePnt3 ) );
+ double L = Min( aLen1, aLen2 ) * 0.5;
+
+ gp_XYZ GI = ( thePnt2 - thePnt1 ) / 2. - theG;
+ gp_XYZ GJ = ( thePnt3 - thePnt2 ) / 2. - theG;
+ gp_XYZ N = GI.Crossed( GJ );
+ N.Normalize();
+
+ double H = gp_Vec( thePnt2 - theG ).Dot( gp_Vec( N ) );
+ return asin( fabs( H / L ) ) * 180 / PI;
+}
+
+SMDSAbs_ElementType Warping::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+
+/*
+ Class : Taper
+ Description : Functor for calculating taper
+*/
+double Taper::GetValue( long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ if ( !getPoints( theId, P ) || P.Length() != 4 )
+ return 0;
+
+ // Compute taper
+ double J1 = getArea( P( 4 ), P( 1 ), P( 2 ) ) / 2;
+ double J2 = getArea( P( 3 ), P( 1 ), P( 2 ) ) / 2;
+ double J3 = getArea( P( 2 ), P( 3 ), P( 4 ) ) / 2;
+ double J4 = getArea( P( 3 ), P( 4 ), P( 1 ) ) / 2;
+
+ double JA = 0.25 * ( J1 + J2 + J3 + J4 );
+
+ double T1 = fabs( ( J1 - JA ) / JA );
+ double T2 = fabs( ( J2 - JA ) / JA );
+ double T3 = fabs( ( J3 - JA ) / JA );
+ double T4 = fabs( ( J4 - JA ) / JA );
+
+ return Max( Max( T1, T2 ), Max( T3, T4 ) );
+}
+
+SMDSAbs_ElementType Taper::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+
+/*
+ Class : Skew
+ Description : Functor for calculating skew in degrees
+*/
+static inline double skewAngle( const gp_XYZ& p1, const gp_XYZ& p2, const gp_XYZ& p3 )
+{
+ gp_XYZ p12 = ( p2 + p1 ) / 2;
+ gp_XYZ p23 = ( p3 + p2 ) / 2;
+ gp_XYZ p31 = ( p3 + p1 ) / 2;
+
+ return gp_Vec( p31 - p2 ).Angle( p12 - p23 );
+}
+
+double Skew::GetValue( long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ if ( !getPoints( theId, P ) || P.Length() != 3 && P.Length() != 4 )
+ return 0;
+
+ // Compute skew
+ static double PI2 = PI / 2;
+ if ( P.Length() == 3 )
+ {
+ double A0 = fabs( PI2 - skewAngle( P( 3 ), P( 1 ), P( 2 ) ) );
+ double A1 = fabs( PI2 - skewAngle( P( 1 ), P( 2 ), P( 3 ) ) );
+ double A2 = fabs( PI2 - skewAngle( P( 2 ), P( 3 ), P( 1 ) ) );
+
+ return Max( A0, Max( A1, A2 ) ) * 180 / PI;
+ }
+ else
+ {
+ gp_XYZ p12 = ( P( 1 ) + P( 2 ) ) / 2;
+ gp_XYZ p23 = ( P( 2 ) + P( 3 ) ) / 2;
+ gp_XYZ p34 = ( P( 3 ) + P( 4 ) ) / 2;
+ gp_XYZ p41 = ( P( 4 ) + P( 1 ) ) / 2;
+
+ double A = fabs( PI2 - gp_Vec( p34 - p12 ).Angle( p23 - p41 ) );
+
+ return A * 180 / PI;
+ }
+}
+
+SMDSAbs_ElementType Skew::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+
+/*
+ Class : Area
+ Description : Functor for calculating area
+*/
+double Area::GetValue( long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ if ( !getPoints( theId, P ) || P.Length() != 3 && P.Length() != 4 )
+ return 0;
+
+ if ( P.Length() == 3 )
+ return getArea( P( 1 ), P( 2 ), P( 3 ) );
+ else
+ return getArea( P( 1 ), P( 2 ), P( 3 ) ) + getArea( P( 1 ), P( 3 ), P( 4 ) );
+}
+
+SMDSAbs_ElementType Area::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+
+/*
+ Class : Length
+ Description : Functor for calculating length off edge
+*/
+double Length::GetValue( long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ return getPoints( theId, P ) && P.Length() == 2 ? getDistance( P( 1 ), P( 2 ) ) : 0;
+}
+
+SMDSAbs_ElementType Length::GetType() const
+{
+ return SMDSAbs_Edge;
+}
+
+
+/*
+ Class : MultiConnection
+ Description : Functor for calculating number of faces conneted to the edge
+*/
+double MultiConnection::GetValue( long theId )
+{
+ return getNbMultiConnection( myMesh, theId );
+}
+
+SMDSAbs_ElementType MultiConnection::GetType() const
+{
+ return SMDSAbs_Edge;
+}
+
+
+/*
+ PREDICATES
+*/
+
+/*
+ Class : FreeBorders
+ Description : Predicate for free borders
+*/
+
+FreeBorders::FreeBorders()
+{
+ myMesh = 0;
+}
+
+void FreeBorders::SetMesh( SMDS_Mesh* theMesh )
+{
+ myMesh = theMesh;
+}
+
+bool FreeBorders::IsSatisfy( long theId )
+{
+ return getNbMultiConnection( myMesh, theId ) == 1;
+}
+
+SMDSAbs_ElementType FreeBorders::GetType() const
+{
+ return SMDSAbs_Edge;
+}
+
+
+/*
+ Class : FreeEdges
+ Description : Predicate for free Edges
+*/
+FreeEdges::FreeEdges()
+{
+ myMesh = 0;
+}
+
+void FreeEdges::SetMesh( SMDS_Mesh* theMesh )
+{
+ myMesh = theMesh;
+}
+
+bool FreeEdges::IsSatisfy( long theId )
+{
+ return getNbMultiConnection( myMesh, theId ) == 1;
+}
+
+SMDSAbs_ElementType FreeEdges::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+FreeEdges::Border::Border(long thePntId1, long thePntId2){
+ PntId[0] = thePntId1; PntId[1] = thePntId2;
+ if(thePntId1 > thePntId2){
+ PntId[1] = thePntId1; PntId[0] = thePntId2;
+ }
+}
+
+//bool operator<(const FreeEdges::Border& x, const FreeEdges::Border& y){
+// if(x.PntId[0] < y.PntId[0]) return true;
+// if(x.PntId[0] == y.PntId[0])
+// if(x.PntId[1] < y.PntId[1]) return true;
+// return false;
+//}
+
+namespace SMESH{
+ namespace Controls{
+ struct EdgeBorder: public FreeEdges::Border{
+ long ElemId;
+ EdgeBorder(long theElemId, long thePntId1, long thePntId2):
+ FreeEdges::Border(thePntId1,thePntId2),
+ ElemId(theElemId)
+ {}
+ };
+
+ bool operator<(const FreeEdges::Border& x, const FreeEdges::Border& y){
+ if(x.PntId[0] < y.PntId[0]) return true;
+ if(x.PntId[0] == y.PntId[0])
+ if(x.PntId[1] < y.PntId[1]) return true;
+ return false;
+ }
+
+ typedef std::set<EdgeBorder> EdgeBorderS;
+
+ inline void UpdateBorders(const EdgeBorder& theBorder,
+ EdgeBorderS& theRegistry,
+ EdgeBorderS& theContainer)
+ {
+ if(theRegistry.find(theBorder) == theRegistry.end()){
+ theRegistry.insert(theBorder);
+ theContainer.insert(theBorder);
+ }else{
+ theContainer.erase(theBorder);
+ }
+ }
+
+ }
+}
+
+void FreeEdges::GetBoreders(Borders& theBorders)
+{
+ EdgeBorderS aRegistry;
+ EdgeBorderS aContainer;
+ SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
+ for(; anIter->more(); ){
+ const SMDS_MeshFace* anElem = anIter->next();
+ long anElemId = anElem->GetID();
+ SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
+ long aNodeId[2];
+ const SMDS_MeshElement* aNode;
+ if(aNodesIter->more()){
+ aNode = aNodesIter->next();
+ aNodeId[0] = aNodeId[1] = aNode->GetID();
+ }
+ for(; aNodesIter->more(); ){
+ aNode = aNodesIter->next();
+ EdgeBorder aBorder(anElemId,aNodeId[1],aNode->GetID());
+ aNodeId[1] = aNode->GetID();
+ //std::cout<<aBorder.PntId[0]<<"; "<<aBorder.PntId[1]<<"; "<<aBorder.ElemId<<"\n";
+ UpdateBorders(aBorder,aRegistry,aContainer);
+ }
+ EdgeBorder aBorder(anElemId,aNodeId[0],aNodeId[1]);
+ UpdateBorders(aBorder,aRegistry,aContainer);
+ }
+ //std::cout<<"aContainer.size() = "<<aContainer.size()<<"\n";
+ if(aContainer.size()){
+ EdgeBorderS::const_iterator anIter = aContainer.begin();
+ for(; anIter != aContainer.end(); anIter++){
+ const EdgeBorder& aBorder = *anIter;
+ //std::cout<<aBorder.PntId[0]<<"; "<<aBorder.PntId[1]<<"; "<<aBorder.ElemId<<"\n";
+ theBorders.insert(Borders::value_type(aBorder.ElemId,aBorder));
+ }
+ }
+}
+
+
+/*
+ Class : Comparator
+ Description : Base class for comparators
+*/
+Comparator::Comparator():
+ myMargin(0)
+{}
+
+Comparator::~Comparator()
+{}
+
+void Comparator::SetMesh( SMDS_Mesh* theMesh )
+{
+ if ( myFunctor )
+ myFunctor->SetMesh( theMesh );
+}
+
+void Comparator::SetMargin( double theValue )
+{
+ myMargin = theValue;
+}
+
+void Comparator::SetNumFunctor( NumericalFunctorPtr theFunct )
+{
+ myFunctor = theFunct;
+}
+
+SMDSAbs_ElementType Comparator::GetType() const
+{
+ return myFunctor ? myFunctor->GetType() : SMDSAbs_All;
+}
+
+
+/*
+ Class : LessThan
+ Description : Comparator "<"
+*/
+bool LessThan::IsSatisfy( long theId )
+{
+ return myFunctor && myFunctor->GetValue( theId ) < myMargin;
+}
+
+
+/*
+ Class : MoreThan
+ Description : Comparator ">"
+*/
+bool MoreThan::IsSatisfy( long theId )
+{
+ return myFunctor && myFunctor->GetValue( theId ) > myMargin;
+}
+
+
+/*
+ Class : EqualTo
+ Description : Comparator "="
+*/
+EqualTo::EqualTo():
+ myToler(Precision::Confusion())
+{}
+
+bool EqualTo::IsSatisfy( long theId )
+{
+ return myFunctor && fabs( myFunctor->GetValue( theId ) - myMargin ) < myToler;
+}
+
+void EqualTo::SetTolerance( double theToler )
+{
+ myToler = theToler;
+}
+
+
+/*
+ Class : LogicalNOT
+ Description : Logical NOT predicate
+*/
+LogicalNOT::LogicalNOT()
+{}
+
+LogicalNOT::~LogicalNOT()
+{}
+
+bool LogicalNOT::IsSatisfy( long theId )
+{
+ return myPredicate && !myPredicate->IsSatisfy( theId );
+}
+
+void LogicalNOT::SetMesh( SMDS_Mesh* theMesh )
+{
+ if ( myPredicate )
+ myPredicate->SetMesh( theMesh );
+}
+
+void LogicalNOT::SetPredicate( PredicatePtr thePred )
+{
+ myPredicate = thePred;
+}
+
+SMDSAbs_ElementType LogicalNOT::GetType() const
+{
+ return myPredicate ? myPredicate->GetType() : SMDSAbs_All;
+}
+
+
+/*
+ Class : LogicalBinary
+ Description : Base class for binary logical predicate
+*/
+LogicalBinary::LogicalBinary()
+{}
+
+LogicalBinary::~LogicalBinary()
+{}
+
+void LogicalBinary::SetMesh( SMDS_Mesh* theMesh )
+{
+ if ( myPredicate1 )
+ myPredicate1->SetMesh( theMesh );
+
+ if ( myPredicate2 )
+ myPredicate2->SetMesh( theMesh );
+}
+
+void LogicalBinary::SetPredicate1( PredicatePtr thePredicate )
+{
+ myPredicate1 = thePredicate;
+}
+
+void LogicalBinary::SetPredicate2( PredicatePtr thePredicate )
+{
+ myPredicate2 = thePredicate;
+}
+
+SMDSAbs_ElementType LogicalBinary::GetType() const
+{
+ if ( !myPredicate1 || !myPredicate2 )
+ return SMDSAbs_All;
+
+ SMDSAbs_ElementType aType1 = myPredicate1->GetType();
+ SMDSAbs_ElementType aType2 = myPredicate2->GetType();
+
+ return aType1 == aType2 ? aType1 : SMDSAbs_All;
+}
+
+
+/*
+ Class : LogicalAND
+ Description : Logical AND
+*/
+bool LogicalAND::IsSatisfy( long theId )
+{
+ return
+ myPredicate1 &&
+ myPredicate2 &&
+ myPredicate1->IsSatisfy( theId ) &&
+ myPredicate2->IsSatisfy( theId );
+}
+
+
+/*
+ Class : LogicalOR
+ Description : Logical OR
+*/
+bool LogicalOR::IsSatisfy( long theId )
+{
+ return
+ myPredicate1 &&
+ myPredicate2 &&
+ myPredicate1->IsSatisfy( theId ) ||
+ myPredicate2->IsSatisfy( theId );
+}
+
+
+/*
+ FILTER
+*/
+
+Filter::Filter()
+{}
+
+Filter::~Filter()
+{}
+
+void Filter::SetPredicate( PredicatePtr thePredicate )
+{
+ myPredicate = thePredicate;
+}
+
+Filter::TIdSequence
+Filter::GetElementsId( SMDS_Mesh* theMesh )
+{
+ TIdSequence aSequence;
+ if ( !theMesh || !myPredicate ) return aSequence;
+
+ myPredicate->SetMesh( theMesh );
+
+ SMDSAbs_ElementType aType = myPredicate->GetType();
+ switch(aType){
+ case SMDSAbs_Edge:{
+ SMDS_EdgeIteratorPtr anIter = theMesh->edgesIterator();
+ if ( anIter != 0 ) {
+ while( anIter->more() ) {
+ const SMDS_MeshElement* anElem = anIter->next();
+ long anId = anElem->GetID();
+ if ( myPredicate->IsSatisfy( anId ) )
+ aSequence.push_back( anId );
+ }
+ }
+ }
+ case SMDSAbs_Face:{
+ SMDS_FaceIteratorPtr anIter = theMesh->facesIterator();
+ if ( anIter != 0 ) {
+ while( anIter->more() ) {
+ const SMDS_MeshElement* anElem = anIter->next();
+ long anId = anElem->GetID();
+ if ( myPredicate->IsSatisfy( anId ) )
+ aSequence.push_back( anId );
+ }
+ }
+ }
+ }
+ return aSequence;
+}
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#ifndef _SMESH_CONTROLS_HXX_
+#define _SMESH_CONTROLS_HXX_
+
+#include <map>
+#include <vector>
+#include <boost/shared_ptr.hpp>
+#include "SMDSAbs_ElementType.hxx"
+
+class SMDS_Mesh;
+class gp_Pnt;
+class gp_XYZ;
+class TColgp_SequenceOfXYZ;
+
+namespace SMESH{
+ namespace Controls{
+ class Functor{
+ public:
+ ~Functor(){}
+ virtual void SetMesh( SMDS_Mesh* theMesh ) = 0;
+ };
+ typedef boost::shared_ptr<Functor> FunctorPtr;
+
+ class NumericalFunctor: public virtual Functor{
+ public:
+ NumericalFunctor();
+ virtual void SetMesh( SMDS_Mesh* theMesh );
+ virtual double GetValue( long theElementId ) = 0;
+ virtual SMDSAbs_ElementType GetType() const = 0;
+
+ protected:
+ bool getPoints( const int theId,
+ TColgp_SequenceOfXYZ& theRes ) const;
+ protected:
+ SMDS_Mesh* myMesh;
+ };
+ typedef boost::shared_ptr<NumericalFunctor> NumericalFunctorPtr;
+
+
+ /*
+ Class : SMESH_MinimumAngle
+ Description : Functor for calculation of minimum angle
+ */
+ class MinimumAngle: public virtual NumericalFunctor{
+ public:
+ virtual double GetValue( long theElementId );
+ virtual SMDSAbs_ElementType GetType() const;
+ };
+
+
+ /*
+ Class : AspectRatio
+ Description : Functor for calculating aspect ratio
+ */
+ class AspectRatio: public virtual NumericalFunctor{
+ public:
+ virtual double GetValue( long theElementId );
+ virtual SMDSAbs_ElementType GetType() const;
+ };
+
+
+ /*
+ Class : Warping
+ Description : Functor for calculating warping
+ */
+ class Warping: public virtual NumericalFunctor{
+ public:
+ virtual double GetValue( long theElementId );
+ virtual SMDSAbs_ElementType GetType() const;
+
+ private:
+ double ComputeA( const gp_XYZ&, const gp_XYZ&,
+ const gp_XYZ&, const gp_XYZ& ) const;
+ };
+
+
+ /*
+ Class : Taper
+ Description : Functor for calculating taper
+ */
+ class Taper: public virtual NumericalFunctor{
+ public:
+ virtual double GetValue( long theElementId );
+ virtual SMDSAbs_ElementType GetType() const;
+ };
+
+
+ /*
+ Class : Skew
+ Description : Functor for calculating skew in degrees
+ */
+ class Skew: public virtual NumericalFunctor{
+ public:
+ virtual double GetValue( long theElementId );
+ virtual SMDSAbs_ElementType GetType() const;
+ };
+
+
+ /*
+ Class : Area
+ Description : Functor for calculating area
+ */
+ class Area: public virtual NumericalFunctor{
+ public:
+ virtual double GetValue( long theElementId );
+ virtual SMDSAbs_ElementType GetType() const;
+ };
+
+
+ /*
+ Class : Length
+ Description : Functor for calculating length of edge
+ */
+ class Length: public virtual NumericalFunctor{
+ public:
+ virtual double GetValue( long theElementId );
+ virtual SMDSAbs_ElementType GetType() const;
+ };
+
+
+ /*
+ Class : MultiConnection
+ Description : Functor for calculating number of faces conneted to the edge
+ */
+ class MultiConnection: public virtual NumericalFunctor{
+ public:
+ virtual double GetValue( long theElementId );
+ virtual SMDSAbs_ElementType GetType() const;
+ };
+
+
+ /*
+ PREDICATES
+ */
+ /*
+ Class : Predicate
+ Description : Base class for all predicates
+ */
+ class Predicate: public virtual Functor{
+ public:
+ virtual bool IsSatisfy( long theElementId ) = 0;
+ virtual SMDSAbs_ElementType GetType() const = 0;
+ };
+ typedef boost::shared_ptr<Predicate> PredicatePtr;
+
+
+
+ /*
+ Class : FreeBorders
+ Description : Predicate for free borders
+ */
+ class FreeBorders: public virtual Predicate{
+ public:
+ FreeBorders();
+ virtual void SetMesh( SMDS_Mesh* theMesh );
+ virtual bool IsSatisfy( long theElementId );
+ virtual SMDSAbs_ElementType GetType() const;
+
+ protected:
+ SMDS_Mesh* myMesh;
+ };
+
+
+ /*
+ Class : FreeEdges
+ Description : Predicate for free Edges
+ */
+ class FreeEdges: public virtual Predicate{
+ public:
+ FreeEdges();
+ virtual void SetMesh( SMDS_Mesh* theMesh );
+ virtual bool IsSatisfy( long theElementId );
+ virtual SMDSAbs_ElementType GetType() const;
+ struct Border{
+ long PntId[2];
+ Border(long thePntId1, long thePntId2);
+ };
+ typedef long TElemId;
+ typedef std::map<TElemId,Border> Borders;
+ void GetBoreders(Borders& theBorders);
+
+ protected:
+ SMDS_Mesh* myMesh;
+ };
+ typedef boost::shared_ptr<FreeEdges> FreeEdgesPtr;
+
+
+ /*
+ Class : Comparator
+ Description : Base class for comparators
+ */
+ class Comparator: public virtual Predicate{
+ public:
+ Comparator();
+ virtual ~Comparator();
+ virtual void SetMesh( SMDS_Mesh* theMesh );
+ virtual void SetMargin(double theValue);
+ virtual void SetNumFunctor(NumericalFunctorPtr theFunct);
+ virtual bool IsSatisfy( long theElementId ) = 0;
+ virtual SMDSAbs_ElementType GetType() const;
+
+ protected:
+ double myMargin;
+ NumericalFunctorPtr myFunctor;
+ };
+ typedef boost::shared_ptr<Comparator> ComparatorPtr;
+
+
+ /*
+ Class : LessThan
+ Description : Comparator "<"
+ */
+ class LessThan: public virtual Comparator{
+ public:
+ virtual bool IsSatisfy( long theElementId );
+ };
+
+
+ /*
+ Class : MoreThan
+ Description : Comparator ">"
+ */
+ class MoreThan: public virtual Comparator{
+ public:
+ virtual bool IsSatisfy( long theElementId );
+ };
+
+
+ /*
+ Class : EqualTo
+ Description : Comparator "="
+ */
+ class EqualTo: public virtual Comparator{
+ public:
+ EqualTo();
+ virtual bool IsSatisfy( long theElementId );
+ virtual void SetTolerance( double theTol );
+
+ private:
+ double myToler;
+ };
+ typedef boost::shared_ptr<EqualTo> EqualToPtr;
+
+
+ /*
+ Class : LogicalNOT
+ Description : Logical NOT predicate
+ */
+ class LogicalNOT: public virtual Predicate{
+ public:
+ LogicalNOT();
+ virtual ~LogicalNOT();
+ virtual bool IsSatisfy( long theElementId );
+ virtual void SetMesh( SMDS_Mesh* theMesh );
+ virtual void SetPredicate(PredicatePtr thePred);
+ virtual SMDSAbs_ElementType GetType() const;
+
+ private:
+ PredicatePtr myPredicate;
+ };
+ typedef boost::shared_ptr<LogicalNOT> LogicalNOTPtr;
+
+
+ /*
+ Class : LogicalBinary
+ Description : Base class for binary logical predicate
+ */
+ class LogicalBinary: public virtual Predicate{
+ public:
+ LogicalBinary();
+ virtual ~LogicalBinary();
+ virtual void SetMesh( SMDS_Mesh* theMesh );
+ virtual void SetPredicate1(PredicatePtr thePred);
+ virtual void SetPredicate2(PredicatePtr thePred);
+ virtual SMDSAbs_ElementType GetType() const;
+
+ protected:
+ PredicatePtr myPredicate1;
+ PredicatePtr myPredicate2;
+ };
+ typedef boost::shared_ptr<LogicalBinary> LogicalBinaryPtr;
+
+
+ /*
+ Class : LogicalAND
+ Description : Logical AND
+ */
+ class LogicalAND: public virtual LogicalBinary{
+ public:
+ virtual bool IsSatisfy( long theElementId );
+ };
+
+
+ /*
+ Class : LogicalOR
+ Description : Logical OR
+ */
+ class LogicalOR: public virtual LogicalBinary{
+ public:
+ virtual bool IsSatisfy( long theElementId );
+ };
+
+
+ /*
+ FILTER
+ */
+ class Filter{
+ public:
+ Filter();
+ virtual ~Filter();
+ virtual void SetPredicate(PredicatePtr thePred);
+ typedef std::vector<long> TIdSequence;
+ virtual TIdSequence GetElementsId( SMDS_Mesh* theMesh );
+
+ protected:
+ PredicatePtr myPredicate;
+ };
+ };
+};
+
+
+#endif
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#include "Driver_Document.h"
+
+Driver_Document::Driver_Document():
+ myDocument(NULL)
+{}
+
+
+void Driver_Document::SetFile(const std::string& theFileName)
+{
+ myFile = theFileName;
+}
+
+
+void Driver_Document::SetDocument(SMESHDS_Document * theDocument)
+{
+ myDocument = theDocument;
+}
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#ifndef _INCLUDE_DRIVER_DOCUMENT
+#define _INCLUDE_DRIVER_DOCUMENT
+
+#include <string>
+
+class SMESHDS_Document;
+
+class Driver_Document
+{
+ public:
+ Driver_Document();
+ virtual ~Driver_Document(){}
+
+ virtual void Perform() = 0;
+ void SetFile(const std::string& theFileName);
+ void SetDocument(SMESHDS_Document *theDocument);
+
+ protected:
+ SMESHDS_Document * myDocument;
+ std::string myFile;
+
+};
+
+
+#endif
--- /dev/null
+// SMESH Driver : implementaion of driver for reading and writing
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : Mesh_Reader.cxx
+// Module : SMESH
+
+#include "Driver_Mesh.h"
+
+using namespace std;
+
+Driver_Mesh::Driver_Mesh():
+ myFile(""),
+ myMeshId(-1)
+{}
+
+
+void Driver_Mesh::SetMeshId(int theMeshId)
+{
+ myMeshId = theMeshId;
+}
+
+
+void Driver_Mesh::SetFile(const std::string& theFileName)
+{
+ myFile = theFileName;
+}
--- /dev/null
+// SMESH Driver : implementaion of driver for reading and writing
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : Mesh_Reader.h
+// Module : SMESH
+
+#ifndef _INCLUDE_DRIVER_MESH
+#define _INCLUDE_DRIVER_MESH
+
+#include <string>
+
+class Driver_Mesh
+{
+ public:
+ Driver_Mesh();
+ virtual ~Driver_Mesh(){}
+
+ enum Status {
+ DRS_OK,
+ DRS_EMPTY, // a file contains no mesh with the given name
+ DRS_WARN_RENUMBER, // a file has overlapped ranges of element numbers,
+ // so the numbers from the file are ignored
+ DRS_WARN_SKIP_ELEM, // some elements were skipped due to incorrect file data
+ DRS_FAIL // general failure (exception etc.)
+ };
+
+ virtual Status Perform() = 0;
+ void SetMeshId(int theMeshId);
+ void SetFile(const std::string& theFileName);
+
+ protected:
+ std::string myFile;
+ int myMeshId;
+
+};
+
+#endif
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#include "Driver_SMDS_Mesh.h"
+
+using namespace std;
+
+Driver_SMDS_Mesh::Driver_SMDS_Mesh():
+ myMesh(NULL)
+{}
+
+void Driver_SMDS_Mesh::SetMesh(SMDS_Mesh *theMesh)
+{
+ myMesh = theMesh;
+}
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#ifndef _INCLUDE_DRIVER_SMDS_MESH
+#define _INCLUDE_DRIVER_SMDS_MESH
+
+#include "Driver_Mesh.h"
+
+class SMDS_Mesh;
+
+class Driver_SMDS_Mesh: public Driver_Mesh
+{
+ public:
+ Driver_SMDS_Mesh();
+ void SetMesh(SMDS_Mesh *theMesh);
+
+ protected:
+ SMDS_Mesh *myMesh;
+
+};
+
+#endif
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#include "Driver_SMESHDS_Mesh.h"
+
+using namespace std;
+
+Driver_SMESHDS_Mesh::Driver_SMESHDS_Mesh():
+ myMesh(NULL)
+{}
+
+void Driver_SMESHDS_Mesh::SetMesh(SMESHDS_Mesh *theMesh)
+{
+ myMesh = theMesh;
+}
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#ifndef _INCLUDE_DRIVER_SMESHDS_MESH
+#define _INCLUDE_DRIVER_SMESHDS_MESH
+
+#include "Driver_Mesh.h"
+
+class SMESHDS_Mesh;
+
+class Driver_SMESHDS_Mesh: public Driver_Mesh
+{
+ public:
+ Driver_SMESHDS_Mesh();
+ void SetMesh(SMESHDS_Mesh *theMesh);
+
+ protected:
+ SMESHDS_Mesh *myMesh;
+
+};
+
+#endif
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#include "DriverDAT_R_SMDS_Mesh.h"
+#include "DriverDAT_W_SMDS_Mesh.h"
+
+int main(int argc, char** argv)
+{
+ DriverDAT_R_SMDS_Mesh aR;
+ DriverDAT_W_SMDS_Mesh aW;
+ return 1;
+}
--- /dev/null
+// SMESH DriverMED : tool to split groups on families
+//
+// Copyright (C) 2003 CEA
+//
+// 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.org
+//
+//
+//
+// File : DriverMED_Family.cxx
+// Author : Julia DOROVSKIKH
+// Module : SMESH
+// $Header$
+
+#include "DriverMED_Family.h"
+#include <sstream>
+
+//=============================================================================
+/*!
+ * Split each group from list <aGroups> on some parts (families)
+ * on the basis of the elements membership in other groups from this list.
+ * Resulting families have no common elements.
+ */
+//=============================================================================
+list<DriverMED_FamilyPtr> DriverMED_Family::MakeFamilies
+ (const map <int, SMESHDS_SubMesh*>& theSubMeshes,
+ const list<SMESHDS_Group*>& theGroups,
+ const bool doGroupOfNodes,
+ const bool doGroupOfEdges,
+ const bool doGroupOfFaces,
+ const bool doGroupOfVolumes)
+{
+ list<DriverMED_FamilyPtr> aFamilies;
+
+ string anAllNodesGroupName = "Group_Of_All_Nodes";
+ string anAllEdgesGroupName = "Group_Of_All_Edges";
+ string anAllFacesGroupName = "Group_Of_All_Faces";
+ string anAllVolumesGroupName = "Group_Of_All_Volumes";
+
+ // Reserve four ids for families of free elements
+ // (1 - nodes, -1 - edges, -2 - faces, -3 - volumes).
+ // 'Free' means here not belonging to any group.
+ int aNodeFamId = FIRST_NODE_FAMILY;
+ int aElemFamId = FIRST_ELEM_FAMILY;
+
+ // Process sub-meshes
+ map<int, SMESHDS_SubMesh*>::const_iterator aSMIter = theSubMeshes.begin();
+ for (; aSMIter != theSubMeshes.end(); aSMIter++)
+ {
+ list<DriverMED_FamilyPtr> aSMFams = SplitByType((*aSMIter).second, (*aSMIter).first);
+ list<DriverMED_FamilyPtr>::iterator aSMFamsIter = aSMFams.begin();
+ for (; aSMFamsIter != aSMFams.end(); aSMFamsIter++)
+ {
+ DriverMED_FamilyPtr aFam2 = (*aSMFamsIter);
+
+ list<DriverMED_FamilyPtr>::iterator aFamsIter = aFamilies.begin();
+ while (aFamsIter != aFamilies.end())
+ {
+ DriverMED_FamilyPtr aFam1 = *aFamsIter;
+ list<DriverMED_FamilyPtr>::iterator aCurrIter = aFamsIter++;
+ if (aFam1->myType == aFam2->myType)
+ {
+ DriverMED_FamilyPtr aCommon (new DriverMED_Family);
+ aFam1->Split(aFam2, aCommon);
+ if (!aCommon->IsEmpty())
+ {
+ aFamilies.push_back(aCommon);
+ }
+ if (aFam1->IsEmpty())
+ {
+ aFamilies.erase(aCurrIter);
+ }
+ if (aFam2->IsEmpty()) break;
+ }
+ }
+ // The rest elements of family
+ if (!aFam2->IsEmpty())
+ {
+ aFamilies.push_back(aFam2);
+ }
+ }
+ }
+
+ // Process groups
+ list<SMESHDS_Group*>::const_iterator aGroupsIter = theGroups.begin();
+ for (; aGroupsIter != theGroups.end(); aGroupsIter++)
+ {
+ DriverMED_FamilyPtr aFam2 (new DriverMED_Family);
+ aFam2->Init(*aGroupsIter);
+
+ list<DriverMED_FamilyPtr>::iterator aFamsIter = aFamilies.begin();
+ while (aFamsIter != aFamilies.end())
+ {
+ DriverMED_FamilyPtr aFam1 = *aFamsIter;
+ list<DriverMED_FamilyPtr>::iterator aCurrIter = aFamsIter++;
+ if (aFam1->myType == aFam2->myType)
+ {
+ DriverMED_FamilyPtr aCommon (new DriverMED_Family);
+ aFam1->Split(aFam2, aCommon);
+ if (!aCommon->IsEmpty())
+ {
+ aFamilies.push_back(aCommon);
+ }
+ if (aFam1->IsEmpty())
+ {
+ aFamilies.erase(aCurrIter);
+ }
+ if (aFam2->IsEmpty()) break;
+ }
+ }
+ // The rest elements of group
+ if (!aFam2->IsEmpty())
+ {
+ aFamilies.push_back(aFam2);
+ }
+ }
+
+ list<DriverMED_FamilyPtr>::iterator aFamsIter = aFamilies.begin();
+ for (; aFamsIter != aFamilies.end(); aFamsIter++)
+ {
+ DriverMED_FamilyPtr aFam = *aFamsIter;
+ if (aFam->myType == SMDSAbs_Node) {
+ aFam->SetId(aNodeFamId++);
+ if (doGroupOfNodes) aFam->myGroupNames.insert(anAllNodesGroupName);
+ }
+ else {
+ aFam->SetId(aElemFamId--);
+ if (aFam->myType == SMDSAbs_Edge) {
+ if (doGroupOfEdges) aFam->myGroupNames.insert(anAllEdgesGroupName);
+ }
+ else if (aFam->myType == SMDSAbs_Face) {
+ if (doGroupOfFaces) aFam->myGroupNames.insert(anAllFacesGroupName);
+ }
+ else if (aFam->myType == SMDSAbs_Volume) {
+ if (doGroupOfVolumes) aFam->myGroupNames.insert(anAllVolumesGroupName);
+ }
+ }
+ }
+
+ // Create families for elements, not belonging to any group
+ if (doGroupOfNodes)
+ {
+ DriverMED_FamilyPtr aFreeNodesFam (new DriverMED_Family);
+ aFreeNodesFam->SetId(REST_NODES_FAMILY);
+ aFreeNodesFam->myType = SMDSAbs_Node;
+ aFreeNodesFam->myGroupNames.insert(anAllNodesGroupName);
+ aFamilies.push_back(aFreeNodesFam);
+ }
+
+ if (doGroupOfEdges)
+ {
+ DriverMED_FamilyPtr aFreeEdgesFam (new DriverMED_Family);
+ aFreeEdgesFam->SetId(REST_EDGES_FAMILY);
+ aFreeEdgesFam->myType = SMDSAbs_Edge;
+ aFreeEdgesFam->myGroupNames.insert(anAllEdgesGroupName);
+ aFamilies.push_back(aFreeEdgesFam);
+ }
+
+ if (doGroupOfFaces)
+ {
+ DriverMED_FamilyPtr aFreeFacesFam (new DriverMED_Family);
+ aFreeFacesFam->SetId(REST_FACES_FAMILY);
+ aFreeFacesFam->myType = SMDSAbs_Face;
+ aFreeFacesFam->myGroupNames.insert(anAllFacesGroupName);
+ aFamilies.push_back(aFreeFacesFam);
+ }
+
+ if (doGroupOfVolumes)
+ {
+ DriverMED_FamilyPtr aFreeVolumesFam (new DriverMED_Family);
+ aFreeVolumesFam->SetId(REST_VOLUMES_FAMILY);
+ aFreeVolumesFam->myType = SMDSAbs_Volume;
+ aFreeVolumesFam->myGroupNames.insert(anAllVolumesGroupName);
+ aFamilies.push_back(aFreeVolumesFam);
+ }
+
+ DriverMED_FamilyPtr aNullFam (new DriverMED_Family);
+ aNullFam->SetId(0);
+ aNullFam->myType = SMDSAbs_All;
+ aFamilies.push_back(aNullFam);
+
+ return aFamilies;
+}
+
+//=============================================================================
+/*!
+ * Create TFamilyInfo for this family
+ */
+//=============================================================================
+MEDA::PFamilyInfo DriverMED_Family::GetFamilyInfo
+ (const MEDA::PMeshInfo& theMeshInfo) const
+{
+ string aValue;
+ ostringstream aStr;
+ aStr << myId;
+ aValue = aStr.str();
+ MED::TStringVector anAttrDescs (1, ""); // 1 attribute with empty description,
+ MED::TIntVector anAttrIds (1, myId); // Id=0,
+ MED::TIntVector anAttrVals (1, myId); // Value=0
+
+ MEDA::PFamilyInfo anInfo = MEDA::TWrapper::CrFamilyInfo(theMeshInfo,
+ aValue,
+ myId,
+ myGroupNames,
+ anAttrDescs,anAttrIds,anAttrVals);
+
+// cout << endl;
+// cout << "Groups: ";
+// set<string>::iterator aGrIter = myGroupNames.begin();
+// for (; aGrIter != myGroupNames.end(); aGrIter++)
+// {
+// cout << " " << *aGrIter;
+// }
+// cout << endl;
+//
+// cout << "Elements: ";
+// set<const SMDS_MeshElement *>::iterator anIter = myElements.begin();
+// for (; anIter != myElements.end(); anIter++)
+// {
+// cout << " " << (*anIter)->GetID();
+// }
+// cout << endl;
+
+ return anInfo;
+}
+
+//=============================================================================
+/*!
+ * Initialize the tool by SMESHDS_Group
+ */
+//=============================================================================
+void DriverMED_Family::Init (SMESHDS_Group* group)
+{
+ // Elements
+ myElements.clear();
+ group->InitIterator();
+ while (group->More())
+ {
+ myElements.insert(group->Next());
+ }
+
+ // Type
+ myType = group->GetType();
+
+ // Groups list
+ myGroupNames.clear();
+ myGroupNames.insert(string(group->GetStoreName()));
+}
+
+//=============================================================================
+/*!
+ * Split <theSubMesh> on some parts (families)
+ * on the basis of the elements type.
+ */
+//=============================================================================
+list<DriverMED_FamilyPtr> DriverMED_Family::SplitByType (SMESHDS_SubMesh* theSubMesh,
+ const int theId)
+{
+ list<DriverMED_FamilyPtr> aFamilies;
+ DriverMED_FamilyPtr aNodesFamily (new DriverMED_Family);
+ DriverMED_FamilyPtr anEdgesFamily (new DriverMED_Family);
+ DriverMED_FamilyPtr aFacesFamily (new DriverMED_Family);
+ DriverMED_FamilyPtr aVolumesFamily (new DriverMED_Family);
+
+ char submeshGrpName[ 30 ];
+ sprintf( submeshGrpName, "SubMesh %d", theId );
+
+ SMDS_NodeIteratorPtr aNodesIter = theSubMesh->GetNodes();
+ while (aNodesIter->more())
+ {
+ const SMDS_MeshNode* aNode = aNodesIter->next();
+ aNodesFamily->AddElement(aNode);
+ }
+
+ SMDS_ElemIteratorPtr anElemsIter = theSubMesh->GetElements();
+ while (anElemsIter->more())
+ {
+ const SMDS_MeshElement* anElem = anElemsIter->next();
+ switch (anElem->GetType())
+ {
+ case SMDSAbs_Edge:
+ anEdgesFamily->AddElement(anElem);
+ break;
+ case SMDSAbs_Face:
+ aFacesFamily->AddElement(anElem);
+ break;
+ case SMDSAbs_Volume:
+ aVolumesFamily->AddElement(anElem);
+ break;
+ default:
+ break;
+ }
+ }
+
+ if (!aNodesFamily->IsEmpty()) {
+ aNodesFamily->SetType(SMDSAbs_Node);
+ aNodesFamily->AddGroupName(submeshGrpName);
+ aFamilies.push_back(aNodesFamily);
+ }
+ if (!anEdgesFamily->IsEmpty()) {
+ anEdgesFamily->SetType(SMDSAbs_Edge);
+ anEdgesFamily->AddGroupName(submeshGrpName);
+ aFamilies.push_back(anEdgesFamily);
+ }
+ if (!aFacesFamily->IsEmpty()) {
+ aFacesFamily->SetType(SMDSAbs_Face);
+ aFacesFamily->AddGroupName(submeshGrpName);
+ aFamilies.push_back(aFacesFamily);
+ }
+ if (!aVolumesFamily->IsEmpty()) {
+ aVolumesFamily->SetType(SMDSAbs_Volume);
+ aVolumesFamily->AddGroupName(submeshGrpName);
+ aFamilies.push_back(aVolumesFamily);
+ }
+
+ return aFamilies;
+}
+
+//=============================================================================
+/*!
+ * Remove from <myElements> elements, common with <by>,
+ * Remove from <by> elements, common with <myElements>,
+ * Create family <common> from common elements, with combined groups list.
+ */
+//=============================================================================
+void DriverMED_Family::Split (DriverMED_FamilyPtr by,
+ DriverMED_FamilyPtr common)
+{
+ // Elements
+ set<const SMDS_MeshElement *>::iterator anIter = by->myElements.begin();
+ for (; anIter != by->myElements.end(); anIter++)
+ {
+ if (myElements.find(*anIter) != myElements.end())
+ {
+ common->myElements.insert(*anIter);
+ myElements.erase(*anIter);
+ by->myElements.erase(*anIter);
+ }
+ }
+
+ if (!common->IsEmpty())
+ {
+ // Groups list
+ common->myGroupNames = myGroupNames;
+ set<string>::iterator aGrNamesIter = by->myGroupNames.begin();
+ for (; aGrNamesIter != by->myGroupNames.end(); aGrNamesIter++)
+ {
+ common->myGroupNames.insert(*aGrNamesIter);
+ }
+
+ // Type
+ common->myType = myType;
+ }
+}
--- /dev/null
+// SMESH DriverMED : tool to split groups on families
+//
+// Copyright (C) 2003 CEA
+//
+// 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.org
+//
+//
+//
+// File : DriverMED_Family.hxx
+// Author : Julia DOROVSKIKH
+// Module : SMESH
+// $Header$
+
+#ifndef _INCLUDE_DRIVERMED_FAMILY
+#define _INCLUDE_DRIVERMED_FAMILY
+
+#include "SMDS_Mesh.hxx"
+#include "SMESHDS_Group.hxx"
+#include "SMESHDS_SubMesh.hxx"
+#include "MEDA_Wrapper.hxx"
+
+#include <boost/shared_ptr.hpp>
+#include <set>
+
+using namespace std;
+
+#define REST_NODES_FAMILY 1
+#define REST_EDGES_FAMILY -1
+#define REST_FACES_FAMILY -2
+#define REST_VOLUMES_FAMILY -3
+#define FIRST_NODE_FAMILY 2
+#define FIRST_ELEM_FAMILY -4
+
+class DriverMED_Family;
+typedef boost::shared_ptr<DriverMED_Family> DriverMED_FamilyPtr;
+
+class DriverMED_Family
+{
+ public:
+
+ // Methods for groups storing to MED
+
+ static list<DriverMED_FamilyPtr> MakeFamilies (const map <int, SMESHDS_SubMesh*>& theSubMeshes,
+ const list<SMESHDS_Group*>& theGroups,
+ const bool doGroupOfNodes,
+ const bool doGroupOfEdges,
+ const bool doGroupOfFaces,
+ const bool doGroupOfVolumes);
+ // Split each group from list <theGroups> and each sub-mesh from list <theSubMeshes>
+ // on some parts (families) on the basis of the elements membership in other groups
+ // from <theGroups> and other sub-meshes from <theSubMeshes>.
+ // Resulting families have no common elements.
+
+ MEDA::PFamilyInfo GetFamilyInfo (const MEDA::PMeshInfo& theMeshInfo) const;
+ // Create TFamilyInfo for this family
+
+ const set<const SMDS_MeshElement *>& GetElements () const { return myElements; }
+ // Returns elements of this family
+
+ int GetId () const { return myId; }
+ // Returns a family ID
+
+ public:
+
+ // Methods for groups reading from MED
+
+ void AddElement (const SMDS_MeshElement* theElement) { myElements.insert(theElement); }
+
+ void AddGroupName (string theGroupName) { myGroupNames.insert(theGroupName); }
+
+ void SetType (const SMDSAbs_ElementType theType) { myType = theType; }
+ SMDSAbs_ElementType GetType () { return myType; }
+
+ bool MemberOf (string theGroupName) const
+ { return (myGroupNames.find(theGroupName) != myGroupNames.end()); }
+
+ const MED::TStringSet& GetGroupNames () const { return myGroupNames; }
+
+ private:
+ void Init (SMESHDS_Group* group);
+ // Initialize the tool by SMESHDS_Group
+
+ static list<DriverMED_FamilyPtr> SplitByType (SMESHDS_SubMesh* theSubMesh,
+ const int theId);
+ // Split <theSubMesh> on some parts (families)
+ // on the basis of the elements type.
+
+ void Split (DriverMED_FamilyPtr by,
+ DriverMED_FamilyPtr common);
+ // Remove from <Elements> elements, common with <by>,
+ // Remove from <by> elements, common with <Elements>,
+ // Create family <common> from common elements, with combined groups list.
+
+ void SetId (const int theId) { myId = theId; }
+ // Sets a family ID
+
+ bool IsEmpty () const { return myElements.empty(); }
+ // Check, if this family has empty list of elements
+
+ private:
+ int myId;
+ SMDSAbs_ElementType myType;
+ set<const SMDS_MeshElement *> myElements;
+ MED::TStringSet myGroupNames;
+};
+
+#endif
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#include "DriverMED_R_SMESHDS_Mesh.h"
+#include "DriverMED_W_SMESHDS_Mesh.h"
+
+int main(int argc, char** argv)
+{
+ DriverMED_R_SMESHDS_Mesh aR;
+ DriverMED_W_SMESHDS_Mesh aW;
+ return 1;
+}
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#include <fstream>
+
+#include "UNV2411_Structure.hxx"
+#include "UNV_Utilities.hxx"
+
+using namespace std;
+using namespace UNV;
+using namespace UNV2411;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+static string _label_dataset = "2411";
+
+UNV2411::TRecord::TRecord():
+ exp_coord_sys_num(0),
+ disp_coord_sys_num(0),
+ color(0)
+{}
+
+void UNV2411::Read(std::ifstream& in_stream, TDataSet& theDataSet)
+{
+ if(!in_stream.good())
+ EXCEPTION(runtime_error,"ERROR: Input file not good.");
+
+ /*
+ * adjust the \p istream to our
+ * position
+ */
+ if(!beginning_of_dataset(in_stream,_label_dataset))
+ EXCEPTION(runtime_error,"ERROR: Could not find "<<_label_dataset<<" dataset!");
+
+ /**
+ * always 3 coordinates in the UNV file, no matter
+ * which dimensionality libMesh is in
+ */
+ TNodeLab aLabel;
+ std::string num_buf;
+ for(; !in_stream.eof();){
+ in_stream >> aLabel ;
+ if(aLabel == -1){
+ // end of dataset is reached
+ break;
+ }
+
+ TRecord aRec;
+ in_stream>>aRec.exp_coord_sys_num;
+ in_stream>>aRec.disp_coord_sys_num;
+ in_stream>>aRec.color;
+
+ /*
+ * take care of the
+ * floating-point data
+ */
+ for(int d = 0; d < 3; d++){
+ in_stream>>num_buf;
+ aRec.coord[d] = D_to_e(num_buf);
+ }
+
+ theDataSet.insert(TDataSet::value_type(aLabel,aRec));
+ }
+}
+
+
+void UNV2411::Write(std::ofstream& out_stream, const TDataSet& theDataSet)
+{
+ if(!out_stream.good())
+ EXCEPTION(runtime_error,"ERROR: Output file not good.");
+
+ /*
+ * Write beginning of dataset
+ */
+ out_stream<<" -1\n";
+ out_stream<<" "<<_label_dataset<<"\n";
+
+ TDataSet::const_iterator anIter = theDataSet.begin();
+ for(; anIter != theDataSet.end(); anIter++){
+ const TNodeLab& aLabel = anIter->first;
+ const TRecord& aRec = anIter->second;
+ char buf[78];
+ sprintf(buf, "%10d%10d%10d%10d\n",
+ aLabel,
+ aRec.exp_coord_sys_num,
+ aRec.disp_coord_sys_num,
+ aRec.color);
+ out_stream<<buf;
+
+ // the coordinates
+ sprintf(buf, "%25.16E%25.16E%25.16E\n",
+ aRec.coord[0],
+ aRec.coord[1],
+ aRec.coord[2]);
+ out_stream<<buf;
+ }
+
+
+ /*
+ * Write end of dataset
+ */
+ out_stream<<" -1\n";
+}
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#ifndef UNV2411_Structure_HeaderFile
+#define UNV2411_Structure_HeaderFile
+
+#include <map>
+#include <fstream>
+
+namespace UNV2411{
+
+ struct TRecord{
+ TRecord();
+ int exp_coord_sys_num; // export coordinate system number
+ int disp_coord_sys_num; // displacement coordinate system number
+ int color; // color
+ double coord[3]; // node coordinates in the part coordinate system
+ };
+
+ typedef int TNodeLab; // type of node label
+ typedef std::map<TNodeLab,TRecord> TDataSet;
+
+ void Read(std::ifstream& in_stream, TDataSet& theDataSet);
+
+ void Write(std::ofstream& out_stream, const TDataSet& theDataSet);
+
+};
+
+
+#endif
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#include <fstream>
+#include <iomanip>
+
+#include "UNV2412_Structure.hxx"
+#include "UNV_Utilities.hxx"
+
+using namespace std;
+using namespace UNV;
+using namespace UNV2412;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+static string _label_dataset = "2412";
+
+UNV2412::TRecord::TRecord():
+ phys_prop_tab_num(2),
+ mat_prop_tab_num(1),
+ color(7),
+ beam_orientation(0),
+ beam_fore_end(0),
+ beam_aft_end(0)
+{}
+
+void UNV2412::Read(std::ifstream& in_stream, TDataSet& theDataSet)
+{
+ if(!in_stream.good())
+ EXCEPTION(runtime_error,"ERROR: Input file not good.");
+
+ /*
+ * adjust the \p istream to our
+ * position
+ */
+ if(!beginning_of_dataset(in_stream,_label_dataset))
+ EXCEPTION(runtime_error,"ERROR: Could not find "<<_label_dataset<<" dataset!");
+
+ TElementLab aLabel;
+ for(; !in_stream.eof();){
+ in_stream >> aLabel ;
+ if(aLabel == -1){
+ // end of dataset is reached
+ break;
+ }
+
+ int n_nodes;
+ TRecord aRec;
+ in_stream>>aRec.fe_descriptor_id;
+ in_stream>>aRec.phys_prop_tab_num;
+ in_stream>>aRec.mat_prop_tab_num;
+ in_stream>>aRec.color;
+ in_stream>>n_nodes;
+
+ if(IsBeam(aRec.fe_descriptor_id)){
+ in_stream>>aRec.beam_orientation;
+ in_stream>>aRec.beam_fore_end;
+ in_stream>>aRec.beam_aft_end;
+ }
+
+ aRec.node_labels.resize(n_nodes);
+ for(int j=0; j < n_nodes; j++){
+ // read node labels
+ in_stream>>aRec.node_labels[j];
+ }
+
+ theDataSet.insert(TDataSet::value_type(aLabel,aRec));
+ }
+
+}
+
+
+void UNV2412::Write(std::ofstream& out_stream, const TDataSet& theDataSet)
+{
+ if(!out_stream.good())
+ EXCEPTION(runtime_error,"ERROR: Output file not good.");
+
+ /*
+ * Write beginning of dataset
+ */
+ out_stream<<" -1\n";
+ out_stream<<" "<<_label_dataset<<"\n";
+
+ TDataSet::const_iterator anIter = theDataSet.begin();
+ for(; anIter != theDataSet.end(); anIter++){
+ const TElementLab& aLabel = anIter->first;
+ const TRecord& aRec = anIter->second;
+ out_stream<<std::setw(10)<<aLabel; /* element ID */
+ out_stream<<std::setw(10)<<aRec.fe_descriptor_id; /* type of element */
+ out_stream<<std::setw(10)<<aRec.phys_prop_tab_num;
+ out_stream<<std::setw(10)<<aRec.mat_prop_tab_num;
+ out_stream<<std::setw(10)<<aRec.color;
+ out_stream<<std::setw(10)<<aRec.node_labels.size()<<std::endl; /* No. of nodes per element */
+
+ if(IsBeam(aRec.fe_descriptor_id)){
+ out_stream<<std::setw(10)<<aRec.beam_orientation;
+ out_stream<<std::setw(10)<<aRec.beam_fore_end;
+ out_stream<<std::setw(10)<<aRec.beam_aft_end<<std::endl;
+ }
+
+ int n_nodes = aRec.node_labels.size();
+ int iEnd = (n_nodes-1)/8 + 1;
+ for(int i = 0, k = 0; i < iEnd; i++){
+ int jEnd = n_nodes - 8*(i+1);
+ if(jEnd < 0)
+ jEnd = 8 + jEnd;
+ else
+ jEnd = 8;
+ for(int j = 0; j < jEnd ; k++, j++){
+ out_stream<<std::setw(10)<<aRec.node_labels[k];
+ }
+ out_stream<<std::endl;
+ }
+ }
+
+ /*
+ * Write end of dataset
+ */
+ out_stream<<" -1\n";
+}
+
+
+bool UNV2412::IsBeam(int theFeDescriptorId){
+ switch (theFeDescriptorId){
+ case 11:
+ case 21:
+ case 22:
+ case 24:
+ case 25:
+ return true;
+ }
+ return false;
+}
+
+
+bool UNV2412::IsFace(int theFeDescriptorId){
+ switch (theFeDescriptorId){
+
+ case 71: // TRI3
+ case 72:
+ case 74:
+
+ case 41: // Plane Stress Linear Triangle - TRI3
+ case 91: // Thin Shell Linear Triangle - TRI3
+
+ case 42: // Plane Stress Quadratic Triangle - TRI6
+ case 92: // Thin Shell Quadratic Triangle - TRI6
+
+ case 43: // Plane Stress Cubic Triangle
+
+ case 44: // Plane Stress Linear Quadrilateral - QUAD4
+ case 94: // Thin Shell Linear Quadrilateral - QUAD4
+
+ case 45: // Plane Stress Quadratic Quadrilateral - QUAD8
+ case 95: // Thin Shell Quadratic Quadrilateral - QUAD8
+
+ case 46: // Plane Stress Cubic Quadrilateral
+
+ return true;
+ }
+ return false;
+}
+
+
+bool UNV2412::IsVolume(int theFeDescriptorId){
+ //if(!IsBeam(theFeDescriptorId) && !IsFace(theFeDescriptorId))
+ // return true;
+ switch (theFeDescriptorId){
+
+ case 111: // Solid Linear Tetrahedron - TET4
+ case 118: // Solid Quadratic Tetrahedron - TET10
+
+ case 112: // Solid Linear Prism - PRISM6
+
+ case 115: // Solid Linear Brick - HEX8
+ case 116: // Solid Quadratic Brick - HEX20
+
+ case 117: // Solid Cubic Brick
+ return true;
+ }
+ return false;
+}
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#ifndef UNV2412_Structure_HeaderFile
+#define UNV2412_Structure_HeaderFile
+
+#include <map>
+#include <vector>
+#include <fstream>
+
+
+namespace UNV2412{
+
+ struct TRecord{
+ TRecord();
+
+ int fe_descriptor_id; // FE descriptor id
+ int phys_prop_tab_num; // physical property table number
+ int mat_prop_tab_num; // material property table number
+ int color; // color
+ std::vector<int> node_labels; // node labels defining element
+
+ //FOR BEAM ELEMENTS ONLY
+ int beam_orientation; // beam orientation node number
+ int beam_fore_end; // beam fore-end cross section number
+ int beam_aft_end; // beam aft-end cross section number
+ };
+
+ typedef int TElementLab; // type of element label
+ typedef std::map<TElementLab,TRecord> TDataSet;
+
+ void Read(std::ifstream& in_stream, TDataSet& theDataSet);
+
+ void Write(std::ofstream& out_stream, const TDataSet& theDataSet);
+
+ bool IsBeam(int theFeDescriptorId);
+ bool IsFace(int theFeDescriptorId);
+ bool IsVolume(int theFeDescriptorId);
+
+};
+
+
+#endif
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+#include "UNV2411_Structure.hxx"
+#include "UNV2412_Structure.hxx"
+#include "UNV_Utilities.hxx"
+
+#include "DriverUNV_R_SMDS_Mesh.h"
+#include "DriverUNV_W_SMDS_Mesh.h"
+
+using namespace std;
+
+#ifdef DEBUG
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+void ReadMed(const char* theFileName){
+ std::ifstream in_stream(theFileName);
+
+ UNV2411::TDataSet aDataSet2411;
+ UNV2411::Read(in_stream,aDataSet2411);
+
+ in_stream.seekg(0);
+ UNV2412::TDataSet aDataSet2412;
+ UNV2412::Read(in_stream,aDataSet2412);
+
+ string aFileName(theFileName);
+ aFileName += "-";
+ std::ofstream out_stream(aFileName.c_str());
+
+ UNV2411::Write(out_stream,aDataSet2411);
+ UNV2412::Write(out_stream,aDataSet2412);
+}
+
+
+int main(int argc, char** argv){
+ DriverUNV_R_SMDS_Mesh aR;
+ DriverUNV_W_SMDS_Mesh aW;
+ try{
+ if(argc > 1){
+ ReadMed(argv[1]);
+ }
+ return 0;
+ }catch(std::exception& exc){
+ cout<<"Follow exception was accured :\n"<<exc.what()<<endl;
+ }catch(...){
+ cout<<"Unknown exception was accured !!!"<<endl;
+ }
+ return 1;
+}
--- /dev/null
+// Copyright (C) 2003 CEA/DEN, EDF R&D
+//
+//
+//
+// File : VISU_DatConvertor.cxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "UNV_Utilities.hxx"
+
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+int UNV::PrefixPrinter::myCounter = 0;
+
+UNV::PrefixPrinter::PrefixPrinter()
+{
+ myCounter++;
+}
+
+UNV::PrefixPrinter::~PrefixPrinter()
+{
+ myCounter--;
+}
+
+string UNV::PrefixPrinter::GetPrefix()
+{
+ if(myCounter)
+ return string(myCounter*2,' ');
+ return "";
+}
--- /dev/null
+// Copyright (C) 2003 CEA/DEN, EDF R&D
+//
+//
+//
+// File : VISU_DatConvertor.hxx
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef MED_Utilities_HeaderFile
+#define MED_Utilities_HeaderFile
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <stdexcept>
+
+
+namespace UNV{
+ using namespace std;
+
+ class PrefixPrinter{
+ static int myCounter;
+ public:
+ PrefixPrinter();
+ ~PrefixPrinter();
+
+ static string GetPrefix();
+ };
+
+ /**
+ * @returns \p false when error occured, \p true otherwise.
+ * Adjusts the \p in_stream to the beginning of the
+ * dataset \p ds_name.
+ */
+ inline bool beginning_of_dataset(std::istream& in_file, const std::string& ds_name)
+ {
+ assert (in_file.good());
+ assert (!ds_name.empty());
+
+ std::string olds, news;
+
+ while(true){
+ in_file >> olds >> news;
+ /*
+ * a "-1" followed by a number means the beginning of a dataset
+ * stop combing at the end of the file
+ */
+ while( ((olds != "-1") || (news == "-1") ) && !in_file.eof() ){
+ olds = news;
+ in_file >> news;
+ }
+ if(in_file.eof())
+ return false;
+ if (news == ds_name)
+ return true;
+ }
+ // should never end up here
+ return false;
+ }
+
+ /**
+ * Method for converting exponential notation
+ * from "D" to "e", for example
+ * \p 3.141592654D+00 \p --> \p 3.141592654e+00
+ * in order to make it readable for C++.
+ */
+ inline double D_to_e(std::string& number)
+ {
+ /* find "D" in string, start looking at
+ * 6th element, to improve speed.
+ * We dont expect a "D" earlier
+ */
+ const int position = number.find("D",6);
+ if(position != std::string::npos){
+ number.replace(position, 1, "e");
+ }
+ return atof (number.c_str());
+ }
+
+};
+
+
+#ifndef MESSAGE
+
+#define MESSAGE(msg) std::cout<<__FILE__<<"["<<__LINE__<<"]::"<<msg<<endl;
+
+#define BEGMSG(msg) std::cout<<UNV::PrefixPrinter::GetPrefix()<<msg
+
+#define ADDMSG(msg) std::cout<<msg
+
+#endif
+
+
+#ifndef EXCEPTION
+
+#define EXCEPTION(TYPE, MSG) {\
+ std::ostringstream aStream;\
+ aStream<<__FILE__<<"["<<__LINE__<<"]::"<<MSG;\
+ throw TYPE(aStream.str());\
+}
+
+#endif
+
+#endif
--- /dev/null
+# SMESH NETGENPlugin : implementaion of SMESH idl descriptions
+#
+# Copyright (C) 2004 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.
+#
+# 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+#
+#
+#
+# File : Makefile.in
+# Author : Julia DOROVSKIKH
+# Module : SMESH
+# $Header$
+
+top_srcdir=@top_srcdir@
+top_builddir=../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl:$(top_builddir)/idl:
+
+
+@COMMENCE@
+
+EXPORT_PYSCRIPTS =
+
+# .po files to transform in .qm
+PO_FILES = NETGENPlugin_icons.po
+
+# Libraries targets
+LIB = libNETGENEngine.la
+LIB_SRC = \
+ NETGENPlugin_NETGEN_3D.cxx \
+ NETGENPlugin_NETGEN_3D_i.cxx \
+ NETGENPlugin_i.cxx
+
+LIB_SERVER_IDL = SMESH_NetgenAlgorithm.idl
+
+LIB_CLIENT_IDL = SMESH_Gen.idl SMESH_Mesh.idl SMESH_Group.idl
+
+# Executables targets
+BIN =
+BIN_SRC =
+
+# additionnal information to compil and link file
+NETGEN_INCLUDES=@NETGEN_INCLUDES@
+
+CPPFLAGS+= $(OCC_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome \
+ -I${GEOM_ROOT_DIR}/include/salome $(NETGEN_INCLUDES) $(BOOST_CPPFLAGS)
+CXXFLAGS+= $(OCC_CXXFLAGS) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome \
+ -I${GEOM_ROOT_DIR}/include/salome $(NETGEN_INCLUDES)
+
+LDFLAGS+= $(HDF5_LIBS) -lSMESHimpl -lSMESHEngine -lStdMeshers -lStdMeshersEngine -lNETGEN -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome -lSalomeGenericObj
+
+@CONCLUDE@
--- /dev/null
+//=============================================================================
+// File : NETGENPlugin_NETGEN_3D.cxx
+// Moved here from SMESH_NETGEN_3D.cxx
+// Created : lundi 27 Janvier 2003
+// Author : Nadir BOUHAMOU (CEA)
+// Project : SALOME
+// Copyright : CEA 2003
+// $Header$
+//=============================================================================
+using namespace std;
+
+#include "NETGENPlugin_NETGEN_3D.hxx"
+#include "SMESH_Gen.hxx"
+#include "SMESH_Mesh.hxx"
+
+#include "SMDS_MeshElement.hxx"
+#include "SMDS_MeshNode.hxx"
+#include "SMDS_FacePosition.hxx"
+
+#include <TopExp.hxx>
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
+
+#include <BRep_Tool.hxx>
+#include <Geom_Surface.hxx>
+#include <Geom_Curve.hxx>
+#include <Geom2d_Curve.hxx>
+
+#include "utilities.h"
+
+/*
+ Netgen include files
+*/
+
+#include "nglib.h"
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_3D::NETGENPlugin_NETGEN_3D(int hypId, int studyId,
+ SMESH_Gen* gen)
+ : SMESH_3D_Algo(hypId, studyId, gen)
+{
+ MESSAGE("NETGENPlugin_NETGEN_3D::NETGENPlugin_NETGEN_3D");
+ _name = "NETGEN_3D";
+// _shapeType = TopAbs_SOLID;
+ _shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID);// 1 bit /shape type
+// MESSAGE("_shapeType octal " << oct << _shapeType);
+ _compatibleHypothesis.push_back("MaxElementVolume");
+
+ _maxElementVolume = 0.;
+
+ _hypMaxElementVolume = NULL;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_3D::~NETGENPlugin_NETGEN_3D()
+{
+ MESSAGE("NETGENPlugin_NETGEN_3D::~NETGENPlugin_NETGEN_3D");
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+bool NETGENPlugin_NETGEN_3D::CheckHypothesis
+ (SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ SMESH_Hypothesis::Hypothesis_Status& aStatus)
+{
+ MESSAGE("NETGENPlugin_NETGEN_3D::CheckHypothesis");
+
+ _hypMaxElementVolume = NULL;
+
+ list<const SMESHDS_Hypothesis*>::const_iterator itl;
+ const SMESHDS_Hypothesis* theHyp;
+
+ const list<const SMESHDS_Hypothesis*>& hyps = GetUsedHypothesis(aMesh, aShape);
+ int nbHyp = hyps.size();
+ if (!nbHyp)
+ {
+ aStatus = SMESH_Hypothesis::HYP_MISSING;
+ return false; // can't work with no hypothesis
+ }
+
+ itl = hyps.begin();
+ theHyp = (*itl); // use only the first hypothesis
+
+ string hypName = theHyp->GetName();
+ int hypId = theHyp->GetID();
+ SCRUTE(hypName);
+
+ bool isOk = false;
+
+ if (hypName == "MaxElementVolume")
+ {
+ _hypMaxElementVolume = static_cast<const StdMeshers_MaxElementVolume*> (theHyp);
+ ASSERT(_hypMaxElementVolume);
+ _maxElementVolume = _hypMaxElementVolume->GetMaxVolume();
+ isOk =true;
+ aStatus = SMESH_Hypothesis::HYP_OK;
+ }
+ else
+ aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
+
+ return isOk;
+}
+
+//=============================================================================
+/*!
+ *Here we are going to use the NETGEN mesher
+ */
+//=============================================================================
+
+bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape)
+{
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute with maxElmentsize = " << _maxElementVolume);
+
+ bool isOk = false;
+ SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
+ SMESH_subMesh* theSubMesh = aMesh.GetSubMesh(aShape);
+ //const Handle(SMESHDS_SubMesh)& subMeshDS = theSubMesh->GetSubMeshDS();
+
+ map<int, const SMDS_MeshNode*> netgenToDS;
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute Checking the mesh Faces");
+
+ // check if all faces were meshed by a triangle mesher (here MESFISTO_2D)
+
+ vector<SMESH_subMesh*> meshFaces;
+ vector<TopoDS_Shape> shapeFaces;
+
+ for (TopExp_Explorer exp(aShape,TopAbs_FACE);exp.More();exp.Next())
+ {
+ TopoDS_Shape aShapeFace = exp.Current();
+ SMESH_subMesh* aSubMesh = aMesh.GetSubMeshContaining(exp.Current());
+ ASSERT (aSubMesh);
+ int internal_size = meshFaces.size();
+ int index = 0;
+ for (int i = 0;i<internal_size;i++)
+ {
+ if (aSubMesh == meshFaces[i]) index = 1;
+ }
+ if (index == 0) meshFaces.push_back(aSubMesh);
+
+ internal_size = shapeFaces.size();
+ index = 0;
+ for (int i = 0;i<internal_size;i++)
+ {
+ if (aShapeFace == shapeFaces[i]) index = 1;
+ }
+ if (index == 0) shapeFaces.push_back(aShapeFace);
+ }
+
+ int numberOfFaces = meshFaces.size();
+ int numberOfShapeFaces = shapeFaces.size();
+
+ SCRUTE(numberOfFaces);
+ SCRUTE(numberOfShapeFaces);
+
+ MESSAGE("---");
+
+ int NbTotOfTria = 0;
+ int NbTotOfNodesFaces = 0;
+
+ for (int i=0; i<numberOfFaces; i++)
+ {
+ TopoDS_Shape aShapeFace = meshFaces[i]->GetSubShape();
+ TopoDS_Shape aFace = shapeFaces[i];
+ SMESH_Algo* algoFace = _gen->GetAlgo(aMesh, aShapeFace);
+ string algoFaceName = algoFace->GetName();
+ SCRUTE(algoFaceName);
+ if (algoFaceName != "MEFISTO_2D")
+ {
+ SCRUTE(algoFaceName);
+ ASSERT(0);
+ return false;
+ }
+
+ bool orientationMeshFace = (aFace.Orientation() == aShapeFace.Orientation());
+
+ const SMESHDS_SubMesh* aSubMeshDSFace = meshFaces[i]->GetSubMeshDS();
+ SCRUTE(aSubMeshDSFace);
+
+ int nbNodes = aSubMeshDSFace->NbNodes();
+ NbTotOfNodesFaces += nbNodes;
+ int nbTria = aSubMeshDSFace->NbElements();
+ NbTotOfTria += nbTria;
+ int index = 0;
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute The mesh Face " << (i+1) << " has " << nbNodes << " face internal Nodes, " << nbTria << " triangles");
+
+ SCRUTE(orientationMeshFace);
+
+ if (orientationMeshFace)
+ {
+ MESSAGE("The mesh and face have the same orientation");
+ }
+ else
+ {
+ MESSAGE("The mesh and face have different orientations");
+ }
+
+ SMDS_NodeIteratorPtr iteratorNodes = aSubMeshDSFace->GetNodes();
+ SCRUTE(nbNodes);
+ index = 0;
+ while(iteratorNodes->more())
+ {
+ index++;
+ const SMDS_MeshNode * node = iteratorNodes->next();
+// int nodeId = node->GetID();
+// double nodeX = node->X();
+// double nodeY = node->Y();
+// double nodeZ = node->Z();
+// MESSAGE("NODE -> ID = " << nodeId << " X = " << nodeX << " Y = " << nodeY << " Z = " << nodeZ);
+ }
+
+ SCRUTE(index);
+
+ SMDS_ElemIteratorPtr iteratorTriangle = aSubMeshDSFace->GetElements();
+
+ SCRUTE(nbTria);
+ index = 0;
+ int numberOfDegeneratedTriangle = 0;
+ while(iteratorTriangle->more())
+ {
+ index++;
+ const SMDS_MeshElement * triangle = iteratorTriangle->next();
+ int triangleId = triangle->GetID();
+
+ SMDS_ElemIteratorPtr triangleNodesIt = triangle->nodesIterator();
+
+ const SMDS_MeshNode * node1 = static_cast<const SMDS_MeshNode *>(triangleNodesIt->next());
+ double node1X = node1->X();
+ double node1Y = node1->Y();
+ double node1Z = node1->Z();
+
+ const SMDS_MeshNode * node2 = static_cast<const SMDS_MeshNode *>(triangleNodesIt->next());
+ double node2X = node2->X();
+ double node2Y = node2->Y();
+ double node2Z = node2->Z();
+
+ const SMDS_MeshNode * node3 = static_cast<const SMDS_MeshNode *>(triangleNodesIt->next());
+ double node3X = node3->X();
+ double node3Y = node3->Y();
+ double node3Z = node3->Z();
+
+ int triangleNode1 = node1->GetID();
+ int triangleNode2 = node2->GetID();
+ int triangleNode3 = node3->GetID();
+
+ // Compute the triangle surface
+
+ double vect1 = ((node2Y - node1Y)*(node3Z - node1Z) - (node2Z - node1Z)*(node3Y - node1Y));
+ double vect2 = - ((node2X - node1X)*(node3Z - node1Z) - (node2Z - node1Z)*(node3X - node1X));
+ double vect3 = ((node2X - node1X)*(node3Y - node1Y) - (node2Y - node1Y)*(node3X - node1X));
+ double epsilon = 1.0e-6;
+
+ bool triangleIsDegenerated = ((abs(vect1)<epsilon) && (abs(vect2)<epsilon) && (abs(vect3)<epsilon));
+
+ if (triangleIsDegenerated)
+ {
+// MESSAGE("TRIANGLE -> ID = " << triangleId << " N1 = " << triangleNode1 << " N2 = " << triangleNode2 << " N3 = " << triangleNode3 << " is degenerated");
+// MESSAGE("NODE -> ID = " << triangleNode1 << " X = " << node1X << " Y = " << node1Y << " Z = " << node1Z);
+// MESSAGE("NODE -> ID = " << triangleNode2 << " X = " << node2X << " Y = " << node2Y << " Z = " << node2Z);
+// MESSAGE("NODE -> ID = " << triangleNode3 << " X = " << node3X << " Y = " << node3Y << " Z = " << node3Z);
+ numberOfDegeneratedTriangle++;
+ }
+ else
+ {
+// MESSAGE("TRIANGLE -> ID = " << triangleId << " N1 = " << triangleNode1 << " N2 = " << triangleNode2 << " N3 = " << triangleNode3 << " is normal");
+ }
+ }
+
+ if (numberOfDegeneratedTriangle > 0)
+ MESSAGE("WARNING THERE IS(ARE) " << numberOfDegeneratedTriangle << " degenerated triangle on this face");
+
+ SCRUTE(index);
+ }
+
+
+
+ SCRUTE(NbTotOfTria);
+ SCRUTE(NbTotOfNodesFaces);
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute Checking the mesh Edges");
+
+ // check if all edges were meshed by a edge mesher (here Regular_1D)
+
+ vector<SMESH_subMesh*> meshEdges;
+ for (TopExp_Explorer exp(aShape,TopAbs_EDGE);exp.More();exp.Next())
+ {
+ SMESH_subMesh* aSubMesh = aMesh.GetSubMeshContaining(exp.Current());
+ ASSERT (aSubMesh);
+ int internal_size = meshEdges.size();
+ int index = 0;
+ for (int i = 0;i<internal_size;i++)
+ {
+ if (aSubMesh == meshEdges[i]) index = 1;
+ }
+ if (index == 0) meshEdges.push_back(aSubMesh);
+ }
+
+ int numberOfEdges = meshEdges.size();
+ SCRUTE(numberOfEdges);
+
+ MESSAGE("---");
+
+ int NbTotOfNodesEdges = 0;
+ int NbTotOfSegs = 0;
+
+ for (int i=0; i<numberOfEdges; i++)
+ {
+ TopoDS_Shape aShapeEdge = meshEdges[i]->GetSubShape();
+ SMESH_Algo* algoEdge = _gen->GetAlgo(aMesh, aShapeEdge);
+ string algoEdgeName = algoEdge->GetName();
+ SCRUTE(algoEdgeName);
+ if (algoEdgeName != "Regular_1D")
+ {
+ SCRUTE(algoEdgeName);
+ ASSERT(0);
+ return false;
+ }
+
+ const SMESHDS_SubMesh* aSubMeshDSEdge = meshEdges[i]->GetSubMeshDS();
+ SCRUTE(aSubMeshDSEdge);
+
+ int nbNodes = aSubMeshDSEdge->NbNodes();
+ NbTotOfNodesEdges += nbNodes;
+ int nbSegs = aSubMeshDSEdge->NbElements();
+ NbTotOfSegs += nbSegs;
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute The mesh Edge " << (i+1) << " has " << nbNodes << " edge internal Nodes, " << nbSegs << " segments");
+
+ SMDS_NodeIteratorPtr iteratorNodes = aSubMeshDSEdge->GetNodes();
+ SCRUTE(nbNodes);
+ int index = 0;
+ while(iteratorNodes->more())
+ {
+ index++;
+ const SMDS_MeshNode * node = iteratorNodes->next();
+// int nodeId = node->GetID();
+// double nodeX = node->X();
+// double nodeY = node->Y();
+// double nodeZ = node->Z();
+// MESSAGE("NODE -> ID = " << nodeId << " X = " << nodeX << " Y = " << nodeY << " Z = " << nodeZ);
+ }
+
+ SCRUTE(index);
+ }
+
+ SCRUTE(NbTotOfNodesEdges);
+ SCRUTE(NbTotOfSegs);
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute Checking the mesh Vertices");
+
+ vector<SMESH_subMesh*> meshVertices;
+ for (TopExp_Explorer exp(aShape,TopAbs_VERTEX);exp.More();exp.Next())
+ {
+ SMESH_subMesh* aSubMesh = aMesh.GetSubMeshContaining(exp.Current());
+ ASSERT (aSubMesh);
+ int internal_size = meshVertices.size();
+ int index = 0;
+ for (int i = 0;i<internal_size;i++)
+ {
+ if (aSubMesh == meshVertices[i]) index = 1;
+ }
+ if (index == 0) meshVertices.push_back(aSubMesh);
+ }
+
+ int numberOfVertices = meshVertices.size();
+ SCRUTE(numberOfVertices);
+
+ MESSAGE("---");
+
+ int NbTotOfNodesVertices = 0;
+
+ for (int i=0; i<numberOfVertices; i++)
+ {
+ TopoDS_Shape aShapeVertex = meshVertices[i]->GetSubShape();
+
+ const SMESHDS_SubMesh * aSubMeshDSVertex = meshVertices[i]->GetSubMeshDS();
+ SCRUTE(aSubMeshDSVertex);
+
+ int nbNodes = aSubMeshDSVertex->NbNodes();
+ NbTotOfNodesVertices += nbNodes;
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute The mesh Vertex " << (i+1) << " has " << nbNodes << " Nodes");
+
+ SMDS_NodeIteratorPtr iteratorNodes = aSubMeshDSVertex->GetNodes();
+ SCRUTE(nbNodes);
+ int index = 0;
+ while(iteratorNodes->more())
+ {
+ index++;
+ const SMDS_MeshNode * node = iteratorNodes->next();
+// int nodeId = node->GetID();
+// double nodeX = node->X();
+// double nodeY = node->Y();
+// double nodeZ = node->Z();
+// MESSAGE("NODE -> ID = " << nodeId << " X = " << nodeX << " Y = " << nodeY << " Z = " << nodeZ);
+ }
+
+ SCRUTE(index);
+ }
+
+ SCRUTE(NbTotOfNodesVertices);
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute --> Analysis of all shell mesh");
+
+ vector<SMESH_subMesh*> meshShells;
+ TopoDS_Shell aShell;
+
+ for (TopExp_Explorer exp(aShape,TopAbs_SHELL);exp.More();exp.Next())
+ {
+ SMESH_subMesh* aSubMesh = aMesh.GetSubMesh(exp.Current());
+ ASSERT(aSubMesh);
+ SCRUTE(aSubMesh);
+ aShell = TopoDS::Shell(exp.Current());
+ meshShells.push_back(aSubMesh);
+ }
+
+ int numberOfShells = meshShells.size();
+ SCRUTE(numberOfShells);
+
+ if (numberOfShells == 1)
+ {
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute Only one shell --> generation of the mesh using directly Netgen");
+
+ /*
+ Prepare the Netgen surface mesh from the SMESHDS
+ */
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute Prepare the Netgen surface mesh from the SMESHDS");
+
+ int spaceDimension = 3;
+ int nbNodesByTri = 3;
+ int nbNodesByTetra = 4;
+
+ int Netgen_NbOfNodes = NbTotOfNodesFaces +
+ NbTotOfNodesEdges +
+ NbTotOfNodesVertices;
+ int Netgen_NbOfTria = NbTotOfTria;
+ int Netgen_param2ndOrder = 0;
+ double Netgen_paramFine = 1.;
+ double Netgen_paramSize = _maxElementVolume;
+
+ SCRUTE(Netgen_NbOfNodes);
+ SCRUTE(Netgen_NbOfTria);
+
+ double * Netgen_Coordinates = new double [spaceDimension*
+ Netgen_NbOfNodes];
+ int * listNodeCoresNetgenSmesh = new int [Netgen_NbOfNodes];
+ int * Netgen_Connectivity = new int [nbNodesByTri*Netgen_NbOfTria];
+ double * Netgen_point = new double [spaceDimension];
+ int * Netgen_triangle = new int [nbNodesByTri];
+ int * Netgen_tetrahedron = new int [nbNodesByTetra];
+
+ for (int i=0; i<Netgen_NbOfTria; i++)
+ {
+ for (int j=0; j<nbNodesByTri; j++)
+ Netgen_Connectivity[i*nbNodesByTri+j] = 0;
+ }
+
+ double bigNumber = 1.e20;
+
+ for (int i=0; i<Netgen_NbOfNodes; i++)
+ {
+ listNodeCoresNetgenSmesh[i] = 0;
+ for (int j=0; j<spaceDimension; j++)
+ Netgen_Coordinates[i*spaceDimension+j] = bigNumber;
+ }
+
+ int indexNodes = 0;
+ for (int i=0; i<numberOfVertices; i++)
+ {
+ const SMESHDS_SubMesh * aSubMeshDSVertex =
+ meshVertices[i]->GetSubMeshDS();
+
+ SMDS_NodeIteratorPtr iteratorNodes = aSubMeshDSVertex->GetNodes();
+
+ while(iteratorNodes->more())
+ {
+ const SMDS_MeshNode * node = iteratorNodes->next();
+ int nodeId = node->GetID();
+ double nodeX = node->X();
+ double nodeY = node->Y();
+ double nodeZ = node->Z();
+// MESSAGE("NODE -> ID = " << nodeId << " X = " << nodeX << " Y = " << nodeY << " Z = " << nodeZ);
+ listNodeCoresNetgenSmesh[indexNodes] = nodeId;
+ int index = indexNodes*spaceDimension;
+ Netgen_Coordinates[index] = nodeX;
+ Netgen_Coordinates[index+1] = nodeY;
+ Netgen_Coordinates[index+2] = nodeZ;
+ netgenToDS[indexNodes] = node;
+ indexNodes++;
+ }
+ }
+
+ for (int i=0; i<numberOfEdges; i++)
+ {
+ const SMESHDS_SubMesh * aSubMeshDSEdge =
+ meshEdges[i]->GetSubMeshDS();
+
+ SMDS_NodeIteratorPtr iteratorNodes = aSubMeshDSEdge->GetNodes();
+
+ while(iteratorNodes->more())
+ {
+ const SMDS_MeshNode * node = iteratorNodes->next();
+ int nodeId = node->GetID();
+ double nodeX = node->X();
+ double nodeY = node->Y();
+ double nodeZ = node->Z();
+// MESSAGE("NODE -> ID = " << nodeId << " X = " << nodeX << " Y = " << nodeY << " Z = " << nodeZ);
+ listNodeCoresNetgenSmesh[indexNodes] = node->GetID();
+ int index = indexNodes*spaceDimension;
+ Netgen_Coordinates[index] = node->X();
+ Netgen_Coordinates[index+1] = node->Y();
+ Netgen_Coordinates[index+2] = node->Z();
+ netgenToDS[indexNodes] = node;
+ indexNodes++;
+ }
+ }
+
+ for (int i=0; i<numberOfFaces; i++)
+ {
+ const SMESHDS_SubMesh * aSubMeshDSFace =
+ meshFaces[i]->GetSubMeshDS();
+
+ SMDS_NodeIteratorPtr iteratorNodes = aSubMeshDSFace->GetNodes();
+
+ while(iteratorNodes->more())
+ {
+ const SMDS_MeshNode * node = iteratorNodes->next();
+ int nodeId = node->GetID();
+ double nodeX = node->X();
+ double nodeY = node->Y();
+ double nodeZ = node->Z();
+// MESSAGE("NODE -> ID = " << nodeId << " X = " << nodeX << " Y = " << nodeY << " Z = " << nodeZ);
+ listNodeCoresNetgenSmesh[indexNodes] = nodeId;
+ int index = indexNodes*spaceDimension;
+ Netgen_Coordinates[index] = nodeX;
+ Netgen_Coordinates[index+1] = nodeY;
+ Netgen_Coordinates[index+2] = nodeZ;
+ netgenToDS[indexNodes] = node;
+ indexNodes++;
+ }
+ }
+
+ SCRUTE(indexNodes);
+
+ for (int i=0; i<Netgen_NbOfNodes; i++)
+ {
+ ASSERT(listNodeCoresNetgenSmesh[i] != 0);
+
+ for (int j=0; j<Netgen_NbOfNodes && j!=i; j++)
+ ASSERT(listNodeCoresNetgenSmesh[i] != listNodeCoresNetgenSmesh[j]);
+
+ for (int j=0; j<spaceDimension; j++)
+ ASSERT(Netgen_Coordinates[i*spaceDimension+j] != bigNumber);
+ }
+
+ int indexTrias = 0;
+ for (int i=0; i<numberOfFaces; i++)
+ {
+ const SMESHDS_SubMesh * aSubMeshDSFace =
+ meshFaces[i]->GetSubMeshDS();
+
+ TopoDS_Shape aFace = shapeFaces[i];
+
+ SMDS_ElemIteratorPtr iteratorTriangle = aSubMeshDSFace->GetElements();
+
+ TopoDS_Shape aShapeFace = meshFaces[i]->GetSubShape();
+
+ bool orientationMeshFace = (aFace.Orientation() == aShapeFace.Orientation());
+
+ SCRUTE(orientationMeshFace);
+
+ if (orientationMeshFace)
+ {
+ MESSAGE("The mesh and face have the same orientation");
+
+ while(iteratorTriangle->more())
+ {
+ const SMDS_MeshElement * triangle = iteratorTriangle->next();
+ int triangleId = triangle->GetID();
+
+ SMDS_ElemIteratorPtr triangleNodesIt = triangle->nodesIterator();
+
+ int triangleNode1 = (triangleNodesIt->next())->GetID();
+ int triangleNode2 = (triangleNodesIt->next())->GetID();
+ int triangleNode3 = (triangleNodesIt->next())->GetID();
+
+// MESSAGE("TRIANGLE -> ID = " << triangleId << " N1 = " << triangleNode1 << " N2 = " << triangleNode2 << " N3 = " << triangleNode3);
+
+ int N1New = 0;
+ int N2New = 0;
+ int N3New = 0;
+ int index = indexTrias*nbNodesByTri;
+
+ for (int j=0; j<Netgen_NbOfNodes; j++)
+ {
+ int jp1 = j+1;
+
+ if (triangleNode1 == listNodeCoresNetgenSmesh[j])
+ N1New = jp1;
+ else if (triangleNode2 == listNodeCoresNetgenSmesh[j])
+ N2New = jp1;
+ else if (triangleNode3 == listNodeCoresNetgenSmesh[j])
+ N3New = jp1;
+ }
+
+ triangleNode1 = N1New;
+ triangleNode2 = N2New;
+ triangleNode3 = N3New;
+
+ Netgen_Connectivity[index] = triangleNode1;
+ Netgen_Connectivity[index+1] = triangleNode2;
+ Netgen_Connectivity[index+2] = triangleNode3;
+
+ indexTrias++;
+ }
+ }
+ else
+ {
+ MESSAGE("The mesh and face have different orientations");
+
+ while(iteratorTriangle->more())
+ {
+ const SMDS_MeshElement * triangle = iteratorTriangle->next();
+ int triangleId = triangle->GetID();
+
+ SMDS_ElemIteratorPtr triangleNodesIt = triangle->nodesIterator();
+
+ int triangleNode1 = (triangleNodesIt->next())->GetID();
+ int triangleNode3 = (triangleNodesIt->next())->GetID();
+ int triangleNode2 = (triangleNodesIt->next())->GetID();
+
+// MESSAGE("TRIANGLE -> ID = " << triangleId << " N1 = " << triangleNode1 << " N2 = " << triangleNode2 << " N3 = " << triangleNode3);
+
+ int N1New = 0;
+ int N2New = 0;
+ int N3New = 0;
+ int index = indexTrias*nbNodesByTri;
+
+ for (int j=0; j<Netgen_NbOfNodes; j++)
+ {
+ int jp1 = j+1;
+
+ if (triangleNode1 == listNodeCoresNetgenSmesh[j])
+ N1New = jp1;
+ else if (triangleNode2 == listNodeCoresNetgenSmesh[j])
+ N2New = jp1;
+ else if (triangleNode3 == listNodeCoresNetgenSmesh[j])
+ N3New = jp1;
+ }
+
+ triangleNode1 = N1New;
+ triangleNode2 = N2New;
+ triangleNode3 = N3New;
+
+ Netgen_Connectivity[index] = triangleNode1;
+ Netgen_Connectivity[index+1] = triangleNode2;
+ Netgen_Connectivity[index+2] = triangleNode3;
+
+ indexTrias++;
+ }
+ }
+ }
+
+ SCRUTE(indexTrias);
+
+ int * nodesUsed = new int[Netgen_NbOfNodes];
+
+ for (int i=0; i<Netgen_NbOfNodes; i++) nodesUsed[i] = 0;
+
+ for (int i=0; i<Netgen_NbOfTria; i++)
+ for (int j=0; j<nbNodesByTri; j++)
+ {
+ int Nij = Netgen_Connectivity[i*nbNodesByTri+j];
+
+ ASSERT((Nij>=1) && (Nij<=Netgen_NbOfNodes));
+
+ nodesUsed[Nij-1] = 1;
+ Netgen_Connectivity[i*nbNodesByTri+j] = Nij;
+ }
+
+ for (int i=0; i<Netgen_NbOfNodes; i++)
+ {
+ ASSERT(nodesUsed[i] != 0);
+ }
+
+ delete [] nodesUsed;
+
+ /*
+ Feed the Netgen surface mesh
+ */
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute Feed the Netgen surface mesh");
+
+ Ng_Mesh * Netgen_mesh;
+
+ Ng_Init();
+
+ Netgen_mesh = Ng_NewMesh();
+
+ Ng_Meshing_Parameters Netgen_param;
+
+ for (int i=0; i<Netgen_NbOfNodes; i++)
+ {
+ for (int j=0; j<spaceDimension; j++)
+ Netgen_point[j] = Netgen_Coordinates[i*spaceDimension+j];
+
+ Ng_AddPoint(Netgen_mesh, Netgen_point);
+ }
+
+ for (int i=0; i<Netgen_NbOfTria; i++)
+ {
+ for (int j=0; j<nbNodesByTri; j++)
+ Netgen_triangle[j] = Netgen_Connectivity[i*nbNodesByTri+j];
+
+ Ng_AddSurfaceElement(Netgen_mesh, NG_TRIG, Netgen_triangle);
+ }
+
+ SCRUTE(Netgen_paramSize);
+
+ Netgen_param.secondorder = Netgen_param2ndOrder;
+ Netgen_param.fineness = Netgen_paramFine;
+ Netgen_param.maxh = Netgen_paramSize;
+
+ /*
+ Generate the volume mesh
+ */
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute Generate the volume mesh");
+
+ SCRUTE(Netgen_NbOfNodes);
+ SCRUTE(Netgen_NbOfTria);
+
+ SCRUTE(Ng_GetNP(Netgen_mesh));
+ SCRUTE(Ng_GetNE(Netgen_mesh));
+ SCRUTE(Ng_GetNSE(Netgen_mesh));
+
+ ASSERT(Netgen_NbOfNodes == Ng_GetNP(Netgen_mesh));
+ ASSERT(Ng_GetNE(Netgen_mesh) == 0);
+ ASSERT(Netgen_NbOfTria == Ng_GetNSE(Netgen_mesh));
+
+ Ng_Result status;
+
+ status = Ng_GenerateVolumeMesh(Netgen_mesh, &Netgen_param);
+
+ SCRUTE(status);
+
+ int Netgen_NbOfNodesNew = Ng_GetNP(Netgen_mesh);
+
+ int Netgen_NbOfTetra = Ng_GetNE(Netgen_mesh);
+
+ SCRUTE(Netgen_NbOfNodesNew);
+
+ SCRUTE(Netgen_NbOfTetra);
+
+ if ((status != NG_OK) ||
+ (Netgen_NbOfNodesNew <= Netgen_NbOfNodes) ||
+ (Netgen_NbOfTetra <= 0))
+ {
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute The Volume Mesh Generation has failed ...");
+ SCRUTE(status);
+
+ /*
+ Free the memory needed by to generate the Netgen Mesh
+ */
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute Free the memory needed by to generate the Netgen Mesh");
+
+ delete [] Netgen_Coordinates;
+ delete [] Netgen_Connectivity;
+ delete [] Netgen_point;
+ delete [] Netgen_triangle;
+ delete [] Netgen_tetrahedron;
+
+ delete [] listNodeCoresNetgenSmesh;
+
+ Ng_DeleteMesh(Netgen_mesh);
+ Ng_Exit();
+
+ return false;
+ }
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute End of Volume Mesh Generation");
+ SCRUTE(status);
+
+ double * Netgen_CoordinatesNew = new double [spaceDimension*Netgen_NbOfNodesNew];
+ int * Netgen_ConnectivityNew = new int [nbNodesByTetra*Netgen_NbOfTetra];
+
+ for (int i=0; i<Netgen_NbOfNodesNew; i++)
+ {
+ Ng_GetPoint(Netgen_mesh, (i+1), Netgen_point);
+
+ for (int j=0; j<spaceDimension; j++)
+ Netgen_CoordinatesNew[i*spaceDimension+j] = Netgen_point[j];
+ }
+
+ for (int i=0; i<Netgen_NbOfNodes; i++)
+ for (int j=0; j<spaceDimension; j++)
+ ASSERT(Netgen_CoordinatesNew[i*spaceDimension+j] == Netgen_Coordinates[i*spaceDimension+j])
+
+ for (int i=0; i<Netgen_NbOfTetra; i++)
+ {
+ Ng_GetVolumeElement(Netgen_mesh, (i+1), Netgen_tetrahedron);
+
+ for (int j=0; j<nbNodesByTetra; j++)
+ Netgen_ConnectivityNew[i*nbNodesByTetra+j] = Netgen_tetrahedron[j];
+ }
+
+ /*
+ Feed back the SMESHDS with the generated Nodes and Volume Elements
+ */
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute Feed back the SMESHDS with the generated Nodes and Volume Elements");
+
+ int NbTotOfNodesShell = Netgen_NbOfNodesNew - Netgen_NbOfNodes;
+
+ SCRUTE(NbTotOfNodesShell);
+
+ int * listNodeShellCoresNetgenSmesh = new int [NbTotOfNodesShell];
+
+ for (int i=0; i<NbTotOfNodesShell; i++)
+ listNodeShellCoresNetgenSmesh[i] = 0;
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute --> Adding the New Nodes to SMESHDS");
+
+ for (int i=0; i<NbTotOfNodesShell; i++)
+ {
+ int index = (i+Netgen_NbOfNodes)*spaceDimension;
+
+ SMDS_MeshNode * node =
+ meshDS->AddNode(Netgen_CoordinatesNew[index],
+ Netgen_CoordinatesNew[index+1],
+ Netgen_CoordinatesNew[index+2]);
+
+ meshDS->SetNodeInVolume(node, aShell);
+
+ index = i+Netgen_NbOfNodes;
+ netgenToDS[index] = node;
+
+ listNodeShellCoresNetgenSmesh[i] = node->GetID();
+ }
+
+ SCRUTE(Netgen_NbOfNodesNew);
+
+ SCRUTE(netgenToDS.size());
+
+ for (int i=0; i<NbTotOfNodesShell; i++)
+ {
+ ASSERT(listNodeShellCoresNetgenSmesh[i] != 0);
+
+ for (int j=0; j<NbTotOfNodesShell && j!=i; j++)
+ ASSERT(listNodeShellCoresNetgenSmesh[i] != listNodeShellCoresNetgenSmesh[j]);
+ }
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute --> Adding the New elements (Tetrahedrons) to the SMESHDS");
+
+ for (int i=0; i<Netgen_NbOfTetra; i++)
+ {
+ int index = i*nbNodesByTetra;
+ int tetraNode1 = Netgen_ConnectivityNew[index];
+ int tetraNode2 = Netgen_ConnectivityNew[index+1];
+ int tetraNode3 = Netgen_ConnectivityNew[index+2];
+ int tetraNode4 = Netgen_ConnectivityNew[index+3];
+
+ const SMDS_MeshNode * node1 = netgenToDS[tetraNode1-1];
+ const SMDS_MeshNode * node2 = netgenToDS[tetraNode2-1];
+ const SMDS_MeshNode * node3 = netgenToDS[tetraNode3-1];
+ const SMDS_MeshNode * node4 = netgenToDS[tetraNode4-1];
+
+ index = tetraNode1;
+ if (index <= Netgen_NbOfNodes)
+ tetraNode1 = listNodeCoresNetgenSmesh[index-1];
+ else
+ tetraNode1 = listNodeShellCoresNetgenSmesh[index-Netgen_NbOfNodes-1];
+
+ index = tetraNode2;
+ if (index <= Netgen_NbOfNodes)
+ tetraNode2 = listNodeCoresNetgenSmesh[index-1];
+ else
+ tetraNode2 = listNodeShellCoresNetgenSmesh[index-Netgen_NbOfNodes-1];
+
+ index = tetraNode3;
+ if (index <= Netgen_NbOfNodes)
+ tetraNode3 = listNodeCoresNetgenSmesh[index-1];
+ else
+ tetraNode3 = listNodeShellCoresNetgenSmesh[index-Netgen_NbOfNodes-1];
+
+ index = tetraNode4;
+ if (index <= Netgen_NbOfNodes)
+ tetraNode4 = listNodeCoresNetgenSmesh[index-1];
+ else
+ tetraNode4 = listNodeShellCoresNetgenSmesh[index-Netgen_NbOfNodes-1];
+
+ SMDS_MeshVolume * elt =
+ meshDS->AddVolume(node1,node2,node3,node4);
+
+ meshDS->SetMeshElementOnShape(elt, aShell);
+ }
+
+ /*
+ Free the memory needed by to generate the Netgen Mesh
+ */
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute Free the memory needed by to generate the Netgen Mesh");
+
+ delete [] Netgen_Coordinates;
+ delete [] Netgen_Connectivity;
+ delete [] Netgen_CoordinatesNew;
+ delete [] Netgen_ConnectivityNew;
+ delete [] Netgen_point;
+ delete [] Netgen_triangle;
+ delete [] Netgen_tetrahedron;
+
+ delete [] listNodeCoresNetgenSmesh;
+ delete [] listNodeShellCoresNetgenSmesh;
+
+ Ng_DeleteMesh(Netgen_mesh);
+ Ng_Exit();
+
+ /*
+ Verification
+ */
+
+ {
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute Verification of the Shell mesh");
+
+ TopoDS_Shape aShapeShell = meshShells[0]->GetSubShape();
+ SMESH_Algo* algoShell = _gen->GetAlgo(aMesh, aShapeShell);
+ string algoShellName = algoShell->GetName();
+ SCRUTE(algoShellName);
+ if (algoShellName != "NETGEN_3D")
+ {
+ SCRUTE(algoShellName);
+ ASSERT(0);
+ return false;
+ }
+
+ const SMESHDS_SubMesh * aSubMeshDSShell = meshShells[0]->GetSubMeshDS();
+ SCRUTE(&aSubMeshDSShell);
+
+ int nbNodes = aSubMeshDSShell->NbNodes();
+ int nbTetra = aSubMeshDSShell->NbElements();
+
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute The mesh Shell has " << nbNodes << " shell internal Nodes, " << nbTetra << " tetrahedrons");
+
+ SMDS_NodeIteratorPtr iteratorNodes = aSubMeshDSShell->GetNodes();
+
+ SCRUTE(nbNodes);
+
+ int index;
+
+ index = 0;
+
+ while(iteratorNodes->more())
+ {
+ index++;
+ const SMDS_MeshNode * node = iteratorNodes->next();
+ int nodeId = node->GetID();
+ double nodeX = node->X();
+ double nodeY = node->Y();
+ double nodeZ = node->Z();
+// MESSAGE("NODE -> ID = " << nodeId << " X = " << nodeX << " Y = " << nodeY << " Z = " << nodeZ);
+ }
+
+ SCRUTE(index);
+
+ SMDS_ElemIteratorPtr iteratorTetra = aSubMeshDSShell->GetElements();
+
+ SCRUTE(nbTetra);
+
+ index = 0;
+ while(iteratorTetra->more())
+ {
+ index++;
+ const SMDS_MeshElement * tetra = iteratorTetra->next();
+ int tetraId = tetra->GetID();
+
+ SMDS_ElemIteratorPtr tetraNodesIt = tetra->nodesIterator();
+
+ int tetraNode1 = (tetraNodesIt->next())->GetID();
+ int tetraNode2 = (tetraNodesIt->next())->GetID();
+ int tetraNode3 = (tetraNodesIt->next())->GetID();
+ int tetraNode4 = (tetraNodesIt->next())->GetID();
+
+// MESSAGE("TETRAHEDRON -> ID = " << tetraId << " N1 = " << tetraNode1 << " N2 = " << tetraNode2 << " N3 = " << tetraNode3 << " N4 = " << tetraNode4);
+
+ }
+
+ SCRUTE(index);
+ }
+ }
+ else
+ {
+ SCRUTE(numberOfShells);
+ MESSAGE("NETGENPlugin_NETGEN_3D::Compute ERROR More than one shell ????? ");
+ return false;
+ }
+
+ return true;
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & NETGENPlugin_NETGEN_3D::SaveTo(ostream & save)
+{
+ return save;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & NETGENPlugin_NETGEN_3D::LoadFrom(istream & load)
+{
+ return load;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & operator << (ostream & save, NETGENPlugin_NETGEN_3D & hyp)
+{
+ return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & operator >> (istream & load, NETGENPlugin_NETGEN_3D & hyp)
+{
+ return hyp.LoadFrom( load );
+}
--- /dev/null
+//=============================================================================
+// File : NETGENPlugin_NETGEN_3D.hxx
+// Moved here from SMESH_NETGEN_3D.hxx
+// Created : lundi 27 Janvier 2003
+// Author : Nadir BOUHAMOU (CEA)
+// Project : SALOME
+// Copyright : CEA 2003
+// $Header$
+//=============================================================================
+
+#ifndef _NETGENPlugin_NETGEN_3D_HXX_
+#define _NETGENPlugin_NETGEN_3D_HXX_
+
+#include "SMESH_3D_Algo.hxx"
+#include "SMESH_Mesh.hxx"
+#include "StdMeshers_MaxElementVolume.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+class NETGENPlugin_NETGEN_3D: public SMESH_3D_Algo
+{
+public:
+ NETGENPlugin_NETGEN_3D(int hypId, int studyId, SMESH_Gen* gen);
+ virtual ~NETGENPlugin_NETGEN_3D();
+
+ virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ SMESH_Hypothesis::Hypothesis_Status& aStatus);
+
+ virtual bool Compute(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape);
+
+ ostream & SaveTo(ostream & save);
+ istream & LoadFrom(istream & load);
+ friend ostream & operator << (ostream & save, NETGENPlugin_NETGEN_3D & hyp);
+ friend istream & operator >> (istream & load, NETGENPlugin_NETGEN_3D & hyp);
+
+protected:
+ double _maxElementVolume;
+
+ const StdMeshers_MaxElementVolume* _hypMaxElementVolume;
+};
+
+#endif
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : NETGENPlugin_NETGEN_3D_i.cxx
+// Moved here from SMESH_NETGEN_3D_i.cxx
+// Author : Nadir Bouhamou CEA
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "NETGENPlugin_NETGEN_3D_i.hxx"
+#include "SMESH_Gen.hxx"
+
+#include "Utils_CorbaException.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ * NETGENPlugin_NETGEN_3D_i::NETGENPlugin_NETGEN_3D_i
+ *
+ * Constructor
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_3D_i::NETGENPlugin_NETGEN_3D_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl )
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA ),
+ SMESH_Algo_i( thePOA ),
+ SMESH_3D_Algo_i( thePOA )
+{
+ MESSAGE( "NETGENPlugin_NETGEN_3D_i::NETGENPlugin_NETGEN_3D_i" );
+ myBaseImpl = new ::NETGENPlugin_NETGEN_3D( theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl );
+}
+
+//=============================================================================
+/*!
+ * NETGENPlugin_NETGEN_3D_i::~NETGENPlugin_NETGEN_3D_i
+ *
+ * Destructor
+ */
+//=============================================================================
+
+NETGENPlugin_NETGEN_3D_i::~NETGENPlugin_NETGEN_3D_i()
+{
+ MESSAGE( "NETGENPlugin_NETGEN_3D_i::~NETGENPlugin_NETGEN_3D_i" );
+}
+
+//=============================================================================
+/*!
+ * NETGENPlugin_NETGEN_3D_i::GetImpl
+ *
+ * Get implementation
+ */
+//=============================================================================
+
+::NETGENPlugin_NETGEN_3D* NETGENPlugin_NETGEN_3D_i::GetImpl()
+{
+ MESSAGE( "NETGENPlugin_NETGEN_3D_i::GetImpl" );
+ return ( ::NETGENPlugin_NETGEN_3D* )myBaseImpl;
+}
+
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : NETGENPlugin_NETGEN_3D_i.hxx
+// Moved here from SMESH_NETGEN_3D_i.hxx
+// Author : Nadir Bouhamou CEA
+// Module : SMESH
+// $Header$
+
+#ifndef _NETGENPlugin_NETGEN_3D_I_HXX_
+#define _NETGENPlugin_NETGEN_3D_I_HXX_
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_NetgenAlgorithm)
+
+#include "SMESH_3D_Algo_i.hxx"
+#include "NETGENPlugin_NETGEN_3D.hxx"
+
+// ======================================================
+// NETGEN 3d algorithm
+// ======================================================
+class NETGENPlugin_NETGEN_3D_i:
+ public virtual POA_NETGENPlugin::NETGENPlugin_NETGEN_3D,
+ public virtual SMESH_3D_Algo_i
+{
+public:
+ // Constructor
+ NETGENPlugin_NETGEN_3D_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl );
+ // Destructor
+ virtual ~NETGENPlugin_NETGEN_3D_i();
+
+ // Get implementation
+ ::NETGENPlugin_NETGEN_3D* GetImpl();
+};
+
+#endif
--- /dev/null
+// SMESH NETGENPlugin : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : NETGENPlugin.cxx
+// Author : Julia DOROVSKIKH
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "SMESH_Hypothesis_i.hxx"
+#include "SMESH_Gen_i.hxx"
+
+#include "utilities.h"
+
+#include "NETGENPlugin_NETGEN_3D_i.hxx"
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+extern "C"
+{
+ GenericHypothesisCreator_i* GetHypothesisCreator (const char* aHypName)
+ {
+ MESSAGE("GetHypothesisCreator " << aHypName);
+
+ GenericHypothesisCreator_i* aCreator = 0;
+
+ // Hypotheses
+
+ // Algorithms
+ if (strcmp(aHypName, "NETGEN_3D") == 0)
+ aCreator = new HypothesisCreator_i<NETGENPlugin_NETGEN_3D_i>;
+ else ;
+
+ return aCreator;
+ }
+}
--- /dev/null
+# This is a Qt message file in .po format. Each msgid starts with
+# a scope. This scope should *NOT* be translated - eg. "Foo::Bar"
+# would be translated to "Pub", not "Foo::Pub".
+msgid ""
+msgstr ""
+"Project-Id-Version: PROJECT VERSION\n"
+"POT-Creation-Date: 2002-05-28 10:57:43 AM CEST\n"
+"PO-Revision-Date: YYYY-MM-DD\n"
+"Last-Translator: FULLNAME <EMAIL@ADDRESS>\n"
+"Content-Type: text/plain; charset=iso-8859-1\n"
+
+
+#-----------------------------------------------------------
+# ObjectBrowser
+#-----------------------------------------------------------
+
+#mesh_tree_algo_netgen
+msgid "ICON_SMESH_TREE_ALGO_NETGEN_3D"
+msgstr "mesh_tree_algo_tetra.png"
+#msgstr "mesh_tree_algo_netgen.png"
--- /dev/null
+// SMESH OBJECT : interactive object for SMESH visualization
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_Actor.cxx
+// Author : Nicolas REJNERI
+// Module : SMESH
+// $Header$
+
+
+#include "SMESH_DeviceActor.h"
+
+#include "SALOME_Transform.h"
+#include "SALOME_TransformFilter.h"
+#include "SALOME_PassThroughFilter.h"
+#include "SALOME_ExtractUnstructuredGrid.h"
+
+#include "utilities.h"
+
+// VTK Includes
+#include <vtkObjectFactory.h>
+#include <vtkShrinkFilter.h>
+#include <vtkShrinkPolyData.h>
+
+#include <vtkProperty.h>
+#include <vtkPolyData.h>
+#include <vtkMergeFilter.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkUnstructuredGrid.h>
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#else
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#endif
+
+using namespace std;
+
+
+vtkStandardNewMacro(SMESH_DeviceActor);
+
+
+SMESH_DeviceActor::SMESH_DeviceActor(){
+ if(MYDEBUG) MESSAGE("SMESH_DeviceActor");
+ myIsShrunk = false;
+ myIsShrinkable = false;
+ myRepresentation = eSurface;
+
+ myProperty = vtkProperty::New();
+ myMapper = vtkPolyDataMapper::New();
+
+ vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(myPolygonOffsetFactor,
+ myPolygonOffsetUnits);
+ //myMapper->SetResolveCoincidentTopologyToShiftZBuffer();
+ //myMapper->SetResolveCoincidentTopologyZShift(0.02);
+
+ myMapper->UseLookupTableScalarRangeOn();
+ myMapper->SetColorModeToMapScalars();
+
+ myShrinkFilter = vtkShrinkFilter::New();
+
+ myExtractUnstructuredGrid = SALOME_ExtractUnstructuredGrid::New();
+ myExtractUnstructuredGrid->SetStoreMapping(true);
+
+ myMergeFilter = vtkMergeFilter::New();
+
+ myStoreMapping = false;
+ myGeomFilter = SALOME_GeometryFilter::New();
+
+ myTransformFilter = SALOME_TransformFilter::New();
+
+ for(int i = 0; i < 6; i++)
+ myPassFilter.push_back(SALOME_PassThroughFilter::New());
+}
+
+
+SMESH_DeviceActor::~SMESH_DeviceActor(){
+ if(MYDEBUG) MESSAGE("~SMESH_DeviceActor");
+ myProperty->Delete();
+
+ myMapper->RemoveAllInputs();
+ myMapper->Delete();
+
+ myShrinkFilter->UnRegisterAllOutputs();
+ myShrinkFilter->Delete();
+
+ myExtractUnstructuredGrid->UnRegisterAllOutputs();
+ myExtractUnstructuredGrid->Delete();
+
+ myMergeFilter->UnRegisterAllOutputs();
+ myMergeFilter->Delete();
+
+ myGeomFilter->UnRegisterAllOutputs();
+ myGeomFilter->Delete();
+
+ myTransformFilter->UnRegisterAllOutputs();
+ myTransformFilter->Delete();
+
+ for(int i = 0, iEnd = myPassFilter.size(); i < iEnd; i++){
+ myPassFilter[i]->UnRegisterAllOutputs();
+ myPassFilter[i]->Delete();
+ }
+}
+
+
+void SMESH_DeviceActor::SetStoreMapping(int theStoreMapping){
+ myStoreMapping = theStoreMapping;
+ Modified();
+}
+
+
+void SMESH_DeviceActor::SetUnstructuredGrid(vtkUnstructuredGrid* theGrid){
+ if(theGrid){
+ //myIsShrinkable = theGrid->GetNumberOfCells() > 10;
+ myIsShrinkable = true;
+
+ myExtractUnstructuredGrid->SetInput(theGrid);
+ myMergeFilter->SetGeometry(myExtractUnstructuredGrid->GetOutput());
+
+ theGrid = static_cast<vtkUnstructuredGrid*>(myMergeFilter->GetOutput());
+
+ int anId = 0;
+ myPassFilter.at( anId )->SetInput( theGrid );
+ myPassFilter.at( anId + 1)->SetInput( myPassFilter.at( anId )->GetOutput() );
+
+ anId++; // 1
+ myGeomFilter->SetStoreMapping( myStoreMapping );
+ myGeomFilter->SetInput( myPassFilter.at( anId )->GetOutput() );
+
+ anId++; // 2
+ myPassFilter.at( anId )->SetInput( myGeomFilter->GetOutput() );
+ myPassFilter.at( anId + 1 )->SetInput( myPassFilter.at( anId )->GetOutput() );
+
+ anId++; // 3
+ myTransformFilter->SetInput( myPassFilter.at( anId )->GetPolyDataOutput() );
+
+ anId++; // 4
+ myPassFilter.at( anId )->SetInput( myTransformFilter->GetOutput() );
+ myPassFilter.at( anId + 1 )->SetInput( myPassFilter.at( anId )->GetOutput() );
+
+ anId++; // 5
+ myMapper->SetInput( myPassFilter.at( anId )->GetPolyDataOutput() );
+
+ vtkLODActor::SetMapper( myMapper );
+ Modified();
+ }
+}
+
+
+SALOME_ExtractUnstructuredGrid* SMESH_DeviceActor::GetExtractUnstructuredGrid(){
+ return myExtractUnstructuredGrid;
+}
+
+
+vtkUnstructuredGrid* SMESH_DeviceActor::GetUnstructuredGrid(){
+ myExtractUnstructuredGrid->Update();
+ return myExtractUnstructuredGrid->GetOutput();
+}
+
+
+vtkMergeFilter* SMESH_DeviceActor::GetMergeFilter(){
+ return myMergeFilter;
+}
+
+
+vtkPolyData* SMESH_DeviceActor::GetPolyDataInput(){
+ return myPassFilter.back()->GetPolyDataOutput();
+}
+
+
+unsigned long int SMESH_DeviceActor::GetMTime(){
+ unsigned long mTime = this->Superclass::GetMTime();
+ mTime = max(mTime,myExtractUnstructuredGrid->GetMTime());
+ mTime = max(mTime,myMergeFilter->GetMTime());
+ mTime = max(mTime,myGeomFilter->GetMTime());
+ mTime = max(mTime,myTransformFilter->GetMTime());
+ return mTime;
+}
+
+
+void SMESH_DeviceActor::SetTransform(SALOME_Transform* theTransform){
+ myTransformFilter->SetTransform(theTransform);
+}
+
+
+void SMESH_DeviceActor::SetShrink()
+{
+ if ( !myIsShrinkable ) return;
+ if ( vtkDataSet* aDataSet = myPassFilter.at( 0 )->GetOutput() )
+ {
+ myShrinkFilter->SetInput( aDataSet );
+ myPassFilter.at( 1 )->SetInput( myShrinkFilter->GetOutput() );
+ myIsShrunk = true;
+ }
+}
+
+void SMESH_DeviceActor::UnShrink()
+{
+ if ( !myIsShrunk ) return;
+ if ( vtkDataSet* aDataSet = myPassFilter.at( 0 )->GetOutput() )
+ {
+ myPassFilter.at( 1 )->SetInput( aDataSet );
+ myPassFilter.at( 1 )->Modified();
+ myIsShrunk = false;
+ Modified();
+ }
+}
+
+
+void SMESH_DeviceActor::SetRepresentation(EReperesent theMode){
+ switch(theMode){
+ case ePoint:
+ myGeomFilter->SetInside(true);
+ GetProperty()->SetRepresentation(0);
+ break;
+ case eInsideframe:
+ myGeomFilter->SetInside(true);
+ GetProperty()->SetRepresentation(1);
+ break;
+ default :
+ GetProperty()->SetRepresentation(theMode);
+ myGeomFilter->SetInside(false);
+ }
+ myRepresentation = theMode;
+ myMapper->Modified();
+ Modified();
+}
+
+
+void SMESH_DeviceActor::SetVisibility(int theMode){
+ if(!myExtractUnstructuredGrid->GetInput() || GetUnstructuredGrid()->GetNumberOfCells()){
+ vtkLODActor::SetVisibility(theMode);
+ }else{
+ vtkLODActor::SetVisibility(false);
+ }
+}
+
+
+int SMESH_DeviceActor::GetVisibility(){
+ if(!GetUnstructuredGrid()->GetNumberOfCells()){
+ vtkLODActor::SetVisibility(false);
+ }
+ return vtkLODActor::GetVisibility();
+}
+
+
+int SMESH_DeviceActor::GetObjId(int theVtkID){
+ if (GetRepresentation() == ePoint){
+ return GetNodeObjId(theVtkID);
+ }else{
+ return GetElemObjId(theVtkID);
+ }
+}
+
+
+SMESH_DeviceActor::TVectorId SMESH_DeviceActor::GetVtkId(int theObjID){
+ if (GetRepresentation() == ePoint){
+ return GetNodeVtkId(theObjID);
+ }else{
+ return GetElemVtkId(theObjID);
+ }
+}
+
+
+int SMESH_DeviceActor::GetNodeObjId(int theVtkID){
+ vtkIdType aRetID = myVisualObj->GetNodeObjId(theVtkID);
+ if(MYDEBUG) MESSAGE("GetNodeObjId - theVtkID = "<<theVtkID<<"; aRetID = "<<aRetID);
+ return aRetID;
+}
+
+SMESH_DeviceActor::TVectorId SMESH_DeviceActor::GetNodeVtkId(int theObjID){
+ SMESH_DeviceActor::TVectorId aVecId;
+ vtkIdType anID = myVisualObj->GetNodeVTKId(theObjID);
+ if(anID < 0)
+ return aVecId;
+ aVecId.push_back(anID);
+ return aVecId;
+}
+
+
+int SMESH_DeviceActor::GetElemObjId(int theVtkID){
+ vtkIdType aGridID = myGeomFilter->GetObjId(theVtkID);
+ if(aGridID < 0)
+ return -1;
+ vtkIdType anExtractID = myExtractUnstructuredGrid->GetOutId(aGridID);
+ if(anExtractID < 0)
+ return -1;
+ vtkIdType aRetID = myVisualObj->GetElemObjId(anExtractID);
+ if(MYDEBUG)
+ MESSAGE("GetElemObjId - theVtkID = "<<theVtkID<<"; anExtractID = "<<anExtractID<<"; aGridID = "<<aGridID<<"; aRetID = "<<aRetID);
+ return aRetID;
+}
+
+SMESH_DeviceActor::TVectorId SMESH_DeviceActor::GetElemVtkId(int theObjID){
+ TVectorId aVecId;
+ vtkIdType aGridID = myVisualObj->GetElemVTKId(theObjID);
+ if(aGridID < 0)
+ return aVecId;
+ aVecId = myGeomFilter->GetVtkId(aGridID);
+ if(MYDEBUG)
+ MESSAGE("GetElemVtkId - theObjID = "<<theObjID<<"; aGridID = "<<aGridID<<"; aGridID = "<<aGridID<<"; aVecId[0] = "<<aVecId[0]);
+ return aVecId;
+}
+
+
+float SMESH_DeviceActor::GetShrinkFactor(){
+ return myShrinkFilter->GetShrinkFactor();
+}
+
+void SMESH_DeviceActor::SetShrinkFactor(float theValue){
+ theValue = theValue > 0.1? theValue: 0.8;
+ myShrinkFilter->SetShrinkFactor(theValue);
+ Modified();
+}
+
+
+void SMESH_DeviceActor::Render(vtkRenderer *ren, vtkMapper* m){
+ int aResolveCoincidentTopology = vtkMapper::GetResolveCoincidentTopology();
+ float aFactor, aUnit;
+ vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(aFactor,aUnit);
+
+ vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
+ vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(myPolygonOffsetFactor,
+ myPolygonOffsetUnits);
+ vtkLODActor::Render(ren,m);
+
+ vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(aFactor,aUnit);
+ vtkMapper::SetResolveCoincidentTopology(aResolveCoincidentTopology);
+}
+
+
+void SMESH_DeviceActor::SetPolygonOffsetParameters(float factor, float units){
+ myPolygonOffsetFactor = factor;
+ myPolygonOffsetUnits = units;
+}
+
--- /dev/null
+// SMESH OBJECT : interactive object for SMESH visualization
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_Actor.h
+// Author : Nicolas REJNERI
+// Module : SMESH
+// $Header$
+
+#ifndef SMESH_DEVICE_ACTOR_H
+#define SMESH_DEVICE_ACTOR_H
+
+#include "SALOME_GeometryFilter.h"
+#include "SMESH_Object.h"
+
+#include <vtkLODActor.h>
+
+class vtkProperty;
+class vtkMergeFilter;
+class vtkShrinkFilter;
+class vtkPolyDataMapper;
+class vtkUnstructuredGrid;
+
+class SALOME_Transform;
+class SALOME_TransformFilter;
+class SALOME_PassThroughFilter;
+class SALOME_ExtractUnstructuredGrid;
+
+
+class SMESH_DeviceActor: public vtkLODActor{
+ friend class SMESH_Actor;
+
+ public:
+ vtkTypeMacro(SMESH_DeviceActor,vtkLODActor);
+ static SMESH_DeviceActor* New();
+
+ void SetStoreMapping(int theStoreMapping);
+ int GetStoreMapping(){ return myStoreMapping;}
+
+ typedef SALOME_GeometryFilter::TVectorId TVectorId;
+ int GetObjId(int theVtkID);
+ TVectorId GetVtkId(int theObjID);
+
+ int GetNodeObjId(int theVtkID);
+ TVectorId GetNodeVtkId(int theObjID);
+
+ int GetElemObjId(int theVtkID);
+ TVectorId GetElemVtkId(int theObjID);
+
+ vtkPolyData* GetPolyDataInput();
+
+ virtual void SetTransform(SALOME_Transform* theTransform);
+ virtual unsigned long int GetMTime();
+
+ float GetShrinkFactor();
+ void SetShrinkFactor(float value);
+
+ bool IsShrunkable() { return myIsShrinkable;}
+ bool IsShrunk() { return myIsShrunk;}
+ void SetShrink();
+ void UnShrink();
+
+ enum EReperesent { ePoint, eWireframe, eSurface, eInsideframe};
+ EReperesent GetRepresentation(){ return myRepresentation;}
+ void SetRepresentation(EReperesent theMode);
+
+ virtual void SetVisibility(int theMode);
+ virtual int GetVisibility();
+
+ SALOME_ExtractUnstructuredGrid* GetExtractUnstructuredGrid();
+ vtkUnstructuredGrid* GetUnstructuredGrid();
+ vtkMergeFilter* GetMergeFilter();
+
+ virtual void Render(vtkRenderer *, vtkMapper *);
+
+ protected:
+ void SetUnstructuredGrid(vtkUnstructuredGrid* theGrid);
+
+ vtkPolyDataMapper *myMapper;
+ TVisualObjPtr myVisualObj;
+
+ vtkProperty *myProperty;
+ EReperesent myRepresentation;
+
+ vtkMergeFilter* myMergeFilter;
+ SALOME_ExtractUnstructuredGrid* myExtractUnstructuredGrid;
+
+ bool myStoreMapping;
+ SALOME_GeometryFilter *myGeomFilter;
+ SALOME_TransformFilter *myTransformFilter;
+ std::vector<SALOME_PassThroughFilter*> myPassFilter;
+
+ vtkShrinkFilter* myShrinkFilter;
+ bool myIsShrinkable;
+ bool myIsShrunk;
+
+ float myPolygonOffsetFactor;
+ float myPolygonOffsetUnits;
+
+ void SetPolygonOffsetParameters(float factor, float units);
+ void GetPolygonOffsetParameters(float& factor, float& units){
+ factor = myPolygonOffsetFactor;
+ units = myPolygonOffsetUnits;
+ }
+
+ SMESH_DeviceActor();
+ ~SMESH_DeviceActor();
+ SMESH_DeviceActor(const SMESH_DeviceActor&) {};
+ void operator=(const SMESH_DeviceActor&) {};
+
+};
+
+
+#endif //SMESH_ACTOR_H
--- /dev/null
+// SMESH OBJECT : interactive object for SMESH visualization
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_Grid.cxx
+// Author : Nicolas REJNERI
+// Module : SMESH
+
+#include "SMESH_Object.h"
+#include "SMDS_Mesh.hxx"
+#include "SALOME_ExtractUnstructuredGrid.h"
+#include "SMESH_Actor.h"
+
+#include CORBA_SERVER_HEADER(SALOME_Exception)
+
+#include <vtkUnstructuredGrid.h>
+#include <vtkUnstructuredGridWriter.h>
+#include <vtkUnstructuredGridReader.h>
+
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <set>
+
+#include "utilities.h"
+
+using namespace std;
+
+#ifndef EXCEPTION
+#define EXCEPTION(TYPE, MSG) {\
+ std::ostringstream aStream;\
+ aStream<<__FILE__<<"["<<__LINE__<<"]::"<<MSG;\
+ throw TYPE(aStream.str());\
+}
+#endif
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+static int MYDEBUGWITHFILES = 0;
+#else
+static int MYDEBUG = 0;
+static int MYDEBUGWITHFILES = 0;
+#endif
+
+
+void WriteUnstructuredGrid(vtkUnstructuredGrid* theGrid, const char* theFileName){
+ vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
+ aWriter->SetFileName(theFileName);
+ aWriter->SetInput(theGrid);
+ aWriter->Write();
+ aWriter->Delete();
+}
+
+
+namespace{
+
+ inline const SMDS_MeshNode* FindNode(const SMDS_Mesh* theMesh, int theId){
+ if(const SMDS_MeshNode* anElem = theMesh->FindNode(theId)) return anElem;
+ EXCEPTION(runtime_error,"SMDS_Mesh::FindNode - cannot find a SMDS_MeshNode for ID = "<<theId);
+ }
+
+
+ inline const SMDS_MeshElement* FindElement(const SMDS_Mesh* theMesh, int theId){
+ if(const SMDS_MeshElement* anElem = theMesh->FindElement(theId)) return anElem;
+ EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot find a SMDS_MeshElement for ID = "<<theId);
+ }
+
+
+ inline void AddNodesWithID(SMDS_Mesh* theMesh,
+ SMESH::log_array_var& theSeq,
+ CORBA::Long theId)
+ {
+ const SMESH::double_array& aCoords = theSeq[theId].coords;
+ const SMESH::long_array& anIndexes = theSeq[theId].indexes;
+ CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
+ if(3*aNbElems != aCoords.length())
+ EXCEPTION(runtime_error,"AddNodesWithID - 3*aNbElems != aCoords.length()");
+ for(CORBA::Long aCoordId = 0; anElemId < aNbElems; anElemId++, aCoordId+=3){
+ SMDS_MeshElement* anElem = theMesh->AddNodeWithID(aCoords[aCoordId],
+ aCoords[aCoordId+1],
+ aCoords[aCoordId+2],
+ anIndexes[anElemId]);
+ if(!anElem)
+ EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddNodeWithID for ID = "<<anElemId);
+ }
+ }
+
+
+ inline void AddEdgesWithID(SMDS_Mesh* theMesh,
+ SMESH::log_array_var& theSeq,
+ CORBA::Long theId)
+ {
+ const SMESH::double_array& aCoords = theSeq[theId].coords;
+ const SMESH::long_array& anIndexes = theSeq[theId].indexes;
+ CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
+ if(3*aNbElems != anIndexes.length())
+ EXCEPTION(runtime_error,"AddEdgeWithID - 3*aNbElems != aCoords.length()");
+ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=3){
+ SMDS_MeshElement* anElem = theMesh->AddEdgeWithID(anIndexes[anIndexId+1],
+ anIndexes[anIndexId+2],
+ anIndexes[anIndexId]);
+ if(!anElem)
+ EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddEdgeWithID for ID = "<<anElemId);
+ }
+ }
+
+
+ inline void AddTriasWithID(SMDS_Mesh* theMesh,
+ SMESH::log_array_var& theSeq,
+ CORBA::Long theId)
+ {
+ const SMESH::double_array& aCoords = theSeq[theId].coords;
+ const SMESH::long_array& anIndexes = theSeq[theId].indexes;
+ CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
+ if(4*aNbElems != anIndexes.length())
+ EXCEPTION(runtime_error,"AddEdgeWithID - 4*aNbElems != anIndexes.length()");
+ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=4){
+ SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
+ anIndexes[anIndexId+2],
+ anIndexes[anIndexId+3],
+ anIndexes[anIndexId]);
+ if(!anElem)
+ EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
+ }
+ }
+
+
+ inline void AddQuadsWithID(SMDS_Mesh* theMesh,
+ SMESH::log_array_var theSeq,
+ CORBA::Long theId)
+ {
+ const SMESH::double_array& aCoords = theSeq[theId].coords;
+ const SMESH::long_array& anIndexes = theSeq[theId].indexes;
+ CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
+ if(5*aNbElems != anIndexes.length())
+ EXCEPTION(runtime_error,"AddEdgeWithID - 4*aNbElems != anIndexes.length()");
+ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=5){
+ SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
+ anIndexes[anIndexId+2],
+ anIndexes[anIndexId+3],
+ anIndexes[anIndexId+4],
+ anIndexes[anIndexId]);
+ if(!anElem)
+ EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
+ }
+ }
+
+
+ inline void AddTetrasWithID(SMDS_Mesh* theMesh,
+ SMESH::log_array_var& theSeq,
+ CORBA::Long theId)
+ {
+ const SMESH::double_array& aCoords = theSeq[theId].coords;
+ const SMESH::long_array& anIndexes = theSeq[theId].indexes;
+ CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
+ if(5*aNbElems != anIndexes.length())
+ EXCEPTION(runtime_error,"AddEdgeWithID - 5*aNbElems != anIndexes.length()");
+ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=5){
+ SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
+ anIndexes[anIndexId+2],
+ anIndexes[anIndexId+3],
+ anIndexes[anIndexId+4],
+ anIndexes[anIndexId]);
+ if(!anElem)
+ EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
+ }
+ }
+
+
+ inline void AddPiramidsWithID(SMDS_Mesh* theMesh,
+ SMESH::log_array_var& theSeq,
+ CORBA::Long theId)
+ {
+ const SMESH::double_array& aCoords = theSeq[theId].coords;
+ const SMESH::long_array& anIndexes = theSeq[theId].indexes;
+ CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
+ if(6*aNbElems != anIndexes.length())
+ EXCEPTION(runtime_error,"AddEdgeWithID - 6*aNbElems != anIndexes.length()");
+ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=6){
+ SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
+ anIndexes[anIndexId+2],
+ anIndexes[anIndexId+3],
+ anIndexes[anIndexId+4],
+ anIndexes[anIndexId+5],
+ anIndexes[anIndexId]);
+ if(!anElem)
+ EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
+ }
+ }
+
+
+ inline void AddPrismsWithID(SMDS_Mesh* theMesh,
+ SMESH::log_array_var& theSeq,
+ CORBA::Long theId)
+ {
+ const SMESH::double_array& aCoords = theSeq[theId].coords;
+ const SMESH::long_array& anIndexes = theSeq[theId].indexes;
+ CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
+ if(7*aNbElems != anIndexes.length())
+ EXCEPTION(runtime_error,"AddEdgeWithID - 7*aNbElems != anIndexes.length()");
+ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=7){
+ SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
+ anIndexes[anIndexId+2],
+ anIndexes[anIndexId+3],
+ anIndexes[anIndexId+4],
+ anIndexes[anIndexId+5],
+ anIndexes[anIndexId+6],
+ anIndexes[anIndexId]);
+ if(!anElem)
+ EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
+ }
+ }
+
+
+ inline void AddHexasWithID(SMDS_Mesh* theMesh,
+ SMESH::log_array_var& theSeq,
+ CORBA::Long theId)
+ {
+ const SMESH::double_array& aCoords = theSeq[theId].coords;
+ const SMESH::long_array& anIndexes = theSeq[theId].indexes;
+ CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
+ if(9*aNbElems != anIndexes.length())
+ EXCEPTION(runtime_error,"AddEdgeWithID - 9*aNbElems != anIndexes.length()");
+ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=9){
+ SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
+ anIndexes[anIndexId+2],
+ anIndexes[anIndexId+3],
+ anIndexes[anIndexId+4],
+ anIndexes[anIndexId+5],
+ anIndexes[anIndexId+6],
+ anIndexes[anIndexId+7],
+ anIndexes[anIndexId+8],
+ anIndexes[anIndexId]);
+ if(!anElem)
+ EXCEPTION(runtime_error,"SMDS_Mesh::FindElement - cannot AddFaceWithID for ID = "<<anElemId);
+ }
+ }
+
+
+}
+/*
+ Class : SMESH_VisualObj
+ Description : Base class for all mesh objects to be visuilised
+*/
+
+//=================================================================================
+// function : getCellType
+// purpose : Get type of VTK cell
+//=================================================================================
+static inline vtkIdType getCellType( const SMESH::ElementType theType,
+ const int theNbNodes )
+{
+ switch( theType )
+ {
+ case SMESH::EDGE: return theNbNodes == 2 ? VTK_LINE : VTK_EMPTY_CELL;
+
+ case SMESH::FACE : if ( theNbNodes == 3 ) return VTK_TRIANGLE;
+ else if ( theNbNodes == 4 ) return VTK_QUAD;
+ else return VTK_EMPTY_CELL;
+
+ case SMESH::VOLUME: if ( theNbNodes == 4 ) return VTK_TETRA;
+ else if ( theNbNodes == 5 ) return VTK_PYRAMID;
+ else if ( theNbNodes == 6 ) return VTK_WEDGE;
+ else if ( theNbNodes == 8 ) return VTK_HEXAHEDRON;
+ else return VTK_EMPTY_CELL;
+
+ default: return VTK_EMPTY_CELL;
+ }
+}
+
+//=================================================================================
+// functions : SMESH_VisualObj
+// purpose : Constructor
+//=================================================================================
+SMESH_VisualObj::SMESH_VisualObj()
+{
+ myGrid = vtkUnstructuredGrid::New();
+}
+SMESH_VisualObj::~SMESH_VisualObj()
+{
+ if ( MYDEBUG )
+ MESSAGE( "~SMESH_MeshObj - myGrid->GetReferenceCount() = " << myGrid->GetReferenceCount() );
+ myGrid->Delete();
+}
+
+//=================================================================================
+// functions : GetNodeObjId, GetNodeVTKId, GetElemObjId, GetElemVTKId
+// purpose : Methods for retrieving VTK IDs by SMDS IDs and vice versa
+//=================================================================================
+vtkIdType SMESH_VisualObj::GetNodeObjId( int theVTKID )
+{
+ return myVTK2SMDSNodes.find(theVTKID) == myVTK2SMDSNodes.end() ? -1 : myVTK2SMDSNodes[theVTKID];
+}
+
+vtkIdType SMESH_VisualObj::GetNodeVTKId( int theObjID )
+{
+ return mySMDS2VTKNodes.find(theObjID) == mySMDS2VTKNodes.end() ? -1 : mySMDS2VTKNodes[theObjID];
+}
+
+vtkIdType SMESH_VisualObj::GetElemObjId( int theVTKID )
+{
+ return myVTK2SMDSElems.find(theVTKID) == myVTK2SMDSElems.end() ? -1 : myVTK2SMDSElems[theVTKID];
+}
+
+vtkIdType SMESH_VisualObj::GetElemVTKId( int theObjID )
+{
+ return mySMDS2VTKElems.find(theObjID) == mySMDS2VTKElems.end() ? -1 : mySMDS2VTKElems[theObjID];
+}
+
+//=================================================================================
+// function : SMESH_VisualObj::createPoints
+// purpose : Create points from nodes
+//=================================================================================
+void SMESH_VisualObj::createPoints( vtkPoints* thePoints )
+{
+ if ( thePoints == 0 )
+ return;
+
+ TEntityList aNodes;
+ vtkIdType nbNodes = GetEntities( SMESH::NODE, aNodes );
+ thePoints->SetNumberOfPoints( nbNodes );
+
+ int nbPoints = 0;
+
+ TEntityList::const_iterator anIter;
+ for ( anIter = aNodes.begin(); anIter != aNodes.end(); ++anIter )
+ {
+ const SMDS_MeshNode* aNode = ( const SMDS_MeshNode* )(*anIter);
+ if ( aNode != 0 )
+ {
+ thePoints->SetPoint( nbPoints, aNode->X(), aNode->Y(), aNode->Z() );
+ int anId = aNode->GetID();
+ mySMDS2VTKNodes.insert( TMapOfIds::value_type( anId, nbPoints ) );
+ myVTK2SMDSNodes.insert( TMapOfIds::value_type( nbPoints, anId ) );
+ nbPoints++;
+ }
+ }
+
+ if ( nbPoints != nbNodes )
+ thePoints->SetNumberOfPoints( nbPoints );
+}
+
+//=================================================================================
+// function : buildPrs
+// purpose : create VTK cells( fill unstructured grid )
+//=================================================================================
+void SMESH_VisualObj::buildPrs()
+{
+ try
+ {
+ mySMDS2VTKNodes.clear();
+ myVTK2SMDSNodes.clear();
+ mySMDS2VTKElems.clear();
+ myVTK2SMDSElems.clear();
+
+ if ( IsNodePrs() )
+ buildNodePrs();
+ else
+ buildElemPrs();
+ }
+ catch( const std::exception& exc )
+ {
+ INFOS("Follow exception was cought:\n\t"<<exc.what());
+ }
+ catch(...)
+ {
+ INFOS("Unknown exception was cought !!!");
+ }
+
+ if( MYDEBUG ) MESSAGE( "Update - myGrid->GetNumberOfCells() = "<<myGrid->GetNumberOfCells() );
+ if( MYDEBUGWITHFILES ) WriteUnstructuredGrid( myGrid,"/tmp/buildPrs" );
+}
+
+//=================================================================================
+// function : buildNodePrs
+// purpose : create VTK cells for nodes
+//=================================================================================
+void SMESH_VisualObj::buildNodePrs()
+{
+ vtkPoints* aPoints = vtkPoints::New();
+ createPoints( aPoints );
+ int nbPoints = aPoints->GetNumberOfPoints();
+ myGrid->SetPoints( aPoints );
+ aPoints->Delete();
+
+ myGrid->SetCells( 0, 0, 0 );
+
+ // Create cells
+
+ /*vtkIdList *anIdList = vtkIdList::New();
+ anIdList->SetNumberOfIds( 1 );
+
+ vtkCellArray *aCells = vtkCellArray::New();
+ aCells->Allocate( 2 * nbPoints, 0 );
+
+ vtkUnsignedCharArray* aCellTypesArray = vtkUnsignedCharArray::New();
+ aCellTypesArray->SetNumberOfComponents( 1 );
+ aCellTypesArray->Allocate( nbPoints );
+
+ for( vtkIdType aCellId = 0; aCellId < nbPoints; aCellId++ )
+ {
+ anIdList->SetId( 0, aCellId );
+ aCells->InsertNextCell( anIdList );
+ aCellTypesArray->InsertNextValue( VTK_VERTEX );
+ }
+
+ vtkIntArray* aCellLocationsArray = vtkIntArray::New();
+ aCellLocationsArray->SetNumberOfComponents( 1 );
+ aCellLocationsArray->SetNumberOfTuples( nbPoints );
+
+ aCells->InitTraversal();
+ for( vtkIdType i = 0, *pts, npts; aCells->GetNextCell( npts, pts ); i++ )
+ aCellLocationsArray->SetValue( i, aCells->GetTraversalLocation( npts ) );
+
+ myGrid->SetCells( aCellTypesArray, aCellLocationsArray, aCells );
+
+ aCellLocationsArray->Delete();
+ aCellTypesArray->Delete();
+ aCells->Delete();
+ anIdList->Delete(); */
+}
+
+//=================================================================================
+// function : buildElemPrs
+// purpose : Create VTK cells for elements
+//=================================================================================
+void SMESH_VisualObj::buildElemPrs()
+{
+ // Create points
+
+ vtkPoints* aPoints = vtkPoints::New();
+ createPoints( aPoints );
+ myGrid->SetPoints( aPoints );
+ aPoints->Delete();
+
+ if ( MYDEBUG )
+ MESSAGE("Update - myGrid->GetNumberOfPoints() = "<<myGrid->GetNumberOfPoints());
+
+ // Calculate cells size
+
+ static SMESH::ElementType aTypes[ 3 ] = { SMESH::EDGE, SMESH::FACE, SMESH::VOLUME };
+
+ // get entity data
+ map< int, int > nbEnts;
+ map< int, TEntityList > anEnts;
+
+ for ( int i = 0; i <= 2; i++ )
+ nbEnts[ aTypes[ i ] ] = GetEntities( aTypes[ i ], anEnts[ aTypes[ i ] ] );
+
+ vtkIdType aCellsSize = 3 * nbEnts[ SMESH::EDGE ];
+
+ for ( int i = 1; i <= 2; i++ ) // iterate through faces and volumes
+ {
+ if ( nbEnts[ aTypes[ i ] ] )
+ {
+ const TEntityList& aList = anEnts[ aTypes[ i ] ];
+ TEntityList::const_iterator anIter;
+ for ( anIter = aList.begin(); anIter != aList.end(); ++anIter )
+ aCellsSize += (*anIter)->NbNodes() + 1;
+ }
+ }
+
+ vtkIdType aNbCells = nbEnts[ SMESH::EDGE ] + nbEnts[ SMESH::FACE ] + nbEnts[ SMESH::VOLUME ];
+
+ if ( MYDEBUG )
+ MESSAGE( "Update - aNbCells = "<<aNbCells<<"; aCellsSize = "<<aCellsSize );
+
+ // Create cells
+
+ vtkCellArray* aConnectivity = vtkCellArray::New();
+ aConnectivity->Allocate( aCellsSize, 0 );
+
+ vtkUnsignedCharArray* aCellTypesArray = vtkUnsignedCharArray::New();
+ aCellTypesArray->SetNumberOfComponents( 1 );
+ aCellTypesArray->Allocate( aNbCells * aCellTypesArray->GetNumberOfComponents() );
+
+ vtkIdList *anIdList = vtkIdList::New();
+ vtkIdType iElem = 0;
+
+ for ( int i = 0; i <= 2; i++ ) // iterate through edges, faces and volumes
+ {
+ if( nbEnts[ aTypes[ i ] ] > 0 )
+ {
+ const TEntityList& aList = anEnts[ aTypes[ i ] ];
+ TEntityList::const_iterator anIter;
+ for ( anIter = aList.begin(); anIter != aList.end(); ++anIter )
+ {
+ const SMDS_MeshElement* anElem = *anIter;
+
+ vtkIdType aNbNodes = anElem->NbNodes();
+ anIdList->SetNumberOfIds( aNbNodes );
+
+ int anId = anElem->GetID();
+
+ mySMDS2VTKElems.insert( TMapOfIds::value_type( anId, iElem ) );
+ myVTK2SMDSElems.insert( TMapOfIds::value_type( iElem, anId ) );
+
+ SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
+ for( vtkIdType aNodeId = 0; aNodesIter->more(); aNodeId++ )
+ {
+ const SMDS_MeshElement* aNode = aNodesIter->next();
+ anIdList->SetId( aNodeId, mySMDS2VTKNodes[aNode->GetID()] );
+ }
+
+ aConnectivity->InsertNextCell( anIdList );
+ aCellTypesArray->InsertNextValue( getCellType( aTypes[ i ], aNbNodes ) );
+
+ iElem++;
+ }
+ }
+ }
+
+ // Insert cells in grid
+
+ vtkIntArray* aCellLocationsArray = vtkIntArray::New();
+ aCellLocationsArray->SetNumberOfComponents( 1 );
+ aCellLocationsArray->SetNumberOfTuples( aNbCells );
+
+ aConnectivity->InitTraversal();
+ for( vtkIdType idType = 0, *pts, npts; aConnectivity->GetNextCell( npts, pts ); idType++ )
+ aCellLocationsArray->SetValue( idType, aConnectivity->GetTraversalLocation( npts ) );
+
+ myGrid->SetCells( aCellTypesArray, aCellLocationsArray,aConnectivity );
+
+ aCellLocationsArray->Delete();
+ aCellTypesArray->Delete();
+ aConnectivity->Delete();
+ anIdList->Delete();
+}
+
+/*
+ Class : SMESH_MeshObj
+ Description : Class for visualisation of mesh
+*/
+
+//=================================================================================
+// function : SMESH_MeshObj
+// purpose : Constructor
+//=================================================================================
+SMESH_MeshObj::SMESH_MeshObj(SMESH::SMESH_Mesh_ptr theMesh)
+{
+ if ( MYDEBUG )
+ MESSAGE("SMESH_MeshObj - theMesh->_is_nil() = "<<theMesh->_is_nil());
+
+ myMeshServer = SMESH::SMESH_Mesh::_duplicate( theMesh );
+ myMeshServer->Register();
+ myMesh = new SMDS_Mesh();
+}
+
+//=================================================================================
+// function : ~SMESH_MeshObj
+// purpose : Destructor
+//=================================================================================
+SMESH_MeshObj::~SMESH_MeshObj()
+{
+ myMeshServer->Destroy();
+ delete myMesh;
+}
+
+//=================================================================================
+// function : Update
+// purpose : Update mesh and fill grid with new values if necessary
+//=================================================================================
+void SMESH_MeshObj::Update( int theIsClear )
+{
+ // Update SMDS_Mesh on client part
+
+ try
+ {
+ SMESH::log_array_var aSeq = myMeshServer->GetLog( theIsClear );
+ CORBA::Long aLength = aSeq->length();
+
+ if( MYDEBUG ) MESSAGE( "Update: length of the script is "<<aLength );
+
+ if( !aLength )
+ return;
+
+ for ( CORBA::Long anId = 0; anId < aLength; anId++)
+ {
+ const SMESH::double_array& aCoords = aSeq[anId].coords;
+ const SMESH::long_array& anIndexes = aSeq[anId].indexes;
+ CORBA::Long anElemId = 0, aNbElems = aSeq[anId].number;
+ SMDS_MeshElement* anElem = NULL;
+ CORBA::Long aCommand = aSeq[anId].commandType;
+
+ switch(aCommand)
+ {
+ case SMESH::ADD_NODE : AddNodesWithID ( myMesh, aSeq, anId ); break;
+ case SMESH::ADD_EDGE : AddEdgesWithID ( myMesh, aSeq, anId ); break;
+ case SMESH::ADD_TRIANGLE : AddTriasWithID ( myMesh, aSeq, anId ); break;
+ case SMESH::ADD_QUADRANGLE : AddQuadsWithID ( myMesh, aSeq, anId ); break;
+ case SMESH::ADD_TETRAHEDRON: AddTetrasWithID ( myMesh, aSeq, anId ); break;
+ case SMESH::ADD_PYRAMID : AddPiramidsWithID( myMesh, aSeq, anId ); break;
+ case SMESH::ADD_PRISM : AddPrismsWithID ( myMesh, aSeq, anId ); break;
+ case SMESH::ADD_HEXAHEDRON : AddHexasWithID ( myMesh, aSeq, anId ); break;
+
+ case SMESH::REMOVE_NODE:
+ for( ; anElemId < aNbElems; anElemId++ )
+ myMesh->RemoveNode( FindNode( myMesh, anIndexes[anElemId] ) );
+ break;
+
+ case SMESH::REMOVE_ELEMENT:
+ for( ; anElemId < aNbElems; anElemId++ )
+ myMesh->RemoveElement( FindElement( myMesh, anIndexes[anElemId] ) );
+ break;
+ }
+ }
+ }
+ catch ( SALOME::SALOME_Exception& exc )
+ {
+ INFOS("Follow exception was cought:\n\t"<<exc.details.text);
+ }
+ catch( const std::exception& exc)
+ {
+ INFOS("Follow exception was cought:\n\t"<<exc.what());
+ }
+ catch(...)
+ {
+ INFOS("Unknown exception was cought !!!");
+ }
+
+ if ( MYDEBUG )
+ {
+ MESSAGE("Update - myMesh->NbNodes() = "<<myMesh->NbNodes());
+ MESSAGE("Update - myMesh->NbEdges() = "<<myMesh->NbEdges());
+ MESSAGE("Update - myMesh->NbFaces() = "<<myMesh->NbFaces());
+ MESSAGE("Update - myMesh->NbVolumes() = "<<myMesh->NbVolumes());
+ }
+
+ // Fill unstructured grid
+ buildPrs();
+}
+
+//=================================================================================
+// function : GetElemDimension
+// purpose : Get dimension of element
+//=================================================================================
+int SMESH_MeshObj::GetElemDimension( const int theObjId )
+{
+ const SMDS_MeshElement* anElem = myMesh->FindElement( theObjId );
+ if ( anElem == 0 )
+ return 0;
+
+ int aType = anElem->GetType();
+ switch ( aType )
+ {
+ case SMDSAbs_Edge : return 1;
+ case SMDSAbs_Face : return 2;
+ case SMDSAbs_Volume: return 3;
+ default : return 0;
+ }
+}
+
+//=================================================================================
+// function : GetEntities
+// purpose : Get entities of specified type. Return number of entities
+//=================================================================================
+int SMESH_MeshObj::GetNbEntities( const SMESH::ElementType theType) const
+{
+ switch ( theType )
+ {
+ case SMESH::NODE:
+ {
+ return myMesh->NbNodes();
+ }
+ break;
+ case SMESH::EDGE:
+ {
+ return myMesh->NbEdges();
+ }
+ break;
+ case SMESH::FACE:
+ {
+ return myMesh->NbFaces();
+ }
+ break;
+ case SMESH::VOLUME:
+ {
+ return myMesh->NbVolumes();
+ }
+ break;
+ default:
+ return 0;
+ break;
+ }
+}
+
+int SMESH_MeshObj::GetEntities( const SMESH::ElementType theType, TEntityList& theObjs ) const
+{
+ theObjs.clear();
+
+ switch ( theType )
+ {
+ case SMESH::NODE:
+ {
+ SMDS_NodeIteratorPtr anIter = myMesh->nodesIterator();
+ while ( anIter->more() ) theObjs.push_back( anIter->next() );
+ }
+ break;
+ case SMESH::EDGE:
+ {
+ SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
+ while ( anIter->more() ) theObjs.push_back( anIter->next() );
+ }
+ break;
+ case SMESH::FACE:
+ {
+ SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
+ while ( anIter->more() ) theObjs.push_back( anIter->next() );
+ }
+ break;
+ case SMESH::VOLUME:
+ {
+ SMDS_VolumeIteratorPtr anIter = myMesh->volumesIterator();
+ while ( anIter->more() ) theObjs.push_back( anIter->next() );
+ }
+ break;
+ default:
+ break;
+ }
+
+ return theObjs.size();
+}
+
+//=================================================================================
+// function : UpdateFunctor
+// purpose : Update functor in accordance with current mesh
+//=================================================================================
+void SMESH_MeshObj::UpdateFunctor( SMESH::Functor_ptr f )
+{
+ f->SetMesh( myMeshServer );
+}
+
+//=================================================================================
+// function : IsNodePrs
+// purpose : Return true if node presentation is used
+//=================================================================================
+bool SMESH_MeshObj::IsNodePrs() const
+{
+ return myMesh->NbEdges() == 0 &&myMesh->NbFaces() == 0 &&myMesh->NbVolumes() == 0 ;
+}
+
+
+/*
+ Class : SMESH_SubMeshObj
+ Description : Base class for visualisation of submeshes and groups
+*/
+
+//=================================================================================
+// function : SMESH_SubMeshObj
+// purpose : Constructor
+//=================================================================================
+SMESH_SubMeshObj::SMESH_SubMeshObj( SMESH_MeshObj* theMeshObj )
+{
+ if ( MYDEBUG ) MESSAGE( "SMESH_SubMeshObj - theMeshObj = " << theMeshObj );
+
+ myMeshObj = theMeshObj;
+}
+
+SMESH_SubMeshObj::~SMESH_SubMeshObj()
+{
+}
+
+//=================================================================================
+// function : GetElemDimension
+// purpose : Get dimension of element
+//=================================================================================
+int SMESH_SubMeshObj::GetElemDimension( const int theObjId )
+{
+ return myMeshObj == 0 ? 0 : myMeshObj->GetElemDimension( theObjId );
+}
+
+//=================================================================================
+// function : UpdateFunctor
+// purpose : Update functor in accordance with current mesh
+//=================================================================================
+void SMESH_SubMeshObj::UpdateFunctor( SMESH::Functor_ptr f )
+{
+ f->SetMesh( myMeshObj->GetMeshServer() );
+}
+
+//=================================================================================
+// function : UpdateFunctor
+// purpose : Update mesh object and fill grid with new values
+//=================================================================================
+void SMESH_SubMeshObj::Update( int theIsClear )
+{
+ myMeshObj->Update( theIsClear );
+ buildPrs();
+}
+
+
+/*
+ Class : SMESH_GroupObj
+ Description : Class for visualisation of groups
+*/
+
+//=================================================================================
+// function : SMESH_GroupObj
+// purpose : Constructor
+//=================================================================================
+SMESH_GroupObj::SMESH_GroupObj( SMESH::SMESH_Group_ptr theGroup,
+ SMESH_MeshObj* theMeshObj )
+: SMESH_SubMeshObj( theMeshObj ),
+ myGroupServer( SMESH::SMESH_Group::_duplicate(theGroup) )
+{
+ if ( MYDEBUG ) MESSAGE("SMESH_GroupObj - theGroup->_is_nil() = "<<theGroup->_is_nil());
+ myGroupServer->Register();
+}
+
+SMESH_GroupObj::~SMESH_GroupObj()
+{
+ if ( MYDEBUG ) MESSAGE("~SMESH_GroupObj");
+ myGroupServer->Destroy();
+}
+
+//=================================================================================
+// function : IsNodePrs
+// purpose : Return true if node presentation is used
+//=================================================================================
+bool SMESH_GroupObj::IsNodePrs() const
+{
+ return myGroupServer->GetType() == SMESH::NODE;
+}
+
+//=================================================================================
+// function : getNodesFromElems
+// purpose : Retrieve nodes from elements
+//=================================================================================
+static int getNodesFromElems( SMESH::long_array_var& theElemIds,
+ const SMDS_Mesh* theMesh,
+ std::list<const SMDS_MeshElement*>& theResList )
+{
+ set<const SMDS_MeshElement*> aNodeSet;
+
+ for ( CORBA::Long i = 0, n = theElemIds->length(); i < n; i++ )
+ {
+ const SMDS_MeshElement* anElem = theMesh->FindElement( theElemIds[ i ] );
+ if ( anElem != 0 )
+ {
+ SMDS_ElemIteratorPtr anIter = anElem->nodesIterator();
+ while ( anIter->more() )
+ {
+ const SMDS_MeshElement* aNode = anIter->next();
+ if ( aNode != 0 )
+ aNodeSet.insert( aNode );
+ }
+ }
+ }
+
+ set<const SMDS_MeshElement*>::const_iterator anIter;
+ for ( anIter = aNodeSet.begin(); anIter != aNodeSet.end(); ++anIter )
+ theResList.push_back( *anIter );
+
+ return theResList.size();
+}
+
+//=================================================================================
+// function : getPointers
+// purpose : Get std::list<const SMDS_MeshElement*> from list of IDs
+//=================================================================================
+static int getPointers( const SMESH::ElementType theRequestType,
+ SMESH::long_array_var& theElemIds,
+ const SMDS_Mesh* theMesh,
+ std::list<const SMDS_MeshElement*>& theResList )
+{
+ for ( CORBA::Long i = 0, n = theElemIds->length(); i < n; i++ )
+ {
+ const SMDS_MeshElement* anElem = theRequestType == SMESH::NODE
+ ? theMesh->FindNode( theElemIds[ i ] ) : theMesh->FindElement( theElemIds[ i ] );
+
+ if ( anElem != 0 )
+ theResList.push_back( anElem );
+ }
+
+ return theResList.size();
+}
+
+
+//=================================================================================
+// function : GetEntities
+// purpose : Get entities of specified type. Return number of entities
+//=================================================================================
+int SMESH_GroupObj::GetNbEntities( const SMESH::ElementType theType) const
+{
+ if(myGroupServer->GetType() == theType){
+ return myGroupServer->Size();
+ }
+ return 0;
+}
+
+int SMESH_GroupObj::GetEntities( const SMESH::ElementType theType, TEntityList& theResList ) const
+{
+ theResList.clear();
+ SMDS_Mesh* aMesh = myMeshObj->GetMesh();
+
+ if ( myGroupServer->Size() == 0 || aMesh == 0 )
+ return 0;
+
+ SMESH::ElementType aGrpType = myGroupServer->GetType();
+ SMESH::long_array_var anIds = myGroupServer->GetListOfID();
+
+ if ( aGrpType == theType )
+ return getPointers( theType, anIds, aMesh, theResList );
+ else if ( theType == SMESH::NODE )
+ return getNodesFromElems( anIds, aMesh, theResList );
+ else
+ return 0;
+}
+
+
+
+/*
+ Class : SMESH_subMeshObj
+ Description : Class for visualisation of submeshes
+*/
+
+//=================================================================================
+// function : SMESH_subMeshObj
+// purpose : Constructor
+//=================================================================================
+SMESH_subMeshObj::SMESH_subMeshObj( SMESH::SMESH_subMesh_ptr theSubMesh,
+ SMESH_MeshObj* theMeshObj )
+: SMESH_SubMeshObj( theMeshObj ),
+ mySubMeshServer( SMESH::SMESH_subMesh::_duplicate( theSubMesh ) )
+{
+ if ( MYDEBUG ) MESSAGE( "SMESH_subMeshObj - theSubMesh->_is_nil() = " << theSubMesh->_is_nil() );
+
+ mySubMeshServer->Register();
+}
+
+SMESH_subMeshObj::~SMESH_subMeshObj()
+{
+ if ( MYDEBUG ) MESSAGE( "~SMESH_subMeshObj" );
+ mySubMeshServer->Destroy();
+}
+
+//=================================================================================
+// function : GetEntities
+// purpose : Get entities of specified type. Return number of entities
+//=================================================================================
+int SMESH_subMeshObj::GetNbEntities( const SMESH::ElementType theType) const
+{
+ switch ( theType )
+ {
+ case SMESH::NODE:
+ {
+ return mySubMeshServer->GetNumberOfNodes();
+ }
+ break;
+ case SMESH::EDGE:
+ case SMESH::FACE:
+ case SMESH::VOLUME:
+ {
+ SMESH::long_array_var anIds = mySubMeshServer->GetElementsByType( theType );
+ return anIds->length();
+ }
+ default:
+ return 0;
+ break;
+ }
+}
+
+int SMESH_subMeshObj::GetEntities( const SMESH::ElementType theType, TEntityList& theResList ) const
+{
+ theResList.clear();
+
+ SMDS_Mesh* aMesh = myMeshObj->GetMesh();
+ if ( aMesh == 0 )
+ return 0;
+
+ bool isNodal = IsNodePrs();
+
+ if ( isNodal )
+ {
+ if ( theType == SMESH::NODE )
+ {
+ SMESH::long_array_var anIds = mySubMeshServer->GetNodesId();
+ return getPointers( SMESH::NODE, anIds, aMesh, theResList );
+ }
+ }
+ else
+ {
+ if ( theType == SMESH::NODE )
+ {
+ SMESH::long_array_var anIds = mySubMeshServer->GetElementsId();
+ return getNodesFromElems( anIds, aMesh, theResList );
+ }
+ else
+ {
+ SMESH::long_array_var anIds = mySubMeshServer->GetElementsByType( theType );
+ return getPointers( theType, anIds, aMesh, theResList );
+ }
+ }
+
+ return 0;
+}
+
+//=================================================================================
+// function : IsNodePrs
+// purpose : Return true if node presentation is used
+//=================================================================================
+bool SMESH_subMeshObj::IsNodePrs() const
+{
+ return mySubMeshServer->GetNumberOfElements() == 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+// SMESH OBJECT : interactive object for SMESH visualization
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_Object.h
+// Author : Nicolas REJNERI
+// Module : SMESH
+// $Header$
+
+#ifndef SMESH_OBJECT_H
+#define SMESH_OBJECT_H
+
+// IDL Headers
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_Mesh)
+#include CORBA_SERVER_HEADER(SMESH_Group)
+#include CORBA_SERVER_HEADER(SMESH_Filter)
+
+#include <map>
+#include <list>
+#include <boost/shared_ptr.hpp>
+#include <vtkSystemIncludes.h>
+
+class vtkUnstructuredGrid;
+class vtkPoints;
+class SALOME_ExtractUnstructuredGrid;
+
+class SMESH_Actor;
+class SMDS_Mesh;
+class SMDS_MeshNode;
+class SMDS_MeshElement;
+
+class SMESH_VisualObj;
+typedef boost::shared_ptr<SMESH_VisualObj> TVisualObjPtr;
+
+
+/*
+ Class : SMESH_VisualObj
+ Description : Base class for all mesh objects to be visuilised
+*/
+
+class SMESH_VisualObj
+{
+protected:
+
+ typedef std::list<const SMDS_MeshElement*> TEntityList;
+ typedef std::map<vtkIdType,vtkIdType> TMapOfIds;
+
+public:
+ SMESH_VisualObj();
+ virtual ~SMESH_VisualObj();
+
+ virtual void Update( int theIsClear = true ) = 0;
+ virtual void UpdateFunctor( SMESH::Functor_ptr theFunctor ) = 0;
+ virtual int GetElemDimension( const int theObjId ) = 0;
+
+ virtual int GetNbEntities( const SMESH::ElementType) const = 0;
+ virtual int GetEntities( const SMESH::ElementType, TEntityList& ) const = 0;
+ virtual bool IsNodePrs() const = 0;
+
+ vtkUnstructuredGrid* GetUnstructuredGrid() { return myGrid; }
+
+ vtkIdType GetNodeObjId( int theVTKID );
+ vtkIdType GetNodeVTKId( int theObjID );
+ vtkIdType GetElemObjId( int theVTKID );
+ vtkIdType GetElemVTKId( int theObjID );
+
+protected:
+
+ void createPoints( vtkPoints* );
+ void buildPrs();
+ void buildNodePrs();
+ void buildElemPrs();
+
+private:
+
+ TMapOfIds mySMDS2VTKNodes;
+ TMapOfIds myVTK2SMDSNodes;
+ TMapOfIds mySMDS2VTKElems;
+ TMapOfIds myVTK2SMDSElems;
+
+ vtkUnstructuredGrid* myGrid;
+};
+
+
+/*
+ Class : SMESH_MeshObj
+ Description : Class for visualisation of mesh
+*/
+
+class SMESH_MeshObj: public SMESH_VisualObj
+{
+public:
+
+ SMESH_MeshObj( SMESH::SMESH_Mesh_ptr );
+ virtual ~SMESH_MeshObj();
+
+ virtual void Update( int theIsClear = true );
+
+ virtual int GetNbEntities( const SMESH::ElementType) const;
+ virtual int GetEntities( const SMESH::ElementType, TEntityList& ) const;
+ virtual bool IsNodePrs() const;
+
+ virtual int GetElemDimension( const int theObjId );
+
+ virtual void UpdateFunctor( SMESH::Functor_ptr f );
+
+ SMESH::SMESH_Mesh_ptr GetMeshServer() { return myMeshServer.in(); }
+ SMDS_Mesh* GetMesh() { return myMesh; }
+
+protected:
+
+ SMESH::SMESH_Mesh_var myMeshServer;
+ SMDS_Mesh* myMesh;
+};
+
+
+/*
+ Class : SMESH_SubMeshObj
+ Description : Base class for visualisation of submeshes and groups
+*/
+
+class SMESH_SubMeshObj: public SMESH_VisualObj
+{
+public:
+
+ SMESH_SubMeshObj(SMESH_MeshObj* theMeshObj);
+ virtual ~SMESH_SubMeshObj();
+
+ virtual void Update( int theIsClear = true );
+
+ virtual void UpdateFunctor( SMESH::Functor_ptr );
+ virtual int GetElemDimension( const int theObjId );
+
+protected:
+
+ SMESH_MeshObj* myMeshObj;
+};
+
+
+/*
+ Class : SMESH_GroupObj
+ Description : Class for visualisation of groups
+*/
+
+class SMESH_GroupObj: public SMESH_SubMeshObj
+{
+public:
+ SMESH_GroupObj( SMESH::SMESH_Group_ptr, SMESH_MeshObj* );
+ virtual ~SMESH_GroupObj();
+
+ virtual int GetNbEntities( const SMESH::ElementType) const;
+ virtual int GetEntities( const SMESH::ElementType, TEntityList& ) const;
+ virtual bool IsNodePrs() const;
+
+private:
+
+ SMESH::SMESH_Group_var myGroupServer;
+};
+
+
+/*
+ Class : SMESH_subMeshObj
+ Description : Class for visualisation of submeshes
+*/
+
+class SMESH_subMeshObj : public SMESH_SubMeshObj
+{
+public:
+
+ SMESH_subMeshObj( SMESH::SMESH_subMesh_ptr,
+ SMESH_MeshObj* );
+ virtual ~SMESH_subMeshObj();
+
+ virtual int GetNbEntities( const SMESH::ElementType) const;
+ virtual int GetEntities( const SMESH::ElementType, TEntityList& ) const;
+ virtual bool IsNodePrs() const;
+
+protected:
+
+ SMESH::SMESH_subMesh_var mySubMeshServer;
+};
+
+
+extern void WriteUnstructuredGrid(vtkUnstructuredGrid* theGrid, const char* theFileName);
+
+
+#endif
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2004 CEA
+//
+// 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.org
+//
+//
+//
+// File : SMESH_Group.cxx
+// Author : Michael Sazonov (OCC)
+// Module : SMESH
+// $Header$
+
+#include <SMESH_Group.hxx>
+#include <SMESH_Mesh.hxx>
+#include <SMESHDS_Group.hxx>
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+SMESH_Group::SMESH_Group (const SMESH_Mesh* theMesh,
+ const SMDSAbs_ElementType theType,
+ const char* theName)
+ : myName(theName)
+{
+ myGroupDS = new SMESHDS_Group (const_cast<SMESH_Mesh*>(theMesh)->GetMeshDS(), theType);
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+SMESH_Group::~SMESH_Group ()
+{
+ delete myGroupDS;
+}
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2004 CEA
+//
+// 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.org
+//
+//
+//
+// File : SMESH_Group.hxx
+// Author : Michael Sazonov (OCC)
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_Group_HeaderFile
+#define _SMESH_Group_HeaderFile
+
+#include <SMDSAbs_ElementType.hxx>
+#include <string>
+using namespace std;
+
+class SMESHDS_Group;
+class SMESH_Mesh;
+
+class SMESH_Group
+{
+ public:
+
+ SMESH_Group (const SMESH_Mesh* theMesh,
+ const SMDSAbs_ElementType theType,
+ const char* theName);
+ ~SMESH_Group ();
+
+ void SetName (const char* theName) { myName = theName; }
+
+ const char* GetName () const { return myName.c_str(); }
+
+ SMESHDS_Group * GetGroupDS () { return myGroupDS; }
+
+ private:
+ SMESH_Group (const SMESH_Group& theOther);
+ // prohibited copy constructor
+ SMESH_Group& operator = (const SMESH_Group& theOther);
+ // prohibited assign operator
+
+ SMESHDS_Group * myGroupDS;
+ string myName;
+
+};
+
+#endif
--- /dev/null
+// SMESH SMESHDS : idl implementation based on 'SMESH' unit's classes
+//
+// Copyright (C) 2004 CEA
+//
+// 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.org
+//
+//
+//
+// File : SMESHDS_Group.cxx
+// Author : Michael Sazonov, OCC
+// Module : SMESH
+// $Header$
+
+#include <SMESHDS_Group.hxx>
+#include <SMESHDS_Mesh.hxx>
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+SMESHDS_Group::SMESHDS_Group (const SMESHDS_Mesh* theMesh,
+ const SMDSAbs_ElementType theType)
+ : SMDS_MeshGroup(theMesh,theType), myStoreName(""),
+ myCurIndex(0), myCurID(0)
+{
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+bool SMESHDS_Group::Contains (const int theID) const
+{
+ const SMDS_MeshElement* aElem = findInMesh (theID);
+ if (aElem)
+ return SMDS_MeshGroup::Contains(aElem);
+ return false;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+bool SMESHDS_Group::Add (const int theID)
+{
+ const SMDS_MeshElement* aElem = findInMesh (theID);
+ if (!aElem || SMDS_MeshGroup::Contains(aElem))
+ return false;
+ SMDS_MeshGroup::Add (aElem);
+ return true;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+bool SMESHDS_Group::Remove (const int theID)
+{
+ const SMDS_MeshElement* aElem = findInMesh (theID);
+ if (!aElem || !SMDS_MeshGroup::Contains(aElem))
+ return false;
+ SMDS_MeshGroup::Remove (aElem);
+ return true;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+int SMESHDS_Group::GetID (const int theIndex)
+{
+ if (theIndex < 1 || theIndex > Extent())
+ return -1;
+ if (myCurIndex < 1 || myCurIndex > theIndex) {
+ InitIterator();
+ myCurIndex = 0;
+ myCurID = -1;
+ }
+ while (myCurIndex < theIndex && More()) {
+ myCurIndex++;
+ myCurID = Next()->GetID();
+ }
+ return myCurID;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+const SMDS_MeshElement* SMESHDS_Group::findInMesh (const int theID) const
+{
+ SMDSAbs_ElementType aType = GetType();
+ const SMDS_MeshElement* aElem = NULL;
+ if (aType == SMDSAbs_Node) {
+ aElem = GetMesh()->FindNode(theID);
+ }
+ else if (aType != SMDSAbs_All) {
+ aElem = GetMesh()->FindElement(theID);
+ if (aElem && aType != aElem->GetType())
+ aElem = NULL;
+ }
+ return aElem;
+}
--- /dev/null
+// SMESH SMESHDS : management of mesh data and SMESH document
+//
+// Copyright (C) 2004 CEA
+//
+// 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.org
+//
+//
+//
+// File : SMESHDS_Group.hxx
+// Author : Michael Sazonov (OCC)
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESHDS_Group_HeaderFile
+#define _SMESHDS_Group_HeaderFile
+
+#include <SMDS_MeshGroup.hxx>
+#include <string>
+
+class SMESHDS_Mesh;
+
+class SMESHDS_Group : public SMDS_MeshGroup
+{
+ public:
+
+ SMESHDS_Group (const SMESHDS_Mesh* theMesh,
+ const SMDSAbs_ElementType theType);
+
+ void SetStoreName (const char* theName)
+ { myStoreName = theName; }
+
+ const char* GetStoreName () const
+ { return myStoreName.c_str(); }
+
+ bool Contains (const int theID) const;
+
+ bool Add (const int theID);
+ bool Remove (const int theID);
+
+ int GetID (const int theIndex);
+ // use it for iterations 1..Extent() as alternative to parent's
+ // InitIterator(), More(), Next()
+
+ private:
+ SMESHDS_Group (const SMESHDS_Group& theOther);
+ // prohibited copy constructor
+ SMESHDS_Group& operator = (const SMESHDS_Group& theOther);
+ // prohibited assign operator
+
+ const SMDS_MeshElement* findInMesh (const int theID) const;
+
+ string myStoreName;
+ int myCurIndex;
+ int myCurID;
+
+};
+
+#endif
--- /dev/null
+int main(int argc, char** argv){
+ return 0;
+}
+
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 CEA
+//
+// 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.org
+//
+//
+//
+// File : SMESHGUI_CreateHypothesesDlg.cxx
+// Author : Julia DOROVSKIKH
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "SMESHGUI_CreateHypothesesDlg.h"
+#include "SMESHGUI.h"
+#include "SALOME_ListIteratorOfListIO.hxx"
+
+#include "QAD_Application.h"
+#include "QAD_Desktop.h"
+#include "utilities.h"
+
+// QT Includes
+#include <qbuttongroup.h>
+#include <qgroupbox.h>
+#include <qpushbutton.h>
+#include <qlayout.h>
+#include <qlistview.h>
+#include <qheader.h>
+
+//=================================================================================
+// class : SMESHGUI_CreateHypothesesDlg()
+// purpose : Constructs a SMESHGUI_CreateHypothesesDlg which is a child of 'parent', with the
+// name 'name' and widget flags set to 'f'.
+// The dialog will by default be modeless, unless you set 'modal' to
+// TRUE to construct a modal dialog.
+//=================================================================================
+SMESHGUI_CreateHypothesesDlg::SMESHGUI_CreateHypothesesDlg (QWidget* parent,
+ const char* name,
+ bool modal,
+ bool isAlgo)
+ : QDialog( parent, name, modal, WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu | WDestructiveClose ),
+ myIsAlgo( isAlgo )
+{
+ MESSAGE("SMESHGUI_CreateHypothesesDlg");
+
+ if ( !name )
+ setName( "SMESHGUI_CreateHypothesesDlg" );
+ setCaption( isAlgo ? tr( "SMESH_CREATE_ALGORITHMS" ) : tr( "SMESH_CREATE_HYPOTHESES" ) );
+ setSizeGripEnabled( TRUE );
+
+ QGridLayout* SMESHGUI_CreateHypothesesDlgLayout = new QGridLayout( this );
+ SMESHGUI_CreateHypothesesDlgLayout->setSpacing( 6 );
+ SMESHGUI_CreateHypothesesDlgLayout->setMargin( 11 );
+
+ /***************************************************************/
+ GroupAlgorithms = new QGroupBox( this, "GroupAlgorithms" );
+ GroupAlgorithms->setTitle( isAlgo ? tr("SMESH_AVAILABLE_ALGORITHMS") : tr("SMESH_AVAILABLE_HYPOTHESES") );
+ GroupAlgorithms->setColumnLayout(0, Qt::Vertical );
+ GroupAlgorithms->layout()->setSpacing( 0 );
+ GroupAlgorithms->layout()->setMargin( 0 );
+
+ QGridLayout* hypLayout = new QGridLayout( GroupAlgorithms->layout() );
+ hypLayout->setGeometry( QRect( 12, 18, 139, 250 ) );
+ hypLayout->setAlignment( Qt::AlignTop );
+ hypLayout->setSpacing( 6 );
+ hypLayout->setMargin( 11 );
+
+ ListAlgoDefinition = new QListView( GroupAlgorithms, "ListAlgoDefinition" );
+ ListAlgoDefinition->setMinimumSize( 400, 200 );
+ ListAlgoDefinition->addColumn("");
+ ListAlgoDefinition->header()->hide();
+ ListAlgoDefinition->setSelectionMode(QListView::Single);
+ ListAlgoDefinition->setResizeMode(QListView::AllColumns);
+ ListAlgoDefinition->setRootIsDecorated( true );
+
+ hypLayout->addWidget( ListAlgoDefinition, 0, 0 );
+ SMESHGUI_CreateHypothesesDlgLayout->addWidget( GroupAlgorithms, 0, 0 );
+
+ /***************************************************************/
+ GroupButtons = new QGroupBox( this, "GroupButtons" );
+ GroupButtons->setColumnLayout( 0, Qt::Vertical );
+ GroupButtons->layout()->setSpacing( 0 );
+ GroupButtons->layout()->setMargin( 0 );
+ QGridLayout* GroupButtonsLayout = new QGridLayout( GroupButtons->layout() );
+ GroupButtonsLayout->setAlignment( Qt::AlignTop );
+ GroupButtonsLayout->setSpacing( 6 );
+ GroupButtonsLayout->setMargin( 11 );
+
+ buttonApply = new QPushButton( GroupButtons, "buttonApply" );
+ buttonApply->setText( tr( "SMESH_BUT_CREATE" ) );
+ buttonApply->setAutoDefault( TRUE );
+ buttonApply->setDefault( FALSE );
+ buttonApply->setEnabled( FALSE ) ;
+ GroupButtonsLayout->addWidget( buttonApply, 0, 1 );
+
+ QSpacerItem* spacer_9 = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
+ GroupButtonsLayout->addItem( spacer_9, 0, 2 );
+
+ buttonCancel = new QPushButton( GroupButtons, "buttonCancel" );
+ buttonCancel->setText( tr( "SMESH_BUT_CLOSE" ) );
+ buttonCancel->setAutoDefault( TRUE );
+ buttonCancel->setDefault( TRUE );
+ buttonCancel->setEnabled( TRUE ) ;
+ GroupButtonsLayout->addWidget( buttonCancel, 0, 3 );
+
+ SMESHGUI_CreateHypothesesDlgLayout->addWidget( GroupButtons, 1, 0 );
+ /***************************************************************/
+
+ Init();
+}
+
+//=================================================================================
+// function : ~SMESHGUI_CreateHypothesesDlg()
+// purpose : Destroys the object and frees any allocated resources
+//=================================================================================
+SMESHGUI_CreateHypothesesDlg::~SMESHGUI_CreateHypothesesDlg()
+{
+ // no need to delete child widgets, Qt does it all for us
+}
+
+//=================================================================================
+// function : Init()
+// purpose :
+//=================================================================================
+void SMESHGUI_CreateHypothesesDlg::Init()
+{
+ mySMESHGUI = SMESHGUI::GetSMESHGUI() ;
+ mySMESHGUI->SetActiveDialogBox( (QDialog*)this ) ;
+
+ InitAlgoDefinition();
+
+ /* signals and slots connections */
+ connect( buttonCancel, SIGNAL( clicked() ), this, SLOT( ClickOnCancel() ) ) ;
+ connect( buttonApply , SIGNAL( clicked() ), this, SLOT( ClickOnApply() ) ) ;
+
+// connect( mySMESHGUI, SIGNAL ( SignalDeactivateActiveDialog() ), this, SLOT( DeactivateActiveDialog() ) ) ;
+ connect( mySMESHGUI, SIGNAL ( SignalCloseAllDialogs() ), this, SLOT( ClickOnCancel() ) ) ;
+
+ connect( ListAlgoDefinition, SIGNAL( selectionChanged() ), this, SLOT( onSelectionChanged() ) );
+ connect( ListAlgoDefinition, SIGNAL( doubleClicked(QListViewItem*) ), this, SLOT( onDoubleClicked(QListViewItem*) ) );
+
+ int x, y ;
+ mySMESHGUI->DefineDlgPosition( this, x, y ) ;
+ this->move( x, y ) ;
+ this->show() ;
+}
+
+//=================================================================================
+// function : ClickOnCancel()
+// purpose :
+//=================================================================================
+void SMESHGUI_CreateHypothesesDlg::ClickOnCancel()
+{
+ close() ;
+}
+
+//=================================================================================
+// function : ClickOnApply()
+// purpose :
+//=================================================================================
+void SMESHGUI_CreateHypothesesDlg::ClickOnApply()
+{
+ QListViewItem* item = ListAlgoDefinition->selectedItem();
+ if ( !item )
+ return;
+ QString aHypType = item->text( 1 );
+ MESSAGE("Apply " << aHypType);
+ char* sHypType = (char*)aHypType.latin1();
+
+ HypothesisData* aHypData = mySMESHGUI->GetHypothesisData(sHypType);
+ if ( !aHypData )
+ return;
+ QString aClientLibName = aHypData->ClientLibName;
+ MESSAGE("Client lib name = " << aClientLibName);
+
+ if (aClientLibName == "")
+ {
+ // Call hypothesis creation server method (without GUI)
+ QString aHypName = aHypData->Label;
+ mySMESHGUI->CreateHypothesis(sHypType, aHypName, myIsAlgo);
+ }
+ else
+ {
+ // Get hypotheses creator client (GUI)
+ SMESHGUI_GenericHypothesisCreator* aCreator =
+ mySMESHGUI->GetHypothesisCreator(sHypType);
+
+ // Create hypothesis/algorithm
+ aCreator->CreateHypothesis(myIsAlgo, this);
+ }
+
+// buttonApply->setEnabled(FALSE);
+ return;
+}
+
+//=================================================================================
+// function : ActivateThisDialog()
+// purpose :
+//=================================================================================
+void SMESHGUI_CreateHypothesesDlg::ActivateThisDialog()
+{
+ mySMESHGUI->EmitSignalDeactivateDialog() ;
+ GroupButtons->setEnabled(true) ;
+ return ;
+}
+
+//=================================================================================
+// function : enterEvent()
+// purpose :
+//=================================================================================
+void SMESHGUI_CreateHypothesesDlg::enterEvent(QEvent* e)
+{
+ ActivateThisDialog() ;
+ return ;
+}
+
+//=================================================================================
+// function : closeEvent()
+// purpose :
+//=================================================================================
+void SMESHGUI_CreateHypothesesDlg::closeEvent( QCloseEvent* e )
+{
+ mySMESHGUI->ResetState();
+ QDialog::closeEvent( e );
+}
+
+//=================================================================================
+// function : onSelectionChanged()
+// purpose :
+//=================================================================================
+void SMESHGUI_CreateHypothesesDlg::onSelectionChanged()
+{
+ QListViewItem* item = ListAlgoDefinition->selectedItem();
+ buttonApply->setEnabled( item && item->depth() > 0 ) ;
+}
+
+//=================================================================================
+// function : onDoubleClicked()
+// purpose :
+//=================================================================================
+void SMESHGUI_CreateHypothesesDlg::onDoubleClicked(QListViewItem* i)
+{
+ if ( i && i->depth() > 0 )
+ this->ClickOnApply();
+}
+
+//=================================================================================
+// function : InitAlgoDefinition()
+// purpose :
+//=================================================================================
+void SMESHGUI_CreateHypothesesDlg::InitAlgoDefinition()
+{
+ ListAlgoDefinition->clear();
+ QStringList HypList = mySMESHGUI->GetAvailableHypotheses(myIsAlgo);
+ for ( int i = 0; i < HypList.count(); ++i ) {
+ HypothesisData* aHypData = mySMESHGUI->GetHypothesisData( HypList[i] );
+ QListViewItem* parentItem = 0;
+ QListViewItem* childItem = ListAlgoDefinition->firstChild();
+ while ( childItem ) {
+ if ( childItem->text(0) == aHypData->PluginName ) {
+ parentItem = childItem;
+ break;
+ }
+ childItem = childItem->nextSibling();
+ }
+ if ( !parentItem )
+ parentItem = new QListViewItem( ListAlgoDefinition, aHypData->PluginName );
+ parentItem->setOpen( true );
+ QListViewItem* aItem = new QListViewItem( parentItem, aHypData->Label, HypList[i] );
+ QPixmap aPixMap (QAD_Desktop::getResourceManager()->loadPixmap
+ ("SMESH", tr(aHypData->IconId)));
+ if ( !aPixMap.isNull() )
+ aItem->setPixmap( 0, aPixMap );
+ }
+}
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 CEA
+//
+// 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.org
+//
+//
+//
+// File : SMESHGUI_CreateHypothesesDlg.h
+// Author : Julia DOROVSKIKH
+// Module : SMESH
+// $Header$
+
+#ifndef DIALOGBOX_CREATE_HYPOTHESES_H
+#define DIALOGBOX_CREATE_HYPOTHESES_H
+
+// QT Includes
+#include <qvariant.h>
+#include <qdialog.h>
+#include <qstringlist.h>
+
+// IDL Headers
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(GEOM_Gen)
+#include CORBA_SERVER_HEADER(GEOM_Shape)
+#include CORBA_SERVER_HEADER(SMESH_Mesh)
+
+#include <map>
+#include <string>
+
+using namespace std;
+
+class QButtonGroup;
+class QGroupBox;
+class QPushButton;
+class QListView;
+class QListViewItem;
+class SMESHGUI;
+
+//=================================================================================
+// class : SMESHGUI_CreateHypothesesDlg
+// purpose :
+//=================================================================================
+class SMESHGUI_CreateHypothesesDlg : public QDialog
+{
+ Q_OBJECT
+
+public:
+ SMESHGUI_CreateHypothesesDlg (QWidget* parent = 0,
+ const char* name = 0,
+ bool modal = FALSE,
+ bool isAlgo = FALSE);
+ ~SMESHGUI_CreateHypothesesDlg ();
+
+private:
+
+ void Init() ;
+ void closeEvent( QCloseEvent* e ) ;
+ void enterEvent ( QEvent * ) ;
+
+ void InitAlgoDefinition();
+
+ SMESHGUI* mySMESHGUI;
+ bool myIsAlgo;
+
+ QGroupBox* GroupButtons;
+ QPushButton* buttonCancel;
+ QPushButton* buttonApply;
+
+ QGroupBox* GroupAlgorithms;
+ QListView* ListAlgoDefinition;
+
+private slots:
+
+ void ClickOnCancel();
+ void ClickOnApply();
+ void ActivateThisDialog() ;
+
+ void onSelectionChanged();
+ void onDoubleClicked(QListViewItem*);
+};
+
+#endif // DIALOGBOX_CREATE_HYPOTHESES_H
--- /dev/null
+// SMESHGUI_Filter : Filters for VTK viewer
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESHGUI_Filter.cxx
+// Author : Sergey LITONIN
+// Module : SMESH
+
+#include "SMESHGUI_Filter.h"
+
+#include <vtkCell.h>
+
+#include <gp_Vec.hxx>
+#include <Precision.hxx>
+#include "SMESH_Actor.h"
+#include "SMESHGUI.h"
+
+IMPLEMENT_STANDARD_HANDLE(SMESHGUI_Filter, VTKViewer_Filter)
+IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_Filter, VTKViewer_Filter)
+
+/*
+ Class : SMESHGUI_Filter
+ Description : Selection filter for VTK viewer. This class aggregate object
+ of SMESH_Filter class and uses it for verification of criterion
+*/
+
+//=======================================================================
+// name : SMESHGUI_Filter::SMESHGUI_Filter
+// Purpose : Constructor
+//=======================================================================
+SMESHGUI_Filter::SMESHGUI_Filter()
+{
+ myActor = 0;
+}
+
+SMESHGUI_Filter::~SMESHGUI_Filter()
+{
+}
+
+//=======================================================================
+// name : SMESHGUI_Filter::IsValid
+// Purpose : Verify whether entry id satisfies to criterion of the filter
+//=======================================================================
+bool SMESHGUI_Filter::IsValid( const int theCellId ) const
+{
+ if ( myActor == 0 || myPred->_is_nil() )
+ return false;
+
+ SMESH_Actor* anActor = ( SMESH_Actor* )myActor;
+
+ int aMeshId = anActor->GetElemObjId( theCellId );
+
+ return myPred->IsSatisfy( aMeshId );
+}
+
+//=======================================================================
+// name : SMESHGUI_Filter::SetPredicate
+// Purpose : Set new pridicate to the filter
+//=======================================================================
+void SMESHGUI_Filter::SetPredicate( SMESH::Predicate_ptr thePred )
+{
+ myPred = thePred;
+}
+
+//=======================================================================
+// name : SMESHGUI_Filter::GetActor
+// Purpose : Get actor of the filter
+//=======================================================================
+SALOME_Actor* SMESHGUI_Filter::GetActor() const
+{
+ return myActor;
+}
+
+//=======================================================================
+// name : SMESHGUI_Filter::SetActor
+// Purpose : Set new actor
+//=======================================================================
+void SMESHGUI_Filter::SetActor( SALOME_Actor* theActor )
+{
+ if ( myActor == theActor )
+ return;
+ VTKViewer_Filter::SetActor( theActor );
+
+ if ( myActor != 0 && !myPred->_is_nil() )
+ {
+ Handle(SALOME_InteractiveObject) anIO = myActor->getIO();
+ if ( !anIO.IsNull() )
+ {
+ Standard_Boolean aRes = false;
+ SMESH::SMESH_Mesh_ptr aMeshPtr = SMESHGUI::GetSMESHGUI()->ConvertIOinMesh( anIO, aRes );
+ if ( aRes )
+ myPred->SetMesh( aMeshPtr );
+ }
+ }
+}
--- /dev/null
+// SMESHGUI_Filter : Filters for VTK viewer
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESHGUI_Filter.h
+// Author : Sergey LITONIN
+// Module : SMESH
+
+#ifndef SMESHGUI_Filter_HeaderFile
+#define SMESHGUI_Filter_HeaderFile
+
+#include "VTKViewer_Filter.h"\r
+\r
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_Filter)
+
+class SALOME_Actor;
+
+
+DEFINE_STANDARD_HANDLE(SMESHGUI_Filter, VTKViewer_Filter)
+
+/*
+ Class : SMESHGUI_Filter
+ Description : Selection filter for VTK viewer
+*/
+
+class SMESHGUI_Filter : public VTKViewer_Filter
+{
+
+public:
+ SMESHGUI_Filter();
+ virtual ~SMESHGUI_Filter();
+
+ virtual bool IsValid( const int theCellId ) const;
+
+ virtual void SetActor( SALOME_Actor* );
+ SALOME_Actor* GetActor() const;\r
+\r
+ void SetPredicate( SMESH::Predicate_ptr );
+\r
+private:
+\r
+ SMESH::Predicate_var myPred;
+
+public:
+ DEFINE_STANDARD_RTTI(SMESHGUI_Filter)
+};
+
+#endif
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESHGUI_FilterDlg.cxx
+// Author : Sergey LITONIN
+// Module : SMESH
+
+#include "SMESHGUI.h"
+#include "SMESHGUI_FilterDlg.h"
+#include "SMESHGUI_Filter.h"
+#include "SMESH_Actor.h"
+#include "VTKViewer_InteractorStyleSALOME.h"
+#include "VTKViewer_ViewFrame.h"
+#include "QAD_RightFrame.h"
+#include "SALOME_ListIteratorOfListIO.hxx"
+#include "SALOMEGUI_QtCatchCorbaException.hxx"
+
+
+#include <TColStd_MapOfInteger.hxx>
+
+#include <qframe.h>
+#include <qlayout.h>
+#include <qlineedit.h>
+#include <qpushbutton.h>
+#include <qgroupbox.h>
+#include <qtable.h>
+#include <qstringlist.h>
+#include <qlayout.h>
+#include <qwidgetstack.h>
+#include <qapplication.h>
+#include <qcombobox.h>
+#include <qfontmetrics.h>
+#include <qmessagebox.h>
+#include <qlabel.h>
+#include <qbuttongroup.h>
+#include <qradiobutton.h>
+#include <qregexp.h>
+#include <qlistbox.h>
+#include <qcheckbox.h>
+
+#define SPACING 5
+#define MARGIN 10
+
+static int maxLength( const QStringList& theList, const QFontMetrics& theMetrics )
+{
+ int aRes = 0;
+ QStringList::const_iterator anIter;
+ for ( anIter = theList.begin(); anIter != theList.end(); ++anIter )
+ aRes = Max( aRes, theMetrics.width( *anIter ) );
+ return aRes;
+}
+
+/*
+ Class : SMESHGUI_FilterDlg::Table
+ Description : Table used by this dialog
+*/
+
+class SMESHGUI_FilterDlg::Table : public QTable
+{
+public:
+ Table( QWidget* parent = 0 );
+ Table( int numRows, int numCols, QWidget* parent = 0 );
+ virtual ~Table();
+
+ void SetEditable( const bool state, const int row, const int col );
+ bool IsEditable( const int row, const int col ) const;
+
+ virtual bool eventFilter( QObject *o, QEvent *e );
+ virtual void insertRows( int row, int count = 1 );
+ virtual QString text( int row, int col ) const;
+};
+
+SMESHGUI_FilterDlg::Table::Table( QWidget* parent )
+: QTable( parent, "SMESHGUI_FilterDlg::Table" )
+{
+}
+
+SMESHGUI_FilterDlg::Table::Table( int numRows, int numCols, QWidget* parent )
+: QTable( numRows, numCols, parent, "SMESHGUI_FilterDlg::Table" )
+{
+}
+
+SMESHGUI_FilterDlg::Table::~Table()
+{
+}
+
+void SMESHGUI_FilterDlg::Table::SetEditable( const bool isEditable, const int row, const int col )
+{
+ QTableItem* anItem = item( row, col );
+ if( anItem )
+ takeItem( anItem );
+
+ if ( !isEditable )
+ {
+ setItem( row, col, new QTableItem( this, QTableItem::Never, "" ) );
+ }
+ else
+ {
+ setItem( row, col, new QTableItem( this, QTableItem::OnTyping, "" ) );
+ }
+}
+
+bool SMESHGUI_FilterDlg::Table::IsEditable( const int row, const int col ) const
+{
+ QTableItem* anItem = item( row, col );
+ return anItem == 0 || anItem->editType() != QTableItem::Never;
+}
+
+void SMESHGUI_FilterDlg::Table::insertRows( int row, int count )
+{
+ int anEditRow = currEditRow();
+ int anEditCol = currEditCol();
+
+// printf( "sln: anEditRow = %d, anEditCol = %d\n", anEditRow, anEditCol );
+
+ if ( anEditRow >= 0 && anEditCol >= 0 )
+ endEdit( anEditRow, anEditCol, true, false );
+
+ QTable::insertRows( row, count );
+}
+
+QString SMESHGUI_FilterDlg::Table::text( int row, int col ) const
+{
+ int anEditRow = currEditRow();
+ int anEditCol = currEditCol();
+
+ if ( anEditRow >= 0 && anEditCol >= 0 && anEditRow == row && anEditCol == col )
+ ((Table*)this)->endEdit( row, col, true, false );
+
+ return QTable::text( row, col );
+}
+
+bool SMESHGUI_FilterDlg::Table::eventFilter( QObject *o, QEvent *e )
+{
+ return QTable::eventFilter( o, e );
+}
+
+/*
+ Class : SMESHGUI_FilterDlg
+ Description : Dialog to specify filters for VTK viewer
+*/
+
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::SMESHGUI_FilterDlg
+// Purpose : Constructor
+//=======================================================================
+SMESHGUI_FilterDlg::SMESHGUI_FilterDlg( QWidget* theParent,
+ const int theType,
+ const bool theModal,
+ const char* theName )
+: QDialog( theParent, theName, theModal,
+ WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu )
+{
+ myType = theType;
+
+ setCaption( tr( "CAPTION" ) );
+
+ QVBoxLayout* aDlgLay = new QVBoxLayout( this, MARGIN, SPACING );
+
+ myMainFrame = createMainFrame ( this );
+ QFrame* aBtnFrame = createButtonFrame( this, theModal );
+
+ aDlgLay->addWidget( myMainFrame );
+ aDlgLay->addWidget( aBtnFrame );
+
+ aDlgLay->setStretchFactor( myMainFrame, 1 );
+
+ Init( myType );
+}
+
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::createMainFrame
+// Purpose : Create frame containing dialog's input fields
+//=======================================================================
+QFrame* SMESHGUI_FilterDlg::createMainFrame( QWidget* theParent )
+{
+ QGroupBox* aMainFrame = new QGroupBox( 1, Qt::Horizontal, theParent );
+ aMainFrame->setFrameStyle( QFrame::NoFrame );
+ aMainFrame->setInsideMargin( 0 );
+
+ // filter frame
+
+ QGroupBox* aFilterGrp = new QGroupBox( 1, Qt::Horizontal, tr ( "Filter" ), aMainFrame );
+ QFrame* aFilterFrame = new QFrame( aFilterGrp );
+
+ myTableGrp = new QGroupBox( 1, Qt::Horizontal, aFilterFrame );
+ myTableGrp->setFrameStyle( QFrame::NoFrame );
+ myTableGrp->setInsideMargin( 0 );
+
+ myTables[ myType ] = createTable( myTableGrp, myType );
+ myAddBtn = new QPushButton( tr( "ADD" ), aFilterFrame );
+ myRemoveBtn = new QPushButton( tr( "REMOVE" ), aFilterFrame );
+ myClearBtn = new QPushButton( tr( "CLEAR" ), aFilterFrame );
+
+ QGridLayout* aLay = new QGridLayout( aFilterFrame, 4, 2, 0, SPACING );
+
+ aLay->addMultiCellWidget( myTableGrp, 0, 3, 0, 0 );
+ aLay->addWidget( myAddBtn, 0, 1 );
+ aLay->addWidget( myRemoveBtn, 1, 1 );
+ aLay->addWidget( myClearBtn, 2, 1 );
+ aLay->setColStretch( 0, 1 );
+ aLay->setColStretch( 1, 0 );
+
+ mySetInViewer = new QCheckBox( tr( "SET_IN_VIEWER" ), aFilterGrp );
+ mySetInViewer->setChecked( true );
+
+ QSpacerItem* aVSpacer = new QSpacerItem( 0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding );
+ aLay->addItem( aVSpacer, 3, 1 );
+
+ // other controls
+ mySourceGrp = createSourceGroup( aMainFrame );
+
+ // signals and slots
+ connect( myAddBtn, SIGNAL( clicked() ), this, SLOT( onAddBtn() ) );
+ connect( myRemoveBtn, SIGNAL( clicked() ), this, SLOT( onRemoveBtn() ) );
+ connect( myClearBtn, SIGNAL( clicked() ), this, SLOT( onClearBtn() ) );
+
+ return aMainFrame;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::createSourceFrame
+// Purpose : Create frame containing source radio button
+//=======================================================================
+QButtonGroup* SMESHGUI_FilterDlg::createSourceGroup( QWidget* theParent )
+{
+ QButtonGroup* aGrp = new QButtonGroup( 1, Qt::Vertical, tr( "SOURCE" ), theParent );
+
+ QRadioButton* aMeshBtn = new QRadioButton( tr( "MESH" ), aGrp );
+ QRadioButton* aSelBtn = new QRadioButton( tr( "SELECTION" ), aGrp );
+ QRadioButton* aGrpBtn = new QRadioButton( tr( "CURRENT_GROUP" ), aGrp );
+// QRadioButton* aNoneBtn = new QRadioButton( tr( "NONE" ), aGrp );
+
+ aGrp->insert( aMeshBtn, Mesh );
+ aGrp->insert( aSelBtn, Selection );
+ aGrp->insert( aGrpBtn, Dialog );
+// aGrp->insert( aNoneBtn, None );
+
+ aGrp->setButton( Selection );
+
+ return aGrp;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::createTable
+// Purpose : Create table
+//=======================================================================
+SMESHGUI_FilterDlg::Table* SMESHGUI_FilterDlg::createTable( QWidget* theParent,
+ const int theType )
+{
+ // create table
+ Table* aTable= new Table( 0, 5, theParent );
+
+ QHeader* aHeaders = aTable->horizontalHeader();
+
+ QFontMetrics aMetrics( aHeaders->font() );
+
+ int aLenCr = abs( maxLength( getCriteria( theType ), aMetrics ) -
+ aMetrics.width( tr( "CRITERION" ) ) ) / aMetrics.width( ' ' ) + 5;
+
+ int aLenCo = abs( maxLength( getCriteria( theType ), aMetrics ) -
+ aMetrics.width( tr( "COMPARE" ) ) ) / aMetrics.width( ' ' ) + 5;
+
+ QString aCrStr;
+ aCrStr.fill( ' ', aLenCr );
+ QString aCoStr;
+ aCoStr.fill( ' ', 10 );
+
+ aHeaders->setLabel( 0, tr( "CRITERION" ) + aCrStr );
+ aHeaders->setLabel( 1, tr( "COMPARE" ) + aCoStr );
+ aHeaders->setLabel( 2, tr( "THRESHOLD_VALUE" ) );
+ aHeaders->setLabel( 3, tr( "UNARY" ) );
+ aHeaders->setLabel( 4, tr( "BINARY" ) + " " );
+
+ // set geometry of the table
+
+ for ( int i = 0; i <= 4; i++ )
+ aTable->adjustColumn( i );
+
+ aTable->updateGeometry();
+ QSize aSize = aTable->sizeHint();
+ int aWidth = aSize.width();
+ aTable->setMinimumSize( QSize( aWidth, aWidth / 2 ) );
+ aTable->setSizePolicy( QSizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding) );
+
+ if ( theType == SMESH::EDGE )
+ connect( aTable, SIGNAL( valueChanged( int, int ) ),
+ this, SLOT( onCriterionChanged( int, int ) ) );
+
+ return aTable;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::createButtonFrame
+// Purpose : Create frame containing buttons
+//=======================================================================
+QFrame* SMESHGUI_FilterDlg::createButtonFrame( QWidget* theParent, const bool theModal )
+{
+ QGroupBox* aGrp = new QGroupBox( 1, Qt::Vertical, theParent );
+
+ myOkBtn = new QPushButton( tr( "SMESH_BUT_OK" ), aGrp );
+ myApplyBtn = new QPushButton( tr( "SMESH_BUT_APPLY" ), aGrp );
+ QLabel* aLbl = new QLabel( aGrp );
+ myCloseBtn = new QPushButton( tr( "SMESH_BUT_CANCEL" ), aGrp );
+
+ aLbl->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
+
+ connect( myOkBtn, SIGNAL( clicked() ), SLOT( onOk() ) );
+ connect( myCloseBtn, SIGNAL( clicked() ), SLOT( onClose() ) ) ;
+ connect( myApplyBtn, SIGNAL( clicked() ), SLOT( onApply() ) );
+
+ if ( theModal )
+ myApplyBtn->hide();
+
+ return aGrp;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::~SMESHGUI_FilterDlg
+// Purpose : Destructor
+//=======================================================================
+SMESHGUI_FilterDlg::~SMESHGUI_FilterDlg()
+{
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::Init
+// Purpose : Init dialog fields, connect signals and slots, show dialog
+//=======================================================================
+void SMESHGUI_FilterDlg::Init( const int theType )
+{
+ mySourceWg = 0;
+ mySelection = 0;
+ myType = theType;
+ myMesh = SMESH::SMESH_Mesh::_nil();
+
+ // activate corresponding tab
+ if ( !myTables.contains( myType ) )
+ myTables[ myType ] = createTable( myTableGrp, myType );
+
+ TableMap::iterator anIter;
+ for ( anIter = myTables.begin(); anIter != myTables.end(); ++anIter )
+ if ( anIter.key() == theType )
+ anIter.data()->show();
+ else
+ anIter.data()->hide();
+
+ // set caption
+ setCaption( myType == SMESH::EDGE ? tr( "EDGES_TLT" ) : tr( "FACES_TLT" ) );
+
+ qApp->processEvents();
+ updateGeometry();
+ adjustSize();
+ setEnabled( true );
+
+ mySMESHGUI = SMESHGUI::GetSMESHGUI() ;
+ mySMESHGUI->SetActiveDialogBox( ( QDialog* )this ) ;
+
+ connect( mySMESHGUI, SIGNAL( SignalDeactivateActiveDialog() ), SLOT( onDeactivate() ) );
+ connect( mySMESHGUI, SIGNAL( SignalCloseAllDialogs() ), SLOT( onClose() ) );
+
+ int x, y ;
+ mySMESHGUI->DefineDlgPosition( this, x, y );
+ this->move( x, y );
+
+ this->show();
+
+ return;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::onOk
+// Purpose : SLOT called when "Ok" button pressed.
+// Assign filters VTK viewer and close dialog
+//=======================================================================
+void SMESHGUI_FilterDlg::onOk()
+{
+ if ( onApply() )
+ {
+ disconnect( mySMESHGUI, 0, this, 0 );
+ mySMESHGUI->ResetState() ;
+ accept();
+ }
+
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::onClose
+// Purpose : SLOT called when "Close" button pressed. Close dialog
+//=======================================================================
+void SMESHGUI_FilterDlg::onClose()
+{
+ disconnect( mySMESHGUI, 0, this, 0 );
+ mySMESHGUI->ResetState() ;
+ reject() ;
+ return ;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::onDeactivate
+// Purpose : SLOT called when dialog must be deativated
+//=======================================================================
+void SMESHGUI_FilterDlg::onDeactivate()
+{
+ setEnabled( false );
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::enterEvent
+// Purpose : Event filter
+//=======================================================================
+void SMESHGUI_FilterDlg::enterEvent( QEvent* )
+{
+// mySMESHGUI->EmitSignalDeactivateDialog();
+ setEnabled( true );
+}
+
+
+//=================================================================================
+// function : closeEvent()
+// purpose :
+//=================================================================================
+void SMESHGUI_FilterDlg::closeEvent( QCloseEvent* e )
+{
+ onClose() ;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::getCriteria
+// Purpose : Retrieve list of ids from given widget
+//=======================================================================
+void SMESHGUI_FilterDlg::getIdsFromWg( const QWidget* theWg, QValueList<int>& theRes ) const
+{
+ theRes.clear();
+ if ( theWg == 0 )
+ return;
+
+ if ( theWg->inherits( "QListBox" ) )
+ {
+ QListBox* aListBox = ( QListBox* )theWg;
+ bool b;
+ for ( int i = 0, n = aListBox->count(); i < n; i++ )
+ {
+ int anId = aListBox->text( i ).toInt( &b );
+ if ( b )
+ theRes.append( anId );
+ }
+ }
+ else if ( theWg->inherits( "QLineEdit" ) )
+ {
+ QLineEdit* aLineEdit = ( QLineEdit* )theWg;
+ QString aStr = aLineEdit->text();
+ QRegExp aRegExp( "(\\d+)" );
+ bool b;
+ int aPos = 0;
+ while ( aPos >= 0 )
+ {
+ aPos = aRegExp.search( aStr, aPos );
+ if ( aPos > -1 )
+ {
+ int anId = aRegExp.cap( 1 ).toInt( &b );
+ if ( b )
+ theRes.append( anId );
+ aPos += aRegExp.matchedLength();
+ }
+ }
+ }
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::getSelMode
+// Purpose : Get criteria for specified type
+//=======================================================================
+Selection_Mode SMESHGUI_FilterDlg::getSelMode( const int theType ) const
+{
+ switch ( theType )
+ {
+ case SMESH::NODE : return NodeSelection;
+ case SMESH::EDGE : return EdgeSelection;
+ case SMESH::FACE : return FaceSelection;
+ case SMESH::VOLUME : return VolumeSelection;
+ default : return ActorSelection;
+ }
+
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::getCriteria
+// Purpose : Get criteria for specified type
+//=======================================================================
+void SMESHGUI_FilterDlg::setIdsToWg( QWidget* theWg, const QValueList<int>& theIds )
+{
+ if ( theWg == 0 )
+ return;
+
+ if ( theWg->inherits( "QListBox" ) )
+ {
+ QListBox* aListBox = ( QListBox* )theWg;
+ aListBox->clear();
+
+ QStringList aStrList;
+ QValueList<int>::const_iterator anIter;
+ for ( anIter = theIds.begin(); anIter != theIds.end(); ++anIter )
+ aStrList.append( QString( "%1" ).arg( *anIter ) );
+
+ aListBox->insertStringList( aStrList );
+ }
+ else if ( theWg->inherits( "QLineEdit" ) )
+ {
+ QLineEdit* aLineEdit = ( QLineEdit* )theWg;
+ QString aStr;
+ QValueList<int>::const_iterator anIter;
+
+ for ( anIter = theIds.begin(); anIter != theIds.end(); ++ anIter )
+ aStr += QString( "%1 " ).arg( *anIter );
+
+ if ( !aStr.isEmpty() )
+ aStr.remove( aStr.length() - 1, 1 );
+
+ aLineEdit->setText( aStr );
+ }
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::getCriteria
+// Purpose : Get criteria for specified type
+//=======================================================================
+const QStringList& SMESHGUI_FilterDlg::getCriteria( const int theType ) const
+{
+ if ( theType == SMESH::EDGE )
+ {
+ static QStringList aCriteria;
+ if ( aCriteria.isEmpty() )
+ {
+ aCriteria.append( tr( "FREE_BORDERS" ) );
+ aCriteria.append( tr( "MULTI_BORDERS" ) );
+ aCriteria.append( tr( "LENGTH" ) );
+ }
+ return aCriteria;
+ }
+ else if ( theType == SMESH::FACE )
+ {
+ static QStringList aCriteria;
+ if ( aCriteria.isEmpty() )
+ {
+ aCriteria.append( tr( "ASPECT_RATIO" ) );
+ aCriteria.append( tr( "WARPING" ) );
+ aCriteria.append( tr( "MINIMUM_ANGLE" ) );
+ aCriteria.append( tr( "TAPER" ) );
+ aCriteria.append( tr( "SKEW" ) );
+ aCriteria.append( tr( "AREA" ) );
+ }
+ return aCriteria;
+ }
+ else
+ {
+ static QStringList aCriteria;
+ return aCriteria;
+ }
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::getCompare
+// Purpose : Get operation of comparison
+//=======================================================================
+const QStringList& SMESHGUI_FilterDlg::getCompare () const
+{
+ static QStringList aList;
+
+ if ( aList.isEmpty() )
+ {
+ aList.append( tr( "LESS_THAN" ) );
+ aList.append( tr( "MORE_THAN" ) );
+ aList.append( tr( "EQUAL_TO" ) );
+ }
+
+ return aList;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::getCriterionItem
+// Purpose : Get combo table item for criteria of specified type
+//=======================================================================
+QTableItem* SMESHGUI_FilterDlg::getCriterionItem( QTable* theParent , const int theType )
+{
+ return new QComboTableItem( theParent, getCriteria( theType ) );
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::getCompareItem
+// Purpose : Get combo table item for operation of comparision
+//=======================================================================
+QTableItem* SMESHGUI_FilterDlg::getCompareItem( QTable* theParent )
+{
+ return new QComboTableItem( theParent, getCompare() );
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::getLogOpItem
+// Purpose :
+//=======================================================================
+QTableItem* SMESHGUI_FilterDlg::getLogOpItem( QTable* theParent )
+{
+ static QStringList aList;
+ if ( aList.isEmpty() )
+ {
+ aList.append( tr( "AND" ) );
+ aList.append( tr( "OR" ) );
+ }
+
+ return new QComboTableItem( theParent, aList );
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::getNotItem
+// Purpose : Get check table item
+//=======================================================================
+QTableItem* SMESHGUI_FilterDlg::getNotItem( QTable* theParent )
+{
+ return new QCheckTableItem( theParent, tr( "NOT" ) );
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::getCurrType
+// Purpose : Get current entity type
+//=======================================================================
+int SMESHGUI_FilterDlg::getCurrType() const
+{
+ return myType;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::getCriterion
+// Purpose :
+//=======================================================================
+int SMESHGUI_FilterDlg::getCriterion( const int theType, const int theRow ) const
+{
+ QComboTableItem* anItem = ( QComboTableItem* )myTables[ getCurrType() ]->item( theRow, 0 );
+ return anItem->currentItem();
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::addRow
+// Purpose :
+//=======================================================================
+void SMESHGUI_FilterDlg::addRow( Table* theTable, const int theType )
+{
+ theTable->insertRows( theTable->numRows() );
+ int aCurrRow = theTable->numRows() - 1;
+
+ // Criteria
+ theTable->setItem( aCurrRow, 0, getCriterionItem( theTable, theType ) );
+
+ // Compare
+ theTable->setItem( aCurrRow, 1, getCompareItem( theTable ) );
+
+ //Logical operation NOT
+ theTable->setItem( aCurrRow, 3, getNotItem( theTable ) );
+
+ // Logical binary operation for previous value
+ if ( aCurrRow > 0 )
+ theTable->setItem( aCurrRow - 1, 4, getLogOpItem( theTable ) );
+ theTable->SetEditable( false, aCurrRow, 4 );
+
+ onCriterionChanged( aCurrRow, 0 );
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::onAddBtn
+// Purpose : SLOT. Called then "Add" button pressed.
+// Adds new string to table
+//=======================================================================
+void SMESHGUI_FilterDlg::onAddBtn()
+{
+ // QTable
+ int aType = getCurrType();
+ Table* aTable = myTables[ aType ];
+
+ addRow( aTable, aType );
+
+ updateBtnState();
+
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::onCriterionChanged()
+// Purpose : SLOT. Called then contents of table changed
+// Provides reaction on change of criterion
+//=======================================================================
+void SMESHGUI_FilterDlg::onCriterionChanged( int row, int col )
+{
+ int aType = getCurrType();
+ if ( aType != SMESH::EDGE || col != 0 )
+ return;
+
+ Table* aTable = myTables[ aType ];
+ QComboTableItem* aCompareItem = (QComboTableItem*)aTable->item( row, 1 );
+
+ if ( getCriterion( aType, row ) != FreeBorders )
+ {
+ if ( aCompareItem->count() == 0 )
+ aCompareItem->setStringList( getCompare() );
+
+ QString aText = aTable->text( row, 2 );
+ aTable->SetEditable( true, row, 2 );
+ aTable->setText( row, 2, aText );
+ }
+ else
+ {
+ if ( aCompareItem->count() > 0 )
+ aCompareItem->setStringList( QStringList() );
+ aTable->SetEditable( false, row, 2 );
+ }
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::onRemoveBtn
+// Purpose : SLOT. Called then "Remove" button pressed.
+// Removes current string from table
+//=======================================================================
+void SMESHGUI_FilterDlg::onRemoveBtn()
+{
+ Table* aTable = myTables[ getCurrType() ];
+
+ if ( aTable->numRows() == 0 )
+ return;
+
+ QMemArray<int> aRows;
+ for ( int i = 0, n = aTable->numRows(); i < n; i++ )
+ {
+ if ( aTable->isRowSelected( i ) )
+ {
+ aRows.resize( aRows.size() + 1 );
+ aRows[ aRows.size() - 1 ] = i;
+ }
+ }
+
+ aTable->removeRows( aRows );
+
+ // remove control of binary logical operation from last row
+ if ( aTable->numRows() > 0 )
+ aTable->SetEditable( false, aTable->numRows() - 1, 4 );
+
+ updateBtnState();
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::onClearBtn
+// Purpose : SLOT. Called then "Clear" button pressed.
+// Removes all strings from table
+//=======================================================================
+void SMESHGUI_FilterDlg::onClearBtn()
+{
+ QTable* aTable = myTables[ getCurrType() ];
+
+ if ( aTable->numRows() == 0 )
+ return;
+
+ while ( aTable->numRows() > 0 )
+ aTable->removeRow( 0 );
+
+ updateBtnState();
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::updateBtnState
+// Purpose : Update button state
+//=======================================================================
+void SMESHGUI_FilterDlg::updateBtnState()
+{
+ myRemoveBtn->setEnabled( myTables[ getCurrType() ]->numRows() > 0 );
+ myClearBtn->setEnabled( myTables[ getCurrType() ]->numRows() > 0 );
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::isValid
+// Purpose : Verify validity of input data
+//=======================================================================
+bool SMESHGUI_FilterDlg::isValid() const
+{
+ Table* aTable = myTables[ getCurrType() ];
+ for ( int i = 0, n = aTable->numRows(); i < n; i++ )
+ {
+ bool isEditable = aTable->IsEditable( i ,2 );
+ bool aRes = false;
+ int aThreshold = ( int )aTable->text( i, 2 ).toDouble( &aRes );
+ if ( isEditable && !aRes )
+ {
+ QMessageBox::information( mySMESHGUI->GetDesktop(),
+ tr( "SMESH_INSUFFICIENT_DATA" ), tr( "ERROR" ),
+ QMessageBox::Ok );
+ return false;
+ }
+ else if ( getCurrType() == SMESH::EDGE &&
+ getCriterion( SMESH::EDGE, i ) == MultiBorders &&
+ aThreshold == 1 )
+ {
+ QMessageBox::information( mySMESHGUI->GetDesktop(),
+ tr( "SMESH_INSUFFICIENT_DATA" ), tr( "MULTIEDGES_ERROR" ),
+ QMessageBox::Ok );
+ return false;
+ }
+ }
+
+ return true;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::GetResultIds
+// Purpose : Get filtered ids
+//=======================================================================
+/*void SMESHGUI_FilterDlg::GetResultIds( SMESH::SMESH_Mesh_ptr theMesh,
+ QValueList<int>& theIds ) const
+{
+ if ( !myPredicate->_is_nil() )
+ theIds = myInputIds;
+ else
+ myPredicate->SetMesh( theMesh );
+
+ theIds.clear();
+ QValueList<int>::const_iterator anIter;
+ for ( anIter = myInputIds.begin(); anIter != myInputIds.end(); ++anIter )
+ if ( myPredicate->IsSatisfy( *anIter ) )
+ theIds.append( *anIter );
+}
+*/
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::SetSourceWg
+// Purpose : Set widget of parent dialog containing idsto be filtered if
+// user select corresponding source radio button
+//=======================================================================
+void SMESHGUI_FilterDlg::SetSourceWg( QWidget* theWg )
+{
+ mySourceWg = theWg;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::SetGroupIds
+// Purpose : Set mesh
+//=======================================================================
+void SMESHGUI_FilterDlg::SetMesh( SMESH::SMESH_Mesh_ptr theMesh )
+{
+ myMesh = theMesh;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::SetSelection
+// Purpose : Get filtered ids
+//=======================================================================
+void SMESHGUI_FilterDlg::SetSelection( SALOME_Selection* theSel )
+{
+ mySelection = theSel;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::onApply
+// Purpose : SLOT called when "Apply" button pressed.
+// Assign filters to VTK viewer
+//=======================================================================
+bool SMESHGUI_FilterDlg::onApply()
+{
+ if ( !isValid() )
+ return false;
+
+ try
+ {
+ int aCurrType = getCurrType();
+
+ SMESH::Predicate_ptr aPredicate = createPredicate( aCurrType );
+
+ if ( mySetInViewer->isChecked() )
+ insertFilterInViewer( aPredicate );
+
+ if ( !aPredicate->_is_nil() )
+ {
+ QValueList<int> aResultIds;
+ filterSource( aCurrType, aPredicate, aResultIds );
+ selectInViewer( aCurrType, aResultIds );
+ }
+ }
+ catch( const SALOME::SALOME_Exception& S_ex )
+ {
+ QtCatchCorbaException( S_ex );
+ }
+ catch( ... )
+ {
+ }
+
+ return true;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::createPredicate
+// Purpose : Create predicate for given type
+//=======================================================================
+SMESH::Predicate_ptr SMESHGUI_FilterDlg::createPredicate( const int theType )
+{
+ SMESH::FilterManager_ptr aFilterMgr = mySMESHGUI->GetFilterMgr();
+ if ( aFilterMgr->_is_nil() )
+ return SMESH::Predicate::_nil();
+
+ QTable* aTable = myTables[ theType ];
+ if ( aTable == 0 )
+ return SMESH::Predicate::_nil();
+
+ // CREATE two lists ( PREDICATES and LOG OP )
+
+ // Criterion
+ QValueList<SMESH::Predicate_ptr> aPredicates;
+ QValueList<int> aLogOps;
+ for ( int i = 0, n = aTable->numRows(); i < n; i++ )
+ {
+ int aCriterion = getCriterion( theType, i );
+
+ SMESH::Predicate_ptr aPredicate = SMESH::Predicate::_nil();
+ SMESH::NumericalFunctor_ptr aFunctor = SMESH::NumericalFunctor::_nil();
+
+ if ( theType == SMESH::EDGE )
+ {
+ switch ( aCriterion )
+ {
+ case FreeBorders:
+ aPredicate = aFilterMgr->CreateFreeBorders();
+ break;
+ case MultiBorders:
+ aFunctor = aFilterMgr->CreateMultiConnection();
+ break;
+ case Length:
+ aFunctor = aFilterMgr->CreateLength();
+ break;
+ default:
+ continue;
+ }
+ }
+ else
+ {
+ switch ( aCriterion )
+ {
+ case AspectRatio:
+ aFunctor = aFilterMgr->CreateAspectRatio();
+ break;
+ case Warping:
+ aFunctor = aFilterMgr->CreateWarping();
+ break;
+ case MinimumAngle:
+ aFunctor = aFilterMgr->CreateMinimumAngle();
+ break;
+ case Taper:
+ aFunctor = aFilterMgr->CreateTaper();
+ break;
+ case Skew:
+ aFunctor = aFilterMgr->CreateSkew();
+ break;
+ case Area:
+ aFunctor = aFilterMgr->CreateArea();
+ break;
+ default:
+ continue;
+ }
+ }
+
+ // Comparator
+ if ( !aFunctor->_is_nil() && aPredicate->_is_nil() )
+ {
+ QComboTableItem* aCombo = (QComboTableItem*)aTable->item( i, 1 );
+ int aCompareOp = aCombo->currentItem();
+ double aThreshold = aTable->text( i, 2 ).toDouble();
+
+ SMESH::Comparator_ptr aComparator = SMESH::Comparator::_nil();
+
+ if ( aCompareOp == LessThan )
+ aComparator = aFilterMgr->CreateLessThan();
+ else if ( aCompareOp == MoreThan )
+ aComparator = aFilterMgr->CreateMoreThan();
+ else if ( aCompareOp == EqualTo )
+ aComparator = aFilterMgr->CreateEqualTo();
+ else
+ continue;
+
+ aComparator->SetNumFunctor( aFunctor );
+ aComparator->SetMargin( aThreshold );
+
+ aPredicate = aComparator;
+ }
+
+ // Logical not
+ QCheckTableItem* anItem = (QCheckTableItem*)aTable->item( i, 3 );
+ if ( anItem->isChecked() )
+ {
+ SMESH::LogicalNOT_ptr aNotPred = aFilterMgr->CreateLogicalNOT();
+ aNotPred->SetPredicate( aPredicate );
+ aPredicate = aNotPred;
+ }
+
+ // logical op
+ int aLogOp = ( i == n - 1 ) ? LO_Undefined
+ : ( (QComboTableItem*)aTable->item( i, 4 ) )->currentItem();
+ aPredicates.append( aPredicate );
+ aLogOps.append( aLogOp );
+
+ } // for
+
+ // CREATE ONE PREDICATE FROM PREVIOUSLY CREATED MAP
+
+ // combine all "AND" operations
+
+ QValueList<SMESH::Predicate_ptr> aResList;
+
+ QValueList<SMESH::Predicate_ptr>::iterator aPredIter;
+ QValueList<int>::iterator aLogOpIter;
+
+ SMESH::Predicate_ptr aPrevPredicate = SMESH::Predicate::_nil();
+ int aPrevLogOp = LO_Undefined;
+
+ for ( aPredIter = aPredicates.begin(), aLogOpIter = aLogOps.begin();
+ aPredIter != aPredicates.end() && aLogOpIter != aLogOps.end();
+ ++aPredIter, ++aLogOpIter )
+ {
+ int aCurrLogOp = *aLogOpIter;
+
+ SMESH::Predicate_ptr aCurrPred = SMESH::Predicate::_nil();
+
+ if ( aPrevLogOp == LO_And )
+ {
+
+ SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalAND();
+ aBinaryPred->SetPredicate1( aPrevPredicate );
+ aBinaryPred->SetPredicate2( *aPredIter );
+ aCurrPred = aBinaryPred;
+ }
+ else
+ aCurrPred = *aPredIter;
+
+ if ( aCurrLogOp != LO_And )
+ aResList.append( aCurrPred );
+
+ aPrevPredicate = aCurrPred;
+ aPrevLogOp = aCurrLogOp;
+ }
+
+ // combine all "OR" operations
+
+ SMESH::Predicate_ptr aResPredicate = SMESH::Predicate::_nil();
+
+ if ( aResList.count() == 1 )
+ aResPredicate = aResList.first();
+ else if ( aResList.count() > 1 )
+ {
+ QValueList<SMESH::Predicate_ptr>::iterator anIter = aResList.begin();
+ aResPredicate = *anIter;
+ anIter++;
+ for ( ; anIter != aResList.end(); ++anIter )
+ {
+ SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalOR();
+ aBinaryPred->SetPredicate1( aResPredicate );
+ aBinaryPred->SetPredicate2( *anIter );
+ aResPredicate = aBinaryPred;
+ }
+ }
+
+ return aResPredicate;
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::insertFilterInViewer
+// Purpose : Insert filter in viewer
+//=======================================================================
+void SMESHGUI_FilterDlg::insertFilterInViewer( SMESH::Predicate_ptr thePred )
+{
+ VTKViewer_InteractorStyleSALOME* aStyle = ((VTKViewer_ViewFrame*)mySMESHGUI->GetActiveStudy()->
+ getActiveStudyFrame()->getRightFrame()->getViewFrame())->
+ getRWInteractor()->GetInteractorStyleSALOME();
+
+ if ( thePred->_is_nil() )
+ {
+ if ( myType == SMESH::EDGE )
+ aStyle->RemoveEdgeFilter();
+ else if ( myType == SMESH::FACE )
+ aStyle->RemoveFaceFilter();
+ }
+ else
+ {
+ Handle(SMESHGUI_Filter) aFilter = new SMESHGUI_Filter();
+ aFilter->SetPredicate( thePred );
+ if ( myType == SMESH::EDGE )
+ aStyle->SetEdgeFilter( aFilter );
+ else if ( myType == SMESH::FACE )
+ aStyle->SetFaceFilter( aFilter );
+ }
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::filterSource
+// Purpose : Filter source ids
+//=======================================================================
+void SMESHGUI_FilterDlg::filterSource( const int theType,
+ SMESH::Predicate_ptr thePred,
+ QValueList<int>& theResIds )
+{
+ theResIds.clear();
+
+ int aSourceId = mySourceGrp->id( mySourceGrp->selected() );
+
+ if ( aSourceId == Mesh )
+ {
+ if ( myMesh->_is_nil() )
+ return;
+ SMESH::FilterManager_ptr aFilterMgr = mySMESHGUI->GetFilterMgr();
+ SMESH::Filter_var aFilter = aFilterMgr->CreateFilter();
+ aFilter->SetPredicate( thePred );
+ SMESH::long_array_var anIds = aFilter->GetElementsId( myMesh );
+ for ( int i = 0, n = anIds->length(); i < n; i++ )
+ theResIds.append( anIds[ i ] );
+ }
+ else if ( aSourceId == Selection )
+ {
+ filterSelectionSource( theType, thePred, theResIds );
+ }
+ else if ( aSourceId == Dialog )
+ {
+ // retrieve ids from dialog
+ QValueList<int> aDialogIds;
+ getIdsFromWg( mySourceWg, aDialogIds );
+
+ if ( myMesh->_is_nil() )
+ {
+ theResIds = aDialogIds;
+ return;
+ }
+
+ // filter ids
+ thePred->SetMesh( myMesh );
+ QValueList<int>::const_iterator anIter;
+ for ( anIter = aDialogIds.begin(); anIter != aDialogIds.end(); ++ anIter )
+ if ( thePred->IsSatisfy( *anIter ) )
+ theResIds.append( *anIter );
+
+ // set ids to the dialog
+ setIdsToWg( mySourceWg, theResIds );
+ }
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::filterSelectionSource
+// Purpose : Filter source selection
+//=======================================================================
+void SMESHGUI_FilterDlg::filterSelectionSource( const int theType,
+ SMESH::Predicate_ptr thePred,
+ QValueList<int>& theResIds )
+{
+ theResIds.clear();
+ if ( myMesh->_is_nil() || mySelection == 0 )
+ return;
+
+ // Create map of entities to be filtered
+ TColStd_MapOfInteger aToBeFiltered;
+ Standard_Boolean aRes = false;
+ SALOME_ListIteratorOfListIO anIter( mySelection->StoredIObjects() );
+
+ for ( ; anIter.More(); anIter.Next() )
+ {
+ // process sub mesh
+ SMESH::SMESH_subMesh_ptr aSubMesh = mySMESHGUI->ConvertIOinSubMesh( anIter.Value(), aRes );
+ if ( aRes && !aSubMesh->_is_nil() )
+ {
+ if ( aSubMesh->GetFather()->GetId() == myMesh->GetId() )
+ {
+ SMESH::long_array_var anIds =
+ theType == SMESH::NODE ? aSubMesh->GetNodesId() : aSubMesh->GetElementsId();
+ for ( int i = 0, n = anIds->length(); i < n; i++ )
+ aToBeFiltered.Add( anIds[ i ] );
+ }
+ }
+
+ // process group
+ SMESH::SMESH_Group_ptr aGroup = mySMESHGUI->ConvertIOinSMESHGroup( anIter.Value(), aRes );
+ if ( aRes && !aGroup->_is_nil() )
+ {
+ if ( aGroup->GetType() == theType && aGroup->GetMesh()->GetId() == myMesh->GetId() )
+ {
+ SMESH::long_array_var anIds = aGroup->GetListOfID();
+ for ( int i = 0, n = anIds->length(); i < n; i++ )
+ aToBeFiltered.Add( anIds[ i ] );
+ }
+ }
+
+ // process mesh
+ SMESH::SMESH_Mesh_ptr aMeshPtr = mySMESHGUI->ConvertIOinMesh( anIter.Value(), aRes );
+ if ( aRes && !aMeshPtr->_is_nil() && aMeshPtr->GetId() == myMesh->GetId() )
+ {
+ TColStd_MapOfInteger aVtkMap;
+ mySelection->GetIndex( anIter.Value(), aVtkMap );
+
+ if ( aVtkMap.Extent() > 0 )
+ {
+ SMESH_Actor *anActor = mySMESHGUI->FindActorByEntry(
+ anIter.Value()->getEntry(), aRes, true );
+ if ( aRes && anActor != 0 )
+ {
+ TColStd_MapIteratorOfMapOfInteger aVtkMapIter( aVtkMap );
+ for ( ; aVtkMapIter.More(); aVtkMapIter.Next() )
+ aToBeFiltered.Add( theType == SMESH::NODE
+ ? anActor->GetNodeObjId( aVtkMapIter.Key() )
+ : anActor->GetElemObjId( aVtkMapIter.Key() ) );
+ }
+ }
+ }
+ }
+
+ // Filter entities
+ thePred->SetMesh( myMesh );
+ TColStd_MapIteratorOfMapOfInteger aResIter( aToBeFiltered );
+ for ( ; aResIter.More(); aResIter.Next() )
+ if ( thePred->IsSatisfy( aResIter.Key() ) )
+ theResIds.append( aResIter.Key() );
+}
+
+//=======================================================================
+// name : SMESHGUI_FilterDlg::selectInViewer
+// Purpose : Select given entities in viewer
+//=======================================================================
+void SMESHGUI_FilterDlg::selectInViewer( const int theType, const QValueList<int>& theIds )
+{
+ if ( mySelection == 0 || myMesh->_is_nil() )
+ return;
+
+ // Set new selection mode if necessary
+ Selection_Mode aSelMode = getSelMode( theType );
+ if ( aSelMode != mySelection->SelectionMode() )
+ {
+ mySelection->ClearIObjects();
+ mySelection->ClearFilters();
+ if ( aSelMode == NodeSelection )
+ mySMESHGUI->ViewNodes();
+ QAD_Application::getDesktop()->SetSelectionMode( aSelMode );
+ }
+
+ Standard_Boolean aRes = false;
+ SMESH_Actor* anActor = mySMESHGUI->FindActor( myMesh, aRes, true );
+ if ( !aRes || anActor == 0 || !anActor->hasIO() )
+ return;
+
+ Handle(SALOME_InteractiveObject) anIO = anActor->getIO();
+ mySelection->ClearIObjects();
+ mySelection->AddIObject( anIO, false );
+
+ TColStd_MapOfInteger aMap;
+ QValueList<int>::const_iterator anIter;
+ for ( anIter = theIds.begin(); anIter != theIds.end(); ++anIter )
+ {
+ std::vector<int> aVtkList = anActor->GetElemVtkId( *anIter );
+ std::vector<int>::iterator it;
+ for ( it = aVtkList.begin(); it != aVtkList.end(); ++it )
+ aMap.Add( *it );
+ }
+
+ mySelection->AddOrRemoveIndex( anIO, aMap, false, true );
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component\r
+//\r
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,\r
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS \r
+// \r
+// This library is free software; you can redistribute it and/or \r
+// modify it under the terms of the GNU Lesser General Public \r
+// License as published by the Free Software Foundation; either \r
+// version 2.1 of the License. \r
+// \r
+// This library is distributed in the hope that it will be useful, \r
+// but WITHOUT ANY WARRANTY; without even the implied warranty of \r
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU \r
+// Lesser General Public License for more details. \r
+// \r
+// You should have received a copy of the GNU Lesser General Public \r
+// License along with this library; if not, write to the Free Software \r
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA \r
+// \r
+// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org \r
+//\r
+//\r
+//\r
+// File : SMESHGUI_FilterDlg.h\r
+// Author : Sergey LITONIN\r
+// Module : SMESH\r
+\r
+\r
+#ifndef SMESHGUI_FilterDlg_H\r
+#define SMESHGUI_FilterDlg_H\r
+\r
+#include <qdialog.h>\r
+#include <qmap.h>\r
+#include <qvaluelist.h>\r
+#include <SALOME_Selection.h>\r
+\r
+#include <SALOMEconfig.h>\r
+#include CORBA_SERVER_HEADER(SMESH_Filter)\r
+#include CORBA_SERVER_HEADER(SMESH_Mesh)\r
+\r
+class QCloseEvent;\r
+class QWidgetStack;\r
+class QStringList;\r
+class QTableItem;\r
+class QFrame;\r
+class QEvent;\r
+class QPushButton;\r
+class QTable;\r
+class SALOME_Selection;\r
+class SMESHGUI;\r
+class QComboBox;\r
+class QButtonGroup;\r
+class QCheckBox;\r
+class QGroupBox;\r
+\r
+\r
+/*\r
+ Class : SMESHGUI_FilterDlg\r
+ Description : Dialog to specify filters for VTK viewer\r
+*/\r
+\r
+class SMESHGUI_FilterDlg : public QDialog\r
+{ \r
+ Q_OBJECT\r
+\r
+ class Table;\r
+\r
+ // Edge criteria\r
+ enum { FreeBorders = 0, MultiBorders, Length }; \r
+\r
+ // Face criteria\r
+ enum { AspectRatio = 0, Warping, MinimumAngle, Taper, Skew, Area }; \r
+\r
+ // Comparision\r
+ enum { LessThan = 0, MoreThan, EqualTo };\r
+\r
+ // Logical operations\r
+ enum { LO_And = 0, LO_Or, LO_Undefined };\r
+\r
+ // Source elements to be selected\r
+ enum { Mesh, Selection, Dialog, None };\r
+\r
+ typedef QMap<int, Table*> TableMap;\r
+\r
+public:\r
+ SMESHGUI_FilterDlg( QWidget* parent, \r
+ const int type,\r
+ const bool theModal = true,\r
+ const char* name = 0 );\r
+ virtual ~SMESHGUI_FilterDlg();\r
+\r
+ void Init( const int type );\r
+\r
+ void SetSelection( SALOME_Selection* );\r
+ void SetMesh( SMESH::SMESH_Mesh_ptr );\r
+ void SetSourceWg( QWidget* );\r
+\r
+private slots:\r
+\r
+ void onAddBtn();\r
+ void onRemoveBtn();\r
+ void onClearBtn();\r
+ void onCriterionChanged( int, int );\r
+\r
+ void onOk();\r
+ bool onApply();\r
+ void onClose();\r
+ void onDeactivate();\r
+\r
+private:\r
+\r
+ void closeEvent( QCloseEvent* e );\r
+ void enterEvent ( QEvent * );\r
+\r
+ void updateBtnState();\r
+\r
+ // dialog creation\r
+ QFrame* createButtonFrame( QWidget*, const bool );\r
+ QFrame* createMainFrame( QWidget* );\r
+ Table* createTable( QWidget*, const int );\r
+ QButtonGroup* createSourceGroup( QWidget* );\r
+ void addRow( Table*, const int );\r
+ QTableItem* getCriterionItem( QTable*, const int );\r
+ QTableItem* getCompareItem( QTable* );\r
+ QTableItem* getNotItem( QTable* );\r
+ QTableItem* getLogOpItem( QTable* );\r
+ const QStringList& getCriteria( const int theType ) const;\r
+ const QStringList& getCompare () const;\r
+ \r
+ // query\r
+ int getCurrType() const;\r
+ int getCriterion( const int theType, const int theRow ) const;\r
+\r
+ // execution\r
+ bool isValid() const;\r
+ SMESH::Predicate_ptr createPredicate( const int theType );\r
+ void insertFilterInViewer( SMESH::Predicate_ptr thePred );\r
+ void selectInViewer( const int theType,\r
+ const QValueList<int>& theIds );\r
+ void filterSource( const int theType,\r
+ SMESH::Predicate_ptr thePred,\r
+ QValueList<int>& theResIds );\r
+ void filterSelectionSource( const int theType,\r
+ SMESH::Predicate_ptr thePred,\r
+ QValueList<int>& theResIds );\r
+ void getIdsFromWg( const QWidget*, QValueList<int>& ) const;\r
+ void setIdsToWg( QWidget*, const QValueList<int>& );\r
+ Selection_Mode getSelMode( const int ) const;\r
+\r
+private:\r
+\r
+ // widgets\r
+ QFrame* myMainFrame;\r
+ QGroupBox* myTableGrp;\r
+\r
+ TableMap myTables;\r
+ QPushButton* myAddBtn;\r
+ QPushButton* myRemoveBtn;\r
+ QPushButton* myClearBtn;\r
+ QButtonGroup* mySourceGrp;\r
+ QCheckBox* mySetInViewer;\r
+\r
+ QPushButton* myOkBtn;\r
+ QPushButton* myApplyBtn;\r
+ QPushButton* myCloseBtn;\r
+\r
+ // initial fields\r
+ int myType;\r
+ SMESHGUI* mySMESHGUI;\r
+ SALOME_Selection* mySelection;\r
+ SMESH::SMESH_Mesh_ptr myMesh;\r
+ QWidget* mySourceWg;\r
+};\r
+\r
+#endif\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 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.
+//
+// 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.org
+//
+//
+//
+// File : SMESHGUI_GroupDlg.cxx
+// Author : Natalia KOPNOVA
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "SMESHGUI_GroupDlg.h"
+#include "SMESHGUI_FilterDlg.h"
+
+#include "SMESHGUI.h"
+#include "SALOMEGUI_QtCatchCorbaException.hxx"
+#include "SALOME_ListIteratorOfListIO.hxx"
+#include "VTKViewer_InteractorStyleSALOME.h"
+#include "VTKViewer_ViewFrame.h"
+#include "QAD_Application.h"
+#include "QAD_Desktop.h"
+#include "QAD_MessageBox.h"
+#include "QAD_RightFrame.h"
+#include "utilities.h"
+
+#include "SMESH_Actor.h"
+
+// QT Includes
+#include <qbuttongroup.h>
+#include <qgroupbox.h>
+#include <qhbox.h>
+#include <qlabel.h>
+#include <qlineedit.h>
+#include <qpushbutton.h>
+#include <qradiobutton.h>
+#include <qcheckbox.h>
+#include <qlayout.h>
+#include <qlistbox.h>
+#include <qimage.h>
+#include <qpixmap.h>
+#include <qmemarray.h>
+
+// STL includes
+#include <vector>
+#include <algorithm>
+
+//=================================================================================
+// class : SMESHGUI_GroupDlg()
+// purpose :
+//=================================================================================
+SMESHGUI_GroupDlg::SMESHGUI_GroupDlg( QWidget* parent, const char* name, SALOME_Selection* theSel,
+ SMESH::SMESH_Mesh_ptr theMesh, bool modal, WFlags fl )
+ : QDialog( parent, name, modal, WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu | WDestructiveClose )
+{
+ if ( !name ) setName( "SMESHGUI_GroupDlg" );
+ initDialog(theSel, true);
+ init(theMesh);
+
+ /* Move widget on the botton right corner of main widget */
+ int x, y ;
+ mySMESHGUI->DefineDlgPosition(this, x, y);
+ this->move(x, y);
+}
+
+SMESHGUI_GroupDlg::SMESHGUI_GroupDlg( QWidget* parent, const char* name, SALOME_Selection* theSel,
+ SMESH::SMESH_Group_ptr theGroup, bool modal, WFlags fl )
+ : QDialog( parent, name, modal, WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu | WDestructiveClose )
+{
+ if ( !name ) setName( "SMESHGUI_GroupDlg" );
+ initDialog(theSel, false);
+ init(theGroup);
+
+ /* Move widget on the botton right corner of main widget */
+ int x, y ;
+ mySMESHGUI->DefineDlgPosition(this, x, y);
+ this->move(x, y);
+}
+
+void SMESHGUI_GroupDlg::initDialog(SALOME_Selection* theSel, bool create)
+{
+ myFilterDlg = 0;
+
+ QPixmap image0(QAD_Desktop::getResourceManager()->loadPixmap( "SMESH",tr("ICON_SELECT")));
+
+ if (create)
+ setCaption( tr( "SMESH_CREATE_GROUP_TITLE" ) );
+ else
+ setCaption( tr( "SMESH_EDIT_GROUP_TITLE" ) );
+ setSizeGripEnabled( TRUE );
+
+ QVBoxLayout* aMainLayout = new QVBoxLayout(this, 11, 6);
+
+ /***************************************************************/
+ myTypeGroup = new QButtonGroup(1, Qt::Vertical, this, "Group types");
+ myTypeGroup->setTitle(tr("SMESH_ELEMENTS_TYPE"));
+ myTypeGroup->setExclusive(true);
+
+ QStringList types;
+ types.append(tr("MESH_NODE"));
+ types.append(tr("SMESH_EDGE"));
+ types.append(tr("SMESH_FACE"));
+ types.append(tr("SMESH_VOLUME"));
+ QRadioButton* rb;
+ for (int i = 0; i < types.count(); i++) {
+ rb = new QRadioButton(types[i], myTypeGroup);
+ }
+ myTypeGroup->setEnabled(create);
+ myTypeId = -1;
+
+ /***************************************************************/
+ QHBox* aNameBox = new QHBox(this, "name box");
+ QLabel* aName = new QLabel(aNameBox, "name label");
+ aName->setText(tr("SMESH_NAME"));
+ aName->setMinimumSize(50,0);
+ myName = new QLineEdit(aNameBox, "name");
+
+ /***************************************************************/
+ QGroupBox* aContentBox = new QGroupBox(1, Qt::Horizontal, this, "content box");
+ aContentBox->setTitle(tr("SMESH_CONTENT"));
+ QFrame* aContent = new QFrame(aContentBox, "content");
+ QGridLayout* aLayout = new QGridLayout(aContent, 7, 4);
+ aLayout->setSpacing(6);
+ aLayout->setAutoAdd(false);
+
+ QLabel* aLabel = new QLabel(aContent, "elements label");
+ aLabel->setText(tr("SMESH_ID_ELEMENTS"));
+ myElements = new QListBox(aContent, "elements list");
+ myElements->setSelectionMode(QListBox::Extended);
+ // myElements->setMinimumHeight(150);
+
+ myFilter = new QPushButton(aContent, "filter");
+ myFilter->setText(tr("SMESH_BUT_FILTER"));
+ QPushButton* aAddBtn = new QPushButton(aContent, "add");
+ aAddBtn->setText(tr("SMESH_BUT_ADD"));
+ QPushButton* aRemoveBtn = new QPushButton(aContent, "remove");
+ aRemoveBtn->setText(tr("SMESH_BUT_REMOVE"));
+ QPushButton* aSortBtn = new QPushButton(aContent, "sort");
+ aSortBtn->setText(tr("SMESH_BUT_SORT"));
+
+ aLayout->addWidget(aLabel, 0, 0);
+ aLayout->addMultiCellWidget(myElements, 1, 6, 0, 0);
+ aLayout->addWidget(myFilter, 1, 2);
+ aLayout->addWidget(aAddBtn, 3, 2);
+ aLayout->addWidget(aRemoveBtn, 4, 2);
+ aLayout->addWidget(aSortBtn, 6, 2);
+
+ aLayout->setColStretch(0, 1);
+ aLayout->addColSpacing(1, 20);
+ aLayout->addColSpacing(3, 20);
+ aLayout->setRowStretch(2, 1);
+ aLayout->setRowStretch(5, 1);
+
+ aContentBox->setMinimumHeight(aContent->sizeHint().height() +
+ aContentBox->sizeHint().height());
+
+ /***************************************************************/
+ QGroupBox* aSelectBox = new QGroupBox(3, Qt::Horizontal, this, "select box");
+ aSelectBox->setTitle(tr("SMESH_SELECT_FROM"));
+
+ mySelectSubMesh = new QCheckBox(aSelectBox, "submesh checkbox");
+ mySelectSubMesh->setText(tr("SMESH_SUBMESH"));
+ mySelectSubMesh->setMinimumSize(50, 0);
+ mySubMeshBtn = new QPushButton(aSelectBox, "submesh button");
+ mySubMeshBtn->setText("");
+ mySubMeshBtn->setPixmap(image0);
+ mySubMeshLine = new QLineEdit(aSelectBox, "submesh line");
+ mySubMeshLine->setReadOnly(true);
+ onSelectSubMesh(false);
+
+ mySelectGroup = new QCheckBox(aSelectBox, "group checkbox");
+ mySelectGroup->setText(tr("SMESH_GROUP"));
+ mySelectGroup->setMinimumSize(50, 0);
+ myGroupBtn = new QPushButton(aSelectBox, "group button");
+ myGroupBtn->setText("");
+ myGroupBtn->setPixmap(image0);
+ myGroupLine = new QLineEdit(aSelectBox, "group line");
+ myGroupLine->setReadOnly(true);
+ onSelectGroup(false);
+
+ aSelectBox->setMinimumHeight(mySubMeshBtn->sizeHint().height() +
+ myGroupBtn->sizeHint().height() +
+ aSelectBox->sizeHint().height());
+
+ /***************************************************************/
+ QFrame* aButtons = new QFrame(this, "button box");
+ aButtons->setFrameStyle(QFrame::Box | QFrame::Sunken);
+ QHBoxLayout* aBtnLayout = new QHBoxLayout(aButtons, 11, 6);
+ aBtnLayout->setAutoAdd(false);
+
+ QPushButton* aOKBtn = new QPushButton(aButtons, "ok");
+ aOKBtn->setText(tr("SMESH_BUT_OK"));
+ aOKBtn->setAutoDefault(true);
+ aOKBtn->setDefault(true);
+ QPushButton* aApplyBtn = new QPushButton(aButtons, "apply");
+ aApplyBtn->setText(tr("SMESH_BUT_APPLY"));
+ aApplyBtn->setAutoDefault(true);
+ QPushButton* aCloseBtn = new QPushButton(aButtons, "close");
+ aCloseBtn->setText(tr("SMESH_BUT_CLOSE"));
+ aCloseBtn->setAutoDefault(true);
+
+ aBtnLayout->addWidget(aOKBtn);
+ aBtnLayout->addWidget(aApplyBtn);
+ aBtnLayout->addStretch();
+ aBtnLayout->addWidget(aCloseBtn);
+
+ /***************************************************************/
+ aMainLayout->addWidget(myTypeGroup);
+ aMainLayout->addWidget(aNameBox);
+ aMainLayout->addWidget(aContentBox);
+ aMainLayout->addWidget(aSelectBox);
+ aMainLayout->addWidget(aButtons);
+
+ /* signals and slots connections */
+ connect(myTypeGroup, SIGNAL(clicked(int)), this, SLOT(onTypeChanged(int)));
+
+ connect(myName, SIGNAL(textChanged(const QString&)), this, SLOT(onNameChanged(const QString&)));
+ connect(myElements, SIGNAL(selectionChanged()), this, SLOT(onListSelectionChanged()));
+
+ connect(myFilter, SIGNAL(clicked()), this, SLOT(setFilters()));
+ connect(aAddBtn, SIGNAL(clicked()), this, SLOT(onAdd()));
+ connect(aRemoveBtn, SIGNAL(clicked()), this, SLOT(onRemove()));
+ connect(aSortBtn, SIGNAL(clicked()), this, SLOT(onSort()));
+
+ connect(mySelectSubMesh, SIGNAL(toggled(bool)), this, SLOT(onSelectSubMesh(bool)));
+ connect(mySelectGroup, SIGNAL(toggled(bool)), this, SLOT(onSelectGroup(bool)));
+ connect(mySubMeshBtn, SIGNAL(clicked()), this, SLOT(setCurrentSelection()));
+ connect(myGroupBtn, SIGNAL(clicked()), this, SLOT(setCurrentSelection()));
+
+ connect(aOKBtn, SIGNAL(clicked()), this, SLOT(onOK()));
+ connect(aApplyBtn, SIGNAL(clicked()), this, SLOT(onApply()));
+ connect(aCloseBtn, SIGNAL(clicked()), this, SLOT(onClose()));
+
+ /* Init selection */
+ mySelection = theSel;
+ mySMESHGUI = SMESHGUI::GetSMESHGUI();
+ mySMESHGUI->SetActiveDialogBox(this);
+ mySMESHGUI->SetState(800);
+
+ mySelectionMode = -1;
+ mySubMeshFilter = new SMESH_TypeFilter(SUBMESH);
+ myGroupFilter = new SMESH_TypeFilter(GROUP);
+
+ connect(mySMESHGUI, SIGNAL(SignalDeactivateActiveDialog()), this, SLOT(onClose()));
+ connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), this, SLOT(onClose()));
+ connect(mySelection, SIGNAL(currentSelectionChanged()), this, SLOT(onObjectSelectionChanged()));
+
+ updateButtons();
+}
+
+//=================================================================================
+// function : ~SMESHGUI_GroupDlg()
+// purpose : Destroys the object and frees any allocated resources
+//=================================================================================
+SMESHGUI_GroupDlg::~SMESHGUI_GroupDlg()
+{
+ // no need to delete child widgets, Qt does it all for us
+}
+
+
+//=================================================================================
+// function : Init()
+// purpose :
+//=================================================================================
+void SMESHGUI_GroupDlg::init(SMESH::SMESH_Mesh_ptr theMesh)
+{
+ /* init data from current selection */
+ myMesh = SMESH::SMESH_Mesh::_duplicate(theMesh);
+ myGroup = SMESH::SMESH_Group::_nil();
+
+ Standard_Boolean aResult;
+ myActor = mySMESHGUI->FindActor(myMesh, aResult, true);
+ mySMESHGUI->SetPickable(myActor);
+
+ myTypeGroup->setButton(0);
+ onTypeChanged(0);
+}
+
+//=================================================================================
+// function : Init()
+// purpose :
+//=================================================================================
+void SMESHGUI_GroupDlg::init(SMESH::SMESH_Group_ptr theGroup)
+{
+
+ myMesh = theGroup->GetMesh();
+ myGroup = SMESH::SMESH_Group::_duplicate(theGroup);
+
+ Standard_Boolean aResult;
+ myActor = mySMESHGUI->FindActor(myMesh, aResult, true);
+ if ( !myActor )
+ myActor = mySMESHGUI->FindActor(myGroup, aResult, true);
+ mySMESHGUI->SetPickable(myActor);
+
+ int aType = 0;
+ switch(theGroup->GetType()) {
+ case SMESH::NODE: aType= 0; break;
+ case SMESH::EDGE: aType = 1; break;
+ case SMESH::FACE: aType = 2; break;
+ case SMESH::VOLUME: aType = 3; break;
+ }
+ myTypeGroup->setButton(aType);
+ onTypeChanged(aType);
+
+ myName->setText(myGroup->GetName());
+ myName->home(false);
+
+ if (!theGroup->IsEmpty()) {
+ SMESH::long_array_var anElements = myGroup->GetListOfID();
+ int k = anElements->length();
+ for (int i = 0; i < k; i++) {
+ myIdList.append(anElements[i]);
+ myElements->insertItem(QString::number(anElements[i]));
+ }
+ myElements->selectAll(true);
+ }
+}
+
+
+//=================================================================================
+// function : updateButtons()
+// purpose :
+//=================================================================================
+void SMESHGUI_GroupDlg::updateButtons()
+{
+ bool enable = !myName->text().stripWhiteSpace().isEmpty() && myElements->count() > 0;
+ QPushButton* aBtn;
+ aBtn = (QPushButton*) child("ok", "QPushButton");
+ if (aBtn) aBtn->setEnabled(enable);
+ aBtn = (QPushButton*) child("apply", "QPushButton");
+ if (aBtn) aBtn->setEnabled(enable);
+}
+
+//=================================================================================
+// function : onNameChanged()
+// purpose :
+//=================================================================================
+void SMESHGUI_GroupDlg::onNameChanged(const QString& text)
+{
+ updateButtons();
+}
+
+//=================================================================================
+// function : onTypeChanged()
+// purpose : Radio button management
+//=================================================================================
+void SMESHGUI_GroupDlg::onTypeChanged(int id)
+{
+ if (myTypeId != id) {
+ myElements->clear();
+ if (myCurrentLineEdit == 0)
+ setSelectionMode(id);
+ myFilter->setEnabled(id == 1 || id == 2);
+ }
+ myTypeId = id;
+}
+
+//=================================================================================
+// function : setSelectionMode()
+// purpose : Radio button management
+//=================================================================================
+void SMESHGUI_GroupDlg::setSelectionMode(int theMode)
+{
+ if (mySelectionMode != theMode) {
+ mySelection->ClearIObjects();
+ mySelection->ClearFilters();
+ if (mySelectionMode == 0)
+ mySMESHGUI->EraseSimulationActors();
+ if (theMode < 4) {
+ if (theMode == 0) {
+ mySMESHGUI->ViewNodes();
+ QAD_Application::getDesktop()->SetSelectionMode(NodeSelection, true);
+ }
+ else if (theMode == 1) {
+ QAD_Application::getDesktop()->SetSelectionMode(EdgeSelection, true);
+ }
+ else if (theMode == 2) {
+ QAD_Application::getDesktop()->SetSelectionMode(FaceSelection, true);
+ }
+ else {
+ QAD_Application::getDesktop()->SetSelectionMode(VolumeSelection, true);
+ }
+ }
+ else {
+ QAD_Application::getDesktop()->SetSelectionMode(ActorSelection, true);
+ if (theMode == 4)
+ mySelection->AddFilter(mySubMeshFilter);
+ else if (theMode == 5)
+ mySelection->AddFilter(myGroupFilter);
+ }
+ mySelectionMode = theMode;
+ }
+}
+
+//=================================================================================
+// function : onApply()
+// purpose :
+//=================================================================================
+bool SMESHGUI_GroupDlg::onApply()
+{
+ if (!myName->text().stripWhiteSpace().isEmpty() && myElements->count() > 0) {
+ mySelection->ClearIObjects();
+ if (myGroup->_is_nil()) {
+ SMESH::ElementType aType = SMESH::ALL;
+ switch(myTypeId) {
+ case 0: aType = SMESH::NODE; break;
+ case 1: aType = SMESH::EDGE; break;
+ case 2: aType = SMESH::FACE; break;
+ case 3: aType = SMESH::VOLUME; break;
+ }
+ SMESH::long_array_var anIdList = new SMESH::long_array;
+ int i, k = myElements->count();
+ anIdList->length(k);
+ QListBoxItem* anItem;
+ for (i = 0, anItem = myElements->firstItem(); anItem != 0; i++, anItem = anItem->next()) {
+ anIdList[i] = anItem->text().toInt();
+ }
+
+ myGroup = mySMESHGUI->AddGroup(myMesh, aType, myName->text());
+ myGroup->Add(anIdList);
+
+ /* init for next operation */
+ myName->setText("");
+ myElements->clear();
+ myGroup = SMESH::SMESH_Group::_nil();
+ }
+ else {
+ myGroup->SetName(myName->text());
+
+ QValueList<int> aAddList;
+ QValueList<int>::iterator anIt;
+ QListBoxItem* anItem;
+ for (anItem = myElements->firstItem(); anItem != 0; anItem = anItem->next()) {
+ int anId = anItem->text().toInt();
+ if ((anIt = myIdList.find(anId)) == myIdList.end())
+ aAddList.append(anId);
+ else
+ myIdList.remove(anIt);
+ }
+ if (!aAddList.empty()) {
+ SMESH::long_array_var anIdList = new SMESH::long_array;
+ anIdList->length(aAddList.count());
+ int i;
+ for (i = 0, anIt = aAddList.begin(); anIt != aAddList.end(); anIt++, i++)
+ anIdList[i] = *anIt;
+ myGroup->Add(anIdList);
+ }
+ if (!myIdList.empty()) {
+ SMESH::long_array_var anIdList = new SMESH::long_array;
+ anIdList->length(myIdList.count());
+ int i;
+ for (i = 0, anIt = myIdList.begin(); anIt != myIdList.end(); anIt++, i++)
+ anIdList[i] = *anIt;
+ myGroup->Remove(anIdList);
+ }
+ /* init for next operation */
+ myIdList.clear();
+ for (anItem = myElements->firstItem(); anItem != 0; anItem = anItem->next())
+ myIdList.append(anItem->text().toInt());
+ }
+
+ mySMESHGUI->GetActiveStudy()->updateObjBrowser(true);
+ mySelection->ClearIObjects();
+ return true;
+ }
+ return false;
+}
+
+//=================================================================================
+// function : onOK()
+// purpose :
+//=================================================================================
+void SMESHGUI_GroupDlg::onOK()
+{
+ if ( onApply() )
+ onClose();
+}
+
+//=================================================================================
+// function : onClose()
+// purpose :
+//=================================================================================
+void SMESHGUI_GroupDlg::onClose()
+{
+ close();
+}
+
+
+static bool busy = false;
+//=================================================================================
+// function : onListSelectionChanged()
+// purpose : Called when selection in element list is changed
+//=================================================================================
+void SMESHGUI_GroupDlg::onListSelectionChanged()
+{
+ // MESSAGE("SMESHGUI_GroupDlg::onListSelectionChanged(); myActor = " << myActor);
+ if (busy || !myActor) return;
+ busy = true;
+
+ if (myCurrentLineEdit == 0) {
+ mySelection->ClearIObjects();
+ TColStd_MapOfInteger aIndexes;
+ QListBoxItem* anItem;
+ for (anItem = myElements->firstItem(); anItem != 0; anItem = anItem->next()) {
+ if (anItem->isSelected()) {
+ std::vector<int> aVtkList;
+ if (myTypeId == 0)
+ aVtkList = myActor->GetNodeVtkId(anItem->text().toInt());
+ else
+ aVtkList = myActor->GetElemVtkId(anItem->text().toInt());
+
+ if (aVtkList.size() > 0) {
+ std::vector<int>::iterator it;
+ for (it = aVtkList.begin(); it != aVtkList.end(); ++it) {
+ aIndexes.Add(*it);
+ }
+ }
+ }
+ }
+ mySelection->AddOrRemoveIndex(myActor->getIO(), aIndexes, false, false);
+ mySelection->AddIObject(myActor->getIO());
+ }
+ busy = false;
+}
+
+//=================================================================================
+// function : onObjectSelectionChanged()
+// purpose : Called when selection in 3D view or ObjectBrowser is changed
+//=================================================================================
+void SMESHGUI_GroupDlg::onObjectSelectionChanged()
+{
+ if (busy) return;
+ busy = true;
+
+ int aNbSel = mySelection->IObjectCount();
+ myElements->clearSelection();
+
+ if (myCurrentLineEdit) {
+ myCurrentLineEdit->setText("") ;
+ QString aString = "";
+ if (aNbSel >= 1) {
+ if (aNbSel > 1) {
+ if (myCurrentLineEdit = mySubMeshLine)
+ aString = tr("SMESH_SUBMESH_SELECTED").arg(aNbSel);
+ else if (myCurrentLineEdit = myGroupLine)
+ aString = tr("SMESH_GROUP_SELECTED").arg(aNbSel);
+ }
+ else {
+ aString = mySelection->firstIObject()->getName();
+ }
+ }
+
+ myCurrentLineEdit->setText(aString) ;
+ myCurrentLineEdit->home( false );
+ }
+ else {
+ if (aNbSel == 1) {
+ QString aListStr = "";
+ int aNbItems = 0;
+ if (myTypeId == 0) {
+ aNbItems = mySMESHGUI->GetNameOfSelectedNodes(mySelection, aListStr);
+ }
+ else {
+ aNbItems = mySMESHGUI->GetNameOfSelectedElements(mySelection, aListStr);
+ }
+ if (aNbItems > 0) {
+ QStringList anElements = QStringList::split(" ", aListStr);
+ QListBoxItem* anItem = 0;
+ for (QStringList::iterator it = anElements.begin(); it != anElements.end(); ++it) {
+ anItem = myElements->findItem(*it, Qt::ExactMatch);
+ if (anItem) myElements->setSelected(anItem, true);
+ }
+ }
+ }
+ }
+ busy = false;
+}
+
+
+//=================================================================================
+// function : onSelectSubMesh()
+// purpose : Called when selection in 3D view or ObjectBrowser is changed
+//=================================================================================
+void SMESHGUI_GroupDlg::onSelectSubMesh(bool on)
+{
+ if (on) {
+ if (mySelectGroup->isChecked()) {
+ mySelectGroup->setChecked(false);
+ }
+ myCurrentLineEdit = mySubMeshLine;
+ setSelectionMode(4);
+ }
+ else {
+ mySubMeshLine->setText("");
+ myCurrentLineEdit = 0;
+ if (myTypeId != -1)
+ setSelectionMode(myTypeId);
+ }
+ mySubMeshBtn->setEnabled(on);
+ mySubMeshLine->setEnabled(on);
+}
+
+//=================================================================================
+// function : (onSelectGroup)
+// purpose : Called when selection in 3D view or ObjectBrowser is changed
+//=================================================================================
+void SMESHGUI_GroupDlg::onSelectGroup(bool on)
+{
+ if (on) {
+ if (mySelectSubMesh->isChecked()) {
+ mySelectSubMesh->setChecked(false);
+ }
+ myCurrentLineEdit = myGroupLine;
+ setSelectionMode(5);
+ }
+ else {
+ myGroupLine->setText("");
+ myCurrentLineEdit = 0;
+ if (myTypeId != -1)
+ setSelectionMode(myTypeId);
+ }
+ myGroupBtn->setEnabled(on);
+ myGroupLine->setEnabled(on);
+}
+
+//=================================================================================
+// function : setCurrentSelection()
+// purpose :
+//=================================================================================
+void SMESHGUI_GroupDlg::setCurrentSelection()
+{
+ QPushButton* send = (QPushButton*)sender();
+ myCurrentLineEdit = 0;
+ if (send == mySubMeshBtn) {
+ myCurrentLineEdit = mySubMeshLine;
+ onObjectSelectionChanged();
+ }
+ else if (send == myGroupBtn) {
+ myCurrentLineEdit = myGroupLine;
+ onObjectSelectionChanged();
+ }
+}
+
+
+//=================================================================================
+// function : setFilters()
+// purpose : SLOT. Called when "Filter" button pressed.
+//=================================================================================
+void SMESHGUI_GroupDlg::setFilters()
+{
+ SMESH::ElementType aType = SMESH::ALL;
+ switch ( myTypeId )
+ {
+ case 0 : aType = SMESH::NODE; break;
+ case 1 : aType = SMESH::EDGE; break;
+ case 2 : aType = SMESH::FACE; break;
+ case 3 : aType = SMESH::VOLUME; break;
+ default: return;
+ }
+
+ if ( myFilterDlg == 0 )
+ myFilterDlg = new SMESHGUI_FilterDlg( this, aType, true );
+ else
+ myFilterDlg->Init( aType );
+
+ myFilterDlg->SetSelection( mySelection );
+ myFilterDlg->SetMesh( myMesh );
+ myFilterDlg->SetSourceWg( myElements );
+
+ if ( myFilterDlg->exec() != QDialog::Accepted )
+ return;
+
+ if ( mySelectSubMesh->isChecked() || mySelectGroup->isChecked() )
+ {
+ mySelectionMode = myTypeId;
+ mySelectSubMesh->setChecked( false );
+ mySelectGroup->setChecked( false );
+ }
+}
+
+//=================================================================================
+// function : onAdd()
+// purpose :
+//=================================================================================
+void SMESHGUI_GroupDlg::onAdd()
+{
+ int aNbSel = mySelection->IObjectCount();
+ if (aNbSel == 0) return;
+
+ busy = true;
+
+ SMESH::ElementType aType = SMESH::ALL;
+ switch(myTypeId) {
+ case 0: aType = SMESH::NODE; break;
+ case 1: aType = SMESH::EDGE; break;
+ case 2: aType = SMESH::FACE; break;
+ case 3: aType = SMESH::VOLUME; break;
+ }
+
+ if (myCurrentLineEdit == 0) {
+ if (aNbSel != 1) { busy = false; return; }
+ QString aListStr = "";
+ int aNbItems = 0;
+ if (myTypeId == 0) {
+ aNbItems = mySMESHGUI->GetNameOfSelectedNodes(mySelection, aListStr);
+ }
+ else {
+ aNbItems = mySMESHGUI->GetNameOfSelectedElements(mySelection, aListStr);
+ }
+ if (aNbItems > 0) {
+ QStringList anElements = QStringList::split(" ", aListStr);
+ QListBoxItem* anItem = 0;
+ for (QStringList::iterator it = anElements.begin(); it != anElements.end(); ++it) {
+ anItem = myElements->findItem(*it, Qt::ExactMatch);
+ if (!anItem) {
+ anItem = new QListBoxText(*it);
+ myElements->insertItem(anItem);
+ }
+ myElements->setSelected(anItem, true);
+ }
+ }
+ }
+ else if (myCurrentLineEdit == mySubMeshLine) {
+ Standard_Boolean aRes;
+ SALOME_ListIteratorOfListIO anIt(mySelection->StoredIObjects());
+ for (; anIt.More(); anIt.Next()) {
+ SMESH::SMESH_subMesh_var aSubMesh = mySMESHGUI->ConvertIOinSubMesh(anIt.Value(), aRes);
+ if (aRes && !aSubMesh->_is_nil()) {
+ // check if mesh is the same
+ if (aSubMesh->GetFather()->GetId() == myMesh->GetId()) {
+ if (aType == SMESH::NODE) {
+ try {
+ SMESH::long_array_var anElements = aSubMesh->GetNodesId();
+ int k = anElements->length();
+ QListBoxItem* anItem = 0;
+ for (int i = 0; i < k; i++) {
+ QString aText = QString::number(anElements[i]);
+ anItem = myElements->findItem(aText, Qt::ExactMatch);
+ if (!anItem) {
+ anItem = new QListBoxText(aText);
+ myElements->insertItem(anItem);
+ }
+ myElements->setSelected(anItem, true);
+ }
+ }
+ catch (const SALOME::SALOME_Exception& ex) {
+ QtCatchCorbaException(ex);
+ }
+ }
+ else {
+ try {
+ SMESH::long_array_var anElements = aSubMesh->GetElementsId();
+ int k = anElements->length();
+ QListBoxItem* anItem = 0;
+ for (int i = 0; i < k; i++) {
+ QString aText = QString::number(anElements[i]);
+ anItem = myElements->findItem(aText, Qt::ExactMatch);
+ if (!anItem) {
+ anItem = new QListBoxText(aText);
+ myElements->insertItem(anItem);
+ }
+ myElements->setSelected(anItem, true);
+ }
+ }
+ catch (const SALOME::SALOME_Exception& ex) {
+ QtCatchCorbaException(ex);
+ }
+ }
+ }
+ }
+ }
+ mySelectSubMesh->setChecked(false);
+ busy = false;
+ onListSelectionChanged();
+ }
+ else if (myCurrentLineEdit == myGroupLine) {
+ Standard_Boolean aRes;
+ SALOME_ListIteratorOfListIO anIt(mySelection->StoredIObjects());
+ for (; anIt.More(); anIt.Next()) {
+ SMESH::SMESH_Group_var aGroup = mySMESHGUI->ConvertIOinSMESHGroup(anIt.Value(), aRes);
+ if (aRes && !aGroup->_is_nil()) {
+ // check if mesh is the same
+ if (aGroup->GetType() == aType && aGroup->GetMesh()->GetId() == myMesh->GetId()) {
+ SMESH::long_array_var anElements = aGroup->GetListOfID();
+ int k = anElements->length();
+ QListBoxItem* anItem = 0;
+ for (int i = 0; i < k; i++) {
+ QString aText = QString::number(anElements[i]);
+ anItem = myElements->findItem(aText, Qt::ExactMatch);
+ if (!anItem) {
+ anItem = new QListBoxText(aText);
+ myElements->insertItem(anItem);
+ }
+ myElements->setSelected(anItem, true);
+ }
+ }
+ }
+ }
+ mySelectGroup->setChecked(false);
+ busy = false;
+ onListSelectionChanged();
+ }
+ busy = false;
+ // mySelection->ClearIObjects();
+ updateButtons();
+}
+
+//=================================================================================
+// function : onRemove()
+// purpose :
+//=================================================================================
+void SMESHGUI_GroupDlg::onRemove()
+{
+ busy = true;
+ if (myCurrentLineEdit == 0) {
+ for (int i = myElements->count(); i > 0; i--) {
+ if (myElements->isSelected(i-1)) {
+ myElements->removeItem(i-1);
+ }
+ }
+ }
+ else {
+ int aNbSel = mySelection->IObjectCount();
+ if (aNbSel == 0) { busy = false; return; }
+
+ SMESH::ElementType aType = SMESH::ALL;
+ switch(myTypeId) {
+ case 0: aType = SMESH::NODE; break;
+ case 1: aType = SMESH::EDGE; break;
+ case 2: aType = SMESH::FACE; break;
+ case 3: aType = SMESH::VOLUME; break;
+ }
+
+ if (myCurrentLineEdit == mySubMeshLine) {
+ Standard_Boolean aRes;
+ SALOME_ListIteratorOfListIO anIt(mySelection->StoredIObjects());
+ for (; anIt.More(); anIt.Next()) {
+ SMESH::SMESH_subMesh_var aSubMesh = mySMESHGUI->ConvertIOinSubMesh(anIt.Value(), aRes);
+ if (aRes && !aSubMesh->_is_nil()) {
+ // check if mesh is the same
+ if (aSubMesh->GetFather()->GetId() == myMesh->GetId()) {
+ if (aType == SMESH::NODE) {
+ try {
+ SMESH::long_array_var anElements = aSubMesh->GetNodesId();
+ int k = anElements->length();
+ QListBoxItem* anItem = 0;
+ for (int i = 0; i < k; i++) {
+ anItem = myElements->findItem(QString::number(anElements[i]), Qt::ExactMatch);
+ if (anItem) delete anItem;
+ }
+ }
+ catch (const SALOME::SALOME_Exception& ex) {
+ QtCatchCorbaException(ex);
+ }
+ }
+ else {
+ try {
+ SMESH::long_array_var anElements = aSubMesh->GetElementsId();
+ int k = anElements->length();
+ QListBoxItem* anItem = 0;
+ for (int i = 0; i < k; i++) {
+ anItem = myElements->findItem(QString::number(anElements[i]), Qt::ExactMatch);
+ if (anItem) delete anItem;
+ }
+ }
+ catch (const SALOME::SALOME_Exception& ex) {
+ QtCatchCorbaException(ex);
+ }
+ }
+ }
+ }
+ }
+ }
+ else if (myCurrentLineEdit == myGroupLine) {
+ Standard_Boolean aRes;
+ SALOME_ListIteratorOfListIO anIt(mySelection->StoredIObjects());
+ for (; anIt.More(); anIt.Next()) {
+ SMESH::SMESH_Group_var aGroup = mySMESHGUI->ConvertIOinSMESHGroup(anIt.Value(), aRes);
+ if (aRes && !aGroup->_is_nil()) {
+ // check if mesh is the same
+ if (aGroup->GetType() == aType && aGroup->GetMesh()->GetId() == myMesh->GetId()) {
+ SMESH::long_array_var anElements = aGroup->GetListOfID();
+ int k = anElements->length();
+ QListBoxItem* anItem = 0;
+ for (int i = 0; i < k; i++) {
+ anItem = myElements->findItem(QString::number(anElements[i]), Qt::ExactMatch);
+ if (anItem) delete anItem;
+ }
+ }
+ }
+ }
+ }
+ }
+ busy = false;
+ updateButtons();
+}
+
+//=================================================================================
+// function : onSort()
+// purpose :
+//=================================================================================
+void SMESHGUI_GroupDlg::onSort()
+{
+ // PAL5412: sorts items in ascending by "string" value
+ // myElements->sort(true);
+ // myElements->update();
+ int i, k = myElements->count();
+ if (k > 0) {
+ busy = true;
+ QStringList aSelected;
+ std::vector<int> anArray(k);
+ // QMemArray<int> anArray(k);
+ QListBoxItem* anItem;
+ // fill the array
+ for (anItem = myElements->firstItem(), i = 0; anItem != 0; anItem = anItem->next(), i++) {
+ anArray[i] = anItem->text().toInt();
+ if (anItem->isSelected())
+ aSelected.append(anItem->text());
+ }
+ // sort & update list
+ std::sort(anArray.begin(), anArray.end());
+ // anArray.sort();
+ myElements->clear();
+ for (i = 0; i < k; i++) {
+ myElements->insertItem(QString::number(anArray[i]));
+ }
+ for (QStringList::iterator it = aSelected.begin(); it != aSelected.end(); ++it) {
+ anItem = myElements->findItem(*it, Qt::ExactMatch);
+ if (anItem) myElements->setSelected(anItem, true);
+ }
+ busy = false;
+ }
+}
+
+//=================================================================================
+// function : closeEvent()
+// purpose :
+//=================================================================================
+void SMESHGUI_GroupDlg::closeEvent( QCloseEvent* e )
+{
+ QAD_StudyFrame* aStudyFrame = mySMESHGUI->GetActiveStudy()->getActiveStudyFrame();
+ if (aStudyFrame->getTypeView() == VIEW_VTK) {
+ mySMESHGUI->SetPickable();
+ if (mySelectionMode == 0)
+ mySMESHGUI->EraseSimulationActors();
+
+ // remove filters from viewer
+ VTKViewer_InteractorStyleSALOME* aStyle = ((VTKViewer_ViewFrame*)aStudyFrame->getRightFrame()->getViewFrame())->getRWInteractor()->GetInteractorStyleSALOME();
+ aStyle->RemoveEdgeFilter();
+ aStyle->RemoveFaceFilter();
+
+ }
+
+ mySelection->ClearIObjects();
+ QAD_Application::getDesktop()->SetSelectionMode(ActorSelection);
+ mySelection->ClearFilters();
+ mySMESHGUI->ResetState();
+
+ QDialog::closeEvent( e );
+}
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 CEA
+//
+// 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.org
+//
+//
+//
+// File : SMESHGUI_GroupDlg.h
+// Author : Natalia KOPNOVA
+// Module : SMESH
+// $Header$
+
+#ifndef DIALOGBOX_GROUP_H
+#define DIALOGBOX_GROUP_H
+
+#include "SALOME_Selection.h"
+#include "SMESH_TypeFilter.hxx"
+
+// QT Includes
+#include <qdialog.h>
+#include <qvaluelist.h>
+
+// IDL Headers
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_Mesh)
+#include CORBA_SERVER_HEADER(SMESH_Group)
+
+class QLineEdit;
+class QButtonGroup;
+class QListBox;
+class QPushButton;
+class QCheckBox;
+class SMESHGUI;
+class SMESH_Actor;
+class SMESHGUI_FilterDlg;
+
+//=================================================================================
+// class : SMESHGUI_GroupDlg
+// purpose :
+//=================================================================================
+class SMESHGUI_GroupDlg : public QDialog
+{
+ Q_OBJECT
+
+public:
+ SMESHGUI_GroupDlg( QWidget* parent = 0, const char* name = 0, SALOME_Selection* theSel = 0,
+ SMESH::SMESH_Mesh_ptr theMesh = SMESH::SMESH_Mesh::_nil(),
+ bool modal = FALSE, WFlags fl = 0 );
+ SMESHGUI_GroupDlg( QWidget* parent, const char* name, SALOME_Selection* theSel,
+ SMESH::SMESH_Group_ptr theGroup, bool modal = FALSE, WFlags fl = 0 );
+ ~SMESHGUI_GroupDlg();
+
+public slots:
+
+ void onAdd();
+ void onRemove();
+
+
+private slots:
+
+ void onTypeChanged(int id);
+
+ void onOK();
+ void onClose();
+ bool onApply();
+
+ void onListSelectionChanged();
+ void onObjectSelectionChanged();
+
+ void onSelectSubMesh(bool on);
+ void onSelectGroup(bool on);
+ void setCurrentSelection();
+
+ void setFilters();
+ void onSort();
+
+ void onNameChanged(const QString& text);
+
+private:
+ void initDialog(SALOME_Selection* theSel, bool create);
+ void init(SMESH::SMESH_Mesh_ptr theMesh);
+ void init(SMESH::SMESH_Group_ptr theGroup);
+ void closeEvent(QCloseEvent* e);
+ void setSelectionMode(int theMode);
+ void updateButtons();
+
+ SMESHGUI* mySMESHGUI ; /* Current SMESHGUI object */
+ SALOME_Selection* mySelection ; /* User shape selection */
+ SMESH_Actor* myActor; /* Current mesh actor */
+ int myTypeId ; /* Current type id = radio button id */
+ QLineEdit* myCurrentLineEdit; /* Current LineEdit */
+
+ QButtonGroup* myTypeGroup;
+ QLineEdit* myName;
+ QListBox* myElements;
+ QPushButton* myFilter;
+
+ QCheckBox* mySelectSubMesh;
+ QPushButton* mySubMeshBtn;
+ QLineEdit* mySubMeshLine;
+
+ QCheckBox* mySelectGroup;
+ QPushButton* myGroupBtn;
+ QLineEdit* myGroupLine;
+
+ SMESH::SMESH_Mesh_var myMesh;
+ SMESH::SMESH_Group_var myGroup;
+ QValueList<int> myIdList;
+
+ int mySelectionMode;
+ Handle(SMESH_TypeFilter) mySubMeshFilter;
+ Handle(SMESH_TypeFilter) myGroupFilter;
+
+ SMESHGUI_FilterDlg* myFilterDlg;
+};
+
+#endif // DIALOGBOX_GROUP_H
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 CEA
+//
+// 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.org
+//
+//
+//
+// File : SMESHGUI_Hypotheses.h
+// Author : Julia DOROVSKIKH
+// Module : SMESH
+// $Header$
+
+#ifndef SMESHGUI_Hypotheses_HeaderFile
+#define SMESHGUI_Hypotheses_HeaderFile
+
+#include CORBA_SERVER_HEADER(SMESH_Hypothesis)
+
+// QT Includes
+#include <qstring.h>
+#include <qwidget.h>
+
+//=================================================================================
+// class : SMESHGUI_GenericHypothesisCreator
+// purpose :
+//=================================================================================
+class SMESHGUI_GenericHypothesisCreator
+{
+ public:
+ virtual void CreateHypothesis (const bool isAlgo, QWidget* parent) = 0;
+ virtual void EditHypothesis (SMESH::SMESH_Hypothesis_ptr theHyp) = 0;
+};
+
+//=================================================================================
+// class : HypothesisData
+// purpose :
+//=================================================================================
+class HypothesisData
+{
+ public:
+ HypothesisData (const QString& aPluginName,
+ const QString& aServerLibName,
+ const QString& aClientLibName,
+ const QString& aLabel,
+ const QString& anIconId) :
+ PluginName(aPluginName),
+ ServerLibName(aServerLibName),
+ ClientLibName(aClientLibName),
+ Label(aLabel),
+ IconId(anIconId)
+ {};
+
+ QString PluginName;
+ QString ServerLibName;
+ QString ClientLibName;
+ QString Label;
+ QString IconId;
+};
+
+#endif
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 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.
+//
+// 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.org
+//
+//
+//
+// File : SMESHGUI_Preferences_SelectionDlg.cxx
+// Author : Natalia KOPNOVA
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "SMESHGUI_Preferences_SelectionDlg.h"
+#include "SMESHGUI.h"
+
+#include <qgroupbox.h>
+#include <qlayout.h>
+#include <qlabel.h>
+#include <qlineedit.h>
+#include <qvalidator.h>
+#include <qspinbox.h>
+#include <qpushbutton.h>
+#include <qpalette.h>
+#include <qcolordialog.h>
+
+//=================================================================================
+// class : SMESHGUI_LineEdit
+// purpose :
+//=================================================================================
+SMESHGUI_LineEdit::SMESHGUI_LineEdit(QWidget* parent, const char *name)
+ : QLineEdit(parent, name)
+{
+}
+
+SMESHGUI_LineEdit::SMESHGUI_LineEdit(const QString& text, QWidget* parent, const char *name)
+ : QLineEdit(text, parent, name)
+{
+}
+
+void SMESHGUI_LineEdit::focusOutEvent(QFocusEvent* e)
+{
+ const QValidator* aVal = validator();
+ QString aText = text();
+ int aCurPos = cursorPosition();
+ if (aVal && aVal->validate(aText, aCurPos) != QValidator::Acceptable) {
+ QString aValid = aText;
+ aVal->fixup(aValid);
+ if (aText != aValid) {
+ setText(aValid);
+ update();
+ return;
+ }
+ }
+ QLineEdit::focusOutEvent(e);
+}
+
+
+//=================================================================================
+// class : SMESHGUI_DoubleValidator
+// purpose :
+//=================================================================================
+SMESHGUI_DoubleValidator::SMESHGUI_DoubleValidator(QObject * parent, const char *name)
+ : QDoubleValidator(parent, name)
+{
+}
+
+SMESHGUI_DoubleValidator::SMESHGUI_DoubleValidator(double bottom, double top, int decimals,
+ QObject * parent, const char *name)
+ : QDoubleValidator(bottom, top, decimals, parent, name)
+{
+}
+
+void SMESHGUI_DoubleValidator::fixup(QString& theText) const
+{
+ bool ok;
+ double aValue = theText.toDouble(&ok);
+ if (ok) {
+ if (aValue < bottom())
+ theText = QString::number(bottom(), 'g', decimals());
+ if (aValue > top())
+ theText = QString::number(top(), 'g', decimals());
+ }
+}
+
+
+//=================================================================================
+// class : SMESHGUI_Preferences_SelectionDlg()
+// purpose :
+//=================================================================================
+SMESHGUI_Preferences_SelectionDlg::SMESHGUI_Preferences_SelectionDlg( QWidget* parent, const char* name )
+ : QDialog( parent, name, true, WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu )
+{
+ if ( !name ) setName( "SMESHGUI_Preferences_SelectionDlg" );
+ setCaption( tr( "SMESH_PREF_SELECTION" ) );
+
+ QVBoxLayout* aMainLayout = new QVBoxLayout(this, 11, 6);
+ QLabel* aLabel;
+
+ /***************************************************************/
+ QGroupBox* aSelectBox = new QGroupBox(4, Qt::Horizontal, this, "selection");
+ aSelectBox->setTitle(tr("SMESH_SELECTION"));
+
+ aLabel = new QLabel(aSelectBox, "selection color label");
+ aLabel->setText(tr("SMESH_OUTLINE_COLOR"));
+ myColor[2] = new QPushButton(aSelectBox, "outline color");
+ myColor[2]->setFixedSize(QSize(25, 25));
+
+ aSelectBox->addSpace(0);
+ aSelectBox->addSpace(0);
+
+ aLabel = new QLabel(aSelectBox, "selection color label");
+ aLabel->setText(tr("SMESH_ELEMENTS_COLOR"));
+ myColor[1] = new QPushButton(aSelectBox, "elements color");
+ myColor[1]->setFixedSize(QSize(25, 25));
+
+ aLabel = new QLabel(aSelectBox, "selection width label");
+ aLabel->setText(tr("SMESH_WIDTH"));
+ myWidth[1] = new QSpinBox(0, 5, 1, aSelectBox, "selection width");
+ myWidth[1]->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
+ myWidth[1]->setButtonSymbols(QSpinBox::PlusMinus);
+ myWidth[1]->setMinimumWidth(50);
+
+ /***************************************************************/
+ QGroupBox* aPreSelectBox = new QGroupBox(1, Qt::Vertical, this, "preselection");
+ aPreSelectBox->setTitle(tr("SMESH_PRESELECTION"));
+
+ aLabel = new QLabel(aPreSelectBox, "preselection color label");
+ aLabel->setText(tr("SMESH_HILIGHT_COLOR"));
+ myColor[0] = new QPushButton(aPreSelectBox, "preselection color");
+ myColor[0]->setFixedSize(QSize(25, 25));
+
+ aLabel = new QLabel(aPreSelectBox, "preselection width label");
+ aLabel->setText(tr("SMESH_WIDTH"));
+ myWidth[0] = new QSpinBox(0, 5, 1, aPreSelectBox, "preselection width");
+ myWidth[0]->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
+ myWidth[0]->setButtonSymbols(QSpinBox::PlusMinus);
+ myWidth[0]->setMinimumWidth(50);
+
+ /***************************************************************/
+ QGroupBox* aPrecisionBox = new QGroupBox(1, Qt::Vertical, this, "preselection");
+ aPrecisionBox->setTitle(tr("SMESH_PRECISION"));
+ QDoubleValidator* aValidator = new SMESHGUI_DoubleValidator(aPrecisionBox);
+ aValidator->setBottom(0.001);
+ aValidator->setDecimals(6);
+
+ aLabel = new QLabel(aPrecisionBox, "node tol label");
+ aLabel->setText(tr("SMESH_NODES"));
+ myPrecision[0] = new SMESHGUI_LineEdit(aPrecisionBox, "node precision");
+ myPrecision[0]->setValidator(aValidator);
+
+ aLabel = new QLabel(aPrecisionBox, "item tol label");
+ aLabel->setText(tr("SMESH_ELEMENTS"));
+ myPrecision[1] = new SMESHGUI_LineEdit(aPrecisionBox, "item precision");
+ myPrecision[1]->setValidator(aValidator);
+
+ /***************************************************************/
+ QFrame* aButtons = new QFrame(this, "button box");
+ aButtons->setFrameStyle(QFrame::Box | QFrame::Sunken);
+ QHBoxLayout* aBtnLayout = new QHBoxLayout(aButtons, 11, 6);
+ aBtnLayout->setAutoAdd(false);
+
+ QPushButton* aOKBtn = new QPushButton(aButtons, "ok");
+ aOKBtn->setText(tr("SMESH_BUT_OK"));
+ aOKBtn->setAutoDefault(true);
+ aOKBtn->setDefault(true);
+ QPushButton* aCloseBtn = new QPushButton(aButtons, "close");
+ aCloseBtn->setText(tr("SMESH_BUT_CLOSE"));
+ aCloseBtn->setAutoDefault(true);
+
+ aBtnLayout->addWidget(aOKBtn);
+ aBtnLayout->addStretch();
+ aBtnLayout->addWidget(aCloseBtn);
+
+ /***************************************************************/
+ aMainLayout->addWidget(aSelectBox);
+ aMainLayout->addWidget(aPreSelectBox);
+ aMainLayout->addWidget(aPrecisionBox);
+ aMainLayout->addWidget(aButtons);
+
+ for (int i = 0; i < 3; i++)
+ connect(myColor[i], SIGNAL(clicked()), this, SLOT(onSelectColor()));
+
+ connect(aOKBtn, SIGNAL(clicked()), this, SLOT(accept()));
+ connect(aCloseBtn, SIGNAL(clicked()), this, SLOT(reject()));
+
+ /* Move widget on the botton right corner of main widget */
+ int x, y ;
+ SMESHGUI::GetSMESHGUI()->DefineDlgPosition(this, x, y);
+ this->move(x, y);
+}
+
+//=================================================================================
+// function : ~SMESHGUI_Preferences_SelectionDlg()
+// purpose : Destroys the object and frees any allocated resources
+//=================================================================================
+SMESHGUI_Preferences_SelectionDlg::~SMESHGUI_Preferences_SelectionDlg()
+{
+ // no need to delete child widgets, Qt does it all for us
+}
+
+//=================================================================================
+// function : closeEvent()
+// purpose :
+//=================================================================================
+void SMESHGUI_Preferences_SelectionDlg::closeEvent( QCloseEvent* e )
+{
+ reject();
+}
+
+//=================================================================================
+// function : onSelectColor()
+// purpose :
+//=================================================================================
+void SMESHGUI_Preferences_SelectionDlg::onSelectColor()
+{
+ QPushButton* aSender = (QPushButton*)sender();
+ QColor aColor = aSender->palette().active().button();
+ aColor = QColorDialog::getColor(aColor, this);
+ if (aColor.isValid()) {
+ QPalette aPal = aSender->palette();
+ aPal.setColor(QColorGroup::Button, aColor);
+ aSender->setPalette(aPal);
+ }
+}
+
+//=================================================================================
+// function : SetColor()
+// purpose :
+//=================================================================================
+void SMESHGUI_Preferences_SelectionDlg::SetColor(int type, QColor color)
+{
+ if (type > 0 && type <= 3) {
+ QPalette aPal = myColor[type-1]->palette();
+ aPal.setColor(QColorGroup::Button, color);
+ myColor[type-1]->setPalette(aPal);
+ }
+}
+
+//=================================================================================
+// function : GetColor()
+// purpose :
+//=================================================================================
+QColor SMESHGUI_Preferences_SelectionDlg::GetColor(int type)
+{
+ QColor aColor;
+ if (type > 0 && type <= 3)
+ aColor = myColor[type-1]->palette().active().button();
+ return aColor;
+}
+
+//=================================================================================
+// function : SetWidth()
+// purpose :
+//=================================================================================
+void SMESHGUI_Preferences_SelectionDlg::SetWidth(int type, int value)
+{
+ if (type > 0 && type <= 2)
+ myWidth[type-1]->setValue(value);
+}
+
+//=================================================================================
+// function : GetWidth()
+// purpose :
+//=================================================================================
+int SMESHGUI_Preferences_SelectionDlg::GetWidth(int type)
+{
+ if (type > 0 && type <= 2)
+ return myWidth[type-1]->value();
+ return 0;
+}
+
+//=================================================================================
+// function : SetPrecision()
+// purpose :
+//=================================================================================
+void SMESHGUI_Preferences_SelectionDlg::SetPrecision(int type, double value)
+{
+ if (type > 0 && type <= 2)
+ myPrecision[type-1]->setText(QString::number(value));
+}
+
+//=================================================================================
+// function : GetPrecision()
+// purpose :
+//=================================================================================
+double SMESHGUI_Preferences_SelectionDlg::GetPrecision(int type)
+{
+ if (type > 0 && type <= 2)
+ return myPrecision[type-1]->text().toDouble();
+}
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 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.
+//
+// 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-platorm.org or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESHGUI_Preferences_SelectionDlg.h
+// Author : Natalia KOPNOVA
+// Module : SMESH
+// $Header$
+
+#ifndef SMESHGUI_PREFERENCES_SELECTIONDLG_H
+#define SMESHGUI_PREFERENCES_SELECTIONDLG_H
+
+
+// QT Includes
+#include <qdialog.h>
+#include <qlineedit.h>
+#include <qvalidator.h>
+
+class QPushButton;
+class QSpinBox;
+class QColor;
+
+class SMESHGUI_LineEdit : public QLineEdit
+{
+ Q_OBJECT
+
+ public:
+ SMESHGUI_LineEdit(QWidget* parent, const char* name = 0);
+ SMESHGUI_LineEdit(const QString& text, QWidget* parent, const char* name = 0);
+
+ ~SMESHGUI_LineEdit() {};
+
+ protected:
+ void focusOutEvent(QFocusEvent* e);
+};
+
+class SMESHGUI_DoubleValidator : public QDoubleValidator
+{
+ Q_OBJECT
+
+ public:
+ SMESHGUI_DoubleValidator(QObject* parent, const char* name = 0);
+ SMESHGUI_DoubleValidator(double bottom, double top, int decimals,
+ QObject* parent, const char* name = 0);
+
+ ~SMESHGUI_DoubleValidator() {};
+
+ void fixup(QString& text) const;
+};
+
+class SMESHGUI_Preferences_SelectionDlg : public QDialog
+{
+ Q_OBJECT
+
+public:
+ SMESHGUI_Preferences_SelectionDlg( QWidget* parent = 0, const char* name = 0 );
+ ~SMESHGUI_Preferences_SelectionDlg();
+
+ void SetColor(int type, QColor color);
+ QColor GetColor(int type);
+ void SetWidth(int type, int value);
+ int GetWidth(int type);
+ void SetPrecision(int type, double value);
+ double GetPrecision(int type);
+
+private:
+ void closeEvent( QCloseEvent* e ) ;
+
+private slots:
+ void onSelectColor();
+
+private:
+ QPushButton* myColor[3];
+ QSpinBox* myWidth[2];
+ QLineEdit* myPrecision[2];
+};
+
+#endif // SMESHGUI_PREFERENCES_SELECTIONDLG_H
--- /dev/null
+// SMESH SMESHGUI : reading of xml file with list of available hypotheses and algorithms
+// Copyright (C) 2003 CEA
+//
+// 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.org
+//
+//
+//
+// File : SMESHGUI_XmlHandler.cxx
+// Author : Julia DOROVSKIKH
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#define INCLUDE_MENUITEM_DEF
+
+#include "SMESHGUI_XmlHandler.h"
+
+// QT Include
+//#include <qaccel.h>
+#include <qfileinfo.h>
+
+/*!
+ Constructor
+*/
+SMESHGUI_XmlHandler::SMESHGUI_XmlHandler()
+{
+}
+
+/*!
+ Destructor
+*/
+SMESHGUI_XmlHandler::~SMESHGUI_XmlHandler()
+{
+}
+
+/*!
+ Starts parsing of document. Does some initialization
+
+ Reimplemented from QXmlDefaultHandler.
+*/
+bool SMESHGUI_XmlHandler::startDocument()
+{
+ myErrorProt = "";
+ return TRUE;
+}
+
+/*!
+ Does different actions depending on the name of the tag and the
+ state you are in document.
+
+ Reimplemented from QXmlDefaultHandler.
+*/
+bool SMESHGUI_XmlHandler::startElement (const QString&, const QString&,
+ const QString& qName,
+ const QXmlAttributes& atts)
+{
+ if (qName == "meshers")
+ {
+ myHypothesesMap.clear();
+ myAlgorithmsMap.clear();
+ }
+ else if (qName == "meshers-group") // group of hypotheses and algorithms
+ {
+// if (atts.value("server-lib") != "")
+ {
+ myPluginName = atts.value("name");
+ myServerLib = atts.value("server-lib");
+ myClientLib = atts.value("gui-lib");
+
+ QString aResName = atts.value("resources");
+ if (aResName != "")
+ {
+ MESSAGE("Loading Resources " << aResName);
+ QAD_ResourceMgr* resMgr = QAD_Desktop::createResourceManager();
+ QString msg;
+ if (!resMgr->loadResources(aResName, msg))
+ MESSAGE(msg);
+ }
+ }
+ }
+ else if (qName == "hypotheses") // group of hypotheses
+ {
+ }
+ else if (qName == "algorithms") // group of algorithms
+ {
+ }
+ else if (qName == "hypothesis" || qName == "algorithm") // hypothesis or algorithm
+ {
+ if (atts.value("type") != "")
+ {
+ QString aHypAlType = atts.value("type");
+ QString aLabel = atts.value("label-id");
+ QString anIcon = atts.value("icon-id");
+ HypothesisData* aHypLibNames =
+ new HypothesisData (myPluginName, myServerLib, myClientLib,
+ aLabel, anIcon);
+
+ if (qName == "algorithm")
+ {
+ myAlgorithmsMap[(char*)aHypAlType.latin1()] = aHypLibNames;
+ }
+ else
+ {
+ myHypothesesMap[(char*)aHypAlType.latin1()] = aHypLibNames;
+ }
+ }
+ }
+ else
+ {
+ // error
+ return FALSE;
+ }
+ return TRUE;
+}
+
+
+/*!
+ Reimplemented from QXmlDefaultHandler.
+*/
+bool SMESHGUI_XmlHandler::endElement (const QString&, const QString&, const QString&)
+{
+ return TRUE;
+}
+
+
+/*!
+ Reimplemented from QXmlDefaultHandler.
+*/
+bool SMESHGUI_XmlHandler::characters (const QString& ch)
+{
+ // we are not interested in whitespaces
+ QString ch_simplified = ch.simplifyWhiteSpace();
+ if ( ch_simplified.isEmpty() )
+ return TRUE;
+ return TRUE;
+}
+
+
+/*!
+ Returns the default error string.
+
+ Reimplemented from QXmlDefaultHandler.
+*/
+QString SMESHGUI_XmlHandler::errorString()
+{
+ return "the document is not in the quote file format";
+}
+
+/*!
+ Returns the error protocol if parsing failed
+
+ Reimplemented from QXmlDefaultHandler.
+*/
+QString SMESHGUI_XmlHandler::errorProtocol()
+{
+ return myErrorProt;
+}
+
+/*!
+ Returns exception
+
+ Reimplemented from QXmlDefaultHandler.
+*/
+bool SMESHGUI_XmlHandler::fatalError (const QXmlParseException& exception)
+{
+ myErrorProt += QString("fatal parsing error: %1 in line %2, column %3\n")
+ .arg(exception.message())
+ .arg(exception.lineNumber())
+ .arg(exception.columnNumber());
+
+ return QXmlDefaultHandler::fatalError( exception );
+}
--- /dev/null
+// SMESH SMESHGUI : reading of xml file with list of available hypotheses and algorithms
+//
+// Copyright (C) 2003 CEA
+//
+// 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.org
+//
+//
+//
+// File : SMESHGUI_XmlHandler.cxx
+// Author : Julia DOROVSKIKH
+// Module : SMESH
+// $Header$
+
+#include "SMESHGUI.h"
+
+#include <qxml.h>
+#include <map>
+
+class SMESHGUI_XmlHandler : public QXmlDefaultHandler
+{
+ public:
+ SMESHGUI_XmlHandler();
+ virtual ~SMESHGUI_XmlHandler();
+
+ bool startDocument();
+ bool startElement( const QString& namespaceURI, const QString& localName,
+ const QString& qName, const QXmlAttributes& atts );
+ bool endElement( const QString& namespaceURI, const QString& localName, const QString& qName );
+ bool characters( const QString& ch );
+
+ QString errorString();
+ QString errorProtocol();
+ bool fatalError (const QXmlParseException& exception);
+
+ public:
+ map<string, HypothesisData*> myHypothesesMap;
+ map<string, HypothesisData*> myAlgorithmsMap;
+
+ private:
+ QString myErrorProt;
+ QString myPluginName;
+ QString myServerLib;
+ QString myClientLib;
+};
--- /dev/null
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+
+int main(int argc, char** argv)
+{
+ return 1;
+}
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_Filter_i.cxx
+// Author : Alexey Petrov, OCC
+// Module : SMESH
+
+
+#include "SMESH_Filter_i.hxx"
+
+#include "SMDS_Iterator.hxx"
+#include "SMDS_MeshElement.hxx"
+#include "SMDS_MeshNode.hxx"
+#include "SMDSAbs_ElementType.hxx"
+#include "SMESH_Gen_i.hxx"
+#include "SMESHDS_Mesh.hxx"
+
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <gp_XYZ.hxx>
+#include <Precision.hxx>
+#include <TColgp_SequenceOfXYZ.hxx>
+#include <TColStd_ListOfInteger.hxx>
+#include <TColStd_MapOfInteger.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
+
+/*
+ AUXILIARY METHODS
+*/
+
+static inline double getAngle( const gp_XYZ& P1, const gp_XYZ& P2, const gp_XYZ& P3 )
+{
+ return gp_Vec( P1 - P2 ).Angle( gp_Vec( P3 - P2 ) );
+}
+
+static inline double getArea( const gp_XYZ& P1, const gp_XYZ& P2, const gp_XYZ& P3 )
+{
+ gp_Vec aVec1( P2 - P1 );
+ gp_Vec aVec2( P3 - P1 );
+ return ( aVec1 ^ aVec2 ).Magnitude() * 0.5;
+}
+
+static inline double getArea( const gp_Pnt& P1, const gp_Pnt& P2, const gp_Pnt& P3 )
+{
+ return getArea( P1.XYZ(), P2.XYZ(), P3.XYZ() );
+}
+
+static inline double getDistance( const gp_XYZ& P1, const gp_XYZ& P2 )
+{
+ double aDist = gp_Pnt( P1 ).Distance( gp_Pnt( P2 ) );
+ return aDist;
+}
+
+static int getNbMultiConnection( SMESHDS_Mesh* theMesh, const int theId )
+{
+ if ( theMesh == 0 )
+ return 0;
+
+ const SMDS_MeshElement* anEdge = theMesh->FindElement( theId );
+ if ( anEdge == 0 || anEdge->GetType() != SMDSAbs_Edge || anEdge->NbNodes() != 2 )
+ return 0;
+
+ TColStd_MapOfInteger aMap;
+
+ int aResult = 0;
+ SMDS_ElemIteratorPtr anIter = anEdge->nodesIterator();
+ if ( anIter != 0 )
+ {
+ while( anIter->more() )
+ {
+ const SMDS_MeshNode* aNode = (SMDS_MeshNode*)anIter->next();
+ if ( aNode == 0 )
+ return 0;
+ SMDS_ElemIteratorPtr anElemIter = aNode->GetInverseElementIterator();
+ while( anElemIter->more() )
+ {
+ const SMDS_MeshElement* anElem = anElemIter->next();
+ if ( anElem != 0 && anElem->GetType() != SMDSAbs_Edge )
+ {
+ int anId = anElem->GetID();
+
+ if ( anIter->more() ) // i.e. first node
+ aMap.Add( anId );
+ else if ( aMap.Contains( anId ) )
+ aResult++;
+ }
+ }
+// delete anElemIter;
+ }
+// delete anIter;
+ }
+
+ return aResult;
+}
+
+using namespace std;
+using namespace SMESH;
+
+/*
+ FUNCTORS
+*/
+
+/*
+ Class : NumericalFunctor_i
+ Description : Base class for numerical functors
+*/
+
+NumericalFunctor_i::NumericalFunctor_i()
+: SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
+{
+ myMesh = 0;
+ SMESH_Gen_i::GetPOA()->activate_object( this );
+}
+
+void NumericalFunctor_i::SetMesh( SMESH_Mesh_ptr theMesh )
+{
+ SMESH_Mesh_i* anImplPtr =
+ dynamic_cast<SMESH_Mesh_i*>( SMESH_Gen_i::GetServant( theMesh ).in() );
+ myMesh = anImplPtr ? anImplPtr->GetImpl().GetMeshDS() : 0;
+}
+
+bool NumericalFunctor_i::getPoints( const int theId,
+ TColgp_SequenceOfXYZ& theRes ) const
+{
+ theRes.Clear();
+
+ if ( myMesh == 0 )
+ return false;
+
+ // Get nodes of the face
+ const SMDS_MeshElement* anElem = myMesh->FindElement( theId );
+ if ( anElem == 0 || anElem->GetType() != GetType() )
+ return false;
+
+ int nbNodes = anElem->NbNodes();
+
+ SMDS_ElemIteratorPtr anIter = anElem->nodesIterator();
+ if ( anIter != 0 )
+ {
+ while( anIter->more() )
+ {
+ const SMDS_MeshNode* aNode = (SMDS_MeshNode*)anIter->next();
+ if ( aNode != 0 )
+ theRes.Append( gp_XYZ( aNode->X(), aNode->Y(), aNode->Z() ) );
+ }
+
+// delete anIter;
+ }
+
+ return true;
+}
+
+
+/*
+ Class : SMESH_MinimumAngleFunct
+ Description : Functor for calculation of minimum angle
+*/
+
+CORBA::Double MinimumAngle_i::GetValue( CORBA::Long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ if ( !getPoints( theId, P ) || P.Length() != 3 && P.Length() != 4 )
+ return 0;
+
+ double aMin;
+
+ if ( P.Length() == 3 )
+ {
+ double A0 = getAngle( P( 3 ), P( 1 ), P( 2 ) );
+ double A1 = getAngle( P( 1 ), P( 2 ), P( 3 ) );
+ double A2 = getAngle( P( 2 ), P( 3 ), P( 1 ) );
+
+ aMin = Min( A0, Min( A1, A2 ) );
+ }
+ else
+ {
+ double A0 = getAngle( P( 4 ), P( 1 ), P( 2 ) );
+ double A1 = getAngle( P( 1 ), P( 2 ), P( 3 ) );
+ double A2 = getAngle( P( 2 ), P( 3 ), P( 4 ) );
+ double A3 = getAngle( P( 3 ), P( 4 ), P( 1 ) );
+
+ aMin = Min( Min( A0, A1 ), Min( A2, A3 ) );
+ }
+
+ return aMin * 180 / PI;
+}
+
+int MinimumAngle_i::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+/*
+ Class : AspectRatio_i
+ Description : Functor for calculating aspect ratio
+*/
+
+CORBA::Double AspectRatio_i::GetValue( CORBA::Long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ if ( !getPoints( theId, P ) || P.Length() != 3 && P.Length() != 4 )
+ return 0;
+
+ int nbNodes = P.Length();
+
+ // Compute lengths of the sides
+
+ double aLen[ nbNodes ];
+ for ( int i = 0; i < nbNodes - 1; i++ )
+ aLen[ i ] = getDistance( P( i + 1 ), P( i + 2 ) );
+ aLen[ nbNodes - 1 ] = getDistance( P( 1 ), P( nbNodes ) );
+
+ // Compute aspect ratio
+
+ if ( nbNodes == 3 )
+ {
+ double aMaxLen = Max( aLen[ 0 ], Max( aLen[ 1 ], aLen[ 2 ] ) );
+ double anArea = getArea( P( 1 ), P( 2 ), P( 3 ) );
+ static double aCoef = sqrt( 3. ) / 4;
+
+ return anArea != 0 ? aCoef * aMaxLen * aMaxLen / anArea : 0;
+ }
+ else
+ {
+ double aMaxLen = Max( Max( aLen[ 0 ], aLen[ 1 ] ), Max( aLen[ 2 ], aLen[ 3 ] ) );
+ double aMinLen = Min( Min( aLen[ 0 ], aLen[ 1 ] ), Min( aLen[ 2 ], aLen[ 3 ] ) );
+
+ return aMinLen != 0 ? aMaxLen / aMinLen : 0;
+ }
+}
+
+int AspectRatio_i::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+/*
+ Class : Warping_i
+ Description : Functor for calculating warping
+*/
+
+CORBA::Double Warping_i::GetValue( CORBA::Long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ if ( !getPoints( theId, P ) || P.Length() != 4 )
+ return 0;
+
+ gp_XYZ G = ( P( 1 ) + P( 2 ) + P( 3 ) + P( 4 ) ) / 4;
+
+ double A1 = ComputeA( P( 1 ), P( 2 ), P( 3 ), G );
+ double A2 = ComputeA( P( 2 ), P( 3 ), P( 4 ), G );
+ double A3 = ComputeA( P( 3 ), P( 4 ), P( 1 ), G );
+ double A4 = ComputeA( P( 4 ), P( 1 ), P( 2 ), G );
+
+ return Max( Max( A1, A2 ), Max( A3, A4 ) );
+}
+
+double Warping_i::ComputeA( const gp_XYZ& thePnt1,
+ const gp_XYZ& thePnt2,
+ const gp_XYZ& thePnt3,
+ const gp_XYZ& theG ) const
+{
+ double aLen1 = gp_Pnt( thePnt1 ).Distance( gp_Pnt( thePnt2 ) );
+ double aLen2 = gp_Pnt( thePnt2 ).Distance( gp_Pnt( thePnt3 ) );
+ double L = Min( aLen1, aLen2 ) * 0.5;
+
+ gp_XYZ GI = ( thePnt2 - thePnt1 ) / 2. - theG;
+ gp_XYZ GJ = ( thePnt3 - thePnt2 ) / 2. - theG;
+ gp_XYZ N = GI.Crossed( GJ );
+ N.Normalize();
+
+ double H = gp_Vec( thePnt2 - theG ).Dot( gp_Vec( N ) );
+ return asin( fabs( H / L ) ) * 180 / PI;
+}
+
+int Warping_i::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+/*
+ Class : Taper_i
+ Description : Functor for calculating taper
+*/
+
+CORBA::Double Taper_i::GetValue( CORBA::Long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ if ( !getPoints( theId, P ) || P.Length() != 4 )
+ return 0;
+
+ // Compute taper
+ double J1 = getArea( P( 4 ), P( 1 ), P( 2 ) ) / 2;
+ double J2 = getArea( P( 3 ), P( 1 ), P( 2 ) ) / 2;
+ double J3 = getArea( P( 2 ), P( 3 ), P( 4 ) ) / 2;
+ double J4 = getArea( P( 3 ), P( 4 ), P( 1 ) ) / 2;
+
+ double JA = 0.25 * ( J1 + J2 + J3 + J4 );
+
+ double T1 = fabs( ( J1 - JA ) / JA );
+ double T2 = fabs( ( J2 - JA ) / JA );
+ double T3 = fabs( ( J3 - JA ) / JA );
+ double T4 = fabs( ( J4 - JA ) / JA );
+
+ return Max( Max( T1, T2 ), Max( T3, T4 ) );
+}
+
+int Taper_i::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+/*
+ Class : Skew_i
+ Description : Functor for calculating skew in degrees
+*/
+
+static inline double skewAngle( const gp_XYZ& p1, const gp_XYZ& p2, const gp_XYZ& p3 )
+{
+ gp_XYZ p12 = ( p2 + p1 ) / 2;
+ gp_XYZ p23 = ( p3 + p2 ) / 2;
+ gp_XYZ p31 = ( p3 + p1 ) / 2;
+
+ return gp_Vec( p31 - p2 ).Angle( p12 - p23 );
+}
+
+CORBA::Double Skew_i::GetValue( CORBA::Long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ if ( !getPoints( theId, P ) || P.Length() != 3 && P.Length() != 4 )
+ return 0;
+
+ // Compute skew
+ static double PI2 = PI / 2;
+ if ( P.Length() == 3 )
+ {
+ double A0 = fabs( PI2 - skewAngle( P( 3 ), P( 1 ), P( 2 ) ) );
+ double A1 = fabs( PI2 - skewAngle( P( 1 ), P( 2 ), P( 3 ) ) );
+ double A2 = fabs( PI2 - skewAngle( P( 2 ), P( 3 ), P( 1 ) ) );
+
+ return Max( A0, Max( A1, A2 ) ) * 180 / PI;
+ }
+ else
+ {
+ gp_XYZ p12 = ( P( 1 ) + P( 2 ) ) / 2;
+ gp_XYZ p23 = ( P( 2 ) + P( 3 ) ) / 2;
+ gp_XYZ p34 = ( P( 3 ) + P( 4 ) ) / 2;
+ gp_XYZ p41 = ( P( 4 ) + P( 1 ) ) / 2;
+
+ double A = fabs( PI2 - gp_Vec( p34 - p12 ).Angle( p23 - p41 ) );
+
+ return A * 180 / PI;
+ }
+}
+
+int Skew_i::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+/*
+ Class : Area_i
+ Description : Functor for calculating area
+*/
+
+CORBA::Double Area_i::GetValue( CORBA::Long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ if ( !getPoints( theId, P ) || P.Length() != 3 && P.Length() != 4 )
+ return 0;
+
+ if ( P.Length() == 3 )
+ return getArea( P( 1 ), P( 2 ), P( 3 ) );
+ else
+ return getArea( P( 1 ), P( 2 ), P( 3 ) ) + getArea( P( 1 ), P( 3 ), P( 4 ) );
+}
+
+int Area_i::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+/*
+ Class : Length_i
+ Description : Functor for calculating length off edge
+*/
+
+CORBA::Double Length_i::GetValue( CORBA::Long theId )
+{
+ TColgp_SequenceOfXYZ P;
+ return getPoints( theId, P ) && P.Length() == 2 ? getDistance( P( 1 ), P( 2 ) ) : 0;
+}
+
+int Length_i::GetType() const
+{
+ return SMDSAbs_Edge;
+}
+
+/*
+ Class : MultiConnection_i
+ Description : Functor for calculating number of faces conneted to the edge
+*/
+
+CORBA::Double MultiConnection_i::GetValue( CORBA::Long theId )
+{
+ return getNbMultiConnection( myMesh, theId );
+}
+
+int MultiConnection_i::GetType() const
+{
+ return SMDSAbs_Edge;
+}
+
+/*
+ PREDICATES
+*/
+
+/*
+ Class : Predicate_i
+ Description : Base class for all predicates
+*/
+Predicate_i::Predicate_i()
+: SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
+{
+ SMESH_Gen_i::GetPOA()->activate_object( this );
+}
+
+
+/*
+ Class : FreeBorders_i
+ Description : Predicate for free borders
+*/
+
+FreeBorders_i::FreeBorders_i()
+{
+ myMesh = 0;
+}
+
+void FreeBorders_i::SetMesh( SMESH_Mesh_ptr theMesh )
+{
+ SMESH_Mesh_i* anImplPtr =
+ dynamic_cast<SMESH_Mesh_i*>( SMESH_Gen_i::GetServant( theMesh ).in() );
+ myMesh = anImplPtr ? anImplPtr->GetImpl().GetMeshDS() : 0;
+}
+
+CORBA::Boolean FreeBorders_i::IsSatisfy( CORBA::Long theId )
+{
+ return getNbMultiConnection( myMesh, theId ) == 1;
+}
+
+int FreeBorders_i::GetType() const
+{
+ return SMDSAbs_Edge;
+}
+
+/*
+ Class : Comparator_i
+ Description : Base class for comparators
+*/
+
+Comparator_i::Comparator_i()
+{
+ myMargin = 0;
+ myFunctor = 0;
+}
+
+Comparator_i::~Comparator_i()
+{
+ if ( myFunctor != 0 )
+ myFunctor->Destroy();
+}
+
+void Comparator_i::SetMesh( SMESH_Mesh_ptr theMesh )
+{
+ if ( myFunctor != 0 )
+ myFunctor->SetMesh( theMesh );
+}
+
+void Comparator_i::SetMargin( CORBA::Double theValue )
+{
+ myMargin = theValue;
+}
+
+void Comparator_i::SetNumFunctor( NumericalFunctor_ptr theFunct )
+{
+ if ( myFunctor != 0 )
+ myFunctor->Destroy();
+
+ myFunctor = dynamic_cast<NumericalFunctor_i*>( SMESH_Gen_i::GetServant( theFunct ).in() );
+
+ if ( myFunctor != 0 )
+ myFunctor->Register();
+}
+
+int Comparator_i::GetType() const
+{
+ return myFunctor != 0 ? myFunctor->GetType() : SMDSAbs_All;
+}
+
+/*
+ Class : LessThan_i
+ Description : Comparator "<"
+*/
+
+CORBA::Boolean LessThan_i::IsSatisfy( CORBA::Long theId )
+{
+ return myFunctor != 0 && myFunctor->GetValue( theId ) < myMargin;
+}
+
+/*
+ Class : MoreThan_i
+ Description : Comparator ">"
+*/
+
+CORBA::Boolean MoreThan_i::IsSatisfy( CORBA::Long theId )
+{
+ return myFunctor != 0 && myFunctor->GetValue( theId ) > myMargin;
+}
+
+/*
+ Class : EqualTo_i
+ Description : Comparator "="
+*/
+EqualTo_i::EqualTo_i()
+{
+ myToler = Precision::Confusion();
+}
+
+CORBA::Boolean EqualTo_i::IsSatisfy( CORBA::Long theId )
+{
+ return myFunctor != 0 && fabs( myFunctor->GetValue( theId ) - myMargin ) < myToler;
+}
+
+void EqualTo_i::SetTolerance( CORBA::Double theToler )
+{
+ myToler = theToler;
+}
+
+
+/*
+ Class : LogicalNOT_i
+ Description : Logical NOT predicate
+*/
+
+LogicalNOT_i::LogicalNOT_i()
+{
+ myPredicate = 0;
+}
+
+LogicalNOT_i::~LogicalNOT_i()
+{
+ if ( myPredicate )
+ myPredicate->Destroy();
+}
+
+CORBA::Boolean LogicalNOT_i::IsSatisfy( CORBA::Long theId )
+{
+ return myPredicate !=0 && !myPredicate->IsSatisfy( theId );
+}
+
+void LogicalNOT_i::SetMesh( SMESH_Mesh_ptr theMesh )
+{
+ if ( myPredicate != 0 )
+ myPredicate->SetMesh( theMesh );
+}
+
+void LogicalNOT_i::SetPredicate( Predicate_ptr thePred )
+{
+ if ( myPredicate != 0 )
+ myPredicate->Destroy();
+
+ myPredicate = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePred ).in() );
+
+ if ( myPredicate != 0 )
+ myPredicate->Register();
+}
+
+int LogicalNOT_i::GetType() const
+{
+ return myPredicate != 0 ? myPredicate->GetType() : SMDSAbs_All;
+}
+
+
+/*
+ Class : LogicalBinary_i
+ Description : Base class for binary logical predicate
+*/
+
+LogicalBinary_i::LogicalBinary_i()
+{
+ myPredicate1 = 0;
+ myPredicate2 = 0;
+}
+LogicalBinary_i::~LogicalBinary_i()
+{
+ if ( myPredicate1 != 0 )
+ myPredicate1->Destroy();
+
+ if ( myPredicate2 != 0 )
+ myPredicate2->Destroy();
+}
+
+void LogicalBinary_i::SetMesh( SMESH_Mesh_ptr theMesh )
+{
+ if ( myPredicate1 != 0 )
+ myPredicate1->SetMesh( theMesh );
+
+ if ( myPredicate2 != 0 )
+ myPredicate2->SetMesh( theMesh );
+}
+
+void LogicalBinary_i::SetPredicate1( Predicate_ptr thePredicate )
+{
+ if ( myPredicate1 != 0 )
+ myPredicate1->Destroy();
+
+ myPredicate1 = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePredicate ).in() );
+
+ if ( myPredicate1 != 0 )
+ myPredicate1->Register();
+}
+
+void LogicalBinary_i::SetPredicate2( Predicate_ptr thePredicate )
+{
+ if ( myPredicate2 != 0 )
+ myPredicate2->Destroy();
+
+ myPredicate2 = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePredicate ).in() );
+
+ if ( myPredicate2 != 0 )
+ myPredicate2->Register();
+}
+
+int LogicalBinary_i::GetType() const
+{
+ if ( myPredicate1 == 0 || myPredicate2 == 0 )
+ return SMDSAbs_All;
+
+ int aType1 = myPredicate1->GetType();
+ int aType2 = myPredicate2->GetType();
+
+ return aType1 == aType2 ? aType1 : SMDSAbs_All;
+}
+
+/*
+ Class : LogicalAND_i
+ Description : Logical AND
+*/
+
+CORBA::Boolean LogicalAND_i::IsSatisfy( CORBA::Long theId )
+{
+ return myPredicate1 != 0 &&
+ myPredicate2 != 0 &&
+ myPredicate1->IsSatisfy( theId ) && myPredicate2->IsSatisfy( theId );;
+}
+
+/*
+ Class : LogicalOR_i
+ Description : Logical OR
+*/
+
+CORBA::Boolean LogicalOR_i::IsSatisfy( CORBA::Long theId )
+{
+ return myPredicate1 != 0 &&
+ myPredicate2 != 0 &&
+ myPredicate1->IsSatisfy( theId ) || myPredicate2->IsSatisfy( theId );
+}
+
+
+/*
+ FILTER
+*/
+
+Filter_i::Filter_i()
+{
+ myPredicate = 0;
+}
+
+Filter_i::~Filter_i()
+{
+ if ( myPredicate != 0 )
+ myPredicate->Destroy();
+}
+
+void Filter_i::SetPredicate( Predicate_ptr thePredicate )
+{
+ if ( myPredicate != 0 )
+ myPredicate->Destroy();
+
+ myPredicate = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePredicate ).in() );
+
+ if ( myPredicate != 0 )
+ myPredicate->Register();
+}
+
+void Filter_i::SetMesh( SMESH_Mesh_ptr theMesh )
+{
+ if ( myPredicate != 0 )
+ myPredicate->SetMesh( theMesh );
+}
+
+SMESH::long_array* Filter_i::GetElementsId( SMESH_Mesh_ptr theMesh )
+{
+
+ SetMesh( theMesh );
+
+ SMESH_Mesh_i* anImplPtr =
+ dynamic_cast<SMESH_Mesh_i*>( SMESH_Gen_i::GetServant( theMesh ).in() );
+
+ TColStd_ListOfInteger aList;
+
+ if ( anImplPtr != 0 )
+ {
+ SMESHDS_Mesh* aMesh = anImplPtr->GetImpl().GetMeshDS();
+
+ if ( myPredicate != 0 )
+ {
+ int aType = myPredicate->GetType();
+
+ if ( aType == SMDSAbs_Edge )
+ {
+ SMDS_EdgeIteratorPtr anIter = aMesh->edgesIterator();
+ if ( anIter != 0 )
+ {
+ while( anIter->more() )
+ {
+ const SMDS_MeshElement* anElem = anIter->next();
+ if ( myPredicate->IsSatisfy( anElem->GetID() ) )
+ aList.Append( anElem->GetID() );
+ }
+ }
+// delete anIter;
+ }
+ else if ( aType == SMDSAbs_Face )
+ {
+ SMDS_FaceIteratorPtr anIter = aMesh->facesIterator();
+ if ( anIter != 0 )
+ {
+ while( anIter->more() )
+ {
+ const SMDS_MeshElement* anElem = anIter->next();
+ if ( myPredicate->IsSatisfy( anElem->GetID() ) )
+ aList.Append( anElem->GetID() );
+ }
+ }
+// delete anIter;
+ }
+ }
+ }
+
+ SMESH::long_array_var anArray = new SMESH::long_array;
+
+ anArray->length( aList.Extent() );
+ TColStd_ListIteratorOfListOfInteger anIter( aList );
+ int i = 0;
+ for( ; anIter.More(); anIter.Next() )
+ anArray[ i++ ] = anIter.Value();
+
+ return anArray._retn();
+}
+
+/*
+ FILTER MANAGER
+*/
+
+FilterManager_i::FilterManager_i()
+: SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
+{
+ SMESH_Gen_i::GetPOA()->activate_object( this );
+}
+
+MinimumAngle_ptr FilterManager_i::CreateMinimumAngle()
+{
+ SMESH::MinimumAngle_i* aServant = new SMESH::MinimumAngle_i();
+ SMESH::MinimumAngle_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+
+AspectRatio_ptr FilterManager_i::CreateAspectRatio()
+{
+ SMESH::AspectRatio_i* aServant = new SMESH::AspectRatio_i();
+ SMESH::AspectRatio_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+
+Warping_ptr FilterManager_i::CreateWarping()
+{
+ SMESH::Warping_i* aServant = new SMESH::Warping_i();
+ SMESH::Warping_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+
+Taper_ptr FilterManager_i::CreateTaper()
+{
+ SMESH::Taper_i* aServant = new SMESH::Taper_i();
+ SMESH::Taper_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+
+Skew_ptr FilterManager_i::CreateSkew()
+{
+ SMESH::Skew_i* aServant = new SMESH::Skew_i();
+ SMESH::Skew_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+
+Area_ptr FilterManager_i::CreateArea()
+{
+ SMESH::Area_i* aServant = new SMESH::Area_i();
+ SMESH::Area_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+
+Length_ptr FilterManager_i::CreateLength()
+{
+ SMESH::Length_i* aServant = new SMESH::Length_i();
+ SMESH::Length_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+
+MultiConnection_ptr FilterManager_i::CreateMultiConnection()
+{
+ SMESH::MultiConnection_i* aServant = new SMESH::MultiConnection_i();
+ SMESH::MultiConnection_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+
+FreeBorders_ptr FilterManager_i::CreateFreeBorders()
+{
+ SMESH::FreeBorders_i* aServant = new SMESH::FreeBorders_i();
+ SMESH::FreeBorders_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+LessThan_ptr FilterManager_i::CreateLessThan()
+{
+ SMESH::LessThan_i* aServant = new SMESH::LessThan_i();
+ SMESH::LessThan_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+
+MoreThan_ptr FilterManager_i::CreateMoreThan()
+{
+ SMESH::MoreThan_i* aServant = new SMESH::MoreThan_i();
+ SMESH::MoreThan_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+EqualTo_ptr FilterManager_i::CreateEqualTo()
+{
+ SMESH::EqualTo_i* aServant = new SMESH::EqualTo_i();
+ SMESH::EqualTo_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+
+LogicalNOT_ptr FilterManager_i::CreateLogicalNOT()
+{
+ SMESH::LogicalNOT_i* aServant = new SMESH::LogicalNOT_i();
+ SMESH::LogicalNOT_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+
+LogicalAND_ptr FilterManager_i::CreateLogicalAND()
+{
+ SMESH::LogicalAND_i* aServant = new SMESH::LogicalAND_i();
+ SMESH::LogicalAND_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+
+LogicalOR_ptr FilterManager_i::CreateLogicalOR()
+{
+ SMESH::LogicalOR_i* aServant = new SMESH::LogicalOR_i();
+ SMESH::LogicalOR_var anObj = aServant->_this();
+ return anObj._retn();
+}
+
+Filter_ptr FilterManager_i::CreateFilter()
+{
+ SMESH::Filter_i* aServant = new SMESH::Filter_i();
+ SMESH::Filter_var anObj = aServant->_this();
+ return anObj._retn();
+}
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses\r
+//\r
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,\r
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS \r
+// \r
+// This library is free software; you can redistribute it and/or \r
+// modify it under the terms of the GNU Lesser General Public \r
+// License as published by the Free Software Foundation; either \r
+// version 2.1 of the License. \r
+// \r
+// This library is distributed in the hope that it will be useful, \r
+// but WITHOUT ANY WARRANTY; without even the implied warranty of \r
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU \r
+// Lesser General Public License for more details. \r
+// \r
+// You should have received a copy of the GNU Lesser General Public \r
+// License along with this library; if not, write to the Free Software \r
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA \r
+// \r
+// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org \r
+//\r
+//\r
+//\r
+// File : SMESH_Filter_i.hxx\r
+// Author : Alexey Petrov, OCC\r
+// Module : SMESH\r
+\r
+#ifndef _SMESH_FILTER_I_HXX_\r
+#define _SMESH_FILTER_I_HXX_\r
+\r
+#include <SALOMEconfig.h>\r
+#include CORBA_SERVER_HEADER(SMESH_Filter)\r
+#include "SALOME_GenericObj_i.hh"\r
+\r
+class SMESHDS_Mesh;\r
+class gp_Pnt;\r
+class gp_XYZ;\r
+class TColgp_SequenceOfXYZ;\r
+\r
+namespace SMESH{\r
+\r
+/*\r
+ FUNCTORS\r
+*/\r
+\r
+/*\r
+ Class : NumericalFunctor_i\r
+ Description : Base class for numerical functors \r
+ \r
+ PortableServer::POA_ptr thePOA\r
+\r
+*/\r
+\r
+class NumericalFunctor_i: public virtual POA_SMESH::NumericalFunctor,\r
+ public virtual SALOME::GenericObj_i\r
+{\r
+public:\r
+ NumericalFunctor_i();\r
+ void SetMesh( SMESH_Mesh_ptr theMesh );\r
+ virtual int GetType() const = 0;\r
+\r
+protected:\r
+ bool getPoints( const int theId, \r
+ TColgp_SequenceOfXYZ& theRes ) const;\r
+protected:\r
+ SMESHDS_Mesh* myMesh;\r
+};\r
+\r
+/*\r
+ Class : SMESH_MinimumAngleFunct\r
+ Description : Functor for calculation of minimum angle\r
+*/\r
+\r
+class MinimumAngle_i: public virtual POA_SMESH::MinimumAngle,\r
+ public virtual NumericalFunctor_i\r
+{\r
+public:\r
+ CORBA::Double GetValue( CORBA::Long theElementId );\r
+ virtual int GetType() const;\r
+};\r
+\r
+/*\r
+ Class : AspectRatio_i\r
+ Description : Functor for calculating aspect ratio\r
+*/\r
+\r
+class AspectRatio_i: public virtual POA_SMESH::AspectRatio,\r
+ public virtual NumericalFunctor_i\r
+{\r
+public:\r
+ CORBA::Double GetValue(CORBA::Long theElementId);\r
+ virtual int GetType() const;\r
+};\r
+\r
+/*\r
+ Class : Warping_i\r
+ Description : Functor for calculating warping\r
+*/\r
+\r
+class Warping_i: public virtual POA_SMESH::Warping,\r
+ public virtual NumericalFunctor_i\r
+{\r
+public:\r
+ CORBA::Double GetValue(CORBA::Long theElementId);\r
+ virtual int GetType() const;\r
+\r
+private:\r
+ double ComputeA( const gp_XYZ&, const gp_XYZ&, \r
+ const gp_XYZ&, const gp_XYZ& ) const;\r
+};\r
+\r
+/*\r
+ Class : Taper_i\r
+ Description : Functor for calculating taper\r
+*/\r
+\r
+class Taper_i: public virtual POA_SMESH::Taper,\r
+ public virtual NumericalFunctor_i\r
+{\r
+public:\r
+ CORBA::Double GetValue( CORBA::Long theElementId );\r
+ virtual int GetType() const;\r
+};\r
+\r
+/*\r
+ Class : Skew_i\r
+ Description : Functor for calculating skew in degrees\r
+*/\r
+\r
+class Skew_i: public virtual POA_SMESH::Skew,\r
+ public virtual NumericalFunctor_i\r
+{\r
+public:\r
+ CORBA::Double GetValue( CORBA::Long theElementId );\r
+ virtual int GetType() const;\r
+};\r
+\r
+/*\r
+ Class : Area_i\r
+ Description : Functor for calculating area\r
+*/\r
+\r
+class Area_i: public virtual POA_SMESH::Area,\r
+ public virtual NumericalFunctor_i\r
+{\r
+public:\r
+ CORBA::Double GetValue( CORBA::Long theElementId );\r
+ virtual int GetType() const;\r
+};\r
+\r
+/*\r
+ Class : Length_i\r
+ Description : Functor for calculating length of edge\r
+*/\r
+\r
+class Length_i: public virtual POA_SMESH::Length,\r
+ public virtual NumericalFunctor_i\r
+{\r
+public:\r
+ CORBA::Double GetValue( CORBA::Long theElementId );\r
+ virtual int GetType() const;\r
+};\r
+\r
+/*\r
+ Class : MultiConnection_i\r
+ Description : Functor for calculating number of faces conneted to the edge\r
+*/\r
+\r
+class MultiConnection_i: public virtual POA_SMESH::MultiConnection,\r
+ public virtual NumericalFunctor_i\r
+{\r
+public:\r
+ CORBA::Double GetValue( CORBA::Long theElementId );\r
+ virtual int GetType() const;\r
+};\r
+\r
+\r
+/*\r
+ PREDICATES\r
+*/\r
+\r
+/*\r
+ Class : Predicate_i\r
+ Description : Base class for all predicates\r
+*/\r
+\r
+class Predicate_i: public virtual POA_SMESH::Predicate,\r
+ public virtual SALOME::GenericObj_i\r
+{\r
+public:\r
+ Predicate_i();\r
+ virtual int GetType() const = 0;\r
+};\r
+\r
+\r
+/*\r
+ Class : FreeBorders_i\r
+ Description : Predicate for free borders\r
+*/\r
+\r
+class FreeBorders_i: public virtual POA_SMESH::FreeBorders,\r
+ public virtual Predicate_i\r
+{\r
+public:\r
+ FreeBorders_i();\r
+ void SetMesh( SMESH_Mesh_ptr theMesh );\r
+ CORBA::Boolean IsSatisfy( CORBA::Long theElementId );\r
+ virtual int GetType() const;\r
+\r
+protected:\r
+ SMESHDS_Mesh* myMesh;\r
+};\r
+\r
+/*\r
+ Class : Comparator_i\r
+ Description : Base class for comparators\r
+*/\r
+\r
+class Comparator_i: public virtual POA_SMESH::Comparator,\r
+ public virtual Predicate_i\r
+{\r
+public:\r
+ Comparator_i();\r
+ virtual ~Comparator_i();\r
+\r
+ void SetMesh( SMESH_Mesh_ptr theMesh );\r
+ void SetMargin( CORBA::Double );\r
+ void SetNumFunctor( NumericalFunctor_ptr );\r
+\r
+ virtual int GetType() const;\r
+\r
+protected:\r
+ CORBA::Double myMargin;\r
+ NumericalFunctor_i* myFunctor;\r
+};\r
+\r
+/*\r
+ Class : LessThan_i\r
+ Description : Comparator "<"\r
+*/\r
+\r
+class LessThan_i: public virtual POA_SMESH::LessThan,\r
+ public virtual Comparator_i\r
+{\r
+public:\r
+ CORBA::Boolean IsSatisfy( CORBA::Long theElementId );\r
+};\r
+\r
+/*\r
+ Class : MoreThan_i\r
+ Description : Comparator ">"\r
+*/\r
+class MoreThan_i: public virtual POA_SMESH::MoreThan,\r
+ public virtual Comparator_i\r
+{\r
+public:\r
+ CORBA::Boolean IsSatisfy( CORBA::Long theElementId );\r
+};\r
+\r
+/*\r
+ Class : EqualTo_i\r
+ Description : Comparator "="\r
+*/\r
+class EqualTo_i: public virtual POA_SMESH::EqualTo,\r
+ public virtual Comparator_i\r
+{\r
+public:\r
+ EqualTo_i();\r
+\r
+ CORBA::Boolean IsSatisfy( CORBA::Long theElementId );\r
+\r
+ void SetTolerance( CORBA::Double );\r
+\r
+private:\r
+ CORBA::Double myToler;\r
+};\r
+\r
+/*\r
+ Class : Logical_i\r
+ Description : Base class for logical predicate\r
+*/\r
+\r
+class Logical_i: public virtual POA_SMESH::Logical,\r
+ public virtual Predicate_i\r
+ \r
+{\r
+};\r
+\r
+/*\r
+ Class : LogicalNOT_i\r
+ Description : Logical NOT predicate\r
+*/\r
+\r
+class LogicalNOT_i: public virtual POA_SMESH::LogicalNOT,\r
+ public virtual Logical_i\r
+{\r
+public:\r
+ LogicalNOT_i();\r
+ virtual ~LogicalNOT_i();\r
+\r
+ CORBA::Boolean IsSatisfy( CORBA::Long );\r
+\r
+ void SetMesh( SMESH_Mesh_ptr );\r
+ void SetPredicate( Predicate_ptr );\r
+\r
+ virtual int GetType() const;\r
+\r
+private:\r
+ Predicate_i* myPredicate;\r
+};\r
+\r
+\r
+/*\r
+ Class : LogicalBinary_i\r
+ Description : Base class for binary logical predicate\r
+*/\r
+\r
+class LogicalBinary_i: public virtual POA_SMESH::LogicalBinary,\r
+ public virtual Logical_i\r
+{\r
+public:\r
+ LogicalBinary_i();\r
+ virtual ~LogicalBinary_i();\r
+\r
+ void SetMesh( SMESH_Mesh_ptr );\r
+\r
+ void SetPredicate1( Predicate_ptr );\r
+ void SetPredicate2( Predicate_ptr );\r
+\r
+ virtual int GetType() const;\r
+\r
+protected:\r
+ Predicate_i* myPredicate1;\r
+ Predicate_i* myPredicate2;\r
+};\r
+\r
+/*\r
+ Class : LogicalAND_i\r
+ Description : Logical AND\r
+*/\r
+\r
+class LogicalAND_i: public virtual POA_SMESH::LogicalAND,\r
+ public virtual LogicalBinary_i\r
+{\r
+public:\r
+ CORBA::Boolean IsSatisfy( CORBA::Long theElementId );\r
+};\r
+\r
+/*\r
+ Class : LogicalOR_i\r
+ Description : Logical OR\r
+*/\r
+\r
+class LogicalOR_i: public virtual POA_SMESH::LogicalOR,\r
+ public virtual LogicalBinary_i\r
+{\r
+public:\r
+ CORBA::Boolean IsSatisfy( CORBA::Long theElementId );\r
+};\r
+\r
+\r
+/*\r
+ FILTER\r
+*/\r
+\r
+class Filter_i: public virtual POA_SMESH::Filter,\r
+ public virtual SALOME::GenericObj_i\r
+{\r
+public:\r
+ Filter_i();\r
+ virtual ~Filter_i();\r
+ void SetPredicate(Predicate_ptr );\r
+ long_array* GetElementsId(SMESH_Mesh_ptr );\r
+ void SetMesh( SMESH_Mesh_ptr );\r
+\r
+protected:\r
+ Predicate_i* myPredicate;\r
+};\r
+\r
+\r
+/*\r
+ FILTER MANAGER\r
+*/\r
+\r
+class FilterManager_i: public virtual POA_SMESH::FilterManager,\r
+ public virtual SALOME::GenericObj_i\r
+{\r
+public:\r
+ FilterManager_i();\r
+ MinimumAngle_ptr CreateMinimumAngle();\r
+ AspectRatio_ptr CreateAspectRatio();\r
+ Warping_ptr CreateWarping();\r
+ Taper_ptr CreateTaper();\r
+ Skew_ptr CreateSkew();\r
+ Area_ptr CreateArea();\r
+ Length_ptr CreateLength();\r
+ MultiConnection_ptr CreateMultiConnection();\r
+ \r
+ FreeBorders_ptr CreateFreeBorders();\r
+\r
+ LessThan_ptr CreateLessThan();\r
+ MoreThan_ptr CreateMoreThan();\r
+ EqualTo_ptr CreateEqualTo();\r
+ \r
+ LogicalNOT_ptr CreateLogicalNOT();\r
+ LogicalAND_ptr CreateLogicalAND();\r
+ LogicalOR_ptr CreateLogicalOR();\r
+\r
+ Filter_ptr CreateFilter();\r
+};\r
+\r
+\r
+\r
+};\r
+\r
+\r
+#endif\r
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's classes
+//
+// Copyright (C) 2004 CEA
+//
+// 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.org
+//
+//
+//
+// File : SMESH_Group_i.cxx
+// Author : Sergey ANIKIN, OCC
+// Module : SMESH
+// $Header$
+
+#include "SMESH_Group_i.hxx"
+#include "SMESH_Mesh_i.hxx"
+#include "SMESH_Gen_i.hxx"
+#include <SMESH_Group.hxx>
+#include <SMESHDS_Group.hxx>
+#include <SMDSAbs_ElementType.hxx>
+#include <utilities.h>
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+SMESH_Group_i::SMESH_Group_i( PortableServer::POA_ptr thePOA, SMESH_Mesh_i* theMeshServant, const int theLocalID )
+: SALOME::GenericObj_i( thePOA ),
+ myMeshServant( theMeshServant ),
+ myLocalID( theLocalID )
+{
+ thePOA->activate_object( this );
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+SMESH_Group_i::~SMESH_Group_i()
+{
+ MESSAGE("~SMESH_Group_i;" );
+ if ( myMeshServant )
+ myMeshServant->removeGroup(myLocalID);
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void SMESH_Group_i::SetName( const char* theName )
+{
+ if ( myMeshServant ) {
+ ::SMESH_Mesh& aMesh = myMeshServant->GetImpl();
+ ::SMESH_Group* aGroup = aMesh.GetGroup(myLocalID);
+ if (aGroup) {
+ aGroup->SetName(theName);
+
+ // Update group name in a study
+ SALOMEDS::Study_var aStudy = myMeshServant->GetGen()->GetCurrentStudy();
+ if ( !aStudy->_is_nil() ) {
+ SALOMEDS::SObject_var aGroupSO = aStudy->FindObjectIOR( SMESH_Gen_i::GetORB()->object_to_string( _this() ) );
+ if ( !aGroupSO->_is_nil() ) {
+ SALOMEDS::StudyBuilder_var aBuilder = aStudy->NewBuilder();
+ aBuilder->SetName( aGroupSO, theName );
+ }
+ }
+ return;
+ }
+ }
+ MESSAGE("can't set name of a vague group");
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+char* SMESH_Group_i::GetName()
+{
+ if ( myMeshServant ) {
+ ::SMESH_Mesh& aMesh = myMeshServant->GetImpl();
+ ::SMESH_Group* aGroup = aMesh.GetGroup(myLocalID);
+ if (aGroup)
+ return CORBA::string_dup (aGroup->GetName());
+ }
+ MESSAGE("get name of a vague group");
+ return CORBA::string_dup( "NO_NAME" );
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+SMESH::ElementType SMESH_Group_i::GetType()
+{
+ if ( myMeshServant ) {
+ ::SMESH_Mesh& aMesh = myMeshServant->GetImpl();
+ ::SMESH_Group* aGroup = aMesh.GetGroup(myLocalID);
+ if (aGroup) {
+ SMDSAbs_ElementType aSMDSType = aGroup->GetGroupDS()->GetType();
+ SMESH::ElementType aType;
+ switch (aSMDSType) {
+ case SMDSAbs_Node: aType = SMESH::NODE; break;
+ case SMDSAbs_Edge: aType = SMESH::EDGE; break;
+ case SMDSAbs_Face: aType = SMESH::FACE; break;
+ case SMDSAbs_Volume: aType = SMESH::VOLUME; break;
+ default: aType = SMESH::ALL; break;
+ }
+ return aType;
+ }
+ }
+ MESSAGE("get type of a vague group");
+ return SMESH::ALL;
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+CORBA::Long SMESH_Group_i::Size()
+{
+ if ( myMeshServant ) {
+ ::SMESH_Mesh& aMesh = myMeshServant->GetImpl();
+ ::SMESH_Group* aGroup = aMesh.GetGroup(myLocalID);
+ if (aGroup) {
+ int aSize = aGroup->GetGroupDS()->Extent();
+ return aSize;
+ }
+ }
+ MESSAGE("get size of a vague group");
+ return 0;
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+CORBA::Boolean SMESH_Group_i::IsEmpty()
+{
+ if ( myMeshServant ) {
+ ::SMESH_Mesh& aMesh = myMeshServant->GetImpl();
+ ::SMESH_Group* aGroup = aMesh.GetGroup(myLocalID);
+ if (aGroup) {
+ bool isEmpty = aGroup->GetGroupDS()->IsEmpty();
+ return isEmpty;
+ }
+ }
+ MESSAGE("checking IsEmpty of a vague group");
+ return true;
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void SMESH_Group_i::Clear()
+{
+ if ( myMeshServant ) {
+ ::SMESH_Mesh& aMesh = myMeshServant->GetImpl();
+ ::SMESH_Group* aGroup = aMesh.GetGroup(myLocalID);
+ if (aGroup) {
+ // a SMDS group forgets its type after clearing, so we must re-set it
+ SMDSAbs_ElementType aSMDSType = aGroup->GetGroupDS()->GetType();
+ aGroup->GetGroupDS()->Clear();
+ aGroup->GetGroupDS()->SetType(aSMDSType);
+ return;
+ }
+ }
+ MESSAGE("attempt to clear a vague group");
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+CORBA::Boolean SMESH_Group_i::Contains( CORBA::Long theID )
+{
+ if ( myMeshServant ) {
+ ::SMESH_Mesh& aMesh = myMeshServant->GetImpl();
+ ::SMESH_Group* aGroup = aMesh.GetGroup(myLocalID);
+ if (aGroup) {
+ bool res = aGroup->GetGroupDS()->Contains(theID);
+ return res;
+ }
+ }
+ MESSAGE("attempt to check contents of a vague group");
+ return false;
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+CORBA::Long SMESH_Group_i::Add( const SMESH::long_array& theIDs )
+{
+ if ( myMeshServant ) {
+ ::SMESH_Mesh& aMesh = myMeshServant->GetImpl();
+ ::SMESH_Group* aGroup = aMesh.GetGroup(myLocalID);
+ if (aGroup) {
+ SMESHDS_Group* aGroupDS = aGroup->GetGroupDS();
+ int nbAdd = 0;
+ for (int i = 0; i < theIDs.length(); i++) {
+ int anID = (int) theIDs[i];
+ if (aGroupDS->Add(anID))
+ nbAdd++;
+ }
+ return nbAdd;
+ }
+ }
+ MESSAGE("attempt to add elements to a vague group");
+ return 0;
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+CORBA::Long SMESH_Group_i::GetID( CORBA::Long theIndex )
+{
+ if ( myMeshServant ) {
+ ::SMESH_Mesh& aMesh = myMeshServant->GetImpl();
+ ::SMESH_Group* aGroup = aMesh.GetGroup(myLocalID);
+ if (aGroup) {
+ int anID = aGroup->GetGroupDS()->GetID(theIndex);
+ return anID;
+ }
+ }
+ MESSAGE("attempt to iterate on a vague group");
+ return -1;
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+SMESH::long_array* SMESH_Group_i::GetListOfID()
+{
+ SMESH::long_array_var aRes = new SMESH::long_array();
+ if ( myMeshServant ) {
+ ::SMESH_Mesh& aMesh = myMeshServant->GetImpl();
+ ::SMESH_Group* aGroup = aMesh.GetGroup(myLocalID);
+ if (aGroup) {
+ SMESHDS_Group* aGroupDS = aGroup->GetGroupDS();
+ int aSize = aGroupDS->Extent();
+ aRes->length(aSize);
+ for (int i = 0; i < aSize; i++)
+ aRes[i] = aGroupDS->GetID(i+1);
+ return aRes._retn();
+ }
+ }
+ MESSAGE("get list of IDs of a vague group");
+ return aRes._retn();
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+CORBA::Long SMESH_Group_i::Remove( const SMESH::long_array& theIDs )
+{
+ if ( myMeshServant ) {
+ ::SMESH_Mesh& aMesh = myMeshServant->GetImpl();
+ ::SMESH_Group* aGroup = aMesh.GetGroup(myLocalID);
+ if (aGroup) {
+ // a SMDS group forgets its type after clearing, so we must re-set it
+ // if the group becomes empty
+ SMDSAbs_ElementType aSMDSType = aGroup->GetGroupDS()->GetType();
+ SMESHDS_Group* aGroupDS = aGroup->GetGroupDS();
+ int nbDel = 0;
+ for (int i = 0; i < theIDs.length(); i++) {
+ int anID = (int) theIDs[i];
+ if (aGroupDS->Remove(anID))
+ nbDel++;
+ }
+ if (aGroupDS->IsEmpty())
+ aGroupDS->SetType(aSMDSType);
+ return nbDel;
+ }
+ }
+ MESSAGE("attempt to remove elements from a vague group");
+ return 0;
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+SMESH::SMESH_Mesh_ptr SMESH_Group_i::GetMesh()
+{
+ MESSAGE("SMESH_Group_i::GetMesh(): mesh servant = " << myMeshServant );
+ SMESH::SMESH_Mesh_var aMesh;
+ if ( myMeshServant )
+ aMesh = SMESH::SMESH_Mesh::_narrow( myMeshServant->_this() );
+ return aMesh._retn();
+}
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+int SMESH_Group_i::GetLocalID()
+{
+ return myLocalID;
+}
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's classes
+//
+// Copyright (C) 2004 CEA
+//
+// 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.org
+//
+//
+//
+// File : SMESH_Group_i.hxx
+// Author : Sergey ANIKIN, OCC
+// Module : SMESH
+// $Header$
+
+#ifndef SMESH_Group_i_HeaderFile
+#define SMESH_Group_i_HeaderFile
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_Group)
+#include CORBA_SERVER_HEADER(SMESH_Mesh)
+
+#include "SALOME_GenericObj_i.hh"
+
+class SMESH_Mesh_i;
+
+class SMESH_Group_i:
+ public virtual POA_SMESH::SMESH_Group,
+ public virtual SALOME::GenericObj_i
+{
+public:
+ SMESH_Group_i( PortableServer::POA_ptr thePOA, SMESH_Mesh_i* theMeshServant, const int theLocalID );
+ virtual ~SMESH_Group_i();
+
+ // CORBA interface implementation
+ void SetName( const char* theName );
+
+ char* GetName();
+
+ SMESH::ElementType GetType();
+
+ CORBA::Long Size();
+
+ CORBA::Boolean IsEmpty();
+
+ void Clear();
+
+ CORBA::Boolean Contains( CORBA::Long theID );
+
+ CORBA::Long Add( const SMESH::long_array& theIDs );
+
+ CORBA::Long GetID( CORBA::Long theIndex );
+
+ SMESH::long_array* GetListOfID();
+
+ CORBA::Long Remove( const SMESH::long_array& theIDs );
+
+ SMESH::SMESH_Mesh_ptr GetMesh();
+
+ // Internal C++ interface
+ int GetLocalID();
+
+ SMESH_Mesh_i* GetMeshServant() { return myMeshServant; }
+
+private:
+ SMESH_Mesh_i* myMeshServant;
+ int myLocalID;
+};
+
+#endif
--- /dev/null
+# Copyright (C) 2004 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.
+#
+# 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+#
+#
+#
+# File : SMESH_control.py
+# Author : Sergey LITONIN
+# Module : SMESH
+
+
+import SMESH
+import SMESH_mechanic
+
+smesh = SMESH_mechanic.smesh
+mesh = SMESH_mechanic.mesh
+salome = SMESH_mechanic.salome
+
+
+aFilterMgr = smesh.CreateFilterManager()
+
+# Criterion : AREA > 100
+
+aFunctor = aFilterMgr.CreateArea()
+aPredicate = aFilterMgr.CreateMoreThan()
+aPredicate.SetNumFunctor( aFunctor )
+aPredicate.SetMargin( 100 )
+
+aFilter = aFilterMgr.CreateFilter()
+aFilter.SetPredicate( aPredicate )
+
+anIds = aFilter.GetElementsId( mesh )
+
+# print result
+print "Criterion: Area > 100 Nb = ", len( anIds )
+#for i in range( len( anIds ) ):
+ #print anIds[ i ]
+
+# create group
+aGroup = mesh.CreateGroup( SMESH.FACE, "Area > 100" )
+aGroup.Add( anIds )
+
+
+# Criterion : Taper > 3e-15
+
+aFunctor = aFilterMgr.CreateTaper()
+aPredicate = aFilterMgr.CreateMoreThan()
+aPredicate.SetNumFunctor( aFunctor )
+aPredicate.SetMargin( 3e-15 )
+
+aFilter = aFilterMgr.CreateFilter()
+aFilter.SetPredicate( aPredicate )
+
+anIds = aFilter.GetElementsId( mesh )
+
+# print result
+print "Criterion: Taper > 3e-15 Nb = ", len( anIds )
+#for i in range( len( anIds ) ):
+ #print anIds[ i ]
+
+# create group
+aGroup = mesh.CreateGroup( SMESH.FACE, "Taper > 3e-15" )
+aGroup.Add( anIds )
+
+
+# Criterion : ASPECT RATIO > 1.3
+
+aFunctor = aFilterMgr.CreateAspectRatio()
+aPredicate = aFilterMgr.CreateMoreThan()
+aPredicate.SetNumFunctor( aFunctor )
+aPredicate.SetMargin( 1.3 )
+
+aFilter = aFilterMgr.CreateFilter()
+aFilter.SetPredicate( aPredicate )
+
+anIds = aFilter.GetElementsId( mesh )
+
+# print result
+print "Criterion: Aspect Ratio > 1.3 Nb = ", len( anIds )
+#for i in range( len( anIds ) ):
+ #print anIds[ i ]
+
+# create group
+aGroup = mesh.CreateGroup( SMESH.FACE, "Aspect Ratio > 1.3" )
+aGroup.Add( anIds )
+
+
+# Criterion : MINIMUM ANGLE < 30
+
+aFunctor = aFilterMgr.CreateMinimumAngle()
+aPredicate = aFilterMgr.CreateLessThan()
+aPredicate.SetNumFunctor( aFunctor )
+aPredicate.SetMargin( 30 )
+
+aFilter = aFilterMgr.CreateFilter()
+aFilter.SetPredicate( aPredicate )
+
+anIds = aFilter.GetElementsId( mesh )
+
+# print result
+print "Criterion: Minimum Angle < 30 Nb = ", len( anIds )
+#for i in range( len( anIds ) ):
+ #print anIds[ i ]
+
+# create group
+aGroup = mesh.CreateGroup( SMESH.FACE, "Minimum Angle < 30" )
+aGroup.Add( anIds )
+
+# Criterion : Warp > 2e-13
+
+aFunctor = aFilterMgr.CreateWarping()
+aPredicate = aFilterMgr.CreateMoreThan()
+aPredicate.SetNumFunctor( aFunctor )
+aPredicate.SetMargin( 2e-13 )
+
+aFilter = aFilterMgr.CreateFilter()
+aFilter.SetPredicate( aPredicate )
+
+anIds = aFilter.GetElementsId( mesh )
+
+# print result
+print "Criterion: Warp > 2e-13 Nb = ", len( anIds )
+#for i in range( len( anIds ) ):
+ #print anIds[ i ]
+
+# create group
+aGroup = mesh.CreateGroup( SMESH.FACE, "Warp > 2e-13" )
+aGroup.Add( anIds )
+
+# Criterion : Skew > 18
+
+aFunctor = aFilterMgr.CreateSkew()
+aPredicate = aFilterMgr.CreateMoreThan()
+aPredicate.SetNumFunctor( aFunctor )
+aPredicate.SetMargin( 18 )
+
+aFilter = aFilterMgr.CreateFilter()
+aFilter.SetPredicate( aPredicate )
+
+anIds = aFilter.GetElementsId( mesh )
+
+# print result
+print "Criterion: Skew > 18 Nb = ", len( anIds )
+#for i in range( len( anIds ) ):
+ #print anIds[ i ]
+
+# create group
+aGroup = mesh.CreateGroup( SMESH.FACE, "Skew > 18" )
+aGroup.Add( anIds )
+
+# Criterion : Length > 10
+
+aFunctor = aFilterMgr.CreateLength()
+aPredicate = aFilterMgr.CreateMoreThan()
+aPredicate.SetNumFunctor( aFunctor )
+aPredicate.SetMargin( 10 )
+
+aFilter = aFilterMgr.CreateFilter()
+aFilter.SetPredicate( aPredicate )
+
+anIds = aFilter.GetElementsId( mesh )
+
+# print result
+print "Criterion: Length > 10 Nb = ", len( anIds )
+#for i in range( len( anIds ) ):
+ #print anIds[ i ]
+
+# create group
+aGroup = mesh.CreateGroup( SMESH.EDGE, "Length > 10" )
+aGroup.Add( anIds )
+
+# Criterion : Borders at multi-connections = 2
+
+aFunctor = aFilterMgr.CreateMultiConnection()
+aPredicate = aFilterMgr.CreateEqualTo()
+aPredicate.SetNumFunctor( aFunctor )
+aPredicate.SetMargin( 2 )
+
+aFilter = aFilterMgr.CreateFilter()
+aFilter.SetPredicate( aPredicate )
+
+anIds = aFilter.GetElementsId( mesh )
+
+# print result
+print "Criterion: Borders at multi-connections = 2 Nb = ", len( anIds )
+#for i in range( len( anIds ) ):
+ #print anIds[ i ]
+
+# create group
+aGroup = mesh.CreateGroup( SMESH.EDGE, "Borders at multi-connections = 2" )
+aGroup.Add( anIds )
+
+
+salome.sg.updateObjBrowser(1)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+import salome\r
+from geompy import gg\r
+import geompy\r
+import SMESH\r
+\r
+import StdMeshers\r
+\r
+ShapeTypeCompSolid = 1\r
+ShapeTypeSolid = 2\r
+ShapeTypeShell = 3\r
+ShapeTypeFace = 4\r
+ShapeTypeWire = 5\r
+ShapeTypeEdge = 6\r
+ShapeTypeVertex = 7\r
+\r
+geom = salome.lcc.FindOrLoadComponent("FactoryServer", "GEOM")\r
+smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")\r
+\r
+geom.GetCurrentStudy(salome.myStudy._get_StudyId())\r
+smesh.SetCurrentStudy(salome.myStudy)\r
+\r
+# Create box without one plane\r
+\r
+box = geompy.MakeBox(0., 0., 0., 10., 20., 30.)\r
+subShapeList = geompy.SubShapeAll(box,ShapeTypeFace)\r
+\r
+FaceList = []\r
+for i in range( 5 ):\r
+ FaceList.append( subShapeList[ i ]._get_Name() )\r
+\r
+aBox = geompy.MakeSewing( FaceList, 1. )\r
+idbox = geompy.addToStudy( aBox, "box" )\r
+ \r
+aBox = salome.IDToObject( idbox )\r
+\r
+# Create mesh\r
+\r
+hyp1 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")\r
+hyp1.SetNumberOfSegments(5)\r
+hyp2 = smesh.CreateHypothesis("MaxElementArea", "libStdMeshersEngine.so")\r
+hyp2.SetMaxElementArea(20)\r
+hyp3 = smesh.CreateHypothesis("MaxElementArea", "libStdMeshersEngine.so")\r
+hyp3.SetMaxElementArea(50)\r
+\r
+algo1 = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")\r
+algo2 = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")\r
+\r
+mesh = smesh.CreateMesh(aBox)\r
+mesh.AddHypothesis(aBox,hyp1)\r
+mesh.AddHypothesis(aBox,hyp2)\r
+mesh.AddHypothesis(aBox,algo1)\r
+mesh.AddHypothesis(aBox,algo2)\r
+\r
+smesh.Compute(mesh,aBox)\r
+\r
+smeshgui = salome.ImportComponentGUI("SMESH")\r
+smeshgui.Init(salome.myStudyId);\r
+smeshgui.SetName( salome.ObjectToID( mesh ), "Mesh_freebord" );\r
+\r
+# Criterion : Free edges\r
+aFilterMgr = smesh.CreateFilterManager()\r
+aPredicate = aFilterMgr.CreateFreeBorders()\r
+aFilter = aFilterMgr.CreateFilter()\r
+aFilter.SetPredicate( aPredicate )\r
+\r
+anIds = aFilter.GetElementsId( mesh )\r
+\r
+# print result\r
+print "Criterion: Free edges Nb = ", len( anIds )\r
+for i in range( len( anIds ) ):\r
+ print anIds[ i ]\r
+\r
+# create group\r
+aGroup = mesh.CreateGroup( SMESH.EDGE, "Free edges" )\r
+aGroup.Add( anIds )\r
+\r
+\r
+salome.sg.updateObjBrowser(1)\r
--- /dev/null
+import salome
+from geompy import gg
+import geompy
+import SMESH
+
+import StdMeshers
+
+ShapeTypeCompSolid = 1
+ShapeTypeSolid = 2
+ShapeTypeShell = 3
+ShapeTypeFace = 4
+ShapeTypeWire = 5
+ShapeTypeEdge = 6
+ShapeTypeVertex = 7
+
+geom = salome.lcc.FindOrLoadComponent("FactoryServer", "GEOM")
+smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
+
+geom.GetCurrentStudy(salome.myStudy._get_StudyId())
+smesh.SetCurrentStudy(salome.myStudy)
+
+box = geompy.MakeBox(0., 0., 0., 100., 200., 300.)
+idbox = geompy.addToStudy(box,"box")
+
+subShapeList = geompy.SubShapeAll(box,ShapeTypeFace)
+face = subShapeList[0]
+name = geompy.SubShapeName( face._get_Name(), box._get_Name() )
+idface = geompy.addToStudyInFather(box,face,name)
+
+box = salome.IDToObject(idbox)
+face = salome.IDToObject(idface)
+
+hyp1 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
+hyp1.SetNumberOfSegments(10)
+hyp2 = smesh.CreateHypothesis("MaxElementArea", "libStdMeshersEngine.so")
+hyp2.SetMaxElementArea(10)
+hyp3 = smesh.CreateHypothesis("MaxElementArea", "libStdMeshersEngine.so")
+hyp3.SetMaxElementArea(100)
+
+algo1 = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
+algo2 = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
+
+mesh = smesh.CreateMesh(box)
+mesh.AddHypothesis(box,hyp1)
+mesh.AddHypothesis(box,hyp2)
+mesh.AddHypothesis(box,algo1)
+mesh.AddHypothesis(box,algo2)
+
+submesh = mesh.GetSubMesh(face, "SubMeshFace")
+mesh.AddHypothesis(face,hyp1)
+mesh.AddHypothesis(face,hyp3)
+mesh.AddHypothesis(face,algo1)
+mesh.AddHypothesis(face,algo2)
+
+smesh.Compute(mesh,box)
+
+faces = submesh.GetElementsByType(SMESH.FACE)
+if len(faces) > 1:
+ print len(faces), len(faces)/2
+ group1 = mesh.CreateGroup(SMESH.FACE,"Group of faces")
+ group2 = mesh.CreateGroup(SMESH.FACE,"Another group of faces")
+ group1.Add(faces[:int(len(faces)/2)])
+ group2.Add(faces[int(len(faces)/2):])
+
+salome.sg.updateObjBrowser(1)
--- /dev/null
+# Copyright (C) 2003 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.
+#
+# 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+#
+#
+#
+# File : SMESH_test1.py
+# Module : SMESH
+
+import salome
+import SMESH
+import SALOMEDS
+import CORBA
+import os
+import os.path
+
+def SetSObjName(theSObj,theName) :
+ ok, anAttr = theSObj.FindAttribute("AttributeName")
+ if ok:
+ aName = anAttr._narrow(SALOMEDS.AttributeName)
+ #print aName.__dict__
+ aName.SetValue(theName)
+
+def ConvertMED2UNV(thePath,theFile) :
+ anInitFileName = thePath + theFile
+ aMeshes,aResult = smesh.CreateMeshesFromMED(anInitFileName)
+ print aResult, aMeshes
+
+ for iMesh in range(len(aMeshes)) :
+ aMesh = aMeshes[iMesh]
+ anSObj = salome.ObjectToSObject(aMesh)
+ print anSObj.GetName(),
+ aFileName = anInitFileName
+ aFileName = os.path.basename(aFileName)
+ SetSObjName(anSObj,aFileName)
+ print anSObj.GetName()
+
+ aFileName = thePath + theFile + "." + str(iMesh) + ".unv"
+ aMesh.ExportUNV(aFileName)
+ aMesh = smesh.CreateMeshesFromUNV(aFileName)
+ anSObj = salome.ObjectToSObject(aMesh)
+ print anSObj.GetName(),
+ os.remove(aFileName)
+ aFileName = os.path.basename(aFileName)
+ SetSObjName(anSObj,aFileName)
+ print anSObj.GetName()
+
+smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
+smesh.SetCurrentStudy(salome.myStudy)
+
+aPath = os.getenv('KERNEL_ROOT_DIR') + '/examples/'
+aListDir = os.listdir(aPath)
+print aListDir
+
+for iFile in range(len(aListDir)) :
+ aFileName = aListDir[iFile];
+ aName,anExt = os.path.splitext(aFileName)
+ if anExt == ".med" :
+ aFileName = os.path.basename(aFileName)
+ print aFileName
+ ConvertMED2UNV(aPath,aFileName)
+ #break
+
+salome.sg.updateObjBrowser(1);
--- /dev/null
+import os
+import re
+
+import batchmode_salome
+import batchmode_geompy
+import batchmode_smesh
+
+geom = batchmode_geompy.geom
+smesh = batchmode_smesh.smesh
+
+geom.GetCurrentStudy(batchmode_salome.myStudyId)
+smesh.SetCurrentStudy(batchmode_salome.myStudy)
+
+ShapeType = batchmode_smesh.ShapeType
+
+import StdMeshers
+
+def CreateMesh (theFileName, area, len = None, nbseg = None):
+
+ if not(os.path.isfile(theFileName)) or re.search("\.brep$", theFileName) is None :
+ print "Incorrect file name !"
+ return
+
+ if (len is None) and (nbseg is None):
+ print "Define length or number of segments !"
+ return
+
+ if (len is not None) and (nbseg is not None):
+ print "Only one Hypothesis (from length and number of segments) can be defined !"
+ return
+
+
+ # ---- Import shape from BREP file and add it to the study
+ shape_mesh = geom.ImportBREP(theFileName)
+ Id_shape = batchmode_geompy.addToStudy( shape_mesh, "shape_mesh")
+
+
+
+ # ---- SMESH
+
+ # ---- create Hypothesis
+
+ print "-------------------------- create Hypothesis"
+ if (len is not None):
+ print "-------------------------- LocalLength"
+ hypLength1 = smesh.CreateHypothesis("LocalLength", "libStdMeshersEngine.so")
+ hypLength1.SetLength(len)
+ print "Hypothesis type: ", hypLength1.GetName()
+ print "Hypothesis ID: ", hypLength1.GetId()
+ print "Hypothesis Value: ", hypLength1.GetLength()
+
+ if (nbseg is not None):
+ print "-------------------------- NumberOfSegments"
+ hypNbSeg1 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
+ hypNbSeg1.SetNumberOfSegments(nbseg)
+ print "Hypothesis type: ", hypNbSeg1.GetName()
+ print "Hypothesis ID: ", hypNbSeg1.GetId()
+ print "Hypothesis Value: ", hypNbSeg1.GetNumberOfSegments()
+
+
+ if (area == "LengthFromEdges"):
+ print "-------------------------- LengthFromEdges"
+ hypLengthFromEdges = smesh.CreateHypothesis("LengthFromEdges", "libStdMeshersEngine.so")
+ hypLengthFromEdges.SetMode(1)
+ print "Hypothesis type: ", hypLengthFromEdges.GetName()
+ print "Hypothesis ID: ", hypLengthFromEdges.GetId()
+ print "LengthFromEdges Mode: ", hypLengthFromEdges.GetMode()
+
+ else:
+ print "-------------------------- MaxElementArea"
+ hypArea1 = smesh.CreateHypothesis("MaxElementArea", "libStdMeshersEngine.so")
+ hypArea1.SetMaxElementArea(area)
+ print "Hypothesis type: ", hypArea1.GetName()
+ print "Hypothesis ID: ", hypArea1.GetId()
+ print "Hypothesis Value: ", hypArea1.GetMaxElementArea()
+
+
+
+ print "-------------------------- Regular_1D"
+ algoReg = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
+
+ listHyp = algoReg.GetCompatibleHypothesis()
+ for hyp in listHyp:
+ print hyp
+
+ print "Algo name: ", algoReg.GetName()
+ print "Algo ID: ", algoReg.GetId()
+
+ print "-------------------------- MEFISTO_2D"
+ algoMef = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
+
+ listHyp=algoMef.GetCompatibleHypothesis()
+ for hyp in listHyp:
+ print hyp
+
+ print "Algo name: ", algoMef.GetName()
+ print "Algo ID: ", algoMef.GetId()
+
+
+
+ # ---- add hypothesis to shape
+
+ print "-------------------------- add hypothesis to shape"
+ mesh = smesh.CreateMesh(shape_mesh)
+
+ ret = mesh.AddHypothesis(shape_mesh, algoReg)
+ print "Add Regular_1D algo .... ",
+ print ret
+
+ if (nbseg is not None):
+ ret=mesh.AddHypothesis(shape_mesh, hypNbSeg1)
+ print "Add Number Of Segements algo .... ",
+ print ret
+
+ if (len is not None):
+ ret=mesh.AddHypothesis(shape_mesh,hypLength1)
+ print "Add Local Length algo .... ",
+ print ret
+
+ ret=mesh.AddHypothesis(shape_mesh, algoMef)
+ print "Add MEFISTO_2D algo....",
+ print ret
+
+ if (area == "LengthFromEdges"):
+ ret = mesh.AddHypothesis( shape_mesh, hypLengthFromEdges) # length from edge
+ print "Add Length From Edges algo .... ",
+ print ret
+ else:
+ ret=mesh.AddHypothesis(shape_mesh, hypArea1)
+ print "Add Max Triangle Area algo .... ",
+ print ret
+
+ # ---- compute mesh
+
+ print "-------------------------- compute mesh"
+ ret=smesh.Compute(mesh,shape_mesh)
+ print "Compute Mesh .... ",
+ print ret
+ log=mesh.GetLog(0); # no erase trace
+ #for linelog in log:
+ # print linelog
+
+ print "------------ INFORMATION ABOUT MESH ------------"
+
+ print "Number of nodes: ", mesh.NbNodes()
+ print "Number of edges: ", mesh.NbEdges()
+ print "Number of faces: ", mesh.NbFaces()
+ print "Number of triangles: ", mesh.NbTriangles()
+
+ return mesh
--- /dev/null
+# SMESH StdMeshers : implementaion of SMESH idl descriptions
+#
+# Copyright (C) 2003 CEA
+#
+# 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.org
+#
+#
+#
+# File : Makefile.in
+# Author : Julia DOROVSKIKH
+# Module : SMESH
+# $Header$
+
+top_srcdir=@top_srcdir@
+top_builddir=../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl:$(top_builddir)/idl
+
+
+@COMMENCE@
+
+# header files
+EXPORT_HEADERS = \
+ StdMeshers_LengthFromEdges.hxx \
+ StdMeshers_LocalLength.hxx \
+ StdMeshers_NumberOfSegments.hxx \
+ StdMeshers_MaxElementArea.hxx \
+ StdMeshers_MaxElementVolume.hxx \
+ StdMeshers_NotConformAllowed.hxx \
+ StdMeshers_Regular_1D.hxx \
+ StdMeshers_Quadrangle_2D.hxx \
+ StdMeshers_MEFISTO_2D.hxx \
+ StdMeshers_Hexa_3D.hxx
+
+EXPORT_PYSCRIPTS =
+
+# Libraries targets
+
+LIB = libStdMeshers.la
+
+LIB_SRC = \
+ StdMeshers_LengthFromEdges.cxx \
+ StdMeshers_LocalLength.cxx \
+ StdMeshers_MaxElementArea.cxx \
+ StdMeshers_MaxElementVolume.cxx \
+ StdMeshers_NumberOfSegments.cxx \
+ StdMeshers_NotConformAllowed.cxx \
+ StdMeshers_Regular_1D.cxx \
+ StdMeshers_Quadrangle_2D.cxx \
+ StdMeshers_MEFISTO_2D.cxx \
+ StdMeshers_Hexa_3D.cxx
+
+LIB_SERVER_IDL =
+
+LIB_CLIENT_IDL =
+
+# Executables targets
+BIN =
+BIN_SRC =
+
+# additionnal information to compil and link file
+CPPFLAGS+= $(OCC_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome $(BOOST_CPPFLAGS)
+CXXFLAGS+= $(OCC_CXXFLAGS) -I${KERNEL_ROOT_DIR}/include/salome
+
+LDFLAGS+= -lSMESHimpl -lMEFISTO2D -L${KERNEL_ROOT_DIR}/lib/salome
+
+@CONCLUDE@
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_Hexa_3D.cxx
+// Moved here from SMESH_Hexa_3D.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_Hexa_3D.hxx"
+#include "StdMeshers_Quadrangle_2D.hxx"
+#include "SMESH_Gen.hxx"
+#include "SMESH_Mesh.hxx"
+
+#include "SMDS_MeshElement.hxx"
+#include "SMDS_MeshNode.hxx"
+#include "SMDS_FacePosition.hxx"
+
+#include <TopExp.hxx>
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
+
+#include <BRep_Tool.hxx>
+#include <Geom_Surface.hxx>
+#include <Geom_Curve.hxx>
+#include <Geom2d_Curve.hxx>
+#include <Handle_Geom2d_Curve.hxx>
+#include <Handle_Geom_Curve.hxx>
+
+#include "utilities.h"
+#include "Utils_ExceptHandlers.hxx"
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_Hexa_3D::StdMeshers_Hexa_3D(int hypId, int studyId,
+ SMESH_Gen * gen):SMESH_3D_Algo(hypId, studyId, gen)
+{
+ MESSAGE("StdMeshers_Hexa_3D::StdMeshers_Hexa_3D");
+ _name = "Hexa_3D";
+// _shapeType = TopAbs_SOLID;
+ _shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID); // 1 bit /shape type
+// MESSAGE("_shapeType octal " << oct << _shapeType);
+ for (int i = 0; i < 6; i++)
+ _quads[i] = 0;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_Hexa_3D::~StdMeshers_Hexa_3D()
+{
+ MESSAGE("StdMeshers_Hexa_3D::~StdMeshers_Hexa_3D");
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+bool StdMeshers_Hexa_3D::CheckHypothesis
+ (SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ SMESH_Hypothesis::Hypothesis_Status& aStatus)
+{
+ MESSAGE("StdMeshers_Hexa_3D::CheckHypothesis");
+
+ bool isOk = true;
+ aStatus = SMESH_Hypothesis::HYP_OK;
+
+ // nothing to check
+
+ return isOk;
+}
+
+//=============================================================================
+/*!
+ * Hexahedron mesh on hexaedron like form
+ * -0. - shape and face mesh verification
+ * -1. - identify faces and vertices of the "cube"
+ * -2. - Algorithm from:
+ * "Application de l'interpolation transfinie à la création de maillages
+ * C0 ou G1 continus sur des triangles, quadrangles, tetraedres, pentaedres
+ * et hexaedres déformés."
+ * Alain PERONNET - 8 janvier 1999
+ */
+//=============================================================================
+
+bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape)throw(SALOME_Exception)
+{
+ Unexpect aCatch(SalomeException);
+ MESSAGE("StdMeshers_Hexa_3D::Compute");
+
+ bool isOk = false;
+ SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
+ SMESH_subMesh *theSubMesh = aMesh.GetSubMesh(aShape);
+ //const SMESHDS_SubMesh *& subMeshDS = theSubMesh->GetSubMeshDS();
+
+ // 0. - shape and face mesh verification
+ // 0.1 - shape must be a solid (or a shell) with 6 faces
+ MESSAGE("---");
+
+ vector < SMESH_subMesh * >meshFaces;
+ for (TopExp_Explorer exp(aShape, TopAbs_FACE); exp.More(); exp.Next())
+ {
+ SMESH_subMesh *aSubMesh = aMesh.GetSubMeshContaining(exp.Current());
+ ASSERT(aSubMesh);
+ meshFaces.push_back(aSubMesh);
+ }
+ if (meshFaces.size() != 6)
+ {
+ SCRUTE(meshFaces.size());
+ ASSERT(0);
+ return false;
+ }
+
+ // 0.2 - is each face meshed with Quadrangle_2D? (so, with a wire of 4 edges)
+ MESSAGE("---");
+
+ for (int i = 0; i < 6; i++)
+ {
+ TopoDS_Shape aShape = meshFaces[i]->GetSubShape();
+ SMESH_Algo *algo = _gen->GetAlgo(aMesh, aShape);
+ string algoName = algo->GetName();
+ if (algoName != "Quadrangle_2D")
+ {
+ // *** delete _quads
+ SCRUTE(algoName);
+ ASSERT(0);
+ return false;
+ }
+ StdMeshers_Quadrangle_2D *quadAlgo =
+ dynamic_cast < StdMeshers_Quadrangle_2D * >(algo);
+ ASSERT(quadAlgo);
+ try
+ {
+ _quads[i] = quadAlgo->CheckAnd2Dcompute(aMesh, aShape);
+ // *** to delete after usage
+ }
+ catch(SALOME_Exception & S_ex)
+ {
+ // *** delete _quads
+ // *** throw exception
+ ASSERT(0);
+ }
+ }
+
+ // 1. - identify faces and vertices of the "cube"
+ // 1.1 - ancestor maps vertex->edges in the cube
+ MESSAGE("---");
+
+ TopTools_IndexedDataMapOfShapeListOfShape MS;
+ TopExp::MapShapesAndAncestors(aShape, TopAbs_VERTEX, TopAbs_EDGE, MS);
+
+ // 1.2 - first face is choosen as face Y=0 of the unit cube
+ MESSAGE("---");
+
+ const TopoDS_Shape & aFace = meshFaces[0]->GetSubShape();
+ const TopoDS_Face & F = TopoDS::Face(aFace);
+
+ // 1.3 - identify the 4 vertices of the face Y=0: V000, V100, V101, V001
+ MESSAGE("---");
+
+ int i = 0;
+ TopoDS_Edge E = _quads[0]->edge[i]; //edge will be Y=0,Z=0 on unit cube
+ double f, l;
+ Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
+ TopoDS_Vertex VFirst, VLast;
+ TopExp::Vertices(E, VFirst, VLast); // corresponds to f and l
+ bool isForward =
+ (((l - f) * (_quads[0]->last[i] - _quads[0]->first[i])) > 0);
+
+ if (isForward)
+ {
+ _cube.V000 = VFirst; // will be (0,0,0) on the unit cube
+ _cube.V100 = VLast; // will be (1,0,0) on the unit cube
+ }
+ else
+ {
+ _cube.V000 = VLast;
+ _cube.V100 = VFirst;
+ }
+
+ i = 1;
+ E = _quads[0]->edge[i];
+ C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
+ TopExp::Vertices(E, VFirst, VLast);
+ isForward = (((l - f) * (_quads[0]->last[i] - _quads[0]->first[i])) > 0);
+ if (isForward)
+ _cube.V101 = VLast; // will be (1,0,1) on the unit cube
+ else
+ _cube.V101 = VFirst;
+
+ i = 2;
+ E = _quads[0]->edge[i];
+ C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
+ TopExp::Vertices(E, VFirst, VLast);
+ isForward = (((l - f) * (_quads[0]->last[i] - _quads[0]->first[i])) > 0);
+ if (isForward)
+ _cube.V001 = VLast; // will be (0,0,1) on the unit cube
+ else
+ _cube.V001 = VFirst;
+
+ // 1.4 - find edge X=0, Z=0 (ancestor of V000 not in face Y=0)
+ // - find edge X=1, Z=0 (ancestor of V100 not in face Y=0)
+ // - find edge X=1, Z=1 (ancestor of V101 not in face Y=0)
+ // - find edge X=0, Z=1 (ancestor of V001 not in face Y=0)
+ MESSAGE("---");
+
+ TopoDS_Edge E_0Y0 = EdgeNotInFace(aMesh, aShape, F, _cube.V000, MS);
+ ASSERT(!E_0Y0.IsNull());
+
+ TopoDS_Edge E_1Y0 = EdgeNotInFace(aMesh, aShape, F, _cube.V100, MS);
+ ASSERT(!E_1Y0.IsNull());
+
+ TopoDS_Edge E_1Y1 = EdgeNotInFace(aMesh, aShape, F, _cube.V101, MS);
+ ASSERT(!E_1Y1.IsNull());
+
+ TopoDS_Edge E_0Y1 = EdgeNotInFace(aMesh, aShape, F, _cube.V001, MS);
+ ASSERT(!E_0Y1.IsNull());
+
+ // 1.5 - identify the 4 vertices in face Y=1: V010, V110, V111, V011
+ MESSAGE("---");
+
+ TopExp::Vertices(E_0Y0, VFirst, VLast);
+ if (VFirst.IsSame(_cube.V000))
+ _cube.V010 = VLast;
+ else
+ _cube.V010 = VFirst;
+
+ TopExp::Vertices(E_1Y0, VFirst, VLast);
+ if (VFirst.IsSame(_cube.V100))
+ _cube.V110 = VLast;
+ else
+ _cube.V110 = VFirst;
+
+ TopExp::Vertices(E_1Y1, VFirst, VLast);
+ if (VFirst.IsSame(_cube.V101))
+ _cube.V111 = VLast;
+ else
+ _cube.V111 = VFirst;
+
+ TopExp::Vertices(E_0Y1, VFirst, VLast);
+ if (VFirst.IsSame(_cube.V001))
+ _cube.V011 = VLast;
+ else
+ _cube.V011 = VFirst;
+
+ // 1.6 - find remaining faces given 4 vertices
+ MESSAGE("---");
+
+ _indY0 = 0;
+ _cube.quad_Y0 = _quads[_indY0];
+
+ _indY1 = GetFaceIndex(aMesh, aShape, meshFaces,
+ _cube.V010, _cube.V011, _cube.V110, _cube.V111);
+ _cube.quad_Y1 = _quads[_indY1];
+
+ _indZ0 = GetFaceIndex(aMesh, aShape, meshFaces,
+ _cube.V000, _cube.V010, _cube.V100, _cube.V110);
+ _cube.quad_Z0 = _quads[_indZ0];
+
+ _indZ1 = GetFaceIndex(aMesh, aShape, meshFaces,
+ _cube.V001, _cube.V011, _cube.V101, _cube.V111);
+ _cube.quad_Z1 = _quads[_indZ1];
+
+ _indX0 = GetFaceIndex(aMesh, aShape, meshFaces,
+ _cube.V000, _cube.V001, _cube.V010, _cube.V011);
+ _cube.quad_X0 = _quads[_indX0];
+
+ _indX1 = GetFaceIndex(aMesh, aShape, meshFaces,
+ _cube.V100, _cube.V101, _cube.V110, _cube.V111);
+ _cube.quad_X1 = _quads[_indX1];
+
+ MESSAGE("---");
+
+ // 1.7 - get convertion coefs from face 2D normalized to 3D normalized
+
+ Conv2DStruct cx0; // for face X=0
+ Conv2DStruct cx1; // for face X=1
+ Conv2DStruct cy0;
+ Conv2DStruct cy1;
+ Conv2DStruct cz0;
+ Conv2DStruct cz1;
+
+ GetConv2DCoefs(*_cube.quad_X0, meshFaces[_indX0]->GetSubShape(),
+ _cube.V000, _cube.V010, _cube.V011, _cube.V001, cx0);
+ GetConv2DCoefs(*_cube.quad_X1, meshFaces[_indX1]->GetSubShape(),
+ _cube.V100, _cube.V110, _cube.V111, _cube.V101, cx1);
+ GetConv2DCoefs(*_cube.quad_Y0, meshFaces[_indY0]->GetSubShape(),
+ _cube.V000, _cube.V100, _cube.V101, _cube.V001, cy0);
+ GetConv2DCoefs(*_cube.quad_Y1, meshFaces[_indY1]->GetSubShape(),
+ _cube.V010, _cube.V110, _cube.V111, _cube.V011, cy1);
+ GetConv2DCoefs(*_cube.quad_Z0, meshFaces[_indZ0]->GetSubShape(),
+ _cube.V000, _cube.V100, _cube.V110, _cube.V010, cz0);
+ GetConv2DCoefs(*_cube.quad_Z1, meshFaces[_indZ1]->GetSubShape(),
+ _cube.V001, _cube.V101, _cube.V111, _cube.V011, cz1);
+
+ // 1.8 - create a 3D structure for normalized values
+
+ MESSAGE("---");
+ int nbx = _cube.quad_Y0->nbPts[0];
+ int nby = _cube.quad_Y0->nbPts[1];
+ int nbz;
+ if (cx0.a1 != 0)
+ nbz = _cube.quad_X0->nbPts[1];
+ else
+ nbz = _cube.quad_X0->nbPts[0];
+ //SCRUTE(nbx);
+ //SCRUTE(nby);
+ //SCRUTE(nbz);
+ int nbxyz = nbx * nby * nbz;
+ Point3DStruct *np = new Point3DStruct[nbxyz];
+
+ // 1.9 - store node indexes of faces
+
+ {
+ const TopoDS_Face & F = TopoDS::Face(meshFaces[_indX0]->GetSubShape());
+
+ faceQuadStruct *quad = _cube.quad_X0;
+ int i = 0; // j = x/face , k = y/face
+ int nbdown = quad->nbPts[0];
+ int nbright = quad->nbPts[1];
+
+
+ SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
+
+ while(itf->more())
+ {
+ const SMDS_MeshNode * node = itf->next();
+ const SMDS_FacePosition* fpos =
+ static_cast<const SMDS_FacePosition*>(node->GetPosition().get());
+ double ri = fpos->GetUParameter();
+ double rj = fpos->GetVParameter();
+ int i1 = int (ri);
+ int j1 = int (rj);
+ int ij1 = j1 * nbdown + i1;
+ quad->uv_grid[ij1].node = node;
+ }
+
+ for (int i1 = 0; i1 < nbdown; i1++)
+ for (int j1 = 0; j1 < nbright; j1++)
+ {
+ int ij1 = j1 * nbdown + i1;
+ int j = cx0.ia * i1 + cx0.ib * j1 + cx0.ic; // j = x/face
+ int k = cx0.ja * i1 + cx0.jb * j1 + cx0.jc; // k = y/face
+ int ijk = k * nbx * nby + j * nbx + i;
+ //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
+ np[ijk].node = quad->uv_grid[ij1].node;
+ //SCRUTE(np[ijk].nodeId);
+ }
+ }
+
+ {
+ const TopoDS_Face & F = TopoDS::Face(meshFaces[_indX1]->GetSubShape());
+
+ SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
+
+ faceQuadStruct *quad = _cube.quad_X1;
+ int i = nbx - 1; // j = x/face , k = y/face
+ int nbdown = quad->nbPts[0];
+ int nbright = quad->nbPts[1];
+
+ while(itf->more())
+ {
+ const SMDS_MeshNode * node = itf->next();
+ const SMDS_FacePosition* fpos =
+ static_cast<const SMDS_FacePosition*>(node->GetPosition().get());
+ double ri = fpos->GetUParameter();
+ double rj = fpos->GetVParameter();
+ int i1 = int (ri);
+ int j1 = int (rj);
+ int ij1 = j1 * nbdown + i1;
+ quad->uv_grid[ij1].node = node;
+ }
+
+ for (int i1 = 0; i1 < nbdown; i1++)
+ for (int j1 = 0; j1 < nbright; j1++)
+ {
+ int ij1 = j1 * nbdown + i1;
+ int j = cx1.ia * i1 + cx1.ib * j1 + cx1.ic; // j = x/face
+ int k = cx1.ja * i1 + cx1.jb * j1 + cx1.jc; // k = y/face
+ int ijk = k * nbx * nby + j * nbx + i;
+ //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
+ np[ijk].node = quad->uv_grid[ij1].node;
+ //SCRUTE(np[ijk].nodeId);
+ }
+ }
+
+ {
+ const TopoDS_Face & F = TopoDS::Face(meshFaces[_indY0]->GetSubShape());
+
+ SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
+
+ faceQuadStruct *quad = _cube.quad_Y0;
+ int j = 0; // i = x/face , k = y/face
+ int nbdown = quad->nbPts[0];
+ int nbright = quad->nbPts[1];
+
+ while(itf->more())
+ {
+ const SMDS_MeshNode * node = itf->next();
+ const SMDS_FacePosition * fpos =
+ static_cast<const SMDS_FacePosition*>(node->GetPosition().get());
+ double ri = fpos->GetUParameter();
+ double rj = fpos->GetVParameter();
+ int i1 = int (ri);
+ int j1 = int (rj);
+ int ij1 = j1 * nbdown + i1;
+ quad->uv_grid[ij1].node = node;
+ }
+
+ for (int i1 = 0; i1 < nbdown; i1++)
+ for (int j1 = 0; j1 < nbright; j1++)
+ {
+ int ij1 = j1 * nbdown + i1;
+ int i = cy0.ia * i1 + cy0.ib * j1 + cy0.ic; // i = x/face
+ int k = cy0.ja * i1 + cy0.jb * j1 + cy0.jc; // k = y/face
+ int ijk = k * nbx * nby + j * nbx + i;
+ //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
+ np[ijk].node = quad->uv_grid[ij1].node;
+ //SCRUTE(np[ijk].nodeId);
+ }
+ }
+
+ {
+ const TopoDS_Face & F = TopoDS::Face(meshFaces[_indY1]->GetSubShape());
+
+ SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
+
+ faceQuadStruct *quad = _cube.quad_Y1;
+ int j = nby - 1; // i = x/face , k = y/face
+ int nbdown = quad->nbPts[0];
+ int nbright = quad->nbPts[1];
+
+ while(itf->more())
+ {
+ const SMDS_MeshNode * node = itf->next();
+ const SMDS_FacePosition* fpos =
+ static_cast<const SMDS_FacePosition *>(node->GetPosition().get());
+ double ri = fpos->GetUParameter();
+ double rj = fpos->GetVParameter();
+ int i1 = int (ri);
+ int j1 = int (rj);
+ int ij1 = j1 * nbdown + i1;
+ quad->uv_grid[ij1].node = node;
+ }
+
+ for (int i1 = 0; i1 < nbdown; i1++)
+ for (int j1 = 0; j1 < nbright; j1++)
+ {
+ int ij1 = j1 * nbdown + i1;
+ int i = cy1.ia * i1 + cy1.ib * j1 + cy1.ic; // i = x/face
+ int k = cy1.ja * i1 + cy1.jb * j1 + cy1.jc; // k = y/face
+ int ijk = k * nbx * nby + j * nbx + i;
+ //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
+ np[ijk].node = quad->uv_grid[ij1].node;
+ //SCRUTE(np[ijk].nodeId);
+ }
+ }
+
+ {
+ const TopoDS_Face & F = TopoDS::Face(meshFaces[_indZ0]->GetSubShape());
+
+ SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
+
+ faceQuadStruct *quad = _cube.quad_Z0;
+ int k = 0; // i = x/face , j = y/face
+ int nbdown = quad->nbPts[0];
+ int nbright = quad->nbPts[1];
+
+ while(itf->more())
+ {
+ const SMDS_MeshNode * node = itf->next();
+ const SMDS_FacePosition * fpos =
+ static_cast<const SMDS_FacePosition*>(node->GetPosition().get());
+ double ri = fpos->GetUParameter();
+ double rj = fpos->GetVParameter();
+ int i1 = int (ri);
+ int j1 = int (rj);
+ int ij1 = j1 * nbdown + i1;
+ quad->uv_grid[ij1].node = node;
+ }
+
+ for (int i1 = 0; i1 < nbdown; i1++)
+ for (int j1 = 0; j1 < nbright; j1++)
+ {
+ int ij1 = j1 * nbdown + i1;
+ int i = cz0.ia * i1 + cz0.ib * j1 + cz0.ic; // i = x/face
+ int j = cz0.ja * i1 + cz0.jb * j1 + cz0.jc; // j = y/face
+ int ijk = k * nbx * nby + j * nbx + i;
+ //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
+ np[ijk].node = quad->uv_grid[ij1].node;
+ //SCRUTE(np[ijk].nodeId);
+ }
+ }
+
+ {
+ const TopoDS_Face & F = TopoDS::Face(meshFaces[_indZ1]->GetSubShape());
+
+ SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
+
+ faceQuadStruct *quad = _cube.quad_Z1;
+ int k = nbz - 1; // i = x/face , j = y/face
+ int nbdown = quad->nbPts[0];
+ int nbright = quad->nbPts[1];
+
+ while(itf->more())
+ {
+ const SMDS_MeshNode * node = itf->next();
+ const SMDS_FacePosition* fpos =
+ static_cast<const SMDS_FacePosition*>(node->GetPosition().get());
+ double ri = fpos->GetUParameter();
+ double rj = fpos->GetVParameter();
+ int i1 = int (ri);
+ int j1 = int (rj);
+ int ij1 = j1 * nbdown + i1;
+ quad->uv_grid[ij1].node = node;
+ }
+
+ for (int i1 = 0; i1 < nbdown; i1++)
+ for (int j1 = 0; j1 < nbright; j1++)
+ {
+ int ij1 = j1 * nbdown + i1;
+ int i = cz1.ia * i1 + cz1.ib * j1 + cz1.ic; // i = x/face
+ int j = cz1.ja * i1 + cz1.jb * j1 + cz1.jc; // j = y/face
+ int ijk = k * nbx * nby + j * nbx + i;
+ //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
+ np[ijk].node = quad->uv_grid[ij1].node;
+ //SCRUTE(np[ijk].nodeId);
+ }
+ }
+
+ // 2.0 - for each node of the cube:
+ // - get the 8 points 3D = 8 vertices of the cube
+ // - get the 12 points 3D on the 12 edges of the cube
+ // - get the 6 points 3D on the 6 faces with their ID
+ // - compute the point 3D
+ // - store the point 3D in SMESHDS, store its ID in 3D structure
+
+ TopoDS_Shell aShell;
+ TopExp_Explorer exp(aShape, TopAbs_SHELL);
+ if (exp.More())
+ {
+ aShell = TopoDS::Shell(exp.Current());
+ }
+ else
+ {
+ MESSAGE("no shell...");
+ ASSERT(0);
+ }
+
+ Pt3 p000, p001, p010, p011, p100, p101, p110, p111;
+ Pt3 px00, px01, px10, px11;
+ Pt3 p0y0, p0y1, p1y0, p1y1;
+ Pt3 p00z, p01z, p10z, p11z;
+ Pt3 pxy0, pxy1, px0z, px1z, p0yz, p1yz;
+
+ GetPoint(p000, 0, 0, 0, nbx, nby, nbz, np, meshDS);
+ GetPoint(p001, 0, 0, nbz - 1, nbx, nby, nbz, np, meshDS);
+ GetPoint(p010, 0, nby - 1, 0, nbx, nby, nbz, np, meshDS);
+ GetPoint(p011, 0, nby - 1, nbz - 1, nbx, nby, nbz, np, meshDS);
+ GetPoint(p100, nbx - 1, 0, 0, nbx, nby, nbz, np, meshDS);
+ GetPoint(p101, nbx - 1, 0, nbz - 1, nbx, nby, nbz, np, meshDS);
+ GetPoint(p110, nbx - 1, nby - 1, 0, nbx, nby, nbz, np, meshDS);
+ GetPoint(p111, nbx - 1, nby - 1, nbz - 1, nbx, nby, nbz, np, meshDS);
+
+ for (int i = 1; i < nbx - 1; i++)
+ {
+ for (int j = 1; j < nby - 1; j++)
+ {
+ for (int k = 1; k < nbz - 1; k++)
+ {
+ // *** seulement maillage regulier
+ // 12 points on edges
+ GetPoint(px00, i, 0, 0, nbx, nby, nbz, np, meshDS);
+ GetPoint(px01, i, 0, nbz - 1, nbx, nby, nbz, np, meshDS);
+ GetPoint(px10, i, nby - 1, 0, nbx, nby, nbz, np, meshDS);
+ GetPoint(px11, i, nby - 1, nbz - 1, nbx, nby, nbz, np, meshDS);
+
+ GetPoint(p0y0, 0, j, 0, nbx, nby, nbz, np, meshDS);
+ GetPoint(p0y1, 0, j, nbz - 1, nbx, nby, nbz, np, meshDS);
+ GetPoint(p1y0, nbx - 1, j, 0, nbx, nby, nbz, np, meshDS);
+ GetPoint(p1y1, nbx - 1, j, nbz - 1, nbx, nby, nbz, np, meshDS);
+
+ GetPoint(p00z, 0, 0, k, nbx, nby, nbz, np, meshDS);
+ GetPoint(p01z, 0, nby - 1, k, nbx, nby, nbz, np, meshDS);
+ GetPoint(p10z, nbx - 1, 0, k, nbx, nby, nbz, np, meshDS);
+ GetPoint(p11z, nbx - 1, nby - 1, k, nbx, nby, nbz, np, meshDS);
+
+ // 12 points on faces
+ GetPoint(pxy0, i, j, 0, nbx, nby, nbz, np, meshDS);
+ GetPoint(pxy1, i, j, nbz - 1, nbx, nby, nbz, np, meshDS);
+ GetPoint(px0z, i, 0, k, nbx, nby, nbz, np, meshDS);
+ GetPoint(px1z, i, nby - 1, k, nbx, nby, nbz, np, meshDS);
+ GetPoint(p0yz, 0, j, k, nbx, nby, nbz, np, meshDS);
+ GetPoint(p1yz, nbx - 1, j, k, nbx, nby, nbz, np, meshDS);
+
+ int ijk = k * nbx * nby + j * nbx + i;
+ double x = double (i) / double (nbx - 1); // *** seulement
+ double y = double (j) / double (nby - 1); // *** maillage
+ double z = double (k) / double (nbz - 1); // *** regulier
+
+ Pt3 X;
+ for (int i = 0; i < 3; i++)
+ {
+ X[i] =
+ (1 - x) * p0yz[i] + x * p1yz[i]
+ + (1 - y) * px0z[i] + y * px1z[i]
+ + (1 - z) * pxy0[i] + z * pxy1[i]
+ - (1 - x) * ((1 - y) * p00z[i] + y * p01z[i])
+ - x * ((1 - y) * p10z[i] + y * p11z[i])
+ - (1 - y) * ((1 - z) * px00[i] + z * px01[i])
+ - y * ((1 - z) * px10[i] + z * px11[i])
+ - (1 - z) * ((1 - x) * p0y0[i] + x * p1y0[i])
+ - z * ((1 - x) * p0y1[i] + x * p1y1[i])
+ + (1 - x) * ((1 - y) * ((1 - z) * p000[i] + z * p001[i])
+ + y * ((1 - z) * p010[i] + z * p011[i]))
+ + x * ((1 - y) * ((1 - z) * p100[i] + z * p101[i])
+ + y * ((1 - z) * p110[i] + z * p111[i]));
+ }
+
+ SMDS_MeshNode * node = meshDS->AddNode(X[0], X[1], X[2]);
+ np[ijk].node = node;
+ //meshDS->SetNodeInVolume(node, TopoDS::Solid(aShape));
+ meshDS->SetNodeInVolume(node, aShell);
+ }
+ }
+ }
+
+ //2.1 - for each node of the cube (less 3 *1 Faces):
+ // - store hexahedron in SMESHDS
+ MESSAGE("Storing hexahedron into the DS");
+ for (int i = 0; i < nbx - 1; i++)
+ for (int j = 0; j < nby - 1; j++)
+ for (int k = 0; k < nbz - 1; k++)
+ {
+ int n1 = k * nbx * nby + j * nbx + i;
+ int n2 = k * nbx * nby + j * nbx + i + 1;
+ int n3 = k * nbx * nby + (j + 1) * nbx + i + 1;
+ int n4 = k * nbx * nby + (j + 1) * nbx + i;
+ int n5 = (k + 1) * nbx * nby + j * nbx + i;
+ int n6 = (k + 1) * nbx * nby + j * nbx + i + 1;
+ int n7 = (k + 1) * nbx * nby + (j + 1) * nbx + i + 1;
+ int n8 = (k + 1) * nbx * nby + (j + 1) * nbx + i;
+
+// MESSAGE(" "<<n1<<" "<<n2<<" "<<n3<<" "<<n4<<" "<<n5<<" "<<n6<<" "<<n7<<" "<<n8);
+ //MESSAGE(" "<<np[n1].nodeId<<" "<<np[n2].nodeId<<" "<<np[n3].nodeId<<" "<<np[n4].nodeId<<" "<<np[n5].nodeId<<" "<<np[n6].nodeId<<" "<<np[n7].nodeId<<" "<<np[n8].nodeId);
+
+ SMDS_MeshVolume * elt = meshDS->AddVolume(np[n1].node,
+ np[n2].node,
+ np[n3].node,
+ np[n4].node,
+ np[n5].node,
+ np[n6].node,
+ np[n7].node,
+ np[n8].node);
+ ;
+ meshDS->SetMeshElementOnShape(elt, aShell);
+
+ // *** 5 tetrahedres ... verifier orientations,
+ // mettre en coherence &vec quadrangles-> triangles
+ // choisir afficher 1 parmi edges, face et volumes
+// int tetra1 = meshDS->AddVolume(np[n1].nodeId,
+// np[n2].nodeId,
+// np[n4].nodeId,
+// np[n5].nodeId);
+// int tetra2 = meshDS->AddVolume(np[n2].nodeId,
+// np[n3].nodeId,
+// np[n4].nodeId,
+// np[n7].nodeId);
+// int tetra3 = meshDS->AddVolume(np[n5].nodeId,
+// np[n6].nodeId,
+// np[n7].nodeId,
+// np[n2].nodeId);
+// int tetra4 = meshDS->AddVolume(np[n5].nodeId,
+// np[n7].nodeId,
+// np[n8].nodeId,
+// np[n4].nodeId);
+// int tetra5 = meshDS->AddVolume(np[n5].nodeId,
+// np[n7].nodeId,
+// np[n2].nodeId,
+// np[n4].nodeId);
+
+ }
+
+ MESSAGE("End of StdMeshers_Hexa_3D::Compute()");
+ return true;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void StdMeshers_Hexa_3D::GetPoint(Pt3 p, int i, int j, int k, int nbx, int nby,
+ int nbz, Point3DStruct * np, const SMESHDS_Mesh * meshDS)
+{
+ int ijk = k * nbx * nby + j * nbx + i;
+ const SMDS_MeshNode * node = np[ijk].node;
+ p[0] = node->X();
+ p[1] = node->Y();
+ p[2] = node->Z();
+ //MESSAGE(" "<<i<<" "<<j<<" "<<k<<" "<<p[0]<<" "<<p[1]<<" "<<p[2]);
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+int StdMeshers_Hexa_3D::GetFaceIndex(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape,
+ const vector < SMESH_subMesh * >&meshFaces,
+ const TopoDS_Vertex & V0,
+ const TopoDS_Vertex & V1,
+ const TopoDS_Vertex & V2, const TopoDS_Vertex & V3)
+{
+ MESSAGE("StdMeshers_Hexa_3D::GetFaceIndex");
+ int faceIndex = -1;
+ for (int i = 1; i < 6; i++)
+ {
+ const TopoDS_Shape & aFace = meshFaces[i]->GetSubShape();
+ //const TopoDS_Face& F = TopoDS::Face(aFace);
+ TopTools_IndexedMapOfShape M;
+ TopExp::MapShapes(aFace, TopAbs_VERTEX, M);
+ bool verticesInShape = false;
+ if (M.Contains(V0))
+ if (M.Contains(V1))
+ if (M.Contains(V2))
+ if (M.Contains(V3))
+ verticesInShape = true;
+ if (verticesInShape)
+ {
+ faceIndex = i;
+ break;
+ }
+ }
+ ASSERT(faceIndex > 0);
+ SCRUTE(faceIndex);
+ return faceIndex;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+TopoDS_Edge
+ StdMeshers_Hexa_3D::EdgeNotInFace(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape,
+ const TopoDS_Face & aFace,
+ const TopoDS_Vertex & aVertex,
+ const TopTools_IndexedDataMapOfShapeListOfShape & MS)
+{
+ MESSAGE("StdMeshers_Hexa_3D::EdgeNotInFace");
+ TopTools_IndexedDataMapOfShapeListOfShape MF;
+ TopExp::MapShapesAndAncestors(aFace, TopAbs_VERTEX, TopAbs_EDGE, MF);
+ const TopTools_ListOfShape & ancestorsInSolid = MS.FindFromKey(aVertex);
+ const TopTools_ListOfShape & ancestorsInFace = MF.FindFromKey(aVertex);
+ SCRUTE(ancestorsInSolid.Extent());
+ SCRUTE(ancestorsInFace.Extent());
+ ASSERT(ancestorsInSolid.Extent() == 6); // 6 (edges doublees)
+ ASSERT(ancestorsInFace.Extent() == 2);
+
+ TopoDS_Edge E;
+ E.Nullify();
+ TopTools_ListIteratorOfListOfShape its(ancestorsInSolid);
+ for (; its.More(); its.Next())
+ {
+ TopoDS_Shape ancestor = its.Value();
+ TopTools_ListIteratorOfListOfShape itf(ancestorsInFace);
+ bool isInFace = false;
+ for (; itf.More(); itf.Next())
+ {
+ TopoDS_Shape ancestorInFace = itf.Value();
+ if (ancestorInFace.IsSame(ancestor))
+ {
+ isInFace = true;
+ break;
+ }
+ }
+ if (!isInFace)
+ {
+ E = TopoDS::Edge(ancestor);
+ break;
+ }
+ }
+ return E;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void StdMeshers_Hexa_3D::GetConv2DCoefs(const faceQuadStruct & quad,
+ const TopoDS_Shape & aShape,
+ const TopoDS_Vertex & V0,
+ const TopoDS_Vertex & V1,
+ const TopoDS_Vertex & V2, const TopoDS_Vertex & V3, Conv2DStruct & conv)
+{
+ MESSAGE("StdMeshers_Hexa_3D::GetConv2DCoefs");
+ const TopoDS_Face & F = TopoDS::Face(aShape);
+ TopoDS_Edge E = quad.edge[0];
+ double f, l;
+ Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
+ TopoDS_Vertex VFirst, VLast;
+ TopExp::Vertices(E, VFirst, VLast); // corresponds to f and l
+ bool isForward = (((l - f) * (quad.last[0] - quad.first[0])) > 0);
+ TopoDS_Vertex VA, VB;
+ if (isForward)
+ {
+ VA = VFirst;
+ VB = VLast;
+ }
+ else
+ {
+ VA = VLast;
+ VB = VFirst;
+ }
+ int a1, b1, c1, a2, b2, c2;
+ if (VA.IsSame(V0))
+ if (VB.IsSame(V1))
+ {
+ a1 = 1;
+ b1 = 0;
+ c1 = 0; // x
+ a2 = 0;
+ b2 = 1;
+ c2 = 0; // y
+ }
+ else
+ {
+ ASSERT(VB.IsSame(V3));
+ a1 = 0;
+ b1 = 1;
+ c1 = 0; // y
+ a2 = 1;
+ b2 = 0;
+ c2 = 0; // x
+ }
+ if (VA.IsSame(V1))
+ if (VB.IsSame(V2))
+ {
+ a1 = 0;
+ b1 = -1;
+ c1 = 1; // 1-y
+ a2 = 1;
+ b2 = 0;
+ c2 = 0; // x
+ }
+ else
+ {
+ ASSERT(VB.IsSame(V0));
+ a1 = -1;
+ b1 = 0;
+ c1 = 1; // 1-x
+ a2 = 0;
+ b2 = 1;
+ c2 = 0; // y
+ }
+ if (VA.IsSame(V2))
+ if (VB.IsSame(V3))
+ {
+ a1 = -1;
+ b1 = 0;
+ c1 = 1; // 1-x
+ a2 = 0;
+ b2 = -1;
+ c2 = 1; // 1-y
+ }
+ else
+ {
+ ASSERT(VB.IsSame(V1));
+ a1 = 0;
+ b1 = -1;
+ c1 = 1; // 1-y
+ a2 = -1;
+ b2 = 0;
+ c2 = 1; // 1-x
+ }
+ if (VA.IsSame(V3))
+ if (VB.IsSame(V0))
+ {
+ a1 = 0;
+ b1 = 1;
+ c1 = 0; // y
+ a2 = -1;
+ b2 = 0;
+ c2 = 1; // 1-x
+ }
+ else
+ {
+ ASSERT(VB.IsSame(V2));
+ a1 = 1;
+ b1 = 0;
+ c1 = 0; // x
+ a2 = 0;
+ b2 = -1;
+ c2 = 1; // 1-y
+ }
+ MESSAGE("X = " << c1 << "+ " << a1 << "*x + " << b1 << "*y");
+ MESSAGE("Y = " << c2 << "+ " << a2 << "*x + " << b2 << "*y");
+ conv.a1 = a1;
+ conv.b1 = b1;
+ conv.c1 = c1;
+ conv.a2 = a2;
+ conv.b2 = b2;
+ conv.c2 = c2;
+
+ int nbdown = quad.nbPts[0];
+ int nbright = quad.nbPts[1];
+ conv.ia = int (a1);
+ conv.ib = int (b1);
+ conv.ic =
+ int (c1 * a1 * a1) * (nbdown - 1) + int (c1 * b1 * b1) * (nbright - 1);
+ conv.ja = int (a2);
+ conv.jb = int (b2);
+ conv.jc =
+ int (c2 * a2 * a2) * (nbdown - 1) + int (c2 * b2 * b2) * (nbright - 1);
+ MESSAGE("I " << conv.ia << " " << conv.ib << " " << conv.ic);
+ MESSAGE("J " << conv.ja << " " << conv.jb << " " << conv.jc);
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & StdMeshers_Hexa_3D::SaveTo(ostream & save)
+{
+ return save;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & StdMeshers_Hexa_3D::LoadFrom(istream & load)
+{
+ return load;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & operator <<(ostream & save, StdMeshers_Hexa_3D & hyp)
+{
+ return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & operator >>(istream & load, StdMeshers_Hexa_3D & hyp)
+{
+ return hyp.LoadFrom( load );
+}
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_Hexa_3D.hxx
+// Moved here from SMESH_Hexa_3D.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_HEXA_3D_HXX_
+#define _SMESH_HEXA_3D_HXX_
+
+#include "SMESH_3D_Algo.hxx"
+#include "SMESH_Mesh.hxx"
+#include "StdMeshers_Quadrangle_2D.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+typedef struct point3Dstruct
+{
+ const SMDS_MeshNode * node;
+} Point3DStruct;
+
+typedef double Pt3[3];
+
+typedef struct conv2dstruct
+{
+ double a1; // X = a1*x + b1*y + c1
+ double b1; // Y = a2*x + b2*y + c2
+ double c1; // a1, b1 a2, b2 in {-1,0,1}
+ double a2; // c1, c2 in {0,1}
+ double b2;
+ double c2;
+ int ia; // I = ia*i + ib*j + ic
+ int ib;
+ int ic;
+ int ja; // J = ja*i + jb*j + jc
+ int jb;
+ int jc;
+} Conv2DStruct;
+
+typedef struct cubeStruct
+{
+ TopoDS_Vertex V000;
+ TopoDS_Vertex V001;
+ TopoDS_Vertex V010;
+ TopoDS_Vertex V011;
+ TopoDS_Vertex V100;
+ TopoDS_Vertex V101;
+ TopoDS_Vertex V110;
+ TopoDS_Vertex V111;
+ faceQuadStruct* quad_X0;
+ faceQuadStruct* quad_X1;
+ faceQuadStruct* quad_Y0;
+ faceQuadStruct* quad_Y1;
+ faceQuadStruct* quad_Z0;
+ faceQuadStruct* quad_Z1;
+ Point3DStruct* np; // normalised 3D coordinates
+} CubeStruct;
+
+class StdMeshers_Hexa_3D:
+ public SMESH_3D_Algo
+{
+public:
+ StdMeshers_Hexa_3D(int hypId, int studyId, SMESH_Gen* gen);
+ virtual ~StdMeshers_Hexa_3D();
+
+ virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ SMESH_Hypothesis::Hypothesis_Status& aStatus);
+
+ virtual bool Compute(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape)
+ throw (SALOME_Exception);
+
+ ostream & SaveTo(ostream & save);
+ istream & LoadFrom(istream & load);
+ friend ostream & operator << (ostream & save, StdMeshers_Hexa_3D & hyp);
+ friend istream & operator >> (istream & load, StdMeshers_Hexa_3D & hyp);
+
+protected:
+ TopoDS_Edge
+ EdgeNotInFace(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ const TopoDS_Face& aFace,
+ const TopoDS_Vertex& aVertex,
+ const TopTools_IndexedDataMapOfShapeListOfShape& MS);
+
+ int GetFaceIndex(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ const vector<SMESH_subMesh*>& meshFaces,
+ const TopoDS_Vertex& V0,
+ const TopoDS_Vertex& V1,
+ const TopoDS_Vertex& V2,
+ const TopoDS_Vertex& V3);
+
+ void GetConv2DCoefs(const faceQuadStruct& quad,
+ const TopoDS_Shape& aShape,
+ const TopoDS_Vertex& V0,
+ const TopoDS_Vertex& V1,
+ const TopoDS_Vertex& V2,
+ const TopoDS_Vertex& V3,
+ Conv2DStruct& conv);
+
+ void GetPoint(Pt3 p,
+ int i, int j, int k,
+ int nbx, int nby, int nbz,
+ Point3DStruct *np,
+ const SMESHDS_Mesh* meshDS);
+
+ CubeStruct _cube;
+ FaceQuadStruct* _quads[6];
+ int _indX0;
+ int _indX1;
+ int _indY0;
+ int _indY1;
+ int _indZ0;
+ int _indZ1;
+};
+
+#endif
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_LengthFromEdges.cxx
+// Moved here from SMESH_LengthFromEdges.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_LengthFromEdges.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_LengthFromEdges::StdMeshers_LengthFromEdges(int hypId, int studyId, SMESH_Gen* gen)
+ : SMESH_Hypothesis(hypId, studyId, gen)
+{
+ _mode =1;
+ _name = "LengthFromEdges";
+// SCRUTE(_name);
+// SCRUTE(&_name);
+ _param_algo_dim = 2; // is used by SMESH_MEFISTO_2D
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_LengthFromEdges::~StdMeshers_LengthFromEdges()
+{
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void StdMeshers_LengthFromEdges::SetMode(int mode)
+ throw (SALOME_Exception)
+{
+ int oldMode = _mode;
+ if (mode <= 0)
+ throw SALOME_Exception(LOCALIZED("mode must be positive"));
+ _mode = mode;
+ if (oldMode != _mode)
+ NotifySubMeshesHypothesisModification();
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+int StdMeshers_LengthFromEdges::GetMode()
+{
+ return _mode;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & StdMeshers_LengthFromEdges::SaveTo(ostream & save)
+{
+ save << this->_mode;
+ return save;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & StdMeshers_LengthFromEdges::LoadFrom(istream & load)
+{
+ bool isOK = true;
+ int a;
+ isOK = (load >> a);
+ if (isOK)
+ this->_mode = a;
+ else
+ load.clear(ios::badbit | load.rdstate());
+ return load;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & operator << (ostream & save, StdMeshers_LengthFromEdges & hyp)
+{
+ return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & operator >> (istream & load, StdMeshers_LengthFromEdges & hyp)
+{
+ return hyp.LoadFrom( load );
+}
+
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_LengthFromEdges.hxx
+// Moved here from SMESH_LengthFromEdges.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_LENGTHFROMEDGES_HXX_
+#define _SMESH_LENGTHFROMEDGES_HXX_
+
+#include "SMESH_Hypothesis.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+class StdMeshers_LengthFromEdges:
+ public SMESH_Hypothesis
+{
+public:
+ StdMeshers_LengthFromEdges(int hypId, int studyId, SMESH_Gen* gen);
+ virtual ~StdMeshers_LengthFromEdges();
+
+ void SetMode(int mode)
+ throw (SALOME_Exception);
+
+ int GetMode();
+
+ virtual ostream & SaveTo(ostream & save);
+ virtual istream & LoadFrom(istream & load);
+ friend ostream & operator << (ostream & save, StdMeshers_LengthFromEdges & hyp);
+ friend istream & operator >> (istream & load, StdMeshers_LengthFromEdges & hyp);
+
+protected:
+ int _mode;
+};
+
+#endif
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_LocalLength.cxx
+// Moved here from SMESH_LocalLength.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_LocalLength.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_LocalLength::StdMeshers_LocalLength(int hypId, int studyId,
+ SMESH_Gen * gen):SMESH_Hypothesis(hypId, studyId, gen)
+{
+ _length = 1.;
+ _name = "LocalLength";
+// SCRUTE(_name);
+// SCRUTE(&_name);
+ _param_algo_dim = 1; // is used by SMESH_Regular_1D
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_LocalLength::~StdMeshers_LocalLength()
+{
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void StdMeshers_LocalLength::SetLength(double length) throw(SALOME_Exception)
+{
+ double oldLength = _length;
+ if (length <= 0)
+ throw SALOME_Exception(LOCALIZED("length must be positive"));
+ _length = length;
+ if (oldLength != _length)
+ NotifySubMeshesHypothesisModification();
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+double StdMeshers_LocalLength::GetLength() const
+{
+ return _length;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & StdMeshers_LocalLength::SaveTo(ostream & save)
+{
+ save << this->_length;
+ return save;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & StdMeshers_LocalLength::LoadFrom(istream & load)
+{
+ bool isOK = true;
+ double a;
+ isOK = (load >> a);
+ if (isOK)
+ this->_length = a;
+ else
+ load.clear(ios::badbit | load.rdstate());
+ return load;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & operator <<(ostream & save, StdMeshers_LocalLength & hyp)
+{
+ return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & operator >>(istream & load, StdMeshers_LocalLength & hyp)
+{
+ return hyp.LoadFrom( load );
+}
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_LocalLength.hxx
+// Moved here from SMESH_LocalLength.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_LOCALLENGTH_HXX_
+#define _SMESH_LOCALLENGTH_HXX_
+
+#include "SMESH_Hypothesis.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+class StdMeshers_LocalLength:public SMESH_Hypothesis
+{
+ public:
+ StdMeshers_LocalLength(int hypId, int studyId, SMESH_Gen * gen);
+ virtual ~ StdMeshers_LocalLength();
+
+ void SetLength(double length) throw(SALOME_Exception);
+
+ double GetLength() const;
+
+ virtual ostream & SaveTo(ostream & save);
+ virtual istream & LoadFrom(istream & load);
+ friend ostream & operator <<(ostream & save, StdMeshers_LocalLength & hyp);
+ friend istream & operator >>(istream & load, StdMeshers_LocalLength & hyp);
+
+ protected:
+ double _length;
+};
+
+#endif
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_MEFISTO_2D.cxx
+// Moved here from SMESH_MEFISTO_2D.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_MEFISTO_2D.hxx"
+#include "SMESH_Gen.hxx"
+#include "SMESH_Mesh.hxx"
+
+#include "StdMeshers_MaxElementArea.hxx"
+#include "StdMeshers_LengthFromEdges.hxx"
+
+#include "Rn.h"
+#include "aptrte.h"
+
+#include "SMDS_MeshElement.hxx"
+#include "SMDS_MeshNode.hxx"
+#include "SMDS_EdgePosition.hxx"
+#include "SMDS_FacePosition.hxx"
+
+#include "utilities.h"
+
+#include <TopoDS_Face.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Shape.hxx>
+#include <Geom_Surface.hxx>
+#include <GeomAdaptor_Curve.hxx>
+#include <Geom2d_Curve.hxx>
+#include <gp_Pnt2d.hxx>
+#include <BRep_Tool.hxx>
+#include <BRepTools.hxx>
+#include <BRepTools_WireExplorer.hxx>
+#include <GCPnts_AbscissaPoint.hxx>
+#include <GCPnts_UniformAbscissa.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
+
+#include <string>
+#include <algorithm>
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_MEFISTO_2D::StdMeshers_MEFISTO_2D(int hypId, int studyId,
+ SMESH_Gen * gen):SMESH_2D_Algo(hypId, studyId, gen)
+{
+ MESSAGE("StdMeshers_MEFISTO_2D::StdMeshers_MEFISTO_2D");
+ _name = "MEFISTO_2D";
+// _shapeType = TopAbs_FACE;
+ _shapeType = (1 << TopAbs_FACE);
+ _compatibleHypothesis.push_back("MaxElementArea");
+ _compatibleHypothesis.push_back("LengthFromEdges");
+
+ _edgeLength = 0;
+ _maxElementArea = 0;
+ _hypMaxElementArea = NULL;
+ _hypLengthFromEdges = NULL;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_MEFISTO_2D::~StdMeshers_MEFISTO_2D()
+{
+ MESSAGE("StdMeshers_MEFISTO_2D::~StdMeshers_MEFISTO_2D");
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+bool StdMeshers_MEFISTO_2D::CheckHypothesis
+ (SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ SMESH_Hypothesis::Hypothesis_Status& aStatus)
+{
+ //MESSAGE("StdMeshers_MEFISTO_2D::CheckHypothesis");
+
+ _hypMaxElementArea = NULL;
+ _hypLengthFromEdges = NULL;
+
+ list <const SMESHDS_Hypothesis * >::const_iterator itl;
+ const SMESHDS_Hypothesis *theHyp;
+
+ const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
+ int nbHyp = hyps.size();
+ if (!nbHyp)
+ {
+ aStatus = SMESH_Hypothesis::HYP_MISSING;
+ return false; // can't work with no hypothesis
+ }
+
+ itl = hyps.begin();
+ theHyp = (*itl); // use only the first hypothesis
+
+ string hypName = theHyp->GetName();
+ int hypId = theHyp->GetID();
+ //SCRUTE(hypName);
+
+ bool isOk = false;
+
+ if (hypName == "MaxElementArea")
+ {
+ _hypMaxElementArea = static_cast<const StdMeshers_MaxElementArea *>(theHyp);
+ ASSERT(_hypMaxElementArea);
+ _maxElementArea = _hypMaxElementArea->GetMaxArea();
+ _edgeLength = 0;
+ isOk = true;
+ aStatus = SMESH_Hypothesis::HYP_OK;
+ }
+
+ else if (hypName == "LengthFromEdges")
+ {
+ _hypLengthFromEdges = static_cast<const StdMeshers_LengthFromEdges *>(theHyp);
+ ASSERT(_hypLengthFromEdges);
+ _edgeLength = 0;
+ _maxElementArea = 0;
+ isOk = true;
+ aStatus = SMESH_Hypothesis::HYP_OK;
+ }
+ else
+ aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
+
+ if (isOk)
+ {
+ isOk = false;
+ if (_maxElementArea > 0)
+ {
+ _edgeLength = 2 * sqrt(_maxElementArea); // triangles : minorant
+ isOk = true;
+ }
+ else
+ isOk = (_hypLengthFromEdges != NULL); // **** check mode
+ if (!isOk)
+ aStatus = SMESH_Hypothesis::HYP_BAD_PARAMETER;
+ }
+
+ //SCRUTE(_edgeLength);
+ //SCRUTE(_maxElementArea);
+ return isOk;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+bool StdMeshers_MEFISTO_2D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)
+{
+ MESSAGE("StdMeshers_MEFISTO_2D::Compute");
+
+ if (_hypLengthFromEdges)
+ _edgeLength = ComputeEdgeElementLength(aMesh, aShape);
+
+ bool isOk = false;
+ const SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
+ SMESH_subMesh *theSubMesh = aMesh.GetSubMesh(aShape);
+
+ const TopoDS_Face & FF = TopoDS::Face(aShape);
+ bool faceIsForward = (FF.Orientation() == TopAbs_FORWARD);
+ TopoDS_Face F = TopoDS::Face(FF.Oriented(TopAbs_FORWARD));
+
+ Z nblf; //nombre de lignes fermees (enveloppe en tete)
+ Z *nudslf = NULL; //numero du dernier sommet de chaque ligne fermee
+ R2 *uvslf = NULL;
+ Z nbpti = 0; //nombre points internes futurs sommets de la triangulation
+ R2 *uvpti = NULL;
+
+ Z nbst;
+ R2 *uvst = NULL;
+ Z nbt;
+ Z *nust = NULL;
+ Z ierr = 0;
+
+ Z nutysu = 1; // 1: il existe un fonction areteideale_()
+ // Z nutysu=0; // 0: on utilise aretmx
+ R aretmx = _edgeLength; // longueur max aretes future triangulation
+ //SCRUTE(aretmx);
+
+ nblf = NumberOfWires(F);
+ //SCRUTE(nblf);
+
+ nudslf = new Z[1 + nblf];
+ nudslf[0] = 0;
+ int iw = 1;
+ int nbpnt = 0;
+
+ const TopoDS_Wire OW1 = BRepTools::OuterWire(F);
+ nbpnt += NumberOfPoints(aMesh, OW1);
+ nudslf[iw++] = nbpnt;
+ //SCRUTE(nbpnt);
+
+ for (TopExp_Explorer exp(F, TopAbs_WIRE); exp.More(); exp.Next())
+ {
+ const TopoDS_Wire & W = TopoDS::Wire(exp.Current());
+ if (!OW1.IsSame(W))
+ {
+ nbpnt += NumberOfPoints(aMesh, W);
+ nudslf[iw++] = nbpnt;
+ //SCRUTE(nbpnt);
+ }
+ }
+
+ uvslf = new R2[nudslf[nblf]];
+ //SCRUTE(nudslf[nblf]);
+ int m = 0;
+
+ map<int, const SMDS_MeshNode*> mefistoToDS; // correspondence mefisto index--> points IDNodes
+ TopoDS_Wire OW = BRepTools::OuterWire(F);
+ LoadPoints(aMesh, F, OW, uvslf, m, mefistoToDS);
+ //SCRUTE(m);
+
+ for (TopExp_Explorer exp(F, TopAbs_WIRE); exp.More(); exp.Next())
+ {
+ const TopoDS_Wire & W = TopoDS::Wire(exp.Current());
+ if (!OW.IsSame(W))
+ {
+ LoadPoints(aMesh, F, W, uvslf, m, mefistoToDS);
+ //SCRUTE(m);
+ }
+ }
+// SCRUTE(nudslf[nblf]);
+// for (int i=0; i<=nblf; i++)
+// {
+// MESSAGE(" -+- " <<i<< " "<< nudslf[i]);
+// }
+// for (int i=0; i<nudslf[nblf]; i++)
+// {
+// MESSAGE(" -+- " <<i<< " "<< uvslf[i]);
+// }
+// SCRUTE(nutysu);
+// SCRUTE(aretmx);
+// SCRUTE(nblf);
+
+ MESSAGE("MEFISTO triangulation ...");
+ uvst = NULL;
+ nust = NULL;
+ aptrte(nutysu, aretmx,
+ nblf, nudslf, uvslf, nbpti, uvpti, nbst, uvst, nbt, nust, ierr);
+
+ if (ierr == 0)
+ {
+ MESSAGE("... End Triangulation Generated Triangle Number " << nbt);
+ MESSAGE(" Node Number " << nbst);
+ //SCRUTE(nbst);
+ //SCRUTE(nbt);
+ StoreResult(aMesh, nbst, uvst, nbt, nust, F,
+ faceIsForward, mefistoToDS);
+ isOk = true;
+ }
+ else
+ {
+ MESSAGE("Error in Triangulation");
+ isOk = false;
+ }
+ if (nudslf != NULL)
+ delete[]nudslf;
+ if (uvslf != NULL)
+ delete[]uvslf;
+ if (uvst != NULL)
+ delete[]uvst;
+ if (nust != NULL)
+ delete[]nust;
+ return isOk;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void StdMeshers_MEFISTO_2D::LoadPoints(SMESH_Mesh & aMesh,
+ const TopoDS_Face & FF,
+ const TopoDS_Wire & WW, R2 * uvslf, int &m,
+ map<int, const SMDS_MeshNode*>&mefistoToDS)
+{
+ MESSAGE("StdMeshers_MEFISTO_2D::LoadPoints");
+
+ SMDS_Mesh * meshDS = aMesh.GetMeshDS();
+
+ double scalex;
+ double scaley;
+ TopoDS_Face F = TopoDS::Face(FF.Oriented(TopAbs_FORWARD));
+ ComputeScaleOnFace(aMesh, F, scalex, scaley);
+
+ TopoDS_Wire W = TopoDS::Wire(WW.Oriented(TopAbs_FORWARD));
+ BRepTools_WireExplorer wexp(W, F);
+ for (wexp.Init(W, F); wexp.More(); wexp.Next())
+ {
+ const TopoDS_Edge & E = wexp.Current();
+
+ // --- IDNodes of first and last Vertex
+
+ TopoDS_Vertex VFirst, VLast;
+ TopExp::Vertices(E, VFirst, VLast); // corresponds to f and l
+
+ ASSERT(!VFirst.IsNull());
+ SMDS_NodeIteratorPtr lid=
+ aMesh.GetSubMesh(VFirst)->GetSubMeshDS()->GetNodes();
+ const SMDS_MeshNode* idFirst = lid->next();
+
+ ASSERT(!VLast.IsNull());
+ lid=aMesh.GetSubMesh(VLast)->GetSubMeshDS()->GetNodes();
+ const SMDS_MeshNode* idLast = lid->next();
+
+ // --- edge internal IDNodes (relies on good order storage, not checked)
+
+ int nbPoints = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
+ //SCRUTE(nbPoints);
+
+ double f, l;
+ Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
+
+ SMDS_NodeIteratorPtr ite= aMesh.GetSubMesh(E)->GetSubMeshDS()->GetNodes();
+
+ bool isForward = (E.Orientation() == TopAbs_FORWARD);
+ map<double, const SMDS_MeshNode*> params;
+
+ while(ite->more())
+ {
+ const SMDS_MeshNode * node = ite->next();
+ const SMDS_EdgePosition* epos =
+ static_cast<const SMDS_EdgePosition*>(node->GetPosition().get());
+ double param = epos->GetUParameter();
+ params[param] = node;
+ }
+ // --- load 2D values into MEFISTO structure,
+ // add IDNodes in mefistoToDS map
+
+ if (E.Orientation() == TopAbs_FORWARD)
+ {
+ gp_Pnt2d p = C2d->Value(f); // first point = Vertex Forward
+ uvslf[m].x = scalex * p.X();
+ uvslf[m].y = scaley * p.Y();
+ mefistoToDS[m + 1] = idFirst;
+ //MESSAGE(" "<<m<<" "<<mefistoToDS[m+1]);
+ //MESSAGE("__ f "<<f<<" "<<uvslf[m].x <<" "<<uvslf[m].y);
+ m++;
+ map<double, const SMDS_MeshNode*>::iterator itp = params.begin();
+ for (int i = 1; i <= nbPoints; i++) // nbPoints internal
+ {
+ double param = (*itp).first;
+ gp_Pnt2d p = C2d->Value(param);
+ uvslf[m].x = scalex * p.X();
+ uvslf[m].y = scaley * p.Y();
+ mefistoToDS[m + 1] = (*itp).second;
+// MESSAGE(" "<<m<<" "<<mefistoToDS[m+1]);
+// MESSAGE("__ "<<i<<" "<<param<<" "<<uvslf[m].x <<" "<<uvslf[m].y);
+ m++;
+ itp++;
+ }
+ }
+ else
+ {
+ gp_Pnt2d p = C2d->Value(l); // last point = Vertex Reversed
+ uvslf[m].x = scalex * p.X();
+ uvslf[m].y = scaley * p.Y();
+ mefistoToDS[m + 1] = idLast;
+// MESSAGE(" "<<m<<" "<<mefistoToDS[m+1]);
+// MESSAGE("__ l "<<l<<" "<<uvslf[m].x <<" "<<uvslf[m].y);
+ m++;
+ map<double, const SMDS_MeshNode*>::reverse_iterator itp = params.rbegin();
+ for (int i = nbPoints; i >= 1; i--)
+ {
+ double param = (*itp).first;
+ gp_Pnt2d p = C2d->Value(param);
+ uvslf[m].x = scalex * p.X();
+ uvslf[m].y = scaley * p.Y();
+ mefistoToDS[m + 1] = (*itp).second;
+// MESSAGE(" "<<m<<" "<<mefistoToDS[m+1]);
+// MESSAGE("__ "<<i<<" "<<param<<" "<<uvslf[m].x <<" "<<uvslf[m].y);
+ m++;
+ itp++;
+ }
+ }
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+// **** a mettre dans SMESH_Algo ou SMESH_2D_Algo
+
+void StdMeshers_MEFISTO_2D::ComputeScaleOnFace(SMESH_Mesh & aMesh,
+ const TopoDS_Face & aFace, double &scalex, double &scaley)
+{
+ //MESSAGE("StdMeshers_MEFISTO_2D::ComputeScaleOnFace");
+ TopoDS_Face F = TopoDS::Face(aFace.Oriented(TopAbs_FORWARD));
+ TopoDS_Wire W = BRepTools::OuterWire(F);
+
+ BRepTools_WireExplorer wexp(W, F);
+
+ double xmin = 1.e300; // min & max of face 2D parametric coord.
+ double xmax = -1.e300;
+ double ymin = 1.e300;
+ double ymax = -1.e300;
+ int nbp = 50;
+ scalex = 1;
+ scaley = 1;
+ for (wexp.Init(W, F); wexp.More(); wexp.Next())
+ {
+ const TopoDS_Edge & E = wexp.Current();
+ double f, l;
+ Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
+ for (int i = 0; i <= nbp; i++)
+ {
+ double param = f + (double (i) / double (nbp))*(l - f);
+ gp_Pnt2d p = C2d->Value(param);
+ if (p.X() < xmin)
+ xmin = p.X();
+ if (p.X() > xmax)
+ xmax = p.X();
+ if (p.Y() < ymin)
+ ymin = p.Y();
+ if (p.Y() > ymax)
+ ymax = p.Y();
+// MESSAGE(" "<< f<<" "<<l<<" "<<param<<" "<<xmin<<" "<<xmax<<" "<<ymin<<" "<<ymax);
+ }
+ }
+// SCRUTE(xmin);
+// SCRUTE(xmax);
+// SCRUTE(ymin);
+// SCRUTE(ymax);
+ double xmoy = (xmax + xmin) / 2.;
+ double ymoy = (ymax + ymin) / 2.;
+
+ Handle(Geom_Surface) S = BRep_Tool::Surface(F); // 3D surface
+
+ double length_x = 0;
+ double length_y = 0;
+ gp_Pnt PX0 = S->Value(xmin, ymoy);
+ gp_Pnt PY0 = S->Value(xmoy, ymin);
+ for (int i = 1; i <= nbp; i++)
+ {
+ double x = xmin + (double (i) / double (nbp))*(xmax - xmin);
+ gp_Pnt PX = S->Value(x, ymoy);
+ double y = ymin + (double (i) / double (nbp))*(ymax - ymin);
+ gp_Pnt PY = S->Value(xmoy, y);
+ length_x += PX.Distance(PX0);
+ length_y += PY.Distance(PY0);
+ PX0.SetCoord(PX.X(), PX.Y(), PX.Z());
+ PY0.SetCoord(PY.X(), PY.Y(), PY.Z());
+ }
+// SCRUTE(length_x);
+// SCRUTE(length_y);
+ scalex = length_x / (xmax - xmin);
+ scaley = length_y / (ymax - ymin);
+// SCRUTE(scalex);
+// SCRUTE(scaley);
+ ASSERT(scalex);
+ ASSERT(scaley);
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void StdMeshers_MEFISTO_2D::StoreResult(SMESH_Mesh & aMesh,
+ Z nbst, R2 * uvst, Z nbt, Z * nust,
+ const TopoDS_Face & F, bool faceIsForward,
+ map<int, const SMDS_MeshNode*>&mefistoToDS)
+{
+ double scalex;
+ double scaley;
+ ComputeScaleOnFace(aMesh, F, scalex, scaley);
+
+ SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
+
+ Z n, m;
+ Handle(Geom_Surface) S = BRep_Tool::Surface(F);
+
+ for (n = 0; n < nbst; n++)
+ {
+ double u = uvst[n][0] / scalex;
+ double v = uvst[n][1] / scaley;
+ gp_Pnt P = S->Value(u, v);
+
+ if (mefistoToDS.find(n + 1) == mefistoToDS.end())
+ {
+ SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnFace(node, F);
+
+ //MESSAGE(nodeId<<" "<<P.X()<<" "<<P.Y()<<" "<<P.Z());
+ mefistoToDS[n + 1] = node;
+ //MESSAGE(" "<<n<<" "<<mefistoToDS[n+1]);
+ SMDS_FacePosition* fpos =
+ static_cast<SMDS_FacePosition*>(node->GetPosition().get());
+ fpos->SetUParameter(u);
+ fpos->SetVParameter(v);
+ }
+ }
+
+ m = 0;
+ int mt = 0;
+
+ //SCRUTE(faceIsForward);
+ for (n = 1; n <= nbt; n++)
+ {
+ int inode1 = nust[m++];
+ int inode2 = nust[m++];
+ int inode3 = nust[m++];
+
+ const SMDS_MeshNode *n1, *n2, *n3;
+ n1 = mefistoToDS[inode1];
+ n2 = mefistoToDS[inode2];
+ n3 = mefistoToDS[inode3];
+ //MESSAGE("-- "<<inode1<<" "<<inode2<<" "<<inode3<<" ++ "<<nodeId1<<" "<<nodeId2<<" "<<nodeId3);
+
+ // triangle points must be in trigonometric order if face is Forward
+ // else they must be put clockwise
+
+ bool triangleIsWellOriented = faceIsForward;
+
+ SMDS_MeshElement * elt;
+ if (triangleIsWellOriented)
+ elt = meshDS->AddFace(n1, n2, n3);
+ else
+ elt = meshDS->AddFace(n1, n3, n2);
+
+ meshDS->SetMeshElementOnShape(elt, F);
+ m++;
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+double StdMeshers_MEFISTO_2D::ComputeEdgeElementLength(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape)
+{
+ MESSAGE("StdMeshers_MEFISTO_2D::ComputeEdgeElementLength");
+ // **** a mettre dans SMESH_2D_Algo ?
+
+ const TopoDS_Face & FF = TopoDS::Face(aShape);
+ bool faceIsForward = (FF.Orientation() == TopAbs_FORWARD);
+ TopoDS_Face F = TopoDS::Face(FF.Oriented(TopAbs_FORWARD));
+
+ double meanElementLength = 100;
+ double wireLength = 0;
+ int wireElementsNumber = 0;
+ for (TopExp_Explorer exp(F, TopAbs_WIRE); exp.More(); exp.Next())
+ {
+ const TopoDS_Wire & W = TopoDS::Wire(exp.Current());
+ for (TopExp_Explorer expe(W, TopAbs_EDGE); expe.More(); expe.Next())
+ {
+ const TopoDS_Edge & E = TopoDS::Edge(expe.Current());
+ int nb = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
+ double length = EdgeLength(E);
+ wireLength += length;
+ wireElementsNumber += nb;
+ }
+ }
+ if (wireElementsNumber)
+ meanElementLength = wireLength / wireElementsNumber;
+ //SCRUTE(meanElementLength);
+ return meanElementLength;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & StdMeshers_MEFISTO_2D::SaveTo(ostream & save)
+{
+ return save;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & StdMeshers_MEFISTO_2D::LoadFrom(istream & load)
+{
+ return load;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & operator <<(ostream & save, StdMeshers_MEFISTO_2D & hyp)
+{
+ return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & operator >>(istream & load, StdMeshers_MEFISTO_2D & hyp)
+{
+ return hyp.LoadFrom( load );
+}
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_MEFISTO_2D.hxx
+// Moved here from SMESH_MEFISTO_2D.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _StdMeshers_MEFISTO_2D_HXX_
+#define _StdMeshers_MEFISTO_2D_HXX_
+
+#include "SMESH_2D_Algo.hxx"
+#include "StdMeshers_MaxElementArea.hxx"
+#include "StdMeshers_LengthFromEdges.hxx"
+#include "Rn.h"
+
+class SMDS_MeshNode;
+#include <TopoDS_Face.hxx>
+#include <map>
+
+class StdMeshers_MEFISTO_2D:
+ public SMESH_2D_Algo
+{
+public:
+ StdMeshers_MEFISTO_2D(int hypId, int studyId, SMESH_Gen* gen);
+ virtual ~StdMeshers_MEFISTO_2D();
+
+ virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ SMESH_Hypothesis::Hypothesis_Status& aStatus);
+
+ virtual bool Compute(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape);
+
+ double ComputeEdgeElementLength(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape);
+
+ void LoadPoints(SMESH_Mesh& aMesh,
+ const TopoDS_Face& F,
+ const TopoDS_Wire& W,
+ R2* uvslf,
+ int& m,
+ map<int,const SMDS_MeshNode*>& mefistoToDS);
+
+ void ComputeScaleOnFace(SMESH_Mesh& aMesh,
+ const TopoDS_Face& aFace,
+ double& scalex,
+ double& scaley);
+
+ void StoreResult (SMESH_Mesh& aMesh,
+ Z nbst, R2* uvst, Z nbt, Z* nust,
+ const TopoDS_Face& F, bool faceIsForward,
+ map<int,const SMDS_MeshNode*>& mefistoToDS);
+
+ ostream & SaveTo(ostream & save);
+ istream & LoadFrom(istream & load);
+ friend ostream & operator << (ostream & save, StdMeshers_MEFISTO_2D & hyp);
+ friend istream & operator >> (istream & load, StdMeshers_MEFISTO_2D & hyp);
+
+protected:
+ double _edgeLength;
+ double _maxElementArea;
+ const StdMeshers_MaxElementArea* _hypMaxElementArea;
+ const StdMeshers_LengthFromEdges* _hypLengthFromEdges;
+};
+
+#endif
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_MaxElementArea.cxx
+// Moved here from SMESH_MaxElementArea.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_MaxElementArea.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_MaxElementArea::StdMeshers_MaxElementArea(int hypId, int studyId, SMESH_Gen* gen)
+ : SMESH_Hypothesis(hypId, studyId, gen)
+{
+ _maxArea =1.;
+ _name = "MaxElementArea";
+// SCRUTE(_name);
+// SCRUTE(&_name);
+ _param_algo_dim = 2;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_MaxElementArea::~StdMeshers_MaxElementArea()
+{
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void StdMeshers_MaxElementArea::SetMaxArea(double maxArea)
+ throw (SALOME_Exception)
+{
+ double oldArea = _maxArea;
+ if (maxArea <= 0)
+ throw SALOME_Exception(LOCALIZED("maxArea must be positive"));
+ _maxArea = maxArea;
+ if (_maxArea != oldArea)
+ NotifySubMeshesHypothesisModification();
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+double StdMeshers_MaxElementArea::GetMaxArea() const
+{
+ return _maxArea;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & StdMeshers_MaxElementArea::SaveTo(ostream & save)
+{
+ save << this->_maxArea;
+ return save;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & StdMeshers_MaxElementArea::LoadFrom(istream & load)
+{
+ bool isOK = true;
+ double a;
+ isOK = (load >> a);
+ if (isOK)
+ this->_maxArea = a;
+ else
+ load.clear(ios::badbit | load.rdstate());
+ return load;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & operator << (ostream & save, StdMeshers_MaxElementArea & hyp)
+{
+ return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & operator >> (istream & load, StdMeshers_MaxElementArea & hyp)
+{
+ return hyp.LoadFrom( load );
+}
+
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_MaxElementArea.hxx
+// Moved here from SMESH_MaxElementArea.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_MAXELEMENTAREA_HXX_
+#define _SMESH_MAXELEMENTAREA_HXX_
+
+#include "SMESH_Hypothesis.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+class StdMeshers_MaxElementArea:public SMESH_Hypothesis
+{
+ public:
+ StdMeshers_MaxElementArea(int hypId, int studyId, SMESH_Gen * gen);
+ virtual ~ StdMeshers_MaxElementArea();
+
+ void SetMaxArea(double maxArea) throw(SALOME_Exception);
+
+ double GetMaxArea() const;
+
+ virtual ostream & SaveTo(ostream & save);
+ virtual istream & LoadFrom(istream & load);
+ friend ostream & operator <<(ostream & save, StdMeshers_MaxElementArea & hyp);
+ friend istream & operator >>(istream & load, StdMeshers_MaxElementArea & hyp);
+
+ protected:
+ double _maxArea;
+};
+
+#endif
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_MaxElementVolume.cxx
+// Moved here from SMESH_MaxElementVolume.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+
+#include "StdMeshers_MaxElementVolume.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_MaxElementVolume::StdMeshers_MaxElementVolume(int hypId, int studyId, SMESH_Gen* gen)
+ : SMESH_Hypothesis(hypId, studyId, gen)
+{
+ _maxVolume =1.;
+ _name = "MaxElementVolume";
+// SCRUTE(_name);
+ SCRUTE(&_name);
+ _param_algo_dim = 3;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_MaxElementVolume::~StdMeshers_MaxElementVolume()
+{
+ MESSAGE("StdMeshers_MaxElementVolume::~StdMeshers_MaxElementVolume");
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void StdMeshers_MaxElementVolume::SetMaxVolume(double maxVolume)
+ throw (SALOME_Exception)
+{
+ double oldVolume = _maxVolume;
+ if (maxVolume <= 0)
+ throw SALOME_Exception(LOCALIZED("maxVolume must be positive"));
+ _maxVolume = maxVolume;
+ if (_maxVolume != oldVolume)
+ NotifySubMeshesHypothesisModification();
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+double StdMeshers_MaxElementVolume::GetMaxVolume() const
+{
+ return _maxVolume;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & StdMeshers_MaxElementVolume::SaveTo(ostream & save)
+{
+ save << this->_maxVolume;
+ return save;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & StdMeshers_MaxElementVolume::LoadFrom(istream & load)
+{
+ bool isOK = true;
+ double a;
+ isOK = (load >> a);
+ if (isOK)
+ this->_maxVolume = a;
+ else
+ load.clear(ios::badbit | load.rdstate());
+ return load;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & operator << (ostream & save, StdMeshers_MaxElementVolume & hyp)
+{
+ return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & operator >> (istream & load, StdMeshers_MaxElementVolume & hyp)
+{
+ return hyp.LoadFrom( load );
+}
+
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_MaxElementVolume.hxx
+// Moved here from SMESH_MaxElementVolume.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_MAXELEMENTVOLUME_HXX_
+#define _SMESH_MAXELEMENTVOLUME_HXX_
+
+#include "SMESH_Hypothesis.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+class StdMeshers_MaxElementVolume:
+ public SMESH_Hypothesis
+{
+public:
+ StdMeshers_MaxElementVolume(int hypId, int studyId, SMESH_Gen* gen);
+ virtual ~StdMeshers_MaxElementVolume();
+
+ void SetMaxVolume(double maxVolume)
+ throw (SALOME_Exception);
+
+ double GetMaxVolume() const;
+
+ virtual ostream & SaveTo(ostream & save);
+ virtual istream & LoadFrom(istream & load);
+ friend ostream & operator << (ostream & save, StdMeshers_MaxElementVolume & hyp);
+ friend istream & operator >> (istream & load, StdMeshers_MaxElementVolume & hyp);
+
+protected:
+ double _maxVolume;
+};
+
+#endif
--- /dev/null
+// SMESH StdMeshers : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_NotConformAllowed.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_NotConformAllowed.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_NotConformAllowed::StdMeshers_NotConformAllowed(int hypId, int studyId, SMESH_Gen* gen)
+ : SMESH_Hypothesis(hypId, studyId, gen)
+{
+ _name = "NotConformAllowed";
+ _param_algo_dim = -1;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_NotConformAllowed::~StdMeshers_NotConformAllowed()
+{
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & StdMeshers_NotConformAllowed::SaveTo(ostream & save)
+{
+ return save << this;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & StdMeshers_NotConformAllowed::LoadFrom(istream & load)
+{
+ return load >> (*this);
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & operator << (ostream & save, StdMeshers_NotConformAllowed & hyp)
+{
+ return save;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & operator >> (istream & load, StdMeshers_NotConformAllowed & hyp)
+{
+ return load;
+}
--- /dev/null
+// SMESH StdMeshers : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_NotConformAllowed.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _StdMeshers_NotConformAllowed_HXX_
+#define _StdMeshers_NotConformAllowed_HXX_
+
+#include "SMESH_Hypothesis.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+class StdMeshers_NotConformAllowed:
+ public SMESH_Hypothesis
+{
+public:
+ StdMeshers_NotConformAllowed(int hypId, int studyId, SMESH_Gen* gen);
+ virtual ~StdMeshers_NotConformAllowed();
+
+ virtual ostream & SaveTo(ostream & save);
+ virtual istream & LoadFrom(istream & load);
+ friend ostream & operator << (ostream & save, StdMeshers_NotConformAllowed & hyp);
+ friend istream & operator >> (istream & load, StdMeshers_NotConformAllowed & hyp);
+};
+
+#endif
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_NumberOfSegments.cxx
+// Moved here from SMESH_NumberOfSegments.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_NumberOfSegments.hxx"
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_NumberOfSegments::StdMeshers_NumberOfSegments(int hypId, int studyId,
+ SMESH_Gen * gen):SMESH_Hypothesis(hypId, studyId, gen)
+{
+ _numberOfSegments = 1;
+ _scaleFactor = 1.0;
+ _name = "NumberOfSegments";
+ _param_algo_dim = 1;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_NumberOfSegments::~StdMeshers_NumberOfSegments()
+{
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void StdMeshers_NumberOfSegments::SetNumberOfSegments(int segmentsNumber)
+throw(SALOME_Exception)
+{
+ int oldNumberOfSegments = _numberOfSegments;
+ if (segmentsNumber <= 0)
+ throw
+ SALOME_Exception(LOCALIZED("number of segments must be positive"));
+ _numberOfSegments = segmentsNumber;
+
+ if (oldNumberOfSegments != _numberOfSegments)
+ NotifySubMeshesHypothesisModification();
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+int StdMeshers_NumberOfSegments::GetNumberOfSegments() const
+{
+ return _numberOfSegments;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
+throw(SALOME_Exception)
+{
+ if (scaleFactor < 0)
+ throw SALOME_Exception(LOCALIZED("scale factor must be positive"));
+ _scaleFactor = scaleFactor;
+
+ NotifySubMeshesHypothesisModification();
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+double StdMeshers_NumberOfSegments::GetScaleFactor() const
+{
+ return _scaleFactor;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & StdMeshers_NumberOfSegments::SaveTo(ostream & save)
+{
+ save << this->_numberOfSegments << " " << this->_scaleFactor;
+ return save;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & StdMeshers_NumberOfSegments::LoadFrom(istream & load)
+{
+ bool isOK = true;
+ int a;
+ isOK = (load >> a);
+ if (isOK)
+ this->_numberOfSegments = a;
+ else
+ load.clear(ios::badbit | load.rdstate());
+ double b;
+ isOK = (load >> b);
+ if (isOK)
+ this->_scaleFactor = b;
+ else
+ load.clear(ios::badbit | load.rdstate());
+ return load;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & operator <<(ostream & save, StdMeshers_NumberOfSegments & hyp)
+{
+ return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & operator >>(istream & load, StdMeshers_NumberOfSegments & hyp)
+{
+ return hyp.LoadFrom( load );
+}
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_NumberOfSegments.hxx
+// Moved here from SMESH_NumberOfSegments.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_NUMBEROFSEGMENTS_HXX_
+#define _SMESH_NUMBEROFSEGMENTS_HXX_
+
+#include "SMESH_Hypothesis.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+class StdMeshers_NumberOfSegments:
+ public SMESH_Hypothesis
+{
+public:
+ StdMeshers_NumberOfSegments(int hypId, int studyId, SMESH_Gen* gen);
+ virtual ~StdMeshers_NumberOfSegments();
+
+ void SetNumberOfSegments(int segmentsNumber)
+ throw (SALOME_Exception);
+
+ int GetNumberOfSegments() const;
+
+ void SetScaleFactor(double scaleFactor)
+ throw (SALOME_Exception);
+
+ double GetScaleFactor() const;
+
+ virtual ostream & SaveTo(ostream & save);
+ virtual istream & LoadFrom(istream & load);
+ friend ostream& operator << (ostream & save, StdMeshers_NumberOfSegments & hyp);
+ friend istream& operator >> (istream & load, StdMeshers_NumberOfSegments & hyp);
+
+protected:
+ int _numberOfSegments;
+ double _scaleFactor;
+};
+
+#endif
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_Quadrangle_2D.cxx
+// Moved here from SMESH_Quadrangle_2D.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_Quadrangle_2D.hxx"
+#include "SMESH_Gen.hxx"
+#include "SMESH_Mesh.hxx"
+
+#include "SMDS_MeshElement.hxx"
+#include "SMDS_MeshNode.hxx"
+#include "SMDS_EdgePosition.hxx"
+#include "SMDS_FacePosition.hxx"
+
+#include <BRep_Tool.hxx>
+#include <BRepTools.hxx>
+#include <BRepTools_WireExplorer.hxx>
+#include <Geom_Surface.hxx>
+#include <Geom_Curve.hxx>
+#include <Geom2d_Curve.hxx>
+#include <Handle_Geom2d_Curve.hxx>
+#include <Handle_Geom_Curve.hxx>
+#include <gp_Pnt2d.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
+
+#include "utilities.h"
+#include "Utils_ExceptHandlers.hxx"
+
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_Quadrangle_2D::StdMeshers_Quadrangle_2D(int hypId,
+ int studyId, SMESH_Gen * gen):SMESH_2D_Algo(hypId, studyId, gen)
+{
+ MESSAGE("StdMeshers_Quadrangle_2D::StdMeshers_Quadrangle_2D");
+ _name = "Quadrangle_2D";
+ // _shapeType = TopAbs_FACE;
+ _shapeType = (1 << TopAbs_FACE);
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_Quadrangle_2D::~StdMeshers_Quadrangle_2D()
+{
+ MESSAGE("StdMeshers_Quadrangle_2D::~StdMeshers_Quadrangle_2D");
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+bool StdMeshers_Quadrangle_2D::CheckHypothesis
+ (SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ SMESH_Hypothesis::Hypothesis_Status& aStatus)
+{
+ //MESSAGE("StdMeshers_Quadrangle_2D::CheckHypothesis");
+
+ bool isOk = true;
+ aStatus = SMESH_Hypothesis::HYP_OK;
+
+ // nothing to check
+
+ return isOk;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+bool StdMeshers_Quadrangle_2D::Compute(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape)throw(SALOME_Exception)
+{
+ Unexpect aCatch(SalomeException);
+ //MESSAGE("StdMeshers_Quadrangle_2D::Compute");
+ SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
+ SMESH_subMesh *theSubMesh = aMesh.GetSubMesh(aShape);
+
+ FaceQuadStruct *quad = CheckAnd2Dcompute(aMesh, aShape);
+ if (!quad)
+ return false;
+
+ // --- compute 3D values on points, store points & quadrangles
+
+ int nbdown = quad->nbPts[0];
+ int nbright = quad->nbPts[1];
+ int nbVertices = nbdown * nbright;
+ int nbQuad = (nbdown - 1) * (nbright - 1);
+ //SCRUTE(nbVertices);
+ //SCRUTE(nbQuad);
+
+ // const TopoDS_Face& FF = TopoDS::Face(aShape);
+ // bool faceIsForward = (FF.Orientation() == TopAbs_FORWARD);
+ // TopoDS_Face F = TopoDS::Face(FF.Oriented(TopAbs_FORWARD));
+ const TopoDS_Face & F = TopoDS::Face(aShape);
+ bool faceIsForward = (F.Orientation() == TopAbs_FORWARD);
+ Handle(Geom_Surface) S = BRep_Tool::Surface(F);
+
+ for (int i = 1; i < nbdown - 1; i++)
+ for (int j = 1; j < nbright - 1; j++) // internal points
+ {
+ int ij = j * nbdown + i;
+ double u = quad->uv_grid[ij].u;
+ double v = quad->uv_grid[ij].v;
+ gp_Pnt P = S->Value(u, v);
+ SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnFace(node, F);
+ quad->uv_grid[ij].node = node;
+// Handle (SMDS_FacePosition) fpos
+// = new SMDS_FacePosition(theSubMesh->GetId(),i,j); // easier than u,v
+// node->SetPosition(fpos);
+ SMDS_FacePosition* fpos =
+ dynamic_cast<SMDS_FacePosition*>(node->GetPosition().get());
+ fpos->SetUParameter(i);
+ fpos->SetVParameter(j);
+ }
+
+ // bool isQuadForward = ( faceIsForward == quad->isEdgeForward[0]);
+ for (int i = 0; i < nbdown - 1; i++)
+ for (int j = 0; j < nbright - 1; j++) // faces
+ {
+ const SMDS_MeshNode *a, *b, *c, *d;
+ a = quad->uv_grid[j * nbdown + i].node;
+ b = quad->uv_grid[j * nbdown + i + 1].node;
+ c = quad->uv_grid[(j + 1) * nbdown + i + 1].node;
+ d = quad->uv_grid[(j + 1) * nbdown + i].node;
+ // if (isQuadForward) faceId = meshDS->AddFace(a,b,c,d);
+ // else faceId = meshDS->AddFace(a,d,c,b);
+ SMDS_MeshFace * face = meshDS->AddFace(a, b, c, d);
+ meshDS->SetMeshElementOnShape(face, F);
+ }
+
+ QuadDelete(quad);
+ bool isOk = true;
+ return isOk;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+FaceQuadStruct *StdMeshers_Quadrangle_2D::CheckAnd2Dcompute(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape)throw(SALOME_Exception)
+{
+ Unexpect aCatch(SalomeException);
+ //MESSAGE("StdMeshers_Quadrangle_2D::ComputeWithoutStore");
+
+ SMESH_subMesh *theSubMesh = aMesh.GetSubMesh(aShape);
+
+ // const TopoDS_Face& FF = TopoDS::Face(aShape);
+ // bool faceIsForward = (FF.Orientation() == TopAbs_FORWARD);
+ // TopoDS_Face F = TopoDS::Face(FF.Oriented(TopAbs_FORWARD));
+ const TopoDS_Face & F = TopoDS::Face(aShape);
+ bool faceIsForward = (F.Orientation() == TopAbs_FORWARD);
+
+ // verify 1 wire only, with 4 edges, same number of points on opposite edges
+
+ if (NumberOfWires(F) != 1)
+ {
+ MESSAGE("only 1 wire by face (quadrangles)");
+ return 0;
+ //throw SALOME_Exception(LOCALIZED("only 1 wire by face (quadrangles)"));
+ }
+ // const TopoDS_Wire WW = BRepTools::OuterWire(F);
+ // TopoDS_Wire W = TopoDS::Wire(WW.Oriented(TopAbs_FORWARD));
+ const TopoDS_Wire & W = BRepTools::OuterWire(F);
+ BRepTools_WireExplorer wexp(W, F);
+
+ FaceQuadStruct *quad = new FaceQuadStruct;
+ for (int i = 0; i < 4; i++)
+ quad->uv_edges[i] = 0;
+ quad->uv_grid = 0;
+
+ int nbEdges = 0;
+ for (wexp.Init(W, F); wexp.More(); wexp.Next())
+ {
+ // const TopoDS_Edge& EE = wexp.Current();
+ // TopoDS_Edge E = TopoDS::Edge(EE.Oriented(TopAbs_FORWARD));
+ const TopoDS_Edge & E = wexp.Current();
+ int nb = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
+ if (nbEdges < 4)
+ {
+ quad->edge[nbEdges] = E;
+ quad->nbPts[nbEdges] = nb + 2; // internal points + 2 extrema
+ }
+ nbEdges++;
+ }
+
+ if (nbEdges != 4)
+ {
+ MESSAGE("face must have 4 edges /quadrangles");
+ QuadDelete(quad);
+ return 0;
+ //throw SALOME_Exception(LOCALIZED("face must have 4 edges /quadrangles"));
+ }
+
+ if (quad->nbPts[0] != quad->nbPts[2])
+ {
+ MESSAGE("different point number-opposed edge");
+ QuadDelete(quad);
+ return 0;
+ //throw SALOME_Exception(LOCALIZED("different point number-opposed edge"));
+ }
+
+ if (quad->nbPts[1] != quad->nbPts[3])
+ {
+ MESSAGE("different point number-opposed edge");
+ QuadDelete(quad);
+ return 0;
+ //throw SALOME_Exception(LOCALIZED("different point number-opposed edge"));
+ }
+
+ // set normalized grid on unit square in parametric domain
+
+ SetNormalizedGrid(aMesh, F, quad);
+
+ return quad;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void StdMeshers_Quadrangle_2D::QuadDelete(FaceQuadStruct * quad)
+{
+ //MESSAGE("StdMeshers_Quadrangle_2D::QuadDelete");
+ if (quad)
+ {
+ for (int i = 0; i < 4; i++)
+ {
+ if (quad->uv_edges[i])
+ delete[]quad->uv_edges[i];
+ quad->edge[i].Nullify();
+ }
+ if (quad->uv_grid)
+ delete[]quad->uv_grid;
+ delete quad;
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void StdMeshers_Quadrangle_2D::SetNormalizedGrid(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape, FaceQuadStruct * quad) throw(SALOME_Exception)
+{
+ Unexpect aCatch(SalomeException);
+ // Algorithme décrit dans "Génération automatique de maillages"
+ // P.L. GEORGE, MASSON, § 6.4.1 p. 84-85
+ // traitement dans le domaine paramétrique 2d u,v
+ // transport - projection sur le carré unité
+
+ const TopoDS_Face & F = TopoDS::Face(aShape);
+
+ // 1 --- find orientation of the 4 edges, by test on extrema
+
+ // max min 0 x1 1
+ // |<----north-2-------^ a3 -------------> a2
+ // | | ^1 1^
+ // west-3 east-1 =right | |
+ // | | ==> | |
+ // y0 | | y1 | |
+ // | | |0 0|
+ // v----south-0--------> a0 -------------> a1
+ // min max 0 x0 1
+ // =down
+ //
+
+ Handle(Geom2d_Curve) c2d[4];
+ gp_Pnt2d pf[4];
+ gp_Pnt2d pl[4];
+ for (int i = 0; i < 4; i++)
+ {
+ c2d[i] = BRep_Tool::CurveOnSurface(quad->edge[i],
+ F, quad->first[i], quad->last[i]);
+ pf[i] = c2d[i]->Value(quad->first[i]);
+ pl[i] = c2d[i]->Value(quad->last[i]);
+ quad->isEdgeForward[i] = false;
+ }
+
+ double eps2d = 1.e-3; // *** utiliser plutot TopExp::CommonVertex, puis
+ // distances si piece fausse
+ int i = 0;
+ if ((pf[1].Distance(pl[0]) < eps2d) || (pl[1].Distance(pl[0]) < eps2d))
+ {
+ quad->isEdgeForward[0] = true;
+ }
+ else
+ {
+ double tmp = quad->first[0];
+ quad->first[0] = quad->last[0];
+ quad->last[0] = tmp;
+ pf[0] = c2d[0]->Value(quad->first[0]);
+ pl[0] = c2d[0]->Value(quad->last[0]);
+ }
+ for (int i = 1; i < 4; i++)
+ {
+ quad->isEdgeForward[i] = (pf[i].Distance(pl[i - 1]) < eps2d);
+ if (!quad->isEdgeForward[i])
+ {
+ double tmp = quad->first[i];
+ quad->first[i] = quad->last[i];
+ quad->last[i] = tmp;
+ pf[i] = c2d[i]->Value(quad->first[i]);
+ pl[i] = c2d[i]->Value(quad->last[i]);
+ //SCRUTE(pf[i].Distance(pl[i-1]));
+ ASSERT(pf[i].Distance(pl[i - 1]) < eps2d);
+ }
+ }
+ //SCRUTE(pf[0].Distance(pl[3]));
+ ASSERT(pf[0].Distance(pl[3]) < eps2d);
+
+// for (int i=0; i<4; i++)
+// {
+// SCRUTE(quad->isEdgeForward[i]);
+// MESSAGE(" -first "<<i<<" "<<pf[i].X()<<" "<<pf[i].Y());
+// MESSAGE(" -last "<<i<<" "<<pl[i].X()<<" "<<pl[i].Y());
+// }
+
+ // 2 --- load 2d edge points (u,v) with orientation and value on unit square
+
+ for (int i = 0; i < 2; i++)
+ {
+ quad->uv_edges[i] = LoadEdgePoints(aMesh, F,
+ quad->edge[i], quad->first[i], quad->last[i]);
+
+ // quad->isEdgeForward[i]);
+ }
+ for (int i = 2; i < 4; i++)
+ {
+ quad->uv_edges[i] = LoadEdgePoints(aMesh, F,
+ quad->edge[i], quad->last[i], quad->first[i]);
+
+ // !quad->isEdgeForward[i]);
+ }
+
+ // 3 --- 2D normalized values on unit square [0..1][0..1]
+
+ int nbdown = quad->nbPts[0];
+ int nbright = quad->nbPts[1];
+ quad->uv_grid = new UVPtStruct[nbright * nbdown];
+
+ UVPtStruct *uv_grid = quad->uv_grid;
+ UVPtStruct *uv_e0 = quad->uv_edges[0];
+ UVPtStruct *uv_e1 = quad->uv_edges[1];
+ UVPtStruct *uv_e2 = quad->uv_edges[2];
+ UVPtStruct *uv_e3 = quad->uv_edges[3];
+ gp_Pnt2d a0 = pf[0];
+ gp_Pnt2d a1 = pf[1];
+ gp_Pnt2d a2 = pf[2];
+ gp_Pnt2d a3 = pf[3];
+
+ // nodes Id on edges
+
+ int j = 0;
+ for (int i = 0; i < nbdown; i++)
+ {
+ int ij = j * nbdown + i;
+ uv_grid[ij].node = uv_e0[i].node;
+ }
+ i = nbdown - 1;
+ for (int j = 0; j < nbright; j++)
+ {
+ int ij = j * nbdown + i;
+ uv_grid[ij].node = uv_e1[j].node;
+ }
+ j = nbright - 1;
+ for (int i = 0; i < nbdown; i++)
+ {
+ int ij = j * nbdown + i;
+ uv_grid[ij].node = uv_e2[i].node;
+ }
+ i = 0;
+ for (int j = 0; j < nbright; j++)
+ {
+ int ij = j * nbdown + i;
+ uv_grid[ij].node = uv_e3[j].node;
+ }
+
+ // normalized 2d values on grid
+
+ for (int i = 0; i < nbdown; i++)
+ for (int j = 0; j < nbright; j++)
+ {
+ int ij = j * nbdown + i;
+ // --- droite i cste : x = x0 + y(x1-x0)
+ double x0 = uv_e0[i].normParam; // bas - sud
+ double x1 = uv_e2[i].normParam; // haut - nord
+ // --- droite j cste : y = y0 + x(y1-y0)
+ double y0 = uv_e3[j].normParam; // gauche-ouest
+ double y1 = uv_e1[j].normParam; // droite - est
+ // --- intersection : x=x0+(y0+x(y1-y0))(x1-x0)
+ double x = (x0 + y0 * (x1 - x0)) / (1 - (y1 - y0) * (x1 - x0));
+ double y = y0 + x * (y1 - y0);
+ uv_grid[ij].x = x;
+ uv_grid[ij].y = y;
+ //MESSAGE("-xy-01 "<<x0<<" "<<x1<<" "<<y0<<" "<<y1);
+ //MESSAGE("-xy-norm "<<i<<" "<<j<<" "<<x<<" "<<y);
+ }
+
+ // 4 --- projection on 2d domain (u,v)
+
+ for (int i = 0; i < nbdown; i++)
+ for (int j = 0; j < nbright; j++)
+ {
+ int ij = j * nbdown + i;
+ double x = uv_grid[ij].x;
+ double y = uv_grid[ij].y;
+ double param_0 = uv_e0[0].param + x * (uv_e0[nbdown - 1].param - uv_e0[0].param); // sud
+ double param_2 = uv_e2[0].param + x * (uv_e2[nbdown - 1].param - uv_e2[0].param); // nord
+ double param_1 = uv_e1[0].param + y * (uv_e1[nbright - 1].param - uv_e1[0].param); // est
+ double param_3 = uv_e3[0].param + y * (uv_e3[nbright - 1].param - uv_e3[0].param); // ouest
+
+ //MESSAGE("params "<<param_0<<" "<<param_1<<" "<<param_2<<" "<<param_3);
+ gp_Pnt2d p0 = c2d[0]->Value(param_0);
+ gp_Pnt2d p1 = c2d[1]->Value(param_1);
+ gp_Pnt2d p2 = c2d[2]->Value(param_2);
+ gp_Pnt2d p3 = c2d[3]->Value(param_3);
+
+ double u =
+ (1 - y) * p0.X() + x * p1.X() + y * p2.X() + (1 - x) * p3.X();
+ double v =
+ (1 - y) * p0.Y() + x * p1.Y() + y * p2.Y() + (1 - x) * p3.Y();
+
+ u -= (1 - x) * (1 - y) * a0.X() + x * (1 - y) * a1.X() +
+ x * y * a2.X() + (1 - x) * y * a3.X();
+ v -= (1 - x) * (1 - y) * a0.Y() + x * (1 - y) * a1.Y() +
+ x * y * a2.Y() + (1 - x) * y * a3.Y();
+
+ uv_grid[ij].u = u;
+ uv_grid[ij].v = v;
+
+ //MESSAGE("-uv- "<<i<<" "<<j<<" "<<uv_grid[ij].u<<" "<<uv_grid[ij].v);
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+UVPtStruct *StdMeshers_Quadrangle_2D::LoadEdgePoints(SMESH_Mesh & aMesh,
+ const TopoDS_Face & F, const TopoDS_Edge & E, double first, double last)
+ // bool isForward)
+{
+ //MESSAGE("StdMeshers_Quadrangle_2D::LoadEdgePoints");
+
+ SMDS_Mesh * meshDS = aMesh.GetMeshDS();
+
+ // --- IDNodes of first and last Vertex
+
+ TopoDS_Vertex VFirst, VLast;
+ TopExp::Vertices(E, VFirst, VLast); // corresponds to f and l
+
+ ASSERT(!VFirst.IsNull());
+ SMDS_NodeIteratorPtr lid= aMesh.GetSubMesh(VFirst)->GetSubMeshDS()->GetNodes();
+ const SMDS_MeshNode * idFirst = lid->next();
+
+ ASSERT(!VLast.IsNull());
+ lid=aMesh.GetSubMesh(VLast)->GetSubMeshDS()->GetNodes();
+ const SMDS_MeshNode * idLast = lid->next();
+
+ // --- edge internal IDNodes (relies on good order storage, not checked)
+
+ int nbPoints = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
+ //SCRUTE(nbPoints);
+ UVPtStruct *uvslf = new UVPtStruct[nbPoints + 2];
+
+ double f, l;
+ Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
+
+ map<double, const SMDS_MeshNode *> params;
+ SMDS_NodeIteratorPtr ite= aMesh.GetSubMesh(E)->GetSubMeshDS()->GetNodes();
+
+ while(ite->more())
+ {
+ const SMDS_MeshNode * node = ite->next();
+ const SMDS_EdgePosition* epos =
+ static_cast<const SMDS_EdgePosition*>(node->GetPosition().get());
+ double param = epos->GetUParameter();
+ params[param] = node;
+ }
+
+ bool isForward = (((l - f) * (last - first)) > 0);
+ double paramin = 0;
+ double paramax = 0;
+ if (isForward)
+ {
+ paramin = f;
+ paramax = l;
+ gp_Pnt2d p = C2d->Value(f); // first point = Vertex Forward
+ uvslf[0].x = p.X();
+ uvslf[0].y = p.Y();
+ uvslf[0].param = f;
+ uvslf[0].node = idFirst;
+ //MESSAGE("__ f "<<f<<" "<<uvslf[0].x <<" "<<uvslf[0].y);
+ map < double, const SMDS_MeshNode* >::iterator itp = params.begin();
+ for (int i = 1; i <= nbPoints; i++) // nbPoints internal
+ {
+ double param = (*itp).first;
+ gp_Pnt2d p = C2d->Value(param);
+ uvslf[i].x = p.X();
+ uvslf[i].y = p.Y();
+ uvslf[i].param = param;
+ uvslf[i].node = (*itp).second;
+ //MESSAGE("__ "<<i<<" "<<param<<" "<<uvslf[i].x <<" "<<uvslf[i].y);
+ itp++;
+ }
+ p = C2d->Value(l); // last point = Vertex Reversed
+ uvslf[nbPoints + 1].x = p.X();
+ uvslf[nbPoints + 1].y = p.Y();
+ uvslf[nbPoints + 1].param = l;
+ uvslf[nbPoints + 1].node = idLast;
+ //MESSAGE("__ l "<<l<<" "<<uvslf[nbPoints+1].x <<" "<<uvslf[nbPoints+1].y);
+ }
+ else
+ {
+ paramin = l;
+ paramax = f;
+ gp_Pnt2d p = C2d->Value(l); // first point = Vertex Reversed
+ uvslf[0].x = p.X();
+ uvslf[0].y = p.Y();
+ uvslf[0].param = l;
+ uvslf[0].node = idLast;
+ //MESSAGE("__ l "<<l<<" "<<uvslf[0].x <<" "<<uvslf[0].y);
+ map < double, const SMDS_MeshNode* >::reverse_iterator itp = params.rbegin();
+ for (int j = nbPoints; j >= 1; j--) // nbPoints internal
+ {
+ double param = (*itp).first;
+ int i = nbPoints + 1 - j;
+ gp_Pnt2d p = C2d->Value(param);
+ uvslf[i].x = p.X();
+ uvslf[i].y = p.Y();
+ uvslf[i].param = param;
+ uvslf[i].node = (*itp).second;
+ //MESSAGE("__ "<<i<<" "<<param<<" "<<uvslf[i].x <<" "<<uvslf[i].y);
+ itp++;
+ }
+ p = C2d->Value(f); // last point = Vertex Forward
+ uvslf[nbPoints + 1].x = p.X();
+ uvslf[nbPoints + 1].y = p.Y();
+ uvslf[nbPoints + 1].param = f;
+ uvslf[nbPoints + 1].node = idFirst;
+ //MESSAGE("__ f "<<f<<" "<<uvslf[nbPoints+1].x <<" "<<uvslf[nbPoints+1].y);
+ }
+
+ ASSERT(paramin != paramax);
+ for (int i = 0; i < nbPoints + 2; i++)
+ {
+ uvslf[i].normParam = (uvslf[i].param - paramin) / (paramax - paramin);
+ //SCRUTE(uvslf[i].normParam);
+ }
+
+ return uvslf;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & StdMeshers_Quadrangle_2D::SaveTo(ostream & save)
+{
+ return save;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & StdMeshers_Quadrangle_2D::LoadFrom(istream & load)
+{
+ return load;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & operator <<(ostream & save, StdMeshers_Quadrangle_2D & hyp)
+{
+ return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & operator >>(istream & load, StdMeshers_Quadrangle_2D & hyp)
+{
+ return hyp.LoadFrom( load );
+}
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_Quadrangle_2D.hxx
+// Moved here from SMESH_Quadrangle_2D.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_QUADRANGLE_2D_HXX_
+#define _SMESH_QUADRANGLE_2D_HXX_
+
+#include "SMESH_2D_Algo.hxx"
+#include "SMESH_Mesh.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+typedef struct uvPtStruct
+{
+ double param;
+ double normParam;
+ double u; // original 2d parameter
+ double v;
+ double x; // 2d parameter, normalized [0,1]
+ double y;
+ const SMDS_MeshNode * node;
+} UVPtStruct;
+
+typedef struct faceQuadStruct
+{
+ int nbPts[4];
+ TopoDS_Edge edge[4];
+ double first[4];
+ double last[4];
+ bool isEdgeForward[4];
+ UVPtStruct* uv_edges[4];
+ UVPtStruct* uv_grid;
+} FaceQuadStruct;
+
+class StdMeshers_Quadrangle_2D:
+ public SMESH_2D_Algo
+{
+public:
+ StdMeshers_Quadrangle_2D(int hypId, int studyId, SMESH_Gen* gen);
+ virtual ~StdMeshers_Quadrangle_2D();
+
+ virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ SMESH_Hypothesis::Hypothesis_Status& aStatus);
+
+ virtual bool Compute(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape)
+ throw (SALOME_Exception);
+
+ FaceQuadStruct* CheckAnd2Dcompute(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape)
+ throw (SALOME_Exception);
+
+ void QuadDelete(FaceQuadStruct* quad);
+
+ ostream & SaveTo(ostream & save);
+ istream & LoadFrom(istream & load);
+ friend ostream & operator << (ostream & save, StdMeshers_Quadrangle_2D & hyp);
+ friend istream & operator >> (istream & load, StdMeshers_Quadrangle_2D & hyp);
+
+protected:
+
+ void SetNormalizedGrid(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ FaceQuadStruct* quad)
+ throw (SALOME_Exception);
+
+ UVPtStruct* LoadEdgePoints(SMESH_Mesh& aMesh,
+ const TopoDS_Face& F,
+ const TopoDS_Edge& E,
+ double first,
+ double last);
+// bool isForward);
+
+// FaceQuadStruct _quadDesc;
+};
+
+#endif
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_Regular_1D.cxx
+// Moved here from SMESH_Regular_1D.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+
+#include "StdMeshers_Regular_1D.hxx"
+#include "SMESH_Gen.hxx"
+#include "SMESH_Mesh.hxx"
+
+#include "StdMeshers_LocalLength.hxx"
+#include "StdMeshers_NumberOfSegments.hxx"
+
+#include "SMDS_MeshElement.hxx"
+#include "SMDS_MeshNode.hxx"
+#include "SMDS_EdgePosition.hxx"
+
+#include "utilities.h"
+
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Shape.hxx>
+#include <GeomAdaptor_Curve.hxx>
+#include <BRep_Tool.hxx>
+#include <GCPnts_AbscissaPoint.hxx>
+#include <GCPnts_UniformAbscissa.hxx>
+
+#include <string>
+#include <algorithm>
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_Regular_1D::StdMeshers_Regular_1D(int hypId, int studyId,
+ SMESH_Gen * gen):SMESH_1D_Algo(hypId, studyId, gen)
+{
+ MESSAGE("StdMeshers_Regular_1D::StdMeshers_Regular_1D");
+ _name = "Regular_1D";
+ // _shapeType = TopAbs_EDGE;
+ _shapeType = (1 << TopAbs_EDGE);
+ _compatibleHypothesis.push_back("LocalLength");
+ _compatibleHypothesis.push_back("NumberOfSegments");
+
+ _localLength = 0;
+ _numberOfSegments = 0;
+ _hypLocalLength = NULL;
+ _hypNumberOfSegments = NULL;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_Regular_1D::~StdMeshers_Regular_1D()
+{
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+bool StdMeshers_Regular_1D::CheckHypothesis
+ (SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ SMESH_Hypothesis::Hypothesis_Status& aStatus)
+{
+ //MESSAGE("StdMeshers_Regular_1D::CheckHypothesis");
+
+ list <const SMESHDS_Hypothesis * >::const_iterator itl;
+ const SMESHDS_Hypothesis *theHyp;
+
+ const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
+ int nbHyp = hyps.size();
+ if (!nbHyp)
+ {
+ aStatus = SMESH_Hypothesis::HYP_MISSING;
+ return false; // can't work with no hypothesis
+ }
+
+ itl = hyps.begin();
+ theHyp = (*itl); // use only the first hypothesis
+
+ string hypName = theHyp->GetName();
+ int hypId = theHyp->GetID();
+ //SCRUTE(hypName);
+
+ bool isOk = false;
+
+ if (hypName == "LocalLength")
+ {
+ _hypLocalLength = dynamic_cast <const StdMeshers_LocalLength * >(theHyp);
+ ASSERT(_hypLocalLength);
+ _localLength = _hypLocalLength->GetLength();
+ _numberOfSegments = 0;
+ isOk = true;
+ aStatus = SMESH_Hypothesis::HYP_OK;
+ }
+
+ else if (hypName == "NumberOfSegments")
+ {
+ _hypNumberOfSegments =
+ dynamic_cast <const StdMeshers_NumberOfSegments * >(theHyp);
+ ASSERT(_hypNumberOfSegments);
+ _numberOfSegments = _hypNumberOfSegments->GetNumberOfSegments();
+ _scaleFactor = _hypNumberOfSegments->GetScaleFactor();
+ _localLength = 0;
+ isOk = true;
+ aStatus = SMESH_Hypothesis::HYP_OK;
+ }
+ else
+ aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
+
+ //SCRUTE(_localLength);
+ //SCRUTE(_numberOfSegments);
+
+ return isOk;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)
+{
+ MESSAGE("StdMeshers_Regular_1D::Compute");
+
+ SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
+ SMESH_subMesh *theSubMesh = aMesh.GetSubMesh(aShape);
+
+ const TopoDS_Edge & EE = TopoDS::Edge(aShape);
+ TopoDS_Edge E = TopoDS::Edge(EE.Oriented(TopAbs_FORWARD));
+
+ double f, l;
+ Handle(Geom_Curve) Curve = BRep_Tool::Curve(E, f, l);
+
+ TopoDS_Vertex VFirst, VLast;
+ TopExp::Vertices(E, VFirst, VLast); // Vfirst corresponds to f and Vlast to l
+
+ double length = EdgeLength(E);
+ //SCRUTE(length);
+
+ double eltSize = 1;
+// if (_localLength > 0) eltSize = _localLength;
+ if (_localLength > 0)
+ {
+ double nbseg = ceil(length / _localLength); // integer sup
+ if (nbseg <= 0)
+ nbseg = 1; // degenerated edge
+ eltSize = length / nbseg;
+ }
+ else
+ {
+ ASSERT(_numberOfSegments > 0);
+ eltSize = length / _numberOfSegments;
+ }
+
+ ASSERT(!VFirst.IsNull());
+ SMDS_NodeIteratorPtr lid= aMesh.GetSubMesh(VFirst)->GetSubMeshDS()->GetNodes();
+ const SMDS_MeshNode * idFirst = lid->next();
+
+ ASSERT(!VLast.IsNull());
+ lid=aMesh.GetSubMesh(VLast)->GetSubMeshDS()->GetNodes();
+ const SMDS_MeshNode * idLast = lid->next();
+
+ if (!Curve.IsNull())
+ {
+ GeomAdaptor_Curve C3d(Curve);
+ GCPnts_UniformAbscissa Discret(C3d, eltSize, f, l);
+ int NbPoints = Discret.NbPoints();
+ //MESSAGE("nb points on edge : "<<NbPoints);
+
+ // edge extrema (indexes : 1 & NbPoints) already in SMDS (TopoDS_Vertex)
+ // only internal nodes receive an edge position with param on curve
+
+ const SMDS_MeshNode * idPrev = idFirst;
+ for (int i = 2; i < NbPoints; i++)
+ {
+ double param = Discret.Parameter(i);
+
+ if (_numberOfSegments > 1)
+ {
+ double epsilon = 0.001;
+ if (fabs(_scaleFactor - 1.0) > epsilon)
+ {
+ double alpha =
+ pow(_scaleFactor, 1.0 / (_numberOfSegments - 1));
+ double d =
+ length * (1 - pow(alpha, i - 1)) / (1 - pow(alpha,
+ _numberOfSegments));
+ param = d;
+ }
+ }
+
+ gp_Pnt P = Curve->Value(param);
+
+ //Add the Node in the DataStructure
+ //MESSAGE("point "<<nodeId<<" "<<P.X()<<" "<<P.Y()<<" "<<P.Z()<<" - "<<i<<" "<<param);
+ SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnEdge(node, E);
+
+ // **** edgePosition associe au point = param.
+ SMDS_EdgePosition* epos =
+ dynamic_cast<SMDS_EdgePosition *>(node->GetPosition().get());
+ epos->SetUParameter(param);
+
+ SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node);
+ meshDS->SetMeshElementOnShape(edge, E);
+ idPrev = node;
+ }
+ SMDS_MeshEdge* edge = meshDS->AddEdge(idPrev, idLast);
+ meshDS->SetMeshElementOnShape(edge, E);
+ }
+ else
+ {
+// MESSAGE ("Edge Degeneree non traitee --- arret");
+// ASSERT(0);
+ if (BRep_Tool::Degenerated(E))
+ {
+ // Edge is a degenerated Edge : We put n = 5 points on the edge.
+ int NbPoints = 5;
+ BRep_Tool::Range(E, f, l);
+ double du = (l - f) / (NbPoints - 1);
+ MESSAGE("************* Degenerated edge! *****************");
+
+ TopoDS_Vertex V1, V2;
+ TopExp::Vertices(E, V1, V2);
+ gp_Pnt P = BRep_Tool::Pnt(V1);
+
+ const SMDS_MeshNode * idPrev = idFirst;
+ for (int i = 2; i < NbPoints; i++)
+ {
+ double param = f + (i - 1) * du;
+ SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ meshDS->SetNodeOnEdge(node, E);
+
+// Handle (SMDS_EdgePosition) epos
+// = new SMDS_EdgePosition(theSubMesh->GetId(),param);
+// node->SetPosition(epos);
+ SMDS_EdgePosition* epos =
+ dynamic_cast<SMDS_EdgePosition*>(node->GetPosition().get());
+ epos->SetUParameter(param);
+
+ SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node);
+ meshDS->SetMeshElementOnShape(edge, E);
+ idPrev = node;
+ }
+ SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, idLast);
+ meshDS->SetMeshElementOnShape(edge, E);
+ }
+ else
+ ASSERT(0);
+ }
+ return true;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & StdMeshers_Regular_1D::SaveTo(ostream & save)
+{
+ return save;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & StdMeshers_Regular_1D::LoadFrom(istream & load)
+{
+ return load;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+ostream & operator <<(ostream & save, StdMeshers_Regular_1D & hyp)
+{
+ return hyp.SaveTo( save );
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+istream & operator >>(istream & load, StdMeshers_Regular_1D & hyp)
+{
+ return hyp.LoadFrom( load );
+}
--- /dev/null
+// SMESH SMESH : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_Regular_1D.hxx
+// Moved here from SMESH_Regular_1D.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_REGULAR_1D_HXX_
+#define _SMESH_REGULAR_1D_HXX_
+
+#include "SMESH_1D_Algo.hxx"
+
+class StdMeshers_LocalLength;
+class StdMeshers_NumberOfSegments;
+
+class StdMeshers_Regular_1D:
+ public SMESH_1D_Algo
+{
+public:
+ StdMeshers_Regular_1D(int hypId, int studyId, SMESH_Gen* gen);
+ virtual ~StdMeshers_Regular_1D();
+
+ virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ SMESH_Hypothesis::Hypothesis_Status& aStatus);
+
+ virtual bool Compute(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape);
+
+ ostream & SaveTo(ostream & save);
+ istream & LoadFrom(istream & load);
+ friend ostream & operator << (ostream & save, StdMeshers_Regular_1D & hyp);
+ friend istream & operator >> (istream & load, StdMeshers_Regular_1D & hyp);
+
+protected:
+ double _localLength;
+ int _numberOfSegments;
+ double _scaleFactor;
+ const StdMeshers_LocalLength* _hypLocalLength;
+ const StdMeshers_NumberOfSegments* _hypNumberOfSegments;
+};
+
+#endif
--- /dev/null
+# SMESH StdMeshersGUI : GUI for StdMeshers plugin
+#
+# Copyright (C) 2003 CEA
+#
+# 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.org
+#
+#
+#
+# File : Makefile.in
+# Author : Julia DOROVSKIKH
+# Module : SMESH
+# $Header$
+
+top_srcdir=@top_srcdir@
+top_builddir=../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl:$(top_builddir)/idl:${KERNEL_ROOT_DIR}/idl/salome:${MED_ROOT_DIR}/idl/salome
+
+
+@COMMENCE@
+
+# .po files to transform in .qm
+ PO_FILES = \
+ StdMeshers_icons.po \
+ StdMeshers_msg_en.po
+
+# Libraries targets
+LIB = libStdMeshersGUI.la
+LIB_SRC = \
+ StdMeshersGUI.cxx \
+ StdMeshersGUI_LocalLengthDlg.cxx \
+ StdMeshersGUI_NbSegmentsDlg.cxx \
+ StdMeshersGUI_MaxElementAreaDlg.cxx \
+ StdMeshersGUI_MaxElementVolumeDlg.cxx
+
+LIB_MOC = \
+ StdMeshersGUI_LocalLengthDlg.h \
+ StdMeshersGUI_NbSegmentsDlg.h \
+ StdMeshersGUI_MaxElementAreaDlg.h \
+ StdMeshersGUI_MaxElementVolumeDlg.h
+
+LIB_CLIENT_IDL = \
+ SALOME_Exception.idl \
+ SMESH_Gen.idl \
+ SMESH_Mesh.idl \
+ SMESH_Group.idl \
+ SMESH_Filter.idl \
+ SMESH_Hypothesis.idl \
+ SMESH_BasicHypothesis.idl \
+ MED.idl
+
+LIB_SERVER_IDL =
+
+# additionnal information to compil and link file
+
+CPPFLAGS += $(QT_INCLUDES) $(VTK_INCLUDES) $(OGL_INCLUDES) $(OCC_INCLUDES) $(PYTHON_INCLUDES) \
+ $(MED2_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome \
+ $(BOOST_CPPFLAGS)
+CXXFLAGS += -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome
+#$(OCC_CXXFLAGS)
+
+LDFLAGS += -lSMESHGUI $(OCC_KERNEL_LIBS) -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome
+
+@CONCLUDE@
--- /dev/null
+// SMESH StdMeshersGUI : GUI for plugged-in meshers
+//
+// Copyright (C) 2003 CEA
+//
+// 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.org
+//
+//
+//
+// File : StdMeshersGUI.cxx
+// Author : Julia DOROVSKIKH
+// Module : SMESH
+// $Header$
+
+using namespace std;
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "SMESHGUI.h"
+#include "SMESHGUI_Hypotheses.h"
+
+#include "StdMeshersGUI_LocalLengthDlg.h"
+#include "StdMeshersGUI_NbSegmentsDlg.h"
+#include "StdMeshersGUI_MaxElementAreaDlg.h"
+#include "StdMeshersGUI_MaxElementVolumeDlg.h"
+
+#include "QAD_Desktop.h"
+#include "QAD_ResourceMgr.h"
+
+#include <qobject.h>
+
+//=============================================================================
+/*! class HypothesisCreator
+ *
+ */
+//=============================================================================
+class StdMeshersGUI_HypothesisCreator : public SMESHGUI_GenericHypothesisCreator
+{
+ public:
+ StdMeshersGUI_HypothesisCreator (const QString& aHypType,
+ const QString& aServerLibName,
+ SMESHGUI* aSMESHGUI)
+ : myHypType(aHypType),
+ myServerLibName(aServerLibName),
+ mySMESHGUI(aSMESHGUI) {}
+
+ virtual void CreateHypothesis (const bool isAlgo, QWidget* parent = 0);
+ virtual void EditHypothesis (SMESH::SMESH_Hypothesis_ptr theHyp);
+
+ private:
+ QString myHypType;
+ QString myServerLibName;
+ SMESHGUI* mySMESHGUI;
+};
+
+//=============================================================================
+/*! HypothesisCreator::CreateHypothesis
+ *
+ */
+//=============================================================================
+void StdMeshersGUI_HypothesisCreator::CreateHypothesis
+ (bool isAlgo, QWidget* parent)
+{
+ MESSAGE("StdMeshersGUI_HypothesisCreator::CreateHypothesis");
+
+ // Get default name for hypothesis/algorithm creation
+ char* sHypType = (char*)myHypType.latin1();
+ HypothesisData* aHypData = mySMESHGUI->GetHypothesisData(sHypType);
+ QString aHypName;
+ if (aHypData)
+ aHypName = aHypData->Label;
+ else
+ aHypName = myHypType;
+
+ // Create hypothesis/algorithm
+ if (isAlgo)
+ {
+ mySMESHGUI->CreateHypothesis(myHypType, aHypName, isAlgo);
+ }
+ else
+ {
+ // Show Dialog for hypothesis creation
+ if (myHypType == "LocalLength")
+ StdMeshersGUI_LocalLengthDlg *aDlg = new StdMeshersGUI_LocalLengthDlg(myHypType, parent, "");
+ else if (myHypType == "NumberOfSegments")
+ StdMeshersGUI_NbSegmentsDlg *aDlg = new StdMeshersGUI_NbSegmentsDlg(myHypType, parent, "");
+ else if (myHypType == "MaxElementArea")
+ StdMeshersGUI_MaxElementAreaDlg *aDlg = new StdMeshersGUI_MaxElementAreaDlg(myHypType, parent, "");
+ else if (myHypType == "MaxElementVolume")
+ StdMeshersGUI_MaxElementVolumeDlg *aDlg = new StdMeshersGUI_MaxElementVolumeDlg(myHypType, parent, "");
+ else if (myHypType == "LengthFromEdges")
+ mySMESHGUI->CreateHypothesis(myHypType, aHypName, isAlgo); // without GUI
+ else if (myHypType == "NotConformAllowed")
+ mySMESHGUI->CreateHypothesis(myHypType, aHypName, isAlgo); // without GUI
+ else ;
+ }
+}
+
+//=============================================================================
+/*! HypothesisCreator::EditHypothesis
+ *
+ */
+//=============================================================================
+void StdMeshersGUI_HypothesisCreator::EditHypothesis
+ (SMESH::SMESH_Hypothesis_ptr theHyp)
+{
+ MESSAGE("StdMeshersGUI_HypothesisCreator::EditHypothesis");
+
+ Standard_Boolean res = Standard_True;
+ SALOMEDS::Study::ListOfSObject_var listSOmesh =
+ mySMESHGUI->GetMeshesUsingAlgoOrHypothesis(theHyp);
+ QString Name = theHyp->GetName();
+ if (Name.compare("LocalLength") == 0)
+ {
+ StdMeshers::StdMeshers_LocalLength_var LL =
+ StdMeshers::StdMeshers_LocalLength::_narrow(theHyp);
+ double beforeLength = LL->GetLength() ;
+ double Length = mySMESHGUI->Parameter(res,
+ beforeLength,
+ QObject::tr("SMESH_LOCAL_LENGTH_HYPOTHESIS"),
+ QObject::tr("SMESH_VALUE"),
+ 1.0E-5, 1E6, 6);
+ if (res && Length != beforeLength)
+ {
+ LL->SetLength(Length);
+ for (int i=0; i<listSOmesh->length(); i++)
+ {
+ mySMESHGUI->GetStudyAPI().ModifiedMesh(listSOmesh[i], false);
+ }
+ }
+ }
+ else if (Name.compare("NumberOfSegments") == 0)
+ {
+ StdMeshers::StdMeshers_NumberOfSegments_var NOS =
+ StdMeshers::StdMeshers_NumberOfSegments::_narrow(theHyp);
+ int beforeNbSeg = NOS->GetNumberOfSegments() ;
+ int NbSeg = mySMESHGUI->Parameter(res,
+ beforeNbSeg,
+ QObject::tr("SMESH_NB_SEGMENTS_HYPOTHESIS"),
+ QObject::tr("SMESH_VALUE"),
+ 1, 1000000);
+ if (res && NbSeg != beforeNbSeg)
+ {
+ NOS->SetNumberOfSegments(NbSeg);
+ for (int i=0; i<listSOmesh->length(); i++)
+ {
+ SALOMEDS::SObject_var SO = listSOmesh[i] ;
+ mySMESHGUI->GetStudyAPI().ModifiedMesh(listSOmesh[i], false);
+ }
+ }
+ }
+ else if (Name.compare("MaxElementArea") == 0)
+ {
+ StdMeshers::StdMeshers_MaxElementArea_var MEA =
+ StdMeshers::StdMeshers_MaxElementArea::_narrow(theHyp);
+ double beforeMaxArea = MEA->GetMaxElementArea();
+ double MaxArea = mySMESHGUI->Parameter(res,
+ beforeMaxArea,
+ QObject::tr("SMESH_MAX_ELEMENT_AREA_HYPOTHESIS"),
+ QObject::tr("SMESH_VALUE"),
+ 1.0E-5, 1E6, 6);
+ if (res && MaxArea != beforeMaxArea)
+ {
+ MEA->SetMaxElementArea(MaxArea);
+ for (int i=0; i<listSOmesh->length(); i++)
+ {
+ mySMESHGUI->GetStudyAPI().ModifiedMesh(listSOmesh[i], false);
+ }
+ }
+ }
+ else if (Name.compare("MaxElementVolume") == 0)
+ {
+ StdMeshers::StdMeshers_MaxElementVolume_var MEV =
+ StdMeshers::StdMeshers_MaxElementVolume::_narrow(theHyp);
+ double beforeMaxVolume = MEV->GetMaxElementVolume() ;
+ double MaxVolume = mySMESHGUI->Parameter(res,
+ beforeMaxVolume,
+ QObject::tr("SMESH_MAX_ELEMENT_VOLUME_HYPOTHESIS"),
+ QObject::tr("SMESH_VALUE"),
+ 1.0E-5, 1E6, 6);
+ if (res && MaxVolume != beforeMaxVolume)
+ {
+ MEV->SetMaxElementVolume(MaxVolume);
+ for (int i=0; i<listSOmesh->length(); i++)
+ {
+ mySMESHGUI->GetStudyAPI().ModifiedMesh(listSOmesh[i], false);
+ }
+ }
+ }
+// else if (Name.compare("Regular_1D") == 0)
+// {}
+// else if (Name.compare("MEFISTO_2D") == 0)
+// {}
+ else
+ {}
+}
+
+//=============================================================================
+/*! GetHypothesisCreator
+ *
+ */
+//=============================================================================
+extern "C"
+{
+ SMESHGUI_GenericHypothesisCreator* GetHypothesisCreator
+ (QString aHypType, QString aServerLibName, SMESHGUI* aSMESHGUI)
+ {
+ return new StdMeshersGUI_HypothesisCreator
+ (aHypType, aServerLibName, aSMESHGUI);
+ }
+}
--- /dev/null
+// SMESH StdMeshersGUI : GUI for StdMeshers plugin
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshersGUI_LocalLengthDlg.cxx
+// Moved here from SMESHGUI_LocalLengthDlg.cxx
+// Author : Nicolas REJNERI
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshersGUI_LocalLengthDlg.h"
+#include "SMESHGUI.h"
+#include "SMESHGUI_SpinBox.h"
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "QAD_Application.h"
+#include "QAD_Desktop.h"
+#include "utilities.h"
+
+#include "SALOMEGUI_QtCatchCorbaException.hxx"
+#include "QAD_MessageBox.h"
+#include "QAD_WaitCursor.h"
+
+// QT Includes
+#include <qgroupbox.h>
+#include <qlabel.h>
+#include <qlineedit.h>
+#include <qpushbutton.h>
+#include <qlayout.h>
+#include <qpixmap.h>
+
+//=================================================================================
+// class : StdMeshersGUI_LocalLengthDlg()
+// purpose : Constructs a StdMeshersGUI_LocalLengthDlg which is a child of 'parent', with the
+// name 'name' and widget flags set to 'f'.
+// The dialog will by default be modeless, unless you set 'modal' to
+// TRUE to construct a modal dialog.
+//=================================================================================
+StdMeshersGUI_LocalLengthDlg::StdMeshersGUI_LocalLengthDlg (const QString& hypType,
+ QWidget* parent,
+ const char* name,
+ bool modal,
+ WFlags fl)
+ : QDialog (parent, name, modal, WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu | WDestructiveClose),
+ myHypType(hypType)
+{
+ QPixmap image0(QAD_Desktop::getResourceManager()->loadPixmap( "SMESH",tr("ICON_DLG_LOCAL_LENGTH")));
+
+ if ( !name )
+ setName( "StdMeshersGUI_LocalLengthDlg" );
+ setCaption( tr( "SMESH_LOCAL_LENGTH_TITLE" ) );
+ setSizeGripEnabled( TRUE );
+ QGridLayout* StdMeshersGUI_LocalLengthDlgLayout = new QGridLayout( this );
+ StdMeshersGUI_LocalLengthDlgLayout->setSpacing( 6 );
+ StdMeshersGUI_LocalLengthDlgLayout->setMargin( 11 );
+
+ /***************************************************************/
+ iconLabel = new QLabel( this );
+ iconLabel->setPixmap( image0 );
+ iconLabel->setScaledContents( false );
+ iconLabel->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) );
+ typeLabel = new QLabel( this );
+ typeLabel->setText( tr( "SMESH_LOCAL_LENGTH_HYPOTHESIS" ) );
+ StdMeshersGUI_LocalLengthDlgLayout->addWidget( iconLabel, 0, 0 );
+ StdMeshersGUI_LocalLengthDlgLayout->addWidget( typeLabel, 0, 1 );
+
+ /***************************************************************/
+ GroupC1 = new QGroupBox( this, "GroupC1" );
+ GroupC1->setTitle( tr( "SMESH_ARGUMENTS" ) );
+ GroupC1->setColumnLayout(0, Qt::Vertical );
+ GroupC1->layout()->setSpacing( 0 );
+ GroupC1->layout()->setMargin( 0 );
+ QGridLayout* GroupC1Layout = new QGridLayout( GroupC1->layout() );
+ GroupC1Layout->setAlignment( Qt::AlignTop );
+ GroupC1Layout->setSpacing( 6 );
+ GroupC1Layout->setMargin( 11 );
+
+ TextLabel_NameHypothesis = new QLabel( GroupC1, "TextLabel_NameHypothesis" );
+ TextLabel_NameHypothesis->setText( tr( "SMESH_NAME" ) );
+ GroupC1Layout->addWidget( TextLabel_NameHypothesis, 0, 0 );
+
+ LineEdit_NameHypothesis = new QLineEdit( GroupC1, "LineEdit_NameHypothesis" );
+ GroupC1Layout->addWidget( LineEdit_NameHypothesis, 0, 1 );
+
+ TextLabel_Length = new QLabel(GroupC1 , "TextLabel_Length" );
+ TextLabel_Length->setText( tr( "SMESH_LENGTH" ) );
+ GroupC1Layout->addWidget( TextLabel_Length, 1, 0 );
+
+ SpinBox_Length = new SMESHGUI_SpinBox( GroupC1, "SpinBox_Length" );
+ GroupC1Layout->addWidget( SpinBox_Length, 1, 1 );
+
+ StdMeshersGUI_LocalLengthDlgLayout->addMultiCellWidget(GroupC1 , 1, 1, 0, 1 );
+
+ /***************************************************************/
+ GroupButtons = new QGroupBox( this, "GroupButtons" );
+ GroupButtons->setColumnLayout(0, Qt::Vertical );
+ GroupButtons->layout()->setSpacing( 0 );
+ GroupButtons->layout()->setMargin( 0 );
+ QGridLayout* GroupButtonsLayout = new QGridLayout( GroupButtons->layout() );
+ GroupButtonsLayout->setAlignment( Qt::AlignTop );
+ GroupButtonsLayout->setSpacing( 6 );
+ GroupButtonsLayout->setMargin( 11 );
+ buttonOk = new QPushButton( GroupButtons, "buttonOk" );
+ buttonOk->setText( tr( "SMESH_BUT_OK" ) );
+ buttonOk->setAutoDefault( TRUE );
+ buttonOk->setDefault( TRUE );
+ GroupButtonsLayout->addWidget( buttonOk, 0, 0 );
+ buttonApply = new QPushButton( GroupButtons, "buttonApply" );
+ buttonApply->setText( tr( "SMESH_BUT_APPLY" ) );
+ buttonApply->setAutoDefault( TRUE );
+ GroupButtonsLayout->addWidget( buttonApply, 0, 1 );
+ QSpacerItem* spacer = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
+ GroupButtonsLayout->addItem( spacer, 0, 2 );
+ buttonCancel = new QPushButton( GroupButtons, "buttonCancel" );
+ buttonCancel->setText( tr( "SMESH_BUT_CLOSE" ) );
+ buttonCancel->setAutoDefault( TRUE );
+ GroupButtonsLayout->addWidget( buttonCancel, 0, 3 );
+ StdMeshersGUI_LocalLengthDlgLayout->addMultiCellWidget( GroupButtons, 2, 2, 0, 1 );
+
+ /***************************************************************/
+ Init() ;
+}
+
+
+//=================================================================================
+// function : ~StdMeshersGUI_LocalLengthDlg()
+// purpose : Destroys the object and frees any allocated resources
+//=================================================================================
+StdMeshersGUI_LocalLengthDlg::~StdMeshersGUI_LocalLengthDlg()
+{
+ // no need to delete child widgets, Qt does it all for us
+}
+
+
+//=================================================================================
+// function : Init()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_LocalLengthDlg::Init()
+{
+ /* min, max, step and decimals for spin boxes */
+ SpinBox_Length->RangeStepAndValidator( 0.001, 999.999, 1.0, 3 ) ;
+ SpinBox_Length->SetValue( 1.0 ) ;
+
+ mySMESHGUI = SMESHGUI::GetSMESHGUI() ;
+
+ char* sHypType = (char*)myHypType.latin1();
+ HypothesisData* aHypData = mySMESHGUI->GetHypothesisData(sHypType);
+ LineEdit_NameHypothesis->setText( aHypData ? aHypData->Label : "" );
+
+ mySMESHGUI->SetActiveDialogBox( (QDialog*)this ) ;
+
+ /* signals and slots connections */
+ connect( buttonOk, SIGNAL(clicked()), this, SLOT(ClickOnOk()) );
+ connect( buttonCancel, SIGNAL(clicked()), this, SLOT(ClickOnCancel()) ) ;
+ connect( buttonApply, SIGNAL(clicked()), this, SLOT(ClickOnApply()) );
+
+ connect( mySMESHGUI, SIGNAL ( SignalDeactivateActiveDialog() ), this, SLOT( DeactivateActiveDialog() ) ) ;
+ connect( mySMESHGUI, SIGNAL ( SignalCloseAllDialogs() ), this, SLOT( ClickOnCancel() ) ) ;
+
+ /* Move widget on the botton right corner of main widget */
+ int x, y ;
+ mySMESHGUI->DefineDlgPosition( this, x, y ) ;
+ this->move( x, y ) ;
+ this->show() ; /* displays Dialog */
+}
+
+
+//=================================================================================
+// function : ClickOnOk()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_LocalLengthDlg::ClickOnOk()
+{
+ if ( this->ClickOnApply() )
+ this->ClickOnCancel() ;
+}
+
+//=================================================================================
+// function : ClickOnApply()
+// purpose :
+//=================================================================================
+bool StdMeshersGUI_LocalLengthDlg::ClickOnApply()
+{
+ QString myHypName = LineEdit_NameHypothesis->text().stripWhiteSpace();
+ if ( myHypName.isEmpty() ) {
+ QAD_MessageBox::warn1( this, tr( "SMESH_WRN_WARNING" ), tr( "SMESH_WRN_EMPTY_NAME" ), tr( "SMESH_BUT_OK" ) );
+ return false;
+ }
+
+ double myLength = SpinBox_Length->GetValue();
+
+ QAD_WaitCursor wc;
+ try {
+ SMESH::SMESH_Hypothesis_var Hyp = SMESH::SMESH_Hypothesis::_narrow
+ (mySMESHGUI->CreateHypothesis(myHypType,
+ myHypName,
+ false)); // isAlgorithm
+ StdMeshers::StdMeshers_LocalLength_var LL =
+ StdMeshers::StdMeshers_LocalLength::_narrow(Hyp);
+ if (!LL->_is_nil())
+ LL->SetLength(myLength);
+ }
+ catch (const SALOME::SALOME_Exception& S_ex) {
+ wc.stop();
+ QtCatchCorbaException(S_ex);
+ return false;
+ }
+ return true;
+}
+
+
+//=================================================================================
+// function : ClickOnCancel()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_LocalLengthDlg::ClickOnCancel()
+{
+ close();
+}
+
+//=================================================================================
+// function : DeactivateActiveDialog()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_LocalLengthDlg::DeactivateActiveDialog()
+{
+ iconLabel->setEnabled(false) ;
+ typeLabel->setEnabled(false) ;
+ GroupC1->setEnabled(false) ;
+ GroupButtons->setEnabled(false) ;
+}
+
+
+//=================================================================================
+// function : ActivateThisDialog()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_LocalLengthDlg::ActivateThisDialog()
+{
+ mySMESHGUI->EmitSignalDeactivateDialog() ;
+ iconLabel->setEnabled(true) ;
+ typeLabel->setEnabled(true) ;
+ GroupC1->setEnabled(true) ;
+ GroupButtons->setEnabled(true) ;
+}
+
+
+//=================================================================================
+// function : enterEvent()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_LocalLengthDlg::enterEvent(QEvent* e)
+{
+ ActivateThisDialog() ;
+}
+
+
+//=================================================================================
+// function : closeEvent()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_LocalLengthDlg::closeEvent( QCloseEvent* e )
+{
+ mySMESHGUI->ResetState();
+ QDialog::closeEvent( e );
+}
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshersGUI_LocalLengthDlg.h
+// Moved here from SMESHGUI_LocalLengthDlg.h
+// Author : Nicolas REJNERI
+// Module : SMESH
+// $Header$
+
+#ifndef DIALOGBOX_LOCAL_LENGTH_H
+#define DIALOGBOX_LOCAL_LENGTH_H
+
+// QT Includes
+#include <qdialog.h>
+
+class QGroupBox;
+class QLabel;
+class QLineEdit;
+class QPushButton;
+class SMESHGUI;
+class SMESHGUI_SpinBox;
+
+//=================================================================================
+// class : StdMeshersGUI_LocalLengthDlg
+// purpose :
+//=================================================================================
+class StdMeshersGUI_LocalLengthDlg : public QDialog
+{
+ Q_OBJECT
+
+public:
+ StdMeshersGUI_LocalLengthDlg (const QString& hypType,
+ QWidget* parent = 0,
+ const char* name = 0,
+ bool modal = FALSE,
+ WFlags fl = 0);
+ ~StdMeshersGUI_LocalLengthDlg ();
+
+private:
+
+ void Init() ;
+ void closeEvent( QCloseEvent* e ) ;
+ void enterEvent ( QEvent * ) ;
+
+ SMESHGUI* mySMESHGUI ;
+ QString myHypType ;
+
+ QLabel* iconLabel;
+ QLabel* typeLabel;
+ QGroupBox* GroupC1;
+ QLabel* TextLabel_NameHypothesis ;
+ QLineEdit* LineEdit_NameHypothesis ;
+ QLabel* TextLabel_Length ;
+ SMESHGUI_SpinBox* SpinBox_Length ;
+ QGroupBox* GroupButtons;
+ QPushButton* buttonOk;
+ QPushButton* buttonApply;
+ QPushButton* buttonCancel;
+
+private slots:
+
+ void ClickOnOk();
+ void ClickOnCancel();
+ bool ClickOnApply();
+ void DeactivateActiveDialog() ;
+ void ActivateThisDialog() ;
+};
+
+#endif // DIALOGBOX_LOCAL_LENGTH_H
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshersGUI_MaxElementAreaDlg.cxx
+// Moved here from SMESHGUI_MaxElementAreaDlg.cxx
+// Author : Nicolas REJNERI
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshersGUI_MaxElementAreaDlg.h"
+#include "SMESHGUI.h"
+#include "SMESHGUI_SpinBox.h"
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "QAD_Application.h"
+#include "QAD_Desktop.h"
+#include "utilities.h"
+
+#include "SALOMEGUI_QtCatchCorbaException.hxx"
+#include "QAD_MessageBox.h"
+#include "QAD_WaitCursor.h"
+
+// QT Includes
+#include <qgroupbox.h>
+#include <qlabel.h>
+#include <qlineedit.h>
+#include <qpushbutton.h>
+#include <qlayout.h>
+#include <qpixmap.h>
+
+//=================================================================================
+// class : StdMeshersGUI_MaxElementAreaDlg()
+// purpose : Constructs a StdMeshersGUI_MaxElementAreaDlg which is a child of 'parent', with the
+// name 'name' and widget flags set to 'f'.
+// The dialog will by default be modeless, unless you set 'modal' to
+// TRUE to construct a modal dialog.
+//=================================================================================
+StdMeshersGUI_MaxElementAreaDlg::StdMeshersGUI_MaxElementAreaDlg (const QString& hypType,
+ QWidget* parent,
+ const char* name,
+ bool modal,
+ WFlags fl)
+ : QDialog (parent, name, modal, WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu | WDestructiveClose),
+ myHypType(hypType)
+{
+ QPixmap image0(QAD_Desktop::getResourceManager()->loadPixmap( "SMESH",tr("ICON_DLG_MAX_ELEMENT_AREA")));
+
+ if ( !name )
+ setName( "StdMeshersGUI_MaxElementAreaDlg" );
+ setCaption( tr( "SMESH_MAX_ELEMENT_AREA_TITLE" ) );
+ setSizeGripEnabled( TRUE );
+ QGridLayout* StdMeshersGUI_MaxElementAreaDlgLayout = new QGridLayout( this );
+ StdMeshersGUI_MaxElementAreaDlgLayout->setSpacing( 6 );
+ StdMeshersGUI_MaxElementAreaDlgLayout->setMargin( 11 );
+
+ /***************************************************************/
+ iconLabel = new QLabel( this );
+ iconLabel->setPixmap( image0 );
+ iconLabel->setScaledContents( false );
+ iconLabel->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) );
+ typeLabel = new QLabel( this );
+ typeLabel->setText( tr( "SMESH_MAX_ELEMENT_AREA_HYPOTHESIS" ) );
+ StdMeshersGUI_MaxElementAreaDlgLayout->addWidget( iconLabel, 0, 0 );
+ StdMeshersGUI_MaxElementAreaDlgLayout->addWidget( typeLabel, 0, 1 );
+
+ /***************************************************************/
+ GroupC1 = new QGroupBox( this, "GroupC1" );
+ GroupC1->setTitle( tr( "SMESH_ARGUMENTS" ) );
+ GroupC1->setColumnLayout(0, Qt::Vertical );
+ GroupC1->layout()->setSpacing( 0 );
+ GroupC1->layout()->setMargin( 0 );
+ QGridLayout* GroupC1Layout = new QGridLayout( GroupC1->layout() );
+ GroupC1Layout->setAlignment( Qt::AlignTop );
+ GroupC1Layout->setSpacing( 6 );
+ GroupC1Layout->setMargin( 11 );
+
+ TextLabel_NameHypothesis = new QLabel( GroupC1, "TextLabel_NameHypothesis" );
+ TextLabel_NameHypothesis->setText( tr( "SMESH_NAME" ) );
+ GroupC1Layout->addWidget( TextLabel_NameHypothesis, 0, 0 );
+
+ LineEdit_NameHypothesis = new QLineEdit( GroupC1, "LineEdit_NameHypothesis" );
+ GroupC1Layout->addWidget( LineEdit_NameHypothesis, 0, 1 );
+
+ TextLabel_MaxElementArea = new QLabel(GroupC1 , "TextLabel_MaxElementArea" );
+ TextLabel_MaxElementArea->setText( tr( "SMESH_MAX_ELEMENT_AREA" ) );
+ GroupC1Layout->addWidget( TextLabel_MaxElementArea, 1, 0 );
+
+ SpinBox_MaxElementArea = new SMESHGUI_SpinBox( GroupC1, "SpinBox_MaxElementArea" ) ;
+ GroupC1Layout->addWidget( SpinBox_MaxElementArea, 1, 1 );
+
+ StdMeshersGUI_MaxElementAreaDlgLayout->addMultiCellWidget(GroupC1 , 1, 1, 0, 1);
+
+ /***************************************************************/
+ GroupButtons = new QGroupBox( this, "GroupButtons" );
+ GroupButtons->setColumnLayout(0, Qt::Vertical );
+ GroupButtons->layout()->setSpacing( 0 );
+ GroupButtons->layout()->setMargin( 0 );
+ QGridLayout* GroupButtonsLayout = new QGridLayout( GroupButtons->layout() );
+ GroupButtonsLayout->setAlignment( Qt::AlignTop );
+ GroupButtonsLayout->setSpacing( 6 );
+ GroupButtonsLayout->setMargin( 11 );
+ buttonOk = new QPushButton( GroupButtons, "buttonOk" );
+ buttonOk->setText( tr( "SMESH_BUT_OK" ) );
+ buttonOk->setAutoDefault( TRUE );
+ buttonOk->setDefault( TRUE );
+ GroupButtonsLayout->addWidget( buttonOk, 0, 0 );
+ buttonApply = new QPushButton( GroupButtons, "buttonApply" );
+ buttonApply->setText( tr( "SMESH_BUT_APPLY" ) );
+ buttonApply->setAutoDefault( TRUE );
+ GroupButtonsLayout->addWidget( buttonApply, 0, 1 );
+ QSpacerItem* spacer = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
+ GroupButtonsLayout->addItem( spacer, 0, 2 );
+ buttonCancel = new QPushButton( GroupButtons, "buttonCancel" );
+ buttonCancel->setText( tr( "SMESH_BUT_CLOSE" ) );
+ buttonCancel->setAutoDefault( TRUE );
+ GroupButtonsLayout->addWidget( buttonCancel, 0, 3 );
+ StdMeshersGUI_MaxElementAreaDlgLayout->addMultiCellWidget( GroupButtons, 2, 2, 0, 1 );
+
+ /***************************************************************/
+ Init() ;
+}
+
+
+//=================================================================================
+// function : ~StdMeshersGUI_MaxElementAreaDlg()
+// purpose : Destroys the object and frees any allocated resources
+//=================================================================================
+StdMeshersGUI_MaxElementAreaDlg::~StdMeshersGUI_MaxElementAreaDlg()
+{
+ // no need to delete child widgets, Qt does it all for us
+}
+
+
+//=================================================================================
+// function : Init()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementAreaDlg::Init()
+{
+ /* min, max, step and decimals for spin boxes */
+ SpinBox_MaxElementArea->setPrecision( 10 );
+ SpinBox_MaxElementArea->RangeStepAndValidator( 0.001, 999999.999, 1.0, 3 ) ;
+ SpinBox_MaxElementArea->SetValue( 1.0 ) ; /* is myMaxElementArea */
+
+ mySMESHGUI = SMESHGUI::GetSMESHGUI() ;
+
+ char* sHypType = (char*)myHypType.latin1();
+ HypothesisData* aHypData = mySMESHGUI->GetHypothesisData(sHypType);
+ LineEdit_NameHypothesis->setText( aHypData ? aHypData->Label : "" );
+
+ mySMESHGUI->SetActiveDialogBox( (QDialog*)this ) ;
+
+ /* signals and slots connections */
+ connect( buttonOk, SIGNAL(clicked()), this, SLOT(ClickOnOk()) );
+ connect( buttonCancel, SIGNAL(clicked()), this, SLOT(ClickOnCancel()) ) ;
+ connect( buttonApply, SIGNAL(clicked()), this, SLOT(ClickOnApply()) );
+
+ connect( mySMESHGUI, SIGNAL ( SignalDeactivateActiveDialog() ), this, SLOT( DeactivateActiveDialog() ) ) ;
+ connect( mySMESHGUI, SIGNAL ( SignalCloseAllDialogs() ), this, SLOT( ClickOnCancel() ) ) ;
+
+ /* Move widget on the botton right corner of main widget */
+ int x, y ;
+ mySMESHGUI->DefineDlgPosition( this, x, y ) ;
+ this->move( x, y ) ;
+ this->show() ; /* displays Dialog */
+}
+
+
+//=================================================================================
+// function : ClickOnOk()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementAreaDlg::ClickOnOk()
+{
+ if ( this->ClickOnApply() )
+ this->ClickOnCancel() ;
+}
+
+//=================================================================================
+// function : ClickOnApply()
+// purpose :
+//=================================================================================
+bool StdMeshersGUI_MaxElementAreaDlg::ClickOnApply()
+{
+ QString myHypName = LineEdit_NameHypothesis->text().stripWhiteSpace();
+ if ( myHypName.isEmpty() ) {
+ QAD_MessageBox::warn1( this, tr( "SMESH_WRN_WARNING" ), tr( "SMESH_WRN_EMPTY_NAME" ), tr( "SMESH_BUT_OK" ) );
+ return false;
+ }
+
+ double myMaxElementArea = SpinBox_MaxElementArea->GetValue();
+
+ QAD_WaitCursor wc;
+ try {
+ SMESH::SMESH_Hypothesis_var Hyp = SMESH::SMESH_Hypothesis::_narrow
+ (mySMESHGUI->CreateHypothesis(myHypType,
+ myHypName,
+ false)); // isAlgorithm
+ StdMeshers::StdMeshers_MaxElementArea_var MaxElArea =
+ StdMeshers::StdMeshers_MaxElementArea::_narrow(Hyp);
+ if (!MaxElArea->_is_nil())
+ MaxElArea->SetMaxElementArea(myMaxElementArea);
+ }
+ catch (const SALOME::SALOME_Exception& S_ex) {
+ wc.stop();
+ QtCatchCorbaException(S_ex);
+ return false;
+ }
+ return true;
+}
+
+
+//=================================================================================
+// function : ClickOnCancel()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementAreaDlg::ClickOnCancel()
+{
+ close();
+}
+
+
+//=================================================================================
+// function : DeactivateActiveDialog()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementAreaDlg::DeactivateActiveDialog()
+{
+ iconLabel->setEnabled(false) ;
+ typeLabel->setEnabled(false) ;
+ GroupC1->setEnabled(false) ;
+ GroupButtons->setEnabled(false) ;
+}
+
+
+//=================================================================================
+// function : ActivateThisDialog()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementAreaDlg::ActivateThisDialog()
+{
+ mySMESHGUI->EmitSignalDeactivateDialog() ;
+ iconLabel->setEnabled(true) ;
+ typeLabel->setEnabled(true) ;
+ GroupC1->setEnabled(true) ;
+ GroupButtons->setEnabled(true) ;
+}
+
+
+//=================================================================================
+// function : enterEvent()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementAreaDlg::enterEvent(QEvent* e)
+{
+ ActivateThisDialog() ;
+}
+
+
+//=================================================================================
+// function : closeEvent()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementAreaDlg::closeEvent( QCloseEvent* e )
+{
+ mySMESHGUI->ResetState();
+ QDialog::closeEvent( e );
+}
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshersGUI_MaxElementAreaDlg.h
+// Moved here from SMESHGUI_MaxElementAreaDlg.h
+// Author : Nicolas REJNERI
+// Module : SMESH
+// $Header$
+
+#ifndef DIALOGBOX_MAX_ELEMENT_AREA_H
+#define DIALOGBOX_MAX_ELEMENT_AREA_H
+
+// QT Includes
+#include <qdialog.h>
+
+class QGroupBox;
+class QLabel;
+class QLineEdit;
+class QPushButton;
+class SMESHGUI;
+class SMESHGUI_SpinBox;
+
+//=================================================================================
+// class : StdMeshersGUI_MaxElementAreaDlg
+// purpose :
+//=================================================================================
+class StdMeshersGUI_MaxElementAreaDlg : public QDialog
+{
+ Q_OBJECT
+
+public:
+ StdMeshersGUI_MaxElementAreaDlg (const QString& hypType,
+ QWidget* parent = 0,
+ const char* name = 0,
+ bool modal = FALSE,
+ WFlags fl = 0 );
+ ~StdMeshersGUI_MaxElementAreaDlg ();
+
+private:
+
+ void Init() ;
+ void closeEvent( QCloseEvent* e ) ;
+ void enterEvent ( QEvent * ) ;
+
+ SMESHGUI* mySMESHGUI ;
+ QString myHypType ;
+
+ QLabel* iconLabel;
+ QLabel* typeLabel;
+ QGroupBox* GroupC1;
+ QLabel* TextLabel_NameHypothesis ;
+ QLineEdit* LineEdit_NameHypothesis ;
+ QLabel* TextLabel_MaxElementArea ;
+ SMESHGUI_SpinBox* SpinBox_MaxElementArea ;
+ QGroupBox* GroupButtons;
+ QPushButton* buttonApply;
+ QPushButton* buttonOk;
+ QPushButton* buttonCancel;
+
+private slots:
+
+ void ClickOnOk();
+ void ClickOnCancel();
+ bool ClickOnApply();
+ void DeactivateActiveDialog() ;
+ void ActivateThisDialog() ;
+};
+
+#endif // DIALOGBOX_MAX_ELEMENT_AREA_H
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshersGUI_MaxElementVolumeDlg.cxx
+// Moved here from SMESHGUI_MaxElementVolumeDlg.cxx
+// Author : Nicolas REJNERI
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshersGUI_MaxElementVolumeDlg.h"
+#include "SMESHGUI.h"
+#include "SMESHGUI_SpinBox.h"
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "QAD_Application.h"
+#include "QAD_Desktop.h"
+#include "utilities.h"
+
+#include "SALOMEGUI_QtCatchCorbaException.hxx"
+#include "QAD_MessageBox.h"
+#include "QAD_WaitCursor.h"
+
+// QT Includes
+#include <qgroupbox.h>
+#include <qlabel.h>
+#include <qlineedit.h>
+#include <qpushbutton.h>
+#include <qlayout.h>
+#include <qpixmap.h>
+
+//=================================================================================
+// class : StdMeshersGUI_MaxElementVolumeDlg()
+// purpose : Constructs a StdMeshersGUI_MaxElementVolumeDlg which is a child of 'parent', with the
+// name 'name' and widget flags set to 'f'.
+// The dialog will by default be modeless, unless you set 'modal' to
+// TRUE to construct a modal dialog.
+//=================================================================================
+StdMeshersGUI_MaxElementVolumeDlg::StdMeshersGUI_MaxElementVolumeDlg (const QString& hypType,
+ QWidget* parent,
+ const char* name,
+ bool modal, WFlags fl)
+ : QDialog (parent, name, modal, WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu | WDestructiveClose),
+ myHypType(hypType)
+{
+ QPixmap image0(QAD_Desktop::getResourceManager()->loadPixmap( "SMESH",tr("ICON_DLG_MAX_ELEMENT_VOLUME")));
+
+ if ( !name )
+ setName( "StdMeshersGUI_MaxElementVolumeDlg" );
+ setCaption( tr( "SMESH_MAX_ELEMENT_VOLUME_TITLE" ) );
+ setSizeGripEnabled( TRUE );
+ QGridLayout* StdMeshersGUI_MaxElementVolumeDlgLayout = new QGridLayout( this );
+ StdMeshersGUI_MaxElementVolumeDlgLayout->setSpacing( 6 );
+ StdMeshersGUI_MaxElementVolumeDlgLayout->setMargin( 11 );
+
+ /***************************************************************/
+ iconLabel = new QLabel( this );
+ iconLabel->setPixmap( image0 );
+ iconLabel->setScaledContents( false );
+ iconLabel->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) );
+ typeLabel = new QLabel( this );
+ typeLabel->setText( tr( "SMESH_MAX_ELEMENT_VOLUME_HYPOTHESIS" ) );
+ StdMeshersGUI_MaxElementVolumeDlgLayout->addWidget( iconLabel, 0, 0 );
+ StdMeshersGUI_MaxElementVolumeDlgLayout->addWidget( typeLabel, 0, 1 );
+
+ /***************************************************************/
+ GroupButtons = new QGroupBox( this, "GroupButtons" );
+ GroupButtons->setColumnLayout(0, Qt::Vertical );
+ GroupButtons->layout()->setSpacing( 0 );
+ GroupButtons->layout()->setMargin( 0 );
+ QGridLayout* GroupButtonsLayout = new QGridLayout( GroupButtons->layout() );
+ GroupButtonsLayout->setAlignment( Qt::AlignTop );
+ GroupButtonsLayout->setSpacing( 6 );
+ GroupButtonsLayout->setMargin( 11 );
+ buttonOk = new QPushButton( GroupButtons, "buttonOk" );
+ buttonOk->setText( tr( "SMESH_BUT_OK" ) );
+ buttonOk->setAutoDefault( TRUE );
+ buttonOk->setDefault( TRUE );
+ GroupButtonsLayout->addWidget( buttonOk, 0, 0 );
+ buttonApply = new QPushButton( GroupButtons, "buttonApply" );
+ buttonApply->setText( tr( "SMESH_BUT_APPLY" ) );
+ buttonApply->setAutoDefault( TRUE );
+ GroupButtonsLayout->addWidget( buttonApply, 0, 1 );
+ QSpacerItem* spacer = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
+ GroupButtonsLayout->addItem( spacer, 0, 2 );
+ buttonCancel = new QPushButton( GroupButtons, "buttonCancel" );
+ buttonCancel->setText( tr( "SMESH_BUT_CLOSE" ) );
+ buttonCancel->setAutoDefault( TRUE );
+ GroupButtonsLayout->addWidget( buttonCancel, 0, 3 );
+ StdMeshersGUI_MaxElementVolumeDlgLayout->addMultiCellWidget( GroupButtons, 2, 2, 0, 1 );
+
+ /***************************************************************/
+ GroupC1 = new QGroupBox( this, "GroupC1" );
+ GroupC1->setTitle( tr( "SMESH_ARGUMENTS" ) );
+ GroupC1->setColumnLayout(0, Qt::Vertical );
+ GroupC1->layout()->setSpacing( 0 );
+ GroupC1->layout()->setMargin( 0 );
+ QGridLayout* GroupC1Layout = new QGridLayout( GroupC1->layout() );
+ GroupC1Layout->setAlignment( Qt::AlignTop );
+ GroupC1Layout->setSpacing( 6 );
+ GroupC1Layout->setMargin( 11 );
+
+ TextLabel_NameHypothesis = new QLabel( GroupC1, "TextLabel_NameHypothesis" );
+ TextLabel_NameHypothesis->setText( tr( "SMESH_NAME" ) );
+ GroupC1Layout->addWidget( TextLabel_NameHypothesis, 0, 0 );
+
+ LineEdit_NameHypothesis = new QLineEdit( GroupC1, "LineEdit_NameHypothesis" );
+ GroupC1Layout->addWidget( LineEdit_NameHypothesis, 0, 1 );
+
+ TextLabel_MaxElementVolume = new QLabel(GroupC1 , "TextLabel_MaxElementVolume" );
+ TextLabel_MaxElementVolume->setText( tr( "SMESH_MAX_ELEMENT_VOLUME" ) );
+ GroupC1Layout->addWidget( TextLabel_MaxElementVolume, 1, 0 );
+
+ SpinBox_MaxElementVolume = new SMESHGUI_SpinBox( GroupC1, "SpinBox_MaxElementVolume" ) ;
+ GroupC1Layout->addWidget( SpinBox_MaxElementVolume, 1, 1 );
+
+ StdMeshersGUI_MaxElementVolumeDlgLayout->addMultiCellWidget(GroupC1 , 1, 1, 0, 1 );
+
+ /***************************************************************/
+ Init() ;
+}
+
+
+//=================================================================================
+// function : ~StdMeshersGUI_MaxElementVolumeDlg()
+// purpose : Destroys the object and frees any allocated resources
+//=================================================================================
+StdMeshersGUI_MaxElementVolumeDlg::~StdMeshersGUI_MaxElementVolumeDlg()
+{
+ // no need to delete child widgets, Qt does it all for us
+}
+
+
+//=================================================================================
+// function : Init()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementVolumeDlg::Init()
+{
+ /* min, max, step and decimals for spin boxes */
+ SpinBox_MaxElementVolume->setPrecision( 10 );
+ SpinBox_MaxElementVolume->RangeStepAndValidator( 0.001, 999999.999, 1.0, 3 ) ;
+ SpinBox_MaxElementVolume->SetValue( 1.0 ) ; /* is myMaxElementVolume */
+
+ mySMESHGUI = SMESHGUI::GetSMESHGUI() ;
+
+ char* sHypType = (char*)myHypType.latin1();
+ HypothesisData* aHypData = mySMESHGUI->GetHypothesisData(sHypType);
+ LineEdit_NameHypothesis->setText( aHypData ? aHypData->Label : "" );
+
+ mySMESHGUI->SetActiveDialogBox( (QDialog*)this ) ;
+
+ /* signals and slots connections */
+ connect( buttonOk, SIGNAL(clicked()), this, SLOT(ClickOnOk()) );
+ connect( buttonCancel, SIGNAL(clicked()), this, SLOT(ClickOnCancel()) ) ;
+ connect( buttonApply, SIGNAL(clicked()), this, SLOT(ClickOnApply()) );
+
+ connect( mySMESHGUI, SIGNAL ( SignalDeactivateActiveDialog() ), this, SLOT( DeactivateActiveDialog() ) ) ;
+ connect( mySMESHGUI, SIGNAL ( SignalCloseAllDialogs() ), this, SLOT( ClickOnCancel() ) ) ;
+
+ /* Move widget on the botton right corner of main widget */
+ int x, y ;
+ mySMESHGUI->DefineDlgPosition( this, x, y ) ;
+ this->move( x, y ) ;
+ this->show() ; /* displays Dialog */
+}
+
+
+//=================================================================================
+// function : ClickOnOk()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementVolumeDlg::ClickOnOk()
+{
+ if ( this->ClickOnApply() )
+ this->ClickOnCancel() ;
+}
+
+//=================================================================================
+// function : ClickOnApply()
+// purpose :
+//=================================================================================
+bool StdMeshersGUI_MaxElementVolumeDlg::ClickOnApply()
+{
+ QString myHypName = LineEdit_NameHypothesis->text().stripWhiteSpace();
+ if ( myHypName.isEmpty() ) {
+ QAD_MessageBox::warn1( this, tr( "SMESH_WRN_WARNING" ), tr( "SMESH_WRN_EMPTY_NAME" ), tr( "SMESH_BUT_OK" ) );
+ return false;
+ }
+
+ double myMaxElementVolume = SpinBox_MaxElementVolume->GetValue();
+
+ QAD_WaitCursor wc;
+ try {
+ SMESH::SMESH_Hypothesis_var Hyp = SMESH::SMESH_Hypothesis::_narrow
+ (mySMESHGUI->CreateHypothesis(myHypType,
+ myHypName,
+ false)); // isAlgorithm
+ StdMeshers::StdMeshers_MaxElementVolume_var MaxElVolume =
+ StdMeshers::StdMeshers_MaxElementVolume::_narrow(Hyp);
+ if (!MaxElVolume->_is_nil())
+ MaxElVolume->SetMaxElementVolume(myMaxElementVolume);
+ }
+ catch (const SALOME::SALOME_Exception& S_ex) {
+ wc.stop();
+ QtCatchCorbaException(S_ex);
+ return false;
+ }
+ return true;
+}
+
+
+//=================================================================================
+// function : ClickOnCancel()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementVolumeDlg::ClickOnCancel()
+{
+ close();
+}
+
+
+//=================================================================================
+// function : DeactivateActiveDialog()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementVolumeDlg::DeactivateActiveDialog()
+{
+ iconLabel->setEnabled(false) ;
+ typeLabel->setEnabled(false) ;
+ GroupC1->setEnabled(false) ;
+ GroupButtons->setEnabled(false) ;
+}
+
+
+//=================================================================================
+// function : ActivateThisDialog()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementVolumeDlg::ActivateThisDialog()
+{
+ mySMESHGUI->EmitSignalDeactivateDialog() ;
+ iconLabel->setEnabled(true) ;
+ typeLabel->setEnabled(true) ;
+ GroupC1->setEnabled(true) ;
+ GroupButtons->setEnabled(true) ;
+}
+
+
+//=================================================================================
+// function : enterEvent()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementVolumeDlg::enterEvent(QEvent* e)
+{
+ ActivateThisDialog() ;
+}
+
+
+//=================================================================================
+// function : closeEvent()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_MaxElementVolumeDlg::closeEvent( QCloseEvent* e )
+{
+ mySMESHGUI->ResetState();
+ QDialog::closeEvent( e );
+}
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshersGUI_MaxElementVolumeDlg.h
+// Moved here from SMESHGUI_MaxElementVolumeDlg.h
+// Author : Nicolas REJNERI
+// Module : SMESH
+// $Header$
+
+#ifndef DIALOGBOX_MAX_ELEMENT_VOLUME_H
+#define DIALOGBOX_MAX_ELEMENT_VOLUME_H
+
+// QT Includes
+#include <qdialog.h>
+
+class QGroupBox;
+class QLabel;
+class QLineEdit;
+class QPushButton;
+class SMESHGUI;
+class SMESHGUI_SpinBox;
+
+//=================================================================================
+// class : StdMeshersGUI_MaxElementVolumeDlg
+// purpose :
+//=================================================================================
+class StdMeshersGUI_MaxElementVolumeDlg : public QDialog
+{
+ Q_OBJECT
+
+public:
+ StdMeshersGUI_MaxElementVolumeDlg (const QString& hypType,
+ QWidget* parent = 0,
+ const char* name = 0,
+ bool modal = FALSE,
+ WFlags fl = 0 );
+ ~StdMeshersGUI_MaxElementVolumeDlg ();
+
+private:
+
+ void Init() ;
+ void closeEvent( QCloseEvent* e ) ;
+ void enterEvent ( QEvent * ) ;
+
+ SMESHGUI* mySMESHGUI ;
+ QString myHypType ;
+
+ QLabel* iconLabel;
+ QLabel* typeLabel;
+ QGroupBox* GroupButtons;
+ QPushButton* buttonApply;
+ QPushButton* buttonOk;
+ QPushButton* buttonCancel;
+ QGroupBox* GroupC1;
+ QLabel* TextLabel_NameHypothesis ;
+ QLineEdit* LineEdit_NameHypothesis ;
+ QLabel* TextLabel_MaxElementVolume ;
+ SMESHGUI_SpinBox* SpinBox_MaxElementVolume ;
+
+private slots:
+
+ void ClickOnOk();
+ void ClickOnCancel();
+ bool ClickOnApply();
+ void DeactivateActiveDialog() ;
+ void ActivateThisDialog() ;
+};
+
+#endif // DIALOGBOX_MAX_ELEMENT_VOLUME_H
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshersGUI_NbSegmentsDlg.cxx
+// Moved here from SMESHGUI_NbSegmentsDlg.cxx
+// Author : Nicolas REJNERI
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshersGUI_NbSegmentsDlg.h"
+#include "SMESHGUI.h"
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "QAD_Application.h"
+#include "QAD_Desktop.h"
+#include "utilities.h"
+
+#include "SALOMEGUI_QtCatchCorbaException.hxx"
+#include "QAD_MessageBox.h"
+#include "QAD_WaitCursor.h"
+
+// QT Includes
+#include <qgroupbox.h>
+#include <qlabel.h>
+#include <qlineedit.h>
+#include <qpushbutton.h>
+#include <qlayout.h>
+#include <qpixmap.h>
+#include <qspinbox.h>
+
+//=================================================================================
+// class : StdMeshersGUI_NbSegmentsDlg()
+// purpose : Constructs a StdMeshersGUI_NbSegmentsDlg which is a child of 'parent', with the
+// name 'name' and widget flags set to 'f'.
+// The dialog will by default be modeless, unless you set 'modal' to
+// TRUE to construct a modal dialog.
+//=================================================================================
+StdMeshersGUI_NbSegmentsDlg::StdMeshersGUI_NbSegmentsDlg (const QString& hypType,
+ QWidget* parent,
+ const char* name,
+ bool modal,
+ WFlags fl)
+ : QDialog (parent, name, modal, WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu | WDestructiveClose),
+ myHypType(hypType)
+{
+ QPixmap image0(QAD_Desktop::getResourceManager()->loadPixmap( "SMESH",tr("ICON_DLG_NB_SEGMENTS")));
+
+ if ( !name )
+ setName( "StdMeshersGUI_NbSegmentsDlg" );
+ setCaption( tr( "SMESH_NB_SEGMENTS_TITLE" ) );
+ setSizeGripEnabled( TRUE );
+ QGridLayout* StdMeshersGUI_NbSegmentsDlgLayout = new QGridLayout( this );
+ StdMeshersGUI_NbSegmentsDlgLayout->setSpacing( 6 );
+ StdMeshersGUI_NbSegmentsDlgLayout->setMargin( 11 );
+
+ /***************************************************************/
+ iconLabel = new QLabel( this );
+ iconLabel->setPixmap( image0 );
+ iconLabel->setScaledContents( false );
+ iconLabel->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) );
+ typeLabel = new QLabel( this );
+ typeLabel->setText( tr( "SMESH_NB_SEGMENTS_HYPOTHESIS" ) );
+ StdMeshersGUI_NbSegmentsDlgLayout->addWidget( iconLabel, 0, 0 );
+ StdMeshersGUI_NbSegmentsDlgLayout->addWidget( typeLabel, 0, 1 );
+
+ /***************************************************************/
+ GroupC1 = new QGroupBox( this, "GroupC1" );
+ GroupC1->setTitle( tr( "SMESH_ARGUMENTS" ) );
+ GroupC1->setColumnLayout(0, Qt::Vertical );
+ GroupC1->layout()->setSpacing( 0 );
+ GroupC1->layout()->setMargin( 0 );
+ QGridLayout* GroupC1Layout = new QGridLayout( GroupC1->layout() );
+ GroupC1Layout->setAlignment( Qt::AlignTop );
+ GroupC1Layout->setSpacing( 6 );
+ GroupC1Layout->setMargin( 11 );
+
+ LineEdit_NameHypothesis = new QLineEdit( GroupC1, "LineEdit_NameHypothesis" );
+ GroupC1Layout->addWidget( LineEdit_NameHypothesis, 0, 1 );
+
+ TextLabel_NameHypothesis = new QLabel( GroupC1, "TextLabel_NameHypothesis" );
+ TextLabel_NameHypothesis->setText( tr( "SMESH_NAME" ) );
+ GroupC1Layout->addWidget( TextLabel_NameHypothesis, 0, 0 );
+
+ TextLabel_NbSeg = new QLabel(GroupC1 , "TextLabel_NbSeg" );
+ TextLabel_NbSeg->setText( tr( "SMESH_SEGMENTS" ) );
+ GroupC1Layout->addWidget( TextLabel_NbSeg, 1, 0 );
+
+ SpinBox_NbSeg = new QSpinBox( GroupC1, "SpinBox_NbSeg" );
+ GroupC1Layout->addWidget( SpinBox_NbSeg, 1, 1 );
+
+ StdMeshersGUI_NbSegmentsDlgLayout->addMultiCellWidget(GroupC1 , 1, 1, 0, 1 );
+
+ /***************************************************************/
+ GroupButtons = new QGroupBox( this, "GroupButtons" );
+ GroupButtons->setColumnLayout(0, Qt::Vertical );
+ GroupButtons->layout()->setSpacing( 0 );
+ GroupButtons->layout()->setMargin( 0 );
+ QGridLayout* GroupButtonsLayout = new QGridLayout( GroupButtons->layout() );
+ GroupButtonsLayout->setAlignment( Qt::AlignTop );
+ GroupButtonsLayout->setSpacing( 6 );
+ GroupButtonsLayout->setMargin( 11 );
+ buttonOk = new QPushButton( GroupButtons, "buttonOk" );
+ buttonOk->setText( tr( "SMESH_BUT_OK" ) );
+ buttonOk->setAutoDefault( TRUE );
+ buttonOk->setDefault( TRUE );
+ GroupButtonsLayout->addWidget( buttonOk, 0, 0 );
+ buttonApply = new QPushButton( GroupButtons, "buttonApply" );
+ buttonApply->setText( tr( "SMESH_BUT_APPLY" ) );
+ buttonApply->setAutoDefault( TRUE );
+ GroupButtonsLayout->addWidget( buttonApply, 0, 1 );
+ QSpacerItem* spacer = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
+ GroupButtonsLayout->addItem( spacer, 0, 2 );
+ buttonCancel = new QPushButton( GroupButtons, "buttonCancel" );
+ buttonCancel->setText( tr( "SMESH_BUT_CLOSE" ) );
+ buttonCancel->setAutoDefault( TRUE );
+ GroupButtonsLayout->addWidget( buttonCancel, 0, 3 );
+ StdMeshersGUI_NbSegmentsDlgLayout->addMultiCellWidget( GroupButtons, 2, 2, 0, 1 );
+
+ /***************************************************************/
+ Init() ;
+}
+
+
+//=================================================================================
+// function : ~StdMeshersGUI_NbSegmentsDlg()
+// purpose : Destroys the object and frees any allocated resources
+//=================================================================================
+StdMeshersGUI_NbSegmentsDlg::~StdMeshersGUI_NbSegmentsDlg()
+{
+ // no need to delete child widgets, Qt does it all for us
+}
+
+
+//=================================================================================
+// function : Init()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_NbSegmentsDlg::Init()
+{
+ SpinBox_NbSeg->setMinValue( 1 );
+ SpinBox_NbSeg->setMaxValue( 9999 );
+ SpinBox_NbSeg->setValue(3) ; /* myNbSeg */
+
+ mySMESHGUI = SMESHGUI::GetSMESHGUI() ;
+
+ char* sHypType = (char*)myHypType.latin1();
+ HypothesisData* aHypData = mySMESHGUI->GetHypothesisData(sHypType);
+ LineEdit_NameHypothesis->setText( aHypData ? aHypData->Label : "" );
+
+ mySMESHGUI->SetActiveDialogBox( (QDialog*)this ) ;
+
+ /* signals and slots connections */
+ connect( buttonOk, SIGNAL(clicked()), this, SLOT(ClickOnOk()) );
+ connect( buttonCancel, SIGNAL(clicked()), this, SLOT(ClickOnCancel()) ) ;
+ connect( buttonApply, SIGNAL(clicked()), this, SLOT(ClickOnApply()) );
+
+ connect( mySMESHGUI, SIGNAL ( SignalDeactivateActiveDialog() ), this, SLOT( DeactivateActiveDialog() ) ) ;
+ connect( mySMESHGUI, SIGNAL ( SignalCloseAllDialogs() ), this, SLOT( ClickOnCancel() ) ) ;
+
+ /* Move widget on the botton right corner of main widget */
+ int x, y ;
+ mySMESHGUI->DefineDlgPosition( this, x, y ) ;
+ this->move( x, y ) ;
+ this->show() ; /* displays Dialog */
+}
+
+
+//=================================================================================
+// function : ClickOnOk()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_NbSegmentsDlg::ClickOnOk()
+{
+ if ( this->ClickOnApply() )
+ this->ClickOnCancel() ;
+}
+
+//=================================================================================
+// function : ClickOnApply()
+// purpose :
+//=================================================================================
+bool StdMeshersGUI_NbSegmentsDlg::ClickOnApply()
+{
+ QString myHypName = LineEdit_NameHypothesis->text().stripWhiteSpace();
+ if ( myHypName.isEmpty() ) {
+ QAD_MessageBox::warn1( this, tr( "SMESH_WRN_WARNING" ), tr( "SMESH_WRN_EMPTY_NAME" ), tr( "SMESH_BUT_OK" ) );
+ return false;
+ }
+
+ long myNbSeg = SpinBox_NbSeg->value();
+
+ QAD_WaitCursor wc;
+ try {
+ SMESH::SMESH_Hypothesis_var Hyp = SMESH::SMESH_Hypothesis::_narrow
+ (mySMESHGUI->CreateHypothesis(myHypType,
+ myHypName,
+ false)); // isAlgorithm
+ StdMeshers::StdMeshers_NumberOfSegments_var NbS =
+ StdMeshers::StdMeshers_NumberOfSegments::_narrow(Hyp);
+ if (!NbS->_is_nil())
+ NbS->SetNumberOfSegments(myNbSeg);
+ }
+ catch (const SALOME::SALOME_Exception& S_ex) {
+ wc.stop();
+ QtCatchCorbaException(S_ex);
+ return false;
+ }
+ return true;
+}
+
+
+//=================================================================================
+// function : ClickOnCancel()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_NbSegmentsDlg::ClickOnCancel()
+{
+ close();
+}
+
+//=================================================================================
+// function : DeactivateActiveDialog()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_NbSegmentsDlg::DeactivateActiveDialog()
+{
+ iconLabel->setEnabled(false) ;
+ typeLabel->setEnabled(false) ;
+ GroupC1->setEnabled(false) ;
+ GroupButtons->setEnabled(false) ;
+}
+
+
+//=================================================================================
+// function : ActivateThisDialog()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_NbSegmentsDlg::ActivateThisDialog()
+{
+ mySMESHGUI->EmitSignalDeactivateDialog() ;
+ iconLabel->setEnabled(true) ;
+ typeLabel->setEnabled(true) ;
+ GroupC1->setEnabled(true) ;
+ GroupButtons->setEnabled(true) ;
+}
+
+
+//=================================================================================
+// function : enterEvent()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_NbSegmentsDlg::enterEvent(QEvent* e)
+{
+ ActivateThisDialog() ;
+}
+
+
+//=================================================================================
+// function : closeEvent()
+// purpose :
+//=================================================================================
+void StdMeshersGUI_NbSegmentsDlg::closeEvent( QCloseEvent* e )
+{
+ mySMESHGUI->ResetState();
+ QDialog::closeEvent( e );
+}
--- /dev/null
+// SMESH SMESHGUI : GUI for SMESH component
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshersGUI_NbSegmentsDlg.h
+// Moved here from SMESHGUI_NbSegmentsDlg.h
+// Author : Nicolas REJNERI
+// Module : SMESH
+// $Header$
+
+#ifndef DIALOGBOX_NB_SEGMENTS_H
+#define DIALOGBOX_NB_SEGMENTS_H
+
+// QT Includes
+#include <qdialog.h>
+
+class QGroupBox;
+class QLabel;
+class QLineEdit;
+class QSpinBox;
+class QPushButton;
+class SMESHGUI;
+
+//=================================================================================
+// class : StdMeshersGUI_NbSegmentsDlg
+// purpose :
+//=================================================================================
+class StdMeshersGUI_NbSegmentsDlg : public QDialog
+{
+ Q_OBJECT
+
+public:
+ StdMeshersGUI_NbSegmentsDlg (const QString& hypType,
+ QWidget* parent = 0,
+ const char* name = 0,
+ bool modal = FALSE,
+ WFlags fl = 0);
+ ~StdMeshersGUI_NbSegmentsDlg ();
+
+private:
+
+ void Init() ;
+ void closeEvent( QCloseEvent* e ) ;
+ void enterEvent ( QEvent * ) ;
+
+ SMESHGUI* mySMESHGUI ;
+ QString myHypType ;
+
+ QLabel* iconLabel;
+ QLabel* typeLabel;
+ QGroupBox* GroupC1;
+ QLabel* TextLabel_NameHypothesis ;
+ QLineEdit* LineEdit_NameHypothesis ;
+ QLabel* TextLabel_NbSeg ;
+ QSpinBox* SpinBox_NbSeg ;
+ QGroupBox* GroupButtons;
+ QPushButton* buttonApply;
+ QPushButton* buttonOk;
+ QPushButton* buttonCancel;
+
+private slots:
+
+ void ClickOnOk();
+ void ClickOnCancel();
+ bool ClickOnApply();
+ void DeactivateActiveDialog() ;
+ void ActivateThisDialog() ;
+};
+
+#endif // DIALOGBOX_NB_SEGMENTS_H
--- /dev/null
+# This is a Qt message file in .po format. Each msgid starts with
+# a scope. This scope should *NOT* be translated - eg. "Foo::Bar"
+# would be translated to "Pub", not "Foo::Pub".
+msgid ""
+msgstr ""
+"Project-Id-Version: PROJECT VERSION\n"
+"POT-Creation-Date: 2002-05-28 10:57:43 AM CEST\n"
+"PO-Revision-Date: YYYY-MM-DD\n"
+"Last-Translator: FULLNAME <EMAIL@ADDRESS>\n"
+"Content-Type: text/plain; charset=iso-8859-1\n"
+
+
+#Select Icon
+msgid "ICON_SELECT"
+msgstr "select1.png"
+
+
+#-----------------------------------------------------------
+# Hypothesis
+#-----------------------------------------------------------
+
+#Hypo Local Length
+msgid "ICON_DLG_LOCAL_LENGTH"
+msgstr "mesh_hypo_length.png"
+
+#Hypo Nb Segments
+msgid "ICON_DLG_NB_SEGMENTS"
+msgstr "mesh_hypo_segment.png"
+
+#Hypo Max Area
+msgid "ICON_DLG_MAX_ELEMENT_AREA"
+msgstr "mesh_hypo_area.png"
+
+#Hypo Max Volume
+msgid "ICON_DLG_MAX_ELEMENT_VOLUME"
+msgstr "mesh_hypo_volume.png"
+
+
+#-----------------------------------------------------------
+# ObjectBrowser
+#-----------------------------------------------------------
+
+#mesh_tree_algo_regular
+msgid "ICON_SMESH_TREE_ALGO_Regular_1D"
+msgstr "mesh_tree_algo_regular.png"
+
+#mesh_tree_algo_hexa
+msgid "ICON_SMESH_TREE_ALGO_Hexa_3D"
+msgstr "mesh_tree_algo_hexa.png"
+
+#mesh_tree_algo_mefisto
+msgid "ICON_SMESH_TREE_ALGO_MEFISTO_2D"
+msgstr "mesh_tree_algo_mefisto.png"
+
+#mesh_tree_algo_quad
+msgid "ICON_SMESH_TREE_ALGO_Quadrangle_2D"
+msgstr "mesh_tree_algo_quad.png"
+
+#mesh_tree_hypo_area
+msgid "ICON_SMESH_TREE_HYPO_MaxElementArea"
+msgstr "mesh_tree_hypo_area.png"
+
+#mesh_tree_hypo_length
+msgid "ICON_SMESH_TREE_HYPO_LocalLength"
+msgstr "mesh_tree_hypo_length.png"
+
+#mesh_tree_hypo_segment
+msgid "ICON_SMESH_TREE_HYPO_NumberOfSegments"
+msgstr "mesh_tree_hypo_segment.png"
+
+#mesh_tree_hypo_volume
+msgid "ICON_SMESH_TREE_HYPO_MaxElementVolume"
+msgstr "mesh_tree_hypo_volume.png"
+
+#mesh_tree_hypo_length
+msgid "ICON_SMESH_TREE_HYPO_LengthFromEdges"
+msgstr "mesh_tree_hypo_length.png"
+
+#mesh_tree_hypo_nonconform
+msgid "ICON_SMESH_TREE_HYPO_NotConformAllowed"
+msgstr "mesh_tree_hypo_length.png"
--- /dev/null
+# This is a Qt message file in .po format. Each msgid starts with
+# a scope. This scope should *NOT* be translated - eg. "Foo::Bar"
+# would be translated to "Pub", not "Foo::Pub".
+msgid ""
+msgstr ""
+"Project-Id-Version: PROJECT VERSION\n"
+"POT-Creation-Date: 2002-05-28 10:46:48 AM CEST\n"
+"PO-Revision-Date: YYYY-MM-DD\n"
+"Last-Translator: FULLNAME <EMAIL@ADDRESS>\n"
+"Content-Type: text/plain; charset=iso-8859-1\n"
+
+
+# -------------- Local Length --------------
+
+msgid "SMESH_LOCAL_LENGTH_HYPOTHESIS"
+msgstr "Local Length"
+
+msgid "SMESH_LOCAL_LENGTH_TITLE"
+msgstr "Hypothesis Construction"
+
+# ----------- Number of Segments -----------
+
+msgid "SMESH_NB_SEGMENTS_HYPOTHESIS"
+msgstr "Number of Segments"
+
+msgid "SMESH_NB_SEGMENTS_TITLE"
+msgstr "Hypothesis Construction"
+
+# ----------- Max. Element Area ------------
+
+msgid "SMESH_MAX_ELEMENT_AREA"
+msgstr "Max. Area"
+
+msgid "SMESH_MAX_ELEMENT_AREA_HYPOTHESIS"
+msgstr "Max. Element Area"
+
+msgid "SMESH_MAX_ELEMENT_AREA_TITLE"
+msgstr "Hypothesis Construction"
+
+# ---------- Max. Element Volume -----------
+
+msgid "SMESH_MAX_ELEMENT_VOLUME"
+msgstr "Max. Volume"
+
+msgid "SMESH_MAX_ELEMENT_VOLUME_HYPOTHESIS"
+msgstr "Max. Element Volume"
+
+msgid "SMESH_MAX_ELEMENT_VOLUME_TITLE"
+msgstr "Hypothesis Construction"
--- /dev/null
+# SMESH StdMeshers_I : idl implementation based on 'StdMeshersPlugin' unit's classes
+#
+# Copyright (C) 2003 CEA
+#
+# 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.org
+#
+#
+#
+# File : Makefile.in
+# Author : Julia DOROVSKIKH
+# Module : SMESH
+# $Header$
+
+top_srcdir=@top_srcdir@
+top_builddir=../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl:$(top_builddir)/idl
+
+
+@COMMENCE@
+
+# EXPORT_PYSCRIPTS = smeshpy.py SMESH_test.py
+
+# Libraries targets
+
+LIB= libStdMeshersEngine.la
+
+LIB_SRC = \
+ StdMeshers_i.cxx \
+ StdMeshers_LocalLength_i.cxx \
+ StdMeshers_LengthFromEdges_i.cxx \
+ StdMeshers_MaxElementArea_i.cxx \
+ StdMeshers_MaxElementVolume_i.cxx \
+ StdMeshers_NumberOfSegments_i.cxx \
+ StdMeshers_NotConformAllowed_i.cxx \
+ StdMeshers_Regular_1D_i.cxx \
+ StdMeshers_Quadrangle_2D_i.cxx \
+ StdMeshers_MEFISTO_2D_i.cxx \
+ StdMeshers_Hexa_3D_i.cxx
+
+LIB_SERVER_IDL = SMESH_BasicHypothesis.idl
+
+LIB_CLIENT_IDL = \
+ SALOMEDS.idl SALOME_Exception.idl \
+ GEOM_Gen.idl GEOM_Shape.idl MED.idl SALOMEDS_Attributes.idl \
+ SMESH_Gen.idl SMESH_Hypothesis.idl SMESH_Group.idl
+
+# Executables targets
+BIN =
+BIN_SRC =
+
+# additionnal information to compil and link file
+CPPFLAGS+= $(OCC_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome \
+ -I${GEOM_ROOT_DIR}/include/salome $(BOOST_CPPFLAGS)
+CXXFLAGS+= $(OCC_CXXFLAGS) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome
+
+#IDLCXXFLAGS+= -Wbtp
+
+#LDFLAGS+= $(HDF5_LIBS) -lStdMeshers -lSMESHEngine -lSalomeLifeCycleCORBA -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome -lSalomeGenericObj
+LDFLAGS+= $(HDF5_LIBS) -lStdMeshers -lSMESHEngine -L${KERNEL_ROOT_DIR}/lib/salome
+
+@CONCLUDE@
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_Hexa_3D_i.cxx
+// Moved here from SMESH_Hexa_3D_i.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_Hexa_3D_i.hxx"
+#include "SMESH_Gen.hxx"
+
+#include "Utils_CorbaException.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ * StdMeshers_Hexa_3D_i::StdMeshers_Hexa_3D_i
+ *
+ * Constructor
+ */
+//=============================================================================
+
+StdMeshers_Hexa_3D_i::StdMeshers_Hexa_3D_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl )
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA ),
+ SMESH_Algo_i( thePOA ),
+ SMESH_3D_Algo_i( thePOA )
+{
+ MESSAGE( "StdMeshers_Hexa_3D_i::StdMeshers_Hexa_3D_i" );
+ myBaseImpl = new ::StdMeshers_Hexa_3D( theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_Hexa_3D_i::~StdMeshers_Hexa_3D_i
+ *
+ * Destructor
+ */
+//=============================================================================
+
+StdMeshers_Hexa_3D_i::~StdMeshers_Hexa_3D_i()
+{
+ MESSAGE( "StdMeshers_Hexa_3D_i::~StdMeshers_Hexa_3D_i" );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_Hexa_3D_i::GetImpl
+ *
+ * Get implementation
+ */
+//=============================================================================
+
+::StdMeshers_Hexa_3D* StdMeshers_Hexa_3D_i::GetImpl()
+{
+ MESSAGE( "StdMeshers_Hexa_3D_i::GetImpl" );
+ return ( ::StdMeshers_Hexa_3D* )myBaseImpl;
+}
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_Hexa_3D_i.hxx
+// Moved here from SMESH_Hexa_3D_i.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_HEXA_3D_I_HXX_
+#define _SMESH_HEXA_3D_I_HXX_
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "SMESH_3D_Algo_i.hxx"
+#include "StdMeshers_Hexa_3D.hxx"
+
+class SMESH_Gen;
+
+// ======================================================
+// Hexaedron 3d algorithm
+// ======================================================
+class StdMeshers_Hexa_3D_i:
+ public virtual POA_StdMeshers::StdMeshers_Hexa_3D,
+ public virtual SMESH_3D_Algo_i
+{
+public:
+ // Constructor
+ StdMeshers_Hexa_3D_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl );
+
+ // Destructor
+ virtual ~StdMeshers_Hexa_3D_i();
+
+ // Get implementation
+ ::StdMeshers_Hexa_3D* GetImpl();
+};
+
+#endif
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_LengthFromEdges_i.cxx
+// Moved here from SMESH_LengthFromEdges_i.cxx
+// Author : Nadir BOUHAMOU CEA/DEN, Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_LengthFromEdges_i.hxx"
+#include "SMESH_Gen.hxx"
+
+#include "Utils_CorbaException.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ * StdMeshers_LengthFromEdges_i::StdMeshers_LengthFromEdges_i
+ *
+ * Constructor
+ */
+//=============================================================================
+
+StdMeshers_LengthFromEdges_i::StdMeshers_LengthFromEdges_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl )
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA )
+{
+ MESSAGE( "StdMeshers_LengthFromEdges_i::StdMeshers_LengthFromEdges_i" );
+ myBaseImpl = new ::StdMeshers_LengthFromEdges( theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_LengthFromEdges_i::~StdMeshers_LengthFromEdges_i
+ *
+ * Destructor
+ */
+//=============================================================================
+
+StdMeshers_LengthFromEdges_i::~StdMeshers_LengthFromEdges_i()
+{
+ MESSAGE( "StdMeshers_LengthFromEdges_i::~StdMeshers_LengthFromEdges_i" );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_LengthFromEdges_i::SetMode
+ *
+ * Set mode
+ */
+//=============================================================================
+
+void StdMeshers_LengthFromEdges_i::SetMode( CORBA::Long theMode )
+ throw (SALOME::SALOME_Exception)
+{
+ MESSAGE( "StdMeshers_LengthFromEdges_i::SetMode" );
+ ASSERT( myBaseImpl );
+ try {
+ this->GetImpl()->SetMode( theMode );
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_LengthFromEdges_i::GetMode
+ *
+ * Get mode
+ */
+//=============================================================================
+
+CORBA::Long StdMeshers_LengthFromEdges_i::GetMode()
+{
+ MESSAGE( "StdMeshers_LengthFromEdges_i::GetMode" );
+ ASSERT( myBaseImpl );
+ return this->GetImpl()->GetMode();
+}
+
+
+//=============================================================================
+/*!
+ * StdMeshers_LengthFromEdges_i::GetImpl
+ *
+ * Get implementation
+ */
+//=============================================================================
+
+::StdMeshers_LengthFromEdges* StdMeshers_LengthFromEdges_i::GetImpl()
+{
+ MESSAGE( "StdMeshers_LengthFromEdges_i::GetImpl" );
+ return ( ::StdMeshers_LengthFromEdges* )myBaseImpl;
+}
+
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_LengthFromEdges_i.hxx
+// Moved here from SMESH_LengthFromEdges_i.hxx
+// Author : Nadir BOUHAMOU CEA/DEN, Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_LENGTHFROMEDGES_I_HXX_
+#define _SMESH_LENGTHFROMEDGES_I_HXX_
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "SMESH_Hypothesis_i.hxx"
+#include "StdMeshers_LengthFromEdges.hxx"
+
+// ======================================================
+// Length from edges hypothesis
+// ======================================================
+class StdMeshers_LengthFromEdges_i:
+ public virtual POA_StdMeshers::StdMeshers_LengthFromEdges,
+ public virtual SMESH_Hypothesis_i
+{
+public:
+ // Constructor
+ StdMeshers_LengthFromEdges_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl );
+ // Destructor
+ virtual ~StdMeshers_LengthFromEdges_i();
+
+ // Set mode
+ void SetMode( CORBA::Long theMode )
+ throw ( SALOME::SALOME_Exception );
+ // Get mode
+ CORBA::Long GetMode();
+
+ // Get implementation
+ ::StdMeshers_LengthFromEdges* GetImpl();
+};
+
+#endif
+
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_LocalLength_i.cxx
+// Moved here from SMESH_LocalLength_i.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_LocalLength_i.hxx"
+#include "SMESH_Gen.hxx"
+
+#include "Utils_CorbaException.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ * StdMeshers_LocalLength_i::StdMeshers_LocalLength_i
+ *
+ * Constructor
+ */
+//=============================================================================
+
+StdMeshers_LocalLength_i::StdMeshers_LocalLength_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl )
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA )
+{
+ MESSAGE( "StdMeshers_LocalLength_i::StdMeshers_LocalLength_i" );
+ myBaseImpl = new ::StdMeshers_LocalLength( theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_LocalLength_i::~StdMeshers_LocalLength_i
+ *
+ * Destructor
+ */
+//=============================================================================
+
+StdMeshers_LocalLength_i::~StdMeshers_LocalLength_i()
+{
+ MESSAGE( "StdMeshers_LocalLength_i::~StdMeshers_LocalLength_i" );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_LocalLength_i::SetLength
+ *
+ * Set length
+ */
+//=============================================================================
+
+void StdMeshers_LocalLength_i::SetLength( CORBA::Double theLength )
+ throw ( SALOME::SALOME_Exception )
+{
+ MESSAGE( "StdMeshers_LocalLength_i::SetLength" );
+ ASSERT( myBaseImpl );
+ try {
+ this->GetImpl()->SetLength( theLength );
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_LocalLength_i::GetLength
+ *
+ * Get length
+ */
+//=============================================================================
+
+CORBA::Double StdMeshers_LocalLength_i::GetLength()
+{
+ MESSAGE( "StdMeshers_LocalLength_i::GetLength" );
+ ASSERT( myBaseImpl );
+ return this->GetImpl()->GetLength();
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_LocalLength_i::GetImpl
+ *
+ * Get implementation
+ */
+//=============================================================================
+
+::StdMeshers_LocalLength* StdMeshers_LocalLength_i::GetImpl()
+{
+ MESSAGE( "StdMeshers_LocalLength_i::GetImpl" );
+ return ( ::StdMeshers_LocalLength* )myBaseImpl;
+}
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_LocalLength_i.hxx
+// Moved here from SMESH_LocalLength_i.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_LOCALLENGTH_I_HXX_
+#define _SMESH_LOCALLENGTH_I_HXX_
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "SMESH_Hypothesis_i.hxx"
+#include "StdMeshers_LocalLength.hxx"
+
+class SMESH_Gen;
+
+// ======================================================
+// Local Length hypothesis
+// ======================================================
+class StdMeshers_LocalLength_i:
+ public virtual POA_StdMeshers::StdMeshers_LocalLength,
+ public virtual SMESH_Hypothesis_i
+{
+public:
+ // Constructor
+ StdMeshers_LocalLength_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl );
+ // Destructor
+ virtual ~StdMeshers_LocalLength_i();
+
+ // Set length
+ void SetLength( CORBA::Double theLength )
+ throw ( SALOME::SALOME_Exception );
+ // Get length
+ CORBA::Double GetLength();
+
+ // Get implementation
+ ::StdMeshers_LocalLength* GetImpl();
+};
+
+#endif
+
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_MEFISTO_2D_i.cxx
+// Moved here from SMESH_MEFISTO_2D_i.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_MEFISTO_2D_i.hxx"
+#include "SMESH_Gen.hxx"
+
+#include "Utils_CorbaException.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ * StdMeshers_MEFISTO_2D_i::StdMeshers_MEFISTO_2D_i
+ *
+ * Constructor
+ */
+//=============================================================================
+
+StdMeshers_MEFISTO_2D_i::StdMeshers_MEFISTO_2D_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl )
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA ),
+ SMESH_Algo_i( thePOA ),
+ SMESH_2D_Algo_i( thePOA )
+{
+ MESSAGE( "StdMeshers_MEFISTO_2D_i::StdMeshers_MEFISTO_2D_i" );
+ myBaseImpl = new ::StdMeshers_MEFISTO_2D( theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_MEFISTO_2D_i::~StdMeshers_MEFISTO_2D_i
+ *
+ * Destructor
+ */
+//=============================================================================
+
+StdMeshers_MEFISTO_2D_i::~StdMeshers_MEFISTO_2D_i()
+{
+ MESSAGE( "StdMeshers_MEFISTO_2D_i::~StdMeshers_MEFISTO_2D_i" );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_MEFISTO_2D_i::GetImpl
+ *
+ * Get implementation
+ */
+//=============================================================================
+
+::StdMeshers_MEFISTO_2D* StdMeshers_MEFISTO_2D_i::GetImpl()
+{
+ MESSAGE( "StdMeshers_MEFISTO_2D_i::GetImpl" );
+ return ( ::StdMeshers_MEFISTO_2D* )myBaseImpl;
+}
+
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_MEFISTO_2D_i.hxx
+// Moved here from SMESH_MEFISTO_2D_i.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _StdMeshers_MEFISTO_2D_I_HXX_
+#define _StdMeshers_MEFISTO_2D_I_HXX_
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "SMESH_2D_Algo_i.hxx"
+#include "StdMeshers_MEFISTO_2D.hxx"
+
+class SMESH_Gen;
+
+// ======================================================
+// Triangle (MEFISTO) 2d algorithm
+// ======================================================
+class StdMeshers_MEFISTO_2D_i:
+ public virtual POA_StdMeshers::StdMeshers_MEFISTO_2D,
+ public virtual SMESH_2D_Algo_i
+{
+public:
+ // Constructor
+ StdMeshers_MEFISTO_2D_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl );
+
+ // Destructor
+ virtual ~StdMeshers_MEFISTO_2D_i();
+
+ // Get implementation
+ ::StdMeshers_MEFISTO_2D* GetImpl();
+};
+
+#endif
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_MaxElementArea_i.cxx
+// Moved here from SMESH_MaxElementArea_i.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_MaxElementArea_i.hxx"
+#include "SMESH_Gen.hxx"
+
+#include "Utils_CorbaException.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ * StdMeshers_MaxElementArea_i::StdMeshers_MaxElementArea_i
+ *
+ * Constructor
+ */
+//=============================================================================
+
+StdMeshers_MaxElementArea_i::StdMeshers_MaxElementArea_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl )
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA )
+{
+ MESSAGE( "StdMeshers_MaxElementArea_i::StdMeshers_MaxElementArea_i" );
+ myBaseImpl = new ::StdMeshers_MaxElementArea( theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_MaxElementArea_i::~StdMeshers_MaxElementArea_i
+ *
+ * Destructor
+ */
+//=============================================================================
+
+StdMeshers_MaxElementArea_i::~StdMeshers_MaxElementArea_i()
+{
+ MESSAGE( "StdMeshers_MaxElementArea_i::~StdMeshers_MaxElementArea_i" );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_MaxElementArea_i::SetMaxElementArea
+ *
+ * Set maximum element area
+ */
+//=============================================================================
+
+void StdMeshers_MaxElementArea_i::SetMaxElementArea( CORBA::Double theArea )
+ throw ( SALOME::SALOME_Exception )
+{
+ MESSAGE( "StdMeshers_MaxElementArea_i::SetMaxElementArea" );
+ ASSERT( myBaseImpl );
+ try {
+ this->GetImpl()->SetMaxArea( theArea );
+ }
+ catch (SALOME_Exception& S_ex) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_MaxElementArea_i::GetMaxElementArea
+ *
+ * Get maximum element area
+ */
+//=============================================================================
+
+CORBA::Double StdMeshers_MaxElementArea_i::GetMaxElementArea()
+{
+ MESSAGE( "StdMeshers_MaxElementArea_i::GetMaxElementArea" );
+ ASSERT( myBaseImpl );
+ return this->GetImpl()->GetMaxArea();
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_MaxElementArea_i::GetImpl
+ *
+ * Get implementation
+ */
+//=============================================================================
+
+::StdMeshers_MaxElementArea* StdMeshers_MaxElementArea_i::GetImpl()
+{
+ MESSAGE( "StdMeshers_MaxElementArea_i::GetImpl" );
+ return ( ::StdMeshers_MaxElementArea* )myBaseImpl;
+}
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_MaxElementArea_i.hxx
+// Moved here from SMESH_MaxElementArea_i.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_MAXELEMENTAREA_I_HXX_
+#define _SMESH_MAXELEMENTAREA_I_HXX_
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "SMESH_Hypothesis_i.hxx"
+#include "StdMeshers_MaxElementArea.hxx"
+
+// ======================================================
+// Maximum Element Area hypothesis
+// ======================================================
+class StdMeshers_MaxElementArea_i:
+ public virtual POA_StdMeshers::StdMeshers_MaxElementArea,
+ public virtual SMESH_Hypothesis_i
+{
+public:
+ // Constructor
+ StdMeshers_MaxElementArea_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl );
+ // Destructor
+ virtual ~StdMeshers_MaxElementArea_i();
+
+ // Set maximum element area
+ void SetMaxElementArea( CORBA::Double theArea )
+ throw ( SALOME::SALOME_Exception );
+ // Get maximum element area
+ CORBA::Double GetMaxElementArea();
+
+ // Get implementation
+ ::StdMeshers_MaxElementArea* GetImpl();
+};
+
+#endif
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_MaxElementVolume_i.cxx
+// Moved here from SMESH_MaxElementVolume_i.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_MaxElementVolume_i.hxx"
+#include "SMESH_Gen.hxx"
+
+#include "Utils_CorbaException.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ * StdMeshers_MaxElementVolume_i::StdMeshers_MaxElementVolume_i
+ *
+ * Constructor
+ */
+//=============================================================================
+
+StdMeshers_MaxElementVolume_i::StdMeshers_MaxElementVolume_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl )
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA )
+{
+ MESSAGE( "StdMeshers_MaxElementVolume_i::StdMeshers_MaxElementVolume_i" );
+ myBaseImpl = new ::StdMeshers_MaxElementVolume( theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_MaxElementVolume_i::~StdMeshers_MaxElementVolume_i
+ *
+ * Destructor
+ */
+//=============================================================================
+
+StdMeshers_MaxElementVolume_i::~StdMeshers_MaxElementVolume_i()
+{
+ MESSAGE( "StdMeshers_MaxElementVolume_i::~StdMeshers_MaxElementVolume_i()" );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_MaxElementVolume_i::SetMaxElementVolume
+ *
+ * Set maximum element volume
+ */
+//=============================================================================
+
+void StdMeshers_MaxElementVolume_i::SetMaxElementVolume( CORBA::Double theVolume )
+ throw ( SALOME::SALOME_Exception )
+{
+ MESSAGE( "StdMeshers_MaxElementVolume_i::SetMaxElementVolume" );
+ ASSERT( myBaseImpl );
+ try {
+ this->GetImpl()->SetMaxVolume( theVolume );
+ }
+ catch (SALOME_Exception& S_ex) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_MaxElementVolume_i::GetMaxElementVolume
+ *
+ * Get maximum element volume
+ */
+//=============================================================================
+
+CORBA::Double StdMeshers_MaxElementVolume_i::GetMaxElementVolume()
+{
+ MESSAGE( "StdMeshers_MaxElementVolume_i::GetMaxElementVolume" );
+ ASSERT( myBaseImpl );
+ return this->GetImpl()->GetMaxVolume();
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_MaxElementVolume_i::GetImpl
+ *
+ * Get implementation
+ */
+//=============================================================================
+
+::StdMeshers_MaxElementVolume* StdMeshers_MaxElementVolume_i::GetImpl()
+{
+ MESSAGE( "StdMeshers_MaxElementVolume_i::GetImpl" );
+ return ( ::StdMeshers_MaxElementVolume* )myBaseImpl;
+}
+
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_MaxElementVolume_i.hxx
+// Moved here from SMESH_MaxElementVolume_i.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_MAXELEMENTVOLUME_I_HXX_
+#define _SMESH_MAXELEMENTVOLUME_I_HXX_
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "SMESH_Hypothesis_i.hxx"
+#include "StdMeshers_MaxElementVolume.hxx"
+
+// ======================================================
+// Maximum Element Volume hypothesis
+// ======================================================
+class StdMeshers_MaxElementVolume_i:
+ public virtual POA_StdMeshers::StdMeshers_MaxElementVolume,
+ public virtual SMESH_Hypothesis_i
+{
+public:
+ // Constructor
+ StdMeshers_MaxElementVolume_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl );
+ // Destructor
+ virtual ~StdMeshers_MaxElementVolume_i();
+
+ // Set maximum element volume
+ void SetMaxElementVolume( CORBA::Double theVolume )
+ throw (SALOME::SALOME_Exception);
+ // Get maximum element volume
+ CORBA::Double GetMaxElementVolume();
+
+ // Get implementation
+ ::StdMeshers_MaxElementVolume* GetImpl();
+};
+
+#endif
--- /dev/null
+// SMESH StdMeshers_I : idl implementation based on 'SMESH' unit's classes
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_NotConformAllowed_i.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+using namespace std;
+#include "StdMeshers_NotConformAllowed_i.hxx"
+#include "SMESH_Gen.hxx"
+
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ * Constructor:
+ * _name is related to the class name: prefix = SMESH_ ; suffix = _i .
+ */
+//=============================================================================
+
+StdMeshers_NotConformAllowed_i::StdMeshers_NotConformAllowed_i
+ (PortableServer::POA_ptr thePOA,
+ int studyId,
+ ::SMESH_Gen* genImpl)
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA )
+{
+ MESSAGE("StdMeshers_NotConformAllowed_i::StdMeshers_NotConformAllowed_i");
+ myBaseImpl = new ::StdMeshers_NotConformAllowed(genImpl->GetANewId(),
+ studyId,
+ genImpl);
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+StdMeshers_NotConformAllowed_i::~StdMeshers_NotConformAllowed_i()
+{
+}
--- /dev/null
+// SMESH StdMeshers_I : idl implementation based on 'SMESH' unit's classes
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_NotConformAllowed_i.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _StdMeshers_NotConformAllowed_I_HXX_
+#define _StdMeshers_NotConformAllowed_I_HXX_
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "SMESH_Hypothesis_i.hxx"
+
+#include "StdMeshers_NotConformAllowed.hxx"
+
+class StdMeshers_NotConformAllowed_i:
+ public POA_StdMeshers::StdMeshers_NotConformAllowed,
+ public SMESH_Hypothesis_i
+{
+public:
+ StdMeshers_NotConformAllowed_i(PortableServer::POA_ptr thePOA,
+ int studyId,
+ ::SMESH_Gen* genImpl);
+ virtual ~StdMeshers_NotConformAllowed_i();
+
+protected:
+ ::StdMeshers_NotConformAllowed* _impl;
+};
+
+#endif
+
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_NumberOfSegments_i.cxx
+// Moved here from SMESH_NumberOfSegments_i.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_NumberOfSegments_i.hxx"
+#include "SMESH_Gen.hxx"
+
+#include "Utils_CorbaException.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ * StdMeshers_NumberOfSegments_i::StdMeshers_NumberOfSegments_i
+ *
+ * Constructor
+ */
+//=============================================================================
+
+StdMeshers_NumberOfSegments_i::StdMeshers_NumberOfSegments_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl )
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA )
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::StdMeshers_NumberOfSegments_i" );
+ myBaseImpl = new ::StdMeshers_NumberOfSegments( theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_NumberOfSegments_i::~StdMeshers_NumberOfSegments_i
+ *
+ * Destructor
+ */
+//=============================================================================
+
+StdMeshers_NumberOfSegments_i::~StdMeshers_NumberOfSegments_i()
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::~StdMeshers_NumberOfSegments_i" );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_NumberOfSegments_i::SetNumberOfSegments
+ *
+ * Set number of segments
+ */
+//=============================================================================
+
+void StdMeshers_NumberOfSegments_i::SetNumberOfSegments( CORBA::Long theSegmentsNumber )
+ throw ( SALOME::SALOME_Exception )
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::SetNumberOfSegments" );
+ ASSERT( myBaseImpl );
+ try {
+ this->GetImpl()->SetNumberOfSegments( theSegmentsNumber );
+ }
+ catch (SALOME_Exception& S_ex) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_NumberOfSegments_i::GetNumberOfSegments
+ *
+ * Get number of segments
+ */
+//=============================================================================
+
+CORBA::Long StdMeshers_NumberOfSegments_i::GetNumberOfSegments()
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::GetNumberOfSegments" );
+ ASSERT( myBaseImpl );
+ return this->GetImpl()->GetNumberOfSegments();
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_NumberOfSegments_i::SetScaleFactor
+ *
+ * Set scalar factor
+ */
+//=============================================================================
+
+void StdMeshers_NumberOfSegments_i::SetScaleFactor( CORBA::Double theScaleFactor )
+ throw ( SALOME::SALOME_Exception )
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::SetScaleFactor" );
+ ASSERT( myBaseImpl );
+ try {
+ this->GetImpl()->SetScaleFactor( theScaleFactor );
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_NumberOfSegments_i::GetScaleFactor
+ *
+ * Get scalar factor
+ */
+//=============================================================================
+
+CORBA::Double StdMeshers_NumberOfSegments_i::GetScaleFactor()
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::GetScaleFactor" );
+ ASSERT( myBaseImpl );
+ return this->GetImpl()->GetScaleFactor();
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_NumberOfSegments_i::GetImpl
+ *
+ * Get implementation
+ */
+//=============================================================================
+
+::StdMeshers_NumberOfSegments* StdMeshers_NumberOfSegments_i::GetImpl()
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::GetImpl" );
+ return ( ::StdMeshers_NumberOfSegments* )myBaseImpl;
+}
+
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_NumberOfSegments_i.hxx
+// Moved here from SMESH_NumberOfSegments_i.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_NUMBEROFSEGMENTS_I_HXX_
+#define _SMESH_NUMBEROFSEGMENTS_I_HXX_
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "SMESH_Hypothesis_i.hxx"
+#include "StdMeshers_NumberOfSegments.hxx"
+
+// ======================================================
+// Number of segments hypothesis
+// ======================================================
+class StdMeshers_NumberOfSegments_i:
+ public virtual POA_StdMeshers::StdMeshers_NumberOfSegments,
+ public virtual SMESH_Hypothesis_i
+{
+public:
+ // Constructor
+ StdMeshers_NumberOfSegments_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl );
+ // Destructor
+ virtual ~StdMeshers_NumberOfSegments_i();
+
+ // Set number of segments
+ void SetNumberOfSegments( CORBA::Long theSegmentsNumber )
+ throw ( SALOME::SALOME_Exception );
+ // Get number of segments
+ CORBA::Long GetNumberOfSegments();
+
+ // Set scalar factor
+ void SetScaleFactor( CORBA::Double theScaleFactor )
+ throw ( SALOME::SALOME_Exception );
+ // Get scalar factor
+ CORBA::Double GetScaleFactor();
+
+ // Get implementation
+ ::StdMeshers_NumberOfSegments* GetImpl();
+};
+
+#endif
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_Quadrangle_2D_i.cxx
+// Moved here from SMESH_Quadrangle_2D_i.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_Quadrangle_2D_i.hxx"
+#include "SMESH_Gen.hxx"
+
+#include "Utils_CorbaException.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ * StdMeshers_Quadrangle_2D_i::StdMeshers_Quadrangle_2D_i
+ *
+ * Constructor
+ */
+//=============================================================================
+
+StdMeshers_Quadrangle_2D_i::StdMeshers_Quadrangle_2D_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl )
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA ),
+ SMESH_Algo_i( thePOA ),
+ SMESH_2D_Algo_i( thePOA )
+{
+ MESSAGE( "StdMeshers_Quadrangle_2D_i::StdMeshers_Quadrangle_2D_i" );
+ myBaseImpl = new ::StdMeshers_Quadrangle_2D( theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_Quadrangle_2D_i::~StdMeshers_Quadrangle_2D_i
+ *
+ * Destructor
+ *
+ */
+//=============================================================================
+
+StdMeshers_Quadrangle_2D_i::~StdMeshers_Quadrangle_2D_i()
+{
+ MESSAGE( "StdMeshers_Quadrangle_2D_i::~StdMeshers_Quadrangle_2D_i" );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_Quadrangle_2D_i::GetImpl
+ *
+ * Get implementation
+ */
+//=============================================================================
+
+::StdMeshers_Quadrangle_2D* StdMeshers_Quadrangle_2D_i::GetImpl()
+{
+ MESSAGE( "StdMeshers_Quadrangle_2D_i::GetImpl" );
+ return ( ::StdMeshers_Quadrangle_2D* )myBaseImpl;
+}
+
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_Quadrangle_2D_i.hxx
+// Moved here from SMESH_Quadrangle_2D_i.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_QUADRANGLE_2D_I_HXX_
+#define _SMESH_QUADRANGLE_2D_I_HXX_
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "SMESH_2D_Algo_i.hxx"
+#include "StdMeshers_Quadrangle_2D.hxx"
+
+class SMESH_Gen;
+
+// ======================================================
+// Quadrangle (Mapping) 2d algorithm
+// ======================================================
+class StdMeshers_Quadrangle_2D_i:
+ public virtual POA_StdMeshers::StdMeshers_Quadrangle_2D,
+ public virtual SMESH_2D_Algo_i
+{
+public:
+ // Constructor
+ StdMeshers_Quadrangle_2D_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl );
+
+ // Destructor
+ virtual ~StdMeshers_Quadrangle_2D_i();
+
+ // Get implementation
+ ::StdMeshers_Quadrangle_2D* GetImpl();
+};
+
+#endif
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_Regular_1D_i.cxx
+// Moved here from SMESH_Regular_1D_i.cxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "StdMeshers_Regular_1D_i.hxx"
+#include "SMESH_Gen.hxx"
+
+#include "Utils_CorbaException.hxx"
+#include "utilities.h"
+
+//=============================================================================
+/*!
+ * StdMeshers_Regular_1D_i::StdMeshers_Regular_1D_i
+ *
+ * Constructor
+ */
+//=============================================================================
+
+StdMeshers_Regular_1D_i::StdMeshers_Regular_1D_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl )
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA ),
+ SMESH_Algo_i( thePOA ),
+ SMESH_1D_Algo_i( thePOA )
+{
+ MESSAGE( "StdMeshers_Regular_1D_i::StdMeshers_Regular_1D_i" );
+ myBaseImpl = new ::StdMeshers_Regular_1D( theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_Regular_1D_i::~StdMeshers_Regular_1D_i
+ *
+ * Destructor
+ */
+//=============================================================================
+
+StdMeshers_Regular_1D_i::~StdMeshers_Regular_1D_i()
+{
+ MESSAGE( "StdMeshers_Regular_1D_i::~StdMeshers_Regular_1D_i" );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_Regular_1D_i::GetImpl
+ *
+ * Get implementation
+ */
+//=============================================================================
+
+::StdMeshers_Regular_1D* StdMeshers_Regular_1D_i::GetImpl()
+{
+ MESSAGE( "StdMeshers_Regular_1D_i::GetImpl" );
+ return ( ::StdMeshers_Regular_1D* )myBaseImpl;
+}
+
--- /dev/null
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+//
+// Copyright (C) 2003 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.
+//
+// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : StdMeshers_Regular_1D_i.hxx
+// Moved here from SMESH_Regular_1D_i.hxx
+// Author : Paul RASCLE, EDF
+// Module : SMESH
+// $Header$
+
+#ifndef _SMESH_REGULAR_1D_I_HXX_
+#define _SMESH_REGULAR_1D_I_HXX_
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
+
+#include "SMESH_1D_Algo_i.hxx"
+#include "StdMeshers_Regular_1D.hxx"
+
+// ======================================================
+// Wire Discretization 1d algorithm
+// ======================================================
+class StdMeshers_Regular_1D_i:
+ public virtual POA_StdMeshers::StdMeshers_Regular_1D,
+ public virtual SMESH_1D_Algo_i
+{
+public:
+ // Constructor
+ StdMeshers_Regular_1D_i( PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl );
+ // Destructor
+ virtual ~StdMeshers_Regular_1D_i();
+
+ // Get implementation
+ ::StdMeshers_Regular_1D* GetImpl();
+};
+
+#endif
--- /dev/null
+// SMESH StdMeshers : implementaion of SMESH idl descriptions
+//
+// Copyright (C) 2003 CEA
+//
+// 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.org
+//
+//
+//
+// File : StdMeshers_i.cxx
+// Author : Julia DOROVSKIKH
+// Module : SMESH
+// $Header$
+
+using namespace std;
+#include "SMESH_Gen_i.hxx"
+
+#include "utilities.h"
+
+#include "StdMeshers_LocalLength_i.hxx"
+#include "StdMeshers_LengthFromEdges_i.hxx"
+#include "StdMeshers_NotConformAllowed_i.hxx"
+#include "StdMeshers_NumberOfSegments_i.hxx"
+#include "StdMeshers_MaxElementArea_i.hxx"
+#include "StdMeshers_MaxElementVolume_i.hxx"
+
+#include "StdMeshers_Regular_1D_i.hxx"
+#include "StdMeshers_MEFISTO_2D_i.hxx"
+#include "StdMeshers_Quadrangle_2D_i.hxx"
+#include "StdMeshers_Hexa_3D_i.hxx"
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+extern "C"
+{
+ GenericHypothesisCreator_i* GetHypothesisCreator (const char* aHypName)
+ {
+ MESSAGE("Get HypothesisCreator for " << aHypName);
+
+ GenericHypothesisCreator_i* aCreator = 0;
+
+ // Hypotheses
+ if (strcmp(aHypName, "LocalLength") == 0)
+ aCreator = new HypothesisCreator_i<StdMeshers_LocalLength_i>;
+ else if (strcmp(aHypName, "NumberOfSegments") == 0)
+ aCreator = new HypothesisCreator_i<StdMeshers_NumberOfSegments_i>;
+ else if (strcmp(aHypName, "LengthFromEdges") == 0)
+ aCreator = new HypothesisCreator_i<StdMeshers_LengthFromEdges_i>;
+ else if (strcmp(aHypName, "NotConformAllowed") == 0)
+ aCreator = new HypothesisCreator_i<StdMeshers_NotConformAllowed_i>;
+ else if (strcmp(aHypName, "MaxElementArea") == 0)
+ aCreator = new HypothesisCreator_i<StdMeshers_MaxElementArea_i>;
+ else if (strcmp(aHypName, "MaxElementVolume") == 0)
+ aCreator = new HypothesisCreator_i<StdMeshers_MaxElementVolume_i>;
+
+ // Algorithms
+ else if (strcmp(aHypName, "Regular_1D") == 0)
+ aCreator = new HypothesisCreator_i<StdMeshers_Regular_1D_i>;
+ else if (strcmp(aHypName, "MEFISTO_2D") == 0)
+ aCreator = new HypothesisCreator_i<StdMeshers_MEFISTO_2D_i>;
+ else if (strcmp(aHypName, "Quadrangle_2D") == 0)
+ aCreator = new HypothesisCreator_i<StdMeshers_Quadrangle_2D_i>;
+ else if (strcmp(aHypName, "Hexa_3D") == 0)
+ aCreator = new HypothesisCreator_i<StdMeshers_Hexa_3D_i>;
+ else ;
+
+ return aCreator;
+ }
+}
