Appelez la fonction de création de modèle. Cette fonction génère un fichier de définition de classe que vous pouvez modifier pour votre propre implémentation.
Définition de classe et de propriété
La première partie du modèle spécifie la définition de classe et toutes les propriétés de la classe. Dérivez de la classe nav.StateSpace . Pour cet exemple, créez une propriété pour les distributions uniforme et normale. Vous pouvez spécifier ici toutes les propriétés supplémentaires définies par l'utilisateur.
classdef MyCustomStateSpace < nav.StateSpace & ...
matlabshared.planning.internal.EnforceScalarHandle
properties
UniformDistribution
NormalDistribution
% Specify additional properties here
end
Enregistrez votre classe d'espace d'état personnalisée et assurez-vous que votre nom de fichier correspond au nom de la classe.
Constructeur de classe
Utilisez le constructeur pour définir le nom de l'espace d'état, le nombre de variables d'état et définir ses limites. Vous pouvez également ajouter des arguments d'entrée à la fonction et transmettre les variables lorsque vous créez un objet.
Pour chaque variable d'état, définissez les valeurs [min max] pour les limites d'état.
Appelez le constructeur de la classe de base.
Pour cet exemple, vous spécifiez les valeurs des propriétés de distribution normale et uniforme à l'aide des classes prédéfinies NormalDistribution et UniformDistribution .
Spécifiez ici toute autre valeur de propriété définie par l'utilisateur.
methods
function obj = MyCustomStateSpace
spaceName = "MyCustomStateSpace";
numStateVariables = 3;
stateBounds = [-100 100; % [min max]
-100 100;
-100 100];
obj@nav.StateSpace(spaceName, numStateVariables, stateBounds);
obj.NormalDistribution = matlabshared.tracking.internal.NormalDistribution(numStateVariables);
obj.UniformDistribution = matlabshared.tracking.internal.UniformDistribution(numStateVariables);
% User-defined property values here
end
Copier la sémantique
Spécifiez la définition de la méthode copy . Copiez toutes les valeurs de vos variables définies par l'utilisateur dans un nouvel objet, donc copyObj est une copie complète. Le comportement par défaut donné dans cet exemple crée une nouvelle copie de l'objet avec le même nom, les mêmes limites d'état et les mêmes distributions.
function copyObj = copy(obj)
copyObj = feval(class(obj));
copyObj.StateBounds = obj.StateBounds;
copyObj.UniformDistribution = obj.UniformDistribution.copy;
copyObj.NormalDistribution = obj.NormalDistribution.copy;
end
Appliquer les limites de l'État
Spécifiez comment garantir que les États sont toujours dans les limites de l'État. Pour cet exemple, les valeurs d'état sont saturées aux valeurs minimales ou maximales des limites d'état.
function boundedState = enforceStateBounds(obj, state)
nav.internal.validation.validateStateMatrix(state, nan, obj.NumStateVariables, "enforceStateBounds", "state");
boundedState = state;
boundedState = min(max(boundedState, obj.StateBounds(:,1)'), ...
obj.StateBounds(:,2)');
end
Échantillonner uniformément
Spécifiez le comportement d’échantillonnage sur une distribution uniforme. prend en charge plusieurs syntaxes pour contraindre la distribution uniforme à un état proche dans une certaine distance et échantillonner plusieurs états.
STATE = sampleUniform(OBJ)
STATE = sampleUniform(OBJ,NUMSAMPLES)
STATE = sampleUniform(OBJ,NEARSTATE,DIST)
STATE = sampleUniform(OBJ,NEARSTATE,DIST,NUMSAMPLES)
Pour cet exemple, utilisez une fonction de validation pour traiter une entrée varargin qui gère les différents arguments d'entrée.
function state = sampleUniform(obj, varargin)
narginchk(1,4);
[numSamples, stateBounds] = obj.validateSampleUniformInput(varargin{:});
obj.UniformDistribution.RandomVariableLimits = stateBounds;
state = obj.UniformDistribution.sample(numSamples);
end
Échantillon de distribution gaussienne
Spécifiez le comportement d'échantillonnage sur une distribution gaussienne. Prend en charge plusieurs syntaxes pour échantillonner un seul état ou plusieurs états.
STATE = sampleGaussian(OBJ, MEANSTATE, STDDEV)
STATE = sampleGaussian(OBJ, MEANSTATE, STDDEV, NUMSAMPLES)
function state = sampleGaussian(obj, meanState, stdDev, varargin)
narginchk(3,4);
[meanState, stdDev, numSamples] = obj.validateSampleGaussianInput(meanState, stdDev, varargin{:});
obj.NormalDistribution.Mean = meanState;
obj.NormalDistribution.Covariance = diag(stdDev.^2);
state = obj.NormalDistribution.sample(numSamples);
state = obj.enforceStateBounds(state);
end
Interpoler entre les états
Définissez comment interpoler entre deux états dans votre espace d’états. Utilisez une entrée, fraction, pour déterminer comment échantillonner le long du chemin entre deux états. Pour cet exemple, définissez une méthode d'interpolation linéaire de base utilisant la différence entre les états.
function interpState = interpolate(obj, state1, state2, fraction)
narginchk(4,4);
[state1, state2, fraction] = obj.validateInterpolateInput(state1, state2, fraction);
stateDiff = state2 - state1;
interpState = state1 + fraction' * stateDiff;
end
Calculer la distance entre les États
Spécifiez comment calculer la distance entre deux états dans votre espace d'état. Utilisez les entrées state1 et state2 pour définir les positions de début et de fin. Les deux entrées peuvent être un seul état (vecteur ligne) ou plusieurs états (matrice de vecteurs lignes). Pour cet exemple, calculez la distance en fonction de la distance euclidienne entre chaque paire de positions d'état.
function dist = distance(obj, state1, state2)
narginchk(3,3);
nav.internal.validation.validateStateMatrix(state1, nan, obj.NumStateVariables, "distance", "state1");
nav.internal.validation.validateStateMatrix(state2, size(state1,1), obj.NumStateVariables, "distance", "state2");
stateDiff = bsxfun(@minus, state2, state1);
dist = sqrt( sum( stateDiff.^2, 2 ) );
end
Terminez les méthodes et les sections de classe.
Enregistrez la définition de votre classe d'espace d'état. Vous pouvez maintenant utiliser le constructeur de classe pour créer un objet pour votre espace d'état.
