ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-13 10:10:33 +05:00
Code Issues Packages Projects Releases Wiki Activity

Merge from V6_main 12/04/2013

Browse Source
This commit is contained in:
vsr 2013-04-12 14:40:29 +00:00
parent 515a51dac3
commit ae86d2a1ab
11 changed files with 217 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
configure.ac
View File

@ -576,6 +576,8 @@ AC_OUTPUT([ \
src/Tools/Makefile \
src/Tools/MeshCut/Makefile \
src/Tools/YamsPlug/Makefile \
src/Tools/YamsPlug/doc/Makefile \
src/Tools/YamsPlug/doc/conf.py \
src/Tools/padder/Makefile \
src/Tools/padder/meshjob/Makefile \
src/Tools/padder/meshjob/idl/Makefile \

1
resources/SalomeApp.xml.in
View File

@ -112,6 +112,7 @@
<section name="smesh_help" >
<parameter name="sub_menu" value="%1 module"/>
<parameter name="User's Guide" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/index.html"/>
<parameter name="Plug-ins/Yams plugin User's Guide" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/yams/index.html"/>
<parameter name="Developer's Guide" value="%SMESH_ROOT_DIR%/share/doc/salome/tui/SMESH/index.html"/>
</section>
<section name="resources">

2
src/Controls/SMESH_Controls.cxx
View File

@ -65,6 +65,7 @@
#include <set>
#include <limits>
#include <Basics_Utils.hxx>
/*
AUXILIARY METHODS
@ -2662,6 +2663,7 @@ void GroupColor::SetMesh( const SMDS_Mesh* theMesh )
void GroupColor::SetColorStr( const TCollection_AsciiString& theStr )
{
Kernel_Utils::Localizer loc;
TCollection_AsciiString aStr = theStr;
aStr.RemoveAll( ' ' );
aStr.RemoveAll( '\t' );

178
src/SMESH/SMESH_Gen.cxx
View File

@ -149,11 +149,12 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
else
computeEvent = SMESH_subMesh::COMPUTE_SUBMESH;
if ( anUpward ) // is called from below code here
if ( anUpward ) // is called from the below code in this method
{
// -----------------------------------------------
// mesh all the sub-shapes starting from vertices
// -----------------------------------------------
// ===============================================
// Mesh all the sub-shapes starting from vertices
// ===============================================
smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst);
while ( smIt->more() )
{
@ -193,19 +194,21 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
}
else
{
// -----------------------------------------------------------------
// apply algos that DO NOT require Discreteized boundaries and DO NOT
// support submeshes, starting from the most complex shapes
// and collect submeshes with algos that DO support submeshes
// -----------------------------------------------------------------
list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes;
// ================================================================
// Apply algos that do NOT require discreteized boundaries
// ("all-dimensional") and do NOT support sub-meshes, starting from
// the most complex shapes and collect sub-meshes with algos that
// DO support sub-meshes
// ================================================================
list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes[4]; // for each dim
// map to sort sm with same dim algos according to dim of
// the shape the algo assigned to (issue 0021217)
multimap< int, SMESH_subMesh* > shDim2sm;
multimap< int, SMESH_subMesh* >::reverse_iterator shDim2smIt;
TopoDS_Shape algoShape;
int prevShapeDim = -1;
int prevShapeDim = -1, aShapeDim;
smIt = sm->getDependsOnIterator(includeSelf, complexShapeFirst);
while ( smIt->more() )
@ -215,7 +218,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
continue;
const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
int aShapeDim = GetShapeDim( aSubShape );
aShapeDim = GetShapeDim( aSubShape );
if ( aShapeDim < 1 ) break;
// check for preview dimension limitations
@ -234,9 +237,9 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
prevShapeDim = aShapeDim;
for ( shDim2smIt = shDim2sm.rbegin(); shDim2smIt != shDim2sm.rend(); ++shDim2smIt )
if ( shDim2smIt->first == globalAlgoDim )
smWithAlgoSupportingSubmeshes.push_back( shDim2smIt->second );
smWithAlgoSupportingSubmeshes[ aShapeDim ].push_back( shDim2smIt->second );
else
smWithAlgoSupportingSubmeshes.push_front( shDim2smIt->second );
smWithAlgoSupportingSubmeshes[ aShapeDim ].push_front( shDim2smIt->second );
shDim2sm.clear();
}
// add smToCompute to shDim2sm map
@ -255,7 +258,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
}
shDim2sm.insert( make_pair( aShapeDim, smToCompute ));
}
else
else // Compute w/o support of sub-meshes
{
if (_compute_canceled)
return false;
@ -270,82 +273,91 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
// reload sub-meshes from shDim2sm into smWithAlgoSupportingSubmeshes
for ( shDim2smIt = shDim2sm.rbegin(); shDim2smIt != shDim2sm.rend(); ++shDim2smIt )
if ( shDim2smIt->first == globalAlgoDim )
smWithAlgoSupportingSubmeshes.push_back( shDim2smIt->second );
smWithAlgoSupportingSubmeshes[0].push_back( shDim2smIt->second );
else
smWithAlgoSupportingSubmeshes.push_front( shDim2smIt->second );
smWithAlgoSupportingSubmeshes[0].push_front( shDim2smIt->second );
// ------------------------------------------------------------
// sort list of submeshes according to mesh order
// ------------------------------------------------------------
aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes );
// ======================================================
// Apply all-dimensional algorithms supporing sub-meshes
// ======================================================
// ------------------------------------------------------------
// compute submeshes under shapes with algos that DO NOT require
// Discreteized boundaries and DO support submeshes
// ------------------------------------------------------------
list< SMESH_subMesh* >::iterator subIt, subEnd;
subIt = smWithAlgoSupportingSubmeshes.begin();
subEnd = smWithAlgoSupportingSubmeshes.end();
// start from lower shapes
for ( ; subIt != subEnd; ++subIt )
for ( aShapeDim = 0; aShapeDim < 4; ++aShapeDim )
{
sm = *subIt;
// ------------------------------------------------
// sort list of sub-meshes according to mesh order
// ------------------------------------------------
aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes[ aShapeDim ] );
// get a shape the algo is assigned to
if ( !GetAlgo( aMesh, sm->GetSubShape(), & algoShape ))
continue; // strange...
// look for more local algos
smIt = sm->getDependsOnIterator(!includeSelf, !complexShapeFirst);
while ( smIt->more() )
// ------------------------------------------------------------
// compute sub-meshes with local uni-dimensional algos under
// sub-meshes with all-dimensional algos
// ------------------------------------------------------------
list< SMESH_subMesh* >::iterator subIt, subEnd;
subIt = smWithAlgoSupportingSubmeshes[ aShapeDim ].begin();
subEnd = smWithAlgoSupportingSubmeshes[ aShapeDim ].end();
// start from lower shapes
for ( ; subIt != subEnd; ++subIt )
{
SMESH_subMesh* smToCompute = smIt->next();
sm = *subIt;
const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
const int aShapeDim = GetShapeDim( aSubShape );
//if ( aSubShape.ShapeType() == TopAbs_VERTEX ) continue;
if ( aShapeDim < 1 ) continue;
// get a shape the algo is assigned to
if ( !GetAlgo( aMesh, sm->GetSubShape(), & algoShape ))
continue; // strange...
// check for preview dimension limitations
if ( aShapesId && GetShapeDim( aSubShape.ShapeType() ) > (int)aDim )
continue;
SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() );
filter
.And( SMESH_HypoFilter::IsApplicableTo( aSubShape ))
.And( SMESH_HypoFilter::IsMoreLocalThan( algoShape, aMesh ));
// look for more local algos
smIt = sm->getDependsOnIterator(!includeSelf, !complexShapeFirst);
while ( smIt->more() )
{
SMESH_subMesh* smToCompute = smIt->next();
if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( aSubShape, filter, true )) {
if ( ! subAlgo->NeedDiscreteBoundary() ) continue;
SMESH_Hypothesis::Hypothesis_Status status;
if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status ))
// mesh a lower smToCompute starting from vertices
Compute( aMesh, aSubShape, /*anUpward=*/true, aDim, aShapesId );
const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
const int aShapeDim = GetShapeDim( aSubShape );
//if ( aSubShape.ShapeType() == TopAbs_VERTEX ) continue;
if ( aShapeDim < 1 ) continue;
// check for preview dimension limitations
if ( aShapesId && GetShapeDim( aSubShape.ShapeType() ) > (int)aDim )
continue;
SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() );
filter
.And( SMESH_HypoFilter::IsApplicableTo( aSubShape ))
.And( SMESH_HypoFilter::IsMoreLocalThan( algoShape, aMesh ));
if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( aSubShape, filter, true )) {
if ( ! subAlgo->NeedDiscreteBoundary() ) continue;
SMESH_Hypothesis::Hypothesis_Status status;
if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status ))
// mesh a lower smToCompute starting from vertices
Compute( aMesh, aSubShape, /*anUpward=*/true, aDim, aShapesId );
}
}
}
}
// ----------------------------------------------------------
// apply the algos that do not require Discreteized boundaries
// ----------------------------------------------------------
for ( subIt = smWithAlgoSupportingSubmeshes.begin(); subIt != subEnd; ++subIt )
{
sm = *subIt;
if ( sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
// --------------------------------
// apply the all-dimensional algos
// --------------------------------
subIt = smWithAlgoSupportingSubmeshes[ aShapeDim ].begin();
for ( ; subIt != subEnd; ++subIt )
{
const TopAbs_ShapeEnum aShType = sm->GetSubShape().ShapeType();
// check for preview dimension limitations
if ( aShapesId && GetShapeDim( aShType ) > (int)aDim )
continue;
sm = *subIt;
if ( sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
{
const TopAbs_ShapeEnum aShType = sm->GetSubShape().ShapeType();
// check for preview dimension limitations
if ( aShapesId && GetShapeDim( aShType ) > (int)aDim )
continue;
if (_compute_canceled)
return false;
_sm_current = sm;
sm->ComputeStateEngine( computeEvent );
_sm_current = NULL;
if ( aShapesId )
aShapesId->insert( sm->GetId() );
if (_compute_canceled)
return false;
_sm_current = sm;
sm->ComputeStateEngine( computeEvent );
_sm_current = NULL;
if ( aShapesId )
aShapesId->insert( sm->GetId() );
}
}
}
} // loop on shape dimensions
// -----------------------------------------------
// mesh the rest sub-shapes starting from vertices
// -----------------------------------------------
@ -451,8 +463,8 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh,
else {
// -----------------------------------------------------------------
// apply algos that DO NOT require Discreteized boundaries and DO NOT
// support submeshes, starting from the most complex shapes
// and collect submeshes with algos that DO support submeshes
// support sub-meshes, starting from the most complex shapes
// and collect sub-meshes with algos that DO support sub-meshes
// -----------------------------------------------------------------
list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes;
smIt = sm->getDependsOnIterator(includeSelf, complexShapeFirst);
@ -481,8 +493,8 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh,
aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes );
// ------------------------------------------------------------
// compute submeshes under shapes with algos that DO NOT require
// Discreteized boundaries and DO support submeshes
// compute sub-meshes under shapes with algos that DO NOT require
// Discreteized boundaries and DO support sub-meshes
// ------------------------------------------------------------
list< SMESH_subMesh* >::iterator subIt, subEnd;
subIt = smWithAlgoSupportingSubmeshes.begin();
@ -650,9 +662,9 @@ static bool checkMissing(SMESH_Gen* aGen,
{
case TopAbs_EDGE:
case TopAbs_FACE:
case TopAbs_SOLID: break; // check this submesh, it can be meshed
case TopAbs_SOLID: break; // check this sub-mesh, it can be meshed
default:
return true; // not meshable submesh
return true; // not meshable sub-mesh
}
if ( aCheckedMap.count( aSubMesh ))
return true;

37
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -6065,7 +6065,26 @@ SMESH_MeshEditor::generateGroups(const SMESH_SequenceOfElemPtr& nodeGens,
if ( resElem != sourceElem )
resultElems.push_back( resElem );
// add resultElems to groups made by ones the sourceElem belongs to
// there must be a top element
const SMDS_MeshElement* topElem = 0;
if ( isNodes )
{
topElem = resultElems.back();
resultElems.pop_back();
}
else
{
list< const SMDS_MeshElement* >::reverse_iterator resElemIt = resultElems.rbegin();
for ( ; resElemIt != resultElems.rend() ; ++resElemIt )
if ( (*resElemIt)->GetType() == sourceElem->GetType() )
{
topElem = *resElemIt;
resultElems.erase( --(resElemIt.base()) ); // erase *resElemIt
break;
}
}
// add resultElems to groups originted from ones the sourceElem belongs to
list< TOldNewGroup >::iterator gOldNew, gLast = groupsOldNew.end();
for ( gOldNew = groupsOldNew.begin(); gOldNew != gLast; ++gOldNew )
{
@ -6074,19 +6093,15 @@ SMESH_MeshEditor::generateGroups(const SMESH_SequenceOfElemPtr& nodeGens,
{
// fill in a new group
SMDS_MeshGroup & newGroup = gOldNew->get<1>()->SMDSGroup();
list< const SMDS_MeshElement* > rejectedElems; // elements of other type
list< const SMDS_MeshElement* >::iterator resLast = resultElems.end(), resElemIt;
for ( resElemIt = resultElems.begin(); resElemIt != resLast; ++resElemIt )
if ( !newGroup.Add( *resElemIt ))
rejectedElems.push_back( *resElemIt );
newGroup.Add( *resElemIt );
// fill "top" group
if ( !rejectedElems.empty() )
// fill a "top" group
if ( topElem )
{
SMDS_MeshGroup & newTopGroup = gOldNew->get<2>()->SMDSGroup();
resLast = rejectedElems.end();
for ( resElemIt = rejectedElems.begin(); resElemIt != resLast; ++resElemIt )
!newTopGroup.Add( *resElemIt );
newTopGroup.Add( topElem );
}
}
}
@ -6116,7 +6131,9 @@ SMESH_MeshEditor::generateGroups(const SMESH_SequenceOfElemPtr& nodeGens,
// make a name
const bool isTop = ( nbNewGroups == 2 &&
newGroupDS->GetType() == oldGroupDS->GetType() );
newGroupDS->GetType() == oldGroupDS->GetType() &&
is2nd );
string name = oldGroupDS->GetStoreName();
if ( !targetMesh ) {
string suffix = ( isTop ? "top": postfix.c_str() );

2
src/SMESHGUI/SMESHGUI_FilterDlg.cxx
View File

@ -67,6 +67,7 @@
// SALOME KERNEL includes
#include <SALOMEDSClient_Study.hxx>
#include <Basics_Utils.hxx>
// OCCT includes
#include <StdSelect_TypeOfFace.hxx>
@ -1246,6 +1247,7 @@ void SMESHGUI_FilterTable::GetCriterion (const int theRow,
QtxColorButton* clrBtn = qobject_cast<QtxColorButton*>(aTable->cellWidget(theRow, 2));
if ( clrBtn )
{
Kernel_Utils::Localizer loc;
const QColor qClr = clrBtn->color();
QString clrStr = QString( "%1;%2;%3" ).
arg( qClr.red()/256. ).arg( qClr.green()/256. ).arg( qClr.blue()/256. );

7
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
View File

@ -607,7 +607,9 @@ void SMESHGUI_MultiEditDlg::onSelectionDone()
anItem->setSelected(true);
}
}
myMesh = SMESH::GetMeshByIO(anIO);
SMESH::SMESH_Mesh_var aSelMesh = SMESH::GetMeshByIO(anIO);
if (!aSelMesh->_is_nil())
myMesh = aSelMesh;
}
if (nbSel > 0) {
@ -662,6 +664,7 @@ void SMESHGUI_MultiEditDlg::onFilterBtn()
myFilterDlg->SetSelection();
myFilterDlg->SetMesh(myMesh);
myFilterDlg->SetSourceWg(myListBox, false);
myFilterDlg->show();
}
@ -975,7 +978,7 @@ void SMESHGUI_MultiEditDlg::setSelectionMode()
{
SMESH::RemoveFilters();
mySelectionMgr->clearSelected();
// mySelectionMgr->clearSelected();
mySelectionMgr->clearFilters();
if (mySubmeshChk->isChecked()) {

9
src/StdMeshers/StdMeshers_ProjectionUtils.cxx
View File

@ -1000,7 +1000,8 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
// get outer edge of theShape1
TopoDS_Shape wire = OuterShape( face1, TopAbs_WIRE );
//edge1 = TopoDS::Edge( OuterShape( face1, TopAbs_EDGE ));
map<int,TopoDS_Edge> propag_edges; // use map to find the closest propagation edge
// use map to find the closest propagation edge
map<int, pair< TopoDS_Edge, TopoDS_Edge > > propag_edges;
for ( TopoDS_Iterator edgeIt( wire ); edgeIt.More(); edgeIt.Next() )
{
edge1 = TopoDS::Edge( edgeIt.Value() );
@ -1009,7 +1010,8 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
edge2 = TopoDS::Edge( exp.Current() );
pair<int,TopoDS_Edge> step_edge = GetPropagationEdge( theMesh1, edge2, edge1 );
if ( !step_edge.second.IsNull() ) { // propagation found
propag_edges.insert( step_edge );
propag_edges.insert( make_pair( step_edge.first,
( make_pair( edge1, step_edge.second ))));
if ( step_edge.first == 1 ) break; // most close found
}
}
@ -1017,7 +1019,8 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
}
if ( !propag_edges.empty() ) // propagation found
{
edge2 = propag_edges.begin()->second;
edge1 = propag_edges.begin()->second.first;
edge2 = propag_edges.begin()->second.second;
TopoDS_Vertex VV1[2], VV2[2];
TopExp::Vertices( edge1, VV1[0], VV1[1], true );
TopExp::Vertices( edge2, VV2[0], VV2[1], true );

2
src/Tools/YamsPlug/Makefile.am
View File

@ -17,6 +17,8 @@
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
SUBDIRS = doc
include $(top_srcdir)/adm_local/unix/make_common_starter.am
UIPY_FILES = YamsPlugDialog.py ViewText.py

72
src/Tools/YamsPlug/doc/Makefile.am Normal file
View File

@ -0,0 +1,72 @@
# Makefile for Sphinx documentation
#
include $(top_srcdir)/adm_local/unix/make_common_starter.am
yamsdocdir=$(docdir)/gui/SMESH/yams
RSTFILES = lct.rst \
index.rst \
editHypo.rst \
Mandatory_params.rst \
Generics_params.rst \
Advanced_params.rst
EXTRA_DIST += $(RSTFILES)
# You can set these variables from the command line.
SPHINXOPTS =
SOURCEDIR = $(srcdir)
SPHINXBUILD = sphinx-build
PAPER =
BUILDDIR = _build
CONF_FILE_DIR = .
# Internal variables.
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees -c $(CONF_FILE_DIR) $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) $(SOURCEDIR)
.PHONY: help clean html latexpdf
all:
make html
help:
@echo "Please use \`make <target>' where <target> is one of"
@echo " html to make standalone HTML files"
@echo " dirhtml to make HTML files named index.html in directories"
@echo " singlehtml to make a single large HTML file"
@echo " pickle to make pickle files"
@echo " json to make JSON files"
@echo " htmlhelp to make HTML files and a HTML help project"
@echo " qthelp to make HTML files and a qthelp project"
@echo " devhelp to make HTML files and a Devhelp project"
@echo " epub to make an epub"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@echo " latexpdf to make LaTeX files and run them through pdflatex"
@echo " text to make text files"
@echo " man to make manual pages"
@echo " changes to make an overview of all changed/added/deprecated items"
@echo " linkcheck to check all external links for integrity"
@echo " doctest to run all doctests embedded in the documentation (if enabled)"
install-data-local: all
test -z $(yamsdocdir) || mkdir -p $(yamsdocdir)
cp -rf $(BUILDDIR)/html/* $(yamsdocdir) ;
clean:
-rm -rf $(BUILDDIR)/*
html:
$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
latexpdf:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through pdflatex..."
$(MAKE) -C $(BUILDDIR)/latex all-pdf
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."

6
src/Tools/YamsPlug/doc/conf.py → src/Tools/YamsPlug/doc/conf.py.in
View File

@ -35,16 +35,16 @@ source_suffix = '.rst'
master_doc = 'index'
# General substitutions.
project = 'YAMS Plug_in'
project = 'YAMS Plug-in'
copyright = '2011, Pascale Noyret'
# The default replacements for |version| and |release|, also used in various
# other places throughout the built documents.
#
# The short X.Y version.
version = '6.4'
version = '@VERSION@'
# The full version, including alpha/beta/rc tags.
release = '6.4.0'
release = '@VERSION@'
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used: