def __init__(self,
args,
images_root_2015=None,
images_root_2012=None,
photometric_augmentations=False,
preprocessing_crop=True):
self._args = args
self.preprocessing_crop = preprocessing_crop
list_of_indices_2012 = []
list_of_indices_2015 = []
# ----------------------------------------------------------
# KITTI 2015
# ----------------------------------------------------------
if images_root_2015 is not None:
if not os.path.isdir(images_root_2015):
raise ValueError("Image directory '%s' not found!")
all_img1_2015_filenames = sorted(
glob(os.path.join(images_root_2015, "*_10.png")))
all_img2_2015_filenames = sorted(
glob(os.path.join(images_root_2015, "*_11.png")))
assert len(all_img1_2015_filenames) != 0
assert len(all_img2_2015_filenames) == len(all_img1_2015_filenames)
list_of_indices_2015 = range(len(all_img1_2015_filenames))
# ----------------------------------------------------------
# KITTI 2012
# ----------------------------------------------------------
if images_root_2012 is not None:
if not os.path.isdir(images_root_2012):
raise ValueError("Image directory '%s' not found!")
all_img1_2012_filenames = sorted(
glob(os.path.join(images_root_2012, "*_10.png")))
all_img2_2012_filenames = sorted(
glob(os.path.join(images_root_2012, "*_11.png")))
assert len(all_img1_2012_filenames) != 0
assert len(all_img2_2012_filenames) == len(all_img1_2012_filenames)
list_of_indices_2012 = range(len(all_img1_2012_filenames))
# ----------------------------------------------------------
# Save list of actual filenames for inputs and flows
# ----------------------------------------------------------
self._image_list = []
self._flow_list = []
for ii in list_of_indices_2015:
im1 = all_img1_2015_filenames[ii]
im2 = all_img2_2015_filenames[ii]
idx1 = os.path.splitext(os.path.basename(im1))[0][:-3]
idx2 = os.path.splitext(os.path.basename(im2))[0][:-3]
assert idx1 == idx2
if not os.path.isfile(im1) or not os.path.isfile(im2):
continue
self._image_list += [[im1, im2]]
for ii in list_of_indices_2012:
im1 = all_img1_2012_filenames[ii]
im2 = all_img2_2012_filenames[ii]
idx1 = os.path.splitext(os.path.basename(im1))[0][:-3]
idx2 = os.path.splitext(os.path.basename(im2))[0][:-3]
assert idx1 == idx2
if not os.path.isfile(im1) or not os.path.isfile(im2):
continue
self._image_list += [[im1, im2]]
self._size = len(self._image_list)
assert len(self._image_list) != 0
# ----------------------------------------------------------
# photometric_augmentations
# ----------------------------------------------------------
if photometric_augmentations:
self._photometric_transform = transforms.ConcatTransformSplitChainer(
[
# uint8 -> PIL
vision_transforms.ToPILImage(),
# PIL -> PIL : random hsv and contrast
vision_transforms.ColorJitter(
brightness=0.5, contrast=0.5, saturation=0.5, hue=0.5),
# PIL -> FloatTensor
vision_transforms.transforms.ToTensor(),
transforms.RandomGamma(
min_gamma=0.7, max_gamma=1.5, clip_image=True),
],
from_numpy=True,
to_numpy=False)
else:
self._photometric_transform = transforms.ConcatTransformSplitChainer(
[
# uint8 -> FloatTensor
vision_transforms.transforms.ToTensor(),
],
from_numpy=True,
to_numpy=False)
def __init__(self,
args,
images_root_2015=None,
flow_root_2015=None,
images_root_2012=None,
flow_root_2012=None,
photometric_augmentations=False,
preprocessing_crop=True,
dstype="full"):
self._args = args
self.preprocessing_crop = preprocessing_crop
list_of_indices_2012 = []
list_of_indices_2015 = []
# ----------------------------------------------------------
# KITTI 2015
# ----------------------------------------------------------
if images_root_2015 is not None and flow_root_2015 is not None:
if not os.path.isdir(images_root_2015):
raise ValueError("Image directory '%s' not found!")
if not os.path.isdir(flow_root_2015):
raise ValueError("Flow directory '%s' not found!")
all_img1_2015_filenames = sorted(
glob(os.path.join(images_root_2015, "*_10.png")))
all_img2_2015_filenames = sorted(
glob(os.path.join(images_root_2015, "*_11.png")))
flow_f_2015_filenames = sorted(
glob(os.path.join(flow_root_2015, "*_10.png")))
assert len(all_img1_2015_filenames) != 0
assert len(all_img2_2015_filenames) == len(all_img1_2015_filenames)
assert len(flow_f_2015_filenames) == len(all_img1_2015_filenames)
num_flows_2015 = len(flow_f_2015_filenames)
validate_indices_2015 = [
x for x in VALIDATE_INDICES_2015 if x in range(num_flows_2015)
]
if dstype == "train":
list_of_indices_2015 = [
x for x in range(num_flows_2015)
if x not in validate_indices_2015
]
elif dstype == "valid":
list_of_indices_2015 = validate_indices_2015
elif dstype == "full":
list_of_indices_2015 = range(len(all_img1_2015_filenames))
else:
raise ValueError("KITTI 2015: dstype '%s' unknown!", dstype)
print("Found {} images for KITTI15 {}".format(
len(list_of_indices_2015), dstype))
# ----------------------------------------------------------
# KITTI 2012
# ----------------------------------------------------------
if images_root_2012 is not None:
if not os.path.isdir(images_root_2012):
raise ValueError("Image directory '%s' not found!")
if not os.path.isdir(flow_root_2012):
raise ValueError("Flow directory '%s' not found!")
all_img1_2012_filenames = sorted(
glob(os.path.join(images_root_2012, "*_10.png")))
all_img2_2012_filenames = sorted(
glob(os.path.join(images_root_2012, "*_11.png")))
flow_f_2012_filenames = sorted(
glob(os.path.join(flow_root_2012, "*_10.png")))
assert len(all_img1_2012_filenames) != 0
assert len(all_img2_2012_filenames) == len(all_img1_2012_filenames)
assert len(flow_f_2012_filenames) == len(all_img1_2012_filenames)
num_flows_2012 = len(flow_f_2012_filenames)
validate_indices_2012 = [
x for x in VALIDATE_INDICES_2012 if x in range(num_flows_2012)
]
if dstype == "train":
list_of_indices_2012 = [
x for x in range(num_flows_2012)
if x not in validate_indices_2012
]
elif dstype == "valid":
list_of_indices_2012 = validate_indices_2012
elif dstype == "full":
list_of_indices_2012 = range(len(all_img1_2012_filenames))
else:
raise ValueError("KITTI 2012: dstype '%s' unknown!", dstype)
print("Found {} images for KITTI12 {}".format(
len(list_of_indices_2012), dstype))
# ----------------------------------------------------------
# Save list of actual filenames for inputs and flows
# ----------------------------------------------------------
self._image_list = []
self._flow_list = []
for ii in list_of_indices_2015:
im1 = all_img1_2015_filenames[ii]
im2 = all_img2_2015_filenames[ii]
idx1 = os.path.splitext(os.path.basename(im1))[0][:-3]
idx2 = os.path.splitext(os.path.basename(im2))[0][:-3]
assert idx1 == idx2
if not os.path.isfile(im1) or not os.path.isfile(im2):
continue
self._image_list += [[im1, im2]]
if dstype is not "test":
flo_f = flow_f_2015_filenames[ii]
idx_f = os.path.splitext(os.path.basename(flo_f))[0][:-3]
assert idx1 == idx_f
if not os.path.isfile(flo_f):
continue
self._flow_list += [[flo_f]]
for ii in list_of_indices_2012:
im1 = all_img1_2012_filenames[ii]
im2 = all_img2_2012_filenames[ii]
idx1 = os.path.splitext(os.path.basename(im1))[0][:-3]
idx2 = os.path.splitext(os.path.basename(im2))[0][:-3]
assert idx1 == idx2
if not os.path.isfile(im1) or not os.path.isfile(im2):
continue
self._image_list += [[im1, im2]]
if dstype is not "test":
flo_f = flow_f_2012_filenames[ii]
idx_f = os.path.splitext(os.path.basename(flo_f))[0][:-3]
assert idx1 == idx_f
if not os.path.isfile(flo_f):
continue
self._flow_list += [[flo_f]]
self._size = len(self._image_list)
assert len(self._image_list) != 0
if dstype is not "test":
assert len(self._image_list) == len(self._flow_list)
# ----------------------------------------------------------
# photometric_augmentations
# ----------------------------------------------------------
if photometric_augmentations:
self._photometric_transform = transforms.ConcatTransformSplitChainer(
[
# uint8 -> PIL
vision_transforms.ToPILImage(),
# PIL -> PIL : random hsv and contrast
vision_transforms.ColorJitter(
brightness=0.5, contrast=0.5, saturation=0.5, hue=0.5),
# PIL -> FloatTensor
vision_transforms.transforms.ToTensor(),
transforms.RandomGamma(
min_gamma=0.7, max_gamma=1.5, clip_image=True),
],
from_numpy=True,
to_numpy=False)
else:
self._photometric_transform = transforms.ConcatTransformSplitChainer(
[
# uint8 -> FloatTensor
vision_transforms.transforms.ToTensor(),
],
from_numpy=True,
to_numpy=False)
def __init__(self,
args,
images_root,
flow_root,
occ_root,
photometric_augmentations=False):
self._args = args
if not os.path.isdir(images_root):
raise ValueError("Image directory '%s' not found!")
if flow_root is not None and not os.path.isdir(flow_root):
raise ValueError("Flow directory '%s' not found!")
if occ_root is not None and not os.path.isdir(occ_root):
raise ValueError("Occ directory '%s' not found!")
if flow_root is not None:
flow_f_filenames = sorted(
glob(os.path.join(flow_root, "into_future/*.flo")))
flow_b_filenames = sorted(
glob(os.path.join(flow_root, "into_past/*.flo")))
if occ_root is not None:
occ1_filenames = sorted(
glob(os.path.join(occ_root, "into_future/*.png")))
occ2_filenames = sorted(
glob(os.path.join(occ_root, "into_past/*.png")))
all_img_filenames = sorted(glob(os.path.join(images_root, "*.png")))
self._image_list = []
self._flow_list = [] if flow_root is not None else None
self._occ_list = [] if occ_root is not None else None
assert len(all_img_filenames) != 0
assert len(flow_f_filenames) != 0
assert len(flow_b_filenames) != 0
assert len(occ1_filenames) != 0
assert len(occ2_filenames) != 0
## path definition
path_flow_f = os.path.join(flow_root, "into_future")
path_flow_b = os.path.join(flow_root, "into_past")
path_occ_f = os.path.join(occ_root, "into_future")
path_occ_b = os.path.join(occ_root, "into_past")
# ----------------------------------------------------------
# Save list of actual filenames for inputs and flows
# ----------------------------------------------------------
for ii in range(0, len(flow_f_filenames)):
flo_f = flow_f_filenames[ii]
idx_f = os.path.splitext(os.path.basename(flo_f))[0]
idx_b = str(int(idx_f) + 1).zfill(7)
flo_b = os.path.join(path_flow_b, idx_b + ".flo")
im1 = os.path.join(images_root, idx_f + ".png")
im2 = os.path.join(images_root, idx_b + ".png")
occ1 = os.path.join(path_occ_f, idx_f + ".png")
occ2 = os.path.join(path_occ_b, idx_b + ".png")
if not os.path.isfile(flo_f) or not os.path.isfile(
flo_b) or not os.path.isfile(im1) or not os.path.isfile(
im2) or not os.path.isfile(occ1) or not os.path.isfile(
occ2):
continue
self._image_list += [[im1, im2]]
self._flow_list += [[flo_f, flo_b]]
self._occ_list += [[occ1, occ2]]
self._size = len(self._image_list)
assert len(self._image_list) == len(self._flow_list)
assert len(self._occ_list) == len(self._flow_list)
assert len(self._image_list) != 0
# ----------------------------------------------------------
# photometric_augmentations
# ----------------------------------------------------------
if photometric_augmentations:
self._photometric_transform = transforms.ConcatTransformSplitChainer(
[
# uint8 -> PIL
vision_transforms.ToPILImage(),
# PIL -> PIL : random hsv and contrast
vision_transforms.ColorJitter(
brightness=0.5, contrast=0.5, saturation=0.5, hue=0.5),
# PIL -> FloatTensor
vision_transforms.transforms.ToTensor(),
transforms.RandomGamma(
min_gamma=0.7, max_gamma=1.5, clip_image=True),
],
from_numpy=True,
to_numpy=False)
else:
self._photometric_transform = transforms.ConcatTransformSplitChainer(
[
# uint8 -> FloatTensor
vision_transforms.transforms.ToTensor(),
],
from_numpy=True,
to_numpy=False)
def __init__(self,
args,
root,
photometric_augmentations=False,
dstype="train"):
self._args = args
# -------------------------------------------------------------
# filenames for all input images and target flows
# -------------------------------------------------------------
image1_filenames = sorted(glob(os.path.join(root, "*_img1.png")))
image2_filenames = sorted(glob(os.path.join(root, "*_img2.png")))
occ1_filenames = sorted(glob(os.path.join(root, "*_occ1.png")))
occ2_filenames = sorted(glob(os.path.join(root, "*_occ2.png")))
flow_f_filenames = sorted(glob(os.path.join(root, "*_flow.flo")))
flow_b_filenames = sorted(glob(os.path.join(root, "*_flow_b.flo")))
assert (len(image1_filenames) == len(image2_filenames))
assert (len(image2_filenames) == len(occ1_filenames))
assert (len(occ1_filenames) == len(occ2_filenames))
assert (len(occ2_filenames) == len(flow_f_filenames))
assert (len(flow_f_filenames) == len(flow_b_filenames))
num_flows = len(flow_f_filenames)
# -------------------------------------------------------------
# Remove invalid validation indices
# -------------------------------------------------------------
validate_indices = [
x for x in VALIDATE_INDICES if x in range(num_flows)
]
# ----------------------------------------------------------
# Construct list of indices for training/validation
# ----------------------------------------------------------
list_of_indices = None
if dstype == "train":
list_of_indices = [
x for x in range(num_flows) if x not in validate_indices
]
elif dstype == "valid":
list_of_indices = validate_indices
elif dstype == "full":
list_of_indices = range(num_flows)
else:
raise ValueError("FlyingChairs: dstype '%s' unknown!", dstype)
# ----------------------------------------------------------
# Save list of actual filenames for inputs and flows
# ----------------------------------------------------------
self._image_list = []
self._flow_list = []
self._occ_list = []
for i in list_of_indices:
flo_f = flow_f_filenames[i]
flo_b = flow_b_filenames[i]
im1 = image1_filenames[i]
im2 = image2_filenames[i]
occ1 = occ1_filenames[i]
occ2 = occ2_filenames[i]
self._image_list += [[im1, im2]]
self._flow_list += [[flo_f, flo_b]]
self._occ_list += [[occ1, occ2]]
self._size = len(self._image_list)
assert len(self._image_list) == len(self._flow_list)
assert len(self._occ_list) == len(self._flow_list)
# ----------------------------------------------------------
# photometric_augmentations
# ----------------------------------------------------------
if photometric_augmentations:
self._photometric_transform = transforms.ConcatTransformSplitChainer(
[
# uint8 -> PIL
vision_transforms.ToPILImage(),
# PIL -> PIL : random hsv and contrast
vision_transforms.ColorJitter(
brightness=0.5, contrast=0.5, saturation=0.5, hue=0.5),
# PIL -> FloatTensor
vision_transforms.transforms.ToTensor(),
transforms.RandomGamma(
min_gamma=0.7, max_gamma=1.5, clip_image=True),
],
from_numpy=True,
to_numpy=False)
else:
self._photometric_transform = transforms.ConcatTransformSplitChainer(
[
# uint8 -> FloatTensor
vision_transforms.transforms.ToTensor(),
],
from_numpy=True,
to_numpy=False)
def __init__(self,
args,
dir_root=None,
photometric_augmentations=False,
imgtype=None,
dstype=None):
self._args = args
self.show_aug = hasattr(args, 'show_aug') and args.show_aug
images_root = os.path.join(dir_root, imgtype)
if imgtype is "comb":
images_root = os.path.join(dir_root, "clean")
flow_root = os.path.join(dir_root, "flow")
occ_root = os.path.join(dir_root, "occlusions")
if not os.path.isdir(images_root):
raise ValueError("Image directory '%s' not found!" % images_root)
if flow_root is not None and not os.path.isdir(flow_root):
raise ValueError("Flow directory '%s' not found!" % flow_root)
if occ_root is not None and not os.path.isdir(occ_root):
raise ValueError("Occ directory '%s' not found!" % occ_root)
all_flo_filenames = sorted(glob(os.path.join(flow_root, "*/*.flo")))
all_occ_filenames = sorted(glob(os.path.join(occ_root, "*/*.png")))
all_img_filenames = sorted(glob(os.path.join(images_root, "*/*.png")))
# Remember base for substraction at runtime
# e.g. subtract_base = "/home/user/.../MPI-Sintel-Complete/training/clean"
self._substract_base = tools.cd_dotdot(images_root)
# ------------------------------------------------------------------------
# Get unique basenames
# ------------------------------------------------------------------------
# e.g. base_folders = [alley_1", "alley_2", "ambush_2", ...]
substract_full_base = tools.cd_dotdot(all_img_filenames[0])
base_folders = sorted(
list(
set([
os.path.dirname(fn.replace(substract_full_base, ""))[1:]
for fn in all_img_filenames
])))
self._image_list = []
self._flow_list = []
self._occ_list = []
for base_folder in base_folders:
scene = os.path.basename(base_folder)
img_filenames = [x for x in all_img_filenames if scene in x]
flo_filenames = [x for x in all_flo_filenames if scene in x]
occ_filenames = [x for x in all_occ_filenames if scene in x]
for i in range(len(img_filenames) - 1):
im1 = img_filenames[i]
im2 = img_filenames[i + 1]
flo = flo_filenames[i]
occ = occ_filenames[i]
self._image_list += [[im1, im2]]
self._flow_list += [flo]
self._occ_list += [occ]
# Sanity check
im1_base_filename = os.path.splitext(os.path.basename(im1))[0]
im2_base_filename = os.path.splitext(os.path.basename(im2))[0]
flo_base_filename = os.path.splitext(os.path.basename(flo))[0]
occ_base_filename = os.path.splitext(os.path.basename(occ))[0]
im1_frame, im1_no = im1_base_filename.split("_")
im2_frame, im2_no = im2_base_filename.split("_")
assert (im1_frame == im2_frame)
assert (int(im1_no) == int(im2_no) - 1)
flo_frame, flo_no = flo_base_filename.split("_")
assert (im1_frame == flo_frame)
assert (int(im1_no) == int(flo_no))
occ_frame, occ_no = occ_base_filename.split("_")
assert (im1_frame == occ_frame)
assert (int(im1_no) == int(occ_no))
assert len(self._image_list) == len(self._flow_list)
assert len(self._image_list) == len(self._occ_list)
# -------------------------------------------------------------
# Remove invalid validation indices
# -------------------------------------------------------------
full_num_examples = len(self._image_list)
validate_indices = [
x for x in VALIDATE_INDICES if x in range(full_num_examples)
]
# ----------------------------------------------------------
# Construct list of indices for training/validation
# ----------------------------------------------------------
list_of_indices = None
if dstype == "train":
list_of_indices = [
x for x in range(full_num_examples)
if x not in validate_indices
]
elif dstype == "valid":
list_of_indices = validate_indices
elif dstype == "full":
list_of_indices = range(full_num_examples)
else:
raise ValueError("dstype '%s' unknown!", dstype)
# ----------------------------------------------------------
# Save list of actual filenames for inputs and flows
# ----------------------------------------------------------
self._image_list = [self._image_list[i] for i in list_of_indices]
self._flow_list = [self._flow_list[i] for i in list_of_indices]
self._occ_list = [self._occ_list[i] for i in list_of_indices]
if imgtype is "comb":
image_list_final = [[
val[0].replace("clean", "final"),
val[1].replace("clean", "final")
] for idx, val in enumerate(self._image_list)]
self._image_list += image_list_final
self._flow_list += self._flow_list
self._occ_list += self._occ_list
assert len(self._image_list) == len(self._flow_list)
assert len(self._image_list) == len(self._occ_list)
# ----------------------------------------------------------
# photometric_augmentations
# ----------------------------------------------------------
if photometric_augmentations:
self._photometric_transform = transforms.ConcatTransformSplitChainer(
[
# uint8 -> PIL
vision_transforms.ToPILImage(),
# PIL -> PIL : random hsv and contrast
vision_transforms.ColorJitter(
brightness=0.5, contrast=0.5, saturation=0.5, hue=0.5),
# PIL -> FloatTensor
vision_transforms.transforms.ToTensor(),
transforms.RandomGamma(
min_gamma=0.7, max_gamma=1.5, clip_image=True),
],
from_numpy=True,
to_numpy=False)
else:
self._photometric_transform = transforms.ConcatTransformSplitChainer(
[
# uint8 -> FloatTensor
vision_transforms.transforms.ToTensor(),
],
from_numpy=True,
to_numpy=False)
self._size = len(self._image_list)
def __init__(self,
args,
dir_root=None,
photometric_augmentations=False,
imgtype=None):
self._args = args
images_root = os.path.join(dir_root, imgtype)
if not os.path.isdir(images_root):
raise ValueError("Image directory '%s' not found!")
all_img_filenames = sorted(glob(os.path.join(images_root, "*/*.png")))
# Remember base for substraction at runtime
# e.g. subtract_base = "/home/user/.../MPI-Sintel-Complete/training/clean"
self._substract_base = tools.cd_dotdot(images_root)
# ------------------------------------------------------------------------
# Get unique basenames
# ------------------------------------------------------------------------
# e.g. base_folders = [alley_1", "alley_2", "ambush_2", ...]
substract_full_base = tools.cd_dotdot(all_img_filenames[0])
base_folders = sorted(
list(
set([
os.path.dirname(fn.replace(substract_full_base, ""))[1:]
for fn in all_img_filenames
])))
self._image_list = []
for base_folder in base_folders:
img_filenames = [x for x in all_img_filenames if base_folder in x]
for i in range(len(img_filenames) - 1):
im1 = img_filenames[i]
im2 = img_filenames[i + 1]
self._image_list += [[im1, im2]]
# Sanity check
im1_base_filename = os.path.splitext(os.path.basename(im1))[0]
im2_base_filename = os.path.splitext(os.path.basename(im2))[0]
im1_frame, im1_no = im1_base_filename.split("_")
im2_frame, im2_no = im2_base_filename.split("_")
assert (im1_frame == im2_frame)
assert (int(im1_no) == int(im2_no) - 1)
full_num_examples = len(self._image_list)
list_of_indices = range(full_num_examples)
# ----------------------------------------------------------
# Save list of actual filenames for inputs and flows
# ----------------------------------------------------------
self._image_list = [self._image_list[i] for i in list_of_indices]
# ----------------------------------------------------------
# photometric_augmentations
# ----------------------------------------------------------
if photometric_augmentations:
self._photometric_transform = transforms.ConcatTransformSplitChainer(
[
# uint8 -> PIL
vision_transforms.ToPILImage(),
# PIL -> PIL : random hsv and contrast
vision_transforms.ColorJitter(
brightness=0.5, contrast=0.5, saturation=0.5, hue=0.5),
# PIL -> FloatTensor
vision_transforms.transforms.ToTensor(),
transforms.RandomGamma(
min_gamma=0.7, max_gamma=1.5, clip_image=True),
],
from_numpy=True,
to_numpy=False)
else:
self._photometric_transform = transforms.ConcatTransformSplitChainer(
[
# uint8 -> FloatTensor
vision_transforms.transforms.ToTensor(),
],
from_numpy=True,
to_numpy=False)
self._size = len(self._image_list)