def train_transform(self, rgb, depth):
s = self.getFocalScale()
if (self.augArgs.varFocus): #Variable focal length simulation
depth_np = depth
else:
depth_np = depth / s #Correct for focal length
if (self.augArgs.varScale): #Variable global scale simulation
scale = self.getDepthGroup()
depth_np = depth_np * scale
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
# perform 1st step of data augmentation
transform = transforms.Compose([
transforms.Resize(
250.0 / iheight
), # this is for computational efficiency, since rotation can be slow
transforms.Rotate(angle),
transforms.Resize(s),
transforms.CenterCrop(self.output_size),
transforms.HorizontalFlip(do_flip)
])
rgb_np = transform(rgb)
rgb_np = self.color_jitter(rgb_np) # random color jittering
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform(depth_np)
return rgb_np, depth_np
def train_transform(self, rgb, depth):
s = np.random.uniform(1.0, 1.5) # random scaling
random_size = (int(s * 224), int(s * 224))
depth_np = depth / s
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
# perform 1st step of data augmentation
# transform = torchvision.transforms.Compose([
# torchvision.transforms.Resize(self.output_size), # this is for computational efficiency, since rotation can be slow
# torchvision.transforms.RandomRotation(angle),
# torchvision.transforms.Resize(random_size),
# torchvision.transforms.CenterCrop(self.output_size),
# torchvision.transforms.RandomHorizontalFlip(do_flip)
#])
transform2 = transforms.Compose([
transforms.Resize(
250.0 / iheight
), # this is for computational efficiency, since rotation can be slow
transforms.Rotate(angle),
transforms.Resize(s),
transforms.CenterCrop(self.output_size),
transforms.HorizontalFlip(do_flip)
])
rgb_np = transform2(rgb)
#rgb_n = Image.fromarray(np.uint8(rgb_np * 255))
#rgb_np = self.color_jitter(rgb_n) # random color jittering
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform2(depth_np)
#depth_np = np.asfarray(depth_np, dtype='float') / 255
return rgb_np, depth_np
def train_transform(self, rgb, depth, rgb_near):
s = np.random.uniform(1.0, 1.5) # random scaling
depth_np = depth / s
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
# perform 1st step of data augmentation
transform = transforms.Compose([
transforms.Resize(
250.0 / iheight
), # this is for computational efficiency, since rotation can be slow
transforms.Rotate(angle),
transforms.Resize(s),
transforms.CenterCrop(self.output_size),
transforms.HorizontalFlip(do_flip)
])
rgb_np = transform(rgb)
rgb_np = self.color_jitter(rgb_np) # random color jittering
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
rgb_near_np = None
if rgb_near is not None:
rgb_near_np = transform(rgb_near)
rgb_near_np = np.asfarray(rgb_near_np, dtype='float') / 255
depth_np = transform(depth_np)
self.K = TransfromIntrinsics(self.K, (250.0 / iheight) * s,
self.output_size)
return rgb_np, depth_np, rgb_near_np
def train_transform(self, im, gt):
im = np.array(im).astype(np.float32)
gt = np.array(gt).astype(np.float32)
s = np.random.uniform(1.0, 1.5) # random scaling
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
color_jitter = my_transforms.ColorJitter(0.4, 0.4, 0.4)
transform = my_transforms.Compose([
my_transforms.Crop(130, 10, 240, 1200),
my_transforms.Resize(460 / 240, interpolation='bilinear'),
my_transforms.Rotate(angle),
my_transforms.Resize(s),
my_transforms.CenterCrop(self.size),
my_transforms.HorizontalFlip(do_flip)
])
im_ = transform(im)
im_ = color_jitter(im_)
gt_ = transform(gt)
im_ = np.array(im_).astype(np.float32)
gt_ = np.array(gt_).astype(np.float32)
im_ /= 255.0
gt_ /= 100.0 * s
im_ = to_tensor(im_)
gt_ = to_tensor(gt_)
gt_ = gt_.unsqueeze(0)
return im_, gt_
def train_transform(self, rgb, depth):
scale = np.random.uniform(low=1, high=1.5)
depth = depth / scale
angle = np.random.uniform(-5.0, 5.0)
should_flip = np.random.uniform(0.0, 1.0) < 0.5
h_offset = int((768 - 228) * np.random.uniform(0.0, 1.0))
v_offset = int((1024 - 304) * np.random.uniform(0.0, 1.0))
base_transform = transforms.Compose([
transforms.Resize(250 / iheight),
transforms.Rotate(angle),
transforms.Resize(scale),
transforms.CenterCrop(self.output_size),
transforms.HorizontalFlip(should_flip),
])
rgb = base_transform(rgb)
rgb = self.color_jitter(rgb)
rgb = rgb / 255.0
depth = base_transform(depth)
return (rgb, depth)
def val_transform(self, rgb, depth):
s = self.getFocalScale()
if (self.augArgs.varScale): #Variable global scale simulation
scale = self.getDepthGroup()
depth_np = depth * scale
else:
depth_np = depth
if (self.augArgs.varFocus):
transform = transforms.Compose([
transforms.Resize(240.0 / iheight),
transforms.Resize(
s
), #Resize both images without correcting the depth values
transforms.CenterCrop(self.output_size),
])
else:
transform = transforms.Compose([
transforms.Resize(240.0 / iheight),
transforms.CenterCrop(self.output_size),
])
rgb_np = transform(rgb)
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform(depth_np)
return rgb_np, depth_np
def val_transform(self, rgb, depth):
depth_np = depth
transform = transforms.Compose([
transforms.Resize(250.0 / iheight),
transforms.CenterCrop((228, 304)),
transforms.Resize(self.output_size),
])
rgb_np = transform(rgb)
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform(depth_np)
return rgb_np, depth_np
def train_transform(self, rgb, depth):
# for create fake underwater images
rgb = uw_style(rgb, depth)
rgb /= rgb.max() / 255
rgb = rgb.astype(np.uint8)
s = np.random.uniform(1.0, 1.5) # random scaling
depth_np = depth / s
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
# perform 1st step of data augmentation
transform = transforms.Compose([
# transforms.Rotate(angle),
# transforms.Resize(s),
# transforms.CenterCrop(self.output_size),
transforms.HorizontalFlip(do_flip),
transforms.Resize(size=self.output_size)
])
rgb_np = transform(rgb)
rgb_np = self.color_jitter(rgb_np) # random color jittering
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform(depth_np)
return rgb_np, depth_np
def train_transform(self, rgb, depth):
s = np.random.uniform(1.0, 1.5) # random scaling
depth_np = depth #/ s
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
# perform 1st step of data augmentation
transform = transforms.Compose([
#transforms.Resize(240.0 / iheight), # this is for computational efficiency, since rotation can be slow
#transforms.Rotate(angle),
#transforms.Resize(s),
#transforms.CenterCrop(self.output_size),
#transforms.HorizontalFlip(do_flip)
transforms.Resize(self.output_size)
])
rgb_np = transform(rgb)
#rgb_np = self.color_jitter(rgb_np) # random color jittering
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform(depth_np)
depth_np = np.asfarray(depth_np, dtype='float')
if self.depth_16:
depth_np = depth_np / self.depth_16_max
else:
depth_np = depth_np / 255
return rgb_np, depth_np
def val_transform(self, rgb, depth):
s = self.getFocalScale()
depth = np.asfarray(
depth, dtype='float32'
) #This used to be the last step, not sure if it goes here?
if (self.augArgs.varScale): #Variable global scale simulation
scale = self.getDepthGroup()
depth_np = depth * scale
else:
depth_np = depth
if (self.augArgs.varFocus):
transform = transforms.Compose([
transforms.Crop(130, 10, 240, 1200),
transforms.Resize(
s
), #Resize both images without correcting the depth values
transforms.CenterCrop(self.output_size),
])
else:
transform = transforms.Compose([
transforms.Crop(130, 10, 240, 1200),
transforms.CenterCrop(self.output_size),
])
rgb_np = transform(rgb)
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform(depth_np)
return rgb_np, depth_np
def train_transform_label(self, rgb, depth, label):
s = np.random.uniform(1.0, 1.5) # random scaling
depth_np = depth # / s
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
shift_x = np.random.uniform(-50.0, 50.0)
# perform 1st step of data augmentation
transform = transforms.Compose([
# transforms.Translate(shift_x, 0.0),
transforms.Resize(
150.0 / iheight
), # this is for computational efficiency, since rotation can be slow
# transforms.Rotate(angle),
# transforms.Resize(s),
# transforms.CenterCrop(self.output_size),
transforms.HorizontalFlip(do_flip)
])
label_transform = transforms.Compose([
# transforms.Translate(shift_x / 2.0, 0.0),
# transforms.CenterCrop(self.output_size),
transforms.HorizontalFlip(do_flip)
])
rgb_np = transform(rgb)
rgb_np = self.color_jitter(rgb_np) # random color jittering
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform(depth_np)
label_np = label_transform(label)
return rgb_np, depth_np, label_np
def val_transform(self, rgb, depth):
"""
[Reference]
https://github.com/fangchangma/sparse-to-dense.pytorch/blob/master/dataloaders/nyu_dataloader.py
Args:
rgb (np.array): RGB image (shape=[H,W,3])
depth (np.array): Depth image (shape=[H,W])
Returns:
torch.Tensor: Tranformed RGB image
torch.Tensor: Transformed Depth image
np.array: Transformed RGB image without color jitter (for 2D mesh creation)
"""
transform = transforms.Compose([
transforms.Resize(240.0 / RAW_HEIGHT),
transforms.CenterCrop(self.img_size),
])
# Apply this transform to rgb/depth
rgb_np_orig = transform(rgb)
rgb_np_for_edge = np.asfarray(rgb_np_orig) # Used for mesh creation
rgb_np = np.asfarray(rgb_np_orig) / 255
depth_np = transform(depth)
return rgb_np, depth_np, rgb_np_for_edge
def train_transform(self, rgb, depth):
#s = np.random.uniform(1.0, 1.5) # random scaling
#depth_np = depth / s
s = self.getFocalScale()
if (self.augArgs.varFocus): #Variable focal length simulation
depth_np = depth
else:
depth_np = depth / s #Correct for focal length
if (self.augArgs.varScale): #Variable global scale simulation
scale = self.getDepthGroup()
depth_np = depth_np * scale
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
# perform 1st step of data augmentation
transform = transforms.Compose([
transforms.Crop(130, 10, 240, 1200),
transforms.Rotate(angle),
transforms.Resize(s),
transforms.CenterCrop(self.output_size),
transforms.HorizontalFlip(do_flip)
])
rgb_np = transform(rgb)
rgb_np = self.color_jitter(rgb_np) # random color jittering
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
# Scipy affine_transform produced RuntimeError when the depth map was
# given as a 'numpy.ndarray'
depth_np = np.asfarray(depth_np, dtype='float32')
depth_np = transform(depth_np)
return rgb_np, depth_np
def val_transform(self, rgb):
transform = transforms.Compose([
transforms.Resize(240.0 / iheight),
transforms.CenterCrop(self.output_size),
])
rgb_np = transform(rgb)
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
return rgb_np
def image_transform(rgb, depth):
depth_frame_converted = np.asfarray(depth.clip(0, 6000),
dtype='float') / 1000
depth_array = depth_frame_converted.reshape((424, 512),
order='C')
rgb_transform = transforms.Compose([
transforms.Resize([240, 426]),
transforms.CenterCrop((228, 304)),
])
depth_transform = transforms.Compose([
transforms.Resize([240, 320]),
transforms.CenterCrop((228, 304)),
])
rgb_frame = rgb_transform(rgb)
rgb_np = np.asfarray(rgb_frame, dtype='float') / 255
depth_np = depth_transform(depth_array)
return rgb_np, depth_np
def seq_transform(self, attrib_list, is_validation):
iheight = attrib_list['gt_depth'].shape[0]
iwidth = attrib_list['gt_depth'].shape[1]
transform = transforms.Compose([
transforms.Resize(
240.0 / iheight), # this is for computational efficiency,
transforms.CenterCrop(self.output_size)
])
attrib_np = dict()
network_max_range = 10.0 # 10 is arbitrary. the network only converge in a especific range
if 'scale' in attrib_list and attrib_list['scale'] > 0:
scale = 1.0 / attrib_list['scale']
attrib_np['scale'] = attrib_list['scale']
else:
if 'fd' in attrib_list:
minmax_image = transform(attrib_list['fd'])
max_depth = max(minmax_image.max(), 1.0)
if 'kor' in attrib_list:
minmax_image = transform(attrib_list['kor'])
max_depth = max(minmax_image.max(), 1.0)
else:
max_depth = 50
scale = network_max_range / max_depth
attrib_np['scale'] = 1.0 / scale
for key, value in attrib_list.items():
if key not in Modality.no_transform:
attrib_np[key] = transform(value)
else:
attrib_np[key] = value
if key in Modality.need_divider:
attrib_np[key] = scale * attrib_np[key]
elif key in Modality.image_size_weight_names:
attrib_np[key] = attrib_np[key] / (
iwidth * 1.5) # 1.5 about sqrt(2)- square's diagonal
if 'rgb' in attrib_np:
if not is_validation:
attrib_np['rgb'] = self.color_jitter(
attrib_np['rgb']) # random color jittering
attrib_np['rgb'] = (np.asfarray(attrib_np['rgb'], dtype='float') /
255).transpose(
(2, 0,
1)) # all channels need to have C x H x W
if 'grey' in attrib_np:
attrib_np['grey'] = np.expand_dims(
np.asfarray(attrib_np['grey'], dtype='float') / 255, axis=0)
return attrib_np
def val_transform(self, rgb, depth, random_seed):
np.random.seed(random_seed)
depth_np = depth
transform = transforms.Compose([
transforms.Resize(240.0 / iheight),
transforms.CenterCrop(self.output_size),
])
rgb_np = transform(rgb)
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform(depth_np)
return rgb_np, depth_np
def val_transform_label(self, rgb, depth, label):
depth_np = depth
transform = transforms.Compose([
transforms.Resize(150.0 / iheight),
# transforms.CenterCrop(self.output_size),
])
# label_transform = transforms.CenterCrop(self.output_size),
rgb_np = transform(rgb)
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform(depth_np)
label_np = label
return rgb_np, depth_np, label_np
def val_transform(self, rgb, depth):
depth_np = depth
transform = transforms.Compose([
transforms.Crop(0, 20, 750, 2000),
transforms.Resize(500 / 750),
transforms.CenterCrop(self.output_size),
])
rgb_np = transform(rgb)
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = np.asfarray(depth_np, dtype='float32')
depth_np = transform(depth_np)
return rgb_np, depth_np
def train_transform(self, rgb, depth):
"""
[Reference]
https://github.com/fangchangma/sparse-to-dense.pytorch/blob/master/dataloaders/nyu_dataloader.py
Args:
rgb (np.array): RGB image (shape=[H,W,3])
depth (np.array): Depth image (shape=[H,W])
Returns:
torch.Tensor: Tranformed RGB image
torch.Tensor: Transformed Depth image
np.array: Transformed RGB image without color jitter (for 2D mesh creation)
"""
# Parameters for each augmentation
s = np.random.uniform(1.0, 1.5) # random scaling
depth_np = depth / s
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
# Perform 1st step of data augmentation
transform = transforms.Compose([
transforms.Resize(250.0 / RAW_HEIGHT),
transforms.Rotate(angle),
transforms.Resize(s),
transforms.CenterCrop(self.img_size),
transforms.HorizontalFlip(do_flip)
])
# Apply this transform to rgb/depth
rgb_np_orig = transform(rgb)
rgb_np_for_edge = np.asfarray(
rgb_np_orig) # Used for canny edge detection
rgb_np = color_jitter(rgb_np_orig) # random color jittering
rgb_np = np.asfarray(rgb_np) / 255
depth_np = transform(depth_np)
return rgb_np, depth_np, rgb_np_for_edge
def val_transform(self, rgb, depth):
depth_np = depth
transform = transforms.Compose([
#transform.Resize(250.0 / iheight),
transforms.Crop(130, 10, 240, 1200),
transforms.CenterCrop(self.output_size),
transforms.Resize(self.output_size),
])
rgb_np = transform(rgb)
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = np.asfarray(depth_np, dtype='float32')
depth_np = transform(depth_np)
return rgb_np, depth_np
def val_transform(self, rgb, depth):
depth_np = depth
transform = transforms.Compose([
transforms.Resize(240.0 / iheight),
transforms.CenterCrop(self.output_size),
])
rgb_np = transform(rgb)
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform(depth_np)
# for compare with Eigen's paper
depth_np = depth_data_transforms(depth_np)
return rgb_np, depth_np
def train_transform(self, rgb, depth):
s = np.random.uniform(1.0, 1.5) # random scaling
depth_np = depth / s
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
# perform 1st step of data augmentation
transform = transforms.Compose([
#Why not crop like in KITTI? Also, if resizing done, why not reflect this in depth_np as well?
transforms.Resize(
250.0 / iheight
), # this is for computational efficiency, since rotation can be slow
transforms.Rotate(angle),
transforms.Resize(s),
transforms.CenterCrop(self.output_size),
transforms.HorizontalFlip(do_flip)
])
rgb_np = transform(rgb)
rgb_np = self.color_jitter(rgb_np) # random color jittering
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform(depth_np)
return rgb_np, depth_np
def validate_transform(self, rgb, depth):
h_offset = int((768 - 228) * np.random.uniform(0.0, 1.0))
v_offset = int((1024 - 304) * np.random.uniform(0.0, 1.0))
base_transform = transforms.Compose([
transforms.Resize(240.0 / iheight),
transforms.CenterCrop(self.output_size),
])
rgb = base_transform(rgb)
rgb = rgb / 255.0
depth = base_transform(depth)
return (rgb, depth)
def train_transform(self, rgb, depth):
s = np.random.uniform(1.0, 1.5) # random scaling
depth_np = depth / s
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
iheight = rgb.shape[0]
# perform 1st step of data augmentation
transform = transforms.Compose([
transforms.Resize(250.0 / iheight), # this is for computational efficiency, since rotation can be slow
transforms.Rotate(angle),
transforms.Resize(s),
transforms.CenterCrop((228, 304)),
transforms.HorizontalFlip(do_flip),
transforms.Resize(self.output_size),
])
rgb_np = transform(rgb)
rgb_np = self.color_jitter(rgb_np) # random color jittering
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
if depth_np.ndim != 2:
print("Wrong Depth ",depth_np)
depth_np = transform(depth_np)
return rgb_np, depth_np
def train_transform(self, rgb, depth):
s = np.random.uniform(1.0, 1.5) # random scaling
# s = 1.5
depth_np = depth / s
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
# perform 1st step of data augmentation
transform = transforms.Compose([
transforms.Resize(
250.0 / iheight
), # this is for computational efficiency, since rotation can be slow
transforms.Rotate(angle),
transforms.Resize(
s), # TODO (Katie): figure out how to resize properly
transforms.RandomCrop(self.output_size),
transforms.HorizontalFlip(do_flip)
])
rgb_np = transform(rgb)
rgb_np = self.color_jitter(rgb_np) # random color jittering
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform(depth_np)
return rgb_np, depth_np
def train_transform(self, rgb, depth):
s = np.random.uniform(1.0, 1.5) # random scaling
depth_np = depth / s
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
# perform 1st step of data augmentation
transform = transforms.Compose([
transforms.Crop(0, 20, 750, 2000),
transforms.Resize(500 / 750),
transforms.Rotate(angle),
transforms.Resize(s),
transforms.CenterCrop(self.output_size),
transforms.HorizontalFlip(do_flip)
])
rgb_np = transform(rgb)
rgb_np = self.color_jitter(rgb_np) # random color jittering
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
# Scipy affine_transform produced RuntimeError when the depth map was
# given as a 'numpy.ndarray'
depth_np = np.asfarray(depth_np, dtype='float32')
depth_np = transform(depth_np)
return rgb_np, depth_np
def val_transform(self, rgb, depth):
# for create fake underwater images
rgb = uw_style(rgb, depth)
rgb /= rgb.max() / 255
rgb = rgb.astype(np.uint8)
depth_np = depth
transform = transforms.Compose([
# transforms.CenterCrop(self.output_size),
transforms.Resize(size=self.output_size)
])
rgb_np = transform(rgb)
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
depth_np = transform(depth_np)
return rgb_np, depth_np
def val_transform(self, rgb, depth, rgb_near):
depth_np = depth
transform = transforms.Compose([
transforms.Resize(240.0 / iheight),
transforms.CenterCrop(self.output_size),
])
rgb_np = transform(rgb)
rgb_np = np.asfarray(rgb_np, dtype='float') / 255
rgb_near_np = None
if rgb_near is not None:
rgb_near_np = transform(rgb_near)
rgb_near_np = np.asfarray(rgb_near_np, dtype='float') / 255
depth_np = transform(depth_np)
self.K = TransfromIntrinsics(self.K, (240.0 / iheight),
self.output_size)
return rgb_np, depth_np, rgb_near_np
def val_transform(self, attrib_list):
iheight = attrib_list['gt_depth'].shape[0]
iwidth = attrib_list['gt_depth'].shape[1]
transform = transforms.Compose([
transforms.Resize(240.0 / iheight),
transforms.CenterCrop(self.output_size),
])
attrib_np = dict()
if self.depth_divider == 0:
if 'fd' in attrib_list:
minmax_image = transform(attrib_list['fd'])
max_depth = max(minmax_image.max(), 1.0)
if 'kor' in attrib_list:
minmax_image = transform(attrib_list['kor'])
max_depth = max(minmax_image.max(), 1.0)
else:
max_depth = 50
scale = 10.0 / max_depth # 10 is arbitrary. the network only converge in a especific range
else:
scale = 1.0 / self.depth_divider
attrib_np['scale'] = 1.0 / scale
for key, value in attrib_list.items():
attrib_np[key] = transform(value)
if key in Modality.need_divider: #['gt_depth','fd','kor','kde','kgt','dor','dde', 'd3dwde','d3dwor','dvor','dvde','dvgt']:
attrib_np[key] = scale * attrib_np[
key] #(attrib_np[key] - min_depth+0.01) / (max_depth - min_depth)
elif key in Modality.image_size_weight_names:
attrib_np[key] = attrib_np[key] / (
iwidth * 1.5) #1.5 about sqrt(2)- square's diagonal
elif key == 'rgb':
attrib_np[key] = (np.asfarray(attrib_np[key], dtype='float') /
255).transpose((2, 0, 1))
elif key == 'grey':
attrib_np[key] = np.expand_dims(
np.asfarray(attrib_np[key], dtype='float') / 255, axis=0)
return attrib_np
