ImplicitSurfaceNetwork/surface_integral/test/test_winding_number.cpp

// main.cpp
#include "polygon_winding_number.h"
#include <iostream>
#include <vector>
#include <string>
#include <cassert>

// -----------------------------
// Test Case Definition
// -----------------------------

struct TestCase {
    std::string              name;
    PolygonRing              outer_ring;
    std::vector<PolygonRing> holes;
    Point2d                  query_point;
    bool                     expected; // true = inside, false = outside
};

// -----------------------------
// Helper: Print Point
// -----------------------------
std::ostream& operator<<(std::ostream& os, const Point2d& p) { return os << "(" << p.x() << ", " << p.y() << ")"; }

// -----------------------------
// Helper: Validate Ring Orientation
// -----------------------------
bool validate_orientation()
{
    // Test CCW (positive area)
    PolygonRing ccw = {
        {0, 0},
        {1, 0},
        {1, 1},
        {0, 1}
    };
    if (compute_ring_area(ccw) <= 0) {
        std::cerr << "Error: CCW ring has non-positive area!\n";
        return false;
    }

    // Test CW (negative area)
    PolygonRing cw = {
        {0, 0},
        {0, 1},
        {1, 1},
        {1, 0}
    };
    if (compute_ring_area(cw) >= 0) {
        std::cerr << "Error: CW ring has non-negative area!\n";
        return false;
    }
    return true;
}

// -----------------------------
// Validate Test Case: Orientation of outer ring (CCW) and holes (CW)
// -----------------------------
bool validate_test_case(const TestCase& tc)
{
    bool        valid  = true;
    std::string status = "";

    // Validate outer ring orientation (should be CCW → positive area)
    double outer_area = compute_ring_area(tc.outer_ring);
    if (outer_area <= 0) {
        status += "Outer ring not CCW (area = " + std::to_string(outer_area) + ")";
        valid   = false;
    }

    // Validate holes orientation (should be CW → negative area)
    for (size_t i = 0; i < tc.holes.size(); ++i) {
        double hole_area = compute_ring_area(tc.holes[i]);
        if (hole_area >= 0) {
            if (!status.empty()) status += ", ";
            status += "Hole " + std::to_string(i) + " not CW (area = " + std::to_string(hole_area) + ")";
            valid   = false;
        }
    }

    if (valid) return true;

    std::cout << "["
              << "\033[33mINVALID\033[0m" // make "INVALID" yellow
              << "] " << tc.name << "\n"
              << "    Query: " << tc.query_point << " | Status: \033[33mInvalid Test Case\033[0m"
              << " | Reason: " << (valid ? "OK" : status) << "\n";

    return valid;
}

// -----------------------------
// Run Single Test
// -----------------------------
bool run_test(const TestCase& tc)
{
    bool result = point_in_polygon_with_holes(tc.query_point, tc.outer_ring, tc.holes);
    bool passed = (result == tc.expected);

    std::cout << "[" << (passed ? "\033[32mPASS\033[0m" : "\033[31mFAIL\033[0m") << "] " << tc.name << "\n"
              << "    Query: " << tc.query_point << " | Expected: " << (tc.expected ? "Inside" : "Outside")
              << " | Got: " << (result ? "Inside" : "Outside") << "\n";

    return passed;
}

// -----------------------------
// Test Case Factory Functions
// -----------------------------

