Joining Lines and Arcs into a Polyline?

[suparhigh12345]

Hello, In AutoCAD, the 'join' command can be used to connect multiple lines and arcs into a single polyline.

Is there a method or function available in the ObjectARX API that provides similar functionality, allowing us to achieve the same result programmatically?

[Alexander.Rivilis]

https://help.autodesk.com/view/OARX/2023/ENU/?guid=OARX-RefGuide-AcDbJoinEntityPE__joinEntities_AcDb...

[Alexander.Rivilis]

Other sample:

 
//-----------------------------------------------------------------------------
//----- acrxEntryPoint.cpp
//-----------------------------------------------------------------------------
#include "StdAfx.h"
#include "resource.h"
 
//-----------------------------------------------------------------------------
#define szRDS _RXST("")
 
//-----------------------------------------------------------------------------
//----- ObjectARX EntryPoint
class CJoinToPlineApp : public AcRxArxApp {
 
public:
  CJoinToPlineApp () : AcRxArxApp () {}
 
  virtual AcRx::AppRetCode On_kInitAppMsg (void *pkt) {
    AcRx::AppRetCode retCode = AcRxArxApp::On_kInitAppMsg (pkt) ;
    return (retCode) ;
  }
 
  virtual AcRx::AppRetCode On_kUnloadAppMsg (void *pkt) {
    AcRx::AppRetCode retCode = AcRxArxApp::On_kUnloadAppMsg (pkt) ;
    return (retCode) ;
  }
 
  virtual void RegisterServerComponents () {
  }
 
  static void JoinToPlineJoinToPline () {
    // filter for selectin lines and arcs
    ACHAR* promptPtrs[] = {
      _T("\nSelect lines and arcs for getting polyline (ENTER - exit): "),
      _T("\nRemove lines and arcs from selection set: ")
    };
 
    ads_name ss;
    resbuf *rbFilter = acutBuildList(RTDXF0,_T("LINE,ARC"),RTNONE);
    int rc = acedSSGet(_T(":$"),promptPtrs,NULL,rbFilter,ss);
    acutRelRb(rbFilter);
 
    if (rc != RTNORM) return;
 
    AcDbObjectIdArray ids;
    if (ObjectIdArrayFromSelSet(ss, ids) != Acad::eOk) return;
    while (ids.length() > 0)
    {
      AcDbEntity *p = MakeJonedPoly(ids);
      if (p) {
        AcDbBlockTableRecordPointer pSpace(acdbCurDwg()->currentSpaceId(), AcDb::kForWrite);
        if (pSpace.openStatus() != Acad::eOk) return;
        pSpace->appendAcDbEntity(p);
        p->close();
      } else {
        acutPrintf(_T("\nError in input data!"));
        return;
      }
    }
 
  }
 
  /// <summary>
  /// Getting AcDbObjectIdArray from SelectionSet
  /// </summary>
  /// <param name="sset">SelectionSet</param>
  /// <param name="ids">AcDbObjectIdArray</param>
  /// <returns></returns>
  static Acad::ErrorStatus ObjectIdArrayFromSelSet(ads_name sset, AcDbObjectIdArray &ids)
  {
    Acad::ErrorStatus es = Acad::eOk;
    long nset = -1;
    if (acedSSLength(sset,&nset) != RTNORM) return Acad::eAmbiguousInput;
    ids.setLogicalLength(nset);
    ads_name en;
    AcDbObjectId id;
    for (long i=0; i < nset; i++) {
      if (acedSSName(sset,i,en) == RTNORM) {
        if ((es = acdbGetObjectId(id,en)) != Acad::eOk) return es;
        ids[i] = id;
      }
    }
    return Acad::eOk;
  }
 
