finished offsetPolyline

Author: skramm

docs/homog2d_history.md

@@ -30,10 +30,12 @@ now all of these return the number of points that the primitive has, as a `size_
   - added `getBisectorLines()` for polyline objects
   - added `getOSegment()` to Polyline class
   - changed normalization of closed polyline: now constant orientation
-  - `getLmPoint()` and associated functions now return a `std::pair`, so user can fetch its position in the container.
+   - `getLmPoint()` and associated functions now return a `std::pair`, so user can fetch its position in the container.
   The downside is that it is now not possible to use a `std::list` as input container.
   See [details here](homog2d_manual.md#extremum_points).
   - renamed `getOrthogonalLine()` to `getOrthogLine()` so it's similar to `getOrthogSegment()`
+  - added member function `getPointAt()` to class `OSegment`
+
 
 - [v2.12](https://github.com/skramm/homog2d/releases/tag/v2.12), released on 2025-01-26
   - **heavy architectural change**: runtime polymorphism is now achieved in a more modern way, using `std::variant`, [see here](homog2d_manual.md#section_rtp).

docs/homog2d_manual.md

@@ -1072,7 +1072,19 @@ The minimum value for `nb` is 3 (will generate an equilateral triangle), the fun
 
 [source](../misc/figures_src/src/polyline_rcp_1.cpp)
 
-#### 3.4.12 - Importing from boost::geometry
+
+#### 3.4.12 - Offsetted polyline
+
+For closed Polyline objects, the member function `getOffsetPoly()` can compute a new polyline at a given distance.
+Its argument is a distance (numerical value).
+If positive, the returned polyline will be "outside", if negative, il will be inside.
+
+An optional second argument of type `OffsetPolyParams` holds a boolean value `_angleSplit` that can be set to `true` to "smoothen" the return polyline, by adding some points on sharp angles
+(applies only to "outside" computation).
+
+See [showcase 22](homog2d_showcase.md#sc22)
+
+#### 3.4.13 - Importing from boost::geometry
 <a name="boost_geom_1"></a>
 
 If the symbol `HOMOG2D_USE_BOOSTGEOM` is defined (see [build options](#build_options)), you can import a Polyline from a boost Polygon type.
@@ -1159,7 +1171,7 @@ bool b2 = isCircle( ell, 1E-15 );
 <a name="p_commonf"></a>
 
 All the types above share some common functions, that are also declared as virtual in the root class `Root`.
-Thus, this enable classical pointer-based runtime polymorphism, [see here](#section_rtp).
+Thus, this enables classical pointer-based runtime polymorphism, [see here](#section_rtp).
 
 All of these are `const`.
 The names of these functions are:

homog2d.hpp

@@ -5990,17 +5990,6 @@ struct OffsetPolyParams
 	bool _angleSplit = false;
 };
 
-#if 1
-struct TmpDebug
-{
-	Point2d_<double> pt1;
-	Point2d_<double> pt_cut;
-	Point2d_<double> ptnew;
-	std::vector<Segment_<double>> segs;
-	std::pair<Line2d_<double>,Line2d_<double>> plines;
-	std::pair<OSegment_<double>,OSegment_<double>> psegs;
-};
-#endif
 
 namespace base {
 
@@ -6607,8 +6596,7 @@ Sfinae should resolve ONLY for CPolyline
 public:
 	template<typename T>
 	PolylineBase<typ::IsClosed,FPT>
-	getOffsetPoly( T value, TmpDebug&, OffsetPolyParams p=OffsetPolyParams{} ) const;
-//	getOffsetPoly( T value, OffsetPolyParams p=OffsetPolyParams{} ) const;
+	getOffsetPoly( T value, OffsetPolyParams p=OffsetPolyParams{} ) const;
 
 	std::vector<Line2d_<HOMOG2D_INUMTYPE>>
 	getBisectorLines() const
@@ -6624,29 +6612,6 @@ Sfinae should resolve ONLY for CPolyline
 }; // class PolylineBase
 
 
-//------------------------------------------------------------------
-/// Helper function for cutting angles, used in getOffsetPoly()
-/// Issue: output points are in wrong order when angle not convex
-template<typename FP1,typename FP2>
-PointPair_<HOMOG2D_INUMTYPE>
-p_computeAngleCut(
-	Point2d_<FP1>                               pt1,  ///< source polyline point
-	Point2d_<HOMOG2D_INUMTYPE>                  pt2,  ///< intersection point that we want to "cut"
-	const std::pair<Line2d_<FP2>,Line2d_<FP2>>& pli   ///< pair of lines that we want to joint before the point pt2
-//	TmpDebug& debug
-)
-{
-	Segment_<HOMOG2D_INUMTYPE> seg( pt1, pt2 );
-//	debug.seg= seg;
-	auto mid = seg.getCenter();
-	auto oline = seg.getLine().getOrthogLine( mid );
-	auto inters1 = oline.intersects(pli.first);
-	auto inters2 = oline.intersects(pli.second);
-	return std::make_pair(
-		inters1.get(),
-		inters2.get()
-	);
-}
 //------------------------------------------------------------------
 /// Return an "offsetted" closed polyline, requires simple polygon (CPolyline AND no crossings) as input
 /**
@@ -6658,11 +6623,11 @@ On failure (for whatever reason), will return an empty CPolyline
 template<typename PLT,typename FPT>
 template<typename T>
 PolylineBase<typ::IsClosed,FPT>
-PolylineBase<PLT,FPT>::getOffsetPoly( T dist, TmpDebug& dbg, OffsetPolyParams params ) const
-//PolylineBase<PLT,FPT>::getOffsetPoly( T dist, OffsetPolyParams params ) const
+PolylineBase<PLT,FPT>::getOffsetPoly( T dist, OffsetPolyParams params ) const
 {
 	HOMOG2D_CHECK_IS_NUMBER(T);
-	auto dist0 = (HOMOG2D_INUMTYPE)dist;
+	auto dist0 = (HOMOG2D_INUMTYPE)dist; // casting
+
 	bool valid = true;
 	if( homog2d_abs(dist) < thr::nullDistance() )
 	{
@@ -6684,24 +6649,19 @@ PolylineBase<PLT,FPT>::getOffsetPoly( T dist, TmpDebug& dbg, OffsetPolyParams pa
 
 	p_normalizePoly();
 
-	auto side = (dist<0 ? PointSide::Left : PointSide::Right);
-
 	size_t current = 0;
-	bool paraLines = false;
+//	bool paraLines = false;
 
 	std::vector<Point2d_<FPT>> v_out;
 	auto osegs = getOSegs();
 	auto oseg1 = osegs.at(current);
 	do
 	{
-		auto next1 = (current==size()-1 ? 0 : current+1);
-		auto next2 = (current==size()-1 ? 0 : current+1);
+		auto next = (current==size()-1 ? 0 : current+1);
 
-		auto pt1 = getPoint(current);
-		auto pt2 = getPoint(next1);
-		auto pt3 = getPoint(next2);
+		auto pt1 = getPoint(next);
 
-		auto oseg2 = osegs.at(next1);
+		auto oseg2 = osegs.at(next);
 
 		auto psegs1 = oseg1.getParallelSegs(homog2d_abs(dist0));
 		auto psegs2 = oseg2.getParallelSegs(homog2d_abs(dist0));
@@ -6718,37 +6678,34 @@ PolylineBase<PLT,FPT>::getOffsetPoly( T dist, TmpDebug& dbg, OffsetPolyParams pa
 		auto li2 = pseg2->getLine();
 		if( !areParallel(li1,li2) )
 		{
-			auto pt = li1 * li2;
-			if( !params._angleSplit || getAngle(oseg1,oseg2)>0 )
+			auto pt_int = li1 * li2;
+			if( !params._angleSplit || getAngle(oseg1,oseg2)>0 || dist < 0 )
 			{
-				v_out.push_back( pt );  // add point intersection of the two lines
+				v_out.push_back( pt_int );  // add point intersection of the two lines
 			}
 			else
 			{
-				auto sseg = OSegment_<HOMOG2D_INUMTYPE>( pt, pt2 );
-				std::cout << "seg=" << oseg << '\n';
-				dbg.segs.push_back( oseg );
-
+				auto oseg = OSegment_<HOMOG2D_INUMTYPE>( pt1, pt_int );
+				auto dist_cut = std::min( oseg.length(), dist0 );
 
-				auto dist2 = pt2.distTo( seg.getCenter() );
-				auto dist_cut = std::min( dist2, dist0 );
-				std::cout << "current:" << current << " d0=" << dist0 << " d2=" << dist2 << " dist_cut="<<dist_cut << '\n';
 				auto pt_cut = oseg.getPointAt( dist_cut );
-				dbg.pt_cut = pt_cut;
-				auto oli = seg.getLine().getOrthogLine( pt_cut );
+				auto oli = oseg.getLine().getOrthogLine( pt_cut );
+
 				auto pt_cut1 = oli * li1;
 				auto pt_cut2 = oli * li2;
+
 				v_out.push_back( pt_cut1 );
-				v_out.push_back( pt_cut2 );
+				if( pt_cut1 != pt_cut2 )        // so we don't add two identical pts (in case they were computed as such)
+					v_out.push_back( pt_cut2 );
 			}
 		}
-		else
-			std::cout << "parallel!\n";
+//		else
+//			std::cout << "parallel!\n";
 
 		current++;
 		oseg1 = oseg2;
 	}
-	while( current<size() && !paraLines );
+	while( current<size() ); //&& !paraLines );
 
 	return PolylineBase<typ::IsClosed,FPT>( v_out );
 }
@@ -6966,6 +6923,9 @@ getTmPoint( const T& t )
 /**
 - first: the point
 - second: the distance (index) from begin position
+
+\todo 20250222: CHANGE RETURN TYPE! => should return an iterator, not a pair
+(so this allows usage of any non-random access container)
 */
 template<
 	typename T,

misc/demo_opencv.cpp

@@ -2004,12 +2004,8 @@ void process_PO( IM& im, const POL& pol, Param_PO& data )
 
 	if( pol.isSimple() )
 	{
-		TmpDebug dbg;
-		auto cpoly_off = pol.getOffsetPoly( (data._side?1:-1)*data._offsetDist, dbg, data._params );
-		draw( im, cpoly_off , img::DrawParams().showPoints().setColor(0,0,250) );
-
-		draw( im, dbg.segs, img::DrawParams().showPoints().setColor(0,250,0) );
-		draw( im, dbg.pt_cut, img::DrawParams().showPoints().setColor(250,0,200) );
+		auto cpoly_off = pol.getOffsetPoly( (data._side?1:-1)*data._offsetDist, data._params );
+		draw( im, cpoly_off , img::DrawParams().showPoints(false).setColor(0,0,250) );
 
 		draw( im, dbg.psegs );
 		auto centr = pol.centroid();

misc/homog2d_test.cpp

@@ -2566,6 +2566,15 @@ TEST_CASE( "Ellipse", "[ell1]" )
 		CHECK( el.isCircle() == false );
 	}
 }
+
+TEST_CASE( "OSegment getPointAt()", "[oseg-pt-at]" )
+{
+	OSegment_<NUMTYPE> s1( 0,0,10,0);
+	CHECK( s1.getPointAt(0) == Point2d_<NUMTYPE>(0,0) );
+	CHECK( s1.getPointAt(5) == Point2d_<NUMTYPE>(5,0) );
+	CHECK( s1.getPointAt(10) == Point2d_<NUMTYPE>(10,0) );
+	CHECK( s1.getPointAt(20) == Point2d_<NUMTYPE>(20,0) );
+}
 
 TEST_CASE( "OSegment point side", "[oseg-pt-side]" )
 {

misc/showcase/showcase13.cpp

@@ -38,10 +38,10 @@ int main( int, const char** )
 		cir.set( vec ); // Minimum Enclosing Circle (MEC)
 		cir.draw( im, img::DrawParams().setColor(0,100,150) );
 
-		getTmPoint(vec).draw( im, extr_col );
-		getRmPoint(vec).draw( im, extr_col );
-		getLmPoint(vec).draw( im, extr_col );
-		getBmPoint(vec).draw( im, extr_col );
+		getTmPoint(vec).first.draw( im, extr_col );
+		getRmPoint(vec).first.draw( im, extr_col );
+		getLmPoint(vec).first.draw( im, extr_col );
+		getBmPoint(vec).first.draw( im, extr_col );
 
 		std::ostringstream oss;
 		oss << "showcase13_" << std::setfill('0') << std::setw(2) << i << ".svg";

misc/showcase/showcase22.cpp

@@ -25,7 +25,6 @@ int main( int, const char** )
 	auto pol2 = H2 * p0;
 
 	auto delta = 5.6;
-//	img::Image<img::SvgImage> im( 500, 250 );
 	img::Image<img::SvgImage> im( 500, 250 );
 
 	std::vector<CPolyline> v_poly1, v_poly2;