yang686526

getting the extents.
getting the extents.
using dwgdirect c++, how can i duplicate the adrawextentssizes function of opendwg toolkit\viewkit to get the same extents values?
regards,
sijmen.
to give you a little more background, i originally created a program using the opendwg toolkit\viewkit to create wmf files from dwg\dxf drawings. now i have to recreate the program using the dwgdirect c++ class library to do the same thing, so that it will work with the autocad 2004 drawings.
in both instances i have code to get the extents of the drawing, and scale it up so that the longest extent relates to 10000 device units.
my problem is that for a sample drawing the extents returned to me from the opendwg toolkkit\viewkit using adrawextentssizes (400.016, 318.361) are different to the extents returned from the dwgdirect c++ library (409.726, 318.319).
as a result the wmf canvas that i draw to is different: (10000, 7958) for opendwg tookkit\viewkit, and (10000, 7769) for dwgdirect c++ library, causing the drawings to be slightly offset from each other.
using the dwgdirect c++ framework, how can i get the same extents that opendwg toolkit\viewkit returned.
all help would be appreciated, as this is a very serious problem for me.
regards,
sijmen grunbauer.
hi,
what operation do you use for that? oddbblocktablerecord::getgeomextents()?
probably the extents are ok, but the conversion after that is a little bit different?
best regards
chudomir
oddbblocktablerecord::getgeomextents() returns world extents but some entities can have viewport-dependent geometry which depends on view direction, view size, render mode etc.
dd 1.13 to be release this week will contain simple method to get view-dependent extents.
sergey slezkin
when i originally created the dgw to wmf conversion program using the opendwg toolkit\viewkit, i used the following code to get the extents of the active layout, and work out the canvas size that the wmf would be drawn on:
code:
// create a drawing window, set to minimum size to calaculate the true extents.
rectlong winrect;
winrect.xmin = 0;
winrect.ymin = 0;
winrect.xmax = 1;
winrect.ymax = 1;
// intialize vectoring in opendwg viewkit.
ad_objhandle psblockhandle;
adhanclear(psblockhandle);
ad_view_parms adviewparms;
rectlong dlrect;
short sretval;
::zeromemory(&dlrect, sizeof(dlrect));
sretval = adinitvectorize(m_hdrawing, &adviewparms, &winrect, &dlrect, psblockhandle);
// get the true extents, which is used as a basis for the window aspect ratio.
double extsx, extsy;
adrawextentssizes(m_hdrawing, &extsx, &extsy);
// calculate the scale so the drawing will fit inside a 10,000 x 10,000 window.
double dscale = (extsx >= extsy) ? (10000.0 / extsx) : (10000.0 / extsy);
// set the wmf canvas size based on the extents size.
winrect.xmin = 0;
winrect.ymin = 0;
winrect.xmax = static_cast<long>(extsx * dscale);
winrect.ymax = static_cast<long>(extsy * dscale);
// save the canvas size.
setwindowrect(&winrect);
the adrawextentssizes(m_hdrawing, &extsx, &extsy); gives me extents of (400.016, 318.361) for my sample drawing, which then translates to a canvas of (10000, 7958).
the dwgdirect c++ code that i am using to get the extents is as follows:
code:
// get the drawing extents for the active view.
double extsx = 0.0;
double extsy = 0.0;
odgsview* pview = pdevice->viewat(0);
oddbextents ext;
ext.addblockext(oddbblocktablerecordptr(pdb->getactivelayoutbtrid().safeopenobject()), pview->viewingmatrix());
if (ext.isvalidextents())
{
odgepoint3d targ = pview->target();
odgevector3d dirfromtarg = pview->position() - targ;
// set target to center of the view and keep the view direction.
targ = ext.minpoint() + (ext.maxpoint() - ext.minpoint()) / 2.0;
targ.transformby(pview->viewingmatrix().invert());
if(pview->isfrontclipped() || pview->isbackclipped())
{
// keep distance from target to front & back planes.
targ = targ.orthoproject(odgeplane(pview->target(), dirfromtarg));
}
// get the extents and increase by 2% for margin around drawing.
extsx = ext.maxpoint().x - ext.minpoint().x;
extsy = ext.maxpoint().y - ext.minpoint().y;
pview->setview(targ + dirfromtarg, targ, pview->upvector(), extsx * 1.02, extsy * 1.02);
}
// calculate the scale so the drawing will fit inside a 10,000 x 10,000 window.
double dscale = (extsx >= extsy) ? (10000.0 / extsx) : (10000.0 / extsy);
// set the drawing window to the true extents size.
odgsdcrect winrect(0, static_cast<long>(extsx * dscale), 0, static_cast<long>(extsy * dscale));
pdwgvectorizedevice->onsize(winrect);
this code gives me the extents as (409.726, 318.319) for my sample drawing, which then translates to a canvas of (10000, 7769), when i need it to be (10000, 7958) for backward compatibility.
any assistance would be appreciated.
regards,
sijmen.
the question is which extents are correct?
if new toolkit returns incorrect extents, we'll fix it.
if old toolkit returns incorrect extents - they will differ and where is no way to get the same result with new toolkit.
sergey slezkin