21021097492

Committed 15 Jan 2026 05:42AM UTC coverage: 70.124% (+10.1%) from 60.064%

Build # 21021097492

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #752 from eyal0/integration_tests_in_ci

ci: Include integration tests as part of coverage.

Run Details

4430 of 7541 branches covered (58.75%)

Branch coverage included in aggregate %.

3710 of 4067 relevant lines covered (91.22%)

15236187.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

54.04

/geos_helpers.cpp

#ifdef GEOS_VERSION

#include "geos_helpers.hpp"
#include "geometry.hpp"
#include <geos/io/WKTReader.h>
#include <geos/io/WKTWriter.h>
#include <geos/geom/Coordinate.h>
#include <geos/geom/GeometryFactory.h>
#include <boost/pointer_cast.hpp>
#include <geos/version.h>
#include <geos/util.h>
#if ((GEOS_VERSION_MAJOR > 3) ||                           \
     (GEOS_VERSION_MAJOR == 3 && GEOS_VERSION_MINOR > 11))
  #define CoordinateArraySequence CoordinateSequence
  #include <geos/geom/CoordinateSequence.h>
#else
  #include <geos/geom/CoordinateArraySequence.h>
#endif


linestring_type_fp from_geos(const geos::geom::LineString* ls) {
  linestring_type_fp ret;
  ret.reserve(ls->getNumPoints());
  for (size_t i = 0; i < ls->getNumPoints(); i++) {
    const auto& p = ls->getPointN(i);
    ret.push_back(point_type_fp(p->getX(), p->getY()));
  }
  return ret;
}

linestring_type_fp from_geos(const std::unique_ptr<geos::geom::LineString>& ls) {
  return from_geos(ls.get());
}

ring_type_fp from_geos(const geos::geom::LinearRing* ring) {
  ring_type_fp ret;
  ret.reserve(ring->getNumPoints());
  for (size_t i = 0; i < ring->getNumPoints(); i++) {
    const auto& p = ring->getPointN(i);
    ret.push_back(point_type_fp(p->getX(), p->getY()));
  }
  return ret;
}

ring_type_fp from_geos(const std::unique_ptr<geos::geom::LinearRing>& ring) {
  return from_geos(ring.get());
}

polygon_type_fp from_geos(const geos::geom::Polygon* poly) {
  polygon_type_fp ret;
  ret.outer() = from_geos(poly->getExteriorRing());
  ret.inners().reserve(poly->getNumInteriorRing());
  for (size_t i = 0; i < poly->getNumInteriorRing(); i++) {
    ret.inners().push_back(from_geos(poly->getInteriorRingN(i)));
  }
  return ret;
}

polygon_type_fp from_geos(const std::unique_ptr<geos::geom::Polygon>& poly) {
  return from_geos(poly.get());
}

multi_polygon_type_fp from_geos(const std::unique_ptr<geos::geom::MultiPolygon>& mpoly) {
  multi_polygon_type_fp ret;
  ret.reserve(mpoly->getNumGeometries());
  for (size_t i = 0; i < mpoly->getNumGeometries(); i++) {
    ret.push_back(from_geos(mpoly->getGeometryN(i)));
  }
  return ret;
}

multi_linestring_type_fp from_geos(const std::unique_ptr<geos::geom::MultiLineString>& mls) {
  multi_linestring_type_fp ret;
  ret.reserve(mls->getNumGeometries());
  for (size_t i = 0; i < mls->getNumGeometries(); i++) {
    ret.push_back(from_geos(mls->getGeometryN(i)));
  }
  return ret;
}

template <>
multi_polygon_type_fp from_geos(const std::unique_ptr<geos::geom::Geometry>& g) {
  if (dynamic_cast<geos::geom::MultiPolygon*>(g.get())) {
    auto mp = boost::dynamic_pointer_cast<geos::geom::MultiPolygon>(g->clone());
    return from_geos(mp);
  }
  if (dynamic_cast<geos::geom::Polygon*>(g.get())) {
  auto p = boost::dynamic_pointer_cast<geos::geom::Polygon>(g->clone());
    return multi_polygon_type_fp{from_geos(p)};
  }
  geos::io::WKTWriter writer;
  throw std::logic_error("Can't convert to multi_polygon_type_fp: " + writer.write(g.get()));
}

std::unique_ptr<geos::geom::LineString> to_geos(
    const linestring_type_fp& ls) {
  auto geom_factory = geos::geom::GeometryFactory::create();
  auto coords = geos::detail::make_unique<geos::geom::CoordinateArraySequence>(ls.size(), 2 /* dimensions */);
  for (size_t i = 0; i < ls.size(); i++) {
    coords->setAt(geos::geom::Coordinate(ls[i].x(), ls[i].y()), i);
  }
  return geom_factory->createLineString(std::move(coords));
}

