def splice(self, image, mask, gan_out): if mask.shape[-1] > 0: mask = (np.sum(mask, -1, keepdims=True) < 1) mask = 1 - mask # invert mask for blending mask = mask.astype('uint8') * 255 mask = GaussianBlur(mask, (29, 29), 0) # mask_img = np.zeros([mask.shape[0], mask.shape[1],3]).astype('uint8') # for i in range(3): # mask_img[:,:,i] = mask mask_img = mask.astype(float) / 255 # proper blending courtesy of https://www.learnopencv.com/alpha-blending-using-opencv-cpp-python/ fg_o = gan_out.astype(float) bg_o = image.astype(float) fg = np.zeros([mask.shape[0], mask.shape[1], 3]).astype(float) bg = np.zeros([mask.shape[0], mask.shape[1], 3]).astype( float ) # create foreground and background images with proper rgb channels cover = image for i in range(3): # Multiply the fg with the mask matte fg[:, :, i] = multiply(mask_img, fg_o[:, :, i]) # Multiply the bg with ( 1 - mask_img ) bg[:, :, i] = multiply(1.0 - mask_img, bg_o[:, :, i]) # Add the masked fg and bg. cover[:, :, i] = add(fg[:, :, i], bg[:, :, i]) else: #error case, return image cover = image return cover
def blur(img, blur_amount=5): if(blur_amount == 7): dst2 = GaussianBlur(img,(7,7),0) dst = bilateralFilter(dst2, 7, 80, 80) else: dst2 = GaussianBlur(img,(5,5),0) dst = bilateralFilter(dst2, 7, 10 * blur_amount, 80) return dst
def gaussian_blur(self, image=None, kernel=(5, 5)) -> ndarray: ''' Applies a Gaussian Noise kernel :param image: numpy.ndarray input image :param kernel: tuple kernel size :return: <numpy.ndarray> ''' if image is not None: assert issubclass(ndarray, type( image)), 'image must be <numpy.ndarray>, for gaussian blur' return GaussianBlur(image, kernel, 0) self.image_tf = GaussianBlur(self.gray, kernel, 0) return self.image_tf
def findFire(data): '''Locates the brightest area in the frame by applying a differential gaussian filter and creating a byte array light vs dark. The centroid of the light region is found and returned as the location of the fire''' data = GaussianBlur(data,(3,3),2) mask = zeros(data.shape) mask[data > (data.mean() + data.max())/2.] = 1 mom = moments(mask) try: x, y = mom['m10']/mom['m00'], mom['m01']/mom['m00'] except ZeroDivisionError: x, y = nan, nan return x, y
def gen_blue_noise(mask, kpc_per_pix, beam, height=73, width=78, fsc=5): ''' Height and width are in the unit of pixel. 1 pixel in CALIFA is 1 arcsec. The fine-structure constant(fsc) is serving to produce a higher-resolution sky map. The kernel size must be odd and here the default value is 15. ''' noise = GaussianBlur(np.random.normal(0, 1, (width * fsc, height * fsc)), (15, 15), beam[0] / kpc_per_pix * fsc)[::fsc, ::fsc] y, x = np.meshgrid(np.arange(height), np.arange(width)) return (noise.reshape(-1)[mask], x.reshape(-1)[mask] * kpc_per_pix, y.reshape(-1)[mask] * kpc_per_pix, min(config.fixed_bin_size, kpc_per_pix))
def findFire(data): '''Locates the brightest area in the frame by applying a differential gaussian filter and creating a byte array light vs dark. The centroid of the light region is found and returned as the location of the fire''' data = GaussianBlur(data,(3,3),2) mask = zeros(data.shape) mask[data > (data.mean() + data.max())/1.5] = 1 mom = moments(mask) imwrite('mask{0}{1}{2}.bmp'.format(mom['m00'],mom['m02'],mom['m20']),mask) if mom['m00']: x, y = mom['m10']/mom['m00'], mom['m01']/mom['m00'] else: x, y = nan, nan return x, y
def sub_pixel_shift_test(): img = imread('../Images/Moon_Tile-024_043939_stacked_with_blurr_pp.tif', IMREAD_GRAYSCALE) show_image("Original image", img, fullscreen=True) spx_shifty = 5.2 spx_shiftx = 3.5 img_resized, img_shifted = subpixel_shifted_frame(img, spx_shifty, spx_shiftx) # for i in range(10): # show_image("Image resized", img_resized, fullscreen=True) # show_image("Image shifted", img_shifted, fullscreen=True) gauss_width_reference = 15 gauss_width_frame = 19 reference_frame_blurred_intermediate = GaussianBlur( img_resized, (gauss_width_reference, gauss_width_reference), 0).astype(float32) reference_frame_blurred = GaussianBlur( reference_frame_blurred_intermediate, (gauss_width_reference, gauss_width_reference), 0).astype(float32) frame_blurred = GaussianBlur(img_shifted, (gauss_width_frame, gauss_width_frame), 0) y_ap = 170 x_ap = 200 half_box_width = 24 y_low = y_ap - half_box_width y_high = y_ap + half_box_width x_low = x_ap - half_box_width x_high = x_ap + half_box_width reference_box_second_phase = reference_frame_blurred[y_low:y_high, x_low:x_high] reference_box_first_phase = reference_box_second_phase[::2, ::2] search_width = 10 shift_y_local_first_phase, shift_x_local_first_phase, success_first_phase, \ shift_y_local_second_phase, shift_x_local_second_phase, success_second_phase = \ Miscellaneous.multilevel_correlation(reference_box_first_phase, frame_blurred, gauss_width_frame, reference_box_second_phase, y_low, y_high, x_low, x_high, search_width, weight_matrix_first_phase=None, subpixel_solve=True) print("Shift in y, first phase: " + str(shift_y_local_first_phase) + ", second phase: " + str(shift_y_local_second_phase) + ", total: " + str(shift_y_local_first_phase + shift_y_local_second_phase)) print("Shift in x, first phase: " + str(shift_x_local_first_phase) + ", second phase: " + str(shift_x_local_second_phase) + ", total: " + str(shift_x_local_first_phase + shift_x_local_second_phase))
def __getitem__(self, index): upscale_factor = 4 all_patch_sizes = [60, 50, 40] patch_size = all_patch_sizes[upscale_factor - 2] lr_image_path = os.path.join(self.LR_path, self.LR_images[index]) hr_image_path = os.path.join(self.HR_path, self.HR_images[index]) lr_image = Image.open(lr_image_path) hr_image = Image.open(hr_image_path) lr_image.load() hr_image.load() lr_image_data = np.asarray(lr_image, dtype=np.float32) hr_image_data = np.asarray(hr_image, dtype=np.float32) seed = 42 lr_patch, hr_patch = get_patch(lr_image_data, hr_image_data, patch_size, upscale_factor, seed) # on testing, found several completely white patches, thus replacing them on fly while 35 > np.mean(lr_patch) or np.mean(lr_patch) > 220: seed += 1 lr_patch, hr_patch = get_patch(lr_image_data, hr_image_data, patch_size, upscale_factor, seed) lr_patch, hr_patch = lr_patch / 255, hr_patch / 255 if self.mode == "DN": lr_patch = random_noise(lr_patch) elif self.mode == "BD": lr_patch = GaussianBlur(lr_patch, (7, 7), 1.6) return lr_patch, hr_patch
def makebackground(imagepath, imagex, imagey, screenx, screeny): from cv2 import GaussianBlur, BORDER_DEFAULT scaleby = find_scale_factor(imagex, imagey, screenx, screeny, True) background = resize_image(imagepath, imagex, imagey, scaleby) background = GaussianBlur(background, (31, 31), BORDER_DEFAULT) background = crop(background, screenx, screeny) return background
def get_derivatives(img): I = GaussianBlur(src=img, ksize=(11, 11), sigmaX=7) h_x1, h_x2 = cv2.getDerivKernels(1, 0, 3, normalize=True) h_y1, h_y2 = cv2.getDerivKernels(0, 1, 3, normalize=True) img_x = cv2.sepFilter2D(I, -1, h_x1, h_x2) img_y = cv2.sepFilter2D(I, -1, h_y1, h_y2) return img_x, img_y
def execute(self, title="", size=None, showPlot=True): field = np.zeros(self._frameSize) #allCords = np.array([]) for i, track in enumerate(self._exp._tracks): #print('Track %d' % i) if track.getMaxDistTravelled() > 100: cords = track._trackCords.astype(np.int) field[cords[:, 0], cords[:, 1]] += 1 #allCords = np.vstack((allCords, cords)) if allCords.size else cords # First we roll the image to center the plate. rightBorder = np.min(np.where(field > 0)[1]) leftBorder = field.shape[1] - np.max(np.where(field > 0)[1]) allBorders = rightBorder + leftBorder correctBorder = np.floor(allBorders / 2) field = np.roll(field, int(correctBorder - rightBorder), axis=1) nField = (field - np.min(field)) / (np.max(field) - np.min(field)) #DEBUG nField = (np.log10(nField)) nField[nField == -np.inf] = 0 #DEBUG #nField = blur(nField, (24, 24)) nField = (GaussianBlur(nField, (65, 65), BORDER_DEFAULT, 15, 15)) # Saving the results self._results['mat'] = nField if showPlot == True: plt.style.use("dark_background") plt.imshow(nField, cmap=plt.get_cmap('gnuplot2_r')) plt.title(title) plt.axis('off') plt.show()
def generateBaseImage(image, sigma, assumed_blur): """Generate base image from input image by upsampling by 2 in both directions and blurring """ logger.debug('Generating base image...') image = resize(image, (0, 0), fx=2, fy=2, interpolation=INTER_LINEAR) sigma_diff = sqrt(max((sigma ** 2) - ((2 * assumed_blur) ** 2), 0.01)) return GaussianBlur(image, (0, 0), sigmaX=sigma_diff, sigmaY=sigma_diff) # the image blur is now sigma instead of assumed_blur
def gaussian(self, kernel_size, sigma_x, *args, region: tuple = None): """ Smooths a rectangle area of the image using Gaussian blur. :param sigma_x: Gaussian kernel standard deviation in X direction. :param kernel_size: Gaussian kernel size. kernel_size.width and kernel_size.height can differ but they both must be positive and odd. Or, they can be zero's and then they are computed from sigma. :param region: a tuple of top left and bottom right points of the smoothing area. The whole image will smoothed if not provided. :return: smoothed image. """ if not region: top_left, bottom_right = (0, 0), (self._obj.width, self._obj.height) else: top_left, bottom_right = region smoothed = self._obj.copy() smoothed_region = smoothed[top_left[1]:bottom_right[1], top_left[0]:bottom_right[0]] smoothed_region = GaussianBlur(smoothed_region, kernel_size, sigma_x, *args) smoothed[top_left[1]:bottom_right[1], top_left[0]:bottom_right[0]] = smoothed_region return self._obj.new(smoothed)
def get_Train_Test_Validation(self): url = [ "data_batch_1", "data_batch_2", "data_batch_3", "data_batch_4", "data_batch_5", "test_batch" ] X = [] y = [] d = self._uncrypt(url) for index in range(len(url)): n = d[url[index]][b'data'].shape[0] doc = url[index] for count in range(n): #Initialize a random Sigma value for the Gaussian Smoothing seed = randint(0, 3) src = self.CreateImage(d[doc][b'data'][count, :]) y.append(src) dst = GaussianBlur(src, (5, 5), seed) X.append(dst) #The proportion of the data is 70% Train, 15% Validation and 15% Test Xtrain, X_test, ytrain, y_test = train_test_split(np.asarray(X), np.asarray(y), test_size=0.3) Xtest, Xval, ytest, yval = train_test_split(X_test, y_test, test_size=0.5) return (Xtrain, ytrain, Xval, yval, Xtest, ytest)
def _find_edges(im): gray = cvtColor(im, COLOR_BGR2GRAY) # Apply histogram equalization - The parameters below are good clahe = createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) gray = clahe.apply(gray) gray = GaussianBlur(gray, (5, 5), 0) return Canny(gray, 75, 200)
def project_object_edge(img, dimension): """ scale the image, binarise with Othu and project to one dimension :param ndarray img: :param int dimension: select dimension for projection :return list(float): >>> img = np.zeros((20, 10, 3)) >>> img[2:6, 1:7, :] = 1 >>> img[10:17, 4:6, :] = 1 >>> project_object_edge(img, 0).tolist() # doctest: +NORMALIZE_WHITESPACE [0.0, 0.0, 0.7, 0.7, 0.7, 0.7, 0.0, 0.0, 0.0, 0.0, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.0, 0.0, 0.0] """ if dimension not in (0, 1): raise ValueError('not supported dimension %i' % dimension) if img.ndim != 3: raise ValueError('unsupported image shape %r' % img.shape) img_gray = np.mean(img, axis=-1) img_gray = GaussianBlur(img_gray, (5, 5), 0) p_low, p_high = np.percentile(img_gray, (1, 95)) img_gray = rescale_intensity(img_gray, in_range=(p_low, p_high)) img_bin = img_gray > threshold_otsu(img_gray) img_edge = np.mean(img_bin, axis=1 - dimension) return img_edge
def gaussianBlur(originalImage, space): from cv2 import GaussianBlur from random import randint min_blur = int(space['blur_extent_min']) max_blur = min_blur + int(space['blur_extent_distance']) amountToBlur = randint(min_blur, max_blur) if amountToBlur % 2 == 0: amountToBlur += 1 return GaussianBlur(originalImage, (int(amountToBlur), int(amountToBlur)),0)
def field_flattening(image, filter_type="gaussian", ksize=31, sigma=101): """ Function that will field flatten a single channel image """ if filter_type == "gaussian": blurred_image = GaussianBlur(image.astype(np.uint8), ksize=(ksize, ksize), sigmaX=sigma) if filter_type == "median": blurred_image = medianBlur(image.astype(np.uint8), ksize=ksize) flat_image = np.divide(image.astype(float), blurred_image.astype(float)) flat_image[np.isnan(flat_image)] = 0 flat_image = (min_max_rescaling(flat_image)) * 255 return flat_image
def generateBaseImage(image, sigma, assumed_blur): """ 通过对原图像的两个方向的向上采样并模糊,来生成basic image. """ logger.info('Generating base image...') image = resize(image, (0, 0), fx=2, fy=2, interpolation=INTER_LINEAR) sigma_diff = sqrt(max((sigma ** 2) - ((2 * assumed_blur) ** 2), 0.01)) return GaussianBlur(image, (0, 0), sigmaX=sigma_diff, sigmaY=sigma_diff)
def toCanny(bw, gaussian): if gaussian == 0: canny = Canny(bw, 200, 230, 3) return canny else: img1 = GaussianBlur(bw, (gaussian, gaussian), 0) cannyGaus = Canny(img1, 10, 30, 453) return cannyGaus
def detect(image): """Detect marker from the camera image""" markers = [] # Stage 1: Detect edges in image gray = cvtColor(image, COLOR_BGR2GRAY) clahe = createCLAHE(clipLimit=1, tileGridSize=(6, 6)) cl1 = clahe.apply(gray) _, thresh = threshold(cl1, 60, 255, THRESH_OTSU) blurred = GaussianBlur(thresh, (5, 5), 0) edges = Canny(blurred, 75, 100) # Stage 2: Find contours contours = findContours(edges, RETR_TREE, CHAIN_APPROX_SIMPLE) contours = sorted(contours, key=contourArea, reverse=True)[:] for contour in contours: # Stage 3: Shape check perimeter = arcLength(contour, True) approx = approxPolyDP(contour, 0.01 * perimeter, True) if len(approx) == QUADRILATERAL_POINTS: area = contourArea(approx) # (x, y, w, h) = boundingRect(approx) # ar = float(h) / float(w) # if area > 100 and ar >= 0.8 and ar <= 1.2: if area > 700: # putText(image, str(area), (10, 30), FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2) drawContours(image, [contour], -1, (0, 255, 0), 1) # Stage 4: Perspective warping topdown_quad = get_topdown_quad(thresh, approx.reshape(4, 2)) # Stage 5: Border check if topdown_quad[int((topdown_quad.shape[0] / 100.0) * 5), int((topdown_quad.shape[1] / 100.0) * 5)] > BLACK_THRESHOLD: continue # Stage 6: Get marker pattern marker_pattern = None try: marker_pattern = get_marker_pattern( topdown_quad, THRESHOLD_PERCENT) except: continue if not marker_pattern: continue # Stage 7: Match marker pattern marker_found, marker_rotation, marker_name = match_marker_pattern( marker_pattern) if marker_found: markers.append([marker_name, marker_rotation]) return markers, image
def get_gradient_x(self): print 'creating sobel features' self.x_train = self.x_train.astype(np.double) x_train = [sobel_features(GaussianBlur(x.reshape((32,32)), ksize=(5,5), \ sigmaX=1), magnitude, direction, sx, sy, x2) \ for x in self.x_train] print 'got features' return x_train
def __init__(self, image, g_h, g_w, tr): _, self.image = threshold( GaussianBlur( cvtColor(image, COLOR_BGR2GRAY), (g_w, g_h), 0 ), tr, 255, THRESH_BINARY )
def get(): valid, frame = mov.read() if not valid: return (False, None) frame = frame.astype(np.float32) frame = cvtColor(frame, CV_RGB2GRAY) if blur: frame = GaussianBlur(frame, (self.kernel, self.kernel), 0) return valid, frame
def Blur(ImageArray, Distort): """ Param: ImageArray: Get an Image array or list Distort: This set the distortion amount in image Return: Returns a blurred image array """ return GaussianBlur(ImageArray, (Distort, Distort), 0)
def preprocess(imgOriginal, PreprocessCvcSel, PreprocessMode, PreprocessGaussKernel, PreprocessThreshBlockSize, PreprocessThreshweight, PreprocessMorphKernel, PreprocessMedianBlurKernel, PreprocessCannyThr): """ CSC, Contrast stretch (morph.), Blurring and Adaptive-Threshold """ # Color-Space-Conversion (CSC): switch from BGR to HSV and take the requested component: imgHSV = cvtColor(imgOriginal, COLOR_BGR2HSV) imgHSV_H, imgHSV_S, imgHSV_V = split(imgHSV) if PreprocessCvcSel == "H": imgGrayscale = imgHSV_H elif PreprocessCvcSel == "S": imgGrayscale = imgHSV_S elif PreprocessCvcSel == "V": imgGrayscale = imgHSV_V else: error("Unsupported PreprocessCvcSel mode: %s" % PreprocessCvcSel) # -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. if PreprocessMode == "Legacy": # Increase Contrast (morphological): imgMaxContrastGrayscale = maximizeContrast(imgGrayscale, PreprocessMorphKernel) # Blurring: imgBlurred = GaussianBlur(imgMaxContrastGrayscale, PreprocessGaussKernel, 0) # Adaptive Threshold: imgThresh = adaptiveThreshold(imgBlurred, 255.0, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY_INV, PreprocessThreshBlockSize, PreprocessThreshweight) # -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. elif PreprocessMode == "BlurAndCanny": # Blurring: imgBlurred = medianBlur(imgGrayscale, PreprocessMedianBlurKernel) # Canny Edge Detection: imgThresh = Canny(imgBlurred, PreprocessCannyThr / 2, PreprocessCannyThr) # -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. -- .. else: error("Unsupported PreprocessMode mode: %s" % PreprocessMode) imgGrayscale = imgBlurred return imgGrayscale, imgThresh
def generar_Imagen_Base(imagen, sigma, assumed_blur): """Genere una imagen base a partir de la imagen de entrada submuestreando en 2 en ambas direcciones y difuminando """ logger.debug('Generando imagen base...') imagen = resize(imagen, (0, 0), fx=2, fy=2, interpolation=INTER_LINEAR) sigma_diff = sqrt(max((sigma ** 2) - ((2 * assumed_blur) ** 2), 0.01)) #el desenfoque de la imagen ahora es sigma en lugar del assumed_blur return GaussianBlur(imagen, (0, 0), sigmaX=sigma_diff, sigmaY=sigma_diff)
def computeFirstImg(self): img_upsampled = resize(self.img, (0, 0), fx=2, fy=2, interpolation=INTER_LINEAR) delta_sigma = np.sqrt(self.sigma**2 - (2 * self.assumed_blur)**2) self.first_img = GaussianBlur(img_upsampled, (0, 0), sigmaX=delta_sigma, sigmaY=delta_sigma)
def __call__(self, sample): im_arr = np.array(sample) im_arr = self.gaussian.augment_image(im_arr) im_arr = self.poisson.augment_image(im_arr) im_arr = GaussianBlur(im_arr, (3, 3), 0.0) im_arr = fastNlMeansDenoisingColored(im_arr, None, 6, 6, 4, 12) image = Image.fromarray(im_arr) return image
def sharpen(src): src = asarray(src) w, h = get_size(src) # w, h = pychron.size() # im = new_dst(w, h) # kern = CreateMat(3, 3, pychron.type) # print type(kern), type(pychron) im = GaussianBlur(src, (3, 3), 3) addWeighted(src, 1.5, im, -0.5, 0, im) return im
def imagePreProcessing(img_url): urllib.request.urlretrieve(img_url, "api/image.jpg") img = imread('api/image.jpg') img = GaussianBlur(img, (5, 5), 0) gray = cvtColor(img, COLOR_BGR2GRAY) kernel1 = getStructuringElement(MORPH_ELLIPSE, (11, 11)) close = morphologyEx(gray, MORPH_CLOSE, kernel1) div = float32(gray) / (close) # freeResources() return uint8(normalize(div, div, 0, 255, NORM_MINMAX))
def ToEdgeByAccuratey(img, rati=3, canny=(50, 100), deg=5): grayImg = cvtColor(img, cv2.COLOR_BGR2GRAY) gauImg = GaussianBlur(grayImg, (rati,rati), 3) cannyImg = Canny(gauImg, canny[0], canny[1]) kernel = np.ones((deg,deg), np.uint8) # openingImg = cv2.morphologyEx(cannyImg, cv2.MORPH_OPEN, kernel) dilateImg = dilate(cannyImg, kernel, iterations =1) ret, thr = threshold(dilateImg, 127, 255, 0) return thr