几何渲染

CAE_Solution/conf/conf_recv.txt

@@ -1,4 +1,4 @@
-host:192.168.0.43
+host:192.168.0.131
 port:5672
 userName:admin
 password:admin

CAE_Solution/conf/conf_send.txt

@@ -1,4 +1,4 @@
-host:192.168.0.43
+host:192.168.0.131
 port:5672
 userName:admin
 password:admin

CAE_Solution/src/VTK/Manager/Manager.pri

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

CAE_Solution/src/VTK/QVTKRenderer/qvtkrenderer.cpp

@@ -86,7 +86,7 @@ void QVTKRenderer::init()
     omWidget->SetEnabled(1);
     omWidget->InteractiveOn();
 
-    widgetFlag = WidgetModel::NoModel;
+    //widgetFlag = WidgetModel::NoModel;
 }
 
 /*

CAE_Solution/src/VTK/QVTKRenderer/qvtkrenderer.h

@@ -100,14 +100,14 @@ private:
 
 public:
     QString img;//保存图片内容
-    enum class WidgetModel//用以判断屏幕中加载的是什么模型
-    {
-        NoModel = 0,
-        UgridModel,
-        ResultModel,
-        VTKModel
-    };
-    WidgetModel widgetFlag;
+//    enum class WidgetModel//用以判断屏幕中加载的是什么模型
+//    {
+//        NoModel = 0,
+//        UgridModel,
+//        ResultModel,
+//        VTKModel
+//    };
+//    WidgetModel widgetFlag;
 };
 
 #endif // QVTKRENDERER_H

CAE_Solution/src/VTK/visualization_VTK/vtkvisunshademesh.cpp

@@ -275,3 +275,21 @@ void vtkVISUnShadeMesh::ModifiedCellDisplayColor(double r, double g, double b)
         ErrorInfo(1, "No Cell Actor!");
     }
 }
+
+/**
+  * @brief set points size.
+  *
+  * @param[in] the size to be setted.
+  * @return
+  * @author: shiting
+  * @date: 20230613
+  * @reviser:
+  * @date:
+  */
+void vtkVISUnShadeMesh::SetMeshPointSize(double size)
+{
+    if (_unActor != NULL)
+    {
+        (_unActor->GetProperty())->SetPointSize(size);
+    }
+}

CAE_Solution/src/VTK/visualization_VTK/vtkvisunshademesh.h

@@ -24,6 +24,7 @@ public:
     vtkActor* CreateCellIdDisplay(int id);
     void ModifiedCellDisplayColor(double r, double g, double b);
 
+    void SetMeshPointSize(double size);
 protected:
     double meshLineWidth_;
     bool shadeFlag_;

CAE_Solution/src/component/MeshGeneration/MeshGenParams.cpp

@@ -0,0 +1,210 @@
+#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

@@ -0,0 +1,77 @@
+#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

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

CAE_Solution/src/component/MeshGeneration/PartManager.cpp

@@ -0,0 +1,168 @@
+#include "PartManager.h"
+#include <qnamespace.h>
+
+
+/**
+  * @brief constructor
+  *
+  * @param[in] the group name.
+  * @return 
+  * @author: shiting
+  * @date: 20230207
+  * @reviser: 
+  * @date: 
+  */
+PartManager::PartManager() : defPart_("*defpart*")
+{
+}
+
+/**
+  * @brief destructor.
+  *
+  * @param[in] 
+  * @return 
+  * @author: shiting
+  * @date: 20230207
+  * @reviser: 
+  * @date: 
+  */
+PartManager::~PartManager()
+{
+}
+
+/**
+  * @brief reset part settings.
+  *
+  * @param[in] 
+  * @return 
+  * @author: shiting
+  * @date: 20230207
+  * @reviser: 
+  * @date: 
+  */
+void PartManager::clear()
+{
+    partNames_.clear();
+    partEntsMap_.clear();
+    entPartMap_.clear();
+}
+
+/**
+  * @brief init the default part setting, just after geometry import.
+  *
+  * @param[in] the geometry ents.
+  * @return 
+  * @author: shiting
+  * @date: 20230208
+  * @reviser: 
+  * @date: 
+  */
+void PartManager::InitDefaultPart(ENTITY_LIST &ents)
+{
+    this->clear();  //clear the old data.
+    partEntsMap_[defPart_] = ents;
+    ENTITY *ent;
+    ents.init();
+    while ((ent = ents.next()) != 0)
+    {
+        entPartMap_[ent] = defPart_;
+    }
+}
+
+/**
+  * @brief get part names.
+  *
+  * @param[in] 
+  * @return all part names.
+  * @author: shiting
+  * @date: 20221212
+  * @reviser: 
+  * @date: 
+  */
+QStringList PartManager::GetPartNames()
+{
+    return partNames_;
+}
+
+/**
+  * @brief set part and its entities. 
+  *
+  * if part already exists, update its entities. if part doesn't exist, create it.
+  * @param[in] the part name and entities to be appended.
+  * @return 
+  * @author: shiting
+  * @date: 20221212
+  * @reviser: 
+  * @date: 
+  */
+void PartManager::SetPartEnts(const QString &partname, const ENTITY_LIST &ents)
+{
+    if (partname.isEmpty() || ents.iteration_count() == 0)  return;
+    for (ENTITY *ent = ents.first(); ent != 0; ent = ents.next())
+    {
+        QString oripart(entPartMap_[ent]);
+        if (oripart == partname)  continue;
+        partEntsMap_[oripart].remove(ent);
+        if (partEntsMap_[oripart].iteration_count() == 0 && oripart != defPart_)
+        {
+            //when part doesn't have ent, delete it. but defpart.
+            partEntsMap_.erase(oripart);
+            partNames_.removeOne(oripart);
+        }
+        entPartMap_[ent] = partname;
+    }
+
+    //if (partNames_.contains(partname, Qt::CaseInsensitive))
+    if (partNames_.contains(partname))
+    {
+        partEntsMap_[partname].add(ents);  //entity list auto unique check.
+    }
+    else  //new part
+    {
+        partEntsMap_[partname] = ents;
+        partNames_.append(partname);
+    }
+}
+
+/**
+  * @brief delete a part by its name.
+  *
+  * @param[in] the partname to be deleted.
+  * @return 
+  * @author: shiting
+  * @date: 20230208
+  * @reviser: 
+  * @date: 
+  */
+void PartManager::DeletePart(const QString &partname)
+{
+    if (partEntsMap_.find(partname) != partEntsMap_.end())
+    {
+        ENTITY_LIST ents = partEntsMap_[partname];
+        partEntsMap_[defPart_].add(ents);
+        for (ENTITY *ent = ents.first(); ent != 0; ent = ents.next())
+        {
+            entPartMap_[ent] = defPart_;
+        }
+        partEntsMap_.erase(partname);
+        partNames_.removeOne(partname);
+    }
+}
+
+/**
+  * @brief check the part existence.
+  *
+  * @param[in] part name.
+  * @return exist or not.
+  * @author: shiting
+  * @date: 20230222
+  * @reviser: 
+  * @date: 
+  */
+bool PartManager::DoesPartExist(const QString &partname)
+{
+    return partNames_.contains(partname);
+}
+
+
+

CAE_Solution/src/component/MeshGeneration/PartManager.h

@@ -0,0 +1,33 @@
+#ifndef PartManager_H
+#define PartManager_H
+
+#include <map>
+using namespace std;
+#include <QStringList>
+#include <QColor>
+#include <lists.hxx>
+
+
+class PartManager
+{
+public:
+    PartManager();
+    ~PartManager();
+    void InitDefaultPart(ENTITY_LIST &ents);
+    QStringList GetPartNames();
+    void SetPartEnts(const QString &partname, const ENTITY_LIST &ents);
+    void DeletePart(const QString &partname);
+    bool DoesPartExist(const QString &partname);
+private:
+    void clear();
+
+private:
+    const QString  defPart_;
+    QStringList partNames_;
+    map<QString, ENTITY_LIST>  partEntsMap_;
+    map<ENTITY*, QString>      entPartMap_;
+};
+
+
+#endif
+

CAE_Solution/src/component/VisGeometry/FacetGeometry.cpp

