1110 更新geometry_manager

CAE_Solution/src/VTK/QVTKRenderer/qvtkrenderer.cpp

@@ -553,6 +553,17 @@ void QVTKRenderer::RemoveAllActors()
 
 }
 
+/*
+ * @brief: remove one actor
+ * @param: actor
+ * @ret: void
+ * @birth: created by czm in 20231107
+ */
+void QVTKRenderer::RemoveActor(vtkProp *actor)
+{
+    if (renderer)  renderer->RemoveViewProp(actor);
+}
+
 
 
 

CAE_Solution/src/VTK/QVTKRenderer/qvtkrenderer.h

@@ -75,6 +75,7 @@ public:
     void SetLineWidth(float width);
     void HideAllActors();
     void RemoveAllActors();
+    void RemoveActor(vtkProp*);
 
 public:
     enum SelectionMode

CAE_Solution/src/component/MeshGeneration/MeshGenParams.cpp

@@ -1,210 +0,0 @@
-#include <QStringList>
-#include <ga_api.hxx>
-#include <kernapi.hxx>
-#include "MeshGenParams.h"
-
-
-/**
-  * @brief constructor
-  *
-  * @return 
-  * @author: shiting
-  * @date: 20230209
-  * @reviser: 
-  * @date: 
-  */
-MeshGenParamManager::MeshGenParamManager() : entAttribName_("entity_index")
-{
-}
-
-/**
-  * @brief destructor
-  *
-  * @return 
-  * @author: shiting
-  * @date: 20230209
-  * @reviser: 
-  * @date: 
-  */
-MeshGenParamManager::~MeshGenParamManager()
-{
-}
-
-/**
-  * @brief clear old data.
-  *
-  * @param[in] 
-  * @return 
-  * @author: shiting
-  * @date: 20230207
-  * @reviser: 
-  * @date: 
-  */
-void MeshGenParamManager::Clear()
-{
-    edgeEntMeshGenParamsMap_.clear();
-    faceEntMeshGenParamsMap_.clear();
-}
-
-/**
-  * @brief set the edge endtiy's mesh generation params.
-  *
-  * @param[in] edge entity and the mesh generation params.
-  * @return 
-  * @author: shiting
-  * @date: 20230209
-  * @reviser: 
-  * @date: 
-  */
-void MeshGenParamManager::SetMeshGenParamsOfEdge(ENTITY *edgeEnt, MeshGenParams_AtEdge &paramObj)
-{
-    edgeEntMeshGenParamsMap_[edgeEnt] = paramObj;
-}
-
-/**
-  * @brief get the edge endtiy's mesh generation params.
-  *
-  * @param[in] edge entity.
-  * @return the mesh generation params.
-  * @author: shiting
-  * @date: 20230209
-  * @reviser: 
-  * @date: 
-  */
-const MeshGenParams_AtEdge* MeshGenParamManager::GetMeshGenParamsOfEdge(ENTITY *edgeEnt)
-{
-    if (edgeEntMeshGenParamsMap_.find(edgeEnt) == edgeEntMeshGenParamsMap_.end())
-    {
-        return 0;
-    }
-    return &edgeEntMeshGenParamsMap_[edgeEnt];
-}
-
-/**
-  * @brief set the face endtiy's mesh generation params.
-  *
-  * @param[in] face entity and the mesh generation params.
-  * @return 
-  * @author: shiting
-  * @date: 20230209
-  * @reviser: 
-  * @date: 
-  */
-void MeshGenParamManager::SetMeshGenParamsOfFace(ENTITY *faceEnt, MeshGenParams_AtFace &paramObj)
-{
-    faceEntMeshGenParamsMap_[faceEnt] = paramObj;
-}
-
-/**
-  * @brief get the face entity's mesh generation params.
-  *
-  * @param[in] face entity.
-  * @return the mesh generation params.
-  * @author: shiting
-  * @date: 20230209
-  * @reviser: 
-  * @date: 
-  */
-const MeshGenParams_AtFace* MeshGenParamManager::GetMeshGenParamsOfFace(ENTITY *faceEnt)
-{
-    if (faceEntMeshGenParamsMap_.find(faceEnt) == faceEntMeshGenParamsMap_.end())
-    {
-        return 0;
-    }
-    return &faceEntMeshGenParamsMap_[faceEnt];
-}
-
-/**
-  * @brief get the entities that have mesh params setting.
-  *
-  * @param[in] 
-  * @return the entity list.
-  * @author: shiting
-  * @date: 20230209
-  * @reviser: 
-  * @date: 
-  */
-ENTITY_LIST MeshGenParamManager::GetEntitiesSettedParams()
-{
-    ENTITY_LIST ents;
-    for (map<ENTITY*, MeshGenParams_AtEdge>::iterator it = edgeEntMeshGenParamsMap_.begin(); it != edgeEntMeshGenParamsMap_.end(); ++it)
-    {
-        ents.add(it->first);
-    }
-    for (map<ENTITY*, MeshGenParams_AtFace>::iterator it = faceEntMeshGenParamsMap_.begin(); it != faceEntMeshGenParamsMap_.end(); ++it)
-    {
-        ents.add(it->first);
-    }
-    return ents;
-}
-
-/**
-  * @brief attach attrib to entity.
-  *
-  * @param[in] 
-  * @return 
-  * @author: shiting
-  * @date: 20230315
-  * @reviser: 
-  * @date: 
-  */
-void MeshGenParamManager::AttachEntityAttrib()
-{
-    ENTITY_LIST paramedEntities = this->GetEntitiesSettedParams();
-    for (ENTITY *ent = paramedEntities.first(); ent != 0; ent = paramedEntities.next())
-    {
-        const char *name = entAttribName_.toLatin1().constData();
-        if (find_named_attrib(ent, name) == 0)
-        {
-            int id;
-            api_get_entity_id(ent, id);
-            api_add_generic_named_attribute(ent, name, id);
-        }
-    }
-}
-
-/**
-  * @brief get all edges' local mesh params.
-  *
-  * @param[in] 
-  * @return the local mesh params of edges.
-  * @author: shiting
-  * @date: 20230317
-  * @reviser: 
-  * @date: 
-  */
-QString MeshGenParamManager::GetMeshGenParamsOfAllEdge()
-{
-    QStringList paramsList;
-    for (map<ENTITY*, MeshGenParams_AtEdge>::iterator it = edgeEntMeshGenParamsMap_.begin(); it != edgeEntMeshGenParamsMap_.end(); ++it)
-    {
-        int id;
-        api_get_entity_id(it->first, id);
-        paramsList << QString("%1,%2").arg(id).arg(it->second.size_);
-    }
-    return paramsList.join(';');
-}
-
-/**
-  * @brief get all faces' local mesh params.
-  *
-  * @param[in] 
-  * @return the local mesh params of faces.
-  * @author: shiting
-  * @date: 20230317
-  * @reviser: 
-  * @date: 
-  */
-QString MeshGenParamManager::GetMeshGenParamsOfAllFace()
-{
-    QStringList paramsList;
-    for (map<ENTITY*, MeshGenParams_AtFace>::iterator it = faceEntMeshGenParamsMap_.begin(); it != faceEntMeshGenParamsMap_.end(); ++it)
-    {
-        int id;
-        api_get_entity_id(it->first, id);
-        paramsList << QString("%1,%2").arg(id).arg(it->second.size_);
-    }
-    return paramsList.join(';');
-}
-
-

CAE_Solution/src/component/MeshGeneration/MeshGenParams.h