std::unique_ptr<geos::geom::LinearRing> to_geos(const ring_type_fp& ring) {
  auto geom_factory = geos::geom::GeometryFactory::create();
  auto coords = geos::detail::make_unique<geos::geom::CoordinateArraySequence>(ring.size(), 2 /* dimensions */);
  for (size_t i = 0; i < ring.size(); i++) {
    // reverse rings for geos.
    coords->setAt(geos::geom::Coordinate(ring[i].x(), ring[i].y()), i);
  }
  return geom_factory->createLinearRing(std::move(coords));
}

std::unique_ptr<geos::geom::Polygon> to_geos(const polygon_type_fp& poly) {
  auto shell = to_geos(poly.outer());
  std::vector<std::unique_ptr<geos::geom::LinearRing>> holes;
  holes.reserve(poly.inners().size());
  for (const auto& inner : poly.inners()) {
    holes.push_back(to_geos(inner));
  }
  auto geom_factory = geos::geom::GeometryFactory::create();
  return geom_factory->createPolygon(std::move(shell), std::move(holes));
}

std::unique_ptr<geos::geom::MultiPolygon> to_geos(const multi_polygon_type_fp& mpoly) {
  std::vector<std::unique_ptr<geos::geom::Polygon>> polys;
  polys.reserve(mpoly.size());
  for (const auto& p : mpoly) {
    polys.push_back(to_geos(p));
  }
  auto geom_factory = geos::geom::GeometryFactory::create();
  return geom_factory->createMultiPolygon(std::move(polys));
}

std::unique_ptr<geos::geom::MultiLineString> to_geos(const multi_linestring_type_fp& mls) {
  std::vector<std::unique_ptr<geos::geom::LineString>> polys;
  polys.reserve(mls.size());
  for (const auto& p : mls) {
    polys.push_back(to_geos(p));
  }
  auto geom_factory = geos::geom::GeometryFactory::create();
  return geom_factory->createMultiLineString(std::move(polys));
}

#endif //GEOS_VERSION

