resample

Rééchantillonner des données uniformes ou non uniformes à une nouvelle fréquence fixe

Syntaxe

y = resample(x,p,q)

y = resample(x,p,q,n)

y = resample(x,p,q,n,beta)

y = resample(x,p,q,b)

yTT = resample(xTT,p,q,___)

y = resample(x,tx)

y = resample(x,tx,fs)

y = resample(x,tx,fs,p,q)

y = resample(x,tx,___,method)

[y,ty] = resample(x,tx,___)

yTT = resample(xTT,___)

[y,b] = resample(x,p,q,___)

[y,ty,b] = resample(x,tx,___)

[yTT,b] = resample(xTT,___)

[___] = resample(___,Dimension=dim)

Description

y = resample(x,p,q) rééchantillonne la séquence d’entrée x en multipliant la fréquence d’échantillonnage d’origine par p/q. resample applique un Filtre passe-bas antialiasing FIR à x et compense le retard dû au filtre. La fonction s’applique le long de la première dimension de tableau dont la taille est supérieure à 1.

y = resample(x,p,q,n) utilise un filtre antialiasing d’ordre 2 × n × max(p,q).

y = resample(x,p,q,n,beta) définit le paramètre de forme de la fenêtre de Kaiser utilisée pour créer le filtre passe-bas.

y = resample(x,p,q,b) filtre x en utilisant les coefficients de filtre définis dans b.

yTT = resample(xTT,p,q,___) rééchantillonne les données uniformément échantillonnées de la timetable MATLAB^® xTT en multipliant la fréquence d’échantillonnage d’origine par p/q. La fonction renvoie la timetable yTT. Vous pouvez spécifier les arguments supplémentaires n, beta ou b.

y = resample(x,tx) rééchantillonne les valeurs x d’un signal échantillonné aux instants indiqués dans le vecteur tx. La fonction interpole linéairement x sur un vecteur d’instants uniformément espacés avec les mêmes points d’extrémité et le même nombre d’échantillons que tx. Les valeurs NaN sont traitées comme des données manquantes et ignorées.

y = resample(x,tx,fs) utilise un filtre antialiasing polyphase pour rééchantillonner le signal à la fréquence d’échantillonnage uniforme définie dans fs.

y = resample(x,tx,fs,p,q) interpole le signal d’entrée sur une grille uniforme intermédiaire en espaçant les échantillons de (p/q)/fs. La fonction filtre ensuite le résultat pour le suréchantillonner par p et le sous-échantillonner par q, ce qui donne la fréquence d’échantillonnage finale fs. Pour des résultats optimaux, assurez-vous que fs × q/p est au moins égal au double de la plus haute composante de fréquence de x.

y = resample(x,tx,___,method) définit la méthode d’interpolation ainsi qu’un ou plusieurs arguments des syntaxes précédentes de ce groupe. La méthode d’interpolation peut être "linear", "pchip" ou "spline".

[y,ty] = resample(x,tx,___) renvoie dans ty les instants correspondant au signal rééchantillonné.

yTT = resample(xTT,___) rééchantillonne les données non uniformément échantillonnées de xTT et renvoie des données uniformément échantillonnées. yTT a les mêmes points d’extrémité et le même nombre d’échantillons que xTT. Vous pouvez spécifier les mêmes options d’argument que celles disponibles pour l’entrée x,tx.

[y,b] = resample(x,p,q,___) renvoie également les coefficients du filtre appliqué à x pendant le rééchantillonnage.

[y,ty,b] = resample(x,tx,___) renvoie dans b les coefficients du filtre antialiasing.

[yTT,b] = resample(xTT,___) rééchantillonne les données de la timetable xTT et renvoie également les coefficients du filtre antialiasing dans b.

[___] = resample(___,Dimension=dim) rééchantillonne l’entrée le long de la dimension dim.

Exemples

Rééchantillonner une séquence linéaire

Rééchantillonnez une séquence linéaire aux 3/2 de la fréquence d’échantillonnage d’origine de 10 Hz. Tracez les signaux d’origine et rééchantillonnés sur la même figure.

