#!python

"""
This program converts SVG files to raw Unicode strings and back again
It was written for a twitter image encoding competition on Stack Overflow
http://stackoverflow.com/questions/891643/twitter-image-encoding-challenge

Copyright: SpliFF
License: Public Domain

Requirements:
Python 2.5+
lxml library
bitfields module (http://www.warriorhut.org/graphics/svg_to_unicode/bitfields.py)
python built for wide unicode characters (UCS2)

Usage:
python2.5 svg_to_unicode-0.2.py [-v] encode -i in.svg -o unicode.txt
python2.5 svg_to_unicode-0.2.py [-v] decode -i unicode.txt -o out.svg

-v: verbose
-i: input file (default stdin)
-o: output file (default stdout)
action: encode / decode (default encode)

How it works:
When tracing bitmaps most libraries will give only 4 types of information we really need to send:
1.) width and height of document (possibly optional since this is vector graphics)
2.) fill color of each path
3.) commands on each path (basically handle types like corner, curve)
4.) point values (where to place the commands)

So this script first dives in with an XML parser and grabs (1). It then walks each path node in the XML and
grabs (2), (3) and (4). To better compact the data it then compresses the range of (4) from a float down to
a maximum integer value of 127 so it can pack two points into each unicode character. Finally the script
increases packed values by about 5000 to avoid a conflict with the values reserved for colors and commands.

Colors are compressed to a range no greater than 4096 by removing 4 bits of each color channel (RGB).

Known Issues:
- Conflict with unicode surrogates

Changelog:
0.2
- Switch to XML parsing (handles more SVG files)
- Allow input/output from stdin/stdout
- Stores 2 path nodes per unicode character
- Supports command-line options
- Debug sent to stderr
- Output to stdout

"""

import re
import sys
from bitfields import *
from lxml import etree as et
from math import sqrt

# Default configuration. Can be set from command-line.
config = {
    'i': '-', # input file path or '-' (stdin)
    'o': '-', # output file path or '-' (stdin)
    'v': True # verbose
}

# Debug writer
def debug(*msg):
    """Writes debugging to stderr in verbose mode"""
    if config['v']: sys.stderr.write(' '.join([str(m) for m in msg]) + '\r\n')
    
# Unicode Character Sets (stored by value)
UC_SAFE = frozenset(range(0,0xD800)) # no reserved characters
UC_NONCHAR = frozenset([eval('0x'+str(x)+'FFFE') for x in range(1,11)] + range(0xFDD0,0xFDEF))
UC_SURROGATE = frozenset(range(0xD800,0xDFFF))
UC_ALL = frozenset(range(0,0x10FFFF))

UC_ALLOWED = UC_ALL - UC_NONCHAR - UC_SURROGATE
UC_MAX = len(UC_ALLOWED)
debug('Max Word Value:', UC_MAX)


OUT_HEADER = """<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg width="%dpt" height="%dpt" viewBox="0 0 %d %d" version="1.1" xmlns="http://www.w3.org/2000/svg">
"""
OUT_PATH = """<path fill="#%s" d=" M %s Z" />"""
OUT_BKG = """<path fill="#fff" d=" M 0.00 0.00 L %d.00 0.00 L %d.00 %d.00 L 0.00 %d.00 L 0.00 0.00 Z" />"""
OUT_FOOTER = """</svg>"""

RE_WIDTH_HEIGHT = re.compile(r'<svg width="([0-9]+)pt" height="([0-9]+)pt"')
RE_STYLE_FILL_COLOR = re.compile(r'fill:(#[0-9A-Fa-f]+)')
RE_POINTS = re.compile(r' d="([^"]+)"')

SVG_COMMANDS = ['M','Z','C','L','H','V','Q','S','A'] # these tokens designate commands in an SVG path
SVG_NUM_COMMANDS = len(SVG_COMMANDS)

SVG_COLOR_MAX = 0xFFF # 4095, reserved range for fill color
SVG_COMMAND_MAX = SVG_COLOR_MAX + SVG_NUM_COMMANDS # reserved range for commands
SVG_POINT_MIN = SVG_COMMAND_MAX + 1 # start of unicode value range
SVG_POINT_MAX = 0xD700 # 55040, max unicode value
SVG_POINT_RANGE = set(range(SVG_POINT_MIN, UC_MAX)) # values reserved for points

def to8bit(value):
    """Convert a value to 8bit int"""
    if value < 0: raise ValueError("Negative value passed to float")
    return min(int(abs(float(value))),108)


# ENCODER

