summaryrefslogtreecommitdiff
path: root/gerbonara/tests/image_support.py
diff options
context:
space:
mode:
authorjaseg <git@jaseg.de>2022-01-30 20:11:38 +0100
committerjaseg <git@jaseg.de>2022-01-30 20:11:38 +0100
commitc3ca4f95bd59f69d45e582a4149327f57a360760 (patch)
tree5f43c61a261698e2f671b5238a7aa9a71a0f6d23 /gerbonara/tests/image_support.py
parent259a56186820923c78a5688f59bd8249cf958b5f (diff)
downloadgerbonara-c3ca4f95bd59f69d45e582a4149327f57a360760.tar.gz
gerbonara-c3ca4f95bd59f69d45e582a4149327f57a360760.tar.bz2
gerbonara-c3ca4f95bd59f69d45e582a4149327f57a360760.zip
Rename gerbonara/gerber package to just gerbonara
Diffstat (limited to 'gerbonara/tests/image_support.py')
-rw-r--r--gerbonara/tests/image_support.py237
1 files changed, 237 insertions, 0 deletions
diff --git a/gerbonara/tests/image_support.py b/gerbonara/tests/image_support.py
new file mode 100644
index 0000000..926e91d
--- /dev/null
+++ b/gerbonara/tests/image_support.py
@@ -0,0 +1,237 @@
+import subprocess
+from pathlib import Path
+import tempfile
+import textwrap
+import os
+from functools import total_ordering
+import shutil
+import bs4
+from contextlib import contextmanager
+import hashlib
+
+import numpy as np
+from PIL import Image
+
+cachedir = Path(__file__).parent / 'image_cache'
+cachedir.mkdir(exist_ok=True)
+
+@total_ordering
+class ImageDifference:
+ def __init__(self, value, histogram):
+ self.value = value
+ self.histogram = histogram
+
+ def __float__(self):
+ return float(self.value)
+
+ def __eq__(self, other):
+ return float(self) == float(other)
+
+ def __lt__(self, other):
+ return float(self) < float(other)
+
+ def __str__(self):
+ return str(float(self))
+
+@total_ordering
+class Histogram:
+ def __init__(self, value, size):
+ self.value, self.size = value, size
+
+ def __eq__(self, other):
+ other = np.array(other)
+ other[other == None] = self.value[other == None]
+ return (self.value == other).all()
+
+ def __lt__(self, other):
+ other = np.array(other)
+ other[other == None] = self.value[other == None]
+ return (self.value <= other).all()
+
+ def __getitem__(self, index):
+ return self.value[index]
+
+ def __str__(self):
+ return f'{list(self.value)} size={self.size}'
+
+
+def run_cargo_cmd(cmd, args, **kwargs):
+ if cmd.upper() in os.environ:
+ return subprocess.run([os.environ[cmd.upper()], *args], **kwargs)
+
+ try:
+ return subprocess.run([cmd, *args], **kwargs)
+
+ except FileNotFoundError:
+ return subprocess.run([str(Path.home() / '.cargo' / 'bin' / cmd), *args], **kwargs)
+
+def svg_to_png(in_svg, out_png, dpi=100, bg=None):
+ params = f'{dpi}{bg}'.encode()
+ digest = hashlib.blake2b(Path(in_svg).read_bytes() + params).hexdigest()
+ cachefile = cachedir / f'{digest}.png'
+
+ if not cachefile.is_file():
+ bg = 'black' if bg is None else bg
+ run_cargo_cmd('resvg', ['--background', bg, '--dpi', str(dpi), in_svg, cachefile], check=True, stdout=subprocess.DEVNULL)
+
+ shutil.copy(cachefile, out_png)
+
+to_gerbv_svg_units = lambda val, unit='mm': val*72 if unit == 'inch' else val/25.4*72
+
+def gerbv_export(in_gbr, out_svg, export_format='svg', origin=(0, 0), size=(6, 6), fg='#ffffff', bg='#000000', override_unit_spec=None):
+ params = f'{origin}{size}{fg}{bg}'.encode()
+ digest = hashlib.blake2b(Path(in_gbr).read_bytes() + params).hexdigest()
+ cachefile = cachedir / f'{digest}.svg'
+
+ if not cachefile.is_file():
+ # NOTE: gerbv seems to always export 'clear' polarity apertures as white, irrespective of --foreground, --background
+ # and project file color settings.
+ # TODO: File issue upstream.
+ with tempfile.NamedTemporaryFile('w') as f:
+ if override_unit_spec:
+ units, zeros, digits = override_unit_spec
+ print(f'{Path(in_gbr).name}: overriding excellon unit spec to {units=} {zeros=} {digits=}')
+ units = 0 if units == 'inch' else 1
+ zeros = {None: 0, 'leading': 1, 'trailing': 2}[zeros]
+ unit_spec = textwrap.dedent(f'''(cons 'attribs (list
+ (list 'autodetect 'Boolean 0)
+ (list 'zero_suppression 'Enum {zeros})
+ (list 'units 'Enum {units})
+ (list 'digits 'Integer {digits})
+ ))''')
+ else:
+ unit_spec = ''
+
+ r, g, b = int(fg[1:3], 16), int(fg[3:5], 16), int(fg[5:], 16)
+ color = f"(cons 'color #({r*257} {g*257} {b*257}))"
+ f.write(f'''(gerbv-file-version! "2.0A")(define-layer! 0 (cons 'filename "{in_gbr}"){unit_spec}{color})''')
+ f.flush()
+ if override_unit_spec:
+ shutil.copy(f.name, '/tmp/foo.gbv')
+
+ x, y = origin
+ w, h = size
+ cmd = ['gerbv', '-x', export_format,
+ '--border=0',
+ f'--origin={x:.6f}x{y:.6f}', f'--window_inch={w:.6f}x{h:.6f}',
+ f'--background={bg}',
+ f'--foreground={fg}',
+ '-o', str(cachefile), '-p', f.name]
+ subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+ shutil.copy(cachefile, out_svg)
+
+@contextmanager
+def svg_soup(filename):
+ with open(filename, 'r') as f:
+ soup = bs4.BeautifulSoup(f.read(), 'xml')
+
+ yield soup
+
+ with open(filename, 'w') as f:
+ f.write(str(soup))
+
+def cleanup_gerbv_svg(soup):
+ for group in soup.find_all('g'):
+ # gerbv uses Cairo's SVG canvas. Cairo's SVG canvas is kind of broken. It has no support for unit
+ # handling at all, which means the output files just end up being in pixels at 72 dpi. Further, it
+ # seems gerbv's aperture macro rendering interacts poorly with Cairo's SVG export. gerbv renders
+ # aperture macros into a new surface, which for some reason gets clipped by Cairo to the given
+ # canvas size. This is just wrong, so we just nuke the clip path from these SVG groups here.
+ #
+ # Apart from being graphically broken, this additionally causes very bad rendering performance.
+ del group['clip-path']
+
+def gerber_difference(reference, actual, diff_out=None, svg_transform=None, size=(10,10), ref_unit_spec=None):
+ with tempfile.NamedTemporaryFile(suffix='.svg') as act_svg,\
+ tempfile.NamedTemporaryFile(suffix='.svg') as ref_svg:
+
+ gerbv_export(reference, ref_svg.name, size=size, export_format='svg', override_unit_spec=ref_unit_spec)
+ gerbv_export(actual, act_svg.name, size=size, export_format='svg')
+
+ with svg_soup(ref_svg.name) as soup:
+ if svg_transform is not None:
+ soup.find('g', attrs={'id': 'surface1'})['transform'] = svg_transform
+ cleanup_gerbv_svg(soup)
+
+ with svg_soup(act_svg.name) as soup:
+ cleanup_gerbv_svg(soup)
+
+ return svg_difference(ref_svg.name, act_svg.name, diff_out=diff_out)
+
+def gerber_difference_merge(ref1, ref2, actual, diff_out=None, composite_out=None, svg_transform1=None, svg_transform2=None, size=(10,10)):
+ with tempfile.NamedTemporaryFile(suffix='.svg') as act_svg,\
+ tempfile.NamedTemporaryFile(suffix='.svg') as ref1_svg,\
+ tempfile.NamedTemporaryFile(suffix='.svg') as ref2_svg:
+
+ gerbv_export(ref1, ref1_svg.name, size=size, export_format='svg')
+ gerbv_export(ref2, ref2_svg.name, size=size, export_format='svg')
+ gerbv_export(actual, act_svg.name, size=size, export_format='svg')
+
+ with svg_soup(ref1_svg.name) as soup1:
+ if svg_transform1 is not None:
+ soup1.find('g', attrs={'id': 'surface1'})['transform'] = svg_transform1
+ cleanup_gerbv_svg(soup1)
+
+ with svg_soup(ref2_svg.name) as soup2:
+ if svg_transform2 is not None:
+ soup2.find('g', attrs={'id': 'surface1'})['transform'] = svg_transform2
+ cleanup_gerbv_svg(soup2)
+
+ defs1 = soup1.find('defs')
+ if not defs1:
+ defs1 = soup1.new_tag('defs')
+ soup1.find('svg').insert(0, defs1)
+
+ defs2 = soup2.find('defs')
+ if defs2:
+ defs2 = defs2.extract()
+ # explicitly convert .contents into list here and below because else bs4 stumbles over itself
+ # iterating because we modify the tree in the loop body.
+ for c in list(defs2.contents):
+ if hasattr(c, 'attrs'):
+ c['id'] = 'gn-merge-b-' + c.attrs.get('id', str(id(c)))
+ defs1.append(c)
+
+ for use in soup2.find_all('use', recursive=True):
+ if (href := use.get('xlink:href', '')).startswith('#'):
+ use['xlink:href'] = f'#gn-merge-b-{href[1:]}'
+
+ svg1 = soup1.find('svg')
+ for c in list(soup2.find('svg').contents):
+ if hasattr(c, 'attrs'):
+ c['id'] = 'gn-merge-b-' + c.attrs.get('id', str(id(c)))
+ svg1.append(c)
+
+ if composite_out:
+ shutil.copyfile(ref1_svg.name, composite_out)
+
+ with svg_soup(act_svg.name) as soup:
+ cleanup_gerbv_svg(soup)
+
+ return svg_difference(ref1_svg.name, act_svg.name, diff_out=diff_out)
+
+def svg_difference(reference, actual, diff_out=None, background=None):
+ with tempfile.NamedTemporaryFile(suffix='-ref.png') as ref_png,\
+ tempfile.NamedTemporaryFile(suffix='-act.png') as act_png:
+
+ svg_to_png(reference, ref_png.name, bg=background)
+ svg_to_png(actual, act_png.name, bg=background)
+
+ return image_difference(ref_png.name, act_png.name, diff_out=diff_out)
+
+def image_difference(reference, actual, diff_out=None):
+ ref = np.array(Image.open(reference)).astype(float)
+ out = np.array(Image.open(actual)).astype(float)
+
+ ref, out = ref.mean(axis=2), out.mean(axis=2) # convert to grayscale
+ # TODO blur images here before comparison to mitigate aliasing issue
+ delta = np.abs(out - ref).astype(float) / 255
+ if diff_out:
+ Image.fromarray((delta*255).astype(np.uint8), mode='L').save(diff_out)
+
+ hist, _bins = np.histogram(delta, bins=10, range=(0, 1))
+ return (ImageDifference(delta.mean(), hist),
+ ImageDifference(delta.max(), hist),
+ Histogram(hist, out.size))
+
+