diff --git a/geometry/calipers_box.cpp b/geometry/calipers_box.cpp
index 639ee96b34..c6bff0bcb9 100644
--- a/geometry/calipers_box.cpp
+++ b/geometry/calipers_box.cpp
@@ -61,8 +61,8 @@ void ForEachRect(ConvexHull const & hull, Fn && fn)
     for (size_t i = 0; i < lines.size(); ++i)
     {
       auto const j = (i + 1) % lines.size();
-      auto result = LineIntersector::Intersect(lines[i], lines[j], CalipersBox::kEps);
-      if (result.m_type == LineIntersector::Result::Type::One)
+      auto result = Intersect(lines[i], lines[j], CalipersBox::kEps);
+      if (result.m_type == IntersectionResult::Type::One)
         corners.push_back(result.m_point);
     }
 
diff --git a/geometry/geometry_tests/line2d_tests.cpp b/geometry/geometry_tests/line2d_tests.cpp
index c5c8147f9e..985e0da57f 100644
--- a/geometry/geometry_tests/line2d_tests.cpp
+++ b/geometry/geometry_tests/line2d_tests.cpp
@@ -2,6 +2,7 @@
 
 #include "geometry/line2d.hpp"
 #include "geometry/point2d.hpp"
+#include "geometry/segment2d.hpp"
 
 using namespace m2;
 
@@ -9,15 +10,15 @@ namespace
 {
 double const kEps = 1e-12;
 
-using Result = LineIntersector::Result;
+using Result = IntersectionResult;
 using Type = Result::Type;
 
 Result Intersect(Line2D const & lhs, Line2D const & rhs)
 {
-  return LineIntersector::Intersect(lhs, rhs, kEps);
+  return Intersect(lhs, rhs, kEps);
 }
 
-UNIT_TEST(LineIntersector_Smoke)
+UNIT_TEST(LineIntersection_Smoke)
 {
   {
     Line2D const line(Segment2D(PointD(0, 0), PointD(1, 0)));
diff --git a/geometry/line2d.cpp b/geometry/line2d.cpp
index e11ce3bf04..8fb29fdace 100644
--- a/geometry/line2d.cpp
+++ b/geometry/line2d.cpp
@@ -25,9 +25,7 @@ string DebugPrint(Line2D const & line)
   return os.str();
 }
 
-// static
-LineIntersector::Result LineIntersector::Intersect(Line2D const & lhs, Line2D const & rhs,
-                                                   double eps)
+IntersectionResult Intersect(Line2D const & lhs, Line2D const & rhs, double eps)
 {
   auto const & a = lhs.m_point;
   auto const & ab = lhs.m_direction;
@@ -38,8 +36,8 @@ LineIntersector::Result LineIntersector::Intersect(Line2D const & lhs, Line2D co
   if (Collinear(ab, cd, eps))
   {
     if (Collinear(c - a, cd, eps))
-      return Result(Result::Type::Infinity);
-    return Result(Result::Type::Zero);
+      return IntersectionResult(IntersectionResult::Type::Infinity);
+    return IntersectionResult(IntersectionResult::Type::Zero);
   }
 
   auto const ac = c - a;
@@ -48,12 +46,12 @@ LineIntersector::Result LineIntersector::Intersect(Line2D const & lhs, Line2D co
   auto const d = CrossProduct(ab, cd);
   auto const scale = n / d;
 
-  return Result(a + ab * scale);
+  return IntersectionResult(a + ab * scale);
 }
 
-string DebugPrint(LineIntersector::Result::Type type)
+string DebugPrint(IntersectionResult::Type type)
 {
-  using Type = LineIntersector::Result::Type;
+  using Type = IntersectionResult::Type;
 
   switch (type)
   {
@@ -64,11 +62,11 @@ string DebugPrint(LineIntersector::Result::Type type)
   UNREACHABLE();
 }
 
-string DebugPrint(LineIntersector::Result const & result)
+string DebugPrint(IntersectionResult const & result)
 {
   ostringstream os;
   os << "Result [";
-  if (result.m_type == LineIntersector::Result::Type::One)
+  if (result.m_type == IntersectionResult::Type::One)
     os << DebugPrint(result.m_point);
   else
     os << DebugPrint(result.m_type);
diff --git a/geometry/line2d.hpp b/geometry/line2d.hpp
index fc7b544e1b..ce4a74e707 100644
--- a/geometry/line2d.hpp
+++ b/geometry/line2d.hpp
@@ -9,6 +9,22 @@
 
 namespace m2
 {
+struct IntersectionResult
+{
+  enum class Type
+  {
+    Zero,
+    One,
+    Infinity
+  };
+
+  explicit IntersectionResult(Type type) : m_type(type) { ASSERT_NOT_EQUAL(m_type, Type::One, ()); }
+  explicit IntersectionResult(PointD const & point) : m_point(point), m_type(Type::One) {}
+
+  PointD m_point;
+  Type m_type;
+};
+
 struct Line2D
 {
   Line2D() = default;
@@ -21,28 +37,9 @@ struct Line2D
   PointD m_direction;
 };
 
-struct LineIntersector
-{
-  struct Result
-  {
-    enum class Type
-    {
-      Zero,
-      One,
-      Infinity
-    };
-
-    explicit Result(Type type) : m_type(type) { ASSERT_NOT_EQUAL(m_type, Type::One, ()); }
-    explicit Result(PointD const & point) : m_point(point), m_type(Type::One) {}
-
-    PointD m_point;
-    Type m_type;
-  };
-
-  static Result Intersect(Line2D const & lhs, Line2D const & rhs, double eps);
-};
+IntersectionResult Intersect(Line2D const & lhs, Line2D const & rhs, double eps);
 
 std::string DebugPrint(Line2D const & line);
-std::string DebugPrint(LineIntersector::Result::Type type);
-std::string DebugPrint(LineIntersector::Result const & result);
+std::string DebugPrint(IntersectionResult::Type type);
+std::string DebugPrint(IntersectionResult const & result);
 }  // namespace m2