From 61f3ab8f23f4c924d455757bf3e65f8487521b5a Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 13 Apr 2024 13:57:42 +0200 Subject: Adding upstream version 1.3. Signed-off-by: Daniel Baumann --- src/cython/CMakeLists.txt | 131 +++ src/cython/README.md | 29 + src/cython/_common_decl.pxd | 14 + src/cython/_common_decl.pyx | 12 + src/cython/_cy_affine.pxd | 247 +++++ src/cython/_cy_affine.pyx | 736 +++++++++++++ src/cython/_cy_conicsection.pxd | 50 + src/cython/_cy_conicsection.pyx | 183 ++++ src/cython/_cy_curves.pxd | 421 ++++++++ src/cython/_cy_curves.pyx | 1945 ++++++++++++++++++++++++++++++++++ src/cython/_cy_path.pxd | 124 +++ src/cython/_cy_path.pyx | 457 ++++++++ src/cython/_cy_primitives.pxd | 237 +++++ src/cython/_cy_primitives.pyx | 846 +++++++++++++++ src/cython/_cy_rectangle.pxd | 442 ++++++++ src/cython/_cy_rectangle.pyx | 2202 +++++++++++++++++++++++++++++++++++++++ src/cython/cy2geom.pyx | 71 ++ src/cython/report.md | 237 +++++ src/cython/test-affine.py | 249 +++++ src/cython/test-conicsection.py | 137 +++ src/cython/test-curves.py | 458 ++++++++ src/cython/test-path.py | 218 ++++ src/cython/test-primitives.py | 288 +++++ src/cython/test-rectangle.py | 601 +++++++++++ src/cython/utils.py | 52 + src/cython/wrapped-pyobject.h | 237 +++++ src/cython/wrapper.py | 360 +++++++ 27 files changed, 10984 insertions(+) create mode 100644 src/cython/CMakeLists.txt create mode 100644 src/cython/README.md create mode 100644 src/cython/_common_decl.pxd create mode 100644 src/cython/_common_decl.pyx create mode 100644 src/cython/_cy_affine.pxd create mode 100644 src/cython/_cy_affine.pyx create mode 100644 src/cython/_cy_conicsection.pxd create mode 100644 src/cython/_cy_conicsection.pyx create mode 100644 src/cython/_cy_curves.pxd create mode 100644 src/cython/_cy_curves.pyx create mode 100644 src/cython/_cy_path.pxd create mode 100644 src/cython/_cy_path.pyx create mode 100644 src/cython/_cy_primitives.pxd create mode 100644 src/cython/_cy_primitives.pyx create mode 100644 src/cython/_cy_rectangle.pxd create mode 100644 src/cython/_cy_rectangle.pyx create mode 100644 src/cython/cy2geom.pyx create mode 100644 src/cython/report.md create mode 100644 src/cython/test-affine.py create mode 100644 src/cython/test-conicsection.py create mode 100644 src/cython/test-curves.py create mode 100644 src/cython/test-path.py create mode 100644 src/cython/test-primitives.py create mode 100644 src/cython/test-rectangle.py create mode 100644 src/cython/utils.py create mode 100644 src/cython/wrapped-pyobject.h create mode 100644 src/cython/wrapper.py (limited to 'src/cython') diff --git a/src/cython/CMakeLists.txt b/src/cython/CMakeLists.txt new file mode 100644 index 0000000..9187d35 --- /dev/null +++ b/src/cython/CMakeLists.txt @@ -0,0 +1,131 @@ +#TODO - rewrite to use ALLCAPS? + +OPTION(2GEOM_CYTHON_BINDINGS + "Build a python binding with Cython." + OFF) +OPTION(2GEOM_CYTHON_BUILD_SHARED + "Build cython shared libraries." + ON) +IF(2GEOM_CYTHON_BUILD_SHARED) + SET(LIB_TYPE SHARED) + SET (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -shared") +ELSE(2GEOM_CYTHON_BUILD_SHARED) + SET(LIB_TYPE STATIC) +ENDIF(2GEOM_CYTHON_BUILD_SHARED) + + +IF(2GEOM_CYTHON_BINDINGS) + + include( UseCython ) + + # With CMake, a clean separation can be made between the source tree and the + # build tree. When all source is compiled, as with pure C/C++, the source is + # no-longer needed in the build tree. However, with pure *.py source, the + # source is processed directly. To handle this, we reproduce the availability + # of the source files in the build tree. + #add_custom_target( ReplicatePythonSourceTree ALL ${CMAKE_COMMAND} -P + # ${CMAKE_CURRENT_SOURCE_DIR}/CMakeScripts/ReplicatePythonSourceTree.cmake + # ${CMAKE_CURRENT_BINARY_DIR} + # WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} ) + + #include_directories( ${CYTHON_CMAKE_EXAMPLE_SOURCE_DIR}/include ) + + # Process the CMakeLists.txt in the 'src' and 'bin' directory. + + set_source_files_properties( + _common_decl.pxd + _common_decl.pyx + + _cy_primitives.pxd + _cy_primitives.pyx + + _cy_rectangle.pxd + _cy_rectangle.pyx + + _cy_affine.pxd + _cy_affine.pyx + + _cy_curves.pxd + _cy_curves.pyx + + _cy_path.pxd + _cy_path.pyx + + _cy_conicsection.pxd + _cy_conicsection.pyx + + cy2geom.pyx + + PROPERTIES CYTHON_IS_CXX 1) + + # Multi-file cython modules do not appear to be working at the moment. + cython_add_module( _common_decl _common_decl.pyx) + + + cython_add_module( _cy_primitives _cy_primitives.pyx) + + cython_add_module( _cy_rectangle _cy_rectangle.pyx) + + cython_add_module( _cy_affine _cy_affine.pyx) + + cython_add_module( _cy_curves _cy_curves.pyx) + + cython_add_module( _cy_path _cy_path.pyx) + + #not finished for now + #~ cython_add_module( _cy_shape _cy_shape.pyx) + + cython_add_module( _cy_conicsection _cy_conicsection.pyx) + + target_link_libraries(_cy_primitives + #TODO! linking to static lib2geom.a gives -fPIC error, to compile + #you have to enable building dynamic library in cmake . -i + gsl gslcblas 2geom + ) + target_link_libraries(_cy_rectangle + gsl gslcblas 2geom + ) + + target_link_libraries(_cy_affine + gsl gslcblas 2geom + ) + + target_link_libraries(_cy_curves + gsl gslcblas 2geom + ) + + target_link_libraries(_cy_path + gsl gslcblas 2geom + ) + + #~ target_link_libraries(_cy_shape + #~ gsl gslcblas 2geom + #~ ) + + target_link_libraries(_cy_conicsection + gsl gslcblas 2geom + ) + + cython_add_module( cy2geom cy2geom.pyx) + + add_test(cython-primitives python2 test-primitives.py) + add_test(cython-rectangle python2 test-rectangle.py) + add_test(cython-affine python2 test-affine.py) + add_test(cython-curves python2 test-curves.py) + add_test(cython-path python2 test-path.py) + add_test(cython-conicsection python2 test-conicsection.py) + + # stuff to install the cy2geom package in the Python site-packages directory + FIND_PACKAGE(PythonLibs) + IF (WIN32) + GET_FILENAME_COMPONENT(PYTHON_LIB_INSTALL "${PYTHON_LIBRARY}" PATH) + GET_FILENAME_COMPONENT(SITEPACKAGE "${PYTHON_LIB_INSTALL}/../Lib/site-packages" ABSOLUTE) + ELSE (WIN32) + SET(PYTHON_LIB_INSTALL "/usr/local/lib/python2.7/dist-packages" CACHE STRING "Where to install the cy2geom module?") + SET(SITEPACKAGE ${PYTHON_LIB_INSTALL}) + ENDIF(WIN32) + + INSTALL(TARGETS _common_decl _cy_primitives _cy_rectangle _cy_affine _cy_curves _cy_path _cy_conicsection cy2geom + DESTINATION "${SITEPACKAGE}/cy2geom") + +ENDIF(2GEOM_CYTHON_BINDINGS) diff --git a/src/cython/README.md b/src/cython/README.md new file mode 100644 index 0000000..a4a0847 --- /dev/null +++ b/src/cython/README.md @@ -0,0 +1,29 @@ +# Installing: + +In addition to 2geom dependencies, cython bindings need `cython >= 0.16`. + +You can turn them on using cmake. Please note that you need to enable +shared library option as well. + +Building on Windows is not tested yet, should be done shortly. Extrapolating +from other projects using cython, this should not be major problem. + +# Usage: + +Bindings are almost 1-1 to 2geom, so using them is pretty straightforward. +Classes and methods are documented shortly. It's generally good idea to +look at 2geom docs and, if problems persist, at their source. + +To look at simple use cases, I suggest looking at tests and utils.py, located +in cython-bindings directory. + +# Hacking: + +cython is pretty straightforward to pick up, but its docs usually cover only +the simplest example. Looking at source of other project can be helpful +(cython bindings for SFML 2 are good example). + +Don't hesitate to contact me or 2geom mailinglist with any requests concerning +design of bindings and bug reports. + +Jan Pulmann - jan.pulmann@gmail.com diff --git a/src/cython/_common_decl.pxd b/src/cython/_common_decl.pxd new file mode 100644 index 0000000..8877048 --- /dev/null +++ b/src/cython/_common_decl.pxd @@ -0,0 +1,14 @@ +from libcpp.vector cimport vector +from libcpp.pair cimport pair + +ctypedef double Coord +ctypedef int IntCoord + +cdef extern from "2geom/coord.h" namespace "Geom": + cdef Coord EPSILON + cdef enum Dim2: + X = 0 + Y = 1 + +cdef object wrap_vector_double(vector[double] v) +cdef vector[double] make_vector_double(object l) diff --git a/src/cython/_common_decl.pyx b/src/cython/_common_decl.pyx new file mode 100644 index 0000000..1f1544e --- /dev/null +++ b/src/cython/_common_decl.pyx @@ -0,0 +1,12 @@ +cdef object wrap_vector_double(vector[double] v): + r = [] + cdef unsigned int i + for i in range(v.size()): + r.append(v[i]) + return r + +cdef vector[double] make_vector_double(object l): + cdef vector[double] ret + for i in l: + ret.push_back( float(i) ) + return ret diff --git a/src/cython/_cy_affine.pxd b/src/cython/_cy_affine.pxd new file mode 100644 index 0000000..91eb662 --- /dev/null +++ b/src/cython/_cy_affine.pxd @@ -0,0 +1,247 @@ +from _common_decl cimport * + +from _cy_rectangle cimport Rect, cy_Rect, wrap_Rect +from _cy_primitives cimport Point, cy_Point, wrap_Point + + +cdef extern from "2geom/affine.h" namespace "Geom": + cdef cppclass Affine: + + Affine(Affine &) + Affine() + Affine(Coord, Coord, Coord, Coord, Coord, Coord) + + Coord operator[](unsigned int) + + Affine & operator*(Affine &) + Affine & operator*(Translate &) + Affine & operator*(Scale &) + Affine & operator*(Rotate &) + Affine & operator*(HShear &) + Affine & operator*(VShear &) + Affine & operator*(Zoom &) + + bint operator==(Affine &) + bint operator!=(Affine &) + + Point xAxis() + Point yAxis() + Point translation() + Coord expansionX() + Coord expansionY() + Point expansion() + + void setXAxis(Point &) + void setYAxis(Point &) + void setTranslation(Point &) + void setExpansionX(Coord) + void setExpansionY(Coord) + void setIdentity() + + bint isIdentity(Coord) + bint isTranslation(Coord) + bint isScale(Coord) + bint isUniformScale(Coord) + bint isRotation(Coord) + bint isHShear(Coord) + bint isVShear(Coord) + bint isNonzeroTranslation(Coord) + bint isNonzeroScale(Coord) + bint isNonzeroUniformScale(Coord) + bint isNonzeroRotation(Coord) + bint isNonzeroHShear(Coord) + bint isNonzeroVShear(Coord) + bint isZoom(Coord) + bint preservesArea(Coord) + bint preservesAngles(Coord) + bint preservesDistances(Coord) + bint flips() + bint isSingular(Coord) + + Affine withoutTranslation() + Affine inverse() + + Coord det() + Coord descrim2() + Coord descrim() + + bint are_near(Affine &, Affine &, Coord) + Affine a_identity "Geom::Affine::identity" () + +cdef extern from "2geom/transforms.h" namespace "Geom": + Affine reflection(Point &, Point &) + #TODO find out how cython __pow__ works + Affine pow(Affine &, int) + Translate pow(Translate &, int) + Scale pow(Scale &, int) + Rotate pow(Rotate &, int) + HShear pow(HShear &, int) + VShear pow(VShear &, int) + Zoom pow(Zoom &, int) + +cdef class cy_Affine: + cdef Affine* thisptr + +cdef cy_Affine wrap_Affine(Affine) + +#helper functions +cdef Affine get_Affine(t) +cdef bint is_transform(t) + + +cdef extern from "2geom/transforms.h" namespace "Geom": + cdef cppclass Translate: + Translate(Translate &) + Translate() + Translate(Point &) + Translate(Coord, Coord) + Coord operator[](Dim2) + Coord operator[](unsigned int) + Translate & operator*(Translate &) + Affine & operator*(Affine &) + bint operator==(Translate &) + bint operator!=(Translate &) + + Affine operator() + + Point vector() + Translate inverse() + + Translate t_identity "Geom::Translate::identity" () + +cdef class cy_Translate: + cdef Translate* thisptr + + +cdef extern from "2geom/transforms.h" namespace "Geom": + cdef cppclass Scale: + Scale(Scale &) + Scale() + Scale(Point &) + Scale(Coord, Coord) + Scale(Coord) + Coord operator[](Dim2) + Scale & operator*(Scale &) + Affine & operator*(Affine &) + bint operator==(Scale &) + bint operator!=(Scale &) + + Affine operator() + + Point vector() + Scale inverse() + Scale identity() + + Scale s_identity "Geom::Scale::identity" () + +cdef class cy_Scale: + cdef Scale* thisptr + + +cdef extern from "2geom/transforms.h" namespace "Geom": + cdef cppclass Rotate: + Rotate(Rotate &) + Rotate() + Rotate(Coord) + Rotate(Point &) + Rotate(Coord, Coord) + Point vector() + + Coord operator[](Dim2) + Coord operator[](unsigned int) + Rotate & operator*(Rotate &) + Affine & operator*(Affine &) + bint operator==(Rotate &) + bint operator!=(Rotate &) + + Affine operator() + Rotate inverse() + + Rotate r_identity "Geom::Rotate::identity" () + +cdef extern from "2geom/transforms.h" namespace "Geom::Rotate": + Rotate from_degrees(Coord) + + +cdef class cy_Rotate: + cdef Rotate* thisptr + +cdef extern from "2geom/transforms.h" namespace "Geom": + cdef cppclass VShear: + VShear(VShear &) + VShear(Coord) + Coord factor() + void setFactor(Coord) + + VShear &operator*(VShear) + Affine & operator*(Affine &) + bint operator==(VShear &) + bint operator!=(VShear &) + Affine operator() + + VShear inverse() + + VShear vs_identity "Geom::VShear::identity"() + +cdef class cy_VShear: + cdef VShear* thisptr + + +cdef extern from "2geom/transforms.h" namespace "Geom": + cdef cppclass HShear: + HShear(HShear &) + HShear(Coord) + Coord factor() + void setFactor(Coord) + HShear &operator*(HShear) + Affine & operator*(Affine &) + bint operator==(HShear &) + bint operator!=(HShear &) + Affine operator() + + HShear inverse() + + HShear hs_identity "Geom::HShear::identity"() + +cdef class cy_HShear: + cdef HShear* thisptr + + +cdef extern from "2geom/transforms.h" namespace "Geom": + cdef cppclass Zoom: + Zoom(Zoom &) + Zoom(Coord) + Zoom(Translate &) + Zoom(Coord, Translate &) + + Zoom & operator*(Zoom &) + Affine & operator*(Affine &) + bint operator==(Zoom &) + bint operator!=(Zoom &) + + Affine operator() + + Coord scale() + void setScale(Coord) + Point translation() + void setTranslation(Point &) + + Zoom inverse() + + Zoom() + + Zoom z_identity "Geom::Zoom::identity" () + +cdef extern from "2geom/transforms.h" namespace "Geom::Zoom": + Zoom map_rect(Rect &, Rect &) + +cdef class cy_Zoom: + cdef Zoom* thisptr + + +cdef extern from "2geom/affine.h" namespace "Geom": + cdef cppclass Eigen: + Point *vectors + double *values + Eigen(Affine &) + Eigen(double[2][2]) diff --git a/src/cython/_cy_affine.pyx b/src/cython/_cy_affine.pyx new file mode 100644 index 0000000..19aa9ef --- /dev/null +++ b/src/cython/_cy_affine.pyx @@ -0,0 +1,736 @@ +from cython.operator cimport dereference as deref + +from numbers import Number + + +cdef class cy_Affine: + + """Class representing affine transform in 2D plane. + + Corresponds to Affine class in 2geom. + """ + + def __cinit__(self, c0=None, + Coord c1=0, + Coord c2=0, + Coord c3=1, + Coord c4=0, + Coord c5=0): + """Create Affine instance from either transform or from coefficients.""" + if c0 is None: + self.thisptr = new Affine() + elif is_transform(c0): + self.thisptr = new Affine( get_Affine(c0) ) + else: + self.thisptr = new Affine( float(c0) ,c1 ,c2 ,c3 ,c4 ,c5) + + def __str__(self): + """str(self)""" + return "Affine({}, {}, {}, {}, {}, {})".format( self[0], + self[1], + self[2], + self[3], + self[4], + self[5], + ) + def __repr__(self): + """repr(self)""" + return str(self) + + def __dealloc__(self): + del self.thisptr + + def __getitem__(self, int i): + """Get coefficients.""" + if i >= 6: + raise IndexError("Affine has only 6 coefficients.") + return deref(self.thisptr) [i] + + def __mul__(cy_Affine self, other): + """Compose with another transformation.""" + if isinstance(other, cy_Affine): + return wrap_Affine( deref(self.thisptr) * deref( ( other).thisptr ) ) + elif isinstance(other, cy_Translate): + return wrap_Affine( deref(self.thisptr) * deref( ( other).thisptr ) ) + elif isinstance(other, cy_Scale): + return wrap_Affine( deref(self.thisptr) * deref( ( other).thisptr ) ) + elif isinstance(other, cy_Rotate): + return wrap_Affine( deref(self.thisptr) * deref( ( other).thisptr ) ) + elif isinstance(other, cy_HShear): + return wrap_Affine( deref(self.thisptr) * deref( ( other).thisptr ) ) + elif isinstance(other, cy_VShear): + return wrap_Affine( deref(self.thisptr) * deref( ( other).thisptr ) ) + elif isinstance(other, cy_Zoom): + return wrap_Affine( deref(self.thisptr) * deref( ( other).thisptr ) ) + + def __pow__(cy_Affine self, int n, z): + """Compose with self n times.""" + return wrap_Affine(pow( deref(self.thisptr), n )) + + def __richcmp__(cy_Affine self, cy_Affine other, int op): + if op == 2: + return deref(self.thisptr) == deref(other.thisptr) + elif op == 3: + return deref(self.thisptr) != deref(other.thisptr) + + def x_axis(self): + """Transformation of unit x vector without translation.""" + return wrap_Point(self.thisptr.xAxis()) + + def y_axis(self): + """Transformation of unit y vector without translation.""" + return wrap_Point(self.thisptr.yAxis()) + + def translation(self): + """Translation of transformation.""" + return wrap_Point(self.thisptr.translation()) + + def expansion_X(self): + """Expansion of unit x vector.""" + return self.thisptr.expansionX() + + def expansion_Y(self): + """Expansion of unit y vector.""" + return self.thisptr.expansionY() + + def expansion(self): + """Point( self.expansion_X(), self.expansion_Y() )""" + return wrap_Point(self.thisptr.expansion()) + + def set_X_axis(self, cy_Point vec): + """Set transformation of x unit vector without translation.""" + self.thisptr.setXAxis(deref( vec.thisptr )) + + def set_Y_axis(self, cy_Point vec): + """Set transformation of y unit vector without translation.""" + self.thisptr.setYAxis(deref( vec.thisptr )) + + def set_translation(self, cy_Point loc): + """Set translation of origin.""" + self.thisptr.setTranslation(deref( loc.thisptr )) + + def set_expansion_X(self, Coord val): + """Set expansion of x unit vector.""" + self.thisptr.setExpansionX(val) + + def set_expansion_Y(self, Coord val): + """Set expansion of y unit vector.""" + self.thisptr.setExpansionY(val) + + def set_identity(self): + """Set self to identity transformation.""" + self.thisptr.setIdentity() + + def is_identity(self, Coord eps=EPSILON): + """Return true if self is close to identity transform. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isIdentity(eps) + + def is_translation(self, Coord eps=EPSILON): + """Return true if self is close to transformation. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isTranslation(eps) + + def is_scale(self, Coord eps=EPSILON): + """Return true if self is close to scale. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isScale(eps) + + def is_uniform_scale(self, Coord eps=EPSILON): + """Return true if self is close to uniform scale. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isUniformScale(eps) + + def is_rotation(self, Coord eps=EPSILON): + """Return true if self is close to rotation. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isRotation(eps) + + def is_HShear(self, Coord eps=EPSILON): + """Return true if self is close to horizontal shear. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isHShear(eps) + + def is_VShear(self, Coord eps=EPSILON): + """Return true if self is close to vertical shear. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isVShear(eps) + + def is_nonzero_translation(self, Coord eps=EPSILON): + """Return true if self is close to translation and is identity. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isNonzeroTranslation(eps) + + def is_nonzero_scale(self, Coord eps=EPSILON): + """Return true if self is close to scale and is identity. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isNonzeroScale(eps) + + def is_nonzero_uniform_scale(self, Coord eps=EPSILON): + """Return true if self is close to scale and is identity. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isNonzeroUniformScale(eps) + + def is_nonzero_rotation(self, Coord eps=EPSILON): + """Return true if self is close to rotation and is identity. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isNonzeroRotation(eps) + + def is_nonzero_HShear(self, Coord eps=EPSILON): + """Return true if self is close to horizontal shear and is not identity. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isNonzeroHShear(eps) + + def is_nonzero_VShear(self, Coord eps=EPSILON): + """Return true if self is close to vertical shear and is not identity. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isNonzeroVShear(eps) + + def is_zoom(self, Coord eps=EPSILON): + """Return true if self is close to zoom. + + Use second argument eps to specify tolerance. + """ + return self.thisptr.isZoom(eps) + + def preserves_area(self, Coord eps=EPSILON): + """Return true if areas are preserved after transformation + + Use second argument eps to specify tolerance. + """ + return self.thisptr.preservesArea(eps) + + def preserves_angles(self, Coord eps=EPSILON): + """Return true if angles are preserved after transformation + + Use second argument eps to specify tolerance. + """ + return self.thisptr.preservesAngles(eps) + + def preserves_distances(self, Coord eps=EPSILON): + """Return true if distances are preserved after transformation + + Use second argument eps to specify tolerance. + """ + return self.thisptr.preservesDistances(eps) + + def flips(self): + """Return true if transformation flips - it has negative scaling.""" + return self.thisptr.flips() + + def is_singular(self, Coord eps=EPSILON): + """Check whether transformation matrix is singular.""" + return self.thisptr.isSingular(eps) + + def without_translation(self): + """Return transformation without translation part.""" + return wrap_Affine(self.thisptr.withoutTranslation()) + + def inverse(self): + """Return inverse transformation.""" + return wrap_Affine(self.thisptr.inverse()) + + def det(self): + """Return determinant of transformation matrix.""" + return self.thisptr.det() + + def descrim2(self): + """Return absolute value of self.det()""" + return self.thisptr.descrim2() + + def descrim(self): + """Return square root of self.descrim2()""" + return self.thisptr.descrim() + + @classmethod + def identity(self): + """Create identity transformation.""" + return wrap_Affine(a_identity()) + + @classmethod + def are_near(cls, A, B, Coord eps=EPSILON): + """Test if two transforms are near.""" + if is_transform(A) & is_transform(B): + return are_near(get_Affine(A), get_Affine(B), eps) + + @classmethod + def reflection(cls, cy_Point vector, cy_Point origin): + """Create transformation reflecting along line specified by vector and origin.""" + return wrap_Affine( reflection( deref(vector.thisptr), deref(origin.thisptr) ) ) + +cdef cy_Affine wrap_Affine(Affine p): + cdef Affine * retp = new Affine() + retp[0] = p + cdef cy_Affine r = cy_Affine.__new__(cy_Affine) + r.thisptr = retp + return r + +cdef Affine get_Affine(t): + if isinstance(t, cy_Affine ): + return deref( ( t).thisptr ) + elif isinstance(t, cy_Translate): + return deref( ( t).thisptr ) + elif isinstance(t, cy_Scale): + return deref( ( t).thisptr ) + elif isinstance(t, cy_Rotate): + return deref( ( t).thisptr ) + elif isinstance(t, cy_HShear): + return deref( ( t).thisptr ) + elif isinstance(t, cy_VShear): + return deref( ( t).thisptr ) + elif isinstance(t, cy_Zoom): + return deref( ( t).thisptr ) + +cdef bint is_transform(t): + return any([isinstance(t, cy_Affine), + isinstance(t, cy_Translate), + isinstance(t, cy_Scale), + isinstance(t, cy_Rotate), + isinstance(t, cy_HShear), + isinstance(t, cy_VShear), + isinstance(t, cy_Zoom) + ]) + + +cdef class cy_Translate: + + """Translation in 2D plane + + Corresponds to Translate class in 2geom. + """ + + def __cinit__(self, *args): + """Create Translate instance form point or it's two coordinates.""" + if len(args) == 0: + self.thisptr = new Translate() + elif len(args) == 1: + self.thisptr = new Translate( deref( ( args[0]).thisptr ) ) + elif len(args) == 2: + self.thisptr = new Translate(float(args[0]), float(args[1])) + + def __dealloc__(self): + del self.thisptr + + + def __getitem__(self, Dim2 dim): + """Get components of displacement vector.""" + return deref( self.thisptr ) [dim] + + def __mul__(cy_Translate self, o): + """Compose with another transformation.""" + if isinstance(o, cy_Translate): + return wrap_Translate(deref( self.thisptr ) * deref( (o).thisptr )) + elif is_transform(o): + return wrap_Affine(deref(self.thisptr) * get_Affine(o)) + + def __pow__(cy_Translate self, int n, z): + """Compose with self n times.""" + return wrap_Translate(pow( deref(self.thisptr), n )) + + def vector(self): + """Get displacement vector.""" + return wrap_Point(self.thisptr.vector()) + + def inverse(self): + """Return inverse transformation.""" + return wrap_Translate(self.thisptr.inverse()) + + @classmethod + def identity(self): + """Create identity translation.""" + return wrap_Translate(t_identity()) + + def __richcmp__(cy_Translate self, cy_Translate t, op): + if op == 2: + return deref(self.thisptr) == deref(t.thisptr) + elif op == 3: + return deref(self.thisptr) != deref(t.thisptr) + +cdef cy_Translate wrap_Translate(Translate p): + cdef Translate * retp = new Translate() + retp[0] = p + cdef cy_Translate r = cy_Translate.__new__(cy_Translate) + r.thisptr = retp + return r + + +cdef class cy_Scale: + + """Scale in 2D plane. + + Corresponds to Scale in 2geom. + """ + + def __cinit__(self, *args): + """Create scale from number, point or it's two coordinates. + + One number creates uniform scale, point or two numbers create + scale with different x and y scale factor. + """ + if len(args) == 0: + self.thisptr = new Scale() + elif len(args) == 1: + if isinstance(args[0], Number): + self.thisptr = new Scale( float(args[0])) + elif isinstance(args[0], cy_Point): + self.thisptr = new Scale( deref( ( args[0]).thisptr ) ) + elif len(args) == 2: + self.thisptr = new Scale(float(args[0]), float(args[1])) + + def __dealloc__(self): + del self.thisptr + + def __getitem__(self, Dim2 d): + """Get scale factors for each axis.""" + return deref( self.thisptr ) [d] + + def __mul__(cy_Scale self, o): + """Compose with another transformation.""" + if isinstance(o, cy_Scale): + return wrap_Scale(deref( self.thisptr ) * deref( (o).thisptr )) + elif is_transform(o): + return wrap_Affine(deref(self.thisptr) * get_Affine(o)) + + def __pow__(cy_Scale self, int n, z): + """Compose with self n times.""" + return wrap_Scale(pow( deref(self.thisptr), n )) + + def vector(self): + """Get both scale factors as a point.""" + return wrap_Point(self.thisptr.vector()) + + def inverse(self): + """Return inverse transformation.""" + return wrap_Scale(self.thisptr.inverse()) + + @classmethod + def identity(self): + """Create identity scale.""" + return wrap_Scale(s_identity()) + + def __richcmp__(cy_Scale self, cy_Scale s, op): + if op == 2: + return deref(self.thisptr) == deref(s.thisptr) + elif op == 3: + return deref(self.thisptr) != deref(s.thisptr) + +cdef cy_Scale wrap_Scale(Scale p): + cdef Scale * retp = new Scale() + retp[0] = p + cdef cy_Scale r = cy_Scale.__new__(cy_Scale) + r.thisptr = retp + return r + + +cdef class cy_Rotate: + + """Rotation in 2D plane. + + Corresponds to Rotate in 2geom. + """ + + def __cinit__(self, *args): + """Create new Rotate instance, specifying angle. + + Use one number to set the angle, or point/its two coordinates, + using point's angle with x-axis as a rotation angle. + """ + if len(args) == 0: + self.thisptr = new Rotate() + elif len(args) == 1: + if isinstance(args[0], Number): + self.thisptr = new Rotate( float(args[0])) + elif isinstance(args[0], cy_Point): + self.thisptr = new Rotate( deref( ( args[0]).thisptr ) ) + elif len(args) == 2: + self.thisptr = new Rotate(float(args[0]), float(args[1])) + + def __dealloc__(self): + del self.thisptr + + def vector(self): + """Return Point(1, 0)*self.""" + return wrap_Point(self.thisptr.vector()) + + def __getitem__(self, Dim2 dim): + """Get components of self.vector()""" + return deref( self.thisptr ) [dim] + + def __mul__(cy_Rotate self, o): + """Compose with another transformation.""" + if isinstance(o, cy_Rotate): + return wrap_Rotate(deref( self.thisptr ) * deref( (o).thisptr )) + elif is_transform(o): + return wrap_Affine(deref(self.thisptr) * get_Affine(o)) + + def __pow__(cy_Rotate self, int n, z): + """Compose with self n times.""" + return wrap_Rotate(pow( deref(self.thisptr), n )) + + def inverse(self): + """Return inverse transformation.""" + return wrap_Rotate(self.thisptr.inverse()) + + @classmethod + def identity(cls): + """Create identity rotation.""" + return wrap_Rotate(r_identity()) + + @classmethod + def from_degrees(cls, Coord deg): + """Create rotation from angle in degrees.""" + return wrap_Rotate(from_degrees(deg)) + + def __richcmp__(cy_Rotate self, cy_Rotate r, op): + if op == 2: + return deref(self.thisptr) == deref(r.thisptr) + elif op == 3: + return deref(self.thisptr) != deref(r.thisptr) + +cdef cy_Rotate wrap_Rotate(Rotate p): + cdef Rotate * retp = new Rotate() + retp[0] = p + cdef cy_Rotate r = cy_Rotate.__new__(cy_Rotate) + r.thisptr = retp + return r + + +cdef class cy_VShear: + + """Vertical shear in 2D plane + + Corresponds to VShear in 2geom. + """ + + def __cinit__(self, Coord h): + """Create VShear instance form shearing factor.""" + self.thisptr = new VShear(h) + + def __dealloc__(self): + del self.thisptr + + def factor(self): + """Get shearing factor.""" + return self.thisptr.factor() + + def set_factor(self, Coord nf): + """Set shearing factor.""" + self.thisptr.setFactor(nf) + + def __mul__(cy_VShear self, o): + """Compose with another transformation.""" + if isinstance(o, cy_VShear): + return wrap_VShear(deref( self.thisptr ) * deref( (o).thisptr )) + elif is_transform(o): + return wrap_Affine(deref(self.thisptr) * get_Affine(o)) + + def __pow__(cy_VShear self, int n, z): + """Compose with self n times.""" + return wrap_VShear(pow( deref(self.thisptr), n )) + + def inverse(self): + """Return inverse transformation.""" + return wrap_VShear(self.thisptr.inverse()) + + @classmethod + def identity(cls): + """Create identity VShear.""" + return wrap_VShear( vs_identity() ) + + def __richcmp__(cy_VShear self, cy_VShear hs, op): + if op == 2: + return deref(self.thisptr) == deref(hs.thisptr) + elif op == 3: + return deref(self.thisptr) != deref(hs.thisptr) + + + +cdef cy_VShear wrap_VShear(VShear p): + cdef VShear * retp = new VShear(0) + retp[0] = p + cdef cy_VShear r = cy_VShear.__new__(cy_VShear, 0) + r.thisptr = retp + return r + +cdef class cy_HShear: + + """Horizontal shear in 2D plane + + Corresponds to HShear in 2geom. + """ + + def __cinit__(self, Coord h): + """Create HShear instance form shearing factor.""" + self.thisptr = new HShear(h) + + def __dealloc__(self): + del self.thisptr + + def factor(self): + """Get shearing factor.""" + return self.thisptr.factor() + + def set_factor(self, Coord nf): + """Set shearing factor.""" + self.thisptr.setFactor(nf) + + def __mul__(cy_HShear self, o): + """Compose with another transformation.""" + if isinstance(o, cy_HShear): + return wrap_HShear(deref( self.thisptr ) * deref( (o).thisptr )) + elif is_transform(o): + return wrap_Affine(deref(self.thisptr) * get_Affine(o)) + + def __pow__(cy_HShear self, int n, z): + """Compose with self n times.""" + return wrap_HShear(pow( deref(self.thisptr), n )) + + def inverse(self): + """Return inverse transformation.""" + return wrap_HShear(self.thisptr.inverse()) + + @classmethod + def identity(cls): + """Create identity HShear.""" + return wrap_HShear( hs_identity() ) + + def __richcmp__(cy_HShear self, cy_HShear hs, op): + if op == 2: + return deref(self.thisptr) == deref(hs.thisptr) + elif op == 3: + return deref(self.thisptr) != deref(hs.thisptr) + +cdef cy_HShear wrap_HShear(HShear p): + cdef HShear * retp = new HShear(0) + retp[0] = p + cdef cy_HShear r = cy_HShear.__new__(cy_HShear, 0) + r.thisptr = retp + return r + + +cdef class cy_Zoom: + + """Zoom in 2D plane, consisting of uniform scale and translation. + + Corresponds to Zoom in 2geom. + """ + + def __cinit__(self, Coord scale=1, cy_Translate translate=cy_Translate()): + """Create Zoom from scale factor and translation""" + self.thisptr = new Zoom( scale, deref( translate.thisptr ) ) + + def __dealloc__(self): + del self.thisptr + + def __mul__(cy_Zoom self, cy_Zoom z): + """Compose with another transformation.""" + return wrap_Zoom( deref(self.thisptr) * deref( z.thisptr )) + + def __pow__(cy_Zoom self, int n, z): + """Compose with self n times.""" + return wrap_Zoom(pow( deref(self.thisptr), n )) + + def __richcmp__(cy_Zoom self, cy_Zoom z, op): + if op == 2: + return deref(self.thisptr) == deref(z.thisptr) + elif op == 3: + return deref(self.thisptr) != deref(z.thisptr) + + def scale(self): + """Get scale factor.""" + return self.thisptr.scale() + + def set_scale(self, Coord s): + """Set scale factor.""" + self.thisptr.setScale(s) + + def translation(self): + """Get translation as a point.""" + return wrap_Point(self.thisptr.translation()) + + def set_translation(self, cy_Point p): + """Set translation.""" + self.thisptr.setTranslation(deref( p.thisptr )) + + def inverse(self): + """Return inverse transformation.""" + return wrap_Zoom(self.thisptr.inverse()) + + @classmethod + def identity(cls): + """Create identity zoom.""" + return wrap_Zoom(z_identity()) + + @classmethod + def map_rect(self, cy_Rect old_r, cy_Rect new_r): + """Create zooming used to go from old rectangle to new.""" + return wrap_Zoom(map_rect(deref( old_r.thisptr ) ,deref( new_r.thisptr ))) + +cdef cy_Zoom wrap_Zoom(Zoom p): + cdef Zoom * retp = new Zoom(0) + retp[0] = p + cdef cy_Zoom r = cy_Zoom.__new__(cy_Zoom, 0) + r.thisptr = retp + return r + + +cdef class cy_Eigen: + + """Class computing eigenvalues and eigenvectors of 2x2 matrix. + + Corresponds to Eigen class in 2geom. + """ + + cdef Eigen* thisptr + + def __cinit__(self, a): + """Create Eigen form 2D transform or 2x2 list - matrix.""" + cdef Affine at + cdef double m[2][2] + if is_transform(a): + at = get_Affine(a) + self.thisptr = new Eigen(at) + else: + for i in range(2): + for j in range(2): + m[i][j] = a[i][j] + self.thisptr = new Eigen(m) + + def __dealloc__(self): + del self.thisptr + + @property + def vectors(self): + """Eigenvectors of matrix.""" + return (wrap_Point(self.thisptr.vectors[0]), wrap_Point(self.thisptr.vectors[1])) + + @property + def values(self): + """Eigenvalues of matrix.""" + return (self.thisptr.values[0], self.thisptr.values[1]) diff --git a/src/cython/_cy_conicsection.pxd b/src/cython/_cy_conicsection.pxd new file mode 100644 index 0000000..f330cd3 --- /dev/null +++ b/src/cython/_cy_conicsection.pxd @@ -0,0 +1,50 @@ +from _common_decl cimport * + +from libcpp.vector cimport vector +from libcpp.pair cimport pair + +from _cy_rectangle cimport Interval, OptInterval, Rect, OptRect +from _cy_rectangle cimport cy_OptRect +from _cy_affine cimport is_transform, get_Affine, Affine +from _cy_curves cimport Curve, cy_Curve, wrap_Curve_p +from _cy_curves cimport SBasis, cy_SBasis +from _cy_curves cimport EllipticalArc, cy_EllipticalArc, wrap_EllipticalArc + +from _cy_path cimport Path, cy_Path + +from _cy_primitives cimport Point, cy_Point, wrap_Point, wrap_vector_point, make_vector_point + + +cdef extern from "2geom/circle.h" namespace "Geom": + cdef cppclass Circle: + Circle() + Circle(double, double, double) + Circle(Point, double) + Circle(double, double, double, double) + Circle(vector[Point] &) + void setCenter(Point &) + void setRadius(double) + void set(double, double, double, double) + void fit(vector[Point] &) + EllipticalArc * arc(Point &, Point &, Point &, bint) + Point center() + Coord center(Dim2) + Coord radius() + +cdef extern from "2geom/ellipse.h" namespace "Geom": + cdef cppclass Ellipse: + Ellipse() + Ellipse(double, double, double, double, double) + Ellipse(double, double, double, double, double, double) + Ellipse(vector[Point] &) + Ellipse(Circle &) + void set(double, double, double, double, double) + void set(double, double, double, double, double, double) + void set(vector[Point] &) + EllipticalArc * arc(Point &, Point &, Point &, bint) + Point center() + Coord center(Dim2) + Coord ray(Dim2) + Coord rot_angle() + vector[double] implicit_form_coefficients() + Ellipse transformed(Affine &) diff --git a/src/cython/_cy_conicsection.pyx b/src/cython/_cy_conicsection.pyx new file mode 100644 index 0000000..91bbd73 --- /dev/null +++ b/src/cython/_cy_conicsection.pyx @@ -0,0 +1,183 @@ +from cython.operator cimport dereference as deref +from numbers import Number +from _cy_rectangle cimport cy_OptInterval, wrap_OptInterval, wrap_Rect, OptRect, wrap_OptRect +from _cy_rectangle cimport cy_Interval, wrap_Interval + +from _cy_affine cimport cy_Affine, wrap_Affine, get_Affine, is_transform + +from _cy_curves cimport is_Curve, get_Curve_p +from _cy_path cimport wrap_Path + + +cdef class cy_Circle: + + """Circle in 2D plane. + + Corresponds to Circle class in 2geom. + """ + + cdef Circle* thisptr + + def __cinit__(self, cy_Point center=None, double r=0): + """Create circle from center and radius.""" + if center is None: + self.thisptr = new Circle() + else: + self.thisptr = new Circle(deref( center.thisptr ), r) + + @classmethod + def from_coefficients(self, double A, double B, double C, double D): + """Create circle form implicit equation coefficients: + + Implicit equation is Ax**2 + Ay**2 + Bx + Cy + D = 0 + """ + return wrap_Circle( Circle(A, B, C, D) ) + + @classmethod + def from_points(self, points): + """Create best fitting circle from at least three points.""" + return wrap_Circle( Circle( make_vector_point(points) ) ) + + def set_center(self, cy_Point c): + """Set coordinates of center.""" + self.thisptr.setCenter(deref(c.thisptr)) + + def set_radius(self, double r): + """Set the circle's radius.""" + self.thisptr.setRadius(r) + + def set_coefficients(self, double A, double B, double C, double D): + """Set implicit equation coefficients: + + Implicit equation is Ax**2 + Ay**2 + Bx + Cy + D = 0 + """ + self.thisptr.set(A, B, C, D) + + def fit(self, points): + """Set circle to the best fit of at least three points.""" + self.thisptr.fit( make_vector_point(points) ) + + def arc(self, cy_Point initial, cy_Point inner, cy_Point final, bint _svg_compliant=True): + """Get (SVG)EllipticalArc. + + Args: + initial: Initial point of arc + inner: Inner point of arc. + final: Final point of arc. + """ + return wrap_EllipticalArc( deref(self.thisptr.arc(deref( initial.thisptr ), deref( inner.thisptr ), deref( final.thisptr ))) ) + + def center(self): + """Get center of circle in point.""" + return wrap_Point(self.thisptr.center()) + + def radius(self): + """Get radius of circle.""" + return self.thisptr.radius() + +cdef cy_Circle wrap_Circle(Circle p): + cdef Circle * retp = new Circle() + retp[0] = p + cdef cy_Circle r = cy_Circle.__new__(cy_Circle) + r.thisptr = retp + return r + +cdef class cy_Ellipse: + """Ellipse in 2D plane. + + Corresponds to Ellipse class in 2geom. + """ + + cdef Ellipse* thisptr + + def __cinit__(self, cy_Point center=None, rx=0, ry=0, double a=0): + """Create new ellipse: + + Args: + center: Center of ellipse (between foci) + rx, ry: major and minor semi-axis. + a: angle of major axis. + """ + if center is None: + self.thisptr = new Ellipse() + else: + self.thisptr = new Ellipse(center.x, center.y, rx, ry, a) + + @classmethod + def from_coefficients(cls, double A, double B, double C, double D, double E, double F): + """Create ellipse from coefficients of implicit equation. + + Implicit equation has form Ax**2 + Bxy + Cy**2 + Dx + Ey + F = 0 + """ + return wrap_Ellipse(Ellipse(A, B, C, D, E, F)) + + @classmethod + def from_circle(cls, cy_Circle c): + """Create ellipse identical to circle.""" + return wrap_Ellipse(Ellipse(deref( c.thisptr ))) + + @classmethod + def from_points(cls, points): + """Create ellipse fitting at least 5 points.""" + return wrap_Ellipse( Ellipse( make_vector_point(points) ) ) + + def set(self, cy_Point center, double rx, double ry, double a): + """Set center, rays and angle of ellipse. + + Args: + center: Center of ellipse. + rx, ry: Major and minor semi-axis. + a: angle of major axis. + self.thisptr.set(center.x, center.y, rx, ry, a) + """ + + def set_coefficients(self, double A, double B, double C, double D, double E, double F): + """Set coefficients of implicit equation. + + Implicit equation has form Ax**2 + Bxy + Cy**2 + Dx + Ey + F = 0 + """ + self.thisptr.set(A, B, C, D, E, F) + + def set_points(self, points): + """Set ellipse to the best fit of at least five points.""" + self.thisptr.set( make_vector_point(points) ) + + def arc(self, cy_Point initial, cy_Point inner, cy_Point final, bint svg_compliant=True): + """Get (SVG)EllipticalArc. + + Args: + initial: Initial point of arc + inner: Inner point of arc. + final: Final point of arc. + """ + return wrap_EllipticalArc( deref(self.thisptr.arc(deref( initial.thisptr ), deref( inner.thisptr ), deref( final.thisptr ))) ) + + def center(self): + """Get center of ellipse.""" + return wrap_Point(self.thisptr.center()) + + def ray(self, Dim2 d): + """Get major/minor semi-axis.""" + return self.thisptr.ray(d) + + def rot_angle(self): + """Get angle of major axis.""" + return self.thisptr.rot_angle() + + def implicit_form_coefficients(self): + """Get coefficients of implicit equation in list.""" + return wrap_vector_double(self.thisptr.implicit_form_coefficients()) + + def transformed(self, m): + """Return transformed ellipse.""" + cdef Affine at + if is_transform(m): + at = get_Affine(m) + return wrap_Ellipse(self.thisptr.transformed(at)) + +cdef cy_Ellipse wrap_Ellipse(Ellipse p): + cdef Ellipse * retp = new Ellipse() + retp[0] = p + cdef cy_Ellipse r = cy_Ellipse.__new__(cy_Ellipse) + r.thisptr = retp + return r diff --git a/src/cython/_cy_curves.pxd b/src/cython/_cy_curves.pxd new file mode 100644 index 0000000..dd13c06 --- /dev/null +++ b/src/cython/_cy_curves.pxd @@ -0,0 +1,421 @@ +from _common_decl cimport * + +from libcpp.vector cimport vector +from libcpp.pair cimport pair + +from _cy_rectangle cimport Interval, OptInterval, Rect, OptRect +from _cy_affine cimport Affine +from _cy_primitives cimport Point, cy_Point, wrap_Point, wrap_vector_point, make_vector_point +from _cy_primitives cimport Angle, cy_Angle, wrap_Angle +from _cy_primitives cimport AngleInterval + + +cdef extern from "2geom/d2.h" namespace "Geom": + cdef cppclass D2[T]: + D2() + D2(T &, T &) + T& operator[](unsigned i) + +cdef extern from "2geom/curve.h" namespace "Geom": + cdef cppclass Curve: + Curve() + Point initialPoint() + Point finalPoint() + bint isDegenerate() + Point pointAt(Coord) + Coord valueAt(Coord, Dim2) + Point operator()(Coord) + vector[Point] pointAndDerivatives(Coord, unsigned int) + void setInitial(Point &) + void setFinal(Point &) + Rect boundsFast() + Rect boundsExact() + OptRect boundsLocal(OptInterval &, unsigned int) + OptRect boundsLocal(OptInterval &) + Curve * duplicate() + Curve * transformed(Affine &) + Curve * portion(Coord, Coord) + Curve * portion(Interval &) + Curve * reverse() + Curve * derivative() + Coord nearestTime(Point &, Coord, Coord) + Coord nearestTime(Point &, Interval &) + vector[double] allNearestTimes(Point &, Coord, Coord) + vector[double] allNearestTimes(Point &, Interval &) + Coord length(Coord) + vector[double] roots(Coord, Dim2) + int winding(Point &) + Point unitTangentAt(Coord, unsigned int) + D2[SBasis] toSBasis() + int degreesOfFreedom() + bint operator==(Curve &) + +cdef class cy_Curve: + cdef Curve* thisptr + +#~ cdef cy_Curve wrap_Curve(Curve & p) +cdef cy_Curve wrap_Curve_p(Curve * p) + + +cdef extern from "2geom/linear.h" namespace "Geom": + cdef cppclass Linear: +#~ Linear(Linear &) + Linear() + Linear(double, double) + Linear(double) + double operator[](int const) + bint isZero(double) + bint isConstant(double) + bint isFinite() + double at0() + double at1() + double valueAt(double) + double operator()(double) + SBasis toSBasis() + OptInterval bounds_exact() + OptInterval bounds_fast() + OptInterval bounds_local(double, double) + double tri() + double hat() + + bint operator==(Linear &, Linear &) + bint operator!=(Linear &, Linear &) + Linear operator*(Linear &, double) + Linear operator+(Linear &, double) + Linear operator+(Linear &, Linear &) + #cython has trouble resolving these + Linear L_neg "operator-" (Linear &) + Linear L_sub_Ld "operator-"(Linear &, double) + Linear L_sub_LL "operator-"(Linear &, Linear &) + Linear operator/(Linear &, double) + + double lerp(double, double, double) + Linear reverse(Linear &) + + +cdef extern from "2geom/sbasis.h" namespace "Geom": + cdef cppclass SBasis: + + SBasis() + SBasis(double) + SBasis(double, double) + SBasis(SBasis &) + SBasis(vector[Linear] &) + SBasis(Linear &) + + size_t size() + Linear operator[](unsigned int) + bint empty() + Linear & back() + void pop_back() + void resize(unsigned int) + void resize(unsigned int, Linear &) + void reserve(unsigned int) + void clear() +#~ void insert(::__gnu_cxx::__normal_iterator > >, ::__gnu_cxx::__normal_iterator > >, ::__gnu_cxx::__normal_iterator > >) + Linear & at(unsigned int) + bint operator==(SBasis &) + bint operator!=(SBasis &) + + bint isZero(double) + bint isConstant(double) + bint isFinite() + double at0() + double at1() + int degreesOfFreedom() + double valueAt(double) + double operator()(double) + vector[double] valueAndDerivatives(double, unsigned int) + SBasis toSBasis() + double tailError(unsigned int) + SBasis operator()(SBasis &) + void normalize() + void truncate(unsigned int) + + SBasis operator*(SBasis &, SBasis &) + SBasis operator*(double, SBasis &) + SBasis operator*(SBasis &, double) + SBasis operator+(SBasis &, double) + SBasis operator+(SBasis &, SBasis &) + SBasis SB_sub_Sd "operator-" (SBasis &, double) + SBasis SB_sub_SS "operator-" (SBasis &, SBasis &) + SBasis SB_neg "operator-" (SBasis &) + SBasis operator/(SBasis &, double) + + SBasis sin(Linear, int) + SBasis cos(Linear, int) + SBasis sqrt(SBasis &, int) + SBasis reciprocal(Linear &, int) + SBasis shift(Linear &, int) + SBasis shift(SBasis &, int) + SBasis inverse(SBasis, int) + + SBasis portion(SBasis &, Interval) + SBasis portion(SBasis &, double, double) + SBasis compose(SBasis &, SBasis &, unsigned int) + SBasis compose(SBasis &, SBasis &) + SBasis truncate(SBasis &, unsigned int) + + unsigned int valuation(SBasis &, double) + + vector[ vector[double] ] multi_roots(SBasis &, vector[double] &, double, double, double, double) #TODO + vector[Interval] level_set(SBasis &, Interval &, double, double, double) + vector[Interval] level_set(SBasis &, double, double, double, double, double) + vector[double] roots(SBasis &, Interval const) + vector[double] roots(SBasis &) + vector[ vector[Interval] ] level_sets(SBasis &, vector[Interval] &, double, double, double) #TODO + vector[ vector[Interval] ] level_sets(SBasis &, vector[double] &, double, double, double, double) #TODO + + SBasis reverse(SBasis &) + SBasis derivative(SBasis &) + SBasis integral(SBasis &) + SBasis divide(SBasis &, SBasis &, int) + SBasis compose_inverse(SBasis &, SBasis &, unsigned int, double) + SBasis multiply(SBasis &, SBasis &) + SBasis multiply_add(SBasis &, SBasis &, SBasis) + + OptInterval bounds_exact(SBasis &) + OptInterval bounds_local(SBasis &, OptInterval &, int) + OptInterval bounds_fast(SBasis &, int) + +cdef class cy_SBasis: + cdef SBasis* thisptr + +cdef extern from "2geom/sbasis-curve.h" namespace "Geom": + cdef cppclass SBasisCurve: + SBasisCurve(D2[SBasis] &) + SBasisCurve(Curve &) + Curve * duplicate() + Point initialPoint() + Point finalPoint() + bint isDegenerate() + Point pointAt(Coord) + Point operator()(double) + vector[Point] pointAndDerivatives(Coord, unsigned int) + Coord valueAt(Coord, Dim2) + void setInitial(Point &) + void setFinal(Point &) + Rect boundsFast() + Rect boundsExact() + OptRect boundsLocal(OptInterval &, unsigned int) + vector[double] roots(Coord, Dim2) + Coord nearestTime(Point &, Coord, Coord) + vector[double] allNearestTimes(Point &, Coord, Coord) + Coord length(Coord) + Curve * portion(Coord, Coord) + Curve * transformed(Affine &) + Curve * derivative() + D2[SBasis] toSBasis() + int degreesOfFreedom() + + +cdef extern from "2geom/bezier.h" namespace "Geom": + cdef cppclass Bezier: +#~ struct Order +#~ pass + unsigned int order() + unsigned int size() + Bezier() +#~ Bezier(Bezier.Order) + Bezier(Coord) + Bezier(Coord, Coord) + Bezier(Coord, Coord, Coord) + Bezier(Coord, Coord, Coord, Coord) + void resize(unsigned int, Coord) + void clear() + unsigned int degree() + bint isZero(double) + bint isConstant(double) + bint isFinite() + Coord at0() + Coord at1() + Coord valueAt(double) + Coord operator()(double) + SBasis toSBasis() + Coord & operator[](unsigned int) + void setPoint(unsigned int, double) + vector[double] valueAndDerivatives(Coord, unsigned int) + pair[Bezier, Bezier] subdivide(Coord) + vector[double] roots() + vector[double] roots(Interval const) + Bezier forward_difference(unsigned int) + Bezier elevate_degree() + Bezier reduce_degree() + Bezier elevate_to_degree(unsigned int) + Bezier deflate() + Bezier(Coord *, unsigned int) + + Bezier operator*(Bezier &, double) + Bezier operator+(Bezier &, double) + Bezier operator-(Bezier &, double) + Bezier operator/(Bezier &, double) + + Bezier portion(Bezier &, double, double) + OptInterval bounds_local(Bezier &, OptInterval) + Coord casteljau_subidivision(Coord, Coord *, Coord *, Coord *, unsigned int) + void bezier_to_sbasis(SBasis &, Bezier &) + Bezier integral(Bezier &) + Bezier derivative(Bezier &) + OptInterval bounds_exact(Bezier &) + double bernsteinValueAt(double, double *, unsigned int) + vector[Point] bezier_points(D2[Bezier] &) + OptInterval bounds_fast(Bezier &) + Bezier multiply(Bezier &, Bezier &) + Bezier reverse(Bezier &) + +#This is ugly workaround around cython's lack of support for integer template parameters +cdef extern from *: + ctypedef int n_0 "0" + ctypedef int n_1 "1" + +cdef extern from "2geom/bezier-curve.h" namespace "Geom": + cdef cppclass BezierCurve: + unsigned int order() + vector[Point] controlPoints() + void setPoint(unsigned int, Point) + void setPoints(vector[Point] &) + Point operator[](unsigned int) + Point initialPoint() + Point finalPoint() + bint isDegenerate() + void setInitial(Point &) + void setFinal(Point &) + Rect boundsFast() + Rect boundsExact() + OptRect boundsLocal(OptInterval &, unsigned int) + Curve * duplicate() + Curve * portion(Coord, Coord) + Curve * reverse() + Curve * transformed(Affine &) + Curve * derivative() + int degreesOfFreedom() + vector[double] roots(Coord, Dim2) + Coord length(Coord) + Point pointAt(Coord) + vector[Point] pointAndDerivatives(Coord, unsigned int) + Coord valueAt(Coord, Dim2) + D2[SBasis] toSBasis() + #protected: +#~ BezierCurve() +#~ BezierCurve(D2[Bezier] &) +#~ BezierCurve(Bezier &, Bezier &) +#~ BezierCurve(vector[Point] &) + #~ Point middle_point(LineSegment &) + #~ Coord length(LineSegment &) + Coord bezier_length(Point, Point, Point, Point, Coord) + Coord bezier_length(Point, Point, Point, Coord) + Coord bezier_length(vector[Point] &, Coord) + + cdef cppclass LineSegment: + LineSegment() + LineSegment(D2[Bezier] &) + LineSegment(Bezier, Bezier) + LineSegment(vector[Point] &) + LineSegment(Point, Point) + pair[LineSegment, LineSegment] subdivide(Coord) + + Curve * duplicate() + Curve * reverse() + Curve * transformed(Affine &) + Curve * derivative() + + cdef cppclass QuadraticBezier: + QuadraticBezier() + QuadraticBezier(D2[Bezier] &) + QuadraticBezier(Bezier, Bezier) + QuadraticBezier(vector[Point] &) + QuadraticBezier(Point, Point, Point) + pair[QuadraticBezier, QuadraticBezier] subdivide(Coord) + + Curve * duplicate() + Curve * reverse() + Curve * transformed(Affine &) + Curve * derivative() + + + cdef cppclass CubicBezier: + CubicBezier() + CubicBezier(D2[Bezier] &) + CubicBezier(Bezier, Bezier) + CubicBezier(vector[Point] &) + CubicBezier(Point, Point, Point, Point) + pair[CubicBezier, CubicBezier] subdivide(Coord) + + Curve * duplicate() + Curve * reverse() + Curve * transformed(Affine &) + Curve * derivative() + +#~ cdef cppclass BezierCurveN[n_1]: +#~ BezierCurveN () +#~ BezierCurveN(Bezier &, Bezier &) +#~ #BezierCurveN(Point &, Point &) +#~ BezierCurveN(vector[Point] &) +#~ pair[BezierCurveN, BezierCurveN] subdivide(Coord) +#~ +#~ Curve * duplicate() +#~ Curve * reverse() +#~ Curve * transformed(Affine &) +#~ Curve * derivative() + +cdef class cy_BezierCurve: + cdef BezierCurve* thisptr + +cdef class cy_LineSegment(cy_BezierCurve): + pass + +cdef cy_LineSegment wrap_LineSegment(LineSegment p) + +cdef extern from "2geom/bezier-curve.h" namespace "Geom::BezierCurve": + BezierCurve * create(vector[Point] &) + +cdef extern from "2geom/elliptical-arc.h" namespace "Geom": + cdef cppclass EllipticalArc: + EllipticalArc(EllipticalArc &) + EllipticalArc() + EllipticalArc(Point, Coord, Coord, Coord, bint, bint, Point) + Interval angleInterval() + Angle rotationAngle() + Coord ray(Dim2) + Point rays() + bint largeArc() + bint sweep() + LineSegment chord() + void set(Point &, double, double, double, bint, bint, Point &) + void setExtremes(Point &, Point &) + Coord center(Dim2) + Point center() + Coord sweepAngle() + bint containsAngle(Coord) + Point pointAtAngle(Coord) + Coord valueAtAngle(Coord, Dim2) + Affine unitCircleTransform() + bint isSVGCompliant() + pair[EllipticalArc, EllipticalArc] subdivide(Coord) + Point initialPoint() + Point finalPoint() + Curve * duplicate() + void setInitial(Point &) + void setFinal(Point &) + bint isDegenerate() + Rect boundsFast() + Rect boundsExact() + OptRect boundsLocal(OptInterval &, unsigned int) + vector[double] roots(double, Dim2) + double nearestTime(Point &, double, double) + int degreesOfFreedom() + Curve * derivative() + Curve * transformed(Affine &) + vector[Point] pointAndDerivatives(Coord, unsigned int) + D2[SBasis] toSBasis() + double valueAt(Coord, Dim2) + Point pointAt(Coord) + Curve * portion(double, double) + Curve * reverse() + +cdef class cy_EllipticalArc: + cdef EllipticalArc* thisptr +cdef cy_EllipticalArc wrap_EllipticalArc(EllipticalArc p) + +cdef Curve * get_Curve_p(object c) +cdef bint is_Curve(object c) diff --git a/src/cython/_cy_curves.pyx b/src/cython/_cy_curves.pyx new file mode 100644 index 0000000..3584a87 --- /dev/null +++ b/src/cython/_cy_curves.pyx @@ -0,0 +1,1945 @@ +from numbers import Number + +from cython.operator cimport dereference as deref + +from _cy_rectangle cimport cy_OptInterval, wrap_OptInterval, wrap_Rect, OptRect, wrap_OptRect +from _cy_rectangle cimport cy_Interval, wrap_Interval + +from _cy_affine cimport cy_Translate, cy_Rotate, cy_Scale +from _cy_affine cimport cy_VShear, cy_HShear, cy_Zoom +from _cy_affine cimport cy_Affine, wrap_Affine, get_Affine, is_transform + + +cdef class cy_Curve: + + """Class representing generic curve. + + Curve maps unit interval to real plane. All curves should implement + these methods. + + This class corresponds to Curve class in 2geom. It's children in cython + aren't actually derived from it, it would make code more unreadable. + """ + + def __cinit__(self): + """Create new Curve. + + You shouldn't create Curve this way, it usually wraps existing + curves (f. e. in Path). + """ + self.thisptr = new SBasisCurve(D2[SBasis]( SBasis(0), SBasis(0) )) + + def __call__(self, Coord t): + """Get point at time value t.""" + return wrap_Point( deref(self.thisptr)(t) ) + + def initial_point(self): + """Get self(0).""" + return wrap_Point(self.thisptr.initialPoint()) + + def final_point(self): + """Get self(1).""" + return wrap_Point(self.thisptr.finalPoint()) + def is_degenerate(self): + """Curve is degenerate if it's length is zero.""" + return self.thisptr.isDegenerate() + + def point_at(self, Coord t): + """Equivalent to self(t).""" + return wrap_Point(self.thisptr.pointAt(t)) + + def value_at(self, Coord t, Dim2 d): + """Equivalent to self(t)[d].""" + return self.thisptr.valueAt(t, d) + + def point_and_derivatives(self, Coord t, unsigned int n): + """Return point and at least first n derivatives at point t in list.""" + return wrap_vector_point(self.thisptr.pointAndDerivatives(t, n)) + + def set_initial(self, cy_Point v): + """Set initial point of curve.""" + self.thisptr.setInitial(deref( v.thisptr )) + + def set_final(self, cy_Point v): + """Set final point of curve.""" + self.thisptr.setFinal(deref( v.thisptr )) + + def bounds_fast(self): + """Return bounding rectangle for curve. + + This method is fast, but does not guarantee to give smallest + rectangle. + """ + return wrap_Rect(self.thisptr.boundsFast()) + + def bounds_exact(self): + """Return exact bounding rectangle for curve. + + This may take a while. + """ + return wrap_Rect(self.thisptr.boundsExact()) + + def bounds_local(self, cy_OptInterval i, unsigned int deg=0): + """Return bounding rectangle to portion of curve.""" + return wrap_OptRect(self.thisptr.boundsLocal(deref( i.thisptr ), deg)) + + #TODO rewrite all duplicates to copy.""" + def duplicate(self): + """Duplicate the curve.""" + return wrap_Curve_p( self.thisptr.duplicate() ) + + def transformed(self, m): + """Transform curve by affine transform.""" + cdef Affine at + if is_transform(m): + at = get_Affine(m) + return wrap_Curve_p( self.thisptr.transformed(at) ) + + def portion(self, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return portion of curve, specified by endpoints or interval.""" + if interval is None: + return wrap_Curve_p( self.thisptr.portion(deref( interval.thisptr )) ) + else: + return wrap_Curve_p( self.thisptr.portion(fr, to) ) + + def reverse(self): + """Return curve with reversed time.""" + return wrap_Curve_p( self.thisptr.reverse() ) + + def derivative(self): + """Return curve's derivative.""" + return wrap_Curve_p( self.thisptr.derivative() ) + + def nearest_time(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return such t that |self(t) - point| is minimized.""" + if interval is None: + return self.thisptr.nearestTime(deref( p.thisptr ), fr, to) + else: + return self.thisptr.nearestTime(deref( p.thisptr ), deref( interval.thisptr )) + + def all_nearest_times(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return all values of t that |self(t) - point| is minimized.""" + if interval is None: + return wrap_vector_double(self.thisptr.allNearestTimes(deref( p.thisptr ), fr, to)) + else: + return wrap_vector_double(self.thisptr.allNearestTimes(deref( p.thisptr ), + deref( interval.thisptr ))) + + def length(self, Coord tolerance): + """Return length of curve, within give tolerance.""" + return self.thisptr.length(tolerance) + + def roots(self, Coord v, Dim2 d): + """Find time values where self(t)[d] == v.""" + return wrap_vector_double(self.thisptr.roots(v, d)) + + def winding(self, cy_Point p): + """Return winding number around specified point.""" + return self.thisptr.winding(deref( p.thisptr )) + + def unit_tangent_at(self, Coord t, unsigned int n): + """Return tangent at self(t). + + Parameter n specifies how many derivatives to take into account.""" + return wrap_Point(self.thisptr.unitTangentAt(t, n)) + + def to_SBasis(self): + """Return tuple of SBasis functions.""" + cdef D2[SBasis] ret = self.thisptr.toSBasis() + return ( wrap_SBasis(ret[0]), wrap_SBasis(ret[1]) ) + + def degrees_of_freedom(self): + """Return number of independent parameters needed to specify the curve.""" + return self.thisptr.degreesOfFreedom() +#~ def operator==(self, cy_Curve c): +#~ return deref( self.thisptr ) == deref( c.thisptr ) + +#~ cdef cy_Curve wrap_Curve(Curve & p): +#~ cdef Curve * retp = new SBasisCurve(D2[SBasis]( SBasis(), SBasis() )) +#~ retp[0] = p +#~ cdef cy_Curve r = cy_Curve.__new__(cy_Curve) +#~ r.thisptr = retp +#~ return r + +cdef cy_Curve wrap_Curve_p(Curve * p): + cdef cy_Curve r = cy_Curve.__new__(cy_Curve) + r.thisptr = p + return r + +cdef class cy_Linear: + """Function mapping linearly between two values. + + Corresponds to Linear class in 2geom. + """ + + cdef Linear* thisptr + + def __cinit__(self, aa = None, b = None): + """Create new Linear from two end values. + + No arguments create zero constant, one value creates constant. + """ + if aa is None: + self.thisptr = new Linear() + elif b is None: + self.thisptr = new Linear(float(aa)) + else: + self.thisptr = new Linear(float(aa), float(b)) + + def __dealloc__(self): + del self.thisptr + + def __call__(self, Coord t): + """Get value at time value t.""" + return deref(self.thisptr)(t) + + def __getitem__(self, i): + """Get end values.""" + return deref( self.thisptr ) [i] + + def __richcmp__(cy_Linear self, cy_Linear other, int op): + if op == 2: + return deref(self.thisptr) == deref(other.thisptr) + elif op == 3: + return deref(self.thisptr) != deref(other.thisptr) + + + def __neg__(cy_Linear self): + """Negate all values of self.""" + return wrap_Linear( L_neg(deref(self.thisptr)) ) + + + def __add__(cy_Linear self, other): + """Add number or other linear.""" + if isinstance(other, Number): + return wrap_Linear( deref(self.thisptr) + float(other) ) + elif isinstance(other, cy_Linear): + return wrap_Linear( deref(self.thisptr) + deref( ( other).thisptr ) ) + + def __sub__(cy_Linear self, other): + """Substract number or other linear.""" + if isinstance(other, Number): + return wrap_Linear( L_sub_Ld(deref(self.thisptr), float(other)) ) + elif isinstance(other, cy_Linear): + return wrap_Linear( L_sub_LL(deref(self.thisptr), deref( ( other).thisptr )) ) + + + def __mul__(cy_Linear self, double b): + """Multiply linear by number.""" + return wrap_Linear(deref( self.thisptr ) * b) + + def __div__(cy_Linear self, double b): + """Divide linear by value.""" + return wrap_Linear(deref( self.thisptr ) / b) + + def is_zero(self, double eps = EPSILON): + """Test whether linear is zero within given tolerance.""" + return self.thisptr.isZero(eps) + + def is_constant(self, double eps = EPSILON): + """Test whether linear is constant within given tolerance.""" + return self.thisptr.isConstant(eps) + + def is_finite(self): + """Test whether linear is finite.""" + return self.thisptr.isFinite() + + def at0(self): + """Equivalent to self(0).""" + return self.thisptr.at0() + + def at1(self): + """Equivalent to self(1).""" + return self.thisptr.at1() + + def value_at(self, double t): + """Equivalent to self(t).""" + return self.thisptr.valueAt(t) + + def to_SBasis(self): + """Convert to SBasis.""" + return wrap_SBasis(self.thisptr.toSBasis()) + + def bounds_exact(self): + """Return exact bounding interval + + This may take a while. + """ + return wrap_OptInterval(self.thisptr.bounds_exact()) + + def bounds_fast(self): + """Return bounding interval + + This method is fast, but does not guarantee to give smallest + interval. + """ + return wrap_OptInterval(self.thisptr.bounds_fast()) + + def bounds_local(self, double u, double v): + """Return bounding interval to the portion of Linear.""" + return wrap_OptInterval(self.thisptr.bounds_local(u, v)) + + def tri(self): + """Return difference between end values.""" + return self.thisptr.tri() + + def hat(self): + """Return value at (0.5).""" + return self.thisptr.hat() + + @classmethod + def sin(cls, cy_Linear bo, int k): + """Return sine of linear.""" + return wrap_SBasis(sin(deref( bo.thisptr ), k)) + + @classmethod + def cos(cls, cy_Linear bo, int k): + """Return cosine of linear.""" + return wrap_SBasis(cos(deref( bo.thisptr ), k)) + + @classmethod + def reciprocal(cls, cy_Linear a, int k): + """Return reciprocical of linear.""" + return wrap_SBasis(reciprocal(deref( a.thisptr ), k)) + + @classmethod + def shift(cls, cy_Linear a, int sh): + """Multiply by x**sh.""" + return wrap_SBasis(shift(deref( a.thisptr ), sh)) + +#leave these in cy2geom napespace? +def cy_lerp(double t, double a, double b): + return lerp(t, a, b) + +cdef cy_Linear wrap_Linear(Linear p): + cdef Linear * retp = new Linear() + retp[0] = p + cdef cy_Linear r = cy_Linear.__new__(cy_Linear) + r.thisptr = retp + return r + +cdef vector[Linear] make_vector_linear(object l): + cdef vector[Linear] ret + for i in l: + ret.push_back( deref( ( i).thisptr ) ) + return ret + + +cdef class cy_SBasis: + + """Class representing SBasis polynomial. + + Corresponds to SBasis class in 2geom.""" + + def __cinit__(self, a=None, b=None): + """Create new SBasis. + + This constructor only creates linear SBasis, specifying endpoints. + """ + if a is None: + self.thisptr = new SBasis() + elif b is None: + self.thisptr = new SBasis( float(a) ) + else: + self.thisptr = new SBasis( float(a), float(b) ) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_linear(cls, cy_Linear l): + """Create SBasis from Linear.""" + return wrap_SBasis( SBasis(deref( l.thisptr )) ) + + @classmethod + def from_linears(cls, lst): + """Create SBasis from list of Linears.""" + return wrap_SBasis( SBasis( make_vector_linear(lst) ) ) + + def size(self): + """Return number of linears SBasis consists of.""" + return self.thisptr.size() + + def __call__(self, o): + """Get point at time value t.""" + if isinstance(o, Number): + return deref(self.thisptr)(float(o)) + elif isinstance(self, cy_SBasis): + return wrap_SBasis(deref(self.thisptr)( deref( ( o).thisptr ) )) + + def __getitem__(self, unsigned int i): + """Get Linear at i th position.""" + if i>=self.size(): + raise IndexError + else: + return wrap_Linear(deref( self.thisptr ) [i]) + + def __neg__(self): + """Return SBasis with negated values.""" + return wrap_SBasis( SB_neg(deref(self.thisptr)) ) + + #cython doesn't use __rmul__, it switches the arguments instead + def __add__(cy_SBasis self, other): + """Add number or other SBasis to SBasis.""" + if isinstance(other, Number): + return wrap_SBasis( deref(self.thisptr) + float(other) ) + elif isinstance(other, cy_SBasis): + return wrap_SBasis( deref(self.thisptr) + deref( ( other).thisptr ) ) + + def __sub__(cy_SBasis self, other): + """Substract number or other SBasis from SBasis.""" + if isinstance(other, Number): + return wrap_SBasis( SB_sub_Sd(deref(self.thisptr), float(other) ) ) + elif isinstance(other, cy_SBasis): + return wrap_SBasis( SB_sub_SS(deref(self.thisptr), deref( ( other).thisptr ) ) ) + + def __mul__(self, other): + """Multiply SBasis by number or other SBasis.""" + if isinstance(other, Number): + return wrap_SBasis( deref( ( self).thisptr ) * float(other) ) + elif isinstance(other, cy_SBasis): + if isinstance(self, cy_SBasis): + return wrap_SBasis( deref( ( self).thisptr ) * deref( ( other).thisptr ) ) + elif isinstance(self, Number): + return wrap_SBasis( float(self) * deref( ( other).thisptr ) ) + + def __div__(cy_SBasis self, double other): + """Divide SBasis by number.""" + return wrap_SBasis( deref(self.thisptr)/other ) + + + def empty(self): + """Test whether SBasis has no linears.""" + return self.thisptr.empty() + + def back(self): + """Return last linear in SBasis.""" + return wrap_Linear(self.thisptr.back()) + + def pop_back(self): + """Remove last linear in SBasis.""" + self.thisptr.pop_back() + + def resize(self, unsigned int n, cy_Linear l = None): + """Resize SBasis, optionally filling created slots with linear.""" + if l is None: + self.thisptr.resize(n) + else: + self.thisptr.resize(n, deref( l.thisptr )) + +#~ def reserve(self, unsigned int n): +#~ self.thisptr.reserve(n) + + def clear(self): + """Make SBasis empty.""" + self.thisptr.clear() +#~ def insert(self, cy_::__gnu_cxx::__normal_iterator > > before, cy_::__gnu_cxx::__normal_iterator > > src_begin, cy_::__gnu_cxx::__normal_iterator > > src_end): +#~ self.thisptr.insert(deref( before.thisptr ), deref( src_begin.thisptr ), deref( src_end.thisptr )) + + def at(self, unsigned int i): + """Equivalent to self[i].""" + return wrap_Linear(self.thisptr.at(i)) + + def __richcmp__(cy_SBasis self, cy_SBasis B, int op): + if op == 2: + return deref( self.thisptr ) == deref( B.thisptr ) + elif op == 3: + return deref( self.thisptr ) != deref( B.thisptr ) + + def is_zero(self, double eps = EPSILON): + """Test whether linear is zero within given tolerance.""" + return self.thisptr.isZero(eps) + + def is_constant(self, double eps = EPSILON): + """Test whether linear is constant within given tolerance.""" + return self.thisptr.isConstant(eps) + + def is_finite(self): + """Test whether linear is finite.""" + return self.thisptr.isFinite() + + def at0(self): + """Equivalent to self(0).""" + return self.thisptr.at0() + + def at1(self): + """Equivalent to self(1).""" + return self.thisptr.at1() + + def degrees_of_freedom(self): + """Return number of independent parameters needed to specify the curve.""" + return self.thisptr.degreesOfFreedom() + + def value_at(self, double t): + """Equivalent to self(t)[d].""" + return self.thisptr.valueAt(t) + + def value_and_derivatives(self, double t, unsigned int n): + """Return value and at least n derivatives at time t.""" + return wrap_vector_double (self.thisptr.valueAndDerivatives(t, n)) + + def to_SBasis(self): + """Just return self.""" + return wrap_SBasis(self.thisptr.toSBasis()) + + def tail_error(self, unsigned int tail): + """Return largest error after truncating linears from tail.""" + return self.thisptr.tailError(tail) + + def normalize(self): + """Remove zero linears at the end.""" + self.thisptr.normalize() + + def truncate(self, unsigned int k): + """Truncate SBasis to have k elements.""" + self.thisptr.truncate(k) + + @classmethod + def sqrt(cls, cy_SBasis a, int k): + """Return square root of SBasis. + + Use k to specify degree of resulting SBasis. + """ + return wrap_SBasis(sqrt(deref( a.thisptr ), k)) + + @classmethod + def inverse(cls, cy_SBasis a, int k): + """Return inverse function to SBasis. + + Passed SBasis must be function [1-1] -> [1-1] bijection. + """ + return wrap_SBasis(inverse(deref( a.thisptr ), k)) + + @classmethod + def valuation(cls, cy_SBasis a, double tol = 0): + """Return the degree of the first non zero coefficient.""" + return valuation(deref( a.thisptr ), tol) + + #call with level_set(SBasis(1, 5), 2, a = 0.2, b = 0.4, tol = 0.02) + @classmethod + def level_set(cls, cy_SBasis f, level, a = 0, b = 1, tol = 1e-5, vtol = 1e-5): + """Return intervals where SBasis is in specified level. + + Specify range and tolerance in other arguments. + """ + if isinstance(level, cy_Interval): + return wrap_vector_interval(level_set(deref( f.thisptr ), deref( ( level).thisptr ), a, b, tol)) #a, b, tol + else: + return wrap_vector_interval(level_set(deref( f.thisptr ), float(level), vtol, a, b, tol)) #vtol, a, b, tol + + @classmethod + def shift(cls, cy_SBasis a, int sh): + """Multiply by x**sh.""" + return wrap_SBasis(shift(deref( a.thisptr ), sh)) + + @classmethod + def compose(cls, cy_SBasis a, cy_SBasis b, k = None): + """Compose two SBasis. + + Specify order of resulting SBasis by parameter k. + """ + if k is None: + return wrap_SBasis(compose(deref( a.thisptr ), deref( b.thisptr ))) + else: + return wrap_SBasis(compose(deref( a.thisptr ), deref( b.thisptr ), int(k))) + + @classmethod + def roots(cls, cy_SBasis s, cy_Interval inside = None): + """Return time values where self equals 0. + + inside intervals specifies subset of domain. + """ + if inside is None: + return wrap_vector_double(roots(deref( s.thisptr ))) + else: + return wrap_vector_double(roots(deref( s.thisptr ), deref( inside.thisptr ))) + + @classmethod + def multi_roots(cls, cy_SBasis f, levels, double htol = 1e-7, double vtol = 1e-7, double a = 0, double b = 1): + """Return lists of roots for different levels.""" + cdef vector[double] l = make_vector_double(levels) + cdef vector[ vector[double] ] r = multi_roots(deref( f.thisptr ), l, htol, vtol, a, b) + lst = [] + for i in range(r.size()): + lst.append( wrap_vector_double(r[i]) ) + return lst + + @classmethod + def multiply_add(cls, cy_SBasis a, cy_SBasis b, cy_SBasis c): + """Return a*b+c.""" + return wrap_SBasis(multiply_add(deref( a.thisptr ), deref( b.thisptr ), deref( c.thisptr ))) + + @classmethod + def divide(cls, cy_SBasis a, cy_SBasis b, int k): + """Divide two SBasis functions. + + Use k to specify degree of resulting SBasis. + """ + return wrap_SBasis(divide(deref( a.thisptr ), deref( b.thisptr ), k)) + + @classmethod + def compose_inverse(cls, cy_SBasis f, cy_SBasis g, unsigned int order, double tol): + """Compose f with g's inverse. + + Requires g to be bijection g: [0, 1] -> [0, 1] + """ + return wrap_SBasis(compose_inverse(deref( f.thisptr ), deref( g.thisptr ), order, tol)) + + @classmethod + def multiply(cls, cy_SBasis a, cy_SBasis b): + """Multiply two SBasis functions.""" + return wrap_SBasis(multiply(deref( ( a).thisptr ), deref( ( b).thisptr ))) + + @classmethod + def derivative(cls, cy_SBasis a): + """Return derivative os SBasis.""" + return wrap_SBasis(derivative(deref( ( a).thisptr ))) + + @classmethod + def integral(cls, a): + """Return integral of SBasis.""" + return wrap_SBasis(integral(deref( ( a).thisptr ))) + + @classmethod + def portion(cls, cy_SBasis a, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return portion of SBasis, specified by endpoints or interval.""" + if interval is None: + return wrap_SBasis( portion( deref( a.thisptr ), fr, to ) ) + else: + return wrap_SBasis( portion( deref( a.thisptr ), deref( interval.thisptr ) ) ) + + @classmethod + def bounds_fast(cls, cy_SBasis a, int order = 0): + """Return bounding interval + + This method is fast, but does not guarantee to give smallest + interval. + """ + return wrap_OptInterval(bounds_fast(deref( a.thisptr ), order)) + + @classmethod + def bounds_exact(cls, cy_SBasis a): + """Return exact bounding interval + + This may take a while. + """ + return wrap_OptInterval(bounds_exact(deref( a.thisptr ))) + + @classmethod + def bounds_local(cls, cy_SBasis a, cy_OptInterval t, int order = 0): + """Return bounding interval to the portion of SBasis.""" + return wrap_OptInterval(bounds_local(deref( a.thisptr ), deref( t.thisptr ), order)) + +#~ def cy_level_sets(cy_SBasis f, vector[Interval] levels, double a, double b, double tol): +#~ return wrap_::std::vector >,std::allocator > > >(level_sets(deref( f.thisptr ), deref( levels.thisptr ), a, b, tol)) +#~ def cy_level_sets(cy_SBasis f, vector[vector] levels, double a, double b, double vtol, double tol): +#~ return wrap_::std::vector >,std::allocator > > >(level_sets(deref( f.thisptr ), deref( levels.thisptr ), a, b, vtol, tol)) + +def cy_reverse(a): + if isinstance(a, cy_Linear): + return wrap_Linear( reverse(deref( ( a).thisptr ))) + elif isinstance(a, cy_SBasis): + return wrap_SBasis( reverse(deref( ( a).thisptr ))) + elif isinstance(a, cy_Bezier): + return wrap_Bezier( reverse(deref( ( a).thisptr ))) + +#already implemented +#~ def cy_truncate(cy_SBasis a, unsigned int terms): +#~ return wrap_SBasis(truncate(deref( a.thisptr ), terms)) + +cdef cy_SBasis wrap_SBasis(SBasis p): + cdef SBasis * retp = new SBasis() + retp[0] = p + cdef cy_SBasis r = cy_SBasis.__new__(cy_SBasis, 0, 0) + r.thisptr = retp + return r + + +cdef class cy_SBasisCurve: + + """Curve mapping two SBasis functions to point (s1(t), s2(t)). + + Corresponds to SBasisCurve in 2geom. + """ + + cdef SBasisCurve* thisptr + +#~ def __init__(self, cy_Curve other): +#~ self.thisptr = self.thisptr.SBasisCurve(deref( other.thisptr )) + + def __cinit__(self, cy_SBasis s1, cy_SBasis s2): + """Create new SBasisCurve from two SBasis functions.""" + self.thisptr = new SBasisCurve( D2[SBasis]( + deref( s1.thisptr ), + deref( s2.thisptr ) ) ) + + def __dealloc__(self): + del self.thisptr + + def __call__(self, double t): + """Get point at time value t.""" + return wrap_Point(deref(self.thisptr)(t)) + + def duplicate(self): + """Duplicate the curve.""" + return wrap_SBasisCurve( deref(self.thisptr.duplicate()) ) + + def initial_point(self): + """Get self(0).""" + return wrap_Point(self.thisptr.initialPoint()) + + def final_point(self): + """Get self(1).""" + return wrap_Point(self.thisptr.finalPoint()) + + def is_degenerate(self): + """Curve is degenerate if it's length is zero.""" + return self.thisptr.isDegenerate() + + def point_at(self, Coord t): + """Equivalent to self(t).""" + return wrap_Point(self.thisptr.pointAt(t)) + + def point_and_derivatives(self, Coord t, unsigned int n): + """Return point and at least first n derivatives at point t in list.""" + return wrap_vector_point(self.thisptr.pointAndDerivatives(t, n)) + + def value_at(self, Coord t, Dim2 d): + """Equivalent to self(t)[d].""" + return self.thisptr.valueAt(t, d) + + def set_initial(self, cy_Point v): + """Set initial point of curve.""" + self.thisptr.setInitial(deref( v.thisptr )) + + def set_final(self, cy_Point v): + """Set final point of curve.""" + self.thisptr.setFinal(deref( v.thisptr )) + + def bounds_fast(self): + """Return bounding rectangle for curve. + + This method is fast, but does not guarantee to give smallest + rectangle. + """ + return wrap_Rect(self.thisptr.boundsFast()) + + def bounds_exact(self): + """Return exact bounding rectangle for curve. + + This may take a while. + """ + return wrap_Rect(self.thisptr.boundsExact()) + + def bounds_local(self, cy_OptInterval i, unsigned int deg): + """Return bounding rectangle to portion of curve.""" + return wrap_OptRect(self.thisptr.boundsLocal(deref( i.thisptr ), deg)) + + def roots(self, Coord v, Dim2 d): + """Find time values where self(t)[d] == v.""" + return wrap_vector_double( self.thisptr.roots(v, d) ) + + def nearest_time(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return such t that |self(t) - point| is minimized.""" + if interval is None: + return self.thisptr.nearestTime(deref( p.thisptr ), fr, to) + else: + return ( self.thisptr).nearestTime(deref( p.thisptr ), deref( interval.thisptr ) ) + + def all_nearest_times(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return all values of t that |self(t) - point| is minimized.""" + if interval is None: + return wrap_vector_double(self.thisptr.allNearestTimes(deref( p.thisptr ), fr, to)) + else: + return wrap_vector_double(( self.thisptr).allNearestTimes(deref( p.thisptr ), + deref( interval.thisptr ) )) + + def length(self, Coord tolerance = 0.01): + """Return length of curve, within give tolerance.""" + return self.thisptr.length(tolerance) + + + def portion(self, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return portion of curve, specified by endpoints or interval.""" + if interval is None: + return wrap_SBasisCurve( deref(self.thisptr.portion( fr, to ) ) ) + else: + return wrap_SBasisCurve( + deref( ( self.thisptr).portion( deref( interval.thisptr ))) ) + + def transformed(self, t): + """Transform curve by affine transform.""" + cdef Affine at + if is_transform(t): + at = get_Affine(t) + return wrap_SBasisCurve( deref(self.thisptr.transformed( at ))) + + def reverse(self): + """Return curve with reversed time.""" + return wrap_SBasisCurve( deref( ( self.thisptr).reverse() ) ) + + def derivative(self): + """Return curve's derivative.""" + return wrap_SBasisCurve( deref(self.thisptr.derivative()) ) + + + def winding(self, cy_Point p): + """Return winding number around specified point.""" + return ( self.thisptr).winding(deref(p.thisptr)) + + def unit_tangent_at(self, Coord t, int n = 3): + """Return tangent at self(t). + + Parameter n specifies how many derivatives to take into account.""" + return wrap_Point(( self.thisptr).unitTangentAt(t, n)) + + def to_SBasis(self): + """Return tuple containing it's SBasis functions.""" + return wrap_D2_SBasis(self.thisptr.toSBasis()) + + def degrees_of_freedom(self): + """Return number of independent parameters needed to specify the curve.""" + return self.thisptr.degreesOfFreedom() + +cdef object wrap_D2_SBasis(D2[SBasis] p): + return ( wrap_SBasis(p[0]), wrap_SBasis(p[1]) ) + +cdef cy_SBasisCurve wrap_SBasisCurve(SBasisCurve p): + cdef SBasisCurve * retp = new SBasisCurve(D2[SBasis]( SBasis(), SBasis() )) + retp[0] = p + cdef cy_SBasisCurve r = cy_SBasisCurve.__new__(cy_SBasisCurve, cy_SBasis(), cy_SBasis()) + r.thisptr = retp + return r + + +cdef class cy_Bezier: + + """Bezier polynomial. + + Corresponds to Bezier class in 2geom. + """ + + cdef Bezier* thisptr + + def __cinit__(self, *args): + """Create Bezier polynomial specifying it's coeffincients + + This constructor takes up to four coefficients. + """ + if len(args) == 0: + #new Bezier() causes segfault + self.thisptr = new Bezier(0) + elif len(args) == 1: + self.thisptr = new Bezier( float(args[0]) ) + elif len(args) == 2: + self.thisptr = new Bezier( float(args[0]), float(args[1]) ) + elif len(args) == 3: + self.thisptr = new Bezier( float(args[0]), float(args[1]), float(args[2]) ) + elif len(args) == 4: + self.thisptr = new Bezier( float(args[0]), float(args[1]), float(args[2]), float(args[3]) ) + else: + raise ValueError("Passed list has too many points") + + def __dealloc__(self): + del self.thisptr + + def __call__(self, double t): + """Get point at time value t.""" + return deref( self.thisptr ) (t) + + + def __getitem__(self, unsigned int ix): + """Get coefficient by accessing list.""" + if ix >= self.size(): + raise IndexError + return deref( self.thisptr ) [ix] + + def order(self): + """Return order of Bezier.""" + return self.thisptr.order() + + def size(self): + """Return number of coefficients.""" + return self.thisptr.size() + + def __mul__( cy_Bezier self, double v): + """Multiply Bezier by number.""" + return wrap_Bezier(deref( self.thisptr ) * v) + + def __add__( cy_Bezier self, double v): + """Add number to Bezier.""" + return wrap_Bezier(deref( self.thisptr ) + v) + + def __sub__( cy_Bezier self, double v): + """Substract number from Bezier.""" + return wrap_Bezier(deref( self.thisptr ) - v) + + def __div__( cy_Bezier self, double v): + """Divide Bezier number.""" + return wrap_Bezier(deref( self.thisptr ) / v) + + + def resize(self, unsigned int n, Coord v): + """Change order of Bezier.""" + self.thisptr.resize(n, v) + + def clear(self): + """Create empty Bezier.""" + self.thisptr.clear() + + def degree(self): + """Return degree of Bezier polynomial.""" + return self.thisptr.degree() + + def is_zero(self, double eps = EPSILON): + """Test whether linear is zero within given tolerance.""" + return self.thisptr.isZero(eps) + + def is_constant(self, double eps = EPSILON): + """Test whether linear is constant within given tolerance.""" + return self.thisptr.isConstant(eps) + + def is_finite(self): + """Test whether linear is finite.""" + return self.thisptr.isFinite() + + def at0(self): + """Equivalent to self(0).""" + return self.thisptr.at0() + + def at1(self): + """Equivalent to self(1).""" + return self.thisptr.at1() + + def value_at(self, double t): + """Equivalent to self(t).""" + return self.thisptr.valueAt(t) + + def to_SBasis(self): + """Convert to SBasis.""" + return wrap_SBasis(self.thisptr.toSBasis()) + + def set_point(self, unsigned int ix, double val): + """Set self[ix] to val.""" + self.thisptr.setPoint(ix, val) + + def value_and_derivatives(self, Coord t, unsigned int n_derivs): + """Return value and at least n derivatives at time t.""" + return wrap_vector_double(self.thisptr.valueAndDerivatives(t, n_derivs)) + + def subdivide(self, Coord t): + """Get two beziers, from 0 to t and from t to 1.""" + cdef pair[Bezier, Bezier] p = self.thisptr.subdivide(t) + return ( wrap_Bezier(p.first), wrap_Bezier(p.second) ) + + def roots(self, cy_Interval ivl = None): + """Find time values where self(t)[d] == v.""" + if ivl is None: + return wrap_vector_double(self.thisptr.roots()) + else: + return wrap_vector_double(self.thisptr.roots(deref( ivl.thisptr ))) + + def forward_difference(self, unsigned int k): +#TODO: ask someone what this function does. +#~ """Compute forward difference of degree k. +#~ +#~ First forward difference of B is roughly function B'(t) = B(t+h)-B(t) +#~ for fixed step h""" + return wrap_Bezier(self.thisptr.forward_difference(k)) + + def elevate_degree(self): + """Increase degree of Bezier by 1.""" + return wrap_Bezier(self.thisptr.elevate_degree()) + + def reduce_degree(self): + """Decrease degree of Bezier by 1.""" + return wrap_Bezier(self.thisptr.reduce_degree()) + + def elevate_to_degree(self, unsigned int new_degree): + """Increase degree of Bezier to new_degree.""" + return wrap_Bezier(self.thisptr.elevate_to_degree(new_degree)) + + def deflate(self): +#TODO: ask someone what this function does. + #It looks like integral(self)*self.size() + return wrap_Bezier(self.thisptr.deflate()) + + @classmethod + def bezier_points(cls, cy_Bezier a, cy_Bezier b): + """Return control points of BezierCurve consisting of two beziers. + + Passed bezier must have same degree.""" + return wrap_vector_point(bezier_points( D2[Bezier]( deref(a.thisptr), deref(b.thisptr) ) )) + + @classmethod + def multiply(cls, cy_Bezier a, cy_Bezier b): + """Multiply two Bezier functions.""" + return wrap_Bezier(multiply(deref( ( a).thisptr ), + deref( ( b).thisptr ))) + + @classmethod + def portion(cls, cy_Bezier a, Coord fr=0, Coord to=1, interval=None): + """Return portion of bezier, specified by endpoints or interval.""" + if interval is None: + return wrap_Bezier(portion(deref( a.thisptr ), fr, to)) + else: + return wrap_Bezier(portion(deref( a.thisptr ), float(interval.min()), + float(interval.max()) )) + + @classmethod + def derivative(cls, cy_Bezier a): + """Return derivative of a bezier.""" + return wrap_Bezier(derivative(deref( a.thisptr ))) + + @classmethod + def integral(cls, cy_Bezier a): + """Return derivative of a bezier.""" + return wrap_Bezier(integral(deref( a.thisptr ))) + + @classmethod + def bounds_fast(cls, cy_Bezier a): + """Return bounding interval + + This method is fast, but does not guarantee to give smallest + interval. + """ + return wrap_OptInterval(bounds_fast(deref( a.thisptr ))) + + @classmethod + def bounds_exact(cls, cy_Bezier a): + """Return exact bounding interval + + This may take a while. + """ + return wrap_OptInterval(bounds_exact(deref( a.thisptr ))) + + @classmethod + def bounds_local(cls, cy_Bezier a, cy_OptInterval t): + """Return bounding interval to the portion of bezier.""" + return wrap_OptInterval(bounds_local(deref( a.thisptr ), deref( t.thisptr ))) + +#This is the same as bz.to_SBasis() +#~ def cy_bezier_to_sbasis(cy_SBasis sb, cy_Bezier bz): +#~ bezier_to_sbasis(deref( sb.thisptr ), deref( bz.thisptr )) + +#These are look like internal functions. +#~ def cy_casteljau_subdivision(Coord t, cy_Coord * v, cy_Coord * left, cy_Coord * right, unsigned int order): +#~ return subdivideArr(t, v.thisptr, left.thisptr, right.thisptr, order) +#~ def cy_bernsteinValueAt(double t, cy_double * c_, unsigned int n): +#~ return bernsteinValueAt(t, c_.thisptr, n) + +cdef cy_Bezier wrap_Bezier(Bezier p): + cdef Bezier * retp = new Bezier() + retp[0] = p + cdef cy_Bezier r = cy_Bezier.__new__(cy_Bezier) + r.thisptr = retp + return r + + +cdef class cy_BezierCurve: + + """Bezier curve, consisting of two Bezier functions. + + Corresponds to BezierCurve class in 2geom. + """ + + #This flag is due to this class children + def __cinit__(self, *args, **kwargs): + """Don't use this constructor, use create instead.""" + pass + + def __dealloc__(self): + del self.thisptr + + def __call__(self, Coord t): + """Get point at time value t.""" + return wrap_Point(deref( self.thisptr )(t)) + + def __getitem__(self, unsigned int ix): + """Get control point by list access.""" + return wrap_Point(deref( self.thisptr ) [ix]) + + @classmethod + def create(cls, pts): + """Create new BezierCurve from control points.""" + return wrap_BezierCurve( deref( create( make_vector_point(pts) ) ) ) + + def order(self): + """Get order of curve.""" + return self.thisptr.order() + + def control_points(self): + """Get control points.""" + return wrap_vector_point(self.thisptr.controlPoints()) + + def set_point(self, unsigned int ix, cy_Point v): + """Set control point.""" + self.thisptr.setPoint(ix, deref( v.thisptr )) + + def set_points(self, ps): + """Set control points""" + self.thisptr.setPoints( make_vector_point(ps) ) + + def initial_point(self): + """Get self(0).""" + return wrap_Point(self.thisptr.initialPoint()) + + def final_point(self): + """Get self(1).""" + return wrap_Point(self.thisptr.finalPoint()) + + def is_degenerate(self): + """Curve is degenerate if it's length is zero.""" + return self.thisptr.isDegenerate() + + def set_initial(self, cy_Point v): + """Set initial point of curve.""" + self.thisptr.setInitial(deref( v.thisptr )) + + def set_final(self, cy_Point v): + """Set final point of curve.""" + self.thisptr.setFinal(deref( v.thisptr )) + + def bounds_fast(self): + """Return bounding rectangle for curve. + + This method is fast, but does not guarantee to give smallest + rectangle. + """ + return wrap_Rect(self.thisptr.boundsFast()) + + def bounds_exact(self): + """Return exact bounding rectangle for curve. + + This may take a while. + """ + return wrap_Rect(self.thisptr.boundsExact()) + + def bounds_local(cy_BezierCurve self, cy_OptInterval i, unsigned int deg): + """Return bounding rectangle to portion of curve.""" + return wrap_OptRect(self.thisptr.boundsLocal(deref( i.thisptr ), deg)) + + def nearest_time(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return such t that |self(t) - point| is minimized.""" + if interval is None: + return ( self.thisptr).nearestTime(deref( p.thisptr ), fr, to) + else: + return ( self.thisptr).nearestTime(deref( p.thisptr ), deref( interval.thisptr ) ) + + def all_nearest_times(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return all values of t that |self(t) - point| is minimized.""" + if interval is None: + return wrap_vector_double(( self.thisptr).allNearestTimes(deref( p.thisptr ), fr, to)) + else: + return wrap_vector_double(( self.thisptr).allNearestTimes(deref( p.thisptr ), + deref( interval.thisptr ) )) + + def portion(self, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return portion of curve, specified by endpoints or interval.""" + if interval is None: + return wrap_BezierCurve( deref( + ( self.thisptr).portion( fr, to ) + ) ) + else: + return wrap_BezierCurve( deref( + ( self.thisptr).portion(deref( interval.thisptr )) + ) ) + + def duplicate(self): + """Duplicate the curve.""" + return wrap_BezierCurve( deref( self.thisptr.duplicate())) + + def reverse(self): + """Return curve with reversed time.""" + return wrap_BezierCurve( deref( self.thisptr.reverse())) + + def transformed(self, t): + """Transform curve by affine transform.""" + cdef Affine at + if is_transform(t): + at = get_Affine(t) + return wrap_BezierCurve( deref( self.thisptr.transformed( at ))) + + def derivative(self): + """Return curve's derivative.""" + return wrap_BezierCurve( deref( self.thisptr.derivative())) + + def degrees_of_freedom(self): + """Return number of independent parameters needed to specify the curve.""" + return self.thisptr.degreesOfFreedom() + + def roots(self, Coord v, Dim2 d): + """Find time values where self(t)[d] == v.""" + return wrap_vector_double(self.thisptr.roots(v, d)) + + def length(self, Coord tolerance = 0.01): + """Return length of curve, within give tolerance.""" + return self.thisptr.length(tolerance) + + def point_at(self, Coord t): + """Equivalent to self(t).""" + return wrap_Point(self.thisptr.pointAt(t)) + + def point_and_derivatives(self, Coord t, unsigned int n): + """Return point and at least first n derivatives at point t in list.""" + return wrap_vector_point(self.thisptr.pointAndDerivatives(t, n)) + + def value_at(self, Coord t, Dim2 d): + """Equivalent to self(t)[d].""" + return self.thisptr.valueAt(t, d) + + def to_SBasis(self): + """Convert self to pair of SBasis functions.""" + return wrap_D2_SBasis(self.thisptr.toSBasis()) + + def winding(self, cy_Point p): + """Return winding number around specified point.""" + return ( self.thisptr).winding(deref(p.thisptr)) + + def unit_tangent_at(self, Coord t, int n = 3): + """Return tangent at self(t). + + Parameter n specifies how many derivatives to take into account.""" + return wrap_Point(( self.thisptr).unitTangentAt(t, n)) + +cdef cy_BezierCurve wrap_BezierCurve(BezierCurve p): + cdef vector[Point] points = make_vector_point([cy_Point(), cy_Point()]) + cdef BezierCurve * retp = create(p.controlPoints()) + cdef cy_BezierCurve r = cy_BezierCurve.__new__(cy_BezierCurve, [cy_Point(), cy_Point()]) + r.thisptr = retp + return r + + +cdef class cy_LineSegment(cy_BezierCurve): + + """Bezier curve with fixed order 1. + + This class inherits from BezierCurve. + + Corresponds to LineSegment in 2geom. BezierCurveN is not wrapped. + """ + + def __cinit__(self, cy_Point p0=None, + cy_Point p1=cy_Point()): + """Create new LineSegment from it's endpoints.""" + if p0 is None: + self.thisptr = new LineSegment() + else: + self.thisptr = new LineSegment( deref(p0.thisptr), + deref(p1.thisptr)) + + @classmethod + def from_beziers(cls, cy_Bezier b0, cy_Bezier b1): + """Create LineSegment from two linear beziers.""" + return wrap_LineSegment( LineSegment(deref(b0.thisptr), deref(b1.thisptr)) ) + + def subdivide(self, Coord t): + """Get two LineSegments, from 0 to t and from t to 1.""" + cdef pair[LineSegment, LineSegment] p = ( self.thisptr).subdivide(t) + return ( wrap_LineSegment(p.first), wrap_LineSegment(p.second) ) + + def duplicate(self): + """Duplicate the curve.""" + return wrap_LineSegment( deref( self.thisptr.duplicate())) + + def portion(self, double fr=0, double to=1, cy_Interval interval=None): + """Return portion of curve, specified by endpoints or interval.""" + if interval is None: + return wrap_LineSegment( deref( self.thisptr.portion( fr, to ) ) ) + else: + return wrap_LineSegment( deref( + ( self.thisptr).portion( deref( interval.thisptr )) + ) ) + + def reverse(self): + """Return curve with reversed time.""" + return wrap_LineSegment( deref( self.thisptr.reverse())) + + def transformed(self, t): + """Transform curve by affine transform.""" + cdef Affine at + if is_transform(t): + at = get_Affine(t) + return wrap_LineSegment( deref( self.thisptr.transformed( at ))) + + def derivative(self): + """Return curve's derivative.""" + return wrap_LineSegment( deref( self.thisptr.derivative())) + +cdef cy_LineSegment wrap_LineSegment(LineSegment p): + cdef LineSegment * retp = new LineSegment() + retp[0] = p + cdef cy_LineSegment r = cy_LineSegment.__new__(cy_LineSegment) + r.thisptr = retp + return r + + +cdef class cy_QuadraticBezier(cy_BezierCurve): + + """Bezier curve with fixed order 2. + + This class inherits from BezierCurve. + + Corresponds to QuadraticBezier in 2geom. BezierCurveN is not wrapped. + """ + + def __cinit__(self, cy_Point p0=None, + cy_Point p1=cy_Point(), + cy_Point p2=cy_Point()): + """Create new QuadraticBezier from three control points.""" + if p0 is None: + self.thisptr = new QuadraticBezier() + else: + self.thisptr = new QuadraticBezier( deref( p0.thisptr ), + deref( p1.thisptr ), + deref( p2.thisptr ) ) + + @classmethod + def from_beziers(cls, cy_Bezier b0, cy_Bezier b1): + """Create QuadraticBezier from two quadratic bezier functions.""" + return wrap_QuadraticBezier( QuadraticBezier(deref(b0.thisptr), deref(b1.thisptr)) ) + + def subdivide(self, Coord t): + """Get two QuadraticBeziers, from 0 to t and from t to 1.""" + cdef pair[QuadraticBezier, QuadraticBezier] p = ( self.thisptr).subdivide(t) + return ( wrap_QuadraticBezier(p.first), wrap_QuadraticBezier(p.second) ) + + def duplicate(self): + """Duplicate the curve.""" + return wrap_QuadraticBezier( deref( self.thisptr.duplicate())) + + def portion(self, double fr=0, double to=1, cy_Interval interval=None): + """Return portion of curve, specified by endpoints or interval.""" + if interval is None: + return wrap_QuadraticBezier( deref( self.thisptr.portion( fr, to ) ) ) + else: + return wrap_QuadraticBezier( deref( + ( self.thisptr).portion( deref( interval.thisptr )) + ) ) + + def reverse(self): + """Return curve with reversed time.""" + return wrap_QuadraticBezier( deref( self.thisptr.reverse())) + + def transformed(self, t): + """Transform curve by affine transform.""" + cdef Affine at + if is_transform(t): + at = get_Affine(t) + return wrap_QuadraticBezier( deref( self.thisptr.transformed( at ))) + + def derivative(self): + """Return curve's derivative.""" + return wrap_LineSegment( deref( self.thisptr.derivative())) + +cdef cy_QuadraticBezier wrap_QuadraticBezier(QuadraticBezier p): + cdef QuadraticBezier * retp = new QuadraticBezier() + retp[0] = p + cdef cy_QuadraticBezier r = cy_QuadraticBezier.__new__(cy_QuadraticBezier) + r.thisptr = retp + return r + +cdef class cy_CubicBezier(cy_BezierCurve): + + """Bezier curve with fixed order 2. + + This class inherits from BezierCurve. + + Corresponds to QuadraticBezier in 2geom. BezierCurveN is not wrapped. + """ + + def __cinit__(self, cy_Point p0=None, + cy_Point p1=cy_Point(), + cy_Point p2=cy_Point(), + cy_Point p3=cy_Point()): + """Create new CubicBezier from four control points.""" + if p0 is None: + self.thisptr = new CubicBezier() + else: + self.thisptr = new CubicBezier( deref( p0.thisptr ), + deref( p1.thisptr ), + deref( p2.thisptr ), + deref( p3.thisptr ) ) + + @classmethod + def from_beziers(cls, cy_Bezier b0, cy_Bezier b1): + """Create CubicBezier from two cubic bezier functions.""" + return wrap_CubicBezier( CubicBezier(deref(b0.thisptr), deref(b1.thisptr)) ) + + def subdivide(self, Coord t): + """Get two CubicBeziers, from 0 to t and from t to 1.""" + cdef pair[CubicBezier, CubicBezier] p = ( self.thisptr).subdivide(t) + return ( wrap_CubicBezier(p.first), wrap_CubicBezier(p.second) ) + + def duplicate(self): + """Duplicate the curve.""" + return wrap_CubicBezier( deref( self.thisptr.duplicate())) + + def portion(self, double fr=0, double to=1, cy_Interval interval=None): + """Return portion of curve, specified by endpoints or interval.""" + if interval is None: + return wrap_CubicBezier( deref( self.thisptr.portion( fr, to ) ) ) + else: + return wrap_CubicBezier( deref( + ( self.thisptr).portion( deref( interval.thisptr )) + ) ) + + def reverse(self): + """Return curve with reversed time.""" + return wrap_CubicBezier( deref( self.thisptr.reverse())) + + def transformed(self, t): + """Transform curve by affine transform.""" + cdef Affine at + if is_transform(t): + at = get_Affine(t) + return wrap_CubicBezier( deref( self.thisptr.transformed( at ))) + + def derivative(self): + """Return curve's derivative.""" + return wrap_QuadraticBezier( deref( self.thisptr.derivative())) + +cdef cy_CubicBezier wrap_CubicBezier(CubicBezier p): + cdef CubicBezier * retp = new CubicBezier() + retp[0] = p + cdef cy_CubicBezier r = cy_CubicBezier.__new__(cy_CubicBezier) + r.thisptr = retp + return r + +#~ cdef class cy_BezierCurveN(cy_BezierCurve): + + +cdef class cy_HLineSegment(cy_LineSegment): + + """Horizontal line segment. + + This class corresponds to HLineSegment in 2geom. + """ + + def __cinit__(self, cy_Point p0=None, cy_Point p1=cy_Point()): + """Create HLineSegment from it's endpoints.""" + if p0 is None: + self.thisptr = new HLineSegment() + else: + self.thisptr = new HLineSegment( deref( p0.thisptr ), deref( p1.thisptr ) ) + + @classmethod + def from_points(cls, cy_Point p0, cy_Point p1): + """Create HLineSegment from it's endpoints.""" + return wrap_HLineSegment( HLineSegment( deref(p0.thisptr), + deref(p1.thisptr)) ) + + @classmethod + def from_point_length(cls, cy_Point p, Coord length): + return wrap_HLineSegment( HLineSegment( deref( p.thisptr ), length ) ) + + def set_initial(self, cy_Point p): + """Set initial point of curve.""" + ( self.thisptr).setInitial( deref(p.thisptr) ) + + def set_final(self, cy_Point p): + """Set final point of curve.""" + ( self.thisptr).setFinal( deref(p.thisptr) ) + + def bounds_fast(self): + """Return bounding rectangle for curve. + + This method is fast, but does not guarantee to give smallest + rectangle. + """ + return wrap_Rect( ( self.thisptr).boundsFast() ) + + def bounds_exact(self): + """Return exact bounding rectangle for curve. + + This may take a while. + """ + return wrap_Rect( ( self.thisptr).boundsExact() ) + + def degrees_of_freedom(self): + """Return number of independent parameters needed to specify the curve.""" + return ( self.thisptr).degreesOfFreedom() + + def roots(self, Coord v, Dim2 d): + """Find time values where self(t)[d] == v.""" + return wrap_vector_double( ( self.thisptr).roots(v, d) ) + + def nearest_time(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return such t that |self(t) - point| is minimized.""" + if interval is None: + return ( self.thisptr).nearestTime(deref( p.thisptr ), fr, to) + else: + return ( self.thisptr).nearestTime(deref( p.thisptr ), + deref( ( interval.thisptr ) ) ) + + def point_at(self, Coord t): + """Equivalent to self(t).""" + return wrap_Point(( self.thisptr).pointAt(t)) + + def value_at(self, Coord t, Dim2 d): + """Equivalent to self(t)[d].""" + return ( self.thisptr).valueAt(t, d) + + def point_and_derivatives(self, Coord t, unsigned n): + """Return point and at least first n derivatives at point t in list.""" + return wrap_vector_point( ( self.thisptr).pointAndDerivatives(t, n) ) + + def get_Y(self): + """Get distance of self from y-axis.""" + return ( self.thisptr).getY() + + def set_initial_X(self, Coord x): + """Set initial point's X coordinate.""" + ( self.thisptr).setInitialX(x) + + def set_final_X(self, Coord x): + """Set final point's X coordinate.""" + ( self.thisptr).setFinalX(x) + + def set_Y(self, Coord y): + """Set Y coordinate of points.""" + ( self.thisptr).setY(y) + + def subdivide(self, Coord t): + """Return two HLineSegments subdivided at t.""" + cdef pair[HLineSegment, HLineSegment] p = ( self.thisptr).subdivide(t) + return (wrap_HLineSegment(p.first), wrap_HLineSegment(p.second)) + + def duplicate(self): + """Duplicate the curve.""" + return wrap_HLineSegment( deref( self.thisptr.duplicate()) ) + + def portion(self, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return portion of curve, specified by endpoints or interval.""" + if interval is None: + return wrap_HLineSegment( deref( self.thisptr.portion( fr, to ) ) ) + else: + return wrap_HLineSegment( deref( + ( self.thisptr).portion( deref( interval.thisptr ) ) + ) ) + + def reverse(self): + """Return curve with reversed time.""" + return wrap_HLineSegment( deref( self.thisptr.reverse()) ) + + def transformed(self, t): + """Transform curve by affine transform.""" + cdef Affine at + if is_transform(t): + at = get_Affine(t) + return wrap_LineSegment( deref( self.thisptr.transformed( at )) ) + + def derivative(self): + """Return curve's derivative.""" + return wrap_HLineSegment( deref( self.thisptr.derivative()) ) + +cdef cy_HLineSegment wrap_HLineSegment(HLineSegment p): + cdef HLineSegment * retp = new HLineSegment() + retp[0] = p + cdef cy_HLineSegment r = cy_HLineSegment.__new__(cy_HLineSegment) + r.thisptr = retp + return r + +cdef class cy_VLineSegment(cy_LineSegment): + + """Vertical line segment. + + This class corresponds to HLineSegment in 2geom. + """ + + def __cinit__(self, cy_Point p0=None, cy_Point p1=cy_Point()): + """Create VLineSegment from it's endpoints.""" + if p0 is None: + self.thisptr = new VLineSegment() + else: + self.thisptr = new VLineSegment( deref( p0.thisptr ), deref( p1.thisptr ) ) + + @classmethod + def from_points(cls, cy_Point p0, cy_Point p1): + """Create VLineSegment from it's endpoints.""" + return wrap_VLineSegment( VLineSegment( deref(p0.thisptr), + deref(p1.thisptr)) ) + + @classmethod + def from_point_length(cls, cy_Point p, Coord length): + return wrap_VLineSegment( VLineSegment( deref( p.thisptr ), length ) ) + + def set_initial(self, cy_Point p): + """Set initial point of curve.""" + ( self.thisptr).setInitial( deref(p.thisptr) ) + + def set_final(self, cy_Point p): + """Set final point of curve.""" + ( self.thisptr).setFinal( deref(p.thisptr) ) + + def bounds_fast(self): + """Return bounding rectangle for curve. + + This method is fast, but does not guarantee to give smallest + rectangle. + """ + return wrap_Rect( ( self.thisptr).boundsFast() ) + + def bounds_exact(self): + """Return exact bounding rectangle for curve. + + This may take a while. + """ + return wrap_Rect( ( self.thisptr).boundsExact() ) + + def degrees_of_freedom(self): + """Return number of independent parameters needed to specify the curve.""" + return ( self.thisptr).degreesOfFreedom() + + def roots(self, Coord v, Dim2 d): + """Find time values where self(t)[d] == v.""" + return wrap_vector_double( ( self.thisptr).roots(v, d) ) + + def nearest_time(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return such t that |self(t) - point| is minimized.""" + if interval is None: + return ( self.thisptr).nearestTime(deref( p.thisptr ), fr, to) + else: + return ( self.thisptr).nearestTime(deref( p.thisptr ), + deref( ( interval.thisptr ) ) ) + + def point_at(self, Coord t): + """Equivalent to self(t).""" + return wrap_Point(( self.thisptr).pointAt(t)) + + def value_at(self, Coord t, Dim2 d): + """Equivalent to self(t)[d].""" + return ( self.thisptr).valueAt(t, d) + + def point_and_derivatives(self, Coord t, unsigned n): + """Return point and at least first n derivatives at point t in list.""" + return wrap_vector_point( ( self.thisptr).pointAndDerivatives(t, n) ) + + def get_X(self): + return ( self.thisptr).getX() + + def set_initial_Y(self, Coord y): + ( self.thisptr).setInitialY(y) + + def set_final_Y(self, Coord y): + ( self.thisptr).setFinalY(y) + + def set_X(self, Coord x): + ( self.thisptr).setX(x) + + def subdivide(self, Coord t): + """Return two HLineSegments subdivided at t.""" + cdef pair[VLineSegment, VLineSegment] p = ( self.thisptr).subdivide(t) + return (wrap_VLineSegment(p.first), wrap_VLineSegment(p.second)) + + def duplicate(self): + """Duplicate the curve.""" + return wrap_VLineSegment( deref( self.thisptr.duplicate()) ) + + def portion(self, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return portion of curve, specified by endpoints or interval.""" + if interval is None: + return wrap_VLineSegment( deref( self.thisptr.portion( fr, to ) ) ) + else: + return wrap_VLineSegment( deref( + ( self.thisptr).portion( deref( interval.thisptr ) ) + ) ) + + def reverse(self): + """Return curve with reversed time.""" + return wrap_VLineSegment( deref( self.thisptr.reverse()) ) + + def transformed(self, t): + """Transform curve by affine transform.""" + cdef Affine at + if is_transform(t): + at = get_Affine(t) + return wrap_LineSegment( deref( self.thisptr.transformed( at )) ) + + def derivative(self): + """Return curve's derivative.""" + return wrap_VLineSegment( deref( self.thisptr.derivative()) ) + +cdef cy_VLineSegment wrap_VLineSegment(VLineSegment p): + cdef VLineSegment * retp = new VLineSegment() + retp[0] = p + cdef cy_VLineSegment r = cy_VLineSegment.__new__(cy_VLineSegment) + r.thisptr = retp + return r + +cdef class cy_EllipticalArc: + + """Elliptical arc. + + Corresponds to EllipticalArc class in 2geom. + """ + + def __cinit__(self, cy_Point ip = cy_Point(0, 0), + Coord rx = 0, + Coord ry = 0, + Coord rot_angle = 0, + bint large_arc = True, + bint sweep = True, + cy_Point fp = cy_Point(0, 0)): + """Create Elliptical arc from it's major axis and rays.""" + self.thisptr = new EllipticalArc(deref( ip.thisptr ), rx, ry, rot_angle, large_arc, sweep, deref( fp.thisptr )) + + def __dealloc__(self): + del self.thisptr + + def __call__(self, Coord t): + """Get point at time value t.""" + return wrap_Point( deref( self.thisptr)(t) ) + #Curve methods + + def length(self, Coord tolerance = 0.01): + """Return length of curve, within give tolerance.""" + return ( self.thisptr).length(tolerance) + + #AngleInterval methods + + def initial_angle(self): + """Get initial Angle of arc.""" + return wrap_Angle(( self.thisptr).initialAngle()) + + def final_angle(self): + """Get final Angle of arc.""" + return wrap_Angle(( self.thisptr).finalAngle()) + + def angle_at(self, Coord t): + """Get Angle from time value.""" + return wrap_Angle(( self.thisptr).angleAt(t)) + + def contains(self, cy_Angle a): + """Test whether arc contains angle.""" + return ( self.thisptr).contains(deref( a.thisptr )) + + def extent(self): + """Get extent of angle interval.""" + return ( self.thisptr).extent() + + def angle_interval(self): + """Get underlying angle Interval.""" + return wrap_Interval(self.thisptr.angleInterval()) + + def rotation_angle(self): + """Return rotation angle of major axis.""" + return wrap_Angle(self.thisptr.rotationAngle()) + + def ray(self, Dim2 d): + """Access rays with X or Y.""" + return self.thisptr.ray(d) + + def rays(self): + """Get rays as a point.""" + return wrap_Point(self.thisptr.rays()) + + def large_arc(self): + """Check if large arc flag is set.""" + return self.thisptr.largeArc() + + def sweep(self): + """Check if sweep flag is set.""" + return self.thisptr.sweep() + + def chord(self): + """Return chord of arc.""" + return wrap_LineSegment(self.thisptr.chord()) + + def set(self, cy_Point ip, double rx, double ry, double rot_angle, bint large_arc, bint sweep, cy_Point fp): + """Set arc's properties.""" + self.thisptr.set(deref( ip.thisptr ), rx, ry, rot_angle, large_arc, sweep, deref( fp.thisptr )) + + def set_extremes(self, cy_Point ip, cy_Point fp): + """Set endpoints of arc.""" + self.thisptr.setExtremes(deref( ip.thisptr ), deref( fp.thisptr )) + + def center(self, coordinate=None): + """Return center of ellipse, or it's coordinate.""" + if coordinate is None: + return wrap_Point(self.thisptr.center()) + else: + return self.thisptr.center(int(coordinate)) + + def sweep_angle(self): + """Equivalent to self.extent()""" + return self.thisptr.sweepAngle() + + def contains_angle(self, Coord angle): + """Test whether arc contains angle. + + Equivalent to self.contains(Angle(a)) + """ + return self.thisptr.containsAngle(angle) + + def point_at_angle(self, Coord a): + """Get point of arc at specified angle.""" + return wrap_Point(self.thisptr.pointAtAngle(a)) + + def value_at_angle(self, Coord a, Dim2 d): + """Equivalent to self.point_at_angle(a)[d]""" + return self.thisptr.valueAtAngle(a, d) + + def unit_circle_transform(self): + """Get Affine transform needed to transform unit circle to ellipse.""" + return wrap_Affine(self.thisptr.unitCircleTransform()) + + def is_SVG_compliant(self): + """Check whether arc is SVG compliant + + SVG has special specification for degenerated ellipse.""" + return self.thisptr.isSVGCompliant() + + def subdivide(self, Coord t): + """Return two arcs, subdivided at time t.""" + cdef pair[EllipticalArc, EllipticalArc] r = self.thisptr.subdivide(t) + return (wrap_EllipticalArc(r.first), wrap_EllipticalArc(r.second)) + + def initial_point(self): + """Get self(0).""" + return wrap_Point(self.thisptr.initialPoint()) + + def final_point(self): + """Get self(1).""" + return wrap_Point(self.thisptr.finalPoint()) + + def duplicate(self): + """Duplicate the curve.""" + return wrap_EllipticalArc( deref( self.thisptr.duplicate()) ) + + def set_initial(self, cy_Point p): + """Set initial point of curve.""" + self.thisptr.setInitial(deref( p.thisptr )) + + def set_final(self, cy_Point p): + """Set final point of curve.""" + self.thisptr.setFinal(deref( p.thisptr )) + + def is_degenerate(self): + """Curve is degenerate if its length is zero.""" + return self.thisptr.isDegenerate() + + def bounds_fast(self): + """Return bounding rectangle for curve. + + This method is fast, but does not guarantee to give smallest + rectangle. + """ + return wrap_Rect(self.thisptr.boundsFast()) + + def bounds_exact(self): + """Return exact bounding rectangle for curve. + + This may take a while. + """ + return wrap_Rect(self.thisptr.boundsExact()) + + def bounds_local(self, cy_OptInterval i, unsigned int deg): + """Return bounding rectangle to portion of curve.""" + return wrap_OptRect(self.thisptr.boundsLocal(deref( i.thisptr ), deg)) + + def roots(self, double v, Dim2 d): + """Find time values where self(t)[d] == v.""" + return wrap_vector_double(self.thisptr.roots(v, d)) + + def nearest_time(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return such t that |self(t) - point| is minimized.""" + if interval is None: + return self.thisptr.nearestTime(deref( p.thisptr ), fr, to) + else: + return ( self.thisptr).nearestTime(deref( p.thisptr ), + deref( interval.thisptr ) ) + + def all_nearest_times(self, cy_Point p, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return all values of t that |self(t) - point| is minimized.""" + if interval is None: + return wrap_vector_double( ( self.thisptr).allNearestTimes(deref( p.thisptr ), fr, to)) + else: + return wrap_vector_double( ( self.thisptr).allNearestTimes(deref( p.thisptr ), deref( interval.thisptr ) )) + + def degrees_of_freedom(self): + """Return number of independent parameters needed to specify the curve.""" + return self.thisptr.degreesOfFreedom() + + def derivative(self): + """Return curve's derivative.""" + return wrap_EllipticalArc( deref( self.thisptr.derivative()) ) + + def transformed(self, cy_Affine m): + """Transform curve by affine transform.""" + return wrap_EllipticalArc( deref( self.thisptr.transformed(deref( m.thisptr ))) ) + + def point_and_derivatives(self, Coord t, unsigned int n): + """Return point and at least first n derivatives at point t in list.""" + return wrap_vector_point(self.thisptr.pointAndDerivatives(t, n)) + + def to_SBasis(self): + """Convert to pair of SBasis polynomials.""" + cdef D2[SBasis] r = self.thisptr.toSBasis() + return ( wrap_SBasis(r[0]), wrap_SBasis(r[1]) ) + + def value_at(self, Coord t, Dim2 d): + """Equivalent to self(t)[d].""" + return self.thisptr.valueAt(t, d) + + def point_at(self, Coord t): + """Equivalent to self(t).""" + return wrap_Point(self.thisptr.pointAt(t)) + + + def portion(self, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return portion of curve, specified by endpoints or interval.""" + if interval is None: + return wrap_EllipticalArc( deref( self.thisptr.portion( fr, to ) ) ) + else: + return wrap_EllipticalArc( deref( ( self.thisptr).portion( deref( interval.thisptr ) ) ) ) + + def reverse(self): + """Return curve with reversed time.""" + return wrap_EllipticalArc( deref( self.thisptr.reverse()) ) + + def winding(self, cy_Point p): + """Return winding number around specified point.""" + return ( self.thisptr).winding(deref(p.thisptr)) + + def unit_tangent_at(self, Coord t, int n = 3): + """Return tangent at self(t). + + Parameter n specifies how many derivatives to take into account.""" + return wrap_Point(( self.thisptr).unitTangentAt(t, n)) + +cdef cy_EllipticalArc wrap_EllipticalArc(EllipticalArc p): + cdef EllipticalArc * retp = new EllipticalArc() + retp[0] = p + cdef cy_EllipticalArc r = cy_EllipticalArc.__new__(cy_EllipticalArc) + r.thisptr = retp + return r + +#TODO move somewhere else + +cdef object wrap_vector_interval(vector[Interval] v): + r = [] + cdef unsigned int i + for i in range(v.size()): + r.append( wrap_Interval(v[i])) + return r + + +cdef bint is_Curve(object c): + return any([ + isinstance(c, cy_Curve), + isinstance(c, cy_SBasisCurve), + isinstance(c, cy_BezierCurve), + isinstance(c, cy_EllipticalArc)]) + +cdef Curve * get_Curve_p(object c): + if isinstance(c, cy_Curve): + return ( c).thisptr + elif isinstance(c, cy_SBasisCurve): + return ( c).thisptr + elif isinstance(c, cy_BezierCurve): + return ( c).thisptr + elif isinstance(c, cy_EllipticalArc): + return ( c).thisptr + return NULL + diff --git a/src/cython/_cy_path.pxd b/src/cython/_cy_path.pxd new file mode 100644 index 0000000..2d41581 --- /dev/null +++ b/src/cython/_cy_path.pxd @@ -0,0 +1,124 @@ +from _common_decl cimport * + +from libcpp.vector cimport vector +from libcpp.pair cimport pair + +from _cy_rectangle cimport Interval, OptInterval, Rect, OptRect +from _cy_affine cimport Affine +from _cy_curves cimport Curve, cy_Curve, wrap_Curve_p +from _cy_curves cimport SBasis, cy_SBasis + +from _cy_primitives cimport Point, cy_Point, wrap_Point + + +cdef extern from "2geom/d2.h" namespace "Geom": + cdef cppclass D2[T]: + D2() + D2(T &, T &) + T& operator[](unsigned i) + +#~ ctypedef int BaseIteratorConst "BaseIterator" + +cdef extern from "2geom/path.h" namespace "Geom::PathInternal": + cdef cppclass BaseIterator[C, P]: + Curve & c_item "operator*" () + C & c_next "operator++" () + C & c_next "operator++" (int) + bint operator==(BaseIterator[C, P]) + + + cdef cppclass ConstIterator: + ConstIterator() + cdef cppclass Iterator: + Iterator() + ConstIterator & operator() + + cdef cppclass BaseIteratorConst "Geom::PathInternal::BaseIterator": +#~ Curve & c_item "operator*" () + ConstIterator & c_next "operator++" () + ConstIterator & c_next "operator++" (int) +#~ bint operator==(BaseIterator[C, P]) + + +cdef extern from "2geom/path.h" namespace "Geom::Path": + cdef enum Stitching: + c_NO_STITCHING "Path::NO_STITCHING" = 0, + c_STITCH_DISCONTINUOUS "Path::STITCH_DISCONTINUOUS" + +cdef extern from "2geom/path.h" namespace "Geom": + cdef cppclass Path: + Path(Path &) + Path(Point) + Path(ConstIterator &, ConstIterator &, bint) + void swap(Path &) + Curve & operator[](unsigned int) +#~ Curve & at_index(unsigned int) +#~ ::boost::shared_ptr get_ref_at_index(unsigned int) + Curve & front() + Curve & back() + Curve & back_open() + Curve & back_closed() + Curve & back_default() + ConstIterator begin_const "begin" () + ConstIterator end() + Iterator begin() +#~ Iterator end() + ConstIterator end_open() + ConstIterator end_closed() + ConstIterator end_default() + size_t size_open() + size_t size_closed() + size_t size_default() + size_t size() + size_t max_size() + bint empty() + bint closed() + void close(bint) + OptRect boundsFast() + OptRect boundsExact() +#~ Piecewise > toPwSb() + bint operator==(Path &) + bint operator!=(Path &) + Path operator*(Affine &) +#~ Path & operator*=(Affine &) + Point pointAt(double) + double valueAt(double, Dim2) + Point operator()(double) except + + vector[double] roots(double, Dim2) + vector[double] allNearestTimes(Point &, double, double) + vector[double] allNearestTimes(Point &) + vector[double] nearestTimePerCurve(Point &) + double nearestTime(Point &, double, double, double *) + double nearestTime(Point &, double *) + void appendPortionTo(Path &, double, double) + Path portion(double, double) + Path portion(Interval) + Path reversed() + void insert(Iterator &, Curve &, Stitching) except + + void insert(Iterator &, ConstIterator &, ConstIterator &, Stitching) + void clear() + void erase(Iterator &, Stitching) + void erase(Iterator &, Iterator &, Stitching) + void erase_last() + void replace(Iterator &, Curve &, Stitching) + void replace(Iterator &, Iterator &, Curve &, Stitching) + void replace(Iterator &, ConstIterator &, ConstIterator &, Stitching) + void replace(Iterator &, Iterator &, ConstIterator &, ConstIterator &, Stitching) + void start(Point) + Point initialPoint() + Point finalPoint() + void setInitial(Point &) + void setFinal(Point &) + void append(Curve &, Stitching) + void append(D2[SBasis] &, Stitching) + void append(Path &, Stitching) + void stitchTo(Point &) + +cdef class cy_Path: +#~ NO_STITCHING = c_NO_STITCHING +#~ STITCH_DISCONTINUOUS = c_STITCH_DISCONTINUOUS + cdef Path* thisptr + cdef ConstIterator _const_iterator_at_index(self, int i) + cdef Iterator _iterator_at_index(self, int i) + +cdef cy_Path wrap_Path(Path p) diff --git a/src/cython/_cy_path.pyx b/src/cython/_cy_path.pyx new file mode 100644 index 0000000..9f3f88e --- /dev/null +++ b/src/cython/_cy_path.pyx @@ -0,0 +1,457 @@ +from cython.operator cimport dereference as deref +from numbers import Number +from _cy_rectangle cimport cy_OptInterval, wrap_OptInterval, wrap_Rect, OptRect, wrap_OptRect +from _cy_rectangle cimport cy_Interval, wrap_Interval + +from _cy_affine cimport cy_Affine, wrap_Affine, get_Affine, is_transform + +from _cy_curves cimport is_Curve, get_Curve_p + + +cdef class cy_Iterator: + cdef Iterator* thisptr + cdef ConstIterator* startptr + cdef ConstIterator* endptr + + def __cinit__(self): + self.thisptr = new Iterator() + + def __dealloc__(self): + del self.thisptr + + def __iter__(self): + return self + + def __next__(self): + if deref( self.endptr) == deref( self.thisptr): + raise StopIteration + cdef Curve * r = &( self.thisptr).c_item() + ( self.thisptr).c_next() + return wrap_Curve_p ( r ) + + + + +cdef cy_Iterator wrap_Iterator(Iterator i, ConstIterator starti, ConstIterator endi): + cdef Iterator * retp = new Iterator() + retp[0] = i + cdef cy_Iterator r = cy_Iterator.__new__(cy_Iterator) + r.thisptr = retp + + cdef ConstIterator * endp = new ConstIterator() + endp[0] = endi + r.endptr = endp + + cdef ConstIterator * startp = new ConstIterator() + startp[0] = starti + r.startptr = startp + + return r + +cdef class cy_Path: + + """Path is a ordered sequence of curves. + + You can iterate this class, accessing curves one at time, or access + them using indices. + + Two constants, NO_STITCHING and STITCH_DISCONTINUOUS are members of + Path namespace, and are used to specify type of stitching, if + necessary. + + Path is either open or closed, but in both cases carries closing + segment, connecting last and first point. + + Corresponds to Path class in 2geom. + """ + + NO_STITCHING = c_NO_STITCHING + STITCH_DISCONTINUOUS = c_STITCH_DISCONTINUOUS + + def __cinit__(self, cy_Point p=cy_Point()): + """Create Path containing only one point.""" + self.thisptr = new Path(deref( p.thisptr )) + + @classmethod + def fromList(cls, l, Stitching stitching=NO_STITCHING, closed=False): + """Create path from list of curves. + + Specify stithing and closed flag in additional arguments. + """ + p = cy_Path() + for curve in l: + p.append_curve(curve, stitching) + p.close(closed) + return p + + @classmethod + def fromPath(cls, cy_Path p, fr=-1, to = 1, bint closed=False): + """Create path copying another's path curves. + + Either copy all curves, or ones from + fr - index of first curve copied + to + to - index of first curve not copied. + + Also takes closed flag. + """ + if fr == -1: + return wrap_Path( Path(p.thisptr.begin_const(), p.thisptr.end_default(), closed) ) + else: + return wrap_Path( Path(p._const_iterator_at_index(fr), p._const_iterator_at_index(to), closed) ) + + def __dealloc__(self): + del self.thisptr + + def __getitem__(self, unsigned int i): + """Get curve with index i.""" + cdef Curve * r = & deref(self.thisptr)[i] + return wrap_Curve_p(r) + + def __call__(self, double t): + """Evaluate path at time t. + + Note: t can be greater than 1 here, it can go to self.size() + """ + return wrap_Point(deref( self.thisptr ) (t) ) + + def __richcmp__(cy_Path self, cy_Path other, int op): + if op == 2: + return deref( self.thisptr ) == deref( other.thisptr ) + elif op == 3: + return deref( self.thisptr ) != deref( other.thisptr ) + + def __mul__(cy_Path self, m): + """Transform path with a transform.""" + cdef Affine at + if is_transform(m): + at = get_Affine(m) + return wrap_Path( deref(self.thisptr) * at ) + + #This is not the fastest way, but it's pretty nice from python's perspective + #Anyway, I would expect that performance hit is minimal, since i is generally really small + cdef ConstIterator _const_iterator_at_index(self, int i): + cdef ConstIterator ci = self.thisptr.begin_const() + cdef ConstIterator * cip = &ci + for ii in range(i): + ( cip).c_next() + return ci + + cdef Iterator _iterator_at_index(self, int i): + cdef Iterator ci = self.thisptr.begin() + cdef Iterator * cip = &ci + for ii in range(i): + ( cip).c_next() + return ci + + def swap(self, cy_Path other): + """Swap curves with another path.""" + self.thisptr.swap(deref( other.thisptr )) + +#This is the same as __getitem__ +#~ def at_index(self, unsigned int i): +#~ return wrap_Curve(self.thisptr.at_index(i)) + + def front(self): + """Get first curve.""" + #this is AFAIK the shortest way to do this + cdef Curve * r = &self.thisptr.front() + return wrap_Curve_p(r) + + def back(self): + """Same as back_open.""" + cdef Curve * r = &self.thisptr.back() + return wrap_Curve_p(r) + + def back_open(self): + """Get last curve, treating self as open.""" + cdef Curve * r = &self.thisptr.back_open() + return wrap_Curve_p(r) + + def back_closed(self): + """Get last curve, treating self as closed.""" + cdef Curve * r = &self.thisptr.back_closed() + return wrap_Curve_p(r) + + def back_default(self): + """Get last curve.""" + cdef Curve * r = &self.thisptr.back_default() + return wrap_Curve_p(r) + + def curves(self): + """Same as curves_open""" + return wrap_Iterator(self.thisptr.begin(), self.thisptr.begin_const(), self.thisptr.end()) + + def curves_open(self): + """Return all curves as iterable, treating self as open.""" + return wrap_Iterator(self.thisptr.begin(), self.thisptr.begin_const(), self.thisptr.end_open()) + + def curves_closed(self): + """Return all curves as iterable, treating self as closed.""" + return wrap_Iterator(self.thisptr.begin(), self.thisptr.begin_const(), self.thisptr.end_closed()) + + def curves_default(self): + """Return all curves as iterable.""" + return wrap_Iterator(self.thisptr.begin(), self.thisptr.begin_const(), self.thisptr.end_default()) + + def __iter__(self): + return self.curves_default() + + def size_open(self): + """Get number of curves, treating self as open.""" + return self.thisptr.size_open() + + def size_closed(self): + """Get number of curves, treating self as closed.""" + return self.thisptr.size_closed() + + def size_default(self): + """Get number of curves.""" + return self.thisptr.size_default() + + def size(self): + """Same as size_open.""" + return self.thisptr.size() + +#Does the same as size_open, which doesn't correspond with name. +#~ def max_size(self): +#~ return self.thisptr.max_size() + + def empty(self): + """Test whether path contains no curves.""" + return self.thisptr.empty() + + def closed(self): + """Return state of closed flag.""" + return self.thisptr.closed() + + def close(self, bint closed): + """Set closed flag.""" + self.thisptr.close(closed) + + def bounds_fast(self): + """Return fast bounding rectangle for path. + + It's not guaranteed to give the tighest bound. + """ + return wrap_OptRect(self.thisptr.boundsFast()) + + def bounds_exact(self): + """Give the tighest bounding rectangle for path.""" + return wrap_OptRect(self.thisptr.boundsExact()) + +#~ def toPwSb(self): +#~ return wrap_Piecewise >(self.thisptr.toPwSb()) + + def point_at(self, double t): + """Same as self(t).""" + return wrap_Point(self.thisptr.pointAt(t)) + + def value_at(self, double t, Dim2 d): + """Same as self(t)[d].""" + return self.thisptr.valueAt(t, d) + + def __call__(self, double t): + """Evaluate path at time t. + + Equivalent to self[floor(t)](t-floor(t)) + """ + return wrap_Point(deref( self.thisptr ) (t) ) + + def roots(self, double v, Dim2 d): + """Find time values where self(t)[d] == v""" + return wrap_vector_double(self.thisptr.roots(v, d)) + + def all_nearest_times(self, cy_Point _point, double fr=-1, double to=1): + """Return all values of t that |self(t) - point| is minimized.""" + if fr == -1: + return wrap_vector_double(self.thisptr.allNearestTimes(deref( _point.thisptr ))) + return wrap_vector_double(self.thisptr.allNearestTimes(deref( _point.thisptr ), fr, to)) + + + def nearest_time_per_curve(self, cy_Point _point): + """Find nearest points, return one time value per each curve.""" + return wrap_vector_double(self.thisptr.nearestTimePerCurve(deref( _point.thisptr ))) + + def nearest_time(self, cy_Point _point, double fr=-1, double to=1):#, cy_double * distance_squared): + """Return such t that |self(t) - point| is minimized.""" + if fr == -1: + return self.thisptr.nearestTime(deref( _point.thisptr ), NULL) + return self.thisptr.nearestTime(deref( _point.thisptr ), fr, to, NULL) + + def nearest_time_and_dist_sq(self, cy_Point _point, double fr=-1, double to=1): + """Return such t that |self(t) - point| is minimized and square of that distance.""" + cdef double t, dist + if fr == -1: + t = self.thisptr.nearestTime(deref( _point.thisptr ), &dist ) + else: + t = self.thisptr.nearestTime(deref( _point.thisptr ), fr, to, &dist) + return (t, dist) + + def append_portion_to(self, cy_Path p, double f, double t): + """Append portion of path to self.""" + self.thisptr.appendPortionTo(deref( p.thisptr ), f, t) + + def portion(self, Coord fr=0, Coord to=1, cy_Interval interval=None): + """Return portion of curve between two time values. + + Alternatively use argument interval. + """ + if interval is None: + return wrap_Path(self.thisptr.portion(fr, to)) + else: + return wrap_Path(self.thisptr.portion(deref( interval.thisptr ))) + + def reversed(self): + """Return reversed curve.""" + return wrap_Path(self.thisptr.reversed()) + + def insert(self, int pos, curve, Stitching stitching=NO_STITCHING): + """Insert curve into position pos. + + Args: + pos: Position of inserted curve. + curve: Curve to insert. + stitching=NO_STITCHING + """ + cdef Curve * cptr = get_Curve_p(curve) + if cptr: + self.thisptr.insert( self._iterator_at_index(pos), deref( cptr ), stitching ) + else: + raise TypeError("passed curve is not C++ Curve") + + def insert_slice(self, int pos, cy_Path p, int first, int last, Stitching stitching=NO_STITCHING): + """Insert curves to position pos. + + Args: + pos: Position of inserted slice. + p: Path from which slice is inserted. + first: First inserted curve position (in p). + last: Fist not inserted curve position (in p). + stiching=NO_STITCHING + """ + self.thisptr.insert(self._iterator_at_index(pos), p._const_iterator_at_index(first), p._const_iterator_at_index(last), stitching) + + def clear(self): + """Clear all curves.""" + self.thisptr.clear() + + def erase(self, int pos, Stitching stitching=NO_STITCHING): + """Erase curve at position pos. + + Args: + pos: Position of erased curve. + stitching=NO_STITCHING + """ + self.thisptr.erase(self._iterator_at_index(pos), stitching) + + def erase_slice(self, int start, int end, Stitching stitching=NO_STITCHING): + """Erase curves with indices [start, end). + + Args: + start, end: Curves with indices start...end-1 are erased + stitching=NO_STITCHING + """ + self.thisptr.erase(self._iterator_at_index(start), self._iterator_at_index(end), stitching) + + def erase_last(self): + """Erase last curve.""" + self.thisptr.erase_last() + + def replace(self, int replaced, curve, Stitching stitching=NO_STITCHING): + """Replace curve at position replaced with another curve. + + Args: + replaced: Position of replaced curve. + curve: New curve. + stitching=NO_STITCHING + """ + cdef Curve * cptr = get_Curve_p(curve) + if cptr: + self.thisptr.replace(self._iterator_at_index(replaced), deref( cptr ), stitching) + else: + raise TypeError("passed curve is not C++ Curve") + + def replace_slice(self, int first_replaced, int last_replaced, curve, Stitching stitching=NO_STITCHING): + """Replace slice of curves by new curve. + + Args: + first_replaced, last_replace: Curves with indices + first_replaced ... last_replaced + curve: New curve. + stitching=NO_STITCHING + """ + cdef Curve * cptr = get_Curve_p(curve) + if cptr: + self.thisptr.replace(self._iterator_at_index(first_replaced), self._iterator_at_index(last_replaced), deref( cptr ), stitching) + else: + raise TypeError("passed curve is not C++ Curve") + +#How to implement this nicely? +#~ def replaceByList(self, int replaced, cy_ConstIterator first, cy_ConstIterator last, Stitching stitching): +#~ self.thisptr.replace(deref( replaced.thisptr ), deref( first.thisptr ), deref( last.thisptr ), stitching) +#~ def replace(self, cy_Iterator first_replaced, cy_Iterator last_replaced, cy_ConstIterator first, cy_ConstIterator last, Stitching stitching): +#~ self.thisptr.replace(deref( first_replaced.thisptr ), deref( last_replaced.thisptr ), deref( first.thisptr ), deref( last.thisptr ), stitching) + + def start(self, cy_Point p): + """Erase all curves and set first point.""" + self.thisptr.start(deref( p.thisptr )) + + def initial_point(self): + """Get initial point.""" + return wrap_Point(self.thisptr.initialPoint()) + + def final_point(self): + """Get final point.""" + return wrap_Point(self.thisptr.finalPoint()) + + def set_initial(self, cy_Point p): + """Set initial point.""" + self.thisptr.setInitial(deref( p.thisptr )) + + def set_final(self, cy_Point p): + """Set final point.""" + self.thisptr.setFinal(deref( p.thisptr )) + + def append_curve(self, curve, Stitching stitching=NO_STITCHING): + """Append curve to path. + + Args: + curve: Curve to append. + stitching=NO_STITCHING + """ + cdef Curve * cptr = get_Curve_p(curve) + if cptr: + self.thisptr.append( deref( cptr ), stitching) + else: + raise TypeError("passed curve is not C++ Curve") + + def append_SBasis(self, cy_SBasis x, cy_SBasis y, Stitching stitching=NO_STITCHING): + """Append two SBasis functions to path. + + Args: + x, y: SBasis functions to append. + stitching=NO_STITCHING + """ + cdef D2[SBasis] sb = D2[SBasis]( deref(x.thisptr), deref(y.thisptr) ) + self.thisptr.append(sb, stitching) + + def append_path(self, cy_Path other, Stitching stitching=NO_STITCHING): + """Append another path to path. + + Args: + other: Path to append. + stitching=NO_STITCHING + """ + self.thisptr.append(deref( other.thisptr ), stitching) + + def stitch_to(self, cy_Point p): + """Set last point to p, creating stitching segment to it.""" + self.thisptr.stitchTo(deref( p.thisptr )) + +cdef cy_Path wrap_Path(Path p): + cdef Path * retp = new Path(Point()) + retp[0] = p + cdef cy_Path r = cy_Path.__new__(cy_Path) + r.thisptr = retp + return r diff --git a/src/cython/_cy_primitives.pxd b/src/cython/_cy_primitives.pxd new file mode 100644 index 0000000..87df1c6 --- /dev/null +++ b/src/cython/_cy_primitives.pxd @@ -0,0 +1,237 @@ +from _common_decl cimport * + + +cdef extern from "2geom/affine.h" namespace "Geom": + cdef cppclass Affine: + pass + cdef cppclass Translate + cdef cppclass Scale + cdef cppclass Rotate + cdef cppclass VShear + cdef cppclass HShear + cdef cppclass Zoom + + +cdef extern from "2geom/angle.h" namespace "Geom": + cdef cppclass Angle: + Angle() + Angle(Coord) + Angle(Point) + Coord radians() + Coord radians0() + Coord degrees() + Coord degreesClock() + + Coord operator() + Angle &operator+(Angle &) + Angle &operator-(Angle &) + bint operator==(Angle &) + bint operator!=(Angle &) + + Coord rad_from_deg(Coord) + Coord deg_from_rad(Coord) + +cdef extern from "2geom/angle.h" namespace "Geom::Angle": + Angle from_radians(Coord d) + Angle from_degrees(Coord d) + Angle from_degrees_clock(Coord d) + +cdef class cy_Angle: + cdef Angle* thisptr + +cdef cy_Angle wrap_Angle(Angle) + + +cdef extern from "2geom/angle.h" namespace "Geom": + cdef cppclass AngleInterval: + AngleInterval(AngleInterval &) + AngleInterval(Angle &, Angle &, bint) + AngleInterval(double, double, bint) + Angle & initialAngle() + Angle & finalAngle() + bint isDegenerate() + Angle angleAt(Coord) + Angle operator()(Coord) + bint contains(Angle &) + Coord extent() + + +cdef extern from "2geom/point.h" namespace "Geom": + cdef cppclass Point: + Point() + Point(Coord, Coord) + Coord length() + Point ccw() + Point cw() + Coord x() + Coord y() + IntPoint round() + IntPoint floor() + IntPoint ceil() + + bint isFinite() + bint isZero() + bint isNormalized(Coord) + + bint operator==(Point &) + bint operator!=(Point &) + bint operator<(Point &) + bint operator>(Point &) + bint operator<=(Point &) + bint operator>=(Point &) + + Coord &operator[](int) + Point operator-() + Point &operator+(Point &) + Point &operator-(Point &) + Point &operator*(Coord) + Point &operator/(Coord) + + Point &operator*(Affine &) + Point &operator*(Translate &) + Point &operator*(Scale &) + Point &operator*(Rotate &) + Point &operator*(HShear &) + Point &operator*(VShear &) + Point &operator*(Zoom &) + + Coord L2(Point &) + Coord L2sq(Point &) + + bint are_near(Point &, Point &, double) + + Point middle_point(Point &, Point &) + Point rot90(Point &) + Point lerp(double, Point &, Point &) + + Coord dot(Point &, Point &) + Coord cross(Point &, Point &) + Coord distance (Point &, Point &) + Coord distanceSq (Point &, Point &) + + Point unit_vector(Point &) + Coord L1(Point &) + Coord LInfty(Point &) + bint is_zero(Point &) + bint is_unit_vector(Point &) + double atan2(Point &) + double angle_between(Point &, Point &) + Point abs(Point &) + Point constrain_angle(Point &, Point &, unsigned int, Point &) + +cdef extern from "2geom/point.h" namespace "Geom::Point": + Point polar(Coord angle, Coord radius) + +cdef class cy_Point: + cdef Point* thisptr + +cdef cy_Point wrap_Point(Point p) +cdef object wrap_vector_point(vector[Point] v) +cdef vector[Point] make_vector_point(object l) + + +cdef extern from "2geom/int-point.h" namespace "Geom": + cdef cppclass IntPoint: + IntPoint() + IntPoint(IntCoord, IntCoord) + IntPoint(IntPoint &) + IntCoord operator[](unsigned int) + IntCoord x() + IntCoord y() + #why doesn't IntPoint have unary -? + IntPoint & operator+(IntPoint &) + IntPoint & operator-(IntPoint &) + bint operator==(IntPoint &) + bint operator!=(IntPoint &) + bint operator<=(IntPoint &) + bint operator>=(IntPoint &) + bint operator>(IntPoint &) + bint operator<(IntPoint &) + +cdef class cy_IntPoint: + cdef IntPoint* thisptr + +cdef cy_IntPoint wrap_IntPoint(IntPoint p) + + +cdef extern from "2geom/curve.h" namespace "Geom": + cdef cppclass Curve + +cdef extern from "2geom/bezier.h" namespace "Geom": + cdef cppclass LineSegment + +cdef extern from "2geom/line.h" namespace "Geom": + cdef cppclass Line: + Line() + Line(Point &, Coord) + Line(Point &, Point &) + + Line(LineSegment &) + Line(Ray &) + Line* duplicate() + + Point origin() + Point versor() + Coord angle() + void setOrigin(Point &) + void setVersor(Point &) + void setAngle(Coord) + void setPoints(Point &, Point &) + void setCoefficients(double, double, double) + bint isDegenerate() + Point pointAt(Coord) + Coord valueAt(Coord, Dim2) + Coord timeAt(Point &) + Coord timeAtProjection(Point &) + Coord nearestTime(Point &) + vector[Coord] roots(Coord, Dim2) + Line reverse() + Curve* portion(Coord, Coord) + LineSegment segment(Coord, Coord) + Ray ray(Coord) + Line derivative() + Line transformed(Affine &) + Point normal() + Point normalAndDist(double &) + + double distance(Point &, Line &) + bint are_near(Point &, Line &, double) + bint are_parallel(Line &, Line &, double) + bint are_same(Line &, Line &, double) + bint are_orthogonal(Line &, Line &, double) + bint are_collinear(Point &, Point &, Point &, double) + + double angle_between(Line &, Line &) + double distance(Point &, LineSegment &) + +cdef extern from "2geom/line.h" namespace "Geom::Line": + Line from_origin_and_versor(Point, Point) + Line from_normal_distance(Point, double) + + +cdef extern from "2geom/ray.h" namespace "Geom": + cdef cppclass Ray: + Ray() + Ray(Point &, Coord) + Ray(Point&, Point &) + Point origin() + Point versor() + void setOrigin(Point &) + void setVersor(Point &) + void setAngle(Coord) + Coord angle() + void setPoints(Point &, Point &) + bint isDegenerate() + Point pointAt(Coord) + Coord valueAt(Coord, Dim2) + vector[Coord] roots(Coord, Dim2) + Coord nearestTime(Point &) + Ray reverse() + Curve *portion(Coord, Coord) + LineSegment segment(Coord, Coord) + Ray transformed(Affine &) + double distance(Point &, Ray &) + bint are_near(Point &, Ray &, double) + bint are_same(Ray&, Ray &, double) + double angle_between(Ray &, Ray &, bint) + Ray make_angle_bisector_ray(Ray &, Ray&) diff --git a/src/cython/_cy_primitives.pyx b/src/cython/_cy_primitives.pyx new file mode 100644 index 0000000..62f7f41 --- /dev/null +++ b/src/cython/_cy_primitives.pyx @@ -0,0 +1,846 @@ +from numbers import Number + +from _common_decl cimport * +from cython.operator cimport dereference as deref + +from _cy_affine cimport cy_Translate, cy_Rotate, cy_Scale +from _cy_affine cimport cy_VShear, cy_HShear, cy_Zoom +from _cy_affine cimport cy_Affine, get_Affine, is_transform + +from _cy_curves cimport cy_Curve, wrap_Curve_p +from _cy_curves cimport cy_LineSegment, wrap_LineSegment + +cdef class cy_Angle: + + """Class representig angle. + + Angles can be tested for equality, but they are not ordered. + + Corresponds to Angle class in 2geom. Most members are direct + calls to Angle methods, otherwise C++ call is specified. + """ + + def __cinit__(self, double x): + """Create new angle from value in radians.""" + self.thisptr = new Angle(x) + + def __repr__(self): + """repr(self)""" + return "Angle({0:2.f})".format(self.radians()) + + def __str__(self): + """str(self)""" + return "{0:.2f} radians".format(self.radians()) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_radians(cls, rad): + """Construnct angle from radians.""" + return wrap_Angle(from_radians(rad)) + + @classmethod + def from_degrees(cls, d): + """Construnct angle from degrees.""" + return wrap_Angle(from_degrees(d)) + + @classmethod + def from_degrees_clock(cls, d): + """Construnct angle from degrees in clock convention.""" + return wrap_Angle(from_degrees_clock(d)) + + @classmethod + def from_Point(cls, cy_Point p): + """Construct angle from Point. Calls Angle(Point) in 2geom.""" + cdef Point * pp = p.thisptr + return wrap_Angle( Angle( deref(p.thisptr) )) + + def __float__(self): + """float(self)""" + return deref(self.thisptr) + + def __add__(cy_Angle self, cy_Angle other): + """alpha + beta""" + return wrap_Angle(deref(other.thisptr) + deref(self.thisptr)) + + def __sub__(cy_Angle self, cy_Angle other): + """alpha - beta""" + return wrap_Angle(deref(other.thisptr) - deref(self.thisptr)) + + def __richcmp__(cy_Angle self, cy_Angle other, int op): + """Test equality of angles. Note: angles are not ordered.""" + if op == 2: + return deref(other.thisptr) == deref(self.thisptr) + elif op == 3: + return deref(other.thisptr) != deref(self.thisptr) + return NotImplemented + + def radians(self): + """Return the angle in radians.""" + return self.thisptr.radians() + + def radians0(self): + """Return the angle in positive radians.""" + return self.thisptr.radians0() + + def degrees(self): + """Return the angle in degrees.""" + return self.thisptr.degrees() + + def degrees_clock(self): + """Return the angle in clock convention. Calls degreesClock() in 2geom.""" + return self.thisptr.degreesClock() + + @classmethod + def rad_from_deg(cls, deg): + """Convert degrees to radians.""" + return rad_from_deg(deg) + + @classmethod + def deg_from_rad(cls, rad): + """Convert radians to degrees.""" + return deg_from_rad(rad) + +cdef cy_Angle wrap_Angle(Angle p): + cdef Angle * retp = new Angle() + retp[0] = p + cdef cy_Angle r = cy_Angle.__new__(cy_Angle, 0) + r.thisptr = retp + return r + + +cdef class cy_AngleInterval: + + """ Class representing interval of angles. + + Corresponds to AngleInterval class in 2geom. Most members are direct + calls to AngleInterval methods, otherwise C++ call is specified. + """ + + cdef AngleInterval* thisptr + + def __cinit__(self, start, end, bint cw=False): + """Create AngleInterval from starting and ending value. + + Optional argument cw specifies direction - counter-clockwise + is default. + """ + self.thisptr = new AngleInterval(float(start), float(end), cw) + + def __call__(self, Coord t): + """A(t), maps unit interval to Angle.""" + return wrap_Angle(deref( self.thisptr ) (t)) + + def initial_angle(self): + """Return initial angle as Angle instance.""" + return wrap_Angle(self.thisptr.initialAngle()) + + def final_angle(self): + """Return final angle as Angle instance.""" + return wrap_Angle(self.thisptr.finalAngle()) + + def is_degenerate(self): + """Test for empty interval.""" + return self.thisptr.isDegenerate() + + def angle_at(self, Coord t): + """A.angle_at(t) <==> A(t)""" + return wrap_Angle(self.thisptr.angleAt(t)) + + def contains(self, cy_Angle a): + """Test whether interval contains Angle.""" + return self.thisptr.contains(deref( a.thisptr )) + + def extent(self): + """Calculate interval's extent.""" + return self.thisptr.extent() + +cdef cy_AngleInterval wrap_AngleInterval(AngleInterval p): + cdef AngleInterval * retp = new AngleInterval(0, 0, 0) + retp[0] = p + cdef cy_AngleInterval r = cy_AngleInterval.__new__(cy_AngleInterval) + r.thisptr = retp + return r + + +cdef class cy_Point: + + """Represents point or vector in 2D plane. + + Points are ordered lexicographically, with y coordinate being + more significant. + + Corresponds to Point class in 2geom. Most members are direct + calls to Point methods, otherwise C++ call is specified. + """ + + def __cinit__(self, double x=0.0, double y=0.0): + """Create Point from it's cartesian coordinates.""" + self.thisptr = new Point(x, y) + + def __repr__(self): + """repr(self)""" + return "Point ({0:.3f}, {1:.3f})".format(self[0], self[1]) + + def __str__(self): + """str(self)""" + return "[{0:.3f}, {1:.3f}]".format(self[0], self[1]) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def polar(cls, Coord angle, Coord radius = 1.0): + """Create Point from polar coordinates.""" + return wrap_Point(polar(angle, radius)) + + def length(self): + """Return distance from origin or length of vector.""" + return self.thisptr.length() + + def ccw(self): + """Return point rotated counter-clockwise.""" + return wrap_Point(self.thisptr.ccw()) + + def cw(self): + """Return point rotated clockwise.""" + return wrap_Point(self.thisptr.cw()) + + def __getitem__(self, key): + """Access coordinates of point.""" + return deref(self.thisptr)[key] + + @property + def x(self): + """First coordinate of point.""" + return self.thisptr.x() + + @property + def y(self): + """Second coordinate of point.""" + return self.thisptr.y() + + def round(self): + """Create IntPoint rounding coordinates.""" + return wrap_IntPoint(self.thisptr.round()) + + def floor(self): + """Create IntPoint flooring coordinates.""" + return wrap_IntPoint(self.thisptr.floor()) + + def ceil(self): + """Create IntPoint ceiling coordinates.""" + return wrap_IntPoint(self.thisptr.ceil()) + + def __neg__(self): + """-P""" + return(wrap_Point(-deref(self.thisptr))) + + def __abs__(self): + """abs(P)""" + return self.length() + + def __add__(cy_Point self, cy_Point other): + """P + Q""" + return wrap_Point(deref(self.thisptr) + deref(other.thisptr)) + + def __sub__(cy_Point self, cy_Point other): + """P - Q""" + return wrap_Point(deref(self.thisptr) - deref(other.thisptr)) + + #TODO exceptions + def __mul__(cy_Point self, s): + """Multiply point by number or Affine transform.""" + if isinstance(s, Number): + return wrap_Point(deref(self.thisptr)* ( float(s))) + elif isinstance(s, cy_Affine): + return wrap_Point( deref(self.thisptr) * deref( ( s).thisptr ) ) + elif isinstance(s, cy_Translate): + return wrap_Point( deref(self.thisptr) * deref( ( s).thisptr ) ) + elif isinstance(s, cy_Scale): + return wrap_Point( deref(self.thisptr) * deref( ( s).thisptr ) ) + elif isinstance(s, cy_Rotate): + return wrap_Point( deref(self.thisptr) * deref( ( s).thisptr ) ) + elif isinstance(s, cy_HShear): + return wrap_Point( deref(self.thisptr) * deref( ( s).thisptr ) ) + elif isinstance(s, cy_VShear): + return wrap_Point( deref(self.thisptr) * deref( ( s).thisptr ) ) + elif isinstance(s, cy_Zoom): + return wrap_Point( deref(self.thisptr) * deref( ( s).thisptr ) ) + return NotImplemented + + def __div__(cy_Point self, Coord s): + """P / s""" + return wrap_Point(deref(self.thisptr)/s) + + def __richcmp__(cy_Point self, cy_Point other, int op): + if op == 0: + return deref(self.thisptr) < deref(other.thisptr) + if op == 1: + return deref(self.thisptr) <= deref(other.thisptr) + if op == 2: + return deref(self.thisptr) == deref(other.thisptr) + if op == 3: + return deref(self.thisptr) != deref(other.thisptr) + if op == 4: + return deref(self.thisptr) > deref(other.thisptr) + if op == 5: + return deref(self.thisptr) >= deref(other.thisptr) + + def isFinite(self): + """Test whether point is finite.""" + return self.thisptr.isFinite() + + def isZero(self): + """Test whether point is origin""" + return self.thisptr.isZero() + + def isNormalized(self, eps=EPSILON): + """Test whether point's norm is close to 1.""" + return self.thisptr.isNormalized(eps) + + @classmethod + def L2(cls, cy_Point p): + """Compute L2 (Euclidean) norm of point. + + L2(P) = sqrt( P.x**2 + P.y**2 ) + """ + return L2(deref(p.thisptr)) + + @classmethod + def L2sq(cls, cy_Point p): + """Compute square of L2 (Euclidean) norm.""" + return L2sq(deref(p.thisptr)) + + @classmethod + def are_near(cls, cy_Point a, cy_Point b, double eps=EPSILON): + """Test if two points are close.""" + return are_near(deref(a.thisptr), deref(b.thisptr), eps) + + @classmethod + def middle_point(cls, cy_Point a, cy_Point b): + """Return point between two points.""" + return wrap_Point(middle_point(deref(a.thisptr), deref(b.thisptr))) + + @classmethod + def rot90(cls, cy_Point a): + """Rotate point by 90 degrees.""" + return wrap_Point(rot90(deref(a.thisptr))) + + @classmethod + def lerp(cls, double t, cy_Point a, cy_Point b): + """Linearly interpolate between too points.""" + return wrap_Point(lerp(t, deref(a.thisptr), deref(b.thisptr))) + + @classmethod + def dot(cls, cy_Point a, cy_Point b): + """Calculate dot product of two points.""" + return dot(deref(a.thisptr), deref(b.thisptr)) + + @classmethod + def cross(cls, cy_Point a, cy_Point b): + """Calculate (z-coordinate of) cross product of two points.""" + return cross(deref(a.thisptr), deref(b.thisptr)) + + @classmethod + def distance(cls, cy_Point a, cy_Point b): + """Compute distance between two points.""" + return distance(deref(a.thisptr), deref(b.thisptr)) + + @classmethod + def distanceSq(cls, cy_Point a, cy_Point b): + """Compute square of distance between two points.""" + return distanceSq(deref(a.thisptr), deref(b.thisptr)) + + @classmethod + def unit_vector(cls, cy_Point p): + """Normalise point.""" + return wrap_Point(unit_vector(deref(p.thisptr))) + + @classmethod + def L1(cls, cy_Point p): + """Compute L1 (Manhattan) norm of a point. + + L1(P) = |P.x| + |P.y| + """ + return L1(deref(p.thisptr)) + + @classmethod + def LInfty(cls, cy_Point p): + """Compute Infinity norm of a point. + + LInfty(P) = max(|P.x|, |P.y|) + """ + return LInfty(deref(p.thisptr)) + + @classmethod + def is_zero(cls, cy_Point p): + """Test whether point is origin.""" + return is_zero(deref(p.thisptr)) + + @classmethod + def is_unit_vector(cls, cy_Point p): + """Test whether point's length equal 1.""" + return is_unit_vector(deref(p.thisptr)) + + @classmethod + def atan2(cls, cy_Point p): + """Return angle between point and x-axis.""" + return atan2(deref(p.thisptr)) + + @classmethod + def angle_between(cls, cy_Point a, cy_Point b): + """Return angle between two point.""" + return angle_between(deref(a.thisptr), deref(b.thisptr)) + + @classmethod + def abs(cls, cy_Point p): + """Return length of a point.""" + return wrap_Point(abs(deref(p.thisptr))) + + @classmethod + def constrain_angle(cls, cy_Point a, cy_Point b, unsigned int n, cy_Point direction): + """Rotate B around A to have specified angle wrt. direction.""" + return wrap_Point(constrain_angle(deref(a.thisptr), deref(b.thisptr), n, deref(direction.thisptr))) + +cdef cy_Point wrap_Point(Point p): + cdef Point * retp = new Point() + retp[0] = p + cdef cy_Point r = cy_Point.__new__(cy_Point) + r.thisptr = retp + return r + +cdef object wrap_vector_point(vector[Point] v): + r = [] + cdef unsigned int i + for i in range(v.size()): + r.append( wrap_Point(v[i]) ) + return r + +cdef vector[Point] make_vector_point(object l): + cdef vector[Point] ret + for i in l: + ret.push_back( deref( ( i).thisptr ) ) + return ret + + +cdef class cy_IntPoint: + + """Represents point with integer coordinates + + IntPoints are ordered lexicographically, with y coordinate being + more significant. + + Corresponds to IntPoint class in 2geom. Most members are direct + calls to IntPoint methods, otherwise C++ call is specified. + """ + + def __init__(self, IntCoord x = 0, IntCoord y = 0): + """Create new IntPoint from it's cartesian coordinates.""" + self.thisptr = new IntPoint(x ,y) + + def __getitem__(self, key): + """Get coordinates of IntPoint.""" + return deref(self.thisptr)[key] + + def __repr__(self): + """repr(self)""" + return "IntPoint ({0}, {1})".format(self[0], self[1]) + + def __str__(self): + """str(self)""" + return "[{0}, {1}]".format(self[0], self[1]) + + def __dealloc__(self): + del self.thisptr + + @property + def x(self): + """First coordinate of IntPoint.""" + return self.thisptr.x() + + @property + def y(self): + """Second coordinate of IntPoint.""" + return self.thisptr.y() + + def __add__(cy_IntPoint self, cy_IntPoint o): + """P + Q""" + return wrap_IntPoint(deref(self.thisptr)+deref( o.thisptr )) + + def __sub__(cy_IntPoint self, cy_IntPoint o): + """P - Q""" + return wrap_IntPoint(deref(self.thisptr)-deref( o.thisptr )) + + def __richcmp__(cy_IntPoint self, cy_IntPoint other, int op): + if op == 0: + return deref(self.thisptr) < deref(other.thisptr) + if op == 1: + return deref(self.thisptr) <= deref(other.thisptr) + if op == 2: + return deref(self.thisptr) == deref(other.thisptr) + if op == 3: + return deref(self.thisptr) != deref(other.thisptr) + if op == 4: + return deref(self.thisptr) > deref(other.thisptr) + if op == 5: + return deref(self.thisptr) >= deref(other.thisptr) + +cdef cy_IntPoint wrap_IntPoint(IntPoint p): + cdef IntPoint * retp = new IntPoint() + retp[0] = p + cdef cy_IntPoint r = cy_IntPoint.__new__(cy_IntPoint) + r.thisptr = retp + return r + + +cdef class cy_Line: + + """Class representing line in plane. + + Corresponds to Line class in 2geom. Most members are direct + calls to Line methods, otherwise C++ call is specified. + """ + + cdef Line* thisptr + + def __cinit__(self, cy_Point cp = None, double x = 0): + """Create Line from point and angle to x-axis. + + Constructor with no arguments calls Line() in 2geom, otherwise + Line(Point &, double) is called. + """ + if cp is None: + self.thisptr = new Line() + else: + self.thisptr = new Line( deref(cp.thisptr), x) + + def __repr__(self): + """repr(self).""" + return "Line({0}, {1:3f})".format(repr(self.origin()), self.angle()) + + def __str__(self): + """str(self)""" + return repr(self) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_points(cls, cy_Point cp, cy_Point cq): + """Create Line passing through two points. + + Calls Line(Point &, Point &) in 2geom. + """ + return wrap_Line( Line( deref(cp.thisptr), deref(cq.thisptr) ) ) + + @classmethod + def from_origin_and_versor(cls, cy_Point o, cy_Point v): + """Create Line passing through point with specified versor.""" + return wrap_Line( from_origin_and_versor(deref(o.thisptr), deref(v.thisptr)) ) + + @classmethod + def from_normal_distance(cls, cy_Point normal, double dist): + """Create Line from it's normal and distance from origin.""" + return wrap_Line( from_normal_distance( deref(normal.thisptr), dist ) ) + + @classmethod + def from_LineSegment(cls, cy_LineSegment LS): + """Create Line from LineSegment. + + Calls Line(LineSegment &) in 2geom. + """ + return wrap_Line( Line( deref( LS.thisptr) ) ) + + @classmethod + def from_Ray(cls, cy_Ray R): + """Create Line from Ray. + + Calls Line(Ray &) in 2geom. + """ + return wrap_Line( Line( deref(R.thisptr) ) ) + + #maybe implement as properties. + + def origin(self): + """Return origin of line.""" + return wrap_Point(self.thisptr.origin()) + + def versor(self): + """Return versor of line.""" + return wrap_Point(self.thisptr.versor()) + + def angle(self): + """Return angle between line and x-axis.""" + return self.thisptr.angle() + + def set_origin(self, cy_Point origin): + """Set origin.""" + self.thisptr.setOrigin( deref(origin.thisptr) ) + + def set_versor(self, cy_Point versor): + """Set versor.""" + self.thisptr.setVersor( deref(versor.thisptr) ) + + def set_angle(self, Coord a): + """Set angle.""" + self.thisptr.setAngle(a) + + def set_points(self, cy_Point cp, cy_Point cq): + """Set two points line passes through.""" + self.thisptr.setPoints( deref(cp.thisptr), deref(cq.thisptr) ) + + def set_coefficients(self, a, b, c): + """Set coefficients in parametric equation of line.""" + self.thisptr.setCoefficients(a, b, c) + + def is_degenerate(self): + """Test whether line's versor is zero vector.""" + return self.thisptr.isDegenerate() + + def point_at(self, t): + """origin + t*versor""" + return wrap_Point(self.thisptr.pointAt(t)) + + def value_at(self, t, Dim2 d): + """Coordinates of point_at(t).""" + return self.thisptr.valueAt(t, d) + + def time_at(self, cy_Point cp): + """Find time value corresponding to point on line.""" + return self.thisptr.timeAt( deref(cp.thisptr) ) + + def time_at_projection(self, cy_Point cp): + """Find time value corresponding to orthogonal projection of point.""" + return self.thisptr.timeAtProjection( deref(cp.thisptr) ) + + def nearest_time(self, cy_Point cp): + """Alias for time_at_projection.""" + return self.thisptr.nearestTime( deref(cp.thisptr) ) + + def roots(self, Coord v, Dim2 d): + """Return time values where self.value_at(t, dim) == v.""" + return wrap_vector_double( self.thisptr.roots(v, d) ) + + def reverse(self): + """Reverse line.""" + return wrap_Line( self.thisptr.reverse() ) + + def derivative(self): + """Take line's derivative.""" + return wrap_Line( self.thisptr.derivative() ) + + def normal(self): + """Return line's normal.""" + return wrap_Point( self.thisptr.normal() ) + + def normal_and_dist(self): + """return tuple containing normal vector and distance from origin. + + Calls normal_and_dist(x) and return it's result and x as a tuple. + """ + cdef double x = 0 + cdef Point p = self.thisptr.normalAndDist(x) + return (wrap_Point(p), x) + + def portion(self, Coord f, Coord t): + """Return Curve corresponding to portion of line.""" + return wrap_Curve_p( self.thisptr.portion(f, t) ) + + def ray(self, Coord t): + """Return Ray continuing from time value t.""" + return wrap_Ray( self.thisptr.ray(t) ) + + def segment(self, Coord f, Coord t): + """Return LineSegment corresponding to portion of line.""" + return wrap_LineSegment( self.thisptr.segment(f, t) ) + + def transformed(self, t): + """Return line transformed by transform.""" + #doing this because transformed(t) takes reference + cdef Affine at + if is_transform(t): + at = get_Affine(t) + return wrap_Line(self.thisptr.transformed( at )) + + @classmethod + def distance(cls, cy_Point cp, cy_Line cl): + """Calculate distance between point and line.""" + return distance( deref(cp.thisptr), deref(cl.thisptr)) + + @classmethod + def are_near(cls, cy_Point cp, cy_Line cl, double eps=EPSILON): + """Test if point is near line.""" + return are_near( deref(cp.thisptr), deref(cl.thisptr), eps) + + @classmethod + def are_parallel(cls, cy_Line cl, cy_Line ck, eps=EPSILON): + """Test if lines are almost parallel.""" + return are_parallel( deref(cl.thisptr), deref(ck.thisptr), eps) + + @classmethod + def are_same(cls, cy_Line cl, cy_Line ck, double eps=EPSILON): + """Test if lines represent the same line.""" + return are_same( deref(cl.thisptr), deref(ck.thisptr), eps) + + @classmethod + def are_orthogonal(cls, cy_Line cl, cy_Line ck, eps=EPSILON): + """Test two lines for orthogonality.""" + return are_orthogonal( deref(cl.thisptr), deref(ck.thisptr), eps) + + @classmethod + def are_collinear(cls, cy_Point cp, cy_Point cq, cy_Point cr, eps=EPSILON): + """Test for collinearity of vectors (cq-cp) and (cr-cp)""" + return are_collinear( deref(cp.thisptr), deref(cq.thisptr), deref(cr.thisptr), eps) + + @classmethod + def angle_between(cls, cy_Line cl, cy_Line ck): + """Calculate angle between two lines""" + return angle_between( deref(cl.thisptr), deref(ck.thisptr) ) + +cdef cy_Line wrap_Line(Line p): + cdef Line * retp = new Line() + retp[0] = p + cdef cy_Line r = cy_Line.__new__(cy_Line) + r.thisptr = retp + return r + +#-- Ray -- + +cdef class cy_Ray: + + """Ray represents half of line, starting at origin and going to + infinity. + + Corresponds to Ray class in 2geom. Most members are direct + calls to Ray methods, otherwise C++ call is specified. + """ + + cdef Ray* thisptr + + def __cinit__(self, cy_Point cp = None, double x = 0): + """Create Ray from origin and angle with x-axis. + + Empty constructor calls Ray() in 2geom. + """ + if cp is None: + self.thisptr = new Ray() + else: + self.thisptr = new Ray( deref(cp.thisptr), x) + + def __repr__(self): + """repr(self).""" + return "Ray({0}, {1:3f})".format(repr(self.origin()), self.angle()) + + def __str__(self): + """str(self)""" + return repr(self) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_points(cls, cy_Point cp, cy_Point cq): + """Create ray passing through two points, starting at first one.""" + return wrap_Ray( (Ray( deref(cp.thisptr), deref(cq.thisptr) )) ) + + def origin(self): + """Return origin.""" + return wrap_Point(self.thisptr.origin()) + + def versor(self): + """Return versor.""" + return wrap_Point(self.thisptr.versor()) + + def angle(self): + """Return angle between ray and x-axis.""" + return self.thisptr.angle() + + def set_origin(self, cy_Point cp): + """Set origin.""" + self.thisptr.setOrigin( deref(cp.thisptr) ) + + def set_versor(self, cy_Point cp): + """Set versor.""" + self.thisptr.setVersor( deref(cp.thisptr) ) + + def set_angle(self, Coord a): + """Set angle.""" + self.thisptr.setAngle(a) + + def set_points(self, cy_Point cp, cy_Point cq): + """Set origin and second point of ray.""" + self.thisptr.setPoints( deref(cp.thisptr), deref(cq.thisptr) ) + + def is_degenerate(self): + """Check for zero versor.""" + return self.thisptr.isDegenerate() + + def point_at(self, t): + """origin + t * versor""" + return wrap_Point(self.thisptr.pointAt(t)) + def value_at(self, t, Dim2 d): + """Access coordinates of point_at(t).""" + return self.thisptr.valueAt(t, d) + + def nearest_time(self, cy_Point cp): + """Get time value of nearest point of ray.""" + return self.thisptr.nearestTime( deref(cp.thisptr) ) + def reverse(self): + """Reverse the ray.""" + return wrap_Ray( self.thisptr.reverse() ) + + def roots(self, Coord v, Dim2 d): + """Return time values for which self.value_at(t, d) == v.""" + return wrap_vector_double( self.thisptr.roots(v, d) ) + + def transformed(self, t): + """Return ray transformed by affine transform.""" + cdef Affine at + if is_transform(t): + at = get_Affine(t) + return wrap_Ray(self.thisptr.transformed( at )) + + def portion(self, Coord f, Coord t): + """Return Curve corresponding to portion of ray.""" + return wrap_Curve_p( self.thisptr.portion(f, t) ) + + def segment(self, Coord f, Coord t): + """Return LineSegment corresponding to portion of ray.""" + return wrap_LineSegment( self.thisptr.segment(f, t) ) + + @classmethod + def distance(cls, cy_Point cp, cy_Ray cl): + """Compute distance between point and ray.""" + return distance( deref(cp.thisptr), deref(cl.thisptr)) + + @classmethod + def are_near(cls, cy_Point cp, cy_Ray cl, double eps=EPSILON): + """Check if distance between point and ray is small.""" + return are_near( deref(cp.thisptr), deref(cl.thisptr), eps) + + @classmethod + def are_same(cls, cy_Ray cl, cy_Ray ck, double eps=EPSILON): + """Check if two ray are same.""" + return are_same( deref(cl.thisptr), deref(ck.thisptr), eps) + + @classmethod + def angle_between(cls, cy_Ray cl, cy_Ray ck, bint cw=True): + """Compute angle between two rays. + + Can specify direction using parameter cw. + """ + return angle_between( deref(cl.thisptr), deref(ck.thisptr), cw) + + @classmethod + def make_angle_bisector_ray(cls, cy_Ray cl, cy_Ray ck): + """Make ray bisecting smaller angle formed by two rays.""" + return wrap_Ray( make_angle_bisector_ray(deref(cl.thisptr), deref(ck.thisptr) )) + +cdef cy_Ray wrap_Ray(Ray p): + cdef Ray * retp = new Ray() + retp[0] = p + cdef cy_Ray r = cy_Ray.__new__(cy_Ray) + r.thisptr = retp + return r diff --git a/src/cython/_cy_rectangle.pxd b/src/cython/_cy_rectangle.pxd new file mode 100644 index 0000000..ac18169 --- /dev/null +++ b/src/cython/_cy_rectangle.pxd @@ -0,0 +1,442 @@ +from _common_decl cimport * +from cpython.ref cimport PyObject + +from _cy_primitives cimport Point, cy_Point, wrap_Point +from _cy_primitives cimport IntPoint, cy_IntPoint, wrap_IntPoint + +cdef extern from "2geom/affine.h" namespace "Geom": + cdef cppclass Affine: + pass + +cdef extern from "2geom/cython-bindings/wrapped-pyobject.h" namespace "Geom": + + cdef cppclass WrappedPyObject: + WrappedPyObject() + WrappedPyObject(object) + object getObj() + + cdef cppclass PyPoint: + PyPoint() + PyPoint(WrappedPyObject, WrappedPyObject) + WrappedPyObject operator[](int) + + +cdef extern from "2geom/generic-interval.h" namespace "Geom": + + cdef cppclass GenericInterval[C]: + + GenericInterval() + GenericInterval(C) + GenericInterval(C, C) + + C min() + C max() + C extent() + C middle() + + bint isSingular() + bint contains(C) + bint contains(GenericInterval[C] &) + bint intersects(GenericInterval[C] &) + + void setMin(C) + void setMax(C) + void expandTo(C) + void expandBy(C) + void unionWith(GenericInterval[C] &) + + GenericInterval[C] &operator+(C) + GenericInterval[C] &operator-(C) + GenericInterval[C] &operator-() + GenericInterval[C] &operator+(GenericInterval[C] &) + GenericInterval[C] &operator-(GenericInterval[C] &) + GenericInterval[C] &operator|(GenericInterval[C] &) + bint operator==(GenericInterval[C] &) + bint operator!=(GenericInterval[C] &) + + + cdef cppclass GenericOptInterval[C]: + + GenericOptInterval() + GenericOptInterval(C) + GenericOptInterval(C, C) + + GenericInterval get() + + C min() + C max() + C extent() + C middle() + + bint isEmpty() + bint isSingular() + bint contains(C) + bint contains(GenericOptInterval[C] &) + bint intersects(GenericOptInterval[C] &) + + void setMin(C) + void setMax(C) + void expandTo(C) + void expandBy(C) + void unionWith(GenericOptInterval[C] &) + void intersectWith(GenericOptInterval &) + + + GenericOptInterval[C] &operator+(C) + GenericOptInterval[C] &operator-(C) + GenericOptInterval[C] &operator-() + GenericOptInterval[C] &operator+(GenericOptInterval[C] &) + GenericOptInterval[C] &operator-(GenericOptInterval[C] &) + GenericOptInterval[C] &operator|(GenericOptInterval[C] &) + GenericOptInterval[C] &operator&(GenericOptInterval[C] &) + bint operator==(GenericOptInterval[C] &) + bint operator!=(GenericOptInterval[C] &) + + +cdef extern from "2geom/int-interval.h" namespace "Geom": + ctypedef GenericInterval[IntCoord] IntInterval + ctypedef GenericOptInterval[IntCoord] OptIntInterval + + +#redeclaring inherited methods, other option is to cast all +#pointers from Interval to GenericInterval[Coord] in extension class +cdef extern from "2geom/interval.h" namespace "Geom": + + cdef cppclass Interval: + + Interval() + Interval(Coord) + Interval(Coord, Coord) + + Coord min() + Coord max() + Coord extent() + Coord middle() + + bint isSingular() + bint contains(Coord) + bint contains(Interval &) + bint intersects(Interval &) + + void setMin(Coord) + void setMax(Coord) + void expandTo(Coord) + void expandBy(Coord) + void unionWith(Interval &) + + bint isFinite() + bint interiorContains(Coord) + bint interiorContains(Interval &) + bint interiorIntersects(Interval &) + + Interval & operator*(Coord) + Interval & operator/(Coord) + Interval & operator*(Interval &) + bint operator==(IntInterval &) + bint operator==(Interval &) + bint operator!=(Interval &) + bint operator!=(IntInterval &) + Interval &operator+(Coord) + Interval &operator-(Coord) + Interval &operator-() + Interval &operator+(Interval &) + Interval &operator-(Interval &) + Interval &operator|(Interval &) + + IntInterval roundOutwards() + OptIntInterval roundInwards() + + + cdef cppclass OptInterval: + + OptInterval(OptInterval &) + OptInterval() + OptInterval(Interval &) + OptInterval(Coord) + OptInterval(Coord, Coord) + OptInterval(GenericOptInterval[double] &) + OptInterval(IntInterval &) + OptInterval(OptIntInterval &) + + Interval get() + bint isEmpty() + void unionWith(OptInterval &) + void intersectWith(OptInterval &) + + OptInterval &operator|(OptInterval &) + OptInterval &operator&(OptInterval &) + +cdef class cy_Interval: + cdef Interval* thisptr + +cdef cy_Interval wrap_Interval(Interval p) + +cdef class cy_OptInterval: + cdef OptInterval* thisptr + +cdef cy_OptInterval wrap_OptInterval(OptInterval p) + + +cdef extern from "2geom/generic-rect.h" namespace "Geom": + cdef cppclass GenericRect[C]: + GenericRect() + GenericRect(GenericInterval[C] &, GenericInterval[C] &) + GenericRect(Point &, Point &) + GenericRect(PyPoint &, PyPoint &) + GenericRect(IntPoint &, IntPoint &) + GenericRect(C, C, C, C) + + GenericInterval[C] & operator[](Dim2) + + PyPoint min() + PyPoint max() + PyPoint corner(unsigned int) + + IntPoint i_min "min" () + IntPoint i_max "max" () + IntPoint i_corner "corner" (unsigned int) + + C top() + C bottom() + C left() + C right() + C width() + C height() + Coord aspectRatio() + + PyPoint dimensions() + PyPoint midpoint() + + IntPoint i_dimensions "dimensions" () + IntPoint i_midpoint "midpoint" () + + C area() + bint hasZeroArea() + C maxExtent() + C minExtent() + bint intersects(GenericRect[C] &) + bint contains(GenericRect[C] &) + + bint contains(PyPoint &) + bint contains(IntPoint &) + + void setLeft(C) + void setRight(C) + void setTop(C) + void setBottom(C) + + void setMin(PyPoint &) + void setMax(PyPoint &) + void expandTo(PyPoint &) + void setMin(IntPoint &) + void setMax(IntPoint &) + void expandTo(IntPoint &) + + void unionWith(GenericRect[C] &) + void expandBy(C) + void expandBy(C, C) + + void expandBy(PyPoint &) + void expandBy(IntPoint &) + + GenericRect[C] & operator+(PyPoint &) + GenericRect[C] & operator+(IntPoint &) + + GenericRect[C] & operator-(PyPoint &) + GenericRect[C] & operator-(IntPoint &) + + GenericRect[C] & operator|(GenericRect[C] &) + bint operator==(GenericRect[C] &) + bint operator!=(GenericRect[C] &) + + + cdef cppclass GenericOptRect[C]: + GenericOptRect() + GenericOptRect(GenericRect[C] &) + GenericOptRect(C, C, C, C) + GenericOptRect(Point &, Point &) + GenericOptRect(GenericOptInterval[C] &, GenericOptInterval[C] &) + + GenericRect[C] get() + + bint isEmpty() + bint intersects(GenericRect[C] &) + bint contains(GenericRect[C] &) + bint intersects(GenericOptRect[C] &) + bint contains(GenericOptRect[C] &) + + bint contains(Point &) + bint contains(IntPoint &) + + void unionWith(GenericRect[C] &) + void unionWith(GenericOptRect[C] &) + void intersectWith(GenericRect[C] &) + void intersectWith(GenericOptRect[C] &) + + void expandTo(Point &) + + GenericOptRect[C] &operator|(GenericOptRect[C] &) + GenericOptRect[C] &operator&(GenericRect[C] &) + GenericOptRect[C] &operator&(GenericOptRect[C] &) + + bint operator==(GenericOptRect[C] &) + bint operator==(GenericRect[C] &) + + bint operator!=(GenericOptRect[C] &) + bint operator!=(GenericRect[C] &) + +cdef extern from "2geom/generic-rect.h" namespace "Geom::GenericRect": + GenericRect[WrappedPyObject] from_xywh(WrappedPyObject, WrappedPyObject, WrappedPyObject, WrappedPyObject) + GenericRect[WrappedPyObject] from_xywh(PyPoint &, PyPoint &) + +cdef extern from "2geom/int-rect.h" namespace "Geom": + ctypedef GenericRect[IntCoord] IntRect + +cdef extern from "2geom/rect.h" namespace "Geom": + cdef cppclass Rect: + Rect() + Rect(Interval &, Interval &) + Rect(Point &, Point &) + Rect(Coord, Coord, Coord, Coord) + + Interval & operator[](Dim2) + Point min() + Point max() + Point corner(unsigned int) + Coord top() + Coord bottom() + Coord left() + Coord right() + Coord width() + Coord height() + Coord aspectRatio() + Point dimensions() + Point midpoint() + Coord area() + bint hasZeroArea() + Coord maxExtent() + Coord minExtent() + + bint intersects(Rect &) + bint contains(Rect &) + bint contains(Point &) + + void setLeft(Coord) + void setRight(Coord) + void setTop(Coord) + void setBottom(Coord) + void setMin(Point &) + void setMax(Point &) + void expandTo(Point &) + void unionWith(Rect &) + void expandBy(Coord) + void expandBy(Coord, Coord) + void expandBy(Point &) + + Rect & operator+(Point &) + Rect & operator-(Point &) + Rect & operator|(Rect &) + bint operator==(Rect &) + bint operator!=(Rect &) + bint operator==(IntRect &) + bint operator!=(IntRect &) + + bint hasZeroArea(Coord) + bint interiorIntersects(Rect &) + bint interiorContains(Point &) + bint interiorContains(Rect &) + bint interiorContains(OptRect &) + + IntRect roundOutwards() + OptIntRect roundInwards() + Rect &operator*(Affine &) + + Coord distanceSq(Point &, Rect &) + Coord distance(Point &, Rect &) + + + cdef cppclass OptRect: + OptRect() + OptRect(Rect &) + OptRect(Coord, Coord, Coord, Coord) + OptRect(Point &, Point &) + OptRect(OptInterval &, OptInterval &) + + Rect get() + + bint isEmpty() + bint intersects(Rect &) + bint contains(Rect &) + bint intersects(OptRect &) + bint contains(OptRect &) + bint contains(Point &) + + void unionWith(Rect &) + void unionWith(OptRect &) + void intersectWith(Rect &) + void intersectWith(OptRect &) + void expandTo(Point &) + + OptRect &operator|(OptRect &) + OptRect &operator&(Rect &) + OptRect &operator&(OptRect &) + + bint operator==(OptRect &) + bint operator==(Rect &) + + bint operator!=(OptRect &) + bint operator!=(Rect &) + +cdef extern from "2geom/rect.h" namespace "Geom::Rect": + Rect from_xywh(Coord, Coord, Coord, Coord) + Rect from_xywh(Point &, Point &) + Rect infinite() + +cdef class cy_Rect: + cdef Rect* thisptr + +cdef cy_Rect wrap_Rect(Rect p) + +cdef class cy_OptRect: + cdef OptRect* thisptr + +cdef cy_OptRect wrap_OptRect(OptRect p) + + +cdef extern from "2geom/int-rect.h" namespace "Geom": + #redeclaring because cython complains about ambiguous overloading otherwise + cdef cppclass OptIntRect: + OptIntRect() + OptIntRect(IntRect &) + OptIntRect(IntCoord, IntCoord, IntCoord, IntCoord) + OptIntRect(IntPoint &, IntPoint &) + OptIntRect(OptIntInterval &, OptIntInterval &) + + IntRect get() + + bint isEmpty() + bint intersects(IntRect &) + bint contains(IntRect &) + bint intersects(OptIntRect &) + bint contains(OptIntRect &) + + bint contains(Point &) + bint contains(IntPoint &) + + void unionWith(IntRect &) + void unionWith(OptIntRect &) + void intersectWith(IntRect &) + void intersectWith(OptIntRect &) + + void expandTo(IntPoint &) + + OptIntRect &operator|(OptIntRect &) + OptIntRect &operator&(IntRect &) + OptIntRect &operator&(OptIntRect &) + + bint operator==(OptIntRect &) + bint operator==(IntRect &) + + bint operator!=(OptIntRect &) + bint operator!=(IntRect &) + diff --git a/src/cython/_cy_rectangle.pyx b/src/cython/_cy_rectangle.pyx new file mode 100644 index 0000000..1d1b687 --- /dev/null +++ b/src/cython/_cy_rectangle.pyx @@ -0,0 +1,2202 @@ +from numbers import Number + +from _common_decl cimport * +from cython.operator cimport dereference as deref + +from _cy_affine cimport cy_Affine, get_Affine, is_transform + + +cdef class cy_GenericInterval: + """ + Represents all numbers between min and max. + + Corresponds to GenericInterval in 2geom. min and max can be arbitrary + python object, they just have to implement arithmetic operations and + comparison - fractions.Fraction works. This is a bit experimental, + it leak memory right now. + """ + + cdef GenericInterval[WrappedPyObject]* thisptr + + def __cinit__(self, u = 0, v = None): + """Create GenericInterval from either one or two values.""" + if v is None: + self.thisptr = new GenericInterval[WrappedPyObject]( WrappedPyObject(u) ) + else: + self.thisptr = new GenericInterval[WrappedPyObject]( WrappedPyObject(u), WrappedPyObject(v) ) + + def __str__(self): + """str(self)""" + return "[{}, {}]".format(self.min(), self.max()) + + def __repr__(self): + """repr(self)""" + if self.is_singular(): + return "GenericInterval({})".format( str(self.min()) ) + return "GenericInterval({}, {})".format( str(self.min()) , str(self.max()) ) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_Interval(self, i): + """Create GenericInterval with same minimum and maximum as argument.""" + return cy_GenericInterval( i.min(), i.max() ) + + @classmethod + def from_list(self, lst): + """Create GenericInterval containing all values in list.""" + if len(lst) == 0: + return cy_GenericInterval() + ret = cy_GenericInterval(lst[0]) + for i in lst[1:]: + ret.expand_to(i) + return ret + + def min(self): + """Return minimal value of interval.""" + return self.thisptr.min().getObj() + + def max(self): + """Return maximal value of interval.""" + return self.thisptr.max().getObj() + def extent(self): + """Return difference between maximal and minimal value.""" + return self.thisptr.extent().getObj() + + def middle(self): + """Return midpoint of interval.""" + return self.thisptr.middle().getObj() + + def is_singular(self): + """Test for one-valued interval.""" + return self.thisptr.isSingular() + + def set_min(self, val): + """Set minimal value.""" + self.thisptr.setMin( WrappedPyObject(val) ) + + def set_max(self, val): + """Set maximal value.""" + self.thisptr.setMax( WrappedPyObject(val) ) + + def expand_to(self, val): + """Create smallest superset of self containing value.""" + self.thisptr.expandTo( WrappedPyObject(val) ) + + def expand_by(self, val): + """Push both boundaries by value.""" + self.thisptr.expandBy( WrappedPyObject(val) ) + def union_with(self, cy_GenericInterval interval): + """self = self | other""" + self.thisptr.unionWith( deref(interval.thisptr) ) + + def contains(self, other): + """Check if interval contains value.""" + return self.thisptr.contains( WrappedPyObject(other) ) + + def contains_interval(self, cy_GenericInterval other): + """Check if interval contains every point of interval.""" + return self.thisptr.contains( deref(other.thisptr) ) + + def intersects(self, cy_GenericInterval other): + """Check for intersecting intervals.""" + return self.thisptr.intersects(deref( other.thisptr )) + + def __neg__(self): + """Return interval with negated boundaries.""" + return wrap_GenericInterval(-deref(self.thisptr)) + + def _add_pyobj(self, X): + return wrap_GenericInterval(deref(self.thisptr) + WrappedPyObject(X) ) + def _sub_pyobj(self, X): + return wrap_GenericInterval(deref(self.thisptr) - WrappedPyObject(X) ) + + def _add_interval(self, cy_GenericInterval I): + return wrap_GenericInterval(deref(self.thisptr)+deref(I.thisptr)) + def _sub_interval(self, cy_GenericInterval I): + return wrap_GenericInterval(deref(self.thisptr)-deref(I.thisptr)) + + def __add__(cy_GenericInterval self, other): + """Add interval or value to self. + + Interval I+J consists of all values i+j such that i is in I and + j is in J + + Interval I+x consists of all values i+x such that i is in I. + """ + if isinstance(other, cy_GenericInterval): + return self._add_interval(other) + else: + return self._add_pyobj(other) + + def __sub__(cy_GenericInterval self, other): + """Substract interval or value. + + Interval I-J consists of all values i-j such that i is in I and + j is in J + + Interval I-x consists of all values i-x such that i is in I. + """ + if isinstance(other, cy_GenericInterval): + return self._sub_interval(other) + else: + return self._sub_pyobj(other) + + def __or__(cy_GenericInterval self, cy_GenericInterval I): + """Return a union of two intervals""" + return wrap_GenericInterval(deref(self.thisptr)|deref(I.thisptr)) + + def _eq(self, cy_GenericInterval other): + return deref(self.thisptr)==deref(other.thisptr) + + def _neq(self, cy_GenericInterval other): + return deref(self.thisptr)!=deref(other.thisptr) + + def __richcmp__(cy_GenericInterval self, other, op): + """Intervals are not ordered.""" + if op == 2: + return self._eq(other) + elif op == 3: + return self._neq(other) + +cdef cy_GenericInterval wrap_GenericInterval(GenericInterval[WrappedPyObject] p): + cdef GenericInterval[WrappedPyObject] * retp = new GenericInterval[WrappedPyObject](WrappedPyObject(0)) + retp[0] = p + cdef cy_GenericInterval r = cy_GenericInterval.__new__( + cy_GenericInterval, 0, 0) + r.thisptr = retp + return r + + +cdef class cy_GenericOptInterval: + + """Class representing optionally empty interval. + + Empty interval has False bool value, and using methods that require + non-empty interval will result in ValueError. This is supposed to be + used this way: + + >>> C = A & B + >>> if C: + >>> print C.min() + + This class represents GenericOptInterval with python object boundaries. + It tries to model behaviour of std::optional. + """ + + cdef GenericOptInterval[WrappedPyObject]* thisptr + + def __cinit__(self, u = None, v = None): + """Create interval from boundaries. + + Using no arguments, you will end up with empty interval.""" + if u is None: + self.thisptr = new GenericOptInterval[WrappedPyObject]() + elif v is None: + self.thisptr = new GenericOptInterval[WrappedPyObject](WrappedPyObject(u)) + else: + self.thisptr = new GenericOptInterval[WrappedPyObject](WrappedPyObject(u), WrappedPyObject(v) ) + + def __bool__(self): + """Logical value of interval, False only for empty interval.""" + return not self.thisptr.isEmpty() + + def __str__(self): + """str(self)""" + if not self: + return "[]" + return "[{}, {}]".format(self.Interval.min(), self.Interval.max()) + + def __repr__(self): + """repr(self)""" + if not self: + return "GenericOptInterval()" + if self.Interval.isSingular(): + return "GenericOptInterval({})".format( str(self.Interval.min()) ) + return "GenericOptInterval({}, {})".format( str(self.Interval.min()) , str(self.Interval.max()) ) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_Interval(self, i): + """Create interval from existing interval.""" + if hasattr(i, "isEmpty"): + if i.isEmpty(): + return cy_GenericOptInterval() + else: + return cy_GenericOptInterval.from_Interval(i.Interval) + return cy_GenericOptInterval( i.min(), i.max() ) + + @classmethod + def from_list(self, lst): + """Create interval containing all values in list. + + Empty list will result in empty interval.""" + if len(lst) == 0: + return cy_GenericOptInterval() + ret = cy_GenericOptInterval(lst[0]) + for i in lst[1:]: + ret.Interval.expandTo(i) + return ret + + property Interval: + """Get underlying GenericInterval.""" + def __get__(self): + if self.is_empty(): + raise ValueError("Interval is empty.") + else: + return wrap_GenericInterval(self.thisptr.get()) + + def is_empty(self): + """Check whether interval is empty set.""" + return self.thisptr.isEmpty() + + def union_with(self, cy_GenericOptInterval o): + """self = self | other""" + self.thisptr.unionWith( deref(o.thisptr) ) + + def intersect_with(cy_GenericOptInterval self, cy_GenericOptInterval o): + """self = self & other""" + self.thisptr.intersectWith( deref(o.thisptr) ) + + def __or__(cy_GenericOptInterval self, cy_GenericOptInterval o): + """Return a union of two intervals.""" + return wrap_GenericOptInterval(deref(self.thisptr) | deref(o.thisptr)) + + def __and__(cy_GenericOptInterval self, cy_GenericOptInterval o): + """Return an intersection of two intervals.""" + return wrap_GenericOptInterval(deref(self.thisptr) & deref(o.thisptr)) + + def __richcmp__(cy_GenericOptInterval self, cy_GenericOptInterval o, int op): + """Intervals are not ordered.""" + if op == 2: + return deref(self.thisptr) == deref(o.thisptr) + elif op == 3: + return deref(self.thisptr) != deref(o.thisptr) + return NotImplemented + + + def _get_Interval_method(self, name): + def f(*args, **kwargs): + if self.is_empty(): + raise ValueError("GenericOptInterval is empty.") + else: + return self.Interval.__getattribute__(name)(*args, **kwargs) + return f + + def __getattr__(self, name): + + Interval_methods = set(['contains', 'contains_interval', + 'expand_by', 'expand_to', 'extent', 'from_Interval', 'from_list', + 'intersects', 'is_singular', 'max', 'middle', 'min', 'set_max', + 'set_min', 'union_with']) + + if name in Interval_methods: + return self._get_Interval_method(name) + else: + raise AttributeError("GenericOptInterval instance has no attribute \"{}\"".format(name)) + + def _wrap_Interval_method(self, name, *args, **kwargs): + if self.isEmpty(): + raise ValueError("GenericOptInterval is empty.") + else: + return self.Interval.__getattr__(name)(*args, **kwargs) + + #declaring these by hand, because they take fixed number of arguments, + #which is enforced by cython + + def __neg__(self): + """Return interval with negated boundaries.""" + return self._wrap_Interval_method("__sub__") + + def __add__(cy_Interval self, other): + """Add interval or value to self. + + Interval I+J consists of all values i+j such that i is in I and + j is in J + + Interval I+x consists of all values i+x such that i is in I. + """ + return self._wrap_Interval_method("__add__", other) + + def __sub__(cy_Interval self, other): + """Substract interval or value. + + Interval I-J consists of all values i-j such that i is in I and + j is in J + + Interval I-x consists of all values i-x such that i is in I. + """ + return self._wrap_Interval_method("__sub__", other) + +cdef cy_GenericOptInterval wrap_GenericOptInterval(GenericOptInterval[WrappedPyObject] p): + cdef GenericOptInterval[WrappedPyObject] * retp = new GenericOptInterval[WrappedPyObject]() + retp[0] = p + cdef cy_GenericOptInterval r = cy_GenericOptInterval.__new__(cy_GenericOptInterval) + r.thisptr = retp + return r + + +cdef class cy_Interval: + + """Class representing interval on real line. + + Corresponds to Interval class in 2geom. + """ + + def __cinit__(self, u = None, v = None): + """Create interval from it's boundaries. + + One argument will create interval consisting that value, no + arguments create Interval(0). + """ + if u is None: + self.thisptr = new Interval() + elif v is None: + self.thisptr = new Interval(float(u)) + else: + self.thisptr = new Interval(float(u), float(v)) + + def __str__(self): + """str(self)""" + return "[{}, {}]".format(self.min(), self.max()) + + def __repr__(self): + """repr(self)""" + if self.is_singular(): + return "Interval({})".format( str(self.min()) ) + return "Interval({}, {})".format( str(self.min()) , str(self.max()) ) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_Interval(c, i): + """Create Interval with same boundaries as argument.""" + return cy_Interval( i.min(), i.max() ) + + @classmethod + def from_list(cls, lst): + """Create interval containing all values in a list.""" + if len(lst) == 0: + return cy_Interval() + ret = cy_Interval(lst[0]) + for i in lst[1:]: + ret.expand_to(i) + return ret + + def min(self): + """Return minimal boundary.""" + return self.thisptr.min() + + def max(self): + """Return maximal boundary.""" + return self.thisptr.max() + + def extent(self): + """Return length of interval.""" + return self.thisptr.extent() + + def middle(self): + """Return middle value.""" + return self.thisptr.middle() + + def set_min(self, Coord val): + """Set minimal value.""" + self.thisptr.setMin(val) + + def set_max(self, Coord val): + """Set maximal value.""" + self.thisptr.setMax(val) + + def expand_to(self, Coord val): + """Set self to smallest superset of set containing value.""" + self.thisptr.expandTo(val) + + def expand_by(self, Coord amount): + """Move both boundaries by amount.""" + self.thisptr.expandBy(amount) + + def union_with(self, cy_Interval a): + """self = self | other""" + self.thisptr.unionWith(deref( a.thisptr )) + +# Not exposing this - deprecated +# def __getitem__(self, unsigned int i): +# return deref(self.thisptr)[i] + + def is_singular(self): + """Test if interval contains only one value.""" + return self.thisptr.isSingular() + + def isFinite(self): + """Test for finiteness of interval's extent.""" + return self.thisptr.isFinite() + + def contains(cy_Interval self, other): + """Test if interval contains number.""" + return self.thisptr.contains(float(other)) + + def contains_interval(cy_Interval self, cy_Interval other): + """Test if interval contains another interval.""" + return self.thisptr.contains( deref(other.thisptr) ) + + def intersects(self, cy_Interval val): + """Test for intersection of intervals.""" + return self.thisptr.intersects(deref( val.thisptr )) + + def interior_contains(cy_Interval self, other): + """Test if interior of iterval contains number.""" + return self.thisptr.interiorContains(float(other)) + + def interior_contains_interval(cy_Interval self, cy_Interval other): + """Test if interior of interval contains another interval.""" + return self.thisptr.interiorContains( deref(other.thisptr) ) + + + def interior_intersects(self, cy_Interval val): + """Test for intersection of interiors of two points.""" + return self.thisptr.interiorIntersects(deref( val.thisptr )) + + def _cmp_Interval(cy_Interval self, cy_Interval other, op): + if op == 2: + return deref(self.thisptr) == deref(other.thisptr) + elif op == 3: + return deref(self.thisptr) != deref(other.thisptr) + def _cmp_IntInterval(cy_Interval self, cy_IntInterval other, op): + if op == 2: + return deref(self.thisptr) == deref(other.thisptr) + elif op == 3: + return deref(self.thisptr) != deref(other.thisptr) + + def __richcmp__(cy_Interval self, other, op): + """Intervals are not ordered.""" + if isinstance(other, cy_Interval): + return self._cmp_Interval(other, op) + elif isinstance(other, cy_IntInterval): + return self._cmp_IntInterval(other, op) + + def __neg__(self): + """Return interval with negated boundaries.""" + return wrap_Interval(-deref(self.thisptr)) + + def _add_number(self, Coord X): + return wrap_Interval(deref(self.thisptr)+X) + def _sub_number(self, Coord X): + return wrap_Interval(deref(self.thisptr)-X) + def _mul_number(self, Coord X): + return wrap_Interval(deref(self.thisptr)*X) + + def _add_interval(self, cy_Interval I): + return wrap_Interval(deref(self.thisptr)+deref(I.thisptr)) + def _sub_interval(self, cy_Interval I): + return wrap_Interval(deref(self.thisptr)-deref(I.thisptr)) + def _mul_interval(self, cy_Interval I): + return wrap_Interval(deref(self.thisptr)*deref(I.thisptr)) + + def __mul__(cy_Interval self, other): + """Multiply interval by interval or number. + + Multiplying by number simply multiplies boundaries, + multiplying intervals creates all values that can be written as + product i*j of i in I and j in J. + """ + if isinstance(other, Number): + return self._mul_number(float(other)) + else: + return self._mul_interval(other) + + def __add__(cy_Interval self, other): + """Add interval or value to self. + + Interval I+J consists of all values i+j such that i is in I and + j is in J + + Interval I+x consists of all values i+x such that i is in I. + """ + if isinstance(other, Number): + return self._add_number(float(other)) + else: + return self._add_interval(other) + + def __sub__(cy_Interval self, other): + """Substract interval or value. + + Interval I-J consists of all values i-j such that i is in I and + j is in J + + Interval I-x consists of all values i-x such that i is in I. + """ + if isinstance(other, Number): + return self._sub_number(float(other)) + else: + return self._sub_interval(other) + + def __div__(cy_Interval self, Coord s): + """Divide boundaries by number.""" + return wrap_Interval(deref(self.thisptr)/s) + + def __or__(cy_Interval self, cy_Interval I): + """Return union of two intervals.""" + return wrap_Interval(deref(self.thisptr)|deref(I.thisptr)) + + def round_outwards(self): + """Create the smallest IntIterval that is superset.""" + return wrap_IntInterval(self.thisptr.roundOutwards()) + + def round_inwards(self): + """Create the largest IntInterval that is subset.""" + return wrap_OptIntInterval(self.thisptr.roundInwards()) + +cdef cy_Interval wrap_Interval(Interval p): + cdef Interval * retp = new Interval() + retp[0] = p + cdef cy_Interval r = cy_Interval.__new__(cy_Interval) + r.thisptr = retp + return r + + +cdef class cy_OptInterval: + + """Class representing optionally empty interval on real line. + + Empty interval has False bool value, and using methods that require + non-empty interval will result in ValueError. This is supposed to be + used this way: + + >>> C = A & B + >>> if C: + >>> print C.min() + + This class represents OptInterval. It tries to model behaviour of + std::optional. + """ + + def __cinit__(self, u = None, v = None): + """Create optionally empty interval form it's endpoints. + + No arguments will result in empty interval. + """ + if u is None: + self.thisptr = new OptInterval() + elif v is None: + self.thisptr = new OptInterval(float(u)) + else: + self.thisptr = new OptInterval(float(u), float(v)) + + def __bool__(self): + """Only empty interval is False.""" + return not self.thisptr.isEmpty() + + def __str__(self): + """str(self)""" + if not self: + return "[]" + return "[{}, {}]".format(self.Interval.min(), self.Interval.max()) + + def __repr__(self): + """repr(self)""" + if not self: + return "OptInterval()" + if self.Interval.isSingular(): + return "OptInterval({})".format( str(self.Interval.min()) ) + return "OptInterval({}, {})".format( str(self.Interval.min()) , str(self.Interval.max()) ) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_Interval(cls, i): + """Create interval from other (possibly empty) interval.""" + if hasattr(i, "isEmpty"): + if i.isEmpty(): + return cy_OptInterval() + else: + return cy_OptInterval.from_Interval(i.Interval) + return cy_OptInterval( i.min(), i.max() ) + + @classmethod + def from_list(self, lst): + """Create interval containing all values in list. + + Empty list will result in empty interval.""" + if len(lst) == 0: + return cy_OptInterval() + ret = cy_OptInterval(lst[0]) + for i in lst[1:]: + ret.Interval.expandTo(i) + return ret + + property Interval: + """Get underlying Interval.""" + def __get__(self): + if self.is_empty(): + raise ValueError("Interval is empty.") + else: + return wrap_Interval(self.thisptr.get()) + + def is_empty(self): + """Test for empty interval.""" + return self.thisptr.isEmpty() + + def union_with(self, cy_OptInterval o): + """self = self | other""" + self.thisptr.unionWith( deref(o.thisptr) ) + + def intersect_with(cy_OptInterval self, cy_OptInterval o): + """self = self & other""" + self.thisptr.intersectWith( deref(o.thisptr) ) + + def __or__(cy_OptInterval self, cy_OptInterval o): + """Return union of intervals.""" + return wrap_OptInterval(deref(self.thisptr) | deref(o.thisptr)) + + def __and__(cy_OptInterval self, cy_OptInterval o): + """Return intersection of intervals.""" + return wrap_OptInterval(deref(self.thisptr) & deref(o.thisptr)) + + def _get_Interval_method(self, name): + def f(*args, **kwargs): + if self.is_empty(): + raise ValueError("OptInterval is empty.") + else: + return self.Interval.__getattribute__(name)(*args, **kwargs) + return f + + def __getattr__(self, name): + + Interval_methods = set(['contains', 'contains_interval', 'expand_by', + 'expand_to', 'extent', 'from_Interval', 'from_list', + 'interior_contains', 'interior_contains_interval', + 'interior_intersects', 'intersects', 'isFinite', 'is_singular', + 'max', 'middle', 'min', 'round_inwards', 'round_outwards', + 'set_max', 'set_min', 'union_with']) + + if name in Interval_methods: + return self._get_Interval_method(name) + else: + raise AttributeError("OptInterval instance has no attribute \"{}\"".format(name)) + + def _wrap_Interval_method(self, name, *args, **kwargs): + if self.isEmpty(): + raise ValueError("OptInterval is empty.") + else: + return self.Interval.__getattr__(name)(*args, **kwargs) + + #declaring these by hand, because they take fixed number of arguments, + #which is enforced by cython + + def __neg__(self): + """Return interval with negated boundaries.""" + return self._wrap_Interval_method("__sub__") + + def __mul__(cy_Interval self, other): + """Multiply interval by interval or number. + + Multiplying by number simply multiplies boundaries, + multiplying intervals creates all values that can be written as + product i*j of i in I and j in J. + """ + return self._wrap_Interval_method("__mul__", other) + + def __add__(cy_Interval self, other): + """Add interval or value to self. + + Interval I+J consists of all values i+j such that i is in I and + j is in J + + Interval I+x consists of all values i+x such that i is in I. + """ + return self._wrap_Interval_method("__add__", other) + + def __sub__(cy_Interval self, other): + """Substract interval or value. + + Interval I-J consists of all values i-j such that i is in I and + j is in J + + Interval I-x consists of all values i-x such that i is in I. + """ + return self._wrap_Interval_method("__sub__", other) + + def __div__(cy_Interval self, other): + """Divide boundaries by number.""" + return self._wrap_Interval_method("__div__", other) + +cdef cy_OptInterval wrap_OptInterval(OptInterval p): + cdef OptInterval * retp = new OptInterval() + retp[0] = p + cdef cy_OptInterval r = cy_OptInterval.__new__(cy_OptInterval) + r.thisptr = retp + return r + + +cdef class cy_IntInterval: + + """Class representing interval of integers. + + Corresponds to IntInterval class in 2geom. + """ + + cdef IntInterval* thisptr + + def __cinit__(self, u = None, v = None): + """Create interval from it's boundaries. + + One argument will create interval consisting that value, no + arguments create IntInterval(0). + """ + if u is None: + self.thisptr = new IntInterval() + elif v is None: + self.thisptr = new IntInterval(int(u)) + else: + self.thisptr = new IntInterval(int(u), int(v)) + + def __str__(self): + """str(self)""" + return "[{}, {}]".format(self.min(), self.max()) + + def __repr__(self): + """repr(self)""" + if self.is_singular(): + return "IntInterval({})".format( str(self.min()) ) + return "IntInterval({}, {})".format( str(self.min()) , str(self.max()) ) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_Interval(cls, i): + return cy_IntInterval( int(i.min()), int(i.max()) ) + + @classmethod + def from_list(cls, lst): + if len(lst) == 0: + return cy_IntInterval() + ret = cy_IntInterval(lst[0]) + for i in lst[1:]: + ret.expand_to(i) + return ret + + def min(self): + """Return minimal boundary.""" + return self.thisptr.min() + + def max(self): + """Return maximal boundary.""" + return self.thisptr.max() + + def extent(self): + """Return length of interval.""" + return self.thisptr.extent() + + def middle(self): + """Return middle value.""" + return self.thisptr.middle() + + def set_min(self, IntCoord val): + """Set minimal value.""" + self.thisptr.setMin(val) + + def set_max(self, IntCoord val): + """Set maximal value.""" + self.thisptr.setMax(val) + + def expand_to(self, IntCoord val): + """Set self to smallest superset of set containing value.""" + self.thisptr.expandTo(val) + + def expand_by(self, IntCoord amount): + """Move both boundaries by amount.""" + self.thisptr.expandBy(amount) + + def union_with(self, cy_IntInterval a): + """self = self | other""" + self.thisptr.unionWith(deref( a.thisptr )) + +# Not exposing this - deprecated +# def __getitem__(self, unsigned int i): +# return deref(self.thisptr)[i] + + def is_singular(self): + """Test if interval contains only one value.""" + return self.thisptr.isSingular() + + def contains(cy_IntInterval self, other): + """Test if interval contains number.""" + return self.thisptr.contains( int(other)) + + def contains_interval(cy_IntInterval self, cy_IntInterval other): + """Test if interval contains another interval.""" + return self.thisptr.contains( deref(other.thisptr) ) + + def intersects(self, cy_IntInterval val): + """Test for intersection with other interval.""" + return self.thisptr.intersects(deref( val.thisptr )) + + def __richcmp__(cy_IntInterval self, cy_IntInterval other, op): + """Intervals are not ordered.""" + if op == 2: + return deref(self.thisptr) == deref(other.thisptr) + elif op == 3: + return deref(self.thisptr) != deref(other.thisptr) + + def __neg__(self): + """Negate interval's endpoints.""" + return wrap_IntInterval(-deref(self.thisptr)) + + def _add_number(self, IntCoord X): + return wrap_IntInterval(deref(self.thisptr)+X) + def _sub_number(self, IntCoord X): + return wrap_IntInterval(deref(self.thisptr)-X) + + def _add_interval(self, cy_IntInterval I): + return wrap_IntInterval(deref(self.thisptr)+deref(I.thisptr)) + def _sub_interval(self, cy_IntInterval I): + return wrap_IntInterval(deref(self.thisptr)-deref(I.thisptr)) + + def __add__(cy_IntInterval self, other): + """Add interval or value to self. + + Interval I+J consists of all values i+j such that i is in I and + j is in J + + Interval I+x consists of all values i+x such that i is in I. + """ + if isinstance(other, Number): + return self._add_number(int(other)) + else: + return self._add_interval(other) + + def __sub__(cy_IntInterval self, other): + """Substract interval or value. + + Interval I-J consists of all values i-j such that i is in I and + j is in J + + Interval I-x consists of all values i-x such that i is in I. + """ + if isinstance(other, Number): + return self._sub_number(int(other)) + else: + return self._sub_interval(other) + + def __or__(cy_IntInterval self, cy_IntInterval I): + """Return union of two intervals.""" + return wrap_IntInterval(deref(self.thisptr)|deref(I.thisptr)) + +cdef cy_IntInterval wrap_IntInterval(IntInterval p): + cdef IntInterval * retp = new IntInterval() + retp[0] = p + cdef cy_IntInterval r = cy_IntInterval.__new__(cy_IntInterval) + r.thisptr = retp + return r + +cdef class cy_OptIntInterval: + + """Class representing optionally empty interval of integers. + + Empty interval has False bool value, and using methods that require + non-empty interval will result in ValueError. This is supposed to be + used this way: + + >>> C = A & B + >>> if C: + >>> print C.min() + + This class represents OptIntInterval. It tries to model behaviour of + std::optional. + """ + + cdef OptIntInterval* thisptr + + def __cinit__(self, u = None, v = None): + """Create optionally empty interval form it's endpoints. + + No arguments will result in empty interval. + """ + if u is None: + self.thisptr = new OptIntInterval() + elif v is None: + self.thisptr = new OptIntInterval(int(u)) + else: + self.thisptr = new OptIntInterval(int(u), int(v)) + + def __bool__(self): + """Only empty interval is False.""" + return not self.thisptr.isEmpty() + + def __str__(self): + """str(self)""" + if not self: + return "[]" + return "[{}, {}]".format(self.Interval.min(), self.Interval.max()) + + def __repr__(self): + """repr(self)""" + if not self: + return "OptIntInterval()" + if self.Interval.isSingular(): + return "OptIntInterval({})".format( str(self.Interval.min()) ) + return "OptIntInterval({}, {})".format( str(self.Interval.min()) , str(self.Interval.max()) ) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_Interval(self, i): + """Create interval from other (possibly empty) interval.""" + if hasattr(i, "isEmpty"): + if i.isEmpty(): + return cy_OptIntInterval() + else: + return cy_OptIntInterval.from_Interval(i.Interval) + return cy_OptIntInterval( i.min(), i.max() ) + + @classmethod + def from_list(self, lst): + """Create interval containing all values in list. + + Empty list will result in empty interval.""" + if len(lst) == 0: + return cy_OptIntInterval() + ret = cy_OptIntInterval(lst[0]) + for i in lst[1:]: + ret.Interval.expandTo(i) + return ret + + property Interval: + """Get underlying interval.""" + def __get__(self): + return wrap_IntInterval(self.thisptr.get()) + + def is_empty(self): + """Test for empty interval.""" + return self.thisptr.isEmpty() + + def union_with(self, cy_OptIntInterval o): + """self = self | other""" + self.thisptr.unionWith( deref(o.thisptr) ) + + def intersect_with(cy_OptIntInterval self, cy_OptIntInterval o): + """self = self & other""" + self.thisptr.intersectWith( deref(o.thisptr) ) + + def __or__(cy_OptIntInterval self, cy_OptIntInterval o): + """Return a union of two intervals.""" + return wrap_OptIntInterval(deref(self.thisptr) | deref(o.thisptr)) + + def __and__(cy_OptIntInterval self, cy_OptIntInterval o): + """Return an intersection of two intervals.""" + return wrap_OptIntInterval(deref(self.thisptr) & deref(o.thisptr)) + + #TODO decide how to implement various combinations of comparisons! + + def _get_Interval_method(self, name): + def f(*args, **kwargs): + if self.is_empty(): + raise ValueError("OptInterval is empty.") + else: + return self.Interval.__getattribute__(name)(*args, **kwargs) + return f + + def __getattr__(self, name): + + Interval_methods = set(['contains', 'contains_interval', + 'expand_by', 'expand_to', 'extent', 'from_Interval', 'from_list', + 'intersects', 'is_singular', 'max', 'middle', 'min', 'set_max', + 'set_min', 'union_with']) + + if name in Interval_methods: + return self._get_Interval_method(name) + else: + raise AttributeError("OptIntInterval instance has no attribute \"{}\"".format(name)) + + def _wrap_Interval_method(self, name, *args, **kwargs): + if self.isEmpty(): + raise ValueError("OptIntInterval is empty.") + else: + return self.Interval.__getattr__(name)(*args, **kwargs) + + #declaring these by hand, because they take fixed number of arguments, + #which is enforced by cython + + def __neg__(self): + """Negate interval's endpoints.""" + return self._wrap_Interval_method("__sub__") + + + def __add__(cy_Interval self, other): + """Add interval or value to self. + + Interval I+J consists of all values i+j such that i is in I and + j is in J + + Interval I+x consists of all values i+x such that i is in I. + """ + return self._wrap_Interval_method("__add__", other) + + def __sub__(cy_Interval self, other): + """Substract interval or value. + + Interval I-J consists of all values i-j such that i is in I and + j is in J + + Interval I-x consists of all values i-x such that i is in I. + """ + return self._wrap_Interval_method("__sub__", other) + +cdef cy_OptIntInterval wrap_OptIntInterval(OptIntInterval p): + cdef OptIntInterval * retp = new OptIntInterval() + retp[0] = p + cdef cy_OptIntInterval r = cy_OptIntInterval.__new__(cy_OptIntInterval) + r.thisptr = retp + return r + + +cdef class cy_GenericRect: + + """Class representing axis aligned rectangle, with arbitrary corners. + + Plane in which the rectangle lies can have any object as a coordinates, + as long as they implement arithmetic operations and comparison. + + This is a bit experimental, corresponds to GenericRect[C] templated + with (wrapped) python object. + """ + + cdef GenericRect[WrappedPyObject]* thisptr + + def __cinit__(self, x0=0, y0=0, x1=0, y1=0): + """Create rectangle from it's top-left and bottom-right corners.""" + self.thisptr = new GenericRect[WrappedPyObject](WrappedPyObject(x0), + WrappedPyObject(y0), + WrappedPyObject(x1), + WrappedPyObject(y1)) + + def __str__(self): + """str(self)""" + return "Rectangle with dimensions {}, topleft point {}".format( + str(self.dimensions()), + str(self.min())) + + def __repr__(self): + """repr(self)""" + return "Rect({}, {}, {}, {})".format( str(self.left()), + str(self.top()), + str(self.right()), + str(self.bottom()) ) + + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_intervals(self, I, J): + """Create rectangle from two intervals. + + First interval corresponds to side parallel with x-axis, + second one with side parallel with y-axis.""" + return cy_GenericRect(I.min(), I.max(), J.min(), J.max()) + + @classmethod + def from_list(cls, lst): + """Create rectangle containing all points in list. + + These points are represented simply by 2-tuples. + """ + ret = cy_GenericRect() + for a in lst: + ret.expand_to(a) + return ret + + @classmethod + def from_xywh(cls, x, y, w, h): + """Create rectangle from topleft point and dimensions.""" + return wrap_GenericRect( from_xywh(WrappedPyObject(x), + WrappedPyObject(y), + WrappedPyObject(w), + WrappedPyObject(h))) + + def __getitem__(self, Dim2 d): + """self[i]""" + return wrap_GenericInterval( deref(self.thisptr)[d] ) + + def min(self): + """Get top-left point.""" + return wrap_PyPoint( self.thisptr.min() ) + + def max(self): + """Get bottom-right point.""" + return wrap_PyPoint( self.thisptr.max() ) + + def corner(self, unsigned int i): + """Get corners (modulo) indexed from 0 to 3.""" + return wrap_PyPoint( self.thisptr.corner(i) ) + + def top(self): + """Get top coordinate.""" + return self.thisptr.top().getObj() + + def bottom(self): + """Get bottom coordinate.""" + return self.thisptr.bottom().getObj() + + def left(self): + """Get left coordinate.""" + return self.thisptr.left().getObj() + + def right(self): + """Get right coordinate.""" + return self.thisptr.right().getObj() + + def width(self): + """Get width.""" + return self.thisptr.width().getObj() + + def height(self): + """Get height.""" + return self.thisptr.height().getObj() + + #For some reason, Cpp aspectRatio returns Coord. + def aspectRatio(self): + """Get ratio between width and height.""" + return float(self.width())/float(self.height()) + + def dimensions(self): + """Get dimensions as tuple.""" + return wrap_PyPoint( self.thisptr.dimensions() ) + + def midpoint(self): + """Get midpoint as tuple.""" + return wrap_PyPoint( self.thisptr.midpoint() ) + + def area(self): + """Get area.""" + return self.thisptr.area().getObj() + + def has_zero_area(self): + """Test for area being zero.""" + return self.thisptr.hasZeroArea() + + def max_extent(self): + """Get bigger value from width, height.""" + return self.thisptr.maxExtent().getObj() + + def min_extent(self): + """Get smaller value from width, height.""" + return self.thisptr.minExtent().getObj() + + def intersects(self, cy_GenericRect r): + """Check if rectangle intersects another rectangle.""" + return self.thisptr.intersects(deref( r.thisptr )) + + def contains(self, r): + """Check if rectangle contains point represented as tuple.""" + if not isinstance(r, tuple): + raise TypeError("Tuple required to create point.") + return self.thisptr.contains( make_PyPoint(r) ) + + def contains_rect(self, cy_GenericRect r): + """Check if rectangle contains another rect.""" + return self.thisptr.contains( deref(r.thisptr) ) + + def set_left(self, val): + """Set left coordinate.""" + self.thisptr.setLeft( WrappedPyObject(val) ) + + def set_right(self, val): + """Set right coordinate.""" + self.thisptr.setRight( WrappedPyObject(val) ) + + def set_top(self, val): + """Set top coordinate.""" + self.thisptr.setTop( WrappedPyObject(val) ) + + def set_bottom(self, val): + """Set bottom coordinate.""" + self.thisptr.setBottom( WrappedPyObject(val) ) + + def set_min(self, p): + """Set top-left point.""" + self.thisptr.setMin(make_PyPoint(p)) + + def set_max(self, p): + """Set bottom-right point.""" + self.thisptr.setMax(make_PyPoint(p)) + + def expand_to(self, p): + """Expand rectangle to contain point represented as tuple.""" + self.thisptr.expandTo(make_PyPoint(p)) + + def union_with(self, cy_GenericRect b): + """self = self | other.""" + self.thisptr.unionWith(deref( b.thisptr )) + + def expand_by(self, x, y = None): + """Expand both intervals. + + Either expand them both by one value, or each by different value. + """ + if y is None: + self.thisptr.expandBy(WrappedPyObject(x)) + else: + self.thisptr.expandBy(WrappedPyObject(x), + WrappedPyObject(y)) + + + def __add__(cy_GenericRect self, p): + """Offset rectangle by point.""" + return wrap_GenericRect( deref(self.thisptr) + make_PyPoint(p) ) + + def __sub__(cy_GenericRect self, p): + """Offset rectangle by -point.""" + return wrap_GenericRect( deref(self.thisptr) - make_PyPoint(p) ) + + def __or__(cy_GenericRect self, cy_GenericRect o): + """Return union of two rects - it's actually bounding rect of union.""" + return wrap_GenericRect( deref(self.thisptr) | deref( o.thisptr )) + + def __richcmp__(cy_GenericRect self, cy_GenericRect o, int op): + """Rectangles are not ordered.""" + if op == 2: + return deref(self.thisptr) == deref(o.thisptr) + if op == 3: + return deref(self.thisptr) != deref(o.thisptr) + +cdef PyPoint make_PyPoint(p): + return PyPoint( WrappedPyObject(p[0]), WrappedPyObject(p[1]) ) + +#D2[WrappedPyObject] is converted to tuple +cdef wrap_PyPoint(PyPoint p): + return (p[0].getObj(), p[1].getObj()) + +cdef cy_GenericRect wrap_GenericRect(GenericRect[WrappedPyObject] p): + cdef WrappedPyObject zero = WrappedPyObject(0) + cdef GenericRect[WrappedPyObject] * retp = new GenericRect[WrappedPyObject](zero, zero, zero, zero) + retp[0] = p + cdef cy_GenericRect r = cy_GenericRect.__new__(cy_GenericRect) + r.thisptr = retp + return r + + +cdef class cy_Rect: + + """Class representing axis-aligned rectangle in 2D real plane. + + Corresponds to Rect class in 2geom.""" + + def __cinit__(self, Coord x0=0, Coord y0=0, Coord x1=0, Coord y1=0): + """Create Rect from coordinates of its top-left and bottom-right corners.""" + self.thisptr = new Rect(x0, y0, x1, y1) + + def __str__(self): + """str(self)""" + return "Rectangle with dimensions {}, topleft point {}".format(str(self.dimensions()), str(self.min())) + + def __repr__(self): + """repr(self)""" + return "Rect({}, {}, {}, {})".format( str(self.left()), + str(self.top()), + str(self.right()), + str(self.bottom())) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_points(cls, cy_Point p0, cy_Point p1): + """Create rectangle from it's top-left and bottom-right corners.""" + return wrap_Rect( Rect(deref(p0.thisptr), deref(p1.thisptr)) ) + + @classmethod + def from_intervals(cls, I, J): + """Create rectangle from two intervals representing its sides.""" + return wrap_Rect( Rect( float(I.min()), + float(J.min()), + float(I.max()), + float(J.max()) ) ) + + @classmethod + def from_list(cls, lst): + """Create rectangle containing all points in list.""" + if lst == []: + return cy_Rect() + if len(lst) == 1: + return cy_Rect.from_points(lst[0], lst[0]) + ret = cy_Rect.from_points(lst[0], lst[1]) + for a in lst: + ret.expand_to(a) + return ret + + @classmethod + def from_xywh(cls, x, y, w, h): + """Create rectangle from it's topleft point and dimensions.""" + return wrap_Rect( from_xywh( x, + y, + w, + h) ) + + @classmethod + def infinite(self): + """Create infinite rectangle.""" + return wrap_Rect(infinite()) + + def __getitem__(self, Dim2 d): + """self[d]""" + return wrap_Interval( deref(self.thisptr)[d] ) + + def min(self): + """Get top-left point.""" + return wrap_Point( self.thisptr.min() ) + + def max(self): + """Get bottom-right point.""" + return wrap_Point( self.thisptr.max() ) + + def corner(self, unsigned int i): + """Get corners (modulo) indexed from 0 to 3.""" + return wrap_Point( self.thisptr.corner(i) ) + + def top(self): + """Get top coordinate.""" + return self.thisptr.top() + + def bottom(self): + """Get bottom coordinate.""" + return self.thisptr.bottom() + + def left(self): + """Get left coordinate.""" + return self.thisptr.left() + + def right(self): + """Get right coordinate.""" + return self.thisptr.right() + + def width(self): + """Get width.""" + return self.thisptr.width() + + def height(self): + """Get height.""" + return self.thisptr.height() + + def aspect_ratio(self): + """Get ratio between width and height.""" + return self.thisptr.aspectRatio() + + def dimensions(self): + """Get dimensions as point.""" + return wrap_Point( self.thisptr.dimensions() ) + + def midpoint(self): + """Get midpoint.""" + return wrap_Point( self.thisptr.midpoint() ) + + def area(self): + """Get area.""" + return self.thisptr.area() + + def has_zero_area(self, Coord eps = EPSILON): + """Test for area being zero.""" + return self.thisptr.hasZeroArea(eps) + + def max_extent(self): + """Get bigger value from width, height.""" + return self.thisptr.maxExtent() + + def min_extent(self): + """Get smaller value from width, height.""" + return self.thisptr.minExtent() + + def intersects(self, cy_Rect r): + """Check if rectangle intersects another rectangle.""" + return self.thisptr.intersects(deref( r.thisptr )) + + def contains(self, cy_Point r): + """Check if rectangle contains point.""" + return self.thisptr.contains( deref(r.thisptr) ) + + def contains_rect(self, cy_Rect r): + """Check if rectangle contains another rect.""" + return self.thisptr.contains( deref(r.thisptr) ) + + def interior_intersects(self, cy_Rect r): + """Check if interior of self intersects another rectangle.""" + return self.thisptr.interiorIntersects(deref( r.thisptr )) + + def interior_contains(self, cy_Point other): + """Check if interior of self contains point.""" + return self.thisptr.interiorContains( deref( ( other).thisptr ) ) + + def interior_contains_rect(self, other): + """Check if interior of self contains another rectangle.""" + if isinstance(other, cy_Rect): + return self.thisptr.interiorContains( deref( ( other).thisptr ) ) + elif isinstance(other, cy_OptRect): + return self.thisptr.interiorContains( deref( ( other).thisptr ) ) + + def set_left(self, Coord val): + """Set left coordinate.""" + self.thisptr.setLeft(val) + + def set_right(self, Coord val): + """Set right coordinate.""" + self.thisptr.setRight(val) + + def set_top(self, Coord val): + """Set top coordinate.""" + self.thisptr.setTop(val) + + def set_bottom(self, Coord val): + """Set bottom coordinate.""" + self.thisptr.setBottom(val) + + def set_min(self, cy_Point p): + """Set top-left point.""" + self.thisptr.setMin( deref( p.thisptr ) ) + + def set_max(self, cy_Point p): + """Set bottom-right point.""" + self.thisptr.setMax( deref( p.thisptr )) + + def expand_to(self, cy_Point p): + """Expand rectangle to contain point represented as tuple.""" + self.thisptr.expandTo( deref( p.thisptr ) ) + + def union_with(self, cy_Rect b): + """self = self | other.""" + self.thisptr.unionWith(deref( b.thisptr )) + + def expand_by(cy_Rect self, x, y = None): + """Expand both intervals. + + Either expand them both by one value, or each by different value. + """ + if y is None: + if isinstance(x, cy_Point): + self.thisptr.expandBy( deref( ( x).thisptr ) ) + else: + self.thisptr.expandBy( x) + else: + self.thisptr.expandBy( x, + y) + + def __add__(cy_Rect self, cy_Point p): + """Offset rectangle by point.""" + return wrap_Rect( deref(self.thisptr) + deref( p.thisptr ) ) + + def __sub__(cy_Rect self, cy_Point p): + """Offset rectangle by -point.""" + return wrap_Rect( deref(self.thisptr) - deref( p.thisptr ) ) + + def __mul__(cy_Rect self, t): + """Apply transform to rectangle.""" + cdef Affine at + if is_transform(t): + at = get_Affine(t) + return wrap_Rect( deref(self.thisptr) * at ) + + def __or__(cy_Rect self, cy_Rect o): + """Return union of two rects - it's actually bounding rect of union.""" + return wrap_Rect( deref(self.thisptr) | deref( o.thisptr )) + + def __richcmp__(cy_Rect self, o, int op): + """Rectangles are not ordered.""" + if op == 2: + if isinstance(o, cy_Rect): + return deref(self.thisptr) == deref( ( o).thisptr) + elif isinstance(o, cy_IntRect): + return deref(self.thisptr) == deref( ( o).thisptr) + if op == 3: + if isinstance(o, cy_Rect): + return deref(self.thisptr) != deref( ( o).thisptr) + elif isinstance(o, cy_IntRect): + return deref(self.thisptr) != deref( ( o).thisptr) + + def round_inwards(self): + """Create OptIntRect rounding inwards.""" + return wrap_OptIntRect(self.thisptr.roundInwards()) + + def round_outwards(self): + """Create IntRect rounding outwards.""" + return wrap_IntRect(self.thisptr.roundOutwards()) + + @classmethod + def distanceSq(cls, cy_Point p, cy_Rect rect): + """Compute square of distance between point and rectangle.""" + return distanceSq( deref(p.thisptr), deref(rect.thisptr) ) + + @classmethod + def distance(cls, cy_Point p, cy_Rect rect): + """Compute distance between point and rectangle.""" + return distance( deref(p.thisptr), deref(rect.thisptr) ) + +cdef cy_Rect wrap_Rect(Rect p): + cdef Rect* retp = new Rect() + retp[0] = p + cdef cy_Rect r = cy_Rect.__new__(cy_Rect) + r.thisptr = retp + return r + + +cdef class cy_OptRect: + + """Class representing optionally empty rect in real plane. + + This class corresponds to OptRect in 2geom, and it tries to mimic + the behaviour of std::optional. In addition to OptRect methods, + this class passes calls for Rect methods to underlying Rect class, + or throws ValueError when it's empty. + """ + + def __cinit__(self, x0=None, y0=None, x1=None, y1=None): + """Create OptRect from coordinates of top-left and bottom-right corners. + + No arguments will result in empty rectangle. + """ + if x0 is None: + self.thisptr = new OptRect() + else: + self.thisptr = new OptRect( float(x0), + float(y0), + float(x1), + float(y1) ) + + def __str__(self): + """str(self)""" + if self.is_empty(): + return "Empty OptRect." + return "OptRect with dimensions {}, topleft point {}".format(str(self.dimensions()), str(self.min())) + + def __repr__(self): + """repr(self)""" + if self.is_empty(): + return "OptRect()" + return "OptRect({}, {}, {}, {})".format( str(self.left()), + str(self.top()), + str(self.right()), + str(self.bottom())) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_points(cls, cy_Point p0, cy_Point p1): + """Create rectangle from it's top-left and bottom-right corners.""" + return wrap_OptRect( OptRect(deref(p0.thisptr), deref(p1.thisptr)) ) + + @classmethod + def from_intervals(cls, I, J): + """Create rectangle from two intervals representing its sides.""" + if hasattr(I, "isEmpty"): + if I.isEmpty(): + return cy_OptRect() + + if hasattr(J, "isEmpty"): + if J.isEmpty(): + return cy_OptRect() + + return wrap_OptRect( OptRect( float(I.min()), + float(J.min()), + float(I.max()), + float(J.max()) ) ) + + @classmethod + def from_rect(cls, r): + """Create OptRect from other, possibly empty, rectangle.""" + if hasattr(r, "isEmpty"): + if r.isEmpty(): + return cy_OptRect() + + return cy_OptRect( r.min().x, + r.min().y, + r.max().x, + r.max().y ) + + @classmethod + def from_list(cls, lst): + """Create OptRect containing all points in the list. + + Empty list will result in empty OptRect. + """ + if lst == []: + return cy_OptRect() + if len(lst) == 1: + return cy_OptRect.from_points(lst[0], lst[0]) + ret = cy_OptRect.from_points(lst[0], lst[1]) + for a in lst: + ret.expand_to(a) + return ret + + property Rect: + """Get underlying Rect.""" + def __get__(self): + if self.is_empty(): + raise ValueError("Rect is empty.") + else: + return wrap_Rect(self.thisptr.get()) + + def __bool__(self): + """OptRect is False only when it's empty.""" + return not self.thisptr.isEmpty() + + def is_empty(self): + """Check for OptRect containing no points.""" + return self.thisptr.isEmpty() + + def intersects(self, other): + """Check if rectangle intersects another rectangle.""" + if isinstance(other, cy_Rect): + return self.thisptr.intersects( deref( ( other).thisptr ) ) + elif isinstance(other, cy_OptRect): + return self.thisptr.intersects( deref( ( other).thisptr ) ) + + def contains(self, cy_Point r): + """Check if rectangle contains point.""" + return self.thisptr.contains( deref(r.thisptr) ) + + def contains_rect(self, other): + """Check if rectangle contains another rect.""" + if isinstance(other, cy_Rect): + return self.thisptr.contains( deref( ( other).thisptr ) ) + elif isinstance(other, cy_OptRect): + return self.thisptr.contains( deref( ( other).thisptr ) ) + + def union_with(self, other): + """self = self | other.""" + if isinstance(other, cy_Rect): + self.thisptr.unionWith( deref( ( other).thisptr ) ) + elif isinstance(other, cy_OptRect): + self.thisptr.unionWith( deref( ( other).thisptr ) ) + + def intersect_with(self, other): + """self = self & other.""" + if isinstance(other, cy_Rect): + self.thisptr.intersectWith( deref( ( other).thisptr ) ) + elif isinstance(other, cy_OptRect): + self.thisptr.intersectWith( deref( ( other).thisptr ) ) + + def expand_to(self, cy_Point p): + """Expand rectangle to contain point represented as tuple.""" + self.thisptr.expandTo( deref(p.thisptr) ) + + def __or__(cy_OptRect self, cy_OptRect other): + """Return union of two rects - it's actually bounding rect of union.""" + return wrap_OptRect( deref(self.thisptr) | deref(other.thisptr) ) + + def __and__(cy_OptRect self, other): + """Return intersection of two rectangles.""" + if isinstance(other, cy_Rect): + return wrap_OptRect( deref(self.thisptr) & deref( ( other).thisptr) ) + elif isinstance(other, cy_OptRect): + return wrap_OptRect( deref(self.thisptr) & deref( ( other).thisptr) ) + + def __richcmp__(cy_OptRect self, other, op): + """Rectangles are not ordered.""" + if op == 2: + if isinstance(other, cy_Rect): + return deref(self.thisptr) == deref( ( other).thisptr ) + elif isinstance(other, cy_OptRect): + return deref(self.thisptr) == deref( ( other).thisptr ) + elif op == 3: + if isinstance(other, cy_Rect): + return deref(self.thisptr) != deref( ( other).thisptr ) + elif isinstance(other, cy_OptRect): + return deref(self.thisptr) != deref( ( other).thisptr ) + return NotImplemented + + def _get_Rect_method(self, name): + def f(*args, **kwargs): + if self.is_empty(): + raise ValueError("OptRect is empty.") + else: + return self.Rect.__getattribute__(name)(*args, **kwargs) + return f + + def __getattr__(self, name): + Rect_methods = set(['area', 'aspectRatio', 'bottom', 'contains', + 'contains_rect', 'corner', 'dimensions', 'distance', 'distanceSq', + 'expand_by', 'expand_to', 'has_zero_area', 'height', 'infinite', + 'interior_contains', 'interior_contains_rect', + 'interior_intersects', 'intersects', 'left', 'max', 'max_extent', + 'midpoint', 'min', 'min_extent', 'right', 'round_inwards', + 'round_outwards', 'set_bottom', 'set_left', 'set_max', 'set_min', + 'set_right', 'set_top', 'top', 'union_with', 'width']) + + if name in Rect_methods: + return self._get_Rect_method(name) + else: + raise AttributeError("OptRect instance has no attribute \"{}\"".format(name)) + + def _wrap_Rect_method(self, name, *args, **kwargs): + if self.isEmpty(): + raise ValueError("OptRect is empty.") + else: + return self.Rect.__getattr__(name)(*args, **kwargs) + + #declaring these by hand, because they take fixed number of arguments, + #which is enforced by cython + + def __getitem__(self, i): + """self[d]""" + return self._wrap_Rect_method("__getitem__", i) + + def __add__(self, other): + """Offset rectangle by point.""" + return self._wrap_Rect_method("__add__", other) + + def __mul__(self, other): + """Apply transform to rectangle.""" + return self._wrap_Rect_method("__mul__", other) + + def __sub__(self, other): + """Offset rectangle by -point.""" + return self._wrap_Rect_method("__sub__", other) + + +cdef cy_OptRect wrap_OptRect(OptRect p): + cdef OptRect* retp = new OptRect() + retp[0] = p + cdef cy_OptRect r = cy_OptRect.__new__(cy_OptRect) + r.thisptr = retp + return r + + + +cdef class cy_IntRect: + + """Class representing axis-aligned rectangle in 2D with integer coordinates. + + Corresponds to IntRect class (typedef) in 2geom.""" + + cdef IntRect* thisptr + + def __cinit__(self, IntCoord x0=0, IntCoord y0=0, IntCoord x1=0, IntCoord y1=0): + """Create IntRect from coordinates of its top-left and bottom-right corners.""" + self.thisptr = new IntRect(x0, y0, x1, y1) + + def __str__(self): + """str(self)""" + return "IntRect with dimensions {}, topleft point {}".format( + str(self.dimensions()), + str(self.min())) + + def __repr__(self): + """repr(self)""" + return "IntRect({}, {}, {}, {})".format( str(self.left()), + str(self.top()), + str(self.right()), + str(self.bottom())) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_points(cls, cy_IntPoint p0, cy_IntPoint p1): + """Create rectangle from it's top-left and bottom-right corners.""" + return wrap_IntRect( IntRect(deref(p0.thisptr), deref(p1.thisptr)) ) + + @classmethod + def from_intervals(cls, I, J): + """Create rectangle from two intervals representing its sides.""" + return cy_IntRect( int(I.min()), + int(J.min()), + int(I.max()), + int(J.max()) ) + + @classmethod + def from_list(cls, lst): + """Create rectangle containing all points in list.""" + if lst == []: + return cy_IntRect() + if len(lst) == 1: + return cy_IntRect(lst[0], lst[0]) + ret = cy_IntRect(lst[0], lst[1]) + for a in lst: + ret.expand_to(a) + return ret + + #didn't manage to declare from_xywh for IntRect + @classmethod + def from_xywh(cls, x, y, w, h): + """Create rectangle from it's topleft point and dimensions.""" + return cy_IntRect(int(x), + int(y), + int(x) + int(w), + int(y) + int(h) ) + + def __getitem__(self, Dim2 d): + """self[d]""" + return wrap_IntInterval( deref(self.thisptr)[d] ) + + def min(self): + """Get top-left point.""" + return wrap_IntPoint( self.thisptr.i_min() ) + + def max(self): + """Get bottom-right point.""" + return wrap_IntPoint( self.thisptr.i_max() ) + + def corner(self, unsigned int i): + """Get corners (modulo) indexed from 0 to 3.""" + return wrap_IntPoint( self.thisptr.i_corner(i) ) + + def top(self): + """Get top coordinate.""" + return self.thisptr.top() + + def bottom(self): + """Get bottom coordinate.""" + return self.thisptr.bottom() + + def left(self): + """Get left coordinate.""" + return self.thisptr.left() + + def right(self): + """Get right coordinate.""" + return self.thisptr.right() + + def width(self): + """Get width.""" + return self.thisptr.width() + + def height(self): + """Get height.""" + return self.thisptr.height() + + def aspect_ratio(self): + """Get ratio between width and height.""" + return self.thisptr.aspectRatio() + + def dimensions(self): + """Get dimensions as IntPoint.""" + return wrap_IntPoint( self.thisptr.i_dimensions() ) + + def midpoint(self): + """Get midpoint.""" + return wrap_IntPoint( self.thisptr.i_midpoint() ) + + def area(self): + """Get area.""" + return self.thisptr.area() + + def has_zero_area(self): + """Test for area being zero.""" + return self.thisptr.hasZeroArea() + + def max_extent(self): + """Get bigger value from width, height.""" + return self.thisptr.maxExtent() + + def min_extent(self): + """Get smaller value from width, height.""" + return self.thisptr.minExtent() + + def intersects(self, cy_IntRect r): + """Check if rectangle intersects another rectangle.""" + return self.thisptr.intersects(deref( r.thisptr )) + + def contains(self, cy_IntPoint r): + """Check if rectangle contains point.""" + return self.thisptr.contains( deref(r.thisptr) ) + + def contains_rect(self, cy_IntRect r): + """Check if rectangle contains another rect.""" + return self.thisptr.contains( deref(r.thisptr) ) + + def set_left(self, IntCoord val): + """Set left coordinate.""" + self.thisptr.setLeft(val) + + def set_right(self, IntCoord val): + """Set right coordinate.""" + self.thisptr.setRight(val) + + def set_top(self, IntCoord val): + """Set top coordinate.""" + self.thisptr.setTop(val) + + def set_bottom(self, IntCoord val): + """Set bottom coordinate.""" + self.thisptr.setBottom(val) + + def set_min(self, cy_IntPoint p): + """Set top-left point.""" + self.thisptr.setMin( deref( p.thisptr ) ) + + def set_max(self, cy_IntPoint p): + """Set bottom-right point.""" + self.thisptr.setMax( deref( p.thisptr )) + + def expand_to(self, cy_IntPoint p): + """Expand rectangle to contain point represented as tuple.""" + self.thisptr.expandTo( deref( p.thisptr ) ) + + def union_with(self, cy_IntRect b): + """self = self | other.""" + self.thisptr.unionWith(deref( b.thisptr )) + + def expand_by(cy_IntRect self, x, y = None): + """Expand both intervals. + + Either expand them both by one value, or each by different value. + """ + if y is None: + if isinstance(x, cy_IntPoint): + self.thisptr.expandBy( deref( ( x).thisptr ) ) + else: + self.thisptr.expandBy( x) + else: + self.thisptr.expandBy( x, + y) + + def __add__(cy_IntRect self, cy_IntPoint p): + """Offset rectangle by point.""" + return wrap_IntRect( deref(self.thisptr) + deref( p.thisptr ) ) + + def __sub__(cy_IntRect self, cy_IntPoint p): + """Offset rectangle by -point.""" + return wrap_IntRect( deref(self.thisptr) - deref( p.thisptr ) ) + + def __or__(cy_IntRect self, cy_IntRect o): + """Return union of two rects - it's actually bounding rect of union.""" + return wrap_IntRect( deref(self.thisptr) | deref( o.thisptr )) + + def __richcmp__(cy_IntRect self, cy_IntRect o, int op): + """Rectangles are not ordered.""" + if op == 2: + return deref(self.thisptr) == deref(o.thisptr) + if op == 3: + return deref(self.thisptr) != deref(o.thisptr) + +cdef cy_IntRect wrap_IntRect(IntRect p): + cdef IntRect* retp = new IntRect() + retp[0] = p + cdef cy_IntRect r = cy_IntRect.__new__(cy_IntRect) + r.thisptr = retp + return r + + + +cdef class cy_OptIntRect: + + """Class representing optionally empty rect in with integer coordinates. + + This class corresponds to OptIntRect in 2geom, and it tries to mimic + the behaviour of std::optional. In addition to OptIntRect methods, + this class passes calls for IntRect methods to underlying IntRect class, + or throws ValueError when it's empty. + """ + + cdef OptIntRect* thisptr + + def __cinit__(self, x0=None, y0=None, x1=None, y1=None): + """Create OptIntRect from coordinates of top-left and bottom-right corners. + + No arguments will result in empty rectangle. + """ + if x0 is None: + self.thisptr = new OptIntRect() + else: + self.thisptr = new OptIntRect( int(x0), + int(y0), + int(x1), + int(y1) ) + + def __str__(self): + """str(self)""" + if self.isEmpty(): + return "Empty OptIntRect" + return "OptIntRect with dimensions {}, topleft point {}".format( + str(self.Rect.dimensions()), + str(self.Rect.min())) + + def __repr__(self): + """repr(self)""" + if self.isEmpty(): + return "OptIntRect()" + return "OptIntRect({}, {}, {}, {})".format( str(self.Rect.left()), + str(self.Rect.top()), + str(self.Rect.right()), + str(self.Rect.bottom())) + + def __dealloc__(self): + del self.thisptr + + @classmethod + def from_points(cls, cy_IntPoint p0, cy_IntPoint p1): + """Create rectangle from it's top-left and bottom-right corners.""" + return wrap_OptIntRect( OptIntRect(deref(p0.thisptr), deref(p1.thisptr)) ) + + @classmethod + def from_intervals(cls, I, J): + """Create rectangle from two intervals representing its sides.""" + if hasattr(I, "isEmpty"): + if I.isEmpty(): + return cy_OptIntRect() + + if hasattr(J, "isEmpty"): + if J.isEmpty(): + return cy_OptIntRect() + + return wrap_OptIntRect( OptIntRect( int(I.min()), + int(J.min()), + int(I.max()), + int(J.max()) ) ) + + @classmethod + def from_rect(cls, r): + """Create OptIntRect from other, possibly empty, rectangle.""" + if hasattr(r, "isEmpty"): + if r.isEmpty(): + return cy_OptIntRect() + return cy_OptIntRect( r.min().x, + r.min().y, + r.max().x, + r.max().y ) + + @classmethod + def from_list(cls, lst): + """Create OptIntRect containing all points in the list. + + Empty list will result in empty OptIntRect. + """ + if lst == []: + return cy_OptIntRect() + if len(lst) == 1: + return cy_OptIntRect.from_points(lst[0], lst[0]) + ret = cy_OptIntRect.from_points(lst[0], lst[1]) + for a in lst: + ret.expand_to(a) + return ret + + property Rect: + """Get underlying IntRect.""" + def __get__(self): + return wrap_IntRect(self.thisptr.get()) + + def __bool__(self): + """OptIntRect is False only when it's empty.""" + return not self.thisptr.isEmpty() + + def is_empty(self): + """Check for OptIntRect containing no points.""" + return self.thisptr.isEmpty() + + def intersects(cy_OptIntRect self, other): + """Check if rectangle intersects another rectangle.""" + if isinstance(other, cy_IntRect): + return self.thisptr.intersects( deref( ( other).thisptr ) ) + elif isinstance(other, cy_OptIntRect): + return self.thisptr.intersects( deref( ( other).thisptr ) ) + + def contains(self, cy_IntPoint other): + """Check if rectangle contains point.""" + return self.thisptr.contains( deref(other.thisptr) ) + + def contains_rect(cy_OptIntRect self, other): + """Check if rectangle contains another rectangle.""" + if isinstance(other, cy_IntRect): + return self.thisptr.contains( deref( ( other).thisptr ) ) + elif isinstance(other, cy_OptIntRect): + return self.thisptr.contains( deref( ( other).thisptr ) ) + + + def union_with(cy_OptIntRect self, other): + """self = self | other.""" + if isinstance(other, cy_IntRect): + self.thisptr.unionWith( deref( ( other).thisptr ) ) + elif isinstance(other, cy_OptIntRect): + self.thisptr.unionWith( deref( ( other).thisptr ) ) + + def intersect_with(cy_OptIntRect self, other): + """self = self & other.""" + if isinstance(other, cy_IntRect): + self.thisptr.intersectWith( deref( ( other).thisptr ) ) + elif isinstance(other, cy_OptIntRect): + self.thisptr.intersectWith( deref( ( other).thisptr ) ) + + def expand_to(self, cy_IntPoint p): + """Expand rectangle to contain point.""" + self.thisptr.expandTo( deref(p.thisptr) ) + + def __or__(cy_OptIntRect self, cy_OptIntRect other): + """Return union of two rects - it's actually bounding rect of union.""" + return wrap_OptIntRect( deref(self.thisptr) | deref(other.thisptr) ) + + def __and__(cy_OptIntRect self, other): + """Return intersection of two rectangles.""" + if isinstance(other, cy_IntRect): + return wrap_OptIntRect( deref(self.thisptr) & deref( ( other).thisptr) ) + elif isinstance(other, cy_OptIntRect): + return wrap_OptIntRect( deref(self.thisptr) & deref( ( other).thisptr) ) + + def __richcmp__(cy_OptIntRect self, other, op): + """Rectangles are not ordered.""" + if op == 2: + if isinstance(other, cy_IntRect): + return deref(self.thisptr) == deref( ( other).thisptr ) + elif isinstance(other, cy_OptIntRect): + return deref(self.thisptr) == deref( ( other).thisptr ) + elif op == 3: + if isinstance(other, cy_IntRect): + return deref(self.thisptr) != deref( ( other).thisptr ) + elif isinstance(other, cy_OptIntRect): + return deref(self.thisptr) != deref( ( other).thisptr ) + + def _get_Rect_method(self, name): + def f(*args, **kwargs): + if self.is_empty(): + raise ValueError("OptIntRect is empty.") + else: + return self.Rect.__getattribute__(name)(*args, **kwargs) + return f + + def __getattr__(self, name): + + Rect_methods = set(['area', 'aspect_ratio', 'bottom', 'contains', + 'contains_rect', 'corner', 'dimensions', 'expand_by', 'expand_to', + 'from_intervals', 'from_list', 'from_points', 'from_xywh', + 'has_zero_area', 'height', 'intersects', 'left', 'max', + 'max_extent', 'midpoint', 'min', 'min_extent', 'right', + 'set_bottom', 'set_left', 'set_max', 'set_min', 'set_right', + 'set_top', 'top', 'union_with', 'width']) + + if name in Rect_methods: + return self._get_Rect_method(name) + else: + raise AttributeError("OptIntRect instance has no attribute \"{}\"".format(name)) + + def _wrap_Rect_method(self, name, *args, **kwargs): + if self.isEmpty(): + raise ValueError("OptIntRect is empty.") + else: + return self.Rect.__getattr__(name)(*args, **kwargs) + + #declaring these by hand, because they take fixed number of arguments, + #which is enforced by cython + + def __getitem__(self, i): + """self[d]""" + return self._wrap_Rect_method("__getitem__", i) + + def __add__(self, other): + """Offset rectangle by point.""" + return self._wrap_Rect_method("__add__", other) + + def __sub__(self, other): + """Offset rectangle by -point.""" + return self._wrap_Rect_method("__sub__", other) + +cdef cy_OptIntRect wrap_OptIntRect(OptIntRect p): + cdef OptIntRect* retp = new OptIntRect() + retp[0] = p + cdef cy_OptIntRect r = cy_OptIntRect.__new__(cy_OptIntRect) + r.thisptr = retp + return r diff --git a/src/cython/cy2geom.pyx b/src/cython/cy2geom.pyx new file mode 100644 index 0000000..f1ba7a6 --- /dev/null +++ b/src/cython/cy2geom.pyx @@ -0,0 +1,71 @@ +#Axis specifiers for Dim2 +X = 0 +Y = 1 + +from _cy_primitives import cy_Angle as Angle +from _cy_primitives import cy_AngleInterval as AngleInterval +from _cy_primitives import cy_Point as Point +from _cy_primitives import cy_Line as Line +from _cy_primitives import cy_Ray as Ray +from _cy_primitives import cy_IntPoint as IntPoint + + +from _cy_rectangle import cy_Interval as Interval +from _cy_rectangle import cy_OptInterval as OptInterval +from _cy_rectangle import cy_IntInterval as IntInterval +from _cy_rectangle import cy_OptIntInterval as OptIntInterval + +from _cy_rectangle import cy_GenericInterval as GenericInterval +from _cy_rectangle import cy_GenericOptInterval as GenericOptInterval + +from _cy_rectangle import cy_GenericRect as GenericRect + +from _cy_rectangle import cy_Rect as Rect +from _cy_rectangle import cy_OptRect as OptRect +from _cy_rectangle import cy_IntRect as IntRect +from _cy_rectangle import cy_OptIntRect as OptIntRect + + +from _cy_affine import cy_Affine as Affine +from _cy_affine import cy_Translate as Translate +from _cy_affine import cy_Rotate as Rotate +from _cy_affine import cy_VShear as VShear +from _cy_affine import cy_HShear as HShear +from _cy_affine import cy_Scale as Scale +from _cy_affine import cy_Zoom as Zoom + +from _cy_affine import cy_Eigen as Eigen + +from _cy_curves import cy_Curve as Curve + +from _cy_curves import cy_Linear as Linear +from _cy_curves import cy_SBasis as SBasis +from _cy_curves import cy_SBasisCurve as SBasisCurve + +from _cy_curves import cy_Bezier as Bezier +from _cy_curves import cy_BezierCurve as BezierCurve +from _cy_curves import cy_LineSegment as LineSegment +from _cy_curves import cy_QuadraticBezier as QuadraticBezier +from _cy_curves import cy_CubicBezier as CubicBezier + +from _cy_curves import cy_HLineSegment as HLineSegment +from _cy_curves import cy_VLineSegment as VLineSegment + +from _cy_curves import cy_EllipticalArc as EllipticalArc +#Wrap this? It doesn't fit into python's dynamic nature and +#BezierCurve covers most of it's functionality +#Maybe implement constructors for BezierCurve similar to those +#seen in BezierCurveN +#TODO +#from _cy_curves import cy_BezierCurveN as BezierCurveN + +from _cy_curves import cy_lerp as lerp +from _cy_curves import cy_reverse as reverse +#~ from _cy_curves import cy_level_sets as level_sets + + +from _cy_path import cy_Path as Path + + +from _cy_conicsection import cy_Circle as Circle +from _cy_conicsection import cy_Ellipse as Ellipse diff --git a/src/cython/report.md b/src/cython/report.md new file mode 100644 index 0000000..e1f8353 --- /dev/null +++ b/src/cython/report.md @@ -0,0 +1,237 @@ +# State of cython Bindings + +This report summarizes work done on [lib2geom][2g] cython bindings during +GSoC 2012 mostly from technical standpoint. It should serve for anyone +doing any further work on these bindings, and for me to help my memory. + +Prior to the project, there were bindings using boost.python. These +bindigs, however, uncovered only part of the lib2geom functionality and +were not actively developed. I decided to go for a fresh start using +[cython][cy]. Cython is programming language capable of calling C and C++ +methods and making so-called "extension types", which act as python +classes. Reasons for choosing python include bit of experience I had with +it, its cleanliness and activity in development. + +## Overview of Bindings + +All work was done in [trunk][tr], since it mostly added new functionality +without altering existing code. Whole bindings are located in directory + + 2geom_dir/src/2geom/cython-bindings + +Code is located in files ending with `.pxd` and `.pyx`, roughly cython's +equivalent of header and implementation files. Classes in cython are +divided into logical groups, which are wrapped in corresponding classes. +cy2geom.pyx imports all classes and methods, and it's what one sees after + + >>> import cy2geom + +In addition to this, there are some C++ files, necessary to wrap some of +the code for cython, unit-tests covering most of the functionality and +wrapper.py script, used to skip tedious part of creating extension types. + +Building of bindings was integrated with cmake, which is used to build +the bindings, using [thewext's code][cm]. + +I will now describe files/logical groups of them, their significance and +state. I will try to write down most of the technical non-trivialities that +I encountered. + +Pattern used for wrapping all classes is taken from cython docs and various +other cython bindings. In .pxd file C++ classes, methods and functions are +declared. In corresponding .pyx file there is an extension type which holds +pointer (called `thisptr`) to it's underlying C++ class. Instance of this +class is created with cython's `__cinit__`, and deleted with `__dealloc__`. +Methods of class are called with `self.thisptr.methodname`, which cython +translates to `thisptr->methodname`. Argument are stripped of their python +wrapping using `deref(arg.thisptr)`, or they are translated automatically +(these are basic numerical types). + +There is a function for each class, named `wrap_classname()`, which takes +C++ instance and creates new python object around it. + +## `_common_decl` +These files (.pxd/.pyx) include basic declarations, common to all files. +Functions for creating and wrapping `vector[double]` should become redundant +in next cython release (0.17), since it should do this conversion +automatically. + +All extension types (cdef classes) have prefix `_cy_`, to avoid clash with +C++ classes. This is removed when importing to `_common_decl.pyx`, but is still +somewhat visible to the user of bindings, for example in traces. Other +option would be renaming the C++ classes. + +## `_cy_primitives` +Geometric primitives are wrapped here. These are relatively simple, few +things that are worth mentioning are: + +* Some of the methods for Line and Ray could be rewritten using properties. +* General points about exceptions, docstrings and classmethod apply here. + +## `_cy_rectangle` +These files include intervals and rectangles, which all inherit from +`GenericInterval[C]` or `GenericRect[C]`, respectively. + +For intervals, classes Interval and IntInterval are wrapped, with added +methods for interval too. Opt variants are supported by rewriting +`__getattr__` method. When calling the method that Interval provides, +OptInterval checks whether it's not empty and passes arguments to Interval's +method. If it is empty, it will raise ValueError. Due to this, Interval's +method do not appear in OptInterval's namespace, which might be not ideal. + +GenericInterval is supported by setting the template type to WrappedPyObject, +defined in `wrapped-pyobject.h`. This thin wrapper of `PyObject *` overloads +operators to support arithmetic operations, comparisons and similar. When +adding two WrappedPyObjects, these objects call corresponding addition using +Python's C-API. This is a bit unstable feature, because it still leaks these +python objects, and propagating error from Python, through C-API to cython +back to Python is not done yet correctly. However, constraints on +parameter of GenericInterval's type are pretty tight - it has to support +arithmetic operations within itself, multiplication by reals and has to be +ordered (ordered linear space with multiplication and division between its +elements), so having GenericInterval only with reals and integers covers most +cases. + +For rectangles, situations is almost identical as for intervals. GenericRect, +return 2-tuples as a points, which is a bit of disadvantage, because adding +tuples doesn't add element-wise, but append them one after another. It might +be convenient to implement PyPoint overloading this functionality. + +A bit problematic region is in comparing all the intervals and rectangles. +Should every interval be comparable to every other type, Interval with +OptIntInterval? This would probably require writing the logic in cython. + +GenericOptRect is not there yet, because I got GenericRect only working +only recently. It should be, however, quick to add. + +## `_cy_affine` +Affine and specialised transforms. This is in pretty good state. Eigenvalues +seem to be a bit off sometimes. + +## `_cy_curves` +All of the curves are wrapped here, together with functions like Linear, +SBasis and Bezier. + +Curve implements method every curve should implement, but other curve +classes do not inherit from Curve. This is mainly because of technical +details, this inheritance would only add complexity to code. However, I +might consider rewriting curves, so they would actually inherit from +Curve, if this appears to be needed. + +State of functions and classmethods is a bit strange. I tried to copy +2geom's methods, but there are differences for Beziers and SBasis +polynomials - to name a few, SBasis implements multiplication with SBasis +as a operator, but Bezier only as a function, or bounds are implemented +as instance methods for Linear, but as a module level functions for Bezier +and SBasis. In case I wasn't sure what to do with a method, I put it, as +a classmethod, to corresponding class. + +BezierCurveN is not implemented. It would be major hurdle, as cython has +problems with templated classes - one would have to declare each type +separately. First three orders are wrapped, and BezierCurve, with variable +degree, is also wrapped. + +`hacks.h` is used to go around cython's problems with integer template +parameters. + +## `_cy_path` +Path is wrapped here. Biggest problem with path was it's heavy use of +iterators, which are not the same as python's iterators. In most of the +cases, I replaced them with integers marking the position of iterator, +and go to the position step-by-step. This makes potentially O(1) operations +actually O(n) where n is size of Path. Best way to deal with this would be +to allow iterators to be shifted by arbitrary number. + +Not everything is provided, but there should be enough functionality to +have total control over Path's curves. + +## `_cy_conicsection` +Circle and ellipse classes. ratQuad and xAx from conic-section should also +go there. + +## `utils.py` +Only a simple function to draw curve/path to Tk windows and regular +N-agon creating function reside there, useful mainly for debugging + +## `wrapper.py` +Script used to cut the most trivial part of creating bindings, writing +.pxd declarations, extension type and other functions. It's pretty tailored +into 2geom, but I guess after some work one could make it more generic. + + +## General Issues +Exceptions coming from C++ code are not handled yet, they actually crash +the program. Simplest solution is adding `except +` after every method that +possibly raises exceptions, but traces won't look that nice. + +cython has some kind of problem with docstrings, it doesn't write function's +argument to them, just ellipsis. This can be addressed by specifying all +arguments in the docstring. + +Design decision has been made to put most of function not belonging to any +class to extension type's namespace using classmethods. Most apt extension +type is chosen, distance(Point, Point) goes to Point class. Other options +are making them check for all possible types (this is ugly and error-prone) +or differentiating using different names, which is more or less the same as +classmethods, just not that systematic + +## What's missing +Piecewise missing and all of crossings/boolops stuff are biggest things +that didn't make. Concerning Piecewise, I think best option is to +implement only `Piecewise` and `Piecewise>` as those are +only ones actually useful (SBasis, Bezier and their D2 versions are AFAIK +only classes implementing required concepts). + +Crossings are working, boolops not so much. Work on Shape and Region has +been started. + +# Personal Notes +I am also summarizing a bit on my personal experience with GSoC. + +## What Did I Learn +I learned a lot, not only new technology, but also gained new perspective +on long-time work. + +Speaking of technology, I am much more confident with cython, and I am not +really scared of python C-API. I got a grasp of bazaar, CMake, python's +unittest module and various (mainly template) C++ features, heavily used +in 2geom. + +I got a grasp of what a polished product looks like, and I realize how +hard is to get your product to that state. I can now appreciate testing, +at first seemingly just a boring and not trivial chore, turned out to be +very helpful both for my understanding of code and for making changes more +quickly. I also read a lot about design of python API, what's idiomatic +and what does various norms (PEPs) say about python. + +I think I never did something of this size before (not that monolithic), +so I learned lot about my work habits and importance of both work ethic +and taking a rest. + +## What I Liked & Disliked +I liked mainly the process of learning new things. I disliked the really +technical scope of this project - I can imagine more exciting things to +work on than doing bindings, but I guess it doesn't hurt to have this kind +of experience. I certainly won't spend my whole life doing only exciting +things :) + +## What Would I Do Differently +I would have planned a bit more. I like to write it on account of my +inexperience, I felt many times that knowing how should final product +look like would save me tons of work - this way, I approached state +with which I was more-or-less content at the end of doing most of the tasks. +Luckily, I got time to go through the code at the end, so I ended up +correcting the largest mistakes. + +I would also discuss design of API bit more, since mapping the C++ sometimes +turned out to be cumbersome from python's perspective. Often, I would spend +lots of time thinking through some detail (Iterator for Path, std::optional, +most of the templated classes), only doing ad-hoc solution at the end in +order to I to keep progressing. + +Jan Pulmann - jan.pulmann@gmail.com + +[2g]: http://lib2geom.sourceforge.net/ +[cy]: http://www.cython.org/ +[cm]: https://github.com/thewtex/cython-cmake-example +[tr]: https://code.launchpad.net/~lib2geom-hackers/lib2geom/trunk diff --git a/src/cython/test-affine.py b/src/cython/test-affine.py new file mode 100644 index 0000000..a020d73 --- /dev/null +++ b/src/cython/test-affine.py @@ -0,0 +1,249 @@ +import unittest +from math import pi, sqrt, sin, cos +from random import randint, uniform + +import cy2geom + +from cy2geom import Point, IntPoint +from cy2geom import Line, Ray, Rect + +from cy2geom import Rect + +from cy2geom import Affine +from cy2geom import Translate, Scale, Rotate, VShear, HShear, Zoom +from cy2geom import Eigen + +class TestPrimitives(unittest.TestCase): + def affine(self, A, B): + c0, c1, c2, c3, c4, c5 = A[0], A[1], A[2], A[3], A[4], A[5] + C = Affine(c0, c1, c2, c3, c4, c5) + self.assertEqual(C, A) + E = Affine.identity() + self.assertEqual(C, C*E) + self.assertEqual(E*B, B) + self.assertEqual(E.det(), 1) + + self.assertAlmostEqual(A.det(), c0*c3-c1*c2) + self.assertAlmostEqual(abs(A.det()), A.descrim2()) + self.assertAlmostEqual(abs(A.det())**0.5, A.descrim()) + #xor + self.assertFalse( A.flips() ^ (A.det() < 0) ) + + if A.is_singular(): + self.assertAlmostEqual(A.det(), 0) + else: + self.assertTrue( Affine.are_near (A*A.inverse(), E) ) + self.assertAlmostEqual(A.det(), 1/A.inverse().det()) + self.assertEqual( A.x_axis(), Point(c0, c1) ) + self.assertEqual( A.y_axis(), Point(c2, c3) ) + self.assertEqual( A.translation(), Point(c4, c5) ) + + self.assertAlmostEqual(A.expansion_X(), A.x_axis().length()) + self.assertAlmostEqual(A.expansion_Y(), A.y_axis().length()) + + if abs(A.expansion_X()) > 1e-7 and abs(A.expansion_Y()) > 1e-7: + A.set_expansion_X(2) + A.set_expansion_Y(3) + self.assertAlmostEqual(A.expansion_X(), 2) + self.assertAlmostEqual(A.expansion_Y(), 3) + + A.set_identity() + + self.assertTrue(A.is_identity()) + self.assertTrue(A.is_translation()) + self.assertFalse(A.is_nonzero_translation()) + self.assertTrue(A.is_scale()) + self.assertTrue(A.is_uniform_scale()) + self.assertFalse(A.is_nonzero_scale()) + self.assertFalse(A.is_nonzero_uniform_scale()) + self.assertTrue(A.is_rotation()) + self.assertFalse(A.is_nonzero_rotation()) + self.assertTrue(A.is_HShear()) + self.assertTrue(A.is_VShear()) + self.assertFalse(A.is_nonzero_HShear()) + self.assertFalse(A.is_nonzero_VShear()) + self.assertTrue(A.is_zoom()) + + self.assertTrue(A.preserves_area() and A.preserves_angles() and A.preserves_distances()) + + self.assertFalse( A.flips() ) + self.assertFalse( A.is_singular() ) + + A.set_X_axis(Point(c0, c1)) + A.set_Y_axis(Point(c2, c3)) + + self.assertEqual(A.without_translation(), A) + + A.set_translation(Point(c4, c5)) + self.assertEqual(C, A) + + self.assertAlmostEqual( (A*B).det(), A.det()*B.det() ) + + self.assertEqual( A.translation(), Point()*A ) + self.assertEqual( Point(1, 1)*A, Point( c0+c2+c4, c1+c3+c5 )) + + l = Line(Point(1, 1), 2) + self.assertEqual( (l.transformed(A)).origin(), l.origin()*A ) + self.assertTrue( Line.are_near( l.point_at(3)*A, l.transformed(A) ) ) + + r = Ray(Point(2, 3), 4) + self.assertEqual( (r.transformed(A)).origin(), r.origin()*A ) + self.assertTrue( Ray.are_near( r.point_at(3)*A, r.transformed(A) ) ) + + + + def test_affine(self): + al = [] + for i in range(10): + al.append(Affine( uniform(-10, 10), + uniform(-10, 10), + uniform(-10, 10), + uniform(-10, 10), + uniform(-10, 10), + uniform(-10, 10))) + for A in al: + for B in al: + self.affine(A, B) + + o = Point(2, 4) + v = Point(-1, 1)/sqrt(2) + l = Line.from_origin_and_versor(o, v) + + R = Affine.reflection(v, o) + for i in range(100): + p = Point(randint(0, 100), randint(0, 100)) + self.assertAlmostEqual(Line.distance(p, l), Line.distance(p*R, l)) + self.assertTrue( Affine.are_near( R, R.inverse() ) ) + + self.affine(R, R.inverse()) + + def test_translate(self): + T = Translate() + U = Translate(Point(2, 4)) + V = Translate(1, -9) + + self.assertTrue(Affine(T).is_translation()) + self.assertTrue(Affine(U).is_nonzero_translation()) + + self.assertEqual( (U*V).vector(), U.vector()+V.vector() ) + self.assertEqual( U.inverse().vector(), -U.vector() ) + self.assertEqual(T, Translate.identity()) + self.assertEqual( U.vector(), Point(U[0], U[1]) ) + + self.affine(Affine(V), Affine(U)) + self.affine(Affine(U), Affine(V)) + + r = Rect.from_points( Point(0, 2), Point(4, 8) ) + + self.assertEqual( ( r*(U*V) ).min(), r.min()+U.vector()+V.vector()) + + def test_scale(self): + S = Scale() + T = Scale( Point (3, 8) ) + U = Scale( -3, 1) + V = Scale(sqrt(2)) + + self.assertTrue( Affine(T).is_scale() ) + self.assertTrue( Affine(T).is_nonzero_scale() ) + self.assertTrue( Affine(V).is_nonzero_uniform_scale()) + + self.assertEqual( (T*V).vector(), T.vector()*sqrt(2) ) + self.assertEqual( (T*U)[0], T[0]*U[0] ) + self.assertAlmostEqual( 1/U.inverse()[1], U[1] ) + + r = Rect.from_points( Point(0, 2), Point(4, 8) ) + self.assertAlmostEqual((r*V).area(), 2*r.area()) + self.assertFalse(Affine(U).preserves_area()) + self.assertTrue(Affine(V).preserves_angles()) + + self.affine(Affine(T), Affine(U)) + self.affine(Affine(U), Affine(V)) + self.affine(Affine(V), Affine(T)) + + def test_rotate(self): + R = Rotate() + S = Rotate(pi/3) + T = Rotate(Point( 1, 1 )) + U = Rotate( -1, 1 ) + + self.assertTrue(S.vector(), Point(cos(pi/3), sin(pi/3)) ) + self.assertEqual( Point(T[0], T[1]), T.vector() ) + self.assertTrue( Affine.are_near( Rotate.from_degrees(60), S ) ) + self.assertEqual(R, Rotate.identity()) + self.assertTrue( Point.are_near( ( S * T ).vector(), + Point( cos( pi/3 + pi/4 ), sin( pi/3 + pi/4 ) ) ) ) + + self.affine( Affine(R), Affine(S)) + self.affine( Affine(S), Affine(T)) + self.affine( Affine(T), Affine(U)) + self.affine( Affine(U), Affine(R)) + + def test_shear(self): + H = HShear(2.98) + V = VShear(-sqrt(2)) + + self.assertAlmostEqual(H.factor(), 2.98) + self.assertAlmostEqual(V.inverse().factor(), sqrt(2)) + + G = HShear.identity() + H.set_factor(0) + self.assertEqual(G, H) + + G.set_factor(2) + H.set_factor(4) + self.assertAlmostEqual((G*H).factor(), G.factor()+H.factor()) + + W = VShear.identity() + V.set_factor(0) + self.assertEqual(W, V) + + W.set_factor(-2) + V.set_factor(3) + self.assertAlmostEqual((W*V).factor(), W.factor()+V.factor()) + + def test_zoom(self): + Z = Zoom(3) + Y = Zoom(translate=Translate(3,2)) + X = Zoom(sqrt(3), Translate(-1, 3)) + + self.assertEqual( + Zoom(Z.scale(), Translate(Y.translation())), + Y*Z ) + + Z.set_translation(Y.translation()) + Y.set_scale(Z.scale()) + self.assertEqual(Z, Y) + + self.assertEqual(Y.inverse().scale(), 1/Y.scale()) + + r = Rect.from_xywh( 1, 1, 3, 6) + q = Rect.from_xywh( 0, -1, 1, 2) + W = Zoom.map_rect(r, q) + + self.assertAlmostEqual(W.scale()*r.width(), q.width()) + self.assertTrue(Point.are_near( + r.min()+W.translation(), + q.min())) + def test_eigen(self): + #TODO looks like bug in eigen - (1, 0) should be eigenvector too + #~ S = Scale(1, 2) + #~ E_S = Eigen(S) + #~ print E_S.vectors, E_S.values + #~ print Affine(S) + #~ for i in E_S.vectors: + #~ print i, i*S, Point(1, 0) * S + + B = Affine(-2, 2, 2, 1, 0, 0) + G1 = Eigen(B) + G2 = Eigen( [[-2, 2], [2, 1]] ) + + self.assertAlmostEqual(min(G1.values), min(G2.values)) + self.assertAlmostEqual(max(G1.values), max(G2.values)) + + if Point.are_near( G1.vectors[0]*G1.values[0], G1.vectors[0]*B ): + self.assertTrue( Point.are_near( G1.vectors[1]*G1.values[1], G1.vectors[1]*B ) ) + else: + self.assertTrue( Point.are_near( G1.vectors[1]*G1.values[0], G1.vectors[1]*B ) ) + self.assertTrue( Point.are_near( G1.vectors[0]*G1.values[1], G1.vectors[0]*B ) ) + +unittest.main() diff --git a/src/cython/test-conicsection.py b/src/cython/test-conicsection.py new file mode 100644 index 0000000..9fc1c20 --- /dev/null +++ b/src/cython/test-conicsection.py @@ -0,0 +1,137 @@ +import unittest +import math +from random import randint, uniform + +import cy2geom + +from cy2geom import Point, IntPoint +from cy2geom import Interval, IntInterval, OptInterval, OptIntInterval + +from cy2geom import Affine +from cy2geom import Translate, Scale, Rotate, VShear, HShear, Zoom +from cy2geom import Eigen + +from cy2geom import Curve +from cy2geom import Linear +from cy2geom import SBasis, SBasisCurve +from cy2geom import Bezier, BezierCurve + +from cy2geom import LineSegment, QuadraticBezier, CubicBezier +from cy2geom import HLineSegment, VLineSegment + +from cy2geom import EllipticalArc + +from cy2geom import Path + +from cy2geom import Circle, Ellipse + + +class TestPrimitives(unittest.TestCase): + def test_circle(self): + C = Circle() + self.assertEqual(C.center(), Point()) + + D = Circle(Point(2, 4), 2) + Dp = D.getPath() + self.assertEqual(D.center(), Point(2, 4)) + self.assertEqual(D.ray(), 2) + + for i in range(11): + t = i/10.0 + #Circle approximated by SBasis is not perfect + self.assertAlmostEqual( abs(D.center()-Dp(t)), D.ray(), delta=0.1 ) + + half_circle = D.arc(Dp(0), Dp(0.3), Dp(0.5)) + + self.assertTrue(half_circle.is_SVG_compliant()) + + self.assertAlmostEqual(Dp(0.25), half_circle(0.5), delta=0.1) + + points = [Point(2, 5), Point(1, 4), Point(9, 0)] + D.set_points(points) + for p in points: + self.assertAlmostEqual( abs(p-D.center()), D.ray() ) + Dc = Circle.from_points(points) + self.assertAlmostEqual(Dc.center(), D.center()) + self.assertAlmostEqual(Dc.ray(), D.ray()) + + coeffs = (2, 4, 1, -4) + E = Circle.from_coefficients(*coeffs) + def param(x, y): + A, B, C, D = coeffs + return A*x**2 + A*y**2 + B*x + C*y + D + Ec = E.arc(E.center()+Point(E.ray(), 0), E.center()-Point(E.ray(), 0), E.center()+Point(E.ray(), 0) ) + for i in range(11): + t = i/10.0 + self.assertAlmostEqual(param(Ec.value_at(t, 0), Ec.value_at(t, 1)), 0) + + E.set(3, 5, 9) + self.assertAlmostEqual(E.center(), Point(3, 5)) + self.assertAlmostEqual(E.ray(), 9) + + E.set_coefficients(*coeffs) + #radius and center from parametric equation + ca = float(coeffs[1])/coeffs[0] + cb = float(coeffs[2])/coeffs[0] + cc = float(coeffs[3])/coeffs[0] + self.assertAlmostEqual( 4*E.ray()**2 , ca**2 + cb**2 -4*cc ) + self.assertAlmostEqual( E.center(), -Point(ca, cb)/2) + + def test_ellipse(self): + #TODO: maybe a bug in arc? get_curve(F) returns different ellipse than F + def get_curve(ellipse): + p = Point(ellipse.ray(0), 0)*Rotate(ellipse.rot_angle()) + return ellipse.arc(ellipse.center()+p, ellipse.center()-p, ellipse.center()+p*(1-1e-7)) + E = Ellipse() + self.assertAlmostEqual(E.center(), Point()) + self.assertAlmostEqual(E.ray(0), 0) + self.assertAlmostEqual(E.ray(1), 0) + + F = Ellipse(Point(), 3, 2, 0) + self.assertAlmostEqual(F.center(), Point()) + self.assertAlmostEqual(F.ray(0), 3) + self.assertAlmostEqual(F.ray(1), 2) + self.assertAlmostEqual(F.rot_angle(), 0) + # x**2/9 + y**2/4 = 1 + self.assertAlmostEqual(F.implicit_form_coefficients()[0], 1/9.0) + self.assertAlmostEqual(F.implicit_form_coefficients()[2], 1/4.0) + self.assertAlmostEqual(F.implicit_form_coefficients()[5], -1) + + coeffs = (1/3.0, 0, 1/16.0, 1, 0, -1/4.0) + G = Ellipse.from_coefficients(*coeffs) + self.assertAlmostEqual(G.center(), Point(-3/2.0, 0)) + self.assertAlmostEqual(G.ray(0), math.sqrt(3)) + self.assertAlmostEqual(G.ray(1), 4) + self.assertAlmostEqual(G.rot_angle(), 0) + + points = [Point(1, 2), Point(2 ,9), Point(0, 3), Point(-3, 8), Point(5, 8)] + G.set_points(points) + coeffs_G = tuple(G.implicit_form_coefficients()) + def paramG(x, y): + A, B, C, D, E, F = coeffs_G + return A*x**2 + B*x*y + C*y**2 + D*x + E*y + F + for p in points: + self.assertAlmostEqual(paramG(p.x, p.y), 0) + + G2 = Ellipse.from_points(points) + coeffs_G2 = tuple(G.implicit_form_coefficients()) + def paramG2(x, y): + A, B, C, D, E, F = coeffs_G2 + return A*x**2 + B*x*y + C*y**2 + D*x + E*y + F + for p in points: + self.assertAlmostEqual(paramG2(p.x, p.y), 0) + + E.set_coefficients(*coeffs_G2) + for a1, a2 in zip(E.implicit_form_coefficients(), G2.implicit_form_coefficients()): + self.assertAlmostEqual(a1, a2) + + H = Ellipse.from_circle(Circle(Point(2, 8), 5)) + self.assertAlmostEqual(H.center(), Point(2, 8)) + self.assertAlmostEqual(H.ray(0), 5) + self.assertAlmostEqual(H.ray(1), 5) + + Ft = F.transformed( Rotate(math.pi/2) ) + self.assertAlmostEqual(F.ray(0), Ft.ray(1)) + self.assertAlmostEqual(F.ray(1), Ft.ray(0)) + +unittest.main() diff --git a/src/cython/test-curves.py b/src/cython/test-curves.py new file mode 100644 index 0000000..8f9b870 --- /dev/null +++ b/src/cython/test-curves.py @@ -0,0 +1,458 @@ +import unittest +import math +from random import randint, uniform + +import cy2geom + +from cy2geom import Angle +from cy2geom import Point, IntPoint +from cy2geom import Line, Ray, Rect +from cy2geom import Interval, IntInterval, OptInterval, OptIntInterval + + +from cy2geom import Affine +from cy2geom import Translate, Scale, Rotate, VShear, HShear, Zoom +from cy2geom import Eigen + +from cy2geom import Linear +from cy2geom import SBasis, SBasisCurve +from cy2geom import Bezier, BezierCurve +from cy2geom import lerp + +from cy2geom import LineSegment, QuadraticBezier, CubicBezier +from cy2geom import HLineSegment, VLineSegment + +from cy2geom import EllipticalArc + +class TestPrimitives(unittest.TestCase): + def test_linear(self): + L = Linear(0, 1) + M = Linear(2) + N = Linear() + self.assertEqual( (L+M), L+2 ) + self.assertEqual( (L-M), L-2 ) + self.assertAlmostEqual(L(0.5), lerp(.5, 0, 1)) + #~ self.assertTrue(N.is_zero()) + self.assertTrue(M.is_constant()) + self.assertTrue(L.is_finite()) + self.assertAlmostEqual(L(0), L.at0()) + self.assertAlmostEqual(L(1), L.at1()) + self.assertAlmostEqual(L.value_at(0.3), L(0.3)) + self.assertTrue( isinstance(M.to_SBasis(), SBasis )) + + self.assertAlmostEqual(L.tri(), L(1) - L(0)) + self.assertAlmostEqual(L.hat(), (L(1) + L(0))/2) + + for i in range(11): + t = i/10.0 + self.assertTrue(L.bounds_exact().Interval.contains(L(t))) + self.assertTrue(L.bounds_fast().Interval.contains(L(t))) + self.assertTrue(L.bounds_local(t-0.05, t+0.05).Interval.contains(L(t))) + self.assertAlmostEqual(lerp(t, 0, 4), t*4) + self.assertAlmostEqual(L(t), cy2geom.reverse(L)(1-t)) + self.assertAlmostEqual( L(t)*t, (L*t)(t) ) + self.assertAlmostEqual( L(t)+t, (L+t)(t) ) + self.assertAlmostEqual( L(t)-t, (L-t)(t) ) + self.assertAlmostEqual( -( L(t) ), (-L)(t) ) + self.assertAlmostEqual( (L/2)(t), L(t)/2 ) + + def test_sBasis(self): + S = SBasis() + T = SBasis(2) + U = SBasis(1, 7) + V = SBasis.from_linear( Linear(2, 8) ) + + self.assertEqual(V[0], Linear(2, 8)) + self.assertEqual(V.back(), Linear(2, 8)) + + #~ self.assertTrue(S.empty()) + self.assertFalse(T.empty()) + + T.pop_back() + self.assertTrue(T.empty()) + + self.assertEqual(S.size(), 0) + self.assertEqual(U.size(), 1) + self.assertEqual((U*V).size(), 2) + + T.resize(1, Linear(2, 3)) + self.assertEqual(T[0], Linear(2, 3)) + T.clear() + self.assertTrue(T.empty()) + #TODO + #~ T.reserve(5) + #~ print T.size() + self.assertEqual(V.at(0), V[0]) + self.assertEqual(V, U+1) + self.assertNotEqual(V, U) + self.assertTrue(T.is_zero()) + self.assertTrue(SBasis(1).is_constant()) + def f(A, B): + return (-A)*(A+B*2.2)*(A*B-B*B/3) + W = f(U, V) + self.assertAlmostEqual(W(0), W.at0()) + self.assertAlmostEqual(W(1), W.at1()) + + for i in range(11): + t = i/10.0 + self.assertAlmostEqual(W(t), W.value_at(t)) + self.assertAlmostEqual(W(t), f(U(t), V(t))) + + vd_UV = (U*V).value_and_derivatives(t, 1) + vd_U = U.value_and_derivatives(t, 1) + vd_V = V.value_and_derivatives(t, 1) + self.assertAlmostEqual( vd_UV[1], vd_U[1]*V(t)+U(t)*vd_V[1] ) + + self.assertAlmostEqual( U(V)(t), U(V(t)) ) + self.assertEqual(T.degrees_of_freedom(), 0) + self.assertEqual(U.degrees_of_freedom(), 2) + + self.assertEqual(T, T.to_SBasis()) + + U2 = SBasis(U(0), U(1)) + U2.resize(10) + self.assertNotEqual(U2, U) + U2.truncate(U.size()) + self.assertEqual(U2, U) + #TODO: normalize() + sL = Linear.sin(Linear(0, 1), 3) + cL = Linear.cos(Linear(0, 1), 3) + sqrtU = SBasis.sqrt( U, 3 ) + rL = Linear.reciprocal(Linear(1,2), 3) + # cy2geom.inverse seems to return nans for degrees > 1 + #~ asin = cy2geom.inverse( cy2geom.sqrt( SBasis(Linear(0, 1)), 3 ), 1) + for i in range(11): + t = i/10.0 + self.assertAlmostEqual(sL(t), math.sin(t)) + self.assertAlmostEqual(cL(t), math.cos(t)) + #cy2geom.sqrt is not that precise + self.assertAlmostEqual(sqrtU(t), math.sqrt(U(t)), places = 1) + self.assertAlmostEqual(rL(t), 1/(1+t), places = 1 ) + #~ self.assertAlmostEqual( asin(t), math.asin(t) ) + self.assertAlmostEqual( SBasis.compose(U, V)(t), U(V)(t) ) + self.assertAlmostEqual( SBasis.divide(U, V, 3)(t), U(t)/V(t), places = 1) + + self.assertAlmostEqual( SBasis.derivative(SBasis.integral(W))(t), W(t)) + self.assertAlmostEqual( cy2geom.reverse(W)(t), W(1-t) ) + self.assertAlmostEqual( SBasis.multiply(U, V)(t), (U*V)(t)) + #TODO looks like bug in 2geom + #~ print cy2geom.multiply_add(U, V, W)(t), (U*V+W)(t) + self.assertAlmostEqual( SBasis.multiply_add(U, W, V)(t), (U*W+V)(t)) + + self.assertTrue( SBasis.bounds_exact(U).Interval.contains(U(t)) ) + self.assertTrue( SBasis.bounds_fast(U).Interval.contains(U(t)) ) + self.assertTrue( SBasis.bounds_local(U, OptInterval(t-0.05, t+0.05)).Interval.contains(U(t)) ) + + + for r in SBasis.roots(W): + self.assertAlmostEqual(W(r), 0) + for r in SBasis.roots(W, Interval(0, 0.7)): + self.assertAlmostEqual(W(r), 0) + self.assertTrue(Interval(0, 0.7).contains(r)) + + levels = [0, 3, 22, -21] + for i, roots in enumerate( SBasis.multi_roots(W, levels) ): + level = levels[i] + for r in roots: + self.assertAlmostEqual(W(r), level) + + self.assertEqual(SBasis.valuation(W), 0) + #TODO: why is this still 0? + #~ print cy2geom.valuation(cy2geom.shift(W, 6)) + self.assertEqual( U[0], SBasis.shift(U, 2)[2] ) + + for I in SBasis.level_set(W, 2, tol = 1e-7): + self.assertAlmostEqual( W(I.mid()), 2 ) + for I in SBasis.level_set(W, Interval(0, 1), tol = 1e-7, vtol = 1e-7): + self.assertTrue( 0 <= W(I.begin()) <= 1 ) + self.assertTrue( 0 <= W(I.mid()) <= 1 ) + self.assertTrue( 0 <= W(I.end()) <= 1 ) + + def test_bezier(self): + B = Bezier() + C = Bezier(2) + D = Bezier(2, 4) + E = Bezier(1, 3, 9) + F = Bezier(-2, 5, -1, 2) + self.assertTrue( B.is_zero() ) + self.assertTrue( C.is_constant() ) + self.assertTrue( D.is_finite() ) + C.clear() + self.assertEqual(D.degree(), 1) + self.assertEqual(E.at0(), 1) + self.assertEqual(E.at1(), 9) + self.assertEqual(E[2], 9) + for i in range(11): + t = i/10.0 + self.assertAlmostEqual( D(t), lerp(t, 2, 4) ) + self.assertAlmostEqual( D(t), D.value_at(t)) + self.assertAlmostEqual( D.value_and_derivatives(t, 0)[0], D(t) ) + self.assertAlmostEqual( D.value_and_derivatives(t, 1)[1], Bezier.derivative(D)(t) ) + self.assertAlmostEqual( Bezier.integral(D).value_and_derivatives(t, 1)[1], D(t) ) + #~ self.assertAlmostEqual( D.elevate_degree().reduce_degree()(t), D(t) ) + self.assertAlmostEqual( (D+2)(t), D(t)+2 ) + self.assertAlmostEqual( (D-1)(t), D(t)-1 ) + self.assertAlmostEqual( (D*2)(t), D(t)*2 ) + self.assertAlmostEqual( (D/4)(t), D(t)/4 ) + self.assertTrue( Bezier.bounds_fast(F).Interval.contains(F(t)) ) + self.assertTrue( Bezier.bounds_exact(F).Interval.contains(F(t)) ) + self.assertTrue( Bezier.bounds_local(F, OptInterval(t-0.05, t+0.05)).Interval.contains(F(t)) ) + for r in F.roots(): + self.assertAlmostEqual(F(r), 0) + #TODO: bug in 2geom? + #~ for r in F.roots(Interval(0.1, 0.8)): + #~ self.assertAlmostEqual(F(r), 0) + #~ self.assertTrue( 0.1 <= r <= 0.8 ) + self.assertIsInstance(F.forward_difference(1), Bezier) + self.assertIsInstance(F.elevate_degree(), Bezier) + self.assertIsInstance(E.reduce_degree(), Bezier) + #F.reduce_degree() fails with + # *** glibc detected *** python2: malloc(): memory corruption: + self.assertIsInstance(F.elevate_to_degree(4), Bezier) + self.assertIsInstance(F.deflate(), Bezier) + S = F.to_SBasis() + self.assertIsInstance(S, SBasis) + for i in range(11): + t = i/10.0 + self.assertAlmostEqual(S(t), F(t)) + + def curve(self, C): + self.assertAlmostEqual(C.initial_point(), C(0)) + self.assertAlmostEqual(C.final_point(), C.point_at(1)) + #Doesn't have to be true + #~ if C.length() > 0.01: + #~ self.assertFalse(C.is_degenerate()) + + if C.is_degenerate(): + #trivial special case + return + + for i in range(11): + t = i/10.0 + self.assertAlmostEqual(C(t).x, C.point_at(t).x) + self.assertAlmostEqual(C(t).y, C.value_at(t, 1)) + self.assertEqual( C(t), C.point_and_derivatives(t, 1)[0] ) + self.assertTrue( C.bounds_exact().contains(C(t)) ) + self.assertTrue( C.bounds_fast().contains(C(t)) ) + #TODO why this works only with degree = 0? + if C.bounds_local(OptInterval(t-0.05, t+0.05), 0 + ) and ( + C.bounds_local(OptInterval(t-0.05, t+0.05), 0).Rect.area() > 1e-10): + #ruling out too small rectangles, they have problems with precision + self.assertTrue( C.bounds_local( OptInterval(t-0.05, t+0.05), 0 ).Rect.contains(C(t))) + D = C.duplicate() + + D.set_initial(Point()) + self.assertAlmostEqual(D.initial_point(), Point()) + + D.set_final(Point(1, 1)) + self.assertAlmostEqual(D.final_point(), Point(1, 1)) + + A = Affine( uniform(-10, 10), + uniform(-10, 10), + uniform(-10, 10), + uniform(-10, 10), + uniform(-10, 10), + uniform(-10, 10)) + E = C.transformed(A) + for i in range(11): + t = i/10.0 + # self.assertAlmostEqual( E(t), C(t)*A ) + G1 = C.portion(0.2, 0.8) + G2 = C.portion( interval=Interval(2, 8)/10 ) + self.assertAlmostEqual( G1(0), C(0.2) ) + self.assertAlmostEqual( G2(0.5), C( lerp(0.5, 0.2, 0.8) )) + self.assertAlmostEqual( G1(1), G2(1) ) + + for i in range(11): + t = i/10.0 + self.assertAlmostEqual( C.reverse()(t), C(1-t) ) + self.assertAlmostEqual( C.point_and_derivatives(0.3, 1)[1], C.derivative()(0.3) ) + + self.assertAlmostEqual( C.nearest_time(C(0)), 0 ) + self.assertAlmostEqual( C( C.nearest_time(C(0.5), interval=Interval(0.2, 0.5)) ), C(0.5) ) + self.assertAlmostEqual( C( C.nearest_time(C(0.5), 0.2, 0.5) ), C(0.5) ) + for p in C.all_nearest_times( C(0), 0, 1): + self.assertEqual(C(p), C(0)) + for p in C.all_nearest_times( C(1), interval=Interval(0, 1)): + self.assertEqual(C(p), C(1)) + for r in C.roots(0, 0): + self.assertAlmostEqual(C.value_at(r, 0), 0) + + self.assertGreaterEqual(C.length(), abs(C(1) - C(0))) + self.assertEqual(C.winding(Point()), int(C.winding(Point())) ) + self.assertAlmostEqual( C.unit_tangent_at(0.5), + Point.unit_vector(C.derivative()(0.5)) ) + self.assertTrue(isinstance(C.to_SBasis()[0], SBasis)) + + def test_sBasisCurve(self): + S = SBasisCurve(SBasis(0, 2), SBasis(3, 7)*SBasis(1, 8)) + a = SBasis(3, 9)*SBasis(4, 6) + b = SBasis(2, 0) + c = a(b) + self.curve(S) + self.curve(S.derivative()) + self.curve(S.reverse()) + self.curve(S.transformed( Scale(4) )) + self.curve(S.transformed( Zoom(9, Translate(3, 6)) )) + self.curve(SBasisCurve(a*b*c, a+b+c)) + self.curve(S.derivative().derivative()) + + def test_bezierCurve(self): + B = BezierCurve.create( [ Point(0, 5), Point(3, 65), Point(-3, 2), Point(1, 9) ] ) + C = BezierCurve.create( [ Point(0,1), Point(1, 0) ] ) + self.curve(B) + self.curve(C) + self.curve(C.reverse()) + self.curve(B.portion(0, 2)) + self.curve(B.transformed(Zoom(9, Translate(3, 6)))) + self.curve(B.derivative()) + + def ntest_lineSegment(self): + L = LineSegment(Point(2, 8), Point(1, 9)) + K = LineSegment.from_beziers(Bezier(2, 8), Bezier(-1, 9)) + self.curve(L) + self.curve(K) + self.curve(L.reverse()) + self.curve(L.portion(Interval(0.2, 0.4))) + self.curve(L.subdivide(0.3)[0]) + self.curve(L.subdivide(0.3)[1]) + self.curve(L.derivative()) + self.curve(L.transformed(Scale(30)*Translate(3, 9))) + + self.curve(LineSegment()) + + def test_quadraticBezier(self): + Q = QuadraticBezier(Point(2, 8), Point(1, 9), Point(-2, 3)) + R = QuadraticBezier.from_beziers(Bezier(2, 8, 4), Bezier(-1, 9, 9)) + self.curve(Q) + self.curve(R) + self.curve(Q.reverse()) + self.curve(Q.portion(interval=Interval(0.1, 0.9))) + self.curve(Q.subdivide(0.8)[0]) + self.curve(Q.subdivide(0.8)[1]) + self.curve(Q.derivative()) + self.curve(Q.transformed(Scale(-3)*Translate(4, 8))) + + self.curve(QuadraticBezier()) + + def test_cubicBezier(self): + C = CubicBezier(Point(2, 0), Point(-1, 2.9), Point(-2, 3), Point(3, 1)) + D = CubicBezier.from_beziers(Bezier(2, 8, 4, 7), Bezier(-1, 9, 9, 8)) + print 343 + self.curve(C) + self.curve(D) + self.curve(C.reverse()) + #Some kind of numerical instability imo + #~ self.curve(C.portion(Interval(0.1, 0.9))) + self.curve(C.subdivide(0.8)[0]) + self.curve(C.subdivide(0.8)[1]) + self.curve(C.derivative()) + self.curve(C.transformed(Scale(-3)*Translate(4, 8))) + + self.curve(CubicBezier()) + + def test_hLineSegment(self): + H = HLineSegment(Point(3, 9), Point(9, 9)) + I = HLineSegment(Point(1, 3), Point(92, 3)) + J = HLineSegment.from_point_length( Point(2, 4), 1) + self.curve( H ) + self.curve( I ) + self.curve( J ) + self.curve( H.portion(0, .25) ) + self.curve( H.derivative() ) + self.curve( H.transformed(Rotate(20)) ) + self.curve( HLineSegment() ) + self.curve( I.reverse() ) + map(self.curve, I.subdivide(0.8)) + + self.assertAlmostEqual(I.get_Y(), 3) + J.set_Y(2) + J.set_initial_X(0) + J.set_final_X(1) + self.assertAlmostEqual( J(0), Point(0, 2) ) + self.assertAlmostEqual( J(1), Point(1, 2) ) + + def test_vLineSegment(self): + V = VLineSegment(Point(2, 9), Point(2, 6)) + W = VLineSegment(Point(1, 2), Point(1, 8)) + X = VLineSegment.from_point_length( Point(2, 4), 1) + #~ self.curve( V ) + #~ self.curve( W ) + #~ self.curve( X ) + #~ self.curve( V.portion(0, .25) ) + #~ self.curve( V.derivative() ) + #~ self.curve( V.transformed(Rotate(20)) ) + #~ self.curve( VLineSegment() ) + #~ self.curve( W.reverse() ) + #~ map(self.curve, W.subdivide(0.8)) + #~ + #~ self.assertAlmostEqual(I.get_Y(), 3) + #~ X.set_Y(2) + #~ X.set_initialX(0) + #~ X.set_finalX(1) + #~ self.assertAlmostEqual( X(0), Point(0, 2) ) + #~ self.assertAlmostEqual( X(1), Point(1, 2) ) + #~ print V(0.5) + #~ print V.nearest_time(V(0.5), 0.1, 0.4 ) + #~ print V.nearest_time(V(0.5), Interval(0.2, 0.5)) + #~ print V(0.5), V(0.2) + #TODO: + #this is likely a bug in 2geom, following code + + #~ VLineSegment V(Point(0, 0), 2); + #~ printf("%f\n", V.nearest_time(V(0.5), 0.2, 0.5)); + + #prints + #0.2 + + def test_ellipticalArc(self): + E = EllipticalArc() + self.curve(E) + F = EllipticalArc(Point(), 1, 2, math.pi/6, True, True, Point(1, 1)) + + self.assertTrue(F.sweep()) + self.assertTrue(F.large_arc()) + self.assertAlmostEqual(F.chord()(0), Point()) + self.assertAlmostEqual(F.chord()(1), Point(1, 1)) + + F.set_extremes(Point(1, 1), Point(-1, 1)) + self.assertAlmostEqual(F.initial_point(), Point(1, 1)) + self.assertAlmostEqual(F.final_point(), Point(-1, 1)) + self.assertEqual(F.initial_angle(), F.angle_at(0)) + self.assertEqual(F.final_angle(), F.angle_at(1)) + self.assertTrue(F.contains(F.angle_at(0.5))) + + G = EllipticalArc(Point(), 1, 1, 0, True, True, Point(2, 0)) + for i in range(11): + t = i/10.0 + print G(t) + self.assertAlmostEqual(G.extent(), math.pi) + self.assertAlmostEqual(G.extent(), G.sweep_angle()) + self.assertAlmostEqual(float(G.angle_at(0.5)), -math.pi/2) + + self.assertAlmostEqual(Point(1, 1), G.rays()) + self.assertAlmostEqual(1, G.ray(1)) + self.assertAlmostEqual(0, float(G.rotation_angle())) + + self.assertAlmostEqual(G.extent(), G.angle_interval().extent()) + + self.assertAlmostEqual(G.center(), Point(1, 0)) + #unit half-circle + U = EllipticalArc(Point(1, 0), 1, 1, 0, True, True, Point(-1, 0)) + + G.set(Point(), 1, 1, 0, True, False, Point(1, 0)) + + A = G.unit_circle_transform() + + self.assertAlmostEqual( G(0.5), U.transformed(A)(0.5) ) + self.assertAlmostEqual( G.value_at_angle(G.angle_at(0.32), 0), G.value_at(0.32, 0) ) + + self.assertTrue(G.contains_angle(Angle(math.pi/4))) + self.assertFalse(G.is_SVG_compliant()) + #~ self.curve(F) + #TODO: + #F.point_and_derivatives(t, 1)[0] differs from F(0) and F.bounds_exact, + #F.bounds_fast doesn't contain F(1) + +unittest.main() diff --git a/src/cython/test-path.py b/src/cython/test-path.py new file mode 100644 index 0000000..6ad6af4 --- /dev/null +++ b/src/cython/test-path.py @@ -0,0 +1,218 @@ +import unittest +import math +from random import randint, uniform + +import cy2geom + +from cy2geom import Point, IntPoint +from cy2geom import Interval, IntInterval, OptInterval, OptIntInterval + +from cy2geom import Affine +from cy2geom import Translate, Scale, Rotate, VShear, HShear, Zoom +from cy2geom import Eigen + +from cy2geom import Curve +from cy2geom import Linear +from cy2geom import SBasis, SBasisCurve +from cy2geom import Bezier, BezierCurve + +from cy2geom import LineSegment, QuadraticBezier, CubicBezier +from cy2geom import HLineSegment, VLineSegment + +from cy2geom import EllipticalArc + +from cy2geom import Path + +#TODO! move drawing elsewhere, it nice to see paths, but is not very suitable for automatic testing +draw = False + +try: + import utils +except ImportError: + print "No drawing with Tk" + draw = False + +class TestPrimitives(unittest.TestCase): + def curves_equal(self, C1, C2): + for i in range(101): + t = i/100.0 + self.assertAlmostEqual(C1(t), C2(t)) + def path(self, P): + for curve in P: + self.assertIsInstance(curve, Curve) + + self.assertAlmostEqual(P(0), P.front()(0)) + self.curves_equal(P.front(), P[0]) + + self.curves_equal(P.back_default(), P[P.size_default()-1]) + self.curves_equal(P.back_open(), P.back()) + self.assertEqual(P.size_open(), P.size()) + + self.assertFalse(P.empty() ^ (P.size()==0)) + + exact = P.bounds_exact().Rect + exact.expand_by(1e-5) + + fast = P.bounds_fast().Rect + fast.expand_by(1e-5) + A1 = Affine(3, 1, 8, 3, 9, 9) + A2 = Rotate(0.231) + + for i in range(100 * P.size_open() + 1): + t = i/100.0 + self.assertTrue(exact.contains(P(t))) + self.assertTrue(fast.contains(P(t))) + self.assertAlmostEqual( (P*A1)(t) , P(t)*A1 ) + self.assertAlmostEqual( (P*A2)(t) , P(t)*A2 ) + + self.assertAlmostEqual(P(t), P.point_at(t)) + self.assertAlmostEqual(P(t).x, P.value_at(t, 0)) + self.assertAlmostEqual(P(t).y, P.value_at(t, 1)) + + if P.closed(): + self.curves_equal(P.back_default(), P.back_closed()) + self.assertEqual(P.size_default(), P.size_closed()) + else: + self.curves_equal(P.back_default(), P.back_open()) + self.assertEqual(P.size_default(), P.size_open()) + + for i in range(10): + for root in P.roots(i, 0): + if root < P.size_default(): + self.assertAlmostEqual(P.value_at(root, 0), i) + for root in P.roots(i, 1): + if root < P.size_default(): + self.assertAlmostEqual(P.value_at(root, 1), i) + + for t in P.all_nearest_times(P(0)): + self.assertAlmostEqual(P(t), P(0)) + self.assertAlmostEqual(min(P.all_nearest_times( P(0) )), 0) + self.assertAlmostEqual(P.nearest_time(P(0), 0, 0.2), 0) + self.assertEqual( len(P.nearest_time_per_curve(Point())), P.size_default() ) + + t, distSq = P.nearest_time_and_dist_sq(Point(-1, -1), 0, P.size()) + self.assertAlmostEqual(distSq**0.5, abs(P(t)-Point(-1, -1)) ) + + self.assertAlmostEqual(P.portion(0.3, 0.4)(0), P(0.3)) + self.assertAlmostEqual( P.portion( interval=Interval(P.size(), P.size() * 2) / 3 )(0), + P(P.size()/3.0)) + + self.assertAlmostEqual(P(0.23), P.reverse()(P.size()-0.23)) + + self.assertAlmostEqual(P.initial_point(), P(0)) + self.assertAlmostEqual(P.final_point(), P(P.size())) + def test_path(self): + a = Path() + a.append_curve( CubicBezier( Point(-7, -3), Point(2, 8), Point(2, 1), Point(-2, 0) ) ) + + self.assertEqual(a.size(), 1) + self.assertFalse(a.closed()) + self.path(a) + + a.close(True) + self.assertTrue(a.closed()) + self.path(a) + + a.close(False) + a.append_curve( LineSegment(a.final_point(), Point(3, 5)) ) + self.assertEqual(a.size(), 2) + self.path(a) + + a.append_SBasis( SBasis(3, 6)*SBasis(1, 0), SBasis(5, 2)) + self.path(a) + + a.append_curve(EllipticalArc(Point(), 1, 2, math.pi/6, True, True, Point(1, 1)), Path.STITCH_DISCONTINUOUS) + #Stitching adds new segment + self.assertEqual(a.size(), 5) + + b = Path() + for c in a: + b.append_curve(c) + + #TODO: This fails with STITCH_DISCONTINUOUS, but also does so in C++, so + #it's either correct behaviour or bug in 2geom + #~ self.path(b) + + b.insert(2, LineSegment(b[2-1](1), b[2](0))) #, Path.STITCH_DISCONTINUOUS) + self.curves_equal(LineSegment(b[2-1](1), b[2](0)), b[2]) + #TODO! fails on root finding + #self.path(b) + + b.set_initial(a[2](1)) + b.set_final(a[3](0)) + + a.insert_slice(3, b, 0, b.size()) + self.assertEqual(a.size(), b.size()*2-1) + + for i in range(b.size()): + self.curves_equal(a[3+i], b[i]) + + #Looks like bug: +# A = Path() +# A.append_curve( CubicBezier( Point(-7, -3), Point(2, 8), Point(2, 1), Point(-2, 0) ) ) +# A.append_curve(EllipticalArc(Point(), 1, 2, math.pi/6, True, True, Point(1, 1)), Path.STITCH_DISCONTINUOUS) +# print A.roots(0, 1) + + #Roots are [1.0, 2.768305708350847, 3.25], Point at second root is + #Point (2.32, -0.48) + #and third root is > 3 - it corresponds to root on closing segment, but A is open, + #and computing A(3.25) results in RangeError - this might be bug or feature. + + self.path(a.portion(0.232, 3.12)) + self.path(a.portion( interval=Interval(0.1, 4.7) )) + self.path(a.portion(0.232, 3.12).reverse()) + + b.clear() + self.assertTrue(b.empty()) + + aa = Path() + for c in a: + aa.append_curve(c) + + a.erase(0) + self.assertEqual(a.size(), aa.size() - 1) + self.assertAlmostEqual(a(0), aa(1)) + + a.erase_last() + self.assertEqual(a.size(), aa.size() - 2) + self.assertAlmostEqual(a.final_point(), aa[aa.size()-2](1)) + + a.replace(3, QuadraticBezier(a(3), Point(), a(4))) + self.assertEqual(a.size(), aa.size() - 2) + + cs = [LineSegment(Point(-0.5, 0), Point(0.5, 0)).transformed( Rotate(-math.pi/3 * i)*Translate(Point(0, math.sqrt(3)/2)*Rotate(-math.pi/3 * i)) ) for i in range(6)] + + hexagon = Path.fromList(cs, stitching = Path.STITCH_DISCONTINUOUS, closed = True) + + if draw: + utils.draw(hexagon, scale = 100) + + #to = 5 because each corner contains one stitching segment + half_hexagon = Path.fromPath(hexagon, fr = 0, to = 5) + if draw: + utils.draw(half_hexagon, scale = 100) + + half_hexagon.replace_slice(1, 5, LineSegment(half_hexagon(1), half_hexagon(5))) + self.assertEqual(half_hexagon.size(), 2) + self.assertAlmostEqual(half_hexagon(1.5), Point(0.5, 0)) + + half_hexagon.stitch_to(half_hexagon(0)) + self.assertAlmostEqual(half_hexagon(2.5), Point()) + + a.start(Point(2, 2)) + a.append_SBasis( SBasis(2, 6), SBasis(1, 5)*SBasis(2, 9) ) + self.assertAlmostEqual(a(1), Point(6, 5*9)) + + l = Path.fromList([QuadraticBezier(Point(6, 5*9), Point(1, 2), Point(-2, .21))]) + a.append_path(l) + self.assertAlmostEqual(a.final_point(), l.final_point()) + + k = Path.fromList([QuadraticBezier(Point(), Point(2, 1), Point(-2, .21)).reverse()]) + k.append_portion_to(l, 0, 0.3) + self.assertAlmostEqual(l.final_point(), k(0.3)) + + def test_read_svgd(self): + p = Path.read_svgd("../toys/spiral.svgd") + if draw: + utils.draw(p[0], scale=0.4) +unittest.main() diff --git a/src/cython/test-primitives.py b/src/cython/test-primitives.py new file mode 100644 index 0000000..0edf218 --- /dev/null +++ b/src/cython/test-primitives.py @@ -0,0 +1,288 @@ +import unittest +from math import pi, sqrt + +import cy2geom +from cy2geom import Angle, AngleInterval, Point, IntPoint, Line, Ray +from cy2geom import LineSegment, Curve + +class TestPrimitives(unittest.TestCase): + + def test_angle(self): + self.assertAlmostEqual(Angle.rad_from_deg(45), pi/4) + self.assertAlmostEqual(Angle.deg_from_rad(pi/6), 30) + + p = Point(1, sqrt(3)) + alpha = Angle.from_Point(p) + self.assertAlmostEqual(alpha.degrees(), 60) + + beta = Angle.from_radians(pi/5) + gamma = Angle.from_degrees(36) + self.assertAlmostEqual(beta.radians0(), gamma.radians0()) + self.assertTrue(beta==gamma) + omega = Angle.from_degrees_clock(0) + self.assertAlmostEqual(omega.radians(), pi/2) + + delta = Angle(-pi * 0.5) + self.assertAlmostEqual(delta.degrees(), -90) + self.assertAlmostEqual(delta.radians0(), 1.5*pi) + #degreesClock roughly means [ 90 - Angle.degrees() ] mod 360 + self.assertAlmostEqual(delta.degrees_clock(), 180) + + self.assertAlmostEqual( + (beta + gamma).radians(), + beta.radians()+gamma.radians() ) + self.assertAlmostEqual( (beta - gamma).degrees(), 0) + + def test_angleInterval(self): + A = AngleInterval(Angle(pi/6), Angle(pi/4)) + B = AngleInterval( 0, pi/4, cw = True ) + self.assertEqual(A(0), Angle(pi/6)) + self.assertEqual(A(0.5), A.angle_at(0.5)) + self.assertEqual(A(0), A.initial_angle()) + self.assertEqual(B(1), B.final_angle()) + self.assertFalse(B.is_degenerate()) + self.assertTrue(B.contains(Angle(pi/6))) + self.assertTrue(A.contains(Angle(pi))) + + self.assertAlmostEqual( B.extent(), pi/4 ) + def test_point(self): + p = Point(3, 4) + q = Point(8, 16) + p_inf = Point(float('inf'), 1) + #y axis points downwards + p_ccw = Point(4, -3) + + self.assertAlmostEqual(p.length(), 5) + self.assertAlmostEqual(p.ccw(), p_ccw) + self.assertAlmostEqual(p_ccw.cw(), p) + self.assertAlmostEqual(p[0], 3) + self.assertAlmostEqual(p[1], 4) + + self.assertFalse(p_inf.isFinite()) + self.assertTrue(p.isFinite()) + self.assertFalse(p.isNormalized()) + self.assertTrue((p/p.length()).isNormalized()) + self.assertFalse(p.isZero()) + self.assertTrue((p*0).isZero()) + + self.assertTrue( (p + p.ccw().ccw()).isZero) + self.assertAlmostEqual( (q-p).length(), 13) + + self.assertGreater(q, p) + self.assertGreaterEqual(q, p) + self.assertEqual(p, p) + self.assertNotEqual(p, q) + self.assertLess( Point(1, 1), Point(1, 2) ) + self.assertLessEqual(p, p) + + self.assertTrue( Point.are_near( + Point.polar(pi/4, sqrt(2)), + Point(1, 1) )) + self.assertAlmostEqual(sqrt(2), Point.L2(Point(1, 1))) + self.assertAlmostEqual(2, Point.L2sq(Point(1, 1))) + self.assertAlmostEqual( Point.middle_point(Point(), q), q/2 ) + self.assertAlmostEqual( Point.rot90(p), p.cw() ) + self.assertAlmostEqual( + Point.lerp(0.2, Point(), Point(3,4)).length(), + 1) + self.assertAlmostEqual(Point.dot(p, p_ccw), 0) + self.assertAlmostEqual(Point.dot(p, p_inf), float('inf')) + self.assertAlmostEqual(Point.dot(p, q), 88) + #TODO this might be implemented incorrectly in lib2geom! + self.assertAlmostEqual(Point.cross(p, q), -16) + + self.assertAlmostEqual(Point.distance(p, q), 13) + self.assertAlmostEqual(Point.distanceSq(p, p_ccw), 50) + self.assertAlmostEqual(Point.unit_vector(p), p/5) + + self.assertAlmostEqual(Point.L1(p), 7) + self.assertAlmostEqual(Point.L1(p_inf), float('inf')) + self.assertAlmostEqual(Point.LInfty(q), 16) + self.assertAlmostEqual(Point.LInfty(p_inf), float('inf')) + + self.assertTrue(Point.is_zero(Point())) + self.assertFalse(Point.is_zero(p)) + self.assertTrue(Point.is_unit_vector(p/5)) + self.assertFalse(Point.is_unit_vector(q)) + + self.assertAlmostEqual(Point.atan2(Point(1, 1)), pi/4) + self.assertAlmostEqual(Point.angle_between(p, p_ccw), -pi/2) + self.assertAlmostEqual(Point.abs(-p), p) + #TODO I have no idea what should this function do + # self.assertAlmostEqual( + # Point.constrain_angle(Point(1, 0), Point(0, 1), 1, Point(sqrt(2)/2, sqrt(2)/2)), + # + # )) + + def test_intPoint(self): + p = Point(4.89, 3.21) + self.assertEqual(p.round(), IntPoint(5, 3)) + self.assertEqual(p.floor(), IntPoint(4, 3)) + self.assertEqual(p.ceil(), IntPoint(5, 4)) + + self.assertEqual(p.ceil().x, 5) + self.assertEqual(p.floor().y, 3) + self.assertEqual(IntPoint(), p.floor()-p.floor()) + + a = IntPoint(2, -5) + b = IntPoint(5, 3) + self.assertEqual(IntPoint(7, -2), a+b) + self.assertEqual(IntPoint(3, 8), b-a) + self.assertGreater(b, a) + self.assertGreaterEqual(b, b) + self.assertNotEqual(a, b) + + def test_line(self): + + l = Line(Point(), pi/4) + self.assertAlmostEqual( l.origin(), Point() ) + self.assertAlmostEqual( l.versor(), Point(1, 1)/sqrt(2) ) + self.assertAlmostEqual( l.angle(), pi/4 ) + + k = Line.from_points(Point(), Point(2, 1)) + self.assertFalse(k.is_degenerate()) + self.assertFalse(Line().is_degenerate()) + self.assertAlmostEqual( l.point_at(sqrt(2)), Point(1,1) ) + self.assertAlmostEqual( + k.point_at(43), + Point(k.value_at(43, 0), k.value_at(43, 1))) + self.assertAlmostEqual(k.time_at(Point(4, 2)), sqrt(20)) + self.assertAlmostEqual( + k.time_at_projection(Point(4, 2) + Point(2, -4)), + sqrt(20)) + self.assertAlmostEqual( + k.point_at(k.nearest_time(Point(4, 2) + Point(2, -4))), + Point(4,2)) + self.assertAlmostEqual( + k.time_at_projection(Point(3, 3)), + -k.reverse().time_at_projection(Point(3, 3))) + self.assertAlmostEqual( k.derivative().origin(), k.versor()) + self.assertAlmostEqual(k.normal(), k.versor().cw()) + + roots = k.roots( 3, 0 ) + for root in roots: + self.assertAlmostEqual( k.value_at(root, 0), 3) + + self.assertAlmostEqual(l.normal(), l.normal_and_dist()[0]) + self.assertAlmostEqual(Line.distance(Point(), l), l.normal_and_dist()[1]) + + self.assertAlmostEqual(Line.distance(Point(-1, 1), l), sqrt(2)) + self.assertTrue(Line.are_near(Point(0), l)) + self.assertFalse(Line.are_near(Point(1, 1), k)) + self.assertTrue(Line.are_near(Point(1, 1), k, 2)) + + p = Line(Point(1, 1)) + p_orto = Line(Point(2, 3), pi/2) + p_para = Line(Point(2, 3)) + p_same = Line.from_points(Point(1, 1), Point(5, 1)) + + self.assertTrue(Line.are_orthogonal(p, p_orto)) + self.assertFalse(Line.are_orthogonal(p, p_para)) + self.assertTrue(Line.are_parallel(p, p_para)) + self.assertFalse(Line.are_parallel(p, p_orto)) + self.assertTrue(Line.are_same(p, p_same)) + self.assertFalse(Line.are_same(p, p_para)) + + self.assertTrue(Line.are_collinear( + Point(1,1), + Point(2, 3), + Point(4, 7))) + self.assertAlmostEqual(Line.angle_between(p, p_orto), pi/2) + + m = Line.from_normal_distance(Point(1, -1), 1) + self.assertAlmostEqual(m.angle(), pi/4) + + m = Line.from_LineSegment( LineSegment( Point(2, 2), Point(4, 4) ) ) + self.assertAlmostEqual(m.angle(), pi/4) + + m = Line.from_Ray( Ray(Point(2, 3), 0.2) ) + self.assertAlmostEqual(m.angle(), 0.2) + self.assertAlmostEqual(m.origin(), Point(2, 3)) + + self.assertIsInstance(m.portion(2, 4), Curve) + self.assertAlmostEqual(m.portion(2, 4)(0), m.point_at(2)) + + self.assertIsInstance(m.segment(1, 5), LineSegment) + self.assertAlmostEqual(m.segment(1, 5)(1), m.point_at(5)) + + self.assertAlmostEqual(m.ray(4).origin(), m.point_at(4)) + + m.set_origin(Point()) + self.assertAlmostEqual(m.origin(), Point()) + + m.set_angle(0.2) + self.assertAlmostEqual(m.angle(), 0.2) + + m.set_versor(Point()) + self.assertTrue(m.is_degenerate()) + + m.set_points(Point(2, 9), Point(1, 8)) + self.assertAlmostEqual(m.versor(), Point.unit_vector(Point(1, 8) - Point(2, 9))) + + def test_ray(self): + r = Ray(Point(1,1), pi/4) + self.assertAlmostEqual(r.origin(), Point(1, 1)) + self.assertAlmostEqual(r.versor(), Point(1, 1)/sqrt(2)) + self.assertAlmostEqual(r.angle(), pi/4) + + r.set_origin(Point(4, 3)) + #TODO this should maybe normalize the versor! + r.set_versor(Point(1, -1)/sqrt(2)) + self.assertAlmostEqual(r.origin(), Point(4, 3)) + self.assertAlmostEqual(r.versor(), Point(1, -1)/sqrt(2)) + self.assertAlmostEqual(r.angle(), -pi/4) + + r.set_points(Point(1, 1), Point(1, 3)) + self.assertFalse(r.is_degenerate()) + self.assertFalse(Ray().is_degenerate()) + self.assertAlmostEqual(r.point_at(4), Point(1, 5)) + + #TODO I think this should be expected behaviour +# self.assertAlmostEqual( +# r.pointAt(-3), +# Point(1, 1))) + self.assertAlmostEqual(r.value_at(4, 0), 1) + self.assertAlmostEqual(r.value_at(4, 1), 5) + + roots = r.roots( 3, 1 ) + for root in roots: + self.assertAlmostEqual( r.value_at(root, 1), 3) + + self.assertAlmostEqual( + r.point_at(3) - r.origin(), + r.origin()-r.reverse().point_at(3)) + + self.assertAlmostEqual(Ray.distance(Point(), r), sqrt(2)) + self.assertAlmostEqual(Ray.distance(Point()+r.versor(), r), 1) + + self.assertTrue(Ray.are_near(Point(), r, 2)) + self.assertFalse(Ray.are_near(Point(), r)) + self.assertTrue(Ray.are_same(r, r)) + + q = Ray(r.origin(), r.angle()) + self.assertTrue(Ray.are_same(r, q)) + + q.set_origin(r.origin()+Point(0, 1)) + self.assertFalse(Ray.are_same(r, q)) + #TODO shouldn't this really be 0? + self.assertAlmostEqual(Ray.angle_between(r, q), 2*pi) + + q.set_versor(Point(1, 0)) + q.set_origin(r.origin()) + self.assertAlmostEqual( + Point(1, 1)/sqrt(2), + Ray.make_angle_bisector_ray(q, r).versor()) + + q.set_angle(pi/7) + self.assertAlmostEqual(q.angle(), pi/7) + + self.assertIsInstance(q.portion(2, 4), Curve) + self.assertAlmostEqual(q.portion(2, 4)(0), q.point_at(2)) + + self.assertIsInstance(q.segment(1, 5), LineSegment) + + self.assertAlmostEqual(q.segment(1, 5)(1), q.point_at(5)) + + +unittest.main() + diff --git a/src/cython/test-rectangle.py b/src/cython/test-rectangle.py new file mode 100644 index 0000000..51f3c50 --- /dev/null +++ b/src/cython/test-rectangle.py @@ -0,0 +1,601 @@ +import unittest +from math import pi, sqrt +from random import randint + +import cy2geom + +from cy2geom import Point, IntPoint + +from cy2geom import Interval, IntInterval, OptInterval, OptIntInterval +from cy2geom import GenericInterval, GenericOptInterval + +from cy2geom import Rect, OptRect, IntRect, OptIntRect +from cy2geom import GenericRect + +from fractions import Fraction + + +class TestPrimitives(unittest.TestCase): + def interval_basic(self, I, J): + #for simplicity + self.assertTrue(I.min() >= 0) + self.assertTrue(J.min() >= 0) + a = I.min() + b = I.max(); + self.assertAlmostEqual(I.middle(), (a+b)/2); + self.assertAlmostEqual(I.extent(), (b-a)); + if a != b: + self.assertFalse(I.is_singular()) + else: + self.assertTrue(I.is_singular()) + + I.expand_by(a) + self.assertAlmostEqual(I.min(), 0); + self.assertAlmostEqual(I.max(), a+b) + I.set_min(a) + I.set_max(b) + + self.assertTrue(I.contains(a+ (b-a)/3 )) + self.assertTrue(I.contains(a)) + self.assertTrue(I.contains_interval(I)) + + if (not I.is_singular()) or I.min() != 0 : + pass + self.assertFalse(I.contains_interval(I+I)) + self.assertFalse(I.contains(a-1)) + + c = J.min() + d = J.max() + self.assertAlmostEqual( (I+J).min(), a+c ) + self.assertAlmostEqual((I|J).min(), min(a, c)) + J.set_min(a+2) + J.set_max(b+2) + self.assertEqual(I+2, J) + I.expand_to(2*b) + self.assertAlmostEqual(I.max(), 2*b) + + def test_interval(self): + I = Interval(1.2, 5) + J = Interval(0, 0.3) + self.interval_basic(I, J) + + self.assertTrue(I.interior_contains(I.middle())) + self.assertFalse(I.interior_contains(I.min())) + self.assertFalse(I.interior_contains_interval(I)) + self.assertTrue(I.interior_contains_interval(Interval(I.min()+1, I.max()-1))) + + self.assertTrue(I.interior_intersects(I)) + self.assertFalse(I.interior_intersects(-I)) + p = [1, 2, 3.442, 3] + K = Interval.from_list(p) + self.assertAlmostEqual(K.max(), max(p)) + self.assertAlmostEqual((K+Interval(1.0)).min(), min(p)+1) + L = Interval(10/3.0) + for i in range(3): + K+=L + self.assertAlmostEqual(K.max(), max(p)+10) + + #TODO This 2geom behaviour is a bit strange + self.assertEqual(Interval(3.0)|Interval(5.0), + Interval(3.0, 5.0)) + self.assertAlmostEqual((K-L).max(), (K-10/3.0).max()) + + self.assertAlmostEqual((K*3.4).max(), 3.4*K.max()) + self.assertAlmostEqual((K/3).extent(), K.extent()/3) + + def test_optInterval(self): + I = OptInterval(2.2, 9.3) + J = Interval(3, 13) + K = OptInterval.from_Interval(J) + self.assertEqual(K.Interval, J) + self.interval_basic(K.Interval, I.Interval) + + L = OptInterval() + + self.assertFalse(L) + self.assertTrue( (L&I).is_empty() ) + L.intersect_with(I) + self.assertFalse(L) + + L |= I + + self.assertEqual(L.Interval, I.Interval) + + self.assertEqual((I & K).Interval, Interval(3, 9.3)) + + def test_intInterval(self): + I = IntInterval(2, 6) + J = IntInterval(0, 1) + self.interval_basic(I, J) + p = [3, 2.3, 65.3, 43] + K = IntInterval.from_list(p) + self.assertAlmostEqual(K.max(), int(max(p))) + self.assertAlmostEqual(int((K+IntInterval(1.0)).min()), int(min(p)+1)) + L = IntInterval(3) + for i in range(3): + K+=L + self.assertAlmostEqual(K.max(), int(max(p))+9) + + self.assertEqual(Interval(3)|Interval(5), + Interval(3, 5)) + self.assertAlmostEqual((K-L).max(), (K-3).max()) + + def test_optIntInterval(self): + I = OptIntInterval(2, 9) + J = IntInterval(3, 13) + K = OptIntInterval.from_Interval(J) + self.assertEqual(K.Interval, J) + self.interval_basic(K.Interval, I.Interval) + + L = OptIntInterval() + + self.assertFalse(L) + self.assertTrue( (L&I).is_empty() ) + L.intersect_with(I) + self.assertFalse(L) + + L |= I + + self.assertEqual(L.Interval, I.Interval) + + self.assertEqual((I & K).Interval, IntInterval(3, 9)) + + def test_genericInterval(self): + maxv = 100000 + test_vars = [ + ( (randint(0, maxv), randint(0, maxv)), (randint(0, maxv), randint(0, maxv)) ), + ( (3,), (2, 0) ), + ( (0.0, 9), (4, 1.3)), + ((2.98, sqrt(2)), (sqrt(7),)), + ( (Fraction(1,2), Fraction(3, 7)), ( Fraction(2, 1), ) ) + ] + for a,b in test_vars: + self.interval_basic( GenericInterval(*a), GenericInterval(*b) ) + + def test_genericOptInterval(self): + test_vars = [ + ( (3,), (2, 0) ), + ( (0.0, 9), (4, 1.3)), + ((2.98, sqrt(2)), (sqrt(7),)), + ( (Fraction(1,2), Fraction(3, 7)), ( Fraction(2, 1), ) ) + ] + + for a, b in test_vars: + I = GenericOptInterval(*a) + J = GenericInterval(*b) + K = GenericOptInterval.from_Interval(J) + + self.assertEqual(I, GenericOptInterval.from_Interval(I)) + + self.assertEqual(K.Interval, J) + self.interval_basic(K.Interval, I.Interval) + + L = GenericOptInterval() + + self.assertFalse(L) + self.assertTrue( (L&I).is_empty() ) + L.intersect_with(I) + self.assertFalse(L) + + L |= I + + self.assertEqual(L.Interval, I.Interval) + + if I.intersect_with(K): + if I.Interval.min() <= K.Interval.min(): + if I.Interval.max() >= K.Interval.max(): + self.assertEqual( I & K, K) + else: + self.assertEqual( I & K, GenericInterval(K.min(), I.max())) + else: + if I.Interval.max() >= K.Interval.max(): + self.assertEqual( I & K, GenericInterval(I.min(), K.max())) + else: + self.assertEqual( I & K, I) + + def test_genericRect(self): + A = GenericRect(1, 1, 4, 4) + self.assertEqual( A.min(), (1, 1) ) + B = GenericRect(Fraction(1,4), Fraction(9, 94), Fraction(2, 3), Fraction(23, 37)) + + amin = A.min() + amax = A.max() + + self.assertAlmostEqual(amin[0], A[0].min()) + self.assertAlmostEqual(amax[1], A[1].max()) + self.assertEqual(amin, A.corner(0)) + + self.assertEqual(amin, (A.left(), A.top())) + self.assertEqual(amax, (A.right(), A.bottom())) + + self.assertAlmostEqual( A.width(), A[0].extent() ) + self.assertAlmostEqual( A.height(), A[1].extent() ) + + self.assertEqual( A.dimensions(), ( A.width(), A.height() ) ) + #~ self.assertEqual( A.midpoint(), (A.min() + A.max())/2 ) + self.assertAlmostEqual(A.area(), A.width()*A.height()) + #TODO export EPSILON from 2geom + if A.area() > 0: + self.assertFalse(A.has_zero_area()) + else: + self.assertTrue(A.has_zero_area()) + self.assertAlmostEqual(A.max_extent(), max(A.width(), A.height())) + self.assertGreaterEqual(A.max_extent(), A.min_extent()) + + bmin = B.min() + bmax = B.max() + + pdiag = sqrt((amax[0]-amin[0])**2+(amax[1]-amin[1])**2) + + B.set_min(A.midpoint()) + B.set_max(A.midpoint()) + + self.assertTrue(B.has_zero_area()) + + B.expand_by(A.min_extent()/3.0) + + self.assertTrue(A.contains_rect(B)) + self.assertTrue(A.intersects(B)) + self.assertTrue(B.intersects(A)) + self.assertFalse(B.contains_rect(A)) + + self.assertTrue(A.contains(A.midpoint())) + self.assertFalse(A.contains( (A.midpoint()[0]*3, A.midpoint()[1]*3) )) + + A.union_with(B) + + self.assertEqual( A.min(), amin ) + + B.set_left(bmin[0]) + B.set_top(bmin[1]) + B.set_right(bmax[0]) + B.set_bottom(bmax[1]) + + self.assertEqual(B.min(), bmin) + self.assertEqual(B.max(), bmax) + + B.expand_to( (0, 0) ) + self.assertEqual((0, 0), B.min()) + + B.expand_by(*bmax) + self.assertEqual(bmax, (- (B.min()[0]), - (B.min()[1])) ) + + B.expand_by(-bmax[0], -bmax[1]) + self.assertEqual(B.max(), bmax) + + self.assertEqual( (A+B.min()).max()[0], A.max()[0] + B.min()[0] ) + + #~ self.assertEqual( (A-B.max()).min(), A.min() - B.max() ) + + self.assertEqual( A|A, A ) + + self.assertFalse( A != A ) + + B.set_left(bmin[0]) + B.set_top(bmin[1]) + B.set_right(bmax[0]) + B.set_bottom(bmax[1]) + + #~ self.assertAlmostEqual(Rect.distance(Point(), A), A.min().length()) + #~ self.assertAlmostEqual(Rect.distanceSq(B.min(), A), Rect.distance(B.min(), A)**2 ) + + + + def rect_basic(self, P, Q): + pmin = P.min() + pmax = P.max() + #for simplicity + self.assertTrue(pmin.x > 0) + self.assertTrue(pmin.y > 0) + + self.assertAlmostEqual(pmin.x, P[0].min()) + self.assertAlmostEqual(pmax.y, P[1].max()) + self.assertEqual(pmin, P.corner(0)) + + self.assertEqual(pmin, Point(P.left(), P.top())) + self.assertEqual(pmax, Point(P.right(), P.bottom())) + + self.assertAlmostEqual( P.width(), P[0].extent() ) + self.assertAlmostEqual( P.height(), P[1].extent() ) + + self.assertAlmostEqual( P.aspect_ratio(), P.width()/P.height() ) + self.assertEqual( P.dimensions(), Point( P.width(), P.height() ) ) + self.assertEqual( P.midpoint(), (P.min() + P.max())/2 ) + self.assertAlmostEqual(P.area(), P.width()*P.height()) + #TODO export EPSILON from 2geom + if P.area() > 1e-7: + self.assertFalse(P.has_zero_area()) + self.assertTrue(P.has_zero_area(P.area())) + else: + self.assertTrue(P.has_zero_area()) + self.assertAlmostEqual(P.max_extent(), max(P.width(), P.height())) + self.assertGreaterEqual(P.max_extent(), P.min_extent()) + + qmin = Q.min() + qmax = Q.max() + + pdiag = (pmax-pmin).length() + + Q.set_min(P.midpoint()) + Q.set_max(P.midpoint()) + self.assertTrue(Q.has_zero_area()) + + #print P,Q + Q.expand_by(P.min_extent()/3.0) + + #print P, Q + + self.assertTrue(P.contains_rect(Q)) + self.assertTrue(P.intersects(Q)) + self.assertTrue(Q.intersects(P)) + self.assertFalse(Q.contains_rect(P)) + + self.assertTrue(P.interior_contains_rect(Q)) + self.assertFalse(P.interior_contains_rect(P)) + self.assertTrue(P.interior_intersects(Q)) + self.assertTrue(P.interior_intersects(P)) + + self.assertTrue(P.contains(P.midpoint())) + self.assertFalse(P.contains(P.midpoint()*3)) + + P.union_with(Q) + + self.assertEqual( P.min(), pmin ) + + Q.set_left(qmin.x) + Q.set_top(qmin.y) + Q.set_right(qmax.x) + Q.set_bottom(qmax.y) + + self.assertEqual(Q.min(), qmin) + self.assertEqual(Q.max(), qmax) + + Q.expand_to( Point() ) + self.assertEqual(Point(), Q.min()) + Q.expand_by(qmax) + self.assertEqual(qmax, -Q.min()) + + Q.expand_by(-qmax.x, -qmax.y) + self.assertEqual(Q.max(), qmax) + + self.assertEqual( (P+Q.min()).max(), P.max() + Q.min() ) + + self.assertEqual( (P-Q.max()).min(), P.min() - Q.max() ) + + self.assertEqual( P|P, P ) + + self.assertFalse( P != P ) + + Q.set_left(qmin.x) + Q.set_top(qmin.y) + Q.set_right(qmax.x) + Q.set_bottom(qmax.y) + + self.assertAlmostEqual(Rect.distance(Point(), P), P.min().length()) + self.assertAlmostEqual(Rect.distanceSq(Q.min(), P), Rect.distance(Q.min(), P)**2 ) + + self.assertEqual(P.round_outwards()[0], P[0].round_outwards()) + if P.round_inwards(): + self.assertEqual(P.round_inwards().Rect[1], P[1].round_inwards().Interval) + + + def intrect_basic(self, P, Q): + pmin = P.min() + pmax = P.max() + #for simplicity + self.assertTrue(pmin.x > 0) + self.assertTrue(pmin.y > 0) + + self.assertAlmostEqual(pmin.x, P[0].min()) + self.assertAlmostEqual(pmax.y, P[1].max()) + self.assertEqual(pmin, P.corner(0)) + + self.assertEqual(pmin, IntPoint(P.left(), P.top())) + self.assertEqual(pmax, IntPoint(P.right(), P.bottom())) + + self.assertAlmostEqual( P.width(), P[0].extent() ) + self.assertAlmostEqual( P.height(), P[1].extent() ) + + self.assertAlmostEqual( P.aspect_ratio(), float(P.width())/float(P.height()) ) + self.assertEqual( P.dimensions(), IntPoint( P.width(), P.height() ) ) + self.assertEqual( P.midpoint().x, (P.min() + P.max()).x/2 ) + self.assertAlmostEqual(P.area(), P.width()*P.height()) + + if P.area() > 0: + self.assertFalse(P.has_zero_area()) + else: + self.assertTrue(P.has_zero_area()) + self.assertAlmostEqual(P.max_extent(), max(P.width(), P.height())) + self.assertGreaterEqual(P.max_extent(), P.min_extent()) + + qmin = Q.min() + qmax = Q.max() + + Q.set_min(P.midpoint()) + Q.set_max(P.midpoint()) + self.assertTrue(Q.has_zero_area()) + + Q.expand_by(P.min_extent()/3.0) + + self.assertTrue(P.contains_rect(Q)) + self.assertTrue(P.intersects(Q)) + self.assertTrue(Q.intersects(P)) + self.assertFalse(Q.contains_rect(P)) + + self.assertTrue(P.contains(P.midpoint())) + self.assertFalse(P.contains(P.midpoint()+P.midpoint()+P.midpoint())) + + P.union_with(Q) + + self.assertEqual( P.min(), pmin ) + + Q.set_left(qmin.x) + Q.set_top(qmin.y) + Q.set_right(qmax.x) + Q.set_bottom(qmax.y) + + self.assertEqual(Q.min(), qmin) + self.assertEqual(Q.max(), qmax) + + Q.expand_to( IntPoint() ) + self.assertEqual(IntPoint(), Q.min()) + Q.expand_by(qmax) + self.assertEqual(qmax, IntPoint()-Q.min()) + + Q.expand_by(-qmax.x, -qmax.y) + self.assertEqual(Q.max(), qmax) + + self.assertEqual( (P+Q.min()).max(), P.max() + Q.min() ) + + self.assertEqual( (P-Q.max()).min(), P.min() - Q.max() ) + + self.assertEqual( P|P, P ) + + self.assertFalse( P != P ) + + Q.set_left(qmin.x) + Q.set_top(qmin.y) + Q.set_right(qmax.x) + Q.set_bottom(qmax.y) + + + + def test_rect(self): + + P = Rect(0.298, 2, 4, 5) + + self.interval_basic(P[0], P[1]) + G = Rect(sqrt(2), sqrt(2), sqrt(3), sqrt(3)) + H = Rect.from_xywh(3.43232, 9.23214, 21.523, -0.31232) + + self.rect_basic(P, G) + self.rect_basic(G, H) + + lst = [Point(randint(-100, 100), randint(-100, 100)) for i in range(10)] + + R = Rect.from_list(lst) + + for p in lst: + self.assertTrue(R.contains(p)) + + self.assertAlmostEqual(min(lst).y, R.min().y) + self.assertAlmostEqual(max(lst).y, R.max().y) + + + + def test_optRect(self): + + P = OptRect(0.298, 2, 4, 5) + self.interval_basic(P.Rect[0], P.Rect[1]) + + + G = Rect(sqrt(2), sqrt(2), sqrt(3), sqrt(3)) + H = OptRect.from_rect(G) + + self.rect_basic(P.Rect, G) + + lst = [Point(randint(-100, 100), randint(-100, 100)) for i in range(10)] + + R = OptRect.from_list(lst) + + for p in lst: + self.assertTrue(R.Rect.contains(p)) + + self.assertAlmostEqual(min(lst).y, R.Rect.min().y) + self.assertAlmostEqual(max(lst).y, R.Rect.max().y) + + Q = OptRect() + self.assertFalse(Q) + self.assertTrue(P) + + self.assertTrue(Q.is_empty()) + self.assertFalse(P.is_empty()) + + self.assertTrue(P.contains_rect( P )) + self.assertTrue(P.contains_rect(Q)) + self.assertFalse(Q.contains_rect(P)) + self.assertFalse(P.intersects(Q)) + self.assertTrue(P.contains_rect(P.Rect)) + self.assertTrue(P.contains(P.Rect.midpoint())) + + self.assertEqual(P, OptRect.from_rect(P)) + + P.union_with(G) + P.union_with(H) + self.assertTrue(P.contains_rect(H)) + + P.intersect_with(G) + self.assertEqual(P, G) + + self.assertEqual( P|H, G ) + self.assertEqual( (P|R).Rect.min().x , min( P.Rect.min().x, R.Rect.min().x )) + + self.assertFalse(P & Q) + self.assertEqual(P, P&P) + + self.assertEqual( P & (R | H), (P & R) | (P & H) ) + + def test_intRect(self): + A = IntRect(2, 6, 9, 23) + B = IntRect.from_intervals(IntInterval(1, 5), IntInterval(8, 9)) + C = IntRect.from_points(IntPoint(1, 8), IntPoint(5, 9)) + + self.assertEqual(B, C) + + self.intrect_basic(A, B) + self.intrect_basic(B, C) + self.intrect_basic(C, A) + + def test_optIntRect(self): + P = OptIntRect(1, 2, 4, 5) + self.interval_basic(P.Rect[0], P.Rect[1]) + + + G = IntRect(2, 2, 3, 3) + H = OptIntRect.from_rect(G) + + self.intrect_basic(P.Rect, G) + + lst = [IntPoint(randint(-100, 100), randint(-100, 100)) for i in range(10)] + + R = OptIntRect.from_list(lst) + + for p in lst: + self.assertTrue(R.Rect.contains(p)) + + self.assertAlmostEqual(min(lst).y, R.Rect.min().y) + self.assertAlmostEqual(max(lst).y, R.Rect.max().y) + + Q = OptIntRect() + self.assertFalse(Q) + self.assertTrue(P) + + self.assertTrue(Q.is_empty()) + self.assertFalse(P.is_empty()) + + self.assertTrue(P.contains_rect( P )) + self.assertTrue(P.contains_rect( P.Rect )) + self.assertTrue(P.contains_rect(Q)) + self.assertFalse(Q.contains_rect(P)) + self.assertFalse(P.intersects(Q)) + self.assertTrue(P.contains_rect(P.Rect)) + self.assertTrue(P.contains(P.Rect.midpoint())) + + self.assertEqual(P, OptIntRect.from_rect(P)) + + P.union_with(G) + P.union_with(H) + self.assertTrue(P.contains_rect(H)) + + P.intersect_with(G) + self.assertEqual(P, G) + + self.assertEqual( P|H, G ) + self.assertEqual( (P|R).Rect.min().x , min( P.Rect.min().x, R.Rect.min().x )) + + self.assertFalse(P & Q) + self.assertEqual(P, P&P) + + self.assertEqual( P & (R | H), (P & R) | (P & H) ) + +unittest.main() diff --git a/src/cython/utils.py b/src/cython/utils.py new file mode 100644 index 0000000..1115d32 --- /dev/null +++ b/src/cython/utils.py @@ -0,0 +1,52 @@ +from Tkinter import * + +import math + +import cy2geom +from cy2geom import Point, Path + + +def Nagon(N): + """Return N-agon with side of length 1.""" + side = cy2geom.LineSegment(Point(-0.5, 0), Point(0.5, 0)) + angle = 2*math.pi/N + distance_to_center = 0.5 / math.tan(math.pi/N) + return Path.fromList( + [ side.transformed( + cy2geom.Translate(Point(0, -distance_to_center))* + cy2geom.Rotate(angle*i)) + for i in range(N) + ], + stitching = Path.STITCH_DISCONTINUOUS, + closed = True ) + +def draw(c, dt=0.001, batch=10, scale=20, x_offset = 400, y_offset = 300): + """Draw curve or path.""" + master = Tk() + w = Canvas(master, width=800, height=600) + w.pack() + n = 0 + t = 0 + points = [] + + if isinstance(c, Path): + maxt = c.size_default() + else: + maxt = 1 + + while (t < maxt): + t = n*dt + n+=1 + p = c(t) + points.extend( [ p.x * scale + x_offset, p.y * scale + y_offset] ) + + while points: + draw_points = tuple(points[:batch*2]) + if len(points) == 2: + break + del points[:batch*2] + + l = w.create_line(*draw_points) + w.grid() + + master.mainloop() diff --git a/src/cython/wrapped-pyobject.h b/src/cython/wrapped-pyobject.h new file mode 100644 index 0000000..bd316fb --- /dev/null +++ b/src/cython/wrapped-pyobject.h @@ -0,0 +1,237 @@ +#include "Python.h" +#include "2geom/generic-interval.h" +#include "2geom/generic-rect.h" +#include "2geom/d2.h" + + +namespace Geom{ + +//TODO! looks like memory leak +class WrappedPyObject{ +private: + PyObject* self; +public: + //~ int code; + + WrappedPyObject(){ + //~ printf("Created empty WPO at address %p\n", this); + self = NULL; + //~ code = 0; + } + + WrappedPyObject(WrappedPyObject const &other){ + self = other.getObj(); + //~ code = other.code; + //~ printf("COPY-CONSTRUCTOR %p, this WPO %p, other WPO %p\n", self, this, &other); + Py_XINCREF(self); + } + + WrappedPyObject(PyObject* arg){ + if (arg == NULL){ + //PyErr_Print(); + //~ code = c; + } + else{ + //~ printf("CONSTRUCTOR %p\n", arg); + Py_INCREF(arg); + self = arg; + //~ code = c; + } + } + + WrappedPyObject(int c){ + self = Py_BuildValue("i", c); + //~ printf("INT-OPERATOR= %p, this WPO %p, other WPO %p\n", self, this, &other); + Py_INCREF(self); + } + + + ~WrappedPyObject(){ + //TODO Leaking memory + //~ printf("DECREF %p\n", self); + //Py_DECREF(self); + } + + PyObject* getObj() const { + return self; + } + + WrappedPyObject operator=(WrappedPyObject other){ + if (this != &other){ + self = other.getObj(); + //~ printf("OPERATOR= %p, this WPO %p, other WPO %p\n", self, this, &other); + Py_XINCREF(self); + } + return *this; + } + + WrappedPyObject operator=(int other){ + + self = Py_BuildValue("i", other); + //~ printf("INT-OPERATOR= %p, this WPO %p, other WPO %p\n", self, this, &other); + Py_INCREF(self); + + return *this; + } + + WrappedPyObject operator-() const { + PyObject * ret; + ret = PyObject_CallMethodObjArgs(self, Py_BuildValue("s", "__neg__"), NULL); + if (ret == NULL){ + Py_INCREF(Py_None); + return WrappedPyObject(Py_None); + } + //Py_INCREF(ret); + WrappedPyObject * retw = new WrappedPyObject(ret); + //Py_DECREF(ret); + return *retw; + } + + WrappedPyObject arithmetic(PyObject* const other, std::string method, std::string rmethod) const { + PyObject * ret; + //printf("%p %p\n", self, other); + ret = PyObject_CallMethodObjArgs(self, Py_BuildValue("s", method.c_str()), other, NULL); + if (ret == NULL){ + Py_INCREF(Py_None); + return WrappedPyObject(Py_None); + } + PyObject * isNI = PyObject_RichCompare(ret, Py_NotImplemented, Py_EQ); + if ( PyInt_AsLong(isNI) ){ + ret = PyObject_CallMethodObjArgs(other, Py_BuildValue("s", rmethod.c_str()), self, NULL); + } + if (ret == NULL){ + Py_INCREF(Py_None); + return WrappedPyObject(Py_None); + } + WrappedPyObject * retw = new WrappedPyObject(ret); + return *retw; + + } + + WrappedPyObject operator+(WrappedPyObject const other) const { + return arithmetic(other.getObj(), "__add__", "__radd__"); + } + + WrappedPyObject operator-(WrappedPyObject const other){ + return arithmetic(other.getObj(), "__sub__", "__rsub__"); + } + + WrappedPyObject operator*(WrappedPyObject const other){ + return arithmetic(other.getObj(), "__mul__", "__rmul__"); + } + + WrappedPyObject operator*(int other){ + PyObject* other_obj = Py_BuildValue("i", other); + //Py_INCREF(other_obj); + WrappedPyObject ret = arithmetic(other_obj, "__mul__", "__rmul__"); + //Py_DECREF(other_obj); + return ret; + } + + WrappedPyObject operator/(int other){ + PyObject* other_obj = Py_BuildValue("i", other); + Py_INCREF(other_obj); + WrappedPyObject ret = arithmetic(other_obj, "__div__", "__rdiv__"); + Py_DECREF(other_obj); + return ret; + } + + bool richcmp(WrappedPyObject const &other, int op) const { + PyObject * ret; + long retv; + ret = PyObject_RichCompare(self, other.getObj(), op); + retv = PyInt_AsLong(ret); + return retv; + } + + bool operator<(WrappedPyObject const &other) const { + return richcmp(other, Py_LT); + } + + bool operator<=(WrappedPyObject const &other) const { + return richcmp(other, Py_LE); + } + + bool operator>=(WrappedPyObject const &other) const{ + return richcmp(other, Py_GE); + } + + bool operator>(WrappedPyObject const &other) const { + return richcmp(other, Py_GT); + } + + bool operator==(WrappedPyObject const &other) const { + return richcmp(other, Py_EQ); + } + + + bool operator<(int const c) const { + return richcmp(WrappedPyObject(c), Py_LT); + } + + bool operator<=(int const c) const { + return richcmp(WrappedPyObject(c), Py_LE); + } + + bool operator>=(int const c) const{ + return richcmp(WrappedPyObject(c), Py_GE); + } + + bool operator>(int const c) const { + return richcmp(WrappedPyObject(c), Py_GT); + } + + bool operator==(int const c) const { + return richcmp(WrappedPyObject(c), Py_EQ); + } + + + WrappedPyObject operator+=(WrappedPyObject other){ + *this = *this + other; + return *this; + + } + + WrappedPyObject operator-=(WrappedPyObject other){ + *this = *this - other; + return *this; + } +}; + +typedef GenericInterval PyInterval; +typedef GenericOptInterval PyOptInterval; + +typedef GenericRect PyRect; +typedef GenericOptRect PyOptRect; + +typedef D2 PyPoint; + +template<> +struct CoordTraits { + typedef PyPoint PointType; + typedef PyInterval IntervalType; + typedef PyOptInterval OptIntervalType; + typedef PyRect RectType; + typedef PyOptRect OptRectType; + + typedef + boost::equality_comparable< PyInterval + , boost::additive< PyInterval + , boost::multipliable< PyInterval + , boost::orable< PyInterval + , boost::arithmetic< PyInterval, WrappedPyObject + > > > > > + IntervalOps; + + typedef + boost::equality_comparable< PyRect + //, boost::equality_comparable< PyRect, IntRect + , boost::orable< PyRect + , boost::orable< PyRect, PyOptRect + , boost::additive< PyRect, PyPoint + //, boost::multipliable< Rect, Affine + > > > > //> > + RectOps; +}; + +} diff --git a/src/cython/wrapper.py b/src/cython/wrapper.py new file mode 100644 index 0000000..241782a --- /dev/null +++ b/src/cython/wrapper.py @@ -0,0 +1,360 @@ +import os +import sys +import argparse + +from pygccxml import parser, declarations + +class wType: + def __init__(self, c_str): + self.c_str = c_str + self.wrapped_types = ["bint", "double", "int", "unsigned int", + "Coord", "IntCoord", "Dim2", "size_t"] + + def get_C(self): + """returns plain c string""" + return self.c_str + + def get_Cython_type(self): + """Returns corresponding Cython type string""" + typestr= self.get_C() + typestr= typestr.replace(" const ", " ") + if typestr.find("::Geom::")==0: + typestr = typestr[len("::Geom::"):] + if typestr == "bool": + typestr = "bint" + return typestr + + def get_Python_function_argument(self): + """Returns argument type to Python function call""" + + typestr = self.get_Cython_type() + if typestr[-1]=="&": + typestr = typestr[:-2] + if typestr in self.wrapped_types: + return typestr+" " + return "cy_"+typestr+" " + def get_Python_return(self): + """ Returns a string used to wrap a function returning this type + returns a string to be called with format( 'function call to c function ') + """ + typestr = self.get_Cython_type() + + if typestr[-1] == "&": + typestr = typestr[:-2] + if typestr in self.wrapped_types: + return "return {}" + if typestr == "void": + return "{}" + if typestr[-1] == "*": + typestr = typestr[:-2]+"_p" + return "return wrap_"+typestr+"({})" + + def get_wrap_method(self, delim): + """Returns wrap method in a form of a list of lines""" + ret = [] + typestr = self.get_Cython_type() + + if typestr[-1] == "&": + typestr = typestr[:-2] + if typestr in self.wrapped_types: + return [] + if typestr == "void": + return [] + if typestr[-1] == "*": + typestr = typestr[:-2]+"_p" + ret.append("cdef cy_{} wrap_{}({} p):".format(typestr, typestr, typestr)) + ret.append(delim+"cdef {} * retp = new {}()".format(typestr, typestr)) + ret.append(delim+"retp[0] = p") + ret.append(delim+"cdef cy_{} r = cy_{}.__new__(cy_{})".format(typestr, typestr, typestr)) + ret.append(delim+"r.thisptr = retp") + ret.append(delim+"return r") + return ret + + def get_Python_pass_argument(self): + """ Returns argument to be passed to C function, to be called with .format(arg_name)""" + typestr = self.get_Cython_type() + if typestr[-1]=="&": + typestr = typestr[:-2] + if typestr in self.wrapped_types: + return "{}" + if typestr[-1] == "*": + return "{}.thisptr" + return "deref( {}.thisptr )" + +class CythonWrapper: + def __init__(self, gn): + self.global_namespace = gn + self.delim = ' ' + + def wrap_constructor(self, constructor, types_dict): + pxd_lines = [] + pyx_lines = [] + + pxd_arguments = [] + for argument_type in constructor.argument_types: + pxd_arguments.append( types_dict[argument_type.decl_string].get_Cython_type() ) + pxd_argument_str = "({})".format(", ".join(pxd_arguments)) + + pxd_function_str = constructor.name+pxd_argument_str + pxd_lines.append(self.delim*2+pxd_function_str) + + #python function + arguments_python = ["self"] + for argument in constructor.arguments: + arguments_python.append(types_dict[argument.type.decl_string].get_Python_function_argument()+argument.name) + declaration = "def {}".format("__init__")+"({}):".format(", ".join(arguments_python)) + + arguments_cython = [] + for argument in constructor.arguments: + arguments_cython.append(types_dict[argument.type.decl_string].get_Python_pass_argument().format(argument.name)) + function_call = "new "+constructor.name+"({})".format(", ".join(arguments_cython)) + + return_statement = "self.thisptr = {}".format(function_call) + pyx_lines.append(self.delim+declaration) + pyx_lines.append(self.delim*2 + return_statement) + + return (pxd_lines, pyx_lines) + + def wrap_operator(self, operator, types_dict): + pxd_lines = [] + pyx_lines = [] + + pxd_arguments = [] + for argument_type in operator.argument_types: + pxd_arguments.append( types_dict[argument_type.decl_string].get_Cython_type() ) + pxd_argument_str = "({})".format(", ".join(pxd_arguments)) + boost_wrapped = ["operator{}=".format(i) for i in ["+", "-", "*", "/", "|", "&"]] + pxd_function_str = types_dict[operator.return_type.decl_string].get_Cython_type()+\ + " "+operator.name+pxd_argument_str + + if not (operator.name in boost_wrapped): + pxd_lines.append(self.delim*2+pxd_function_str) + + else: + pxd_lines.append(self.delim*2+"#"+pxd_function_str) + + pxd_function_str = types_dict[operator.return_type.decl_string].get_Cython_type()+\ + " "+operator.name[:-1]+pxd_argument_str + pxd_lines.append(self.delim*2+pxd_function_str) + + + special_methods = { + "+" : "__add__", + "-" : "__sub__", + "*" : "__mul__", + "/" : "__div__", + "|" : "__or__", + "&" : "__and__", + "[]": "__getitem__", + "()": "__call__", + "==": "__richcmp__", + "!=": "__richcmp__" + } + + if operator.name in boost_wrapped: + operation = operator.name[-2] + else: + operation = operator.name[ len("operator"): ] + + if operation in special_methods: + python_name = special_methods[operation] + else: + python_name = operator.name + + arguments_python = ["self"] + for argument in operator.arguments: + arguments_python.append(types_dict[argument.type.decl_string].get_Python_function_argument()+argument.name) + declaration = "def {}".format(python_name)+"({}):".format(", ".join(arguments_python)) + + arguments_cython = [] + for argument in operator.arguments: + arguments_cython.append(types_dict[argument.type.decl_string].get_Python_pass_argument().format(argument.name)) + function_call = "deref( self.thisptr ) "+operation+" {}".format(", ".join(arguments_cython)) + + return_statement = types_dict[operator.return_type.decl_string].get_Python_return().format(function_call) + + if (operator.arguments == []) and (operation == '-'): + declaration = "def __neg__(self):" + pyx_lines.append(self.delim+declaration) + pyx_lines.append(self.delim*2 + return_statement) + + return (pxd_lines, pyx_lines) + + def wrap_method(self, method, types_dict): + pxd_lines = [] + pyx_lines = [] + + pxd_arguments = [] + for argument_type in method.argument_types: + pxd_arguments.append( types_dict[argument_type.decl_string].get_Cython_type() ) + pxd_argument_str = "({})".format(", ".join(pxd_arguments)) + + + pxd_function_str = types_dict[method.return_type.decl_string].get_Cython_type()+\ + " "+method.name+pxd_argument_str + pxd_lines.append(self.delim*2+pxd_function_str) + + #python function + arguments_python = ["self"] + for argument in method.arguments: + arguments_python.append(types_dict[argument.type.decl_string].get_Python_function_argument()+argument.name) + declaration = "def {}".format(method.name)+"({}):".format(", ".join(arguments_python)) + + arguments_cython = [] + for argument in method.arguments: + arguments_cython.append(types_dict[argument.type.decl_string].get_Python_pass_argument().format(argument.name)) + function_call = "self.thisptr."+method.name+"({})".format(", ".join(arguments_cython)) + + return_statement = types_dict[method.return_type.decl_string].get_Python_return().format(function_call) + pyx_lines.append(self.delim+declaration) + pyx_lines.append(self.delim*2 + return_statement) + + return (pxd_lines, pyx_lines) + + def wrap_free_function(self, function, types_dict): + pxd_lines = [] + pyx_lines = [] + decl_lines = [] + + pxd_arguments = [] + for argument_type in function.argument_types: + pxd_arguments.append( types_dict[argument_type.decl_string].get_Cython_type() ) + pxd_argument_str = "({})".format(", ".join(pxd_arguments)) + + + pxd_function_str = types_dict[function.return_type.decl_string].get_Cython_type()+\ + " "+function.name+pxd_argument_str + pxd_lines.append(self.delim+pxd_function_str) + + #python function + arguments_python = [] + for argument in function.arguments: + arguments_python.append(types_dict[argument.type.decl_string].get_Python_function_argument()+argument.name) + declaration = "def cy_{}".format(function.name)+"({}):".format(", ".join(arguments_python)) + + decl_lines.append("from _cy_??? import cy_{0} as {0}".format(function.name)) + + arguments_cython = [] + for argument in function.arguments: + + arguments_cython.append(types_dict[argument.type.decl_string].get_Python_pass_argument().format(argument.name)) + function_call = function.name+"({})".format(", ".join(arguments_cython)) + + return_statement = types_dict[function.return_type.decl_string].get_Python_return().format(function_call) + pyx_lines.append(declaration) + pyx_lines.append(self.delim + return_statement) + + return (pxd_lines, pyx_lines, decl_lines) + + + def wrap_class(self, class_name, class_file): + pxd_lines = [] + pyx_lines = [] + decl_lines = [] + other_lines = [] + + pxd_lines.append("cdef extern from \"2geom/{}\" namespace \"Geom\":".format(class_file)) + pxd_lines.append(self.delim+"cdef cppclass {}:".format(class_name)) + pyx_lines.append("cdef class cy_{}:".format(class_name)) + pyx_lines.append(self.delim+"cdef {}* thisptr".format(class_name)) + #get_types + types_dict = self.collect_types(class_name) + #parse + c_class = self.global_namespace.namespace(name = "Geom").class_(name=class_name) + + for member in c_class.get_members(): + if isinstance(member, declarations.calldef.constructor_t): + pxd, pyx = self.wrap_constructor(member, types_dict) + pxd_lines += pxd + pyx_lines += pyx + elif isinstance(member, declarations.calldef.member_operator_t): + pxd, pyx = self.wrap_operator(member, types_dict) + pxd_lines += pxd + pyx_lines += pyx + elif isinstance(member, declarations.calldef.member_function_t): + pxd, pyx = self.wrap_method(member, types_dict) + pxd_lines += pxd + pyx_lines += pyx + + pyx_lines.append("#free functions:") + for ff in self.global_namespace.namespace(name = "Geom").free_funs(): + if os.path.basename(ff.location.file_name) == class_file: + pxd, pyx, decl = self.wrap_free_function(ff, types_dict) + pxd_lines += map(lambda x: x[4:], pxd) + pyx_lines += pyx + decl_lines += decl + + for ff in self.global_namespace.namespace(name = "Geom").free_operators(): + if os.path.basename(ff.location.file_name) == class_file: + pxd, pyx = self.wrap_operator(ff, types_dict) + pxd_lines += map(lambda x: x[4:], pxd) + pyx_lines += pyx + + pyx_lines.append("") + for ctype in types_dict: + wtype = types_dict[ctype] + for line in wtype.get_wrap_method(self.delim): + pyx_lines.append(line) + print "------" + for i in pxd_lines: + print i + print "------" + for i in pyx_lines: + print i + print "------" + for i in decl_lines: + print i + + + def collect_types(self, class_name): + types_set = set() + c_class = self.global_namespace.namespace(name = "Geom").class_(name=class_name) + for member in c_class.get_members(): + if any([isinstance(member, declarations.calldef.constructor_t), + isinstance(member, declarations.calldef.member_operator_t), + isinstance(member, declarations.calldef.member_function_t)]): + for a_type in member.argument_types: + types_set.add(a_type.decl_string) + if isinstance(member, declarations.calldef.member_operator_t) or isinstance(member, declarations.calldef.member_function_t): + types_set.add(member.return_type.decl_string) + for ff in list(self.global_namespace.namespace(name = "Geom").free_funs()) + list(self.global_namespace.namespace(name = "Geom").free_operators()): + for a_type in ff.argument_types: + types_set.add(a_type.decl_string) + types_set.add(ff.return_type.decl_string) + types_dict = dict() + + for f_type in types_set: + + types_dict[f_type] = wType(f_type) + return types_dict + +def main(): + + #set up argument parser + cmd_parser = argparse.ArgumentParser() + cmd_parser.add_argument('--lib2geom_dir', action = 'store') + cmd_parser.add_argument('--file_name', action = 'store') + cmd_parser.add_argument('--class_name', action = 'store') + cmd_args = cmd_parser.parse_args() + + #set up pygccxml + includes = [cmd_args.lib2geom_dir, + os.path.join(cmd_args.lib2geom_dir, 'src'), + "/usr/include/boost"] + + config = parser.config_t(compiler='gcc', + include_paths=includes, + cflags="") + + file_to_parse = [os.path.join(cmd_args.lib2geom_dir, "src", "2geom", cmd_args.file_name)] + + decls = parser.parse( file_to_parse, config ) + global_namespace = declarations.get_global_namespace( decls ) + wrapper = CythonWrapper(global_namespace) + wrapper.wrap_class(cmd_args.class_name, cmd_args.file_name) + +main() + +#run with +#python2 wrapper.py --lib2geom_dir ../../.. --file_name int-point.h --class_name IntPoint +#from cython-bindings directory -- cgit v1.2.3