| 1 | """PixMapWrapper - defines the PixMapWrapper class, which wraps an opaque
|
|---|
| 2 | QuickDraw PixMap data structure in a handy Python class. Also provides
|
|---|
| 3 | methods to convert to/from pixel data (from, e.g., the img module) or a
|
|---|
| 4 | Python Imaging Library Image object.
|
|---|
| 5 |
|
|---|
| 6 | J. Strout <joe@strout.net> February 1999"""
|
|---|
| 7 |
|
|---|
| 8 |
|
|---|
| 9 | from warnings import warnpy3k
|
|---|
| 10 | warnpy3k("In 3.x, the PixMapWrapper module is removed.", stacklevel=2)
|
|---|
| 11 |
|
|---|
| 12 | from Carbon import Qd
|
|---|
| 13 | from Carbon import QuickDraw
|
|---|
| 14 | import struct
|
|---|
| 15 | import MacOS
|
|---|
| 16 | import img
|
|---|
| 17 | import imgformat
|
|---|
| 18 |
|
|---|
| 19 | # PixMap data structure element format (as used with struct)
|
|---|
| 20 | _pmElemFormat = {
|
|---|
| 21 | 'baseAddr':'l', # address of pixel data
|
|---|
| 22 | 'rowBytes':'H', # bytes per row, plus 0x8000
|
|---|
| 23 | 'bounds':'hhhh', # coordinates imposed over pixel data
|
|---|
| 24 | 'top':'h',
|
|---|
| 25 | 'left':'h',
|
|---|
| 26 | 'bottom':'h',
|
|---|
| 27 | 'right':'h',
|
|---|
| 28 | 'pmVersion':'h', # flags for Color QuickDraw
|
|---|
| 29 | 'packType':'h', # format of compression algorithm
|
|---|
| 30 | 'packSize':'l', # size after compression
|
|---|
| 31 | 'hRes':'l', # horizontal pixels per inch
|
|---|
| 32 | 'vRes':'l', # vertical pixels per inch
|
|---|
| 33 | 'pixelType':'h', # pixel format
|
|---|
| 34 | 'pixelSize':'h', # bits per pixel
|
|---|
| 35 | 'cmpCount':'h', # color components per pixel
|
|---|
| 36 | 'cmpSize':'h', # bits per component
|
|---|
| 37 | 'planeBytes':'l', # offset in bytes to next plane
|
|---|
| 38 | 'pmTable':'l', # handle to color table
|
|---|
| 39 | 'pmReserved':'l' # reserved for future use
|
|---|
| 40 | }
|
|---|
| 41 |
|
|---|
| 42 | # PixMap data structure element offset
|
|---|
| 43 | _pmElemOffset = {
|
|---|
| 44 | 'baseAddr':0,
|
|---|
| 45 | 'rowBytes':4,
|
|---|
| 46 | 'bounds':6,
|
|---|
| 47 | 'top':6,
|
|---|
| 48 | 'left':8,
|
|---|
| 49 | 'bottom':10,
|
|---|
| 50 | 'right':12,
|
|---|
| 51 | 'pmVersion':14,
|
|---|
| 52 | 'packType':16,
|
|---|
| 53 | 'packSize':18,
|
|---|
| 54 | 'hRes':22,
|
|---|
| 55 | 'vRes':26,
|
|---|
| 56 | 'pixelType':30,
|
|---|
| 57 | 'pixelSize':32,
|
|---|
| 58 | 'cmpCount':34,
|
|---|
| 59 | 'cmpSize':36,
|
|---|
| 60 | 'planeBytes':38,
|
|---|
| 61 | 'pmTable':42,
|
|---|
| 62 | 'pmReserved':46
|
|---|
| 63 | }
|
|---|
| 64 |
|
|---|
| 65 | class PixMapWrapper:
|
|---|
| 66 | """PixMapWrapper -- wraps the QD PixMap object in a Python class,
|
|---|
| 67 | with methods to easily get/set various pixmap fields. Note: Use the
|
|---|
| 68 | PixMap() method when passing to QD calls."""
|
|---|
| 69 |
|
|---|
| 70 | def __init__(self):
|
|---|
| 71 | self.__dict__['data'] = ''
|
|---|
| 72 | self._header = struct.pack("lhhhhhhhlllhhhhlll",
|
|---|
| 73 | id(self.data)+MacOS.string_id_to_buffer,
|
|---|
| 74 | 0, # rowBytes
|
|---|
| 75 | 0, 0, 0, 0, # bounds
|
|---|
| 76 | 0, # pmVersion
|
|---|
| 77 | 0, 0, # packType, packSize
|
|---|
| 78 | 72<<16, 72<<16, # hRes, vRes
|
|---|
| 79 | QuickDraw.RGBDirect, # pixelType
|
|---|
| 80 | 16, # pixelSize
|
|---|
| 81 | 2, 5, # cmpCount, cmpSize,
|
|---|
| 82 | 0, 0, 0) # planeBytes, pmTable, pmReserved
|
|---|
| 83 | self.__dict__['_pm'] = Qd.RawBitMap(self._header)
|
|---|
| 84 |
|
|---|
| 85 | def _stuff(self, element, bytes):
|
|---|
| 86 | offset = _pmElemOffset[element]
|
|---|
| 87 | fmt = _pmElemFormat[element]
|
|---|
| 88 | self._header = self._header[:offset] \
|
|---|
| 89 | + struct.pack(fmt, bytes) \
|
|---|
| 90 | + self._header[offset + struct.calcsize(fmt):]
|
|---|
| 91 | self.__dict__['_pm'] = None
|
|---|
| 92 |
|
|---|
| 93 | def _unstuff(self, element):
|
|---|
| 94 | offset = _pmElemOffset[element]
|
|---|
| 95 | fmt = _pmElemFormat[element]
|
|---|
| 96 | return struct.unpack(fmt, self._header[offset:offset+struct.calcsize(fmt)])[0]
|
|---|
| 97 |
|
|---|
| 98 | def __setattr__(self, attr, val):
|
|---|
| 99 | if attr == 'baseAddr':
|
|---|
| 100 | raise 'UseErr', "don't assign to .baseAddr -- assign to .data instead"
|
|---|
| 101 | elif attr == 'data':
|
|---|
| 102 | self.__dict__['data'] = val
|
|---|
| 103 | self._stuff('baseAddr', id(self.data) + MacOS.string_id_to_buffer)
|
|---|
| 104 | elif attr == 'rowBytes':
|
|---|
| 105 | # high bit is always set for some odd reason
|
|---|
| 106 | self._stuff('rowBytes', val | 0x8000)
|
|---|
| 107 | elif attr == 'bounds':
|
|---|
| 108 | # assume val is in official Left, Top, Right, Bottom order!
|
|---|
| 109 | self._stuff('left',val[0])
|
|---|
| 110 | self._stuff('top',val[1])
|
|---|
| 111 | self._stuff('right',val[2])
|
|---|
| 112 | self._stuff('bottom',val[3])
|
|---|
| 113 | elif attr == 'hRes' or attr == 'vRes':
|
|---|
| 114 | # 16.16 fixed format, so just shift 16 bits
|
|---|
| 115 | self._stuff(attr, int(val) << 16)
|
|---|
| 116 | elif attr in _pmElemFormat.keys():
|
|---|
| 117 | # any other pm attribute -- just stuff
|
|---|
| 118 | self._stuff(attr, val)
|
|---|
| 119 | else:
|
|---|
| 120 | self.__dict__[attr] = val
|
|---|
| 121 |
|
|---|
| 122 | def __getattr__(self, attr):
|
|---|
| 123 | if attr == 'rowBytes':
|
|---|
| 124 | # high bit is always set for some odd reason
|
|---|
| 125 | return self._unstuff('rowBytes') & 0x7FFF
|
|---|
| 126 | elif attr == 'bounds':
|
|---|
| 127 | # return bounds in official Left, Top, Right, Bottom order!
|
|---|
| 128 | return ( \
|
|---|
| 129 | self._unstuff('left'),
|
|---|
| 130 | self._unstuff('top'),
|
|---|
| 131 | self._unstuff('right'),
|
|---|
| 132 | self._unstuff('bottom') )
|
|---|
| 133 | elif attr == 'hRes' or attr == 'vRes':
|
|---|
| 134 | # 16.16 fixed format, so just shift 16 bits
|
|---|
| 135 | return self._unstuff(attr) >> 16
|
|---|
| 136 | elif attr in _pmElemFormat.keys():
|
|---|
| 137 | # any other pm attribute -- just unstuff
|
|---|
| 138 | return self._unstuff(attr)
|
|---|
| 139 | else:
|
|---|
| 140 | return self.__dict__[attr]
|
|---|
| 141 |
|
|---|
| 142 |
|
|---|
| 143 | def PixMap(self):
|
|---|
| 144 | "Return a QuickDraw PixMap corresponding to this data."
|
|---|
| 145 | if not self.__dict__['_pm']:
|
|---|
| 146 | self.__dict__['_pm'] = Qd.RawBitMap(self._header)
|
|---|
| 147 | return self.__dict__['_pm']
|
|---|
| 148 |
|
|---|
| 149 | def blit(self, x1=0,y1=0,x2=None,y2=None, port=None):
|
|---|
| 150 | """Draw this pixmap into the given (default current) grafport."""
|
|---|
| 151 | src = self.bounds
|
|---|
| 152 | dest = [x1,y1,x2,y2]
|
|---|
| 153 | if x2 is None:
|
|---|
| 154 | dest[2] = x1 + src[2]-src[0]
|
|---|
| 155 | if y2 is None:
|
|---|
| 156 | dest[3] = y1 + src[3]-src[1]
|
|---|
| 157 | if not port: port = Qd.GetPort()
|
|---|
| 158 | Qd.CopyBits(self.PixMap(), port.GetPortBitMapForCopyBits(), src, tuple(dest),
|
|---|
| 159 | QuickDraw.srcCopy, None)
|
|---|
| 160 |
|
|---|
| 161 | def fromstring(self,s,width,height,format=imgformat.macrgb):
|
|---|
| 162 | """Stuff this pixmap with raw pixel data from a string.
|
|---|
| 163 | Supply width, height, and one of the imgformat specifiers."""
|
|---|
| 164 | # we only support 16- and 32-bit mac rgb...
|
|---|
| 165 | # so convert if necessary
|
|---|
| 166 | if format != imgformat.macrgb and format != imgformat.macrgb16:
|
|---|
| 167 | # (LATER!)
|
|---|
| 168 | raise "NotImplementedError", "conversion to macrgb or macrgb16"
|
|---|
| 169 | self.data = s
|
|---|
| 170 | self.bounds = (0,0,width,height)
|
|---|
| 171 | self.cmpCount = 3
|
|---|
| 172 | self.pixelType = QuickDraw.RGBDirect
|
|---|
| 173 | if format == imgformat.macrgb:
|
|---|
| 174 | self.pixelSize = 32
|
|---|
| 175 | self.cmpSize = 8
|
|---|
| 176 | else:
|
|---|
| 177 | self.pixelSize = 16
|
|---|
| 178 | self.cmpSize = 5
|
|---|
| 179 | self.rowBytes = width*self.pixelSize/8
|
|---|
| 180 |
|
|---|
| 181 | def tostring(self, format=imgformat.macrgb):
|
|---|
| 182 | """Return raw data as a string in the specified format."""
|
|---|
| 183 | # is the native format requested? if so, just return data
|
|---|
| 184 | if (format == imgformat.macrgb and self.pixelSize == 32) or \
|
|---|
| 185 | (format == imgformat.macrgb16 and self.pixelsize == 16):
|
|---|
| 186 | return self.data
|
|---|
| 187 | # otherwise, convert to the requested format
|
|---|
| 188 | # (LATER!)
|
|---|
| 189 | raise "NotImplementedError", "data format conversion"
|
|---|
| 190 |
|
|---|
| 191 | def fromImage(self,im):
|
|---|
| 192 | """Initialize this PixMap from a PIL Image object."""
|
|---|
| 193 | # We need data in ARGB format; PIL can't currently do that,
|
|---|
| 194 | # but it can do RGBA, which we can use by inserting one null
|
|---|
| 195 | # up frontpm =
|
|---|
| 196 | if im.mode != 'RGBA': im = im.convert('RGBA')
|
|---|
| 197 | data = chr(0) + im.tostring()
|
|---|
| 198 | self.fromstring(data, im.size[0], im.size[1])
|
|---|
| 199 |
|
|---|
| 200 | def toImage(self):
|
|---|
| 201 | """Return the contents of this PixMap as a PIL Image object."""
|
|---|
| 202 | import Image
|
|---|
| 203 | # our tostring() method returns data in ARGB format,
|
|---|
| 204 | # whereas Image uses RGBA; a bit of slicing fixes this...
|
|---|
| 205 | data = self.tostring()[1:] + chr(0)
|
|---|
| 206 | bounds = self.bounds
|
|---|
| 207 | return Image.fromstring('RGBA',(bounds[2]-bounds[0],bounds[3]-bounds[1]),data)
|
|---|
| 208 |
|
|---|
| 209 | def test():
|
|---|
| 210 | import MacOS
|
|---|
| 211 | import EasyDialogs
|
|---|
| 212 | import Image
|
|---|
| 213 | path = EasyDialogs.AskFileForOpen("Image File:")
|
|---|
| 214 | if not path: return
|
|---|
| 215 | pm = PixMapWrapper()
|
|---|
| 216 | pm.fromImage( Image.open(path) )
|
|---|
| 217 | pm.blit(20,20)
|
|---|
| 218 | return pm
|
|---|
