def process(img1, img2, outfile): data1 = rasterio.open(img1) lons1, lats1 = utils.get_bounds(data1) data2 = rasterio.open(img2) lons2, lats2 = utils.get_bounds(data2) lons, lats = utils.get_overlap(lons1, lats1, lons2, lats2) if not lons or not lats: raise Exception(f'ERR no overlap: {lons1} {lats1} {lons2} {lats2}') crop1 = utils.crop_data(data1, lons, lats) crop2 = utils.crop_data(data2, lons, lats) new1, new2 = utils.scale_img(crop1, crop2) res = abs(int(new1.shape[0] / crop1.shape[0]) * data1.res[0]) s = get_ssim(new1, new2) print(f'{img1}, {img2}, ssim, {s:.06f}') norm1, norm2 = get_norm(new1), get_norm(new2) p = get_psnr(norm1, norm2) print(f'{img1}, {img2}, pnsr, {p:.06f}') transform = Affine.translation(lons[0], lats[0]) transform *= Affine.scale(res) utils.write_tiff(outfile, norm1 * norm2, transform, nodata=data1.nodata)
def plot_feature_distribution( sample_features, ax=None, t_sne=True, hue=None, hue_order=None, style=None, style_order=None, x_lim='min_max', y_lim='min_max', contour=False, z_generator=None): if ax is None: raise AttributeError('you must specify an ax') sample_features = np.array(sample_features) assert sample_features.ndim == 2 assert x_lim in ['min_max', 'min_max_extend', 'box'] or len(x_lim) == 2 assert y_lim in ['min_max', 'min_max_extend', 'box'] or len(y_lim) == 2 ndim = sample_features.shape[1] if ndim != 2 and not t_sne: raise AttributeError('must use t_sne to preprocess features whose ndim is not 2') if ndim == 1: sample_features = np.concatenate([sample_features, np.zeros_like(sample_features)], 1) ndim = 2 if t_sne and ndim != 2: sample_features = TSNE(n_components=2, init='pca', random_state=1, n_jobs=4, method='exact')\ .fit_transform(sample_features) lower_bound_x, upper_bound_x = x_lim if len(x_lim) == 2 else \ get_bounds(sample_features[:, 0], x_lim, extend_factor=0.2) lower_bound_y, upper_bound_y = y_lim if len(y_lim) == 2 else \ get_bounds(sample_features[:, 1], y_lim, extend_factor=0.1) if contour: plot_contour([lower_bound_x, upper_bound_x], [lower_bound_y, upper_bound_y], z_generator, ax=ax) sns.scatterplot(x=sample_features[:, 0], y=sample_features[:, 1], hue=hue, hue_order=hue_order, style=style, style_order=style_order, ax=ax) ax.legend(loc="best") ax.set_xlim(lower_bound_x, upper_bound_x) ax.set_ylim(lower_bound_y, upper_bound_y)
def _createFeatures(self, points): features_list = [] bounds = utils.get_bounds(points) min_x = bounds.left avg_y = np.average(np.sum(points, 1)) vectors = utils.get_vectors_from_points( points, normalize_vectors=False) #Будет len(points)-1 векторов normalized_vectors = normalize(vectors) for i in range(len(points) - 1): #Посчитать относительные координаты pt = points[i] rel_x = pt[0] - min_x #x Относительно начала rel_y = pt[1] - avg_y #y относительно среднего x_dir = normalized_vectors[i][0] #Направление по x y_dir = normalized_vectors[i][1] #Направление по y length = np.linalg.norm(vectors[i]) #Длина вектора features_list.append((rel_x, rel_y, x_dir, y_dir, length)) return features_list
def search(heightmap, row, col): row_bounds, col_bounds = get_bounds(heightmap) basin = list() basin.append((row, col)) frontier = list() frontier.append((row, col)) while len(frontier) > 0: r, c = frontier.pop() neighbor_indices = [(r - 1, c), (r, c - 1), (r, c + 1), (r + 1, c)] for r_i, c_i in neighbor_indices: if (r_i in row_bounds and c_i in col_bounds and heightmap.data[r_i, c_i] != 9 and (r_i, c_i) not in basin): basin.append((r_i, c_i)) frontier.append((r_i, c_i)) return basin
def draw_strokes(data, svg_filename, factor=0.2, padding=50, make_png=True): """ little function that displays vector images and saves them to .svg :param data: :param factor: :param svg_filename: :return: """ min_x, max_x, min_y, max_y = utils.get_bounds(data, factor) dims = (padding + max_x - min_x, padding + max_y - min_y) dwg = svgwrite.Drawing(svg_filename, size=dims) dwg.add(dwg.rect(insert=(0, 0), size=dims, fill='white')) lift_pen = 1 abs_x = int(padding / 2) - min_x abs_y = int(padding / 2) - min_y p = "M%s, %s " % (abs_x, abs_y) # use lowcase for relative position command = "m" for i in range(len(data)): if lift_pen == 1: command = "m" elif command != "l": command = "l" else: command = "" x = float(data[i, 0]) / factor y = float(data[i, 1]) / factor lift_pen = data[i, 2] p += command + str(x) + ", " + str(y) + " " the_color = "black" stroke_width = 1 dwg.add(dwg.path(p).stroke(the_color, stroke_width).fill("none")) dwg.save() if make_png: png_filename = svg_filename[:-4] + '.png' svg2png(bytestring=dwg.tostring(), write_to=png_filename) return dims, dwg.tostring()
def bounds(self): return get_bounds(self.x, self.y, self.radius)
def bounds(self): return get_bounds(*self.__center, self.__radius)
def main(): # Obtain input arguments parser = argparse.ArgumentParser(description='Process inputs to sampler') parser.add_argument('input_file', default=None, type=str) parser.add_argument('output_file', default="output.txt", type=str) parser.add_argument('N', default=1000, type=int) parser.add_argument('--plot_bool', action="store_true") # Parse input arguments args = parser.parse_args() input_file = args.input_file output_file = args.output_file N = args.N plot_bool = args.plot_bool np.random.seed(0) # Load file and the corresponding constraint functions and valid example if not path.isfile(input_file) and input_file: raise ValueError('Input file does not exist') elif input_file: constraint = Constraint(input_file) x0 = np.array(constraint.get_example()) constraints = constraint.eval_constraints constraint_bool = constraint.apply constraint_bools = constraint.apply_list else: # Used for local testing constraints = func_constraints constraint_bool = func_constraints_bool x0 = x0 # Obtain bounds of input space from which initial sample guesses will # be uniformly drawn bounds = get_bounds(x0, constraint_bools) # Find valid uniformly distributed samples with constrained SMC N_star = int(N * 1.1) run = RunSMC(N=N_star, bounds=bounds, type="constrained_smc", tau_T=1e7, constraints=constraints) x, x0 = run.get_x(), run.get_x0() # Evaluate validity. uniqueness, and spread of results # Subsample result acc, x_valid = get_accuracy(x, constraint_bool) idx_x, idx_x_valid = np.arange(x.shape[0]), np.arange(x_valid.shape[0]) x = x_valid[np.random.choice(idx_x_valid, N, replace=False)] if x_valid.shape[0] >= N else \ x[np.random.choice(idx_x, N, replace=False)] std = np.std(x, axis=0) uniq_nums = np.unique(x, axis=0).shape[0] print('accuracy: {acc} std: {std} unique candidates: {uniq}'.format( acc=acc, std=std, uniq=uniq_nums)) # Save output and plot if 2D and plot_bool np.savetxt(output_file, x, delimiter=' ') if x.shape[1] == 2 and plot_bool: plt.plot(x0[:, 0], x0[:, 1], 'o', x[:, 0], x[:, 1], '*') plt.show()
def dream_image(image, settings, out_name): print("Processing...") ####Global settings for every renderer img = image orig_img = image #maybe clean up #Iterations and octaves iterations = settings['iterations'] octave_n = settings['octaves'] octave_scale = settings['octave_scale'] iteration_descent = settings['iteration_descent'] #Additional Settings save_gradient = settings['save_gradient'] background_color = settings['background'] #tf.random.set_seed(settings.tf_seed)#not working? #Renderers renderers = settings['renderers'] ###Set layers and channels t_obs = [] for r in renderers: t_obs.append( set_layer(r['layer'], r['squared'], r['f_channel'], r['l_channel'])) ##Create background g_sum = np.zeros_like(img) # split the image into a number of octaves octaves = [] g_sums = [] #Prepare Image & backgrounds for every octave for i in range(octave_n - 1): hw = img.shape[:2] lo = resize(img, np.int32(np.float32(hw) / octave_scale)) hi = img - resize(lo, hw) img = lo octaves.append(hi) lo = resize(g_sum, np.int32(np.float32(hw) / octave_scale)) hi = g_sum - resize(lo, hw) g_sum = lo g_sums.append(hi) # generate details octave by octave for octave in range(octave_n): ##Prepare current Octave if octave > 0: hi = octaves[-octave] img = resize(img, hi.shape[:2]) + hi hi_g = g_sums[-octave] g_sum = resize(g_sum, hi.shape[:2]) + hi_g ##More Preperations bounds = utils.get_bounds(img.shape[1], img.shape[0], renderers) iteration_masks = [] for r in renderers: if r['masked']: iteration_masks.append(resize(r['mask'], img.shape[:2]) / 255) #move up, /255 just once else: iteration_masks.append([]) orig_img_m = resize(image, img.shape[:2]) / 255 #move up, /255 just once ####Iterations for iteration in range(iterations - octave * iteration_descent): print("Iteration " + str(iteration + 1) + " / " + str(iterations - octave * iteration_descent) + " Octave: " + str(octave + 1) + " / " + str(octave_n)) ####Gradient gradients = [] for i in range(len(renderers)): if (iteration + 1) % renderers[i]['render_x_iteration'] == 0: start_time = time.time() ##Pre Gradient preperations #Crop the image t_img = img[bounds[i][2]:bounds[i][3], bounds[i][0]:bounds[i][1]] #Rotate if true if renderers[i]['rotate']: t_img = np.rot90(t_img, renderers[i]['rotation']) ##Get the gradient g = calc_grad_tiled(t_img, t_obs[i], tile_size=renderers[i]['tile_size']) g = g * (renderers[i]['step_size'] / (np.abs(g).mean() + 1e-7)) ## ##Gradient manipulations: ## #Rotate back if necessary if renderers[i]['rotate']: g = np.rot90(g, 4 - renderers[i]['rotation']) #Masking the gradient if renderers[i]['masked']: g *= iteration_masks[i][bounds[i][2]:bounds[i][3], bounds[i][0]:bounds[i][1]] #Color Correction if renderers[i]['color_correction']: g = utils.gradient_grading( g, orig_img_m[bounds[i][2]:bounds[i][3], bounds[i][0]:bounds[i][1]], method=renderers[i]['cc_vars'][0], fr=renderers[i]['cc_vars'][1], fg=renderers[i]['cc_vars'][2], fb=renderers[i]['cc_vars'][3]) ##Adding the finalized Gradient to list gradients.append(g) print('Finished computing Gradient for Renderer {} in {}s'. format(i, time.time() - start_time)) else: gradients.append(np.zeros_like(img)) for i in range(len(bounds)): img[bounds[i][2]:bounds[i][3], bounds[i][0]:bounds[i][1]] += gradients[i] g_sum[bounds[i][2]:bounds[i][3], bounds[i][0]:bounds[i][1]] += gradients[i] ####Save Image if settings['color_correction']: img = image + utils.gradient_grading(g_sum, image / 255, method=settings['cc_vars'][0], fr=settings['cc_vars'][1], fg=settings['cc_vars'][2], fb=settings['cc_vars'][3]) g_sum[:, :] += background_color utils.save_image(img, out_name) if save_gradient: utils.save_image(g_sum, 'gradient_' + out_name)