Commit 6ac8188f authored by tomasz.wlostowski@cern.ch's avatar tomasz.wlostowski@cern.ch
Browse files

common: minimum version of the shape library

parent b0357ce9

common/CMakeLists.txt

+4 −0
Original line number Original line Diff line number Diff line
@@ -162,6 +162,10 @@ set(COMMON_SRCS 
  tool/tool_event.cpp

  tool/tool_event.cpp

  tool/tool_interactive.cpp

  tool/tool_interactive.cpp

  tool/context_menu.cpp

  tool/context_menu.cpp

  

  geometry/seg.cpp

  geometry/shape_line_chain.cpp

  geometry/shape_collisions.cpp

  )

  )





add_library(common STATIC ${COMMON_SRCS})

add_library(common STATIC ${COMMON_SRCS})

common/geometry/seg.cpp

0 → 100644
+150 −0
Original line number Original line Diff line number Diff line 
/*

 * This program source code file is part of KiCad, a free EDA CAD application.

 *

 * Copyright (C) 2013 CERN

 * @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, you may find one here:

 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html

 * or you may search the http://www.gnu.org website for the version 2 license,

 * or you may write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

 */





#include <geometry/seg.h>



template <typename T> int sgn(T val) {

    return (T(0) < val) - (val < T(0));

}



bool SEG::PointCloserThan (const VECTOR2I& aP, int dist) const

{

	VECTOR2I   	  d = b - a;

	ecoord dist_sq = (ecoord) dist * dist;



 	SEG::ecoord l_squared = d.Dot(d);

    SEG::ecoord t = d.Dot(aP - a);





    if( t <= 0 || !l_squared )

    	return (aP - a).SquaredEuclideanNorm() < dist_sq;

    else if( t >= l_squared ) 

    	return (aP - b).SquaredEuclideanNorm() < dist_sq;





	int dxdy =  abs(d.x) - abs(d.y);	



    if( (dxdy >= -1 && dxdy <= 1) || abs(d.x) <= 1 || abs(d.y) <= 1)

    {

    	int ca = -sgn(d.y);

    	int cb = sgn(d.x);

    	int cc = -ca * a.x - cb * a.y;

    	

		ecoord num = ca * aP.x + cb * aP.y + cc;

		num *= num;



		if(ca && cb)

			num >>= 1;



		if(num > (dist_sq + 100))

			return false;

		else if(num < (dist_sq - 100))

			return true;

    }



	VECTOR2I nearest;    

    nearest.x = a.x + rescale(t, (ecoord)d.x, l_squared);

    nearest.y = a.y + rescale(t, (ecoord)d.y, l_squared);



    return (nearest - aP).SquaredEuclideanNorm() <= dist_sq;

}



SEG::ecoord SEG::SquaredDistance( const SEG& aSeg ) const 

{

		// fixme: rather inefficient.... 

		if(Intersect(aSeg))

			return 0;



		const VECTOR2I pts[4] =

		{

			aSeg.NearestPoint(a) - a,

			aSeg.NearestPoint(b) - b,

			NearestPoint(aSeg.a) - aSeg.a,

			NearestPoint(aSeg.b) - aSeg.b

			};



		ecoord m = VECTOR2I::ECOORD_MAX;

		for (int i = 0; i<4 ; i++)

			m = std::min(m, pts[i].SquaredEuclideanNorm());

		return m;

}

	

OPT_VECTOR2I SEG::Intersect( const SEG& aSeg, bool aIgnoreEndpoints, bool aLines ) const

{

	const VECTOR2I e (b - a);

	const VECTOR2I f (aSeg.b - aSeg.a);

	const VECTOR2I ac (aSeg.a - a);

	

	ecoord d = f.Cross(e);

	ecoord p = f.Cross(ac);

	ecoord q = e.Cross(ac);

	

	if(d == 0)

		return OPT_VECTOR2I();

	if (!aLines && d > 0 && (q < 0 || q > d || p < 0 || p > d))

		return OPT_VECTOR2I();

	if (!aLines && d < 0 && (q < d || p < d || p > 0 || q > 0))

		return OPT_VECTOR2I();

	if (!aLines && aIgnoreEndpoints && (q == 0 || q == d) && (p == 0 || p == d))

		return OPT_VECTOR2I();

		

	

	 VECTOR2I  ip ( aSeg.a.x + rescale(q, (ecoord)f.x, d),

					  aSeg.a.y + rescale(q, (ecoord)f.y, d) );



	 return ip;

}





