AutoCAD DevBlog

Custom Python Scripts for AutoCAD Plant 3D – Part 3

By David Wolfe (Contributor)

Get start with Part 1 and Part 2 of this series.

Expansion Joint Script

This article will look at creating a completely new script, an expansion joint.
The script should look like this:

from varmain.primitiv import *
from varmain.custom import *
 
@activate(Group="Sleeve", TooltipShort="Expansion Joint", TooltipLong="Expansion Joint with Bellows", FirstPortEndtypes="FL", LengthUnit="in",  Ports="2")
@group("MainDimensions")
@param(D=LENGTH, TooltipShort="Pipe OD", TooltipLong="Pipe OD")
@param(D1=LENGTH, TooltipShort="Flange OD", TooltipLong="Flange OD")
@param(D31=LENGTH, TooltipShort="Bellows OD", TooltipLong="Bellows OD")
@param(L=LENGTH, TooltipShort="Length of the ExpansionJoint", TooltipLong="Overall Length of Expansion Joint")
@param(L31=LENGTH, TooltipShort="Flange Thickness", TooltipLong="Flange Thickness")
@param(T=LENGTH, TooltipShort="Bellows thickness", TooltipLong="Thickness of a bellow")
@param(B=LENGTH, TooltipShort="Number of Bolts", TooltipLong="Number of bolts")
@param(B1=LENGTH, TooltipShort="Bolt Size", TooltipLong="Bolt Thickness")
@param(B2=LENGTH, TooltipShort="Bolt Length (greater than L)", TooltipLong="Bolt Length")
@param(OF=LENGTH0)
 
 
#(arxload "PnP3dACPAdapter")
#(testacpscript "EXPJOINT1")
def EXPJOINT1(s, D=4.5, D31=5.5,D1 = 9.0, B=4, B1=0.75, B2=9.5, L=9.0, L31=0.25, T=0.5, K=1, OF=0, **kw ):
    NumOfBellow=round(((L - (2*L31))/ T)/2)-1
    #set a default hole size
    fhole = .95*D   
    #create a hole in the flange
    if OF > 0:
        fhole = (D-OF)
    #create our first flange
    Flange1=CYLINDER(s,R=D1/2, H=L31,O=0).rotateY(90)
    bellowlength = (T*2*NumOfBellow)-1
    nb = 0
    #overall length - belows length / 2 plus 1/4 the width of the bellow
    offset= ((L - bellowlength - (2*L31))/2)+L31
    expBody = CYLINDER(s,R=D31/2,H=L-L31,O=D).rotateY(90).translate((L31,0,0))
    #union the first flange and main body
    Flange1.uniteWith(expBody)
    expBody.erase()
    while (nb < NumOfBellow):       
        #create and offset our torus
        b=TORUS(s,R1=D31/2,R2=T/2).rotateY(90).translate((offset,0,0))
        #increment our offset distance
        offset = offset + T*2
        #union as we go
        Flange1.uniteWith(b)
        b.erase()
        nb = nb +1
    #create our end flange and offset it
    Flange2=CYLINDER(s,R=D1/2, H=L31,O=0).rotateY(90).translate((L - L31,0,0))
    Flange1.uniteWith(Flange2)
    Flange2.erase()
    #see if we need to create bolts, if there is a bolt cound and it's greater than 0
    if B > 1 and B1 > 0 and B2 > L:
        anglesplit = 360/B
        startangle = 0
    if B%2!=0:       
        startangle = anglesplit/2
    intbolt=0
    incangle=startangle
    platewidth=3*B1
    platelength=4*B1
    plateheight= 0.75*L31
    #make the bolts the length of the object + 2 flange thickness
    boltlength = L + 4*L31
    #calculate our offsets
    #plate on flg one offset
    pof1 = (L31 - plateheight/2,D1/2+platewidth/2,0)
    #translate the bolts
    bof1 = (-(B2-L),D1/2+platewidth/2,0)
    #translate the second plate
    pof2 = (L - (L31 - plateheight/2),D1/2+platewidth/2,0)
    #create a cylinder to subtract for the opening
    boreCy = CYLINDER(s,R=fhole/2, H=L,O=0).rotateY(90)
    Flange1.subtractFrom(boreCy)
    boreCy.erase()
    while (intbolt < B):
        #create a plate for the bolt, rotate it, and then move it to the edge and back to face of flange 1
        p = BOX(s,L=platewidth,W=platelength,H=plateheight).rotateX(90).translate(pof1).rotateX(incangle)
        #unite with flange 1 so we have a single body
        Flange1.uniteWith(p)
        p.erase()
        #create the bolt
        b = CYLINDER(s, R=B1/2, H=boltlength,O=0).rotateY(90).translate(bof1).rotateX(incangle)
        #join the flange and bolt
        Flange1.uniteWith(b)
        b.erase()
        #create our plate on flange 2
        p2 = BOX(s,L=platewidth,W=platelength,H=plateheight).rotateX(90).translate(pof2).rotateX(incangle)
        #merge the last plate
        Flange1.uniteWith(p2)
        p2.erase()
        incangle = incangle + anglesplit
        intbolt = intbolt + 1
    return

 

