Class ClothoidCurve

Inheritance Relationships

Base Type

Class Documentation

class ClothoidCurve : public CurveBase

Public Functions

function ClothoidCurve( varargin)

Create a new C++ class instance for the clothoid arc object

Usage:

ref = ClothoidCurve()
ref = ClothoidCurve( x0, y0, theta0, k0, dk, L )

On input:

  • x0, y0: coordinate of initial point

  • theta0: orientation of the clothoid at initial point

  • k0: curvature of the clothoid at initial point

  • dk: derivative of curvature respect to arclength

  • L: length of curve from initial to final point

On output:

  • ref: reference handle to the object instance

function is_type( ignoredArg)
function build( self, varargin)

Build the clothoid from known parameters

Usage:

ref.build( x0, y0, theta0, k0, dk, L )

On input:

  • x0, y0: coordinate of initial point

  • theta0: orientation of the clothoid at initial point

  • k0: curvature of the clothoid at initial point

  • dk: derivative of curvature respect to arclength

  • L: length of curve from initial to final point

function build_G1( self, x0, y0, theta0, x1, y1, theta1)

Build the interpolating G1 clothoid arc

Usage:

ref.build_G1( x0, y0, theta0, x1, y1, theta1 )

On input:

  • x0, y0: coordinate of initial point

  • theta0: orientation of the clothoid at initial point

  • x1, y1: coordinate of final point

  • theta1: orientation of the clothoid at final point

function build_forward( self, x0, y0, theta0, k0, x1, y1)

Build the interpolating clothoid arc fixing initial position angle and curvature

Usage:

ok = ref.build_forward( x0, y0, theta0, k0, x1, y1 );

On input:

  • x0, y0: coordinate of initial point

  • theta0: orientation of the clothoid at initial point

  • k0: curvature of the clothoid at initial point

  • x1, y1: coordinate of final point

On output:

  • ok: true iff the interpolation was successful

function closestPoint( self, qx, qy)

Find the closest point to a clothoid curve using the algorithm described in

E. Bertolazzi, M. Frego, Point-Clothoid Distance and Projection Computation,
SIAM Journal on Scientific Computing, 2019, 41(5).
https://doi.org/10.1137/18M1200439

Usage:

[ X, Y, S, DST ] = ref.closestPoint( qx, qy );

On input:

  • qx, qx: coordinate of the point

On output:

  • X, Y : coordinate of the pojected point

  • S : curvilinear coordinate along the clothoid of the projection

  • DST : point clothoid distance

function closestPointBySample( self, qx, qy, ds)

Find the closest point to a clothoid by sampling points

[ X, Y, S, DST ] = ref.closestPointBySample( qx, qy, ds );

On input:

  • qx, qx: coordinate of the point

  • ds: sampling distance coordinate of the point

On output:

  • X, Y : coordinate of the pojected point

  • S : curvilinear coordinate along the clothoid of the projection

  • DST : point clothoid distance

function distanceBySample( self, qx, qy, ds)

Find the distance between a point and a clothoid by sampling

[ DST, S ] = ref.distanceBySample( qx, qy, ds );

On input:

  • qx, qx: coordinate of the point

  • ds: sampling distance coordinate of the point

On output:

  • S : curvilinear coordinate along the clothoid of the projection

  • DST : point clothoid distance

function dkappa( self)

Return curvature derivatve of the clothoid

Usage:

dk = ref.dkappa(s0,L);
function changeCurvilinearOrigin( self, s0, L)

change the origin of the clothoid curve to curviliear corrdinate s0

Usage:

ref.changeOrigin(s0,L);

On input:

  • s0: curvilinear coordinate of the origin of the new curve

  • L: nel length of the curve

function infinity( self)

point at infinity

Usage:

[xp,yp,xm,ym] = ref.infinity();

  • xp, yp: point at infinity (positive arc)

  • xm, ym: point at infinity (negative arc)

