How to set the size of the output for the drawing addon

[karstenflores]

Hi

I'm using the drawing addon to create an image.
Instead of saving and loading the image I use numpy.frombuffer to save it in a variable for further use.
This is the function i wrote, mostly copied the Drawing/Export Addon example, to create an image from an given dxf file.

def to_np(filename, min_line_weight: float = 2) -> np.ndarray:
    try:
        doc, auditor = recover.readfile(filename)
    except IOError:
        print(f'Not a DXF file or a generic I/O error.')
        sys.exit(1)
    except ezdxf.DXFStructureError:
        print(f'Invalid or corrupted DXF file.')
        sys.exit(2)

    if not auditor.has_errors:
        fig: plt.Figure = plt.figure()
        ax: plt.Axes = fig.add_axes([0, 0, 1, 1])

        ctx = RenderContext(doc)

        params = {'min_lineweight': min_line_weight}
        out = MatplotlibBackend(ax, params=params)

        Frontend(ctx, out).draw_layout(doc.modelspace(), finalize=True)

        fig.canvas.draw()
        plt.clf()

        dxf_img = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)
        dxf_img = dxf_img.reshape(fig.canvas.get_width_height()[::-1] + (3,))
        plt.close()

        dxf_img = cv2.cvtColor(dxf_img, cv2.COLOR_RGB2GRAY)
        (thresh, dxf_img) = cv2.threshold(dxf_img, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)

        return dxf_img

When calling the function:

dxf_img10 = dxf.to_np("rect10.dxf")  # 10x10 mm Rectangle
dxf_img100 = dxf.to_np("rect100.dxf")  # 100x100 mm Rectangle

fig, ax = plt.subplots(1, 2)
ax[0].set_title("10x10 mm Rectangle")
ax[0].imshow(dxf_img10, "gray")
ax[1].set_title("100x100 mm Rectangle")
ax[1].imshow(dxf_img100, "gray")
plt.show()

I'll get this result:

With the current setting I get two identical images.

How do I configure the Frontend or MatplotlibBackend so that the resulting figure/image
has a scale of, for example: 1mm equals 1px.

thanks in advance
flores

[mbway]

this can be solved in a way that isn't specific to ezdxf by carefully setting the figure size before saving. Matplotlib is quite complex when it comes to measurements. I have a solution which seems to work well but there may be slight inaccuracies since the calculations are done using floating point numbers but at the end of the day pixels are a discrete measurement so it's probably possible to be at least 1 pixel off. There are probably lots of other things like line widths which have an effect.

Background

The axes of a matplotlib plot have data limits which are of course in units of the data, in the case of ezdxf these are also the units of the CAD file. Then there is the figure size which is measured in inches. ezdxf uses the data limits after plotting (i.e. the bounding box of the CAD) to set the figure size so that the aspect ratio is correct. In the case of ezdxf there are no margins around the axes (there are margins around the data inside the axes though) so setting the figure size can accurately set the axes size as well. Finally there is the figure dpi, which controls several things, most importantly the conversion from inches to pixels.

So if you want to output a figure with an exact size in pixels you can change the dpi or the figure size. Since dpi has other effects like text size and also might have undesirable effects on line widths I think it's better to adjust the figure size.

you can calculate the desired figure size by specifying a desired units_to_pixels conversion factor and scaling the figure size so that the data spans the correct number of pixels. This assumes that the figure aspect ratio is already correct as my solution uses the same scale factor for width and height.

Solution

from typing import Tuple

import matplotlib.pyplot as plt


def _draw_box(fig: plt.Figure, ax: plt.Axes, width: float, height: float) -> None:
    """ emulates what ezdxf drawing does """
    ax.set_axis_off()
    ax.set_aspect('equal')
    ax.plot([0, width, width, 0, 0], [0, 0, height, height, 0])
    xmin, xmax = ax.get_xlim()
    ymin, ymax = ax.get_ylim()
    fig_width, fig_height = plt.figaspect((ymax - ymin) / (xmax - xmin))
    fig.set_size_inches(fig_width, fig_height)


