Qu'est-ce que l'algorithme utilisé pour interpoler dans Matlab imresize fonction?

Je suis en utilisant le logiciel Matlab/Octave imresize() fonction qui ré-échantillonne un tableau 2D. Je veux comprendre comment un algorithme d'interpolation utilisé dans imresize œuvres.

(Je suis en utilisant l'octave sur windows)

par exemple

A =  1 2 
     3 4

est un tableau 2D. Puis-je utiliser la commande

b=imresize(a,2,'linear');

essentiellement à un suréchantillonnage de lignes et de colonnes par 2.

La sortie est

1.0000   1.3333   1.6667   2.0000
1.6667   2.0000   2.3333   2.6667
2.3333   2.6667   3.0000   3.3333
3.0000   3.3333   3.6667   4.0000

Je ne comprends pas comment cette interpolation linéaire est de travail. Il est dit d'utiliser biinterpolation linéaire, mais comment est-il pavé de données à des limites et comment elle fait pour obtenir le résultat qu'il obtient?

Deuxième exemple:
Pour

A = 

1   2   3   4
5   6   7   8
0   1   2   3
1   2   3   4

comment imresize(a,1.5,'linear') donne la sortie suivante?

1.00000   1.60000   2.20000   2.80000   3.40000   4.00000
3.40000   4.00000   4.60000   5.20000   5.80000   6.40000
4.00000   4.60000   5.20000   5.80000   6.40000   7.00000
1.00000   1.60000   2.20000   2.80000   3.40000   4.00000
0.40000   1.00000   1.60000   2.20000   2.80000   3.40000
1.00000   1.60000   2.20000   2.80000   3.40000   4.00000

OriginalL'auteur goldenmean | 2011-06-22

0

Comme vous pouvez le voir, dans votre exemple, chaque point de coin est l'un des originaux de vos valeurs d'entrée.

Les valeurs intermédiaires sont dérivées par interpolation linéaire dans chaque direction. Ainsi, par exemple, pour calculer b(3,2):
- b(1,2) est de 1/3 de la voie entre b(1,1) et b(1,4). Donc:
```
b(1,2) = (1/3)*b(1,4) + (2/3)*b(1,1)
```
- b(4,2) est de 1/3 de la voie entre b(4,1) et b(4,4). Donc:
```
b(4,2) = (1/3)*b(4,4) + (2/3)*b(4,1)
```
- b(3,2) est de 2/3 de la voie entre b(1,2) et b(4,2). Donc:
```
b(3,2) = (2/3)*b(4,2) + (1/3)*b(1,2)
```
Merci. - Je l'obtenir. Je suppose, Le calcul des coefficients de pondération pour un autre facteur d'échelle prendrait les valeurs appropriées. c'est à dire Pour mon exemple, le poids de 0,33,0.66 depuis 2 donné des échantillons devaient être interpolées à 4 échantillons total, si c'était 2 échantillons pour être interpolées total N échantillons, poids devrait être de 1/(N-1), 2/(N-1) n'est-ce pas?
Édité OP pour ajouter un deuxième exemple qui ré-échantillonne par une fraction de facteur d'échelle,. Dans ce cas, ne sait pas comment il comptued de ses sorties. U peut pls. vérifiez ci-dessus.
Toutes les entrées sur le deuxième exemple que j'ai ajouté à l'OP?
également en que vous avez édité la réponse b(4,2) et b(3,2) calculs look incorrect (poids échangé) pour moi. N'est-ce pas?
Oui, bon coin, j'ai eu ce dernier calcul de l'arrière vers l'avant!

OriginalL'auteur Oliver Charlesworth
2

Le code suivant montre comment effectuer la méthode d'interpolation bilinéaire à l'aide de INTERP2:
```
A = [1 2; 3 4];
SCALE = 2;

xi = linspace(1,size(A,2),SCALE*size(A,2));  %# interpolated horizontal positions
yi = linspace(1,size(A,1),SCALE*size(A,1));  %# interpolated vertical positions
[X Y] = meshgrid(1:size(A,2),1:size(A,1));   %# pixels X-/Y-coords
[XI YI] = meshgrid(xi,yi);                   %# interpolated pixels X-/Y-coords
B = interp2(X,Y,A, XI,YI, '*linear');        %# interp values at these positions
```
le résultat est d'accord avec votre Octave code de sortie:
```
B =
            1       1.3333       1.6667            2
       1.6667            2       2.3333       2.6667
       2.3333       2.6667            3       3.3333
            3       3.3333       3.6667            4
```
Je dois mentionner que j'obtiens des résultats différents entre MATLAB et Octave IMRESIZE de sortie. Par exemple, c'est ce que j'obtiens quand je exécutez les opérations suivantes dans MATLAB sur la matrice A=[1 2; 3 4]:
```
>> B = imresize([1 2; 3 4], 2, 'bilinear')
B =
            1         1.25         1.75            2
          1.5         1.75         2.25          2.5
          2.5         2.75         3.25          3.5
            3         3.25         3.75            4
```
qui suggère que MATLAB mise en œuvre est en train de faire quelque chose de plus... Malheureusement il n'est pas facile à lire, le IMRESIZE code source, surtout depuis à un certain point, il appelle une MEX-fonction compilée (avec aucune forme de code source disponible).

Comme une note de côté, il semble y avoir une version plus ancienne de cette fonction ainsi: IMRESIZE_OLD (purement mises en œuvre dans le m-code). De ce que j'ai pu comprendre, il effectue une sorte de transformation affine sur l'image. Peut-être que quelqu'un de plus familier avec la technique pourrait jeter quelque lumière sur le sujet...

Ma conjecture est que Matlab exécute un filtre Gaussien sur les données d'entrée avant de suréchantillonnage. Octave ne pas le faire(Bien qu'octave mentionne que dans l'aide imresize, mais ne pas le faire, quand j'ai vérifié.
qui pourrait expliquer la différence. En tout cas, et pour répondre à votre question initiale, l'article de Wikipedia je lien qui explique bien la méthode d'interpolation bilinéaire processus avec un exemple..
J'ai pris un second regard sur le IMRESIZE fonction, merci de lire ma réponse à cette autre question: stackoverflow.com/questions/7758078/...

OriginalL'auteur Amro

Vous devez vous connecter pour publier un commentaire.