[ARX函数]：AcGeInterval

xyy2005

#include <aced.h>
#include <adslib.h>
#include <geassign.h>   // asDblArray
#include <gecone.h>
#include <gessint.h>
#include <dbxutil.h>     // acdbWcs2Ucs



void dcgMdtDrawInfo(const AcGeCurve3d* crv,short color)
{
        // ads_printf("\nCurve is a %d", crv->type() );
        AcGeInterval iv; double lb,ub; double nominalRange = 10.0;
        crv->getInterval(iv);
        if( iv.isUnBounded() )
        {
                ads_printf("\nCurve is unbounded");  
                lb = -(nominalRange / 2.0);  
                ub = nominalRange / 2.0;
        }
        else
        {  
                iv.getBounds(lb,ub);
                if( iv.isBounded() )
                {  
                        ads_printf("\nCurve is bounded");
                }
                else if( iv.isBoundedBelow() )
                {   
                        ads_printf("\nCurve is unbounded above");  
                        ub = lb + nominalRange;
                }
                else
                {  
                        ads_printf("\nCurve is unbounded below");
                        lb = ub - nominalRange;
                }  
        }  
        ads_printf("\nBounds of curve [lower,upper] = [%.3lf,%.3lf]",lb,ub);
        AcGePoint3dArray pts;
        AcGeDoubleArray params;  
        crv->getSamplePoints( lb, ub, 0.01, pts, params );
        int nPts = pts.length();
        AcGePoint3d start = pts[0];
        acdbWcs2Ucs(asDblArray(start),asDblArray(start),Adesk::kFalse);
        ads_printf("\nGot %d sample points",nPts);
        for( int i=1;i<nPts; i++ )
        {  
                AcGePoint3d end = pts;  
                ads_printf("\nSamplePoint [%d] = (%.3lf,%.3lf,%.3lf)",i,pts.x,pts.y,pts.z);
                acdbWcs2Ucs(asDblArray(end),asDblArray(end),Adesk::kFalse);
                ads_grdraw(asDblArray(start),asDblArray(end),color,0);
                start = end;
        }
}


void dcgMdtDrawInfo(const AcGeSurface* srf,int color)
{
        AcGeInterval vi,ui;
        double vlb,vub,ulb,uub; srf->getEnvelope(ui,vi);
        vi.getBounds(vlb,vub); ui.getBounds(ulb,uub);
        double vstep = (vub-vlb) / 4;
        AcGePoint3d p1,p2;
        double ustep = (uub - ulb) / 100;
        AcGePoint2d param(ulb,vlb);
        p1 = srf->evalPoint(param);
        while(param.y < vub)
        {
                param.x = ulb;
                p1 = srf->evalPoint(param);
                acdbWcs2Ucs(asDblArray(p1),asDblArray(p1),Adesk::kFalse);  
                while(param.x < uub)
                {
                        param.x += ustep;  
                        p2 = srf->evalPoint(param);
                        acdbWcs2Ucs(asDblArray(p2),asDblArray(p2),Adesk::kFalse);   
                        ads_grdraw(asDblArray(p1),asDblArray(p2),color,0);
                        p1 = p2;
                }
                param.y += vstep;
        }
        param.y = vub;
        param.x = ulb;
        p1 = srf->evalPoint(param);
        while(param.x < uub)
        {
                param.x += ustep;
                p2 = srf->evalPoint(param);
                acdbWcs2Ucs(asDblArray(p2),asDblArray(p2),Adesk::kFalse);
                ads_grdraw(asDblArray(p1),asDblArray(p2),color,0);
                p1 = p2;
        }
        param.y += vstep;
        vstep = (vub-vlb) / 100;
        ustep = (uub - ulb) / 4;
        param.set(ulb,vlb);
        while(param.x < uub)
        {  
                param.y = vlb;
                p1 = srf->evalPoint(param);  
                while(param.y < vub)  
                {
                        param.y += vstep;
                        p2 = srf->evalPoint(param);
                        acdbWcs2Ucs(asDblArray(p2),asDblArray(p2),Adesk::kFalse);
                        ads_grdraw(asDblArray(p1),asDblArray(p2),color,0);
                        p1 = p2;
                }
                param.x += ustep;  
        }
        param.x = uub;
        param.y = vlb;
        p1 = srf->evalPoint(param);
        while(param.y < vub)
        {  
                param.y += vstep;  
                p2 = srf->evalPoint(param);
                acdbWcs2Ucs(asDblArray(p2),asDblArray(p2),Adesk::kFalse);
                ads_grdraw(asDblArray(p1),asDblArray(p2),color,0);
                p1 = p2;
        }
        param.x += ustep;
}   


