def process(inputs, ctx, **kwargs):
image, is_video = load_image(inputs, 'inputs')
if image is None:
raise RuntimeError('Missing "inputs" key in inputs. Provide an image in "inputs" key')
def _return(result):
encoding = ''
if not is_video:
if result.shape[2] == 3:
result = result[:, :, ::-1]
result = cv2.imencode('.jpg', result)[1].tostring()
encoding = 'jpeg'
else:
result = result
result = cv2.imencode('.png', result)[1].tostring()
encoding = 'png'
return {'output': result, 'encoding': encoding}
ratio = 1.0
w = float(image.shape[1])
h = float(image.shape[0])
if w > h:
if w > 1024:
ratio = w / 1024.0
else:
if h > 1024:
ratio = h / 1024.0
if ratio > 1:
image = cv2.resize(image, (int(w / ratio), int(h / ratio)))
input = cv2.resize(image, (160, 160))
input = np.asarray(input, np.float32) / 255.0
outputs = ctx.drivers[0].predict({'image': np.expand_dims(input, axis=0)})
mask = outputs['output'][0]
mask = cv2.resize(mask, (image.shape[1], image.shape[0]))
mask = cv2.GaussianBlur(mask, (21, 21), 11)
mask = np.expand_dims(mask, 2)
back_name = get_param(inputs, 'background', None)
if back_name is not None:
background = backgrounds.get(back_name)
else:
if glob_background is not None:
background = glob_background
else:
background = backgrounds.get('None')
image = image.astype(np.float32) * mask
background = cv2.resize(background, (image.shape[1], image.shape[0]))
background = background.astype(np.float32)
background = background * (1 - mask)
image = background + image
image = image.astype(np.uint8)
return _return(image)
def process(inputs, ctx, **kwargs):
style_name = helpers.get_param(inputs, 'style', None)
default_model = ctx.global_ctx['default_model']
if style_name == 'young' or default_model == 'young':
return ctx.global_ctx['young'].process(inputs, ctx, **kwargs)
img, is_video = helpers.load_image(inputs, 'image', rgb=False)
if style_name is not None:
p = style_name.split('_')
model = default_model
if len(p) > 1:
model = p[0]
style_name = '_'.join(p[1:])
img = ctx.global_ctx[model].process(img, style_name, inputs)
if not is_video:
img = img[:, :, ::-1]
img = cv2.imencode('.jpg', img)[1].tostring()
return {'output': img}
def set_detection_params(inputs, ctx):
detection_params = [
'detect_faces',
'detect_objects',
'build_caption',
'detect_poses',
]
for param in detection_params:
raw_value = helpers.get_param(inputs, param)
if raw_value is not None:
LOG.info('%s=%s', param, raw_value)
value = raw_value
else:
# True by default
value = PARAMS.get(param, True)
setattr(ctx, param, value)
def process(inputs, ct_x, **kwargs):
original_image, is_video = load_image(inputs, 'inputs')
if original_image is None:
raise RuntimeError(
'Missing "inputs" key in inputs. Provide an image in "inputs" key')
def _return(result):
encoding = ''
if not is_video:
if result.shape[2] == 3:
result = result[:, :, ::-1]
result = cv2.imencode('.jpg', result)[1].tostring()
encoding = 'jpeg'
else:
result = result
result = cv2.imencode('.png', result)[1].tostring()
encoding = 'png'
return {'output': result, 'encoding': encoding}
ratio = 1.0
w = float(original_image.shape[1])
h = float(original_image.shape[0])
if w > h:
if w > 1024:
ratio = w / 1024.0
else:
if h > 1024:
ratio = h / 1024.0
if ratio > 1:
image = cv2.resize(original_image, (int(w / ratio), int(h / ratio)))
else:
image = original_image
if not boolean_string(get_param(inputs, 'return_origin_size', False)):
original_image = image
try:
area_threshold = int(get_param(inputs, 'area_threshold', 0))
except:
area_threshold = 0
area_threshold = limit(area_threshold, 0, 100, 0)
try:
max_objects = int(get_param(inputs, 'max_objects', 1))
except:
max_objects = 1
max_objects = limit(max_objects, 1, 10, 1)
try:
pixel_threshold = int(
float(get_param(inputs, 'pixel_threshold', 0.5)) * 255)
except:
pixel_threshold = int(0.5 * 255)
pixel_threshold = limit(pixel_threshold, 1, 254, int(0.5 * 255))
object_classes = [
obj_classes.get(get_param(inputs, 'object_class', 'Person'), 1)
]
effect = get_param(inputs, 'effect',
'Remove background') # Remove background,Mask,Blur
try:
blur_radius = int(get_param(inputs, 'blur_radius', 2))
except:
blur_radius = 2
blur_radius = limit(blur_radius, 1, 10, 2)
outputs = ct_x.drivers[0].predict(
{'inputs': np.expand_dims(image, axis=0)})
num_detection = int(outputs['num_detections'][0])
if num_detection < 1:
return _return(original_image)
process_width = image.shape[1]
process_height = image.shape[0]
image_area = process_width * process_height
detection_boxes = outputs["detection_boxes"][0][:num_detection]
detection_boxes = detection_boxes * [
process_height, process_width, process_height, process_width
]
detection_boxes = detection_boxes.astype(np.int32)
detection_classes = outputs["detection_classes"][0][:num_detection]
detection_masks = outputs["detection_masks"][0][:num_detection]
masks = []
for i in range(num_detection):
if int(detection_classes[i]) not in object_classes:
continue
box = detection_boxes[i]
mask_image = cv2.resize(detection_masks[i],
(box[3] - box[1], box[2] - box[0]),
interpolation=cv2.INTER_LINEAR)
left = max(0, box[1] - 50)
right = min(process_width, box[3] + 50)
upper = max(0, box[0] - 50)
lower = min(process_height, box[2] + 50)
box_mask = np.pad(mask_image, ((box[0] - upper, lower - box[2]),
(box[1] - left, right - box[3])),
'constant')
area = int(np.sum(np.greater_equal(box_mask, 0.5).astype(np.int32)))
if area * 100 / image_area < area_threshold:
continue
masks.append((area, box_mask, [upper, left, lower, right]))
if len(masks) < 1:
return _return(original_image)
masks = sorted(masks, key=lambda row: -row[0])
total_mask = np.zeros((process_height, process_width), np.float32)
min_left = process_width
min_upper = process_height
max_right = 0
max_lower = 0
for i in range(min(len(masks), max_objects)):
pre_mask = masks[i][1]
box = masks[i][2]
left = max(0, box[1])
right = min(process_width, box[3])
upper = max(0, box[0])
lower = min(process_height, box[2])
box_mask = np.pad(pre_mask, ((upper, process_height - lower),
(left, process_width - right)),
'constant')
total_mask = np.maximum(total_mask, box_mask)
if left < min_left:
min_left = left
if right > max_right:
max_right = right
if upper < min_upper:
min_upper = upper
if lower > max_lower:
max_lower = lower
mask = np.uint8(total_mask[min_upper:max_lower, min_left:max_right] * 255)
box = (min_upper, min_left, max_lower, max_right)
if len(mask.shape) > 2:
logging.warning('Mask shape is {}'.format(mask.shape))
mask = mask[:, :, 0]
image = cv2.resize(image[box[0]:box[2], box[1]:box[3], :], (320, 320))
mask = cv2.resize(mask, (320, 320))
mask[np.less_equal(mask, pixel_threshold)] = 0
mask[np.greater(mask, pixel_threshold)] = 255
input_trimap = generate_trimap(mask)
input_trimap = np.expand_dims(input_trimap.astype(np.float32), 2)
image = image.astype(np.float32)
input_image = image - g_mean
outputs = ct_x.drivers[1].predict({
'input':
np.expand_dims(input_image, axis=0),
'trimap':
np.expand_dims(input_trimap, axis=0)
})
mask = outputs.get('mask', None)
if mask is None:
mask = outputs['output'][0] * 255
mask = np.reshape(mask, (320, 320))
mask = np.clip(mask, 0, 255)
mask = mask.astype(np.uint8)
mask = cv2.resize(mask, (box[3] - box[1], box[2] - box[0]))
mask = mask.astype(np.float32) / 255
mask = np.pad(mask, ((box[0], process_height - box[2]),
(box[1], process_width - box[3])), 'constant')
if mask.shape != original_image.shape:
mask = cv2.resize(mask,
(original_image.shape[1], original_image.shape[0]))
mask = cv2.GaussianBlur(mask, (21, 21), 11)
if effect == 'Remove background':
background = None
if 'background_img' in inputs:
background, _ = load_image(inputs, 'background_img')
if background is None:
back_name = get_param(inputs, 'background', None)
if back_name is not None:
background = backgrounds.get(back_name)
else:
if glob_background is not None:
background = glob_background
else:
background = backgrounds.get('None')
add_style = get_param(inputs, 'style', '')
if len(add_style) > 0:
image = apply_style(original_image, add_style).astype(np.float32)
else:
image = original_image.astype(np.float32)
mask = np.expand_dims(mask, 2)
if background is not None:
image = image * mask
background = cv2.resize(background,
(image.shape[1], image.shape[0]))
background = background.astype(np.float32)
background = background * (1 - mask)
image = background + image
image = image.astype(np.uint8)
else:
if not is_video:
mask = (mask * 255).astype(np.uint8)
image = image[:, :, ::-1].astype(np.uint8)
image = np.concatenate([image, mask], axis=2)
else:
image = image * mask
image = image.astype(np.uint8)
elif effect == "Mask":
mask = mask * 255
image = mask.astype(np.uint8)
else:
image = original_image.astype(np.float32)
mask = np.expand_dims(mask, 2)
foreground = mask * image
radius = min(max(blur_radius, 2), 10)
if effect == 'Grey':
background = rgb2gray(original_image)
else:
background = cv2.GaussianBlur(original_image, (radius, radius), 10)
background = (1.0 - mask) * background.astype(np.float32)
image = foreground + background
image = image.astype(np.uint8)
return _return(image)
def process(self, inputs, ctx, **kwargs):
alpha = int(helpers.get_param(inputs, 'alpha', self._alpha))
original, is_video = helpers.load_image(inputs, 'image')
if self._portret:
original = np.transpose(original, (1, 0, 2))
output_view = helpers.get_param(inputs, 'output_view',
self._output_view)
if output_view == 'horizontal' or output_view == 'h':
x0 = int(original.shape[1] / 4)
x1 = int(original.shape[1] / 2) + x0
original = original[:, x0:x1, :]
if output_view == 'vertical' or output_view == 'v':
y0 = int(original.shape[0] / 4)
y1 = int(original.shape[0] / 2) + y0
original = original[y0:y1, :, :]
boxes = self.face_detector.bboxes(original)
boxes.sort(key=lambda box: abs((box[3] - box[1]) * (box[2] - box[0])),
reverse=True)
box = None
if len(boxes) > 0:
box = boxes[0].astype(int)
if box[3] - box[1] < 1 or box[2] - box[0] < 1:
box = None
image = original.copy()
if box is not None and self.style_model is not None:
inference_img, output, box = self.style_model.process(
ctx, image, box)
alpha = np.clip(alpha, 1, 255)
if srt_2_bool(
helpers.get_param(inputs, 'color_correction',
self._color_correction)):
output = color_tranfer(output, inference_img)
if helpers.get_param(inputs, 'transfer_mode',
self._transfer_mode) == 'direct':
output = (inference_img * self._mask_orig +
output * self._mask_face).astype(np.uint8)
output = cv2.resize(output, (box[2] - box[0], box[3] - box[1]),
interpolation=cv2.INTER_LINEAR)
image[box[1]:box[3], box[0]:box[2], :] = output
else:
output = cv2.resize(np.array(output),
(box[2] - box[0], box[3] - box[1]),
interpolation=cv2.INTER_AREA)
if helpers.get_param(inputs, 'transfer_mode',
self._transfer_mode) == 'box_margin':
xmin = max(0, box[0] - 50)
wleft = box[0] - xmin
ymin = max(0, box[1] - 50)
wup = box[1] - ymin
xmax = min(image.shape[1], box[2])
ymax = min(image.shape[0], box[3])
out = image[ymin:ymax, xmin:xmax, :]
center = (wleft + output.shape[1] // 2,
wup + output.shape[0] // 2)
samples = int(helpers.get_param(inputs, 'samples', 0))
if samples > 1:
results = {
's_0':
cv2.imencode('.jpg',
image[:, :, ::-1])[1].tostring()
}
step_alpha = 255.0 / (samples - 1)
for si in range(samples - 1):
alpha = int(step_alpha * (si + 1))
s_image = image.copy()
#out_copy = out.copy()
out = cv2.seamlessClone(
output, out,
np.ones_like(output) * alpha, center,
cv2.NORMAL_CLONE)
s_image[ymin:ymax, xmin:xmax, :] = out
results[f's_{si + 1}'] = cv2.imencode(
'.jpg', s_image[:, :, ::-1])[1].tostring()
results['output'] = results['s_4']
return results
else:
out = cv2.seamlessClone(output, out,
np.ones_like(output) * alpha,
center, cv2.NORMAL_CLONE)
image[ymin:ymax, xmin:xmax, :] = out
else:
center = (box[0] + output.shape[1] // 2,
box[1] + output.shape[0] // 2)
if not (center[0] >= output.shape[1] or
box[1] + output.shape[0] // 2 >= output.shape[0]):
image = cv2.seamlessClone(output, image,
np.ones_like(output) * alpha,
center, cv2.NORMAL_CLONE)
if len(box) > 0:
if srt_2_bool(
helpers.get_param(inputs, "draw_box", self._draw_box)):
image = cv2.rectangle(image, (box[0], box[1]),
(box[2], box[3]), (0, 255, 0), 2, 8)
result = {}
image = self.maybe_mirror(image)
if output_view == 'horizontal' or output_view == 'h' or output_view == 'fh':
image = np.hstack((self.maybe_mirror(original), image))
elif output_view == 'vertical' or output_view == 'v':
image = np.vstack((self.maybe_mirror(original), image))
image = self.add_overlay(image)
image = image[:, :, ::-1]
if not is_video:
image_bytes = cv2.imencode('.jpg', image)[1].tostring()
else:
image_bytes = image[:, :, ::-1]
h = 480
w = int(480 * image.shape[1] / image.shape[0])
result['status'] = cv2.resize(image, (w, h))
result['output'] = image_bytes
return result