  /// <summary>
  /// Crete polyline from lines and arcs.
  /// </summary>
  /// <param name="ids">array of objectId</param>
  /// <param name="FUZZ"></param>
  /// <returns></returns>
  static AcDbPolyline* MakeJonedPoly(
    AcDbObjectIdArray &ids,
    double FUZZ = AcGeContext::gTol.equalPoint())
  {
    AcDbPolyline *p = new AcDbPolyline();
    p->setDatabaseDefaults();
    AcDbObjectId idFirst = ids[0];
    AcGePoint3d nextPt = AcGePoint3d::kOrigin;
    AcGePoint3d prevPt = AcGePoint3d::kOrigin;
 
    AcDbObjectPointer<AcDbCurve> c(idFirst,AcDb::kForRead);
    if (c.openStatus() == Acad::eOk) {
      AcGePoint3d ptStart, ptEnd;
      c->getStartPoint(ptStart); c->getEndPoint(ptEnd);
      p->addVertexAt(0, asPnt2d(asDblArray(ptStart)), BulgeFromArc(c, false), 0, 0);
      p->addVertexAt(1, asPnt2d(asDblArray(ptEnd)), 0, 0, 0);
      nextPt = ptEnd;
      prevPt = ptStart;
    }
 
    ids.remove(idFirst);
    int prevCnt = ids.length() + 1;
 
    while (ids.length() > 0 && ids.length() < prevCnt)
    {
      prevCnt = ids.length();
      for (int i = 0; i < ids.length(); i++) {
        AcDbObjectId id = ids[i];
        AcDbObjectPointer<AcDbCurve> cv(id,AcDb::kForRead);
        if (cv.openStatus() == Acad::eOk) {
          AcGePoint3d ptStart, ptEnd;
          cv->getStartPoint(ptStart); cv->getEndPoint(ptEnd);
          if (ptStart.distanceTo(nextPt) < FUZZ || ptEnd.distanceTo(nextPt) < FUZZ) {
            double bulge = BulgeFromArc(cv, ptEnd.distanceTo(nextPt) < FUZZ);
            p->setBulgeAt(p->numVerts() - 1, bulge);
            if (ptStart.distanceTo(nextPt) < FUZZ)
              nextPt = ptEnd;
            else
              nextPt = ptStart;
            p->addVertexAt(p->numVerts(), asPnt2d(asDblArray(nextPt)), 0, 0, 0);
            ids.remove(id);
            break;
          } else if (ptStart.distanceTo(prevPt) < FUZZ || ptEnd.distanceTo(prevPt) < FUZZ) {
            double bulge = BulgeFromArc(cv, ptStart.distanceTo(prevPt) < FUZZ);
            if (ptStart.distanceTo(prevPt) < FUZZ)
              prevPt = ptEnd;
            else
              prevPt = ptStart;
            p->addVertexAt(0, asPnt2d(asDblArray(prevPt)), bulge, 0, 0);
            ids.remove(id);
            break;
          }
        }
      }
    }
    if (p->numVerts() == 0) {
      delete p;  return NULL;
    }  else  {
      return p;
    }
  }
 
  /// <summary>
  /// Getting bulge for curve
  /// </summary>
  /// <param name="c">curve pointer</param>
  /// <param name="clockwise">clockwise or counterclockwise.</param>
  /// <returns></returns>
  static double BulgeFromArc(AcDbCurve *c, bool clockwise)
  {
    double bulge = 0.0;
    AcDbArc *a = AcDbArc::cast(c);
    if (a == NULL) return bulge;
 
    double newStart =
      (a->startAngle() > a->endAngle()) ?
      (a->startAngle() - 8 * atan(1.0)) :
      (a->startAngle());
 
    bulge = tan((a->endAngle() - newStart) / 4.0);
    if (clockwise) bulge = -bulge;
    return bulge;
  }
} ;
 
//-----------------------------------------------------------------------------
IMPLEMENT_ARX_ENTRYPOINT(CJoinToPlineApp)
ACED_ARXCOMMAND_ENTRY_AUTO(CJoinToPlineApp, JoinToPline, JoinToPline, JoinToPline, ACRX_CMD_MODAL, NULL)

[Alexander.Rivilis · Accepted solution]

Sample with using AcDbJoinEntityPE::joinEntities method:

//-----------------------------------------------------------------------------
//----- acrxEntryPoint.cpp
//-----------------------------------------------------------------------------
#include "StdAfx.h"
#include "resource.h"
#include "dbJoinEntityPE.h"

//-----------------------------------------------------------------------------
#define szRDS _RXST("")

//-----------------------------------------------------------------------------
//----- ObjectARX EntryPoint
class CJoinEntitiesApp : public AcRxArxApp {

public:
  CJoinEntitiesApp() : AcRxArxApp() {}

  virtual AcRx::AppRetCode On_kInitAppMsg(void* pkt) {
    AcRx::AppRetCode retCode = AcRxArxApp::On_kInitAppMsg(pkt);
    return (retCode);
  }

  virtual AcRx::AppRetCode On_kUnloadAppMsg(void* pkt) {
    AcRx::AppRetCode retCode = AcRxArxApp::On_kUnloadAppMsg(pkt);
    return (retCode);
  }

  virtual void RegisterServerComponents() {  }

  static void RivilisJoinEnts()
  {
    // filter for selectin lines and arcs
    ACHAR* promptPtrs[] = {
      _T("\nSelect lines, arcs, polylines for getting polyline (ENTER - exit): "),
      _T("\nRemove lines, arcs, polylines from selection set: ")
    };

    ads_name ss;
    resbuf* rbFilter = acutBuildList(RTDXF0, _T("LINE,ARC,LWPOLYLINE"), RTNONE);
    int rc = acedSSGet(_T(":$"), promptPtrs, NULL, rbFilter, ss);
    acutRelRb(rbFilter);

    if (rc != RTNORM) return;

    AcDbObjectIdArray ids;
    if (ObjectIdArrayFromSelSet(ss, ids) != Acad::eOk) return;
    bool bContinue = true;
    while (bContinue)
    {
      bContinue = false;
      AcDbPolyline* pPoly = JoinToPolyline(ids);
      if (pPoly)
      {
        AcDbBlockTableRecordPointer pSpace(acdbCurDwg()->currentSpaceId(), AcDb::kForWrite);
        if (pSpace.openStatus() != Acad::eOk) return;
        pSpace->appendAcDbEntity(pPoly);
        pPoly->close();
        pSpace->close();
        for (int i = ids.length() - 1; i >= 0; i--)
        {
          if (ids[i].isNull()) {
            bContinue = true;
            ids.removeAt(i);
          }
        }
      }
    }
  }

