Logo Search packages:      
Sourcecode: inkscape version File versions

Geom Namespace Reference


Detailed Description

Various geometrical calculations.

Shapes are special paths on which boolops can be performed.

A convex cover is a sequence of convex polygons that completely cover the path. For now a convex hull class is included here (the convex-hull header is wrong)

Authors: Michael G. Sloan <mgsloan@gmail.com> Nathan Hurst <njh@mail.csse.monash.edu.au> MenTaLguY <mental@rydia.net>

Copyright 2007-2009 Authors

This library is free software; you can redistribute it and/or modify it either under the terms of the GNU Lesser General Public License version 2.1 as published by the Free Software Foundation (the "LGPL") or, at your option, under the terms of the Mozilla Public License Version 1.1 (the "MPL"). If you do not alter this notice, a recipient may use your version of this file under either the MPL or the LGPL.

You should have received a copy of the LGPL along with this library in the file COPYING-LGPL-2.1; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA You should have received a copy of the MPL along with this library in the file COPYING-MPL-1.1

The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.mozilla.org/MPL/

This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the LGPL or the MPL for the specific language governing rights and limitations.

Various utility functions.

Copyright 2008 Marco Cecchetti <mrcekets at gmail.com> Copyright 2007 Johan Engelen <goejendaagh@zonnet.nl> Copyright 2006 Michael G. Sloan <mgsloan@gmail.com>

This library is free software; you can redistribute it and/or modify it either under the terms of the GNU Lesser General Public License version 2.1 as published by the Free Software Foundation (the "LGPL") or, at your option, under the terms of the Mozilla Public License Version 1.1 (the "MPL"). If you do not alter this notice, a recipient may use your version of this file under either the MPL or the LGPL.

You should have received a copy of the LGPL along with this library in the file COPYING-LGPL-2.1; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA You should have received a copy of the MPL along with this library in the file COPYING-MPL-1.1

The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.mozilla.org/MPL/

This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the LGPL or the MPL for the specific language governing rights and limitations.

Specific nodetype geometry functions for Inkscape, not provided my lib2geom.

Author: Johan Engelen <goejendaagh@zonnet.nl>

Copyright (C) 2008 Johan Engelen

Released under GNU GPL


Classes

struct  AddableConcept
class  angle_cmp
class  Bernsteins
class  Bezier
class  BezierCurve
class  BezierCurve< 0 >
class  Circle
class  Circulator
struct  ContainmentOrder
class  ContinuityError
class  ConvexHull
struct  Crosser
struct  Crossing
struct  CrossingOrder
class  Curve
struct  CurveHelpers
class  D2
class  D2< Interval >
union  dbl_64
class  Eigen
class  Ellipse
class  EllipticalArc
struct  Event
class  Exception
struct  FragmentConcept
class  HLineSegment
class  InfiniteSolutions
class  Interval
 This class represents a range of numbers that is never empty. More...
class  InvariantsViolation
class  IPoint
class  Line
class  Linear
class  Linear2d
class  LogicalError
class  make_elliptical_arc
class  Matrix
struct  MonoCrosser
struct  MultiplicableConcept
struct  NearConcept
class  NotImplemented
class  NotInvertible
struct  OffsetableConcept
class  OptInterval
 OptInterval is an Interval that can be empty. More...
class  OptRect
class  Path
class  PathBuilder
struct  PathVectorPosition
class  Piecewise
class  Point
 Cartesian 2D point. More...
class  Poly
class  Quad
class  QuadTree
class  RangeError
class  Ray
class  RectHull
class  Region
struct  ResultTraits< double >
struct  ResultTraits< Point >
class  Rotate
class  SBasis
class  SBasis2d
class  SBasisCurve
struct  ScalableConcept
class  Scale
class  Shape
struct  SimpleCrosser
class  sturm
class  SVGEllipticalArc
class  SVGPathGenerator
struct  SVGPathParseError
class  SVGPathSink
struct  TransformConcept
class  Translate
class  VLineSegment

Typedefs

typedef Point BezierCurve []
typedef double Coord
typedef std::vector< Crossing > Crossings
typedef std::vector< Crossings > CrossingSet
typedef BezierCurve< 3 > CubicBezier
typedef SimpleCrosser DefaultCrosser
typedef long ICoord
typedef
std::back_insert_iterator
< std::vector< Path > > 
iter
typedef BezierCurve< 1 > LineSegment
typedef boost::optional< Crossing > OptCrossing
typedef std::vector< Path > PathVector
typedef BezierCurve< 2 > QuadraticBezier
typedef D2< IntervalRect
typedef std::vector< Region > Regions

Enumerations

enum  { BOOLOP_JUST_A = 1, BOOLOP_JUST_B = 2, BOOLOP_BOTH = 4, BOOLOP_NEITHER = 8 }
enum  {
  BOOLOP_NULL = 0, BOOLOP_INTERSECT = BOOLOP_BOTH, BOOLOP_SUBTRACT_A_B = BOOLOP_JUST_B, BOOLOP_IDENTITY_A = BOOLOP_JUST_A | BOOLOP_BOTH,
  BOOLOP_SUBTRACT_B_A = BOOLOP_JUST_A, BOOLOP_IDENTITY_B = BOOLOP_JUST_B | BOOLOP_BOTH, BOOLOP_EXCLUSION = BOOLOP_JUST_A | BOOLOP_JUST_B, BOOLOP_UNION = BOOLOP_JUST_A | BOOLOP_JUST_B | BOOLOP_BOTH
}
enum  { BOOLOP_JUST_A = 1, BOOLOP_JUST_B = 2, BOOLOP_BOTH = 4, BOOLOP_NEITHER = 8 }
enum  {
  BOOLOP_NULL = 0, BOOLOP_INTERSECT = BOOLOP_BOTH, BOOLOP_SUBTRACT_A_B = BOOLOP_JUST_B, BOOLOP_IDENTITY_A = BOOLOP_JUST_A | BOOLOP_BOTH,
  BOOLOP_SUBTRACT_B_A = BOOLOP_JUST_A, BOOLOP_IDENTITY_B = BOOLOP_JUST_B | BOOLOP_BOTH, BOOLOP_EXCLUSION = BOOLOP_JUST_A | BOOLOP_JUST_B, BOOLOP_UNION = BOOLOP_JUST_A | BOOLOP_JUST_B | BOOLOP_BOTH
}
enum  Dim2 { X = 0, Y = 1, X = 0, Y = 1 }
enum  Dim2 { X = 0, Y = 1, X = 0, Y = 1 }
enum  IntersectorKind {
  intersects = 0, parallel, coincident, no_intersection,
  intersects = 0, parallel, coincident, no_intersection
}
enum  IntersectorKind {
  intersects = 0, parallel, coincident, no_intersection,
  intersects = 0, parallel, coincident, no_intersection
}
enum  NodeType {
  NODE_NONE, NODE_CUSP, NODE_SMOOTH, NODE_SYMM,
  NODE_NONE, NODE_CUSP, NODE_SMOOTH, NODE_SYMM
}
enum  NodeType {
  NODE_NONE, NODE_CUSP, NODE_SMOOTH, NODE_SYMM,
  NODE_NONE, NODE_CUSP, NODE_SMOOTH, NODE_SYMM
}

