# ##### BEGIN GPL LICENSE BLOCK #####
#
# 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####
# <pep8 compliant>
"""Reading various vector file formats.
Functions for classifying files, tokenizing, and parsing them.
The ultimate goal is to parse a file into an instance of the class Art,
which has the line segments, bezier segments, arc segments,
and faces specified in a vector file.
"""
__author__ = "howard.trickey@gmail.com"
import re
from . import geom
from . import pdf
from . import svg
WARN = True # print Warnings about strange things?
# Token types
TNAME = 0
TLITNAME = 1
TSTRING = 2
TNUM = 3
def ClassifyFile(filename):
"""Classify file into one of known vector types.
Args:
filename: string, the name of the file to classify
Returns:
(string, string), giving maintype and version.
If there's an error, returns ("error", reason-string)
"""
if filename.endswith(".svg"):
return ("svg", "")
try:
f = open(filename, "rb")
start = f.read(25)
except IOError:
return ("error", "file open error")
# Encapsulated Postscript files start like
# %!PS-Adobe-X.X EPSF-Y.Y
# where the first number is the version of PostScript Document Structuring
# Convention, and the second number is the level of EPSF.
# Adobe Illustrator files, version 8 and earlier, have
# %%+ procset Adobe_Illustrator...
# sometime before %%EndProlog
if start.startswith(b"%!PS-Adobe-"):
ans = ("ps", "")
if start[14:20] == b" EPSF-":
ans = ("eps", start[20:23].decode())
if start[14:19] == b" PDF-":
ans = ("pdf", start[19:22].decode())
if ans[0] != "pdf" and _FindAdobeIllustrator(f):
ans = ("ai", "eps")
# PDF files start with %PDF
# Adobe Illustrator files, version 9 and later, have
# %%+ procset Adobe_Illustrator...
# sometime before %%EndProlog
elif start.startswith(b"%PDF"):
ans = ("pdf", start[5:8].decode())
if _FindAdobeIllustrator(f):
ans = ("ai", "pdf")
else:
ans = ("error", "unknown file type")
f.close()
return ans
def _FindAdobeIllustrator(f):
"""Does a file contain "Adobe_Illustrator"?
Args:
f: an open File
Returns:
bool: True if reading forward in f, we find "Adobe_Illustrator"
"""
while True:
s = f.readline()
if not s or s.startswith(b"%%EndProlog"):
break
if s.find(b"Adobe_Illustrator") >= 0:
return True
return False
def ParseVecFile(filename):
"""Parse a vector art file and return an Art object for it.
Right now, handled file types are: EPS, Adobe Illustrator, PDF
Args:
filename: string - name of the file to read and parse
Returns:
geom.Art: object containing paths drawn in the file.
Return None if there was a major problem reading the file.
"""
(major, minor) = ClassifyFile(filename)
if (major == "error"):
print("Couldn't get Art:", minor)
return None
if major == "pdf" or (major == "ai" and minor == "pdf"):
contents = pdf.ReadPDFPageOneContents(filename)
if contents:
toks = TokenizeAIEPS(contents)
return ParsePS(toks, major, minor)
else:
return None
elif major == "eps" or (major == "ai" and minor == "eps"):
toks = TokenizeAIEPSFile(filename)
return ParsePS(toks, major, minor)
elif major == "svg":
return svg.ParseSVGFile(filename)
else:
return None
def ParseAIEPSFile(filename):
"""Parse an AI (eps kind) file and return an Art object for it.
Args:
filename: string - name of the file to read and parse
Returns:
geom.Art - object containing paths and faces drawn in the file
"""
toks = TokenizeAIEPSFile(filename)
return ParsePS(toks, "ai", "eps")
def TokenizeAIEPSFile(filename):
"""Tokenize the after-setup part of an AI (eps kind) file.
Runs TokenizeAIEPS (see below) on the contents of the file.
Args:
filename: name of the file to tokenize
Returns:
list of (tokenid, value) tuples
"""
try:
f = open(filename, "rU") # 'U'-> all newline reps converted to '\n'
except IOError:
if WARN:
print("Can't open file", filename)
return []
contents = f.read()
f.close()
return TokenizeAIEPS(contents)
# Regular expressions for PostScript tokens
_re_psname = re.compile(r"[^ \t\r\n()<>[\]{}/%]+")
_re_psfloat = re.compile(r"(\+|-)?(([0-9]+\.[0-9]*)|(\.[0-9]+))")
_re_psint = re.compile(r"(\+|-)?[0-9]+")
_re_psstring = re.compile(r"\((\\.|.)*?\)")
_re_pshexstring = re.compile(r"<.*>")
def TokenizeAIEPS(s):
"""Tokenize the after-setup part of the an AI (eps kind) string.
Args:
s: string to tokenize
Returns:
list of (Txxx, val) where Txxx is a token type constant
"""
i = s.find("%%EndSetup")
if i == -1:
i = 0
else:
i += 10
ans = []
while i < len(s):
c = s[i]
if c.isspace():
i += 1
elif c == "%":
i = s.find("\n", i)
if i < 0:
i = len(s)
break
i += 1
elif c == "/":
m = _re_psname.match(s, i + 1)
if m:
ans.append((TLITNAME, m.group()))
i = m.end()
else:
if WARN:
print("empty name at", i)
i += 1
elif c == "(":
m = _re_psstring.match(s, i)
if m:
ans.append((TSTRING, s[m.start() + 1:m.end() - 1]))
i = m.end()
else:
if WARN:
print("unterminated string at", i)
i = len(s)
elif c == "<":
m = _re_pshexstring.match(s, i)
if m:
ans.append((TSTRING, s[m.start() + 1:m.end() - 1]))
i = m.end()
else:
if WARN:
print("unterminated hex string at", i)
i = len(s) # unterminated hex string
elif c == "[" or c == "]" or c == "{" or c == "}":
ans.append((TNAME, c))
i += 1
elif c == "-" or c.isdigit():
m = _re_psfloat.match(s, i)
if m:
v = float(m.group())
ans.append((TNUM, v))
i = m.end()
else:
m = _re_psint.match(s, i)
if m:
v = int(m.group())
ans.append((TNUM, v))
i = m.end()
else:
if WARN:
print("number parse problem at", i)
i += 1
else:
m = _re_psname.match(s, i)
if m:
ans.append((TNAME, m.group()))
i = m.end()
else:
if WARN:
print("tokenize error at", i, s[i:i + 10], "...")
i += 1
return ans
class GState(object):
"""Object to hold graphic state.
Attributes:
ctm: geom.TransformMatrix - current transform matrix
fillpaint: geom.Paint
strokepaint: geom.Paint
"""
def __init__(self):
self.ctm = geom.TransformMatrix()
self.fillpaint = geom.black_paint
self.strokepaint = geom.black_paint
def Copy(self):
"""Return a copy of this graphics state."""
gs = GState()
gs.ctm = self.ctm.Copy()
gs.fillpaint = self.fillpaint # ok to share, paint is immutable
gs.strokepaint = self.strokepaint
return gs
class _PathState(object):
"""Object to hold state while parsing Adobe paths.
Attributes:
art: geom.Art, used to accumulate answer
curpath: geom.Path
cursubpath: geom.Subpath - not yet added into curpath
curpoint: coordinates of current point, None if none
incompound: true if parsing an ai/eps compound path
gstate: GState - the current graphics state
gstack: list of GState - stack when graphics state pushed
messages: list of string - warnings, errors
"""
def __init__(self):
"""Construct the _PathState object."""
self.art = geom.Art()
self.ResetPath()
self.incompound = False
self.gstate = GState()
self.statestack = []
self.messages = []
def CloseSubpath(self):
"""Close the current subpath.
Close the current subpath by appending a straight line segment from
current point to starting point of the subpath, terminating current
subpath.
Does nothing if current subpath is already closed or is empty.
"""
if not self.cursubpath.Empty():
startp = geom.Subpath.SegStart(self.cursubpath.segments[0])
if startp != self.curpoint:
self.cursubpath.AddSegment(("L", self.curpoint, startp))
self.curpoint = startp
self.curpath.AddSubpath(self.cursubpath)
self.cursubpath = geom.Subpath()
def ResetPath(self):
"""Reset the current path state to empty,
discarding any current path."""
self.curpath = geom.Path()
self.cursubpath = geom.Subpath()
self.curpoint = None
self.incompound = False
def StartCompound(self):
"""Mark entry to an ai/eps compound path."""
self.incompound = True
def EndCompound(self):
"""Finish off an ai/eps compound path."""
if not self.curpath.Empty():
self.art.paths.append(self.curpath)
self.ResetPath()
def DrawPath(self, dofill, dostroke, fillevenodd=False):
"""End the current path and add its subpaths to art.
Assume any finally closing of the current subpath, if needed,
was done separately.
If we are in an ai/eps compound path, don't close off the
current path yet - wait until EndCompound - but record
the fill/stroke parameters for later use.
Arguments:
dofill: if true, the path is to be filled
dostroke: if true, the path is to be stroked
fillevenodd: it true, use even-odd fill rule,
else nonzero winding number rule
"""
if not self.cursubpath.Empty():
self.curpath.AddSubpath(self.cursubpath)
self.cursubpath = geom.Subpath()
p = self.curpath
if not p.Empty():
p.filled = dofill
p.fillevenodd = fillevenodd
p.stroked = dostroke
if dofill:
p.fillpaint = self.gstate.fillpaint
if dostroke:
p.strokepaint = self.gstate.strokepaint
if not self.incompound:
self.art.paths.append(p)
self.ResetPath()
elif not self.incompound:
self.ResetPath()
def MoveTo(self, x, y, relative=False):
"""Begin a new subpath, starting at (x,y).
If the previous path construction was also a MoveTo,
its effect is overridden.
If relative is True, the move should be relative
to the previous point, else it is absolute.
Args:
x: float
y: float - the 2d coord to start at
relative: bool - if true, then a relative move, else absolute
"""
(xp, yp) = self.gstate.ctm.Apply((x, y))
if relative and self.curpoint:
xp += self.curpoint[0]
yp += self.curpoint[1]
p = (xp, yp)
if not self.cursubpath.Empty():
self.curpath.AddSubpath(self.cursubpath)
self.cursubpath = geom.Subpath()
self.curpoint = p
def LineTo(self, x, y, relative=False):
"""Append a straight line segment from current point to (x,y).
Does nothing if there is no current point, or the segment
would have no length.
If relative is True, the endpoint of the line is relative to the start.
Args:
x: float
y: float - the 2d coord to make the line to.
relative: bool - if true, then a relative lineto
"""
if self.curpoint == -1:
return
(xp, yp) = self.gstate.ctm.Apply((x, y))
if relative and self.curpoint:
xp += self.curpoint[0]
yp += self.curpoint[1]
p = (xp, yp)
if p != self.curpoint:
self.cursubpath.AddSegment(("L", self.curpoint, p))
self.curpoint = p
def Bezier3To(self, x, y, cp1x, cp1y, cp2x, cp2y,
use_start_as_cp=False, relative=False):
"""Append a cubic bezier curve from current point to (x,y).
Args:
x: float
y: float - the 2d coord that ends the curve
cp1x: float
cp1y: float - first bezier control point
cp2x: float
cp2y: float - second bezier control point
use_start_as_cp: bool - if True, ignore cp1x,cp2y and use current
point as first control point instead
relative: bool - if True, all coords are relative to previous point
"""
if self.curpoint == -1:
return
(rx, ry) = (0, 0)
if relative and self.curpoint:
(rx, ry) = self.curpoint
if use_start_as_cp:
cp1 = self.curpoint
else:
cp1 = self.gstate.ctm.Apply((cp1x + rx, cp1y + ry))
cp2 = self.gstate.ctm.Apply((cp2x + rx, cp2y + ry))
p = self.gstate.ctm.Apply((x + rx, y + ry))
self.cursubpath.AddSegment(("B", self.curpoint, p, cp1, cp2))
self.curpoint = p
def PushGState(self):
"""Push the graphics state, leaving a copy in gstate."""
newgstate = self.gstate.Copy()
self.statestack.append(self.gstate)
self.gstate = newgstate
def PopGState(self):
"""Pop the graphics state (no-op if stack is empty)."""
if self.statestack:
self.gstate = self.statestack.pop()
def ParsePS(toks, major="pdf", minor=""):
"""Parse a Postscript-like token list into an Art object.
Four kinds of files use approximately the same painting
model and operators:
Encapsulated Postscript (EPS) - Postscript with Document
Structuring Convention Comments: in general, these
can have Postscript procedures and are not handled
by the code here, but many programs producing eps
just use the path creating/painting operators or
abbreviations for them.
Adobe Illustrator, version <=8: Uses EPS but with
paths are all just single subpaths unless enclosed
in compound path brackets (*u ... *U)
Adobe Illustrator, version >=9: PDF for page description
PDF: similar to Postscript, but some different operators
We can parse each into an Art structure using approximately
the same code.
Args:
toks: list of (Txxx, val), result of Tokenizing a file
major: string - major version ("ps", "eps", "pdf", or "ai")
minor: string - minor version (version number for ps, eps, pdf,
and "eps" or "pdf" for "ai")
Returns:
geom.Art: object with the paths painted by the token stream
"""
pstate = _PathState()
i = 0
while i < len(toks):
(t, v) = toks[i]
i += 1
if t == TNAME:
# zero-operand operator or unhandled one
# since all handled multi-operand operators
# are handled below
if v == "h" or v == "H" or v == "closepath":
pstate.CloseSubpath()
elif v == "f" or v == "F" or v == "fill":
# fill path using nonzero winding number rule
pstate.DrawPath(True, False, False)
elif v == "f*" or v == "eofill":
# fill path using even-odd rule
pstate.DrawPath(True, False, True)
elif v == "s":
# close and stroke path
pstate.CloseSubpath()
pstate.DrawPath(False, True)
elif v == "S" or v == "stroke":
# stroke path
pstate.DrawPath(False, True)
elif v == "b":
# close, fill and stroke path using nonzero winding rule
pstate.CloseSubpath()
pstate.DrawPath(True, True, False)
elif v == "B":
# fill and stroke path uwing nonzero winding rule
pstate.DrawPath(True, True, False)
elif v == "b*":
# close, fill and stroke path using even-odd rule
pstate.CloseSubpath()
pstate.DrawPath(True, True, True)
elif v == "B*":
# fill and stroke path using even-odd rule
pstate.DrawPath(True, True, True)
elif v == "n" or v == "N" or v == "newpath":
# finish path no-op, probably after clipping
# (which is not handled yet)
pstate.ResetPath()
elif v == "*u" and major == "ai" and minor == "eps":
# beginning of AI compound path
pstate.StartCompound()
elif v == "*U" and major == "ai" and minor == "eps":
# end of AI compound path
pstate.EndCompound()
elif v == "q" or v == "gsave":
pstate.PushGState()
elif v == "Q" or v == "grestore":
pstate.PopGState()
elif t == TNUM:
# see if have nargs numbers followed by an op name
op = ""
args = [float(v)]
iend = min(i + 6, len(toks))
while i < iend:
t = toks[i][0]
if t == TNUM:
args.append(float(toks[i][1]))
i += 1
elif t == TNAME:
op = toks[i][1]
i += 1
break
else:
break
if op and len(args) <= 6:
if len(args) == 1:
if op == "g":
# gray level for non-stroking operations
pstate.gstate.fillpaint = geom.Paint(args[0],
args[0], args[0])
elif op == "G":
pstate.gstate.strokepaint = geom.Paint(args[0],
args[0], args[0])
if len(args) == 2:
if op == "m" or op == "moveto":
pstate.MoveTo(args[0], args[1], False)
elif op == "rmoveto":
pstate.MoveTo(args[0], args[1], True)
elif op == "l" or op == "L" or op == "lineto":
pstate.LineTo(args[0], args[1], False)
elif op == "rlineto":
pstate.LineTo(args[0], args[1], True)
elif op == "scale":
pstate.gstate.ctm.ComposeTransform(args[0], 0.0,
0.0, args[1], 0.0, 0.0)
elif op == "translate":
pstate.gstate.ctm.ComposeTransform(0.0, 0.0,
0.0, 0.0, args[0], args[1])
if len(args) == 3:
if op == "rg" or op == "scn":
# rgb for non-stroking operations
# For scn should really refer to Color space from
# cs operator, which in turn may need to look in
# Resource Dictionary in pdf,
# so for now punt and assume rgb if three operands
pstate.gstate.fillpaint = geom.Paint(args[0],
args[1], args[2])
elif op == "RG" or op == "SCN":
pstate.gstate.strokepaint = geom.Paint(args[0],
args[1], args[2])
elif len(args) == 4:
if op == "v" or op == "V":
# cubic bezier but use start as first cp
pstate.Bezier3To(args[2], args[3], 0.0, 0.0,
args[0], args[1],
use_start_as_cp=True)
elif op == "y" or op == "Y":
# cubic bezier but use last as second cp
pstate.Bezier3To(args[2], args[3], args[0], args[1],
args[2], args[3])
elif op == "re" or op == "rectfill" or op == "rectstroke":
# rectangle with x, y, width, height as args
# drawn as complete subpath (a PDF operator)
x = args[0]
y = args[1]
w = args[2]
h = args[3]
pstate.MoveTo(x, y)
pstate.LineTo(x + w, y)
pstate.LineTo(x + w, y + h)
pstate.LineTo(x, h + y)
pstate.CloseSubpath()
if op == "rectfill":
pstate.DrawPath(True, False)
elif op == "rectstroke":
pstate.DrawPath(False, True)
elif op == "k" or op == "scn":
# cmyk for non-stroking operations
# For scn should really refer to Color space from
# cs operator, which in turn may need to look in
# Resource Dictionary in pdf,
# so for now punt and assume cmyk if four operands
pstate.gstate.fillpaint = geom.Paint.CMYK(args[0],
args[1], args[2], args[3])
elif op == "K" or op == "SCN":
pstate.gstate.strokepaint = geom.Paint.CMYK(args[0],
args[1], args[2], args[3])
elif len(args) == 6:
if op == "c" or op == "C" or op == "curveto":
# corner and non-corner cubic beziers
pstate.Bezier3To(args[4], args[5], args[0], args[1],
args[2], args[3], False, False)
elif op == "rcurveto":
pstate.Bezier3To(args[4], args[5], args[0], args[1],
args[2], args[3], False, True)
elif op == "cm" or op == "concat":
pstate.gstate.ctm.ComposeTransform(args[0], args[1],
args[2], args[3], args[4], args[5])
return pstate.art
# Notes on Adobe Illustrator post version 8:
# Outside format is PDF.
# A Page object may have a PieceInfo with Illustrator attribute
# pointing to an object with a Private attribute that points to
# an object with AIMetaData and AIPrivateData[123456]
# AIMetaData points to the prolog of an old-style AI file
# AIPrivate1 points to a thumbnail image
# AIPrivate2-6 point to compressed stream objects - need more investigation.
# But AI version12 does different stuff: has AIPrivateData1-6 etc.
# It appears that AIPrivate6 obj has the %EndSetup and then old-style AI file
# So: hacky way that will sometimes work:
# 1) find "/AIPrivateData6 Z 0 R" for some Z
# 2) find "Z 0 obj"
# 3) find following stream, and then endstream
# 4) flatedecode the stream if necessary
# 5) look for "%%EndSetup, if found: tokenize and parse like old AI files