Thread: SF.net SVN: matplotlib: [3993] branches/transforms/src

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 3993
          http://matplotlib.svn.sourceforge.net/matplotlib/?rev=3993&view=rev
Author:   mdboom
Date:     2007-10-24 10:11:00 -0700 (Wed, 24 Oct 2007)

Log Message:
-----------
Forgot to svn add these files in last commit.

Added Paths:
-----------
    branches/transforms/src/_path.cpp
    branches/transforms/src/agg_py_transforms.h

Added: branches/transforms/src/_path.cpp
===================================================================

--- branches/transforms/src/_path.cpp	                        (rev 0)
+++ branches/transforms/src/_path.cpp	2007-10-24 17:11:00 UTC (rev 3993)
@@ -0,0 +1,384 @@
+#include "agg_py_path_iterator.h"
+#include "agg_py_transforms.h"
+
+#include "CXX/Extensions.hxx"
+
+#include "agg_conv_curve.h"
+#include "agg_conv_stroke.h"
+#include "agg_conv_transform.h"
+#include "agg_path_storage.h"
+#include "agg_trans_affine.h"
+
+// the extension module
+class _path_module : public Py::ExtensionModule<_path_module>
+{
+public:
+  _path_module()
+    : Py::ExtensionModule<_path_module>( "_path" )
+  {
+    add_varargs_method("point_in_path", &_path_module::point_in_path,
+		       "point_in_path(x, y, path, trans)");
+    add_varargs_method("point_on_path", &_path_module::point_on_path,
+		       "point_on_path(x, y, r, path, trans)");
+    add_varargs_method("get_path_extents", &_path_module::get_path_extents,
+		       "get_path_extents(path, trans)");
+    add_varargs_method("get_path_collection_extents", &_path_module::get_path_collection_extents,
+		       "get_path_collection_extents(trans, paths, transforms, offsets, offsetTrans)");
+    add_varargs_method("point_in_path_collection", &_path_module::point_in_path_collection,
+		       "point_in_path_collection(x, y, r, trans, paths, transforms, offsets, offsetTrans, filled)");
+
+    initialize("Helper functions for paths");
+  }
+
+  virtual ~_path_module() {}
+
+private:
+
+  Py::Object point_in_path(const Py::Tuple& args);
+  Py::Object point_on_path(const Py::Tuple& args);
+  Py::Object get_path_extents(const Py::Tuple& args);
+  Py::Object get_path_collection_extents(const Py::Tuple& args);
+  Py::Object point_in_path_collection(const Py::Tuple& args);
+};
+
+//
+// The following function was found in the Agg 2.3 examples (interactive_polygon.cpp).
+// It has been generalized to work on (possibly curved) polylines, rather than
+// just polygons.  The original comments have been kept intact.
+//  -- Michael Droettboom 2007-10-02
+//
+//======= Crossings Multiply algorithm of InsideTest ======================== 
+//
+// By Eric Haines, 3D/Eye Inc, er...@ey...
+//
+// This version is usually somewhat faster than the original published in
+// Graphics Gems IV; by turning the division for testing the X axis crossing
+// into a tricky multiplication test this part of the test became faster,
+// which had the additional effect of making the test for "both to left or
+// both to right" a bit slower for triangles than simply computing the
+// intersection each time.  The main increase is in triangle testing speed,
+// which was about 15% faster; all other polygon complexities were pretty much
+// the same as before.  On machines where division is very expensive (not the
+// case on the HP 9000 series on which I tested) this test should be much
+// faster overall than the old code.  Your mileage may (in fact, will) vary,
+// depending on the machine and the test data, but in general I believe this
+// code is both shorter and faster.  This test was inspired by unpublished
+// Graphics Gems submitted by Joseph Samosky and Mark Haigh-Hutchinson.
+// Related work by Samosky is in:
+//
+// Samosky, Joseph, "SectionView: A system for interactively specifying and
+// visualizing sections through three-dimensional medical image data",
+// M.S. Thesis, Department of Electrical Engineering and Computer Science,
+// Massachusetts Institute of Technology, 1993.
+//
+// Shoot a test ray along +X axis.  The strategy is to compare vertex Y values
+// to the testing point's Y and quickly discard edges which are entirely to one
+// side of the test ray.  Note that CONVEX and WINDING code can be added as
+// for the CrossingsTest() code; it is left out here for clarity.
+//
+// Input 2D polygon _pgon_ with _numverts_ number of vertices and test point
+// _point_, returns 1 if inside, 0 if outside.
+template<class T>
+bool point_in_path_impl(double tx, double ty, T& path) {
+  int yflag0, yflag1, inside_flag;
+  double vtx0, vty0, vtx1, vty1, sx, sy;
+  double x, y;
+
+  path.rewind(0);
+  unsigned code = path.vertex(&x, &y);
+  if (code == agg::path_cmd_stop)
+    return false;
+
+  while (true) {
+    sx = vtx0 = x;
+    sy = vty0 = y;
+
+    // get test bit for above/below X axis
+    yflag0 = (vty0 >= ty);
+
+    vtx1 = x;
+    vty1 = x;
+
+    inside_flag = 0;
+    while (true) {
+      code = path.vertex(&x, &y);
+
+      // The following cases denote the beginning on a new subpath
+      if ((code & agg::path_cmd_end_poly) == agg::path_cmd_end_poly) {
+	x = sx; y = sy;
+      } else if (code == agg::path_cmd_move_to)
+	break;
+      
+      yflag1 = (vty1 >= ty);
+      // Check if endpoints straddle (are on opposite sides) of X axis
+      // (i.e. the Y's differ); if so, +X ray could intersect this edge.
+      // The old test also checked whether the endpoints are both to the
+      // right or to the left of the test point.  However, given the faster
+      // intersection point computation used below, this test was found to
+      // be a break-even proposition for most polygons and a loser for
+      // triangles (where 50% or more of the edges which survive this test
+      // will cross quadrants and so have to have the X intersection computed
+      // anyway).  I credit Joseph Samosky with inspiring me to try dropping
+      // the "both left or both right" part of my code.
+      if (yflag0 != yflag1) {
+	// Check intersection of pgon segment with +X ray.
+	// Note if >= point's X; if so, the ray hits it.
+	// The division operation is avoided for the ">=" test by checking
+	// the sign of the first vertex wrto the test point; idea inspired
+	// by Joseph Samosky's and Mark Haigh-Hutchinson's different
+	// polygon inclusion tests.
+	if ( ((vty1-ty) * (vtx0-vtx1) >=
+	      (vtx1-tx) * (vty0-vty1)) == yflag1 ) {
+	  inside_flag ^= 1;
+	}
+      }
+
+      // Move to the next pair of vertices, retaining info as possible.
+      yflag0 = yflag1;
+      vtx0 = vtx1;
+      vty0 = vty1;
+	
+      vtx1 = x;
+      vty1 = y;
+
+      if (code == agg::path_cmd_stop || 
+	  (code & agg::path_cmd_end_poly) == agg::path_cmd_end_poly)
+	break;
+    }
+
+    if (inside_flag != 0)
+      return true;
+
+    if (code == agg::path_cmd_stop)
+      return false;
+  }
+
+  return false;
+}
+
+bool point_in_path(double x, double y, PathIterator& path, agg::trans_affine& trans) {
+  typedef agg::conv_transform<PathIterator> transformed_path_t;
+  typedef agg::conv_curve<transformed_path_t> curve_t;
+  
+  transformed_path_t trans_path(path, trans);
+  curve_t curved_path(trans_path);
+  return point_in_path_impl(x, y, curved_path);
+}
+
+bool point_on_path(double x, double y, double r, PathIterator& path, agg::trans_affine& trans) {
+  typedef agg::conv_transform<PathIterator> transformed_path_t;
+  typedef agg::conv_curve<transformed_path_t> curve_t;
+  typedef agg::conv_stroke<curve_t> stroke_t;
+
+  transformed_path_t trans_path(path, trans);
+  curve_t curved_path(trans_path);
+  stroke_t stroked_path(curved_path);
+  stroked_path.width(r * 2.0);
+  return point_in_path_impl(x, y, stroked_path);
+}
+
+Py::Object _path_module::point_in_path(const Py::Tuple& args) {
+  args.verify_length(4);
+  
+  double x = Py::Float(args[0]);
+  double y = Py::Float(args[1]);
+  PathIterator path(args[2]);
+  agg::trans_affine trans = py_to_agg_transformation_matrix(args[3]);
+
+  if (::point_in_path(x, y, path, trans))
+    return Py::Int(1);
+  return Py::Int(0);
+}
+
+Py::Object _path_module::point_on_path(const Py::Tuple& args) {
+  args.verify_length(5);
+  
+  double x = Py::Float(args[0]);
+  double y = Py::Float(args[1]);
+  double r = Py::Float(args[2]);
+  PathIterator path(args[3]);
+  agg::trans_affine trans = py_to_agg_transformation_matrix(args[4]);
+
+  if (::point_on_path(x, y, r, path, trans))
+    return Py::Int(1);
+  return Py::Int(0);
+}
+
+void get_path_extents(PathIterator& path, agg::trans_affine& trans, 
+		      double* x0, double* y0, double* x1, double* y1) {
+  typedef agg::conv_transform<PathIterator> transformed_path_t;
+  typedef agg::conv_curve<transformed_path_t> curve_t;
+  double x, y;
+  unsigned code;
+
+  transformed_path_t tpath(path, trans);
+  curve_t curved_path(tpath);
+
+  curved_path.rewind(0);
+
+  while ((code = curved_path.vertex(&x, &y)) != agg::path_cmd_stop) {
+    if ((code & agg::path_cmd_end_poly) == agg::path_cmd_end_poly)
+      continue;
+    if (x < *x0) *x0 = x;
+    if (y < *y0) *y0 = y;
+    if (x > *x1) *x1 = x;
+    if (y > *y1) *y1 = y;
+  }
+}
+
+Py::Object _path_module::get_path_extents(const Py::Tuple& args) {
+  args.verify_length(2);
+  
+  PathIterator path(args[0]);
+  agg::trans_affine trans = py_to_agg_transformation_matrix(args[1]);
+
+  double x0 =  std::numeric_limits<double>::infinity();
+  double y0 =  std::numeric_limits<double>::infinity();
+  double x1 = -std::numeric_limits<double>::infinity();
+  double y1 = -std::numeric_limits<double>::infinity();
+
+  ::get_path_extents(path, trans, &x0, &y0, &x1, &y1);
+
+  Py::Tuple result(4);
+  result[0] = Py::Float(x0);
+  result[1] = Py::Float(y0);
+  result[2] = Py::Float(x1);
+  result[3] = Py::Float(y1);
+  return result;
+}
+
+Py::Object _path_module::get_path_collection_extents(const Py::Tuple& args) {
+  args.verify_length(5);
+
+  //segments, trans, clipbox, colors, linewidths, antialiaseds
+  agg::trans_affine	  master_transform = py_to_agg_transformation_matrix(args[0]);
+  Py::SeqBase<Py::Object> paths		   = args[1];
+  Py::SeqBase<Py::Object> transforms_obj   = args[2];
+  Py::Object              offsets_obj      = args[3];
+  agg::trans_affine       offset_trans     = py_to_agg_transformation_matrix(args[4], false);
+
+  PyArrayObject* offsets = NULL;
+  double x0, y0, x1, y1;
+
+  try {
+    offsets = (PyArrayObject*)PyArray_FromObject(offsets_obj.ptr(), PyArray_DOUBLE, 2, 2);
+    if (!offsets || offsets->dimensions[1] != 2)
+      throw Py::ValueError("Offsets array must be Nx2");
+
+    size_t Npaths      = paths.length();
+    size_t Noffsets    = offsets->dimensions[0];
+    size_t N	       = std::max(Npaths, Noffsets);
+    size_t Ntransforms = std::min(transforms_obj.length(), N);
+    size_t i;
+
+    // Convert all of the transforms up front
+    typedef std::vector<agg::trans_affine> transforms_t;
+    transforms_t transforms;
+    transforms.reserve(Ntransforms);
+    for (i = 0; i < Ntransforms; ++i) {
+      agg::trans_affine trans = py_to_agg_transformation_matrix
+	(transforms_obj[i], false);
+      trans *= master_transform;
+      transforms.push_back(trans);
+    }
+    
+    // The offset each of those and collect the mins/maxs
+    x0 = std::numeric_limits<double>::infinity();
+    y0 = std::numeric_limits<double>::infinity();
+    x1 = -std::numeric_limits<double>::infinity();
+    y1 = -std::numeric_limits<double>::infinity();
+    for (i = 0; i < N; ++i) {
+      PathIterator path(paths[i % Npaths]);
+      
+      double xo                = *(double*)PyArray_GETPTR2(offsets, i % Noffsets, 0);
+      double yo                = *(double*)PyArray_GETPTR2(offsets, i % Noffsets, 1);
+      offset_trans.transform(&xo, &yo);
+      agg::trans_affine_translation transOffset(xo, yo);
+      agg::trans_affine trans = transforms[i % Ntransforms];
+      trans *= transOffset;
+
+      ::get_path_extents(path, trans, &x0, &y0, &x1, &y1);
+    }
+  } catch (...) {
+    Py_XDECREF(offsets);
+    throw;
+  }
+
+  Py_XDECREF(offsets);
+
+  Py::Tuple result(4);
+  result[0] = Py::Float(x0);
+  result[1] = Py::Float(y0);
+  result[2] = Py::Float(x1);
+  result[3] = Py::Float(y1);
+  return result;
+}
+
+Py::Object _path_module::point_in_path_collection(const Py::Tuple& args) {
+  args.verify_length(9);
+
+  //segments, trans, clipbox, colors, linewidths, antialiaseds
+  double		  x		   = Py::Float(args[0]);
+  double		  y		   = Py::Float(args[1]);
+  double                  radius           = Py::Float(args[2]);
+  agg::trans_affine	  master_transform = py_to_agg_transformation_matrix(args[3]);
+  Py::SeqBase<Py::Object> paths		   = args[4];
+  Py::SeqBase<Py::Object> transforms_obj   = args[5];
+  Py::SeqBase<Py::Object> offsets_obj      = args[6];
+  agg::trans_affine       offset_trans     = py_to_agg_transformation_matrix(args[7]);
+  bool                    filled           = Py::Int(args[8]);
+  
+  PyArrayObject* offsets = (PyArrayObject*)PyArray_FromObject(offsets_obj.ptr(), PyArray_DOUBLE, 2, 2);
+  if (!offsets || offsets->dimensions[1] != 2)
+    throw Py::ValueError("Offsets array must be Nx2");
+
+  size_t Npaths	     = paths.length();
+  size_t Noffsets    = offsets->dimensions[0];
+  size_t N	     = std::max(Npaths, Noffsets);
+  size_t Ntransforms = std::min(transforms_obj.length(), N);
+  size_t i;
+
+  // Convert all of the transforms up front
+  typedef std::vector<agg::trans_affine> transforms_t;
+  transforms_t transforms;
+  transforms.reserve(Ntransforms);
+  for (i = 0; i < Ntransforms; ++i) {
+    agg::trans_affine trans = py_to_agg_transformation_matrix
+      (transforms_obj[i], false);
+    trans *= master_transform;
+    transforms.push_back(trans);
+  }
+
+  Py::List result;
+
+  for (i = 0; i < N; ++i) {
+    PathIterator path(paths[i % Npaths]);
+    
+    double xo = *(double*)PyArray_GETPTR2(offsets, i % Noffsets, 0);
+    double yo = *(double*)PyArray_GETPTR2(offsets, i % Noffsets, 1);
+    offset_trans.transform(&xo, &yo);
+    agg::trans_affine_translation transOffset(xo, yo);
+    agg::trans_affine trans = transforms[i % Ntransforms];
+    trans *= transOffset;
+
+    if (filled) {
+      if (::point_in_path(x, y, path, trans))
+	result.append(Py::Int((int)i));
+    } else {
+      if (::point_on_path(x, y, radius, path, trans))
+	result.append(Py::Int((int)i));
+    }
+  }
+
+  return result;
+}
+
+extern "C"
+DL_EXPORT(void)
+  init_path(void)
+{
+  import_array();
+  
+  static _path_module* _path = NULL;
+  _path = new _path_module;
+};

