Export DXF with matplotlib

[akantifirst]

Hello! First of all, thank you for this great library! Highly appreciate your work and use it in my hobby projects.

Exporting DXF file (AC1015) of 75 KB size with matplotlib approach results in a 320KB output pdf. Exporting the same file with AutoCAD "DWG to PDF" default printer results with 15KB output pdf file. This is how the file looks:

I have noticed that AutoCAD output has embedded .ttf font and matplotlib output has no embedded fonts. I tried to export with .shx fonts and it makes no difference. As long as pdf is vector file format, I wonder why the pdf files rendered by matplotlib are so huge?
I am looking for the way to:
a) reduce the resulting pdf file size.
b) reduce pdf rendering time

What I have tried so far is converting dxf to svg with Inkscape, but it is not possibly to install on my headless Raspberry Pi. Ghostscript converting to PostScript file and back to PDF produces ~220KB file, which is no acceptable for my purposes.

May be you or somebody could give me advice on how to solve this problem.
template.zip

[mozman]

A simple script to create an example PDF by Matplotlib:

import ezdxf
from ezdxf.addons.drawing.matplotlib import qsave

doc = ezdxf.new()
msp = doc.modelspace()
msp.add_text("TEXT")

qsave(msp, "text.pdf")

If you open the PDF with a PDF editor or a vector graphic editor, you will see that Matplotlib (as we use it) exports text as path objects. This takes up more space, but also does not require embedding font files. This is the current status of implementation and it will not change in the future either.

[akantifirst]

Thank you for the fast answer. Is it a limitation of ezdxf library or matplotlib library? Are there any workarounds in order to reduce the file size?

[mozman]

I don't know if it is possible or how to change the PDF rendering of Matplotlib, maybe @mbway knows more.

This approach using the PdfPages() backend creates the same result as qsave():

import matplotlib.pyplot as plt
from matplotlib.backends.backend_pdf import PdfPages

import ezdxf
from ezdxf.addons.drawing import RenderContext, Frontend
from ezdxf.addons.drawing.matplotlib import MatplotlibBackend

doc = ezdxf.new()
msp = doc.modelspace()
msp.add_text("TEXT")

with PdfPages("text.pdf") as pdf:
    fig: plt.Figure = plt.figure()
    ax: plt.Axes = fig.add_axes([0, 0, 1, 1])
    ctx = RenderContext(doc)
    out = MatplotlibBackend(ax)
    Frontend(ctx, out).draw_layout(msp, finalize=True)
    pdf.savefig()
    plt.close(fig)

[akantifirst]

If I understand it right, in addons/drawing/matplotlib.py module there is a function draw_text which is responsible for rendering text to MatplotlibBackend object. With a certain amount of confidence I can say that this function explodes the text entity to paths and this is the cause why huge PDF files are produced.

