kolizja punktu z odcinkiem

	bool LinePoint(const int x1, const int y1, const int x2, const int y2,int x3,int y3)
	{
     // zmienne pomocnicze
     int d, dx, dy, ai, bi, xi, yi;
     int x = x1, y = y1;
     // ustalenie kierunku rysowania
     if (x1 < x2)
     {
         xi = 1;
         dx = x2 - x1;
     }
     else
     {
         xi = -1;
         dx = x1 - x2;
     }
     // ustalenie kierunku rysowania
     if (y1 < y2)
     {
         yi = 1;
         dy = y2 - y1;
     }
     else
     {
         yi = -1;
         dy = y1 - y2;
     }
     // pierwszy piksel
	 
	if(x==x3 && y==y3)
		return true;

     // oś wiodąca OX
     if (dx > dy)
     {
         ai = (dy - dx) * 2;
         bi = dy * 2;
         d = bi - dx;
         // pętla po kolejnych x
         while (x != x2)
         {
             // test współczynnika
             if (d >= 0)
             {
                 x += xi;
                 y += yi;
                 d += ai;
             }
             else
             {
                 d += bi;
                 x += xi;
             }
            
			if(x==x3 && y==y3)
				return true;

         }
     }
     // oś wiodąca OY
     else
     {
         ai = ( dx - dy ) * 2;
         bi = dx * 2;
         d = bi - dy;
         // pętla po kolejnych y
         while (y != y2)
         {
             // test współczynnika
             if (d >= 0)
             {
                 x += xi;
                 y += yi;
                 d += ai;
             }
             else
             {
                 d += bi;
                 y += yi;
             }
          
			if(x==x3 && y==y3)
				return true;
         }
     }

	 return false;
	}

bool LinePoint(double line_start_x, double line_start_y, double line_stop_x, double line_stop_y,
               double point_x, double point_y) {
  const double FLOAT_INACCURACY = 1000 * std::numeric_limits<double>::epsilon; // zmienić w ramach potrzeb

  double line_length = std::sqrt((line_start_x - line_stop_x)*(line_start_x - line_stop_x) +
                                 (line_start_y - line_stop_y)*(line_start_y - line_stop_y));

  double distance_from_start = …;
  double distance_from_end = …;

  return std::abs(line_length - distance_from_start - distance_from_end) <= FLOAT_INACCURACY;
}

bool isPointInLine(sf::Vector2f point, sf::Vector2f line_start, sf::Vector2f line_end) {

    const float delta = 1000 * std::numeric_limits<float>::epsilon();

    float line_len = sqrt(pow(line_end.x - line_start.x, 2) + pow(line_end.y - line_start.y, 2));

    float distance_from_start = sqrt(pow(line_start.x - point.x, 2) + pow(line_start.y - point.y, 2));
    float distance_from_end = sqrt(pow(line_end.x - point.x, 2) + pow(line_end.y - point.y, 2));

    return std::abs(line_len - distance_from_start - distance_from_end) <= delta;

}

#include <iostream>
#include <limits>

int main() {
    std::cout << "Epsilon dla float: " << std::numeric_limits<float>::epsilon() << '\n';
    return 0;
}

#include <iostream>

int main() {
    float epsilon = 1.0f;

    while ((1.0f + epsilon) != 1.0f) {
        epsilon /= 2.0f;
    }

    epsilon *= 2.0f; // ostatnia wartość, która jeszcze zmienia wynik

    std::cout << "Epsilon (float): " << epsilon << '\n';

    return 0;
}

abs(line_len - distance_from_start - distance_from_end) <= delta;

namespace geometry {
using Real = double;

struct Point {
    Real x = {};
    Real y = {};
};

struct Vect {
    Real dx;
    Real dy;

    [[nodiscard]] constexpr Real length() const noexcept
    {
        return std::sqrt(dx * dx + dy * dy);
    }

    [[nodiscard]] constexpr Vect normalized() const noexcept
    {
        auto len = length();
        return { dx / len, dy / len };
    }

    [[nodiscard]] constexpr Vect left90() const noexcept
    {
        return { -dy, dx };
    }

    [[nodiscard]] constexpr Vect right90() const noexcept
    {
        return { dy, -dx };
    }

    [[nodiscard]] Real angle() const noexcept
    {
        return std::atan2(dy, dx);
    }
};

[[nodiscard]] constexpr Vect operator-(Point a, Point b) noexcept
{
    return { a.x - b.x, a.y - b.y };
}

[[nodiscard]] constexpr Point operator+(Vect v, Point p) noexcept
{
    return { v.dx + p.x, v.dy + p.y };
}

[[nodiscard]] constexpr Real operator*(Vect v, Point p) noexcept
{
    return v.dx * p.x + v.dy * p.y;
}

[[nodiscard]] constexpr Vect operator*(Vect v, Real fac) noexcept
{
    return { v.dx * fac, v.dy * fac };
}

class Line {
    Vect ab;
    Real c;

public:
    Line(Vect direction, Point p0)
        : ab { direction.left90().normalized() }
        , c { -(ab * p0) }
    {
    }

    Line(Point a, Point b)
        : Line(b - a, a)
    {
    }

    Real distanceTo(Point p) const
    {
        assert(std::abs(ab.length() - 1.0) < std::numeric_limits<Real>::epsilon() * 8);
        return ab * p + c;
    }
};

class LineSegmentTester {
    Line line;
    Line symetry;
    Real halfLen;

public:
    LineSegmentTester(Point a, Point b)
        : line { a, b }
        , symetry { (b - a).left90(), (b - a) * 0.5 + a }
        , halfLen { (a - b).length() * 0.5 }
    {
    }

    [[nodiscard]] bool test(Point p, Real epsilon) const noexcept
    {
        return std::abs(line.distanceTo(p)) <= epsilon && std::abs(symetry.distanceTo(p)) <= halfLen + epsilon;
    }
};
}