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
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
"""PixMapWrapper - defines the PixMapWrapper class, which wraps an opaque
QuickDraw PixMap data structure in a handy Python class. Also provides
methods to convert to/from pixel data (from, e.g., the img module) or a
Python Imaging Library Image object.
J. Strout <joe@strout.net> February 1999"""
from Carbon import Qd
from Carbon import QuickDraw
import struct
import MacOS
import img
import imgformat
# PixMap data structure element format (as used with struct)
_pmElemFormat = {
'baseAddr':'l', # address of pixel data
'rowBytes':'H', # bytes per row, plus 0x8000
'bounds':'hhhh', # coordinates imposed over pixel data
'top':'h',
'left':'h',
'bottom':'h',
'right':'h',
'pmVersion':'h', # flags for Color QuickDraw
'packType':'h', # format of compression algorithm
'packSize':'l', # size after compression
'hRes':'l', # horizontal pixels per inch
'vRes':'l', # vertical pixels per inch
'pixelType':'h', # pixel format
'pixelSize':'h', # bits per pixel
'cmpCount':'h', # color components per pixel
'cmpSize':'h', # bits per component
'planeBytes':'l', # offset in bytes to next plane
'pmTable':'l', # handle to color table
'pmReserved':'l' # reserved for future use
}
# PixMap data structure element offset
_pmElemOffset = {
'baseAddr':0,
'rowBytes':4,
'bounds':6,
'top':6,
'left':8,
'bottom':10,
'right':12,
'pmVersion':14,
'packType':16,
'packSize':18,
'hRes':22,
'vRes':26,
'pixelType':30,
'pixelSize':32,
'cmpCount':34,
'cmpSize':36,
'planeBytes':38,
'pmTable':42,
'pmReserved':46
}
class PixMapWrapper:
"""PixMapWrapper -- wraps the QD PixMap object in a Python class,
with methods to easily get/set various pixmap fields. Note: Use the
PixMap() method when passing to QD calls."""
def __init__(self):
self.__dict__['data'] = ''
self._header = struct.pack("lhhhhhhhlllhhhhlll",
id(self.data)+MacOS.string_id_to_buffer,
0, # rowBytes
0, 0, 0, 0, # bounds
0, # pmVersion
0, 0, # packType, packSize
72<<16, 72<<16, # hRes, vRes
QuickDraw.RGBDirect, # pixelType
16, # pixelSize
2, 5, # cmpCount, cmpSize,
0, 0, 0) # planeBytes, pmTable, pmReserved
self.__dict__['_pm'] = Qd.RawBitMap(self._header)
def _stuff(self, element, bytes):
offset = _pmElemOffset[element]
fmt = _pmElemFormat[element]
self._header = self._header[:offset] \
+ struct.pack(fmt, bytes) \
+ self._header[offset + struct.calcsize(fmt):]
self.__dict__['_pm'] = None
def _unstuff(self, element):
offset = _pmElemOffset[element]
fmt = _pmElemFormat[element]
return struct.unpack(fmt, self._header[offset:offset+struct.calcsize(fmt)])[0]
def __setattr__(self, attr, val):
if attr == 'baseAddr':
raise 'UseErr', "don't assign to .baseAddr -- assign to .data instead"
elif attr == 'data':
self.__dict__['data'] = val
self._stuff('baseAddr', id(self.data) + MacOS.string_id_to_buffer)
elif attr == 'rowBytes':
# high bit is always set for some odd reason
self._stuff('rowBytes', val | 0x8000)
elif attr == 'bounds':
# assume val is in official Left, Top, Right, Bottom order!
self._stuff('left',val[0])
self._stuff('top',val[1])
self._stuff('right',val[2])
self._stuff('bottom',val[3])
elif attr == 'hRes' or attr == 'vRes':
# 16.16 fixed format, so just shift 16 bits
self._stuff(attr, int(val) << 16)
elif attr in _pmElemFormat.keys():
# any other pm attribute -- just stuff
self._stuff(attr, val)
else:
self.__dict__[attr] = val
def __getattr__(self, attr):
if attr == 'rowBytes':
# high bit is always set for some odd reason
return self._unstuff('rowBytes') & 0x7FFF
elif attr == 'bounds':
# return bounds in official Left, Top, Right, Bottom order!
return ( \
self._unstuff('left'),
self._unstuff('top'),
self._unstuff('right'),
self._unstuff('bottom') )
elif attr == 'hRes' or attr == 'vRes':
# 16.16 fixed format, so just shift 16 bits
return self._unstuff(attr) >> 16
elif attr in _pmElemFormat.keys():
# any other pm attribute -- just unstuff
return self._unstuff(attr)
else:
return self.__dict__[attr]
def PixMap(self):
"Return a QuickDraw PixMap corresponding to this data."
if not self.__dict__['_pm']:
self.__dict__['_pm'] = Qd.RawBitMap(self._header)
return self.__dict__['_pm']
def blit(self, x1=0,y1=0,x2=None,y2=None, port=None):
"""Draw this pixmap into the given (default current) grafport."""
src = self.bounds
dest = [x1,y1,x2,y2]
if x2 == None:
dest[2] = x1 + src[2]-src[0]
if y2 == None:
dest[3] = y1 + src[3]-src[1]
if not port: port = Qd.GetPort()
Qd.CopyBits(self.PixMap(), port.portBits, src, tuple(dest),
QuickDraw.srcCopy, None)
def fromstring(self,s,width,height,format=imgformat.macrgb):
"""Stuff this pixmap with raw pixel data from a string.
Supply width, height, and one of the imgformat specifiers."""
# we only support 16- and 32-bit mac rgb...
# so convert if necessary
if format != imgformat.macrgb and format != imgformat.macrgb16:
# (LATER!)
raise "NotImplementedError", "conversion to macrgb or macrgb16"
self.data = s
self.bounds = (0,0,width,height)
self.cmpCount = 3
self.pixelType = QuickDraw.RGBDirect
if format == imgformat.macrgb:
self.pixelSize = 32
self.cmpSize = 8
else:
self.pixelSize = 16
self.cmpSize = 5
self.rowBytes = width*self.pixelSize/8
def tostring(self, format=imgformat.macrgb):
"""Return raw data as a string in the specified format."""
# is the native format requested? if so, just return data
if (format == imgformat.macrgb and self.pixelSize == 32) or \
(format == imgformat.macrgb16 and self.pixelsize == 16):
return self.data
# otherwise, convert to the requested format
# (LATER!)
raise "NotImplementedError", "data format conversion"
def fromImage(self,im):
"""Initialize this PixMap from a PIL Image object."""
# We need data in ARGB format; PIL can't currently do that,
# but it can do RGBA, which we can use by inserting one null
# up frontpm =
if im.mode != 'RGBA': im = im.convert('RGBA')
data = chr(0) + im.tostring()
self.fromstring(data, im.size[0], im.size[1])
def toImage(self):
"""Return the contents of this PixMap as a PIL Image object."""
import Image
# our tostring() method returns data in ARGB format,
# whereas Image uses RGBA; a bit of slicing fixes this...
data = self.tostring()[1:] + chr(0)
bounds = self.bounds
return Image.fromstring('RGBA',(bounds[2]-bounds[0],bounds[3]-bounds[1]),data)
def test():
import MacOS
import macfs
import Image
fsspec, ok = macfs.PromptGetFile("Image File:")
if not ok: return
path = fsspec.as_pathname()
pm = PixMapWrapper()
pm.fromImage( Image.open(path) )
pm.blit(20,20)
return pm
|
