haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Coding conventions and cleanup.

This commit is contained in:
Jeff Young 2024-01-12 17:09:52 +00:00
parent e549d7c0c6
commit 8410a5e685
4 changed files with 61 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
common/font/outline_font.cpp
View File

@ -32,8 +32,6 @@
#include FT_GLYPH_H #include FT_GLYPH_H
#include FT_BBOX_H #include FT_BBOX_H
#include <trigo.h> #include <trigo.h>
#include <font/fontconfig.h>
#include <convert_basic_shapes_to_polygon.h>
#include <core/utf8.h> #include <core/utf8.h>
using namespace KIFONT; using namespace KIFONT;

10
include/font/outline_decomposer.h
View File

@ -64,23 +64,17 @@ public:
void OutlineToSegments( CONTOURS* aContours ); void OutlineToSegments( CONTOURS* aContours );
private: private:
void contourToSegmentsAndArcs( CONTOUR& aResult, unsigned int aContourIndex ) const;
void newContour(); void newContour();
void addContourPoint( const VECTOR2D& p ); void addContourPoint( const VECTOR2D& p );
int approximateContour( const GLYPH_POINTS& aPoints, const std::vector<bool>& aPointOnCurve,
GLYPH_POINTS& aResult ) const;
bool approximateBezierCurve( GLYPH_POINTS& result, const GLYPH_POINTS& bezier ) const; bool approximateBezierCurve( GLYPH_POINTS& result, const GLYPH_POINTS& bezier ) const;
bool approximateQuadraticBezierCurve( GLYPH_POINTS& result, const GLYPH_POINTS& bezier ) const; bool approximateQuadraticBezierCurve( GLYPH_POINTS& result, const GLYPH_POINTS& bezier ) const;
bool approximateCubicBezierCurve( GLYPH_POINTS& result, const GLYPH_POINTS& bezier ) const; bool approximateCubicBezierCurve( GLYPH_POINTS& result, const GLYPH_POINTS& bezier ) const;
/** /**
* @return 1 if aContour is in clockwise order, -1 if it is in * @return 1 if aContour is in clockwise order, -1 if it is in counterclockwise order,
* counterclockwise order, or 0 if the winding can't be * or 0 if the winding can't be determined.
* determined.
*/ */
int winding( const GLYPH_POINTS& aContour ) const; int winding( const GLYPH_POINTS& aContour ) const;

115
libs/kimath/include/geometry/polygon_triangulation.h
View File