void printInfo(AcGe::ssiConfig config)
{
        switch(config)
        {
        case AcGe::kXOut :
                ads_printf("\n      kXOut : Curve neighborhood is outside the surface.");
                break;
        case AcGe::kXIn:  ads_printf("\n      kXIn  : Curve neighborhood is inside the surface.");
                break;
        case AcGe::kXTanOut :  ads_printf("\n      kXTanOut : Curve neighborhood is outside the surface.");   
                break;
        case AcGe::kXTanIn :  ads_printf("\n      kXTanIn  : Curve neighborhood is inside the surface.");
                break;
        default :
                ads_printf("\n      unknown ssiConfig %d",config);
                break;
        }
}

void getIntConfigs(const AcGeSurfSurfInt& surfInt)
{
        AcGeIntersectError err;
        int numResult = surfInt.numResults(err);
        int dim;
        AcGe::ssiConfig surf1Left,surf1Right,surf2Left,surf2Right;
        AcGe::ssiType intType;
        ads_printf("\n Configs of intersection : ");
        for(int i=0;i<numResult;i++)
        {  
                surfInt.getIntConfigs(i,surf1Left,surf1Right,surf2Left,surf2Right,intType,dim,err);  
                ads_printf("\n   Intersection %d",i);
                ads_printf("\n   surf1Left : ");  printInfo(surf1Left);
                ads_printf("\n   dim = %d",dim);
        }
}


int testfun()
{
        double cosineAngle =  0.7071067811865;
        double sineAngle = - 0.7071067811865;
        AcGePoint3d origin(0,0,0);
        double radius = 2;
        AcGeVector3d axis(0,0,1);  
        AcGeIntersectError err;
        Boolean isExternal = kTrue;  // Draw the cone with ads_grdraw for visualization
        AcGeCone geCone(cosineAngle,sineAngle,origin,radius,axis);
        dcgMdtDrawInfo(&geCone,3);  
        ads_printf("\nFirst test case : "); // take the same cone and intersect it with a xz-plane
        AcGeCone hCone(cosineAngle,sineAngle,origin,radius,axis);
        AcGePlane hPlane(AcGePoint3d(0,0,0),AcGeVector3d(0,0,1));
        AcGeSurfSurfInt surfSurfInt(hCone,hPlane);
        getIntConfigs(surfSurfInt);
        int numInters = surfSurfInt.numResults(err);
        ads_printf("\nGot %d intersections : err = %d",numInters,err);
        AcGeCurve3d* pIntersCurve;
        for(int k=0;k<numInters;k++)
        {
                pIntersCurve = surfSurfInt.intCurve(k,isExternal,err);
                ads_printf("\nsurfSurfInt: err = %d",numInters,err);
                if(pIntersCurve)  
                        dcgMdtDrawInfo(pIntersCurve,1);
        }  // intersect the cone with another plane
        ads_printf("\n\nSecond test case : ");
        AcGePlane hPlane2(AcGePoint3d(0,0,1.0),AcGeVector3d(0.1, 0, 1.0));
        AcGeSurfSurfInt surfSurfInt2(hCone,hPlane2);
        getIntConfigs(surfSurfInt2);  
        numInters = surfSurfInt2.numResults(err);
        ads_printf("\nGot %d intersections : err = %d",numInters,err);
        for(k=0;k<numInters;k++)
        {
                pIntersCurve = surfSurfInt2.intCurve(k,isExternal,err);  
                ads_printf("\nsurfSurfInt: err = %d",numInters,err);
                if(pIntersCurve)   
                        dcgMdtDrawInfo(pIntersCurve,1);
        }
        // intersect the cone with a plane on the cones tip
        ads_printf("\n\nThird test case : ");
        AcGePlane hPlane3(AcGePoint3d(0,0,2),AcGeVector3d(0,0,1));
        AcGeSurfSurfInt surfSurfInt3(hCone,hPlane3);
        getIntConfigs(surfSurfInt3);  
        numInters = surfSurfInt3.numResults(err);
        ads_printf("\nGot %d intersections : err = %d",numInters,err);
        AcGePoint3d isPoint;
        for(k=0;k<numInters;k++)
        {
                isPoint = surfSurfInt3.intPoint(k,err);  
                ads_printf("\nIntersection point at (%.3lf,%.3lf,%.3lf)",isPoint.x,isPoint.y,isPoint.z);
        }
        return 1;
}

