def resize(im, crop, limit):
"""
Resize image to limit if limit > 0
if crop_square, and height and width are within 9 % crop to smaller dimension
"""
width = im.width
height = im.height
if width == height:
size = width
if 0 < limit < width:
size = limit
im = resizeimage.resize_width(im, size)
elif width > height:
size = height
if 0 < limit < height:
size = limit
if crop and (width - height) / width < 0.09:
im = resizeimage.resize_crop(im, [size, size])
else:
im = resizeimage.resize_width(im, size)
elif height > width:
size = width
if limit and width > limit:
size = limit
if crop and (height - width) / height < 0.09:
im = resizeimage.resize_crop(im, [size, size])
else:
im = resizeimage.resize_height(im, size)
return im
def buttonClicked(self):
#print "goButton clicked"
global designingCarPark, globalMapImage
if len(carParkShape.getVertices()
) < 3: #a valid shape can't have less than three vertices
tkMessageBox.showerror(
"Report",
"Error: Your car park shape must have more than 2 vertices")
else:
globalMapImage = resizeimage.resize_height(images[globalMapName],
imageHeight)
designingCarPark = False
carParkShapeForUseInProcessing = copy.deepcopy(
carParkShape
) #because it would otherwise pass my shape instance by referance, I make a copy of it to be passed to the processing code.
listOfGroupsOfCoordinatesForLines, messageToPrint = processingCode.GetCarParkPixelLinesToDrawFromPixelShape(
carParkShapeForUseInProcessing, pixelsPerMeter,
getAddPerimeterRoad())
draw = ImageDraw.Draw(globalMapImage)
listOfCoordinates = carParkShape.getVerticesCoordinates()
for eachGroupOfCoordinatesForLines in listOfGroupsOfCoordinatesForLines:
#print "eachGroupOfCoordinatesForLines:"
#print eachGroupOfCoordinatesForLines
draw.line(eachGroupOfCoordinatesForLines)
del draw
refreshWindow()
tkMessageBox.showinfo("Report", messageToPrint)
def resize(self, width, height, name='', type='width'):
output = os.path.join(self.cdir, self.name + '-' + str(width) + 'x' + str(height) + '-' + name + self.ext)
with open(self.src, 'r+b') as f:
with Image.open(f) as image:
if type == 'contain':
try:
result = resizeimage.resize_cover(image, [width, height])
except:
tmp = resizeimage.resize_contain(image, [width, height])
result = resizeimage.resize_cover(tmp, [width, height])
elif type == 'height':
result = resizeimage.resize_height(image, height, validate=False)
elif type == 'crop':
tmp = resizeimage.resize_contain(image, [width + 150, height + 150])
result = resizeimage.resize_crop(tmp, [width, height])
elif type == 'tcrop':
tmp = resizeimage.resize_contain(image, [width, height])
result = resizeimage.resize_crop(tmp, [width, height])
elif type == 'thumbnail':
result = resizeimage.resize_thumbnail(image, [width, height])
else:
result = resizeimage.resize_width(image, width, validate=False)
result.save(output, optimize=True)
return [output, '[{}x{}] {}'.format(width, height, name), self.name + '-' + str(width) + 'x' + str(height) + '-' + name + self.ext, name]
def make_small_file(photo_id):
"""
Task for making small photo
:param photo_id:
:return:
"""
from app.models import Photo
photo = Photo.objects.get(pk=photo_id)
image = photo.original_file
file_name = image.name.split('/')[-1]
image_obj = Image.open(image)
file_format = image_obj.format
width, height = image_obj.size
image_obj.convert('RGB')
if width > height:
image_obj = resizeimage.resize_width(image_obj, 150)
else:
image_obj = resizeimage.resize_height(image_obj, 150)
thumb_io = BytesIO()
image_obj.save(thumb_io, file_format, quality=90)
file_object = File(thumb_io, name=file_name)
photo.small_file = file_object
photo.save()
def resize_image(image_path, output_dir):
'''
:param image_path: str, path to image
:param output_dir: str, path to destination directory saving the resized image
:return: boolean, indicate if image exists and is valid
'''
image_exist = False
if os.path.exists(image_path):
file_info = os.stat(image_path)
if file_info.st_size < 15424400:
image_exist = True
else:
return image_exist
with open(image_path, 'r+b') as f:
image = Image.open(f)
width, height = image.size
if width >= height:
if width > 640:
width = 640
image = resizeimage.resize_width(image, width)
else:
if height > 640:
height = 640
image = resizeimage.resize_height(image, height)
# create new resized image at output_dir
image.save(output_dir + os.path.basename(image_path), image.format)
return image_exist
def buttonClicked(self):
global globalMapName,globalMapImage, carParkShape
globalMapName = self.parent.items['mapTypeComboBox'].comboBox.get()
globalMapImage = resizeimage.resize_height(images[globalMapName], imageHeight)
#sets the car park shape to a new blank shape
carParkShape = processingCode.shape()
refreshMap()
def resize_image(file: pathlib.Path,
indir: pathlib.Path,
outdir: pathlib.Path,
width=None,
height=None,
verbose=False):
assert width or height, "At least height or width must be specified"
if verbose:
print("Opening file {}".format(file))
with Image.open(file.resolve()) as img:
if width and height:
resized = resizeimage.resize_thumbnail(img, [width, height])
elif width:
resized = resizeimage.resize_width(img, width)
else:
resized = resizeimage.resize_height(img, height)
if verbose:
print("File {} resized. Will save it.".format(file))
final_path = file.relative_to(indir)
final_path = outdir.joinpath(final_path)
if not final_path.parent.exists():
final_path.parent.mkdir(parents=True)
resized.save(final_path, resized.format)
if verbose:
print("Saved resized version of {} to {}".format(file, final_path))
def buttonClicked(self):
global globalMapName, globalMapImage
globalMapName = self.parent.items['mapTypeComboBox'].comboBox.get()
globalMapImage = resizeimage.resize_height(images[globalMapName],
imageHeight)
print "shapeResetButton clicked"
#print self.parent.items['mapTypeComboBox'].comboBox.get()
refreshMap()
def resize_img(path):
with open(f'{path}', 'r+b') as f:
new_name = f'rs{datetime.datetime.today()}.png'
with Image.open(f) as image:
cover = resizeimage.resize_height(image, 300)
# cover.show()
# cover.save(f'resource/{new_name}', image.format)
return cover
def crop_profile_picture(input_file, output_file):
with open(input_file, "rb") as fd_img:
img = Image.open(fd_img)
img = resizeimage.resize_height(img, 200)
img = resizeimage.resize_crop(img, [112, 200])
img.save(output_file, img.format)
fd_img.close()
return True
def drawMapImage():
global globalMapImage
globalMapImage = resizeimage.resize_height(images[globalMapName], imageHeight)
draw = ImageDraw.Draw(globalMapImage)
listOfCoordinates = carParkShape.getVerticesCoordinates()
for count in range(len(listOfCoordinates)):# each in carParkShape.getVerticesCoordinates():
draw.ellipse((listOfCoordinates[count][0]-radiusOfCarParkVertices,listOfCoordinates[count][1]-radiusOfCarParkVertices,listOfCoordinates[count][0]+radiusOfCarParkVertices,listOfCoordinates[count][1]+radiusOfCarParkVertices))#,fill = colour)
draw.line((listOfCoordinates[count][0],listOfCoordinates[count][1],listOfCoordinates[(count+1)%len(listOfCoordinates)][0],listOfCoordinates[(count+1)%len(listOfCoordinates)][1]))
del draw
def crop_image(
image_base64: str, png_image_quality: int = IMAGE_QUALITY_PNG
) -> str:
"""
Crop an image, encoded in Base64.
Args:
image_base64: Image encoded in Base64
Kwargs:
png_image_quality: PNG image quality (defaults to 6)
Returns:
PNG image (possibly cropped) encoded in Base64
"""
img: Image.Image = Image.open(BytesIO(base64.b64decode(image_base64)))
img_width: int
img_height: int
img_width, img_height = img.size
cropped_image_base64: str
# Image is too small
if img_width < IMAGE_WIDTH_DESKTOP or img_height < IMAGE_HEIGHT_DESKTOP:
raise ValidationError(
"Image is too small (min {} x {} pixels): {} x {} pixels".format(
IMAGE_WIDTH_DESKTOP,
IMAGE_HEIGHT_DESKTOP,
img_width,
img_height,
)
)
# Image is too big
elif img_width > IMAGE_WIDTH_DESKTOP or img_height > IMAGE_HEIGHT_DESKTOP:
# Image is too wide
if (img_width / img_height) > (
IMAGE_WIDTH_DESKTOP / IMAGE_HEIGHT_DESKTOP
):
img = resizeimage.resize_height(img, IMAGE_HEIGHT_DESKTOP)
# Image is too high (and wide)
else:
img = resizeimage.resize_width(img, IMAGE_WIDTH_DESKTOP)
img = img.crop((0, 0, IMAGE_WIDTH_DESKTOP, IMAGE_HEIGHT_DESKTOP))
buffered = BytesIO()
img.save(
buffered, format="PNG", compress_level=png_image_quality
) # [0, 9], where 0 = no compression and 9 = best compression, defaults to 6
cropped_image_base64 = base64.b64encode(buffered.getvalue()).decode(
"utf-8"
)
# Image dimensions are correct (use the original image)
else:
cropped_image_base64 = image_base64
return cropped_image_base64
def upload():
if request.method == "POST":
target = os.path.join(
APP_ROOT,
'/var/www/homeDelicious/home_delicious_frontend/dist/img/uploadImgs'
)
# target = os.path.join(APP_ROOT, '/Users/Taylo/InnoTech/Assignments/Project/Home delicious/home_delicious_frontend')
if not os.path.isdir(target):
os.mkdir(target)
files = request.files.getlist("file")
for file in files:
# print(file)
filename = file.filename
destination = "/".join([target, filename])
print(destination)
file.save(destination)
image = Image.open(destination)
if image.width > 1280 and image.height < 1280:
with open(destination, 'r+b') as f:
with Image.open(f) as image:
cover = resizeimage.resize_width(image, 1280)
cover.save(destination, image.format)
elif image.width < 1280 and image.height > 1280:
with open(destination, 'r+b') as f:
with Image.open(f) as image:
cover = resizeimage.resize_height(image, 1280)
cover.save(destination, image.format)
elif image.width > 1280 and image.height > 1280:
with open(destination, 'r+b') as f:
with Image.open(f) as image:
cover = resizeimage.resize_cover(image, [1280, 1280])
cover.save(destination, image.format)
return Response(json.dumps(destination, default=str),
mimetype="application/json",
status=204)
if __name__ == "__main__":
app.run(port=4555, debug=True)
if request.method == "DELETE":
image = request.json.get("image")
print(image)
path = "/var/www/homeDelicious/home_delicious_frontend/dist/img/uploadImgs/"
image_path = path + image
print(image_path)
if os.path.exists(image_path):
os.remove(image_path)
if os.path.exists(image_path):
return Response("Delete went wrong!",
mimetype="text/html",
status=500)
else:
return Response("Delete sucess",
mimetype="application/json",
status=200)
else:
print("The file does not exist")
def main():
# Measures total program runtime by collecting start time
start_time = time()
max_width = 960
max_height = 960
folder = 'uploaded_images'
for filename in listdir(folder):
filepath = "%s/%s" % (folder, filename)
if not filename.endswith('.jpg'):
continue
size_slug = "contain%dx%d" % (max_width, max_height)
new_filename = "%s.%s.%s" % (filename.split('.')[0], size_slug,
filename.split('.')[-1])
new_filepath = "%s/%s" % (folder, new_filename)
replace_file = False
if filename == new_filename or path.isfile(new_filepath):
print("File %s already exists, skipping file" % (new_filename))
continue
with open(filepath, 'r+b') as file:
with Image.open(file) as image:
if image.width <= max_width and image.height <= max_height:
print("File %s already resized, skipping file" %
(filename))
else:
print('Resizing image %s => %s' % (filename, new_filename))
if image.width > image.height:
resized = resizeimage.resize_width(image, max_width)
else:
resized = resizeimage.resize_height(image, max_height)
resized.convert('RGB').save(new_filepath, image.format)
replace_file = True
if replace_file:
remove(filepath)
rename(new_filepath, filepath)
# Measure total program runtime by collecting end time
end_time = time()
# Computes overall runtime in seconds & prints it in hh:mm:ss format
tot_time = end_time - start_time # calculate difference between end time and start time
print(
"\n** Total Elapsed Runtime:",
str(int((tot_time / 3600))) + ":" + str(int(
(tot_time % 3600) / 60)) + ":" + str(int((tot_time % 3600) % 60)))
def test_resize_height(self):
"""
Test that the image resized with resize_height
has the expected size
"""
with self._open_test_image() as img:
img = resizeimage.resize_height(img, 200)
filename = self._tmp_filename('resize-height.jpeg')
img.save(filename, img.format)
with Image.open(filename) as image:
self.assertEqual(image.size[1], 200)
def test_resize_height(self):
"""
Test that the image resized with resize_height
has the expected size
"""
with self._open_test_image() as img:
img = resizeimage.resize_height(img, 200)
filename = self._tmp_filename('resize-height.jpeg')
img.save(filename, img.format)
with Image.open(filename) as image:
self.assertEqual(image.size[1], 200)
def img_resize(path, width: int = None, height: int = None):
with open(path, 'r+b') as f:
with Image.open(f) as img:
if height and width:
cover = resizeimage.resize_cover(img, (height, width))
elif height:
cover = resizeimage.resize_height(img, height)
else:
cover = resizeimage.resize_width(img, width)
img.save(path + '.tmp', img.format)
os.rename(path + '.tmp', path)
def _resize(inpath, outpath, width=None, height=None):
with open(inpath, 'r+b') as infile:
with Image.open(infile) as inimage:
if width and height:
thumb = resizeimage.resize_cover(inimage, [width, height])
elif width:
thumb = resizeimage.resize_width(inimage, width, validate=True)
elif height:
thumb = resizeimage.resize_height(inimage, height, validate=True)
else:
raise RuntimeError('at least width or height must be provided')
thumb.save(outpath, inimage.format)
def upload_image(image, cover=False):
image = b64decode(image.encode())
extension = imghdr.what(None, h=image)
filename = str(uuid4()) + "." + extension
pic = io.BytesIO(image)
with Image.open(pic) as image_pil:
cover = resizeimage.resize_height(image_pil, 600, validate=False)
cover.save("static/images/{}".format(filename), image_pil.format)
return filename
def create_thumbnail(input_file: str, output_file: str, width: Optional[int],
height: Optional[int]) -> None:
with open(input_file, 'rb') as fh:
img = Image.open(fh)
if width and height:
img = resizeimage.resize_thumbnail(img, [width, height])
elif width:
img = resizeimage.resize_width(img, width)
elif height:
img = resizeimage.resize_height(img, height)
else:
raise ValueError('Width or height must be specified.')
img.save(output_file)
def convert_image(image, width, height):
"""
resize the image to the correct size needed by the template.
"""
name = image.name
pio = Image.open(image)
if width is None:
img = resizeimage.resize_height(pio, height, validate=False)
else:
img = resizeimage.resize_cover(pio, [width, height], validate=False)
new_image_io = BytesIO()
img.save(new_image_io, format=pio.format)
image.delete(save=False)
image.save(name, content=ContentFile(new_image_io.getvalue()), save=False)
def _load_data(filename):
# Load an image
load_image = Image.open(data_path + filename)
#rescale the image so the smallest side (height) is 299
re_image = resizeimage.resize_height(load_image, 299)
# convert image to a numpy array
image = np.asarray(re_image)
# preprocess the image to the range that the model expects. [-1, 1]
image = 2 * (image / 255.0) - 1.0
return image
def _resize_image(final_image, width, height):
orig_data = io.BytesIO(final_image)
with Image.open(orig_data) as image:
resized = None
if width and height:
resized = resizeimage.resize_cover(image, [width, height])
elif width:
resized = resizeimage.resize_width(image, width)
elif height:
resized = resizeimage.resize_height(image, height)
resized_data = io.BytesIO()
resized.save(resized_data, image.format)
final_image = resized_data.getvalue()
return final_image
def _resize_image(final_image, width, height):
orig_data = io.BytesIO(final_image)
with Image.open(orig_data) as image:
resized = None
if width and height:
resized = resizeimage.resize_cover(image, [width, height])
elif width:
resized = resizeimage.resize_width(image, width)
elif height:
resized = resizeimage.resize_height(image, height)
resized_data = io.BytesIO()
resized.save(resized_data, image.format)
final_image = resized_data.getvalue()
return final_image
def imagegrabber(url):
proxy = getProxy()
data = requests.get(url, headers=hdr, proxies=proxy)
image = Image.open(StringIO(data.content))
if image.size[1] > 400:
img = resizeimage.resize_height(image, 400)
result = StringIO()
format = "JPEG"
img.save(result, format)
image = result.getvalue()
else:
image = data.content
return image
def post(self, request, *args, **kwargs):
image_data = request.data.get('image', None)
description = request.data.get('description', '')
r = check_too_many_reports()
if r is not None:
return r
if image_data is not None:
orig_image = image_data
pil_image = Image.open(orig_image)
width, height = pil_image.size
max_dim = 1200
if width > max_dim:
pil_image = resizeimage.resize_width(pil_image, max_dim)
elif height > max_dim:
pil_image = resizeimage.resize_height(pil_image, max_dim)
output = BytesIO()
pil_image.save(output, format='JPEG', quality=100)
output.seek(0)
inmemory = InMemoryUploadedFile(output, 'image', 'a.jpg',
'image/jpeg',
output.getbuffer().nbytes, None)
image_hash_text = imagehash.phash(pil_image)
existed_object = get_or_none(ImageReport,
image_hash=image_hash_text)
if existed_object is not None:
print(existed_object.__dict__)
return Response(
{
'result': 'already_existed',
'key': existed_object.id,
'report': existed_object.image_hash
},
status=status.HTTP_201_CREATED)
else:
image_report = ImageReport()
image_report.image_hash = image_hash_text
image_report.image = inmemory
image_report.description = description
image_report.save()
report = Report()
report.report_type = 'image'
report.image_report = image_report
report.save()
save_created_event(report)
return Response({'key': report.id},
status=status.HTTP_201_CREATED)
else:
return Response({'reason': 'Image is invalid.'},
status=status.HTTP_400_BAD_REQUEST)
def afficher(nomprogramme, db, fenetre, canvas, ordre, datedebut):
cur = db.cursor()
query = 'SELECT exercice.nom, exercice.description, exercice.image, muscle.nom, programme_exercice.nombre_repetition, programme_exercice.temps, programme_exercice.pause FROM programme_exercice JOIN exercice ON programme_exercice.exercice = exercice.ID JOIN muscle ON exercice.muscle = muscle.ID WHERE programme = (SELECT ID FROM programme WHERE nom = ?) AND ordre= ?'
try:
cur.execute(query, (nomprogramme, ordre))
for var in cur:
row = var
canvas.delete('all')
fenetre.title('lire programme')
image = PhotoImage(file='image/fond.gif', master=fenetre)
canvas.pack()
canvas.create_image(550, 300, image=image)
canvas.create_text(550, 50, text=row[0], font=("times new roman", 18))
canvas.create_text(550, 100, text=row[1], font=("times new roman", 14))
cheminimage = "image/" + str(row[2]) + ".gif"
try:
im = Image.open(cheminimage)
except:
im = Image.open("image/default.gif")
if im.size[1] >= 235:
cover = resizeimage.resize_height(im, 235)
cover.save(cheminimage, im.format)
imageexercice = PhotoImage(file=cheminimage, master=fenetre)
canvas.create_image(550, 235, image=imageexercice)
if row[5] != 0:
timer = canvas.create_text(550, 450, text="", font=("times new roman", 18), justify=CENTER)
updatetime(db, row[5], timer, canvas, fenetre, row[6], ordre, nomprogramme, datedebut)
menu.menu_footer(fenetre, canvas, db)
elif row[4] != 0:
repetition = "Vous devez faire \n " + str(row[4]) + " \n repetitions pour terminer l'exercice"
canvas.create_text(550, 400, text=repetition, font=("times new roman", 18), justify=CENTER)
button = Button(fenetre, text="Passer à l'exercice suivant",
command=lambda: afficherpause(row[6], db, fenetre, canvas, ordre, nomprogramme, datedebut),
font=("times new roman", 20), background="#59C38D", borderwidth=0,
activebackground="#2FB5A3")
canvas.create_window(550, 500, window=button)
menu.menu_footer(fenetre, canvas, db)
else:
afficherpause(row[6], db, fenetre, canvas, ordre, nomprogramme, datedebut)
menu.menu_footer(fenetre, canvas, db)
except:
terminer(datedebut, nomprogramme, db, fenetre, canvas)
def create_thumbnail(self):
"""Create thumbnail(s) for provided image"""
try:
image_file = Image.open(self.image_path)
#for tile_height in THUMBNAIL_HEIGHT:
# for tile_format in THUMBNAIL_FORMAT:
thumbnail = resizeimage.resize_height(image_file, app_config.THUMBNAIL_HEIGHT)
thumbnail.save(self.thumbnail_path)
except Exception as ex:
exc_type = ex.__class__.__name__
self.errors.append("IMG: Unable to create thumbnail image [" + self.file_name
+ "] Exception Type: " + str(exc_type) + " Error: " + str(ex))
finally:
if image_file is not None:
image_file.close()
def resize(filename, height=None):
"""
Resize the image to a certain proportion by height
:param filename: string path of file to the image
:param height: int
:return: new filename of the image
"""
if height is None:
return filename
print("Resizing %s to %spx height..." % (filename, height))
with open(filename, 'r+b') as f:
with Image.open(f) as image:
cover = resizeimage.resize_height(image, height)
new_filename = filename + '.res'
cover.save(new_filename, image.format)
return new_filename
def buttonClicked(self): #needs finishing
#print "goButton clicked"
global designingCarPark, globalMapImage
globalMapImage = resizeimage.resize_height(images[globalMapName],
imageHeight)
designingCarPark = False
listOfGroupsOfCoordinatesForLines = processingCode.GetCarParkPixelLinesToDrawFromPixelShape(
carParkShape, pixelsPerMeter)
draw = ImageDraw.Draw(globalMapImage)
listOfCoordinates = carParkShape.getVerticesCoordinates()
for eachGroupOfCoordinatesForLines in listOfGroupsOfCoordinatesForLines:
print "eachGroupOfCoordinatesForLines:"
print eachGroupOfCoordinatesForLines
draw.line(eachGroupOfCoordinatesForLines)
del draw
refreshWindow()
def resize(filename, height=None):
"""
Resize the image to a certain proportion by height
:param filename: string path of file to the image
:param height: int
:return: new filename of the image
"""
if height is None:
return filename
print("Resizing %s to %spx height..." % (filename, height))
with open(filename, 'r+b') as f:
with Image.open(f) as image:
cover = resizeimage.resize_height(image, height)
new_filename = filename + '.res'
cover.save(new_filename, image.format)
return new_filename
def resize_image(images_list):
for image_file in images_list:
with open(image_file, 'r+b') as f:
with Image.open(f) as image:
try:
width, height = image.size
if height >= width:
cover = resizeimage.resize_height(image, 512)
else:
cover = resizeimage.resize_width(image, 512)
save_files(cover, image_file, image)
except imageexceptions.ImageSizeError:
print(
colored(
f"Image {image_file} is too small to be resized! ({width}x{height})",
'red'))
save_files(image, image_file, image)
def convert_image(image, width, height):
"""
resize the image to the correct size needed by the template.
"""
name = image.name
pio = Image.open(image)
if width is None:
img = resizeimage.resize_height(pio, height, validate=False)
else:
img = resizeimage.resize_cover(pio, [width, height], validate=False)
new_image_io = BytesIO()
img.save(new_image_io, format=pio.format)
image.delete(save=False)
image.save(
name,
content=ContentFile(new_image_io.getvalue()),
save=False
)
def upload_image_to_s3(self, image_path, relative_dir, cdn_bucket, sizes=[(None,None),(320,None),(640,None),(1280,None)]):
"""Uploads the provided image into S3 in multiple sizes if the file doesn't already exist.
Returns an array of (path, width) tuples"""
image_path = image_path.replace('./', '')
with open(os.path.normpath(os.path.join(relative_dir, image_path)), 'r+b') as f:
with Image.open(f) as image:
image_s3_path = os.path.join('static/', 'images/', image_path)
images = [(self.add_suffix_to_filename(image_s3_path, size[0]), size) for size in sizes]
# If the hash of the image locally matches what is in s3, there
# is no need to upload again so return immediately
local_hash = self.md5_checksum(self.img_to_bytes(image))
s3_hash = self.get_s3_etag(cdn_bucket, image_s3_path)
if local_hash == s3_hash:
# Finally check that the files for all of the sizes we are going
# to make exist as well
tags = [self.get_s3_etag(cdn_bucket, path) for path, size in images]
if None not in tags:
return images
for (path, size) in images:
# If size is None then we are keeping the original resolution
image_sized = image
if size != (None, None):
x, y = size
if x is not None and y is not None:
image_sized = resizeimage.resize_cover(image, [x, y], validate=False)
elif y is not None:
image_sized = resizeimage.resize_height(image, y, validate=False)
else:
image_sized = resizeimage.resize_width(image, x, validate=False)
# Save the image to a byte array and upload to S3
print("> Uploading", path)
cdn_bucket.upload_fileobj(
self.img_to_bytes(image_sized),
path,
ExtraArgs={'ACL':'public-read', 'ContentType': Image.MIME[image_sized.format]}
)
return images
def resize(self, width, height, name='', type='width'):
output = os.path.join(
self.cdir, self.name + '-' + str(width) + 'x' + str(height) + '-' +
name + self.ext)
with open(self.src, 'r+b') as f:
with Image.open(f) as image:
if type == 'contain':
try:
result = resizeimage.resize_cover(
image, [width, height])
except:
tmp = resizeimage.resize_contain(
image, [width, height])
result = resizeimage.resize_cover(tmp, [width, height])
elif type == 'height':
result = resizeimage.resize_height(image,
height,
validate=False)
elif type == 'crop':
tmp = resizeimage.resize_contain(
image, [width + 150, height + 150])
result = resizeimage.resize_crop(tmp, [width, height])
elif type == 'tcrop':
tmp = resizeimage.resize_contain(image, [width, height])
result = resizeimage.resize_crop(tmp, [width, height])
elif type == 'thumbnail':
result = resizeimage.resize_thumbnail(
image, [width, height])
else:
result = resizeimage.resize_width(image,
width,
validate=False)
result.save(output, optimize=True)
return [
output, '[{}x{}] {}'.format(width, height, name),
self.name + '-' + str(width) + 'x' + str(height) + '-' +
name + self.ext, name
]
def save(self, *args, **kwargs):
pil_image_obj = Image.open(self.logo_image)
new_image = resizeimage.resize_height(
pil_image_obj,
35,
validate=False
)
new_image_io = BytesIO()
new_image.save(new_image_io, format='PNG')
temp_name = self.logo_image.name
self.logo_image.delete(save=False)
self.logo_image.save(
temp_name,
content=ContentFile(new_image_io.getvalue()),
save=False
)
super(LogoImage, self).save(*args, **kwargs)
def edit_original(big_image, generator):
"""
Takes in a full-sized image and runs the generator on a smaller version.
Returns an edited version of the full-sized image.
"""
logging.info("Resizing")
resized = resize(big_image, (hp.img_size, hp.img_size)).astype(np.float32)
logging.info("Running generator")
prob, _ = generator(resized[None])
logging.info("Scaling action space")
act_scaled, _ = generator.convert_prob_act(prob.numpy(),
det=True,
det_avg=hp.det_avg)
logging.info(big_image.shape)
if big_image.shape[0] > 400:
resized = resizeimage.resize_height(Image.fromarray(big_image), 400)
elif big_image.shape[1] > 400:
resized = resizeimage.resize_width(Image.fromarray(big_image), 400)
resized = np.array(resized)
orig_edit = PhotoEditor.edit((resized / 255)[None], act_scaled)
return orig_edit[0]
def test_can_not_resize_larger_height(self):
with self._open_test_image() as img:
with self.assertRaises(ImageSizeError):
resizeimage.resize_height(img, 534)
import sys
from PIL import Image
from io import BytesIO
import yaml
import requests
from resizeimage import resizeimage
from slugify import slugify
shows = yaml.load(sys.stdin)
for show in shows:
slug = slugify(show['title'])
filename = '../img/shows/' + slug + '.jpg'
response = requests.get(show['thumbnail'])
with Image.open(BytesIO(response.content)) as img:
img_resized = resizeimage.resize_height(img, 425)
img_resized.save(filename, img_resized.format)