mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-20 06:21:16 +01:00
370 lines
11 KiB
Python
Executable File
370 lines
11 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import xml.etree.ElementTree as ET
|
|
import re
|
|
import math
|
|
|
|
def tokenize_path_data(d_attribute):
|
|
"""
|
|
Splits an SVG path 'd' attribute string into a list of tokens:
|
|
- Single-letter commands (M, m, L, l, C, c, etc.)
|
|
- Float values (including possible scientific notation)
|
|
Returns a list of strings/float, e.g. ['M', 10.0, 20.0, 'L', 30.5, 40.7, 'Z'].
|
|
"""
|
|
# Regex explanation:
|
|
# ([MmZzLlHhVvCcSsQqTtAa]) => one of the valid path command letters
|
|
# | => OR
|
|
# ([+-]?\d+(\.\d+)?([eE][+-]?\d+)?) => a number that may include optional +/-,
|
|
# decimals, and scientific notation
|
|
token_pattern = re.compile(r'([MmZzLlHhVvCcSsQqTtAa])|([+-]?\d+(\.\d+)?([eE][+-]?\d+)?)')
|
|
raw_tokens = token_pattern.findall(d_attribute)
|
|
|
|
# raw_tokens is a list of tuples from the capturing groups. We only need one
|
|
# of those fields from each match. We'll filter out empty strings and parse floats.
|
|
tokens = []
|
|
for match in raw_tokens:
|
|
# match is a tuple: (command_letter, number_string, ..., ...)
|
|
command_letter = match[0]
|
|
number_string = match[1]
|
|
if command_letter:
|
|
# It's a path command like 'M', 'L', etc.
|
|
tokens.append(command_letter)
|
|
else:
|
|
# It's a numeric value
|
|
tokens.append(float(number_string))
|
|
|
|
return tokens
|
|
|
|
def extract_paths_from_svg(svg_data):
|
|
"""
|
|
Parses an SVG file and extracts the 'd' attribute from
|
|
all <path> elements in order. Returns a list of token lists.
|
|
"""
|
|
root = ET.fromstring(svg_data)
|
|
|
|
# Inkscape / Illustrator SVGs often have a default namespace.
|
|
# You may need to adjust the namespace if the <path> tags are qualified.
|
|
# For example:
|
|
# namespace = {'svg': 'http://www.w3.org/2000/svg'}
|
|
# for path_elem in root.findall('.//svg:path', namespace):
|
|
# ...
|
|
# If your SVGs do not use a default namespace, the below should work.
|
|
|
|
all_token_lists = []
|
|
for path_elem in root.findall('.//{http://www.w3.org/2000/svg}path'):
|
|
d_attribute = path_elem.get('d')
|
|
if d_attribute:
|
|
tokens = tokenize_path_data(d_attribute)
|
|
all_token_lists.append(tokens)
|
|
|
|
# If your SVG has no default namespace or if you removed it, you might do:
|
|
# for path_elem in root.findall('.//path'):
|
|
# d_attribute = path_elem.get('d')
|
|
# ...
|
|
#
|
|
# Adjust as appropriate depending on your actual SVG structure/namespaces.
|
|
|
|
return all_token_lists
|
|
|
|
def normalize_tokens(tokens):
|
|
"""
|
|
Normalize path tokens for structural comparison.
|
|
Currently this drops degenerate linear segments:
|
|
- L/l where endpoint equals current point
|
|
- H/h where x stays unchanged
|
|
- V/v where y stays unchanged
|
|
"""
|
|
out = []
|
|
i = 0
|
|
cmd = None
|
|
cx = 0.0
|
|
cy = 0.0
|
|
sx = 0.0
|
|
sy = 0.0
|
|
have_current = False
|
|
|
|
def gather_numbers(start):
|
|
j = start
|
|
vals = []
|
|
while j < len(tokens) and not isinstance(tokens[j], str):
|
|
vals.append(tokens[j])
|
|
j += 1
|
|
return vals, j
|
|
|
|
while i < len(tokens):
|
|
token = tokens[i]
|
|
if isinstance(token, str):
|
|
cmd = token
|
|
i += 1
|
|
elif cmd is None:
|
|
# Malformed path: no command to apply.
|
|
return tokens
|
|
|
|
if cmd in ('Z', 'z'):
|
|
out.append(cmd)
|
|
if have_current:
|
|
cx, cy = sx, sy
|
|
continue
|
|
|
|
values, i = gather_numbers(i)
|
|
|
|
if cmd in ('M', 'm'):
|
|
if len(values) < 2:
|
|
return tokens
|
|
|
|
# First pair is moveto and cannot be dropped.
|
|
out.extend([cmd, values[0], values[1]])
|
|
if cmd == 'M':
|
|
cx, cy = values[0], values[1]
|
|
else:
|
|
if have_current:
|
|
cx += values[0]
|
|
cy += values[1]
|
|
else:
|
|
cx, cy = values[0], values[1]
|
|
sx, sy = cx, cy
|
|
have_current = True
|
|
|
|
# Remaining pairs are implicit lineto.
|
|
kept = []
|
|
k = 2
|
|
while k + 1 < len(values):
|
|
x = values[k]
|
|
y = values[k + 1]
|
|
if cmd == 'M':
|
|
nx, ny = x, y
|
|
else:
|
|
nx, ny = cx + x, cy + y
|
|
|
|
if nx != cx or ny != cy:
|
|
kept.extend([x, y])
|
|
cx, cy = nx, ny
|
|
k += 2
|
|
|
|
out.extend(kept)
|
|
continue
|
|
|
|
if cmd in ('L', 'l'):
|
|
kept = []
|
|
k = 0
|
|
while k + 1 < len(values):
|
|
x = values[k]
|
|
y = values[k + 1]
|
|
if cmd == 'L':
|
|
nx, ny = x, y
|
|
else:
|
|
nx, ny = cx + x, cy + y
|
|
|
|
if nx != cx or ny != cy:
|
|
kept.extend([x, y])
|
|
cx, cy = nx, ny
|
|
k += 2
|
|
|
|
if kept:
|
|
out.append(cmd)
|
|
out.extend(kept)
|
|
continue
|
|
|
|
if cmd in ('H', 'h'):
|
|
kept = []
|
|
for x in values:
|
|
nx = x if cmd == 'H' else cx + x
|
|
if nx != cx:
|
|
kept.append(x)
|
|
cx = nx
|
|
if kept:
|
|
out.append(cmd)
|
|
out.extend(kept)
|
|
continue
|
|
|
|
if cmd in ('V', 'v'):
|
|
kept = []
|
|
for y in values:
|
|
ny = y if cmd == 'V' else cy + y
|
|
if ny != cy:
|
|
kept.append(y)
|
|
cy = ny
|
|
if kept:
|
|
out.append(cmd)
|
|
out.extend(kept)
|
|
continue
|
|
|
|
# For other commands, keep original parameters and just track current point.
|
|
if cmd in ('C', 'c'):
|
|
if values:
|
|
out.append(cmd)
|
|
out.extend(values)
|
|
k = 0
|
|
while k + 5 < len(values):
|
|
if cmd == 'C':
|
|
cx, cy = values[k + 4], values[k + 5]
|
|
else:
|
|
cx += values[k + 4]
|
|
cy += values[k + 5]
|
|
k += 6
|
|
have_current = True
|
|
continue
|
|
|
|
if cmd in ('S', 's'):
|
|
if values:
|
|
out.append(cmd)
|
|
out.extend(values)
|
|
k = 0
|
|
while k + 3 < len(values):
|
|
if cmd == 'S':
|
|
cx, cy = values[k + 2], values[k + 3]
|
|
else:
|
|
cx += values[k + 2]
|
|
cy += values[k + 3]
|
|
k += 4
|
|
have_current = True
|
|
continue
|
|
|
|
if cmd in ('Q', 'q'):
|
|
if values:
|
|
out.append(cmd)
|
|
out.extend(values)
|
|
k = 0
|
|
while k + 3 < len(values):
|
|
if cmd == 'Q':
|
|
cx, cy = values[k + 2], values[k + 3]
|
|
else:
|
|
cx += values[k + 2]
|
|
cy += values[k + 3]
|
|
k += 4
|
|
have_current = True
|
|
continue
|
|
|
|
if cmd in ('T', 't'):
|
|
if values:
|
|
out.append(cmd)
|
|
out.extend(values)
|
|
k = 0
|
|
while k + 1 < len(values):
|
|
if cmd == 'T':
|
|
cx, cy = values[k], values[k + 1]
|
|
else:
|
|
cx += values[k]
|
|
cy += values[k + 1]
|
|
k += 2
|
|
have_current = True
|
|
continue
|
|
|
|
if cmd in ('A', 'a'):
|
|
if values:
|
|
out.append(cmd)
|
|
out.extend(values)
|
|
k = 0
|
|
while k + 6 < len(values):
|
|
if cmd == 'A':
|
|
cx, cy = values[k + 5], values[k + 6]
|
|
else:
|
|
cx += values[k + 5]
|
|
cy += values[k + 6]
|
|
k += 7
|
|
have_current = True
|
|
continue
|
|
|
|
# Unknown command: keep as-is.
|
|
out.append(cmd)
|
|
out.extend(values)
|
|
|
|
return out
|
|
|
|
def compare_token_lists_exact(tokens_a, tokens_b):
|
|
"""
|
|
Compares two lists of path tokens (commands and floats).
|
|
Returns True if they match (same commands in same positions,
|
|
numeric values within given tolerance), otherwise False.
|
|
"""
|
|
if len(tokens_a) != len(tokens_b):
|
|
return None # Different lengths => not a match
|
|
|
|
max_diff = 0
|
|
for a, b in zip(tokens_a, tokens_b):
|
|
if isinstance(a, str) and isinstance(b, str):
|
|
# Must match exactly the same command letter
|
|
if a != b:
|
|
return None
|
|
elif isinstance(a, float) and isinstance(b, float):
|
|
# Compare numeric values
|
|
diff = abs(a - b)
|
|
max_diff = max(max_diff, diff)
|
|
else:
|
|
# One is command, the other is float => mismatch
|
|
return None
|
|
|
|
return max_diff
|
|
|
|
def compare_token_lists(tokens_a, tokens_b):
|
|
"""
|
|
Compare path token streams with a fallback that ignores degenerate
|
|
linear segments (no-op L/l/H/h/V/v) when needed to resolve
|
|
structural mismatches.
|
|
"""
|
|
ret = compare_token_lists_exact(tokens_a, tokens_b)
|
|
if ret is not None:
|
|
return ret
|
|
|
|
return compare_token_lists_exact(normalize_tokens(tokens_a),
|
|
normalize_tokens(tokens_b))
|
|
|
|
def compare_svg_files(svg_file_1, svg_file_2):
|
|
"""
|
|
Compares two SVG files to check if they have the same number of <path> elements,
|
|
and each corresponding path has the same structure of commands.
|
|
Return max difference between respective numeric values in the paths.
|
|
"""
|
|
|
|
svg_data_1 = open(svg_file_1).read()
|
|
svg_data_2 = open(svg_file_2).read()
|
|
|
|
# If contents match exactly, return 0
|
|
if svg_data_1 == svg_data_2:
|
|
return 0
|
|
|
|
paths1 = extract_paths_from_svg(svg_data_1)
|
|
paths2 = extract_paths_from_svg(svg_data_2)
|
|
|
|
# Check that we have the same number of <path> elements
|
|
if len(paths1) != len(paths2):
|
|
return None
|
|
|
|
# Compare each path token list
|
|
max_diff = 0
|
|
for tokens1, tokens2 in zip(paths1, paths2):
|
|
ret = compare_token_lists(tokens1, tokens2)
|
|
if ret is None:
|
|
return ret
|
|
max_diff = max(max_diff, ret)
|
|
|
|
return max_diff
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import sys
|
|
|
|
if '--help' in sys.argv[1:]:
|
|
print("Usage: hb-svg-compare TOLERANCE < file_with_svg_pairs.txt")
|
|
sys.exit(1)
|
|
|
|
tolerance = 0
|
|
if len(sys.argv) > 1:
|
|
tolerance = float(sys.argv[1])
|
|
|
|
# Read all lines of two SVG file paths from stdin and compare
|
|
for line in sys.stdin:
|
|
svg1, svg2 = line.strip().split()
|
|
diff = compare_svg_files(svg1, svg2)
|
|
|
|
if diff is None:
|
|
diff = "DIFF"
|
|
elif diff <= tolerance:
|
|
continue
|
|
else:
|
|
diff = f"{diff:g}"
|
|
|
|
print(f"{diff}\t{svg1}\t{svg2}")
|
|
# Flush stdout to make sure output is immediate
|
|
sys.stdout.flush()
|