747 lines
29 KiB
Python
747 lines
29 KiB
Python
#!/usr/bin/env python3
|
|
"""Generate style-specific 1:1 A3 clay templates for SOFT FACET V2.
|
|
|
|
The PDF contains:
|
|
1. A quick one-piece frustum blank with an 8 mm overlap.
|
|
2. Four style-specific gores for a lower-strain, more accurate assembly.
|
|
3. The exact raw-clay support plate outline.
|
|
|
|
Both size presets are supported. Use --all-styles to generate one PDF/SVG/JSON
|
|
set for every OpenSCAD surface style.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import copy
|
|
import json
|
|
import math
|
|
from dataclasses import asdict, dataclass
|
|
from pathlib import Path
|
|
from typing import Iterable, Sequence
|
|
|
|
from reportlab.lib.colors import HexColor
|
|
from reportlab.lib.pagesizes import A3, landscape
|
|
from reportlab.lib.units import mm
|
|
from reportlab.pdfbase import pdfmetrics
|
|
from reportlab.pdfbase.ttfonts import TTFont
|
|
from reportlab.pdfgen import canvas
|
|
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
DEFAULT_SVG_DIR = ROOT / "output/svg"
|
|
OUTPUT_ROOT = ROOT / "output"
|
|
SURFACE_STYLES = (
|
|
"smooth_sculpted", "vertical_soft", "horizontal_rings", "cross_wave",
|
|
"diagonal_flow", "woven_cells", "organic_asymmetric", "ribbed_petal",
|
|
"pillow_facets", "dimpled_grid", "spiral_flow",
|
|
)
|
|
PRESET_DEFAULTS = {
|
|
"v60_01": {
|
|
"target_inner_top_d": 114.0,
|
|
"target_inner_outlet_d": 20.0,
|
|
"target_inner_height": 87.0,
|
|
"support_finished_span": 117.0,
|
|
"support_finished_hole_d": 20.0,
|
|
},
|
|
"v60_02": {
|
|
"target_inner_top_d": 124.0,
|
|
"target_inner_outlet_d": 21.0,
|
|
"target_inner_height": 95.0,
|
|
"support_finished_span": 127.0,
|
|
"support_finished_hole_d": 21.0,
|
|
},
|
|
}
|
|
|
|
BLACK = HexColor("#1D252C")
|
|
GRAY = HexColor("#69757D")
|
|
LIGHT_GRAY = HexColor("#D7DDE1")
|
|
ACCENT = HexColor("#B6412D")
|
|
OCHRE = HexColor("#C7922B")
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class TemplateDimensions:
|
|
model_version: str
|
|
preset: str
|
|
surface_style: str
|
|
release_scale: float
|
|
minimum_release_draft_angle_deg: float
|
|
shrink_percent: float
|
|
slab_thickness_mm: float
|
|
master_top_radius_mm: float
|
|
master_bottom_radius_mm: float
|
|
master_height_mm: float
|
|
average_meridian_length_mm: float
|
|
single_piece_outer_radius_mm: float
|
|
single_piece_inner_radius_mm: float
|
|
single_piece_angle_deg: float
|
|
seam_allowance_mm: float
|
|
gore_count: int
|
|
gore_top_widths_mm: list[float]
|
|
gore_bottom_widths_mm: list[float]
|
|
gore_heights_mm: list[float]
|
|
support_max_span_mm: float
|
|
support_min_span_mm: float
|
|
support_hole_diameter_mm: float
|
|
|
|
|
|
def parse_args() -> argparse.Namespace:
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("--preset", choices=("v60_01", "v60_02", "custom"), default="v60_02")
|
|
parser.add_argument("--surface-style", choices=SURFACE_STYLES, default="smooth_sculpted")
|
|
parser.add_argument("--all-styles", action="store_true")
|
|
parser.add_argument("--target-inner-top-d", type=float, default=None)
|
|
parser.add_argument("--target-inner-outlet-d", type=float, default=None)
|
|
parser.add_argument("--target-inner-height", type=float, default=None)
|
|
parser.add_argument("--support-finished-span", type=float, default=None)
|
|
parser.add_argument("--support-finished-hole-d", type=float, default=None)
|
|
parser.add_argument("--shrink-percent", type=float, default=12.0)
|
|
parser.add_argument("--slab-thickness", type=float, default=5.0)
|
|
parser.add_argument("--support-corner-ratio", type=float, default=0.18)
|
|
parser.add_argument("--profile-power", type=float, default=0.97)
|
|
parser.add_argument("--minimum-release-draft-angle", type=float, default=5.0)
|
|
parser.add_argument("--seam-allowance", type=float, default=8.0)
|
|
parser.add_argument("--gores", type=int, default=4)
|
|
parser.add_argument("--output-root", type=Path, default=OUTPUT_ROOT)
|
|
parser.add_argument("--pdf", type=Path, default=None)
|
|
parser.add_argument("--data", type=Path, default=None)
|
|
parser.add_argument("--svg-dir", type=Path, default=None)
|
|
args = parser.parse_args()
|
|
|
|
for field, value in PRESET_DEFAULTS.get(args.preset, {}).items():
|
|
if getattr(args, field) is None:
|
|
setattr(args, field, value)
|
|
|
|
if args.preset == "custom":
|
|
required = (
|
|
"target_inner_top_d",
|
|
"target_inner_outlet_d",
|
|
"target_inner_height",
|
|
"support_finished_span",
|
|
"support_finished_hole_d",
|
|
)
|
|
missing = [field for field in required if getattr(args, field) is None]
|
|
if missing:
|
|
raise ValueError("custom preset requires explicit values for: " + ", ".join(missing))
|
|
|
|
return args
|
|
|
|
|
|
def validate(args: argparse.Namespace) -> None:
|
|
if not 0 <= args.shrink_percent < 100:
|
|
raise ValueError("shrink-percent must be in the range 0..99")
|
|
positive = {
|
|
"target-inner-top-d": args.target_inner_top_d,
|
|
"target-inner-outlet-d": args.target_inner_outlet_d,
|
|
"target-inner-height": args.target_inner_height,
|
|
"support-finished-span": args.support_finished_span,
|
|
"support-finished-hole-d": args.support_finished_hole_d,
|
|
"slab-thickness": args.slab_thickness,
|
|
"seam-allowance": args.seam_allowance,
|
|
}
|
|
for name, value in positive.items():
|
|
if value is None or value <= 0:
|
|
raise ValueError(f"{name} must be greater than zero")
|
|
if args.target_inner_top_d <= args.target_inner_outlet_d:
|
|
raise ValueError("top diameter must be larger than outlet diameter")
|
|
if not 0 < args.support_corner_ratio < 0.5:
|
|
raise ValueError("support-corner-ratio must be between 0 and 0.5")
|
|
if not 0 < args.minimum_release_draft_angle < 30:
|
|
raise ValueError("minimum-release-draft-angle must be between 0 and 30")
|
|
if args.gores != 4:
|
|
raise ValueError("the verified A3 layout requires exactly 4 gores")
|
|
if args.all_styles and any((args.pdf, args.data, args.svg_dir)):
|
|
raise ValueError("--pdf, --data and --svg-dir are single-style options")
|
|
|
|
|
|
def gauss(value: float, center: float, width: float) -> float:
|
|
return math.exp(-((value - center) / width) ** 2)
|
|
|
|
|
|
def edge_fade(t: float) -> float:
|
|
return max(0.0, math.sin(math.radians(180.0 * t))) ** 0.80
|
|
|
|
|
|
def sculpted_offset(t: float) -> float:
|
|
return -2.80 * gauss(t, 0.53, 0.22) + 1.60 * gauss(t, 0.88, 0.11)
|
|
|
|
|
|
def facet_local_u(angle: float, count: int) -> float:
|
|
segment = 360.0 / count
|
|
return 2.0 * (angle / segment - math.floor(angle / segment + 0.5))
|
|
|
|
|
|
def dimple_bump(value_deg: float) -> float:
|
|
return max(0.0, math.cos(math.radians(value_deg))) ** 3
|
|
|
|
|
|
def groove_profile(phase_deg: float, width_fraction: float) -> float:
|
|
return max(0.0, math.cos(math.radians(phase_deg))) ** (1.0 / max(0.05, width_fraction))
|
|
|
|
|
|
def style_offset(style: str, t: float, angle: float) -> float:
|
|
sculpted = sculpted_offset(t)
|
|
if style == "smooth_sculpted":
|
|
return sculpted
|
|
if style == "vertical_soft":
|
|
return sculpted + 2.20 * (0.25 + 0.75 * t) * math.cos(math.radians(10 * angle))
|
|
if style == "horizontal_rings":
|
|
return sculpted + 1.80 * edge_fade(t) * math.sin(math.radians(1080 * t))
|
|
if style == "cross_wave":
|
|
return sculpted + 0.72 * 2.20 * (0.25 + 0.75 * t) * math.cos(
|
|
math.radians(8 * angle)
|
|
) + 0.72 * 1.80 * edge_fade(t) * math.sin(math.radians(1080 * t))
|
|
if style == "diagonal_flow":
|
|
return sculpted + 1.80 * (0.20 + 0.80 * t) * math.cos(
|
|
math.radians(7 * angle + 360 * 0.55 * t)
|
|
)
|
|
if style == "woven_cells":
|
|
return sculpted + 1.50 * edge_fade(t) * math.cos(
|
|
math.radians(8 * angle)
|
|
) * math.sin(math.radians(1080 * t))
|
|
if style == "organic_asymmetric":
|
|
return sculpted + 2.20 * edge_fade(t) * (
|
|
0.66 * math.cos(math.radians(angle - 35 + 115 * t))
|
|
+ 0.34 * math.cos(math.radians(3 * angle + 20 - 70 * t))
|
|
)
|
|
if style == "ribbed_petal":
|
|
return sculpted + 1.60 * (0.30 + 0.70 * t) * (
|
|
0.65 * math.cos(math.radians(14 * angle))
|
|
+ 0.35 * math.cos(math.radians(28 * angle))
|
|
)
|
|
if style == "pillow_facets":
|
|
return sculpted + 1.90 * edge_fade(t) * (1.0 - facet_local_u(angle, 9) ** 2)
|
|
if style == "dimpled_grid":
|
|
return sculpted - 1.15 * edge_fade(t) * dimple_bump(16 * angle) * dimple_bump(2160 * t)
|
|
if style == "spiral_flow":
|
|
return sculpted - 1.60 * edge_fade(t) * groove_profile(angle + 360 * 2.3 * t, 0.42)
|
|
raise ValueError(f"unsupported surface style: {style}")
|
|
|
|
|
|
def base_dimensions(args: argparse.Namespace) -> tuple[float, float, float]:
|
|
shrink_scale = 1.0 - args.shrink_percent / 100.0
|
|
top_r = args.target_inner_top_d / shrink_scale / 2.0 + args.slab_thickness
|
|
bottom_r = args.target_inner_outlet_d / shrink_scale / 2.0 + args.slab_thickness
|
|
height = args.target_inner_height / shrink_scale + args.slab_thickness * 0.7
|
|
return top_r, bottom_r, height
|
|
|
|
|
|
def base_radius(args: argparse.Namespace, t: float) -> float:
|
|
top_r, bottom_r, _ = base_dimensions(args)
|
|
return bottom_r + (top_r - bottom_r) * t ** args.profile_power
|
|
|
|
|
|
def release_scale_for(args: argparse.Namespace, style: str, rings: int = 110, segments: int = 240) -> float:
|
|
_, _, height = base_dimensions(args)
|
|
required_step = math.tan(math.radians(args.minimum_release_draft_angle)) * height / rings
|
|
limit = 1.0
|
|
for ring in range(rings):
|
|
t0 = ring / rings
|
|
t1 = (ring + 1) / rings
|
|
base_step = base_radius(args, t1) - base_radius(args, t0)
|
|
for segment in range(segments):
|
|
angle = 360.0 * segment / segments
|
|
relief_step = style_offset(style, t1, angle) - style_offset(style, t0, angle)
|
|
if relief_step < 0:
|
|
limit = min(limit, (base_step - required_step) / (-relief_step))
|
|
return max(0.0, min(1.0, limit))
|
|
|
|
|
|
def surface_radius(args: argparse.Namespace, style: str, scale: float, t: float, angle: float) -> float:
|
|
return base_radius(args, t) + scale * style_offset(style, t, angle)
|
|
|
|
|
|
def build_profile(
|
|
args: argparse.Namespace,
|
|
style: str,
|
|
scale: float,
|
|
angle: float,
|
|
steps: int = 320,
|
|
) -> list[tuple[float, float, float]]:
|
|
_, _, height = base_dimensions(args)
|
|
|
|
raw = [
|
|
(height * index / steps, surface_radius(args, style, scale, index / steps, angle))
|
|
for index in range(steps + 1)
|
|
]
|
|
|
|
profile: list[tuple[float, float, float]] = [(raw[0][0], raw[0][1], 0.0)]
|
|
distance = 0.0
|
|
for previous, current in zip(raw, raw[1:]):
|
|
distance += math.hypot(current[0] - previous[0], current[1] - previous[1])
|
|
profile.append((current[0], current[1], distance))
|
|
return profile
|
|
|
|
|
|
def polar_arc_length(
|
|
args: argparse.Namespace,
|
|
style: str,
|
|
scale: float,
|
|
t: float,
|
|
start_angle: float,
|
|
end_angle: float,
|
|
steps: int = 120,
|
|
) -> float:
|
|
points = []
|
|
for index in range(steps + 1):
|
|
angle = start_angle + (end_angle - start_angle) * index / steps
|
|
radius = surface_radius(args, style, scale, t, angle)
|
|
points.append((radius * math.cos(math.radians(angle)), radius * math.sin(math.radians(angle))))
|
|
return sum(math.hypot(b[0] - a[0], b[1] - a[1]) for a, b in zip(points, points[1:]))
|
|
|
|
|
|
def build_gore_patterns(
|
|
args: argparse.Namespace,
|
|
style: str,
|
|
scale: float,
|
|
steps: int = 180,
|
|
) -> list[list[tuple[float, float]]]:
|
|
patterns = []
|
|
sector_angle = 360.0 / args.gores
|
|
for gore_index in range(args.gores):
|
|
left_angle = gore_index * sector_angle
|
|
center_angle = left_angle + sector_angle / 2.0
|
|
right_angle = left_angle + sector_angle
|
|
meridian = build_profile(args, style, scale, center_angle, steps)
|
|
left = []
|
|
right = []
|
|
for index, (_, _, distance) in enumerate(meridian):
|
|
t = index / steps
|
|
left.append((-polar_arc_length(args, style, scale, t, left_angle, center_angle, 48), distance))
|
|
right.append((polar_arc_length(args, style, scale, t, center_angle, right_angle, 48), distance))
|
|
patterns.append(left + list(reversed(right)))
|
|
return patterns
|
|
|
|
|
|
def compute_dimensions(
|
|
args: argparse.Namespace,
|
|
style: str,
|
|
scale: float,
|
|
patterns: Sequence[Sequence[tuple[float, float]]],
|
|
) -> TemplateDimensions:
|
|
top_r, bottom_r, height = base_dimensions(args)
|
|
top_circumference = polar_arc_length(args, style, scale, 1.0, 0.0, 360.0, 720)
|
|
bottom_circumference = polar_arc_length(args, style, scale, 0.0, 0.0, 360.0, 720)
|
|
effective_top_r = top_circumference / (2.0 * math.pi)
|
|
effective_bottom_r = bottom_circumference / (2.0 * math.pi)
|
|
meridian_lengths = [
|
|
build_profile(args, style, scale, angle, 640)[-1][2]
|
|
for angle in range(0, 360, 15)
|
|
]
|
|
meridian = sum(meridian_lengths) / len(meridian_lengths)
|
|
|
|
outer = meridian * effective_top_r / (effective_top_r - effective_bottom_r)
|
|
inner = outer - meridian
|
|
angle = math.degrees(top_circumference / outer)
|
|
|
|
shrink_scale = 1.0 - args.shrink_percent / 100.0
|
|
support_green_span = args.support_finished_span / shrink_scale
|
|
envelope = support_green_span / (
|
|
math.sqrt(3.0) * (0.5 - args.support_corner_ratio)
|
|
+ 2.0 * args.support_corner_ratio
|
|
)
|
|
corner_r = envelope * args.support_corner_ratio
|
|
center_r = envelope / 2.0 - corner_r
|
|
support_min_span = 1.5 * center_r + 2.0 * corner_r
|
|
|
|
return TemplateDimensions(
|
|
model_version="2.0",
|
|
preset=args.preset,
|
|
surface_style=style,
|
|
release_scale=scale,
|
|
minimum_release_draft_angle_deg=args.minimum_release_draft_angle,
|
|
shrink_percent=args.shrink_percent,
|
|
slab_thickness_mm=args.slab_thickness,
|
|
master_top_radius_mm=top_r,
|
|
master_bottom_radius_mm=bottom_r,
|
|
master_height_mm=height,
|
|
average_meridian_length_mm=meridian,
|
|
single_piece_outer_radius_mm=outer,
|
|
single_piece_inner_radius_mm=inner,
|
|
single_piece_angle_deg=angle,
|
|
seam_allowance_mm=args.seam_allowance,
|
|
gore_count=args.gores,
|
|
gore_top_widths_mm=[max(x for x, _ in pattern) - min(x for x, _ in pattern) for pattern in patterns],
|
|
gore_bottom_widths_mm=[abs(pattern[0][0]) + abs(pattern[-1][0]) for pattern in patterns],
|
|
gore_heights_mm=[max(y for _, y in pattern) - min(y for _, y in pattern) for pattern in patterns],
|
|
support_max_span_mm=support_green_span,
|
|
support_min_span_mm=support_min_span,
|
|
support_hole_diameter_mm=args.support_finished_hole_d / shrink_scale,
|
|
)
|
|
|
|
|
|
def register_fonts() -> None:
|
|
regular = Path("/System/Library/Fonts/Supplemental/Arial.ttf")
|
|
bold = Path("/System/Library/Fonts/Supplemental/Arial Bold.ttf")
|
|
if regular.exists() and bold.exists():
|
|
pdfmetrics.registerFont(TTFont("TemplateSans", str(regular)))
|
|
pdfmetrics.registerFont(TTFont("TemplateSans-Bold", str(bold)))
|
|
else:
|
|
pdfmetrics.registerFont(TTFont("TemplateSans", "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"))
|
|
pdfmetrics.registerFont(TTFont("TemplateSans-Bold", "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"))
|
|
|
|
|
|
def pt(point_mm: tuple[float, float]) -> tuple[float, float]:
|
|
return point_mm[0] * mm, point_mm[1] * mm
|
|
|
|
|
|
def arc_points(radius: float, start_deg: float, end_deg: float, count: int = 180) -> list[tuple[float, float]]:
|
|
return [
|
|
(
|
|
radius * math.cos(math.radians(start_deg + (end_deg - start_deg) * index / count)),
|
|
radius * math.sin(math.radians(start_deg + (end_deg - start_deg) * index / count)),
|
|
)
|
|
for index in range(count + 1)
|
|
]
|
|
|
|
|
|
def draw_polyline(c: canvas.Canvas, points: Sequence[tuple[float, float]], close: bool = False) -> None:
|
|
path = c.beginPath()
|
|
path.moveTo(*pt(points[0]))
|
|
for point in points[1:]:
|
|
path.lineTo(*pt(point))
|
|
if close:
|
|
path.close()
|
|
c.drawPath(path, stroke=1, fill=0)
|
|
|
|
|
|
def draw_header(c: canvas.Canvas, title: str, subtitle: str, page: int) -> None:
|
|
c.setFillColor(BLACK)
|
|
c.setFont("TemplateSans-Bold", 15)
|
|
c.drawString(14 * mm, 283 * mm, title)
|
|
c.setFillColor(GRAY)
|
|
c.setFont("TemplateSans", 8.5)
|
|
c.drawString(14 * mm, 276 * mm, subtitle)
|
|
c.drawRightString(406 * mm, 283 * mm, f"A3, 100%, стр. {page}/3")
|
|
c.setStrokeColor(LIGHT_GRAY)
|
|
c.setLineWidth(0.35)
|
|
c.line(14 * mm, 271 * mm, 406 * mm, 271 * mm)
|
|
|
|
|
|
def draw_calibration(c: canvas.Canvas, x: float, y: float) -> None:
|
|
c.setStrokeColor(BLACK)
|
|
c.setFillColor(BLACK)
|
|
c.setLineWidth(0.6)
|
|
c.rect(x * mm, y * mm, 50 * mm, 50 * mm, stroke=1, fill=0)
|
|
c.setFont("TemplateSans", 7)
|
|
c.drawString(x * mm, (y - 4) * mm, "Контрольный квадрат 50 x 50 мм")
|
|
c.line(x * mm, (y - 9) * mm, (x + 100) * mm, (y - 9) * mm)
|
|
for mark in range(0, 101, 10):
|
|
height = 3 if mark % 50 else 5
|
|
c.line((x + mark) * mm, (y - 9) * mm, (x + mark) * mm, (y - 9 + height) * mm)
|
|
c.drawString((x + 102) * mm, (y - 10) * mm, "100 мм")
|
|
|
|
|
|
def draw_compact_calibration(c: canvas.Canvas, x: float, y: float) -> None:
|
|
c.setStrokeColor(BLACK)
|
|
c.setFillColor(BLACK)
|
|
c.setLineWidth(0.6)
|
|
c.rect(x * mm, y * mm, 50 * mm, 50 * mm, stroke=1, fill=0)
|
|
c.setFont("TemplateSans", 6.5)
|
|
c.drawCentredString((x + 25) * mm, (y - 4) * mm, "50 x 50 мм")
|
|
|
|
|
|
def label_for_preset(preset: str) -> str:
|
|
return preset.upper().replace("_", "-")
|
|
|
|
|
|
def draw_single_piece(c: canvas.Canvas, dims: TemplateDimensions) -> None:
|
|
label = label_for_preset(dims.preset)
|
|
draw_header(
|
|
c,
|
|
f"{label}: цельная заготовка стенки",
|
|
f"{dims.surface_style}; release scale {dims.release_scale:.3f}. Красная линия - припуск {dims.seam_allowance_mm:g} мм.",
|
|
1,
|
|
)
|
|
cx, cy = 210.0, 60.0
|
|
half = dims.single_piece_angle_deg / 2.0
|
|
start, end = 90.0 - half, 90.0 + half
|
|
outer = [(cx + x, cy + y) for x, y in arc_points(dims.single_piece_outer_radius_mm, start, end)]
|
|
inner = [(cx + x, cy + y) for x, y in arc_points(dims.single_piece_inner_radius_mm, end, start, 80)]
|
|
outline = outer + inner
|
|
|
|
c.setStrokeColor(BLACK)
|
|
c.setLineWidth(0.65)
|
|
draw_polyline(c, outline, close=True)
|
|
|
|
nominal_inner = inner[-1]
|
|
nominal_outer = outer[0]
|
|
c.setDash(3 * mm, 2 * mm)
|
|
c.setStrokeColor(GRAY)
|
|
draw_polyline(c, [nominal_inner, nominal_outer])
|
|
c.setDash()
|
|
|
|
angle = math.radians(start)
|
|
outward = (math.sin(angle), -math.cos(angle))
|
|
allowance_inner = (
|
|
nominal_inner[0] + dims.seam_allowance_mm * outward[0],
|
|
nominal_inner[1] + dims.seam_allowance_mm * outward[1],
|
|
)
|
|
allowance_outer = (
|
|
nominal_outer[0] + dims.seam_allowance_mm * outward[0],
|
|
nominal_outer[1] + dims.seam_allowance_mm * outward[1],
|
|
)
|
|
c.setStrokeColor(ACCENT)
|
|
c.setLineWidth(1.0)
|
|
draw_polyline(c, [allowance_inner, allowance_outer])
|
|
draw_polyline(c, [nominal_inner, allowance_inner])
|
|
draw_polyline(c, [nominal_outer, allowance_outer])
|
|
|
|
c.setFillColor(ACCENT)
|
|
c.setFont("TemplateSans-Bold", 8)
|
|
c.drawString(318 * mm, 70 * mm, f"ПРИПУСК {dims.seam_allowance_mm:g} ММ")
|
|
c.setFillColor(BLACK)
|
|
c.setFont("TemplateSans", 8)
|
|
c.drawString(128 * mm, 44 * mm, "Быстрый вариант: окончательная посадка формируется пластически в гипсе.")
|
|
c.drawString(128 * mm, 37 * mm, "Не растягивать верхнюю кромку; избыток распределять по высоте.")
|
|
c.drawString(128 * mm, 30 * mm, "Для минимальной деформации используйте 4 индивидуальных сектора.")
|
|
draw_calibration(c, 14.0, 15.0)
|
|
|
|
|
|
def draw_gore(c: canvas.Canvas, points: Sequence[tuple[float, float]], cx: float, cy: float, number: int) -> None:
|
|
translated = [(cx + x, cy + y) for x, y in points]
|
|
c.setStrokeColor(BLACK)
|
|
c.setLineWidth(0.55)
|
|
draw_polyline(c, translated, close=True)
|
|
c.setFillColor(GRAY)
|
|
c.setFont("TemplateSans-Bold", 7)
|
|
c.drawCentredString(cx * mm, (cy + 5) * mm, f"СЕКТОР {number}")
|
|
c.setDash(1.5 * mm, 1.5 * mm)
|
|
c.setStrokeColor(OCHRE)
|
|
c.line(cx * mm, (cy + 2) * mm, cx * mm, (cy + max(y for _, y in points) - 2) * mm)
|
|
c.setDash()
|
|
|
|
|
|
def draw_gores(
|
|
c: canvas.Canvas,
|
|
dims: TemplateDimensions,
|
|
patterns: Sequence[Sequence[tuple[float, float]]],
|
|
) -> None:
|
|
label = label_for_preset(dims.preset)
|
|
draw_header(
|
|
c,
|
|
f"{label}: 4-секторный раскрой стенки",
|
|
f"{dims.surface_style}: сектора различаются и пронумерованы по кругу. Соединять 1-2-3-4.",
|
|
2,
|
|
)
|
|
if max(dims.gore_heights_mm) > 129.0 or max(dims.gore_top_widths_mm) > 180.0:
|
|
raise ValueError(f"{dims.surface_style}: gore pattern does not fit verified A3 layout")
|
|
positions = [(108.0, 8.0), (312.0, 8.0), (108.0, 139.0), (312.0, 139.0)]
|
|
for index, (points, (cx, cy)) in enumerate(zip(patterns, positions), start=1):
|
|
draw_gore(c, points, cx, cy, index)
|
|
draw_compact_calibration(c, 185.0, 108.0)
|
|
c.setFillColor(GRAY)
|
|
c.setFont("TemplateSans", 7)
|
|
c.drawString(14 * mm, 272.5 * mm, "Охра - ось. Кромки срезать под 45 градусов, насечь, нанести шликер и соединить встык.")
|
|
|
|
|
|
def convex_hull(points: Iterable[tuple[float, float]]) -> list[tuple[float, float]]:
|
|
unique = sorted(set(points))
|
|
if len(unique) <= 1:
|
|
return unique
|
|
|
|
def cross(origin: tuple[float, float], a: tuple[float, float], b: tuple[float, float]) -> float:
|
|
return (a[0] - origin[0]) * (b[1] - origin[1]) - (a[1] - origin[1]) * (b[0] - origin[0])
|
|
|
|
lower: list[tuple[float, float]] = []
|
|
for point in unique:
|
|
while len(lower) >= 2 and cross(lower[-2], lower[-1], point) <= 0:
|
|
lower.pop()
|
|
lower.append(point)
|
|
upper: list[tuple[float, float]] = []
|
|
for point in reversed(unique):
|
|
while len(upper) >= 2 and cross(upper[-2], upper[-1], point) <= 0:
|
|
upper.pop()
|
|
upper.append(point)
|
|
return lower[:-1] + upper[:-1]
|
|
|
|
|
|
def support_outline(args: argparse.Namespace) -> list[tuple[float, float]]:
|
|
shrink_scale = 1.0 - args.shrink_percent / 100.0
|
|
green_span = args.support_finished_span / shrink_scale
|
|
envelope = green_span / (
|
|
math.sqrt(3.0) * (0.5 - args.support_corner_ratio)
|
|
+ 2.0 * args.support_corner_ratio
|
|
)
|
|
corner_r = envelope * args.support_corner_ratio
|
|
center_r = envelope / 2.0 - corner_r
|
|
samples: list[tuple[float, float]] = []
|
|
for center_angle in (90.0, 210.0, 330.0):
|
|
cx = center_r * math.cos(math.radians(center_angle))
|
|
cy = center_r * math.sin(math.radians(center_angle))
|
|
for index in range(180):
|
|
angle = 2.0 * math.pi * index / 180.0
|
|
samples.append((cx + corner_r * math.cos(angle), cy + corner_r * math.sin(angle)))
|
|
return convex_hull(samples)
|
|
|
|
|
|
def draw_support(c: canvas.Canvas, args: argparse.Namespace, dims: TemplateDimensions) -> None:
|
|
label = label_for_preset(dims.preset)
|
|
draw_header(
|
|
c,
|
|
f"{label}: опорная площадка из сырой глины",
|
|
f"Общая для {dims.surface_style}; увеличена на усадку {dims.shrink_percent:g}%.",
|
|
3,
|
|
)
|
|
cx, cy = 210.0, 145.0
|
|
outline = [(cx + x, cy + y) for x, y in support_outline(args)]
|
|
c.setStrokeColor(BLACK)
|
|
c.setLineWidth(0.75)
|
|
draw_polyline(c, outline, close=True)
|
|
c.circle(cx * mm, cy * mm, dims.support_hole_diameter_mm / 2.0 * mm, stroke=1, fill=0)
|
|
c.setDash(2 * mm, 2 * mm)
|
|
c.setStrokeColor(OCHRE)
|
|
c.line((cx - dims.support_max_span_mm / 2) * mm, cy * mm, (cx + dims.support_max_span_mm / 2) * mm, cy * mm)
|
|
c.setDash()
|
|
c.setFillColor(BLACK)
|
|
c.setFont("TemplateSans", 8)
|
|
c.drawString(128 * mm, 55 * mm, f"Габарит сырой детали: {dims.support_max_span_mm:.2f} x {dims.support_min_span_mm:.2f} мм")
|
|
c.drawString(128 * mm, 48 * mm, f"Отверстие: {dims.support_hole_diameter_mm:.2f} мм; толщина пласта по SCAD: 6 мм")
|
|
c.drawString(128 * mm, 41 * mm, "Закруглить кромки, подсушить до мягкой кожи и соединить со стенкой.")
|
|
draw_calibration(c, 14.0, 15.0)
|
|
|
|
|
|
def svg_path(points: Sequence[tuple[float, float]], close: bool = True) -> str:
|
|
commands = [f"M {points[0][0]:.4f} {points[0][1]:.4f}"]
|
|
commands.extend(f"L {x:.4f} {y:.4f}" for x, y in points[1:])
|
|
if close:
|
|
commands.append("Z")
|
|
return " ".join(commands)
|
|
|
|
|
|
def write_svg(
|
|
path: Path,
|
|
points: Sequence[tuple[float, float]],
|
|
width: float,
|
|
height: float,
|
|
circles: Sequence[tuple[float, float, float]] = (),
|
|
) -> None:
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
min_x = min(x for x, _ in points)
|
|
max_x = max(x for x, _ in points)
|
|
min_y = min(y for _, y in points)
|
|
max_y = max(y for _, y in points)
|
|
offset_x = (width - (max_x - min_x)) / 2.0 - min_x
|
|
offset_y = (height - (max_y - min_y)) / 2.0 + max_y
|
|
translated = [(x + offset_x, offset_y - y) for x, y in points]
|
|
circle_markup = "".join(
|
|
f' <circle cx="{cx + offset_x:.4f}" cy="{offset_y - cy:.4f}" r="{radius:.4f}" '
|
|
'fill="none" stroke="#1D252C" stroke-width="0.35"/>\n'
|
|
for cx, cy, radius in circles
|
|
)
|
|
content = (
|
|
'<?xml version="1.0" encoding="UTF-8"?>\n'
|
|
f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}mm" height="{height}mm" viewBox="0 0 {width} {height}">\n'
|
|
f' <path d="{svg_path(translated)}" fill="none" stroke="#1D252C" stroke-width="0.35"/>\n'
|
|
f'{circle_markup}'
|
|
'</svg>\n'
|
|
)
|
|
path.write_text(content, encoding="utf-8")
|
|
|
|
|
|
def write_svgs(
|
|
args: argparse.Namespace,
|
|
dims: TemplateDimensions,
|
|
patterns: Sequence[Sequence[tuple[float, float]]],
|
|
svg_dir: Path,
|
|
) -> None:
|
|
half = dims.single_piece_angle_deg / 2.0
|
|
single = arc_points(dims.single_piece_outer_radius_mm, 90.0 - half, 90.0 + half)
|
|
single += arc_points(dims.single_piece_inner_radius_mm, 90.0 + half, 90.0 - half, 80)
|
|
write_svg(
|
|
svg_dir / f"{args.preset}_{dims.surface_style}_cone_single_piece.svg",
|
|
single,
|
|
350.0,
|
|
190.0,
|
|
)
|
|
|
|
for index, gore in enumerate(patterns, start=1):
|
|
write_svg(
|
|
svg_dir / f"{args.preset}_{dims.surface_style}_cone_gore_{index}_of_{dims.gore_count}.svg",
|
|
gore,
|
|
180.0,
|
|
135.0,
|
|
)
|
|
|
|
support = support_outline(args)
|
|
hole_r = dims.support_hole_diameter_mm / 2.0
|
|
write_svg(
|
|
svg_dir / f"{args.preset}_{dims.surface_style}_support_plate.svg",
|
|
support,
|
|
180.0,
|
|
180.0,
|
|
circles=[(0.0, 0.0, hole_r)],
|
|
)
|
|
|
|
|
|
def generate_pdf(
|
|
args: argparse.Namespace,
|
|
dims: TemplateDimensions,
|
|
patterns: Sequence[Sequence[tuple[float, float]]],
|
|
pdf_path: Path,
|
|
) -> None:
|
|
pdf_path.parent.mkdir(parents=True, exist_ok=True)
|
|
c = canvas.Canvas(str(pdf_path), pagesize=landscape(A3), pageCompression=1)
|
|
c.setTitle(f"{args.preset} {args.surface_style} clay templates A3")
|
|
c.setAuthor("SOFT FACET V2 repository")
|
|
c.setSubject("Style-specific full-scale clay cutting templates")
|
|
draw_single_piece(c, dims)
|
|
c.showPage()
|
|
draw_gores(c, dims, patterns)
|
|
c.showPage()
|
|
draw_support(c, args, dims)
|
|
c.showPage()
|
|
c.save()
|
|
|
|
|
|
def output_paths(args: argparse.Namespace, style: str) -> tuple[Path, Path, Path]:
|
|
pdf = args.pdf or args.output_root / "pdf" / f"{args.preset}_{style}_clay_templates_a3.pdf"
|
|
data = args.data or args.output_root / "data" / f"{args.preset}_{style}_clay_templates.json"
|
|
svg_dir = args.svg_dir or args.output_root / "svg" / style
|
|
return pdf, data, svg_dir
|
|
|
|
|
|
def portable_path(path: Path) -> str:
|
|
try:
|
|
return str(path.relative_to(ROOT))
|
|
except ValueError:
|
|
return str(path)
|
|
|
|
|
|
def generate_style(args: argparse.Namespace, style: str) -> dict[str, object]:
|
|
style_args = copy.copy(args)
|
|
style_args.surface_style = style
|
|
scale = release_scale_for(style_args, style)
|
|
patterns = build_gore_patterns(style_args, style, scale)
|
|
dims = compute_dimensions(style_args, style, scale, patterns)
|
|
pdf_path, data_path, svg_dir = output_paths(style_args, style)
|
|
generate_pdf(style_args, dims, patterns, pdf_path)
|
|
write_svgs(style_args, dims, patterns, svg_dir)
|
|
data_path.parent.mkdir(parents=True, exist_ok=True)
|
|
data_path.write_text(json.dumps(asdict(dims), ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
|
|
print(f"{style}: {pdf_path}")
|
|
return {
|
|
"surface_style": style,
|
|
"pdf": portable_path(pdf_path),
|
|
"data": portable_path(data_path),
|
|
"svg_dir": portable_path(svg_dir),
|
|
"release_scale": scale,
|
|
}
|
|
|
|
|
|
def main() -> None:
|
|
args = parse_args()
|
|
validate(args)
|
|
register_fonts()
|
|
styles = SURFACE_STYLES if args.all_styles else (args.surface_style,)
|
|
entries = [generate_style(args, style) for style in styles]
|
|
if args.all_styles:
|
|
index_path = args.output_root / "data" / f"{args.preset}_all_styles_index.json"
|
|
index_path.write_text(json.dumps(entries, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
|
|
print(f"index: {index_path}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|