AutoCAD DevBlog

Embedding an image in a drawing

By Balaji Ramamoorthy

In this blog post we will look at creating a custom object derived from AcDbRasterImageDef that saves/loads the image data to/from the drawing using ATIL. This will ensure that your drawing is independent of the external image file and the image data will get loaded to the AcDbRasterImageDef if the arx is loaded in AutoCAD.

For other ways to embed an image in a drawing without having a dependency on an external image file, please refer to this blog post :

Embedding an image in a drawing

 // AcDbMyRasterImageDef.h 

 class  DLLIMPEXP AcDbMyRasterImageDef : 

 	public  AcDbRasterImageDef 

 {

 protected :

 	static  Adesk::UInt32 kCurrentVersionNumber;

 public :

 	ACRX_DECLARE_MEMBERS(AcDbMyRasterImageDef) ;

 	AcDbMyRasterImageDef () ;

 	virtual  ~AcDbMyRasterImageDef () ;

 	virtual  Acad::ErrorStatus 

 		dwgOutFields (AcDbDwgFiler *pFiler) const  ;

 	virtual  Acad::ErrorStatus dwgInFields 

 		(AcDbDwgFiler *pFiler) ;

 	//----- deepClone 

 	virtual  Acad::ErrorStatus 

 		subDeepClone (AcDbObject *pOwnerObject, 

 		AcDbObject *&pClonedObject, AcDbIdMapping &idMap, 

 		Adesk::Boolean isPrimary =true ) const  ;

 	//----- wblockClone 

 	virtual  Acad::ErrorStatus subWblockClone 

 		(AcRxObject *pOwnerObject, AcDbObject *&pClonedObject, 

 		AcDbIdMapping &idMap, Adesk::Boolean isPrimary =true )

 		const  ;

 	Acad::ErrorStatus 

 		setEmbeddedImage(const  ACHAR* imageFilePath);

 private :

 	void  *operator  new [](size_t) throw (){ return  (void *)0;}

     void  operator  delete [](void  *) {};

     void  *operator  new [](size_t , const  char  *, int  ) throw ()

 	{ return  (void *)0;}

 	Atil::Image *m_pAtilImage;

 };

 // AcDbMyRasterImageDef.cpp 

 AcDbMyRasterImageDef::AcDbMyRasterImageDef () 

 	: AcDbRasterImageDef () 

 {

 	m_pAtilImage = NULL;

 }

 AcDbMyRasterImageDef::~AcDbMyRasterImageDef() 

 {

 	if (m_pAtilImage != NULL)

 	{

 		delete  m_pAtilImage;

 		m_pAtilImage = NULL;

 	}

 }

 Acad::ErrorStatus AcDbMyRasterImageDef::dwgOutFields

 	(AcDbDwgFiler *pFiler) const  {

 	assertReadEnabled () ;

 	//----- Save parent class information first. 

 	Acad::ErrorStatus es =

 		AcDbRasterImageDef::dwgOutFields (pFiler) ;

 	if  ( es != Acad::eOk )

 		return  (es) ;

 	//----- Object version number needs to be saved first 

 	if  ( (es =pFiler->writeUInt32 

 		(AcDbMyRasterImageDef::kCurrentVersionNumber))

 		!= Acad::eOk )

 		return  (es) ;

 	if (m_pAtilImage)

 	{

 		Atil::Size size = m_pAtilImage->size();

 		Int32 width = size.width;

 		Int32 height = size.height;

 		pFiler->writeInt32(width);

 		pFiler->writeInt32(height);

 		// Write the image data on to the Atil image 

 		// using an Image Context 

 		Atil::Offset upperLeft(0,0);

 		Atil::ImageContext *pImgContext 

 			= m_pAtilImage->createContext(

 				Atil::ImageContext::kRead,

 				size,

 				upperLeft);

 		if  (pImgContext != NULL)

 		{

 			for  (int  xf=0;xf<width;xf++)

 			{

 				for  (int  yf=0;yf<height;yf++)

 				{

 					Atil::RgbColor p;

 					p = pImgContext->get32(xf, yf);

 					pFiler->writeInt32(p.packed);

 				}

 			}

 		}

 		pImgContext->flush();

 		delete  pImgContext;

 	}

 	return  (pFiler->filerStatus ()) ;

 }

 Acad::ErrorStatus AcDbMyRasterImageDef::dwgInFields

 	(AcDbDwgFiler *pFiler) 

 {

 	assertWriteEnabled () ;

 	Acad::ErrorStatus es =

 		AcDbRasterImageDef::dwgInFields (pFiler) ;

 	if  ( es != Acad::eOk )

 		return  (es) ;

 	Adesk::UInt32 version =0 ;

 	if  ( (es =pFiler->readUInt32 (&version)) 

 		!= Acad::eOk )

 		return  (es) ;

 	if  ( version > 

 		AcDbMyRasterImageDef::kCurrentVersionNumber)

 		return  (Acad::eMakeMeProxy) ;

 	Int32 width = 0;

 	Int32 height = 0;

 	pFiler->readInt32(&width);

 	pFiler->readInt32(&height);

 	// Create an Atil::Image. 

     // The AcDbRasterImageDef::setImage requires it 

     Atil::ImagePixel initialImage;

     initialImage.setToZero();

     initialImage.type 

 		= Atil::DataModelAttributes::kBgra;

     initialImage.value.rgba = 0xff000000;

     Atil::Size size(width, height);

     const  Atil::RgbModel *pDm 

 		= new  Atil::RgbModel(

         Atil::RgbModelAttributes::k4Channels,

         Atil::DataModelAttributes::kBlueGreenRedAlpha);

 	if (m_pAtilImage != NULL)

 	{

 		delete  m_pAtilImage;

 		m_pAtilImage = NULL;

 	}

     m_pAtilImage

 		= new  Atil::Image(size, pDm, initialImage);

 	// Write the image data on to the Atil image 

 	// using an Image Context 

 	Atil::Offset upperLeft(0,0);

 	Atil::ImageContext *pImgContext 

 		= m_pAtilImage->createContext(

 				Atil::ImageContext::kWrite,

 				size,

 				upperLeft);

 	if  (pImgContext != NULL)

 	{

 		for  (int  xf=0;xf<width;xf++)

 		{

 			for  (int  yf=0;yf<height;yf++)

 			{

 				Int32 value;

 				pFiler->readInt32(&value);

 				pImgContext->put32(xf, yf, value);

 			}

 		}

 	}

 	pImgContext->flush();

 	delete  pImgContext;

 	setImage (m_pAtilImage, NULL) ;

 	return  (pFiler->filerStatus ()) ;

 }

 //----- deepClone 

 Acad::ErrorStatus AcDbMyRasterImageDef::subDeepClone 

 	(AcDbObject *pOwnerObject, AcDbObject *&pClonedObject, 

 	AcDbIdMapping &idMap, Adesk::Boolean isPrimary) const  

 {

 	assertReadEnabled () ;

 	return  (AcDbRasterImageDef::subDeepClone 

 		(pOwnerObject, pClonedObject, idMap, isPrimary)) ;

 }

 //----- wblockClone 

 Acad::ErrorStatus AcDbMyRasterImageDef::subWblockClone 

 	(AcRxObject *pOwnerObject, AcDbObject *&pClonedObject, 

 	AcDbIdMapping &idMap, Adesk::Boolean isPrimary) const  

 {

 	assertReadEnabled () ;

 	return  (AcDbRasterImageDef::subWblockClone 

 		(pOwnerObject, pClonedObject, idMap, isPrimary)) ;

 }

 Acad::ErrorStatus  AcDbMyRasterImageDef::setEmbeddedImage

 							(const  ACHAR* imageFilePath)

 {

     AcString imagePath(imageFilePath);

     AcTcImage tc;

     tc.Load(imagePath);

     HBITMAP bmp=0;

     tc.GetHBITMAP(RGB(0xff,0xff,0xff),bmp);

     if  (bmp == NULL)

 		return  Acad::eFileNotFound;

     BITMAP _bmp={0};

     GetObject(bmp,sizeof  BITMAP,&_bmp);

     HDC hdcScr=GetDC(NULL);

     HDC    hdcMem=CreateCompatibleDC(hdcScr);

     SelectObject(hdcMem,bmp);

     Atil::ImagePixel initialImage;

     initialImage.setToZero();

 	initialImage.type = Atil::DataModelAttributes::kBgra;

     initialImage.value.rgba = 0xff000000;

     Atil::Size size(_bmp.bmWidth, _bmp.bmHeight);

     const  Atil::RgbModel *pDm = new  Atil::RgbModel(

         Atil::RgbModelAttributes::k4Channels,

         Atil::DataModelAttributes::kBlueGreenRedAlpha);

 	if (m_pAtilImage != NULL)

 	{

 		delete  m_pAtilImage;

 		m_pAtilImage = NULL;

 	}

     m_pAtilImage 

 		= new  Atil::Image(size, pDm, initialImage);

     Atil::Offset upperLeft(0,0);

     Atil::ImageContext *pImgContext

         = m_pAtilImage->createContext(

                     Atil::ImageContext::kWrite,

                     size,

                     upperLeft);

     if  (pImgContext != NULL)

     {

         for  (int  xf=0;xf<_bmp.bmWidth;xf++)

         {

             for  (int  yf=0;yf<_bmp.bmHeight;yf++)

             {

                 BYTE alpha= 0xff;

                 COLORREF pix=GetPixel(hdcMem,xf,yf);

                 BYTE rr = (pix&0xff);

                 BYTE gg = (pix>>8)&0xff;

                 BYTE bb = (pix>>16)&0xff;

                 Atil::RgbColor p;

                 p.set(rr, gg, bb, alpha);

                 pImgContext->put32(xf, yf, p);

             }

         }

     }

     pImgContext->flush();

     delete  pImgContext;

     bool  isImageValid = m_pAtilImage->isValid();

     assert(isImageValid);

     // Cleanup 

     DeleteDC(hdcMem);

     ReleaseDC(NULL,hdcScr);

     DeleteObject( bmp);

 	return  setImage (m_pAtilImage, NULL) ;

 }

 // Embed image command 

 static  void  AdskMyTestEmbedImage(void )

 {

 	AcDbMyRasterImageDef *pImageDef 

 		= new  AcDbMyRasterImageDef();

 	pImageDef->setEmbeddedImage(

 		ACRX_T("D:\\TestFiles\\MyTexture.jpg" ));

 	Acad::ErrorStatus es 

 		= InsertImageInDwg(pImageDef);

 	if (es != Acad::eOk)

 	{

 		delete  pImageDef;

 		return ;

 	}

 }

 static  Acad::ErrorStatus 

 	InsertImageInDwg(AcDbRasterImageDef *pImageDef)

 {

 	Acad::ErrorStatus es;

 	if (! pImageDef->isLoaded())

 	{

 		es = pImageDef->load();

 		if (es != Acad::eOk)

 			return  es;

 	}

 	AcApDocument *pActiveDoc 

 		= acDocManager->mdiActiveDocument();

 	AcDbDatabase *pDB = pActiveDoc->database();

 	// Get the image dictionary 

 	// Create it if not available already 

 	AcDbObjectId dictID

 	= AcDbRasterImageDef::imageDictionary(pDB);

 	if (dictID == AcDbObjectId::kNull)

 	{

 		es = AcDbRasterImageDef::createImageDictionary

 			(pDB, dictID);

 		if (es != Acad::eOk)

 			return  es;

 	}

 	AcDbDictionary* pDict;

 	es = acdbOpenObject(pDict, dictID, AcDb::kForWrite);

 	if (es != Acad::eOk)

 			return  es;

 	ACHAR *DICT_NAME = ACRX_T("RASTER_USING_BUFFER" );

 	BOOL bExist = pDict->has(DICT_NAME);

 	AcDbObjectId objID = AcDbObjectId::kNull;

 	if  (!bExist)

 	{

 		es = pDict->setAt(DICT_NAME, pImageDef, objID);

 		if (es != Acad::eOk)

 		{

 			pDict->close();

 			return  es;

 		}

 	}

 	else 

 	{

 		pDict->getAt(DICT_NAME,

 					(AcDbObject*&)pImageDef,

 					AcDb::kForWrite);

 		objID = pImageDef->objectId();

 	}

 	// close Dictionary and Definition. 

 	pDict->close();

 	pImageDef->close();

 	// Create a raster image using the RasterImage Def 

 	AcDbRasterImage* pImage = new  AcDbRasterImage;

 	es = pImage->setImageDefId(objID);

 	if  (es != Acad::eOk)

 	{

 		delete  pImage;

 		return  es;

 	}

 	// Add the raster image to the model space 

 	AcDbBlockTable* pBlockTable;

 	AcDbBlockTableRecord* pBTRecord;

 	es = acdbCurDwg()->getBlockTable(pBlockTable,

 							AcDb::kForRead);

 	assert(es == Acad::eOk);

 	es = pBlockTable->getAt(ACDB_MODEL_SPACE,

 							pBTRecord,

 							AcDb::kForWrite);

 	assert(es == Acad::eOk);

 	es = pBTRecord->appendAcDbEntity(pImage);

 	assert(es == Acad::eOk);

 	pBTRecord->close();

 	pBlockTable->close();

 	AcDbObjectId entID = pImage->objectId();

 	AcDbObjectPointer<AcDbRasterImageDefReactor>

 						rasterImageDefReactor;

 	rasterImageDefReactor.create();

 	es = rasterImageDefReactor->setOwnerId(

 							pImage->objectId());

 	if  (es == Acad::eOk)

 	{

 		AcDbObjectId defReactorId;

 		es = curDoc()->database()->addAcDbObject(

 				defReactorId,

 				rasterImageDefReactor.object());

 		if  (es == Acad::eOk)

 		{

 			pImage->setReactorId(defReactorId);

 			AcDbObjectPointer<AcDbRasterImageDef> 

 				rasterImagedef

 				(pImage->imageDefId(), AcDb::kForWrite);

 			if  (rasterImagedef.openStatus() == Acad::eOk)

 			{

 				rasterImagedef->addPersistentReactor

 						(defReactorId);

 			}

 		}

 	}

 	pImageDef->close();

 	pImage->close();

 	return  Acad::eOk;

 }

 virtual  AcRx::AppRetCode On_kInitAppMsg (void  *pkt) 

 {

 	AcRx::AppRetCode retCode =

 		AcRxArxApp::On_kInitAppMsg (pkt) ;

 	acrxDynamicLinker->loadModule

 		(L"acismobj20.dbx" ,true ); 

 	AcDbMyRasterImageDef::rxInit();

 	acrxBuildClassHierarchy();

 	return  (retCode) ;

 }