@@ -0,0 +1,246 @@
+//acis headers
+#include <vector>
+using namespace std;
+#include <kernapi.hxx>
+#include <af_api.hxx>
+#include <acistype.hxx>
+#include <face.hxx>
+#include <edge.hxx>
+#include <vertex.hxx>
+#include <point.hxx>
+#include <getowner.hxx>
+#include <transf.hxx>
+
+#include <vtkPoints.h>
+#include <vtkUnstructuredGrid.h>
+#include <vtkTriangle.h>
+#include <vtkPolyLine.h>
+#include <vtkVertex.h>
+
+#include "FacetGeometry.h"
+
+
+/**
+  * @brief the constructor
+  *
+  * @param[in] 
+  * @return 
+  * @author: shiting
+  * @date: 20230804
+  * @reviser: 
+  * @date: 
+  */
+//GeometryFaceter::GeometryFaceter()
+//{
+//}
+
+/**
+  * @brief the destructor
+  *
+  * @param[in] 
+  * @return 
+  * @author: shiting
+  * @date: 20230804
+  * @reviser: 
+  * @date: 
+  */
+//GeometryFaceter::~GeometryFaceter()
+//{
+//}
+
+/**
+  * @brief facet the geometry.
+  *
+  * @param[in] facet geometry ents.
+  * @return true for facet successfully, false for ohter.
+  * @author: shiting
+  * @date: 20230804
+  * @reviser: 
+  * @date: 
+  */
+bool GeometryFaceter::FacetGeometry(const ENTITY_LIST &ents)
+{
+    if (ents.iteration_count() == 0)
+    {
+        return false;
+    }
+    for (ENTITY *ent = ents.first(); ent; ent = ents.next())
+    {
+        outcome out = api_facet_entity(ent);
+        if (!out.ok())  return false;
+    }
+    return true;
+}
+
+/**
+  * @brief get the entity's faceted mesh.
+  *
+  * @param[in] 
+  * @return the faceted mesh of geometry entity.
+  * @author: shiting
+  * @date: 20230807
+  * @reviser: 
+  * @date: 
+  */
+vtkUnstructuredGrid* GeometryFaceter::GetMeshOfFaceEntity(ENTITY *faceEnt)
+{
+    FACE *face = static_cast<FACE*>(faceEnt);
+    af_serializable_mesh *seriMesh = GetSerializableMesh(face);
+    if (seriMesh == 0)  return 0;
+    SPAtransf tr = get_owner_transf(face);
+
+    int np = seriMesh->number_of_vertices();
+    vector<float> xyzVec(np*3);
+    seriMesh->serialize_positions(xyzVec.data());
+    vtkPoints *points = vtkPoints::New();
+    points->SetNumberOfPoints(np);
+    for (int id = 0; id < np; ++id)
+    {
+        int j = id * 3;
+        SPAposition pos(xyzVec[j], xyzVec[j+1], xyzVec[j+2]);
+        pos *= tr;
+        points->SetPoint(id, pos.x(), pos.y(), pos.z());
+    }
+    xyzVec.clear();
+
+    int nPolygon = seriMesh->number_of_polygons();
+    vector<int> topoVec(nPolygon*3);  //facet to tri mesh.
+    int ne_actual = seriMesh->serialize_triangles(topoVec.data());
+    if (ne_actual < nPolygon)
+    {
+        nPolygon = ne_actual;
+        topoVec.resize(nPolygon*3);
+    }
+
+    vtkUnstructuredGrid *unMesh = vtkUnstructuredGrid::New();
+    unMesh->Allocate(nPolygon);
+    unMesh->SetPoints(points);
+    points->Delete();
+    vtkTriangle *cell = 0;
+    for (int id = 0; id < nPolygon; ++id)
+    {
+        int j = id * 3;
+        cell = vtkTriangle::New();
+        cell->GetPointIds()->SetId(0, topoVec[j]);
+        cell->GetPointIds()->SetId(1, topoVec[j+1]);
+        cell->GetPointIds()->SetId(2, topoVec[j+2]);
+        unMesh->InsertNextCell(cell->GetCellType(), cell->GetPointIds());
+        cell->Delete();
+    }
+    return unMesh;
+}
+
+/**
+  * @brief get edge entities mesh.
+  *
+  * @param[in] faceted edges.
+  * @return mesh of edges, and edgeMesh entities.
+  * @author: shiting
+  * @date: 20230804
+  * @reviser: 
+  * @date: 
+  */
+std::pair<vtkUnstructuredGrid*, ENTITY_LIST> GeometryFaceter::GetMeshOfEdgeEntities(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::pair<vtkUnstructuredGrid*, ENTITY_LIST>{0, resResultEnts};
+    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::pair<vtkUnstructuredGrid*, ENTITY_LIST>{unMesh, resResultEnts};
+}
+
+/**
+  * @brief get the mesh of vertex entities.
+  *
+  * @param[in] vertex ents.
+  * @return 
+  * @author: shiting
+  * @date: 20230804
+  * @reviser: 
+  * @date: 
+  */
+vtkUnstructuredGrid* GeometryFaceter::GetMeshOfVertexEntities(const ENTITY_LIST &vertexEnts)
+{
+    int np = vertexEnts.iteration_count();
+    if (np == 0)  return 0;
+    vtkPoints *points = vtkPoints::New();
+    points->SetNumberOfPoints(np);
+    int n = 0;
+    for (ENTITY *ent = vertexEnts.first(); ent; ent = vertexEnts.next())
+    {
+        VERTEX *vertex = static_cast<VERTEX*>(ent);
+        SPAposition pos(vertex->geometry()->coords());
+        SPAtransf tr = get_owner_transf(vertex);
+        pos *= tr;
+        points->SetPoint(n, pos.x(), pos.y(), pos.z());
+        ++n;
+    }
+
+    vtkUnstructuredGrid *unMesh = vtkUnstructuredGrid::New();
+    unMesh->Allocate(np);
+    unMesh->SetPoints(points);
+    points->Delete();
+    for (int id = 0; id < np; ++id)
+    {
+        vtkVertex *cell = vtkVertex::New();
+        cell->GetPointIds()->SetId(0, id);
+        unMesh->InsertNextCell(cell->GetCellType(), cell->GetPointIds());
+        cell->Delete();
+    }
+    return unMesh;
+}
+

CAE_Solution/src/component/VisGeometry/FacetGeometry.h

@@ -0,0 +1,24 @@
+#ifndef FACETGEOMETRY_H
+#define FACETGEOMETRY_H
+
+#include <utility>
+#include <lists.hxx>
+
+class vtkUnstructuredGrid;
+
+
+
+class GeometryFaceter
+{
+protected:
+    GeometryFaceter() = delete;
+
+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 vtkUnstructuredGrid* GetMeshOfVertexEntities(const ENTITY_LIST &vertexEnts);
+};
+
+#endif
+

CAE_Solution/src/component/VisGeometry/VisGeometry.pri

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

CAE_Solution/src/component/VisGeometry/VisGeometry_VTK.cpp

