Point within a triangle: barycentric co-ordinates - c++

Question

I'm solving a classic problem of determining whether a point is within a triangle, and I'm using the barycentric co-ordinates method.
For some reason (I think it's the logic, not the precision) it doesn't pass all the tests.
What could be wrong?
The code is this:
#include <iostream>
using namespace std;
struct point
{
int x;
int y;
};
bool Place(point &A, point &B, point &C, point &P)
{
double det = (B.y - C.y)*(A.x - C.x) + (C.x - B.x)*(A.y - C.y);
double factor_alpha = (B.y - C.y)*(P.x - C.x) + (C.x - B.x)*(P.y - C.y);
double factor_beta = (C.y - A.y)*(P.x - C.x) + (A.x - C.x)*(P.y - C.y);
double alpha = factor_alpha / det;
double beta = factor_beta / det;
double gamma = 1.0 - alpha - beta;
bool In = false;
if (((A.x == P.x) & (A.y == P.y)) | ((B.x == P.x) & (B.y == P.y)) | ((C.x == P.x) & (C.y == P.y)))
In = true; // the sneaky guys are trying to see if the vertice of the triangle belongs to it
// the problem statement says it does.
if ((alpha == 0) | (beta == 0) | (gamma == 0))
In = true; // the point is on the edge of the triangle
if (( (0 < alpha) & (alpha < 1)) & ((0 < beta) & (beta < 1)) & ((0 < gamma) & (gamma < 1)))
In = true; // in this case P is actually within the triangle area
return In;
}
int main()
{
point A, B, C, P;
cin >> A.x >> A.y >> B.x >> B.y >> C.x >> C.y >> P.x >> P.y;
Place(A, B, C, P) ? cout << "In\n" : cout << "Out\n";
return 0;
}

Answer 1

Your logic says that the point is on the edge if at least one of alpha, beta, or gamma is 0.
That's necessary but not sufficient; the other ones must also be in the interval [0, 1].
Since you're not interested in the "edge" case specifically, you could write
if (0 <= alpha && alpha <= 1 && 0 <= beta && beta <= 1 && 0 <= gamma && gamma <= 1)
In = true;
(I removed some brackets and replaced the bitwise & with the logical &&.)
Readability suggestion:
Introducing a couple of functions makes the code look more like a mathematical definition:
bool operator ==(const point& a, const point& b)
{
return a.x == b.x && a.y == b.y;
}
bool within(double x)
{
return 0 <= x && x <= 1;
}
bool Place(const point &A, const point &B, const point &C, const point &P)
{
double det = (B.y - C.y)*(A.x - C.x) + (C.x - B.x)*(A.y - C.y);
double factor_alpha = (B.y - C.y)*(P.x - C.x) + (C.x - B.x)*(P.y - C.y);
double factor_beta = (C.y - A.y)*(P.x - C.x) + (A.x - C.x)*(P.y - C.y);
double alpha = factor_alpha / det;
double beta = factor_beta / det;
double gamma = 1.0 - alpha - beta;
return P == A || P == B || P == C || (within(alpha) && within(beta) && within(gamma));
}

Answer 2

Try this function (assumes that you have a Point class template where T is the stored type, and also that you have overloaded operator* for computing the dot product):
template <typename T>
bool is_point_in_triangle(const Point<3,T>& p,
const Point<3,T>& a,
const Point<3,T>& b,
const Point<3,T>& c) {
typedef Point<3,T> point_type;
point_type v0 = b-a, v1 = c-a, v2 = p-a;
T d00 = v0*v0;
T d01 = v0*v1;
T d11 = v1*v1;
T d20 = v2*v0;
T d21 = v2*v1;
T denom = d00*d11 - d01*d01;
// compute parametric coordinates
Real v = (d11 * d20 - d01 * d21) / denom;
Real w = (d00 * d21 - d01 * d20) / denom;
return v >= 0. && w >= 0. && v + w <= 1.;
}
As a side note, you're using int to store the coordinates, so your tests may be failing because of the truncation?
Good luck!