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

stateSamplerGaussian

Échantillonneur d'état gaussien pour la planification de mouvements basée sur l'échantillonnage

Depuis R2023b

Description

L'objet stateSamplerGaussian crée un échantillonneur d'état pour la planification de mouvement en utilisant la distribution gaussienne. Utilisez cet échantillonneur pour planifier des mouvements dans des passages étroits. Pour plus d'informations sur la façon dont l'échantillonneur d'état gaussien sélectionne les échantillons d'état valides, voir Rechercher des exemples d'états à l'aide de l'échantillonneur d'état gaussien.

Création

Syntaxe

sampler = stateSamplerGaussian

sampler = stateSamplerGaussian(stateValidator)

sampler = stateSamplerGaussian(___,Name=Value)

Description

sampler = stateSamplerGaussian crée un échantillonneur d'état gaussien associé à un objet stateSpaceSE2 avec les paramètres par défaut.

sampler = stateSamplerGaussian(stateValidator) crée un échantillonneur d'état gaussien pour générer des échantillons pour un espace d'état valide. Utilisez l'objet validatorOccupancyMap pour créer un validateur d'état et utilisez le validateur d'état comme entrée de l'échantillonneur d'état gaussien.

sampler = stateSamplerGaussian(___,Name=Value) définit les propriétés en utilisant un argument ou un argument nom-valeur en plus de l'argument d'entrée dans la syntaxe précédente. Vous pouvez spécifier les propriétés StandardDeviation et MaxAttempts comme arguments nom-valeur.

Propriétés

StateSpace — Espace d’état SE(2)

Objet stateSpaceSE2

Ce propriété est en lecture seule.

Espace d'état SE(2), stocké en tant qu'objet stateSpaceSE2 . Cette propriété est définie par le validateur d'état d'entrée stateValidator.

StateValidator — Définition du validateur d’état

validatorOccupancyMap objet | objet de la sous-classe de la classe nav.StateValidator

Ce propriété est en lecture seule.

Définition du validateur d'état, spécifiée comme un objet validatorOccupancyMap ou un objet d'une sous-classe de la classe nav.StateValidator . Cette propriété est définie par le validateur d'état d'entrée stateValidator.

StandardDeviation — Écart type pour la distribution gaussienne

N-vecteur de ligne d'éléments

Écart type pour la distribution gaussienne, spécifié comme vecteur de ligne d'éléments N. N est le nombre de variables d'état. Pour l'espace d'état SE(2), l'écart type doit être un vecteur ligne à trois éléments de forme [σ_x σ_y σ_θ].

L'objet calcule la valeur par défaut de l'écart type en utilisant les limites minimale et maximale des variables d'état x, y et θ.

$$\begin{array}{l}{\sigma }_x=\frac{1}{100}\left(x_{\max }-x_{\min }\right)\\ {\sigma }_y=\frac{1}{100}\left(y_{\max }-y_{\min }\right)\\ {\sigma }_{\theta }=\frac{1}{100}\left({\theta }_{\max }-{\theta }_{\min }\right)\end{array}$$

Par programme, vous pouvez lire les limites des variables d'état à partir de la propriété StateSpace de l'objet stateSamplerGaussian . L'objet stateSamplerGaussian calcule la valeur par défaut de l'écart type comme suit :

1/100*(sampler.StateSpace.StateBounds(:,2)-sampler.StateSpace.StateBounds(:,1))

Pour plus d'informations sur la façon de choisir les valeurs d'écart type, voir Rechercher des exemples d'états à l'aide de l'échantillonneur d'état gaussien.

Remarque

Pour des résultats corrects, les valeurs d’écart type ne doivent pas dépasser la largeur des passages étroits dans l’espace de configuration.

Types de données : single | double

MaxAttempts — Seuil pour le nombre maximum de tentatives

10 (par défaut) | entier positif

Seuil du nombre maximum de tentatives que l'échantillonneur peut effectuer pour trouver les échantillons valides, spécifié sous la forme d'un entier positif. L'échantillonneur arrête la recherche s'il obtient le nombre optimal d'échantillons valides avant le seuil spécifié.

