Logo Search packages:      
Sourcecode: inkscape version File versions

Geom Namespace Reference


Detailed Description

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)

Defines the different types of exceptions that 2geom can throw.

Copyright 2007 Johan Engelen <goejendaagh@zonnet.nl>

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.

two-dimensional geometric operators. Copyright 2007, JFBarraud Copyright 2007, njh

These operators are built on a more 'polynomially robust' transformation to map a function that takes a [0,1] parameter to a 2d vector into a function that takes the same [0,1] parameter to a unit vector with the same direction.

Rather that using (X/sqrt(X))(t) which involves two unstable operations, sqrt and divide, this approach forms a curve directly from the various tangent directions at each end (angular jet). As a result, the final path has a convergence behaviour derived from that of the sin and cos series. -- njh

Various utility functions.

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.


Classes

struct  AddableConcept
class  angle_cmp
class  BaseIterator
class  Bezier
class  BezierCurve
class  BezierCurve< 0 >
class  Circulator
struct  ContainmentOrder
class  ContinuityError
class  ConvexHull
struct  Crosser
struct  Crossing
struct  CrossingNode
struct  CrossingOrder
class  Curve
struct  CurveHelpers
class  D2
class  DuplicatingIterator
struct  Edge
class  Eigen
struct  Event
class  Exception
struct  FragmentConcept
class  Hat
class  Interval
class  InvariantsViolation
class  IPoint
class  Linear
class  Linear2d
class  LogicalError
class  Matrix
struct  MonoCrosser
struct  MultiplicableConcept
struct  NearConcept
class  NotImplemented
class  NotInvertible
struct  OffsetableConcept
class  OldBezier
class  Path
class  PathBuilder
class  Piecewise
class  Point
 Cartesian point. More...
class  RangeError
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  TimeOrder
struct  TransformConcept
class  Translate
class  Tri

Typedefs