The sample project can be downloaded here :

Download EmbedImage

If you are looking to create an embedded raster image using the AutoCAD .Net API, a way to do it is by creating a managed wrapper for the custom object that we created. A .Net only solution is not possible at present since custom objects can only be created using C++. Also, ATIL is a C++ only library which we use in this case.

A way to access it in .Net is demonstrated in the following sample project. To try this sample, appload the .arx and netload the managed wrapper and custom .Net module. Run the "EmbedImageMgd" command.

Download CustomRasterImageDef

 

Update:

the broker code is fixed and updated to ObjectARX 2022, is posted in Github

https://github.com/MadhukarMoogala/EmbedRasterImage

 

Switching assembly references based on build configuration

By Balaji Ramamoorthy

Recently, a developer came up with this query :

Is there a simple way to have a single copy of my code configured to compile to different folders with different references based on the desired version of AutoCAD to be run ?

This is not strictly an AutoCAD API related query but it is very relevant to how we build plugins for AutoCAD. It is a common requirement that we add references from different paths based on the AutoCAD version for which we are building the plugin.

A simple way to get this working is to create separate build configurations in your Visual Studio solution.

Now, open the .csproj in a text editor and manually include the "Condition" for each of the references.

As an example, here is the change to include different versions of the interop assembly for Sheetset manager for each build configuration.

<Reference Include="Interop.ACSMCOMPONENTS20Lib" Condition="'$(Configuration)'=='Debug2015'">
<HintPath>..\..\..\..\ObjectARX 2015\inc-x64\ACSMCOMPONENTS20Lib.dll</HintPath>
<EmbedInteropTypes>True</EmbedInteropTypes>
</Reference>
<Reference Include="Interop.ACSMCOMPONENTS20Lib" Condition="'$(Configuration)'=='Debug2016'">
<HintPath>..\..\..\..\ObjectARX 2016\inc-x64\ACSMCOMPONENTS20Lib.dll</HintPath>
<EmbedInteropTypes>True</EmbedInteropTypes>
</Reference>