transformed_path = _transform_path(
            self._text_renderer.get_text_path(text, font_properties),
            Matrix44.scale(
                self._text_renderer.get_scale(cap_height, font_properties)
            )

That's really sorry that font embedding will not be implemented for as long as ezdxf is the best solution to generate DXF with Python.

[mozman]

It seems the matplotlib.axes.Axes.text method adds text as characters and not as paths, at least the example scripts do so. If this method supports all the required DXF features (scaling, mirroring, oblique, ...), you have to ask @mbway to replace his working and tested solution of adding text as PathPatch() by ax.text() or you have to do it by yourself.

I'm happy with the current implementation, it works as expected.

[mbway]

Yes, ezdxf renders text to paths. This has the advantage of producing the exact same output independent of the viewer software or what fonts the user has installed. Also vector output is a nice side-effect of using matplotlib but wasn't the primary focus while developing it. To get the best optimised vector outputs another backend would probably be preferable. I don't know much about pdf internals but I imagine matplotlib also writes metadata and other stuff that isn't strictly necessary if you are trying to make the smallest files possible.

It seems that Matplotlib has the ability to embed fonts in postscript and pdf output

Axes.text() depends on the dpi and the current view. This makes them a nightmare to position accurately which is why this method was avoided.
Internally there is a class called Text but the only public method for adding one to an Axes is by using ax.text.

After some tinkering I have this:

text_object: Text = self.ax.text(
    0, 0, text.replace('$', '\\$'),
    color=properties.color, size=1,
    fontproperties=font_properties, transform_rotates_text=True, zorder=self._get_z())
arr = np.array(text_transform.get_2d_transformation()).reshape(3, 3).T
text_object.set_transform(Affine2D(arr))

But as expected this isn't positioning text in the correct place.

Hopefully this better illustrates what is going on:

fig, ax = plt.subplots()
fig.tight_layout()
ax.set_aspect('equal', 'datalim')

text: Text = ax.text(0, 0, 'test', size=10, color='red')

path = TextPath((0, 0), 'test', size=10)
ax.add_patch(PathPatch(path, color='blue', alpha=0.4))

ax.autoscale(True)
plt.show()

video.mp4

It seems that it is possible to work around this though: https://stackoverflow.com/questions/28370598/how-to-plot-text-with-a-fixed-size

[mbway]

ok, so this isn't a brilliant workaround, but could work for you if you don't care too much about accuracy. I couldn't find how to get the scale factor you would need to set the text size with ax.text to match what a path would produce, but at least the positions are correct and you can adjust the scale yourself manually:

import argparse
import math

import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties

import ezdxf
from ezdxf.addons.drawing import Properties, RenderContext, Frontend
from ezdxf.addons.drawing.backend import prepare_string_for_rendering
from ezdxf.addons.drawing.matplotlib import MatplotlibBackend
from ezdxf.addons.drawing.properties import LayoutProperties
from ezdxf.math import Matrix44


class FixedSizedTextMatplotlibBackend(MatplotlibBackend):
    def __init__(
            self,
            ax: plt.Axes,
            text_size_scale: float = 2,
            *,
            adjust_figure: bool = True,
            font: FontProperties = FontProperties(),
    ):
        self._text_size_scale = text_size_scale
        super().__init__(ax, adjust_figure=adjust_figure, font=font, use_text_cache=False)

    def draw_text(
        self,
        text: str,
        transform: Matrix44,
        properties: Properties,
        cap_height: float,
    ):
        if not text.strip():
            return  # no point rendering empty strings
        font_properties = self.get_font_properties(properties.font)
        assert self.current_entity is not None
        text = prepare_string_for_rendering(text, self.current_entity.dxftype())
        scale = self._text_renderer.get_scale(cap_height, font_properties)
        text_transform = Matrix44.scale(scale) @ transform
        x, y, _, _ = text_transform.get_row(3)
        scale = math.sqrt(sum(i * i for i in text_transform.get_row(0)))
        self.ax.text(
            x, y, text.replace('$', '\\$'),
            color=properties.color, size=1 * scale * self._text_size_scale, in_layout=True,
            fontproperties=font_properties, transform_rotates_text=True, zorder=self._get_z()
        )


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('dxf_file')
    parser.add_argument('output_path')
    args = parser.parse_args()
    
    doc = ezdxf.readfile(args.dxf_file)

    layout = doc.modelspace()

    fig: plt.Figure = plt.figure()
    ax: plt.Axes = fig.add_axes((0, 0, 1, 1))
    ctx = RenderContext(layout.doc)
    layout_properties = LayoutProperties.from_layout(layout)
    out = FixedSizedTextMatplotlibBackend(ax)
    #out = MatplotlibBackend(ax)
    Frontend(ctx, out).draw_layout(
        layout,
        finalize=True,
        layout_properties=layout_properties,
    )
    fig.savefig(
        args.output_path, dpi=300, facecolor=ax.get_facecolor(), transparent=True
    )
    plt.close(fig)


if __name__ == '__main__':
    main()

this resulted in a pdf file which was 1/14 the size of the original, but as expected the test is a slightly different size and not rotated either, although you could fix that
top is original, bottom is with the custom backend

[akantifirst]

This works like a charm! I am almost crying from happiness. Another benefit is that pdf rendering is reasonably faster now. After metadata cleanup it weighs about 21 KB instead of 320KB! Thank you so much! May be it is a good idea to give user a choice, i.e. 'embed_font' option in configuration file...

[mbway]

I think the solution I presented is not suitable for inclusion in ezdxf because it isn't very accurate. I don't fully understand the mechanism by which ax.text behaves differently. I think at a high level it's simply that the text is described in points which is a physical unit like inches is for the figure size, but I can't figure out a formula to obtain the correct scale factor which would allow conversion between data units and points. I tried combinations of the obvious factors involving the figure dpi, 72 (points to pixels scale factor) but didn't find anything.

[mozman]

I also did not find a solution for the scaling factor, but its possible to simplify draw_text(), there seems to be no need to use self._text_renderer.get_scale() by only adjusting the text_size_scale, but every DXF file has its individual scaling factor:

    from ezdxf.math import X_AXIS

    def draw_text(
        self,
        text: str,
        transform: Matrix44,
        properties: Properties,
        cap_height: float,
    ):
        if not text.strip():
            return  # no point rendering empty strings
        font_properties = self.get_font_properties(properties.font)
        assert self.current_entity is not None
        text = prepare_string_for_rendering(text, self.current_entity.dxftype())
        x, y, _, _ = transform.get_row(3)
        rotation = transform.transform_direction(X_AXIS).angle_deg
        self.ax.text(
            x,
            y,
            text.replace("$", "\\$"),
            color=properties.color,
            size=cap_height * self._text_size_scale,
            rotation=rotation,
            in_layout=True,
            fontproperties=font_properties,
            transform_rotates_text=True,
            zorder=self._get_z(),
        )

Result for text_size_scale of ~4:

def new_doc():
    doc = ezdxf.new()
    msp = doc.modelspace()
    for y in range(10):
        msp.add_line((0, y), (50, y))

    msp.add_text(
        "1. LINE OF TEXT height=1.0", dxfattribs={"height": 1.0}
    ).set_pos((0, 0), align="LEFT")

    msp.add_text(
        "2. LINE OF TEXT height=2.0", dxfattribs={"height": 2.0}
    ).set_pos((0, 4), align="LEFT")
    
    m = Matrix44.z_rotate(math.radians(10)) * Matrix44.translate(100, 20, 0)
    for entity in msp:
        entity.transform(m)

    return doc

The second example requires a text_size_scale of ~26:

[mozman]

Added your script as example file: https://github.com/mozman/ezdxf/blob/master/examples/addons/drawing/custom_mpl_backend.py

[mozman]

I tried to understand Matplotlib scaling and learned nothing :(

def new_doc(width, height):
    doc = ezdxf.new()
    msp = doc.modelspace()
    w, h = width, height
    text_size = 10
    msp.add_lwpolyline([(0, 0), (w, 0), (w, h), (0, h)], close=True)
    for y in range(1, 10):
        msp.add_line((0, y), (10, y))
    msp.add_line((0, text_size), (w, text_size))
    msp.add_text("A LINE OF TEXT", dxfattribs={"height": text_size}).set_pos(
        (10, 0)
    )
    return doc


def main(width, height, dpi=300):
    doc = new_doc(width, height)
    layout = doc.modelspace()
    scale = 10 * 50.0 / height
    fig: plt.Figure = plt.figure()
    ax: plt.Axes = fig.add_axes((0, 0, 1, 1))
    ctx = RenderContext(layout.doc)
    layout_properties = LayoutProperties.from_layout(layout)
    out = FixedSizedTextMatplotlibBackend(ax, text_size_scale=scale)
    config = Configuration.defaults()
    Frontend(
        ctx, out, config=config.with_changes(lineweight_scaling=0.01)
    ).draw_layout(
        layout,
        finalize=True,
        layout_properties=layout_properties,
    )
    paper_width = 10
    fig.set_size_inches(paper_width, (height / width) * paper_width)
    name = rf"C:\Users\manfred\Desktop\Outbox\{width}x{height}.pdf"
    fig.savefig(
        name,
        dpi=dpi,
        facecolor=ax.get_facecolor(),
        transparent=True,
    )
    print(f"{name} saved")
    plt.close(fig)

if __name__ == "__main__":
    main(200, 50)
    main(200, 100)
    main(200, 150)
    main(200, 200)
    main(200, 300)

At least I can set the paper size in inches now :)

The finalize() method set a small paper size which overemphasizes the line weight:

Line weight scaling seems not to work for the Matplotlib backend.

More examples:
200x50

200x300

[ascaron37]

Did I understand correctly, that as of now there is no way to get the dimensions of entities like lines when exporting to the matplotlib backend? When I use the example here and create a numpy.array from the figure canvas renderer, I always get a width of 1100 pixels.
My idea was to use opencv to find contours like here.

[mbway]

what do you mean by 'dimensions'. There is https://ezdxf.readthedocs.io/en/stable/bbox.html?highlight=box#bounding-box to get the bounding box of many entities, or did you want the exact geometry?

are you looking to measure distances between places on the final image by any chance? in which case see the FAQ

[ascaron37]

Oh shoot... I missed that, sorry. Thank you very much, #357 explains what I need.