function getPars( self)

Get clothoid parameters

Usage:

[ x0, y0, theta0, k0, dk, L ] = ref.getPars();

  • x0, y0: initial point of the clothoid arc

  • theta0: initial angle of the clothoid arc

  • kappa0: initial curvature of the clothoid arc

  • dk: curvature derivative

  • L: length of the clothoid arc

function optimized_sample( self, npts, max_angle, offs)

Get an optimized sampling of curviliear coordinates on the clothoid arc

Usage:

S = ref.optimized_sample(npts,max_angle,offs);
S = ref.optimized_sample(npts,max_angle,offs,'ISO');
S = ref.optimized_sample(npts,max_angle,offs,'SAE');

Input:

  • npts: total number of sampling points

  • max_angle: initial angle of the clothoid arc

  • offs: offset of the curve

  • ISO: use ISO orientation of the normal for offset

  • SAE: use SAE orientation of the normal for offset

Output:

  • S: the vector with the sampled curvilinear coordinates

function plot( self, npts, varargin)

Plot the clothoid arc

Usage:

ref.plot();
ref.plot( npts );
ref.plot( npts, 'Color','blue','Linewidth',2);

  • npts: number of sampling points for plotting

function plot_offs( self, offs, npts, varargin)

Plot the clothoid arc with offset

Usage:

ref.plot_offs( offs );
ref.plot_offs( offs, npts );
ref.pplot_offslot( offs, npts, 'Color','blue','Linewidth',2);

  • npts: number of sampling points for plotting

  • offs: offset of the curve

function plotCurvature( self, npts, varargin)

Plot the curvature of the clothoid curve

Usage:

ref.plotCurvature( npts );
ref.plotCurvature( npts, 'Color','blue','Linewidth',2);

  • npts: number of sampling points for plotting

function plotAngle( self, npts, varargin)

Plot the angle of the clothoid curve

Usage:

ref.plotAngle( npts );
ref.plotAngle( npts, 'Color','blue','Linewidth',2);

  • npts: number of sampling points for plotting

function plotNormal( self, step, len)

Plot the normal of the clothoid curve

Usage:

ref.plotNormal( step, len );

  • step: number of sampling normals

  • len: length of the plotted normal

function obj_handle( self)

Return the pointer of the interbal stored c++ object

Usage

obj = ref.obj_handle();
function copy( self, C)

Make of copy of a curve object

Usage

ref.copy( C );

where C id the curve object to be copied.

function bbox( self, varargin)

Return the bounding box of the curve object

Usage

[ xmin, ymin, xmax, ymax ] = ref.bbox( C );
[ xmin, ymin, xmax, ymax ] = ref.bbox( C, offs );
[ xmin, ymin, xmax, ymax ] = ref.bbox( C, offs, 'ISO' );
[ xmin, ymin, xmax, ymax ] = ref.bbox( C, offs, 'SAE' );

  • xmin: x minimum coordinate of the bounding box

  • ymin: y minimum coordinate of the bounding box

  • xmax: x maximum coordinate of the bounding box

  • ymax: y maximum coordinate of the bounding box

Optional Arguments

  • offs: offset of the curve used in the bbox computation

  • ’ISO’/’SAE’: use ISO or SAE orientation of the normal for offset computation

function translate( self, tx, ty)

Translate the curve by (tx,ty)

Usage

ref.translate( tx, ty );
function trim( self, smin, smax)

Cut the curve at the curvilinear parameter smin up to smax

Usage

ref.trim( smin, smax );

function rotate( self, angle, cx, cy)

Rotate the curve by angle angle around point (cx, cy)

Usage

ref.rotate( angle, cx, cy );
function reverse( self)

Reverse the direction of travel of the curve.

Usage

ref.reverse();
function scale( self, sc)

Scale the curve by factor sc

Usage

ref.scale( sc );
function changeOrigin( self, newX0, newY0)

