def green_key(canvas,key_image,img_source,mtype=KEY_REG):
s3 = key_image.split()
mask = (s3[1].point(lambda i: (i > 254 or 256))) # cut out green area (overlay)
if(mtype == KEY_BLUR or mtype == KEY_BLUR_BRIGHT or mtype == KEY_BLUR_BRIGHT_MORE):
mask = mask.filter(ImageFilter.SMOOTH_MORE)
mask = mask.filter(ImageFilter.BLUR)
mask = mask.filter(ImageFilter.SMOOTH_MORE)
if(mtype == KEY_BLUR_BRIGHT):
mask = (mask.point(lambda k: (k*2)))
elif(mtype == KEY_BLUR_BRIGHT_MORE):
mask = (mask.point(lambda k: k > 20 and (k*k)))
# mask.show()
# mask.save("images/saved/mask.jpg")
# canvas.convert("RGBA") # needed?
if(canvas.size != img_source.size): # fix image size
if(canvas.size < img_source.size):
print "resizing canvas", canvas.size, img_source.size, key_image.size
canvas = ImageOps.fit(canvas,img_source.size)
else:
print "resizing img_source and mask", canvas.size, img_source.size, key_image.size
img_source = ImageOps.fit(img_source,canvas.size)
mask = ImageOps.fit(mask,canvas.size)
image = Image.composite(img_source,canvas,mask)
return image
def green_key(canvas, key_image, img_source, mtype=KEY_REG):
s3 = key_image.split()
mask = (s3[1].point(lambda i: (i > 254 or 256))
) # cut out green area (overlay)
if (mtype == KEY_BLUR or mtype == KEY_BLUR_BRIGHT
or mtype == KEY_BLUR_BRIGHT_MORE):
mask = mask.filter(ImageFilter.SMOOTH_MORE)
mask = mask.filter(ImageFilter.BLUR)
mask = mask.filter(ImageFilter.SMOOTH_MORE)
if (mtype == KEY_BLUR_BRIGHT):
mask = (mask.point(lambda k: (k * 2)))
elif (mtype == KEY_BLUR_BRIGHT_MORE):
mask = (mask.point(lambda k: k > 20 and (k * k)))
# mask.show()
# mask.save("images/saved/mask.jpg")
# canvas.convert("RGBA") # needed?
if (canvas.size != img_source.size): # fix image size
if (canvas.size < img_source.size):
print "resizing canvas", canvas.size, img_source.size, key_image.size
canvas = ImageOps.fit(canvas, img_source.size)
else:
print "resizing img_source and mask", canvas.size, img_source.size, key_image.size
img_source = ImageOps.fit(img_source, canvas.size)
mask = ImageOps.fit(mask, canvas.size)
image = Image.composite(img_source, canvas, mask)
return image
def resizeImage(self, file_path, th_width = 200, th_height = 200, or_width = 1000, or_height = 800):
image = Image.open(file_path)
# Crop and make thumbnails
thumb = ImageOps.fit(image, (th_width, th_height), Image.ANTIALIAS)
thumb64 = ImageOps.fit(image, (64, 64), Image.ANTIALIAS)
# Resize original
image.thumbnail((or_width, or_height), Image.ANTIALIAS)
old_filename = file_path.rsplit('/', 1)[1]
thumb_filename = old_filename.rsplit('.', 1)[0] + "_thumb.jpg"
thumb_filename = thumb_filename.replace(" ", "_")
new_filename = thumb_filename.replace(" ", "_")
thumb.save(self.THUMB_DIR + thumb_filename, "JPEG", quality=100)
thumb64.save(self.THUMB64_DIR + thumb_filename, "JPEG", quality=100)
image.save(self.NEW_ORIGINAL_DIR + new_filename, "JPEG", quality=100)
return {
'original': old_filename,
'new_original': new_filename,
'thumbnail': thumb_filename
}
def resize(relative_path, size, method):
image_file = os.path.join(settings.MEDIA_ROOT, relative_path)
relative_resized_path = resized_path(relative_path, size, method)
resized_file = os.path.join(settings.MEDIA_ROOT, relative_resized_path)
relative_url = os.path.join(settings.MEDIA_URL, relative_resized_path)
# Parse size string 'WIDTHxHEIGHT'
width, height = [int(i) for i in size.split('x')]
if os.path.exists(resized_file):
return relative_url
try:
image = Image.open(image_file)
except:
return settings.STATIC_URL + 'g/blank.png'
if image.mode != 'RGB':
image = image.convert('RGB')
# use PIL methods to edit images
if method == 'scale':
image.thumbnail((width, height), Image.ANTIALIAS)
image.save(resized_file, FORMAT, quality=QUALITY)
elif method == 'crop':
ImageOps.fit(image, (width, height), Image.ANTIALIAS).save(
resized_file, FORMAT, quality=QUALITY)
return relative_url
def update(self, control):
Effect.update(self, control)
img = Image.new("RGB", self.providers[0].size)
src_img = self.providers[0].getImage(self.currentFrame)
size = self.providers[0].size
x = 0
for i in range(self.sliceCount):
w = int(size[0] * (float(self.percentages[i]) / float(100)))
l = x
x += w
r = x
if i > self.__current_slice:
tmpimg = ImageOps.fit(src_img, (w,img.size[1]))
img.paste(tmpimg, (l,0,r,tmpimg.size[1]))
if i == self.__current_slice + 1:
self.__end_x = l
if self.__current_slice >= 0:
start_x = int(self.__x)
# paste left half
tmpimg = ImageOps.fit(src_img, (start_x, img.size[1]))
img.paste(tmpimg, (0,0,start_x, tmpimg.size[1]))
# paste right half
tmpimg = ImageOps.fit(src_img, ((self.__end_x - start_x), img.size[1]))
img.paste(tmpimg, (start_x, 0, self.__end_x, tmpimg.size[1]))
#self.__x += int(self.step_size[self.__current_slice])
self.__x += self.__step_size
if self.__x >= self.pixels[self.__current_slice]:
self.__x = 0.00
self.__current_slice -= 1
self.keeper.setImage(img)
def generate_thumbnail(path, size, method):
try:
import Image
except ImportError:
try:
from PIL import Image
except ImportError:
raise ImportError('Cannot import the Python Image Library.')
image = Image.open(path)
# normalize image mode
if image.mode != 'RGB':
image = image.convert('RGB')
# parse size string 'WIDTHxHEIGHT'
width, height = [int(i) for i in size.split('x')]
# use PIL methods to edit images
if method == 'scale':
image.thumbnail((width, height), Image.ANTIALIAS)
image.save(thumbnail_path(path, size, method), MEDIA_IMAGE_FORMAT, quality=MEDIA_IMAGE_QUALITY)
elif method == 'crop':
try:
import ImageOps
except ImportError:
from PIL import ImageOps
ImageOps.fit(
image, (width, height), Image.ANTIALIAS
).save(thumbnail_path(path, size, method), MEDIA_IMAGE_FORMAT, quality=MEDIA_IMAGE_QUALITY)
def _store_image_and_transformations(self, original):
self._store_image(original)
self._store_image(
original, 'thumbnail', lambda
(image): ImageOps.fit(image, (260, 260), Image.ANTIALIAS))
self._store_image(
original, 'large', lambda
(image): ImageOps.fit(image, (612, 612), Image.ANTIALIAS))
def uploadBkgImg(Bkgpic, oldname, newname):
try:
Bkgpicname = newname
'Save tmp file'
tmp_filepath = "atv/tmp/bkg/" + Bkgpicname
tmp_output_file = open(tmp_filepath, 'wb')
Bkgpic.seek(0)
while True:
data = Bkgpic.read(2 << 16)
if not data:
break
tmp_output_file.write(data)
tmp_output_file.close()
'resize'
size = 942, 225
im = Image.open(tmp_filepath)
im = ImageOps.fit(im, size, Image.ANTIALIAS)
im.save(tmp_filepath, "PNG")
'Save main img to S3'
k = Key(b)
k.key = "permbks/" + Bkgpicname
k.set_contents_from_filename(tmp_filepath, policy='public-read')
'resize mini'
size = 230, 55
im = Image.open(tmp_filepath)
im = ImageOps.fit(im, size, Image.ANTIALIAS)
im.save(tmp_filepath, "PNG")
'Save main mini img to S3'
k = Key(b)
k.key = "minipermbks/" + Bkgpicname
k.set_contents_from_filename(tmp_filepath, policy='public-read')
'delete tmp file'
os.remove(tmp_filepath)
status = ""
'delete old img files'
do_not_delete_list = [
"birdbox.png", "blueflower.png", "cars.png", "cartographer.png",
"default.png", "elastoplast.png", "fireheart.png", "food.png",
"glammer.png", "greyfloral.png", "knittednetting.png",
"molten.png", "norwegianrose.png", "pineapple.png",
"purplecrown.png", "reddrop.png", "redflower.png", "retroleaf.png",
"seamless.png", "shattered.png", "stardust.png", "stripes.png",
"whitebrick.png", "wood.png"
]
if oldname in do_not_delete_list:
pass
else:
k = Key(b)
k.key = "permbks/" + oldname
b.delete_key(k)
k = Key(b)
k.key = "minipermbks/" + oldname
b.delete_key(k)
return status
except:
status = """File could not be uploaded - please check the file extension
and try again."""
return status
def scale(imagefield, method='scale'):
"""
Template filter used to scale an image
that will fit inside the defined area.
Returns the url of the resized image.
{% load image_tags %}
{{ profile.picture|scale }}
"""
if not imagefield:
return None
# imagefield can be a dict with "path" and "url" keys
if imagefield.__class__.__name__ == 'dict':
imagefield = type('imageobj', (object,), imagefield)
image_path = resized_path(imagefield.path, method)
#thumb_path = os.path.join(settings.MEDIA_ROOT, "%s_%s_%s.%s" % (imagefield.name.rsplit('.', 1)[0], method, EXT))
#thumb_url = "%s_%s_%s.%s" % (imagefield.url.rsplit('.', 1)[0], method, EXT)
#print thumb_path, thumb_url
if not os.path.exists(image_path):
try:
import Image
except ImportError:
try:
from PIL import Image
except ImportError:
raise ImportError('Cannot import the Python Image Library.')
image = Image.open(imagefield.path)
# normalize image mode
if image.mode != 'RGB':
image = image.convert('RGB')
# use PIL methods to edit images
if method == 'scale':
width, height = [int(i) for i in IMAGE_SIZE.split('x')]
image.thumbnail((width, height), Image.ANTIALIAS)
image.save(image_path, FMT, quality=QUAL)
elif method == 'crop':
try:
import ImageOps
except ImportError:
from PIL import ImageOps
width, height = [int(i) for i in THUMBNAIL_SIZE.split('x')]
ImageOps.fit(image, (width, height), Image.ANTIALIAS
).save(image_path, FMT, quality=QUAL)
return resized_path(imagefield.url, method)
def uploadBkgImg(Bkgpic, oldname, newname):
try:
Bkgpicname = newname
'Save tmp file'
tmp_filepath = "atv/tmp/bkg/" + Bkgpicname
tmp_output_file = open(tmp_filepath, 'wb')
Bkgpic.seek(0)
while True:
data = Bkgpic.read(2<<16)
if not data:
break
tmp_output_file.write(data)
tmp_output_file.close()
'resize'
size = 942, 225
im = Image.open(tmp_filepath)
im = ImageOps.fit(im, size, Image.ANTIALIAS)
im.save(tmp_filepath, "PNG")
'Save main img to S3'
k = Key(b)
k.key = "permbks/" + Bkgpicname
k.set_contents_from_filename(tmp_filepath, policy='public-read')
'resize mini'
size = 230, 55
im = Image.open(tmp_filepath)
im = ImageOps.fit(im, size, Image.ANTIALIAS)
im.save(tmp_filepath, "PNG")
'Save main mini img to S3'
k = Key(b)
k.key = "minipermbks/" + Bkgpicname
k.set_contents_from_filename(tmp_filepath, policy='public-read')
'delete tmp file'
os.remove(tmp_filepath)
status = ""
'delete old img files'
do_not_delete_list=["birdbox.png","blueflower.png","cars.png","cartographer.png","default.png","elastoplast.png",
"fireheart.png","food.png","glammer.png","greyfloral.png","knittednetting.png","molten.png",
"norwegianrose.png","pineapple.png","purplecrown.png","reddrop.png","redflower.png","retroleaf.png",
"seamless.png","shattered.png","stardust.png","stripes.png","whitebrick.png","wood.png"]
if oldname in do_not_delete_list:
pass
else:
k = Key(b)
k.key = "permbks/" + oldname
b.delete_key(k)
k = Key(b)
k.key = "minipermbks/" + oldname
b.delete_key(k)
return status
except:
status = """File could not be uploaded - please check the file extension
and try again."""
return status
def resizeImage(self, buffer_filepath, local_filepath, params, cropped_image = False):
image = Image.open(buffer_filepath)
width, height = image.size
imgData = {
"width" : width,
"height": height
}
need_resize = False
createSmallItemSpell = False
if "type_of_form" in params and params['type_of_form'] == "create_artwork":
checkWidth = self.core.MAX_ARTWORK_WIDTH
checkHeight = self.core.MAX_ARTWORK_HEIGHT
elif "type_of_form" in params and (params['type_of_form'] == "create_item" or params['type_of_form'] == "create_spell"):
checkWidth = self.core.MAX_ITEM_SPELL_WIDTH
checkHeight = self.core.MAX_ITEM_SPELL_HEIGHT
createSmallItemSpell = True
else:
checkWidth = self.core.MAX_AVA_WIDTH
checkHeight = self.core.MAX_AVA_HEIGHT
if width > checkWidth:
width = checkWidth
need_resize = True
if height > checkHeight:
height = checkHeight
need_resize = True
#need_resize = False
if need_resize:
if params['type_of_form'] == "create_artwork":
thumb = ImageOps.fit(cropped_image, (self.core.THUMB_ARTWORK_WIDTH, self.core.THUMB_ARTWORK_HEIGHT), Image.ANTIALIAS)
else:
thumb = ImageOps.fit(cropped_image, (width,height), Image.ANTIALIAS)
thumb.save(local_filepath+"_fit.png", "PNG")
elif params['type_of_form'] == "create_artwork":
thumb = ImageOps.fit(cropped_image, (self.core.THUMB_ARTWORK_WIDTH, self.core.THUMB_ARTWORK_HEIGHT), Image.ANTIALIAS)
thumb.save(local_filepath+"_fit.png", "PNG")
else:
image.save(local_filepath+"_fit.png", "PNG")
if createSmallItemSpell:
thumb = ImageOps.fit(cropped_image, (self.core.THUMB_ITEM_SPELL_WIDTH, self.core.THUMB_ITEM_SPELL_HEIGHT), Image.ANTIALIAS)
thumb_local_filpath = local_filepath+"_thumb.png"
thumb.save(thumb_local_filpath,"PNG")
return imgData
def scaleByWidth(imagefield, size, method='scale'):
"""
Template filter used to scale an image
that will fit inside the defined area.
Returns the url of the resized image.
{% load image_tags %}
{{ profile.picture|scale:"48x48" }}
"""
# imagefield can be a dict with "path" and "url" keys
if imagefield.__class__.__name__ == 'dict':
imagefield = type('imageobj', (object, ), imagefield)
image_path = resized_path(imagefield.path, size, method)
if not os.path.exists(image_path):
try:
import Image
except ImportError:
try:
from PIL import Image
except ImportError:
raise ImportError('Cannot import the Python Image Library.')
image = Image.open(imagefield.path)
# normalize image mode
if image.mode != 'RGB':
image = image.convert('RGB')
# parse size string 'WIDTHxHEIGHT'
# width, height = [int(i) for i in size.split('x')]
width = int(size)
wpercent = (width / float(image.size[0]))
height = int((float(image.size[1]) * float(wpercent)))
# use PIL methods to edit images
if method == 'scale':
image.thumbnail((width, height), Image.ANTIALIAS)
image.save(image_path, FMT, quality=QUAL)
elif method == 'crop':
try:
import ImageOps
except ImportError:
from PIL import ImageOps
ImageOps.fit(image, (width, height),
Image.ANTIALIAS).save(image_path, FMT, quality=QUAL)
return resized_path(imagefield.url, size, method)
def scaleByWidth(imagefield, size, method='scale'):
"""
Template filter used to scale an image
that will fit inside the defined area.
Returns the url of the resized image.
{% load image_tags %}
{{ profile.picture|scale:"48x48" }}
"""
# imagefield can be a dict with "path" and "url" keys
if imagefield.__class__.__name__ == 'dict':
imagefield = type('imageobj', (object,), imagefield)
image_path = resized_path(imagefield.path, size, method)
if not os.path.exists(image_path):
try:
import Image
except ImportError:
try:
from PIL import Image
except ImportError:
raise ImportError('Cannot import the Python Image Library.')
image = Image.open(imagefield.path)
# normalize image mode
if image.mode != 'RGB':
image = image.convert('RGB')
# parse size string 'WIDTHxHEIGHT'
# width, height = [int(i) for i in size.split('x')]
width = int(size)
wpercent =(width / float(image.size[0]))
height = int((float(image.size[1]) * float(wpercent)))
# use PIL methods to edit images
if method == 'scale':
image.thumbnail((width, height), Image.ANTIALIAS)
image.save(image_path, FMT, quality=QUAL)
elif method == 'crop':
try:
import ImageOps
except ImportError:
from PIL import ImageOps
ImageOps.fit(image, (width, height), Image.ANTIALIAS
).save(image_path, FMT, quality=QUAL)
return resized_path(imagefield.url, size, method)
def scale_image(image_path, size, method='scale'):
"""
Return generated or cached thumbnail relative path
image_path - a full path in file system
size - an array or tuple of width and height
"""
(original_path, file_name, file_ext) = split_filepath(image_path)
cached_filename = '%s.%s.%dx%d_%s.jpg' % (file_name, file_ext, size[0], size[1], method)
cached_file_path = '%s/%s' % (original_path, cached_filename)
if not os.path.exists(image_path):
return False
if not os.path.exists(cached_file_path):
try:
import Image
except ImportError:
try:
from PIL import Image
except ImportError:
raise ImportError('Cannot import the Python Image Library.')
image = Image.open(image_path)
# normalize image mode
if image.mode != 'RGBA':
image = image.convert('RGBA')
if format == 'PNG':
pixdata = image.load()
for y in xrange(image.size[1]):
for x in xrange(image.size[0]):
if pixdata[x, y] == (0, 0, 0, 0):
pixdata[x, y] = (255, 255, 255, 0)
if method == 'scale':
image.thumbnail(size, Image.ANTIALIAS)
image.save(cached_file_path, 'JPEG')
elif method == 'crop':
try:
import ImageOps
except ImportError:
from PIL import ImageOps
ImageOps.fit(image, size, Image.ANTIALIAS).save(cached_file_path, 'JPEG', quality=80)
#return os.path.abspath(cached_file_path).replace(os.path.abspath(settings.BASE_PATH), '')
return cached_filename
def resize_image(cls, image_body, size, fit_to_size=False):
"""Takes a raw image (in image_body) and resizes it to fit given
dimensions. Returns a file-like object in the form of a StringIO.
This must happen in this function because PIL is transforming the
original as it works."""
image_file = StringIO(image_body)
try:
image = Image.open(image_file)
except IOError:
# Invalid image file
return False
# Get the image format early, as we lose it after perform a `thumbnail` or `fit`.
format = image.format
# Check for rotation
image = cls.adjust_image_orientation(image)
if not fit_to_size:
image.thumbnail(PROFILE_PICTURE_SIZES[size], Image.ANTIALIAS)
else:
image = PILOps.fit(image, PROFILE_PICTURE_SIZES[size],
method=Image.ANTIALIAS,
centering=(0.5, 0.5))
output = StringIO()
if format.lower() == 'jpg':
format = 'jpeg'
image.save(output, format=format, quality=95)
return output
def render_and_save_variation(self, name, content, variation):
"""
Renders the image variations and saves them to the storage
"""
resample = variation['resample'] or Image.ANTIALIAS
content.seek(0)
img = Image.open(content)
if self.is_smaller(img, variation):
factor = 1
while (img.size[0] / factor > 2 * variation['width'] and
img.size[1] * 2 / factor > 2 * variation['height']):
factor *= 2
if factor > 1:
img.thumbnail((int(img.size[0] / factor),
int(img.size[1] / factor)), resample=resample)
if variation['crop']:
img = ImageOps.fit(img, (variation['width'], variation['height']), method=resample)
else:
img.thumbnail((variation['width'], variation['height']), resample=resample)
variation_name = self.get_variation_name(self.instance, self.field, variation)
file_buffer = StringIO()
format = self.get_file_extension(name).lower().replace('jpg', 'jpeg')
img.save(file_buffer, format)
self.storage.save(variation_name, ContentFile(file_buffer.getvalue()))
file_buffer.close()
def settings(request):
if not request.user.is_authenticated():
return HttpResponseForbidden("<h1>Forbidden</h1><p>user not authenticated</p>")
c={}
c.update(csrf(request))
if request.method == 'POST':
settingsForm = SettingsForm(request.POST, request.FILES)
if settingsForm.is_valid():
avatarFile = settingsForm.cleaned_data['avatarFile']
if avatarFile:
userProfile = UserProfile.objects.get(user=request.user)
if userProfile.avatar:
userProfile.avatar.delete(save=False) # deleting old avatar
# creating new one, with sha1'ed name
hashingFunc = sha1()
hashingFunc.update(hashSalt + str(request.user.id))
avatarFileName = "%s.%s" % (hashingFunc.hexdigest(), avatarFile.content_type.split('/')[1])
originalImage = Image.open(avatarFile)
resizedImage = ImageOps.fit(originalImage, (300, 300), Image.ANTIALIAS)
tmpDest = os.path.join(MEDIA_ROOT, 'avatars', 'tmp' + avatarFileName)
resizedImage.save(tmpDest)
f = open(tmpDest)
avatarResizedFile = File(f)
userProfile.avatar.save(avatarFileName, avatarResizedFile)
avatarResizedFile.close()
os.remove(tmpDest)
########
user = request.user
user.first_name = settingsForm.cleaned_data['first_name']
user.last_name = settingsForm.cleaned_data['last_name']
user.email = settingsForm.cleaned_data['email_address']
user.userprofile.bio = settingsForm.cleaned_data['bio']
if settingsForm.cleaned_data['old_password']:
if settingsForm.cleaned_data['new_password']:
user.set_password(settingsForm.cleaned_data['new_password'])
user.save()
user.userprofile.save()
return HttpResponseRedirect('/settings/')
else:
settingsForm = SettingsForm(
{
'userId': str(request.user.id),
'first_name':request.user.first_name,
'last_name':request.user.last_name,
'email_address':request.user.email,
'bio' :request.user.userprofile.bio
})
sectionTitle = inspect.stack()[0][3]
c.update({'sectionTitle' : sectionTitle, 'sections' : sections, 'settingsForm': settingsForm})
return render_to_response('%s.html' % sectionTitle, c, context_instance=RequestContext(request))
def creIma(Hum):
wrNumb(Hum)
highlight = Image.open('/usr/share/ingweather/data/square.png')
mask = Image.open('/usr/share/ingweather/data/square-mask.png')
icon = Image.open('/tmp/ingweather/numb.png').convert('RGBA')
button = Image.new('RGBA', mask.size)
# Resize Icon
icon = ImageOps.fit(
icon, highlight.size, method=Image.ANTIALIAS, centering=(0.5, 0.5)
)
# Create a helper image that will hold the icon after the reshape
helper = button.copy()
# Cut the icon by the shape of the mask
helper.paste(icon, mask=mask)
# Fill with a solid color by the mask's shape
button.paste((255, 255, 255), mask=mask)
# Get rid of the icon's alpha band
icon = icon.convert('RGB')
# Paste the icon on the solid background
# Note we are using the reshaped icon as a mask
button.paste(icon, mask=helper)
# Get a copy of the highlight image without the alpha band
overlay = highlight.copy().convert('RGB')
button.paste(overlay, mask=highlight)
button.save('/tmp/ingweather/button.png')
def _resize_image(self, filename, size):
"""Resizes the image to specified width, height and force option
- filename: full path of image to resize
- size: dictionary containing:
- width: new width
- height: new height
- force: if True, image will be cropped to fit the exact size,
if False, it will have the bigger size that fits the
specified size, but without cropping, so it could be
smaller on width or height
"""
WIDTH, HEIGHT = 0, 1
# from PIL import Image, ImageOps #@UnresolvedImport
import Image
import ImageOps # @UnresolvedImport
img = Image.open(filename)
if img.size[WIDTH] > size["width"] or img.size[HEIGHT] > size["height"]:
if size["force"]:
img = ImageOps.fit(img, (size["width"], size["height"]), Image.ANTIALIAS)
else:
img.thumbnail((size["width"], size["height"]), Image.ANTIALIAS)
try:
img.save(filename, optimize=1)
except IOError:
img.save(filename)
def resize(self, img=None, orientation=None):
size = 640, 640
try:
if not img:
img = Image.open(self.image)
# Rotate/Flip image according to orientation
if orientation:
if orientation == 1:
pass
elif orientation == 2:
img = img.transpose(Image.FLIP_LEFT_RIGHT)
elif orientation == 3:
img = img.transpose(Image.ROTATE_180)
elif orientation == 4:
img = img.transpose(Image.FLIP_TOP_BOTTOM)
elif orientation == 5:
img = img.transpose(Image.FLIP_LEFT_RIGHT).transpose(
Image.ROTATE_90)
elif orientation == 6:
img = img.transpose(Image.ROTATE_270)
elif orientation == 7:
img = img.transpose(Image.ROTATE_270).transpose(
Image.FLIP_LEFT_RIGHT)
elif orientation == 8:
img = img.transpose(Image.ROTATE_90)
img = ImageOps.fit(img, size, Image.ANTIALIAS, 0, (0.5, 0.5))
img.save(self.original_path(), "PNG")
except IOError:
print "Cannot create resized image for ", self.image
def scale(imagefield, size, method='scale'):
"""
Template filter used to scale an image
that will fit inside the defined area.
Returns the url of the resized image.
{% load image_format %}
{{ profile.picture|scale:"48x48" }}
"""
# imagefield can be a dict with "path" and "url" keys
if imagefield.__class__.__name__ == 'dict':
imagefield = type('imageobj', (object,), imagefield)
image_path = resized_path(imagefield.path, size, method)
need_resize = True
if not os.path.exists(image_path):
try:
import Image
except ImportError:
try:
from PIL import Image
except ImportError:
raise ImportError('Cannot import the Python Image Library.')
image = Image.open(imagefield.path)
# normalize image mode
if image.mode != 'RGBA' or image.mode != 'RGB':
image = image.convert('RGBA')
# parse size string 'WIDTHxHEIGHT'
width, height = [int(i) for i in size.split('x')]
need_resize = width != image.size[0] or height != image.size[1]
# use PIL methods to edit images
if method == 'scale' and need_resize:
premultiply(image)
image.thumbnail((width, height), Image.ANTIALIAS)
unmultiply(image)
image.save(image_path, FMT, quality=QUAL)
elif method == 'crop' and need_resize:
try:
import ImageOps
except ImportError:
from PIL import ImageOps
premultiply(image)
image = ImageOps.fit(image, (width, height), Image.ANTIALIAS)
unmultiply(image)
image.save(image_path, FMT, quality=QUAL)
if need_resize:
return resized_path(imagefield.url, size, method)
return imagefield.url
def resize_image(cls, image_body, size, fit_to_size=False):
"""Takes a raw image (in image_body) and resizes it to fit given
dimensions. Returns a file-like object in the form of a StringIO.
This must happen in this function because PIL is transforming the
original as it works."""
image_file = StringIO(image_body)
try:
image = Image.open(image_file)
except IOError:
# Invalid image file
return False
# Get the image format early, as we lose it after perform a `thumbnail` or `fit`.
format = image.format
# Check for rotation
image = cls.adjust_image_orientation(image)
if not fit_to_size:
image.thumbnail(PROFILE_PICTURE_SIZES[size], Image.ANTIALIAS)
else:
image = PILOps.fit(image,
PROFILE_PICTURE_SIZES[size],
method=Image.ANTIALIAS,
centering=(0.5, 0.5))
output = StringIO()
if format.lower() == 'jpg':
format = 'jpeg'
image.save(output, format=format, quality=95)
return output
def render_and_save_variation(self, name, content, variation):
"""
Renders the image variations and saves them to the storage
"""
content.seek(0)
img = Image.open(content)
if self.is_smaller(img, variation):
factor = 1
while (img.size[0] / factor > 2 * variation['width'] and
img.size[1] * 2 / factor > 2 * variation['height']):
factor *= 2
if factor > 1:
img.thumbnail((int(img.size[0] / factor),
int(img.size[1] / factor)), resample=resample)
if variation['crop']:
img = ImageOps.fit(img, (variation['width'], variation['height']), method=resample)
else:
img.thumbnail((variation['width'], variation['height']), resample=resample)
variation_name = self.get_variation_name(self.instance, self.field, variation)
file_buffer = StringIO()
format = self.get_file_extension(name).lower().replace('jpg', 'jpeg')
img.save(file_buffer, format)
self.storage.save(variation_name, ContentFile(file_buffer.getvalue()))
file_buffer.close()
def loadiSUNVAL():
NumSample = 926;
X2 = np.zeros((NumSample, 3, 96, 96), dtype='float32')
y2 = np.zeros((NumSample,48*48), dtype='float32')
names = loadNameListSUN(MAT_VAL_SUN,NumSample,'validation')
for i in range(NumSample):
img = Image.open('/imatge/jpan/work/iSUN/images/'+names[i]+'.jpg')
img = ImageOps.fit(img, (96, 96), Image.ANTIALIAS)
img = np.asarray(img, dtype = 'float32') /255.
if(cmp(img.shape , (96,96,3)) == 0):
img = img.transpose(2,0,1).reshape(3, 96, 96)
X2[i] = img
else:
print names[i]
aux=to_rgb(img)
aux = aux.transpose(2,0,1).reshape(3, 96, 96)
X2[i]=aux
label = loadSaliencyMapSUN(names[i])
label = misc.imresize(label,(48,48)) / 127.5
label = label -1.
y2[i] = label.reshape(1,48*48)
data_to_save = (X2, y2)
f = file('data_iSun_VAL.cPickle', 'wb')
pickle.dump(data_to_save, f, protocol=pickle.HIGHEST_PROTOCOL)
f.close()
def resize(self, img=None, orientation=None): size = 640,640 try: if not img: img = Image.open(self.image) # Rotate/Flip image according to orientation if orientation: if orientation == 1: pass elif orientation == 2: img = img.transpose(Image.FLIP_LEFT_RIGHT) elif orientation == 3: img = img.transpose(Image.ROTATE_180) elif orientation == 4: img = img.transpose(Image.FLIP_TOP_BOTTOM) elif orientation == 5: img = img.transpose(Image.FLIP_LEFT_RIGHT).transpose(Image.ROTATE_90) elif orientation == 6: img = img.transpose(Image.ROTATE_270) elif orientation == 7: img = img.transpose(Image.ROTATE_270).transpose(Image.FLIP_LEFT_RIGHT) elif orientation == 8: img = img.transpose(Image.ROTATE_90) img = ImageOps.fit(img, size, Image.ANTIALIAS, 0, (0.5,0.5)) img.save(self.original_path(), "PNG") except IOError: print "Cannot create resized image for ", self.image
def create_photo_strips():
'''using the original images we build a color and black and white photo strip and save it to photos/strips'''
strip = Image.new('RGB', (PHOTO_HEIGHT + (BORDER_WIDTH * 2) + FOOTER_HEIGHT, (PHOTO_WIDTH * PHOTO_COUNT) + (BORDER_WIDTH * 2)), BG_COLOR)
for i in range(PHOTO_COUNT):
photo = Image.open(PHOTO_FOLDER + str(i+1) + '.' + PHOTO_FILE_EXTENSION)
w, h = map(lambda x: x/2, photo.size)
photo = ImageOps.fit(photo, (PHOTO_WIDTH, PHOTO_HEIGHT), centering=(0.5, 0.5))
photo = photo.rotate(270)
photo = ImageOps.autocontrast(photo, cutoff=0)
strip.paste(photo, (FOOTER_HEIGHT, (i * PHOTO_WIDTH) + (i * BORDER_WIDTH)))
#append footer
font = ImageFont.truetype('font_1.ttf', 40)
footer_img = Image.new("RGB", ((PHOTO_COUNT * PHOTO_WIDTH) + (PHOTO_COUNT * BORDER_WIDTH), FOOTER_HEIGHT), BG_COLOR)
draw = ImageDraw.Draw(footer_img)
draw.text((220, 40), "ashley & david's wedding, july 28, 2012", font=font, fill=(100,100,0))
strip.paste(footer_img.rotate(270), (0,0))
strip.save(COLOR_FOLDER + current_timestamp() + '.png', PHOTO_FORMAT)
ImageOps.grayscale(strip).save(GREYSCALE_FOLDER + current_timestamp() + '.png', PHOTO_FORMAT)
strip_to_print = Image.new('RGB', (PAGE_WIDTH, PAGE_HEIGHT), BG_COLOR)
strip_to_print.paste(ImageOps.grayscale(strip), (-BORDER_WIDTH, -BORDER_WIDTH))
strip_to_print.save('to_print.png', PHOTO_FORMAT)
return 'to_print.png'
def create_thumb(self):
"""
Reformat and create small and thumbnail images.
All pictures are squared for artistic reasons :)
"""
self.image.seek(0)
original = Image.open(self.image)
if original.mode not in ('L', 'RGB'):
original = original.convert('RGB')
quality_val = 95
dpi_val = (150, 150)
format = original.format
min_dim = min(original.size)
#original = original.crop((0,0,min_dim,min_dim))
#make it square
original = ImageOps.fit(original, (min_dim, min_dim), centering=(0.5, 0.5))
#make large
im = original.resize((MAX_SIZE, MAX_SIZE), Image.ANTIALIAS)
im.save(self.image.path, format, quality=quality_val, dpi=dpi_val)
#make small
im = original.resize((SMALL_SIZE, SMALL_SIZE), Image.ANTIALIAS)
im.save(self.get_path(thumb=False), format, quality=quality_val, dpi=dpi_val)
# Make Thumb
im = original.resize((THUMB_SIZE, THUMB_SIZE), Image.ANTIALIAS)
im.save(self.get_path(thumb=True), format, quality=quality_val, dpi=dpi_val)
def snap(self, file):
self.camera.capture(file, use_video_port=True)
Time.sleep(0.1)
im = Image.open(file)
smaller = ImageOps.fit(im, self.normal_size, Image.ANTIALIAS, (0.5, 0.5))
smaller.save(file, 'JPEG', quality=98)
def uploadImg(Profilepic, oldname, newname):
try:
Profilepicname = newname
'Save tmp file'
tmp_filepath = "atv/tmp/profile/" + Profilepicname
tmp_output_file = open(tmp_filepath, 'wb')
Profilepic.seek(0)
while True:
data = Profilepic.read(2 << 16)
if not data:
break
tmp_output_file.write(data)
tmp_output_file.close()
'resize'
size = 200, 200
im = Image.open(tmp_filepath)
im = ImageOps.fit(im, size, Image.ANTIALIAS)
im.save(tmp_filepath, "PNG")
'Save img to S3'
k = Key(b)
k.key = "profileimg/" + Profilepicname
k.set_contents_from_filename(tmp_filepath, policy='public-read')
status = ""
'resize mini'
size = 25, 25
im = Image.open(tmp_filepath)
im = ImageOps.fit(im, size, Image.ANTIALIAS)
im.save(tmp_filepath, "PNG")
'Save mini img to S3'
k = Key(b)
k.key = "miniprofileimg/" + Profilepicname
k.set_contents_from_filename(tmp_filepath, policy='public-read')
'delete tmp file'
os.remove(tmp_filepath)
status = ""
'delete old img files'
k = Key(b)
k.key = "profileimg/" + oldname
b.delete_key(k)
k = Key(b)
k.key = "miniprofileimg/" + oldname
b.delete_key(k)
return status
except:
status = """File could not be uploaded - please check the file extension
and try again."""
return status
def uploadImg(Profilepic, oldname, newname):
try:
Profilepicname = newname
'Save tmp file'
tmp_filepath = "atv/tmp/profile/" + Profilepicname
tmp_output_file = open(tmp_filepath, 'wb')
Profilepic.seek(0)
while True:
data = Profilepic.read(2<<16)
if not data:
break
tmp_output_file.write(data)
tmp_output_file.close()
'resize'
size = 200, 200
im = Image.open(tmp_filepath)
im = ImageOps.fit(im, size, Image.ANTIALIAS)
im.save(tmp_filepath, "PNG")
'Save img to S3'
k = Key(b)
k.key = "profileimg/" + Profilepicname
k.set_contents_from_filename(tmp_filepath, policy='public-read')
status = ""
'resize mini'
size = 25, 25
im = Image.open(tmp_filepath)
im = ImageOps.fit(im, size, Image.ANTIALIAS)
im.save(tmp_filepath, "PNG")
'Save mini img to S3'
k = Key(b)
k.key = "miniprofileimg/" + Profilepicname
k.set_contents_from_filename(tmp_filepath, policy='public-read')
'delete tmp file'
os.remove(tmp_filepath)
status = ""
'delete old img files'
k = Key(b)
k.key = "profileimg/" + oldname
b.delete_key(k)
k = Key(b)
k.key = "miniprofileimg/" + oldname
b.delete_key(k)
return status
except:
status = """File could not be uploaded - please check the file extension
and try again."""
return status
def __init__(self, size, default=None):
self.size = size
if default:
self.__default = Image.open(default)
if self.__default.mode != "RGB":
self.__default = self.__default.convert("RGB")
if self.__default.size != size:
self.__default = ImageOps.fit(self.__default,self.size)
def getImage(self, frame_num):
""" try helps us loop to begining of sequence
if we reach the end start providing frames from the begining"""
try:
image = Image.open(self.__src % (frame_num - self.__offset))
except IOError:
self.__offset = frame_num - 1
image = Image.open(self.__src % (frame_num - self.__offset))
return ImageOps.fit(image, self.size)
def get_pilscreens(self,screens,screensdir,number_thumbs,image_size):
method = Image.ANTIALIAS
bleed = 0
centering = (0.5,0.5)
defaulthumbpath = self.get_defaulthumbpath()
defaulthumb = ImageOps.fit(Image.open(defaulthumbpath),image_size,method,bleed,centering)
pilscreens = [defaulthumb] * number_thumbs
#random.shuffle(screens)
i = 0
for screen in screens:
if i < number_thumbs:
im = Image.open(os.path.join(screensdir,screen))
thumb = ImageOps.fit(im,image_size,method,bleed,centering)
pilscreens[i] = thumb
i += 1
return pilscreens
def __call__(self, image, x, y, sheet_xdensity, sheet_ydensity, width=1.0, height=1.0):
self.image=image
# JPALERT: Right now this ignores all options and just fits the image into given array.
# It needs to be fleshed out to properly size and crop the
# image given the options. (maybe this class needs to be
# redesigned? The interface to this function is pretty inscrutable.)
im = ImageOps.fit(self.image,x.shape,self.sampling_method)
return array(im,dtype=Float)
def __call__(self, image, x, y, sheet_xdensity, sheet_ydensity, width=1.0, height=1.0):
self.image=image
# JPALERT: Right now this ignores all options and just fits the image into given array.
# It needs to be fleshed out to properly size and crop the
# image given the options. (maybe this class needs to be
# redesigned? The interface to this function is pretty inscrutable.)
im = ImageOps.fit(self.image,x.shape,self.sampling_method)
return array(im,dtype=Float)
def push_history_frame(self, frame):
""" Push a frame to the top of the history images. """
# Shift back.
for n in range(len(self._ui_history_frames) - 1):
self._ui_history_frames[n][:,:] = self._ui_history_frames[n+1][:,:]
# Update.
h, w = self._ui_history_frame_size
img = np.array(ImageOps.fit(PIL.Image.fromarray(frame), (w, h)))
self._ui_history_frames[-1][:,:] = img
def run(self):
Output.debug("PhotoLoadThread " + str(self.index) + " starting...")
# Load the photo
Output.debug("PhotoLoadThread " + str(self.index) + ": Opening...")
self.image = Image.open(self.filename)
Output.debug("PhotoLoadThread " + str(self.index) + ": Fitting...")
self.image = ImageOps.fit(self.image, (Display.image_size(self.fullsize), Display.image_size(self.fullsize)))
Output.debug("PhotoLoadThread " + str(self.index) + ": TKing...")
images()[self.index] = ImageTk.PhotoImage(self.image)
Output.debug("PhotoLoadThread " + str(self.index) + " finished.")
def make_thumbnail(photo_url, width=None, height=None, aspect=None,
root=settings.MEDIA_ROOT, url_root=settings.MEDIA_URL):
""" create thumbnail """
# one of width/height is required
assert (width is not None) or (height is not None)
if not photo_url:
return None
th_url = _get_thumbnail_path(photo_url, width, height, aspect)
th_path = get_path_from_url(th_url, root, url_root)
photo_path = get_path_from_url(photo_url, root, url_root)
if _has_thumbnail(photo_url, width, height, root, url_root, aspect):
# thumbnail already exists
if not (os.path.getmtime(photo_path) > os.path.getmtime(th_path)):
# if photo mtime is newer than thumbnail recreate thumbnail
return th_url
# make thumbnail
# get original image size
orig_w, orig_h = get_image_size(photo_url, root, url_root)
if (orig_w is None) and (orig_h is None):
# something is wrong with image
return photo_url
# make proper size
if (width is not None) and (height is not None):
if (orig_w == width) and (orig_h == height):
# same dimensions
return None
size = (width, height)
elif width is not None:
if orig_w == width:
# same dimensions
return None
size = (width, orig_h)
elif height is not None:
if orig_h == height:
# same dimensions
return None
size = (orig_w, height)
try:
img = Image.open(photo_path).copy()
if aspect:
img = ImageOps.fit(img, size, Image.ANTIALIAS, (0.5, 0.5))
img.thumbnail(size, Image.ANTIALIAS)
img.save(th_path, quality=settings.THUMBNAIL_QUALITY)
except Exception, err:
# this goes to webserver error log
print >> sys.stderr, '[MAKE THUMBNAIL] error %s for file %r' % (err, photo_url)
return photo_url
def update(self, control):
Effect.update(self, control)
src_img = self.providers[0].getImage(self.currentFrame)
img = self.providers[1].getImage(self.currentFrame)
size = self.providers[1].size
x = 0
for i in range(self.sliceCount):
w = int(size[0] * (float(self.percents[i]) / float(100)))
l = x
x += w
r = x
if not(self.truths) or (self.truths and self.truths[i]):
tmpimg = ImageOps.fit(src_img, (w,img.size[1]))
if self.maskProvider:
mask = self.maskProvider.getImage(self.currentFrame)
mask = ImageOps.fit(mask, tmpimg.size)
img.paste(tmpimg, (l,0,r,img.size[1]), mask)
else:
img.paste(tmpimg, (l,0,r,img.size[1]))
self.keeper.setImage(img)
def process(self, obj, key, valDict, *sizes):
# Sanity check
if len(sizes) == 0:
raise ElementFilterException(C.make_error("USER_IMAGE_SIZE_MISSING"))
# Do we have an attribute to process?
if key in valDict and valDict[key]['value']:
# Check if a cache entry exists...
entry = self.db.cache.find_one({'uuid': obj.uuid, 'attribute': key}, {'modified': 1})
if entry:
# Nothing to do if it's unmodified
if obj.modifyTimestamp == entry['modified']:
return key, valDict
# Create new cache entry
else:
c_entry = {
'uuid': obj.uuid,
'attribute': key
}
self.db.cache.save(c_entry)
# Convert all images to all requested sizes
data = {
'uuid': obj.uuid,
'attribute': key,
'modified': obj.modifyTimestamp
}
for idx in range(0, len(valDict[key]['value'])):
image = StringIO(valDict[key]['value'][idx].get())
try:
im = Image.open(image) #@UndefinedVariable
except IOError:
continue
for size in sizes:
s = int(size)
tmp = ImageOps.fit(im, (s, s), Image.ANTIALIAS) #@UndefinedVariable
tgt = StringIO()
tmp.save(tgt, "JPEG")
# Collect all images in [size][] lists
if not size in data:
data[size] = []
data[size].append(Binary(tgt.getvalue()))
# Update cache
self.db.cache.update({'uuid': obj.uuid, 'attribute': key}, data)
return key, valDict
def prepare_image(cls, image):
if isinstance(image, str):
image = Image.open(image)
if isinstance(image, Image.Image):
if (image.size[0] < cls.kernel_size or
image.size[1] < cls.kernel_size):
image = ImageOps.fit(image, (cls.kernel_size, cls.kernel_size))
image = np.array(image)
image = image.swapaxes(1, 2).swapaxes(0, 1).astype(np.float32)
return image
def clientChanged(self, event):
#print " ... video Client Changed"
jpg = self.commQueue.get()
cv_image = cv2.imdecode(np.fromstring(jpg, dtype=np.uint8),
cv2.CV_LOAD_IMAGE_COLOR)
cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB)
pil_image = PIL.Image.fromarray(cv_image)
pil_image2 = ImageOps.fit(pil_image, (640, 360), Image.ANTIALIAS)
tk_image = ImageTk.PhotoImage(image=pil_image2)
self.hui.image_label.configure(image=tk_image)
self.hui.image_label._image_cache = tk_image # avoid garbage collection
self.hui.root.update()
def loadImage():
xt = np.zeros((num_img, 3, 96, 96), dtype='float32')
i = 0
for file in glob.glob(url + "*.jpg"):
img = Image.open(file)
img = ImageOps.fit(img, (96, 96), Image.ANTIALIAS)
img = np.asarray(img, dtype='float32') / 255.
if (cmp(img.shape, (96, 96, 3)) == 0):
img = img.transpose(2, 0, 1).reshape(3, 96, 96)
xt[i] = img
else:
aux = to_rgb(img)
aux = aux.transpose(2, 0, 1).reshape(3, 96, 96)
xt[i] = aux
i = i + 1
return xt
def _resize_image(self, filename, size):
"""Resizes the image to specified width, height and force option
Arguments::
filename -- full path of image to resize
size -- dictionary with
- width: int
- height: int
- force: bool
if True, image will be cropped to fit the exact size,
if False, it will have the bigger size that fits the specified
size, but without cropping, so it could be smaller on width
or height
"""
width, height = 0, 1
try:
import Image, ImageOps
except ImportError:
from PIL import Image, ImageOps
img = Image.open(filename)
if (img.size[width] > size['width']
or img.size[height] > size['height']):
#If the image is big resize it with the cheapest resize algorithm
factor = 1
while (img.size[0] / factor > 2 * size['width']
and img.size[1] * 2 / factor > 2 * size['height']):
factor *= 2
if factor > 1:
img.thumbnail(
(int(img.size[0] / factor), int(img.size[1] / factor)),
Image.NEAREST)
if size['force']:
img = ImageOps.fit(img, (size['width'], size['height']),
Image.ANTIALIAS)
else:
img.thumbnail((size['width'], size['height']), Image.ANTIALIAS)
try:
img.save(filename, optimize=1)
except IOError:
img.save(filename)
def _resize_image(self, filename, size):
"""
ripped from:
https://github.com/humanfromearth/django-stdimage/blob/master/stdimage/fields.py
Resizes the image to specified width, height and force option
Arguments::
filename -- full path of image to resize
size -- dictionary with
- width: int
- height: int
- force: bool
if True, image will be cropped to fit the exact size,
if False, it will have the bigger size that fits the specified
size, but without cropping, so it could be smaller on width
or height
"""
WIDTH, HEIGHT = 0, 1
img = Image.open(filename)
if (img.size[WIDTH] > size['width'] or
img.size[HEIGHT] > size['height']):
#If the image is big resize it with the cheapest resize algorithm
factor = 1.61803398875
while (img.size[0] / factor > 2 * size['width'] and
img.size[1] * 2 / factor > 2 * size['height']):
factor *= 2
if factor > 1:
img.thumbnail((int(img.size[0] / factor),
int(img.size[1] / factor)), Image.NEAREST)
if size['force']:
img = ImageOps.fit(img, (size['width'], size['height']),
Image.ANTIALIAS)
else:
img.thumbnail((size['width'], size['height']), Image.ANTIALIAS)
try:
img.save(filename, optimize=1)
except IOError:
img.save(filename)
def resize(
): # for resizing images to 256 by 256 and zooming in on the objects
for s in wanted_classes:
files = glob('data/overlays/' + labels[s] + '/*')
for f in tqdm(files):
images = glob(f + '/*')
for im in images:
# here I am maintianing the origional images and renaming them with a large_ prefix
actual = im
new = f + '/orig_' + im.split('/')[-1]
shutil.move(actual, new)
im = Image.open(new)
x, y = im.size
diff = (x - y) / 2
im = im.crop(
(diff + 100, 100, x - diff - 100, y - 100)
) # getting a square aspect ratio and zooming in on object by 100 pixels
im = ImageOps.fit(im, (256, 256),
Image.ANTIALIAS) # reshaping to 256 by 256
im.save(actual)
def generate_thumbnail(image_url, preserve_ratio=False, size=(220, 165)):
"""Take an image src, generate a thumbnail, return new path"""
filename = image_url.rsplit('/', 1)[1]
path_to_read = 'img/' + filename
path_to_save = "%smain/static/dev/%s" % (ABSOLUTE_PATH, path_to_read)
if not os.path.isfile(path_to_save):
img_file = urllib.urlopen(image_url)
img = StringIO(img_file.read())
image = Image.open(img)
if preserve_ratio:
width = image.size[0]
height = image.size[1]
new_height = size[0] * height / width
size = (size[0], new_height)
im = ImageOps.fit(image, size, Image.ANTIALIAS)
im.save(path_to_save)
return path_to_read
def read_files(folders):
size = 28, 28
features_list = []
for folderpath in folders:
for root, dirs, files in os.walk(folderpath):
path = root.split('/')
for file in files:
if "and " in file:
# print "@@@", os.path.join(root, file)
im = Image.open(os.path.join(root, file))
imagefit = ImageOps.fit(im, size, Image.ANTIALIAS)
features = list(imagefit.getdata())
assert_equal(len(features), 784)
# print features
if(is_grayscale(features)):
features_list.append(features)
# print features_list
print "!!!!!!", len(features_list)
return features_list
def prepSizedImage(source, width, height):
hash = XUtils.hash((source.encode(), width, height))
bucket = "media/temp/" + hash
basename = os.path.basename(source)
if os.path.splitext(basename)[1] == "":
basename = basename + ".png"
newSource = bucket + "/" + basename
if not os.path.exists(newSource) or (
not source.startswith("http")
and os.stat(source).st_mtime > os.stat(newSource).st_mtime):
try:
os.makedirs(bucket)
except OSError:
if os.path.isdir(bucket): pass
else: raise
image = None
if source.startswith("http"):
image = Image.open(
StringIO.StringIO(urllib2.urlopen(source).read()))
else:
image = Image.open(source)
baseWidth, baseHeight = image.size
if height or width:
if not height: height = width * baseHeight / baseWidth
if not width: width = height * baseWidth / baseHeight
if width != baseWidth and height != baseHeight:
image = image.convert("RGBA")
image = ImageOps.fit(image, (width, height),
Image.ANTIALIAS, 0, (0.5, 0.5))
else:
width, height = image.size
image.save(newSource)
source = newSource
return source
def loadiSUNTest():
NumSample = 2000
names = loadNameListSUN(MAT_TEST_SUN,NumSample,'testing')
Xt = np.zeros((NumSample, 3, 96, 96), dtype='float32')
for i in range(NumSample):
img = Image.open('/imatge/jpan/work/iSUN/images/'+names[i]+'.jpg')
img = ImageOps.fit(img, (96, 96), Image.ANTIALIAS)
img = np.asarray(img, dtype = 'float32') / 255.
if(cmp(img.shape , (96,96,3)) == 0):
img = img.transpose(2,0,1).reshape(3, 96, 96)
Xt[i] = img
else:
print names[i]
aux=to_rgb(img)
aux = aux.transpose(2,0,1).reshape(3, 96, 96)
Xt[i]=aux
data_to_save = Xt
f = file('data_iSUN_Test.cPickle', 'wb')
pickle.dump(data_to_save, f, protocol=pickle.HIGHEST_PROTOCOL)
f.close()
def fit(image, size, method, bleed, centering):
return ImageOps.fit(image, size, method, bleed, centering)
def _execute_hook(self, im, new_im_width, new_im_height):
fit_im = ImageOps.fit(im, (int(new_im_width), int(new_im_height)))
fit_im.format = im.format
return fit_im
def resizeImage(self,
buffer_filepath,
local_filepath,
params,
cropped_image=False):
image = Image.open(buffer_filepath)
width, height = image.size
imgData = {"width": width, "height": height}
need_resize = False
createSmallItemSpell = False
if "type_of_form" in params and params[
'type_of_form'] == "create_artwork":
checkWidth = self.core.MAX_ARTWORK_WIDTH
checkHeight = self.core.MAX_ARTWORK_HEIGHT
elif "type_of_form" in params and (
params['type_of_form'] == "create_item"
or params['type_of_form'] == "create_spell"):
checkWidth = self.core.MAX_ITEM_SPELL_WIDTH
checkHeight = self.core.MAX_ITEM_SPELL_HEIGHT
createSmallItemSpell = True
else:
checkWidth = self.core.MAX_AVA_WIDTH
checkHeight = self.core.MAX_AVA_HEIGHT
if width > checkWidth:
width = checkWidth
need_resize = True
if height > checkHeight:
height = checkHeight
need_resize = True
#need_resize = False
if need_resize:
if params['type_of_form'] == "create_artwork":
thumb = ImageOps.fit(cropped_image,
(self.core.THUMB_ARTWORK_WIDTH,
self.core.THUMB_ARTWORK_HEIGHT),
Image.ANTIALIAS)
else:
thumb = ImageOps.fit(cropped_image, (width, height),
Image.ANTIALIAS)
thumb.save(local_filepath + "_fit.png", "PNG")
elif params['type_of_form'] == "create_artwork":
thumb = ImageOps.fit(cropped_image,
(self.core.THUMB_ARTWORK_WIDTH,
self.core.THUMB_ARTWORK_HEIGHT),
Image.ANTIALIAS)
thumb.save(local_filepath + "_fit.png", "PNG")
else:
image.save(local_filepath + "_fit.png", "PNG")
if createSmallItemSpell:
thumb = ImageOps.fit(cropped_image,
(self.core.THUMB_ITEM_SPELL_WIDTH,
self.core.THUMB_ITEM_SPELL_HEIGHT),
Image.ANTIALIAS)
thumb_local_filpath = local_filepath + "_thumb.png"
thumb.save(thumb_local_filpath, "PNG")
return imgData
try:
widthInt = int(width)
except ValueError:
respondError( "Parameter width can't be parsed to int")
if widthInt < 10 or widthInt > 600:
respondError( "Parameter width is out of range 10 to 600")
height = form.getvalue('height')
if not height:
respondError( "Parameter height is missing in HTTP request")
try:
heightInt = int(height)
except ValueError:
respondError( "Parameter height can't be parsed to int")
if heightInt < 10 or heightInt > 600:
respondError( "Parameter height is out of range 10 to 600")
# if we got this far then we have good parameter and can read the image and scale and crop
im = Image.open( recipePath + filename)
im = ImageOps.fit( im,( widthInt, heightInt ), Image.NEAREST, 0, (0.5,0.5) )
# looks like I need to save the image so that it can be opened and printede
im.save( cachePath + filename )
# print the image to the output stream
print ("Content-type: image/jpeg\n")
file = open(cachePath + filename, "r")
print file.read()
def image2raw(self, imgfilename): im = Image.open(imgfilename) if im.size[0] != 256 or im.size[1] != 256: im = ImageOps.fit(im, (256,256), Image.ANTIALIAS) self.wfile.write(im.tostring())
import os, sys
import Image,ImageOps
size = 16, 8
'''
for infile in sys.argv[1:]:
outfile = os.path.splitext(infile)[0] + ".thumbnail"
if infile != outfile:
try:
im = Image.open(infile)
im.thumbnail(size, Image.ANTIALIAS)
im.save(outfile, "JPEG")
except IOError:
print "cannot create thumbnail for '%s'" % infile'''
for path, subdirs, files in os.walk("./Images/"):
if(not path.endswith("ConvertedImages")):
i=0
for file in files:
#print path+"/ConvertedImages/"+file
outfile = path+"/ConvertedImages/"+str(i)+".jpg"
i += 1
infile = path+"/"+file
try:
im = Image.open(infile)
#im.resize(size)
img = ImageOps.fit(im, size, Image.ANTIALIAS)
img.save(outfile, "JPEG")
except IOError:
print "cannot create thumbnail for '%s'" % infile
raise
try:
image_dir = sys.argv[1]
except:
print "Please specify a directory"
exit(1)
files = os.listdir(image_dir)
for file in files:
if IMAGEEXT.match(file):
f = os.path.join(image_dir, file)
print f
img = Image.open(f)
# rotate landscape images
if img.size[0] > img.size[1]:
img = img.rotate(90)
# resize and crop the image to fit in 600x800 screen
img = ImageOps.fit(img, SIZE, Image.ANTIALIAS)
# convert to grayscale
img = img.convert('L')
# save to ./ss directory
ensuredirs(os.path.join(image_dir, 'ss'))
fout = os.path.join(image_dir, 'ss', file)
img.save(fout, "JPEG")
def format_image(im):
pixels = ImageOps.fit(im, (40, 40)).convert('L').getdata()
return pixels
def scale(imagefield, size, method='scale'):
"""
Template filter used to scale an image
that will fit inside the defined area.
Returns the url of the resized image.
{% load image_tags %}
{{ profile.picture|scale:"48x48" }}
"""
# imagefield can be a dict with "path" and "url" keys
if imagefield.__class__.__name__ == 'dict':
imagefield = type('imageobj', (object, ), imagefield)
image_path = resized_path(imagefield.path, size, method)
if not os.path.exists(image_path):
try:
import Image
except ImportError:
try:
from PIL import Image
except ImportError:
raise ImportError('Cannot import the Python Image Library.')
image = Image.open(imagefield.path)
# normalize image mode
if image.mode != 'RGB':
image = image.convert('RGB')
# parse size string 'WIDTHxHEIGHT'
width, height = [int(i) for i in size.split('x')]
# use PIL methods to edit images
if method == 'scale':
image.thumbnail((width, height), Image.ANTIALIAS)
image.save(image_path, FMT, quality=QUAL)
elif method == 'crop':
try:
import ImageOps, ExifTags
except ImportError:
from PIL import ImageOps, ExifTags
ImageOps.fit(image, (width, height),
Image.ANTIALIAS).save(image_path, FMT, quality=QUAL)
try:
for orientation in ExifTags.TAGS.keys():
if ExifTags.TAGS[orientation] == 'Orientation': break
exif = dict(image._getexif().items())
if exif[orientation] == 3:
image = image.rotate(180, expand=True)
elif exif[orientation] == 6:
image = image.rotate(270, expand=True)
elif exif[orientation] == 8:
image = image.rotate(90, expand=True)
image.save(image_path, FMT, quality=QUAL)
except ImportError:
raise ImportError('Cannot rotate.')
return resized_path(imagefield.url, size, method)
