def laplacian_then_bilateral_opc(opc, loops_laplacian=5, _lambda=1.0, kernel_size=3, loops_bilateral=0, sigma_length=0.1, sigma_angle=0.261, **kwargs):
"""Performs Laplacian Smoothing on Point Cloud and then performs Bilateral normal smoothing
Arguments:
opc {ndarray} -- Organized Point Cloud (MXNX3)
Keyword Arguments:
loops_laplacian {int} -- How many iterations of laplacian smoothing (default: {5})
_lambda {float} -- Weigh factor for laplacian (default: {0.5})
kernel_size {int} -- Kernel Size for Laplacian (default: {3})
loops_bilateral {int} -- How many iterations of bilateral smoothing (default: {0})
sigma_length {float} -- Scaling factor for length bilateral (default: {0.1})
sigma_angle {float} -- Scaling factor for angle bilateral (default: {0.261})
Returns:
tuple(ndarray, ndarray) -- Smoothed OPC MXNX3, Smoothed Normals M*NX3, normals arrays are flattened
"""
opc_float = (np.ascontiguousarray(opc[:, :, :3])).astype(np.float32)
a_ref = Matrix3fRef(opc_float)
t1 = time.perf_counter()
if kernel_size == 3:
b_cp = opf.filter.laplacian_K3(a_ref, _lambda=_lambda, iterations=loops_laplacian, **kwargs)
else:
b_cp = opf.filter.laplacian_K5(a_ref, _lambda=_lambda, iterations=loops_laplacian, **kwargs)
t2 = time.perf_counter()
logging.debug("OPC Mesh Smoothing Took (ms): %.2f", (t2 - t1) * 1000)
opc_float_out = np.asarray(b_cp)
b_ref = Matrix3fRef(opc_float_out)
opc_normals_float = opf.filter.bilateral_K3(
b_ref, iterations=loops_bilateral, sigma_length=sigma_length, sigma_angle=sigma_angle)
t3 = time.perf_counter()
logging.debug("OPC Bilateral Normal Filter Took (ms): %.2f", (t3 - t2) * 1000)
opc_normals_float_out = np.asarray(opc_normals_float)
total_triangles = int(opc_normals_float_out.size / 3)
opc_normals_out = opc_normals_float_out.astype(np.float64)
opc_normals_out = opc_normals_float_out.reshape((total_triangles, 3))
opc_out = opc_float_out.astype(np.float64)
# total_points = int(opc_out.size / 3)
# opc_out = opc_out.reshape((total_points, 3))
timings = dict(t_laplacian=(t2-t1)*1000, t_bilateral=(t3-t2)*1000)
return opc_out, opc_normals_out, timings
def bilateral_opc(opc, loops=5, sigma_length=0.1, sigma_angle=0.261, **kwargs):
"""Performs bilateral normal smoothing on a mesh implicit from an organized point
Arguments:
opc {ndarray} -- Organized Point Cloud MXNX3, Assumed Float 64
Keyword Arguments:
loops {int} -- How many iterations of smoothing (default: {5})
sigma_length {float} -- Saling factor for length (default: {0.1})
sigma_angle {float} -- Scaling factor for angle (default: {0.261})
Returns:
ndarray -- MXNX2X3 Triangle Normal Array, Float 64
"""
opc_float = (np.ascontiguousarray(opc[:, :, :3])).astype(np.float32)
a_ref = Matrix3fRef(opc_float)
t1 = time.perf_counter()
normals = opf.filter.bilateral_K3(a_ref,
iterations=loops,
sigma_length=sigma_length,
sigma_angle=sigma_angle)
t2 = time.perf_counter()
logger.info("OPC Bilateral Filter Took (ms): %.2f", (t2 - t1) * 1000)
normals_float_out = np.asarray(normals)
normals_out = normals_float_out.astype(np.float64)
return normals_out
def compute_normals_and_centroids_opc(opc, convert_f64=True, **kwargs):
"""Computes the Normals and Centroid of Implicit Triangle Mesh in the Organized Point Cloud
Arguments:
opc {ndarray} -- MXNX3
Keyword Arguments:
convert_f64 {bool} -- Return F64? (default: {True})
Returns:
ndarray -- Numpy array
"""
opc_float = (np.ascontiguousarray(opc[:, :, :3])).astype(np.float32)
a_ref = Matrix3fRef(opc_float)
t1 = time.perf_counter()
normals, centroids = opf.filter.compute_normals_and_centroids(a_ref)
t2 = time.perf_counter()
logger.info("OPC Compute Normals and Centroids Took (ms): %.2f",
(t2 - t1) * 1000)
normals_float_out = np.asarray(normals)
centroids_float_out = np.asarray(centroids)
if not convert_f64:
return (normals_float_out, centroids_float_out)
return (normals_float_out.astype(np.float64),
centroids_float_out.astype(np.float64))
def laplacian_opc(opc, loops=5, _lambda=0.5, kernel_size=3, **kwargs):
"""Performs Laplacian Smoothing on an organized point cloud
Arguments:
opc {ndarray} -- Organized Point Cloud MXNX3, Assumed F64
Keyword Arguments:
loops {int} -- How many iterations of smoothing (default: {5})
_lambda {float} -- Weight factor for update (default: {0.5})
kernel_size {int} -- Kernel Size (How many neighbors to intregrate) (default: {3})
Returns:
ndarray -- Smoothed Point Cloud, MXNX3, F64
"""
opc_float = (np.ascontiguousarray(opc[:, :, :3])).astype(np.float32)
a_ref = Matrix3fRef(opc_float)
t1 = time.perf_counter()
if kernel_size == 3:
b_cp = opf.filter.laplacian_K3(a_ref, _lambda=_lambda, iterations=loops, **kwargs)
else:
b_cp = opf.filter.laplacian_K5(a_ref, _lambda=_lambda, iterations=loops, **kwargs)
t2 = time.perf_counter()
logging.debug("OPC Mesh Smoothing Took (ms): %.2f", (t2 - t1) * 1000)
opc_float_out = np.asarray(b_cp)
opc_out = opc_float_out.astype(np.float64)
time_elapsed = (t2 - t1) * 1000
return opc_out, time_elapsed
def bench_cuda_opc(opc, loops):
a_ref = Matrix3fRef(opc)
normals, centroids = opf.filter.compute_normals_and_centroids(a_ref)
normals_float = np.asarray(normals)
centroid_float = np.asarray(centroids)
# normals_opc, centroids_opc = compute_normals_and_centroids_opc(opc, convert_f64=False)
b = opf_cuda.kernel.bilateral_K3_cuda(normals_float, centroid_float, loops)
return b
def main():
a = np.random.randn(5, 5, 3).astype(np.float32)
a_ref = Matrix3fRef(a)
print("Call by Ref (same memory buffer")
print(get_np_buffer_ptr(a))
print(get_np_buffer_ptr(np.asarray(a_ref)))
print(a)
b_ref = opf.filter.laplacian_K3(a_ref, iterations=1)
print("Result")
print(np.asarray(b_ref))
def compute_normals_opc(opc, **kwargs):
opc_float = (np.ascontiguousarray(opc[:, :, :3])).astype(np.float32)
a_ref = Matrix3fRef(opc_float)
t1 = time.perf_counter()
normals = opf.filter.compute_normals(a_ref)
t2 = time.perf_counter()
logger.info("OPC Compute Normals Took (ms): %.2f", (t2 - t1) * 1000)
normals_float_out = np.asarray(normals)
normals_out = normals_float_out.astype(np.float64)
return normals_out
def main():
a = np.arange(5 * 5 * 3).reshape((5, 5, 3)).astype(np.float32)
print(f"Original Memory Buffer {get_np_buffer_ptr(a)}")
print(a.shape)
print(a)
print("By Ref")
b = Matrix3fRef(a)
c = np.asarray(b)
print(f"By Ref Memory Buffer {get_np_buffer_ptr(c)}")
print(c.shape)
print(c)
print("Check with Copy!!")
b = Matrix3f(a)
print(b)
c = np.asarray(b)
print(c)
print(c.shape)
print(get_np_buffer_ptr(c))
def test_cpu_bilateral_k3_rgbd1(rgbd1, loops, benchmark):
"""
Will benchmark bilateral cpu
"""
a = Matrix3fRef(rgbd1)
b = benchmark(opf.filter.bilateral_K3, a, loops)