ARX_插入图片（dwg，dxf，png等）

最新推荐文章于 2021-04-04 23:04:40 发布

weixin_34242658

最新推荐文章于 2021-04-04 23:04:40 发布

阅读量785

点赞数

文章标签：数据库 python

原文链接：https://my.oschina.net/u/2930533/blog/1824127

版权

2019独角兽企业重金招聘Python工程师标准>>>

先封装一个函数

.h
//xform  插入点;dScale  比例;pBlockId    图块ID
//nBasePos  插入的基点，0：以DWG图形最左下点为基点，1：右下，2：右上，3：左上，4：原图(0,0)点
bool InsertDwg(const AcGePoint3d & xform, AcDbDatabase* pSrc, LPCTSTR lpLayer/*=NULL*/, double dScale=1.0/*比例*/, int nBasePos=0, bool bIsDWGMoveToOrignFirst=true, AcDbObjectId* pBlockId=NULL, double dAngle = 0.0);

.cpp
bool InsertDwg(const AcGePoint3d & xform, AcDbDatabase* pSrc, LPCTSTR lpLayer/*=NULL*/, double dScale/*=1.0比例*/, int nBasePos/*=0*/, bool bIsDWGMoveToOrignFirst/*=true*/, AcDbObjectId* pBlockId/*=NULL*/, double dAngle/* = 0.0*/)
{
	AcAxDocLock docLock(m_pDb);
	pSrc->updateExt();
	// 得到图形左下和右上角点
	AcGePoint3d p1(pSrc->extmin());
	AcGePoint3d p2(pSrc->extmax());
	// 取得DWG中所有元素
	AcDbObjectId blockId;
	HHVerifyErr2(m_pDb->insert(blockId, GenGUID(), pSrc),return false;);
	AcDbBlockReference* pBlockReference = new AcDbBlockReference ( AcGePoint3d(0.0,0.0,0.0), blockId);
	AddEntity(pBlockReference, pBlockId)
{
delete pBlockReference;
return false;
}
	// 设图层
	if ( lpLayer != NULL )
	{
		AcDbObjectId mLayerId;
		if ( !GetLayerId(lpLayer, mLayerId) )
		{
			AddLayer(lpLayer, &mLayerId);
		}
		pBlockReference->setLayer(mLayerId);
	}

	// 设比例
	if ( fabs(dScale-1.0) > 1e-6 )
	{
		AcGeScale3d scale(dScale);
		HHVerifyErr(pBlockReference->setScaleFactors(scale));
		p1.scaleBy(dScale);
		p2.scaleBy(dScale);
	}
	if ( !bIsDWGMoveToOrignFirst )
		p1 = AcGePoint3d(0.0,0.0,0.0);

	// 计算坐标
	switch (nBasePos)
	{
	default:
	case 0:// 左下
		break;
	case 1:// 右下
		p1.x = p2.x;
		break;
	case 2:// 右上
		p1 = p2;
		break;
	case 3:// 左上
		p1.y = p2.y;
		break;
	case 4:// 元坐标
		p1.x = 0.0;
		p1.y = 0.0;
		break;
	case 5:
		p1.x += (p2.x - p1.x) / 2.0;
		p1.y += (p2.y - p1.y) / 2.0;
	}

	pBlockReference->transformBy(xform-p1);

	AcGeMatrix3d matrix = matrix.rotation(dAngle,zAxis,xform);
	pBlockReference->transformBy(matrix);

	pBlockReference->close();
	return true;
}

1.dxf格式的

CString strFilePath;//dxf文件路径
AcDbDatabase mDb(false, true);
Acad::ErrorStatus es = mDb.dxfIn(strFilePath);
if (es != Acad::eOk)
{
	HHTalkBox(_T("读入dxf文件失败！"));
	return;
}

LPCTSTR lpLayer;//插入图层
AcAxDocLock lock;
InsertDwg(ptReference, &mDb, lpLayer, 1, 0, false, &mId);

2.dwg格式的

AcAxDocLock lock;
// 分配
AcDbDatabase* pDb = new AcDbDatabase(Adesk::kFalse, true);
if(pDb==NULL)
return false;
if(!pDb->readDwgFile(lpDWG, _SH_DENYNO))
{
delete pDb;
return false;
}

