d6/d7f/tikzgeom__algorithms__test_8cc_source.html

#include <gtest/gtest.h>


#include <cctype>

#include <sstream>

#include <string>

#include <vector>


#include <tikzgeom_algorithms.H>

#include <tikzgeom_scene.H>


using namespace Aleph;


namespace

{


bool has_nan_or_inf(std::string s)

{

  for (char & c : s)

    c = static_cast<char>(::tolower(static_cast<unsigned char>(c)));


  return s.find("nan") != std::string::npos or

         s.find("inf") != std::string::npos;

}


Polygon make_convex_a()

{

  Polygon p;

  p.add_vertex(Point(-20, -10));

  p.add_vertex(Point(10, -12));

  p.add_vertex(Point(18, 4));

  p.add_vertex(Point(-8, 18));

  p.close();

  return p;

}


Polygon make_convex_b()

{

  Polygon p;

  p.add_vertex(Point(-14, -18));

  p.add_vertex(Point(22, -2));

  p.add_vertex(Point(8, 22));

  p.add_vertex(Point(-18, 8));

  p.close();

  return p;

}


Polygon make_shortest_path_polygon()

{

  Polygon p;

  p.add_vertex(Point(0, 0));

  p.add_vertex(Point(20, 0));

  p.add_vertex(Point(20, 20));

  p.add_vertex(Point(12, 20));

  p.add_vertex(Point(12, 8));

  p.add_vertex(Point(8, 8));

  p.add_vertex(Point(8, 20));

  p.add_vertex(Point(0, 20));

  p.close();

  return p;

}


Polygon make_concave_for_decomposition()

{

  Polygon p;

  p.add_vertex(Point(0, 0));

  p.add_vertex(Point(12, 0));

  p.add_vertex(Point(12, 10));

  p.add_vertex(Point(7, 10));

  p.add_vertex(Point(7, 4));

  p.add_vertex(Point(4, 4));

  p.add_vertex(Point(4, 10));

  p.add_vertex(Point(0, 10));

  p.close();

  return p;

}


Polygon make_convex_for_calipers()

{

  Polygon p;

  p.add_vertex(Point(-10, -4));

  p.add_vertex(Point(10, -6));

  p.add_vertex(Point(16, 2));

  p.add_vertex(Point(7, 12));

  p.add_vertex(Point(-8, 10));

  p.close();

  return p;

}


Polygon make_visibility_polygon()

{

  Polygon p;

  p.add_vertex(Point(0, 0));

  p.add_vertex(Point(20, 0));

  p.add_vertex(Point(20, 18));

  p.add_vertex(Point(11, 18));

  p.add_vertex(Point(11, 8));

  p.add_vertex(Point(7, 8));

  p.add_vertex(Point(7, 18));

  p.add_vertex(Point(0, 18));

  p.close();

  return p;

}


size_t count_points(const DynList<Point> & pts)

{

  size_t n = 0;

  for (DynList<Point>::Iterator it(pts); it.has_curr(); it.next_ne())

    ++n;

  return n;

}


size_t count_points(const Array<Point> & pts)

{

  return pts.size();

}


} // namespace


TEST(TikzGeomAlgorithmsTest, LayerOrderIsRespected)

{

  Tikz_Plane plane(100, 60);


  Tikz_Style back = tikz_wire_style("green");

  Tikz_Style front = tikz_wire_style("red");


  put_in_plane(plane, Segment(Point(0, 0), Point(50, 50)), front, 10);

  put_in_plane(plane, Segment(Point(0, 50), Point(50, 0)), back, -10);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();


  const size_t green_pos = result.find("draw=green");

  const size_t red_pos = result.find("draw=red");


  ASSERT_NE(green_pos, std::string::npos);

  ASSERT_NE(red_pos, std::string::npos);

  EXPECT_LT(green_pos, red_pos);

}


TEST(TikzGeomAlgorithmsTest, VisualizeConvexHull)

