Lisp to find length of a block
You can use this:
(defun C:BB (/ minpt maxpt); Bounding Box of selected object
(vla-getboundingbox (vlax-ename->vla-object (car (entsel))) 'minpt 'maxpt)
(setq
box (list (vlax-safearray->list minpt) (vlax-safearray->list maxpt))
delta (mapcar '- (cadr box) (car box))
); setq
(prompt
(strcat
"\nBounding Box [in 'box' variable]: " (vl-princ-to-string box) ";"
"\nExtents: X direction " (rtos (car delta))
"; Y direction " (rtos (cadr delta))
"; Z direction " (rtos (caddr delta)) "."
); strcat
); prompt
(princ)
)
and read [and/or put into a variable, etc., if you want] its reported X-direction extents, or Y-direction if that's what "length" might mean for a given Block.
It works with different kinds of objects, stretch-parameter line length differences, scale factors, etc.
I also have a routine to draw the XY plane of the bounding box, instead of just report on it -- the DBB command [and DBBM for the collective box around Multiple objects] in DrawBoundingBox.lsp, >here<. That was used for the illustration below.
BUT:
That's reliable only with something orthogonally oriented. The difficulty is that when used with a Block, if it's rotated at some non-orthogonal angle, it's as though its bounding box when at zero rotation becomes part of the definition, and the resulting bounding box of the rotated Block is that of the bounding box of the non-rotated Block, when rotated to the same angle. Here, the dotted yellow at right illustrates what the yellow box in the middle becomes as if it's present and rotated along with the Block [even though it's not part of the Block definition]. That is what the right image builds its green bounding box around, though the Block itself is all that was selected. So the green one extends beyond the actual extents of the white Block contents:
So if "length" for you means, for example, extent in the direction of its rotation angle, whatever that is, something else would be needed.
Kent was on the right track getting the bounding box, but get the bounding boxes of the entities inside the block table record * the scale.
This python seems to work on the few dynamic blocks I tried.
Maybe someone can port this to lisp
def PyRxCmd_doit1():
try:
etype = Db.BlockReference.desc()
res: tuple[Ed.PromptStatus,
Db.ObjectId,
Ge.Point3d] = Ed.Editor.entSel("\nPick it: ",etype)
if res[0] != Ed.PromptStatus.eOk:
return
ref = Db.BlockReference(res[1])
btr = Db.BlockTableRecord(ref.blockTableRecord())
ext = Db.Extents()
for id in btr.objectIds():
ent = Db.Entity(id)
subext = Db.Extents()
if ent.bounds(subext):
ext.addExt(subext)
length = (ext.maxPoint().x - ext.minPoint().x)* ref.scaleFactors().sx
except Exception as err:
traceback.print_exception(err)
@smallƑish wrote:
Yes, only line and polyline
As objects only, or always defined into Blocks [see the topic heading]? Can you post a drawing or an image showing some examples of the objects you're talking about? Include the range of possibilities of scale, rotation, dynamic properties, etc.
It can make a big difference, for example, whether or not a Polyline is defined into a Block. In this overly simple example, the dashed red are the bounding boxes, if that should be a way to determine what you want. Note that they are the same on the left, but how different the ones on the right are, between the white Polyline and the green Block containing only the same Polyline, when rotated at a non-orthogonal angle. As a Block, its bounding box is quite different than it is as an independent Polyline. The dotted yellow is not part of it, but only illustrates the non-rotated Block's bounding box becoming the basis for that of the rotated Block.
Of course, the question remains: in a situation like this, what would "length" mean? That's why I'd like to see some real examples of the kinds of things you want to find the length of, how they might be oriented, what length would mean in relation to them, etc.
nope, you have complex blocks in a sense of they having not one entity, so the best way to get measurement needed is to define a parameter for each measurement in a block which may be a dimension or a formula and hiding unnecessary ones. this will make a dynamic block if it's not from which you can get needed measurement with some lisp coding. see illustration below for arc length.