@@ -1,77 +0,0 @@
-#ifndef MESHGENPARAMS_H
-#define MESHGENPARAMS_H
-
-#include <map>
-using namespace std;
-#include <QString>
-#include <lists.hxx>
-
-
-class MeshGenParams_Base
-{
-public:
-    MeshGenParams_Base() : useDefault_(true) {}
-    MeshGenParams_Base(const MeshGenParams_Base &obj)
-    {
-        *this = obj;
-    }
-    MeshGenParams_Base& operator=(const MeshGenParams_Base &obj)
-    {
-        this->useDefault_ = obj.useDefault_;
-        this->size_ = obj.size_;
-        //...
-        return *this;
-    }
-
-    bool useDefault_;
-    QString  size_;
-};
-
-class MeshGenParams_Global : public MeshGenParams_Base
-{
-public:
-    MeshGenParams_Global() : MeshGenParams_Base() {}
-};
-
-class MeshGenParams_AtEdge : public MeshGenParams_Base
-{
-public:
-    MeshGenParams_AtEdge() : MeshGenParams_Base() {}
-};
-
-class MeshGenParams_AtFace : public MeshGenParams_Base
-{
-public:
-    MeshGenParams_AtFace() : MeshGenParams_Base() {}
-};
-
-///////////////////////////////////////
-/**
-  manage mesh generation parameters attach to each Face and Edge geometry entity.
-*/
-class MeshGenParamManager
-{
-public:
-    MeshGenParamManager();
-    ~MeshGenParamManager();
-    void Clear();
-    void SetMeshGenParamsOfEdge(ENTITY *edgeEnt, MeshGenParams_AtEdge &paramObj);
-    const MeshGenParams_AtEdge* GetMeshGenParamsOfEdge(ENTITY *edgeEnt);
-    void SetMeshGenParamsOfFace(ENTITY *faceEnt, MeshGenParams_AtFace &paramObj);
-    const MeshGenParams_AtFace* GetMeshGenParamsOfFace(ENTITY *faceEnt);
-    ENTITY_LIST GetEntitiesSettedParams();
-    void AttachEntityAttrib();
-
-    QString GetMeshGenParamsOfAllEdge();
-    QString GetMeshGenParamsOfAllFace();
-
-private:
-    map<ENTITY*, MeshGenParams_AtEdge>  edgeEntMeshGenParamsMap_;
-    map<ENTITY*, MeshGenParams_AtFace>  faceEntMeshGenParamsMap_;
-    const QString entAttribName_;
-};
-
-
-
-#endif
-

CAE_Solution/src/component/MeshGeneration/MeshGeneration.pri

@@ -1,5 +1,8 @@
 HEADERS += \ 
