From dcd4896fd6aff786fedff74a044ac7c7c1806dbe Mon Sep 17 00:00:00 2001 From: Andy Date: Thu, 30 Mar 2017 02:22:23 -0700 Subject: [PATCH] added "examples" folder --- ...-many-points-quickly-using-numpy-arrays.py | 56 +++++++++++++++++++ ...path-is-contained-in-other-path-example.py | 39 +++++++++++++ .../distance-between-two-svg-paths-example.py | 17 ++++++ 3 files changed, 112 insertions(+) create mode 100644 examples/compute-many-points-quickly-using-numpy-arrays.py create mode 100755 examples/determine-if-svg-path-is-contained-in-other-path-example.py create mode 100755 examples/distance-between-two-svg-paths-example.py diff --git a/examples/compute-many-points-quickly-using-numpy-arrays.py b/examples/compute-many-points-quickly-using-numpy-arrays.py new file mode 100644 index 0000000..590821a --- /dev/null +++ b/examples/compute-many-points-quickly-using-numpy-arrays.py @@ -0,0 +1,56 @@ +"""The goal of this gist is to show how to compute many points on a path +quickly using NumPy arrays. I.e. there's a much faster way than using, say +[some_path.point(t) for t in many_tvals]. The example below assumes the +`Path` object is composed entirely of `CubicBezier` objects, but this can +easily be generalized to paths containing `Line` and `QuadraticBezier` objects +also. +Note: The relevant matrix transformation for quadratics can be found in the +svgpathtools.bezier module.""" + +import numpy as np +from svgpathtools import * + + +class HigherOrderBezier: + def __init__(self, bpoints): + self.bpts = bpoints + + def bpoints(self): + return self.bpts + + def point(self, t): + return bezier_point(self.bpoints(), t) + + def __repr__(self): + return str(self.bpts) + + +def random_bezier(degree): + if degree <= 3: + return bpoints2bezier(polynomial2bezier(np.random.rand(degree + 1))) + else: + return HigherOrderBezier(np.random.rand(degree + 1)) + + +def points_in_each_seg_slow(path, tvals): + return [seg.poly()(tvals) for seg in path] + + +def points_in_each_seg(path, tvals): + """Compute seg.point(t) for each seg in path and each t in tvals.""" + A = np.matrix([[-1, 3, -3, 1], # transforms cubic bez to standard poly + [ 3, -6, 3, 0], + [-3, 3, 0, 0], + [ 1, 0, 0, 0]]) + B = [seg.bpoints() for seg in path] + return np.dot(B, np.dot(A, np.power(tvals, [[3],[2],[1],[0]]))) + + +if __name__ == '__main__': + num_segs = 1000 + testpath = Path(*[random_bezier(3) for dummy in range(num_segs)]) + tvals = np.linspace(0, 1, 10) + + pts = points_in_each_seg(testpath, tvals) + pts_check = points_in_each_seg_slow(testpath, tvals) + print np.max(pts - pts_check) diff --git a/examples/determine-if-svg-path-is-contained-in-other-path-example.py b/examples/determine-if-svg-path-is-contained-in-other-path-example.py new file mode 100755 index 0000000..2a01632 --- /dev/null +++ b/examples/determine-if-svg-path-is-contained-in-other-path-example.py @@ -0,0 +1,39 @@ +""" +An example of how to determine if an svg path is contained in another +svg path in Python. + +Note: for discontinuous paths you can use the svgpathtools +Path.continuous_subpaths() method to split a paths into a list of its +continuous subpaths. +""" + +from svgpathtools import * + +def path1_is_contained_in_path2(path1, path2): + assert path2.isclosed() # This question isn't well-defined otherwise + if path2.intersect(path1): + return False + + # find a point that's definitely outside path2 + xmin, xmax, ymin, ymax = path2.bbox() + B = (xmin + 1) + 1j*(ymax + 1) + + A = path1.start # pick an arbitrary point in path1 + AB_line = Path(Line(A, B)) + number_of_intersections = len(AB_line.intersect(path2)) + if number_of_intersections % 2: # if number of intersections is odd + return True + else: + return False + + +# Test examples +closed_path = Path(Line(0,5), Line(5,5+5j), Line(5+5j, 0)) +path_that_is_contained = Path(Line(1+1j, 2+2j)) +print(path1_is_contained_in_path2(path_that_is_contained, closed_path)) + +path_thats_not_contained = Path(Line(10+10j, 20+20j)) +print(path1_is_contained_in_path2(path_thats_not_contained, closed_path)) + +path_that_intersects = Path(Line(2+1j, 10+10j)) +print(path1_is_contained_in_path2(path_that_intersects, closed_path)) diff --git a/examples/distance-between-two-svg-paths-example.py b/examples/distance-between-two-svg-paths-example.py new file mode 100755 index 0000000..57e2749 --- /dev/null +++ b/examples/distance-between-two-svg-paths-example.py @@ -0,0 +1,17 @@ +from svgpathtools import * + +# create some example paths +path1 = CubicBezier(1,2+3j,3-5j,4+1j) +path2 = path1.rotated(60).translated(3) + +# find minimizer +from scipy.optimize import fminbound +def dist(t): + return path1.radialrange(path2.point(t))[0][0] +T2 = fminbound(dist, 0, 1) + +# Let's do a visual check +pt2 = path2.point(T2) +T1 = path1.radialrange(pt2)[0][1] +pt1 = path1.point(T1) +disvg([path1, path2, Line(pt1, pt2)], 'grb', nodes=[pt1, pt2])