[ARX程序]：求救：算法：已知.....

fastdev

已知两个AcDb2dPolyline线，求它们之间的最近距离；
在同一个平面上
请各位高手帮忙：）

e2002

如果有交点 , disttance_min = 0
如果不在平行的平面上 ,  不知道AcGe库中有没有提供函数?

fastdev

我已经知道了，结帐喽

XDSoft

最初由 fastdev 发布
[B]我已经知道了，结帐喽 [/B]

告诉下大家你的方法吧

fastdev

1：首先计算了2个AcDb2dPolyline实体（特点：每一个实体只有2个顶点，在此，我称之为单位实体）之间的最小距离，这是很容易可以做到的。
2：2个普通的AcDb2dPolyline实体（不限制顶点数目）之间的最小距离，肯定落在2个单位实体之间。
3：普通实体是由单位实体组成，用一个2重循环就可以求的最小值了；

XDSoft

最初由 fastdev 发布
[B]1：首先计算了2个AcDb2dPolyline实体（特点：每一个实体只有2个顶点，在此，我称之为单位实体）之间的最小距离，这是很容易可以做到的。
2：2个普通的AcDb2dPolyline实体（不限制顶点数目）之间的最小距离，肯定落?.. [/B]

谢谢，可以把代码贴出来吗？是否考虑了有弧线的段？

还有另外个方法求，直接使用ARX的几何库

AcGeCurve2d::closestPointTo(....),对于任意的AcGeCurve2d,3d实体都可以求得两条几何曲线的最近点。前提是需要你根据DB实体构造出AcGe实体来。

AcGePoint2d
closestPointTo(
    const AcGeCurve2d& curve,
    AcGePoint2d& pntOnOtherCrv,

    const AcGeTol& tol = AcGeContext::gTol) const;

curve        Input any 2D curve
pntOnOtherCrv        Output closest point on input curve to this curve
tol        Input tolerance used for interative methods

Finds the two closest points between this curve and the input curve. The return value of this function is the closest point on this curve. The closest point on the input curve is returned in the pntOnOtherCrv parameter.

fastdev

//已知2个AcDb2dPolyline线的id（可以任意个顶点），计算它们之间的最小值
int GetMinDistBy2Polyline(AcDbObjectId id1,AcDbObjectId id2,
double &dMinDist)
{
        int iRz;
        AcGeDoubleArray dDists;
        //得到该实体的点集
        AcGePoint3dArray pts1,pts2;
        AcGeDoubleArray dBlgs1,dBlgs2;
        iRz=GetCurveParam(id1, &pts1, &dBlgs1);
        if(iRz==0)
        {
                return 0;
        }
        iRz=GetCurveParam(id2, &pts2, &dBlgs2);
        if(iRz==0)
        {
                return 0;
        }
        //循环求实数集
        for (int i=0;i<pts1.length()-1;i++)
        {
                for(int j=0;j<pts2.length()-1;j++)
                {
                        double dMinD;
                        iRz=GetMinDistanceFor2Id(pts1,pts1[i+1],dBlgs1,
                                pts2[j],pts2[j+1],dBlgs2[j],dMinD);
                        if(iRz==0)
                        {
                                return 0;
                        }else
                        {
                                dDists.append(dMinD);
                        }
                }
        }
        //求实数集中的最小值
        double dMaxD;
        iRz=GetDoubleArrayMinMax(dDists,dMinDist,dMaxD);
        if(iRz==0)
        {
                return 0;
        }
        return 1;
}