If you are using any other technique to achieve this already, please do share by posting your comments. I am sure that will help many other developers. Thank you.

Mapping a material texture on a SubDMesh

By Balaji Ramamoorthy

When a material is assigned to the SubDMesh, the mapper (AcGiMapper) associated with the material takes care of most of the details involved in mapping the texture on to the SubDMesh. The mapper can be configured for its projection, scaling, translation, tiling and such parameters that affect the texture mapping. This approach is suitable for complex texture mapping and if your mapping fits one of the existing projection methods that AcGiMapper provides. In this blog post, we will look at another approach that relies on AcDbSubDMesh::setVertexTextureArray to set the texture mapping. If the SubDMesh was created using vertex and face information and you have an image that needs to be mapped, the "setVertexTextureArray" can be used to control the mapping.

Thanks to Erik Larsen from our AutoCAD engineering team for his help in getting the mapping right. Please note that the texture coordinates are normalized and does not depend on the actual image dimensions.

Here is a screenshot of an image mapped on to a box shaped SubDMesh.

Here is the code :

static void SubDMeshWithTexture()
{
	AcDbSubDMesh *ptrMesh = new AcDbSubDMesh();
		
	int imgWidth = 320;
	int imgHeight = 160;

	// We will create a box shaped SubDMesh
	// The four side put together match the 
	// image width. 
	// This will let us fully wrap the image on the box shaped mesh.
	int cx = imgWidth / 4;
	int cy = cx;
	int cz = imgHeight;

	double points[30];
	int triangles[24];

	// Vertices 
	points[0]=0.0; points[1]=0.0; points[2]=0.0;
	points[3]=cx; points[4]=0.0; points[5]=0.0;
	points[6]=cx; points[7]=cy; points[8]=0.0;
	points[9]=0.0; points[10]=cy; points[11]=5.0;

	points[12]=0.0; points[13]=0.0; points[14]=cz;
	points[15]=cx; points[16]=0.0; points[17]=cz;
	points[18]=cx; points[19]=cy; points[20]=cz;
	points[21]=0.0; points[22]=cy; points[23]=cz;

	points[24]=0.0; points[25]=0.0; points[26]=0.0;
	points[27]=0.0; points[28]=0.0; points[29]=cz;

	// Face information as triangles
	triangles[0]=0; triangles[1]=1; triangles[2]=5;
	triangles[3]=0; triangles[4]=5; triangles[5]=4;

	triangles[6]=7; triangles[7]=6; triangles[8]=2;
	triangles[9]=7; triangles[10]=2; triangles[11]=3;

	triangles[12]=6; triangles[13]=5; triangles[14]=1;
	triangles[15]=6; triangles[16]=1; triangles[17]=2;

	triangles[18]=8; triangles[19]=7; triangles[20]=3;
	triangles[21]=8; triangles[22]=9; triangles[23]=7;

	// Create the subDMesh using vertex and face data
	Acad::ErrorStatus es  = CreateSubDMesh
				(10, 8, points,triangles, ptrMesh);
	if(es == Acad::eOk)
	{
		AcDbObjectId meshId = AcDbObjectId::kNull;
		AcDbBlockTable*        pBlockTable;
		AcDbBlockTableRecord*  pSpaceRecord;

		AcDbDatabase *pDb = acdbCurDwg();

		pDb->getBlockTable(pBlockTable, AcDb::kForRead);
		pBlockTable->getAt(
			ACDB_MODEL_SPACE, 
			pSpaceRecord, AcDb::kForWrite);
		es = pSpaceRecord->appendAcDbEntity(
										meshId, ptrMesh);
		es = ptrMesh->close();

		es = pSpaceRecord->close();
		es = pBlockTable->close();

		AcDbEntity* pEnt = NULL;
		acdbOpenAcDbEntity(pEnt, meshId, AcDb::kForWrite);

		// Create a material with our custom image 
		// as its texture
		CreateMaterial(_T("Fusion"));

		AcDbSubDMesh *pSubDMesh = AcDbSubDMesh::cast(pEnt);
		if(pSubDMesh != NULL)
		{
			// Assign the material to the subDMesh
			pSubDMesh->setMaterial(L"Fusion", Adesk::kTrue);

			// Ensure the material mapping is as we expect
			// fully wrapped around the faces
			AcGePoint3dArray textureArray;
			textureArray.append(AcGePoint3d(0.0, 0.0, 0.0));
			textureArray.append(AcGePoint3d(0.25, 0.0, 0.0));
			textureArray.append(AcGePoint3d(0.5, 0.0, 0.0));
			textureArray.append(AcGePoint3d(0.75, 0.0, 0.0));
			textureArray.append(AcGePoint3d(0.0, 1.0, 0.0));
			textureArray.append(AcGePoint3d(0.25, 1.0, 0.0));
			textureArray.append(AcGePoint3d(0.5, 1.0, 0.0));
			textureArray.append(AcGePoint3d(0.75, 1.0, 0.0));

			textureArray.append(AcGePoint3d(1.0, 0.0, 0.0));
			textureArray.append(AcGePoint3d(1.0, 1.0, 0.0));

			pSubDMesh->setVertexTextureArray(textureArray);
		}
		pEnt->close();
	}
}

static Acad::ErrorStatus CreateSubDMesh(int numberOfPoints, 
									int numberOfTriangles,
									double *points,
									int *triangles, 
									AcDbSubDMesh *ptrMesh) 
{
	if((numberOfPoints <3) || (numberOfTriangles<1)) 
		return eNotImplementedYet;

	Acad::ErrorStatus es;
	AcGePoint3dArray *vertexArray 
			= new AcGePoint3dArray ();
	AcArray *faceArray 
			= new AcArray();

	vertexArray->setPhysicalLength(numberOfPoints*3);
	faceArray->setPhysicalLength(numberOfTriangles*3);

	for(int i=0; iappend(pt);
	}

	int id=-1;
	for(int i=0; iinsertAt(id,3); 
		
		id++; faceArray->insertAt(id,triangles[i*3]);

		id++; faceArray->insertAt(id,triangles[i*3+1]);

		id++; faceArray->insertAt(id,triangles[i*3+2]); 
	};

	es = ptrMesh->setSubDMesh(*vertexArray,*faceArray, 0);

	delete vertexArray;
	delete faceArray;

	return es;
}

static void CreateMaterial(
		const ACHAR* name, AcDbDatabase *pDb) 
{ 
	AcDbDictionary *pMaterialDict; 
	Acad::ErrorStatus es; 
	es = pDb->getMaterialDictionary(
		pMaterialDict, AcDb::kForWrite);
	if (es == Acad::eOk)
	{ 
        AcGiImageFileTexture tex;
		tex.setSourceFileName(
			_T("D:\\TestFiles\\FusionLogo.jpg"));
 
		double uScale = 1.0;
		double vScale = 1.0;
        double uOffset = 0;
		double vOffset = 0;
 
        AcGeMatrix3d mx;
		mx(0, 0) = uScale;
		mx(0, 1) = 0;
		mx(0, 2) = 0;
		mx(0, 3) = uScale * uOffset;

		mx(1, 0) = 0;
		mx(1, 1) = vScale;
		mx(1, 2) = 0;
		mx(1, 3) = vScale * vOffset;

		mx(2, 0) = 0;
		mx(2, 1) = 0;
		mx(2, 2) = 1;
		mx(2, 3) = 0;

		mx(3, 0) = 0;
		mx(3, 1) = 0;
		mx(3, 2) = 0;
		mx(3, 3) = 1;
			 
        AcGiMapper mapper;
		mapper.setProjection
			(AcGiMapper::Projection::kBox);
		mapper.setUTiling
			(AcGiMapper::Tiling::kCrop);
		mapper.setVTiling
			(AcGiMapper::Tiling::kCrop);
		mapper.setAutoTransform
			(AcGiMapper::AutoTransform::kNone);
		mapper.setTransform(mx);

        AcGiMaterialMap map;
		map.setSourceFileName(name);
		map.setTexture(&tex);
		map.setBlendFactor(1.0);
		map.setMapper(mapper);

		AcDbMaterial *pMaterialObj 
			= new AcDbMaterial(); 
		pMaterialObj->setName(name);

		AcDbObjectId materialId; 
		es = pMaterialDict->setAt
			(name, pMaterialObj, materialId); 

		AcGiMaterialColor diffuseColor; 
		pMaterialObj->setDiffuse
			(diffuseColor, map);
		pMaterialObj->setMode
			(AcGiMaterialTraits::kRealistic);

		pMaterialObj->close(); 
		pMaterialDict->close(); 
	} 
} 

