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.

DGNIMPORT to a new document and document switching

By Balaji Ramamoorthy

Recently, one of my colleague had this query :

• I am importing the DGN (not to the current drawing). This creates a new drawing and I want to switch to the new drawing and perform other commands. What is the best way to switch the current drawing to the other open drawing.

Here is a code snippet to do that.

The command that invokes the "DGNIMPORT", makes the newly imported document as Active. After the document is made active, you are in the new document’s context and to verify it, the editor.writemessage will output the message in the new document's command prompt.

[CommandMethod("Test1", CommandFlags.Session)]
public async static void Test1Method()
{
    DocumentCollection dm = Application.DocumentManager;
    Editor ed = 
    Application.DocumentManager.MdiActiveDocument.Editor;
    try
    {
        PromptResult promptDgnPath
                = ed.GetString("\nEnter DGN file name: ");
        if (promptDgnPath.Status != PromptStatus.OK)
            return;

        try
        {
            await dm.ExecuteInCommandContextAsync(
                async (obj) =>
                {
                    await ed.CommandAsync(new object[] 
                    { 
                        "_.-DGNIMPORT", 
                        promptDgnPath.StringResult, 
                        "Default", 
                        "Master", 
                        "Standard" 
                    });
                },
                null
            );
        }
        catch (System.Exception ex)
        {
            ed.WriteMessage("\nException: {0}\n", ex.Message);
        }

        DocumentCollection docs = Application.DocumentManager;
        foreach (Document doc in docs)
        {
            if (doc.Name.StartsWith("Drawing"))
            {
                Application.DocumentManager.MdiActiveDocument 
                                                        = doc;
                break;
            }
        }
        ed.WriteMessage("Hello !!");
    }
    catch (System.Exception ex)
    {
        ed.WriteMessage(ex.Message);
    }
}

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);

 }

Creating a Rectangular RevCloud using acedCommandS

By Balaji Ramamoorthy

When running the _RevCloud command from a script or using acedCommandS, the options presented in AutoCAD's command window did not match the options that one gets when running _RevCloud command in AutoCAD UI. The option to set the Revcloud type was not appearing when invoked from acedCommandS.

Here are screenshots of the options to show how they differed :

The following reason for this behavior was provided by Markus Kraus from our AutoCAD engineering team :

When driven from apps or from script, most AutoCAD commands default to their first command version (the version where the command has been introduced the first time in AutoCAD)

Here is a small code snippet that set the command version to get this working :

 Adesk::UInt8 cmdVerNew = 2;

 Adesk::UInt8 cmdVerOld 

 	= acedInitCommandVersion(cmdVerNew);

 AcGePoint2d ll(0.0, 0.0); 

 AcGePoint2d ur(4.0, 5.0);

 acedCommandS(RTSTR, _T("_.revcloud" ), 

 				RTSTR, _T("_R" ), 

 				RTSTR, _T("_A" ), 

 				RTREAL, 0.25, RTREAL, 0.75, 

 				RTPOINT, ll, RTPOINT, ur, RTNONE);

Such the command versioning can also be implemented for custom commands that you create. To do this, please refer to the ObjectARX documentation on "acedGetCommandVersion". Based on the command version, a custom command can vary in its functioning.

Creating coincident constraint between Line and Point

By Balaji Ramamoorthy

The High-Level API wrapper for creating constraints was created by my colleagues Philippe Leefsma and Gopinath Taget which simplifies the creation of constraints using the API. In a recent query, a developer reported that the library was not helping create a coincident constraint between a Line and a Point. After debugging through it, what was causing it to fail is that the Constraints library was created in a generic way that did not consider that the Point entity did not have edge sub-entities for it. Also, when creating a coincident constraint between two entities and one of them being a Point entity, the subentity path of the vertex is required to be added to the constraint group before the constrained geometry can be created.