//已知两个实体（可能是直线，可能是圆弧,规定只有2个顶点,我称之为单位实体），求它们最近距离
int GetMinDistanceFor2Id(AcGePoint3d g3Sp1,AcGePoint3d g3Ep1,double dBlg1,
                                                 AcGePoint3d g3Sp2,AcGePoint3d g3Ep2,double dBlg2,
                                                 double & dMinDist)
{
        int iRz;
        AcGeDoubleArray dDists;
        double dMaxDist;
        if(fabs(dBlg1)<1.e-5&&fabs(dBlg2)<1.e-5)//2个直线
        {
                AcGePoint3d g3MinSP1,g3MinSP2,g3MinEP1,g3MinEP2;
                //2个几何直线
                AcGeLineSeg3d geLS1(g3Sp1,g3Ep1),geLS2(g3Sp2,g3Ep2);
                //4个最近点，4个最近距离
                g3MinSP1=geLS2.closestPointTo(g3Sp1);
                dDists.append(g3MinSP1.distanceTo(g3Sp1));
                g3MinSP2=geLS1.closestPointTo(g3Sp2);
                dDists.append(g3MinSP2.distanceTo(g3Sp2));
                g3MinEP1=geLS2.closestPointTo(g3Ep1);
                dDists.append(g3MinEP1.distanceTo(g3Ep1));
                g3MinEP2=geLS1.closestPointTo(g3Ep2);
                dDists.append(g3MinEP2.distanceTo(g3Ep2));
                //求该实数集中的最小值
                iRz=GetDoubleArrayMinMax(dDists,dMinDist,dMaxDist);
                if(iRz==0)
                {
                        return 0;
                }
        }else if(fabs(dBlg1)<1.e-5&&fabs(dBlg2)>1.e-5)//直线和圆弧
        {
                iRz=GetMinDistForArcLineSeg(g3Sp2,g3Ep2,dBlg2,g3Sp1,g3Ep1,dMinDist);
                if(iRz==0)
                {
                        return 0;
                }
        }else if(fabs(dBlg1)>1.e-5&&fabs(dBlg2)<1.e-5)//圆弧和直线
        {
                iRz=GetMinDistForArcLineSeg(g3Sp1,g3Ep1,dBlg1,g3Sp2,g3Ep2,dMinDist);
                if(iRz==0)
                {
                        return 0;
                }
        }else if(fabs(dBlg1)>1.e-5&&fabs(dBlg2)>1.e-5)//圆弧和圆弧
        {
                iRz=GetMinDistFor2Arc(g3Sp1,g3Ep1,dBlg1,g3Sp2,g3Ep2,dBlg2,dMinDist);
                if(iRz==0)
                {
                        return 0;
                }
        }
        return 1;
}

//已知一个实数集，求其中的最小值和最大值
int GetDoubleArrayMinMax(AcGeDoubleArray dNums,
                                                 double &dMin,
                                                 double &dMax)
{
        if(dNums.length()==0)
        {
                return 0;
        }
        dMin=dMax=dNums[0];
        for(int i=0;i<dNums.length();i++)
        {
                if(dMin>dNums)
                {
                        dMin=dNums;
                }

                if(dMax<dNums)
                {
                        dMax=dNums;
                }
        }
        return 1;
}

//已知圆弧和直线，求其中最近距离
int GetMinDistForArcLineSeg(AcGePoint3d g3Sp1,AcGePoint3d g3Ep1,double dBlg,
                                                        AcGePoint3d g3Sp2,AcGePoint3d g3Ep2,double & dMinDist)
{
        int iRz;
        AcGeDoubleArray dDists;
        double dMaxDist;
        //4个最近点
        AcGePoint3d g3MinSP1,g3MinSP2,g3MinEP1,g3MinEP2;
        //几何圆弧和几何直线
        AcGeLineSeg3d geLS(g3Sp2,g3Ep2);
        AcGePoint3d g3ArcMidPt;
        iRz=GetArcMidPoint(g3Sp1,g3Ep1,dBlg,g3ArcMidPt);
        if(iRz==0)
        {
                return 0;
        }
        AcGeCircArc3d geArc(g3Sp1,g3ArcMidPt,g3Ep1);
        //4个最近点，4个最近距离
        g3MinSP1=geLS.closestPointTo(g3Sp1);
        dDists.append(g3MinSP1.distanceTo(g3Sp1));
        g3MinSP2=geArc.closestPointTo(g3Sp2);
        dDists.append(g3MinSP2.distanceTo(g3Sp2));
        g3MinEP1=geLS.closestPointTo(g3Ep1);
        dDists.append(g3MinEP1.distanceTo(g3Ep1));
        g3MinEP2=geArc.closestPointTo(g3Ep2);
        dDists.append(g3MinEP2.distanceTo(g3Ep2));
        //求圆心到线段的最近距离
        AcGePoint3d g3MinCp;
        //求圆弧圆心和半径
        fast_arc ark(g3Sp1,g3Ep1,dBlg);
        AcGePoint3d g3Cp;
        double dRad;
        g3Cp=ark.fast_arc_getcenPoint();
        dRad=ark.fast_arc_getradius();
        g3MinCp=geLS.closestPointTo(g3Cp);
        AcGeLineSeg3d g3LineSeg(g3Cp,g3MinCp);//
        int intn;
    AcGePoint3d p1,p2;
        int iRz1=0;
        if(iRz1=geArc.intersectWith(g3LineSeg,intn,p1,p2))
        {
                dDists.append(g3MinCp.distanceTo(g3Cp)-dRad);
        }
       
        //求该实数集中的最小值
        iRz=GetDoubleArrayMinMax(dDists,dMinDist,dMaxDist);
        if(iRz==0)
        {
                return 0;
        }
        return 1;
}