MLeader text that reflects MLeaderStyle settings

By Balaji Ramamoorthy

Here is a short code snippet that creates an MLeader based on an existing MLeaderStyle. For the MLeader's text to correctly follow any changes made to the MLeaderStyle, it is necessary to clone the MLeaderStyle.DefaultText and use it as the MLeader's text. Creating a new MText without relying on the DefaultText can cause the text to not reflect any later changes that are made to the MLeaderStyle.

Thanks to Xin Xu from the AutoCAD engineering team for providing this tip.

[CommandMethod("MLTest")]
public void MLTestMethod()
{
    Editor ed = default(Editor);
    ed = Application.DocumentManager.MdiActiveDocument.Editor;

    PromptPointResult ppr1 = default(PromptPointResult);
    ppr1 = ed.GetPoint(
        new PromptPointOptions("Select start point"));

    if (ppr1.Status != PromptStatus.OK)
        return;

    PromptPointResult ppr2 = default(PromptPointResult);
    ppr2 = ed.GetPoint(
            new PromptPointOptions("Select end point"));
    if (ppr2.Status != PromptStatus.OK)
        return;

    Database db = HostApplicationServices.WorkingDatabase;

    ObjectId myMLeaderId = ObjectId.Null;
    using (Transaction trans 
                = db.TransactionManager.StartTransaction())
    {
        ObjectId myleaderStyleId = db.MLeaderstyle;
        MLeaderStyle mlstyle 
            = trans.GetObject(myleaderStyleId, 
                        OpenMode.ForRead) as MLeaderStyle;

        using (MLeader myMLeader = new MLeader())
        {
            myMLeader.SetDatabaseDefaults();
            myMLeader.PostMLeaderToDb(db);
            myMLeaderId = myMLeader.ObjectId;
            myMLeader.MLeaderStyle = db.MLeaderstyle;

            int leaderIndex = myMLeader.AddLeader();
            int leaderLineIndex 
                = myMLeader.AddLeaderLine(leaderIndex);
            myMLeader.AddFirstVertex(
                        leaderLineIndex, ppr1.Value);
            myMLeader.AddLastVertex(
                        leaderLineIndex, ppr2.Value);

            MText myMText 
                = mlstyle.DefaultMText.Clone() as MText;
            if (myMText != null)
            {
                myMText.SetContentsRtf("Autodesk");
                myMLeader.MText = myMText;
            }
        }
        trans.Commit();
    }
}

Batch rendering of drawings

By Balaji Ramamoorthy

In a recent query, a developer wanted to batch render drawings in AutoCAD. The API does support rendering to a file as explained in this blog post. But, if you do not want to code all that and would prefer running AutoCAD's Render command on a set of files, here is a code snippet to do that. This uses the AutoCAD's COM API to open the drawing, run the Render command and close it after its done. As the Render command in AutoCAD brings up the Render window, the following code snippet closes that window using Win32 API.

Here is a recording to show the Batch rendering of drawings in action :

Here is the code snippet :

#include 

#pragma warning( disable : 4278 )
// Change it if you use a different AutoCAD version
#import "acax19ENU.tlb" no_implementation raw_interfaces_only named_guids
using namespace AutoCAD; 
#pragma warning( default : 4278 )

#pragma pack (pop)


Acad::ErrorStatus es;
AcDbBlockTable *pBlockTable = NULL;

AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
		
HRESULT hr;

CStringArray m_arDrawingsToOpen ;
m_arDrawingsToOpen.SetSize(3);
m_arDrawingsToOpen[0] = "D:\\Temp\\RT1.dwg";
m_arDrawingsToOpen[1] = "D:\\Temp\\RT2.dwg";
m_arDrawingsToOpen[2] = "D:\\Temp\\RT3.dwg";

CWinApp* pWinApp = acedGetAcadWinApp(); 
if(! pWinApp) 
	return;
CComPtr pDisp = pWinApp->GetIDispatch(TRUE); 
if(! pDisp) 
	return;
			
CComPtr pComApp; 
hr = pDisp->QueryInterface(
    AutoCAD::IID_IAcadApplication,(void**)&pComApp); 
if(FAILED(hr)) 
	return;

CComPtr pDocs;
hr = pComApp->get_Documents(&pDocs);
if(FAILED(hr)) 
	return;
						
for (int index = 0; 
    index < m_arDrawingsToOpen.GetSize(); index++)
{
	CString strDrawingFile = m_arDrawingsToOpen[index];

	CComPtr pDispDoc;
	hr = pDocs->Open(CComBSTR(strDrawingFile), 
    CComVariant(true), CComVariant(NULL), &pDispDoc);

	if(SUCCEEDED(hr))
	{
		WaitUntilReady(pComApp);

		//;;Command
		//-RENDER
		//;;Specify render preset [Draft/Low/Medium/High/Presentation/Other] : 
		//Medium
		//;;Specify render destination [Render window/Viewport] : 
		//R
		//;;Enter output width <640>:
		//640
		//;;Enter output height <480>:
		//480
		//;;Save rendering to a file? [Yes/No] : 
		//Y
		//;;Specify output file name and path: 
		//D:\Temp\Test.png
		CString outFilePath;
		outFilePath.Format(ACRX_T("D:\\Temp\\Test%d.jpg"), index+1);

		CString cmd;
		cmd.Format(ACRX_T("-RENDER Medium R 640 480 Y %s\n"), outFilePath); 
		BSTR bstrCmd = cmd.AllocSysString();

		CFile file;
		CFileStatus status;
		if(file.GetStatus(outFilePath, status) == TRUE)
		{// Erase existing file, before proceeding to render
			CFile::Remove(outFilePath);
		}

		hr = pDispDoc->SendCommand(bstrCmd);

		::SysFreeString(bstrCmd);

		TCHAR windowText[MAX_PATH];
		GetWindowTextW(GetActiveWindow(), windowText, MAX_PATH);

		CString wndCaption;
		wndCaption.Format(ACRX_T("Test%d - Render"), index+1);

		if (! lstrcmpi(windowText, wndCaption))
		{
			SendMessage(GetActiveWindow(), WM_CLOSE, 0,0);
			acutPrintf(ACRX_T("\n%s window closed."), windowText);
		}

		_variant_t b(VARIANT_FALSE);
		hr = pDispDoc->Close(b);
	}
}


static Adesk::Boolean WaitUntilReady(CComPtr pComApp)
{
	HRESULT hr;
	Adesk::Boolean renderDone = Adesk::kFalse;
	int maxTries = 10;
	do
	{
		CComPtr pAcadState;
		hr = pComApp->GetAcadState(&pAcadState);
		if(SUCCEEDED(hr))
		{
			VARIANT_BOOL bReady = VARIANT_FALSE; 
			pAcadState->get_IsQuiescent(&bReady);
			if(bReady == VARIANT_TRUE)
			{
				return Adesk::kTrue;
			}
			else
				::Sleep(1000);
		}
		maxTries--;
	}while( (maxTries > 0) && ! renderDone);
	return Adesk::kFalse;
}

Linetype Preview image using AccoreConsole

By Balaji Ramamoorthy

If you need a preview image for a linetype to show in a picture box or for any other purpose, AccoreConsole should come in handy. To get this working, pass-in a blank drawing to AccoreConsole and have your plugin that loads in AccoreConsole load the linetype and create lines associated with that linetype. After the lines have been created, generate a preview image by plotting it as PNG.

Here is a sample code for the above steps and the script file that loads in AccoreConsole :