Functions

Piecewise< SBasis > abs (Piecewise< SBasis > const &f)
Piecewise< SBasis > abs (SBasis const &f)
Point abs (Point const &b)
void add_to_shape (Shape &s, Path const &p, bool fill)
std::vector< double > all_nearest_points (Point const &p, Piecewise< D2< SBasis > > const &c)
std::vector< double > all_nearest_points (Point const &p, D2< SBasis > const &c, double from=0, double to=1)
std::vector< double > all_nearest_points (Point const &p, Piecewise< D2< SBasis > > const &c, double from, double to)
std::vector< double > all_nearest_points (Point const &p, D2< SBasis > const &c, D2< SBasis > const &dc, double from, double to)
std::vector< PathVectorPosition > allNearestPoints (PathVector const &path_in, Point const &_point, double *distance_squared)
double angle_between (Ray const &r1, Ray const &r2, bool cw=true)
Coord angle_between (Point const a, Point const b)
double angle_between (Line const &l1, Line const &l2)
template<typename T>
void append (T &a, T const &b)
Piecewise< D2< SBasis > > arc_length_parametrization (Piecewise< D2< SBasis > > const &M, unsigned order, double tol)
Piecewise< D2< SBasis > > arc_length_parametrization (D2< SBasis > const &M, unsigned order, double tol)
Piecewise< SBasis > arcLengthSb (D2< SBasis > const &M, double tol)
Piecewise< SBasis > arcLengthSb (Piecewise< D2< SBasis > > const &M, double tol)
bool are_collinear (Point const &p1, Point const &p2, Point const &p3, double eps=EPSILON)
bool are_near (Point const &_point, Ray const &_ray, double eps=EPSILON)
bool are_near (Point const &a, Point const &b, double const eps=EPSILON)
bool are_near (Point const &_point, LineSegment const &_segment, double eps=EPSILON)
bool are_near (Point const &_point, Line const &_line, double eps=EPSILON)
template<typename T>
bool are_near (D2< T > const &a, D2< T > const &b, double tol)
bool are_near (Coord a, Coord b, double eps=EPSILON)
bool are_orthogonal (Line const &l1, Line const &l2, double eps=EPSILON)
bool are_parallel (Line const &l1, Line const &l2, double eps=EPSILON)
bool are_same (Ray const &r1, Ray const &r2, double eps=EPSILON)
bool are_same (Line const &l1, Line const &l2, double eps=EPSILON)
Piecewise< SBasis > atan2 (D2< SBasis > const &vect, double tol, unsigned order)
Piecewise< SBasis > atan2 (Piecewise< D2< SBasis > > const &vect, double tol, unsigned order)
Coord atan2 (Point const p)
template<class T>
const T & between (const T &min, const T &max, const T &x)
static Geom::Point Bezier (Geom::Point const *V, unsigned degree, double t, Geom::Point *Left, Geom::Point *Right)
int bezier_fit_cubic (Point bezier[], Point const data[], int len, double error)
int bezier_fit_cubic (Point *bezier, Point const *data, int len, double error)
int bezier_fit_cubic_full (Point bezier[], int split_points[], Point const data[], int const len, Point const &tHat1, Point const &tHat2, double const error, unsigned const max_beziers)
int bezier_fit_cubic_r (Point bezier[], Point const data[], int const len, double const error, unsigned const max_beziers)
std::vector< Pointbezier_points (const D2< Bezier > &a)
Point bezier_pt (unsigned const degree, Point const V[], double const t)
void bezier_to_sbasis (D2< SBasis > &sb, std::vector< Point > const &bz)
void bezier_to_sbasis (SBasis &sb, Bezier const &bz)
double binomial (unsigned int n, unsigned int k)
void binomial_coefficients (std::vector< size_t > &bc, size_t n)
Shape boolop (Shape const &, Shape const &, unsigned flags, CrossingSet &)
Shape boolop (Shape const &a, Shape const &b, unsigned flags)
Shape boolop (Shape const &a, Shape const &b, unsigned flags, CrossingSet const &crs)
template<typename C>
std::vector< Rectbounds (C const &a)
OptInterval bounds_exact (SBasis const &a)
template<typename T>
FragmentConcept< T >::BoundsType bounds_exact (const Piecewise< T > &f)
OptRect bounds_exact (PathVector const &pv)
template<typename T>
OptRect bounds_exact (const D2< T > &a)
OptInterval bounds_exact (Bezier const &b)
OptInterval bounds_fast (const SBasis &sb, int order)
template<typename T>
FragmentConcept< T >::BoundsType bounds_fast (const Piecewise< T > &f)
OptRect bounds_fast (PathVector const &pv)
template<typename T>
OptRect bounds_fast (const D2< T > &a)
OptInterval bounds_fast (Bezier const &b)
OptInterval bounds_local (const SBasis &sb, const OptInterval &i, int order)
template<typename T>
FragmentConcept< T >::BoundsType bounds_local (const Piecewise< T > &f, const OptInterval &_m)
template<typename T>
OptRect bounds_local (const D2< T > &a, const OptInterval &t)
OptInterval bounds_local (Bezier const &b, OptInterval i)
std::vector< Pointbridge_points (ConvexHull a, ConvexHull b)
pair< map< int, int >, map
< int, int > > 
bridges (ConvexHull a, ConvexHull b)
void build_from_sbasis (Geom::PathBuilder &pb, D2< SBasis > const &B, double tol, bool only_cubicbeziers)
unsigned centroid (Piecewise< D2< SBasis > > const &p, Point &centroid, double &area)
int centroid (std::vector< Geom::Point > const &p, Geom::Point &centroid, double &area)
static void chord_length_parameterize (Point const d[], double u[], unsigned len)
int circle_circle_intersection (Point X0, double r0, Point X1, double r1, Point &p0, Point &p1)
void clean (Crossings &, Crossings &)
ConvexHull clip (ConvexHull const &ch, Point n, double d)
SBasis compose (SBasis const &a, SBasis const &b, unsigned k)
SBasis compose (SBasis const &a, SBasis const &b)
SBasis2d compose (SBasis2d const &a, SBasis2d const &b, unsigned k)
SBasis2d compose (SBasis2d const &a, SBasis2d const &b)
SBasis compose (SBasis2d const &fg, D2< SBasis > const &p)
SBasis compose (Linear2d const &a, D2< SBasis > const &p)
Poly compose (Poly const &a, Poly const &b)
template<typename T>
Piecewise< T > compose (Piecewise< T > const &f, Piecewise< SBasis > const &g)
template<typename T>
Piecewise< T > compose (Piecewise< T > const &f, SBasis const &g)
template<typename T>
D2< T > compose (D2< T > const &a, T const &b)
D2< SBasis > compose_each (D2< SBasis2d > const &fg, D2< SBasis > const &p)
template<typename T>
D2< T > compose_each (T const &a, D2< T > const &b)
template<typename T>
D2< T > compose_each (D2< T > const &a, D2< T > const &b)
int compose_findSegIdx (std::map< double, unsigned >::iterator const &cut, std::map< double, unsigned >::iterator const &next, std::vector< double > const &levels, SBasis const &g)
SBasis compose_inverse (SBasis const &f, SBasis const &g, unsigned order, double zero)
std::map< double, unsigned > compose_pullback (std::vector< double > const &values, SBasis const &g)
static double compute_hook (Point const &a, Point const &b, double const u, BezierCurve const bezCurve, double const tolerance)
static double compute_max_error_ratio (Point const d[], double const u[], unsigned len, BezierCurve const bezCurve, double tolerance, unsigned *splitPoint)
static double compute_x_intercept (Geom::Point const *V, unsigned degree)
Point constrain_angle (Point const &A, Point const &B, unsigned int n, Point const &dir)
bool contains (Path const &p, Point i, bool evenodd=true)
static unsigned control_poly_flat_enough (Geom::Point const *V, unsigned degree)
static unsigned copy_without_nans_or_adjacent_duplicates (Point const src[], unsigned src_len, Point dest[])
SBasis cos (Linear bo, int k)
Piecewise< SBasis > cos (SBasis const &f, double tol, int order)
Piecewise< SBasis > cos (Piecewise< SBasis > const &f, double tol, int order)
Coord cross (Point const &a, Point const &b)
template<typename T>
cross (D2< T > const &a, D2< T > const &b)
Piecewise< SBasis > cross (Piecewise< D2< SBasis > > const &a, Piecewise< D2< SBasis > > const &b)
unsigned crossing_along (double t, unsigned ix, unsigned jx, bool dir, Crossings const &crs)
unsigned crossing_count (double const *V, unsigned degree, double left_t, double right_t)
unsigned crossing_count (Geom::Point const *V, unsigned degree)
void crossing_dual (unsigned &i, unsigned &j, CrossingSet const &crs)
CrossingSet crossings (std::vector< Path > const &a, std::vector< Path > const &b)
Crossings crossings (Path const &a, Path const &b)
Crossings crossings (Curve const &a, Curve const &b)
CrossingSet crossings_among (std::vector< Path > const &p)
CrossingSet crossings_between (Shape const &a, Shape const &b)
template<class T>
cube (const T &x)
template<typename iterator>
static void cubic_bezier_poly_coeff (iterator b, Point *pc)
Path cubicbezierpath_from_sbasis (D2< SBasis > const &B, double tol)
std::vector< D2< SBasis > > cubics_fitting_curvature (Point const &M0, Point const &M1, Point const &dM0, Point const &dM1, Point const &d2M0, Point const &d2M1, int insist_on_speed_signs, double epsilon)
std::vector< D2< SBasis > > cubics_fitting_curvature (Point const &M0, Point const &M1, Point const &dM0, Point const &dM1, double d2M0xdM0, double d2M1xdM1, int insist_on_speed_signs, double epsilon)
 returns the cubics fitting direction and curvature of a given input curve at two points.