LPCTSTR lpLayer;//插入图层
InsertDwg(xform, pDb, lpLayer, dScale, nBasePos, bIsDWGMoveToOrignFirst, pBlockId, dAngle);
delete pDb;

3.图片格式的（*.jpg;*.gif;*.bmp;*.png）

// 计算图片大小
Gdiplus::Bitmap img(strPrjPath);
double dWidth = img.GetWidth()/img.GetHorizontalResolution()*25.4;
double dHeight = img.GetHeight()/img.GetVerticalResolution()*25.4;

// 插入图片
AcAxDocLock lock;
CImageSupportModule	ISM(m_pDb);
	AcDbObjectId tempId;
	if (pId == NULL)
		pId = &tempId;
	// attach image
	Acad::ErrorStatus es = ISM.NewImageAttach(lpJpgPath,*pId);	// returns Entity Id.
	if (es != Acad::eOk)
	{
		assert(false);
		acutPrintf(_T("Error: Attach example image failed.\n")); 
		return false;
	}

	AcDbObjectId oid = *pId;
	AcDbObjectPointer<AcDbRasterImage> imgPtr(oid,kForWrite);
	AcGeMatrix3d mtx;
	mtx.setToTranslation(mPtLB.asVector());	
	
	AcDbExtents ext ;
	imgPtr->getGeomExtents(ext);

	AcGeVector3d origsize = ext.maxPoint() - ext.minPoint();	
	AcGeVector3d newSize = mPtRT - mPtLB;

	double ratioX = newSize.x / origsize.x;
	double ratioY = newSize.y / origsize.y;

	double ratioResult = min(ratioX,ratioY);
	AcGeMatrix3d scaleMtx = AcGeMatrix3d::scaling(ratioResult,mPtLB);

	mtx.preMultBy(scaleMtx);
    imgPtr->transformBy(mtx);

	AcGePoint3dArray ptArr;
	imgPtr->getStretchPoints(ptArr);
	if (4==ptArr.length())
	{
		AcDbExtents extsPost;
		imgPtr->getGeomExtents(extsPost);
		AcGeVector3d vecOffset = mPtRT -extsPost.maxPoint();
		AcDbIntArray ptIndex;
		if (ratioX-ratioY>1e-6)
		{
			ptIndex.append(2);
			ptIndex.append(3);
		}
		else
		{
			ptIndex.append(1);
			ptIndex.append(2);
		}

		imgPtr->moveStretchPointsAt(ptIndex,vecOffset);
	}

	if ( vmRoat!=NULL )
		imgPtr->transformBy(*vmRoat);

	// 设置图层 
	AcDbObjectId acdIdLayer;
	if ( !GetLayerId(lpLayer, acdIdLayer) )
	{
		HHVerify(AddLayer(lpLayer, &acdIdLayer));
	}
	imgPtr->setLayer(acdIdLayer);



class CImageSupportModule
{
public:
	CImageSupportModule(AcDbDatabase* pDb);
	virtual ~CImageSupportModule(void);

public:
	// Attaches an new Image
	virtual Acad::ErrorStatus	NewImageAttach					(const CString& strImgPath, AcDbObjectId & parEntityId);
	// Manipulate Image
	virtual Acad::ErrorStatus	Manipulate						(AcDbObjectId   parEntityId);

	virtual Acad::ErrorStatus   SetPos                          (const AcDbObjectId& id, const AcGePoint3d& ptLB, const AcGePoint3d& ptRT);


	// Create Objects
	virtual Acad::ErrorStatus	CreateAcDbRasterImage			(AcDbObjectId & parEntityId, AcDbObjectId parObjectId);
	// creates the entity
	virtual Acad::ErrorStatus	CreateAcDbRasterImageDef		(AcDbObjectId &	parObjectId, CString parImageName, CString parImagePath);
	// creates the definition
	virtual Acad::ErrorStatus	CreateAcDbRasterImageDefReactor	(AcDbObjectId & parReactorId, AcDbObjectId parObjectId, AcDbObjectId parEntityId);
	// creates the reactor


	// Utilities Method
	virtual	Acad::ErrorStatus	AppendToPaperOrModelSpace		(AcDbEntity* parEntity, Adesk::Boolean parbToPaperSpace);