Vous pouvez affiner la valeur de ce paramètre ainsi que la valeur du paramètre d’écart type. Si les échantillons renvoyés par l'échantillonneur d'état sont dispersés dans tout l'espace de configuration, vous pouvez augmenter le nombre de tentatives pour permettre à l'échantillonneur de trouver des échantillons concentrés le long de la limite d'obstacle. De plus, si vous diminuez la valeur de l'écart type, vous devez envisager d'augmenter le nombre maximum de tentatives pour permettre à l'échantillonneur de trouver les échantillons optimaux.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Fonctions d'objet

sample	Exemples d'états de l'échantillonneur d'état gaussien
copy	Créer une copie complète de l'objet échantillonneur d'état gaussien

Exemples

Exemple d'espace d'état SE (2) à l'aide d'un échantillonneur d'état gaussien

Échantillonnez un espace d'état SE(2) à l'aide d'un échantillonneur d'état gaussien et observez l'impact des valeurs des paramètres de l'échantillonneur sur les résultats d'échantillonnage.

Définissez la valeur de départ pour vous assurer de générer les mêmes résultats.

rng(50,"twister");

Créez une carte d'occupation simple avec un passage étroit.

map = binaryOccupancyMap;
occupied = [5*ones(9,1),[1; 2; 3; 4; 5; 7; 8; 9; 10]];
setOccupancy(map,occupied,1);
figure(Position=[0, 0, 200, 200])
show(map)

Définissez les limites inférieure et supérieure des variables de l'espace d'état x, y et theta à partir de la carte d'occupation.

x = map.XWorldLimits;
y =  map.YWorldLimits;
theta = [-pi pi];

Créez un objet SE(2) d'espace d'état à l'aide des variables d'espace d'état spécifiées. Vérifiez la validité des états dans l'espace d'état d'entrée à l'aide d'un validateur d'état. Définissez la distance de validation sur 0,01.

ss = stateSpaceSE2([x; y; theta]);
sv = validatorOccupancyMap(ss,Map=map);
sv.ValidationDistance = 0.01;

Exemple d'espace d'état à l'aide d'un échantillonneur d'état gaussien

Créez un échantillonneur d'état gaussien avec les valeurs de paramètres par défaut. Par défaut:

• Le nombre maximum de tentatives que l'échantillonneur doit effectuer pour trouver les échantillons d'état est fixé à 10.

• Les valeurs d'écart type le long de la$\mathit{x},\mathit{y},$et$\theta$les directions sont définies respectivement sur 0,1, 0,1 et 0,0628.

sampler_orig = stateSamplerGaussian(sv)

sampler_orig = 
  stateSamplerGaussian with properties:

           StateSpace: [1x1 stateSpaceSE2]
       StateValidator: [1x1 validatorOccupancyMap]
    StandardDeviation: [0.1000 0.1000 0.0628]
          MaxAttempts: 10

Générez 40 échantillons pour la planification de mouvement à partir de l'espace d'état d'entrée.

states_orig = sample(sampler_orig,40);

Vous pouvez générer des échantillons optimaux en modifiant le nombre maximum de tentatives et les valeurs d'écart type. Si les échantillons sont dispersés dans tout l'espace d'entrée, augmentez le nombre maximum de tentatives et les valeurs d'écart type pour concentrer les échantillons d'état autour de la limite de l'obstacle.

Varier le nombre maximum de tentatives

Créez des copies de l'objet échantillonneur d'état d'origine et modifiez le nombre maximum de tentatives, propriété de l'échantillonneur, MaxAttempts, pour étudier son impact sur les résultats d'échantillonnage. Définissez les valeurs d’écart type sur les valeurs par défaut.

Définissez le nombre maximum de tentatives pour trouver des échantillons valides sur 100 et générez 40 nouveaux échantillons à partir de l'espace d'état d'entrée.

sampler_2 = copy(sampler_orig);
sampler_2.MaxAttempts = 100;
states_2 = sample(sampler_2,40);

Définissez le nombre maximum de tentatives pour trouver des échantillons valides sur 200 et générez 40 nouveaux échantillons à partir de l'espace d'état d'entrée.

sampler_3 = copy(sampler_orig);
sampler_3.MaxAttempts = 200;
states_3 = sample(sampler_3,40);

Affichez les résultats à l'aide de la fonction d'assistance helperDisplayStates . Notez que, à mesure que le nombre de tentatives augmente, les échantillons se concentrent davantage autour de la limite de l’obstacle.

helperDisplayStates(map,states_orig,sampler_2,states_2,sampler_3,states_3,"MaxAttempts");

Varier l'écart type