bool SEG::ccw ( const VECTOR2I& a, const VECTOR2I& b, const VECTOR2I &c ) const

{

	return (ecoord)(c.y - a.y) * (b.x - a.x) > (ecoord)(b.y - a.y) * (c.x - a.x);

}



bool SEG::Collide( const SEG& aSeg, int aClearance ) const 

{

	// check for intersection 

	// fixme: move to a method

	if( ccw(a,aSeg.a,aSeg.b) != ccw(b,aSeg.a,aSeg.b) && ccw(a,b,aSeg.a) != ccw(a,b,aSeg.b) )

		return true;



#define CHK(_seg, _pt) \

	if( (_seg).PointCloserThan (_pt, aClearance ) ) return true;

	

	CHK(*this, aSeg.a);

	CHK(*this, aSeg.b);

	CHK(aSeg, a);

	CHK(aSeg, b);



#undef CHK



	return false;

}

		

bool SEG::Contains(const VECTOR2I& aP) const

{

	return PointCloserThan(aP, 1);

}

common/geometry/shape_collisions.cpp

0 → 100644
+210 −0
Original line number Original line Diff line number Diff line 
/*

 * This program source code file is part of KiCad, a free EDA CAD application.

 *

 * Copyright (C) 2013 CERN

 * @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, you may find one here:

 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html

 * or you may search the http://www.gnu.org website for the version 2 license,

 * or you may write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

 */



#include <math/vector2d.h>



#include <geometry/shape.h>

#include <geometry/shape_line_chain.h>

#include <geometry/shape_circle.h>

#include <geometry/shape_rect.h>



typedef typename VECTOR2I::extended_type ecoord;



static inline bool Collide( const SHAPE_CIRCLE& a, const SHAPE_CIRCLE& b, int clearance, bool needMTV, VECTOR2I& aMTV )

{

	ecoord min_dist = clearance + a.GetRadius() + b.GetRadius();

	ecoord min_dist_sq = min_dist * min_dist;

		

	const VECTOR2I delta = b.GetCenter() - a.GetCenter();



	ecoord dist_sq = delta.SquaredEuclideanNorm();



	if ( dist_sq >= min_dist_sq )

		return false;

	

	if ( needMTV )

		aMTV = delta.Resize( sqrt (abs(min_dist_sq - dist_sq)) + 1);



	return true;

}



static inline  bool Collide( const SHAPE_RECT& a, const SHAPE_CIRCLE& b, int clearance, bool needMTV, VECTOR2I& aMTV )

{

	const VECTOR2I c = b.GetCenter();

	const VECTOR2I p0 = a.GetPosition();

	const VECTOR2I size = a.GetSize();

	const ecoord r = b.GetRadius();

	const ecoord min_dist = clearance + r;

	const ecoord min_dist_sq = min_dist * min_dist;



	if (a.BBox(0).Contains(c))

		return true;

			

	const VECTOR2I vts[] = { 

						VECTOR2I(p0.x, 			p0.y),

						VECTOR2I(p0.x,			p0.y + size.y),

						VECTOR2I(p0.x + size.x, p0.y + size.y),

						VECTOR2I(p0.x + size.x, p0.y),

						VECTOR2I(p0.x, 			p0.y) };



	ecoord nearest_seg_dist_sq = VECTOR2I::ECOORD_MAX;

	VECTOR2I nearest;



	bool inside =  c.x >= p0.x && c.x <= (p0.x + size.x) 

				&& c.y >= p0.y && c.y <= (p0.y + size.y);



	if(!inside)

	{



		for (int i = 0; i < 4; i++)

		{

			const SEG seg (vts[i], vts[i+1]);

			ecoord dist_sq = seg.SquaredDistance ( c );

		



			if(dist_sq < min_dist_sq)

			{

				if(!needMTV)

					return true;

				else

				{

					nearest = seg.NearestPoint ( c );

					nearest_seg_dist_sq = dist_sq;

				}

			}

		}

	}



	if(nearest_seg_dist_sq >= min_dist_sq && !inside)

		return false;



	VECTOR2I delta = c - nearest;



	if(!needMTV)

		return true;



	if(inside)

		aMTV = -delta.Resize(sqrt(abs(r * r + nearest_seg_dist_sq) + 1));

	else

		aMTV = delta.Resize(sqrt(abs(r * r - nearest_seg_dist_sq) + 1));



	return true;

}