	// delete image attach
	virtual Acad::ErrorStatus DeleteImageDef(const ACHAR* pImageName);

private:
	CString m_strImagePath;
	AcDbDatabase* m_pDb;
};


#include "StdAfx.h"
#include "ImageSupportModule.h"
#include "FilteredEntityCollector.h"


using namespace EntityFilter;
CImageSupportModule::CImageSupportModule(AcDbDatabase* pDb)
: m_pDb(pDb)
{
	if (m_pDb == NULL)
	{
		m_pDb = acdbHostApplicationServices()->workingDatabase();
	}
}

CImageSupportModule::~CImageSupportModule(void)
{
}

//	
//	description:	Create image definition object.
//					Create image entity.
//					Create image reactor.
//
//	parameter:		parEntityId		Returns the object Id of the RasterImage.
//
//
//	problems:		The image path has to be updated in the newImageAttach method.
//					Or the image path has to be set in the preference project directory
//					of Acad and set it to the current project.
//
Acad::ErrorStatus CImageSupportModule::NewImageAttach (const CString& strImgPath, AcDbObjectId& parEntityId)
{
	CString	ImageName;
	int iIndex = strImgPath.ReverseFind('\\');
	if (iIndex != -1)
	{
		ImageName = strImgPath.Right(strImgPath.GetLength()-iIndex-1);
		ImageName = ImageName.Left(ImageName.GetLength()-4);
	}

	// Create image definition object.
	AcDbObjectId ObjectId;
	Acad::ErrorStatus es = CreateAcDbRasterImageDef(ObjectId, ImageName, strImgPath);
	if (es != Acad::eOk)		return es;

	// Create image entity.
	es = CreateAcDbRasterImage(parEntityId, ObjectId);
	if (es != Acad::eOk)		return es;

	// Create image reactor.
	AcDbObjectId 	ReactorId;			// AcDbRasterImageDefReactor Id
	es = CreateAcDbRasterImageDefReactor (ReactorId, ObjectId, parEntityId);
	if (es != Acad::eOk)		return es;

	return es;
}

//	description:	Create a new image entity.
//					Set Defintion id in Entity. ( link it to the specified image definition object)
//					Appends the entity to model space.
//					Set Entity ID to Attribute.
//
//	parameter:		parEntityId		Returns object Id of the created RasterImage.
//					parObjectId		Object Id of the RasterImageDef.
//
//
Acad::ErrorStatus CImageSupportModule::CreateAcDbRasterImage (AcDbObjectId & parEntityId, AcDbObjectId   parObjectId)
{
	AcDbRasterImage* pAcDbRasterImage = new AcDbRasterImage;
	if ( pAcDbRasterImage == NULL)
		return Acad::eNullEntityPointer;

	// Set Defintion id in Entity. ( link it to the specified image definition object)
	Acad::ErrorStatus es = pAcDbRasterImage->setImageDefId(parObjectId);
	if (es != Acad::eOk)
	{
		delete pAcDbRasterImage;
		return es;
	}

	// Appends the entity to model space.
	es = AppendToPaperOrModelSpace ((AcDbEntity*) pAcDbRasterImage, Adesk::kFalse);
	if (es != Acad::eOk) 
	{
		delete pAcDbRasterImage;
		return es;
	}

	// Set Entity ID to Attribute.
	parEntityId = pAcDbRasterImage->objectId();

	pAcDbRasterImage->close();

	return es;
}


