1686 lines
42 KiB
C++
1686 lines
42 KiB
C++
#include "StdAfx.h"
|
|
#include "AecDbJoggedCamera.h"
|
|
#include "MFCDbDwgFiler.h"
|
|
#include "CoreTools.h"
|
|
#include "simpleProperty.h"
|
|
#include "dbgrip.h"
|
|
#include "COMPARE_DOUBLE.h"
|
|
#include "hlrcutoption.h"
|
|
|
|
#define PIXEL_SIZE 4
|
|
|
|
namespace
|
|
{
|
|
struct sort_jogged
|
|
{
|
|
sort_jogged(const AcGeVector3d &vt) : m_vt(vt){}
|
|
AcGeVector3d m_vt;
|
|
bool operator()(const AecDbJoggedCamera::Camera *pCam1, const AecDbJoggedCamera::Camera *pCam2) const
|
|
{
|
|
AcGeLine3d line(AcGePoint3d::kOrigin, m_vt);
|
|
AcGePoint3d pt1 = line.closestPointTo(pCam1->getMidPoint());
|
|
AcGePoint3d pt2 = line.closestPointTo(pCam2->getMidPoint());
|
|
|
|
if ((pt1 - pt2).isCodirectionalTo(m_vt))
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
};
|
|
// 检查ptChk点,在直线(ptOrg, vt)上的投影点ptClosed在ptOrg的后方
|
|
bool checkPoint(const AcGePoint3d &ptOrg
|
|
, const AcGeVector3d &vt
|
|
, const AcGePoint3d &ptChk
|
|
, AcGePoint3d &ptClosed
|
|
, const bool &bAllowSame)
|
|
{
|
|
/*
|
|
->vt->
|
|
OK: ptOrg->->->ptClosed->->->
|
|
NO: ptClosed->->->ptOrg->->->
|
|
*/
|
|
AcGeLine3d line(ptOrg, vt);
|
|
ptClosed = line.closestPointTo(ptChk);
|
|
|
|
if (ptClosed.isEqualTo(ptOrg))
|
|
{
|
|
if (bAllowSame)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
return (ptClosed - ptOrg).isCodirectionalTo(vt);
|
|
}
|
|
|
|
|
|
bool ptInnerSegment(const AcGePoint3d &pt, const AcGeLineSeg3d &seg)
|
|
{
|
|
double dParam;
|
|
double dStart = seg.paramOf(seg.startPoint());
|
|
double dEnd = seg.paramOf(seg.endPoint());
|
|
|
|
if (seg.isOn(pt, dParam))
|
|
{
|
|
if (dParam < dEnd && dParam > dStart)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool isColinearAndOverlapping(AcGeLineSeg3d &seg1, AcGeLineSeg3d &seg2)
|
|
{
|
|
// 不共线,一定不重叠
|
|
if (!seg1.isColinearTo(seg2))
|
|
return false;
|
|
|
|
// 已经共线
|
|
|
|
// 如果seg2的起点或终点在seg1上，并且不在端点上，则认为两线段重叠
|
|
if (ptInnerSegment(seg2.startPoint(), seg1)
|
|
|| ptInnerSegment(seg2.endPoint(), seg1))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// 同上
|
|
if (ptInnerSegment(seg1.startPoint(), seg2)
|
|
|| ptInnerSegment(seg1.endPoint(), seg2))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// 再判断两个线段完全重合
|
|
if (seg1.startPoint().isEqualTo(seg2.startPoint())
|
|
&& seg1.endPoint().isEqualTo(seg2.endPoint()))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (seg1.startPoint().isEqualTo(seg2.endPoint())
|
|
&& seg1.endPoint().isEqualTo(seg2.startPoint()))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool isRegionOverlapping(AcGeLineSeg3d &seg1, AcGeLineSeg3d &seg2)
|
|
{
|
|
// 如果不平行,则认为区域一定重叠
|
|
if (!seg1.isParallelTo(seg2))
|
|
return true;
|
|
|
|
// 如果共线,则用isColinearAndOverlapping来判断
|
|
if (seg1.isColinearTo(seg2))
|
|
return isColinearAndOverlapping(seg1, seg2);
|
|
|
|
// 已经平行,但不共线,则判断两线段所在的区域是否重叠
|
|
|
|
// 让seg1两个端点seg2所在无限直线上投影,得到seg3
|
|
// 如果seg3与seg2重叠,则认为两线段所在的区域重叠
|
|
AcGeLine3d line(seg2.startPoint(), seg2.direction());
|
|
AcGePoint3d pt1 = line.closestPointTo(seg1.startPoint());
|
|
AcGePoint3d pt2 = line.closestPointTo(seg1.endPoint());
|
|
AcGeLineSeg3d seg3(pt1, pt2);
|
|
return isColinearAndOverlapping(seg2, seg3);
|
|
}
|
|
|
|
AcGeVector3d getViewDir()
|
|
{
|
|
AcGePoint3dArray pts;
|
|
struct resbuf rb;
|
|
acedGetVar(_T("viewdir"), &rb);
|
|
ads_point dirPt;
|
|
acdbUcs2Wcs(rb.resval.rpoint, dirPt, Adesk::kTrue);
|
|
return asVec3d(dirPt);
|
|
}
|
|
|
|
AcDbExtents getResultExtent(const AcDbObjectIdArray &ar)
|
|
{
|
|
AcDbExtents ext, _ext;
|
|
for (int i(0); i < ar.length(); ++i)
|
|
{
|
|
AcDbEntityPointer ent(ar[i], AcDb::kForRead);
|
|
if (ent.openStatus() == Acad::eOk)
|
|
{
|
|
ent->getGeomExtents(_ext);
|
|
ext.addExt(_ext);
|
|
}
|
|
}
|
|
return ext;
|
|
}
|
|
|
|
bool Grip_WorldDrawfunc(AcDbGripData *pThis,
|
|
AcGiWorldDraw *pWd,
|
|
const AcDbObjectId &entId,
|
|
AcDbGripOperations::DrawType type,
|
|
AcGePoint3d *cursor,
|
|
double dGripSize)
|
|
{
|
|
bool bHori(false);
|
|
AcGeVector3d vtNow(getViewDir());
|
|
if (vtNow.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
bHori = true;
|
|
// 画夹点
|
|
AcGiFillType eOldFill = pWd->subEntityTraits().fillType();
|
|
int nOldColor = pWd->subEntityTraits().color();
|
|
|
|
AecDbXCamera::GripData *pGrip = (AecDbXCamera::GripData *)pThis->appData();
|
|
|
|
AcGePoint3d ptGe[5], ptBox[5];
|
|
AcGePoint3d ptGrip = pThis->gripPoint();
|
|
double dOne = CoreTools::PixelToWcs(1);
|
|
|
|
ptGe[0] = ptGrip;
|
|
ptGe[0].x -= PIXEL_SIZE * dOne;
|
|
ptGe[1] = ptGrip;
|
|
ptGe[1].x += PIXEL_SIZE * dOne;
|
|
|
|
ptBox[0] = ptGe[0];
|
|
ptBox[0].y -= PIXEL_SIZE * dOne;
|
|
ptBox[1] = ptGe[0];
|
|
ptBox[1].y += PIXEL_SIZE * dOne;
|
|
ptBox[2] = ptGe[1];
|
|
ptBox[2].y += PIXEL_SIZE * dOne;
|
|
ptBox[3] = ptGe[1];
|
|
ptBox[3].y -= PIXEL_SIZE * dOne;
|
|
|
|
if (!bHori)
|
|
{
|
|
AcGePlane pln(ptGrip, vtNow);
|
|
AcGeVector3d X, Y;
|
|
pln.getCoordSystem(ptGrip, X, Y);
|
|
AcGeMatrix3d mat;
|
|
mat.setToAlignCoordSys(ptGrip, AcGeVector3d::kXAxis, AcGeVector3d::kYAxis, AcGeVector3d::kZAxis
|
|
, ptGrip, X, Y, vtNow);
|
|
ptBox[0].transformBy(mat);
|
|
ptBox[1].transformBy(mat);
|
|
ptBox[2].transformBy(mat);
|
|
ptBox[3].transformBy(mat);
|
|
}
|
|
|
|
pWd->subEntityTraits().setFillType(kAcGiFillAlways);
|
|
pWd->geometry().polygon(4, ptBox);
|
|
pWd->subEntityTraits().setFillType(eOldFill);
|
|
////
|
|
|
|
// 每次取4个点
|
|
AcGePoint3d arFrame[5] = {};
|
|
pWd->subEntityTraits().setColor(9);
|
|
if (bHori)
|
|
{
|
|
for (int i(3); i < pGrip->m_arSelectFrame.length(); i += 4)
|
|
{
|
|
arFrame[0] = pGrip->m_arSelectFrame[i - 3];
|
|
arFrame[1] = pGrip->m_arSelectFrame[i - 2];
|
|
arFrame[2] = pGrip->m_arSelectFrame[i - 1];
|
|
arFrame[3] = pGrip->m_arSelectFrame[i];
|
|
pWd->geometry().polyline(4, arFrame);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 8个一组，4个低点在前，4个高点在后
|
|
AcGePoint3d ptT1, ptT2, ptT3, ptT4, ptB1, ptB2, ptB3, ptB4;
|
|
// 8个点一起取
|
|
for (int i(7); i < pGrip->m_arSelectFrame.length(); i += 8)
|
|
{
|
|
// 4-7
|
|
ptT1 = pGrip->m_arSelectFrame[i - 3];
|
|
ptT2 = pGrip->m_arSelectFrame[i - 2];
|
|
ptT3 = pGrip->m_arSelectFrame[i - 1];
|
|
ptT4 = pGrip->m_arSelectFrame[i - 0];
|
|
|
|
// 0-3
|
|
ptB1 = pGrip->m_arSelectFrame[i - 7];
|
|
ptB2 = pGrip->m_arSelectFrame[i - 6];
|
|
ptB3 = pGrip->m_arSelectFrame[i - 5];
|
|
ptB4 = pGrip->m_arSelectFrame[i - 4];
|
|
|
|
arFrame[0] = ptT1;
|
|
arFrame[1] = ptT2;
|
|
arFrame[2] = ptT3;
|
|
arFrame[3] = ptT4;
|
|
arFrame[4] = ptT1;
|
|
pWd->geometry().polyline(5, arFrame);
|
|
|
|
arFrame[0] = ptB1;
|
|
arFrame[1] = ptB2;
|
|
arFrame[2] = ptB3;
|
|
arFrame[3] = ptB4;
|
|
pWd->geometry().polyline(4, arFrame);
|
|
|
|
arFrame[0] = ptT1;
|
|
arFrame[1] = ptB1;
|
|
pWd->geometry().polyline(2, arFrame);
|
|
|
|
arFrame[0] = ptT2;
|
|
arFrame[1] = ptB2;
|
|
pWd->geometry().polyline(2, arFrame);
|
|
|
|
arFrame[0] = ptT3;
|
|
arFrame[1] = ptB3;
|
|
pWd->geometry().polyline(2, arFrame);
|
|
|
|
arFrame[0] = ptT4;
|
|
arFrame[1] = ptB4;
|
|
pWd->geometry().polyline(2, arFrame);
|
|
}
|
|
}
|
|
|
|
// 画结果范围
|
|
if (pGrip->m_bDrawResultFrame && !pGrip->m_arResultFrame.isEmpty())
|
|
{
|
|
// 每次取4个点
|
|
for (int i(3), clr = 1; i < pGrip->m_arResultFrame.length(); i += 4, ++clr)
|
|
{
|
|
arFrame[0] = pGrip->m_arResultFrame[i - 3];
|
|
arFrame[1] = pGrip->m_arResultFrame[i - 2];
|
|
arFrame[2] = pGrip->m_arResultFrame[i - 1];
|
|
arFrame[3] = pGrip->m_arResultFrame[i];
|
|
arFrame[4] = arFrame[0];
|
|
|
|
// 颜色9保留
|
|
if (clr == 9) ++clr;
|
|
|
|
pWd->subEntityTraits().setColor(clr);
|
|
pWd->geometry().polyline(5, arFrame);
|
|
}
|
|
pWd->subEntityTraits().setColor(nOldColor);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void addGripData( const int &idxCamera
|
|
, const int &idxPoint
|
|
, const AcGePoint3d &pt
|
|
, AcArray<AecDbXCamera::GripData *> &gripDatas
|
|
, AcDbGripDataPtrArray &grips)
|
|
{
|
|
AecDbXCamera::GripData *gpd = new AecDbXCamera::GripData;
|
|
gpd->m_idx = idxCamera;
|
|
gpd->m_subIdx = idxPoint;
|
|
gpd->m_pt = pt;
|
|
AcDbGripData *pGripData = new AcDbGripData;
|
|
pGripData->setGripPoint(pt);
|
|
pGripData->setWorldDraw(Grip_WorldDrawfunc);
|
|
gripDatas.append(gpd);
|
|
pGripData->setAppData(gpd);
|
|
grips.append(pGripData);
|
|
}
|
|
|
|
}
|
|
|
|
#pragma region AecDbJoggedCamera::Camera
|
|
|
|
void AecDbJoggedCamera::Camera::getGripPoints(AcGePoint3dArray &ar) const
|
|
{
|
|
// 顺时针获取Grip点
|
|
/*
|
|
0-----1-----|
|
|
| |
|
|
5 6 2
|
|
| |
|
|
4-----3-----|
|
|
*/
|
|
AcGePoint3d pt0 = m_ptStart;
|
|
AcGePoint3d pt1 = pt0 + m_vtDir * .5;
|
|
AcGePoint3d pt5 = CoreTools::MidPt(m_ptStart, m_ptEnd);
|
|
AcGePoint3d pt2 = pt5 + m_vtDir;
|
|
AcGePoint3d pt3 = m_ptEnd + m_vtDir * .5;
|
|
AcGePoint3d pt4 = m_ptEnd;
|
|
AcGePoint3d pt6 = CoreTools::MidPt(pt5, pt2);
|
|
|
|
pt0.z = pt1.z = pt2.z = pt3.z = pt4.z = pt5.z = pt6.z = .0;
|
|
|
|
ar.append(pt0);
|
|
ar.append(pt1);
|
|
ar.append(pt2);
|
|
ar.append(pt3);
|
|
ar.append(pt4);
|
|
ar.append(pt5);
|
|
ar.append(pt6);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbJoggedCamera::Camera::dwgOutFields(AcDbDwgFiler * pFiler) const
|
|
{
|
|
Acad::ErrorStatus es;
|
|
es = pFiler->writeUInt32(AecDbJoggedCamera::Camera::kCurrentVersionNumber);
|
|
if (es != Acad::eOk)
|
|
return (es);
|
|
|
|
pFiler->writePoint3d(m_ptStart);
|
|
pFiler->writePoint3d(m_ptEnd);
|
|
pFiler->writeDouble(m_dMinElev);
|
|
pFiler->writeDouble(m_dMaxElev);
|
|
pFiler->writeVector3d(m_vtDir);
|
|
pFiler->writeInt16(m_iColor);
|
|
pFiler->writePoint3d(m_ptOutput);
|
|
|
|
pFiler->writeInt32(m_arResults.length());
|
|
for (int i(0); i < m_arResults.length(); ++i)
|
|
pFiler->writeSoftPointerId(m_arResults[i]);
|
|
|
|
return (pFiler->filerStatus());
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbJoggedCamera::Camera::dwgInFields(AcDbDwgFiler * pFiler)
|
|
{
|
|
Acad::ErrorStatus es;
|
|
Adesk::UInt32 version = 0;
|
|
es = pFiler->readUInt32(&version);
|
|
if (es != Acad::eOk) return (es);
|
|
if (version > AecDbJoggedCamera::Camera::kCurrentVersionNumber) return (Acad::eMakeMeProxy);
|
|
|
|
pFiler->readPoint3d(&m_ptStart);
|
|
pFiler->readPoint3d(&m_ptEnd);
|
|
pFiler->readDouble(&m_dMinElev);
|
|
pFiler->readDouble(&m_dMaxElev);
|
|
pFiler->readVector3d(&m_vtDir);
|
|
pFiler->readInt16(&m_iColor);
|
|
pFiler->readPoint3d(&m_ptOutput);
|
|
|
|
if (version > 1)
|
|
{
|
|
m_arResults.removeAll();
|
|
Adesk::Int32 num(0);
|
|
pFiler->readInt32(&num);
|
|
AcDbObjectId id;
|
|
for (int i(0); i < num; ++i)
|
|
{
|
|
pFiler->readSoftPointerId((AcDbSoftPointerId *)&id);
|
|
if (id.isValid())
|
|
m_arResults.append(id);
|
|
}
|
|
}
|
|
|
|
return (pFiler->filerStatus());
|
|
}
|
|
|
|
AcDbPolyline* AecDbJoggedCamera::Camera::getSectionPolygon() const
|
|
{
|
|
AcGePoint3dArray ar;
|
|
|
|
AcGePoint3d pt0(m_ptStart), pt1(m_ptEnd), pt2(m_ptEnd), pt3(m_ptStart);
|
|
pt0.z = pt1.z = m_dMinElev;
|
|
pt2.z = pt3.z = m_dMaxElev;
|
|
|
|
AcDbPolyline *pPoly = new AcDbPolyline();
|
|
|
|
AcGeVector3d vecNormal(m_vtDir.normal());
|
|
AcGeMatrix3d matWcs2Ocs;
|
|
matWcs2Ocs.setToWorldToPlane(vecNormal);
|
|
|
|
pt0.transformBy(matWcs2Ocs);
|
|
pt1.transformBy(matWcs2Ocs);
|
|
pt2.transformBy(matWcs2Ocs);
|
|
pt3.transformBy(matWcs2Ocs);
|
|
|
|
pPoly->setNormal(vecNormal);
|
|
pPoly->setElevation(pt0.z);
|
|
pPoly->addVertexAt(0, AcGePoint2d(pt0.x, pt0.y));
|
|
pPoly->addVertexAt(1, AcGePoint2d(pt1.x, pt1.y));
|
|
pPoly->addVertexAt(2, AcGePoint2d(pt2.x, pt2.y));
|
|
pPoly->addVertexAt(3, AcGePoint2d(pt3.x, pt3.y));
|
|
pPoly->addVertexAt(4, AcGePoint2d(pt0.x, pt0.y));
|
|
|
|
return pPoly;
|
|
}
|
|
|
|
void AecDbJoggedCamera::Camera::moveGripPointsAt(const int &_idx, const AcGeVector3d &offset)
|
|
{
|
|
|
|
AcGePoint3dArray arPts;
|
|
getGripPoints(arPts);
|
|
|
|
if (arPts.length() < 7) return;
|
|
|
|
int idx(_idx);
|
|
if (idx >= 100)
|
|
idx -= 100;
|
|
|
|
if (idx < 0 || idx >= arPts.length()) return;
|
|
|
|
|
|
AcGeVector3d X((arPts[1] - arPts[0]).normal());
|
|
AcGeVector3d Y((arPts[0] - arPts[4]).normal());
|
|
|
|
AcGePoint3d ptNew(arPts[idx] + offset), ptOnLine;
|
|
if (COMPARE_DOUBLE::equal_zero(ptNew.distanceTo(arPts[idx])))
|
|
return;
|
|
|
|
AcGeLine3d lineTop(arPts[0], arPts[0] + m_vtDir);
|
|
AcGeLine3d lineBottom(arPts[4], arPts[4] + m_vtDir);
|
|
AcGeLine3d lineLeft(arPts[0], arPts[4]);
|
|
AcGeLine3d lineRight(arPts[0] + m_vtDir, arPts[4] + m_vtDir);
|
|
|
|
AcGeVector3d vtNew, vtOld;
|
|
AcGeMatrix3d mat;
|
|
double dDist(.0), dAngle;
|
|
vtNew = ptNew - arPts[5];
|
|
|
|
switch (_idx)
|
|
{
|
|
case 0:
|
|
vtOld = -getJoggedDir();
|
|
dAngle = vtOld.angleTo(vtNew, AcGeVector3d::kZAxis);
|
|
m_vtDir.rotateBy(dAngle, AcGeVector3d::kZAxis);
|
|
dDist = m_ptStart.distanceTo(m_ptEnd) * .5;
|
|
m_ptStart = arPts[5] + vtNew.normal() * dDist;
|
|
m_ptEnd = arPts[5] - vtNew.normal() * dDist;
|
|
break;
|
|
case 4:
|
|
vtOld = getJoggedDir();
|
|
dAngle = vtOld.angleTo(vtNew, AcGeVector3d::kZAxis);
|
|
m_vtDir.rotateBy(dAngle, AcGeVector3d::kZAxis);
|
|
dDist = m_ptStart.distanceTo(m_ptEnd) * .5;
|
|
m_ptEnd = arPts[5] + vtNew.normal() * dDist;
|
|
m_ptStart = arPts[5] - vtNew.normal() * dDist;
|
|
break;
|
|
case 1: // 移动上端范围
|
|
if (offset.isParallelTo(X)) return;
|
|
ptOnLine = lineTop.closestPointTo(ptNew);
|
|
dDist = ptOnLine.distanceTo(ptNew);
|
|
vtNew = ptNew - ptOnLine;
|
|
if (!vtNew.isCodirectionalTo(Y))
|
|
dDist *= -1;
|
|
m_ptStart += Y * dDist;
|
|
break;
|
|
case 2: // 右侧范围左右移动
|
|
if (offset.isParallelTo(Y)) return;
|
|
ptOnLine = lineRight.closestPointTo(ptNew);
|
|
dDist = ptOnLine.distanceTo(ptNew);
|
|
vtNew = ptNew - ptOnLine;
|
|
if (!vtNew.isCodirectionalTo(X))
|
|
dDist *= -1;
|
|
m_vtDir = m_vtDir.normal() * (m_vtDir.length() + dDist);
|
|
break;
|
|
case 3: // 移动下端范围
|
|
if (offset.isParallelTo(X)) return;
|
|
ptOnLine = lineBottom.closestPointTo(ptNew);
|
|
dDist = ptOnLine.distanceTo(ptNew);
|
|
vtNew = ptNew - ptOnLine;
|
|
if (!vtNew.isCodirectionalTo(Y))
|
|
dDist *= -1;
|
|
m_ptEnd += Y * dDist;
|
|
break;
|
|
case 5: // 左侧范围左右移动
|
|
if (offset.isParallelTo(Y)) return;
|
|
ptOnLine = lineLeft.closestPointTo(ptNew);
|
|
dDist = ptOnLine.distanceTo(ptNew);
|
|
vtNew = ptNew - ptOnLine;
|
|
if (!vtNew.isCodirectionalTo(X))
|
|
dDist *= -1;
|
|
m_ptStart += X * dDist;
|
|
m_ptEnd += X * dDist;
|
|
m_vtDir = m_vtDir.normal() * (m_vtDir.length() - dDist);
|
|
break;
|
|
case 6: // 移动中点, 负责平移
|
|
mat.setToTranslation(offset);
|
|
m_ptStart.transformBy(mat);
|
|
m_ptEnd.transformBy(mat);
|
|
break;
|
|
case 101: // 移动顶点
|
|
ptNew = arPts[idx];
|
|
ptNew.z = m_dMaxElev;
|
|
ptNew += offset;
|
|
|
|
m_dMaxElev = ptNew.z;
|
|
if (m_dMinElev > m_dMaxElev)
|
|
std::swap(m_dMinElev, m_dMaxElev);
|
|
break;
|
|
case 100: // 移动底点
|
|
ptNew = arPts[idx];
|
|
ptNew.z = m_dMinElev;
|
|
ptNew += offset;
|
|
m_dMinElev = ptNew.z;
|
|
if (m_dMinElev > m_dMaxElev)
|
|
std::swap(m_dMinElev, m_dMaxElev);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
void AecDbJoggedCamera::Camera::collectEntities(AcDbObjectIdArray & ar)
|
|
{
|
|
struct resbuf *typelist = AecDbXCamera::getSelectTypeResbuf();
|
|
struct resbuf *pointlist = acutBuildList(RTPOINT, m_ptStart, RTPOINT, m_ptEnd,
|
|
RTPOINT, m_ptEnd + m_vtDir, RTPOINT, m_ptStart + m_vtDir, RTPOINT, m_ptStart, 0);
|
|
|
|
AecDbXCamera::collectEnities(typelist, pointlist, ar);
|
|
|
|
acutRelRb(pointlist);
|
|
acutRelRb(typelist);
|
|
}
|
|
|
|
void AecDbJoggedCamera::Camera::moveOutput(const AcGeVector3d &vtOffset)
|
|
{
|
|
AcGeMatrix3d mat;
|
|
mat.setToTranslation(vtOffset);
|
|
for (int i(0); i < m_arResults.length(); ++i)
|
|
{
|
|
AcDbEntityPointer ent(m_arResults[i], AcDb::kForWrite);
|
|
if (ent.openStatus() == Acad::eOk && !ent->isErased())
|
|
ent->transformBy(mat);
|
|
}
|
|
}
|
|
|
|
void AecDbJoggedCamera::Camera::hlrCalc()
|
|
{
|
|
AecDbXCamera::eraseEnts(m_arResults);
|
|
|
|
AcDbObjectIdArray ar;
|
|
collectEntities(ar);
|
|
if (ar.isEmpty()) return;
|
|
|
|
AcDbPolyline *pSection(getSectionPolygon());
|
|
if (!pSection) return;
|
|
|
|
AecDbXCamera::AcDbEntityArray entAxis;
|
|
AecDbXCamera::IDMapEntities outputWithID; // 可以与数据库实体相关联的结果
|
|
AecDbXCamera::AcDbEntityArray outputWithoutID;// 不能与数据库实体相关联的结果
|
|
AecDbXCamera::hlrCalc(ar
|
|
, getMidPoint()
|
|
, m_vtDir
|
|
, getXDir()
|
|
, m_ptOutput
|
|
, pSection
|
|
, outputWithID
|
|
, outputWithoutID
|
|
, entAxis);
|
|
|
|
DELETE_PTR(pSection);
|
|
|
|
// 输出
|
|
AecDbXCamera::IDMapEntities::iterator it(outputWithID.begin());
|
|
AcDbObjectId id;
|
|
for (; it != outputWithID.end(); ++it)
|
|
{
|
|
for (int i(0); i < it->second.length(); ++i)
|
|
{
|
|
AcDbEntity *pEnt(it->second[i]);
|
|
if (!pEnt) continue;
|
|
id = CoreTools::AddToModelSpace(pEnt);
|
|
if (id.isValid())
|
|
m_arResults.append(id);
|
|
else
|
|
DELETE_PTR(pEnt);
|
|
}
|
|
}
|
|
|
|
for (int i(0); i < outputWithoutID.length(); ++i)
|
|
{
|
|
AcDbEntity *pEnt(outputWithoutID[i]);
|
|
if (!pEnt) continue;
|
|
id = CoreTools::AddToModelSpace(pEnt);
|
|
if (id.isValid())
|
|
m_arResults.append(id);
|
|
else
|
|
DELETE_PTR(pEnt);
|
|
}
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region AecDbJoggedCamera
|
|
ACRX_DXF_DEFINE_MEMBERS(AecDbJoggedCamera, AecDbEntityBase,
|
|
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
|
|
AEC_JOGGEDCAMERA,
|
|
"AecDbJoggedCamera"
|
|
"|Product Desc: shanghua earthworm app obj"
|
|
"|Company: shanghua inc"
|
|
"|WEB Address: www.shanghuasoft.com")
|
|
|
|
Adesk::UInt32 AecDbJoggedCamera::kCurrentVersionNumber = 2;
|
|
Adesk::UInt32 AecDbJoggedCamera::Camera::kCurrentVersionNumber = 2;
|
|
|
|
AecDbJoggedCamera::AecDbJoggedCamera(): m_bSameSectionDir(false), m_bForcedParallel(false)
|
|
{
|
|
m_bSameSectionDir = HlrCutOption::getHlrZX_SameDir() == FALSE ? false : true;
|
|
m_bForcedParallel = HlrCutOption::getHlrZX_Parallel() == FALSE ? false : true;
|
|
}
|
|
|
|
AecDbJoggedCamera::AecDbJoggedCamera(AecDbJoggedCamera * pSrc)
|
|
{
|
|
copyFrom(pSrc);
|
|
}
|
|
|
|
AecDbJoggedCamera::~AecDbJoggedCamera()
|
|
{
|
|
deleteContainerOfArx<GripData>(m_GripDatas);
|
|
}
|
|
|
|
AecDbObjXDataMap * AecDbJoggedCamera::GetSpecialtyData(AcDb::OpenMode bMode)
|
|
{
|
|
if (bMode == AcDb::kForWrite)
|
|
AssertWriteEnabled();
|
|
else
|
|
assertReadEnabled();
|
|
|
|
return &m_mapSpecXData;
|
|
}
|
|
|
|
const AecDbObjXDataMap * AecDbJoggedCamera::GetSpecialtyData() const
|
|
{
|
|
assertReadEnabled();
|
|
return &m_mapSpecXData;
|
|
}
|
|
|
|
void AecDbJoggedCamera::subList() const
|
|
{
|
|
assertReadEnabled();
|
|
AecDbEntityBase::subList();
|
|
m_mapSpecXData.List();
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbJoggedCamera::copyFrom(const AcRxObject * pSrc)
|
|
{
|
|
AssertWriteEnabled();
|
|
AecDbJoggedCamera *pCamera = AecDbJoggedCamera::cast(pSrc);
|
|
if (pCamera == NULL) return Acad::eInvalidInput;
|
|
|
|
m_mapSpecXData.CopyFrom(pCamera->GetSpecialtyData(AcDb::kForRead));
|
|
m_cameras = pCamera->m_cameras;
|
|
m_ptOutput = pCamera->m_ptOutput;
|
|
m_bSameSectionDir = pCamera->m_bSameSectionDir;
|
|
m_bForcedParallel = pCamera->m_bForcedParallel;
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbJoggedCamera::subTransformBy(const AcGeMatrix3d & xform)
|
|
{
|
|
AssertWriteEnabled();
|
|
AecDbEntityBase::subTransformBy(xform);
|
|
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
Camera &cam = m_cameras[i];
|
|
cam.m_ptStart.transformBy(xform);
|
|
cam.m_ptEnd.transformBy(xform);
|
|
cam.m_vtDir.transformBy(xform);
|
|
}
|
|
|
|
// 剖切结果对齐点不移动
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbJoggedCamera::subGetGripPoints(AcDbGripDataPtrArray & grips
|
|
, const double curViewUnitSize
|
|
, const int gripSize
|
|
, const AcGeVector3d & curViewDir
|
|
, const int bitflags) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGeVector3d vtZ(curViewDir);
|
|
bool bHori = vtZ.isParallelTo(AcGeVector3d::kZAxis) == Adesk::kFalse ? false : true;
|
|
|
|
deleteContainerOfArx<GripData>(m_GripDatas);
|
|
|
|
getGripPoints(bHori, grips);
|
|
|
|
getVirtualLine(bHori);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbJoggedCamera::subMoveGripPointsAt(const AcDbVoidPtrArray & appData, const AcGeVector3d & offset, const int bitflags)
|
|
{
|
|
// 如果能进到这个函数,说明至少有一个Camera
|
|
AssertWriteEnabled();
|
|
if (appData.isEmpty()) return Acad::eOk;
|
|
|
|
GripData *pAppData = (GripData *)appData.first();
|
|
|
|
|
|
if (pAppData->m_idx == -1 && pAppData->m_subIdx == -1)
|
|
{
|
|
// 结果点
|
|
if (database())
|
|
moveOutput(offset);
|
|
}
|
|
else if ((pAppData->m_idx >= 0 && pAppData->m_idx < m_cameras.size()))
|
|
{
|
|
switch (pAppData->m_subIdx)
|
|
{
|
|
case 0: // 移动第一个点, 统一旋转
|
|
case 4:
|
|
{
|
|
AcGePoint3d ptNew = pAppData->m_pt + offset;
|
|
AcGeVector3d vtOld = m_cameras.begin()->getJoggedDir();
|
|
AcGePoint3d ptOther;
|
|
|
|
if (pAppData->m_subIdx == 0)
|
|
{
|
|
ptOther = m_cameras.begin()->getMidPoint();
|
|
vtOld *= -1;
|
|
}
|
|
else if (pAppData->m_subIdx == 4)
|
|
{
|
|
ptOther = m_cameras.rbegin()->getMidPoint();
|
|
}
|
|
AcGeVector3d vtNew = ptNew - ptOther;
|
|
double dA = vtOld.angleTo(vtNew, AcGeVector3d::kZAxis);
|
|
AcGeMatrix3d mat(AcGeMatrix3d::rotation(dA, AcGeVector3d::kZAxis, ptOther));
|
|
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
m_cameras[i].transformBy(mat);
|
|
|
|
break;
|
|
}
|
|
case 101: // 顶点
|
|
{
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
m_cameras[i].moveGripPointsAt(101, offset);
|
|
}
|
|
break;
|
|
case 100: // 底点
|
|
{
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
m_cameras[i].moveGripPointsAt(100, offset);
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
AcGeVector3d vtOld(m_cameras[pAppData->m_idx].m_vtDir);
|
|
// 如果调整了1、6、3夹点，需要判断一下调整后的折线会不会和其他的相交
|
|
if (pAppData->m_subIdx == 1 || pAppData->m_subIdx == 3 || pAppData->m_subIdx == 6)
|
|
{
|
|
Camera cam = m_cameras[pAppData->m_idx];
|
|
cam.moveGripPointsAt(pAppData->m_subIdx, offset);
|
|
AcGeLineSeg3d seg1(cam.m_ptStart, cam.m_ptEnd), seg2;
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
if (i == pAppData->m_idx) continue;
|
|
seg2.set(m_cameras[i].m_ptStart, m_cameras[i].m_ptEnd);
|
|
if (isRegionOverlapping(seg1, seg2))
|
|
return Acad::eInvalidInput;
|
|
}
|
|
m_cameras[pAppData->m_idx] = cam;
|
|
if (pAppData->m_subIdx == 1 || pAppData->m_subIdx == 3)
|
|
refreshOutputPoint();
|
|
}
|
|
else
|
|
{
|
|
m_cameras[pAppData->m_idx].moveGripPointsAt(pAppData->m_subIdx, offset);
|
|
}
|
|
|
|
// 新需求,各个剖切线的方向不需要统一
|
|
// 一个折线改变了方向,其他一起改变
|
|
if (database() && !vtOld.isCodirectionalTo(m_cameras[pAppData->m_idx].m_vtDir) && m_bSameSectionDir)
|
|
{
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
if (i == pAppData->m_idx) continue;
|
|
m_cameras[i].m_vtDir *= -1;
|
|
}
|
|
refreshOutputPoint();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbJoggedCamera::dwgInFields(AcDbDwgFiler * pFiler)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
//----- Read parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
if (!pFiler->isKindOf(CMFCDbDwgFiler::desc()))
|
|
{
|
|
es = AecDbEntityBase::dwgInFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
return (es);
|
|
}
|
|
|
|
//----- Object version number needs to be read first
|
|
Adesk::UInt32 version = 0;
|
|
if ((es = pFiler->readUInt32(&version)) != Acad::eOk)
|
|
return (es);
|
|
|
|
if (version > AecDbJoggedCamera::kCurrentVersionNumber)
|
|
return (Acad::eMakeMeProxy);
|
|
|
|
m_mapSpecXData.dwgInFields(pFiler);
|
|
|
|
pFiler->readPoint3d(&m_ptOutput);
|
|
|
|
int countOfCameras(0);
|
|
pFiler->readInt32((Adesk::Int32 *)&countOfCameras);
|
|
|
|
m_cameras.resize(countOfCameras);
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
if (m_cameras[i].dwgInFields(pFiler) != Acad::eOk)
|
|
return (es);
|
|
}
|
|
|
|
if (version > 1)
|
|
{
|
|
pFiler->readBool(&m_bSameSectionDir);
|
|
pFiler->readBool(&m_bForcedParallel);
|
|
}
|
|
|
|
return (pFiler->filerStatus());
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbJoggedCamera::dwgOutFields(AcDbDwgFiler * pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//----- Save parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
if (!pFiler->isKindOf(CMFCDbDwgFiler::desc()))
|
|
{
|
|
es = AecDbEntityBase::dwgOutFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
return (es);
|
|
}
|
|
|
|
//----- Object version number needs to be saved first
|
|
if ((es = pFiler->writeUInt32(AecDbJoggedCamera::kCurrentVersionNumber)) != Acad::eOk)
|
|
return (es);
|
|
|
|
m_mapSpecXData.dwgOutFields(pFiler);
|
|
|
|
pFiler->writePoint3d(m_ptOutput);
|
|
|
|
pFiler->writeInt32((Adesk::Int32)m_cameras.size());
|
|
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
if (m_cameras[i].dwgOutFields(pFiler) != Acad::eOk)
|
|
return (es);
|
|
}
|
|
|
|
pFiler->writeBool(m_bSameSectionDir);
|
|
pFiler->writeBool(m_bForcedParallel);
|
|
|
|
return (pFiler->filerStatus());
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbJoggedCamera::subGetGeomExtents(AcDbExtents & extents) const
|
|
{
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
extents.addPoint(m_cameras[i].m_ptStart);
|
|
extents.addPoint(m_cameras[i].m_ptEnd);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbJoggedCamera::subGetOsnapPoints(AcDb::OsnapMode osnapMode
|
|
, INT_PTR gsSelectionMark
|
|
, const AcGePoint3d & pickPoint
|
|
, const AcGePoint3d & lastPoint
|
|
, const AcGeMatrix3d & viewXform
|
|
, AcGePoint3dArray & snapPoints
|
|
, AcDbIntArray & geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGePoint3dArray ar;
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
ar.removeAll();
|
|
|
|
m_cameras[i].getGripPoints(ar);
|
|
|
|
if (!ar.isEmpty())
|
|
snapPoints.append(ar);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbJoggedCamera::Draw2d(AcGiDraw & dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
// 颜色随层
|
|
Adesk::UInt16 oldClr = dc.GetColor();
|
|
AcDbObjectId oldLinetype = dc.GetLineTypeId();
|
|
double oldLineWidth = dc.GetLineWidth();
|
|
|
|
AcDbObjectId lTContinuous = CoreTools::GetLTypeId(_T("Continuous"));
|
|
AcDbObjectId lTCenter2 = CoreTools::GetLTypeId(_T("CENTER2"));
|
|
if (!lTContinuous.isValid())
|
|
lTContinuous = oldLinetype;
|
|
if (!lTCenter2.isValid())
|
|
lTCenter2 = lTContinuous;
|
|
|
|
dc.SetColor(256);
|
|
int iClr(0);
|
|
// 绘制剖切线
|
|
AcGePoint3d pt1, pt2;
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
const Camera &cam = m_cameras[i];
|
|
pt1 = cam.m_ptStart;
|
|
pt2 = cam.m_ptEnd;
|
|
//pt1.z = pt2.z = (cam.m_ptStart.z + cam.m_ptEnd.z) * 0.5;
|
|
pt1.z = pt2.z = cam.m_dMinElev;
|
|
|
|
// 颜色随着索引变化， 方便在属性中对应修改
|
|
dc.SetColor(cam.m_iColor);
|
|
|
|
dc.SetLineType(lTContinuous);
|
|
dc.SetLineWidth(5.);
|
|
dc.DrawLine(AcGeLineSeg3d(pt1, pt2));
|
|
DrawElev(dc, cam, cam.m_iColor);
|
|
}
|
|
dc.SetColor(9);
|
|
for (size_t i(1); i < m_cameras.size(); ++i)
|
|
{
|
|
const Camera &cam0 = m_cameras[i-1];
|
|
const Camera &cam1 = m_cameras[i];
|
|
pt1 = cam0.m_ptEnd;
|
|
pt2 = cam1.m_ptStart;
|
|
pt1.z = cam0.m_dMinElev;
|
|
pt2.z = cam1.m_dMinElev;
|
|
dc.SetLineType(lTCenter2);
|
|
dc.SetLineWidth(1.);
|
|
dc.DrawLine(AcGeLineSeg3d(pt1, pt2));
|
|
}
|
|
|
|
dc.SetColor(oldClr);
|
|
dc.SetLineType(oldLinetype);
|
|
dc.SetLineWidth(oldLineWidth);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbJoggedCamera::DrawElev(AcGiDraw &dc, const Camera &cam, const int &iClr) const
|
|
{
|
|
assertReadEnabled();
|
|
int oldClr = dc.GetColor();
|
|
dc.SetColor(iClr);
|
|
const AcGePoint3d &pt1 = cam.m_ptStart;
|
|
const AcGePoint3d &pt2 = cam.m_ptEnd;
|
|
|
|
double dH(pt1.distanceTo(pt2) * .025);
|
|
AcGePoint3d ptIns = CoreTools::MidPt(pt1, pt2) - cam.m_vtDir.normal() * dH;
|
|
AcGeVector3d X = (pt2 - pt1).normalize();
|
|
double dRotation = AcGeVector3d::kXAxis.angleTo(X, AcGeVector3d::kZAxis);
|
|
CString sTop;
|
|
int prec(0);
|
|
sTop.Format(_T("%s , %s")
|
|
, TypeConvert::d2s(cam.m_dMaxElev, &prec)
|
|
, TypeConvert::d2s(cam.m_dMinElev, &prec));
|
|
|
|
AcDbText txt1;
|
|
AcDbExtents ext;
|
|
txt1.setTextString(sTop);
|
|
txt1.setPosition(ptIns);
|
|
txt1.setHeight(dH);
|
|
txt1.getGeomExtents(ext);
|
|
double dW = ext.maxPoint().x - ext.minPoint().x;
|
|
ptIns -= X * (dW * .5);
|
|
ptIns.z = cam.m_dMinElev;
|
|
txt1.setPosition(ptIns);
|
|
txt1.setRotation(dRotation);
|
|
|
|
dc.DrawEntity(txt1);
|
|
dc.SetColor(oldClr);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbJoggedCamera::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
return Draw2d(dc);
|
|
}
|
|
|
|
void AecDbJoggedCamera::moveOutput(const AcGeVector3d & vtOffset)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptOutput += vtOffset;
|
|
refreshOutputPoint();
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
m_cameras[i].moveOutput(vtOffset);
|
|
}
|
|
|
|
void AecDbJoggedCamera::getVirtualLine(const bool &bHori) const
|
|
{
|
|
assertReadEnabled();
|
|
// 第1个点作为绘制点,绘制虚框
|
|
GripData &first = *m_GripDatas.first();
|
|
first.m_mode = AecDbXCamera::eVerti;
|
|
first.m_arSelectFrame.removeAll();
|
|
|
|
AcGePoint3d pt1, pt2, pt3, pt4;
|
|
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
const Camera &cam = m_cameras[i];
|
|
pt1 = cam.m_ptStart;
|
|
pt2 = cam.m_ptStart + cam.m_vtDir;
|
|
pt3 = cam.m_ptEnd + cam.m_vtDir;
|
|
pt4 = cam.m_ptEnd;
|
|
if (bHori)
|
|
{
|
|
pt1.z = pt2.z = pt3.z = pt4.z = .0;
|
|
// 4个点为一组
|
|
first.m_arSelectFrame.append(pt1);
|
|
first.m_arSelectFrame.append(pt2);
|
|
first.m_arSelectFrame.append(pt3);
|
|
first.m_arSelectFrame.append(pt4);
|
|
}
|
|
else
|
|
{
|
|
pt1.z = pt2.z = pt3.z = pt4.z = cam.m_dMinElev;
|
|
// 4个点为一组,低点在前，高点在后
|
|
first.m_arSelectFrame.append(pt1);
|
|
first.m_arSelectFrame.append(pt2);
|
|
first.m_arSelectFrame.append(pt3);
|
|
first.m_arSelectFrame.append(pt4);
|
|
|
|
pt1.z = pt2.z = pt3.z = pt4.z = cam.m_dMaxElev;
|
|
first.m_arSelectFrame.append(pt1);
|
|
first.m_arSelectFrame.append(pt2);
|
|
first.m_arSelectFrame.append(pt3);
|
|
first.m_arSelectFrame.append(pt4);
|
|
}
|
|
}
|
|
// 显示结果范围
|
|
AcGePoint3dArray ar;
|
|
if (getResultBox(ar))
|
|
{
|
|
GripData &first = *m_GripDatas.first();
|
|
first.m_bDrawResultFrame = true;
|
|
first.m_arResultFrame.append(ar);
|
|
}
|
|
}
|
|
|
|
bool AecDbJoggedCamera::getResultBox(AcGePoint3dArray &ar) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AecDbXCamera::IDMapEntities result1;
|
|
AecDbXCamera::EntMapEntities result2;
|
|
|
|
AcGePoint3d pt;
|
|
int numVerts;
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
const Camera *pCam(&m_cameras[i]);
|
|
AcDbPolyline *pPoly(pCam->getSectionPolygon());
|
|
if (!pPoly) continue;
|
|
|
|
|
|
|
|
AecDbXCamera::transfromHlrResult(pCam->getMidPoint()
|
|
, pCam->m_vtDir
|
|
, pCam->getXDir()
|
|
, pCam->m_ptOutput
|
|
, result1
|
|
, result2
|
|
, pPoly);
|
|
|
|
numVerts = pPoly->numVerts();
|
|
if (numVerts < 4)
|
|
{
|
|
DELETE_PTR(pPoly);
|
|
continue;
|
|
}
|
|
for (int j(0); j < 4; ++j)
|
|
{
|
|
pPoly->getPointAt(j, pt);
|
|
ar.append(pt);
|
|
}
|
|
|
|
DELETE_PTR(pPoly);
|
|
}
|
|
|
|
return ar.length() >= 4;
|
|
}
|
|
|
|
void AecDbJoggedCamera::refreshOutputPoint()
|
|
{
|
|
// 不重新计算
|
|
assertReadEnabled();
|
|
|
|
if (m_cameras.empty()) return;
|
|
|
|
// 得到 折线 排序的方向 "左" -> "右"
|
|
// 各个折线的中点沿着 vtSort 排序, 得到在m_ptOutput点沿水平方向展开的顺序
|
|
std::vector<Camera*> cameras;
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
cameras.push_back(&m_cameras[i]);
|
|
std::sort(cameras.begin(), cameras.end(), sort_jogged(m_cameras.begin()->getXDir()));
|
|
|
|
double dAllLen(.0);
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
dAllLen += m_cameras[i].getJoggedLength();
|
|
|
|
AcGePoint3d ptS(m_ptOutput - AcGeVector3d::kXAxis * dAllLen * .5);
|
|
|
|
AcGeVector3d vt;
|
|
double dLen(.0);
|
|
for (size_t i(0); i < cameras.size(); ++i)
|
|
{
|
|
vt = cameras[i]->getJoggedLength() * .5 * AcGeVector3d::kXAxis;
|
|
cameras[i]->m_ptOutput = ptS + vt;
|
|
ptS += 2 * vt;
|
|
}
|
|
}
|
|
|
|
void AecDbJoggedCamera::getGripPoints(const bool &bHori, AcDbGripDataPtrArray &grips) const
|
|
{
|
|
assertReadEnabled();
|
|
if (m_cameras.empty()) return;
|
|
|
|
if (bHori)
|
|
{
|
|
// 第一段起点，和第二段终点，其他段的中点
|
|
addGripData(0, 0, m_cameras.begin()->m_ptStart, m_GripDatas, grips);
|
|
|
|
int idx3(0);//上一个camera的第3个点的索引
|
|
AcGePoint3dArray pts;
|
|
double dOnePixel = CoreTools::PixelToWcs(1);
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
const Camera &cam = m_cameras[i];
|
|
pts.removeAll();
|
|
cam.getGripPoints(pts);
|
|
|
|
// 共6个点
|
|
if (pts.length() < 7) continue;
|
|
|
|
// 每个camera的第pts[1]点可能和上一个camera的第pts[3]点重合
|
|
// 此时，应该把当前camera的第二个点向折线绘制方向移动一个夹点的距离
|
|
|
|
// 没插入pts[1]之前，m_GripDatas的最后一个点是上个camera的第pts[6]点
|
|
// 那么再上2个点就是需要比较的第pts[3]点
|
|
|
|
// 得到上个camera的第6个点
|
|
idx3 = m_GripDatas.length() - 3;
|
|
// 重合，移动一下pts[1],然后插入ar
|
|
if (idx3 > 0 && COMPARE_DOUBLE::equal_zero(m_GripDatas[idx3]->m_pt.distanceTo(pts[1])))
|
|
pts[1] += (cam.getJoggedDir()).normal() * PIXEL_SIZE * dOnePixel;
|
|
|
|
addGripData((int)i, 1, pts[1], m_GripDatas, grips);
|
|
addGripData((int)i, 2, pts[2], m_GripDatas, grips);
|
|
addGripData((int)i, 3, pts[3], m_GripDatas, grips);
|
|
addGripData((int)i, 5, pts[5], m_GripDatas, grips);
|
|
addGripData((int)i, 6, pts[6], m_GripDatas, grips);
|
|
}
|
|
|
|
addGripData((int)(m_cameras.size() - 1), 4, m_cameras.rbegin()->m_ptEnd, m_GripDatas, grips);
|
|
}
|
|
else
|
|
{ // 每段上中点和下中点,序号从100开始
|
|
// 改为只显示一个，用来统一修改标高
|
|
AcGePoint3d pt;
|
|
if (!m_cameras.empty())
|
|
{
|
|
const Camera &cam = *m_cameras.begin();
|
|
pt = CoreTools::MidPt(cam.m_ptStart, cam.m_ptEnd);
|
|
pt.z = cam.m_dMinElev;
|
|
addGripData((int)0, 100 + 0, pt, m_GripDatas, grips);
|
|
|
|
pt.z = cam.m_dMaxElev;
|
|
// 如果m_dMinElev == m_dMaxElev,说明没有高度差
|
|
// 上中点需要向上移动一个夹点的距离，避免和下中点重合
|
|
if (cam.m_dMinElev == cam.m_dMaxElev)
|
|
pt.z += PIXEL_SIZE * CoreTools::PixelToWcs(1);
|
|
|
|
addGripData((int)0, 100 + 1, pt, m_GripDatas, grips);
|
|
}
|
|
}
|
|
// 对齐点在最后一个
|
|
addGripData(-1, -1, m_ptOutput, m_GripDatas, grips);
|
|
}
|
|
|
|
AcGePoint3d AecDbJoggedCamera::getLastPoint() const
|
|
{
|
|
assertReadEnabled();
|
|
if (m_cameras.empty()) return AcGePoint3d::kOrigin;
|
|
return m_cameras.rbegin()->m_ptEnd;
|
|
}
|
|
|
|
AcGeVector3d AecDbJoggedCamera::getJoggedDir() const
|
|
{
|
|
assertReadEnabled();
|
|
AcGeVector3d vt(AcGeVector3d::kIdentity);
|
|
if (m_cameras.empty()) return vt;
|
|
return m_cameras[0].getJoggedDir();
|
|
}
|
|
|
|
AcGeVector3d AecDbJoggedCamera::getSectionDir() const
|
|
{
|
|
assertReadEnabled();
|
|
AcGeVector3d vt(AcGeVector3d::kIdentity);
|
|
if (m_cameras.empty()) return vt;
|
|
return m_cameras[0].m_vtDir;
|
|
}
|
|
|
|
void AecDbJoggedCamera::delCamera(const int & idx)
|
|
{
|
|
AssertWriteEnabled();
|
|
if (idx < 0 || idx >= m_cameras.size()) return;
|
|
Cameras::iterator it(m_cameras.begin());
|
|
std::advance(it, idx);
|
|
m_cameras.erase(it);
|
|
}
|
|
|
|
const AecDbJoggedCamera::Camera* AecDbJoggedCamera::getCamera(const int & idx) const
|
|
{
|
|
assertReadEnabled();
|
|
if (idx < 0 || idx >= m_cameras.size()) return NULL;
|
|
return &m_cameras[idx];
|
|
}
|
|
|
|
void AecDbJoggedCamera::setCameraHeight(const int & idx, const double & dMax, const double & dMin)
|
|
{
|
|
AssertWriteEnabled();
|
|
if (idx < 0 || idx >= m_cameras.size()) return;
|
|
|
|
Camera &cam(m_cameras[idx]);
|
|
|
|
if (COMPARE_DOUBLE::equal(dMax, dMin))
|
|
{
|
|
cam.setElev(1000., 0.);
|
|
return;
|
|
}
|
|
|
|
cam.setElev(dMax, dMin);
|
|
|
|
if (cam.m_dMaxElev < cam.m_dMinElev)
|
|
std::swap(cam.m_dMaxElev, cam.m_dMinElev);
|
|
}
|
|
|
|
void AecDbJoggedCamera::setCameraWidth(const int & idx, const AcGePoint3d &ptOut)
|
|
{
|
|
AssertWriteEnabled();
|
|
if (idx < 0 || idx >= m_cameras.size()) return;
|
|
|
|
Camera &cam(m_cameras[idx]);
|
|
|
|
AcGePoint3d ptOn = getClosestPoint(cam.m_ptStart, cam.m_ptEnd, ptOut);
|
|
|
|
double dist(ptOn.distanceTo(ptOut));
|
|
if (COMPARE_DOUBLE::equal_zero(dist))
|
|
dist = 1000.;
|
|
else
|
|
{
|
|
if (!(ptOut - ptOn).isCodirectionalTo(cam.m_vtDir))
|
|
dist *= -1;
|
|
}
|
|
|
|
cam.m_vtDir.normalize();
|
|
cam.m_vtDir *= dist;
|
|
|
|
// 如果不是第一段折线，那么其他的剖切方向都要和第一段一致
|
|
if (idx != 0 && !cam.m_vtDir.isCodirectionalTo(m_cameras.begin()->m_vtDir))
|
|
cam.m_vtDir *= -1;
|
|
}
|
|
|
|
bool AecDbJoggedCamera::isOverlappingCamera(const int & idx) const
|
|
{
|
|
assertReadEnabled();
|
|
return false;
|
|
}
|
|
|
|
AcGePoint3d AecDbJoggedCamera::getClosestPoint(const AcGePoint3d & ptOn1, const AcGePoint3d & ptOn2, const AcGePoint3d & ptOut)
|
|
{
|
|
AcGeLine3d line(ptOn1, ptOn2);
|
|
return line.closestPointTo(ptOut);
|
|
}
|
|
|
|
AcGePoint3d AecDbJoggedCamera::getClosestPoint(const AcGePoint3d & ptOn, const AcGeVector3d & vt, const AcGePoint3d & ptOut)
|
|
{
|
|
AcGeLine3d line(ptOn, vt);
|
|
return line.closestPointTo(ptOut);
|
|
}
|
|
|
|
void AecDbJoggedCamera::setOutputPoint(const AcGePoint3d & pt)
|
|
{
|
|
moveOutput(pt - m_ptOutput);
|
|
}
|
|
|
|
bool AecDbJoggedCamera::judgeSegmentCanInsert(const AcGePoint3d &pt1, const AcGePoint3d &pt2, AcGePoint3d &ptClosed) const
|
|
{
|
|
// 这些子折线,都互相平行,
|
|
// 可以共线，不能重合
|
|
// 也就是说,这些Camera的m_vtDir方向都相同
|
|
|
|
if (m_cameras.empty()) return true;
|
|
|
|
const Camera LastCam = *m_cameras.rbegin();
|
|
|
|
AcGeVector3d vtDir(LastCam.getJoggedDir());
|
|
|
|
// 检查第1个点
|
|
if (!checkPoint(LastCam.m_ptEnd, vtDir, pt1, ptClosed, true)) return false;
|
|
|
|
// 检查第2个点
|
|
if (!checkPoint(pt1, vtDir, pt2, ptClosed, false)) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool AecDbJoggedCamera::addCamera(const AcGePoint3d &_pt1
|
|
, const AcGePoint3d &_pt2
|
|
, const AcGeVector3d &vt)
|
|
{
|
|
AssertWriteEnabled();
|
|
if (m_cameras.empty())
|
|
{
|
|
m_cameras.push_back(Camera(_pt1, _pt2));
|
|
m_cameras.rbegin()->m_vtDir = vt;
|
|
m_cameras.rbegin()->m_iColor = 1;
|
|
return true;
|
|
}
|
|
|
|
AcGePoint3d ptClosed;
|
|
|
|
if (!judgeSegmentCanInsert(_pt1, _pt2, ptClosed))
|
|
return false;
|
|
|
|
Camera &lastCam = m_cameras.back();
|
|
|
|
// 通过judgeSegmentCanInsert检查后,如果pt1-pt2的方向与
|
|
// 其他Camera的m_ptStart-m_ptEnd方向不一致,改变方向即可插入
|
|
AcGePoint3d pt1 = _pt1, pt2 = _pt2;
|
|
if (!lastCam.getJoggedDir().isCodirectionalTo(pt2 - pt1))
|
|
std::swap(pt1, pt2);
|
|
|
|
// 以上条件都满足,不需要判断方向,使用统一的方向,但要得到矢量的长度
|
|
m_cameras.push_back(Camera(pt1, pt2));
|
|
|
|
// 方向改为任意,不需要统一
|
|
//m_cameras.rbegin()->m_vtDir = m_cameras.begin()->m_vtDir.normal() * vt.length();
|
|
m_cameras.rbegin()->m_vtDir = vt;
|
|
|
|
// 根据索引设置颜色
|
|
if (lastCam.m_iColor == 8)
|
|
m_cameras.rbegin()->m_iColor = 10; // 颜色9保留
|
|
else
|
|
m_cameras.rbegin()->m_iColor = lastCam.m_iColor + 1;
|
|
return true;
|
|
}
|
|
|
|
bool AecDbJoggedCamera::GetProperties(SimpleProperty::PropertySetByIndex & properties) const
|
|
{
|
|
assertReadEnabled();
|
|
CString sIndex;
|
|
|
|
// 上下标高永远用第一段剖切线的
|
|
if (m_cameras.empty()) return false;
|
|
|
|
const Camera &cam = *m_cameras.begin();
|
|
SimpleProperty::makeAndInsert(properties, _T("剖切范围上标高"), cam.m_dMaxElev, true);
|
|
SimpleProperty::makeAndInsert(properties, _T("剖切范围下标高"), cam.m_dMinElev, true);
|
|
|
|
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
const Camera &cam = m_cameras[i];
|
|
sIndex.Format(_T("折线%d-剖切宽度"), i + 1);
|
|
SimpleProperty::makeAndInsert(properties, sIndex, cam.m_vtDir.length(), true, cam.m_iColor);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool AecDbJoggedCamera::SetProperties(SimpleProperty::PropertySetByName & properties)
|
|
{
|
|
AssertWriteEnabled();
|
|
// 处理 上下标高
|
|
|
|
if (m_cameras.empty()) return false;
|
|
|
|
// 按照原始值初始化，哪怕界面上没有修改数值，也能保证数据的正确性
|
|
double dMax(m_cameras.begin()->m_dMaxElev), dMin(m_cameras.begin()->m_dMinElev);
|
|
properties.findAndSet(_T("剖切范围上标高"), dMax);
|
|
properties.findAndSet(_T("剖切范围下标高"), dMin);
|
|
if (dMax < dMin)
|
|
{
|
|
// 交换
|
|
std::swap(dMax, dMin);
|
|
}
|
|
|
|
double dVal;
|
|
CString sPropertyName(_T(""));
|
|
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
sPropertyName.Format(_T("折线%d-剖切宽度"), i + 1);
|
|
if (properties.findAndSet(sPropertyName, dVal))
|
|
{
|
|
if (dVal < 10.)
|
|
{
|
|
acutPrintf(_T("\n剖切宽度不能小于10，已自动调整为10。"));
|
|
dVal = 10.;
|
|
}
|
|
m_cameras[i].m_vtDir = m_cameras[i].m_vtDir.normal() * dVal;
|
|
}
|
|
m_cameras[i].m_dMaxElev = dMax;
|
|
m_cameras[i].m_dMinElev = dMin;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void AecDbJoggedCamera::refresh()
|
|
{
|
|
for (size_t i(0); i < m_cameras.size(); ++i)
|
|
{
|
|
m_cameras[i].hlrCalc();
|
|
}
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region JoggedJig
|
|
AcEdJig::DragStatus CJoggedCameraJig::DoIt()
|
|
{
|
|
m_pPolyline = new AcDbPolyline();
|
|
m_pPolyline->setNormal(AcGeVector3d::kZAxis);
|
|
m_pPolyline->setElevation(.0);
|
|
AcEdJig::DragStatus stat;
|
|
AcGePoint3d ptClosest;
|
|
AcDbObjectId subid;
|
|
while (true)
|
|
{
|
|
setDispPrompt(_T("\n选取第%d段剖切线的起点："), m_numOfSeg + 1);
|
|
stat = drag();
|
|
if (stat == AcEdJig::kNull || stat == AcEdJig::kCancel)
|
|
{
|
|
deleteSupportLine();
|
|
return stat;
|
|
}
|
|
|
|
if (m_pJogged->getCameraCount() == 0)
|
|
{
|
|
++m_nStep;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (m_pJogged->judgeSegmentCanInsert(m_ptStart, m_ptStart + m_pJogged->getJoggedDir().normal() * 10, ptClosest))
|
|
{
|
|
++m_nStep;
|
|
|
|
deleteSupportLine();
|
|
AcDbLine *pLine = new AcDbLine(m_ptStart, m_pJogged->getLastPoint());
|
|
pLine->setColorIndex(9);
|
|
m_supportLineID = CoreTools::AddToModelSpace(pLine, true);
|
|
|
|
break;
|
|
}
|
|
acutPrintf(_T("\n剖切线的起点不能和已有的剖切线区域重叠，请重新拾取！"));
|
|
}
|
|
}
|
|
|
|
while (true)
|
|
{
|
|
setDispPrompt(_T("\n选取第%d段剖切线的终点："), m_numOfSeg + 1);
|
|
stat = drag();
|
|
if (stat == AcEdJig::kNull || stat == AcEdJig::kCancel)
|
|
{
|
|
deleteSupportLine();
|
|
return stat;
|
|
}
|
|
|
|
if (m_pJogged->getCameraCount() == 0)
|
|
{
|
|
++m_nStep;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (m_pJogged->judgeSegmentCanInsert(m_ptStart, m_ptEnd, ptClosest))
|
|
{
|
|
if (m_pJogged->isForcedParallel())
|
|
m_ptEnd = ptClosest;
|
|
++m_nStep;
|
|
break;
|
|
}
|
|
acutPrintf(_T("\n剖切线的终点必须在上个剖切线终点和当前剖切线起点的延长线上，请重新拾取！"));
|
|
}
|
|
}
|
|
|
|
setDispPrompt(_T("\n选取第%d段剖切线的方向和范围："), m_numOfSeg + 1);
|
|
stat = drag();
|
|
|
|
deleteSupportLine();
|
|
|
|
if (stat == AcEdJig::kNull || stat == AcEdJig::kCancel) return stat;
|
|
++m_nStep;
|
|
|
|
return stat;
|
|
}
|
|
|
|
AcEdJig::DragStatus CJoggedCameraJig::sampler()
|
|
{
|
|
AcEdJig::DragStatus stat;
|
|
setUserInputControls((UserInputControls) (AcEdJig::kAccept3dCoordinates | AcEdJig::kNullResponseAccepted ));
|
|
|
|
m_pPolyline->reset(false, 0);
|
|
|
|
if (m_nStep == 0)
|
|
{
|
|
if (m_numOfSeg != 0)
|
|
{
|
|
static AcGePoint3d pt0;
|
|
AcGePoint3d ptPrev(m_pJogged->getLastPoint());
|
|
stat = acquirePoint(m_ptStart, ptPrev);
|
|
|
|
if (m_ptStart != pt0)
|
|
pt0 = m_ptStart;
|
|
else if (stat == AcEdJig::kNormal)
|
|
return AcEdJig::kNoChange;
|
|
}
|
|
else
|
|
stat = acquirePoint(m_ptStart);
|
|
}
|
|
else if (m_nStep == 1)
|
|
{
|
|
static AcGePoint3d pt1;
|
|
stat = acquirePoint(m_ptEnd, m_ptStart);
|
|
|
|
// 当shfit按下时,或者"强制平行"被设置时
|
|
bool bShiftPressed = (GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0 || m_pJogged->isForcedParallel();
|
|
|
|
if (m_ptEnd != pt1)
|
|
pt1 = m_ptEnd;
|
|
else if (stat == AcEdJig::kNormal)
|
|
return AcEdJig::kNoChange;
|
|
|
|
if (m_ptEnd.isEqualTo(m_ptStart))
|
|
return AcEdJig::kNoChange;
|
|
|
|
if (bShiftPressed && m_numOfSeg != 0)
|
|
{
|
|
AcGeVector3d vt = m_pJogged->getJoggedDir();
|
|
AcGeLine3d ln(m_ptStart, vt.normal());
|
|
m_ptEnd = ln.closestPointTo(m_ptEnd);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double dDist(.0);
|
|
AcGePoint3d ptMid(CoreTools::MidPt(m_ptStart, m_ptEnd));
|
|
if (m_numOfSeg == 0 || !m_pJogged->isSameSectionDir())
|
|
{
|
|
static AcGePoint3d pt2;
|
|
AcGePoint3d ptDir;
|
|
stat = acquirePoint(ptDir, ptMid);
|
|
|
|
if (ptDir != pt2)
|
|
pt2 = ptDir;
|
|
else if (stat == AcEdJig::kNormal)
|
|
return AcEdJig::kNoChange;
|
|
|
|
AcGeLine3d line(m_ptStart, m_ptEnd);
|
|
AcGePoint3d ptOnLine(line.closestPointTo(ptDir));
|
|
dDist = ptOnLine.distanceTo(ptDir);
|
|
m_vtEye = ptDir - ptOnLine;
|
|
}
|
|
else
|
|
{
|
|
stat = acquireDist(dDist, ptMid);
|
|
m_vtEye = m_vtEye.normal() * dDist;
|
|
}
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
AcDbEntity *CJoggedCameraJig::entity() const
|
|
{
|
|
return m_pPolyline;
|
|
}
|
|
|
|
Adesk::Boolean CJoggedCameraJig::update()
|
|
{
|
|
double dw = CoreTools::PixelToWcs(10);
|
|
switch (m_nStep)
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
{
|
|
m_pPolyline->addVertexAt(0, m_ptStart.convert2d(AcGePlane::kXYPlane), .0, dw, dw);
|
|
m_pPolyline->addVertexAt(1, m_ptEnd.convert2d(AcGePlane::kXYPlane));
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
AcGePoint3d ptCloset;
|
|
m_pPolyline->addVertexAt(0, m_ptStart.convert2d(AcGePlane::kXYPlane), .0, dw, dw);
|
|
m_pPolyline->addVertexAt(1, m_ptEnd.convert2d(AcGePlane::kXYPlane));
|
|
m_pPolyline->addVertexAt(2, (m_ptEnd + m_vtEye).convert2d(AcGePlane::kXYPlane));
|
|
m_pPolyline->addVertexAt(3, (m_ptStart + m_vtEye).convert2d(AcGePlane::kXYPlane));
|
|
m_pPolyline->setClosed(Adesk::kTrue);
|
|
}
|
|
break;
|
|
case 3:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return Adesk::kTrue;
|
|
}
|
|
|
|
void CJoggedCameraJig::deleteSupportLine()
|
|
{
|
|
AcDbEntityPointer entLine(m_supportLineID, AcDb::kForWrite);
|
|
if (entLine.openStatus() == Acad::eOk)
|
|
entLine->erase();
|
|
}
|
|
#pragma endregion
|