[CommandMethod("LTypePreview")]
public void LTypePreviewMethod()
{
    Document activeDoc = 
    Autodesk.AutoCAD.ApplicationServices.Core.Application.
    DocumentManager.MdiActiveDocument;
    Editor ed = activeDoc.Editor;

    String ltypeName = "BATTING";
    String linetypeFilePath = @"D:\Temp\acdb.lin";
    Database db = activeDoc.Database;

    using (Transaction trans 
                = db.TransactionManager.StartTransaction())
    {
        BlockTable bt = trans.GetObject(
            db.BlockTableId, 
            OpenMode.ForRead) as BlockTable;

        BlockTableRecord ms = trans.GetObject(
            bt[BlockTableRecord.ModelSpace], 
            OpenMode.ForWrite) as BlockTableRecord;

        LinetypeTable lineTypeTable = 
            trans.GetObject(
            db.LinetypeTableId, 
            OpenMode.ForRead) as LinetypeTable;

        bool isLinetypeLoaded 
                = lineTypeTable.Has(ltypeName);
        if (!isLinetypeLoaded)
        {// Not  loaded, try  loading the linetype
            db.LoadLineTypeFile(ltypeName, linetypeFilePath);
        }

        double ltScale = 30;
        ObjectId ltypeId = lineTypeTable[ltypeName];
        double incrx = 64.0;
        double incry = 48.0;
        for (int cnt = 0; cnt < 10; cnt++)
        {
            if (cnt == 0)
            {
                Line line = new Line(
                    new Point3d(0.0, 0.0, 0.0), 
                    new Point3d(640.0, 480.0, 0.0));
                line.LinetypeScale = ltScale;
                line.LinetypeId = ltypeId;
                ms.AppendEntity(line);
                trans.AddNewlyCreatedDBObject(line, true);
            }
            else
            {
                Line line1 = new Line(
                    new Point3d(cnt * incrx, 0.0, 0.0), 
                    new Point3d(640.0, (10 - cnt) * incry,
                    0.0));
                line1.LinetypeScale = ltScale;
                line1.LinetypeId = ltypeId;
                ms.AppendEntity(line1);
                trans.AddNewlyCreatedDBObject(line1, true);

                Line line2 = new Line(
                    new Point3d(0.0, cnt * incry, 0.0), 
                    new Point3d((10 - cnt) * incrx, 
                    480.0, 0.0));
                line2.LinetypeScale = ltScale;
                line2.LinetypeId = ltypeId;
                ms.AppendEntity(line2);
                trans.AddNewlyCreatedDBObject(line2, true);
            }
        }
        trans.Commit();
    }

    if (System.IO.File.Exists("D:\\Temp\\Test.png"))
    {
        System.IO.File.Delete("D:\\Temp\\Test.png");
    }

    string deviceName = "PublishToWeb PNG.pc3";
    string mediaName = "VGA (640.00 x 480.00 Pixels)";

    using (Transaction tr 
            = db.TransactionManager.StartTransaction())
    {
        BlockTableRecord btr 
            = tr.GetObject(db.CurrentSpaceId, OpenMode.ForRead)
            as BlockTableRecord;
        Layout lo = 
            tr.GetObject(btr.LayoutId, OpenMode.ForRead) 
            as Layout;

        PlotInfo pi = new PlotInfo();
        pi.Layout = btr.LayoutId;

        PlotSettings ps = new PlotSettings(lo.ModelType);
        PlotConfigInfo pci = new PlotConfigInfo();

        ps.CopyFrom(lo);
        ps.PlotPlotStyles = true;

        Extents2d windowpos 
            = new Extents2d(0.0, 0.0, 640.0, 480.0);
        PlotSettingsValidator psv 
            = PlotSettingsValidator.Current;
        psv.SetPlotWindowArea(ps, windowpos);
        psv.SetPlotType(ps, PlotType.Window);
        psv.SetUseStandardScale(ps, true);
        ps.PrintLineweights = true;
        psv.SetPlotConfigurationName
            (ps, deviceName, 
            mediaName.Replace(" ", "_"));
        psv.SetPlotCentered(ps, true);
        psv.SetStdScaleType(ps, 
            StdScaleType.ScaleToFit);
        psv.RefreshLists(ps);
        pi.OverrideSettings = ps;
        PlotInfoValidator piv 
            = new PlotInfoValidator();
        piv.Validate(pi);
        using (var pe 
            = PlotFactory.CreatePublishEngine())
        {
            pe.BeginPlot(null, null);
            pe.BeginDocument(pi, activeDoc.Name, 
                null, 1, true, "D:\\Temp\\Test.png");
            PlotPageInfo ppi = new PlotPageInfo();
            pe.BeginPage(ppi, pi, true, null);
            pe.BeginGenerateGraphics(null);
            pe.EndGenerateGraphics(null);
            pe.EndPage(null);
            pe.EndDocument(null);
            pe.EndPlot(null);
        }
        tr.Commit();
    }
}

Here are a few sample linetype preview images generated using AccoreConsole :

Docking toolbars in rows using CUI API

By Balaji Ramamoorthy

The toolbar creation and docking in AutoCAD API is exposed via the COM API. Although the toolbars can be docked using the COM API, it does not provide a way to arrange the docked toolbars as in multiple rows. AutoCAD internally uses a method that can dock toolbars to the desired location in rows, which is not exposed via the COM API.

A way to workaround it is to configure the workspace toolbars and set their arrangement using CUI API. Here is a sample code snippet that arranges the toolbars in the current workspace as shown in the following screenshot. All other toolbars in the current workspace are hidden. You can modify the code to show other toolbars if required.

Here is the toolbar arrangement that we seek :

Row : 0 Column : 0 - Smooth Mesh toolbar

Row : 1 Column : 0 - Smooth Mesh Primitives toolbar

Row : 0 Column : 1 - Draw toolbar

Row : 1 Column : 1 - Draw order toolbar

Row : 0 Column : 2 - Standard toolbar

