VIEWPORT support for the drawing add-on

[mozman]

For the support of the VIEWPORT entity in the drawing add-on are some additional features of the backend and frontend required:

1. Rendering DXF content in an arbitrary clipping path (ezdxf.path.Path) if the backend has clipping path support. The frontend can't clip TEXT and the backend is maybe optimized for this task. The clipping path support could also be used to render only the LIMITS or EXTENTS stored in the HEADER section, although they are often incorrect, ezdxf itself does not maintain these values.
2. The clipping path of the backend should be changeable to reuse the same backend for multiple view ports.
3. A VIEWPORT can have a different layer visibility (frozen layers).
4. A VIEWPORT can have a different plot style (colors, linetypes, lineweights)
5. many things I don't think of yet

Just the idea:

def draw_viewport(self, entity: DXFEntity, properties: Properties):
    vp = cast(Viewport, entity)
    
    # a viewport can have different layer, color, ... settings and 
    # share the same backend "out"
    vp_frontend = self.create_vp_frontend(vp, properties)
    self.out.push_clipping_path(vp.clipping_path())
    # virtual_entities(vp) (__virtual_entities__ protocol) should yield transformed 
    # DXF entities of the viewport:
    vp_frontend.render_entities(virtual_entities(vp))
    self.out.pop_clipping_path()

VIEWPORT support for the drawing add-on is only being considered and implemented in ezdxf version > 1.0, if at all.

[mbway]

For backends which do not support clipping paths, viewport support would still be possible: The interior of the viewport could be rendered to an image by setting xlim and ylim like in #451 then rendered to the output using the backend method that would be necessary for drawing IMAGE entities: #525 (comment)

looks like matplotlib should support clipping paths: https://matplotlib.org/3.2.2/api/_as_gen/matplotlib.axes.Axes.set_clip_path.html
for Qt, it looks like you can use the QGraphicsItem::ItemClipsChildrenToShape flag together with a custom group item implementation which overrides QGraphicsItem::shape() to implement clipping: https://stackoverflow.com/a/47973022
the default implementation of GraphicsItemGroup::shape() returns the bounding rect so wouldn't clip anything (source)

The frontend could also do some culling if an entity doesn't intersect with the clipping region at all then it can be skipped.

[mozman]

Individual VIEWPORT properties tested with BricsCAD:

• location in paper space layout
• scale (zoom)
• annotation scale
• rotation about the z-axis (free 3D rendering will not be supported)
• clipping path
• individual layer properties
  • frozen/thawed (on/off in VP)
  • color ACI/true color
  • linetype
  • linetype scaling
  • lineweight
  • transparency
  • plot style index (CTB/STB table)

Each paper space layout can have an individual CTB/STB plot style table.

[mozman]

Added support for layer attribute overriding #670

[mozman]

First rudimentary viewport support for the Pillow backend:

Same paperspace layout in BricsCad:

Supports only top-view VIEWPORT entites and this can only change if the frontend gets proper 3D support.

Still to do:

• frozen layer support
• support for property overriding in VIEWPORT entities
• clipping support for the MatplotlibBackend
• clipping support for the PyQtBackend

[mozman]

The clipping path in Matplotlib does not work as expected:

The clipping path seems not to be evaluated while drawing, so there can be only one clipping path for each Axis at all which is applied when exporting the image. I tried set_clip_path() and set_clip_box() same result for both methods. That would mean that for each VIEWPORT entity a separated Axis should be created, this Axis should be congruent to the main Axis because the Frontend applies the necessary transformation from modelspace to viewport automatically. I have no idea if this can be achieved on the fly inside of the MatplotlibBackend .

This all works well for the PillowBackend for which I implemented the clipping myself, as shown in the previous post.

[mozman]

In contrast to the MatplotlibBackend works the VIEWPORT clipping in the PyQtBackend as expected, even for non-rectangular viewports:

[mozman]

Next try for the MatplotlibBackend - using inset_axes()

    def __init__(...):
        super().__init__()
        self.ax = ax  # current drawing axes
        self.main_ax = ax
        ...

    def set_clipping_path(self, path: ezdxf.path.Path = None, scale: float = 1.0) -> bool:
        from matplotlib.transforms import Transform

        if path:
            clip_rect = ezdxf.path.bbox([path])
            x, y, _ = clip_rect.extmin
            w, h, _ = clip_rect.size
            ax = self.main_ax.inset_axes([x, y, w, h])
            setup_axes(ax)
            mpl_path = ezdxf.path.to_matplotlib_path([path])
            ax.set_clip_path(mpl_path, Transform())
            self.ax = ax
        else:
            self.ax = self.main_ax  # reset
        return True  # confirm clipping support

This also does not work!!!

[mozman]

VIEWPORT properties override works:

[kkkkkom]

Dear @mozman , thanks for the awesome package!

May I know is there any update on the viewport drawing support?

[mozman]

yes ...

[kkkkkom]

Thanks for your reply!
Is it something that you plan to merge in soon or do you have an estimated timeline that I should expect?

[mozman]

#1041
#1055

[kkkkkom]

Thank you so much !