{

  DynList<Point> pts;

  pts.append(Point(-15, -8));

  pts.append(Point(-8, 10));

  pts.append(Point(0, -10));

  pts.append(Point(8, 8));

  pts.append(Point(14, -3));

  pts.append(Point(2, 16));


  Tikz_Plane plane(120, 80);

  AndrewMonotonicChainConvexHull hull_algo;


  Polygon hull = visualize_convex_hull(

      plane, pts, hull_algo,

      tikz_points_style("black"),

      tikz_wire_style("red"),

      tikz_points_style("red"));


  EXPECT_GE(hull.size(), 3U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();


  EXPECT_NE(result.find("draw=red"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeConvexIntersection)

{

  const Polygon a = make_convex_a();

  const Polygon b = make_convex_b();


  Tikz_Plane plane(120, 80);

  Polygon inter = visualize_convex_intersection(plane, a, b);


  EXPECT_GT(inter.size(), 0U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();


  EXPECT_NE(result.find("fill=red!30"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeVoronoi)

{

  DynList<Point> sites;

  sites.append(Point(-18, -8));

  sites.append(Point(-6, 14));

  sites.append(Point(8, -10));

  sites.append(Point(16, 9));

  sites.append(Point(2, 20));


  Tikz_Plane plane(150, 100);

  const auto vor = visualize_voronoi(plane, sites, VoronoiDiagram(), true);


  EXPECT_EQ(vor.sites.size(), 5U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();


  EXPECT_NE(result.find("dashed"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeDelaunay)

{

  DynList<Point> points;

  points.append(Point(-12, -8));

  points.append(Point(-8, 9));

  points.append(Point(0, 14));

  points.append(Point(11, 9));

  points.append(Point(14, -7));

  points.append(Point(2, -13));

  points.append(Point(0, 0));


  Tikz_Plane plane(160, 110);

  const auto dt = visualize_delaunay(plane, points);


  EXPECT_GE(dt.sites.size(), 5U);

  EXPECT_GT(dt.triangles.size(), 0U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();

  EXPECT_NE(result.find("draw=blue"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizePowerDiagram)

{

  Array<PowerDiagram::WeightedSite> sites;

  sites.append({Point(-16, -6), Geom_Number(1)});

  sites.append({Point(-2, 12), Geom_Number(4)});

  sites.append({Point(12, -8), Geom_Number(2)});

  sites.append({Point(18, 10), Geom_Number(6)});


  Tikz_Plane plane(150, 100);

  const auto pd = visualize_power_diagram(plane, sites);


  EXPECT_EQ(pd.sites.size(), 4U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();


  EXPECT_NE(result.find("violet"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeSegmentArrangement)

{

  Array<Segment> segments;

  segments.append(Segment(Point(-20, 0), Point(20, 0)));

  segments.append(Segment(Point(0, -20), Point(0, 20)));

  segments.append(Segment(Point(-20, -20), Point(20, 20)));


  Tikz_Plane plane(150, 100);

  const auto arrangement = visualize_segment_arrangement(

      plane, segments, SegmentArrangement(),

      true, true, false,

      tikz_area_style("teal!60!black", "teal!12", 0.30),

      tikz_wire_style("teal!70!black"),

      tikz_points_style("teal!70!black"),

      true);


  EXPECT_GT(arrangement.vertices.size(), 4U);

  EXPECT_GT(arrangement.edges.size(), 3U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();


  EXPECT_NE(result.find("teal!70!black"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeSegmentArrangementFaceColoring)

{

  Array<Segment> segments;

  segments.append(Segment(Point(0, 0), Point(20, 0)));

  segments.append(Segment(Point(20, 0), Point(20, 20)));

  segments.append(Segment(Point(20, 20), Point(0, 20)));

  segments.append(Segment(Point(0, 20), Point(0, 0)));

  segments.append(Segment(Point(0, 0), Point(20, 20)));


  Tikz_Plane plane(150, 100);

  const auto arrangement = visualize_segment_arrangement(

      plane, segments, SegmentArrangement(),

      true, true, false,

      tikz_area_style("teal!60!black", "teal!12", 0.30),

      tikz_wire_style("teal!70!black"),

      tikz_points_style("teal!70!black"),

      true);


  EXPECT_GT(arrangement.faces.size(), 1U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();


  EXPECT_NE(result.find("blue!20"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeShortestPathInPolygon)

{

  const Polygon polygon = make_shortest_path_polygon();

  const Point source(2, 16);

  const Point target(18, 16);


  Tikz_Plane plane(170, 110);

  const auto path = visualize_shortest_path_in_polygon(

      plane, polygon, source, target, ShortestPathInPolygon());


  EXPECT_GE(count_points(path), 2U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();


  EXPECT_NE(result.find("draw=red"), std::string::npos);

  EXPECT_NE(result.find("fill=green!50!black"), std::string::npos);

  EXPECT_NE(result.find("fill=blue"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeAlphaShape)

{

  DynList<Point> points;

  points.append(Point(-12, -8));

  points.append(Point(-10, 9));

  points.append(Point(-1, 14));

  points.append(Point(10, 10));

  points.append(Point(13, -7));

  points.append(Point(0, -13));

  points.append(Point(0, 0));


  Tikz_Plane plane(170, 110);

  const auto alpha_shape = visualize_alpha_shape(

      plane, points, Geom_Number(10000), AlphaShape(),

      true);


  EXPECT_GT(alpha_shape.boundary_edges.size(), 0U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();


  EXPECT_NE(result.find("orange!90!black"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeRegularTriangulation)

{

  Array<RegularTriangulationBowyerWatson::WeightedSite> sites;

  sites.append({Point(-10, -6), Geom_Number(0)});

  sites.append({Point(-2, 10), Geom_Number(2)});

  sites.append({Point(10, -4), Geom_Number(1)});

  sites.append({Point(15, 8), Geom_Number(3)});

  sites.append({Point(2, -12), Geom_Number(0)});


  Tikz_Plane plane(160, 110);

  const auto rt = visualize_regular_triangulation(plane, sites);


  EXPECT_GE(rt.sites.size(), 4U);

  EXPECT_GT(rt.triangles.size(), 0U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();

  EXPECT_NE(result.find("blue!60"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeClosestPair)

{

  DynList<Point> points;

  points.append(Point(-12, -8));

  points.append(Point(-2, 5));

  points.append(Point(1, 7));

  points.append(Point(2, 7));

  points.append(Point(10, -6));


  Tikz_Plane plane(150, 100);

  const auto cp = visualize_closest_pair(plane, points);


  EXPECT_TRUE(cp.distance_squared >= 0);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();

  EXPECT_NE(result.find("draw=red"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeRotatingCalipers)

{

  const Polygon poly = make_convex_for_calipers();

  Tikz_Plane plane(160, 110);


  const auto rc = visualize_rotating_calipers(plane, poly);


  EXPECT_TRUE(rc.diameter.distance_squared > 0);

  EXPECT_TRUE(rc.width.width_squared >= 0);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();

  EXPECT_NE(result.find("draw=red"), std::string::npos);

  EXPECT_NE(result.find("draw=blue"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeHalfPlaneIntersection)

{

  const Polygon clip = make_convex_for_calipers();

  const auto hps = HalfPlaneIntersection::from_convex_polygon(clip);


  Tikz_Plane plane(160, 110);

  const Polygon inter = visualize_half_plane_intersection(plane, hps);


  EXPECT_GT(inter.size(), 0U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();

  EXPECT_NE(result.find("fill=red!25"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeMinkowskiSum)

{

  Polygon p;

  p.add_vertex(Point(-4, -2));

  p.add_vertex(Point(3, -2));

  p.add_vertex(Point(1, 4));

  p.close();


  Polygon q;

  q.add_vertex(Point(-3, -1));

  q.add_vertex(Point(2, -1));

  q.add_vertex(Point(0, 3));

  q.close();


  Tikz_Plane plane(160, 110);

  const Polygon sum = visualize_minkowski_sum(plane, p, q);


  EXPECT_GT(sum.size(), 0U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();

  EXPECT_NE(result.find("fill=red!26"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeMonotoneTriangulation)

{

  const Polygon concave = make_concave_for_decomposition();

  Tikz_Plane plane(170, 110);


  const DynList<Triangle> tris = visualize_monotone_triangulation(plane, concave);

  size_t tri_count = 0;

  for (DynList<Triangle>::Iterator it(tris); it.has_curr(); it.next_ne())

    ++tri_count;

  EXPECT_GT(tri_count, 0U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();

  EXPECT_NE(result.find("blue!65"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeVisibilityPolygon)

{

  const Polygon polygon = make_visibility_polygon();

  const Point query(2, 16);


  Tikz_Plane plane(170, 110);

  const Polygon vis = visualize_visibility_polygon(plane, polygon, query);

  EXPECT_GT(vis.size(), 0U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();

  EXPECT_NE(result.find("orange!90!black"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeLineSweep)

{

  Array<Segment> segments;

  segments.append(Segment(Point(-15, -8), Point(15, 10)));

  segments.append(Segment(Point(-12, 11), Point(14, -7)));

  segments.append(Segment(Point(-15, 2), Point(15, 2)));


  Tikz_Plane plane(170, 110);

  const auto intersections = visualize_line_sweep(plane, segments);


  EXPECT_GT(intersections.size(), 0U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();

  EXPECT_NE(result.find("blue!60"), std::string::npos);

  EXPECT_NE(result.find("fill=red"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeKDTreePartitions)

{

  Array<Point> points;

  points.append(Point(10, 10));

  points.append(Point(20, 30));

  points.append(Point(50, 40));

  points.append(Point(70, 80));

  points.append(Point(90, 20));

  const auto kd = KDTreePointSearch::build(points, 0, 0, 100, 100);


  Tikz_Plane plane(180, 110);

  const auto snap = visualize_kdtree_partitions(plane, kd, true, true);


  EXPECT_EQ(snap.points.size(), points.size());

  EXPECT_GT(snap.partitions.size(), 0U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();

  EXPECT_NE(result.find("fill=red"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeRangeTreeAndQuery)

{

  DynList<Point> points;

  points.append(Point(1, 1));

  points.append(Point(3, 5));

  points.append(Point(4, 4));

  points.append(Point(7, 2));

  points.append(Point(9, 8));


  RangeTree2D tree;

  tree.build(points);


  Tikz_Plane plane(180, 110);

  const auto viz = visualize_range_tree_query(

      plane, tree, Rectangle(2, 1, 6, 5));


  EXPECT_GT(viz.snapshot.nodes.size(), 0U);

  EXPECT_GT(viz.query_hits.size(), 0U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();

  EXPECT_NE(result.find("draw=red"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeAABBTreeAndQuery)

{

  AABBTree tree;

  Array<AABBTree::Entry> entries;

  entries.append({Rectangle(0, 0, 5, 5), 0});

  entries.append({Rectangle(3, 3, 8, 8), 1});

  entries.append({Rectangle(10, 10, 15, 15), 2});

  tree.build(entries);


  Tikz_Plane plane(180, 110);

  const auto viz = visualize_aabb_tree_query(

      plane, tree, Rectangle(2, 2, 6, 6));


  EXPECT_GT(viz.snapshot.nodes.size(), 0U);

  EXPECT_GT(viz.query_hit_ids.size(), 0U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();

  EXPECT_NE(result.find("draw=red"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeShortestPathWithPortals)

{

  const Polygon polygon = make_shortest_path_polygon();

  const Point source(2, 16);

  const Point target(18, 16);


  Tikz_Plane plane(170, 110);

  const auto debug = visualize_shortest_path_with_portals(

      plane, polygon, source, target, ShortestPathInPolygon());


  EXPECT_GE(debug.portals.size(), 2U);

  EXPECT_GE(count_points(debug.path), 2U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();


  EXPECT_NE(result.find("draw=purple"), std::string::npos);

  EXPECT_NE(result.find("dashed"), std::string::npos);

  EXPECT_NE(result.find("draw=red"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, VisualizeConvexDecomposition)

{

  const Polygon concave = make_concave_for_decomposition();


  Tikz_Plane plane(170, 110);

  const auto parts = visualize_convex_decomposition(

      plane, concave, ConvexPolygonDecomposition(),

      true, tikz_wire_style("black", true),

      true);


  EXPECT_GT(parts.size(), 1U);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();


  EXPECT_NE(result.find("blue!20"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomAlgorithmsTest, ComputeFunnelTrace)

{

  const Polygon polygon = make_shortest_path_polygon();

  const Point source(2, 16);

  const Point target(18, 16);


  const FunnelTraceResult trace =

      compute_shortest_path_funnel_trace(polygon, source, target);


  EXPECT_GE(trace.portals.size(), 2U);

  EXPECT_GT(trace.steps.size(), 0U);

  EXPECT_GE(count_points(trace.final_path), 2U);

  EXPECT_EQ(trace.final_path(0), source);

  EXPECT_EQ(trace.final_path(trace.final_path.size() - 1), target);

}


TEST(TikzGeomAlgorithmsTest, PutFunnelTraceStepRenders)

{

  const Polygon polygon = make_shortest_path_polygon();

  const Point source(2, 16);

  const Point target(18, 16);


  const FunnelTraceResult trace =

      compute_shortest_path_funnel_trace(polygon, source, target);

  ASSERT_GT(trace.steps.size(), 0U);


  Tikz_Plane plane(170, 110);

  put_funnel_trace_step(plane, polygon, source, target, trace, 0);


  std::ostringstream output;

  plane.draw(output);

  const std::string result = output.str();


  EXPECT_NE(result.find("draw=purple"), std::string::npos);

  EXPECT_NE(result.find("draw=orange!90!black"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(result));

}


TEST(TikzGeomSceneTest, ComposeMultipleAlgorithmsInSingleScene)

{

  Array<Segment> segments;

  segments.append(Segment(Point(-20, 0), Point(20, 0)));

  segments.append(Segment(Point(0, -20), Point(0, 20)));

  segments.append(Segment(Point(-18, -14), Point(18, 14)));


  Tikz_Scene scene(190, 120, 0, 0, true);

  scene.put_cartesian_axis()

      .set_point_radius_mm(0.65);


  const auto arrangement = scene.visualize_segment_arrangement(

      segments,

      SegmentArrangement(),

      true,

      true,

      false,

      tikz_area_style("teal!60!black", "teal!12", 0.30),

      tikz_wire_style("teal!70!black"),

      tikz_points_style("teal!70!black"),

      true);


  DynList<Point> arrangement_points;

  for (size_t i = 0; i < arrangement.vertices.size(); ++i)

    arrangement_points.append(arrangement.vertices(i));


  const Polygon hull = scene.visualize_convex_hull(

      arrangement_points,

      AndrewMonotonicChainConvexHull(),

      tikz_points_style("black"),

      tikz_wire_style("red"),

      tikz_points_style("red"),

      Tikz_Plane::Layer_Default,

      Tikz_Plane::Layer_Overlay,

      true);


  EXPECT_GE(hull.size(), 3U);


  const std::string tikz = scene.to_tikz();

  EXPECT_NE(tikz.find("draw=teal!70!black"), std::string::npos);

  EXPECT_NE(tikz.find("draw=red"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(tikz));

}


TEST(TikzGeomSceneTest, NewVisualizationWrappers)

{

  Tikz_Scene scene(190, 120, 0, 0, true);


  DynList<Point> points;

  points.append(Point(-10, -7));

  points.append(Point(-2, 9));

  points.append(Point(8, -6));

  points.append(Point(12, 8));

  points.append(Point(0, 0));


  const auto dt = scene.visualize_delaunay(points);

  EXPECT_GT(dt.triangles.size(), 0U);


  const auto cp = scene.visualize_closest_pair(points);

  EXPECT_TRUE(cp.distance_squared >= 0);


  Array<Segment> segments;

  segments.append(Segment(Point(-12, -8), Point(12, 10)));

  segments.append(Segment(Point(-12, 10), Point(12, -8)));

  const auto intersections = scene.visualize_line_sweep(segments);

  EXPECT_GT(intersections.size(), 0U);


  Array<Point> kd_points;

  kd_points.append(Point(5, 5));

  kd_points.append(Point(15, 20));

  kd_points.append(Point(35, 10));

  kd_points.append(Point(45, 30));

  const auto kd = KDTreePointSearch::build(kd_points, 0, 0, 50, 40);

  const auto kd_snap = scene.visualize_kdtree_partitions(kd);

  EXPECT_GT(kd_snap.partitions.size(), 0U);


  RangeTree2D range_tree;

  DynList<Point> range_points;

  range_points.append(Point(1, 1));

  range_points.append(Point(3, 4));

  range_points.append(Point(6, 2));

  range_tree.build(range_points);

  const auto rv = scene.visualize_range_tree_query(

      range_tree, Rectangle(0, 0, 4, 5));

  EXPECT_GT(rv.query_hits.size(), 0U);


  AABBTree aabb_tree;

  Array<AABBTree::Entry> aabb_entries;

  aabb_entries.append({Rectangle(0, 0, 4, 4), 0});

  aabb_entries.append({Rectangle(2, 2, 8, 8), 1});

  aabb_tree.build(aabb_entries);

  const auto av = scene.visualize_aabb_tree_query(

      aabb_tree, Rectangle(1, 1, 3, 3));

  EXPECT_GT(av.query_hit_ids.size(), 0U);


  const std::string tikz = scene.to_tikz();

  EXPECT_NE(tikz.find("draw=blue"), std::string::npos);

  EXPECT_NE(tikz.find("draw=red"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(tikz));

}


TEST(TikzGeomSceneTest, StandaloneExportWrapsTikzPicture)

{

  Tikz_Scene scene(120, 80, 2, 3, true);

  scene.add(Segment(Point(0, 0), Point(10, 15)), tikz_wire_style("blue"));


  Tikz_Standalone_Document_Options opts;

  opts.class_options = "tikz,border=6pt";

  const std::string latex = scene.to_standalone(opts);


  EXPECT_NE(latex.find("\\documentclass[tikz,border=6pt]{standalone}"),

            std::string::npos);

  EXPECT_NE(latex.find("}\n\\usepackage{tikz}\n"), std::string::npos);

  EXPECT_EQ(latex.find("}\\n\\usepackage{tikz}\\n"), std::string::npos);

  EXPECT_NE(latex.find("\\usepackage{tikz}"), std::string::npos);

  EXPECT_NE(latex.find("\\begin{tikzpicture}"), std::string::npos);

  EXPECT_NE(latex.find("\\end{document}"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(latex));

}


TEST(TikzGeomSceneTest, BeamerExportWrapsSingleFrame)

{

  Tikz_Scene scene(120, 80, 2, 3, true);

  scene.add(Segment(Point(0, 0), Point(10, 15)), tikz_wire_style("blue"));


  Tikz_Beamer_Document_Options opts;

  opts.class_options = "aspectratio=43";

  opts.frame_title = "Scene Demo";

  opts.frame_options = "t";


  const std::string latex = scene.to_beamer(opts);


  EXPECT_NE(latex.find("\\documentclass[aspectratio=43]{beamer}"),

            std::string::npos);

  EXPECT_NE(latex.find("\\setbeamertemplate{navigation symbols}{}"),

            std::string::npos);

  EXPECT_NE(latex.find("\\begin{frame}[t]{Scene Demo}"), std::string::npos);

  EXPECT_NE(latex.find("\\begin{tikzpicture}"), std::string::npos);

  EXPECT_EQ(latex.find("\\documentclass[handout,aspectratio=43]{beamer}"),

            std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(latex));

}


TEST(TikzGeomSceneTest, HandoutExportAddsHandoutClassOption)

{

  Tikz_Scene scene(120, 80, 0, 0, true);

  scene.add(Point(1, 1), tikz_points_style("red"));


  Tikz_Beamer_Document_Options opts;

  opts.class_options = "aspectratio=169";

  opts.frame_title = "Handout Demo";


  const std::string latex = scene.to_handout(opts);


  EXPECT_NE(latex.find("\\documentclass[handout,aspectratio=169]{beamer}"),

            std::string::npos);

  EXPECT_NE(latex.find("\\begin{frame}[t]{Handout Demo}"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(latex));


  opts.class_options = "handout,aspectratio=169";

  const std::string latex_no_dup = scene.to_handout(opts);

  EXPECT_NE(latex_no_dup.find("\\documentclass[handout,aspectratio=169]{beamer}"),

            std::string::npos);

  EXPECT_EQ(latex_no_dup.find("handout,handout"), std::string::npos);

}


TEST(TikzGeomSceneTest, BeamerOverlaysExportWrapsOnlyBlocks)

{

  std::vector<Tikz_Scene> steps;

  steps.emplace_back(120, 80, 0, 0, true);

  steps.back().add(Point(2, 3), tikz_points_style("red"));

  steps.emplace_back(120, 80, 0, 0, true);

  steps.back().add(Segment(Point(0, 0), Point(12, 9)), tikz_wire_style("blue"));


  Tikz_Beamer_Document_Options opts;

  opts.class_options = "aspectratio=169";

  opts.frame_title = "Overlay Demo";

  opts.frame_options = "t";


  const std::string latex = Tikz_Scene::to_beamer_overlays(steps, opts);


  EXPECT_NE(latex.find("\\documentclass[aspectratio=169]{beamer}"),

            std::string::npos);

  EXPECT_NE(latex.find("\\begin{frame}[t]{Overlay Demo}"), std::string::npos);

  EXPECT_NE(latex.find("\\only<1>{"), std::string::npos);

  EXPECT_NE(latex.find("\\only<2>{"), std::string::npos);

  EXPECT_EQ(latex.find("\\only<3>{"), std::string::npos);

  EXPECT_EQ(latex.find("\\documentclass[handout,aspectratio=169]{beamer}"),

            std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(latex));

}


TEST(TikzGeomSceneTest, HandoutOverlaysAddsHandoutClassOption)

{

  std::vector<Tikz_Scene> steps;

  steps.emplace_back(120, 80, 0, 0, true);

  steps.back().add(Point(4, 5), tikz_points_style("black"));


  Tikz_Beamer_Document_Options opts;

  opts.class_options = "handout,aspectratio=43";

  opts.frame_title = "Overlay Handout";


  const std::string latex = Tikz_Scene::to_handout_overlays(steps, opts);

  EXPECT_NE(latex.find("\\documentclass[handout,aspectratio=43]{beamer}"),

            std::string::npos);

  EXPECT_EQ(latex.find("handout,handout"), std::string::npos);

  EXPECT_NE(latex.find("\\only<1>{"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(latex));

}


TEST(TikzGeomSceneTest, BeamerOverlaysHandlesEmptySteps)

{

  const std::vector<Tikz_Scene> steps;

  const std::string latex = Tikz_Scene::to_beamer_overlays(steps);


  EXPECT_NE(latex.find("No overlays provided."), std::string::npos);

  EXPECT_EQ(latex.find("\\only<1>{"), std::string::npos);

  EXPECT_FALSE(has_nan_or_inf(latex));

}


Aleph::AABBTree
Axis-aligned bounding box tree for spatial queries.
Definition geom_algorithms.H:12064

Aleph::AABBTree::build
size_t build(Array< size_t > &idx, const size_t lo, const size_t hi)
Definition geom_algorithms.H:12226

Aleph::AlphaShape
Alpha shape of a point set.
Definition geom_algorithms.H:10745

Aleph::AndrewMonotonicChainConvexHull
Andrew's monotonic chain convex hull algorithm.
Definition geom_algorithms.H:4742

Aleph::Array
Simple dynamic array with automatic resizing and functional operations.
Definition tpl_array.H:139

Aleph::Array::size
constexpr size_t size() const noexcept
Return the number of elements stored in the stack.
Definition tpl_array.H:351

Aleph::Array::append
T & append(const T &data)
Append a copy of data
Definition tpl_array.H:245

Aleph::ConvexPolygonDecomposition
Decompose a simple polygon into convex parts using Hertel-Mehlhorn.
Definition geom_algorithms.H:8357

Aleph::DynList::Iterator
Iterator on the items of list.
Definition htlist.H:1420

Aleph::DynList
Dynamic singly linked list with functional programming support.
Definition htlist.H:1155

Aleph::DynList::append
T & append(const T &item)
Definition htlist.H:1271

Aleph::HTList::Iterator::has_curr
bool has_curr() const noexcept
Definition htlist.H:930

Aleph::HalfPlaneIntersection::from_convex_polygon
static Array< HalfPlane > from_convex_polygon(const Polygon &poly)
Build half-planes from the edges of a closed convex polygon.
Definition geom_algorithms.H:1916

Aleph::KDTreePointSearch::build
static KDTreePointSearch build(const Array< Point > &points, const Geom_Number &xmin, const Geom_Number &ymin, const Geom_Number &xmax, const Geom_Number &ymax)
Build a balanced KD-tree from a point array.
Definition geom_algorithms.H:8180

Aleph::Point
Represents a point with rectangular coordinates in a 2D plane.
Definition point.H:229

Aleph::Polygon
A general (irregular) 2D polygon defined by a sequence of vertices.
Definition polygon.H:246

Aleph::Polygon::add_vertex
void add_vertex(const Point &point)
Add a vertex to the polygon.
Definition polygon.H:677

Aleph::Polygon::close
void close()
Close the polygon.
Definition polygon.H:840

Aleph::Polygon::size
const size_t & size() const
Get the number of vertices.
Definition polygon.H:477

Aleph::RangeTree2D
Static 2D range tree for orthogonal range queries.
Definition geom_algorithms.H:8604

Aleph::RangeTree2D::build
void build(const DynList< Point > &points)
Build the range tree from a point set.
Definition geom_algorithms.H:8753

Aleph::Rectangle
An axis-aligned rectangle.
Definition point.H:1737

Aleph::SegmentArrangement
Compute the full planar subdivision induced by a set of segments.
Definition geom_algorithms.H:10360

Aleph::Segment
Represents a line segment between two points.
Definition point.H:827

Aleph::ShortestPathInPolygon
Compute the shortest Euclidean path between two points inside a simple polygon.
Definition geom_algorithms.H:9941

Aleph::Tikz_Plane
2D TikZ canvas storing geometry objects and emitting LaTeX output.
Definition tikzgeom.H:184

Aleph::Tikz_Plane::draw
void draw(std::ostream &output, const bool squarize=true) const
Emit a complete tikzpicture with all inserted objects.
Definition tikzgeom.H:1383

Aleph::Tikz_Plane::Layer_Default
static constexpr int Layer_Default
Definition tikzgeom.H:187

Aleph::Tikz_Plane::Layer_Overlay
static constexpr int Layer_Overlay
Definition tikzgeom.H:189

Aleph::Tikz_Scene
High-level scene wrapper to compose objects and algorithm visualizations.
Definition tikzgeom_scene.H:81

Aleph::Tikz_Scene::to_handout_overlays
static std::string to_handout_overlays(const std::vector< Tikz_Scene > &steps, const Tikz_Beamer_Document_Options &options={})
String variant of draw_handout_overlays.
Definition tikzgeom_scene.H:642

Aleph::Tikz_Scene::to_beamer_overlays
static std::string to_beamer_overlays(const std::vector< Tikz_Scene > &steps, const Tikz_Beamer_Document_Options &options={})
String variant of draw_beamer_overlays.
Definition tikzgeom_scene.H:623

Aleph::VoronoiDiagram
O(n log n) Voronoi diagram construction.
Definition geom_algorithms.H:4199

TEST
#define TEST(name)
Definition disjoint_sparse_table_test.cc:95

Aleph
Main namespace for Aleph-w library functions.
Definition ah-arena.H:89

Aleph::visualize_aabb_tree_query
AABBTreeQueryVizResult visualize_aabb_tree_query(Tikz_Plane &plane, const AABBTree &tree, const Rectangle &query_rect, const Tikz_Style &node_bbox_style=tikz_wire_style("teal!70!black"), const Tikz_Style &leaf_bbox_style=tikz_wire_style("blue!70"), const Tikz_Style &query_rect_style=tikz_wire_style("red", true), const Tikz_Style &query_hit_style=tikz_wire_style("red"))
Visualize AABB tree with a rectangle query overlay.
Definition tikzgeom_algorithms.H:1151

Aleph::tolower
std::string tolower(const char *str)
Convert a C std::string to lower-case.
Definition ah-string-utils.H:294

Aleph::put_in_plane
void put_in_plane(Tikz_Plane &plane, const Geom &geom_obj)
Insert any supported geometry type in a Tikz_Plane.
Definition tikzgeom.H:1456

Aleph::visualize_convex_intersection
Polygon visualize_convex_intersection(Tikz_Plane &plane, const Polygon &subject, const Polygon &clip, const ConvexPolygonIntersectionBasic &intersection_algorithm={}, const Tikz_Style &subject_style=tikz_area_style("blue", "blue!15", 0.45), const Tikz_Style &clip_style=tikz_area_style("orange", "orange!20", 0.45), const Tikz_Style &result_style=tikz_area_style("red", "red!30", 0.60), const int input_layer=Tikz_Plane::Layer_Default, const int result_layer=Tikz_Plane::Layer_Foreground)
Visualizes the intersection of two convex polygons.
Definition tikzgeom_algorithms.H:626

Aleph::visualize_alpha_shape
AlphaShape::Result visualize_alpha_shape(Tikz_Plane &plane, const DynList< Point > &points, const Geom_Number &alpha_squared, const AlphaShape &algorithm={}, const bool draw_kept_triangles=false, const Tikz_Style &triangle_style=tikz_wire_style("gray!55"), const Tikz_Style &boundary_style=tikz_path_style("orange!90!black"), const bool draw_sites=true, const Tikz_Style &site_style=tikz_points_style("black"))
Compute and insert alpha-shape for input points.
Definition tikzgeom_algorithms.H:1592

Aleph::put_funnel_trace_step
void put_funnel_trace_step(Tikz_Plane &plane, const Polygon &polygon, const Point &source, const Point &target, const FunnelTraceResult &trace, size_t step_index, const Tikz_Style &polygon_style=tikz_area_style("black", "gray!15", 0.22), const Tikz_Style &source_style=tikz_points_style("green!50!black"), const Tikz_Style &target_style=tikz_points_style("blue"), const Tikz_Style &all_portals_style=tikz_wire_style("purple", true), const Tikz_Style &active_portal_style=tikz_path_style("purple"), const Tikz_Style &funnel_leg_style=tikz_path_style("orange!90!black"), const Tikz_Style &committed_style=tikz_path_style("red"), const bool draw_waypoints=true, const Tikz_Style &waypoint_style=tikz_points_style("red"), const int polygon_layer=Tikz_Plane::Layer_Default, const int portal_layer=Tikz_Plane::Layer_Foreground, const int highlight_layer=Tikz_Plane::Layer_Overlay)
Render one funnel-trace frame in a plane.
Definition tikzgeom_algorithms.H:1376

Aleph::visualize_range_tree_query
RangeTreeQueryVizResult visualize_range_tree_query(Tikz_Plane &plane, const RangeTree2D &tree, const Rectangle &query_rect, const bool draw_points=true, const Tikz_Style &split_style=tikz_wire_style("purple"), const Tikz_Style &point_style=tikz_points_style("black"), const Tikz_Style &query_rect_style=tikz_wire_style("red", true), const Tikz_Style &query_hit_style=tikz_points_style("red"))
Visualize range-tree plus a query rectangle and matching points.
Definition tikzgeom_algorithms.H:1074

Aleph::visualize_power_diagram
PowerDiagram::Result visualize_power_diagram(Tikz_Plane &plane, const Array< PowerDiagram::WeightedSite > &sites, const PowerDiagram &algorithm={}, const bool draw_cells=true, const Tikz_Style &cell_style=tikz_area_style("violet", "violet!18", 0.35), const Tikz_Style &edge_style=tikz_wire_style("violet"), const Tikz_Style &site_style=tikz_points_style("purple"))
Compute and insert Power diagram for weighted sites.
Definition tikzgeom_algorithms.H:841

Aleph::visualize_delaunay
DelaunayTriangulationBowyerWatson::Result visualize_delaunay(Tikz_Plane &plane, const DynList< Point > &points, const DelaunayTriangulationBowyerWatson &algorithm={}, const Tikz_Style &triangle_style=tikz_wire_style("blue"), const bool draw_sites=true, const Tikz_Style &site_style=tikz_points_style("black"))
Compute and insert Delaunay triangulation as triangle outlines.
Definition tikzgeom_algorithms.H:712

Aleph::visualize_voronoi
VoronoiDiagram::Result visualize_voronoi(Tikz_Plane &plane, const DynList< Point > &sites, const VoronoiDiagram &algorithm={}, const bool draw_cells=false, const Tikz_Style &cell_style=tikz_area_style("gray!50!black", "gray!15", 0.35), const Tikz_Style &edge_style=tikz_wire_style("black"), const Tikz_Style &unbounded_edge_style=tikz_wire_style("black", true, true), const Tikz_Style &site_style=tikz_points_style("red"), const Geom_Number &unbounded_ray_length=Geom_Number(50))
Compute and insert Voronoi diagram for input sites.
Definition tikzgeom_algorithms.H:785

Aleph::visualize_regular_triangulation
RegularTriangulationBowyerWatson::Result visualize_regular_triangulation(Tikz_Plane &plane, const Array< RegularTriangulationBowyerWatson::WeightedSite > &weighted_sites, const RegularTriangulationBowyerWatson &algorithm={}, const Tikz_Style &triangle_style=tikz_wire_style("blue!60"), const bool draw_sites=true, const Tikz_Style &site_style=tikz_points_style("black"))
Compute and insert regular (weighted Delaunay) triangulation.
Definition tikzgeom_algorithms.H:1642

Aleph::visualize_half_plane_intersection
Polygon visualize_half_plane_intersection(Tikz_Plane &plane, const Array< HalfPlaneIntersection::HalfPlane > &halfplanes, const HalfPlaneIntersection &algorithm={}, const Tikz_Style &boundary_style=tikz_wire_style("gray!60", true, true), const Tikz_Style &result_style=tikz_area_style("red", "red!25", 0.50))
Compute and draw bounded half-plane intersection.
Definition tikzgeom_algorithms.H:1757

Aleph::visualize_visibility_polygon
Polygon visualize_visibility_polygon(Tikz_Plane &plane, const Polygon &polygon, const Point &query_point, const VisibilityPolygon &algorithm={}, const Tikz_Style &polygon_style=tikz_wire_style("black"), const Tikz_Style &visibility_style=tikz_area_style("orange!90!black", "orange!25", 0.50), const Tikz_Style &query_style=tikz_points_style("red"))
Compute and draw visibility polygon from a query point.
Definition tikzgeom_algorithms.H:1855

Aleph::divide_and_conquer_partition_dp
Divide_Conquer_DP_Result< Cost > divide_and_conquer_partition_dp(const size_t groups, const size_t n, Transition_Cost_Fn transition_cost, const Cost inf=dp_optimization_detail::default_inf< Cost >())
Optimize partition DP using divide-and-conquer optimization.
Definition DP_Optimizations.H:133

Aleph::visualize_shortest_path_with_portals
ShortestPathDebugResult visualize_shortest_path_with_portals(Tikz_Plane &plane, const Polygon &polygon, const Point &source, const Point &target, const ShortestPathInPolygon &algorithm={}, const Tikz_Style &polygon_style=tikz_area_style("black", "gray!15", 0.25), const Tikz_Style &source_style=tikz_points_style("green!50!black"), const Tikz_Style &target_style=tikz_points_style("blue"), const Tikz_Style &portal_style=tikz_wire_style("purple", true), const Tikz_Style &path_style=tikz_path_style("red"), const bool draw_waypoints=true, const Tikz_Style &waypoint_style=tikz_points_style("red"), const int polygon_layer=Tikz_Plane::Layer_Default, const int portal_layer=Tikz_Plane::Layer_Foreground, const int path_layer=Tikz_Plane::Layer_Overlay)
Visualize the shortest path plus funnel portals.
Definition tikzgeom_algorithms.H:1468

Aleph::visualize_line_sweep
Array< SweepLineSegmentIntersection::Intersection > visualize_line_sweep(Tikz_Plane &plane, const Array< Segment > &segments, const SweepLineSegmentIntersection &algorithm={}, const Tikz_Style &segment_style=tikz_wire_style("blue!60"), const Tikz_Style &intersection_style=tikz_points_style("red"))
Compute and draw Bentley-Ottmann line-sweep intersections.
Definition tikzgeom_algorithms.H:1890

Aleph::visualize_kdtree_partitions
KDTreePointSearch::DebugSnapshot visualize_kdtree_partitions(Tikz_Plane &plane, const KDTreePointSearch &kd_tree, const bool draw_partition_boxes=false, const bool draw_points=true, const Tikz_Style &partition_style=tikz_wire_style("gray!55", true), const Tikz_Style &split_style=tikz_wire_style("blue!70"), const Tikz_Style &point_style=tikz_points_style("red"))
Visualize KD-tree recursive space partitions.
Definition tikzgeom_algorithms.H:985

Aleph::Geom_Number
mpq_class Geom_Number
Numeric type used by the geometry module.
Definition point.H:115

Aleph::visualize_shortest_path_in_polygon
DynList< Point > visualize_shortest_path_in_polygon(Tikz_Plane &plane, const Polygon &polygon, const Point &source, const Point &target, const ShortestPathInPolygon &algorithm={}, const Tikz_Style &polygon_style=tikz_area_style("black", "gray!15", 0.25), const Tikz_Style &source_style=tikz_points_style("green!50!black"), const Tikz_Style &target_style=tikz_points_style("blue"), const Tikz_Style &path_style=tikz_path_style("red"), const bool draw_waypoints=true, const Tikz_Style &waypoint_style=tikz_points_style("red"), const int polygon_layer=Tikz_Plane::Layer_Default, const int path_layer=Tikz_Plane::Layer_Foreground)
Visualize the shortest path inside a simple polygon.
Definition tikzgeom_algorithms.H:1434

Aleph::visualize_closest_pair
ClosestPairDivideAndConquer::Result visualize_closest_pair(Tikz_Plane &plane, const DynList< Point > &points, const ClosestPairDivideAndConquer &algorithm={}, const Tikz_Style &points_style=tikz_points_style("black"), const Tikz_Style &pair_style=tikz_path_style("red"), const Tikz_Style &pair_points_style=tikz_points_style("red"))
Compute and draw the closest pair from an input point set.
Definition tikzgeom_algorithms.H:1675

Aleph::visualize_rotating_calipers
RotatingCalipersResult visualize_rotating_calipers(Tikz_Plane &plane, const Polygon &polygon, const Tikz_Style &polygon_style=tikz_wire_style("gray!55"), const Tikz_Style &diameter_style=tikz_path_style("red"), const Tikz_Style &width_style=tikz_path_style("blue"), const Tikz_Style &witness_style=tikz_points_style("orange!90!black"))
Compute and draw rotating-calipers diameter and minimum width.
Definition tikzgeom_algorithms.H:1719

Aleph::tikz_wire_style
Tikz_Style tikz_wire_style(const std::string &color="black", const bool dashed=false, const bool with_arrow=false)
Creates a style optimized for wireframe segments and polygons.
Definition tikzgeom_algorithms.H:346

Aleph::visualize_segment_arrangement
SegmentArrangement::Result visualize_segment_arrangement(Tikz_Plane &plane, const Array< Segment > &segments, const SegmentArrangement &algorithm={}, const bool draw_faces=true, const bool draw_vertices=true, const bool draw_unbounded_face=false, const Tikz_Style &face_style=tikz_area_style("teal!60!black", "teal!12", 0.30), const Tikz_Style &edge_style=tikz_wire_style("teal!70!black"), const Tikz_Style &vertex_style=tikz_points_style("teal!70!black"), const bool color_faces_by_index=false)
Compute and insert arrangement for input segments.
Definition tikzgeom_algorithms.H:919

Aleph::visualize_minkowski_sum
Polygon visualize_minkowski_sum(Tikz_Plane &plane, const Polygon &first, const Polygon &second, const MinkowskiSumConvex &algorithm={}, const Tikz_Style &first_style=tikz_area_style("blue", "blue!14", 0.30), const Tikz_Style &second_style=tikz_area_style("green!60!black", "green!16", 0.30), const Tikz_Style &result_style=tikz_area_style("red", "red!26", 0.60))
Compute and draw Minkowski sum of two convex polygons.
Definition tikzgeom_algorithms.H:1790

Aleph::compute_shortest_path_funnel_trace
FunnelTraceResult compute_shortest_path_funnel_trace(const Polygon &polygon, const Point &source, const Point &target)
Compute a full SSFA trace (portal-by-portal states).
Definition tikzgeom_algorithms.H:1272

Aleph::visualize_monotone_triangulation
DynList< Triangle > visualize_monotone_triangulation(Tikz_Plane &plane, const Polygon &polygon, const MonotonePolygonTriangulation &algorithm={}, const Tikz_Style &polygon_style=tikz_wire_style("black"), const Tikz_Style &triangle_style=tikz_wire_style("blue!65"))
Compute and draw triangulation via monotone partition pipeline.
Definition tikzgeom_algorithms.H:1822

Aleph::tikz_area_style
Tikz_Style tikz_area_style(const std::string &draw_color="black", const std::string &fill_color="gray!25", const double opacity=0.6)
Creates a style for drawing filled polygons.
Definition tikzgeom_algorithms.H:384

Aleph::visualize_convex_hull
Polygon visualize_convex_hull(Tikz_Plane &plane, const DynList< Point > &points, const HullAlgorithm &hull_algorithm, const Tikz_Style &point_style=tikz_points_style("black", 0.6), const Tikz_Style &hull_style=tikz_wire_style("red"), const Tikz_Style &hull_vertex_style=tikz_points_style("red"), const int point_layer=Tikz_Plane::Layer_Default, const int hull_layer=Tikz_Plane::Layer_Foreground, const bool draw_hull_vertices=true)
Runs a convex hull algorithm and visualizes the result.
Definition tikzgeom_algorithms.H:585

Aleph::tikz_points_style
Tikz_Style tikz_points_style(const std::string &color="black", const double opacity=-1.0)
Creates a style optimized for point clouds.
Definition tikzgeom_algorithms.H:329

Aleph::visualize_convex_decomposition
Array< Polygon > visualize_convex_decomposition(Tikz_Plane &plane, const Polygon &polygon, const ConvexPolygonDecomposition &algorithm={}, const bool draw_input_polygon=true, const Tikz_Style &input_style=tikz_wire_style("black", true), const bool color_parts_by_index=true, const Tikz_Style &part_style=tikz_area_style("blue!60!black", "blue!15", 0.40), const int input_layer=Tikz_Plane::Layer_Default, const int part_layer=Tikz_Plane::Layer_Foreground)
Compute and insert convex decomposition for a polygon.
Definition tikzgeom_algorithms.H:1530

Aleph::sum
T sum(const Container &container, const T &init=T{})
Compute sum of all elements.
Definition ahFunctional.H:2241

Aleph::FunnelTraceResult
Full trace for shortest-path funnel processing.
Definition tikzgeom_algorithms.H:1262

Aleph::Tikz_Beamer_Document_Options
Options used by Tikz_Scene beamer/handout export helpers.
Definition tikzgeom_scene.H:56

Aleph::Tikz_Beamer_Document_Options::class_options
std::string class_options
beamer class options (for example aspectratio=169).
Definition tikzgeom_scene.H:58

Aleph::Tikz_Standalone_Document_Options
Options used by Tikz_Scene standalone document export.
Definition tikzgeom_scene.H:48

Aleph::Tikz_Standalone_Document_Options::class_options
std::string class_options
Definition tikzgeom_scene.H:50

Aleph::Tikz_Style
Style descriptor for TikZ primitives.
Definition tikzgeom.H:86

tikzgeom_algorithms.H
Helpers to visualize computational-geometry algorithm results in TikZ.

tikzgeom_scene.H

output
ofstream output
Definition writeHeap.C:215