Row : 1 Column : 2 - CAD Standard toolbar

 using  Autodesk.AutoCAD.Customization;

 [DllImport("accore.dll" , CharSet = CharSet.Ansi, 

 CallingConvention = CallingConvention.Cdecl, 

 EntryPoint = "acedCmdS" )]

 private  static  extern  int  acedCmdS(System.IntPtr vlist);

 [CommandMethod("SetDockedToolbars" )]

 public  void  SetDockedToolbarsMethod()

 {

     Document activeDoc 

 		= Application.DocumentManager.MdiActiveDocument;

     Database db = activeDoc.Database;

     Editor ed = activeDoc.Editor;

     string mainCuiFile = 

 		(string)Application.GetSystemVariable("MENUNAME" );

     mainCuiFile += ".cuix" ;

     CustomizationSection cs 

 		= new  CustomizationSection(mainCuiFile);

     string curWorkspace = 

 		(string)Application.GetSystemVariable("WSCURRENT" );

     Workspace ws = cs.getWorkspace(curWorkspace);  

     // Turn off all the workspace toolbars. 

     // We will later turn on the ones that we need and  

     // dock them as we desire 

     foreach (WorkspaceToolbar wsTb in ws.WorkspaceToolbars)

     {

         wsTb.Display = 0;

     }

     // Smooth Mesh toolbar 

     Toolbar tbSmoothMesh = 

 		cs.MenuGroup.Toolbars.

 		FindToolbarWithName("Smooth Mesh" );

     WorkspaceToolbar wsTbSmoothMesh = 

 		ws.WorkspaceToolbars.FindWorkspaceToolbar

 		(tbSmoothMesh.ElementID, cs.MenuGroup.Name);

     if (wsTbSmoothMesh == null)

     {

         wsTbSmoothMesh = new  WorkspaceToolbar(ws, tbSmoothMesh);

         ws.WorkspaceToolbars.Add(wsTbSmoothMesh);

     }

     wsTbSmoothMesh.Display = 1;

     wsTbSmoothMesh.ToolbarOrient = ToolbarOrient.left;

     wsTbSmoothMesh.DockRow = 0;

     wsTbSmoothMesh.DockColumn = 0;

     // Smooth Mesh Primitives toolbar 

     Toolbar tbSmoothMeshPrimitives 

 		= cs.MenuGroup.Toolbars.FindToolbarWithName

 		("Smooth Mesh Primitives" );

     WorkspaceToolbar wsTbSmoothMeshPrimitives 

 		= ws.WorkspaceToolbars.FindWorkspaceToolbar

 		(tbSmoothMeshPrimitives.ElementID, cs.MenuGroup.Name);

     if (wsTbSmoothMeshPrimitives == null)

     {

         wsTbSmoothMeshPrimitives = 

 			new  WorkspaceToolbar(ws, tbSmoothMeshPrimitives);

         ws.WorkspaceToolbars.Add(wsTbSmoothMeshPrimitives);

     }

     wsTbSmoothMeshPrimitives.Display = 1;

     wsTbSmoothMeshPrimitives.ToolbarOrient = ToolbarOrient.left;

     wsTbSmoothMeshPrimitives.DockRow = 1;

     wsTbSmoothMeshPrimitives.DockColumn = 0;

     // Draw toolbar 

     Toolbar tbDraw = 

 		cs.MenuGroup.Toolbars.FindToolbarWithName("Draw" );

     WorkspaceToolbar wsTbDraw = 

 		ws.WorkspaceToolbars.FindWorkspaceToolbar

 		(tbDraw.ElementID, cs.MenuGroup.Name);

     if (wsTbDraw == null)

     {

         wsTbDraw = new  WorkspaceToolbar(ws, tbDraw);

         ws.WorkspaceToolbars.Add(wsTbDraw);

     }

     wsTbDraw.Display = 1;

     wsTbDraw.ToolbarOrient = ToolbarOrient.left;

     wsTbDraw.DockRow = 0;

     wsTbDraw.DockColumn = 1;

     // Draw order toolbar 

     Toolbar tbDrawOrder = 

 		cs.MenuGroup.Toolbars.FindToolbarWithName("Draw Order" );

     WorkspaceToolbar wsTbDrawOrder = 

 		ws.WorkspaceToolbars.FindWorkspaceToolbar

 		(tbDrawOrder.ElementID, cs.MenuGroup.Name);

     if (wsTbDrawOrder == null)

     {

         wsTbDrawOrder = new  WorkspaceToolbar(ws, tbDrawOrder);

         ws.WorkspaceToolbars.Add(wsTbDrawOrder);

     }

     wsTbDrawOrder.Display = 1;

     wsTbDrawOrder.ToolbarOrient = ToolbarOrient.left;

     wsTbDrawOrder.DockRow = 1;

     wsTbDrawOrder.DockColumn = 1;

     // Standard toolbar 

     Toolbar tbStandard = 

 		cs.MenuGroup.Toolbars.FindToolbarWithName("Standard" );

     WorkspaceToolbar wsTbStandard = 

 		ws.WorkspaceToolbars.FindWorkspaceToolbar

 		(tbStandard.ElementID, cs.MenuGroup.Name);

     if (wsTbStandard == null)

     {

         wsTbStandard = new  WorkspaceToolbar(ws, tbStandard);

         ws.WorkspaceToolbars.Add(wsTbStandard);

     }

     wsTbStandard.Display = 1;

     wsTbStandard.ToolbarOrient = ToolbarOrient.left;

     wsTbStandard.DockRow = 0;

     wsTbStandard.DockColumn = 2;

     // CAD Standard toolbar 

     Toolbar tbCADStandards = 

 		cs.MenuGroup.Toolbars.FindToolbarWithName

 		("CAD Standards" );

     WorkspaceToolbar wsTbCADStandards 

 		= ws.WorkspaceToolbars.FindWorkspaceToolbar

 		(tbCADStandards.ElementID, cs.MenuGroup.Name);

     if (wsTbCADStandards == null)

     {

         wsTbCADStandards = 

 			new  WorkspaceToolbar(ws, tbCADStandards);

         ws.WorkspaceToolbars.Add(wsTbCADStandards);

     }

     wsTbCADStandards.Display = 1;

     wsTbCADStandards.ToolbarOrient = ToolbarOrient.left;

     wsTbCADStandards.DockRow = 1;

     wsTbCADStandards.DockColumn = 2;

     saveCui(cs);

 }

 public  static  void  saveCui(CustomizationSection cs)

 {

     if  (cs.IsModified)

         cs.Save();

     ResultBuffer rb = new  ResultBuffer();

     rb.Add(new  TypedValue(5005, "FILEDIA" ));

     rb.Add(new  TypedValue(5005, "0" ));

     acedCmdS(rb.UnmanagedObject);

     string cuiMenuGroup = cs.MenuGroup.Name;

     rb = new  ResultBuffer();

     rb.Add(new  TypedValue(5005, "_CUIUNLOAD" ));

     rb.Add(new  TypedValue(5005, cuiMenuGroup));

     acedCmdS(rb.UnmanagedObject);

     string cuiFileName = cs.CUIFileName;

     rb = new  ResultBuffer();

     rb.Add(new  TypedValue(5005, "_CUILOAD" ));

     rb.Add(new  TypedValue(5005, cuiFileName));

     acedCmdS(rb.UnmanagedObject);

 }

Rendering using RenderToImage API

By Balaji Ramamoorthy

As you may already know, the API for the graphics system changed in AutoCAD 2015 as explained in this blog post : Graphic changes in AutoCAD 2015. Also, AutoCAD 2016 renders using the RapidRT renderer that replaced the MentalRay renderer that was used by the previous AutoCAD releases. To account for this, the "AcDbRapidRTRenderSettings" class was introduced in ObjectARX 2016. All these changes requires changes in your code if you rely on "AcGsView::RenderToImage" method to generate an image of an AutoCAD model.

Here is a code that should help generate the rendered image in previous releases and in AutoCAD 2016. To accommodate the various graphics system changes and the renderer, the below code makes extensive use of conditional compilation.

