Data

Tools

Indexes

Applications

Experiments

Open Source Science

Recent Releases of Helper for Bézier Curves, Triangles, and Higher Order Objects

Helper for Bézier Curves, Triangles, and Higher Order Objects - 2024.6.20

PyPI link to release 2024.6.20 Documentation for release 2024.6.20

libbezzier Changes

Packaging

  • Stop building with -static on Windows (#311). This is entirely enabled by the amazing delvewheel project (non-static dependencies can now easily be packaged into a built wheel for Python).

Python Changes

Packaging

  • Added support for Python 3.12 (#315).
  • Dropped support for Python 3.8 (#310) and Python 3.9 (#315).

Documentation

  • Add DEVELOPMENT.rst section about configuring a shell and compilers for Windows development (#311). This had been a hodge podge of local and remote (CI) development for the last 5+ years, so this a big milestone!

Scientific Software - Peer-reviewed - Python
Published by dhermes almost 2 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 2023.7.28

PyPI link to release 2023.7.28 Documentation for release 2023.7.28

Robustness

  • Fall back to de Casteljau algorithm for evaluation on high degree curves (#264). Fixed #263. The more efficient evaluate_multi_vs() function relies on the ability to compute binomial coefficients (n C k) but after (55 C 26) these values cannot be computed in floating point without roundoff and for very large degrees these values overflow.

Python Changes

Packaging

  • Switched to delvewheel for repairing Windows wheels (#307). This is similar to how Linux and macOS packaging already work. This is vastly superior to the homegrown approach previously used with extra-dll.
  • Dropped support for Python 3.7 and added support for Python 3.10 and 3.11 (#271, #302).
  • Add strict check for Python version on source installs. Fixed #278.
  • Make missing BEZIER_INSTALL_PREFIX error message more helpful. In particular, add a suggestion to set BEZIER_NO_EXTENSION for a source only install if BEZIER_INSTALL_PREFIX cannot be set. Fixed #277.
  • Use cibuildwheel to automate building wheels as part of release (#308).

Bug Fixes

  • Allow the extra DLL directory to be absent on Windows. For binary wheel installs, this directory contains the libbezier DLL (e.g. bezier.libs\bezier-2a44d276.dll). For pure Python installs, the bezier.libs directory will be absent. (#307, #255). Fixed #254.
  • Bug fix for clip_range() (doc). Intersections with the t=0 / t=1 sides of the fat line were not taken into account and a value for s_max could be accidentally left unset if the intersections occurred in an order where the s-value decreased throughout (#259).

Breaking Changes

  • Removing Surface alias for the Triangle type (#252). The Surface type was deprecated (and converted to an alias) in the 2020.1.14 release.

Additive Changes

  • Renaming all \"private\" _verify args to verify (#251). For example, in Curve.intersect() (doc)
  • Adding provisional support for self-intersection checks in planar curves (#265, #267). Fixed #165 and #171. Supported via Curve.self_intersections() method.
  • Added alpha argument to Triangle.plot() and CurvedPolygon.plot() methods (#296).

Documentation

  • Making all docs pages import external packages at least once (#257). Fixed #210.

Scientific Software - Peer-reviewed - Python
Published by dhermes almost 3 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 2021.2.12

PyPI link to release 2021.2.12 Documentation for release 2021.2.12

Python Changes

Packaging

  • Dropped support for Python 3.6 and added support for Python 3.9 (#246).

Breaking Changes

  • Moved non-public / experimental bezier._clipping module to bezier.hazmat.clipping (#225).

Scientific Software - Peer-reviewed - Python
Published by dhermes over 5 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 2020.5.19

PyPI link to release 2020.5.19 Documentation for release 2020.5.19

Python Changes

Bug Fixes

  • Using importlib.metadata to locate extra-dll on Windows, caused by the behavior of the conda-supplied setuptools in Python 3.8 (#208, fixed #206).

Breaking Changes

  • Created bezier.hazmat subpackage (fixed #170).
    • Moved non-public bezier._py_helpers module to bezier.hazmat.helpers (#201).
    • Moved non-public bezier._algebraic_intersection module to bezier.hazmat.algebraic_intersection (#216).
    • Moved non-public bezier._py_curve_helpers module to bezier.hazmat.curve_helpers (#218).
    • Moved non-public bezier._py_triangle_intersection module to bezier.hazmat.triangle_intersection (#219).
    • Moved non-public bezier._py_triangle_helpers module to bezier.hazmat.triangle_helpers (#220).
    • Moved non-public bezier._py_intersection_helpers module to bezier.hazmat.intersection_helpers (#222).
    • Moved non-public bezier._py_geometric_intersection module to bezier.hazmat.geometric_intersection (#223).

Documentation

  • Updated binary-extension doc to refer to bezier.libs (#211). This is based on a change to auditwheel from the 3.1.0 release.
  • Removed algorithms/algebraic-helpers document since the bezier.hazmat.algebraic_intersection module is now fully documented (#216).
  • Updated from https://docs.scipy.org/doc/numpy to https://numpy.org for references to the NumPy documentation (#221).
  • Removed algorithms/geometric-helpers document since the functions and classes there are now fully documented in bezier.hazmat (#223).

Scientific Software - Peer-reviewed - Python
Published by dhermes about 6 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 2020.2.3

PyPI link to release 2020.2.3 Documentation for release 2020.2.3

ABI Changes

Packaging

  • Introduced first-class build and install support for libbezier via CMake. Achieved with the following PRs

    • Added CMakeLists.txt files to enable building libbezier with CMake (#175).
    • Added -DTARGET_NATIVE_ARCH:BOOL=OFF flag to enable portable release builds (#182).

    and closed the following issues - Use a shared library (rather than a static library) for libbezier (#54). - Enable Python installs to be "hybrid-editable" (#56). (This means that the Python files reference the source tree but the built components, i.e. libbezier and _speedup.so, are already built and utilize caching of CMake.) - Use build system other than Python / distutils / setuptools (#62). - Add ability to disable -march=native flag to make release builds portable across compatible operating systems (#181).

Python Changes

Additive Changes

  • Exposing Curve.evaluate_hodograph() method as part of the public API (#191). Fixed #138.

Packaging

  • Removed build dependency on gfortran and other heavyweight tools (and hacks) such as numpy.distutils. Now, libbezier must be built before the Python package can be installed and the install location must be provided via the BEZIER_INSTALL_PREFIX environment variable. Achieved with the following PRs
    • Requiring prebuilt libbezier when building bezier._speedup Python binary extension (#176).
    • Support building of wheels on all platforms that depend on libbezier (#182).
  • Switch from manylinux1 to manylinux2010 for built wheels (#178).
  • Delaying imports of pkg_resources, scipy and sympy until actually needed (if ever) (#194, #195, 38602d8).
  • Adding matplotlib to pip install bezier[full] (8beb036).
  • Avoiding bezier.dll name collision on Windows in wheels distributed on PyPI (#190). Fixed #189.

Breaking Changes

  • Removed bezier.get_dll() helper (#184).

Documentation

  • Changed "Read the Docs" landing page to point to .../stable/ documentation (i.e. the last published release) instead of .../latest documentation (i.e. the last merged commit).
  • Making sure CMake installed trees (on Linux, macOS and Windows) are verified in doctest as part of CI (48e4166).
  • Making sure example_*.c ABI examples are compiled and run (on Linux and macOS) in doctest as part of CI (ffdcdf7, 9551495, 0766649).
  • Converting (untested, potentially stale) console codeblocks to doctest (that get run in CI) for Linux sections of binary extension documentation (#188). Fixed #74.

Scientific Software - Peer-reviewed - Python
Published by dhermes over 6 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 2020.1.14

PyPI link to release 2020.1.14 Documentation for release 2020.1.14

Breaking Changes

  • Rename Surface to Triangle (#172). Fixed #132.

Documentation

  • Make sure all ABI example_*.c blocks get run with doctest (#174). Fixed #173.

Packaging

Scientific Software - Peer-reviewed - Python
Published by dhermes over 6 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.11.0

PyPI link to release 0.11.0 Documentation for release 0.11.0

Python Changes

Packaging

  • Explicit support for Python 3.8 has been added (#161). On Windows this required using the os.add_dll_directory() function to load bezier.dll (in earlier Python versions, the DLL directory was added by modifying %PATH%).

New Features

Internals

  • Re-factored non-public modules so that algorithms implemented in pure Python only invoke other algorithms written in pure Python (#160). Previously these algorithms invoked the equivalent Fortran speedup if present for a given function. Fixed #159.

Miscellany

  • Moved *.f90 Fortran files out of Python source tree (#152).

ABI Changes

Breaking Changes

  • Added BEZ_ prefix for exported ABI names (#167). Fixed #166.

Additive Changes

  • Changed all [in] arguments in C headers to const pointers (#169). Fixed #168.

Bug Fixes

  • Explicitly handle length 0 curves (with an error) in the compute_length() Fortran subroutine that is used by the Curve.length property (a24368f). Fixed #148.
  • Fixed high-degree error in the Curve.evaluate() method, via the evaluate_curve_barycentric() Fortran subroutine (5768824). Fixed #156. The code uses (n C (k + 1)) = (n - k) / (k + 1) (n C k) to update the value and (30 - 14) (30 C 14) overflows a 32-bit signed integer.

Documentation

  • Updated install instructions to show how to disable the binary extension via BEZIER_NO_EXTENSION (6262594, 00c1e61). Fixed #147.
  • Added "Citation" section to landing page (9885063). Fixed #150.

Scientific Software - Peer-reviewed - Python
Published by dhermes over 6 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.10.0

PyPI link to release 0.10.0 Documentation for release 0.10.0

Python Changes

Breaking Changes

  • Support for Python 2.7 has been dropped. With the impending EOL of Python 2.7 on January 1, 2020 many of the bezier dependencies such as numpy, scipy and pytest have dropped support for Python 2.7 in their latest releases. Some changes related to this include:
    • Removing support for Python 2.7 (3eaa5aa).
    • Updating all PyPy usage to be Python 3 only (1e3037f).
    • Removing _bool_patch.h (4ccc559).

Build

  • Integrating black code formatter into the nox --session lint session to ensure consistent formatting (e659532).
  • Fully automating the building of wheels in the bezier-wheels project (recent commits). Built wheels are uploaded to a Google Cloud Storage bucket.
  • Using the same set of optimal flags for Fortran 77 code (i.e. .f files) that are used for Fortran 90 code (i.e. .f90 files) (e7eb56e).
  • Unify requirements.txt files and add notes about why each dependency is required (230814d, 1ae147f, e710ee6).
  • Changing imp usage to importlib due to deprecation of the former (9231d92). Fixed #137.
  • Ditching the --check-archs flag in the macOS script for building wheels since we can no longer support 32-bit on macOS due to NumPy (37be384).
  • Improved dev experience with Docker image used on CircleCI by adding a .dockerignore file for faster builds, suggesting --workdir and flag during local dev, setting WHEELHOUSE environment variable directly in the container (rather than in the CircleCI settings) and allowing "default" locations for pre-built wheels at /wheelhouse and ${HOME}/wheelhouse (08be336, 26acc38, 7634779, f9a8fcf).

Miscellany

  • Make some functional test cases more lenient so that they pass on 32-bit CentOS 5, which is used for manylinux (e7eb56e). This was part of a large effort to fully automate the building of wheels in the bezier-wheels project.
  • Replacing pypy with pypy3 in testing as the only non-CPython "unofficially supported" runtime. (This is part of the drop in support for Python 2.7.) Unfortunately the currently (as of August 2019) released versions of pypy3 are not currently working with numpy >= 1.16 (see numpy/numpy#12740) so the numpy == 1.15.4 version is a pinned dependency.
    • Specifying the NumPy version in setup.py based on implementation_name (7e9046d).
    • Add _pypy_speedup.c built with Cython 0.29.11 because the latest Cython (0.29.13 as of August 2019) corresponds to the versions of NumPy that are incompatible with PyPy (7813e41).
    • Pinning to numpy==1.15.4 and scipy==1.2.0 in wheelhouse for pre-built Docker container (7634779).
  • Added nox --session validate_functional_test_cases session to ensure that functional test cases always adhere to the JSON schema.
    • Added nox session and fixed some schema file bugs (618653a).
    • Fixed curve intersections that did not adhere to schema (35b158a).
    • Transposed nodes schema for curved polygon (8c3ca89).
    • Enable the nox session to run in CircleCI (5a0a343).
  • Updated @slow marker for pytest because it used a deprecated API (46f8b57).

Documentation

  • Changing all references to Mac OS X to macOS (b10c2fc, c1c2c6b, 131d17b). As of 10.12, the operating system has changed its name.
  • Splitting up algorithms/helpers. The pre-amble has been moved into the algorithms landing page and the geometric and algebraic helpers have been moved into separate docs. (889c913).

Scientific Software - Peer-reviewed - Python
Published by dhermes almost 7 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.9.0

PyPI link to release 0.9.0 Documentation for release 0.9.0

Documentation

  • Documenting the C ABI libbezier (4608364). Fixed #63. This documentation contains a page for each "module" which corresponds to the underlying Fortran module. Each module documents the routines in the corresponding header file, e.g. the surface document corresponds to the bezier/surface.h header. Fully working C examples have been added for each routine in bezier/curve.h and for the enum in bezier/status.h.
  • Adding section about environment variables to development document (5186e24). Fixed #78.
  • Remove dependency on rawgit.com (04d0f8d). The website is being turned down. Fixed #130.
  • Renaming the "Native Libraries" document as "Binary Extension" (f99db20). In the process, changed most references to the "native" Python extension to instead call it a "binary" extension.
  • Added a "Cython .pxd Declarations" document (f99db20). Fixed #122.
  • Moving all Python specific documentation under a specific URL path (3db483b). In particular, moving
    • /reference/... to /python/reference/...
    • /python-binary-extension.html to /python/binary-extension.html
    • /pxd/... to /python/pxd/....
  • Moving all algorithm specific documentation under a specific URL path (6e9c825). In particular, moving
    • /algorithm-helpers.html to /algorithms/helpers.html
    • /curve-curve-intersection.html to /algorithms/curve-curve-intersection.html

ABI Changes

New Features

  • Added surface.h::compute_area helper that can be used to compute the area of both a surface and a curved polygon (d4d7249).

Breaking Changes

  • Removing getters and setters for parameters used during curve-curve intersection (2fda3ae):
    • curve_intersection.h::set_max_candidates
    • curve_intersection.h::get_max_candidates
  • Removing dimension from curve.h::get_curvature (1e39c0c).

Python Changes

New Features

Non-Public API

  • Removing getters and setters for parameters used during curve-curve intersection (2fda3ae):
    • bezier._geometric_intersection.set_max_candidates()
    • bezier._geometric_intersection.get_max_candidates()
  • Removing cached values for Curve.length property, Surface.area property and Surface.is_valid property (34d48d6).

Build

  • Renaming libbezier.dll shared library to bezier.dll on Windows (d17a9bc). This follows the correct convention on Windows.
  • Adding Python 3.7 support and making it the default version used for testing (e368e9f).
  • Dropping support for Python 3.5 (f99db20).
  • Adding back -march=native for non-wheel builds (1566019). This way, when installing from source (either via a local checkout or from the source distribution on PyPI) the most optimal machine instructions will be produced. Fixed #99.
  • Removing all traces of 32-bit support for OS X (d7620ad). This was driven by a decision from the NumPy maintainers.

Miscellany

  • Adopted black code formatter (f21b52d).
  • Adding project URLs and keywords for PyPI (cfb070d).
  • Added 20 new surface-surface functional tests (9fd9c1e). See #121 for more information.
  • Removed time and memory benchmarks due to flakiness and lack of an environment that could be used for benchmarking (6a30dc2). See #125 to follow discussion on re-enabling such benchmarks.
  • Using DEBUG=True environment variable when running unit tests and other related tests (d84dffb).

Scientific Software - Peer-reviewed - Python
Published by dhermes over 7 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.8.0

PyPI link to release 0.8.0 Documentation for release 0.8.0

New Features

  • Adding support for surface-surface intersections that have coincident segments shared between each surface (cfa2b93, 0a9645c). See cases:

  • Adding support for curve-curve intersections that are also points of tangency. This was accomplished by five broad changes to the geometric intersection algorithm:

    • Checking if almost-linear curves have disjoint bounding boxes before intersecting the linearized segments (05f0343).
    • Adding a "full" Newton iteration for finding B1(s) = B2(t) when known to be near a solution. In particular, this has special handling for tangencies, which cause a singular Jacobian and make convergence drop from quadratic to linear and stalls out convergence early (13a5be5, 4bac61a).

    • Changing how "bad" linearized segments are handled. After subdividing to approximately linear curve segments, there were two problems which are now being handled in the same way. If the line segments connecting the subdivided curve endpoints

      • are parallel, then the algorithm failed with a PARALLEL status
      • intersect outside of the unit interval (for either s or t), the curve-curve candidate was rejected (a small amount, 0.5^{16}, of "wiggle" room was allowed outside of [0, 1]).

      Now both cases are handled in the same way. First, the subdivided curve segments will have a convex hull check applied (which is more strict than a bounding box check). If their convex hulls do collide, they are treated as a normal intersection of curved segments (4457f64, fe453c3).

    • Using the newly added "full" Newton's iteration for all intersections. Before, a single Newton step was applied after intersection the linearized segments (d06430f).

    • Changing how a candidate pair of s-t parameters is added. (c998445). In the previous implementation, a pair was considered a duplicate only if there was a difference of at most 1 ULP from an existing intersection (though this could be toggled via set_similar_ulps()). Now, the pair is "normalized" so that s and t are away from 0. For example, if s < 2^{-10} then we use 1 - s instead. (This is perfectly "appropriate" since evaluating a Bézier curve requires using both s and 1 - s, so both values are equally relevant.) Once normalized, a relative error threshold is used.

  • Four curve-curve functional test cases have gone from failing to passing:

    and two surface-surface cases have as well: - 10: 20Q-21Q - 42: 41Q-21Q

    In order to support the aforementioned surface-surface cases, special support for "tangent corners" was added (12b0de4).

ABI Changes

Breaking Changes

  • Removed BAD_TANGENT status enum (b89b2b1). The case where that failure was issued has now been handled as an acceptable TANGENT_BOTH classification for surface-surface intersection points. (See the classify_intersection() function for an example.)
  • Adding BAD_INTERIOR status enum (6348dc6). (This is a breaking change rather than additive because it re-uses the enum value of 5 previously used by BAD_TANGENT.) This value is used by interior_combine() in the case that the curved polygon intersection(s) cannot be determined from the edge-edge intersections for a given surface-surface pair. See #101.
  • Removed PARALLEL status enum (fe453c3). Now when doing geometric curve-curve intersection, parallel linearized segments are handled by checking if the convex hulls collide and then (if they do) using a modified Newton iteration to converge to a root.
  • Adding BAD_MULTIPLICITY status enum (fe453c3). (This is a breaking change rather than additive because it re-uses the enum value of 1 previously used by PARALLEL.) This is used when Newton's method fails to converge to either a simple intersection or a tangent intersection. Such failures to converge, when already starting near an intersection, may be caused by one of:
    • The intersection was of multiplicity greater than 2
    • The curves don't actually intersect, though they come very close
    • Numerical issues caused the iteration to leave the region of convergence
  • Removed ulps_away() (c998445).
  • Removed set_similar_ulps() and get_similar_ulps() (c998445).

Surface Changes

  • Added SINGULAR status enum for cases when a linear system can't be solved due to a singular matrix (4457f64).
  • Adding status as a return value in newton_refine_curve_intersect(). This way, when the Jacobian is singular (which happens at points of tangency), the SINGULAR status can be returned (4457f64). The old behavior would've resulted in a division by zero.

Non-Public API

  • Adding custom linear solver for the 2 x 2 case (a3fb476). This is modelled after dgesv from LAPACK.

Python Changes

  • (Bug fix) The 0.7.0 release broke Surface.plot() and CurvedPolygon.plot() (when the nodes were transposed, the plotting helpers were not correctly updated). The add_patch() helper was fixed to account for the changes in data layout (80bfaaa).
  • Added custom UnsupportedDegree exception to be used by routines that have implementations that are hard-coded for specific degrees (87a1f21). See #103.
  • Removed ulps_away() (c998445).
  • Removed set_similar_ulps() and get_similar_ulps() (c998445).

Non-Public API

  • Returning coincident flag from curve-curve all_intersections (ebe6617).
  • Adding a TANGENT_BOTH classification for surface-surface intersection points that are interior to both surfaces at the point of tangency (b89b2b1). This previously failed with a NotImplementedError.
  • Added COINCIDENT classification for surface-surface intersection points that occur on a segment that is coincident on an edges of each surface (8b1c59d). Such points previously failed classification because they were interpreted as being tangent and having the same curvature (because the segments are identical).
  • Added a COINCIDENT_UNUSED classification (cfa2b93) for cases where coincident segments are moving in opposite directions (i.e. the surfaces don't share a common interior). For example see case 44 (29Q-43Q).
  • Adding custom linear solver for the 2 x 2 case (764e56d). This is modelled after dgesv from LAPACK.
  • Adding some support for Bézier clipping algorithm (fbed62d, ada4ea3). See the original paper by Sederberg and Nishita for more information.

Scientific Software - Peer-reviewed - Python
Published by dhermes about 8 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.7.0

PyPI link to release 0.7.0 Documentation for release 0.7.0

Robustness

  • Geometric curve-curve intersection has better handling for cases when the number of intersection candidates grows large (MAX_CANDIDATES == 64):
    • First tries to reduce the number of candidates by checking if the actual convex hulls of each segment in a candidate pair intersect. This is a much "finer" check than using the "blunt" bounding box check.
    • If the convex hull refinement fails, checks if the curves are coincident, i.e. different segments / parameterizations along the same algebraic curve. This is done by using the Curve.locate() function to try to project each of the four endpoints onto the other curve and then re-parameterizing each curve onto a common interval.

Data Structures

  • Storing xy-points as columns (rather than rows). This was a very large and breaking change, started in b44af8c. See #51 for more information.

Python Changes

Non-Public API

  • Requiring contiguous 1D arrays for Cython functions (9ede37d).

Scientific Software - Peer-reviewed - Python
Published by dhermes over 8 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.6.4

PyPI link to release 0.6.4 Documentation for release 0.6.4

Python Changes

Surface Changes

  • Stopped raising ValueError('At least one value outside of unit interval', s_val, t_val) or ValueError('outside of unit interval') when a curve-curve intersection falls barely outside of the parameter space [0, 1] (329a59a).

ABI Changes

Surface Changes

  • Removed Status_WIGGLE_FAIL enum and re-numbered all larger Status enum values (by subtracting one)
  • Changing "wiggle failure" in curve-curve intersection from a non-success status to be a dropped candidate for intersection

Scientific Software - Peer-reviewed - Python
Published by dhermes over 8 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.6.3

PyPI link to release 0.6.3 Documentation for release 0.6.3

Python Changes

Surface Changes

  • Changed RuntimeError('Unexpected number of edges', 11) to RuntimeError('Unknown error has occured.') in the speedup that does surface-surface intersection (35ab5d5). The old error message was a "copy-paste" artifact from the basic_interior_combine() Python helper.

Build

  • Removed a flag (-march=native) from the build process for the bezier._speedup extension module (e739429). Using the flag caused the manylinux wheels to be "broken" (see #98).

Scientific Software - Peer-reviewed - Python
Published by dhermes over 8 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.6.2

PyPI link to release 0.6.2 Documentation for release 0.6.2

Python Changes

Documentation

Non-Public API

  • Collapsed all Cython-generated modules into a single bezier._speedup module (8bcb319).
    • This is the change that prompted the release.
    • Dropped the five bezier._HAS_*_SPEEDUP members for a single bezier._HAS_SPEEDUP (this was the previous approach before 0.6.0).
    • Renamed a few of the Cython helper functions to avoid name collision.
    • This was done to fix a bug and prevent future bugs. The issue was that a mutable Fortran global (MAX_CANDIDATES) was being included via an object file in separate extension modules. When one module updated the global, the other module never saw the update (because it was a different copy).

Scientific Software - Peer-reviewed - Python
Published by dhermes over 8 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.6.1

PyPI: https://pypi.org/project/bezier/0.6.1/ Docs: https://bezier.readthedocs.io/en/0.6.1/

Python Changes

Documentation

  • Noting that Surface.intersect() can return a list of either CurvedPolygon or Surface instances (16e77d7).

Breaking Changes

  • Removing IntersectionClassification enum from _status.pxd (4da969e).

Non-Public API

  • Adding getters and setters for parameters used during curve-curve intersection (ef4ebc0):
    • bezier._geometric_intersection.set_max_candidates()
    • bezier._geometric_intersection.get_max_candidates()
    • bezier._geometric_intersection.set_similar_ulps()
    • bezier._geometric_intersection.get_similar_ulps()

ABI Changes

Surface Changes

  • Switching from int to an actual enum for relevant functions with output values that are enums:
    • In surface_intersection.h::surface_intersections, contained is now a SurfaceContained (0a9c0c3) and status is now a Status (c356c32)
    • In curve_intersection.h::bbox_intersect, enum_ is now a BoxIntersectionType (ef856af)
    • In curve_intersection.h::curve_intersections, status is now a Status (ef856af)
  • Adding getters and setters for parameters used during curve-curve intersection (ef4ebc0):
    • curve_intersection.h::set_max_candidates
    • curve_intersection.h::get_max_candidates
    • curve_intersection.h::set_similar_ulps
    • curve_intersection.h::get_similar_ulps

Breaking Changes

  • Removing inputs curve_start / curve_end and outputs true_start / true_end in curve.h::specialize_curve (959c547)

Scientific Software - Peer-reviewed - Python
Published by dhermes over 8 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.6.0

PyPI: https://pypi.org/project/bezier/0.6.0/ Docs: https://bezier.readthedocs.io/en/0.6.0/

Performance Optimizations

  • Added recommended performance flags for gfortran based on recommendations on fortran90.org (3877982).
    • Extensions can be compiled in debug mode by setting DEBUG=True (b62460b).
    • Setting BEZIER_NO_EXTENSIONS=True will build pure-Python modules only (3f6280c)
  • Added QUADPACK to use in curve.f90::compute_length (985a4c0).
  • Implemented curve-curve intersection completely in Fortran (e.g. 4a8f801) which resulted in a 10x speedup when called from Python. Also implemented surface-surface intersection completely in Fortran, resulting in a 3x speedup.

Python Changes

New Features

  • Added CurvedPolygon._metadata to track where edges originated, e.g. from a surface-surface intersection (871d23d). This is used for sanity checking in functional tests (e253da2).
  • Made speedup checks specific to the module, not all four. I.e. bezier._HAS_SPEEDUP was dropped in favor of five members, e.g. _HAS_CURVE_SPEEDUP (d798f66).
  • Added bezier.__author__ and bezier.__version__ attributes.
  • Added bezier.get_dll() for Windows (699e39b).
  • Added bezier/__config__.py that adds libbezier to %PATH% on Windows (8538af4).
  • Fortran / Cython speedups added:
    • _curve_speedup.pyx::subdivide_nodes
    • _curve_speedup.pyx::newton_refine
    • _curve_speedup.pyx::locate_point
    • _curve_speedup.pyx::elevate_nodes
    • _curve_speedup.pyx::get_curvature
    • _curve_speedup.pyx::reduce_pseudo_inverse
    • _curve_speedup.pyx::full_reduce
    • _curve_speedup.pyx::compute_length
    • _curve_intersection_speedup.pyx::all_intersections
    • _curve_intersection_speedup.pyx::free_curve_intersections_workspace
    • _helpers_speedup.pyx::contains_nd
    • _helpers_speedup.pyx::vector_close
    • _helpers_speedup.pyx::in_interval
    • _helpers_speedup.pyx::ulps_away
    • _surface_speedup.pyx::specialize_surface
    • _surface_speedup.pyx::subdivide_nodes
    • _surface_speedup.pyx::compute_edge_nodes
    • _surface_intersection_speedup.pyx::newton_refine
    • _surface_intersection_speedup.pyx::locate_point
    • _surface_intersection_speedup.pyx::surface_intersections
    • _surface_intersection_speedup.pyx::free_surface_intersections_workspace

Breaking Changes

ABI Changes

New Features

  • Fully implemented curve-curve intersection (as curve_intersection.h::curve_intersections) and surface-surface intersection (as surface_intersection.h::surface_intersections) at the ABI level.
  • Added the surface_intersection.h header file and implementations for the described functions (fafd9ff).
  • Newly added functions
  • Added status.h with an enum for failure states. Each Fortran procedure that returns a status documents the possible values and if each value is set directly or by a called procedure (9fc8575, c2accf7).

Breaking Changes

  • Removed functions
    • curve.h::specialize_curve_generic (d52453b)
    • curve.h::specialize_curve_quadratic (d52453b)
    • curve_intersection.h::from_linearized (d62e462)
    • curve_intersection.h::bbox_line_intersect (72c0179)
    • curve_intersection.h::linearization_error (4a3378b)
    • curve_intersection.h::segment_intersection (4060590)
    • curve_intersection.h::parallel_different (df3e195)
  • Renamed functions
    • curve.h::newton_refine to newton_refine_curve (194ce95)
    • curve.h::elevate_nodes to elevate_nodes_curve (194ce95)
    • curve_intersection.h::newton_refine_intersect to newton_refine_curve_intersect (a055525)
  • Replaced degree with num_nodes (== degree + 1) in functions that operate on curves:
    • curve.h::evaluate_curve_barycentric (13eacdd)
    • curve.h::evaluate_multi (962c288)
    • curve.h::specialize_curve (ac86233)
    • curve.h::evaluate_hodograph (9170855)
    • curve_intersection.h::newton_refine_curve_intersect (80ec491)

Miscellany

  • Added documentation for "native extensions" in DEVELOPMENT (2f9f2c4).
  • Overhauled native-libraries doc with subsections for OS X and Windows (bfa75ee, 72005fb, etc.).
  • Added Fortran unit tests (758bdd1, e8afba7, 3164365, etc.).
  • Began testing in Mac OS X on Travis (9ac5e8e, 85f7619, etc.).
  • Added a workaround (include/bezier/_bool_patch.h) for the missing support for bool in old MSVC versions that are required to work with Python 2.7 (5577178).

Scientific Software - Peer-reviewed - Python
Published by dhermes over 8 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.5.0

PyPI: https://pypi.org/project/bezier/0.5.0/ Docs: https://bezier.readthedocs.io/en/0.5.0/

Performance Optimizations

  • Change wiggle_interval to return success bool instead of raising an exception. This allows the implicitization approach to use it without having to use exceptions for flow-control. (Fixes #22.)
  • Switching Fortran speedups from f2py to Cython (this is because f2py artificially limits the feature set of Fortran, i.e. user defined types)
  • Moving some more code to Fortran (e.g. bbox_line_intersect() 3dcf640)

New Features

Miscellany

  • Getting bezier published in the Journal of Open Source Science (JOSS). See review. (e6c4536 and 975ac6b)
  • Updating error message for locate() methods and adding a note that locate() / evaluate*() are (essentially) inverses. H/T to @pdknsk #36
  • Using Fortran-contiguous arrays in _check_non_simple(). (b06c78e)
  • Moving most of Curve.subdivide() and Surface.subdivide() logic into helpers. This is part of an effort to make all helpers take low-level data types rather than Curves, Surfaces, etc. (34515bd and 1fc80e5)
  • Split speedup.f90 into submodules curve.f90, surface.f90, etc. (75349b7, dfd6bba, 7096a9d, c326c00)
  • Adding BEZIER_JOURNAL option to setup.py. This stores a record of compiler commands invoked during installation. See Native Libraries for more details. (3d832e7 and c64a97a)

Scientific Software - Peer-reviewed - Python
Published by dhermes over 8 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.4.0

PyPI: https://pypi.org/project/bezier/0.4.0/ Docs: https://bezier.readthedocs.io/en/0.4.0/

Performance Optimizations

  • Adding Fortran speedups for many crucial computation helpers including
    • intersecting line segments
    • (vectorized) Horner's method for evaluating a Bézier curve at multiple parameters at once
    • (vectorized) Horner's method for evaluating a Bézier surface
    • computing "linearization error" (how close a curve is to a line)
    • specializing a Bézier curve to a sub-interval
    • using Newton's method to refine a curve-curve intersection
  • Adding _verify switch to Surface.locate() and Curve.intersect() to selectively disable overly defensive value checking. (Making sure to use this switch during "internal" computation.)
  • Making sure NumPy arrays are Fortran-contiguous as often as possible (e.g. snippets and source, via np.asfortranarray()). This is to avoid (and emphasize) a non-trivial overhead when passing a C-contiguous array to a Fortran function. (03a7242, 6064e4c, f1804f4)
  • Using Horner's method in Curve.evaluate_multi() and Surface.evaluate_barycentric(), rather than inferior (sometimes non-vectorized) approaches (dee8181, 2611e64)
  • Made surface-surface intersection more resilient / lenient for corner intersections. For "nearby" intersections, parameter values can be rounded to 0 or 1. (4a8458c)

New Features

Interface Changes

Miscellany

  • Adding IntersectionClassification to docs (ref)
  • Moving most plotting into a dedicated module. More importantly, importing plotting helpers at run-time rather at import time. So if computational code never plots, it won't eat the import cost of matplotlib. Removing matplotlib as a dependency.

Scientific Software - Peer-reviewed - Python
Published by dhermes almost 9 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.3.0

PyPI: https://pypi.org/project/bezier/0.3.0/ Docs: http://bezier.readthedocs.io/en/0.3.0/

Performance Optimizations

Breaking Changes

Bug Fixes

  • Handling cases where one corner of a surface touches another but their interiors don't intersect (in Surface.intersect()). Adding ignored_corner classification to handle these curve-curve intersecions that don't contribute to a surface-surface intersection
  • Throwing exception in Curve.locate() when the subdivided intervals are very far apart (#13)
  • Improving Surface.is_valid by considering the signs of the Jacobian determinant at corner nodes (#12)

Miscellany

  • Adding possible strategy to avoid linear convergence in newton_refine()
  • Adding AppVeyor configuration to make sure there are no Windows issues, testing exclusively with conda install
  • Updating generated images with matplotlib 2.0

Scientific Software - Peer-reviewed - Python
Published by dhermes over 9 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.2.1

PyPI: https://pypi.org/project/bezier/0.2.1/ Docs: http://bezier.readthedocs.io/en/0.2.1/

  • Added Curve.locate() and _curve_helpers.newton_refine() helper
  • Adding optional color to Surface.plot()
  • Adding Surface.elevate() for degree elevation
  • Fixing nodes defining the self-intersecting curve in curve-curve-intersection (no code in bezier was broken / fixed, just "bad" docs)
  • Allow wiggle outside of [0, 1] when intersecting linearizations in from_linearized()
  • Collapsing almost-same parameter values in intersect_one_round() (via from_linearized()). Previously checked for bitwise equality and relied on checking values at the boundary of a subdivided interval
  • Adding non-public bezier._plot_helpers module

Scientific Software - Peer-reviewed - Python
Published by dhermes over 9 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.2.0

PyPI: https://pypi.org/project/bezier/0.2.0/ Docs: http://bezier.readthedocs.io/en/0.2.0/

  • Primary feature: Surface.intersect() added
  • To support intersection, needed CurvedPolygon, i.e. an object defined only by its curved sides (whereas a Surface may have interior control points)
  • Curve.specialize for chopping a Curve at arbitrary parameter values (this is also used in surface-surface intersection)
  • Added images to most documented functions and methods to illustrate the concept at hand. For example classify_intersection has seven images to enumerate all of the possible cases covered in the algorithm.
  • Added Surface.locate(), made possible by newton_refine
  • Added Algorithm Helpers doc to try to explain some of the core algorithms at work (not all are documented yet). Some of this content was previously documented in the bezier.curve module, but was moved. Since, documentation has been added for get_curvature, newton_refine (for surfaces), classify_intersection (to determine how two curves interact while intersecting) and for some helper classes.
  • Added Surface.base_x, Surface.base_y and Surface.width properties to allow tracking a sub-surface during the subdivision process (this is an analogue to the Curve.start and Curve.end properties)
  • Added Curve.edge_index, Curve.next_edge and Curve.previous_edge properties to allow tracking when curves are actually the sides of a Surface

Scientific Software - Peer-reviewed - Python
Published by dhermes over 9 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.1.1

PyPI: https://pypi.org/project/bezier/0.1.1/ Docs: http://bezier.readthedocs.io/en/0.1.1/

Changes: - Adding Curve.elevate() for degree elevation - Upgrading curve-curve intersection algorithm to ignore parallel line segments that don't meet (rather than throwing NotImplementedError) - Making segment_intersection() return a success bool instead of raising NotImplementedError on failure - Updating docs for newton_refine() with two examples and making parallel_different() a publicly documented function (as a partner to segment_intersection()) - Adding some more examples / failures to curve-curve-intersection doc

Scientific Software - Peer-reviewed - Python
Published by dhermes over 9 years ago

Helper for Bézier Curves, Triangles, and Higher Order Objects - 0.1.0

Second Release: https://pypi.org/project/bezier/0.1.0/ Docs: http://bezier.readthedocs.io/en/0.1.0/

Primary changes since previous release (0.0.1) are related to curve-curve intersection. See the intersection docs for examples and more information.

Scientific Software - Peer-reviewed - Python
Published by dhermes over 9 years ago