Got it, let's solve this problem without losing any precision. The core issue here is that cv2.convexHull() expects integer coordinates, but your points are float64 values in [-10, 10]. The key insight is that convex hull depends on relative positions of points, not their absolute scale—so we can safely scale and convert our float points to integers, compute the convex hull, then scale back to get the original float coordinates.

Step-by-Step Approach #

Here's the plan to avoid precision loss:

• Scale float points to integers: Since your values are between -10 and 10, we can multiply them by a large enough integer factor to turn all decimal values into whole numbers. Float64 can precisely represent integers up to 2^53 (around 9e15), so even multiplying by 1e6 gives us values well within this safe range.
• Compute convex hull on integer points: Use cv2.convexHull() as usual on the scaled integer array.
• Scale back to original float coordinates: Divide the convex hull result by the same scaling factor to get back to your original coordinate system.

Code Implementation #

import numpy as np
import cv2

# Example float64 point set (replace with your actual data)
original_pts = np.random.uniform(-10, 10, (100, 2)).astype(np.float64)

# Choose a scaling factor large enough to eliminate decimals
# 1e6 works for up to 6 decimal places, which covers most use cases
scale_factor = 1e6

# Convert to integer points (no precision loss here)
scaled_pts = (original_pts * scale_factor).astype(np.int64)

# Calculate convex hull on integer points
hull_scaled = cv2.convexHull(scaled_pts)

# Convert back to original float coordinates
hull_original = hull_scaled.astype(np.float64) / scale_factor

# Optional: Visualize to verify
import matplotlib.pyplot as plt
plt.scatter(original_pts[:, 0], original_pts[:, 1], s=12, label='Original Points')
plt.plot(hull_original[:, 0, 0], hull_original[:, 0, 1], 'r-', linewidth=2, label='Convex Hull')
plt.legend()
plt.title('Convex Hull for Float64 Points')
plt.show()

Why This Works Without Precision Loss #

• Float64 can exactly represent all integers up to 2^53. Since our scaled values (10 * 1e6 = 1e7) are way smaller than this limit, converting from float64 to int64 doesn't lose any data.
• When we scale back, dividing by the same factor reverses the transformation perfectly—no rounding errors introduced.

Notes #

• If your points have fewer decimal places (e.g., only 2), you can use a smaller scale factor like 100 to speed up calculations. 1e6 is just a safe universal choice.
• Avoid using np.round() before converting to integers—direct multiplication and casting works because the scaled float values are exact integers (thanks to float64's precision).

内容的提问来源于stack exchange，提问作者Hal Jarrett