|  | @@ -63,9 +63,9 @@ handlePool::~handlePool()
 | 
											
												
													
														|  |  void handlePool::getmsg_recvstateTohandlePool(std::string recvmsg)
 |  |  void handlePool::getmsg_recvstateTohandlePool(std::string recvmsg)
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  |      std::cout<<"recvmsg"<<recvmsg<<std::endl;
 |  |      std::cout<<"recvmsg"<<recvmsg<<std::endl;
 | 
											
												
													
														|  | -    vtkJsonObject* json_object = new vtkJsonObject();
 |  | 
 | 
											
												
													
														|  | 
 |  | +    boostJsonObject* json_object = new boostJsonObject();
 | 
											
												
													
														|  |      QVTKRenderer* render_=NULL;
 |  |      QVTKRenderer* render_=NULL;
 | 
											
												
													
														|  | -    json_object->FromJSON(recvmsg);
 |  | 
 | 
											
												
													
														|  | 
 |  | +    json_object->FromJson(recvmsg);
 | 
											
												
													
														|  |  
 |  |  
 | 
											
												
													
														|  |      operateRender(json_object,render_);//解析命令
 |  |      operateRender(json_object,render_);//解析命令
 | 
											
												
													
														|  |  
 |  |  
 | 
											
										
											
												
													
														|  | @@ -77,7 +77,7 @@ void handlePool::getmsg_recvstateTohandlePool(std::string recvmsg)
 | 
											
												
													
														|  |   * @ret:void
 |  |   * @ret:void
 | 
											
												
													
														|  |   * @birth: creadted by czm in 20230406
 |  |   * @birth: creadted by czm in 20230406
 | 
											
												
													
														|  |   */
 |  |   */
 | 
											
												
													
														|  | -void handlePool::operateRender(vtkJsonObject* object,QVTKRenderer* render_)
 |  | 
 | 
											
												
													
														|  | 
 |  | +void handlePool::operateRender(boostJsonObject* object,QVTKRenderer* render_)
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  |      if(object->action == "init"){
 |  |      if(object->action == "init"){
 | 
											
												
													
														|  |          delete object;
 |  |          delete object;
 | 
											
										
											
												
													
														|  | @@ -145,23 +145,43 @@ void handlePool::operateRender(vtkJsonObject* object,QVTKRenderer* render_)
 | 
											
												
													
														|  |              cout<<"please import tecplot result first!"<<endl;
 |  |              cout<<"please import tecplot result first!"<<endl;
 | 
											
												
													
														|  |          }
 |  |          }
 | 
											
												
													
														|  |          return;
 |  |          return;
 | 
											
												
													
														|  | 
 |  | +    }else if(object->action == "SliceDisplayAdd"){//切片添加窗口
 | 
											
												
													
														|  | 
 |  | +        if(!result_slicedisplay(object,render_,"addpage")){
 | 
											
												
													
														|  | 
 |  | +            cout<<"please import tecplot result first!"<<endl;
 | 
											
												
													
														|  | 
 |  | +        }
 | 
											
												
													
														|  | 
 |  | +        return;
 | 
											
												
													
														|  | 
 |  | +    }else if(object->action == "SliceDisplayUpdate"){//切片刷新
 | 
											
												
													
														|  | 
 |  | +        if(!result_slicedisplay(object,render_,"update")){
 | 
											
												
													
														|  | 
 |  | +            cout<<"please import tecplot result first!"<<endl;
 | 
											
												
													
														|  | 
 |  | +        }
 | 
											
												
													
														|  | 
 |  | +        return;
 | 
											
												
													
														|  | 
 |  | +    }else if(object->action == "SliceDisplayDel"){//切片删除
 | 
											
												
													
														|  | 
 |  | +        if(!result_slicedisplay(object,render_,"clear")){
 | 
											
												
													
														|  | 
 |  | +            cout<<"please import tecplot result first!"<<endl;
 | 
											
												
													
														|  | 
 |  | +        }
 | 
											
												
													
														|  | 
 |  | +        return;
 | 
											
												
													
														|  | 
 |  | +    }else if(object->action == "SliceDisplayApply"){//切片渲染
 | 
											
												
													
														|  | 
 |  | +        if(!result_slicedisplay(object,render_,"apply")){
 | 
											
												
													
														|  | 
 |  | +            cout<<"please import tecplot result first!"<<endl;
 | 
											
												
													
														|  | 
 |  | +        }
 | 
											
												
													
														|  | 
 |  | +        return;
 | 
											
												
													
														|  |      }
 |  |      }
 | 
											
												
													
														|  |      send_picture(object,render_);//发送图片
 |  |      send_picture(object,render_);//发送图片
 | 
											
												
													
														|  |  }
 |  |  }
 | 
											
												
													
														|  |  
 |  |  
 | 
											
												
													
														|  |  /*
 |  |  /*
 | 
											
												
													
														|  |   * @brief: deal with msg about loaddata
 |  |   * @brief: deal with msg about loaddata
 | 
											
												
													
														|  | - * @param: vtkJsonObject QVTKRenderer
 |  | 
 | 
											
												
													
														|  | 
 |  | + * @param: boostJsonObject QVTKRenderer
 | 
											
												
													
														|  |   * @ret: bool
 |  |   * @ret: bool
 | 
											
												
													
														|  |   * @birth: created by czm in 20230425
 |  |   * @birth: created by czm in 20230425
 | 
											
												
													
														|  |   */
 |  |   */
 | 
											
												
													
														|  | -void handlePool::judgeLoaddata(vtkJsonObject *object, QVTKRenderer *render_)
 |  | 
 | 
											
												
													
														|  | 
 |  | +void handlePool::judgeLoaddata(boostJsonObject *object, QVTKRenderer *render_)
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  |      if(!qmapRender.contains(object->proId)){//判断有无窗口
 |  |      if(!qmapRender.contains(object->proId)){//判断有无窗口
 | 
											
												
													
														|  |          render_ = new QVTKRenderer();
 |  |          render_ = new QVTKRenderer();
 | 
											
												
													
														|  |          qmapRender.insert(object->proId,render_);
 |  |          qmapRender.insert(object->proId,render_);
 | 
											
												
													
														|  |          render_->init();
 |  |          render_->init();
 | 
											
												
													
														|  | -        w->addTab(render_->GetWidget(),object->proId);
 |  | 
 | 
											
												
													
														|  | 
 |  | +        w->addTab(render_->GetWidget(),QString::fromStdString(object->proId));
 | 
											
												
													
														|  |      }else{
 |  |      }else{
 | 
											
												
													
														|  |          render_ = qmapRender.value(object->proId);
 |  |          render_ = qmapRender.value(object->proId);
 | 
											
												
													
														|  |          auto flag = render_->widgetFlag;
 |  |          auto flag = render_->widgetFlag;
 | 
											
										
											
												
													
														|  | @@ -178,8 +198,8 @@ void handlePool::judgeLoaddata(vtkJsonObject *object, QVTKRenderer *render_)
 | 
											
												
													
														|  |              render_->RemoveAllActors();
 |  |              render_->RemoveAllActors();
 | 
											
												
													
														|  |          }
 |  |          }
 | 
											
												
													
														|  |      }
 |  |      }
 | 
											
												
													
														|  | -    QString m_filePath = object->filePath;//测试路径
 |  | 
 | 
											
												
													
														|  | -    //QString m_filePath = "F:\\czm\\vtkfile\\tfg.ugrid";
 |  | 
 | 
											
												
													
														|  | 
 |  | +    //QString m_filePath = object->filePath;//测试路径
 | 
											
												
													
														|  | 
 |  | +    QString m_filePath = "F:\\czm\\vtkfile\\tfg.ugrid";
 | 
											
												
													
														|  |      QFileInfo fileinfo_(m_filePath);
 |  |      QFileInfo fileinfo_(m_filePath);
 | 
											
												
													
														|  |      if(!fileinfo_.isFile()){
 |  |      if(!fileinfo_.isFile()){
 | 
											
												
													
														|  |          cout<<"file path is Empty!"<<endl;
 |  |          cout<<"file path is Empty!"<<endl;
 | 
											
										
											
												
													
														|  | @@ -214,9 +234,13 @@ void handlePool::judgeLoaddata(vtkJsonObject *object, QVTKRenderer *render_)
 | 
											
												
													
														|  |   * @ret: void
 |  |   * @ret: void
 | 
											
												
													
														|  |   * @birth: created by czm in 20230420
 |  |   * @birth: created by czm in 20230420
 | 
											
												
													
														|  |   */
 |  |   */
 | 
											
												
													
														|  | -bool handlePool::resultImport(vtkJsonObject *object_, QVTKRenderer *renderer_)
 |  | 
 | 
											
												
													
														|  | 
 |  | +bool handlePool::resultImport(boostJsonObject *object_, QVTKRenderer *renderer_)
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  | -    QStringList fileName_list=object_->getFileName().split(",");
 |  | 
 | 
											
												
													
														|  | 
 |  | +    vector<string> tmp = stringSplit(object_->fileName,',');
 | 
											
												
													
														|  | 
 |  | +    QStringList fileName_list;
 | 
											
												
													
														|  | 
 |  | +    for(auto & x:tmp){
 | 
											
												
													
														|  | 
 |  | +        fileName_list.append(QString::fromStdString(x));
 | 
											
												
													
														|  | 
 |  | +    }
 | 
											
												
													
														|  |      if(fileName_list.isEmpty()){
 |  |      if(fileName_list.isEmpty()){
 | 
											
												
													
														|  |          cout<< "No Tecplot file is ready to read!"<<endl;
 |  |          cout<< "No Tecplot file is ready to read!"<<endl;
 | 
											
												
													
														|  |          return false;
 |  |          return false;
 | 
											
										
											
												
													
														|  | @@ -226,7 +250,7 @@ bool handlePool::resultImport(vtkJsonObject *object_, QVTKRenderer *renderer_)
 | 
											
												
													
														|  |          renderer_ = new QVTKRenderer();
 |  |          renderer_ = new QVTKRenderer();
 | 
											
												
													
														|  |          qmapRender.insert(object_->proId,renderer_);
 |  |          qmapRender.insert(object_->proId,renderer_);
 | 
											
												
													
														|  |          renderer_->init();
 |  |          renderer_->init();
 | 
											
												
													
														|  | -        w->addTab(renderer_->GetWidget(),object_->proId);
 |  | 
 | 
											
												
													
														|  | 
 |  | +        w->addTab(renderer_->GetWidget(),QString::fromStdString(object_->proId));
 | 
											
												
													
														|  |          renderer_->widgetFlag = QVTKRenderer::WidgetModel::NoModel;
 |  |          renderer_->widgetFlag = QVTKRenderer::WidgetModel::NoModel;
 | 
											
												
													
														|  |      }else{
 |  |      }else{
 | 
											
												
													
														|  |          renderer_ = qmapRender[object_->proId];
 |  |          renderer_ = qmapRender[object_->proId];
 | 
											
										
											
												
													
														|  | @@ -236,7 +260,7 @@ bool handlePool::resultImport(vtkJsonObject *object_, QVTKRenderer *renderer_)
 | 
											
												
													
														|  |              renderer_->HideAllActors();//to do 有bug 先导入结果,在loaddata,再导入,会报错
 |  |              renderer_->HideAllActors();//to do 有bug 先导入结果,在loaddata,再导入,会报错
 | 
											
												
													
														|  |              renderer_->RemoveAllActors();
 |  |              renderer_->RemoveAllActors();
 | 
											
												
													
														|  |          }else if(flag ==QVTKRenderer::WidgetModel::ResultModel){
 |  |          }else if(flag ==QVTKRenderer::WidgetModel::ResultModel){
 | 
											
												
													
														|  | -            if(qmapResultmanager.value(object_->proId)->fileName == object_->getFileName()){//to do 详细比对文件名
 |  | 
 | 
											
												
													
														|  | 
 |  | +            if(qmapResultmanager.value(object_->proId)->fileName == (object_->fileName)){//to do 详细比对文件名
 | 
											
												
													
														|  |                  send_picture(object_,renderer_);
 |  |                  send_picture(object_,renderer_);
 | 
											
												
													
														|  |                  return true;
 |  |                  return true;
 | 
											
												
													
														|  |              }
 |  |              }
 | 
											
										
											
												
													
														|  | @@ -245,8 +269,8 @@ bool handlePool::resultImport(vtkJsonObject *object_, QVTKRenderer *renderer_)
 | 
											
												
													
														|  |              //            renderer_->RemoveAllActors();
 |  |              //            renderer_->RemoveAllActors();
 | 
											
												
													
														|  |          }
 |  |          }
 | 
											
												
													
														|  |      }
 |  |      }
 | 
											
												
													
														|  | -    //object_->filePath = "C:\\Users\\Administrator\\Desktop\\Postprocess_Binary";//测试路径
 |  | 
 | 
											
												
													
														|  | -    QDir dir(object_->filePath);
 |  | 
 | 
											
												
													
														|  | 
 |  | +    object_->filePath = "C:\\Users\\Administrator\\Desktop\\Postprocess_Binary";//测试路径
 | 
											
												
													
														|  | 
 |  | +    QDir dir(QString::fromStdString(object_->filePath));
 | 
											
												
													
														|  |      if(!dir.exists()){
 |  |      if(!dir.exists()){
 | 
											
												
													
														|  |          return false;
 |  |          return false;
 | 
											
												
													
														|  |      }
 |  |      }
 | 
											
										
											
												
													
														|  | @@ -256,7 +280,7 @@ bool handlePool::resultImport(vtkJsonObject *object_, QVTKRenderer *renderer_)
 | 
											
												
													
														|  |      rsMeshManager->Clear();
 |  |      rsMeshManager->Clear();
 | 
											
												
													
														|  |      bool flag = true;
 |  |      bool flag = true;
 | 
											
												
													
														|  |      for(int i =0;i<fileName_list.size();i++){
 |  |      for(int i =0;i<fileName_list.size();i++){
 | 
											
												
													
														|  | -        bool f =rsMeshManager->LoadData(object_->filePath+"/"+fileName_list[i]);
 |  | 
 | 
											
												
													
														|  | 
 |  | +        bool f =rsMeshManager->LoadData(QString::fromStdString(object_->filePath)+"/"+fileName_list[i]);
 | 
											
												
													
														|  |          if(f){
 |  |          if(f){
 | 
											
												
													
														|  |              rsMeshManager->SetSaveIndex(i);
 |  |              rsMeshManager->SetSaveIndex(i);
 | 
											
												
													
														|  |              if(renderer_){
 |  |              if(renderer_){
 | 
											
										
											
												
													
														|  | @@ -276,7 +300,7 @@ bool handlePool::resultImport(vtkJsonObject *object_, QVTKRenderer *renderer_)
 | 
											
												
													
														|  |          rsMeshManager->InitWidgetsParameter();
 |  |          rsMeshManager->InitWidgetsParameter();
 | 
											
												
													
														|  |          renderer_->ZoomToExtents();
 |  |          renderer_->ZoomToExtents();
 | 
											
												
													
														|  |      }
 |  |      }
 | 
											
												
													
														|  | -/*********************************************/
 |  | 
 | 
											
												
													
														|  | 
 |  | +    /*********************************************/
 | 
											
												
													
														|  |      ContourDisplayW *contourdw = new ContourDisplayW();//云图窗口参数初始化
 |  |      ContourDisplayW *contourdw = new ContourDisplayW();//云图窗口参数初始化
 | 
											
												
													
														|  |      rsMeshManager->SetCotourWidget(contourdw);
 |  |      rsMeshManager->SetCotourWidget(contourdw);
 | 
											
												
													
														|  |      rsMeshManager->SetWidgetRange();
 |  |      rsMeshManager->SetWidgetRange();
 | 
											
										
											
												
													
														|  | @@ -288,9 +312,13 @@ bool handlePool::resultImport(vtkJsonObject *object_, QVTKRenderer *renderer_)
 | 
											
												
													
														|  |      VectorW *vecdW = new VectorW();//矢量窗口初始化参数
 |  |      VectorW *vecdW = new VectorW();//矢量窗口初始化参数
 | 
											
												
													
														|  |      rsMeshManager->SetVectorWidget(vecdW);
 |  |      rsMeshManager->SetVectorWidget(vecdW);
 | 
											
												
													
														|  |  
 |  |  
 | 
											
												
													
														|  | 
 |  | +
 | 
											
												
													
														|  |      SolidSurfaceWidget* solidfW = new SolidSurfaceWidget();//实体表面窗口初始化参数
 |  |      SolidSurfaceWidget* solidfW = new SolidSurfaceWidget();//实体表面窗口初始化参数
 | 
											
												
													
														|  |      rsMeshManager->SetSurfaceSolidWidget(solidfW);
 |  |      rsMeshManager->SetSurfaceSolidWidget(solidfW);
 | 
											
												
													
														|  | -/********************************************/
 |  | 
 | 
											
												
													
														|  | 
 |  | +
 | 
											
												
													
														|  | 
 |  | +    //SsliceWidget * ssliceW = new SsliceWidget();
 | 
											
												
													
														|  | 
 |  | +    //rsMeshManager->SetSliceWidget(ssliceW);
 | 
											
												
													
														|  | 
 |  | +    /********************************************/
 | 
											
												
													
														|  |      renderer_->widgetFlag = QVTKRenderer::WidgetModel::ResultModel;//设置当前窗口模型状态
 |  |      renderer_->widgetFlag = QVTKRenderer::WidgetModel::ResultModel;//设置当前窗口模型状态
 | 
											
												
													
														|  |      if(qmapResultmanager.contains(object_->proId)){//加载不同的结果文件
 |  |      if(qmapResultmanager.contains(object_->proId)){//加载不同的结果文件
 | 
											
												
													
														|  |          delete qmapResultmanager.value(object_->proId);
 |  |          delete qmapResultmanager.value(object_->proId);
 | 
											
										
											
												
													
														|  | @@ -313,7 +341,7 @@ bool handlePool::resultImport(vtkJsonObject *object_, QVTKRenderer *renderer_)
 | 
											
												
													
														|  |   * @ret: bool
 |  |   * @ret: bool
 | 
											
												
													
														|  |   * @birth: created by czm in 20230421
 |  |   * @birth: created by czm in 20230421
 | 
											
												
													
														|  |   */
 |  |   */
 | 
											
												
													
														|  | -bool handlePool::result_contourdisplay(vtkJsonObject *object_,QVTKRenderer* render_)
 |  | 
 | 
											
												
													
														|  | 
 |  | +bool handlePool::result_contourdisplay(boostJsonObject *object_,QVTKRenderer* render_)
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  |      ContourDisplay* condis = NULL;
 |  |      ContourDisplay* condis = NULL;
 | 
											
												
													
														|  |  
 |  |  
 | 
											
										
											
												
													
														|  | @@ -343,7 +371,7 @@ bool handlePool::result_contourdisplay(vtkJsonObject *object_,QVTKRenderer* rend
 | 
											
												
													
														|  |   * @ret: bool
 |  |   * @ret: bool
 | 
											
												
													
														|  |   * @birth: created by czm in 20230424
 |  |   * @birth: created by czm in 20230424
 | 
											
												
													
														|  |   */
 |  |   */
 | 
											
												
													
														|  | -bool handlePool::result_linedisplay(vtkJsonObject *object_,QVTKRenderer* render_)
 |  | 
 | 
											
												
													
														|  | 
 |  | +bool handlePool::result_linedisplay(boostJsonObject *object_,QVTKRenderer* render_)
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  |      LineDisplay* linedis = NULL;
 |  |      LineDisplay* linedis = NULL;
 | 
											
												
													
														|  |      if(!qmapResultmanager.contains(object_->proId))return false;
 |  |      if(!qmapResultmanager.contains(object_->proId))return false;
 | 
											
										
											
												
													
														|  | @@ -373,7 +401,7 @@ bool handlePool::result_linedisplay(vtkJsonObject *object_,QVTKRenderer* render_
 | 
											
												
													
														|  |   * @ret: bool
 |  |   * @ret: bool
 | 
											
												
													
														|  |   * @birth: created by czm in 20230504
 |  |   * @birth: created by czm in 20230504
 | 
											
												
													
														|  |   */
 |  |   */
 | 
											
												
													
														|  | -bool handlePool::result_vectordisplay(vtkJsonObject *object_, QVTKRenderer *render_)
 |  | 
 | 
											
												
													
														|  | 
 |  | +bool handlePool::result_vectordisplay(boostJsonObject *object_, QVTKRenderer *render_)
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  |      Vectordisplay *vecdis = NULL;
 |  |      Vectordisplay *vecdis = NULL;
 | 
											
												
													
														|  |      if(!qmapResultmanager.contains(object_->proId))return false;
 |  |      if(!qmapResultmanager.contains(object_->proId))return false;
 | 
											
										
											
												
													
														|  | @@ -396,7 +424,7 @@ bool handlePool::result_vectordisplay(vtkJsonObject *object_, QVTKRenderer *rend
 | 
											
												
													
														|  |   * @ret: bool
 |  |   * @ret: bool
 | 
											
												
													
														|  |   * @birth: created by czm in 20230505
 |  |   * @birth: created by czm in 20230505
 | 
											
												
													
														|  |   */
 |  |   */
 | 
											
												
													
														|  | -bool handlePool::result_solidsurfacedisplay(vtkJsonObject *object_, QVTKRenderer *render_)
 |  | 
 | 
											
												
													
														|  | 
 |  | +bool handlePool::result_solidsurfacedisplay(boostJsonObject *object_, QVTKRenderer *render_)
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  |      SolidSurface *solidfdis = NULL;
 |  |      SolidSurface *solidfdis = NULL;
 | 
											
												
													
														|  |      if(!qmapResultmanager.contains(object_->proId))return false;
 |  |      if(!qmapResultmanager.contains(object_->proId))return false;
 | 
											
										
											
												
													
														|  | @@ -413,6 +441,49 @@ bool handlePool::result_solidsurfacedisplay(vtkJsonObject *object_, QVTKRenderer
 | 
											
												
													
														|  |      return true;
 |  |      return true;
 | 
											
												
													
														|  |  }
 |  |  }
 | 
											
												
													
														|  |  
 |  |  
 | 
											
												
													
														|  | 
 |  | +/*
 | 
											
												
													
														|  | 
 |  | + * @brief: analysis msg about slicedisplay
 | 
											
												
													
														|  | 
 |  | + * @param: object and render
 | 
											
												
													
														|  | 
 |  | + * @ret: bool
 | 
											
												
													
														|  | 
 |  | + * @birth: created by czm in 20230505
 | 
											
												
													
														|  | 
 |  | + */
 | 
											
												
													
														|  | 
 |  | +bool handlePool::result_slicedisplay(boostJsonObject *object_, QVTKRenderer *render_,QString type)
 | 
											
												
													
														|  | 
 |  | +{
 | 
											
												
													
														|  | 
 |  | +    SliceWidget *slicedis = NULL;
 | 
											
												
													
														|  | 
 |  | +    if(!qmapResultmanager.contains(object_->proId))return false;
 | 
											
												
													
														|  | 
 |  | +    render_ = qmapRender[object_->proId];
 | 
											
												
													
														|  | 
 |  | +    ResultMeshManager* resultmm = qmapResultmanager[object_->proId]->resultMeshManager_;
 | 
											
												
													
														|  | 
 |  | +    if(map_slicedisplay.contains(object_->proId)){
 | 
											
												
													
														|  | 
 |  | +        slicedis = map_slicedisplay[object_->proId];//to do
 | 
											
												
													
														|  | 
 |  | +    }else{
 | 
											
												
													
														|  | 
 |  | +        slicedis = new SliceWidget(resultmm);
 | 
											
												
													
														|  | 
 |  | +        map_slicedisplay.insert(object_->proId,slicedis);
 | 
											
												
													
														|  | 
 |  | +    }
 | 
											
												
													
														|  | 
 |  | +    if(type == "addpage"){
 | 
											
												
													
														|  | 
 |  | +        int tmp_index = object_->sd_struct->index;
 | 
											
												
													
														|  | 
 |  | +        resultmm->sliceW_->setIndex(tmp_index);
 | 
											
												
													
														|  | 
 |  | +        resultmm->InitSliceWidget();
 | 
											
												
													
														|  | 
 |  | +        resultmm->MakeVISUnStructGrid();
 | 
											
												
													
														|  | 
 |  | +        resultmm->DisplayUnstructGrid();
 | 
											
												
													
														|  | 
 |  | +        resultmm->sliceW_->AddPage();
 | 
											
												
													
														|  | 
 |  | +        resultmm->sliceW_->get_map_SliceDisplayWidget().value(tmp_index)->SetPosition(resultmm->GetUnslicePosition(tmp_index));
 | 
											
												
													
														|  | 
 |  | +        resultmm->sliceW_->get_map_SliceDisplayWidget().value(tmp_index)->SetPositionRange(resultmm->GetUnsliceSourceBounds(tmp_index));
 | 
											
												
													
														|  | 
 |  | +        emit sendImg_handlePoolToSendstate(object_->ToJson("addPage_slice",buildResultImport_msg("addpage_slice",resultmm,object_)));//发送切片结果数据
 | 
											
												
													
														|  | 
 |  | +    }else if(type == "update"){
 | 
											
												
													
														|  | 
 |  | +        resultmm->UpdataSliceWidgetParameter();
 | 
											
												
													
														|  | 
 |  | +        resultmm->sliceW_->UpdateWidget();
 | 
											
												
													
														|  | 
 |  | +        emit sendImg_handlePoolToSendstate(object_->ToJson("update_slice",buildResultImport_msg("update_slice",resultmm,object_)));//发送切片结果数据
 | 
											
												
													
														|  | 
 |  | +    }else if(type == "clear"){
 | 
											
												
													
														|  | 
 |  | +        //resultmm->UpdataSliceWidgetParameter();//先刷新再删除会有问题?
 | 
											
												
													
														|  | 
 |  | +        //resultmm->sliceW_->UpdateWidget();
 | 
											
												
													
														|  | 
 |  | +        resultmm->sliceW_->remove_map_SliceDisplayWidget(object_->sd_struct->index);
 | 
											
												
													
														|  | 
 |  | +    }else if(type == "apply"){
 | 
											
												
													
														|  | 
 |  | +        slicedis->slicewidget_execute(object_);
 | 
											
												
													
														|  | 
 |  | +        send_picture(object_,render_);
 | 
											
												
													
														|  | 
 |  | +    }
 | 
											
												
													
														|  | 
 |  | +    return true;
 | 
											
												
													
														|  | 
 |  | +}
 | 
											
												
													
														|  | 
 |  | +
 | 
											
												
													
														|  |  /*
 |  |  /*
 | 
											
												
													
														|  |   * @brief: save the tecplot filename into QStringList
 |  |   * @brief: save the tecplot filename into QStringList
 | 
											
												
													
														|  |   * @param: filePath
 |  |   * @param: filePath
 | 
											
										
											
												
													
														|  | @@ -519,13 +590,58 @@ QMap<QString,string> handlePool::buildResultImport_msg(QString type,ResultMeshMa
 | 
											
												
													
														|  |      return map_tmp;
 |  |      return map_tmp;
 | 
											
												
													
														|  |  }
 |  |  }
 | 
											
												
													
														|  |  
 |  |  
 | 
											
												
													
														|  | 
 |  | +/*
 | 
											
												
													
														|  | 
 |  | + * @brief: build result file mash which need to be sent to java
 | 
											
												
													
														|  | 
 |  | + * @param: resultmeshManager
 | 
											
												
													
														|  | 
 |  | + * @ret: msg(QString)
 | 
											
												
													
														|  | 
 |  | + * @birth: created by czm in 20230506
 | 
											
												
													
														|  | 
 |  | + */
 | 
											
												
													
														|  | 
 |  | +QMap<QString, string> handlePool::buildResultImport_msg(QString type, ResultMeshManager *cmanager, boostJsonObject *object)
 | 
											
												
													
														|  | 
 |  | +{
 | 
											
												
													
														|  | 
 |  | +    QMap<QString,string> map_tmp;
 | 
											
												
													
														|  | 
 |  | +    if(type == "addpage_slice"){
 | 
											
												
													
														|  | 
 |  | +        int tmp_index = object->sd_struct->index;
 | 
											
												
													
														|  | 
 |  | +        SliceDisplayWidget* sdwidget = cmanager->sliceW_->get_map_SliceDisplayWidget().value(tmp_index);
 | 
											
												
													
														|  | 
 |  | +        string msg;
 | 
											
												
													
														|  | 
 |  | +        map_tmp.insert("position_x",to_string(sdwidget->GetPosition()[0]));
 | 
											
												
													
														|  | 
 |  | +        map_tmp.insert("position_y",to_string(sdwidget->GetPosition()[1]));
 | 
											
												
													
														|  | 
 |  | +        map_tmp.insert("position_z",to_string(sdwidget->GetPosition()[2]));
 | 
											
												
													
														|  | 
 |  | +        map_tmp.insert("min_position_x",to_string(sdwidget->GetPositionRange()[0]));
 | 
											
												
													
														|  | 
 |  | +        map_tmp.insert("max_position_x",to_string(sdwidget->GetPositionRange()[1]));
 | 
											
												
													
														|  | 
 |  | +        map_tmp.insert("min_position_y",to_string(sdwidget->GetPositionRange()[2]));
 | 
											
												
													
														|  | 
 |  | +        map_tmp.insert("max_position_y",to_string(sdwidget->GetPositionRange()[3]));
 | 
											
												
													
														|  | 
 |  | +        map_tmp.insert("min_position_z",to_string(sdwidget->GetPositionRange()[4]));
 | 
											
												
													
														|  | 
 |  | +        map_tmp.insert("max_position_z",to_string(sdwidget->GetPositionRange()[5]));
 | 
											
												
													
														|  | 
 |  | +        for(int i =0; i<sdwidget->GetVariableName_vector().size();i++){
 | 
											
												
													
														|  | 
 |  | +            msg+=sdwidget->GetVariableName_vector()[i];
 | 
											
												
													
														|  | 
 |  | +            msg+=",";
 | 
											
												
													
														|  | 
 |  | +        }
 | 
											
												
													
														|  | 
 |  | +        msg = msg.erase(msg.size()-1);
 | 
											
												
													
														|  | 
 |  | +        map_tmp.insert("variableName",msg);
 | 
											
												
													
														|  | 
 |  | +        msg.clear();
 | 
											
												
													
														|  | 
 |  | +        map_tmp.insert("arearange",sdwidget->getAreaRange().toStdString());
 | 
											
												
													
														|  | 
 |  | +    }else if((type == "update_slice")|| (type == "clear_slice")){
 | 
											
												
													
														|  | 
 |  | +        QMap<int,SliceDisplayWidget*> sdw_map = cmanager->sliceW_->get_map_SliceDisplayWidget();
 | 
											
												
													
														|  | 
 |  | +        for(auto iter = sdw_map.begin();iter!=sdw_map.end();iter++){
 | 
											
												
													
														|  | 
 |  | +            map_tmp.insert("index",to_string(iter.key()));
 | 
											
												
													
														|  | 
 |  | +            map_tmp.insert("normal_x",to_string(iter.value()->GetNormal()[0]));
 | 
											
												
													
														|  | 
 |  | +            map_tmp.insert("normal_y",to_string(iter.value()->GetNormal()[1]));
 | 
											
												
													
														|  | 
 |  | +            map_tmp.insert("normal_z",to_string(iter.value()->GetNormal()[2]));
 | 
											
												
													
														|  | 
 |  | +            map_tmp.insert("position_x",to_string(iter.value()->GetPosition()[0]));
 | 
											
												
													
														|  | 
 |  | +            map_tmp.insert("position_y",to_string(iter.value()->GetPosition()[0]));
 | 
											
												
													
														|  | 
 |  | +            map_tmp.insert("position_z",to_string(iter.value()->GetPosition()[0]));
 | 
											
												
													
														|  | 
 |  | +        }
 | 
											
												
													
														|  | 
 |  | +    }
 | 
											
												
													
														|  | 
 |  | +    return map_tmp;
 | 
											
												
													
														|  | 
 |  | +}
 | 
											
												
													
														|  | 
 |  | +
 | 
											
												
													
														|  |  /*
 |  |  /*
 | 
											
												
													
														|  |   * @brief: send picture
 |  |   * @brief: send picture
 | 
											
												
													
														|  | - * @param: vtkJsonObject QVTKRenderer
 |  | 
 | 
											
												
													
														|  | 
 |  | + * @param: boostJsonObject QVTKRenderer
 | 
											
												
													
														|  |   * @ret: void
 |  |   * @ret: void
 | 
											
												
													
														|  |   * @birth: created by czm in 20230425
 |  |   * @birth: created by czm in 20230425
 | 
											
												
													
														|  |   */
 |  |   */
 | 
											
												
													
														|  | -void handlePool::send_picture(vtkJsonObject *object, QVTKRenderer *render_)
 |  | 
 | 
											
												
													
														|  | 
 |  | +void handlePool::send_picture(boostJsonObject *object, QVTKRenderer *render_)
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  |      render_->CaptureWindowImages();
 |  |      render_->CaptureWindowImages();
 | 
											
												
													
														|  |      if(!render_->img.isEmpty()){
 |  |      if(!render_->img.isEmpty()){
 | 
											
										
											
												
													
														|  | @@ -561,7 +677,7 @@ string handlePool::removeSpaces(string str)//删除字符串中的\u0000
 | 
											
												
													
														|  |   * @ret: QMap<QString, QVTKRenderer *>
 |  |   * @ret: QMap<QString, QVTKRenderer *>
 | 
											
												
													
														|  |   * @birth: created by czm in 20230420
 |  |   * @birth: created by czm in 20230420
 | 
											
												
													
														|  |   */
 |  |   */
 | 
											
												
													
														|  | -QMap<QString, QVTKRenderer *> handlePool::getMapRender()
 |  | 
 | 
											
												
													
														|  | 
 |  | +QMap<string, QVTKRenderer *> handlePool::getMapRender()
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  |      return this->qmapRender;
 |  |      return this->qmapRender;
 | 
											
												
													
														|  |  }
 |  |  }
 | 
											
										
											
												
													
														|  | @@ -572,37 +688,37 @@ QMap<QString, QVTKRenderer *> handlePool::getMapRender()
 | 
											
												
													
														|  |   * @ret: QMap<QString, ResultMeshManager *>
 |  |   * @ret: QMap<QString, ResultMeshManager *>
 | 
											
												
													
														|  |   * @birth: created by czm in 20230420
 |  |   * @birth: created by czm in 20230420
 | 
											
												
													
														|  |   */
 |  |   */
 | 
											
												
													
														|  | -QMap<QString, pid_resultManager *> handlePool::getMapResultManager()
 |  | 
 | 
											
												
													
														|  | 
 |  | +QMap<string, pid_resultManager *> handlePool::getMapResultManager()
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  |      return this->qmapResultmanager;
 |  |      return this->qmapResultmanager;
 | 
											
												
													
														|  |  }
 |  |  }
 | 
											
												
													
														|  |  
 |  |  
 | 
											
												
													
														|  |  /*
 |  |  /*
 | 
											
												
													
														|  |   * @brief: create a pid_meshManager
 |  |   * @brief: create a pid_meshManager
 | 
											
												
													
														|  | - * @param: vtkJsonObject MeshManager
 |  | 
 | 
											
												
													
														|  | 
 |  | + * @param: boostJsonObject MeshManager
 | 
											
												
													
														|  |   * @ret: map_meshManager
 |  |   * @ret: map_meshManager
 | 
											
												
													
														|  |   * @birth: created by czm in 20230425
 |  |   * @birth: created by czm in 20230425
 | 
											
												
													
														|  |   */
 |  |   */
 | 
											
												
													
														|  | -pid_meshManager *handlePool::set_map_meshManager(vtkJsonObject *object, MeshManager *mmanager_)
 |  | 
 | 
											
												
													
														|  | 
 |  | +pid_meshManager *handlePool::set_map_meshManager(boostJsonObject *object, MeshManager *mmanager_)
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  |      pid_meshManager* meshManager_p = new pid_meshManager();
 |  |      pid_meshManager* meshManager_p = new pid_meshManager();
 | 
											
												
													
														|  |      meshManager_p->meshManager_ = mmanager_;
 |  |      meshManager_p->meshManager_ = mmanager_;
 | 
											
												
													
														|  | -    meshManager_p->fileName = object->getFileName();
 |  | 
 | 
											
												
													
														|  | 
 |  | +    meshManager_p->fileName = object->fileName;
 | 
											
												
													
														|  |      meshManager_p->filePath = object->filePath;
 |  |      meshManager_p->filePath = object->filePath;
 | 
											
												
													
														|  |      return meshManager_p;
 |  |      return meshManager_p;
 | 
											
												
													
														|  |  }
 |  |  }
 | 
											
												
													
														|  |  
 |  |  
 | 
											
												
													
														|  |  /*
 |  |  /*
 | 
											
												
													
														|  |   * @brief: create a pid_resultManager
 |  |   * @brief: create a pid_resultManager
 | 
											
												
													
														|  | - * @param: vtkJsonObject ResultMeshManager
 |  | 
 | 
											
												
													
														|  | 
 |  | + * @param: boostJsonObject ResultMeshManager
 | 
											
												
													
														|  |   * @ret: pid_resultManager
 |  |   * @ret: pid_resultManager
 | 
											
												
													
														|  |   * @birth: created by czm in 20230425
 |  |   * @birth: created by czm in 20230425
 | 
											
												
													
														|  |   */
 |  |   */
 | 
											
												
													
														|  | -pid_resultManager *handlePool::set_map_resultManager(vtkJsonObject *object, ResultMeshManager *rmanager_)
 |  | 
 | 
											
												
													
														|  | 
 |  | +pid_resultManager *handlePool::set_map_resultManager(boostJsonObject *object, ResultMeshManager *rmanager_)
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  |      pid_resultManager *resultManager_p = new pid_resultManager();
 |  |      pid_resultManager *resultManager_p = new pid_resultManager();
 | 
											
												
													
														|  |      resultManager_p->resultMeshManager_ = rmanager_;
 |  |      resultManager_p->resultMeshManager_ = rmanager_;
 | 
											
												
													
														|  | -    resultManager_p->fileName = object->getFileName();
 |  | 
 | 
											
												
													
														|  | 
 |  | +    resultManager_p->fileName = object->fileName;
 | 
											
												
													
														|  |      resultManager_p->filePath = object->filePath;
 |  |      resultManager_p->filePath = object->filePath;
 | 
											
												
													
														|  |      return resultManager_p;
 |  |      return resultManager_p;
 | 
											
												
													
														|  |  }
 |  |  }
 | 
											
										
											
												
													
														|  | @@ -613,8 +729,25 @@ pid_resultManager *handlePool::set_map_resultManager(vtkJsonObject *object, Resu
 | 
											
												
													
														|  |   * @ret: QMap<QString, MeshManager *>
 |  |   * @ret: QMap<QString, MeshManager *>
 | 
											
												
													
														|  |   * @birth: created by czm in 20230420
 |  |   * @birth: created by czm in 20230420
 | 
											
												
													
														|  |   */
 |  |   */
 | 
											
												
													
														|  | -QMap<QString, pid_meshManager *> handlePool::getMapManager()
 |  | 
 | 
											
												
													
														|  | 
 |  | +QMap<string, pid_meshManager *> handlePool::getMapManager()
 | 
											
												
													
														|  |  {
 |  |  {
 | 
											
												
													
														|  |      return this->qmapManager;
 |  |      return this->qmapManager;
 | 
											
												
													
														|  |  }
 |  |  }
 | 
											
												
													
														|  |  
 |  |  
 | 
											
												
													
														|  | 
 |  | +/*
 | 
											
												
													
														|  | 
 |  | + * @brief: string split
 | 
											
												
													
														|  | 
 |  | + * @param: str
 | 
											
												
													
														|  | 
 |  | + * @ret: vector
 | 
											
												
													
														|  | 
 |  | + * @birth: created by czm in 20230509
 | 
											
												
													
														|  | 
 |  | + */
 | 
											
												
													
														|  | 
 |  | +vector<string> handlePool::stringSplit(const string& str, char delim) {
 | 
											
												
													
														|  | 
 |  | +    stringstream ss(str);
 | 
											
												
													
														|  | 
 |  | +    string item;
 | 
											
												
													
														|  | 
 |  | +    vector<string> elems;
 | 
											
												
													
														|  | 
 |  | +    while (getline(ss, item, delim)) {
 | 
											
												
													
														|  | 
 |  | +        if (!item.empty()) {
 | 
											
												
													
														|  | 
 |  | +            elems.push_back(item);
 | 
											
												
													
														|  | 
 |  | +        }
 | 
											
												
													
														|  | 
 |  | +    }
 | 
											
												
													
														|  | 
 |  | +    return elems;
 | 
											
												
													
														|  | 
 |  | +}
 |