@ -56,10 +56,10 @@
#include <math/box2.h> #include <math/box2.h>
#include <math/vector2d.h> #include <math/vector2d.h>
class PolygonTriangulation class POLYGON_TRIANGULATION
{ {
public: public:
PolygonTriangulation( SHAPE_POLY_SET::TRIANGULATED_POLYGON& aResult ) : POLYGON_TRIANGULATION( SHAPE_POLY_SET::TRIANGULATED_POLYGON& aResult ) :
m_result( aResult ) m_result( aResult )
{}; {};
@ -74,7 +74,8 @@ public:
/// Place the polygon Vertices into a circular linked list /// Place the polygon Vertices into a circular linked list
/// and check for lists that have only 0, 1 or 2 elements and /// and check for lists that have only 0, 1 or 2 elements and
/// therefore cannot be polygons /// therefore cannot be polygons
Vertex* firstVertex = createList( aPoly ); VERTEX* firstVertex = createList( aPoly );
if( !firstVertex || firstVertex->prev == firstVertex->next ) if( !firstVertex || firstVertex->prev == firstVertex->next )
return false; return false;
@ -86,9 +87,9 @@ public:
} }
private: private:
struct Vertex struct VERTEX
{ {
Vertex( size_t aIndex, double aX, double aY, PolygonTriangulation* aParent ) : VERTEX( size_t aIndex, double aX, double aY, POLYGON_TRIANGULATION* aParent ) :
i( aIndex ), i( aIndex ),
x( aX ), x( aX ),
y( aY ), y( aY ),
@ -96,14 +97,14 @@ private:
{ {
} }
Vertex& operator=( const Vertex& ) = delete; VERTEX& operator=( const VERTEX& ) = delete;
Vertex& operator=( Vertex&& ) = delete; VERTEX& operator=( VERTEX&& ) = delete;
bool operator==( const Vertex& rhs ) const bool operator==( const VERTEX& rhs ) const
{ {
return this->x == rhs.x && this->y == rhs.y; return this->x == rhs.x && this->y == rhs.y;
} }
bool operator!=( const Vertex& rhs ) const { return !( *this == rhs ); } bool operator!=( const VERTEX& rhs ) const { return !( *this == rhs ); }
/** /**
@ -116,14 +117,14 @@ private:
* @return the newly created vertex in the polygon that does not include the * @return the newly created vertex in the polygon that does not include the
* reference vertex. * reference vertex.
*/ */
Vertex* split( Vertex* b ) VERTEX* split( VERTEX* b )
{ {
parent->m_vertices.emplace_back( i, x, y, parent ); parent->m_vertices.emplace_back( i, x, y, parent );
Vertex* a2 = &parent->m_vertices.back(); VERTEX* a2 = &parent->m_vertices.back();
parent->m_vertices.emplace_back( b->i, b->x, b->y, parent ); parent->m_vertices.emplace_back( b->i, b->x, b->y, parent );
Vertex* b2 = &parent->m_vertices.back(); VERTEX* b2 = &parent->m_vertices.back();
Vertex* an = next; VERTEX* an = next;
Vertex* bp = b->prev; VERTEX* bp = b->prev;
next = b; next = b;
b->prev = this; b->prev = this;
@ -172,7 +173,7 @@ private:
*/ */
void updateList() void updateList()
{ {
Vertex* p = next; VERTEX* p = next;
while( p != this ) while( p != this )
{ {
@ -201,14 +202,14 @@ private:
*/ */
void zSort() void zSort()
{ {
std::deque<Vertex*> queue; std::deque<VERTEX*> queue;
queue.push_back( this ); queue.push_back( this );
for( auto p = next; p && p != this; p = p->next ) for( auto p = next; p && p != this; p = p->next )
queue.push_back( p ); queue.push_back( p );
std::sort( queue.begin(), queue.end(), []( const Vertex* a, const Vertex* b ) std::sort( queue.begin(), queue.end(), []( const VERTEX* a, const VERTEX* b )
{ {
if( a->z != b->z ) if( a->z != b->z )
return a->z < b->z; return a->z < b->z;
@ -222,7 +223,7 @@ private:
return a->i < b->i; return a->i < b->i;
} ); } );
Vertex* prev_elem = nullptr; VERTEX* prev_elem = nullptr;
for( auto elem : queue ) for( auto elem : queue )
{ {
@ -240,7 +241,7 @@ private:
/** /**
* Check to see if triangle surrounds our current vertex * Check to see if triangle surrounds our current vertex
*/ */
bool inTriangle( const Vertex& a, const Vertex& b, const Vertex& c ) bool inTriangle( const VERTEX& a, const VERTEX& b, const VERTEX& c )
{ {
return ( c.x - x ) * ( a.y - y ) - ( a.x - x ) * ( c.y - y ) >= 0 return ( c.x - x ) * ( a.y - y ) - ( a.x - x ) * ( c.y - y ) >= 0
&& ( a.x - x ) * ( b.y - y ) - ( b.x - x ) * ( a.y - y ) >= 0 && ( a.x - x ) * ( b.y - y ) - ( b.x - x ) * ( a.y - y ) >= 0
@ -250,18 +251,18 @@ private:
const size_t i; const size_t i;
const double x; const double x;
const double y; const double y;
PolygonTriangulation* parent; POLYGON_TRIANGULATION* parent;
// previous and next vertices nodes in a polygon ring // previous and next vertices nodes in a polygon ring
Vertex* prev = nullptr; VERTEX* prev = nullptr;
Vertex* next = nullptr; VERTEX* next = nullptr;
// z-order curve value // z-order curve value
int32_t z = 0; int32_t z = 0;
// previous and next nodes in z-order // previous and next nodes in z-order
Vertex* prevZ = nullptr; VERTEX* prevZ = nullptr;
Vertex* nextZ = nullptr; VERTEX* nextZ = nullptr;
}; };
/** /**
@ -294,10 +295,10 @@ private:
* as the NULL triangles are inserted as Steiner points to improve the * as the NULL triangles are inserted as Steiner points to improve the
* triangulation regularity of polygons * triangulation regularity of polygons
*/ */
Vertex* removeNullTriangles( Vertex* aStart ) VERTEX* removeNullTriangles( VERTEX* aStart )
{ {
Vertex* retval = nullptr; VERTEX* retval = nullptr;
Vertex* p = aStart->next; VERTEX* p = aStart->next;
while( p != aStart ) while( p != aStart )
{ {
@ -328,9 +329,9 @@ private:
/** /**
* Take a Clipper path and converts it into a circular, doubly-linked list for triangulation. * Take a Clipper path and converts it into a circular, doubly-linked list for triangulation.
*/ */
Vertex* createList( const ClipperLib::Path& aPath ) VERTEX* createList( const ClipperLib::Path& aPath )
{ {
Vertex* tail = nullptr; VERTEX* tail = nullptr;
double sum = 0.0; double sum = 0.0;
auto len = aPath.size(); auto len = aPath.size();
@ -369,9 +370,9 @@ private:
/** /**
* Take a #SHAPE_LINE_CHAIN and links each point into a circular, doubly-linked list. * Take a #SHAPE_LINE_CHAIN and links each point into a circular, doubly-linked list.
*/ */
Vertex* createList( const SHAPE_LINE_CHAIN& points ) VERTEX* createList( const SHAPE_LINE_CHAIN& points )
{ {
Vertex* tail = nullptr; VERTEX* tail = nullptr;
double sum = 0.0; double sum = 0.0;
// Check for winding order // Check for winding order
@ -411,14 +412,14 @@ private:
* an edited file), we create a single triangle and remove both vertices before attempting * an edited file), we create a single triangle and remove both vertices before attempting
* to. * to.
*/ */
bool earcutList( Vertex* aPoint, int pass = 0 ) bool earcutList( VERTEX* aPoint, int pass = 0 )
{ {
if( !aPoint ) if( !aPoint )
return true; return true;
Vertex* stop = aPoint; VERTEX* stop = aPoint;
Vertex* prev; VERTEX* prev;
Vertex* next; VERTEX* next;
while( aPoint->prev != aPoint->next ) while( aPoint->prev != aPoint->next )
{ {
@ -437,7 +438,7 @@ private:
continue; continue;
} }
Vertex* nextNext = next->next; VERTEX* nextNext = next->next;
if( *prev != *nextNext && intersects( prev, aPoint, next, nextNext ) && if( *prev != *nextNext && intersects( prev, aPoint, next, nextNext ) &&
locallyInside( prev, nextNext ) && locallyInside( prev, nextNext ) &&
@ -504,11 +505,11 @@ private:
* *
* @return true if aEar is the apex point of a ear in the polygon. * @return true if aEar is the apex point of a ear in the polygon.
*/ */
bool isEar( Vertex* aEar ) const bool isEar( VERTEX* aEar ) const
{ {
const Vertex* a = aEar->prev; const VERTEX* a = aEar->prev;
const Vertex* b = aEar; const VERTEX* b = aEar;
const Vertex* c = aEar->next; const VERTEX* c = aEar->next;
// If the area >=0, then the three points for a concave sequence // If the area >=0, then the three points for a concave sequence
// with b as the reflex point // with b as the reflex point
@ -526,7 +527,7 @@ private:
const int32_t maxZ = zOrder( maxTX, maxTY ); const int32_t maxZ = zOrder( maxTX, maxTY );
// first look for points inside the triangle in increasing z-order // first look for points inside the triangle in increasing z-order
Vertex* p = aEar->nextZ; VERTEX* p = aEar->nextZ;
while( p && p->z <= maxZ ) while( p && p->z <= maxZ )
{ {
@ -560,20 +561,20 @@ private:
* independently. This is assured to generate at least one new ear if the * independently. This is assured to generate at least one new ear if the
* split is successful * split is successful
*/ */
bool splitPolygon( Vertex* start ) bool splitPolygon( VERTEX* start )
{ {
Vertex* origPoly = start; VERTEX* origPoly = start;
do do
{ {
Vertex* marker = origPoly->next->next; VERTEX* marker = origPoly->next->next;
while( marker != origPoly->prev ) while( marker != origPoly->prev )
{ {
// Find a diagonal line that is wholly enclosed by the polygon interior // Find a diagonal line that is wholly enclosed by the polygon interior
if( origPoly->i != marker->i && goodSplit( origPoly, marker ) ) if( origPoly->i != marker->i && goodSplit( origPoly, marker ) )
{ {
Vertex* newPoly = origPoly->split( marker ); VERTEX* newPoly = origPoly->split( marker );
origPoly->updateList(); origPoly->updateList();
newPoly->updateList(); newPoly->updateList();
@ -599,7 +600,7 @@ private:
* and the midpoint. Finally, we check to split creates two new polygons, * and the midpoint. Finally, we check to split creates two new polygons,
* each with positive area. * each with positive area.
*/ */
bool goodSplit( const Vertex* a, const Vertex* b ) const bool goodSplit( const VERTEX* a, const VERTEX* b ) const
{ {
bool a_on_edge = ( a->nextZ && *a == *a->nextZ ) || ( a->prevZ && *a == *a->prevZ ); bool a_on_edge = ( a->nextZ && *a == *a->nextZ ) || ( a->prevZ && *a == *a->prevZ );
bool b_on_edge = ( b->nextZ && *b == *b->nextZ ) || ( b->prevZ && *b == *b->prevZ ); bool b_on_edge = ( b->nextZ && *b == *b->nextZ ) || ( b->prevZ && *b == *b->prevZ );
@ -616,7 +617,7 @@ private:
/** /**
* Return the twice the signed area of the triangle formed by vertices p, q, and r. * Return the twice the signed area of the triangle formed by vertices p, q, and r.
*/ */
double area( const Vertex* p, const Vertex* q, const Vertex* r ) const double area( const VERTEX* p, const VERTEX* q, const VERTEX* r ) const
{ {
return ( q->y - p->y ) * ( r->x - q->x ) - ( q->x - p->x ) * ( r->y - q->y ); return ( q->y - p->y ) * ( r->x - q->x ) - ( q->x - p->x ) * ( r->y - q->y );
} }
@ -630,7 +631,7 @@ private:
/** /**
* If p, q, and r are collinear and r lies between p and q, then return true. * If p, q, and r are collinear and r lies between p and q, then return true.
*/ */
constexpr bool overlapping( const Vertex* p, const Vertex* q, const Vertex* r ) const constexpr bool overlapping( const VERTEX* p, const VERTEX* q, const VERTEX* r ) const
{ {
return q->x <= std::max( p->x, r->x ) && return q->x <= std::max( p->x, r->x ) &&
q->x >= std::min( p->x, r->x ) && q->x >= std::min( p->x, r->x ) &&
@ -643,7 +644,7 @@ private:
* *
* @return true if p1-p2 intersects q1-q2. * @return true if p1-p2 intersects q1-q2.
*/ */
bool intersects( const Vertex* p1, const Vertex* q1, const Vertex* p2, const Vertex* q2 ) const bool intersects( const VERTEX* p1, const VERTEX* q1, const VERTEX* p2, const VERTEX* q2 ) const
{ {
int sign1 = sign( area( p1, q1, p2 ) ); int sign1 = sign( area( p1, q1, p2 ) );
int sign2 = sign( area( p1, q1, q2 ) ); int sign2 = sign( area( p1, q1, q2 ) );
@ -675,9 +676,9 @@ private:
* *
* @return true if the segment intersects the edge of the polygon. * @return true if the segment intersects the edge of the polygon.
*/ */
bool intersectsPolygon( const Vertex* a, const Vertex* b ) const bool intersectsPolygon( const VERTEX* a, const VERTEX* b ) const
{ {
const Vertex* p = a->next; const VERTEX* p = a->next;
do do
{ {
@ -702,7 +703,7 @@ private:
* *
* @return true if the segment from a->b is inside a's polygon next to vertex a. * @return true if the segment from a->b is inside a's polygon next to vertex a.
*/ */
bool locallyInside( const Vertex* a, const Vertex* b ) const bool locallyInside( const VERTEX* a, const VERTEX* b ) const
{ {
if( area( a->prev, a, a->next ) < 0 ) if( area( a->prev, a, a->next ) < 0 )
return area( a, b, a->next ) >= 0 && area( a, a->prev, b ) >= 0; return area( a, b, a->next ) >= 0 && area( a, a->prev, b ) >= 0;
@ -713,9 +714,9 @@ private:
/** /**
* Check to see if the segment halfway point between a and b is inside the polygon * Check to see if the segment halfway point between a and b is inside the polygon
*/ */
bool middleInside( const Vertex* a, const Vertex* b ) const bool middleInside( const VERTEX* a, const VERTEX* b ) const
{ {
const Vertex* p = a; const VERTEX* p = a;
bool inside = false; bool inside = false;
double px = ( a->x + b->x ) / 2; double px = ( a->x + b->x ) / 2;
double py = ( a->y + b->y ) / 2; double py = ( a->y + b->y ) / 2;
@ -738,12 +739,12 @@ private:
* *
* @return a pointer to the newly created vertex. * @return a pointer to the newly created vertex.
*/ */
Vertex* insertVertex( const VECTOR2I& pt, Vertex* last ) VERTEX* insertVertex( const VECTOR2I& pt, VERTEX* last )
{ {
m_result.AddVertex( pt ); m_result.AddVertex( pt );
m_vertices.emplace_back( m_result.GetVertexCount() - 1, pt.x, pt.y, this ); m_vertices.emplace_back( m_result.GetVertexCount() - 1, pt.x, pt.y, this );
Vertex* p = &m_vertices.back(); VERTEX* p = &m_vertices.back();
if( !last ) if( !last )
{ {
@ -762,7 +763,7 @@ private:
private: private:
BOX2I m_bbox; BOX2I m_bbox;
std::deque<Vertex> m_vertices; std::deque<VERTEX> m_vertices;
SHAPE_POLY_SET::TRIANGULATED_POLYGON& m_result; SHAPE_POLY_SET::TRIANGULATED_POLYGON& m_result;
}; };

2
libs/kimath/src/geometry/shape_poly_set.cpp
View File

@ -3016,7 +3016,7 @@ void SHAPE_POLY_SET::CacheTriangulation( bool aPartition, bool aSimplify )
dest.erase( dest.end() - 1 ); dest.erase( dest.end() - 1 );
dest.push_back( std::make_unique<TRIANGULATED_POLYGON>( forOutline ) ); dest.push_back( std::make_unique<TRIANGULATED_POLYGON>( forOutline ) );
PolygonTriangulation tess( *dest.back() ); POLYGON_TRIANGULATION tess( *dest.back() );
// If the tessellation fails, we re-fracture the polygon, which will // If the tessellation fails, we re-fracture the polygon, which will
// first simplify the system before fracturing and removing the holes // first simplify the system before fracturing and removing the holes