革天明

改了_T来支持Unicode，但实际上这些代码不能正常运行

static void dcgMdtDrawInfo(const AcGeCurve3d* crv,short color)
        {
                // ads_printf("\nCurve is a %d", crv->type() );
                AcGeInterval iv; double lb,ub; double nominalRange = 10.0;
                crv->getInterval(iv);
                if( iv.isUnBounded() )
                {
                        ads_printf(_T("\nCurve is unbounded"));  
                        lb = -(nominalRange / 2.0);  
                        ub = nominalRange / 2.0;
                }
                else
                {  
                        iv.getBounds(lb,ub);
                        if( iv.isBounded() )
                        {  
                                ads_printf(_T("\nCurve is bounded"));
                        }
                        else if( iv.isBoundedBelow() )
                        {   
                                ads_printf(_T("\nCurve is unbounded above"));  
                                ub = lb + nominalRange;
                        }
                        else
                        {  
                                ads_printf(_T("\nCurve is unbounded below"));
                                lb = ub - nominalRange;
                        }  
                }  
                ads_printf(_T("\nBounds of curve [lower,upper] = [%.3lf,%.3lf]"),lb,ub);
                AcGePoint3dArray pts;
                AcGeDoubleArray params;  
                crv->getSamplePoints( lb, ub, 0.01, pts, params );
                int nPts = pts.length();
                AcGePoint3d start = pts[0];
                acdbWcs2Ucs(asDblArray(start),asDblArray(start),Adesk::kFalse);
                ads_printf(_T("\nGot %d sample points"),nPts);
                for( int i=1;i<nPts; i++ )
                {  
                        AcGePoint3d end = pts.at(i);  
                        ads_printf(_T("\nSamplePoint [%d] = (%.3lf,%.3lf,%.3lf)"),i,end.x,end.y,end.z);
                        acdbWcs2Ucs(asDblArray(end),asDblArray(end),Adesk::kFalse);
                        ads_grdraw(asDblArray(start),asDblArray(end),color,0);
                        start = end;
                }
        }


        static void dcgMdtDrawInfo(const AcGeSurface* srf,int color)
        {
                AcGeInterval vi,ui;
                double vlb,vub,ulb,uub; srf->getEnvelope(ui,vi);
                vi.getBounds(vlb,vub); ui.getBounds(ulb,uub);
                double vstep = (vub-vlb) / 4;
                AcGePoint3d p1,p2;
                double ustep = (uub - ulb) / 100;
                AcGePoint2d param(ulb,vlb);
                p1 = srf->evalPoint(param);
                while(param.y < vub)
                {
                        param.x = ulb;
                        p1 = srf->evalPoint(param);
                        acdbWcs2Ucs(asDblArray(p1),asDblArray(p1),Adesk::kFalse);  
                        while(param.x < uub)
                        {
                                param.x += ustep;  
                                p2 = srf->evalPoint(param);
                                acdbWcs2Ucs(asDblArray(p2),asDblArray(p2),Adesk::kFalse);   
                                ads_grdraw(asDblArray(p1),asDblArray(p2),color,0);
                                p1 = p2;
                        }
                        param.y += vstep;
                }
                param.y = vub;
                param.x = ulb;
                p1 = srf->evalPoint(param);
                while(param.x < uub)
                {
                        param.x += ustep;
                        p2 = srf->evalPoint(param);
                        acdbWcs2Ucs(asDblArray(p2),asDblArray(p2),Adesk::kFalse);
                        ads_grdraw(asDblArray(p1),asDblArray(p2),color,0);
                        p1 = p2;
                }
                param.y += vstep;
                vstep = (vub-vlb) / 100;
                ustep = (uub - ulb) / 4;
                param.set(ulb,vlb);
                while(param.x < uub)
                {  
                        param.y = vlb;
                        p1 = srf->evalPoint(param);  
                        while(param.y < vub)  
                        {
                                param.y += vstep;
                                p2 = srf->evalPoint(param);
                                acdbWcs2Ucs(asDblArray(p2),asDblArray(p2),Adesk::kFalse);
                                ads_grdraw(asDblArray(p1),asDblArray(p2),color,0);
                                p1 = p2;
                        }
                        param.x += ustep;  
                }
                param.x = uub;
                param.y = vlb;
                p1 = srf->evalPoint(param);
                while(param.y < vub)
                {  
                        param.y += vstep;  
                        p2 = srf->evalPoint(param);
                        acdbWcs2Ucs(asDblArray(p2),asDblArray(p2),Adesk::kFalse);
                        ads_grdraw(asDblArray(p1),asDblArray(p2),color,0);
                        p1 = p2;
                }
                param.x += ustep;
        }   


        static void printInfo(AcGe::ssiConfig config)
        {
                switch(config)
                {
                case AcGe::kXOut :
                        ads_printf(_T("\n      kXOut : Curve neighborhood is outside the surface."));
                        break;
                case AcGe::kXIn:  ads_printf(_T("\n      kXIn  : Curve neighborhood is inside the surface."));
                        break;
                case AcGe::kXTanOut :  ads_printf(_T("\n      kXTanOut : Curve neighborhood is outside the surface."));   
                        break;
                case AcGe::kXTanIn :  ads_printf(_T("\n      kXTanIn  : Curve neighborhood is inside the surface."));
                        break;
                default :
                        ads_printf(_T("\n      unknown ssiConfig %d"),config);
                        break;
                }
        }

        static void getIntConfigs(const AcGeSurfSurfInt& surfInt)
        {
                AcGeIntersectError err;
                int numResult = surfInt.numResults(err);
                int dim;
                AcGe::ssiConfig surf1Left,surf1Right,surf2Left,surf2Right;
                AcGe::ssiType intType;
                ads_printf(_T("\n Configs of intersection : "));
                for(int i=0;i<numResult;i++)
                {  
                        surfInt.getIntConfigs(i,surf1Left,surf1Right,surf2Left,surf2Right,intType,dim,err);  
                        ads_printf(_T("\n   Intersection %d"),i);
                        ads_printf(_T("\n   surf1Left : "));  printInfo(surf1Left);
                        ads_printf(_T("\n   dim = %d"),dim);
                }
        }