static inline  bool Collide( const SHAPE_CIRCLE& a, const SHAPE_LINE_CHAIN& b, int clearance, bool needMTV, VECTOR2I& aMTV )

{

	for (int s = 0; s < b.SegmentCount(); s++)

	{

		if ( a.Collide (b.CSegment(s), clearance))

			return true;

	}

	

	return false;	

}



static inline bool Collide( const SHAPE_LINE_CHAIN& a, const SHAPE_LINE_CHAIN& b, int clearance, bool needMTV, VECTOR2I& aMTV )

{

	for( int i = 0; i < b.SegmentCount() ;i++)

		if(a.Collide(b.CSegment(i), clearance))

			return true;

	return false;

}





static inline bool Collide( const SHAPE_RECT& a, const SHAPE_LINE_CHAIN& b, int clearance, bool needMTV, VECTOR2I& aMTV )

{

	for (int s = 0; s < b.SegmentCount(); s++)

	{

		SEG seg = b.CSegment(s);

			if ( a.Collide (seg, clearance))

				return true;

	}



	return false;

}







bool CollideShapes ( const SHAPE *a, const SHAPE *b, int clearance, bool needMTV, VECTOR2I& aMTV )

{

	switch(a->Type())

	{

		case SH_RECT:

			switch(b->Type())

			{

				case SH_CIRCLE:

					return Collide( *static_cast<const SHAPE_RECT *> (a), *static_cast<const SHAPE_CIRCLE *> (b), clearance, needMTV, aMTV );

				case SH_LINE_CHAIN:

					return Collide( *static_cast<const SHAPE_RECT *> (a), *static_cast<const SHAPE_LINE_CHAIN *> (b), clearance, needMTV, aMTV );

				default:

					break;

			}



		case SH_CIRCLE:

			switch(b->Type())

			{

				case SH_RECT:

					return Collide( *static_cast<const SHAPE_RECT *> (b), *static_cast<const SHAPE_CIRCLE *> (a), clearance, needMTV, aMTV );

				case SH_CIRCLE:

					return Collide( *static_cast<const SHAPE_CIRCLE *> (a), *static_cast<const SHAPE_CIRCLE *> (b), clearance, needMTV, aMTV );

				case SH_LINE_CHAIN:

					return Collide( *static_cast<const SHAPE_CIRCLE *> (a), *static_cast<const SHAPE_LINE_CHAIN *> (b), clearance, needMTV, aMTV );

				default:

					break;

			}



		case SH_LINE_CHAIN:

			switch(b->Type())

			{

				case SH_RECT:

					return Collide( *static_cast<const SHAPE_RECT *> (b), *static_cast<const SHAPE_LINE_CHAIN *> (a), clearance, needMTV, aMTV );

				case SH_CIRCLE:

					return Collide( *static_cast<const SHAPE_CIRCLE *> (b), *static_cast<const SHAPE_LINE_CHAIN *> (a), clearance, needMTV, aMTV );

				case SH_LINE_CHAIN:

					return Collide( *static_cast<const SHAPE_LINE_CHAIN *> (a), *static_cast<const SHAPE_LINE_CHAIN *> (b), clearance, needMTV, aMTV );

				default:

					break;

			}

		default:

			break;

	}



	bool unsupported_collision = true;



	assert(unsupported_collision == false);

	return false;

}





bool SHAPE::Collide ( const SHAPE *aShape, int aClerance, VECTOR2I& aMTV ) const

{

	return CollideShapes( this, aShape, aClerance, true, aMTV);

}



bool SHAPE::Collide ( const SHAPE *aShape, int aClerance ) const

{

	VECTOR2I dummy;

	return CollideShapes( this, aShape, aClerance, false, dummy);

}

		
 No newline at end of file

common/geometry/shape_line_chain.cpp