-    $$PWD/*.h
+    $$PWD/*.h \
+    $$PWD/meshparams_ds.h \
+    $$PWD/custommeshparamsmanager.h
 
 SOURCES += \ 
-     $$PWD/*.cpp
+     $$PWD/*.cpp \
+    $$PWD/custommeshparamsmanager.cpp

CAE_Solution/src/component/MeshGeneration/custommeshparamsmanager.cpp

@@ -0,0 +1,248 @@
+#include <acistype.hxx>
+#include "CustomMeshParamsManager.h"
+
+
+/**
+  * @brief constructor
+  *
+  * @return
+  * @author: shiting
+  * @date: 20230209
+  * @reviser:
+  * @date:
+  */
+CustomMeshParamsManager::CustomMeshParamsManager() : entAttribName_("entity_index")
+{
+}
+
+/**
+  * @brief destructor
+  *
+  * @return
+  * @author: shiting
+  * @date: 20230209
+  * @reviser:
+  * @date:
+  */
+CustomMeshParamsManager::~CustomMeshParamsManager()
+{
+}
+
+/**
+  * @brief clear old data.
+  *
+  * @param[in]
+  * @return
+  * @author: shiting
+  * @date: 20230207
+  * @reviser:
+  * @date:
+  */
+void CustomMeshParamsManager::Clear()
+{
+    customNameidEntsHash_.clear();
+    entCustomNameidsMap_.clear();
+    customNameidFaceParamsHash_.clear();
+    customNameidEdgeParamsHash_.clear();
+}
+
+/**
+  * @brief init meshgen params of face ents.
+  *
+  * @param[in] faces' group nameid.
+  * @param[in] faces entity list.
+  * @param[in] faces' group params.
+  * @return
+  * @author: shiting
+  * @date: 20231025
+  * @reviser:
+  * @date:
+  */
+void CustomMeshParamsManager::InitCustomMeshParamsOfFaces(const QString &customNameid, ENTITY_LIST faceEnts, const QStringList &paramsList)
+{
+    if (paramsList.size() < 7)  return;
+    if (faceEnts.iteration_count() == 0) return;
+    customNameidEntsHash_[customNameid] = faceEnts;
+    for (ENTITY *ent = faceEnts.first(); ent; ent = faceEnts.next())
+    {
+        if (entCustomNameidsMap_.find(ent) == entCustomNameidsMap_.end())
+        {
+            entCustomNameidsMap_[ent] = QStringList();
+        }
+        entCustomNameidsMap_[ent].append(customNameid);
+    }
+
+    GeoMeshGenParams_AtFace params;
+    params.maxSize_ = paramsList[0];
+    params.height_ = paramsList[1];
+    params.heightRatio_ = paramsList[2];
+    params.numOfLayers_ = paramsList[3];
+    params.chordError_ = paramsList[4];
+    params.geoApproxAngle_ = paramsList[5];
+    params.meshType_ = paramsList[6];
+    customNameidFaceParamsHash_[customNameid] = params;
+}
+
+/**
+  * @brief update meshgen params fo face ents.
+  *
+  * @param[in] faces' group nameid.
+  * @param[in] faces' group params.
+  * @return
+  * @author: shiting
+  * @date: 20231025
+  * @reviser:
+  * @date:
+  */
+void CustomMeshParamsManager::UpdateCustomMeshParamsOfFaces(const QString &customNameid, const QStringList &paramsList)
+{
+    if (paramsList.size() < 7)  return;
+    if (customNameidFaceParamsHash_.count(customNameid) == 0) return;
+    customNameidFaceParamsHash_[customNameid].maxSize_ = paramsList[0];
+    customNameidFaceParamsHash_[customNameid].height_ = paramsList[1];
+    customNameidFaceParamsHash_[customNameid].heightRatio_ = paramsList[2];
+    customNameidFaceParamsHash_[customNameid].numOfLayers_ = paramsList[3];
+    customNameidFaceParamsHash_[customNameid].chordError_ = paramsList[4];
+    customNameidFaceParamsHash_[customNameid].geoApproxAngle_ = paramsList[5];
+    customNameidFaceParamsHash_[customNameid].meshType_ = paramsList[6];
+}
+
+/**
+  * @brief init meshgen params of edge ents.
+  *
+  * @param[in] edges' group nameid.
+  * @param[in] edges entity list.
+  * @param[in] edges' group params.
+  * @return
+  * @author: shiting
+  * @date: 20231025
+  * @reviser:
+  * @date:
+  */
+void CustomMeshParamsManager::InitCustomMeshParamsOfEdges(const QString &customNameid, ENTITY_LIST edgeEnts, const QStringList &paramsList)
+{
+    if (paramsList.size() < 13)  return;
+    if (edgeEnts.iteration_count() == 0) return;
+    customNameidEntsHash_[customNameid] = edgeEnts;
+    for (ENTITY *ent = edgeEnts.first(); ent; ent = edgeEnts.next())
+    {
+        if (entCustomNameidsMap_.find(ent) == entCustomNameidsMap_.end())
+        {
+            entCustomNameidsMap_[ent] = QStringList();
+        }
+        entCustomNameidsMap_[ent].append(customNameid);
+    }
+
+    GeoMeshGenParams_AtEdge params;
+    params.maxSize_ = paramsList[0];
+    params.numOfNodes_ = paramsList[1];
+    params.height_ = paramsList[2];
+    params.heightRatio_ = paramsList[3];
+    params.numOfLayers_ = paramsList[4];
+    params.chordError_ = paramsList[5];
+    params.geoApproxAngle_ = paramsList[6];
+    params.bunchingLaw_ = paramsList[7];
+    params.spacing1_ = paramsList[8];
+    params.ratio1_ = paramsList[9];
+    params.spacing2_ = paramsList[10];
+    params.ratio2_ = paramsList[11];
+    params.maxSpace_ = paramsList[12];
+    customNameidEdgeParamsHash_[customNameid] = params;
+}
+
+/**
+  * @brief update meshgen params fo edge ents.
+  *
+  * @param[in] edges' group nameid.
+  * @param[in] edges' group params.
+  * @return
+  * @author: shiting
+  * @date: 20231025
+  * @reviser:
+  * @date:
+  */
+void CustomMeshParamsManager::UpdateCustomMeshParamsOfEdges(const QString &customNameid, const QStringList &paramsList)
+{
+    if (paramsList.size() < 13)  return;
+    if (customNameidEdgeParamsHash_.count(customNameid) == 0) return;
+    customNameidEdgeParamsHash_[customNameid].maxSize_ = paramsList[0];
+    customNameidEdgeParamsHash_[customNameid].numOfNodes_ = paramsList[1];
+    customNameidEdgeParamsHash_[customNameid].height_ = paramsList[2];
+    customNameidEdgeParamsHash_[customNameid].heightRatio_ = paramsList[3];
+    customNameidEdgeParamsHash_[customNameid].numOfLayers_ = paramsList[4];
+    customNameidEdgeParamsHash_[customNameid].chordError_ = paramsList[5];
+    customNameidEdgeParamsHash_[customNameid].geoApproxAngle_ = paramsList[6];
+    customNameidEdgeParamsHash_[customNameid].bunchingLaw_ = paramsList[7];
+    customNameidEdgeParamsHash_[customNameid].spacing1_ = paramsList[8];
+    customNameidEdgeParamsHash_[customNameid].ratio1_ = paramsList[9];
+    customNameidEdgeParamsHash_[customNameid].spacing2_ = paramsList[10];
+    customNameidEdgeParamsHash_[customNameid].ratio2_ = paramsList[11];
+    customNameidEdgeParamsHash_[customNameid].maxSpace_ = paramsList[12];
+}
+
+/**
+  * @brief get the entities that have mesh params setting.
+  *
+  * @param[in]
+  * @return the entity list.
+  * @author: shiting
+  * @date: 20230209
+  * @reviser:
+  * @date:
+  */
+ENTITY_LIST CustomMeshParamsManager::GetEntitiesSettedParams()
+{
+    ENTITY_LIST ents;
+    for (auto it {entCustomNameidsMap_.begin()}; it != entCustomNameidsMap_.end(); ++it)
+    {
+        ents.add(it.key());
+    }
+    return ents;
+}
+
+/**
+  * @brief get entity's mesh params.
+  *
+  * @param[in] the entity.
+  * @return entity's mesh params.
+  * @author: shiting
+  * @date: 20231030
+  * @reviser:
+  * @date:
+  */
+QStringList CustomMeshParamsManager::GetCustomParamsOfEntity(ENTITY *ent)
+{
+    QStringList params;
+    if (entCustomNameidsMap_.count(ent) == 0)  return params;
+    QString nameid {entCustomNameidsMap_[ent].back()};
+    if (is_FACE(ent))
+    {
+        params << customNameidFaceParamsHash_[nameid].maxSize_;
+        params << customNameidFaceParamsHash_[nameid].height_;
+        params << customNameidFaceParamsHash_[nameid].heightRatio_;
+        params << customNameidFaceParamsHash_[nameid].numOfLayers_;
+        params << customNameidFaceParamsHash_[nameid].chordError_;
+        params << customNameidFaceParamsHash_[nameid].geoApproxAngle_;
+        params << customNameidFaceParamsHash_[nameid].meshType_;
+    }
+    else if (is_EDGE(ent))
+    {
+        params << customNameidEdgeParamsHash_[nameid].maxSize_;
+        params << customNameidEdgeParamsHash_[nameid].numOfNodes_;
+        params << customNameidEdgeParamsHash_[nameid].height_;
+        params << customNameidEdgeParamsHash_[nameid].heightRatio_;
+        params << customNameidEdgeParamsHash_[nameid].numOfLayers_;
+        params << customNameidEdgeParamsHash_[nameid].chordError_;
+        params << customNameidEdgeParamsHash_[nameid].geoApproxAngle_;
+        params << customNameidEdgeParamsHash_[nameid].bunchingLaw_;
+        params << customNameidEdgeParamsHash_[nameid].spacing1_;
+        params << customNameidEdgeParamsHash_[nameid].ratio1_;
+        params << customNameidEdgeParamsHash_[nameid].spacing2_;
+        params << customNameidEdgeParamsHash_[nameid].ratio2_;
+        params << customNameidEdgeParamsHash_[nameid].maxSpace_;
+    }
+    return params;
+}
+
+
+

CAE_Solution/src/component/MeshGeneration/custommeshparamsmanager.h

@@ -0,0 +1,40 @@
+#ifndef CUSTOMMESHPARAMSMANAGER_H
+#define CUSTOMMESHPARAMSMANAGER_H
+
+
+#include <QString>
+#include <QStringList>
+#include <QHash>
+#include <lists.hxx>
+#include "MeshParams_DS.h"
+
+
+/**
+  manage mesh generation parameters attach to each Face and Edge geometry entity.
+*/
+class CustomMeshParamsManager
+{
+public:
+    CustomMeshParamsManager();
+    ~CustomMeshParamsManager();
+    void Clear();
+
+    void InitCustomMeshParamsOfFaces(const QString &customNameid, ENTITY_LIST faceEnts, const QStringList &paramsList);
+    void UpdateCustomMeshParamsOfFaces(const QString &customNameid, const QStringList &paramsList);
+    void InitCustomMeshParamsOfEdges(const QString &customNameid, ENTITY_LIST edgeEnts, const QStringList &paramsList);
+    void UpdateCustomMeshParamsOfEdges(const QString &customNameid, const QStringList &paramsList);
+
+    ENTITY_LIST GetEntitiesSettedParams();
+    QStringList GetCustomParamsOfEntity(ENTITY *ent);
+
+private:
+    //custom setting.
+    QHash<QString, ENTITY_LIST>  customNameidEntsHash_;
+    QHash<ENTITY*, QStringList>  entCustomNameidsMap_;
+    QHash<QString, GeoMeshGenParams_AtFace>  customNameidFaceParamsHash_;
+    QHash<QString, GeoMeshGenParams_AtEdge>  customNameidEdgeParamsHash_;
+
+    const QString entAttribName_;
+};
+
+#endif // CUSTOMMESHPARAMSMANAGER_H

CAE_Solution/src/component/MeshGeneration/meshparams_ds.h

