Finish SimpleSets, add chorematic map, and refactoring

CMakeLists.txt

@@ -43,6 +43,7 @@ include_directories(${CGAL_INCLUDE_DIR})
 link_libraries(${CGAL_LIBRARIES})
 find_package(GMP REQUIRED)
 
+find_package(GDAL CONFIG REQUIRED)
 find_package(Qt5Widgets REQUIRED)
 set(CMAKE_AUTOMOC ON)
 find_package(glog REQUIRED)
@@ -55,6 +56,7 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
 add_subdirectory(cartocrow)
 add_subdirectory(demos)

README.md

@@ -27,7 +27,7 @@ CartoCrow depends on the following build tools:
 
 And it depends on the following libraries:
 
-* CGAL (5.4, 5.5) – for implementations of computational geometry algorithms we need
+* CGAL (5.6) – for implementations of computational geometry algorithms we need
 * glog (0.5.0, 0.6.0) – for logging
 * ipelib (7.2.26) – for [Ipe](https://ipe.otfried.org) input and SVG/Ipe output
 * nlohmann-json (3.10.5, 3.11.2) – for JSON parsing

cartocrow/CMakeLists.txt

@@ -17,6 +17,7 @@ add_subdirectory(simplification)
 add_subdirectory(flow_map)
 add_subdirectory(isoline_simplification)
 add_subdirectory(simplesets)
+add_subdirectory(chorematic_map)
 
 add_library(cartocrow_lib INTERFACE)
 target_link_libraries(
@@ -26,6 +27,9 @@ target_link_libraries(
     necklace_map
     flow_map
     simplification
+    isoline_simplification
+    simplesets
+    chorematic_map
 )
 
 install(

cartocrow/chorematic_map/CMakeLists.txt

@@ -0,0 +1,29 @@
+set(SOURCES
+	maximum_weight_disk.cpp
+    sampler.h
+	parse_points.cpp
+	disk_area.cpp
+	choropleth.cpp
+	natural_breaks_external.cpp
+	choropleth_disks.cpp
+	input_parsing.cpp
+)
+set(HEADERS
+	maximum_weight_disk.h
+	parse_points.h
+	disk_area.h
+	choropleth.h
+	natural_breaks.h
+	weighted_region_sample.h
+	choropleth_disks.h
+	input_parsing.h
+)
+
+add_library(chorematic_map ${SOURCES})
+target_link_libraries(chorematic_map
+	PUBLIC core
+	PRIVATE GDAL::GDAL
+)
+
+cartocrow_install_module(chorematic_map)
+install(FILES ${HEADERS} DESTINATION ${CARTOCROW_INSTALL_DIR}/chorematic_map)

cartocrow/chorematic_map/choropleth.cpp

@@ -0,0 +1,65 @@
+#include "choropleth.h"
+#include "../core/arrangement_helpers.h"
+#include "../core/centroid.h"
+#include "../core/rectangle_helpers.h"
+
+namespace cartocrow::chorematic_map {
+using namespace renderer;
+
+PolygonWithHoles<Inexact> transform(const CGAL::Aff_transformation_2<Inexact>& t, const PolygonWithHoles<Inexact>& pwh) {
+    Polygon<Inexact> outerT;
+    if (!pwh.is_unbounded()) {
+        outerT = transform(t, pwh.outer_boundary());
+    }
+    std::vector<Polygon<Inexact>> holesT;
+    for (const auto& h : pwh.holes()) {
+        holesT.push_back(transform(t, h));
+    }
+    return {outerT, holesT.begin(), holesT.end()};
+}
+
+void ChoroplethPainting::paint(GeometryRenderer& renderer) const {
+	const auto& arr = *m_choropleth.m_arr;
+	for (auto fit = arr.faces_begin(); fit != arr.faces_end(); ++fit) {
+		if (!fit->has_outer_ccb()) continue;
+		auto region = fit->data();
+		if (region.empty() || region == "#") {
+            renderer.setMode(0);
+            continue;
+		} else {
+            renderer.setMode(GeometryRenderer::fill);
+		}
+		std::optional<int> bin = m_choropleth.regionToBin(region);
+		Color color = m_options.noDataColor;
+		if (bin.has_value()) {
+			if (m_colors.size() <= *bin) {
+				std::cerr << "No color specified for bin " << *bin << std::endl;
+			} else {
+				color = m_colors.at(*bin);
+			}
+		}
+		renderer.setFill(color);
+		auto poly = approximate(face_to_polygon_with_holes<Exact>(fit));
+		renderer.draw(transform(m_options.transformation, poly));
+	}
+	if (m_options.drawLabels) {
+		for (auto fit = arr.faces_begin(); fit != arr.faces_end(); ++fit) {
+			if (!fit->has_outer_ccb())
+				continue;
+			auto region = fit->data();
+			auto poly = approximate(face_to_polygon_with_holes<Exact>(fit));
+			auto c = centroid(poly);
+			renderer.setMode(GeometryRenderer::stroke);
+			renderer.setStroke(Color{0, 0, 0}, m_options.strokeWidth);
+			auto label = fit->data().empty() ? "empty" : fit->data();
+			renderer.drawText(c.transform(m_options.transformation), label);
+		}
+	}
+	renderer.setLineCap(GeometryRenderer::RoundCap);
+	renderer.setMode(GeometryRenderer::stroke);
+	renderer.setStroke(m_options.strokeColor, m_options.strokeWidth);
+	for (auto eit = arr.edges_begin(); eit != arr.edges_end(); ++eit) {
+		renderer.draw(Segment<Inexact>(approximate(eit->source()->point()), approximate(eit->target()->point())).transform(m_options.transformation));
+	}
+}
+}

cartocrow/chorematic_map/choropleth.h

@@ -0,0 +1,170 @@
+#ifndef CARTOCROW_CHOROPLETH_H
+#define CARTOCROW_CHOROPLETH_H
+
+#include <utility>
+#include "../renderer/geometry_painting.h"
+#include "../core/region_arrangement.h"
+#include "../core/arrangement_helpers.h"
+#include "natural_breaks.h"
+
+#include <CGAL/Aff_transformation_2.h>
+
+namespace cartocrow::chorematic_map {
+/// A choropleth map. It is a \ref RegionArrangement where double values are associated with each region.
+/// Thresholds that define classes can be passed to the constructor.
+/// If no thresholds are passed, the Fisher-Jenks natural breaks algorithm is used to compute natural thresholds.
+///
+/// This class represents only an abstract choropleth; to draw one, see \ref ChoroplethPainting.
+class Choropleth {
+  public:
+	std::shared_ptr<RegionArrangement> m_arr;
+	std::shared_ptr<std::unordered_map<std::string, double>> m_data;
+
+    void naturalBreaks(int nBins) {
+        m_thresholds.clear();
+        std::vector<double> values;
+        for (auto& [_, value] : *m_data) {
+            values.push_back(value);
+        }
+        natural_breaks(values.begin(), values.end(), std::back_inserter(m_thresholds), nBins);
+    }
+
+	void rebin() {
+		// Clear
+		m_bins.clear();
+		m_regionToBin.clear();
+
+		// Initialize bins
+		for (int i = 0; i < m_thresholds.size() + 1; ++i) {
+			m_bins.push_back(std::vector<std::string>({}));
+		}
+
+		// Fill bins and regionToBin map
+		for (auto fit = m_arr->faces_begin(); fit != m_arr->faces_end(); ++fit) {
+			auto region = fit->data();
+			if (!m_data->contains(region)) continue;
+			double value = m_data->at(region);
+			int bin = std::distance(m_thresholds.begin(), std::upper_bound(m_thresholds.begin(), m_thresholds.end(), value));
+			m_bins[bin].push_back(region);
+			m_regionToBin[region] = bin;
+		}
+	}
+
+    Choropleth(std::shared_ptr<RegionArrangement> arr,
+               std::shared_ptr<std::unordered_map<std::string, double>> data,
+               int nBins) :
+            m_arr(std::move(arr)), m_data(std::move(data)) {
+        naturalBreaks(nBins);
+        rebin();
+    }
+
+	template <class InputIterator>
+	Choropleth(std::shared_ptr<RegionArrangement> arr,
+	           std::shared_ptr<std::unordered_map<std::string, double>> data,
+	           InputIterator thresholdsBegin, InputIterator thresholdsEnd) :
+	      m_arr(std::move(arr)), m_data(std::move(data)), m_thresholds(thresholdsBegin, thresholdsEnd) {
+		rebin();
+	}
+
+	std::optional<int> regionToBin(const std::string& region) const {
+		if (!m_regionToBin.contains(region)) return std::nullopt;
+		return m_regionToBin.at(region);
+	}
+
+	template <class InputIterator>
+	void setThresholds(InputIterator begin, InputIterator end) {
+		m_thresholds.clear();
+		m_thresholds.resize(0);
+		std::copy(begin, end, std::back_inserter(m_thresholds));
+	}
+
+	std::vector<double>& getThresholds() {
+		return m_thresholds;
+	}
+
+	std::vector<double> getIntervals() {
+		std::optional<double> min;
+		std::optional<double> max;
+		for (auto& [region, value] : *m_data) {
+			if (!min.has_value() || value < *min) {
+				min = value;
+			}
+			if (!max.has_value() || value > *max) {
+				max = value;
+			}
+		}
+		std::vector<double> intervals({*min});
+		for (const auto& t : getThresholds()) {
+			intervals.push_back(t);
+		}
+		intervals.push_back(*max);
+		return intervals;
+	}
+
+    int numberOfBins() const {
+        return m_bins.size();
+    }
+
+    std::vector<Number<Exact>> binAreas() const {
+        std::vector<Number<Exact>> areas;
+        for (int i = 0; i < m_bins.size(); ++i) {
+            areas.emplace_back(0);
+        }
+        for (auto fit = m_arr->faces_begin(); fit != m_arr->faces_end(); ++fit) {
+            auto pwh = face_to_polygon_with_holes<Exact>(fit);
+            auto& region = fit->data();
+            if (!m_regionToBin.contains(region)) continue;
+            auto& bin = m_regionToBin.at(region);
+            areas[bin] += abs(pwh.outer_boundary().area());
+            for (auto& hole : pwh.holes()) {
+                areas[bin] -= abs(hole.area());
+            }
+        }
+        return areas;
+    }
+
+  private:
+	std::vector<double> m_thresholds;
+	std::vector<std::vector<std::string>> m_bins;
+	std::unordered_map<std::string, int> m_regionToBin;
+};
+
+/// Draws a \ref Choropleth. One should pass a color for each bin of the choropleth.
+/// Drawing style can be configured via \ref ChoroplethPainting::Options.
+class ChoroplethPainting : public renderer::GeometryPainting {
+  public:
+	Choropleth& m_choropleth;
+	std::vector<Color> m_colors;
+
+	struct Options {
+		bool drawLabels = false;
+		Color noDataColor = Color(200, 200, 200);
+		CGAL::Aff_transformation_2<Inexact> transformation = CGAL::IDENTITY;
+		double strokeWidth = 1.0;
+		Color strokeColor = Color(0, 0, 0);
+	};
+
+	Options m_options;
+
+	// Needed because bug in clang gcc:
+	// https://stackoverflow.com/questions/53408962/try-to-understand-compiler-error-message-default-member-initializer-required-be
+	static Options defaultOptions() {
+		return {};
+	}
+
+	template <class InputIterator>
+	ChoroplethPainting(Choropleth& choropleth, InputIterator beginColors, InputIterator endColors, Options options = defaultOptions())
+	    : m_choropleth(choropleth), m_colors(beginColors, endColors), m_options(options) {}
+
+	template <class InputIterator>
+	void setColors(InputIterator begin, InputIterator end) {
+		m_colors.clear();
+		m_colors.resize(0);
+		std::copy(begin, end, std::back_inserter(m_colors));
+	}
+
+	void paint(renderer::GeometryRenderer& renderer) const override;
+};
+}
+
+#endif //CARTOCROW_CHOROPLETH_H