From: <md...@us...> - 2010-06-15 19:10:26
|
Revision: 8437 http://matplotlib.svn.sourceforge.net/matplotlib/?rev=8437&view=rev Author: mdboom Date: 2010-06-15 19:10:19 +0000 (Tue, 15 Jun 2010) Log Message: ----------- Use the word "snapping" everywhere for consistency. This is the word used in the outward-facing interface all along. Modified Paths: -------------- trunk/matplotlib/lib/matplotlib/path.py trunk/matplotlib/src/_backend_agg.cpp trunk/matplotlib/src/_backend_agg.h trunk/matplotlib/src/_macosx.m trunk/matplotlib/src/_path.cpp trunk/matplotlib/src/path_cleanup.cpp trunk/matplotlib/src/path_cleanup.h trunk/matplotlib/src/path_converters.h Modified: trunk/matplotlib/lib/matplotlib/path.py =================================================================== --- trunk/matplotlib/lib/matplotlib/path.py 2010-06-15 13:01:22 UTC (rev 8436) +++ trunk/matplotlib/lib/matplotlib/path.py 2010-06-15 19:10:19 UTC (rev 8437) @@ -188,7 +188,7 @@ return len(self.vertices) def iter_segments(self, transform=None, remove_nans=True, clip=None, - quantize=False, stroke_width=1.0, simplify=None, + snap=False, stroke_width=1.0, simplify=None, curves=True): """ Iterates over all of the curve segments in the path. Each @@ -208,11 +208,12 @@ *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. + *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 quantizer. + 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 @@ -236,7 +237,7 @@ STOP = self.STOP vertices, codes = cleanup_path(self, transform, remove_nans, clip, - quantize, stroke_width, simplify, curves) + snap, stroke_width, simplify, curves) len_vertices = len(vertices) i = 0 Modified: trunk/matplotlib/src/_backend_agg.cpp =================================================================== --- trunk/matplotlib/src/_backend_agg.cpp 2010-06-15 13:01:22 UTC (rev 8436) +++ trunk/matplotlib/src/_backend_agg.cpp 2010-06-15 19:10:19 UTC (rev 8437) @@ -270,11 +270,11 @@ Py::Callable method(method_obj); Py::Object py_snap = method.apply(Py::Tuple()); if (py_snap.isNone()) { - quantize_mode = QUANTIZE_AUTO; + snap_mode = SNAP_AUTO; } else if (py_snap.isTrue()) { - quantize_mode = QUANTIZE_TRUE; + snap_mode = SNAP_TRUE; } else { - quantize_mode = QUANTIZE_FALSE; + snap_mode = SNAP_FALSE; } } @@ -506,8 +506,8 @@ Py::Object RendererAgg::draw_markers(const Py::Tuple& args) { typedef agg::conv_transform<PathIterator> transformed_path_t; - typedef PathQuantizer<transformed_path_t> quantize_t; - typedef agg::conv_curve<quantize_t> curve_t; + typedef PathSnapper<transformed_path_t> snap_t; + typedef agg::conv_curve<snap_t> curve_t; typedef agg::conv_stroke<curve_t> stroke_t; typedef agg::pixfmt_amask_adaptor<pixfmt, alpha_mask_type> pixfmt_amask_type; typedef agg::renderer_base<pixfmt_amask_type> amask_ren_type; @@ -533,19 +533,19 @@ PathIterator marker_path(marker_path_obj); transformed_path_t marker_path_transformed(marker_path, marker_trans); - quantize_t marker_path_quantized(marker_path_transformed, - gc.quantize_mode, - marker_path.total_vertices(), - gc.linewidth); - curve_t marker_path_curve(marker_path_quantized); + snap_t marker_path_snapped(marker_path_transformed, + gc.snap_mode, + marker_path.total_vertices(), + gc.linewidth); + curve_t marker_path_curve(marker_path_snapped); PathIterator path(path_obj); transformed_path_t path_transformed(path, trans); - quantize_t path_quantized(path_transformed, - gc.quantize_mode, - path.total_vertices(), - 1.0); - curve_t path_curve(path_quantized); + snap_t path_snapped(path_transformed, + gc.snap_mode, + path.total_vertices(), + 1.0); + curve_t path_curve(path_snapped); path_curve.rewind(0); facepair_t face = _get_rgba_face(face_obj, gc.alpha); @@ -1079,8 +1079,8 @@ typedef agg::conv_transform<PathIterator> transformed_path_t; typedef PathNanRemover<transformed_path_t> nan_removed_t; typedef PathClipper<nan_removed_t> clipped_t; - typedef PathQuantizer<clipped_t> quantized_t; - typedef PathSimplifier<quantized_t> simplify_t; + typedef PathSnapper<clipped_t> snapped_t; + typedef PathSimplifier<snapped_t> simplify_t; typedef agg::conv_curve<simplify_t> curve_t; _VERBOSE("RendererAgg::draw_path"); @@ -1108,8 +1108,8 @@ transformed_path_t tpath(path, trans); nan_removed_t nan_removed(tpath, true, path.has_curves()); clipped_t clipped(nan_removed, clip, width, height); - quantized_t quantized(clipped, gc.quantize_mode, path.total_vertices(), gc.linewidth); - simplify_t simplified(quantized, simplify, path.simplify_threshold()); + snapped_t snapped(clipped, gc.snap_mode, path.total_vertices(), gc.linewidth); + simplify_t simplified(snapped, simplify, path.simplify_threshold()); curve_t curve(simplified); try { @@ -1141,8 +1141,8 @@ typedef agg::conv_transform<typename PathGenerator::path_iterator> transformed_path_t; typedef PathNanRemover<transformed_path_t> nan_removed_t; typedef PathClipper<nan_removed_t> clipped_t; - typedef PathQuantizer<clipped_t> quantized_t; - typedef agg::conv_curve<quantized_t> quantized_curve_t; + typedef PathSnapper<clipped_t> snapped_t; + typedef agg::conv_curve<snapped_t> snapped_curve_t; typedef agg::conv_curve<clipped_t> curve_t; PyArrayObject* offsets = NULL; @@ -1275,13 +1275,13 @@ transformed_path_t tpath(path, trans); nan_removed_t nan_removed(tpath, true, has_curves); clipped_t clipped(nan_removed, do_clip, width, height); - quantized_t quantized(clipped, gc.quantize_mode, - path.total_vertices(), gc.linewidth); + snapped_t snapped(clipped, gc.snap_mode, + path.total_vertices(), gc.linewidth); if (has_curves) { - quantized_curve_t curve(quantized); + snapped_curve_t curve(snapped); _draw_path(curve, has_clippath, face, gc); } else { - _draw_path(quantized, has_clippath, face, gc); + _draw_path(snapped, has_clippath, face, gc); } } else { gc.isaa = bool(Py::Int(antialiaseds[i % Naa])); Modified: trunk/matplotlib/src/_backend_agg.h =================================================================== --- trunk/matplotlib/src/_backend_agg.h 2010-06-15 13:01:22 UTC (rev 8436) +++ trunk/matplotlib/src/_backend_agg.h 2010-06-15 19:10:19 UTC (rev 8437) @@ -123,7 +123,7 @@ typedef std::vector<std::pair<double, double> > dash_t; double dashOffset; dash_t dashes; - e_quantize_mode quantize_mode; + e_snap_mode snap_mode; Py::Object hatchpath; Modified: trunk/matplotlib/src/_macosx.m =================================================================== --- trunk/matplotlib/src/_macosx.m 2010-06-15 13:01:22 UTC (rev 8436) +++ trunk/matplotlib/src/_macosx.m 2010-06-15 19:10:19 UTC (rev 8437) @@ -288,7 +288,7 @@ 0, 0, rect, - QUANTIZE_FALSE, + SNAP_FALSE, 1.0, 0); Py_DECREF(transform); @@ -446,13 +446,13 @@ return p; } -static int _get_snap(GraphicsContext* self, enum e_quantize_mode* mode) +static int _get_snap(GraphicsContext* self, enum e_snap_mode* mode) { PyObject* snap = PyObject_CallMethod((PyObject*)self, "get_snap", ""); if(!snap) return 0; - if(snap==Py_None) *mode = QUANTIZE_AUTO; - else if (PyBool_Check(snap)) *mode = QUANTIZE_TRUE; - else *mode = QUANTIZE_FALSE; + if(snap==Py_None) *mode = SNAP_AUTO; + else if (PyBool_Check(snap)) *mode = SNAP_TRUE; + else *mode = SNAP_FALSE; Py_DECREF(snap); return 1; } @@ -662,7 +662,7 @@ 0, 0, rect, - QUANTIZE_AUTO, + SNAP_AUTO, 1.0, 0); Py_DECREF(transform); @@ -892,7 +892,7 @@ 1, 0, rect, - QUANTIZE_AUTO, + SNAP_AUTO, linewidth, rgbFace == NULL); if (!iterator) @@ -970,7 +970,7 @@ 1, 0, rect, - QUANTIZE_AUTO, + SNAP_AUTO, linewidth, 0); if (!iterator) @@ -1006,7 +1006,7 @@ CGMutablePathRef marker; void* iterator; double rect[4] = {0.0, 0.0, self->size.width, self->size.height}; - enum e_quantize_mode mode; + enum e_snap_mode mode; double xc, yc; unsigned code; @@ -1071,7 +1071,7 @@ 1, 1, rect, - QUANTIZE_TRUE, + SNAP_TRUE, 1.0, 0); if (!iterator) @@ -1225,7 +1225,7 @@ /* --------- Prepare some variables for the path iterator ------------- */ void* iterator; double rect[4] = {0.0, 0.0, self->size.width, self->size.height}; - enum e_quantize_mode mode; + enum e_snap_mode mode; ok = _get_snap(self, &mode); if (!ok) { @@ -1382,7 +1382,7 @@ 0, 0, rect, - QUANTIZE_AUTO, + SNAP_AUTO, 1.0, 0); if (!iterator) @@ -1690,7 +1690,7 @@ 0, 0, rect, - QUANTIZE_AUTO, + SNAP_AUTO, 1.0, 0); if (iterator) @@ -2676,7 +2676,7 @@ 0, 0, rect, - QUANTIZE_AUTO, + SNAP_AUTO, 1.0, 0); if (iterator) Modified: trunk/matplotlib/src/_path.cpp =================================================================== --- trunk/matplotlib/src/_path.cpp 2010-06-15 13:01:22 UTC (rev 8436) +++ trunk/matplotlib/src/_path.cpp 2010-06-15 19:10:19 UTC (rev 8437) @@ -55,7 +55,7 @@ add_varargs_method("convert_path_to_polygons", &_path_module::convert_path_to_polygons, "convert_path_to_polygons(path, trans, width, height)"); add_varargs_method("cleanup_path", &_path_module::cleanup_path, - "cleanup_path(path, trans, remove_nans, clip, quantize, simplify, curves)"); + "cleanup_path(path, trans, remove_nans, clip, snap, simplify, curves)"); initialize("Helper functions for paths"); } @@ -1228,22 +1228,22 @@ void _cleanup_path(PathIterator& path, const agg::trans_affine& trans, bool remove_nans, bool do_clip, const agg::rect_base<double>& rect, - e_quantize_mode quantize_mode, double stroke_width, + e_snap_mode snap_mode, double stroke_width, bool do_simplify, bool return_curves, std::vector<double>& vertices, std::vector<npy_uint8>& codes) { typedef agg::conv_transform<PathIterator> transformed_path_t; typedef PathNanRemover<transformed_path_t> nan_removal_t; typedef PathClipper<nan_removal_t> clipped_t; - typedef PathQuantizer<clipped_t> quantized_t; - typedef PathSimplifier<quantized_t> simplify_t; + typedef PathSnapper<clipped_t> snapped_t; + typedef PathSimplifier<snapped_t> simplify_t; typedef agg::conv_curve<simplify_t> curve_t; transformed_path_t tpath(path, trans); nan_removal_t nan_removed(tpath, remove_nans, path.has_curves()); clipped_t clipped(nan_removed, do_clip, rect); - quantized_t quantized(clipped, quantize_mode, path.total_vertices(), stroke_width); - simplify_t simplified(quantized, do_simplify, path.simplify_threshold()); + snapped_t snapped(clipped, snap_mode, path.total_vertices(), stroke_width); + simplify_t simplified(snapped, do_simplify, path.simplify_threshold()); vertices.reserve(path.total_vertices() * 2); codes.reserve(path.total_vertices()); @@ -1286,19 +1286,19 @@ do_clip = true; } - Py::Object quantize_obj = args[4]; - e_quantize_mode quantize_mode; - if (quantize_obj.isNone()) + Py::Object snap_obj = args[4]; + e_snap_mode snap_mode; + if (snap_obj.isNone()) { - quantize_mode = QUANTIZE_AUTO; + snap_mode = SNAP_AUTO; } - else if (quantize_obj.isTrue()) + else if (snap_obj.isTrue()) { - quantize_mode = QUANTIZE_TRUE; + snap_mode = SNAP_TRUE; } else { - quantize_mode = QUANTIZE_FALSE; + snap_mode = SNAP_FALSE; } double stroke_width = Py::Float(args[5]); @@ -1319,7 +1319,7 @@ std::vector<double> vertices; std::vector<npy_uint8> codes; - _cleanup_path(path, trans, remove_nans, do_clip, clip_rect, quantize_mode, + _cleanup_path(path, trans, remove_nans, do_clip, clip_rect, snap_mode, stroke_width, simplify, return_curves, vertices, codes); npy_intp length = codes.size(); Modified: trunk/matplotlib/src/path_cleanup.cpp =================================================================== --- trunk/matplotlib/src/path_cleanup.cpp 2010-06-15 13:01:22 UTC (rev 8436) +++ trunk/matplotlib/src/path_cleanup.cpp 2010-06-15 19:10:19 UTC (rev 8437) @@ -12,8 +12,8 @@ typedef agg::conv_transform<PathIterator> transformed_path_t; typedef PathNanRemover<transformed_path_t> nan_removal_t; typedef PathClipper<nan_removal_t> clipped_t; - typedef PathQuantizer<clipped_t> quantized_t; - typedef PathSimplifier<quantized_t> simplify_t; + typedef PathSnapper<clipped_t> snapped_t; + typedef PathSimplifier<snapped_t> simplify_t; Py::Object m_path_obj; PathIterator m_path_iter; @@ -21,14 +21,14 @@ transformed_path_t m_transformed; nan_removal_t m_nan_removed; clipped_t m_clipped; - quantized_t m_quantized; + snapped_t m_snapped; simplify_t m_simplify; public: PathCleanupIterator(PyObject* path, agg::trans_affine trans, bool remove_nans, bool do_clip, const agg::rect_base<double>& rect, - e_quantize_mode quantize_mode, double stroke_width, + e_snap_mode snap_mode, double stroke_width, bool do_simplify) : m_path_obj(path, true), m_path_iter(m_path_obj), @@ -36,9 +36,9 @@ m_transformed(m_path_iter, m_transform), m_nan_removed(m_transformed, remove_nans, m_path_iter.has_curves()), m_clipped(m_nan_removed, do_clip, rect), - m_quantized(m_clipped, quantize_mode, m_path_iter.total_vertices(), - stroke_width), - m_simplify(m_quantized, do_simplify && m_path_iter.should_simplify(), + m_snapped(m_clipped, snap_mode, m_path_iter.total_vertices(), + stroke_width), + m_simplify(m_snapped, do_simplify && m_path_iter.should_simplify(), m_path_iter.simplify_threshold()) { Py_INCREF(path); @@ -55,7 +55,7 @@ void* get_path_iterator( PyObject* path, PyObject* trans, int remove_nans, int do_clip, - double rect[4], e_quantize_mode quantize_mode, double stroke_width, + double rect[4], e_snap_mode snap_mode, double stroke_width, int do_simplify) { agg::trans_affine agg_trans = py_to_agg_transformation_matrix(trans, false); @@ -63,7 +63,7 @@ PathCleanupIterator* pipeline = new PathCleanupIterator( path, agg_trans, remove_nans != 0, do_clip != 0, - clip_rect, quantize_mode, stroke_width, do_simplify != 0); + clip_rect, snap_mode, stroke_width, do_simplify != 0); return (void*)pipeline; } Modified: trunk/matplotlib/src/path_cleanup.h =================================================================== --- trunk/matplotlib/src/path_cleanup.h 2010-06-15 13:01:22 UTC (rev 8436) +++ trunk/matplotlib/src/path_cleanup.h 2010-06-15 19:10:19 UTC (rev 8437) @@ -3,17 +3,17 @@ #include <Python.h> -enum e_quantize_mode +enum e_snap_mode { - QUANTIZE_AUTO, - QUANTIZE_FALSE, - QUANTIZE_TRUE + SNAP_AUTO, + SNAP_FALSE, + SNAP_TRUE }; void* get_path_iterator( PyObject* path, PyObject* trans, int remove_nans, int do_clip, - double rect[4], enum e_quantize_mode quantize_mode, double stroke_width, + double rect[4], enum e_snap_mode snap_mode, double stroke_width, int do_simplify); unsigned Modified: trunk/matplotlib/src/path_converters.h =================================================================== --- trunk/matplotlib/src/path_converters.h 2010-06-15 13:01:22 UTC (rev 8436) +++ trunk/matplotlib/src/path_converters.h 2010-06-15 19:10:19 UTC (rev 8437) @@ -26,7 +26,7 @@ Agg where coordinates can not be larger than 24-bit signed integers. - 4. PathQuantizer: Rounds the path to the nearest center-pixels. + 4. PathSnapper: Rounds the path to the nearest center-pixels. This makes rectilinear curves look much better. 5. PathSimplifier: Removes line segments from highly dense paths @@ -361,36 +361,36 @@ }; /************************************************************ - PathQuantizer rounds vertices to their nearest center-pixels. This + PathSnapper rounds vertices to their nearest center-pixels. This makes rectilinear paths (rectangles, horizontal and vertical lines etc.) look much cleaner. */ -enum e_quantize_mode +enum e_snap_mode { - QUANTIZE_AUTO, - QUANTIZE_FALSE, - QUANTIZE_TRUE + SNAP_AUTO, + SNAP_FALSE, + SNAP_TRUE }; template<class VertexSource> -class PathQuantizer +class PathSnapper { private: VertexSource* m_source; - bool m_quantize; - double m_quantize_value; + bool m_snap; + double m_snap_value; - static bool should_quantize(VertexSource& path, - e_quantize_mode quantize_mode, - unsigned total_vertices) { + static bool should_snap(VertexSource& path, + e_snap_mode snap_mode, + unsigned total_vertices) { // If this contains only straight horizontal or vertical lines, it should be - // quantized to the nearest pixels + // snapped to the nearest pixels double x0, y0, x1, y1; unsigned code; - switch (quantize_mode) + switch (snap_mode) { - case QUANTIZE_AUTO: + case SNAP_AUTO: if (total_vertices > 1024) { return false; @@ -420,9 +420,9 @@ } return true; - case QUANTIZE_FALSE: + case SNAP_FALSE: return false; - case QUANTIZE_TRUE: + case SNAP_TRUE: return true; } @@ -431,21 +431,21 @@ public: /* - quantize_mode should be one of: - - QUANTIZE_AUTO: Examine the path to determine if it should be quantized - - QUANTIZE_TRUE: Force quantization - - QUANTIZE_FALSE: No quantization + snap_mode should be one of: + - SNAP_AUTO: Examine the path to determine if it should be snapped + - SNAP_TRUE: Force snapping + - SNAP_FALSE: No snapping */ - PathQuantizer(VertexSource& source, e_quantize_mode quantize_mode, + PathSnapper(VertexSource& source, e_snap_mode snap_mode, unsigned total_vertices=15, double stroke_width=0.0) : m_source(&source) { - m_quantize = should_quantize(source, quantize_mode, total_vertices); + m_snap = should_snap(source, snap_mode, total_vertices); - if (m_quantize) + if (m_snap) { - int odd_even = (int)mpl_round(stroke_width) % 2; - m_quantize_value = (odd_even) ? 0.5 : 0.0; + int is_odd = (int)mpl_round(stroke_width) % 2; + m_snap_value = (is_odd) ? 0.5 : 0.0; } source.rewind(0); @@ -460,17 +460,17 @@ { unsigned code; code = m_source->vertex(x, y); - if (m_quantize && agg::is_vertex(code)) - { - *x = mpl_round(*x) + m_quantize_value; - *y = mpl_round(*y) + m_quantize_value; + if (m_snap && agg::is_vertex(code)) + { + *x = mpl_round(*x) + m_snap_value; + *y = mpl_round(*y) + m_snap_value; } return code; } - inline bool is_quantizing() + inline bool is_snapping() { - return m_quantize; + return m_snap; } }; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |