import copy

import math

import cmath

import string

import random

import os

import sys

import re

import inkex

import simplestyle

import render_alphabetsoup_config

import bezmisc

import simplepath

import simpletransform

inkex.localize()

syntax = render_alphabetsoup_config.syntax

alphabet = render_alphabetsoup_config.alphabet

units = render_alphabetsoup_config.units

font = render_alphabetsoup_config.font

def loadPath( svgPath ):

extensionDir = os.path.normpath(

os.path.join( os.getcwd(), os.path.dirname(__file__) )

)

# __file__ is better then sys.argv[0] because this file may be a module

# for another one.

tree = inkex.etree.parse( extensionDir + "/" + svgPath )

root = tree.getroot()

pathElement = root.find('{http://www.w3.org/2000/svg}path')

if pathElement == None:

return None, 0, 0

d = pathElement.get("d")

width = float(root.get("width"))

height = float(root.get("height"))

return simplepath.parsePath(d), width, height # Currently we only support a single path

def combinePaths( pathA, pathB ):

if pathA == None and pathB == None:

return None

elif pathA == None:

return pathB

elif pathB == None:

return pathA

else:

return pathA + pathB

def reverseComponent(c):

nc = []

last = c.pop()

nc.append(['M', last[1][-2:]])

while c:

this = c.pop()

cmd = last[0]

if cmd == 'C':

nc.append([last[0], last[1][2:4] + last[1][:2] + this[1][-2:]])

else:

nc.append([last[0], this[1][-2:]])

last = this

return nc

def reversePath(sp):

rp = []

component = []

for p in sp:

cmd, params = p

if cmd == 'Z':

rp.extend(reverseComponent(component))

rp.append(['Z', []])

component = []

else:

component.append(p)

return rp

def flipLeftRight( sp, width ):

for cmd,params in sp:

defs = simplepath.pathdefs[cmd]

for i in range(defs[1]):

if defs[3][i] == 'x':

params[i] = width - params[i]

def flipTopBottom( sp, height ):

for cmd,params in sp:

defs = simplepath.pathdefs[cmd]

for i in range(defs[1]):

if defs[3][i] == 'y':

params[i] = height - params[i]

def solveQuadratic(a, b, c):

det = b*b - 4.0*a*c

if det >= 0: # real roots

sdet = math.sqrt(det)

else: # complex roots

sdet = cmath.sqrt(det)

return (-b + sdet) / (2*a), (-b - sdet) / (2*a)

def cbrt(x):

if x >= 0:

return x**(1.0/3.0)

else:

return -((-x)**(1.0/3.0))

def findRealRoots(a,b,c,d):

if a != 0:

a, b, c, d = 1, b/float(a), c/float(a), d/float(a) # Divide through by a

t = b / 3.0

p, q = c - 3 * t**2, d - c * t + 2 * t**3

u, v = solveQuadratic(1, q, -(p/3.0)**3)

if type(u) == type(0j): # Complex Cubic Root

r = math.sqrt(u.real**2 + u.imag**2)

w = math.atan2(u.imag, u.real)

y1 = 2 * cbrt(r) * math.cos(w / 3.0)

else: # Complex Real Root

y1 = cbrt(u) + cbrt(v)

y2, y3 = solveQuadratic(1, y1, p + y1**2)

if type(y2) == type(0j): # Are y2 and y3 complex?

return [y1 - t]

return [y1 - t, y2 - t, y3 - t]

elif b != 0:

det=c*c - 4.0*b*d

if det >= 0:

return [(-c + math.sqrt(det))/(2.0*b),(-c - math.sqrt(det))/(2.0*b)]

elif c != 0:

return [-d/c]

return []

def getPathBoundingBox( sp ):

box = None

last = None

lostctrl = None

for cmd,params in sp:

segmentBox = None

if cmd == 'M':

# A move cannot contribute to the bounding box

last = params[:]

lastctrl = params[:]

elif cmd == 'L':

if last:

segmentBox = (min(params[0], last[0]), max(params[0], last[0]), min(params[1], last[1]), max(params[1], last[1]))

last = params[:]

lastctrl = params[:]

elif cmd == 'C':

if last:

segmentBox = (min(params[4], last[0]), max(params[4], last[0]), min(params[5], last[1]), max(params[5], last[1]))

