def test_calc_tile_slice(tc_params, tiy, tix, s, exp, monkeypatch): """Test appropriate slice is returned given image data.""" tile_calc = TileCalculator(*tc_params) res = tile_calc.calc_tile_slice(tiy, tix, s) assert res == exp
class SIFTTiledGeolocatedMixin: def __init__(self, data, *area_params, tile_shape=(DEFAULT_TILE_HEIGHT, DEFAULT_TILE_WIDTH), texture_shape=(DEFAULT_TEXTURE_HEIGHT, DEFAULT_TEXTURE_WIDTH), wrap_lon=False, projection=DEFAULT_PROJECTION, **visual_kwargs): origin_x, origin_y, cell_width, cell_height = area_params if visual_kwargs.get("method", "subdivide") != "subdivide": raise ValueError("Only 'subdivide' drawing method is supported.") visual_kwargs["method"] = "subdivide" if "grid" in visual_kwargs: raise ValueError( "The 'grid' keyword argument is not supported with the tiled mixin." ) # visual nodes already have names, so be careful if not hasattr(self, "name"): self.name = visual_kwargs.pop("name", None) self._init_geo_parameters( origin_x, origin_y, cell_width, cell_height, projection, texture_shape, tile_shape, wrap_lon, visual_kwargs.get('shape'), data, ) # Call the init of the Visual super().__init__(data, **visual_kwargs) def _init_geo_parameters(self, origin_x, origin_y, cell_width, cell_height, projection, texture_shape, tile_shape, wrap_lon, shape, data): self._viewable_mesh_mask = None self._ref1 = None self._ref2 = None self.origin_x = origin_x self.origin_y = origin_y self.cell_width = cell_width self.cell_height = cell_height # Note: cell_height is usually negative self.texture_shape = texture_shape self.tile_shape = tile_shape self.num_tex_tiles = self.texture_shape[0] * self.texture_shape[1] self._stride = (0, 0) self._latest_tile_box = None self.wrap_lon = wrap_lon self._tiles = {} assert (shape or data is not None), "`data` or `shape` must be provided" self.shape = shape or data.shape self.ndim = len(self.shape) or data.ndim # Where does this image lie in this lonely world self.calc = TileCalculator( self.name, self.shape, Point(x=self.origin_x, y=self.origin_y), Resolution(dy=abs(self.cell_height), dx=abs(self.cell_width)), self.tile_shape, self.texture_shape, wrap_lon=self.wrap_lon, projection=projection, ) # What tiles have we used and can we use self.texture_state = TextureTileState(self.num_tex_tiles) def _normalize_data(self, data): if data is not None and data.dtype == np.float64: data = data.astype(np.float32) return data def _build_texture_tiles(self, data, stride, tile_box: Box): """Prepare and organize strided data in to individual tiles with associated information. """ data = self._normalize_data(data) LOG.debug("Uploading texture data for %d tiles (%r)", (tile_box.bottom - tile_box.top) * (tile_box.right - tile_box.left), tile_box) # Tiles start at upper-left so go from top to bottom tiles_info = [] for tiy in range(tile_box.top, tile_box.bottom): for tix in range(tile_box.left, tile_box.right): already_in = (stride, tiy, tix) in self.texture_state # Update the age if already in there # Assume that texture_state does not change from the main thread if this is run in another tex_tile_idx = self.texture_state.add_tile((stride, tiy, tix)) if already_in: # FIXME: we should make a list/set of the tiles we need to add before this continue # Assume we were given a total image worth of this stride y_slice, x_slice = self.calc.calc_tile_slice(tiy, tix, stride) tile_data = self._slice_texture_tile(data, y_slice, x_slice) tiles_info.append((stride, tiy, tix, tex_tile_idx, tile_data)) return tiles_info def _slice_texture_tile(self, data, y_slice, x_slice): # force a copy of the data from the content array (provided by the workspace) # to a vispy-compatible contiguous float array # this can be a potentially time-expensive operation since content array is # often huge and always memory-mapped, so paging may occur # we don't want this paging deferred until we're back in the GUI thread pushing data to OpenGL! return np.array(data[y_slice, x_slice], dtype=np.float32) def _set_texture_tiles(self, tiles_info): for tile_info in tiles_info: stride, tiy, tix, tex_tile_idx, data = tile_info self._texture.set_tile_data(tex_tile_idx, data) def _build_vertex_tiles(self, preferred_stride, tile_box: Box): """Rebuild the vertex buffers used for rendering the image when using the subdivide method. SIFT Note: Copied from 0.5.0dev original ImageVisual class """ total_num_tiles = (tile_box.bottom - tile_box.top) * (tile_box.right - tile_box.left) if total_num_tiles <= 0: # we aren't looking at this image # FIXME: What's the correct way to stop drawing here raise RuntimeError( "View calculations determined a negative number of tiles are visible" ) elif total_num_tiles > self.num_tex_tiles: LOG.warning( "Current view sees more tiles than can be held in the GPU") # We continue on, showing as many tiles as we can tex_coords = np.empty( (6 * total_num_tiles * (TESS_LEVEL * TESS_LEVEL), 2), dtype=np.float32) vertices = np.empty( (6 * total_num_tiles * (TESS_LEVEL * TESS_LEVEL), 2), dtype=np.float32) # What tile are we currently describing out of all the tiles being viewed used_tile_idx = -1 LOG.debug("Building vertex data for %d tiles (%r)", total_num_tiles, tile_box) tl = TESS_LEVEL * TESS_LEVEL # Tiles start at upper-left so go from top to bottom for tiy in range(tile_box.top, tile_box.bottom): for tix in range(tile_box.left, tile_box.right): # Update the index here because we have multiple exit/continuation points used_tile_idx += 1 # Check if the tile we want to draw is actually in the GPU # if not (atlas too small?) fill with zeros and keep going if (preferred_stride, tiy, tix) not in self.texture_state: # THIS SHOULD NEVER HAPPEN IF TEXTURE BUILDING IS DONE CORRECTLY AND THE ATLAS IS BIG ENOUGH tile_start = TESS_LEVEL * TESS_LEVEL * used_tile_idx * 6 tile_end = TESS_LEVEL * TESS_LEVEL * (used_tile_idx + 1) * 6 tex_coords[tile_start:tile_end, :] = 0 vertices[tile_start:tile_end, :] = 0 continue # we should have already loaded the texture data in to the GPU so get the index of that texture tex_tile_idx = self.texture_state[(preferred_stride, tiy, tix)] factor_rez, offset_rez = self.calc.calc_tile_fraction( tiy, tix, preferred_stride) tex_coords[tl * used_tile_idx * 6: tl * (used_tile_idx + 1) * 6, :] = \ self.calc.calc_texture_coordinates(tex_tile_idx, factor_rez, offset_rez, tessellation_level=TESS_LEVEL) vertices[tl * used_tile_idx * 6:tl * (used_tile_idx + 1) * 6, :] = self.calc.calc_vertex_coordinates( tiy, tix, preferred_stride[0], preferred_stride[1], factor_rez, offset_rez, tessellation_level=TESS_LEVEL) return vertices, tex_coords def _set_vertex_tiles(self, vertices, tex_coords): self._subdiv_position.set_data(vertices.astype('float32')) self._subdiv_texcoord.set_data(tex_coords.astype('float32')) def determine_reference_points(self): # Image points transformed to canvas coordinates img_cmesh = self.transforms.get_transform().map(self.calc.image_mesh) # Mask any points that are really far off screen (can't be transformed) valid_mask = (np.abs(img_cmesh[:, 0]) < CANVAS_EPSILON) & (np.abs( img_cmesh[:, 1]) < CANVAS_EPSILON) # The image mesh projected to canvas coordinates (valid only) img_cmesh = img_cmesh[valid_mask] # The image mesh of only valid "viewable" projected coordinates img_vbox = self.calc.image_mesh[valid_mask] if not img_cmesh[:, 0].size or not img_cmesh[:, 1].size: self._viewable_mesh_mask = None self._ref1, self._ref2 = None, None return x_cmin, x_cmax = img_cmesh[:, 0].min(), img_cmesh[:, 0].max() y_cmin, y_cmax = img_cmesh[:, 1].min(), img_cmesh[:, 1].max() center_x = (x_cmax - x_cmin) / 2. + x_cmin center_y = (y_cmax - y_cmin) / 2. + y_cmin dist = img_cmesh.copy() dist[:, 0] = center_x - img_cmesh[:, 0] dist[:, 1] = center_y - img_cmesh[:, 1] self._viewable_mesh_mask = valid_mask self._ref1, self._ref2 = get_reference_points(dist, img_vbox) def get_view_box(self): """Calculate shown portion of image and image units per pixel This method utilizes a precomputed "mesh" of relatively evenly spaced points over the entire image space. This mesh is transformed to the canvas space (-1 to 1 user-viewed space) to figure out which portions of the image are currently being viewed and which portions can actually be projected on the viewed projection. While the result of the chosen method may not always be completely accurate, it should work for all possible viewing cases. """ if self._viewable_mesh_mask is None or self.canvas.size[ 0] == 0 or self.canvas.size[1] == 0: raise ValueError("Image '%s' is not viewable in this projection" % (self.name, )) # Image points transformed to canvas coordinates img_cmesh = self.transforms.get_transform().map(self.calc.image_mesh) # The image mesh projected to canvas coordinates (valid only) img_cmesh = img_cmesh[self._viewable_mesh_mask] # The image mesh of only valid "viewable" projected coordinates img_vbox = self.calc.image_mesh[self._viewable_mesh_mask] ref_idx_1, ref_idx_2 = get_reference_points(img_cmesh, img_vbox) dx, dy = calc_pixel_size(img_cmesh[(self._ref1, self._ref2), :], img_vbox[(self._ref1, self._ref2), :], self.canvas.size) view_extents = self.calc.calc_view_extents(img_cmesh[ref_idx_1], img_vbox[ref_idx_1], self.canvas.size, dx, dy) return ViewBox(*view_extents, dx=dx, dy=dy) def _get_stride(self, view_box): return self.calc.calc_stride(view_box) def assess(self): """Determine if a retile is needed. Tell workspace we will be needed """ try: view_box = self.get_view_box() preferred_stride = self._get_stride(view_box) tile_box = self.calc.visible_tiles(view_box, stride=preferred_stride, extra_tiles_box=Box(1, 1, 1, 1)) except ValueError as e: # If image is outside of canvas, then an exception will be raised LOG.warning( "Could not determine viewable image area for '{}': {}".format( self.name, e)) return False, self._stride, self._latest_tile_box num_tiles = (tile_box.bottom - tile_box.top) * (tile_box.right - tile_box.left) LOG.debug( "Assessment: Prefer '%s' have '%s', was looking at %r, now looking at %r", preferred_stride, self._stride, self._latest_tile_box, tile_box) # If we zoomed out or we panned need_retile = (num_tiles > 0) and (preferred_stride != self._stride or self._latest_tile_box != tile_box) return need_retile, preferred_stride, tile_box def retile(self, data, preferred_stride, tile_box): """Get data from workspace and retile/retexture as needed. """ tiles_info = self._build_texture_tiles(data, preferred_stride, tile_box) vertices, tex_coords = self._build_vertex_tiles( preferred_stride, tile_box) return tiles_info, vertices, tex_coords def set_retiled(self, preferred_stride, tile_box, tiles_info, vertices, tex_coords): self._set_texture_tiles(tiles_info) self._set_vertex_tiles(vertices, tex_coords) # don't update here, the caller will do that # Store the most recent level of detail that we've done self._stride = preferred_stride self._latest_tile_box = tile_box