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.