bx0, by0 = last[:]

bx1, by1, bx2, by2, bx3, by3 = params[:]

# Compute the x limits

a = (-bx0 + 3*bx1 - 3*bx2 + bx3)*3

b = (3*bx0 - 6*bx1 + 3*bx2)*2

c = (-3*bx0 + 3*bx1)

ts = findRealRoots(0, a, b, c)

for t in ts:

if t >= 0 and t <= 1:

x = (-bx0 + 3*bx1 - 3*bx2 + bx3)*(t**3) + \

(3*bx0 - 6*bx1 + 3*bx2)*(t**2) + \

(-3*bx0 + 3*bx1)*t + \

bx0

segmentBox = (min(segmentBox[0], x), max(segmentBox[1], x), segmentBox[2], segmentBox[3])

# Compute the y limits

a = (-by0 + 3*by1 - 3*by2 + by3)*3

b = (3*by0 - 6*by1 + 3*by2)*2

c = (-3*by0 + 3*by1)

ts = findRealRoots(0, a, b, c)

for t in ts:

if t >= 0 and t <= 1:

y = (-by0 + 3*by1 - 3*by2 + by3)*(t**3) + \

(3*by0 - 6*by1 + 3*by2)*(t**2) + \

(-3*by0 + 3*by1)*t + \

by0

segmentBox = (segmentBox[0], segmentBox[1], min(segmentBox[2], y), max(segmentBox[3], y))

last = params[-2:]

lastctrl = params[2:4]

elif cmd == 'Q':

# Provisional

if last:

segmentBox = (min(params[0], last[0]), max(params[0], last[0]), min(params[1], last[1]), max(params[1], last[1]))

last = params[-2:]

lastctrl = params[2:4]

elif cmd == 'A':

# Provisional

if last:

segmentBox = (min(params[0], last[0]), max(params[0], last[0]), min(params[1], last[1]), max(params[1], last[1]))

last = params[-2:]

lastctrl = params[2:4]

if segmentBox:

if box:

box = (min(segmentBox[0],box[0]), max(segmentBox[1],box[1]), min(segmentBox[2],box[2]), max(segmentBox[3],box[3]))

else:

box = segmentBox

return box

def mxfm( image, width, height, stack ): # returns possibly transformed image

tbimage = image

if ( stack[0] == "-" ): # top-bottom flip

flipTopBottom(tbimage, height)

tbimage = reversePath(tbimage)

stack.pop( 0 )

lrimage = tbimage

if ( stack[0] == "|" ): # left-right flip

flipLeftRight(tbimage, width)

lrimage = reversePath(lrimage)

stack.pop( 0 )

return lrimage

def comparerule( rule, nodes ): # compare node list to nodes in rule

for i in range( 0, len(nodes)): # range( a, b ) = (a, a+1, a+2 ... b-2, b-1)

if (nodes[i] == rule[i][0]):

pass

else: return 0

return 1

def findrule( state, nodes ): # find the rule which generated this subtree

ruleset = syntax[state][1]

nodelen = len(nodes)

for rule in ruleset:

rulelen = len(rule)

if ((rulelen == nodelen) and (comparerule( rule, nodes ))):

return rule

return

def generate( state ): # generate a random tree (in stack form)

stack = [ state ]

if ( len(syntax[state]) == 1 ): # if this is a stop symbol

return stack

else:

stack.append( "[" )

path = random.randint(0, (len(syntax[state][1])-1)) # choose randomly from next states

for symbol in syntax[state][1][path]: # recurse down each non-terminal

if ( symbol != 0 ): # 0 denotes end of list ###

substack = generate( symbol[0] ) # get subtree

for elt in substack:

stack.append( elt )

if (symbol[3]):stack.append( "-" ) # top-bottom flip

if (symbol[4]):stack.append( "|" ) # left-right flip

#else:

#inkex.debug("found end of list in generate( state =", state, ")") # this should be deprecated/never happen

stack.append("]")

return stack

def draw( stack ): # draw a character based on a tree stack

state = stack.pop(0)

#print state,

image, width, height = loadPath( font+syntax[state][0] ) # load the image

if (stack[0] != "["): # terminal stack element

