Gauss bulanıklığı , görüntüleri düzgün bir şekilde bulanıklaştırmak için kullanılan bir yöntemdir. Bir görüntünün pikselleriyle birleştirilerek kullanılacak bir matris oluşturmayı içerir. Bu meydan okumada, göreviniz Gauss bulanıklığında kullanılan matrisi oluşturmaktır. Bulanıklaştırma yarıçapı olacak bir r girişi ve boyutları (2 r + 1 × 2 r + 1) olan bir matris oluşturmak için standart sapma olacak bir σ girişi alacaksınız . Bu matristeki her değer , merkezden her yöne olan mutlak mesafesine bağlı olan bir ( x , y ) değerine sahip olacak ve formülün bulunduğu yerde G ( x , y ) hesaplamak için kullanılacaktır.G, bir

Örneğin, r = 2 ise, 5 x 5 matris oluşturmak istiyoruz. İlk olarak, ( x , y ) değerlerinin matrisi

(2, 2) (1, 2) (0, 2) (1, 2) (2, 2)
(2, 1) (1, 1) (0, 1) (1, 1) (2, 1)
(2, 0) (1, 0) (0, 0) (1, 0) (2, 0)
(2, 1) (1, 1) (0, 1) (1, 1) (2, 1)
(2, 2) (1, 2) (0, 2) (1, 2) (2, 2)

Sonra σ = 1.5 olsun ve her birine G uygulayın ( x , y )

0.0119552 0.0232856 0.0290802 0.0232856 0.0119552
0.0232856 0.0453542 0.0566406 0.0453542 0.0232856
0.0290802 0.0566406 0.0707355 0.0566406 0.0290802
0.0232856 0.0453542 0.0566406 0.0453542 0.0232856
0.0119552 0.0232856 0.0290802 0.0232856 0.0119552

Normalde görüntü bulanıklığında, bu matris, o matristeki tüm değerlerin toplamı alınarak ve buna bölünerek normalleştirilir. Bu zorluk için, bu gerekli değildir ve formül tarafından hesaplanan ham değerler çıktının ne olması gerektiğidir.

kurallar

• Bu kod golf yani kısa kod kazanır.
• R girişi negatif olmayan bir tamsayı olacak ve σ pozitif bir gerçek sayı olacaktır.
• Çıktı bir matrisi temsil etmelidir. 2d dizisi, 2d dizisini temsil eden bir dize veya benzer bir şey olarak biçimlendirilebilir.
• Kayan nokta yanlışlıkları size karşı sayılmaz.

Test Durumları

(r, σ) = (0, 0.25)
2.54648

(1, 7)
0.00318244 0.00321509 0.00318244
0.00321509 0.00324806 0.00321509
0.00318244 0.00321509 0.00318244

(3, 2.5)
0.00603332 0.00900065 0.0114421  0.012395 0.0114421 0.00900065 0.00603332
0.00900065  0.0134274 0.0170696 0.0184912 0.0170696  0.0134274 0.00900065
 0.0114421  0.0170696 0.0216997  0.023507 0.0216997  0.0170696  0.0114421
  0.012395  0.0184912  0.023507 0.0254648  0.023507  0.0184912   0.012395
 0.0114421  0.0170696 0.0216997  0.023507 0.0216997  0.0170696  0.0114421
0.00900065  0.0134274 0.0170696 0.0184912 0.0170696  0.0134274 0.00900065
0.00603332 0.00900065 0.0114421  0.012395 0.0114421 0.00900065 0.00603332

(4, 3.33)
0.00339074 0.00464913 0.00582484 0.00666854 0.00697611 0.00666854 0.00582484 0.00464913 0.00339074
0.00464913 0.00637454 0.00798657  0.0091434 0.00956511  0.0091434 0.00798657 0.00637454 0.00464913
0.00582484 0.00798657  0.0100063  0.0114556   0.011984  0.0114556  0.0100063 0.00798657 0.00582484
0.00666854  0.0091434  0.0114556   0.013115  0.0137198   0.013115  0.0114556  0.0091434 0.00666854
0.00697611 0.00956511   0.011984  0.0137198  0.0143526  0.0137198   0.011984 0.00956511 0.00697611
0.00666854  0.0091434  0.0114556   0.013115  0.0137198   0.013115  0.0114556  0.0091434 0.00666854
0.00582484 0.00798657  0.0100063  0.0114556   0.011984  0.0114556  0.0100063 0.00798657 0.00582484
0.00464913 0.00637454 0.00798657  0.0091434 0.00956511  0.0091434 0.00798657 0.00637454 0.00464913
0.00339074 0.00464913 0.00582484 0.00666854 0.00697611 0.00666854 0.00582484 0.00464913 0.00339074

