def cleaned(self,
transform=None,
remove_nans=False,
clip=None,
quantize=False,
simplify=False,
curves=False,
stroke_width=1.0,
snap=False,
sketch=None):
"""
Cleans up the path according to the parameters returning a new
Path instance.
.. seealso::
See :meth:`iter_segments` for details of the keyword arguments.
Returns
-------
Path instance with cleaned up vertices and codes.
"""
vertices, codes = _path.cleanup_path(self, transform, remove_nans,
clip, snap, stroke_width,
simplify, curves, sketch)
internals = {
'should_simplify': self.should_simplify and not simplify,
'has_nonfinite': self.has_nonfinite and not remove_nans,
'simplify_threshold': self.simplify_threshold,
'interpolation_steps': self._interpolation_steps
}
return Path._fast_from_codes_and_verts(vertices, codes, internals)
def cleaned(self, transform=None, remove_nans=False, clip=None,
quantize=False, simplify=False, curves=False,
stroke_width=1.0, snap=False, sketch=None):
"""
Cleans up the path according to the parameters returning a new
Path instance.
.. seealso::
See :meth:`iter_segments` for details of the keyword arguments.
Returns
-------
Path instance with cleaned up vertices and codes.
"""
vertices, codes = _path.cleanup_path(self, transform,
remove_nans, clip,
snap, stroke_width,
simplify, curves, sketch)
internals = {'should_simplify': self.should_simplify and not simplify,
'has_nonfinite': self.has_nonfinite and not remove_nans,
'simplify_threshold': self.simplify_threshold,
'interpolation_steps': self._interpolation_steps}
return Path._fast_from_codes_and_verts(vertices, codes, internals)
def iter_segments(self, transform=None, remove_nans=True, clip=None,
quantize=False, simplify=None, curves=True):
"""
Iterates over all of the curve segments in the path. Each
iteration returns a 2-tuple (*vertices*, *code*), where
*vertices* is a sequence of 1 - 3 coordinate pairs, and *code* is
one of the :class:`Path` codes.
Additionally, this method can provide a number of standard
cleanups and conversions to the path.
*transform*: if not None, the given affine transformation will
be applied to the path.
*remove_nans*: if True, will remove all NaNs from the path and
insert MOVETO commands to skip over them.
*clip*: if not None, must be a four-tuple (x1, y1, x2, y2)
defining a rectangle in which to clip the path.
*quantize*: if None, auto-quantize. If True, force quantize,
and if False, don't quantize.
*simplify*: if True, perform simplification, to remove
vertices that do not affect the appearance of the path. If
False, perform no simplification. If None, use the
should_simplify member variable.
*curves*: If True, curve segments will be returned as curve
segments. If False, all curves will be converted to line
segments.
"""
vertices = self.vertices
if not len(vertices):
return
codes = self.codes
NUM_VERTICES = self.NUM_VERTICES
MOVETO = self.MOVETO
LINETO = self.LINETO
CLOSEPOLY = self.CLOSEPOLY
STOP = self.STOP
vertices, codes = cleanup_path(self, transform, remove_nans, clip,
quantize, simplify, curves)
len_vertices = len(vertices)
i = 0
while i < len_vertices:
code = codes[i]
if code == STOP:
return
else:
num_vertices = NUM_VERTICES[int(code) & 0xf]
curr_vertices = vertices[i:i+num_vertices].flatten()
yield curr_vertices, code
i += num_vertices
def iter_segments(self, transform=None, remove_nans=True, clip=None,
quantize=False, simplify=None, curves=True):
"""
Iterates over all of the curve segments in the path. Each
iteration returns a 2-tuple (*vertices*, *code*), where
*vertices* is a sequence of 1 - 3 coordinate pairs, and *code* is
one of the :class:`Path` codes.
Additionally, this method can provide a number of standard
cleanups and conversions to the path.
*transform*: if not None, the given affine transformation will
be applied to the path.
*remove_nans*: if True, will remove all NaNs from the path and
insert MOVETO commands to skip over them.
*clip*: if not None, must be a four-tuple (x1, y1, x2, y2)
defining a rectangle in which to clip the path.
*quantize*: if None, auto-quantize. If True, force quantize,
and if False, don't quantize.
*simplify*: if True, perform simplification, to remove
vertices that do not affect the appearance of the path. If
False, perform no simplification. If None, use the
should_simplify member variable.
*curves*: If True, curve segments will be returned as curve
segments. If False, all curves will be converted to line
segments.
"""
vertices = self.vertices
if not len(vertices):
return
codes = self.codes
NUM_VERTICES = self.NUM_VERTICES
MOVETO = self.MOVETO
LINETO = self.LINETO
CLOSEPOLY = self.CLOSEPOLY
STOP = self.STOP
vertices, codes = cleanup_path(self, transform, remove_nans, clip,
quantize, simplify, curves)
len_vertices = len(vertices)
i = 0
while i < len_vertices:
code = codes[i]
if code == STOP:
return
else:
num_vertices = NUM_VERTICES[int(code) & 0xf]
curr_vertices = vertices[i:i+num_vertices].flatten()
yield curr_vertices, code
i += num_vertices
def iter_segments(self,
transform=None,
remove_nans=True,
clip=None,
snap=False,
stroke_width=1.0,
simplify=None,
curves=True,
sketch=None):
"""
Iterates over all of the curve segments in the path. Each
iteration returns a 2-tuple (*vertices*, *code*), where
*vertices* is a sequence of 1 - 3 coordinate pairs, and *code* is
one of the :class:`Path` codes.
Additionally, this method can provide a number of standard
cleanups and conversions to the path.
*transform*: if not None, the given affine transformation will
be applied to the path.
*remove_nans*: if True, will remove all NaNs from the path and
insert MOVETO commands to skip over them.
*clip*: if not None, must be a four-tuple (x1, y1, x2, y2)
defining a rectangle in which to clip the path.
*snap*: if None, auto-snap to pixels, to reduce
fuzziness of rectilinear lines. If True, force snapping, and
if False, don't snap.
*stroke_width*: the width of the stroke being drawn. Needed
as a hint for the snapping algorithm.
*simplify*: if True, perform simplification, to remove
vertices that do not affect the appearance of the path. If
False, perform no simplification. If None, use the
should_simplify member variable.
*curves*: If True, curve segments will be returned as curve
segments. If False, all curves will be converted to line
segments.
*sketch*: If not None, must be a 3-tuple of the form
(scale, length, randomness), representing the sketch
parameters.
"""
vertices = self.vertices
if not len(vertices):
return
codes = self.codes
NUM_VERTICES = self.NUM_VERTICES
MOVETO = self.MOVETO
LINETO = self.LINETO
CLOSEPOLY = self.CLOSEPOLY
STOP = self.STOP
vertices, codes = cleanup_path(self, transform, remove_nans, clip,
snap, stroke_width, simplify, curves,
sketch)
len_vertices = len(vertices)
i = 0
while i < len_vertices:
code = codes[i]
if code == STOP:
return
else:
num_vertices = NUM_VERTICES[int(code) & 0xf]
curr_vertices = vertices[i:i + num_vertices].flatten()
yield curr_vertices, code
i += num_vertices
def iter_segments(self, transform=None, remove_nans=True, clip=None,
snap=False, stroke_width=1.0, simplify=None,
curves=True, sketch=None):
"""
Iterates over all of the curve segments in the path. Each
iteration returns a 2-tuple (*vertices*, *code*), where
*vertices* is a sequence of 1 - 3 coordinate pairs, and *code* is
one of the :class:`Path` codes.
Additionally, this method can provide a number of standard
cleanups and conversions to the path.
*transform*: if not None, the given affine transformation will
be applied to the path.
*remove_nans*: if True, will remove all NaNs from the path and
insert MOVETO commands to skip over them.
*clip*: if not None, must be a four-tuple (x1, y1, x2, y2)
defining a rectangle in which to clip the path.
*snap*: if None, auto-snap to pixels, to reduce
fuzziness of rectilinear lines. If True, force snapping, and
if False, don't snap.
*stroke_width*: the width of the stroke being drawn. Needed
as a hint for the snapping algorithm.
*simplify*: if True, perform simplification, to remove
vertices that do not affect the appearance of the path. If
False, perform no simplification. If None, use the
should_simplify member variable.
*curves*: If True, curve segments will be returned as curve
segments. If False, all curves will be converted to line
segments.
*sketch*: If not None, must be a 3-tuple of the form
(scale, length, randomness), representing the sketch
parameters.
"""
vertices = self.vertices
if not len(vertices):
return
codes = self.codes
NUM_VERTICES = self.NUM_VERTICES
MOVETO = self.MOVETO
LINETO = self.LINETO
CLOSEPOLY = self.CLOSEPOLY
STOP = self.STOP
vertices, codes = cleanup_path(self, transform, remove_nans, clip,
snap, stroke_width, simplify, curves,
sketch)
len_vertices = len(vertices)
i = 0
while i < len_vertices:
code = codes[i]
if code == STOP:
return
else:
num_vertices = NUM_VERTICES[int(code) & 0xf]
curr_vertices = vertices[i:i+num_vertices].flatten()
yield curr_vertices, code
i += num_vertices