def testValueAccessorCopy(self): xyz = (0, 0, 0) grid = openvdb.BoolGrid() acc = grid.getAccessor() self.assertEqual(acc.getValue(xyz), False) self.assertFalse(acc.isValueOn(xyz)) copyOfAcc = acc.copy() self.assertEqual(copyOfAcc.getValue(xyz), False) self.assertFalse(copyOfAcc.isValueOn(xyz)) # Verify that changes made to the grid through one accessor are reflected in the other. acc.setValueOn(xyz, True) self.assertEqual(acc.getValue(xyz), True) self.assertTrue(acc.isValueOn(xyz)) self.assertEqual(copyOfAcc.getValue(xyz), True) self.assertTrue(copyOfAcc.isValueOn(xyz)) copyOfAcc.setValueOff(xyz) self.assertEqual(acc.getValue(xyz), True) self.assertFalse(acc.isValueOn(xyz)) self.assertEqual(copyOfAcc.getValue(xyz), True) self.assertFalse(copyOfAcc.isValueOn(xyz)) # Verify that the two accessors are distinct, by checking that they # have cached different sets of nodes. xyz2 = (-1, -1, -1) copyOfAcc.setValueOn(xyz2) self.assertTrue(copyOfAcc.isCached(xyz2)) self.assertFalse(copyOfAcc.isCached(xyz)) self.assertTrue(acc.isCached(xyz)) self.assertFalse(acc.isCached(xyz2))
def testGridMetadata(self): grid = openvdb.BoolGrid() self.assertEqual(grid.metadata, {}) meta = { 'name': 'test', 'saveFloatAsHalf': True, 'xyz': (-1, 0, 1) } grid.metadata = meta self.assertEqual(grid.metadata, meta) meta['xyz'] = (-100, 100, 0) grid.updateMetadata(meta) self.assertEqual(grid.metadata, meta) self.assertEqual(set(grid.iterkeys()), set(meta.keys())) for name in meta: self.assertTrue(name in grid) self.assertEqual(grid[name], meta[name]) for name in grid: self.assertTrue(name in grid) self.assertEqual(grid[name], meta[name]) self.assertTrue('xyz' in grid) del grid['xyz'] self.assertFalse('xyz' in grid) grid['xyz'] = meta['xyz'] self.assertTrue('xyz' in grid) grid.addStatsMetadata() meta = grid.getStatsMetadata() self.assertEqual(0, meta["file_voxel_count"])
def testMap(self): grid = openvdb.BoolGrid() grid.fill((-4, -4, -4), (5, 5, 5), grid.zeroValue) # make active grid.mapOn(lambda x: not x) # replace active False values with True n = sum(item.value for item in grid.iterOnValues()) self.assertEqual(n, 10 * 10 * 10) grid = openvdb.FloatGrid() grid.fill((-4, -4, -4), (5, 5, 5), grid.oneValue) grid.mapOn(lambda x: x * 2) n = sum(item.value for item in grid.iterOnValues()) self.assertEqual(n, 10 * 10 * 10 * 2) grid = openvdb.Vec3SGrid() grid.fill((-4, -4, -4), (5, 5, 5), grid.zeroValue) grid.mapOn(lambda x: (0, 1, 0)) n = sum(item.value[1] for item in grid.iterOnValues()) self.assertEqual(n, 10 * 10 * 10)
def testGridMetadata(self): grid = openvdb.BoolGrid() self.assertEqual(grid.metadata, {}) meta = { 'name': 'test', 'xyz': (-1, 0, 1), 'xyzw': (1.0, 2.25, 3.5, 4.0), 'intval': 42, 'floatval': 1.25, 'mat4val': [[1] * 4] * 4, 'saveFloatAsHalf': True, } grid.metadata = meta self.assertEqual(grid.metadata, meta) meta['xyz'] = (-100, 100, 0) grid.updateMetadata(meta) self.assertEqual(grid.metadata, meta) self.assertEqual(set(grid.iterkeys()), set(meta.keys())) for name in meta: self.assertTrue(name in grid) self.assertEqual(grid[name], meta[name]) self.assertEqual(type(grid[name]), type(meta[name])) for name in grid: self.assertTrue(name in grid) self.assertEqual(grid[name], meta[name]) self.assertEqual(type(grid[name]), type(meta[name])) self.assertTrue('xyz' in grid) del grid['xyz'] self.assertFalse('xyz' in grid) grid['xyz'] = meta['xyz'] self.assertTrue('xyz' in grid) grid.addStatsMetadata() meta = grid.getStatsMetadata() self.assertEqual(0, meta["file_voxel_count"])
def testGridMetadata(self): grid = openvdb.BoolGrid() self.assertEqual(grid.metadata, {}) meta = dict(name='test', saveFloatAsHalf=True, xyz=(-1, 0, 1), intval=42, floatval=1.25) grid.metadata = meta self.assertEqual(grid.metadata, meta) meta['xyz'] = (-100, 100, 0) grid.updateMetadata(meta) self.assertEqual(grid.metadata, meta) self.assertEqual(set(grid.iterkeys()), set(meta.keys())) for name in meta: self.assertTrue(name in grid) self.assertEqual(grid[name], meta[name]) self.assertEqual(type(grid[name]), type(meta[name])) for name in grid: self.assertTrue(name in grid) self.assertEqual(grid[name], meta[name]) self.assertEqual(type(grid[name]), type(meta[name])) self.assertTrue('xyz' in grid) del grid['xyz'] self.assertFalse('xyz' in grid) grid['xyz'] = meta['xyz'] self.assertTrue('xyz' in grid) grid.addStatsMetadata() meta = grid.getStatsMetadata() self.assertEqual(0, meta["file_voxel_count"])
def predict_volume_appearance( dataset_base_dir: str, dataset: dict, model_filename, model_config, materials_filename, stencils_only, timings: Dict = None, ignore_md5_checks: bool = False, verbose_logging: bool = False, ): model_params = model_config["model_params"] if not os.path.isabs(materials_filename): materials_filename = os.path.join(dataset_base_dir, materials_filename) # backward compatibility if type(model_params["stencil_channels"]) == int: model_params["stencil_channels"] = [ "scattering", "absorption", "mask" ][:model_params["stencil_channels"]] model_arch_name = model_params["model_arch_name"] patch_size = model_params["patch_size"] scale_levels = model_params["scale_levels"] stencil_channels = model_params["stencil_channels"] is_2D_dataset = classify_dataset_class(dataset_base_dir, dataset) data_class = DataPlanar if is_2D_dataset else Data3D alignment_z_centered = model_params.get("alignment_z_centered", data_class == Data3D) data = data_class( alignment_z_centered=alignment_z_centered, data_items=dataset, dataset_base_dir=dataset_base_dir, find_inner_material_voxels=model_params["find_inner_material_voxels"], ignore_md5_checks=ignore_md5_checks, materials_file=materials_filename, mode=MODE_PREDICT, patch_size=patch_size, sat_object_class_name="TreeSAT", scale_levels=scale_levels, shuffle_patches=False, sliding_window_length=1, stencil_channels=stencil_channels, stencils_only=stencils_only, timings=timings, verbose_logging=verbose_logging, ) batch_size = int(os.getenv("BATCH_SIZE", 10000)) model_make_function = models_collection[model_arch_name] model = model_make_function(params=model_params) model.load_weights(model_filename) make_batch_function = (make_batch_swap_axes if model_arch_name in ("planar_first", "first_baseline") else make_batch) locations = [] predictions = model.predict_generator( generator=make_batches_gen(data, batch_size, locations, make_batch_function), steps=math.ceil(len(data) / batch_size), verbose=1, ) predicted_images = {} predicted_images_accessors = {} gt_renderings = {} predicted_masks = None predicted_masks_accessors = {} materials = populate_materials(materials_filename) material_channels = [m.channels for m in materials.values()] assert max(material_channels) == min( material_channels ), "number of channels in materials file mismatch" # all elements equal materials_channel_count = material_channels[0] if materials_channel_count != 3: # spectral mode material_wavelengths = [m.wavelengths for m in materials.values()] for i in range(1, len(material_wavelengths)): assert numpy.array_equal( material_wavelengths[i - 1], material_wavelengths[i] ), "wavelength definition mismatch in materials file" # spectral prediction X, Y, Z = CIEXYZ_primaries(material_wavelengths[0] * 10) # convert nm to Angstrom if is_2D_dataset: for (datafile_idx, channel, pidx), pixel_prediction in zip(locations, predictions): dataset_item_key, metadata = data.volume_files[datafile_idx] if dataset_item_key not in predicted_images.keys(): if not stencils_only: gt_renderings[dataset_item_key] = data.get_render( dataset_item_key=dataset_item_key) predicted_images[dataset_item_key] = numpy.empty( shape=(metadata["height"], metadata["width"], 3), dtype=numpy.float32) x, y, z = data.convert_patch_index(datafile_idx, channel, pidx) predicted_images[dataset_item_key][y, x, channel] = pixel_prediction else: # is 3D dataset material_voxel_found_index_masks = { dataset_item_key: data.material_voxel_found_index[datafile_idx] for datafile_idx, (dataset_item_key, _) in enumerate(data.volume_files) } predicted_masks = {} locations_predictions = (pd.DataFrame( numpy.concatenate( [numpy.array(locations), numpy.array(predictions)], axis=1), columns=["datafile_idx", "channel", "pidx", "value"], ).astype({ "datafile_idx": "uint16", "channel": "uint8", "pidx": "uint32", }).sort_values(by=["datafile_idx", "pidx", "channel"])) num_channels = int(locations_predictions["channel"].max()) + 1 for lp_idx in range(0, len(locations_predictions), num_channels): datafile_idx = int(locations_predictions.at[lp_idx, "datafile_idx"]) pidx = int(locations_predictions.at[lp_idx, "pidx"]) dataset_item_key, metadata = data.volume_files[int(datafile_idx)] if dataset_item_key not in predicted_images.keys(): predicted_images[dataset_item_key] = pyopenvdb.Vec3SGrid( (-1, -1, -1)) predicted_images_accessors[ dataset_item_key] = predicted_images[ dataset_item_key].getAccessor() predicted_masks[dataset_item_key] = pyopenvdb.BoolGrid(False) predicted_masks_accessors[dataset_item_key] = predicted_masks[ dataset_item_key].getAccessor() render, _, _, _, _ = data.get_render( dataset_item_key=dataset_item_key) gt_renderings[dataset_item_key] = render if render is not None: predicted_images[ dataset_item_key].transform = render.transform else: dataset_item = data.data_items[dataset_item_key] filled_path = dataset_item["proxy_object_filled_path"] if filled_path is not None: normal_grid = pyopenvdb.read(filled_path, "normalGrid") predicted_images[ dataset_item_key].transform = normal_grid.transform else: raise RuntimeError( "One of: `render_filename`, `proxy_object_filled_path` " "should be set to extract transform for the predicted grid" ) predicted_images[dataset_item_key].name = "prediction" x, y, z = data.convert_patch_index_to_render_coords( datafile_idx, 0, pidx) if num_channels == 3: value = ( locations_predictions.at[lp_idx + 0, "value"], locations_predictions.at[lp_idx + 1, "value"], locations_predictions.at[lp_idx + 2, "value"], ) else: # convolve the renderings with the XYZ color matching functions value = [0.0, 0.0, 0.0] for i, wavelength in enumerate(material_wavelengths[0]): value[0] += X[i] * locations_predictions.at[lp_idx + i, "value"] value[1] += Y[i] * locations_predictions.at[lp_idx + i, "value"] value[2] += Z[i] * locations_predictions.at[lp_idx + i, "value"] value = tuple(xyz2linear_rgb([[value]])[0][0]) predicted_images_accessors[dataset_item_key].setValueOn((x, y, z), value) mask_value = material_voxel_found_index_masks[dataset_item_key][ pidx] predicted_masks_accessors[dataset_item_key].setValueOn((x, y, z), mask_value) return predicted_images, gt_renderings, predicted_masks