mirror
/
evil-mad-EggBot
kopia lustrzana https://github.com/evil-mad/EggBot
1
0
Forkuj 0
Kod Zgłoszenia Packages Projekty Wydania Wiki Aktywność
evil-mad-EggBot/inkscape_deprecated/eggbot_spiraltext.py

450 wiersze
17 KiB
Python
Executable File
Czysty Bezpośredni odnośnik Wina Historia

# coding=utf-8
# eggbot_spiraltext.py
#
# Render a passage of text using the Hershey fonts, then stretch it so
# that it will wrap multiple times around an egg, and finally tilt it
# so that it will spiral as it wraps.
#
# + The wrapping need not be an integral multiple of 3200 pixels
#
# + The text tilt is computed to use the full height of the document
#
# + The text can be run starting from the top of the page or from
# the bottom (and upside down). This latter orientation is useful
# when placing the bottom of the egg (fat end) in the egg motor's
# egg cup
#
# + The text can be stretched more horizontally than vertically to
# compensate for some of the geometry issues associated with drawing
# on eggs.
#
# + The text can contain markup (see below)
#
# This extension also permits some basic markup of the passage using
# XHTML-like conventions and a limited set of tags:
#
# <sans> - A simple typeface which lacks serifs
# <times> - "Times" like typeface (a face with serifs)
# <script> - A flowing script font
# <b> - Boldface
# <em> - Emphasis
# <i> - Italics
# <face> - Where "face" is any of the typeface names from hersheydata.py
#
# The markup processing is not XML-conformant: we don't expect a well-formed
# document as input. No single root element is required. And, at the end of
# the text, we do not require closure of any open tags. We do however enforce
# proper nesting of tags: an element cannot be closed unless its children have
# already been closed. This is more to prevent ambiguity about whether or
# not closing a typeface also closes any markup operating under it (e.g.,
# does <sans><b>text</sans> mean that the <b> was implicitly ended when
# </sans> was encountered?
#
# This extension requires the hersheydata.py file which is part of the
# Hershey Text rendering extension written by Windell H. Oskay of
# www.evilmadscientist.com. Information on that extension may be found at
#
# http://www.evilmadscientist.com/go/hershey
#
# Copyright 2011, Daniel C. Newman,
#
# Significant portions of this code were written by Windell H. Oskay and are
# Copyright 2011, Windell H. Oskay, www.evilmadscientist.com
#
# Small portions of this code were changed by Sheldon B. Michaels 2016,
# in order to accommodate the addition of several new faces
# (the "EMS" series) to hersheydata.py. Additionally, changes were made
# to the default text rendering style.
#
# 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 2 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, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
import math
import hersheydata # data file w/ Hershey font data
import inkex
import simplestyle
# Mapping table to map the names used here to the corresponding
# names used in hersheydata.py. This helps prevent end users from
# being impacted by a name change in hersheydata.py. This can also
# be used to deal with a face being removed from hersheydata.py
map_our_names_to_hersheydata = {
'astrology': 'astrology',
'cursive': 'cursive',
'cyrillic': 'cyrillic',
'futural': 'futural',
'futuram': 'futuram',
'gothiceng': 'gothiceng',
'gothicger': 'gothicger',
'gothicita': 'gothicita',
'greek': 'greek',
'japanese': 'japanese',
'markers': 'markers',
'mathlow': 'mathlow',
'mathupp': 'mathupp',
'meteorology': 'meteorology',
'music': 'music',
'scriptc': 'scriptc',
'scripts': 'scripts',
'symbolic': 'symbolic',
'timesg': 'timesg',
'timesi': 'timesi',
'timesib': 'timesib',
'timesr': 'timesr',
'timesrb': 'timesrb'}
# The following two routines are lifted with impunity from Windell H. Oskay's
# hershey.py Hershey Text extension for Inkscape. They are,
# Copyright 2011, Windell H. Oskay, www.evilmadscientist.com
def draw_svg_text(char, face, offset, vertoffset, parent):
style = {'stroke': '#000000', 'fill': 'none', 'stroke-linecap': 'round', 'stroke-linejoin': 'round'}
# Apply rounding to ends so that user gets best impression of final printed text appearance.
path_string = face[char]
split_string = path_string.split()
midpoint = offset - float(split_string[0])
i = path_string.find("M")
if i >= 0:
path_string = path_string[i:] # portion after first move
trans = 'translate(' + str(midpoint) + ',' + str(vertoffset) + ')'
text_attribs = {'style': simplestyle.formatStyle(style), 'd': path_string, 'transform': trans}
inkex.etree.SubElement(parent, inkex.addNS('path', 'svg'), text_attribs)
return midpoint + float(split_string[1]) # new offset value
def renderText(parent, markup):
# Embed text in group to make manipulation easier:
g_attribs = {inkex.addNS('label', 'inkscape'): 'Hershey Text'}
g = inkex.etree.SubElement(parent, 'g', g_attribs)
w = 0 # Initial spacing offset
spacing = 3 # spacing between letters
for face, text in markup:
if face in map_our_names_to_hersheydata:
face = map_our_names_to_hersheydata[face]
font = getattr(hersheydata, face)
letter_vals = (ord(q) - 32 for q in text)
for q in letter_vals:
if (q < 0) or (q > 95):
w += 2 * spacing
else:
w = draw_svg_text(q, font, w, 0, g)
return g, w
# The generic font "families" we support
generic_families = ('sans', 'script', 'times')
# Convert "family-name" + "bold-0-or-1" + "italic-0-or-1" to a typeface name
family_to_font = {'sans00': 'futural',
'sans10': 'futuram',
'sans01': 'futural',
'sans11': 'futuram',
'times00': 'timesr',
'times10': 'timesrb',
'times01': 'timesi',
'times11': 'timesib',
'script00': 'scripts',
'script10': 'scriptc',
'script01': 'scripts',
'script11': 'scriptc'}
emphasis_is_bold = {'sans': True, 'times': False, 'script': True}
# Short list of entity references
entity_refs = {'&lt;': '<', '&gt;': '>', '&amp;': '&', '&quot;': '"', '&apos': "'", '&nbsp;': ' '}
def normalize_possible_EMS_string(tag):
# Normalizes tag name by removing any spaces
s_normalized_tag = tag.replace(' ', '')
return s_normalized_tag
def is_valid_EMS_name(tag):
# returns true if family is one of the "EMS" faces in hersheydata.py
# else false
s_normalized_tag = normalize_possible_EMS_string(tag)
b_ret_val = False # default assumption
try:
fontgroup = hersheydata.group_allfonts
except:
# User probably has old version of hersheydata.py
pass
else:
for f in fontgroup:
if f[0] == s_normalized_tag:
b_ret_val = True
break
return b_ret_val
def pickFace(family, bold=False, italics=False, emphasis=False):
if not family:
return None
b = '0'
i = '0'
# If using a generic font family, then determine how to map <em>
if emphasis and (family in generic_families):
if emphasis_is_bold[family]:
bold = True
else:
italics = True
if bold:
b = '1'
if italics:
i = '1'
if (family + b + i) in family_to_font:
return family_to_font[family + b + i]
return family
def processMarkup(text, family='sans'):
if text is None:
text = ''
# By default we assume 'sans'
if not family:
family = 'sans'
default_family = family
face_stack = [family]
# Bold and italics off
bold = False
emphasis = False
italic = False
# Set the current typeface
face = pickFace(family, bold, italic, emphasis)
# And the result of markup processing so far
markup = []
# We keep a queue / list of the open markup tags
# When a tag is closed, we expect it to be well nested. To enforce
# that expectation, we make sure that we are closing the most recently
# opened tag. While this may seem overly picky, it's easier than worrying
# issues like, "Does closing a typeface imply implicitly closing <b> or <it>?"
# And, "Does starting a new typeface imply closing the prior selected face?"
tags_used = []
outstr = ''
i = 0
while i < len(text):
# An entity reference?
if text[i] == '&':
j = text.find(';', i + 1)
if j != -1:
eref = text[i:j + 1]
if eref in entity_refs:
outstr += entity_refs[eref]
i = j + 1
else:
inkex.errormsg('Ignoring the unrecognized entity reference {0}.'.format(eref))
outstr += eref
i = j + 1
else:
inkex.errormsg('An unescaped "&" was encountered; please replace it with "&amp;".')
break
# Start of a tag (start-tag or end-tag? self-closing tags not supported)
elif text[i] == '<':
j = text.find('>', i + 1)
if (j != -1) and (j > (i + 1)):
tag = text[i + 1:j]
i = j + 1
if tag[0] == '/':
# This is an end-tag (closing tag)
close = True
tag = tag[1:]
# Ensure that the most recently opened tag is that which we are closing here
# We'll pop the most recent tag from the queue of opened tags and see if
# it matches
if len(tags_used) == 0:
inkex.errormsg('The ending tag </{0}> appeared before any start tag <{1}>.'.format(tag, tag))
break
else:
old_tag = tags_used.pop()
if old_tag != tag:
inkex.errormsg('The ending tag </{0}> does not appear to be correctly nested; it tried to close the tag <{1}>. Sorry, but all tags must be properly nested.'.format(tag, old_tag))
break
else:
# Start tag (opening tag)
# Push it onto the queue of opened tags
close = False
tags_used.append(tag)
if (tag == 'b') or (tag == 'strong'):
if bold == close:
# Push prior string and font onto the stack
if outstr != '':
markup.append([face, outstr])
outstr = ''
# Start a new boldface string
bold = not bold
face = pickFace(family, bold, italic, emphasis)
elif tag == 'i':
if italic == close:
# Push the prior string and font unto the stack
if outstr != '':
markup.append([face, outstr])
outstr = ''
# Start a new italicized string
italic = not italic
face = pickFace(family, bold, italic, emphasis)
elif tag == 'em':
if emphasis == close:
# Push the prior string and font unto the stack
if outstr != '':
markup.append([face, outstr])
outstr = ''
# Start a new italicized string
emphasis = not emphasis
face = pickFace(family, bold, italic, emphasis)
else:
b_valid_ems_name = is_valid_EMS_name(tag)
if b_valid_ems_name:
tag = normalize_possible_EMS_string(tag)
if all([tag not in generic_families,
tag not in map_our_names_to_hersheydata,
not b_valid_ems_name]):
if close:
inkex.errormsg('Ignoring the unrecognized tag </{0}>.'.format(tag))
else:
inkex.errormsg('Ignoring the unrecognized tag <{0}>.'.format(tag))
else:
if outstr != '':
markup.append([face, outstr])
outstr = ''
if not close:
family = tag
face_stack.append(family)
else:
if face_stack:
# Current face on the stack should be the one we just closed
face_stack.pop()
if face_stack:
family = face_stack[len(face_stack) - 1]
else:
family = default_family
else:
family = default_family
face = pickFace(family, bold, italic, emphasis)
else:
inkex.errormsg('Ignoring unescaped "<"')
outstr += '<'
i += 1
else:
outstr += text[i]
i += 1
# We won't worry about unclosed tags -- we're not trying to be an XML or XHTML parser
# See if there was a hard error
if i < len(text):
return None
# And push the last text into the list of processed markup
if outstr != '':
markup.append([face, outstr])
return markup
class SpiralText(inkex.Effect):
def __init__(self):
inkex.Effect.__init__(self)
self.OptionParser.add_option("--tab", # NOTE: value is not used.
action="store", type="string",
dest="tab", default="splash",
help="The active tab when Apply was pressed")
self.OptionParser.add_option("--text",
action="store", type="string",
dest="text", default="Hershey Text for Inkscape",
help="The input text to render")
self.OptionParser.add_option("--fontfamily",
action="store", type="string",
dest="fontfamily", default="sans",
help="The selected font face when Apply was pressed")
self.OptionParser.add_option("--wrap",
action="store", type="float",
dest="wrap", default=10.0,
help="Number of times to wrap the text around the egg")
self.OptionParser.add_option("--flip",
action="store", type="inkbool",
dest="flip", default=False,
help="Flip the text for plotting with the egg's bottom at the egg motor")
self.OptionParser.add_option("--stretch",
action="store", type="inkbool",
dest="stretch", default=True,
help="Stretch the text horizontally to account for egg distortions")
def effect(self):
markup = processMarkup(self.options.text, self.options.fontfamily)
g, w = renderText(self.current_layer, markup)
# Now to wrap the text N times around the egg, we need to scale it to have
# length 3200 * N. It's current width is w so the scale factor is (3200 * N) / w.
scale_x = float(3200 * self.options.wrap) / float(w)
scale_y = scale_x
if self.options.stretch:
scale_y = scale_y * 2.0 / 3.0
# In planning the scaling, we'd like to know the height of our line of text.
# Rather than computing its bounding box, we'll just use the height of the
# parens from the Simplex Roman font. And, we could compute that but we'll
# just use our prior knowledge of it being 32.
h = 32.0
# And the angular tilt will be arcsine( height / (3200 * fWrap) )
svg = self.document.getroot()
height = float(self.unittouu(svg.attrib['height'])) - h * scale_y
angle = (180.0 / math.pi) * math.asin(height / float(3200 * self.options.wrap))
if self.options.flip:
angle += 180.0
t = 'translate({0:f},{1:f}) rotate({2:f},{3:f},0) scale({4:f},{5:f})'.format(-w * scale_x, h * scale_y, angle,
w * scale_x, scale_x, scale_y)
else:
t = 'translate(0,{0:f}) rotate({1:f},0,0) scale({2:f},{3:f})'.format(h, angle, scale_x, scale_y)
g.set('transform', t)
if __name__ == '__main__':
e = SpiralText()
e.affect()
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik