matlab-generate-report

MATLAB Report Generation

Generate structured, professional reports (PDF, Word, HTML) from MATLAB data and Simulink models.

When to Use

Creating PDF, Word, or HTML reports from MATLAB data
Building reports with chapters, title pages, tables of contents
Adding auto-numbered figures and tables to documents
Creating multipage HTML reports (separate HTML files with navigation)
Documenting Simulink models with block diagrams, I/O tables, execution order
Customizing report templates (styles, colors, fonts, headers, footers)
Creating custom reporter classes with template holes and dynamic content
Building multi-reporter packages with shared company styles
Creating table variant reporters with different header colors
Including HTML content in reports

When NOT to Use

Simple file export (CSV, Excel) — use writetable, writematrix
Live Scripts as reports — use MATLAB Live Editor export
Interactive report building — use Report Explorer GUI
Web views of Simulink models — use slreportgen.webview.* directly

API Selection

Always use the Report API (mlreportgen.report.*) as the foundation. It provides the Report container and reporters (Figure, BaseTable, FormalImage, Chapter, TitlePage, etc.) that handle auto-numbering, captions, and document structure.

Use both APIs together. Use the Report API to create the report and add content for which reporters exist. Use the DOM API (mlreportgen.dom.*) for styled paragraphs, custom tables, inline formatting, HTML inclusion, and images without captions. DOM objects append directly to Report, Chapter, or Section alongside reporters.

Critical rule: Report API reporters (Figure, BaseTable, FormalImage) can ONLY be appended to Report, Chapter, or Section objects — never to DOM objects like TableEntry. Use DOM objects inside TableEntry.

Simulink reports: Use slreportgen.report.Report (not mlreportgen.report.Report) — it extends the base with model compilation support required by SystemIO, ExecutionOrder, and other Simulink reporters.

Multipage HTML: Use mlreportgen.dom.Document with "html-multipage" type + HTMLPage objects. This is the only case where you use the DOM Document instead of the Report API Report.

Core Workflow: Standard Report

TitlePage, TableOfContents, ListOfFigures, and ListOfTables are optional — include only when the task requires them. The minimal report is just Report + content + close.

import mlreportgen.report.*
import mlreportgen.dom.*

rpt = Report("MyReport","pdf");
append(rpt,TitlePage(Title="Report Title",Author="Team"));  % optional
append(rpt,TableOfContents());   % optional
append(rpt,ListOfFigures());     % optional
append(rpt,ListOfTables());      % optional

ch = Chapter("Results");
append(ch,Paragraph("Analysis complete."));

% Auto-numbered table
data = FormalTable(["ID","Value"],[1 10; 2 20]);
bt = BaseTable(data);
bt.Title = "Measured values";
append(ch,bt);

% Auto-numbered figure
fig = figure("Visible","off");
plot([1 2],[10 20]);
rptFig = Figure(fig);
rptFig.Snapshot.Caption = "Value trend";
append(ch,rptFig);
close(fig);

append(rpt,ch);
close(rpt);
rptview(rpt);

Core Workflow: Simulink Report

load_system(modelName);

% MUST use slreportgen.report.Report for Simulink content
rpt = slreportgen.report.Report(outputPath,"pdf");
append(rpt,mlreportgen.report.TitlePage("Title","Model Report"));
append(rpt,mlreportgen.report.TableOfContents());

ch = mlreportgen.report.Chapter("Diagrams");

% Root diagram — direct reporter
rootDiag = slreportgen.report.Diagram(modelName);
rootDiag.Snapshot.ScaleToFit = true;
append(ch,rootDiag);

% Subsystems — finder pattern (iterator for memory efficiency)
finder = slreportgen.finder.SystemDiagramFinder(modelName);
finder.IncludeRoot = false;
finder.SortType = "alphabetical";

while finder.hasNext()
    result = finder.next();
    sec = mlreportgen.report.Section("Title",result.Name);
    append(sec,result);
    append(ch,sec);
end

append(rpt,ch);
close(rpt);
rptview(rpt);

Choosing Built-In vs Custom Reporters

Before writing code, analyze requirements against built-in reporter capabilities:

List all content/format requirements — title page fields, page borders, headers/footers, branded styling
Check built-in reporters. Built-in TitlePage has: Title, Subtitle, Author, Publisher, PubDate, Image. Built-in Chapter/Section provide headings, auto-numbering, and a Content hole.
If built-in reporters meet all requirements, use them directly
If any requirement is unmet, create custom reporters:
- Single custom reporter — see references/custom-reporters.md
- Multiple reporters sharing a visual identity — see references/report-package.md

Common triggers for custom reporters:

Title page needs fields beyond the standard set (project name, facility, contract number)
Page borders, watermarks, or custom page layout
Page headers/footers with dynamic content (per-chapter images, tickers)
Branded table variants with different header colors
MATLAB-generated logos (geometric shapes drawn with plot/patch + exportgraphics)

Do NOT force-fit requirements into built-in properties (e.g., concatenating fields into Subtitle). Create a custom reporter instead.

Do NOT build custom title pages with raw DOM elements (Paragraphs, Images appended to a Chapter). Always use customizeReporter for template-based layout and format portability.

