Program Listing for File CurveBase.m¶
↰ Return to documentation for file (CurveBase.m)
classdef CurveBase < handle
%% MATLAB class wrapper for the underlying C++ class
properties (SetAccess = protected, Hidden = true)
mexName;
objectHandle; % Handle to the underlying C++ class instance
end
methods
function self = CurveBase( mexName )
self.mexName = mexName;
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
function delete( self )
%% Destroy the C++ class instance
if self.objectHandle ~= 0
feval( self.mexName, 'delete', self.objectHandle );
end
self.objectHandle = 0; % avoid double destruction of object
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Return the `pointer` of the interbal stored c++ object
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> obj = ref.obj_handle();
%>
%> \endrst
%>
function obj = obj_handle( self )
obj = self.objectHandle;
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Make of copy of a curve object
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> ref.copy( C );
%>
%> \endrst
%>
%> where `C` id the curve object to be copied.
%>
function copy( self, C )
feval( self.mexName, 'copy', self.objectHandle, C.obj_handle() );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Return the bounding box of the curve object
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> [ 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' );
%>
%> \endrst
%>
%> - 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 [ xmin, ymin, xmax, ymax ] = bbox( self, varargin )
% return the bounding box triangle of the circle arc
[ xmin, ymin, xmax, ymax ] = ...
feval( self.mexName, 'bbox', self.objectHandle, varargin{:} );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Translate the curve by `(tx,ty)`
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> ref.translate( tx, ty );
%>
%> \endrst
%>
function translate( self, tx, ty )
% translate curve by vector (tx,ty)
feval( self.mexName, 'translate', self.objectHandle, tx, ty );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Cut the curve at the curvilinear parameter `smin` up to `smax`
%>
%> **Usage**
%>
%> ref.trim( smin, smax );
%>
function trim( self, smin, smax )
% trim circle curve to the corresponding curvilinear parameters
feval( self.mexName, 'trim', self.objectHandle, smin, smax );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Rotate the curve by angle `angle` around point `(cx, cy)`
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> ref.rotate( angle, cx, cy );
%>
%> \endrst
%>
function rotate( self, angle, cx, cy )
% rotate curve around `(cx,cy)` by angle `angle`
feval( self.mexName, 'rotate', self.objectHandle, angle, cx, cy );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Reverse the direction of travel of the curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> ref.reverse();
%>
%> \endrst
%>
function reverse( self )
% reverse curve mileage
feval( self.mexName, 'reverse', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Scale the curve by factor `sc`
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> ref.scale( sc );
%>
%> \endrst
%>
function scale( self, sc )
% scale curve by `sc`
feval( self.mexName, 'scale', self.objectHandle, sc );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Translate the curve in such a way the origin is at `(newX0,newY0`.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> ref.changeOrigin( newX0, newY0 );
%>
%> \endrst
%>
function changeOrigin( self, newX0, newY0 )
% change the origgin or the curve to `(newX0,newY0)`
feval( self.mexName, 'changeOrigin', self.objectHandle, newX0, newY0 );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate the curve at curvilinear coordinate `s`.
%> Argument `s` may be a vector for multiple evaluations.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> [ 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' );
%>
%> \endrst
%>
%> **Optional Arguments**
%>
%> - offs: offset of the curve used in computation
%> - 'ISO'/'SAE': use ISO or SAE orientation of the normal for offset computation
%>
function [ x, y, theta, kappa ] = evaluate( self, s, varargin )
[ x, y, theta, kappa ] = feval( self.mexName, 'evaluate', ...
self.objectHandle, s, varargin{:} ...
);
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate the curve at curvilinear coordinate `s`.
%> Argument `s` may be a vector for multiple evaluations.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> 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' );
%>
%> \endrst
%>
%> **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 varargout = eval( self, varargin )
[ varargout{1:nargout} ] = ...
feval( self.mexName, 'eval', self.objectHandle, varargin{:} );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate the first derivatives of the curve at curvilinear coordinate `s`.
%> Argument `s` may be a vector for multiple evaluations.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> 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' );
%>
%> \endrst
%>
%> **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 varargout = eval_D( self, varargin )
% evaluate derivative at `s`
% XY = eval_D(s,[offs,'ISO'/'SAE')
% [X,Y] = eval_D(s,[offs,'ISO'/'SAE')
[ varargout{1:nargout} ] = ...
feval( self.mexName, 'eval_D', self.objectHandle, varargin{:} );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate the second derivatives of the curve at curvilinear coordinate `s`.
%> Argument `s` may be a vector for multiple evaluations.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> 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' );
%>
%> \endrst
%>
%> **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 varargout = eval_DD( self, varargin )
[ varargout{1:nargout} ] = ...
feval( self.mexName, 'eval_DD', self.objectHandle, varargin{:} );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate the third derivatives of the curve at curvilinear coordinate `s`.
%> Argument `s` may be a vector for multiple evaluations.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> 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' );
%>
%> \endrst
%>
%> **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 varargout = eval_DDD( self, varargin )
[ varargout{1:nargout} ] = ...
feval( self.mexName, 'eval_DDD', self.objectHandle, varargin{:} );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate the angle of the curve at curvilinear coordinate `s`.
%> Argument `s` may be a vector for multiple evaluations.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> theta = ref.theta( s );
%>
%> \endrst
%>
function th = theta(self, s)
th = feval( self.mexName, 'theta', self.objectHandle, s );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate the angle derivatives (curvature) of the curve at curvilinear coordinate `s`.
%> Argument `s` may be a vector for multiple evaluations.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> theta = ref.theta_D( s );
%>
%> \endrst
%>
function th = theta_D(self, s)
% evaluate angle derivative [curvature] at `s`
th = feval( self.mexName, 'theta_D', self.objectHandle, s );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate the angle second derivatuve of the curve at curvilinear coordinate `s`.
%> Argument `s` may be a vector for multiple evaluations.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> theta = ref.theta_DD( s );
%>
%> \endrst
%>
function th = theta_DD(self, s)
% evaluate angle second derivative at `s`
th = feval( self.mexName, 'theta_DD', self.objectHandle, s );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate the angle third derivative of the curve at curvilinear coordinate `s`.
%> Argument `s` may be a vector for multiple evaluations.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> theta = ref.theta_DDD( s );
%>
%> \endrst
%>
function th = theta_DDD(self, s)
% evaluate angle third derivative at `s`
th = feval( self.mexName, 'theta_DDD', self.objectHandle, s );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate the curvature of the curve at curvilinear coordinate `s`.
%> Argument `s` may be a vector for multiple evaluations.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> theta = ref.kappa( s );
%>
%> \endrst
%>
function th = kappa(self, s)
% evaluate curvature at `s`
th = feval( self.mexName, 'kappa', self.objectHandle, s );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate the curvature derivative of the curve at curvilinear coordinate `s`.
%> Argument `s` may be a vector for multiple evaluations.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> theta = ref.kappa_D( s );
%>
%> \endrst
%>
function th = kappa_D(self, s)
% evaluate curvature derivative at `s`
th = feval( self.mexName, 'kappa_D', self.objectHandle, s );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate the curvature second derivative of the curve at curvilinear coordinate `s`.
%> Argument `s` may be a vector for multiple evaluations.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> theta = ref.kappa_DD( s );
%>
%> \endrst
%>
%>
function th = kappa_DD(self, s)
% evaluate curvature second derivative at `s`
th = feval( self.mexName, 'kappa_DD', self.objectHandle, s );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate initial point of the curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> [ x0, y0 ] = ref.xyBegin();
%>
%> \endrst
%>
function [ x, y ] = xyBegin( self )
[ x, y ] = feval( self.mexName, 'xyBegin', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate final point of the curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> [ x1, y1 ] = ref.xyEnd();
%>
%> \endrst
%>
function [ x, y ] = xyEnd( self )
[ x, y ] = feval( self.mexName, 'xyEnd', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate initial x-coordinate of the curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> x0 = ref.xBegin();
%>
%> \endrst
%>
function X0 = xBegin( self )
X0 = feval( self.mexName, 'xBegin', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate final x-coordinate of the curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> x1 = ref.xEnd();
%>
%> \endrst
%>
function X1 = xEnd( self )
X1 = feval( self.mexName, 'xEnd', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate initial y-coordinate of the curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> y0 = ref.yBegin();
%>
%> \endrst
%>
function Y0 = yBegin( self )
Y0 = feval( self.mexName, 'yBegin', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate final y-coordinate of the curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> y1 = ref.yEnd();
%>
%> \endrst
%>
function Y1 = yEnd( self )
Y1 = feval( self.mexName, 'yEnd', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate initial angle of the curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> theta = ref.thetaBegin();
%>
%> \endrst
%>
function th0 = thetaBegin( self )
th0 = feval( self.mexName, 'thetaBegin', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate final angle of the curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> theta = ref.thetaEnd();
%>
%> \endrst
%>
function th1 = thetaEnd( self )
th1 = feval( self.mexName, 'thetaEnd', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate initial curvature of the curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> kappa0 = ref.kappaBegin();
%>
%> \endrst
%>
function kappa0 = kappaBegin( self )
kappa0 = feval( self.mexName, 'kappaBegin', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate final curvature of the curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> kappa1 = ref.kappaEnd();
%>
%> \endrst
%>
function kappa1 = kappaEnd( self )
kappa1 = feval( self.mexName, 'kappaEnd', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Return the length of the curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> length = ref.length();
%>
%> \endrst
%>
function res = length( self, varargin )
res = feval( self.mexName, 'length', self.objectHandle, varargin{:} );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
function [ p1, p2 ] = points( self )
[ p1, p2 ] = feval( self.mexName, 'points', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Evaluate the bounding box triangles of curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> [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');
%>
%> \endrst
%>
%> **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 [P1,P2,P3] = bbTriangles( self, varargin )
[P1,P2,P3] = feval( self.mexName, 'bbTriangles', ...
self.objectHandle, varargin{:} ...
);
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> 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**
%>
%> \rst
%> .. code-block:: matlab
%>
%> [ 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' );
%>
%> \endrst
%>
%> **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 varargout = closestPoint( self, qx, qy, varargin )
% iflag > 0 = segment number
[ varargout{1:nargout} ] = feval( self.mexName, 'closestPoint', ...
self.objectHandle, qx, qy, varargin{:} ...
);
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> 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**
%>
%> \rst
%> .. code-block:: matlab
%>
%> 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' );
%>
%> \endrst
%>
%> **Optional Arguments**
%>
%> - `offs`: offset of the curve used in computation
%> - 'ISO'/'SAE': use ISO or SAE orientation of the normal for the offset
%>
function dst = distance( self, qx, qy, varargin )
dst = feval( self.mexName, 'distance', ...
self.objectHandle, qx, qy, varargin{:} ...
);
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Check if two curve collide.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> ok = ref.collision( obj );
%> ok = ref.collision( obj, offs, offs1 );
%> ok = ref.collision( obj, offs, offs1, 'ISO' );
%> ok = ref.collision( obj, offs, offs1, 'SAE' );
%>
%> \endrst
%>
%> **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 ok = collision( self, OBJ, varargin )
ok = feval( self.mexName, 'collision', ...
self.objectHandle, OBJ.obj_handle(), OBJ.is_type(), varargin{:} ...
);
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Intersect two curves.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> [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' );
%>
%> \endrst
%>
%> - `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 [s1,s2] = intersect( self, OBJ, varargin )
[s1,s2] = feval( self.mexName, 'intersect', ...
self.objectHandle, OBJ.obj_handle(), OBJ.is_type(), varargin{:} ...
);
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Print on the console some information on the stored curve.
%>
%> **Usage**
%>
%> \rst
%> .. code-block:: matlab
%>
%> ref.info();
%>
%> \endrst
%>
function info( self )
feval( self.mexName, 'info', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Get the curvilinear coordinates of the point `(x,y)`
%>
%> **Usage:**
%>
%> \rst
%> .. code-block:: matlab
%>
%> [s,t] = ref.find_coord( x, y );
%>
%> \endrst
%>
%> - `s`: curvilinear coordinate along the curve
%> - `t`: curvilinear coordinate along the normal of the curve
%>
function [s,t] = find_coord( self, x, y )
[s,t] = feval( self.mexName, 'findST', self.objectHandle, x, y );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%>
%> Activate the use of AABB three in intersection/collision computations
%>
function yesAABBtree( self )
feval( self.mexName, 'yesAABBtree', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%>
%> Deactivate the use of AABB three in intersection/collision computations
%>
function noAABBtree( self )
feval( self.mexName, 'noAABBtree', self.objectHandle );
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Plot a triangle BBOX
%>
%> **Usage:**
%>
%> \rst
%> .. code-block:: matlab
%>
%> ref.plotTBox( P1, P2, P3 );
%> ref.plotTBox( P1, P2, P3, 'Color', 'red' );
%>
%> \endrst
%>
%>
function plotTBox( self, P1, P2, P3, varargin )
for k=1:size(P1,2)
pp1 = P1(:,k);
pp2 = P2(:,k);
pp3 = P3(:,k);
plot( [pp1(1),pp2(1),pp3(1),pp1(1)], ...
[pp1(2),pp2(2),pp3(2),pp1(2)], varargin{:} );
end
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Plot the bounding box of the curve
%>
%> **Usage:**
%>
%> \rst
%> .. code-block:: matlab
%>
%> ref.plotBBox();
%> ref.plotBBox('Color', 'red' );
%>
%> \endrst
%>
function plotBBox( self, varargin )
if nargin > 1
offs = varargin{1};
[xmin,ymin,xmax,ymax] = self.bbox( offs );
else
[xmin,ymin,xmax,ymax] = self.bbox();
end
x = [ xmin, xmax, xmax, xmin, xmin ];
y = [ ymin, ymin, ymax, ymax, ymin ];
if nargin > 2
plot( x, y, varargin{2:end});
else
plot( x, y );
end
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
%> Plot the covering triangles of the curve
%>
%> **Usage:**
%>
%> \rst
%> .. code-block:: matlab
%>
%> ref.plotTriangles()
%> ref.plotTriangles('red','FaceAlpha', 0.5);
%>
%> \endrst
%>
function plotTriangles( self, varargin )
[p1,p2,p3] = self.bbTriangles();
for k=1:size(p1,2)
x = [ p1(1,k), p2(1,k), p3(1,k), p1(1,k) ];
y = [ p1(2,k), p2(2,k), p3(2,k), p1(2,k) ];
%fill( x, y, 'red','FaceAlpha', 0.5 );
fill( x, y, varargin{:});
end
end
% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
end
end