//已知圆弧起点和终点和突起值，求圆弧中点
int GetArcMidPoint(AcGePoint3d g3Sp,AcGePoint3d g3Ep,double dBlg,
                                   AcGePoint3d &g3ArcMidPt)
{
        int iRz=0;
        //求圆弧圆心和半径
        fast_arc ark(g3Sp,g3Ep,dBlg);
        AcGePoint3d g3Cp;
        double dRad;
        g3Cp=ark.fast_arc_getcenPoint();
        dRad=ark.fast_arc_getradius();
        if(fabs((fabs(dBlg)-1))<1.e-5)//是半园
        {
                AcGeVector3d v3Sp=g3Sp-g3Cp;
                AcGeVector3d v3k(0.0,0.0,1.0);
                if(dBlg>0)//逆时针
                {
                        v3Sp.rotateBy(3.1415926/2,v3k);
                }else//顺时针
                {
                        v3Sp.rotateBy(3.1415926/2,-v3k);
                }
                g3ArcMidPt=g3Cp+v3Sp;
        }else
        {
                //求弦中点
                double dAng;
                AcGeVector3d v3Sp,v3Ep;
                AcGeVector3d v3K(0.0,0.0,1.0);
                v3Sp=g3Sp-g3Cp;
                v3Ep=g3Ep-g3Cp;
                if(dBlg>0)//逆时针
                {
                        dAng=v3Sp.angleTo(v3Ep,v3K);
                        v3Sp.rotateBy(dAng/2,v3K);
                }else//顺时针
                {
                        dAng=v3Sp.angleTo(v3Ep,-v3K);
                        v3Sp.rotateBy(dAng/2,-v3K);
                }
                g3ArcMidPt=g3Cp+v3Sp;
        }
       
        return 1;
}


