I am writing to propose an enhancement for the RevoScan software, used alongside RevoPoint’s 3D scanners. Currently, RevoScan offers various selection tools like the lasso, which are useful for many applications. However, there is a notable gap in functionality, especially evident when working with curved or complex shapes: the absence of a spline selection mode.

Introducing a spline selection tool would be a valuable addition to the existing toolkit. Splines provide greater flexibility and precision, particularly in defining and selecting radii and curves in 3D models. This tool would enable users to create more precise and smoother selection edges, which is particularly beneficial when working with organic forms such as bodies, artistic sculptures, or automotive parts.

The inclusion of a spline selection tool would enhance the user experience of RevoScan, making the software more accessible for a wider range of applications and projects. It would also contribute to improving the accuracy of 3D modeling and editing, ultimately enhancing the quality of the final products.

Optimally, the spline would initially be displayed as a path, allowing users to edit it afterward and thus modify the selection. This feature would offer greater control and accuracy in the selection process, enhancing the overall functionality of the tool.

Yes, you’re right, an editable tool might be a bit too much to ask for. However, a standard spline tool would be a great addition. One could sequentially click points, and a spline would be drawn through these points. An algorithm ( Catmull-Rom-Spline-Algorithm ) could be integrated for this purpose. With each new calculation, the current selection would need to be discarded and reselected. Alternatively, it could be designed so that the algorithm is only applied and the selection made when the spline is closed.

Perfect for curvy shapes!

Again heres an Python Example for doing this:

import numpy as np
import matplotlib.pyplot as plt
def catmull_rom_spline_points(P, num_points=100):
"""
Calculate Catmull-Rom for a list of points and return the combined curve.
"""
def catmull_rom_segment(P0, P1, P2, P3, num_points=100):
"""
Calculate points for a single segment of the Catmull-Rom spline.
"""
# Calculate t0 to t4
def tj(ti, Pi, Pj):
xi, yi, zi = Pi
xj, yj, zj = Pj
return ((xj - xi) ** 2 + (yj - yi) ** 2 + (zj - zi) ** 2) ** 0.5 + ti
t0 = 0
t1 = tj(t0, P0, P1)
t2 = tj(t1, P1, P2)
t3 = tj(t2, P2, P3)
# Only calculate points between P1 and P2
t = np.linspace(t1, t2, num_points)
# Reshape so that we can multiply by the points P0 to P3
# and get a point for each value of t.
t = t.reshape(len(t), 1)
# Calculate the coefficients of the cubic polynomial
A1 = (t1 - t) / (t1 - t0) * P0 + (t - t0) / (t1 - t0) * P1
A2 = (t2 - t) / (t2 - t1) * P1 + (t - t1) / (t2 - t1) * P2
A3 = (t3 - t) / (t3 - t2) * P2 + (t - t2) / (t3 - t2) * P3
B1 = (t2 - t) / (t2 - t0) * A1 + (t - t0) / (t2 - t0) * A2
B2 = (t3 - t) / (t3 - t1) * A2 + (t - t1) / (t3 - t1) * A3
C = (t2 - t) / (t2 - t1) * B1 + (t - t1) / (t2 - t1) * B2
return C
# Ensure the points list is a numpy array
P = np.asarray(P)
# Wrap the points to create a loop
P_extended = np.vstack((P[-2:], P, P[:2]))
# Calculate the Catmull-Rom splines for each segment
splines = np.vstack([catmull_rom_segment(P_extended[i], P_extended[i + 1], P_extended[i + 2], P_extended[i + 3], num_points)
for i in range(len(P))])
return splines
# Define points as a list
points = [np.array([1, 1, 1]), np.array([5, 2, 2]), np.array([8, 7, 3]), np.array([9, 9, 9])]
# Calculate the Catmull-Rom spline points
spline_points = catmull_rom_spline_points(points)
# Plot the spline and control points
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot(spline_points[:, 0], spline_points[:, 1], spline_points[:, 2], 'b')
ax.plot(*zip(*points), 'ro')
plt.show()