ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-15 10:08:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

0021336: EDF 1717 SMESH: New algorithm "body fitting" cartesian unstructured

Browse Source
This commit is contained in:
eap 2011-10-28 12:57:18 +00:00
parent 7a8ade40f7
commit e0125dc5c3
13 changed files with 1453 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/StdMeshersGUI/Makefile.am
View File

@ -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)

3
src/StdMeshersGUI/StdMeshersGUI.cxx
View File

@ -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 );
}

690
src/StdMeshersGUI/StdMeshersGUI_CartesianParamCreator.cxx Normal file
View File

@ -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 <SMESHGUI.h>
#include <SMESHGUI_Utils.h>
#include <SMESHGUI_HypothesesUtils.h>
#include <SMESHGUI_SpinBox.h>
// IDL includes
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
// SALOME GUI includes
#include <SalomeApp_Tools.h>
#include <SalomeApp_IntSpinBox.h>
#include <QtxComboBox.h>
// Qt includes
#include <QAbstractItemModel>
#include <QApplication>
#include <QButtonGroup>
#include <QGridLayout>
#include <QGroupBox>
#include <QHBoxLayout>
#include <QLabel>
#include <QLineEdit>
#include <QListWidget>
#include <QModelIndex>
#include <QRadioButton>
#include <QString>
#include <QStyleOptionViewItem>
#include <QTreeWidget>
#include <QTreeWidgetItem>
#include <QVBoxLayout>
#include <QPushButton>
#include <QTabWidget>
#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<QTreeWidgetItem *> 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<QTreeWidget*>( parent )),
myCoordList( qobject_cast<QListWidget*>( 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<SMESHGUI_SpinBox*>( 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<SMESHGUI_SpinBox*>( 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<QLineEdit*>(editor)->text().trimmed().isEmpty() )
{
QItemDelegate::setModelData( editor, model, index );
}
}
else
{
SMESHGUI_SpinBox* sb = qobject_cast<SMESHGUI_SpinBox*>( 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 "";
}

141
src/StdMeshersGUI/StdMeshersGUI_CartesianParamCreator.h Normal file
View File

@ -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 <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include CORBA_SERVER_HEADER(SMESH_Hypothesis)
#include <QFrame>
#include <QItemDelegate>
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

1
src/StdMeshersGUI/StdMeshersGUI_StdHypothesisCreator.cxx
View File

@ -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;

4
src/StdMeshersGUI/StdMeshers_images.ts
View File

@ -35,6 +35,10 @@
<source>ICON_DLG_MAX_LENGTH</source>
<translation>mesh_hypo_length.png</translation>
</message>
<message>
<source>ICON_DLG_CARTESIAN_PARAMS</source>
<translation>mesh_hypo_length.png</translation>
</message>
<message>
<source>ICON_DLG_VISCOUS_LAYERS</source>
<translation>mesh_hypo_viscous_layers.png</translation>

46
src/StdMeshersGUI/StdMeshers_msg_en.ts
View File

@ -139,6 +139,10 @@
<source>SMESH_MAX_LENGTH_HYPOTHESIS</source>
<translation>Max Length</translation>
</message>
<message>
<source>SMESH_CARTESIAN_PARAMS_HYPOTHESIS</source>
<translation>Body Fitting Parameters</translation>
</message>
<message>
<source>SMESH_USE_PREESTIMATED_LENGTH</source>
<translation>Use preestimated length</translation>
@ -167,6 +171,10 @@
<source>SMESH_MAX_LENGTH_TITLE</source>
<translation>Hypothesis Construction</translation>
</message>
<message>
<source>SMESH_CARTESIAN_PARAMS_TITLE</source>
<translation>Hypothesis Construction</translation>
</message>
<message>
<source>SMESH_MAX_ELEMENT_AREA_HYPOTHESIS</source>
<translation>Max. Element Area</translation>
@ -434,4 +442,42 @@
<translation>Edit</translation>
</message>
</context>
<context>
<name>StdMeshersGUI_CartesianParamCreator</name>
<message>
<source>THRESHOLD</source>
<translation>Threshold</translation>
</message>
<message>
<source>AXIS_X</source>
<translation>Axis X</translation>
</message>
<message>
<source>AXIS_Y</source>
<translation>Axis Y</translation>
</message>
<message>
<source>AXIS_Z</source>
<translation>Axis Z</translation>
</message>
</context>
<context>
<name>StdMeshersGUI::GridAxisTab</name>
<message>
<source>GRID_DEF_MODE</source>
<translation>Definition mode</translation>
</message>
<message>
<source>SPACING</source>
<translation>Spacing</translation>
</message>
<message>
<source>INSERT</source>
<translation>Insert</translation>
</message>
<message>
<source>COORD_STEP</source>
<translation>Step</translation>
</message>
</context>
</TS>

8
src/StdMeshers_I/Makefile.am
View File

@ -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 = \

294
src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.cxx Normal file
View File

@ -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<double> 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<double> 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<string> funVec;
vector<double> 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<string> funVec;
vector<double> 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<string> xFuns;
vector<double> 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;
}

117
src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.hxx Normal file
View File

@ -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 <SALOMEconfig.h>
#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

80
src/StdMeshers_I/StdMeshers_Cartesian_3D_i.cxx Normal file
View File

@ -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;
}

59
src/StdMeshers_I/StdMeshers_Cartesian_3D_i.hxx Normal file
View File

@ -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 <SALOMEconfig.h>
#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

6
src/StdMeshers_I/StdMeshers_i.cxx
View File

@ -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 T> class StdHypothesisCreator_i:public HypothesisCreator_i<T>
{
@ -177,6 +179,8 @@ STDMESHERS_I_EXPORT
aCreator = new StdHypothesisCreator_i<StdMeshers_ImportSource2D_i>;
else if (strcmp(aHypName, "ViscousLayers") == 0)
aCreator = new StdHypothesisCreator_i<StdMeshers_ViscousLayers_i>;
else if (strcmp(aHypName, "CartesianParameters3D") == 0)
aCreator = new StdHypothesisCreator_i<StdMeshers_CartesianParameters3D_i>;
// Algorithms
else if (strcmp(aHypName, "Regular_1D") == 0)
@ -213,6 +217,8 @@ STDMESHERS_I_EXPORT
aCreator = new StdHypothesisCreator_i<StdMeshers_Import_1D_i>;
else if (strcmp(aHypName, "Import_1D2D") == 0)
aCreator = new StdHypothesisCreator_i<StdMeshers_Import_1D2D_i>;
else if (strcmp(aHypName, "Cartesian_3D") == 0)
aCreator = new StdHypothesisCreator_i<StdMeshers_Cartesian_3D_i>;
else ;
return aCreator;