Synthetic Document Factory

Training a layout detection model such as YOLO, DETR or LayoutLMv3 needs pages where every title, paragraph, list, table and figure has a box and a label, and drawing those boxes by hand is slow. In this tool, a local Ollama model writes the document, the tool lays it out in a random style, and it records where each element lands while the PDF is being drawn. The boxes are exact, not guessed afterwards.

Box tracking inside the renderer. A ReportLab Frame subclass wraps each labelled element's drawOn call and records its page, coordinates and text at the moment it's drawn. When a paragraph or table splits across pages or columns, each piece gets its own box, which is how DocLayNet labels them.

class _TrackingFrame(Frame):
    def add(self, flowable, canv, trySplit=0):
        label = getattr(flowable, "_layout_label", None)
        if not label:
            return Frame._add(self, flowable, canv, trySplit)

        boxes = self._boxes
        original = flowable.drawOn

        def drawOn(c, x, y, _sW=0):
            x = flowable._hAlignAdjust(x, _sW)
            w, h = _flowable_size(flowable)
            x0, x1 = _paragraph_extent(flowable, x, w) if isinstance(flowable, Paragraph) else (x, x + w)
            boxes.append({
                "page": c.getPageNumber(), "label": label,
                "x0": x0, "y0": y, "x1": x1, "y1": y + h,
                "text": _flowable_text(flowable),
            })
            return original(c, x, y)

        flowable.drawOn = drawOn
        try:
            return Frame._add(self, flowable, canv, trySplit)
        finally:
            del flowable.drawOn

• Layout variety: one or two columns, Times or Helvetica, four font sizes, three margin sizes, A4 or Letter, running headers, numbered or plain headings, and justified or left-aligned text.
• Cheap augmentation: --variants 5 renders the same text in five layouts without any extra LLM calls.
• Page targeting: after the first render, the tool adds or trims text and re-renders until the document has the requested number of pages, and stops if the count stalls.
• Export: one PNG per page, YOLO label files, COCO annotations in pixels that also store each box's text (useful for text-aware models like LayoutLM), and a data.yaml ready for YOLO training.

• Record boxes during rendering, not after

  Detecting elements on a finished page would add its own errors. Recording them while ReportLab draws makes every box exact by construction.

• Match DocLayNet's labels and ids

  The output uses the same 11 labels and ids as DocLayNet, so it can be mixed with that dataset or used with models trained on it. Footnote and Formula are kept in the map even though they aren't generated.

• Reuse text across layouts

  The local LLM is the slow part. Rendering the same text in several layouts multiplies the labelled pages without more generation.

The test suite runs without Ollama. It checks that every labelled element lies inside its page, reads the text back out of each box to confirm it matches the labelled text, checks that a paragraph split across pages gets a box on each page, checks that export writes COCO, YOLO and images, and checks that random layouts repeat with a seed.

• Text is English only (Latin alphabet), because the PDFs use the built-in PDF fonts.
• A document takes several minutes on a laptop, since the local LLM writes every section.
• data.yaml points train and validation at the same images, so they need splitting before real training.