279 lines
7.6 KiB
C++
279 lines
7.6 KiB
C++
|
#include "KTCad.h"
|
|||
|
|
#include "dwg_annotate_common.h"
|
|||
|
|
#include "dbcolor.h" // AcCmColor
|
|||
|
|
|
|||
|
|
#include <algorithm>
|
|||
|
|
#include <cmath>
|
|||
|
|
|
|||
|
|
// windows.h（经 afxwin.h）把 min/max 定义成宏，会顶掉下面的 std::min / std::max
|
|||
|
|
// （CadProject 那边的 cadsdk.h 里带了 NOMINMAX，本仓库的 KTCad.h 没有）。
|
|||
|
|
#undef min
|
|||
|
|
#undef max
|
|||
|
|
|
|||
|
|
|
|||
|
|
namespace dwg_annotate
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
DocLock::DocLock()
|
|||
|
|
: m_bLocked(false), m_pDoc(NULL)
|
|||
|
|
{
|
|||
|
|
m_pDoc = acDocManager->curDocument();
|
|||
|
|
if (m_pDoc != NULL && acDocManager->lockDocument(m_pDoc) == Acad::eOk)
|
|||
|
|
m_bLocked = true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
DocLock::~DocLock()
|
|||
|
|
{
|
|||
|
|
if (m_bLocked && m_pDoc != NULL)
|
|||
|
|
acDocManager->unlockDocument(m_pDoc);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
using namespace dwg_review;
|
|||
|
|
|
|||
|
|
const char* kDefaultAnnotLayer = "AI_REVIEW";
|
|||
|
|
|
|||
|
|
// ===========================================================================
|
|||
|
|
// 编码
|
|||
|
|
// ===========================================================================
|
|||
|
|
|
|||
|
|
std::wstring utf8ToWStr(const std::string& s)
|
|||
|
|
{
|
|||
|
|
if (s.empty()) return std::wstring();
|
|||
|
|
int len = ::MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), NULL, 0);
|
|||
|
|
if (len <= 0) return std::wstring();
|
|||
|
|
std::wstring out((size_t)len, L'\0');
|
|||
|
|
::MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), &out[0], len);
|
|||
|
|
return out;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ===========================================================================
|
|||
|
|
// 图层
|
|||
|
|
// ===========================================================================
|
|||
|
|
|
|||
|
|
bool ensureLayer(AcDbDatabase* pDb, const std::string& name, int aciColor)
|
|||
|
|
{
|
|||
|
|
if (!pDb || name.empty()) return false;
|
|||
|
|
const std::wstring wn = utf8ToWStr(name);
|
|||
|
|
|
|||
|
|
// 已存在则直接返回
|
|||
|
|
AcDbLayerTable* pLT = nullptr;
|
|||
|
|
if (pDb->getLayerTable(pLT, AcDb::kForRead) == Acad::eOk && pLT)
|
|||
|
|
{
|
|||
|
|
const bool exists = pLT->has(wn.c_str());
|
|||
|
|
pLT->close();
|
|||
|
|
if (exists) return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// 创建新图层
|
|||
|
|
if (pDb->getLayerTable(pLT, AcDb::kForWrite) != Acad::eOk || !pLT) return false;
|
|||
|
|
|
|||
|
|
AcDbLayerTableRecord* pRec = new AcDbLayerTableRecord();
|
|||
|
|
pRec->setName(wn.c_str());
|
|||
|
|
AcCmColor color;
|
|||
|
|
color.setColorIndex((Adesk::UInt16)aciColor);
|
|||
|
|
pRec->setColor(color);
|
|||
|
|
|
|||
|
|
const Acad::ErrorStatus es = pLT->add(pRec);
|
|||
|
|
pRec->close();
|
|||
|
|
pLT->close();
|
|||
|
|
return es == Acad::eOk || es == Acad::eDuplicateRecordName;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ===========================================================================
|
|||
|
|
// 空间
|
|||
|
|
// ===========================================================================
|
|||
|
|
|
|||
|
|
AcDbBlockTableRecord* openWriteSpace(AcDbDatabase* pDb, const std::string& space)
|
|||
|
|
{
|
|||
|
|
if (!pDb) return nullptr;
|
|||
|
|
|
|||
|
|
AcDbBlockTable* pBT = nullptr;
|
|||
|
|
if (pDb->getBlockTable(pBT, AcDb::kForRead) != Acad::eOk || !pBT) return nullptr;
|
|||
|
|
|
|||
|
|
AcDbBlockTableRecord* pRec = nullptr;
|
|||
|
|
if (space.empty() || space == "Model" || space == "model")
|
|||
|
|
{
|
|||
|
|
pBT->getAt(ACDB_MODEL_SPACE, pRec, AcDb::kForWrite);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
AcDbObjectId id;
|
|||
|
|
const std::wstring ws = utf8ToWStr(space);
|
|||
|
|
if (pBT->getAt(ws.c_str(), id) == Acad::eOk)
|
|||
|
|
acdbOpenObject(pRec, id, AcDb::kForWrite);
|
|||
|
|
}
|
|||
|
|
pBT->close();
|
|||
|
|
return pRec;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ===========================================================================
|
|||
|
|
// 参数解析
|
|||
|
|
// ===========================================================================
|
|||
|
|
|
|||
|
|
bool parsePoint(const nlohmann::json& j, AcGePoint3d& out)
|
|||
|
|
{
|
|||
|
|
if (j.is_array() && j.size() >= 2)
|
|||
|
|
{
|
|||
|
|
out.x = j[0].get<double>();
|
|||
|
|
out.y = j[1].get<double>();
|
|||
|
|
out.z = (j.size() >= 3) ? j[2].get<double>() : 0.0;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
if (j.is_object() && j.contains("x") && j.contains("y"))
|
|||
|
|
{
|
|||
|
|
out.x = j["x"].get<double>();
|
|||
|
|
out.y = j["y"].get<double>();
|
|||
|
|
out.z = j.contains("z") ? j["z"].get<double>() : 0.0;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool parsePoints(const nlohmann::json& arr, std::vector<AcGePoint3d>& out)
|
|||
|
|
{
|
|||
|
|
out.clear();
|
|||
|
|
if (!arr.is_array()) return false;
|
|||
|
|
for (size_t i = 0; i < arr.size(); ++i)
|
|||
|
|
{
|
|||
|
|
AcGePoint3d p;
|
|||
|
|
if (!parsePoint(arr[i], p)) { out.clear(); return false; }
|
|||
|
|
out.push_back(p);
|
|||
|
|
}
|
|||
|
|
return !out.empty();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool parseWindow(const nlohmann::json& args, double& x1, double& y1, double& x2, double& y2)
|
|||
|
|
{
|
|||
|
|
if (args.contains("window") && args["window"].is_object())
|
|||
|
|
{
|
|||
|
|
const nlohmann::json& w = args["window"];
|
|||
|
|
if (w.contains("min_x") && w.contains("min_y") && w.contains("max_x") && w.contains("max_y"))
|
|||
|
|
{
|
|||
|
|
x1 = w["min_x"].get<double>(); y1 = w["min_y"].get<double>();
|
|||
|
|
x2 = w["max_x"].get<double>(); y2 = w["max_y"].get<double>();
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (args.contains("min_x") && args.contains("min_y") &&
|
|||
|
|
args.contains("max_x") && args.contains("max_y"))
|
|||
|
|
{
|
|||
|
|
x1 = args["min_x"].get<double>(); y1 = args["min_y"].get<double>();
|
|||
|
|
x2 = args["max_x"].get<double>(); y2 = args["max_y"].get<double>();
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
if (args.contains("p1") && args.contains("p2"))
|
|||
|
|
{
|
|||
|
|
AcGePoint3d a, b;
|
|||
|
|
if (parsePoint(args["p1"], a) && parsePoint(args["p2"], b))
|
|||
|
|
{
|
|||
|
|
x1 = (std::min)(a.x, b.x); y1 = (std::min)(a.y, b.y);
|
|||
|
|
x2 = (std::max)(a.x, b.x); y2 = (std::max)(a.y, b.y);
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
std::vector<std::string> collectHandlesArg(const nlohmann::json& args)
|
|||
|
|
{
|
|||
|
|
std::vector<std::string> hs;
|
|||
|
|
if (args.contains("handle") && args["handle"].is_string())
|
|||
|
|
hs.push_back(args["handle"].get<std::string>());
|
|||
|
|
if (args.contains("handles") && args["handles"].is_array())
|
|||
|
|
{
|
|||
|
|
for (size_t i = 0; i < args["handles"].size(); ++i)
|
|||
|
|
if (args["handles"][i].is_string())
|
|||
|
|
hs.push_back(args["handles"][i].get<std::string>());
|
|||
|
|
}
|
|||
|
|
return hs;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ===========================================================================
|
|||
|
|
// 公共参数默认值
|
|||
|
|
// ===========================================================================
|
|||
|
|
|
|||
|
|
std::string getLayerArg(const nlohmann::json& args)
|
|||
|
|
{
|
|||
|
|
if (args.contains("layer") && args["layer"].is_string())
|
|||
|
|
return args["layer"].get<std::string>();
|
|||
|
|
return std::string(kDefaultAnnotLayer);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int getColorArg(const nlohmann::json& args, int def)
|
|||
|
|
{
|
|||
|
|
if (args.contains("color") && args["color"].is_number_integer())
|
|||
|
|
return args["color"].get<int>();
|
|||
|
|
return def;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
std::string getSpaceArg(const nlohmann::json& args)
|
|||
|
|
{
|
|||
|
|
if (args.contains("space") && args["space"].is_string())
|
|||
|
|
return args["space"].get<std::string>();
|
|||
|
|
return std::string("Model");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ===========================================================================
|
|||
|
|
// 实体写入
|
|||
|
|
// ===========================================================================
|
|||
|
|
|
|||
|
|
void applyLayerColor(AcDbEntity* pEnt, const std::string& layer, int aciColor)
|
|||
|
|
{
|
|||
|
|
if (!pEnt) return;
|
|||
|
|
if (!layer.empty())
|
|||
|
|
{
|
|||
|
|
const std::wstring wl = utf8ToWStr(layer);
|
|||
|
|
pEnt->setLayer(wl.c_str());
|
|||
|
|
}
|
|||
|
|
pEnt->setColorIndex((Adesk::UInt16)aciColor);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
AcDbObjectId appendToSpace(AcDbBlockTableRecord* pSpace, AcDbEntity* pEnt)
|
|||
|
|
{
|
|||
|
|
AcDbObjectId id = AcDbObjectId::kNull;
|
|||
|
|
if (!pEnt) return id;
|
|||
|
|
if (!pSpace)
|
|||
|
|
{
|
|||
|
|
pEnt->close();
|
|||
|
|
return id;
|
|||
|
|
}
|
|||
|
|
if (pSpace->appendAcDbEntity(id, pEnt) != Acad::eOk)
|
|||
|
|
id = AcDbObjectId::kNull;
|
|||
|
|
pEnt->close();
|
|||
|
|
return id;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
std::string handleOfId(AcDbDatabase* pDb, const AcDbObjectId& id)
|
|||
|
|
{
|
|||
|
|
if (!pDb || id == AcDbObjectId::kNull) return std::string();
|
|||
|
|
AcDbEntity* pEnt = nullptr;
|
|||
|
|
if (acdbOpenObject(pEnt, id, AcDb::kForRead) != Acad::eOk || !pEnt) return std::string();
|
|||
|
|
const std::string h = handleOf(pEnt);
|
|||
|
|
pEnt->close();
|
|||
|
|
return h;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ===========================================================================
|
|||
|
|
// 结果构造
|
|||
|
|
// ===========================================================================
|
|||
|
|
|
|||
|
|
nlohmann::json makeCreatedItem(AcDbDatabase* pDb, const AcDbObjectId& id,
|
|||
|
|
const std::string& type, const std::string& layer)
|
|||
|
|
{
|
|||
|
|
nlohmann::json item;
|
|||
|
|
item["handle"] = handleOfId(pDb, id);
|
|||
|
|
item["type"] = type;
|
|||
|
|
item["layer"] = layer;
|
|||
|
|
return item;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
nlohmann::json createdResult(const std::vector<nlohmann::json>& created)
|
|||
|
|
{
|
|||
|
|
nlohmann::json r;
|
|||
|
|
r["ok"] = true;
|
|||
|
|
r["count"] = (int)created.size();
|
|||
|
|
r["created"] = created;
|
|||
|
|
return makeJsonResult(r);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} // namespace dwg_annotate
|