std::vector< D2< SBasis > > cubics_with_prescribed_curvature (Point const &M0, Point const &M1, Point const &dM0, Point const &dM1, double k0, double k1, int insist_on_speed_signs, double epsilon)
Piecewise< SBasis > curvature (Piecewise< D2< SBasis > > const &V, double tol)
Piecewise< SBasis > curvature (D2< SBasis > const &M, double tol)
std::vector< double > curve_mono_splits (Curve const &d)
Crossings curve_self_crossings (Curve const &a)
template<typename T>
Crossings curve_sweep (Path const &a, Path const &b)
Piecewise< D2< SBasis > > cutAtRoots (Piecewise< D2< SBasis > > const &M, double ZERO)
static Point darray_center_tangent (Point const d[], unsigned center, unsigned length)
Point darray_left_tangent (Point const d[], unsigned const len, double const tolerance_sq)
Point darray_left_tangent (Point const d[], unsigned const len)
Point darray_right_tangent (Point const d[], unsigned const len, double const tolerance_sq)
static Point darray_right_tangent (Point const d[], unsigned const len)
double decimal_round (double const x, int const places)
double deg_to_rad (double deg)
SBasis derivative (SBasis const &a)
Poly derivative (Poly const &p)
template<typename T>
Piecewise< T > derivative (Piecewise< T > const &a)
template<typename T>
D2< T > derivative (D2< T > const &a)
Bezier derivative (const Bezier &a)
std::vector< Path > desanitize (Shape const &s)
double distance (Point const &p, Rect const &rect)
double distance (Point const &_point, Ray const &_ray)
Coord distance (Point const &a, Point const &b)
double distance (Point const &_point, LineSegment const &_segment)
double distance (Point const &_point, Line const &_line)
double distanceSq (Point const &p, Rect const &rect)
Coord distanceSq (Point const &a, Point const &b)
SBasis divide (SBasis const &a, SBasis const &b, int k)
SBasis2d divide (SBasis2d const &a, SBasis2d const &b, int k)
Poly divide (Poly const &a, Poly const &b, Poly &r)
Piecewise< SBasis > divide (SBasis const &a, SBasis const &b, double tol, unsigned k, double zero)
Piecewise< SBasis > divide (SBasis const &a, Piecewise< SBasis > const &b, double tol, unsigned k, double zero)
Piecewise< SBasis > divide (Piecewise< SBasis > const &a, SBasis const &b, double tol, unsigned k, double zero)
Piecewise< SBasis > divide (Piecewise< SBasis > const &a, Piecewise< SBasis > const &b, double tol, unsigned k, double zero)
Piecewise< SBasis > divide (Piecewise< SBasis > const &a, Piecewise< SBasis > const &b, unsigned k)
Poly divide_out_root (Poly const &p, double x)
Coord dot (Point const &a, Point const &b)
template<typename T>
dot (D2< T > const &a, D2< T > const &b)
Piecewise< SBasis > dot (Piecewise< D2< SBasis > > const &a, Piecewise< D2< SBasis > > const &b)
template<typename T>
elem_portion (const Piecewise< T > &a, unsigned i, double from, double to)
static void eliminate_duplicates_p (std::vector< Point > &pts)
Matrix elliptic_quadratic_form (Matrix const &m)
static double EpsilonBy (double value, int eps)
static void estimate_bi (Point b[4], unsigned ei, Point const data[], double const u[], unsigned len)
static void estimate_lengths (Point bezier[], Point const data[], double const u[], unsigned len, Point const &tHat1, Point const &tHat2)
Linear extract_u (Linear2d const &a, double u)
SBasis extract_u (SBasis2d const &a, double u)
Linear extract_v (Linear2d const &a, double v)
SBasis extract_v (SBasis2d const &a, double v)
std::vector< std::vector
< unsigned > > 
fake_cull (unsigned a, unsigned b)
Geom::Point finalPoint (PathVector const &path_in)
void find_bernstein_roots (double const *w, unsigned degree, std::vector< double > &solutions, unsigned depth, double left_t, double right_t, bool use_secant)
unsigned find_bottom_right (ConvexHull const &a)
void find_collinear_normal (std::vector< std::pair< double, double > > &xs, std::vector< Point > const &A, std::vector< Point > const &B, double precision=1e-5)
unsigned find_crossing (Crossings const &cr, Crossing x, unsigned i)
void find_intersections (std::vector< std::pair< double, double > > &xs, std::vector< Point > const &A, std::vector< Point > const &B, double precision)
void find_intersections (std::vector< std::pair< double, double > > &xs, D2< SBasis > const &A, D2< SBasis > const &B)
void find_intersections_bezier_clipping (std::vector< std::pair< double, double > > &xs, std::vector< Point > const &A, std::vector< Point > const &B, double precision=1e-5)
void find_parametric_bezier_roots (Geom::Point const *w, unsigned degree, std::vector< double > &solutions, unsigned depth)
void find_self_intersections (std::vector< std::pair< double, double > > &xs, D2< SBasis > const &A)
std::vector< double > find_tangents (Point P, D2< SBasis > const &A)
 returns all the parameter values of A whose tangent passes through P.