Decision Tree: What Reference Do I Need?

I need to...	Reference
Build a standard report with chapters, figures, tables, verification	references/report-api-patterns.md
Work with DOM tables, HTML inclusion, multipage HTML, Number/NumberFormat	references/dom-api-patterns.md
Understand template file types, locate/inspect templates	references/template-system.md
Look up built-in template holes, styles, page layout (pre-computed)	references/template-reference.md
Create a custom reporter class (customizeReporter, holes, headers)	references/custom-reporters.md
Build a multi-reporter package with shared styles and buildTemplates	references/report-package.md
Generate Simulink model reports (finders, orientation, centering)	references/simulink-report.md
Look up all Simulink finders and reporters	references/finders-and-reporters.md
Iterate struct arrays into chapters with custom reporters	references/data-driven-report-pattern.md
Edit template styles (colors, fonts, headers, footers, TOC)	references/template-system.md

Key Functions

Class	Purpose	Package
`Report`	Top-level report container	`mlreportgen.report`
`TitlePage`	Title page with title, subtitle, author	`mlreportgen.report`
`TableOfContents`	Auto-generated TOC	`mlreportgen.report`
`Chapter` / `Section`	Document structure	`mlreportgen.report`
`Figure`	Auto-numbered figure from MATLAB figure	`mlreportgen.report`
`FormalImage`	Auto-numbered image from file with caption	`mlreportgen.report`
`BaseTable`	Auto-numbered table wrapper (pass `FormalTable`)	`mlreportgen.report`
`FormalTable`	Table with header/body/footer from cell arrays	`mlreportgen.dom`
`Template` (3-arg)	Edit templates: `Template(out,fmt,src)`	`mlreportgen.dom`
`HTMLFile` / `HTML`	Include HTML content in any output format	`mlreportgen.dom`
`HTMLPage`	Page in multipage HTML document (R2024a+)	`mlreportgen.dom`
`Number`	Numeric DOM object (use with `NumberFormat`)	`mlreportgen.dom`
`TemplateHole`	Placeholder filled at report time	`mlreportgen.dom`
`Page` / `NumPages`	Page number / total pages	`mlreportgen.dom`
`*.customizeReporter`	Scaffold custom reporter + templates	`mlreportgen.report`
`getStyle` / `replaceStyle`	Modify template styles	`mlreportgen.dom`
`slreportgen.report.Report`	Report container for Simulink content	`slreportgen.report`
`slreportgen.report.Diagram`	Diagram snapshot of a system	`slreportgen.report`
`slreportgen.finder.SystemDiagramFinder`	Find system/subsystem diagrams	`slreportgen.finder`
`slreportgen.report.SystemIO`	Report inputs/outputs (requires compilation)	`slreportgen.report`
`slreportgen.report.ExecutionOrder`	Report block execution order	`slreportgen.report`
`slreportgen.report.LookupTable`	Report lookup table data + plot	`slreportgen.report`
`rptview`	Display report (updates DOCX fields)	function
`docview`	Process Word documents (update fields, convert)	function

Common Mistakes