@@ -0,0 +1,52 @@
+#ifndef MESHPARAMS_DS_H
+#define MESHPARAMS_DS_H
+#include <QString>
+
+
+class GeoMeshGenParams_Common
+{
+public:
+    GeoMeshGenParams_Common() = default;
+    virtual ~GeoMeshGenParams_Common() = default;
+
+    QString  maxSize_;
+    QString  height_;
+    QString  heightRatio_;
+    QString  numOfLayers_;
+    QString  chordError_;
+    QString  geoApproxAngle_;
+};
+
+class GeoMeshGenParams_AtPart : public GeoMeshGenParams_Common
+{
+public:
+    GeoMeshGenParams_AtPart() = default;
+
+    QString  enablePrism_;
+    QString  enableInternalWall_;
+    QString  enableSplitWall_;
+};
+
+class GeoMeshGenParams_AtEdge : public GeoMeshGenParams_Common
+{
+public:
+    GeoMeshGenParams_AtEdge() = default;
+
+    QString numOfNodes_;
+    QString bunchingLaw_;
+    QString spacing1_;
+    QString ratio1_;
+    QString spacing2_;
+    QString ratio2_;
+    QString maxSpace_;
+};
+
+class GeoMeshGenParams_AtFace : public GeoMeshGenParams_Common
+{
+public:
+    GeoMeshGenParams_AtFace() = default;
+
+    QString meshType_;
+};
+
+#endif // MESHPARAMS_DS_H

CAE_Solution/src/component/VisGeometry/FacetGeometry.cpp

@@ -11,12 +11,17 @@ using namespace std;
 #include <getowner.hxx>
 #include <transf.hxx>
 
+#include <vtkSmartPointer.h>
+#include <vtkMultiBlockDataSet.h>
+#include <vtkPolyData.h>
+#include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkUnstructuredGrid.h>
 #include <vtkTriangle.h>
 #include <vtkPolyLine.h>
 #include <vtkVertex.h>
 
+
 #include "FacetGeometry.h"
 
 
@@ -203,6 +208,102 @@ std::pair<vtkUnstructuredGrid*, ENTITY_LIST> GeometryFaceter::GetMeshOfEdgeEntit
     return std::pair<vtkUnstructuredGrid*, ENTITY_LIST>{unMesh, resResultEnts};
 }
 
