Report

Report/append_sources_to_report.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""
+Append source files to a markdown report and save as a new file.
+
+Example:
+    python3 Report/append_sources_to_report.py \
+      --input Report/zivro-open-project-report.md \
+      --output Report/zivro-open-project-report-with-code.md \
+      --base .
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Iterable
+
+
+DEFAULT_EXTENSIONS = {
+    ".zig",
+    ".zon",
+    ".json",
+    ".toml",
+    ".yaml",
+    ".yml",
+    ".md",
+    ".txt",
+    ".py",
+    ".puml",
+}
+
+DEFAULT_EXCLUDE_DIRS = {
+    ".git",
+    "zig-out",
+    "zig-cache",
+    ".zig-cache",
+    ".cursor",
+    "mcps",
+}
+
+DEFAULT_EXCLUDE_FILES = {
+    ".DS_Store",
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Adds source code listings to the end of a markdown report and writes "
+            "the result to a new markdown file."
+        )
+    )
+    parser.add_argument("--input", required=True, help="Path to source markdown report")
+    parser.add_argument("--output", required=True, help="Path to output markdown report")
+    parser.add_argument(
+        "--base",
+        default=".",
+        help="Project root to scan for source files (default: current directory)",
+    )
+    parser.add_argument(
+        "--include",
+        nargs="*",
+        default=["src", "build.zig", "build.zig.zon"],
+        help=(
+            "Files/directories (relative to --base) to include in appendix scan. "
+            "Default: src build.zig build.zig.zon"
+        ),
+    )
+    parser.add_argument(
+        "--extensions",
+        nargs="*",
+        default=sorted(DEFAULT_EXTENSIONS),
+        help=(
+            "Allowed file extensions (e.g. .zig .md). "
+            "If empty, all file extensions are allowed."
+        ),
+    )
+    parser.add_argument(
+        "--exclude-dir",
+        nargs="*",
+        default=sorted(DEFAULT_EXCLUDE_DIRS),
+        help="Directory names to exclude recursively",
+    )
+    parser.add_argument(
+        "--max-bytes",
+        type=int,
+        default=1_000_000,
+        help="Skip files larger than this size in bytes (default: 1_000_000)",
+    )
+    return parser.parse_args()
+
+
+def is_text_file(path: Path) -> bool:
+    try:
+        data = path.read_bytes()
+    except OSError:
+        return False
+
+    if b"\x00" in data:
+        return False
+    return True
+
+
+def iter_files(
+    base: Path,
+    include_paths: Iterable[str],
+    extensions: set[str],
+    exclude_dirs: set[str],
+    max_bytes: int,
+) -> list[Path]:
+    files: list[Path] = []
+
+    def add_file(path: Path) -> None:
+        if not path.is_file():
+            return
+        if path.name in DEFAULT_EXCLUDE_FILES:
+            return
+        if extensions and path.suffix.lower() not in extensions:
+            return
+        try:
+            size = path.stat().st_size
+        except OSError:
+            return
+        if size > max_bytes:
+            return
+        if not is_text_file(path):
+            return
+        files.append(path)
+
+    for rel in include_paths:
+        item = (base / rel).resolve()
+        if not item.exists():
+            continue
+        if item.is_file():
+            add_file(item)
+            continue
+        for path in item.rglob("*"):
+            if any(part in exclude_dirs for part in path.parts):
+                continue
+            add_file(path)
+
+    return sorted(set(files), key=lambda p: p.relative_to(base).as_posix())
+
+
+def language_for(path: Path) -> str:
+    ext = path.suffix.lower()
+    if ext == ".zig":
+        return "zig"
+    if ext == ".py":
+        return "python"
+    if ext in {".yaml", ".yml"}:
+        return "yaml"
+    if ext == ".json":
+        return "json"
+    if ext == ".toml":
+        return "toml"
+    if ext == ".md":
+        return "markdown"
+    return ""
+
+
+def main() -> int:
+    args = parse_args()
+
+    input_path = Path(args.input).resolve()
+    output_path = Path(args.output).resolve()
+    base_path = Path(args.base).resolve()
+
+    if not input_path.exists():
+        raise FileNotFoundError(f"Input report not found: {input_path}")
+    if input_path == output_path:
+        raise ValueError("--input and --output must be different files")
+
+    report_text = input_path.read_text(encoding="utf-8")
+
+    extensions = {e.lower() if e.startswith(".") else f".{e.lower()}" for e in args.extensions}
+    exclude_dirs = set(args.exclude_dir)
+
+    files = iter_files(
+        base=base_path,
+        include_paths=args.include,
+        extensions=extensions,
+        exclude_dirs=exclude_dirs,
+        max_bytes=args.max_bytes,
+    )
+
+    appendix_lines: list[str] = []
+    appendix_lines.append("")
+    appendix_lines.append("---")
+    appendix_lines.append("")
+    appendix_lines.append("## Приложение A. Исходные тексты")
+    appendix_lines.append("")
+    appendix_lines.append(
+        f"Сформировано автоматически скриптом `Report/append_sources_to_report.py` "
+        f"(файлов: {len(files)})."
+    )
+    appendix_lines.append("")
+
+    for idx, path in enumerate(files, start=1):
+        rel = path.relative_to(base_path).as_posix()
+        lang = language_for(path)
+        code = path.read_text(encoding="utf-8", errors="replace")
+
+        appendix_lines.append(f"### A.{idx}. `{rel}`")
+        appendix_lines.append("")
+        appendix_lines.append(f"```{lang}")
+        appendix_lines.append(code.rstrip("\n"))
+        appendix_lines.append("```")
+        appendix_lines.append("")
+
+    output_text = report_text.rstrip() + "\n" + "\n".join(appendix_lines)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(output_text, encoding="utf-8")
+
+    print(f"Created: {output_path}")
+    print(f"Input report preserved: {input_path}")
+    print(f"Attached files: {len(files)}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

Report/header.tex

@@ -0,0 +1,16 @@
+\usepackage{fvextra}
+\DefineVerbatimEnvironment{Highlighting}{Verbatim}{
+  breaklines,
+  breakanywhere,
+  commandchars=\\\{\},
+  fontsize=\small
+}
+
+\usepackage{xurl}
+\urlstyle{same}
+\setlength{\emergencystretch}{3em}
+
+\usepackage{graphicx}
+\setkeys{Gin}{width=\linewidth,height=0.80\textheight,keepaspectratio}
+\usepackage{float}
+\floatplacement{figure}{H}

Report/render_uml_png.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""
+Render PlantUML diagrams (.puml) to high-resolution PNG files via Kroki.
+
+Why this script:
+- local `plantuml` may require X11 in some environments;
+- this script uses Kroki HTTP API and can raise output quality via `skinparam dpi`.
+
+Examples:
+    python3 Report/render_uml_png.py
+    python3 Report/render_uml_png.py --dpi 360 --glob "*.puml"
+    python3 Report/render_uml_png.py --input-dir Report/uml --timeout 120
+"""
+
+from __future__ import annotations
+
+import argparse
+import io
+from pathlib import Path
+import re
+from typing import Iterable
+
+import requests
+from PIL import Image
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Render .puml diagrams to PNG with configurable DPI."
+    )
+    parser.add_argument(
+        "--input-dir",
+        default="Report/uml",
+        help="Directory with .puml files (default: Report/uml)",
+    )
+    parser.add_argument(
+        "--glob",
+        default="*.puml",
+        help="Glob pattern inside input-dir (default: *.puml)",
+    )
+    parser.add_argument(
+        "--dpi",
+        type=int,
+        default=300,
+        help="Output DPI via PlantUML skinparam (default: 300)",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=120,
+        help="HTTP timeout in seconds (default: 120)",
+    )
+    parser.add_argument(
+        "--kroki-url",
+        default="https://kroki.io/plantuml/png",
+        help="Kroki PlantUML PNG endpoint",
+    )
+    parser.add_argument(
+        "--min-dpi",
+        type=int,
+        default=96,
+        help="Lower bound for auto DPI fallback (default: 96)",
+    )
+    parser.add_argument(
+        "--max-dim",
+        type=int,
+        default=3900,
+        help=(
+            "Target max PNG dimension during auto-fit. "
+            "Keep below backend hard limits (default: 3900)"
+        ),
+    )
+    return parser.parse_args()
+
+
+def iter_puml_files(input_dir: Path, pattern: str) -> Iterable[Path]:
+    return sorted(p for p in input_dir.glob(pattern) if p.is_file())
+
+
+def inject_or_replace_skinparam(plantuml_text: str, key: str, value: int) -> str:
+    """
+    Ensure diagram has the requested `skinparam <key>`.
+    - If skinparam exists, replace it.
+    - Otherwise insert after @startuml line.
+    """
+    line_value = f"skinparam {key} {value}"
+    pattern = rf"(?im)^\s*skinparam\s+{re.escape(key)}\s+\d+\s*$"
+
+    if re.search(pattern, plantuml_text):
+        return re.sub(pattern, line_value, plantuml_text)
+
+    lines = plantuml_text.splitlines()
+    for i, line in enumerate(lines):
+        if line.strip().lower().startswith("@startuml"):
+            lines.insert(i + 1, line_value)
+            return "\n".join(lines) + ("\n" if plantuml_text.endswith("\n") else "")
+
+    # Fallback: if @startuml is missing, prepend anyway.
+    return line_value + "\n" + plantuml_text
+
+
+def render_one(
+    puml_file: Path,
+    kroki_url: str,
+    dpi: int,
+    min_dpi: int,
+    max_dim: int,
+    timeout: int,
+) -> Path:
+    source = puml_file.read_text(encoding="utf-8")
+    source = inject_or_replace_skinparam(source, "padding", 24)
+
+    current_dpi = dpi
+    png_bytes: bytes | None = None
+
+    while True:
+        payload = inject_or_replace_skinparam(source, "dpi", current_dpi)
+        response = requests.post(
+            kroki_url,
+            data=payload.encode("utf-8"),
+            timeout=timeout,
+        )
+        response.raise_for_status()
+        candidate = response.content
+
+        with Image.open(io.BytesIO(candidate)) as im:
+            width, height = im.size
+
+        # Kroki/PlantUML PNG responses may hit hard canvas limits.
+        # If we are close to that ceiling, lower DPI and retry.
+        if (width > max_dim or height > max_dim) and current_dpi > min_dpi:
+            next_dpi = max(min_dpi, int(current_dpi * 0.82))
+            if next_dpi == current_dpi:
+                next_dpi = current_dpi - 1
+            current_dpi = max(min_dpi, next_dpi)
+            continue
+
+        png_bytes = candidate
+        break
+
+    if png_bytes is None:
+        raise RuntimeError(f"Failed to render diagram: {puml_file}")
+
+    out_file = puml_file.with_suffix(".png")
+    out_file.write_bytes(png_bytes)
+    return out_file
+
+
+def main() -> int:
+    args = parse_args()
+
+    input_dir = Path(args.input_dir).resolve()
+    if not input_dir.exists():
+        raise FileNotFoundError(f"Input directory not found: {input_dir}")
+
+    files = list(iter_puml_files(input_dir, args.glob))
+    if not files:
+        print(f"No files matched in {input_dir} with pattern {args.glob}")
+        return 0
+
+    print(f"Rendering {len(files)} diagrams from: {input_dir}")
+    print(f"DPI: {args.dpi}")
+
+    success = 0
+    for puml in files:
+        out = render_one(
+            puml_file=puml,
+            kroki_url=args.kroki_url,
+            dpi=args.dpi,
+            min_dpi=args.min_dpi,
+            max_dim=args.max_dim,
+            timeout=args.timeout,
+        )
+        print(f"created {out}")
+        success += 1
+
+    print(f"Done: {success}/{len(files)} PNG files generated.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

Report/uml/canvas-viewport-algorithm.puml

@@ -0,0 +1,35 @@
+@startuml
+title Canvas/ViewPort: алгоритм вычисления видимой области и редроу
+
+start
+:Get zoomed document rect\n(getZoomedImageSize);
+:Read viewport rect + scroll offset;
+:Compute visible width/height\nmin(viewport, image size);
+:Compute raw visible x/y\nfrom scroll - image offset;
+:Clamp x/y into image bounds;
+:Store Rect_i{x,y,w,h} as _visible_rect;
+
+if (visible rect changed\nOR texture is null?) then (yes)
+  :request redraw;
+else (no)
+  :no redraw needed;
+endif
+
+if (redraw pending?) then (yes)
+  :Read render quality %;
+  :Convert area-quality to side-scale\nscale = sqrt(q/100);
+  :Scale full canvas size;
+  :Scale visible rect;
+  :Clamp scaled rect to scaled canvas;
+  if (scaled visible rect valid?) then (yes)
+    :Render only scaled visible area\nthrough RenderEngine;
+    :Update texture + stats + throttle;
+  else (no)
+    :Drop texture / skip rendering;
+  endif
+else (no)
+  :Keep previous frame;
+endif
+stop
+
+@enduml

Report/uml/coordinate-pipeline.puml

@@ -0,0 +1,28 @@
+@startuml
+title Конвейер координат: Local -> World -> Canvas -> Buffer
+
+skinparam rectangle {
+  RoundCorner 10
+}
+
+rectangle "Local coords\n(object space)" as L
+rectangle "World coords\n(document space)" as W
+rectangle "Canvas coords\n(scaled document)" as C
+rectangle "Buffer coords\n(visible rect origin)" as B
+
+L --> W : localToWorld()\nrotate + scale + translate
+W --> C : world * scale_x/scale_y
+C --> B : subtract visible_rect.(x,y)
+
+B --> C : + visible_rect.(x,y)
+C --> W : divide by scale_x/scale_y
+W --> L : worldToLocal()\ntranslate^-1 + rotate^-1 + scale^-1
+
+note right of B
+All raster tests are done
+in buffer coords (integer pixels).
+Shape analytics often done
+in local coords after inverse map.
+end note
+
+@enduml

Report/uml/ellipse-arc-rasterization.puml

@@ -0,0 +1,43 @@
+@startuml
+title Эллипс/дуга: алгоритм растризации
+
+start
+:Read rx, ry, thickness,\narc_percent, closed, filled;
+if (rx<=0 or ry<=0?) then (yes)
+  stop
+endif
+
+:Build local bbox corners with margin;
+:Transform corners to buffer\nand compute pixel scan bounds;
+:Create temporary transparent buffer;
+if (do_fill?) then (yes)
+  :startFill() collect border pixels;
+endif
+
+while (for each pixel in bbox)
+  :Map pixel center Buffer -> World -> Local;
+  :nx = x/rx, ny = y/ry,\nd = nx^2 + ny^2;
+  if (d in stroke ring?) then (yes)
+    if (arc_percent < 100?) then (yes)
+      :Compute angular position\nvia atan2 and normalized diff;
+      if (inside arc sector?) then (yes)
+        :plot stroke pixel;
+      endif
+    else (full ellipse)
+      :plot stroke pixel;
+    endif
+  endif
+endwhile
+
+if (closed and arc_percent<100?) then (yes)
+  :Draw two radial segments\n(center->start and center->end);
+endif
+
+if (do_fill?) then (yes)
+  :stopFill(fill_color);
+endif
+
+:Composite temp buffer to target\nonce with object opacity;
+stop
+
+@enduml

Report/uml/liang-barsky-clip.puml

@@ -0,0 +1,34 @@
+@startuml
+title Liang-Barsky: отсечение отрезка прямоугольником
+
+start
+:Input segment P0,P1 and clip rect;
+:dx = x1-x0, dy = y1-y0;
+:t0 = 0, t1 = 1;
+
+:Process boundary x >= left\np=-dx, q=x0-left;
+if (clip test fails?) then (yes)
+  stop
+endif
+
+:Process boundary x <= right\np=dx, q=right-x0;
+if (clip test fails?) then (yes)
+  stop
+endif
+
+:Process boundary y >= top\np=-dy, q=y0-top;
+if (clip test fails?) then (yes)
+  stop
+endif
+
+:Process boundary y <= bottom\np=dy, q=bottom-y0;
+if (clip test fails?) then (yes)
+  stop
+endif
+
+:Compute clipped points:\nP0' = P0 + t0*(P1-P0)\nP1' = P0 + t1*(P1-P0);
+:Round to integer pixels;
+:Return accepted clipped segment;
+stop
+
+@enduml

Report/uml/line-rasterization-flow.puml

@@ -0,0 +1,30 @@
+@startuml
+title Линия: полная схема растризации
+
+start
+:Input local endpoints (x0,y0),(x1,y1)\n+ color + thickness;
+:Map endpoints Local -> World -> Buffer;
+:Compute pixel thickness from transform scale;
+if (thickness_px <= 0?) then (yes)
+  stop
+endif
+
+if (draw_when_outside == false?) then (yes)
+  :Clip segment to expanded buffer bounds\n(Liang-Barsky);
+  if (segment rejected?) then (yes)
+    stop
+  endif
+endif
+
+:Compute angle-based thickness correction\n(using |dx|/len and |dy|/len);
+:Initialize Bresenham state\ndx,dy,sx,sy,err;
+
+while (not reached end point?)
+  :Choose effective half-thickness:\nfull in viewport, 0 outside if draw_when_outside;
+  :Draw stripe around center pixel\n(along normal axis);
+  :Advance Bresenham step by error update;
+endwhile
+
+stop
+
+@enduml

Report/uml/pma-alpha-blending.puml

@@ -0,0 +1,27 @@
+@startuml
+title PMA alpha blending в blendPixelAtBuffer
+
+start
+:Input dst pixel, src PMA pixel,\ntransform opacity;
+if (pixel outside buffer?) then (yes)
+  stop
+endif
+
+if (replace_mode?) then (yes)
+  :dst = src;
+  stop
+endif
+
+:a = (src.a / 255) * opacity;
+:inv_a = 1 - a;
+:src_rgb = src.rgb * opacity;
+
+:dst.r = clamp(src_r + inv_a * dst.r);
+:dst.g = clamp(src_g + inv_a * dst.g);
+:dst.b = clamp(src_b + inv_a * dst.b);
+:dst.a = clamp(a*255 + inv_a * dst.a);
+
+:Store dst pixel;
+stop
+
+@enduml

Report/uml/polyline-fill-algorithm.puml

@@ -0,0 +1,29 @@
+@startuml
+title Ломаная + заливка: 3-фазный алгоритм
+
+start
+:Input points[], closed, filled;
+if (points < 2?) then (yes)
+  stop
+endif
+
+:Create temporary buffer + copy context;
+if (closed and filled?) then (yes)
+  :Enable FillCanvas (startFill);
+endif
+
+:Draw all segments Pi->Pi+1;
+if (closed?) then (yes)
+  :Draw segment Pn->P0;
+endif
+
+if (fill enabled?) then (yes)
+  :Phase 1:\nBorder pixels already collected in hash-set;
+  :Phase 2:\nSort border keys by (y,x),\nfind row segments,\nchoose interior seeds;
+  :Phase 3:\nStack flood fill (4-neighbors),\nskip border/visited,\npaint fill color;
+endif
+
+:Composite temporary buffer to target once;
+stop
+
+@enduml

Report/uml/transform-compose-algorithm.puml

@@ -0,0 +1,19 @@
+@startuml
+title Алгоритм композиции трансформаций (parent * local)
+
+start
+:Input parent transform:\nP(tx,ty,angle,sx,sy,opacity);
+:Input local transform:\nL(tx,ty,angle,sx,sy,opacity);
+
+:Scale local position by parent scale:\nlx' = L.tx * P.sx\nly' = L.ty * P.sy;
+:Rotate by parent angle:\nrx = cos(P.a)*lx' - sin(P.a)*ly'\nry = sin(P.a)*lx' + cos(P.a)*ly';
+:Translate by parent position:\nW.tx = P.tx + rx\nW.ty = P.ty + ry;
+
+:Compose angle:\nW.angle = P.angle + L.angle;
+:Compose scale:\nW.sx = P.sx * L.sx\nW.sy = P.sy * L.sy;
+:Compose opacity:\nW.opacity = P.opacity * L.opacity;
+
+:Return world transform W;
+stop
+
+@enduml

Report/uml/zivro-architecture-components.puml

@@ -0,0 +1,49 @@
+@startuml
+title Zivro: компонентная архитектура
+
+skinparam componentStyle rectangle
+skinparam shadowing false
+
+package "UI Layer" {
+  [main.zig\nEvent Loop]
+  [ui/*\nMenu/Tab/Panels]
+  [Canvas.zig\nViewport + Redraw]
+}
+
+package "Application State" {
+  [WindowContext.zig\nOpenDocument tabs]
+  [models/Document.zig\nObject tree]
+  [models/Object.zig\nProperties + Children]
+}
+
+package "Render Layer" {
+  [RenderEngine.zig\nInterface]
+  [CpuRenderEngine.zig\nCPU backend]
+  [cpu/draw.zig\nRecursive draw]
+  [cpu/pipeline.zig\nTransforms + blend]
+  [cpu/line.zig]
+  [cpu/ellipse.zig]
+  [cpu/broken.zig]
+}
+
+package "Persistence" {
+  [persistence/json_io.zig]
+}
+
+[main.zig\nEvent Loop] --> [WindowContext.zig\nOpenDocument tabs]
+[ui/*\nMenu/Tab/Panels] --> [WindowContext.zig\nOpenDocument tabs]
+[Canvas.zig\nViewport + Redraw] --> [RenderEngine.zig\nInterface]
+[Canvas.zig\nViewport + Redraw] --> [models/Document.zig\nObject tree]
+[WindowContext.zig\nOpenDocument tabs] --> [Canvas.zig\nViewport + Redraw]
+[WindowContext.zig\nOpenDocument tabs] --> [CpuRenderEngine.zig\nCPU backend]
+
+[RenderEngine.zig\nInterface] <|.. [CpuRenderEngine.zig\nCPU backend]
+[CpuRenderEngine.zig\nCPU backend] --> [cpu/draw.zig\nRecursive draw]
+[cpu/draw.zig\nRecursive draw] --> [cpu/pipeline.zig\nTransforms + blend]
+[cpu/draw.zig\nRecursive draw] --> [cpu/line.zig]
+[cpu/draw.zig\nRecursive draw] --> [cpu/ellipse.zig]
+[cpu/draw.zig\nRecursive draw] --> [cpu/broken.zig]
+[models/Document.zig\nObject tree] --> [models/Object.zig\nProperties + Children]
+[persistence/json_io.zig] ..> [models/Document.zig\nObject tree] : save/load
+
+@enduml

Report/uml/zivro-render-sequence.puml

@@ -0,0 +1,33 @@
+@startuml
+title Zivro: последовательность рендера кадра (CPU)
+
+actor User
+participant "UI Frame\n(frame.zig)" as UI
+participant "Canvas\n(Canvas.zig)" as Canvas
+participant "RenderEngine" as RE
+participant "CpuRenderEngine" as CPU
+participant "drawDocument\n(cpu/draw.zig)" as Draw
+participant "Shape modules\nline/ellipse/broken" as Shapes
+
+User -> UI : input/events
+UI -> Canvas : processPendingRedraw()
+alt redraw pending and throttle passed
+  Canvas -> Canvas : computeVisibleImageRect()\ncompute quality scale
+  Canvas -> RE : render(document, canvas_size, visible_rect)
+  RE -> CPU : renderDocument(...)
+  CPU -> Draw : drawDocument(pixels,...)
+  loop for each root object
+    Draw -> Draw : Transform.compose(parent, local)
+    Draw -> Shapes : draw shape by object.kind
+    loop for each child
+      Draw -> Draw : recursive drawObject(child, world_transform)
+    end
+  end
+  Draw --> CPU : pixels rendered
+  CPU --> Canvas : texture
+  Canvas -> UI : texture for draw
+else no redraw
+  Canvas -> UI : keep previous texture
+end
+
+@enduml

Report/zivro-open-project-report.md

@@ -0,0 +1,427 @@
+# Лабораторная работа 3  
+## Анализ и описание открытого проекта `Zivro`
+
+## 1. Цель работы
+
+Изучить архитектуру и ключевые алгоритмы открытого графического проекта, реализованного на языке Zig, и подготовить технический отчёт по его устройству, процессу сборки и принципам работы основных подсистем.
+
+## 2. Постановка задачи
+
+В рамках лабораторной работы требуется:
+
+- выбрать открытый проект и изучить его структуру;
+- выделить основные модули и описать их взаимодействие;
+- разобрать математические алгоритмы, используемые в проекте;
+- описать процесс сборки, запуска и тестирования;
+- подготовить отчёт в формате Markdown;
+- сформировать приложение с исходным кодом автоматически, без ручной вставки кода в текст отчёта.
+
+## 3. Краткое описание проекта
+
+В качестве открытого проекта выбран `Zivro` - настольное графическое приложение для работы с векторными объектами (линия, эллипс, ломаная), с собственной моделью документа, иерархией объектов и CPU-рендерингом.
+
+Приложение использует:
+
+- язык `Zig`;
+- UI-библиотеку `dvui` с SDL3-бэкендом;
+- модульную архитектуру (UI, модель данных, рендер, сериализация, инструменты).
+
+Точка входа находится в `src/main.zig`: создаётся окно, инициализируется `WindowContext`, далее выполняется event/render loop.
+
+## 4. Структура проекта
+
+Основные каталоги и файлы:
+
+- `build.zig` - сценарий сборки и шагов `run`/`test`;
+- `src/main.zig` - запуск приложения и главный цикл;
+- `src/WindowContext.zig` - управление открытыми документами и активным документом;
+- `src/Canvas.zig` - логика холста, масштабирование, вычисление видимой области, запуск рендера;
+- `src/models/*` - модель документа, объектов и их свойств;
+- `src/render/*` - CPU-рендер и конвейер отрисовки;
+- `src/persistence/json_io.zig` - сохранение/загрузка документов в JSON;
+- `src/ui/*` - интерфейсные панели и компоновка экрана;
+- `src/tests.zig` - entry-point тестов.
+
+## 5. Архитектура приложения
+
+### 5.1. Высокоуровневая схема
+
+Архитектурно проект разделён на три уровня:
+
+1. **UI-уровень** (`src/ui`, `src/Canvas.zig`)  
+   Обрабатывает пользовательские события, отображает панели и холст, передаёт действия в модель и рендер.
+
+2. **Модель данных** (`src/models`)  
+   Хранит документ, дерево объектов и свойства (позиция, угол, масштаб, цвет, точки, радиусы и др.).
+
+3. **Рендер-уровень** (`src/render`)  
+   Преобразует модель объектов в набор пикселей видимой области и формирует текстуру.
+
+### 5.2. Управление документами
+
+`WindowContext` хранит массив открытых документов (`OpenDocument`) и индекс активного документа.  
+Каждый `OpenDocument` содержит:
+
+- `Document`;
+- экземпляр `CpuRenderEngine`;
+- `Canvas`;
+- идентификатор выбранного объекта.
+
+Это позволяет одновременно работать с несколькими документами во вкладках.
+
+### 5.3. Рендер-конвейер
+
+Ключевой путь рендера:
+
+1. `Canvas.redraw()` вычисляет масштаб качества и видимую часть документа;
+2. вызывается `RenderEngine.render(...)` (в текущей конфигурации CPU-вариант);
+3. `CpuRenderEngine.renderDocument(...)` подготавливает пиксельный буфер;
+4. `cpu/draw.zig` рекурсивно обходит объекты документа;
+5. для каждого объекта применяется `Transform.compose(parent, local)`;
+6. shape-специфичные модули рисуют примитивы в буфер;
+7. буфер превращается в текстуру UI.
+
+## 6. Математические алгоритмы проекта (подробное текстовое описание)
+
+В данном разделе подробно рассмотрены алгоритмы, которые формируют геометрию и цвет в CPU-рендере.  
+Диаграммы PlantUML будут добавлены отдельным шагом, после фиксации текстовой части.
+
+### 6.1. Иерархические трансформации объектов
+
+В основе рендера лежит сцена-дерево: каждый объект может иметь дочерние элементы.  
+Следовательно, координаты дочернего объекта заданы не в мировой системе, а в системе координат родителя.
+
+В `Transform` хранятся:
+
+- `position = (tx, ty)` - перенос;
+- `angle = a` - поворот;
+- `scale = (sx, sy)` - независимый масштаб по осям;
+- `opacity = o` - накопленная непрозрачность.
+
+Для перехода из локальных координат объекта к мировым используется аффинное преобразование:
+
+$$
+\begin{aligned}
+x_w &= t_x + (x_l \cdot s_x)\cos a - (y_l \cdot s_y)\sin a, \\
+y_w &= t_y + (x_l \cdot s_x)\sin a + (y_l \cdot s_y)\cos a.
+\end{aligned}
+$$
+
+При композиции `parent * local` (в `Transform.compose`) выполняются шаги:
+
+1. локальная позиция сначала масштабируется масштабом родителя;
+2. результат поворачивается на угол родителя;
+3. добавляется перенос родителя;
+4. углы складываются: `a_world = a_parent + a_local`;
+5. масштабы перемножаются покомпонентно: `sx_world = sx_parent * sx_local`, `sy_world = sy_parent * sy_local`;
+6. прозрачности перемножаются: `o_world = o_parent * o_local`.
+
+Почему это важно: такой порядок гарантирует, что при повороте/масштабе группы объектов дочерние элементы ведут себя как единая связанная конструкция.
+
+### 6.2. Цепочка преобразований координат в рендере
+
+Рендер использует 4 системы координат:
+
+1. **локальная** (внутри shape);  
+2. **мировая** (внутри документа);  
+3. **координаты канвы** (после масштабирования документа под текущий размер);  
+4. **координаты буфера viewport** (видимая часть, начинающаяся с `(0,0)`).
+
+Основные формулы:
+
+- `canvas_x = world_x * scale_x`, `canvas_y = world_y * scale_y`;
+- `buffer_x = canvas_x - visible_rect.x`, `buffer_y = canvas_y - visible_rect.y`.
+
+Обратное преобразование также используется (например, в эллипсе):
+
+- `canvas_x = buffer_x + visible_rect.x`, `canvas_y = buffer_y + visible_rect.y`;
+- `world_x = canvas_x / scale_x`, `world_y = canvas_y / scale_y`.
+
+Для вычисления локальных координат из мировых применяется обратный поворот и обратный масштаб:
+
+$$
+\begin{aligned}
+dx &= x_w - t_x,\quad dy = y_w - t_y, \\
+x_l &= \frac{dx\cos(-a)-dy\sin(-a)}{s_x}, \\
+y_l &= \frac{dx\sin(-a)+dy\cos(-a)}{s_y}.
+\end{aligned}
+$$
+
+Практический смысл: shape можно тестировать аналитически (по формулам) в "своей" удобной локальной системе, независимо от того, как он повернут и где расположен в документе.
+
+### 6.3. Рисование линии: отсечение + дискретизация + толщина
+
+Алгоритм в `line.zig` состоит из трёх частей.
+
+#### 6.3.1. Отсечение Liang-Barsky
+
+Перед рисованием линия отсекается расширенным прямоугольником буфера.  
+Параметрическая форма отрезка:
+
+$$
+P(t)=P_0+t(P_1-P_0),\quad t\in[0,1].
+$$
+
+Для каждого ограничения (`x >= left`, `x <= right`, `y >= top`, `y <= bottom`) обновляется допустимый интервал `[t0, t1]`.  
+Если после обработки ограничений `t0 > t1`, отрезок полностью вне экрана и пропускается.
+
+Преимущество: вместо "шагать по пикселям и каждый проверять границы" рендер сразу работает только с видимым отрезком.
+
+#### 6.3.2. Дискретизация линии (Bresenham-подобный проход)
+
+После отсечения используются целочисленные приращения:
+
+- `dx = abs(x1 - x0)`, `dy = -abs(y1 - y0)`;
+- `sx = sign(x1 - x0)`, `sy = sign(y1 - y0)`;
+- ошибка `err = dx + dy`.
+
+На каждом шаге:
+
+- вычисляется `e2 = 2*err`;
+- если `e2 >= dy`, двигаемся по `x`;
+- если `e2 <= dx`, двигаемся по `y`.
+
+Это классическая идея целочисленного интегрирования ошибки для аппроксимации идеального непрерывного отрезка на пиксельной сетке.
+
+#### 6.3.3. Толщина и коррекция по углу
+
+Если просто расширять линию равномерно, визуальная толщина может "плыть" при разных углах.  
+В проекте вычисляется поправка по длине проекций:
+
+- `cos(theta) = |dx| / len`;
+- `sin(theta) = |dy| / len`;
+- выбирается базис (по X или Y), где ошибка толщины минимальна;
+- итоговая толщина пересчитывается через деление на `max(sin, eps)` или `max(cos, eps)`.
+
+Далее вокруг центрального пикселя проводится полоса ширины `thickness_corrected`.
+
+Дополнительно есть режим `draw_when_outside`:
+
+- внутри viewport рисуется полная толщина;
+- за пределами viewport — только 1px, чтобы контур не "взрывался" по ширине за экраном.
+
+### 6.4. Растрирование эллипса и дуги
+
+Алгоритм `ellipse.zig` не использует инкрементальные midpoint-формулы, а работает через аналитическую проверку каждого пикселя в ограничивающем прямоугольнике.
+
+#### 6.4.1. Нормализация координат
+
+Для пикселя вычисляются локальные координаты `loc = (x_l, y_l)` и нормализуются:
+
+$$
+n_x = \frac{x_l}{r_x},\quad n_y = \frac{y_l}{r_y},\quad d=n_x^2+n_y^2.
+$$
+
+- `d = 1` соответствует идеальному контуру эллипса;
+- `d < 1` внутри;
+- `d > 1` снаружи.
+
+#### 6.4.2. Полоса обводки заданной толщины
+
+Толщина `thickness` переводится в нормированное пространство через меньшую полуось:
+
+- `half_norm = thickness / (2*min(rx, ry))`;
+- внутренний радиус: `inner = max(0, 1 - half_norm)`;
+- внешний радиус: `outer = 1 + half_norm`.
+
+Пиксель принадлежит обводке, если:
+
+$$
+inner^2 \le d \le outer^2.
+$$
+
+Это даёт геометрически корректную полосу вокруг эллипса при произвольном повороте/масштабе объекта.
+
+#### 6.4.3. Дуга через угловой фильтр
+
+Если `arc_percent < 100`, из полного эллипса берётся только часть:
+
+- вычисляется длина дуги в радианах: `arc_len = 2*pi*arc_percent/100`;
+- для пикселя находится угол через `atan2(ny, nx)` (с поправкой на экранную систему);
+- точка принимается только если её угловая позиция не превышает `arc_len`.
+
+Если `closed = true`, концы дуги соединяются с центром двумя радиальными отрезками (используется общий алгоритм линии).
+
+### 6.5. Ломаная, выделение границы и заливка
+
+В `broken.zig` ломаная строится как цепочка сегментов `P0->P1->...->Pn`, а при `closed` добавляется `Pn->P0`.
+
+Для корректной заливки применяется двухфазный алгоритм.
+
+#### 6.5.1. Фаза 1: сбор пикселей границы
+
+Во временном `FillCanvas` при каждом `blendPixelAtBuffer` сохраняется координата пикселя как граничная точка (`border_set`).
+
+Смысл: сначала зафиксировать "жёсткий" контур, затем независимо заполнить внутренность.
+
+#### 6.5.2. Фаза 2: поиск внутренних сегментов по строкам
+
+Граничные пиксели сортируются по `(y, x)`. Для каждой строки:
+
+1. выделяются последовательности рёбер;
+2. строятся интервалы между соседними рёбрами;
+3. из подходящих интервалов выбираются seed-точки (середина интервала).
+
+Это снижает риск старта flood fill с внешней стороны фигуры.
+
+#### 6.5.3. Фаза 3: flood fill (4-связность)
+
+От каждого seed выполняется стековый обход соседей:
+
+- влево, вправо, вверх, вниз;
+- граничные пиксели не пересекаются;
+- уже посещённые пиксели пропускаются.
+
+Каждый найденный внутренний пиксель окрашивается в `fill_color`.
+
+Почему используется отдельный буфер: при полупрозрачности иначе одна и та же область может смешаться несколько раз из-за пересечения сегментов.
+
+### 6.6. Альфа-смешивание в Premultiplied Alpha (PMA)
+
+Для каждого канала цвета применяется модель:
+
+$$
+C_{out} = C_{src} + (1-\alpha_{src})C_{dst},
+\quad
+\alpha_{out} = \alpha_{src} + (1-\alpha_{src})\alpha_{dst}.
+$$
+
+В коде `C_src` уже premultiplied (или домножается на opacity трансформа в момент смешивания).
+
+Пошагово:
+
+1. берётся альфа источника `a = src_a/255 * transform.opacity`;
+2. вычисляется `inv_a = 1 - a`;
+3. каналы `r,g,b` источника масштабируются на `transform.opacity`;
+4. формируется новый `dst` по PMA-формуле.
+
+`replace_mode = true` отключает смешивание и просто заменяет пиксель.  
+Этот режим используется во временных буферах shape-рендера, а затем результат один раз композится в целевой буфер.
+
+### 6.7. Численная устойчивость и ограничения
+
+В алгоритмах предусмотрены защиты от деградации вычислений:
+
+- защита от деления на ноль в обратных преобразованиях (`scale == 0 -> 1.0`);
+- использование `eps` в коррекции толщины линий;
+- ограничение минимальных размеров рендер-буфера (`>= 1 px`);
+- отсечение слишком больших выходов за viewport до начала растрирования;
+- явное округление float->int в точках, где нужна стабильная пиксельная привязка.
+
+Это снижает число визуальных артефактов при малых масштабах, сильных поворотах и частичной видимости объектов.
+
+## 7. Работа с данными и сериализация
+
+Модуль `src/persistence/json_io.zig` поддерживает:
+
+- `saveToFile(...)` - сериализация в JSON (pretty-print);
+- `loadFromFile(...)` - чтение JSON и восстановление структуры.
+
+Для `Document` после парсинга выполняется клонирование, чтобы избежать проблем владения памятью (парсер выделяет память из арены).
+
+## 8. Сборка, запуск и тестирование
+
+### 8.1. Сборка и запуск
+
+```bash
+zig build
+zig build run
+```
+
+### 8.2. Запуск тестов
+
+```bash
+zig build test
+```
+
+Файл `src/tests.zig` подключает модули с `test`-блоками, чтобы они выполнялись в составе общего тестового шага.
+
+## 9. Автоматическое формирование приложения с исходным кодом
+
+Чтобы не вставлять исходники вручную в конец отчёта, используется скрипт `Report/append_sources_to_report.py`.
+
+Скрипт:
+
+- читает исходный `.md` отчёт;
+- добавляет раздел с кодом файлов проекта;
+- перед каждым листингом вставляет путь файла;
+- сохраняет результат в новый `.md` файл;
+- исходный отчёт не изменяет.
+
+Пример запуска:
+
+```bash
+python3 Report/append_sources_to_report.py \
+  --input Report/zivro-open-project-report.md \
+  --output Report/zivro-open-project-report-with-code.md \
+  --base .
+```
+
+## 10. PlantUML-диаграммы
+
+Для отчёта подготовлены диаграммы в формате PlantUML (`.puml`) и сгенерированы их PNG-версии для прямой вставки в документ.
+
+### 10.1. Архитектура проекта
+
+`Report/uml/zivro-architecture-components.puml` - компонентная архитектура приложения.
+
+![Компонентная архитектура Zivro](uml/zivro-architecture-components.png)
+
+`Report/uml/zivro-render-sequence.puml` - последовательность рендера кадра.
+
+![Последовательность рендера кадра](uml/zivro-render-sequence.png)
+
+### 10.2. Управление холстом и viewport
+
+`Report/uml/canvas-viewport-algorithm.puml` - вычисление видимой области, масштабирование по качеству, условия редроу.
+
+![Алгоритм управления viewport и redraw](uml/canvas-viewport-algorithm.png)
+
+### 10.3. Алгоритмы обработки данных и растризации
+
+`Report/uml/transform-compose-algorithm.puml` - композиция трансформаций в иерархии объектов.
+
+![Композиция трансформаций](uml/transform-compose-algorithm.png)
+
+`Report/uml/coordinate-pipeline.puml` - конвейер преобразований координат.
+
+![Конвейер преобразований координат](uml/coordinate-pipeline.png)
+
+`Report/uml/line-rasterization-flow.puml` - полный алгоритм отрисовки линии.
+
+![Полный алгоритм растрирования линии](uml/line-rasterization-flow.png)
+
+`Report/uml/liang-barsky-clip.puml` - шаги отсечения отрезка методом Liang-Barsky.
+
+![Алгоритм Liang-Barsky](uml/liang-barsky-clip.png)
+
+`Report/uml/ellipse-arc-rasterization.puml` - растрирование эллипса/дуги.
+
+![Алгоритм растрирования эллипса и дуги](uml/ellipse-arc-rasterization.png)
+
+`Report/uml/polyline-fill-algorithm.puml` - построение и заливка замкнутой ломаной.
+
+![Алгоритм ломаной и заливки](uml/polyline-fill-algorithm.png)
+
+`Report/uml/pma-alpha-blending.puml` - PMA alpha-композиция пикселей.
+
+![PMA alpha-композиция пикселя](uml/pma-alpha-blending.png)
+
+### 10.4. Скрипт генерации PNG-диаграмм
+
+Для повторной генерации PNG сохранён отдельный скрипт:
+
+- `Report/render_uml_png.py`
+
+Пример запуска в высоком качестве:
+
+```bash
+python3 Report/render_uml_png.py --input-dir Report/uml --dpi 360
+```
+
+## 11. Выводы
+
+В ходе работы изучен открытый проект `Zivro` и подготовлено структурированное описание его архитектуры. Проект реализует модульный подход: модель документа, иерархию объектов, CPU-рендер с преобразованиями координат и отдельные алгоритмы растеризации геометрии.
+
+Ключевые математические части - композиция трансформаций, отсечение и растеризация линий, рендер эллипсов/дуг, а также алгоритм заливки замкнутых контуров.  
+Текстовый отчёт подготовлен без встроенных листингов кода; для генерации версии с приложением исходников создан отдельный автоматизированный скрипт.