//	description:	Create reactor.
//					Set the entity to be its owner.
//					Link it to the definition object.
//					Set Reactor Id.
//					Adds the database resident object to the reactor list of the object.
//
//	parameter:		parReactorId	Returns object Id of the created RasterImageDefReactor. 
//					parObjectId		Object Id of the RasterImageDef.
//					parEntityId		Object Id of the RasterImage.
//
Acad::ErrorStatus CImageSupportModule::CreateAcDbRasterImageDefReactor (AcDbObjectId & parReactorId, 
																	  AcDbObjectId   parObjectId, 
																	  AcDbObjectId   parEntityId)
{
	// Disable image definition notification while changing the defintion reactor list.
	AcDbRasterImageDefReactor::setEnable(Adesk::kFalse);

	// open Definition
	AcDbRasterImageDef*	pAcDbRasterImageDef = NULL;
	Acad::ErrorStatus es = acdbOpenObject((AcDbObject*&) pAcDbRasterImageDef, parObjectId, AcDb::kForWrite);
	if (es != Acad::eOk)		return es;

	AcDbRasterImage* pAcDbRasterImage = NULL;
	es = acdbOpenObject((AcDbObject*&) pAcDbRasterImage, parEntityId, AcDb::kForWrite);
	if (es != Acad::eOk) 
	{
		pAcDbRasterImageDef->close();
		return es;
	}

	// Create reactor.
	AcDbRasterImageDefReactor* pAcDbRasterImageDefReactor = new AcDbRasterImageDefReactor;			
	if (pAcDbRasterImageDefReactor == NULL)
	{
		pAcDbRasterImage->close();
		pAcDbRasterImageDef->close();
		return Acad::eNullObjectPointer;
	}

	// Set the entity to be its owner.
	es = pAcDbRasterImageDefReactor->setOwnerId( parEntityId);
	if (es != Acad::eOk) 
	{
		pAcDbRasterImage->close();
		pAcDbRasterImageDef->close();
		delete pAcDbRasterImageDefReactor;
		return es;
	}

	// Link it to the definition object.
	es = m_pDb->addAcDbObject( parReactorId, pAcDbRasterImageDefReactor);
	if (es != Acad::eOk) 
	{
		pAcDbRasterImage->close();
		pAcDbRasterImageDef->close();
		delete pAcDbRasterImageDefReactor;
		return es;
	}

	// Set Reactor Id.
	pAcDbRasterImage->setReactorId( parReactorId);

	// Adds the database resident object to the reactor list of the object.
	pAcDbRasterImageDef->addPersistentReactor(parReactorId);

	pAcDbRasterImageDefReactor->close();
	pAcDbRasterImageDef->close();
	pAcDbRasterImage->close();

	// Re-enable image def notification.
	AcDbRasterImageDefReactor::setEnable(Adesk::kTrue);

	return es;
}

// ___ createAcDbRasterImageDef ________________________________________________________________________
//	
//	description:	Create new image def object
//					set source file name
//					load image
//					Get Dictionary Id.
//					Check if image name already in use.
//
//	parameter:		parObjectId		Returns object Id of the created RasterImageDef.
//					parImageName	Name of the image.
//					parImagePath	Path of the image.
//
//	return value:	ErrorStatus
//					Returns Acad::eOk if successfull.
//					Acad::eNullObjectPointer	failed to initialize entity.
//					Acad::eHandleInUse	image name in use.
//					And error states of this classes: AcDbDictionary, AcDbRasterImageDef, 
//					and the function acdbOpenObject.
//
//	problems:		.
Acad::ErrorStatus CImageSupportModule::CreateAcDbRasterImageDef (AcDbObjectId &	parObjectId, 
																 CString		parImageName, 
																 CString		parImagePath)
{
	Acad::ErrorStatus es = eOk;
	// Get Dictionary Id.
	AcDbObjectId DictionaryId = AcDbRasterImageDef::imageDictionary(m_pDb);
	if (DictionaryId.isNull()) 
	{
		// Create dictionary
		es = AcDbRasterImageDef::createImageDictionary(m_pDb, DictionaryId);
		if (es!= Acad::eOk)
		{			
			return es;
		}
	}

	//es = acdbOpenObject((AcDbObject*&)pDictionary, DictionaryId, AcDb::kForRead);
	AcDbObjectPointer<AcDbDictionary> dictionaryPtr(DictionaryId,kForRead);
	if (dictionaryPtr.openStatus() != Acad::eOk)
	{		
		return es;
	}
	if (dictionaryPtr->has(parImageName))
	{
		es = dictionaryPtr->getAt(parImageName,parObjectId);
		return es;
	}

	//acutDelString(pTempNewName);
	// Create new image def object
	AcDbRasterImageDef* pAcDbRasterImageDef = new AcDbRasterImageDef();			
	if (pAcDbRasterImageDef == NULL)
		return Acad::eNullObjectPointer;
	// set source file name
	es  = pAcDbRasterImageDef->setSourceFileName(parImagePath);
	
	if (es != Acad::eOk) 
	{
		acutPrintf(_T("Error: Could not find the image file.\n")); 
		delete pAcDbRasterImageDef;
		return es;
	}

	// load image
	es = pAcDbRasterImageDef->load(); 	
	pAcDbRasterImageDef->setActiveFileName(parImagePath);
	if (es != Acad::eOk) 
	{
		acutPrintf(_T("Error: Could not open the image file.\n")); 
		delete pAcDbRasterImageDef;
		return es;
	}

	dictionaryPtr->upgradeOpen();
	// adds a new entry specified by newValue into the dictionary and returns Object Id.
	es = dictionaryPtr->setAt(parImageName, pAcDbRasterImageDef, parObjectId);	
	
	pAcDbRasterImageDef->close();
	return es;
}


