pyx/bitmap.py

   1 # -*- coding: ISO-8859-1 -*-
   2 #
   3 #
   4 # Copyright (C) 2004-2005 André Wobst <wobsta@users.sourceforge.net>
   5 #
   6 # This file is part of PyX (http://pyx.sourceforge.net/).
   7 #
   8 # PyX is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # PyX is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with PyX; if not, write to the Free Software
  20 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  21
  22 import struct, warnings, binascii
  23 try:
  24     import zlib
  25     haszlib = 1
  26 except:
  27     haszlib = 0
  28
  29 import bbox, canvas, pswriter, pdfwriter, trafo, unit
  30
  31 def ascii85lines(datalen):
  32     if datalen < 4:
  33         return 1
  34     return (datalen + 56)/60
  35
  36 def ascii85stream(file, data):
  37     """Encodes the string data in ASCII85 and writes it to
  38     the stream file. The number of lines written to the stream
  39     is known just from the length of the data by means of the
  40     ascii85lines function. Note that the tailing newline character
  41     of the last line is not added by this function, but it is taken
  42     into account in the ascii85lines function."""
  43     i = 3 # go on smoothly in case of data length equals zero
  44     l = 0
  45     l = [None, None, None, None]
  46     for i in range(len(data)):
  47         c = data[i]
  48         l[i%4] = ord(c)
  49         if i%4 == 3:
  50             if i%60 == 3 and i != 3:
  51                 file.write("\n")
  52             if l:
  53                 # instead of
  54                 # l[3], c5 = divmod(256*256*256*l[0]+256*256*l[1]+256*l[2]+l[3], 85)
  55                 # l[2], c4 = divmod(l[3], 85)
  56                 # we have to avoid number > 2**31 by
  57                 l[3], c5 = divmod(256*256*l[0]+256*256*l[1]+256*l[2]+l[3], 85)
  58                 l[2], c4 = divmod(256*256*3*l[0]+l[3], 85)
  59                 l[1], c3 = divmod(l[2], 85)
  60                 c1  , c2 = divmod(l[1], 85)
  61                 file.write(struct.pack('BBBBB', c1+33, c2+33, c3+33, c4+33, c5+33))
  62             else:
  63                 file.write("z")
  64     if i%4 != 3:
  65         for j in range((i%4) + 1, 4):
  66             l[j] = 0
  67         l[3], c5 = divmod(256*256*l[0]+256*256*l[1]+256*l[2]+l[3], 85)
  68         l[2], c4 = divmod(256*256*3*l[0]+l[3], 85)
  69         l[1], c3 = divmod(l[2], 85)
  70         c1  , c2 = divmod(l[1], 85)
  71         file.write(struct.pack('BBBB', c1+33, c2+33, c3+33, c4+33)[:(i%4)+2])
  72
  73 _asciihexlinelength = 64
  74 def asciihexlines(datalen):
  75     return (datalen*2 + _asciihexlinelength - 1) / _asciihexlinelength
  76
  77 def asciihexstream(file, data):
  78     hexdata = binascii.b2a_hex(data)
  79     for i in range((len(hexdata)-1)/_asciihexlinelength + 1):
  80         file.write(hexdata[i*_asciihexlinelength: i*_asciihexlinelength+_asciihexlinelength])
  81         file.write("\n")
  82
  83
  84 class image:
  85
  86     def __init__(self, width, height, mode, data, compressed=None):
  87         if width <= 0 or height <= 0:
  88             raise ValueError("valid image size")
  89         if mode not in ["L", "RGB", "CMYK"]:
  90             raise ValueError("invalid mode")
  91         if compressed is None and len(mode)*width*height != len(data):
  92             raise ValueError("wrong size of uncompressed data")
  93         self.size = width, height
  94         self.mode = mode
  95         self.data = data
  96         self.compressed = compressed
  97
  98     def tostring(self, *args):
  99         if len(args):
 100             raise RuntimeError("encoding not supported in this implementation")
 101         return self.data
 102
 103     def convert(self, model):
 104         raise RuntimeError("color model conversion not supported in this implementation")
 105
 106
 107 class jpegimage(image):
 108
 109    def __init__(self, file):
 110        try:
 111            data = file.read()
 112        except:
 113            data = open(file, "rb").read()
 114        pos = 0
 115        nestinglevel = 0
 116        try:
 117            while 1:
 118                if data[pos] == "\377" and data[pos+1] not in ["\0", "\377"]:
 119                    # print "marker: 0x%02x \\%03o" % (ord(data[pos+1]), ord(data[pos+1]))
 120                    if data[pos+1] == "\330":
 121                        if not nestinglevel:
 122                            begin = pos
 123                        nestinglevel += 1
 124                    elif not nestinglevel:
 125                        raise ValueError("begin marker expected")
 126                    elif data[pos+1] == "\331":
 127                        nestinglevel -= 1
 128                        if not nestinglevel:
 129                            end = pos + 2
 130                            break
 131                    elif data[pos+1] in ["\300", "\301"]:
 132                        l, bits, height, width, components = struct.unpack(">HBHHB", data[pos+2:pos+10])
 133                        if bits != 8:
 134                            raise ValueError("implementation limited to 8 bit per component only")
 135                        try:
 136                            mode = {1: "L", 3: "RGB", 4: "CMYK"}[components]
 137                        except KeyError:
 138                            raise ValueError("invalid number of components")
 139                        pos += l+1
 140                    elif data[pos+1] == "\340":
 141                        l, id, major, minor, dpikind, xdpi, ydpi = struct.unpack(">H5sBBBHH", data[pos+2:pos+16])
 142                        if dpikind == 1:
 143                            self.info = {"dpi": (xdpi, ydpi)}
 144                        elif dpikind == 2:
 145                            self.info = {"dpi": (xdpi*2.54, ydpi*2.45)}
 146                        # else do not provide dpi information
 147                        pos += l+1
 148                pos += 1
 149        except IndexError:
 150            raise ValueError("end marker expected")
 151        image.__init__(self, width, height, mode, data[begin:end], compressed="DCT")
 152
 153
 154 class PSimagedata(pswriter.PSresource):
 155
 156     def __init__(self, name, data, singlestring, maxstrlen):
 157         pswriter.PSresource.__init__(self, "imagedata", name)
 158         self.data = data
 159         self.singlestring = singlestring
 160         self.maxstrlen = maxstrlen
 161
 162     def output(self, file, writer, registry):
 163         file.write("%%%%BeginRessource: %s\n" % self.id)
 164         if self.singlestring:
 165             file.write("%%%%BeginData: %i ASCII Lines\n"
 166                        "<~" % ascii85lines(len(self.data)))
 167             ascii85stream(file, self.data)
 168             file.write("~>\n"
 169                          "%%EndData\n")
 170         else:
 171             datalen = len(self.data)
 172             tailpos = datalen - datalen % self.maxstrlen
 173             file.write("%%%%BeginData: %i ASCII Lines\n" %
 174                        ((tailpos/self.maxstrlen) * ascii85lines(self.maxstrlen) +
 175                         ascii85lines(datalen-tailpos)))
 176             file.write("[ ")
 177             for i in xrange(0, tailpos, self.maxstrlen):
 178                 file.write("<~")
 179                 ascii85stream(file, self.data[i: i+self.maxstrlen])
 180                 file.write("~>\n")
 181             if datalen != tailpos:
 182                 file.write("<~")
 183                 ascii85stream(file, self.data[tailpos:])
 184                 file.write("~>")
 185             file.write("]\n"
 186                        "%%EndData\n")
 187         file.write("/%s exch def\n" % self.id)
 188         file.write("%%EndRessource\n")
 189
 190
 191 class PDFimagepalettedata(pdfwriter.PDFobject):
 192
 193     def __init__(self, name, data):
 194         pdfwriter.PDFobject.__init__(self, "imagepalettedata", name)
 195         self.data = data
 196
 197     def write(self, file, writer, registry):
 198         file.write("<<\n"
 199                    "/Length %d\n" % len(self.data))
 200         file.write(">>\n"
 201                    "stream\n")
 202         file.write(self.data)
 203         file.write("\n"
 204                    "endstream\n")
 205
 206
 207 class PDFimage(pdfwriter.PDFobject):
 208
 209     def __init__(self, name, width, height, palettecolorspace, palettedata, colorspace,
 210                        bitspercomponent, compressmode, data, registry):
 211         if palettedata is not None:
 212             procset = "ImageI"
 213         elif colorspace == "/DeviceGray":
 214             procset = "ImageB"
 215         else:
 216             procset = "ImageC"
 217         pdfwriter.PDFobject.__init__(self, "image", name)
 218         registry.addresource("XObject", name, self, procset=procset)
 219         if palettedata is not None:
 220             # acrobat wants a palette to be an object
 221             self.PDFpalettedata = PDFimagepalettedata(name, palettedata)
 222             registry.add(self.PDFpalettedata)
 223         self.name = name
 224         self.width = width
 225         self.height = height
 226         self.palettecolorspace = palettecolorspace
 227         self.palettedata = palettedata
 228         self.colorspace = colorspace
 229         self.bitspercomponent = bitspercomponent
 230         self.compressmode = compressmode
 231         self.data = data
 232
 233     def write(self, file, writer, registry):
 234         file.write("<<\n"
 235                    "/Type /XObject\n"
 236                    "/Subtype /Image\n"
 237                    "/Width %d\n" % self.width)
 238         file.write("/Height %d\n" % self.height)
 239         if self.palettedata is not None:
 240             file.write("/ColorSpace [ /Indexed %s %i\n" % (self.palettecolorspace, len(self.palettedata)/3-1))
 241             file.write("%d 0 R\n" % registry.getrefno(self.PDFpalettedata))
 242             file.write("]\n")
 243         else:
 244             file.write("/ColorSpace %s\n" % self.colorspace)
 245         file.write("/BitsPerComponent %d\n" % self.bitspercomponent)
 246         file.write("/Length %d\n" % len(self.data))
 247         if self.compressmode:
 248             file.write("/Filter /%sDecode\n" % self.compressmode)
 249         file.write(">>\n"
 250                    "stream\n")
 251         file.write(self.data)
 252         file.write("\n"
 253                    "endstream\n")
 254
 255
 256 class bitmap(canvas.canvasitem):
 257
 258     def __init__(self, xpos, ypos, image, width=None, height=None, ratio=None,
 259                        PSstoreimage=0, PSmaxstrlen=4093, PSbinexpand=1,
 260                        compressmode="Flate", flatecompresslevel=6,
 261                        dctquality=75, dctoptimize=0, dctprogression=0):
 262         self.xpos = xpos
 263         self.ypos = ypos
 264         self.imagewidth, self.imageheight = image.size
 265         self.PSstoreimage = PSstoreimage
 266         self.PSmaxstrlen = PSmaxstrlen
 267         self.PSbinexpand = PSbinexpand
 268
 269         if width is not None or height is not None:
 270             self.width = width
 271             self.height = height
 272             if self.width is None:
 273                 if ratio is None:
 274                     self.width = self.height * self.imagewidth / float(self.imageheight)
 275                 else:
 276                     self.width = ratio * self.height
 277             elif self.height is None:
 278                 if ratio is None:
 279                     self.height = self.width * self.imageheight / float(self.imagewidth)
 280                 else:
 281                     self.height = (1.0/ratio) * self.width
 282             elif ratio is not None:
 283                 raise ValueError("can't specify a ratio when setting width and height")
 284         else:
 285             if ratio is not None:
 286                 raise ValueError("must specify width or height to set a ratio")
 287             widthdpi, heightdpi = image.info["dpi"] # fails when no dpi information available
 288             self.width = self.imagewidth / float(widthdpi) * unit.t_inch
 289             self.height = self.imageheight / float(heightdpi) * unit.t_inch
 290
 291         self.xpos_pt = unit.topt(self.xpos)
 292         self.ypos_pt = unit.topt(self.ypos)
 293         self.width_pt = unit.topt(self.width)
 294         self.height_pt = unit.topt(self.height)
 295
 296         # create decode and colorspace
 297         self.colorspace = self.palettecolorspace = self.palettedata = None
 298         if image.mode == "P":
 299             palettemode, self.palettedata = image.palette.getdata()
 300             self.decode = "[0 255]"
 301             try:
 302                 self.palettecolorspace = {"L": "/DeviceGray",
 303                                           "RGB": "/DeviceRGB",
 304                                           "CMYK": "/DeviceCMYK"}[palettemode]
 305             except KeyError:
 306                 warnings.warn("image with unknown palette mode '%s' converted to rgb image" % palettemode)
 307                 image = image.convert("RGB")
 308                 self.decode = "[0 1 0 1 0 1]"
 309                 self.palettedata = None
 310                 self.colorspace = "/DeviceRGB"
 311         elif len(image.mode) == 1:
 312             if image.mode != "L":
 313                 image = image.convert("L")
 314                 warnings.warn("specific single channel image mode not natively supported, converted to regular grayscale")
 315             self.decode = "[0 1]"
 316             self.colorspace = "/DeviceGray"
 317         elif image.mode == "CMYK":
 318             self.decode = "[0 1 0 1 0 1 0 1]"
 319             self.colorspace = "/DeviceCMYK"
 320         else:
 321             if image.mode != "RGB":
 322                 image = image.convert("RGB")
 323                 warnings.warn("image with unknown mode converted to rgb")
 324             self.decode = "[0 1 0 1 0 1]"
 325             self.colorspace = "/DeviceRGB"
 326
 327         # create imagematrix
 328         self.imagematrixPS = (trafo.mirror(0)
 329                               .translated_pt(-self.xpos_pt, self.ypos_pt+self.height_pt)
 330                               .scaled_pt(self.imagewidth/self.width_pt, self.imageheight/self.height_pt))
 331         self.imagematrixPDF = (trafo.scale_pt(self.width_pt, self.height_pt)
 332                                .translated_pt(self.xpos_pt, self.ypos_pt))
 333
 334         # check whether imagedata is compressed or not
 335         try:
 336             imagecompressed = image.compressed
 337         except:
 338             imagecompressed = None
 339         if compressmode != None and imagecompressed != None:
 340             raise ValueError("compression of a compressed image not supported")
 341         self.compressmode = compressmode
 342         if compressmode is not None and compressmode not in ["Flate", "DCT"]:
 343                 raise ValueError("invalid compressmode '%s'" % compressmode)
 344         if imagecompressed is not None:
 345             self.compressmode = imagecompressed
 346             if imagecompressed not in ["Flate", "DCT"]:
 347                 raise ValueError("invalid compressed image '%s'" % imagecompressed)
 348         if not haszlib and compressmode == "Flate":
 349             warnings.warn("zlib module not available, disable compression")
 350             self.compressmode = compressmode = None
 351
 352         # create data
 353         if compressmode == "Flate":
 354             self.data = zlib.compress(image.tostring(), flatecompresslevel)
 355         elif compressmode == "DCT":
 356             self.data = image.tostring("jpeg", image.mode,
 357                                        dctquality, dctoptimize, dctprogression)
 358         else:
 359             self.data = image.tostring()
 360
 361         self.PSsinglestring = self.PSstoreimage and len(self.data) < self.PSmaxstrlen
 362         if self.PSsinglestring:
 363             self.PSimagename = "image-%d-%s-singlestring" % (id(image), compressmode)
 364         else:
 365             self.PSimagename = "image-%d-%s-stringarray" % (id(image), compressmode)
 366         self.PDFimagename = "image-%d-%s" % (id(image), compressmode)
 367
 368     def bbox(self):
 369         return bbox.bbox_pt(self.xpos_pt, self.ypos_pt,
 370                             self.xpos_pt+self.width_pt, self.ypos_pt+self.height_pt)
 371
 372     def processPS(self, file, writer, context, registry, bbox):
 373         if self.PSstoreimage and not self.PSsinglestring:
 374             registry.add(pswriter.PSdefinition("imagedataaccess",
 375                                                "{ /imagedataindex load " # get list index
 376                                                "dup 1 add /imagedataindex exch store " # store increased index
 377                                                "/imagedataid load exch get }")) # select string from array
 378         if self.PSstoreimage:
 379             registry.add(PSimagedata(self.PSimagename, self.data, self.PSsinglestring, self.PSmaxstrlen))
 380         bbox += self.bbox()
 381
 382         file.write("gsave\n")
 383         if self.palettedata is not None:
 384             file.write("[ /Indexed %s %i\n" % (self.palettecolorspace, len(self.palettedata)/3-1))
 385             file.write("%%%%BeginData: %i ASCII Lines\n" % ascii85lines(len(self.palettedata)))
 386             file.write("<~")
 387             ascii85stream(file, self.palettedata)
 388             file.write("~>\n"
 389                        "%%EndData\n")
 390             file.write("] setcolorspace\n")
 391         else:
 392             file.write("%s setcolorspace\n" % self.colorspace)
 393
 394         if self.PSstoreimage and not self.PSsinglestring:
 395             file.write("/imagedataindex 0 store\n" # not use the stack since interpreters differ in their stack usage
 396                        "/imagedataid %s store\n" % self.PSimagename)
 397
 398         file.write("<<\n"
 399                    "/ImageType 1\n"
 400                    "/Width %i\n" % self.imagewidth)
 401         file.write("/Height %i\n" % self.imageheight)
 402         file.write("/BitsPerComponent 8\n"
 403                    "/ImageMatrix %s\n" % self.imagematrixPS)
 404         file.write("/Decode %s\n" % self.decode)
 405
 406         file.write("/DataSource ")
 407         if self.PSstoreimage:
 408             if self.PSsinglestring:
 409                 file.write("/%s load" % self.PSimagename)
 410             else:
 411                 file.write("/imagedataaccess load") # some printers do not allow for inline code here -> we store it in a resource
 412         else:
 413             if self.PSbinexpand == 2:
 414                 file.write("currentfile /ASCIIHexDecode filter")
 415             else:
 416                 file.write("currentfile /ASCII85Decode filter")
 417         if self.compressmode:
 418             file.write(" /%sDecode filter" % self.compressmode)
 419         file.write("\n")
 420
 421         file.write(">>\n")
 422
 423         if self.PSstoreimage:
 424             file.write("image\n")
 425         else:
 426             if self.PSbinexpand == 2:
 427                 file.write("%%%%BeginData: %i ASCII Lines\n"
 428                            "image\n" % (asciihexlines(len(self.data)) + 1))
 429                 asciihexstream(file, self.data)
 430             else:
 431                 # the datasource is currentstream (plus some filters)
 432                 file.write("%%%%BeginData: %i ASCII Lines\n"
 433                            "image\n" % (ascii85lines(len(self.data)) + 1))
 434                 ascii85stream(file, self.data)
 435                 file.write("~>\n")
 436             file.write("%%EndData\n")
 437
 438         file.write("grestore\n")
 439
 440     def processPDF(self, file, writer, context, registry, bbox):
 441         registry.add(PDFimage(self.PDFimagename, self.imagewidth, self.imageheight,
 442                               self.palettecolorspace, self.palettedata, self.colorspace,
 443                               8, self.compressmode, self.data, registry))
 444         bbox += self.bbox()
 445
 446         file.write("q\n")
 447         self.imagematrixPDF.processPDF(file, writer, context, registry, bbox)
 448         file.write("/%s Do\n" % self.PDFimagename)
 449         file.write("Q\n")