def test_entropy_in_cylinders(self):
"""Test computing of eigenvalues in cylinder."""
num_all_pc_points = len(self.point_cloud[keys.point]["x"]["data"])
rand_indices = [
random.randint(0, num_all_pc_points) for p in range(20)
]
target_point_cloud = utils.copy_point_cloud(self.point_cloud,
rand_indices)
n_targets = len(target_point_cloud[keys.point]["x"]["data"])
radius = 25
neighbors = compute_neighbors.compute_cylinder_neighborhood(
self.point_cloud, target_point_cloud, radius)
target_idx_base = 0
for x in neighbors:
feature_extractor.compute_features(self.point_cloud,
x,
target_idx_base,
target_point_cloud,
["entropy_z"],
InfiniteCylinder(5),
layer_thickness=0.1)
target_idx_base += len(x)
for i in range(n_targets):
H = utils.get_attribute_value(target_point_cloud, i, "entropy_z")
self.assertTrue(H >= 0)
self.assertEqual(
"laserchicken.feature_extractor.entropy_feature_extractor",
target_point_cloud[keys.provenance][0]["module"])
self.assertEqual([0.1],
target_point_cloud[keys.provenance][0]["parameters"])
def assert_std_for_z_function_in_xy_grid(z_checkered, expected):
"""Assert that the standard deviation of z values in a grid of unit x and y"""
n_points, points = create_points_in_xy_grid(z_checkered)
point_cloud = create_point_cloud(points[:, 0], points[:, 1], points[:, 2])
targets = create_point_cloud([0], [0], [0])
compute_features(point_cloud, [range(n_points)], 0, targets, ['sigma_z'],
InfiniteCylinder(10))
np.testing.assert_almost_equal(targets[keys.point]['sigma_z']['data'][0],
expected)
def test_eigenvalues_of_too_few_points_results_in_0():
"""If there are too few points to calculate the eigen values don't output NaN or inf."""
a = np.array([5])
pc = create_point_cloud(a, a, a)
feature_extractor.compute_features(
pc, [[0]], 0, pc, ["eigenv_1", "eigenv_2", "eigenv_3"],
InfiniteCylinder(5))
eigen_val_123 = np.array(
[pc[keys.point]['eigenv_{}'.format(i)]['data'] for i in [1, 2, 3]])
assert not np.any(np.isnan(eigen_val_123))
assert not np.any(np.isinf(eigen_val_123))
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 = read_las.read(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)
target_idx_base = 0
for x in neighbors:
feature_extractor.compute_features(
point_cloud, x, target_idx_base, target_point_cloud,
["eigenv_1", "eigenv_2", "eigenv_3"], InfiniteCylinder(5))
target_idx_base += len(x)
self.assertEqual(
"laserchicken.feature_extractor.eigenvals_feature_extractor",
target_point_cloud[keys.provenance][0]["module"])
#
neighbors = compute_neighborhoods(pc, target, Cell(np.float(args.radius)))
iteration = 0
target_idx_base = 0
for x in neighbors:
end = time.time()
difftime = end - start
print(("build kd-tree: %f sec") % (difftime))
print("Computed neighborhoods list length at iteration %d is: %d" %
(iteration, len(x)))
start1 = time.time()
print("------ Feature calculation is started ------")
compute_features(pc, x, target_idx_base, target, [
'max_z', 'min_z', 'mean_z', 'median_z', 'std_z', 'var_z',
'coeff_var_z', 'skew_z', 'kurto_z', 'sigma_z', 'perc_20', 'perc_40',
'perc_60', 'perc_80', 'perc_90', 'pulse_penetration_ratio',
'point_density', 'eigenv_1', 'eigenv_2', 'eigenv_3'
], Cell(np.float(args.radius)))
target_idx_base += len(x)
end1 = time.time()
difftime1 = end1 - start1
print(("feature calc: %f sec") % (difftime1))
iteration += 1
write(target, args.output)
#
# example usage: computefea_wtargets_cylinder.py D:/GitHub/eEcoLiDAR/develop-branch/eEcoLiDAR/ D:/GitHub/eEcoLiDAR/myPhD_escience_analysis/test_data/testdata.las D:/GitHub/eEcoLiDAR/myPhD_escience_analysis/test_data/testdata.las 2.5 D:/GitHub/eEcoLiDAR/myPhD_escience_analysis/test_data/testdata.ply
#python D:/GitHub/eEcoLiDAR/myPhD_escience_analysis/test_laserchicken/release1/computefea_wtargets_cell.py D:/GitHub/eEcoLiDAR/develop-branch/eEcoLiDAR/ D:/Koma/Paper1_ReedStructure/Data/ALS/02gz2/testmetrics/tile_00003_norm2.las D:/Koma/Paper1_ReedStructure/Data/ALS/02gz2/testmetrics/tile_00003_norm_target.las 2.5 D:/Koma/Paper1_ReedStructure/Data/ALS/02gz2/testmetrics/testdata.ply
#
print("------ Computing neighborhood is started ------")
#compute_neighborhoods is now a generator. To get the result of a generator the user
#needs to call next(compute_neighborhoods). The following shows how to get the results.
#
#indices_cyl=compute_neighborhoods(pc, target, Cell(np.float(args.radius)))
#
neighbors = compute_neighborhoods(pc, target, Cell(np.float(radius)))
iteration = 0
target_idx_base = 0
for x in neighbors:
print("Computed neighborhoods list length at iteration %d is: %d" %
(iteration, len(x)))
print("------ Feature calculation is started ------")
compute_features(pc, x, target_idx_base, target, [
'min_z', 'max_z', 'mean_z', 'median_z', 'perc_10', 'perc_30',
'perc_50', 'perc_70', 'perc_90', 'point_density', 'eigenv_1',
'eigenv_2', 'eigenv_3', 'z_entropy', 'std_z', 'var_z', 'skew_z',
'kurto_z', 'pulse_penetration_ratio', 'density_absolute_mean'
], Cell(np.float(radius)))
target_idx_base += len(x)
iteration += 1
write(target, filename + str(resolution) + "m_cell.ply")
end1 = time.time()
difftime1 = end1 - start1
print(("feature calc: %f sec") % (difftime1))
print(("Number of points in target: %s ") %
(target[point]['x']['data'].shape[0]))
print("------ Computing neighborhood is started ------")
#compute_neighborhoods is now a generator. To get the result of a generator the user
#needs to call next(compute_neighborhoods). The following shows how to get the results.
#
#indices_cyl=compute_neighborhoods(pc, target, Cell(np.float(args.radius)))
#
neighbors = compute_neighborhoods(pc, target, Cell(np.float(radius)))
iteration = 0
target_idx_base = 0
for x in neighbors:
print("Computed neighborhoods list length at iteration %d is: %d" %
(iteration, len(x)))
print("------ Feature calculation is started ------")
compute_features(pc, x, target_idx_base, target, [
'max_z', 'mean_z', 'median_z', 'perc_10', 'perc_30', 'perc_50',
'perc_70', 'perc_90'
], Cell(np.float(radius)))
target_idx_base += len(x)
iteration += 1
write(target, filename + str(resolution) + "m_cell.ply")
end1 = time.time()
difftime1 = end1 - start1
print(("feature calc: %f sec") % (difftime1))
iteration = 0
target_idx_base = 0
fullstarttime = time.time()
for x in neighbors:
end = time.time()
difftime = end - start
print(("build kd-tree: %f sec") % (difftime))
print("Computed neighborhoods list length at iteration %d is: %d" %
(iteration, len(x)))
start1 = time.time()
print("------ Feature calculation is started ------")
compute_features(pc, x, target_idx_base, target,
['eigenv_1', 'eigenv_2', 'eigenv_3'],
InfiniteCylinder(np.float(args.radius)))
target_idx_base += len(x)
end1 = time.time()
difftime1 = end1 - start1
print(("feature calc: %f sec") % (difftime1))
iteration += 1
fullendtime = time.time()
fulldifftime = fullendtime - fullstarttime
print(fulldifftime)
write(target, args.output)
#
print(("Number of points in target: %s ") %
(target[point]['x']['data'].shape[0]))
print("------ Computing neighborhood is started ------")
#compute_neighborhoods is now a generator. To get the result of a generator the user
#needs to call next(compute_neighborhoods). The following shows how to get the results.
#
#indices_cyl=compute_neighborhoods(pc, target, Cell(np.float(args.radius)))
#
neighbors = compute_neighborhoods(pc, target, Cell(np.float(radius)))
iteration = 0
target_idx_base = 0
for x in neighbors:
print("Computed neighborhoods list length at iteration %d is: %d" %
(iteration, len(x)))
print("------ Feature calculation is started ------")
compute_features(pc, x, target_idx_base, target, [
'max_z', 'min_z', 'mean_z', 'median_z', 'std_z', 'var_z',
'coeff_var_z', 'skew_z', 'kurto_z'
], Cell(np.float(radius)))
target_idx_base += len(x)
iteration += 1
write(target, workingdirectory + filename + "_cell_10m.ply")
end1 = time.time()
difftime1 = end1 - start1
print(("feature calc: %f sec") % (difftime1))
from laserchicken.write_ply import write
print("------ Feature calculation is started ------")
# Import
pc = read_las.read(args.input)
f = open(args.kdtree, 'rb')
kdtree = pickle.load(f)
f.close()
start1 = time.time()
compute_features(pc, kdtree, 0, pc, [
'max_z', 'min_z', 'mean_z', 'median_z', 'std_z', 'var_z', 'range',
'coeff_var_z', 'skew_z', 'kurto_z', 'sigma_z', 'perc_20', 'perc_40',
'perc_60', 'perc_80', 'pulse_penetration_ratio', 'density_absolute_mean'
], Sphere(np.float(args.radius)))
"""
feadataframe=pd.DataFrame({'_x':pc[point]['x']['data'],'_y':pc[point]['y']['data'],'_z':pc[point]['z']['data'],
'max_z':pc[point]['max_z']['data'],'min_z':pc[point]['min_z']['data'], 'mean_z':pc[point]['mean_z']['data'],
'median_z':pc[point]['median_z']['data'],'std_z':pc[point]['std_z']['data'], 'var_z':pc[point]['var_z']['data'],
'range':pc[point]['range']['data'],'coeff_var_z':pc[point]['coeff_var_z']['data'], 'skew_z':pc[point]['skew_z']['data'],'kurto_z':pc[point]['kurto_z']['data'],
'pulse_penetration_ratio':pc[point]['pulse_penetration_ratio']['data'],'density_absolute_mean':pc[point]['density_absolute_mean']['data'],
'sigma_z':pc[point]['sigma_z']['data'], 'perc_20':pc[point]['perc_20']['data'],
'perc_40':pc[point]['perc_40']['data'],'perc_60':pc[point]['perc_60']['data'], 'perc_80':pc[point]['perc_80']['data']})
feadataframe.to_csv(args.output,sep=";",index=False)
"""
end1 = time.time()
#needs to call next(compute_neighborhoods). The following shows how to get the results.
#
#indices_cyl=compute_neighborhoods(pc, target, InfiniteCylinder(np.float(args.radius)))
#
neighbors = compute_neighborhoods(pc, target,
InfiniteCylinder(np.float(args.radius)))
iteration = 0
target_idx_base
for x in neighbors:
end = time.time()
difftime = end - start
print(("build kd-tree: %f sec") % (difftime))
print("Computed neighborhoods list length at iteration %d is: %d" %
(iteration, len(indices_cyl)))
# Calculate features
start1 = time.time()
compute_features(pc, indices_cyl, target_idx_base, target, [
'max_z', 'min_z', 'mean_z', 'median_z', 'std_z', 'var_z', 'range',
'coeff_var_z', 'skew_z', 'kurto_z', 'sigma_z', 'perc_20', 'perc_40',
'perc_60', 'perc_80', 'echo_ratio', 'pulse_penetration_ratio',
'density_absolute_mean'
], InfiniteCylinder(np.float(args.radius)))
end1 = time.time()
difftime1 = end1 - start1
print(("feature calc: %f sec") % (difftime1))
target_idx_base += len(x)
iteration += 1
write(target, args.output)
#needs to call next(compute_neighborhoods). The following shows how to get the results.
#
#indices_cyl=compute_neighborhoods(pc, target, InfiniteCylinder(np.float(args.radius)))
#
neighbors = compute_neighborhoods(pc, target,
InfiniteCylinder(np.float(args.radius)))
iteration = 0
target_idx_base = 0
for x in neighbors:
end = time.time()
difftime = end - start
print(("build kd-tree: %f sec") % (difftime))
print("Computed neighborhoods list length at iteration %d is: %d" %
(iteration, len(x)))
start1 = time.time()
print("------ Feature calculation is started ------")
compute_features(pc, x, target_idx_base, target, [
'max_z', 'echo_ratio', 'eigenv_1', 'eigenv_2', 'eigenv_3',
'normal_vector_1', 'normal_vector_2', 'normal_vector_3', 'slope',
'pulse_penetration_ratio', 'sigma_z'
], InfiniteCylinder(np.float(args.radius)))
target_idx_base += len(x)
end1 = time.time()
difftime1 = end1 - start1
print(("feature calc: %f sec") % (difftime1))
iteration += 1
write(target, args.output)
def _compute_features(target, feature_names, overwrite=False):
neighborhoods = [[] for i in range(len(target["vertex"]["x"]["data"]))]
feature_extractor.compute_features({}, neighborhoods, 0, target,
feature_names, Sphere(5), overwrite)
return target
#indices_cyl=compute_neighborhoods(pc, target, Sphere(2.5))
#
neighbors = compute_neighborhoods(pc, pc, Sphere(2.5))
iteration = 0
target_idx_base = 0
for x in neighbors:
end = time.time()
difftime = end - start
print(("build kd-tree: %f sec") % (difftime))
print("Computed neighborhoods list length at iteration %d is: %d" %
(iteration, len(indices_cyl)))
start1 = time.time()
compute_features(pc, indices_cyl, target_idx_base, pc, [
'max_z', 'min_z', 'mean_z', 'median_z', 'std_z', 'var_z', 'range',
'coeff_var_z', 'skew_z', 'kurto_z', 'eigenv_1', 'eigenv_2', 'eigenv_3',
'z_entropy', 'sigma_z', 'perc_20', 'perc_40', 'perc_60', 'perc_80'
], Sphere(2.5))
feadataframe = pd.DataFrame({
'_x': pc[point]['x']['data'],
'_y': pc[point]['y']['data'],
'_z': pc[point]['z']['data'],
'max_z': pc[point]['max_z']['data'],
'min_z': pc[point]['min_z']['data'],
'mean_z': pc[point]['mean_z']['data'],
'median_z': pc[point]['median_z']['data'],
'std_z': pc[point]['std_z']['data'],
'var_z': pc[point]['var_z']['data'],
'range': pc[point]['range']['data'],
'coeff_var_z': pc[point]['coeff_var_z']['data'],
'skew_z': pc[point]['skew_z']['data'],
