diff --git a/Docs/CMakeLists.txt b/Docs/CMakeLists.txt index 41375b6..4bb6d05 100644 --- a/Docs/CMakeLists.txt +++ b/Docs/CMakeLists.txt @@ -42,9 +42,6 @@ set(DOXYGEN_DIRS ${PROJECT_SOURCE_DIR}/src/Core/protected/Topo/EdgeMeshingPropertyGlobalInterpolate.h ${PROJECT_SOURCE_DIR}/src/Core/protected/Topo/EdgeMeshingPropertyTabulated.h ${PROJECT_SOURCE_DIR}/src/Core/protected/Topo/EdgeMeshingPropertyBeta.h - ${PROJECT_SOURCE_DIR}/src/Core/protected/Topo/FaceMeshingPropertyDirectional.h - ${PROJECT_SOURCE_DIR}/src/Core/protected/Topo/FaceMeshingPropertyOrthogonal.h - ${PROJECT_SOURCE_DIR}/src/Core/protected/Topo/FaceMeshingPropertyRotational.h ${PROJECT_SOURCE_DIR}/src/Core/protected/Topo/FaceMeshingPropertyTransfinite.h ${PROJECT_SOURCE_DIR}/src/Core/protected/Topo/FaceMeshingPropertyDelaunayGMSH.h ${PROJECT_SOURCE_DIR}/src/Core/protected/Topo/FaceMeshingPropertyQuadPairing.h diff --git a/src/Core/Internal/ImportMDLImplementation.cpp b/src/Core/Internal/ImportMDLImplementation.cpp index 964c091..d06baf2 100644 --- a/src/Core/Internal/ImportMDLImplementation.cpp +++ b/src/Core/Internal/ImportMDLImplementation.cpp @@ -530,7 +530,6 @@ void ImportMDLImplementation::performTopo(Internal::InfoCommand* icmd) } // sélection de la méthode transfinie ou directionnelle si possible m_icmd->addTopoInfoEntity (coface, Internal::InfoCommand::CREATED); - coface->selectBasicMeshLaw(m_icmd); } else { // cas non-structuré diff --git a/src/Core/Internal/ServiceGeomToTopo.cpp b/src/Core/Internal/ServiceGeomToTopo.cpp index 5295061..2d0c935 100644 --- a/src/Core/Internal/ServiceGeomToTopo.cpp +++ b/src/Core/Internal/ServiceGeomToTopo.cpp @@ -73,8 +73,6 @@ bool ServiceGeomToTopo::convertBlockStructured(const int ni, const int nj, const if (bloc->structurable()){ bloc->structure(m_icmd); - bloc->selectBasicMeshLaw(m_icmd); - // cas où le nombre de bras est donné par l'utilisateur if (ni>0 && nj>0 && nk>0){ std::vector coedges; @@ -114,8 +112,6 @@ bool ServiceGeomToTopo::convertCoFaceStructured() if (coface->structurable()){ coface->structure(m_icmd); - coface->selectBasicMeshLaw(m_icmd); - return false; // ok } else diff --git a/src/Core/Mesh/MeshImplementationStructured.cpp b/src/Core/Mesh/MeshImplementationStructured.cpp index 4bf5c77..8c094b1 100644 --- a/src/Core/Mesh/MeshImplementationStructured.cpp +++ b/src/Core/Mesh/MeshImplementationStructured.cpp @@ -17,9 +17,6 @@ #include "Topo/TopoHelper.h" #include "Topo/EdgeMeshingPropertyUniform.h" #include "Topo/EdgeMeshingPropertyTabulated.h" -#include "Topo/FaceMeshingPropertyDirectional.h" -#include "Topo/FaceMeshingPropertyOrthogonal.h" -#include "Topo/FaceMeshingPropertyRotational.h" #include "Topo/BlockMeshingData.h" #include "Topo/TopoHelper.h" @@ -71,10 +68,6 @@ void MeshImplementation::preMeshStrutured(Topo::Block* bl) { std::cout <<"Maillage du bloc structuré "<getName()<<" avec la méthode " << bl->getMeshLawName(); - if (bl->getMeshLaw() == Topo::BlockMeshingProperty::rotational - || bl->getMeshLaw() == Topo::BlockMeshingProperty::directional - || bl->getMeshLaw() == Topo::BlockMeshingProperty::orthogonal) - std::cout << " et direction "<<(short)bl->getBlockMeshingProperty()->getDir(); std::cout << std::endl; std::vector groupsName; @@ -511,137 +504,16 @@ void MeshImplementation::preMeshStrutured(Topo::CoFace* coface) }// end for cote<4 - if (coface->getMeshLaw() == Topo::CoFaceMeshingProperty::transfinite) + if (coface->getMeshLaw() == Topo::CoFaceMeshingProperty::transfinite) { discretiseTransfinie(nbBrasI, nbBrasJ, l_points); - else if (coface->getMeshLaw() == Topo::CoFaceMeshingProperty::rotational){ - Utils::Math::Point axis1; - Utils::Math::Point axis2; - Topo::FaceMeshingPropertyRotational* prop = - dynamic_cast(coface->getCoFaceMeshingProperty()); - CHECK_NULL_PTR_ERROR(prop); - prop->getAxis(axis1, axis2); - uint dir = prop->getDir(); - - discretiseRotation(nbBrasI, nbBrasJ, 0, l_points, axis1, axis2, dir); - - } - else if (coface->getMeshLaw() == Topo::CoFaceMeshingProperty::directional - || coface->getMeshLaw() == Topo::CoFaceMeshingProperty::orthogonal){ - - Topo::CoEdgeMeshingProperty *empI, *empJ; - Topo::FaceMeshingPropertyDirectional* prop = - dynamic_cast(coface->getCoFaceMeshingProperty()); - CHECK_NULL_PTR_ERROR(prop); - uint dir = prop->getDir(); - Topo::CoEdgeMeshingProperty *empDir[2]; - - // il faut retrouver si possible la discrétisation depuis une arête - // on peut se permettre de reconstruire une loi uniforme pour les directions - // qui ne sont pas celle de la discrétisation - if (dir == 0){ - bool is_inverted; - empDir[1] = new Topo::EdgeMeshingPropertyUniform(nbBrasJ); - Topo::CoEdgeMeshingProperty * empTmp = coface->getMeshingProperty(Topo::CoFace::i_dir, is_inverted); - // si elle est interpolée, on s'en passe - if (empTmp && empTmp->getMeshLaw() != Topo::CoEdgeMeshingProperty::interpolate){ - empDir[0] = empTmp->clone(); - if (is_inverted) - empDir[0]->setDirect(!empDir[0]->getDirect()); - } - else - empDir[0] = 0; - - } else { - bool is_inverted; - empDir[0] = new Topo::EdgeMeshingPropertyUniform(nbBrasI); - Topo::CoEdgeMeshingProperty * empTmp = coface->getMeshingProperty(Topo::CoFace::j_dir, is_inverted); - // si elle est interpolée, on s'en passe - if (empTmp && empTmp->getMeshLaw() != Topo::CoEdgeMeshingProperty::interpolate){ - empDir[1] = empTmp->clone(); - if (is_inverted) - empDir[1]->setDirect(!empDir[1]->getDirect()); - } - else - empDir[1] = 0; - } - - // si la discrétisation est nulle (cas interpolée ou composée), on la remplace par une version tabulée - if (empDir[dir] == 0){ - std::vector coedges; - Topo::Vertex* vtx1; - Topo::Vertex* vtx2; - std::map ratios; - if (dir == 0){ - Topo::Edge* edge = coface->getEdge(1); - edge->getCoEdges(coedges); - vtx1 = coface->getVertex(1); - vtx2 = coface->getVertex(2); - for (uint i=0; igetRatio(coedges[i]); - - } - else { - Topo::Edge* edge = coface->getEdge(0); - edge->getCoEdges(coedges); - vtx1 = coface->getVertex(1); - vtx2 = coface->getVertex(0); - for (uint i=0; igetRatio(coedges[i]); - } - - // ordonne les coedges - std::vector coedges_between; - Topo::TopoHelper::getCoEdgesBetweenVertices(vtx1, vtx2, coedges, coedges_between); - - std::vector edge_points; - Topo::TopoHelper::getPoints(vtx1, vtx2, coedges_between, ratios, edge_points); - - // calcul des longueurs des bras - std::vector tabulation; - for (uint i=1; igetMeshLaw() == Topo::CoFaceMeshingProperty::orthogonal){ - Topo::FaceMeshingPropertyOrthogonal* fmp = dynamic_cast(prop); - CHECK_NULL_PTR_ERROR(fmp); - uint side = fmp->getSide(); - uint nbLayers = fmp->getNbLayers(); - // recherche de la surface / laquelle il faut être orthogonal - // on ne connait pas la normale à une courbe ... - Geom::Surface* surface = 0; - Topo::Edge* edge = coface->getEdge(dir+side*2); - std::vector coedges; - edge->getCoEdges(coedges); - //std::cout<<"orthogonal pour "<getName()<<" dir="<getName()<getGeomAssociation() && coface->getMeshLaw() > Topo::CoFaceMeshingProperty::rotational){ + if (coface->getGeomAssociation()){ #ifdef _DEBUG_MESH std::cout <<" Projection des noeuds de la coface "<getName()<<" sur la surface "<getGeomAssociation()->getName()< &ratios) } // end for i iCoedges[3]; - getOrientedCoEdges(iCoedges[0], iCoedges[1], iCoedges[2]); - - std::vector sommets; - getHexaVertices(sommets); - - // une des 3 directions convient-elle ? - for (uint j=0; j<3; j++){ - std::vector > coedges_dirs; - for (uint k=0; k<4; k++){ - std::vector coedges_dir1; - - TopoHelper::getCoEdgesBetweenVertices(sommets[TopoHelper::tabIndVtxByEdgeAndDirOnBlock[j][k][0]], - sommets[TopoHelper::tabIndVtxByEdgeAndDirOnBlock[j][k][1]], - iCoedges[j], - coedges_dir1); - coedges_dirs.push_back(coedges_dir1); - - } // end for k - } // end for j -} -/*----------------------------------------------------------------------------*/ Utils::Math::Point Block::getBarycentre() const { Utils::Math::Point barycentre; diff --git a/src/Core/Topo/CoFace.cpp b/src/Core/Topo/CoFace.cpp index 3888d54..8174dce 100644 --- a/src/Core/Topo/CoFace.cpp +++ b/src/Core/Topo/CoFace.cpp @@ -26,9 +26,6 @@ #include "Topo/CommandEditTopo.h" #include "Topo/EdgeMeshingPropertyUniform.h" #include "Topo/EdgeMeshingPropertyInterpolate.h" -#include "Topo/FaceMeshingPropertyDirectional.h" -#include "Topo/FaceMeshingPropertyOrthogonal.h" -#include "Topo/FaceMeshingPropertyRotational.h" #include "Topo/FaceMeshingPropertyTransfinite.h" #include "Topo/FaceMeshingPropertyDelaunayGMSH.h" @@ -161,25 +158,17 @@ CoFace(Internal::Context& ctx, } /*----------------------------------------------------------------------------*/ CoFace:: -CoFace(Internal::Context& ctx, int ni, int nj, - CoFaceMeshingProperty::meshLaw ml, - CoFaceMeshingProperty::meshDirLaw md) +CoFace(Internal::Context& ctx, int ni, int nj) : TopoEntity(ctx, ctx.newProperty(Utils::Entity::TopoCoFace), ctx.newDisplayProperties(Utils::Entity::TopoCoFace)) , m_topo_property(new CoFaceTopoProperty()) , m_save_topo_property(0) -, m_mesh_property(0) +, m_mesh_property(new FaceMeshingPropertyTransfinite()) , m_save_mesh_property(0) , m_mesh_data(new CoFaceMeshingData()) , m_save_mesh_data(0) { - if (ml == CoFaceMeshingProperty::directional) - m_mesh_property =new FaceMeshingPropertyDirectional(md); - else - m_mesh_property =new FaceMeshingPropertyTransfinite(); - - // face avec les sommets équivalents à ceux d'une surface de taille 1 std::vector vertices; vertices.push_back(new Topo::Vertex(ctx, Utils::Math::Point(1,0,0))); @@ -955,12 +944,6 @@ split2(eDirOnCoFace dir, std::vector& edges1, std::vector& edges3, coface2->getGroupsContainer().add(gr); } - // recherche de la méthode de maillage qui semble la plus adaptée - if (getMeshLaw() == CoFaceMeshingProperty::directional){ - coface1->selectBasicMeshLaw(icmd); - coface2->selectBasicMeshLaw(icmd); - } - // on ajoute les 2 CoFaces aux faces for (uint i=0; isaveFaceTopoProperty(icmd); @@ -1217,13 +1200,6 @@ split3(eDirOnCoFace dir, std::vector& edges1, std::vector& edges3, coface3->getGroupsContainer().add(gr); } - // recherche de la méthode de maillage qui semble la plus adaptée - if (getMeshLaw() == CoFaceMeshingProperty::directional){ - coface1->selectBasicMeshLaw(icmd); - coface2->selectBasicMeshLaw(icmd); - coface3->selectBasicMeshLaw(icmd); - } - // on ajoute les 3 CoFaces aux faces for (uint i=0; isaveFaceTopoProperty(icmd); @@ -1499,11 +1475,6 @@ splitOgrid(eDirOnCoFace dir, coface2->getGroupsContainer().add(gr); } - // recherche de la méthode de maillage qui semble la plus adaptée - coface0->selectBasicMeshLaw(icmd); - coface1->selectBasicMeshLaw(icmd); - coface2->selectBasicMeshLaw(icmd); - } else if (edges1.size() == 3){ // cas de la création de 4 faces en Ogrid @@ -1722,12 +1693,6 @@ splitOgrid(eDirOnCoFace dir, coface3->getGroupsContainer().add(gr); } - // recherche de la méthode de maillage qui semble la plus adaptée - coface0->selectBasicMeshLaw(icmd); - coface1->selectBasicMeshLaw(icmd); - coface2->selectBasicMeshLaw(icmd); - coface3->selectBasicMeshLaw(icmd); - } // end else if (edges1.size() == 3) @@ -2077,63 +2042,12 @@ getRepresentation(Utils::DisplayRepresentation& dr, bool checkDestroyed) const if (isStructured()){ uint lastId = (getNbVertices() == 3?0:3); - Edge* edge1=0; - Edge* edge2=0; - if (m_mesh_property->getMeshLaw() == CoFaceMeshingProperty::directional){ - FaceMeshingPropertyDirectional* mp = dynamic_cast(m_mesh_property); - CHECK_NULL_PTR_ERROR(mp); - if (mp->getDir() == 1){ - edge1 = getEdge(0); - edge2 = getEdge(1); - } - else { - edge1 = getEdge(1); - edge2 = getEdge(0); - } - } - else if (m_mesh_property->getMeshLaw() == CoFaceMeshingProperty::orthogonal){ - FaceMeshingPropertyOrthogonal* mp = dynamic_cast(m_mesh_property); - CHECK_NULL_PTR_ERROR(mp); - if (mp->getDir() == 1){ - edge1 = getEdge(0); - if (mp->getSide() == 1){ - // cas où il faut prendre les arêtes de l'autre côté - edge2 = getEdge(getVertex(0), getVertex(lastId)); - } - else - edge2 = getEdge(1); - } - else { - edge1 = getEdge(1); - if (mp->getSide() == 1){ - // cas où il faut prendre les arêtes de l'autre côté - edge2 = getEdge(getVertex(2), getVertex(lastId)); - } - else - edge2 = getEdge(0); - } - } - else if (m_mesh_property->getMeshLaw() == CoFaceMeshingProperty::rotational){ - FaceMeshingPropertyRotational* mp = dynamic_cast(m_mesh_property); - CHECK_NULL_PTR_ERROR(mp); - if (mp->getDir() == 1){ - edge1 = getEdge(0); - edge2 = getEdge(1); - } - else { - edge1 = getEdge(1); - edge2 = getEdge(0); - } - } - else { - edge1 = getEdge(1); - edge2 = getEdge(0); - } + Edge* edge1 = getEdge(1); + Edge* edge2 = getEdge(0); // std::cout<<"CoFace::getRepresentation pour "<getName()<<" - "<getName()< points_edge1; std::vector points_edge2; edge1->getPoints(points_edge1); @@ -2207,61 +2121,19 @@ getRepresentation(Utils::DisplayRepresentation& dr, bool checkDestroyed) const // std::cout<<" vect1 : "<getMeshLaw() == CoFaceMeshingProperty::rotational){ - FaceMeshingPropertyRotational* mp = dynamic_cast(m_mesh_property); - CHECK_NULL_PTR_ERROR(mp); - Utils::Math::Point axis1, axis2; - mp->getAxis(axis1, axis2); - - // on cherche à minimiser la distance entre l'axe et l'un des points - // avec l'une des options pour la direction - Utils::Math::Point option1 = (vect1*0.5+vect2*(0.5+0.1)+vect3*(0.5))*ratio+orig; - Utils::Math::Point option2 = (vect1*0.5+vect2*(0.5-0.1)+vect3*(0.5))*ratio+orig; - Utils::Math::Point option3 = (vect1*0.5+vect2*(0.5)+vect3*(0.5+0.1))*ratio+orig; - Utils::Math::Point option4 = (vect1*0.5+vect2*(0.5)+vect3*(0.5-0.1))*ratio+orig; - - uint best_option = 1; - double dist = (axis1-option1).norme2(); - - if ((axis1-option2).norme2()getMeshLaw() == CoFaceMeshingProperty::directional - || m_mesh_property->getMeshLaw() == CoFaceMeshingProperty::orthogonal){ - points.push_back(vect1*1.1+vect2*0.6); - points.push_back(vect1*1.1+vect2*0.2); - points.push_back(vect1*1.3+vect2*0.4); - } else if (m_mesh_property->getMeshLaw() == CoFaceMeshingProperty::rotational){ - if (dec2>0.0){ - points.push_back(vect1*1.2+vect2*0.5); - points.push_back(vect1*1.0+vect2*0.7); - points.push_back(vect1*1.2+vect2*0.7); - } else if (dec2<0.0) { - points.push_back(vect1*1.0+vect2*0.1); - points.push_back(vect1*1.2+vect2*0.3); - points.push_back(vect1*1.2+vect2*0.1); - } else { - points.push_back(vect1*1.1+vect2*0.6+vect3*dec3*2); - points.push_back(vect1*1.1+vect2*0.2+vect3*dec3*2); - points.push_back(vect1*1.3+vect2*0.4+vect3*dec3*4); - } - } if (points.size() > 12){ indices.push_back(3); indices.push_back(14); indices.push_back(13); indices.push_back(14); indices.push_back(12); indices.push_back(14); } - if (m_mesh_property->getMeshLaw() == CoFaceMeshingProperty::orthogonal){ - uint id = points.size(); - points.push_back(vect1*0.5+vect2*0.4); - points.push_back(vect1*0.5+vect2*0.5); - points.push_back(vect1*0.4+vect2*0.5); - indices.push_back(id); indices.push_back(id+1); - indices.push_back(id+2); indices.push_back(id+1); - } } // end if (isStructured()) else { @@ -3501,19 +3345,6 @@ permuteToJmaxEdge(Edge* edge, Internal::InfoCommand* icmd) m_topo_property->getEdgeContainer().add(sorted_edges); m_topo_property->getVertexContainer().clear(); m_topo_property->getVertexContainer().add(sorted_vertices); - - if (dec%2 && getMeshLaw() == CoFaceMeshingProperty::directional){ - saveCoFaceMeshingProperty(icmd); - FaceMeshingPropertyDirectional* fmp = dynamic_cast(getCoFaceMeshingProperty()); - CHECK_NULL_PTR_ERROR(fmp); - fmp->permDir(); - } - else if (dec%2 && getMeshLaw() == CoFaceMeshingProperty::orthogonal){ - saveCoFaceMeshingProperty(icmd); - FaceMeshingPropertyOrthogonal* fmp = dynamic_cast(getCoFaceMeshingProperty()); - CHECK_NULL_PTR_ERROR(fmp); - fmp->permDir(); - } } // end if (ind != 4) } /*----------------------------------------------------------------------------*/ @@ -3846,89 +3677,6 @@ uint CoFace::getNbBlocks() const return blocks.size(); } /*----------------------------------------------------------------------------*/ -void CoFace:: -selectBasicMeshLaw(Internal::InfoCommand* icmd, bool forceCompute) -{ -//#define _DEBUG_selectBasicMeshLaw -#ifdef _DEBUG_selectBasicMeshLaw - std::cout<<"selectBasicMeshLaw pour "< iCoedges[2]; - getOrientedCoEdges(iCoedges[0], iCoedges[1]); - - // la direction sélectionnée, à définir - FaceMeshingPropertyDirectional::meshDirLaw dirLaw = FaceMeshingPropertyDirectional::dir_undef; - - // dirI ok ? - { - std::vector > coedges_dirs; - std::vector coedges_dir1; - std::vector coedges_dir2; - - // il faut qu'un des côté soit en une seule arête sans ratio - bool unCoteOk = false; - - TopoHelper::getCoEdgesBetweenVertices(getVertex(1), getVertex(2), iCoedges[0], coedges_dir1); - coedges_dirs.push_back(coedges_dir1); - if (coedges_dir1.size() == 1 && getEdge(getVertex(1), getVertex(2))->getRatio(coedges_dir1[0]) == 1) - unCoteOk = true; - - if (getNbVertices() == 4){ - TopoHelper::getCoEdgesBetweenVertices(getVertex(0), getVertex(3), iCoedges[0], coedges_dir2); - coedges_dirs.push_back(coedges_dir2); - if (coedges_dir2.size() == 1 && getEdge(getVertex(0), getVertex(3))->getRatio(coedges_dir2[0]) == 1) - unCoteOk = true; - } - - if (TopoHelper::isUnidirectionalMeshable(coedges_dirs) && unCoteOk) - dirLaw = FaceMeshingPropertyDirectional::dir_i; - } - - // dirJ ok ? - { - std::vector > coedges_dirs; - std::vector coedges_dir1; - std::vector coedges_dir2; - - // il faut qu'un des côté soit en une seule arête sans ratio - bool unCoteOk = false; - - TopoHelper::getCoEdgesBetweenVertices(getVertex(1), getVertex(0), iCoedges[1], coedges_dir1); - coedges_dirs.push_back(coedges_dir1); - if (coedges_dir1.size() == 1 && getEdge(getVertex(1), getVertex(2))->getRatio(coedges_dir1[0]) == 1) - unCoteOk = true; - - Vertex* vtx3 = getVertex((getNbVertices()==4)?3:0); - TopoHelper::getCoEdgesBetweenVertices(getVertex(2), vtx3, iCoedges[1], coedges_dir2); - coedges_dirs.push_back(coedges_dir2); - if (coedges_dir2.size() == 1 && getEdge(getVertex(2), vtx3)->getRatio(coedges_dir2[0]) == 1) - unCoteOk = true; - - if (TopoHelper::isUnidirectionalMeshable(coedges_dirs) && unCoteOk) - dirLaw = FaceMeshingPropertyDirectional::dir_j; - } - - // cas où l'on trouve que le maillage peut se faire suivant une direction - if (dirLaw != FaceMeshingPropertyDirectional::dir_undef){ - saveCoFaceMeshingProperty(icmd); - FaceMeshingPropertyDirectional* mp = new FaceMeshingPropertyDirectional(dirLaw); - switchCoFaceMeshingProperty(icmd, mp); - delete mp; - -#ifdef _DEBUG_selectBasicMeshLaw - std::cout<<" on attribue "< iCoedges; - std::vector jCoedges; - - coface->getOrientedCoEdges(iCoedges, jCoedges); - - for (uint i=0; igetVertex(0)->getCoord(), coedge->getVertex(1)->getCoord()); - Utils::Math::Vector vect3 = vect1*vect2; - if (Utils::Math::MgxNumeric::isNearlyZero(vect3.abs2())) - return dir_i; - } - - for (uint i=0; igetVertex(0)->getCoord(), coedge->getVertex(1)->getCoord()); - Utils::Math::Vector vect3 = vect1*vect2; - if (Utils::Math::MgxNumeric::isNearlyZero(vect3.abs2())) - return dir_j; - } - - TkUtil::UTF8String messErr (TkUtil::Charset::UTF_8); - messErr << "Il n'est pas possible d'orienter la face commune "<getName() - << " avec les 2 points "<< v1 << " et "<< v2; - throw TkUtil::Exception(messErr); -} -/*----------------------------------------------------------------------------*/ -CoFaceMeshingProperty::meshSideLaw CoFaceMeshingProperty::_computeSide(CoFace* coface, - Utils::Math::Point & v1, Utils::Math::Point & v2, uint dir) -{ - if (dir == 0){ - if (coface->getVertex(1)->getCoord() == v1 || coface->getVertex(2)->getCoord() == v2) - return CoFaceMeshingProperty::side_min; - else if (coface->getVertex(2)->getCoord() == v1 || coface->getVertex(1)->getCoord() == v2) - return CoFaceMeshingProperty::side_max; - if (coface->getNbVertices()==4){ - if (coface->getVertex(0)->getCoord() == v1 || coface->getVertex(3)->getCoord() == v2) - return CoFaceMeshingProperty::side_min; - else if (coface->getVertex(3)->getCoord() == v1 || coface->getVertex(0)->getCoord() == v2) - return CoFaceMeshingProperty::side_max; - } - } else if (dir == 1){ - if (coface->getVertex(1)->getCoord() == v1 || coface->getVertex(0)->getCoord() == v2) - return CoFaceMeshingProperty::side_min; - else if (coface->getVertex(0)->getCoord() == v1 || coface->getVertex(1)->getCoord() == v2) - return CoFaceMeshingProperty::side_max; - uint ind_op = (coface->getNbVertices()==4?3:0); - if (coface->getVertex(2)->getCoord() == v1 || coface->getVertex(ind_op)->getCoord() == v2) - return CoFaceMeshingProperty::side_min; - else if (coface->getVertex(ind_op)->getCoord() == v1 || coface->getVertex(2)->getCoord() == v2) - return CoFaceMeshingProperty::side_max; - } else - throw TkUtil::Exception (TkUtil::UTF8String ("Erreur interne, CoFaceMeshingProperty::_computeSide / dir", TkUtil::Charset::UTF_8)); - - TkUtil::UTF8String messErr (TkUtil::Charset::UTF_8); - messErr << "Il n'est pas possible de sélectionner un côté de la face "<getName() - << " avec les 2 points "<< v1 << " et "<< v2; - throw TkUtil::Exception(messErr); -} -/*----------------------------------------------------------------------------*/ } // end namespace Topo /*----------------------------------------------------------------------------*/ } // end namespace Mgx3D diff --git a/src/Core/Topo/CommandChangeVertexSameLocation.cpp b/src/Core/Topo/CommandChangeVertexSameLocation.cpp index f417a54..d0f7ec6 100644 --- a/src/Core/Topo/CommandChangeVertexSameLocation.cpp +++ b/src/Core/Topo/CommandChangeVertexSameLocation.cpp @@ -67,9 +67,6 @@ internalExecute() auto lastcofaces = std::unique(cofaces.begin(), cofaces.end()); cofaces.erase(lastcofaces, cofaces.end()); - // recherche la méthode la plus simple possible - updateMeshLaw(cofaces,blocks); - // on parcours les entités modifiées pour sauvegarder leur état d'avant la commande saveInternalsStats(); diff --git a/src/Core/Topo/CommandChangeVerticesLocation.cpp b/src/Core/Topo/CommandChangeVerticesLocation.cpp index 85bb84b..bb414b7 100644 --- a/src/Core/Topo/CommandChangeVerticesLocation.cpp +++ b/src/Core/Topo/CommandChangeVerticesLocation.cpp @@ -140,9 +140,6 @@ internalExecute() auto lastcofaces = std::unique(cofaces.begin(), cofaces.end()); cofaces.erase(lastcofaces, cofaces.end()); - // recherche la méthode la plus simple possible - updateMeshLaw(cofaces, blocks); - // on parcours les entités modifiées pour sauvegarder leur état d'avant la commande saveInternalsStats(); diff --git a/src/Core/Topo/CommandEditTopo.cpp b/src/Core/Topo/CommandEditTopo.cpp index a1bc6d5..fd46181 100644 --- a/src/Core/Topo/CommandEditTopo.cpp +++ b/src/Core/Topo/CommandEditTopo.cpp @@ -17,7 +17,6 @@ #include "Topo/Face.h" #include "Topo/CoFace.h" #include "Topo/Block.h" -#include "Topo/FaceMeshingPropertyOrthogonal.h" #include "Topo/EdgeMeshingPropertyInterpolate.h" #include "Geom/Vertex.h" @@ -435,48 +434,6 @@ registerToManagerCreatedEntities() } // end if (t == Internal::InfoCommand::CREATED) } // end for iter -} -/*----------------------------------------------------------------------------*/ -void CommandEditTopo:: -updateMeshLaw(std::vector& cofaces, std::vector& blocks) -{ -#ifdef _DEBUG2 - uint nb_cofaces = 0; - uint nb_blocs = 0; -#endif - for(auto& coface : cofaces){ - if (coface->isDestroyed()) - continue; -#ifdef _DEBUG2 - nb_cofaces += 1; -#endif - // cas d'une méthode structurée directionnelle ou rotationnelle - if (coface->getMeshLaw() < CoFaceMeshingProperty::transfinite){ - - // on cherche une méthode la plus basique possible - coface->selectBasicMeshLaw(&getInfoCommand(), true); - - } // end if (coface->getMeshLaw() <= rotJ) - } // end for iter=l_f.begin() - - // il est préférable de le faire sur les blocs après les faces communes - // c'est pour cela que tout est dans une unique méthode - for(auto& block : blocks){ - if (block->isDestroyed()) - continue; -#ifdef _DEBUG2 - nb_blocs += 1; -#endif - if (block->getMeshLaw() < BlockMeshingProperty::transfinite){ - - // on cherche une méthode la plus basique possible - block->selectBasicMeshLaw(&getInfoCommand(), true); - - } // end if (bloc->getMeshLaw() <= rotK) - } // end for iter=l_b.begin() -#ifdef _DEBUG2 - std::cout<<"CommandEditTopo::updateMeshLaw avec "< &nb_coedges_by_vertex) @@ -723,57 +680,6 @@ getPreviewRepresentationDeletedTopo(Utils::DisplayRepresentation& dr) previewEnd(); } /*----------------------------------------------------------------------------*/ -void CommandEditTopo::setOrthogonalCoEdges(CoFace* coface, FaceMeshingPropertyOrthogonal* mp) -{ - if (mp->getDir() == 0){ - // cas orthogonalité suivant I - if (mp->getSide() == 0){ - setOrthogonalCoEdges(coface->getEdge(1), coface->getVertex(1), mp->getNbLayers()); - // pour cas non dégénéré avec 3 sommets - if (coface->getNbVertices() == 4) - setOrthogonalCoEdges(coface->getEdge(3), coface->getVertex(0), mp->getNbLayers()); - } - else { - setOrthogonalCoEdges(coface->getEdge(1), coface->getVertex(2), mp->getNbLayers()); - // pour cas non dégénéré avec 3 sommets - if (coface->getNbVertices() == 4) - setOrthogonalCoEdges(coface->getEdge(3), coface->getVertex(3), mp->getNbLayers()); - } - - } else { - // cas orthogonalité suivant J - if (mp->getSide() == 0){ - setOrthogonalCoEdges(coface->getEdge(0), coface->getVertex(1), mp->getNbLayers()); - setOrthogonalCoEdges(coface->getEdge(2), coface->getVertex(2), mp->getNbLayers()); - } - else { - setOrthogonalCoEdges(coface->getEdge(0), coface->getVertex(0), mp->getNbLayers()); - setOrthogonalCoEdges(coface->getEdge(2), coface->getVertex(3), mp->getNbLayers()); - } - } -} -/*----------------------------------------------------------------------------*/ -void CommandEditTopo::setOrthogonalCoEdges(Edge* edge, Vertex* vertex, int nbLayers) -{ - if (edge->getNbCoEdges() == 1){ - CoEdge* coedge = edge->getCoEdge(0); - - CoEdgeMeshingProperty *cemp = coedge->getMeshingProperty()->clone(); - bool sens = (coedge->getVertex(0)==vertex); - cemp->setOrthogonal(nbLayers, sens); - if ((*cemp) != (*coedge->getMeshingProperty())) - coedge->switchCoEdgeMeshingProperty(&getInfoCommand(), cemp); - delete cemp; - } - else { - MGX_NOT_YET_IMPLEMENTED("Propagation orthogonalité pour plusieurs arêtes sur bord de face"); - TkUtil::UTF8String message (TkUtil::Charset::UTF_8); - message <<"Propagation orthogonalité pour arête "<getName()<<" sur bord d'une face n'est pas implémentée"; - message <<"Cette arête est composée de plusieurs arêtes communes"; - getContext().getLogStream()->log (TkUtil::TraceLog (message, TkUtil::Log::WARNING)); - } -} -/*----------------------------------------------------------------------------*/ void CommandEditTopo:: duplicate(std::vector& cofaces_dep, std::map& filtre_vertex, diff --git a/src/Core/Topo/CommandExtrudeFace.cpp b/src/Core/Topo/CommandExtrudeFace.cpp index c8a5af2..8501fca 100644 --- a/src/Core/Topo/CommandExtrudeFace.cpp +++ b/src/Core/Topo/CommandExtrudeFace.cpp @@ -11,7 +11,6 @@ #include "Topo/CoFace.h" #include "Topo/Edge.h" #include "Topo/EdgeMeshingPropertyUniform.h" -#include "Topo/FaceMeshingPropertyDirectional.h" #include "Geom/CommandExtrusion.h" #include "Geom/Vertex.h" @@ -365,11 +364,6 @@ namespace Mgx3D { // mise à jour de la projection suivant la géom qui a été extrudée //updateGeomAssociation(coedge_0->getGeomAssociation(), newCoFace); - // maillage directionnel, suivant extrusion - FaceMeshingPropertyDirectional* newProp = new FaceMeshingPropertyDirectional(FaceMeshingPropertyDirectional::dir_j); - CoFaceMeshingProperty* oldProp = newCoFace->setProperty(newProp); - delete oldProp; - } // end if filtre_vu } // end for coedges } // end for edges diff --git a/src/Core/Topo/CommandExtrudeTopo.cpp b/src/Core/Topo/CommandExtrudeTopo.cpp index 71ed972..7f9aa4d 100644 --- a/src/Core/Topo/CommandExtrudeTopo.cpp +++ b/src/Core/Topo/CommandExtrudeTopo.cpp @@ -15,7 +15,6 @@ #include "Topo/CoFace.h" #include "Topo/Edge.h" #include "Topo/EdgeMeshingPropertyUniform.h" -#include "Topo/FaceMeshingPropertyDirectional.h" #include "Geom/CommandExtrusion.h" #include "Geom/Vertex.h" @@ -332,11 +331,6 @@ void CommandExtrudeTopo::constructExtrudeFaces(std::vector& cofaces_0, // mise à jour de la projection suivant la géom qui a été extrudée updateGeomAssociation(coedge_0->getGeomAssociation(), newCoFace); - // maillage directionnel, suivant extrusion - FaceMeshingPropertyDirectional* newProp = new FaceMeshingPropertyDirectional(FaceMeshingPropertyDirectional::dir_j); - CoFaceMeshingProperty* oldProp = newCoFace->setProperty(newProp); - delete oldProp; - } // end if filtre_vu } // end for coedges } // end for edges diff --git a/src/Core/Topo/CommandMakeBlocksByRevol.cpp b/src/Core/Topo/CommandMakeBlocksByRevol.cpp index 75d997f..2d1e506 100644 --- a/src/Core/Topo/CommandMakeBlocksByRevol.cpp +++ b/src/Core/Topo/CommandMakeBlocksByRevol.cpp @@ -16,8 +16,6 @@ #include "Topo/CoFace.h" #include "Topo/Edge.h" #include "Topo/EdgeMeshingPropertyUniform.h" -#include "Topo/FaceMeshingPropertyDirectional.h" -#include "Topo/FaceMeshingPropertyRotational.h" #include "Topo/EdgeMeshingPropertyInterpolate.h" #include "Geom/CommandExtrudeRevolution.h" @@ -2018,42 +2016,6 @@ constructRevolFaces(std::vector& cofaces_0, else updateGeomAssociation(coedge_0->getGeomAssociation(), newCoFace); -#ifdef _DEBUG_MESH_LAW - std::cout<<"filtre_coedge["<getName()<<"] = "<getMeshLaw() != CoEdgeMeshingProperty::interpolate){ - // on remplace la méthode créée par défaut, par celle directionnelle en I - FaceMeshingPropertyDirectional* newProp = new FaceMeshingPropertyDirectional(FaceMeshingPropertyDirectional::dir_i); - CoFaceMeshingProperty* oldProp = newCoFace->setProperty(newProp); - delete oldProp; -#ifdef _DEBUG_MESH_LAW - std::cout<<"On utilise la méthode direction (dirI) pour mailler "<getName()<getNbVertices(); i++) - if (filtre_vertex[coedge_dep->getVertex(i)]%5 == 1) - touche = true; - if (!touche){ - // on remplace la méthode créée par défaut, par celle rotationnelle suivant J - FaceMeshingPropertyRotational* newProp = - new FaceMeshingPropertyRotational - (FaceMeshingPropertyRotational::dir_j, - Utils::Math::Point(0,0,0), - Utils::Math::Point(1,0,0)); - CoFaceMeshingProperty* oldProp = newCoFace->setProperty(newProp); - delete oldProp; -#ifdef _DEBUG_MESH_LAW - std::cout<<"On utilise la méthode rotation (rotJ) pour mailler "<getName()<& cofaces_0, std::cout<<"\nCréation du bloc à l'extérieur de l'ogrid : "<<*newBlock; //newBlock->check(); #endif - - // on cherche si l'une des directions peut servir pour définir un maillage unidirectionnel - // on se base sur la face de départ - // non valable pour le cas des blocs dégénérés - bool findDir = false; - if (vertices.size() == 8){ - Face* face = newBlock->getFace(0); - if (face->getNbCoFaces() == 1){ - CoFaceMeshingProperty::meshLaw ml = face->getCoFace(0)->getMeshLaw(); - findDir = (ml == CoFaceMeshingProperty::directional); - } - } - - if (vertices.size() == 8 && findDir){ - std::vector iCoedges; - std::vector jCoedges; - - Face* face = newBlock->getFace(0); - - face->getOrientedCoEdges(iCoedges, jCoedges); - } // end if (vertices.size() == 8 && findDir) } // end for cofaces } /*----------------------------------------------------------------------------*/ @@ -3137,7 +3078,6 @@ constructRevolBlocksInnerOgrid_4(std::vector& cofaces_0, Block* newBlock = new Topo::Block(getContext(), faces, vertices, true); getInfoCommand().addTopoInfoEntity(newBlock, Internal::InfoCommand::CREATED); - newBlock->selectBasicMeshLaw(&getInfoCommand()); updateGeomAssociation(coface_0->getGeomAssociation(), newBlock); #ifdef _DEBUG_REVOL std::cout<<"\nCréation du bloc à l'intérieur de l'ogrid (sur l'axe) : "<<*newBlock; @@ -3253,7 +3193,6 @@ constructRevolBlocksInnerOgrid_4(std::vector& cofaces_0, Block* newBlock = new Topo::Block(getContext(), faces, vertices, true); getInfoCommand().addTopoInfoEntity(newBlock, Internal::InfoCommand::CREATED); - newBlock->selectBasicMeshLaw(&getInfoCommand()); updateGeomAssociation(coface_0->getGeomAssociation(), newBlock); #ifdef _DEBUG_REVOL std::cout<<"\nCréation du 1er bloc à l'intérieur de l'ogrid (autour du bloc central) : "<<*newBlock; @@ -3349,7 +3288,6 @@ constructRevolBlocksInnerOgrid_4(std::vector& cofaces_0, Block* newBlock = new Topo::Block(getContext(), faces, vertices, true); getInfoCommand().addTopoInfoEntity(newBlock, Internal::InfoCommand::CREATED); - newBlock->selectBasicMeshLaw(&getInfoCommand()); updateGeomAssociation(coface_0->getGeomAssociation(), newBlock); #ifdef _DEBUG_REVOL std::cout<<"\nCréation du 2ème bloc à l'intérieur de l'ogrid (autour du bloc central) : "<<*newBlock; @@ -3423,7 +3361,6 @@ constructRevolBlocksInnerOgrid_4(std::vector& cofaces_0, Block* newBlock = new Topo::Block(getContext(), faces, vertices, true); getInfoCommand().addTopoInfoEntity(newBlock, Internal::InfoCommand::CREATED); - newBlock->selectBasicMeshLaw(&getInfoCommand()); updateGeomAssociation(coface_0->getGeomAssociation(), newBlock); #ifdef _DEBUG_REVOL std::cout<<"\nCréation du 3ème bloc à l'intérieur de l'ogrid (autour du bloc central) : "<<*newBlock; @@ -3603,7 +3540,6 @@ constructRevolBlocksInnerOgrid_2(std::vector& cofaces_0, // Block (unique) Block* newBlock = new Topo::Block(getContext(), faces, vertices, true); getInfoCommand().addTopoInfoEntity(newBlock, Internal::InfoCommand::CREATED); - newBlock->selectBasicMeshLaw(&getInfoCommand()); updateGeomAssociation(coface_0->getGeomAssociation(), newBlock); #ifdef _DEBUG_REVOL std::cout<<"\nCréation du bloc à l'intérieur de l'ogrid (sur l'axe) : "<<*newBlock; @@ -3715,7 +3651,6 @@ constructRevolBlocksInnerOgrid_2(std::vector& cofaces_0, Block* newBlock = new Topo::Block(getContext(), faces, vertices, true); getInfoCommand().addTopoInfoEntity(newBlock, Internal::InfoCommand::CREATED); - newBlock->selectBasicMeshLaw(&getInfoCommand()); updateGeomAssociation(coface_0->getGeomAssociation(), newBlock); #ifdef _DEBUG_REVOL std::cout<<"\nCréation du 1er bloc à l'intérieur de l'ogrid (autour du bloc central) : "<<*newBlock; @@ -3816,7 +3751,6 @@ constructRevolBlocksInnerOgrid_2(std::vector& cofaces_0, Block* newBlock = new Topo::Block(getContext(), faces, vertices, true); getInfoCommand().addTopoInfoEntity(newBlock, Internal::InfoCommand::CREATED); - newBlock->selectBasicMeshLaw(&getInfoCommand()); updateGeomAssociation(coface_0->getGeomAssociation(), newBlock); #ifdef _DEBUG_REVOL std::cout<<"\nCréation du 2ème bloc à l'intérieur de l'ogrid (autour du bloc central) : "<<*newBlock; @@ -3912,7 +3846,6 @@ constructRevolBlocksInnerOgrid_2(std::vector& cofaces_0, Block* newBlock = new Topo::Block(getContext(), faces, vertices, true); getInfoCommand().addTopoInfoEntity(newBlock, Internal::InfoCommand::CREATED); - newBlock->selectBasicMeshLaw(&getInfoCommand()); updateGeomAssociation(coface_0->getGeomAssociation(), newBlock); #ifdef _DEBUG_REVOL std::cout<<"\nCréation du 3ème bloc à l'intérieur de l'ogrid (autour du bloc central) : "<<*newBlock; @@ -4009,7 +3942,6 @@ constructRevolBlocksInnerOgrid_2(std::vector& cofaces_0, Block* newBlock = new Topo::Block(getContext(), faces, vertices, true); getInfoCommand().addTopoInfoEntity(newBlock, Internal::InfoCommand::CREATED); - newBlock->selectBasicMeshLaw(&getInfoCommand()); updateGeomAssociation(coface_0->getGeomAssociation(), newBlock); #ifdef _DEBUG_REVOL std::cout<<"\nCréation du 4ème bloc à l'intérieur de l'ogrid (autour du bloc central) : "<<*newBlock; @@ -4086,7 +4018,6 @@ constructRevolBlocksInnerOgrid_2(std::vector& cofaces_0, Block* newBlock = new Topo::Block(getContext(), faces, vertices, true); getInfoCommand().addTopoInfoEntity(newBlock, Internal::InfoCommand::CREATED); - newBlock->selectBasicMeshLaw(&getInfoCommand()); updateGeomAssociation(coface_0->getGeomAssociation(), newBlock); #ifdef _DEBUG_REVOL std::cout<<"\nCréation du 5ème bloc à l'intérieur de l'ogrid (autour du bloc central) : "<<*newBlock; @@ -4240,7 +4171,6 @@ constructRevolBlocksInnerOgrid_1(std::vector& cofaces_45, // Block (unique) Block* newBlock = new Topo::Block(getContext(), faces, vertices, true); getInfoCommand().addTopoInfoEntity(newBlock, Internal::InfoCommand::CREATED); - newBlock->selectBasicMeshLaw(&getInfoCommand()); updateGeomAssociation(coface_45->getGeomAssociation(), newBlock); #ifdef _DEBUG_REVOL std::cout<<"\nCréation du bloc à l'intérieur de l'ogrid (sur l'axe) : "<<*newBlock; @@ -4431,7 +4361,6 @@ constructRevolBlocksInnerOgrid_1(std::vector& cofaces_45, Block* newBlock = new Topo::Block(getContext(), faces, vertices, true); getInfoCommand().addTopoInfoEntity(newBlock, Internal::InfoCommand::CREATED); - newBlock->selectBasicMeshLaw(&getInfoCommand()); updateGeomAssociation(coface_0->getGeomAssociation(), newBlock); #ifdef _DEBUG_REVOL std::cout<<"\nCréation du "<& cofaces_45, Block* newBlock = new Topo::Block(getContext(), faces, vertices, true); getInfoCommand().addTopoInfoEntity(newBlock, Internal::InfoCommand::CREATED); - newBlock->selectBasicMeshLaw(&getInfoCommand()); updateGeomAssociation(coface_0->getGeomAssociation(), newBlock); #ifdef _DEBUG_REVOL std::cout<<"\nCréation du "<getNbCoFaces() == 1){ - CoFace* coface = face->getCoFace(0); - - Utils::Math::Point v2, v1; - if (reverse){ - v2 = vtx1->getCoord(); - v1 = vtx2->getCoord(); - } - else { - v1 = vtx1->getCoord(); - v2 = vtx2->getCoord(); - } - - FaceMeshingPropertyOrthogonal* mp = new FaceMeshingPropertyOrthogonal(v1, v2, nbLayers); - mp->initDir(coface); // initialisation avant == - - if ((*mp) != (*coface->getCoFaceMeshingProperty())) { - coface->switchCoFaceMeshingProperty(&getInfoCommand(), mp); - - setOrthogonalCoEdges(coface, mp); - } - delete mp; - } - else { - MGX_NOT_YET_IMPLEMENTED("Propagation orthogonalité pour plusieurs faces sur bord de bloc"); - TkUtil::UTF8String message (TkUtil::Charset::UTF_8); - message <<"Propagation orthogonalité pour face "<getName()<<" sur bord d'un bloc n'est pas implémentée"; - message <<"Cette face est composée de plusieurs faces communes"; - getContext().getLogStream()->log (TkUtil::TraceLog (message, TkUtil::Log::WARNING)); - } -} -/*----------------------------------------------------------------------------*/ } // end namespace Topo /*----------------------------------------------------------------------------*/ } // end namespace Mgx3D diff --git a/src/Core/Topo/CommandSetFaceMeshingProperty.cpp b/src/Core/Topo/CommandSetFaceMeshingProperty.cpp index f7d1858..6d8ca09 100644 --- a/src/Core/Topo/CommandSetFaceMeshingProperty.cpp +++ b/src/Core/Topo/CommandSetFaceMeshingProperty.cpp @@ -8,7 +8,6 @@ */ /*----------------------------------------------------------------------------*/ #include "Topo/CommandSetFaceMeshingProperty.h" -#include "Topo/FaceMeshingPropertyOrthogonal.h" #include "Utils/Common.h" /*----------------------------------------------------------------------------*/ @@ -69,15 +68,6 @@ internalExecute() // initialise la direction si nécessaire coface->getCoFaceMeshingProperty()->initDir(coface); - - // transmission de la demande d'orthogonalité aux arêtes - if (m_prop->getMeshLaw() == CoFaceMeshingProperty::orthogonal){ - FaceMeshingPropertyOrthogonal* mp = dynamic_cast(coface->getCoFaceMeshingProperty()); - CHECK_NULL_PTR_ERROR(mp); - - setOrthogonalCoEdges(coface, mp); - - } // end if (m_prop->getMeshLaw() == CoFaceMeshingProperty::orthogonal) } // on parcours les entités modifiées pour sauvegarder leur état d'avant la commande diff --git a/src/Core/Topo/CommandSnapVertices.cpp b/src/Core/Topo/CommandSnapVertices.cpp index 5938181..f6c340a 100644 --- a/src/Core/Topo/CommandSnapVertices.cpp +++ b/src/Core/Topo/CommandSnapVertices.cpp @@ -667,9 +667,6 @@ internalExecute() } // end for iter1 } //end if (!m_project_on_first) - // recherche la méthode la plus simple possible pour les cofaces et les blocs modifiés - updateMeshLaw(cofaces, blocks); - // enregistrement des nouvelles entités dans le TopoManager registerToManagerCreatedEntities(); diff --git a/src/Core/Topo/CommandTransformTopo.cpp b/src/Core/Topo/CommandTransformTopo.cpp index 3546978..2875a18 100644 --- a/src/Core/Topo/CommandTransformTopo.cpp +++ b/src/Core/Topo/CommandTransformTopo.cpp @@ -12,7 +12,6 @@ #include "Utils/Common.h" #include "Topo/Block.h" #include "Topo/TopoHelper.h" -#include "Topo/FaceMeshingPropertyRotational.h" #include "Topo/CommandDuplicateTopo.h" /*----------------------------------------------------------------------------*/ #include @@ -193,27 +192,6 @@ transform(CoFace* co, gp_Trsf* transf, std::map& filtre) } } - if (co->getMeshLaw() == Topo::CoFaceMeshingProperty::rotational){ - FaceMeshingPropertyRotational* fmp = dynamic_cast(co->getCoFaceMeshingProperty()); - CHECK_NULL_PTR_ERROR(fmp); - Utils::Math::Point axis[2]; - fmp->getAxis(axis[0], axis[1]); - - for (uint i=0; i<2; i++){ - double x = axis[i].getX(); - double y = axis[i].getY(); - double z = axis[i].getZ(); - - transf->Transforms(x, y, z); - - axis[i].setX(x); - axis[i].setY(y); - axis[i].setZ(z); - } - co->saveCoFaceMeshingProperty(&getInfoCommand()); - fmp->setAxis(axis[0], axis[1]); - } - filtre[co] = 1; } /*----------------------------------------------------------------------------*/ @@ -235,27 +213,6 @@ transform(CoFace* co, gp_GTrsf* transf, std::map& filtre) } } - if (co->getMeshLaw() == Topo::CoFaceMeshingProperty::rotational){ - FaceMeshingPropertyRotational* fmp = dynamic_cast(co->getCoFaceMeshingProperty()); - CHECK_NULL_PTR_ERROR(fmp); - Utils::Math::Point axis[2]; - fmp->getAxis(axis[0], axis[1]); - - for (uint i=0; i<2; i++){ - double x = axis[i].getX(); - double y = axis[i].getY(); - double z = axis[i].getZ(); - - transf->Transforms(x, y, z); - - axis[i].setX(x); - axis[i].setY(y); - axis[i].setZ(z); - } - co->saveCoFaceMeshingProperty(&getInfoCommand()); - fmp->setAxis(axis[0], axis[1]); - } - filtre[co] = 1; } /*----------------------------------------------------------------------------*/ diff --git a/src/Core/protected/Topo/Block.h b/src/Core/protected/Topo/Block.h index 2f1b919..07ff082 100644 --- a/src/Core/protected/Topo/Block.h +++ b/src/Core/protected/Topo/Block.h @@ -369,11 +369,6 @@ class Block : public TopoEntity { */ virtual void setMeshLaw(BlockMeshingProperty* new_ppty); - /** Recherche d'une méthode de maillage unidirectionnelle autant que possible, - * sinon on utilise la méthode transfinie - */ - virtual void selectBasicMeshLaw(Internal::InfoCommand* icmd, bool forceCompute = false); - /*------------------------------------------------------------------------*/ /** Accesseur sur la liste des points */ Utils::Math::Point*& points() {return m_mesh_data->points();} diff --git a/src/Core/protected/Topo/CoFace.h b/src/Core/protected/Topo/CoFace.h index 932fb51..a53c764 100644 --- a/src/Core/protected/Topo/CoFace.h +++ b/src/Core/protected/Topo/CoFace.h @@ -63,9 +63,7 @@ class CoFace : public TopoEntity { bool hasHole); /// Constructeur par défaut, maillage structuré - CoFace(Internal::Context& c, int ni=0, int nj=0, - CoFaceMeshingProperty::meshLaw ml = CoFaceMeshingProperty::directional, - CoFaceMeshingProperty::meshDirLaw md = CoFaceMeshingProperty::dir_i); + CoFace(Internal::Context& c, int ni=0, int nj=0); /*------------------------------------------------------------------------*/ @@ -438,12 +436,6 @@ class CoFace : public TopoEntity { /// Accesseur sur le nom de la méthode de maillage virtual std::string getMeshLawName() const {return m_mesh_property->getMeshLawName();} - /** Recherche d'une méthode de maillage unidirectionnelle autant que possible, - * sinon on utilise la méthode transfinie - */ - - virtual void selectBasicMeshLaw(Internal::InfoCommand* icmd, bool forceCompute = false); - /*------------------------------------------------------------------------*/ /** Accesseur sur la liste des noeuds ordonnés suivant les sommets diff --git a/src/Core/protected/Topo/CoFaceMeshingProperty.h b/src/Core/protected/Topo/CoFaceMeshingProperty.h index de8c3ba..679f0ab 100644 --- a/src/Core/protected/Topo/CoFaceMeshingProperty.h +++ b/src/Core/protected/Topo/CoFaceMeshingProperty.h @@ -33,23 +33,11 @@ class CoFaceMeshingProperty { /** Les méthodes de maillage pour une face commune */ typedef enum{ - directional, - orthogonal, - rotational, transfinite, delaunayGMSH, // recommandé / delaunay GMSH quadPairing } meshLaw; - /** Direction suivant laquelle est effectuée la discrétisation (relative à la face commune) - * pour les méthodes avec une direction - */ - typedef enum{ - dir_undef, - dir_i, - dir_j - }meshDirLaw; - /** Côté de départ pour les discrétisations orientés (tel que FaceMeshingPropertyOrthogonal) */ typedef enum{ @@ -105,14 +93,6 @@ class CoFaceMeshingProperty { CoFaceMeshingProperty(const CoFaceMeshingProperty& pm) {} #endif - /*------------------------------------------------------------------------*/ -#ifndef SWIG - /// Cherche la direction dans la coface à partir de deux points - static meshDirLaw _computeDir(CoFace* coface, Utils::Math::Point & v1, Utils::Math::Point & v2); - /// Cherche le côté dans la coface à partir de deux points - static meshSideLaw _computeSide(CoFace* coface, Utils::Math::Point & v1, Utils::Math::Point & v2, uint dir); -#endif - }; /*----------------------------------------------------------------------------*/ } // end namespace Topo diff --git a/src/Core/protected/Topo/CommandEditTopo.h b/src/Core/protected/Topo/CommandEditTopo.h index 2dcf7f9..9fb3401 100644 --- a/src/Core/protected/Topo/CommandEditTopo.h +++ b/src/Core/protected/Topo/CommandEditTopo.h @@ -195,20 +195,6 @@ class CommandEditTopo: public Internal::CommandInternal { /// Compte le nombre d'arêtes reliées à chacun des sommets de la topologie concernée par la commande virtual void countNbCoEdgesByVertices(std::map &nb_coedges_by_vertex); - /*------------------------------------------------------------------------*/ - /** Dans les cas d'une méthode de maillage initiale directionnelle ou rotationnelle - * potentiellement invalide - * recherche la méthode la plus simple - */ - void updateMeshLaw(std::vector& cofaces, std::vector& blocks); - - /*------------------------------------------------------------------------*/ - /// change la discrétisation pour les arêtes d'une coface en mettant la discrétisation orthogonale - virtual void setOrthogonalCoEdges(CoFace* coface, FaceMeshingPropertyOrthogonal* mp); - - /// Change la discrétisation pour une ou plusieurs arêtes en la mettant orthogonale - virtual void setOrthogonalCoEdges(Edge* edge, Vertex* vertex, int nbLayers); - /*------------------------------------------------------------------------*/ /** Duplique les CoFaces */ diff --git a/src/Core/protected/Topo/CommandSetBlockMeshingProperty.h b/src/Core/protected/Topo/CommandSetBlockMeshingProperty.h index 3fa9617..e1e4266 100644 --- a/src/Core/protected/Topo/CommandSetBlockMeshingProperty.h +++ b/src/Core/protected/Topo/CommandSetBlockMeshingProperty.h @@ -64,9 +64,6 @@ class CommandSetBlockMeshingProperty: public Topo::CommandEditTopo { /// recherche le sommet suivant pour une face dans un bloc avec 2 sommets non marqués à 2 Vertex* getNextVertex(Block* bloc, Vertex* vtx1, Vertex* vtx2, std::map& filtre_sommets); - /// Change la discrétisation pour une ou plusieurs faces en la mettant orthogonale - void setOrthogonalCoFaces(Face* face, Vertex* vtx1, Vertex* vtx2, int nbLayers, bool reverse); - private: /// la nouvelle propriété de discrétisation BlockMeshingProperty* m_prop; diff --git a/src/Core/protected/Topo/FaceMeshingPropertyDirectional.h b/src/Core/protected/Topo/FaceMeshingPropertyDirectional.h deleted file mode 100644 index e9ff260..0000000 --- a/src/Core/protected/Topo/FaceMeshingPropertyDirectional.h +++ /dev/null @@ -1,139 +0,0 @@ -/*----------------------------------------------------------------------------*/ -/* - * \file FaceMeshingPropertyDirectional.h - * - * \author Eric Brière de l'Isle - * - * \date 10/10/13 - */ -/*----------------------------------------------------------------------------*/ - - -#ifndef FACEPROPERTYMESHINGDIRECTIONAL_H_ -#define FACEPROPERTYMESHINGDIRECTIONAL_H_ -/*----------------------------------------------------------------------------*/ -#include "Utils/Point.h" -#include "Topo/CoFaceMeshingProperty.h" -/*----------------------------------------------------------------------------*/ -namespace Mgx3D { -/*----------------------------------------------------------------------------*/ -namespace Topo { -/*----------------------------------------------------------------------------*/ -/** - @brief Propriété de la discrétisation d'une face commune suivant une direction - */ -class FaceMeshingPropertyDirectional : public CoFaceMeshingProperty { -public: - - /*------------------------------------------------------------------------*/ - /// Constructeur avec direction suivant 2 sommets - FaceMeshingPropertyDirectional(Utils::Math::Point v1, Utils::Math::Point v2) - : m_dir(dir_undef), m_v1(v1), m_v2(v2) - {} - - /// Constructeur dont on connait la direction - FaceMeshingPropertyDirectional(meshDirLaw md) - : m_dir(md), m_v1(), m_v2() - {} - - /*------------------------------------------------------------------------*/ - /// Comparaison de 2 propriétés. - virtual bool operator == (const CoFaceMeshingProperty& mp) const - { - const FaceMeshingPropertyDirectional* fmp = dynamic_cast (&mp); - return fmp != 0 && - m_dir == fmp->m_dir && - m_v1 == fmp->m_v1 && - m_v2 == fmp->m_v2 && - CoFaceMeshingProperty::operator == (*fmp); - } - - /*------------------------------------------------------------------------*/ - /// Accesseur sur la méthode de maillage - virtual CoFaceMeshingProperty::meshLaw getMeshLaw() const {return CoFaceMeshingProperty::directional;} - - /*------------------------------------------------------------------------*/ - /// Accesseur sur le nom de la méthode de maillage - virtual std::string getMeshLawName() const - { - if (m_dir == dir_i) - return "DirectionI"; - else if (m_dir == dir_j) - return "DirectionJ"; - else - return "Direction à préciser"; - } - - /*------------------------------------------------------------------------*/ - /// Accesseur sur la direction associée à la CoFace - virtual uint getDir() const - { - if (m_dir == dir_i) - return 0; - else if (m_dir == dir_j) - return 1; - else - throw TkUtil::Exception(TkUtil::UTF8String ("FaceMeshingPropertyDirectional::getDir() ne peut se faire sans initialiser la direction", TkUtil::Charset::UTF_8)); - } - - /*------------------------------------------------------------------------*/ - /// inversion de la direction - virtual void permDir() - { - if (m_dir == dir_i) - m_dir = dir_j; - else if (m_dir == dir_j) - m_dir = dir_i; - else - throw TkUtil::Exception(TkUtil::UTF8String ("FaceMeshingPropertyDirectional::permDir() ne peut se faire sans initialiser la direction", TkUtil::Charset::UTF_8)); - } - - /*------------------------------------------------------------------------*/ - /** \brief Indique si la face est structurée - */ - virtual bool isStructured() const {return true;} - -#ifndef SWIG - /*------------------------------------------------------------------------*/ - /// initialisation de la direction en fonction de ce qui a été donné à la construction - virtual void initDir(CoFace* coface) - { - m_dir = _computeDir(coface, m_v1, m_v2); - } - - /*------------------------------------------------------------------------*/ - /** Création d'un clone, on copie toutes les informations */ - virtual FaceMeshingPropertyDirectional* clone() {return new FaceMeshingPropertyDirectional(*this);} - - /*------------------------------------------------------------------------*/ - /// Script pour la commande de création Python - virtual TkUtil::UTF8String getScriptCommand() const - { - TkUtil::UTF8String o (TkUtil::Charset::UTF_8); - o << getMgx3DAlias() << ".FaceMeshingPropertyDirectional(" - << m_v1.getScriptCommand() << ", " - << m_v2.getScriptCommand() << ")"; - return o; - } -#endif - -protected: - - /*------------------------------------------------------------------------*/ - /// Direction suivant laquelle est effectuée la discrétisation (relative à la CoFace) - meshDirLaw m_dir; - - /// premier point pour déterminer la direction - Utils::Math::Point m_v1; - - /// deuxième point pour déterminer la direction - Utils::Math::Point m_v2; - -}; -/*----------------------------------------------------------------------------*/ -} // end namespace Topo -/*----------------------------------------------------------------------------*/ -} // end namespace Mgx3D -/*----------------------------------------------------------------------------*/ - -#endif /* FACEPROPERTYMESHINGDIRECTIONAL_H_ */ diff --git a/src/Core/protected/Topo/FaceMeshingPropertyOrthogonal.h b/src/Core/protected/Topo/FaceMeshingPropertyOrthogonal.h deleted file mode 100644 index 8d3c1c9..0000000 --- a/src/Core/protected/Topo/FaceMeshingPropertyOrthogonal.h +++ /dev/null @@ -1,138 +0,0 @@ -/*----------------------------------------------------------------------------*/ -/* - * \file FaceMeshingPropertyOrthogonal.h - * - * \author Eric Brière de l'Isle - * - * \date 9/7/15 - */ -/*----------------------------------------------------------------------------*/ - - -#ifndef FACEPROPERTYMESHINGORTHOGONAL_H_ -#define FACEPROPERTYMESHINGORTHOGONAL_H_ -/*----------------------------------------------------------------------------*/ -#include "Utils/Point.h" -#include "Topo/FaceMeshingPropertyDirectional.h" -/*----------------------------------------------------------------------------*/ -namespace Mgx3D { -/*----------------------------------------------------------------------------*/ -namespace Topo { -/*----------------------------------------------------------------------------*/ -/** - @brief Propriété de la discrétisation d'une face commune suivant une direction - */ -class FaceMeshingPropertyOrthogonal : public FaceMeshingPropertyDirectional { -public: - - /*------------------------------------------------------------------------*/ - /// Constructeur avec direction suivant 2 sommets - FaceMeshingPropertyOrthogonal(Utils::Math::Point v1, Utils::Math::Point v2, int nbLayers) - : FaceMeshingPropertyDirectional(v1, v2) - , m_side(side_undef) - , m_nbLayers(nbLayers) - {} - - /// Constructeur dont on connait la direction - FaceMeshingPropertyOrthogonal(meshDirLaw md, int nbLayers) - : FaceMeshingPropertyDirectional(md) - , m_side(side_undef) - , m_nbLayers(nbLayers) - {} - - /*------------------------------------------------------------------------*/ - /// Comparaison de 2 propriétés. - virtual bool operator == (const CoFaceMeshingProperty& mp) const - { - const FaceMeshingPropertyOrthogonal* fmp = dynamic_cast (&mp); - return fmp != 0 && - m_nbLayers == fmp->m_nbLayers && - m_side == fmp->m_side && - FaceMeshingPropertyDirectional::operator == (*fmp); - } - -/*------------------------------------------------------------------------*/ - /// Accesseur sur la méthode de maillage - virtual CoFaceMeshingProperty::meshLaw getMeshLaw() const - {return CoFaceMeshingProperty::orthogonal;} - - /*------------------------------------------------------------------------*/ - /// Accesseur sur le nom de la méthode de maillage - virtual std::string getMeshLawName() const - { - if (m_dir == dir_i) - return "OrthogonalI"; - else if (m_dir == dir_j) - return "OrthogonalJ"; - else - return "Direction à préciser"; - } - -#ifndef SWIG - /*------------------------------------------------------------------------*/ - /// initialisation du côté en plus - virtual void initDir(CoFace* coface) - { - FaceMeshingPropertyDirectional::initDir(coface); - - m_side = _computeSide(coface, m_v1, m_v2, getDir()); - } - - /*------------------------------------------------------------------------*/ - virtual uint getSide() const - { - if (m_side == side_min) - return 0; - else if (m_side == side_max) - return 1; - else - throw TkUtil::Exception(TkUtil::UTF8String ("FaceMeshingPropertyOrthogonal::getSide() ne peut se faire sans initialiser le côté", TkUtil::Charset::UTF_8)); - } - - /*------------------------------------------------------------------------*/ - /** Création d'un clone, on copie toutes les informations */ - virtual FaceMeshingPropertyOrthogonal* clone() {return new FaceMeshingPropertyOrthogonal(*this);} - - /*------------------------------------------------------------------------*/ - /// Script pour la commande de création Python - virtual TkUtil::UTF8String getScriptCommand() const - { - TkUtil::UTF8String o (TkUtil::Charset::UTF_8); - o << getMgx3DAlias() << ".FaceMeshingPropertyOrthogonal(" - << m_v1.getScriptCommand() << ", " - << m_v2.getScriptCommand() << ", " - << (long)m_nbLayers << ")"; - return o; - } - - /// ajoute la description des propriétés spécifiques - virtual void addProperties(Utils::SerializedRepresentation& ppt) const - { - ppt.addProperty ( - Utils::SerializedRepresentation::Property ("Nombre de couches orthogonales", (long)m_nbLayers)); - ppt.addProperty ( - Utils::SerializedRepresentation::Property ("Discrétisation orthogonale coté", - m_side == side_min?std::string("départ"):std::string("arrivée"))); - } -#endif - /*------------------------------------------------------------------------*/ - virtual int getNbLayers() const - { return m_nbLayers; } - /*------------------------------------------------------------------------*/ - -private: - - /*------------------------------------------------------------------------*/ - /// coté où on se contraint à être orthogonal - meshSideLaw m_side; - - /// nombre de couches pour orthogonalité - int m_nbLayers; -}; -/*----------------------------------------------------------------------------*/ -} // end namespace Topo -/*----------------------------------------------------------------------------*/ -} // end namespace Mgx3D -/*----------------------------------------------------------------------------*/ - -#endif /* FACEPROPERTYMESHINGORTHOGONAL_H_ */ diff --git a/src/Core/protected/Topo/FaceMeshingPropertyRotational.h b/src/Core/protected/Topo/FaceMeshingPropertyRotational.h deleted file mode 100644 index e4a5f6e..0000000 --- a/src/Core/protected/Topo/FaceMeshingPropertyRotational.h +++ /dev/null @@ -1,156 +0,0 @@ -/*----------------------------------------------------------------------------*/ -/* - * \file FaceMeshingPropertyRotational.h - * - * \author Eric Brière de l'Isle - * - * \date 10/10/13 - */ -/*----------------------------------------------------------------------------*/ - - -#ifndef FACEPROPERTYMESHINGROTATIONAL_H_ -#define FACEPROPERTYMESHINGROTATIONAL_H_ -/*----------------------------------------------------------------------------*/ -#include "Utils/Point.h" -#include "Topo/CoFaceMeshingProperty.h" -/*----------------------------------------------------------------------------*/ -namespace Mgx3D { -/*----------------------------------------------------------------------------*/ -namespace Topo { -/*----------------------------------------------------------------------------*/ -/** - @brief Propriété de la discrétisation d'une face commune - */ -class FaceMeshingPropertyRotational : public CoFaceMeshingProperty { -public: - - /*------------------------------------------------------------------------*/ - /** Constructeur avec rotation suivant 2 sommets, - autour d'un axe défini par deux points - */ - FaceMeshingPropertyRotational(Utils::Math::Point v1, Utils::Math::Point v2, - Utils::Math::Point axis1, Utils::Math::Point axis2) - : m_dir(dir_undef), m_v1(v1), m_v2(v2), m_axis1(axis1), m_axis2(axis2) - {} - - /** Constructeur avec rotation déterminée, - autour d'un axe défini par deux points - */ - FaceMeshingPropertyRotational(meshDirLaw md, - Utils::Math::Point axis1, Utils::Math::Point axis2) - : m_dir(md), m_v1(), m_v2(), m_axis1(axis1), m_axis2(axis2) - {} - - /*------------------------------------------------------------------------*/ - /// Comparaison de 2 propriétés. - virtual bool operator == (const CoFaceMeshingProperty& mp) const - { - const FaceMeshingPropertyRotational* fmp = dynamic_cast (&mp); - return fmp != 0 && - getDir() == fmp->getDir() && - m_v1 == fmp->m_v1 && - m_v2 == fmp->m_v2 && - m_axis1 == fmp->m_axis1 && - m_axis2 == fmp->m_axis2 && - CoFaceMeshingProperty::operator == (*fmp); - } - /*------------------------------------------------------------------------*/ - /// Accesseur sur la méthode de maillage - CoFaceMeshingProperty::meshLaw getMeshLaw() const {return CoFaceMeshingProperty::rotational;} - - /*------------------------------------------------------------------------*/ - /// Accesseur sur le nom de la méthode de maillage - std::string getMeshLawName() const - { - if (m_dir == dir_i) - return "RotationI"; - else if (m_dir == dir_j) - return "RotationJ"; - else - return "Rotation à préciser"; - } - - /*------------------------------------------------------------------------*/ - /// Accesseur sur la direction associée à la CoFace - uint getDir() const - { - if (m_dir == dir_i) - return 0; - else if (m_dir == dir_j) - return 1; - else - throw TkUtil::Exception(TkUtil::UTF8String ("FaceMeshingPropertyRotational::getDir() ne peut se faire sans initialiser la direction", TkUtil::Charset::UTF_8)); - } - - /*------------------------------------------------------------------------*/ - /** \brief Indique si la face est structurée - */ - bool isStructured() const {return true;} - - /*------------------------------------------------------------------------*/ - /** Retourne l'axe de rotation */ - void getAxis(Utils::Math::Point & axis1, Utils::Math::Point & axis2) - { - axis1 = m_axis1; - axis2 = m_axis2; - } - /*------------------------------------------------------------------------*/ - /** Change l'axe de rotation */ - void setAxis(Utils::Math::Point & axis1, Utils::Math::Point & axis2) - { - m_axis1 = axis1; - m_axis2 = axis2; - } - - /*------------------------------------------------------------------------*/ -#ifndef SWIG - void initDir(CoFace* coface) - { - m_dir = _computeDir(coface, m_v1, m_v2); - } - - /*------------------------------------------------------------------------*/ - /** Création d'un clone, on copie toutes les informations */ - FaceMeshingPropertyRotational* clone() {return new FaceMeshingPropertyRotational(*this);} - - /*------------------------------------------------------------------------*/ - /// Script pour la commande de création Python - virtual TkUtil::UTF8String getScriptCommand() const - { - TkUtil::UTF8String o (TkUtil::Charset::UTF_8); - o << getMgx3DAlias() << ".FaceMeshingPropertyRotational(" - << m_v1.getScriptCommand() << ", " - << m_v2.getScriptCommand() << ", " - << m_axis1.getScriptCommand() << ", " - << m_axis2.getScriptCommand() << ")"; - return o; - } -#endif - -private: - - /*------------------------------------------------------------------------*/ - /// Direction suivant laquelle est effectuée la discrétisation (relative à la CoFace) - meshDirLaw m_dir; - - /// premier point pour déterminer la direction de la rotation - Utils::Math::Point m_v1; - - /// deuxième point pour déterminer la direction de la rotation - Utils::Math::Point m_v2; - - /// premier point pour l'axe de rotation de la méthode "rotation" - Utils::Math::Point m_axis1; - - /// deuxième point pour l'axe de rotation de la méthode "rotation" - Utils::Math::Point m_axis2; - -}; -/*----------------------------------------------------------------------------*/ -} // end namespace Topo -/*----------------------------------------------------------------------------*/ -} // end namespace Mgx3D -/*----------------------------------------------------------------------------*/ - -#endif /* FACEPROPERTYMESHINGROTATIONAL_H_ */ diff --git a/src/QtComponents/QtFaceMeshingPropertyAction.cpp b/src/QtComponents/QtFaceMeshingPropertyAction.cpp index 47f357c..7196412 100644 --- a/src/QtComponents/QtFaceMeshingPropertyAction.cpp +++ b/src/QtComponents/QtFaceMeshingPropertyAction.cpp @@ -87,590 +87,6 @@ FaceMeshingPropertyTransfinite* QtFaceTransfinitePanel::getMeshingProperty ( ) c } // QtFaceTransfinitePanel::getMeshingProperty -// =========================================================================== -// LA CLASSE QtFaceDirectionalPanel -// =========================================================================== - - -QtFaceDirectionalPanel::QtFaceDirectionalPanel ( - QWidget* parent, QtMgx3DMainWindow& window, QtMgx3DOperationPanel* mainPanel) - : QtMgx3DOperationsSubPanel (parent, window, mainPanel), - _edgeTextField (0), _invertCheckBox (0), _directionLabel (0) -{ - QVBoxLayout* layout = new QVBoxLayout (this); - setLayout (layout); - layout->setContentsMargins ( - Resources::instance ( )._margin.getValue ( ), - Resources::instance ( )._margin.getValue ( ), - Resources::instance ( )._margin.getValue ( ), - Resources::instance ( )._margin.getValue ( )); - layout->setSpacing (Resources::instance ( )._spacing.getValue ( )); - - // La direction du maillage : - _edgeTextField = new QtMgx3DEdgePanel ( - this, "", true, "", &window, FilterEntity::TopoCoEdge); - _edgeTextField->getEntityPanel ( ).setLabel ("Arête directionnelle :"); - layout->addWidget (_edgeTextField); - connect (&_edgeTextField->getEntityTextField ( ), - SIGNAL (selectionModified (QString)), this, - SLOT (directionModifiedCallback ( ))); - - // Faut il inverser le vecteur ? - _invertCheckBox = new QCheckBox ("Inverser le vecteur", this); - layout->addWidget (_invertCheckBox); - connect (_invertCheckBox, SIGNAL (stateChanged (int)), this, - SLOT (directionModifiedCallback ( ))); - - // Le vecteur : - QHBoxLayout* hlayout = new QHBoxLayout ( ); - layout->addLayout (hlayout); - QLabel* label = new QLabel ("Direction :", this); - hlayout->addWidget (label); - _directionLabel = new QLabel ("", this); - hlayout->addWidget (_directionLabel); - hlayout->addStretch (2.); -} // QtFaceDirectionalPanel::QtFaceDirectionalPanel - - -QtFaceDirectionalPanel::QtFaceDirectionalPanel ( - const QtFaceDirectionalPanel& p) - : QtMgx3DOperationsSubPanel (p), - _edgeTextField (0), _invertCheckBox (0), _directionLabel (0) -{ - MGX_FORBIDDEN ("QtFaceDirectionalPanel copy constructor is not allowed."); -} // QtFaceDirectionalPanel::QtFaceDirectionalPanel - - -QtFaceDirectionalPanel& QtFaceDirectionalPanel::operator = ( - const QtFaceDirectionalPanel&) -{ - MGX_FORBIDDEN ("QtFaceDirectionalPanel assignment operator is not allowed."); - return *this; -} // QtFaceDirectionalPanel::operator = - - -QtFaceDirectionalPanel::~QtFaceDirectionalPanel ( ) -{ -} // QtFaceDirectionalPanel::~QtFaceDirectionalPanel - - -void QtFaceDirectionalPanel::setVisible (bool visible) -{ - preview (visible, true); - QtMgx3DOperationsSubPanel::setVisible (visible); -} // QtFaceDirectionalPanel::setVisible - - -Math::Point QtFaceDirectionalPanel::getPoint1 ( ) const -{ - CHECK_NULL_PTR_ERROR (_edgeTextField) - const CoEdge* edge = getContext ( ).getTopoManager ( ).getCoEdge ( - _edgeTextField->getUniqueName( )); - CHECK_NULL_PTR_ERROR (edge) - size_t index = false == isEdgeInverted ( ) ? - 0 : edge->getNbVertices ( ) - 1; - const Vertex* v1 = edge->getVertex (index); - CHECK_NULL_PTR_ERROR (v1) - - return v1->getCoord ( ); -} // QtFaceDirectionalPanel::getPoint1 - - -Math::Point QtFaceDirectionalPanel::getPoint2 ( ) const -{ - CHECK_NULL_PTR_ERROR (_edgeTextField) - const CoEdge* edge = getContext ( ).getTopoManager ( ).getCoEdge ( - _edgeTextField->getUniqueName( )); - CHECK_NULL_PTR_ERROR (edge) - size_t index = true == isEdgeInverted ( ) ? - 0 : edge->getNbVertices ( ) - 1; - const Vertex* v2 = edge->getVertex (index); - CHECK_NULL_PTR_ERROR (v2) - - return v2->getCoord ( ); -} // QtFaceDirectionalPanel::getPoint2 - - -FaceMeshingPropertyDirectional* QtFaceDirectionalPanel::getMeshingProperty ( ) const -{ - return new FaceMeshingPropertyDirectional (getPoint1 ( ), getPoint2 ( )); -} // QtFaceDirectionalPanel::getMeshingProperty - - -bool QtFaceDirectionalPanel::isEdgeInverted ( ) const -{ - CHECK_NULL_PTR_ERROR (_invertCheckBox) - return Qt::Checked == _invertCheckBox->checkState ( ) ? true : false; -} // QtFaceDirectionalPanel::isEdgeInverted - - -void QtFaceDirectionalPanel::stopSelection ( ) -{ - if (0 != _edgeTextField) - _edgeTextField->stopSelection ( ); -} // QtFaceDirectionalPanel::stopSelection - - -QtEntityIDTextField* QtFaceDirectionalPanel::getEdgeTextField ( ) -{ - CHECK_NULL_PTR_ERROR (_edgeTextField) - return &_edgeTextField->getEntityTextField ( ); -} // QtFaceDirectionalPanel::getEdgeTextField - - -void QtFaceDirectionalPanel::reset ( ) -{ - BEGIN_QT_TRY_CATCH_BLOCK - - CHECK_NULL_PTR_ERROR (_edgeTextField) - _edgeTextField->reset ( ); - - CHECK_NULL_PTR_ERROR(_directionLabel) - _directionLabel->clear(); - - COMPLETE_QT_TRY_CATCH_BLOCK (true, this, "Magix 3D") - - QtMgx3DOperationsSubPanel::reset ( ); -} // QtFaceDirectionalPanel::reset - - -void QtFaceDirectionalPanel::preview (bool on, bool destroyInteractor) -{ - Math::Point p1, p2; - try - { - CHECK_NULL_PTR_ERROR (_directionLabel) - p1 = getPoint1 ( ); - p2 = getPoint2 ( ); - UTF8String label (Charset::UTF_8); - label << "(" << MgxNumeric::userRepresentation (p1.getX ( )) - << ", " << MgxNumeric::userRepresentation (p1.getY ( )) << ",\n" - << MgxNumeric::userRepresentation (p1.getZ ( )) << ") -> (" - << MgxNumeric::userRepresentation (p2.getX ( )) - << ",\n" << MgxNumeric::userRepresentation (p2.getY ( )) << ", " - << MgxNumeric::userRepresentation (p2.getZ ( )) - << ")"; - _directionLabel->setText (label.ascii ( ).c_str ( )); - } - catch (...) - { - } - - try - { // Quoi qu'il arrive on détruit l'éventuel aperçu existant : - removePreviewedObjects ( ); - } - catch (...) - { - } - - try - { - if (true == previewResult ( )) - { - if (true == on) - { - DisplayProperties properties; - properties.setWireColor (Color ( - 255 * Resources::instance ( )._previewColor.getRed ( ), - 255 * Resources::instance ( )._previewColor.getGreen ( ), - 255 * Resources::instance ( )._previewColor.getBlue ( ))); - properties.setLineWidth (Resources::instance ( )._previewWidth.getValue( )); - RenderingManager::RepresentationID arrowID = - getRenderingManager ( ).createVector (p1, p2, properties, true); - registerPreviewedObject (arrowID); - } // if (true == on) - } // if (true == previewResult ( )) - } - catch (...) - { - } - - try - { - getRenderingManager ( ).forceRender ( ); - } - catch (...) - { - } -} // QtFaceDirectionalPanel::preview - - -void QtFaceDirectionalPanel::directionModifiedCallback ( ) -{ - preview (true, true); -} // QtFaceDirectionalPanel::directionModifiedCallback - - -// =========================================================================== -// LA CLASSE QtFaceOrthogonalPanel -// =========================================================================== - - -QtFaceOrthogonalPanel::QtFaceOrthogonalPanel ( - QWidget* parent, QtMgx3DMainWindow& window, QtMgx3DOperationPanel* mainPanel) - : QtFaceDirectionalPanel (parent, window, mainPanel), - _layersNumTextField (0) -{ - QBoxLayout* mainLayout = dynamic_cast(layout ( )); - if (0 == mainLayout) - { - INTERNAL_ERROR (exc, "Mauvais type de layout.", "QtFaceOrthogonalPanel::QtFaceOrthogonalPanel") - throw exc; - } // if (0 == mainLayout) - QHBoxLayout* hlayout = new QHBoxLayout ( ); - mainLayout->addLayout (hlayout); - QLabel* label = new QLabel ("Nombre de couches :", this); - hlayout->addWidget (label); - _layersNumTextField = new QtIntTextField (this); - _layersNumTextField->setValue (5); - hlayout->addWidget (_layersNumTextField); - _layersNumTextField->setRange (0, NumericServices::intMachMax ( )); -} // QtFaceOrthogonalPanel::QtFaceOrthogonalPanel - - -QtFaceOrthogonalPanel::QtFaceOrthogonalPanel (const QtFaceOrthogonalPanel&) - : QtFaceDirectionalPanel (0,*new QtMgx3DMainWindow(0), 0), - _layersNumTextField (0) -{ - MGX_FORBIDDEN ("QtFaceDelaunayGMSHPanel copy constructor is not allowed."); -} // QtFaceOrthogonalPanel::QtFaceOrthogonalPanel - - -QtFaceOrthogonalPanel& QtFaceOrthogonalPanel::operator = ( - const QtFaceOrthogonalPanel&) -{ - MGX_FORBIDDEN ("QtFaceDelaunayGMSHPanel assignment operator is not allowed."); - return *this; -} // QtFaceOrthogonalPanel::operator = - - -QtFaceOrthogonalPanel::~QtFaceOrthogonalPanel ( ) -{ -} // QtFaceOrthogonalPanel::~QtFaceOrthogonalPanel - - -void QtFaceOrthogonalPanel::reset ( ) -{ - BEGIN_QT_TRY_CATCH_BLOCK - - CHECK_NULL_PTR_ERROR (_layersNumTextField) - _layersNumTextField->setValue (5); - - COMPLETE_QT_TRY_CATCH_BLOCK (true, this, "Magix 3D") - - QtFaceDirectionalPanel::reset ( ); -} // QtFaceOrthogonalPanel::reset - - -FaceMeshingPropertyOrthogonal* - QtFaceOrthogonalPanel::getMeshingProperty ( ) const -{ - return new FaceMeshingPropertyOrthogonal ( - getPoint1 ( ), getPoint2 ( ), getLayersNum ( )); -} // QtFaceOrthogonalPanel::getMeshingProperty - - -size_t QtFaceOrthogonalPanel::getLayersNum( ) const -{ - CHECK_NULL_PTR_ERROR (_layersNumTextField) - return _layersNumTextField->getValue ( ); -} // QtFaceOrthogonalPanel::getLayersNum - - - -// =========================================================================== -// LA CLASSE QtFaceRotationalPanel -// =========================================================================== - - -QtFaceRotationalPanel::QtFaceRotationalPanel ( - QWidget* parent, QtMgx3DMainWindow& window, QtMgx3DOperationPanel* mainPanel) - : QtMgx3DOperationsSubPanel (parent, window, mainPanel), - _directionTextField (0), _axePoint1Panel (0), _axePoint2Panel (0), - _directionLabel (0), _axeLabel (0) -{ -// setContentsMargins (0, 0, 0, 0); - QVBoxLayout* layout = new QVBoxLayout (this); - setLayout (layout); - layout->setContentsMargins ( - Resources::instance ( )._margin.getValue ( ), - Resources::instance ( )._margin.getValue ( ), - Resources::instance ( )._margin.getValue ( ), - Resources::instance ( )._margin.getValue ( )); - layout->setSpacing (Resources::instance ( )._spacing.getValue ( )); - - // La direction du maillage : - QLabel* label = new QLabel ("Direction", this); - QFont font (label->font ( )); - font.setBold (true); - label->setFont (font); - layout->addWidget (label); - _directionTextField = new QtMgx3DEdgePanel ( - this, "", true, "", &window, FilterEntity::TopoCoEdge); - _directionTextField->getEntityPanel ( ).setLabel ("Arête directionnelle :"); - _directionTextField->layout ( )->setContentsMargins (0, 0, 0, 0); - _directionTextField->layout ( )->setSpacing (0); - _directionTextField->setFixedSize (_directionTextField->sizeHint ( )); - layout->addWidget (_directionTextField); - connect (&_directionTextField->getEntityTextField ( ), - SIGNAL (selectionModified (QString)), this, - SLOT (parametersModifiedCallback ( ))); - QHBoxLayout* hlayout = new QHBoxLayout ( ); - layout->addLayout (hlayout); - label = new QLabel ("Direction :", this); - hlayout->addWidget (label); - _directionLabel = new QLabel ("", this); - hlayout->addWidget (_directionLabel); - hlayout->addStretch (2.); - - // L'axe de rotation : - label = new QLabel ("Axe de rotation", this); - label->setFont (font); - layout->addWidget (label); - _axePoint1Panel = new QtMgx3DPointPanel ( - this, "", true, "x :", "y :", "z :", - 0., -DBL_MAX, DBL_MAX, 0., -DBL_MAX, DBL_MAX, 0., -DBL_MAX, DBL_MAX, - &window, FilterEntity::AllPoints, true); - layout->addWidget (_axePoint1Panel); - connect (_axePoint1Panel, SIGNAL (pointModified ( )), this, - SLOT (parametersModifiedCallback ( ))); - _axePoint2Panel = new QtMgx3DPointPanel ( - this, "", true, "x :", "y :", "z :", - 1., -DBL_MAX, DBL_MAX, 0., -DBL_MAX, DBL_MAX, 0., -DBL_MAX, DBL_MAX, - &window, FilterEntity::AllPoints, true); - layout->addWidget (_axePoint2Panel); - connect (_axePoint2Panel, SIGNAL (pointModified ( )), this, - SLOT (parametersModifiedCallback ( ))); - _axeLabel = new QLabel ("", this); - layout->addWidget (_axeLabel); - - parametersModifiedCallback ( ); -} // QtFaceRotationalPanel::QtFaceRotationalPanel - - -QtFaceRotationalPanel::QtFaceRotationalPanel ( - const QtFaceRotationalPanel& p) - : QtMgx3DOperationsSubPanel (p), _directionTextField (0), - _axePoint1Panel (0), _axePoint2Panel (0), - _directionLabel (0), _axeLabel (0) -{ - MGX_FORBIDDEN ("QtFaceRotationalPanel copy constructor is not allowed."); -} // QtFaceRotationalPanel::QtFaceRotationalPanel - - -QtFaceRotationalPanel& QtFaceRotationalPanel::operator = ( - const QtFaceRotationalPanel&) -{ - MGX_FORBIDDEN ("QtFaceRotationalPanel assignment operator is not allowed."); - return *this; -} // QtFaceRotationalPanel::operator = - - -QtFaceRotationalPanel::~QtFaceRotationalPanel ( ) -{ -} // QtFaceRotationalPanel::~QtFaceRotationalPanel - - -void QtFaceRotationalPanel::reset ( ) -{ - BEGIN_QT_TRY_CATCH_BLOCK - - CHECK_NULL_PTR_ERROR (_directionTextField) - CHECK_NULL_PTR_ERROR (_axePoint1Panel) - CHECK_NULL_PTR_ERROR (_axePoint2Panel) - _directionTextField->reset ( ); - _axePoint1Panel->reset ( ); - _axePoint2Panel->reset ( ); - - CHECK_NULL_PTR_ERROR(_directionLabel) - _directionLabel->clear(); - - COMPLETE_QT_TRY_CATCH_BLOCK (true, this, "Magix 3D") - - QtMgx3DOperationsSubPanel::reset ( ); -} // QtFaceRotationalPanel::reset - - -void QtFaceRotationalPanel::setVisible (bool visible) -{ - preview (visible, true); - QtMgx3DOperationsSubPanel::setVisible (visible); -} // QtFaceRotationalPanel::setVisible - - -Math::Point QtFaceRotationalPanel::getDirPoint1 ( ) const -{ - CHECK_NULL_PTR_ERROR (_directionTextField) - const CoEdge* edge = getContext ( ).getTopoManager ( ).getCoEdge ( - _directionTextField->getUniqueName( )); - CHECK_NULL_PTR_ERROR (edge) - const Vertex* v1 = edge->getVertex (0); - CHECK_NULL_PTR_ERROR (v1) - - return v1->getCoord ( ); -} // QtFaceRotationalPanel::getDirPoint1 - - -Math::Point QtFaceRotationalPanel::getDirPoint2 ( ) const -{ - CHECK_NULL_PTR_ERROR (_directionTextField) - const CoEdge* edge = getContext ( ).getTopoManager ( ).getCoEdge ( - _directionTextField->getUniqueName( )); - CHECK_NULL_PTR_ERROR (edge) - const Vertex* v2 = edge->getVertex (edge->getNbVertices ( ) - 1); - CHECK_NULL_PTR_ERROR (v2) - - return v2->getCoord ( ); -} // QtFaceRotationalPanel::getDirPoint2 - - -Math::Point QtFaceRotationalPanel::getAxePoint1 ( ) const -{ - CHECK_NULL_PTR_ERROR (_axePoint1Panel) - return _axePoint1Panel->getPoint(); -} // QtFaceRotationalPanel::getAxePoint1 - - -Math::Point QtFaceRotationalPanel::getAxePoint2 ( ) const -{ - CHECK_NULL_PTR_ERROR (_axePoint2Panel) - return _axePoint2Panel->getPoint(); -} // QtFaceRotationalPanel::getAxePoint2 - - -FaceMeshingPropertyRotational* QtFaceRotationalPanel::getMeshingProperty ( ) const -{ - return new FaceMeshingPropertyRotational ( - getDirPoint1 ( ), getDirPoint2 ( ), getAxePoint1 ( ), getAxePoint2 ( )); -} // QtFaceRotationalPanel::getMeshingProperty - - -void QtFaceRotationalPanel::stopSelection ( ) -{ - if (0 != _directionTextField) - _directionTextField->stopSelection ( ); - if (0 != _axePoint1Panel) - _axePoint1Panel->stopSelection ( ); - if (0 != _axePoint2Panel) - _axePoint2Panel->stopSelection ( ); -} // QtFaceRotationalPanel::stopSelection - - -QtEntityIDTextField* QtFaceRotationalPanel::getEdgeTextField ( ) -{ - CHECK_NULL_PTR_ERROR (_directionTextField) - return &_directionTextField->getEntityTextField ( ); -} // QtFaceRotationalPanel::getEdgeTextField - - -QtEntityIDTextField* QtFaceRotationalPanel::getAxePoint1TextField ( ) -{ - CHECK_NULL_PTR_ERROR (_axePoint1Panel) - return _axePoint1Panel->getVertexTextField ( ); -} // QtFaceRotationalPanel::getAxePoint1TextField - - -QtEntityIDTextField* QtFaceRotationalPanel::getAxePoint2TextField ( ) -{ - CHECK_NULL_PTR_ERROR (_axePoint2Panel) - return _axePoint2Panel->getVertexTextField ( ); -} // QtFaceRotationalPanel::getAxePoint2TextField - - -void QtFaceRotationalPanel::preview (bool on, bool destroyInteractor) -{ - try - { - CHECK_NULL_PTR_ERROR (_directionLabel) - Math::Point p1 = getDirPoint1 ( ), p2 = getDirPoint2 ( ); - UTF8String label (Charset::UTF_8); - label << "(" << MgxNumeric::userRepresentation (p1.getX ( )) - << ", " << MgxNumeric::userRepresentation (p1.getY ( )) << ",\n" - << MgxNumeric::userRepresentation (p1.getZ ( )) << ") -> (" - << MgxNumeric::userRepresentation (p2.getX ( )) - << ",\n" << MgxNumeric::userRepresentation (p2.getY ( )) << ", " - << MgxNumeric::userRepresentation (p2.getZ ( )) - << ")"; - _directionLabel->setText (label.ascii ( ).c_str ( )); - } - catch (...) - { - } - - try - { - CHECK_NULL_PTR_ERROR (_axeLabel) - Math::Point p1 = getAxePoint1 ( ), p2 = getAxePoint2 ( ); - UTF8String label (Charset::UTF_8); - label << "(" << MgxNumeric::userRepresentation (p1.getX ( )) - << ", " << MgxNumeric::userRepresentation (p1.getY ( )) << ", " - << MgxNumeric::userRepresentation (p1.getZ ( )) << ") -> (" - << MgxNumeric::userRepresentation (p2.getX ( )) - << ", " << MgxNumeric::userRepresentation (p2.getY ( )) << ", " - << MgxNumeric::userRepresentation (p2.getZ ( )) - << ")"; - _axeLabel->setText (label.ascii ( ).c_str ( )); - } - catch (...) - { - } - - try - { // Quoi qu'il arrive on détruit l'éventuel aperçu existant : - removePreviewedObjects ( ); - } - catch (...) - { - } - - if (false == previewResult ( )) - return; - - DisplayProperties properties; - properties.setWireColor (Color ( - 255 * Resources::instance ( )._previewColor.getRed ( ), - 255 * Resources::instance ( )._previewColor.getGreen ( ), - 255 * Resources::instance ( )._previewColor.getBlue ( ))); - properties.setLineWidth (Resources::instance ( )._previewWidth.getValue ( )); - - try - { - if (true == on) - { - Math::Point p1 = getAxePoint1 ( ), p2 = getAxePoint2 ( ); - RenderingManager::RepresentationID axeID = - getRenderingManager ( ).createRotationAxe ( - p1, p2, properties, true); - registerPreviewedObject (axeID); - } // if (true == on) - } - catch (...) - { - } - try - { - if (true == on) - { - Math::Point p1 = getDirPoint1 ( ), p2 = getDirPoint2 ( ); - RenderingManager::RepresentationID directionID = - getRenderingManager ( ).createSegment(p1, p2, properties, true); - registerPreviewedObject (directionID); - } // if (true == on) - } - catch (...) - { - } - - try - { - getRenderingManager ( ).forceRender ( ); - } - catch (...) - { - } -} // QtFaceRotationalPanel::preview - // =========================================================================== // LA CLASSE QtFaceDelaunayGMSHPanel @@ -877,8 +293,7 @@ QtFaceMeshingPropertyPanel::QtFaceMeshingPropertyPanel ( QtMgx3DApplication::HelpSystem::instance ( ).facesMeshingPropertyOperationTag), _operationMethodComboBox (0), _currentParentWidget (0), _currentPanel (0), - _transfinitePanel (0), _directionalPanel (0), _orthogonalPanel (0), - _rotationalPanel (0), + _transfinitePanel (0), _delaunayGMSHPanel (0), _quadPairingPanel(0), _facesPanel (0) { @@ -948,12 +363,6 @@ QtFaceMeshingPropertyPanel::QtFaceMeshingPropertyPanel ( // _transfinitePanel->layout ( )->setSpacing (5); // _transfinitePanel->layout ( )->setContentsMargins (0, 0, 0, 0); _transfinitePanel->hide ( ); - _directionalPanel = new QtFaceDirectionalPanel (0, mainWindow, this); - _directionalPanel->hide ( ); - _orthogonalPanel = new QtFaceOrthogonalPanel (0, mainWindow, this); - _orthogonalPanel->hide ( ); - _rotationalPanel = new QtFaceRotationalPanel (0, mainWindow, this); - _rotationalPanel->hide ( ); _delaunayGMSHPanel = new QtFaceDelaunayGMSHPanel (0, mainWindow, this); _delaunayGMSHPanel->hide ( ); // _quadPairingPanel = new QtFaceQuadPairingPanel(0, mainWindow, this); @@ -973,8 +382,7 @@ QtFaceMeshingPropertyPanel::QtFaceMeshingPropertyPanel (const QtFaceMeshingPrope 0, *new QtMgx3DMainWindow(0), 0, "", ""), _operationMethodComboBox (0), _currentParentWidget (0), _currentPanel (0), - _transfinitePanel (0), _directionalPanel (0), _orthogonalPanel (0), - _rotationalPanel (0), + _transfinitePanel (0), _delaunayGMSHPanel (0), _quadPairingPanel(0), _facesPanel (0) { @@ -1006,20 +414,11 @@ QtFaceMeshingPropertyPanel::OPERATION_METHOD CoFaceMeshingProperty* QtFaceMeshingPropertyPanel::getMeshingProperty ( ) const { CHECK_NULL_PTR_ERROR (_transfinitePanel) - CHECK_NULL_PTR_ERROR (_directionalPanel) - CHECK_NULL_PTR_ERROR (_orthogonalPanel) - CHECK_NULL_PTR_ERROR (_rotationalPanel) CHECK_NULL_PTR_ERROR (_delaunayGMSHPanel) switch (getOperationMethod ( )) { case QtFaceMeshingPropertyPanel::TRANSFINITE : return _transfinitePanel->getMeshingProperty ( ); - case QtFaceMeshingPropertyPanel::DIRECTIONAL : - return _directionalPanel->getMeshingProperty ( ); - case QtFaceMeshingPropertyPanel::ORTHOGONAL : - return _orthogonalPanel->getMeshingProperty ( ); - case QtFaceMeshingPropertyPanel::ROTATIONAL : - return _rotationalPanel->getMeshingProperty ( ); case QtFaceMeshingPropertyPanel::DELAUNAY_GMSH : return _delaunayGMSHPanel->getMeshingProperty ( ); // case QtFaceMeshingPropertyPanel::QUAD_PAIRING : @@ -1044,16 +443,10 @@ void QtFaceMeshingPropertyPanel::reset ( ) BEGIN_QT_TRY_CATCH_BLOCK CHECK_NULL_PTR_ERROR (_transfinitePanel) - CHECK_NULL_PTR_ERROR (_directionalPanel) - CHECK_NULL_PTR_ERROR (_orthogonalPanel) - CHECK_NULL_PTR_ERROR (_rotationalPanel) CHECK_NULL_PTR_ERROR (_delaunayGMSHPanel) // CHECK_NULL_PTR_ERROR (_quadPairingPanel) CHECK_NULL_PTR_ERROR (_facesPanel) _transfinitePanel->reset ( ); - _directionalPanel->reset ( ); - _orthogonalPanel->reset ( ); - _rotationalPanel->reset ( ); _delaunayGMSHPanel->reset ( ); // _quadPairingPanel->reset ( ); _facesPanel->reset ( ); @@ -1091,9 +484,6 @@ void QtFaceMeshingPropertyPanel::validate ( ) switch (_operationMethodComboBox->currentIndex ( )) { case QtFaceMeshingPropertyPanel::TRANSFINITE : - case QtFaceMeshingPropertyPanel::DIRECTIONAL : - case QtFaceMeshingPropertyPanel::ORTHOGONAL : - case QtFaceMeshingPropertyPanel::ROTATIONAL : case QtFaceMeshingPropertyPanel::DELAUNAY_GMSH : // case QtFaceMeshingPropertyPanel::QUAD_PAIRING : break; @@ -1216,13 +606,6 @@ void QtFaceMeshingPropertyPanel::operationMethodCallback ( ) CHECK_NULL_PTR_ERROR (_facesPanel) CHECK_NULL_PTR_ERROR (_facesPanel->getNameTextField ( )) CHECK_NULL_PTR_ERROR (_transfinitePanel) - CHECK_NULL_PTR_ERROR (_directionalPanel) - CHECK_NULL_PTR_ERROR (_directionalPanel->getEdgeTextField ( )) - CHECK_NULL_PTR_ERROR (_orthogonalPanel) - CHECK_NULL_PTR_ERROR (_rotationalPanel) - CHECK_NULL_PTR_ERROR (_rotationalPanel->getEdgeTextField ( )) - CHECK_NULL_PTR_ERROR (_rotationalPanel->getAxePoint1TextField ( )) - CHECK_NULL_PTR_ERROR (_rotationalPanel->getAxePoint2TextField ( )) CHECK_NULL_PTR_ERROR (_delaunayGMSHPanel) // CHECK_NULL_PTR_ERROR (_quadPairingPanel) if (0 != _currentPanel) @@ -1240,35 +623,6 @@ void QtFaceMeshingPropertyPanel::operationMethodCallback ( ) { case QtFaceMeshingPropertyPanel::TRANSFINITE : _currentPanel = _transfinitePanel; break; - case QtFaceMeshingPropertyPanel::DIRECTIONAL : - _currentPanel = _directionalPanel; - _directionalPanel->getEdgeTextField ( )->setLinkedSeizureManagers ( - 0, _facesPanel->getNameTextField ( )); - _facesPanel->getNameTextField ( )->setLinkedSeizureManagers ( - _directionalPanel->getEdgeTextField ( ), 0); - break; - case QtFaceMeshingPropertyPanel::ORTHOGONAL : - _currentPanel = _orthogonalPanel; - _orthogonalPanel->getEdgeTextField ( )->setLinkedSeizureManagers ( - 0, _facesPanel->getNameTextField ( )); - _facesPanel->getNameTextField ( )->setLinkedSeizureManagers ( - _orthogonalPanel->getEdgeTextField ( ), 0); - break; - case QtFaceMeshingPropertyPanel::ROTATIONAL : - _currentPanel = _rotationalPanel ; - _rotationalPanel->getEdgeTextField ( )->setLinkedSeizureManagers ( - 0, _rotationalPanel->getAxePoint1TextField ( )); - _rotationalPanel->getAxePoint1TextField ( - )->setLinkedSeizureManagers ( - _rotationalPanel->getEdgeTextField ( ), - _rotationalPanel->getAxePoint2TextField ( )); - _rotationalPanel->getAxePoint2TextField ( - )->setLinkedSeizureManagers ( - _rotationalPanel->getAxePoint1TextField ( ), - _facesPanel->getNameTextField ( )); - _facesPanel->getNameTextField ( )->setLinkedSeizureManagers ( - _rotationalPanel->getAxePoint2TextField ( ), 0); - break; case QtFaceMeshingPropertyPanel::DELAUNAY_GMSH : _currentPanel = _delaunayGMSHPanel; break; // case QtFaceMeshingPropertyPanel::QUAD_PAIRING : diff --git a/src/QtComponents/QtTopoInformationOperationAction.cpp b/src/QtComponents/QtTopoInformationOperationAction.cpp index c7df039..61dad9c 100644 --- a/src/QtComponents/QtTopoInformationOperationAction.cpp +++ b/src/QtComponents/QtTopoInformationOperationAction.cpp @@ -366,15 +366,7 @@ void QtTopoInformationOperationPanel::autoUpdate ( ) nb_cofaces +=1; size_t nb = coface->getMeshingData()->faces().size(); nb_faces_tot += nb; - if (coface->getMeshLaw() == Topo::CoFaceMeshingProperty::directional){ - nb_fac_str_dir += 1; - nb_faces_str_dir += nb; - } - else if (coface->getMeshLaw() == Topo::CoFaceMeshingProperty::rotational){ - nb_fac_str_rot += 1; - nb_faces_str_rot += nb; - } - else if (coface->getMeshLaw() == Topo::CoFaceMeshingProperty::transfinite){ + if (coface->getMeshLaw() == Topo::CoFaceMeshingProperty::transfinite){ nb_fac_str_trans += 1; nb_faces_str_trans += nb; } diff --git a/src/QtComponents/protected/QtComponents/QtFaceMeshingPropertyAction.h b/src/QtComponents/protected/QtComponents/QtFaceMeshingPropertyAction.h index 9b1625e..8a5cad5 100644 --- a/src/QtComponents/protected/QtComponents/QtFaceMeshingPropertyAction.h +++ b/src/QtComponents/protected/QtComponents/QtFaceMeshingPropertyAction.h @@ -14,9 +14,6 @@ #include "QtComponents/QtMgx3DTopoOperationAction.h" #include "QtComponents/RenderingManager.h" #include "Topo/FaceMeshingPropertyTransfinite.h" -#include "Topo/FaceMeshingPropertyDirectional.h" -#include "Topo/FaceMeshingPropertyOrthogonal.h" -#include "Topo/FaceMeshingPropertyRotational.h" #include "Topo/FaceMeshingPropertyDelaunayGMSH.h" #include "Topo/FaceMeshingPropertyQuadPairing.h" @@ -72,278 +69,6 @@ class QtFaceTransfinitePanel : public QtMgx3DOperationsSubPanel }; // class QtFaceTransfinitePanel -/** - * Le paramétrage d'un maillage directionnel. - */ -class QtFaceDirectionalPanel : public QtMgx3DOperationsSubPanel -{ - Q_OBJECT - - public : - - /** - * \param Widget parent - * \param Fenêtre principale Magix 3D de rattachement, - * utilisée notamment pour récupérer le contexte. - * \param Eventuel panneau de rattachement. - */ - QtFaceDirectionalPanel ( - QWidget* parent, Mgx3D::QtComponents::QtMgx3DMainWindow& mw, - QtMgx3DOperationPanel* mainPanel); - - /** - * Destructeur. RAS. - */ - virtual ~QtFaceDirectionalPanel ( ); - - /** - * Réinitialise le panneau. - */ - virtual void reset ( ); - - /** - * \param true pour prévisualiser l'opération, false - * pour arrêter la prévisualisation. - * \param inutilisé - */ - virtual void preview (bool on, bool destroyInteractor); - - /** - * Affiche/masque la fenêtre, et les éventuelles informations de - * prévisualisation. - */ - virtual void setVisible (bool visible); - - /** - * \return Le point de départ définissant le vecteur directionnel. - * \see getPoint2 - */ - virtual Mgx3D::Utils::Math::Point getPoint1 ( ) const; - - /** - * \return Le point d'arrivée définissant le vecteur directionnel. - * \see getPoint1 - */ - virtual Mgx3D::Utils::Math::Point getPoint2 ( ) const; - - /** - * \return La propriété de maillage de la face conforme au panneau. - */ - virtual Mgx3D::Topo::FaceMeshingPropertyDirectional* - getMeshingProperty ( ) const; - - /** - * Faut-il inverser le vecteur donné par l'arête ? - */ - virtual bool isEdgeInverted ( ) const; - - /** - * Quitte le mode sélection interactive. - */ - virtual void stopSelection ( ); - - /** - * \return Le champ de saisie de l'arête directionnelle. - */ - virtual QtEntityIDTextField* getEdgeTextField ( ); - - - protected slots : - - /** - * Appelé lorsqu'un paramètre à changé : actualise les informations - * affichées. - */ - virtual void directionModifiedCallback ( ); - - - private : - - /** - * Constructeur de copie et opérateur = : interdits. - */ - QtFaceDirectionalPanel (const QtFaceDirectionalPanel&); - QtFaceDirectionalPanel& operator = (const QtFaceDirectionalPanel&); - - /** La saisie du vecteur directeur. */ - QtMgx3DEdgePanel* _edgeTextField; - - /** Le vecteur directionnel est-il à inverser ? */ - QCheckBox* _invertCheckBox; - - /** Le vecteur donnant la direction. */ - QLabel* _directionLabel; -}; // class QtFaceDirectionalPanel - - -/** - * Le paramétrage d'un maillage Orthogonal. - */ -class QtFaceOrthogonalPanel : public QtFaceDirectionalPanel -{ - public : - - /** - * \param Widget parent - * \param Fenêtre principale Magix 3D de rattachement, - * utilisée notamment pour récupérer le contexte. - * \param Eventuel panneau de rattachement. - */ - QtFaceOrthogonalPanel ( - QWidget* parent, Mgx3D::QtComponents::QtMgx3DMainWindow& mw, - QtMgx3DOperationPanel* mainPanel); - - /** - * Destructeur. RAS. - */ - virtual ~QtFaceOrthogonalPanel ( ); - - /** - * Réinitialise le panneau. - */ - virtual void reset ( ); - - /** - * \return La propriété de maillage de la face conforme au panneau. - */ - virtual Mgx3D::Topo::FaceMeshingPropertyOrthogonal* - getMeshingProperty ( ) const; - - /** - * \return Le nombre de couches. - */ - virtual size_t getLayersNum ( ) const; - - - private : - - /** - * Constructeur de copie et opérateur = : interdits. - */ - QtFaceOrthogonalPanel (const QtFaceOrthogonalPanel&); - QtFaceOrthogonalPanel& operator = (const QtFaceOrthogonalPanel&); - - /** Le nombre de couches. */ - QtIntTextField* _layersNumTextField; -}; // class QtFaceOrthogonalPanel - - -/** - * Le paramétrage d'un maillage rotationel. La rotation est définie par - * l'axe de rotation et la direction selon laquelle s'effectue le maillage. - */ -class QtFaceRotationalPanel : public QtMgx3DOperationsSubPanel -{ - public : - - /** - * \param Widget parent - * \param Fenêtre principale Magix 3D de rattachement, - * utilisée notamment pour récupérer le contexte. - * \param Eventuel panneau de rattachement. - */ - QtFaceRotationalPanel ( - QWidget* parent, Mgx3D::QtComponents::QtMgx3DMainWindow& mw, - QtMgx3DOperationPanel* mainPanel); - - /** - * Destructeur. RAS. - */ - virtual ~QtFaceRotationalPanel ( ); - - /** - * \param true pour prévisualiser l'opération, false - * pour arrêter la prévisualisation. - * \param inutilisé - */ - virtual void preview (bool on, bool destroyInteractor); - - /** - * Affiche/masque la fenêtre, et les éventuelles informations de - * prévisualisation. - */ - virtual void setVisible (bool visible); - - /** - * \return Le point de départ définissant la direction de la rotation. - * \see getDirPoint2 - * \see getAxePoint1 - */ - virtual Mgx3D::Utils::Math::Point getDirPoint1 ( ) const; - - /** - * \return Le point d'arrivée définissant la direction de la rotation. - * \see getDirPoint1 - */ - virtual Mgx3D::Utils::Math::Point getDirPoint2 ( ) const; - - /** - * \return Le point de départ définissant l'axe de rotation. - * \see getAxePoint2 - * \see getDirPoint1 - */ - virtual Mgx3D::Utils::Math::Point getAxePoint1 ( ) const; - - /** - * \return Le point d'arrivée définissant l'axe de rotation. - * \see getAxePoint1 - */ - virtual Mgx3D::Utils::Math::Point getAxePoint2 ( ) const; - - /** - * \return La propriété de maillage de la face conforme au panneau. - */ - virtual Mgx3D::Topo::FaceMeshingPropertyRotational* - getMeshingProperty ( ) const; - - /** - * Réinitialise le panneau. - */ - virtual void reset ( ); - - /** - * Quitte le mode sélection interactive. - */ - virtual void stopSelection ( ); - - /** - * \return Le champ de saisie de l'arête directionnelle. - */ - virtual QtEntityIDTextField* getEdgeTextField ( ); - - /** - * \return Le champ de saisie du premier point de l'axe de rotation. - */ - virtual QtEntityIDTextField* getAxePoint1TextField ( ); - - /** - * \return Le champ de saisie du second point de l'axe de rotation. - */ - virtual QtEntityIDTextField* getAxePoint2TextField ( ); - - - private : - - /** - * Constructeur de copie et opérateur = : interdits. - */ - QtFaceRotationalPanel (const QtFaceRotationalPanel&); - QtFaceRotationalPanel& operator = (const QtFaceRotationalPanel&); - - /** La saisie de l'arête donnant la direction du maillage. */ - QtMgx3DEdgePanel* _directionTextField; - - /** La saisie de 2 points permettant de définir l'axe de rotation. */ - QtMgx3DPointPanel *_axePoint1Panel, *_axePoint2Panel; - - /** Le vecteur donnant la direction. */ - QLabel* _directionLabel; - - /** Le vecteur donnant l'axe de rotation. */ - QLabel* _axeLabel; -}; // class QtFaceRotationalPanel - - /** * Le paramétrage d'un maillage Delaunay via GMSH. */ @@ -475,13 +200,10 @@ class QtFaceMeshingPropertyPanel : public QtMgx3DOperationPanel /** La méthode de maillage de la face. *
    *
  1. Maillage structuré transfini, - *
  2. Maillage structuré directionnel - *
  3. Maillage structuré directionnel orthogonal - *
  4. Maillage structuré rotationnel *
  5. Maillage non structuré Delaunay généré par GMSH *