0 → 100644
+465 −0
Original line number Original line Diff line number Diff line 
/*

 * This program source code file is part of KiCad, a free EDA CAD application.

 *

 * Copyright (C) 2013 CERN

 * @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, you may find one here:

 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html

 * or you may search the http://www.gnu.org website for the version 2 license,

 * or you may write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

 */



#include <geometry/shape_line_chain.h>

#include <geometry/shape_circle.h>



using namespace std;

using boost::optional;



bool SHAPE_LINE_CHAIN::Collide ( const VECTOR2I& aP, int aClearance ) const

{

	assert(false);

	return false;

}



bool SHAPE_LINE_CHAIN::Collide ( const BOX2I& aBox, int aClearance ) const

{

	assert(false);

	return false;

}



bool SHAPE_LINE_CHAIN::Collide ( const SEG& aSeg, int aClearance ) const

{

	BOX2I box_a(aSeg.a, aSeg.b - aSeg.a);

	BOX2I::ecoord_type dist_sq = (BOX2I::ecoord_type) aClearance * aClearance;



	for( int i = 0; i < SegmentCount() ;i++)

	{

		const SEG& s = CSegment(i);

		BOX2I box_b(s.a, s.b - s.a);

	

		BOX2I::ecoord_type d = box_a.SquaredDistance ( box_b );



		if(d < dist_sq)

		{

			if(s.Collide(aSeg, aClearance))

				return true;

		}

	}

	return false;

}



const SHAPE_LINE_CHAIN SHAPE_LINE_CHAIN::Reverse() const 

{

	SHAPE_LINE_CHAIN a (*this);

	reverse(a.m_points.begin(), a.m_points.end());

	a.m_closed = m_closed;



	return a;

}



	

int SHAPE_LINE_CHAIN::Length() const

{

	int l = 0;

	for (int i = 0; i < SegmentCount(); i++)

		l += CSegment(i).Length();

	return l;

}



void SHAPE_LINE_CHAIN::Replace( int start_index, int end_index, const VECTOR2I& aP)				

{

	if(end_index < 0)

		end_index += PointCount();

	if(start_index < 0)

		start_index += PointCount();



	if (start_index == end_index)

		m_points [start_index] = aP;

	else {

		m_points.erase (m_points.begin() + start_index + 1, m_points.begin() + end_index + 1);

		m_points [start_index] = aP;

	}

}



void SHAPE_LINE_CHAIN::Replace( int start_index, int end_index, const SHAPE_LINE_CHAIN& aLine)				

{

	if(end_index < 0)

		end_index += PointCount();

	if(start_index < 0)

		start_index += PointCount();



	m_points.erase (m_points.begin() + start_index, m_points.begin() + end_index + 1);

	m_points.insert (m_points.begin() + start_index, aLine.m_points.begin(), aLine.m_points.end());

}



void SHAPE_LINE_CHAIN::Remove( int start_index, int end_index)				

{

	if(end_index < 0)

		end_index += PointCount();

	if(start_index < 0)

		start_index += PointCount();



	m_points.erase (m_points.begin() + start_index, m_points.begin() + end_index + 1);

}



int SHAPE_LINE_CHAIN::Distance( const VECTOR2I & aP ) const

{

	int d = INT_MAX;

	for (int s = 0; s < SegmentCount(); s++)

		d = min (d, CSegment(s).Distance(aP));

	return d;

}

		

int SHAPE_LINE_CHAIN::Split( const VECTOR2I & aP )

{

	int ii = -1;

	int min_dist = 2;



	ii = Find(aP);



	if(ii >= 0)

		return ii;



	for (int s = 0; s < SegmentCount(); s++)

	{

		const SEG seg = CSegment(s);

		int dist = seg.Distance(aP);



		// make sure we are not producing a 'slightly concave' primitive. This might happen

		// if aP lies very close to one of already existing points.			

		if(dist < min_dist && seg.a != aP && seg.b != aP)

		{

			min_dist = dist;

			ii = s;

		}

	}



	if(ii >= 0)

	{

		m_points.insert(m_points.begin() + ii + 1, aP);

		return ii + 1;

	}



	return -1;

}



int SHAPE_LINE_CHAIN::Find ( const VECTOR2I& aP ) const

{

	for (int s = 0; s< PointCount(); s++)

		if(CPoint(s) == aP)

			return s;

	return -1;

}