Translate the curve in such a way the origin is at (newX0,newY0.

Usage

ref.changeOrigin( newX0, newY0 );
function evaluate( self, s, varargin)

Evaluate the curve at curvilinear coordinate s. Argument s may be a vector for multiple evaluations.

Usage

[ x, y, theta, kappa ] = ref.evaluate( s );
[ x, y, theta, kappa ] = ref.evaluate( s, offs );
[ x, y, theta, kappa ] = ref.evaluate( s, offs, 'ISO' );
[ x, y, theta, kappa ] = ref.evaluate( s, offs, 'SAE' );

Optional Arguments

  • offs: offset of the curve used in computation

  • ’ISO’/’SAE’: use ISO or SAE orientation of the normal for offset computation

function eval( self, varargin)

Evaluate the curve at curvilinear coordinate s. Argument s may be a vector for multiple evaluations.

Usage

XY = ref.eval( s );
XY = ref.eval( s, offs );
XY = ref.eval( s, offs, 'ISO' );
XY = ref.eval( s, offs, 'SAE' );

[X,Y] = ref.eval( s );
[X,Y] = ref.eval( s, offs );
[X,Y] = ref.eval( s, offs, 'ISO' );
[X,Y] = ref.eval( s, offs, 'SAE' );

Optional Arguments

  • offs: offset of the curve used compiutation

  • ’ISO’/’SAE’: use ISO or SAE orientation of the normal for offset computation

Output

  • XY: matrix 2 x n of the evaluated points

  • X: vector of the x-coordinates of the evaluated points

  • Y: vector of the y-coordinates of the evaluated points

function eval_D( self, varargin)

Evaluate the first derivatives of the curve at curvilinear coordinate s. Argument s may be a vector for multiple evaluations.

Usage

XY = ref.eval_D( s );
XY = ref.eval_D( s, offs );
XY = ref.eval_D( s, offs, 'ISO' );
XY = ref.eval_D( s, offs, 'SAE' );

[X,Y] = ref.eval_D( s );
[X,Y] = ref.eval_D( s, offs );
[X,Y] = ref.eval_D( s, offs, 'ISO' );
[X,Y] = ref.eval_D( s, offs, 'SAE' );

Optional Arguments

  • offs: offset of the curve used in computation

  • ’ISO’/’SAE’: use ISO or SAE orientation of the normal for offset computation

Output

  • XY: matrix 2 x n of the evaluated points

  • X: vector of the x-coordinates of the evaluated point derivatives

  • Y: vector of the y-coordinates of the evaluated point derivatives

function eval_DD( self, varargin)

Evaluate the second derivatives of the curve at curvilinear coordinate s. Argument s may be a vector for multiple evaluations.

Usage

XY = ref.eval_DD( s );
XY = ref.eval_DD( s, offs );
XY = ref.eval_DD( s, offs, 'ISO' );
XY = ref.eval_DD( s, offs, 'SAE' );

[X,Y] = ref.eval_DD( s );
[X,Y] = ref.eval_DD( s, offs );
[X,Y] = ref.eval_DD( s, offs, 'ISO' );
[X,Y] = ref.eval_DD( s, offs, 'SAE' );

Optional Arguments

  • offs: offset of the curve used in computation

  • ’ISO’/’SAE’: use ISO or SAE orientation of the normal for offset computation

Output

  • XY: matrix 2 x n of the evaluated points

  • X: vector of the x-coordinates of the evaluated point derivatives

  • Y: vector of the y-coordinates of the evaluated point derivatives

function eval_DDD( self, varargin)

Evaluate the third derivatives of the curve at curvilinear coordinate s. Argument s may be a vector for multiple evaluations.

Usage

XY = ref.eval_DDD( s );
XY = ref.eval_DDD( s, offs );
XY = ref.eval_DDD( s, offs, 'ISO' );
XY = ref.eval_DDD( s, offs, 'SAE' );

[X,Y] = ref.eval_DDD( s );
[X,Y] = ref.eval_DDD( s, offs );
[X,Y] = ref.eval_DDD( s, offs, 'ISO' );
[X,Y] = ref.eval_DDD( s, offs, 'SAE' );

Optional Arguments

  • offs: offset of the curve used in computation

  • ’ISO’/’SAE’: use ISO or SAE orientation of the normal for offset computation

Output

  • XY: matrix 2 x n of the evaluated points

  • X: vector of the x-coordinates of the evaluated point derivatives

  • Y: vector of the y-coordinates of the evaluated point derivatives

function theta( self, s)

Evaluate the angle of the curve at curvilinear coordinate s. Argument s may be a vector for multiple evaluations.

Usage

theta = ref.theta( s );
function theta_D( self, s)

Evaluate the angle derivatives (curvature) of the curve at curvilinear coordinate s. Argument s may be a vector for multiple evaluations.

Usage

theta = ref.theta_D( s );
function theta_DD( self, s)

Evaluate the angle second derivatuve of the curve at curvilinear coordinate s. Argument s may be a vector for multiple evaluations.

Usage

theta = ref.theta_DD( s );
function theta_DDD( self, s)

Evaluate the angle third derivative of the curve at curvilinear coordinate s. Argument s may be a vector for multiple evaluations.

Usage

theta = ref.theta_DDD( s );
function kappa( self, s)

Evaluate the curvature of the curve at curvilinear coordinate s. Argument s may be a vector for multiple evaluations.

Usage

theta = ref.kappa( s );
function kappa_D( self, s)

Evaluate the curvature derivative of the curve at curvilinear coordinate s. Argument s may be a vector for multiple evaluations.

Usage

theta = ref.kappa_D( s );
function kappa_DD( self, s)

Evaluate the curvature second derivative of the curve at curvilinear coordinate s. Argument s may be a vector for multiple evaluations.

Usage

theta = ref.kappa_DD( s );
function xyBegin( self)

Evaluate initial point of the curve.

Usage

[ x0, y0 ] = ref.xyBegin();
function xyEnd( self)

Evaluate final point of the curve.

Usage

[ x1, y1 ] = ref.xyEnd();
function xBegin( self)

Evaluate initial x-coordinate of the curve.

Usage

x0 = ref.xBegin();
function xEnd( self)

Evaluate final x-coordinate of the curve.

Usage

x1 = ref.xEnd();
function yBegin( self)

Evaluate initial y-coordinate of the curve.

Usage

y0 = ref.yBegin();
function yEnd( self)

Evaluate final y-coordinate of the curve.

Usage

y1 = ref.yEnd();
function thetaBegin( self)

Evaluate initial angle of the curve.

Usage

theta = ref.thetaBegin();
function thetaEnd( self)

Evaluate final angle of the curve.

Usage

theta = ref.thetaEnd();
function kappaBegin( self)

Evaluate initial curvature of the curve.

Usage

kappa0 = ref.kappaBegin();
function kappaEnd( self)

Evaluate final curvature of the curve.

Usage

kappa1 = ref.kappaEnd();
function length( self, varargin)

Return the length of the curve.

Usage

length = ref.length();
function points( self)
function bbTriangles( self, varargin)

Evaluate the bounding box triangles of curve.

Usage

[P1,P2,P3] = ref.bbTriangles();
[P1,P2,P3] = ref.bbTriangles(max_angle,max_size);
[P1,P2,P3] = ref.bbTriangles(max_angle,max_size,offs);
[P1,P2,P3] = ref.bbTriangles(max_angle,max_size,offs,'ISO');
[P1,P2,P3] = ref.bbTriangles(max_angle,max_size,offs,'SAE');

Optional Arguments

  • max_angle: maximum curve angle variation admitted in a triangle

  • max_size: maximum triangles size

  • offs: offset of the curve used in computation

  • ’ISO’/’SAE’: use ISO or SAE orientation of the normal for the offset

Output

  • P1: 2 x n matrix with the first points of the triangles

  • P2: 2 x n matrix with the second points of the triangles

  • P3: 2 x n matrix with the third points of the triangles

function closestPoint( self, qx, qy, varargin)

Evaluate the point at minimum distance of another point on the curve. qx and qy may be vectors so that the return values are vectors too.

Usage

[ x, y, s, t, iflag, dst ] = ref.closestPoint( qx, qy );
[ x, y, s, t, iflag, dst ] = ref.closestPoint( qx, qy, offs );
[ x, y, s, t, iflag, dst ] = ref.closestPoint( qx, qy, offs, 'ISO' );
[ x, y, s, t, iflag, dst ] = ref.closestPoint( qx, qy, offs, 'SAE' );

Optional Arguments

  • offs: offset of the curve used in computation

  • ’ISO’/’SAE’: use ISO or SAE orientation of the normal for the offset

Output

  • x, y: Point at minimum distance from (qx,qy) on the curve.

  • s, t: Curvilinear coordinates of the point (qx,qy).

  • iflag: iflag < 0 some error in computation, iflag >0 is the numer of segment containing the point at minimum distance.

  • dst: point curve distance.

function distance( self, qx, qy, varargin)

Evaluate the distance of a point (qx,qy) to the curve. qx and qy may be vectors so that the return values are vectors too.

Usage

dst = ref.distance( qx, qy );
dst = ref.distance( qx, qy, offs );
dst = ref.distance( qx, qy, offs, 'ISO' );
dst = ref.distance( qx, qy, offs, 'SAE' );

Optional Arguments

  • offs: offset of the curve used in computation

  • ’ISO’/’SAE’: use ISO or SAE orientation of the normal for the offset

function collision( self, OBJ, varargin)

Check if two curve collide.

Usage

ok = ref.collision( obj );
ok = ref.collision( obj, offs, offs1 );
ok = ref.collision( obj, offs, offs1, 'ISO' );
ok = ref.collision( obj, offs, offs1, 'SAE' );

Optional Arguments

  • offs, offs1: offset of the curves used in computation

  • ’ISO’/’SAE’: use ISO or SAE orientation of the normal for the offsets

function intersect( self, OBJ, varargin)

Intersect two curves.

Usage

[s1,s2] = ref.intersect( obj );
[s1,s2] = ref.intersect( obj, offs, offs1 );
[s1,s2] = ref.intersect( obj, offs, offs1, 'ISO' );
[s1,s2] = ref.intersect( obj, offs, offs1, 'SAE' );

  • s1: curvilinear coordinates of the intersections on the first curve

  • s2: curvilinear coordinates of the intersections on the second curve

Optional Argument

  • offs, offs1: offset of the curves used in computation

  • ’ISO’/’SAE’: use ISO or SAE orientation of the normal for the offsets

function info( self)

Print on the console some information on the stored curve.

Usage

ref.info();
function find_coord( self, x, y)

Get the curvilinear coordinates of the point (x,y)

Usage:

[s,t] = ref.find_coord( x, y );

  • s: curvilinear coordinate along the curve

  • t: curvilinear coordinate along the normal of the curve

function yesAABBtree( self)

Activate the use of AABB three in intersection/collision computations

function noAABBtree( self)

Deactivate the use of AABB three in intersection/collision computations

function plotTBox( self, P1, P2, P3, varargin)

Plot a triangle BBOX

Usage:

ref.plotTBox( P1, P2, P3 );
ref.plotTBox( P1, P2, P3, 'Color', 'red' );
function plotBBox( self, varargin)

Plot the bounding box of the curve

Usage:

ref.plotBBox();
ref.plotBBox('Color', 'red' );
function plotTriangles( self, varargin)

Plot the covering triangles of the curve

Usage:

ref.plotTriangles()
ref.plotTriangles('red','FaceAlpha', 0.5);