+/**
+  * @brief get edge entities mesh.
+  *
+  * @param[in] faceted edges.
+  * @return mesh of edges, and edgeMesh entities.
+  * @author: shiting
+  * @date: 20230804
+  * @reviser:
+  * @date:
+  */
+std::tuple<vtkUnstructuredGrid*, vtkSmartPointer<vtkMultiBlockDataSet>, ENTITY_LIST> GeometryFaceter::GetMeshOfEdgeEntities2(const ENTITY_LIST &edgeEnts)
+{
+    vector<vtkPoints*> ptsVec;
+    ptsVec.reserve(edgeEnts.iteration_count());
+    ENTITY_LIST resResultEnts;
+    for (ENTITY *ent = edgeEnts.first(); ent; ent = edgeEnts.next())
+    {
+        EDGE *edge = static_cast<EDGE*>(ent);
+        SPAposition *pos = 0;
+        int np = 0;
+        outcome out = api_get_facet_edge_points(edge, pos, np);
+        if (!out.ok())
+        {
+            ACIS_DELETE [] pos;
+            continue;
+        }
+        if (np == 0 || pos == 0)  continue;
+        resResultEnts.add(ent);
+        SPAtransf tr = get_owner_transf(edge);
+
+        vtkPoints *points = vtkPoints::New();
+        points->SetNumberOfPoints(np);
+        for (int id = 0; id < np; ++id)
+        {
+            pos[id] *= tr;
+            points->SetPoint(id, pos[id].x(), pos[id].y(), pos[id].z());
+        }
+        ACIS_DELETE [] pos;
+        ptsVec.push_back(points);
+    }
+    int nPolyline = ptsVec.size();
+    if (nPolyline == 0)  return std::tuple<vtkUnstructuredGrid*, vtkSmartPointer<vtkMultiBlockDataSet>, ENTITY_LIST>{nullptr, nullptr, resResultEnts};
+
+    //mbds
+    vtkSmartPointer<vtkMultiBlockDataSet> mbds = vtkSmartPointer<vtkMultiBlockDataSet>::New();
+    mbds->SetNumberOfBlocks(nPolyline);
+    for (int i = 0; i < nPolyline; ++i)
+    {
+        vtkPoints *points = ptsVec[i];
+        int np = points->GetNumberOfPoints();
+        vtkSmartPointer<vtkCellArray> cellArray {vtkSmartPointer<vtkCellArray>::New()};
+        cellArray->InsertNextCell(np);
+        for (int id = 0; id < np; ++id)
+        {
+            cellArray->InsertCellPoint(id);
+        }
+
+        vtkSmartPointer<vtkPolyData> polyData {vtkSmartPointer<vtkPolyData>::New()};
+        polyData->SetPoints(points);
+        polyData->SetLines(cellArray);
+        mbds->SetBlock(i, polyData);
+    }
+
+    //unsgrid
+    int totalPoint = 0;
+    for (int i = 0; i < nPolyline; ++i)
+    {
+        totalPoint += ptsVec[i]->GetNumberOfPoints();
+    }
+    vtkPoints *meshPoints = vtkPoints::New();
+    meshPoints->SetNumberOfPoints(totalPoint);
+
+    vtkUnstructuredGrid *unMesh = vtkUnstructuredGrid::New();
+    unMesh->Allocate(nPolyline);
+    int num = 0;
+    for (int i = 0; i < nPolyline; ++i)
+    {
+        int np = ptsVec[i]->GetNumberOfPoints();
+        vtkPolyLine *cell = vtkPolyLine::New();
+        cell->GetPointIds()->SetNumberOfIds(np);
+        for (int id = 0; id < np; ++id)
+        {
+            meshPoints->SetPoint(num, ptsVec[i]->GetPoint(id));
+            cell->GetPointIds()->SetId(id, num);
+            ++num;
+        }
+        ptsVec[i]->Delete();
+        unMesh->InsertNextCell(cell->GetCellType(), cell->GetPointIds());
+        cell->Delete();
+    }
+    unMesh->SetPoints(meshPoints);
+    meshPoints->Delete();
+    return std::tuple<vtkUnstructuredGrid*, vtkMultiBlockDataSet*, ENTITY_LIST>{unMesh, mbds, resResultEnts};
+}
+
+
 /**
   * @brief get the mesh of vertex entities.
   *

CAE_Solution/src/component/VisGeometry/FacetGeometry.h

@@ -2,8 +2,11 @@
 #define FACETGEOMETRY_H
 
 #include <utility>
+#include <tuple>
 #include <lists.hxx>
+#include <vtkSmartPointer.h>
 
+class vtkMultiBlockDataSet;
 class vtkUnstructuredGrid;
 
 
@@ -17,6 +20,7 @@ public:
     static bool FacetGeometry(const ENTITY_LIST &ents);
     static vtkUnstructuredGrid* GetMeshOfFaceEntity(ENTITY *faceEnt);
     static std::pair<vtkUnstructuredGrid*, ENTITY_LIST> GetMeshOfEdgeEntities(const ENTITY_LIST &edgeEnts);
+    static std::tuple<vtkUnstructuredGrid*, vtkSmartPointer<vtkMultiBlockDataSet>, ENTITY_LIST> GetMeshOfEdgeEntities2(const ENTITY_LIST &edgeEnts);
     static vtkUnstructuredGrid* GetMeshOfVertexEntities(const ENTITY_LIST &vertexEnts);
 };
 

CAE_Solution/src/component/VisGeometry/VisGeometry_VTK.cpp

@@ -7,7 +7,12 @@
 #include "VisGeometry_VTK.h"
 #include "../../VTK/visualization_VTK/vtkvisunstructuredgridsource.h"
 #include "../../VTK/visualization_VTK/vtkvisunshademesh.h"
-
+#include <vtkMultiBlockDataSet.h>
+#include <vtkProperty.h>
+#include <vtkRenderer.h>
+#include <vtkDataSetMapper.h>
+#include <vtkCompositeDataDisplayAttributes.h>
+#include <vtkRenderer.h>
 
 
 /**
@@ -44,8 +49,8 @@ VtkVisGeometry::VtkVisGeometry(QVTKRenderer *qvtkRenderer)
     COLORS_.push_back(vtkColor3f(0.52941, 0.0, 0.0));
 
     renderer_ = 0;
-    edgeVisMesh_ = 0;
-    vertexVisMesh_ = 0;
+//    edgeVisMesh_ = 0;
+//    vertexVisMesh_ = 0;
     SetRenderer(qvtkRenderer);
 }
 
@@ -61,7 +66,7 @@ VtkVisGeometry::VtkVisGeometry(QVTKRenderer *qvtkRenderer)
   */
 VtkVisGeometry::~VtkVisGeometry()
 {
-    for (auto it = vismeshFaceMap_.begin(); it != vismeshFaceMap_.end(); ++it)
+    /*for (auto it = vismeshFaceMap_.begin(); it != vismeshFaceMap_.end(); ++it)
     {
         if (!renderer_)
         {
@@ -88,8 +93,18 @@ VtkVisGeometry::~VtkVisGeometry()
         }
         vertexVisMesh_->Delete();
         vertexVisMesh_ = 0;
+    }*/
+    if(renderer_){
+        for(auto it = faceActorsVec_.begin();it != faceActorsVec_.end();++it){
+            renderer_->RemoveActor(*it);
+        }
+        if(edgesActor_){
+            renderer_->RemoveActor(edgesActor_);
+        }
+        if(verticesActor_){
+            renderer_->RemoveActor(verticesActor_);
+        }
     }
-
     for (auto &item : actorDatasetMap_)
     {
         item.second->Delete();
@@ -203,21 +218,26 @@ void VtkVisGeometry::CreateGeoDisplay(const ENTITY_LIST &geoEnts)
 void VtkVisGeometry::createFacesDisplay(const ENTITY_LIST &faceEnts)
 {
     if (renderer_ == 0)  return;
+    int id {0};
     for (ENTITY *ent = faceEnts.first(); ent; ent = faceEnts.next())
     {
         vtkUnstructuredGrid *unMesh = GeometryFaceter::GetMeshOfFaceEntity(ent);
         if (unMesh == 0) continue;
-        vtkVISUnShadeMesh *visobj = createVisDisplayObj(unMesh);
-        //unMesh->Delete();
-        int num = vismeshFaceMap_.size();
-        int id = num % COLORS_.size();
-        vtkColor3f color(COLORS_.at(id));
-        visobj->SetColor(color.GetRed(), color.GetGreen(), color.GetBlue());
-        vismeshFaceMap_[visobj] = ent;
-        vtkProp *actor {visobj->GetActor()};
-        geoActorMap_[ent] = actor;
-        //actorGeotypeMap_[actor] = GeomType::GeomFace;
+        vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
+        mapper->SetInputData(unMesh);
+        vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+        actor->SetMapper(mapper);
+        int num = faceActorsVec_.size();
+        int n = num % COLORS_.size();
+        vtkColor3f color(COLORS_.at(n));
+        actor->GetProperty()->SetColor(color.GetRed(), color.GetGreen(), color.GetBlue());
+        renderer_->GetRenderer()->AddActor(actor);
+        faceActorsVec_.push_back(actor);
+        actorFaceMap_[actor] = ent;
         actorDatasetMap_[actor] = unMesh;
+        geoActorMap_[ent] = actor;
+        geoMeshIdMap_[ent] = id;
+        ++id;
     }
 }
 
@@ -235,37 +255,36 @@ void VtkVisGeometry::createEdgesDisplay(const ENTITY_LIST &edgeEnts)
 {
     //all edges in one mesh.
     if (renderer_ == 0)  return;
-    pair<vtkUnstructuredGrid*, ENTITY_LIST> resPair = GeometryFaceter::GetMeshOfEdgeEntities(edgeEnts);
-    vtkUnstructuredGrid *unMesh = resPair.first;
+    auto res = GeometryFaceter::GetMeshOfEdgeEntities2(edgeEnts);
+    vtkUnstructuredGrid *unMesh {std::get<0>(res)};
     if (unMesh == 0)  return;
-    vtkVISUnShadeMesh *visobj = createVisDisplayObj(unMesh);
-    //unMesh->Delete();
-    visobj->SetColor(0.0, 0.0, 1.0);
-    visobj->SetMeshLineWidth(4.0);
-    edgeVisMesh_ = visobj;
-    vtkProp *actor {visobj->GetActor()};
+    vtkSmartPointer<vtkMultiBlockDataSet> mbds  {std::get<1>(res)};
+    ENTITY_LIST edgeList(std::get<2>(res));
+
+
+    edgesMapper_ = vtkSmartPointer<vtkCompositePolyDataMapper2>::New();
+    edgesMapper_->SetInputDataObject(mbds);
+    vtkSmartPointer<vtkCompositeDataDisplayAttributes> edgesAttrib {vtkSmartPointer<vtkCompositeDataDisplayAttributes>::New()};
+    edgesMapper_->SetCompositeDataDisplayAttributes(edgesAttrib);
+    auto blkNum {mbds->GetNumberOfBlocks()};
+    double rgb[] {0.0,0.0,1.0};
+    for(int i {0};i<blkNum;++i){
+        edgesMapper_->SetBlockColor(i+1,rgb);
+    }
+    edgesActor_ = vtkSmartPointer<vtkActor>::New();
+    edgesActor_->SetMapper(edgesMapper_);
+    edgesActor_->GetProperty()->SetLineWidth(4.0);
+    renderer_->GetRenderer()->AddActor(edgesActor_);
+    actorDatasetMap_[edgesActor_] = unMesh;
+
     int id {0};
-    for (ENTITY *ent = resPair.second.first(); ent; ent = resPair.second.next())
+    for (ENTITY *ent = edgeList.first(); ent; ent = edgeList.next())
     {
-        geoActorMap_[ent] = actor;
-        vismeshcellEdgeMap_[id] = ent;
+        geoActorMap_[ent] = edgesActor_;
+        geoMeshIdMap_[ent] = id;
+
         ++id;
     }
-    //actorGeotypeMap_[actor] = GeomType::GeomEdges;
-    actorDatasetMap_[actor] = unMesh;
-
-    //each edge is a mesh.  unused.
-    //for (ENTITY *ent = edgeEnts.first(); ent; ent = edgeEnts.next())
-    //{
-        //vtkUnstructuredGrid *unMesh = GeometryFaceter::GetMeshOfEdgeEntity(ent);
-        //if (unMesh == 0) continue;
-        //vtkVISUnShadeMesh *visobj = createVisDisplayObj(unMesh);
-        //unMesh->Delete();
-        //visobj->SetColor(0.0, 0.0, 1.0);
-        //visobj->SetMeshLineWidth(4.0);
-        //entityMeshMap_[ent] = visobj;
-        //meshEntityMap_[visobj] = ent;
-    //}
 }
 
 /**
@@ -283,46 +302,26 @@ void VtkVisGeometry::createVerticesDisplay(const ENTITY_LIST &vertexEnts)
     if (renderer_ == 0)  return;
     vtkUnstructuredGrid *unMesh = GeometryFaceter::GetMeshOfVertexEntities(vertexEnts);
     if (unMesh == 0) return;
-    vtkVISUnShadeMesh *visobj = createVisDisplayObj(unMesh);
-    //unMesh->Delete();
-    visobj->SetColor(1.0, 0.0, 0.0);
-    visobj->SetMeshPointSize(8.0);
-    char str[] = "Points";
-    visobj->ChangeRepresentation(str);
-    vertexVisMesh_ = visobj;
-    vtkProp *actor {visobj->GetActor()};
+    vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
+    mapper->SetInputData(unMesh);
+    verticesActor_ = vtkSmartPointer<vtkActor>::New();
+    verticesActor_->SetMapper(mapper);
+    verticesActor_->GetProperty()->SetColor(1.0, 0.0, 0.0);
+    verticesActor_->GetProperty()->SetRepresentationToPoints();
+    verticesActor_->GetProperty()->SetPointSize(8.0);
+    renderer_->GetRenderer()->AddActor(verticesActor_);
+    actorDatasetMap_[verticesActor_] = unMesh;
+
     int id {0};
     for (ENTITY *ent = vertexEnts.first(); ent; ent = vertexEnts.next())
     {
-        geoActorMap_[ent] = actor;
-        vismeshcellVertexMap_[id] = ent;
+        geoActorMap_[ent] = verticesActor_;
+        geoMeshIdMap_[ent] = id;
+        meshcellidVertexMap_[id] = ent;
         ++id;
     }
-    //actorGeotypeMap_[actor] = GeomType::GeomVertices;
-    actorDatasetMap_[actor] = unMesh;
 }
 
-/**
-  * @brief create mesh display object.
-  *
-  * @param[in] vtkUnstructuredGrid object.
-  * @return 
-  * @author: shiting
-  * @date: 20230809
-  * @reviser: 
-  * @date: 
-  */
-vtkVISUnShadeMesh* VtkVisGeometry::createVisDisplayObj(vtkUnstructuredGrid *unMesh)
-{
-    vtkVISUnstructuredGridSource *source = vtkVISUnstructuredGridSource::New();
-    source->unstruGrid = unMesh;
-    vtkVISUnShadeMesh *visobj = vtkVISUnShadeMesh::New();
-    visobj->SetRenderTo(renderer_->GetRenderer());
-    visobj->SetDataSource(source);
-    visobj->CreateShadeMeshDisplay(true);
-    source->Delete();
-    return visobj;
-}
 
 /**
   * @brief set faces visibility.
@@ -336,10 +335,9 @@ vtkVISUnShadeMesh* VtkVisGeometry::createVisDisplayObj(vtkUnstructuredGrid *unMe
   */
 void VtkVisGeometry::SetFacesVisible(bool visible)
 {
-    for (auto it = vismeshFaceMap_.begin(); it != vismeshFaceMap_.end(); ++it)
+    for (auto it : faceActorsVec_)
     {
-        if (visible)  it->first->ShowOn();
-        else          it->first->ShowOff();
+        it->SetVisibility(visible);
     }
 }
 
@@ -355,10 +353,9 @@ void VtkVisGeometry::SetFacesVisible(bool visible)
   */
 void VtkVisGeometry::SetEdgesVisible(bool visible)
 {
-    if (edgeVisMesh_)
+    if (edgesActor_)
     {
-        if (visible)  edgeVisMesh_->ShowOn();
-        else          edgeVisMesh_->ShowOff();
+        edgesActor_->SetVisibility(visible);
     }
 }
 
@@ -374,10 +371,9 @@ void VtkVisGeometry::SetEdgesVisible(bool visible)
   */
 void VtkVisGeometry::SetVerticesVisible(bool visible)
 {
-    if (vertexVisMesh_)
+    if (verticesActor_)
     {
-        if (visible)  vertexVisMesh_->ShowOn();
-        else          vertexVisMesh_->ShowOff();
+        verticesActor_->SetVisibility(visible);
     }
 }
 
@@ -447,25 +443,4 @@ void VtkVisGeometry::SetSelectionModeToEntity()
 
 
 
-/**
-  * @brief give a brief description here.
-  *
-  * @param[in] the vis shademesh object.
-  * @param[out] actors vector.
-  * @param[out] actor-mesh map.
-  * @return 
-  * @author: shiting
-  * @date: 20230911
-  * @reviser: 
-  * @date: 
-  */
-void VtkVisGeometry::saveSelInfo(vtkVISUnShadeMesh *inputMesh, vector<vtkProp*> &actorVec)
-{
-    if (inputMesh)
-    {
-        vtkProp *actor {inputMesh->GetActor()};
-        actorVec.push_back(actor);
-    }
-}
-
 

CAE_Solution/src/component/VisGeometry/VisGeometry_VTK.h

@@ -5,9 +5,9 @@
 using namespace std;
 #include <vtkColor.h>
 #include <lists.hxx>
+#include <vtkSmartPointer.h>
+#include <vtkCompositePolyDataMapper2.h>
 
-
-class vtkVISUnShadeMesh;
 class vtkUnstructuredGrid;
 //class InteractorStyle_GeomMousePick;
 class vtkProp;
@@ -33,16 +33,15 @@ public:
     void SetSelectionModeToFace();
     void SetSelectionModeToEntity();
 
-
 private:
     void vtkInitPick();
     void createFacesDisplay(const ENTITY_LIST &faceEnts);
     void createEdgesDisplay(const ENTITY_LIST &edgeEnts);
     void createVerticesDisplay(const ENTITY_LIST &vertexEnts);
-    vtkVISUnShadeMesh* createVisDisplayObj(vtkUnstructuredGrid *unMesh);
+
 
     //void refineSelect(InteractorStyle_GeomMousePick *pickStyle);
-    void saveSelInfo(vtkVISUnShadeMesh *inputMesh, vector<vtkProp*> &actorVec);
+
 
 private:
     vector<vtkColor3f>  COLORS_;
@@ -50,16 +49,19 @@ private:
     ENTITY_LIST         allGeoEnts_;   //all displayed entities.
 
     //face entity.
-    unordered_map<vtkVISUnShadeMesh*, ENTITY*>  vismeshFaceMap_;
+    vector<vtkSmartPointer<vtkActor>> faceActorsVec_;
+    unordered_map<vtkProp*, ENTITY*>   actorFaceMap_;
     //edge entity.
-    vtkVISUnShadeMesh   *edgeVisMesh_;  //all edges in one mesh.
-    unordered_map<int, ENTITY*>  vismeshcellEdgeMap_;
+    vtkSmartPointer<vtkActor> edgesActor_ {nullptr};
+    vtkSmartPointer<vtkCompositePolyDataMapper2> edgesMapper_ {nullptr};
+    unordered_map<int, ENTITY*>  meshidEdgeMap_;
     //vertex entity.
-    vtkVISUnShadeMesh   *vertexVisMesh_;  //all vertices in one mesh.
-    unordered_map<int, ENTITY*>  vismeshcellVertexMap_;
+    vtkSmartPointer<vtkActor> verticesActor_ {nullptr};
+    unordered_map<int, ENTITY*>  meshcellidVertexMap_;
 
     //data maps
     unordered_map<ENTITY*, vtkProp*>  geoActorMap_;
+    unordered_map<ENTITY*, int>  geoMeshIdMap_;
     //using GeomType = InteractorStyle_GeomMousePick::GeomType;
     //unordered_map<vtkProp*, GeomType>  actorGeotypeMap_;
     unordered_map<vtkProp*, vtkUnstructuredGrid*>  actorDatasetMap_;
@@ -74,6 +76,9 @@ private:
         EntitySelection
     };
     SelectionMode  curSelMode_ {SelectionMode::FaceSelection};
+    //group property
+    unordered_map<string, vtkColor3f>  groupColorMap_;
+    unordered_map<string, bool>  groupVisibilityMap_;
 };
 
 

