2514 lines
90 KiB
C++
2514 lines
90 KiB
C++
#include "StabilityModel.h"
|
||
#include <QFile>
|
||
#include "MessageHandle.h"
|
||
#include "CmdDefine.h"
|
||
#include "OCCStructDataMD.h"
|
||
#include "BRepMesh_IncrementalMesh.hxx"
|
||
#include "Logger.h"
|
||
#include <algorithm>
|
||
#include <cctype>
|
||
#include "Constants.h"
|
||
#include "PathUtil.h"
|
||
#include "CommandStreamProcessing.h"
|
||
|
||
|
||
StabilityModel *StabilityModel::m_pStabilityModel = nullptr;
|
||
#ifdef __cplusplus
|
||
extern "C"
|
||
{
|
||
#endif
|
||
|
||
StabilityModel *StabilityModel::getStabilityModelInstance()
|
||
{
|
||
if (m_pStabilityModel == nullptr)
|
||
{
|
||
m_pStabilityModel = new StabilityModel();
|
||
}
|
||
return m_pStabilityModel;
|
||
}
|
||
|
||
void StabilityModel::destroy()
|
||
{
|
||
if (m_pStabilityModel != nullptr)
|
||
{
|
||
delete m_pStabilityModel;
|
||
m_pStabilityModel = nullptr;
|
||
}
|
||
}
|
||
|
||
void StabilityModel::loadXLSXFile(const QString &filePath)
|
||
{
|
||
if (!m_pDataManager)
|
||
{
|
||
return;
|
||
}
|
||
m_eLoadDataType = XMLFile_Type_xls;
|
||
m_pDataManager->readFile(m_eLoadDataType, filePath);
|
||
}
|
||
|
||
DataManager *StabilityModel::getDataManagerPtr()
|
||
{
|
||
if (m_pDataManager)
|
||
{
|
||
return m_pDataManager;
|
||
}
|
||
return nullptr;;
|
||
}
|
||
|
||
StabilityModel *StabilityModel::getStabilityModelpPtr()
|
||
{
|
||
return m_pStabilityModel;
|
||
}
|
||
|
||
void StabilityModel::get3DObjColor(int type,int& iColor,bool& isShowName)
|
||
{
|
||
OptionDataColorSetting::getOptionDataColorSettingInstance().get3DObjColor((E_Stablity_ModelDisplay_Color)type,iColor,isShowName);
|
||
}
|
||
|
||
StabilityModel::StabilityModel()
|
||
{
|
||
// 获取主程序中的共享 logger 实例
|
||
|
||
OptionDataColorSetting::getOptionDataColorSettingInstance();
|
||
|
||
auto log_t = get_shared_logger();
|
||
spdlog::set_default_logger(log_t); // 设置为默认 logger
|
||
|
||
ChangeFSPos::reset();
|
||
m_pDataManager = DataManager::getDataManagerModelInstance();
|
||
m_pDataMD = OCCModeling::GetDataMD();
|
||
|
||
std::vector<IModel*> data_t;
|
||
push_undo_redo_data(-1, data_t);
|
||
|
||
LOG_DEBUG("StabilityModel Constructed");
|
||
}
|
||
StabilityModel::~StabilityModel()
|
||
{
|
||
DataManager::destroy();
|
||
m_pDataManager = nullptr;
|
||
OCCModeling::ReInitData();
|
||
|
||
LOG_DEBUG("StabilityModel Destroyed");
|
||
}
|
||
|
||
bool StabilityModel::showWindowsLog(QString &log)
|
||
{
|
||
if (getDataManagerPtr())
|
||
{
|
||
return getDataManagerPtr()->showWindowsLog(log);
|
||
}
|
||
return false;
|
||
}
|
||
// log 不能有空格
|
||
void StabilityModel::addShowWindowsLog(QString log)
|
||
{
|
||
if (getDataManagerPtr())
|
||
{
|
||
getDataManagerPtr()->addShowWindowsLog(log);
|
||
}
|
||
}
|
||
|
||
//导入型值表
|
||
//横向横剖线 命令集
|
||
std::vector<std::string>& StabilityModel::getTransverseProfile_commad()
|
||
{
|
||
return getDataManagerPtr()->getTransverseProfile_commad();
|
||
}
|
||
//梁拱命令
|
||
std::vector<std::string>& StabilityModel::getCamber_commad()
|
||
{
|
||
return getDataManagerPtr()->getCamber_commad();
|
||
}
|
||
//绘制纵剖线
|
||
std::vector<std::string>& StabilityModel::getLongitudinalProfile_commad()
|
||
{
|
||
return getDataManagerPtr()->getLongitudinalProfile_commad();
|
||
}
|
||
//水线
|
||
std::vector<std::string>& StabilityModel::getWaterLine_commad()
|
||
{
|
||
return getDataManagerPtr()->getWaterLine_commad();
|
||
}
|
||
//空间线
|
||
std::vector<std::string>& StabilityModel::getSpaceLine_commad()
|
||
{
|
||
return getDataManagerPtr()->getSpaceLine_commad();
|
||
}
|
||
|
||
void StabilityModel::setImportOffsetOption(ImportOffsetOption& _option)
|
||
{
|
||
return getDataManagerPtr()->setImportOffsetOption(_option);
|
||
}
|
||
|
||
|
||
void StabilityModel::readFile(XMLFile_Type type, const QString &filePath)
|
||
{
|
||
LOG_DEBUG("trace");
|
||
if (!m_pDataManager)
|
||
{
|
||
return;
|
||
}
|
||
//type = XMLFile_Type_xls;
|
||
m_eLoadDataType = type;
|
||
switch (type)
|
||
{
|
||
case XMLFile_Type_csx:
|
||
{
|
||
OCCModeling::ReInitData();
|
||
m_pDataManager->readFile(type, filePath);
|
||
ModelData &_modelData = m_pDataManager->getModelData();
|
||
// 读取完所有数据后，填充到Map里，为后续Command已有图元查找做准备
|
||
_modelData.UpdateModelMaps();
|
||
// 更新最大ID,为后续创建新对象做赋ID做准备
|
||
_modelData.UpdateMaxID();
|
||
// CheckMaxID() 是测试代码，暂时不需要
|
||
// _modelData.CheckMaxID();
|
||
InitGeometry();
|
||
InitHull();
|
||
|
||
ChangeFSPos::SetSecConvert(&_modelData);
|
||
}
|
||
break;
|
||
case XMLFile_Type_xls:
|
||
{
|
||
loadXLSXFile(filePath);
|
||
//loadXLSXFile("D:/COMPASS-I-F/trunk/doc/TestData/100m.xlsx");
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
QString StabilityModel::updateDelete3dToJson(vector<string>& names)
|
||
{
|
||
json namelist = nlohmann::json::object();
|
||
namelist["name"] = json::array(); // 初始化为空数组
|
||
|
||
for (auto strName : names)
|
||
{
|
||
namelist["name"].push_back(strName);
|
||
}
|
||
QString outJsonData = QString::fromStdString(namelist.dump());
|
||
return outJsonData;
|
||
}
|
||
QString StabilityModel::updateDelete3dToJson(string& name)
|
||
{
|
||
json namelist = nlohmann::json::object();
|
||
namelist["name"] = json::array(); // 初始化为空数组
|
||
namelist["name"].push_back(name);
|
||
|
||
QString outJsonData = QString::fromStdString(namelist.dump());
|
||
return outJsonData;
|
||
}
|
||
|
||
|
||
|
||
void StabilityModel::update3dToJson(json &outjson,E_GEO_3D_OBJ_TYPE type, int id)
|
||
{
|
||
// 读取文件初始默认值给几何相关的信息
|
||
if (!outjson.contains("geometry"))
|
||
{
|
||
outjson["geometry"] = nlohmann::json::object();
|
||
}
|
||
|
||
switch (type)
|
||
{
|
||
case E_GEO_3D_OBJ_TYPE_ALL:
|
||
//0 全量数据传输
|
||
LOG_DEBUG("OCC ExportShapeToJSON_nolhmann begin..");
|
||
ExportShapeToJSON_nolhmann(outjson);
|
||
LOG_DEBUG("OCC ExportShapeToJSON_nolhmann end..");
|
||
ExportHullToJSON_nolhmann(outjson);
|
||
break;
|
||
case E_GEO_3D_OBJ_TYPE_POINT3D:
|
||
// 1 点数据传输
|
||
m_pointByFaceIndex.clear();
|
||
if (m_pDataMD->m_mapAllTopoShapes.size() > 0)
|
||
{
|
||
map<int, TopoDS_Shape>::iterator it;
|
||
for (it = m_pDataMD->m_mapAllTopoShapes.begin(); it != m_pDataMD->m_mapAllTopoShapes.end(); ++it)
|
||
{
|
||
int index = it->first;
|
||
if( id != index)
|
||
{
|
||
continue;
|
||
}
|
||
TopoDS_Shape shape = it->second;
|
||
ShapeTom_pointByFaceIndex(index, shape);
|
||
}
|
||
}
|
||
|
||
for (const auto &[facename, points] : m_pointByFaceIndex)
|
||
{
|
||
nlohmann::json pointData;
|
||
for (const auto &point : points)
|
||
{
|
||
pointData["data"].push_back({point.v1[0], point.v1[1], point.v1[2]});
|
||
}
|
||
pointData["attribute"] = "";
|
||
pointData["visible"] = points[0].visible;
|
||
pointData["id"] = points.empty() ? -1 : points[0].id;
|
||
pointData["color"] = points[0].color;
|
||
|
||
// 追加数据，而不是覆盖
|
||
outjson["geometry"]["point"][facename] = pointData;
|
||
}
|
||
|
||
break;
|
||
case E_GEO_3D_OBJ_TYPE_CURVE:
|
||
//2 线数据传输
|
||
m_linesByFaceIndex.clear();
|
||
|
||
if (m_pDataMD->m_mapAllTopoShapes.size() > 0)
|
||
{
|
||
map<int, TopoDS_Shape>::iterator it;
|
||
for (it = m_pDataMD->m_mapAllTopoShapes.begin(); it != m_pDataMD->m_mapAllTopoShapes.end(); ++it)
|
||
{
|
||
int index = it->first;
|
||
if( id != index)
|
||
{
|
||
continue;
|
||
}
|
||
TopoDS_Shape shape = it->second;
|
||
ShapeToLineByFaceIndex(index, shape);
|
||
}
|
||
}
|
||
for (const auto &[facename, lines] : m_linesByFaceIndex)
|
||
{
|
||
nlohmann::json lineData;
|
||
lineData["attribute"] = "";
|
||
lineData["visible"] = lines[0].visible;
|
||
lineData["id"] = lines.empty() ? -1 : lines[0].id;
|
||
lineData["color"] = lines[0].color;
|
||
|
||
// ✅ 追加线数据（不覆盖已有的 pdata、dpdata、src 等字段）
|
||
for (const auto &line : lines)
|
||
{
|
||
for (const auto &val : line.dp)
|
||
lineData["dpdata"].push_back(val);
|
||
for (const auto &val : line.src)
|
||
lineData["src"].push_back(val);
|
||
}
|
||
|
||
// ✅ 追加线数据
|
||
outjson["geometry"]["lines"][facename] = lineData;
|
||
}
|
||
break;
|
||
case E_GEO_3D_OBJ_TYPE_SURFACE:
|
||
//3 面数据传输
|
||
m_trianglesByFaceIndex.clear();
|
||
if (m_pDataMD->m_mapAllTopoShapes.size() > 0)
|
||
{
|
||
map<int, TopoDS_Shape>::iterator it;
|
||
for (it = m_pDataMD->m_mapAllTopoShapes.begin(); it != m_pDataMD->m_mapAllTopoShapes.end(); ++it)
|
||
{
|
||
int index = it->first;
|
||
if( id != index)
|
||
{
|
||
continue;
|
||
}
|
||
TopoDS_Shape shape = it->second;
|
||
ShapeToTriangleByFaceIndex(index, shape);
|
||
}
|
||
}
|
||
for (const auto &[facename, triangles] : m_trianglesByFaceIndex)
|
||
{
|
||
nlohmann::json surfaceData;
|
||
std::vector<double> tempData; // 存储所有坐标数据
|
||
for (const auto &tri : triangles)
|
||
{
|
||
tempData.insert(tempData.end(), {tri.v1[0], tri.v1[1], tri.v1[2],
|
||
tri.v2[0], tri.v2[1], tri.v2[2],
|
||
tri.v3[0], tri.v3[1], tri.v3[2]});
|
||
}
|
||
surfaceData["data"] = tempData;
|
||
surfaceData["attribute"] = "";
|
||
surfaceData["visible"] = triangles[0].visible;
|
||
surfaceData["id"] = triangles.empty() ? -1 : triangles[0].id;
|
||
surfaceData["color"] = triangles[0].color;
|
||
|
||
// ✅ 追加面数据
|
||
outjson["geometry"]["surface"][facename] = surfaceData;
|
||
}
|
||
break;
|
||
case E_GEO_3D_OBJ_TYPE_SOLID:
|
||
//4 体数据传输
|
||
m_solidsByFaceIndex.clear();
|
||
if (m_pDataMD->m_mapAllTopoShapes.size() > 0)
|
||
{
|
||
map<int, TopoDS_Shape>::iterator it;
|
||
for (it = m_pDataMD->m_mapAllTopoShapes.begin(); it != m_pDataMD->m_mapAllTopoShapes.end(); ++it)
|
||
{
|
||
int index = it->first;
|
||
if( id != index)
|
||
{
|
||
continue;
|
||
}
|
||
TopoDS_Shape shape = it->second;
|
||
ShapeToSolidByFaceIndex(index, shape);
|
||
}
|
||
}
|
||
for (const auto &[facename, solids] : m_solidsByFaceIndex)
|
||
{
|
||
nlohmann::json solidData;
|
||
std::vector<double> tempData; // 存储所有坐标数据
|
||
for (const auto &solid : solids)
|
||
{
|
||
tempData.insert(tempData.end(), {solid.v1[0], solid.v1[1], solid.v1[2],
|
||
solid.v2[0], solid.v2[1], solid.v2[2],
|
||
solid.v3[0], solid.v3[1], solid.v3[2]});
|
||
}
|
||
solidData["data"] = tempData;
|
||
solidData["attribute"] = "";
|
||
solidData["visible"] = solids[0].visible;
|
||
solidData["id"] = solids.empty() ? -1 : solids[0].id;
|
||
solidData["color"] = solids[0].color;
|
||
|
||
outjson["geometry"]["solid"][facename] = solidData;
|
||
}
|
||
break;
|
||
case E_GEO_3D_OBJ_TYPE_HULL:
|
||
//5 主船体数据传输
|
||
m_mainBodyByFaceIndex.clear();
|
||
if (!outjson.contains("hull"))
|
||
{
|
||
outjson["hull"] = nlohmann::json::object();
|
||
}
|
||
|
||
if (m_pDataMD->m_mapAllTopoShapes.size() > 0)
|
||
{
|
||
map<int, TopoDS_Shape>::iterator it;
|
||
for (it = m_pDataMD->m_mapAllTopoShapes.begin(); it != m_pDataMD->m_mapAllTopoShapes.end(); ++it)
|
||
{
|
||
int index = it->first;
|
||
if( id != index)
|
||
{
|
||
continue;
|
||
}
|
||
TopoDS_Shape shape = it->second;
|
||
ShapeTom_mainBodyByFaceIndex(index, shape);
|
||
}
|
||
}
|
||
for (const auto &[facename, mainbody] : m_mainBodyByFaceIndex)
|
||
{
|
||
nlohmann::json mainbodyData;
|
||
std::vector<double> tempData; // 存储所有坐标数据
|
||
for (const auto &tri : mainbody)
|
||
{
|
||
tempData.insert(tempData.end(), {tri.v1[0], tri.v1[1], tri.v1[2],
|
||
tri.v2[0], tri.v2[1], tri.v2[2],
|
||
tri.v3[0], tri.v3[1], tri.v3[2]});
|
||
}
|
||
mainbodyData["data"] = tempData;
|
||
mainbodyData["attribute"] = "";
|
||
mainbodyData["visible"] = mainbody[0].visible;
|
||
mainbodyData["color"] = mainbody[0].color;
|
||
|
||
mainbodyData["id"] = mainbody.empty() ? -1 : mainbody[0].id;
|
||
|
||
// ✅ 追加面数据
|
||
outjson["hull"]["mainbody"][facename] = mainbodyData;
|
||
}
|
||
break;
|
||
case E_GEO_3D_OBJ_TYPE_SPACE:
|
||
//6 舱室数据传输
|
||
m_spaceByFaceIndex.clear();
|
||
if (!outjson.contains("hull"))
|
||
{
|
||
outjson["hull"] = nlohmann::json::object();
|
||
}
|
||
if (m_pDataMD->m_mapAllTopoShapes.size() > 0)
|
||
{
|
||
map<int, TopoDS_Shape>::iterator it;
|
||
for (it = m_pDataMD->m_mapAllTopoShapes.begin(); it != m_pDataMD->m_mapAllTopoShapes.end(); ++it)
|
||
{
|
||
int index = it->first;
|
||
if( id != index)
|
||
{
|
||
continue;
|
||
}
|
||
TopoDS_Shape shape = it->second;
|
||
ShapeTom_spaceByFaceIndex(index, shape);
|
||
}
|
||
}
|
||
for (const auto &[facename, spaces] : m_spaceByFaceIndex)
|
||
{
|
||
nlohmann::json spaceData;
|
||
std::vector<double> tempData; // 存储所有坐标数据
|
||
for (const auto &tri : spaces)
|
||
{
|
||
tempData.insert(tempData.end(), {tri.v1[0], tri.v1[1], tri.v1[2],
|
||
tri.v2[0], tri.v2[1], tri.v2[2],
|
||
tri.v3[0], tri.v3[1], tri.v3[2]});
|
||
}
|
||
spaceData["data"] = tempData;
|
||
spaceData["attribute"] = "";
|
||
spaceData["visible"] = spaces[0].visible;
|
||
spaceData["color"] = spaces[0].color;
|
||
|
||
spaceData["id"] = spaces.empty() ? -1 : spaces[0].id;
|
||
|
||
// ✅ 追加面数据
|
||
if (spaces[0].isunit)
|
||
{
|
||
outjson["hull"]["unit"][facename] = spaceData;
|
||
}
|
||
else
|
||
{
|
||
outjson["hull"]["space"][facename] = spaceData;
|
||
}
|
||
}
|
||
break;
|
||
case E_GEO_3D_OBJ_TYPE_APPENDAGE:
|
||
//7 附体数据传输
|
||
m_appendageByFaceIndex.clear();
|
||
if (!outjson.contains("hull"))
|
||
{
|
||
outjson["hull"] = nlohmann::json::object();
|
||
}
|
||
if (m_pDataMD->m_mapAllTopoShapes.size() > 0)
|
||
{
|
||
map<int, TopoDS_Shape>::iterator it;
|
||
for (it = m_pDataMD->m_mapAllTopoShapes.begin(); it != m_pDataMD->m_mapAllTopoShapes.end(); ++it)
|
||
{
|
||
int index = it->first;
|
||
if( id != index)
|
||
{
|
||
continue;
|
||
}
|
||
TopoDS_Shape shape = it->second;
|
||
ShapeTom_appendageByFaceIndex(index, shape);
|
||
}
|
||
}
|
||
for (const auto &[facename, appendages] : m_appendageByFaceIndex)
|
||
{
|
||
nlohmann::json appendageData;
|
||
std::vector<double> tempData; // 存储所有坐标数据
|
||
for (const auto &tri : appendages)
|
||
{
|
||
tempData.insert(tempData.end(), {tri.v1[0], tri.v1[1], tri.v1[2],
|
||
tri.v2[0], tri.v2[1], tri.v2[2],
|
||
tri.v3[0], tri.v3[1], tri.v3[2]});
|
||
}
|
||
appendageData["data"] = tempData;
|
||
appendageData["attribute"] = "";
|
||
appendageData["visible"] = appendages[0].visible;
|
||
appendageData["color"] = appendages[0].color;
|
||
|
||
appendageData["id"] = appendages.empty() ? -1 : appendages[0].id;
|
||
|
||
// ✅ 追加面数据
|
||
outjson["hull"]["appendage"][facename] = appendageData;
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
if(XMLFile_Type_csx == m_eLoadDataType)
|
||
{
|
||
int a = 0;
|
||
}
|
||
else if(XMLFile_Type_null == m_eLoadDataType)
|
||
{
|
||
|
||
}
|
||
else if(XMLFile_Type_iges == m_eLoadDataType)
|
||
{
|
||
modifyOutJson_color(outjson,"color",0xFFFF00);
|
||
}
|
||
else if(XMLFile_Type_dxf == m_eLoadDataType)
|
||
{
|
||
modifyOutJson_color(outjson,"color",0xFFFF00);
|
||
}
|
||
|
||
|
||
// std::ofstream outFile("D://0430.json", std::ios::out);
|
||
|
||
// if (!outFile.is_open()) return;
|
||
// outFile << outjson.dump(4) ;
|
||
// outFile.close();
|
||
}
|
||
|
||
|
||
void StabilityModel::modifyOutJson_color(json& j, const std::string& key, int new_color_value)
|
||
{
|
||
if (j.contains(key))
|
||
{
|
||
j[key] = new_color_value;
|
||
}
|
||
// 递归检查并修改嵌套的 color 字段
|
||
for (auto& el : j.items())
|
||
{
|
||
if (el.value().is_object())
|
||
{
|
||
modifyOutJson_color(el.value(), key, new_color_value);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 捕获点的选择
|
||
void StabilityModel::snap_point(SNAP_POINTS_Type iSelect, int &errorCode, QString &outMsg, QString &data, const QString &message)
|
||
{
|
||
m_pDataManager->snap_point(iSelect, errorCode, outMsg, data, message);
|
||
}
|
||
|
||
std::vector<double> StabilityModel::DiscretePoints(TopoDS_Edge &curve, double dAngle, double dTol)
|
||
{
|
||
// m_bOK = true;
|
||
|
||
std::vector<double> listDrawPoints;
|
||
BRepAdaptor_Curve adaptor(curve);
|
||
|
||
double U1 = adaptor.FirstParameter();
|
||
double U2 = adaptor.LastParameter();
|
||
|
||
const Standard_Integer nbinter = adaptor.NbIntervals(GeomAbs_C1);
|
||
TColStd_Array1OfReal T(1, nbinter + 1);
|
||
adaptor.Intervals(T, GeomAbs_C1);
|
||
|
||
Standard_Real theU1, theU2;
|
||
Standard_Integer NumberOfPoints, i, j;
|
||
|
||
for (j = 1; j <= nbinter; j++)
|
||
{
|
||
theU1 = T(j);
|
||
theU2 = T(j + 1);
|
||
if (theU2 > U1 && theU1 < U2)
|
||
{
|
||
theU1 = (theU1 > U1) ? theU1 : U1;
|
||
theU2 = (theU2 < U2) ? theU2 : U2;
|
||
|
||
GCPnts_TangentialDeflection Algo(adaptor, theU1, theU2, dAngle, dTol);
|
||
NumberOfPoints = Algo.NbPoints();
|
||
|
||
if (NumberOfPoints > 0)
|
||
{
|
||
for (i = 1; i <= NumberOfPoints; i++)
|
||
{
|
||
listDrawPoints.push_back(Algo.Value(i).X());
|
||
listDrawPoints.push_back(Algo.Value(i).Y());
|
||
listDrawPoints.push_back(Algo.Value(i).Z());
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// m_bOK = false;
|
||
}
|
||
}
|
||
}
|
||
return listDrawPoints;
|
||
}
|
||
|
||
std::vector<double> StabilityModel::DiscretePointsByAngle(Handle_Geom_BSplineCurve &curve, double dAngle, double dTol)
|
||
{
|
||
TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(curve);
|
||
return DiscretePoints(edge, dAngle, dTol);
|
||
}
|
||
|
||
bool StabilityModel::ShapeToTriangleByFaceIndex(int &index, TopoDS_Shape &shape)
|
||
{
|
||
auto searchname = m_pDataMD->m_mapAllNames.find(index);
|
||
auto surfacesearch = m_pDataMD->m_mapSurfaces.find(index);
|
||
|
||
if (searchname == m_pDataMD->m_mapAllNames.end() || surfacesearch == m_pDataMD->m_mapSurfaces.end())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
const std::string &facename = searchname->second;
|
||
if (facename.empty())
|
||
{
|
||
return false;
|
||
}
|
||
int id = surfacesearch->second.ID;
|
||
|
||
Standard_Real aDeflection = 0.05;
|
||
BRepTools::Clean(shape);
|
||
BRepMesh_IncrementalMesh(shape, aDeflection);
|
||
|
||
for (TopExp_Explorer ex(shape, TopAbs_FACE); ex.More(); ex.Next())
|
||
{
|
||
TopoDS_Face F = TopoDS::Face(ex.Current());
|
||
BRepMesh_IncrementalMesh(F, aDeflection);
|
||
TopLoc_Location L;
|
||
Handle(Poly_Triangulation) facing = BRep_Tool::Triangulation(F, L);
|
||
if (facing.IsNull())
|
||
continue;
|
||
|
||
const Poly_Array1OfTriangle &triangles = facing->InternalTriangles();
|
||
Standard_Integer triLower = triangles.Lower();
|
||
Standard_Integer triUpper = triangles.Upper();
|
||
|
||
std::vector<Triangle3D> faceTriangles;
|
||
|
||
for (Standard_Integer i = triLower; i <= triUpper; ++i)
|
||
{
|
||
Poly_Triangle tri = triangles.Value(i);
|
||
Standard_Integer index1, index2, index3;
|
||
tri.Get(index1, index2, index3);
|
||
|
||
// 防止 index 越界访问 Node()
|
||
if (index1 < 1 || index1 > facing->NbNodes() ||
|
||
index2 < 1 || index2 > facing->NbNodes() ||
|
||
index3 < 1 || index3 > facing->NbNodes())
|
||
{
|
||
qDebug() << "非法三角形索引：" << index1 << index2 << index3;
|
||
continue; // 跳过非法面，避免崩溃
|
||
}
|
||
|
||
gp_Pnt p1 = facing->Node(index1);
|
||
gp_Pnt p2 = facing->Node(index2);
|
||
gp_Pnt p3 = facing->Node(index3);
|
||
|
||
Triangle3D triangle;
|
||
|
||
if (F.Orientation() == TopAbs_REVERSED)
|
||
{
|
||
triangle.v1 = {p3.X(), p3.Y(), p3.Z()};
|
||
triangle.v2 = {p2.X(), p2.Y(), p2.Z()};
|
||
triangle.v3 = {p1.X(), p1.Y(), p1.Z()};
|
||
}
|
||
else
|
||
{
|
||
triangle.v1 = {p1.X(), p1.Y(), p1.Z()};
|
||
triangle.v2 = {p2.X(), p2.Y(), p2.Z()};
|
||
triangle.v3 = {p3.X(), p3.Y(), p3.Z()};
|
||
}
|
||
|
||
triangle.id = id;
|
||
triangle.visible = surfacesearch->second.Visible;
|
||
triangle.color = surfacesearch->second.Color;
|
||
faceTriangles.push_back(triangle);
|
||
}
|
||
|
||
if (faceTriangles.empty())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
m_trianglesByFaceIndex[facename].insert(
|
||
m_trianglesByFaceIndex[facename].end(),
|
||
std::make_move_iterator(faceTriangles.begin()),
|
||
std::make_move_iterator(faceTriangles.end()));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool StabilityModel::ShapeToLineByFaceIndex(int &index, TopoDS_Shape &shape)
|
||
{
|
||
auto searchname = m_pDataMD->m_mapAllNames.find(index);
|
||
auto curvesearch = m_pDataMD->m_mapCurves.find(index);
|
||
|
||
if (searchname == m_pDataMD->m_mapAllNames.end() || curvesearch == m_pDataMD->m_mapCurves.end())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
const std::string &facename = searchname->second;
|
||
if (facename.empty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
int id = curvesearch->second.ID;
|
||
const auto &srcindex = curvesearch->second.Src;
|
||
|
||
std::vector<double> src;
|
||
src.reserve(256 * 3); // 预分配最大可能大小，避免 `push_back` 导致的多次扩容
|
||
|
||
for (int i = 0; i < 256; ++i)
|
||
{
|
||
if (srcindex[i] != 0 && srcindex[i] < 100000)
|
||
{
|
||
const auto &point = m_pDataMD->m_mapPoints[srcindex[i]];
|
||
src.push_back(point.X);
|
||
src.push_back(point.Y);
|
||
src.push_back(point.Z);
|
||
}
|
||
}
|
||
|
||
for (TopExp_Explorer ex(shape, TopAbs_EDGE); ex.More(); ex.Next())
|
||
{
|
||
TopoDS_Edge E = TopoDS::Edge(ex.Current());
|
||
BRepAdaptor_Curve curve(E);
|
||
|
||
Line3D line;
|
||
line.id = id;
|
||
line.dp = DiscretePoints(E, 3.1415926535 / 18, 0.001);
|
||
line.src = std::move(src); // 直接移动 `src` 避免拷贝，提高效率
|
||
line.visible = curvesearch->second.Visible;
|
||
line.color = curvesearch->second.Color;
|
||
m_linesByFaceIndex[facename].emplace_back(std::move(line)); // 直接 `emplace_back`
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool StabilityModel::ShapeTom_pointByFaceIndex(int &index, TopoDS_Shape &shape)
|
||
{
|
||
auto searchname = m_pDataMD->m_mapAllNames.find(index);
|
||
auto pointsearch = m_pDataMD->m_mapPoints.find(index);
|
||
if (searchname == m_pDataMD->m_mapAllNames.end() || pointsearch == m_pDataMD->m_mapPoints.end())
|
||
{
|
||
return false;
|
||
}
|
||
int id = pointsearch->second.ID;
|
||
const std::string &facename = searchname->second;
|
||
if (facename.empty())
|
||
{
|
||
return false;
|
||
}
|
||
for (TopExp_Explorer ex(shape, TopAbs_VERTEX); ex.More(); ex.Next())
|
||
{
|
||
TopoDS_Vertex V = TopoDS::Vertex(ex.Current());
|
||
gp_Pnt p = BRep_Tool::Pnt(V);
|
||
m_Point3D point;
|
||
point.v1.push_back(p.X());
|
||
point.v1.push_back(p.Y());
|
||
point.v1.push_back(p.Z());
|
||
point.id = id;
|
||
point.visible = pointsearch->second.Visible;
|
||
point.color = pointsearch->second.Color;
|
||
|
||
m_pointByFaceIndex[facename].emplace_back(std::move(point));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool StabilityModel::ShapeToSolidByFaceIndex(int &index, TopoDS_Shape &shape)
|
||
{
|
||
auto searchname = m_pDataMD->m_mapAllNames.find(index);
|
||
auto solidsearch = m_pDataMD->m_mapSolids.find(index);
|
||
if (searchname == m_pDataMD->m_mapAllNames.end() || solidsearch == m_pDataMD->m_mapSolids.end())
|
||
{
|
||
return false;
|
||
}
|
||
int id = solidsearch->second.ID;
|
||
|
||
// 输出点数据
|
||
const std::string &facename = searchname->second;
|
||
if (facename.empty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
Standard_Real aDeflection = 0.05;
|
||
BRepTools::Clean(shape);
|
||
BRepMesh_IncrementalMesh(shape, aDeflection);
|
||
|
||
for (TopExp_Explorer ex(shape, TopAbs_FACE); ex.More(); ex.Next())
|
||
{
|
||
TopoDS_Face F = TopoDS::Face(ex.Current());
|
||
BRepMesh_IncrementalMesh(F, aDeflection);
|
||
TopLoc_Location L;
|
||
Handle(Poly_Triangulation) facing = BRep_Tool::Triangulation(F, L);
|
||
if (facing.IsNull())
|
||
continue;
|
||
|
||
const Poly_Array1OfTriangle &triangles = facing->InternalTriangles();
|
||
Standard_Integer triLower = triangles.Lower();
|
||
Standard_Integer triUpper = triangles.Upper();
|
||
|
||
std::vector<m_Solid> faceSolids;
|
||
|
||
for (Standard_Integer i = triLower; i <= triUpper; ++i)
|
||
{
|
||
Poly_Triangle tri = triangles.Value(i);
|
||
Standard_Integer index1, index2, index3;
|
||
tri.Get(index1, index2, index3);
|
||
|
||
// 防止 index 越界访问 Node()
|
||
if (index1 < 1 || index1 > facing->NbNodes() ||
|
||
index2 < 1 || index2 > facing->NbNodes() ||
|
||
index3 < 1 || index3 > facing->NbNodes())
|
||
{
|
||
qDebug() << "非法三角形索引：" << index1 << index2 << index3;
|
||
continue; // 跳过非法面，避免崩溃
|
||
}
|
||
|
||
gp_Pnt p1 = facing->Node(index1);
|
||
gp_Pnt p2 = facing->Node(index2);
|
||
gp_Pnt p3 = facing->Node(index3);
|
||
|
||
m_Solid solid;
|
||
|
||
if (F.Orientation() == TopAbs_REVERSED)
|
||
{
|
||
solid.v1 = {p3.X(), p3.Y(), p3.Z()};
|
||
solid.v2 = {p2.X(), p2.Y(), p2.Z()};
|
||
solid.v3 = {p1.X(), p1.Y(), p1.Z()};
|
||
}
|
||
else
|
||
{
|
||
solid.v1 = {p1.X(), p1.Y(), p1.Z()};
|
||
solid.v2 = {p2.X(), p2.Y(), p2.Z()};
|
||
solid.v3 = {p3.X(), p3.Y(), p3.Z()};
|
||
}
|
||
|
||
solid.id = id;
|
||
solid.visible = solidsearch->second.Visible;
|
||
solid.color = solidsearch->second.Color;
|
||
faceSolids.push_back(solid);
|
||
}
|
||
|
||
m_solidsByFaceIndex[facename].insert(
|
||
m_solidsByFaceIndex[facename].end(),
|
||
std::make_move_iterator(faceSolids.begin()),
|
||
std::make_move_iterator(faceSolids.end()));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool StabilityModel::ShapeTom_mainBodyByFaceIndex(int &index, TopoDS_Shape &shape)
|
||
{
|
||
auto searchname = m_pDataMD->m_mapAllNames.find(index);
|
||
auto hullsearch = m_pDataMD->m_mapHull.find(index);
|
||
if (searchname == m_pDataMD->m_mapAllNames.end() || hullsearch == m_pDataMD->m_mapHull.end())
|
||
{
|
||
return false;
|
||
}
|
||
int id = hullsearch->second.ID;
|
||
|
||
// 输出点数据
|
||
const std::string &facename = searchname->second;
|
||
if (facename.empty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
Standard_Real aDeflection = 0.05;
|
||
BRepTools::Clean(shape);
|
||
BRepMesh_IncrementalMesh(shape, aDeflection);
|
||
|
||
for (TopExp_Explorer ex(shape, TopAbs_FACE); ex.More(); ex.Next())
|
||
{
|
||
TopoDS_Face F = TopoDS::Face(ex.Current());
|
||
BRepMesh_IncrementalMesh(F, aDeflection);
|
||
TopLoc_Location L;
|
||
Handle(Poly_Triangulation) facing = BRep_Tool::Triangulation(F, L);
|
||
if (facing.IsNull())
|
||
continue;
|
||
|
||
const Poly_Array1OfTriangle &triangles = facing->InternalTriangles();
|
||
Standard_Integer triLower = triangles.Lower();
|
||
Standard_Integer triUpper = triangles.Upper();
|
||
|
||
std::vector<m_mainbody> faceMainBody;
|
||
|
||
for (Standard_Integer i = triLower; i <= triUpper; ++i)
|
||
{
|
||
Poly_Triangle tri = triangles.Value(i);
|
||
Standard_Integer index1, index2, index3;
|
||
tri.Get(index1, index2, index3);
|
||
|
||
// 防止 index 越界访问 Node()
|
||
if (index1 < 1 || index1 > facing->NbNodes() ||
|
||
index2 < 1 || index2 > facing->NbNodes() ||
|
||
index3 < 1 || index3 > facing->NbNodes())
|
||
{
|
||
qDebug() << "非法三角形索引：" << index1 << index2 << index3;
|
||
continue; // 跳过非法面，避免崩溃
|
||
}
|
||
|
||
gp_Pnt p1 = facing->Node(index1);
|
||
gp_Pnt p2 = facing->Node(index2);
|
||
gp_Pnt p3 = facing->Node(index3);
|
||
m_mainbody mainbody;
|
||
if (F.Orientation() == TopAbs_REVERSED)
|
||
{
|
||
mainbody.v1 = {p3.X(), p3.Y(), p3.Z()};
|
||
mainbody.v2 = {p2.X(), p2.Y(), p2.Z()};
|
||
mainbody.v3 = {p1.X(), p1.Y(), p1.Z()};
|
||
}
|
||
else
|
||
{
|
||
mainbody.v1 = {p1.X(), p1.Y(), p1.Z()};
|
||
mainbody.v2 = {p2.X(), p2.Y(), p2.Z()};
|
||
mainbody.v3 = {p3.X(), p3.Y(), p3.Z()};
|
||
}
|
||
mainbody.id = id;
|
||
mainbody.visible = hullsearch->second.Visible;
|
||
mainbody.color = hullsearch->second.Color;
|
||
faceMainBody.push_back(mainbody);
|
||
}
|
||
|
||
m_mainBodyByFaceIndex[facename].insert(
|
||
m_mainBodyByFaceIndex[facename].end(),
|
||
std::make_move_iterator(faceMainBody.begin()),
|
||
std::make_move_iterator(faceMainBody.end()));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool StabilityModel::ShapeTom_spaceByFaceIndex(int &index, TopoDS_Shape &shape)
|
||
{
|
||
auto searchname = m_pDataMD->m_mapAllNames.find(index);
|
||
auto spacesearch = m_pDataMD->m_mapSpace.find(index);
|
||
if (searchname == m_pDataMD->m_mapAllNames.end() || spacesearch == m_pDataMD->m_mapSpace.end())
|
||
{
|
||
return false;
|
||
}
|
||
int id = spacesearch->second.ID;
|
||
|
||
// 输出点数据
|
||
const std::string &facename = searchname->second;
|
||
if (facename.empty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
Standard_Real aDeflection = 0.05;
|
||
BRepTools::Clean(shape);
|
||
BRepMesh_IncrementalMesh(shape, aDeflection);
|
||
|
||
for (TopExp_Explorer ex(shape, TopAbs_FACE); ex.More(); ex.Next())
|
||
{
|
||
TopoDS_Face F = TopoDS::Face(ex.Current());
|
||
BRepMesh_IncrementalMesh(F, aDeflection);
|
||
TopLoc_Location L;
|
||
Handle(Poly_Triangulation) facing = BRep_Tool::Triangulation(F, L);
|
||
if (facing.IsNull())
|
||
continue;
|
||
|
||
const Poly_Array1OfTriangle &triangles = facing->InternalTriangles();
|
||
Standard_Integer triLower = triangles.Lower();
|
||
Standard_Integer triUpper = triangles.Upper();
|
||
|
||
std::vector<m_space> faceSpace;
|
||
|
||
for (Standard_Integer i = triLower; i <= triUpper; ++i)
|
||
{
|
||
Poly_Triangle tri = triangles.Value(i);
|
||
Standard_Integer index1, index2, index3;
|
||
tri.Get(index1, index2, index3);
|
||
|
||
// 防止 index 越界访问 Node()
|
||
if (index1 < 1 || index1 > facing->NbNodes() ||
|
||
index2 < 1 || index2 > facing->NbNodes() ||
|
||
index3 < 1 || index3 > facing->NbNodes())
|
||
{
|
||
qDebug() << "非法三角形索引：" << index1 << index2 << index3;
|
||
continue; // 跳过非法面，避免崩溃
|
||
}
|
||
|
||
gp_Pnt p1 = facing->Node(index1);
|
||
gp_Pnt p2 = facing->Node(index2);
|
||
gp_Pnt p3 = facing->Node(index3);
|
||
m_space space;
|
||
if (F.Orientation() == TopAbs_REVERSED)
|
||
{
|
||
space.v1 = {p3.X(), p3.Y(), p3.Z()};
|
||
space.v2 = {p2.X(), p2.Y(), p2.Z()};
|
||
space.v3 = {p1.X(), p1.Y(), p1.Z()};
|
||
}
|
||
else
|
||
{
|
||
space.v1 = {p1.X(), p1.Y(), p1.Z()};
|
||
space.v2 = {p2.X(), p2.Y(), p2.Z()};
|
||
space.v3 = {p3.X(), p3.Y(), p3.Z()};
|
||
}
|
||
space.id = id;
|
||
space.visible = spacesearch->second.Visible;
|
||
space.isunit = spacesearch->second.isUnit;
|
||
space.color = spacesearch->second.Color;
|
||
faceSpace.push_back(space);
|
||
}
|
||
m_spaceByFaceIndex[facename].insert(
|
||
m_spaceByFaceIndex[facename].end(),
|
||
std::make_move_iterator(faceSpace.begin()),
|
||
std::make_move_iterator(faceSpace.end()));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool StabilityModel::ShapeTom_appendageByFaceIndex(int &index, TopoDS_Shape &shape)
|
||
{
|
||
auto searchname = m_pDataMD->m_mapAllNames.find(index);
|
||
auto appendagesearch = m_pDataMD->m_mapAppendage.find(index);
|
||
if (searchname == m_pDataMD->m_mapAllNames.end() || appendagesearch == m_pDataMD->m_mapAppendage.end())
|
||
{
|
||
return false;
|
||
}
|
||
int id = appendagesearch->second.ID;
|
||
|
||
// 输出点数据
|
||
const std::string &facename = searchname->second;
|
||
if (facename.empty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
Standard_Real aDeflection = 0.05;
|
||
BRepTools::Clean(shape);
|
||
BRepMesh_IncrementalMesh(shape, aDeflection);
|
||
|
||
for (TopExp_Explorer ex(shape, TopAbs_FACE); ex.More(); ex.Next())
|
||
{
|
||
TopoDS_Face F = TopoDS::Face(ex.Current());
|
||
BRepMesh_IncrementalMesh(F, aDeflection);
|
||
TopLoc_Location L;
|
||
Handle(Poly_Triangulation) facing = BRep_Tool::Triangulation(F, L);
|
||
if (facing.IsNull())
|
||
continue;
|
||
|
||
const Poly_Array1OfTriangle &triangles = facing->InternalTriangles();
|
||
Standard_Integer triLower = triangles.Lower();
|
||
Standard_Integer triUpper = triangles.Upper();
|
||
|
||
std::vector<m_Appendage> faceAppendage;
|
||
|
||
for (Standard_Integer i = triLower; i <= triUpper; ++i)
|
||
{
|
||
Poly_Triangle tri = triangles.Value(i);
|
||
Standard_Integer index1, index2, index3;
|
||
tri.Get(index1, index2, index3);
|
||
|
||
// 防止 index 越界访问 Node()
|
||
if (index1 < 1 || index1 > facing->NbNodes() ||
|
||
index2 < 1 || index2 > facing->NbNodes() ||
|
||
index3 < 1 || index3 > facing->NbNodes())
|
||
{
|
||
qDebug() << "非法三角形索引：" << index1 << index2 << index3;
|
||
continue; // 跳过非法面，避免崩溃
|
||
}
|
||
m_Appendage appendage;
|
||
gp_Pnt p1 = facing->Node(index1);
|
||
gp_Pnt p2 = facing->Node(index2);
|
||
gp_Pnt p3 = facing->Node(index3);
|
||
|
||
if (F.Orientation() == TopAbs_REVERSED)
|
||
{
|
||
appendage.v1 = {p3.X(), p3.Y(), p3.Z()};
|
||
appendage.v2 = {p2.X(), p2.Y(), p2.Z()};
|
||
appendage.v3 = {p1.X(), p1.Y(), p1.Z()};
|
||
}
|
||
else
|
||
{
|
||
appendage.v1 = {p1.X(), p1.Y(), p1.Z()};
|
||
appendage.v2 = {p2.X(), p2.Y(), p2.Z()};
|
||
appendage.v3 = {p3.X(), p3.Y(), p3.Z()};
|
||
}
|
||
appendage.id = id;
|
||
appendage.visible = appendagesearch->second.Visible;
|
||
appendage.color = appendagesearch->second.Color;
|
||
faceAppendage.push_back(appendage);
|
||
}
|
||
m_appendageByFaceIndex[facename].insert(
|
||
m_appendageByFaceIndex[facename].end(),
|
||
std::make_move_iterator(faceAppendage.begin()),
|
||
std::make_move_iterator(faceAppendage.end()));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void StabilityModel::ExportShapeToJSON_nolhmann(nlohmann::json &jsonOutput)
|
||
{
|
||
m_trianglesByFaceIndex.clear();
|
||
m_linesByFaceIndex.clear();
|
||
m_pointByFaceIndex.clear();
|
||
m_solidsByFaceIndex.clear();
|
||
|
||
if (!jsonOutput.contains("geometry"))
|
||
{
|
||
jsonOutput["geometry"] = nlohmann::json::object();
|
||
}
|
||
|
||
|
||
if (m_pDataMD->m_mapAllTopoShapes.size() > 0)
|
||
{
|
||
map<int, TopoDS_Shape>::iterator it;
|
||
for (it = m_pDataMD->m_mapAllTopoShapes.begin(); it != m_pDataMD->m_mapAllTopoShapes.end(); ++it)
|
||
{
|
||
int index = it->first;
|
||
TopoDS_Shape shape = it->second;
|
||
if (ShapeTom_pointByFaceIndex(index, shape) ||
|
||
ShapeToLineByFaceIndex(index, shape) ||
|
||
ShapeToTriangleByFaceIndex(index, shape) ||
|
||
ShapeToSolidByFaceIndex(index, shape))
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
|
||
for (const auto &[facename, points] : m_pointByFaceIndex)
|
||
{
|
||
nlohmann::json pointData;
|
||
for (const auto &point : points)
|
||
{
|
||
pointData["data"].push_back({point.v1[0], point.v1[1], point.v1[2]});
|
||
}
|
||
pointData["attribute"] = "";
|
||
pointData["visible"] = points[0].visible;
|
||
pointData["id"] = points.empty() ? -1 : points[0].id;
|
||
pointData["color"] = points[0].color;
|
||
// 追加数据，而不是覆盖
|
||
jsonOutput["geometry"]["point"][facename] = pointData;
|
||
}
|
||
|
||
for (const auto &[facename, lines] : m_linesByFaceIndex)
|
||
{
|
||
nlohmann::json lineData;
|
||
lineData["attribute"] = "";
|
||
lineData["visible"] = lines[0].visible;
|
||
lineData["id"] = lines.empty() ? -1 : lines[0].id;
|
||
lineData["color"] = lines[0].color;
|
||
|
||
// ✅ 追加线数据（不覆盖已有的 pdata、dpdata、src 等字段）
|
||
for (const auto &line : lines)
|
||
{
|
||
for (const auto &val : line.dp)
|
||
lineData["dpdata"].push_back(val);
|
||
for (const auto &val : line.src)
|
||
lineData["src"].push_back(val);
|
||
}
|
||
|
||
// ✅ 追加线数据
|
||
jsonOutput["geometry"]["lines"][facename] = lineData;
|
||
}
|
||
|
||
for (const auto &[facename, triangles] : m_trianglesByFaceIndex)
|
||
{
|
||
nlohmann::json surfaceData;
|
||
std::vector<double> tempData; // 存储所有坐标数据
|
||
for (const auto &tri : triangles)
|
||
{
|
||
tempData.insert(tempData.end(), {tri.v1[0], tri.v1[1], tri.v1[2],
|
||
tri.v2[0], tri.v2[1], tri.v2[2],
|
||
tri.v3[0], tri.v3[1], tri.v3[2]});
|
||
}
|
||
surfaceData["data"] = tempData;
|
||
surfaceData["attribute"] = "";
|
||
surfaceData["visible"] = triangles[0].visible;
|
||
surfaceData["id"] = triangles.empty() ? -1 : triangles[0].id;
|
||
surfaceData["color"] = triangles[0].color;
|
||
|
||
// ✅ 追加面数据
|
||
jsonOutput["geometry"]["surface"][facename] = surfaceData;
|
||
}
|
||
|
||
// 体数据（示例）
|
||
for (const auto &[facename, solids] : m_solidsByFaceIndex)
|
||
{
|
||
nlohmann::json solidData;
|
||
std::vector<double> tempData; // 存储所有坐标数据
|
||
for (const auto &solid : solids)
|
||
{
|
||
tempData.insert(tempData.end(), {solid.v1[0], solid.v1[1], solid.v1[2],
|
||
solid.v2[0], solid.v2[1], solid.v2[2],
|
||
solid.v3[0], solid.v3[1], solid.v3[2]});
|
||
}
|
||
solidData["data"] = tempData;
|
||
solidData["attribute"] = "";
|
||
solidData["visible"] = solids[0].visible;
|
||
solidData["color"] = solids[0].color;
|
||
solidData["id"] = solids.empty() ? -1 : solids[0].id;
|
||
jsonOutput["geometry"]["solid"][facename] = solidData;
|
||
}
|
||
|
||
// std::ofstream outFile("D://0417.json", std::ios::out);
|
||
|
||
// if (!outFile.is_open())
|
||
// {
|
||
// return ;
|
||
// }
|
||
// outFile << jsonOutput.dump(4) ;
|
||
// outFile.close();
|
||
return;
|
||
}
|
||
|
||
void StabilityModel::ExportHullToJSON_nolhmann(nlohmann::json &jsonOutput)
|
||
{
|
||
m_mainBodyByFaceIndex.clear();
|
||
m_spaceByFaceIndex.clear();
|
||
m_appendageByFaceIndex.clear();
|
||
|
||
jsonOutput["hull"] = nlohmann::json::object();
|
||
if (m_pDataMD->m_mapAllTopoShapes.size() > 0)
|
||
{
|
||
map<int, TopoDS_Shape>::iterator it;
|
||
for (it = m_pDataMD->m_mapAllTopoShapes.begin(); it != m_pDataMD->m_mapAllTopoShapes.end(); ++it)
|
||
{
|
||
int index = it->first;
|
||
TopoDS_Shape shape = it->second;
|
||
if (ShapeTom_mainBodyByFaceIndex(index, shape) ||
|
||
ShapeTom_spaceByFaceIndex(index, shape) ||
|
||
ShapeTom_appendageByFaceIndex(index, shape))
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
for (const auto &[facename, mainbody] : m_mainBodyByFaceIndex)
|
||
{
|
||
nlohmann::json mainbodyData;
|
||
std::vector<double> tempData; // 存储所有坐标数据
|
||
for (const auto &tri : mainbody)
|
||
{
|
||
tempData.insert(tempData.end(), {tri.v1[0], tri.v1[1], tri.v1[2],
|
||
tri.v2[0], tri.v2[1], tri.v2[2],
|
||
tri.v3[0], tri.v3[1], tri.v3[2]});
|
||
}
|
||
mainbodyData["data"] = tempData;
|
||
mainbodyData["attribute"] = "";
|
||
mainbodyData["visible"] = mainbody[0].visible;
|
||
mainbodyData["color"] = mainbody[0].color;
|
||
mainbodyData["id"] = mainbody.empty() ? -1 : mainbody[0].id;
|
||
|
||
// ✅ 追加面数据
|
||
jsonOutput["hull"]["mainbody"][facename] = mainbodyData;
|
||
}
|
||
|
||
for (const auto &[facename, spaces] : m_spaceByFaceIndex)
|
||
{
|
||
nlohmann::json spaceData;
|
||
std::vector<double> tempData; // 存储所有坐标数据
|
||
for (const auto &tri : spaces)
|
||
{
|
||
tempData.insert(tempData.end(), {tri.v1[0], tri.v1[1], tri.v1[2],
|
||
tri.v2[0], tri.v2[1], tri.v2[2],
|
||
tri.v3[0], tri.v3[1], tri.v3[2]});
|
||
}
|
||
spaceData["data"] = tempData;
|
||
spaceData["attribute"] = "";
|
||
spaceData["visible"] = spaces[0].visible;
|
||
spaceData["color"] = spaces[0].color;
|
||
spaceData["id"] = spaces.empty() ? -1 : spaces[0].id;
|
||
|
||
// ✅ 追加面数据
|
||
if (spaces[0].isunit)
|
||
{
|
||
jsonOutput["hull"]["unit"][facename] = spaceData;
|
||
}
|
||
else
|
||
{
|
||
jsonOutput["hull"]["space"][facename] = spaceData;
|
||
}
|
||
}
|
||
for (const auto &[facename, appendages] : m_appendageByFaceIndex)
|
||
{
|
||
nlohmann::json appendageData;
|
||
std::vector<double> tempData; // 存储所有坐标数据
|
||
for (const auto &tri : appendages)
|
||
{
|
||
tempData.insert(tempData.end(), {tri.v1[0], tri.v1[1], tri.v1[2],
|
||
tri.v2[0], tri.v2[1], tri.v2[2],
|
||
tri.v3[0], tri.v3[1], tri.v3[2]});
|
||
}
|
||
appendageData["data"] = tempData;
|
||
appendageData["attribute"] = "";
|
||
appendageData["visible"] = appendages[0].visible;
|
||
appendageData["color"] = appendages[0].color;
|
||
appendageData["id"] = appendages.empty() ? -1 : appendages[0].id;
|
||
|
||
// ✅ 追加面数据
|
||
jsonOutput["hull"]["appendage"][facename] = appendageData;
|
||
}
|
||
// std::ofstream outFile("D://0424.json", std::ios::out);
|
||
// if (!outFile.is_open())
|
||
|
||
// {
|
||
// return jsonOutput;
|
||
// }
|
||
// outFile << jsonOutput.dump(4) ;
|
||
// outFile.close();
|
||
return;
|
||
}
|
||
std::string StabilityModel::CurveTypeToString(GeomAbs_CurveType type)
|
||
{
|
||
switch (type)
|
||
{
|
||
case GeomAbs_Line:
|
||
return "Line";
|
||
case GeomAbs_Circle:
|
||
return "Circle";
|
||
case GeomAbs_Ellipse:
|
||
return "Ellipse";
|
||
case GeomAbs_Hyperbola:
|
||
return "Hyperbola";
|
||
case GeomAbs_Parabola:
|
||
return "Parabola";
|
||
case GeomAbs_BezierCurve:
|
||
return "BezierCurve";
|
||
case GeomAbs_BSplineCurve:
|
||
return "BSplineCurve";
|
||
case GeomAbs_OtherCurve:
|
||
return "OtherCurve";
|
||
default:
|
||
return "Unknown";
|
||
}
|
||
}
|
||
|
||
void StabilityModel::saveFile(QString &savefilePath)
|
||
{
|
||
m_pDataManager->saveFile(savefilePath);
|
||
}
|
||
|
||
bool StabilityModel::create_point(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
m_eLoadDataType = XMLFile_Type_null;
|
||
|
||
int errorCode = 0;
|
||
QString strLog = "";
|
||
|
||
vector<string> commandLines = CommandStreamProcessing::SplitCommand(singlecmdstring);
|
||
|
||
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
errorCode = m_pDataManager->create_point(commandLines,strLog);
|
||
if(errorCode)
|
||
{
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
|
||
// const std::vector<int> ids = m_pDataManager->getCurrentOperationId();
|
||
// json outjson;
|
||
// outjson["geometry"] = nlohmann::json::object();
|
||
// for( auto id : ids)
|
||
// {
|
||
// update3dToJson(outjson, e_modeling_operate_POINT , id);
|
||
// }
|
||
// outJsonData = QString::fromStdString(outjson.dump(4));
|
||
|
||
outJsonData = getUpdate3dToJson();
|
||
|
||
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return true;
|
||
}
|
||
|
||
bool StabilityModel::create_line(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
m_eLoadDataType = XMLFile_Type_null;
|
||
|
||
int errorCode = 0;
|
||
QString strLog = "";
|
||
|
||
vector<string> commandLines = CommandStreamProcessing::SplitCommand(singlecmdstring);
|
||
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
errorCode = m_pDataManager->create_line(commandLines,strLog);
|
||
if(errorCode)
|
||
{
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
const std::vector<int> ids = m_pDataManager->getCurrentOperationId();
|
||
if(ids.size() < 1)
|
||
{
|
||
strLog += "创建失败" + PathUtil::getEndMark();
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
json outjson;
|
||
update3dToJson(outjson, E_GEO_3D_OBJ_TYPE_CURVE , ids[0]);
|
||
outJsonData = QString::fromStdString(outjson.dump(4));
|
||
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return true;
|
||
}
|
||
|
||
bool StabilityModel::create_surface(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
m_eLoadDataType = XMLFile_Type_null;
|
||
int errorCode = 0;
|
||
QString strLog = "";
|
||
|
||
vector<string> commandLines = CommandStreamProcessing::SplitCommand(singlecmdstring);
|
||
|
||
|
||
|
||
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
errorCode = m_pDataManager->create_surface(commandLines, strLog);
|
||
if(errorCode)
|
||
{
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
const std::vector<int> ids = m_pDataManager->getCurrentOperationId();
|
||
if(ids.size() < 1)
|
||
{
|
||
strLog += "创建失败";
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
json outjson;
|
||
update3dToJson(outjson, E_GEO_3D_OBJ_TYPE_SURFACE, ids[0]);
|
||
outJsonData = QString::fromStdString(outjson.dump(4));
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return true;
|
||
}
|
||
|
||
bool StabilityModel::create_solid(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
m_eLoadDataType = XMLFile_Type_null;
|
||
int errorCode = 0;
|
||
QString strLog = "";
|
||
|
||
vector<string> commandLines = CommandStreamProcessing::SplitCommand(singlecmdstring);
|
||
|
||
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
errorCode = m_pDataManager->create_solid(commandLines, strLog);
|
||
if(errorCode)
|
||
{
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
const std::vector<int> ids = m_pDataManager->getCurrentOperationId();
|
||
if(ids.size() < 1)
|
||
{
|
||
errorCode = 1;
|
||
strLog += "创建失败";
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
json outjson;
|
||
update3dToJson(outjson, E_GEO_3D_OBJ_TYPE_SOLID, ids[0]);
|
||
outJsonData = QString::fromStdString(outjson.dump(4));
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return true;
|
||
}
|
||
|
||
bool StabilityModel::create_Hull(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
m_eLoadDataType = XMLFile_Type_null;
|
||
QString strLog = "";
|
||
int errorCode = 0;
|
||
|
||
vector<string> commandLines = CommandStreamProcessing::SplitCommand(singlecmdstring);
|
||
|
||
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
errorCode = m_pDataManager->create_Hull(commandLines,strLog);
|
||
if(errorCode)
|
||
{
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
const std::vector<int> ids = m_pDataManager->getCurrentOperationId();
|
||
if(ids.size() < 1)
|
||
{
|
||
strLog += "创建失败" + PathUtil::getEndMark();
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
json outjson;
|
||
update3dToJson(outjson, E_GEO_3D_OBJ_TYPE_HULL, ids[0]);
|
||
outJsonData = QString::fromStdString(outjson.dump(4));
|
||
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return true;
|
||
}
|
||
bool StabilityModel::create_unit_and_space(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
m_eLoadDataType = XMLFile_Type_null;
|
||
|
||
int errorCode = 0;
|
||
QString strLog = "";
|
||
|
||
vector<string> commandLines = CommandStreamProcessing::SplitCommand(singlecmdstring);
|
||
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
errorCode = m_pDataManager->create_unit_and_space(commandLines,strLog);
|
||
if(errorCode)
|
||
{
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
const std::vector<int> ids = m_pDataManager->getCurrentOperationId();
|
||
if(ids.size() < 1)
|
||
{
|
||
strLog += "创建失败" + PathUtil::getEndMark();
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
json outjson;
|
||
update3dToJson(outjson, E_GEO_3D_OBJ_TYPE_SPACE, ids[0]);
|
||
outJsonData = QString::fromStdString(outjson.dump(4));
|
||
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return true;
|
||
}
|
||
|
||
bool StabilityModel::create_Appendage(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
m_eLoadDataType = XMLFile_Type_null;
|
||
QString strLog = "";
|
||
int errorCode = 0;
|
||
|
||
vector<string> commandLines = CommandStreamProcessing::SplitCommand(singlecmdstring);
|
||
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
|
||
|
||
errorCode = m_pDataManager->create_Appendage(commandLines, strLog);
|
||
if(errorCode)
|
||
{
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
const std::vector<int> ids = m_pDataManager->getCurrentOperationId();
|
||
if(ids.size() < 1)
|
||
{
|
||
strLog += "创建失败" + PathUtil::getEndMark();
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
|
||
json outjson;
|
||
update3dToJson(outjson, E_GEO_3D_OBJ_TYPE_APPENDAGE, ids[0]);
|
||
outJsonData = QString::fromStdString(outjson.dump(4));
|
||
|
||
strLog += PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return true;
|
||
}
|
||
|
||
void StabilityModel::from(int &errorCode, QString &outMsg, QString &data, const QString &message)
|
||
{
|
||
|
||
}
|
||
|
||
bool StabilityModel::setObjVisible(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
|
||
QString strLog = "";
|
||
int errorCode = 0;
|
||
|
||
vector<string> commandLines = CommandStreamProcessing::SplitCommand(singlecmdstring);
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
bool bRet = m_pDataManager->setObjVisible(commandLines);
|
||
if(bRet)
|
||
{
|
||
strLog += "命令执行成功" + PathUtil::getEndMark();
|
||
|
||
}
|
||
else
|
||
{
|
||
strLog += "命令执行失败" + PathUtil::getEndMark();
|
||
}
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
|
||
|
||
outJsonData = getUpdate3dToJson();
|
||
|
||
// const std::vector<int> ids = m_pDataManager->getCurrentOperationId();
|
||
// json outjson;
|
||
// outjson["geometry"] = nlohmann::json::object();
|
||
// for( auto id : ids)
|
||
// {
|
||
// e_modeling_type type = CommandStreamProcessing::getObjTypeById(id);
|
||
// update3dToJson(outjson, type , id);
|
||
// }
|
||
// outJsonData = QString::fromStdString(outjson.dump(4));
|
||
|
||
return bRet;
|
||
|
||
}
|
||
|
||
QString StabilityModel::getUpdate3dToJson(std::vector<int>& ids)
|
||
{
|
||
json outjson;
|
||
outjson["geometry"] = nlohmann::json::object();
|
||
for (auto id : ids)
|
||
{
|
||
E_GEO_3D_OBJ_TYPE type = CommandStreamProcessing::getObjTypeById(id);
|
||
update3dToJson(outjson, type, id);
|
||
}
|
||
QString outJsonData = QString::fromStdString(outjson.dump(4));
|
||
|
||
return outJsonData;
|
||
}
|
||
|
||
QString StabilityModel::getUpdate3dToJson()
|
||
{
|
||
const std::vector<int> ids = m_pDataManager->getCurrentOperationId();
|
||
|
||
json outjson;
|
||
outjson["geometry"] = nlohmann::json::object();
|
||
for( auto id : ids)
|
||
{
|
||
E_GEO_3D_OBJ_TYPE type = CommandStreamProcessing::getObjTypeById(id);
|
||
update3dToJson(outjson, type , id);
|
||
}
|
||
QString outJsonData = QString::fromStdString(outjson.dump(4));
|
||
|
||
|
||
|
||
return outJsonData;
|
||
}
|
||
|
||
QString StabilityModel::getUpdate_UI_StateJson()
|
||
{
|
||
if (!m_pDataManager)
|
||
{
|
||
return "";
|
||
}
|
||
|
||
json outjson = nlohmann::json::object();
|
||
json undo_redo_startjson = nlohmann::json::object();
|
||
undo_redo_startjson["undo"] = (int)m_pDataManager->isCanUndo();
|
||
undo_redo_startjson["redo"] = (int)m_pDataManager->isCanRedo();
|
||
|
||
outjson["cmd_update_undo_redo_ui_state"] = undo_redo_startjson;
|
||
|
||
|
||
QString outJsonData = QString::fromStdString(outjson.dump(4));
|
||
return outJsonData;
|
||
}
|
||
|
||
//bool StabilityModel::setObjVisible(int id,int value)
|
||
//{
|
||
// return m_pDataManager->setObjVisible(id,value);
|
||
//}
|
||
|
||
|
||
void StabilityModel::stab_model_editor_hydro_static(int &errorCode, QString &outMsg, QString &data, const QString &message)
|
||
{
|
||
// DataManager处理，通过
|
||
m_pDataManager->stab_model_editor_hydro_static(errorCode, outMsg, data, message);
|
||
}
|
||
|
||
void StabilityModel::stab_model_editor_tank_cap(int &errorCode, QString &outMsg, QString &data, const QString &message)
|
||
{
|
||
// DataManager处理，通过
|
||
m_pDataManager->stab_model_editor_tank_cap(errorCode, outMsg, data, message);
|
||
}
|
||
|
||
void StabilityModel::stab_model_editor_intact(int &errorCode, QString &outMsg, QString &data, const QString &message)
|
||
{
|
||
// DataManager处理，通过
|
||
m_pDataManager->stab_model_editor_intact(errorCode, outMsg, data, message);
|
||
}
|
||
|
||
void StabilityModel::stab_model_editor_allow_kg(int &errorCode, QString &outMsg, QString &data, const QString &message)
|
||
{
|
||
// DataManager处理，通过
|
||
m_pDataManager->stab_model_editor_allow_kg(errorCode, outMsg, data, message);
|
||
}
|
||
|
||
void StabilityModel::stab_model_editor_damage(int &errorCode, QString &outMsg, QString &data, const QString &message)
|
||
{
|
||
// DataManager处理，通过
|
||
m_pDataManager->stab_model_editor_damage(errorCode, outMsg, data, message);
|
||
}
|
||
|
||
void StabilityModel::stab_model_editor_damage_prob(int &errorCode, QString &outMsg, QString &data, const QString &message)
|
||
{
|
||
// DataManager处理，通过
|
||
m_pDataManager->stab_model_editor_damage_prob(errorCode, outMsg, data, message);
|
||
}
|
||
|
||
void StabilityModel::stab_model_editor_inclining(int &errorCode, QString &outMsg, QString &data, const QString &message)
|
||
{
|
||
// DataManager处理，通过
|
||
m_pDataManager->stab_model_editor_inclining(errorCode, outMsg, data, message);
|
||
}
|
||
|
||
void StabilityModel::stab_model_editor_check(int &errorCode, QString &outMsg, QString &data, const QString &message)
|
||
{
|
||
// DataManager处理，通过
|
||
m_pDataManager->stab_model_editor_check(errorCode, outMsg, data, message);
|
||
}
|
||
void StabilityModel::stab_model_editor_save(int &errorCode, QString &outMsg, QString &data, const QString &message)
|
||
{
|
||
// DataManager处理，通过
|
||
m_pDataManager->stab_model_editor_save(errorCode, outMsg, data, message);
|
||
}
|
||
|
||
void StabilityModel::InitGeometry()
|
||
{
|
||
ModelData &_modelData = m_pDataManager->getModelData();
|
||
|
||
std::vector<std::pair<int, Point3D_M>> &mPointData = _modelData.getPoint3DModel();
|
||
|
||
std::vector<std::pair<int, Curve_M>> &mCurveData = _modelData.getCurveModle();
|
||
|
||
std::vector<std::pair<int, Surface_M>> &mSurfaceData = _modelData.getSurfaces();
|
||
|
||
std::vector<std::pair<int, Solid_M>> &mSolidData = _modelData.getSolids();
|
||
// 读取完所有数据后，填充到Map里，为后续Command已有图元查找做准备
|
||
vector<Point3D> vPoint3d;
|
||
vector<Curve> vCur;
|
||
vector<Surface> vSur;
|
||
vector<Solid> vSol;
|
||
|
||
auto itPoint = mPointData.begin();
|
||
for (; itPoint != mPointData.end(); ++itPoint)
|
||
{
|
||
Point3D pd = itPoint->second.getGeoPoint();
|
||
vPoint3d.emplace_back(pd);
|
||
}
|
||
|
||
auto itCurve = mCurveData.begin();
|
||
for (; itCurve != mCurveData.end(); ++itCurve)
|
||
{
|
||
Curve cur = itCurve->second.getGeoCurve();
|
||
vCur.emplace_back(cur);
|
||
}
|
||
|
||
auto itSurface = mSurfaceData.begin();
|
||
for (; itSurface != mSurfaceData.end(); ++itSurface)
|
||
{
|
||
Surface sur = itSurface->second.getGeoSurface();
|
||
vSur.emplace_back(sur);
|
||
}
|
||
auto itSolid = mSolidData.begin();
|
||
for (; itSolid != mSolidData.end(); ++itSolid)
|
||
{
|
||
Solid sol = itSolid->second.getGeoSolid();
|
||
vSol.emplace_back(sol);
|
||
}
|
||
LOG_DEBUG("OCC InitData begin..");
|
||
OCCModeling::InitData(vPoint3d, vCur, vSur, vSol);
|
||
LOG_DEBUG("OCC InitData end..");
|
||
|
||
// auto itp = vPoint3d.begin();
|
||
// for (; itp != vPoint3d.end(); ++itp)
|
||
// {
|
||
// itp->clear();
|
||
// }
|
||
|
||
// auto itc = vCur.begin();
|
||
// for (; itc != vCur.end(); ++itc)
|
||
// {
|
||
// itc->clear();
|
||
// }
|
||
}
|
||
|
||
|
||
|
||
|
||
void StabilityModel::InitHull()
|
||
{
|
||
ModelData &_modelData = m_pDataManager->getModelData();
|
||
std::vector<std::pair<int, struct Hull_M>> m_Hulls = _modelData.getHulls();
|
||
std::vector<std::pair<int, struct Space_M>> m_Spaces = _modelData.getSpaces();
|
||
std::vector<std::pair<int, struct Appendage_M>> m_Appendages = _modelData.getAppendages();
|
||
vector<Hull> vHull;
|
||
vector<Space> vSpace;
|
||
vector<Appendage> vAppendage;
|
||
auto itH = m_Hulls.begin();
|
||
for (; itH != m_Hulls.end(); ++itH)
|
||
{
|
||
Hull hull = itH->second.getGeoHull();
|
||
vHull.emplace_back(hull);
|
||
}
|
||
auto itS = m_Spaces.begin();
|
||
for (; itS != m_Spaces.end(); ++itS)
|
||
{
|
||
Space space = itS->second.getGeoSpace();
|
||
vSpace.emplace_back(space);
|
||
}
|
||
auto itA = m_Appendages.begin();
|
||
for (; itA != m_Appendages.end(); ++itA)
|
||
{
|
||
Appendage appendage = itA->second.getGeoAppendage();
|
||
vAppendage.emplace_back(appendage);
|
||
}
|
||
LOG_DEBUG("OCC InitData HULL begin..");
|
||
OCCModeling::InitHullData(vHull, vSpace, vAppendage);
|
||
LOG_DEBUG("OCC InitData HULL end..");
|
||
}
|
||
|
||
void StabilityModel::analysis_show_tree(int &errorCode, QString &outMsg, QString &data, const QString &message)
|
||
{
|
||
// DataManager处理，通过
|
||
m_pDataManager->analysis_show_tree(errorCode, outMsg, data, message);
|
||
}
|
||
|
||
void StabilityModel::hull_show_tree(int &errorCode, QString &outMsg, QString &data, const QString &message)
|
||
{
|
||
json outjson;
|
||
ExportHullToJSON_nolhmann(outjson);
|
||
data = QString::fromStdString(outjson.dump(4));
|
||
errorCode = 0;
|
||
outMsg = "Hull tree data exported successfully.";
|
||
}
|
||
|
||
long StabilityModel::ImportIGES(const json &j)
|
||
{
|
||
long lRet = 0;
|
||
// if(j.contains("file_menu_import_iges_ok"))
|
||
// {
|
||
const json& file_menu_import_iges_ok = j;
|
||
std::string filepath = PathUtil::jsonContainsKeyToString(file_menu_import_iges_ok,"file_path");
|
||
|
||
int i_check_box_pnt = PathUtil::jsonContainsKeyToInt(file_menu_import_iges_ok,"check_box_pnt");
|
||
int i_check_box_curve = PathUtil::jsonContainsKeyToInt(file_menu_import_iges_ok,"check_box_curve");
|
||
int i_check_box_face = PathUtil::jsonContainsKeyToInt(file_menu_import_iges_ok,"check_box_face");
|
||
int i_check_box_solid = PathUtil::jsonContainsKeyToInt(file_menu_import_iges_ok,"check_box_solid");
|
||
|
||
int impType = 0;
|
||
if(i_check_box_pnt)
|
||
{
|
||
impType |= 0x01;
|
||
}
|
||
if(i_check_box_curve)
|
||
{
|
||
impType |= 0x02;
|
||
}
|
||
if(i_check_box_face)
|
||
{
|
||
impType |= 0x04;
|
||
}
|
||
|
||
double d_text_box_scale = PathUtil::jsonContainsKeyToDouble(file_menu_import_iges_ok,"text_box_scale");
|
||
double d_text_box_translate_x = PathUtil::jsonContainsKeyToDouble(file_menu_import_iges_ok,"text_box_translate_x");
|
||
double d_text_box_translate_y = PathUtil::jsonContainsKeyToDouble(file_menu_import_iges_ok,"text_box_translate_y");
|
||
double d_text_box_translate_z = PathUtil::jsonContainsKeyToDouble(file_menu_import_iges_ok,"text_box_translate_z");
|
||
|
||
double d_text_box_rotate_x = PathUtil::jsonContainsKeyToDouble(file_menu_import_iges_ok,"text_box_rotate_x");
|
||
double d_text_box_rotate_y = PathUtil::jsonContainsKeyToDouble(file_menu_import_iges_ok,"text_box_rotate_y");
|
||
double d_text_box_rotate_z = PathUtil::jsonContainsKeyToDouble(file_menu_import_iges_ok,"text_box_rotate_z");
|
||
|
||
vector<float> vTransfromParams;
|
||
// vTransfromParams.emplace_back(1);
|
||
// vTransfromParams.emplace_back(0);
|
||
// vTransfromParams.emplace_back(0);
|
||
// vTransfromParams.emplace_back(0);
|
||
// vTransfromParams.emplace_back(0);
|
||
// vTransfromParams.emplace_back(0);
|
||
// vTransfromParams.emplace_back(0);
|
||
vTransfromParams.emplace_back(d_text_box_scale);
|
||
vTransfromParams.emplace_back(d_text_box_translate_x);
|
||
vTransfromParams.emplace_back(d_text_box_translate_y);
|
||
vTransfromParams.emplace_back(d_text_box_translate_z);
|
||
vTransfromParams.emplace_back(d_text_box_rotate_x);
|
||
vTransfromParams.emplace_back(d_text_box_rotate_y);
|
||
vTransfromParams.emplace_back(d_text_box_rotate_z);
|
||
|
||
int i_radio_button_add = PathUtil::jsonContainsKeyToDouble(file_menu_import_iges_ok,"radio_button_add");
|
||
|
||
// std::string filepath = "D:/内河/内河2025/COMPASS2023/bin/Data/XF/40.igs";
|
||
// int impType = 7;
|
||
// int i_radio_button_add = 1;
|
||
|
||
lRet = ImportIGES(filepath,impType,vTransfromParams,(bool)i_radio_button_add);
|
||
|
||
//}
|
||
|
||
return lRet;
|
||
}
|
||
|
||
long StabilityModel::ImportIGES(std::string fileName, int impType, vector<float> vTransfromParams, bool bIsAddMode)
|
||
{
|
||
if (vTransfromParams.size() != 7)
|
||
{
|
||
return 0;
|
||
}
|
||
m_eLoadDataType = XMLFile_Type_iges;
|
||
const char *cstr = fileName.c_str(); // 返回 const char*
|
||
// 如果需要 char*，可以做一个复制
|
||
char *modifiableCStr = new char[fileName.length() + 1];
|
||
std::strcpy(modifiableCStr, cstr); // 复制内容到新的 char* 数组
|
||
|
||
OCCModeling::ReInitData();
|
||
float transfromParams[7] = {0};
|
||
transfromParams[0] = vTransfromParams[0];
|
||
transfromParams[1] = vTransfromParams[1];
|
||
transfromParams[2] = vTransfromParams[2];
|
||
transfromParams[3] = vTransfromParams[3];
|
||
transfromParams[4] = vTransfromParams[4];
|
||
transfromParams[5] = vTransfromParams[5];
|
||
transfromParams[6] = vTransfromParams[6];
|
||
|
||
long ret = OCCModeling::ImportIGES(modifiableCStr, impType, transfromParams);
|
||
|
||
delete[] modifiableCStr;
|
||
|
||
return ret;
|
||
}
|
||
|
||
void StabilityModel::ExportIGES(const json &j)
|
||
{
|
||
long lRet = 0;
|
||
// if (j.contains("file_menu_export_iges_ok"))
|
||
// {
|
||
|
||
const json &file_menu_export_iges_ok = j;
|
||
std::string fileName = PathUtil::jsonContainsKeyToString(file_menu_export_iges_ok, "file_path");
|
||
|
||
int i_check_box_pnt = PathUtil::jsonContainsKeyToInt(file_menu_export_iges_ok, "check_box_pnt");
|
||
int i_check_box_curve = PathUtil::jsonContainsKeyToInt(file_menu_export_iges_ok, "check_box_curve");
|
||
int i_check_box_face = PathUtil::jsonContainsKeyToInt(file_menu_export_iges_ok, "check_box_face");
|
||
int i_check_box_solid = PathUtil::jsonContainsKeyToInt(file_menu_export_iges_ok, "check_box_solid");
|
||
|
||
int i_radio_button = PathUtil::jsonContainsKeyToInt(file_menu_export_iges_ok, "radio_button");
|
||
|
||
int i_selectedCnt = 3;//PathUtil::jsonContainsKeyToInt(file_menu_export_iges_ok, "selected_cnt");
|
||
|
||
int expOpt = 0x00;
|
||
if (i_check_box_pnt)
|
||
{
|
||
expOpt |= 0x01;
|
||
}
|
||
if (i_check_box_curve)
|
||
{
|
||
expOpt |= 0x02;
|
||
}
|
||
if (i_check_box_face)
|
||
{
|
||
expOpt |= 0x04;
|
||
}
|
||
if (i_check_box_solid)
|
||
{
|
||
expOpt |= 0x08;
|
||
}
|
||
|
||
if (i_radio_button == 0)
|
||
{
|
||
expOpt |= 0x10;
|
||
}
|
||
else if (i_radio_button == 1)
|
||
{
|
||
expOpt |= 0x20;
|
||
}
|
||
else if (i_radio_button == 2)
|
||
{
|
||
expOpt |= 0x40;
|
||
}
|
||
|
||
int *selectLst = new int[i_selectedCnt];
|
||
const json &selectIDs = file_menu_export_iges_ok["selectIDs"];
|
||
if (selectIDs.is_array() && i_selectedCnt == selectIDs.size())
|
||
{
|
||
int ik = 0;
|
||
for (const auto &id : selectIDs)
|
||
{
|
||
selectLst[ik] = id;
|
||
}
|
||
}
|
||
|
||
const char *cstr = fileName.c_str(); // 返回 const char*
|
||
// 如果需要 char*，可以做一个复制
|
||
char *modifiableCStr = new char[fileName.length() + 1];
|
||
std::strcpy(modifiableCStr, cstr); // 复制内容到新的 char* 数组
|
||
OCCModeling::ExportIGES(modifiableCStr, expOpt, i_selectedCnt, selectLst);
|
||
|
||
delete[] modifiableCStr;
|
||
delete[] selectLst;
|
||
|
||
//}
|
||
}
|
||
|
||
void StabilityModel::ImportDXF(QString filePath)
|
||
{
|
||
long lRet = 0;
|
||
m_eLoadDataType = XMLFile_Type_dxf;
|
||
QByteArray byteArray = filePath.toUtf8(); // 将QString转换为UTF-8的QByteArray
|
||
const char* constCharPtr = byteArray.constData(); // 获取常量指针
|
||
|
||
// 如果你需要一个非const的char*，你可以复制数据到一个新的数组中
|
||
char* charPtr = new char[byteArray.size() + 1]; // 为null结尾符号分配空间
|
||
std::strcpy(charPtr, constCharPtr); // 复制数据
|
||
|
||
OCCModeling::ImportCAD(charPtr);
|
||
int a = 0;
|
||
delete[] charPtr;
|
||
}
|
||
|
||
bool StabilityModel::cmd_copy(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
// 适用对象:ALL
|
||
int errorCode = 0;
|
||
QString strLog = "";
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
errorCode = m_pDataManager->cmd_copy(singlecmdstring,strLog);
|
||
if(errorCode)
|
||
{
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
const std::vector<int> ids = m_pDataManager->getCurrentOperationId();
|
||
if(ids.size() < 1)
|
||
{
|
||
strLog += "创建失败" + PathUtil::getEndMark();
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
outJsonData = getUpdate3dToJson();
|
||
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
|
||
return true;
|
||
}
|
||
bool StabilityModel::cmd_trim(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
// 适用对象：线、面
|
||
int errorCode = 0;
|
||
QString strLog = "";
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
errorCode = m_pDataManager->cmd_trim(singlecmdstring,strLog);
|
||
if(errorCode)
|
||
{
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
outJsonData = getUpdate3dToJson();
|
||
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
|
||
return true;
|
||
}
|
||
bool StabilityModel::cmd_mirror(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
// 适用对象：所有图元
|
||
int errorCode = 0;
|
||
QString strLog = "";
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
errorCode = m_pDataManager->cmd_mirror(singlecmdstring,strLog);
|
||
if(errorCode)
|
||
{
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
outJsonData = getUpdate3dToJson();
|
||
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
|
||
return true;
|
||
}
|
||
bool StabilityModel::cmd_intersection(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
// 适用对象：面
|
||
int errorCode = 0;
|
||
QString strLog = "";
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
errorCode = m_pDataManager->cmd_intersection(singlecmdstring,strLog);
|
||
if(errorCode)
|
||
{
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
outJsonData = getUpdate3dToJson();
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return true;
|
||
}
|
||
bool StabilityModel::cmd_join(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
// 适用对象：线、面
|
||
int errorCode = 0;
|
||
QString strLog = "";
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
m_pDataManager->cmd_join(singlecmdstring,strLog);
|
||
if(errorCode)
|
||
{
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
outJsonData = getUpdate3dToJson();
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return true;
|
||
}
|
||
bool StabilityModel::cmd_delete(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
// 适用对象：所有图元
|
||
int id = -1;
|
||
int type = 0;
|
||
int errorCode = 0;
|
||
QString strLog = "";
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
std::vector<std::string> vDeleteObjName;
|
||
errorCode = m_pDataManager->cmd_delete(singlecmdstring,strLog,vDeleteObjName);
|
||
if(errorCode)
|
||
{
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
outJsonData = updateDelete3dToJson(vDeleteObjName);
|
||
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return true;
|
||
}
|
||
|
||
//bool StabilityModel::cmd_delete(std::string& singlecmdstring, QString& outJsonData)
|
||
|
||
|
||
|
||
|
||
bool StabilityModel::cmd_tool_show_obj_command(std::string& singlecmdstring, QString &outJsonData)
|
||
{
|
||
int errorCode = 0;
|
||
QString strLog = "";
|
||
strLog +=QString::fromStdString(singlecmdstring);
|
||
|
||
errorCode = m_pDataManager->cmd_tool_show_obj_command(singlecmdstring,strLog);
|
||
if(errorCode)
|
||
{
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return false;
|
||
}
|
||
|
||
strLog +="命令执行成功" + PathUtil::getEndMark();
|
||
strLog +=PathUtil::getLogEndLine();
|
||
addShowWindowsLog(strLog);
|
||
return true;
|
||
|
||
}
|
||
bool StabilityModel::Menu_toolbar_show_obj_infor_XYZ(std::vector<string>& ids,QString& outStr ) //获取obj XYZ infor
|
||
{
|
||
if(ids.size() == 0)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
QString strcmd = "";
|
||
|
||
for (size_t i = 0; i < ids.size(); i++)
|
||
{
|
||
std::string obName = ids[i];
|
||
|
||
|
||
IModel *pObj = DataManager::GetObjectByName(obName);
|
||
if (!pObj)
|
||
{
|
||
continue;
|
||
}
|
||
if(pObj->GetCommand().isEmpty())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
int objid = pObj->GetID();
|
||
|
||
strcmd += pObj->GetName() + PathUtil::getEndMark();
|
||
|
||
// 分割命令行
|
||
QString allCommandLine = pObj->GetCommand().trimmed();
|
||
|
||
QStringList commandLines = allCommandLine.split(PathUtil::getEndMark());
|
||
if(commandLines.size() < 2)
|
||
{
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
QString SSS = commandLines[1];
|
||
QString command = commandLines[1].trimmed(); // 使用 trimmed() 去除空格
|
||
// 查找空格的位置
|
||
int index = command.indexOf(' ');
|
||
if (index == -1)
|
||
{
|
||
|
||
}
|
||
else
|
||
{
|
||
|
||
QString ss = commandLines[1].left(index); // Extract substring
|
||
ss = ss.toUpper(); // Convert to uppercase
|
||
|
||
QString tmp = "";
|
||
QString tmpPos = "";
|
||
QString commandFirstLine = commandLines[0];
|
||
commandFirstLine = commandFirstLine.toUpper(); // Convert to uppercase
|
||
|
||
if (commandFirstLine.startsWith("POINT"))
|
||
{
|
||
// Point3D p = GetPointByID(1); // Replace with real logic for point retrieval
|
||
if(pObj->getObjType() == E_GEO_3D_OBJ_TYPE_POINT3D)
|
||
{
|
||
Point3D_M* p = (Point3D_M*)pObj;
|
||
tmp += QString::number(p->m_X) + "," + QString::number(p->m_Y) + "," + QString::number(p->m_Z) + PathUtil::getEndMark();
|
||
}
|
||
|
||
}
|
||
else if (commandFirstLine.startsWith("CURVE") || commandFirstLine.startsWith("ELLIPSE") || commandFirstLine.startsWith("PARABOLA"))
|
||
{
|
||
Curve_M* crv = (Curve_M*)pObj;;
|
||
|
||
if (ss == "X")
|
||
{
|
||
for (size_t ii = 0; ii < crv->m_KnotID.size(); ii++)
|
||
{
|
||
if (crv->m_KnotID[ii] != 0)
|
||
{
|
||
Point3D_M *p = (Point3D_M*)DataManager::GetObjectByID(crv->m_KnotID[ii]);
|
||
if(!p)
|
||
{
|
||
continue;
|
||
}
|
||
tmpPos = ss + " " + QString::number(p->m_X) + PathUtil::getEndMark();
|
||
tmp += QString::number(ii + 1) + " " + QString::number(p->m_Y) + "," + QString::number(p->m_Z) + PathUtil::getEndMark();
|
||
}
|
||
}
|
||
}
|
||
else if (ss == "Y")
|
||
{
|
||
for (size_t ii = 0; ii < crv->m_KnotID.size(); ii++)
|
||
{
|
||
if (crv->m_KnotID[ii] != 0)
|
||
{
|
||
//Point3D p = GetPointByID(crv.KnotID[ii]);
|
||
Point3D_M *p = (Point3D_M*)DataManager::GetObjectByID(crv->m_KnotID[ii]);
|
||
if(!p)
|
||
{
|
||
continue;
|
||
}
|
||
tmpPos = ss + " " + QString::number(p->m_Y) + PathUtil::getEndMark();
|
||
tmp += QString::number(ii + 1) + " " + QString::number(p->m_X) + "," + QString::number(p->m_Z) + PathUtil::getEndMark();
|
||
}
|
||
}
|
||
}
|
||
else if (ss == "Z")
|
||
{
|
||
for (size_t ii = 0; ii < crv->m_KnotID.size(); ii++)
|
||
{
|
||
if (crv->m_KnotID[ii] != 0)
|
||
{
|
||
// Point3D p = GetPointByID(crv.KnotID[ii]);
|
||
Point3D_M *p = (Point3D_M*)DataManager::GetObjectByID(crv->m_KnotID[ii]);
|
||
if(!p)
|
||
{
|
||
continue;
|
||
}
|
||
tmpPos = ss + " " + QString::number(p->m_Z) + PathUtil::getEndMark();
|
||
tmp += QString::number(ii + 1) + " " + QString::number(p->m_X) + "," + QString::number(p->m_Y) + PathUtil::getEndMark();
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (size_t ii = 0; ii < crv->m_KnotID.size(); ii++)
|
||
{
|
||
if (crv->m_KnotID[ii] != 0)
|
||
{
|
||
//Point3D p = GetPointByID(crv.KnotID[ii]);
|
||
Point3D_M *p = (Point3D_M*)DataManager::GetObjectByID(crv->m_KnotID[ii]);
|
||
if(!p)
|
||
{
|
||
continue;
|
||
}
|
||
tmp += QString::number(ii + 1) + " " + QString::number(p->m_X) + "," + QString::number(p->m_Y) + "," + QString::number(p->m_Z) + PathUtil::getEndMark();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
vector<Point3D> pointList = DataManager::GetCurvePointByFSEx(objid, 3);
|
||
//QVector<Point3D> pointList; // Replace with real logic to get points
|
||
if (pointList.size() < 2)
|
||
{
|
||
|
||
}
|
||
else
|
||
{
|
||
tmp += "1 " + QString::number(pointList[0].X) + "," + QString::number(pointList[0].Y) + "," + QString::number(pointList[0].Z) + "\r\n";
|
||
tmp += "2 " + QString::number(pointList[pointList.size() - 1].X) + "," + QString::number(pointList[pointList.size() - 1].Y) + "," + QString::number(pointList[pointList.size() - 1].Z) + "\r\n";
|
||
}
|
||
|
||
}
|
||
|
||
strcmd += tmpPos;
|
||
strcmd += tmp;
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
if(!strcmd.isEmpty())
|
||
{
|
||
QString retStr = strcmd + PathUtil::getLogEndLine();
|
||
m_pDataManager->addShowWindowsLog(retStr);
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
|
||
}
|
||
|
||
bool StabilityModel::cmd_tool_show_curve_rib_crd(std::vector<string>& ids,bool isShowCoordF,QString& outStr )
|
||
{
|
||
if(ids.size() == 0)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
std::set<int> curve_ids;
|
||
for (size_t i = 0; i < ids.size(); i++)
|
||
{
|
||
std::string objName = ids[i];
|
||
IModel *pObj = DataManager::GetObjectByName(objName);
|
||
if (!pObj)
|
||
{
|
||
continue;
|
||
}
|
||
if(E_GEO_3D_OBJ_TYPE_CURVE == pObj->getObjType())
|
||
{
|
||
curve_ids.insert(pObj->GetID());
|
||
}
|
||
}
|
||
|
||
QString cmd = "";
|
||
//int count = 0;
|
||
for(auto id_tmp :curve_ids)
|
||
{
|
||
IModel *pObj = DataManager::GetObjectByID(id_tmp);
|
||
if (!pObj)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
|
||
cmd += pObj->GetName() + PathUtil::getEndMark();
|
||
string tmp = "";
|
||
vector<Point3D> pointList;
|
||
if (isShowCoordF)
|
||
{
|
||
pointList =DataManager::GetCurvePointByFSEx(id_tmp, 1);
|
||
}
|
||
else
|
||
{
|
||
pointList =DataManager::GetCurvePointByFSEx(id_tmp, 2);
|
||
}
|
||
for (int ii = 0; ii < pointList.size(); ii++)
|
||
{
|
||
Point3D& p = pointList[ii];
|
||
|
||
|
||
if (ii == 0 || ii == (int)pointList.size() - 1)
|
||
{
|
||
if (isShowCoordF)
|
||
{
|
||
tmp += "(" + StringHelper::tostring_fix(p.X,4) + "," + StringHelper::tostring_fix(p.Y,4) + "," + StringHelper::tostring_fix(p.Z,4) + ")" + PathUtil::getEndMark().toStdString();
|
||
}
|
||
else
|
||
{
|
||
tmp += "(" + StringHelper::tostring_fix(p.X,4) + "," + StringHelper::tostring_fix(p.Y,4) + "," + StringHelper::tostring_fix(p.Z,4) + ")" + PathUtil::getEndMark().toStdString();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (isShowCoordF)
|
||
{
|
||
tmp += "(" + ChangeFSPos::ShowF(::to_string(p.X)) + "," + StringHelper::tostring_fix(p.Y,4) + "," + StringHelper::tostring_fix(p.Z,4) + ")" + PathUtil::getEndMark().toStdString();
|
||
}
|
||
else
|
||
{
|
||
tmp += "(" + ChangeFSPos::ShowS(::to_string(p.X)) + "," + StringHelper::tostring_fix(p.Y,4) + "," + StringHelper::tostring_fix(p.Z,4) + ")" + PathUtil::getEndMark().toStdString();
|
||
}
|
||
}
|
||
}
|
||
cmd += QString::fromStdString(tmp);
|
||
//count++;
|
||
}
|
||
if (curve_ids.size() == 0)
|
||
{
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
QString retStr = cmd + PathUtil::getLogEndLine();
|
||
m_pDataManager->addShowWindowsLog(retStr);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
void StabilityModel::push_undo_redo_data(int icommandid, std::vector<IModel*>& data)
|
||
{
|
||
m_pDataManager->push_undo_redo_data(icommandid, data);
|
||
|
||
}
|
||
void StabilityModel::cmd_undo(QString& strDeleteJson, QString& strChangeJson)
|
||
{
|
||
bool isCanUndo = false;
|
||
bool isCanRedo = false;
|
||
std::vector<string> disCardObjsName;
|
||
std::vector<int> changesObjsID;
|
||
m_pDataManager->cmd_undo(disCardObjsName, changesObjsID,isCanUndo, isCanRedo);
|
||
|
||
if (disCardObjsName.size() > 0)
|
||
{
|
||
strDeleteJson = updateDelete3dToJson(disCardObjsName);
|
||
}
|
||
|
||
if (changesObjsID.size() > 0)
|
||
{
|
||
strChangeJson = getUpdate3dToJson(changesObjsID);
|
||
}
|
||
}
|
||
void StabilityModel::cmd_redo(QString& strDeleteJson, QString& strChangeJson)
|
||
{
|
||
bool isCanUndo = false;
|
||
bool isCanRedo = false;
|
||
std::vector<string> disCardObjsName;
|
||
std::vector<int> changesObjsID;
|
||
m_pDataManager->cmd_redo(disCardObjsName, changesObjsID, isCanUndo, isCanRedo);
|
||
if (disCardObjsName.size() > 0)
|
||
{
|
||
strDeleteJson = updateDelete3dToJson(disCardObjsName);
|
||
}
|
||
|
||
if (changesObjsID.size() > 0)
|
||
{
|
||
strChangeJson = getUpdate3dToJson(changesObjsID);
|
||
}
|
||
|
||
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|