AutoCAD DevBlog

Integrating AutoCAD with Oculus Rift DK2

By Balaji Ramamoorthy

Oculus Rift DK2 provides a great virtual reality experience that is very immersive. In this blog post, I have attached a sample project that enables viewing solids from the drawing database for viewing in Oculus Rift. The code makes use of helper methods from the "Win32_DX11AppUtil" of the "OculusRoomTiny" sample which is included in the Oculus SDK. Some of the helper methods have also been modified to extend it for AutoCAD solids. Here is a short video before we look at the sample code.

Here is the relevant code snippet that renders the view. The full sample project can be downloaded here : Download OVRAutoCADSolids

 CAcModuleResourceOverride resourceOverride;

 gpDX11 = new  DirectX11();

 // Initializes LibOVR, and the Rift 

 ovrBool ovrInitialized = ovr_Initialize();

 HMD = ovrHmd_Create(0);

 if  (!HMD)

 { 

 	MessageBoxA(NULL,"Oculus Rift not detected." ,"" , MB_OK); 

 	return ;

 }

 if  (HMD->ProductName[0] ==  )

 {

 	MessageBoxA(NULL,

     "Rift detected, display not enabled." , 

     "" , MB_OK);

 }

 bool  windowed = (HMD->HmdCaps & ovrHmdCap_ExtendDesktop) 

                         ? false  : true ; 

 HINSTANCE hInstance = GetModuleHandle(NULL);

 CWinApp *app = acedGetAcadWinApp();

 CWnd *pWnd = app->GetMainWnd ();

 HWND hWndParent = pWnd->m_hWnd;

 gpDX11->InitWindowAndDevice(

                 hInstance, 

                 hWndParent, 

                 Recti(HMD->WindowsPos, HMD->Resolution), 

                 true );

 EnableWindow(hWndParent, FALSE);

 gpDX11->SetMaxFrameLatency(1);

 ovrHmd_AttachToWindow(HMD, gpDX11->Window, NULL, NULL);

 ovrHmd_SetEnabledCaps(

             HMD, 

             ovrHmdCap_LowPersistence | 

             ovrHmdCap_DynamicPrediction);

 ovrHmd_ConfigureTracking(HMD, 

             ovrTrackingCap_Orientation | 

             ovrTrackingCap_MagYawCorrection |

             ovrTrackingCap_Position, 0);

 for  (int  eye=0; eye<2; eye++)

 {

 	Sizei idealSize = ovrHmd_GetFovTextureSize(

                     HMD, (ovrEyeType)eye,

 					HMD->DefaultEyeFov[eye], 1.0f);

 	pEyeRenderTexture[eye] 

                 = new  ImageBuffer(true , false , idealSize);

 	pEyeDepthBuffer[eye]   

                 = new  ImageBuffer(

                         true , 

                         true , 

                         pEyeRenderTexture[eye]->Size);

 	EyeRenderViewport[eye].Pos  = Vector2i(0, 0);

 	EyeRenderViewport[eye].Size 

                 = pEyeRenderTexture[eye]->Size;

 }

 ovrD3D11Config d3d11cfg;

 d3d11cfg.D3D11.Header.API            

         = ovrRenderAPI_D3D11;

 d3d11cfg.D3D11.Header.BackBufferSize 

         = Sizei(HMD->Resolution.w, HMD->Resolution.h);

 d3d11cfg.D3D11.Header.Multisample    

         = 1;

 d3d11cfg.D3D11.pDevice               

         = gpDX11->Device;

 d3d11cfg.D3D11.pDeviceContext        

         = gpDX11->Context;

 d3d11cfg.D3D11.pBackBufferRT         

         = gpDX11->BackBufferRT;

 d3d11cfg.D3D11.pSwapChain            

         = gpDX11->SwapChain;

 if  (!ovrHmd_ConfigureRendering(HMD, &d3d11cfg.Config,

 	ovrDistortionCap_Chromatic | ovrDistortionCap_Vignette |

 	ovrDistortionCap_TimeWarp | ovrDistortionCap_Overdrive,

 	HMD->DefaultEyeFov, EyeRenderDesc))

 	return ;

 ovrHmd_DismissHSWDisplay(HMD);

 // Create the scene based on AutoCAD model  

 Acad::ErrorStatus es;

 AcDbDatabase *pDb 

     = acdbHostApplicationServices()->workingDatabase();

 AcDbBlockTable *pBlockTable;

 es = pDb->getSymbolTable(pBlockTable, AcDb::kForRead);

 AcDbBlockTableRecord *pMS = NULL;

 es = pBlockTable->getAt(

         ACDB_MODEL_SPACE, pMS, AcDb::kForRead);

 pBlockTable->close();

 Scene acadScene;

 AcDbBlockTableRecordIterator *pBTRIterator = NULL;

 es = pMS->newIterator(pBTRIterator);

 if  (es == Acad::eOk)

 {

     for  (pBTRIterator->start(); 

         ! pBTRIterator->done(); 

         pBTRIterator->step())

     {

 		AcDbEntity *pEnt = NULL;

         es = pBTRIterator->getEntity(

                         pEnt, AcDb::kForRead);

         if  (es == Acad::eOk)

         {

 			AcDb3dSolid *pSolid = NULL;

 			AcDbSubDMesh *pSubDMesh = NULL;

             if  (pSolid = AcDb3dSolid::cast(pEnt))

             {//solid 

 				AcDbFaceterSettings settings;

 				settings.faceterMeshType = 2;

 				AcDbExtents sldExtents;

 				es = pSolid->getGeomExtents(sldExtents);

 				AcGeVector3d dir = 

                 sldExtents.maxPoint() - sldExtents.minPoint();

                 settings.faceterMaxEdgeLength 

                                 = dir.length() * 0.02;

 				AcGePoint3dArray vertices;

 				AcArray<Adesk::Int32> faceArr; 

 				AcGiFaceData* faceData;

 				es = acdbGetObjectMesh(

                         pSolid, 

                         &settings, 

                         vertices, 

                         faceArr, 

                         faceData);

 				if  (faceData) 

 				{

 					delete [] faceData->trueColors(); 

 					delete [] faceData->materials();

 					delete faceData;

 				}

 				AcArray<MeshVertex> modelVertices;

 				AcArray<Adesk::Int32> modelFaceInfo;

 				try 

 				{

 					AcArray<Adesk::Int32> faceVertices;

 					int  verticesInFace = 0;

 					int  facecnt = 0;

 					for  (int  x = 0; x < faceArr.length(); 

                         facecnt++, x = x + verticesInFace + 1)

 					{

 						faceVertices.removeAll();

 						verticesInFace = faceArr[x];

 						for  (int  y = x + 1; 

                             y <= x + verticesInFace; y++)

 						{

 							faceVertices.append(faceArr[y]);

 						}

 						Adesk::Boolean continueCollinearCheck 

                                             = Adesk::kFalse;

 						do 

 						{

 							continueCollinearCheck 

                                         = Adesk::kFalse;

 							for  (int  index = 0; 

                             index < faceVertices.length(); 

                             index++)

 							{

 								int  v1 = index;

                                 int  v2 = 

                                 (index + 1) >= faceVertices.length() ? 

                                 (index + 1) - faceVertices.length() : 

                                 index + 1;

 								int  v3 = 

                                 (index + 2) >= faceVertices.length() ? 

                                 (index + 2) - faceVertices.length() : 

                                 index + 2;

 								// Check collinear 

 								AcGePoint3d p1 

                                 = vertices[faceVertices[v1]];

                                 AcGePoint3d p2 

                                 = vertices[faceVertices[v2]];

                                 AcGePoint3d p3 

                                 = vertices[faceVertices[v3]];

 								AcGeVector3d vec1 = p1 - p2;

 								AcGeVector3d vec2 = p2 - p3;

 								if  (vec1.isCodirectionalTo(vec2))

 								{

 									faceVertices.removeAt(v2);

 									continueCollinearCheck 

                                     = Adesk::kTrue;

 									break ;

 								}

 							}

 						} while  (continueCollinearCheck);

 						if  (faceVertices.length() == 3)

 						{

 							AcGePoint3d p1 

                             = vertices[faceVertices[0]];

                             AcGePoint3d p2 

                             = vertices[faceVertices[1]];

                             AcGePoint3d p3 

                             = vertices[faceVertices[2]];

 							AppendVertex(

                             modelVertices, 

                             modelFaceInfo, 

                             p1, p2, p3);

 						}

 						else  if  (faceVertices.length() == 4)

 						{

 							AcGePoint3d p1 

                             = vertices[faceVertices[0]];

                             AcGePoint3d p2 

                             = vertices[faceVertices[1]];

                             AcGePoint3d p3 

                             = vertices[faceVertices[2]];

 							AppendVertex(

                             modelVertices, 

                             modelFaceInfo, 

                             p1, p2, p3);

 							p1 = 

                             vertices[faceVertices[2]];

                             p2 = 

                             vertices[faceVertices[3]];

                             p3 = 

                             vertices[faceVertices[0]];

 							AppendVertex(

                             modelVertices, 

                             modelFaceInfo, 

                             p1, p2, p3);

 						}

 						else 

 						{

 							acutPrintf(

                             ACRX_T("Face with more than 4  

                             vertices will need triangulation 

                             to import in  Direct3D ")); 

 						}

 					}

 				}

 				catch (...)

 				{

 					acutPrintf(ACRX_T("Error !!" ));

 					return ;

 				}

 				AcDbHandle handle 

                 = pSolid->objectId().handle();

                 ACHAR sHandle[50];

 				handle.getIntoAsciiBuffer(sHandle);

 				AcGePoint3d minPt = sldExtents.minPoint();

 				AcGePoint3d maxPt = sldExtents.maxPoint();

 				COLORREF colorRef = RGB(255, 255, 255);

 				AcCmColor color = pSolid->color();

 				Adesk::UInt8 blue, green, red;

 				Adesk::UInt16 ACIindex;

 				long  acirgb, r,g,b; 

 				// get the RGB value as an Adesk::Int32 

 				Adesk::Int32 nValue = color.color();

 				// now extract the values 

 				AcCmEntityColor::ColorMethod cMethod;

 				cMethod = color.colorMethod();

 				Model::Color modelColor;

 				switch (cMethod)

 				{

 					case  AcCmEntityColor::kByColor :

 						blue = nValue;

 						nValue = nValue>>8;

 						green = nValue;

 						nValue = nValue>>8;

 						red = nValue;

 						modelColor.R = red;

 						modelColor.G = green;

 						modelColor.B = blue;

 						colorRef = RGB(red, green, blue);

 						break ;

 					case  AcCmEntityColor::kByACI :

 						ACIindex = color.colorIndex(); 

 						acirgb = acedGetRGB ( ACIindex );

 						r = ( acirgb & 0xffL ); 

 						g = ( acirgb & 0xff00L ) >> 8;

 						b = acirgb >> 16;

 						modelColor.R = r;

 						modelColor.G = g;

 						modelColor.B = b;

 						colorRef = RGB(r, g, b);

 						break ;

 					case  AcCmEntityColor::kByLayer :

 						break ;

 					default  :

 						break ;

 				}

 				acadScene.AppendCustomModel(

                 modelVertices, 

                 modelFaceInfo, 

                 modelColor);

 				modelVertices.removeAll();

 				modelFaceInfo.removeAll();

             }

             pEnt->close();

         }

     }

     delete pBTRIterator;

 }

 pMS->close(); 

 while  (!(gpDX11->Key[ ] && 

         gpDX11->Key[VK_CONTROL]) && 

         ! gpDX11->Key[VK_ESCAPE])

 {

 	gpDX11->HandleMessages();

 	ovrVector3f useHmdToEyeViewOffset[2] = 

     {EyeRenderDesc[0].HmdToEyeViewOffset,

 	EyeRenderDesc[1].HmdToEyeViewOffset};

 	ovrHmd_BeginFrame(HMD, 0);

 	// Keyboard inputs to adjust player orientation 

 	if  (gpDX11->Key[VK_LEFT])  Yaw += 0.02f;

 	if  (gpDX11->Key[VK_RIGHT]) Yaw -= 0.02f;

 	// Keyboard inputs to adjust player position 

 	if  (gpDX11->Key[ ]||gpDX11->Key[VK_UP])   

     Pos+=Matrix4f::RotationY(Yaw).

          Transform(Vector3f(0,0,-0.05f));

     if  (gpDX11->Key[ ]||gpDX11->Key[VK_DOWN]) 

     Pos+=Matrix4f::RotationY(Yaw).

         Transform(Vector3f(0,0,+0.05f));

 	if  (gpDX11->Key[ ])

         Pos+=Matrix4f::RotationY(Yaw).

         Transform(Vector3f(0,+0.05f,0));

     if  (gpDX11->Key[ ])

         Pos+=Matrix4f::RotationY(Yaw).

         Transform(Vector3f(0,-0.05f,0));

 	if  (gpDX11->Key[ ]) 

 		Pos.y+=0.05f;

 	if  (gpDX11->Key[ ])

 		Pos.y-=0.05f;

 	ovrPosef temp_EyeRenderPose[2];

 	ovrHmd_GetEyePoses(

             HMD, 0, 

             useHmdToEyeViewOffset, 

             temp_EyeRenderPose, NULL);

 	// Render the two undistorted eye views  

 	for  (int  eye = 0; eye < 2; eye++)

 	{

 		ImageBuffer * useBuffer

         = pEyeRenderTexture[eye];  

         ovrPosef    * useEyePose

         = &EyeRenderPose[eye];

         float  * useYaw

         = &YawAtRender[eye];

         bool  clearEyeImage  = true ;

 		bool  updateEyeImage = true ;

 		if  (clearEyeImage)

 			gpDX11->ClearAndSetRenderTarget(

             useBuffer->TexRtv,

 			pEyeDepthBuffer[eye], 

             Recti(EyeRenderViewport[eye]));

 		if  (updateEyeImage)

 		{

 			*useEyePose = temp_EyeRenderPose[eye];

 			*useYaw     = Yaw;

 			// Get view and projection matrices 

 			Matrix4f rollPitchYaw       

             = Matrix4f::RotationY(Yaw);

             Matrix4f finalRollPitchYaw

             = rollPitchYaw * Matrix4f(useEyePose->Orientation);

             Vector3f finalUp

             = finalRollPitchYaw.Transform(Vector3f(0, 1, 0));

             Vector3f finalForward

             = finalRollPitchYaw.Transform(Vector3f(0, 0, -1));

             Vector3f shiftedEyePos

             = Pos + rollPitchYaw.Transform(useEyePose->Position);

 			Matrix4f view = Matrix4f::LookAtRH(

             shiftedEyePos, shiftedEyePos + finalForward, 

             finalUp);

 			Matrix4f proj = ovrMatrix4f_Projection(

             EyeRenderDesc[eye].Fov, 0.2f, 1000.0f, true ); 

             Vector4f viewDir = Vector4f(finalForward, 1.0);

 			acadScene.Render(

             viewDir, 

             view, proj.Transposed());

 		}

 	}

 	// Do distortion rendering, Present and flush/sync 

 	ovrD3D11Texture eyeTexture[2]; 

 	for  (int  eye = 0; eye<2; eye++)

 	{

 		eyeTexture[eye].D3D11.Header.API

         = ovrRenderAPI_D3D11;

         eyeTexture[eye].D3D11.Header.TextureSize

         = pEyeRenderTexture[eye]->Size;

         eyeTexture[eye].D3D11.Header.RenderViewport 

         = EyeRenderViewport[eye];

         eyeTexture[eye].D3D11.pTexture

         = pEyeRenderTexture[eye]->Tex;

         eyeTexture[eye].D3D11.pSRView

         = pEyeRenderTexture[eye]->TexSv;

 	}

 	ovrHmd_EndFrame(

         HMD, 

         EyeRenderPose, 

         &eyeTexture[0].Texture);

 }

 EnableWindow(hWndParent, TRUE);

 // Release and close down 

 ovrHmd_Destroy(HMD);

 ovr_Shutdown();

 gpDX11->ReleaseWindow(hInstance);

 delete gpDX11;

 gpDX11 = NULL;

If you are already familiar with the "OculusRoomTiny" sample from the Oculus SDK, the following list of changes will make it easier for you to track the changes :

1. Includes code to add custom solid to the scene based on the meshed solids from AutoCAD

2. Included surface Normal input to the vertex and pixel shader to highlight edges. This works well if the solid color has all components such as R, G and B values.

3. Increased the number of solids in the scene to 20 and generalized it to accept variable number of vertices and indices.

Accessing AcGsView associated with viewport

By Balaji Ramamoorthy

In releases prior to AutoCAD 2015, the "acgsGetGsView" method provided access to the AcGsView of a viewport. In AutoCAD 2015, this method is not available and as a replacement, two other methods - "acgsGetCurrentAcGsView" and "acgsGetCurrent3dAcGsView" have been introduced. The sample code in this blog post and the comments are meant to clarify the differences and their usage.

 #include "acgs.h"

 // Prior to AutoCAD 2015 

 // Get the current viewport number 

 struct  resbuf  rb;

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

 if (rt != RTNORM)

 {

 	acutPrintf(_T("\\nError !" ));

 	return ;

 }

 int  vportNum = rb.resval.rint;

 // Get the GS View associated with the viewport 

 AcGsView *pView1 = acgsGetGsView

                         (vportNum, false );

 // If AutoCAD is in a shaded view,  

 // then pView will be non-null. 

 if (pView1)

 {   //'re in shaded mode OR  

 	// a GS view has been already been created  

     // and associated with viewport 

     acutPrintf(ACRX_T("We are in shaded mode..." ));

 }

 else 

 {

     //'re in a 2D wireframe or a GsView has not  

     // been created for this viewport ... 

 	// To create a GS View and associate with the  

     // viewport use : 

 	// AcGsView *pView2 = acgsGetGsView(vportNum, true); 

     //if(pView2 != NULL) 

     //{ 

     //    acutPrintf(ACRX_T("Created a 3D GS View  

     //            and associated with viewport..")); 

     //} 

 	acutPrintf(ACRX_T("We are in 2D wireframe mode..." ));

 }

 // For AutoCAD 2015+ 

 // Get the current viewport number 

 struct  resbuf  rb;

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

 if (rt != RTNORM)

 {

 	acutPrintf(_T("\\nError ! " ));

 	return ;

 }

 int  vportNum = rb.resval.rint;

 Acad::ErrorStatus es;

 // Returns a GS View regardless of 2D or 3D 

 AcGsView *pGsView1 = acgsGetCurrentAcGsView(vportNum);

 ASSERT(pGsView1 != NULL);

 // Returns a 3D GS view if a view is associated  

 // with the viewport. If not this will return null.  

 // But, a null value does not let us 

 // assume it is 2D Wireframe, as a 3d AcGsView can  

 // be created and associated with the viewport. 

 AcGsView *pGsView2 = acgsGetCurrent3dAcGsView(vportNum);

 if (pGsView2 != NULL)

 {

 	//'re in shaded mode OR  

 	// a 3D GS view has been created and  

     // associated with viewport 

 	acutPrintf(ACRX_T("We are in shaded mode..." ));

 }

 else 

 { 

 	//'re in a 2D wireframe and a 3D GS view has  

     // not been created yet... 

 	// Lets create a 3D GS View. 

 	// After the 3D GS view is created, both  

     // acgsGetCurrentAcGsView and  acgsGetCurrent3dAcGsView  

     // will return the newly created GS View. 

 	// To create a GS View and associate it with the  

     // viewport use : 

 	/* 

 	AcGsKernelDescriptor desc; 

 	desc.addRequirement( AcGsKernelDescriptor::k3DDrawing ); 

 	AcGsView* pView2 = acgsObtainAcGsView(vportNum, desc); 

 	if(pView2 != NULL) 

 	{ 

 		acutPrintf(ACRX_T("Created a 3D GS View  

                 and associated with viewport..")); 

 	} 

 	*/ 

 	acutPrintf(ACRX_T("We are in a 2D wireframe mode..." ));

 }

Adding Field to Text Programmatically

By Madhukar Moogala

We will see in this blog how can we set the contents of a AcDbText entity to a field linking to contents of another AcDbText.

Two APIs to be noted here,

1. AcFdMakeFieldCode, formats an object property field code using the specified components.
2. acdbEvaluateFields,evaluates all the fields in the objects in the database, similar to UpdateFields in the UI.

CString sPrompt(_T("\nSelect entity: "));

ads_name  an;

ads_point ap;

int nReturn = acedEntSel(sPrompt, an, ap);

// Canceled or nothing selected

if (nReturn == RTCAN)

{

return;

}

 

// Convert ads name to object id

AcDbObjectId id;

acdbGetObjectId(id, an);

 

AcTransaction* pTrans = acdbTransactionManager->startTransaction();

if (NULL == pTrans)

{

return;

}

 

AcDbText* pExistingText = NULL;

Acad::ErrorStatus es = acdbTransactionManager->getObject((AcDbObject*&)pExistingText, id, AcDb::kForRead);

if (!eOkVerify(es))

{

acdbTransactionManager->abortTransaction();

acedPrompt(_T("\nNot a text"));

return;

}

 

AcDbText* pText = new AcDbText();

pText->setPosition(

AcGePoint3d(pExistingText->position().x,

pExistingText->position().y+20.00,

pExistingText->position().z));

ads_name objName;

acdbGetAdsName(objName, id);

 

 

ACHAR* strField;

AcFdMakeFieldCode(id,(AcDbEvalNodeId)0,

                    _T("TextString"),

                    AcFdEval::kObjFieldNone,

                    _T(""),

                    (AcHyperlink*)NULL,

                    (ACHAR*&)strField);

pText->setTextString(strField);

 

AcDbBlockTableRecord* pModelSpace = NULL;

es = acdbTransactionManager->getObject((AcDbObject*&)pModelSpace,

acdbSymUtil()->blockModelSpaceId(

acdbHostApplicationServices()->workingDatabase()),

AcDb::kForWrite);

 

if (!eOkVerify(es))

{

acdbTransactionManager->abortTransaction();

acedPrompt(_T("\nCannot open model space."));

return;

}

 

AcDbObjectId outId;

es = pModelSpace->appendAcDbEntity(outId, pText);

if (!eOkVerify(es))

{

acdbTransactionManager->abortTransaction();

acedPrompt(_T("\nCannot append new entity."));

return;

}

pText->close();

/*Update Fields*/

es = acdbEvaluateFields(outId,

AcDbField::kRegen,

NULL,

acdbHostApplicationServices()->workingDatabase(),

AcFd::kEvalRecursive);

if(!eOkVerify(es))

{

CString esText = acadErrorStatusText(es);

esText = esText + _T(": Failed to Evalute");

acedAlert(esText);

}

/*Clean Up*/

acutDelString(strField);

acdbTransactionManager->endTransaction();

Identify the block editing mode in AutoCAD

By Virupaksha Aithal

In last couple of weeks we have received quires related to identifying the block editing state in AutoCAD. One approach to identify the state is to read the system variable “BLOCKEDITOR” using GetSystemVariable in .NET or using acedGetVar in ObjectARX. BLOCKEDITOR will be 1 if you are in block editing mode.

Reset Pipe tags

By Augusto Goncalves

On the UI it’s possible to select Pipes, erase the Tag (set as unassigned) and then set it back. In some cases, this is a workflow to fix tag problems on Pipes, that can reflect on ISO generation.

The idea of this code is: on the database level (DataLinksManager), get all the PipeRunComponents, Fasteners and P3dConnector, then finally Unrelate and Relate again. The purpose is to force Plant 3D to rebuild its structure and restore.

Thanks to Jorge Lopez (big) help on this!

Important: if you plan to use this, ensure you have a backup of your project.

[CommandMethod("tryFixPipeTag")]
public static void CmdTryFixLineTag()
{
  Editor ed = Application.DocumentManager.
    MdiActiveDocument.Editor;
 
  PlantProject currentProj = 
    PlantApplication.CurrentProject;
  PipingProject pipeProj = 
    (PipingProject)currentProj.ProjectParts["Piping"];
  DataLinksManager dlm = 
    pipeProj.DataLinksManager;
 
  PnPDatabase db = dlm.GetPnPDatabase();
 
  db.StartTransaction();
 
  int dwgRowId = dlm.GetDrawingId(
    Application.DocumentManager.MdiActiveDocument.Database);
  PnPRowIdArray groupIds = dlm.GetRelatedRowIds(
    "P3dDrawingLineGroupRelationship", "Drawing",
    dwgRowId, "LineGroup");
 
  foreach (int groupId in groupIds)
  {
    List<PnPRow> rowsToFix = new List<PnPRow>();
    PnPRow rowLineGroup = db.GetRow(groupId);
 
    string tag = rowLineGroup["Tag"] as string;
    if (string.IsNullOrWhiteSpace(tag)) continue;
 
    ed.WriteMessage("\n{0}", tag);
    System.Diagnostics.Debug.WriteLine(
      string.Format("\n{0}", tag));
 
    // Get pipe run components
    //
    PnPTable tblPipes = db.Tables["PipeRunComponent"];
    PnPRow[] rowsPipes = tblPipes.Select(
      string.Format("LineNumberTag='{0}'", tag));
 
    AddRowsToUniqueList(rowsToFix, rowsPipes);
 
    // Get fasteners
    //
    PnPTable tblFastener = db.Tables["Fasteners"];
    PnPRow[] rowsFastener = tblFastener.Select(
      string.Format("LineNumberTag='{0}'", tag));
 
    AddRowsToUniqueList(rowsToFix, rowsFastener);
 
    // Get P3dConnectors
    //
    PnPTable tblConnector = db.Tables["P3dConnector"];
    // just in case, make sure all rows are loaded in
    tblConnector.Select();  
 
    foreach (PnPRow rowFastener in rowsFastener)
    {
      PpObjectIdArray arr = dlm.FindAcPpObjectIds(rowFastener.RowId);
      foreach (PpObjectId ppId in arr)
      {
        PpObjectId ppConnectorId = new PpObjectId(
          ppId.DwgId, ppId.dbHandle, 0);
        int rowIdConnector = dlm.FindAcPpRowId(ppConnectorId);
        PnPRow jointRow = db.GetRow(rowIdConnector);
 
        AddRowToUniqueList(rowsToFix, jointRow);
      }
    }
 
    // Fix: Catches the following situations:
    //
    // 1. where tag does not match actual group
    // 2. when there is more than one group per part
    // 3. when the relationship is missing
    //
    foreach (PnPRow row in rowsToFix)
    {
      PnPRowIdArray priorGroupIds = 
        dlm.GetRelatedRowIds(
        "P3dLineGroupPartRelationship",
        "Part", row.RowId, "LineGroup");
      if (priorGroupIds.Count == 1 &&
        priorGroupIds.First.Value == rowLineGroup.RowId)
      {
        continue;
      }
 
      foreach (int id in priorGroupIds)
      {
        dlm.Unrelate("P3dLineGroupPartRelationship",
          "LineGroup", id, "Part", row.RowId);
      }
 
      dlm.Relate("P3dLineGroupPartRelationship", 
        "LineGroup", rowLineGroup.RowId, "Part", row.RowId);
    }
  }
 
  db.CommitTransaction();
}
 
private static void AddRowToUniqueList(
  List<PnPRow> rowsToFix, PnPRow jointRow)
{
  AddRowsToUniqueList(rowsToFix, new PnPRow[] { jointRow });
}
 
private static void AddRowsToUniqueList(
  List<PnPRow> rowsToFix, PnPRow[] rowsPipes)
{
  rowsToFix.AddRange(rowsPipes);
}

Creating transparent image using ATIL

By Balaji Ramamoorthy

Here is a sample code that implements a custom ATIL image filter to create transparent images. The implementation sets the Alpha channel for Red color pixels in the image. You can modify it to use any other RGB value if you choose. The complete sample project can be downloaded here : Download TransparentSnapShotUsingATIL

The sample project uses the "getSnapShot" to capture a snap shot of the entities selected. To try it,  build the attached sample project and load it in AutoCAD 2015. Open any drawing and run “GenImg” command and select the entity when prompted. The red background is intentionally set to the AcGsDevice while generating the screenshot. This is because, we can then use Red as the color to turn transparent from the image filter. The transparent image is generated under “D:\Temp\Test_Arx.png”.

Here is the relevant code :

//MyRgbaTransparency.h

 #ifndef  MYRGBATRANSPARENCY_H

 #define  MYRGBATRANSPARENCY_H

 class  MyRgbaTransparency 

 	: public  Atil::ImageFilter

 {

 public :

 	MyRgbaTransparency ( 

 		Atil::RowProviderInterface* pInput, 

 		int  nKeyColors, 

 		Atil::RgbColor* paKeyColors);

 	virtual  ~MyRgbaTransparency ();

 	virtual  int  rowsRemaining ();

 	virtual  void  getNextRow

 		(Atil::DataBuffer &oneRow);

 	virtual  void  convertColor

 		(Atil::ImagePixel& color) const ;

 private :

 	enum  By { kQuad, kTreble, kNon };

 	By mBy;

 	int  mnRows;

 	int  mnColumns;

 	int  mnKeyColors;

 	int  mnRowsRemaining;

 	Atil::RgbColor* mpKeyColors;

 };

 #endif

 //MyRgbaTransparency.cpp

 #include  "stdafx.h"

 #include  "MyRgbaTransparency.h"

 MyRgbaTransparency::MyRgbaTransparency

 	(Atil::RowProviderInterface* pInput, 

 	int  nKeyColors, 

 	Atil::RgbColor* paKeyColors )

 {

 	connectInput( pInput );

 	Atil::Size size(input(0)->size());

 	mnColumns = size.width;;

 	mnRows = size.height;

 	mnRowsRemaining = size.height;

 	mnKeyColors = nKeyColors;

 	switch (input(0)->dataModel().dataModelType())

 	{

 		case  Atil::DataModelAttributes

 			::DataModelType::kRgbModel:

 		{

 			mBy = kTreble;

 			init( size );

 			break ;

 		}

 		default :

 		{

 			mBy = kQuad;

 			init( size );

 			break ;

 		}

 	}

 }

 MyRgbaTransparency::~MyRgbaTransparency ()

 {

 }

 int  MyRgbaTransparency::rowsRemaining ()

 {

 	return  mnRowsRemaining;

 }

 void  MyRgbaTransparency::getNextRow

 	(Atil::DataBuffer &oneRow)

 {

 	input(0)->getNextRow(oneRow);

 	if  ( mnRowsRemaining > 0 ) 

 	{

 		if  ( mBy == kTreble ) 

 		{

 			Atil::RgbColor *pColor = 

 				(Atil::RgbColor*) oneRow.dataPtr();

 			for  (int  i=0; i<mnColumns; ++i) 

 			{

 				if ( pColor[i].rgba.red == 255 && 

 					pColor[i].rgba.blue == 0 && 

 					pColor[i].rgba.green == 0)

 				{// Turn alpha to 0 only for Red values

 					pColor[i].rgba.alpha = 0;

 				}

 			}

 		} 

 		--mnRowsRemaining;

 	}

 }

 void  MyRgbaTransparency::convertColor

 	(Atil::ImagePixel& color) const

 {

 	ImageFilter::convertColor(color);

 	switch  ( color.type )

 	{

 		case  Atil::DataModelAttributes::PixelType::kRgba:

 		{

 			Atil::RgbColor rgb( color.value.rgba );

 			if ( rgb.rgba.red == 255 

 				&& rgb.rgba.blue == 0 

 				&& rgb.rgba.green == 0)

 			{// Turn alpha to 0 only for Red values

 				rgb.packed = rgb.packed;

 				rgb.rgba.alpha = 0;

 				color.value.rgba = rgb;

 			}

 			break ;

 		}

 	}

 }

 // Usage of the Transparency Image filter

 Atil::RgbModel rgbModel(

 	Atil::RgbModelAttributes::k4Channels, 

 	Atil::DataModelAttributes::kRedGreenBlueAlpha);

 Atil::ImagePixel initialColor(

 	Atil::DataModelAttributes::PixelType::kRgba);

 initialColor.setToZero();

 initialColor.type = Atil::DataModelAttributes::kRgba;

 initialColor.value.rgba = 0xff000000;

 Atil::Image imgSource(

 	Atil::Size(width, height), 

 	&rgbModel, initialColor);

 // get a snapshot of the GsView

 pView->getSnapShot(&imgSource, screenRect.m_min);

 Atil::RowProviderInterface *pPipe 

 	= imgSource.read(

 		imgSource.size(), 

 		Atil::Offset(0,0),Atil::kBottomUpLeftRight);

 if (pPipe != NULL)

 {

 	Atil::RgbColor aColors[1];

 	COLORREF crBkg = RGB(255, 0, 0); 

 	aColors[0] = Atil::RgbColor(

 		GetRValue(crBkg), 

 		GetGValue(crBkg & 0xffff), 

 		GetBValue(crBkg), 0);

 	pPipe = new  MyRgbaTransparency(

 		pPipe, 

 		1, 

 		aColors);

 	if  (pPipe != NULL && pPipe->isValid()) 

 	{

 		TCHAR drive[_MAX_DRIVE];

 		TCHAR dir[_MAX_DIR];

 		TCHAR fname[_MAX_FNAME];

 		TCHAR ext[_MAX_EXT];	

 		// find out what extension we have

 		_tsplitpath_s(

 			pFileName, 

 			drive, dir, fname, ext);

 		Atil::ImageFormatCodec *pCodec = NULL;

 		if  (CString(ext) == _T(".png" ))

 			pCodec = new  PngFormatCodec();

 		if  (pCodec != NULL)

 		{

 			// and it is compatible

 			if  (Atil::FileWriteDescriptor::

 				isCompatibleFormatCodec(

 				pCodec, &(pPipe->dataModel()), 

 				pPipe->size())) 

 			{

 			// create a new file output object

 			Atil::FileWriteDescriptor fileWriter(pCodec);

 			Atil::FileSpecifier fs(

 				Atil::StringBuffer((lstrlen(pFileName)+1) 

 				* sizeof (TCHAR), 

 				(const  Atil::Byte *)pFileName, 

 				Atil::StringBuffer::kUTF_16), 

 				Atil::FileSpecifier::kFilePath);

 			// if the file already exists

 			// we better delete it because setFileSpecifier 

 			// will fail otherwise

 			_tremove(pFileName);

 			if  (fileWriter.setFileSpecifier(fs))

 			{

 				fileWriter.createImageFrame(

 					pPipe->dataModel(), 

 					pPipe->size());

 				// At any rate you want to fetch the property

 				// from the write file descriptor then alter 

 				// it and set it in\uc1\u8230?

 				Atil::FormatCodecPropertyInterface *pProp 

 					= fileWriter.getProperty(

 				Atil::FormatCodecPropertyInterface::kCompression);

 				if  (pProp != NULL) 

 				{

 				if  (CString(ext) == _T(".png" )) 

 				{

 					PngCompression *pComp = 

 						dynamic_cast <PngCompression*>(pProp);

 					if  (pComp != NULL) 

 					{

 					pComp->selectCompression(

 						PngCompressionType::kHigh);

 					fileWriter.setProperty(pComp);

 					}

 				}

 				// clean up

 				delete  pProp; 

 				pProp = NULL;

 				}

 			}

 			Atil::FormatCodecPropertySetIterator* pPropsIter

 				= fileWriter.newPropertySetIterator();

 			if  (pPropsIter)

 			{

 				for  (pPropsIter->start(); 

 					!pPropsIter->endOfList(); 

 					pPropsIter->step())

 				{

 					Atil::FormatCodecPropertyInterface* pProp

 						= pPropsIter->openProperty();

 					if  (pProp->isRequired())

 					{

 						fileWriter.setProperty(pProp);

 					}

 					pPropsIter->closeProperty();

 				}

 				delete  pPropsIter;

 			}

 			Atil::FormatCodecPropertyInterface 

 				*pTransparencyProp

 			= fileWriter.getProperty(

 			Atil::FormatCodecPropertyInterface::kTransparency);

 			if (pTransparencyProp)

 			{

 				fileWriter.setProperty(pTransparencyProp);

 			}

 			// ok - ready to write it

 			fileWriter.writeImageFrame(pPipe);

 			done = true ;

 			}

 		}

 		delete  pCodec;

 		}

 	}

 }