NP CAD Page | Articles | Russian | Download

There is a function (intersectWith) that is often used in a very important geometrical calculation, that is entities intersection. AcGe-objects as well as objects derived from AcDbEntity class possess a method with such a name.
An example of programmatic calculation of two selectable entities intersection is given in listing 5.15.

Listing 5.15. Intersection of entities
// Based on:
// N.Poleshchuk, Chapter 05\Book09\acrxEntryPoint.cpp
// Based on book "AutoCAD: Application Development, Tuning and Customization"
// (BHV-Petersburg Publishing House, Russia, 2006)
// http://poleshchuk.spb.ru/cad/2006/Razr2006e.htm
//
// ----- ads_book09 symbol (do not rename)
static int ads_book09(void)
{
int es1, es2;
ads_name ent1, ent2;
ads_point pt1, pt2;
AcDbObjectId entId1, entId2;
AcDbEntity* pEnt1 = NULL;
AcDbEntity* pEnt2 = NULL;
AcGePoint3dArray points;
 
// First object selection by inquiry
es1 = acedEntSel("\nSpecify entity No. 1: ", ent1, pt1);
if (es1 != RTNORM)
{
acutPrintf("\nObject is not selected.");
return (RSRSLT);
}
 
// Calculation of ID to switch from ads_name to AcDbObjectId
es1 = acdbGetObjectId(entId1, ent1);
if (es1 != Acad::eOk)
{
acutPrintf("\nNo Id 1 ");
return (RSRSLT);
}
// Calculation of pointer to AcDbEntity
es1 = acdbOpenAcDbEntity(pEnt1, entId1, AcDb::kForRead);
if (es1 != Acad::eOk)
{
acutPrintf("\nObject 1 is not opened ");
return (RSRSLT);
}
// Highlighting first object
pEnt1->highlight();
 
// Second object selection by inquiry
label_select2:
es2 = acedEntSel("\nSpecify object No. 2: ", ent2, pt2);
if (es2 != RTNORM)
{
pEnt1->unhighlight(); // unhighlighting
pEnt1->close(); // we’ll close object 1
acutPrintf("\nObject is not selected. ");
return (RSRSLT);
}
// Calculation of ID to switch from ads_name to AcDbObjectId
es2 = acdbGetObjectId(entId2, ent2);
if (es2 != Acad::eOk)
{
pEnt1->unhighlight();
pEnt1->close(); // we’ll close object 1
acutPrintf("\nNo Id 2 ");
return (RSRSLT);
}
// Check for coincidence
if(entId2 == entId1)
{
acutPrintf(" Repeat selection: ");
goto label_select2;
}
 
// Calculation of pointer to AcDbEntity
es2 = acdbOpenAcDbEntity(pEnt2, entId2, AcDb::kForRead);
if (es2 != Acad::eOk)
{
pEnt1->unhighlight();
pEnt1->close(); // closing object 1
acutPrintf("\nObject 2 is not opened ");
return (RSRSLT);
}
 
// Highlighting second object
pEnt2->highlight();
 
// Printing selected objects
acutPrintf("\n"); // to a new line
pEnt1->list();
acutPrintf("\n");
pEnt2->list();
 
// Calculation of entities intersection points
es1 = pEnt2->intersectWith(pEnt1, AcDb::kOnBothOperands, points);
int len;
if ( (es1 != Acad::eOk) || ((len = points.length() ) == 0) )
acutPrintf("\nObjects do not intersect.");
else
{
acutPrintf("\nIntersection points:");
for (int i=0; i<len; ++i)
{
acutPrintf("\n%d: %.6f %.6f %.6f",
i+1, points[i].x, points[i].y, points[i].z);
}
}
 
// Unhighlighting
pEnt1->unhighlight();
pEnt2->unhighlight();
 
// Closing objects with memory release
pEnt1->close();
pEnt2->close();
 
// TODO: Replace the following line by your returned value if any
acedRetVoid () ;
return (RSRSLT) ;
}

Let's give some explanations to source text. To select entity in an interactive mode the acedEntSel function is used. This function is declared in acedads.h so:

The first argument is a prompt text to be displayed and the second and the third arguments by reference return selection result (entity name and point for entity specification). Unlike entsel (LISP function) integer code is returned, not list. The normal return value is RTNORM.
The first one of specified entities is saved in ent1 variable having ads_name type which is one of the types for entity presentation in the ObjectARX programming system. To transform entity from a presentation to another one, appropriate functions are used.
For further work with the first selected object we should get its drawing base identificator, or ID (Object ID). Those identificators as well as entity names (ads_name) are not constant and in every new session they have different values.
Entity name ent1 is being transformed to identificator entId1 with the help of acdbGetObjectId function that is declared in dbmain.h so:

Acad::ErrorStatus acdbGetObjectId (AcDbObjectId& objId, const ads_name objName);

Computed entity ID is passed by reference through the first argument.
Next by entId1 with the help of acdbOpenAcDbEntity function one can by reference get value of pointer to entity as a member of AcDbEntity class and then access to entity properties and methods. The function is declared in dbmain.h file:

Acad::ErrorStatus acdbOpenAcDbEntity (AcDbEntity*& pEnt, AcDbObjectId id, AcDb::OpenMode mode, bool openErasedEntity = false);

The first argument of the acdbOpenAcDbEntity function is a countable pointer, the second one is an object ID, the third one is an access mode and the fourth one is a flag of accessing erased entities (by default erased entities are unavailable). So for the first object selected on screen we've got pEnt1 pointer that is already pointing to the object of AcDbEntity type.
With the help of pEnt1 pointer one can call a method for highlighting the specified entity. The highlight function is used for this purpose.
Next all that was mentioned above is applied in the program to the second object. Second object ID (entId2) is being calculated and afterwards pEnt2 is calculated too and the entity is being highlighted too (it is difficult to catch this because the program is being run very quickly and and at the end highlighting is canceled).
During the execution it is being verified if the same object is specified twice (in this case entId2 == entId1) and if yes then control is being passed to the label_select2 label, which is used to mark the second entity selection operation.
Later details concerning entities selected are output to the screen with the help of list function as if it were done by the LIST command.
After that we may go to immediate points calculation using for this purpose the intersectWith method (function) mentioned above. This function is virtual in the AcDbEntity class and it is declared so in the dbmain.h file:

virtual  Acad::ErrorStatus intersectWith (const AcDbEntity* pEnt, AcDb::Intersect intType, AcGePoint3dArray& points, int thisGsMarker = 0, int otherGsMarker = 0) const;

In this prototype (and there exists another overloaded declaration, with other arguments) the function accepts pointer to auxiliary AcDbEntity object as a first argument, flag of extension for one or both primitives as a second argument and reference to array of points belonging to AcGePoint3d type as a third argument. We do not use the fouth and the fifth arguments in an explicit way (the default values are sufficient).
In our example the main entity is the first one of the objects specified on screen and pEnt2 is a pointer to the secondary primitive to be passed to the function. Extension flag intType may receive the following values: