## mark a section (Learn more)

#!/usr/bin/env python # -*- coding: utf-8 -*- ## changelog # Original version by Alex Ross # patch to validate html, fix hex parsing, and check PIL version by micheal -- 10/16/2007 """gen_imgmap.py Usage: gen_imgmap.py [-hi] image_file csv_file out_file Options: -i, --integer-colors Interpret color values as integers (hex is default). -h, --help Show this information. Arguments: image_file – png with one color per clickable area. The areas do not have to be contiguous, and may have holes. csv_file – csv mapping colors to tag attributes. The first row must be labels. The first column must be either a hexadecimal color, or an integer color (specify -i for integer colors). The remaining columns will be attached to the area tags as attribute values (theattribute key will be the column label). out_file – file name to which the generated image map will be written. Requirements: ImageMagick ≥ 6.3.0 Python ≥ 2.4 numpy ≥ 1.0 PIL ≥ 1.1.6\ """ import sys import time import os import getopt import csv import Image from numpy import * pil_version = Image.VERSION.split('.') pil_version =[int(e) for e in pil_version] if not (len(pil_version) == 3 and pil_version[0] >= 1 and pil_version[1] >= 1 and pil_version[2] >= 6): sys.stderr.write("your PIL version is too old %s minimum 1.1.6. needed\n" % Image.VERSION) sys.exit(1) sys.stdout = sys.stderr def save(a, name): Image.fromarray(bit2rgb(a)).save(name) def bit2rgb(b): """ Convert a bitmap to an RGB img. """ b = b[:,:,newaxis]*255 return concatenate((b, b, b), 2) def pixels_of(img): for y, x in combinations_of(range(img.shape[0]), range(img.shape[1])): yield y,x def combinations_of(A,B): for a in A: for b in B: yield a,b def dist(yx1, yx2): """ Euclidean distance from `yx1` to `yx2`.""" y1, x1 = yx1 y2, x2 = yx2 return sqrt(float((x2-x1)**2 + (y2-y1)**2)) def fill(img, yx, val): """ Fill `img` from `yx` with `val`. """ img = img.copy() edge = [yx] while edge: newedge = [] for (y,x) in edge: for (s, t) in ((y, x+1), (y, x-1), (y+1, x), (y-1, x)): try: p = img[s, t] except IndexError: pass else: if p != val: img[s, t] = val newedge.append((s, t)) edge = newedge return img def count_neighbors(yx, val, img): """ Return the number of pixels adjacent to (Y,X) with value `val`. """ c = 0 for t,s in neighbors_of(yx, corners=False): if (t < 0 or t >= img.shape[0]) or (s < 0 or s >= img.shape[1]): c+=1 continue if img[t,s] == val: c+=1 return c def neighbors_of(yx, corners=True): """ Yield the coordinates of pixels that are adjacent yx. If `corners` is False, don't yield the pixels that are adjacent to the corners of `yx`. """ y,x = yx if corners: pixels = [(y-1, x-1), (y-1, x), (y-1, x+1), ( y, x-1), ( y, x+1), (y+1, x-1), (y+1, x), (y+1, x+1)] else: pixels = [(y-1, x), ( y, x+1), (y+1, x), ( y, x-1),] for yx in pixels: yield yx def shapes_from(a): """ Yield the separate contiguous shapes of a. """ a = a.copy() while True: Y, X = a.nonzero() YX = zip(Y,X) y,x = min(YX) b = fill(a, (y,x), 0) s = logical_xor(b, a) yield s a = logical_xor(s,a) if not a.any(): break def poly_from(shp): """ Return the bounding polygon of a contiguous, solid shp. `shp` should be a binary numpy array. All parts of the shape should be connected to all other parts of the shape (contiguous). There should not be a hole in any part of the shape (solid). """ if not shp.any(): return [] Y, X = shp.nonzero() YX = zip(Y,X) y,x = min(YX) wfirst = (y, x) bfirst = (y-1, x) hist = [(wfirst, bfirst)] wcurs, bcurs = wfirst, bfirst # Traverse the shape in a clockwise manner, recording all # pixels as we go. while True: wn = [yx for yx in list(neighbors_of(wcurs))+[wcurs] if yx in YX] bn = [yx for yx in list(neighbors_of(bcurs)) + [bcurs] if not yx in YX] distances = [dist(w, b) for w, b in combinations_of(wn, bn)] temp = sorted(zip(distances, list(combinations_of(wn, bn)))) next_curs = [wb for d, wb in temp if d < 2.0 and wb not in hist] if all([w in [wh for wh, bh in hist if dist(b, bh) < 2] for w,b in next_curs]) or not next_curs: break for wb in next_curs: wcurs, bcurs = wb hist.append(wb) break poly = [w for w,b in hist] return poly def area_of(yx_1, yx_2, yx_3): """ Euclidean area of the triangle `yx_1`, `yx_2`, `yx_3`. """ y1, x1 = yx_1 y2, x2 = yx_2 y3, x3 = yx_3 return 1/2. * abs(-x2*y1 + x3*y1 + x1*y2 - x3*y2 - x1*y3 + x2*y3) def simplified(poly, min_area = 0.25): """ Return a simplified version of `poly` (`poly` is a list or array of points.). Uses a “triangle-based” simplification algorithm. For consecutive points along the edge of `poly`""" # simplify polygon i = 0 while True: if i+2 >= len(poly): break j,k,m = i, i+1, i+2 if area_of(poly[j], poly[k], poly[m]) < min_area: del poly[k] i = 0 continue else: i+=1 return poly def flip_lonely_pixels(box, min_neighbors=2): """ Fill in any lonely pixels (a pixel is lonely if it has less than 2 identical neighbors). """ print " Flipping lonely pixels…" box = box.copy() while True: boxl = box.copy() for Y, X in pixels_of(box): if count_neighbors((Y,X), box[Y,X], box) < min_neighbors: box[Y,X] = not box[Y,X] if (boxl == box).all(): break return box def fill_holes(shp): """ Return `shp` with all of its holes filled in.""" e = shp.copy() for yx in [(0,0), (-1,0), (0,-1), (-1,-1)]: d = fill(shp, yx, True) e = logical_or(e, d) if logical_not(e).any(): # the shape has a hole z_order = -1 else: z_order = 1 filled = logical_or(shp, logical_not(e)) save(filled, 'filled.png') return filled, z_order def areatags_from(mask_path=None, kwds={}): """ Return a list of html area tags for the mask at `mask_path`. Any kwds is a dictionary of attributes which are added to ALL of the returned tags. I.e. if you pass {href="http://google.com"}, all of the area tag will have “href="http://google.com"”. """ img = asarray(Image.open(mask_path)) img = img[:,:,0].astype(bool) # get the smallest box containing the shape in a. if not img.any(): return [] Y, X = img.nonzero() miny, maxy = min(Y), max(Y)+1 minx, maxx = min(X), max(X)+1 pad = 3 box = zeros((maxy-miny + 2*pad, maxx - minx + 2*pad), bool) box[pad:-pad, pad:-pad] = img[miny:maxy, minx:maxx] box = flip_lonely_pixels(box) if not box.any(): return [] # find polys print " Finding shapes…", shapes = [] for i, shp in enumerate(shapes_from(box)): print i+1, shp, z_order = fill_holes(shp) shapes.append((shp, z_order)) print print " Computing bounding polygons from shapes…" polys = [] for i, (shp, z_order) in enumerate(shapes): print " %i: z_order = %i" % (i, z_order) polys.append((poly_from(shp), z_order)) # simplify polys print " Simplifying polys…" # two passes of simplification. polys = [(simplified(poly, min_area=0.8), z_order) for poly, z_order in polys] polys = [(simplified(poly[len(poly)/2:] + poly[:len(poly)/2], min_area=0.8), z_order) for poly, z_order in polys] polys = [([(miny + y - pad + 2, minx + x - pad + 1) for y,x in poly], z_order) for poly, z_order in polys] # format html tags = [] print " Formatting area tag…" for poly, z_order in polys: tag = [] tag.append('<area shape="poly" ') for key in kwds.keys(): tag.append('%s="%s" ' % (key, kwds[key])) tag.append('coords="') tag.append(", ".join("%i,%i" % (x,y) for y,x in poly)) tag.append('"></area>\n') tags.append(("".join(tag), z_order)) return tags def rgbint(color): """ Converts an integer color code into an rgb tuple. """ color = int(color) - 2**25 return (color % 2**8, color % 2**16 / 2**8, color / 2**16) def rgbhex(color): """ Convert a hexadecimal color code into a rgb tuple. """ _2hex = lambda n: int(n,16) if len(color) in [4,7]: assert color[0] == "#" color = color[1:] if len(color) == 6: s = [color[i:i+2] for i in range(0,5,2)] else: s = [color[i] for i in range(0,3)] return tuple(map(_2hex, s)) def rgbtup(rgb): r,g,b = rgb return 2**25 + b * 2**16 + g * 2**8 + r def process_csv(csv_file): """ Generate a dictionary keyed by color from a csv. """ import csv as _csv f = open(csv_file) csv = _csv.reader(f) # the first line should be the labels attrs = {} labels = csv.next() labels = [lbl.lower() for lbl in labels] assert "color" == labels[0] for row in csv: if row: color = row[0] attrs[color] = [] for x, b in enumerate(labels[1:]): attrs[color].append((b, row[x+1].strip(" \""))) return attrs def generate_masks(base_img, attrs, integer_colors=False): masks = [] if not os.path.exists("./masks"): os.mkdir("masks") for color in attrs: if integer_colors: rgb = rgbint(color) else: rgb = rgbhex(color) label, value = attrs[color][0] new_mask = "masks/%s.png" % value if not os.path.exists(new_mask): ex = 'convert %s -transparent "rgb%r" '\ '-fx "a" +matte -negate %s' % (base_img, rgb, new_mask) print ex os.system(ex) masks.append([color, new_mask]) return masks def generate_area_tags(masks, attrs): area_tags = [] for color, m in masks: print "Processing area tag(s) for %s…" % m tags = areatags_from(m, dict(attrs[color])) if not tags: continue for tag, z_order in tags: if z_order > 0: area_tags.insert(0, tag) else: area_tags.append(tag) return area_tags def timeit(func): def wrapper(*args, **kwds): begin_time = time.time() result = func(*args, **kwds) end_time = time.time() print "Total time: %f minutes." % ((end_time - begin_time) / 60) return result return wrapper @timeit def main_(base_img, attrs_csv, output_file="out.html", integer_colors=False): attrs = process_csv(attrs_csv) masks = generate_masks(base_img, attrs, integer_colors) area_tags = generate_area_tags(masks, attrs) try: html = file(output_file, "w") html.write('<html><body>\n<map name="genmap">\n') for tag in area_tags: html.write(tag) html.write("</map>\n") html.write('<img src="%s" usemap="#genmap">\n' % base_img) html.write("</body></html>\n") finally: html.close() class Usage(Exception): def __init__(self, msg): self.msg = msg def main(argv=None): if argv is None: argv = sys.argv try: try: opts, args = getopt.getopt(argv[1:], "hi", ["help", "integer-colors"]) except getopt.error, msg: raise Usage(msg) # more code, unchanged integer_colors = False for opt in opts: if opt[0] in ["-h", "--help"]: print __doc__ return 2 elif opt[0] in ["-i", "--integer-colors"]: integer_colors = True if len(args) not in [2,3] : raise Usage("Invalid arguments.") return 2 else: base_img, attrs_csv, out_file = args main_(base_img, attrs_csv, out_file, integer_colors) except Usage, err: print >>sys.stderr, err.msg print >>sys.stderr, "for help use --help" return 2 if __name__ == "__main__": sys.exit(main())

This paste will be private.