Créez des copies de l'objet échantillonneur d'état d'origine et modifiez l'écart type, propriété de l'échantillonneur, StandardDeviation, pour étudier son impact sur les résultats d'échantillonnage. Définissez le nombre maximum de tentatives sur 200.

Générez 40 échantillons avec les valeurs d’écart type par défaut.

sampler_orig.MaxAttempts = 200;
states_orig = sample(sampler_orig,40);

Définissez les valeurs d’écart type sur [0,01 0,01 0,06]. Générez 40 nouveaux échantillons à partir de l’espace d’état d’entrée.

sampler_4 = copy(sampler_orig);
sampler_4.StandardDeviation = [0.01 0.01 0.06];
states_4 = sample(sampler_4,40);

Définissez les valeurs d’écart type sur [0,5 0,5 0,06]. Générez 40 nouveaux échantillons à partir de l’espace d’état d’entrée.

sampler_5 = copy(sampler_orig);
sampler_5.StandardDeviation = [0.5 0.5 0.06];
states_5 = sample(sampler_5,40);

Affichez les résultats à l'aide de la fonction d'assistance helperDisplayStates . Notez que, à mesure que vous augmentez les valeurs d’écart type, les échantillons se concentrent davantage autour de la limite de l’obstacle. Cependant, si les valeurs d'écart type sont supérieures à la largeur des passages étroits dans l'espace d'entrée, l'échantillonneur génère des résultats incorrects.

helperDisplayStates(map,states_orig,sampler_4,states_4,sampler_5,states_5,"Std.Deviation");

 Fonction d'assistance 

helperDisplayStates affiche les résultats à l’aide d’une fenêtre de figure personnalisée.

function helperDisplayStates(map,states_orig,sampler_2,states_2,sampler_3,states_3,select)
if select == "MaxAttempts"
    title_1 = "MaxAttempts = 10 (Default value)";
    title_2 = strcat("MaxAttempts = ",num2str(sampler_2.MaxAttempts));
    title_3 = strcat("MaxAttempts = ",num2str(sampler_3.MaxAttempts));
elseif select == "Std.Deviation"
    title_1 = "StandardDeviation = [0.1 0.1 0.06] (Default value)";
    title_2 = strcat("StandardDeviation = [0.01 0.01 0.06]");
    title_3 = strcat("StandardDeviation = [0.5 0.5 0.06]");
end

fig_1 = figure(Position=[0 0 700 300]);
movegui("center")
panel_1 = uipanel(fig_1, ...
    Position=[0 0 0.33 1], ...
    Title=title_1);
hPlot1 = axes(panel_1);
show(map,Parent=hPlot1);
hold on;
plot(states_orig(:,1),states_orig(:,2),plannerLineSpec.state{:})
hold off

panel_2 = uipanel(fig_1, ...
    Position=[0.33 0 0.33 1], ...
    Title=title_2);
hPlot2 = axes(panel_2);
show(map,Parent=hPlot2);
hold on;
plot(states_2(:,1),states_2(:,2),plannerLineSpec.state{:})
hold off

panel_3 = uipanel(fig_1, ...
    Position=[0.66 0 0.33 1], ...
    Title=title_3);
hPlot3 = axes(panel_3);
show(map,Parent=hPlot3);
hold on;
plot(states_3(:,1),states_3(:,2),plannerLineSpec.state{:})
hold off
end

Effectuer une planification de mouvement à l'aide de l'approche d'échantillonnage dans l'espace d'état gaussien

Échantillonnez un espace d'états pour la planification de mouvements à l'aide de la distribution gaussienne, puis utilisez les états échantillonnés pour trouver un chemin optimal entre deux points dans l'espace d'états d'entrée. Utilisez un planificateur de chemin PRM pour calculer un chemin optimal entre deux points.

Définissez la valeur de départ du nombre aléatoire pour garantir la répétabilité.

rng(100,"twister");

Créer une carte d'occupation et rechercher des variables d'état

Chargez une carte binaire représentant l'environnement de l'espace d'état d'entrée dans l'espace de travail MATLAB®.

load("mapData.mat")

Créez une carte d'occupation à partir de l'entrée.

map = occupancyMap(narrowPassageMap);

Trouvez les limites inférieure et supérieure des variables de l'espace d'état x, y et theta à partir de la carte d'occupation.

x = map.XWorldLimits;
y =  map.YWorldLimits;
theta = [-pi pi];

