static bool CheackTubeLenth(AcDbObjectId& objId)
{
objId = ArxUtilHelper::SelectObject( _T( "请选择一条瓦斯管路:" ) );
if( objId.isNull() ) return false;
if( !ArxUtilHelper::IsEqualType( _T( "GasTube" ), objId ) ) return false;
AcTransaction *pTrans = actrTransactionManager->startTransaction();
if ( 0 == pTrans ) return false;
AcDbObject *pObj;
if (Acad::eOk != pTrans->getObject(pObj,objId,AcDb::kForRead)) return false;
GasTube *pGasTube = GasTube::cast(pObj);
if ( 0 == pGasTube)
{
actrTransactionManager->abortTransaction();
return false;
}
AcGePoint3d spt,ept;
pGasTube->getSEPoint(spt,ept);
//double angle = pGasTube->getAngle();
actrTransactionManager->endTransaction();
AcGeVector3d v = ept - spt;
double tubeLenth = v.length();
return true;
}
Acad::ErrorStatus
ArxDbgDbEntity::setNormal(const AcGeVector3d& nvec)
{
if (nvec.isZeroLength()) {
ASSERT(0);
return Acad::eInvalidInput;
}
if (nvec != m_zDir) {
assertWriteEnabled();
AcGeVector3d txdir, tydir;
AcGeVector3d txdiro, tydiro;
ArxDbgUtils::getEcsXAxis(nvec, txdir); // get AutoCAD's arbitrary X-Axis for this normal
ArxDbgUtils::getEcsXAxis(m_zDir, txdiro); // get AutoCAD's arbitrary X-Axis for this normal
tydir = nvec.crossProduct(txdir);
tydir.normalize();
tydiro = m_zDir.crossProduct(txdiro);
tydiro.normalize();
AcGeMatrix3d mat;
mat.setToAlignCoordSys(m_origin, txdiro, tydiro, m_zDir,
m_origin, txdir, tydir, nvec);
m_xDir.transformBy(mat);
m_zDir.transformBy(mat);
m_origin.transformBy(mat);
}
return Acad::eOk;
}
void DrawCmd::DrawWindLibrary( void )
{
AcDbObjectId objId = ArxUtilHelper::SelectObject( _T( "请选择一条巷道:" ) );
if( objId.isNull() ) return;
if( !ArxUtilHelper::IsEqualType( _T( "LinkedGE" ), objId ) ) return;
AcGePoint3d pt,insertPt;
double angle;
if( !ArxUtilHelper::PromptPt( _T( "\n请指定风库的插入点坐标:" ), pt ) ) return;
if( !GetClosePtAndAngle( objId, pt, angle ) ) return;
AcGeVector3d v = AcGeVector3d(AcGeVector3d::kXAxis);
v.rotateBy(angle - PI/2,AcGeVector3d::kZAxis);
v.normalize();
insertPt = pt + v * 60;
WindLibrary* pWindLib = new WindLibrary( insertPt, angle );
if( pWindLib == 0 ) return;
pWindLib->setRelatedGE( objId ); // 关联巷道
// 初始化并提交到数据库
if( !ArxUtilHelper::PostToModelSpace( pWindLib ) ) delete pWindLib;
}
void SingleTunnelDraw::extendByLength( double length )
{
AcGeVector3d v = m_endPt - m_startPt;
v.normalize();
m_endPt = m_endPt + v * length; // 修改末点坐标
}
void
ArxDbgUtils::getEcsToWcsMatrix(const AcGePoint3d& origin,
const AcGeVector3d& zAxis, AcGeMatrix3d& mat)
{
const double kArbBound = 0.015625; // 1/64th
// short circuit if in WCS already
if (zAxis == AcGeVector3d::kZAxis) {
mat.setToIdentity();
return;
}
AcGeVector3d xAxis, yAxis;
ASSERT(zAxis.isUnitLength());
if ((fabs(zAxis.x) < kArbBound) && (fabs(zAxis.y) < kArbBound))
xAxis = AcGeVector3d::kYAxis.crossProduct(zAxis);
else
xAxis = AcGeVector3d::kZAxis.crossProduct(zAxis);
xAxis.normalize();
yAxis = zAxis.crossProduct(xAxis);
yAxis.normalize();
mat.setCoordSystem(AcGePoint3d::kOrigin, xAxis, yAxis, zAxis);
}
double LinkedGE::getAngle() const
{
assertReadEnabled();
AcGeVector3d v = m_endPt - m_startPt;
return v.angleTo( AcGeVector3d::kXAxis, -AcGeVector3d::kZAxis );
}
AcGeVector3d PDEcone::getFaceVect() const
{
assertReadEnabled();
AcGeVector3d centerVect = m_ptEnd - m_ptStart;
AcGeVector3d tmpV1 = centerVect.crossProduct(m_vect);
return m_vect.crossProduct(tmpV1).normal();
}
void DrawArc( AcGiWorldDraw* mode, const AcGePoint3d& spt, const AcGePoint3d& pt, const AcGePoint3d& ept, bool fill )
{
AcGiSubEntityTraits& traits = mode->subEntityTraits();
AcGiFillType ft = traits.fillType();
traits.setFillType( fill ? kAcGiFillAlways : kAcGiFillNever );
AcGeCircArc3d arc( spt, pt, ept );
AcGePoint3d cnt = arc.center();
double radius = arc.radius();
AcGeVector3d sv = spt - cnt;
AcGeVector3d ev = ept - cnt;
double sa = sv.angleTo( AcGeVector3d::kXAxis, -AcGeVector3d::kZAxis );
double ea = ev.angleTo( AcGeVector3d::kXAxis, -AcGeVector3d::kZAxis );
if( arc.normal().z > 0 )
{
AcDbArc arcEnt( cnt, radius, sa, ea );
arcEnt.worldDraw( mode );
}
else
{
AcDbArc arcEnt( cnt, radius, ea, sa );
arcEnt.worldDraw( mode );
}
// 恢复属性
traits.setFillType( ft );
}
AcGeVector3d DoubleLine::getEndPointInExtendAngle() const
{
AcGeVector3d v = m_endPt - m_startPt;
v.rotateBy( PI, AcGeVector3d::kZAxis ); // 旋转180度
return v;
}
void DoubleLine::update()
{
AcGeVector3d v = m_endPt - m_startPt;
double angle = v.angleTo( AcGeVector3d::kXAxis, -AcGeVector3d::kZAxis );
caclLeftPoint( angle, m_leftStartPt, m_rightStartPt );
caclRightPoint( angle, m_leftEndPt, m_rightEndPt );
}
void
ArxDbgDbEntity::getEcs(AcGeMatrix3d& retVal) const
{
AcGeVector3d yDir = m_zDir.crossProduct(m_xDir);
retVal.setCoordSystem(m_origin, m_xDir, yDir.normal(), m_zDir);
}
void
createSmiley()
{
AcGePoint3d cen;
struct resbuf rbFrom, rbTo;
ads_getpoint( NULL, "\nCenter point: ", asDblArray( cen ));
rbFrom.restype = RTSHORT;
rbFrom.resval.rint = 1; // from UCS
rbTo.restype = RTSHORT;
rbTo.resval.rint = 0; // to WCS
ads_trans( asDblArray( cen ), &rbFrom, &rbTo, Adesk::kFalse, asDblArray( cen ));
AcGeVector3d x = acdbHostApplicationServices()->workingDatabase()->ucsxdir();
AcGeVector3d y = acdbHostApplicationServices()->workingDatabase()->ucsydir();
AcGeVector3d normalVec = x.crossProduct( y );
normalVec.normalize();
SmileyJig jig( cen, normalVec );
jig.start();
}
AcGePoint3d DoubleTTunnelDraw::caclHeadPoint()
{
AcGeVector3d v = m_endPt - m_startPt;
v.normalize(); // 单位方向向量
v = v * m_distance;
return m_endPt + v;
}
void GasPumpGEDraw::extendByLength( double length )
{
AcGeVector3d v = m_endPt - m_startPt;
v.normalize();
m_endPt = m_endPt + v * length; // 更新末点坐标
update();
}
void DoubleTunnelDraw::extendByLength( double length )
{
AcGeVector3d v = m_endPt - m_startPt;
v.normalize();
m_endPt = m_endPt + v * length; // 更新末点坐标
update(); // 更新其它参数
}
AcGePoint3d PDEcone::getEndPtOrthoInStartPtPlane()const
{
assertReadEnabled();
AcGeVector3d centerVect = m_ptEnd - m_ptStart;
AcGeVector3d tmpV = centerVect.crossProduct(m_vect);
tmpV = m_vect.crossProduct(tmpV);
return m_ptEnd.orthoProject(AcGePlane(m_ptStart, tmpV));
}
double
ArxDbgDbEntity::rotation() const
{
assertReadEnabled();
AcGeVector3d xAxis;
ArxDbgUtils::getEcsXAxis(m_zDir, xAxis); // get AutoCAD's arbitrary X-Axis
return xAxis.angleTo(m_xDir, m_zDir);
}
Acad::ErrorStatus
rx_makeArc(const AcGePoint3d pt1,
const AcGePoint3d pt2,
double bulge,
const AcGeVector3d entNorm,
AcGeCircArc3d& arc)
{
Acad::ErrorStatus es = Acad::eOk;
// The points that are coming in are in ECS. These are actually
// 2d points, may be with an elevation in the z coord.
//
// Therefore, let's create a 2d arc from these values and transform
// the relevant data of the arc for creating a 3d arc.
AcGeCircArc2d arc2d;
AcGePoint2d p1, p2;
assert(fabs(pt1[Z] - pt2[Z]) < 1.0e-10);
p1.set(pt1[X], pt1[Y]); p2.set(pt2[X], pt2[Y]);
arc2d.set(p1, p2, bulge);
AcGePoint3d center((arc2d.center())[X], (arc2d.center())[Y], pt1[Z]);
AcGePoint3d startPnt((arc2d.startPoint())[X],
(arc2d.startPoint())[Y], pt1[Z]);
AcGePoint3d endPnt((arc2d.endPoint())[X], (arc2d.endPoint())[Y], pt1[Z]);
// If the arc is CW, flip the normal.
AcGeVector3d norm;
if (arc2d.startAng() > arc2d.endAng()) {
norm.set(0, 0, -1);
} else {
norm.set(0, 0, 1);
}
double incAng = fabs(arc2d.endAng() - arc2d.startAng());
// Transform all the data to WCS.
acdbEcs2Wcs(asDblArray(center), asDblArray(center), asDblArray(entNorm),
Adesk::kFalse);
acdbEcs2Wcs(asDblArray(startPnt), asDblArray(startPnt), asDblArray(entNorm),
Adesk::kFalse);
acdbEcs2Wcs(asDblArray(endPnt), asDblArray(endPnt), asDblArray(entNorm),
Adesk::kFalse);
acdbEcs2Wcs(asDblArray(norm), asDblArray(norm), asDblArray(entNorm),
Adesk::kTrue);
arc.set(center, norm, norm.perpVector(),
(startPnt - center).length(), 0, incAng);
return es;
}
static void AddDirection( const AcDbObjectId& objId, const AcGePoint3d& spt, const AcGePoint3d& ept )
{
AcGeVector3d v = ept - spt;
if( v.length() < 100 ) return;
double angle = v.angleTo( AcGeVector3d::kXAxis, -AcGeVector3d::kZAxis );
WindDirection* pDir = new WindDirection( spt + v * 0.5, angle ); // 巷道中心位置
pDir->setRelatedGE( objId );
ArxUtilHelper::PostToModelSpace( pDir );
}
//===================================================================
double userToLocalAngle(const AcGeVector3d& normal,
const AcGeVector3d& ucsXdir)
{
AcGeMatrix3d wcsToLcs = AcGeMatrix3d::worldToPlane(normal);
AcGeVector3d xDir = ucsXdir;
xDir.transformBy(wcsToLcs);
double angle = atan2(xDir.y, xDir.x);
return angle;
//return fixAngle(angle);
}
AcGeVector3d DoubleArcTunnelDraw::getEndPointInExtendAngle() const
{
AcGeCircArc3d arc( m_startPt, m_thirdPt, m_endPt );
AcGePoint3d cenPt = arc.center();
AcGeVector3d v = m_endPt - cenPt;
AcGeVector3d v2 = m_startPt - m_endPt;
AcGeVector3d v3 = v.crossProduct( v2 );
int c = ( v3.z > 0 ? 1 : -1 );
v.rotateBy( c * PI / 2, AcGeVector3d::kZAxis );
return v;
}
void GasPumpGEDraw::readPropertyDataFromGE( const AcStringArray& values )
{
CString strLenth;
strLenth.Format(_T("%s"),values[0].kACharPtr());
m_radius = _tstof(strLenth);
if( 0 >= m_radius ) m_radius = 3;
AcGeVector3d v = m_endPt - m_startPt;
v.normalize();
m_endPt = m_startPt + v * m_radius;
}
void DoubleLine::caclEndPoint( AcGePoint3d& endPt1, AcGePoint3d& endPt2 )
{
AcGeVector3d v = m_ept - m_spt;
v.normalize();
v.rotateBy( PI * 0.5, AcGeVector3d::kZAxis );
endPt1 = m_ept + v * m_width * 0.5;
v.rotateBy( PI, AcGeVector3d::kZAxis );
endPt2 = m_ept + v * m_width * 0.5;
}
void DoubleTunnelDraw::caclEndPoint( AcGePoint3d& endPt1, AcGePoint3d& endPt2 )
{
AcGeVector3d v = m_endPt - m_startPt;
v.normalize();
v.rotateBy( PI * 0.5, AcGeVector3d::kZAxis );
endPt1 = m_endPt + v * m_width * 0.5;
v.rotateBy( PI, AcGeVector3d::kZAxis );
endPt2 = m_endPt + v * m_width * 0.5;
}
Acad::ErrorStatus
ArxDbgDbEntity::setRotation(double rot)
{
assertWriteEnabled();
AcGeVector3d xAxis;
ArxDbgUtils::getEcsXAxis(m_zDir, xAxis); // get AutoCAD's arbitrary X-Axis
m_xDir = xAxis.rotateBy(rot, m_zDir); // factor in rotation angle
m_xDir.normalize();
return Acad::eOk;
}
static void EffectRanDrawed(AcDbObjectId ttunel)
{
AcTransaction *pTrans = actrTransactionManager->startTransaction();
if ( 0 == pTrans ) return;
AcDbObject *pObj;
if (Acad::eOk != pTrans->getObject(pObj,ttunel,AcDb::kForRead)) return;
TTunnel *pTTunnel = TTunnel::cast(pObj);
if ( 0 == pTTunnel)
{
actrTransactionManager->abortTransaction();
return;
}
AcGePoint3d spt,ept;
pTTunnel->getSEPoint(spt,ept);
double angle = pTTunnel->getAngle();
actrTransactionManager->endTransaction();
AcDbObjectIdArray eTags;
DrawHelper::GetTagGEById2( ttunel, _T( "EffectRanTagGE" ), eTags );
if (!eTags.isEmpty())
{
ArxEntityHelper::EraseObjects( eTags, true );
}
AcGeVector3d v = ept - spt;
double diatance = v.length();
CString area,way;
if(!DataHelper::GetPropertyData(ttunel,_T("断面面积"),area)) return;
if(!DataHelper::GetPropertyData(ttunel,_T("通风方法"),way)) return;
double minDistan,maxDistan;
if(way.IsEmpty()) return;
if(area.IsEmpty()) return;
if (_T("压入式") == way || _T("长压短抽") == way)
{
minDistan = 4*sqrtf(_tstof(area));
maxDistan = 5*sqrtf(_tstof(area));
}
else
{
minDistan = 0;
maxDistan = 1.5*sqrtf(_tstof(area));
}
EffectRanTagGE *pTag = new EffectRanTagGE(ept,angle,minDistan,maxDistan,diatance*0.1);
if (0 == pTag) return;
pTag->setRelatedGE(ttunel);
if( !ArxUtilHelper::PostToModelSpace( pTag ) ) delete pTag;
}
// This function uses the AcEdJig mechanism to create and
// drag an ellipse entity. The creation criteria are
// slightly different from the AutoCAD command. In this
// case, the user selects an ellipse center point and then,
// drags to visually select the major and minor axes
// lengths. This sample is somewhat limited; if the
// minor axis ends up longer than the major axis, then the
// ellipse will just be round because the radius ratio
// cannot be greater than 1.0.
//
void
createEllipse()
{
// First, have the user select the ellipse center point.
// We don't use the jig for this because there is
// nothing to see yet.
//
AcGePoint3d tempPt;
struct resbuf rbFrom, rbTo;
acedGetPoint(NULL, _T("\nEllipse center point: "),
asDblArray(tempPt));
// The point we just got is in UCS coordinates, but
// AcDbEllipse works in WCS, so convert the point.
//
rbFrom.restype = RTSHORT;
rbFrom.resval.rint = 1; // from UCS
rbTo.restype = RTSHORT;
rbTo.resval.rint = 0; // to WCS
acedTrans(asDblArray(tempPt), &rbFrom, &rbTo,
Adesk::kFalse, asDblArray(tempPt));
// Now you need to get the current UCS z-Axis to be used
// as the normal vector for the ellipse.
//
AcGeVector3d x = acdbHostApplicationServices()->workingDatabase()
->ucsxdir();
AcGeVector3d y = acdbHostApplicationServices()->workingDatabase()
->ucsydir();
AcGeVector3d normalVec = x.crossProduct(y);
normalVec.normalize();
// Create an AsdkEllipseJig object passing in the
// center point just selected by the user and the normal
// vector just calculated.
//
AsdkEllipseJig *pJig
= new AsdkEllipseJig(tempPt, normalVec);
// Now start up the jig to interactively get the major
// and minor axes lengths.
//
pJig->doIt();
// Now delete the jig object, since it is no longer needed.
//
delete pJig;
}
void DoubleArcTunnelDraw::extendByLength( double length )
{
AcGeCircArc3d arc( m_startPt, m_thirdPt, m_endPt );
AcGePoint3d cenPt = arc.center();
double radius = arc.radius();
AcGeVector3d v = m_endPt - cenPt;
AcGeVector3d v2 = m_startPt - m_endPt;
AcGeVector3d v3 = v.crossProduct( v2 );
int c = ( v3.z > 0 ? 1 : -1 );
v.rotateBy( c * length / radius, AcGeVector3d::kZAxis );
m_endPt = cenPt + v; // 修改圆弧的末点
}
void Additional_Class::RotateEnt( AcDbObjectId EntID, double RotateAng, AcGePoint3d InpPt)
{
AcDbEntity *pEnt_Temp;
if (acdbOpenAcDbEntity(pEnt_Temp, EntID, AcDb::kForWrite) != Acad::eOk)
{
acutPrintf(_T("\nOPEN ERROR"));
return;
}
AcGeMatrix3d tt;
AcGeVector3d zAxis;
zAxis.set(0,0,1);
tt.setToRotation(RotateAng, zAxis, InpPt);
pEnt_Temp->transformBy(tt);
pEnt_Temp->close();
}
AcGeVector3d
ArxDbgUtils::wcsToUcs(const AcGeVector3d& vec)
{
AcDbDatabase* db = acdbHostApplicationServices()->workingDatabase();
ASSERT(db != NULL);
AcGeMatrix3d m;
getWcsToUcsMatrix(m, db);
AcGeVector3d newv = vec;
newv.transformBy(m);
return newv;
}