2038 lines
55 KiB
C++
2038 lines
55 KiB
C++
#include "StdAfx.h"
|
|
#include <algorithm>
|
|
#include <sstream>
|
|
#include <iterator>
|
|
#include "UITools.h"
|
|
#include "ZDOutput.h"
|
|
#include "KTCadUtility.h"
|
|
#include "KTCadUtilityEx.h"
|
|
#include "KTSetting.h"
|
|
#include "aecdbObjXDataMap.h"
|
|
#include "KTModelLayoutXData.h"
|
|
#include "MakeDim.h"
|
|
#include "sorttab.h"
|
|
#include "dimfactory.h"
|
|
|
|
|
|
namespace
|
|
{
|
|
#define TEXT_STYLE _T("Pipe_Dim")
|
|
#define STAKE_SECTION _T("DIM_DATA")
|
|
#define STAKE_SEGMENT _T("szStake")
|
|
#define STAKE_TYPE _T("szNodeSpec")
|
|
#define STAKE_FNTYPE _T("eFnType")
|
|
#define NODE_TYPE _T("szNodeSpec")
|
|
#define NODE_ID _T("szLockId")
|
|
#define NODE_NAME _T("szNodeName")
|
|
#define ZDTB_FILE _T("\\zdtbsz.dat")
|
|
#define STAKE_FILE_NAME _T("\\stakedata.dat")
|
|
|
|
// 标尺与网格最左侧间距
|
|
static double g_rule_grid_space = 2;
|
|
// 内容块需要平移的矩阵
|
|
static AcGeMatrix3d g_content_blk_mat;
|
|
// 最后一张图宽度范围
|
|
static std::pair<double, double> g_prRang;
|
|
|
|
}
|
|
|
|
namespace
|
|
{
|
|
bool AddToTableRecord(AcDbEntity* pEnt, AcDbObjectId &id, bool bClose = true, AcDbObjectId *pEntID = NULL)
|
|
{
|
|
if (!pEnt) return false;
|
|
AcDbObjectId entID;
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AcDbBlockTableRecord, pRec)
|
|
if (!pRec) return false;
|
|
pRec->appendAcDbEntity(entID, pEnt);
|
|
if (bClose) pEnt->close();
|
|
OPENOBJ_END()
|
|
if (pEntID)
|
|
*pEntID = entID;
|
|
return true;
|
|
}
|
|
|
|
double getScale(LPCTSTR s)
|
|
{
|
|
if (!s) return .0;
|
|
|
|
AecDbObjXDataMap xDataMap;
|
|
KTModelLayoutXData::ReadModelXData(_T("EW_EARTHWORMINIT"), xDataMap);
|
|
CString scale(_T("1:100"));
|
|
xDataMap.GetAt(s, scale);
|
|
|
|
int idx = scale.Find(_T(":"));
|
|
|
|
CString a = scale.Left(idx);
|
|
CString b = scale.Mid(idx+1);
|
|
|
|
//return _ttof(b)/_ttof(a);
|
|
return 1;
|
|
}
|
|
|
|
bool InBox(const AcGePoint3d &pt, const double maxX, const double &minX)
|
|
{
|
|
return ( pt.x <= maxX && pt.x >= minX );
|
|
}
|
|
|
|
void drawCircle(AcDbObjectId id, const AcGePoint3d &pt, const double &r = 10)
|
|
{
|
|
AcDbCircle *p = new AcDbCircle(pt, AcGeVector3d::kZAxis, r);
|
|
AddToTableRecord(p, id);
|
|
}
|
|
|
|
struct EWNodeDimInfo
|
|
{
|
|
CString strType;
|
|
CString strID;
|
|
CString strStake;
|
|
CString strName;
|
|
int fnType;
|
|
AcDbExtents ext;
|
|
AcGePoint3d getInsPnt() const
|
|
{
|
|
AcGePoint3d ptIns(AcGePoint3d::kOrigin);
|
|
Midpoint((ext.maxPoint()), (ext.minPoint()), ptIns);
|
|
return ptIns;
|
|
}
|
|
struct _com_by_x
|
|
{
|
|
bool operator () (EWNodeDimInfo &a, EWNodeDimInfo &b)
|
|
{
|
|
return a.getInsPnt().x < b.getInsPnt().x;
|
|
}
|
|
};
|
|
};
|
|
typedef std::map<CString, EWNodeDimInfo> EWNodeDimInfos;
|
|
void catalogNodeType(const std::vector<AcDbObjectId> &ids, EWNodeDimInfos &nds)
|
|
{
|
|
AecDbObjXDataMap xmap;
|
|
CString strType(_T("")), strID(_T("")), strStake(_T("")), strName(_T(""));
|
|
int fnType;
|
|
AcDbObjectId id;
|
|
EWNodeDimInfo info;
|
|
double dist(.0);
|
|
for (size_t i = 0; i < ids.size(); ++i)
|
|
{
|
|
id = ids[i];
|
|
xmap.Empty();
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AcDbEntity, pEnt)
|
|
if (!xmap.Read(pEnt, STAKE_SECTION)) continue;
|
|
if (!xmap.GetAt(NODE_TYPE, strType)) continue;
|
|
if (!xmap.GetAt(NODE_ID, strID)) continue;
|
|
if (!xmap.GetAt(STAKE_FNTYPE, fnType)) continue;
|
|
|
|
if (xmap.GetAt(STAKE_SEGMENT, strStake)) // 非必须
|
|
info.strStake = strStake;
|
|
|
|
xmap.GetAt(NODE_NAME, strName);
|
|
|
|
// 里程节点不需要标注
|
|
if (fnType == kStackNode) continue;
|
|
// 变形缝不需要标注
|
|
if (fnType == kEspJoint) continue;
|
|
|
|
// 子变形缝需要看一下配置
|
|
if (fnType == kSubEspJoint)
|
|
{
|
|
bool bDimJoin = TypeConvert::s2i(ZD_OUT::getConfiguration(ZD_OUT::KEY_BXFBZ_S)) == 0 ? false : true;
|
|
if (!bDimJoin) continue;
|
|
}
|
|
|
|
info.strID = strID;
|
|
info.fnType = fnType;
|
|
info.strType = strType;
|
|
info.strName = strName;
|
|
|
|
EWNodeDimInfos::iterator it = nds.find(strID);
|
|
AcDbExtents ext;
|
|
pEnt->getGeomExtents(ext);
|
|
|
|
if (it == nds.end())// 未找到，新建
|
|
{
|
|
info.ext = ext;
|
|
nds.insert(std::make_pair(strID, info));
|
|
}
|
|
else
|
|
it->second.ext.addExt(ext);
|
|
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace
|
|
{
|
|
std::vector<std::pair<CString, CString>> g_config;
|
|
// 生成默认的配置数据
|
|
int initConfig()
|
|
{
|
|
for (size_t i = 0; i < sizeof(ZD_OUT::g_TableHead) / sizeof(LPCTSTR); i++)
|
|
g_config.push_back(std::make_pair(ZD_OUT::g_TableHead[i], _T("1")));
|
|
|
|
// 纵断计算数据 文字设置
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_HEAD_H, _T("2")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_HEAD_S, _T("Pipe_Dim")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_HEAD_W, _T("0.75")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_DATA_H, _T("1.5")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_DATA_S, _T("Pipe_Dim")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_DATA_W, _T("0.5")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_DATA_GL_STAKENO, _T("K0+000")));
|
|
|
|
// 网格设置
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_GRID_INTERVAL, _T("1")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_GRID_PREC, _T("1")));
|
|
|
|
// 网格设置 文字设置
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_RATIO_H , _T("0.5")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_RATIO_S , _T("Pipe_Dim")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_RATIO_W , _T("0.5")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_GRID_H , _T("0.5")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_GRID_S , _T("Pipe_Dim")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_GRID_W , _T("0.5")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_ARROW_W , _T("0.25")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_GRID_WH, _T("0.25")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_GRID_TEXT_INTERVAL, _T("0.75")));
|
|
|
|
// 节点设置
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_NODE_SCALE, _T("1.0")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_BXFBZ_S, _T("1")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_NODE_DIMTYPE, _T("1")));
|
|
|
|
// 引出标注设置
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_YCBZ_H , _T("1.75")));
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_YCBZ_S , _T("Pipe_Dim")));
|
|
|
|
// 其它设置
|
|
g_config.push_back(std::make_pair(ZD_OUT::KEY_QTSZ_LCJG , _T("200")));
|
|
|
|
return 1;
|
|
}
|
|
|
|
void split(LPCTSTR pszSrc, TCHAR sp, std::vector<CString> &vec)
|
|
{
|
|
if (!pszSrc) return;
|
|
|
|
vec.clear();
|
|
|
|
CString src(pszSrc);
|
|
|
|
CString oneString(_T(""));
|
|
TCHAR ch;
|
|
for (int i = 0; i < src.GetLength(); ++i)
|
|
{
|
|
ch = src[i];
|
|
if (ch == sp)
|
|
{
|
|
if (oneString.IsEmpty())
|
|
continue;
|
|
else
|
|
{
|
|
vec.push_back(oneString);
|
|
oneString.Empty();
|
|
}
|
|
}
|
|
else
|
|
oneString += ch;
|
|
}
|
|
if (!oneString.IsEmpty())
|
|
vec.push_back(oneString);
|
|
}
|
|
|
|
void analyGradeAndDistance(LPCTSTR psz, CString &sGrade, CString &sDistance, CString &start, CString &end)
|
|
{
|
|
// 坡度%/距离(起始号-结束号)
|
|
|
|
if (!psz) return;
|
|
CString str(psz);
|
|
|
|
// idx1 '/' 位置
|
|
int idx1 = str.FindOneOf(_T("/"));
|
|
if (idx1 == -1) return;
|
|
sGrade = str.Left(idx1);
|
|
|
|
// idx2 '(' 位置
|
|
int idx2 = str.Find(_T("("), idx1);
|
|
if (idx2 == -1) return;
|
|
sDistance = str.Mid(idx1 + 1, idx2 - idx1 - 1);
|
|
|
|
// idx3 '-'位置
|
|
int idx3 = str.Find(_T("-"), idx2);
|
|
if (idx3 == -1) return;
|
|
start = str.Mid(idx2 + 1, idx3 - idx2 - 1);
|
|
|
|
|
|
// idx4 ')'位置
|
|
int idx4 = str.Find(_T(")"), idx3);
|
|
if (idx4 == -1) return;
|
|
end = str.Mid(idx3 + 1, idx4 - idx3 - 1);
|
|
|
|
return;
|
|
}
|
|
|
|
bool readConfiguration()
|
|
{
|
|
CString sPath = FilePath::getProgramDataFolder() + ZDTB_FILE;
|
|
if (_taccess(sPath, 0x0) != 0x0) return false;
|
|
|
|
CStdioFile file(sPath, CFile::shareDenyRead);
|
|
if (!file.m_hFile) return false;
|
|
|
|
CString line(_T(""));
|
|
std::vector<CString> vec(0);
|
|
std::pair<CString, CString> pr;
|
|
std::vector<std::pair<CString, CString>> _temp(0);
|
|
while (file.ReadString(line))
|
|
{
|
|
split(line, _T('='), vec);
|
|
if (vec.size() != 2) continue;
|
|
pr.first = vec[0];
|
|
pr.second = vec[1];
|
|
_temp.push_back(pr);
|
|
}
|
|
|
|
int countOfHead = sizeof(ZD_OUT::g_TableHead) / sizeof(LPCTSTR);
|
|
|
|
// 前countOfHead个为纵断数据顺序，所以要与文件中一至
|
|
if (_temp.size() < countOfHead) return false;
|
|
|
|
std::vector<std::pair<CString, CString>>::iterator it_temp = _temp.begin()
|
|
, it_config = g_config.begin();
|
|
|
|
std::advance(it_temp, countOfHead);
|
|
std::advance(it_config, countOfHead);
|
|
|
|
// 将 g_config 尾部备份
|
|
std::vector<std::pair<CString, CString>> xx(it_config, g_config.end());
|
|
|
|
// 取文件中前 countOfHead 的数据给g_config,此时，g_config会变成countOfHead个
|
|
g_config.assign(_temp.begin(), it_temp);
|
|
|
|
// 把尾部备份还原
|
|
g_config.insert(g_config.end(), xx.begin(), xx.end());
|
|
|
|
// 把尾部的数据与文件中的一一对应
|
|
for (size_t i = countOfHead; i < g_config.size(); ++i)
|
|
{
|
|
for (size_t j = 0; j < _temp.size(); ++j)
|
|
{
|
|
if (_temp[j].first == g_config[i].first)
|
|
{
|
|
g_config[i].second = _temp[j].second;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static int g_init = initConfig();
|
|
|
|
CString getConfiguration(LPCTSTR key)
|
|
{
|
|
if (!key) return _T("");
|
|
std::vector<std::pair<CString, CString>>::iterator it = g_config.begin();
|
|
for (; it != g_config.end(); ++it)
|
|
{
|
|
if (it->first.CompareNoCase(key) == 0)
|
|
return it->second;
|
|
}
|
|
return _T("");
|
|
}
|
|
|
|
CString getScaleS2()
|
|
{
|
|
// 读出纵断比例
|
|
AecDbObjXDataMap xDataMap;
|
|
xDataMap.SetAt(_T("S2"), _T("1:100"));
|
|
KTModelLayoutXData::ReadModelXData(_T("EW_EARTHWORMINIT"), xDataMap);
|
|
CString str(_T("1:100"));
|
|
xDataMap.GetAt(_T("S2"), str);
|
|
return str;
|
|
}
|
|
|
|
void scalePaperSpace(AcDbObjectId paperID , AcDbObjectIdArray &arIDs)
|
|
{
|
|
if (!GLTools::isThisClass<AcDbBlockTableRecord>(paperID)) return;
|
|
if (arIDs.isEmpty()) return;
|
|
|
|
// 读出纵断比例
|
|
CString str(getScaleS2());
|
|
std::vector<CString> vecs(0);
|
|
split(str, _T(':'), vecs);
|
|
if (vecs.size() != 2) return;
|
|
double Yscale = _ttoi(vecs[1]) / _ttoi(vecs[0]);
|
|
// end
|
|
|
|
// 首先新建一个块表
|
|
AcDbObjectId bkID(AcDbObjectId::kNull);
|
|
AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
|
|
if (!pDb) return;
|
|
AcDbBlockTable *pTbl(NULL);
|
|
Acad::ErrorStatus es = pDb->getBlockTable(pTbl, AcDb::kForWrite);
|
|
if (es != Acad::eOk) return;
|
|
|
|
AcDbBlockTableRecord *pRc = new AcDbBlockTableRecord;
|
|
pRc->setName(_T("*xx"));
|
|
if (pTbl->add(pRc) != Acad::eOk)
|
|
{
|
|
pTbl->close();
|
|
return;
|
|
}
|
|
bkID = pRc->objectId();
|
|
pTbl->close();
|
|
// end
|
|
|
|
// 将所有 arIDs 内的实本，都clone出一份，加入到新的块表内,然后删除。
|
|
AcDbExtents ext, extAll;
|
|
AcDbObjectIdArray arrTemp(arIDs);
|
|
for (int i = 0; i < arrTemp.length(); ++i)
|
|
{
|
|
OPENOBJ_BEGIN(arrTemp[i], AcDb::kForWrite, AcDbEntity, pEnt)
|
|
if (!pEnt) continue;
|
|
if (!AcDbCurve::cast(pEnt)) continue;
|
|
pEnt->getGeomExtents(ext);
|
|
extAll.addExt(ext);
|
|
if (pRc->appendAcDbEntity((AcDbCurve*)pEnt->clone()) == Acad::eOk)
|
|
{
|
|
arIDs.removeAt(i);
|
|
pEnt->erase();
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
pRc->close();
|
|
// end
|
|
|
|
// 新建一个 块参照 按比例进行缩放后炸碎，将炸出的实体入到到 paper 中。
|
|
AcDbVoidPtrArray arrPtr;
|
|
AcGePoint3d ptIns(extAll.minPoint());
|
|
AcDbBlockReference *pRef = new AcDbBlockReference(ptIns, bkID);
|
|
AcGeScale3d scale;
|
|
scale.set(1., Yscale, 1.);
|
|
pRef->setScaleFactors(scale);
|
|
es = pRef->explode(arrPtr);
|
|
|
|
OPENOBJ_BEGIN(paperID, AcDb::kForWrite, AcDbBlockTableRecord, pPaper)
|
|
for (size_t i = 0; i < arrPtr.length(); i++)
|
|
{
|
|
AcDbEntity *p = (AcDbEntity*)arrPtr[i];
|
|
if (pPaper->appendAcDbEntity(p) == Acad::eOk)
|
|
arIDs.append(p->objectId());
|
|
}
|
|
OPENOBJ_END()
|
|
|
|
//pRef->close();
|
|
DELETE_PTR(pRef);
|
|
// end
|
|
|
|
// 最后删除 新建的 块表
|
|
OPENOBJ_BEGIN(bkID, AcDb::kForWrite, AcDbBlockTableRecord, pRec)
|
|
if (pRec) pRec->erase();
|
|
OPENOBJ_END()
|
|
// pRc->erase();
|
|
// pRc->close();
|
|
// end
|
|
}
|
|
|
|
void ADSProjectSendToBottom(AcDbObjectId &idPaper, AcDbObjectIdArray &ids)
|
|
{
|
|
Acad::ErrorStatus es;
|
|
OPENOBJ_BEGIN(idPaper, AcDb::kForRead, AcDbBlockTableRecord, pBlock)
|
|
if (!pBlock) return;
|
|
AcDbSortentsTable *pSortTbl(NULL);
|
|
if (Acad::eOk == pBlock->getSortentsTable(pSortTbl, AcDb::kForWrite, true))
|
|
{
|
|
es = pSortTbl->moveToBottom(ids);//moveToTop
|
|
pSortTbl->close();
|
|
}
|
|
OPENOBJ_END()
|
|
acDocManager->sendStringToExecute ( acDocManager->curDocument(), _T("_regen\n"), false, true );
|
|
}
|
|
}
|
|
|
|
namespace
|
|
{
|
|
struct _compare_pt_y { bool operator () (AcGePoint3d pt1, AcGePoint3d pt2) const { return pt1.y < pt2.y; } };
|
|
|
|
// bWeitght 粗线在左，细线在右
|
|
void insertSegmentOfRuleline(AcDbObjectId &id, const AcGePoint3d &ptS, const AcGePoint3d &ptE, bool bWeight)
|
|
{
|
|
double w(TypeConvert::s2f(getConfiguration(ZD_OUT::KEY_GRID_WH)));
|
|
AcGeVector3d vtl(AcGeVector3d::kXAxis * w);
|
|
AcGeVector2d vtp(AcGeVector2d::kXAxis * w * .25f);
|
|
|
|
AcDbLine *pLine = new AcDbLine(bWeight ? ptS : ptS - vtl, bWeight ? ptE : ptE - vtl);
|
|
|
|
AcDbPolyline *pPLine = new AcDbPolyline();
|
|
AcGePoint2d pt2S(ptS.x, ptS.y), pt2E(ptE.x, ptE.y);
|
|
pPLine->addVertexAt(0, bWeight ? pt2S - 3*vtp : pt2S - vtp, 0, w*.5, w*.5);
|
|
pPLine->addVertexAt(1, bWeight ? pt2E - 3*vtp : pt2E - vtp, 0, w*.5, w*.5);
|
|
g_LayerMgr::instance().setLayer(pLine, GLTools::gLayer_ZD_RULE);
|
|
g_LayerMgr::instance().setLayer(pPLine, GLTools::gLayer_ZD_RULE);
|
|
AddToTableRecord(pLine, id);
|
|
AddToTableRecord(pPLine, id);
|
|
}
|
|
|
|
void insertRulelineText(
|
|
AcDbObjectId &id
|
|
, const AcGePoint3d &pt
|
|
, LPCTSTR pszText
|
|
, int clr
|
|
, const float &textH
|
|
, const float &textWFactor
|
|
, LPCTSTR pszTextStyle )
|
|
{
|
|
float fIntervalWithRule(TypeConvert::s2f(getConfiguration(ZD_OUT::KEY_GRID_TEXT_INTERVAL)));
|
|
AcDbText *pText = new AcDbText();
|
|
pText->setHeight(textH);
|
|
pText->setWidthFactor(textWFactor);
|
|
pText->setHorizontalMode(AcDb::kTextRight);
|
|
pText->setTextString(pszText);
|
|
AcGeVector3d vtX(AcGeVector3d::kXAxis * (fIntervalWithRule));
|
|
AcGeVector3d vtY(AcGeVector3d::kYAxis * textH * .5);
|
|
pText->setAlignmentPoint(pt - vtX - vtY);
|
|
|
|
AcDbObjectId idTextStyle = GLTools::getTextStyle(TEXT_STYLE);
|
|
if (!idTextStyle.isNull())
|
|
pText->setTextStyle(idTextStyle);
|
|
|
|
g_LayerMgr::instance().setLayer(pText, GLTools::gLayer_ZD_TEXT_RULE);
|
|
AddToTableRecord(pText, id);
|
|
}
|
|
|
|
// 画比例尺
|
|
void drawScaleRule(
|
|
AcDbObjectId recID
|
|
, AcGePoint3d pt
|
|
, LPCTSTR pszH
|
|
, LPCTSTR pszV
|
|
, const double &arW
|
|
, const double &textH
|
|
, const double &textWF
|
|
, LPCTSTR textStyle )
|
|
{
|
|
AcDbExtents extH, extV;
|
|
AcDbObjectId idTextStyle = GLTools::getTextStyle(textStyle);
|
|
double deltaXH(.0), deltaYH(.0);
|
|
double deltaXV(.0), deltaYV(.0);
|
|
double lenghtH(.0), lenghtV(.0);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
AcDbText *pTextH = new AcDbText();
|
|
pTextH->setHeight(textH);
|
|
pTextH->setWidthFactor(textWF);
|
|
pTextH->setHorizontalMode(AcDb::kTextMid);
|
|
pTextH->setTextString(pszH);
|
|
if (!idTextStyle.isNull()) pTextH->setTextStyle(idTextStyle);
|
|
pTextH->getGeomExtents(extH);
|
|
deltaXH = extH.maxPoint().x - extH.minPoint().x;
|
|
deltaYH = extH.maxPoint().y - extH.minPoint().y;
|
|
lenghtH = deltaXH * 2.5;
|
|
//////////////////////////////////////////////////////////////////////////
|
|
AcDbText *pTextV = new AcDbText();
|
|
pTextV->setHeight(textH);
|
|
pTextV->setWidthFactor(textWF);
|
|
pTextV->setRotation(PI * .5);
|
|
pTextV->setVerticalMode(AcDb::kTextVertMid);
|
|
pTextV->setTextString(pszV);
|
|
if (!idTextStyle.isNull()) pTextV->setTextStyle(idTextStyle);
|
|
pTextV->getGeomExtents(extV);
|
|
deltaXV = extV.maxPoint().x - extV.minPoint().x;
|
|
deltaYV = extV.maxPoint().y - extV.minPoint().y;
|
|
lenghtV = deltaYV * 2.5;
|
|
//////////////////////////////////////////////////////////////////////////
|
|
AcGePoint3d ptIns(pt);
|
|
ptIns.x += arW;
|
|
|
|
double delta(.01);
|
|
pTextV->setAlignmentPoint(AcGePoint3d(ptIns.x - delta, ptIns.y + lenghtV * .5 - deltaYV * .5, ptIns.z));
|
|
pTextH->setAlignmentPoint(AcGePoint3d(ptIns.x + lenghtH * .5 + deltaXV * .5, ptIns.y + deltaYH * .5 + delta, ptIns.z));
|
|
g_LayerMgr::instance().setLayer(pTextH, GLTools::gLayer_ZD_TEXT_SCALE);
|
|
g_LayerMgr::instance().setLayer(pTextV, GLTools::gLayer_ZD_TEXT_SCALE);
|
|
AddToTableRecord(pTextH, recID);
|
|
AddToTableRecord(pTextV, recID);
|
|
|
|
ptIns.x += deltaXV * .5;
|
|
|
|
AcGeVector3d vt;
|
|
AcGePoint3d ptEndH(AcGePoint3d::kOrigin);
|
|
AcGePoint3d ptEndV(AcGePoint3d::kOrigin);
|
|
float arL = arW * 100 / 33;
|
|
// 画横轴
|
|
vt.normalize();
|
|
vt = AcGeVector3d::kXAxis;
|
|
vt *= lenghtH;
|
|
ptEndH = ptIns + vt;
|
|
AcDbPolyline *pLineH = new AcDbPolyline;
|
|
pLineH->addVertexAt(0, AcGePoint2d(ptIns.x, ptIns.y));
|
|
pLineH->addVertexAt(1, AcGePoint2d(ptEndH.x, ptEndH.y), .0, arW, 0.);
|
|
vt.normalize();
|
|
vt *= lenghtH + arL;
|
|
ptEndH = ptIns + vt;
|
|
pLineH->addVertexAt(2, AcGePoint2d(ptEndH.x, ptEndH.y));
|
|
g_LayerMgr::instance().setLayer(pLineH, GLTools::gLayer_ZD_SCALE);
|
|
AddToTableRecord(pLineH, recID);
|
|
|
|
// 画纵轴
|
|
vt.normalize();
|
|
vt = AcGeVector3d::kYAxis;
|
|
vt *= lenghtV;
|
|
ptEndV = ptIns + vt;
|
|
AcDbPolyline *pLineV = new AcDbPolyline;
|
|
pLineV->addVertexAt(0, AcGePoint2d(ptIns.x, ptIns.y));
|
|
pLineV->addVertexAt(1, AcGePoint2d(ptEndV.x, ptEndV.y), 0., arW, .0);
|
|
vt.normalize();
|
|
vt *= lenghtV + arL;
|
|
ptEndV = ptIns + vt;
|
|
pLineV->addVertexAt(2, AcGePoint2d(ptEndV.x, ptEndV.y));
|
|
g_LayerMgr::instance().setLayer(pLineV, GLTools::gLayer_ZD_SCALE);
|
|
AddToTableRecord(pLineV, recID);
|
|
|
|
}
|
|
|
|
// 在 pt 点生成一个标尺和网格，以pt点位原点, 以dOrigin为起始标尺
|
|
// delta grid间距
|
|
// height 垂直总高
|
|
// width 水平总距离
|
|
// factor 为 现实高程与图纸坐标Y值的比例
|
|
// prec 刻度的小数个数
|
|
void drawGrid(AcDbObjectId &id
|
|
, const AcGePoint3d &ptOrigin
|
|
, const double dOrigin
|
|
, const int &ideltaYInterval
|
|
, const double &deltaY
|
|
, const double &deltaX
|
|
, const double &height
|
|
, const double &width
|
|
, const int &prec
|
|
, const float & textH
|
|
, const float & textWFactor
|
|
, LPCTSTR pszTextStyle
|
|
, double &dLeft // 标尺的 X 值
|
|
, double &dMid // 网格最左 X 值
|
|
, double &dRight // 网格最右 X 值
|
|
, double &dDown // 网格最下 Y 值
|
|
)
|
|
{
|
|
// 计算格子
|
|
double dSpace(g_rule_grid_space);
|
|
double _deltaY = deltaY * ideltaYInterval;
|
|
int h = int((width - dSpace) / deltaX);
|
|
int v = int(height / deltaY);
|
|
int v1 = int(height / _deltaY);
|
|
|
|
AcGeVector3d vtY(AcGeVector3d::kYAxis), vtX(AcGeVector3d::kXAxis);
|
|
vtX.normalize();
|
|
vtX *= dSpace;
|
|
vtY.normalize();
|
|
vtY *= _deltaY;
|
|
|
|
std::vector<AcGePoint3d> hpts(0);
|
|
hpts.push_back(ptOrigin + vtX);
|
|
|
|
AcGePoint3d ptUp(ptOrigin/* - vtX*/);
|
|
dLeft = ptUp.x;
|
|
int i(0);
|
|
for (i = 0; i < v1; ++i)
|
|
{
|
|
// 先向上
|
|
insertSegmentOfRuleline(id, ptUp, ptUp + vtY, i % 2 != 0);
|
|
insertRulelineText(id, ptUp, TypeConvert::f2s(dOrigin + (i * ideltaYInterval), &prec), i == 0 ? 1 : 256, textH, textWFactor, pszTextStyle);
|
|
ptUp += vtY;
|
|
}
|
|
insertRulelineText(id, ptUp, TypeConvert::f2s(dOrigin + (i * ideltaYInterval), &prec), i == 0 ? 1 : 256, textH, textWFactor, pszTextStyle);
|
|
|
|
vtY.normalize();
|
|
vtY *= deltaY;
|
|
ptUp = ptOrigin + vtX;
|
|
for (i = 0; i < v; ++i)
|
|
{
|
|
ptUp += vtY;
|
|
hpts.push_back(ptUp);
|
|
}
|
|
|
|
AcDbObjectIdArray ids;
|
|
AcDbObjectId entID;
|
|
// 画横线
|
|
vtX.normalize();
|
|
vtX *= h * deltaX;
|
|
AcDbLine *pL(NULL);
|
|
AcDbObjectId _id;
|
|
AcGePoint3d ptTemp(AcGePoint3d::kOrigin);
|
|
for (size_t i = 0; i < hpts.size(); ++i)
|
|
{
|
|
ptTemp = hpts[i];
|
|
pL = new AcDbLine(ptTemp, ptTemp + vtX);
|
|
g_LayerMgr::instance().setLayer(pL, GLTools::gLayer_ZD_GRID_LINE);
|
|
AddToTableRecord(pL, id, true, &_id);
|
|
ids.append(_id);
|
|
}
|
|
dMid = ptTemp.x;
|
|
dRight = ptTemp.x + vtX.length();
|
|
|
|
// 画纵线
|
|
vtX.normalize();
|
|
vtX *= deltaX;
|
|
vtY.normalize();
|
|
vtY *= (v)* deltaY;
|
|
AcGePoint3d ptS(*hpts.begin());
|
|
for (int i = 0; i < h + 1; ++i)
|
|
{
|
|
pL = new AcDbLine(ptS, ptS + vtY);
|
|
g_LayerMgr::instance().setLayer(pL, GLTools::gLayer_ZD_GRID_LINE);
|
|
AddToTableRecord(pL, id, true, &_id);
|
|
ptS += vtX;
|
|
ids.append(_id);
|
|
}
|
|
dDown = ptS.y;
|
|
|
|
ads_name ss;
|
|
acedSSAdd(NULL, NULL, ss);
|
|
for (long i = 0; i < ids.length(); ++i)
|
|
{
|
|
ads_name nn;
|
|
acdbGetAdsName(nn, ids[i]);
|
|
acedSSAdd(nn, ss, ss);
|
|
acedSSFree(nn);
|
|
}
|
|
|
|
SHacedCommand(RTSTR, _T(".DRAWORDER"), RTPICKS, ss, RTSTR, _T(""), RTSTR, _T("B"), RTSTR, _T(""), RTNONE);
|
|
|
|
acedSSFree(ss);
|
|
}
|
|
|
|
|
|
// 得到纵断的标志点，共三点，“设计道路端点” “上标程点” “下标程点”
|
|
void getMarkPoints(const AcDbObjectIdArray &arrIDs, std::map<AcGePoint3d, double, _compare_pt_y> &ptMap)
|
|
{
|
|
AecDbObjXDataMap xmap;
|
|
AcGePoint3d pt(AcGePoint3d::kOrigin);
|
|
double dY(.0);
|
|
for (int i = 0; i < arrIDs.length(); ++i)
|
|
{
|
|
OPENOBJ_BEGIN(arrIDs[i], AcDb::kForRead, AcDbPoint, pPt)
|
|
if (!pPt) continue;
|
|
if (!xmap.Read(pPt, _T("StaEl"))) continue;
|
|
if (!xmap.GetAt(_T("StaEl"), dY)) continue;
|
|
ptMap.insert(std::make_pair(pPt->position(), dY));
|
|
xmap.Empty();
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
bool generateStakeRecordByFile(std::vector<CStakeRecord> &records)
|
|
{
|
|
CString sPath = FilePath::getSystemTemporaryFolder() + _T("\\") + STAKE_FILE_NAME;
|
|
if (_taccess(sPath, 0x0) != 0x0) return false;
|
|
|
|
CStdioFile file(sPath, CFile::shareDenyRead);
|
|
if (!file.m_hFile) return false;
|
|
|
|
std::vector<CString> stakes(0) // 桩号
|
|
, soils(0) // 管廊覆土
|
|
, topElev(0) // 管廊外顶标高
|
|
, currentGroundElev(0) // 现状地面高程
|
|
, designGroundElev(0) // 设计地面高程
|
|
, gradAndDistance(0) // 设计坡度与距离
|
|
, bottomInnerElev(0) // 管廊内底标高
|
|
, glStakes(0) // 管廊内底标高
|
|
, soilElev(0) // 覆土高度
|
|
, shEwVol(0) // 盾构体积
|
|
, guid(0) // GUID
|
|
;
|
|
|
|
CString sLine(_T(""));
|
|
std::vector<CString> vec(0);
|
|
while (file.ReadString(sLine))
|
|
{
|
|
vec.clear();
|
|
split(sLine, ' ', vec);
|
|
if (vec.empty()) continue;
|
|
if (vec[0].Compare(ZD_OUT::KEY_STAKENO) == 0)
|
|
stakes.assign(++vec.begin(), vec.end());
|
|
else if (vec[0].Compare(ZD_OUT::KEY_SOIL) == 0)
|
|
soils.assign(++vec.begin(), vec.end());
|
|
else if (vec[0].Compare(ZD_OUT::KEY_TOP_ELEV) == 0)
|
|
topElev.assign(++vec.begin(), vec.end());
|
|
else if (vec[0].Compare(ZD_OUT::KEY_CURRENT_GROUND_ELEV) == 0)
|
|
currentGroundElev.assign(++vec.begin(), vec.end());
|
|
else if (vec[0].Compare(ZD_OUT::KEY_DESIGN_GROUND_ELEV) == 0)
|
|
designGroundElev.assign(++vec.begin(), vec.end());
|
|
else if (vec[0].Compare(ZD_OUT::KEY_GRADE_DISTANCE) == 0)
|
|
gradAndDistance.assign(++vec.begin(), vec.end());
|
|
else if (vec[0].Compare(ZD_OUT::KEY_BOTTOM_INNER_ELEV) == 0)
|
|
bottomInnerElev.assign(++vec.begin(), vec.end());
|
|
else if (vec[0].Compare(ZD_OUT::KEY_GL_STAKENO) == 0)
|
|
glStakes.assign(++vec.begin(), vec.end());
|
|
else if (vec[0].Compare(ZD_OUT::KEY_SOIL_ELEV) == 0)
|
|
soilElev.assign(++vec.begin(), vec.end());
|
|
else if (vec[0].Compare(ZD_OUT::KEY_NODE_GUID) == 0)
|
|
guid.assign(++vec.begin(), vec.end());
|
|
else if (vec[0].Compare(ZD_OUT::KEY_SH_EW_VOL) == 0)
|
|
shEwVol.assign(++vec.begin(), vec.end());
|
|
|
|
}
|
|
|
|
file.Close();
|
|
|
|
if (stakes.empty()) return false;
|
|
|
|
if (stakes.size() != soils.size()
|
|
|| stakes.size() != topElev.size()
|
|
|| stakes.size() != currentGroundElev.size()
|
|
|| stakes.size() != designGroundElev.size()) return false;
|
|
|
|
CStakeRecord record0(ZD_OUT::KEY_STAKENO, stakes, stakes);
|
|
CStakeRecord record1(ZD_OUT::KEY_SOIL, stakes, soils);
|
|
CStakeRecord record2(ZD_OUT::KEY_TOP_ELEV, stakes, topElev);
|
|
CStakeRecord record3(ZD_OUT::KEY_CURRENT_GROUND_ELEV, stakes, currentGroundElev);
|
|
CStakeRecord record4(ZD_OUT::KEY_DESIGN_GROUND_ELEV, stakes, designGroundElev);
|
|
CStakeRecord record5(ZD_OUT::KEY_GRADE_DISTANCE, gradAndDistance);
|
|
CStakeRecord record6(ZD_OUT::KEY_BOTTOM_INNER_ELEV, stakes, bottomInnerElev);
|
|
CStakeRecord record7(ZD_OUT::KEY_GL_STAKENO, stakes, glStakes);
|
|
CStakeRecord record8(ZD_OUT::KEY_SOIL_ELEV, stakes, soilElev);
|
|
CStakeRecord record9(ZD_OUT::KEY_NODE_GUID, stakes, guid);
|
|
CStakeRecord record10(ZD_OUT::KEY_SH_EW_VOL, stakes, shEwVol);
|
|
|
|
records.push_back(record0);
|
|
records.push_back(record1);
|
|
records.push_back(record2);
|
|
records.push_back(record3);
|
|
records.push_back(record4);
|
|
records.push_back(record5);
|
|
records.push_back(record6);
|
|
records.push_back(record7);
|
|
records.push_back(record8);
|
|
records.push_back(record9);
|
|
|
|
// 检查 "盾构体积" 是否有效，如有效，放入
|
|
for (size_t i = 0; i < shEwVol.size(); ++i)
|
|
{
|
|
double d = TypeConvert::s2f(shEwVol[i]);
|
|
if (!EQUAL_ZERO(d))
|
|
{
|
|
records.push_back(record10);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void generateStakeInsertPoint(const AcDbObjectIdArray &arrIDs, CStakeRecord::StakeInsPts &stPts)
|
|
{
|
|
AecDbObjXDataMap xmap;
|
|
CString strStake(_T("")), strType(_T(""));
|
|
int fnType(0);
|
|
AcGePoint3d ptS(AcGePoint3d::kOrigin)
|
|
, ptE(AcGePoint3d::kOrigin)
|
|
, ptIns(AcGePoint3d::kOrigin);
|
|
int bCenterPt(0);
|
|
AcDbExtents ext, extAll;
|
|
CStakeRecord::StakeInsPts arCenPts;
|
|
for (int i = 0; i < arrIDs.length(); ++i)
|
|
{
|
|
OPENOBJ_BEGIN(arrIDs[i], AcDb::kForRead, AcDbEntity, pEnt)
|
|
if (!pEnt) continue;
|
|
|
|
if (AcDbBlockReference::cast(pEnt)) continue;
|
|
|
|
pEnt->getGeomExtents(ext);
|
|
extAll.addExt(ext);
|
|
|
|
if (!xmap.Read(pEnt, STAKE_SECTION)) continue;
|
|
if (!xmap.GetAt(STAKE_SEGMENT, strStake)) continue;
|
|
if (!xmap.GetAt(STAKE_TYPE, strType)) continue;
|
|
if (!xmap.GetAt(STAKE_FNTYPE, fnType)) continue;
|
|
|
|
// 直线上的起点和终点，哪一点的Y值小，取哪一点
|
|
AcDbPoint *pPt = AcDbPoint::cast(pEnt);
|
|
if (pPt)
|
|
{
|
|
if (xmap.GetAt(_T("CenterPoint"), bCenterPt) && fnType == kProModel)
|
|
{
|
|
ptIns = pPt->position();
|
|
arCenPts.insert(std::make_pair(strStake, ptIns));
|
|
}
|
|
else
|
|
{
|
|
ptIns = pPt->position();
|
|
stPts.insert(std::make_pair(strStake, ptIns));
|
|
}
|
|
}
|
|
|
|
xmap.Empty();
|
|
|
|
OPENOBJ_END()
|
|
}
|
|
|
|
|
|
for (CStakeRecord::StakeInsPts::iterator it = arCenPts.begin(); it != arCenPts.end(); ++it)
|
|
{
|
|
CString key(it->first);
|
|
CStakeRecord::StakeInsPts::iterator _it = stPts.find(key);
|
|
if (_it != stPts.end())
|
|
_it->second = it->second;
|
|
}
|
|
|
|
// 所有桩号的对应的点的Y值统一为最小值
|
|
for (CStakeRecord::StakeInsPts::iterator it = stPts.begin(); it != stPts.end(); ++it)
|
|
(it->second).y = extAll.minPoint().y;
|
|
}
|
|
|
|
void generateMileStoneRecord(const AcDbObjectIdArray &arrIDs, CStakeRecord &rec)
|
|
{
|
|
rec.setRecType(CStakeRecord::eMilestoneRec);
|
|
rec.setHeadString(ZD_OUT::KEY_MILESTONE);
|
|
|
|
AecDbObjXDataMap xmap;
|
|
std::set<CString> stakeSet;
|
|
CString strStake(_T("")), strType(_T(""));
|
|
int fnType(0);
|
|
CStakeRecord::_Data_ data;
|
|
for (int i = 0; i < arrIDs.length(); ++i)
|
|
{
|
|
OPENOBJ_BEGIN(arrIDs[i], AcDb::kForRead, AcDbEntity, pEnt)
|
|
|
|
if (!pEnt) continue;
|
|
if (!xmap.Read(pEnt, STAKE_SECTION)) continue;
|
|
if (!xmap.GetAt(STAKE_SEGMENT, strStake)) continue;
|
|
if (!xmap.GetAt(STAKE_TYPE, strType)) continue;
|
|
if (!xmap.GetAt(STAKE_FNTYPE, fnType)) continue;
|
|
|
|
if (fnType != kStackNode) continue;
|
|
|
|
if (!stakeSet.insert(strStake).second) continue;
|
|
|
|
data.stake = strStake;
|
|
data.sData = strStake;
|
|
rec.addData(data);
|
|
|
|
xmap.Empty();
|
|
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void analyFeatureString(LPCTSTR src, std::map<CString, std::vector<CString>> &features, std::vector<CString> &vfeatures)
|
|
{
|
|
std::vector<CString> v0(0); // <电力舱:xxx;xxx;xxx><燃气舱:xxx;xxx;xxx>...
|
|
std::vector<CString> v1(0); // <电力舱><xxx;xxx;xxx>
|
|
std::vector<CString> v2(0); // <电力舱><xxx;xxx;xxx>
|
|
split(src, _T('|'), v0);
|
|
if (v0.empty()) return;
|
|
vfeatures.assign(v0.begin(), v0.end());
|
|
std::pair<CString, std::vector<CString>> pr;
|
|
for (size_t i = 0; i < v0.size(); ++i)
|
|
{
|
|
pr.second.clear();
|
|
split(v0[i], _T(':'), v1);
|
|
if (v1.size() != 2) continue;
|
|
pr.first = v1[0];
|
|
split(v1[1], _T(';'), v2);
|
|
for (size_t j = 0; j < v2.size(); ++j)
|
|
{
|
|
pr.second.push_back(v2[j]);
|
|
}
|
|
features.insert(pr);
|
|
}
|
|
}
|
|
|
|
void generatekFeatureRecord(const AcDbObjectIdArray &arrIDs, CStakeRecord &rec)
|
|
{
|
|
rec.setRecType(CStakeRecord::eFeatureRec);
|
|
rec.setHeadString(ZD_OUT::KEY_FEATURE);
|
|
|
|
AecDbObjXDataMap xmap;
|
|
std::vector<CString>vecs(0);
|
|
std::pair<std::set<CString>::iterator, bool> pr;
|
|
CString strStake(_T("")), strType(_T(""));
|
|
int fnType(0);
|
|
CStakeRecord::_Data_ *pData(NULL), data;
|
|
std::map<CString, std::vector<CString>> features;
|
|
for (int i = 0; i < arrIDs.length(); ++i)
|
|
{
|
|
OPENOBJ_BEGIN(arrIDs[i], AcDb::kForRead, AcDbEntity, pEnt)
|
|
|
|
if (!pEnt) continue;
|
|
if (!xmap.Read(pEnt, STAKE_SECTION)) continue;
|
|
if (!xmap.GetAt(STAKE_SEGMENT, strStake)) continue;
|
|
if (!xmap.GetAt(STAKE_TYPE, strType)) continue;
|
|
if (!xmap.GetAt(STAKE_FNTYPE, fnType)) continue;
|
|
|
|
// 去掉变形缝
|
|
//if (fnType < kEspJoint || fnType > kProModel) continue;
|
|
if (fnType < kEspJoint + 1 || fnType > kProModel) continue;
|
|
|
|
data.clear();
|
|
|
|
if (fnType == kProModel)
|
|
{
|
|
features.clear();
|
|
vecs.clear();
|
|
analyFeatureString(strType, features, vecs);
|
|
if (rec.findData(strStake, pData))
|
|
{
|
|
for (size_t i = 0; i < vecs.size(); ++i)
|
|
pData->features.insert(vecs[i]);
|
|
}
|
|
else
|
|
{
|
|
data.stake = strStake;
|
|
for (size_t i = 0; i < vecs.size(); ++i)
|
|
data.features.insert(vecs[i]);
|
|
rec.addData(data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (rec.findData(strStake, pData))
|
|
{
|
|
pData->features.insert(strType);
|
|
}
|
|
else
|
|
{
|
|
data.stake = strStake;
|
|
data.features.insert(strType);
|
|
rec.addData(data);
|
|
}
|
|
}
|
|
|
|
xmap.Empty();
|
|
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
// 得到存有所有实体的匿名块ID
|
|
AcDbObjectId getBlockID(const AcDbObjectIdArray &arrIDs)
|
|
{
|
|
AcDbExtents ext;
|
|
for (int i = 0; i < arrIDs.length(); ++i)
|
|
{
|
|
OPENOBJ_BEGIN(arrIDs[i], AcDb::kForRead, AcDbBlockReference, pEnt)
|
|
if (!pEnt) continue;
|
|
OPENOBJ_BEGIN(pEnt->blockTableRecord(), AcDb::kForRead, AcDbBlockTableRecord, pRc)
|
|
if (!pRc) continue;
|
|
if (pRc->isAnonymous()) // 匿名块
|
|
return pEnt->objectId();
|
|
OPENOBJ_END()
|
|
OPENOBJ_END()
|
|
return AcDbObjectId::kNull;
|
|
}
|
|
return AcDbObjectId::kNull;
|
|
}
|
|
// 得到所有实体的外接矩形
|
|
void getExtent(AcDbObjectId &idBlk, AcGePoint3d &ptMin, AcGePoint3d &ptMax)
|
|
{
|
|
AcDbExtents ext;
|
|
OPENOBJ_BEGIN(idBlk, AcDb::kForRead, AcDbBlockReference, pEnt)
|
|
if (!pEnt) return;
|
|
OPENOBJ_BEGIN(pEnt->blockTableRecord(), AcDb::kForRead, AcDbBlockTableRecord, pRc)
|
|
if (!pRc) return;
|
|
if (pRc->isAnonymous()) // 匿名块
|
|
pEnt->getGeomExtents(ext);
|
|
OPENOBJ_END()
|
|
OPENOBJ_END()
|
|
|
|
ptMin = ext.minPoint();
|
|
ptMax = ext.maxPoint();
|
|
}
|
|
|
|
// 缩放节点
|
|
typedef std::multimap<CString, AcDbObjectId>::iterator _IT;
|
|
void scaleNodes(_IT it1, _IT it2, const double &scale)
|
|
{
|
|
AcGePoint3d pt(AcGePoint3d::kOrigin);
|
|
AcDbExtents ext, extAll;
|
|
for (_IT it = it1; it != it2; ++it)
|
|
{
|
|
AcDbObjectId &id = it->second;
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pEnt)
|
|
if (!pEnt) continue;
|
|
pEnt->getGeomExtents(ext);
|
|
extAll.addExt(ext);
|
|
OPENOBJ_END()
|
|
}
|
|
pt = extAll.minPoint();
|
|
|
|
pt.x += (extAll.maxPoint().x - extAll.minPoint().x) * .5;
|
|
|
|
AcGeMatrix3d mat;
|
|
mat.setToScaling(scale, pt);
|
|
for (_IT it = it1; it != it2; ++it)
|
|
{
|
|
AcDbObjectId &id = it->second;
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AcDbEntity, pEnt)
|
|
if (!pEnt) continue;
|
|
pEnt->transformBy(mat);
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void scaleNodes(const AcDbObjectIdArray &arrIDs, const float &scale)
|
|
{
|
|
|
|
AcGeMatrix3d mat;
|
|
mat.setToScaling(scale);
|
|
|
|
int iType(0);
|
|
CString strID(_T(""));
|
|
AecDbObjXDataMap xmap;
|
|
std::multimap<CString, AcDbObjectId> idmaps;
|
|
for (int i = 0; i < arrIDs.length(); ++i)
|
|
{
|
|
OPENOBJ_BEGIN(arrIDs[i], AcDb::kForRead, AcDbEntity, pEnt)
|
|
if (!pEnt) continue;
|
|
|
|
if (AcDbBlockReference::cast(pEnt)) continue;
|
|
|
|
if (!xmap.Read(pEnt, STAKE_SECTION)) continue;
|
|
if (!xmap.GetAt(STAKE_FNTYPE, iType)) continue;
|
|
if (!xmap.GetAt(NODE_ID, strID)) continue;
|
|
|
|
if (pEnt->colorIndex() <= 0 || pEnt->colorIndex() > 6) continue;
|
|
|
|
if (iType == kPipeDoghouse
|
|
|| iType == kCableDoghouse
|
|
|| iType == kHeatDoghouse
|
|
|| iType == kVenDoghouse
|
|
|| iType == kEscapeHatch)
|
|
{
|
|
idmaps.insert(std::make_pair(strID, pEnt->objectId()));
|
|
}
|
|
xmap.Empty();
|
|
|
|
OPENOBJ_END()
|
|
}
|
|
|
|
_IT it(idmaps.begin());
|
|
std::pair<_IT, _IT> pr;
|
|
while (it != idmaps.end())
|
|
{
|
|
pr = idmaps.equal_range(it->first);
|
|
scaleNodes(pr.first, pr.second, scale);
|
|
it = pr.second;
|
|
}
|
|
}
|
|
|
|
double getFrameScaleD(const AcDbObjectIdArray &arrIDs)
|
|
{
|
|
AcGeScale3d scale;
|
|
CString str(_T(""));
|
|
for (size_t i = 0; i < arrIDs.length(); ++i)
|
|
{
|
|
OPENOBJ_BEGIN(arrIDs[i], AcDb::kForRead, AcDbBlockReference, pEnt)
|
|
if (!pEnt) continue;
|
|
OPENOBJ_BEGIN(pEnt->blockTableRecord(), AcDb::kForRead, AcDbBlockTableRecord, pRc)
|
|
if (!pRc) continue;
|
|
if (!pRc->isAnonymous()) // 非匿名块,即是图框块
|
|
{
|
|
scale = pEnt->scaleFactors();
|
|
return scale.sx;
|
|
}
|
|
OPENOBJ_END()
|
|
OPENOBJ_END()
|
|
}
|
|
return 1.;
|
|
}
|
|
|
|
CString getFrameScaleS(const AcDbObjectIdArray &arrIDs)
|
|
{
|
|
AcGeScale3d scale;
|
|
CString str(_T(""));
|
|
for (size_t i = 0; i < arrIDs.length(); ++i)
|
|
{
|
|
OPENOBJ_BEGIN(arrIDs[i], AcDb::kForRead, AcDbBlockReference, pEnt)
|
|
if (!pEnt) continue;
|
|
OPENOBJ_BEGIN(pEnt->blockTableRecord(), AcDb::kForRead, AcDbBlockTableRecord, pRc)
|
|
if (!pRc) continue;
|
|
if (!pRc->isAnonymous()) // 非匿名块,即是图框块
|
|
{
|
|
scale = pEnt->scaleFactors();
|
|
str.Format(_T("1:%d"), (int)(scale.sx * 1000));
|
|
return str;
|
|
}
|
|
OPENOBJ_END()
|
|
OPENOBJ_END()
|
|
}
|
|
return _T("1:1");
|
|
}
|
|
|
|
void collectEntityByXData(AcDbObjectId &recId, LPCTSTR pszSection, std::vector<AcDbObjectId> &ids)
|
|
{
|
|
if (!pszSection) return;
|
|
|
|
// 遍历所有实体，判断其扩展数据为桩号的直线，将其保存
|
|
Acad::ErrorStatus es;
|
|
AcDbEntity *pEnt(NULL);
|
|
AcDbBlockTableRecordIterator *pIter(NULL);
|
|
|
|
OPENOBJ_BEGIN(recId, AcDb::kForWrite, AcDbBlockTableRecord, pRec)
|
|
if (!pRec) return;
|
|
pRec->newIterator(pIter);
|
|
if (!pIter) return;
|
|
AecDbObjXDataMap xDataMap;
|
|
CString stakeNo(_T(""));
|
|
AcGePoint3d ptS(AcGePoint3d::kOrigin), ptE(AcGePoint3d::kOrigin);
|
|
for (pIter->start(); !pIter->done(); pIter->step())
|
|
{
|
|
es = pIter->getEntity(pEnt, AcDb::kForRead);
|
|
if (!pEnt) continue;
|
|
if (xDataMap.Read(pEnt, pszSection))
|
|
{
|
|
ids.push_back(pEnt->objectId());
|
|
}
|
|
pEnt->close();
|
|
}
|
|
OPENOBJ_END()
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d getGeometryCenter(AcDbEntity *pEnt)
|
|
{
|
|
if (!pEnt) return AcGePoint3d::kOrigin;
|
|
AcDbExtents ext;
|
|
pEnt->getGeomExtents(ext);
|
|
return AcGePoint3d((ext.maxPoint().x + ext.minPoint().x) * .5
|
|
,(ext.maxPoint().y + ext.minPoint().y) * .5
|
|
, (ext.maxPoint().z + ext.minPoint().z) * .5);
|
|
}
|
|
|
|
CString getTraitString(LPCTSTR psz, const AcGePoint3d &pt)
|
|
{
|
|
if (!psz) return _T("");
|
|
CString str(psz);
|
|
str += TypeConvert::f2s(pt.x);
|
|
str += TypeConvert::f2s(pt.y);
|
|
str += TypeConvert::f2s(pt.z);
|
|
return str;
|
|
}
|
|
|
|
Acad::ErrorStatus transformBy(AcDbObjectId &id, AcGeMatrix3d mat)
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AcDbEntity, pEnt)
|
|
if (pEnt)
|
|
return pEnt->transformBy(mat);
|
|
OPENOBJ_END()
|
|
return Acad::eInvalidInput;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
#pragma region CStakeRecord
|
|
|
|
float CStakeRecord::m_dataTextHeight;
|
|
|
|
float CStakeRecord::m_dataTextFactor;
|
|
|
|
CString CStakeRecord::m_dataTextStyle;
|
|
|
|
float CStakeRecord::m_headTextHeight;
|
|
|
|
float CStakeRecord::m_headTextFactor;
|
|
|
|
CString CStakeRecord::m_headTextStyle;
|
|
|
|
double CStakeRecord::m_dTxtSpace = 1;
|
|
|
|
double CStakeRecord::m_dHeadTblTxtSpace = 1;
|
|
|
|
CStakeRecord::CStakeRecord(LPCTSTR head
|
|
, const std::vector<CString> &stakes
|
|
, const std::vector<CString> &data)
|
|
: m_sHead(head)
|
|
, m_type(eStringRec)
|
|
, m_datas(0)
|
|
{
|
|
if (stakes.size() != data.size()) return;
|
|
_Data_ d;
|
|
for (size_t i = 0; i < stakes.size(); ++i)
|
|
{
|
|
d.stake = stakes[i];
|
|
d.sData = data[i];
|
|
m_datas.push_back(d);
|
|
}
|
|
}
|
|
|
|
CStakeRecord::CStakeRecord(LPCTSTR head
|
|
, const std::vector<CString> &data)
|
|
: m_sHead(head)
|
|
, m_type(eGradRec)
|
|
, m_datas(0)
|
|
{
|
|
_Data_ d1, d2;
|
|
CString grade(_T("")), distance(_T("")), start(_T("")), end(_T(""));
|
|
for (size_t i = 0; i < data.size(); ++i)
|
|
{
|
|
analyGradeAndDistance(data[i], grade, distance, start, end);
|
|
d1.stake = start;
|
|
d1.sData = grade;
|
|
d2.stake = end;
|
|
d2.sData = distance;
|
|
m_datas.push_back(d1);
|
|
m_datas.push_back(d2);
|
|
}
|
|
}
|
|
|
|
double CStakeRecord::getHeadStringExtentX()
|
|
{
|
|
AcDbExtents ext;
|
|
AcDbText *p = generateText_H(m_sHead, m_headTextHeight, m_headTextFactor, m_headTextStyle);
|
|
if (p)
|
|
{
|
|
p->getGeomExtents(ext);
|
|
DELETE_PTR(p);
|
|
}
|
|
return ext.maxPoint().x - ext.minPoint().x;
|
|
}
|
|
|
|
double CStakeRecord::getHeadStringExtentY()
|
|
{
|
|
AcDbExtents ext;
|
|
AcDbText *p = generateText_H(m_sHead, m_headTextHeight, m_headTextFactor, m_headTextStyle);
|
|
if (p)
|
|
{
|
|
p->getGeomExtents(ext);
|
|
DELETE_PTR(p);
|
|
}
|
|
return ext.maxPoint().y - ext.minPoint().y;
|
|
}
|
|
|
|
double CStakeRecord::getMaxHeight()
|
|
{
|
|
AcDbText *p(NULL);
|
|
AcDbExtents result;
|
|
p = generateText_H(m_sHead, m_headTextHeight, m_headTextFactor, m_headTextStyle);
|
|
if (p)
|
|
{
|
|
result = getTextExtent(p);
|
|
DELETE_PTR(p);
|
|
}
|
|
if (m_type == eFeatureRec)
|
|
{
|
|
for (size_t i = 0; i < m_datas.size(); i++)
|
|
{
|
|
_Data_ &data = m_datas[i];
|
|
std::set<CString>::iterator it = data.features.begin();
|
|
for (; it != data.features.end(); ++it)
|
|
{
|
|
p = generateText_V(*it, m_dataTextHeight, m_dataTextFactor, m_dataTextStyle);
|
|
if (p)
|
|
{
|
|
result.addExt(getTextExtent(p));
|
|
DELETE_PTR(p);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_type != eGradRec)
|
|
{
|
|
for (size_t i = 0; i < m_datas.size(); i++)
|
|
{
|
|
_Data_ &data = m_datas[i];
|
|
p = generateText_V(data.sData, m_dataTextHeight, m_dataTextFactor, m_dataTextStyle);
|
|
if (p)
|
|
{
|
|
result.addExt(getTextExtent(p));
|
|
DELETE_PTR(p);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result.maxPoint().y - result.minPoint().y + m_dTxtSpace;
|
|
}
|
|
|
|
void CStakeRecord::calcInsertPointY(const double &up, double &rowMaxH)
|
|
{
|
|
double delta(.2);
|
|
rowMaxH = getMaxHeight();
|
|
double down = up - rowMaxH;
|
|
double dTxtY = down + rowMaxH * .5;
|
|
for (size_t i = 0; i < m_datas.size(); ++i)
|
|
m_datas[i].pt.y = dTxtY;
|
|
m_ptHead.y = dTxtY;
|
|
}
|
|
|
|
double CStakeRecord::draw(
|
|
AcDbObjectId &id
|
|
, const double &preY
|
|
, const double &headW
|
|
, const double &dLeft
|
|
, const double &dMid
|
|
, const double &dRight
|
|
, const AcGeMatrix3d mat
|
|
)
|
|
{
|
|
m_ptHead.x = dLeft - headW * .5;
|
|
double rowMaxH;
|
|
calcInsertPointY(preY, rowMaxH);
|
|
AcDbText *pText = generateText_H(m_sHead, m_headTextHeight, m_headTextFactor, m_headTextStyle);
|
|
pText->setAlignmentPoint(m_ptHead);
|
|
g_LayerMgr::instance().setLayer(pText, GLTools::gLayer_ZD_TEXT_HEAD);
|
|
AddToTableRecord(pText, id);
|
|
|
|
// 共画8条线，四横四纵，包围 表头 和 数据
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 画数据长线
|
|
AcDbLine *pLine = new AcDbLine(AcGePoint3d(dLeft, preY, 0.), AcGePoint3d(dRight, preY, 0.));
|
|
g_LayerMgr::instance().setLayer(pLine, GLTools::gLayer_ZD_TABLE_LINE);
|
|
AddToTableRecord(pLine, id);
|
|
|
|
pLine = new AcDbLine(AcGePoint3d(dLeft, preY - rowMaxH, 0.), AcGePoint3d(dRight, preY - rowMaxH, 0.));
|
|
g_LayerMgr::instance().setLayer(pLine, GLTools::gLayer_ZD_TABLE_LINE);
|
|
AddToTableRecord(pLine, id);
|
|
|
|
// 两根数据短线
|
|
// pLine = new AcDbLine(AcGePoint3d(dMid, preY, 0.), AcGePoint3d(dMid, preY - rowMaxH, 0.));
|
|
// g_LayerMgr::instance().setLayer(pLine, GLTools::gLayer_ZD_TABLE_LINE);
|
|
// AddToTableRecord(pLine, id);
|
|
|
|
pLine = new AcDbLine(AcGePoint3d(dRight, preY, 0.), AcGePoint3d(dRight, preY - rowMaxH, 0.));
|
|
g_LayerMgr::instance().setLayer(pLine, GLTools::gLayer_ZD_TABLE_LINE);
|
|
AddToTableRecord(pLine, id);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 再画2根短竖线
|
|
pLine = new AcDbLine(AcGePoint3d(dLeft, preY, 0.), AcGePoint3d(dLeft, preY - rowMaxH, 0.));
|
|
g_LayerMgr::instance().setLayer(pLine, GLTools::gLayer_ZD_TABLE_LINE);
|
|
AddToTableRecord(pLine, id);
|
|
|
|
pLine = new AcDbLine(AcGePoint3d(dLeft - headW, preY, 0.), AcGePoint3d(dLeft - headW, preY - rowMaxH, 0.));
|
|
g_LayerMgr::instance().setLayer(pLine, GLTools::gLayer_ZD_TABLE_LINE);
|
|
AddToTableRecord(pLine, id);
|
|
|
|
// 画2根短横线
|
|
pLine = new AcDbLine(AcGePoint3d(dLeft, preY - rowMaxH, 0.), AcGePoint3d(dLeft - headW, preY - rowMaxH, 0.));
|
|
g_LayerMgr::instance().setLayer(pLine, GLTools::gLayer_ZD_TABLE_LINE);
|
|
AddToTableRecord(pLine, id);
|
|
|
|
pLine = new AcDbLine(AcGePoint3d(dLeft, preY, 0.), AcGePoint3d(dLeft - headW, preY, 0.));
|
|
g_LayerMgr::instance().setLayer(pLine, GLTools::gLayer_ZD_TABLE_LINE);
|
|
AddToTableRecord(pLine, id);
|
|
//////////////////////////////////////////////////////////////////////////
|
|
if (m_type == eStringRec || m_type == eMilestoneRec)
|
|
{
|
|
// 绘制数据
|
|
for (size_t i = 0; i < m_datas.size(); ++i)
|
|
{
|
|
_Data_ &data = m_datas[i];
|
|
|
|
if (i != 0)
|
|
{
|
|
if (!InBox(data.pt, dRight, dMid))
|
|
continue;
|
|
}
|
|
|
|
pText = generateText_V(data.sData, m_dataTextHeight, m_dataTextFactor, m_dataTextStyle);
|
|
pText->setAlignmentPoint(data.pt);
|
|
g_LayerMgr::instance().setLayer(pText, GLTools::gLayer_ZD_TEXT_DATA);
|
|
pText->transformBy(mat);
|
|
AddToTableRecord(pText, id);
|
|
}
|
|
}
|
|
else if (m_type == eFeatureRec)
|
|
{
|
|
double x(0);
|
|
for (size_t i = 0; i < m_datas.size(); ++i)
|
|
{
|
|
_Data_ &data(m_datas[i]);
|
|
|
|
if (!InBox(data.pt, dRight, dMid)) continue;
|
|
|
|
if (data.features.empty()) continue;
|
|
x = data.pt.x;
|
|
std::set<CString>::iterator it = data.features.begin();
|
|
for (; it != data.features.end(); ++it)
|
|
{
|
|
pText = generateText_V(*it, m_dataTextHeight, m_dataTextFactor, m_dataTextStyle);
|
|
pText->setAlignmentPoint(AcGePoint3d(x, data.pt.y, .0));
|
|
pText->transformBy(mat);
|
|
g_LayerMgr::instance().setLayer(pText, GLTools::gLayer_ZD_TEXT_DATA);
|
|
AddToTableRecord(pText, id);
|
|
x += m_dataTextHeight;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{ // 绘制坡度
|
|
AcGePoint3d ptS(AcGePoint3d::kOrigin), ptE(AcGePoint3d::kOrigin), ptIns(AcGePoint3d::kOrigin);
|
|
AcDbExtents ext;
|
|
double w(.0), h(.0), delta(.1);
|
|
for (size_t i = 0; i < m_datas.size(); ++i)
|
|
{
|
|
_Data_ &data = m_datas[i];
|
|
|
|
if (!InBox(data.pt, dRight, dMid)) continue;
|
|
|
|
// 先画一条竖线
|
|
ptS.x = ptE.x = data.pt.x;
|
|
ptS.y = preY;
|
|
ptE.y = preY - rowMaxH;
|
|
pLine = new AcDbLine(ptS, ptE);
|
|
g_LayerMgr::instance().setLayer(pLine, GLTools::gLayer_ZD_TEXT_DATA);
|
|
pLine->transformBy(mat);
|
|
AddToTableRecord(pLine, id);
|
|
|
|
pText = generateText_H(data.sData, m_dataTextHeight*.5f, m_dataTextFactor, m_dataTextStyle);
|
|
ptIns = data.pt;
|
|
|
|
pText->getGeomExtents(ext);
|
|
w = ext.maxPoint().x - ext.minPoint().x;
|
|
h = ext.maxPoint().y - ext.minPoint().y;
|
|
w *= .5;
|
|
h *= .5;
|
|
w += delta;
|
|
h += delta;
|
|
|
|
if (data.sData.Find(_T("%")) != -1)
|
|
{ // 有 "%" 为坡度数据，插入点向右移整段宽度的一半
|
|
ptIns.x += w;
|
|
ptIns.y += h;
|
|
}
|
|
else
|
|
{ // 无 "%" 为距离数据，插入点向左移整段宽度的一半
|
|
ptIns.x -= w;
|
|
ptIns.y += h;
|
|
}
|
|
pText->setAlignmentPoint(ptIns);
|
|
pText->transformBy(mat);
|
|
g_LayerMgr::instance().setLayer(pText, GLTools::gLayer_ZD_TEXT_DATA);
|
|
AddToTableRecord(pText, id);
|
|
}
|
|
}
|
|
|
|
return preY - rowMaxH;
|
|
}
|
|
|
|
void CStakeRecord::init(const StakeInsPts &dataSet)
|
|
{
|
|
// 从 dataSet 内找出需要的点
|
|
for (size_t i = 0; i < m_datas.size(); ++i)
|
|
{
|
|
_Data_ &data = m_datas[i];
|
|
StakeInsPts::const_iterator it = dataSet.find(data.stake);
|
|
// 文件中存在的数据，在图形中并没有实体对应
|
|
if (it == dataSet.end()) continue;
|
|
data.pt = it->second;
|
|
}
|
|
}
|
|
|
|
bool CStakeRecord::findData(const CString &stake, _Data_ *&data)
|
|
{
|
|
for (size_t i = 0; i < m_datas.size(); i++)
|
|
{
|
|
if (m_datas[i].stake.CompareNoCase(stake) == 0)
|
|
{
|
|
data = &m_datas[i];
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CStakeRecord::setStaticValue(const double &dScale)
|
|
{
|
|
// 数据字高
|
|
m_dataTextHeight = TypeConvert::s2f(getConfiguration(ZD_OUT::KEY_DATA_H)) * dScale;
|
|
|
|
// 数据宽度比例
|
|
m_dataTextFactor = TypeConvert::s2f(getConfiguration(ZD_OUT::KEY_DATA_W));
|
|
|
|
// 数据文字样式
|
|
m_dataTextStyle = getConfiguration(ZD_OUT::KEY_DATA_S);
|
|
|
|
// 行头字高
|
|
m_headTextHeight = TypeConvert::s2f(getConfiguration(ZD_OUT::KEY_HEAD_H)) * dScale;
|
|
|
|
// 行头宽度比例
|
|
m_headTextFactor = TypeConvert::s2f(getConfiguration(ZD_OUT::KEY_HEAD_W));
|
|
|
|
// 行头文字样式
|
|
m_headTextStyle = getConfiguration(ZD_OUT::KEY_HEAD_S);
|
|
|
|
m_dTxtSpace *= dScale;
|
|
m_dHeadTblTxtSpace *= dScale;
|
|
}
|
|
|
|
AcDbText* CStakeRecord::generateHeadText()
|
|
{
|
|
return generateText_H(m_sHead, m_headTextHeight, m_headTextFactor, m_headTextStyle);
|
|
}
|
|
|
|
AcDbText* CStakeRecord::generateText_V(LPCTSTR str, const float &dH, const float &dF, LPCTSTR style)
|
|
{
|
|
double dScale = getScale(_T("S2"));
|
|
AcDbText *pText = new AcDbText();
|
|
pText->setHeight(dH * dScale);
|
|
pText->setWidthFactor(dF);
|
|
pText->setRotation(PI * .5);
|
|
pText->setVerticalMode(AcDb::kTextVertMid);
|
|
pText->setHorizontalMode(AcDb::kTextCenter);
|
|
pText->setTextString(str);
|
|
|
|
AcDbObjectId idTextStyle = GLTools::getTextStyle(style);
|
|
if (!idTextStyle.isNull())
|
|
pText->setTextStyle(idTextStyle);
|
|
|
|
return pText;
|
|
}
|
|
|
|
AcDbText* CStakeRecord::generateText_H(LPCTSTR str, const float &dH, const float &dF, LPCTSTR style)
|
|
{
|
|
double dScale = getScale(_T("S2"));
|
|
AcDbText *pText = new AcDbText();
|
|
pText->setHeight(dH * dScale);
|
|
pText->setWidthFactor(dF);
|
|
pText->setHorizontalMode(AcDb::kTextMid);
|
|
pText->setTextString(str);
|
|
|
|
AcDbObjectId idTextStyle = GLTools::getTextStyle(style);
|
|
if (!idTextStyle.isNull())
|
|
pText->setTextStyle(idTextStyle);
|
|
|
|
return pText;
|
|
}
|
|
|
|
AcDbExtents CStakeRecord::getTextExtent(AcDbText *p)
|
|
{
|
|
AcDbExtents ext;
|
|
if (p)
|
|
p->getGeomExtents(ext);
|
|
return ext;
|
|
}
|
|
#pragma endregion CStakeRecord
|
|
|
|
namespace ZD_OUT
|
|
{
|
|
|
|
void getDataRecords(AcDbObjectIdArray &arrIDs
|
|
, std::vector<CStakeRecord> &records)
|
|
{
|
|
records.clear();
|
|
if (arrIDs.isEmpty()) return;
|
|
|
|
CStakeRecord::setStaticValue(getFrameScaleD(arrIDs));
|
|
// 得到空间中存在的桩号的插入点
|
|
CStakeRecord::StakeInsPts stPts;
|
|
generateStakeInsertPoint(arrIDs, stPts);
|
|
|
|
if (stPts.empty())
|
|
{
|
|
acutPrintf(_T("\n未能在图形中提取出桩号信息。"));
|
|
return;
|
|
}
|
|
|
|
// 得到桩号所对应的数据，从文件中。
|
|
std::vector<CStakeRecord> recs(0);
|
|
if (!generateStakeRecordByFile(recs))
|
|
{
|
|
acutPrintf(_T("\n未在本地找到桩号数据。"));
|
|
return;
|
|
}
|
|
|
|
// 里程节点记录
|
|
CStakeRecord rec;
|
|
generateMileStoneRecord(arrIDs, rec);
|
|
recs.push_back(rec);
|
|
|
|
// 特征节点记录
|
|
CStakeRecord rec1;
|
|
generatekFeatureRecord(arrIDs, rec1);
|
|
recs.push_back(rec1);
|
|
|
|
// 初始化插入点
|
|
for (size_t i = 0; i < recs.size(); ++i)
|
|
recs[i].init(stPts);
|
|
|
|
// 按 rules顺序进行输出
|
|
for (size_t i = 0; i < g_config.size(); ++i)
|
|
{
|
|
std::vector<CStakeRecord>::iterator it = std::find_if(recs.begin(), recs.end(), CStakeRecord::compare(g_config[i].first));
|
|
if (it != recs.end())
|
|
{
|
|
if (g_config[i].second.CompareNoCase(_T("0")) != 0)
|
|
records.push_back(*it);
|
|
}
|
|
}
|
|
}
|
|
|
|
void insertZDTable(AcDbObjectId &recId
|
|
, AcDbObjectIdArray &arrIDs
|
|
, std::vector<CStakeRecord> &records
|
|
, const AcGePoint3d &_ptMin
|
|
, const AcGePoint3d &_ptMax
|
|
, const bool &bEnd // 最后一次调用
|
|
)
|
|
{
|
|
if (arrIDs.isEmpty()) return;
|
|
if (!recId.isValid()) return;
|
|
if (records.empty()) return;
|
|
|
|
double dScaleH(getFrameScaleD(arrIDs));
|
|
|
|
readConfiguration();
|
|
|
|
// 网格设置参数
|
|
int i_wg_grid_interval(TypeConvert::s2i(getConfiguration(KEY_GRID_INTERVAL)));
|
|
int i_wg_prec(TypeConvert::s2i(getConfiguration(KEY_GRID_PREC)));
|
|
|
|
float f_wg_arrow_w(TypeConvert::s2f(getConfiguration(KEY_ARROW_W)));
|
|
|
|
float f_wg_grid_h(TypeConvert::s2f(getConfiguration(KEY_GRID_H)) * dScaleH);
|
|
CString s_wg_grid_s(getConfiguration(KEY_GRID_S));
|
|
float f_wg_grid_w(TypeConvert::s2f(getConfiguration(KEY_GRID_W)));
|
|
|
|
float f_wg_ratio_h(TypeConvert::s2f(getConfiguration(KEY_RATIO_H)) * dScaleH);
|
|
CString s_wg_ratio_s(getConfiguration(KEY_RATIO_S));
|
|
float f_wg_ratio_w(TypeConvert::s2f(getConfiguration(KEY_RATIO_W)));
|
|
|
|
// 引出标注设置参数
|
|
float f_ycbz_h(TypeConvert::s2f(getConfiguration(KEY_YCBZ_H)));
|
|
CString f_ycbz_s(getConfiguration(KEY_YCBZ_S));
|
|
|
|
// 节点设置参数
|
|
float f_jd_scale(TypeConvert::s2f(getConfiguration(KEY_NODE_SCALE)));
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 下面代码绘制网格标尺
|
|
|
|
// 先取出三个特征点,三个特征点用来计算真实高程
|
|
std::map<AcGePoint3d, double, _compare_pt_y> ptMap;
|
|
getMarkPoints(arrIDs, ptMap);
|
|
if (ptMap.size() != 3) return;
|
|
|
|
std::map<AcGePoint3d, double, _compare_pt_y>::iterator it(ptMap.begin());
|
|
AcGePoint3d ptDown(it->first);
|
|
double dDown(it->second);
|
|
++it;
|
|
AcGePoint3d ptUp(it->first);
|
|
double dUp(it->second);
|
|
++it;
|
|
AcGePoint3d ptRoad(it->first);
|
|
double dRoad(it->second);
|
|
|
|
//drawCircle(recId, ptUp, 5);
|
|
//drawCircle(recId, ptDown, 5);
|
|
|
|
// 得到所有实体的范围
|
|
AcDbObjectId idBlk = getBlockID(arrIDs); // 所有实体都在此块中
|
|
AcGePoint3d ptMin(AcGePoint3d::kOrigin), ptMax(AcGePoint3d::kOrigin);
|
|
getExtent(idBlk, ptMin, ptMax);
|
|
AcGePoint3d ptMinBk(ptMin), ptMaxBk(ptMax);
|
|
|
|
//drawCircle(recId, ptMin, 1);
|
|
//drawCircle(recId, ptMax, 1);
|
|
|
|
// factor 为 现实高程差与图纸坐标Y值差的比
|
|
double factorY = (dUp - dDown) / (ptUp.y - ptDown.y);
|
|
double factorX = dScaleH;
|
|
|
|
double deltaY = 1 / factorY;
|
|
double deltaX = deltaY;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 下面输出计算数据
|
|
|
|
AcDbExtents extHead;
|
|
double dHeadW(.0), dHeadDelta(.0), dTblH(.0);
|
|
for (size_t i = 0; i < records.size(); ++i)
|
|
{
|
|
CStakeRecord &rec = records[i];
|
|
AcDbText *pText = rec.generateHeadText();
|
|
if (!pText) continue;
|
|
AcDbExtents ext;
|
|
pText->getGeomExtents(ext);
|
|
extHead.addExt(ext);
|
|
DELETE_PTR(pText);
|
|
dTblH += records[i].getMaxHeight();
|
|
}
|
|
dHeadDelta = extHead.maxPoint().x - extHead.minPoint().x;
|
|
dHeadW = dHeadDelta + CStakeRecord::m_dTxtSpace;
|
|
|
|
// 根据 dHeadW 重新计算 dLeft
|
|
AcGePoint3d ptInsMin(AcGePoint3d::kOrigin);
|
|
double dLeft, dMid, dRight;
|
|
ptInsMin.x = _ptMin.x - g_rule_grid_space;
|
|
// 把 ptInsMin.y 算一下，用最小的Y值加表格高度，再加一个间隙
|
|
ptInsMin.y = _ptMin.y + dTblH + 1;
|
|
|
|
// dMinDown 为标尺左下角高程
|
|
double dMinDown = dDown - factorY * (ptDown.y - ptInsMin.y);
|
|
|
|
// iDown 为取整后的dMinDown
|
|
int iDown(0);
|
|
if (dMinDown - (int)(dMinDown) < 1e-6)
|
|
iDown = (int)(dMinDown);
|
|
else
|
|
iDown = (int)(dMinDown) + 1;
|
|
|
|
// 根据 iDown 算出坐标
|
|
ptInsMin.y = ptDown.y - (dDown - iDown) / factorY;
|
|
|
|
drawGrid(recId
|
|
, ptInsMin
|
|
, iDown
|
|
, i_wg_grid_interval
|
|
, deltaY
|
|
, deltaX
|
|
, _ptMax.y - ptInsMin.y + deltaY
|
|
, _ptMax.x - ptInsMin.x + deltaY
|
|
, i_wg_prec
|
|
, f_wg_grid_h
|
|
, f_wg_grid_w
|
|
, s_wg_grid_s
|
|
, dLeft
|
|
, dMid
|
|
, dRight
|
|
, dDown);
|
|
|
|
// 将存有实体的块移动到网格处
|
|
AcGeVector3d vtMove(AcGeVector3d::kXAxis);
|
|
vtMove *= dMid - ptMinBk.x;
|
|
g_content_blk_mat.setToIdentity();
|
|
g_content_blk_mat.setTranslation(vtMove);
|
|
|
|
if (bEnd)
|
|
transformBy(idBlk, g_content_blk_mat);
|
|
|
|
|
|
double preY(_ptMin.y + dTblH);
|
|
for (size_t i = 0; i < records.size(); ++i)
|
|
preY = records[i].draw(recId, preY, dHeadW, dLeft, dMid, dRight, g_content_blk_mat);
|
|
|
|
// 缩放节点
|
|
scaleNodes(arrIDs, f_jd_scale);
|
|
|
|
// 绘制比例尺
|
|
double dHLength(.0), dVLength(.0);
|
|
CString strV(getScaleS2());
|
|
CString strH = getFrameScaleS(arrIDs);
|
|
AcGePoint3d ptRule(dLeft - dHeadW, dDown, 0);
|
|
drawScaleRule(recId, ptRule, strH, strV, f_wg_arrow_w, f_wg_ratio_h, f_wg_ratio_w, s_wg_ratio_s);
|
|
|
|
if (bEnd)
|
|
{
|
|
g_prRang.first = _ptMin.x;
|
|
g_prRang.second = _ptMax.x;
|
|
}
|
|
}
|
|
|
|
bool readConfiguration()
|
|
{
|
|
return ::readConfiguration();
|
|
}
|
|
|
|
CString getConfiguration(LPCTSTR key)
|
|
{
|
|
return ::getConfiguration(key);
|
|
}
|
|
|
|
void getConfiguration(std::vector<std::pair<CString, CString>> &v)
|
|
{
|
|
v.assign(g_config.begin(), g_config.end());
|
|
}
|
|
|
|
void insertDimension(AcDbObjectId &recId)
|
|
{
|
|
std::vector<AcDbObjectId> ids;
|
|
collectEntityByXData(recId, STAKE_SECTION, ids);
|
|
if (ids.empty()) return;
|
|
|
|
CString strType(_T("")), strID(_T("")), strTextStyle(getConfiguration(KEY_YCBZ_S));
|
|
|
|
if (strTextStyle.IsEmpty())
|
|
strTextStyle = _T("standard");
|
|
|
|
float textH(TypeConvert::s2f(getConfiguration(KEY_YCBZ_H)));
|
|
int nDimByStake(TypeConvert::s2i(getConfiguration(KEY_NODE_DIMTYPE)));
|
|
|
|
AcGePoint3d ptIns(AcGePoint3d::kOrigin), pt2(AcGePoint3d::kOrigin);
|
|
std::set<CString> strSet1;
|
|
std::pair<std::set<CString>::iterator, bool> pr;
|
|
AcDbEntity *pDim(NULL);
|
|
|
|
AcGePoint3d ptMax(AcGePoint3d::kOrigin), ptMin(AcGePoint3d::kOrigin);
|
|
EWNodeDimInfos nds;
|
|
catalogNodeType(ids, nds);
|
|
int nCharLen(0);
|
|
|
|
std::multiset<CString> mmapStrs;
|
|
typedef std::multiset<CString>::iterator mmapIt;
|
|
std::pair<mmapIt, mmapIt> _pr;
|
|
size_t dif(0);
|
|
std::wstringstream ss;
|
|
|
|
std::vector<EWNodeDimInfo> vnds(0);
|
|
for (EWNodeDimInfos::iterator it = nds.begin(); it != nds.end(); ++it)
|
|
{
|
|
vnds.push_back(it->second);
|
|
}
|
|
|
|
std::sort(vnds.begin(), vnds.end(), EWNodeDimInfo::_com_by_x());
|
|
|
|
// first 管廊长度，second.first 管廊起始桩号，second.second 管廊结束桩号
|
|
std::map<CString, double> guids;
|
|
if (TypeConvert::s2i(getConfiguration(KEY_NODE_DIMTYPE)) != 1)
|
|
{
|
|
std::vector<CStakeRecord> recs(0);
|
|
if (!generateStakeRecordByFile(recs))
|
|
{
|
|
acutPrintf(_T("\n未在本地找到桩号数据。"));
|
|
return;
|
|
}
|
|
|
|
if (recs.size() < 9) return;
|
|
|
|
CStakeRecord recDist(recs[7]);
|
|
CStakeRecord recGuid(recs[9]);
|
|
|
|
if (recDist.m_datas.size() == recGuid.m_datas.size())
|
|
{
|
|
double d;
|
|
for (size_t i = 0; i < recDist.m_datas.size() - 1; i++)
|
|
{
|
|
StakeTools::analyStakeString(recDist.m_datas[i].sData, d);
|
|
guids.insert(std::make_pair(recGuid.m_datas[i].sData, d));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
CString strDim(_T(""));
|
|
double dStake(.0);
|
|
for (std::vector<EWNodeDimInfo>::iterator it = vnds.begin(); it != vnds.end(); ++it)
|
|
{
|
|
ss.str(_T(""));
|
|
mmapStrs.insert(it->strType);
|
|
_pr = std::equal_range(mmapStrs.begin(), mmapStrs.end(), it->strType);
|
|
dif = std::distance(_pr.first, _pr.second);
|
|
|
|
ss << dif;
|
|
|
|
ptMax = it->ext.maxPoint();
|
|
ptMin = it->ext.minPoint();
|
|
ptIns.x = (ptMax.x + ptMin.x) * .5;
|
|
ptIns.y = (ptMax.y + ptMin.y) * .5;
|
|
pr = strSet1.insert(getTraitString(it->strType, ptIns));
|
|
if (!pr.second) continue;
|
|
|
|
pt2 = ptIns;
|
|
pt2.y += (ptMax.y - ptMin.y) * .5 + 1;
|
|
|
|
if (it->fnType == kFirwWall)
|
|
pt2.y += 5;
|
|
|
|
nCharLen = it->strType.GetLength();
|
|
|
|
// 在这里判断是否需要根据距离来标注节点
|
|
strDim = it->strStake;
|
|
if (TypeConvert::s2i(getConfiguration(KEY_NODE_DIMTYPE)) != 1)
|
|
{
|
|
std::map<CString, double>::iterator mIt(guids.end());
|
|
mIt = guids.find(it->strID);
|
|
if (mIt != guids.end())
|
|
strDim = StakeTools::generateStakeString(mIt->second, _T("L"));
|
|
}
|
|
|
|
//pDim = MK_DIM::makeSymbNode(ptIns
|
|
#ifndef ZWCAD
|
|
pDim = DimFactory(FilePath::GetArxDir() + _T("//dimension.arx")).makeSymbNode(ptIns
|
|
#else
|
|
pDim = DimFactory(FilePath::GetArxDir() + _T("//dimension.zrx")).makeSymbNode(ptIns
|
|
#endif
|
|
, pt2
|
|
, nCharLen * .7
|
|
, strDim + _T(":") + it->strName + _T(" ") + it->strType + ss.str().c_str()
|
|
, strTextStyle
|
|
, textH
|
|
//, MK_DIM::eNoneArrow
|
|
, DimFactory::eNoneArrow
|
|
, 3.
|
|
//, MK_DIM::eBeginAlign);
|
|
, DimFactory::eBeginAlign);
|
|
|
|
if (!pDim) continue;
|
|
|
|
if (ptIns.x > g_prRang.first)
|
|
pDim->transformBy(g_content_blk_mat);
|
|
|
|
g_LayerMgr::instance().setLayer(pDim, GLTools::gLayer_ZD_DIM);
|
|
AddToTableRecord(pDim, recId);
|
|
}
|
|
|
|
// 在这里删除所有多余点
|
|
for (size_t i = 0; i < ids.size(); ++i)
|
|
{
|
|
AcDbObjectId &id = ids[i];
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AcDbEntity, pEnt)
|
|
if (pEnt) pEnt->erase();
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
// 网格最左侧（不算标尺）与表格最左侧的距离（+1）
|
|
double getGridLeftPointDist()
|
|
{
|
|
std::vector<CStakeRecord> recs(0);
|
|
CStakeRecord rec;
|
|
rec.setHeadString(ZD_OUT::KEY_STAKENO);
|
|
recs.push_back(rec);
|
|
rec.setHeadString(ZD_OUT::KEY_SOIL);
|
|
recs.push_back(rec);
|
|
rec.setHeadString(ZD_OUT::KEY_TOP_ELEV);
|
|
recs.push_back(rec);
|
|
rec.setHeadString(ZD_OUT::KEY_CURRENT_GROUND_ELEV);
|
|
recs.push_back(rec);
|
|
rec.setHeadString(ZD_OUT::KEY_DESIGN_GROUND_ELEV);
|
|
recs.push_back(rec);
|
|
rec.setHeadString(ZD_OUT::KEY_GRADE_DISTANCE);
|
|
recs.push_back(rec);
|
|
rec.setHeadString(ZD_OUT::KEY_GRADE);
|
|
recs.push_back(rec);
|
|
rec.setHeadString(ZD_OUT::KEY_DISTANCE);
|
|
recs.push_back(rec);
|
|
rec.setHeadString(ZD_OUT::KEY_FEATURE);
|
|
recs.push_back(rec);
|
|
rec.setHeadString(ZD_OUT::KEY_MILESTONE);
|
|
recs.push_back(rec);
|
|
rec.setHeadString(ZD_OUT::KEY_BOTTOM_INNER_ELEV);
|
|
recs.push_back(rec);
|
|
rec.setHeadString(ZD_OUT::KEY_GL_STAKENO);
|
|
recs.push_back(rec);
|
|
rec.setHeadString(ZD_OUT::KEY_SOIL_ELEV);
|
|
recs.push_back(rec);
|
|
|
|
std::vector<CStakeRecord> records(0);
|
|
for (size_t i = 0; i < g_config.size(); ++i)
|
|
{
|
|
std::vector<CStakeRecord>::iterator it = std::find_if(recs.begin(), recs.end(), CStakeRecord::compare(g_config[i].first));
|
|
if (it != recs.end())
|
|
{
|
|
if (g_config[i].second.CompareNoCase(_T("0")) != 0)
|
|
records.push_back(*it);
|
|
}
|
|
}
|
|
|
|
AcDbExtents extHead;
|
|
double dHeadW(.0), dHeadDelta(.0);
|
|
for (size_t i = 0; i < records.size(); ++i)
|
|
{
|
|
CStakeRecord &rec = records[i];
|
|
AcDbText *pText = rec.generateHeadText();
|
|
if (!pText) continue;
|
|
AcDbExtents ext;
|
|
pText->getGeomExtents(ext);
|
|
extHead.addExt(ext);
|
|
DELETE_PTR(pText);
|
|
}
|
|
dHeadDelta = extHead.maxPoint().x - extHead.minPoint().x;
|
|
dHeadW = dHeadDelta + CStakeRecord::m_dTxtSpace + g_rule_grid_space + CStakeRecord::m_dHeadTblTxtSpace;
|
|
return dHeadW;
|
|
}
|
|
}
|
|
|