def image_with_single_person():
URL = ('https://github.com/oarriaga/altamira-data/releases/download'
'/v0.10/single_person_test_pose.png')
filename = os.path.basename(URL)
fullpath = get_file(filename, URL, cache_subdir='paz/tests')
image = load_image(fullpath)
return image
def image_with_YCB_objects():
URL = ('https://github.com/oarriaga/altamira-data/releases/download'
'/v0.9.1/image_with_YCB_objects.jpg')
filename = os.path.basename(URL)
fullpath = get_file(filename, URL, cache_subdir='paz/tests')
image = load_image(fullpath)
return image
def load_data(self, path, label, with_crop=True):
data = []
for filename in os.listdir(path):
face = load_image(os.path.join(path, filename))
if with_crop:
croped_face = self.crop(face)
sample = {'image': croped_face, 'label': label}
data.append(sample)
return data
def predict(target_dir: pathlib.Path) -> Dict[str, np.ndarray]:
results = {}
detect = EmotionDetector()
for i, img_file in enumerate(map(str, target_dir.glob("*.png"))):
image = load_image(img_file)
predictions = detect(image)
if len(predictions) != 1:
continue
print(f"{i:05d} {img_file}", predictions[0][0].tolist())
results[img_file] = predictions[0][0]
return results
import argparse
from pipelines import DetectGMMKeypointNet2D
from paz.backend.image import show_image, load_image
description = 'Demo for visualizing uncertainty in probabilistic keypoints'
parser = argparse.ArgumentParser(description=description)
parser.add_argument('-p', '--path', type=str, help='Path to image')
args = parser.parse_args()
pipeline = DetectGMMKeypointNet2D()
image = load_image(args.path)
inferences = pipeline(image)
show_image(inferences['image'])
show_image(inferences['contours'][0])
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(ResizeImageWithNearestNeighbors((1024, 512)))
# self.add(pr.ShowImage())
num_classes = len(data_manager.class_names)
input_shape = (128, 128, 3)
model = UNET_VGG16(num_classes, input_shape, 'imagenet', activation='softmax')
post_process = PostprocessSegmentation(model)
model.load_weights(args.weights_path)
for sample in data:
masks = post_process(sample)
image = load_image(sample['image_path'])
image = resize_image(image, (1024, 512))
image_with_masks = ((0.6 * image) + (0.4 * masks)).astype("uint8")
# image_and_masks = np.concatenate([image, masks], axis=1)
show_image(image_with_masks)
import os
from tensorflow.keras.utils import get_file
from paz.backend.image import load_image, show_image
from paz.applications import MinimalHandPoseEstimation
URL = ('https://github.com/oarriaga/altamira-data/releases/download'
'/v0.14/image_with_hand.png')
filename = os.path.basename(URL)
fullpath = get_file(filename, URL, cache_subdir='paz/tests')
image = load_image(fullpath)
detect = MinimalHandPoseEstimation(right_hand=False)
inferences = detect(image)
image = inferences['image']
show_image(image)
import os
from paz.abstract import SequentialProcessor
from paz.backend.image import show_image, load_image
import paz.processors as pr
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.utils import get_file
# let's download a test image and put it inside our PAZ directory
IMAGE_URL = ('https://github.com/oarriaga/altamira-data/releases/download'
'/v0.9/image_augmentation.png')
filename = os.path.basename(IMAGE_URL)
image_fullpath = get_file(filename, IMAGE_URL, cache_subdir='paz/tutorials')
# we load the original image and display it
image = load_image(image_fullpath)
show_image(image)
# 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)
def test_load_image_shape_with_4_channels(image_with_face_fullpath):
image = opencv_image.load_image(image_with_face_fullpath, 4)
assert len(image.shape) == 3
assert image.shape[-1] == 4
def test_passes(image_with_face_fullpath):
with pytest.raises(Exception):
opencv_image.load_image(image_with_face_fullpath, 2)
opencv_image.load_image(image_with_face_fullpath, 5)
from paz.pipelines import DetectSingleShot
from paz.models.detection import SSD300
from paz.backend.image import load_image, show_image, write_image
class SSD300SolarPanel(DetectSingleShot):
def __init__(self,
weights_path,
score_thresh=0.50,
nms_thresh=0.45,
draw=True):
class_names = ['background', 'solar_panel']
model = SSD300(len(class_names), None, None)
model.load_weights(weights_path)
super(SSD300SolarPanel, self).__init__(model,
class_names,
score_thresh,
nms_thresh,
draw=draw)
# weights_path = 'trained_models/SSD300/weights.172-3.15.hdf5'
weights_path = 'trained_models/SSD300/weights.141-2.66.hdf5'
detect = SSD300SolarPanel(weights_path)
image_paths = glob.glob('datasets/test_solar_panel/*.jpg')
for image_arg, image_path in enumerate(image_paths):
image = load_image(image_path)
results = detect(image)
# show_image(results['image'])
write_image('results/image_%s.png' % image_arg, results['image'])
def test_load_image_shape_with_1_channel(image_with_face_fullpath):
image = opencv_image.load_image(image_with_face_fullpath, 1)
assert len(image.shape) == 2
parser.add_argument('-p', '--image_path', type=str,
help='full image path used for the pipelines')
parser.add_argument('-c', '--camera_id', type=str,
help='Camera/device ID')
parser.add_argument('-d', '--dataset', type=str, default='COCO',
choices=['VOC', 'COCO', 'YCBVideo', 'FAT'],
help='Dataset name')
args = parser.parse_args()
name_to_model = {'VOC': SSD300VOC, 'FAT': SSD300FAT, 'COCO': SSD512COCO,
'YCBVideo': SSD512YCBVideo}
image = load_image(args.image_path)
H = 1000
W = int((H / image.shape[0]) * image.shape[1])
# image = resize_image(image, (W, H))
focal_length = image.shape[1]
image_center = (image.shape[1] / 2.0, image.shape[0] / 2.0)
camera = Camera(args.camera_id)
camera.distortion = np.zeros((4, 1))
camera.intrinsics = np.array([[focal_length, 0, image_center[0]],
[0, focal_length, image_center[1]],
[0, 0, 1]])
pipeline_A = DetectMiniXceptionFER([args.offset, args.offset])
pipeline_B = DetectFaceKeypointNet2D32()
pipeline_C = HeadPoseKeypointNet2D32(camera)
from paz.backend.image import show_image, load_image, resize_image
from paz.backend.camera import Camera
from paz.pipelines import PIX2YCBTools6D
image = load_image('images/unit_test.png')
# image = load_image('images/group_photo_onefourth.png')
print(image.shape)
camera = Camera()
camera.intrinsics_from_HFOV(55, image.shape)
pipeline = PIX2YCBTools6D(camera)
inferences = pipeline(image)
predicted_image = inferences['image']
H, W = predicted_image.shape[:2]
predicted_image = resize_image(predicted_image, (W * 3, H * 3))
show_image(predicted_image)
"""
from paz.backend.camera import VideoPlayer
camera = Camera(4)
camera.intrinsics_from_HFOV(55)
pipeline = PIX2YCBTools6D(camera, resize=False)
player = VideoPlayer((640 * 3, 480 * 3), pipeline, camera)
player.run()
"""
import os
import numpy as np
from paz.abstract import SequentialProcessor
from paz.backend.image import show_image, load_image
import paz.processors as pr
from tensorflow.keras.utils import get_file
# let's download a test image and put it inside our PAZ directory
IMAGE_URL = ('https://github.com/oarriaga/altamira-data/releases/download'
'/v0.9/object_detection_augmentation.png')
filename = os.path.basename(IMAGE_URL)
image_fullpath = get_file(filename, IMAGE_URL, cache_subdir='paz/tutorials')
# The x_min, y_min are the **noramlized** coordinates
# of **top-left** bounding-box corner.
H, W = load_image(image_fullpath).shape[:2]
# The x_max, y_max are the **normalized** coordinates
class_names = ['background', 'human', 'horse']
box_data = np.array([[200 / W, 60 / H, 300 / W, 200 / H, 1],
[100 / W, 90 / H, 400 / W, 300 / H, 2]])
# Let's visualize our boxes!
# 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))
points2D = denormalize_points2D(points2D, 128, 128)
success, rotation, translation = predict_pose(points3D, points2D)
quaternion = rotation_vector_to_quaternion(rotation)
pose6D = Pose6D(quaternion, translation, 'solar_panel')
poses6D = [pose6D]
# show_image(image)
points = [[points2D, points3D]]
image = draw_masks(image, points, object_sizes)
image = image.astype('float')
image = draw_poses6D(image, poses6D, cube_points3D, camera_intrinsics)
image = image.astype('uint8')
image = resize_image(image, (256 * 3, 256 * 3))
show_image(image)
image = load_image('images/zed_left_1011.png')
image = image[250:800, 250:850, :]
H, W, num_channels = image.shape
# image = resize_image(image, (W * 20, H * 20))
quick_pose(image)
image = load_image('images/MicrosoftTeams-image.png')
quick_pose(image)
image = load_image('images/zed_left_705.png')
image = image[250:1080, 250:1400, :]
quick_pose(image)
image = load_image('images/zed_left_792.png')
# image = image[280:1060, 320:1060, :]
if __name__ == "__main__":
from paz.backend.image import show_image, load_image
from paz.backend.camera import Camera
from paz.pipelines import RGBMaskToPowerDrillPose6D
from paz.pipelines import SSD300FAT
def approximate_intrinsics(image):
image_size = image.shape[0:2]
focal_length = image_size[1]
image_center = (image_size[1] / 2.0, image_size[0] / 2.0)
camera_intrinsics = np.array([[focal_length, 0, image_center[0]],
[0, focal_length, image_center[1]],
[0, 0, 1]])
return camera_intrinsics
image = load_image('images/test_image2.jpg')
camera = Camera(device_id=0)
camera.intrinsics = approximate_intrinsics(image)
camera.distortion = np.zeros((4))
estimate_pose = RGBMaskToPowerDrillPose6D(camera, 0.15, draw=False)
pipeline = PIX2POSE_ROCK(estimate_pose, [0.5, 0.5], ['035_power_drill'],
True)
detect = SSD300FAT(0.5, 0.45, draw=False)
boxes2D = detect(image)['boxes2D']
inferences = pipeline(image, boxes2D)
predicted_image = inferences['image']
show_image(predicted_image)