//已知2圆弧，求其中最近距离
int GetMinDistFor2Arc(AcGePoint3d g3Sp1,AcGePoint3d g3Ep1,double dBlg1,
                                          AcGePoint3d g3Sp2,AcGePoint3d g3Ep2,double dBlg2,
                                          double & dMinDist)
{
        int iRz;
        AcGePoint3d g3ArcMidPt1,g3ArcMidPt2;
        iRz=GetArcMidPoint( g3Sp1, g3Ep1, dBlg1,g3ArcMidPt1);
        if(iRz==0)
        {
                return 0;
        }
        iRz=GetArcMidPoint( g3Sp2, g3Ep2, dBlg2,g3ArcMidPt2);
        if(iRz==0)
        {
                return 0;
        }
        //求2个圆心
        AcGePoint3d g3Cp1,g3Cp2;
        double dRad1,dRad2;
        fast_arc ark1(g3Sp1,g3Ep1,dBlg1);
        g3Cp1=ark1.fast_arc_getcenPoint();
        dRad1=ark1.fast_arc_getradius();
        fast_arc ark2(g3Sp2,g3Ep2,dBlg2);
        g3Cp2=ark2.fast_arc_getcenPoint();
        dRad2=ark2.fast_arc_getradius();
        //构造几何圆弧，几何线段（圆心线段）
        AcGeCircArc3d  geArc1(g3Sp1,g3ArcMidPt1,g3Ep1);
        AcGeCircArc3d  geArc2(g3Sp2,g3ArcMidPt2,g3Ep2);
        AcGeLineSeg3d geLineSeg(g3Cp1,g3Cp2);
        int intn;
        AcGePoint3d p1,p2;
        int intn1;
        AcGePoint3d pp1,pp2;
        int iRz1,iRz2;
        if((iRz2=geArc2.intersectWith(geLineSeg,intn1,pp1,pp2))&&
                (iRz1=geArc1.intersectWith(geLineSeg,intn,p1,p2)))
        {
                dMinDist=g3Cp1.distanceTo(g3Cp2)-(dRad1+dRad2);
        }else
        {
                AcGeDoubleArray dDists;
                //4个最近点
                AcGePoint3d g3MinSP1,g3MinSP2,g3MinEP1,g3MinEP2;
                //4个最近点，4个最近距离
                g3MinSP1=geArc2.closestPointTo(g3Sp1);
                dDists.append(g3MinSP1.distanceTo(g3Sp1));
                g3MinSP2=geArc1.closestPointTo(g3Sp2);
                dDists.append(g3MinSP2.distanceTo(g3Sp2));
                g3MinEP1=geArc2.closestPointTo(g3Ep1);
                dDists.append(g3MinEP1.distanceTo(g3Ep1));
                g3MinEP2=geArc1.closestPointTo(g3Ep2);
                dDists.append(g3MinEP2.distanceTo(g3Ep2));
                //求该实数集中的最小值
                double dMaxDist;
                iRz=GetDoubleArrayMinMax(dDists,dMinDist,dMaxDist);
                if(iRz==0)
                {
                        return 0;
                }
        }
        return 1;
}

MicroStation迷

各位ARX编程高手：
   我真佩服您们的数学能力，居然能自己编写出求两元素间最短距离的函数。我是MicroStation的忠实用户，当初由ACAD转向MS时就是看中了MS的二次开发能力，在MS的MDL中有一函数
      mdlMinDist_betweenElms (...)
它可以求得任何两元素间的最短距离，不用您关心这两个元素是何种类型（B-样条元素都没关系），也不用管它们是2D还是3D。多么强大的功能啊！

    由于我是ARX新手，在ARX中编程真是举步维艰。现有一问题求教：如何把一Block显示在一对话框中？
（这在MS的MDL中也是轻而易举，用mdlElmdscr_displayToWindow 即可）

fastdev

首先把块block导出成位图，然后显示在对话框中

e2002

最初由 fastdev 发布
[B]首先把块block导出成位图，然后显示在对话框中 [/B]

肯定不需要如此，我见过博超的EES(Power)电气软件和LayerManager pro ,都能在对话框中显示和浏览dwg的。

XDSoft

1. 
   
2. [FONT=courier new]
   
3. Include File
   
4. 
   
5. dbmain.h
   
6. 
   
7. Adesk::Boolean
   
8. 
   
9. acdbDisplayPreviewFromDwg(
   
10.     const char *pszDwgfilename,
    
11. 
    
12.     void* pPreviewWnd);
    
13. 
    
14. pszDwgfilename        Input path\filename string
    
15. pPreviewWnd        Input HWND for window within which to display preview
    
16. 
    
17. This function obtains the preview image (if any) of the drawing specified by pszDwgfilename and displays it in the window identified by the HWND argument pPreviewWnd.
    
18. The image size varies up to a maximum size no larger than 256 x 188 pixels. If the pPreviewWnd window is larger than the image, then the image will be stretched to fit. But, if the window is smaller than the image, the image will not be adjusted and will spill out beyond the window's borders.
    
19. 
    
20. Returns Adesk::kTrue if successful, otherwise it returns Adesk::kFalse.[/FONT]

复制代码