const SHAPE_LINE_CHAIN SHAPE_LINE_CHAIN::Slice( int start_index, int end_index ) const

{

	SHAPE_LINE_CHAIN rv;

	

	if(end_index < 0)

		end_index += PointCount();

	if(start_index < 0)

		start_index += PointCount();



	for(int i = start_index; i<= end_index; i++)

		rv.Append(m_points[i]);

	return rv;

}



struct compareOriginDistance {

	compareOriginDistance( VECTOR2I& aOrigin ):

		m_origin(aOrigin) {};



	bool operator()(const SHAPE_LINE_CHAIN::Intersection &a, const SHAPE_LINE_CHAIN::Intersection& b) 

	{

		return (m_origin - a.p).EuclideanNorm() < (m_origin - b.p).EuclideanNorm();

	}



	VECTOR2I m_origin;

};



		

int SHAPE_LINE_CHAIN::Intersect ( const SEG& aSeg, Intersections& aIp ) const

{

	for (int s = 0; s < SegmentCount(); s++)

	{

		OPT_VECTOR2I p = CSegment(s).Intersect(aSeg);

		if(p)

		{

			Intersection is;

			is.our = CSegment(s);

			is.their = aSeg;

			is.p = *p;

			aIp.push_back(is);

		}

	}



	compareOriginDistance comp(aSeg.a);

	sort(aIp.begin(), aIp.end(), comp);

	return aIp.size();

};



int SHAPE_LINE_CHAIN::Intersect( const SHAPE_LINE_CHAIN &aChain, Intersections& aIp ) const

{

BOX2I bb_other = aChain.BBox();

	

	for (int s1 = 0; s1 < SegmentCount(); s1++)

	{

		const SEG& a = CSegment(s1);

		const BOX2I bb_cur (a.a, a.b - a.a);



		if(! bb_other.Intersects( bb_cur ))

			continue;



		for (int s2 = 0; s2 < aChain.SegmentCount(); s2++)

		{

			const SEG& b = aChain.CSegment(s2);

			Intersection is;

			

			

			if(a.Collinear(b))

			{

				if(a.Contains(b.a)) { is.p = b.a; aIp.push_back(is); }

				if(a.Contains(b.b)) { is.p = b.b; aIp.push_back(is); }

				if(b.Contains(a.a)) { is.p = a.a; aIp.push_back(is); }

				if(b.Contains(a.b)) { is.p = a.b; aIp.push_back(is); }

			} else {

				OPT_VECTOR2I p = a.Intersect(b);

				

				if(p)

				{

					is.p = *p;

					is.our = a;

					is.their = b;

					aIp.push_back(is);	

				}

			}

		}

	}

	

	return aIp.size();



	for (int s1 = 0; s1 < SegmentCount(); s1++)

		for (int s2 = 0; s2 < aChain.SegmentCount(); s2++)

		{

			const SEG& a = CSegment(s1);

			const SEG& b = aChain.CSegment(s2);

			OPT_VECTOR2I p = a.Intersect(b);

			Intersection is;

			

			if(p)

			{

				is.p = *p;

				is.our = a;

				is.their = b;

				aIp.push_back(is);

			} else if (a.Collinear(b))

			{

				if(a.a != b.a && a.a != b.b && b.Contains(a.a) )

				{

					is.p = a.a;

					is.our = a;

					is.their = b;

					aIp.push_back(is);

				}

				else if(a.b != b.a && a.b != b.b && b.Contains(a.b) )

				{

					is.p = a.b;

					is.our = a;

					is.their = b;

					aIp.push_back(is);

				}



			}

		}

	return aIp.size();

}

		

int SHAPE_LINE_CHAIN::PathLength (const VECTOR2I& aP ) const

{

	int sum = 0;

	for (int i = 0; i < SegmentCount(); i++)

	{

		const SEG seg = CSegment(i);

		int d = seg.Distance(aP);

		if (d <= 1)

		{

			sum += (aP - seg.a).EuclideanNorm();

			return sum;

		}

		else

			sum += seg.Length();

	}

	return -1;

}

		

bool SHAPE_LINE_CHAIN::PointInside( const VECTOR2I& aP) const

