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

Merge 'master' branch into 'V9_dev' branch.

Browse Source
This commit is contained in:
rnv 2018-01-17 16:20:50 +03:00
commit 7a3ecab720
212 changed files with 1169 additions and 2371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1811
ChangeLog
View File

File diff suppressed because it is too large Load Diff

2
doc/salome/examples/creating_meshes_ex03.py
View File

@ -42,7 +42,7 @@ Nb_Segments_4 = Regular_1D_3.NumberOfSegments(12)
MEFISTO_2D_3 = Mesh_1.Triangle(algo=smeshBuilder.MEFISTO,geom=Face_3)
SubMesh_3 = MEFISTO_2D_3.GetSubMesh()
# check exisiting sub-mesh priority order
# check existing sub-mesh priority order
[ [ SubMesh_1, SubMesh_3, SubMesh_2 ] ] = Mesh_1.GetMeshOrder()
isDone = Mesh_1.Compute()
print("Nb elements at initial order of sub-meshes:", Mesh_1.NbElements())

2
doc/salome/examples/filters_ex01.py
View File

@ -15,7 +15,7 @@ ids = filter.GetIDs()
print("Number of faces with aspect ratio > 1.5:", len(ids))
# copy the faces with aspect ratio > 1.5 to another mesh;
# this demostrates that a filter can be used where usually a group or sub-mesh is acceptable
# this demonstrates that a filter can be used where usually a group or sub-mesh is acceptable
filter.SetMesh( mesh.GetMesh() ) # - actually non necessary as mesh is set at filter creation
mesh2 = smesh.CopyMesh( filter, "AR > 1.5" )
print("Number of copied faces with aspect ratio > 1.5:", mesh2.NbFaces())

BIN
doc/salome/gui/SMESH/images/duplicate01.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 23 KiB

After

Width:  |  Height:  |  Size: 22 KiB

BIN
doc/salome/gui/SMESH/images/duplicate02.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 28 KiB

After

Width:  |  Height:  |  Size: 27 KiB

BIN
doc/salome/gui/SMESH/images/duplicate03.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 20 KiB

After

Width:  |  Height:  |  Size: 18 KiB

BIN
doc/salome/gui/SMESH/images/duplicate04.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 22 KiB

After

Width:  |  Height:  |  Size: 19 KiB

8
doc/salome/gui/SMESH/input/double_nodes_page.doc
View File

@ -42,7 +42,10 @@ Parameters to be defined in this mode:
<li><b>Group of nodes to duplicate</b> (<em>mandatory</em>): these
nodes will be duplicated.</li>
<li><b>Group of elements to replace nodes with new ones</b>
(<em>optional</em>): the new nodes will replace the duplicated nodes within these elements.</li>
(<em>optional</em>): the new nodes will replace the duplicated nodes
within these elements. \b Generate button automatically creates
these groups.
</li>
<li><b>Construct group with newly created nodes</b> option
(<em>checked by default</em>): if checked - the group with newly
created nodes will be built.</li>
@ -73,7 +76,8 @@ Parameters to be defined in this mode:
group of nodes at crack bottom which will not be duplicated.</li>
<li><b>Group of elements to replace nodes with new ones</b>
(<em>mandatory</em>): the new nodes will replace the nodes to
duplicate within these elements.</li>
duplicate within these elements. \b Generate button automatically
creates these groups.</li>
<li><b>Construct group with newly created elements</b> option
(<em>checked by default</em>): if checked - the group of newly created
elements will be built.</li>

2
doc/salome/gui/SMESH/input/smesh_migration.doc
View File