Acad::ErrorStatus CImageSupportModule::AppendToPaperOrModelSpace (AcDbEntity* parEntity, Adesk::Boolean parbToPaperSpace)
{
	// declaration
	Acad::ErrorStatus	ErrorStatus;

	AcDbDatabase*			pDataBase;
	AcDbBlockTable*			pBlockTable; 
	AcDbBlockTableRecord*	pBlockTableRecord;


	// get database
	pDataBase	= acdbHostApplicationServices()->workingDatabase();
	// check
	if (pDataBase == NULL) 
		// No database
		return Acad::eNoDatabase;


	// get block table
	ErrorStatus = pDataBase->getSymbolTable(pBlockTable, AcDb::kForRead);
	// check
	if (ErrorStatus != Acad::eOk) 
		// Failed to get block table
		return ErrorStatus;


	// appends to ...
	if (parbToPaperSpace)
		// ... paper space		
		ErrorStatus = pBlockTable->getAt(ACDB_PAPER_SPACE, pBlockTableRecord, AcDb::kForWrite);
	else
		// ... model space by default
		ErrorStatus = pBlockTable->getAt(ACDB_MODEL_SPACE, pBlockTableRecord, AcDb::kForWrite);

	// check
	if (ErrorStatus != Acad::eOk)
		// Failed to get block table record
	{
		pBlockTable->close();
		return ErrorStatus;
	}


	// append entity to block table record
	ErrorStatus = pBlockTableRecord->appendAcDbEntity (parEntity);

	pBlockTableRecord->close();
	pBlockTable->close();

	return ErrorStatus;
}

// ___ manipulate ______________________________________________________
//	
//	description:	Set orientation.
//					Set clip boundary to whole image.
//					Set polygonal clip boundary.
//
//	parameter:		parEntityId		Object Id of the RasterImage.
//
//	return value:	ErrorStatus
//					Returns Acad::eOk if successfull.
//	problems:		.
Acad::ErrorStatus CImageSupportModule::Manipulate (AcDbObjectId   parEntityId)
{
	AcDbRasterImage*	pAcDbRasterImage;
	Acad::ErrorStatus es = acdbOpenObject((AcDbObject*&) pAcDbRasterImage, parEntityId, AcDb::kForWrite);
	if (es == Acad::eOk) 
	{
		// Get current clip boundary.
		AcGePoint2dArray ClipBoundary	 = pAcDbRasterImage->clipBoundary ();
		// type of clip boundary
		AcDbRasterImage::ClipBoundaryType ClipBoundaryType = AcDbRasterImage::kPoly;	// polygonal clip boundary


		// Define single clip points to set and append it to the clip boundary.
		//	Be aware that the first and last clip point has to be the same 
		//	and that the clip points are pixel space.
		AcGePoint2d							ClipPoint;			// single clip point
		ClipPoint.set	(100, 100);
		ClipBoundary.setAt (0, ClipPoint);

		ClipPoint.set	(300, 0);
		ClipBoundary.setAt (1, ClipPoint);

		ClipPoint.set	(600, 200);
		ClipBoundary.setAt (2, ClipPoint);

		ClipPoint.set	(100, 400);
		ClipBoundary.setAt (3, ClipPoint);

		ClipPoint.set	(100, 100);
		ClipBoundary.setAt (4, ClipPoint);

		// Last point has to be same as first point.
		ClipPoint.set	(100, 100);
		ClipBoundary.append (ClipPoint);

		// Set orientation.
		AcGePoint3d		origin(4, 3, 0);
		AcGeVector3d	u(6, 0, 0),v(0, 1, 0);
		Adesk::Boolean ReturnValue = pAcDbRasterImage->setOrientation( origin, u, v );
		if (ReturnValue != Adesk::kTrue)
			acutPrintf(_T("Error: Set orientation failed.\n")); 

		// Set clip boundary.
		es = pAcDbRasterImage->setClipBoundary(ClipBoundaryType, ClipBoundary);
		if (es != Acad::eOk)
			acutPrintf(_T("Error: Set orientation failed.\n")); 

		pAcDbRasterImage->close();
	}


	return es;
}