CAE_Solution/src/component/manager/geometrymanager.cpp

@@ -76,7 +76,7 @@ void GeometryManager::clear()
     hasVerticesVtkVis_ = false;
     qvtkRenderer_ = 0;
 
-    meshParamMgr_.Clear();
+    customMeshParamMgr_.Clear();
 }
 
 /**
@@ -89,7 +89,7 @@ void GeometryManager::clear()
   */
 bool GeometryManager::LoadData(const QString &datafile)
 {
-    //this->clear();  //clear the old mesh.
+    this->clear();  //clear the old mesh.
     bool loadstate = false;
     //read file
     loadstate = this->giExporter->LoadGeometryFile(datafile.toStdString());
@@ -426,19 +426,31 @@ void GeometryManager::EnterFaceSelection()
 }
 
 /**
-  * @brief update part setting by part name.
+  * @brief create/update part setting by part name.
   *
   * @param[in] the current partname, new or old one.
-  * @return part setting updated or not.
+  * @return create a new part or not.
   * @author: shiting
   * @date: 20230210
   * @reviser:
   * @date:
   */
-bool GeometryManager::UpdatePartSetting(const QString &partname)
+bool GeometryManager::CreatePart(const QString &partname)
 {
-    if (partname.isEmpty())  return false;
-    if (!vtkVisGeoEnts_)  return false;
+//    if (partname.isEmpty())  return false;
+//    if (!vtkVisGeoEnts_)  return false;
+//    //ENTITY_LIST selEnts(vtkVisGeoEnts_->GetSelectedEntities());
+//    //filter vertices.
+//    for (ENTITY *ent = selEnts.first(); ent != 0; ent = selEnts.next())
+//    {
+//        if (is_VERTEX(ent))  selEnts.remove(ent);
+//    }
+//    if (selEnts.iteration_count() == 0)  return false;
+//    bool isNewPart {!partMgr_.DoesPartExist(partname)};
+//    partMgr_.SetPartEnts(partname, selEnts);
+//    vtkVisGeoEnts_->UpdateGroup(partname.toStdString(), selEnts);
+//    qvtkRenderer_->Update();
+//    return isNewPart;
     return true;
 }
 
