distance signée entre le plan et le point

Question

Je ne trouve pas de méthode cohérente pour trouver la distance signée entre un point et un plan. Comment puis-je calculer cela étant donné un plan défini comme un point et un normal?

struct Plane 
{ 
    Vec3 point; 
    Vec3 normal; 
} 

Answer 1

Tu fais beaucoup trop compliqué les choses. Si votre normale est normalisée, vous pouvez simplement faire ceci:

float dist = dotProduct(p.normal, (vectorSubtract(point, p.point))); 

Answer 2

ne vous inquiétez pas je comprends exactement ce que vous ressentez. Je suppose que vous voulez des extraits de code. donc vous pouvez l'implémenter dans le vôtre. vous devez faire beaucoup plus de travail que de simplement découvrir le produit scalaire.

Il vous appartient de comprendre cet algorithme et de mettre en œuvre dans votre propre programme ce que je vais faire est de vous donner une implémentation de cet algorithme

distance signée entre le point et le plan

Voici quelques exemples d'implémentations "C++" de ces algorithmes.

// Assume that classes are already given for the objects: 
// Point and Vector with 
//  coordinates {float x, y, z;} 
//  operators for: 
//   Point = Point ± Vector 
//   Vector = Point - Point 
//   Vector = Scalar * Vector (scalar product) 
// Plane with a point and a normal {Point V0; Vector n;} 
//=================================================================== 

// dot product (3D) which allows vector operations in arguments 
#define dot(u,v) ((u).x * (v).x + (u).y * (v).y + (u).z * (v).z) 
#define norm(v) sqrt(dot(v,v)) // norm = length of vector 
#define d(u,v)  norm(u-v)  // distance = norm of difference 

// pbase_Plane(): get base of perpendicular from point to a plane 
// Input: P = a 3D point 
//   PL = a plane with point V0 and normal n 
// Output: *B = base point on PL of perpendicular from P 
// Return: the distance from P to the plane PL 
float 
pbase_Plane(Point P, Plane PL, Point* B) 
{ 
    float sb, sn, sd; 

    sn = -dot(PL.n, (P - PL.V0)); 
    sd = dot(PL.n, PL.n); 
    sb = sn/sd; 

    *B = P + sb * PL.n; 
    return d(P, *B); 
} 

Extrait d'ici: http://www.softsurfer.com/Archive/algorithm_0104/algorithm_0104.htm

PK