{

	if(!m_closed || SegmentCount() < 3)

		return false;



	int cur = CSegment(0).Side(aP);

	if(cur == 0)

		return false;



	for( int i = 1; i < SegmentCount(); i++)

	{

		const SEG s = CSegment(i);

		if(aP == s.a || aP == s.b) // edge does not belong to the interior!

			return false;

		if (s.Side(aP) != cur)

			return false;

		}

	return true;

}

	

bool SHAPE_LINE_CHAIN::PointOnEdge( const VECTOR2I& aP) const

{

	if(SegmentCount() < 1)

		return m_points[0] == aP;

		

	for( int i = 1; i < SegmentCount(); i++)

	{

		const SEG s = CSegment(i);

		if(s.a == aP || s.b == aP)

			return true;



		if(s.Distance(aP) <= 1)

			return true;

	}

	return false;

}



const optional<SHAPE_LINE_CHAIN::Intersection> SHAPE_LINE_CHAIN::SelfIntersecting() const

{

	for (int s1 = 0; s1 < SegmentCount(); s1++)	

		for (int s2 = s1 + 1; s2 < SegmentCount(); s2++)

		{

			const VECTOR2I s2a = CSegment(s2).a, s2b = CSegment(s2).b;

			if(s1 + 1 != s2 && CSegment(s1).Contains(s2a))

			{

				Intersection is;

				is.our = CSegment(s1);

				is.their = CSegment(s2);

				is.p = s2a;

				return is;

			} else if (CSegment(s1).Contains(s2b)) {

				Intersection is;

				is.our = CSegment(s1);

				is.their = CSegment(s2);

				is.p = s2b;

				return is;



			} else {

				OPT_VECTOR2I p = CSegment(s1).Intersect(CSegment(s2), true);

			

				if(p) 

				{

					Intersection is;

					is.our = CSegment(s1);

					is.their = CSegment(s2);

					is.p = *p;

					return is;

				}

			}

		}

	return optional<Intersection>();

}

		



SHAPE_LINE_CHAIN& SHAPE_LINE_CHAIN::Simplify()

{

	vector<VECTOR2I> pts_unique;

		

	if (PointCount() < 2)

	{

		return *this;

	} else if (PointCount() == 2) {

		if(m_points[0] == m_points[1])

			m_points.erase(m_points.end());

		return *this;

	}



	int i = 0;

	int np = PointCount();

		

	// stage 1: eliminate duplicate vertices

	while ( i < np )

	{

		int j = i+1;

		while(j < np && CPoint(i) == CPoint(j))

			j ++;

		pts_unique.push_back(CPoint(i));	

		i = j;

	}



	m_points.clear();

	np = pts_unique.size();



	i = 0;

	// stage 1: eliminate collinear segments

	while (i < np - 2)

	{

		const VECTOR2I p0 = pts_unique[i];

		const VECTOR2I p1 = pts_unique[i+1];

		int n = i;

		while(n < np - 2 && SEG(p0, p1).LineDistance(pts_unique[n + 2]) <= 1)

			n++;

		

		m_points.push_back(p0);

		if (n > i)

			i = n;

		if (n == np)

		{

			m_points.push_back(pts_unique[n-1]);

			return *this;

		}

		i ++;

	}



	if(np > 1)

		m_points.push_back(pts_unique[np-2]);

	m_points.push_back(pts_unique[np-1]);



	return *this;

}



const VECTOR2I SHAPE_LINE_CHAIN::NearestPoint(const VECTOR2I& aP) const

{

	int min_d = INT_MAX;

	int nearest;

	for ( int i = 0; i < SegmentCount() ; i++ )

	{

		int d = CSegment(i).Distance(aP);

		if( d < min_d )

		{

			min_d = d;

			nearest = i;

		}

	}

	return CSegment(nearest).NearestPoint(aP); 

}

		

const string SHAPE_LINE_CHAIN::Format() const

{

	stringstream ss;



	ss << m_points.size() << " " << (m_closed ? 1 : 0) << " " ;



	for(int i = 0; i<PointCount(); i++)

		ss << m_points[i].x << " " << m_points[i].y<<" ";// Format() << " ";

	

	return ss.str();

}

include/geometry/seg.h

0 → 100644
+361 −0

File added.

Preview size limit exceeded, changes collapsed.