easy_thumbnails.processors: 113 total statements, 0.0% covered

Generated: Wed 2013-03-13 10:33 CET

Source file: /media/Envs/Envs/filer-gallery/lib/python2.7/site-packages/easy_thumbnails/processors.py

Stats: 0 executed, 107 missed, 6 excluded, 122 ignored

1. import re
3. try:
4. from PIL import Image, ImageChops, ImageFilter
5. except ImportError:
6. import Image
7. import ImageChops
8. import ImageFilter
9. from easy_thumbnails import utils
12. def _compare_entropy(start_slice, end_slice, slice, difference):
13. """
14. Calculate the entropy of two slices (from the start and end of an axis),
15. returning a tuple containing the amount that should be added to the start
16. and removed from the end of the axis.
18. """
19. start_entropy = utils.image_entropy(start_slice)
20. end_entropy = utils.image_entropy(end_slice)
21. if end_entropy and abs(start_entropy / end_entropy - 1) < 0.01:
22. # Less than 1% difference, remove from both sides.
23. if difference >= slice * 2:
24. return slice, slice
25. half_slice = slice // 2
26. return half_slice, slice - half_slice
27. if start_entropy > end_entropy:
28. return 0, slice
29. else:
30. return slice, 0
33. def colorspace(im, bw=False, replace_alpha=False, **kwargs):
34. """
35. Convert images to the correct color space.
37. A passive option (i.e. always processed) of this method is that all images
38. (unless grayscale) are converted to RGB colorspace.
40. This processor should be listed before :func:`scale_and_crop` so palette is
41. changed before the image is resized.
43. bw
44. Make the thumbnail grayscale (not really just black & white).
46. replace_alpha
47. Replace any transparency layer with a solid color. For example,
48. ``replace_alpha='#fff'`` would replace the transparency layer with
49. white.
51. """
52. is_transparent = utils.is_transparent(im)
53. if bw:
54. if im.mode in ('L', 'LA'):
55. return im
56. if is_transparent:
57. return im.convert('LA')
58. else:
59. return im.convert('L')
61. if im.mode in ('L', 'RGB'):
62. return im
64. if is_transparent:
65. if im.mode != 'RGBA':
66. im = im.convert('RGBA')
67. if not replace_alpha:
68. return im
69. base = Image.new('RGBA', im.size, replace_alpha)
70. base.paste(im)
71. im = base
73. return im.convert('RGB')
76. def autocrop(im, autocrop=False, **kwargs):
77. """
78. Remove any unnecessary whitespace from the edges of the source image.
80. This processor should be listed before :func:`scale_and_crop` so the
81. whitespace is removed from the source image before it is resized.
83. autocrop
84. Activates the autocrop method for this image.
86. """
87. if autocrop:
88. bw = im.convert('1')
89. bw = bw.filter(ImageFilter.MedianFilter)
90. # White background.
91. bg = Image.new('1', im.size, 255)
92. diff = ImageChops.difference(bw, bg)
93. bbox = diff.getbbox()
94. if bbox:
95. im = im.crop(bbox)
96. return im
99. def scale_and_crop(im, size, crop=False, upscale=False, **kwargs):
100. """
101. Handle scaling and cropping the source image.
103. Images can be scaled / cropped against a single dimension by using zero
104. as the placeholder in the size. For example, ``size=(100, 0)`` will cause
105. the image to be resized to 100 pixels wide, keeping the aspect ratio of
106. the source image.
108. crop
109. Crop the source image height or width to exactly match the requested
110. thumbnail size (the default is to proportionally resize the source
111. image to fit within the requested thumbnail size).
113. By default, the image is centered before being cropped. To crop from
114. the edges, pass a comma separated string containing the ``x`` and ``y``
115. percentage offsets (negative values go from the right/bottom). Some
116. examples follow:
118. * ``crop="0,0"`` will crop from the left and top edges.
120. * ``crop="-10,-0"`` will crop from the right edge (with a 10% offset)
121. and the bottom edge.
123. * ``crop=",0"`` will keep the default behavior for the x axis
124. (horizontally centering the image) and crop from the top edge.
126. The image can also be "smart cropped" by using ``crop="smart"``. The
127. image is incrementally cropped down to the requested size by removing
128. slices from edges with the least entropy.
130. Finally, you can use ``crop="scale"`` to simply scale the image so that
131. at least one dimension fits within the size dimensions given (you may
132. want to use the upscale option too).
134. upscale
135. Allow upscaling of the source image during scaling.
137. """
138. source_x, source_y = [float(v) for v in im.size]
139. target_x, target_y = [float(v) for v in size]
141. if crop or not target_x or not target_y:
142. scale = max(target_x / source_x, target_y / source_y)
143. else:
144. scale = min(target_x / source_x, target_y / source_y)
146. # Handle one-dimensional targets.
147. if not target_x:
148. target_x = source_x * scale
149. elif not target_y:
150. target_y = source_y * scale
152. if scale < 1.0 or (scale > 1.0 and upscale):
153. # Resize the image to the target size boundary. Round the scaled
154. # boundary sizes to avoid floating point errors.
155. im = im.resize((int(round(source_x * scale)),
156. int(round(source_y * scale))),
157. resample=Image.ANTIALIAS)
159. if crop:
160. # Use integer values now.
161. source_x, source_y = im.size
162. # Difference between new image size and requested size.
163. diff_x = int(source_x - min(source_x, target_x))
164. diff_y = int(source_y - min(source_y, target_y))
165. if diff_x or diff_y:
166. # Center cropping (default).
167. halfdiff_x, halfdiff_y = diff_x // 2, diff_y // 2
168. box = [halfdiff_x, halfdiff_y,
169. min(source_x, int(target_x) + halfdiff_x),
170. min(source_y, int(target_y) + halfdiff_y)]
171. # See if an edge cropping argument was provided.
172. edge_crop = (isinstance(crop, basestring) and
173. re.match(r'(?:(-?)(\d+))?,(?:(-?)(\d+))?$', crop))
174. if edge_crop and filter(None, edge_crop.groups()):
175. x_right, x_crop, y_bottom, y_crop = edge_crop.groups()
176. if x_crop:
177. offset = min(int(target_x) * int(x_crop) // 100, diff_x)
178. if x_right:
179. box[0] = diff_x - offset
180. box[2] = source_x - offset
181. else:
182. box[0] = offset
183. box[2] = source_x - (diff_x - offset)
184. if y_crop:
185. offset = min(int(target_y) * int(y_crop) // 100, diff_y)
186. if y_bottom:
187. box[1] = diff_y - offset
188. box[3] = source_y - offset
189. else:
190. box[1] = offset
191. box[3] = source_y - (diff_y - offset)
192. # See if the image should be "smart cropped".
193. elif crop == 'smart':
194. left = top = 0
195. right, bottom = source_x, source_y
196. while diff_x:
197. slice = min(diff_x, max(diff_x // 5, 10))
198. start = im.crop((left, 0, left + slice, source_y))
199. end = im.crop((right - slice, 0, right, source_y))
200. add, remove = _compare_entropy(start, end, slice, diff_x)
201. left += add
202. right -= remove
203. diff_x = diff_x - add - remove
204. while diff_y:
205. slice = min(diff_y, max(diff_y // 5, 10))
206. start = im.crop((0, top, source_x, top + slice))
207. end = im.crop((0, bottom - slice, source_x, bottom))
208. add, remove = _compare_entropy(start, end, slice, diff_y)
209. top += add
210. bottom -= remove
211. diff_y = diff_y - add - remove
212. box = (left, top, right, bottom)
213. # Finally, crop the image!
214. if crop != 'scale':
215. im = im.crop(box)
216. return im
219. def filters(im, detail=False, sharpen=False, **kwargs):
220. """
221. Pass the source image through post-processing filters.
223. sharpen
224. Sharpen the thumbnail image (using the PIL sharpen filter)
226. detail
227. Add detail to the image, like a mild *sharpen* (using the PIL
228. ``detail`` filter).
230. """
231. if detail:
232. im = im.filter(ImageFilter.DETAIL)
233. if sharpen:
234. im = im.filter(ImageFilter.SHARPEN)
235. return im