def map(self, L, x, y): dd = 1.0 / (2.0**(int(L))) relx = int(x) * dd rely = int(y) * dd DW = (self.ds.domain_right_edge - self.ds.domain_left_edge) xl = self.ds.domain_left_edge[0] + relx * DW[0] yl = self.ds.domain_left_edge[1] + rely * DW[1] xr = xl + dd * DW[0] yr = yl + dd * DW[1] frb = FixedResolutionBuffer(self.data, (xl, xr, yl, yr), (256, 256)) cmi, cma = get_color_bounds( self.data['px'], self.data['py'], self.data['pdx'], self.data['pdy'], self.data[self.field], self.ds.domain_left_edge[0], self.ds.domain_right_edge[0], self.ds.domain_left_edge[1], self.ds.domain_right_edge[1], dd * DW[0] / (64 * 256), dd * DW[0]) if self.ds._get_field_info(self.field).take_log: cmi = np.log10(cmi) cma = np.log10(cma) to_plot = apply_colormap(np.log10(frb[self.field]), color_bounds=(cmi, cma)) else: to_plot = apply_colormap(frb[self.field], color_bounds=(cmi, cma)) rv = write_png_to_string(to_plot) return rv
def map(self, L, x, y): dd = 1.0 / (2.0**(int(L))) relx = int(x) * dd rely = int(y) * dd DW = (self.ds.domain_right_edge - self.ds.domain_left_edge) xl = self.ds.domain_left_edge[0] + relx * DW[0] yl = self.ds.domain_left_edge[1] + rely * DW[1] xr = xl + dd*DW[0] yr = yl + dd*DW[1] frb = FixedResolutionBuffer(self.data, (xl, xr, yl, yr), (256, 256)) cmi, cma = get_color_bounds(self.data['px'], self.data['py'], self.data['pdx'], self.data['pdy'], self.data[self.field], self.ds.domain_left_edge[0], self.ds.domain_right_edge[0], self.ds.domain_left_edge[1], self.ds.domain_right_edge[1], dd*DW[0] / (64*256), dd*DW[0]) if self.ds._get_field_info(self.field).take_log: cmi = np.log10(cmi) cma = np.log10(cma) to_plot = apply_colormap(np.log10(frb[self.field]), color_bounds = (cmi, cma)) else: to_plot = apply_colormap(frb[self.field], color_bounds = (cmi, cma)) rv = write_png_to_string(to_plot) return rv
def apply_colormap(self): ''' Applies a colormap to the current image without re-rendering. Parameters ---------- cmap_name : string, optional An acceptable colormap. See either yt.visualization.color_maps or http://www.scipy.org/Cookbook/Matplotlib/Show_colormaps . color_bounds : tuple of floats, optional The min and max to scale between. Outlying values will be clipped. Returns ------- current_image : A new image with the specified color scale applied to the underlying data. ''' image = apply_colormap(self.data, color_bounds=self._color_bounds, cmap_name=self._cmap) / 255. alpha = image[:, :, 3] alpha[self.sampler.aimage_used == -1] = 0.0 image[:, :, 3] = alpha return image
def map(self, field, L, x, y): if "," in field: field = tuple(field.split(",")) cmap = self.cmap dd = 1.0 / (2.0**(int(L))) relx = int(x) * dd rely = int(y) * dd DW = self.ds.domain_right_edge - self.ds.domain_left_edge xl = self.ds.domain_left_edge[0] + relx * DW[0] yl = self.ds.domain_left_edge[1] + rely * DW[1] xr = xl + dd * DW[0] yr = yl + dd * DW[1] try: self.lock() w = 256 # pixels data = self.data[field] frb = FixedResolutionBuffer(self.data, (xl, xr, yl, yr), (w, w)) cmi, cma = get_color_bounds( self.data["px"], self.data["py"], self.data["pdx"], self.data["pdy"], data, self.ds.domain_left_edge[0], self.ds.domain_right_edge[0], self.ds.domain_left_edge[1], self.ds.domain_right_edge[1], dd * DW[0] / (64 * 256), dd * DW[0], ) finally: self.unlock() if self.takelog: cmi = np.log10(cmi) cma = np.log10(cma) to_plot = apply_colormap(np.log10(frb[field]), color_bounds=(cmi, cma), cmap_name=cmap) else: to_plot = apply_colormap(frb[field], color_bounds=(cmi, cma), cmap_name=cmap) rv = write_png_to_string(to_plot) return rv
def __init__( self, data_source, alpha=0.3, cmap=None, min_level=None, max_level=None ): self.data_source = data_source_or_all(data_source) corners = [] levels = [] for block, _mask in self.data_source.blocks: block_corners = np.array( [ [block.LeftEdge[0], block.LeftEdge[1], block.LeftEdge[2]], [block.RightEdge[0], block.LeftEdge[1], block.LeftEdge[2]], [block.RightEdge[0], block.RightEdge[1], block.LeftEdge[2]], [block.LeftEdge[0], block.RightEdge[1], block.LeftEdge[2]], [block.LeftEdge[0], block.LeftEdge[1], block.RightEdge[2]], [block.RightEdge[0], block.LeftEdge[1], block.RightEdge[2]], [block.RightEdge[0], block.RightEdge[1], block.RightEdge[2]], [block.LeftEdge[0], block.RightEdge[1], block.RightEdge[2]], ], dtype="float64", ) corners.append(block_corners) levels.append(block.Level) corners = np.dstack(corners) levels = np.array(levels) if cmap is None: cmap = ytcfg.get("yt", "default_colormap") if max_level is not None: subset = levels <= max_level levels = levels[subset] corners = corners[:, :, subset] if min_level is not None: subset = levels >= min_level levels = levels[subset] corners = corners[:, :, subset] colors = ( apply_colormap( levels * 1.0, color_bounds=[0, self.data_source.ds.index.max_level], cmap_name=cmap, )[0, :, :] / 255.0 ) colors[:, 3] = alpha order = [0, 1, 1, 2, 2, 3, 3, 0] order += [4, 5, 5, 6, 6, 7, 7, 4] order += [0, 4, 1, 5, 2, 6, 3, 7] vertices = np.empty([corners.shape[2] * 2 * 12, 3]) for i in range(3): vertices[:, i] = corners[order, i, ...].ravel(order="F") vertices = vertices.reshape((corners.shape[2] * 12, 2, 3)) super(GridSource, self).__init__(vertices, colors, color_stride=24)
def map(self, field, L, x, y): if ',' in field: field = tuple(field.split(',')) dd = 1.0 / (2.0**(int(L))) relx = int(x) * dd rely = int(y) * dd DW = (self.ds.domain_right_edge - self.ds.domain_left_edge) xl = self.ds.domain_left_edge[0] + relx * DW[0] yl = self.ds.domain_left_edge[1] + rely * DW[1] xr = xl + dd*DW[0] yr = yl + dd*DW[1] try: self.lock() data = self.data[field] frb = FixedResolutionBuffer(self.data, (xl, xr, yl, yr), (256, 256)) cmi, cma = get_color_bounds(self.data['px'], self.data['py'], self.data['pdx'], self.data['pdy'], data, self.ds.domain_left_edge[0], self.ds.domain_right_edge[0], self.ds.domain_left_edge[1], self.ds.domain_right_edge[1], dd*DW[0] / (64*256), dd*DW[0]) finally: self.unlock() if self.takelog: cmi = np.log10(cmi) cma = np.log10(cma) to_plot = apply_colormap(np.log10(frb[field]), color_bounds = (cmi, cma)) else: to_plot = apply_colormap(frb[field], color_bounds = (cmi, cma)) rv = write_png_to_string(to_plot) return rv
def apply_colormap(self): """ Applies a colormap to the current image without re-rendering. Returns ------- current_image : A new image with the specified color scale applied to the underlying data. """ image = (apply_colormap( self.data, color_bounds=self._color_bounds, cmap_name=self._cmap) / 255.0) alpha = image[:, :, 3] alpha[self.sampler.aimage_used == -1] = 0.0 image[:, :, 3] = alpha return image
def test_apply_colormap(self): x = np.array(np.random.randint(0, 256, size=(10, 10)), dtype="uint8") apply_colormap(x, color_bounds=None, cmap_name=None, func=lambda x: x**2)
def __call__(self, plot): x0, x1 = plot.xlim y0, y1 = plot.ylim xx0, xx1 = plot._axes.get_xlim() yy0, yy1 = plot._axes.get_ylim() (dx, dy) = self.pixel_scale(plot) (xpix, ypix) = plot.image._A.shape ax = plot.data.axis px_index = plot.data.ds.coordinates.x_axis[ax] py_index = plot.data.ds.coordinates.y_axis[ax] DW = plot.data.ds.domain_width if self.periodic: pxs, pys = np.mgrid[-1:1:3j, -1:1:3j] else: pxs, pys = np.mgrid[0:0:1j, 0:0:1j] GLE, GRE, levels = [], [], [] for block, mask in plot.data.blocks: GLE.append(block.LeftEdge.in_units("code_length")) GRE.append(block.RightEdge.in_units("code_length")) levels.append(block.Level) if len(GLE) == 0: return # Retain both units and registry GLE = YTArray(GLE, input_units=GLE[0].units) GRE = YTArray(GRE, input_units=GRE[0].units) levels = np.array(levels) min_level = self.min_level or 0 max_level = self.max_level or levels.max() # sorts the three arrays in order of ascending level - this makes images look nicer new_indices = np.argsort(levels) levels = levels[new_indices] GLE = GLE[new_indices] GRE = GRE[new_indices] for px_off, py_off in zip(pxs.ravel(), pys.ravel()): pxo = px_off * DW[px_index] pyo = py_off * DW[py_index] left_edge_x = np.array((GLE[:, px_index] + pxo - x0) * dx) + xx0 left_edge_y = np.array((GLE[:, py_index] + pyo - y0) * dy) + yy0 right_edge_x = np.array((GRE[:, px_index] + pxo - x0) * dx) + xx0 right_edge_y = np.array((GRE[:, py_index] + pyo - y0) * dy) + yy0 xwidth = xpix * (right_edge_x - left_edge_x) / (xx1 - xx0) ywidth = ypix * (right_edge_y - left_edge_y) / (yy1 - yy0) visible = np.logical_and( np.logical_and(xwidth > self.min_pix, ywidth > self.min_pix), np.logical_and(levels >= min_level, levels <= max_level)) # Grids can either be set by edgecolors OR a colormap. if self.edgecolors is not None: edgecolors = colorConverter.to_rgba(self.edgecolors, alpha=self.alpha) else: # use colormap if not explicity overridden by edgecolors if self.cmap is not None: color_bounds = [0, plot.data.ds.index.max_level] edgecolors = apply_colormap( levels[visible] * 1.0, color_bounds=color_bounds, cmap_name=self.cmap)[0, :, :] * 1.0 / 255. edgecolors[:, 3] = self.alpha else: edgecolors = (0.0, 0.0, 0.0, self.alpha) if visible.nonzero()[0].size == 0: continue verts = np.array([ (left_edge_x, left_edge_x, right_edge_x, right_edge_x), (left_edge_y, right_edge_y, right_edge_y, left_edge_y) ]) verts = verts.transpose()[visible, :, :] grid_collection = matplotlib.collections.PolyCollection( verts, facecolors="none", edgecolors=edgecolors, linewidth=self.linewidth) plot._axes.hold(True) plot._axes.add_collection(grid_collection) if self.draw_ids: visible_ids = np.logical_and( np.logical_and(xwidth > self.min_pix_ids, ywidth > self.min_pix_ids), np.logical_and(levels >= min_level, levels <= max_level)) active_ids = np.unique(plot.data['grid_indices']) for i in np.where(visible_ids)[0]: plot._axes.text(left_edge_x[i] + (2 * (xx1 - xx0) / xpix), left_edge_y[i] + (2 * (yy1 - yy0) / ypix), "%d" % active_ids[i], clip_on=True) plot._axes.hold(False)