Metadata

The most interesting part of this script, other than the geometry, is the metadata.

 

Note that the group defines where the script shows up in the spec editor.

The tooltips show when the dimensions are hovered over in the editor as well.

Script Testing

While creating the script, you must be able to test it to see if your geometry can be generated.  Because these scripts are designed to be processed within AutoCAD, currently there is no IDE that you can use to debug the shapes. The process of testing the script looks like this.

1. Create your script file at C:\AutoCAD Plant 3D 2016 Content\CPak Common\CustomScripts (or wherever your Shared Content folder is for plant (MODIFYSHAREDCONTENTFOLDER).
2. Create your geometry functions, and metadata sections.
3. Start Plant 3D
4. Use PLANTREGISTERCUSTOMSCRIPTS. If there is an error in the script, you will get a warning at the command line with the line number. For most errors line of the script with the error will be listed.  If no errors are shown, the script compiled.
   
5. Load the PnP3dACPAdapter.arx. You can do this by pasting this at the command line (arxload "PnP3dACPAdapter")
6. Test the script. You can test with the default parameters by pasting this at the command line: (testacpscript "EXPJOINT1"). Fill in your script function where EXPJOINT1 is.
   You can also test the script from one of the other following options:
       (TESTACPSCRIPT "CPFLR")
       (TESTACPSCRIPT "CPFLR" "D1" "300.5")
       (TESTACPSCRIPT "CPFLR" "L" "40" "D1" "300.5" "D2" "88.9")
   Or
       (TESTACPSCRIPT1 "CPFLR")
       (TESTACPSCRIPT1 "CPFLR" "D1=300.5")
       (TESTACPSCRIPT1 "CPFLR" "L=40,D1=300.5,D2=88.9")
7. If you need to make changes, make them before closing Plant. That was you can try to register the script again to see if you still have breaking code.
8. If the script has been changed and registered, you must close Plant 3D in order to test the geometry again. Once the script is registered or run, the Python processor stores that script in memory until Plant 3D is closed, so starting a new session is the only way test new script changes.

Autodesk Exchange Apps Store surpasses 1 million downloads

We reached a great milestone in the success of the Exchange Apps Store: one million downloads. 

 

 

Selected point on solid during entity selection

By Balaji Ramamoorthy

The acedEntSel method provides a way for the user to select an entity and it also provides the point that was used during the entity selection. When used on a 2D entity, the point returned by acedEntSel is quite useful if you need that information to further work on the entity and perform tasks such as break, trim etc. 

However, when acedEntSel is used to select a solid, the point returned is in the UCS XY Plane regardless of where on the solid you pick. if you use an OSNAP while selecting the solid entity, the point will be on the solid. If the point on the solid that was used while selecting the solid is important for doing further processing in your code, here is a way to get that.

In the following code, a ray is created along the viewing direction with which we will find the intersection points of the solid. The code displays all the intersection points as though the ray pierced the solid. But the first intersection point should provide the selection point, in case you are only interested in that.

Please note that, in AutoCAD 2015 and AutoCAD 2016, the "AcBrBrep::getLineContainment" returns lesser number of hits during an intersection test. This behavior has been logged with our engineering team. AutoCAD 2014 and previous releases provide the right number of hits.

Here is a recording which demonstrates the entity selection and the sample code :

 Acad::ErrorStatus es;

 // pt is in UCS coordinates and in the UCS XY plane  

 // unless a osnap is used while selecting the entity 

 // In that case, the point will be have all  

 // the three coordinate values in UCS. 

 ads_name  ename;

 ads_point pt;

 int  ret = acedEntSel(_T("\\nPick a solid : " ), ename, pt);

 if  (ret != RTNORM)

 	return ;

 AcDbObjectId entId = AcDbObjectId::kNull;

 es = acdbGetObjectId(entId, ename);

 AcDbEntity *pEnt = NULL;

 AcDb3dSolid *pSolid = NULL;

 es = acdbOpenAcDbEntity(pEnt, entId, AcDb::kForRead);

 pSolid = AcDb3dSolid::cast(pEnt);

 if (pSolid == NULL)

 {

 	acutPrintf(L"\\nSelected entity was not a solid.\\n" );

 	return ;

 }

 // Get the WCS coordinates of the selected point 

 AcGePoint3d wcsPt = AcGePoint3d::kOrigin;

 acdbUcs2Wcs(pt, pt, 0);

 wcsPt = asPnt3d(pt);

 resbuf viewRb;

 AcGePoint3d  target = AcGePoint3d::kOrigin; 

 // TARGET is in UCS 

 acedGetVar(_T("TARGET" ), &viewRb); 

 target = asPnt3d(viewRb.resval.rpoint);

 acdbUcs2Wcs(asDblArray(target), asDblArray(target), 0);

 AcGeVector3d dir = AcGeVector3d::kIdentity; 

 // VIEWDIR is in UCS 

 acedGetVar( ACRX_T("VIEWDIR" ), &viewRb ); 

 dir = asVec3d(viewRb.resval.rpoint);

 acdbUcs2Wcs(asDblArray(dir), asDblArray(dir), 1);

 AcGePoint3d  position = target + dir;

 dir = dir.normalize().negate();

 AcGeLine3d testRay(

 	wcsPt.project(AcGePlane(position, dir), dir.negate()),

 	dir);

 AcBrBrep*pBrep = new  AcBrBrep();

 pBrep->setSubentPath( AcDbFullSubentPath

 	( pEnt->objectId(),  AcDbSubentId()));

 AcBr::ErrorStatus bres;

 AcBrHit *pHits = NULL;

 Adesk::UInt32 nHitsFound = 0;

 // Find all hits 

 bres = pBrep->getLineContainment(

 	testRay, 0, nHitsFound, pHits );

 if (bres == AcBr::eOk)

 {

 	for ( Adesk::UInt32 i = 0; i < nHitsFound; i++) 

 	{

 		AcBrEntity *pHitEntity = NULL;

 		pHits[i].getEntityHit( pHitEntity );

 		if ( pHitEntity == NULL )

 			continue ;

 		if ( ! pHitEntity->isKindOf(AcBrBrep::desc()))

 		{

 			AcGePoint3d hitPt;

 			pHits[i].getPoint(hitPt);

 			AcDbPoint *pDbPt = new  AcDbPoint(hitPt);

 			PostToDb(pDbPt);

 			es = pDbPt->close();

 		} 

 		delete  pHitEntity;

 	}

 	delete  [] pHits;

 }

 delete  pBrep;

 pEnt->close();

Custom Python Scripts for AutoCAD Plant 3D – Part 2

By David Wolfe (Contributor)

Check here the Part 1 of this series.

The first example script is taken from an older Autodesk University class (AU Python PDF). The pdf is available here. Beginning on page 44, the pdf creates a sample script. The script should look like this:

from aqa.math import *
from varmain.primitiv import *
from varmain.custom import *
 
@activate(Group="Support",
 TooltipShort="Test script",
 TooltipLong="This is a custom Testscript", 
 LengthUnit="in",
 Ports=1)
@group("MainDimensions")
@param(D=LENGTH, TooltipShort="Cylinder Diameter", Ask4Dist=True)
@param(L=LENGTH, TooltipLong="Length of the Cylinder")
@param(OF=LENGTH0)
@group(Name="meaningless enum")
@param(K=ENUM)
@enum(1, "align X")
@enum(2, "align Y")
@enum(3, "align Z")
#--------------------------------------------------------
#(arxload "PnP3dACPAdapter")
#(testacpscript "TESTSCRIPT" "D" "4.5" "L" "12")
def TESTSCRIPT(s, D=80.0, L=150.0, OF=-1, K=1, **kw):
    CYLINDER(s, R=D/2, H=L, O=0.0).rotateY(90)

Scripts Parts

There are three sections to this script, the imports section, the metadata section, and the actual shape script.  In addition, you may create functions as needed for your shape generation.

Imports

The imports section lists other python classes and functions that may be used by the current script. In order to avoid having to tell Plant 3D what a cylinder is and how to draw it, we can simpler reference a function (CYLINDER) and use that in our scripts.  The imports section is resolved by the AutoCAD Plant 3D Python interpreter, and as such, doesn’t load into other IDE’s.  The imports shown here are basic ones, but others available in the actual product scripts. Some of the scripts used by Plant 3D are available upon request through ADN.

Metadata

The metadata section instructs the PLANTREGISTERCUSTOMSCRIPTS command how to treat the script being registered. One of the key pieces not shown in the original Python script sample is the number of Ports.  In order for the script to be used in the Spec Editor, the number of ports must be included in the metadata section.

Some of the other parameters referenced in the AU python documentation aren’t used. The image options will be explained in future posts.

Shape Scripts

Before getting into the script portion, notice the comments above the line that starts with def.  In Python, comment rows start with pound signs (#). It’s easier to test your script if you can copy the lines minus the comments to the command line to load the testing adapter, and then call the script with values.

In any case, the def line defines our shape function that will be called to create a script. The registration command looks for the function that matches the script file name.  If you create additional functions to use within your shape script, you must locate them above the script so the script will compile. For example, to use a function called FlangeSizeCalc, you would have to define it first and then reference it lower in the script file.

Shape scripts can get complicated, so you should contact ADN to view samples that work.  In addition the AU Python PDF gives more details on how to move objects and use Boolean operations to get the shape needed.

Finished Script

At the beginning you saw the finished script.  Here is a screenshot of the final product with images being used in the spec editor.

Figure 1: script thumbnail

Figure 2: dimension images and tool tips

Figure 3: register custom script files

How to Get Default Drawing Format

By Madhukar Moogala

I have recently received a query from an ADN partner whether it is possible to get default Save As format details from an API or Command, I’m not sure if we have command to get, but we do have a simple API to get the details.

 

Following tiny code snippet will give details of

 

void testDWGFormatDefault()

{

/*The format mentioned in Options/ Open and Save*/

AcApDocument ::SaveFormat saveFormat =

acDocManagerPtr()->defaultFormatForSave();

AcDb::AcDbDwgVersion dwgVersion;

AcDb::MaintenanceReleaseVersion maintainRelVersion;

AcApDocument* pCurDoc = acDocManagerPtr()->curDocument();

/*To get relevant dwg and mReleaseVersions*/

if( !eOkVerify(pCurDoc->getDwgVersionFromSaveFormat(saveFormat,

dwgVersion,

maintainRelVersion)))

return;

}

Identifying layer property overrides for a viewport

By Balaji Ramamoorthy

Here is a sample code to identify the layers that have their properties overridden for a viewport and to list the property overrides. The "AcDbLayerTableRecord::hasAnyOverrides" should quickly let us know if there are any overrides for any of the viewports. If it does exist, we can get to the details using "AcDbLayerTableRecord::hasOverrides" and provide the ObjectId of the viewport for which we want to know the overrides.

 Acad::ErrorStatus es;

 AcDbDatabase *pDb 

 	= acdbHostApplicationServices()->workingDatabase();

 ads_point pt;

 ads_name ename;

 if  ( RTNORM != 

 	acedEntSel(ACRX_T("Select a viewport :" ), 

 	ename, pt))

 	return ;

 AcDbObjectId vpid = AcDbObjectId::kNull;

 if  ( Acad::eOk != acdbGetObjectId(vpid, ename ))

 	return ;

 AcDbObjectId layerId = AcDbObjectId::kNull;

 AcDbLayerTable* pLayerTable;

 pDb->getSymbolTable(pLayerTable, AcDb::kForRead);

 AcDbLayerTableIterator *pIter = NULL;

 AcDbLayerTableRecord *pLTR = NULL;

 pLayerTable->newIterator(pIter);

 for  (;! pIter->done(); pIter->step()) 

 {

 	es = pIter->getRecord(pLTR, AcDb::kForRead);

 	if (! pLTR->hasAnyOverrides())

 	{

 		pLTR->close();

 		continue ;

 	}

 	if (! pLTR->hasOverrides(vpid))

 	{

 		pLTR->close();

 		continue ;

 	}

 	TCHAR *lname;

 	pLTR->getName(lname);

 	acutPrintf(L"\\n Layer : %s has the following overrides :" ,

 		lname);

 	bool  isOverriddenForVP = Adesk::kFalse;

 	AcCmColor clr = pLTR->color(vpid, isOverriddenForVP);

 	if (isOverriddenForVP)

 	{

 		acutPrintf(L"\\n Color override" );

 	}

 	isOverriddenForVP = Adesk::kFalse;

 	AcDbObjectId ltypeId 

 		= pLTR->linetypeObjectId(

 		vpid, isOverriddenForVP);

 	if (isOverriddenForVP)

 	{

 		acutPrintf(L"\\n Linetype override" );

 	}

 	isOverriddenForVP = Adesk::kFalse;

 	AcDb::LineWeight lw 

 		= pLTR->lineWeight

 		(vpid, isOverriddenForVP);

 	if (isOverriddenForVP)

 	{

 		acutPrintf(L"\\n Lineweight override" );

 	}

 	isOverriddenForVP = Adesk::kFalse;

 	ACHAR *psName = pLTR->plotStyleName

 		(vpid, isOverriddenForVP);

 	if (isOverriddenForVP)

 	{

 		acutPrintf(L"\\n Plotstyle override" );

 	}

 	pLTR->close();

 }

 delete  pIter;

 pLayerTable->close();

Extracting pattern, text and shapes used in linetypes

By Balaji Ramamoorthy

As you may already know, linetype definition in AutoCAD consists of series of values representing the pattern and can include text and shapes. Here is a sample code to iterate the linetypes loaded in the database and display the definition. In case of embedded shapes, a preview of the shape is created by adding an AcDbShape to the modelspace.

 Acad::ErrorStatus es;

 double  previewOffset = 5.0;

 AcGePoint3d pos = AcGePoint3d::kOrigin;

 AcApDocument *pActiveDoc 

 	= acDocManager->mdiActiveDocument();

 AcDbDatabase *pDB = pActiveDoc->database();

 AcDbLinetypeTable* pLineTypeTable = NULL; 

 if  ( pDB->getLinetypeTable(

 	pLineTypeTable, AcDb::kForRead) != Acad::eOk) 

 	return ;

 es = acDocManager->lockDocument(pActiveDoc);

 AcDbBlockTableRecordPointer 

 	pMS(ACDB_MODEL_SPACE, pDB, AcDb::kForWrite);

 AcDbLinetypeTableIterator* pIter = NULL; 

 es = pLineTypeTable->newIterator( pIter); 

 es = pLineTypeTable->close(); 

 for (;! pIter->done(); pIter->step()) 

 { 

 	AcDbLinetypeTableRecord* pLinetype = NULL; 

 	if  ( pIter->getRecord( pLinetype, 

 		AcDb::kForRead) == Acad::eOk) 

 	{ 

 		const  ACHAR *pLinetypeName = NULL; 

 		es = pLinetype->getName(pLinetypeName); 

 		acutPrintf(_T("\\nLinetype : %s" ), 

 			pLinetypeName); 

 		for ( int  dash = 0; dash < 

 			pLinetype->numDashes(); ++dash) 

 		{ 

 			int  shapeNumber 

 				= pLinetype->shapeNumberAt(dash);

 			double  dashLen 

 				= pLinetype->dashLengthAt(dash); 

 			AcDbObjectId objIdShape

 				(pLinetype->shapeStyleAt( dash)); 

 			if  ( objIdShape == AcDbObjectId::kNull) 

 			{ 

 				const  ACHAR *pText = NULL; 

 				es = pLinetype->textAt(dash, pText);

 				if (pText == NULL)

 					acutPrintf(_T("\\nDash : %d DashLen : %lf" ),

 					dash,  dashLen); 

 				else

 					acutPrintf(_T("\\nDash : %d Text : %s" ), 

 					dash,  pText); 

 				continue ;

 			}

 			// Shape involved, lets preview it...

 			AcDbObject* pObject = NULL;

 			es = acdbOpenAcDbObject(

 				pObject, objIdShape, AcDb::kForRead);

 			AcDbTextStyleTableRecord* pTextSyleTableRec 

 				= AcDbTextStyleTableRecord::cast( pObject); 

 			Adesk::Boolean isShapeFile 

 				= pTextSyleTableRec->isShapeFile();

 			if (isShapeFile)

 			{

 				// Create a preview of the shape

 				AcDbShape *pShape = new  AcDbShape

 					(AcGePoint3d::kOrigin, 1.0); 

 				if ( pShape->setShapeNumber(shapeNumber) 

 					!= Acad::eOk || 

 					pShape->setStyleId(objIdShape) 

 					!= Acad::eOk)

 				{

 					delete  pShape;

 					pShape = NULL;

 				}

 				if (pShape)

 				{

 					es = pShape->setWidthFactor(1.0);

 					AcDbObjectId id;

 					es = pMS->appendAcDbEntity(id, pShape);

 					es = pShape->setPosition(pos);

 					pos += 

 					AcGeVector3d::kXAxis * previewOffset;

 					es = pShape->setSize(1);

 					es = pShape->setRotation(0);

 					es=pShape->close();

 					const  ACHAR *pShapeFileName = NULL; 

 					Acad::ErrorStatus es 

 						= pTextSyleTableRec->fileName

 						(pShapeFileName); 

 					acutPrintf(_T("\\nDash : %d 

 							ShapeNumber : %d 

 							ShapeName : %s 

 							ShapeFile : %s"), 

 							dash, shapeNumber, 

 							pShape->name(), pShapeFileName);

 				}

 			}

 			else

 			{

 				const  ACHAR *pText = NULL; 

 				es = pLinetype->textAt(dash, pText);

 				acutPrintf(_T("\\nDash : %d Text : %s" ), 

 					dash,  pText); 

 			}

 			pObject->close(); 

 		}

 		pLinetype->close();

 	}

 }

 delete  pIter;

 es = acDocManager->unlockDocument(pActiveDoc);

The output generated by this code snippet is as seen in this screenshot :

Custom Python Scripts for AutoCAD Plant 3D – Part 1

By David Wolfe (Contributor)

In this series of posts, we will cover developing custom python scripts for AutoCAD Plant 3D.

Along with learning about the development environment, we will cover troubleshooting, template scripts, and deployment. The original AU course covering scripts and Plant 3D is available here.

This blog article is going to assume some familiarity with Python.  There are a lot of great resources for learning python on the internet. To get started learning the language syntax I suggest using Code Academy.
This introductory article will start off by covering the basics of:

• Description of the development process
• Programs are necessary for development
• Description of script types

Development Process

Unlike typical development done with .Net languages or even normal Python scripts, there is no integrated IDE for compiling, testing, and debugging.  The compiling is done by running a special command in Plant 3D, and then the scripts are loaded into memory for the AutoCAD session. Since the only way to test changes is to start a new AutoCAD session, the process of troubleshooting
The steps in the development process are:

• Define function(s) for modeling the custom part
• Define the metadata header
• Test the script
• Create the snapshots
• Build a script package (if necessary)
• Deploy the content

Through the rest of the articles, we’ll break down these steps even further so that you have an accurate understanding of the entire process. Along the way we will also develop a few custom scripts to help get you started.

Development Programs

Due to the prevalence of Python, there are many good free editors. Since we are not looking for an IDE (Integrated Development Environment), any of the text editors that highlight the Python syntax will work well.  I’ve used Komodo Edit, but my preference for text editors is TotalEdit Pro (now free).  Again, the main job here is just to color the text. All of the testing of the code will be done in AutoCAD Plant, and there is no debugger to step through.

When building scripts for Equipment, you will need to have a zip program. My personal favorite is 7-zip, as it integrates well with the Windows Explorer right-click menu.

With xml files, you can use Foxe which offers a customizable tree view of the xml beside the xml content with syntax highlighting. Here’s a quick article showing how to customize the tree.

Script Types

Plant 3D uses scripts in a couple different ways, for equipment and also for catalog content.  The scripts get stored in special folders inside the shared content folder.  The two special folders for scripts are:

• C:\AutoCAD Plant 3D 20XX Content\CPak Common\equipment
• C:\AutoCAD Plant 3D 20XX Content\CPak Common\CustomScripts

The paths are above are the default locations. If you are using a shared network location, these folder should be located there. You may have to create the CustomScripts folder as it is not present by default.

If you are going to create an object that will connect to piping, and show as an end connection on the isometric (and is not a nozzle), you should create an equipment script.  Any other type of script will be created as a custom script.

 

 

Equipment Scripts

These basic shapes (primitives) are hard coded into the program, and you cannot add your own routines to this list.

Another type of script is for generating a complete equipment item. For example, the Centrifugal Pump script generates the entire pump, and the user inputs values for the parameters.

Scripts of this type generate the entire equipment item without removable parts.

Synopsis

In this article you learned some high-level information about developing Python scripts for Plant 3D. You learned which program will be used to modify equipment packages and script files, as well as the key locations for developing and testing those files. The next article will describe the parts of a custom script and the custom equipment packages in more detail.

Programmatically mimic the Burst command

By Balaji Ramamoorthy

The "Burst" command from the express tools is quite useful when exploding block references with attributes. Unlike the usual explode command, it leaves the attributes unchanged when a block reference is exploded.

Here is a sample code to mimic the Burst command using the AutoCAD .Net API. It first explodes a block reference and replaces any attribute definitions in the exploded entity collection by a DBText.

 [CommandMethod("EB" , CommandFlags.UsePickSet)]

 public  void  ExplodeBock()

 {

     Document doc 

         = Application.DocumentManager.MdiActiveDocument;

     Editor ed = doc.Editor;

     PromptSelectionResult psr = ed.SelectImplied();

     if  (psr.Status != PromptStatus.OK)

     {

         ed.WriteMessage(@"Please select the  

         block references to explode and  

         then run the command" );

         return ;

     }

     using  (SelectionSet ss = psr.Value)

     {

         if  (ss.Count <= 0)

         {

             ed.WriteMessage(@"Please select the  

             block references to explode and  

             then run the command" );

             return ;

         }

         Database db = doc.Database;

         using  (Transaction tr 

             = db.TransactionManager.StartTransaction())

         {

             ObjectId msId 

             = SymbolUtilityServices.GetBlockModelSpaceId(db);

             BlockTableRecord ms = tr.GetObject(msId, 

                 OpenMode.ForWrite) as  BlockTableRecord;

             foreach  (SelectedObject selectedEnt in  ss)

             {

                 BlockReference blockRef = tr.GetObject(

                 selectedEnt.ObjectId, 

                 OpenMode.ForRead) as  BlockReference;

                 if  (blockRef != null )

                 {

                     DBObjectCollection toAddColl 

                             = new  DBObjectCollection();

                     BlockTableRecord blockDef 

                     = tr.GetObject(

                     blockRef.BlockTableRecord,

                     OpenMode.ForRead) as  BlockTableRecord;

                     // Create a text for const and  

                     // visible attributes 

                     foreach  (ObjectId entId in  blockDef)

                     {

                         if  (entId.ObjectClass.Name 

                             == "AcDbAttributeDefinition" )

                         {

                             AttributeDefinition attDef 

                             = tr.GetObject(entId, 

                             OpenMode.ForRead) 

                             as  AttributeDefinition;

                             if  ((attDef.Constant && 

                                 !attDef.Invisible))

                             {

                                 DBText text = new  DBText();

                                 text.Height = attDef.Height;

                                 text.TextString 

                                     = attDef.TextString;

                                 text.Position = 

                                 attDef.Position.TransformBy

                                 (blockRef.BlockTransform);

                                 toAddColl.Add(text);

                             }

                         }

                     }

                     // Create a text for non-const  

                     // and visible attributes 

                     foreach  (ObjectId attRefId 

                         in  blockRef.AttributeCollection)

                     {

                         AttributeReference attRef 

                         = tr.GetObject(attRefId, 

                         OpenMode.ForRead)

                         as  AttributeReference;

                         if  (attRef.Invisible == false )

                         {

                             DBText text = new  DBText();

                             text.Height = attRef.Height;

                             text.TextString 

                                 = attRef.TextString;

                             text.Position = attRef.Position;

                             toAddColl.Add(text);

                         }

                     }

                     // Get the entities from the  

                     // block reference 

                     // Attribute definitions have  

                     // been taken care of.. 

                     // So ignore them 

                     DBObjectCollection entityColl 

                     = new  DBObjectCollection();

                     blockRef.Explode(entityColl);

                     foreach  (Entity ent in  entityColl)

                     {

                         if  (! (ent is  AttributeDefinition))

                         {

                             toAddColl.Add(ent);

                         }

                     }

                     // Add the entities to modelspace 

                     foreach  (Entity ent in  toAddColl)

                     {

                         ms.AppendEntity(ent);

                         tr.AddNewlyCreatedDBObject

                         (ent, true );

                     }

                     // Erase the block reference 

                     blockRef.UpgradeOpen();

                     blockRef.Erase();

                 }

                 tr.Commit();

             }

         }

     }

 }

Dynamic dimension using GripOverrule

By Balaji Ramamoorthy

Dynamic dimensions are an easy and intuitive way to let users modify entity dimensions using grips. For this to work, the dimensional input is to be turned on by setting the DYNMODE system variable to either 2 or 3. If you wish to change the default grip editing behavior for an entity and prompt for another dimension that is more intuitive and readily available for users, grip overrule can help do that.

For a circle, when a grip turns hot, a dynamic dimension appears prompting for the radius value. In the following sample code, we will change that to accept diameter value by displaying a dynamic dimension diametrically on the circle being grid edited. Also, the prompt at the command line window is changed to make the user aware of the diameter input that we are expecting.

Here is a recording of the behavior with/without the grip overrule and the sample code :

 #include  "dbentityoverrule.h" 

 class  CMyGripOverrule: public  AcDbGripOverrule

 {

 public :

 	static  CMyGripOverrule* _pTheOverrule;

 	ACRX_DECLARE_MEMBERS(CMyGripOverrule);

 	static  AcDbDimData *mpDimData;

 	static  void  CMyGripOverrule::AddOverrule()

 	{

 		mpDimData = NULL;

 		if (_pTheOverrule != NULL)

 			return ;

 		_pTheOverrule = new  CMyGripOverrule();

 		AcRxOverrule::addOverrule(

 						AcDbCircle::desc(),

 						_pTheOverrule, 

 						true 

 						);

 		CMyGripOverrule::setIsOverruling(true );

 	}

 	static  void  CMyGripOverrule::RemoveOverrule()

 	{

 		if (_pTheOverrule == NULL)

 			return ;

 		CMyGripOverrule::setIsOverruling(false );

 		AcRxOverrule::removeOverrule(

 					AcDbCircle::desc(), 

 					_pTheOverrule

 					);

 		delete  _pTheOverrule;

 		_pTheOverrule = NULL;

 	}

 	ACDB_PORT Acad::ErrorStatus moveGripPointsAt(

 						AcDbEntity* pSubject,

                         const  AcDbVoidPtrArray& gripAppData,

                         const  AcGeVector3d& offset, 

                         const  int  bitflags)

 	{

 		if  (!pSubject->isKindOf(AcDbCircle::desc())) 

 			return  Acad::eOk;

 		AcDbCircle* pCircle = AcDbCircle::cast(pSubject);

 		if  (pCircle == NULL) 

 			return  Acad::eOk;

 		AcGeVector3d normal = pCircle->normal();

 		AcGeVector3d horizDir = normal.perpVector();

 		AcGePoint3d center = pCircle->center();

 		double  radius = pCircle->radius();

 		AcGePoint3d pt1 = center + radius * horizDir;

 		pt1 = pt1 + offset;

 		AcGeVector3d radVec = pt1 - center;

 		updateDimensions(

 			pCircle, 

 			center-radVec, 

 			center+radVec);

 		AcDbGripOverrule::moveGripPointsAt(

 			pSubject, 

 			gripAppData, 

 			offset, 

 			bitflags); 

 	}

 	ACDB_PORT Acad::ErrorStatus getGripPoints(

 		const  AcDbEntity* pSubject, 

 		AcDbGripDataPtrArray& grips, 

 		const  double  curViewUnitSize, 

 		const  int  gripSize, 

 		const  AcGeVector3d& curViewDir, 

 		const  int  bitflags

 	)

 	{

 		if  (!pSubject->isKindOf(AcDbCircle::desc())) 

 			return  Acad::eOk;

 		AcDbCircle* pCircle 

 			= AcDbCircle::cast(pSubject);

 		if  (pCircle == NULL) 

 			return  Acad::eOk;

 		AcDbGripDataPtrArray oldGrips;

 		AcDbGripOverrule::getGripPoints(

 			pSubject, oldGrips, 

 			curViewUnitSize, gripSize, 

 			curViewDir, bitflags); 

 		AcDbGripData * pGripData 

 			= new  AcDbGripData(*(oldGrips.at(1)));

 		pGripData->setGripPoint

 			(oldGrips.at(1)->gripPoint());

 		pGripData->setHotGripDimensionFunc

 			(MyGripHotGripDimensionfunc);

 		pGripData->setHoverDimensionFunc

 			(MyHoverGripDimensionfunc);

 		pGripData->setCLIPromptFunc

 			(MyGripCLIPromptCallback);

 		grips.append(pGripData);

 		return  Acad::eOk;

 	}

 	static  void  gripDimensionCbackFunc(

 		AcDbGripData* pGrip, 

 		const  AcDbObjectId& objId, 

 		double  dimScale, 

 		AcDbDimDataPtrArray& dimDataArr)

 	{

 		Acad::ErrorStatus es;

 		if  (pGrip == NULL)

 			return ;

 		AcDbEntity *pEnt = NULL;

 		if  (acdbOpenAcDbEntity(

 			pEnt, objId, 

 			AcDb::kForRead) != Acad::eOk)

 			return ;

 		AcDbCircle *pCircle 

 			= AcDbCircle::cast(pEnt);

 		if  (pCircle == NULL) {

 			pEnt->close();

 			return ;

 		}

 		AcGeVector3d normal = pCircle->normal();

 		AcGeVector3d horizDir = normal.perpVector();

 		AcGeVector3d vertDir 

 			= normal.crossProduct(horizDir);

 		AcGePoint3d center = pCircle->center();

 		double  radius = pCircle->radius();

 		pCircle->close();

 		AcDbAlignedDimension *pAlignedDim 

 			= new  AcDbAlignedDimension();

 		pAlignedDim->setDatabaseDefaults();

 		es = pAlignedDim->setDimsah(true );

 		es = pAlignedDim->setDimse1(true );

 		es = pAlignedDim->setDimblk1(_T("None" ));

 		es = pAlignedDim->setNormal(normal);

 		es = pAlignedDim->setElevation(0.0);

 		es = pAlignedDim->setHorizontalRotation(0.0);

 		es = pAlignedDim->setXLine1Point

 			(center - radius * horizDir);

 	    es = pAlignedDim->setXLine2Point

 			(center + radius * horizDir);

 		es = pAlignedDim->setDimLinePoint

 			(center + 0.5 * radius * horizDir);

 		es = pAlignedDim->setDynamicDimension(true );

 		es = pAlignedDim->setColorIndex(1);

 		AcDbDimData *pDimData 

 			= new  AcDbDimData(pAlignedDim);

 		es = pDimData->setOwnerId(objId);

 		es = pDimData->setDimFocal(true );

 		es = pDimData->setDimEditable(true );

 		es = pDimData->setDimRadius(true );

 		es = pDimData->setDimHideIfValueIsZero(true );

 		es = pDimData->setDimValueFunc

 			(setDimValueCbackFunc);

 		es = pDimData->setDimension(pAlignedDim);

 		dimDataArr.append(pDimData);

 		mpDimData = pDimData;

 	}

 	bool  isApplicable(

 		const  AcRxObject *pOverruledSubject) const 

 	{

 		if  (!pOverruledSubject->isKindOf

 			(AcDbCircle::desc())) 

 			return  false ;

 		return  true ;

 	}

 	static  const  ACHAR* MyGripCLIPromptCallback

 		(AcDbGripData *pGripData)

 	{

 		return  ACRX_T("\\nRing diameter : " ); 

 	}

 	static  void  MyGripHotGripDimensionfunc

 		(AcDbGripData *pGripData, 

 		const  AcDbObjectId &entId, 

 		double  dimScale, 

 		AcDbDimDataPtrArray &dimDataArr)

 	{

 		gripDimensionCbackFunc

 			(pGripData, entId, dimScale, dimDataArr);

 	}

 	static  void  MyHoverGripDimensionfunc

 		(AcDbGripData *pGripData, 

 		const  AcDbObjectId &entId, 

 		double  dimScale, 

 		AcDbDimDataPtrArray &dimDataArr)

 	{

 		gripDimensionCbackFunc(pGripData, 

 			entId, dimScale, dimDataArr);

 	}

 	static  AcGeVector3d setDimValueCbackFunc

 		(AcDbDimData* pDimData, AcDbEntity* pEnt, 

 		double  newValue, const  AcGeVector3d& offset)

 	{

 		AcGeVector3d newOffset(offset);

 		if  ((pDimData == NULL) || (pEnt == NULL))

 			return  newOffset;

 		AcDbObjectId objId;

 		AcDbCircle *pCir = AcDbCircle::cast(pEnt);

    		 if  (pCir == NULL)

 			return  newOffset;

 		pCir->setRadius(newValue * 0.5);

 		return  newOffset;

 	}

 	static  bool  updateDimensions

 		(AcDbCircle* pCircle, 

 		AcGePoint3d xline1Pt, 

 		AcGePoint3d xline2Pt)

 	{

 		if  (!pCircle || !mpDimData)

 			return  false ;

 		AcDbObjectId entId = pCircle->objectId();

 		AcGeVector3d normal = pCircle->normal();

 		AcGeVector3d horizDir = normal.perpVector();

 		AcGeVector3d vertDir 

 			= normal.crossProduct(horizDir);

 		AcGePoint3d center = pCircle->center();

 		double  radius = pCircle->radius();

 		AcDbObjectId ownerId;

 		AcDbDimData *pDimData = mpDimData;

 		AcDbAlignedDimension *pAlignedDim 

 			= AcDbAlignedDimension::cast(

 			pDimData->dimension());

 		if (pAlignedDim != NULL)

 		{

 			pAlignedDim->setXLine1Point(xline1Pt);

 			pAlignedDim->setXLine2Point(xline2Pt);

 			pAlignedDim->setDimLinePoint

 				(xline1Pt + (xline2Pt - xline1Pt) * 0.5);

 		}

 		return  true ;

 	}

 };

 AcDbDimData * CMyGripOverrule::mpDimData = NULL;

 CMyGripOverrule* CMyGripOverrule::_pTheOverrule = NULL;

 ACRX_NO_CONS_DEFINE_MEMBERS(

 	CMyGripOverrule, 

 	AcDbGripOverrule);