panda
/
COMPASSi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
COMPASSi/trunk/code/projects/DataManager/Logic/Logic.DataManagement/Interpreters/ObjectInterpreter.cpp

1934 lines
60 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#include "ObjectInterpreter.h"
#include "../Infrastructure.Interface/Arithmetics/ChangeFSPos.h"
#include <regex>
#include <stdexcept>
#include <typeinfo>
#include "DataManager.h"
#include "Constants.h"
#include <QList>
#include "DllImportOccModeling.h"
#include "Geometry.h"
ObjectInterpreter::ObjectInterpreter()
{
}
void ObjectInterpreter::ExecuteCommand(std::vector<std::string> &commandLines)
{
}
int ObjectInterpreter::ParseBoolSymbolFromName(std::string &objName)
{
// // protected int PareseSolidName(ref string solidname)
int solidandtype = 0;
if(StringHelper::startsWith(objName,"+"))
{
objName = objName.substr(1);
}
else if (StringHelper::startsWith(objName,"-"))
{
// solidandtype = 1;
objName = objName.substr(1);
solidandtype = 1;
}
else if (StringHelper::startsWith(objName,"*"))
{
// solidandtype = 2;
objName = objName.substr(1);
solidandtype = 2;
}
if (!ValidSyntaxOfName(objName)) // 20170801 新增 by czb
{
throw std::runtime_error("名称不合法,请检查是否包含关键字等!");
}
return solidandtype;
}
bool ObjectInterpreter::ParseName(IModel& o, std::string &objName, const std::string &commandLine)
{
id2DelOrReplace = -1;
genNewID = false;
int renameSrcID = -1;
std::vector<std::string> lineName = StringHelper::GetWords(commandLine); // 20180320 modified by czb //.toUpper().GetWords();
std::string name = "";
if (lineName.size() < 2)
{
{
// // 生成名称流水号 add by yangchen 20151119
int i = 0;
while (true)
{
// // 反复生成默认名称,直到不存在重名
name = GenerateObjectName(o) + std::to_string(++i);
id2DelOrReplace = FindIDByName(name, true,typeid(o).name(), false);
// int id2DelOrReplace1 = FindIDByNameFromInteract(name, true, o->GetType(), false);
if (id2DelOrReplace == -1)
{
objName = name;
return true;
}
}
}
}
else
{
name = lineName[1];
// // 名称合法性验证,例如关键字冲突等
if (!ValidSyntaxOfName(name)) // 20170801 新增 by czb
{
throw std::runtime_error("名称不合法,请检查是否包含关键字等!");
}
id2DelOrReplace = FindIDByName(name, true, typeid(o).name(), false);
if (id2DelOrReplace == -2)
{
// // 重名图元不可被替换
return false;
}
else if (id2DelOrReplace == -1)
{
// // 无重名图元,名称可以使用
if (renameSrcID != -1)
{
id2DelOrReplace = renameSrcID;
}
}
else
{
// if (renameSrcID != -1)
// {
// throw ErrorSyntaxException("存在不可替换的重名图元:" + name);
// }
// else
// {
// std::string stp = DataDictionary::TypeNameCnDic[Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().GetObjectByID(id2DelOrReplace)->GetType()];
// if (AppSetting::Default->SameNameRule == 0) // 更新
// {
// //
// if (!o->GetType()->Equals(Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().GetObjectByID(id2DelOrReplace)->GetType()))
// {
// throw ErrorSyntaxException("指定的对象名称" + name + "相同，但不是同一类型的对象，无法更新");
// }
// }
// else if (AppSetting::Default->SameNameRule == 1) // 放弃
// {
// throw ErrorSyntaxException("命令放弃执行.\r\n存在重名图元:" + stp + "\"" + name + "\"" + "\r\n");
// }
// else if (AppSetting::Default->SameNameRule == 2) // 询问
// {
// // string strtext = "存在重名图元:" + stp + "\"" + name + "\",确定要覆盖吗?";
// // strtext += "\r" + "\r" + "如不需要重名弹窗提示，可在“工具”-“选项”-“系统设置”将“同名规则”设置为“更新对象”"; //cqr-20210304 增加提示
// // cqr-20210416 修改为在弹窗可直接设置同名规则
// std::string strtext = "存在重名图元:" + stp + "\"" + name + "\",是否要覆盖?";
// strtext += "\r" + "\r" + "如不需要重名弹窗提示，可点击“取消”设置为“直接覆盖，不再弹窗”";
// std::shared_ptr<DialogResult> dr = MessageBox::Show(strtext, "图元重名", MessageBoxButtons::YesNoCancel, MessageBoxIcon::Warning, MessageBoxDefaultButton::Button3, MessageBoxOptions::ServiceNotification);
// if (dr == DialogResult::No) // cqr-20210416
// {
// throw ErrorSyntaxException("命令放弃执行.\r\n存在重名图元:" + stp + "\"" + name + "\"" + "\r\n");
// }
// else
// {
// if (!o->GetType()->Equals(Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().GetObjectByID(id2DelOrReplace)->GetType()))
// {
// throw ErrorSyntaxException("指定的对象名称" + name + "相同，但不是同一类型的对象，无法更新");
// }
// if (dr == DialogResult::Cancel) // cqr-20210416
// {
// AppSetting::Default->SameNameRule = 0; // 同名规则为更新
// }
// }
// }
// }
}
// // 无重名图元或重名图元可被替换
objName = name;
return true;
}
}
bool ObjectInterpreter::ParseInputName(IModel &o, std::string &objName, const std::string &inputName)
{
id2DelOrReplace = -1;
genNewID = false;
int renameSrcID = -1;
std::string name = "";
if (inputName.empty() || StringHelper::trim(inputName) == "")
{
////// 未指定名称
// 生成名称流水号
int i = 0;
while (true)
{
// 反复生成默认名称,直到不存在重名
name = GenerateObjectName(o) + std::to_string(++i);
id2DelOrReplace = FindIDByName(name, true, typeid(o).name(), false);
// int id2DelOrReplace1 = FindIDByNameFromInteract(name, true, o.GetType(), false);
if (id2DelOrReplace == -1)
{
objName = name;
return true;
}
}
}
else
{
//// 指定名称
name = inputName;
// 名称合法性验证,例如关键字冲突等
if (!ValidSyntaxOfName(name))
{
throw std::runtime_error("名称不合法:" + name);
}
id2DelOrReplace = FindIDByName(name, true, typeid(o).name());
if (id2DelOrReplace == -2)
{
// 重名图元不可被替换
return false;
}
else if (id2DelOrReplace == -1)
{
// 无重名图元,名称可以使用
if (renameSrcID != -1)
{
id2DelOrReplace = renameSrcID;
}
}
// else
// {
// //// 有重名图元,则不可重命名
// if (renameSrcID != -1)
// {
// throw std::runtime_error("存在不可替换的重名图元:" + name);
// }
// else
// {
// std::string stp = TypeNameCn[typeid(DataManager::GetObjectByID(id2DelOrReplace)).name()];
// if (AppSetting::Default->SameNameRule == 0) // 更新
// {
// if (!o->GetType()->Equals(Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().GetObjectByID(id2DelOrReplace)->GetType()))
// {
// throw std::runtime_error("指定的对象名称" + name + "相同，但不是同一类型的对象，无法更新");
// }
// }
// else if (AppSetting::Default->SameNameRule == 1) // 放弃
// {
// throw std::runtime_error("命令放弃执行.\r\n存在重名图元:" + stp + "\"" + name + "\"" + "\r\n");
// }
// else if (AppSetting::Default->SameNameRule == 2) // 询问
// {
// // string strtext = "存在重名图元:" + stp + "\"" + name + "\",确定要覆盖吗?";
// // strtext += "\r" + "\r" + "如不需要重名弹窗提示，可在“工具”-“选项”-“系统设置”将“同名规则”设置为“更新对象”"; //cqr-20210304 增加提示
// // cqr-20210416 修改为在弹窗可直接设置同名规则
// std::string strtext = "存在重名图元:" + stp + "\"" + name + "\",是否要覆盖?";
// strtext += "\r" + "\r" + "如不需要重名弹窗提示，可点击“取消”设置为“直接覆盖，不再弹窗”";
// std::shared_ptr<DialogResult> dr = MessageBox::Show(strtext, "图元重名", MessageBoxButtons::YesNoCancel, MessageBoxIcon::Warning, MessageBoxDefaultButton::Button3, MessageBoxOptions::ServiceNotification);
// if (dr == DialogResult::No) // cqr-20210416
// {
// throw ErrorSyntaxException("命令放弃执行.\r\n存在重名图元:" + stp + "\"" + name + "\"" + "\r\n");
// }
// else
// {
// if (!o->GetType()->Equals(Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().GetObjectByID(id2DelOrReplace)->GetType()))
// {
// throw ErrorSyntaxException("指定的对象名称" + name + "相同，但不是同一类型的对象，无法更新");
// }
// if (dr == DialogResult::Cancel) // cqr-20210416
// {
// AppSetting::Default->SameNameRule = 0; // 同名规则为更新
// }
// }
// }
// }
// }
// 无重名图元或重名图元可被替换
objName = name;
return true;
}
}
bool ObjectInterpreter::ParseInputName(std::string &objName, const std::string &inputName)
{
id2DelOrReplace = -1;
genNewID = false;
int renameSrcID = -1;
std::string name;
name = inputName;
// 名称合法性验证
if (!ValidSyntaxOfName(name))
{
throw std::runtime_error("名称不合法:" + name);
}
id2DelOrReplace = FindIDByName(name); // 查找是否存在相同名称
if (id2DelOrReplace == -2)
{
// 重名图元不可被替换
return false;
}
else if (id2DelOrReplace == -1)
{
// 无重名图元,名称可以使用
if (renameSrcID != -1)
{
id2DelOrReplace = renameSrcID;
}
}
// else
// {
// if (renameSrcID != -1)
// {
// throw ErrorSyntaxException("存在不可替换的重名图元:" + name);
// }
// else
// {
// std::string stp = DataDictionary::TypeNameCnDic[Global::RootWorkItem->GetObjectByID(id2DelOrReplace)];
// if (AppSetting::SameNameRule == 0)
// { // 更新
// // 更新逻辑，暂无操作
// }
// else if (AppSetting::SameNameRule == 1)
// { // 放弃
// throw ErrorSyntaxException("命令放弃执行.\n存在重名图元:" + stp + "\"" + name + "\"\n");
// }
// else if (AppSetting::SameNameRule == 2)
// { // 询问
// std::string strtext = "存在重名图元:" + stp + "\"" + name + "\",是否要覆盖?\n\n";
// strtext += "如不需要重名弹窗提示，可点击“取消”设置为“直接覆盖，不再弹窗”";
// DialogResult dr = MessageBox(strtext, "图元重名");
// if (dr == DialogResult::No)
// {
// throw ErrorSyntaxException("命令放弃执行.\n存在重名图元:" + stp + "\"" + name + "\"\n");
// }
// else if (dr == DialogResult::Cancel)
// {
// AppSetting::SameNameRule = 0; // 更新规则
// }
// }
// }
//}
// 无重名图元或可替换图元
objName = name;
return true;
}
bool ObjectInterpreter::ValidSyntaxOfName(const std::string& objName) {
if (objName.empty()) return false;
// 正则表达式匹配
std::regex regexPattern(R"(^[A-Za-z][A-Za-z0-9-_.]*$)");
if (!std::regex_match(objName, regexPattern)) {
return false;
}
std::string upperName = StringHelper::toUpper(objName); // 将字符串转换为大写;
if( std::find(CommandKeyWords.begin(), CommandKeyWords.end(), upperName) != CommandKeyWords.end())
{
return false;
}
return true;
}
// bool ObjectInterpreter::ParseInputName(std::string &objName, const std::string &inputName)
// {
// id2DelOrReplace = -1;
// genNewID = false;
// int renameSrcID = -1;
// std::string name = "";
// {
// //// 指定名称
// name = inputName;
// // 名称合法性验证,例如关键字冲突等
// if (!Statics::ValidSyntaxOfName(name))
// {
// throw NameSyntaxErrorException();
// }
// id2DelOrReplace = FindIDByName(name); //???存疑，有可能覆盖原有对象，并且不检查被覆盖的对象类型是否相同
// if (id2DelOrReplace == -2)
// {
// // 重名图元不可被替换
// return false;
// }
// else if (id2DelOrReplace == -1)
// {
// // 无重名图元,名称可以使用
// if (renameSrcID != -1)
// {
// id2DelOrReplace = renameSrcID;
// }
// }
// else
// {
// //// 有重名图元,则不可重命名
// if (renameSrcID != -1)
// {
// throw ErrorSyntaxException("存在不可替换的重名图元:" + name);
// }
// else
// {
// std::string stp = DataDictionary::TypeNameCnDic[Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().GetObjectByID(id2DelOrReplace)->GetType()];
// if (AppSetting::Default->SameNameRule == 0) // 更新
// {
// }
// else if (AppSetting::Default->SameNameRule == 1) // 放弃
// {
// throw ErrorSyntaxException("命令放弃执行.\r\n存在重名图元:" + stp + "\"" + name + "\"" + "\r\n");
// }
// else if (AppSetting::Default->SameNameRule == 2) // 询问
// {
// // string strtext = "存在重名图元:" + stp + "\"" + name + "\",确定要覆盖吗?";
// // strtext += "\r" + "\r" + "如不需要重名弹窗提示，可在“工具”-“选项”-“系统设置”将“同名规则”设置为“更新对象”"; //cqr-20210304 增加提示
// // DialogResult dr = MessageBox.Show(strtext, "图元重名", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button3, MessageBoxOptions.ServiceNotification);
// // cqr-20210416 修改为在弹窗可直接设置同名规则
// std::string strtext = "存在重名图元:" + stp + "\"" + name + "\",是否要覆盖?";
// strtext += "\r" + "\r" + "如不需要重名弹窗提示，可点击“取消”设置为“直接覆盖，不再弹窗”";
// std::shared_ptr<DialogResult> dr = MessageBox::Show(strtext, "图元重名", MessageBoxButtons::YesNoCancel, MessageBoxIcon::Warning, MessageBoxDefaultButton::Button3, MessageBoxOptions::ServiceNotification);
// if (dr == DialogResult::No) // cqr-20210416
// {
// throw ErrorSyntaxException("命令放弃执行.\r\n存在重名图元:" + stp + "\"" + name + "\"" + "\r\n");
// }
// else
// {
// if (dr == DialogResult::Cancel) // cqr-20210416
// {
// AppSetting::Default->SameNameRule = 0; // 同名规则为更新
// }
// }
// // if (dr == DialogResult.Cancel)
// //{
// // throw new ErrorSyntaxException("命令放弃执行.\r\n存在重名图元:" + stp + "\"" + name + "\"" + "\r\n");
// // }
// // else
// //{
// // }
// }
// }
// }
// // 无重名图元或重名图元可被替换
// objName = name;
// return true;
// }
// }
std::string ObjectInterpreter::ParseNameMirror(IModel *o, const std::string &commandLine)
{
id2DelOrReplace = -1;
genNewID = false;
int renameSrcID = -1;
std::vector<std::string> lineName = StringHelper::GetWords(commandLine);
std::vector<std::string> lineNameU = StringHelper::GetWords(StringHelper::toUpper(commandLine));
if (std::find(lineNameU.begin(), lineNameU.end(), "RENAME") != lineNameU.end())
{
auto it = std::find(lineNameU.begin(), lineNameU.end(), "RENAME");
size_t idx = std::distance(lineNameU.begin(), it);
if (idx == lineName.size() - 1)
{
throw std::runtime_error("参数错误！");
}
std::string srenameSrc = lineName[idx + 1];
renameSrcID = DataManager::GetObjectIDByName(srenameSrc);
if (renameSrcID == -1)
{
throw std::runtime_error("未找到对象：" + srenameSrc);
}
}
std::string name;
if (lineName.size() < 2)
{
// 未指定名称
if (typeid(*o) == typeid(Hull))
{
name = ParseNameHull();
}
else
{
name = ParseNameSuffix(o, "_M");
}
}
else
{
// 指定名称
name = lineName[1];
// 名称合法性验证
if (!ValidSyntaxOfName(name))
{
throw std::runtime_error("名称语法错误！");
}
id2DelOrReplace = FindIDByName(name, true, typeid(*o).name());
if (id2DelOrReplace == -2)
{
throw std::runtime_error(name + " 不可被替换！");
}
else if (id2DelOrReplace == -1)
{
if (renameSrcID != -1)
{
id2DelOrReplace = renameSrcID;
}
}
//同类型同名问题由前端首先处理弹窗后再进入函数 ，这里不再做这种处理
// else
// {
// if (renameSrcID != -1)
// {
// throw std::runtime_error("存在不可替换的重名图元：" + name);
// }
// std::string stp = DataDictionary::TypeNameCnDic[Global::RootWorkItem->Services->Get<IDataManager>()->GetObjectByID(id2DelOrReplace)->GetType()];
// if (AppSetting::Default::SameNameRule == 0) // 更新
// {
// if (typeid(*o) != typeid(*Global::RootWorkItem->Services->Get<IDataManager>()->GetObjectByID(id2DelOrReplace)))
// {
// throw std::runtime_error("指定的对象名称 " + name + " 相同，但不是同一类型的对象，无法更新！");
// }
// }
// else if (AppSetting::Default::SameNameRule == 1) // 放弃
// {
// throw std::runtime_error("命令放弃执行。\n存在重名图元：" + stp + " \"" + name + "\"\n");
// }
// else if (AppSetting::Default::SameNameRule == 2) // 询问
// {
// std::string strtext = "存在重名图元：" + stp + " \"" + name + "\", 是否要覆盖？\n\n如不需要重名弹窗提示，可点击“取消”设置为“直接覆盖，不再弹窗”。";
// DialogResult dr = MessageBox::Show(strtext, "图元重名", MessageBoxButtons::YesNoCancel, MessageBoxIcon::Warning, MessageBoxDefaultButton::Button3, MessageBoxOptions::ServiceNotification);
// if (dr == DialogResult::No)
// {
// throw std::runtime_error("命令放弃执行。\n存在重名图元：" + stp + " \"" + name + "\"\n");
// }
// else
// {
// if (typeid(*o) != typeid(*Global::RootWorkItem->Services->Get<IDataManager>()->GetObjectByID(id2DelOrReplace)))
// {
// throw std::runtime_error("指定的对象名称 " + name + " 相同，但不是同一类型的对象，无法更新！");
// }
// if (dr == DialogResult::Cancel)
// {
// AppSetting::Default::SameNameRule = 0; // 同名规则为更新
// }
// }
// }
// }
}
return name;
}
// std::string ObjectInterpreter::ParseNameMirror(std::shared_ptr<IModel> o)
// {
// if (std::dynamic_pointer_cast<ScNode>(o) != nullptr || std::dynamic_pointer_cast<ScBeam>(o) != nullptr || std::dynamic_pointer_cast<ScPlate>(o) != nullptr || std::dynamic_pointer_cast<ScLoop>(o) != nullptr)
// {
// return GenerateObjectNameSec(o, (std::dynamic_pointer_cast<ISection>(o))->SecID);
// }
// else
// {
// std::string name = o->Name + "_M";
// // 未指定名称
// int i = 0;
// while (true)
// {
// // 反复生成默认名称,直到不存在重名
// id2DelOrReplace = FindIDByName(name, false, o->GetType()); // update zyy
// if (id2DelOrReplace == -1)
// {
// return name;
// }
// i++;
// name = name + std::to_string(i);
// }
// }
// }
std::string ObjectInterpreter::ParseNameByPre(const std::string &preName)
{
std::string name = preName;
// 未指定名称
int i = 0;
while (true)
{
// 反复生成默认名称,直到不存在重名
int id = DataManager::GetGeomObjectIDByName(name);
if (id == -1)
{
return name;
}
i++;
name = preName + std::to_string(i);
}
}
std::string ObjectInterpreter::ParseNameByPre(const std::string &preName, int &baseNum)
{
std::string name = preName + std::to_string(baseNum);
// 未指定名称
int i = baseNum;
while (true)
{
// 反复生成默认名称,直到不存在重名
int id = DataManager::GetGeomObjectIDByName(name);
if (id == -1)
{
baseNum = i;
return name;
}
i++;
name = preName + std::to_string(i);
}
}
std::string ObjectInterpreter::ParseNameHull()
{
{
std::string preName = "Hull_";
std::string name;
// 未指定名称
int i = 1;
while (true)
{
// 反复生成默认名称,直到不存在重名
name = preName + std::to_string(i);
// C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
id2DelOrReplace = FindIDByName(name, false, typeid(Hull).name()); // update zyy
if (id2DelOrReplace == -1)
{
return name;
}
i++;
}
}
}
std::string ObjectInterpreter::ParseNameSuffix(IModel *o, const std::string &sSuffix)
{
std::string name = o->m_Name.toStdString() + sSuffix;
int i = 0;
while (true)
{
// 反复生成默认名称，直到不存在重名
id2DelOrReplace = FindIDByName(name, false, typeid(*o).name());
if (id2DelOrReplace == -1)
{
//旧代码这个逻辑很奇怪不知道为什么要这样
// bool sameF = false;
// for (IModel3D *oo : Statics::Objects2Interact)
// {
// if (oo->m_Name == name)
// {
// sameF = true;
// break;
// }
// }
// if (!sameF)
// {
// return name;
// }
return name;
}
i++;
name = name + std::to_string(i);
}
}
bool ObjectInterpreter::ParsePointLoc(Point3D_M &o, const std::string &loc, bool withRef)
{
if (loc.front() == '(' && loc.back() == ')')
{ // 坐标形式 (x1,y1,z1)
std::string content = loc.substr(1, loc.length() - 2);
std::vector<std::string> xyz = StringHelper::split(content, {WORD_SPLITTER, WORD_SPLITTER_2});
if (xyz.size() != 3)
{
throw std::runtime_error("坐标格式错误.");
}
o.m_X = GetX(xyz[0]);
o.m_Y = std::stod(xyz[1]);
o.m_Z = std::stod(xyz[2]);
o.m_Type = 0;
return true;
}
else if (loc.find(SLASH) != std::string::npos && loc.find(EQUAL) != std::string::npos)
{ // 截取 c/y=? c/n=?
std::vector<std::string> locs = StringHelper::split(loc, std::vector<std::string>{SLASH});
if (locs.size() < 2)
{
throw std::runtime_error("坐标格式错误.");
}
int baseCurve = DataManager::GetObjectIDByName(locs[0]);
if (baseCurve == -1)
{
throw std::runtime_error("未找到曲线" + locs[0]);
}
o.m_Src.reserve(ModelData::ARRAY_SIZE_NORMAL);
o.m_Src[0] = baseCurve;
std::vector<std::string> locxyz = StringHelper::split(locs[1], std::vector<std::string>{EQUAL});
bool IsN = false;
if (StringHelper::toUpper(locxyz[0]) == "X")
{
o.m_CutDir = 0;
o.m_Cut = GetX(locxyz[1]);
}
else if (StringHelper::toUpper(locxyz[0]) == "Y")
{
o.m_CutDir = 1;
o.m_Cut = std::stod(locxyz[1]);
}
else if (StringHelper::toUpper(locxyz[0]) == "Z")
{
o.m_CutDir = 2;
o.m_Cut = std::stod(locxyz[1]);
}
else if (StringHelper::toUpper(locxyz[0]) == "N")
{
IsN = true;
}
else
{
throw std::runtime_error("坐标格式错误.");
}
if (locs.size() == 2)
{
if (IsN)
{
int index = std::stoi(locxyz[1]);
IModel *baseModel = DataManager::GetObjectByID(baseCurve); // 返回 IModel* 类型
struct Curve_M *model = dynamic_cast<struct Curve_M *>(baseModel);
if (model)
{
// 成功转换，进行处理
// 使用 model 访问 Curve_M 类型的成员
}
else
{
// 转换失败，处理错误
qWarning() << "Failed to cast IModel to Curve_M";
}
if (model->m_KnotID.empty())
{
model->m_KnotID.reserve(ModelData::ARRAY_SIZE_NORMAL);
}
int len = 0;
for (size_t j = 0; j < model->m_KnotID.size(); j++)
{
if (model->m_KnotID[j] == 0)
{
len = j;
break;
}
}
if (index == 0 || index < -len || index >= len)
{
throw std::runtime_error("坐标格式错误.");
}
if (index < 0)
{
index += len;
}
else
{
index -= 1;
}
Point3D_M * pSrc = dynamic_cast<struct Point3D_M *>(DataManager::GetObjectByID(model->m_KnotID[index]));
if (pSrc == nullptr)
{
throw std::runtime_error("未找到曲线" + locs[0]);
}
ParseRes(o, "N=" + locxyz[1]);
o.m_Type = 10;
o.m_X = pSrc->m_X;
o.m_Y = pSrc->m_Y;
o.m_Z = pSrc->m_Z;
}
else
{
ParseRes(o, locs[1]);
o.m_Type = 1;
Point3D temp_o = o.getGeoPoint();
if ( OCCModeling::CheckPoint(&temp_o))
{
// throw std::runtime_error(Global::RootWorkItem.Services.Get<IModelingAdapter>()->GetErrInfo() + ".");
throw std::runtime_error("坐标格式错误.");
}
o.m_X = temp_o.X;
o.m_Y = temp_o.Y;
o.m_Z = temp_o.Z;
if (!withRef)
{
o.m_Type = 0;
}
}
}
return true;
}
else if (loc.find(SLASH) != std::string::npos)
{ // 相交 c1/c2
std::vector<std::string> locs = StringHelper::split(loc, std::vector<std::string>{SLASH});
if (locs.size() < 2)
{
throw std::runtime_error("坐标格式错误.");
}
int baseCurve0 = DataManager::GetObjectIDByName(locs[0]);
if (baseCurve0 == -1)
{
throw std::runtime_error("未找到曲线" + locs[0]);
}
int baseCurve1 = DataManager::GetObjectIDByName(locs[1]);
if (baseCurve1 == -1)
{
throw std::runtime_error("未找到曲线" + locs[1]);
}
if (baseCurve0 == baseCurve1)
{
throw std::runtime_error("相交曲线不可为同一曲线.");
}
//o.m_Src.reserve(ModelData::ARRAY_SIZE_NORMAL);
o.m_Src[0] = baseCurve0;
o.m_Src[1] = baseCurve1;
if (locs.size() > 2)
{
ParseRes(o, locs[2]);
}
o.m_Type = 2;
Point3D temp_o = o.getGeoPoint();
if ( OCCModeling::CheckPoint(&temp_o))
{
// throw std::runtime_error(Global::RootWorkItem.Services.Get<IModelingAdapter>()->GetErrInfo() + ".");
throw std::runtime_error("坐标格式错误.");
}
o.m_X = temp_o.X;
o.m_Y = temp_o.Y;
o.m_Z = temp_o.Z;
if (!withRef)
{
o.m_Type = 0;
}
return true;
}
else
{ // 点图元名称
int basePnt = DataManager::GetObjectIDByName(loc);
if (basePnt == -1)
{
throw std::runtime_error("未找到点" + loc);
}
Point3D_M * basep = dynamic_cast<struct Point3D_M *>(DataManager::GetObjectByID(basePnt));
if (basep == nullptr)
{
throw std::runtime_error("未找到曲线" + basePnt);
}
o.m_X = basep->m_X;
o.m_Y = basep->m_Y;
o.m_Z = basep->m_Z;
//o.m_Src.reserve(ModelData::ARRAY_SIZE_NORMAL);
o.m_Src[0] = basePnt;
o.m_Type = 11;
Point3D temp_o = o.getGeoPoint();
if ( OCCModeling::CheckPoint(&temp_o))
{
// throw std::runtime_error(Global::RootWorkItem.Services.Get<IModelingAdapter>()->GetErrInfo() + ".");
throw std::runtime_error("坐标格式错误.");
}
o.m_X = temp_o.X;
o.m_Y = temp_o.Y;
o.m_Z = temp_o.Z;
if (!withRef)
{
o.m_Type = 0;
}
return true;
}
}
void ObjectInterpreter::ParsePointLoc2D(Point3D_M &o, const std::string &loc, const std::string &cutdir, double cutoff)
{
o.m_Src.resize(ModelData::ARRAY_SIZE_NORMAL);
if (loc.front() == '(' && loc.back() == ')') // 数值表达式
{
// // 坐标形式 (x1,y1)
std::vector<std::string> cds;
std::string loc_sub = loc.substr(1, loc.size() - 2);
std::stringstream ss(loc_sub);
std::string temp;
while (std::getline(ss, temp, ' ')) {
cds.push_back(temp);
}
if (cds.size() != 2)
{
throw std::runtime_error("坐标格式错误.");
}
std::string cd1 = cds[0];
std::string cd2 = cds[1];
switch (cutdir[0])
{
case 'X':
o.m_X = cutoff;
o.m_Y = std::stod(cd1);
o.m_Z = std::stod(cd2);
break;
case 'Y':
o.m_X = GetX(cd1);
o.m_Y = cutoff;
o.m_Z = std::stod(cd2);
break;
case 'Z':
o.m_X = GetX(cd1);
o.m_Y = std::stod(cd2);
o.m_Z = cutoff;
break;
default:
break;
}
o.m_Type = 0;
}
else // 引用表达式
{
std::vector<std::string> locs;
std::stringstream ss(loc);
std::string temp;
while (std::getline(ss, temp, '/')) {
locs.push_back(temp);
}
if (locs.size() < 1)
{
throw std::runtime_error("坐标格式错误.");
}
int baseCurve = DataManager::GetObjectIDByName(locs[0]);
if (baseCurve>=1000000 && baseCurve<2000000) // 引用曲线 C1
{
int crossCurve = -1;
if (locs.size() > 1)
{
crossCurve = DataManager::GetObjectIDByName(locs[1]);
}
if (crossCurve != -1) // C2 曲线相交 "C1/C2"
{
o.m_Src[0] = baseCurve;
o.m_Src[1] = crossCurve;
if (locs.size() > 2) // 可能是类似的表达式？
{
ParseRes(o, locs[2]);
}
o.m_Type = 2; // 曲线相交
Point3D temp_o = o.getGeoPoint();
bool b = OCCModeling::CheckPoint(&temp_o);
if (b == false)
{
throw std::runtime_error("坐标格式错误.");
}
o.m_X = temp_o.X;
o.m_Y = temp_o.Y;
o.m_Z = temp_o.Z;
switch (cutdir[0])
{
case 'X':
o.m_X = cutoff;
break;
case 'Y':
o.m_Y = cutoff;
break;
case 'Z':
o.m_Z = cutoff;
break;
default:
break;
}
}
else // 曲线上截取 C/X=? C/N=? C/Y>? C/Z~?
{
o.m_Src[0] = baseCurve;
switch (cutdir[0])
{
case 'X':
o.m_CutDir = 0;
break;
case 'Y':
o.m_CutDir = 1;
break;
case 'Z':
o.m_CutDir = 2;
break;
default:
throw std::runtime_error("坐标格式错误.");
}
o.m_Cut = cutoff;
if (locs.size() > 1)
{
ParseRes(o, locs[1]); // 判断引用表达式的类型，设置 o.ResType 和 o.Type
}
if(o.m_Type == 10) // C/N=?
{
// // 引用已有点
int curveID = DataManager::GetObjectIDByName(locs[0]);
Curve_M * model = dynamic_cast<struct Curve_M *>(DataManager::GetObjectByID(curveID));
int index = static_cast<int>(o.m_Res);
int len = 0;
for (int j = 0; j < model->m_KnotID.size(); j++)
{
if (model->m_KnotID[j] == 0)
{
len = j;
break;
}
}
if (index == 0)
{
std::runtime_error("坐标格式错误.");
}
else if (index > 0)
{
index -= 1;
}
else
{
index += len;
}
if (index < 0 || index > len)
{
throw std::runtime_error("坐标格式错误.");
}
int pointId = model->m_KnotID[index]; // 取点
Point3D_M * basep = dynamic_cast<struct Point3D_M *>(DataManager::GetObjectByID(pointId));
switch (cutdir[0])
{
case 'X':
o.m_X = cutoff;
o.m_Y = basep->m_Y;
o.m_Z = basep->m_Z;
break;
case 'Y':
o.m_X = basep->m_X;
o.m_Y = cutoff;
o.m_Z = basep->m_Z;
break;
case 'Z':
o.m_X = basep->m_X;
o.m_Y = basep->m_Y;
o.m_Z = cutoff;
break;
default:
break;
}
o.m_Type = 1;
}
else // C/X=? C/Y>? C/Z~?
{
o.m_Type = 1;
if ((o.m_CutDir == (o.m_ResDir - 1))) // && (o.ResType == 0)
o.m_Cut = o.m_Res;
Point3D temp_o = o.getGeoPoint();
bool b = OCCModeling::CheckPoint(&temp_o);
if (b == false)
{
throw std::runtime_error("坐标格式错误.");
}
o.m_X = temp_o.X;
o.m_Y = temp_o.Y;
o.m_Z = temp_o.Z;
switch (cutdir[0]) // 处理 X, Y, Z
{
case 'X':
o.m_X = cutoff;
break;
case 'Y':
o.m_Y = cutoff;
break;
case 'Z':
o.m_Z = cutoff;
break;
default:
break;
}
}
}
}
else // 引用点
{
int basePnt = DataManager::GetObjectIDByName(locs[0]);
if (basePnt == -1 || basePnt >= 1000000)
{
throw std::runtime_error("未找到点" + locs[0]);
}
Point3D_M * basep = dynamic_cast<struct Point3D_M *>(DataManager::GetObjectByID(basePnt));
o.m_Src[0] = basePnt;
switch (cutdir[0])
{
case 'X':
o.m_X = cutoff;
o.m_Y = basep->m_Y;
o.m_Z = basep->m_Z;
break;
case 'Y':
o.m_X = basep->m_X;
o.m_Y = cutoff;
o.m_Z = basep->m_Z;
break;
case 'Z':
o.m_X = basep->m_X;
o.m_Y = basep->m_Y;
o.m_Z = cutoff;
break;
default:
break;
}
o.m_Type = 11;
}
}
}
// std::shared_ptr<Curve> ObjectInterpreter::CreateTempCurve(std::shared_ptr<Point3D> p, const std::string &cutdir)
// {
// std::shared_ptr<Curve> c = std::make_shared<Curve>();
// c->Type = 5;
// c->KnotID = std::vector<int>(ModelData::ARRAY_SIZE_NORMAL); // 20170501 by czb
// c->KnotDir = std::vector<int>(ModelData::ARRAY_SIZE_NORMAL);
// c->KnotDirII = std::vector<int>(ModelData::ARRAY_SIZE_NORMAL);
// c->KnotAX = std::vector<double>(ModelData::ARRAY_SIZE_NORMAL);
// c->KnotAY = std::vector<double>(ModelData::ARRAY_SIZE_NORMAL);
// c->KnotAZ = std::vector<double>(ModelData::ARRAY_SIZE_NORMAL);
// c->KnotAXII = std::vector<double>(ModelData::ARRAY_SIZE_NORMAL);
// c->KnotAYII = std::vector<double>(ModelData::ARRAY_SIZE_NORMAL);
// c->KnotAZII = std::vector<double>(ModelData::ARRAY_SIZE_NORMAL);
// std::shared_ptr<Point3D> tp = std::make_shared<Point3D>();
// std::shared_ptr<Point3D> ep = std::make_shared<Point3D>();
// tp = p;
// ep = p;
// tp->Type = 0;
// ep->Type = 0;
// // C# TO C++ CONVERTER NOTE: The following 'switch' operated on a string and was converted to C++ 'if-else' logic:
// // switch (cutdir)
// // ORIGINAL LINE: case "X":
// if (cutdir == "X")
// {
// tp->X = -10000;
// ep->X = 10000;
// }
// // ORIGINAL LINE: case "Y":
// else if (cutdir == "Y")
// {
// tp->Y = -10000;
// ep->Y = 10000;
// }
// // ORIGINAL LINE: case "Z":
// else if (cutdir == "Z")
// {
// tp->Z = -10000;
// ep->Z = 10000;
// }
// else
// {
// }
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// tp->ID = GenerateObjectID(typeof(Point3D));
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// ep->ID = GenerateObjectID(typeof(Point3D));
// Add2ModelOrInteract(tp);
// Add2ModelOrInteract(ep);
// c->KnotID[0] = tp->ID;
// c->KnotID[0] = ep->ID;
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// c->ID = GenerateObjectID(typeof(Curve));
// std::shared_ptr<IModelingAdapter> adapter = Global::RootWorkItem::Services::Get<std::shared_ptr<IModelingAdapter>>();
// std::vector<int> order;
// std::vector<std::shared_ptr<Curve>> crv;
// std::vector<std::shared_ptr<Surface>> sur;
// crv.push_back(c);
// order.push_back(c->ID);
// adapter->AddObj(-1, order.size(), order.ToArray(), 0, nullptr, 0, nullptr, crv.size(), crv.ToArray(), 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr);
// return c;
// }
// void ObjectInterpreter::ParsePointLoc(std::shared_ptr<Point3D> &o, std::shared_ptr<Point3D> p, const std::string &cutdir, int baseCurve)
// {
// std::shared_ptr<Curve> c2 = CreateTempCurve(p, cutdir);
// o->Src = std::vector<int>(ModelData::ARRAY_SIZE_NORMAL);
// o->Src[0] = baseCurve;
// o->Src[1] = c2->ID;
// o->Type = 2; // 曲线相交
// bool b = Global::RootWorkItem::Services::Get<std::shared_ptr<IModelingAdapter>>().CheckPoint(o);
// if (b == false)
// {
// throw ErrorSyntaxException(Global::RootWorkItem::Services::Get<std::shared_ptr<IModelingAdapter>>().GetErrInfo() + ".");
// }
// }
void ObjectInterpreter::ParseRes(Point3D_M &o, const std::string &res)
{
if (res.find(CLOSE2) != std::string::npos)
{
o.m_ResType = 3;
}
else if (res.find(EQUAL) != std::string::npos)
{
o.m_ResType = 0;
}
else if (res.find(LESS) != std::string::npos)
{
o.m_ResType = 1;
}
else if (res.find(GREATER) != std::string::npos)
{
o.m_ResType = 2;
}
std::vector<std::string> ss = StringHelper::split(res, {EQUAL, LESS, GREATER, CLOSE2});
if (ss.size() < 2)
{
std::runtime_error("数据错误.");
}
// C# TO C++ CONVERTER NOTE: The following 'switch' operated on a string and was converted to C++ 'if-else' logic:
// switch (ss[0].toUpper())
// ORIGINAL LINE: case "X":
if (StringHelper::toUpper(ss[0]) == "X")
{
o.m_ResDir = 1;
}
// ORIGINAL LINE: case "Y":
else if (StringHelper::toUpper(ss[0]) == "Y")
{
o.m_ResDir = 2;
}
// ORIGINAL LINE: case "Z":
else if (StringHelper::toUpper(ss[0]) == "Z")
{
o.m_ResDir = 3;
}
// ORIGINAL LINE: case "N":
else if (StringHelper::toUpper(ss[0]) == "N")
{
o.m_Type = 10;
}
else
{
}
if (o.m_ResDir == 1) // 20161107 by czb
{
o.m_Res = GetX(ss[1]);
return;
}
o.m_Res = std::stod(ss[1]);
}
// void ObjectInterpreter::Add2ModelOrInteract(std::shared_ptr<IModel> o)
// {
// if (std::dynamic_pointer_cast<IModel3D>(o) != nullptr)
// {
// Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().Add2Interact(std::dynamic_pointer_cast<IModel3D>(o));
// }
// else
// {
// Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().Add2Model(o);
// }
// }
void ObjectInterpreter::Add2ModelOrInteractWithIdtf(IModel *o, bool bSetCommand)
{
o->m_Visible = 1;
o->m_Color = -1;
o->m_Transparency = 1.0;
if(id2DelOrReplace<=0)
{
o->m_ID = GenerateObjectID(o);
}
else
{
o->m_ID = id2DelOrReplace;
}
// 等出现问题在考虑这部分补丁有没有用
// 20161117 by czb，创建命令中无图元名称时，将图元名称添加到命令中
// std::vector<std::string> commands = DataManagement::Services::DataManager::SplitCommand(o->Command);
// if (commands[0].GetWords()->Length == 1) // 仅有命令，无对象名称时，20170601 by czb，解决重命名对象的问题
// {
// commands[0] = commands[0].FirstWord() + " " + o->Name;
// o->Command = std::string::Join(Constants->LINE_SPLITTER, commands);
// }
//我们没有这个结构 不需要加
// Add2ModelOrInteract(o);
}
int ObjectInterpreter::GenerateObjectID(IModel *o)
{
// 生成新图元ID
// int max = TypeNameMaxId[typeid(*o).name()];
// if(max)
// {
// TypeNameMaxId[typeid(*o).name()] = max + 1;
// return max;
// }
// int prefix = TypeNamePrefixId[typeid(*o).name()];
// //生成新的图元ID的时候这个Max值也需要更新为后面使用
// TypeNameMaxId[typeid(*o).name()] = prefix * MAX_SIZE_OF_OBJECT_GROUP + max + 1;
// return prefix * MAX_SIZE_OF_OBJECT_GROUP + max;
int max=0;
string typeName = typeid(*o).name();
auto it = Model3D_MCommanData::TypeNameMaxId.find(typeName);
if (it != Model3D_MCommanData::TypeNameMaxId.end())
{
max = ++Model3D_MCommanData::TypeNameMaxId[typeName];
return max;
}
int prefix = Model3D_MCommanData::TypeNamePrefixId[typeName];
return prefix * MAX_SIZE_OF_OBJECT_GROUP + max;
//else if (Global.RootWorkItem.Services.Get<IDataManager>().Calculation.MaxIDs.ContainsKey(typeName))
//{ max = ++Global.RootWorkItem.Services.Get<IDataManager>().Calculation.MaxIDs[typeName]; }
// int prefix = ModelData.TypeIDPrefixDic[typeName];
//int prefix = DataDictionary.TypeIDPrefixDic[typeName];
//return prefix * DataDictionary.MAX_SIZE_OF_OBJECT_GROUP + max;
}
// void ObjectInterpreter::InitialObjectID(std::type_info t)
// {
// // 生成新图元ID
// std::shared_ptr<ModelData> model = Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().Model;
// std::string typeName = t.name();
// model->MaxIDs[typeName] = 0;
// Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().Calculation::MaxIDs[typeName] = 0;
// }
std::string ObjectInterpreter::GenerateObjectName(IModel &o)
{
// if (Space* s = dynamic_cast<Space*>(o)) { // 判断是否为 Space 类型
// if (s->isUnit) {
// return "SpaceUnit";
// }
// }
//// 根据默认规则生成新图元名称
typeid(o).name();
std::string prefix = Model3D_MCommanData::TypeNamePrefixDic[typeid(o).name()];
return prefix;
}
// std::string ObjectInterpreter::GenerateObjectNameSec(std::shared_ptr<IModel> o, int secid)
// {
// if (std::dynamic_pointer_cast<ScNode>(o) != nullptr || std::dynamic_pointer_cast<ScBeam>(o) != nullptr || std::dynamic_pointer_cast<ScPlate>(o) != nullptr || std::dynamic_pointer_cast<ScLoop>(o) != nullptr)
// {
// int max = 0;
// auto items = Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().Model::ObjectDics[o->GetType()->Name]->Values;
// for (auto item : items)
// {
// if (std::dynamic_pointer_cast<ISection>(item) != nullptr && (std::dynamic_pointer_cast<ISection>(item))->SecID == secid)
// {
// int n = 0;
// try
// {
// n = std::stoi((std::dynamic_pointer_cast<IModel>(item))->Name);
// }
// catch (const std::runtime_error &e1)
// {
// }
// if (n > max)
// {
// max = n;
// }
// }
// }
// max++;
// return std::to_string(max);
// }
// else
// {
// return GenerateObjectName(o);
// }
// }
int ObjectInterpreter::FindIDByName(const std::string& name, bool replace, const char* typeName, bool throwEx)
{
int id = DataManager::GetGeomObjectIDByName(name);
if (id != -1) {
// 如果找到 ID
if (replace) {
IModel* tempmodel = DataManager::GetObjectByID(id);
if (tempmodel == nullptr || std::string(typeid(*tempmodel).name()) != typeName) {
return -2; // 如果 tempmodel 为 nullptr 或类型不匹配，返回 -2
}
}
return id;
}
// 格式验证
if (typeName) {
bool isHull = std::regex_match(name, std::regex (Reg_HULL));
bool isMdeck = std::regex_match(name, std::regex (Reg_MDECKSURF));
bool isShell = std::regex_match(name, std::regex (Reg_SHELLSURF));
if (typeName == typeid(Hull_M).name() && !isHull) {
throw std::runtime_error("主船体命名格式不正确.");
return -1;
}
//下面这些现在都没有 用不上
// if (typeName == "MAINDECKSURF" && !isMdeck) {
// if (throwEx) throw std::runtime_error("主甲板面命名格式不正确.");
// return -1;
// }
// if (typeName == "SHELLSURF" && !isShell) {
// if (throwEx) throw std::runtime_error("外板面命名格式不正确.");
// return -1;
// }
// if (typeName != "HULL" && typeName != "MAINDECKSURF" && typeName != "SHELLSURF") {
// if (isHull) throw std::runtime_error("与主船体命名格式冲突.");
// if (isMdeck) throw std::runtime_error("与主甲板面命名格式冲突.");
// if (isShell) throw std::runtime_error("与外板面命名格式冲突.");
// }
}
return -1;
}
// int ObjectInterpreter::FindIDByNameFromInteract(const std::string &name, bool replace, std::type_info t, bool throwEx)
// {
// std::vector<std::shared_ptr<IModel3D>> listM = Statics::Objects2Interact;
// for (auto m : listM)
// {
// if (m->Name != nullptr && m->Name.Equals(name))
// {
// return m->ID;
// }
// }
// return -1;
// }
// std::shared_ptr<IModel> ObjectInterpreter::CopyObjectWithSrc(int id, bool add2Model, bool mirror, double dx, double dy, double dz, double kx, double ky, double kz, std::unordered_map<int, int> &dicCopyed)
// {
// if (dicCopyed.empty())
// {
// dicCopyed = std::unordered_map<int, int>();
// }
// return CopyObjectWithSrcPriv(dicCopyed, id, add2Model, mirror, dx, dy, dz, kx, ky, kz);
// }
// std::shared_ptr<IModel> ObjectInterpreter::CopyObjectWithSrcPriv(std::unordered_map<int, int> &dicCopyed, int id, bool add2Model, bool mirror, double dx, double dy, double dz, double kx, double ky, double kz)
// {
// // 获取待拷贝图元
// std::shared_ptr<IModel> src = Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().GetObjectByID(id);
// if (src == nullptr)
// {
// return nullptr;
// }
// if (dicCopyed.contains(src->ID))
// {
// return nullptr;
// }
// // 拷贝数据
// std::shared_ptr<IModel> o = std::dynamic_pointer_cast<IModel>(Statics::CopyObject(src));
// // 拷贝其依赖图元
// if (src->Src != nullptr)
// {
// o->Src = std::vector<int>(ModelData::ARRAY_SIZE_NORMAL);
// for (int i = 0; i < src->Src->Length; i++)
// {
// int srcid = src->Src[i];
// if (srcid == 0)
// {
// break;
// }
// else if (dicCopyed.contains(srcid))
// {
// o->Src[i] = dicCopyed[srcid];
// }
// else
// {
// std::shared_ptr<IModel> copyM = CopyObjectWithSrcPriv(dicCopyed, src->Src[i], true, mirror, dx, dy, dz, kx, ky, kz);
// if (copyM != nullptr)
// {
// o->Src[i] = copyM->ID;
// }
// }
// }
// }
// // 拷贝节点ID KnotID 20170601 by czb
// if (std::dynamic_pointer_cast<Curve>(src) != nullptr)
// {
// std::shared_ptr<Curve> cc = std::static_pointer_cast<Curve>(src);
// if (cc->KnotID != nullptr)
// {
// std::shared_ptr<Curve> oo = std::static_pointer_cast<Curve>(o);
// oo->KnotID = std::vector<int>(ModelData::ARRAY_SIZE_NORMAL);
// auto srcList = cc->Src.ToList();
// for (int i = 0; i < cc->KnotID->Length; i++)
// {
// int cid = cc->KnotID[i];
// if (cid == 0)
// {
// break;
// }
// int index = VectorHelper::indexOf(srcList, cid);
// oo->KnotID[i] = oo->Src[index];
// }
// o = oo;
// }
// }
// // 偏移量，修改X、Y、Z坐标属性
// std::vector<std::shared_ptr<FieldInfo>> fields = o->GetType()->GetFields();
// for (auto f : fields)
// {
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// if (f->GetCustomAttributes(typeof(OffsetPropAttribute), true).Count() > 0 && f->FieldType == typeof(double))
// {
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// std::shared_ptr<OffsetPropAttribute> att = std::dynamic_pointer_cast<OffsetPropAttribute>(f->GetCustomAttributes(typeof(OffsetPropAttribute), true)[0]);
// double v = std::any_cast<double>(f->GetValue(o));
// switch (att->Type)
// {
// case OffsetType::X:
// f->SetValue(o, kx * v + dx);
// break;
// case OffsetType::Y:
// f->SetValue(o, ky * v + dy);
// break;
// case OffsetType::Z:
// f->SetValue(o, kz * v + dz);
// break;
// default:
// break;
// }
// }
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// else if (f->GetCustomAttributes(typeof(OffsetArrayAttribute), true).Count() > 0)
// {
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// std::shared_ptr<OffsetArrayAttribute> att = std::dynamic_pointer_cast<OffsetArrayAttribute>(f->GetCustomAttributes(typeof(OffsetArrayAttribute), true)[0]);
// std::shared_ptr<Array> arr = std::dynamic_pointer_cast<Array>(f->GetValue(o));
// if (arr != nullptr)
// {
// for (int i = 0; i < arr->Length; i++)
// {
// double v = std::any_cast<double>(arr->GetValue(i));
// double vv = v;
// switch (att->Type)
// {
// case OffsetType::X:
// vv = kx * v + dx;
// break;
// case OffsetType::Y:
// vv = ky * v + dy;
// break;
// case OffsetType::Z:
// vv = kz * v + dz;
// break;
// default:
// break;
// }
// arr->SetValue(vv, i);
// }
// f->SetValue(o, arr);
// }
// }
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// else if ((f->GetCustomAttributes(typeof(CutArrayAttribute), true).Count() > 0) && mirror)
// {
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// std::shared_ptr<CutArrayAttribute> att = std::dynamic_pointer_cast<CutArrayAttribute>(f->GetCustomAttributes(typeof(CutArrayAttribute), true)[0]);
// std::shared_ptr<Array> arr = std::dynamic_pointer_cast<Array>(f->GetValue(o));
// if (arr != nullptr)
// {
// for (int i = 0; i < arr->Length; i++)
// {
// double v = std::any_cast<double>(arr->GetValue(i));
// double vv = v;
// switch (att->Type)
// {
// case OffsetType::X:
// vv = kx * v + dx;
// break;
// case OffsetType::Y:
// vv = ky * v + dy;
// break;
// case OffsetType::Z:
// vv = kz * v + dz;
// break;
// default:
// break;
// }
// arr->SetValue(vv, i);
// }
// f->SetValue(o, arr);
// }
// }
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// else if (f->GetCustomAttributes(typeof(AngleAttribute), true).Count() > 0 && f->FieldType == typeof(double))
// {
// if (mirror)
// {
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// std::shared_ptr<AngleAttribute> att = std::dynamic_pointer_cast<AngleAttribute>(f->GetCustomAttributes(typeof(AngleAttribute), true)[0]);
// double v = std::any_cast<double>(f->GetValue(o));
// f->SetValue(o, 360 - v);
// }
// }
// }
// if (mirror)
// {
// double temp1 = -1;
// double temp2 = -1;
// for (auto f : fields)
// {
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// if (f->GetCustomAttributes(typeof(AngleAttribute), true).Count() > 0 && f->FieldType == typeof(double))
// {
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// std::shared_ptr<AngleAttribute> att = std::dynamic_pointer_cast<AngleAttribute>(f->GetCustomAttributes(typeof(AngleAttribute), true)[0]);
// double v = std::any_cast<double>(f->GetValue(o));
// if (att->Type == AngleType::A1)
// {
// temp1 = v;
// }
// if (att->Type == AngleType::A2)
// {
// temp2 = v;
// }
// }
// }
// for (auto f : fields)
// {
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// if (f->GetCustomAttributes(typeof(AngleAttribute), true).Count() > 0 && f->FieldType == typeof(double))
// {
// // C# TO C++ CONVERTER TASK: There is no C++ equivalent to the C# 'typeof' operator:
// std::shared_ptr<AngleAttribute> att = std::dynamic_pointer_cast<AngleAttribute>(f->GetCustomAttributes(typeof(AngleAttribute), true)[0]);
// double v = std::any_cast<double>(f->GetValue(o));
// if (att->Type == AngleType::A1)
// {
// f->SetValue(o, temp2);
// }
// if (att->Type == AngleType::A2)
// {
// f->SetValue(o, temp1);
// }
// }
// }
// }
// o->Name = nullptr;
// // 置入数据集
// if (add2Model)
// {
// if (mirror && src->Name != nullptr)
// {
// o->Name = ParseNameMirror(src);
// }
// // o.Command = cmd.ToString().Substring(2);
// o->ID = GenerateObjectID(o->GetType());
// // Add2ModelOrInteract(o);by yangchen20170227
// // by yangchen 20170418
// if (std::dynamic_pointer_cast<Point3D>(o) != nullptr)
// {
// Add2ModelOrInteract(o);
// // Global.RootWorkItem.Services.Get<IDataManager>().Add2Model(o); //20170601 by czb
// }
// }
// dicCopyed.emplace(src->ID, o->ID);
// return o;
// }
double ObjectInterpreter::GetX(const std::string &str)
{
// C++ 正则表达式
std::regex reg(Reg_LONGCOORDFULL); // 需要替换为实际的正则表达式
if (!std::regex_match(str, reg)) {
throw std::runtime_error(
"纵向坐标定义格式不正确, 请参照格式(1)数字(最多五位小数),(2)#整数±数字（最多一位小数）,(3)$数字（三位小数）±数字（最多一位小数）"
);
}
return ChangeFSPos::ShowX(str);
}
// void ObjectInterpreter::ParsePointLoc2D(std::shared_ptr<Point3D> &o, const std::string &loc, const std::string &cutdir, double cutoff, std::shared_ptr<Surface> sur)
// {
// if (loc.starts_with("(") && loc.ends_with(")")) // 坐标形式
// {
// std::vector<std::string> cds = loc.substr(1, loc.length() - 2).Split({Constants->SPACE}, StringSplitOptions::RemoveEmptyEntries);
// if (cds.size() != 2)
// {
// throw ErrorParameterException();
// }
// std::string cd1 = cds[0];
// std::string cd2 = cds[1];
// // C# TO C++ CONVERTER NOTE: The following 'switch' operated on a string and was converted to C++ 'if-else' logic:
// // switch (cutdir)
// // ORIGINAL LINE: case "X":
// if (cutdir == "X")
// {
// o->X = cutoff;
// o->Y = std::stod(cd1);
// o->Z = std::stod(cd2);
// }
// // ORIGINAL LINE: case "Y":
// else if (cutdir == "Y")
// {
// o->X = GetX(cd1);
// o->Y = cutoff;
// o->Z = std::stod(cd2);
// }
// // ORIGINAL LINE: case "Z":
// else if (cutdir == "Z")
// {
// o->X = GetX(cd1);
// o->Y = std::stod(cd2);
// o->Z = cutoff;
// }
// else
// {
// }
// o->Type = 0;
// }
// else // 引用表达式
// {
// std::vector<std::string> locs = loc.Split({Constants->SLASH}, StringSplitOptions::RemoveEmptyEntries);
// if (locs.size() < 1)
// {
// throw ErrorParameterException();
// }
// int baseCurve = Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().GetObjectIDByName<std::shared_ptr<Curve>>(locs[0]);
// if (baseCurve != -1) // 引用线
// {
// int crossCurve = -1;
// if (locs.size() > 1)
// {
// crossCurve = Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().GetObjectIDByName<std::shared_ptr<Curve>>(locs[1]);
// }
// if (crossCurve != -1) // 曲线相交
// {
// o->Src = std::vector<int>(ModelData::ARRAY_SIZE_NORMAL);
// o->Src[0] = baseCurve;
// o->Src[1] = crossCurve;
// if (locs.size() > 2)
// {
// ParseRes(o, locs[2]);
// }
// o->Type = 2;
// bool b = Global::RootWorkItem::Services::Get<std::shared_ptr<IModelingAdapter>>().CheckPoint(o);
// if (b == false)
// {
// throw ErrorSyntaxException(Global::RootWorkItem::Services::Get<std::shared_ptr<IModelingAdapter>>().GetErrInfo() + ".");
// }
// // C# TO C++ CONVERTER NOTE: The following 'switch' operated on a string and was converted to C++ 'if-else' logic:
// // switch (cutdir)
// // ORIGINAL LINE: case "X":
// if (cutdir == "X")
// {
// o->X = cutoff;
// }
// // ORIGINAL LINE: case "Y":
// else if (cutdir == "Y")
// {
// o->Y = cutoff;
// }
// // ORIGINAL LINE: case "Z":
// else if (cutdir == "Z")
// {
// o->Z = cutoff;
// }
// else
// {
// }
// }
// else // 曲线和曲面相交截取
// {
// o->Src = std::vector<int>(ModelData::ARRAY_SIZE_NORMAL);
// o->Src[0] = baseCurve;
// o->Src[1] = sur->ID;
// // C# TO C++ CONVERTER NOTE: The following 'switch' operated on a string and was converted to C++ 'if-else' logic:
// // switch (cutdir)
// // ORIGINAL LINE: case "X":
// if (cutdir == "X")
// {
// o->CutDir = 0;
// }
// // ORIGINAL LINE: case "Y":
// else if (cutdir == "Y")
// {
// o->CutDir = 1;
// }
// // ORIGINAL LINE: case "Z":
// else if (cutdir == "Z")
// {
// o->CutDir = 2;
// }
// else
// {
// throw ErrorParameterException();
// }
// o->Cut = cutoff;
// if (locs.size() > 1)
// {
// ParseRes(o, locs[1]);
// }
// o->Type = 3;
// bool b = Global::RootWorkItem::Services::Get<std::shared_ptr<IModelingAdapter>>().CheckPoint(o);
// if (b == false)
// {
// throw ErrorSyntaxException(Global::RootWorkItem::Services::Get<std::shared_ptr<IModelingAdapter>>().GetErrInfo() + ".");
// }
// // C# TO C++ CONVERTER NOTE: The following 'switch' operated on a string and was converted to C++ 'if-else' logic:
// // switch (cutdir) //20170501 by czb，新增
// // ORIGINAL LINE: case "X":
// if (cutdir == "X")
// {
// o->X = cutoff;
// }
// // ORIGINAL LINE: case "Y":
// else if (cutdir == "Y")
// {
// o->Y = cutoff;
// }
// // ORIGINAL LINE: case "Z":
// else if (cutdir == "Z")
// {
// o->Z = cutoff;
// }
// else
// {
// }
// }
// }
// else // 引用点
// {
// int basePnt = Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().GetObjectIDByName<std::shared_ptr<Point3D>>(locs[0]);
// if (basePnt == -1)
// {
// throw ObjectNotFoundException(locs[0]);
// }
// std::shared_ptr<Point3D> basep = std::static_pointer_cast<Point3D>(Global::RootWorkItem::Services::Get<std::shared_ptr<IDataManager>>().GetObjectByID(basePnt));
// // C# TO C++ CONVERTER NOTE: The following 'switch' operated on a string and was converted to C++ 'if-else' logic:
// // switch (cutdir)
// // ORIGINAL LINE: case "X":
// if (cutdir == "X")
// {
// o->X = cutoff;
// o->Y = basep->Y;
// o->Z = basep->Z;
// }
// // ORIGINAL LINE: case "Y":
// else if (cutdir == "Y")
// {
// o->X = basep->X;
// o->Y = cutoff;
// o->Z = basep->Z;
// }
// // ORIGINAL LINE: case "Z":
// else if (cutdir == "Z")
// {
// o->X = basep->X;
// o->Y = basep->Y;
// o->Z = cutoff;
// }
// else
// {
// }
// o->Type = 0;
// }
// }
// }
Point3D_M ObjectInterpreter::ParseLoc(std::vector<std::string> &linePara1b, const std::string &cutdir, double &offset)
{
Point3D_M pt;
if (linePara1b[1].find("/") != std::string::npos)
{
if (ParsePointLoc(pt, linePara1b[1], true))
{
// // C# TO C++ CONVERTER NOTE: The following 'switch' operated on a string and was converted to C++ 'if-else' logic:
// // switch (cutdir)
// // ORIGINAL LINE: case "X":
if (cutdir == "X") offset = pt.m_X;
// offset = pt->X;
// }
// // ORIGINAL LINE: case "Y":
else if (cutdir == "Y") offset = pt.m_Y;
// {
// offset = pt->Y;
// }
// // ORIGINAL LINE: case "Z":
else if (cutdir == "Z") offset = pt.m_Z;
// {
// offset = pt->Z;
// }
// else
// {
// }
}
else
{
throw std::runtime_error("数据错误.");
}
}
else
{
std::string dir = StringHelper::toUpper(linePara1b[0]);
if (dir == "X")
{
offset = GetX(linePara1b[1]);
}
else
{
offset = std::stod(linePara1b[1]);
}
}
return pt;
}
Reference in New Issue View Git Blame Copy Permalink