  static AcDbPolyline* JoinToPolyline(AcDbObjectIdArray &ids)
  {
    AcGeIntArray aInts;
    AcDbPolyline *pPoly = new AcDbPolyline();
    pPoly->setDatabaseDefaults();
    AcArray<AcDbEntity*> ents;
    AcDbObjectPointer<AcDbCurve> c(ids[0], AcDb::kForWrite);
    if (c.openStatus() == Acad::eOk) {
      if (c->isKindOf(AcDbPolyline::desc())) {
        pPoly->copyFrom(c);
        c->erase();
      }
      else {
        AcGePoint3d ptStart, ptEnd;
        c->getStartPoint(ptStart); c->getEndPoint(ptEnd);
        pPoly->addVertexAt(0, asPnt2d(asDblArray(ptStart)), BulgeFromArc(c, false), 0, 0);
        pPoly->addVertexAt(1, asPnt2d(asDblArray(ptEnd)), 0, 0, 0);
        c->erase();
      }
    }

    for (int i = 1; i < ids.length(); i++)
    {
      AcDbObjectPointer<AcDbCurve> c(ids[i], AcDb::kForWrite);
      if (c.openStatus() == Acad::eOk)
      {
        AcDbCurve* cc = NULL;  c.release(cc);
        ents.append(cc);
      }
    }

    if (ents.length() > 0)
    {
      AcDbJoinEntityPE* pPE = AcDbJoinEntityPE::cast(pPoly->queryX(AcDbJoinEntityPE::desc()));

      Acad::ErrorStatus es = pPE->joinEntities(pPoly, ents, aInts);
      if (es != Acad::eOk)
      {
        // acutPrintf(_T("\nError pPE->joinEntities(pPoly, ents, aInts) = %s"), acadErrorStatusText(es));
      }
      else
      {
        for (int i = 0; i < aInts.length(); i++)
        {
          ents[aInts[i]]->erase();
          ents[aInts[i]]->close();
          ents[aInts[i]] = NULL;
          if (aInts[i] + 1 < ids.length()) 
            ids[aInts[i]+1].setNull();
        }
      }
    }
    for (int i = 0; i < ents.length(); i++) {
      if (ents[i] != NULL) {
        ents[i]->close();
      }
    }
    ids[0].setNull();
    return pPoly;
  }

  /// <summary>
  /// Getting AcDbObjectIdArray from SelectionSet
  /// </summary>
  /// <param name="sset">SelectionSet</param>
  /// <param name="ids">AcDbObjectIdArray</param>
  /// <returns></returns>
  static Acad::ErrorStatus ObjectIdArrayFromSelSet(ads_name sset, AcDbObjectIdArray& ids)
  {
    Acad::ErrorStatus es = Acad::eOk;
    Adesk::Int32 nset = -1;
    if (acedSSLength(sset, &nset) != RTNORM) return Acad::eAmbiguousInput;
    ids.setLogicalLength(nset);
    ads_name en;
    AcDbObjectId id;
    for (long i = 0; i < nset; i++) {
      if (acedSSName(sset, i, en) == RTNORM) {
        if ((es = acdbGetObjectId(id, en)) != Acad::eOk) return es;
        ids[i] = id;
      }
    }
    return Acad::eOk;
  }
  /// <summary>
  /// Getting bulge for curve
  /// </summary>
  /// <param name="c">curve pointer</param>
  /// <param name="clockwise">clockwise or counterclockwise.</param>
  /// <returns></returns>
  static double BulgeFromArc(AcDbCurve* c, bool clockwise)
  {
    double bulge = 0.0;
    AcDbArc* a = AcDbArc::cast(c);
    if (a == NULL) return bulge;

    double newStart =
      (a->startAngle() > a->endAngle()) ?
      (a->startAngle() - 8 * atan(1.0)) :
      (a->startAngle());

    bulge = tan((a->endAngle() - newStart) / 4.0);
    if (clockwise) bulge = -bulge;
    return bulge;
  }
};

//-----------------------------------------------------------------------------
IMPLEMENT_ARX_ENTRYPOINT(CJoinEntitiesApp)

ACED_ARXCOMMAND_ENTRY_AUTO(CJoinEntitiesApp, Rivilis, JoinEnts, JoinEnts, ACRX_CMD_MODAL | ACRX_CMD_USEPICKSET, NULL)

Update: Code fixed.