Complete OpenEMS CSX parser

src/CMakeLists.txt

@@ -12,6 +12,7 @@ target_sources( openemsh
 	"${CMAKE_CURRENT_SOURCE_DIR}/utils/entity.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/utils/tree_node.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/utils/state_management.cpp"
+	"${CMAKE_CURRENT_SOURCE_DIR}/utils/logger.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/utils/progress.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/domain/geometrics/space.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/domain/geometrics/relation.cpp"
@@ -84,6 +85,7 @@ add_executable( openemsh_bin WIN32 )
 target_sources( openemsh_bin
 	PRIVATE
 	"${CMAKE_CURRENT_SOURCE_DIR}/ui/cli/cli.cpp"
+	"${CMAKE_CURRENT_SOURCE_DIR}/ui/cli/logger.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/ui/cli/progress.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/ui/qt/utils/nodegraph/highlightable.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/ui/qt/utils/nodegraph/port.cpp"
@@ -132,6 +134,7 @@ target_sources( openemsh_bin
 	"${CMAKE_CURRENT_SOURCE_DIR}/ui/qt/about_dialog.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/ui/qt/icons.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/ui/qt/main_window.cpp"
+	"${CMAKE_CURRENT_SOURCE_DIR}/ui/qt/logger.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/ui/qt/progress.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/ui/qt/style.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/ui/qt/resources.qrc"

src/domain/board.cpp

@@ -5,6 +5,7 @@
 ///*****************************************************************************
 
 #include <algorithm>
+#include <limits>
 #include <set>
 #include <utility>
 
@@ -65,10 +66,16 @@ shared_ptr<Board> Board::Builder::build(Params&& params) {
 	return make_shared<Board>(
 		std::move(polygons),
 		std::move(fixed_meshline_policy_creators),
+		std::move(material),
 		std::move(params),
 		Caretaker::singleton().get_history_root());
 }
 
+//******************************************************************************
+void Board::Builder::set_background_material(shared_ptr<Material> background) {
+	material = background;
+}
+
 // TODO should be in meshline manager?
 //******************************************************************************
 void Board::Builder::add_fixed_meshline_policy(Axis const axis, Coord const coord) {
@@ -146,12 +153,14 @@ Board::Board(PlaneSpace<vector<shared_ptr<Polygon>>>&& polygons, Params&& params
 Board::Board(
 	PlaneSpace<std::vector<std::shared_ptr<Polygon>>>&& polygons,
 	AxisSpace<std::vector<std::function<void (Board*, Timepoint*)>>>&& fixed_meshline_policy_creators,
+	shared_ptr<Material>&& background,
 	Params&& params,
 	Timepoint* t)
 : Originator(t, BoardState(std::move(polygons)))
 , global_params(make_shared<GlobalParams>(std::move(params), t))
 , conflict_manager(make_shared<ConflictManager>(t))
 , line_policy_manager(make_shared<MeshlinePolicyManager>(global_params.get(), t))
+, material(background)
 , fixed_meshline_policy_creators(std::move(fixed_meshline_policy_creators)) {
 
 	conflict_manager->init(line_policy_manager.get());
@@ -196,8 +205,7 @@ pair<shared_ptr<Material>, remove_const_t<decltype(Polygon::priority)>> Board::f
 	if(!materials.empty())
 		return materials.back();
 	else
-		// TODO if no material return Board::background_material
-		return {};
+		return { material, std::numeric_limits<remove_const_t<decltype(Polygon::priority)>>::min() };
 }
 
 //******************************************************************************
@@ -661,9 +669,7 @@ void Board::detect_individual_edges() {
 
 //******************************************************************************
 void Board::add_fixed_meshline_policies() {
-#warning TODO
-//	for(auto const& axis : AllAxis)
-	for(auto const& axis : { X, Y })
+	for(auto const& axis : AllAxis)
 		add_fixed_meshline_policies(axis);
 }
 

src/domain/board.hpp

@@ -24,6 +24,7 @@
 #include "utils/state_management.hpp"
 #include "conflict_manager.hpp"
 #include "global.hpp"
+#include "material.hpp"
 #include "meshline_policy_manager.hpp"
 //#include "meshline_policy.hpp"
 //#include "range.hpp"
@@ -59,6 +60,7 @@ class Board
 	class Builder {
 	public:
 
+		void set_background_material(std::shared_ptr<Material> background);
 		void add_fixed_meshline_policy(Axis axis, Coord coord);
 		void add_polygon(Plane plane, std::shared_ptr<Material> const& material, std::string const& name, std::size_t priority, Polygon::RangeZ const& z_placement, std::initializer_list<Point> points);
 		void add_polygon(Plane plane, std::shared_ptr<Material> const& material, std::string const& name, std::size_t priority, Polygon::RangeZ const& z_placement, std::vector<std::unique_ptr<Point const>>&& points);
@@ -67,16 +69,19 @@ class Board
 		[[nodiscard]] std::shared_ptr<Board> build(Params&& params = Params());
 
 	private:
+		std::shared_ptr<Material> material;
 		PlaneSpace<std::vector<std::shared_ptr<Polygon>>> polygons;
 		AxisSpace<std::vector<std::function<void (Board*, Timepoint*)>>> fixed_meshline_policy_creators;
 	};
 
+	std::shared_ptr<Material> material;
 	AxisSpace<std::vector<std::function<void (Board*, Timepoint*)>>> const fixed_meshline_policy_creators; // Meant to delay MeshlinePolicies creation at Step time instead of Parse time.
 
 	Board(PlaneSpace<std::vector<std::shared_ptr<Polygon>>>&& polygons, Params&& params, Timepoint* t);
 	Board(
 		PlaneSpace<std::vector<std::shared_ptr<Polygon>>>&& polygons,
 		AxisSpace<std::vector<std::function<void (Board*, Timepoint*)>>>&& fixed_meshline_policy_creators,
+		std::shared_ptr<Material>&& background,
 		Params&& params,
 		Timepoint* t);
 

src/domain/conflicts/conflict_colinear_edges.cpp

@@ -33,6 +33,7 @@ void ConflictColinearEdges::append(Edge* edge, Timepoint* t) {
 void ConflictColinearEdges::auto_solve(MeshlinePolicyManager& line_policy_manager) {
 	size_t normal_min = 0;
 	size_t normal_max = 0;
+	bool must_be_oneline = false;
 
 	auto const& s = get_current_state();
 
@@ -49,15 +50,21 @@ void ConflictColinearEdges::auto_solve(MeshlinePolicyManager& line_policy_manage
 		case Normal::YMIN:
 		case Normal::ZMIN:
 			++normal_min;
-			break;
+			continue;
 		case Normal::XMAX:
 		case Normal::YMAX:
 		case Normal::ZMAX:
 			++normal_max;
+			continue;
+		case Normal::NONE:
+			must_be_oneline = true;
 			break;
 		default:
-			break;
+			::unreachable();
 		}
+
+		if(must_be_oneline)
+			break;
 	}
 
 	optional<Coord> const coord = domain::coord(s.edges.front()->p0(), s.edges.front()->axis);
@@ -78,7 +85,11 @@ void ConflictColinearEdges::auto_solve(MeshlinePolicyManager& line_policy_manage
 	};
 
 	if(coord) {
-		if(normal_min && normal_max) {
+		if(must_be_oneline) {
+			add_policy(
+				MeshlinePolicy::Policy::ONELINE,
+				MeshlinePolicy::Normal::NONE);
+		} else if(normal_min && normal_max) {
 			add_policy(
 				MeshlinePolicy::Policy::HALFS,
 				MeshlinePolicy::Normal::NONE);

src/domain/conflicts/conflict_too_close_meshline_policies.cpp

@@ -36,52 +36,49 @@ void ConflictTooCloseMeshlinePolicies::auto_solve(MeshlinePolicyManager& line_po
 	if(a->axis != b->axis)
 		return;
 
-	auto [policy, normal] = [&]() -> tuple<optional<MeshlinePolicy::Policy>, optional<MeshlinePolicy::Normal>> {
+	auto [policy, normal, coord] = [&]() -> tuple<optional<MeshlinePolicy::Policy>, optional<MeshlinePolicy::Normal>, optional<Coord>> {
 		auto const& state_a = a->get_current_state();
 		auto const& state_b = b->get_current_state();
 
-		if(state_a.policy == MeshlinePolicy::Policy::THIRDS && state_b.policy == MeshlinePolicy::Policy::THIRDS) {
+		if(state_a.policy == MeshlinePolicy::Policy::ONELINE && state_b.policy == MeshlinePolicy::Policy::ONELINE) {
+			return { MeshlinePolicy::Policy::ONELINE, MeshlinePolicy::Normal::NONE, mid(a->coord, b->coord) };
+		} else if(state_a.policy == MeshlinePolicy::Policy::ONELINE && state_b.policy != MeshlinePolicy::Policy::ONELINE) {
+			return { MeshlinePolicy::Policy::ONELINE, MeshlinePolicy::Normal::NONE, a->coord };
+		} else if(state_a.policy != MeshlinePolicy::Policy::ONELINE && state_b.policy == MeshlinePolicy::Policy::ONELINE) {
+			return { MeshlinePolicy::Policy::ONELINE, MeshlinePolicy::Normal::NONE, b->coord };
+		} else if(state_a.policy == MeshlinePolicy::Policy::THIRDS && state_b.policy == MeshlinePolicy::Policy::THIRDS) {
 			if(state_a.normal != state_b.normal) {
-				return { MeshlinePolicy::Policy::HALFS, MeshlinePolicy::Normal::NONE };
+				return { MeshlinePolicy::Policy::HALFS, MeshlinePolicy::Normal::NONE, mid(a->coord, b->coord) };
 			} else if(state_a.normal == MeshlinePolicy::Normal::MIN
 			       && state_b.normal == MeshlinePolicy::Normal::MIN) {
-				return { MeshlinePolicy::Policy::THIRDS, MeshlinePolicy::Normal::MIN };
+				return { MeshlinePolicy::Policy::THIRDS, MeshlinePolicy::Normal::MIN, mid(a->coord, b->coord) };
 			} else if(state_a.normal == MeshlinePolicy::Normal::MAX
 			       && state_b.normal == MeshlinePolicy::Normal::MAX) {
-				return { MeshlinePolicy::Policy::THIRDS, MeshlinePolicy::Normal::MAX };
+				return { MeshlinePolicy::Policy::THIRDS, MeshlinePolicy::Normal::MAX, mid(a->coord, b->coord) };
 			}
 		} else if((state_a.policy == MeshlinePolicy::Policy::HALFS && state_b.policy == MeshlinePolicy::Policy::HALFS)
 		       || (state_a.policy == MeshlinePolicy::Policy::HALFS && state_b.policy == MeshlinePolicy::Policy::THIRDS)
 		       || (state_a.policy == MeshlinePolicy::Policy::THIRDS && state_b.policy == MeshlinePolicy::Policy::HALFS)) {
-			return { MeshlinePolicy::Policy::HALFS, MeshlinePolicy::Normal::NONE };
-		} //else if(ONE and *) { // TODO }
-		// TODO should not have been created ?
-		// TODO only one, remove other?
-		// TODO one and one : merge
+			return { MeshlinePolicy::Policy::HALFS, MeshlinePolicy::Normal::NONE, mid(a->coord, b->coord) };
+		}
 
-		return { nullopt, nullopt };
+		return { nullopt, nullopt, nullopt };
 	} ();
 
-	if(policy && normal) {
+	if(policy && normal && coord) {
 		auto [t, state] = make_next_state();
 		state.meshline_policy = line_policy_manager.add_meshline_policy(
 			{ this },
 			axis,
 			policy.value(),
 			normal.value(),
-			mid(a->coord, b->coord),
+			coord.value(),
 			true,
 			t);
 		state.solution = state.meshline_policy;
 		state.is_solved = true;
 		set_state(t, state);
 	}
-
-	// TODO detect axis
-	// TODO detect 2 vs 3 rule (vs 1 rule?)
-	// TODO detect normal
-	// TODO create MLP
-
 }
 
 // TODO Interval class : just mesh() from adjacent / neibourgh

src/domain/geometrics/polygon.cpp

@@ -4,6 +4,9 @@
 /// @author Thomas Lepoix <thomas.lepoix@protonmail.ch>
 ///*****************************************************************************
 
+#include <cmath>
+#include <numbers>
+
 #include "utils/unreachable.hpp"
 #include "edge.hpp"
 #include "point.hpp"
@@ -50,8 +53,8 @@ vector<shared_ptr<Edge>> detect_edges(vector<unique_ptr<Point const>> const& poi
 		edges.push_back(make_shared<Edge>(plane, prev, point.get(), t));
 		prev = point.get();
 	}
-	edges.shrink_to_fit();
 
+	edges.shrink_to_fit();
 	return edges;
 }
 
@@ -204,10 +207,26 @@ relation::PolygonPoint Polygon::relation_to(Point const& point) const noexcept {
 /// Check if two Z ranges overlap or just touch each other.
 ///*****************************************************************************
 bool does_overlap(Polygon::RangeZ const& a, Polygon::RangeZ const& b) noexcept {
-	return (b.min >= a.min && b.min <= a.max)
-	    || (b.max >= a.min && b.max <= a.max)
-	    || (a.min >= b.min && a.min <= b.max)
-	    || (a.max >= b.min && a.max <= b.max);
+	return min(a.max, b.max) >= max(a.min, b.min);
+}
+
+/// Points on axes guaranteed. CCW oriented.
+///*****************************************************************************
+vector<unique_ptr<Point const>> circle_to_points(Point const& center, double radius, size_t n_slices_per_quarter) {
+	if(!n_slices_per_quarter)
+		n_slices_per_quarter = 1;
+
+	double const angle = (numbers::pi/2) / n_slices_per_quarter;
+	size_t const n = n_slices_per_quarter * 4;
+
+	vector<unique_ptr<Point const>> points;
+	for(size_t i = 0; i < n; ++i) {
+		double a = angle * i;
+		points.emplace_back(make_unique<Point const>(center.x + radius * cos(a), center.y + radius * sin(a)));
+	}
+
+	points.shrink_to_fit();
+	return points;
 }
 
 } // namespace domain

src/domain/geometrics/polygon.hpp

@@ -90,4 +90,7 @@ std::vector<std::shared_ptr<Edge>> detect_edges(std::vector<std::unique_ptr<Poin
 //******************************************************************************
 bool does_overlap(Polygon::RangeZ const& a, Polygon::RangeZ const& b) noexcept;
 
+//******************************************************************************
+std::vector<std::unique_ptr<Point const>> circle_to_points(Point const& center, double radius, std::size_t n_slices_per_quarter = 9);
+
 } // namespace domain

src/domain/global.hpp

@@ -7,7 +7,10 @@
 #pragma once
 
 #include <cstddef>
+#include <utility>
+#include <vector>
 
+#include "geometrics/space.hpp"
 #include "utils/state_management.hpp"
 
 namespace domain {
@@ -17,12 +20,14 @@ struct Params {
 	bool has_grid_already = false; // TODO would better fit in infra layer?
 	double proximity_limit = 1; // TODO must be linked to initial d
 	double smoothness = 2;
-	std::size_t lmin = 10;
+	std::size_t lmin = 2;
 	double dmax = 2.5;
 
 	std::size_t diagonal_lmin = 2;
 	double diagonal_dmax = 0.2;
 	double consecutive_diagonal_minimal_angle = 20; // Limite between acute / obtuse angles.
+
+	std::vector<std::pair<Axis, double>> input_fixed_meshlines;
 };
 
 //******************************************************************************

src/domain/material.cpp

@@ -38,22 +38,33 @@ Material::Material(Type type, string const& name, optional<Color> const& fill_co
 //******************************************************************************
 strong_ordering Material::operator<=>(Material const& other) const noexcept {
 	switch(type) {
+	case Type::PORT:
+		switch(other.type) {
+		case Type::PORT: return strong_ordering::equivalent;
+		case Type::CONDUCTOR: return strong_ordering::greater;
+		case Type::DIELECTRIC: return strong_ordering::greater;
+		case Type::AIR: return strong_ordering::greater;
+		default: ::unreachable();
+		}
 	case Type::CONDUCTOR:
 		switch(other.type) {
+		case Type::PORT: return strong_ordering::less;
 		case Type::CONDUCTOR: return strong_ordering::equivalent;
 		case Type::DIELECTRIC: return strong_ordering::greater;
 		case Type::AIR: return strong_ordering::greater;
 		default: ::unreachable();
 		}
 	case Type::DIELECTRIC:
 		switch(other.type) {
+		case Type::PORT: return strong_ordering::less;
 		case Type::CONDUCTOR: return strong_ordering::less;
 		case Type::DIELECTRIC: return strong_ordering::equivalent;
 		case Type::AIR: return strong_ordering::greater;
 		default: ::unreachable();
 		}
 	case Type::AIR:
 		switch(other.type) {
+		case Type::PORT: return strong_ordering::less;
 		case Type::CONDUCTOR: return strong_ordering::less;
 		case Type::DIELECTRIC: return strong_ordering::less;
 		case Type::AIR: return strong_ordering::equivalent;

src/domain/material.hpp

@@ -18,6 +18,7 @@ class Material {
 
 	enum class Type {
 //		DUMP,
+		PORT,
 //		PEC,
 		CONDUCTOR,
 		DIELECTRIC,

src/domain/mesh/meshline_policy.cpp

@@ -23,14 +23,12 @@ MeshlinePolicy::MeshlinePolicy(
 		Coord const coord,
 		Timepoint* t,
 		vector<IMeshLineOrigin*> const& origins,
-		bool const is_enabled,
-		double const res_factor)
+		bool const is_enabled)
 : Originator(t, {
 	.policy = policy,
 	.normal = normal,
 	.is_enabled = is_enabled,
-	.res_factor = res_factor,
-	.d = global_params->get_current_state().dmax / res_factor,
+	.d = global_params->get_current_state().dmax / 2, // TODO this seems to help while center of intervals is buggy
 	.origins = origins
 })
 , axis(axis)
@@ -40,7 +38,8 @@ MeshlinePolicy::MeshlinePolicy(
 
 //******************************************************************************
 optional<Meshline> MeshlinePolicy::mesh() {
-	if(get_current_state().policy == Policy::ONELINE)
+	auto const& state = get_current_state();
+	if(state.is_enabled && state.policy == Policy::ONELINE)
 		return Meshline(coord, this);
 	else
 		return nullopt;