Cette page a été traduite par traduction automatique. Cliquez ici pour voir la dernière version en anglais.

sampleGaussian

Classe : nav.StateSpace
Namespace : nav

Exemple d'état utilisant la distribution gaussienne

développer tous les éléments de la page

Syntaxe

states = sampleGaussian(ssObj,meanState,stdDev)
states = sampleGaussian(ssObj,meanState,stdDev,numSamples)

Description

states = sampleGaussian(ssObj,meanState,stdDev) échantillonne un seul état dans votre espace d'états à partir d'une distribution gaussienne centrée sur meanState avec un écart type spécifié.

exemple

states = sampleGaussian(ssObj,meanState,stdDev,numSamples) échantillonne plusieurs états en fonction de numSamples.

Arguments d'entrée

développer tout

Objet d'espace d'état, spécifié comme objet d'une sous-classe de nav.StateSpace.

Position d'état moyenne, spécifiée comme vecteur d'élément n ou m-par- n matrice de vecteurs de lignes, où n est la dimension de l'espace d'état spécifié dans la propriété NumStateVariables de ssObj. m est le nombre d'échantillons spécifié dans numSamples.

Écart type autour de l'état moyen, spécifié comme un vecteur d'éléments n ou une matrice m-by- n de vecteurs lignes, où chacun element correspond à un élément dans meanState.

Nombre d'échantillons, spécifié sous forme d'entier positif. Par défaut, la fonction suppose que numSamples est 1.

Arguments de sortie

développer tout

États échantillonnés à partir de l'espace d'états, spécifiés comme un vecteur d'éléments n ou une matrice m-by- n de vecteurs de ligne. n est la dimension de l'espace d'état spécifié dans la propriété NumStateVariables de ssObj. m est le nombre d'échantillons spécifié dans numSamples. Tous les états sont échantillonnés dans la propriété StateBounds de ssObj.

Exemples

développer tout

Ouvrir le live script

Cet exemple montre comment utiliser la fonction createPlanningTemplate pour générer un modèle permettant de personnaliser votre propre définition d'espace d'état et votre échantillonneur à utiliser avec les algorithmes de planification de chemin. Une implémentation simple est fournie avec le modèle.

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.

createPlanningTemplate

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.

    end
end

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.

Historique des versions

Introduit dans R2019b

Voir aussi

| | | |