//------------------------------------------------
Acad::ErrorStatus es;
                ads_name e1,e2;
                ads_point p1,p2;
                AcDbEntity *pEnt1,*pEnt2;
                AcDbObjectId Id1,Id2;
                AcDbCurve *pDbCurve1,*pDbCurve2;
                AcGeCurve3d *pGeCurve1,*pGeCurve2;
                AcGeInterval GeIntVal1,GeIntVal2,GeIntVal3;
                double lower1,upper1,lower2,upper2,lower3,upper3;
                int rc = acedEntSel(_T("\n第一条曲线:"),e1,p1);
                if (rc != RTNORM)
                {
                        return;
                }
                acdbGetObjectId(Id1,e1);
                es = acdbOpenObject(pEnt1,Id1,AcDb::kForRead);
                if (es != Acad::eOk)
                {
                        return;
                }
                if (!pEnt1->isKindOf(AcDbCurve::desc()))
                {
                        pEnt1->close();
                        return;
                }
                pDbCurve1 = AcDbCurve::cast(pEnt1);
                rc = acedEntSel(_T("\n第二条曲线:"),e2,p2);
                if (rc != RTNORM)
                {
                        return;
                }
                acdbGetObjectId(Id2,e2);
                es = acdbOpenObject(pEnt2,Id2,AcDb::kForRead);
                if (es != Acad::eOk)
                {
                        pEnt1->close();
                        return;
                }
                if (!pEnt2->isKindOf(AcDbCurve::desc()))
                {
                        pEnt1->close();
                        pEnt2->close();
                        return;
                }
                pDbCurve2 = AcDbCurve::cast(pEnt2);
                es = YJArxUtil::AcGeUtil::AcDbCurveToAcGeCurve(pGeCurve1,pDbCurve1);
                if (es != Acad::eOk)
                {
                        pEnt1->close();
                        pEnt2->close();
                        return;
                }
                 YJArxUtil::AcGeUtil::AcDbCurveToAcGeCurve(pGeCurve2,pDbCurve2);
                if (es != Acad::eOk)
                {
                        delete pGeCurve1;
                        pEnt1->close();
                        pEnt2->close();
                        return;
                }
                AcDbCurve *pC1,*pC2;
                if (Acad::eOk ==  YJArxUtil::AcGeUtil::AcGeCurveToAcDbCurve(pC1,pGeCurve1))
                {
                        pC1->setColorIndex(1);
                        YJArxUtil::DbUtil::PostToModelSpace(pC1);
                }
                if (Acad::eOk ==  YJArxUtil::AcGeUtil::AcGeCurveToAcDbCurve(pC2,pGeCurve2)){
                        pC2->setColorIndex(2);
                        YJArxUtil::DbUtil::PostToModelSpace(pC2);
                }
                pGeCurve1->getInterval(GeIntVal1);
                GeIntVal1.getBounds(lower1,upper1);
                pGeCurve2->getInterval(GeIntVal2);
                GeIntVal2.getBounds(lower2,upper2);
                acutPrintf(_T("\n曲线1：lower = %0.3f, upper = %0.3f length = %0.3f 曲线2：lower = %0.3f, upper = %0.3f length = %0.3f "),
                        lower1,upper1,GeIntVal1.length(),lower2,upper2,GeIntVal2.length());
                if (GeIntVal1.isDisjoint(GeIntVal2))
                {
                        acutPrintf(_T("\n两曲线不相交!"));
                        pEnt1->close();
                        pEnt2->close();
                        delete pGeCurve1;
                        delete pGeCurve2;
                        return;
                }
                if (GeIntVal1.intersectWith(GeIntVal2,GeIntVal3))
                {
                        GeIntVal3.getBounds(lower3,upper3);
                        acutPrintf(_T("\n相交后曲线：lower = %0.3f, upper = %0.3f  length = %0.3f "),GeIntVal3.lowerBound(),GeIntVal3.upperBound(),GeIntVal3.length());
                }

                pEnt1->close();
                pEnt2->close();
                delete pGeCurve1;
                delete pGeCurve2;