*/ - enum OPERATION_METHOD { TRANSFINITE, DIRECTIONAL, ORTHOGONAL, ROTATIONAL, DELAUNAY_GMSH }; + enum OPERATION_METHOD { TRANSFINITE, DELAUNAY_GMSH }; /** * Créé l'ihm. @@ -603,15 +325,6 @@ class QtFaceMeshingPropertyPanel : public QtMgx3DOperationPanel /** Maillage transfini. */ QtFaceTransfinitePanel* _transfinitePanel; - /** Maillage structuré directionnel. */ - QtFaceDirectionalPanel* _directionalPanel; - - /** Maillage structuré directionnel orthogonal. */ - QtFaceOrthogonalPanel* _orthogonalPanel; - - /** Maillage structuré rotationnel. */ - QtFaceRotationalPanel* _rotationalPanel; - /** Maillage non structuré Delaunay généré avec GMSH. */ QtFaceDelaunayGMSHPanel* _delaunayGMSHPanel; diff --git a/src/pyMagix3D/CMakeLists.txt b/src/pyMagix3D/CMakeLists.txt index 1e8ba05..f87eb66 100644 --- a/src/pyMagix3D/CMakeLists.txt +++ b/src/pyMagix3D/CMakeLists.txt @@ -161,21 +161,14 @@ if (Doxygen_FOUND) ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/EdgeMeshingPropertyTabulated.h ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/EdgeMeshingPropertyBeta.h ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/CoFaceMeshingProperty.h - ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/FaceMeshingPropertyDirectional.h - ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/FaceMeshingPropertyOrthogonal.h - ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/FaceMeshingPropertyRotational.h ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/FaceMeshingPropertyTransfinite.h ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/FaceMeshingPropertyDelaunayNetgen.h ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/FaceMeshingPropertyDelaunayGMSH.h ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/FaceMeshingPropertyQuadPairing.h ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/BlockMeshingProperty.h - ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/BlockMeshingPropertyDirectional.h - ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/BlockMeshingPropertyOrthogonal.h - ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/BlockMeshingPropertyRotational.h ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/BlockMeshingPropertyTransfinite.h ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/BlockMeshingPropertyDelaunayNetgen.h ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/BlockMeshingPropertyDelaunayTetgen.h - ${CMAKE_SOURCE_DIR}/src/Core/protected/Topo/BlockMeshingPropertyInsertion.h ${CMAKE_SOURCE_DIR}/src/Core/protected/Mesh/MeshManagerIfc.h ${CMAKE_SOURCE_DIR}/src/Core/protected/Smoothing/SurfacicSmoothing.h ${CMAKE_SOURCE_DIR}/src/Core/protected/Smoothing/VolumicSmoothing.h diff --git a/src/pyMagix3D/pyMagix3D.doxygen b/src/pyMagix3D/pyMagix3D.doxygen index 08ed784..d922c38 100644 --- a/src/pyMagix3D/pyMagix3D.doxygen +++ b/src/pyMagix3D/pyMagix3D.doxygen @@ -770,9 +770,6 @@ INPUT = ../../src/Doc/User \ ../../src/Core/protected/Topo/EdgeMeshingPropertyTabulated.h \ ../../src/Core/protected/Topo/EdgeMeshingPropertyBeta.h \ ../../src/Core/protected/Topo/CoFaceMeshingProperty.h \ - ../../src/Core/protected/Topo/FaceMeshingPropertyDirectional.h \ - ../../src/Core/protected/Topo/FaceMeshingPropertyOrthogonal.h \ - ../../src/Core/protected/Topo/FaceMeshingPropertyRotational.h \ ../../src/Core/protected/Topo/FaceMeshingPropertyTransfinite.h \ ../../src/Core/protected/Topo/FaceMeshingPropertyDelaunayGMSH.h \ ../../src/Core/protected/Topo/FaceMeshingPropertyQuadPairing.h \ diff --git a/src/pyMagix3D/pyMagix3D.i b/src/pyMagix3D/pyMagix3D.i index 64beff8..10eb547 100644 --- a/src/pyMagix3D/pyMagix3D.i +++ b/src/pyMagix3D/pyMagix3D.i @@ -48,9 +48,6 @@ using std::ptrdiff_t; #include "Topo/EdgeMeshingPropertyGlobalInterpolate.h" #include "Topo/EdgeMeshingPropertyTabulated.h" #include "Topo/EdgeMeshingPropertyBeta.h" -#include "Topo/FaceMeshingPropertyDirectional.h" -#include "Topo/FaceMeshingPropertyOrthogonal.h" -#include "Topo/FaceMeshingPropertyRotational.h" #include "Topo/FaceMeshingPropertyTransfinite.h" #include "Topo/FaceMeshingPropertyDelaunayGMSH.h" #include "Topo/FaceMeshingPropertyQuadPairing.h" @@ -314,9 +311,6 @@ using std::ptrdiff_t; %include Topo/EdgeMeshingPropertyTabulated.h %include Topo/EdgeMeshingPropertyBeta.h %include Topo/CoFaceMeshingProperty.h -%include Topo/FaceMeshingPropertyDirectional.h -%include Topo/FaceMeshingPropertyOrthogonal.h -%include Topo/FaceMeshingPropertyRotational.h %include Topo/FaceMeshingPropertyTransfinite.h %include Topo/FaceMeshingPropertyDelaunayGMSH.h %include Topo/FaceMeshingPropertyQuadPairing.h diff --git a/src/pyMagix3D/swig_doc.i b/src/pyMagix3D/swig_doc.i index 759892f..5717076 100644 --- a/src/pyMagix3D/swig_doc.i +++ b/src/pyMagix3D/swig_doc.i @@ -479,108 +479,6 @@ bool Mgx3D::Topo::FaceMeshingPropertyDelaunayNetgen::isStructured() const Indique si la face est structurée. -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyDirectional " -Propriété de la discrétisation d'une face commune suivant une direction. -"; - -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyDirectional::FaceMeshingPropertyDirectional " -Mgx3D::Topo::FaceMeshingPropertyDirectional::FaceMeshingPropertyDirectional(Utils::Math::Point v1, Utils::Math::Point v2) - -Constructeur avec direction suivant 2 sommets. - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyDirectional::FaceMeshingPropertyDirectional " -Mgx3D::Topo::FaceMeshingPropertyDirectional::FaceMeshingPropertyDirectional(meshDirLaw md) - -Constructeur dont on connait la direction. - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyDirectional::getDir " -uint Mgx3D::Topo::FaceMeshingPropertyDirectional::getDir() const - -Accesseur sur la direction associée à la CoFace. - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyDirectional::getMeshLaw " -CoFaceMeshingProperty::meshLaw Mgx3D::Topo::FaceMeshingPropertyDirectional::getMeshLaw() const - -Accesseur sur la méthode de maillage. - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyDirectional::getMeshLawName " -std::string Mgx3D::Topo::FaceMeshingPropertyDirectional::getMeshLawName() const - -Accesseur sur le nom de la méthode de maillage. - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyDirectional::isStructured " -bool Mgx3D::Topo::FaceMeshingPropertyDirectional::isStructured() const - -Indique si la face est structurée. - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyDirectional::permDir " -void Mgx3D::Topo::FaceMeshingPropertyDirectional::permDir() - -inversion de la direction - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyRotational " -Propriété de la discrétisation d'une face commune. -"; - -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyRotational::FaceMeshingPropertyRotational " -Mgx3D::Topo::FaceMeshingPropertyRotational::FaceMeshingPropertyRotational(Utils::Math::Point v1, Utils::Math::Point v2, Utils::Math::Point axis1, Utils::Math::Point axis2) - - -Constructeur avec rotation suivant 2 sommets, autour d'un axe défini par deux points - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyRotational::FaceMeshingPropertyRotational " -Mgx3D::Topo::FaceMeshingPropertyRotational::FaceMeshingPropertyRotational(meshDirLaw md, Utils::Math::Point axis1, Utils::Math::Point axis2) - - -Constructeur avec rotation déterminée, autour d'un axe défini par deux points - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyRotational::getAxis " -void Mgx3D::Topo::FaceMeshingPropertyRotational::getAxis(Utils::Math::Point &axis1, Utils::Math::Point &axis2) - - -Retourne l'axe de rotation - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyRotational::getDir " -uint Mgx3D::Topo::FaceMeshingPropertyRotational::getDir() const - -Accesseur sur la direction associée à la CoFace. - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyRotational::getMeshLaw " -CoFaceMeshingProperty::meshLaw Mgx3D::Topo::FaceMeshingPropertyRotational::getMeshLaw() const - -Accesseur sur la méthode de maillage. - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyRotational::getMeshLawName " -std::string Mgx3D::Topo::FaceMeshingPropertyRotational::getMeshLawName() const - -Accesseur sur le nom de la méthode de maillage. - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyRotational::isStructured " -bool Mgx3D::Topo::FaceMeshingPropertyRotational::isStructured() const - -Indique si la face est structurée. - -"; -%feature("docstring") Mgx3D::Topo::FaceMeshingPropertyRotational::setAxis " -void Mgx3D::Topo::FaceMeshingPropertyRotational::setAxis(Utils::Math::Point &axis1, Utils::Math::Point &axis2) - - -Change l'axe de rotation - "; %feature("docstring") Mgx3D::Topo::FaceMeshingPropertyTransfinite " Propriété de la discrétisation d'une face commune.