#!/usr/bin/env python3 """Grades the tracks of any scenery for the uneven attribute, from what the scenery shows: textures, grass on the track, curves, speed and road crossings. The originals stay as they are, graded copies of the files with tracks go to --out. python track_uneven_grade.py scenery/td.scn python track_uneven_grade.py scenery/baltyk_skm1.scn --out graded python track_uneven_grade.py scenery/baltyk_skm1.scn --out graded --route -107,2300 -4120,2491 --straight tor0290,tor0906 python track_uneven_grade.py scenery/mytracks.scm --root scenery --out graded --gain 1.2 With no --out it only reports. See track_uneven_doc.md for the attribute. Python 3.8 or later, no other packages. """ import argparse import collections import heapq import math import pathlib import re import sys import zlib # PLK Id-14 appendix 1, class C: vertical limit in mm by speed in km/h LIMITS = [(20, 50), (30, 40), (40, 35), (50, 30), (60, 25), (70, 21), (80, 18), (90, 16), (100, 14), (110, 12), (120, 10), (130, 9), (140, 8), (150, 7), (160, 6)] # how worn a texture looks, 0-1: the first pattern found in its name counts, anything else is 0.5 BALLAST_WEAR = [("grass|traw", 0.95), ("old|star", 0.9), ("oil|smar", 0.6), ("new|nowa", 0.0), ("bps|beton|conc|tpb", 0.2), ("drew|wood|tpd", 0.45)] RAIL_WEAR = [("unused2", 1.0), ("unused", 0.85), ("rused2", 0.8), ("rused", 0.65), ("used2", 0.45), ("used", 0.2), ("new", 0.0), ("old|rust", 0.8)] WOOD = re.compile("drew|wood|tpd") GRASS = re.compile("grass|traw|chwast|weed") NO_SPEED = 40.0 # km/h, a stretch with no velocity anywhere: station and side tracks SWITCH_MOST = 35.0 # the limit of 40 km/h DIVERGING = 40.0 # km/h through the diverging path MOST, MOST_UP = 50.0, 60.0 # of uneven and of its vertical part REACH = 0.3 # how near the ends of tracks count as joined, m SHORT = 2.0 # the pieces inside a slip don't tell the quality of the line PIECE = 100.0 # a track without a speed shorter than this can take it through a switch, m GRASS_NEAR, GRASS_FULL = 2.5, 14.0 # grass this near the middle grows on the track; plants per 100 m of an overgrown one NEAR_LEAST, NEAR_MOST = 0.5, 0.95 # how far a chosen track goes towards the limit CURVE_STEP = 1.0 / 2500.0 # a difference of curvature that counts as a change, 1/m RISE = 0.0273 * 4.5 # how fast pressure lifts a pantograph, m/s, by TDynamicObject::Update GAP_MOST = 0.006 # the gap to the wire allowed; at 0.01 m the voltage goes and the main breaker trips OVERSPEED = 1.1 # a driver can go this much over the speed of the track # as up_waves and the dip of the joints in world/TrackUneven.h STRAY_PER_MM, DIP_SHARE, DIP_REACH = 0.00145, 0.4, 3.0 GOLDEN = math.pi * (3.0 - math.sqrt(5.0)) UP_WAVES = [(2 * math.pi / length * math.cos(GOLDEN * i), 2 * math.pi / length * math.sin(GOLDEN * i), GOLDEN * (i + 1), share) for i, (length, share) in enumerate(zip((8.3, 11.9, 16.7, 23.9, 37.1, 47.3, 61.9, 83.3), (.14, .19, .22, .22, .23, .23, .23, .23)))] TOKEN = re.compile(r"//[^\n]*|\S+") NUMBER = re.compile(r"^[-+]?\d*\.?\d+([eE][-+]?\d+)?$") def limit(speed): if speed <= LIMITS[0][0]: return float(LIMITS[0][1]) for (v0, n0), (v1, n1) in zip(LIMITS, LIMITS[1:]): if speed <= v1: return n0 + (n1 - n0) * (speed - v0) / (v1 - v0) return float(LIMITS[-1][1]) def wear(name, table): name = (name or "").lower() for pattern, value in table: if re.search(pattern, name): return value return 0.5 def hashed(salt, name): return zlib.crc32(salt + name.encode("latin-1", "replace")) / 0xffffffff class Scenery: """All that's found by following the includes from the given files.""" def __init__(self, root): self.root = root self.tracks, self.roads, self.plants = [], [], collections.defaultdict(list) self.seen = set() self.notes = collections.Counter() self.texts = {} def read(self, path, offset=(0.0, 0.0, 0.0)): path = path.resolve() if path in self.seen: return self.seen.add(path) text = path.read_bytes().decode("latin-1") self.texts[path] = text matches = [m for m in TOKEN.finditer(text) if not m.group(0).startswith("//")] words = [m.group(0) for m in matches] lower = [w.lower() for w in words] origins = [offset] i = 0 while i < len(words): word = lower[i] if word == "include" and i + 1 < len(words): end = i + 1 while end < len(words) and lower[end] != "end": end += 1 self.include(words[i + 1], words[i + 2:end], origins[-1]) i = end elif word == "origin" and i + 3 < len(words) and all(NUMBER.match(w) for w in words[i + 1:i + 4]): origins.append(tuple(o + float(w) for o, w in zip(origins[-1], words[i + 1:i + 4]))) i += 3 elif word == "endorigin" and len(origins) > 1: origins.pop() elif word == "rotate" and i + 3 < len(words) and any(w.strip("0.-") for w in words[i + 1:i + 4]): self.notes["rotate"] += 1 elif word == "node" and i + 4 < len(words): kind = lower[i + 4] if kind == "track": i = self.track(path, matches, words, lower, i, origins[-1]) elif kind == "model" and i + 9 < len(words) and GRASS.search(lower[i + 9]) and all(NUMBER.match(w) for w in words[i + 5:i + 8]): self.plant(float(words[i + 5]) + origins[-1][0], float(words[i + 7]) + origins[-1][2]) i += 1 def include(self, name, params, origin): path = self.root / name.replace("\\", "/") # a plant takes its place in the parameters; a file with grass in its name and none of them just lists plants numbers = [float(w) for w in params if NUMBER.match(w)] if GRASS.search(name.lower()) and len(numbers) >= 3: self.plant(numbers[0] + origin[0], numbers[2] + origin[2]) return if not path.is_file(): self.notes["brak pliku " + name] += 1 return if params: # the same file can come many times with other parameters: its tracks can't be told apart in one copy if path.stat().st_size < 4000000 and re.search(rb"\btrack\s+(normal|switch)\b", path.read_bytes(), re.I): self.notes["pliki z parametrami, tory pominiete"] += 1 return self.read(path, origin) def plant(self, x, z): self.plants[(round(x / 10), round(z / 10))].append((x, z)) def track(self, path, matches, words, lower, i, origin): at = i + 4 end = at while end < len(words) and lower[end] != "endtrack": end += 1 if end >= len(words) or at + 10 >= end: return i kind = lower[at + 1] if kind not in ("normal", "switch", "road"): return end cursor = at + 10 rail = ballast = None if lower[at + 9] == "vis": rail, ballast = lower[cursor], lower[cursor + 2] cursor += 6 paths = [] for _ in range(2 if kind == "switch" else 1): values = words[cursor:cursor + 15] if len(values) < 15 or not all(NUMBER.match(v) for v in values): self.notes["tory z parametrami, pominiete"] += 1 return end n = [float(v) for v in values] part = dict(p1=[n[j] + origin[j] for j in range(3)], c1=n[4:7], c2=n[7:10], p2=[n[10 + j] + origin[j] for j in range(3)], radius=abs(n[14])) part["line"] = line_of(part) part["length"] = sum(math.dist(a, b) for a, b in zip(part["line"], part["line"][1:])) paths.append(part) cursor += 15 if kind == "road": self.roads.append(paths[0]) return end block = lower[at:end] taken = any(w in block for w in ("uneven", "unevenup", "unevenside", "unevencross", "jointdip")) velocity = float(words[at + block.index("velocity") + 1]) if "velocity" in block and NUMBER.match(words[at + block.index("velocity") + 1]) else 0.0 sound = float(words[at + 5]) if NUMBER.match(words[at + 5]) else -1.0 self.tracks.append(dict(name=words[i + 3], kind=kind, rail=rail, ballast=ballast, sound=sound, paths=paths, speed=velocity if velocity > 0 else None, source="wpis" if velocity > 0 else None, file=path, offset=matches[end].start(), taken=taken)) return end def bezier(part, t): a = [part["p1"][i] + part["c1"][i] for i in range(3)] b = [part["p2"][i] + part["c2"][i] for i in range(3)] u = 1 - t return [u * u * u * part["p1"][i] + 3 * u * u * t * a[i] + 3 * u * t * t * b[i] + t * t * t * part["p2"][i] for i in range(3)] def line_of(part, step=5.0): if not any(part["c1"]) and not any(part["c2"]): return [list(part["p1"]), list(part["p2"])] count = max(4, int(math.dist(part["p1"], part["p2"]) / step)) return [bezier(part, i / count) for i in range(count + 1)] def plan_radius(line): least = math.inf for a, b, c in zip(line, line[1:], line[2:]): area = abs((b[0] - a[0]) * (c[2] - a[2]) - (c[0] - a[0]) * (b[2] - a[2])) / 2 if area > 1e-6: least = min(least, math.dist((a[0], a[2]), (b[0], b[2])) * math.dist((b[0], b[2]), (c[0], c[2])) * math.dist((c[0], c[2]), (a[0], a[2])) / (4 * area)) return least def end_curve(part, key): line = part["line"] if len(line) < 3: return 1.0 / part["radius"] if part["radius"] > 0 else 0.0 a, b, c = line[:3] if key == "p1" else line[-3:] sides = math.dist(a, b) * math.dist(b, c) * math.dist(c, a) return 2.0 * ((b[0] - a[0]) * (c[2] - b[2]) - (b[2] - a[2]) * (c[0] - b[0])) / sides if sides > 0 else 0.0 class Joints: def __init__(self, tracks): self.ends = collections.defaultdict(list) for t in tracks: for part in t["paths"]: for key in ("p1", "p2"): self.ends[(round(part[key][0]), round(part[key][2]))].append((t, part, key)) def at(self, point): found = [] for cx in (round(point[0]) - 1, round(point[0]), round(point[0]) + 1): for cz in (round(point[2]) - 1, round(point[2]), round(point[2]) + 1): for item in self.ends.get((cx, cz), ()): if abs(item[1][item[2]][0] - point[0]) <= REACH and abs(item[1][item[2]][2] - point[2]) <= REACH: found.append(item) return found def settle_speeds(tracks, joints): # from the nearest track on the stretch between switches, a short piece also along the straight path of a switch heads = collections.deque(t for t in tracks if t["kind"] == "normal" and t["speed"]) while heads: t = heads.popleft() for key in ("p1", "p2"): for other, _, _ in joints.at(t["paths"][0][key]): if other is not t and other["kind"] == "normal" and other["speed"] is None: other["speed"], other["source"] = t["speed"], "sasiad" heads.append(other) heads = collections.deque(t for t in tracks if t["kind"] == "normal" and t["speed"]) while heads: t = heads.popleft() for key in ("p1", "p2"): points, seen = [t["paths"][0][key]], set() for _ in range(6): onward = [] for point in points: for other, part, side in joints.at(point): if other is t or id(part) in seen: continue seen.add(id(part)) if other["kind"] == "switch": if other["paths"].index(part) != other["bent"]: onward.append(part["p2" if side == "p1" else "p1"]) elif other["speed"] is None and other["paths"][0]["length"] < PIECE: other["speed"], other["source"] = t["speed"], "sasiad" heads.append(other) points = onward for t in tracks: if t["speed"] is None: t["speed"], t["source"] = NO_SPEED, "brak" def distances(tracks, joints, station): best, heap = {}, [] for t in tracks: for part in t["paths"]: for key in ("p1", "p2"): gap = math.dist((part[key][0], part[key][2]), station) node = (round(part[key][0], 1), round(part[key][2], 1)) if gap < 300 and t["kind"] == "normal" and gap < best.get(node, math.inf): best[node] = gap heapq.heappush(heap, (gap, node, part[key])) while heap: distance, node, point = heapq.heappop(heap) if distance > best.get(node, math.inf): continue for _, part, key in joints.at(point): other = part["p2" if key == "p1" else "p1"] onward = (round(other[0], 1), round(other[2], 1)) if distance + part["length"] < best.get(onward, math.inf): best[onward] = distance + part["length"] heapq.heappush(heap, (best[onward], onward, other)) return best def grass_on(part, plants): near, count = set(), max(1, int(part["length"] / 3)) line = part["line"] for i in range(count + 1): position = i / count * (len(line) - 1) low = min(int(position), len(line) - 2) share = position - low x, z = line[low][0] + (line[low + 1][0] - line[low][0]) * share, line[low][2] + (line[low + 1][2] - line[low][2]) * share for cx in (round(x / 10) - 1, round(x / 10), round(x / 10) + 1): for cz in (round(z / 10) - 1, round(z / 10), round(z / 10) + 1): for plant in plants.get((cx, cz), ()): if (plant[0] - x) ** 2 + (plant[1] - z) ** 2 < GRASS_NEAR * GRASS_NEAR: near.add(plant) return len(near) * 100.0 / max(part["length"], 5.0) def road_cells(roads): cells = collections.defaultdict(list) for road in roads: for a, b in zip(road["line"], road["line"][1:]): for x in range(math.floor(min(a[0], b[0]) / 50), math.floor(max(a[0], b[0]) / 50) + 1): for z in range(math.floor(min(a[2], b[2]) / 50), math.floor(max(a[2], b[2]) / 50) + 1): cells[(x, z)].append((a, b)) return cells def hits_road(part, cells): for a, b in zip(part["line"], part["line"][1:]): for x in range(math.floor(min(a[0], b[0]) / 50), math.floor(max(a[0], b[0]) / 50) + 1): for z in range(math.floor(min(a[2], b[2]) / 50), math.floor(max(a[2], b[2]) / 50) + 1): for c, d in cells.get((x, z), ()): rx, rz, sx, sz = b[0] - a[0], b[2] - a[2], d[0] - c[0], d[2] - c[2] k = rx * sz - rz * sx if abs(k) < 1e-9: continue t = ((c[0] - a[0]) * sz - (c[2] - a[2]) * sx) / k u = ((c[0] - a[0]) * rz - (c[2] - a[2]) * rx) / k if 0 <= t <= 1 and 0 <= u <= 1: return True return False def heights_per_mm(t): # the height of the rail under a pantograph frame by frame, per mm of the vertical part step = t["speed"] * OVERSPEED / 3.6 / 60.0 heights, done = [], 0.0 line = t["paths"][0]["line"] for a, b in zip(line, line[1:]): length = math.dist(a, b) count = max(1, int(length / step)) for i in range(count): share = i / count x, z = a[0] + (b[0] - a[0]) * share, a[2] + (b[2] - a[2]) * share height = STRAY_PER_MM * sum(s * math.sin(wx * x + wz * z + phase) for wx, wz, phase, s in UP_WAVES) if t["sound"] > 2.0 * DIP_REACH: phase = math.fmod(done + length * share, t["sound"]) joint = min(phase, t["sound"] - phase) if joint < DIP_REACH: height -= 0.001 * DIP_SHARE * math.cos(math.pi / 2 * joint / DIP_REACH) ** 2 heights.append(height) done += length return heights def largest_gap(heights, up): gap = worst = 0.0 climb = RISE / 60.0 for before, after in zip(heights, heights[1:]): gap = max(0.0, gap + (before - after) * up - climb) worst = max(worst, gap) return worst def ceiling(t, product): # the worst track of a speed comes up to it and the better ones stay under it, so the state of a track still shows return product / t["speed"] * (0.7 + 0.3 * min(1.0, max(0.0, (t["state"] - 0.5) / 0.7))) def path_radius(part): return min(plan_radius(part["line"]), part["radius"] if part["radius"] > 0 else math.inf) def mark_diverging_paths(switches): # the path that bends more for t in switches: radii = [path_radius(p) for p in t["paths"]] t["bent"] = 1 if len(radii) < 2 or radii[1] <= radii[0] else 0 class Route: """How far along from the first point to the second a place lies, measured along the tracks.""" def __init__(self, tracks, joints, first, last): self.first, self.last = first, last self.from_first, self.from_last = distances(tracks, joints, first), distances(tracks, joints, last) ends = [self.from_last[n] for n in self.from_last if math.dist(n, first) < 300] self.length = min(ends) if ends else math.dist(first, last) if not ends: print("uwaga: po torach nie ma polaczenia miedzy punktami --route, licze w linii prostej") def share(self, part): shares = [] for key in ("p1", "p2"): place = (part[key][0], part[key][2]) node = (round(place[0], 1), round(place[1], 1)) a, b = self.from_first.get(node), self.from_last.get(node) if a is None or b is None: a, b = math.dist(place, self.first), math.dist(place, self.last) shares.append(min(1.0, max(0.0, (a - b + self.length) / (2 * self.length)))) return 0.5 * sum(shares) def grade_states(scenery, route, gain): cells = road_cells(scenery.roads) for t in scenery.tracks: part = t["paths"][0] radius = path_radius(part) curve = 0.0 if radius >= 6000 else min(1.0, max(0.0, (1200 - radius) / 950)) plain = t["kind"] == "normal" density = grass_on(part, scenery.plants) if plain else 0.0 crossing = plain and hits_road(part, cells) progress = route.share(part) if route else 0.5 state = 0.50 + 0.20 * wear(t["ballast"], BALLAST_WEAR) + 0.10 * wear(t["rail"], RAIL_WEAR) + 0.12 * min(1.0, density / GRASS_FULL) + 0.06 * curve + 0.22 * progress + 0.18 * crossing + 0.06 * (hashed(b"", t["name"]) - 0.5) t.update(state=min(state, 1.2) * gain, curve=curve, crossing=crossing, grass=density) if plain: value = min(limit(t["speed"]) * t["state"], MOST) t.update(value=value, up=min(value * 1.25, MOST_UP), side=min(value * (0.9 + 0.4 * curve), MOST)) def fit_under_pantograph(normal): # the largest product of the vertical part and the speed with the gap small on every track low, high = 100, 4000 while high - low > 25: middle = (low + high) // 2 if all(largest_gap(t["heights"], min(t["up"], ceiling(t, middle))) <= GAP_MOST for t in normal): low = middle else: high = middle for t in normal: up = ceiling(t, low) if up < t["up"]: ratio = up / t["up"] t["up"], t["value"], t["side"] = up, t["value"] * ratio, t["side"] * ratio return low def curve_changes(t, joints): part = t["paths"][0] if abs(end_curve(part, "p1") - end_curve(part, "p2")) > CURVE_STEP: return True for key in ("p1", "p2"): for other, theirs, side in joints.at(part[key]): if other is not t and other["kind"] == "normal": their = end_curve(theirs, side) if abs(end_curve(part, key) - (-their if side == key else their)) > CURVE_STEP: return True return False def move_near_limit(normal, joints, share): # on wooden sleepers and where the curve changes, a share of the tracks goes nearer the limit, chosen for good by the place chosen = 0 for t in normal: if not (WOOD.search(t["ballast"] or "") or curve_changes(t, joints)): continue part = t["paths"][0] name = f"{t['name']}:{part['p1'][0]:.0f}:{part['p1'][2]:.0f}" if hashed(b"near", name) >= share: continue value = t["value"] + (limit(t["speed"]) - t["value"]) * (NEAR_LEAST + (NEAR_MOST - NEAR_LEAST) * hashed(b"how", name)) if value <= t["value"]: continue # sideways and the cross level don't move a pantograph, up and down only as far as it keeps to the wire on this track up = value while up > t["up"] and largest_gap(t["heights"], up) > GAP_MOST: up -= 0.5 t["value"], t["up"], t["side"] = value, max(up, t["up"]), min(value * (0.9 + 0.4 * t["curve"]), MOST) chosen += 1 return chosen def grade_switches(switches, joints, product): # each path by the plain tracks it leads to, the worst of them; those only among switches from their neighbours for t in switches: t["values"] = [None] * len(t["paths"]) for index, part in enumerate(t["paths"]): found = [o for key in ("p1", "p2") for o, theirs, _ in joints.at(part[key]) if o["kind"] == "normal" and theirs["length"] >= SHORT] if found: speed = max(o["speed"] for o in found) if index == t["bent"]: speed = min(speed, DIVERGING) t["values"][index] = min(limit(speed) * max(o["state"] for o in found), SWITCH_MOST, product / speed) for _ in range(5): for t in switches: for index, part in enumerate(t["paths"]): if t["values"][index] is None: found = [o["values"][i] for key in ("p1", "p2") for o, theirs, _ in joints.at(part[key]) if o["kind"] == "switch" and o is not t for i, q in enumerate(o["paths"]) if q is theirs and o["values"][i] is not None] if found: t["values"][index] = max(found) for t in switches: t["values"] = [min(SWITCH_MOST, product / NO_SPEED) if v is None else v for v in t["values"]] def grade(scenery, options): tracks = scenery.tracks normal = [t for t in tracks if t["kind"] == "normal"] switches = [t for t in tracks if t["kind"] == "switch"] joints = Joints(tracks) mark_diverging_paths(switches) settle_speeds(tracks, joints) grade_states(scenery, Route(tracks, joints, *options.route) if options.route else None, options.gain) for t in normal: t["heights"] = heights_per_mm(t) product = fit_under_pantograph(normal) chosen = move_near_limit(normal, joints, options.near) worst = max((largest_gap(t["heights"], t["up"]) for t in normal), default=0.0) for t in normal: del t["heights"] if t["name"].lower() in options.straight: t["value"] = t["up"] = t["side"] = 0.0 grade_switches(switches, joints, product) return product, chosen, worst def report(scenery, product, chosen, worst): normal = [t for t in scenery.tracks if t["kind"] == "normal"] switches = [t for t in scenery.tracks if t["kind"] == "switch"] print(f"pliki: {len(scenery.seen)}, tory: {len(normal)}, rozjazdy: {len(switches)}, drogi: {len(scenery.roads)}, trawa: {sum(len(v) for v in scenery.plants.values())}") print(f"pion razy km/h najwyzej {product}, blizej granicy {chosen} torow, najwieksza przerwa do drutu {worst * 100:.2f} cm (bez wznosu samego drutu)") groups = collections.defaultdict(list) for t in normal: groups[(t["source"], t["speed"])].append(t) print("predkosc skad torow km limit uneven min/mediana/max pion max") for key in sorted(groups, key=lambda k: (-k[1], k[0])): rows = groups[key] values = sorted(t["value"] for t in rows) print(f"{key[1]:8.0f} {key[0]:8} {len(rows):6} {sum(t['paths'][0]['length'] for t in rows) / 1000:6.1f} {limit(key[1]):6.1f} {values[0]:6.1f} {values[len(values) // 2]:6.1f} {values[-1]:6.1f} {max(t['up'] for t in rows):8.1f}") if switches: values = sorted(v for t in switches for v in t["values"]) print(f"rozjazdy: {values[0]:.1f}-{values[-1]:.1f} mm, mediana {values[len(values) // 2]:.1f}") for note, count in sorted(scenery.notes.items()): print(f"uwaga: {note}: {count}" if not note.startswith("brak") else f"uwaga: {note}") if scenery.notes["rotate"]: print("uwaga: bloki rotate nie sa uwzgledniane, polaczenia torow z nich moga byc nierozpoznane") taken = sum(1 for t in scenery.tracks if t["taken"]) if taken: print(f"uwaga: {taken} torow ma juz nierownosci, zostaja bez zmian") def attribute(t): if t["kind"] == "normal": return f"uneven {t['value']:.1f};{t['up']:.1f};{t['side']:.1f} " if t["value"] > 0 else "" return "uneven " + ";".join(f"{v:.1f}" for v in t["values"]) + " " def write(scenery, out): by_file = collections.defaultdict(list) for t in scenery.tracks: if not t["taken"]: by_file[t["file"]].append(t) written = 0 for path, tracks in by_file.items(): text = scenery.texts[path] pieces, last = [], 0 for t in sorted(tracks, key=lambda t: t["offset"]): pieces += [text[last:t["offset"]], attribute(t)] last = t["offset"] pieces.append(text[last:]) target = out / path.relative_to(scenery.root) target.parent.mkdir(parents=True, exist_ok=True) target.write_bytes("".join(pieces).encode("latin-1")) written += 1 print(f"zapisane pliki: {written}, w {out}") def point(text): x, z = text.split(",") return float(x), float(z) def main(): parser = argparse.ArgumentParser(description="Ocena torow dowolnej scenerii dla atrybutu uneven.") parser.add_argument("files", nargs="+", type=pathlib.Path, help=".scn, .scm albo .inc; includy sa czytane dalej") parser.add_argument("--root", type=pathlib.Path, help="folder scenery, wzgledem ktorego ida includy; domyslnie folder pierwszego pliku") parser.add_argument("--out", type=pathlib.Path, help="folder na kopie plikow z torami; bez tego tylko raport") parser.add_argument("--route", nargs=2, type=point, metavar="X,Z", help="tory pogarszaja sie od pierwszego punktu do drugiego, liczac po torach") parser.add_argument("--gain", type=float, default=1.0, help="mnoznik stanu torow, domyslnie 1") parser.add_argument("--near", type=float, default=0.6, help="jaka czesc torow na drewnie i przy zmianach krzywizny idzie blizej granicy Id-14, domyslnie 0.6") parser.add_argument("--straight", default="", help="nazwy torow bez nierownosci, po przecinku") options = parser.parse_args() options.straight = {name.strip().lower() for name in options.straight.split(",") if name.strip()} root =(options.root or options.files[0].parent).resolve() if options.out: options.out = options.out.resolve() if options.out == root or root in options.out.parents: sys.exit("--out nie moze lezec w folderze scenerii: oryginaly maja zostac nietkniete") scenery = Scenery(root) for path in options.files: scenery.read(path) if not scenery.tracks: sys.exit("nie znaleziono torow") product, chosen, worst = grade(scenery, options) report(scenery, product, chosen, worst) if options.out: write(scenery, options.out) if __name__ == "__main__": main()