ObjectARX中如何获取填充实体的边界

原文链接：https://blog.csdn.net/itwalker1618/article/details/54604486

//遍历填充对象的边界信息。
bool CAcUiSelDialog::OpenDwgFile(const ACHAR* fileName)
{
    Acad::ErrorStatus es;
    //AcDbObjectIdArray objectIds ;         //边界id数组
    AcGeVector3d normal;                    //填充平面
    bool bAssociative;                      //关联型
    AcDbHatch::HatchPatternType patternType;//填充图案类型
    const ACHAR *patternName;               //填充图案名
    AcDbHatch::HatchStyle   hatchStyle;
    //2.读取.dwg文件
    AcDbDatabase *pDb = new AcDbDatabase(Adesk::kFalse); 
    es=pDb->readDwgFile(_T("D:\\***.dwg")); //.dwg文件路径
    if (Acad::eOk!=es)
    {
        acedAlert(_T("临时数据库打开失败"));
        delete pDb;
        return false;
    }
    //3.获取块表
    AcDbBlockTable *pBlkTbl; 
    es=pDb->getSymbolTable(pBlkTbl, AcDb::kForRead); 
    if (Acad::eOk!=es)
    {
        acedAlert(_T("获取块表错误!"));
        delete pDb;
        pBlkTbl->close();
        return false;
    }
    //4.获取块表记录
    AcDbBlockTableRecord *pBlkTblRcd; 
    es=pBlkTbl->getAt(ACDB_MODEL_SPACE, pBlkTblRcd,AcDb::kForRead); 
    if (Acad::eOk!=es)
    {
        delete pDb;
        pBlkTbl->close();
        pBlkTblRcd->close();
        acedAlert(_T("获取块表记录错误！"));
        return false;
    }
    pBlkTbl->close(); 

    //5.创建块表记录迭代器,遍历模型空间块表记录
    CString hClass;  
    AcDbBlockTableRecordIterator *pBlkTblRcdItr; 
    pBlkTblRcd->newIterator(pBlkTblRcdItr); 

    AcGePoint3d *pPt3D = new AcGePoint3d();
    if (NULL == pPt3D)
    {
        pBlkTblRcd->close();
        delete pDb;
        //delete pHatch;
        delete pBlkTblRcdItr;
        return false;
    }
    //遍历块表记录中的实体
    for (pBlkTblRcdItr->start();!pBlkTblRcdItr->done();pBlkTblRcdItr->step()) 
    {
        //6.得到实体对象
        AcDbHatch *pHatch= new AcDbHatch();
        AcDbEntity *pEnt;
        Adesk::Int32 loopType;                  
        Adesk::UInt16 color=0;      
        AcGePoint2dArray vertices;             
        AcGeDoubleArray bulges;  
        pBlkTblRcdItr->getEntity(pEnt,AcDb::kForRead); 
        if (!pEnt->isKindOf(AcDbHatch::desc()))
        {
            pEnt->close();          
            pHatch->close();
            //delete patternName;
            delete pBlkTblRcdItr;
            return false;
        }
        pHatch=AcDbHatch::cast(pEnt);
        if (pHatch != NULL) 
        {   

            int loopNums=pHatch->numLoops();
            //acutPrintf(_T("%d"),loopNums);//此处可用
            normal=pHatch->normal();                //平面向量
            bAssociative=pHatch->associative();     //关联性
            patternName=pHatch->patternName();      //填充图案名
            patternType=pHatch->patternType();      //填充类型
            hatchStyle=pHatch->hatchStyle();        //hatch style of the hatch entity,填充风格
            color=pHatch->colorIndex();             //得到为indicates the entity uses the color specified in the LayerTableRecord it references.
            //acutPrintf(_T("填充对象的颜色：%d"),color);

            /
            AcDbHatch *pHatch2 = new AcDbHatch();           //新建填充对象                    
            es=pHatch2->setNormal(normal);                  // 设置填充平面
            if (Acad::eOk!=es)
            {
                acedAlert(_T("构造向量失败"));
                return false;
            }           
            es=pHatch2->setElevation(0); 
            es=pHatch2->setAssociative(bAssociative);       // 设置关联性
            if (Acad::eOk!=es)
            {
                acedAlert(_T("构造关联性失败"));
                return false;
            }
            es=pHatch2->setPattern(patternType,patternName); // 设置填充图案
            if (Acad::eOk!=es)
            {
                acedAlert(_T("构造图案失败"));
                return false;
            }
            es=pHatch2->setHatchStyle(hatchStyle);//设置填充类型
            es=pHatch2->setColorIndex(color);//设置颜色


            for (int loopIndex=0;loopIndex<loopNums;loopIndex++)//遍历第-61条边界
            {
                //为每一条边界长久存放数组
                AcGeVoidPointerArray edgePtrs;          
                AcGeIntArray edgeTypes;   

                AcGeVoidPointerArray VoidPtrAry;
                AcGeIntArray IntAry;
                if (Acad::eNotApplicable != pHatch->getLoopAt(loopIndex,loopType, vertices,bulges))//获取kPolyLine的边界
                {
                    //多义线----kPolyLine-----获取其顶点;
                    int iIndex = 0;
                    for (iIndex=0; iIndex<vertices.length(); iIndex++)
                    {                                               
                        pPt3D->x = vertices.at(iIndex).x;//This function returns the element of the array at position i
                        pPt3D->y = vertices.at(iIndex).y;
                        acutPrintf(_T("多义线的坐标是：%d,%d"),pPt3D->x,pPt3D->y);
                        //pPenStroke->m_Stroke.push_back(pPt3D);//保存多义线顶点
                    }
                }
                //非多义线
                else
                {
                    //分别获取第-61条边界，每一条边界都是AcGe对像数组
                    es=pHatch->getLoopAt(loopIndex,   //Input index of selected loop 
                        loopType,      //Output loop type 
                        edgePtrs,       //Output a set of AcGeCurve pointers 
                        edgeTypes);     //Output a set of enumerated edge types                     
                    for (int j=0; j<edgePtrs.length(); j++)//遍历AcGe对象数组中的点
                    {
                        /*
                        else if(edgeTypes[j]==AcDbHatch::kCirArc)//圆弧
                        {
                        //AcGeCircArc2d *CirArc=(AcGeCircArc2d *)edgePtrs;
                        acutPrintf(_T("\n圆弧"));
                        //可以根据数学圆弧构造相应的AcDb圆弧，取决于你（以下同）
                        }
                        else if(edgeTypes[j]==AcDbHatch::kEllArc)//椭圆弧
                        {
                        //AcGeEllipArc2d *EllArc=(AcGeEllipArc2d *)edgePtrs;
                        acutPrintf(_T("\n椭圆弧"));
                        }
                        else if(edgeTypes[j]==AcDbHatch::kSpline)//NURBS曲线
                        {
                        //AcGeNurbCurve2d *Spline=(AcGeNurbCurve2d *)edgePtrs;
                        acutPrintf(_T("\nNURBS曲线"));
                        }
                        //获取直线的起点和终点，只考虑直线，章中只有直线
                        if(edgeTypes[j]==AcDbHatch::kLine)//线型
                        {
                        AcGeLineSeg2d *pLnSeg=(AcGeLineSeg2d *)edgePtrs.at(j);//遍历第j个AcGe对象
                        }
                        */
                        AcGeLineSeg2d *pLineSeg= NULL;
                        //边类型（仅当边界不是多段线时）：
                        //1 = 直线；= 圆弧；= 椭圆弧；= 样条曲线
                        switch(edgeTypes.at(j))//判断边类型
                        {
                        case 1://-----直线
                            {
                                pLineSeg = (AcGeLineSeg2d *)edgePtrs.at(j);
                            }
                        }
                        if (NULL != pLineSeg)
                        {
                            AcGePoint3d * pPt3D1 = new AcGePoint3d() ;//起点，并转换为D                            
                            pPt3D1->x = pLineSeg->startPoint().x;
                            pPt3D1->y = pLineSeg->startPoint().y;
                            AcGePoint2d BeginPt(pPt3D1->x, pPt3D1->y);
                            delete pPt3D1;

                            AcGePoint3d *pPt3D2=new AcGePoint3d() ;//尾点，并转为D                            
                            pPt3D2->x = pLineSeg->endPoint().x;
                            pPt3D2->y = pLineSeg->endPoint().y;
                            AcGePoint2d EndPt(pPt3D2->x, pPt3D2->y);
                            delete pPt3D2;

                            AcGeLineSeg2d *pObj = new AcGeLineSeg2d(BeginPt, EndPt);//
                            //acutPrintf(_T("添加第%d对象数组")),loopIndex;
                            VoidPtrAry.append(pObj);
                            IntAry.append(AcDbHatch::kLine);
                        }

                    }//遍历边界（AcGe对象数组）中AcGe对象结束，得到AcGe对象数组               

                    //es=pHatch2->appendLoop(loopType,VoidPtrAry,IntAry);
                    es=pHatch2->appendLoop(loopType,VoidPtrAry,IntAry);
                    if(Acad::eOk!=es)
                    {
                        acedAlert(_T("Acad::eInvalidInput"));
                        pHatch2->close();
                        pHatch->close();
                        pBlkTblRcd->close();
                        delete pBlkTblRcdItr;
                        delete patternName;
                        delete pDb;
                        return false;
                    }                   

                }//将每一条边界添加进自定义实体, //将得到的每条边界加入到填充对象中

            }//边界循环结束,得到填充对象的整边界

            es = pHatch2->evaluateHatch();      // 显示填充对象
            AcDbObjectId hatchId;               // 添加到模型空间
            hatchId = PostToModelSpace(pHatch2); 
            if (hatchId!=NULL)
            {
                acedAlert(_T("获取填充对象成功\n"));
            }           
            pEnt->close();
            pHatch->close();//关闭实体，
            //pHatch2->close();
            pBlkTblRcd->close();
//          delete patternName;
            delete pBlkTblRcdItr;
            delete pDb;
            return true;

        }//pHatch对象为空
        pEnt->close();          
        pHatch->close();
        delete patternName;
        delete pBlkTblRcdItr;
        delete pDb;

        return false;
    }//遍历dwg文件临时库结束

}