#!/usr/bin/env python  """ Convert and optimise images for display in an Acorn Electron MODE 1 variant with four colours per line but eight colours available for selection on each line.  Copyright (C) 2015 Paul Boddie <paul@boddie.org.uk>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>. """  from random import random, randrange from os.path import split, splitext import EXIF import PIL.Image import itertools import sys  corners = [     (0, 0, 0), (255, 0, 0), (0, 255, 0), (255, 255, 0),     (0, 0, 255), (255, 0, 255), (0, 255, 255), (255, 255, 255)     ]  # Basic colour operations.  def within(v, lower, upper):     return min(max(v, lower), upper)  def clip(v):     return int(within(v, 0, 255))  def restore(srgb):     r, g, b = srgb     return int(r * 255.0), int(g * 255.0), int(b * 255.0)  def scale(rgb):     r, g, b = rgb     return r / 255.0, g / 255.0, b / 255.0  def invert(srgb):     r, g, b = srgb     return 1.0 - r, 1.0 - g, 1.0 - b  scaled_corners = map(scale, corners) zipped_corners = zip(corners, scaled_corners)  # Colour distribution functions.  def combination(rgb):      "Return the colour distribution for 'rgb'."      # Get the colour with components scaled from 0 to 1, plus the inverted     # component values.      srgb = scale(rgb)     rgbi = invert(srgb)     pairs = zip(rgbi, srgb)      # For each corner of the colour cube (primary and secondary colours plus     # black and white), calculate the corner value's contribution to the     # input colour.      d = []     for corner, scaled in zipped_corners:         rs, gs, bs = scaled          # Obtain inverted channel values where corner channels are low;         # obtain original channel values where corner channels are high.          d.append((pairs[0][int(rs)] * pairs[1][int(gs)] * pairs[2][int(bs)], corner))      # Balance the corner contributions.      return balance(d)  def complements(rgb):      "Return 'rgb' and its complement."      r, g, b = rgb     return rgb, restore(invert(scale(rgb)))  bases = [(0, 0, 0), (255, 0, 0), (0, 255, 0), (0, 0, 255)] base_complements = map(complements, bases)  def balance(d):      """     Balance distribution 'd', cancelling opposing values and their complements     and replacing their common contributions with black and white contributions.     """      d = dict([(value, f) for f, value in d])     for primary, secondary in base_complements:         common = min(d[primary], d[secondary])         d[primary] -= common         d[secondary] -= common     return [(f, value) for value, f in d.items()]  def combine(d):      "Combine distribution 'd' to get a colour value."      out = [0, 0, 0]     for v, rgb in d:         out[0] += v * rgb[0]         out[1] += v * rgb[1]         out[2] += v * rgb[2]     return tuple(map(int, out))  def pattern(rgb, chosen=None):      """     Obtain a sorted colour distribution for 'rgb', optionally limited to any     specified 'chosen' colours.     """      l = [(f, value) for f, value in combination(rgb) if not chosen or value in chosen]     l.sort(reverse=True)     return l  def get_value(rgb, chosen=None, fail=False):      """     Get an output colour for 'rgb', optionally limited to any specified 'chosen'     colours. If 'fail' is set to a true value, return None if the colour cannot     be expressed using any of the chosen colours.     """      l = pattern(rgb, chosen)     limit = sum([f for f, c in l])     if not limit:         if fail:             return None         else:             return l[randrange(0, len(l))][1]      choose = random() * limit     threshold = 0     for f, c in l:         threshold += f         if choose < threshold:             return c     return c  # Colour processing operations.  def sign(x):     return x >= 0 and 1 or -1  def saturate_rgb(rgb, exp):     r, g, b = rgb     return saturate_value(r, exp), saturate_value(g, exp), saturate_value(b, exp)  def saturate_value(x, exp):     return int(127.5 + sign(x - 127.5) * 127.5 * pow(abs(x - 127.5) / 127.5, exp))  def amplify_rgb(rgb, exp):     r, g, b = rgb     return amplify_value(r, exp), amplify_value(g, exp), amplify_value(b, exp)  def amplify_value(x, exp):     return int(pow(x / 255.0, exp) * 255.0)  # Image operations.  def get_colours(im, y):      "Get a colour distribution from image 'im' for the row 'y'."      width, height = im.size     c = {}     for x in range(0, width):         rgb = im.getpixel((x, y))          # Sum the colour probabilities.          for f, value in combination(rgb):             if not c.has_key(value):                 c[value] = f             else:                 c[value] += f      d = [(n/width, value) for value, n in c.items()]     d.sort(reverse=True)     return d  def get_combinations(c, n):      """     Get combinations of colours from 'c' of size 'n' in decreasing order of     probability.     """      all = []     for l in itertools.combinations(c, n):         total = 0         for f, value in l:             total += f         all.append((total, l))     all.sort(reverse=True)     return [l for total, l in all]  def test():      "Generate slices of the colour cube."      size = 512     for r in (0, 63, 127, 191, 255):         im = PIL.Image.new("RGB", (size, size))         for g in range(0, size):             for b in range(0, size):                 value = get_value((r, (g * 256) / size, (b * 256 / size)))                 im.putpixel((g, b), value)         im.save("rgb%d.png" % r)  def test_flat(rgb):      "Generate a flat image for the colour 'rgb'."      size = 64     im = PIL.Image.new("RGB", (size, size))     for y in range(0, size):         for x in range(0, size):             im.putpixel((x, y), get_value(rgb))     im.save("rgb%02d%02d%02d.png" % rgb)  def rotate_and_scale(exif, im, width, height, rotate):      """     Using the given 'exif' information, rotate and scale image 'im' given the     indicated 'width' and 'height' constraints and any explicit 'rotate'     indication. The returned image will be within the given 'width' and     'height', filling either or both, and preserve its original aspect ratio.     """      if rotate or exif and exif["Image Orientation"].values == [6L]:         im = im.rotate(270)      w, h = im.size     if w > h:         height = (width * h) / w     else:         width = (height * w) / h      return im.resize((width, height))  def count_colours(im, colours):      """     Count colours on each row of image 'im', returning a tuple indicating the     first row with more than the given number of 'colours' together with the     found colours; otherwise returning None.     """      width, height = im.size      for y in range(0, height):         l = set()         for x in range(0, width):             l.add(im.getpixel((x, y)))         if len(l) > colours:             return (y, l)     return None  def process_image(pim, saturate, desaturate, darken, brighten):      """     Process image 'pim' using the given options: 'saturate', 'desaturate',     'darken', 'brighten'.     """      width, height = pim.size     im = SimpleImage(list(pim.getdata()), pim.size)      if saturate or desaturate or darken or brighten:         for y in range(0, height):             for x in range(0, width):                 rgb = im.getpixel((x, y))                 if saturate or desaturate:                     rgb = saturate_rgb(rgb, saturate and 0.5 / saturate or 2 * desaturate)                 if darken or brighten:                     rgb = amplify_rgb(rgb, brighten and 0.5 / brighten or 2 * darken)                 im.putpixel((x, y), rgb)      pim.putdata(im.getdata())  def preview_image(pim, half_resolution_preview=False):      "Return a preview copy of image 'pim'."      width, height = pim.size     imp = pim.copy()     im = SimpleImage(list(pim.getdata()), pim.size)     step = half_resolution_preview and 2 or 1      for y in range(0, height):         for x in range(0, width):             rgb = im.getpixel((x, y))             value = get_value(rgb)             im.putpixel((x, y), value)             if half_resolution_preview:                 im.putpixel((x+1, y), value)      imp.putdata(im.getdata())     return imp  def convert_image(pim):      "Convert image 'pim' to an appropriate output representation."      width, height = pim.size     im = SimpleImage(list(pim.getdata()), pim.size)      for y in range(0, height):         c = get_colours(im, y)          for l in get_combinations(c, 4):             most = [value for f, value in l]             for x in range(0, width):                 rgb = im.getpixel((x, y))                 value = get_value(rgb, most, True)                 if value is None:                     break # try next combination             else:                 break # use this combination         else:             most = [value for f, value in c[:4]] # use the first four          for x in range(0, width):             rgb = im.getpixel((x, y))             value = get_value(rgb, most)             im.putpixel((x, y), value)              if x < width - 1:                 rgbn = im.getpixel((x+1, y))                 rgbn = (                     clip(rgbn[0] + (rgb[0] - value[0]) / 4.0),                     clip(rgbn[1] + (rgb[1] - value[1]) / 4.0),                     clip(rgbn[2] + (rgb[2] - value[2]) / 4.0)                     )                 im.putpixel((x+1, y), rgbn)              if y < height - 1:                 rgbn = im.getpixel((x, y+1))                 rgbn = (                     clip(rgbn[0] + (rgb[0] - value[0]) / 2.0),                     clip(rgbn[1] + (rgb[1] - value[1]) / 2.0),                     clip(rgbn[2] + (rgb[2] - value[2]) / 2.0)                     )                 im.putpixel((x, y+1), rgbn)      pim.putdata(im.getdata())  def get_float(options, flag):     try:         i = options.index(flag)         if i+1 < len(options) and options[i+1].isdigit():             return float(options[i+1])         else:             return 1.0     except ValueError:         return 0.0  class SimpleImage:      "An image behaving like PIL.Image."      def __init__(self, data, size):         self.data = data         self.width, self.height = self.size = size      def copy(self):         return SimpleImage(self.data[:], self.size)      def getpixel(self, xy):         x, y = xy         return self.data[y * self.width + x]      def putpixel(self, xy, value):         x, y = xy         self.data[y * self.width + x] = value      def getdata(self):         return self.data  # Main program.  if __name__ == "__main__":      # Test options.      if "--test" in sys.argv:         test()         sys.exit(0)     elif "--test-flat" in sys.argv:         test_flat((120, 40, 60))         sys.exit(0)     elif "--help" in sys.argv:         print >>sys.stderr, """\ Usage: %s <input filename> <output filename> [ <options> ]  Options are...  -s - Saturate the input image (can be followed by a float, default 1.0) -d - Desaturate the input image (can be followed by a float, default 1.0) -D - Darken the input image (can be followed by a float, default 1.0) -B - Brighten the input image (can be followed by a float, default 1.0)  -r - Rotate the input image clockwise -p - Generate a separate preview image -h - Make the preview image with half horizontal resolution (MODE 2) -v - Verify the output image (loaded if -n is given) -n - Generate no output image """ % split(sys.argv[0])[1]         sys.exit(1)      width = 320     height = 256      input_filename, output_filename = sys.argv[1:3]     basename, ext = splitext(output_filename)     preview_filename = "".join([basename + "_preview", ext])      options = sys.argv[3:]      # Preprocessing options that can be repeated for extra effect.      saturate = get_float(options, "-s")     desaturate = get_float(options, "-d")     darken = get_float(options, "-D")     brighten = get_float(options, "-B")      # General output options.      rotate = "-r" in options     preview = "-p" in options     half_resolution_preview = "-h" in options     verify = "-v" in options     no_normal_output = "-n" in options     make_image = not no_normal_output      # Load the input image if requested.      if make_image or preview:         exif = EXIF.process_file(open(input_filename))         im = PIL.Image.open(input_filename).convert("RGB")         im = rotate_and_scale(exif, im, width, height, rotate)          process_image(im, saturate, desaturate, darken, brighten)      # Generate a preview if requested.      if preview:         preview_image(im, half_resolution_preview).save(preview_filename)      # Generate an output image if requested.      if make_image:         convert_image(im)         im.save(output_filename)      # Verify the output image (which may be loaded) if requested.      if verify:         if no_normal_output:             im = PIL.Image.open(output_filename).convert("RGB")          result = count_colours(im, 4)         if result is not None:             y, colours = result             print "Image %s: row %d has the following colours: %s" % (output_filename, y, "; ".join([repr(c) for c in colours]))  # vim: tabstop=4 expandtab shiftwidth=4