2

Perhaps best asked in three parts:

  1. Given five not necessarily coplanar points (in 3 dimensions), what is a good measure of how close to coplanar they are?

  2. Given another set of five not necessarily coplanar points, how can we assess which of these two sets of five points is “more coplanar”?

  3. Given n sets of five not necessarily coplanar points, how can we order these sets of points from “most coplanar” to “least coplanar”?

Suggestions?

I’m working with sets of five points at a time, but will eventually need to consider more points in these sets.

Is this a well-formulated question? An algorithm would be helpful, especially if coded in Python.

Bruce Simonson
  • 171
  • 5
  • @Spektre - thanks for the suggestion. After reading up on 3DOBB, I understand how volume/area might be a suitable metric. I’m wondering if the total surface area of the OBB might be a better denominator? (In the limit of many points, this approach intuitively feels like a convex hull of the points that looks like a sphere would have the highest volume/area ratio and be the “worst coplanar” fit, whereas flattened ellipsoids would have lower volume/area ratios and intuitively seem more coplanar.) In any case, why the smallest_side^2, instead of total surface area of the 3DOBB? – Bruce Simonson May 09 '22 at 14:49
  • I converted the comments into answer (covering #1,#2) with some more explanations ... What you mean by #3 `Given n sets of five not necessarily coplanar points, how can we order these sets of points from “most coplanar” to “least coplanar”?` no matter how you change order of points the coplanarity will not change (unless you throw away points or change their positions) – Spektre May 10 '22 at 06:53
  • Thanks. By “n sets of 5 points” I mean, for example, say I have n=100 samples, each sample with 5 points. I would like to order these 100 samples from “most coplanar” to “least coplanar”. – Bruce Simonson May 11 '22 at 10:55
  • Yes that is possible simply compute the coplanarity coefficient and then (index) sort the sets by it ... – Spektre May 11 '22 at 14:39

3 Answers3

1

I would start with 3D OBB and try to use its dimensions as metrics m. Let a,b,c be the sides of the OBB then for example I would try this:

V = a*b*c             // volume
d = min(a,b,c)        // thickness
S = a*b*c/min(a,b,c)  // area
  = V/d
m = d/S               // cop-lanarity metrics
  = d/(V/d)
  = d^2/V

this will lead to m in range <0 , +inf> where 0 means co-planar however the result will be non linear and maybe you should normalize the result by dividing it with V so you can compare between different PCLs

If you want something linear you can try angle of side and diagonal chose the side with smallest and not biggest side lengths:

diagonal line

m = atan( min(a,b,c) / ( a*b*c / (min(a,b,c)*max(a,b,c)) ) )
    atan( min(a,b,c)^2 * max(a,b,c) / (a*b*c) )

this will lead to angle in range <0deg , 45deg> where 0deg means co-planar. If you want to have something more precise I would add also the other side angle and combine them somehow for example like this:

diagonal lines

m0 = atan( min(a,b,c)^2 * max(a,b,c) / (a*b*c) ) 
m1 = atan( min(a,b,c) / max(a,b,c) )  
m =  0.5*(m0+m1)

If you sort the sides so a<=b<=c then you can rewrite to:

m0 = atan(a/b) 
m1 = atan(a/c)  
m =  0.5*(m0+m1)
Spektre
  • 49,595
  • 11
  • 110
  • 380
1

I would use a simpler approach:

  1. Given your points, compute the best-fit plane.
  2. Compute the point-plane distances.
  3. Compute a metric based on the distances above to measure the quality of the fitting.

So, here is the code in Python (for the best-fit plane computation I use the scikit-spatial library):

Import libraries:

import numpy as np
import matplotlib.pyplot as plt

from skspatial.objects import Plane, Points

Load the points (for the sake of simplicity I have just hardcoded them here, but you will get them from an external source):

points = Points([[2, 0, -1], [1, 0, 0], [0, 4, -2], [6, -2, 5], [-2, -7, 5]])

Compute the best-fit plane:

best_fit_plane = Plane.best_fit(points)

Compute the point-plane distances:

distances = [best_fit_plane.distance_point(point) for point in points]

Compute a metric to measure the quality of the fitting (e.g, a RMSE):

error = np.sqrt(np.dot(distances, distances) / len(distances))

Now, going back to three questions:

  1. Use the error metric.
  2. Use the error as a comparison metric.
  3. Use the distances.

The Points class has an are_coplanarmethod. So, before doing the computation above, check if the points are coplanar in the first place:

points.are_coplanar()
blunova
  • 2,122
  • 3
  • 9
  • 21
1

If you calculate the singular value decomposition (SVD) of the point matrix, you get the semi-axes of an ellipsoid that approximates the shape of the point distribution.

If the point array has a point per row:

points = np.array([(0,0,0), (1,0,1), (0,1,0), (2,0,2), (1,1,1)])

centroid = np.mean(points, axis=0)
_, magnitudes, axes = np.linalg.svd(points - centroid, full_matrices=False)

axes is an array containing the three unitary axes of the ellipsoid, normal to each other. And magnitudes is a vector of non-negative numbers that represent the magninude of each axis. Both are conveniently sorted from high to low magnitude.

The axis of minimum magnitude is normal to the best fitting plane. Along with the centroid you get the plane equation:

>>> normal = axes[2]
>>> normal
array([-7.07106781e-01,  1.11022302e-16,  7.07106781e-01])
>>> centroid
array([0.8, 0.4, 0.8])

The magnitude of the last axis is a measure of coplanarity, where zero represents a perfect plane fit. In this example, the fit is perfect:

>>> dispersion = magnitudes[2]
>>> dispersion
1.5265928729081877e-16

You can use the dispersion value to rank point sets by coplanarity.

aerobiomat
  • 2,883
  • 1
  • 16
  • 19