def _augment_noise(in_images, noise_type=NoiseType.gaussian_noise, std=1.): for i in range(len(in_images)): if noise_type == NoiseType.gaussian_noise: in_images[i] = random_noise(in_images[i], mode='gaussian', var=std**2) elif noise_type == NoiseType.poisson_noise: in_images[i] = random_noise(in_images[i], mode='poisson') elif noise_type == NoiseType.speckle_noise: in_images[i] = random_noise(in_images[i], mode='speckle', var=std**2) return in_images
def add_noise(img, mode, var): sigma = var sigma_ = sigma / 255. sigma_ = sigma_ * sigma_ if mode is None: raise Exception('please add the noise type !!') if var is None: noisemat = random_noise(img, mode=mode) elif mode == 'poisson': noisemat = random_noise(img, mode=mode) else: noisemat = random_noise(img, mode=mode, var=sigma_) return noisemat
def generateGaussianRandomVarNoise(img): #choosen_var = np.random.uniform(0.0005,0.01) # sigma from 0.02~0.1 choosen_var = np.random.uniform(0.0001, 0.0025) # sigma from 0.01~0.05 #sigma = 10**(np.random.uniform(-4,-1)) #sigma = sigma**2 return np.clip(random_noise(img, mode='gaussian', var=choosen_var), 0, 1)
def __init__(self, sensor, colour=True, depth=True, **kwargs): """ A wrapper class for the random_noise function from the skimage.util.noise package. The default noise type is gaussian additive noise. For a list of arguments refer to the scikit-image documentation. The 'seed' argument is disabled, since it would cause the class to generate the same noise for all images. Args: colour(bool): Whether to apply noise to the colour image. depth(bool): Whether to apply noise to the depth image. """ self.logger = getLogger(f'{LOGGER_ID}.RandomImageNoise') self.logger.setLevel(DEBUG) super().__init__(sensor) img_types = ['colour', 'depth'] use = [colour, depth] self._data = dict() self._img_types = [t for t, do in zip(img_types, use) if do] self.logger.debug('Creating noise for the following image types: ' f'{", ".join(self._img_types)}') if 'seed' in kwargs: self.logger.debug('The seed option is disabled and will ' 'be removed from argument list.') kwargs.update({'seed': None}) self._generate_noise = lambda img: skinoise.random_noise(img, **kwargs)
def initialize(content, style, segmentation, L_max): # apply color transfer from S to C new_content = color_transform(content, style) # Build the Gaussian pyramids of C, S, and W images = pd.DataFrame( index=["L" + str(i) for i in range(L_max + 1)], columns=['content', 'style', 'segmentation', 'estimation']) images['original'] = list( pyramid_gaussian(content, multichannel=True, max_layer=L_max)) images['content'] = list( pyramid_gaussian(new_content, multichannel=True, max_layer=L_max)) images['style'] = list( pyramid_gaussian(style, multichannel=True, max_layer=L_max)) images['segmentation'] = list( pyramid_gaussian(segmentation, multichannel=False, max_layer=L_max)) #mages['segmentation'] = [None]*(L_max+1) # initialize X with additive gaussian to content ∼ N (0, 50) estimated_image = noise.random_noise( new_content, mode="gaussian", mean=0, var=50 / 256) # normalized variance because image is normalized images['estimation'] = list( pyramid_gaussian(estimated_image, multichannel=True, max_layer=L_max)) # images['estimation'][images.index[-1]] = rescale(estimated_image, 1 / (2 ** L_max), multichannel=True,anti_aliasing=True, mode='constant', cval=0) return images
def generateGaussianRandomVarNoiseChannelSpecificSTD(img, std): out = np.zeros_like(img) for channel in range(img.shape[-1]): choosen_var = np.random.uniform(std - 0.005, std + 0.005) out[:, :, channel] = random_noise(img[:, :, channel], mode='gaussian', var=choosen_var) return out
def noise_injection(x, noise_kwargs): from skimage.util.noise import random_noise channel = x.shape[2] if channel == 1 or channel == 3: y = random_noise(x, **noise_kwargs) else: raise RuntimeError('Channel is not grayscale or RGB') return y
def generateGaussianRandomVarNoiseChannelSpecific(img): out = np.zeros_like(img) for channel in range(img.shape[-1]): choosen_var = np.random.uniform(0.0001, 0.0025) # sigma from 0.01~0.05 out[:, :, channel] = random_noise(img[:, :, channel], mode='gaussian', var=choosen_var) return out
def generateGaussianRandomVarNoiseChannelSpecific(img, std=0.02): out = np.zeros_like(img) for channel in range(img.shape[-1]): choosen_var = std**2 #CHOSEN_STD(1)[0][0]**2 #std from 1600: 0.06585 #np.random.uniform(0.0005,0.01) out[:, :, channel] = random_noise(img[:, :, channel], mode='gaussian', var=choosen_var) out = np.clip(out, 0, 1) return out
def add_noise(img_path, i): img=Image.open(img_path) img=np.array(img) var=np.random.uniform(0,0.01) mean=np.random.uniform(0,0.1) noise_img=random_noise(img, mean=mean, var=var) print(var, "\t", mean) Image.fromarray(np.uint8(noise_img*255)).save("C:/Users/Administrator/Desktop/train_B/{}.jpg".format(str(i))) print(i, "done")
def poisson_noise(ref): """Poisson noise Parameters ---------- ref : :class:`numpy.ndarray` Image to be noised. Returns ------- inp : :class:`numpy.ndarray` Noised image. """ inp = random_noise(ref, mode='poisson', seed=RANDOM_SEED, clip=True) assert inp.shape == ref.shape, "Shape mismatch between input ({}) and output ({})".format(inp.shape, ref.shape) return inp
def gaussian_noise(ref, noise_level=15): """Gaussian noise Parameters ---------- ref : :class:`numpy.ndarray` Image to be noised. noise_level : :class:`numpy.ndarray` Level of corruption. Always give the noise_level in terms of 0-255 pixel intensity range. Returns ------- inp : :class:`numpy.ndarray` Noised image. """ inp = random_noise(ref, mode='gaussian', clip=False, var=(noise_level / 255) ** 2) assert inp.shape == ref.shape, "Shape mismatch between input ({}) and output ({})".format(inp.shape, ref.shape) return inp
def speckle_noise(ref, noise_level=15): """Speckle noise Parameters ---------- ref : :class:`numpy.ndarray` Image to be noised. noise_level : :class:`numpy.ndarray` Percentage of perturbed pixels. Returns ------- inp : :class:`numpy.ndarray` Noised image. """ inp = random_noise(ref, mode='speckle', clip=True, var=noise_level) assert inp.shape == ref.shape, "Shape mismatch between input ({}) and output ({})".format(inp.shape, ref.shape) return inp
def _generate_noisy_data(self): """ This member function is called to generate the noise and applies it to the point cloud. """ point_cloud = np.array(self._sensor.data['points']) if point_cloud.size > 0: point_cloud = point_cloud.astype(np.float64) magnitude = max(point_cloud.max(), np.abs(point_cloud.min())) point_cloud /= magnitude point_cloud = skinoise.random_noise(point_cloud, mode='gaussian', mean=self._mean, var=self._var) point_cloud = point_cloud * magnitude point_cloud = skitype.img_as_float32(point_cloud) else: point_cloud = self._sensor.data['points'] self._data.update({'points': point_cloud})
def imgNoise(oriImg: str, flag=True,noise_type:list=[]): if len(noise_type) == 0: noise_type = ['gaussian', 'poisson', 's&p', 'speckle'] l = np.random.randint(2, size=len(noise_type)).tolist() p = list(zip(noise_type, l)) if isinstance(oriImg, str): if os.path.exists(oriImg): img = io.imread(oriImg) else: raise FileNotFoundError('Original image not found') else: img = oriImg for i in p: if i[1] != 0: img = snoise.random_noise(img, mode=i[0]) # print(np.max(img)) # print(np.min(img)) img = np.array(img * 255).astype(np.uint8) if flag: parent_path = os.path.dirname(oriImg) if os.path.exists(parent_path + os.sep + 'augimgs_'): pass else: os.makedirs(parent_path + os.sep + 'augimgs_') # fileName = oriLabel.split(os.sep)[-1].replace('.json','') tmp = os.path.splitext(oriImg)[0] fileName = tmp.split(os.sep)[-1] io.imsave( parent_path + os.sep + 'augimgs_' + os.sep + fileName + '_noise.jpg', img) else: d = dict() d['noise'] = Ori_Pro(img, None) return d
def salt_and_pepper_noise(ref, noise_level=15): """Salt and pepper noise Parameters ---------- ref : :class:`numpy.ndarray` Image to be noised. noise_level : :class:`numpy.ndarray` Percentage of perturbed pixels. Returns ------- inp : :class:`numpy.ndarray` Noised image. """ assert noise_level >= 0 and noise_level <= 100, "Expected noise_level to be a percentage," \ "but got {}".format(noise_level) inp = random_noise(ref, mode='s&p', seed=RANDOM_SEED, clip=True, amount=noise_level / 100.0) assert inp.shape == ref.shape, "Shape mismatch between input ({}) and output ({})".format(inp.shape, ref.shape) return inp
def regular_augmenter(img, gt): shapes = len(img.shape) img = np.squeeze(img) gt = np.squeeze(gt) if np.random.random() > 0.5: img = np.fliplr(img) gt = np.fliplr(gt) if np.random.random() > 0.5: idx_x = [576, 544, 512, 480] idx_y = [768, 736, 704, 672] img = cropND( img, (idx_x[np.random.randint(4)], idx_y[np.random.randint(4)], 3)) gt = cropND(gt, img.shape) if np.random.random() > 0.5: img = random_noise(img) img = img[np.newaxis, ...] gt = gt[np.newaxis, ..., np.newaxis] assert len(img.shape) == shapes assert len(gt.shape) == shapes assert img.shape[1] % 32 == 0 assert img.shape[2] % 32 == 0 return img, gt
def imgNoise(oriImg: str, oriLabel: str, flag=True): """ see skimage.util.random_noise """ noise_type = ['gaussian', 'poisson', 's&p', 'speckle'] l = np.random.randint(2, size=len(noise_type)).tolist() # print(l) p = list(zip(noise_type, l)) if isinstance(oriImg, str): if os.path.exists(oriImg): img = io.imread(oriImg) else: raise FileNotFoundError('Original image not found') elif isinstance(oriImg, np.ndarray): img = oriImg else: logger.error('input {} type error'.format(imgFlip)) return for i in p: if i[1] != 0: img = snoise.random_noise(img, mode=i[0]) img = np.array(img * 255).astype(np.uint8) if flag: parent_path = os.path.dirname(oriLabel) if os.path.exists(parent_path + os.sep + 'jsons_'): pass else: os.makedirs(parent_path + os.sep + 'jsons_') fileName = oriLabel.split(os.sep)[-1].replace('.json', '') io.imsave( parent_path + os.sep + 'jsons_' + os.sep + fileName + '_noise.jpg', img) try: if isinstance(oriLabel, str): shutil.copyfile( oriLabel, parent_path + os.sep + 'jsons_' + os.sep + fileName + '_noise.json') base64code = imgEncode(parent_path + os.sep + 'jsons_' + os.sep + fileName + '_noise.jpg') with open( parent_path + os.sep + 'jsons_' + os.sep + fileName + '_noise.json', 'r') as f: load_dict = json.load(f) load_dict['imageData'] = base64code with open( parent_path + os.sep + 'jsons_' + os.sep + fileName + '_noise.json', 'w') as f: # json.dump(load_dict,parent_path+os.sep+'jsons_'+os.sep+fileName+'_noise.json') f.write(json.dumps(load_dict)) elif isinstance(oriLabel, np.ndarray): """ labeled file can be an Image """ noisedMask_j = getMultiShapes(parent_path + os.sep + 'jsons_' + os.sep + fileName + '_noise.jpg', oriLabel, flag=True, labelYamlPath='') with open( parent_path + os.sep + 'jsons_' + os.sep + fileName + '_noise.json', 'w') as f: f.write(json.dumps(noisedMask_j)) except Exception: print(traceback.format_exc()) else: d = dict() # mask = processor(oriLabel,flag=True) if isinstance(oriLabel, str): mask = processor(oriLabel, flag=True) elif isinstance(oriLabel, np.ndarray): mask = oriLabel else: raise TypeError( "input parameter 'oriLabel' type {} is not supported".format( type(oriLabel))) d['noise'] = Ori_Pro(img, mask) return d
def style_transfer(content_path, style_path, I_irls, I_alg, seg_fac, L_max): content = io.imread(content_path).astype('float64') / 255 content = cv2.resize(content, (400, 400)) style = io.imread(style_path).astype('float64') / 255 style = cv2.resize(style, (400, 400)) segmentation = get_segmentation(content_path) * seg_fac + 0.25 * seg_fac # segmentation = np.zeros(content.shape[:-1]) images = initialize(content, style, segmentation, L_max) scaler_objects, pca_objects, nn_objects, style_patches = prepare_style_patches( images['style'], L_max=L_max) for layer in reversed(style_patches.index): for index, patch_size in enumerate(style_patches.columns): # add another loop for IRLS itarations scaler = scaler_objects[patch_size][layer] pca = pca_objects[patch_size][layer] nn = nn_objects[patch_size][layer] current_style_patches = style_patches[patch_size][layer] for _ in range(I_alg): # convert estimation image of the current layer to patches we can operate on estimation_image = noise.random_noise( images['estimation'][layer], mode="gaussian", mean=0, var=100 / 256) # normalized variance because image is normalized current_estimation_patches = image_to_patches(estimation_image, is_pyramid=False, index=index) flat_curr_estimation_patches = flatten_patches( current_estimation_patches, rotate=False) scaled_estimation_patches = apply_standard_Scaler( flat_curr_estimation_patches, scaler=scaler) reduced_estimation_patches = apply_pca( scaled_estimation_patches, pca=pca) nn_indices = apply_nearest_neighbor(reduced_estimation_patches, nbrs=nn) nn_patches = get_nn_style_patch_from_indices( current_style_patches, nn_indices, current_estimation_patches.shape) # IRLS estimation_image = IRLS(images['estimation'][layer], nn_patches, patch_size, subsampling_gaps[index], I_irls) e1 = np.copy(estimation_image) # content fusion estimation_image = content_fusion( images['content'][layer], estimation_image, images['segmentation'][layer]) e2 = np.copy(estimation_image) # color transfer estimation_image = color_transform(estimation_image, images['style'][layer]) e3 = np.copy(estimation_image) # domain transform filter # sigma_s = 100 # sigma_r = 3 # # estimation_image = Iterative_C(estimation_image * 255, sigma_s, sigma_r,3)/255 # e4 = np.copy(estimation_image) show_animated([ images['style'][layer], images['original'][layer], estimation_image ], ["style", "content", "estimation"]) # print("style max", images['style'][layer].max(),"style min", images['style'][layer].min()) # print("content max", images['content'][layer].max(),"content min", images['content'][layer].min()) # print("est max", images['estimation'][layer].max(),"est min", images['estimation'][layer].min()) # estimation_image = noise.random_noise(estimation_image, mode="gaussian", mean=0, var=50 / 256) # normalized variance because image is normalized # e5 = estimation_image # show_animated([e1, e2, e3, e4, e5], ["irls", "content fusion", "color transfer", "domain transform", "noise"]) images['estimation'][layer] = estimation_image # scaling up images['estimation'][list(images.index).index(layer) - 1] =\ rescale(images['estimation'][layer], 2, multichannel=True,anti_aliasing=True, mode='constant', cval=0) # show_images([images['style'][layer], images['original'][layer], images['estimation']['L0']],["style", "content", "result"]) # plt.pause(500) return images['estimation']['L0']
'GT_SRGB', 'NOISY_SRGB')).astype('float32') / 255.0 img_clean_NF = imageio.imread( img_name.replace( 'samples_gts', 'samples_gtsNF')).astype('float32') / 255.0 img_noisy_NF = imageio.imread( img_name.replace('samples_gts', 'samples_noisyNF').replace( 'GT_SRGB', 'NOISY_SRGB')).astype('float32') / 255.0 img_gan = imageio.imread( img_name.replace('samples_gts', 'GAN').replace( '.png', '_fake_B.png')).astype('float32') / 255.0 #std = np.random.uniform(0.24,11.51)/255.0 #Noiseflow values std = gaussian_stds[str(cur_iso)]['both_dataset'] std_linear = gaussian_stds[str(cur_iso)]['both_dataset_linear'] img_gaussian = random_noise(img_clean, mode='gaussian', var=std**2) #img_gaussian = np.clip(random_noise(img_clean**2.2,mode='gaussian',var=std_linear**2)**(1/2.2),0,1) ## AWGN linear #img_awgn_poi_linear = generateGaussianPoissonNoise(img_clean,std) img_awgn_poi_linear = np.clip( generateGaussianPoissonNoise((img_clean**2.2), std_linear)**(1 / 2.2), 0, 1) ## GaussianPoissonian in linear #img_gaussian = imageio.imread(img_name.replace('samples_GT_sRGB','samples_gaussian_sRGB')).astype('float32')/255.0 img_noiseflow = imageio.imread( img_name.replace( 'samples_gts', 'samples_noiseflowNF')).astype('float32') / 255.0 #Computing diffs diff_natural = img_noisy - img_clean
def generateGaussianRandomVarNoiseSTD(img, std): choosen_var = np.random.uniform(std - 0.005, std + 0.005) #sigma=[0,022~0.1] return random_noise(img, mode='gaussian', var=choosen_var)
def generateGaussianRandomVarNoise(img, std=0.02): #choosen_var = np.random.uniform(0.0005,0.01) #sigma=[0,022~0.1] choosen_var = std**2 #gaussian_stds['800']['both_dataset']**2 #CHOSEN_STD(1)[0][0]**2 #std from 1600: 0.06585 return random_noise(img, mode='gaussian', var=choosen_var)
def generatePoissonNoise(img): return random_noise(img, mode='poisson')