void first_false (std::vector< std::vector< bool > > visited, unsigned &i, unsigned &j)
void flip_crossings (Crossings &crs)
Piecewise< D2< SBasis > > force_continuity (Piecewise< D2< SBasis > > const &f, double tol, bool closed)
Matrix from_basis (Point const x_basis, Point const y_basis, Point const offset)
double fudgerize (double d, bool rev)
std::vector< Piecewise< D2
< SBasis > > > 
fuse_nearby_ends (std::vector< Piecewise< D2< SBasis > > > const &f, double tol)
Poly gcd (Poly const &a, Poly const &b, const double)
static void generate_bezier (Point b[], Point const d[], double const u[], unsigned len, Point const &tHat1, Point const &tHat2, double tolerance_sq)
NodeType get_nodetype (Curve const &c_incoming, Curve const &c_outgoing)
ConvexHull graham_merge (ConvexHull a, ConvexHull b)
template<typename T>
D2< SBasis > handles_to_sbasis (T const &handles, unsigned order)
double hausdorf (D2< SBasis > &A, D2< SBasis > const &B, double m_precision, double *a_t, double *b_t)
double hausdorfl (D2< SBasis > &A, D2< SBasis > const &B, double m_precision, double *a_t, double *b_t)
Matrix identity ()
template<typename iter>
iter inc (iter const &x, unsigned n)
Coord infinity ()
Geom::Point initialPoint (PathVector const &path_in)
std::vector< Path > inner_sanitize (std::vector< Path > const &ps)
int inner_winding (Path const &p, std::vector< Path > const &ps)
SBasis integral (SBasis const &c)
SBasis2d integral (SBasis2d const &c)
Poly integral (Poly const &p)
template<typename T>
Piecewise< T > integral (Piecewise< T > const &a)
template<typename T>
D2< T > integral (D2< T > const &a)
Bezier integral (const Bezier &a)
Piecewise< SBasis > interpolate (std::vector< double > times, std::vector< double > values, unsigned smoothness)
 Retruns a Piecewise SBasis with prescribed values at prescribed times.