if (len(syntax[state]) == 1): # this state is a terminal node

return image, width, height

else:

substack = generate( state ) # generate random substack

return draw( substack ) # draw random substack

else:

#inkex.debug("[")

stack.pop(0)

images = [] # list of daughter images

nodes = [] # list of daughter names

while (stack[0] != "]"): # for all nodes in stack

newstate = stack[0] # the new state

newimage, width, height = draw( stack ) # draw the daughter state

if (newimage):

tfimage = mxfm( newimage, width, height, stack ) # maybe transform daughter state

images.append( [tfimage, width, height] ) # list of daughter images

nodes.append( newstate ) # list of daughter nodes

else:

#inkex.debug(("recurse on",newstate,"failed")) # this should never happen

return None, 0, 0

rule = findrule( state, nodes ) # find the rule for this subtree

for i in range( 0, len(images)):

currimg, width, height = images[i]

if currimg:

#box = getPathBoundingBox(currimg)

dx = rule[i][1]*units

dy = rule[i][2]*units

#newbox = ((box[0]+dx),(box[1]+dy),(box[2]+dx),(box[3]+dy))

simplepath.translatePath(currimg, dx, dy)

image = combinePaths( image, currimg )

stack.pop( 0 )

return image, width, height

def draw_crop_scale( stack, zoom ): # draw, crop and scale letter image

image, width, height = draw(stack)

bbox = getPathBoundingBox(image)

simplepath.translatePath(image, -bbox[0], 0)

simplepath.scalePath(image, zoom/units, zoom/units)

return image, bbox[1] - bbox[0], bbox[3] - bbox[2]

def randomize_input_string(tokens, zoom ): # generate a glyph starting from each token in the input string

imagelist = []

for i in range(0,len(tokens)):

char = tokens[i]

#if ( re.match("[a-zA-Z0-9?]", char)):

if ( alphabet.has_key(char)):

if ((i > 0) and (char == tokens[i-1])): # if this letter matches previous letter

imagelist.append(imagelist[len(stack)-1])# make them the same image

else: # generate image for letter

stack = string.split( alphabet[char][random.randint(0,(len(alphabet[char])-1))] , "." )

#stack = string.split( alphabet[char][random.randint(0,(len(alphabet[char])-2))] , "." )

imagelist.append( draw_crop_scale( stack, zoom ))

elif( char == " "): # add a " " space to the image list

imagelist.append( " " )

else: # this character is not in config.alphabet, skip it

sys.stderr.write('bad character "%s"\n' % char)

return imagelist

def generate_random_string( tokens, zoom ): # generate a totally random glyph for each glyph in the input string

imagelist = []

for char in tokens:

if ( char == " "): # add a " " space to the image list

imagelist.append( " " )

else:

if ( re.match("[a-z]", char )): # generate lowercase letter

stack = generate("lc")

elif ( re.match("[A-Z]", char )): # generate uppercase letter

stack = generate("UC")

else: # this character is not in config.alphabet, skip it

sys.stderr.write('bad character"%s"\n' % char)

stack = generate("start")

imagelist.append( draw_crop_scale( stack, zoom ))

return imagelist

def optikern( image, width, zoom ): # optical kerning algorithm

left = []

right = []

resolution = 8

for i in range( 0, 18 * resolution ):

y = 1.0/resolution * (i + 0.5) * zoom

xmin = None

xmax = None

for cmd,params in image:

segmentBox = None

if cmd == 'M':

# A move cannot contribute to the bounding box

last = params[:]

lastctrl = params[:]

elif cmd == 'L':

if (y >= last[1] and y <= params[1]) or (y >= params[1] and y <= last[1]):

if params[0] == last[0]:

x = params[0]

else:

a = (params[1] - last[1]) / (params[0] - last[0])

b = last[1] - a * last[0]

if a != 0:

x = (y - b) / a

else: x = None

if x:

if xmin == None or x < xmin: xmin = x

if xmax == None or x > xmax: xmax = x

last = params[:]

lastctrl = params[:]

elif cmd == 'C':

if last:

bx0, by0 = last[:]

bx1, by1, bx2, by2, bx3, by3 = params[:]

d = by0 - y

c = -3*by0 + 3*by1

