struct bspline is the object in vspline holding b-spline coefficients. In a way, the b-spline 'is' it's coefficients, since it is totally determined by them - while, of course, the 'actual' spline is an n-dimensional curve. So, even if this is a bit sloppy, I often refer to the coefficients as 'the spline', and have named struct bspline so even if it just holds the coefficients.
More...
|
| static xlf_type | lower_limit (const bc_code &bc) |
| | lower_limit returns the lower bound of the spline's defined range. This is usually 0.0, but with REFLECT boundary condition it's -0.5, the lower point of reflection. The lowest coordinate at which the spline can be accessed may be lower: even splines have wider support, and splines with extra headroom add even more room to manoevre. More...
|
| |
| static xlf_type | upper_limit (const std::size_t &extent, const bc_code &bc) |
| | upper_limit returns the upper bound of the spline's defined range. This is normally M - 1 if the shape for this axis is M. Splines with REFLECT boundary condition use M - 0.5, the upper point of reflection, and periodic splines use M. The highest coordinate at which the spline may be accessed safely may be higher. More...
|
| |
| static shape_type | get_left_brace_size (int spline_degree, bcv_type bcv) |
| | get_left_brace_size and get_right_brace_size calculate the size of the brace vspline puts around the 'core' coefficients to allow evaluation inside the defined range (and even slightly beyond) without bounds checking. These routines are static to allow user code to establish vspline's bracing requirements without creating a bspline object. user code might use this information to generate coefficient arrays suitable for use with vspline evaluation code, sidestepping use of a bspline object. More...
|
| |
| static shape_type | get_right_brace_size (int spline_degree, bcv_type bcv) |
| |
| static shape_type | get_container_shape (int spline_degree, bcv_type bcv, shape_type core_shape, int headroom) |
| | convenience method to caculate the shape of a container array needed to hold the coefficients of a spline with the given properties. The arguments are the same as those passed to the bspline object's constructor, but this method is static, so it can be called on the spline's type and does not need an object. I'm including this to make it easier for code which creates the container array externally before constructing the bspline object, rather than relying on class bspline to allocate it's own storage. More...
|
| |
| template<typename = std::enable_if < _dimension == 1 >> |
| static long | get_container_shape (int spline_degree, vspline::bc_code bc, long core_shape, int headroom) |
| | variant for 1D splines. This variant accepts the shape as a plain long, rather than requiring a TinyVector of one long. More...
|
| |
template<unsigned int _dimension>
struct vspline::bspline_base< _dimension >
struct bspline is the object in vspline holding b-spline coefficients. In a way, the b-spline 'is' it's coefficients, since it is totally determined by them - while, of course, the 'actual' spline is an n-dimensional curve. So, even if this is a bit sloppy, I often refer to the coefficients as 'the spline', and have named struct bspline so even if it just holds the coefficients.
The coefficients held in a bspline object are 'braced', providing a few extra extrapolated coefficients around a 'core' area corresponding with the knot point, or original data. This way, they can be used by vspline's evaluation code which relies on such a brace being present.
struct bspline is a convenience class which bundles a coefficient array (and it's creation) with a set of metadata describing the parameters used to create the coefficients and the resulting data. I have chosen to implement class bspline so that there is only a minimal set of template arguments, namely the spline's data type (like pixels etc.) and it's dimension. All other parameters relevant to the spline's creation are passed in at construction time. This way, if explicit specialization becomes necessary (like, to interface to code which can't use templates) the number of specializations remains manageable. This design decision pertains specifically to the spline's degree, which could also be implemented as a template argument, allowing for some optimization by making some members static. Yet going down this path requires explicit specialization for every spline degree used and the performance gain I found doing so was hardly measurable, while automatic testing became difficult and compilation times grew.
class bspline may or may not 'own' the coefficient data it refers to - this depends on the specific initialization used, but is handled privately by class b-spline, using a shared_ptr to the data if they are owned, which makes bspline objects trivially copyable.
The 'metadata part' of the bspline object is coded as a base class, which is convenient to derive other 'spline-like' classes with the same metadata structure. class bspline itself adds the coeffcients of the spline and the storage holding the coefficients.
Definition at line 191 of file bspline.h.