fs = 10;
t1 = 0:1/fs:1;
x = t1;
y = resample(x,3,2);
t2 = (0:(length(y)-1))*2/(3*fs);

plot(t1,x,'*',t2,y,'o')
xlabel('Time (s)')
ylabel('Signal')
legend('Original','Resampled', ...
    'Location','NorthWest')

Lors du filtrage, resample suppose que la séquence d’entrée x est nulle avant et après les échantillons donnés. Les écarts importants par rapport à zéro aux points d’extrémité de x peuvent entraîner des valeurs de y inattendues.

Affichez ces écarts en rééchantillonnant une séquence triangulaire et une version décalée verticalement de la séquence avec des points d’extrémité non nuls.

x = [1:10 9:-1:1;
    10:-1:1 2:10]';
y = resample(x,3,2);

subplot(2,1,1)
plot(1:19,x(:,1),'*',(0:28)*2/3 + 1,y(:,1),'o')
title('Edge Effects Not Noticeable')
legend('Original','Resampled', ...
    'Location','South')

subplot(2,1,2)
plot(1:19,x(:,2),'*',(0:28)*2/3 + 1,y(:,2),'o')
title('Edge Effects Noticeable')
legend('Original','Resampled', ...
    'Location','North')

Rééchantillonner un signal avec une fenêtre de Kaiser

Créez un signal sinusoïdal. Définissez une fréquence d’échantillonnage de sorte que 16 échantillons correspondent exactement à une période du signal. Affichez un tracé à tiges du signal. Superposez-lui un graphique en escalier pour visualiser l’échantillonnage avec conservation des valeurs.

fs = 16;
t = 0:1/fs:1-1/fs;

x = 0.75*sin(2*pi*t);

stem(t,x)
hold on
stairs(t,x)
hold off

Utilisez resample pour suréchantillonner le signal par un facteur de 4. Utilisez les paramètres par défaut. Tracez le résultat ainsi que le signal d’origine.

ups = 4;
dns = 1;

fu = fs*ups;
tu = 0:1/fu:1-1/fu;

y = resample(x,ups,dns);

stem(tu,y)
hold on
stairs(t,x)
hold off
legend("Resampled","Original")

Répétez le calcul. Spécifiez n = 1 pour que le filtre antialiasing soit d’ordre $$2\times 1\times 4=8$$. Spécifiez un paramètre de forme $$\beta =0$$ pour la fenêtre de Kaiser. Générez le filtre ainsi que le signal rééchantillonné.

n = 1;
beta = 0;

[y,b] = resample(x,ups,dns,n,beta);

fo = filtord(b)

fo = 
8

stem(tu,y)
hold on
stairs(t,x,"--")
hold off
legend("n = 1, \beta = 0")

Le signal rééchantillonné présente des effets d’aliasing dus au lobe principal relativement large et à la faible atténuation de lobe secondaire de la fenêtre.

Augmentez n à 5 et gardez $$\beta =0$$. Vérifiez que le filtre est d’ordre 40. Tracez le signal rééchantillonné.

n = 5;

[y,b] = resample(x,ups,dns,n,beta);

fo = filtord(b)

fo = 
40

stem(tu,y)
hold on
stairs(t,x,"--")
hold off
legend("n = 5, \beta = 0")

La fenêtre plus longue a un lobe principal plus étroit et atténue mieux les effets d’aliasing. Elle atténue également le signal.

Laissez l’ordre du filtre à $$2\times 5\times 4=40$$ et augmentez le paramètre de forme à $$\beta =20$$.

beta = 20;

y = resample(x,ups,dns,n,beta);

stem(tu,y)
hold on
stairs(t,x,"--")
hold off
legend("n = 5, \beta = 20")

La forte atténuation de lobe secondaire donne un rééchantillonnage efficace.

Diminuez l’ordre du filtre pour le ramener à $$2\times 1\times 4=8$$ et gardez $$\beta =20$$.

n = 1;

[y,b] = resample(x,ups,dns,n,beta);

stem(tu,y)
hold on
stairs(t,x,"--")
hold off
legend("n = 1, \beta = 20")

Le lobe principal plus large génère des artefacts considérables lors du rééchantillonnage.

Rééchantillonner une sinusoïde