OptRect intersect (Rect const &a, Rect const &b)
OptInterval intersect (const Interval &a, const Interval &b)
static void intersect_polish_root (Curve const &A, double &s, Curve const &B, double &t)
static void intersect_polish_root (D2< SBasis > const &A, double &s, D2< SBasis > const &B, double &t)
OptCrossing intersection (Ray const &r1, LineSegment const &ls2)
OptCrossing intersection (LineSegment const &ls1, Ray const &r2)
OptCrossing intersection (Line const &l1, LineSegment const &ls2)
OptCrossing intersection (LineSegment const &ls1, Line const &l2)
OptCrossing intersection (Line const &l1, Ray const &r2)
OptCrossing intersection (Ray const &r1, Line const &l2)
OptCrossing intersection (LineSegment const &ls1, LineSegment const &ls2)
OptCrossing intersection (Ray const &r1, Ray const &r2)
OptCrossing intersection (Line const &l1, Line const &l2)
ConvexHull intersection (ConvexHull, ConvexHull)
int intersector_ccw (const Geom::Point &p0, const Geom::Point &p1, const Geom::Point &p2)
bool intersectp (ConvexHull a, ConvexHull b)
SBasis inverse (SBasis a, int k)
SBasis2d inverse (SBasis2d const &a, int k)
static bool is_less (Point const &A, Point const &B)
bool is_unit_vector (Point const &p)
bool is_zero (Point const &p)
Coord L1 (Point const &p)
Coord L2 (Point const &p)
SBasis L2 (D2< SBasis > const &a, unsigned k)
Coord L2sq (Point const &p)
double length (Piecewise< D2< SBasis > > const &s, double tol)
double length (D2< SBasis > const &s, double tol)
double length (LineSegment const &_segment)
void length_integrating (D2< SBasis > const &B, double &result, double &abs_error, double tol)
static double lensq (Point const p)
Point lerp (double const t, Point const a, Point const b)
template<typename T>
Piecewise< T > lerp (double t, Piecewise< T > const &a, Piecewise< T > b)
double lerp (double t, double a, double b)
IntersectorKind line_intersection (Geom::Point const &n0, double const d0, Geom::Point const &n1, double const d1, Geom::Point &result)
IntersectorKind line_segment_intersect (Geom::Point const &p00, Geom::Point const &p01, Geom::Point const &p10, Geom::Point const &p11, Geom::Point &result)
bool line_segment_intersectp (Geom::Point const &p00, Geom::Point const &p01, Geom::Point const &p10, Geom::Point const &p11)
IntersectorKind line_twopoint_intersect (Geom::Point const &p00, Geom::Point const &p01, Geom::Point const &p10, Geom::Point const &p11, Geom::Point &result)
bool linear_intersect (Point A0, Point A1, Point B0, Point B1, double &tA, double &tB, double &det)
Coord LInfty (Point const &p)
Piecewise< SBasis > log (Piecewise< SBasis >const &f, double tol=1e-3, int order=3)
Piecewise< SBasis > log (SBasis const &f, double tol=1e-3, int order=3)
bool logical_xor (bool a, bool b)
Line make_angle_bisector_line (Point const &A, Point const &O, Point const &B)
Line make_angle_bisector_line (Line const &l1, Line const &l2)
Ray make_angle_bisector_ray (Ray const &r1, Ray const &r2)
Line make_bisector_line (LineSegment const &_segment)
D2< Piecewise< SBasis > > make_cuts_independent (Piecewise< D2< SBasis > > const &a)
Line make_orthogonal_line (Point const &_point, Line const &_line)
Line make_parallel_line (Point const &_point, Line const &_line)
double map_circular_arc_on_unit_interval (double angle, double start_angle, double end_angle, bool cw=true)
Coord map_unit_interval_on_circular_arc (Coord t, double start_angle, double end_angle, bool cw=true)
bool matrix_equalp (Geom::Matrix const &m0, Geom::Matrix const &m1, Geom::Coord const epsilon)
Piecewise< SBasis > max (Piecewise< SBasis > const &f, Piecewise< SBasis > const &g)
Piecewise< SBasis > max (SBasis const &f, Piecewise< SBasis > const &g)
Piecewise< SBasis > max (Piecewise< SBasis > const &f, SBasis const &g)
Piecewise< SBasis > max (SBasis const &f, SBasis const &g)
ConvexHull merge (ConvexHull a, ConvexHull b)
void merge_crossings (Crossings &a, Crossings &b, unsigned i)
Point middle_point (Point const &P1, Point const &P2)
Point middle_point (LineSegment const &_segment)
Piecewise< SBasis > min (Piecewise< SBasis > const &f, Piecewise< SBasis > const &g)
Piecewise< SBasis > min (SBasis const &f, Piecewise< SBasis > const &g)
Piecewise< SBasis > min (Piecewise< SBasis > const &f, SBasis const &g)
Piecewise< SBasis > min (SBasis const &f, SBasis const &g)
int mod (int i, int l)
Crossings mono_intersect (Curve const &A, Interval const &Ad, Curve const &B, Interval const &Bd)
void mono_intersect (Curve const &A, double Al, double Ah, Curve const &B, double Bl, double Bh, Crossings &ret, double tol=0.1, unsigned depth=0)
void mono_pair (Path const &A, double Al, double Ah, Path const &B, double Bl, double Bh, Crossings &ret, double, unsigned depth=0)
std::vector< std::vector
< double > > 
multi_roots (SBasis const &f, std::vector< double > const &levels, double htol, double vtol, double a, double b)
std::vector< std::vector
< double > > 
multi_roots (Piecewise< SBasis > const &f, std::vector< double > const &values)
static void multi_roots_internal (SBasis const &f, SBasis const &df, std::vector< double > const &levels, std::vector< std::vector< double > > &roots, double htol, double vtol, double a, double fa, double b, double fb)
SBasis multiply (SBasis const &a, SBasis const &b)
SBasis2d multiply (SBasis2d const &a, SBasis2d const &b)
D2< SBasis > multiply (SBasis const &a, D2< SBasis > const &b)
D2< SBasis > multiply (Linear const &a, D2< SBasis > const &b)
SBasis multiply_add (SBasis const &a, SBasis const &b, SBasis c)
Coord nearest_point (Point const &p, Path const &c)
double nearest_point (Point const &p, Piecewise< D2< SBasis > > const &c)
double nearest_point (Point const &p, D2< SBasis > const &c, double from=0, double to=1)
double nearest_point (Point const &p, Point const &A, Point const &v)
double nearest_point (Point const &p, Piecewise< D2< SBasis > > const &c, double from, double to)
double nearest_point (Point const &p, D2< SBasis > const &c, D2< SBasis > const &dc, double from, double to)
Coord nearest_point (Point const &p, Curve const &c)
boost::optional
< PathVectorPosition > 
nearestPoint (PathVector const &path_in, Point const &_point, double *distance_squared)
static double NewtonRaphsonRootFind (BezierCurve const Q, Point const &P, double u)
void offset_crossings (Crossings &cr, double a, double b)
std::vector< double > offset_doubles (std::vector< double > const &x, double offs)
bool operator!= (Linear2d const &a, Linear2d const &b)
bool operator!= (Point const &a, Point const &b)
bool operator!= (Matrix const &a, Matrix const &b)
bool operator!= (Linear const &a, Linear const &b)
template<typename T>
bool operator!= (D2< T > const &a, D2< T > const &b)
Point operator* (Point const &v, Rotate const &r)
Point operator* (Point const &p, Scale const &s)
Point operator* (Point const &v, Translate const &t)
Matrix operator* (Matrix const &m, Rotate const &r)
Matrix operator* (Matrix const &m, Scale const &s)
Matrix operator* (Matrix const &m, Translate const &t)
Matrix operator* (Scale const &s, Matrix const &m)
Matrix operator* (Scale const &s, Translate const &t)
Matrix operator* (Translate const &t, Rotate const &r)
Matrix operator* (Translate const &t, Scale const &s)
SBasis operator* (SBasis const &a, SBasis const &b)
SBasis operator* (double k, SBasis const &a)
SBasis operator* (SBasis const &a, double k)
SBasis2d operator* (SBasis2d const &a, SBasis2d const &b)
SBasis2d operator* (double k, SBasis2d const &a)
Linear2d operator* (double const a, Linear2d const &b)
Poly operator* (double a, Poly const &b)
Point operator* (double const s, Point const &p)
Point operator* (Point const &v, Matrix const &m)
template<typename T1, typename T2>
Piecewise< T2 > operator* (Piecewise< T1 > const &a, Piecewise< T2 > const &b)
template<typename T>
Piecewise< T > operator* (Piecewise< T > const &a, T b)
template<typename T>
Piecewise< T > operator* (Piecewise< T > const &a, double b)
PathVector operator* (PathVector const &path_in, Translate const &m)
PathVector operator* (PathVector const &path_in, Matrix const &m)
Matrix operator* (Matrix const &m0, Matrix const &m1)
Linear operator* (Linear const &a, double b)
Interval operator* (const Interval &a, const Interval &b)
template<typename T>
D2< T > operator* (D2< T > const &a, T const &b)
template<typename T>
D2< T > operator* (D2< T > const &v, Matrix const &m)
template<typename T>
D2< T > operator* (D2< T > const &a, double b)
template<typename T>
D2< T > operator* (D2< T > const &a, Point const &b)
Piecewise< D2< SBasis > > operator* (Piecewise< D2< SBasis > > const &a, Matrix const &m)
template<class T>
ConvexHull operator* (ConvexHull const &p, T const &m)
Bezier operator* (const Bezier &a, double v)
SBasis & operator*= (SBasis &a, SBasis const &b)
SBasis & operator*= (SBasis &a, double b)
SBasis2d & operator*= (SBasis2d &a, double b)
Linear2d & operator*= (Linear2d &a, double b)
template<typename T>
Piecewise< T > & operator*= (Piecewise< T > &a, Piecewise< T > const &b)
template<typename T>
Piecewise< T > & operator*= (Piecewise< T > &a, double b)
void operator*= (PathVector &path_in, Translate const &m)
void operator*= (PathVector &path_in, Matrix const &m)
Matrixoperator*= (Matrix &a, Matrix const &b)
Linear operator*= (Linear &a, double b)
Interval operator*= (Interval &a, const Interval &b)
template<typename T>
D2< T > operator*= (D2< T > &a, double b)
template<typename T>
D2< T > operator*= (D2< T > &a, Point const &b)
SBasis operator+ (const SBasis &a, double b)
SBasis operator+ (const SBasis &a, const SBasis &b)
SBasis2d operator+ (const SBasis2d &a, const SBasis2d &b)
Linear2d operator+ (Linear2d const &a, Linear2d const &b)
template<typename T>
Piecewise< T > operator+ (Piecewise< T > const &a, Piecewise< T > const &b)
template<typename T>
Piecewise< T > operator+ (Piecewise< T > const &a, typename T::output_type b)
PathVector operator+ (PathVector const &path_in, Point const &p)
Linear operator+ (Linear const &a, double b)
Linear operator+ (Linear const &a, Linear const &b)
Interval operator+ (const Interval &a, const Interval &b)
template<typename T>
D2< T > operator+ (D2< T > const &a, Point b)
template<typename T>
D2< T > operator+ (D2< T > const &a, D2< T > const &b)
Bezier operator+ (const Bezier &a, double v)
SBasis & operator+= (SBasis &a, double b)
SBasis & operator+= (SBasis &a, const SBasis &b)
SBasis2d & operator+= (SBasis2d &a, double b)
SBasis2d & operator+= (SBasis2d &a, const Linear2d &b)
Linear2d & operator+= (Linear2d &a, Linear2d const &b)
template<typename T>
Piecewise< T > & operator+= (Piecewise< T > &a, Piecewise< T > const &b)
template<typename T>
Piecewise< T > & operator+= (Piecewise< T > &a, typename T::output_type b)
void operator+= (PathVector &path_in, Point const &p)
Linear & operator+= (Linear &a, double b)
Linear & operator+= (Linear &a, Linear const &b)
Interval operator+= (Interval &a, const Interval &b)
template<typename T>
D2< T > operator+= (D2< T > &a, Point b)
template<typename T>
D2< T > operator+= (D2< T > &a, D2< T > const &b)
SBasis operator- (const SBasis &a, double b)
SBasis operator- (const SBasis &p)
SBasis operator- (const SBasis &a, const SBasis &b)
SBasis2d operator- (const SBasis2d &a, const SBasis2d &b)
SBasis2d operator- (const SBasis2d &p)
Linear2d operator- (Linear2d const &a, Linear2d const &b)
Linear2d operator- (Linear2d const &a)
template<typename T>
Piecewise< T > operator- (Piecewise< T > const &a, Piecewise< T > const &b)
template<typename T>
Piecewise< T > operator- (Piecewise< T > const &a)
template<typename T>
Piecewise< T > operator- (Piecewise< T > const &a, typename T::output_type b)
Linear operator- (Linear const &a)
Linear operator- (Linear const &a, double b)
Linear operator- (Linear const &a, Linear const &b)
Interval operator- (const Interval &a, const Interval &b)
template<typename T>
D2< T > operator- (D2< T > const &a, Point b)
template<typename T>
D2< T > operator- (D2< T > const &a)
template<typename T>
D2< T > operator- (D2< T > const &a, D2< T > const &b)
Bezier operator- (const Bezier &a, double v)
SBasis & operator-= (SBasis &a, double b)
SBasis & operator-= (SBasis &a, const SBasis &b)
SBasis2d & operator-= (SBasis2d &a, double b)
SBasis2d & operator-= (SBasis2d &a, const Linear2d &b)
Linear2d & operator-= (Linear2d &a, Linear2d const &b)
template<typename T>
Piecewise< T > & operator-= (Piecewise< T > &a, Piecewise< T > const &b)
template<typename T>
Piecewise< T > & operator-= (Piecewise< T > &a, typename T::output_type b)
Linear & operator-= (Linear &a, double b)
Linear & operator-= (Linear &a, Linear const &b)
Interval operator-= (Interval &a, const Interval &b)
template<typename T>
D2< T > operator-= (D2< T > &a, Point b)
template<typename T>
D2< T > operator-= (D2< T > &a, D2< T > const &b)
SBasis operator/ (SBasis const &a, double k)
Point operator/ (Point const &p, Matrix const &m)
template<typename T>
Piecewise< T > operator/ (Piecewise< T > const &a, double b)
Linear operator/ (Linear const &a, double b)
template<typename T>
D2< T > operator/ (D2< T > const &a, double b)
template<typename T>
D2< T > operator/ (D2< T > const &a, Point const &b)
Bezier operator/ (const Bezier &a, double v)
SBasis & operator/= (SBasis &a, double b)
SBasis2d & operator/= (SBasis2d &a, double b)
template<typename T>
Piecewise< T > & operator/= (Piecewise< T > &a, double b)
Linear operator/= (Linear &a, double b)
template<typename T>
D2< T > operator/= (D2< T > &a, double b)
template<typename T>
D2< T > operator/= (D2< T > &a, Point const &b)
template<class charT>
std::basic_ostream< charT > & operator<< (std::basic_ostream< charT > &os, const SVGEllipticalArc &ea)
std::ostream & operator<< (std::ostream &out_file, const SBasis &p)
std::ostream & operator<< (std::ostream &out_file, const Linear &bo)
std::ostream & operator<< (std::ostream &out_file, const SBasis2d &p)
std::ostream & operator<< (std::ostream &out_file, const Linear2d &bo)
std::ostream & operator<< (std::ostream &out_file, const Poly &in_poly)
std::ostream & operator<< (std::ostream &out_file, const Geom::Point &in_pnt)
std::ostream & operator<< (std::ostream &out_file, const Geom::Matrix &m)
template<typename T>
std::ostream & operator<< (std::ostream &out_file, const Geom::D2< T > &in_d2)
std::ostream & operator<< (std::ostream &out_file, const Bezier &b)
bool operator<= (Point const &a, Point const &b)
bool operator== (Linear2d const &a, Linear2d const &b)
bool operator== (Point const &a, Point const &b)
bool operator== (Matrix const &a, Matrix const &b)
bool operator== (Linear const &a, Linear const &b)
template<typename T>
bool operator== (D2< T > const &a, D2< T > const &b)
Point operator^ (Point const &a, Point const &b)
void outer_crossing (unsigned &ix, unsigned &jx, bool &dir, std::vector< Path > const &ps, CrossingSet const &crs)
unsigned outer_index (Regions const &ps)
void output (SVGEllipticalArc const &curve, SVGPathSink &sink)
void output (LineSegment const &curve, SVGPathSink &sink)
void output (VLineSegment const &curve, SVGPathSink &sink)
void output (HLineSegment const &curve, SVGPathSink &sink)
void output (Curve const &curve, SVGPathSink &sink)
template<typename T>
bool output_as (Curve const &curve, SVGPathSink &sink)
void output_svg_path (Path &path, SVGPathSink &sink)
Crossings pair_intersect (Curve const &A, Interval const &Ad, Curve const &B, Interval const &Bd)
void pair_intersect (Curve const &A, double Al, double Ah, Curve const &B, double Bl, double Bh, Crossings &ret, unsigned depth=0)
std::vector< Path > parse_svg_path (char const *str) throw (SVGPathParseError)
void parse_svg_path (char const *str, SVGPathSink &sink) throw (SVGPathParseError)
SBasis2d partial_derivative (SBasis2d const &f, int dim)
template<typename T>
Piecewise< T > partition (const Piecewise< T > &pw, std::vector< double > const &c)
bool path_direction (Path const &p)
std::vector< Geom::Path > path_from_piecewise (Geom::Piecewise< Geom::D2< Geom::SBasis > > const &B, double tol, bool only_cubicbeziers)
Path path_from_sbasis (D2< SBasis > const &B, double tol, bool only_cubicbeziers)
std::vector< double > path_mono_splits (Path const &p)
std::vector< Path > paths_from_regions (Regions const &rs)
std::vector< std::vector
< double > > 
paths_mono_splits (std::vector< Path > const &ps)
static Piecewise< D2< SBasis > > paths_to_pw (std::vector< Path > paths)
int paths_winding (std::vector< Path > const &ps, Point p)
unsigned pick_coincident (unsigned ix, unsigned jx, bool &rev, std::vector< Path > const &ps, CrossingSet const &crs)
Point pointAt (PathVector const &path_in, PathVectorPosition const pvp)
void polish_intersections (std::vector< std::pair< double, double > > &xs, D2< SBasis > const &A, D2< SBasis > const &B)
double polish_root (Poly const &p, double guess, double tol)
SBasis poly_to_sbasis (Poly const &p)
SBasis portion (const SBasis &t, Interval ivl)
SBasis portion (const SBasis &t, double from, double to)
template<typename T>
Piecewise< T > portion (const Piecewise< T > &pw, double from, double to)
template<typename T>
D2< T > portion (const D2< T > &a, Interval i)
template<typename T>
D2< T > portion (const D2< T > &a, Coord f, Coord t)
template<typename T>
portion (const T &t, const Interval &i)
Bezier portion (const Bezier &a, double from, double to)
Matrix pow (Matrix t, int n)
Rotate pow (Rotate t, int n)
Matrix pow (Matrix x, long n)
Rotate pow (Rotate x, long n)
Scale pow (Scale const &s, int n)
Coord pow (Coord x, long n)
Translate pow (Translate const &t, int n)
LineSegment projection (LineSegment const &_segment, Line const &_line)
Point projection (Point const &_point, Line const &_line)
double rad_to_deg (double rad)
std::vector< Path > read_svgd (char const *name) throw (SVGPathParseError)
SBasis reciprocal (Linear const &a, int k)
Piecewise< SBasis > reciprocal (Piecewise< SBasis > const &f, double tol, int order)
Piecewise< SBasis > reciprocal (SBasis const &f, double tol, int order)
SBasis2d reciprocal (Linear2d const &a, int k)
Piecewise< SBasis > reciprocalOnDomain (Interval range, double tol)
boost::optional< LineSegment > rect_line_intersect (Geom::Rect &r, Geom::Line l)
boost::optional< LineSegment > rect_line_intersect (Geom::Rect &r, Geom::LineSegment ls)
std::vector< Geom::Pointrect_line_intersect (Geom::Point const &c0, Geom::Point const &c1, Geom::Point const &p0, Geom::Point const &p1)
Regions region_boolean (bool rev, Region const &a, Region const &b)
Regions region_boolean (bool rev, Region const &a, Region const &b, Crossings const &cr_a, Crossings const &cr_b)
Regions region_boolean (bool rev, Region const &a, Region const &b, Crossings const &cr)
std::vector< double > region_sizes (Shape const &a)
Regions regions_from_paths (std::vector< Path > const &ps)
template<typename T>
Piecewise< T > remove_short_cuts (Piecewise< T > const &f, double tol)
template<typename T>
Piecewise< T > remove_short_cuts_extending (Piecewise< T > const &f, double tol)
static void reparameterize (Point const d[], unsigned len, double u[], BezierCurve const bezCurve)
SBasis reverse (SBasis const &a)
template<typename T>
Piecewise< T > reverse (Piecewise< T > const &f)
Linear reverse (Linear const &a)
template<typename T>
D2< T > reverse (const D2< T > &a)
Bezier reverse (const Bezier &a)
PathVector reverse_paths_and_order (PathVector const &path_in)
CrossingSet reverse_ta (CrossingSet const &cr, unsigned split, std::vector< double > max)
Crossings reverse_ta (Crossings const &cr, std::vector< double > max)
CrossingSet reverse_tb (CrossingSet const &cr, unsigned split, std::vector< double > max)
Crossings reverse_tb (Crossings const &cr, unsigned split, std::vector< double > max)
std::vector< double > roots (SBasis const &s)
template<typename T>
std::vector< double > roots (const Piecewise< T > &pw)
std::vector< double > roots (Piecewise< SBasis > const &f)
std::vector< double > roots1 (SBasis const &s)
Point rot90 (Point const &p)
template<typename T>
D2< T > rot90 (D2< T > const &a)
Piecewise< D2< SBasis > > rot90 (Piecewise< D2< SBasis > > const &M)
double round (double const x)
Shape sanitize (std::vector< Path > const &ps)
Regions sanitize_path (Path const &p)
D2< SBasis > sb2d_cubic_solve (SBasis2d const &f, Geom::Point const &A, Geom::Point const &B)
D2< SBasis > sb2dsolve (SBasis2d const &f, Geom::Point const &A, Geom::Point const &B, unsigned degmax)
unsigned sbasis_size (D2< SBasis > const &a)
void sbasis_to_bezier (std::vector< Point > &bz, D2< SBasis > const &sb, size_t sz)
void sbasis_to_bezier (Bezier &bz, SBasis const &sb, size_t sz)
Poly sbasis_to_poly (SBasis const &sb)
Piecewise< D2< SBasis > > sectionize (D2< Piecewise< SBasis > > const &a)
IntersectorKind segment_intersect (Geom::Point const &p00, Geom::Point const &p01, Geom::Point const &p10, Geom::Point const &p11, Geom::Point &result)
bool segment_intersectp (Geom::Point const &p00, Geom::Point const &p01, Geom::Point const &p10, Geom::Point const &p11)
Crossings self_crossings (Path const &p)
static void set_first_point (Piecewise< D2< SBasis > > &f, Point a)
static void set_last_point (Piecewise< D2< SBasis > > &f, Point a)
template<class T>
int sgn (const T &x)
template<class t>
static int SGN (t x)
int sgn (unsigned int j, unsigned int k)
Shape shape_boolean (bool rev, Shape const &a, Shape const &b)
Shape shape_boolean (bool rev, Shape const &a, Shape const &b, CrossingSet const &crs)
Shape shape_boolean_ra (bool rev, Shape const &a, Shape const &b, CrossingSet const &crs)
Shape shape_boolean_rb (bool rev, Shape const &a, Shape const &b, CrossingSet const &crs)
SBasis shift (Linear const &a, int sh)
SBasis shift (SBasis const &a, int sh)
SBasis2d shift (Linear2d const &a, int sh)
SBasis2d shift (SBasis2d const &a, int sh)
double SignedTriangleArea (Point p0, Point p1, Point p2)
Piecewise< SBasis > signSb (Piecewise< SBasis > const &f)
Piecewise< SBasis > signSb (SBasis const &f)
SBasis sin (Linear b, int k)
Piecewise< SBasis > sin (Piecewise< SBasis > const &f, double tol, int order)
Piecewise< SBasis > sin (SBasis const &f, double tol, int order)
std::vector< std::complex
< double > > 
solve (Poly const &pp)
std::vector< double > solve_reals (Poly const &p)
void sort_crossings (Crossings &cr, unsigned ix)
void split (vector< Point > const &p, double t, vector< Point > &left, vector< Point > &right)
std::vector< Geom::Piecewise
< Geom::D2< Geom::SBasis > > > 
split_at_discontinuities (Geom::Piecewise< Geom::D2< Geom::SBasis > > const &pwsbin, double tol)
std::vector< std::vector< Rect > > split_bounds (std::vector< Path > const &p, std::vector< std::vector< double > > splits)
template<class T>
sqr (const T &x)
SBasis sqrt (SBasis const &a, int k)
Piecewise< SBasis > sqrt (Piecewise< SBasis > const &f, double tol, int order)
Piecewise< SBasis > sqrt (SBasis const &f, double tol, int order)
SBasis2d sqrt (SBasis2d const &a, int k)
static Piecewise< SBasis > sqrt_internal (SBasis const &f, double tol, int order)
Shape stopgap_cleaner (std::vector< Path > const &ps)
void subdiv_sbasis (SBasis const &s, std::vector< double > &roots, double left, double right)
Coord subdivideArr (Coord t, Coord const *v, Coord *left, Coord *right, unsigned order)
std::vector< std::vector
< unsigned > > 
sweep_bounds (std::vector< Rect > a, std::vector< Rect > b, Dim2 d)
 Make a list of pairs of red-blue intersections between two lists of Rects.