def _get_data_width(ax: plt.Axes) -> Tuple[float, float]:
    xmin, xmax = ax.get_xlim()
    xmargin, ymargin = ax.margins()
    total_width = (xmax - xmin)
    data_width = total_width / (1 + 2 * xmargin)
    return total_width, data_width


def _get_data_width_pixels(fig: plt.Figure, ax: plt.Axes) -> float:
    """ get the number of horizontal pixels taken up by the data of the plot (excluding margins)
    figure must be entirely taken up by a single set of axes (i.e. created with `fig.add_axes((0, 0, 1, 1))` )
    """
    total_width, data_width = _get_data_width(ax)
    data_fraction = data_width / total_width

    pixels_per_inch = fig.dpi
    width_inches, height_inches = fig.get_size_inches()
    width_pixels = width_inches * pixels_per_inch
    return width_pixels * data_fraction


def _set_units_to_pixels_scale(units_to_pixels: float, fig: plt.Figure, ax: plt.Axes) -> None:
    total_width, data_width = _get_data_width(ax)
    desired_data_width_pixels = data_width * units_to_pixels
    scale = desired_data_width_pixels / _get_data_width_pixels(fig, ax)
    width_inches, height_inches = fig.get_size_inches()
    fig.set_size_inches(width_inches * scale, height_inches * scale)


def main():
    fig: plt.Figure = plt.figure()
    ax: plt.Axes = fig.add_axes((0, 0, 1, 1))

    _draw_box(fig, ax, width=5.0, height=2.5)
    _set_units_to_pixels_scale(100, fig, ax)

    fig.savefig('/tmp/image.png')
    plt.close(fig)


if __name__ == '__main__':
    main()

which results in this image:

I measured in GIMP and the box is 500px wide and 250px high, just as expected :)

[mbway]

another thing you could do if you want better control over the exact pixels that are drawn would be to create your own backend. It shouldn't be that difficult. You would first need to get the bounding box of the CAD content (which ezdxf can now do natively) in order to determine the resulting image size, then you would need to set up a transformation matrix to map from CAD coordinates to pixels. Then you could use OpenCV to do the drawing: openCV drawing documentation
There are only about 6 different methods that are essential to implement to get a functioning backend. Things like clear() can just raise an exception in your backend since it isn't usually necessary.

ezdxf/src/ezdxf/addons/drawing/backend.py

Line 62 in b896e5b

class Backend(ABC):

[ascaron37]

Hi mbway,
thank you for your code. While testing I found out that the Axes margins are relative values of the data interval and not absolute, see here. So it should be data_width = total_width / (1 + 2 * xmargin) in the _get_data_width function.
I don't know if it changed recently in matplotlib, but now I get an "almost" correct result in the x axis (on a length of roughly 3.2 mm I get an error of around 0.0005, a rounding error in the process I guess). But the y axis is still off by more than 0.01 mm compared to FreeCAD and SolidWorks. It seems that the ymax limit - margin is higher than the actual value in the dxf file. ymin limit + margin looks ok. Maybe it is some kind of layer that I can't see in both programs. I will look into that.

[mbway]

thanks. I did know the margins are relative so I should have caught that. I think quite a few people have used the code above so I will amend it.

I do have to warn you though. It is painful to get entirely accurate results with matplotlib. The current rendering is OK for visualisation but wasn't really intended for the results to be measured! Although in other projects I have managed to produce images with exact numbers of pixels and exact data_to_pixels scale factors so it is possible with some effort.

One tip I have is that matplotlib can only produce perfectly accurate images if the image size (data_dimensions * data_to_pixels) is a multiple of the dpi. This means you can either set the limits and dpi so they match or keep a fixed dpi (like 100), adjust the limits so that the resulting image has a width and height which is a multiple of 100, then crop the excess afterwards.

[ascaron37]

Thank you for the tip. I decided to simply iterate over all entities of my one contour, which are few in my case and use the flattening methods to get all approximate points. After that it's just a matter of calling cv2.polylines to create a poly drawing which is accurate enough for me. Thank you so much for your help.

[mozman]

The ezdxf.bbox module does this to detect the bounding box:

from ezdxf import bbox

# -x-x-x- snip -x-x-x-

# detects the bounding box for any Iterable[DXFEntity]
bounding_box = bbox.extents(doc.modelspace())