recopie de OFS.Image pour remettre le support des blobs sur une base clean.
[Photo.git] / Photo.py
1 # -*- coding: utf-8 -*-
2 #######################################################################################
3 # Photo is a part of Plinn - http://plinn.org #
4 # Copyright (C) 2004-2007 Benoît PIN <benoit.pin@ensmp.fr> #
5 # #
6 # This program is free software; you can redistribute it and/or #
7 # modify it under the terms of the GNU General Public License #
8 # as published by the Free Software Foundation; either version 2 #
9 # of the License, or (at your option) any later version. #
10 # #
11 # This program is distributed in the hope that it will be useful, #
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of #
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
14 # GNU General Public License for more details. #
15 # #
16 # You should have received a copy of the GNU General Public License #
17 # along with this program; if not, write to the Free Software #
18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. #
19 #######################################################################################
20 """ Photo zope object
21
22 $Id: Photo.py 1281 2009-08-13 10:44:40Z pin $
23 $URL: http://svn.luxia.fr/svn/labo/projects/zope/Photo/trunk/Photo.py $
24 """
25
26 from Globals import InitializeClass, DTMLFile
27 from AccessControl import ClassSecurityInfo
28 from AccessControl.Permissions import manage_properties, view
29 from metadata import Metadata
30 from TileSupport import TileSupport
31 from xmputils import TIFF_ORIENTATIONS
32 from BTrees.OOBTree import OOBTree
33 from cache import memoizedmethod
34
35 from blobbases import Image, cookId, getImageInfo
36 import PIL.Image
37 import string
38 from math import floor
39 from types import StringType
40 from logging import getLogger
41 console = getLogger('Photo.Photo')
42
43
44
45 def _strSize(size) :
46 return str(size[0]) + '_' + str(size[1])
47
48 def getNewSize(fullSize, maxNewSize) :
49 fullWidth, fullHeight = fullSize
50 maxWidth, maxHeight = maxNewSize
51
52 widthRatio = float(maxWidth) / fullWidth
53 if int(fullHeight * widthRatio) > maxWidth :
54 heightRatio = float(maxHeight) / fullHeight
55 return (int(fullWidth * heightRatio) , maxHeight)
56 else :
57 return (maxWidth, int(fullHeight * widthRatio))
58
59
60
61
62
63
64 class Photo(Image, TileSupport, Metadata):
65 "Photo éditable en ligne"
66
67 meta_type = 'Photo'
68
69 security = ClassSecurityInfo()
70
71 manage_editForm = DTMLFile('dtml/photoEdit',globals(),
72 Kind='Photo', kind='photo')
73 manage_editForm._setName('manage_editForm')
74 manage = manage_main = manage_editForm
75 view_image_or_file = DTMLFile('dtml/photoView',globals())
76
77 manage_options=(
78 {'label':'Edit', 'action':'manage_main',
79 'help':('OFSP','Image_Edit.stx')},
80 {'label':'View', 'action':'view_image_or_file',
81 'help':('OFSP','Image_View.stx')},) + Image.manage_options[2:]
82
83
84 filters = ['NEAREST', 'BILINEAR', 'BICUBIC', 'ANTIALIAS']
85
86 _properties = Image._properties[:2] + (
87 {'id' : 'height', 'type' : 'int', 'mode' : 'w'},
88 {'id' : 'width', 'type' : 'int', 'mode' : 'w'},
89 {'id' : 'auto_update_thumb', 'type' : 'boolean', 'mode' : 'w'},
90 {'id' : 'tiles_available', 'type' : 'int', 'mode' : 'r'},
91 {'id' : 'thumb_height', 'type' : 'int', 'mode' : 'w'},
92 {'id' : 'thumb_width', 'type' : 'int', 'mode' : 'w'},
93 {'id' : 'prop_filter',
94 'label' : 'Filter',
95 'type' : 'selection',
96 'select_variable' : 'filters',
97 'mode' : 'w'},
98 )
99
100
101 security.declareProtected(manage_properties, 'manage_editProperties')
102 def manage_editProperties(self, REQUEST=None, no_refresh = 0, **kw):
103 "Save Changes and update the thumbnail"
104 Image.manage_changeProperties(self, REQUEST, **kw)
105
106 if hasattr(self, 'thumbnail') and self.auto_update_thumb == 1 and no_refresh == 0 :
107 self.makeThumbnail()
108
109 if REQUEST:
110 message="Saved changes."
111 return self.manage_propertiesForm(self,REQUEST,
112 manage_tabs_message=message)
113
114
115 def __init__(self, id, title, file, content_type='', precondition='', **kw) :
116 # 0 means: tiles are not generated
117 # 1 means: tiles are all generated
118 # 2 means: tiling is not available is this photo (deliberated choice of the owner)
119 # -1 means: no data tiles cannot be generated
120 self.tiles_available = 0
121 super(Photo, self).__init__(id, title, file, content_type='', precondition='')
122
123 self.auto_update_thumb = kw.get('auto_update_thumb', 1)
124 self.thumb_height = kw.get('thumb_height', 180)
125 self.thumb_width = kw.get('thumb_width', 120)
126 self.prop_filter = kw.get('prop_filter', 'ANTIALIAS')
127
128 defaultBlankThumbnail = kw.get('defaultBlankThumbnail', None)
129 if defaultBlankThumbnail :
130 blankThumbnail = Image('thumbnail', '',
131 getattr(defaultBlankThumbnail, '_data', getattr(defaultBlankThumbnail, 'data', None)))
132 self.thumbnail = blankThumbnail
133
134 self._methodResultsCache = OOBTree()
135 TileSupport.__init__(self)
136
137 def update_data(self, file, content_type=None) :
138 super(Photo, self).update_data(file, content_type)
139
140 if self.content_type != 'image/jpeg' and self.size :
141 raw = self.open('r')
142 im = PIL.Image.open(raw)
143 self.content_type = 'image/%s' % im.format.lower()
144 self.width, self.height = im.size
145
146 if im.mode not in ('L', 'RGB'):
147 im = im.convert('RGB')
148
149 jpeg_image = Image('jpeg_image', '', '', content_type='image/jpeg')
150 out = jpeg_image.open('w')
151 im.save(out, 'JPEG', quality=90)
152 jpeg_image.updateFormat(out.tell(), im.size, 'image/jpeg')
153 out.close()
154 self.jpeg_image = jpeg_image
155
156 self._methodResultsCache = OOBTree()
157 self._v__methodResultsCache = OOBTree()
158
159 self._tiles = OOBTree()
160 if self.tiles_available in [1, -1]:
161 self.tiles_available = 0
162
163 if hasattr(self, 'thumbnail') and self.auto_update_thumb == 1 :
164 self.makeThumbnail()
165
166
167
168 def _getJpegBlob(self) :
169 if self.size :
170 if self.content_type == 'image/jpeg' :
171 return self.bdata
172 else :
173 return self.jpeg_image.bdata
174 else :
175 return None
176
177 security.declareProtected(view, 'getJpegImage')
178 def getJpegImage(self, REQUEST, RESPONSE) :
179 """ return JPEG formated image """
180 if self.content_type == 'image/jpeg' :
181 return self.index_html(REQUEST, RESPONSE)
182 elif self.jpeg_image :
183 return self.jpeg_image.index_html(REQUEST, RESPONSE)
184
185 security.declareProtected(view, 'tiffOrientation')
186 @memoizedmethod()
187 def tiffOrientation(self) :
188 tiffOrientation = self.getXmpValue('tiff:Orientation')
189 if tiffOrientation :
190 return int(tiffOrientation)
191 else :
192 # TODO : falling back to legacy Exif metadata
193 return 1
194
195 def _rotateOrFlip(self, im) :
196 orientation = self.tiffOrientation()
197 rotation, flip = TIFF_ORIENTATIONS.get(orientation, (0, False))
198 if rotation :
199 im = im.rotate(-rotation)
200 if flip :
201 im = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)
202 return im
203
204 @memoizedmethod('size', 'keepAspectRatio')
205 def _getResizedImage(self, size, keepAspectRatio) :
206 """ returns a resized version of the raw image.
207 """
208
209 fullSizeFile = self._getJpegBlob().open('r')
210 fullSizeImage = PIL.Image.open(fullSizeFile)
211 if fullSizeImage.mode not in ('L', 'RGB'):
212 fullSizeImage.convert('RGB')
213 fullSize = fullSizeImage.size
214
215 if (keepAspectRatio) :
216 newSize = getNewSize(fullSize, size)
217 else :
218 newSize = size
219
220 fullSizeImage.thumbnail(newSize, PIL.Image.ANTIALIAS)
221 fullSizeImage = self._rotateOrFlip(fullSizeImage)
222
223 for hook in self._getAfterResizingHooks() :
224 hook(self, fullSizeImage)
225
226
227 resizedImage = Image(self.getId() + _strSize(size), 'resized copy of %s' % self.getId(), '')
228 out = resizedImage.open('w')
229 fullSizeImage.save(out, "JPEG", quality=90)
230 resizedImage.updateFormat(out.tell(), fullSizeImage.size, 'image/jpeg')
231 out.close()
232 return resizedImage
233
234 def _getAfterResizingHooks(self) :
235 """ returns a list of hook scripts that are executed
236 after the image is resized.
237 """
238 return []
239
240
241 security.declarePrivate('makeThumbnail')
242 def makeThumbnail(self) :
243 "make a thumbnail from jpeg data"
244 b = self._getJpegBlob()
245 if b is not None :
246 # récupération des propriétés de redimentionnement
247 thumb_size = []
248 if int(self.width) >= int(self.height) :
249 thumb_size.append(self.thumb_height)
250 thumb_size.append(self.thumb_width)
251 else :
252 thumb_size.append(self.thumb_width)
253 thumb_size.append(self.thumb_height)
254 thumb_size = tuple(thumb_size)
255
256 if thumb_size[0] <= 1 or thumb_size[1] <= 1 :
257 thumb_size = (180, 180)
258 thumb_filter = getattr(PIL.Image, self.prop_filter, PIL.Image.ANTIALIAS)
259
260 # create a thumbnail image file
261 original_file = b.open('r')
262 image = PIL.Image.open(original_file)
263 if image.mode not in ('L', 'RGB'):
264 image = image.convert('RGB')
265
266 image.thumbnail(thumb_size, thumb_filter)
267 image = self._rotateOrFlip(image)
268
269 thumbnail = Image('thumbnail', 'Thumbail', '', 'image/jpeg')
270 out = thumbnail.open('w')
271 image.save(out, "JPEG", quality=90)
272 thumbnail.updateFormat(out.tell(), image.size, 'image/jpeg')
273 out.close()
274 original_file.close()
275 self.thumbnail = thumbnail
276 return True
277 else :
278 return False
279
280 security.declareProtected(view, 'getThumbnail')
281 def getThumbnail(self, REQUEST, RESPONSE) :
282 "Return the thumbnail image and create it before if it does not exist yet."
283 if not hasattr(self, 'thumbnail') :
284 self.makeThumbnail()
285 return self.thumbnail.index_html(REQUEST=REQUEST, RESPONSE=RESPONSE)
286
287 security.declareProtected(view, 'getThumbnailSize')
288 def getThumbnailSize(self) :
289 """ return thumbnail size dict
290 """
291 if not hasattr(self, 'thumbnail') :
292 if not self.width :
293 return {'height' : 0, 'width' : 0}
294 else :
295 thumbMaxFrame = []
296 if int(self.width) >= int(self.height) :
297 thumbMaxFrame.append(self.thumb_height)
298 thumbMaxFrame.append(self.thumb_width)
299 else :
300 thumbMaxFrame.append(self.thumb_width)
301 thumbMaxFrame.append(self.thumb_height)
302 thumbMaxFrame = tuple(thumbMaxFrame)
303
304 if thumbMaxFrame[0] <= 1 or thumbMaxFrame[1] <= 1 :
305 thumbMaxFrame = (180, 180)
306
307 th = self.height * thumbMaxFrame[0] / float(self.width)
308 # resizing round limit is not 0.5 but seems to be strictly up to 0.75
309 # TODO check algorithms
310 if th > floor(th) + 0.75 :
311 th = int(floor(th)) + 1
312 else :
313 th = int(floor(th))
314
315 if th <= thumbMaxFrame[1] :
316 thumbSize = (thumbMaxFrame[0], th)
317 else :
318 tw = self.width * thumbMaxFrame[1] / float(self.height)
319 if tw > floor(tw) + 0.75 :
320 tw = int(floor(tw)) + 1
321 else :
322 tw = int(floor(tw))
323 thumbSize = (tw, thumbMaxFrame[1])
324
325 if self.tiffOrientation() <= 4 :
326 return {'width':thumbSize[0], 'height' : thumbSize[1]}
327 else :
328 return {'width':thumbSize[1], 'height' : thumbSize[0]}
329
330 else :
331 return {'height' : self.thumbnail.height, 'width' :self.thumbnail.width}
332
333
334 security.declareProtected(view, 'getResizedImageSize')
335 def getResizedImageSize(self, REQUEST=None, size=(), keepAspectRatio=True, asXml=False) :
336 """ return the reel image size the after resizing """
337 if not size :
338 size = REQUEST.SESSION.get('preferedImageSize', (600, 600))
339 elif type(size) == StringType :
340 size = tuple([int(n) for n in size.split('_')])
341
342 resizedImage = self._getResizedImage(size, keepAspectRatio)
343 size = (resizedImage.width, resizedImage.height)
344
345 if asXml :
346 REQUEST.RESPONSE.setHeader('content-type', 'text/xml; charset=utf-8')
347 return '<size><width>%d</width><height>%d</height></size>' % size
348 else :
349 return size
350
351
352 security.declareProtected(view, 'getResizedImage')
353 def getResizedImage(self, REQUEST, RESPONSE, size=(), keepAspectRatio=True) :
354 """
355 Return a volatile resized image.
356 The 'preferedImageSize' tuple (width, height) is looked up into SESSION data.
357 Default size is 600 x 600 px
358 """
359 if not size :
360 size = REQUEST.SESSION.get('preferedImageSize', (600, 600))
361 elif type(size) == StringType :
362 size = size.split('_')
363 if len(size) == 1 :
364 i = int(size[0])
365 size = (i, i)
366 keepAspectRatio = True
367 else :
368 size = tuple([int(n) for n in size])
369
370 return self._getResizedImage(size, keepAspectRatio).index_html(REQUEST=REQUEST, RESPONSE=RESPONSE)
371
372
373 InitializeClass(Photo)
374
375
376 # Factories
377 def addPhoto(dispatcher, id, file='', title='',
378 precondition='', content_type='', REQUEST=None, **kw) :
379 """
380 Add a new Photo object.
381 Creates a new Photo object 'id' with the contents of 'file'.
382 """
383 id=str(id)
384 title=str(title)
385 content_type=str(content_type)
386 precondition=str(precondition)
387
388 id, title = cookId(id, title, file)
389 parentContainer = dispatcher.Destination()
390
391 parentContainer._setObject(id, Photo(id,title,file,content_type, precondition, **kw))
392
393 if REQUEST is not None:
394 try: url=dispatcher.DestinationURL()
395 except: url=REQUEST['URL1']
396 REQUEST.RESPONSE.redirect('%s/manage_main' % url)
397 return id
398
399 # creation form
400 addPhotoForm = DTMLFile('dtml/addPhotoForm', globals())