std::vector< std::vector
< unsigned > > 
sweep_bounds (std::vector< Rect > rs, Dim2 d)
 Make a list of pairs of self intersections in a list of Rects.
ConvexHull sweepline_intersection (ConvexHull const &a, ConvexHull const &b)
double tail_error (D2< SBasis > const &a, unsigned tail)
D2< Piecewise< SBasis > > tan2 (Piecewise< SBasis > const &angle, double tol, unsigned order)
D2< Piecewise< SBasis > > tan2 (SBasis const &angle, double tol, unsigned order)
bool transform_equalp (Geom::Matrix const &m0, Geom::Matrix const &m1, Geom::Coord const epsilon)
bool translate_equalp (Geom::Matrix const &m0, Geom::Matrix const &m1, Geom::Coord const epsilon)
SBasis truncate (SBasis const &a, unsigned terms)
SBasis2d truncate (SBasis2d const &a, unsigned terms)
D2< SBasis > truncate (D2< SBasis > const &a, unsigned terms)
void truncateResult (Piecewise< SBasis > &f, int order)
static Point const unconstrained_tangent (0, 0)
OptRect unify (OptRect const &a, OptRect const &b)
Rect unify (const Rect &, const Rect &)
Interval unify (const Interval &a, const Interval &b)
Rect union_list (std::vector< Rect > const &r)
Point unit_vector (Point const &a)
Piecewise< D2< SBasis > > unitVector (Piecewise< D2< SBasis > > const &V, double tol, unsigned order)
Piecewise< D2< SBasis > > unitVector (D2< SBasis > const &V_in, double tol, unsigned order)
static int upper_level (vector< double > const &levels, double x, double tol=0.)
unsigned valuation (SBasis const &a, double tol=0)
int winding (Path const &path, Point p)
double wrap_dist (double from, double to, double size, bool rev)

Variables

static const char _svg_path_actions []
static const short _svg_path_index_offsets []
static const short _svg_path_indicies []
static const short _svg_path_key_offsets []
static const char _svg_path_range_lengths []
static const char _svg_path_single_lengths []
static const char _svg_path_trans_actions_wi []
static const char _svg_path_trans_keys []
static const short _svg_path_trans_targs_wi []
const double BEPSILON = ldexp(1.0,(-MAXDEPTH-1))
const Coord EPSILON = 1e-5
const unsigned MAXDEPTH = 23
const double SECANT_EPSILON = 1e-13
static const int svg_path_en_main = 1
static const int svg_path_first_final = 270
static const int svg_path_start = 1
unsigned total_steps
unsigned total_subs
static Point const unconstrained_tangent (0, 0)


Generated by  Doxygen 1.6.0   Back to index