1	#ifdef GEOS_VERSION
2
3	#include "geos_helpers.hpp"
4	#include "geometry.hpp"
5	#include <geos/io/WKTReader.h>
6	#include <geos/io/WKTWriter.h>
7	#include <geos/geom/Coordinate.h>
8	#include <geos/geom/GeometryFactory.h>
9	#include <boost/pointer_cast.hpp>
10	#include <geos/version.h>
11	#include <geos/util.h>
12	#if ((GEOS_VERSION_MAJOR > 3) \|\| \
13	(GEOS_VERSION_MAJOR == 3 && GEOS_VERSION_MINOR > 11))
14	#define CoordinateArraySequence CoordinateSequence
15	#include <geos/geom/CoordinateSequence.h>
16	#else
17	#include <geos/geom/CoordinateArraySequence.h>
18	#endif
19
20
21	linestring_type_fp from_geos(const geos::geom::LineString* ls) {	×
22	linestring_type_fp ret;
23	ret.reserve(ls->getNumPoints());	×
24	for (size_t i = 0; i < ls->getNumPoints(); i++) {	×
25	const auto& p = ls->getPointN(i);	×
26	ret.push_back(point_type_fp(p->getX(), p->getY()));	×
27	}
28	return ret;	×
29	}
30
31	linestring_type_fp from_geos(const std::unique_ptr<geos::geom::LineString>& ls) {	×
32	return from_geos(ls.get());	×
33	}
34
35	ring_type_fp from_geos(const geos::geom::LinearRing* ring) {	16,601!
36	ring_type_fp ret;
37	ret.reserve(ring->getNumPoints());	16,601!
38	for (size_t i = 0; i < ring->getNumPoints(); i++) {	9,355,956!
39	const auto& p = ring->getPointN(i);	9,339,355!
40	ret.push_back(point_type_fp(p->getX(), p->getY()));	18,678,710!
41	}
42	return ret;	16,601✔
43	}
44
45	ring_type_fp from_geos(const std::unique_ptr<geos::geom::LinearRing>& ring) {	×
46	return from_geos(ring.get());	×
47	}
48
49	polygon_type_fp from_geos(const geos::geom::Polygon* poly) {	12,422!
50	polygon_type_fp ret;
51	ret.outer() = from_geos(poly->getExteriorRing());	24,844!
52	ret.inners().reserve(poly->getNumInteriorRing());	12,422!
53	for (size_t i = 0; i < poly->getNumInteriorRing(); i++) {	16,601!
54	ret.inners().push_back(from_geos(poly->getInteriorRingN(i)));	8,358!
55	}
56	return ret;	12,422✔
57	}
58
59	polygon_type_fp from_geos(const std::unique_ptr<geos::geom::Polygon>& poly) {	×
60	return from_geos(poly.get());	6,695!
61	}
62
63	multi_polygon_type_fp from_geos(const std::unique_ptr<geos::geom::MultiPolygon>& mpoly) {	392!
64	multi_polygon_type_fp ret;
65	ret.reserve(mpoly->getNumGeometries());	392!
66	for (size_t i = 0; i < mpoly->getNumGeometries(); i++) {	6,119!
67	ret.push_back(from_geos(mpoly->getGeometryN(i)));	11,454!
68	}
69	return ret;	392✔
70	}
71
72	multi_linestring_type_fp from_geos(const std::unique_ptr<geos::geom::MultiLineString>& mls) {	×
73	multi_linestring_type_fp ret;
74	ret.reserve(mls->getNumGeometries());	×
75	for (size_t i = 0; i < mls->getNumGeometries(); i++) {	×
76	ret.push_back(from_geos(mls->getGeometryN(i)));	×
77	}
78	return ret;	×
79	}
80
81	template <>
82	multi_polygon_type_fp from_geos(const std::unique_ptr<geos::geom::Geometry>& g) {	7,087!
83	if (dynamic_cast<geos::geom::MultiPolygon*>(g.get())) {	7,087!
84	auto mp = boost::dynamic_pointer_cast<geos::geom::MultiPolygon>(g->clone());	784✔
85	return from_geos(mp);	392!
86	}
87	if (dynamic_cast<geos::geom::Polygon*>(g.get())) {	6,695!
88	auto p = boost::dynamic_pointer_cast<geos::geom::Polygon>(g->clone());	13,390!
89	return multi_polygon_type_fp{from_geos(p)};	13,390!
90	}
91	geos::io::WKTWriter writer;	×
92	throw std::logic_error("Can't convert to multi_polygon_type_fp: " + writer.write(g.get()));	×
93	}
94
95	std::unique_ptr<geos::geom::LineString> to_geos(	2,448✔
96	const linestring_type_fp& ls) {
97	auto geom_factory = geos::geom::GeometryFactory::create();	2,448✔
98	auto coords = geos::detail::make_unique<geos::geom::CoordinateArraySequence>(ls.size(), 2 /* dimensions */);	4,896!
99	for (size_t i = 0; i < ls.size(); i++) {	256,691✔
100	coords->setAt(geos::geom::Coordinate(ls[i].x(), ls[i].y()), i);	254,243✔
101	}
102	return geom_factory->createLineString(std::move(coords));	4,896!
103	}
104
105	std::unique_ptr<geos::geom::LinearRing> to_geos(const ring_type_fp& ring) {	19,877✔
106	auto geom_factory = geos::geom::GeometryFactory::create();	19,877✔
107	auto coords = geos::detail::make_unique<geos::geom::CoordinateArraySequence>(ring.size(), 2 /* dimensions */);	39,754!
108	for (size_t i = 0; i < ring.size(); i++) {	5,623,129✔
109	// reverse rings for geos.
110	coords->setAt(geos::geom::Coordinate(ring[i].x(), ring[i].y()), i);	5,603,252✔
111	}
112	return geom_factory->createLinearRing(std::move(coords));	39,754!
113	}
114
115	std::unique_ptr<geos::geom::Polygon> to_geos(const polygon_type_fp& poly) {	16,068✔
116	auto shell = to_geos(poly.outer());	32,136✔
117	std::vector<std::unique_ptr<geos::geom::LinearRing>> holes;	16,068✔
118	holes.reserve(poly.inners().size());	16,068!
119	for (const auto& inner : poly.inners()) {	19,877✔
120	holes.push_back(to_geos(inner));	7,618!
121	}
122	auto geom_factory = geos::geom::GeometryFactory::create();	16,068!
123	return geom_factory->createPolygon(std::move(shell), std::move(holes));	32,136!
124	}
125
126	std::unique_ptr<geos::geom::MultiPolygon> to_geos(const multi_polygon_type_fp& mpoly) {	13,090!
127	std::vector<std::unique_ptr<geos::geom::Polygon>> polys;	13,090✔
128	polys.reserve(mpoly.size());	13,090!
129	for (const auto& p : mpoly) {	29,158✔
130	polys.push_back(to_geos(p));	32,136!
131	}
132	auto geom_factory = geos::geom::GeometryFactory::create();	13,090!
133	return geom_factory->createMultiPolygon(std::move(polys));	26,180!
134	}
135
136	std::unique_ptr<geos::geom::MultiLineString> to_geos(const multi_linestring_type_fp& mls) {	251!
137	std::vector<std::unique_ptr<geos::geom::LineString>> polys;	251✔
138	polys.reserve(mls.size());	251!
139	for (const auto& p : mls) {	2,699✔
140	polys.push_back(to_geos(p));	4,896!
141	}
142	auto geom_factory = geos::geom::GeometryFactory::create();	251!
143	return geom_factory->createMultiLineString(std::move(polys));	502!
144	}
145
146	#endif //GEOS_VERSION

pcb2gcode / pcb2gcode / 21021097492

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous