From e0125dc5c31424465b748fbae81cbf3d1497a243 Mon Sep 17 00:00:00 2001 From: eap Date: Fri, 28 Oct 2011 12:57:18 +0000 Subject: [PATCH] 0021336: EDF 1717 SMESH: New algorithm "body fitting" cartesian unstructured --- src/StdMeshersGUI/Makefile.am | 9 +- src/StdMeshersGUI/StdMeshersGUI.cxx | 3 + .../StdMeshersGUI_CartesianParamCreator.cxx | 690 ++++++++++++++++++ .../StdMeshersGUI_CartesianParamCreator.h | 141 ++++ .../StdMeshersGUI_StdHypothesisCreator.cxx | 1 + src/StdMeshersGUI/StdMeshers_images.ts | 4 + src/StdMeshersGUI/StdMeshers_msg_en.ts | 46 ++ src/StdMeshers_I/Makefile.am | 8 +- .../StdMeshers_CartesianParameters3D_i.cxx | 294 ++++++++ .../StdMeshers_CartesianParameters3D_i.hxx | 117 +++ .../StdMeshers_Cartesian_3D_i.cxx | 80 ++ .../StdMeshers_Cartesian_3D_i.hxx | 59 ++ src/StdMeshers_I/StdMeshers_i.cxx | 6 + 13 files changed, 1453 insertions(+), 5 deletions(-) create mode 100644 src/StdMeshersGUI/StdMeshersGUI_CartesianParamCreator.cxx create mode 100644 src/StdMeshersGUI/StdMeshersGUI_CartesianParamCreator.h create mode 100644 src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.cxx create mode 100644 src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.hxx create mode 100644 src/StdMeshers_I/StdMeshers_Cartesian_3D_i.cxx create mode 100644 src/StdMeshers_I/StdMeshers_Cartesian_3D_i.hxx diff --git a/src/StdMeshersGUI/Makefile.am b/src/StdMeshersGUI/Makefile.am index f18240902..fe0dee7ce 100644 --- a/src/StdMeshersGUI/Makefile.am +++ b/src/StdMeshersGUI/Makefile.am @@ -34,7 +34,8 @@ salomeinclude_HEADERS = \ StdMeshersGUI_QuadrangleParamWdg.h \ StdMeshersGUI_LayerDistributionParamWdg.h \ StdMeshersGUI_FixedPointsParamWdg.h \ - StdMeshersGUI_SubShapeSelectorWdg.h + StdMeshersGUI_SubShapeSelectorWdg.h \ + StdMeshersGUI_CartesianParamCreator.h # Libraries targets lib_LTLIBRARIES = libStdMeshersGUI.la @@ -49,7 +50,8 @@ dist_libStdMeshersGUI_la_SOURCES = \ StdMeshersGUI_QuadrangleParamWdg.cxx \ StdMeshersGUI_LayerDistributionParamWdg.cxx \ StdMeshersGUI_FixedPointsParamWdg.cxx \ - StdMeshersGUI_SubShapeSelectorWdg.cxx + StdMeshersGUI_SubShapeSelectorWdg.cxx \ + StdMeshersGUI_CartesianParamCreator.cxx MOC_FILES = \ StdMeshersGUI_StdHypothesisCreator_moc.cxx \ @@ -60,7 +62,8 @@ MOC_FILES = \ StdMeshersGUI_QuadrangleParamWdg_moc.cxx \ StdMeshersGUI_LayerDistributionParamWdg_moc.cxx \ StdMeshersGUI_FixedPointsParamWdg_moc.cxx \ - StdMeshersGUI_SubShapeSelectorWdg_moc.cxx + StdMeshersGUI_SubShapeSelectorWdg_moc.cxx \ + StdMeshersGUI_CartesianParamCreator_moc.cxx nodist_libStdMeshersGUI_la_SOURCES= \ $(MOC_FILES) diff --git a/src/StdMeshersGUI/StdMeshersGUI.cxx b/src/StdMeshersGUI/StdMeshersGUI.cxx index efe3f1283..b311ff8e3 100644 --- a/src/StdMeshersGUI/StdMeshersGUI.cxx +++ b/src/StdMeshersGUI/StdMeshersGUI.cxx @@ -26,6 +26,7 @@ // #include "StdMeshersGUI_StdHypothesisCreator.h" #include "StdMeshersGUI_NbSegmentsCreator.h" +#include "StdMeshersGUI_CartesianParamCreator.h" //============================================================================= /*! GetHypothesisCreator @@ -39,6 +40,8 @@ extern "C" { if( aHypType=="NumberOfSegments" ) return new StdMeshersGUI_NbSegmentsCreator(); + else if ( aHypType=="CartesianParameters3D" ) + return new StdMeshersGUI_CartesianParamCreator( aHypType ); else return new StdMeshersGUI_StdHypothesisCreator( aHypType ); } diff --git a/src/StdMeshersGUI/StdMeshersGUI_CartesianParamCreator.cxx b/src/StdMeshersGUI/StdMeshersGUI_CartesianParamCreator.cxx new file mode 100644 index 000000000..1a54a4502 --- /dev/null +++ b/src/StdMeshersGUI/StdMeshersGUI_CartesianParamCreator.cxx @@ -0,0 +1,690 @@ +// Copyright (C) 2007-2011 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_CartesianParamCreator.cxx +// Author : Open CASCADE S.A.S. +// SMESH includes +// +#include "StdMeshersGUI_CartesianParamCreator.h" + +#include +#include +#include +#include + +// IDL includes +#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis) + +// SALOME GUI includes +#include +#include +#include + +// Qt includes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define SPACING 6 +#define MARGIN 11 + +namespace StdMeshersGUI +{ + enum { COORD_BUT = 0, SPACING_BUT }; + + //================================================================================ + /*! + * \brief get spacing definition from a tree item + */ + //================================================================================ + + void getFromItem(QTreeWidgetItem * item, double& t0, double& t1, QString& fun ) + { + if ( item ) + { + t0 = item->text( 0 ).split(' ')[0].toDouble(); + t1 = item->data( 0, Qt::UserRole ).toDouble(); + fun = item->text( 1 ); + } + } + + //================================================================================ + /*! + * \brief set spacing definition to a tree item + */ + //================================================================================ + + QTreeWidgetItem* setToItem(double t0, double t1, const QString& fun, QTreeWidgetItem * item) + { + if ( !item ) item = new QTreeWidgetItem; + item->setText( 0, QString( "%1 - %2" ).arg( t0 ).arg( t1 )); + item->setData( 0, Qt::UserRole, t1 ); + item->setText( 1, fun ); + item->setFlags( item->flags() | Qt::ItemIsEditable ); + return item; + } + + //================================================================================ + /*! + * \brief Retrieves coordinate value from a list item + */ + //================================================================================ + + double coordFromItem( QListWidgetItem * item ) + { + return item ? item->data( Qt::UserRole ).toDouble() : 0; + } + + //================================================================================ + /*! + * \brief Sets coordinate value to a list item + */ + //================================================================================ + + QListWidgetItem* coordToItem( double coord, QListWidgetItem * item ) + { + if ( !item ) item = new QListWidgetItem; + item->setText( QString::number( coord )); + item->setData( Qt::UserRole, coord ); + item->setFlags( item->flags() | Qt::ItemIsEditable ); + return item; + } + + //================================================================================ + /*! + * \brief Constructor + * \param theParent - Parent widget for this tab + * + * Makes tab's look and feel + */ + //================================================================================ + + GridAxisTab::GridAxisTab( QWidget* theParent,const int axisIndex ): + QFrame( theParent ), myAxisIndex( axisIndex ) + { + // 1) Grid definition mode + myModeGroup = new QButtonGroup( this ); + QGroupBox* modeBox = new QGroupBox( tr( "GRID_DEF_MODE" ), this ); + QHBoxLayout* modeLay = new QHBoxLayout( modeBox ); + modeLay->setMargin( MARGIN ); + modeLay->setSpacing( SPACING ); + + QRadioButton* coordModeBtn = new QRadioButton( tr( "SMESH_COORDINATES" ), modeBox ); + QRadioButton* spacModeBtn = new QRadioButton( tr( "SPACING" ), modeBox ); + + modeLay->addWidget( coordModeBtn ); + modeLay->addWidget( spacModeBtn ); + myModeGroup->addButton( coordModeBtn, COORD_BUT ); + myModeGroup->addButton( spacModeBtn, SPACING_BUT ); + + // 2) Buttons + Step + myInsertBtn = new QPushButton( tr("INSERT"), this); + myDeleteBtn = new QPushButton( tr("SMESH_BUT_DELETE"), this); + + myStepLabel = new QLabel( tr("COORD_STEP")); + myStepSpin = new SMESHGUI_SpinBox( this ); + myStepSpin->setAcceptNames( false ); // No Notebook variables allowed + myStepSpin->RangeStepAndValidator(); + myStepSpin->SetStep( 1. ); + myStepSpin->SetValue( myStep = 1. ); + + // 3) Coodrinates/Spacing group + QFrame* csFrame = new QFrame( this ); + QVBoxLayout* scLay = new QVBoxLayout( csFrame ); + scLay->setMargin( 0 ); + scLay->setSpacing( SPACING ); + + // 3.1) Spacing + mySpacingTreeWdg = new QTreeWidget( csFrame ); + mySpacingTreeWdg->setColumnCount(2); + mySpacingTreeWdg->setHeaderLabels( QStringList() << tr( "SMESH_RANGE" ) << QString( "f(t)" )); + mySpacingTreeWdg->setColumnWidth( 1, 40 ); + mySpacingTreeWdg->setColumnWidth( 2, 30 ); + mySpacingTreeWdg->setItemDelegate( new LineDelegate( mySpacingTreeWdg )); + scLay->addWidget( mySpacingTreeWdg ); + + // 3.2) Coordinates + myCoordList = new QListWidget( csFrame ); + myCoordList->setItemDelegate( new LineDelegate( myCoordList )); + scLay->addWidget( myCoordList ); + + // layouting + + QGridLayout* axisTabLayout = new QGridLayout( this ); + axisTabLayout->setMargin( MARGIN ); + axisTabLayout->setSpacing( SPACING ); + + axisTabLayout->addWidget( modeBox , 0, 0, 1, 3 ); + axisTabLayout->addWidget( myInsertBtn , 1, 0, 1, 2 ); + axisTabLayout->addWidget( myDeleteBtn , 2, 0, 1, 2 ); + axisTabLayout->addWidget( myStepLabel, 3, 0 ); + axisTabLayout->addWidget( myStepSpin , 3, 1 ); + axisTabLayout->addWidget( csFrame , 1, 2, 4, 1 ); + + axisTabLayout->setRowStretch( 4, 1 ); + + // signals + connect( myInsertBtn, SIGNAL( clicked() ), SLOT( onInsert() )); + connect( myDeleteBtn, SIGNAL( clicked() ), SLOT( onDelete() )); + connect( myModeGroup, SIGNAL( buttonClicked ( int )), SLOT( onMode(int))); + connect( mySpacingTreeWdg, SIGNAL( itemSelectionChanged()), SLOT( updateButtons() )); + connect( myCoordList, SIGNAL( itemSelectionChanged()), SLOT( updateButtons() )); + connect( myStepSpin, SIGNAL( valueChanged(double)), SLOT( onStepChange() )); + } + + void GridAxisTab::onInsert() + { + if ( isGridBySpacing() ) + { + QTreeWidgetItem * item = mySpacingTreeWdg->currentItem(); + if ( !item ) item = mySpacingTreeWdg->topLevelItem( 0 ); + int i = mySpacingTreeWdg->indexOfTopLevelItem( item ); + + double t0, t1; QString fun; + getFromItem( item, t0, t1, fun ); + double t = 0.5 * ( t0 + t1 ); + setToItem( t0, t, fun, item ); + + item = setToItem( t, t1, fun ); + if ( i == mySpacingTreeWdg->topLevelItemCount()-1 ) + mySpacingTreeWdg->addTopLevelItem( item ); + else + mySpacingTreeWdg->insertTopLevelItem( i+1, item ); + mySpacingTreeWdg->setCurrentItem( item ); + } + else + { + if ( myCoordList->count() == 0 ) + { + myCoordList->addItem( coordToItem( 0 )); + } + else + { + double coord = coordFromItem( myCoordList->currentItem() ) + myStep; + int i = myCoordList->currentRow(); + while ( i > 0 && coordFromItem( myCoordList->item( i-1 )) > coord ) + --i; + while ( i < myCoordList->count() && coordFromItem( myCoordList->item( i )) < coord ) + ++i; + const double tol = 1e-6; + const bool isSame = + ( i < myCoordList->count() && coordFromItem( myCoordList->item( i )) - coord < tol ) || + ( i > 0 && coord - coordFromItem( myCoordList->item( i-1 )) < tol ); + if ( !isSame ) + myCoordList->insertItem( i, coordToItem( coord )); + else if ( myStep < 0 ) + --i; + myCoordList->setCurrentRow( i ); + } + } + updateButtons(); + } + + void GridAxisTab::onDelete() + { + if ( isGridBySpacing() ) + { + QList selItems = mySpacingTreeWdg->selectedItems(); + QTreeWidgetItem * item; + foreach ( item, selItems ) + { + int i = mySpacingTreeWdg->indexOfTopLevelItem( item ); + if ( i == 0 ) continue; + QTreeWidgetItem* prevItem = mySpacingTreeWdg->topLevelItem( i-1 ); + + double t0, t1, t2; QString fun; + getFromItem( item, t1, t2, fun ); + getFromItem( prevItem, t0, t1, fun ); + delete item; + + setToItem( t0, t2, fun, prevItem ); + } + } + else + { + if ( myCoordList->count() > 2 ) + if ( QListWidgetItem * item = myCoordList->currentItem() ) + delete item; + } + updateButtons(); + } + + void GridAxisTab::onMode(int isSpacing) + { + mySpacingTreeWdg->setShown( isSpacing ); + myCoordList->setShown( !isSpacing ); + myStepSpin->setShown( !isSpacing ); + myStepLabel->setShown( !isSpacing ); + if ( isSpacing ) + { + if ( mySpacingTreeWdg->topLevelItemCount() == 0 ) + { + QString spacing( "1" ); + if ( myCoordList->count() > 1 ) + { + double c1 = coordFromItem( myCoordList->item( 1 )); + double c0 = coordFromItem( myCoordList->item( 0 )); + spacing = QString::number( c1 - c0 ); + } + mySpacingTreeWdg->addTopLevelItem( setToItem( 0., 1., spacing ) ); + } + myCoordList->clear(); + } + else + { + mySpacingTreeWdg->clear(); + if ( myCoordList->count() == 0 ) + myCoordList->addItem( coordToItem( 0 )); + } + updateButtons(); + } + + void GridAxisTab::onStepChange() + { + if ( fabs( myStepSpin->GetValue() ) < 1e-100 ) + { + double delta = myStepSpin->singleStep() * ( myStep > myStepSpin->GetValue() ? -1 : +1 ); + myStepSpin->SetValue( myStepSpin->GetValue() + delta ); + } + myStep = myStepSpin->GetValue(); + } + + void GridAxisTab::updateButtons() + { + bool insertEnable = false, deleteEnable = false; + if ( isGridBySpacing() ) + { + insertEnable = true; + const int nbSelected = mySpacingTreeWdg->selectedItems().count(); + if ( nbSelected > 0 ) + { + // we delete a current range by uniting it with the previous + int i = mySpacingTreeWdg->indexOfTopLevelItem( mySpacingTreeWdg->currentItem() ); + deleteEnable = ( i > 0 ); + } + } + else + { + const int nbSelected = myCoordList->selectedItems().count(); + insertEnable = ( nbSelected || myCoordList->count() < 2 ); + deleteEnable = ( nbSelected && myCoordList->count() > 2 ); + } + myInsertBtn->setEnabled( insertEnable ); + myDeleteBtn->setEnabled( deleteEnable ); + } + + void GridAxisTab::setCoordinates( SMESH::double_array_var coords ) + { + myCoordList->clear(); + for ( size_t i = 0; i < coords->length(); ++i ) + myCoordList->addItem( coordToItem( coords[i] )); + + myModeGroup->button( COORD_BUT )->setChecked( true ); + onMode( COORD_BUT ); + } + + void GridAxisTab::setSpacing( SMESH::string_array_var funs, SMESH::double_array_var points ) + { + mySpacingTreeWdg->clear(); + if ( funs->length() == points->length() - 1 ) + { + for ( size_t i = 1; i < points->length(); ++i ) + mySpacingTreeWdg->addTopLevelItem + ( setToItem( points[i-1], points[i], (const char*) funs[i-1] )); + } + myModeGroup->button( SPACING_BUT )->setChecked( true ); + onMode( SPACING_BUT ); + } + + bool GridAxisTab::isGridBySpacing() const + { + return ( myModeGroup->checkedId() == SPACING_BUT ); + } + + SMESH::double_array* GridAxisTab::getCoordinates() + { + SMESH::double_array_var coords = new SMESH::double_array; + coords->length( myCoordList->count() ); + for ( size_t i = 0; i < coords->length(); ++i ) + coords[i] = coordFromItem( myCoordList->item( i ) ); + + return coords._retn(); + } + + void GridAxisTab::getSpacing(SMESH::string_array_out funs, + SMESH::double_array_out points) const + { + funs = new SMESH::string_array(); + points = new SMESH::double_array(); + funs->length( mySpacingTreeWdg->topLevelItemCount() ); + points->length( mySpacingTreeWdg->topLevelItemCount() + 1 ); + double t0, t1; QString fun; + for ( size_t i = 0; i < funs->length(); ++i ) + { + QTreeWidgetItem* item = mySpacingTreeWdg->topLevelItem( i ); + getFromItem( item, t0, t1, fun ); + points[i] = t0; + funs[i] = fun.toLatin1().constData(); + } + points[ points->length()-1 ] = 1.0; + } + + + bool GridAxisTab::checkParams(QString& msg, SMESH::SMESH_Hypothesis_var& hyp) const + { + if ( isGridBySpacing() ) + { + if ( mySpacingTreeWdg->topLevelItemCount() == 0 ) + return false; // how could it be? + StdMeshers::StdMeshers_CartesianParameters3D_var h = + StdMeshers::StdMeshers_CartesianParameters3D::_narrow( hyp ); + SMESH::string_array_var funs; + SMESH::double_array_var points; + getSpacing( funs.out(), points.out() ); + try { + const char* axisName[3] = { "X", "Y", "Z" }; + SMESH::double_array_var coords = + h->ComputeCoordinates(0.,1., funs, points, axisName[ myAxisIndex ]); + } + catch ( const SALOME::SALOME_Exception& ex ) { + msg = (const char*) ex.details.text; + return false; + } + } + else + { + return myCoordList->count() > 1; + } + return true; + } + + LineDelegate::LineDelegate( QWidget* parent ): + QItemDelegate( parent ), + mySpacingTreeWdg( qobject_cast( parent )), + myCoordList( qobject_cast( parent )) + { + } + + QWidget* LineDelegate::createEditor( QWidget* parent, + const QStyleOptionViewItem& opt, + const QModelIndex& index) const + { + QWidget* w = 0; + if ( mySpacingTreeWdg ) + { + if ( index.column() == 0 && + index.row() != mySpacingTreeWdg->topLevelItemCount()-1 ) + { + SMESHGUI_SpinBox* sb = new SMESHGUI_SpinBox( parent ); + sb->setAcceptNames( false ); // No Notebook variables allowed + sb->setFrame( false ); + w = sb; + } + if ( index.column() == 1 ) { + w = new QLineEdit( parent ); + } + } + else + { + SMESHGUI_SpinBox* sb = new SMESHGUI_SpinBox( parent ); + sb->setAcceptNames( false ); // No Notebook variables allowed + sb->setFrame( false ); + const double tol = 1e-5; + double from = index.row() ? coordFromItem( myCoordList->item( index.row()-1 ))+tol : -1e+6; + double to = index.row() == myCoordList->count()-1 ? 1e+6 : coordFromItem( myCoordList->item( index.row()+1 ))-tol; + sb->RangeStepAndValidator( from, to, 0.01 ); + w = sb; + } + return w; + } + + void LineDelegate::setEditorData ( QWidget * editor, const QModelIndex & index ) const + { + if ( mySpacingTreeWdg && index.column() == 0 ) + { + double t0, t1, t2=1.0; QString fun; + QTreeWidgetItem* item = mySpacingTreeWdg->topLevelItem( index.row() ); + getFromItem( item, t0, t1, fun ); + if ( index.row() != mySpacingTreeWdg->topLevelItemCount()-1 ) + { + item = mySpacingTreeWdg->topLevelItem( index.row()+1 ); + getFromItem( item, t1, t2, fun ); + } + const double tol = 1e-3; + SMESHGUI_SpinBox* sb = qobject_cast( editor ); + sb->RangeStepAndValidator( t0 + tol, t2 - tol, 0.01 ); + sb->SetValue( t1 ); + } + else + { + QItemDelegate::setEditorData( editor, index ); + } + } + void LineDelegate::setModelData( QWidget* editor, + QAbstractItemModel* model, + const QModelIndex& index ) const + { + if ( mySpacingTreeWdg ) + { + if ( index.column() == 0 ) + { + if ( index.row() != mySpacingTreeWdg->topLevelItemCount()-1 ) + { + SMESHGUI_SpinBox* sb = qobject_cast( editor ); + double t0, t1, t = sb->GetValue(); QString fun; + + QTreeWidgetItem* item = mySpacingTreeWdg->topLevelItem( index.row() ); + getFromItem( item, t0, t1, fun ); + setToItem( t0, t, fun, item ); + + item = mySpacingTreeWdg->topLevelItem( index.row() + 1 ); + getFromItem( item, t0, t1, fun ); + setToItem( t, t1, fun, item ); + } + } + else if ( !qobject_cast(editor)->text().trimmed().isEmpty() ) + { + QItemDelegate::setModelData( editor, model, index ); + } + } + else + { + SMESHGUI_SpinBox* sb = qobject_cast( editor ); + coordToItem( sb->GetValue(), myCoordList->item( index.row() )); + } + } + +} // namespace StdMeshersGUI + + +StdMeshersGUI_CartesianParamCreator::StdMeshersGUI_CartesianParamCreator(const QString& aHypType) + : StdMeshersGUI_StdHypothesisCreator( aHypType ), + myThreshold( 0 ) +{ + myAxisTabs[0] = 0; + myAxisTabs[1] = 0; + myAxisTabs[2] = 0; +} + +StdMeshersGUI_CartesianParamCreator::~StdMeshersGUI_CartesianParamCreator() +{ + if ( myAxisTabs[0] ) delete myAxisTabs[0]; + if ( myAxisTabs[1] ) delete myAxisTabs[1]; + if ( myAxisTabs[2] ) delete myAxisTabs[2]; + myAxisTabs[0] = 0; + myAxisTabs[1] = 0; + myAxisTabs[2] = 0; +} + +bool StdMeshersGUI_CartesianParamCreator::checkParams( QString& msg ) const +{ + if( !SMESHGUI_GenericHypothesisCreator::checkParams( msg ) ) + return false; + + if ( myName && myName->text().trimmed().isEmpty() ) + { + msg = tr("SMESH_WRN_EMPTY_NAME"); + return false; + } + if ( ! myThreshold->isValid( msg, true )) + return false; + + SMESH::SMESH_Hypothesis_var hyp = hypothesis(); + if ( !myAxisTabs[0]->checkParams( msg, hyp )) return false; + if ( !myAxisTabs[1]->checkParams( msg, hyp )) return false; + if ( !myAxisTabs[2]->checkParams( msg, hyp )) return false; + + return true; +} + +QFrame* StdMeshersGUI_CartesianParamCreator::buildFrame() +{ + QFrame* fr = new QFrame(); + //fr->setMinimumWidth(460); + + QVBoxLayout* lay = new QVBoxLayout( fr ); + lay->setMargin( 0 ); + lay->setSpacing( SPACING ); + + QGroupBox* GroupC1 = new QGroupBox( tr( "SMESH_ARGUMENTS" ), fr ); + lay->addWidget( GroupC1 ); + + StdMeshers::StdMeshers_NumberOfSegments_var h = + StdMeshers::StdMeshers_NumberOfSegments::_narrow( hypothesis() ); + + QGridLayout* argGroupLayout = new QGridLayout( GroupC1 ); + argGroupLayout->setSpacing( SPACING ); + argGroupLayout->setMargin( MARGIN ); + argGroupLayout->setColumnStretch( 0, 0 ); + argGroupLayout->setColumnStretch( 1, 1 ); + + int row = 0; + // 0) name + myName = 0; + if( isCreation() ) + { + myName = new QLineEdit( GroupC1 ); + argGroupLayout->addWidget( new QLabel( tr( "SMESH_NAME" ), GroupC1 ), row, 0 ); + argGroupLayout->addWidget( myName, row, 1 ); + row++; + } + + // 1) threshold + argGroupLayout->addWidget( new QLabel( tr( "THRESHOLD" ), GroupC1 ), row, 0 ); + myThreshold = new SMESHGUI_SpinBox( GroupC1 ); + myThreshold->setAcceptNames( false ); // No Notebook variables allowed + myThreshold->RangeStepAndValidator( 1.1, 1e+10, 1., "length_precision" ); + argGroupLayout->addWidget( myThreshold, row, 1 ); + row++; + + // 2) Grid definition + QTabWidget* tabWdg = new QTabWidget( fr ); + myAxisTabs[ 0 ] = new StdMeshersGUI::GridAxisTab( tabWdg, 0 ); + myAxisTabs[ 1 ] = new StdMeshersGUI::GridAxisTab( tabWdg, 1 ); + myAxisTabs[ 2 ] = new StdMeshersGUI::GridAxisTab( tabWdg, 2 ); + tabWdg->addTab( myAxisTabs[ 0 ], tr( "AXIS_X" ) ); + tabWdg->addTab( myAxisTabs[ 1 ], tr( "AXIS_Y" ) ); + tabWdg->addTab( myAxisTabs[ 2 ], tr( "AXIS_Z" ) ); + argGroupLayout->addWidget( tabWdg, row, 0, 1, 2 ); + + return fr; +} + +void StdMeshersGUI_CartesianParamCreator::retrieveParams() const +{ + StdMeshers::StdMeshers_CartesianParameters3D_var h = + StdMeshers::StdMeshers_CartesianParameters3D::_narrow( initParamsHypothesis() ); + + if( myName ) + myName->setText( hypName() ); + + myThreshold->setValue( h->GetSizeThreshold() ); + + for ( int ax = 0; ax < 3; ++ax ) + { + if ( h->IsGridBySpacing( ax )) + { + SMESH::string_array_var funs; + SMESH::double_array_var intPoints; + h->GetGridSpacing( funs.out(), intPoints.out(), ax ); + myAxisTabs[ax]->setSpacing( funs, intPoints ); + } + else + { + SMESH::double_array_var coords = h->GetGrid( ax ); + myAxisTabs[ax]->setCoordinates( coords ); + } + } + if ( dlg() ) + dlg()->setMinimumSize( dlg()->minimumSizeHint().width(), dlg()->minimumSizeHint().height() ); +} + +QString StdMeshersGUI_CartesianParamCreator::storeParams() const +{ + StdMeshers::StdMeshers_CartesianParameters3D_var h = + StdMeshers::StdMeshers_CartesianParameters3D::_narrow( hypothesis() ); + + try + { + if( isCreation() ) + SMESH::SetName( SMESH::FindSObject( h ), myName->text().toLatin1().constData() ); + + h->SetSizeThreshold( myThreshold->text().toDouble() ); + + for ( int ax = 0; ax < 3; ++ax ) + { + if ( myAxisTabs[ax]->isGridBySpacing()) + { + SMESH::double_array_var intPoints; + SMESH::string_array_var funs; + myAxisTabs[ax]->getSpacing( funs.out(), intPoints.out() ); + h->SetGridSpacing( funs, intPoints, ax ); + } + else + { + SMESH::double_array_var coords = myAxisTabs[ax]->getCoordinates(); + h->SetGrid( coords, ax ); + } + } + } + catch(const SALOME::SALOME_Exception& ex) + { + SalomeApp_Tools::QtCatchCorbaException(ex); + } + return ""; +} + diff --git a/src/StdMeshersGUI/StdMeshersGUI_CartesianParamCreator.h b/src/StdMeshersGUI/StdMeshersGUI_CartesianParamCreator.h new file mode 100644 index 000000000..a35608f88 --- /dev/null +++ b/src/StdMeshersGUI/StdMeshersGUI_CartesianParamCreator.h @@ -0,0 +1,141 @@ +// Copyright (C) 2007-2011 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_CartesianParamCreator.h +// Author : Open CASCADE S.A.S. +// +#ifndef STDMESHERSGUI_CartesianParamCreator_H +#define STDMESHERSGUI_CartesianParamCreator_H + +// SMESH includes +#include "SMESH_StdMeshersGUI.hxx" + +#include "StdMeshersGUI_StdHypothesisCreator.h" + +// IDL includes +#include +#include CORBA_SERVER_HEADER(SMESH_Mesh) +#include CORBA_SERVER_HEADER(SMESH_Hypothesis) + +#include +#include + +class SMESHGUI_SpinBox; +class QLineEdit; +class QButtonGroup; +class QTreeWidgetItem; +class QString; +class QWidget; +class QTreeWidget; +class QListWidget; +class QStyleOptionViewItem; +class QModelIndex; +class QAbstractItemModel; +class QListWidgetItem; + +namespace StdMeshersGUI +{ + void getFromItem(QTreeWidgetItem * item, double& t0, double& t1, QString& fun ); + QTreeWidgetItem* setToItem (double t0, double t1, const QString& fun, QTreeWidgetItem* item=0); + + double coordFromItem( QListWidgetItem * ); + QListWidgetItem* coordToItem( double coord, QListWidgetItem * item=0); + + /*! + * \brief Widget defining the grid in one direction + */ + class GridAxisTab : public QFrame + { + Q_OBJECT + public: + GridAxisTab( QWidget* parent, const int axisIndex ); + ~GridAxisTab() {} + + void setCoordinates( SMESH::double_array_var coords ); + void setSpacing( SMESH::string_array_var funs, SMESH::double_array_var points ); + + bool checkParams(QString& msg, SMESH::SMESH_Hypothesis_var& hyp) const; + bool isGridBySpacing() const; + SMESH::double_array* getCoordinates(); + void getSpacing(SMESH::string_array_out funs, SMESH::double_array_out points) const; + + private slots: + void onInsert(); + void onDelete(); + void onMode(int); + void onStepChange(); + void updateButtons(); + + private: + + int myAxisIndex; + QButtonGroup* myModeGroup; + QTreeWidget* mySpacingTreeWdg; + QListWidget* myCoordList; + QPushButton* myInsertBtn; + QPushButton* myDeleteBtn; + SMESHGUI_SpinBox* myStepSpin; + QLabel* myStepLabel; + double myStep; + }; + /* + * \brief : Custom item delegate + */ + class LineDelegate : public QItemDelegate + { + Q_OBJECT + public: + LineDelegate( QWidget* parent ); + ~LineDelegate() {} + + QWidget* createEditor( QWidget*, const QStyleOptionViewItem&, const QModelIndex& ) const; + void setEditorData ( QWidget * editor, const QModelIndex & index ) const; + void setModelData( QWidget* editor, QAbstractItemModel* model, const QModelIndex& index ) const; + + private: + QTreeWidget* mySpacingTreeWdg; + QListWidget* myCoordList; + }; +} + +class STDMESHERSGUI_EXPORT StdMeshersGUI_CartesianParamCreator : public StdMeshersGUI_StdHypothesisCreator +{ + Q_OBJECT + +public: + StdMeshersGUI_CartesianParamCreator( const QString& aHypType ); + virtual ~StdMeshersGUI_CartesianParamCreator(); + + virtual bool checkParams( QString& ) const; + +protected: + virtual QFrame* buildFrame(); + virtual void retrieveParams() const; + virtual QString storeParams() const; + +private: + QLineEdit* myName; + SMESHGUI_SpinBox* myThreshold; + StdMeshersGUI::GridAxisTab* myAxisTabs[3]; +}; + +#endif // STDMESHERSGUI_CartesianParamCreator_H diff --git a/src/StdMeshersGUI/StdMeshersGUI_StdHypothesisCreator.cxx b/src/StdMeshersGUI/StdMeshersGUI_StdHypothesisCreator.cxx index ff09f9b48..0c99dcbd1 100644 --- a/src/StdMeshersGUI/StdMeshersGUI_StdHypothesisCreator.cxx +++ b/src/StdMeshersGUI/StdMeshersGUI_StdHypothesisCreator.cxx @@ -1341,6 +1341,7 @@ QString StdMeshersGUI_StdHypothesisCreator::hypTypeName( const QString& t ) cons types.insert( "MaxLength", "MAX_LENGTH" ); types.insert( "ViscousLayers", "VISCOUS_LAYERS" ); types.insert( "QuadrangleParams", "QUADRANGLE_PARAMS" ); + types.insert( "CartesianParameters3D", "CARTESIAN_PARAMS" ); } QString res; diff --git a/src/StdMeshersGUI/StdMeshers_images.ts b/src/StdMeshersGUI/StdMeshers_images.ts index 6bf81c4e2..aaf16607c 100644 --- a/src/StdMeshersGUI/StdMeshers_images.ts +++ b/src/StdMeshersGUI/StdMeshers_images.ts @@ -35,6 +35,10 @@ ICON_DLG_MAX_LENGTH mesh_hypo_length.png + + ICON_DLG_CARTESIAN_PARAMS + mesh_hypo_length.png + ICON_DLG_VISCOUS_LAYERS mesh_hypo_viscous_layers.png diff --git a/src/StdMeshersGUI/StdMeshers_msg_en.ts b/src/StdMeshersGUI/StdMeshers_msg_en.ts index 203913c5d..8a5d055b5 100644 --- a/src/StdMeshersGUI/StdMeshers_msg_en.ts +++ b/src/StdMeshersGUI/StdMeshers_msg_en.ts @@ -139,6 +139,10 @@ SMESH_MAX_LENGTH_HYPOTHESIS Max Length + + SMESH_CARTESIAN_PARAMS_HYPOTHESIS + Body Fitting Parameters + SMESH_USE_PREESTIMATED_LENGTH Use preestimated length @@ -167,6 +171,10 @@ SMESH_MAX_LENGTH_TITLE Hypothesis Construction + + SMESH_CARTESIAN_PARAMS_TITLE + Hypothesis Construction + SMESH_MAX_ELEMENT_AREA_HYPOTHESIS Max. Element Area @@ -434,4 +442,42 @@ Edit + + StdMeshersGUI_CartesianParamCreator + + THRESHOLD + Threshold + + + AXIS_X + Axis X + + + AXIS_Y + Axis Y + + + AXIS_Z + Axis Z + + + + StdMeshersGUI::GridAxisTab + + GRID_DEF_MODE + Definition mode + + + SPACING + Spacing + + + INSERT + Insert + + + COORD_STEP + Step + + diff --git a/src/StdMeshers_I/Makefile.am b/src/StdMeshers_I/Makefile.am index 19a04f18e..cec31e8be 100644 --- a/src/StdMeshers_I/Makefile.am +++ b/src/StdMeshers_I/Makefile.am @@ -67,7 +67,9 @@ salomeinclude_HEADERS = \ StdMeshers_ImportSource2D_i.hxx \ StdMeshers_Import_1D_i.hxx \ StdMeshers_Import_1D2D_i.hxx \ - StdMeshers_ViscousLayers_i.hxx + StdMeshers_ViscousLayers_i.hxx \ + StdMeshers_CartesianParameters3D_i.hxx \ + StdMeshers_Cartesian_3D_i.hxx # Libraries targets lib_LTLIBRARIES = libStdMeshersEngine.la @@ -113,7 +115,9 @@ dist_libStdMeshersEngine_la_SOURCES = \ StdMeshers_ImportSource2D_i.cxx \ StdMeshers_Import_1D_i.cxx \ StdMeshers_Import_1D2D_i.cxx \ - StdMeshers_ViscousLayers_i.cxx + StdMeshers_ViscousLayers_i.cxx \ + StdMeshers_CartesianParameters3D_i.cxx \ + StdMeshers_Cartesian_3D_i.cxx # additionnal information to compil and link file libStdMeshersEngine_la_CPPFLAGS = \ diff --git a/src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.cxx b/src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.cxx new file mode 100644 index 000000000..06ebe87d4 --- /dev/null +++ b/src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.cxx @@ -0,0 +1,294 @@ +// Copyright (C) 2007-2011 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 SMESH_I : idl implementation based on 'SMESH' unit's calsses +// File : StdMeshers_CartesianParameters3D_i.cxx +// Module : SMESH +// +#include "StdMeshers_CartesianParameters3D_i.hxx" + +#include "StdMeshers_CartesianParameters3D.hxx" +#include "SMESH_Gen_i.hxx" +#include "SMESH_Gen.hxx" +#include "SMESH_PythonDump.hxx" + +#include "Utils_CorbaException.hxx" +#include "utilities.h" + +#define _vec2array( v, a,conversion ) \ + { \ + a->length( v.size() ); \ + for ( size_t i = 0; i < v.size(); ++i ) \ + a[i] = conversion( v[i] ); \ + } +#define _array2vec(a,v,conversion) \ + { \ + v.resize( a.length() ); \ + for ( size_t i = 0; i < v.size(); ++i ) \ + v[i] = conversion ( a[i] ); \ + } +namespace +{ + const char* _string2chars(const std::string& s ) { return s.c_str(); } +} + +//============================================================================= +/*! + * StdMeshers_CartesianParameters3D_i::StdMeshers_CartesianParameters3D_i + * + * Constructor + */ +//============================================================================= + +StdMeshers_CartesianParameters3D_i:: +StdMeshers_CartesianParameters3D_i( PortableServer::POA_ptr thePOA, + int theStudyId, + ::SMESH_Gen* theGenImpl ) + : SALOME::GenericObj_i( thePOA ), + SMESH_Hypothesis_i( thePOA ) +{ + MESSAGE( "StdMeshers_CartesianParameters3D_i::StdMeshers_CartesianParameters3D_i" ); + myBaseImpl = new ::StdMeshers_CartesianParameters3D( theGenImpl->GetANewId(), + theStudyId, + theGenImpl ); +} + +//============================================================================= +/*! + * StdMeshers_CartesianParameters3D_i::~StdMeshers_CartesianParameters3D_i + * + * Destructor + */ +//============================================================================= + +StdMeshers_CartesianParameters3D_i::~StdMeshers_CartesianParameters3D_i() +{ + MESSAGE( "StdMeshers_CartesianParameters3D_i::~StdMeshers_CartesianParameters3D_i" ); +} + +//============================================================================= +/*! + * SetGrid + */ +//============================================================================= + +void StdMeshers_CartesianParameters3D_i::SetGrid(const SMESH::double_array& coords, + CORBA::Short axis) + throw (SALOME::SALOME_Exception) +{ + std::vector coordVec;//, yCoords, zCoords; + _array2vec( coords, coordVec, ); + + ASSERT( myBaseImpl ); + try { + this->GetImpl()->SetGrid( coordVec, axis ); + } + catch ( SALOME_Exception& S_ex ) { + THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM ); + } + + // Update Python script + SMESH::TPythonDump() << _this() << ".SetGrid( " << coords << ", " << axis << " )"; +} + +//============================================================================= +/*! + * GetGrid + */ +//============================================================================= + +SMESH::double_array* StdMeshers_CartesianParameters3D_i::GetGrid(CORBA::Short axis) + throw (SALOME::SALOME_Exception) +{ + std::vector coordVec; + ASSERT( myBaseImpl ); + try { + this->GetImpl()->GetGrid(coordVec, axis); + } + catch ( SALOME_Exception& S_ex ) { + THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM ); + } + + SMESH::double_array_var coords = new SMESH::double_array(); + _vec2array( coordVec, coords, ); + + return coords._retn(); +} + +//============================================================================= +/*! + * SetSizeThreshold + */ +//============================================================================= + +void StdMeshers_CartesianParameters3D_i::SetSizeThreshold(CORBA::Double threshold) + throw (SALOME::SALOME_Exception) +{ + ASSERT( myBaseImpl ); + try { + this->GetImpl()->SetSizeThreshold(threshold); + } + catch ( SALOME_Exception& S_ex ) { + THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM ); + } + + // Update Python script + SMESH::TPythonDump() << _this() << ".SetSizeThreshold( " << threshold << " )"; +} + +//============================================================================= +/*! + * GetSizeThreshold + */ +//============================================================================= + +CORBA::Double StdMeshers_CartesianParameters3D_i::GetSizeThreshold() +{ + return this->GetImpl()->GetSizeThreshold(); +} + +//======================================================================= +//function : SetGridSpacing +//\brief Set grid spacing along the three axes +// \param spaceFunctions - functions defining spacing values at given point on axis +// \param internalPoints - points dividing a grid into parts along each direction +// Parameter t of spaceFunction f(t) is a position [0,1] withing bounding box of +// the shape to mesh or withing an interval defined by internal points +//======================================================================= + +void StdMeshers_CartesianParameters3D_i::SetGridSpacing(const SMESH::string_array& spaceFunctions, + const SMESH::double_array& internalPoints, + CORBA::Short axis) + throw (SALOME::SALOME_Exception) +{ + vector funVec; + vector pointVec; + _array2vec( spaceFunctions, funVec, (const char*) ); + _array2vec( internalPoints, pointVec, ); + + ASSERT( myBaseImpl ); + try { + this->GetImpl()->SetGridSpacing( funVec, pointVec, axis ); + } + catch ( SALOME_Exception& S_ex ) { + THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM ); + } + + // Update Python script + SMESH::TPythonDump() << _this() << ".SetGridSpacing( " + << spaceFunctions << ", " + << internalPoints << ", " + << axis << " )"; +} + +//======================================================================= +//function : GetGridSpacing +//======================================================================= + +void StdMeshers_CartesianParameters3D_i::GetGridSpacing(SMESH::string_array_out xSpaceFunctions, + SMESH::double_array_out xInternalPoints, + CORBA::Short axis) + throw (SALOME::SALOME_Exception) +{ + ASSERT( myBaseImpl ); + try { + vector funVec; + vector pointVec; + this->GetImpl()->GetGridSpacing( funVec, pointVec, axis ); + + xSpaceFunctions = new SMESH::string_array(); + xInternalPoints = new SMESH::double_array(); + + _vec2array( funVec, xSpaceFunctions, _string2chars ); + _vec2array( pointVec, xInternalPoints, ); + } + catch ( SALOME_Exception& S_ex ) { + THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM ); + } +} + +//======================================================================= +//function : IsGridBySpacing +//purpose : Return true if the grid is defined by spacing functions and +// not by node coordinates +//======================================================================= + +CORBA::Boolean StdMeshers_CartesianParameters3D_i::IsGridBySpacing(CORBA::Short axis) +{ + return this->GetImpl()->IsGridBySpacing(axis); +} + +//======================================================================= +//function : ComputeCoordinates +//purpose : Computes node coordinates by spacing functions +//======================================================================= + +SMESH::double_array* +StdMeshers_CartesianParameters3D_i::ComputeCoordinates(CORBA::Double x0, + CORBA::Double x1, + const SMESH::string_array& spaceFuns, + const SMESH::double_array& points, + const char* axisName ) + throw (SALOME::SALOME_Exception) +{ + vector xFuns; + vector xPoints, coords; + _array2vec( spaceFuns, xFuns, (const char*) ); + _array2vec( points, xPoints, ); + + try { + this->GetImpl()->ComputeCoordinates( x0, x1, xFuns, xPoints, coords, axisName ); + } + catch ( SALOME_Exception& S_ex ) { + THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM ); + } + SMESH::double_array_var res = new SMESH::double_array; + _vec2array( coords, res, ); + + return res._retn(); +} + +//============================================================================= +/*! + * Get implementation + */ +//============================================================================= + +::StdMeshers_CartesianParameters3D* StdMeshers_CartesianParameters3D_i::GetImpl() +{ + MESSAGE( "StdMeshers_CartesianParameters3D_i::GetImpl" ); + return ( ::StdMeshers_CartesianParameters3D* )myBaseImpl; +} + +//================================================================================ +/*! + * \brief Verify whether hypothesis supports given entity type + * \param type - dimension (see SMESH::Dimension enumeration) + * \retval CORBA::Boolean - TRUE if dimension is supported, FALSE otherwise + * + * Verify whether hypothesis supports given entity type (see SMESH::Dimension enumeration) + */ +//================================================================================ + +CORBA::Boolean StdMeshers_CartesianParameters3D_i::IsDimSupported( SMESH::Dimension type ) +{ + return type == SMESH::DIM_3D; +} diff --git a/src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.hxx b/src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.hxx new file mode 100644 index 000000000..e33a8984c --- /dev/null +++ b/src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.hxx @@ -0,0 +1,117 @@ +// Copyright (C) 2007-2011 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 SMESH_I : idl implementation based on 'SMESH' unit's calsses +// File : StdMeshers_CartesianParameters3D_i.hxx +// Module : SMESH +// +#ifndef _SMESH_CartesianParameters3D_I_HXX_ +#define _SMESH_CartesianParameters3D_I_HXX_ + +#include "SMESH_StdMeshers_I.hxx" + +#include +#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis) + +#include "SMESH_Hypothesis_i.hxx" + +class SMESH_Gen; +class StdMeshers_CartesianParameters3D; + +// ====================================================== +// "CartesianParameters3D" hypothesis +// ====================================================== + +class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i: + public virtual POA_StdMeshers::StdMeshers_CartesianParameters3D, + public virtual SMESH_Hypothesis_i +{ + public: + // Constructor + StdMeshers_CartesianParameters3D_i( PortableServer::POA_ptr thePOA, + int theStudyId, + ::SMESH_Gen* theGenImpl ); + // Destructor + virtual ~StdMeshers_CartesianParameters3D_i(); + + /*! + * Set size threshold. A polyhedral cell got by cutting an initial + * hexahedron by geometry boundary is considered small and is removed if + * it's size is \athreshold times less than the size of the initial hexahedron. + * threshold must be > 1.0 + */ + void SetSizeThreshold(CORBA::Double threshold) throw (SALOME::SALOME_Exception); + CORBA::Double GetSizeThreshold(); + + /*! + * \brief Set node coordinates along an axis (counterd from zero) + */ + void SetGrid(const SMESH::double_array& coords, + CORBA::Short axis) throw (SALOME::SALOME_Exception); + SMESH::double_array* GetGrid(CORBA::Short axis) throw (SALOME::SALOME_Exception); + + /*! + * \brief Set grid spacing along an axis + * \param spaceFunctions - functions defining spacing value at given point on axis + * \param internalPoints - points dividing a grid into parts along each direction + * \param axis - index of an axis counterd from zero, i.e. 0==X, 1==Y, 2==Z + * + * Parameter t of spaceFunction f(t) is a position [0,1] withing bounding box of + * the shape to mesh or withing an interval defined by internal points + */ + void SetGridSpacing(const SMESH::string_array& spaceFunctions, + const SMESH::double_array& internalPoints, + CORBA::Short axis) throw (SALOME::SALOME_Exception); + + void GetGridSpacing(SMESH::string_array_out xSpaceFunctions, + SMESH::double_array_out xInternalPoints, + CORBA::Short axis) throw (SALOME::SALOME_Exception); + + /*! + * \brief Return true if the grid is defined by spacing functions and + * not by node coordinates + */ + CORBA::Boolean IsGridBySpacing(CORBA::Short axis); + + /*! + * \brief Computes node coordinates by spacing functions + * \param x0 - lower coordinate + * \param x1 - upper coordinate + * \param spaceFuns - space functions + * \param points - internal points + * \param coords - the computed coordinates + */ + SMESH::double_array* ComputeCoordinates(CORBA::Double x0, + CORBA::Double x1, + const SMESH::string_array& spaceFuns, + const SMESH::double_array& points, + const char* axisName ) + throw (SALOME::SALOME_Exception); + + // Get implementation + ::StdMeshers_CartesianParameters3D* GetImpl(); + + // Verify whether hypothesis supports given entity type + CORBA::Boolean IsDimSupported( SMESH::Dimension type ); +}; + +#endif + diff --git a/src/StdMeshers_I/StdMeshers_Cartesian_3D_i.cxx b/src/StdMeshers_I/StdMeshers_Cartesian_3D_i.cxx new file mode 100644 index 000000000..0665ebefb --- /dev/null +++ b/src/StdMeshers_I/StdMeshers_Cartesian_3D_i.cxx @@ -0,0 +1,80 @@ +// Copyright (C) 2007-2011 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 SMESH_I : idl implementation based on 'SMESH' unit's calsses +// File : StdMeshers_Cartesian_3D_i.cxx +// Module : SMESH +// +#include "StdMeshers_Cartesian_3D_i.hxx" +#include "StdMeshers_Cartesian_3D.hxx" +#include "SMESH_Gen.hxx" + +#include "Utils_CorbaException.hxx" +#include "utilities.h" + +//============================================================================= +/*! + * StdMeshers_Cartesian_3D_i::StdMeshers_Cartesian_3D_i + * + * Constructor + */ +//============================================================================= + +StdMeshers_Cartesian_3D_i::StdMeshers_Cartesian_3D_i( PortableServer::POA_ptr thePOA, + int theStudyId, + ::SMESH_Gen* theGenImpl ) + : SALOME::GenericObj_i( thePOA ), + SMESH_Hypothesis_i( thePOA ), + SMESH_Algo_i( thePOA ), + SMESH_3D_Algo_i( thePOA ) +{ + MESSAGE( "StdMeshers_Cartesian_3D_i::StdMeshers_Cartesian_3D_i" ); + myBaseImpl = new ::StdMeshers_Cartesian_3D( theGenImpl->GetANewId(), + theStudyId, + theGenImpl ); +} + +//============================================================================= +/*! + * StdMeshers_Cartesian_3D_i::~StdMeshers_Cartesian_3D_i + * + * Destructor + */ +//============================================================================= + +StdMeshers_Cartesian_3D_i::~StdMeshers_Cartesian_3D_i() +{ + MESSAGE( "StdMeshers_Cartesian_3D_i::~StdMeshers_Cartesian_3D_i" ); +} + +//============================================================================= +/*! + * StdMeshers_Cartesian_3D_i::GetImpl + * + * Get implementation + */ +//============================================================================= + +::StdMeshers_Cartesian_3D* StdMeshers_Cartesian_3D_i::GetImpl() +{ + MESSAGE( "StdMeshers_Cartesian_3D_i::GetImpl" ); + return ( ::StdMeshers_Cartesian_3D* )myBaseImpl; +} diff --git a/src/StdMeshers_I/StdMeshers_Cartesian_3D_i.hxx b/src/StdMeshers_I/StdMeshers_Cartesian_3D_i.hxx new file mode 100644 index 000000000..4d518036b --- /dev/null +++ b/src/StdMeshers_I/StdMeshers_Cartesian_3D_i.hxx @@ -0,0 +1,59 @@ +// Copyright (C) 2007-2011 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 SMESH_I : idl implementation based on 'SMESH' unit's calsses +// File : StdMeshers_Cartesian_3D_i.hxx +// Module : SMESH +// +#ifndef _SMESH_Cartesian_3D_I_HXX_ +#define _SMESH_Cartesian_3D_I_HXX_ + +#include "SMESH_StdMeshers_I.hxx" + +#include +#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis) + +#include "SMESH_3D_Algo_i.hxx" + +class SMESH_Gen; +class StdMeshers_Cartesian_3D; + +// ====================================================== +// Cartesianedron 3d algorithm +// ====================================================== +class STDMESHERS_I_EXPORT StdMeshers_Cartesian_3D_i: + public virtual POA_StdMeshers::StdMeshers_Cartesian_3D, + public virtual SMESH_3D_Algo_i +{ +public: + // Constructor + StdMeshers_Cartesian_3D_i( PortableServer::POA_ptr thePOA, + int theStudyId, + ::SMESH_Gen* theGenImpl ); + + // Destructor + virtual ~StdMeshers_Cartesian_3D_i(); + + // Get implementation + ::StdMeshers_Cartesian_3D* GetImpl(); +}; + +#endif diff --git a/src/StdMeshers_I/StdMeshers_i.cxx b/src/StdMeshers_I/StdMeshers_i.cxx index 34047b0d8..a87dc8490 100644 --- a/src/StdMeshers_I/StdMeshers_i.cxx +++ b/src/StdMeshers_I/StdMeshers_i.cxx @@ -58,6 +58,7 @@ #include "StdMeshers_QuadrangleParams_i.hxx" #include "StdMeshers_ImportSource1D_i.hxx" #include "StdMeshers_ImportSource2D_i.hxx" +#include "StdMeshers_Cartesian_3D_i.hxx" #include "StdMeshers_Regular_1D_i.hxx" #include "StdMeshers_MEFISTO_2D_i.hxx" @@ -72,6 +73,7 @@ #include "StdMeshers_Import_1D_i.hxx" #include "StdMeshers_Import_1D2D_i.hxx" #include "StdMeshers_ViscousLayers_i.hxx" +#include "StdMeshers_CartesianParameters3D_i.hxx" template class StdHypothesisCreator_i:public HypothesisCreator_i { @@ -177,6 +179,8 @@ STDMESHERS_I_EXPORT aCreator = new StdHypothesisCreator_i; else if (strcmp(aHypName, "ViscousLayers") == 0) aCreator = new StdHypothesisCreator_i; + else if (strcmp(aHypName, "CartesianParameters3D") == 0) + aCreator = new StdHypothesisCreator_i; // Algorithms else if (strcmp(aHypName, "Regular_1D") == 0) @@ -213,6 +217,8 @@ STDMESHERS_I_EXPORT aCreator = new StdHypothesisCreator_i; else if (strcmp(aHypName, "Import_1D2D") == 0) aCreator = new StdHypothesisCreator_i; + else if (strcmp(aHypName, "Cartesian_3D") == 0) + aCreator = new StdHypothesisCreator_i; else ; return aCreator; -- 2.39.2