b = 3*by0 - 6*by1 + 3*by2

a = -by0 + 3*by1 - 3*by2 + by3

ts = findRealRoots(a, b, c, d)

for t in ts:

if t >= 0 and t <= 1:

x = (-bx0 + 3*bx1 - 3*bx2 + bx3)*(t**3) + \

(3*bx0 - 6*bx1 + 3*bx2)*(t**2) + \

(-3*bx0 + 3*bx1)*t + \

bx0

if xmin == None or x < xmin: xmin = x

if xmax == None or x > xmax: xmax = x

last = params[-2:]

lastctrl = params[2:4]

elif cmd == 'Q':

# Quadratic beziers are ignored

last = params[-2:]

lastctrl = params[2:4]

elif cmd == 'A':

# Arcs are ignored

last = params[-2:]

lastctrl = params[2:4]

if xmin != None and xmax != None:

left.append( xmin ) # distance from left edge of region to left edge of bbox

right.append( width - xmax ) # distance from right edge of region to right edge of bbox

else:

left.append( width )

right.append( width )

return (left, right)

def layoutstring( imagelist, zoom ): # layout string of letter-images using optical kerning

kernlist = []

length = zoom

for entry in imagelist:

if (entry == " "): # leaving room for " " space characters

length = length + (zoom * render_alphabetsoup_config.space)

else:

image, width, height = entry

length = length + width + zoom # add letter length to overall length

kernlist.append( optikern(image, width, zoom) ) # append kerning data for this image

workspace = None

position = zoom

for i in range(0, len(kernlist)):

while(imagelist[i] == " "):

position = position + (zoom * render_alphabetsoup_config.space )

imagelist.pop(i)

image, width, height = imagelist[i]

# set the kerning

if i == 0: kern = 0 # for first image, kerning is zero

else:

kerncompare = [] # kerning comparison array

for j in range( 0, len(kernlist[i][0])):

kerncompare.append( kernlist[i][0][j]+kernlist[i-1][1][j] )

kern = min( kerncompare )

position = position - kern # move position back by kern amount

thisimage = copy.deepcopy(image)

simplepath.translatePath(thisimage, position, 0)

workspace = combinePaths(workspace, thisimage)

position = position + width + zoom # advance position by letter width

return workspace

def tokenize(text):

"""Tokenize the string, looking for LaTeX style, multi-character tokens in the string, like \\yogh."""

tokens = []

i = 0

while i < len(text):

c = text[i]

i += 1

if c == '\\': # found the beginning of an escape

t = ''

while i < len(text): # gobble up content of the escape

c = text[i]

if c == '\\': # found another escape, stop this one

break

i += 1

if c == ' ': # a space terminates this escape

break

t += c # stick this character onto the token

if t:

tokens.append(t)

else:

tokens.append(c)

return tokens

class AlphabetSoup(inkex.Effect):

def __init__(self):

inkex.Effect.__init__(self)

self.OptionParser.add_option("-t", "--text",

action="store", type="string",

dest="text", default="Inkscape",

help="The text for alphabet soup")

self.OptionParser.add_option("-z", "--zoom",

action="store", type="float",

dest="zoom", default="8.0",

help="The zoom on the output graphics")

self.OptionParser.add_option("-r", "--randomize",

action="store", type="inkbool",

dest="randomize", default=False,

help="Generate random (unreadable) text")

def effect(self):

zoom = self.unittouu( str(self.options.zoom) + 'px')

if self.options.randomize:

imagelist = generate_random_string(self.options.text, zoom)

else:

tokens = tokenize(self.options.text)

imagelist = randomize_input_string(tokens, zoom)

image = layoutstring( imagelist, zoom )

if image:

s = { 'stroke': 'none', 'fill': '#000000' }

new = inkex.etree.Element(inkex.addNS('path','svg'))

new.set('style', simplestyle.formatStyle(s))

new.set('d', simplepath.formatPath(image))

self.current_layer.append(new)

# compensate preserved transforms of parent layer

if self.current_layer.getparent() is not None:

mat = simpletransform.composeParents(self.current_layer, [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]])

simpletransform.applyTransformToNode(simpletransform.invertTransform(mat), new)

if __name__ == '__main__':

e = AlphabetSoup()

e.affect()