#!/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 import itertools import math 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 distance(rgb1, rgb2):     r1, g1, b1 = rgb1     r2, g2, b2 = rgb2     return math.sqrt(pow(r1 - r2, 2) + pow(g1 - g2, 2) + pow(b1 - b2, 2))  def restore(srgb):     return tuple(map(lambda x: int(x * 255.0), srgb))  def scale(rgb):     return tuple(map(lambda x: x / 255.0, rgb))  def invert(srgb):     return tuple(map(lambda x: 1.0 - x, srgb))  # 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.      rgb = scale(rgb)     rgbi = invert(rgb)     pairs = zip(rgbi, rgb)      # 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 in corners:         rs, gs, bs = scale(corner)          # 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)))  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 map(complements, [(0, 0, 0), (255, 0, 0), (0, 255, 0), (0, 0, 255)]):         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 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):     return tuple([saturate_value(x, exp) for x in rgb])  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):     return tuple([amplify_value(x, exp) for x in rgb])  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      c = [(n/width, value) for value, n in c.items()]     c.sort(reverse=True)     return c  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_slice(im, size, r):     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)  def test_flat_slice(im, size, rgb):     for y in range(0, size):         for x in range(0, size):             im.putpixel((x, y), get_value(rgb))  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(im.getdata()[y * width:(y+1) * width])         if len(l) > colours:             return (y, l)     return None  def process_image(im, saturate, desaturate, darken, brighten):      """     Process image 'im' using the given options: 'saturate', 'desaturate',     'darken', 'brighten'.     """      width, height = im.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)  def preview_image(im, half_resolution_preview=False):      "Return a preview copy of image 'im'."      width, height = im.size      imp = im.copy()     step = half_resolution_preview and 2 or 1      for y in range(0, height):         for x in range(0, width, step):             rgb = imp.getpixel((x, y))             value = get_value(rgb)             imp.putpixel((x, y), value)             if half_resolution_preview:                 imp.putpixel((x+1, y), value)      return imp  def convert_image(im):      "Convert image 'im' to an appropriate output representation."      width, height = im.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 = tuple(map(lambda i: clip(i[0] + (i[1] - i[2]) / 4.0), zip(rgbn, rgb, value)))                 im.putpixel((x+1, y), rgbn)              if y < height - 1:                 rgbn = im.getpixel((x, y+1))                 rgbn = tuple(map(lambda i: clip(i[0] + (i[1] - i[2]) / 2.0), zip(rgbn, rgb, value)))                 im.putpixel((x, y+1), rgbn)  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  # Test program.  if __name__ == "__main__":     data = [(0, 0, 0)] * 1024     size = (32, 32)      im = SimpleImage(data, size)      process_image(im, 1.0, 0.0, 1.0, 0.0)     imp = preview_image(im, False)     convert_image(im)      test_im = SimpleImage(data, size)     test_slice(test_im, 32, 0)      test_flat_im = SimpleImage(data, size)     test_flat_slice(test_flat_im, 32, (200, 100, 50))  # vim: tabstop=4 expandtab shiftwidth=4