//
//! @brief
//! @param const AcGePoint3d& ptLB
//! @param const AcGePoint3d& ptRT
//! @exception
//! @return Acad::ErrorStatus
//! @sa 
// -----------------------------------------------------------------------
//	作者:		
//	版本:		1.0
// -----------------------------------------------------------------------
//	修改记录:
//	日 期        版本           修改人         修改内容
//	2011-3-19      1.0            
//  2011-7-25      1.0             
//
Acad::ErrorStatus CImageSupportModule::SetPos( const AcDbObjectId& id, const AcGePoint3d& ptLB, const AcGePoint3d& ptRT )
{
	AcDbRasterImage* pRasterImage = NULL;
	Acad::ErrorStatus es = acdbOpenObject((AcDbObject*&) pRasterImage, id, AcDb::kForWrite);
	if (es != Acad::eOk)		return es;
	
	
	AcGePoint3dArray verts;
	pRasterImage->getVertices(verts);
	AcGeMatrix3d mtx = ptLB - verts[0];

	pRasterImage->transformBy(mtx);
	
	if (es != eOk) return es;

	return Acad::eOk;
}

/** 
 * @brief 删除本图中所有名字为 \c pImageName 的图像引用，然后删除图像定义
 * 
 * @param pImageName
 * 
 * @returns (Acad::ErrorStatus)
 * 
 * detailed description here.
 * 
 */
Acad::ErrorStatus CImageSupportModule::DeleteImageDef( const ACHAR* pImageName )
{
	Acad::ErrorStatus es = eOk;
	// Get Dictionary Id.
	AcDbObjectId DictionaryId = AcDbRasterImageDef::imageDictionary(m_pDb);
	if (DictionaryId.isNull())
	{
		return eOk; // 没有图像字典，说明无需删除，返回eOK是合理的
	}
	AcDbObjectPointer<AcDbDictionary> dictionaryPtr(DictionaryId,kForRead);
	if (dictionaryPtr.openStatus() != Acad::eOk)
	{		
		return es;
	}
	if (!dictionaryPtr->has(pImageName))
	{
		return eOk; // 没有此图形记录，返回eOk
	}
	AcDbObjectId parObjectId;
	es = dictionaryPtr->getAt(pImageName,parObjectId);

	struct ImagePred
	{
		ImagePred(AcDbObjectId id) : m_imageDefId(id)
		{
		}
		bool operator()(const AcDbEntity * pEnt)
		{
			if (!pEnt->isKindOf(AcDbRasterImage::desc())) return false;
			const AcDbRasterImage * pImage = (const AcDbRasterImage*) pEnt;
			return pImage->imageDefId() == m_imageDefId;
		}
	private:
		AcDbObjectId m_imageDefId;
	};
	FilteredEntityCollector entityColl (m_pDb);
	ImagePred imagePred(parObjectId);
	entityColl.OfPredicate(imagePred);
	
	AcDbObjectIdArray resultImageIds = entityColl.ToObjectIdArray();
	for(int i = 0; i < resultImageIds.length(); ++i)
	{
		const AcDbObjectId& oid = resultImageIds.at(i);
		AcDbObjectPointer<AcDbEntity> entPtr(oid,kForWrite);
		if ((es = entPtr.openStatus()) != eOk)
			return es;
		entPtr->erase();
	}
	AcDbObjectPointer<AcDbObject> imageDefPtr(parObjectId,kForWrite);
	if ((es = imageDefPtr.openStatus()) != eOk) return es;
	es = imageDefPtr->erase();
	if (es != eOk) return es;
	imageDefPtr->close();
	dictionaryPtr->upgradeOpen();
	es = dictionaryPtr->remove(pImageName);
	return es;
}

转载于:https://my.oschina.net/u/2930533/blog/1824127