-// Copyright (C) 2009-2013 CEA/DEN, EDF R&D
+// Copyright (C) 2009-2024 CEA, EDF
//
// 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.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include <TopoDS.hxx>
#include <BRepBuilderAPI_MakeVertex.hxx>
-#include <GEOMBase.h>
#include "HEXABLOCKGUI_SalomeTools.hxx"
-#include "GEOM_GEOMBase.hxx"
-
#include <SALOME_ListIO.hxx>
#include <SALOMEconfig.h>
#include <SUIT_ViewWindow.h>
#include "HEXABLOCKGUI_VtkDocumentGraphicView.hxx"
-
+#include <Geom_Circle.hxx>
+#include <gp_Circ.hxx>
+#include <BRep_Tool.hxx>
+#include <TopoDS_Edge.hxx>
//#define _DEVDEBUG_
case HEXA_TREE : elt = getHexaPtr<HEXA_NS::Hexa*>(iElt); break;
case VECTOR_TREE : elt = getHexaPtr<HEXA_NS::Vector*>(iElt); break;
case ELEMENTS_TREE : elt = getHexaPtr<HEXA_NS::Elements*>(iElt); break;
- case CROSSELEMENTS_TREE : elt = getHexaPtr<HEXA_NS::CrossElements*>(iElt); break;
+// case CROSSELEMENTS_TREE : elt = getHexaPtr<HEXA_NS::CrossElements*>(iElt); break;
case GEOMSHAPE_TREE: elt = getHexaPtr<HEXA_NS::NewShape*>(iElt); break;
case GEOMPOINT_TREE: elt = getHexaPtr<HEXA_NS::VertexShape*>(iElt); break;
case GEOMEDGE_TREE: elt = getHexaPtr<HEXA_NS::EdgeShape*>(iElt); break;
return getNbrElt(eltType) - getNbrUsedElt(eltType);
}
+// compute the length of the given edge
+double DocumentModel::getLength(const QModelIndex& iEdge)
+{
+ // * Get the pointer to the edge
+ HEXA_NS::Edge* edge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
+ HEXA_NS::EdgeShape* geomEdge = getHexaPtr<HEXA_NS::EdgeShape*>(iEdge);
+
+ // * The edge can be from VTK or OCC View
+ if (edge != NULL)
+ return edge->getLength();
+ else if (geomEdge != NULL)
+ return geomEdge->getLength();
+ else
+ return 0.;
+}
+
+// Compute the radius of the given edge
+double DocumentModel::getRadius(const QModelIndex& iEdge)
+{
+ // * Get the pointer to the edge
+ // * In our case only an OCC edge can have a radius
+ HEXA_NS::EdgeShape* edge = getHexaPtr<HEXA_NS::EdgeShape*>(iEdge);
+ if (edge == NULL)
+ return 0.;
+
+ return edge->getRadius();
+}
+
+// Compute the angle of the given edge (internal angle)
+double DocumentModel::getAngle(const QModelIndex& iEdge)
+{
+ // * Get the pointer to the edge
+ HEXA_NS::EdgeShape* edge = getHexaPtr<HEXA_NS::EdgeShape*>(iEdge);
+ if (edge == NULL)
+ return 0.;
+
+ return edge->getAngle();
+}
//Load the current Document
void DocumentModel::load()
clearAll();
fillData();
- fillBuilder();
+// fillBuilder();
fillGeometry();
fillAssociation();
fillGroups();
clearAll();
fillData();
- fillBuilder();
+// fillBuilder();
fillGeometry();
fillAssociation();
fillGroups();
void DocumentModel::clearAll()
{
clearData();
- clearBuilder();
+// clearBuilder();
clearGeometry();
clearAssociation();
clearGroups();
_edgeDirItem->removeRows(0, _edgeDirItem->rowCount() );
_quadDirItem->removeRows(0, _quadDirItem->rowCount() );
_hexaDirItem->removeRows(0, _hexaDirItem->rowCount() );
-}
-
-void DocumentModel::clearBuilder()
-{
_vectorDirItem->removeRows(0, _vectorDirItem->rowCount() );
_elementsDirItem->removeRows(0, _elementsDirItem->rowCount() );
_crossElementsDirItem->removeRows(0, _crossElementsDirItem->rowCount() );
}
+
+//void DocumentModel::clearBuilder()
+//{
+// _vectorDirItem->removeRows(0, _vectorDirItem->rowCount() );
+// _elementsDirItem->removeRows(0, _elementsDirItem->rowCount() );
+// _crossElementsDirItem->removeRows(0, _crossElementsDirItem->rowCount() );
+//}
+
void DocumentModel::clearGeometry()
{
_explicitShapesDirItem->removeRows(0, _explicitShapesDirItem->rowCount() );
hItem = new HexaItem(h, _entry);
_hexaDirItem->appendRow(hItem);
}
-}
+ // +++++ Builder ++++++++++++++++++++++++++++++
-void DocumentModel::fillBuilder()
-{
- HEXA_NS::Vector *v = NULL;
- VectorItem *vItem = NULL;
+ HEXA_NS::Vector *vec = NULL;
+ VectorItem *vecItem = NULL;
int nbVector = _hexaDocument->countVector();
for ( int i=0; i<nbVector; ++i ){
- v = _hexaDocument->getVector(i);
- vItem = new VectorItem(v);
- _vectorDirItem->appendRow(vItem);
+ vec = _hexaDocument->getVector(i);
+ vecItem = new VectorItem(vec);
+ _vectorDirItem->appendRow(vecItem);
}
//******* A VOIR AVEC ALAIN POUR LE REMPLISSAGE DE L'ARBRE ELEMENTS ET CROSSELEMENTS (ByCylinder) *******/
//******* OU SONT STOCKES LES ELEMENTS ET LES CROSSELEMENTS DANS LE DOCUMENT? ******/
// _cylinderDirItem
-// HEXA_NS::Cylinder *c = NULL;
-// HEXA_NS::Elements* c = NULL;
-// CylinderItem *cItem = NULL;
-// ElementsItem* cItem = NULL;
-// int nbCylinder = _hexaDocument->countCylinder();
-// for ( int i=0; i<nbCylinder; ++i ){
-// c = _hexaDocument->getCylinder(i);
-// cItem = new CylinderItem(c, _entry);
-// cItem = new ElementsItem(c, _entry);
-// _cylinderDirItem->appendRow(cItem);
-// _elementsDirItem->appendRow(cItem);
-// }
+ // HEXA_NS::Cylinder *c = NULL;
+ // HEXA_NS::Elements* c = NULL;
+ // CylinderItem *cItem = NULL;
+ // ElementsItem* cItem = NULL;
+ // int nbCylinder = _hexaDocument->countCylinder();
+ // for ( int i=0; i<nbCylinder; ++i ){
+ // c = _hexaDocument->getCylinder(i);
+ // cItem = new CylinderItem(c, _entry);
+ // cItem = new ElementsItem(c, _entry);
+ // _cylinderDirItem->appendRow(cItem);
+ // _elementsDirItem->appendRow(cItem);
+ // }
// _pipeDirItem
-// HEXA_NS::Pipe *p = NULL;
-// HEXA_NS::Elements* p = NULL;
-// PipeItem *pItem = NULL;
-// ElementsItem* pItem = NULL;
-// int nbPipe = _hexaDocument->countPipe();
-// for ( int i=0; i<nbPipe; ++i ){
-// p = _hexaDocument->getPipe(i);
-// pItem = new PipeItem(p);
-// pItem = new ElementsItem(p, _entry);
-// _pipeDirItem->appendRow(pItem);
-// _elementsDirItem->appendRow(pItem);
-// }
+ // HEXA_NS::Pipe *p = NULL;
+ // HEXA_NS::Elements* p = NULL;
+ // PipeItem *pItem = NULL;
+ // ElementsItem* pItem = NULL;
+ // int nbPipe = _hexaDocument->countPipe();
+ // for ( int i=0; i<nbPipe; ++i ){
+ // p = _hexaDocument->getPipe(i);
+ // pItem = new PipeItem(p);
+ // pItem = new ElementsItem(p, _entry);
+ // _pipeDirItem->appendRow(pItem);
+ // _elementsDirItem->appendRow(pItem);
+ // }
//********************************************************************************************************
}
+
+//void DocumentModel::fillBuilder()
+//{
+// HEXA_NS::Vector *v = NULL;
+// VectorItem *vItem = NULL;
+// int nbVector = _hexaDocument->countVector();
+// for ( int i=0; i<nbVector; ++i ){
+// v = _hexaDocument->getVector(i);
+// vItem = new VectorItem(v);
+// _vectorDirItem->appendRow(vItem);
+// }
+//
+// //******* A VOIR AVEC ALAIN POUR LE REMPLISSAGE DE L'ARBRE ELEMENTS ET CROSSELEMENTS (ByCylinder) *******/
+// //******* OU SONT STOCKES LES ELEMENTS ET LES CROSSELEMENTS DANS LE DOCUMENT? ******/
+//
+// // _cylinderDirItem
+//// HEXA_NS::Cylinder *c = NULL;
+//// HEXA_NS::Elements* c = NULL;
+//// CylinderItem *cItem = NULL;
+//// ElementsItem* cItem = NULL;
+//// int nbCylinder = _hexaDocument->countCylinder();
+//// for ( int i=0; i<nbCylinder; ++i ){
+//// c = _hexaDocument->getCylinder(i);
+//// cItem = new CylinderItem(c, _entry);
+//// cItem = new ElementsItem(c, _entry);
+//// _cylinderDirItem->appendRow(cItem);
+//// _elementsDirItem->appendRow(cItem);
+//// }
+//
+// // _pipeDirItem
+//// HEXA_NS::Pipe *p = NULL;
+//// HEXA_NS::Elements* p = NULL;
+//// PipeItem *pItem = NULL;
+//// ElementsItem* pItem = NULL;
+//// int nbPipe = _hexaDocument->countPipe();
+//// for ( int i=0; i<nbPipe; ++i ){
+//// p = _hexaDocument->getPipe(i);
+//// pItem = new PipeItem(p);
+//// pItem = new ElementsItem(p, _entry);
+//// _pipeDirItem->appendRow(pItem);
+//// _elementsDirItem->appendRow(pItem);
+//// }
+// //********************************************************************************************************
+//}
+
void DocumentModel::fillGeometry()
{
PatternGeomSelectionModel* pgsm = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
- if (_hexaDocument == NULL || isEmpty() || pgsm == NULL)
+ if (_hexaDocument == NULL /*|| isEmpty()*/ || pgsm == NULL)
return;
HEXA_NS::NewShape* shape;
shapeById[shapeName+","+QString::number(node->getIdent())] = node;
// * update the compound of vertices
- if (shape->getOrigin() == HEXA_NS::SH_CLOUD && !vertexCompound.IsNull())
+ if (shape->getOrigin() == HEXA_NS::SH_CLOUD && !vertexCompound.IsNull() && !node->getShape().IsNull())
compoundBuilder.Add(topo_shapes[shapeName], node->getShape());
}
_propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
}
+/**********************************************************
void DocumentModel::allowCrossElementsSelectionOnly()
{
_vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
_lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
_propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
}
+ ********************************************************** */
void DocumentModel::allowLawSelectionOnly()
{
return edgeIndex;
}
+QModelIndex DocumentModel::addEdgeVector( const QModelIndex &i_v, const QModelIndex &i_vec )
+{
+ QModelIndex edgeIndex;
+
+ HEXA_NS::Vertex* hv = getHexaPtr<HEXA_NS::Vertex*>(i_v);
+ HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(i_vec);
+
+ if (hv == NULL || hvec == NULL) return edgeIndex;
+
+ HEXA_NS::Edge* he = _hexaDocument->addEdgeVector( hv, hvec );
+ if ( BadElement(he) ) return edgeIndex;
+
+ HEXA_NS::Vertex* hv2 = he->getAval(); //the new vertex resulting from the creation of the edge
+ if (hv2 == NULL) return edgeIndex;
+
+ //ADD the edge in the treeview
+ EdgeItem* e = new EdgeItem(he, _entry);
+ _edgeDirItem->appendRow(e);
+ edgeIndex = e->index();
+
+ //The resulting Vertex
+ VertexItem* v = new VertexItem(hv2, _entry);
+ _vertexDirItem->appendRow(v);
+
+ emit patternDataChanged();
+
+ return edgeIndex;
+}
+
QModelIndex DocumentModel::addQuadVertices( const QModelIndex &i_v0, const QModelIndex &i_v1,
const QModelIndex &i_v2, const QModelIndex &i_v3 )
{ //CS_TODO : gestion erreur
HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(i_v2);
HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(i_v3);
- if ( hv0 and hv1 and hv2 and hv3 ){
+ if ( hv0 && hv1 && hv2 && hv3 ){
HEXA_NS::Quad* hq = _hexaDocument->addQuadVertices( hv0, hv1, hv2, hv3 );
if ( BadElement(hq) ) return quadIndex;
HEXA_NS::Edge* he2 = getHexaPtr<HEXA_NS::Edge*>(e2);
HEXA_NS::Edge* he3 = getHexaPtr<HEXA_NS::Edge*>(e3);
- if ( he0 and he1 and he2 and he3 ){
+ if ( he0 && he1 && he2 && he3 ){
HEXA_NS::Quad* hq = _hexaDocument->addQuad( he0, he1, he2, he3 );
if ( BadElement(hq) ) return quadIndex;
return iElts;
}
-
-
QModelIndex DocumentModel::makeRotation( const QModelIndex& ielts,
const QModelIndex& iv,
const QModelIndex& ivec, double angle )
return false;
}
-QModelIndex DocumentModel::replace( const QModelIndexList& iquadsPattern,
- const QModelIndex& ip1, const QModelIndex& ic1,
- const QModelIndex& ip2, const QModelIndex& ic2,
- const QModelIndex& ip3, const QModelIndex& ic3 )
+QModelIndex DocumentModel::replace( const QModelIndexList& iquads_source,
+ const QModelIndexList& iquads_dest,
+ const QModelIndex& ip1_source, const QModelIndex& ic1_dest,
+ const QModelIndex& ip2_source, const QModelIndex& ic2_dest)
{
QModelIndex ielts;
- HEXA_NS::Vertex* hp1 = getHexaPtr<HEXA_NS::Vertex*>(ip1);
- HEXA_NS::Vertex* hc1 = getHexaPtr<HEXA_NS::Vertex*>(ic1);
- HEXA_NS::Vertex* hp2 = getHexaPtr<HEXA_NS::Vertex*>(ip2);
- HEXA_NS::Vertex* hc2 = getHexaPtr<HEXA_NS::Vertex*>(ic2);
- HEXA_NS::Vertex* hp3 = getHexaPtr<HEXA_NS::Vertex*>(ip3);
- HEXA_NS::Vertex* hc3 = getHexaPtr<HEXA_NS::Vertex*>(ic3);
+ HEXA_NS::Vertex* hp1 = getHexaPtr<HEXA_NS::Vertex*>(ip1_source);
+ HEXA_NS::Vertex* hp2 = getHexaPtr<HEXA_NS::Vertex*>(ip2_source);
+ HEXA_NS::Vertex* hc1 = getHexaPtr<HEXA_NS::Vertex*>(ic1_dest);
+ HEXA_NS::Vertex* hc2 = getHexaPtr<HEXA_NS::Vertex*>(ic2_dest);
- HEXA_NS::Quads hquads;
+ HEXA_NS::Quads hquads_source, hquads_dest;
HEXA_NS::Quad* hquad = NULL;
- foreach( const QModelIndex& iquad, iquadsPattern ){
+ foreach( const QModelIndex& iquad, iquads_source ){
hquad = getHexaPtr<HEXA_NS::Quad*>(iquad);
- hquads.push_back( hquad );
+ hquads_source.push_back( hquad );
}
- HEXA_NS::Elements* helts = _hexaDocument->replace( hquads,
- hp1, hc1, hp2, hc2, hp3, hc3 );
- if ( BadElement(helts) ) return ielts;
+ foreach( const QModelIndex& iquad, iquads_dest) {
+ hquad = getHexaPtr<HEXA_NS::Quad*>(iquad);
+ hquads_dest.push_back(hquad);
+ }
+
+ HEXA_NS::Elements* helts = _hexaDocument->replace( hquads_source,
+ hquads_dest,
+ hp1, hc1, hp2, hc2);
+ if ( BadElement(helts) )
+ return ielts;
updateData();
ElementsItem* eltsItem = new ElementsItem(helts);
PatternDataModel::PatternDataModel( QObject * parent ) :
QSortFilterProxyModel( parent )
{
- QString dataRegExp = QString("(%1|%2|%3|%4|%5|%6|%7|%8)").
- arg(VERTEX_TREE).arg(EDGE_TREE).arg(QUAD_TREE).arg(HEXA_TREE).
- arg(VERTEX_DIR_TREE).arg(EDGE_DIR_TREE).arg(QUAD_DIR_TREE).arg(HEXA_DIR_TREE);
+ QString dataRegExp = QString("(%1|%2|%3|%4|%5|%6|%7|%8|%9|%10|%11|%12)").
+ arg(VERTEX_TREE).arg(EDGE_TREE).arg(QUAD_TREE).arg(HEXA_TREE).arg(VECTOR_TREE).arg(ELEMENTS_TREE).
+ arg(VERTEX_DIR_TREE).arg(EDGE_DIR_TREE).arg(QUAD_DIR_TREE).arg(HEXA_DIR_TREE).arg(VECTOR_DIR_TREE).
+ arg(ELEMENTS_DIR_TREE);
setFilterRole(HEXA_TREE_ROLE);
setFilterRegExp ( QRegExp(dataRegExp) );
QVariant PatternDataModel::headerData ( int section, Qt::Orientation orientation, int role ) const
{
- if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
+ if ( section == 0 && orientation == Qt::Horizontal && role == Qt::DisplayRole ){
return QVariant( "Data" );
} else {
return QSortFilterProxyModel::headerData ( section, orientation, role );
return item;
}
-PatternBuilderModel::PatternBuilderModel( QObject * parent ) :
- QSortFilterProxyModel( parent )
-{
- QString builderRegExp =QString("(%1|%2|%3|%4|%5|%6)").
- arg(VECTOR_TREE).arg(ELEMENTS_TREE).
- arg(CROSSELEMENTS_TREE).arg(VECTOR_DIR_TREE).arg(ELEMENTS_DIR_TREE).arg(CROSSELEMENTS_DIR_TREE);
-
- setFilterRole( HEXA_TREE_ROLE );
- setFilterRegExp ( QRegExp( builderRegExp ) );
-}
-
-PatternBuilderModel::~PatternBuilderModel()
-{
-}
+//PatternBuilderModel::PatternBuilderModel( QObject * parent ) :
+// QSortFilterProxyModel( parent )
+//{
+// QString builderRegExp =QString("(%1|%2|%3|%4|%5|%6)").
+// arg(VECTOR_TREE).arg(ELEMENTS_TREE).
+// arg(CROSSELEMENTS_TREE).arg(VECTOR_DIR_TREE).arg(ELEMENTS_DIR_TREE).arg(CROSSELEMENTS_DIR_TREE);
+//
+// setFilterRole( HEXA_TREE_ROLE );
+// setFilterRegExp ( QRegExp( builderRegExp ) );
+//}
-Qt::ItemFlags PatternBuilderModel::flags(const QModelIndex &index) const
-{
- Qt::ItemFlags flags;
+//PatternBuilderModel::~PatternBuilderModel()
+//{
+//}
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- flags = m->flags( mapToSource(index) );
- }
- return flags;
-}
+//Qt::ItemFlags PatternBuilderModel::flags(const QModelIndex &index) const
+//{
+// Qt::ItemFlags flags;
+//
+// DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+// if ( m != NULL ){
+// flags = m->flags( mapToSource(index) );
+// }
+// return flags;
+//}
-QVariant PatternBuilderModel::headerData ( int section, Qt::Orientation orientation, int role ) const
-{
- if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
- return QVariant( "Builder" );
- } else {
- return QSortFilterProxyModel::headerData ( section, orientation, role );
- }
-}
+//QVariant PatternBuilderModel::headerData ( int section, Qt::Orientation orientation, int role ) const
+//{
+// if ( section == 0 && orientation == Qt::Horizontal && role == Qt::DisplayRole ){
+// return QVariant( "Builder" );
+// } else {
+// return QSortFilterProxyModel::headerData ( section, orientation, role );
+// }
+//}
-QStandardItem* PatternBuilderModel::itemFromIndex ( const QModelIndex & index ) const
-{
- QStandardItem *item = NULL;
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- item = m->itemFromIndex( mapToSource(index) );
- }
- return item;
-}
+//QStandardItem* PatternBuilderModel::itemFromIndex ( const QModelIndex & index ) const
+//{
+// QStandardItem *item = NULL;
+// DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+// if ( m != NULL ){
+// item = m->itemFromIndex( mapToSource(index) );
+// }
+// return item;
+//}
//====================================================================
// PatternGeomModel
QVariant PatternGeomModel::headerData ( int section, Qt::Orientation orientation, int role ) const
{
- if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
+ if ( section == 0 && orientation == Qt::Horizontal && role == Qt::DisplayRole ){
return QVariant( "Geometry" );
} else {
return QSortFilterProxyModel::headerData ( section, orientation, role );
QVariant AssociationsModel::headerData ( int section, Qt::Orientation orientation, int role ) const
{
- if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
+ if ( section == 0 && orientation == Qt::Horizontal && role == Qt::DisplayRole ){
return QVariant( "Associations" );
} else {
return QSortFilterProxyModel::headerData ( section, orientation, role );
QVariant GroupsModel::headerData ( int section, Qt::Orientation orientation, int role ) const
{
- if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
+ if ( section == 0 && orientation == Qt::Horizontal && role == Qt::DisplayRole ){
return QVariant( "Groups" );
} else {
return QSortFilterProxyModel::headerData ( section, orientation, role );
QVariant MeshModel::headerData ( int section, Qt::Orientation orientation, int role ) const
{
- if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
+ if ( section == 0 && orientation == Qt::Horizontal && role == Qt::DisplayRole ){
return QVariant( "Mesh" );
} else {
return QSortFilterProxyModel::headerData ( section, orientation, role );
QModelIndex DocumentModel::makeCartesian(const QModelIndex& icenter,
const QModelIndex& ibase, const QModelIndex& ivec, const QModelIndex& iaxis,
- vector<double>& radius, vector<double>& angles, vector<double>& heights)
+ std::vector<double>& radius, std::vector<double>& angles, std::vector<double>& heights)
{
QModelIndex result;
QModelIndex DocumentModel::makeSphere (QModelIndex& icenter,
QModelIndex& ivec_x, QModelIndex& ivec_z,
- vector<double>& tray, vector<double>& tang, vector<double>& thaut)
+ std::vector<double>& tray, std::vector<double>& tang, std::vector<double>& thaut)
{
QModelIndex result;
QModelIndex DocumentModel::makeSpherical (QModelIndex& icenter,
QModelIndex& ivec_x, QModelIndex& ivec_z,
- vector<double>& rayon,
+ std::vector<double>& rayon,
int crit)
{
QModelIndex result;
QModelIndex DocumentModel::makeRind (QModelIndex& icenter,
QModelIndex& ivec_x, QModelIndex& ivec_z,
- vector<double>& tray, vector<double>& tang, vector<double>& thaut)
+ std::vector<double>& tray, std::vector<double>& tang, std::vector<double>& thaut)
{
QModelIndex result;
}
QModelIndex DocumentModel::makeCylinder(QModelIndex& iorig, QModelIndex& ivecx, QModelIndex& ivecz,
- vector<double>& tray, vector<double>& tang, vector<double>& thaut)
+ std::vector<double>& tray, std::vector<double>& tang, std::vector<double>& thaut)
{
QModelIndex result;
}
QModelIndex DocumentModel::makePipe(QModelIndex& iorig, QModelIndex& ivecx, QModelIndex& ivecz,
- vector<double>& tray, vector<double>& tang, vector<double>& thaut)
+ std::vector<double>& tray, std::vector<double>& tang, std::vector<double>& thaut)
{
QModelIndex result;
HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
HEXA_NS::Vertex* hv4 = getHexaPtr<HEXA_NS::Vertex*>(iv4);
- HEXA_NS::Elements* helts = _hexaDocument->joinQuadUni(hstart, hdest, hv1, hv2, hv3, hv4, nb);
+ // Be careful, the order of vertices is not the same in joinQuadUni of HexDocument_v6.cxx
+ // and corresponding python dump
+ HEXA_NS::Elements* helts = _hexaDocument->joinQuadUni(hstart, hdest, hv1, hv3, hv2, hv4, nb);
if (BadElement(helts))
return result;
}
QModelIndex DocumentModel::joinQuad(QModelIndex& istart, QModelIndex& idest, QModelIndex& iva1, QModelIndex& ivb1,
- QModelIndex& iva2, QModelIndex& ivb2, vector<double>& tlen)
+ QModelIndex& iva2, QModelIndex& ivb2, std::vector<double>& tlen)
{
QModelIndex result;
HEXA_NS::Vertex* hva2 = getHexaPtr<HEXA_NS::Vertex*>(iva2);
HEXA_NS::Vertex* hvb2 = getHexaPtr<HEXA_NS::Vertex*>(ivb2);
- HEXA_NS::Elements* helts = _hexaDocument->joinQuad(hstart, hdest, hva1, hvb1, hva2, hvb2, tlen);
+ // Be careful, the order of vertices is not the same in joinQuadUni of HexDocument_v6.cxx
+ // and corresponding python dump
+ HEXA_NS::Elements* helts = _hexaDocument->joinQuad(hstart, hdest, hva1, hva2, hvb1, hvb2, tlen);
if (BadElement(helts))
return result;
HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
HEXA_NS::Vertex* hv4 = getHexaPtr<HEXA_NS::Vertex*>(iv4);
- HEXA_NS::Elements* helts = _hexaDocument->joinQuadsUni(hstarts, hdest, hv1, hv2, hv3, hv4, nb);
+ // Be careful, the order of vertices is not the same in joinQuadUni of HexDocument_v6.cxx
+ // and corresponding python dump
+ HEXA_NS::Elements* helts = _hexaDocument->joinQuadsUni(hstarts, hdest, hv1, hv3, hv2, hv4, nb);
if (BadElement(helts))
return result;
}
QModelIndex DocumentModel::joinQuads(QModelIndexList& istarts, QModelIndex& idest, QModelIndex& iva1, QModelIndex& ivb1,
- QModelIndex& iva2, QModelIndex& ivb2, vector<double>& tlen)
+ QModelIndex& iva2, QModelIndex& ivb2, std::vector<double>& tlen)
{
QModelIndex result;
HEXA_NS::Vertex* hva2 = getHexaPtr<HEXA_NS::Vertex*>(iva2);
HEXA_NS::Vertex* hvb2 = getHexaPtr<HEXA_NS::Vertex*>(ivb2);
- HEXA_NS::Elements* helts = _hexaDocument->joinQuads(hstarts, hdest, hva1, hvb1, hva2, hvb2, tlen);
+ // Be careful, the order of vertices is not the same in joinQuadUni of HexDocument_v6.cxx
+ // and corresponding python dump
+ HEXA_NS::Elements* helts = _hexaDocument->joinQuads(hstarts, hdest, hva1, hva2, hvb1, hvb2, tlen);
if (BadElement(helts))
return result;
}
QModelIndex DocumentModel::revolutionQuad(QModelIndex& istart, QModelIndex& icenter, QModelIndex& iaxis,
- vector<double>& angles)
+ std::vector<double>& angles)
{
QModelIndex result;
}
QModelIndex DocumentModel::revolutionQuads(QModelIndexList& istarts, QModelIndex& icenter, QModelIndex& iaxis,
- vector<double>& angles)
+ std::vector<double>& angles)
{
QModelIndex result;
return result;
}
-QModelIndex DocumentModel::extrudeQuad(QModelIndex& istart, QModelIndex& dv, vector<double>& tlen)
+QModelIndex DocumentModel::extrudeQuad(QModelIndex& istart, QModelIndex& dv, std::vector<double>& tlen)
{
QModelIndex result;
return result;
}
-QModelIndex DocumentModel::extrudeQuads(QModelIndexList& istarts, QModelIndex& iaxis, vector<double>& tlen)
+QModelIndex DocumentModel::extrudeQuads(QModelIndexList& istarts, QModelIndex& iaxis, std::vector<double>& tlen)
{
QModelIndex result;
return result;
}
-QModelIndex DocumentModel::cut(QModelIndex& iEdge, vector<double>& tlen)
+QModelIndex DocumentModel::cut(QModelIndex& iEdge, std::vector<double>& tlen)
{
QModelIndex result;