def encode(svg_data):
    """Takes SVG and encodes to compact unicode string"""

    debug('ORIGINAL CHARACTERS:', len(svg_data))
    
    # parse XML tree
    svg = et.XML(svg_data)
    svg_nsurl = svg.nsmap[svg.prefix] # namespace url for tag match

    # get width and height from header  
    left, top, width, height = svg.get('viewBox').split(' ')
    output = [unichr(pack16(to8bit(width),to8bit(height)))]
    count = len(output) # count unpacked tokens
    for node in svg.findall(u'{%s}path'%svg_nsurl):
        debug(node.tag)

        # skip background
        path = node.get('d').upper().replace(',',' ')
        debug(path)
        if path.find(' L 0.00 ') != -1:
            debug('Removing background')
            continue
        
        # fill color
        color = ''
        if node.attrib.has_key('fill'):
            color = node.attrib['fill'] 
        elif node.attrib.has_key('style'):
            fill_matches = RE_STYLE_FILL_COLOR.findall(node.get('style'))
            debug(fill_matches)
            if fill_matches: color = fill_matches[0]

        # no color name support
        if not color or color[0] != '#':
            debug("Can't get color")
            color="#FFF"
        else:
            # reduce color depth to 4 bits per channel and convert
            # the maximum color range is 4095 (0xFFF) 
            short_color = '0x'+color[1]+color[3]+color[5] #r g b
            output.append(unichr(eval(short_color)))
            count += 1
        
        # path
        path_pieces = path.split(' ')
        last_value = None
        for i in range(len(path_pieces)):
            token = path_pieces[i].strip()
            if token in ('M','Z',''): continue # ignore start and end path
            count += 1
            if token in SVG_COMMANDS: # commands
                debug('Command: ',token)
                value = SVG_COMMANDS.index(token) # move to reserved range
            else: # points
                #round the float and push value out of commands range
                debug('Point: ',token)
                value = SVG_NUM_COMMANDS + to8bit(token) + 1

            #pack commands and points above the reserved range for colors
            if last_value != None:
                #pack two values
                output.append(unichr(SVG_COLOR_MAX + pack16(last_value,value)))
                last_value = None
            elif i == len(path_pieces)-1:
                #no further values coming, pad final value with 'Z' placeholder
                output.append(unichr(SVG_COLOR_MAX + pack16(value,SVG_COMMANDS.index('Z'))))
            else:
                last_value = value # pack this with the next value

    debug('CHARACTERS UNPACKED:', count)
    debug('CHARACTERS PACKED:', len(output))
    
    return u''.join(output)


# DECODER

def decode(data):
    """Takes compact unicode string and encodes to SVG"""
    # header
    width, height = unpack16(ord(data[0]))
    output = [OUT_HEADER % (width,height,width+10,height+10)]
    output.append(OUT_BKG % (width,width,height,height))
    debug("Image Width: %d Height: %d" % (width,height))

    color = None
    points = []

    # paths
    for point in data[1:]:
        value = ord(point)
        if value <= SVG_COLOR_MAX: # fill and line start
            if color: # second or subsequent path
                output.append(OUT_PATH % (color, ' '.join(points)))
                points = []
            color = str(hex(value))[2:]
            debug('------')
            debug('color:', color)

        else: # packed commands and points
            unpacked_values = unpack16(value - SVG_COLOR_MAX)
            for v in unpacked_values:
                if v < SVG_NUM_COMMANDS:
                    command = SVG_COMMANDS[v]
                    if command != 'Z': 
                        debug('command:', command)
                        points.append(command)
                else:
                    point = '%d.00' % (v - SVG_NUM_COMMANDS)
                    debug('point:', point)
                    points.append(point)

    # add last path
    output.append(OUT_PATH % (color, ' '.join(points)))
    # close SVG element
    output.append(OUT_FOOTER)
    return u'\n'.join(output)


# MAIN LOOP

if __name__ == '__main__':
    # parse command-line 
    config_key = 'i'
    action = 'encode' # or decode
    for arg in sys.argv[1:]:
        if arg in ('encode','decode'):
            action = arg
        elif len(arg) > 1 and arg[0] == '-':
            for key in arg[1:]:
                if config.has_key(key):
                    if type(config[key]) == str:
                        config_key = key # string argument
                    else:
                        config[key] = True # boolean arg
                else:
                    raise "Unknown configuration option '%s'" % key
        else:
            config[config_key] = arg
                    
    if config['i'] == '-':
        input_file = sys.stdin
    else:
        input_file = file(config['i'])

    if config['o'] == '-':
        output_file = sys.stdout
    else:
        output_file = file(config['o'],'w+')
        
    #encode to unicode
    if action == 'encode':
        svg_data = input_file.read()
        encoded_data = encode(svg_data)
        debug('=========== UNICODE ===============')
        debug(repr(encoded_data))
        output_file.write(encoded_data.encode('utf-16'))
    
    #decode to svg
    if action == 'decode':
        raw_data = input_file.read()
        repr(raw_data)
        encoded_data = unicode( raw_data, "utf-16", 'ignore' )
        new_svg_data = decode(encoded_data)
        debug('============= SVG =================')
        debug(new_svg_data)
        output_file.write(new_svg_data)