Mathematica, 60 54 50 bayt

@GregMartin'e 4 bayt için teşekkürler!

Array[s=2#2^2;E^(-{##}.{##}/s)/π/s&,1+2{#,#},-#]&

R ve sigma'yı girdi olarak alır, matrisi (tam sayılar) döndürür.

Dahili sürüm (58 bayt)

GaussianMatrix[{##},Standardized->1<0,Method->"Gaussian"]&

Tabii ki, Mathematica'nın bunun için yerleşik bir yeri var, ama çok uzun.

MATL , 20 bayt

_G&:U&+iUE/_Ze5MYP*/

Çevrimiçi deneyin!

açıklama

_     % Take input r implicitly. Negate
G     % Push r again
&:    % Binary range: [-r -r+1 ... r]
U     % Square, elementwise
&+    % Matrix of all pairwise additions
i     % Take input σ
U     % Square
E     % Multiply by 2. Gives 2σ^2
/     % Divide
_     % Negate
Ze    % Exponential
5M    % Push 2σ^2 again
YP    % Push pi
*     % Multiply
/     % Divide. Display implicitly

Oktav, 45 bayt

@(r,s)exp((x=-(-r:r).^2/2/s^2)+x')/2/s^2/pi

Oktav, 49 bayt

@(r,q)1./((Q=2*q^2)*pi*e.^(((x=(-r:r).^2)+x')/Q))

Çevrimiçi Deneyin!

Python, 88 bayt

lambda r,s:[[.5/3.14/s/s/2.72**((x*x+y*y)/2/s/s)for x in range(-r,r+1)]for y in range(-r,r+1)]

Her birini 1 bayt maliyetle 3.14 ve 2.72 kodlayabileceğiniz kuralı kullanır.

Perl 6 , 71 bayt

->\r,\σ{map ->\y{map ->\x{exp((x*x+y*y)/-2/σ/σ)/2/pi/σ/σ},-r..r},-r..r}

Teknik olarak kodlanmış ve bir dosyaya kaydedilmişse bu 71 bayttan fazla olabilir, ancak gerçek bir Yunan sigma ile "sigma" girişi adlandırma direnemedim. İstenirse herhangi bir düz ASCII harfi olarak yeniden adlandırılabilir.

SAS Makro Dili, 296 bayt

Muhtemelen bunu yapmanın çok daha etkili bir yolu ama işe yarıyor :)

Bu kod, ortaya çıkan veri kümesini yazdırır.

%macro G(r,s);%let l=%eval(2*&r+1);%let pi=%sysfunc(constant(pi));data w;array a[*] t1-t&l;%do i=-&r %to &r;%do j=-&r %to &r;%let t=%sysfunc(sum(&j,&r,1));a[&t]=%sysevalf(1/(2*&pi*&s**2)*%sysfunc(exp(-(%sysfunc(abs(&j))**2+%sysfunc(abs(&i))**2)/(2*&s**2))));%end;output;%end;proc print;run;%mend;

Haskell, 59 bayt

r#s|i<-[-r..r]=[[exp(-(x*x+y*y)/2/s/s)/2/pi/s/s|x<-i]|y<-i]

Kullanım örneği:

1#7

[[3.1824449424224664e-3,3.2150851187016326e-3,3.1824449424224664e-3],
 [3.2150851187016326e-3,3.2480600630999047e-3,3.2150851187016326e-3],
 [3.1824449424224664e-3,3.2150851187016326e-3,3.1824449424224664e-3]]

Python 2.7, 167 bayt

Çok basit bir çözüm:

from __future__ import division;from math import*;r,s=input();s*=2*s;R=range(-r,r+1);print"\n".join("\t".join(str(pow(e,-(x*x+y*y)/s)/(pi*s))[:9]for x in R)for y in R)

Burada deneyin !

Ungolfed:

from __future__ import division
from math import *
r,s = input()                         # Take input
s *= 2*s                              # Set s = 2*s^2; simplifies the expression
R = range(-r,r+1)                     # Range object; used twice

                                   # G(x,y)             # Stripped
print "\n".join("\t".join(str(pow(e,-(x*x + y*y)/s)/(pi*s))[:9] for x in R) for y in R)