///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2015, Open Design Alliance (the "Alliance").
|
// All rights reserved.
|
//
|
// This software and its documentation and related materials are owned by
|
// the Alliance. The software may only be incorporated into application
|
// programs owned by members of the Alliance, subject to a signed
|
// Membership Agreement and Supplemental Software License Agreement with the
|
// Alliance. The structure and organization of this software are the valuable
|
// trade secrets of the Alliance and its suppliers. The software is also
|
// protected by copyright law and international treaty provisions. Application
|
// programs incorporating this software must include the following statement
|
// with their copyright notices:
|
//
|
// This application incorporates Teigha(R) software pursuant to a license
|
// agreement with Open Design Alliance.
|
// Teigha(R) Copyright (C) 2002-2015 by Open Design Alliance.
|
// All rights reserved.
|
//
|
// By use of this software, its documentation or related materials, you
|
// acknowledge and accept the above terms.
|
///////////////////////////////////////////////////////////////////////////////
|
|
// stdafx.cpp : source file that includes just the standard includes
|
// OpenCAD.pch will be the pre-compiled header
|
// stdafx.obj will contain the pre-compiled type information
|
|
#include "stdafx.h"
|
|
// #ifdef _TOOLKIT_IN_DLL_
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2015, Open Design Alliance (the "Alliance").
|
// All rights reserved.
|
//
|
// This software and its documentation and related materials are owned by
|
// the Alliance. The software may only be incorporated into application
|
// programs owned by members of the Alliance, subject to a signed
|
// Membership Agreement and Supplemental Software License Agreement with the
|
// Alliance. The structure and organization of this software are the valuable
|
// trade secrets of the Alliance and its suppliers. The software is also
|
// protected by copyright law and international treaty provisions. Application
|
// programs incorporating this software must include the following statement
|
// with their copyright notices:
|
//
|
// This application incorporates Teigha(R) software pursuant to a license
|
// agreement with Open Design Alliance.
|
// Teigha(R) Copyright (C) 2002-2015 by Open Design Alliance.
|
// All rights reserved.
|
//
|
// By use of this software, its documentation or related materials, you
|
// acknowledge and accept the above terms.
|
///////////////////////////////////////////////////////////////////////////////
|
|
// stdafx.cpp : source file that includes just the standard includes
|
// OpenCAD.pch will be the pre-compiled header
|
// stdafx.obj will contain the pre-compiled type information
|
|
|
#include <map>
|
#include <vector>
|
|
std::map<int, OdDbObjectId> _mapId2Object;
|
std::map<int, OdDbObjectId> _mapId2ObjectText;
|
|
// #endif
|
int addHatches(const OdDbObjectId& btrId, const OdString& textName, float w,
|
double x, double y, const OdDbObjectId& layerId,
|
const OdDbObjectId& shxStyleId, const OdDbObjectId& ttfStyleId,
|
bool bValidText) {
|
/**********************************************************************/
|
/* Open the BlockTableRecord */
|
/**********************************************************************/
|
OdDbBlockTableRecordPtr bBTR = btrId.safeOpenObject(OdDb::kForWrite);
|
|
OdDbDatabase* pDb = btrId.database();
|
|
OdGePoint3d rightupper = pDb->getEXTMAX();
|
OdGePoint3d leftBottom = pDb->getEXTMIN();
|
/**********************************************************************/
|
/* Get the Upper-left corner of the box and its size */
|
/**********************************************************************/
|
OdGePoint3d point;
|
point.x = x;
|
point.y = y;
|
// double h = m_EntityBoxes.getHeight();
|
//double w = 3000;
|
double delta = w;
|
|
/**********************************************************************/
|
/* Create a rectangular Hatch with a circular hole */
|
/**********************************************************************/
|
OdDbHatchPtr pHatch = OdDbHatch::createObject();
|
pHatch->setDatabaseDefaults(pDb);
|
OdDbObjectId whiteHatchId = bBTR->appendOdDbEntity(pHatch);
|
|
/**********************************************************************/
|
/* Set some properties */
|
/**********************************************************************/
|
pHatch->setAssociative(false);
|
pHatch->setPattern(OdDbHatch::kPreDefined, OD_T("SOLID"));
|
pHatch->setHatchStyle(OdDbHatch::kNormal);
|
|
OdCmColor col1;
|
if (!bValidText) {
|
col1.setRGB(240, 104, 37);
|
}
|
else {
|
col1.setRGB(37, 214, 240);
|
}
|
// col1.setRGB(255, 0, 0); //±ê×¢ÑÕÉ«
|
pHatch->setColor(col1);
|
OdCmTransparency transparency;
|
transparency.setAlphaPercent(0.7);
|
pHatch->setTransparency(transparency);
|
|
/**********************************************************************/
|
/* Define the outer loop with an OdGePolyline2d */
|
/**********************************************************************/
|
OdGePoint2dArray vertexPts;
|
OdGeDoubleArray vertexBulges;
|
|
double zy = 0.8;
|
double zx = 0.2;
|
double zw = 1.5;
|
double zh = 1;
|
vertexPts.resize(7);
|
vertexPts[0].set(point.x, point.y);
|
vertexPts[1].set(point.x + delta * zx, point.y * zh + delta * zy);
|
vertexPts[2].set(point.x + delta * zw, point.y * zh + delta * zy);
|
vertexPts[3].set(point.x + delta * zw, point.y * zh + delta * zy + delta);
|
vertexPts[4].set(point.x - delta * zw, point.y * zh + delta * zy + delta);
|
vertexPts[5].set(point.x - delta * zw, point.y * zh + delta * zy);
|
vertexPts[6].set(point.x - delta * zx, point.y * zh + delta * zy);
|
|
pHatch->appendLoop(OdDbHatch::kExternal | OdDbHatch::kPolyline, vertexPts,
|
vertexBulges);
|
|
std::vector < OdDbObjectId > vecObjectId;
|
|
vecObjectId.push_back(pHatch->objectId());
|
|
OdDbHandle id1 = pHatch->handle();
|
OdUInt64 nId = id1;
|
_mapId2Object[nId] = pHatch->objectId();
|
|
/**********************************************************************/
|
/* Add a label */
|
/**********************************************************************/
|
OdGePoint3d position;
|
position = point;
|
point.y += zy * w + w * 0.5;
|
point.z = 10;
|
OdDbObjectId id = addTextEnt(bBTR, point, point, textName, 0.4 * w,
|
OdDb::kTextMid, OdDb::kTextVertMid, layerId, shxStyleId);
|
|
_mapId2ObjectText[nId] = id;
|
|
return nId;
|
}
|
|
/************************************************************************/
|
/* Add an Image to the specified BlockTableRecord */
|
/************************************************************************/
|
int addImage(OdDbDatabasePtr pDb, const OdString& sImagePath, double xPos, double yPos, double width, double height, const OdString& textName, const OdDbObjectId& layerId, const OdDbObjectId& shxStyleId)
|
{
|
OdDbBlockTableRecordPtr pRecord = pDb->getActiveLayoutBTRId().safeOpenObject(OdDb::kForWrite);
|
OdDbObjectId imageDictId = OdDbRasterImageDef::createImageDictionary(pRecord->database());
|
OdDbDictionaryPtr pImageDict = imageDictId.safeOpenObject(OdDb::kForWrite);
|
// Create image definition
|
OdDbObjectId defId;
|
OdDbRasterImageDefPtr pDef = OdDbRasterImageDef::createObject();
|
pDef->setSourceFileName(sImagePath);
|
|
char s[MAX_PATH];
|
// int i = _mapId2Object.size();
|
int i = rand();
|
sprintf(s, "pic__%d", i);
|
defId = pImageDict->setAt(s, pDef);
|
// Try to load raster image to found correct dimensions inside TD
|
OdDbRasterImageDefPtr pDefLoad = OdDbRasterImageDef::cast(defId.openObject(OdDb::kForWrite));
|
OdResult result = pDefLoad->load(false);
|
OdGeVector2d size = pDefLoad->size();
|
if(width==0){
|
width = size.x;
|
height = size.y;
|
}
|
// Create and attach raster image reference
|
OdDbRasterImagePtr pRef = OdDbRasterImage::createObject();
|
pRef->setDatabaseDefaults(pDb);
|
pRecord->appendOdDbEntity(pRef);
|
|
pRef->setImageDefId(defId);
|
OdGePoint3d origin;
|
OdGeVector3d u, v;
|
|
|
origin.x = xPos-width/2;
|
origin.y = yPos;
|
origin.z = 0;
|
|
|
u.set(width, 0, 0);
|
v.set(0, height, 0);
|
|
pRef->setOrientation(origin, u, v);
|
pRef->setDisplayOpt(OdDbRasterImage::kShow, true);
|
pRef->setDisplayOpt(OdDbRasterImage::kTransparent, true);
|
pRef->setDisplayOpt(OdDbRasterImage::kClip, false);
|
OdCmTransparency transparency;
|
if (textName.getLength()) {
|
transparency.setAlphaPercent(0.7);
|
} else {
|
transparency.setAlphaPercent(1.0);
|
}
|
pRef->setTransparency(transparency);
|
|
//¹Ø±ÕͼƬframe
|
OdDbRasterVariablesPtr pRVars = OdDbRasterVariables::openRasterVariables(pRecord->database(), OdDb::kForWrite);
|
pRVars->setImageFrame(OdDbRasterVariables::kImageFrameOff);
|
|
|
OdDbHandle id1 = pRef->handle();
|
OdUInt64 nId = id1;
|
_mapId2Object[nId] = pRef->objectId();
|
|
|
/**********************************************************************/
|
/* Add a label */
|
/**********************************************************************/
|
OdGePoint3d position;
|
position = origin;
|
position.x += width / 2;
|
position.y += height / 1.5;
|
position.z = 10;
|
OdDbObjectId id = addTextEnt(pRecord, position, position, textName, 0.5 * height,
|
OdDb::kTextMid, OdDb::kTextVertMid, layerId, shxStyleId);
|
|
_mapId2ObjectText[nId] = id;
|
|
return nId;
|
}
|
|
OdDbObjectId addLayer(OdDbDatabase* pDb, const OdString& name,
|
const OdCmColor color, const OdString& linetype) {
|
OdDbLayerTablePtr pLayersRead = pDb->getLayerTableId().safeOpenObject(
|
OdDb::kForRead);
|
OdDbSymbolTableIteratorPtr pEntIter = pLayersRead->newIterator();
|
/********************************************************************/
|
for (; !pEntIter->done(); pEntIter->step()) {
|
/********************************************************************/
|
/* Dump the Entity */
|
/********************************************************************/
|
OdDbLayerTableRecordPtr pEntity = pEntIter->getRecord();
|
if (pEntity->getName() == name)
|
return pEntity->objectId();
|
}
|
|
/**********************************************************************/
|
/* Open the layer table */
|
/**********************************************************************/
|
OdDbLayerTablePtr pLayers = pDb->getLayerTableId().safeOpenObject(
|
OdDb::kForWrite);
|
|
/**********************************************************************/
|
/* Create a layer table record */
|
/**********************************************************************/
|
OdDbLayerTableRecordPtr pLayer = OdDbLayerTableRecord::createObject();
|
|
/**********************************************************************/
|
/* Layer must have a name before adding it to the table. */
|
/**********************************************************************/
|
pLayer->setName(name);
|
|
/**********************************************************************/
|
/* Set the Color. */
|
/**********************************************************************/
|
// pLayer->setColorIndex(color);
|
pLayer->setColor(color);
|
|
/**********************************************************************/
|
/* Set the Linetype. */
|
/**********************************************************************/
|
OdDbLinetypeTablePtr pLinetypes = pDb->getLinetypeTableId().safeOpenObject(
|
OdDb::kForRead);
|
OdDbObjectId linetypeId = pLinetypes->getAt(linetype);
|
pLayer->setLinetypeObjectId(linetypeId);
|
|
/**********************************************************************/
|
/* Add the record to the table. */
|
/**********************************************************************/
|
OdDbObjectId layerId = pLayers->add(pLayer);
|
|
return layerId;
|
}
|
|
/************************************************************************/
|
/* Add a Text Style to the specified database */
|
/* */
|
/* The symbol table and symbol table record are implicitly closed when */
|
/* this function returns. */
|
/************************************************************************/
|
OdDbObjectId addStyle(OdDbDatabase* pDb, const OdString& txt, const OdString& hztxt, const OdString& styleName,
|
double textSize, double xScale, double priorSize, double obliquing,
|
const OdString& fileName, bool isShapeFile, const OdString& ttFaceName,
|
bool bold, bool italic, int charset, int pitchAndFamily)
|
{
|
OdDbTextStyleTablePtr pLayersRead =
|
pDb->getTextStyleTableId().safeOpenObject(OdDb::kForRead);
|
OdDbSymbolTableIteratorPtr pEntIter = pLayersRead->newIterator();
|
/********************************************************************/
|
for (; !pEntIter->done(); pEntIter->step()) {
|
/********************************************************************/
|
/* Dump the Entity */
|
/********************************************************************/
|
OdDbTextStyleTableRecordPtr pEntity = pEntIter->getRecord();
|
if (pEntity->getName() == styleName)
|
return pEntity->objectId();
|
}
|
|
OdDbObjectId styleId;
|
|
OdDbTextStyleTablePtr pStyles = pDb->getTextStyleTableId().safeOpenObject(
|
OdDb::kForWrite);
|
OdDbTextStyleTableRecordPtr pStyle =
|
OdDbTextStyleTableRecord::createObject();
|
|
// Name must be set before a table object is added to a table. The
|
// isShapeFile flag must also be set (if true) before adding the object
|
// to the database.
|
pStyle->setName(styleName);
|
pStyle->setIsShapeFile(false);
|
|
pStyle->setFileName(txt);
|
pStyle->setBigFontFileName(hztxt);
|
|
// Add the object to the table.
|
styleId = pStyles->add(pStyle);
|
|
// Set the remaining properties.
|
pStyle->setTextSize(textSize);
|
pStyle->setXScale(xScale);
|
pStyle->setPriorSize(priorSize);
|
pStyle->setObliquingAngle(obliquing);
|
// pStyle->setFileName(fileName);
|
if (isShapeFile) {
|
pStyle->setPriorSize(22.45);
|
}
|
if (!ttFaceName.isEmpty()) {
|
pStyle->setFont(ttFaceName, bold, italic, charset, pitchAndFamily);
|
}
|
|
return styleId;
|
}
|
|
std::vector<OdDbObjectId> _vecObjectId;
|
|
void ZoomTag(OdDbDatabasePtr m_pDatabase, double revZoomScale) {
|
OdDbBlockTableRecordPtr pBlockTableRecord =
|
m_pDatabase->getModelSpaceId().safeOpenObject(OdDb::kForRead);
|
OdGePoint3d Start, End;
|
std::map<int, OdDbObjectId>::iterator iter = _mapId2Object.begin();
|
while (iter != _mapId2Object.end()) {
|
int key = iter->first;
|
OdDbObjectId val = iter->second;
|
OdDbObjectPtr oid = val.openObject(OdDb::kForWrite, false);
|
|
OdDbHatchPtr hatch = OdDbHatch::cast(oid);
|
if (!hatch.isNull()) {
|
OdGePoint2dArray vertices;
|
OdGeDoubleArray bulges;
|
hatch->getLoopAt(0, vertices, bulges);
|
// writeLine(indent++, OD_T("Edges"));
|
int nCnt = vertices.size();
|
OdGePoint2d origin = vertices[0];
|
Start.set(origin.x, origin.y, 0);
|
OdGeMatrix3d tm;
|
tm.setToScaling(revZoomScale, Start);
|
hatch->transformBy(tm);
|
|
std::map<int, OdDbObjectId>::iterator iter1 = _mapId2ObjectText.find(
|
key);
|
if (iter1 != _mapId2ObjectText.end()) {
|
OdDbObjectId val = iter1->second;
|
OdDbObjectPtr oid = val.openObject(OdDb::kForWrite, false);
|
|
OdDbTextPtr text = OdDbText::cast(oid);
|
if (!text.isNull()) {
|
OdGePoint3d pos = text->position();
|
|
OdGeMatrix3d tm;
|
tm.setToScaling(revZoomScale, Start);
|
text->transformBy(tm);
|
}
|
}
|
}
|
|
|
|
OdDbRasterImagePtr image = OdDbRasterImage::cast(oid);
|
if (!image.isNull()) {
|
OdGePoint3d origin;
|
OdGeVector3d u, v;
|
image->getOrientation(origin, u, v);
|
origin.x += u[0] / 2;
|
OdGeMatrix3d tm;
|
tm.setToScaling(revZoomScale, origin);
|
image->transformBy(tm);
|
|
std::map<int, OdDbObjectId>::iterator iter1 = _mapId2ObjectText.find(
|
key);
|
if (iter1 != _mapId2ObjectText.end()) {
|
OdDbObjectId val = iter1->second;
|
OdDbObjectPtr oid = val.openObject(OdDb::kForWrite, false);
|
|
OdDbTextPtr text = OdDbText::cast(oid);
|
if (!text.isNull()) {
|
OdGePoint3d pos = text->position();
|
|
OdGeMatrix3d tm;
|
tm.setToScaling(revZoomScale, origin);
|
text->transformBy(tm);
|
}
|
}
|
}
|
|
iter++;
|
}
|
}
|
|
/************************************************************************/
|
/* Add a text entity with the specified attributes to the specified */
|
/* BlockTableRecord */
|
/************************************************************************/
|
OdDbObjectId addTextEnt(OdDbBlockTableRecord* bBTR, const OdGePoint3d& position,
|
const OdGePoint3d& ap, const OdString& str, double height,
|
OdDb::TextHorzMode hMode, OdDb::TextVertMode vMode,
|
const OdDbObjectId& layerId, const OdDbObjectId& styleId,
|
OdDbGroup* pGroup) {
|
/**********************************************************************/
|
/* Create the text object */
|
/**********************************************************************/
|
OdDbTextPtr pText = OdDbText::createObject();
|
pText->setDatabaseDefaults(bBTR->database());
|
OdDbObjectId textId = bBTR->appendOdDbEntity(pText);
|
|
// Make the text annotative
|
OdDbAnnotativeObjectPEPtr(pText)->setAnnotative(pText, true);
|
|
/**********************************************************************/
|
/* Add the text to the specified group */
|
/**********************************************************************/
|
if (pGroup) {
|
pGroup->append(textId);
|
}
|
|
/**********************************************************************/
|
/* Set some properties */
|
/**********************************************************************/
|
pText->setPosition(position);
|
pText->setAlignmentPoint(ap);
|
pText->setHeight(height);
|
pText->setWidthFactor(1.0);
|
pText->setTextString(str);
|
pText->setHorizontalMode(hMode);
|
pText->setVerticalMode(vMode);
|
|
/**********************************************************************/
|
/* Set the text to the specified style */
|
/**********************************************************************/
|
if (!styleId.isNull()) {
|
pText->setTextStyle(styleId);
|
}
|
/**********************************************************************/
|
/* Set the text to the specified layer */
|
/**********************************************************************/
|
if (!layerId.isNull()) {
|
pText->setLayer(layerId, false);
|
}
|
|
return textId;
|
}
|
|
void ScreenToWorld(OdGsViewPtr pDevice, float x, float y, float out[]) {
|
OdGsViewPtr pView = pDevice;
|
OdGePoint3d WCSPoint(x, y, 0.0);
|
|
OdGeMatrix3d screenMatrix = pView->screenMatrix();
|
OdGeMatrix3d projectionMatrix = pView->projectionMatrix();
|
|
WCSPoint.transformBy(
|
(pView->screenMatrix() * pView->projectionMatrix()).inverse());
|
WCSPoint.z = 0.0;
|
WCSPoint.transformBy(OdAbstractViewPEPtr(pView)->eyeToWorld(pView));
|
|
out[0] = WCSPoint.x;
|
out[1] = WCSPoint.y;
|
out[2] = WCSPoint.z;
|
}
|
|
void WorldToScreen(OdGsViewPtr pDevice, float x, float y, float z,
|
float out[]) {
|
OdGsViewPtr pView = pDevice;
|
OdGePoint3d WCSPoint(x, y, z);
|
OdGeMatrix3d xWorldToScr = pView->worldToDeviceMatrix();
|
OdGePoint3d pt = xWorldToScr * WCSPoint;
|
|
out[0] = pt.x;
|
out[1] = pt.y;
|
}
|
|
int AddShape(OdDbDatabase* pDb, const OdString& txt, const OdString& hztxt, float x, float y, float fSize, const OdString& sImagePath, const OdString& sLableText, bool bValidText)
|
{
|
OdCmColor clr;
|
OdString name;
|
// clr.setRGB(255, 255, 255);
|
if (bValidText){
|
clr.setRGB(255, 255, 255);
|
name = OD_T("JKYTextLayer");
|
}
|
else{
|
clr.setRGB(0, 255, 0);
|
name = OD_T("JKYTextLayer1");
|
}
|
|
OdDbObjectId odaLayerId = addLayer(pDb, name, clr, OD_T("CONTINUOUS"));
|
|
OdDbObjectId shxTextStyleId = addStyle(pDb, txt, hztxt, OD_T("OdaShxStyle"), 0.0, 1.0,
|
0.2, 0.0, OD_T("txt"));
|
|
//int nId = addHatches(pDb->getModelSpaceId(), sLableText, 2000, x, y, odaLayerId, shxTextStyleId, shxTextStyleId, bValidText);
|
|
int nId = addImage(pDb, sImagePath, x, y, fSize, fSize*0.3, sLableText, odaLayerId, shxTextStyleId);
|
return nId;
|
}
|
|
void DeleteShape(OdDbDatabasePtr m_pDatabase, int nID) {
|
OdDbBlockTableRecordPtr pBlockTableRecord =
|
m_pDatabase->getModelSpaceId().safeOpenObject(OdDb::kForRead);
|
|
if (nID > 0) {
|
std::map<int, OdDbObjectId>::iterator iter = _mapId2Object.find(nID);
|
if (iter != _mapId2Object.end()) {
|
OdDbObjectId id = iter->second;
|
OdDbObjectPtr oid = id.openObject(OdDb::kForWrite, false);
|
oid->erase();
|
|
_mapId2Object.erase(iter);
|
}
|
|
iter = _mapId2ObjectText.find(nID);
|
if (iter != _mapId2ObjectText.end()) {
|
OdDbObjectId id = iter->second;
|
OdDbObjectPtr oid = id.openObject(OdDb::kForWrite, false);
|
oid->erase();
|
|
_mapId2ObjectText.erase(iter);
|
}
|
}
|
else {
|
std::map<int, OdDbObjectId>::iterator iter = _mapId2Object.begin();
|
while (iter != _mapId2Object.end()) {
|
DeleteShape(m_pDatabase, iter->first);
|
iter++;
|
}
|
ClearData();
|
}
|
}
|
|
int PickShapeByCursor(OdGsViewPtr pDevice, OdDbDatabasePtr m_pDatabase, float x,
|
float y) {
|
int nRet = 0;
|
OdDbBlockTableRecordPtr pBlockTableRecord =
|
m_pDatabase->getModelSpaceId().safeOpenObject(OdDb::kForRead);
|
float out[3];
|
ScreenToWorld(pDevice, x, y, out);
|
OdGePoint3d Start, End;
|
std::map<int, OdDbObjectId>::iterator iter = _mapId2Object.begin();
|
while (iter != _mapId2Object.end()) {
|
int key = iter->first;
|
OdDbObjectId val = iter->second;
|
OdDbObjectPtr oid = val.openObject(OdDb::kForRead, false);
|
|
OdDbHatchPtr hatch = OdDbHatch::cast(oid);
|
if (!hatch.isNull()) {
|
OdGePoint2dArray vertices;
|
OdGeDoubleArray bulges;
|
hatch->getLoopAt(0, vertices, bulges);
|
// writeLine(indent++, OD_T("Edges"));
|
int nCnt = vertices.size();
|
|
float xmin = 0, ymin = 0, xmax = 0, ymax = 0;
|
for (int i = 0; i < nCnt; i++) {
|
if (i == 0) {
|
xmin = vertices[i].x;
|
ymin = vertices[i].y;
|
xmax = vertices[i].x;
|
ymax = vertices[i].y;
|
}
|
else {
|
if (xmin > vertices[i].x)
|
xmin = vertices[i].x;
|
if (ymin > vertices[i].y)
|
ymin = vertices[i].y;
|
if (xmax < vertices[i].x)
|
xmax = vertices[i].x;
|
if (ymax < vertices[i].y)
|
ymax = vertices[i].y;
|
}
|
}
|
|
if (out[0] > xmin && out[0] < xmax && out[1] > ymin
|
&& out[1] < ymax) {
|
nRet = key;
|
break;
|
}
|
}
|
|
OdDbRasterImagePtr image = OdDbRasterImage::cast(oid);
|
if (!image.isNull())
|
{
|
float xmin = 0, ymin = 0, xmax = 0, ymax = 0;
|
OdGePoint3d origin;
|
OdGeVector3d u, v;
|
image->getOrientation(origin, u, v);
|
|
xmin = origin.x;
|
ymin = origin.y;
|
xmax = xmin + u[0];
|
ymax = ymin + v[1];
|
if (out[0] > xmin && out[0] < xmax && out[1] > ymin
|
&& out[1] < ymax) {
|
nRet = key;
|
break;
|
}
|
}
|
|
iter++;
|
}
|
|
return nRet;
|
}
|
|
void ClearData() {
|
_mapId2Object.clear();
|
_mapId2ObjectText.clear();
|
}
|
|
|
// #endif
|
