length that changes in arithmetic progression (Lk = Lk-1 + d)
beginning from a given starting length and up to a given end length.
+The direction of the splitting is defined by the orientation of the underlying geometrical edge.
+<b>"Reverse Edges"</b> list box allows to specify the edges for which the splitting should be made
+in the direction opposing to their orientation. This list box is enabled only if the geometry object
+is selected for the meshing. In this case the user can select edges to be reversed either directly
+picking them in the 3D viewer or by selecting the edges or groups of edges in the Object browser.
+
\image html a-arithmetic1d.png
\image html b-ithmetic1d.png "Arithmetic 1D hypothesis - the size of mesh elements gradually increases"
mesh. Later these nodes will be used for meshing of the faces abutting
to these edges.
+The direction of the splitting is defined by the orientation of the underlying geometrical edge.
+<b>"Reverse Edges"</b> list box allows to specify the edges for which the splitting should be made
+in the direction opposing to their orientation. This list box is enabled only if the geometry object
+is selected for the meshing. In this case the user can select edges to be reversed either directly
+picking them in the 3D viewer or by selecting the edges or groups of edges in the Object browser.
+
\image html image46.gif
You can set the type of distribution for this hypothesis in the
constructed at segment ends location and 1D mesh elements are
constructed on them.
+The direction of the splitting is defined by the orientation of the underlying geometrical edge.
+<b>"Reverse Edges"</b> list box allows to specify the edges for which the splitting should be made
+in the direction opposing to their orientation. This list box is enabled only if the geometry object
+is selected for the meshing. In this case the user can select edges to be reversed either directly
+picking them in the 3D viewer or by selecting the edges or groups of edges in the Object browser.
+
\image html a-startendlength.png
\image html b-art_end_length.png "The lengths of the first and the last segment are strictly defined"
#include "SMESH_Hypothesis.idl"
#include "SMESH_Mesh.idl"
-
/*!
* StdMeshers: interfaces to standard hypotheses and algorithms
*/
*/
long ConversionMode()
raises (SALOME::SALOME_Exception);
+
+ /*!
+ * Set list of edges to reverse
+ */
+ void SetReversedEdges( in SMESH::long_array list );
+
+ /*!
+ * Returns list of edges to reverse
+ */
+ SMESH::long_array GetReversedEdges();
+
+ /*!
+ * Set entry of the main object
+ */
+ void SetObjectEntry( in string entry );
+
+ /*!
+ * Get the entry of the main object
+ */
+ string GetObjectEntry();
};
/*!
* Returns <start segment length> or <end segment length> parameter value
*/
double GetLength(in boolean isStartLength);
+
+ /*!
+ * Set list of edges to reverse
+ */
+ void SetReversedEdges( in SMESH::long_array list );
+
+ /*!
+ * Returns list of edges to reverse
+ */
+ SMESH::long_array GetReversedEdges();
+
+ /*!
+ * Set entry of the main object
+ */
+ void SetObjectEntry( in string entry );
+
+ /*!
+ * Get the entry of the main object
+ */
+ string GetObjectEntry();
};
/*!
* Returns <start segment length> or <end segment length> parameter value
*/
double GetLength(in boolean isStartLength);
+
+ /*!
+ * Set list of edges to reverse
+ */
+ void SetReversedEdges( in SMESH::long_array list );
+
+ /*!
+ * Returns list of edges to reverse
+ */
+ SMESH::long_array GetReversedEdges();
+
+ /*!
+ * Set entry of the main object
+ */
+ void SetObjectEntry( in string entry );
+
+ /*!
+ * Get the entry of the main object
+ */
+ string GetObjectEntry();
};
SMESH_ActorUtils.h \
SMESH_ActorDef.h \
SMESH_DeviceActor.h \
+ SMESH_PreviewActorsCollection.h \
SMESH_ExtractGeometry.h \
SMESH_ActorUtils.h \
SMESH_FaceOrientationFilter.h
SMESH_Object.cxx \
SMESH_DeviceActor.cxx \
SMESH_Actor.cxx \
+ SMESH_PreviewActorsCollection.cxx \
SMESH_ExtractGeometry.cxx \
SMESH_ActorUtils.cxx \
SMESH_FaceOrientationFilter.cxx
libSMESHObject_la_CPPFLAGS = \
+ $(QT_INCLUDES) \
$(KERNEL_CXXFLAGS) \
$(GUI_CXXFLAGS) \
$(MED_CXXFLAGS) \
--- /dev/null
+// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 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.com
+//
+// SMESH OBJECT : interactive object for SMESH visualization
+// File : SMESH_PreviewActorsCollection.cxx
+// Author :
+// Module : SMESH
+//
+
+#include "SMESH_PreviewActorsCollection.h"
+
+#include "utilities.h"
+
+#include "SALOME_InteractiveObject.hxx"
+
+// OCC includes
+#include <TopoDS.hxx>
+#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+
+// VTK includes
+#include <vtkUnstructuredGrid.h>
+#include <vtkScalarBarActor.h>
+#include <vtkPlane.h>
+#include <vtkRenderer.h>
+#include <vtkProperty.h>
+
+#include "VTKViewer_Actor.h"
+
+#include "SVTK_DeviceActor.h"
+#include "SALOME_Actor.h"
+
+// QT
+#include <QString>
+#include <QColor>
+
+#ifdef _DEBUG_
+static int MYDEBUG = 0;
+#else
+static int MYDEBUG = 0;
+#endif
+
+using namespace std;
+
+
+//vtkStandardNewMacro(SMESH_PreviewActorsCollection);
+
+
+SMESH_PreviewActorsCollection
+::SMESH_PreviewActorsCollection()
+{
+ if(MYDEBUG) MESSAGE("SMESH_PreviewActorsCollection - "<<this);
+}
+
+
+SMESH_PreviewActorsCollection
+::~SMESH_PreviewActorsCollection()
+{
+ if(MYDEBUG) MESSAGE("~SMESH_PreviewActorsCollection - "<<this);
+ if (myRenderer)
+ RemoveFromRender(myRenderer);
+
+ myMapOfActors.clear();
+}
+
+bool SMESH_PreviewActorsCollection::Init( const TopoDS_Shape& theShape, TopAbs_ShapeEnum theType, const QString& theEntry )
+{
+ myMainShape = theShape;
+ myMapOfActors.clear();
+ myMapOfShapes.Clear();
+
+ if ( theShape.IsNull() )
+ return false;
+
+ Handle( SALOME_InteractiveObject ) anIO = new SALOME_InteractiveObject();
+ anIO->setEntry( theEntry.toLatin1().constData() );
+
+ // get indexes of seleted elements
+ TopExp::MapShapes(theShape, myMapOfShapes);
+
+ TopExp_Explorer exp( theShape, theType );
+ for ( ; exp.More(); exp.Next() ) {
+ int index = myMapOfShapes.FindIndex( exp.Current() );
+ if ( index ) {
+ // create actor if the index is present
+ if ( GEOM_Actor* anActor = createActor( exp.Current() )) {
+ // Create new entry for actor
+ QString aString = theEntry;
+ aString += QString("_%1").arg( index ); // add index to actor entry
+
+ // Create interactive object
+ Handle( SALOME_InteractiveObject ) anIO = new SALOME_InteractiveObject();
+ anIO->setEntry( aString.toLatin1().constData() );
+
+ // Init Actor
+ anActor->SetVectorMode( true );
+ anActor->setIO( anIO );
+ anActor->SetSelector( mySelector );
+ anActor->SetPickable( true );
+ anActor->SetResolveCoincidentTopology( true );
+
+ // Add Actor to the Actors Map
+ myMapOfActors.insert(index, anActor);
+ }
+ }
+ }
+ mySelector->ClearIObjects();
+
+ return true;
+}
+
+GEOM_Actor* SMESH_PreviewActorsCollection::createActor(const TopoDS_Shape& shape)
+{
+ GEOM_Actor* actor = GEOM_Actor::New();
+ actor->SetShape(shape,0,0);
+
+ //Color Properties
+ /*
+ vtkProperty* aProp = vtkProperty::New();
+ vtkProperty* aHLProp = vtkProperty::New();
+ vtkProperty* aPHLProp = vtkProperty::New();
+
+ aProp->SetColor( 255, 0, 0);
+ actor->SetProperty(aProp);
+
+ aHLProp->SetColor( 255, 255, 255);
+ actor->SetHighlightProperty(aHLProp);
+
+ aPHLProp->SetColor( 155, 155, 155);
+ aPHLProp->SetLineWidth ( 3 );
+ aPHLProp->SetOpacity ( 0.75 );
+ actor->SetPreHighlightProperty(aPHLProp);
+
+ aProp->Delete();
+ aHLProp->Delete();
+ aPHLProp->Delete();
+ */
+
+ return actor;
+}
+
+GEOM_Actor* SMESH_PreviewActorsCollection::GetActorByIndex(int index)
+{
+ return myMapOfActors.value(index);
+}
+
+int SMESH_PreviewActorsCollection::GetIndexByShape( const TopoDS_Shape& theShape )
+{
+ return myMapOfShapes.FindIndex( theShape );
+}
+
+void SMESH_PreviewActorsCollection::AddToRender(vtkRenderer* theRenderer)
+{
+ myRenderer = theRenderer;
+
+ QMap<int, GEOM_Actor*>::iterator iter = myMapOfActors.begin();
+ for ( ; iter != myMapOfActors.end(); ++iter )
+ iter.value()->AddToRender( theRenderer );
+}
+
+void SMESH_PreviewActorsCollection::RemoveFromRender(vtkRenderer* theRenderer){
+ QMap<int, GEOM_Actor*>::iterator iter = myMapOfActors.begin();
+ for ( ; iter != myMapOfActors.end(); ++iter )
+ iter.value()->RemoveFromRender( theRenderer );
+}
+
+void SMESH_PreviewActorsCollection::SetSelector(SVTK_Selector* theSelector)
+{
+ mySelector = theSelector;
+}
+
+void SMESH_PreviewActorsCollection::HighlightAll( bool theHighlight ){
+ QMap<int, GEOM_Actor*>::iterator iter = myMapOfActors.begin();
+ for ( ; iter != myMapOfActors.end(); ++iter )
+ iter.value()->Highlight( theHighlight );
+}
+
+void SMESH_PreviewActorsCollection::HighlightID( int index ){
+ GEOM_Actor* anActor = GetActorByIndex( index );
+ if ( anActor && !anActor->isHighlighted() )
+ anActor->Highlight( true );
+}
+
+void SMESH_PreviewActorsCollection::SetShown( bool shown ){
+ QMap<int, GEOM_Actor*>::iterator iter = myMapOfActors.begin();
+ for ( ; iter != myMapOfActors.end(); ++iter )
+ iter.value()->SetVisibility( shown );
+}
--- /dev/null
+// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 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.com
+//
+// SMESH OBJECT : interactive object for SMESH visualization
+// File : SMESH_PreviewActorsCollection.h
+// Author : OCN
+// Module : SMESH
+// $Header: /home/server/cvs/SMESH/SMESH_SRC/src/OBJECT/SMESH_PreviewActorsCollection.h,v 1
+//
+#ifndef SMESH_PREVIEW_ACTOR_COLLECTION_H
+#define SMESH_PREVIEW_ACTOR_COLLECTION_H
+
+#include <SMESH_Actor.h>
+#include <GEOM_Actor.h>
+#include "SMESH_Object.h"
+#include <TopoDS_Shape.hxx>
+#include <SMDS_SetIterator.hxx>
+#include <TopAbs_ShapeEnum.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <QString>
+#include <QMap>
+
+class vtkRenderer;
+class GEOM_Actor;
+
+class SMESHOBJECT_EXPORT SMESH_PreviewActorsCollection
+{
+ public:
+ SMESH_PreviewActorsCollection();
+ ~SMESH_PreviewActorsCollection();
+
+ virtual void AddToRender(vtkRenderer* theRenderer);
+ virtual void RemoveFromRender(vtkRenderer* theRenderer);
+
+ bool Init( const TopoDS_Shape& theShape, TopAbs_ShapeEnum subShapeType = TopAbs_EDGE, const QString& = QString("") );
+
+ void SetSelector( SVTK_Selector* );
+
+ void HighlightAll( bool );
+ void HighlightID( int );
+
+ GEOM_Actor* GetActorByIndex( int );
+
+ int GetIndexByShape( const TopoDS_Shape& );
+
+ void SetShown( bool );
+
+ protected:
+ GEOM_Actor* createActor( const TopoDS_Shape& );
+
+ protected:
+ TopoDS_Shape myMainShape;
+ SVTK_Selector* mySelector;
+ vtkRenderer* myRenderer;
+ TopTools_IndexedMapOfShape myMapOfShapes;
+ QMap<int, GEOM_Actor*> myMapOfActors;
+};
+
+
+#endif //SMESH_DEVICE_ACTOR_COLLECTION_H
Dlg->setType( type() );
retrieveParams();
Dlg->show();
+ Dlg->resize( Dlg->minimumSizeHint() );
if ( !myEventLoop )
myEventLoop = new QEventLoop( this );
myEventLoop->exec(); // make myDlg not modal
return myHypo;
}
+void SMESHGUI_GenericHypothesisCreator::setShapeEntry( const QString& theEntry )
+{
+ myShapeEntry = theEntry;
+}
+
//================================================================================
/*!
* \brief Return hypothesis containing initial parameters
QString hypType() const;
QString hypName() const;
bool isCreation() const;
+
+ QString getShapeEntry() const { return myShapeEntry; }
+ void setShapeEntry( const QString& theEntry );
protected:
struct StdParam
bool myIsCreate;
QtxDialog* myDlg;
QEventLoop* myEventLoop;
+ QString myShapeEntry;
};
class SMESHGUI_HypothesisDlg : public QtxDialog
int obj = myDlg->getActiveObject();
removeCustomFilters(); // Issue 0020170
+
+ // Set Geometry
+ QStringList aList;
+ myDlg->selectedObject( SMESHGUI_MeshDlg::Geom, aList );
+ if (aList.count() != 0)
+ aCreator->setShapeEntry( aList.first() );
+ else
+ aCreator->setShapeEntry( QString() );
+
myDlg->setEnabled( false );
aCreator->create(initParamHyp, aHypName, myDlg);
onActivateObject( obj ); // Issue 0020170. Restore filters
getInitParamsHypothesis( aHyp->GetName(), aHyp->GetLibName());
aCreator->setInitParamsHypothesis( initParamHyp );
+ // Set Geometry
+ QStringList aList;
+ myDlg->selectedObject( SMESHGUI_MeshDlg::Geom, aList );
+ if (aList.count() > 0)
+ aCreator->setShapeEntry( aList.first() );
+ else
+ aCreator->setShapeEntry( "" );
+
int obj = myDlg->getActiveObject();
removeCustomFilters(); // Issue 0020170
myDlg->setEnabled( false );
*/
//=============================================================================
+void StdMeshers_Arithmetic1D::SetReversedEdges( std::vector<int>& ids )
+{
+ if ( ids != _edgeIDs ) {
+ _edgeIDs = ids;
+
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
ostream & StdMeshers_Arithmetic1D::SaveTo(ostream & save)
{
- save << _begLength << " " << _endLength;
+ int listSize = _edgeIDs.size();
+ save << _begLength << " " << _endLength << " " << listSize;
+
+ if ( listSize > 0 ) {
+ for ( int i = 0; i < listSize; i++)
+ save << " " << _edgeIDs[i];
+ save << " " << _objEntry;
+ }
+
return save;
}
istream & StdMeshers_Arithmetic1D::LoadFrom(istream & load)
{
bool isOK = true;
+ int intVal;
isOK = (load >> _begLength);
if (!isOK)
load.clear(ios::badbit | load.rdstate());
isOK = (load >> _endLength);
+
if (!isOK)
load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> intVal);
+ if (isOK && intVal > 0) {
+ _edgeIDs.reserve( intVal );
+ for (int i = 0; i < _edgeIDs.capacity() && isOK; i++) {
+ isOK = (load >> intVal);
+ if ( isOK ) _edgeIDs.push_back( intVal );
+ }
+ isOK = (load >> _objEntry);
+ }
+
return load;
}
#ifndef _SMESH_ARITHMETIC1D_HXX_
#define _SMESH_ARITHMETIC1D_HXX_
+
+
#include "SMESH_StdMeshers.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
+#include <vector>
+
class STDMESHERS_EXPORT StdMeshers_Arithmetic1D:
public SMESH_Hypothesis
{
double GetLength(bool isStartLength) const;
+ void SetReversedEdges( std::vector<int>& ids);
+
+ void SetObjectEntry( const char* entry ) { _objEntry = entry; }
+
+ const char* GetObjectEntry() { return _objEntry.c_str(); }
+
+ const std::vector<int>& GetReversedEdges() const { return _edgeIDs; }
+
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
friend std::ostream& operator << (std::ostream & save, StdMeshers_Arithmetic1D & hyp);
protected:
double _begLength, _endLength;
+ std::vector<int> _edgeIDs;
+ std::string _objEntry;
};
#endif
ostream & StdMeshers_NumberOfSegments::SaveTo(ostream & save)
{
+ int listSize = _edgeIDs.size();
save << _numberOfSegments << " " << (int)_distrType;
switch (_distrType)
{
if (_distrType == DT_TabFunc || _distrType == DT_ExprFunc)
save << " " << _convMode;
+
+ if ( _distrType != DT_Regular && listSize > 0 ) {
+ save << " " << listSize;
+ for ( int i = 0; i < listSize; i++ )
+ save << " " << _edgeIDs[i];
+ save << " " << _objEntry;
+ }
return save;
}
load.clear(ios::badbit | load.rdstate());
}
+ // load reversed edges IDs
+ int intVal;
+ isOK = (load >> intVal);
+ if ( isOK && _distrType != DT_Regular && intVal > 0 ) {
+ _edgeIDs.reserve( intVal );
+ for (int i = 0; i < _edgeIDs.capacity() && isOK; i++) {
+ isOK = (load >> intVal);
+ if ( isOK ) _edgeIDs.push_back( intVal );
+ }
+ isOK = (load >> _objEntry);
+ }
+
return load;
}
return (_numberOfSegments = dflts._nbSegments );
}
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+void StdMeshers_NumberOfSegments::SetReversedEdges( std::vector<int>& ids )
+{
+ if ( ids != _edgeIDs ) {
+ _edgeIDs = ids;
+
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
int ConversionMode() const
throw (SALOME_Exception);
+ void SetReversedEdges( std::vector<int>& ids);
+
+ void SetObjectEntry( const char* entry ) { _objEntry = entry; }
+
+ const char* GetObjectEntry() { return _objEntry.c_str(); }
+
+ const std::vector<int>& GetReversedEdges() const { return _edgeIDs; }
/*!
* \brief Initialize number of segments by the mesh built on the geometry
std::vector<double> _table, _distr; //!< the table for DT_TabFunc, a sequence of pairs of numbers
std::string _func; //!< the expression of the function for DT_ExprFunc
int _convMode; //!< flag of conversion mode: 0=exponent, 1=cut negative
+ std::vector<int> _edgeIDs; //!< list of reversed edges ids
+ std::string _objEntry; //!< Entry of the main object to reverse edges
};
#endif
{
case StdMeshers_NumberOfSegments::DT_Scale:
_value[ SCALE_FACTOR_IND ] = hyp->GetScaleFactor();
+ _revEdgesIDs = hyp->GetReversedEdges();
break;
case StdMeshers_NumberOfSegments::DT_TabFunc:
_vvalue[ TAB_FUNC_IND ] = hyp->GetTableFunction();
+ _revEdgesIDs = hyp->GetReversedEdges();
break;
case StdMeshers_NumberOfSegments::DT_ExprFunc:
_svalue[ EXPR_FUNC_IND ] = hyp->GetExpressionFunction();
+ _revEdgesIDs = hyp->GetReversedEdges();
break;
case StdMeshers_NumberOfSegments::DT_Regular:
break;
_value[ END_LENGTH_IND ] = hyp->GetLength( false );
ASSERT( _value[ BEG_LENGTH_IND ] > 0 && _value[ END_LENGTH_IND ] > 0 );
_hypType = ARITHMETIC_1D;
+
+ _revEdgesIDs = hyp->GetReversedEdges();
+
aStatus = SMESH_Hypothesis::HYP_OK;
}
_value[ END_LENGTH_IND ] = hyp->GetLength( false );
ASSERT( _value[ BEG_LENGTH_IND ] > 0 && _value[ END_LENGTH_IND ] > 0 );
_hypType = BEG_END_LENGTH;
+
+ _revEdgesIDs = hyp->GetReversedEdges();
+
aStatus = SMESH_Hypothesis::HYP_OK;
}
bool reversed = false;
if ( !_mainEdge.IsNull() )
reversed = ( _mainEdge.Orientation() == TopAbs_REVERSED );
+ else if ( _revEdgesIDs.size() > 0 ) {
+ for ( int i = 0; i < _revEdgesIDs.size(); i++)
+ if ( _revEdgesIDs[i] == shapeID )
+ reversed = true;
+ }
BRepAdaptor_Curve C3d( E );
double length = EdgeLength( E );
const TopoDS_Edge & EE = TopoDS::Edge(theShape);
TopoDS_Edge E = TopoDS::Edge(EE.Oriented(TopAbs_FORWARD));
- int shapeID = meshDS->ShapeToIndex( E );
+ // int shapeID = meshDS->ShapeToIndex( E );
double f, l;
Handle(Geom_Curve) Curve = BRep_Tool::Curve(E, f, l);
int _ivalue[3];
std::vector<double> _vvalue[1];
std::string _svalue[1];
+ std::vector<int> _revEdgesIDs;
// a source of propagated hypothesis, is set by CheckHypothesis()
// always called before Compute()
*/
//=============================================================================
+void StdMeshers_StartEndLength::SetReversedEdges( std::vector<int>& ids )
+{
+ if ( ids != _edgeIDs ) {
+ _edgeIDs = ids;
+
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
ostream & StdMeshers_StartEndLength::SaveTo(ostream & save)
{
- save << _begLength << " " <<_endLength;
+ int listSize = _edgeIDs.size();
+ save << _begLength << " " << _endLength << " " << listSize;
+
+ if ( listSize > 0 ) {
+ for ( int i = 0; i < listSize; i++) {
+ save << " " << _edgeIDs[i];
+ }
+ save << " " << _objEntry;
+ }
+
return save;
}
istream & StdMeshers_StartEndLength::LoadFrom(istream & load)
{
bool isOK = true;
+ int intVal;
isOK = (load >> _begLength);
if (!isOK)
load.clear(ios::badbit | load.rdstate());
isOK = (load >> _endLength);
+
if (!isOK)
load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> intVal);
+ if (isOK && intVal > 0) {
+ _edgeIDs.reserve( intVal );
+ for (int i = 0; i < _edgeIDs.capacity() && isOK; i++) {
+ isOK = (load >> intVal);
+ if ( isOK ) _edgeIDs.push_back( intVal );
+ }
+ isOK = (load >> _objEntry);
+ }
+
return load;
}
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
+#include <vector>
+
class STDMESHERS_EXPORT StdMeshers_StartEndLength:public SMESH_Hypothesis
{
public:
void SetLength(double length, bool isStartLength) throw(SALOME_Exception);
double GetLength(bool isStartLength) const;
+
+ void SetReversedEdges( std::vector<int>& ids);
+
+ const std::vector<int>& GetReversedEdges() const { return _edgeIDs; }
+
+ void SetObjectEntry( const char* entry ) { _objEntry = entry; }
+
+ const char* GetObjectEntry() { return _objEntry.c_str(); }
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
protected:
double _begLength, _endLength;
+ std::vector<int> _edgeIDs;
+ std::string _objEntry;
};
#endif
StdMeshersGUI_DistrTable.h \
StdMeshersGUI_NbSegmentsCreator.h \
StdMeshersGUI_ObjectReferenceParamWdg.h \
- StdMeshersGUI_LayerDistributionParamWdg.h
+ StdMeshersGUI_LayerDistributionParamWdg.h \
+ StdMeshersGUI_EdgeDirectionParamWdg.h
# Libraries targets
lib_LTLIBRARIES = libStdMeshersGUI.la
StdMeshersGUI_DistrTable.cxx \
StdMeshersGUI_NbSegmentsCreator.cxx \
StdMeshersGUI_ObjectReferenceParamWdg.cxx \
- StdMeshersGUI_LayerDistributionParamWdg.cxx
+ StdMeshersGUI_LayerDistributionParamWdg.cxx \
+ StdMeshersGUI_EdgeDirectionParamWdg.cxx
MOC_FILES = \
StdMeshersGUI_StdHypothesisCreator_moc.cxx \
StdMeshersGUI_DistrTable_moc.cxx \
StdMeshersGUI_NbSegmentsCreator_moc.cxx \
StdMeshersGUI_ObjectReferenceParamWdg_moc.cxx \
- StdMeshersGUI_LayerDistributionParamWdg_moc.cxx
+ StdMeshersGUI_LayerDistributionParamWdg_moc.cxx \
+ StdMeshersGUI_EdgeDirectionParamWdg_moc.cxx
nodist_libStdMeshersGUI_la_SOURCES= \
$(MOC_FILES)
--- /dev/null
+// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 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.com
+//
+// File : StdMeshersGUI_EdgeDirectionParamWdg.cxx
+// Author : Open CASCADE S.A.S. (dmv)
+// SMESH includes
+//
+#include "StdMeshersGUI_EdgeDirectionParamWdg.h"
+
+// SMESH Includes
+#include <SMESH_Type.h>
+#include "SMESHGUI_MeshUtils.h"
+#include <SMESH_Actor.h>
+#include <SMESH_PreviewActorsCollection.h>
+#include <SMESH_ActorUtils.h>
+#include "SMESHGUI_GroupUtils.h"
+#include "SMESH_Gen_i.hxx"
+#include "SMESHGUI_GEOMGenUtils.h"
+
+// SVTK Includes
+#include <SVTK_ViewWindow.h>
+#include <SVTK_ViewModel.h>
+#include <SVTK_ViewWindow.h>
+#include <SVTK_Selector.h>
+
+// SALOME GUI includes
+#include <SALOME_ListIO.hxx>
+#include <LightApp_SelectionMgr.h>
+#include <SALOME_ListIteratorOfListIO.hxx>
+
+// SUIT Includes
+#include <SUIT_ResourceMgr.h>
+
+// GEOM Includes
+#include <GEOMBase.h>
+
+// Qt includes
+#include <QPushButton>
+#include <QGridLayout>
+#include <QListWidget>
+#include <QCheckBox>
+#include <QLineEdit>
+
+// OCCT includes
+#include <TColStd_MapOfInteger.hxx>
+#include <TColStd_IndexedMapOfInteger.hxx>
+#include <TopoDS_Shape.hxx>
+#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+
+// SALOME KERNEL includes
+#include <SALOMEDS_SObject.hxx>
+
+#define SPACING 6
+#define MARGIN 0
+
+//================================================================================
+/*!
+ * Constructor
+ */
+//================================================================================
+
+StdMeshersGUI_EdgeDirectionParamWdg
+::StdMeshersGUI_EdgeDirectionParamWdg( QWidget * parent ):
+ QWidget( parent )
+{
+ QPixmap image0( SMESH::GetResourceMgr( mySMESHGUI )->loadPixmap( "SMESH", tr( "ICON_SELECT" ) ) );
+
+ QGridLayout* edgesLayout = new QGridLayout( this );
+ edgesLayout->setMargin( MARGIN );
+ edgesLayout->setSpacing( SPACING );
+
+ myListWidget = new QListWidget( this );
+ myAddButton = new QPushButton( tr( "SMESH_BUT_ADD" ), this );
+ myRemoveButton = new QPushButton( tr( "SMESH_BUT_REMOVE" ), this );
+ myListWidget->setSelectionMode( QListWidget::ExtendedSelection );
+
+ edgesLayout->addWidget(myListWidget, 0, 0, 3, 3);
+ edgesLayout->addWidget(myAddButton, 0, 4);
+ edgesLayout->addWidget(myRemoveButton, 1, 4);
+
+ edgesLayout->setRowStretch(2, 5);
+ edgesLayout->setColumnStretch(2, 5);
+
+ setLayout( edgesLayout );
+ setMinimumWidth( 300 );
+
+ init();
+}
+
+//================================================================================
+/*!
+ * Destructor
+ */
+//================================================================================
+
+StdMeshersGUI_EdgeDirectionParamWdg::~StdMeshersGUI_EdgeDirectionParamWdg()
+{
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI )) {
+ myPreviewActor->RemoveFromRender( myRenderer );
+ aViewWindow->Repaint();
+ }
+ myEntry = "";
+ myParamValue = "";
+ myMainShape.Nullify();
+
+ delete myPreviewActor;
+}
+
+//================================================================================
+/*!
+ * Create a layout, initialize fields
+ */
+//================================================================================
+
+void StdMeshersGUI_EdgeDirectionParamWdg::init()
+{
+ myParamValue = "";
+ myListOfIDs.clear();
+ mySelectedIDs.clear();
+
+ mySMESHGUI = SMESHGUI::GetSMESHGUI();
+ mySelectionMgr = SMESH::GetSelectionMgr( mySMESHGUI );
+ mySelector = (SMESH::GetViewWindow( mySMESHGUI ))->GetSelector();
+
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode( ActorSelection );
+
+ connect( myAddButton, SIGNAL(clicked()), SLOT(onAdd()));
+ connect( myRemoveButton, SIGNAL(clicked()), SLOT(onRemove()));
+
+ connect( mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
+ connect( myListWidget, SIGNAL(itemSelectionChanged()), this, SLOT(onListSelectionChanged()));
+
+ updateState();
+}
+
+//================================================================================
+/*!
+ * Create a layout, initialize fields
+ */
+//================================================================================
+
+void StdMeshersGUI_EdgeDirectionParamWdg::showPreview( bool visible)
+{
+ if ( myIsShown != visible ) {
+ myPreviewActor->SetShown( visible );
+
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->Repaint();
+
+ myIsShown = visible;
+ }
+}
+
+//=================================================================================
+// function : SelectionIntoArgument()
+// purpose : Called when selection as changed or other case
+//=================================================================================
+void StdMeshersGUI_EdgeDirectionParamWdg::SelectionIntoArgument()
+{
+ mySelectedIDs.clear();
+
+ // get selected mesh
+ SALOME_ListIO aList;
+ mySelectionMgr->selectedObjects( aList );
+ int nbSel = aList.Extent();
+
+ if (nbSel < 1)
+ return;
+
+ SALOME_ListIteratorOfListIO anIt (aList);
+
+ for ( ; anIt.More(); anIt.Next()) { // Loop on selected objects
+ Handle(SALOME_InteractiveObject) IO = anIt.Value();
+
+ GEOM::GEOM_Object_var aGeomObj = GetGeomObjectByEntry( IO->getEntry() );
+ if ( !CORBA::is_nil( aGeomObj ) ) { // Selected Object From Study
+ GEOM::GEOM_Object_ptr aGeomFatherObj = aGeomObj->GetMainShape();
+ QString aFatherEntry = "";
+ QString aMainFatherEntry = "";
+ TopoDS_Shape shape;
+ if ( !CORBA::is_nil( aGeomFatherObj ) ) {
+ // Get Main Shape
+ GEOM::GEOM_Object_var aGeomMain = GetGeomObjectByEntry( myEntry );
+ if ( !CORBA::is_nil( aGeomMain ) || aGeomMain->GetType() == 37 ) { // Main Shape is a Group
+ GEOM::GEOM_Object_ptr aMainFatherObj = aGeomMain->GetMainShape();
+ if ( !CORBA::is_nil( aMainFatherObj ) )
+ aMainFatherEntry = aMainFatherObj->GetStudyEntry();
+ }
+ aFatherEntry = aGeomFatherObj->GetStudyEntry();
+ }
+
+ if ( aFatherEntry != "" && ( aFatherEntry == myEntry || aFatherEntry == aMainFatherEntry ) ) {
+ if ( aGeomObj->GetType() == 37 /*GEOM_GROUP*/ ) { // Selected Group that belongs the main object
+ GEOMBase::GetShape(aGeomObj, shape);
+ if ( !shape.IsNull() ) {
+ TopExp_Explorer exp( shape, TopAbs_EDGE );
+ for ( ; exp.More(); exp.Next() ) {
+ int index = myPreviewActor->GetIndexByShape( exp.Current() );
+ if ( index ) {
+ mySelectedIDs.append( index );
+ myPreviewActor->HighlightID( index );
+ }
+ }
+ }
+ } else if ( aGeomObj->GetType() == 28 /*GEOM_SUBSHAPE*/ ) {
+ GEOMBase::GetShape(aGeomObj, shape);
+ if ( !shape.IsNull() && shape.ShapeType() == TopAbs_EDGE ) {
+ int index = myPreviewActor->GetIndexByShape( shape );
+ if ( index ) {
+ mySelectedIDs.append( index );
+ myPreviewActor->HighlightID( index );
+ }
+ }
+ }
+ }
+ } else { // Selected Actor from Actor Collection
+ QString anEntry = IO->getEntry();
+ QString str = "_";
+ int index = anEntry.lastIndexOf( str );
+ anEntry.remove(0, index+1);
+ int ind = anEntry.toInt();
+ if ( ind )
+ mySelectedIDs.append( ind );
+ }
+ }
+}
+
+//=================================================================================
+// function : onAdd()
+// purpose : Called when Add Button Clicked
+//=================================================================================
+void StdMeshersGUI_EdgeDirectionParamWdg::onAdd()
+{
+ if ( mySelectedIDs.size() < 1 )
+ return;
+
+ myListWidget->blockSignals( true );
+ for (int i = 0; i < mySelectedIDs.size(); i++) {
+ if ( myListOfIDs.indexOf( mySelectedIDs.at(i) ) == -1 ) {
+ QString anID = QString(" %1").arg( mySelectedIDs.at(i) );
+
+ QListWidgetItem* anItem = new QListWidgetItem( anID, myListWidget );
+ anItem->setSelected(true);
+
+ myListOfIDs.append( mySelectedIDs.at(i) );
+ }
+ }
+ onListSelectionChanged();
+
+ myListWidget->blockSignals( false );
+}
+
+//=================================================================================
+// function : onRemove()
+// purpose : Called when Remove Button Clicked
+//=================================================================================
+void StdMeshersGUI_EdgeDirectionParamWdg::onRemove()
+{
+ if ( myListWidget->count() < 1 )
+ return;
+
+ myListWidget->blockSignals( true );
+ QList<QListWidgetItem*> selItems = myListWidget->selectedItems();
+ QListWidgetItem* item;
+ foreach(item, selItems) {
+ QString idStr = item->text();
+ int id = idStr.toInt();
+
+ int index = myListOfIDs.indexOf( id );
+ myListOfIDs.removeAt( index );
+ delete item;
+ }
+
+ onListSelectionChanged();
+ myListWidget->blockSignals( false );
+}
+
+//=================================================================================
+// function : onListSelectionChanged()
+// purpose : Called when selection in element list is changed
+//=================================================================================
+void StdMeshersGUI_EdgeDirectionParamWdg::onListSelectionChanged()
+{
+ mySelectionMgr->clearSelected();
+ TColStd_MapOfInteger aIndexes;
+ QList<QListWidgetItem*> selItems = myListWidget->selectedItems();
+ QListWidgetItem* anItem;
+ foreach(anItem, selItems)
+ myPreviewActor->HighlightID( anItem->text().toInt() );
+}
+
+//=================================================================================
+// function : setGeomShape
+// purpose : Called to set geometry
+//================================================================================
+void StdMeshersGUI_EdgeDirectionParamWdg::SetMainShapeEntry( const QString& theEntry )
+{
+ if ( theEntry != "") {
+ myParamValue = theEntry;
+ myEntry = theEntry;
+ myMainShape = GetTopoDSByEntry( theEntry );
+ updateState();
+ }
+}
+
+//=================================================================================
+// function : updateState
+// purpose : update Widget state
+//=================================================================================
+void StdMeshersGUI_EdgeDirectionParamWdg::updateState()
+{
+ bool state = false;
+ if ( !myMainShape.IsNull() )
+ state = true;
+
+ myListWidget->setEnabled( state );
+ myAddButton->setEnabled( state );
+ myRemoveButton->setEnabled( state );
+
+ if (state = true) {
+ myPreviewActor = new SMESH_PreviewActorsCollection();
+ myPreviewActor->SetSelector( mySelector );
+ myPreviewActor->Init( myMainShape, TopAbs_EDGE, myEntry );
+ myPreviewActor->SetShown( false );
+ myIsShown = false;
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI )) {
+ myRenderer = aViewWindow->getRenderer();
+ myPreviewActor->AddToRender( myRenderer );
+ aViewWindow->Repaint();
+ }
+ }
+}
+
+//=================================================================================
+// function : GetGeomObjectByEntry
+// purpose : Called to get GeomObject
+//=================================================================================
+GEOM::GEOM_Object_var StdMeshersGUI_EdgeDirectionParamWdg::GetGeomObjectByEntry( const QString& theEntry )
+{
+ GEOM::GEOM_Object_var aGeomObj;
+ SALOMEDS::Study_var aStudy = SMESHGUI::GetSMESHGen()->GetCurrentStudy();
+ if (aStudy != 0) {
+ SALOMEDS::SObject_var aSObj = aStudy->FindObjectID( theEntry.toLatin1().data() );
+ SALOMEDS::GenericAttribute_var anAttr;
+
+ if (!aSObj->_is_nil() && aSObj->FindAttribute(anAttr, "AttributeIOR")) {
+ SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+ CORBA::String_var aVal = anIOR->Value();
+ CORBA::Object_var obj = aStudy->ConvertIORToObject(aVal);
+ aGeomObj = GEOM::GEOM_Object::_narrow(obj);
+ }
+ }
+ return aGeomObj;
+}
+
+//=================================================================================
+// function : setObjectByEntry
+// purpose : Called to get GeomObject
+//=================================================================================
+TopoDS_Shape StdMeshersGUI_EdgeDirectionParamWdg::GetTopoDSByEntry( const QString& theEntry )
+{
+ TopoDS_Shape shape;
+ GEOM::GEOM_Object_var aGeomObj = GetGeomObjectByEntry( theEntry );
+ GEOMBase::GetShape(aGeomObj, shape);
+ return shape;
+}
+
+//=================================================================================
+// function : GetListOfIds
+// purpose : Called to get the list of Edges IDs
+//=================================================================================
+SMESH::long_array_var StdMeshersGUI_EdgeDirectionParamWdg::GetListOfIDs()
+{
+ SMESH::long_array_var anArray = new SMESH::long_array;
+ int size = myListOfIDs.size();
+ anArray->length( size );
+ if ( size ) {
+ for (int i = 0; i < size; i++) {
+ anArray[i] = myListOfIDs.at(i);
+ }
+ }
+ return anArray;
+}
+
+//=================================================================================
+// function : SetListOfIds
+// purpose : Called to set the list of Edges IDs
+//=================================================================================
+void StdMeshersGUI_EdgeDirectionParamWdg::SetListOfIDs( SMESH::long_array_var theIds)
+{
+ mySelectedIDs.clear();
+ myListOfIDs.clear();
+ int size = theIds->length();
+ for ( int i = 0; i < size; i++ )
+ mySelectedIDs.append( theIds[ i ] );
+ onAdd();
+}
--- /dev/null
+// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 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.com
+//
+// File : StdMeshersGUI_EdgeDirectionParamWdg.h
+// Author : Open CASCADE S.A.S. (dmv)
+//
+#ifndef STDMESHERSGUI_EDGEDIRECTIONPARAMWGD_H
+#define STDMESHERSGUI_EDGEDIRECTIONPARAMWGD_H
+
+// SMESH includes
+#include <SMESHGUI.h>
+#include "SMESH_StdMeshersGUI.hxx"
+#include "SMESH_SMESHGUI.hxx"
+
+// Qt includes
+#include <QWidget>
+#include <QStringList>
+#include <TopoDS_Shape.hxx>
+
+#include <SMESHGUI_VTKUtils.h>
+
+class SMESHGUI;
+class LightApp_SelectionMgr;
+class SVTK_Selector;
+class QPushButton;
+class QLineEdit;
+class QCheckBox;
+class QListWidget;
+class SMESH_Actor;
+class SMESH_PreviewActorsCollection;
+class vtkRenderer;
+
+class STDMESHERSGUI_EXPORT StdMeshersGUI_EdgeDirectionParamWdg : public QWidget
+{
+ Q_OBJECT
+
+public:
+ StdMeshersGUI_EdgeDirectionParamWdg( QWidget* parent = 0 );
+ ~StdMeshersGUI_EdgeDirectionParamWdg();
+
+ SMESH::long_array_var GetListOfIDs();
+ void SetListOfIDs( SMESH::long_array_var );
+
+ void SetMainShapeEntry( const QString& theEntry );
+ const char* GetMainShapeEntry() { return myEntry.toLatin1().data();}
+
+ TopoDS_Shape GetMainShape() { return myMainShape; }
+
+ static GEOM::GEOM_Object_var GetGeomObjectByEntry( const QString& );
+ static TopoDS_Shape GetTopoDSByEntry( const QString& );
+
+ QString GetValue() const { return myParamValue; }
+
+ void showPreview ( bool );
+
+private:
+ void updateState();
+
+private slots:
+ void onAdd();
+ void onRemove();
+ void SelectionIntoArgument();
+ void onListSelectionChanged();
+
+private:
+ void init();
+
+private:
+ SMESHGUI* mySMESHGUI;
+ LightApp_SelectionMgr* mySelectionMgr; /* User shape selection */
+ SVTK_Selector* mySelector;
+ SMESH::SMESH_Mesh_var myMesh;
+ TopoDS_Shape myMainShape;
+ QString myEntry;
+ vtkRenderer* myRenderer;
+
+ QListWidget* myListWidget;
+ QPushButton* myAddButton;
+ QPushButton* myRemoveButton;
+ QList<int> mySelectedIDs;
+ QList<int> myListOfIDs;
+
+ QString myParamValue;
+ bool myIsShown;
+
+ SMESH_PreviewActorsCollection* myPreviewActor;
+};
+
+#endif // STDMESHERSGUI_EDGEDIRECTIONPARAMWGD_H
#include "StdMeshersGUI_NbSegmentsCreator.h"
#include "StdMeshersGUI_DistrTable.h"
#include "StdMeshersGUI_DistrPreview.h"
+#include "StdMeshersGUI_EdgeDirectionParamWdg.h"
#include <SMESHGUI.h>
#include <SMESHGUI_Utils.h>
QVBoxLayout* lay = new QVBoxLayout( fr );
lay->setMargin( 0 );
- lay->setSpacing( 0 );
+ lay->setSpacing( SPACING );
QGroupBox* GroupC1 = new QGroupBox( tr( "SMESH_ARGUMENTS" ), fr );
lay->addWidget( GroupC1 );
myPreviewRow = row;
row++;
+ // 8) reverce edge parameters
+ myReversedEdgesBox = new QGroupBox(tr( "SMESH_REVERCE_EDGES" ), fr);
+ QHBoxLayout* edgeLay = new QHBoxLayout( myReversedEdgesBox );
+
+ myDirectionWidget = new StdMeshersGUI_EdgeDirectionParamWdg();
+ QString anEntry = getShapeEntry();
+ if ( anEntry == "" )
+ anEntry = h->GetObjectEntry();
+ myDirectionWidget->SetMainShapeEntry( anEntry );
+ myDirectionWidget->SetListOfIDs( h->GetReversedEdges() );
+ edgeLay->addWidget( myDirectionWidget );
+
+ lay->addWidget( myReversedEdgesBox );
+
connect( myNbSeg, SIGNAL( valueChanged( const QString& ) ), this, SLOT( onValueChanged() ) );
connect( myDistr, SIGNAL( activated( int ) ), this, SLOT( onValueChanged() ) );
connect( myTable, SIGNAL( valueChanged( int, int ) ), this, SLOT( onValueChanged() ) );
connect( myExpr, SIGNAL( textChanged( const QString& ) ), this, SLOT( onValueChanged() ) );
- connect( myConv, SIGNAL( cuttonClicked( int ) ), this, SLOT( onValueChanged() ) );
+ connect( myConv, SIGNAL( buttonClicked( int ) ), this, SLOT( onValueChanged() ) );
return fr;
}
if( distr==2 || distr==3 )
h->SetConversionMode( h_data.myConv );
+ if( distr==1 || distr==2 || distr==3 ) {
+ h->SetReversedEdges( myDirectionWidget->GetListOfIDs() );
+ h->SetObjectEntry( myDirectionWidget->GetMainShapeEntry() );
+ }
+
if( distr==2 )
h->SetTableFunction( h_data.myTable );
myScale->setShown( distr==1 );
myLScale->setShown( distr==1 );
+ myReversedEdgesBox->setShown( !distr==0 );
+ myDirectionWidget->showPreview( !distr==0 );
bool isFunc = distr==2 || distr==3;
myPreview->setShown( isFunc );
if ( (QtxComboBox*)sender() == myDistr && dlg() ) {
QApplication::instance()->processEvents();
+ myGroupLayout->invalidate();
+ dlg()->layout()->invalidate();
dlg()->updateGeometry();
- dlg()->setMinimumSize( dlg()->minimumSizeHint().width(), dlg()->minimumSizeHint().height() );
+ dlg()->setMinimumSize( dlg()->minimumSizeHint() );
dlg()->resize( dlg()->minimumSize() );
+ QApplication::instance()->processEvents();
}
}
class QGroupBox;
class QGridLayout;
class QRadioButton;
+class StdMeshersGUI_EdgeDirectionParamWdg;
typedef struct
{
QGridLayout* myGroupLayout;
int myTableRow, myPreviewRow;
QRadioButton* myCutNeg;
+ QGroupBox* myReversedEdgesBox;
+
+ StdMeshersGUI_EdgeDirectionParamWdg* myDirectionWidget;
};
#endif // STDMESHERSGUI_NBSEGMENTSCREATOR_H
#include <SMESH_NumberFilter.hxx>
#include "StdMeshersGUI_ObjectReferenceParamWdg.h"
#include "StdMeshersGUI_LayerDistributionParamWdg.h"
+#include "StdMeshersGUI_EdgeDirectionParamWdg.h"
#include <SALOMEDSClient_Study.hxx>
// SALOME GUI includes
StdMeshers::StdMeshers_Arithmetic1D_var h =
StdMeshers::StdMeshers_Arithmetic1D::_narrow( hypothesis() );
+ StdMeshersGUI_EdgeDirectionParamWdg* w =
+ widget< StdMeshersGUI_EdgeDirectionParamWdg >( 2 );
+
h->SetLength( params[0].myValue.toDouble(), true );
h->SetParameters(SMESHGUI::JoinObjectParameters(aVariablesList));
h->SetLength( params[1].myValue.toDouble(), false );
h->SetParameters(SMESHGUI::JoinObjectParameters(aVariablesList));
+ if (w) {
+ h->SetReversedEdges( w->GetListOfIDs() );
+ const char * entry = w->GetMainShapeEntry();
+ h->SetObjectEntry( entry );
+ }
}
else if( hypType()=="MaxElementArea" )
{
StdMeshers::StdMeshers_StartEndLength_var h =
StdMeshers::StdMeshers_StartEndLength::_narrow( hypothesis() );
+ StdMeshersGUI_EdgeDirectionParamWdg* w =
+ widget< StdMeshersGUI_EdgeDirectionParamWdg >( 2 );
+
h->SetLength( params[0].myValue.toDouble(), true );
h->SetParameters(SMESHGUI::JoinObjectParameters(aVariablesList));
h->SetLength( params[1].myValue.toDouble(), false );
h->SetParameters(SMESHGUI::JoinObjectParameters(aVariablesList));
+ if (w) {
+ h->SetReversedEdges( w->GetListOfIDs() );
+ h->SetObjectEntry( w->GetMainShapeEntry() );
+ }
}
else if( hypType()=="Deflection1D" )
{
item.myValue = h->GetLength( true );
p.append( item );
+ customWidgets()->append (0);
+
item.myName = tr( "SMESH_END_LENGTH_PARAM" );
if(!initVariableName(aParameters,item,1))
item.myValue = h->GetLength( false );
p.append( item );
+
+ customWidgets()->append (0);
+
+ item.myName = tr( "SMESH_REVERCE_EDGES" );
+ p.append( item );
+
+ StdMeshersGUI_EdgeDirectionParamWdg* aDirectionWidget = new StdMeshersGUI_EdgeDirectionParamWdg();
+ QString anEntry = SMESHGUI_GenericHypothesisCreator::getShapeEntry();
+ if ( anEntry == "" )
+ anEntry = h->GetObjectEntry();
+ aDirectionWidget->SetMainShapeEntry( anEntry );
+ aDirectionWidget->SetListOfIDs( h->GetReversedEdges() );
+ aDirectionWidget->showPreview( true );
+ customWidgets()->append ( aDirectionWidget );
}
else if( hypType()=="MaxElementArea" )
{
if(!initVariableName(aParameters,item,0))
item.myValue = h->GetLength( true );
p.append( item );
+ customWidgets()->append(0);
item.myName = tr( "SMESH_END_LENGTH_PARAM" );
if(!initVariableName(aParameters,item,1))
item.myValue = h->GetLength( false );
p.append( item );
-
+ customWidgets()->append(0);
+
+ item.myName = tr( "SMESH_REVERCE_EDGES" );
+ p.append( item );
+
+ StdMeshersGUI_EdgeDirectionParamWdg* aDirectionWidget = new StdMeshersGUI_EdgeDirectionParamWdg();
+ QString anEntry = SMESHGUI_GenericHypothesisCreator::getShapeEntry();
+ if ( anEntry == "" )
+ anEntry = h->GetObjectEntry();
+ aDirectionWidget->SetMainShapeEntry( anEntry );
+ aDirectionWidget->SetListOfIDs( h->GetReversedEdges() );
+ aDirectionWidget->SetMainShapeEntry( h->GetObjectEntry() );
+ aDirectionWidget->showPreview( true );
+ customWidgets()->append ( aDirectionWidget );
}
else if( hypType()=="Deflection1D" )
{
param.myValue = w->GetValue();
return true;
}
+ if ( widget->inherits( "StdMeshersGUI_EdgeDirectionParamWdg" ))
+ {
+ const StdMeshersGUI_EdgeDirectionParamWdg * w =
+ static_cast<const StdMeshersGUI_EdgeDirectionParamWdg*>( widget );
+ param.myValue = w->GetValue();
+ return true;
+ }
return false;
}
<source>SMESH_REMOVE_ROW</source>
<translation>Remove row</translation>
</message>
+ <message>
+ <source>SMESH_REVERCE_EDGES</source>
+ <translation>Reverce Edges</translation>
+ </message>
<message>
<source>SMESH_SEGMENT_LENGTH_AROUND_VERTEX_HYPOTHESIS</source>
<translation>Segment Length Around Vertex</translation>
CORBA::Double StdMeshers_Arithmetic1D_i::GetLength( CORBA::Boolean theIsStart)
{
- MESSAGE( "StdMeshers_StartEndLength_i::GetLength" );
+ MESSAGE( "StdMeshers_Arithmetic1D_i::GetLength" );
ASSERT( myBaseImpl );
return this->GetImpl()->GetLength( theIsStart );
}
+//=============================================================================
+/*!
+ * StdMeshers_Arithmetic1D_i::SetReversedEdges
+ *
+ * Set edges to reverse
+ */
+//=============================================================================
+
+void StdMeshers_Arithmetic1D_i::SetReversedEdges( const SMESH::long_array& theIds )
+{
+ MESSAGE( "StdMeshers_Arithmetic1D_i::SetReversedEdges" );
+ ASSERT( myBaseImpl );
+ try {
+ std::vector<int> ids( theIds.length() );
+ CORBA::Long iEnd = theIds.length();
+ for ( CORBA::Long i = 0; i < iEnd; i++ )
+ ids[ i ] = theIds[ i ];
+
+ this->GetImpl()->SetReversedEdges( ids );
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+
+ // Update Python script
+ /* SMESH::TPythonDump() << _this() << ".SetEdgesToReverse( "
+ << theList << " )";*/
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_Arithmetic1D_i::SetObjectEntry
+ *
+ * Set the Entry for the Main Object
+ */
+//=============================================================================
+
+void StdMeshers_Arithmetic1D_i::SetObjectEntry( const char* entry )
+{
+ MESSAGE( "StdMeshers_Arithmetic1D_i::SetObjectEntry" );
+ ASSERT( myBaseImpl );
+
+ try {
+ this->GetImpl()->SetObjectEntry( entry );
+ // Update Python script
+ // SMESH::TPythonDump() << _this() << ".SetObjectEntry( '" << entry << "' )";
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_Arithmetic1D_i::GetObjectEntry
+ *
+ * Set the Entry for the Main Object
+ */
+//=============================================================================
+
+char* StdMeshers_Arithmetic1D_i::GetObjectEntry()
+{
+ MESSAGE( "StdMeshers_Arithmetic1D_i::SetObjectEntry" );
+ ASSERT( myBaseImpl );
+ const char* entry;
+ try {
+ entry = this->GetImpl()->GetObjectEntry();
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+ return CORBA::string_dup( entry );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_Arithmetic1D_i::GetReversedEdges
+ *
+ * Get reversed edges
+ */
+//=============================================================================
+
+SMESH::long_array* StdMeshers_Arithmetic1D_i::GetReversedEdges()
+{
+ MESSAGE( "StdMeshers_StartEndLength_i::GetReversedEdges" );
+ ASSERT( myBaseImpl );
+ SMESH::long_array_var anArray = new SMESH::long_array;
+ std::vector<int> ids = this->GetImpl()->GetReversedEdges();
+ anArray->length( ids.size() );
+ for ( CORBA::Long i = 0; i < ids.size(); i++)
+ anArray [ i ] = ids [ i ];
+
+ return anArray._retn();
+}
+
//=============================================================================
/*!
* StdMeshers_Arithmetic1D_i::GetImpl
// Set length
void SetLength( CORBA::Double theLength, CORBA::Boolean theIsStart )
throw ( SALOME::SALOME_Exception );
+
// Get length
CORBA::Double GetLength(CORBA::Boolean theIsStart);
+ //Set Reversed Edges
+ void SetReversedEdges( const SMESH::long_array& theIDs);
+
+ //Get Reversed Edges
+ SMESH::long_array* GetReversedEdges();
+
+ //Set the Entry of the Object
+ void SetObjectEntry( const char* theEntry);
+
+ //Get Object Entry
+ char* GetObjectEntry();
+
// Get implementation
::StdMeshers_Arithmetic1D* GetImpl();
return this->GetImpl()->GetNumberOfSegments();
}
+//=============================================================================
+/*!
+ * StdMeshers_NumberOfSegments_i::SetReversedEdges
+ *
+ * Set edges to reverse
+ */
+//=============================================================================
+
+void StdMeshers_NumberOfSegments_i::SetReversedEdges( const SMESH::long_array& theIds )
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::SetReversedEdges" );
+ ASSERT( myBaseImpl );
+ try {
+ std::vector<int> ids( theIds.length() );
+ CORBA::Long iEnd = theIds.length();
+ for ( CORBA::Long i = 0; i < iEnd; i++ )
+ ids[ i ] = theIds[ i ];
+
+ this->GetImpl()->SetReversedEdges( ids );
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+
+ // Update Python script
+ /* SMESH::TPythonDump() << _this() << ".SetEdgesToReverse( "
+ << theList << " )";*/
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_NumberOfSegments_i::SetObjectEntry
+ *
+ * Set the Entry for the Main Object
+ */
+//=============================================================================
+
+void StdMeshers_NumberOfSegments_i::SetObjectEntry( const char* entry )
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::SetObjectEntry" );
+ ASSERT( myBaseImpl );
+
+ try {
+ this->GetImpl()->SetObjectEntry( entry );
+ // Update Python script
+ // SMESH::TPythonDump() << _this() << ".SetObjectEntry( '" << entry << "' )";
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_NumberOfSegments_i::GetObjectEntry
+ *
+ * Set the Entry for the Main Object
+ */
+//=============================================================================
+
+char* StdMeshers_NumberOfSegments_i::GetObjectEntry()
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::SetObjectEntry" );
+ ASSERT( myBaseImpl );
+
+ const char* entry;
+ try {
+ entry = this->GetImpl()->GetObjectEntry();
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+ return CORBA::string_dup( entry );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_NumberOfSegments_i::GetReversedEdges
+ *
+ * Get reversed edges
+ */
+//=============================================================================
+
+SMESH::long_array* StdMeshers_NumberOfSegments_i::GetReversedEdges()
+{
+ MESSAGE( "StdMeshers_NumberOfSegments_i::GetReversedEdges" );
+ ASSERT( myBaseImpl );
+ SMESH::long_array_var anArray = new SMESH::long_array;
+ std::vector<int> ids = this->GetImpl()->GetReversedEdges();
+ anArray->length( ids.size() );
+ for ( CORBA::Long i = 0; i < ids.size(); i++)
+ anArray [ i ] = ids [ i ];
+
+ return anArray._retn();
+}
+
//=============================================================================
/*!
*/
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
+
+ //Set Reversed Edges
+ void SetReversedEdges( const SMESH::long_array& theIDs);
+
+ //Get Reversed Edges
+ SMESH::long_array* GetReversedEdges();
+
+ //Set Object Entry
+ void SetObjectEntry( const char* entry);
+
+ //Get Object Entry
+ char* GetObjectEntry();
};
#endif
return this->GetImpl()->GetLength( theIsStart );
}
+//=============================================================================
+/*!
+ * StdMeshers_StartEndLength_i::SetReversedEdges
+ *
+ * Set edges to reverse
+ */
+//=============================================================================
+
+void StdMeshers_StartEndLength_i::SetReversedEdges( const SMESH::long_array& theIds )
+{
+ MESSAGE( "StdMeshers_StartEndLength_i::SetReversedEdges" );
+ ASSERT( myBaseImpl );
+ try {
+ std::vector<int> ids( theIds.length() );
+ CORBA::Long iEnd = theIds.length();
+ for ( CORBA::Long i = 0; i < iEnd; i++ )
+ ids[ i ] = theIds[ i ];
+
+ this->GetImpl()->SetReversedEdges( ids );
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+
+ // Update Python script
+ /* SMESH::TPythonDump() << _this() << ".SetEdgesToReverse( "
+ << theList << " )";*/
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_StartEndLength_i::SetObjectEntry
+ *
+ * Set the Entry for the Main Object
+ */
+//=============================================================================
+
+void StdMeshers_StartEndLength_i::SetObjectEntry( const char* entry )
+{
+ MESSAGE( "StdMeshers_StartEndLength_i::SetObjectEntry" );
+ ASSERT( myBaseImpl );
+ try {
+ this->GetImpl()->SetObjectEntry( entry );
+ // Update Python script
+ // SMESH::TPythonDump() << _this() << ".SetObjectEntry( '" << entry << "' )";
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_StartEndLength_i::GetObjectEntry
+ *
+ * Set the Entry for the Main Object
+ */
+//=============================================================================
+
+char* StdMeshers_StartEndLength_i::GetObjectEntry()
+{
+ MESSAGE( "StdMeshers_StartEndLength_i::SetObjectEntry" );
+ ASSERT( myBaseImpl );
+ const char* entry;
+ try {
+ entry = this->GetImpl()->GetObjectEntry();
+ }
+ catch ( SALOME_Exception& S_ex ) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
+ SALOME::BAD_PARAM );
+ }
+ return CORBA::string_dup( entry );
+}
+
+//=============================================================================
+/*!
+ * StdMeshers_StartEndLength_i::GetReversedEdges
+ *
+ * Get reversed edges
+ */
+//=============================================================================
+
+SMESH::long_array* StdMeshers_StartEndLength_i::GetReversedEdges()
+{
+ MESSAGE( "StdMeshers_StartEndLength_i::GetReversedEdges" );
+ ASSERT( myBaseImpl );
+ SMESH::long_array_var anArray = new SMESH::long_array;
+ std::vector<int> ids = this->GetImpl()->GetReversedEdges();
+ anArray->length( ids.size() );
+ for ( CORBA::Long i = 0; i < ids.size(); i++)
+ anArray [ i ] = ids [ i ];
+
+ return anArray._retn();
+}
+
//=============================================================================
/*!
* StdMeshers_StartEndLength_i::GetImpl
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
+
+ //Set Reversed Edges
+ void SetReversedEdges( const SMESH::long_array& theIDs);
+
+ //Get Reversed Edges
+ SMESH::long_array* GetReversedEdges();
+
+ //Set Object Entry
+ void SetObjectEntry( const char* entry);
+
+ //Get Object Entry
+ char* GetObjectEntry();
};
#endif