std::vector<TestCase> create_test_cases()
{
    std::vector<TestCase> tests;


    // --------------------------------------------------
    // Test 1: Simple hole - point inside hole → Outside
    // --------------------------------------------------
    PolygonRing outer1 = {
        {0, 0},
        {2, 0},
        {2, 2},
        {0, 2}
    };
    PolygonRing hole1 = {
        {0.5, 0.5},
        {0.5, 1.5},
        {1.5, 1.5},
        {1.5, 0.5}
    };
    tests.push_back({
        "Inside Hole",
        outer1,
        {hole1},
        {1.0, 1.0},
        false
    });

    // --------------------------------------------------
    // Test 2: Point inside outer, outside all holes → Inside
    // --------------------------------------------------
    tests.push_back({
        "Inside Outer, Outside Hole",
        outer1,
        {hole1},
        {0.1, 0.1},
        true
    });

    // --------------------------------------------------
    // Test 3: Point outside outer ring → Outside
    // --------------------------------------------------
    tests.push_back({
        "Outside Outer",
        outer1,
        {hole1},
        {3.0, 3.0},
        false
    });

    // --------------------------------------------------
    // Test 4: Point on outer ring edge (bottom edge)
    // Winding rule: on boundary → considered inside
    // --------------------------------------------------
    tests.push_back({
        "On Outer Edge (Bottom)",
        outer1,
        {},
        {1.0, 0.0},
        true
    });

    // --------------------------------------------------
    // Test 5: Point on outer ring vertex
    // --------------------------------------------------
    tests.push_back({
        "On Outer Vertex Offset Slightly Outside",
        outer1,
        {},
        {0.0, 0.0 - 1e-8},
        false
    });

    // --------------------------------------------------
    // Test 6: Point on hole edge
    // Should be outside (on hole boundary still "outside" the solid)
    // --------------------------------------------------
    PolygonRing hole6 = {
        {1.0, 1.0},
        {1.0, 2.0},
        {2.0, 2.0},
        {2.0, 1.0}
    }; // CW
    tests.push_back({
        "On Hole Edge",
        {{0, 0}, {3, 0}, {3, 3}, {0, 3}},
        {hole6},
        {1.5, 1.0},
        false
    });

    // --------------------------------------------------
    // Test 7: Multiple holes
    // --------------------------------------------------
    PolygonRing hole7a = {
        {0.5, 0.5},
        {0.5, 1.0},
        {1.0, 1.0},
        {1.0, 0.5}
    }; // CW
    PolygonRing hole7b = {
        {1.5, 1.5},
        {1.5, 2.0},
        {2.0, 2.0},
        {2.0, 1.5}
    }; // CW
    tests.push_back({
        "Multiple Holes - Inside",
        outer1,
        {hole7a, hole7b},
        {0.1,    0.1   },
        true
    });

    tests.push_back({
        "Multiple Holes - In First Hole",
        outer1,
        {hole7a, hole7b},
        {0.7,    0.7   },
        false
    });

    tests.push_back({
        "Multiple Holes - In Second Hole",
        outer1,
        {hole7a, hole7b},
        {1.7,    1.7   },
        false
    });

    // --------------------------------------------------
    // Test 8: Nested holes (hole inside hole) - NOT standard, but test behavior
    // Note: This is not valid in simple polygons, but test robustness
    // --------------------------------------------------
    PolygonRing outer8 = {
        {0, 0},
        {3, 0},
        {3, 3},
        {0, 3}
    };
    PolygonRing hole8a = {
        {0.5, 0.5},
        {0.5, 2.5},
        {2.5, 2.5},
        {2.5, 0.5}
    }; // large hole
    PolygonRing hole8b = {
        {1.0, 1.0},
        {1.0, 2.0},
        {2.0, 2.0},
        {2.0, 1.0}
    }; // small hole inside hole8a
    // This creates a "island" in the hole
    tests.push_back({
        "Nested Holes - On Island",
        outer8,
        {hole8a, hole8b},
        {1.5,    1.5   },
        true  // inside outer, inside hole8a, but outside hole8b → solid
    });

    // --------------------------------------------------
    // Test 9: Complex L-shaped polygon with hole
    // --------------------------------------------------
    PolygonRing outer9 = {
        {0, 0},
        {3, 0},
        {3, 1},
        {2, 1},
        {2, 3},
        {0, 3},
        {0, 0}  // L-shape, explicitly closed and no self-intersection
    }; // CCW
    PolygonRing hole9 = {
        {0.5, 0.5},
        {0.5, 1.5},
        {1.5, 1.5},
        {1.5, 0.5}
    }; // CW
    tests.push_back({
        "L-Shape with Hole - Inside Leg",
        outer9,
        {hole9},
        {0.1, 0.1},
        true
    });
    tests.push_back({
        "L-Shape with Hole - In Hole",
        outer9,
        {hole9},
        {1.0, 1.0},
        false
    });
    tests.push_back({
        "L-Shape with Hole - In Arm",
        outer9,
        {hole9},
        {2.0, 0.5},
        true
    });

    // --------------------------------------------------
    // Test 10: Degenerate: Point exactly at intersection of hole and outer? (not possible, but test near)
    // --------------------------------------------------
    tests.push_back({
        "Near Degenerate - Close to Corner",
        outer1,
        {hole1},
        {0.5000001, 0.5000001},
        false  // just outside hole
    });

    return tests;
}

// -----------------------------
// Main Function
// -----------------------------
int main()
{
    std::cout << "Running Polygon Winding Number Tests...\n\n";

    // Optional: Validate orientation logic
    if (!validate_orientation()) {
        std::cerr << "Orientation validation failed!\n";
        return 1;
    }

    auto test_cases = create_test_cases();

    int passed = 0;
    int total  = test_cases.size();

    for (const auto& tc : test_cases) {
        if (!validate_test_case(tc)) { continue; }
        if (run_test(tc)) { passed++; }
    }

    std::cout << "\nSummary: " << passed << " / " << total << " tests passed.\n";

    if (passed == total) {
        std::cout << "\033[32m All tests passed!\033[0m\n";
        return 0;
    } else {
        std::cout << "\033[31m Some tests failed!\033[0m\n";
        return 1;
    }
}