请帮我修改这个代码,使得只在mask为0的地方随机取点
- User
请帮我修改这个代码,使得只在mask为0的地方随机取点
- Assistant
当然可以!请提供您想要修改的代码片段,这样我才能更好地帮助您。
- User
def add_random_dots(noisy_depth_map, mask, num_dots=100, dot_radius=5): if len(noisy_depth_map.shape) != 2: raise ValueError("Input noisy_depth_map must be a 2-dimensional array (height, width)")
if noisy_depth_map.dtype != np.uint8: raise ValueError("Input noisy_depth_map must be of type np.uint8") h, w = noisy_depth_map.shape for _ in range(num_dots): y = np.random.randint(0, h) x = np.random.randint(0, w) dot_color = np.random.randint(0, 256) cv2.circle(noisy_depth_map, (x, y), radius=dot_radius, color=dot_color, thickness=-1) # -1 表示填充 return noisy_depth_map - Assistant
为了使随机点只在
mask为 0 的位置上生成,您可以修改代码逻辑,确保在随机选点时仅选择mask为 0 的位置。以下是修改后的代码:import numpy as np import cv2 def add_random_dots(noisy_depth_map, mask, num_dots=100, dot_radius=5): if len(noisy_depth_map.shape) != 2: raise ValueError("Input noisy_depth_map must be a 2-dimensional array (height, width)") if noisy_depth_map.dtype != np.uint8: raise ValueError("Input noisy_depth_map must be of type np.uint8") if mask.shape != noisy_depth_map.shape: raise ValueError("Mask must have the same dimensions as noisy_depth_map") h, w = noisy_depth_map.shape # 获取所有mask为0的位置 zero_mask_indices = np.argwhere(mask == 0) if len(zero_mask_indices) < num_dots: raise ValueError("Not enough space to place the requested number of dots in the given mask.") for _ in range(num_dots): # 随机选择mask为0的位置 y, x = zero_mask_indices[np.random.choice(len(zero_mask_indices))] dot_color = np.random.randint(0, 256) cv2.circle(noisy_depth_map, (x, y), radius=dot_radius, color=dot_color, thickness=-1) # -1 表示填充 return noisy_depth_map代码说明:
-
检查输入:
- 确保
mask的形状与noisy_depth_map一致。 - 在添加点之前,检查
mask为 0 的位置是否足够。
- 确保
-
找到所有
mask为 0 的位置:- 使用
np.argwhere(mask == 0)找到所有可以放置点的坐标。
- 使用
-
在可用位置随机选择点:
- 通过
np.random.choice从可用的位置中随机选择一个点来添加圆形。
- 通过
这样,随机点会只在
mask为 0 的地方生成。希望这能满足您的需求!如果有其他问题,请告诉我。 -
- User
如果我需要点的边缘很模糊呢
- Assistant
如果您希望添加的点的边缘比较模糊,可以通过使用高斯模糊(Gaussian blur)来实现。您可以在绘制圆形后,使用
cv2.GaussianBlur对图像进行模糊处理。以下是修改后的代码示例:import numpy as np import cv2 def add_random_dots(noisy_depth_map, mask, num_dots=100, dot_radius=5, blur_radius=15): if len(noisy_depth_map.shape) != 2: raise ValueError("Input noisy_depth_map must be a 2-dimensional array (height, width)") if noisy_depth_map.dtype != np.uint8: raise ValueError("Input noisy_depth_map must be of type np.uint8") if mask.shape != noisy_depth_map.shape: raise ValueError("Mask must have the same dimensions as noisy_depth_map") h, w = noisy_depth_map.shape zero_mask_indices = np.argwhere(mask == 0) if len(zero_mask_indices) < num_dots: raise ValueError("Not enough space to place the requested number of dots in the given mask.") for _ in range(num_dots): # 随机选择mask为0的位置 y, x = zero_mask_indices[np.random.choice(len(zero_mask_indices))] dot_color = np.random.randint(0, 256) # 在图像上绘制一个圆形 cv2.circle(noisy_depth_map, (x, y), radius=dot_radius, color=dot_color, thickness=-1) # -1 表示填充 # 使用高斯模糊使边缘变得模糊 noisy_depth_map = cv2.GaussianBlur(noisy_depth_map, (blur_radius, blur_radius), 0) return noisy_depth_map # 调用示例: # noisy_depth_map = np.zeros((height, width), dtype=np.uint8) # mask = np.zeros((height, width), dtype=np.uint8) # 例如,mask中的值为0和1 # noisy_depth_map_with_dots = add_random_dots(noisy_depth_map, mask, num_dots=100, dot_radius=5, blur_radius=15)关键变化:
-
新增的参数
blur_radius:- 这个参数控制了高斯模糊的程度,您可以根据需要调整这个值,通常它需要是正奇数。
-
使用
cv2.GaussianBlur处理新的深度图:- 在所有点绘制完成后,调用
cv2.GaussianBlur对图像进行模糊处理,以使点的边缘变得模糊。
- 在所有点绘制完成后,调用
注意事项:
- 模糊处理不仅会影响刚刚绘制的点,也会影响整个图像。如果只想模糊点的边缘,而不想影响其他区域,您可能需要在模糊之前创建一个新的图像,只在上面绘制点,然后再将其融合到原始图像中。
- 如果有其他需求或问题,请随时告知!
-
- User
我只想模糊点的边缘
- Assistant
如果您只想模糊点的边缘,而不影响整个图像,可以采用以下方法:
- 在一个新的图像上绘制点。
- 对这个新图像进行模糊处理。
- 将模糊处理后的点图像与原始图像进行合并。
以下是实现这个思路的修改代码:
import numpy as np import cv2 def add_random_dots(noisy_depth_map, mask, num_dots=100, dot_radius=5, blur_radius=15): if len(noisy_depth_map.shape) != 2: raise ValueError("Input noisy_depth_map must be a 2-dimensional array (height, width)") if noisy_depth_map.dtype != np.uint8: raise ValueError("Input noisy_depth_map must be of type np.uint8") if mask.shape != noisy_depth_map.shape: raise ValueError("Mask must have the same dimensions as noisy_depth_map") h, w = noisy_depth_map.shape zero_mask_indices = np.argwhere(mask == 0) if len(zero_mask_indices) < num_dots: raise ValueError("Not enough space to place the requested number of dots in the given mask.") # 创建一个和 noisy_depth_map 相同的空白图像用于绘制点 dot_image = np.zeros_like(noisy_depth_map) for _ in range(num_dots): # 随机选择mask为0的位置 y, x = zero_mask_indices[np.random.choice(len(zero_mask_indices))] dot_color = np.random.randint(0, 256) # 在新图像上绘制一个圆形 cv2.circle(dot_image, (x, y), radius=dot_radius, color=dot_color, thickness=-1) # -1 表示填充 # 使用高斯模糊使绘制的点的边缘模糊 blurred_dots = cv2.GaussianBlur(dot_image, (blur_radius, blur_radius), 0) # 将模糊的点与原始图像结合 noisy_depth_map = cv2.addWeighted(noisy_depth_map, 1, blurred_dots, 1, 0) return noisy_depth_map # 调用示例: # noisy_depth_map = np.zeros((height, width), dtype=np.uint8) # mask = np.zeros((height, width), dtype=np.uint8) # 例如,mask中的值为0和1 # noisy_depth_map_with_dots = add_random_dots(noisy_depth_map, mask, num_dots=100, dot_radius=5, blur_radius=15)关键变化:
-
使用新图像
dot_image:- 创建一个与
noisy_depth_map相同大小的空白图像dot_image,在上面绘制点。
- 创建一个与
-
先对新图像进行模糊处理:
- 对绘制了圆形的
dot_image进行高斯模糊处理,使得点的边缘模糊。
- 对绘制了圆形的
-
合成原始图像与模糊的点图像:
- 使用
cv2.addWeighted将原始的noisy_depth_map和模糊后的blurred_dots结合,从而只模糊点的边缘,而不影响原始图像的其他部分。
- 使用
这样,您就可以单独控制点的边缘模糊而不影响整个图像了。如果有其他需求或问题,请随时告知!
- User
请在下述代码的基础上,给定三种不同的点大小,每次循环重新选择
- Assistant
好的!为了让每次循环选择三种不同的点大小,您可以在代码中随机选择这些点的大小。以下是对原始代码的修改,以实现该功能。我们将定义三种不同的点大小并在每次迭代中随机选择一个:
import numpy as np import cv2 def add_random_dots(noisy_depth_map, mask, num_dots=100, dot_sizes=[3, 5, 7], blur_radius=15): if len(noisy_depth_map.shape) != 2: raise ValueError("Input noisy_depth_map must be a 2-dimensional array (height, width)") if noisy_depth_map.dtype != np.uint8: raise ValueError("Input noisy_depth_map must be of type np.uint8") if mask.shape != noisy_depth_map.shape: raise ValueError("Mask must have the same dimensions as noisy_depth_map") h, w = noisy_depth_map.shape zero_mask_indices = np.argwhere(mask == 0) if len(zero_mask_indices) < num_dots: raise ValueError("Not enough space to place the requested number of dots in the given mask.") # 创建一个和 noisy_depth_map 相同的空白图像用于绘制点 dot_image = np.zeros_like(noisy_depth_map) for _ in range(num_dots): # 随机选择mask为0的位置 y, x = zero_mask_indices[np.random.choice(len(zero_mask_indices))] dot_color = np.random.randint(0, 256) # 随机选择点的大小 dot_radius = np.random.choice(dot_sizes) # 在新图像上绘制一个圆形 cv2.circle(dot_image, (x, y), radius=dot_radius, color=dot_color, thickness=-1) # -1 表示填充 # 使用高斯模糊使绘制的点的边缘模糊 blurred_dots = cv2.GaussianBlur(dot_image, (blur_radius, blur_radius), 0) # 将模糊的点与原始图像结合 noisy_depth_map = cv2.addWeighted(noisy_depth_map, 1, blurred_dots, 1, 0) return noisy_depth_map # 调用示例: # noisy_depth_map = np.zeros((height, width), dtype=np.uint8) # mask = np.zeros((height, width), dtype=np.uint8) # 例如,mask中的值为0和1 # noisy_depth_map_with_dots = add_random_dots(noisy_depth_map, mask, num_dots=100, dot_sizes=[3, 5, 7], blur_radius=15)关键修改点:
-
新增参数
dot_sizes:- 参数
dot_sizes是一个列表,包含三种不同的点大小(例如[3, 5, 7])。
- 参数
-
随机选择点大小:
- 在每次循环中,通过
np.random.choice(dot_sizes)随机选择一个点的大小。
- 在每次循环中,通过
这样,您就能够在每次绘制点时随机选择指定的点大小。如果有其他需求或者问题,请随时告诉我!
-
- User
from future import absolute_import, division, print_function
import os import random import numpy as np from PIL import Image from skimage.filters import gaussian, sobel from scipy.interpolate import griddata import cv2 import torch from torchvision import transforms import multiprocessing as mp from utils import transfer_color import matplotlib.pyplot as plt import sys from tqdm import tqdm
def pil_loader(path): # print(path) with open(path, 'rb') as f: from PIL import Image with Image.open(f) as img: return img.convert('RGB')
def depth_loader(path): # print(path) with open(path, 'rb') as f: from PIL import Image with Image.open(f) as img: return img.convert('L')
def read_pfm(file): with open(file, 'rb') as fh: fh.readline() width, height = str(fh.readline().rstrip())[2:-1].split() fh.readline() disp = np.fromfile(fh, '<f') return np.flipud(disp.reshape(int(height), int(width)))
def load_images(img_path, idx, do_flip=False): image = pil_loader(img_path[idx]) if do_flip: image = image.transpose(Image.FLIP_LEFT_RIGHT) frame = random.choice(img_path) background = pil_loader(frame) return image, background
def load_disparity(depth_path, idx, do_flip=False): depth = depth_loader(depth_path[idx]).convert("L") # disparity = 255 - np.squeeze(np.array(depth)) disparity = np.squeeze(np.array(depth))
if do_flip: disparity = disparity[:, ::-1] return disparitydef preprocess(inputs, feed_width, feed_height, disable_normalisation, has_gt, to_tensor, is_train, brightness, contrast, saturation, hue): if is_train and random.random() > 0.5: color_aug = transforms.ColorJitter.get_params( brightness, contrast, saturation, hue) for key in ['image', 'stereo_image']: inputs[key] = color_aug(inputs[key])
for key in ['image', 'stereo_image']: if disable_normalisation: inputs[key] = to_tensor(inputs[key]) else: inputs[key] = (to_tensor(inputs[key]) - 0.45) / 0.225 if has_gt: inputs['disparity'] = torch.from_numpy(inputs['disparity']).float() if inputs.get('mono_disparity') is not None: inputs['mono_disparity'] = torch.from_numpy(inputs['mono_disparity']).float()def process_disparity(disparity, feed_height, process_width, max_disparity_range=(40, 196), disable_sharpening=True): disparity = disparity.copy() min_disp = disparity.min() if min_disp < 0: disparity += np.abs(min_disp)
disparity /= disparity.max() scaling_factor = (max_disparity_range[0] + random.random() * (max_disparity_range[1] - max_disparity_range[0])) disparity *= scaling_factor if not disable_sharpening: edges = sobel(disparity) > 3 disparity[edges] = 0 mask = disparity > 0 ys, xs = np.meshgrid(np.arange(process_width), np.arange(feed_height)) try: disparity = griddata(np.stack([ys[mask].ravel(), xs[mask].ravel()], 1), disparity[mask].ravel(), np.stack([ys.ravel(), xs.ravel()], 1), method='nearest').reshape(feed_height, process_width) except (ValueError, IndexError): pass return disparitydef prepare_sizes(inputs, feed_height, process_width, keep_aspect_ratio): height, width, _ = np.array(inputs['left_image']).shape if keep_aspect_ratio: # if feed_height <= height and process_width <= width: # target_height, target_width = height, width if feed_height <= height and process_width <= width: target_height, target_width = feed_height, feed_width ### 这边改一下 else: current_ratio = height / width target_ratio = feed_height / process_width if current_ratio < target_ratio: target_height = feed_height target_width = int(feed_height / height * width) elif current_ratio > target_ratio: target_height = int(process_width / width * height) target_width = process_width else: target_height, target_width = feed_height, process_width else: target_height, target_width = feed_height, process_width
# inputs = resize_all(inputs, feed_height, feed_width) inputs = resize_all(inputs, target_height, target_width) if not (target_height == feed_height and target_width == process_width): inputs = crop_all(inputs, feed_height, process_width) return inputsdef crop_all(inputs, feed_height, process_width): ###要么改这,要么改上面 ##改这的话可以多crop几张 height, width, _ = np.array(inputs['left_image']).shape top = int(random.random() * (height - feed_height)) left = int(random.random() * (width - process_width)) right, bottom = left + process_width, top + feed_height for key in ['left_image', 'background']: inputs[key] = inputs[key].crop((left, top, right, bottom)) inputs['loaded_disparity'] = inputs['loaded_disparity'][top:bottom, left:right] return inputs
def resize_all(inputs, height, width): img_resizer = transforms.Resize(size=(height, width)) for key in ['left_image', 'background']: inputs[key] = img_resizer(inputs[key]) disp = inputs['loaded_disparity'] disp = np.array(disp).astype(np.float32) disp *= width / disp.shape[1] disp = cv2.resize(disp.astype(float), (width, height)) inputs['loaded_disparity'] = disp return inputs
def get_occlusion_mask(shifted, process_width): mask_up, mask_down = shifted > 0, shifted > 0 shifted_up, shifted_down = np.ceil(shifted), np.floor(shifted) for col in range(process_width - 2): loc = shifted[:, col:col + 1] loc_up, loc_down = np.ceil(loc), np.floor(loc) _mask_down = ((shifted_down[:, col + 2:] != loc_down) & (shifted_up[:, col + 2:] != loc_down)).min(-1) _mask_up = ((shifted_down[:, col + 2:] != loc_up) & (shifted_up[:, col + 2:] != loc_up)).min(-1) mask_up[:, col], mask_down[:, col] = mask_up[:, col] * _mask_up, mask_down[:, col] * _mask_down return mask_up + mask_down
def project_image(np_xs, np_ys, feed_height, process_width, image, disp_map, background_image, disable_background): image, background_image = np.array(image), np.array(background_image) warped_image = np.zeros_like(image).astype(float) warped_image = np.stack([warped_image] * 2, 0) pix_locations = np_xs - disp_map mask = get_occlusion_mask(pix_locations, process_width) masked_pix_locations = pix_locations * mask - process_width * (1 - mask) weights = np.ones((2, feed_height, process_width)) * 10000
for col in range(process_width - 1, -1, -1): loc = masked_pix_locations[:, col] loc_up, loc_down = np.ceil(loc).astype(int), np.floor(loc).astype(int) weight_up, weight_down = loc_up - loc, 1 - (loc_up - loc) mask = loc_up >= 0 mask[mask] = weights[0, np.arange(feed_height)[mask], loc_up[mask]] > weight_up[mask] weights[0, np.arange(feed_height)[mask], loc_up[mask]] = weight_up[mask] warped_image[0, np.arange(feed_height)[mask], loc_up[mask]] = image[:, col][mask] / 255. mask = loc_down >= 0 mask[mask] = weights[1, np.arange(feed_height)[mask], loc_down[mask]] > weight_down[mask] weights[1, np.arange(feed_height)[mask], loc_down[mask]] = weight_down[mask] warped_image[1, np.arange(feed_height)[mask], loc_down[mask]] = image[:, col][mask] / 255. weights /= weights.sum(0, keepdims=True) + 1e-7 weights = np.expand_dims(weights, -1) warped_image = warped_image[0] * weights[1] + warped_image[1] * weights[0] warped_image *= 255. if not disable_background: occluded = warped_image.max(-1) == 0 warped_image[occluded] = background_image[occluded] return warped_image.astype(np.uint8)def augment_synthetic_image(disable_synthetic_augmentation, image): if disable_synthetic_augmentation: return Image.fromarray(image.astype(np.uint8))
noise = np.random.randn(feed_height, process_width, 3) / 50 image = np.clip(image / 255 + noise, 0, 1) * 255 if random.random() > 0.5: image = gaussian(image, sigma=random.random()) image = np.clip(image, 0, 255) return Image.fromarray(image.astype(np.uint8))def process_and_save(data, save_path, np_xs, np_ys, feed_height, process_width, count): left, right_image, disparity, mono_disparity = data idx = count + 773 print('idx=',idx) val_path = save_path + str(idx) + "_right.jpg" print(val_path)
if os.path.isfile(val_path): sys.exit() else: left = cv2.cvtColor(left, cv2.COLOR_RGB2BGR) right_image = cv2.cvtColor(right_image, cv2.COLOR_RGB2BGR) cv2.imwrite(save_path + str(idx) + "_left.jpg", left) cv2.imwrite(save_path + str(idx) + "_right.jpg", right_image) cv2.imwrite(save_path + str(idx) + "_disp.png", disparity * 10) data = {'left': left, 'right': right_image, 'disparity': disparity, 'mono_disparity': mono_disparity} return datadef worker(save_path, data_paths, max_disparity, disable_background, disable_sharpening, disable_synthetic_augmentation, process_width, feed_height, feed_width, disable_normalisation, has_gt, to_tensor, is_train, brightness, contrast, saturation, hue, np_xs, np_ys, keep_aspect_ratio, count): try: val_path = save_path + str(count) + "_right.jpg" if os.path.isfile(val_path): print(val_apth) sys.exit() else: img_path, depth_path = data_paths do_flip = is_train and random.random() > 0.5
left_image, background_image = load_images(img_path, count, do_flip) loaded_disparity = load_disparity(depth_path, count, do_flip) inputs = {'left_image': left_image, 'background': background_image, 'loaded_disparity': loaded_disparity} inputs = prepare_sizes(inputs, feed_height, process_width, keep_aspect_ratio) inputs['background'] = transfer_color(np.array(inputs['background']), np.array(inputs['left_image'])) disparity = process_disparity(inputs['loaded_disparity'], feed_height, process_width, (10, max_disparity)) right_image = project_image(np_xs, np_ys, feed_height, process_width, inputs['left_image'], disparity, inputs['background'], disable_background) right_image = augment_synthetic_image(disable_synthetic_augmentation, right_image) inputs = {'image': inputs['left_image'], 'stereo_image': right_image, 'disparity': disparity.astype(float), 'mono_disparity': inputs['loaded_disparity'].astype(float)} for key in ['image', 'stereo_image']: inputs[key] = inputs[key].crop((0, 0, feed_width, feed_height)) for key in ['disparity', 'mono_disparity']: inputs[key] = inputs[key][:, :feed_width] return process_and_save([np.array(inputs["image"]), np.array(inputs["stereo_image"]), np.array(inputs["disparity"]), np.array(inputs["mono_disparity"])], save_path, np_xs, np_ys, feed_height, process_width, count) except: print("error")if name == "main": # data_path = "/home/notebook/data/group/Ruby/langan_datasets/nightlangan3_deblur/" np.random.seed(42)
itxt_path = 'naicha2_image.txt' dtxt_path = 'naicha2_depth.txt' all_img = [] all_depth = [] with open(itxt_path, 'r') as fi: for li in fi.readlines(): li = li.strip('\n') all_img.append(li) with open(dtxt_path, 'r') as fd: for ld in fd.readlines(): ld = ld.strip('\n') all_depth.append(ld) img_path = all_img depth_path = all_depth save_path = r"/home/notebook/data/group/Ruby/langan_datasets/shoushi/naicha2_mono/" count_start, count_end = 0, len(all_img) # feed_height, feed_width, process_width = 1024, 768, 768 + 20 feed_height, feed_width, process_width = 1024, 768, 768 disable_background, is_train = False, True disable_normalisation, has_gt, disable_sharpening = True, True, True max_disparity = 20 disable_synthetic_augmentation = True brightness, contrast, saturation, hue = (0.8, 1.2), (0.8, 1.2), (0.8, 1.2), (-0.1, 0.1) np_xs, np_ys = np.meshgrid(np.arange(process_width), np.arange(feed_height)) to_tensor = transforms.ToTensor() keep_aspect_ratio = True data_paths = (img_path, depth_path) num_workers = 16 with mp.Pool(processes=num_workers) as pool: results = [ pool.apply_async(worker, args=(save_path, data_paths, max_disparity, disable_background, disable_sharpening, disable_synthetic_augmentation, process_width, feed_height, feed_width, disable_normalisation, has_gt, to_tensor, is_train, brightness, contrast, saturation, hue, np_xs, np_ys, keep_aspect_ratio, count)) for count in tqdm(range(count_start, count_end), desc='Processing Images') ] processed_data = [p.get() for p in results] print("Processing complete.")帮我看一下这里面有没有随机翻转的代码
- Assistant
在您提供的代码中,确实有随机翻转图像的逻辑。主要是在
load_images和load_disparity函数中实现的,具体如下:找到的随机翻转部分:
-
在
load_images函数中:def load_images(img_path, idx, do_flip=False): image = pil_loader(img_path[idx]) if do_flip: image = image.transpose(Image.FLIP_LEFT_RIGHT) frame = random.choice(img_path) background = pil_loader(frame) return image, background- 这里根据
do_flip的值决定是否对此图像进行水平翻转(Image.FLIP_LEFT_RIGHT)。
- 这里根据
-
在
load_disparity函数中:def load_disparity(depth_path, idx, do_flip=False): depth = depth_loader(depth_path[idx]).convert("L") disparity = np.squeeze(np.array(depth)) if do_flip: disparity = disparity[:, ::-1] return disparity- 同样地,这里也根据
do_flip的值决定是否水平翻转disparity图像。
- 同样地,这里也根据
do_flip的赋值:- 在
worker函数中,do_flip这个变量是由以下代码设置的:do_flip = is_train and random.random() > 0.5- 这段代码表示在训练模式下(
is_train为True),有 50% 的概率设置do_flip为True,意味着图像和深度图在某次处理时会被随机翻转。
- 这段代码表示在训练模式下(
总结:
因此,代码中确实存在随机翻转的逻辑,具体是在加载图像和深度图时根据
do_flip进行判断。如果do_flip为True,则在加载过程中将图像和深度图进行翻转处理。 -