Créer un échantillonneur d'état gaussien

Créez un objet SE(2) d'espace d'état à l'aide des variables d'espace d'état spécifiées.

stateSpace = stateSpaceSE2([x; y; theta]);

Vérifiez la validité des états dans l'espace d'état d'entrée à l'aide d'un validateur d'état.

stateValidator = validatorOccupancyMap(stateSpace,Map=map); 

Créez un échantillonneur d'état gaussien pour échantillonner l'espace d'état spécifié. Définissez les valeurs d’écart type.

sampler = stateSamplerGaussian(stateValidator,StandardDeviation=[25 5 0.05]); 

Configurer le planificateur de chemin PRM

Configurez le planificateur de chemin PRM. Utilisez l'échantillonneur d'état gaussien pour échantillonner l'espace d'état d'entrée.

planner = plannerPRM(stateSpace,stateValidator,StateSampler=sampler); 

Trouver le chemin optimal entre deux états

Spécifiez le point de départ et le point d'objectif dans l'espace d'état d'entrée.

start = [55 50 0];
goal = [210 190 0]; 

Calculez le chemin optimal entre le point de départ et le point d'arrivée à l'aide du planificateur de chemin PRM.

[path,info] = plan(planner,start,goal);

Visualisez les résultats

Afficher la carte d'occupation.

figure
show(map)
hold on

Tracez le point de départ et le point d'arrivée. Spécifiez les propriétés de couleur et de ligne par défaut pour tracer les points de départ et d'arrivée à l'aide des fonctions plannerLineSpec.start t et plannerLineSpec.goal , respectivement.

plot(start(1),start(2),plannerLineSpec.start{:}); 
plot(goal(1),goal(2),plannerLineSpec.goal{:}); 

Si le planificateur a trouvé un chemin optimal entre les états de départ et d'objectif, tracez les résultats. Utilisez la fonction plannerLineSpec.path pour spécifier la couleur et les propriétés de ligne par défaut pour tracer le chemin.

if info.IsPathFound
    plot(path.States(:,1),path.States(:,2),plannerLineSpec.path{:})
    legend
else
    disp("Path not found. Try modifying the planner parameters."); 
end

En savoir plus

Rechercher des exemples d'états à l'aide de l'échantillonneur d'état gaussien

L'échantillonneur génère à plusieurs reprises des paires d'états. L'échantillonneur sélectionne le premier échantillon d'état dans chaque paire en utilisant une distribution uniforme, et le deuxième échantillon d'état en utilisant une distribution gaussienne centrée autour du premier échantillon.

L'échantillonneur détermine la distance entre le premier échantillon et le deuxième échantillon de chaque paire en utilisant les paramètres gaussiens σ_x, σ_y et σ_θ.

• σ_x spécifie la propagation le long de la direction x

• σ_y spécifie la propagation le long de la direction y.

• σ_θ spécifie la propagation le long de la direction angulaire.

Le validateur d'état considère qu'une paire d'états générée est valide si un échantillon d'état de la paire se trouve sur l'obstacle et l'autre se trouve dans l'espace libre. L'échantillon de la paire valide qui se trouve dans l'espace libre est renvoyé comme échantillon d'état pour la planification du mouvement.

Comment sélectionner les valeurs d’écart type ?

Pour obtenir les échantillons optimaux pour la planification de mouvements, vous pouvez diminuer ou augmenter les valeurs d'écart type.

• Lorsque vous diminuez la valeur de l'écart type le long d'une direction particulière, la distance entre deux échantillons de chaque paire valide diminue le long de la direction spécifiée. Diminuez les valeurs d’écart type si l’espace d’entrée pour la planification du mouvement comporte des passages trop étroits. Vous devez également augmenter le nombre maximum de tentatives de l'échantillonneur pour trouver les échantillons optimaux.

• Lorsque vous augmentez la valeur de l'écart type le long d'une direction particulière, la distance entre deux échantillons de chaque paire valide augmente le long de la direction spécifiée. Augmentez les valeurs d'écart type si l'espace d'entrée pour la planification du mouvement ne comporte pas de passages trop étroits.

Historique des versions

Introduit dans R2023b

Voir aussi

Fonctions

• sample | copy

Objets

• stateSamplerUniform | stateSamplerMPNET

Rubriques

• Hybrid Sampling Method for Motion Planning in Warehouse Environment