| import os |
| import glob |
| import re |
| import tensorflow as tf |
| import json |
| import numpy as np |
| from PIL import Image |
|
|
| def make_json_parser(json_file, image_dir, image_size, greyscale_images=False): |
| def json_parser(): |
| with open(json_file, 'r') as file: |
| data = json.load(file) |
| for timestep in data['timesteps']: |
| image_path = os.path.join(image_dir, timestep['image_name']) |
| image = Image.open(image_path) |
| if greyscale_images: |
| image = image.convert('L') |
| image = np.array(image.resize(image_size)) |
| if greyscale_images: |
| image = np.expand_dims(image, axis=0) |
| image = image.reshape((*image_size, 1)) |
| current_pose = np.array(timestep['current_pose']['data']) |
| desired_pose = np.array(timestep['desired_pose']['data']) |
| yield (image, current_pose, desired_pose) |
| return json_parser |
|
|
| def make_timestep_dataset(make_json_parser): |
| return tf.data.Dataset.from_generator( |
| make_json_parser, |
| output_signature=(tf.TensorSpec(shape=(None, None, None), dtype=tf.uint8), |
| tf.TensorSpec(shape=(4, 4), dtype=tf.float32), |
| tf.TensorSpec(shape=(4, 4), dtype=tf.float32)) |
| ) |
|
|
| def make_trajectory_dataset(timestep_datasets): |
| return tf.data.Dataset.from_tensor_slices(timestep_datasets) |
|
|
| def flatten_nested_dataset(dataset): |
| return dataset.flat_map(lambda x: x) |
|
|
| def get_files(directory): |
| if not os.path.isdir(directory): |
| raise ValueError(f"{directory} is not a valid directory.") |
| search_path = os.path.join(directory, "*.json") |
| files = glob.glob(search_path) |
| return files |
|
|
| def make_future_timesteps_dataset(timestep_dataset, future_steps, lookahead_fields): |
| def lookahead(*args): |
| return [field[0] if i not in lookahead_fields else field for (i, field) in enumerate(args)] |
| return timestep_dataset \ |
| .window(future_steps, shift=1, stride=1, drop_remainder=True) \ |
| .flat_map(lambda *args: tf.data.Dataset.zip(args)) \ |
| .batch(future_steps) \ |
| .map(lookahead) |
|
|
| import unittest |
| class TestDataset(unittest.TestCase): |
| @staticmethod |
| def create_synthetic_timestep_dataset(size, image_size): |
| values = [] |
| for i in range(size): |
| image = np.random.rand(*image_size, 3) |
| current_pose = np.random.rand(4, 4) |
| desired_pose = np.random.rand(4, 4) |
| values.append((image, current_pose, desired_pose)) |
|
|
| def generator(): |
| for value in values: |
| yield value |
|
|
| return tf.data.Dataset.from_generator( |
| generator, |
| output_signature=( |
| tf.TensorSpec(shape=(None, None, 3), dtype=tf.uint8), |
| tf.TensorSpec(shape=(4, 4), dtype=tf.float32), |
| tf.TensorSpec(shape=(4, 4), dtype=tf.float32) |
| ) |
| ) |
|
|
| @classmethod |
| def get_test_dir(cls): |
| current_file_path = os.path.realpath(__file__) |
| base_dir = os.path.dirname(current_file_path) |
| return os.path.join(base_dir, "test_data") |
|
|
| @classmethod |
| def get_trajectory_files(cls, data_dir): |
| data_dir = os.path.join(data_dir, "trajectories") |
| json_files = get_files(data_dir) |
| return json_files |
| |
| @classmethod |
| def get_test_trajectory_files(cls): |
| return cls.get_trajectory_files(cls.get_test_dir()) |
| |
| @classmethod |
| def get_image_dir(cls, data_dir): |
| return os.path.join(data_dir, "images") |
| |
| @classmethod |
| def get_test_image_dir(cls): |
| return cls.get_image_dir(cls.get_test_dir()) |
| |
| def test_greyscale_image_generation(self): |
| json_files = self.get_test_trajectory_files() |
| self.assertTrue(len(json_files) > 0, "There should be at least one trajectory file") |
| trajectory_dataset = flatten_nested_dataset( |
| make_trajectory_dataset([ |
| make_timestep_dataset(make_json_parser(json_file, self.get_test_image_dir(), (100, 100), greyscale_images=True)) |
| for json_file in json_files |
| ]) |
| ) |
| for image, _, _ in trajectory_dataset: |
| self.assertEqual(image.shape[-1], 1, f"Image should be greyscale. found shape {image.shape}") |
|
|
| def check_timesteps_shape(self, timestep_dataset): |
| count = 0 |
| for image, current_pose, desired_pose in timestep_dataset: |
| count += 1 |
| self.assertEqual(image.shape, (100, 100, 3), "Image should have shape (100, 100, 3)") |
| self.assertEqual(current_pose.shape, (4, 4), "Current pose should have shape (4, 4)") |
| self.assertEqual(desired_pose.shape, (4, 4), "Desired pose should have shape (4, 4)") |
| self.assertGreater(count, 0) |
| |
| def check_lookahead_timestep_shape(self, lookahead_count, timestep_dataset): |
| count = 0 |
| for image, current_pose, desired_pose in timestep_dataset: |
| count += 1 |
| self.assertEqual(image.shape, (100, 100, 3), "Image should have shape (100, 100, 3)") |
| self.assertEqual(current_pose.shape, (4, 4), "Current pose should have shape (4, 4)") |
| self.assertEqual(desired_pose.shape, (lookahead_count, 4, 4), "Desired pose should have shape (4, 4)") |
| self.assertGreater(count, 0) |
|
|
| def test_json_dataset(self): |
| json_files = self.get_test_trajectory_files() |
| self.assertTrue(len(json_files) > 0, "There should be at least one trajectory file") |
| trajectory_dataset = flatten_nested_dataset(make_trajectory_dataset([make_timestep_dataset(make_json_parser(json_file, self.get_test_image_dir(), (100, 100))) for json_file in json_files])) |
| self.check_timesteps_shape(trajectory_dataset) |
| def test_synthetic_timestep_dataset(self): |
| synthetic_dataset = self.create_synthetic_timestep_dataset(5, (100, 100)) |
| self.check_timesteps_shape(synthetic_dataset) |
| def test_make_future_trajectory_dataset(self): |
| single_timestep_dataset = self.create_synthetic_timestep_dataset(5, (100, 100)) |
| single_timestep_data = [] |
| for data in single_timestep_dataset: |
| single_timestep_data.append(data) |
| future_steps = 2 |
| future_dataset = make_future_timesteps_dataset(single_timestep_dataset, future_steps=future_steps, lookahead_fields=[2]) |
| loop_count = 0 |
| self.check_lookahead_timestep_shape(future_steps, future_dataset) |
| for i, (future_image, future_current_pose, future_desired_poses) in enumerate(future_dataset): |
| image = single_timestep_data[i][0] |
| current_pose = single_timestep_data[i][1] |
| desired_poses = np.array([single_timestep_data[i + j][2] for j in range(future_steps)]) |
| self.assertTrue(np.array_equal(future_image, image)) |
| self.assertTrue(np.array_equal(future_current_pose, current_pose)) |
| self.assertTrue(np.array_equal(future_desired_poses, desired_poses)) |
| loop_count += 1 |
| self.assertEqual(loop_count, len(single_timestep_data) - future_steps + 1) |
| def test_generate_trajectory_unflattened_dataset(self): |
| single_timestep_datasets = [self.create_synthetic_timestep_dataset(5, (100, 100)) for _ in range(5)] |
| future_steps = 2 |
| future_datasets = [make_future_timesteps_dataset(single_timestep_dataset, future_steps=future_steps, lookahead_fields=[2]) for single_timestep_dataset in single_timestep_datasets] |
| trajectory_dataset = make_trajectory_dataset(future_datasets) |
| for timesteps in trajectory_dataset: |
| self.check_lookahead_timestep_shape(future_steps, timesteps) |
| def test_generate_trajectory_flattened_dataset(self): |
| single_timestep_datasets = [self.create_synthetic_timestep_dataset(5, (100, 100)) for _ in range(5)] |
| future_steps = 2 |
| future_datasets = [make_future_timesteps_dataset(single_timestep_dataset, future_steps=future_steps, lookahead_fields=[2]) for single_timestep_dataset in single_timestep_datasets] |
| trajectory_dataset = make_trajectory_dataset(future_datasets) |
| flattened_dataset = flatten_nested_dataset(trajectory_dataset) |
| self.check_lookahead_timestep_shape(future_steps, flattened_dataset) |
|
|
| if __name__ == '__main__': |
| unittest.main() |
