adebaumann
1740e0db02
Changed from top half (y0=92.8, y1=103.8) to bottom half (y0=103.8, y1=114.8). The label baseline sits at y≈101.5mm, so the lower half starts 2.3mm below it — clean visual separation without the unit appearing high up on the panel.
528 lines
18 KiB
Python
528 lines
18 KiB
Python
import base64
|
|
import math
|
|
import pathlib
|
|
from collections import namedtuple
|
|
from flask import Flask, render_template, request, Response
|
|
from html import escape
|
|
from fontTools.ttLib import TTFont
|
|
from fontTools.pens.svgPathPen import SVGPathPen
|
|
|
|
app = Flask(__name__)
|
|
|
|
VERSION = "0.87"
|
|
|
|
_LOGO_PATH = pathlib.Path(__file__).parent / 'static' / 'logo.png'
|
|
_LOGO_B64 = base64.b64encode(_LOGO_PATH.read_bytes()).decode()
|
|
|
|
_FontData = namedtuple('_FontData', ['key', 'label', 'b64', 'glyph_set', 'cmap', 'hmtx', 'upm', 'glyf'])
|
|
|
|
_FONT_LABELS = {
|
|
'GOST_2.30481_type_A': 'GOST Type A',
|
|
'GOST_2.30481_type_A_Bold': 'GOST Type A Bold',
|
|
'Gost2.30481TypeB': 'GOST Type B',
|
|
'ISOCPEUR': 'ISOCPEUR',
|
|
'SIEMENS_GOST_Type_A': 'Siemens GOST Type A',
|
|
'TGL_31034-1': 'TGL 31 034',
|
|
}
|
|
|
|
|
|
def _load_fonts():
|
|
font_dir = pathlib.Path(__file__).parent / 'fonts'
|
|
if not font_dir.exists():
|
|
font_dir = pathlib.Path(__file__).parent.parent / 'fonts'
|
|
fonts = {}
|
|
for path in sorted(font_dir.glob('*.ttf')):
|
|
key = path.stem
|
|
obj = TTFont(str(path))
|
|
fonts[key] = _FontData(
|
|
key=key,
|
|
label=_FONT_LABELS.get(key, key.replace('_', ' ')),
|
|
b64=base64.b64encode(path.read_bytes()).decode(),
|
|
glyph_set=obj.getGlyphSet(),
|
|
cmap=obj.getBestCmap(),
|
|
hmtx=obj['hmtx'].metrics,
|
|
upm=obj['head'].unitsPerEm,
|
|
glyf=obj['glyf'],
|
|
)
|
|
return fonts
|
|
|
|
|
|
_FONTS = _load_fonts()
|
|
_DEFAULT_FONT = 'GOST_2.30481_type_A'
|
|
|
|
# SVG absolute coordinate constants (1 user unit = 1 mm)
|
|
ZERO_X = 60.844130
|
|
MAX_X = 180.251230
|
|
BAR_Y = 107.54670
|
|
SCALE_LEN = MAX_X - ZERO_X # 119.4071 mm
|
|
|
|
BIG_H = 5.0895
|
|
SMALL_H = 2.6683
|
|
|
|
_UNIT_AREA_WIDTH = 18.445
|
|
_UNIT_SCALE_X = 0.96486402
|
|
_UNIT_MAX_FS = 18.7981
|
|
|
|
# --- Inline markup for the unit label -------------------------------------
|
|
_SUP_SCALE = 0.62
|
|
_SUP_RISE = 0.36
|
|
_SUB_DROP = 0.14
|
|
_FRAC_SCALE = 0.62
|
|
_FRAC_AXIS = 0.32
|
|
_FRAC_GAP = 0.14
|
|
_FRAC_SIDE = 0.12
|
|
|
|
_UNIT_BOX_X0, _UNIT_BOX_X1 = 39.6, 57.4
|
|
_UNIT_BOX_Y0, _UNIT_BOX_Y1 = 92.8, 114.8
|
|
_UNIT_BOX_HALF_Y0 = (_UNIT_BOX_Y0 + _UNIT_BOX_Y1) / 2 # 103.8 — bottom half starts here
|
|
|
|
|
|
def _glyph_svg(ch: str, x: float, y: float, fs: float, fill: str, fd: _FontData):
|
|
gn = fd.cmap.get(ord(ch))
|
|
if gn is None:
|
|
return None, 0.0
|
|
s = fs / fd.upm
|
|
adv = fd.hmtx.get(gn, (0, 0))[0] * s
|
|
pen = SVGPathPen(fd.glyph_set)
|
|
fd.glyph_set[gn].draw(pen)
|
|
d = pen.getCommands()
|
|
if not d:
|
|
return None, adv
|
|
t = f'translate({x:.5f},{y:.5f}) scale({s:.8f},{-s:.8f})'
|
|
return f'<path style="fill:{fill}" transform="{t}" d="{d}"/>', adv
|
|
|
|
|
|
def _glyph_ybounds(ch: str, fd: _FontData):
|
|
gn = fd.cmap.get(ord(ch))
|
|
if gn is None:
|
|
return 0.0, 0.0
|
|
g = fd.glyf[gn]
|
|
if g.numberOfContours == 0:
|
|
return 0.0, 0.0
|
|
g.recalcBounds(fd.glyf)
|
|
return g.yMin / fd.upm, g.yMax / fd.upm
|
|
|
|
|
|
def _extract_braced(s: str, i: int):
|
|
depth, j = 1, i + 1
|
|
while j < len(s) and depth:
|
|
if s[j] == '{':
|
|
depth += 1
|
|
elif s[j] == '}':
|
|
depth -= 1
|
|
if depth == 0:
|
|
break
|
|
j += 1
|
|
return s[i + 1:j], j + 1
|
|
|
|
|
|
def _parse_braced(inner: str):
|
|
depth = 0
|
|
for k, ch in enumerate(inner):
|
|
if ch == '{':
|
|
depth += 1
|
|
elif ch == '}':
|
|
depth -= 1
|
|
elif ch == '/' and depth == 0:
|
|
return ('frac', _parse_markup(inner[:k]), _parse_markup(inner[k + 1:]))
|
|
return ('group', _parse_markup(inner))
|
|
|
|
|
|
def _parse_atom(s: str, i: int):
|
|
if i >= len(s):
|
|
return [], i
|
|
if s[i] == '{':
|
|
inner, j = _extract_braced(s, i)
|
|
return [_parse_braced(inner)], j
|
|
return [('lit', s[i])], i + 1
|
|
|
|
|
|
def _parse_markup(s: str):
|
|
nodes, i = [], 0
|
|
while i < len(s):
|
|
c = s[i]
|
|
if c in '^_':
|
|
atom, i = _parse_atom(s, i + 1)
|
|
nodes.append(('sup' if c == '^' else 'sub', atom))
|
|
elif c == '{':
|
|
inner, j = _extract_braced(s, i)
|
|
nodes.append(_parse_braced(inner))
|
|
i = j
|
|
else:
|
|
nodes.append(('lit', c))
|
|
i += 1
|
|
return nodes
|
|
|
|
|
|
def _measure(nodes, fs: float, fd: _FontData) -> float:
|
|
w = 0.0
|
|
for n in nodes:
|
|
if n[0] == 'lit':
|
|
gn = fd.cmap.get(ord(n[1]))
|
|
if gn:
|
|
w += fd.hmtx.get(gn, (0, 0))[0] / fd.upm * fs
|
|
elif n[0] == 'group':
|
|
w += _measure(n[1], fs, fd)
|
|
elif n[0] in ('sup', 'sub'):
|
|
w += _measure(n[1], fs * _SUP_SCALE, fd)
|
|
elif n[0] == 'frac':
|
|
fs2 = fs * _FRAC_SCALE
|
|
w += max(_measure(n[1], fs2, fd), _measure(n[2], fs2, fd)) + 2 * _FRAC_SIDE * fs2
|
|
return w
|
|
|
|
|
|
def _frac_layout(n, fs: float, fd: _FontData):
|
|
fs2 = fs * _FRAC_SCALE
|
|
axis = -_FRAC_AXIS * fs
|
|
_, num_bot = _vbounds(n[1], fs2, fd)
|
|
num_base = axis - _FRAC_GAP * fs2 - num_bot
|
|
den_top, _ = _vbounds(n[2], fs2, fd)
|
|
den_base = axis + _FRAC_GAP * fs2 - den_top
|
|
return fs2, axis, num_base, den_base
|
|
|
|
|
|
def _vbounds(nodes, fs: float, fd: _FontData):
|
|
lo, hi = math.inf, -math.inf
|
|
for n in nodes:
|
|
if n[0] == 'lit':
|
|
ymin, ymax = _glyph_ybounds(n[1], fd)
|
|
a, b = -ymax * fs, -ymin * fs
|
|
elif n[0] == 'group':
|
|
a, b = _vbounds(n[1], fs, fd)
|
|
elif n[0] == 'sup':
|
|
a, b = _vbounds(n[1], fs * _SUP_SCALE, fd)
|
|
a, b = a - _SUP_RISE * fs, b - _SUP_RISE * fs
|
|
elif n[0] == 'sub':
|
|
a, b = _vbounds(n[1], fs * _SUP_SCALE, fd)
|
|
a, b = a + _SUB_DROP * fs, b + _SUB_DROP * fs
|
|
elif n[0] == 'frac':
|
|
fs2, axis, num_base, den_base = _frac_layout(n, fs, fd)
|
|
nt, nb = _vbounds(n[1], fs2, fd)
|
|
dt, db = _vbounds(n[2], fs2, fd)
|
|
a = min(nt + num_base, axis)
|
|
b = max(db + den_base, axis)
|
|
else:
|
|
continue
|
|
lo, hi = min(lo, a), max(hi, b)
|
|
return (0.0, 0.0) if lo > hi else (lo, hi)
|
|
|
|
|
|
def _draw_nodes(nodes, x: float, y: float, fs: float, fill: str, fd: _FontData):
|
|
parts, cx = [], x
|
|
for n in nodes:
|
|
if n[0] == 'lit':
|
|
p, adv = _glyph_svg(n[1], cx, y, fs, fill, fd)
|
|
if p:
|
|
parts.append(p)
|
|
cx += adv
|
|
elif n[0] == 'group':
|
|
p, adv = _draw_nodes(n[1], cx, y, fs, fill, fd)
|
|
parts += p
|
|
cx += adv
|
|
elif n[0] in ('sup', 'sub'):
|
|
fs2 = fs * _SUP_SCALE
|
|
y2 = y - _SUP_RISE * fs if n[0] == 'sup' else y + _SUB_DROP * fs
|
|
p, adv = _draw_nodes(n[1], cx, y2, fs2, fill, fd)
|
|
parts += p
|
|
cx += adv
|
|
elif n[0] == 'frac':
|
|
fs2, axis, num_base, den_base = _frac_layout(n, fs, fd)
|
|
wn, wd = _measure(n[1], fs2, fd), _measure(n[2], fs2, fd)
|
|
bar_w = max(wn, wd) + 2 * _FRAC_SIDE * fs2
|
|
pn, _ = _draw_nodes(n[1], cx + (bar_w - wn) / 2, y + num_base, fs2, fill, fd)
|
|
pd, _ = _draw_nodes(n[2], cx + (bar_w - wd) / 2, y + den_base, fs2, fill, fd)
|
|
parts += pn + pd
|
|
ay = y + axis
|
|
parts.append(
|
|
f'<line x1="{cx:.5f}" y1="{ay:.5f}" x2="{cx + bar_w:.5f}" y2="{ay:.5f}"'
|
|
f' style="stroke:{fill};stroke-width:{fs * 0.055:.5f};stroke-linecap:butt" />'
|
|
)
|
|
cx += bar_w
|
|
return parts, cx - x
|
|
|
|
|
|
def _has_markup(s: str) -> bool:
|
|
return any(c in s for c in '^_') or ('{' in s and '}' in s)
|
|
|
|
|
|
def _markup_unit_svg(unit: str, fd: _FontData, fill='#1a1a1a', box_y0=None, box_y1=None) -> str:
|
|
nodes = _parse_markup(unit)
|
|
x0, x1 = _UNIT_BOX_X0, _UNIT_BOX_X1
|
|
y0 = box_y0 if box_y0 is not None else _UNIT_BOX_Y0
|
|
y1 = box_y1 if box_y1 is not None else _UNIT_BOX_Y1
|
|
xc, yc = (x0 + x1) / 2, (y0 + y1) / 2
|
|
|
|
w1 = _measure(nodes, 1.0, fd)
|
|
top1, bot1 = _vbounds(nodes, 1.0, fd)
|
|
fs = _UNIT_MAX_FS
|
|
if w1 > 0:
|
|
fs = min(fs, (x1 - x0) / (w1 * _UNIT_SCALE_X))
|
|
if bot1 - top1 > 0:
|
|
fs = min(fs, (y1 - y0) / (bot1 - top1))
|
|
|
|
w = _measure(nodes, fs, fd)
|
|
top, bot = _vbounds(nodes, fs, fd)
|
|
y_base = yc - (top + bot) / 2
|
|
parts, _ = _draw_nodes(nodes, xc - w / 2, y_base, fs, fill, fd)
|
|
cond = f'translate({xc:.5f},0) scale({_UNIT_SCALE_X},1) translate({-xc:.5f},0)'
|
|
return f'<g transform="{cond}">\n{chr(10).join(parts)}\n</g>'
|
|
|
|
|
|
def _unit_font_size(unit: str, fd: _FontData) -> float:
|
|
em_w = _measure(_parse_markup(unit), 1.0, fd)
|
|
if em_w <= 0:
|
|
return _UNIT_MAX_FS
|
|
return min(_UNIT_MAX_FS, _UNIT_AREA_WIDTH / (em_w * _UNIT_SCALE_X))
|
|
|
|
|
|
def _text_to_paths(text, x, y, font_size, fd: _FontData, anchor='start', fill='#1a1a1a', wrap_transform=None):
|
|
s = font_size / fd.upm
|
|
|
|
if anchor == 'middle':
|
|
total_w = sum(
|
|
fd.hmtx.get(fd.cmap.get(ord(ch)), (0, 0))[0] * s
|
|
for ch in text if fd.cmap.get(ord(ch))
|
|
)
|
|
x -= total_w / 2
|
|
|
|
parts = []
|
|
cx = x
|
|
for ch in text:
|
|
gn = fd.cmap.get(ord(ch))
|
|
if gn is None:
|
|
continue
|
|
pen = SVGPathPen(fd.glyph_set)
|
|
fd.glyph_set[gn].draw(pen)
|
|
d = pen.getCommands()
|
|
if d:
|
|
t = f'translate({cx:.5f},{y:.5f}) scale({s:.8f},{-s:.8f})'
|
|
parts.append(f'<path style="fill:{fill}" transform="{t}" d="{d}"/>')
|
|
cx += fd.hmtx.get(gn, (0, 0))[0] * s
|
|
|
|
inner = '\n'.join(parts)
|
|
if wrap_transform:
|
|
return f'<g transform="{wrap_transform}">{inner}</g>'
|
|
return inner
|
|
|
|
|
|
def _fmt(v: float) -> str:
|
|
if math.isinf(v):
|
|
return '∞'
|
|
r = round(v)
|
|
if abs(v - r) < 1e-9 * max(1.0, abs(v)):
|
|
return str(int(r))
|
|
exp = math.floor(math.log10(abs(v)))
|
|
decimals = max(0, 4 - 1 - exp)
|
|
s = f"{v:.{decimals}f}"
|
|
return s.rstrip('0').rstrip('.') if '.' in s else s
|
|
|
|
|
|
def generate_svg(unit, min_val, max_val, range_label, big_ticks, small_ticks, label_count,
|
|
use_paths=True, scale_type='linear', custom_labels=None, label_size=9,
|
|
font_key=None, half_height_unit=False):
|
|
fd = _FONTS.get(font_key) or _FONTS.get(_DEFAULT_FONT) or next(iter(_FONTS.values()))
|
|
unit_box_y0 = _UNIT_BOX_HALF_Y0 if half_height_unit else None
|
|
|
|
if scale_type == 'log':
|
|
if min_val <= 0 or max_val <= 0:
|
|
raise ValueError("Logarithmic scale requires min and max values greater than 0.")
|
|
lmin, lmax = math.log(min_val), math.log(max_val)
|
|
lspan = lmax - lmin
|
|
if lspan == 0:
|
|
raise ValueError("Logarithmic scale requires min and max values to differ.")
|
|
|
|
def value_to_x(v):
|
|
return ZERO_X + SCALE_LEN * (math.log(v) - lmin) / lspan
|
|
|
|
def major_value(i):
|
|
return min_val * (max_val / min_val) ** (i / big_ticks)
|
|
|
|
elif scale_type == 'sqrt':
|
|
if min_val < 0:
|
|
raise ValueError("Square-root scale requires min value ≥ 0.")
|
|
span = max_val - min_val
|
|
if span <= 0:
|
|
raise ValueError("Square-root scale requires max value greater than min.")
|
|
|
|
def value_to_x(v):
|
|
return ZERO_X + SCALE_LEN * math.sqrt((v - min_val) / span)
|
|
|
|
def major_value(i):
|
|
return min_val + span * (i / big_ticks) ** 2
|
|
|
|
elif scale_type == 'reciprocal':
|
|
if min_val <= 0:
|
|
raise ValueError("Reciprocal scale requires min and max values greater than 0.")
|
|
if not math.isinf(max_val) and max_val <= min_val:
|
|
raise ValueError("Reciprocal scale requires max value greater than min.")
|
|
if math.isinf(max_val):
|
|
def value_to_x(v):
|
|
if math.isinf(v):
|
|
return ZERO_X
|
|
return ZERO_X + SCALE_LEN * min_val / v
|
|
|
|
def major_value(i):
|
|
if i == 0:
|
|
return math.inf
|
|
return min_val * big_ticks / i
|
|
else:
|
|
if max_val <= 0:
|
|
raise ValueError("Reciprocal scale requires min and max values greater than 0.")
|
|
k = 1.0 / min_val - 1.0 / max_val
|
|
|
|
def value_to_x(v):
|
|
return ZERO_X + SCALE_LEN * (1.0 / v - 1.0 / max_val) / k
|
|
|
|
def major_value(i):
|
|
return 1.0 / (1.0 / max_val + i / big_ticks * k)
|
|
|
|
else:
|
|
span = max_val - min_val
|
|
|
|
def value_to_x(v):
|
|
if span == 0:
|
|
return ZERO_X
|
|
return ZERO_X + SCALE_LEN * (v - min_val) / span
|
|
|
|
def major_value(i):
|
|
return min_val + span * i / big_ticks
|
|
|
|
big_interval = SCALE_LEN / big_ticks
|
|
big_xs = [ZERO_X + i * big_interval for i in range(big_ticks + 1)]
|
|
big_vals = [major_value(i) for i in range(big_ticks + 1)]
|
|
|
|
if custom_labels:
|
|
label_count = max(1, min(len(custom_labels), big_ticks + 1))
|
|
custom_labels = custom_labels[:label_count]
|
|
else:
|
|
label_count = max(2, min(label_count, big_ticks + 1))
|
|
|
|
if label_count == 1:
|
|
label_indices = [0]
|
|
else:
|
|
label_indices = [round(k * big_ticks / (label_count - 1)) for k in range(label_count)]
|
|
|
|
font_face = (
|
|
'<defs><style>'
|
|
f'@font-face {{font-family:"{fd.label}";'
|
|
f'src:url("data:font/truetype;base64,{fd.b64}") format("truetype");}}'
|
|
'</style></defs>'
|
|
)
|
|
|
|
parts = [
|
|
'<?xml version="1.0" encoding="UTF-8" standalone="no"?>',
|
|
'<svg width="157.18373mm" height="26.683672mm"'
|
|
' viewBox="0 0 157.18373 26.683672" version="1.1"'
|
|
' xmlns="http://www.w3.org/2000/svg">',
|
|
]
|
|
|
|
if use_paths:
|
|
parts.append(' <g transform="translate(-37.352226,-90.454928)">')
|
|
else:
|
|
parts += [font_face, ' <g transform="translate(-37.352226,-90.454928)">']
|
|
|
|
parts.append(
|
|
' <path style="fill:#ffffff;stroke:#1a1a1a;stroke-width:0.184;'
|
|
'stroke-linecap:round;stroke-miterlimit:10"'
|
|
' d="M 37.444226,90.546928 V 117.0466 H 194.44395 V 90.546928 Z'
|
|
' M 58.443978,107.54692 H 183.64409 v 6.19963 H 58.443978 Z" />'
|
|
)
|
|
|
|
# Paths mode and any unit needing special handling (markup, half-height):
|
|
# use _markup_unit_svg which fits actual ink bounds to the box, giving
|
|
# correct sizing for all fonts. Text mode for plain normal-height units
|
|
# keeps live <text> nodes; half-height always uses paths for correct centering.
|
|
if use_paths or _has_markup(unit) or half_height_unit:
|
|
unit_svg = ' ' + _markup_unit_svg(unit, fd, box_y0=unit_box_y0)
|
|
else:
|
|
fs = _unit_font_size(unit, fd)
|
|
unit_svg = (
|
|
f' <text style="font-size:{fs:.4f}px;font-family:\'{fd.label}\',monospace;fill:#1a1a1a"'
|
|
f' x="41.455711" y="109.03796"'
|
|
f' transform="scale({_UNIT_SCALE_X},1.0364155)">{escape(unit)}</text>'
|
|
)
|
|
|
|
if use_paths:
|
|
parts += [unit_svg, ' ' + _text_to_paths(range_label, 184.79707, 113.6755, 3.60539, fd)]
|
|
else:
|
|
parts += [
|
|
unit_svg,
|
|
f' <text style="font-size:3.60539px;font-family:\'{fd.label}\',monospace;fill:#1a1a1a"'
|
|
f' x="184.79707" y="113.6755">{escape(range_label)}</text>',
|
|
]
|
|
|
|
for x in big_xs:
|
|
parts.append(
|
|
f' <line x1="{x:.5f}" y1="{BAR_Y}" x2="{x:.5f}" y2="{BAR_Y - BIG_H:.5f}"'
|
|
f' style="stroke:#1a1a1a;stroke-width:0.555;stroke-linecap:butt" />'
|
|
)
|
|
|
|
if small_ticks > 0:
|
|
sub = small_ticks + 1
|
|
for i in range(big_ticks):
|
|
for j in range(1, small_ticks + 1):
|
|
if scale_type == 'sqrt':
|
|
x = big_xs[i] + (j / sub) ** 2 * (big_xs[i + 1] - big_xs[i])
|
|
elif scale_type == 'reciprocal' or math.isinf(big_vals[i]):
|
|
x = big_xs[i] + (j / sub) * (big_xs[i + 1] - big_xs[i])
|
|
else:
|
|
v = big_vals[i] + j * (big_vals[i + 1] - big_vals[i]) / sub
|
|
x = value_to_x(v)
|
|
parts.append(
|
|
f' <line x1="{x:.5f}" y1="{BAR_Y}" x2="{x:.5f}" y2="{BAR_Y - SMALL_H:.5f}"'
|
|
f' style="stroke:#1a1a1a;stroke-width:0.302;stroke-linecap:butt" />'
|
|
)
|
|
|
|
for k, idx in enumerate(label_indices):
|
|
x = big_xs[idx]
|
|
label = custom_labels[k] if custom_labels else _fmt(big_vals[idx])
|
|
if use_paths:
|
|
parts.append(' ' + _text_to_paths(label, x, 101.49598, label_size, fd, anchor='middle'))
|
|
else:
|
|
parts.append(
|
|
f' <text style="font-size:{label_size:.5f}px;font-family:\'{fd.label}\',monospace;fill:#1a1a1a"'
|
|
f' text-anchor="middle" x="{x:.5f}" y="101.49598">{escape(label)}</text>'
|
|
)
|
|
|
|
parts += [' </g>', '</svg>']
|
|
return '\n'.join(parts)
|
|
|
|
|
|
@app.route('/')
|
|
def index():
|
|
fonts = list(_FONTS.values())
|
|
return render_template('index.html', logo_b64=_LOGO_B64, version=VERSION,
|
|
fonts=fonts, default_font=_DEFAULT_FONT)
|
|
|
|
|
|
@app.route('/generate', methods=['POST'])
|
|
def generate():
|
|
unit = request.form.get('unit', '%')
|
|
min_val = float(request.form.get('min', 0))
|
|
max_val = float(request.form.get('max', 100))
|
|
range_label = request.form.get('range_label', '5mA')
|
|
big_ticks = max(1, min(50, int(request.form.get('big_ticks', 10))))
|
|
small_ticks = max(0, min(20, int(request.form.get('small_ticks', 4))))
|
|
label_count = max(2, int(request.form.get('label_count', 6)))
|
|
use_paths = request.form.get('output_mode', 'paths') == 'paths'
|
|
scale_type = request.form.get('scale_type', 'linear')
|
|
font_key = request.form.get('font', _DEFAULT_FONT)
|
|
half_height_unit = request.form.get('half_height_unit') == '1'
|
|
if request.form.get('max_is_inf') == '1':
|
|
max_val = math.inf
|
|
|
|
custom_labels = [s.strip() for s in request.form.get('labels', '').split(',') if s.strip()] or None
|
|
label_size = max(0.5, min(25.0, float(request.form.get('label_size', 9))))
|
|
|
|
try:
|
|
svg = generate_svg(unit, min_val, max_val, range_label, big_ticks, small_ticks,
|
|
label_count, use_paths, scale_type, custom_labels, label_size,
|
|
font_key, half_height_unit)
|
|
except ValueError as err:
|
|
return Response(str(err), status=400, mimetype='text/plain')
|
|
return Response(svg, mimetype='image/svg+xml')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
app.run(debug=True)
|