From b6933ff322807a203afdec5aae879d001142452c Mon Sep 17 00:00:00 2001 From: Ponku Date: Tue, 2 Aug 2022 15:42:58 +0100 Subject: [PATCH 01/10] Added ETH3D stereo dataset --- docs/source/datasets.rst | 1 + test/test_datasets.py | 70 ++++++++++++++++ torchvision/datasets/__init__.py | 3 +- torchvision/datasets/_stereo_matching.py | 100 +++++++++++++++++++++++ 4 files changed, 173 insertions(+), 1 deletion(-) diff --git a/docs/source/datasets.rst b/docs/source/datasets.rst index af7ac072e31..e0931b12ae5 100644 --- a/docs/source/datasets.rst +++ b/docs/source/datasets.rst @@ -111,6 +111,7 @@ Stereo Matching CarlaStereo Kitti2012Stereo Kitti2015Stereo + ETH3DStereo Image pairs ~~~~~~~~~~~ diff --git a/test/test_datasets.py b/test/test_datasets.py index 54696b0d6a8..1206998518d 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -2841,5 +2841,75 @@ def test_train_splits(self): datasets_utils.shape_test_for_stereo(left, right, disparity) +class ETH3DStereoestCase(datasets_utils.ImageDatasetTestCase): + DATASET_CLASS = datasets.ETH3DStereo + ADDITIONAL_CONFIGS = datasets_utils.combinations_grid(split=("train", "test")) + FEATURE_TYPES = (PIL.Image.Image, PIL.Image.Image, (np.ndarray, type(None)), (np.ndarray, type(None))) + + @staticmethod + def _create_scene_folder(num_examples: int, root_dir: str): + # make the root_dir if it does not exits + root_dir = pathlib.Path(root_dir) + os.makedirs(root_dir, exist_ok=True) + + for i in range(num_examples): + scene_dir = root_dir / f"scene_{i}" + os.makedirs(scene_dir, exist_ok=True) + # populate with left right images + datasets_utils.create_image_file(root=scene_dir, name="im0.png", size=(100, 100)) + datasets_utils.create_image_file(root=scene_dir, name="im1.png", size=(100, 100)) + + @staticmethod + def _create_annotation_folder(num_examples: int, root_dir: str): + # make the root_dir if it does not exits + root_dir = pathlib.Path(root_dir) + os.makedirs(root_dir, exist_ok=True) + + # create scene directories + for i in range(num_examples): + scene_dir = root_dir / f"scene_{i}" + os.makedirs(scene_dir, exist_ok=True) + # populate with a random png file for occlusion mask, and a pfm file for disparity + datasets_utils.create_image_file(root=scene_dir, name="mask0nocc.png", size=(1, 100, 100)) + + pfm_path = scene_dir / "disp0GT.pfm" + datasets_utils.make_fake_pfm_file(h=100, w=100, file_name=pfm_path) + + def inject_fake_data(self, tmpdir, config): + eth3d_dir = pathlib.Path(tmpdir) / "ETH3D" + + num_examples = 2 if config["split"] == "train" else 3 + + split_name = "two_view_training" if config["split"] == "train" else "two_view_test" + split_dir = eth3d_dir / split_name + self._create_scene_folder(num_examples, split_dir) + + if config["split"] == "train": + annot_dir = eth3d_dir / "two_view_training_gt" + self._create_annotation_folder(num_examples, annot_dir) + + return num_examples + + def test_training_splits(self): + with self.create_dataset(split="train") as (dataset, _): + assert dataset._images and len(dataset._images) == len( + dataset._disparities + ), "Training images do not match with training disparities" + for left, right, disparity, valid_mask in dataset: + datasets_utils.shape_test_for_stereo(left, right, disparity, valid_mask) + + def test_testing_splits(self): + with self.create_dataset(split="test") as (dataset, _): + assert all(d == (None, None) for d in dataset._disparities) + for left, right, disparity, valid_mask in dataset: + assert valid_mask is None + datasets_utils.shape_test_for_stereo(left, right, disparity) + + def test_bad_input(self): + with pytest.raises(ValueError, match="Unknown value 'bad' for argument split"): + with self.create_dataset(split="bad"): + pass + + if __name__ == "__main__": unittest.main() diff --git a/torchvision/datasets/__init__.py b/torchvision/datasets/__init__.py index d8b6293fb42..5db66464f6d 100644 --- a/torchvision/datasets/__init__.py +++ b/torchvision/datasets/__init__.py @@ -1,5 +1,5 @@ from ._optical_flow import FlyingChairs, FlyingThings3D, HD1K, KittiFlow, Sintel -from ._stereo_matching import CarlaStereo, Kitti2012Stereo, Kitti2015Stereo +from ._stereo_matching import CarlaStereo, ETH3DStereo, Kitti2012Stereo, Kitti2015Stereo from .caltech import Caltech101, Caltech256 from .celeba import CelebA from .cifar import CIFAR10, CIFAR100 @@ -109,4 +109,5 @@ "Kitti2012Stereo", "Kitti2015Stereo", "CarlaStereo", + "ETH3DStereo", ) diff --git a/torchvision/datasets/_stereo_matching.py b/torchvision/datasets/_stereo_matching.py index de213fc0368..d5d2ab244a4 100644 --- a/torchvision/datasets/_stereo_matching.py +++ b/torchvision/datasets/_stereo_matching.py @@ -359,3 +359,103 @@ def __getitem__(self, index: int) -> Tuple: Both ``disparity`` and ``valid_mask`` are ``None`` if the dataset split is test. """ return super().__getitem__(index) + + +class ETH3DStereo(StereoMatchingDataset): + """ "ETH3D `Low-Res Two-View `_ dataset. + + The dataset is expected to have the following structure: :: + + root + ETH3D + two_view_training + scene1 + im1.png + im0.png + images.txt + cameras.txt + calib.txt + scene2 + im1.png + im0.png + images.txt + cameras.txt + calib.txt + ... + two_view_training_gt + scene1 + disp0GT.pfm + mask0nocc.png + scene2 + disp0GT.pfm + mask0nocc.png + ... + two_view_testing + scene1 + im1.png + im0.png + images.txt + cameras.txt + calib.txt + scene2 + im1.png + im0.png + images.txt + cameras.txt + calib.txt + ... + + Args: + root (string): Root directory of the ETH3D Dataset. + split (string, optional): The dataset split of scenes, either "train" (default) or "test". + transforms (callable, optional): A function/transform that takes in a sample and returns a transformed version. + """ + + _has_built_in_disparity_mask = True + + def __init__(self, root: str, split: str = "train", transforms: Optional[Callable] = None): + super().__init__(root, transforms) + + verify_str_arg(split, "split", valid_values=("train", "test")) + + root = Path(root) / "ETH3D" + + img_dir = "two_view_training" if split == "train" else "two_view_test" + anot_dir = "two_view_training_gt" + + left_img_pattern = str(root / img_dir / "*" / "im0.png") + right_img_pattern = str(root / img_dir / "*" / "im1.png") + self._images = self._scan_pairs(left_img_pattern, right_img_pattern) + + if split == "test": + self._disparities = list((None, None) for _ in self._images) + else: + disparity_pattern = str(root / anot_dir / "*" / "disp0GT.pfm") + self._disparities = self._scan_pairs(disparity_pattern, None) + + def _read_disparity(self, file_path: str) -> Tuple: + # test split has no disparity maps + if file_path is None: + return None, None + + disparity_map = _read_pfm_file(file_path) + disparity_map = np.abs(disparity_map) # ensure that the disparity is positive + mask_path = Path(file_path).parent / "mask0nocc.png" + valid_mask = Image.open(mask_path) + valid_mask = np.asarray(valid_mask).astype(np.bool_) + return disparity_map, valid_mask + + def __getitem__(self, index: int) -> Tuple: + """Return example at given index. + + Args: + index(int): The index of the example to retrieve + + Returns: + tuple: A 4-tuple with ``(img_left, img_right, disparity, valid_mask)``. + The disparity is a numpy array of shape (1, H, W) and the images are PIL images. + ``valid_mask`` is implicitly ``None`` if the ``transforms`` parameter does not + generate a valid mask. + Both ``disparity`` and ``valid_mask`` are ``None`` if the dataset split is test. + """ + return super().__getitem__(index) From eac1590ce0f97a3e760d1524ff11bdca2ec1b5e4 Mon Sep 17 00:00:00 2001 From: Ponku Date: Tue, 2 Aug 2022 15:44:34 +0100 Subject: [PATCH 02/10] Small doc-reformating --- torchvision/datasets/_stereo_matching.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torchvision/datasets/_stereo_matching.py b/torchvision/datasets/_stereo_matching.py index d5d2ab244a4..9cf488be8ea 100644 --- a/torchvision/datasets/_stereo_matching.py +++ b/torchvision/datasets/_stereo_matching.py @@ -362,7 +362,7 @@ def __getitem__(self, index: int) -> Tuple: class ETH3DStereo(StereoMatchingDataset): - """ "ETH3D `Low-Res Two-View `_ dataset. + """ETH3D `Low-Res Two-View `_ dataset. The dataset is expected to have the following structure: :: From 1478a8c056bbed59b6f4a67f78a5cfac84cc9fda Mon Sep 17 00:00:00 2001 From: Ponku Date: Wed, 3 Aug 2022 14:04:24 +0100 Subject: [PATCH 03/10] Removed assertions with no use, changed np conversion --- test/test_datasets.py | 4 ---- torchvision/datasets/_stereo_matching.py | 2 +- 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/test/test_datasets.py b/test/test_datasets.py index 1206998518d..254bbe6e8e1 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -2892,15 +2892,11 @@ def inject_fake_data(self, tmpdir, config): def test_training_splits(self): with self.create_dataset(split="train") as (dataset, _): - assert dataset._images and len(dataset._images) == len( - dataset._disparities - ), "Training images do not match with training disparities" for left, right, disparity, valid_mask in dataset: datasets_utils.shape_test_for_stereo(left, right, disparity, valid_mask) def test_testing_splits(self): with self.create_dataset(split="test") as (dataset, _): - assert all(d == (None, None) for d in dataset._disparities) for left, right, disparity, valid_mask in dataset: assert valid_mask is None datasets_utils.shape_test_for_stereo(left, right, disparity) diff --git a/torchvision/datasets/_stereo_matching.py b/torchvision/datasets/_stereo_matching.py index 9cf488be8ea..a2db1670505 100644 --- a/torchvision/datasets/_stereo_matching.py +++ b/torchvision/datasets/_stereo_matching.py @@ -442,7 +442,7 @@ def _read_disparity(self, file_path: str) -> Tuple: disparity_map = np.abs(disparity_map) # ensure that the disparity is positive mask_path = Path(file_path).parent / "mask0nocc.png" valid_mask = Image.open(mask_path) - valid_mask = np.asarray(valid_mask).astype(np.bool_) + valid_mask = np.asarray(valid_mask).astype(bool) return disparity_map, valid_mask def __getitem__(self, index: int) -> Tuple: From a4eac5f8f89e6776c8f7296aabcd66afcad644e1 Mon Sep 17 00:00:00 2001 From: Ponku Date: Tue, 2 Aug 2022 15:42:58 +0100 Subject: [PATCH 04/10] Added ETH3D stereo dataset --- docs/source/datasets.rst | 1 + test/test_datasets.py | 81 +++++++++++++ torchvision/datasets/__init__.py | 2 + torchvision/datasets/_stereo_matching.py | 140 ++++++++++++++++++++--- 4 files changed, 207 insertions(+), 17 deletions(-) diff --git a/docs/source/datasets.rst b/docs/source/datasets.rst index 572f526dc2e..7641139daed 100644 --- a/docs/source/datasets.rst +++ b/docs/source/datasets.rst @@ -115,6 +115,7 @@ Stereo Matching SceneFlowStereo SintelStereo InStereo2k + ETH3DStereo Image pairs ~~~~~~~~~~~ diff --git a/test/test_datasets.py b/test/test_datasets.py index 3a17758531c..1120f41978d 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -2872,15 +2872,26 @@ def inject_fake_data(self, tmpdir, config): os.makedirs(fallingthings_dir, exist_ok=True) num_examples = {"single": 2, "mixed": 3, "both": 4}.get(config["variant"], 0) + variants = { "single": ["single"], "mixed": ["mixed"], "both": ["single", "mixed"], }.get(config["variant"], []) + variant_dir_prefixes = { + "single": 1, + "mixed": 0, + } + for variant_name in variants: variant_dir = pathlib.Path(fallingthings_dir) / variant_name os.makedirs(variant_dir, exist_ok=True) + + for i in range(variant_dir_prefixes[variant_name]): + variant_dir = variant_dir / f"{i:02d}" + os.makedirs(variant_dir, exist_ok=True) + for i in range(num_examples): self._make_scene_folder( root=variant_dir, @@ -3109,5 +3120,75 @@ def test_bad_input(self): pass +class ETH3DStereoestCase(datasets_utils.ImageDatasetTestCase): + DATASET_CLASS = datasets.ETH3DStereo + ADDITIONAL_CONFIGS = datasets_utils.combinations_grid(split=("train", "test")) + FEATURE_TYPES = (PIL.Image.Image, PIL.Image.Image, (np.ndarray, type(None)), (np.ndarray, type(None))) + + @staticmethod + def _create_scene_folder(num_examples: int, root_dir: str): + # make the root_dir if it does not exits + root_dir = pathlib.Path(root_dir) + os.makedirs(root_dir, exist_ok=True) + + for i in range(num_examples): + scene_dir = root_dir / f"scene_{i}" + os.makedirs(scene_dir, exist_ok=True) + # populate with left right images + datasets_utils.create_image_file(root=scene_dir, name="im0.png", size=(100, 100)) + datasets_utils.create_image_file(root=scene_dir, name="im1.png", size=(100, 100)) + + @staticmethod + def _create_annotation_folder(num_examples: int, root_dir: str): + # make the root_dir if it does not exits + root_dir = pathlib.Path(root_dir) + os.makedirs(root_dir, exist_ok=True) + + # create scene directories + for i in range(num_examples): + scene_dir = root_dir / f"scene_{i}" + os.makedirs(scene_dir, exist_ok=True) + # populate with a random png file for occlusion mask, and a pfm file for disparity + datasets_utils.create_image_file(root=scene_dir, name="mask0nocc.png", size=(1, 100, 100)) + + pfm_path = scene_dir / "disp0GT.pfm" + datasets_utils.make_fake_pfm_file(h=100, w=100, file_name=pfm_path) + + def inject_fake_data(self, tmpdir, config): + eth3d_dir = pathlib.Path(tmpdir) / "ETH3D" + + num_examples = 2 if config["split"] == "train" else 3 + + split_name = "two_view_training" if config["split"] == "train" else "two_view_test" + split_dir = eth3d_dir / split_name + self._create_scene_folder(num_examples, split_dir) + + if config["split"] == "train": + annot_dir = eth3d_dir / "two_view_training_gt" + self._create_annotation_folder(num_examples, annot_dir) + + return num_examples + + def test_training_splits(self): + with self.create_dataset(split="train") as (dataset, _): + assert dataset._images and len(dataset._images) == len( + dataset._disparities + ), "Training images do not match with training disparities" + for left, right, disparity, valid_mask in dataset: + datasets_utils.shape_test_for_stereo(left, right, disparity, valid_mask) + + def test_testing_splits(self): + with self.create_dataset(split="test") as (dataset, _): + assert all(d == (None, None) for d in dataset._disparities) + for left, right, disparity, valid_mask in dataset: + assert valid_mask is None + datasets_utils.shape_test_for_stereo(left, right, disparity) + + def test_bad_input(self): + with pytest.raises(ValueError, match="Unknown value 'bad' for argument split"): + with self.create_dataset(split="bad"): + pass + + if __name__ == "__main__": unittest.main() diff --git a/torchvision/datasets/__init__.py b/torchvision/datasets/__init__.py index 68b8ec61d6f..e8793ca0162 100644 --- a/torchvision/datasets/__init__.py +++ b/torchvision/datasets/__init__.py @@ -7,6 +7,7 @@ Kitti2015Stereo, SceneFlowStereo, SintelStereo, + ETH3DStereo, ) from .caltech import Caltech101, Caltech256 from .celeba import CelebA @@ -121,4 +122,5 @@ "SceneFlowStereo", "SintelStereo", "InStereo2k", + "ETH3DStereo", ) diff --git a/torchvision/datasets/_stereo_matching.py b/torchvision/datasets/_stereo_matching.py index d9dbd18a541..3938af68c7b 100644 --- a/torchvision/datasets/_stereo_matching.py +++ b/torchvision/datasets/_stereo_matching.py @@ -371,19 +371,20 @@ class FallingThingsStereo(StereoMatchingDataset): root FallingThings single - scene1 - _object_settings.json - _camera_settings.json - image1.left.depth.png - image1.right.depth.png - image1.left.jpg - image1.right.jpg - image2.left.depth.png - image2.right.depth.png - image2.left.jpg - image2.right - ... - scene2 + dir1 + scene1 + _object_settings.json + _camera_settings.json + image1.left.depth.png + image1.right.depth.png + image1.left.jpg + image1.right.jpg + image2.left.depth.png + image2.right.depth.png + image2.left.jpg + image2.right + ... + scene2 ... mixed scene1 @@ -420,13 +421,18 @@ def __init__(self, root: str, variant: str = "single", transforms: Optional[Call "both": ["single", "mixed"], }[variant] + split_prefix = { + "single": Path("*") / "*", + "mixed": Path("*"), + } + for s in variants: - left_img_pattern = str(root / s / "*" / "*.left.jpg") - right_img_pattern = str(root / s / "*" / "*.right.jpg") + left_img_pattern = str(root / s / split_prefix[s] / "*.left.jpg") + right_img_pattern = str(root / s / split_prefix[s] / "*.right.jpg") self._images += self._scan_pairs(left_img_pattern, right_img_pattern) - left_disparity_pattern = str(root / s / "*" / "*.left.depth.png") - right_disparity_pattern = str(root / s / "*" / "*.right.depth.png") + left_disparity_pattern = str(root / s / split_prefix[s] / "*.left.depth.png") + right_disparity_pattern = str(root / s / split_prefix[s] / "*.right.depth.png") self._disparities += self._scan_pairs(left_disparity_pattern, right_disparity_pattern) def _read_disparity(self, file_path: str) -> Tuple: @@ -762,3 +768,103 @@ def __getitem__(self, index: int) -> Tuple: a 4-tuple with ``(img_left, img_right, disparity, valid_mask)`` is returned. """ return super().__getitem__(index) + + +class ETH3DStereo(StereoMatchingDataset): + """ETH3D `Low-Res Two-View `_ dataset. + + The dataset is expected to have the following structure: :: + + root + ETH3D + two_view_training + scene1 + im1.png + im0.png + images.txt + cameras.txt + calib.txt + scene2 + im1.png + im0.png + images.txt + cameras.txt + calib.txt + ... + two_view_training_gt + scene1 + disp0GT.pfm + mask0nocc.png + scene2 + disp0GT.pfm + mask0nocc.png + ... + two_view_testing + scene1 + im1.png + im0.png + images.txt + cameras.txt + calib.txt + scene2 + im1.png + im0.png + images.txt + cameras.txt + calib.txt + ... + + Args: + root (string): Root directory of the ETH3D Dataset. + split (string, optional): The dataset split of scenes, either "train" (default) or "test". + transforms (callable, optional): A function/transform that takes in a sample and returns a transformed version. + """ + + _has_built_in_disparity_mask = True + + def __init__(self, root: str, split: str = "train", transforms: Optional[Callable] = None): + super().__init__(root, transforms) + + verify_str_arg(split, "split", valid_values=("train", "test")) + + root = Path(root) / "ETH3D" + + img_dir = "two_view_training" if split == "train" else "two_view_test" + anot_dir = "two_view_training_gt" + + left_img_pattern = str(root / img_dir / "*" / "im0.png") + right_img_pattern = str(root / img_dir / "*" / "im1.png") + self._images = self._scan_pairs(left_img_pattern, right_img_pattern) + + if split == "test": + self._disparities = list((None, None) for _ in self._images) + else: + disparity_pattern = str(root / anot_dir / "*" / "disp0GT.pfm") + self._disparities = self._scan_pairs(disparity_pattern, None) + + def _read_disparity(self, file_path: str) -> Tuple: + # test split has no disparity maps + if file_path is None: + return None, None + + disparity_map = _read_pfm_file(file_path) + disparity_map = np.abs(disparity_map) # ensure that the disparity is positive + mask_path = Path(file_path).parent / "mask0nocc.png" + valid_mask = Image.open(mask_path) + valid_mask = np.asarray(valid_mask).astype(bool) + return disparity_map, valid_mask + + def __getitem__(self, index: int) -> Tuple: + """Return example at given index. + + Args: + index(int): The index of the example to retrieve + + Returns: + tuple: A 4-tuple with ``(img_left, img_right, disparity, valid_mask)``. + The disparity is a numpy array of shape (1, H, W) and the images are PIL images. + ``valid_mask`` is implicitly ``None`` if the ``transforms`` parameter does not + generate a valid mask. + Both ``disparity`` and ``valid_mask`` are ``None`` if the dataset split is test. + """ + return super().__getitem__(index) From a63500d6edc3adf9495a2f60996d7a86f4838731 Mon Sep 17 00:00:00 2001 From: Ponku Date: Wed, 3 Aug 2022 14:04:24 +0100 Subject: [PATCH 05/10] Removed assertions with no use, changed np conversion --- test/test_datasets.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/test/test_datasets.py b/test/test_datasets.py index 1120f41978d..207f11d8564 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -3171,15 +3171,11 @@ def inject_fake_data(self, tmpdir, config): def test_training_splits(self): with self.create_dataset(split="train") as (dataset, _): - assert dataset._images and len(dataset._images) == len( - dataset._disparities - ), "Training images do not match with training disparities" for left, right, disparity, valid_mask in dataset: datasets_utils.shape_test_for_stereo(left, right, disparity, valid_mask) def test_testing_splits(self): with self.create_dataset(split="test") as (dataset, _): - assert all(d == (None, None) for d in dataset._disparities) for left, right, disparity, valid_mask in dataset: assert valid_mask is None datasets_utils.shape_test_for_stereo(left, right, disparity) From 5dff9d6c72dfdf65224beeacfaf80002e3bed075 Mon Sep 17 00:00:00 2001 From: Ponku Date: Thu, 18 Aug 2022 11:57:56 +0100 Subject: [PATCH 06/10] rebased on main --- torchvision/datasets/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torchvision/datasets/__init__.py b/torchvision/datasets/__init__.py index e8793ca0162..d5303849a41 100644 --- a/torchvision/datasets/__init__.py +++ b/torchvision/datasets/__init__.py @@ -1,13 +1,13 @@ from ._optical_flow import FlyingChairs, FlyingThings3D, HD1K, KittiFlow, Sintel from ._stereo_matching import ( CarlaStereo, + ETH3DStereo, FallingThingsStereo, InStereo2k, Kitti2012Stereo, Kitti2015Stereo, SceneFlowStereo, SintelStereo, - ETH3DStereo, ) from .caltech import Caltech101, Caltech256 from .celeba import CelebA From 9a002d3396ae162104ba2bb39aec366424549779 Mon Sep 17 00:00:00 2001 From: Ponku Date: Thu, 18 Aug 2022 12:23:33 +0100 Subject: [PATCH 07/10] Revert "Removed assertions with no use, changed np conversion" This reverts commit 1478a8c056bbed59b6f4a67f78a5cfac84cc9fda. --- test/test_datasets.py | 4 ++++ torchvision/datasets/_stereo_matching.py | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/test/test_datasets.py b/test/test_datasets.py index 207f11d8564..1120f41978d 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -3171,11 +3171,15 @@ def inject_fake_data(self, tmpdir, config): def test_training_splits(self): with self.create_dataset(split="train") as (dataset, _): + assert dataset._images and len(dataset._images) == len( + dataset._disparities + ), "Training images do not match with training disparities" for left, right, disparity, valid_mask in dataset: datasets_utils.shape_test_for_stereo(left, right, disparity, valid_mask) def test_testing_splits(self): with self.create_dataset(split="test") as (dataset, _): + assert all(d == (None, None) for d in dataset._disparities) for left, right, disparity, valid_mask in dataset: assert valid_mask is None datasets_utils.shape_test_for_stereo(left, right, disparity) diff --git a/torchvision/datasets/_stereo_matching.py b/torchvision/datasets/_stereo_matching.py index 3938af68c7b..c11eb8ef194 100644 --- a/torchvision/datasets/_stereo_matching.py +++ b/torchvision/datasets/_stereo_matching.py @@ -851,7 +851,7 @@ def _read_disparity(self, file_path: str) -> Tuple: disparity_map = np.abs(disparity_map) # ensure that the disparity is positive mask_path = Path(file_path).parent / "mask0nocc.png" valid_mask = Image.open(mask_path) - valid_mask = np.asarray(valid_mask).astype(bool) + valid_mask = np.asarray(valid_mask).astype(np.bool_) return disparity_map, valid_mask def __getitem__(self, index: int) -> Tuple: From a8c3f4d3b2ff2810d00414acb687555d2c6671d5 Mon Sep 17 00:00:00 2001 From: Ponku Date: Thu, 18 Aug 2022 13:52:43 +0100 Subject: [PATCH 08/10] Update to np.bool instead of np.bool_ --- torchvision/datasets/_stereo_matching.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torchvision/datasets/_stereo_matching.py b/torchvision/datasets/_stereo_matching.py index c11eb8ef194..737beb4ba6b 100644 --- a/torchvision/datasets/_stereo_matching.py +++ b/torchvision/datasets/_stereo_matching.py @@ -851,7 +851,7 @@ def _read_disparity(self, file_path: str) -> Tuple: disparity_map = np.abs(disparity_map) # ensure that the disparity is positive mask_path = Path(file_path).parent / "mask0nocc.png" valid_mask = Image.open(mask_path) - valid_mask = np.asarray(valid_mask).astype(np.bool_) + valid_mask = np.asarray(valid_mask).astype(np.bool) return disparity_map, valid_mask def __getitem__(self, index: int) -> Tuple: From 335c8e6dd07a27634ce0f2b815f97b03fd19b4d9 Mon Sep 17 00:00:00 2001 From: Ponku Date: Thu, 18 Aug 2022 14:46:43 +0100 Subject: [PATCH 09/10] lint and mypy nit fix --- torchvision/datasets/_stereo_matching.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torchvision/datasets/_stereo_matching.py b/torchvision/datasets/_stereo_matching.py index 737beb4ba6b..3938af68c7b 100644 --- a/torchvision/datasets/_stereo_matching.py +++ b/torchvision/datasets/_stereo_matching.py @@ -851,7 +851,7 @@ def _read_disparity(self, file_path: str) -> Tuple: disparity_map = np.abs(disparity_map) # ensure that the disparity is positive mask_path = Path(file_path).parent / "mask0nocc.png" valid_mask = Image.open(mask_path) - valid_mask = np.asarray(valid_mask).astype(np.bool) + valid_mask = np.asarray(valid_mask).astype(bool) return disparity_map, valid_mask def __getitem__(self, index: int) -> Tuple: From 02292e7127382ace9450be7997ede996c9e03a14 Mon Sep 17 00:00:00 2001 From: Ponku Date: Thu, 18 Aug 2022 17:35:31 +0100 Subject: [PATCH 10/10] test nit --- test/test_datasets.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/test/test_datasets.py b/test/test_datasets.py index 1120f41978d..ad31856cd01 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -3171,9 +3171,6 @@ def inject_fake_data(self, tmpdir, config): def test_training_splits(self): with self.create_dataset(split="train") as (dataset, _): - assert dataset._images and len(dataset._images) == len( - dataset._disparities - ), "Training images do not match with training disparities" for left, right, disparity, valid_mask in dataset: datasets_utils.shape_test_for_stereo(left, right, disparity, valid_mask)