@@ -454,6 +466,11 @@ bool GeometryManager::UpdatePartSetting(const QString &partname)
   */
 void GeometryManager::SetPartVisible(const QString &partname, bool visible)
 {
+    if (!vtkVisGeoEnts_)  return;
+    //ENTITY_LIST ents {partMgr_.GetPartEntities(partname)};
+    //ents may be empty.
+    //vtkVisGeoEnts_->SetGroupEntitiesVisible(partname.toStdString(), ents, visible);
+    //if (ents.iteration_count() != 0)  qvtkRenderer_->Update();
 }
 
 /**
@@ -468,6 +485,170 @@ void GeometryManager::SetPartVisible(const QString &partname, bool visible)
   */
 void GeometryManager::ChangePartColor(const QString &partname, const QColor &color)
 {
+    if (!vtkVisGeoEnts_)  return;
+    //ENTITY_LIST ents {partMgr_.GetPartEntities(partname)};
+    //ents nay be empty.
+    double rgb[] {color.red()/255.0, color.green()/255.0, color.blue()/255.0};
+    //vtkVisGeoEnts_->SetGroupEntitiesColor(partname.toStdString(), ents, rgb);
+    //if (ents.iteration_count() != 0)  qvtkRenderer_->Update();
+}
+
+void GeometryManager::DeletePart(const QString &partname)
+{
+//    if (!vtkVisGeoEnts_)  return;
+//    ENTITY_LIST ents {partMgr_.GetPartEntities(partname)};
+//    if (ents.iteration_count() != 0)
+//    {
+//        partMgr_.DeletePart(partname);
+//        //part may be invisible, show on it.
+//        vtkVisGeoEnts_->SetGroupEntitiesVisible(partname.toStdString(), ents, true);
+//        qvtkRenderer_->Update();
+//    }
+//    vtkVisGeoEnts_->DeleteGroup(partname.toStdString(), ents);
+}
+
+void GeometryManager::SavePartParams(const QString &partname, const QStringList &paramList)
+{
+    //partMgr_.SetPartParams(partname, paramList);
+}
+
+bool GeometryManager::RenamePart(const QString &oldPartname, const QString &newPartname)
+{
+//    if (!vtkVisGeoEnts_)  return false;
+//    bool res {partMgr_.RenamePart(oldPartname, newPartname)};
+//    if (!res)  return false;
+//    vtkVisGeoEnts_->RenameGroup(oldPartname.toStdString(), newPartname.toStdString());
+    return true;
+}
+
+bool GeometryManager::CreateMeshParamsAtSelectedFaces(const QString &nameid, const QStringList &paramList)
+{
+    if (paramList.size() < 6)  return false;
+    ENTITY_LIST ents = getSelectedFaces();
+    if (ents.iteration_count() == 0)  return false;
+    customMeshParamMgr_.InitCustomMeshParamsOfFaces(nameid, ents, paramList);
+    return true;
+}
+
+void GeometryManager::ModifyMeshParamsAtFaces(const QString &nameid, const QStringList &paramList)
+{
+    if (paramList.size() < 6)  return;
+    customMeshParamMgr_.UpdateCustomMeshParamsOfFaces(nameid, paramList);
+}
+
+bool GeometryManager::CreateMeshParamsAtSelectedEdges(const QString &nameid, const QStringList &paramList)
+{
+    if (paramList.size() < 13)  return false;
+    ENTITY_LIST ents = getSelectedEdges();
+    if (ents.iteration_count() == 0)  return false;
+    customMeshParamMgr_.InitCustomMeshParamsOfEdges(nameid, ents, paramList);
+    return true;
+}
+
+void GeometryManager::ModifyMeshParamsAtEdges(const QString &nameid, const QStringList &paramList)
+{
+    if (paramList.size() < 13)  return;
+    customMeshParamMgr_.UpdateCustomMeshParamsOfEdges(nameid, paramList);
+}
+
+QString GeometryManager::GetFacesMeshParams()
+{
+    QStringList paramsList;
+    const char *name = "entity_index";
+
+//    ENTITY_LIST customEnts {customMeshParamMgr_.GetEntitiesSettedParams()};
+//    for (ENTITY *ent = customEnts.first(); ent; ent = customEnts.next())
+//    {
+//        if (is_FACE(ent))
+//        {
+//            QStringList entParams {customMeshParamMgr_.GetCustomParamsOfEntity(ent)};
+//            if (entParams.size() != 7)  continue;
+//            int id;
+//            api_get_entity_id(ent, id);
+//            paramsList << QString("%1,%2").arg(id).arg(entParams.at(0));
+//            //attach ent attrib for meshing.
+//            if (find_named_attrib(ent, name) == 0)
+//            {
+//                api_add_generic_named_attribute(ent, name, id);
+//            }
+//        }
+//    }
+
+//    ENTITY_LIST partEnts;
+//    QStringList partNames {partMgr_.GetPartNames()};
+//    auto size {partNames.size()};
+//    for (auto i {0}; i < size; ++i)
+//    {
+//        partEnts.add(partMgr_.GetPartEntities(partNames[i]));
+//    }
+//    for (ENTITY *ent = partEnts.first(); ent; ent = partEnts.next())
+//    {
+//        if (is_FACE(ent) && customEnts.lookup(ent) < 0)
+//        {
+//            QStringList entParams {partMgr_.GetParamsOfEntityWithinPart(ent)};
+//            if (entParams.size() != 9)  continue;
+//            int id;
+//            api_get_entity_id(ent, id);
+//            paramsList << QString("%1,%2").arg(id).arg(entParams.at(1));
+//            //attach ent attrib for meshing.
+//            if (find_named_attrib(ent, name) == 0)
+//            {
+//                api_add_generic_named_attribute(ent, name, id);
+//            }
+//        }
+//    }
+
+    return paramsList.join(';');
+}
+
+QString GeometryManager::GetEdgesMeshParams()
+{
+    QStringList paramsList;
+    const char *name = "entity_index";
+
+//    ENTITY_LIST customEnts {customMeshParamMgr_.GetEntitiesSettedParams()};
+//    for (ENTITY *ent = customEnts.first(); ent; ent = customEnts.next())
+//    {
+//        if (is_EDGE(ent))
+//        {
+//            QStringList entParams {customMeshParamMgr_.GetCustomParamsOfEntity(ent)};
+//            if (entParams.size() != 13)  continue;
+//            int id;
+//            api_get_entity_id(ent, id);
+//            paramsList << QString("%1,%2").arg(id).arg(entParams.at(0));
+//            //attach ent attrib for meshing.
+//            if (find_named_attrib(ent, name) == 0)
+//            {
+//                api_add_generic_named_attribute(ent, name, id);
+//            }
+//        }
+//    }
+
+//    ENTITY_LIST partEnts;
+//    QStringList partNames {partMgr_.GetPartNames()};
+//    auto size {partNames.size()};
+//    for (auto i {0}; i < size; ++i)
+//    {
+//        partEnts.add(partMgr_.GetPartEntities(partNames[i]));
+//    }
+//    for (ENTITY *ent = partEnts.first(); ent; ent = partEnts.next())
+//    {
+//        if (is_EDGE(ent) && customEnts.lookup(ent) < 0)
+//        {
+//            QStringList entParams {partMgr_.GetParamsOfEntityWithinPart(ent)};
+//            if (entParams.size() != 9)  continue;
+//            int id;
+//            api_get_entity_id(ent, id);
+//            paramsList << QString("%1,%2").arg(id).arg(entParams.at(1));
+//            //attach ent attrib for meshing.
+//            if (find_named_attrib(ent, name) == 0)
+//            {
+//                api_add_generic_named_attribute(ent, name, id);
+//            }
+//        }
+//    }
+
+    return paramsList.join(';');
 }
 
 /**
@@ -510,77 +691,6 @@ ENTITY_LIST GeometryManager::getSelectedEdges()
     return selEnts;
 }
 
-/**
-  * @brief save mesh params at current selected faces.
-  *
-  * @param[in] mesh generation params.
-  * @return
-  * @author: shiting
-  * @date: 20230317
-  * @reviser:
-  * @date:
-  */
-void GeometryManager::SaveMeshGenParamsAtSelectedFaces(const QStringList &paramList)
-{
-    MeshGenParams_AtFace params;
-    params.size_ = paramList.at(0);
-    ENTITY_LIST ents = getSelectedFaces();
-    for (ENTITY *ent = ents.first(); ent != 0; ent = ents.next())
-    {
-        meshParamMgr_.SetMeshGenParamsOfFace(ent, params);
-    }
-}
-
-/**
-  * @brief save mesh params at current selected edges.
-  *
-  * @param[in] mesh generation params.
-  * @return
-  * @author: shiting
-  * @date: 20230317
-  * @reviser:
-  * @date:
-  */
-void GeometryManager::SaveMeshGenParamsAtSelectedEdges(const QStringList &paramList)
-{
-    MeshGenParams_AtEdge params;
-    params.size_ = paramList.at(0);
-    ENTITY_LIST ents = getSelectedEdges();
-    for (ENTITY *ent = ents.first(); ent != 0; ent = ents.next())
-    {
-        meshParamMgr_.SetMeshGenParamsOfEdge(ent, params);
-    }
-}
-
-/**
-  * @brief get all faces' local mesh params.
-  *
-  * @param[in]
-  * @return the local mesh params of faces.
-  * @author: shiting
-  * @date: 20230317
-  * @reviser:
-  * @date:
-  */
-QString GeometryManager::GetLocalMeshGenParams_AtFaces()
-{
-    return meshParamMgr_.GetMeshGenParamsOfAllFace();
-}
-
-/**
-  * @brief get all edges' local mesh params.
-  *
-  * @param[in]
-  * @return the local mesh params of edges.
-  * @author: shiting
-  * @date: 20230317
-  * @reviser:
-  * @date:
-  */
-QString GeometryManager::GetLocalMeshGenParams_AtEdges()
-{
-    return meshParamMgr_.GetMeshGenParamsOfAllEdge();
-}
 
 /**
   * @brief save geometry to file.
@@ -595,7 +705,7 @@ QString GeometryManager::GetLocalMeshGenParams_AtEdges()
 bool GeometryManager::SaveGeometryFile(const QString &geofile)
 {
     if (bodyEntList_.iteration_count() == 0)  return false;
-    meshParamMgr_.AttachEntityAttrib();
+    //meshParamMgr_.AttachEntityAttrib();
     this->giExporter->ExportACISParts(bodyEntList_, geofile.toStdString());
     return true;
 }

CAE_Solution/src/component/manager/geometrymanager.h

@@ -8,7 +8,7 @@ using namespace std;
 #include <QColor>
 #include <lists.hxx>
 #include "../MeshGeneration/PartManager.h"
-#include "../MeshGeneration/MeshGenParams.h"
+#include "../MeshGeneration/custommeshparamsmanager.h".h"
 
 class QString;
 
@@ -45,15 +45,19 @@ public:
     void EnterFaceSelection();
 
     QStringList GetPartNames();
-    bool UpdatePartSetting(const QString &partname);
+    bool CreatePart(const QString &partname);
     void SetPartVisible(const QString &partname, bool visible);
     void ChangePartColor(const QString &partname, const QColor &color);
-
-    void SaveMeshGenParamsAtSelectedFaces(const QStringList &paramList);
-    void SaveMeshGenParamsAtSelectedEdges(const QStringList &paramList);
-    QString GetLocalMeshGenParams_AtFaces();
-    QString GetLocalMeshGenParams_AtEdges();
-
+    void DeletePart(const QString &partname);
+    void SavePartParams(const QString &partname, const QStringList &paramList);
+    bool RenamePart(const QString &oldPartname, const QString &newPartname);
+
+    bool CreateMeshParamsAtSelectedFaces(const QString &nameid, const QStringList &paramList);
+    void ModifyMeshParamsAtFaces(const QString &nameid, const QStringList &paramList);
+    bool CreateMeshParamsAtSelectedEdges(const QString &nameid, const QStringList &paramList);
+    void ModifyMeshParamsAtEdges(const QString &nameid, const QStringList &paramList);
+    QString GetFacesMeshParams();
+    QString GetEdgesMeshParams();
     //save data
     bool SaveGeometryFile(const QString &geofile);
 private:
@@ -82,11 +86,12 @@ private:
     bool           hasFacesVtkVis_;
     bool           hasEdgesVtkVis_;
     bool           hasVerticesVtkVis_;
+    PickMode       geoPickMode_;
 
     //part manager
     PartManager  partMgr_;
     //geometry ent's mesh params
-    MeshGenParamManager  meshParamMgr_;
+    CustomMeshParamsManager  customMeshParamMgr_;
     GeometryImExporter *giExporter;
 };