To try this, open a drawing and set the viewing direction in AutoCAD based on how you wish to generate the rendered image. Setup the rendering presets and render it in AutoCAD. After you are convinced with the results, make the render settings as current. This should save the render presets as Active. The above code, retrieves the render settings based on the active render preset and uses it to generate the rendered image.

 static  void  AdskMyTestRTITest(void )

 {

 	AcDbDatabase *pDb 

 		= acdbHostApplicationServices()->workingDatabase();

 	AcGsManager *gsManager = acgsGetGsManager();

 	if  (! gsManager)

 		return ;

 	#ifdef  ACAD2016 // 2016 and later uses RapidRT renderer 

 		AcGsManager2 *gsManager2 

 			= dynamic_cast <AcGsManager2 *>(gsManager);

 		if  (! gsManager2)

 			return ;

 		AcGsKernelDescriptor descriptor;

 		descriptor.addRequirement(

 			AcGsKernelDescriptor::k3DRapidRTRendering);

 		AcGsGraphicsKernel *pGraphicsKernel 

 			= AcGsManager::acquireGraphicsKernel(descriptor);

 		AcGsDevice *offDevice 

 			= gsManager2->getOffScreenDevice(*pGraphicsKernel); 

 		if  (! offDevice)

 			return ;

 	#elif  ACAD2015 

 	// 2015 uses Mental Ray renderer. Includes GS API changes  

 		AcGsKernelDescriptor descriptor;

 		descriptor.addRequirement

 			(AcGsKernelDescriptor::k3DDrawing);

 		AcGsGraphicsKernel *pGraphicsKernel 

 			= AcGsManager::acquireGraphicsKernel(descriptor);

 		AcGsDevice *offDevice 

 			= pGraphicsKernel->createOffScreenDevice();

 		if  (! offDevice)

 			return ;

 	#else  // 2014 and earlier releases uses Mental ray renderer 

 		AcGsClassFactory *factory 

 			= gsManager->getGSClassFactory();

 		if  (! factory)

 			return ;

 		AcGsDevice *offDevice 

 			= factory->createOffScreenDevice();

 		if  (! offDevice)

 			return ;

 	#endif 

 	AcDbObjectId curVportId = AcDbObjectId::kNull;

 	int  width = 10, height = 10;

 	Adesk::IntDbId viewportObjectId;

 	LONG_PTR acadWindowId;

 	LONG_PTR viewportId;

 	if  (pDb->tilemode()) 

 	{// Modelspace 

 		curVportId = acedActiveViewportId();

 		struct  resbuf rb;

 		int  rt = acedGetVar(_T("CVPORT" ), &rb);

 		if (rt != RTNORM)

 			return ;

 		int  vportNum = rb.resval.rint;

 		AcDbObjectPointer<AcDbViewportTableRecord> 

 			curVTR (curVportId,AcDb::kForRead);

 		if (curVTR.openStatus() == Acad::eOk)

 		{

 			curVTR.close();

 		}

 		int  l,r,b,t;

 		acgsGetViewportInfo(vportNum,l,b,r,t);

 		height = t - b - 1;

 		width = r - l - 1;

 		viewportObjectId = curVportId.asOldId();

 		acadWindowId = vportNum;

 		viewportId = curVportId.asOldId();

 	} 

 	else  

 	{// Paperspace, but with a modelspace  

 		// activated in viewport 

 		curVportId = acedGetCurViewportObjectId();

 		AcDbObjectPointer<AcDbViewport> 

 			curVport (curVportId,AcDb::kForRead);

 		if (curVport->number() < 2)

 		{

 			AfxMessageBox(_T("For Render to work,  

 				modelspace in a viewport must be activated.")); 

 			return ;

 		}

 		int  l,r,b,t;

 		acgsGetViewportInfo(curVport->number(),l,b,r,t);

 		height = t - b - 1;

 		width = r - l - 1;

 		viewportObjectId = curVportId.asOldId();

 		acadWindowId = curVport->number();

 		viewportId = curVportId.asOldId();

 	}

 	offDevice->onSize(width, height);

 	#ifdef  ACAD2016

 		AcGsClientViewInfo info;

 		info.viewportId = viewportId;

 		info.acadWindowId = acadWindowId;

 		info.viewportObjectId = viewportObjectId;

 		AcGsView* pView = 

 		gsManager2->getOffScreenView(*pGraphicsKernel, info);

 	#elif  ACAD2015

 		AcGsView *pView = pGraphicsKernel->createView();

 		if  (! pView)

 			return ;

 	#else 

 		AcGsView *pView = factory->createView();

 		if  (! pView)

 			return ;

 	#endif 

 	acgsGetViewParameters(acadWindowId, pView);

 	offDevice->setDeviceRenderer(AcGsDevice::kFullRender);

 	offDevice->add(pView);

 	offDevice->update();

 	#if  defined (ACAD2016) || defined (ACAD2015)

 		AcGsModel *pModel 

 		= gsManager->createAutoCADModel(*pGraphicsKernel);

 	#else 

 		AcGsModel *pModel = gsManager->createAutoCADModel();

 	#endif 

 	if  (! pModel)

 		return ;

 	// Model space 

 	AcDbBlockTable *pBT = NULL;

 	AcDbBlockTableRecord *pBTR = NULL;

 	AcDbObjectId msId;

 	pDb->getBlockTable(pBT, AcDb::kForRead);

 	pBT->getAt(ACDB_MODEL_SPACE, msId);

 	pBT->close();

 	AcDbBlockTableRecordPointer spaceRec(msId, AcDb::kForRead);

 	if  (spaceRec.openStatus() != Acad::eOk)

 		return ;

 	pView->add(spaceRec, pModel);

 	spaceRec.close();

 	if  (pView != NULL)

 	{

 		pView->invalidate();

 		pView->update();

 	}

 	// get the filename to output 

 	struct  resbuf *result = NULL;

 	int  status = acedGetFileNavDialog(

 		_T("Render Image" ), 

 		NULL, 

 		_T("jpg;png;tif;bmp" ), 

 		_T("RenderImageDialog" ), 1, &result);  

 	if  (status == RTNORM)

 	{

 		ACHAR *pFileName = result->resval.rstring;

 		if  (! CreateAtilImage(

 			pView, width, height, 32, 0, pFileName))

 		AfxMessageBox(_T("Failed to create image..." ));

 	}

 	// now do the various GS clean up ops 

 	pView->eraseAll();

 	offDevice->erase(pView);

 	#if  defined (ACAD2016)

 		//pGraphicsKernel->deleteView(pView); 

 		pGraphicsKernel->deleteModel(pModel);

 		//pGraphicsKernel->deleteDevice(offDevice); 

 		AcGsManager::releaseGraphicsKernel(pGraphicsKernel);

 	#elif  ACAD2015

 		pGraphicsKernel->deleteView(pView);

 		pGraphicsKernel->deleteModel(pModel);

 		pGraphicsKernel->deleteDevice(offDevice);

 		AcGsManager::releaseGraphicsKernel(pGraphicsKernel);

 	#else 

 		factory->deleteView(pView);

 		factory->deleteModel(pModel);

 		factory->deleteDevice(offDevice);

 	#endif 

 }

 #ifdef  ACAD2016

 static   Acad::ErrorStatus GetActiveRapidRTRenderSetting

 	(AcDbRapidRTRenderSettings *&pRenderSetting)

 {

 	AcApDocument *pActiveDoc = acDocManager->mdiActiveDocument();

 	AcDbDatabase *pDB = pActiveDoc->database();

 	AcDbDictionary *pNODContainer = NULL;

 	Acad::ErrorStatus es 

 		= pDB->getNamedObjectsDictionary

 		(pNODContainer, 

 		AcDb::OpenMode::kForRead); 

 	AcDbObject *pMyDictObject = NULL;

 	if (pNODContainer->has(

 		ACRX_T("ACAD_RENDER_ACTIVE_RAPIDRT_SETTINGS" )))

 	{

 		es = pNODContainer->getAt(ACRX_T(

 			"ACAD_RENDER_ACTIVE_RAPIDRT_SETTINGS" ), 

 			pMyDictObject, AcDb::OpenMode::kForRead); 

 		AcDbObjectId myObjectId = AcDbObjectId::kNull;

 		if (es == Acad::eOk)

 		{

 			AcDbRapidRTRenderSettings *pRapidRTActiveSetting 

 				= AcDbRapidRTRenderSettings::cast(pMyDictObject);

 			if (pRapidRTActiveSetting != NULL)

 			{

 				pRenderSetting = new  AcDbRapidRTRenderSettings();

 				es = pRenderSetting->copyFrom(pRapidRTActiveSetting);

 			}

 			es = pRapidRTActiveSetting->close();

 		}

 	}

 	else 

 	{

 		acutPrintf(

 		ACRX_T("ACAD_RENDER_ACTIVE_RAPIDRT_SETTINGS not found !!" ));

 	}

 	pNODContainer->close();

 	return  Acad::eOk;

 }

 #else 

 static   Acad::ErrorStatus GetActiveRenderSetting

 	(AcDbMentalRayRenderSettings *&pRenderSetting)

 {

 	AcApDocument *pActiveDoc = acDocManager->mdiActiveDocument();

 	AcDbDatabase *pDB = pActiveDoc->database();

 	AcDbDictionary *pNODContainer = NULL;

 	Acad::ErrorStatus es = pDB->getNamedObjectsDictionary

 		(pNODContainer, AcDb::OpenMode::kForRead); 

 	AcDbObject *pMyDictObject = NULL;

 	if (pNODContainer->has(ACRX_T("ACAD_RENDER_ACTIVE_SETTINGS" )))

 	{

 		es = pNODContainer->getAt(

 			ACRX_T("ACAD_RENDER_ACTIVE_SETTINGS" ), 

 			pMyDictObject, AcDb::OpenMode::kForRead); 

 		AcDbObjectId myObjectId = AcDbObjectId::kNull;

 		if (es == Acad::eOk)

 		{

 			AcDbMentalRayRenderSettings 

 				*pMentalRayActiveSetting = 

 				AcDbMentalRayRenderSettings::cast(pMyDictObject);

 			if (pMentalRayActiveSetting != NULL)

 			{

 				pRenderSetting = new  AcDbMentalRayRenderSettings();

 				es = pRenderSetting->copyFrom(pMentalRayActiveSetting);

 			}

 			es = pMentalRayActiveSetting->close();

 		}

 	}

 	else 

 	{

 		acutPrintf(ACRX_T("ACAD_RENDER_ACTIVE_SETTINGS not found !!" ));

 	}

 	pNODContainer->close();

 	return  Acad::eOk;

 }

 #endif 

 static  bool  CreateAtilImage(AcGsView *pView, 

 						int  width, int  height, 

 						int  colorDepth, int  paletteSize, 

 						ACHAR *pFileName)

 {

 	bool  done = false ;

 	AcGsDCRect screenRect(0,width-1,0, height-1);

 	// we want colorDepth to be either 24 or 32 

 	if  (colorDepth < 24)

 		colorDepth = 24;

 	if  (colorDepth > 24)

 		colorDepth = 32;

 	// create rbgmodel 32 bit true color 

 	Atil::RgbModel rgbModel(colorDepth);

 	Atil::ImagePixel initialColor(rgbModel.pixelType());

 	// create the Atil image on the stack 

 	Atil::Image imgSource

 		(Atil::Size(width, height), 

 		&rgbModel, initialColor);

 	bool  ok = false ;

 	#ifdef  ACAD2016 // 2016 uses Rapid RT renderer 

 		AcDbRapidRTRenderSettings 

 			*pCurrentSetting = NULL;

 		Acad::ErrorStatus es 

 			= GetActiveRapidRTRenderSetting(pCurrentSetting);

 		if (pCurrentSetting != NULL)

 		{

 			ok = pView->renderToImage

 				(&imgSource, pCurrentSetting, 

 				nullptr , screenRect);

 			delete  pCurrentSetting;

 		}

 	#else  // 2015 and earlier releases uses Mental Ray renderer 

 		AcDbMentalRayRenderSettings *pCurrentSetting = NULL;

 		Acad::ErrorStatus es 

 			= GetActiveRenderSetting(pCurrentSetting);

 		if (pCurrentSetting != NULL)

 		{

 			ok = pView->RenderToImage

 				(&imgSource, pCurrentSetting, 

 				nullptr , screenRect);

 			delete  pCurrentSetting;

 		}

 	#endif 

 	if  (!ok)

 	{

 		AfxMessageBox(_T("Failed to RenderToImage" ));

 		return  false ;

 	}

 	else 

 	{

 		done = WriteImageToFile(&imgSource, pFileName); 

 	}

 	return  done;

 }

The sample project and a drawing with render presets configured can be downloaded here :

Download RTI

Download Torus_2016

Here is a screenshot of the rendered image that was created in AutoCAD 2016 using the RapidRT renderer :

Modifying an Associative Path Array using API

By Balaji Ramamoorthy

In this blog post, we will look at modifying an associative path array. A path array can either be using the item spacing or the item count depending on how the path array is configured in its properties. The below code snippet decrements the item count or increases the item spacing to reduce the number of items along the path.

Here is a recording and a code snippet :

 #include  "AcDbAssocManager.h" 

 #include  "AcDbAssocArrayActionBody.h" 

 #include  "AcDbAssocArrayPathParameters.h" 

 Acad::ErrorStatus es;

 ads_name ename; 

 ads_point pickPt;

 int  rc = acedEntSel(_T("\\nSelect Entity" ), ename, pickPt);

 if  (rc != RTNORM)

 	return ;

 AcDbObjectId entId; 

 acdbGetObjectId(entId, ename);

 AcDbObjectPointer <AcDbEntity> pEntity(entId, AcDb::kForRead);

 if ((es = pEntity.openStatus()) != Acad::eOk)

 	return ;

 if (! AcDbAssocArrayActionBody::isAssociativeArray(pEntity))

 {

 	acutPrintf(ACRX_T("\\nNot an associative array !" ));

 	return ;

 }

 AcDbObjectId actionBodyId 

 	= AcDbAssocArrayActionBody::getControllingActionBody(

 	pEntity, NULL);

 pEntity->close();

 AcDbAssocArrayActionBody* pArrayActionBody = NULL;

 if ( (es = acdbOpenAcDbObject(

 	(AcDbObject*&)pArrayActionBody, 

 	actionBodyId, 

 	AcDb::kForWrite)) != Acad::eOk)

 	return ;

 AcDbAssocArrayParameters *pAssocArrayParams 

 	= pArrayActionBody->parameters();

 AcDbAssocArrayPathParameters *pAssocArrayPathParams 

 	= AcDbAssocArrayPathParameters::cast(pAssocArrayParams);

 AcDbAssocArrayPathParameters::Method pathArrMethod 

 	= pAssocArrayPathParams->method();

 if (pathArrMethod 

 	== AcDbAssocArrayPathParameters::Method::kDivide)

 {

 	//The Divide method arranges the given number of items on the  

 	// entire path equidistantly.  

 	// So we will decrement the number of items along the path 

 	pAssocArrayPathParams->setItemCount

 		(pAssocArrayPathParams->itemCount() - 1);

 }

 else  if (pathArrMethod 

 	== AcDbAssocArrayPathParameters::Method::kMeasure)

 {

 	double  itemSpacingBefore 

 		= pAssocArrayPathParams->itemSpacing();

 	//The Measure method arranges the given number of items  

 	// using the specified item spacing along the path. 

 	pAssocArrayPathParams->setItemSpacing

 		(pAssocArrayPathParams->itemSpacing() * 1.1);

 	double  itemSpacingAfter 

 		= pAssocArrayPathParams->itemSpacing();

 	if (fabs(itemSpacingBefore-itemSpacingAfter) < 0.0001)

 	{// Reduce the number of items 

 		pAssocArrayPathParams->setItemCount

 			(pAssocArrayPathParams->itemCount() - 1);

 		pAssocArrayPathParams->setItemSpacing

 			(pAssocArrayPathParams->itemSpacing() * 1.1);

 	}

 }

 pArrayActionBody->close();

 AcDbAssocManager::evaluateTopLevelNetwork(entId.database());

 acedUpdateDisplay();

Setting orthographic view without affecting UCS

By Balaji Ramamoorthy

Here is a previous blog post on a similar topic for setting an orthographic view. The limitation with the code snippet posted in that blog post is that it modifies the active ViewportTableRecord and after the view change, the name of current UCS does not get displayed under the View Cube. When changing the view using AutoCAD's View Cube and switching to Top View, it only changes the view without affecting the UCS. Also, the X and Y axes are aligned horizontally and vertically. To get a similar behavior using the API, here is a code snippet that sets the viewing direction along +Z axis and aligns the X and Y axes just as the View Cube does.

 [DllImport("accore.dll" , 

     CallingConvention = CallingConvention.Cdecl, 

     EntryPoint = "acedTrans" )]

 private  static  extern  int  acedTrans(

     double [] point, 

     IntPtr fromRb, 

     IntPtr toRb, 

     int  disp, 

     double [] result);

 [CommandMethod("SetViewDir" )]

 public  static  void  SetViewDirMethod()

 {

     Document doc 

         = Application.DocumentManager.MdiActiveDocument;

     Database db = doc.Database;

     Editor ed = doc.Editor;

     Matrix3d ucs = ed.CurrentUserCoordinateSystem;

     using  (Transaction tr 

         = db.TransactionManager.StartTransaction())

     {

         ViewportTable vt = tr.GetObject(

             db.ViewportTableId, 

             OpenMode.ForWrite) as  ViewportTable;

         ViewportTableRecord activeVTR = 

             tr.GetObject(ed.ActiveViewportId, 

             OpenMode.ForRead) as  ViewportTableRecord;

         using  (ViewTableRecord vtr = new  ViewTableRecord())

         {

             vtr.Target = activeVTR.Target;

             vtr.ViewDirection = activeVTR.ViewDirection;

             vtr.Height = activeVTR.Height;

             vtr.CenterPoint = activeVTR.CenterPoint;

             vtr.ViewDirection = ucs.CoordinateSystem3d.Zaxis;

             ed.SetCurrentView(vtr);

         }

         tr.Commit();

     }

     ucs = ed.CurrentUserCoordinateSystem;

     double [] resVec = new  double [] { 0, 0, 0 };

     ResultBuffer rbFrom

         = new  ResultBuffer(new  TypedValue(5003, 0));

     ResultBuffer rbTo 

         = new  ResultBuffer(new  TypedValue(5003, 2));

     Vector3d yAxisUCS = ucs.CoordinateSystem3d.Yaxis;

     int  res = acedTrans(

         yAxisUCS.ToArray(),

         rbFrom.UnmanagedObject,

         rbTo.UnmanagedObject,

         1,

         resVec

     );

     Vector3d yAxisDCS 

         = new  Vector3d(resVec[0], resVec[1], resVec[2]);

     double  twistAngle 

         = (Math.PI * 0.5) 

         - Math.Atan2(yAxisDCS.Y, yAxisDCS.X);

     using  (ViewTableRecord vtr 

         = doc.Editor.GetCurrentView())

     {

         vtr.ViewTwist = twistAngle;

         ed.SetCurrentView(vtr);

     }

 }

Here is a screenshot of the View cube before and after the View change while retaining the UCS :