typedef Point BezierCurve []
typedef double Coord
typedef std::vector< CrossingNode > CrossingGraph
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 BezierCurve< 2 > QuadraticBezier
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  Dim2 { X = 0, Y = 1 }
enum  IntersectorKind { intersects = 0, parallel, coincident, no_intersection }

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)
Coord angle_between (Point const a, Point const b)
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_near (Point const &a, Point const &b, double const 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)
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)
static void Bernstein (double const *V, unsigned degree, double t, double *Left, double *Right)
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)
SBasis bezier_to_sbasis (Bezier const &B)
SBasis bezier_to_sbasis (Coord const *handles, unsigned order)
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< Rect > bounds (C const &a)
Interval bounds_exact (SBasis const &a)
template<typename T>
FragmentConcept< T >::BoundsType bounds_exact (const Piecewise< T > &f)
template<typename T>
Rect bounds_exact (const D2< T > &a)
Interval bounds_exact (Bezier const &b)
Interval bounds_fast (const SBasis &sb, int order)
template<typename T>
FragmentConcept< T >::BoundsType bounds_fast (const Piecewise< T > &f)
template<typename T>
Rect bounds_fast (const D2< T > &a)
Interval bounds_fast (Bezier const &b)
Interval bounds_local (const SBasis &sb, const Interval &i, int order)
template<typename T>
FragmentConcept< T >::BoundsType bounds_local (const Piecewise< T > &f, const Interval &m)
template<typename T>
Rect bounds_local (const D2< T > &a, const Interval &t)
Interval bounds_local (Bezier const &b, Interval 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)
unsigned centroid (Piecewise< D2< SBasis > > const &p, Point &centroid, double &area)
int centroid (std::vector< Geom::Point > 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 &cr_a, Crossings &cr_b)
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)
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)
bool contains (Path const &p, Point i, bool evenodd=true)
static unsigned control_poly_flat_enough (Geom::Point const *V, unsigned degree)
static unsigned control_poly_flat_enough (double const *V, unsigned degree, double left_t, double right_t)
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)
CrossingGraph create_crossing_graph (std::vector< Path > const &p, Crossings const &crs)
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)
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)
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)
SBasis2d derivative (SBasis2d const &a)
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)
Coord distance (Point const &a, Point const &b)
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)
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)
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)
Matrix elliptic_quadratic_form (Matrix const &m)
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)
void find_bernstein_roots (double const *w, unsigned degree, std::vector< double > &solutions, unsigned depth, double left_t, double right_t)
unsigned find_bottom_right (ConvexHull const &a)
unsigned find_crossing (Crossings const &cr, Crossing x, unsigned i)
std::vector< std::pair< double,
double > > 
find_intersections (std::vector< Point > const &A, std::vector< Point > const &B)
std::vector< std::pair< double,
double > > 
find_intersections (D2< SBasis > const &A, D2< SBasis > const &B)
std::vector< std::pair< double,
double > > 
find_intersections (vector< Geom::Point > const &A, vector< Geom::Point > const &B)
static std::vector< std::pair
< double, double > > 
find_intersections (OldBezier a, OldBezier b)
void find_parametric_bezier_roots (Geom::Point const *w, unsigned degree, std::vector< double > &solutions, unsigned depth)
std::vector< std::pair< double,
double > > 
find_self_intersections (std::vector< Point > const &A)
std::vector< std::pair< double,
double > > 
find_self_intersections (D2< SBasis > const &A)
std::vector< std::pair< double,
double > > 
find_self_intersections (OldBezier const &Sb)
static std::vector< std::pair
< double, double > > 
find_self_intersections (OldBezier const &Sb, D2< SBasis > const &A)
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)
static void generate_bezier (Point b[], Point const d[], double const u[], unsigned len, Point const &tHat1, Point const &tHat2, double tolerance_sq)
ConvexHull graham_merge (ConvexHull a, ConvexHull b)
template<typename T>
D2< SBasis > handles_to_sbasis (T const &handles, unsigned order)
Matrix identity ()
template<typename iter>
iter inc (iter const &x, unsigned n)
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)
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)
boost::optional< Interval > intersect (const Interval &a, const Interval &b)
bool intersect_BB (OldBezier a, OldBezier b)
ConvexHull intersection (ConvexHull a, ConvexHull b)
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)
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 &M, double tol)
double length (D2< SBasis > const &M, double tol)
static double lensq (Point const p)
Point lerp (double const t, Point const a, Point const 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_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)
double Lmax (Point 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)
double log4 (double x)
bool logical_xor (bool a, bool b)
D2< Piecewise< SBasis > > make_cuts_independant (Piecewise< D2< SBasis > > const &a)
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)
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)
void mono_pair (Path const &A, double Al, double Ah, Path const &B, double Bl, double Bh, Crossings &ret, double tol, unsigned depth=0)
double mopi (int i)
std::vector< std::vector
< double > > 
multi_roots (SBasis const &f, std::vector< double > const &levels, double htol, double vtol, double a, double b)
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)
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)
Matrix operator* (Matrix const &m, Rotate const &r)
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, 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)
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, double b)
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 &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)
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, Linear const &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)
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 Linear &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- (const SBasis &a, double b)
SBasis operator- (const SBasis &a, Linear const &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 Linear &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)
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 Geom::Point &in_pnt)
std::ostream & operator<< (std::ostream &out_file, const Geom::Matrix &m)
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 (Curve const &curve, SVGPathSink &sink)
template<typename T>
bool output_as (Curve const &curve, SVGPathSink &sink)
void output_svg_path (Path &path, SVGPathSink &sink)
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)
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)
Path path_from_sbasis (D2< SBasis > const &B, double tol)
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)
SBasis poly_to_sbasis (Poly const &p)
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, Coord f, Coord t)
template<typename T>
portion (const T &t, const Interval &i)
Bezier portion (const Bezier &a, double from, double to)
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)
void recursively_intersect (OldBezier a, double t0, double t1, int deptha, OldBezier b, double u0, double u1, int depthb, std::vector< std::pair< double, double > > &parameters)
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)
Linear reverse (Linear const &a)
template<typename T>
D2< T > reverse (const D2< T > &a)
Bezier reverse (const Bezier &a)
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)
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)
unsigned sbasis_size (D2< SBasis > const &a)
std::vector< Geom::Pointsbasis_to_bezier (D2< SBasis > const &B, unsigned qq)
Bezier sbasis_to_bezier (SBasis const &B, unsigned q)
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)
static 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)
template<class T>
int sgn (const T &x)
template<class t>
static int SGN (t x)
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)
void sort_crossings (Crossings &cr, unsigned ix)
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)
std::vector< std::vector
< unsigned > > 
sweep_bounds (std::vector< Rect > rs)
ConvexHull sweepline_intersection (ConvexHull const &a, ConvexHull const &b)
double tail_error (D2< SBasis > const &a, unsigned tail)
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)
Interval unify (const Interval &a, const Interval &b)
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)
double W (unsigned n, unsigned j, unsigned k)
unsigned wangs_theorem (OldBezier a)
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 unsigned 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 double eps = .1
const Coord EPSILON = 1e-5
const double INV_EPS = (1L<<14)
const unsigned MAXDEPTH = 64
static const int svg_path_first_final = 326
static const int svg_path_start = 0
unsigned total_steps
unsigned total_subs
static Point const unconstrained_tangent (0, 0)


Generated by  Doxygen 1.6.0   Back to index