@@ -0,0 +1,471 @@
+#include <kernapi.hxx>
+#include <acistype.hxx>
+#include <vtkUnstructuredGrid.h>
+#include <vtkActor.h>
+#include "../../VTK/QVTKRenderer/qvtkrenderer.h"
+#include "FacetGeometry.h"
+#include "VisGeometry_VTK.h"
+#include "../../VTK/visualization_VTK/vtkVISUnstructuredGridSource.h"
+#include "../../VTK/visualization_VTK/vtkVISUnShadeMesh.h"
+
+
+
+/**
+  * @brief the constructor
+  *
+  * @param[in] 
+  * @return 
+  * @author: shiting
+  * @date: 20230807
+  * @reviser: 
+  * @date: 
+  */
+VtkVisGeometry::VtkVisGeometry(QVTKRenderer *qvtkRenderer)
+{
+    COLORS_.push_back(vtkColor3f(0.945098, 0.235294, 0.811765));
+    COLORS_.push_back(vtkColor3f(0.152941, 0.482353, 0.654902));
+    COLORS_.push_back(vtkColor3f(0.164706, 0.721569, 0.494118));
+    COLORS_.push_back(vtkColor3f(1.0, 0.560784, 0.239216));
+    COLORS_.push_back(vtkColor3f(0.913725, 0.839216, 0.419608));
+    COLORS_.push_back(vtkColor3f(0.0, 0.5, 0.5));
+    COLORS_.push_back(vtkColor3f(0.568627, 0.360784, 0.513725));
+    COLORS_.push_back(vtkColor3f(0.5, 0.5, 0.0));
+    COLORS_.push_back(vtkColor3f(0.0, 1.0, 1.0));
+    COLORS_.push_back(vtkColor3f(0.25, 0.423529, 1.0));
+    COLORS_.push_back(vtkColor3f(0.0, 0.37255, 0.0));
+    COLORS_.push_back(vtkColor3f(0.52941, 0.0, 0.0));
+    COLORS_.push_back(vtkColor3f(0.52941, 0.52941, 0.0));
+    COLORS_.push_back(vtkColor3f(0.52941, 0.52941, 1.0));
+    COLORS_.push_back(vtkColor3f(0.0, 0.52941, 1.0));
+    COLORS_.push_back(vtkColor3f(0.84314, 0.52941, 0.0));
+    COLORS_.push_back(vtkColor3f(0.84314, 0.0, 0.84314));
+    COLORS_.push_back(vtkColor3f(0.52941, 0.68627, 0.0));
+    COLORS_.push_back(vtkColor3f(0.37255, 0.37255, 0.52941));
+    COLORS_.push_back(vtkColor3f(0.52941, 0.0, 0.0));
+
+    renderer_ = 0;
+    edgeVisMesh_ = 0;
+    vertexVisMesh_ = 0;
+    SetRenderer(qvtkRenderer);
+}
+
+/**
+  * @brief the destructor
+  *
+  * @param[in] 
+  * @return 
+  * @author: shiting
+  * @date: 20230807
+  * @reviser: 
+  * @date: 
+  */
+VtkVisGeometry::~VtkVisGeometry()
+{
+    for (auto it = vismeshFaceMap_.begin(); it != vismeshFaceMap_.end(); ++it)
+    {
+        if (!renderer_)
+        {
+            it->first->SetRenderTo(nullptr);
+        }
+        it->first->Delete();
+    }
+    //vismeshFaceMap_.clear();
+
+    if (edgeVisMesh_)
+    {
+        if (!renderer_)
+        {
+            edgeVisMesh_->SetRenderTo(nullptr);
+        }
+        edgeVisMesh_->Delete();
+        edgeVisMesh_ = 0;
+    }
+    if (vertexVisMesh_)
+    {
+        if (!renderer_)
+        {
+            vertexVisMesh_->SetRenderTo(nullptr);
+        }
+        vertexVisMesh_->Delete();
+        vertexVisMesh_ = 0;
+    }
+
+    for (auto &item : actorDatasetMap_)
+    {
+        item.second->Delete();
+    }
+    //actorDatasetMap_.clear();
+
+}
+
+/**
+  * @brief set the renderer to display geometry.
+  *
+  * @param[in] the vtk renderer.
+  * @return 
+  * @author: shiting
+  * @date: 20230807
+  * @reviser: 
+  * @date: 
+  */
+void VtkVisGeometry::SetRenderer(QVTKRenderer *renderer)
+{
+    renderer_ = renderer;
+}
+
+/**
+  * @brief init geometry pick.
+  *
+  * @param[in] 
+  * @return 
+  * @author: shiting
+  * @date: 20230911
+  * @reviser: 
+  * @date: 
+  */
+void VtkVisGeometry::vtkInitPick()
+{
+    if (!renderer_)  return;
+}
+
+/**
+  * @brief display geometry entities.
+  *
+  * @param[in] the entities display.
+  * @return 
+  * @author: shiting
+  * @date: 20230814
+  * @reviser: 
+  * @date: 
+  */
+void VtkVisGeometry::CreateGeoDisplay(const ENTITY_LIST &geoEnts)
+{
+    //facet geometry entities.
+    ENTITY_LIST newEnts;
+    for (ENTITY *ent = geoEnts.first(); ent; ent = geoEnts.next())
+    {
+        if (allGeoEnts_.lookup(ent) < 0)
+        {
+            allGeoEnts_.add(ent);
+            newEnts.add(ent);
+        }
+    }
+    int nEntNew = newEnts.iteration_count();
+    if (nEntNew == 0)  return;
+    GeometryFaceter::FacetGeometry(newEnts);
+
+    //display geometry entities.
+    ENTITY_LIST faceEnts;
+    ENTITY_LIST edgeEnts;
+    ENTITY_LIST vertexEnts;
+    for (ENTITY *ent = newEnts.first(); ent; ent = newEnts.next())
+    {
+        if (is_BODY(ent))
+        {
+            ENTITY_LIST fents;
+            ENTITY_LIST eents;
+            ENTITY_LIST vents;
+            api_get_faces(ent, fents);
+            api_get_edges(ent, eents);
+            api_get_vertices(ent, vents);
+            faceEnts.add(fents);
+            edgeEnts.add(eents);
+            vertexEnts.add(vents);
+        }
+        else if (is_FACE(ent))
+        {
+            faceEnts.add(ent);
+        }
+        else if (is_EDGE(ent))
+        {
+            edgeEnts.add(ent);
+        }
+        else if (is_VERTEX(ent))
+        {
+            vertexEnts.add(ent);
+        }
+    }
+    createFacesDisplay(faceEnts);
+    createEdgesDisplay(edgeEnts);
+    createVerticesDisplay(vertexEnts);
+}
+
+/**
+  * @brief display the face entities.
+  *
+  * @param[in] face entities to display.
+  * @return 
+  * @author: shiting
+  * @date: 20230809
+  * @reviser: 
+  * @date: 
+  */
+void VtkVisGeometry::createFacesDisplay(const ENTITY_LIST &faceEnts)
+{
+    if (renderer_ == 0)  return;
+    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;
+        actorDatasetMap_[actor] = unMesh;
+    }
+}
+
+/**
+  * @brief display the edge entities.
+  *
+  * @param[in] edge entities to display.
+  * @return 
+  * @author: shiting
+  * @date: 20230809
+  * @reviser: 
+  * @date: 
+  */
+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;
+    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()};
+    int id {0};
+    for (ENTITY *ent = resPair.second.first(); ent; ent = resPair.second.next())
+    {
+        geoActorMap_[ent] = actor;
+        vismeshcellEdgeMap_[id] = ent;
+        ++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;
+    //}
+}
+
+/**
+  * @brief display the vertex entities.
+  *
+  * @param[in] vertex entities to display.
+  * @return 
+  * @author: shiting
+  * @date: 20230809
+  * @reviser: 
+  * @date: 
+  */
+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()};
+    int id {0};
+    for (ENTITY *ent = vertexEnts.first(); ent; ent = vertexEnts.next())
+    {
+        geoActorMap_[ent] = actor;
+        vismeshcellVertexMap_[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.
+  *
+  * @param[in] true: visible, false: invisible.
+  * @return 
+  * @author: shiting
+  * @date: 20230814
+  * @reviser: 
+  * @date: 
+  */
+void VtkVisGeometry::SetFacesVisible(bool visible)
+{
+    for (auto it = vismeshFaceMap_.begin(); it != vismeshFaceMap_.end(); ++it)
+    {
+        if (visible)  it->first->ShowOn();
+        else          it->first->ShowOff();
+    }
+}
+
+/**
+  * @brief set edges visibility.
+  *
+  * @param[in] true: visible, false: invisible.
+  * @return 
+  * @author: shiting
+  * @date: 20230814
+  * @reviser: 
+  * @date: 
+  */
+void VtkVisGeometry::SetEdgesVisible(bool visible)
+{
+    if (edgeVisMesh_)
+    {
+        if (visible)  edgeVisMesh_->ShowOn();
+        else          edgeVisMesh_->ShowOff();
+    }
+}
+
+/**
+  * @brief set vertices visibility.
+  *
+  * @param[in] true: visible, false: invisible.
+  * @return 
+  * @author: shiting
+  * @date: 20230814
+  * @reviser: 
+  * @date: 
+  */
+void VtkVisGeometry::SetVerticesVisible(bool visible)
+{
+    if (vertexVisMesh_)
+    {
+        if (visible)  vertexVisMesh_->ShowOn();
+        else          vertexVisMesh_->ShowOff();
+    }
+}
+
+/**
+  * @brief set geometry selection mode to vertex.
+  *
+  * @param[in] 
+  * @return 
+  * @author: shiting
+  * @date: 20230911
+  * @reviser: 
+  * @date: 
+  */
+void VtkVisGeometry::SetSelectionModeToVertex()
+{
+    vtkInitPick();
+    curSelMode_ = SelectionMode::VertexSelection;
+}
+
+/**
+  * @brief set geometry selection mode to edge.
+  *
+  * @param[in] 
+  * @return 
+  * @author: shiting
+  * @date: 20230911
+  * @reviser: 
+  * @date: 
+  */
+void VtkVisGeometry::SetSelectionModeToEdge()
+{
+    vtkInitPick();
+    curSelMode_ = SelectionMode::EdgeSelection;
+}
+
+/**
+  * @brief set geometry selection mode to face.
+  *
+  * @param[in] 
+  * @return 
+  * @author: shiting
+  * @date: 20230911
+  * @reviser: 
+  * @date: 
+  */
+void VtkVisGeometry::SetSelectionModeToFace()
+{
+    vtkInitPick();
+    curSelMode_ = SelectionMode::FaceSelection;
+}
+
+/**
+  * @brief set geometry selection mode to entity.
+  *
+  * @param[in] 
+  * @return 
+  * @author: shiting
+  * @date: 20230911
+  * @reviser: 
+  * @date: 
+  */
+void VtkVisGeometry::SetSelectionModeToEntity()
+{
+    curSelMode_ = SelectionMode::EntitySelection;
+}
+
+
+
+
+/**
+  * @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

@@ -0,0 +1,81 @@
+#ifndef VISGEOMETRY_VTK_H
+#define VISGEOMETRY_VTK_H
+#include <unordered_map>
+#include <vector>
+using namespace std;
+#include <vtkColor.h>
+#include <lists.hxx>
+
+
+class vtkVISUnShadeMesh;
+class vtkUnstructuredGrid;
+//class InteractorStyle_GeomMousePick;
+class vtkProp;
+
+
+class QVTKRenderer;
+class GeometryFaceter;
+
+class  VtkVisGeometry
+{
+public:
+    VtkVisGeometry(QVTKRenderer *qvtkRenderer);
+    virtual ~VtkVisGeometry();
+    void SetRenderer(QVTKRenderer *renderer);
+    void CreateGeoDisplay(const ENTITY_LIST &geoEnts);
+    void SetFacesVisible(bool visible);
+    void SetEdgesVisible(bool visible);
+    void SetVerticesVisible(bool visible);
+
+    //selection mode.
+    void SetSelectionModeToVertex();
+    void SetSelectionModeToEdge();
+    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_;
+    QVTKRenderer        *renderer_;
+    ENTITY_LIST         allGeoEnts_;   //all displayed entities.
+
+    //face entity.
+    unordered_map<vtkVISUnShadeMesh*, ENTITY*>  vismeshFaceMap_;
+    //edge entity.
+    vtkVISUnShadeMesh   *edgeVisMesh_;  //all edges in one mesh.
+    unordered_map<int, ENTITY*>  vismeshcellEdgeMap_;
+    //vertex entity.
+    vtkVISUnShadeMesh   *vertexVisMesh_;  //all vertices in one mesh.
+    unordered_map<int, ENTITY*>  vismeshcellVertexMap_;
+
+    //data maps
+    unordered_map<ENTITY*, vtkProp*>  geoActorMap_;
+    //using GeomType = InteractorStyle_GeomMousePick::GeomType;
+    //unordered_map<vtkProp*, GeomType>  actorGeotypeMap_;
+    unordered_map<vtkProp*, vtkUnstructuredGrid*>  actorDatasetMap_;
+
+    //select
+    //InteractorStyle_GeomMousePick  *geoPickStyle_;
+    enum class SelectionMode
+    {
+        VertexSelection,
+        EdgeSelection,
+        FaceSelection,
+        EntitySelection
+    };
+    SelectionMode  curSelMode_ {SelectionMode::FaceSelection};
+};
+
+
+#endif
+

CAE_Solution/src/component/component.pri

@@ -0,0 +1,4 @@
+include( $$PWD/manager/manager.pri)
+include( $$PWD/MeshGeneration/MeshGeneration.pri)
+#include( $$PWD/Visualization/Visualization.pri)
+include( $$PWD/VisGeometry/VisGeometry.pri)

CAE_Solution/src/component/manager/geometrymanager.cpp

@@ -0,0 +1,606 @@
+#include <QString>
+#include <acistype.hxx>
+#include <kernapi.hxx>
+#include "../../VTK/QVTKRenderer/qvtkrenderer.h"
+#include "../../acis/GeometryImExporter.h"
+//#include "../Visualization/VisGeometry.h"
+#include "../VisGeometry/VisGeometry_VTK.h"
+#include "GeometryManager.h"
+
+
+/**
+  * @brief the constructor.
+  *
+  * @param[in]
+  * @return
+  * @author shiting
+  * @date 20220729
+  */
+GeometryManager::GeometryManager()
+{
+    visGeoEnts_ = 0;
+
+    qvtkRenderer_ = 0;
+    vtkVisGeoEnts_ = 0;
+    hasFacesVtkVis_ = false;
+    hasEdgesVtkVis_ = false;
+    hasVerticesVtkVis_ = false;
+    this->giExporter = new GeometryImExporter();
+}
+
+/**
+  * @brief the destructor.
+  *
+  * @param[in]
+  * @return
+  * @author shiting
+  * @date 20220729
+  */
+GeometryManager::~GeometryManager()
+{
+    qvtkRenderer_ = nullptr;
+    this->clear();
+    if(giExporter){
+        delete giExporter;
+        giExporter = NULL;
+    }
+}
+
+/**
+  * @brief clear the mesh information.
+  *
+  * @param[in]
+  * @return
+  * @author shiting
+  * @date 20220802
+  */
+void GeometryManager::clear()
+{
+    bodyEntList_.clear();
+    vertexEntList_.clear();
+    edgeEntList_.clear();
+    faceEntList_.clear();
+    if (visGeoEnts_)
+    {
+        delete visGeoEnts_;
+        visGeoEnts_ = 0;
+    }
+
+    if (vtkVisGeoEnts_)
+    {
+        if (!qvtkRenderer_)
+        {
+            vtkVisGeoEnts_->SetRenderer(nullptr);
+        }
+        delete vtkVisGeoEnts_;
+        vtkVisGeoEnts_ = 0;
+    }
+    hasFacesVtkVis_ = false;
+    hasEdgesVtkVis_ = false;
+    hasVerticesVtkVis_ = false;
+    qvtkRenderer_ = 0;
+
+    meshParamMgr_.Clear();
+}
+
+/**
+  * @brief load mesh from file.
+  *
+  * @param[in] the mesh file path.
+  * @return loading mesh is successful or not.
+  * @author shiting
+  * @date 20220729
+  */
+bool GeometryManager::LoadData(const QString &datafile)
+{
+    this->clear();  //clear the old mesh.
+    bool loadstate = false;
+    //read file
+    loadstate = this->giExporter->LoadGeometryFile(datafile.toStdString());
+    if (loadstate == false)  return false;
+    bodyEntList_ = this->giExporter->GetBodies();
+    vertexEntList_ = this->giExporter->GetVertices();
+    edgeEntList_ = this->giExporter->GetEdges();
+    faceEntList_ = this->giExporter->GetFaces();
+
+    //build default part.
+    ENTITY_LIST ents;
+    ents.add(vertexEntList_);
+    ents.add(edgeEntList_);
+    ents.add(faceEntList_);
+    partMgr_.InitDefaultPart(ents);
+    return true;
+}
+
+/**
+  * @brief display geometry in renderer.
+  *
+  * @param[in] the renderer to draw geometry.
+  * @return
+  * @author shiting
+  * @date 20230522
+  */
+void GeometryManager::DisplayGeometry(QVTKRenderer *qvtkRenderer)
+{
+    if (qvtkRenderer == 0)  return;
+    qvtkRenderer_ = qvtkRenderer;
+    vtkVisGeoEnts_ = new VtkVisGeometry(qvtkRenderer);
+    setEdgesVisible_VTK(true);
+}
+
+/**
+  * @brief set bodies(sub endities) display.
+  *
+  * @param[in] true: visible, false: invisible.
+  * @return
+  * @author: shiting
+  * @date: 20230814
+  * @reviser:
+  * @date:
+  */
+void GeometryManager::setBodiesVisible_VTK(bool visible)
+{
+    if (vtkVisGeoEnts_ == 0)  return;
+    vtkVisGeoEnts_->CreateGeoDisplay(bodyEntList_);
+    hasFacesVtkVis_ = true;
+    hasEdgesVtkVis_ = true;
+    hasVerticesVtkVis_ = true;
+
+    vtkVisGeoEnts_->SetFacesVisible(visible);
+    vtkVisGeoEnts_->SetEdgesVisible(visible);
+    vtkVisGeoEnts_->SetVerticesVisible(visible);
+}
+
+/**
+  * @brief set face entities display.
+  *
+  * @param[in]  true: visible, false: invisible.
+  * @return
+  * @author: shiting
+  * @date: 20230814
+  * @reviser:
+  * @date:
+  */
+void GeometryManager::setFacesVisible_VTK(bool visible)
+{
+    if (vtkVisGeoEnts_ == 0)  return;
+    if (!hasFacesVtkVis_)
+    {
+        if (visible)
+        {
+            vtkVisGeoEnts_->CreateGeoDisplay(faceEntList_);
+            hasFacesVtkVis_ = true;
+        }
+    }
+    else
+    {
+        vtkVisGeoEnts_->SetFacesVisible(visible);
+    }
+}
+
+/**
+  * @brief set edge entities display.
+  *
+  * @param[in]  true: visible, false: invisible.
+  * @return
+  * @author: shiting
+  * @date: 20230814
+  * @reviser:
+  * @date:
+  */
+void GeometryManager::setEdgesVisible_VTK(bool visible)
+{
+    if (vtkVisGeoEnts_ == 0)  return;
+    if (!hasEdgesVtkVis_)
+    {
+        if (visible)
+        {
+            vtkVisGeoEnts_->CreateGeoDisplay(edgeEntList_);
+            hasEdgesVtkVis_ = true;
+        }
+    }
+    else
+    {
+        vtkVisGeoEnts_->SetEdgesVisible(visible);
+    }
+}
+
+/**
+  * @brief set vertex entities display.
+  *
+  * @param[in]  true: visible, false: invisible.
+  * @return
+  * @author: shiting
+  * @date: 20230814
+  * @reviser:
+  * @date:
+  */
+void GeometryManager::setVerticesVisible_VTK(bool visible)
+{
+    if (vtkVisGeoEnts_ == 0)  return;
+    if (!hasVerticesVtkVis_)
+    {
+        if (visible)
+        {
+            vtkVisGeoEnts_->CreateGeoDisplay(vertexEntList_);
+            hasVerticesVtkVis_ = true;
+        }
+    }
+    else
+    {
+        vtkVisGeoEnts_->SetVerticesVisible(visible);
+    }
+}
+
+/**
+  * @brief get geometry information: vertex number.
+  *
+  * @param[in]
+  * @return the vertex entity number.
+  * @author: shiting
+  * @date: 20221212
+  * @reviser:
+  * @date:
+  */
+int GeometryManager::GetVertexEntNumber()
+{
+    return vertexEntList_.iteration_count();
+}
+
+/**
+  * @brief get geometry information: edge number.
+  *
+  * @param[in]
+  * @return the edge entity number.
+  * @author: shiting
+  * @date: 20221212
+  * @reviser:
+  * @date:
+  */
+int GeometryManager::GetEdgeEntNumber()
+{
+    return edgeEntList_.iteration_count();
+}
+
+/**
+  * @brief get geometry information: face number.
+  *
+  * @param[in]
+  * @return the face entity number.
+  * @author: shiting
+  * @date: 20221212
+  * @reviser:
+  * @date:
+  */
+int GeometryManager::GetFaceEntNumber()
+{
+    return faceEntList_.iteration_count();
+}
+
+/**
+  * @brief get part names.
+  *
+  * @param[in]
+  * @return all part names.
+  * @author: shiting
+  * @date: 20221212
+  * @reviser:
+  * @date:
+  */
+QStringList GeometryManager::GetPartNames()
+{
+    return partMgr_.GetPartNames();
+}
+
+/**
+  * @brief set geometry-point visible or not.
+  *
+  * @param[in] point visible flag
+  * @return
+  * @author shiting
+  * @date 20230302
+  */
+void GeometryManager::SetVertexVisible(bool visible)
+{
+    if (qvtkRenderer_ == 0) return;
+    setVerticesVisible_VTK(visible);
+    qvtkRenderer_->Update();
+}
+
+/**
+  * @brief set geometry-curve visible or not.
+  *
+  * @param[in] curve visible flag
+  * @return
+  * @author shiting
+  * @date 20230302
+  */
+void GeometryManager::SetEdgeVisible(bool visible)
+{
+    if (qvtkRenderer_ == 0) return;
+    setEdgesVisible_VTK(visible);
+    qvtkRenderer_->Update();
+}
+
+/**
+  * @brief set geometry-surface visible or not.
+  *
+  * @param[in] surface visible flag
+  * @return
+  * @author shiting
+  * @date 20230302
+  */
+void GeometryManager::SetFaceVisible(bool visible)
+{
+    if (qvtkRenderer_ == 0) return;
+    setFacesVisible_VTK(visible);
+    qvtkRenderer_->Update();
+}
+
+/**
+  * @brief init vtk's pick.
+  *
+  * @param[in] pick mode.
+  * @return
+  * @author: shiting
+  * @date: 20230911
+  * @reviser:
+  * @date:
+  */
+void GeometryManager::vtkInitPick(PickMode pickMode)
+{
+    if (vtkVisGeoEnts_ == nullptr)  return;
+    if (pickMode == PickMode::VertexPick)
+    {
+        vtkVisGeoEnts_->SetSelectionModeToVertex();
+    }
+    else if (pickMode == PickMode::EdgePick)
+    {
+        vtkVisGeoEnts_->SetSelectionModeToEdge();
+    }
+    else if (pickMode == PickMode::FacePick)
+    {
+        vtkVisGeoEnts_->SetSelectionModeToFace();
+    }
+    else if (pickMode == PickMode::EntityPick)
+    {
+        vtkVisGeoEnts_->SetSelectionModeToEntity();
+    }
+    qvtkRenderer_->Update();
+}
+
+/**
+  * @brief set geometry selection to entity.
+  *
+  * @param[in]
+  * @return
+  * @author: shiting
+  * @date: 20230425
+  * @reviser:
+  * @date:
+  */
+void GeometryManager::EnterEntitySelection()
+{
+    vtkInitPick(PickMode::EntityPick);
+}
+
+/**
+  * @brief set geometry selection to vertex.
+  *
+  * @param[in]
+  * @return
+  * @author: shiting
+  * @date: 20230425
+  * @reviser:
+  * @date:
+  */
+void GeometryManager::EnterVertexSelection()
+{
+    vtkInitPick(PickMode::VertexPick);
+}
+
+/**
+  * @brief set geometry selection to edge.
+  *
+  * @param[in]
+  * @return
+  * @author: shiting
+  * @date: 20230425
+  * @reviser:
+  * @date:
+  */
+void GeometryManager::EnterEdgeSelection()
+{
+    vtkInitPick(PickMode::EdgePick);
+}
+
+/**
+  * @brief set geometry selection to face.
+  *
+  * @param[in]
+  * @return
+  * @author: shiting
+  * @date: 20230425
+  * @reviser:
+  * @date:
+  */
+void GeometryManager::EnterFaceSelection()
+{
+    vtkInitPick(PickMode::FacePick);
+}
+
+/**
+  * @brief update part setting by part name.
+  *
+  * @param[in] the current partname, new or old one.
+  * @return part setting updated or not.
+  * @author: shiting
+  * @date: 20230210
+  * @reviser:
+  * @date:
+  */
+bool GeometryManager::UpdatePartSetting(const QString &partname)
+{
+    if (partname.isEmpty())  return false;
+    if (!vtkVisGeoEnts_)  return false;
+    return true;
+}
+
+/**
+  * @brief show/hide part.
+  *
+  * @param[in] part name and show state.
+  * @return
+  * @author: shiting
+  * @date: 20230222
+  * @reviser:
+  * @date:
+  */
+void GeometryManager::SetPartVisible(const QString &partname, bool visible)
+{
+}
+
+/**
+  * @brief change part color.
+  *
+  * @param[in] part name and color.
+  * @return
+  * @author: shiting
+  * @date: 20230222
+  * @reviser:
+  * @date:
+  */
+void GeometryManager::ChangePartColor(const QString &partname, const QColor &color)
+{
+}
+
+/**
+  * @brief get the selected face entities.
+  *
+  * @param[in]
+  * @return the selected face ids.
+  * @author: shiting
+  * @date: 20230316
+  * @reviser:
+  * @date:
+  */
+ENTITY_LIST GeometryManager::getSelectedFaces()
+{
+    ENTITY_LIST selEnts;
+    for (ENTITY *ent = selEnts.first(); ent != 0; ent = selEnts.next())
+    {
+        if (!is_FACE(ent))  selEnts.remove(ent);
+    }
+    return selEnts;
+}
+
+/**
+  * @brief get the selected face entities.
+  *
+  * @param[in]
+  * @return the selected face ids.
+  * @author: shiting
+  * @date: 20230316
+  * @reviser:
+  * @date:
+  */
+ENTITY_LIST GeometryManager::getSelectedEdges()
+{
+    ENTITY_LIST selEnts;
+    for (ENTITY *ent = selEnts.first(); ent != 0; ent = selEnts.next())
+    {
+        if (!is_EDGE(ent))  selEnts.remove(ent);
+    }
+    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.
+  *
+  * @param[in] the geometry file path.
+  * @return save successfully or not.
+  * @author: shiting
+  * @date: 20230307
+  * @reviser:
+  * @date:
+  */
+bool GeometryManager::SaveGeometryFile(const QString &geofile)
+{
+    if (bodyEntList_.iteration_count() == 0)  return false;
+    meshParamMgr_.AttachEntityAttrib();
+    this->giExporter->ExportACISParts(bodyEntList_, geofile.toStdString());
+    return true;
+}
+

CAE_Solution/src/component/manager/geometrymanager.h

@@ -0,0 +1,94 @@
+#ifndef GEOMETRYMANAGER_H
+#define GEOMETRYMANAGER_H
+
+
+#include <vector>
+using namespace std;
+#include <QStringList>
+#include <QColor>
+#include <lists.hxx>
+#include "../MeshGeneration/PartManager.h"
+#include "../MeshGeneration/MeshGenParams.h"
+
+class QString;
+
+class IMainFrame;
+
+
+class VisGeometry;
+class QVTKRenderer;
+class VtkVisGeometry;
+class GeometryImExporter;
+
+
+class GeometryManager
+{
+public:
+    GeometryManager();
+    virtual ~GeometryManager();
+
+    bool LoadData(const QString &datafile);
+
+    //vtk vis functions.
+    void DisplayGeometry(QVTKRenderer *qvtkRenderer = 0);
+
+    int GetVertexEntNumber();
+    int GetEdgeEntNumber();
+    int GetFaceEntNumber();
+    void SetVertexVisible(bool visible);
+    void SetEdgeVisible(bool visible);
+    void SetFaceVisible(bool visible);
+
+    void EnterEntitySelection();
+    void EnterVertexSelection();
+    void EnterEdgeSelection();
+    void EnterFaceSelection();
+
+    QStringList GetPartNames();
+    bool UpdatePartSetting(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();
+
+    //save data
+    bool SaveGeometryFile(const QString &geofile);
+private:
+    void clear();
+    //vtk render funcs
+    void setBodiesVisible_VTK(bool visible);
+    void setFacesVisible_VTK(bool visible);
+    void setEdgesVisible_VTK(bool visible);
+    void setVerticesVisible_VTK(bool visible);
+    enum class PickMode {VertexPick, EdgePick, FacePick, EntityPick};
+    void vtkInitPick(PickMode pickMode);
+    ENTITY_LIST getSelectedFaces();
+    ENTITY_LIST getSelectedEdges();
+
+private:
+    ENTITY_LIST  bodyEntList_;
+    ENTITY_LIST  vertexEntList_;
+    ENTITY_LIST  edgeEntList_;
+    ENTITY_LIST  faceEntList_;
+    //hoops vis geos
+    VisGeometry  *visGeoEnts_;
+
+    //vtk vis geos
+    QVTKRenderer   *qvtkRenderer_;
+    VtkVisGeometry *vtkVisGeoEnts_;
+    bool           hasFacesVtkVis_;
+    bool           hasEdgesVtkVis_;
+    bool           hasVerticesVtkVis_;
+
+    //part manager
+    PartManager  partMgr_;
+    //geometry ent's mesh params
+    MeshGenParamManager  meshParamMgr_;
+    GeometryImExporter *giExporter;
+};
+
+
+#endif // GEOMETRYMANAGER_H

CAE_Solution/src/component/manager/manager.pri

@@ -0,0 +1,4 @@
+HEADERS += \
+        $$PWD/*.h
+SOURCES += \
+        $$PWD/*.cpp

CAE_Solution/src/main.cpp

@@ -23,6 +23,12 @@ VTK_MODULE_INIT(vtkRenderingFreeType)
 #include "threadPool_and_statemachine/dealWith/boostjsonobject.h"
 #include "VTK/Manager/ResultMeshManager.h"
 #include "Rabbitmq/sendLogMsg/logmsg.h"
+
+#include "./component/manager/geometrymanager.h"
+
+//#include "SPAIopAcisSystem.h"
+//#include "spatial_license.h"
+//extern void unlock_license();
 int main(int argc, char *argv[])
 {
 #if (QT_VERSION >= QT_VERSION_CHECK(5,6,0))
@@ -38,6 +44,13 @@ int main(int argc, char *argv[])
     QApplication a(argc, argv);
     Widget w;
 
+//    unlock_license();
+//    api_start_modeller(0);//启动ACIS,生成内部数据结构
+//    api_initialize_3dpm_bridge();
+
+//    SPAIopAcisSystem::Shutdown();
+//    SPAIopAcisSystem::Initialize(SPATIAL_LICENSE);
+
     w.resize(QApplication::desktop()->availableGeometry().size());//最大化
     w.move(0,0);
     w.show();
@@ -47,7 +60,6 @@ int main(int argc, char *argv[])
     QThread *thread_sendstate = new QThread();
 
     stateMachine* sendstate= new stateMachine("sendClient") ;
-//  emit LogMsg::getInstance()->send_to_sendClient("log");
     handlePool *handle = new handlePool(&w);
 
     recvstate->moveToThread(thread_recvsate);
@@ -58,6 +70,15 @@ int main(int argc, char *argv[])
 
     QObject::connect(handle,SIGNAL(sendImg_handlePoolToSendstate(std::string)),sendstate,SLOT(getImg_handlePoolToSendstate(std::string)));
     QObject::connect(recvstate,SIGNAL(sendmsg_recvstateTohandlePool(std::string)),handle,SLOT(getmsg_recvstateTohandlePool(std::string)));
+//    QVTKRenderer* render = new QVTKRenderer();
+//    render->init();
+//    w.addTab(render->GetWidget(),"test");
+//    GeometryManager *gm = new GeometryManager();
+//    bool f = gm->LoadData("F:\\czm\\qt_demo\\test_hoops\\tfg_part1_tec_volume_timestep100.plt");
+//    if(f){
+//        gm->DisplayGeometry(render);
+//        render->ZoomToExtents();
+//    }
 
     return a.exec();
 }

CAE_Solution/src/src.pro

@@ -40,6 +40,7 @@ include( ./Rabbitmq/Rabbitmq.pri)
 include( ./VTK/VTK.pri)
 include( ./threadPool_and_statemachine/threadPool_and_statemachine.pri)
 include(./acis/acis.pri)
+include(./component/component.pri)
 #########################################################################
 #自动拷贝配置文件
 conf_.files += $$PWD/../conf/*.txt

CAE_Solution/src/threadPool_and_statemachine/dealWith/boostjsonobject.cpp

@@ -16,6 +16,7 @@ boostJsonObject::boostJsonObject()
     sm_struct = NULL;
     ci_struct = NULL;
     da_struct = NULL;
+    rg_struct = NULL;
     usrId.clear();
     solverConfigid.clear();
     proId.clear();
@@ -69,6 +70,10 @@ boostJsonObject::~boostJsonObject()
         delete da_struct;
         da_struct = NULL;
     }
+    if(rg_struct){
+        delete rg_struct;
+        rg_struct = NULL;
+    }
 }
 
 /*
@@ -153,6 +158,7 @@ boostJsonObject *boostJsonObject::operator=(boostJsonObject *object)
     this->da_struct->hybridParam = object->da_struct->hybridParam;
     this->da_struct->surfParam = object->da_struct->surfParam;
     this->da_struct->tetraParam = object->da_struct->tetraParam;
+    this->rg_struct = object->rg_struct;
     return this;
 }
 
@@ -556,6 +562,9 @@ void boostJsonObject::FromParamJson(string param)
             throw myException("hybridParam miss some parameters!");
             da_struct->HybridParaml_ = false;
         }
+    }else if(this->action == "geometryFileShow"){
+        rg_struct = new render_geo_struct();
+        rg_struct->filename = root.get<std::string>("geometryFile");
     }
 }
 

CAE_Solution/src/threadPool_and_statemachine/dealWith/boostjsonobject.h

@@ -45,6 +45,7 @@ public:
     contourinimationw_struct* ci_struct;//contourinimation;
 
     DPM_ADIParam_struct* da_struct;
+    render_geo_struct* rg_struct;
 };
 
 #endif // BOOSTJSONOBJECT_H

CAE_Solution/src/threadPool_and_statemachine/dealWith/display_struct.h

@@ -239,5 +239,11 @@ public:                               //父类中为char*类型,把string转换
     virtual ~myException() throw(){}
 };
 
+class render_geo_struct{
+public:
+    render_geo_struct(){}
+    ~render_geo_struct(){}
+    string filename;
+};
 
 #endif // DISPLAY_STRUCT_H

CAE_Solution/src/threadPool_and_statemachine/dealWith/handlepool.cpp

@@ -10,6 +10,7 @@
 #include <vtkActor.h>
 #include "../../acis/cmdmainprocess.h"
 #include "../../manager_acis_modeller.h"
+#include "../../component/manager/geometrymanager.h"
 
 
 /*
@@ -219,6 +220,11 @@ void handlePool::operateRender(boostJsonObject* object,QVTKRenderer* render_)
             cout<<"read igs file fail!"<<endl;
         }
         return;
+    }else if(object->action == "render_igs"){
+        if(!result_displayIgs(object,render_)){
+            cout<<"display igs file fail!"<<endl;
+        }
+        return;
     }
     send_picture(object,render_);//发送图片
 }
@@ -238,26 +244,28 @@ void handlePool::judgeLoaddata(boostJsonObject *object, QVTKRenderer *render_)
         w->addTab(render_->GetWidget(),QString::fromStdString(object->proId));
     }else{
         render_ = qmapRender.value(object->proId);
-        auto flag = render_->widgetFlag;
-        if(flag == QVTKRenderer::WidgetModel::NoModel){
-        }else if(flag == QVTKRenderer::WidgetModel::UgridModel){//判断窗口当前模型
-            if(qmapManager.value(object->proId)->filePath == object->filePath){
-                send_picture(object,render_);
-                return;
-            }
-            render_->HideAllActors();
-            render_->RemoveAllActors();
-        }else if(flag == QVTKRenderer::WidgetModel::ResultModel){
-            render_->HideAllActors();
-            render_->RemoveAllActors();
-        }else if(flag == QVTKRenderer::WidgetModel::VTKModel){//判断窗口当前模型
-            if(qmapManager.value(object->proId)->filePath == object->filePath){
-                send_picture(object,render_);
-                return;
-            }
-            render_->HideAllActors();
-            render_->RemoveAllActors();
-        }
+//        auto flag = render_->widgetFlag;
+//        if(flag == QVTKRenderer::WidgetModel::NoModel){
+//        }else if(flag == QVTKRenderer::WidgetModel::UgridModel){//判断窗口当前模型
+//            if(qmapManager.value(object->proId)->filePath == object->filePath){
+//                send_picture(object,render_);
+//                return;
+//            }
+//            render_->HideAllActors();
+//            render_->RemoveAllActors();
+//        }else if(flag == QVTKRenderer::WidgetModel::ResultModel){
+//            render_->HideAllActors();
+//            render_->RemoveAllActors();
+//        }else if(flag == QVTKRenderer::WidgetModel::VTKModel){//判断窗口当前模型
+//            if(qmapManager.value(object->proId)->filePath == object->filePath){
+//                send_picture(object,render_);
+//                return;
+//            }
+//            render_->HideAllActors();
+//            render_->RemoveAllActors();
+//        }
+        render_->HideAllActors();
+        render_->RemoveAllActors();
     }
     QString m_filePath = QString::fromStdString(object->filePath);//测试路径
     QFileInfo fileinfo_(m_filePath);
@@ -277,7 +285,7 @@ void handlePool::judgeLoaddata(boostJsonObject *object, QVTKRenderer *render_)
             render_->ZoomToExtents();
         }
     }
-    qmapRender.value(object->proId)->widgetFlag = QVTKRenderer::WidgetModel::UgridModel;//设置widget中有模型
+//    qmapRender.value(object->proId)->widgetFlag = QVTKRenderer::WidgetModel::UgridModel;//设置widget中有模型
     if(!qmapManager.contains(object->proId)){//判断加载模型和当前模型是不是一样
         qmapManager.insert(object->proId,set_map_meshManager(object,meshmanager));
     }else{
@@ -333,24 +341,26 @@ bool handlePool::resultImport(boostJsonObject *object_, QVTKRenderer *renderer_)
         qmapRender.insert(object_->proId,renderer_);
         renderer_->init();
         w->addTab(renderer_->GetWidget(),QString::fromStdString(object_->proId));
-        renderer_->widgetFlag = QVTKRenderer::WidgetModel::NoModel;
+//        renderer_->widgetFlag = QVTKRenderer::WidgetModel::NoModel;
     }else{
         renderer_ = qmapRender[object_->proId];
-        auto flag_ = renderer_->widgetFlag;
-        if(flag_==QVTKRenderer::WidgetModel::UgridModel){
-            renderer_ = qmapRender.value(object_->proId);
-            renderer_->HideAllActors();
-            renderer_->RemoveAllActors();
-        }else if(flag_ ==QVTKRenderer::WidgetModel::ResultModel){
-            if(qmapResultmanager.value(object_->proId)->fileName == (object_->fileName)){
-                send_picture(object_,renderer_);
-                return true;
-            }
-        }else if(flag_==QVTKRenderer::WidgetModel::VTKModel){
-            renderer_ = qmapRender.value(object_->proId);
-            renderer_->HideAllActors();
-            renderer_->RemoveAllActors();
-        }
+//        auto flag_ = renderer_->widgetFlag;
+//        if(flag_==QVTKRenderer::WidgetModel::UgridModel){
+//            renderer_ = qmapRender.value(object_->proId);
+//            renderer_->HideAllActors();
+//            renderer_->RemoveAllActors();
+//        }else if(flag_ ==QVTKRenderer::WidgetModel::ResultModel){
+//            if(qmapResultmanager.value(object_->proId)->fileName == (object_->fileName)){
+//                send_picture(object_,renderer_);
+//                return true;
+//            }
+//        }else if(flag_==QVTKRenderer::WidgetModel::VTKModel){
+//            renderer_ = qmapRender.value(object_->proId);
+//            renderer_->HideAllActors();
+//            renderer_->RemoveAllActors();
+//        }
+        renderer_->HideAllActors();
+        renderer_->RemoveAllActors();
     }
     //object_->filePath = "F:\\czm\\vtkfile";
     //object_->filePath = "C:\\Users\\Administrator\\Desktop\\Postprocess_Binary";//测试路径
@@ -484,7 +494,7 @@ bool handlePool::resultImport(boostJsonObject *object_, QVTKRenderer *renderer_)
     StreamDisplayWidget* streamW = new StreamDisplayWidget();//流线窗口初始化参数
     rsManager->SetStremWidget(streamW);
     /********************************************/
-    renderer_->widgetFlag = QVTKRenderer::WidgetModel::ResultModel;//设置当前窗口模型状态
+//    renderer_->widgetFlag = QVTKRenderer::WidgetModel::ResultModel;//设置当前窗口模型状态
     if(qmapResultmanager.contains(object_->proId)){//加载不同的结果文件
         delete qmapResultmanager.value(object_->proId);
     }
@@ -724,34 +734,27 @@ bool handlePool::result_contourinimationdisplay(boostJsonObject *object_, QVTKRe
         qmapRender.insert(object_->proId,render_);
         render_->init();
         w->addTab(render_->GetWidget(),QString::fromStdString(object_->proId));
-        render_->widgetFlag = QVTKRenderer::WidgetModel::NoModel;
+        //render_->widgetFlag = QVTKRenderer::WidgetModel::NoModel;
     }else{
         render_ = qmapRender[object_->proId];
-        auto flag_ = render_->widgetFlag;
-        if(flag_==QVTKRenderer::WidgetModel::UgridModel){
-            render_ = qmapRender.value(object_->proId);
-            render_->HideAllActors();
-            render_->RemoveAllActors();
-        }else if(flag_ ==QVTKRenderer::WidgetModel::ResultModel){
-            render_ = qmapRender.value(object_->proId);
-            render_->HideAllActors();
-            render_->RemoveAllActors();
-        }else if(flag_==QVTKRenderer::WidgetModel::VTKModel){
-            render_ = qmapRender.value(object_->proId);
-            render_->HideAllActors();
-            render_->RemoveAllActors();
-        }
+//        auto flag_ = render_->widgetFlag;
+//        if(flag_==QVTKRenderer::WidgetModel::UgridModel){
+//            render_ = qmapRender.value(object_->proId);
+//            render_->HideAllActors();
+//            render_->RemoveAllActors();
+//        }else if(flag_ ==QVTKRenderer::WidgetModel::ResultModel){
+//            render_ = qmapRender.value(object_->proId);
+//            render_->HideAllActors();
+//            render_->RemoveAllActors();
+//        }else if(flag_==QVTKRenderer::WidgetModel::VTKModel){
+//            render_ = qmapRender.value(object_->proId);
+//            render_->HideAllActors();
+//            render_->RemoveAllActors();
+//        }
+        render_->HideAllActors();
+        render_->RemoveAllActors();
     }
 
-    //    object_->ci_struct->filenames.clear();测试
-    //    object_->ci_struct->filenames.resize(1);
-    //    object_->ci_struct->filenames[0] = "dynamicResponse-transient1.vtk";
-    //    object_->ci_struct->steps.clear();
-    //    object_->ci_struct->steps.resize(1);
-    //    object_->ci_struct->steps[0] = 1;
-    //    object_->filePath = "F:\\czm\\vtkfile";
-    //    object_->cd_struct->scalarName = "Displacement-magnitude";
-
     for(int i =0;i<object_->ci_struct->filenames.size();i++){
         animation_render(object_->ci_struct->filenames[i],object_->ci_struct->steps[i],render_,object_);
         if(i!=object_->ci_struct->filenames.size()-1){
@@ -777,11 +780,12 @@ bool handlePool::result_readIgsFile(boostJsonObject *object_, QVTKRenderer *rend
         qmapRender.insert(object_->proId,renderer_);
         renderer_->init();
         w->addTab(renderer_->GetWidget(),QString::fromStdString(object_->proId));
-        renderer_->widgetFlag = QVTKRenderer::WidgetModel::NoModel;
+        //renderer_->widgetFlag = QVTKRenderer::WidgetModel::NoModel;
     }else{
         renderer_ = qmapRender[object_->proId];
-        auto flag_ = renderer_->widgetFlag;
-        //to do
+        //auto flag_ = renderer_->widgetFlag;
+        renderer_->HideAllActors();
+        renderer_->RemoveAllActors();
     }
 
     //cmdMainProcess* cmdp = new cmdMainProcess();
@@ -804,6 +808,36 @@ bool handlePool::result_readIgsFile(boostJsonObject *object_, QVTKRenderer *rend
     }
 }
 
+/*
+ * @brief: load igs file and display it
+ * @param: [in]object [in]render
+ * @ret: bool
+ * @birth: created by czm in 202321009
+ */
+bool handlePool::result_displayIgs(boostJsonObject *object_, QVTKRenderer *render_)
+{
+    if(object_->rg_struct->filename.empty())return false;
+    if(!qmapRender.contains(object_->proId)){
+        render_ = new QVTKRenderer();
+        qmapRender.insert(object_->proId,render_);
+        render_->init();
+        w->addTab(render_->GetWidget(),QString::fromStdString(object_->proId));
+        //render_->widgetFlag = QVTKRenderer::WidgetModel::NoModel;
+    }else{
+        render_ = qmapRender[object_->proId];
+        //auto flag_ = render_->widgetFlag;
+        render_->HideAllActors();
+        render_->RemoveAllActors();
+    }
+    GeometryManager *gm = new GeometryManager();
+    bool f = gm->LoadData(QString::fromStdString(object_->rg_struct->filename));
+    if(f){
+        gm->DisplayGeometry(render_);
+        render_->ZoomToExtents();
+    }
+    return true;
+}
+
 
 /*
  * @brief: build result file mash which need to be sent to java
@@ -920,7 +954,7 @@ QMap<QString,string> handlePool::buildResultImport_msg(QString type,ResultManage
     }else if(type == "Solidsurface"){
         map_tmp.insert("r",to_string(cmanager->solidSurfaceW_->number_r));
         map_tmp.insert("g",to_string(cmanager->solidSurfaceW_->number_g));
-        map_tmp.insert("b",to_string(cmanager->solidSurfaceW_->number_b));;
+        map_tmp.insert("b",to_string(cmanager->solidSurfaceW_->number_b));
         map_tmp.insert("transparency",to_string(cmanager->solidSurfaceW_->GetTransparency()));
         if(cmanager->solidSurfaceW_->GetShowHideState()){
             map_tmp.insert("showHideState",QString("true").toStdString());
@@ -1276,7 +1310,7 @@ void handlePool::animation_render(string filename,int step,QVTKRenderer* rendere
     ResultManager* rsManager = NULL;
     set<string> zonename_set;
     if(type_ == "one_plt_ascii_file"||type_ == "one_plt_binary_file"){
-        renderer_->widgetFlag = QVTKRenderer::WidgetModel::ResultModel;
+        //renderer_->widgetFlag = QVTKRenderer::WidgetModel::ResultModel;
         bool flag = true;
         rsManager = new ResultMeshManager();
         rsManager->Clear();
@@ -1310,7 +1344,7 @@ void handlePool::animation_render(string filename,int step,QVTKRenderer* rendere
             renderer_->ZoomToExtents();
         }
     }else if(type_ == "vtkfile"){
-        renderer_->widgetFlag = QVTKRenderer::WidgetModel::VTKModel;
+        //renderer_->widgetFlag = QVTKRenderer::WidgetModel::VTKModel;
         rsManager = new ResultVTKManager();
         rsManager->Clear();
         rsManager->fileType = "VTK";

CAE_Solution/src/threadPool_and_statemachine/dealWith/handlepool.h

@@ -77,6 +77,7 @@ public:
     bool result_contourinimationdisplay(boostJsonObject*,QVTKRenderer*);
 
     bool result_readIgsFile(boostJsonObject*,QVTKRenderer*);
+    bool result_displayIgs(boostJsonObject*,QVTKRenderer*);
 
     QMap<QString,string> buildResultImport_msg(QString,ResultManager*);
     QMap<QString,string> buildResultImport_msg(QString,ResultManager*,boostJsonObject*);