How can I detect multiple separate entity groups in model space?

[derekcbr]

If DXF file has many pages drawings for different buildings or floors,how to split them up into different group so that my calculation can be based on the single building instead?
doc = ezdxf.readfile(filename)

iterate over all entities in modelspace

msp = doc.modelspace()

But msp will only return the single modelspace, how to split the modelspace by different pages in DXF file?

[mbway]

by 'pages' are you referring to different entities being spatially separated but within the same layout?

If that's the case then you want to be able to query / filter out entities based on their locations. is that correct?

like this:

(so not different paperspace layouts which would appear like pages/tabs in AutoCAD like this)

[derekcbr]

Hi,
Thank you for the answer,that is correct. The dxf file has 14 pages/drawings. Is there api to separate each page?

[mbway]

I don't think there is currently a simple way to do this. How tricky it will be depends on how many different cases you want to handle (as dxf is quite a complex file format).

For example determining whether a multi-line text entity inside an insert entity with rotation and scaling applied would be very challenging, since you need to know the font measurements to get the untransformed bounding box, then apply the transformation which the insert entity applies to its children to get the final bounding box of the text to know where it is.

Another question is whether you are interested in all possible types of entities or only a subset. For example if you only care about lines then the filtering is very simple: just iterate over all the lines, then calculate whether entity.dxf.start and entity.dxf.end describe a line which lies within the box you want to keep.

Any another thing you haven't specified is whether you even know the bounding boxes for each page that you want to extract. Finding those in arbitrary CAD files would be a nightmare but should be possible if you know how the files were constructed (for example maybe the edges of the pages are stored on a particular layer?)

I seem to suggest this a lot, but the drawing addon which I wrote for ezdxf can help with the filtering as it deals with all (known) tricky cases like the first example I gave and breaks down the complex dxf structure into simple primitives. These primitives (such as lines, chunks of text with well defined positions and scales etc) would be quite easy to test whether they lie within the box you want to keep and the rendering backend is given a reference to the dxf entity which is currently being drawn which you could use for filtering.

So my suggestion would be:

• if you don't know the bounding boxes of the pages then I can't help you
• if you want something simple like just extracting all the lines, ignoring any insert entities or other complications, iterate over all the lines and use the dxf properties to test whether you want to keep those lines
• if you want a robust approach which handles all dxf entity types then create a custom 'rendering' backend which implements this interface

Your backend would not have to actually draw anything, just implement each of the draw_* methods and for each primitive, test whether it lies within the box you want to keep, and if it does, add the entity to a list of entities to keep.

here is an outline for what to do. I'm using shapely to do the intersection testing. Note that this approach will loose any nested structure of the document as it explodes any Insert entities. It should be possible to overcome this if you want to keep the structure but that would be much more complex.
(note that you have to check whether current_entity is already in kept_entities to handle cases like multi-line text because each line will be drawn separately and you don't want multiple copies of the entity to be added to the list)

from shapely.geometry import LineString, Polygon


class FilteringBackend(Backend):
    def __init__(self, keep_box: Polygon, params: Optional[Dict] = None):
        super().__init__(params)
        self.box = keep_box
        self.kept_entities = []

    def draw_line(self, start: Vec3, end: Vec3, properties: Properties) -> None:
        if self.current_entity not in self.kept_entities and self.box.contains(LineString([start.xy, end.xy])):
            self.kept_entities.append(self.current_entity)

    ...  # implement other methods




my_layout = doc.modelspace()
my_box = Polygon([...])
backend = FilteringBackend(my_box)
ctx = RenderContext(my_layout.doc)
ctx.set_current_layout(my_layout)
Frontend(ctx, backend).draw_layout(my_layout)


for entity in backend.kept_entities:
    pass  # do something with entity

I hope that helps

[mozman]

I will add a virtual_entities() method to layouts (model_space, paper_space and block layouts). This may be helpful for some cases, but detecting boundaries of TEXT and MTEXT is not possible without rendering them.

A tool for "estimating" bounding boxes would be helpful (FAQ: How do I get the drawing extends?), but I don't want to add a get_bounding_box() to the DXF entities, because this is for many entities not possible without rendering them.

A non-graphical backend for the drawing add-on could be the base for such a tool. Using matplotlib to calculate the text dimensions it would be possible to estimate the bounding box of TEXT and MTEXT entities at least. But MTEXT is a complex beast and will never get full support (auto-wrap, columns, stacked text, inline font change, inline change of font properties ...).

This tool would be an add-on, because of the requirement of matplotlib. But the tool could be used without having matplotlib installed by ignoring text based entities or calculating text dimensions for a mono-spaced font (char width = text height * width factor).

PS: I recognized virtual_entities() for layouts is misleading, Insert.virtual_entities() is not recursive (except for contained non-uniform scaled INSERT), but should be exhaustively recursive for layouts. The "shallow" virtual_entities() method is just for e in layout: ....

[derekcbr]

Indeed helpful with such a great tool. Thanks again!