我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.dstack()。
def showAnns(self, anns): """ Display the specified annotations. :param anns (array of object): annotations to display :return: None """ if len(anns) == 0: return 0 if self.dataset['type'] == 'instances': ax = plt.gca() polygons = [] color = [] for ann in anns: c = np.random.random((1, 3)).tolist()[0] if type(ann['segmentation']) == list: # polygon for seg in ann['segmentation']: poly = np.array(seg).reshape((len(seg)/2, 2)) polygons.append(Polygon(poly, True,alpha=0.4)) color.append(c) else: # mask mask = COCO.decodeMask(ann['segmentation']) img = np.ones( (mask.shape[0], mask.shape[1], 3) ) if ann['iscrowd'] == 1: color_mask = np.array([2.0,166.0,101.0])/255 if ann['iscrowd'] == 0: color_mask = np.random.random((1, 3)).tolist()[0] for i in range(3): img[:,:,i] = color_mask[i] ax.imshow(np.dstack( (img, mask*0.5) )) p = PatchCollection(polygons, facecolors=color, edgecolors=(0,0,0,1), linewidths=3, alpha=0.4) ax.add_collection(p) if self.dataset['type'] == 'captions': for ann in anns: print ann['caption']
def compute_eng_color(img, rgb_weights): """ Computes the energy of an image using its color properties Args: img4 (n,m,4 numpy matrix): RGB image with additional mask layer. rgb_weights (n,m numpy matrix): img-specific weights for RBG values Returns: n,m numpy matrix: Color energy map of the provided image """ eng = np.dstack(( img[:, :, 0] * rgb_weights[0], img[:, :, 1] * rgb_weights[1], img[:, :, 2] * rgb_weights[2] )) eng = np.sum(eng, axis=2) return eng
def read_naip(file_path, bands_to_use): """ Read in a NAIP, based on www.machinalis.com/blog/python-for-geospatial-data-processing. Bands_to_use is an array like [0,0,0,1], designating whether to use each band (R, G, B, IR). """ raster_dataset = gdal.Open(file_path, gdal.GA_ReadOnly) bands_data = [] index = 0 for b in range(1, raster_dataset.RasterCount + 1): band = raster_dataset.GetRasterBand(b) if bands_to_use[index] == 1: bands_data.append(band.ReadAsArray()) index += 1 bands_data = numpy.dstack(bands_data) return raster_dataset, bands_data
def renderRelighting(renderer, albedo, spec, roughness, normal): renderer.SetPointLight(0, 0.27, -0.25, 1, 0, 0.6, 0.6, 0.6) renderer.SetAlbedoMap(albedo) renderer.SetSpecValue(spec) renderer.SetRoughnessValue(roughness) normal = normal * 2.0 - 1.0 normal[0] = normal[0] * 2.5 len = np.linalg.norm(normal, axis = 2) normal = normal / np.dstack((len, len, len)) normal = 0.5*(normal + 1.0) renderer.SetNormalMap(normal*2.0 - 1.0) img = renderer.Render() renderer.SetEnvLightByID(43, 30, -10.0) renderer.SetAlbedoMap(albedo) renderer.SetSpecValue(spec) renderer.SetRoughnessValue(roughness) renderer.SetNormalMap(normal*2.0 - 1.0) img_1 = renderer.Render() return 1.2 * img + 0.8 * img_1
def new_image(self, image, diag=False): if isinstance(image, str): self.image_file = image self.image = np.array(PIL.Image.open(image)) else: self.image_file = None self.image = image # Get the image into the right format. if self.image.dtype != np.uint8: raise TypeError('Image %s dtype is not unsigned 8 bit integer, image.dtype is %s.'%( '"%s"'%self.image_file if self.image_file is not None else 'argument', self.image.dtype)) self.image = np.squeeze(self.image) if len(self.image.shape) == 2: self.image = np.dstack([self.image] * 3) self.preprocess_edges() self.randomize_view() if diag: plt.figure('Image') plt.title('Image') plt.imshow(self.image, interpolation='nearest') plt.show()
def _fix_alpha_channel(self): # This is a fix for a bug where the Alpha channel was dropped. colors3to4 = [(c[:3], c[3]) for c in self.names.keys()] colors3to4 = dict(colors3to4) assert(len(colors3to4) == len(self.names)) # Dropped alpha channel causes colors to collide :( for lbl in self.labels: if lbl is None: continue # No label file created yet. img = Image.open(lbl) size = img.size img = np.array(img) if img.shape[2] == 4: continue # Image has alpha channel, good. elif img.shape[2] == 3: # Lookup each (partial) color and find what its alpha should be. alpha = np.apply_along_axis(lambda c: colors3to4[tuple(c)], 2, img) data = np.dstack([img, np.array(alpha, dtype=np.uint8)]) new_img = Image.frombuffer("RGBA", size, data, "raw", "RGBA", 0, 1) new_img.save(lbl) print("FIXED", lbl)
def plot_img_with_mask(img,mask,mask2=None, line_size=2): kernel = np.ones((line_size,line_size),dtype=np.uint8) if np.max(img)<=1.0: img = np.array(img*255,dtype=np.uint8); mask = np.array(mask*255, dtype=np.uint8); color_img = np.dstack((img,img,img)); edges = binary_dilation(canny(mask,sigma=1.0),kernel); color_img[edges,0] = 255; color_img[edges,1] = 0; color_img[edges,2] = 0; if mask2 is not None: mask2 = np.array(mask2*255,dtype=np.uint8); edges2 = binary_dilation(canny(mask2,sigma=1.0),kernel); color_img[edges2,2] = 255; color_img[edges2,0:2] = 0; plt.imshow(color_img)
def plot_cost_to_go_mountain_car(env, estimator, num_tiles=20): x = np.linspace(env.observation_space.low[0], env.observation_space.high[0], num=num_tiles) y = np.linspace(env.observation_space.low[1], env.observation_space.high[1], num=num_tiles) X, Y = np.meshgrid(x, y) Z = np.apply_along_axis(lambda _: -np.max(estimator.predict(_)), 2, np.dstack([X, Y])) fig = plt.figure(figsize=(10, 5)) ax = fig.add_subplot(111, projection='3d') surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=matplotlib.cm.coolwarm, vmin=-1.0, vmax=1.0) ax.set_xlabel('Position') ax.set_ylabel('Velocity') ax.set_zlabel('Value') ax.set_title("Mountain \"Cost To Go\" Function") fig.colorbar(surf) plt.show()
def test_encode_data_roundtrip(): minrand, maxrand = np.sort(np.random.randint(-427, 8848, 2)) testdata = np.round((np.sum( np.dstack( np.indices((512, 512), dtype=np.float64)), axis=2) / (511. + 511.)) * maxrand, 2) + minrand baseval = -1000 interval = 0.1 rtripped = _decode(data_to_rgb(testdata.copy(), baseval, interval), baseval, interval) assert testdata.min() == rtripped.min() assert testdata.max() == rtripped.max()
def process_one(image_dir, page_dir, output_dir, basename, colormap, color_labels): image_filename = os.path.join(image_dir, "{}.jpg".format(basename)) page_filename = os.path.join(page_dir, "{}.xml".format(basename)) page = PAGE.parse_file(page_filename) text_lines = [tl for tr in page.text_regions for tl in tr.text_lines] graphic_regions = page.graphic_regions img = imread(image_filename, mode='RGB') gt = np.zeros_like(img[:, :, 0]) mask1 = cv2.fillPoly(gt.copy(), [PAGE.Point.list_to_cv2poly(tl.coords) for tl in text_lines if 'comment' in tl.id], 1) mask2 = cv2.fillPoly(gt.copy(), [PAGE.Point.list_to_cv2poly(tl.coords) for tl in text_lines if not 'comment' in tl.id], 1) mask3 = cv2.fillPoly(gt.copy(), [PAGE.Point.list_to_cv2poly(tl.coords) for tl in graphic_regions], 1) arr = np.dstack([mask1, mask2, mask3]) gt_img = convert_array_masks(arr, colormap, color_labels) save_and_resize(img, os.path.join(output_dir, 'images', '{}.jpg'.format(basename))) save_and_resize(gt_img, os.path.join(output_dir, 'labels', '{}.png'.format(basename)), nearest=True)
def __init__(self, m): k = 4*m + 3 self.degree = k theta = 2*numpy.pi * numpy.arange(1, k+2) / (k+1) p, w = numpy.polynomial.legendre.leggauss(m+1) # scale points to [r0, r1] (where r0 = 0, r1 = 1 for now) p = numpy.sqrt(0.5*(p + 1.0)) p_theta = numpy.dstack(numpy.meshgrid(p, theta)).reshape(-1, 2).T self.points = numpy.column_stack([ p_theta[0] * numpy.cos(p_theta[1]), p_theta[0] * numpy.sin(p_theta[1]), ]) # When integrating between 0 and 1, the weights are exactly the # Gauss-Legendre weights, scaled according to the disk area. self.weights = numpy.tile(0.5 * numpy.pi / (k+1) * w, k+1) return
def _process(self, img, key=None): if self.p.fast: return self._fast_process(img, key) proj = self.p.projection if proj == img.crs: return img x0, x1 = img.range(0) y0, y1 = img.range(1) xn, yn = img.interface.shape(img, gridded=True)[:2] px0, py0, px1, py1 = project_extents((x0, y0, x1, y1), img.crs, proj) src_ext, trgt_ext = (x0, x1, y0, y1), (px0, px1, py0, py1) arrays = [] for vd in img.vdims: arr = img.dimension_values(vd, flat=False) projected, extents = warp_array(arr, proj, img.crs, (xn, yn), src_ext, trgt_ext) arrays.append(projected) projected = np.dstack(arrays) if len(arrays) > 1 else arrays[0] data = np.flipud(projected) bounds = (extents[0], extents[2], extents[1], extents[3]) return img.clone(data, bounds=bounds, kdims=img.kdims, vdims=img.vdims, crs=proj)
def geo_mesh(element): """ Get mesh data from a 2D Element ensuring that if the data is on a cylindrical coordinate system and wraps globally that data actually wraps around. """ if len(element.vdims) > 1: xs, ys = (element.dimension_values(i, False, False) for i in range(2)) zs = np.dstack([element.dimension_values(i, False, False) for i in range(2, 2+len(element.vdims))]) else: xs, ys, zs = (element.dimension_values(i, False, False) for i in range(3)) lon0, lon1 = element.range(0) if isinstance(element.crs, ccrs._CylindricalProjection) and (lon1 - lon0) == 360: xs = np.append(xs, xs[0:1] + 360, axis=0) zs = np.ma.concatenate([zs, zs[:, 0:1]], axis=1) return xs, ys, zs
def test_concat(make_data): """Test concatenation layer.""" x, _, X = make_data # This replicates the input layer behaviour f = ab.InputLayer('X', n_samples=3) g = ab.InputLayer('Y', n_samples=3) catlayer = ab.Concat(f, g) F, KL = catlayer(X=x, Y=x) tc = tf.test.TestCase() with tc.test_session(): forked = F.eval() orig = X.eval() assert forked.shape == orig.shape[0:2] + (2 * orig.shape[2],) assert np.all(forked == np.dstack((orig, orig))) assert KL.eval() == 0.0
def test_100_inputs(self): """Test that 100 input rings work""" def dstack_handler(*args): """Stack all input arrays""" return np.dstack(tuple(args)) number_inputs = 100 connections = {'in_1': 0, 'out_1': 1} for index in range(number_inputs): self.blocks.append([ NumpyBlock(function=np.copy), {'in_1': 0, 'out_1': index + 2}]) connections['in_' + str(index + 2)] = index + 2 self.blocks.append([ NumpyBlock(function=dstack_handler, inputs=len(connections) - 1), connections]) self.expected_result = np.dstack((self.test_array,) * (len(connections) - 1)).ravel()
def find_intersections(A,B): arrayMinimum = lambda x1, x2: np.where(x1<x2, x1, x2) arrayMaximum = lambda x1, x2: np.where(x1>x2, x1, x2) arrayAll = lambda abools: np.dstack(abools).all(axis=2) slope = lambda line: (lambda d: d[:,1]/d[:,0])(np.diff(line, axis=0)) x11, x21 = np.meshgrid(A[:-1, 0], B[:-1, 0]) x12, x22 = np.meshgrid(A[1:, 0], B[1:, 0]) y11, y21 = np.meshgrid(A[:-1, 1], B[:-1, 1]) y12, y22 = np.meshgrid(A[1:, 1], B[1:, 1]) m1, m2 = np.meshgrid(slope(A), slope(B)) # Here we use masked arrays to properly treat the rare case where a line segment is perfectly vertical _m1 = np.ma.masked_array(m1,m1==-np.inf) _m2 = np.ma.masked_array(m2,m2==-np.inf) yi = (_m1*(x21-x11-y21/_m2)+y11)/(1-_m1/_m2) xi = (yi-y21)/_m2+x21 xconds = (arrayMinimum(x11, x12) < xi, xi <= arrayMaximum(x11, x12), arrayMinimum(x21, x22) < xi, xi <= arrayMaximum(x21, x22) ) yconds = (arrayMinimum(y11, y12) < yi, yi <= arrayMaximum(y11, y12), arrayMinimum(y21, y22) < yi, yi <= arrayMaximum(y21, y22) ) return xi[arrayAll(xconds)], yi[arrayAll(yconds)]
def test_iou(): # 3 x 5 x 2 grid = np.dstack(np.meshgrid(10 * np.arange(5), 10 * np.arange(3))) boxes = np.tile( np.expand_dims(np.expand_dims(np.array([10, 10]), 0), 0), [3, 5, 1] ) proposals = np.reshape(np.concatenate([grid, boxes], axis=2), (-1, 4)) proposals = tf.constant(proposals, tf.float32) ground_truth = tf.constant(np.array([ [4, 4, 10, 10], [10, 10, 10, 10] ]), tf.float32) iou_metric = sess.run(model.iou(ground_truth, 2, proposals, 15)) assert equal(iou_metric[0, 0], 0.2195) assert equal(iou_metric[1, 0], 0.1363) assert equal(iou_metric[5, 0], 0.1363) assert equal(iou_metric[6, 0], 0.0869) assert equal(iou_metric[6, 1], 1.0) for (boxes, count) in [(proposals, 15), (ground_truth, 2)]: iou_metric = sess.run(model.iou(boxes, count, boxes, count)) assert np.all(np.diag(iou_metric) == 1)
def _init_random_maze(self): # init goal position goal = np.zeros_like(self._level) while True: row_idx = np.random.randint(0, self._level.shape[0]) col_idx = np.random.randint(0, self._level.shape[1]) if self._level[row_idx, col_idx] == 0: goal[row_idx, col_idx] = 1 self._goal_pos = np.array([row_idx, col_idx]) break # init player position player = np.zeros_like(self._level) while True: row_idx = np.random.randint(0, self._level.shape[0]) col_idx = np.random.randint(0, self._level.shape[1]) if self._level[row_idx, col_idx] == 0 and goal[row_idx, col_idx] == 0: player[row_idx, col_idx] = 1 self._player_pos = np.array([row_idx, col_idx]) break # stack all together in depth (along third axis) self._maze = np.dstack((self._level, goal, player))
def draw_lines(img, lines, color=[255, 0, 0], thickness=2): """ averaging & extrapolating lines points achieved. """ if len(img.shape) == 2: # grayscale image -> make a "color" image out of it img = np.dstack((img, img, img)) for line in lines: for x1, y1, x2, y2 in line: if x1 >= 0 and x1 < img.shape[1] and \ y1 >= 0 and y1 < img.shape[0] and \ x2 >= 0 and x2 < img.shape[1] and \ y2 >= 0 and y2 < img.shape[0]: cv2.line(img, (x1, y1), (x2, y2), color, thickness) else: print('BAD LINE (%d, %d, %d, %d)' % (x1, y1, x2, y2))
def sort_eigensystem(parameters_dict): eigenvectors = np.stack(tensor_spherical_to_cartesian(np.squeeze(parameters_dict['theta']), np.squeeze(parameters_dict['phi']), np.squeeze(parameters_dict['psi'])), axis=0) eigenvalues = np.atleast_2d(np.squeeze(np.dstack([parameters_dict['d'], parameters_dict['dperp0'], parameters_dict['dperp1']]))) ranking = np.atleast_2d(np.squeeze(np.argsort(eigenvalues, axis=1, kind='mergesort')[:, ::-1])) voxels_range = np.arange(ranking.shape[0]) sorted_eigenvalues = np.concatenate([eigenvalues[voxels_range, ranking[:, ind], None] for ind in range(ranking.shape[1])], axis=1) sorted_eigenvectors = np.stack([eigenvectors[ranking[:, ind], voxels_range, :] for ind in range(ranking.shape[1])]) return sorted_eigenvalues, sorted_eigenvectors, ranking
def draw_matches(self, im1, pos1, im2, pos2, matches, filename="matches.jpg"): self._log("drawing matches into '%s'..." % filename) row1, col1 = im1.shape row2, col2 = im2.shape im_out = np.zeros((max(row1, row2), col1+col2, 3), dtype=np.uint8) im_out[:row1, :col1] = np.dstack([im1]*3) im_out[:row2, col1:] = np.dstack([im2]*3) l = len(matches) for ind, (i, j, d) in list(enumerate(matches))[::-1]: d /= para.descr_match_threshold # map to [0, 1] _pos1, _pos2 = pos1[i], pos2[j] color = hsv_to_rgb(int(d * 120 - 120), 1, 1 - d / 3) color = [int(c * 255) for c in color] cv2.line(im_out, (_pos1[1], _pos1[0]), (_pos2[1]+col1, _pos2[0]), color, 1) cv2.imwrite(filename, im_out) ########################## # Utility ##########################
def get_cells_for_tile(self, tile_h, tile_v): """ Returns the list of cells covered by the given modis tile. The tile is identified by its MODIS grid coordinates """ range_x = np.arange(tile_h * self.n_cells_per_tile_x, (tile_h + 1) * self.n_cells_per_tile_x) range_y = np.arange(tile_v * self.n_cells_per_tile_y, (tile_v + 1) * self.n_cells_per_tile_y) cells_ij = np.dstack( np.meshgrid(range_y, range_x, indexing='ij')).reshape(-1, 2) cells = np.ravel_multi_index( (cells_ij[:, 0], cells_ij[:, 1]), (self.n_cells_y, self.n_cells_x) ) # sanity check assert len(cells) == self.n_cells_per_tile_x * self.n_cells_per_tile_y return cells
def test_nonrectangular_add(self): rgba1 = np.ones((64, 1, 4)) z1 = np.expand_dims(np.arange(64.), 1) rgba2 = np.zeros((64, 1, 4)) z2 = np.expand_dims(np.arange(63., -1., -1.), 1) exact_rgba = np.concatenate((np.ones(32), np.zeros(32))) exact_rgba = np.expand_dims(exact_rgba, 1) exact_rgba = np.dstack((exact_rgba, exact_rgba, exact_rgba, exact_rgba)) exact_z = np.concatenate((np.arange(32.), np.arange(31.,-1.,-1.))) exact_z = np.expand_dims(exact_z, 1) buff1 = ZBuffer(rgba1, z1) buff2 = ZBuffer(rgba2, z2) buff = buff1 + buff2 assert_almost_equal(buff.rgba, exact_rgba) assert_almost_equal(buff.z, exact_z)
def log_mat(x, n, g_coeff, c_1, const): with np.errstate(divide='ignore', invalid='ignore'): K = g_coeff.shape[0] - 1 thres = 2 * c_1 * math.log(n) / n [T, X] = np.meshgrid(thres, x) ratio = np.clip(2*X/T - 1, 0, 1) # force MATLAB-esque behavior with NaN, inf ratio[T == 0] = 1.0 ratio[X == 0] = 0.0 q = np.reshape(np.arange(K), [1, 1, K]) g = np.tile(np.reshape(g_coeff, [1, 1, K + 1]), [c_1.shape[1], 1]) g[:, :, 0] = g[:, :, 0] + np.log(thres) MLE = np.log(X) + (1-X) / (2*X*n) MLE[X == 0] = -np.log(n) - const tmp = (n*X[:,:,np.newaxis] - q)/(T[:,:,np.newaxis]*(n - q)) polyApp = np.sum(np.cumprod(np.dstack([np.ones(T.shape + (1,)), tmp]), axis=2) * g, axis=2) polyFail = np.logical_or(np.isnan(polyApp), np.isinf(polyApp)) polyApp[polyFail] = MLE[polyFail] return ratio*MLE + (1-ratio)*polyApp
def getNeighborsSorted(self, id, objType): if id not in self.objectDict: return None distColumn, idColumn = self.kdTrees[objType][1].query(self.get(id).pos, k=self.maxSearch[objType]) indexToID = self.kdTrees[objType][0] for i in range(0, idColumn.size): if distColumn[i] == float('inf'): idColumn = idColumn[:i] distColumn = distColumn[:i] break idColumn[i] = indexToID[idColumn[i]] return np.dstack([idColumn, distColumn])[0]
def MakePaddedSequenceTensorFromListArray( in_arr, pad_value=0., doWhitening=False, maxlen=None, padding = 'pre'): seq_list = numpy.array([]) arr = in_arr if len(in_arr.shape)==1: arr = numpy.array([ in_arr ]) for i in range( arr.shape[1] ): current = convertSequencesFromListArray( arr[:,i], dopad=True, doWhitening=doWhitening, maxlen=maxlen, padding = padding ) if len(seq_list)==0: seq_list = current else: seq_list = numpy.dstack((seq_list, current) ) return seq_list
def MakePaddedSequenceTensor( filename_list, doWhitening=False, maxlen=None): seq_list = numpy.array([]) for fn in filename_list: current = convertSequences( fn, dopad=True, doWhitening= doWhitening, maxlen=maxlen) if len(seq_list)==0: seq_list = current else: seq_list = numpy.dstack((seq_list, current) ) return seq_list ################################################################################################### # maniplation functions ###################################################################################################
def ensurebuf(self, invalidate=True): if self.dbuf is None: if self.dpil is not None: self.dbuf = self.dpil.tostring("raw", "RGBX", 0, 1) elif self.darr is not None: data = self.scaledpixelarray(0,255.999) self.dbuf = np.dstack(( np.flipud(np.rollaxis(data,1)).astype(np.uint8), np.zeros(self.shape[::-1],np.uint8) )).tostring() else: raise ValueError("No source data for conversion to buffer") if invalidate: self.dpil = None self.darr = None self.rangearr = None ## This private function ensures that there is a valid numpy array representation, converting from # one of the other representations if necessary, and invalidating the other representations if requested.
def asarray(self, axis=3): """ This function ... :return: """ # Get a list that contains the frames frame_list = self.frames.as_list() # Stack the frames into a 3D numpy array if axis == 3: return np.dstack(frame_list) elif axis == 2: return np.hstack(frame_list) elif axis == 1: return np.vstack(frame_list) elif axis == 0: return np.stack(frame_list) else: raise ValueError("'axis' parameter should be integer 0-3") # -----------------------------------------------------------------
def flowList(xFileNames, yFileNames): ''' (x/y)fileNames: List of the fileNames in order to get the flows from ''' frameList = [] if (len(xFileNames) != len(yFileNames)): print 'XFILE!=YFILE ERROR: In', xFileNames[0] for i in range(0, min(len(xFileNames), len(yFileNames))): imgX = io.imread(xFileNames[i]) imgY = io.imread(yFileNames[i]) frameList.append(np.dstack((imgX, imgY))) frameList = np.array(frameList) return frameList
def vstack(tup): """Stacks arrays vertically. If an input array has one dimension, then the array is treated as a horizontal vector and stacked along the additional axis at the head. Otherwise, the array is stacked along the first axis. Args: tup (sequence of arrays): Arrays to be stacked. Each array is converted by :func:`cupy.atleast_2d` before stacking. Returns: cupy.ndarray: Stacked array. .. seealso:: :func:`numpy.dstack` """ return concatenate(cupy.atleast_2d(*tup), 0)
def disp_to_flowfile(disp, filename): """ Read KITTI disparity file in png format :param disp: disparity matrix :param filename: the flow file name to save :return: None """ f = open(filename, 'wb') magic = np.array([202021.25], dtype=np.float32) (height, width) = disp.shape[0:2] w = np.array([width], dtype=np.int32) h = np.array([height], dtype=np.int32) empty_map = np.zeros((height, width), dtype=np.float32) data = np.dstack((disp, empty_map)) magic.tofile(f) w.tofile(f) h.tofile(f) data.tofile(f) f.close()
def _gen_centroids(): a = np.arange(SSIZE/18, SSIZE, SSIZE/9) x, y = np.meshgrid(a, a) return np.dstack((y, x)).reshape((81, 2))
def build_data_auto_encoder(data, step, win_size): count = data.shape[1] / float(step) docX = np.zeros((count, 3, win_size)) for i in range(0, data.shape[1] - win_size, step): c = i / step docX[c][0] = np.abs(data[0, i:i + win_size] - data[1, i:i + win_size]) docX[c][1] = np.power(data[0, i:i + win_size] - data[1, i:i + win_size], 2) docX[c][2] = np.pad( (data[0, i:i + win_size - 1] - data[0, i + 1:i + win_size]) * (data[1, i:i + win_size - 1] - data[1, i + 1:i + win_size]), (0, 1), 'constant', constant_values=0) data = np.dstack((docX[:, 0], docX[:, 1], docX[:, 2])).reshape(docX.shape[0], docX.shape[1]*docX.shape[2]) return data
def test_weighted_average(self): """ Test results of weighted average against numpy.average """ stream = [np.random.random(size = (16,16)) for _ in range(5)] with self.subTest('float weights'): weights = [random() for _ in stream] from_iaverage = last(iaverage(stream, weights = weights)) from_numpy = np.average(np.dstack(stream), axis = 2, weights = np.array(weights)) self.assertTrue(np.allclose(from_iaverage, from_numpy)) with self.subTest('array weights'): weights = [np.random.random(size = stream[0].shape) for _ in stream] from_iaverage = last(iaverage(stream, weights = weights)) from_numpy = np.average(np.dstack(stream), axis = 2, weights = np.dstack(weights)) self.assertTrue(np.allclose(from_iaverage, from_numpy))
def test_ignore_nan(self): """ Test that NaNs are handled correctly """ stream = [np.random.random(size = (16,12)) for _ in range(5)] for s in stream: s[randint(0, 15), randint(0,11)] = np.nan with catch_warnings(): simplefilter('ignore') from_iaverage = last(iaverage(stream, ignore_nan = True)) from_numpy = np.nanmean(np.dstack(stream), axis = 2) self.assertTrue(np.allclose(from_iaverage, from_numpy))
def test_avg_no_weights(self): stream = [np.random.random(size = (16,16)) for _ in range(5)] from_caverage = caverage(stream) from_numpy = np.average(np.dstack(stream), axis = 2) self.assertTrue(np.allclose(from_caverage, from_numpy))
def test_weighted_average(self): """ Test results of weighted average against numpy.average """ stream = [np.random.random(size = (16,16)) for _ in range(5)] weights = [np.random.random(size = stream[0].shape) for _ in stream] from_caverage = caverage(stream, weights = weights) from_numpy = np.average(np.dstack(stream), axis = 2, weights = np.dstack(weights)) self.assertTrue(np.allclose(from_caverage, from_numpy))
def test_mean_random(self): """ Test cmean against numpy.mean on random data """ stream = [np.random.random(size = (16,16)) for _ in range(5)] from_cmean = cmean(stream) from_numpy = np.mean(np.dstack(stream), axis = 2) self.assertTrue(np.allclose(from_cmean, from_numpy))
def test_against_numpy(self): """ Test that iprod() returns the same as numpy.prod() for various axis inputs """ stream = [np.random.random((16,16)) for _ in range(10)] stack = np.dstack(stream) for axis in (0, 1, 2, None): with self.subTest('axis = {}'.format(axis)): from_numpy = np.prod(stack, axis = axis) from_stream = last(iprod(stream, axis = axis)) self.assertTrue(np.allclose(from_stream, from_numpy))
def iterate_cifar(shapeInput, batch_size, shuffle=False, train=True): # iterator over patches of the cifar10 data set. files = [] if train: for j in range(1, 6): files.append('data_batch_'+str(j)) else: for j in range(1, 6): files.append('test_batch') data_idxs = np.random.permutation(len(files)) data = [] labels = [] for j in range(len(files)): data_idx = j if shuffle: data_idx = data_idxs[j] file = files[data_idx] dict = unpickle('C:\\Paul\\cifar-10-batches-py\\'+file) ls = dict['labels'] idxs = np.random.permutation(len(dict['data'])) for i in range(len(dict['data'])): if shuffle: idx = idxs[i] else: idx = i stackedArray = np.dstack((dict['data'][idx][0:1024].reshape(32, 32), dict['data'][idx][1024:1024 * 2].reshape(32,32), dict['data'][idx][1024 * 2:1024 * 3].reshape(32, 32))) patches = image.extract_patches_2d(stackedArray, (shapeInput[0], shapeInput[1]), max_patches=1) #max = patches.max()+1.e-6 patches = patches.astype(np.float32) / 256.0 data.append(patches) labels.append(ls[idx]) if len(data)>=batch_size: array = np.asarray(data).reshape(-1, shapeInput[0]*shapeInput[1]*3) data = [] labels = [] #print(len(dict['data'])*len(files)*patches.shape[0]) yield array
def test_lab_full_gamut(self): a, b = np.meshgrid(np.arange(-100, 100), np.arange(-100, 100)) L = np.ones(a.shape) lab = np.dstack((L, a, b)) for value in [0, 10, 20]: lab[:, :, 0] = value with expected_warnings(['Color data out of range']): lab2xyz(lab)
def test_sun_rgbd(): from pybot.vision.image_utils import to_color from pybot.vision.imshow_utils import imshow_cv from pybot.utils.io_utils import write_video from pybot.vision.color_utils import colormap directory = '/media/HD1/data/SUNRGBD/' dataset = SUNRGBDDataset(directory) colors = cv2.imread('data/sun3d/sun.png').astype(np.uint8) for (rgb, depth, label) in dataset.segmentationdb(None): cout = np.dstack([label, label, label]) colored = cv2.LUT(cout, colors) cdepth = colormap(depth / 64000.0) for j in range(5): write_video('xtion.avi', np.hstack([rgb, cdepth, colored])) # for f in dataset.iteritems(every_k_frames=5): # # vis = rgbd_data_uw.annotate(f) # imshow_cv('frame', f.img, text='Image') # imshow_cv('depth', (f.depth / 16).astype(np.uint8), text='Depth') # imshow_cv('instance', (f.instance).astype(np.uint8), text='Instance') # imshow_cv('label', (f.label).astype(np.uint8), text='Label') # cv2.waitKey(100) return dataset
def valid_pixels(im, valid): """ Determine valid pixel (x,y) coords for the image """ if valid.dtype != np.bool: raise ValueError('valid_pixels requires boolean image') assert(im.shape == valid.shape) H,W = valid.shape[:2] xs, ys = np.meshgrid(np.arange(W), np.arange(H)) return np.dstack([xs[valid], ys[valid], im[valid]]).reshape(-1,3)
def reconstruct(self, depth): s = self.skip depth_sampled = depth[::s,::s] assert(depth_sampled.shape == self.xs.shape) return np.dstack([self.xs * depth_sampled, self.ys * depth_sampled, depth_sampled])
def dense_optical_flow(im1, im2, pyr_scale=0.5, levels=3, winsize=5, iterations=3, poly_n=5, poly_sigma=1.2, fb_threshold=-1, mask1=None, mask2=None, flow1=None, flow2=None): if flow1 is None: fflow = cv2.calcOpticalFlowFarneback(to_gray(im1), to_gray(im2), pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, 0) else: fflow = cv2.calcOpticalFlowFarneback(to_gray(im1), to_gray(im2), pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, 0, flow1.copy()) if mask1 is not None: fflow[~mask1.astype(np.bool)] = np.nan if fb_threshold > 0: H, W = im1.shape[:2] xs, ys = np.meshgrid(np.arange(W), np.arange(H)) xys1 = np.dstack([xs, ys]) xys2 = xys1 + fflow rflow = dense_optical_flow(im2, im1, pyr_scale=pyr_scale, levels=levels, winsize=winsize, iterations=iterations, poly_n=poly_n, poly_sigma=poly_sigma, fb_threshold=-1) if mask2 is not None: rflow[~mask2.astype(np.bool)] = np.nan xys1r = xys2 + rflow fb_bad = (np.fabs(xys1r - xys1) > fb_threshold).all(axis=2) fflow[fb_bad] = np.nan return fflow
