Comment ne du voisin le plus proche d'interpolation de travail dans MATLAB?

Si vous appliquez régulièrement interpolation à l'aide de interp1, il vous donnera le résultat que vous calculée par la main:

>> N = 9;
>> B = interp1(linspace(0,1,numel(A)), A, linspace(0,1,N), 'nearest')
B =
     1     4     4     7     4     4     3     3     6

Il y a quelques temps, je suis allé à travers le code source de IMRESIZE essayer de comprendre comment il fonctionne. Voir ce post pour un résumé. À un certain point, le code fait appel à un privé MEX-fonction (pas de code source disponible), mais les commentaires sont assez pour comprendre la mise en œuvre.

Pour ce que ça vaut, il y a une aussi une fonction imresize_old qui fournit un ancien de la mise en œuvre de imresize (utilisé dans la version R2006b et antérieures). Il a donné encore un autre résultat différent:

>> B = imresize(A, [1 N], 'nearest')
B =
     1     4     4     7     4     4     3     6     6

>> B = imresize_old(A, [1 N], 'nearest')
B =
     1     4     4     7     7     4     3     6     6

Ce qui est plus il a été observé précédemment que la mise en œuvre entre MATLAB et Octave diffèrent aussi dans certains cas.

---

EDIT:

Comme vous l'avez remarqué, dans certains cas, vous devez être attentif à virgule flottante limitations lorsque vous travaillez avec interp1. Nous avons donc pu faire l'interpolation en choisissant x-numéros entre [0,1] gamme, ou une plus grande stabilité de gamme comme [1,numel(A)]. En raison des erreurs d'arrondi dans les cas limites, cela pourrait donner des résultats différents.

Par exemple de comparer les deux codes ci-dessous:

% interpolation in [0,1]
N = 11;
y = [1 4 7 4 3 6];
x = linspace(0,1,numel(y));
xi = linspace(0,1,N);
yi = interp1(x, y, xi, 'nearest');

% print numbers with extended precision
fprintf('%.17f %g\n',[x;y])
fprintf('%.17f %g\n',[xi;yi])

contre:

% interpolation in [1,k]
N = 11;
y = [1 4 7 4 3 6];
x = 1:numel(y);
xi = linspace(1,numel(y),N);
yi = interp1(x, y, xi, 'nearest');

% print numbers with extended precision
fprintf('%.17f %g\n',[x;y])
fprintf('%.17f %g\n',[xi;yi])

Voici la sortie joliment mis en forme:

--------------------------------------------------------
       [0,1] RANGE        |         [1,k] RANGE
--------------------------------------------------------     
        xi           yi   |            xi            yi
--------------------------------------------------------
0.00000000000000000  1    |     1.00000000000000000  1 |
0.20000000000000001  4    |     2.00000000000000000  4 |
0.40000000000000002  7    |     3.00000000000000000  7 |
0.59999999999999998  4    |     4.00000000000000000  4 |  INPUT
0.80000000000000004  3    |     5.00000000000000000  3 |
1.00000000000000000  6    |     6.00000000000000000  6 |
--------------------------------------------------------
0.00000000000000000  1    |     1.00000000000000000  1 |
0.10000000000000001  4    |     1.50000000000000000  4 |
0.20000000000000001  4    |     2.00000000000000000  4 |
0.29999999999999999  4    |     2.50000000000000000  7 |
0.40000000000000002  7    |     3.00000000000000000  7 |
0.50000000000000000  4    |     3.50000000000000000  4 | OUTPUT
0.59999999999999998  4    |     4.00000000000000000  4 |
0.69999999999999996  4    |     4.50000000000000000  3 |
0.80000000000000004  3    |     5.00000000000000000  3 |
0.90000000000000002  6    |     5.50000000000000000  6 |
1.00000000000000000  6    |     6.00000000000000000  6 |
--------------------------------------------------------

De sorte que vous pouvez voir que certains numéros ne sont pas exactement représentable en double précision lorsque l'on travaille dans [0,1]. Afin de 0,3, ce qui est supposé être dans le milieu de [0.2, 0.4], s'avère être plus proche de l'extrémité inférieure de 0,2 inférieure à 0,4 en raison de l'erreur d'arrondi. Tandis que de l'autre côté, 2.5 est exactement dans le milieu de [2,3] (tous les chiffres exactement représenté), et est affecté à l'extrémité supérieure de 3 à l'aide du voisin le plus proche.

Aussi être conscient que colon et linspace peut produire différentes sorties parfois:

>> (0:0.1:1)' - linspace(0,1,11)'
ans =
            0
            0
            0
   5.5511e-17
            0
            0
            0
            0
            0
            0
            0

OriginalL'auteur Amro

Je n'ai pas de référence pour le présent, aussi je vous conseille de le tester contre d'autres exemples utilisant imresize mais je peux récupérer Mat;ab valeurs de ce type.

Supposer que A représente y les valeurs et les positions des éléments dans A représentent x valeurs. alors maintenant,

n = length(A);
N = 9;

x = 1:n %//i.e. 1:6

maintenant, nous devons trouver d'interpolation de la position c'est à dire xi points. J'aurais fait comme ceci:

xi = round((1:N)/N)*n

qui donne

xi =

   1   1   2   3   3   4   5   5   6

ce qui résulte en une yi de

yi = A(xi)

yi =

   1   1   4   7   7   4   3   3   6

qui diffère à la fois de vous et Matlab réponses (comment avez-vous le vôtre?)

Alors j'ai essayé:

xi = round(((0:N-1)/N)*n)+1
yi = A(xi)

qui fait juste comme beaucoup de sens et me met à Matlab résultat de

yi =

   1   4   4   7   4   4   3   6   6

Donc je suppose que c'est comment ils le font. Mais je n'ai pas imresize pour tester d'autres cas

OriginalL'auteur Dan