Mistake	Correct Approach
Using `mlreportgen.dom.Document` as report container	Use `mlreportgen.report.Report`. Exception: multipage HTML requires `Document` with `"html-multipage"`
Using `mlreportgen.report.Report` for Simulink content	Use `slreportgen.report.Report` — needed for model compilation
Using `Report` with `"html"` for multipage output	Use `mlreportgen.dom.Document` with `"html-multipage"` + `HTMLPage` objects
Appending reporters to DOM objects (Paragraph, TableEntry)	Reporters can ONLY go in Report, Chapter, or Section. Use DOM objects inside TableEntry
Putting raw doubles in `FormalTable` cells	Use `Number` with `NumberFormat` in Style: `n = Number(42); n.Style = {NumberFormat("%.0f")}`. Put `n` directly in cell arrays. See references/dom-api-patterns.md § Number and NumberFormat
`NumberFormat("$%.0f")` or `NumberFormat("%,.0f")`	Only standard `sprintf` specifiers work (no `$`, no `%,`, no `%d`). For currency/units, wrap `Number` in `Paragraph` and prepend/append `Text`
Customizing only "default"/"even" page headers	Customize ALL page types: "first", "default", "even" — but differentiate content (see below)
Putting StyleRef (chapter title) in the first-page header	First page already displays the chapter heading — omit StyleRef from "first" header. Use it only in "default"/"even" for wayfinding
Opening DOCX with `winopen`/`open`/`start`	Use `rptview(rpt)` or `docview(file,"updatefields")` — triggers field update
Using `ColSpec`/`ColSpecGroup` for widths	Use `TableColSpecGroup` + `TableColSpec` with `Width` in `Style`
Setting widths without `ResizeToFitContents(false)`	Add `ResizeToFitContents(false)` to table `Style`; set absolute `ft.Width` (not `"100%"`)
`TemplateParagraphStyle.Formats = {Bold(true)}`	Use array: `Formats = [Bold(true),FontSize("12pt")]`
`Template(path,"pdf")` to edit existing template	2-arg creates blank. Use 3-arg: `Template(out,"pdf",src)`
Same path for source and output in Template constructor	OPC cannot read/write simultaneously. Use different paths, then `movefile`
Setting `PDFPageLayout.PageSize.Orientation` without `rotate()`	Call `rotate(pl)` — swaps Width/Height AND sets Orientation
Using `DOCXPageLayout` without explicit Height and Width	DOCX does not auto-swap — set both explicitly
Page numbers resetting after `PDFPageLayout`	Set `pl.FirstPageNumber = ''` (empty string) to continue numbering
Wrapping reporter in Paragraph to center it	Customize the reporter's template style via Template API
Using `RawText(html)` for HTML in PDF	Use `HTMLFile(path)` or `HTML(string)` — works for any format
Using `Group` in a `Table` cell array	Use nested cell arrays: `Table({{img,caption},desc})`
Passing MATLAB `table()` to `BaseTable`	Pass `FormalTable(headers,body)` — avoids `MATLABTable` wrapper
`e.Style = {BackgroundColor("yellow")}` (overwrites existing styles)	Append: `e.Style = [e.Style, {BackgroundColor("yellow")}]` — preserves inherited styles
Force-fitting fields into `TitlePage.Subtitle`	Create a custom title page reporter via `customizeReporter`
Writing custom reporter class from scratch	Use `customizeReporter` to scaffold — creates required binary templates
Writing classdef before running `customizeReporter`	Scaffolding overwrites classdef files. Scaffold first, then edit
Unqualified `TitlePage.getClassFolder()` in package	Use fully-qualified: `mypkg.TitlePage.getClassFolder()`
`getStyle(ss,name,type)` for PDF/HTML	Type arg returns `[]`. Use `getStyle(ss,name)` without type
`OuterMargin("12pt","6pt","0","0")` for vertical spacing	Args are `(left,right,top,bottom)` — NOT CSS order. Use `OuterMargin("0","0","12pt","6pt")` for top/bottom spacing
Using `TemplateCharacterStyle`	Does not exist. Use `TemplateTextStyle` for character/inline styles in PDF/HTML
Unzipping `.pdftx`/`.htmtx`/`.dotx` to edit with fileread/regexprep	ALWAYS use DOM Template API — `Template(out,fmt,src)` + `open` + modify objects + `close`. Raw edits bypass framework validation
`find_system` + `DiagramFinder` for discovery	Use `SystemDiagramFinder` with filter properties
`Diagram(result.Path)` on `ChartDiagramFinder` results	Use `getReporter(result)` — chart paths are invalid for `Diagram` constructor
`find()` + for loop on finders	Always use iterator: `while finder.hasNext()` / `result = finder.next()`
`BlockFinder` with `SearchDepth=inf` expecting referenced models	`BlockFinder` does NOT traverse Model References. Use `SystemDiagramFinder` (IncludeReferencedModels=true) + per-system `BlockFinder` (SearchDepth=1)
`ExecutionOrder` on virtual subsystem	Check `get_param(obj,'IsSubsystemVirtual')` first
`ExecutionOrder`/`SystemIO` on Simulink Functions	Guard with `slreportgen.utils.isSimulinkFunction(result.Object)`

Conventions

Always close(rpt) after appending all content — generates the output file
Always rptview or docview to open DOCX — never winopen or open
Use figure("Visible","off") for plots destined for reports
Use exportgraphics (not print) when saving figures to files
One Chapter = one numbering scope — figures/tables numbered Chapter-Sequence (e.g., "Figure 2-1")
BaseTable wraps FormalTable — pass FormalTable(headers,body), not a MATLAB table()
Cell-level styling: Use entry(t,row,col) after construction, not during
Template styles use [] arrays; inline .Style properties use {}
Reporters in @ClassName directories — each needs its own resources/templates/
Scaffold ALL reporters before editing ANY — customizeReporter creates binary templates + overwrites classdef
Fix unqualified class names after scaffolding — use package-qualified names
Customize all output formats — PDF/Word/HTML templates are independent
Simulink: Always slreportgen.report.Report; always Diagram.Snapshot.ScaleToFit = true
Simulink finders: Use .Object handle (not path string) for get_param; use result.Name for titles
JSON is single source of truth for multi-reporter packages — never hardcode style values

Viewing and Processing Reports

rptview(rpt);                           % Open in system viewer (updates DOCX fields)
rptview("MyReport.docx","pdf");         % Convert DOCX to PDF via Word
docview("Report.docx","updatefields","closedoc","closeapp");  % Update without display

Verification: Running without error does NOT confirm correctness. After close(rpt):

Check isfile(rpt.OutputPath) and dir(rpt.OutputPath).bytes > 1000
For PDF: call open(rpt), then set rpt.Document.RetainFO = true before appending content, search *_FO/*.fo files
For DOCX: unzip and search word/document.xml
Assert expected titles, headings, captions appear in output

See references/report-api-patterns.md for full verification patterns.

Required Toolbox

MATLAB Report Generator (verify with mcp__matlab__detect_matlab_toolboxes). Simulink Report Generator additionally required for Simulink model reports.