Générez une sinusoïde de 60 échantillons et rééchantillonnez-la aux 3/2 de la fréquence d’origine. Affichez les signaux d’origine et rééchantillonné.

tx = 0:6:360-3;
x = sin(2*pi*tx/120);

ty = 0:4:360-2;
[y,by] = resample(x,3,2);

plot(tx,x,'+-',ty,y,'o:')
legend('original','resampled')

Tracez la réponse en fréquence du filtre antialiasing.

freqz(by)

Rééchantillonnez le signal aux 2/3 de la fréquence d’origine. Affichez le signal d’origine et son rééchantillonnage.

tz = 0:9:360-9;
[z,bz] = resample(x,2,3);

plot(tx,x,'+-',tz,z,'o:')
legend('original','resampled')

Tracez la réponse impulsionnelle du nouveau filtre passe-bas.

impz(bz)

Rééchantillonner les données d’une timetable

Créez deux vecteurs de dix nombres générés aléatoirement. Supposez qu’un nombre a été enregistré pour chaque vecteur tous les jours pendant un total de dix jours. Stockez les données dans une timetable MATLAB.

a = randn(10,1);
b = randn(10,1);

t = days(1:10);

xTT = timetable(t',[a b]);

Utilisez la fonction resample pour augmenter la fréquence d’échantillonnage d’une fois par jour à une fois par heure. Tracez les deux jeux de données.

yTT = resample(xTT,24,1);

subplot(2,1,1)
plot(xTT.Time,xTT.Var1,'-o')
subplot(2,1,2)
plot(yTT.Time,yTT.Var1,'-o')

Rééchantillonner un jeu de données non uniformément échantillonné

Utilisez les données enregistrées par Galilée en 1610 pour déterminer la période orbitale de Callisto, le plus extérieur des quatre plus grands satellites de Jupiter.

Galilée a observé le mouvement des satellites pendant six semaines à partir du 15 janvier. Ses observations comportent des lacunes, car Jupiter n’était pas visible les nuits où le temps était nuageux. Générez un tableau datetime des heures d’observation.

t = [0 2 3 7 8 9 10 11 12 17 18 19 20 24 25 26 27 28 29 31 32 33 35 37 ...
    41 42 43 44 45]'+1;

yg = [10.5 11.5 10.5 -5.5 -10.0 -12.0 -11.5 -12.0 -7.5 8.5 12.5 12.5 ...
    10.5 -6.0 -11.5 -12.5 -12.5 -10.5 -6.5 2.0 8.5 10.5 13.5 10.5 -8.5 ...
    -10.5 -10.5 -10.0 -8.0]';

obsv = datetime(1610,1,15+t);

Rééchantillonnez les données sur une grille régulière avec une fréquence d’échantillonnage d’une observation par jour. Utilisez un facteur de suréchantillonnage modéré de 3 pour éviter le surajustement.

fs = 1;

[y,ty] = resample(yg,t,fs,3,1);

Tracez les données et le signal rééchantillonné.

plot(t,yg,'o',ty,y,'.-')
xlabel('Day')

Répétez la procédure en utilisant une interpolation par spline et en affichant les dates d’observation. Exprimez la fréquence d’échantillonnage en inverse du nombre de jours.

fs = 1/86400;

[ys,tys] = resample(yg,obsv,fs,3,1,'spline');

plot(t,yg,'o')
hold on
plot(ys,'.-')
hold off

ax = gca;
ax.XTick = t(1:9:end);
ax.XTickLabel = char(obsv(1:9:end));

Calculez l’estimation du spectre de puissance du périodogramme des données uniformément espacées et interpolées de manière linéaire. Choisissez une longueur de DFT de 1 024. Le signal atteint un pic à l’inverse de la période orbitale.

[pxx,f] = periodogram(ys,[],1024,1,'power');
[pk,i0] = max(pxx);

f0 = f(i0);
T0 = 1/f0

T0 = 
16.7869

plot(f,pxx,f0,pk,'o')
xlabel('Frequency (day^{-1})')

Rééchantillonner les données non uniformément échantillonnées d’une timetable

Une personne a enregistré son poids en livres presque tous les jours de l’année bissextile 2012. Elle a saisi une valeur NaN pour les échantillons manquants. Chargez les données et stockez les mesures dans une timetable MATLAB. Spécifiez les informations d’horodatage des lignes avec un vecteur datetime et supprimez les échantillons manquants.

load weight2012.dat

rowTimes = datetime(2012,1,1:366)';
wt = weight2012(:,2);
xTT = timetable(rowTimes,wt);
xTT(isnan(wt),:) = [];

Rééchantillonnez les données. Le résultat est une timetable contenant des données uniformément échantillonnées avec les mêmes points d’extrémité et le même nombre d’échantillons que wt.

yTT = resample(xTT);

Tracez les données d’origine et rééchantillonnées pour les comparer. Ajustez les limites de l’axe des x pour afficher uniquement les mesures du mois d’août.

plot(xTT.rowTimes,xTT.wt,":o",yTT.Time,yTT.wt,"-*")
aug = datetime([2012 08 01;2012 08 31]); 
xlim(aug)
legend(["Original" "Resampled"])

Rééchantillonnez à nouveau les données avec une interpolation cubique.

yTTs = resample(xTT,"pchip");

plot(xTT.rowTimes,xTT.wt,":o",yTTs.Time,yTTs.wt,"-*")
xlim(aug)
legend(["Original" "Resampled"])

À présent, augmentez la fréquence d’échantillonnage à deux mesures par jour et appliquez une interpolation par spline. Tracez le résultat.

fs = 1/86400;
yTTf = resample(xTT,2*fs,"spline");

plot(xTT.rowTimes,xTT.wt,":o",yTTf.Time,yTTf.wt,'-*')
xlim(aug)
legend(["Original" "Resampled"])

Rééchantillonner un signal multicanal

Générez un signal sinusoïdal à 5 canaux et 100 échantillons. Les horodatages augmentent le long des colonnes et les fréquences augmentent le long des lignes. Tracez le signal.

p = 3;
q = 2;

tx = 0:p:300-p;

x = cos(2*pi*tx./(1:5)'/100);

plot(tx,x,'.:')
title('Original')
ylim([-1.5 1.5])

Suréchantillonnez la sinusoïde par 3/2 le long de sa deuxième dimension. Superposez le signal rééchantillonné sur le tracé.

ty = 0:q:300-q;

y = resample(x,p,q,'Dimension',2);

plot(ty,y,'.:')
title('Upsampled')

Transformez le signal rééchantillonné pour que les horodatages correspondent à une troisième dimension.

y = permute(y,[1 3 2]);
size(y)

ans = 1×3

     5     1   150

Sous-échantillonnez le signal pour le ramener à sa fréquence d’origine et tracez-le.

z = resample(y,q,p,'Dimension',3);

plot(tx,squeeze(z),'.:')
title('Downsampled')

Arguments d'entrée

x — Signal d’entrée

vecteur | matrice | tableau ND

Signal d’entrée, défini par un vecteur, une matrice ou un tableau ND. x peut contenir des valeurs NaN lorsque des informations temporelles sont incluses. Les valeurs NaN sont traitées comme des données manquantes et exclues du rééchantillonnage.

Exemple : cos(pi/4*(0:159))+randn(1,160) est un signal monocanal défini par un vecteur ligne.

Exemple : cos(pi./[4;2]*(0:159))'+randn(160,2) est un signal bicanal.

Types de données : single | double

p, q — Facteurs de rééchantillonnage

entiers positifs

Facteurs de rééchantillonnage, définis par des entiers positifs.

Types de données : single | double

n — Nombre de termes voisins

10 (par défaut) | entier non négatif

Nombre de termes voisins, défini par un entier non négatif. Si n = 0, resample effectue une interpolation au plus proche voisin. La longueur du filtre FIR antialiasing est proportionnelle à n. Des valeurs de n plus élevées offrent une meilleure précision mais allongent le temps de calcul.

Types de données : single | double

beta — Paramètre de forme de la fenêtre de Kaiser

5 (par défaut) | scalaire réel positif

Paramètre de forme de la fenêtre de Kaiser, défini par un scalaire réel positif. L’augmentation de beta élargit le lobe principal de la fenêtre utilisée pour créer le filtre antialiasing et diminue l’amplitude des lobes secondaires.

Types de données : single | double

b — Coefficients du filtre FIR

vecteur

Coefficients du filtre FIR, définis par un vecteur. Par défaut, resample crée le filtre en utilisant firls avec une fenêtre de Kaiser. Pour compenser le retard, resample suppose que b est de longueur impaire et à phase linéaire. Pour plus d’informations, veuillez consulter Filtre passe-bas antialiasing.

Types de données : single | double

xTT — Timetable en entrée

timetable

Timetable en entrée avec au moins deux lignes, définie par un objet timetable. Chaque variable de xTT est traitée comme un signal indépendant. Si une variable de la timetable est un tableau ND, resample s’applique le long de la première dimension.

Remarque

• RowTimes doit être un vecteur de type duration ou un objet datetime avec des valeurs uniques et finies. Les valeurs temporelles non finies sont traitées comme des données manquantes et ignorées.

• Si aucun ordre de tri n’est indiqué, resample trie RowTimes dans l’ordre croissant.

Pour plus d’informations, veuillez consulter timetable.

tx — Instants temporels

vecteur réel non négatif | tableau datetime

Instants temporels, définis par un vecteur réel non négatif ou un tableau datetime. tx doit augmenter de manière monotone mais il n’est pas nécessaire que les valeurs soient espacées uniformément. tx peut contenir des valeurs NaN ou NaT. Ces valeurs sont traitées comme des données manquantes et exclues du rééchantillonnage. tx est valide uniquement pour l’entrée x.

Types de données : single | double | datetime

fs — Fréquence d'échantillonnage

scalaire positif

Fréquence d’échantillonnage, définie par un scalaire positif. La fréquence d’échantillonnage est le nombre d’échantillons par unité de temps. Si l’unité de temps est la seconde, la fréquence d’échantillonnage est exprimée en Hz.

Types de données : single | double

method — Méthode d’interpolation

"linear" (par défaut) | "pchip" | "spline"

Méthode d’interpolation, définie par "linear", "pchip" ou "spline" :

• "linear" : interpolation linéaire.

• "pchip" : interpolation cubique par morceaux préservant la forme.

• "spline" : interpolation par spline avec des conditions de bord « not-a-knot ».

Pour plus d’informations, veuillez consulter la page de référence de interp1.

Remarque

Si x ne varie pas lentement, envisagez d’utiliser interp1 avec la méthode d’interpolation "pchip".

dim — Dimension le long de laquelle appliquer la fonction

scalaire entier positif

Dimension le long de laquelle appliquer la fonction, définie par un scalaire entier positif. Si dim n’est pas spécifié, resample s’applique le long de la première dimension de tableau dont la taille est supérieure à 1. Si l’entrée est une timetable, dim doit être égale à 1.

Types de données : single | double

Arguments de sortie

y — Signal rééchantillonné

vecteur | matrice | tableau ND

Signal rééchantillonné, renvoyé sous la forme d’un vecteur, d’une matrice ou d’un tableau ND. Si x a la longueur N le long de la dimension dim et que vous spécifiez p et q, y a la longueur ⌈N × p/q⌉ le long de dim.

b — Coefficients du filtre FIR

vecteur

Coefficients du filtre FIR, renvoyés sous la forme d’un vecteur.

ty — Instants en sortie

vecteur réel non négatif

Instants en sortie, renvoyés sous la forme d’un vecteur réel non négatif. ty s’applique uniquement pour l’entrée x.

yTT — Timetable rééchantillonnée

timetable

Timetable rééchantillonnée, renvoyée sous la forme d’un objet timetable.

En savoir plus

Filtre passe-bas antialiasing

Pour rééchantillonner un signal par un facteur rationnel p/q, resample appelle upfirdn qui sur le plan conceptuel effectue les actions suivantes :

1. Insérer des zéros pour suréchantillonner le signal par un facteur p.

2. Appliquer un filtre antialiasing FIR au signal suréchantillonné.

3. Ignorer des échantillons pour sous-échantillonner le signal filtré par q.

Le filtre antialiasing idéal a la fréquence de coupure normalisée f_c = π/max(p,q) rad/échantillon et le gain p. Pour approximer le filtre antialiasing, resample utilise la méthode de la fenêtre de Kaiser.

• L’ordre du filtre est 2 × n × max(p,q). La valeur par défaut de n est 10.

• La fenêtre de Kaiser a un paramètre de forme beta qui contrôle le compromis entre la largeur de transition et l’atténuation dans la bande coupée. La valeur par défaut de beta est 5.

• Les coefficients de filtre sont normalisés pour tenir compte du gain de traitement de la fenêtre.

À titre d’exemple, créez un filtre antialiasing pour rééchantillonner un signal aux 3/2 de sa fréquence d’échantillonnage d’origine :

p = 3;
q = 2;
maxpq = max(p,q);

fc = 1/maxpq;
n = 10;
order = 2*n*maxpq;
beta = 5;

b = fir1(order,fc,kaiser(order+1,beta));
b = p*b/sum(b);

Pour plus d’informations, veuillez consulter Resample Uniformly Sampled Signals.

Conseils

• Utilisez la fonction isregular pour déterminer si une timetable est uniformément échantillonnée.

Algorithmes

resample crée un filtre FIR avec firls, normalise le résultat pour tenir compte du gain de traitement de la fenêtre puis modifie la fréquence d’échantillonnage avec upfirdn.

Capacités étendues

Génération de code C/C++

Générez du code C et C++ avec MATLAB® Coder™.

Notes d’usage et limitations :

• La fonction resample ne supporte pas les entrées timetable pour la génération de code.

• Pour générer du code optimisé qui utilise des intrinsèques SIMD et s’exécute sur les processeurs ARM^® Cortex^®-A 32/64 bits, vous devez installer Embedded Coder^® Support Package for AMD SoC Devices. Le Support Package pour la plateforme Xilinx^® Zynq^® comprend des chaînes d’outils de compilation croisée pour ARM et permet le déploiement sur des processeurs ARM Cortex-A. MATLAB Support Package for Raspberry Pi^® Hardware permet de déployer directement du code optimisé sur des dispositifs ARM. Vous trouverez un exemple dans Generate Optimized Code on Raspberry Pi Target. (depuis R2022b)

• Pour les architectures ARM, la fonction resample ne supporte pas les entrées simple précision.

Génération de code GPU

Générez du code CUDA® pour les GPU NVIDIA® avec GPU Coder™.

Notes d'usage et limitations :

• Les entrées timetable ne sont pas supportées pour la génération de code.

GPU Arrays

Accélérez le code en exécutant les calculs sur une unité de traitement graphique (GPU) avec Parallel Computing Toolbox™.

La fonction resample supporte les GPU arrays en entrée avec les notes d’usage et limitations suivantes :

• La méthode d’interpolation "pchip" n’est pas supportée.

• Les timetables en entrée contenant un gpuArray ne sont pas supportées.

Pour plus d’informations, veuillez consulter Exécuter les fonctions MATLAB sur un GPU (Parallel Computing Toolbox).

Historique des versions

Introduit avant R2006a

R2024a: Utiliser des tableaux datetime pour la génération de code C/C++

La fonction resample supporte les tableaux datetime pour la génération de code. Vous devez disposer de MATLAB Coder™ pour utiliser cette fonctionnalité.

R2023a: Utiliser des données simple précision

La fonction resample supporte les entrées simple précision.

R2020b: Rééchantillonner des tableaux multidimensionnels

La fonction resample dispose d’un argument dim permettant de spécifier la dimension le long de laquelle elle doit s’appliquer. Si vous ne spécifiez pas l’argument dim, la fonction resample s’applique le long de la première dimension de tableau dont la taille est supérieure à 1. La sortie a le même nombre de dimensions que l’entrée.

Voir aussi

decimate | downsample | fillgaps | firls | interp | interp1 | intfilt | kaiser | spline | upfirdn | upsample

Rubriques

• Resample Uniformly Sampled Signals
• Resample Nonuniformly Sampled Signals
• Reconstruct Missing Data
• Reconstruct a Signal from Irregularly Sampled Data