Added: branches/transforms/src/agg_py_transforms.h
===================================================================
--- branches/transforms/src/agg_py_transforms.h	                        (rev 0)
+++ branches/transforms/src/agg_py_transforms.h	2007-10-24 17:11:00 UTC (rev 3993)
@@ -0,0 +1,58 @@
+#ifndef __AGG_PY_TRANSFORMS_H__
+#define __AGG_PY_TRANSFORMS_H__
+
+#define PY_ARRAY_TYPES_PREFIX NumPy
+#include "numpy/arrayobject.h"
+
+#include "CXX/Objects.hxx"
+#include "agg_trans_affine.h"
+
+
+/** A helper function to convert from a Numpy affine transformation matrix
+ *  to an agg::trans_affine.
+ */
+agg::trans_affine py_to_agg_transformation_matrix(const Py::Object& obj, bool errors = true) {
+  PyArrayObject* matrix = NULL;
+  
+  try {
+    if (obj.ptr() == Py_None)
+      throw std::exception();
+    matrix = (PyArrayObject*) PyArray_FromObject(obj.ptr(), PyArray_DOUBLE, 2, 2);
+    if (!matrix)
+      throw std::exception();
+    if (matrix->nd == 2 || matrix->dimensions[0] == 3 || matrix->dimensions[1] == 3) {
+      size_t stride0 = matrix->strides[0];
+      size_t stride1 = matrix->strides[1];
+      char* row0 = matrix->data;
+      char* row1 = row0 + stride0;
+      
+      double a = *(double*)(row0);
+      row0 += stride1;
+      double c = *(double*)(row0);
+      row0 += stride1;
+      double e = *(double*)(row0);
+      
+      double b = *(double*)(row1);
+      row1 += stride1;
+      double d = *(double*)(row1);
+      row1 += stride1;
+      double f = *(double*)(row1);
+      
+      Py_XDECREF(matrix);
+      
+      return agg::trans_affine(a, b, c, d, e, f);
+    }
+
+    throw std::exception();
+  } catch (...) {
+    if (errors) {
+      Py_XDECREF(matrix);
+      throw Py::TypeError("Invalid affine transformation matrix");
+    }
+  }
+
+  Py_XDECREF(matrix);
+  return agg::trans_affine();
+}
+
+#endif // __AGG_PY_TRANSFORMS_H__


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




Thread: SF.net SVN: matplotlib: [3993] branches/transforms/src

matplotlib-checkins