def test_height_stats(self): pc_in = load("testdata/AHN2.las") neighborhood = [89664, 23893, 30638, 128795, 62052, 174453, 29129, 17127, 128215, 29667, 116156, 119157, 98591, 7018, 61494, 65194, 117931, 62971, 10474, 90322] kurtosis_z = self.extractor.extract(pc_in, [neighborhood], None, None, None)[0] np.testing.assert_allclose(kurtosis_z, 3.968414258629714)
def test_wkt_polygons_contains_original_not_changed(self): """Point cloud in should not change by filtering.""" pc_in = load("testdata/AHN2.las") len_x_before = len(pc_in[point]['x']['data']) _pc_out = select_polygon(pc_in, self.polygon_around_1_point_ahn2) len_x_after = len(pc_in[point]['x']['data']) assert_equal(len_x_after, len_x_before)
def setUp(self): """ Set up the test. Load in a bunch of real data from AHN3. """ np.random.seed(1234) _TEST_FILE_NAME = 'AHN3.las' _TEST_DATA_SOURCE = 'testdata' _CYLINDER = InfiniteCylinder(4) _PC_260807 = load(os.path.join(_TEST_DATA_SOURCE, _TEST_FILE_NAME)) _PC_1000 = copy_point_cloud( _PC_260807, array_mask=(np.random.choice(range( len(_PC_260807[keys.point]['x']['data'])), size=1000, replace=False))) _1000_NEIGHBORHOODS_IN_260807 = list( compute_neighbors.compute_neighborhoods(_PC_260807, _PC_1000, _CYLINDER)) self.point_cloud = _PC_260807 self.neigh = _1000_NEIGHBORHOODS_IN_260807
def test_height_stats_without_neighbors(self): pc_in = load("testdata/AHN2.las") neighborhood = [] max_z, min_z, range_z = RangeFeatureExtractor().extract( pc_in, [neighborhood], pc_in, None, None)[:, 0] assert np.isnan(range_z) assert np.isnan(max_z) assert np.isnan(min_z)
def test_shp_polygons_containsEmpty(): """ Selecting all points within a Polygon. """ pc_in = load("testdata/AHN2.las") pc_out = select_polygon(pc_in, "testdata/ahn2_geometries_shp/ahn2_polygon_empty.shp", read_from_file=True) x = pc_out[point]['x']['data'] y = pc_out[point]['y']['data'] assert (len(x) == 0) assert (len(y) == 0)
def test_height_stats_without_neighbors(self): pc_in = load("testdata/AHN2.las") neighborhood = [] mean_z, std_z, coeff_var_z = self.extractor.extract( pc_in, [neighborhood], pc_in, None, None)[:, 0] assert np.isnan(mean_z) assert np.isnan(std_z) assert np.isnan(coeff_var_z)
def test_points_in_polygon_wkt_invalidPolygon(): """Polygon is not closed so should raise error.""" pc_in = load("testdata/AHN2.las") with pytest.raises(ValueError): select_polygon( pc_in, "POLYGON(( 243590.0 572110.0, 243640.0 572160.0, 243700.0 572110.0, 243640.0 572060.0 ))" )
def test_shp_polygons_contains(): """ Selecting all points within a Polygon. """ pc_in = load("testdata/AHN2.las") pc_out = select_polygon(pc_in, "testdata/ahn2_geometries_shp/ahn2_polygon.shp", read_from_file=True) x = pc_out[point]['x']['data'] y = pc_out[point]['y']['data'] # Seemingly redundant 'astype' call: since pandas 0.24 Dataframe() doesn't enforce the given dtype as before df_out = pd.DataFrame({'x': x, 'y': y}, dtype=np.int32).astype(dtype=np.int32) df = pd.read_csv("testdata/ahn2_polygon.out", sep=',', header=0, index_col=0, dtype=np.int32) assert (pd.DataFrame.equals(df, df_out))
def setUp(self): """Set up the test.""" self.point_cloud = load(os.path.join(self._test_data_source, self._test_file_name)) random.seed(102938482634) self.target_point_cloud = self._get_random_targets() radius = 0.5 self.sphere = Sphere(radius) self.cyl = InfiniteCylinder(radius)
def test_wkt_polygons_containsEmpty(): """ Selecting all points within a Polygon. """ pc_in = load("testdata/AHN2.las") pc_out = select_polygon(pc_in, ("POLYGON(( 253590.0 582110.0, " "253640.0 582160.0, 253700.0 582110.0, " "253640.0 582060.0, 253590.0 582110.0 ))")) x = pc_out[point]['x']['data'] y = pc_out[point]['y']['data'] assert (len(x) == 0) assert (len(y) == 0)
def test_wkt_polygons_contains_single_point(self): """Selecting a single point with a tiny polygon. Test for https://github.com/eEcoLiDAR/eEcoLiDAR/issues/64. """ pc_in = load("testdata/AHN2.las") pc_out = select_polygon(pc_in, self.polygon_around_1_point_ahn2) x = pc_out[point]['x']['data'] y = pc_out[point]['y']['data'] expected_x = 243627.841248 expected_y = 572073.440002 assert_equal(len(x), 1) assert_almost_equal(x[0], expected_x, 4) assert_almost_equal(y[0], expected_y, 4)
def test_height_stats(self): pc_in = load("testdata/AHN2.las") neighborhood = [ 89664, 23893, 30638, 128795, 62052, 174453, 29129, 17127, 128215, 29667, 116156, 119157, 98591, 7018, 61494, 65194, 117931, 62971, 10474, 90322 ] max_z, min_z, range_z = RangeFeatureExtractor().extract( pc_in, [neighborhood], None, None, None)[:, 0] np.testing.assert_allclose(range_z, 5.5) np.testing.assert_allclose(max_z, 5.979999973773956) np.testing.assert_allclose(min_z, 0.47999997377395631)
def test_height_stats(self): pc_in = load("testdata/AHN2.las") neighborhood = [ 89664, 23893, 30638, 128795, 62052, 174453, 29129, 17127, 128215, 29667, 116156, 119157, 98591, 7018, 61494, 65194, 117931, 62971, 10474, 90322 ] mean_z, std_z, coeff_var_z = self.extractor.extract( pc_in, [neighborhood], None, None, None)[:, 0] np.testing.assert_allclose(mean_z, 1.3779999737739566) np.testing.assert_allclose(std_z, 1.3567741153191268) np.testing.assert_allclose(coeff_var_z, 0.9845966191155302)
def test_percentile(self): """Compute the percentile of a given selection.""" _test_file_name = 'AHN3.las' _test_data_source = 'testdata' point_cloud = load(os.path.join(_test_data_source, _test_file_name)) index = [ 89664, 23893, 30638, 128795, 62052, 174453, 29129, 17127, 128215, 29667, 116156, 119157, 98591, 7018, 61494, 65194, 117931, 62971, 10474, 90322 ] extractor = PercentileFeatureExtractor() extractor.extract(point_cloud, index, None, None, None)
def load(self, **load_opts): """ Read point cloud from disk. :param load_opts: Arguments passed to the laserchicken load function """ check_path_exists(self.input_path, should_exist=True) input_file_list = _get_input_file_list(self.input_path) logger.info('Loading point cloud data ...') for file in input_file_list: logger.info('... loading {}'.format(file)) add_to_point_cloud(self.point_cloud, load(file, **load_opts)) logger.info('... loading completed.') return self
def test_tutorial_once(self): """This test should be identical to running all cells in the tutorial notebook once, in order.""" from laserchicken import load point_cloud = load('testdata/AHN3.las') point_cloud from laserchicken.normalize import normalize normalize(point_cloud) point_cloud from laserchicken.filter import select_polygon polygon = "POLYGON(( 131963.984125 549718.375000," + \ " 132000.000125 549718.375000," + \ " 132000.000125 549797.063000," + \ " 131963.984125 549797.063000," + \ " 131963.984125 549718.375000))" point_cloud = select_polygon(point_cloud, polygon) from laserchicken.filter import select_above, select_below points_below_1_meter = select_below(point_cloud, 'normalized_height', 1) points_above_1_meter = select_above(point_cloud, 'normalized_height', 1) from laserchicken import compute_neighborhoods from laserchicken import build_volume targets = point_cloud volume = build_volume("sphere", radius=5) neighborhoods = compute_neighborhoods(point_cloud, targets, volume) from laserchicken import compute_features compute_features(point_cloud, neighborhoods, targets, ['std_z', 'mean_z', 'slope'], volume) from laserchicken import register_new_feature_extractor from laserchicken.feature_extractor.band_ratio_feature_extractor import BandRatioFeatureExtractor register_new_feature_extractor(BandRatioFeatureExtractor(None, 1, data_key='normalized_height')) register_new_feature_extractor(BandRatioFeatureExtractor(1, 2, data_key='normalized_height')) register_new_feature_extractor(BandRatioFeatureExtractor(2, None, data_key='normalized_height')) register_new_feature_extractor(BandRatioFeatureExtractor(None, 0, data_key='z')) from laserchicken.feature_extractor.feature_extraction import list_feature_names sorted(list_feature_names()) cylinder = build_volume("infinite cylinder", radius=5) neighborhoods = compute_neighborhoods(point_cloud, targets, cylinder) compute_features(point_cloud, neighborhoods, targets, ['band_ratio_1<normalized_height<2'], cylinder) from laserchicken import export export(point_cloud, 'my_output.ply')
def test_eigenvalues_in_cylinders(self): """Test provenance added (This should actually be part the general feature extractor test suite).""" random.seed(102938482634) point_cloud = load(os.path.join('testdata', 'AHN3.las')) num_all_pc_points = len(point_cloud[keys.point]["x"]["data"]) rand_indices = [ random.randint(0, num_all_pc_points) for _ in range(20) ] target_point_cloud = utils.copy_point_cloud(point_cloud, rand_indices) radius = 2.5 neighbors = compute_neighbors.compute_cylinder_neighborhood( point_cloud, target_point_cloud, radius) compute_features(point_cloud, neighbors, target_point_cloud, ["eigenv_1", "eigenv_2", "eigenv_3"], InfiniteCylinder(5)) self.assertEqual( "laserchicken.feature_extractor.eigenvals_feature_extractor", target_point_cloud[keys.provenance][-1]["module"])
def test_valid(self): """Compute the echo ratio for a sphere/cylinder at different target points without crashing.""" # read the data self.point_cloud = load( os.path.join(self._test_data_source, self._test_file_name)) # get the target point clouds random.seed(102938482634) self.target_point_cloud = self._get_random_targets() self.target_point_cloud_index = 0 # volume descriptions radius = 0.5 self.cyl = InfiniteCylinder(radius) neighborhoods = compute_neighborhoods(self.point_cloud, self.target_point_cloud, self.cyl) # extractor extractor = PulsePenetrationFeatureExtractor() extractor.extract(self.point_cloud, neighborhoods, None, None, None)
def setUp(self): self.pointcloud = load( os.path.join(self._test_data_source, self._test_file_name))
def test_points_in_polygon_wkt_Line(): pc_in = load("testdata/AHN2.las") with pytest.raises(ValueError): select_polygon(pc_in, "LINESTRING(3 4,10 50,20 25)")
def test_points_in_polygon_wkt_MultiLine(): pc_in = load("testdata/AHN2.las") with pytest.raises(ValueError): select_polygon( pc_in, "MULTILINESTRING((3 4,10 50,20 25),(-5 -8,-10 -8,-15 -4))")
def assert_none_path_raises_value_error(function): pc_in = load("testdata/AHN2.las") with pytest.raises(Exception): function(pc_in, None, read_from_file=True)
def test_points_in_polygon_shp_invalidPolygon(): pc_in = load("testdata/AHN2.las") with pytest.raises(ValueError): select_polygon(pc_in, "testdata/ahn2_geometries_shp/invalid_polygon.shp", read_from_file=True)
def test_points_in_polygon_shp_MultiLine(): pc_in = load("testdata/AHN2.las") with pytest.raises(ValueError): select_polygon(pc_in, "testdata/ahn2_geometries_shp/multiline.shp", read_from_file=True)
def test_height_stats_without_neighbors(self): pc_in = load("testdata/AHN2.las") neighborhood = [] kurtosis_z = self.extractor.extract(pc_in, [neighborhood], pc_in, None, None)[0] assert np.isnan(kurtosis_z)
def test_points_in_polygon_wkt_MultiPoint(): pc_in = load("testdata/AHN2.las") with pytest.raises(ValueError): select_polygon(pc_in, "MULTIPOINT(3.5 5.6, 4.8 10.5)")
def assert_none_wkt_raises_value_error(function): pc_in = load("testdata/AHN2.las") with pytest.raises(ValueError): function(pc_in, None)
def test_points_in_polygon_wkt_Collection(): pc_in = load("testdata/AHN2.las") with pytest.raises(ValueError): select_polygon( pc_in, "GEOMETRYCOLLECTION(POINT(4 6),LINESTRING(4 6,7 10))")
def setUp(self): self.point_cloud = load( os.path.join(self._test_data_source, self._test_file_name)) random.seed(102938482634)
def test_points_in_polygon_wkt_Collection(): pc_in = load("testdata/AHN2.las") with pytest.raises(ValueError): select_polygon(pc_in, "testdata/ahn2_geometries_wkt/collection.wkt", read_from_file=True)