def _next_frame(self, frame_index: int, im1: image_types, im2: image_types,
**params) -> dict:
print('BlendingTransition::_next_frame STARTS HERE')
result = locals()
im1 = utils.verify_alpha_channel(
utils.convert_image_type(im1, np.ndarray))
im2 = utils.verify_alpha_channel(
utils.convert_image_type(im2, np.ndarray))
print('im1:', type(im1), '\tim2:', type(im2))
# im1 = PilImage.blend(im1=im1, im2=im2, alpha=frame_index/self.frames_count)
# print(f'\nSIZES: {utils.get_image_size(im1)} ; {utils.get_image_size(im2)}')
frame_resolution = params.get('frame_resolution', (1920, 1080))
print('frame_resolution:', frame_resolution)
# im1 = cv2.addWeighted(im1, frame_index/self.frames_count, im2, frame_index/self.frames_count, 0.5)
ts = blend_images_effect(im2,
im1,
frame_index / self.frames_count,
1 - frame_index / self.frames_count,
resolution=frame_resolution)
result['to_save'] = ts
result['im1'] = im1
result['im2'] = im2
print('BlendingTransition::_next_frame ENDS HERE')
return result
def set_image(self, image_inst):
curr_size = utils.get_image_size(self.image)
next_size = utils.get_image_size(image_inst)
if curr_size != next_size:
image_inst = cv2.resize(utils.convert_image_type(image_inst, numpy.ndarray), curr_size)
image_inst = utils.convert_image_type(image_inst, type(image_inst))
self.image = image_inst
def _preprocess(self, first_image: image_types, second_image: image_types,
frame_index: int) -> tuple:
# print('>> Preprocess effects...')
return (self._assign_next_effect(utils.convert_image_type(
source_image=first_image, dest_type=self.kwargs['load_as']),
process_name='preprocess_first',
frame_index=frame_index),
self._assign_next_effect(utils.convert_image_type(
source_image=second_image,
dest_type=self.kwargs['load_as']),
process_name='preprocess_second',
frame_index=frame_index))
def _next_frame(self, frame_index: int, im1: image_types, im2: image_types,
**params) -> dict:
print('bt next_frame')
result = locals()
im1 = utils.convert_image_type(im1, PillowImage)
im2 = utils.convert_image_type(im2, PillowImage)
im1 = PilImage.blend(im1=im1,
im2=im2,
alpha=frame_index / self.frames_count)
result['to_save'] = im1
return result
def _assign_next_effect(self,
image: image_types,
image_param_name='image',
process_name='preprocess_first',
frame_index=0):
# print('_assign_next_efect: ' + process_name)
if 'process_name' not in self.effects:
return image
cl: utils.CircleList = self.effects[process_name]
call_back: utils.Callback = cl.next()
if isinstance(call_back, utils.Callback):
if call_back.needs_param('frame_index'):
call_back.add_one_arg('frame_index', frame_index)
if call_back.needs_param('im1'):
call_back.add_one_arg('im1', image)
if call_back.needs_param('im2'):
call_back.add_one_arg('im2', image)
image = call_back.__call__(**{image_param_name: image})
if isinstance(image, dict):
image = image['to_save']
return utils.convert_image_type(source_image=image,
dest_type=self.kwargs['load_as'])
def reload(self, **kwargs) -> True or utils.image_types:
"""
Reloads image from drive with other params than in __init__
:keyword kwargs:
:key image_type: PIL.Image.Image or numpy.ndarray, or passed in __init__
:key resolution: new resolution or passed in __init__
:key return_image: if passed and set to True, method returns reloaded image, else returns True
:return: look above
"""
self.image = utils.load_image(self.init_params['full_path'], self.init_params['image_type'])
resolution = self.init_params['kwargs']['resolution']
image_type = kwargs.get('image_type', self.init_params['image_type'])
if kwargs.get('resolution', None) is not None:
resolution = kwargs['resolution']
if resolution is not None:
print('ImageHandler reloading, resize to', resolution)
loaded_image_size = utils.get_image_size(self.image)
if loaded_image_size != resolution:
self.image = utils.convert_image_type(
source_image=cv_effects.cut_rect(
image=self.image,
src_box=(0, 0, *loaded_image_size),
size=resolution
),
dest_type=image_type
)
self.init_params['reload_params'] = kwargs
if kwargs.get('return_image', None) is not None:
return self.image
return True
def resize_image(image: image_types, dest_image_type: image_types or None = None, dest_resolution=(1920, 1080)):
if not isinstance(dest_resolution, (list, tuple)):
if not len(dest_resolution) == 2:
raise ValueError('dest_resolution must be list/tuple of len 2. i.e. dest_resolution(720, 576)')
resized = cv2.resize(utils.load_image(image, np.ndarray), dest_resolution)
if dest_image_type is None:
return resized
return utils.convert_image_type(resized, dest_resolution)
def cut_rect(image: image_types, src_box: list or tuple, size: list or tuple = (1920, 1080)) -> np.ndarray:
if len(src_box) != 4:
raise AttributeError('cv_effects.cut_rect param src_box must be tuple of 4 (x1, y1, x2, y2)')
if len(size) != 2:
raise AttributeError('cv_effects.cut_rect param size must be tuple of 2 (width, height)')
x1, y1, x2, y2 = src_box
w, h = abs(x2 - x1), abs(y2 - y1)
image = utils.convert_image_type(image, np.ndarray)
crop_img = image[y1:y1 + h, x1:x1 + w]
return cv2.resize(crop_img, dsize=size)
def __init__(
self,
full_path: str,
image_type: utils.image_types = numpy.ndarray,
**kwargs):
"""
:param full_path: full path to image on drive
:param image_type: PIL.Image.Image or numpy.ndarray
:keyword kwargs:
:key load: loads image to RAM, pass True value for it
:key resolution: tuple (width, height) that tells to handle rescaled image
:key frame_indexes: list/tuple of ints describing positions on timeline where image should occur
:key uid_setter: instance of such class with method set_next_uid() -> str
"""
kwargs['frame_indexes'] = kwargs.get('frame_indexes', [0])
self.init_params = locals()
self.uid = None
if kwargs.get('uid_setter', False):
uid_setter = kwargs['uid_setter']
if hasattr(uid_setter, 'set_next_uid'):
uid_setter = getattr(uid_setter, 'set_next_uid')
if callable(uid_setter):
self.uid = uid_setter()
self.image = False if not kwargs.get('load', False) else utils.load_image(
image_or_path=full_path,
result_type=image_type
)
if 'resolution' in kwargs:
if self.image is not False:
self.image = utils.load_image(self.image, numpy.ndarray)
size = utils.get_image_size(self.image)
if size != kwargs['resolution']:
print('ImageHandler resize resolution to', kwargs['resolution'])
input('enter...')
self.image = cv2.resize(self.image, kwargs['resolution'])
self.image = utils.convert_image_type(self.image, image_type)
def pick_image_for_frame(self, frame_index: int = -1) -> List[utils.image_types, int]:
if frame_index == -1:
# print(f'Wizard::pick_image() for frame {frame_index} ==> (default) = {self.global_frame_index}')
frame_index = self.global_frame_index
closest, result_handler_id = self.total_slide_duration, None
for handler_id, image_handler in enumerate(self.image_handlers):
indexes = image_handler.get_frame_indexes()
if frame_index >= indexes[0]:
dist = frame_index - indexes[0]
if dist < closest:
closest, result_handler_id = dist, handler_id
if result_handler_id is None:
raise ValueError('No such image')
result = self.image_handlers[result_handler_id].get_image()
print(f'picked image.index = {result_handler_id}, with shape:', utils.get_image_size(result))
return [
cv2.resize(utils.convert_image_type(result, numpy.ndarray), self.frame_resolution),
result_handler_id
]
intensity=0.3,
red=10,
green=100,
blue=0)
import cv2
cv2.imshow('name', im)
cv2.waitKey()
cv2.destroyAllWindows()
exit()
import numpy
im = utils.load_image('source_images/1.jpg', PIL.Image.Image)
print('type after loading ', type(im))
print('type after conv ', type(utils.convert_image_type(im,
numpy.ndarray))) #
exit()
from effects.elasticdeform_effect import elastic_transform
elastic_transform(r'C:\proj\py\rw\source_images\3.jpg', 0.1, 20).show()
exit()
from effects.pixelate_effect import pixelate
pixelate("source_images/1.jpg", 256).show()
exit()
from effects.sketch_effect import sketch_v4
sk = sketch_v4("source_images/1.jpg")