Here are the changes to Constraints library :

 Acad::ErrorStatus AcDbAssoc2dConstraintAPI

 		::createCoincidentConstraint(

 	AcDbObjectId& entId1, 

 	AcDbObjectId& entId2, 

 	AcGePoint3d& ptEnt1, 

 	AcGePoint3d& ptEnt2)

 {

 	Acad::ErrorStatus es = Acad::eOk;

 	if ((es = AcDbAssocManager::initialize()) != Acad::eOk)

 		return  es;

 	AcDbFullSubentPathArray aPaths;

 	AcDbFullSubentPath edgeEntPath1;

 	if (entId1.objectClass() != AcDbPoint::desc())

 	{

 		if ((es = ADNAssocSampleUtils

 			::getClosestEdgeSubEntPath(

 			entId1, ptEnt1, 

 			edgeEntPath1)) != Acad::eOk)

 			return  es;

 		aPaths.append(edgeEntPath1); 

 	}

 	AcDbFullSubentPathArray aVertexPaths;

 	AcDbFullSubentPath vertEntPath1;

 	AcGePoint3d vertexPos1;

 	if ((es = ADNAssocSampleUtils

 		::getClosestVertexInfo

 		(entId1, edgeEntPath1, ptEnt1, 

 		vertexPos1, vertEntPath1)) != Acad::eOk)

 		return  es;

 	aVertexPaths.append(vertEntPath1);

 	if (entId1.objectClass() == AcDbPoint::desc())

 	{

 		aPaths.append(vertEntPath1); 

 	}

 	AcDbFullSubentPath edgeEntPath2;

 	if (entId2.objectClass() != AcDbPoint::desc())

 	{

 		if ((es = ADNAssocSampleUtils

 			::getClosestEdgeSubEntPath

 			(entId2, ptEnt2, edgeEntPath2)) != Acad::eOk)

 			return  es;

 		aPaths.append(edgeEntPath2); 

 	}

 	AcDbFullSubentPath vertEntPath2;

 	AcGePoint3d vertexPos2;

 	if ((es = ADNAssocSampleUtils

 		::getClosestVertexInfo

 		(entId2, edgeEntPath2, ptEnt2, vertexPos2, 

 		vertEntPath2)) != Acad::eOk)

 		return  es;

 	aVertexPaths.append(vertEntPath2);

 	if (entId2.objectClass() == AcDbPoint::desc())

 	{

 		aPaths.append(vertEntPath2); 

 	}

 	AcArray<AcConstrainedGeometry*> pConsGeoms;

 	if ((es = ADNAssocSampleUtils

 		::addConstrainedGeometry(aPaths, 

 		pConsGeoms)) != Acad::eOk)

 		return  es;

 	es = ADNAssocSampleUtils

 		::addGeomConstraint

 		(AcGeomConstraint::kCoincident, aVertexPaths);

 	return  es;

 }

 Acad::ErrorStatus ADNAssocSampleUtils

 	::getClosestVertexInfo(

 	const  AcDbObjectId& entId, 

 	const  AcDbFullSubentPath& edgeSubentPath, 

 	const  AcGePoint3d& pt, 

 	AcGePoint3d& closestVertexPos,

 	AcDbFullSubentPath& closestVertexSubentPath)

 {

 	Acad::ErrorStatus es;

 	AcDbSmartObjectPointer <AcDbEntity> 

 		pEntity(entId, AcDb::kForRead);

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

 		return  es;

 	if (pEntity->isKindOf(AcDbBlockReference::desc()))

 	{

 		return  ADNAssocSampleUtils

 			::getClosestVertexInfoBref(entId, 

 			edgeSubentPath, 

 			pt, 

 			closestVertexPos, 

 			closestVertexSubentPath);

 	}

 	AcDbAssocPersSubentIdPE* const  pAssocPersSubentIdPE = 

 		AcDbAssocPersSubentIdPE::cast

 		(pEntity->queryX(AcDbAssocPersSubentIdPE::desc()));

 	AcArray<AcDbSubentId> vertexSubentIds;

 	if  (pEntity->isKindOf(AcDbSpline::desc()))

 	{

 		AcDbSubentId startVertexSubentId;

 		AcDbSubentId endVertexSubentId;

 		AcArray<AcDbSubentId> controlPointSubentIds;

 		AcArray<AcDbSubentId> fitPointSubentIds;

 		if ((es = 

 			pAssocPersSubentIdPE->getSplineEdgeVertexSubentities

 			(pEntity,

 			AcDbSubentId(),

 			startVertexSubentId,

 			endVertexSubentId,

 			controlPointSubentIds,

 			fitPointSubentIds)) != Acad::eOk)

 			return  es;

 		vertexSubentIds.append(startVertexSubentId);

 		vertexSubentIds.append(endVertexSubentId);

 		vertexSubentIds.append(controlPointSubentIds);

 	}

 	else  if  (pEntity->isKindOf(AcDbPoint::desc()))

 	{

 		AcArray<AcDbSubentId> vertexSubentIds;

 		es = pAssocPersSubentIdPE->getAllSubentities

 			(pEntity, AcDb::kVertexSubentType, vertexSubentIds);

 		if  (vertexSubentIds.length() > 0)

 		{

 			closestVertexSubentPath 

 			= AcDbFullSubentPath(entId, vertexSubentIds[0]);

 			return  es;

 		}

 	}

 	else 

 	{	

 		AcDbSubentId startVertexSubentId;

 		AcDbSubentId endVertexSubentId;

 		if ((es = pAssocPersSubentIdPE->getEdgeVertexSubentities

 			(pEntity,

 			edgeSubentPath.subentId(),

 			startVertexSubentId,

 			endVertexSubentId,

 			vertexSubentIds)) != Acad::eOk)

 			return  es;

 		vertexSubentIds.append(startVertexSubentId);

 		vertexSubentIds.append(endVertexSubentId);

 	}

 	double  minDist = -1.0;

 	AcDbSubentId closestId;

 	for (int  i=0; i<vertexSubentIds.length(); ++i)

 	{

 		AcGePoint3d vertexPos;

 		if  ((es = pAssocPersSubentIdPE->

 			getVertexSubentityGeometry(pEntity, 

 			vertexSubentIds[i],

 			vertexPos)) != eOk)

 			return  es;

 		double  dist = vertexPos.distanceTo(pt);

 		if (minDist < 0 || dist < minDist)

 		{

 			minDist = dist;

 			closestId = vertexSubentIds[i];

 			closestVertexPos = vertexPos;

 		}

 	}

 	closestVertexSubentPath 

 		= AcDbFullSubentPath(entId, closestId);

 	return  es;

 }