@ -1,6 +1,6 @@
/*!
\page smesh_migration_page Modifing Mesh Python scripts from SALOME 6 and before
\page smesh_migration_page Modifying Mesh Python scripts from SALOME 6 and before
\n In SALOME 7.2, the Python interface for %Mesh has been slightly modified to offer new functionality:

2
doc/salome/gui/SMESH/input/tui_filters.doc
View File

@ -190,7 +190,7 @@ filters over-constrained faces:
\section filter_double_elements Double edges, Double faces, Double volumes
filters mesh elements basing on the same set of nodes:
- element type is either \a SMESH.EGDE, \a SMESH.FACE or \a SMESH.VOLUME
- element type is either \a SMESH.EDGE, \a SMESH.FACE or \a SMESH.VOLUME
- functor type is either \a SMESH.FT_EqualEdges, \a
SMESH.FT_EqualFaces or \a SMESH.FT_EqualVolumes,
- threshold value is not required

2
idl/SMESH_BasicHypothesis.idl
View File

@ -128,7 +128,7 @@ module StdMeshers
};
/*!
* Common inteface of 1D hypotheses that can be reversed
* Common interface of 1D hypotheses that can be reversed
*/
interface Reversible1D
{

4
idl/SMESH_Gen.idl
View File

@ -76,7 +76,7 @@ module SMESH
const long Tag_LastGroup = 16;
/*!
* Hypothesis definintion error
* Hypothesis definition error
*/
struct AlgoStateError
{
@ -348,7 +348,7 @@ module SMESH
raises ( SALOME::SALOME_Exception );
/*!
* Return errors of hypotheses definintion
* Return errors of hypotheses definition
* algo_error_array is empty if everything is OK
*/
algo_error_array GetAlgoState( in SMESH_Mesh theMesh,

8
idl/SMESH_Measurements.idl
View File

@ -31,7 +31,6 @@
module SMESH
{
/*
* Measure component
*/
@ -70,7 +69,12 @@ module SMESH
* sum of volume of 3D elements of the source
*/
double Volume(in SMESH_IDSource source);
/*!
* gravity center of the source
*/
PointStruct GravityCenter(in SMESH_IDSource source);
};
};
};
#endif

6
idl/SMESH_MeshEditor.idl
View File

@ -318,7 +318,7 @@ module SMESH
* \param IDsOfElements Ids of triangles to be fused.
* \param theCriterion Is used to choose a neighbour to fuse with.
* \param theMaxAngle Is a max angle between element normals at which fusion
* is still performed; theMaxAngle is mesured in radians.
* is still performed; theMaxAngle is measured in radians.
* \return \c true in case of success, FALSE otherwise.
*/
boolean TriToQuad (in long_array IDsOfElements,
@ -356,7 +356,7 @@ module SMESH
/*!
* \brief Split quadrangles into triangles.
* \param theElems The faces to be splitted.
* \param theElems The faces to be split.
* \param the13Diag Is used to choose a diagonal for splitting.
* \return TRUE in case of success, FALSE otherwise.
*/
@ -372,7 +372,7 @@ module SMESH
/*!
* Find better splitting of the given quadrangle.
* \param IDOfQuad ID of the quadrangle to be splitted.
* \param IDOfQuad ID of the quadrangle to be split.
* \param Criterion A criterion to choose a diagonal for splitting.
* \return 1 if 1-3 diagonal is better, 2 if 2-4
* diagonal is better, 0 if error occurs.

4
src/Controls/SMESH_Controls.cxx
View File

@ -1279,7 +1279,7 @@ double AspectRatio3D::GetValue( const TSequenceOfXYZ& P )
} // switch(nbNodes)
if ( nbNodes > 4 ) {
// avaluate aspect ratio of quadranle faces
// evaluate aspect ratio of quadrangle faces
AspectRatio aspect2D;
SMDS_VolumeTool::VolumeType type = SMDS_VolumeTool::GetType( nbNodes );
int nbFaces = SMDS_VolumeTool::NbFaces( type );
@ -1288,7 +1288,7 @@ double AspectRatio3D::GetValue( const TSequenceOfXYZ& P )
if ( SMDS_VolumeTool::NbFaceNodes( type, i ) != 4 )
continue;
const int* pInd = SMDS_VolumeTool::GetFaceNodesIndices( type, i, true );
for ( int p = 0; p < 4; ++p ) // loop on nodes of a quadranle face
for ( int p = 0; p < 4; ++p ) // loop on nodes of a quadrangle face
points( p + 1 ) = P( pInd[ p ] + 1 );
aQuality = std::max( aQuality, aspect2D.GetValue( points ));
}

2
src/Driver/Driver_Mesh.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH Driver : implementaion of driver for reading and writing
// SMESH Driver : implementation of driver for reading and writing
// File : Mesh_Reader.cxx
// Module : SMESH
//

2
src/Driver/Driver_Mesh.h
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH Driver : implementaion of driver for reading and writing
// SMESH Driver : implementation of driver for reading and writing
// File : Mesh_Reader.h
// Module : SMESH
//

2
src/DriverGMF/libmesh5.c
View File

@ -247,7 +247,7 @@ int GmfOpenMesh(const char *FilNam, int mod, ...)
return(0);
}
/* Open the file in the required mod and initialyse the mesh structure */
/* Open the file in the required mod and initialise the mesh structure */
if(msh->mod == GmfRead)
{

2
src/DriverMED/DriverMED.hxx
View File

@ -32,7 +32,7 @@ typedef boost::shared_ptr<DriverMED_Family> DriverMED_FamilyPtr;
namespace DriverMED
{
// Implemetation is in DriverMED_W_Field.cxx
// Implementation is in DriverMED_W_Field.cxx
/*
* Returns MED element geom type (MED::EGeometrieElement) by SMDS type

2
src/DriverMED/DriverMED_W_Field.cxx
View File

@ -358,7 +358,7 @@ Driver_Mesh::Status DriverMED_W_Field::Perform()
return DRS_OK;
}
namespace DriverMED // Implemetation of fuctions declared in DriverMED.hxx
namespace DriverMED // Implementation of functions declared in DriverMED.hxx
{
//================================================================================
/*!

2
src/OBJECT/SMESH_ExtractGeometry.cxx
View File

@ -80,7 +80,7 @@ int SMESH_ExtractGeometry::RequestData(vtkInformation *vtkNotUsed(request),
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
// get the input and ouptut
// get the input and output
vtkDataSet *input =
vtkDataSet::SafeDownCast(inInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkUnstructuredGrid *output =

2
src/OBJECT/SMESH_FaceOrientationFilter.cxx
View File

@ -242,7 +242,7 @@ int SMESH_FaceOrientationFilter::RequestData(
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
// get the input and ouptut
// get the input and output
vtkDataSet *input = vtkDataSet::SafeDownCast(
inInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkPolyData *output = vtkPolyData::SafeDownCast(

3
src/OBJECT/SMESH_ScalarBarActor.cxx
View File

@ -557,7 +557,8 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
}
//polygons & cell colors
unsigned char *rgba, *rgb;
unsigned char *rgb;
const unsigned char *rgba;
vtkIdType ptIds[4], dcCount=0;
for ( i = 0; i < numColors; i++ )
{

2
src/SMDS/SMDSAbs_ElementType.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDSAbs_ElementType.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_BallElement.cxx
View File

@ -17,7 +17,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// Module : SMESH
// File : SMDS_BallElement.cxx
// Author : Edward AGAPOV (eap)

2
src/SMDS/SMDS_BallElement.hxx
View File

@ -17,7 +17,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_BallElement.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_EdgePosition.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_EdgePosition.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH

2
src/SMDS/SMDS_EdgePosition.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_EdgePosition.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_ElemIterator.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshElement.hxx
// Module : SMESH
// Created: 12.01.05 18:02:52

2
src/SMDS/SMDS_FaceOfEdges.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)

2
src/SMDS/SMDS_FaceOfNodes.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)

2
src/SMDS/SMDS_FaceOfNodes.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
//
#ifndef _SMDS_FaceOfNodes_HeaderFile
#define _SMDS_FaceOfNodes_HeaderFile

2
src/SMDS/SMDS_FacePosition.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_FacePosition.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH

2
src/SMDS/SMDS_FacePosition.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_FacePosition.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_Iterator.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
//
#ifndef _SMDS_Iterator_HeaderFile
#define _SMDS_Iterator_HeaderFile

2
src/SMDS/SMDS_IteratorOfElements.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)

2
src/SMDS/SMDS_IteratorOfElements.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
//
#include "SMESH_SMDS.hxx"

4
src/SMDS/SMDS_IteratorOnIterators.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_IteratorOnIterators.hxx
// Author : Edward AGAPOV (eap)
//
@ -32,7 +32,7 @@
///////////////////////////////////////////////////////////////////////////////
/// SMDS_Iterator iterating over all elements provided by other iterators
///
/// Other iterators must implement SMDS_Iterator iterface and
/// Other iterators must implement SMDS_Iterator interface and
/// must be provided within a stl-like container
/// BE CAREFUL: iterator pointed value is static_cast'ed to VALUE
///////////////////////////////////////////////////////////////////////////////

2
src/SMDS/SMDS_Mesh.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_Mesh.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_Mesh0DElement.cxx
View File

@ -17,7 +17,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_Mesh0DElement.cxx
// Module : SMESH
//

2
src/SMDS/SMDS_Mesh0DElement.hxx
View File

@ -17,7 +17,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_Mesh0DElement.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_MeshEdge.hxx
View File

@ -17,7 +17,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshEdge.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_MeshElement.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)

2
src/SMDS/SMDS_MeshElement.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshElement.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_MeshElementIDFactory.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshElementIDFactory.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH

2
src/SMDS/SMDS_MeshElementIDFactory.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshElementIDFactory.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_MeshFace.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
//
#include "SMDS_MeshFace.hxx"

2
src/SMDS/SMDS_MeshFace.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshFace.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_MeshGroup.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshGroup.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH

2
src/SMDS/SMDS_MeshGroup.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshGroup.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_MeshIDFactory.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshIDFactory.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH

2
src/SMDS/SMDS_MeshIDFactory.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshIDFactory.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_MeshNode.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)

2
src/SMDS/SMDS_MeshNode.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshNode.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_MeshObject.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshObject.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH

2
src/SMDS/SMDS_MeshObject.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshObject.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_MeshVolume.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshVolume.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH

2
src/SMDS/SMDS_MeshVolume.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshVolume.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_PolygonalFaceOfNodes.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)

2
src/SMDS/SMDS_PolygonalFaceOfNodes.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
//
#ifndef _SMDS_PolygonalFaceOfNodes_HeaderFile
#define _SMDS_PolygonalFaceOfNodes_HeaderFile

2
src/SMDS/SMDS_PolyhedralVolumeOfNodes.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)

2
src/SMDS/SMDS_PolyhedralVolumeOfNodes.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_PolyhedralVolumeOfNodes.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_Position.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_Position.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH

2
src/SMDS/SMDS_Position.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_Position.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_QuadraticEdge.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File: SMDS_QuadraticEdge.cxx
// Created: 16.01.06 16:25:42
// Author: Sergey KUUL

2
src/SMDS/SMDS_QuadraticEdge.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_QuadraticEdge.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_QuadraticFaceOfNodes.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File: SMDS_QuadraticFaceOfNodes.cxx
// Created: 16.01.06 17:12:58
// Author: Sergey KUUL

2
src/SMDS/SMDS_QuadraticFaceOfNodes.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_QuadraticVolumeOfNodes.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_QuadraticVolumeOfNodes.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File: SMDS_QuadraticVolumeOfNodes.cxx
// Created: 17.01.06 09:46:11
// Author: Sergey KUUL

2
src/SMDS/SMDS_QuadraticVolumeOfNodes.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_QuadraticVolumeOfNodes.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_SetIterator.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_SetIterator.hxx
// Created : Feb 27 2006
// Author : Edward AGAPOV (eap)

2
src/SMDS/SMDS_SpacePosition.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_SpacePosition.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH

2
src/SMDS/SMDS_SpacePosition.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_SpacePosition.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_StdIterator.hxx
View File

@ -17,7 +17,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_StdIterator.hxx
// Created : Fri Feb 5 11:03:46 2010
// Author : Edward AGAPOV (eap)

2
src/SMDS/SMDS_TypeOfPosition.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_TypeOfPosition.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_VertexPosition.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_VertexPosition.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH

2
src/SMDS/SMDS_VertexPosition.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_VertexPosition.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_VolumeOfFaces.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_VolumeOfFaces.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH

2
src/SMDS/SMDS_VolumeOfFaces.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_VolumeOfFaces.hxx
// Module : SMESH
//

2
src/SMDS/SMDS_VolumeOfNodes.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)

2
src/SMDS/SMDS_VolumeOfNodes.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshVolume.hxx
// Module : SMESH
//

4
src/SMDS/SMDS_VolumeTool.cxx
View File

@ -1683,7 +1683,7 @@ double SMDS_VolumeTool::MaxLinearSize2() const
//================================================================================
/*!
* \brief fast check that only one volume is build on the face nodes
* \brief Fast quickly check that only one volume is built on the face nodes
* This check is valid for conformal meshes only
*/
//================================================================================
@ -1731,7 +1731,7 @@ bool SMDS_VolumeTool::IsFreeFace( int faceIndex, const SMDS_MeshElement** otherV
//================================================================================
/*!
* \brief Thorough check that only one volume is build on the face nodes
* \brief Thorough check that only one volume is built on the face nodes
*/
//================================================================================

2
src/SMDS/SMDS_VolumeTool.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_VolumeTool.hxx
// Module : SMESH
// Created : Tue Jul 13 11:27:17 2004

2
src/SMDS/SMDS_VtkEdge.hxx
View File

@ -17,7 +17,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMDS : implementaion of Salome mesh data structure
// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_VtkEdge.hxx
// Module : SMESH

2
src/SMESH/SMESH_Algo.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Algo.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH

4
src/SMESH/SMESH_Algo.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Algo.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
@ -69,7 +69,7 @@ typedef std::map< SMESH_subMesh*, std::vector<int> >::iterator MapShapeNbElemsIt
* Methods of the class are grouped into several parts:
* - main lifecycle methods, like Compute()
* - methods describing features of the algorithm, like NeedShape()
* - methods related to dependencies between sub-meshes imposed by the algorith
* - methods related to dependencies between sub-meshes imposed by the algorithm
* - static utilities, like EdgeLength()
*/
// ==================================================================================

2
src/SMESH/SMESH_Gen.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Gen.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH

2
src/SMESH/SMESH_Gen.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Gen.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH

2
src/SMESH/SMESH_Group.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Group.cxx
// Author : Michael Sazonov (OCC)
// Module : SMESH

2
src/SMESH/SMESH_Group.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Group.hxx
// Author : Michael Sazonov (OCC)
// Module : SMESH

2
src/SMESH/SMESH_HypoFilter.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_HypoFilter.cxx
// Module : SMESH
//

2
src/SMESH/SMESH_HypoFilter.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_HypoFilter.hxx
// Module : SMESH
//

2
src/SMESH/SMESH_Hypothesis.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Hypothesis.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH

2
src/SMESH/SMESH_Hypothesis.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Hypothesis.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH

4
src/SMESH/SMESH_Mesh.cxx
View File

@ -694,7 +694,7 @@ SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
}
}
// check concurent hypotheses on ancestors
// check concurrent hypotheses on ancestors
if (ret < SMESH_Hypothesis::HYP_CONCURENT && !isGlobalHyp )
{
SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false);
@ -764,7 +764,7 @@ SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
if (ret2 > ret) // more severe
ret = ret2;
// check concurent hypotheses on ancestors
// check concurrent hypotheses on ancestors
if (ret < SMESH_Hypothesis::HYP_CONCURENT && !IsMainShape( aSubShape ) )
{
SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false);

769
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -93,6 +93,7 @@
#include <sstream>
#include <boost/tuple/tuple.hpp>
#include <boost/container/flat_set.hpp>
#include <Standard_Failure.hxx>
#include <Standard_ErrorHandler.hxx>
@ -1279,7 +1280,7 @@ int SMESH_MeshEditor::Reorient2D (TIDSortedElemSet & theFaces,
}
if ( otherFace && otherFace != theFace)
{
// link must be reverse in otherFace if orientation ot otherFace
// link must be reverse in otherFace if orientation to otherFace
// is same as that of theFace
if ( abs(nodeInd2-nodeInd1) == 1 ? nodeInd2 > nodeInd1 : nodeInd1 > nodeInd2 )
{
@ -1501,7 +1502,7 @@ bool SMESH_MeshEditor::QuadToTri (TIDSortedElemSet & theElems,
//=======================================================================
/*!
* \brief Split each of given quadrangles into 4 triangles.
* \param theElems - The faces to be splitted. If empty all faces are split.
* \param theElems - The faces to be split. If empty all faces are split.
*/
//=======================================================================
@ -4570,11 +4571,7 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement* elem,
std::swap( itNN[0], itNN[1] );
std::swap( prevNod[0], prevNod[1] );
std::swap( nextNod[0], nextNod[1] );
#if defined(__APPLE__)
std::swap( isSingleNode[0], isSingleNode[1] );
#else
isSingleNode.swap( isSingleNode[0], isSingleNode[1] );
#endif
if ( nbSame > 0 )
sames[0] = 1 - sames[0];
iNotSameNode = 1 - iNotSameNode;
@ -6145,7 +6142,7 @@ SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet theElements[2],
makeEdgePathPoints(aPrms, aTrackEdge,(aN1->GetID()==startNid), LPP);
LLPPs.push_back(LPP);
UsedNums.Add(k);
// update startN for search following egde
// update startN for search following edge
if( aN1->GetID() == startNid ) startNid = aN2->GetID();
else startNid = aN1->GetID();
break;
@ -6444,7 +6441,7 @@ SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet theElements[2],
makeEdgePathPoints(aPrms, aTrackEdge, aN1isOK, LPP);
LLPPs.push_back(LPP);
UsedNums.Add(k);
// update startN for search following egde
// update startN for search following edge
if ( aN1isOK ) aVprev = aV2;
else aVprev = aV1;
break;
@ -7982,33 +7979,29 @@ void SMESH_MeshEditor::FindEqualElements(TIDSortedElemSet & theElements,
typedef map< SortableElement, int > TMapOfNodeSet;
typedef list<int> TGroupOfElems;
if ( theElements.empty() )
{ // get all elements in the mesh
SMDS_ElemIteratorPtr eIt = GetMeshDS()->elementsIterator();
while ( eIt->more() )
theElements.insert( theElements.end(), eIt->next() );
}
SMDS_ElemIteratorPtr elemIt;
if ( theElements.empty() ) elemIt = GetMeshDS()->elementsIterator();
else elemIt = elemSetIterator( theElements );
vector< TGroupOfElems > arrayOfGroups;
TGroupOfElems groupOfElems;
TMapOfNodeSet mapOfNodeSet;
TIDSortedElemSet::iterator elemIt = theElements.begin();
for ( int i = 0; elemIt != theElements.end(); ++elemIt )
for ( int iGroup = 0; elemIt->more(); )
{
const SMDS_MeshElement* curElem = *elemIt;
const SMDS_MeshElement* curElem = elemIt->next();
SortableElement SE(curElem);
// check uniqueness
pair< TMapOfNodeSet::iterator, bool> pp = mapOfNodeSet.insert(make_pair(SE, i));
pair< TMapOfNodeSet::iterator, bool> pp = mapOfNodeSet.insert(make_pair(SE, iGroup));
if ( !pp.second ) { // one more coincident elem
TMapOfNodeSet::iterator& itSE = pp.first;
int ind = (*itSE).second;
arrayOfGroups[ind].push_back( curElem->GetID() );
int iG = itSE->second;
arrayOfGroups[ iG ].push_back( curElem->GetID() );
}
else {
arrayOfGroups.push_back( groupOfElems );
arrayOfGroups.back().push_back( curElem->GetID() );
i++;
iGroup++;
}
}
@ -10599,6 +10592,559 @@ SMESH_MeshEditor::FindMatchingNodes(set<const SMDS_MeshElement*>& theSide1,
return SEW_OK;
}
namespace // automatically find theAffectedElems for DoubleNodes()
{
bool isOut( const SMDS_MeshNode* n, const gp_XYZ& norm, const SMDS_MeshElement* elem );
//--------------------------------------------------------------------------------
// Nodes shared by adjacent FissureBorder's.
// 1 node if FissureBorder separates faces
// 2 nodes if FissureBorder separates volumes
struct SubBorder
{
const SMDS_MeshNode* _nodes[2];
int _nbNodes;
SubBorder( const SMDS_MeshNode* n1, const SMDS_MeshNode* n2 = 0 )
{
_nodes[0] = n1;
_nodes[1] = n2;
_nbNodes = bool( n1 ) + bool( n2 );
if ( _nbNodes == 2 && n1 > n2 )
std::swap( _nodes[0], _nodes[1] );
}
bool operator<( const SubBorder& other ) const
{
for ( int i = 0; i < _nbNodes; ++i )
{
if ( _nodes[i] < other._nodes[i] ) return true;
if ( _nodes[i] > other._nodes[i] ) return false;
}
return false;
}
};
//--------------------------------------------------------------------------------
// Map a SubBorder to all FissureBorder it bounds
struct FissureBorder;
typedef std::map< SubBorder, std::vector< FissureBorder* > > TBorderLinks;
typedef TBorderLinks::iterator TMappedSub;
//--------------------------------------------------------------------------------
/*!
* \brief Element border (volume facet or face edge) at a fissure
*/
struct FissureBorder
{
std::vector< const SMDS_MeshNode* > _nodes; // border nodes
const SMDS_MeshElement* _elems[2]; // volume or face adjacent to fissure
std::vector< TMappedSub > _mappedSubs; // Sub() in TBorderLinks map
std::vector< const SMDS_MeshNode* > _sortedNodes; // to compare FissureBorder's
FissureBorder( FissureBorder && from ) // move constructor
{
std::swap( _nodes, from._nodes );
std::swap( _sortedNodes, from._sortedNodes );
_elems[0] = from._elems[0];
_elems[1] = from._elems[1];
}
FissureBorder( const SMDS_MeshElement* elemToDuplicate,
std::vector< const SMDS_MeshElement* > & adjElems)
: _nodes( elemToDuplicate->NbCornerNodes() )
{
for ( size_t i = 0; i < _nodes.size(); ++i )
_nodes[i] = elemToDuplicate->GetNode( i );
SMDSAbs_ElementType type = SMDSAbs_ElementType( elemToDuplicate->GetType() + 1 );
findAdjacent( type, adjElems );
}
FissureBorder( const SMDS_MeshNode** nodes,
const size_t nbNodes,
const SMDSAbs_ElementType adjElemsType,
std::vector< const SMDS_MeshElement* > & adjElems)
: _nodes( nodes, nodes + nbNodes )
{
findAdjacent( adjElemsType, adjElems );
}
void findAdjacent( const SMDSAbs_ElementType adjElemsType,
std::vector< const SMDS_MeshElement* > & adjElems)
{
_elems[0] = _elems[1] = 0;
adjElems.clear();
if ( SMDS_Mesh::GetElementsByNodes( _nodes, adjElems, adjElemsType ))
for ( size_t i = 0; i < adjElems.size() && i < 2; ++i )
_elems[i] = adjElems[i];
}
bool operator<( const FissureBorder& other ) const
{
return GetSortedNodes() < other.GetSortedNodes();
}
const std::vector< const SMDS_MeshNode* >& GetSortedNodes() const
{
if ( _sortedNodes.empty() && !_nodes.empty() )
{
FissureBorder* me = const_cast<FissureBorder*>( this );
me->_sortedNodes = me->_nodes;
std::sort( me->_sortedNodes.begin(), me->_sortedNodes.end() );
}
return _sortedNodes;
}
size_t NbSub() const
{
return _nodes.size();
}
SubBorder Sub(size_t i) const
{
return SubBorder( _nodes[i], NbSub() > 2 ? _nodes[ (i+1)%NbSub() ] : 0 );
}
void AddSelfTo( TBorderLinks& borderLinks )
{
_mappedSubs.resize( NbSub() );
for ( size_t i = 0; i < NbSub(); ++i )
{
TBorderLinks::iterator s2b =
borderLinks.insert( std::make_pair( Sub(i), TBorderLinks::mapped_type() )).first;
s2b->second.push_back( this );
_mappedSubs[ i ] = s2b;
}
}
void Clear()
{
_nodes.clear();
}
const SMDS_MeshElement* GetMarkedElem() const
{
if ( _nodes.empty() ) return 0; // cleared
if ( _elems[0] && _elems[0]->isMarked() ) return _elems[0];
if ( _elems[1] && _elems[1]->isMarked() ) return _elems[1];
return 0;
}
gp_XYZ GetNorm() const // normal to the border
{
gp_XYZ norm;
if ( _nodes.size() == 2 )
{
gp_XYZ avgNorm( 0,0,0 ); // sum of normals of adjacent faces
if ( SMESH_MeshAlgos::FaceNormal( _elems[0], norm ))
avgNorm += norm;
if ( SMESH_MeshAlgos::FaceNormal( _elems[1], norm ))
avgNorm += norm;
gp_XYZ bordDir( SMESH_NodeXYZ( _nodes[0] ) - SMESH_NodeXYZ( _nodes[1] ));
norm = bordDir ^ avgNorm;
}
else
{
SMESH_NodeXYZ p0( _nodes[0] );
SMESH_NodeXYZ p1( _nodes[1] );
SMESH_NodeXYZ p2( _nodes[2] );
norm = ( p0 - p1 ) ^ ( p2 - p1 );
}
if ( isOut( _nodes[0], norm, GetMarkedElem() ))
norm.Reverse();
return norm;
}
void ChooseSide() // mark an _elem located at positive side of fissure
{
_elems[0]->setIsMarked( true );
gp_XYZ norm = GetNorm();
double maxX = norm.Coord(1);
if ( Abs( maxX ) < Abs( norm.Coord(2)) ) maxX = norm.Coord(2);
if ( Abs( maxX ) < Abs( norm.Coord(3)) ) maxX = norm.Coord(3);
if ( maxX < 0 )
{
_elems[0]->setIsMarked( false );
_elems[1]->setIsMarked( true );
}
}
}; // struct FissureBorder
//--------------------------------------------------------------------------------
/*!
* \brief Classifier of elements at fissure edge
*/
class FissureNormal
{
std::vector< gp_XYZ > _normals;
bool _bothIn;
public:
void Add( const SMDS_MeshNode* n, const FissureBorder& bord )
{
_bothIn = false;
_normals.reserve(2);
_normals.push_back( bord.GetNorm() );
if ( _normals.size() == 2 )
_bothIn = !isOut( n, _normals[0], bord.GetMarkedElem() );
}
bool IsIn( const SMDS_MeshNode* n, const SMDS_MeshElement* elem ) const
{
bool isIn = false;
switch ( _normals.size() ) {
case 1:
{
isIn = !isOut( n, _normals[0], elem );
break;
}
case 2:
{
bool in1 = !isOut( n, _normals[0], elem );
bool in2 = !isOut( n, _normals[1], elem );
isIn = _bothIn ? ( in1 && in2 ) : ( in1 || in2 );
}
}
return isIn;
}
};
//================================================================================
/*!
* \brief Classify an element by a plane passing through a node
*/
//================================================================================
bool isOut( const SMDS_MeshNode* n, const gp_XYZ& norm, const SMDS_MeshElement* elem )
{
SMESH_NodeXYZ p = n;
double sumDot = 0;
for ( int i = 0, nb = elem->NbCornerNodes(); i < nb; ++i )
{
SMESH_NodeXYZ pi = elem->GetNode( i );
sumDot += norm * ( pi - p );
}
return sumDot < -1e-100;
}
//================================================================================
/*!
* \brief Find FissureBorder's by nodes to duplicate
*/
//================================================================================
void findFissureBorders( const TIDSortedElemSet& theNodes,
std::vector< FissureBorder > & theFissureBorders )
{
TIDSortedElemSet::const_iterator nIt = theNodes.begin();
const SMDS_MeshNode* n = dynamic_cast< const SMDS_MeshNode*>( *nIt );
if ( !n ) return;
SMDSAbs_ElementType elemType = SMDSAbs_Volume;
if ( n->NbInverseElements( elemType ) == 0 )
{
elemType = SMDSAbs_Face;
if ( n->NbInverseElements( elemType ) == 0 )
return;
}
// unmark elements touching the fissure
for ( ; nIt != theNodes.end(); ++nIt )
SMESH_MeshAlgos::MarkElems( cast2Node(*nIt)->GetInverseElementIterator(), false );
// loop on elements touching the fissure to get their borders belonging to the fissure
std::set< FissureBorder > fissureBorders;
std::vector< const SMDS_MeshElement* > adjElems;
std::vector< const SMDS_MeshNode* > nodes;
SMDS_VolumeTool volTool;
for ( nIt = theNodes.begin(); nIt != theNodes.end(); ++nIt )
{
SMDS_ElemIteratorPtr invIt = cast2Node(*nIt)->GetInverseElementIterator( elemType );
while ( invIt->more() )
{
const SMDS_MeshElement* eInv = invIt->next();
if ( eInv->isMarked() ) continue;
eInv->setIsMarked( true );
if ( elemType == SMDSAbs_Volume )
{
volTool.Set( eInv );
int iQuad = eInv->IsQuadratic() ? 2 : 1;
for ( int iF = 0, nbF = volTool.NbFaces(); iF < nbF; ++iF )
{
const SMDS_MeshNode** nn = volTool.GetFaceNodes( iF );
int nbN = volTool.NbFaceNodes( iF ) / iQuad;
nodes.clear();
bool allOnFissure = true;
for ( int iN = 0; iN < nbN && allOnFissure; iN += iQuad )
if (( allOnFissure = theNodes.count( nn[ iN ])))
nodes.push_back( nn[ iN ]);
if ( allOnFissure )
fissureBorders.insert( std::move( FissureBorder( &nodes[0], nodes.size(),
elemType, adjElems )));
}
}
else // elemType == SMDSAbs_Face
{
const SMDS_MeshNode* nn[2] = { eInv->GetNode( eInv->NbCornerNodes()-1 ), 0 };
bool onFissure0 = theNodes.count( nn[0] ), onFissure1;
for ( int iN = 0, nbN = eInv->NbCornerNodes(); iN < nbN; ++iN )
{
nn[1] = eInv->GetNode( iN );
onFissure1 = theNodes.count( nn[1] );
if ( onFissure0 && onFissure1 )
fissureBorders.insert( std::move( FissureBorder( nn, 2, elemType, adjElems )));
nn[0] = nn[1];
onFissure0 = onFissure1;
}
}
}
}
theFissureBorders.reserve( theFissureBorders.size() + fissureBorders.size());
std::set< FissureBorder >::iterator bord = fissureBorders.begin();
for ( ; bord != fissureBorders.end(); ++bord )
{
theFissureBorders.push_back( std::move( const_cast<FissureBorder&>( *bord ) ));
}
return;
} // findFissureBorders()
//================================================================================
/*!
* \brief Find elements on one side of a fissure defined by elements or nodes to duplicate
* \param [in] theElemsOrNodes - elements or nodes to duplicate
* \param [in] theNodesNot - nodes not to duplicate
* \param [out] theAffectedElems - the found elements
*/
//================================================================================
void findAffectedElems( const TIDSortedElemSet& theElemsOrNodes,
TIDSortedElemSet& theAffectedElems)
{
if ( theElemsOrNodes.empty() ) return;
// find FissureBorder's
std::vector< FissureBorder > fissure;
std::vector< const SMDS_MeshElement* > elemsByFacet;
TIDSortedElemSet::const_iterator elIt = theElemsOrNodes.begin();
if ( (*elIt)->GetType() == SMDSAbs_Node )
{
findFissureBorders( theElemsOrNodes, fissure );
}
else
{
fissure.reserve( theElemsOrNodes.size() );
for ( ; elIt != theElemsOrNodes.end(); ++elIt )
fissure.push_back( std::move( FissureBorder( *elIt, elemsByFacet )));
}
if ( fissure.empty() )
return;
// fill borderLinks
TBorderLinks borderLinks;
for ( size_t i = 0; i < fissure.size(); ++i )
{
fissure[i].AddSelfTo( borderLinks );
}
// get theAffectedElems
// unmark elements having nodes on the fissure, theAffectedElems elements will be marked
for ( size_t i = 0; i < fissure.size(); ++i )
for ( size_t j = 0; j < fissure[i]._nodes.size(); ++j )
{
SMESH_MeshAlgos::MarkElemNodes( fissure[i]._nodes[j]->GetInverseElementIterator(),
false, /*markElem=*/true );
}
std::vector<const SMDS_MeshNode *> facetNodes;
std::map< const SMDS_MeshNode*, FissureNormal > fissEdgeNodes2Norm;
boost::container::flat_set< const SMDS_MeshNode* > fissureNodes;
// choose a side of fissure
fissure[0].ChooseSide();
theAffectedElems.insert( fissure[0].GetMarkedElem() );
size_t nbCheckedBorders = 0;
while ( nbCheckedBorders < fissure.size() )
{
// find a FissureBorder to treat
FissureBorder* bord = 0;
for ( size_t i = 0; i < fissure.size() && !bord; ++i )
if ( fissure[i].GetMarkedElem() )
bord = & fissure[i];
for ( size_t i = 0; i < fissure.size() && !bord; ++i )
if ( fissure[i].NbSub() > 0 && fissure[i]._elems[0] )
{
bord = & fissure[i];
bord->ChooseSide();
theAffectedElems.insert( bord->GetMarkedElem() );
}
if ( !bord ) return;
++nbCheckedBorders;
// treat FissureBorder's linked to bord
fissureNodes.clear();
fissureNodes.insert( bord->_nodes.begin(), bord->_nodes.end() );
for ( size_t i = 0; i < bord->NbSub(); ++i )
{
TBorderLinks::iterator l2b = bord->_mappedSubs[ i ];
if ( l2b == borderLinks.end() || l2b->second.empty() ) continue;
std::vector< FissureBorder* >& linkedBorders = l2b->second;
const SubBorder& sb = l2b->first;
const SMDS_MeshElement* bordElem = bord->GetMarkedElem();
if ( linkedBorders.size() == 1 ) // fissure edge reached, fill fissEdgeNodes2Norm
{
for ( int j = 0; j < sb._nbNodes; ++j )
fissEdgeNodes2Norm[ sb._nodes[j] ].Add( sb._nodes[j], *bord );
continue;
}
// add to theAffectedElems elems sharing nodes of a SubBorder and a node of bordElem
// until an elem adjacent to a neighbour FissureBorder is found
facetNodes.clear();
facetNodes.insert( facetNodes.end(), sb._nodes, sb._nodes + sb._nbNodes );
facetNodes.resize( sb._nbNodes + 1 );
while ( bordElem )
{
// check if bordElem is adjacent to a neighbour FissureBorder
for ( size_t j = 0; j < linkedBorders.size(); ++j )
{
FissureBorder* bord2 = linkedBorders[j];
if ( bord2 == bord ) continue;
if ( bordElem == bord2->_elems[0] || bordElem == bord2->_elems[1] )
bordElem = 0;
else
fissureNodes.insert( bord2->_nodes.begin(), bord2->_nodes.end() );
}
if ( !bordElem )
break;
// find the next bordElem
const SMDS_MeshElement* nextBordElem = 0;
for ( int iN = 0, nbN = bordElem->NbCornerNodes(); iN < nbN && !nextBordElem; ++iN )
{
const SMDS_MeshNode* n = bordElem->GetNode( iN );
if ( fissureNodes.count( n )) continue;
facetNodes[ sb._nbNodes ] = n;
elemsByFacet.clear();
if ( SMDS_Mesh::GetElementsByNodes( facetNodes, elemsByFacet ) > 1 )
{
for ( size_t iE = 0; iE < elemsByFacet.size(); ++iE )
if ( elemsByFacet[ iE ] != bordElem &&
!elemsByFacet[ iE ]->isMarked() )
{
theAffectedElems.insert( elemsByFacet[ iE ]);
elemsByFacet[ iE ]->setIsMarked( true );
if ( elemsByFacet[ iE ]->GetType() == bordElem->GetType() )
nextBordElem = elemsByFacet[ iE ];
}
}
}
bordElem = nextBordElem;
} // while ( bordElem )
linkedBorders.clear(); // not to treat this link any more
} // loop on SubBorder's of a FissureBorder
bord->Clear();
} // loop on FissureBorder's
// add elements sharing only one node of the fissure, except those sharing fissure edge nodes
// mark nodes of theAffectedElems
SMESH_MeshAlgos::MarkElemNodes( theAffectedElems.begin(), theAffectedElems.end(), true );
// unmark nodes of the fissure
elIt = theElemsOrNodes.begin();
if ( (*elIt)->GetType() == SMDSAbs_Node )
SMESH_MeshAlgos::MarkElems( elIt, theElemsOrNodes.end(), false );
else
SMESH_MeshAlgos::MarkElemNodes( elIt, theElemsOrNodes.end(), false );
std::vector< gp_XYZ > normVec;
// loop on nodes of the fissure, add elements having marked nodes
for ( elIt = theElemsOrNodes.begin(); elIt != theElemsOrNodes.end(); ++elIt )
{
const SMDS_MeshElement* e = (*elIt);
if ( e->GetType() != SMDSAbs_Node )
e->setIsMarked( true ); // avoid adding a fissure element
for ( int iN = 0, nbN = e->NbCornerNodes(); iN < nbN; ++iN )
{
const SMDS_MeshNode* n = e->GetNode( iN );
if ( fissEdgeNodes2Norm.count( n ))
continue;
SMDS_ElemIteratorPtr invIt = n->GetInverseElementIterator();
while ( invIt->more() )
{
const SMDS_MeshElement* eInv = invIt->next();
if ( eInv->isMarked() ) continue;
eInv->setIsMarked( true );
SMDS_ElemIteratorPtr nIt = eInv->nodesIterator();
while( nIt->more() )
if ( nIt->next()->isMarked())
{
theAffectedElems.insert( eInv );
SMESH_MeshAlgos::MarkElems( eInv->nodesIterator(), true );
n->setIsMarked( false );
break;
}
}
}
}
// add elements on the fissure edge
std::map< const SMDS_MeshNode*, FissureNormal >::iterator n2N;
for ( n2N = fissEdgeNodes2Norm.begin(); n2N != fissEdgeNodes2Norm.end(); ++n2N )
{
const SMDS_MeshNode* edgeNode = n2N->first;
const FissureNormal & normals = n2N->second;
SMDS_ElemIteratorPtr invIt = edgeNode->GetInverseElementIterator();
while ( invIt->more() )
{
const SMDS_MeshElement* eInv = invIt->next();
if ( eInv->isMarked() ) continue;
eInv->setIsMarked( true );
// classify eInv using normals
bool toAdd = normals.IsIn( edgeNode, eInv );
if ( toAdd ) // check if all nodes lie on the fissure edge
{
bool notOnEdge = false;
for ( int iN = 0, nbN = eInv->NbCornerNodes(); iN < nbN && !notOnEdge; ++iN )
notOnEdge = !fissEdgeNodes2Norm.count( eInv->GetNode( iN ));
toAdd = notOnEdge;
}
if ( toAdd )
{
theAffectedElems.insert( eInv );
}
}
}
return;
} // findAffectedElems()
} // namespace
//================================================================================
/*!
* \brief Create elements equal (on same nodes) to given ones
@ -10616,7 +11162,6 @@ void SMESH_MeshEditor::DoubleElements( const TIDSortedElemSet& theElements )
SMDSAbs_ElementType type = SMDSAbs_All;
SMDS_ElemIteratorPtr elemIt;
vector< const SMDS_MeshElement* > allElems;
if ( theElements.empty() )
{
if ( mesh->NbNodes() == 0 )
@ -10632,12 +11177,7 @@ void SMESH_MeshEditor::DoubleElements( const TIDSortedElemSet& theElements )
type = types[i];
break;
}
// put all elements in the vector <allElems>
allElems.reserve( mesh->GetMeshInfo().NbElements( type ));
elemIt = mesh->elementsIterator( type );
while ( elemIt->more() )
allElems.push_back( elemIt->next());
elemIt = elemSetIterator( allElems );
}
else
{
@ -10645,6 +11185,9 @@ void SMESH_MeshEditor::DoubleElements( const TIDSortedElemSet& theElements )
elemIt = elemSetIterator( theElements );
}
// un-mark all elements to avoid duplicating just created elements
SMESH_MeshAlgos::MarkElems( mesh->elementsIterator( type ), false );
// duplicate elements
ElemFeatures elemType;
@ -10653,13 +11196,14 @@ void SMESH_MeshEditor::DoubleElements( const TIDSortedElemSet& theElements )
while ( elemIt->more() )
{
const SMDS_MeshElement* elem = elemIt->next();
if ( elem->GetType() != type )
if ( elem->GetType() != type || elem->isMarked() )
continue;
elemType.Init( elem, /*basicOnly=*/false );
nodes.assign( elem->begin_nodes(), elem->end_nodes() );
AddElement( nodes, elemType );
if ( const SMDS_MeshElement* newElem = AddElement( nodes, elemType ))
newElem->setIsMarked( true );
}
}
@ -10679,8 +11223,7 @@ bool SMESH_MeshEditor::DoubleNodes( const TIDSortedElemSet& theElems,
const TIDSortedElemSet& theNodesNot,
const TIDSortedElemSet& theAffectedElems )
{
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
ClearLastCreated();
if ( theElems.size() == 0 )
return false;
@ -10725,8 +11268,8 @@ bool SMESH_MeshEditor::doubleNodes(SMESHDS_Mesh* theMeshDS,
for ( ; elemItr != theElems.end(); ++elemItr )
{
const SMDS_MeshElement* anElem = *elemItr;
if (!anElem)
continue;
// if (!anElem)
// continue;
// duplicate nodes to duplicate element
bool isDuplicate = false;
@ -10780,8 +11323,7 @@ bool SMESH_MeshEditor::doubleNodes(SMESHDS_Mesh* theMeshDS,
bool SMESH_MeshEditor::DoubleNodes( const std::list< int >& theListOfNodes,
const std::list< int >& theListOfModifiedElems )
{
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
ClearLastCreated();
if ( theListOfNodes.size() == 0 )
return false;
@ -10797,8 +11339,7 @@ bool SMESH_MeshEditor::DoubleNodes( const std::list< int >& theListOfNodes,
std::list< int >::const_iterator aNodeIter;
for ( aNodeIter = theListOfNodes.begin(); aNodeIter != theListOfNodes.end(); ++aNodeIter )
{
int aCurr = *aNodeIter;
SMDS_MeshNode* aNode = (SMDS_MeshNode*)aMeshDS->FindNode( aCurr );
const SMDS_MeshNode* aNode = aMeshDS->FindNode( *aNodeIter );
if ( !aNode )
continue;
@ -10813,49 +11354,28 @@ bool SMESH_MeshEditor::DoubleNodes( const std::list< int >& theListOfNodes,
}
}
// Create map of new nodes for modified elements
// Change nodes of elements
std::map< SMDS_MeshElement*, vector<const SMDS_MeshNode*> > anElemToNodes;
std::vector<const SMDS_MeshNode*> aNodeArr;
std::list< int >::const_iterator anElemIter;
for ( anElemIter = theListOfModifiedElems.begin();
anElemIter != theListOfModifiedElems.end(); ++anElemIter )
for ( anElemIter = theListOfModifiedElems.begin();
anElemIter != theListOfModifiedElems.end();
anElemIter++ )
{
int aCurr = *anElemIter;
SMDS_MeshElement* anElem = (SMDS_MeshElement*)aMeshDS->FindElement( aCurr );
const SMDS_MeshElement* anElem = aMeshDS->FindElement( *anElemIter );
if ( !anElem )
continue;
vector<const SMDS_MeshNode*> aNodeArr( anElem->NbNodes() );
SMDS_ElemIteratorPtr anIter = anElem->nodesIterator();
int ind = 0;
while ( anIter->more() )
aNodeArr.assign( anElem->begin_nodes(), anElem->end_nodes() );
for( size_t i = 0; i < aNodeArr.size(); ++i )
{
SMDS_MeshNode* aCurrNode = (SMDS_MeshNode*)anIter->next();
if ( aCurr && anOldNodeToNewNode.find( aCurrNode ) != anOldNodeToNewNode.end() )
{
const SMDS_MeshNode* aNewNode = anOldNodeToNewNode[ aCurrNode ];
aNodeArr[ ind++ ] = aNewNode;
}
else
aNodeArr[ ind++ ] = aCurrNode;
}
anElemToNodes[ anElem ] = aNodeArr;
}
// Change nodes of elements
std::map< SMDS_MeshElement*, vector<const SMDS_MeshNode*> >::iterator
anElemToNodesIter = anElemToNodes.begin();
for ( ; anElemToNodesIter != anElemToNodes.end(); ++anElemToNodesIter )
{
const SMDS_MeshElement* anElem = anElemToNodesIter->first;
vector<const SMDS_MeshNode*> aNodeArr = anElemToNodesIter->second;
if ( anElem )
{
aMeshDS->ChangeElementNodes( anElem, &aNodeArr[ 0 ], anElem->NbNodes() );
std::map< const SMDS_MeshNode*, const SMDS_MeshNode* >::iterator n2n =
anOldNodeToNewNode.find( aNodeArr[ i ]);
if ( n2n != anOldNodeToNewNode.end() )
aNodeArr[ i ] = n2n->second;
}
aMeshDS->ChangeElementNodes( anElem, &aNodeArr[ 0 ], aNodeArr.size() );
}
return true;
@ -10877,8 +11397,8 @@ namespace {
{
gp_XYZ centerXYZ (0, 0, 0);
SMDS_ElemIteratorPtr aNodeItr = theElem->nodesIterator();
while (aNodeItr->more())
centerXYZ += SMESH_TNodeXYZ(cast2Node( aNodeItr->next()));
while ( aNodeItr->more() )
centerXYZ += SMESH_NodeXYZ( aNodeItr->next() );
gp_Pnt aPnt = centerXYZ / theElem->NbNodes();
theClassifier.Perform(aPnt, theTol);
@ -10933,9 +11453,9 @@ namespace {
(select elements with a gravity center on the side given by faces normals).
This mode (null shape) is faster, but works only when theElems are faces, with coherents orientations.
The replicated nodes should be associated to affected elements.
\return groups of affected elements
\return true
\sa DoubleNodeElemGroupsInRegion()
*/
*/
//================================================================================
bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theElems,
@ -10945,94 +11465,7 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
{
if ( theShape.IsNull() )
{
std::set<const SMDS_MeshNode*> alreadyCheckedNodes;
std::set<const SMDS_MeshElement*> alreadyCheckedElems;
std::set<const SMDS_MeshElement*> edgesToCheck;
alreadyCheckedNodes.clear();
alreadyCheckedElems.clear();
edgesToCheck.clear();
// --- iterates on elements to be replicated and get elements by back references from their nodes
TIDSortedElemSet::const_iterator elemItr = theElems.begin();
for ( ; elemItr != theElems.end(); ++elemItr )
{
SMDS_MeshElement* anElem = (SMDS_MeshElement*)*elemItr;
if (!anElem || (anElem->GetType() != SMDSAbs_Face))
continue;
gp_XYZ normal;
SMESH_MeshAlgos::FaceNormal( anElem, normal, /*normalized=*/true );
std::set<const SMDS_MeshNode*> nodesElem;
nodesElem.clear();
SMDS_ElemIteratorPtr nodeItr = anElem->nodesIterator();
while ( nodeItr->more() )
{
const SMDS_MeshNode* aNode = cast2Node(nodeItr->next());
nodesElem.insert(aNode);
}
std::set<const SMDS_MeshNode*>::iterator nodit = nodesElem.begin();
for (; nodit != nodesElem.end(); nodit++)
{
const SMDS_MeshNode* aNode = *nodit;
if ( !aNode || theNodesNot.find(aNode) != theNodesNot.end() )
continue;
if (alreadyCheckedNodes.find(aNode) != alreadyCheckedNodes.end())
continue;
alreadyCheckedNodes.insert(aNode);
SMDS_ElemIteratorPtr backElemItr = aNode->GetInverseElementIterator();
while ( backElemItr->more() )
{
const SMDS_MeshElement* curElem = backElemItr->next();
if (alreadyCheckedElems.find(curElem) != alreadyCheckedElems.end())
continue;
if (theElems.find(curElem) != theElems.end())
continue;
alreadyCheckedElems.insert(curElem);
double x=0, y=0, z=0;
int nb = 0;
SMDS_ElemIteratorPtr nodeItr2 = curElem->nodesIterator();
while ( nodeItr2->more() )
{
const SMDS_MeshNode* anotherNode = cast2Node(nodeItr2->next());
x += anotherNode->X();
y += anotherNode->Y();
z += anotherNode->Z();
nb++;
}
gp_XYZ p;
p.SetCoord( x/nb -aNode->X(),
y/nb -aNode->Y(),
z/nb -aNode->Z() );
if (normal*p > 0)
{
theAffectedElems.insert( curElem );
}
else if (curElem->GetType() == SMDSAbs_Edge)
edgesToCheck.insert(curElem);
}
}
}
// --- add also edges lying on the set of faces (all nodes in alreadyCheckedNodes)
std::set<const SMDS_MeshElement*>::iterator eit = edgesToCheck.begin();
for( ; eit != edgesToCheck.end(); eit++)
{
bool onside = true;
const SMDS_MeshElement* anEdge = *eit;
SMDS_ElemIteratorPtr nodeItr = anEdge->nodesIterator();
while ( nodeItr->more() )
{
const SMDS_MeshNode* aNode = cast2Node(nodeItr->next());
if (alreadyCheckedNodes.find(aNode) == alreadyCheckedNodes.end())
{
onside = false;
break;
}
}
if (onside)
{
theAffectedElems.insert(anEdge);
}
}
findAffectedElems( theElems, theAffectedElems );
}
else
{
@ -11053,9 +11486,7 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
TIDSortedElemSet::const_iterator elemItr = theElems.begin();
for ( ; elemItr != theElems.end(); ++elemItr )
{
SMDS_MeshElement* anElem = (SMDS_MeshElement*)*elemItr;
if (!anElem)
continue;
SMDS_MeshElement* anElem = (SMDS_MeshElement*)*elemItr;
SMDS_ElemIteratorPtr nodeItr = anElem->nodesIterator();
while ( nodeItr->more() )
{
@ -11067,9 +11498,9 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
{
const SMDS_MeshElement* curElem = backElemItr->next();
if ( curElem && theElems.find(curElem) == theElems.end() &&
( bsc3d.get() ?
isInside( curElem, *bsc3d, aTol ) :
isInside( curElem, *aFaceClassifier, aTol )))
( bsc3d.get() ?
isInside( curElem, *bsc3d, aTol ) :
isInside( curElem, *aFaceClassifier, aTol )))
theAffectedElems.insert( curElem );
}
}

4
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -199,7 +199,7 @@ public:
const bool the13Diag);
/*!
* \brief Split each of given quadrangles into 4 triangles.
* \param theElems - The faces to be splitted. If empty all faces are split.
* \param theElems - The faces to be split. If empty all faces are split.
*/
void QuadTo4Tri (TIDSortedElemSet & theElems);
@ -542,7 +542,7 @@ public:
// of the side 2. If nb of links in the free border and
// between theSide2FirstNode and theSide2LastNode are different,
// additional nodes are inserted on a link provided that no
// volume elements share the splitted link.
// volume elements share the split link.
// The side 2 is a free border if theSide2IsFreeBorder == true.
// Sewing is performed between the given first, second and last
// nodes on the sides.

4
src/SMESH/SMESH_MesherHelper.cxx
View File

@ -2963,7 +2963,7 @@ bool SMESH_MesherHelper::IsDistorted2D( SMESH_subMesh* faceSM,
* \brief Find out elements orientation on a geometrical face
* \param theFace - The face correctly oriented in the shape being meshed
* \retval bool - true if the face normal and the normal of first element
* in the correspoding submesh point in different directions
* in the corresponding submesh point in different directions
*/
//================================================================================
@ -4378,7 +4378,7 @@ namespace { // Structures used by FixQuadraticElements()
vector< TChain> & resultChains,
SMDS_TypeOfPosition pos )
{
// put links in the set and evalute number of result chains by number of boundary links
// put links in the set and evaluate number of result chains by number of boundary links
TLinkSet linkSet;
size_t nbBndLinks = 0;
for ( TChain::iterator lnk = allLinks.begin(); lnk != allLinks.end(); ++lnk ) {

2
src/SMESH/SMESH_Pattern.cxx
View File

@ -2481,7 +2481,7 @@ bool SMESH_Pattern::Apply (const TopoDS_Face& theFace,
// If there are several wires, define the order of edges of inner wires:
// compute UV of inner edge-points using 2 methods: the one for in-face points
// and the one for on-edge points and then choose the best edge order
// by the best correspondance of the 2 results
// by the best correspondence of the 2 results
if ( nbWires > 1 )
{
// compute UV of inner edge-points using the method for in-face points

2
src/SMESH/SMESH_subMesh.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// SMESH SMESH : implementaion of SMESH idl descriptions
// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_subMesh.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH

Some files were not shown because too many files have changed in this diff Show More