sources for convert.py [rev. 38799]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
import py
from py.__.process.cmdexec import ExecutionFailed
# utility functions to convert between various formats
format_to_dotargument = {"png": "png",
                         "eps": "ps",
                         "ps":  "ps",
                         "pdf": "ps",
                        }
def ps2eps(ps):
    # XXX write a pure python version
    if not py.path.local.sysfind("ps2epsi") and \
           not py.path.local.sysfind("ps2eps"):
        raise SystemExit("neither ps2eps nor ps2epsi found")
    try:
        eps = ps.new(ext=".eps")
        py.process.cmdexec('ps2epsi "%s" "%s"' % (ps, eps))
    except ExecutionFailed:
        py.process.cmdexec('ps2eps -l -f "%s"' % ps)
def ps2pdf(ps, compat_level="1.2"):
    if not py.path.local.sysfind("gs"):
        raise SystemExit("ERROR: gs not found")
    pdf = ps.new(ext=".pdf")
    options = dict(OPTIONS="-dSAFER -dCompatibilityLevel=%s" % compat_level,
                   infile=ps, outfile=pdf)
    cmd = ('gs %(OPTIONS)s -q -dNOPAUSE -dBATCH -sDEVICE=pdfwrite '
           '"-sOutputFile=%(outfile)s" %(OPTIONS)s -c .setpdfwrite '
           '-f "%(infile)s"') % options
    py.process.cmdexec(cmd)
    return pdf
def eps2pdf(eps):
    # XXX write a pure python version
    if not py.path.local.sysfind("epstopdf"):
        raise SystemExit("ERROR: epstopdf not found")
    py.process.cmdexec('epstopdf "%s"' % eps)
def dvi2eps(dvi, dest=None):
    if dest is None:
        dest = eps.new(ext=".eps")
    command = 'dvips -q -E -n 1 -D 600 -p 1 -o "%s" "%s"' % (dest, dvi)
    if not py.path.local.sysfind("dvips"):
        raise SystemExit("ERROR: dvips not found")
    py.process.cmdexec(command)
def convert_dot(fn, new_extension):
    if not py.path.local.sysfind("dot"):
        raise SystemExit("ERROR: dot not found")
    result = fn.new(ext=new_extension)
    print result
    arg = "-T%s" % (format_to_dotargument[new_extension], )
    py.std.os.system('dot "%s" "%s" > "%s"' % (arg, fn, result))
    if new_extension == "eps":
        ps = result.new(ext="ps")
        result.move(ps)
        ps2eps(ps)
        ps.remove()
    elif new_extension == "pdf":
        # convert to eps file first, to get the bounding box right
        eps = result.new(ext="eps")
        ps = result.new(ext="ps")
        result.move(ps)
        ps2eps(ps)
        eps2pdf(eps)
        ps.remove()
        eps.remove()
    return result
 
class latexformula2png(object):
    def __init__(self, formula, dest, temp=None):
        self.formula = formula
        try:
            import Image
            self.Image = Image
            self.scale = 2 # create a larger image
            self.upscale = 5 # create the image upscale times larger, then scale it down
        except ImportError:
            self.scale = 2
            self.upscale = 1
            self.Image = None
        self.output_format = ('pngmono', 'pnggray', 'pngalpha')[2]
        if temp is None:
            temp = py.test.ensuretemp("latexformula")
        self.temp = temp
        self.latex = self.temp.join('formula.tex')
        self.dvi = self.temp.join('formula.dvi')
        self.eps = self.temp.join('formula.eps')
        self.png = self.temp.join('formula.png')
        self.saveas(dest)
    def saveas(self, dest):
        self.gen_latex()
        self.gen_dvi()
        dvi2eps(self.dvi, self.eps)
        self.gen_png()
        self.scale_image()
        self.png.copy(dest)
    def gen_latex(self):
        self.latex.write ("""
        \\documentclass{article}
        \\pagestyle{empty}
        \\begin{document}
        %s
        \\pagebreak
        
        \\end{document}
        """ % (self.formula))
    def gen_dvi(self):
        origdir = py.path.local()
        self.temp.chdir()
        py.process.cmdexec('latex "%s"' % (self.latex))
        origdir.chdir()
    def gen_png(self):
        tempdir = py.path.local.mkdtemp()
        
        re_bbox = py.std.re.compile('%%BoundingBox:\s*(\d+) (\d+) (\d+) (\d+)')
        eps = self.eps.read()
        x1, y1, x2, y2 = [int(i) for i in re_bbox.search(eps).groups()]
        X = x2 - x1 + 2
        Y = y2 - y1 + 2
        mx = -x1
        my = -y1
        ps = self.temp.join('temp.ps')
        source = self.eps
        ps.write("""
        1 1 1 setrgbcolor
        newpath
        -1 -1 moveto
        %(X)d  -1 lineto
        %(X)d %(Y)d lineto
        -1 %(Y)d lineto
        closepath
        fill
        %(mx)d %(my)d translate
        0 0 0 setrgbcolor
        (%(source)s) run
        
        """ % locals())
        sx = int((x2 - x1) * self.scale * self.upscale)
        sy = int((y2 - y1) * self.scale * self.upscale)
        res = 72 * self.scale * self.upscale
        command = ('gs -q -g%dx%d -r%dx%d -sDEVICE=%s -sOutputFile="%s" '
                   '-dNOPAUSE -dBATCH "%s"') % (
                    sx, sy, res, res, self.output_format, self.png, ps)
        py.process.cmdexec(command)
    def scale_image(self):
        if self.Image is None:
            return
        image = self.Image.open(str(self.png))
        image.resize((image.size[0] / self.upscale,
                      image.size[1] / self.upscale),
                     self.Image.ANTIALIAS).save(str(self.png))