def __init__(self, size, image_size, crop_size, variance):
super(ExtractHandPose, self).__init__()
self.unwrap_inputs = pr.UnpackDictionary(
['image', 'segmentation_label', 'annotations'])
self.preprocess_image = pr.SequentialProcessor(
[pr.LoadImage(), pr.ResizeImage((size, size))])
self.preprocess_segmentation_map = pr.SequentialProcessor(
[pr.LoadImage(),
pr.ResizeImage((size, size)),
ExtractHandmask()])
self.extract_annotations = pr.UnpackDictionary(['xyz', 'uv_vis', 'K'])
self.extract_2D_keypoints = Extract2DKeypoints()
self.keypoints_to_palm = KeypointstoPalmFrame()
self.visibility_to_palm = TransformVisibilityMask()
self.extract_hand_side = ExtractHandsideandKeypoints()
self.to_one_hot = ToOneHot(num_classes=2)
self.normaliza_keypoints = NormalizeKeypoints()
self.to_relative_frame = TransformtoRelativeFrame()
self.canonical_transformations = GetCanonicalTransformation()
self.flip_right_hand = FlipRightHandToLeftHand()
self.get_matrix_inverse = CalculatePseudoInverse()
self.extract_hand_visibility = ExtractDominantHandVisibility()
self.extract_dominant_keypoints = ExtractDominantKeypoints2D()
self.crop_image_from_mask = CropImageFromMask()
self.create_scoremaps = CreateScoremaps(image_size=image_size,
crop_size=crop_size,
variance=variance)
self.wrap = pr.WrapOutput(
['score_maps', 'hand_side', 'keypoints3D', 'rotation_matrix'])
def __init__(self,
prior_boxes,
split=pr.TRAIN,
num_classes=21,
size=300,
mean=pr.BGR_IMAGENET_MEAN,
IOU=.5,
variances=[0.1, 0.1, 0.2, 0.2]):
super(AugmentDetection, self).__init__()
# image processors
self.augment_image = AugmentImage()
self.augment_image.add(pr.ConvertColorSpace(pr.RGB2BGR))
self.preprocess_image = PreprocessImage((size, size), mean)
# box processors
self.augment_boxes = AugmentBoxes()
args = (num_classes, prior_boxes, IOU, variances)
self.preprocess_boxes = PreprocessBoxes(*args)
# pipeline
self.add(pr.UnpackDictionary(['image', 'boxes']))
self.add(pr.ControlMap(pr.LoadImage(), [0], [0]))
if split == pr.TRAIN:
self.add(pr.ControlMap(self.augment_image, [0], [0]))
self.add(pr.ControlMap(self.augment_boxes, [0, 1], [0, 1]))
self.add(pr.ControlMap(self.preprocess_image, [0], [0]))
self.add(pr.ControlMap(self.preprocess_boxes, [1], [1]))
self.add(
pr.SequenceWrapper({0: {
'image': [size, size, 3]
}}, {1: {
'boxes': [len(prior_boxes), 4 + num_classes]
}}))
def __init__(self, image_shape, num_classes, input_name='input_1', dataset='CityScapes'):
super(PreprocessSegmentationIds, self).__init__()
self.add(pr.UnpackDictionary(['image_path', 'label_path']))
preprocess_image = pr.SequentialProcessor()
preprocess_image.add(pr.LoadImage())
preprocess_image.add(pr.ResizeImage(image_shape))
preprocess_image.add(pr.ConvertColorSpace(pr.RGB2BGR))
preprocess_image.add(pr.SubtractMeanImage(pr.BGR_IMAGENET_MEAN))
preprocess_label = pr.SequentialProcessor()
preprocess_label.add(pr.LoadImage())
preprocess_label.add(ResizeImageWithNearestNeighbors(image_shape))
preprocess_label.add(FromIdToMask(dataset))
self.add(pr.ControlMap(preprocess_image, [0], [0]))
self.add(pr.ControlMap(preprocess_label, [1], [1]))
H, W = image_shape[:2]
self.add(pr.SequenceWrapper({0: {input_name: [H, W, 3]}},
{1: {'masks': [H, W, num_classes]}}))
def __init__(self, size=320):
super(ExtractHandSegmentation, self).__init__()
self.add(
pr.UnpackDictionary(['image', 'segmentation_label',
'annotations']))
preprocess_image = pr.SequentialProcessor(
[pr.LoadImage(), pr.ResizeImage((size, size))])
preprocess_segmentation_map = pr.SequentialProcessor(
[pr.LoadImage(),
pr.ResizeImage((size, size)),
ExtractHandmask()])
self.add(pr.ControlMap(preprocess_image, [0], [0]))
self.add(pr.ControlMap(preprocess_segmentation_map, [1], [1]))
self.add(
pr.SequenceWrapper({0: {
'image': [size, size, 3]
}}, {1: {
'hand_mask': [size, size]
}}))
def __init__(self, size, image_size, crop_size, variance):
super(ExtractHandPose2D, self).__init__()
self.unwrap_inputs = pr.UnpackDictionary(
['image', 'segmentation_label', 'annotations'])
self.preprocess_image = pr.SequentialProcessor(
[pr.LoadImage(), pr.ResizeImage((size, size))])
self.preprocess_segmentation_map = pr.SequentialProcessor(
[pr.LoadImage(),
pr.ResizeImage((size, size)),
ExtractHandmask()])
self.extract_annotations = pr.UnpackDictionary(['xyz', 'uv_vis', 'K'])
self.extract_2D_keypoints = Extract2DKeypoints()
self.keypoints_to_palm = KeypointstoPalmFrame()
self.visibility_to_palm = TransformVisibilityMask()
self.extract_hand_side = ExtractHandsideandKeypoints()
self.extract_visibility_dominant_hand = ExtractDominantHandVisibility()
self.create_scoremaps = CreateScoremaps(image_size, crop_size,
variance)
self.crop_image_from_mask = CropImageFromMask()
self.wrap = pr.WrapOutput(
['cropped_image', 'score_maps', 'keypoints_vis21'])
def __init__(self, model, colors=None):
super(PostprocessSegmentation, self).__init__()
self.add(pr.UnpackDictionary(['image_path']))
self.add(pr.LoadImage())
self.add(pr.ResizeImage(model.input_shape[1:3]))
self.add(pr.ConvertColorSpace(pr.RGB2BGR))
self.add(pr.SubtractMeanImage(pr.BGR_IMAGENET_MEAN))
self.add(pr.ExpandDims(0))
self.add(pr.Predict(model))
self.add(pr.Squeeze(0))
self.add(Round())
self.add(MasksToColors(model.output_shape[-1], colors))
self.add(pr.DenormalizeImage())
self.add(pr.CastImage('uint8'))
self.add(pr.ShowImage())
# We construct a data augmentation pipeline using the built-in PAZ processors:
augment = SequentialProcessor()
augment.add(pr.RandomContrast())
augment.add(pr.RandomBrightness())
augment.add(pr.RandomSaturation())
# We can now apply our pipeline as a normal function:
for _ in range(5):
image = load_image(image_fullpath)
# use it as a normal function
image = augment(image)
show_image(image)
# We can add to our sequential pipeline other function anywhere i.e. arg 0:
augment.insert(0, pr.LoadImage())
for _ in range(5):
# now we don't load the image every time.
image = augment(image_fullpath)
show_image(image)
# Adding new processor at the end to have a single function.
augment.add(pr.ShowImage())
for _ in range(5):
# everything compressed into a single function
image = augment(image_fullpath)
# We can also pop the last processor added.
augment.pop()
# We now create another processor for geometric augmentation.
# first we transform our numpy array into our built-in ``Box2D`` messages
to_boxes2D = pr.ToBoxes2D(class_names)
denormalize = pr.DenormalizeBoxes2D()
boxes2D = to_boxes2D(box_data)
image = load_image(image_fullpath)
boxes2D = denormalize(image, boxes2D)
draw_boxes2D = pr.DrawBoxes2D(class_names)
show_image(draw_boxes2D(image, boxes2D))
# As you can see, we were not able to put everything as a
# ``SequentialProcessor``. This is because we are dealing with 2 inputs:
# ``box_data`` and ``image``. We can join them into a single processor
# using ``pr.ControlMap`` wrap. ``pr.ControlMap`` allows you to select which
# arguments (``intro_indices``) are passed to your processor, and also where
# you should put the output of your processor (``outro_indices``).
draw_boxes = SequentialProcessor()
draw_boxes.add(pr.ControlMap(to_boxes2D, intro_indices=[1], outro_indices=[1]))
draw_boxes.add(pr.ControlMap(pr.LoadImage(), [0], [0]))
draw_boxes.add(pr.ControlMap(denormalize, [0, 1], [1], keep={0: 0}))
draw_boxes.add(pr.DrawBoxes2D(class_names))
draw_boxes.add(pr.ShowImage())
# now you have everything in a single packed function that loads and draws!
draw_boxes(image_fullpath, box_data)
# Also note if one of your function is ``eating`` away one input that you
# wish to keep in your pipeline, you can use the ``keep`` dictionary to
# explicitly say which of your inputs you wish to keep and where it should
# be located. This is represented respectively by the ``key`` and the
# ``value`` of the ``keep`` dictionary.