Const e:Double = 2.7182818284590452353602874713526

Function GaussianFunction1Dim:Double(x:Double , radius:Double) 
	
	Return (1 / Sqr(2 * Pi * radius)) * (e ^ ( - 0.5 * ( (x ^ 2) / (radius ^ 2) ) ) ) 
	
EndFunction

Function CalculateKernel:Double[](range:Int, radius:Double)
	
	Local kernel:Double[range], arrayPos:Int = 0
	
	For Local i:Int = - (range / 2) To (range / 2)
		
		kernel[arrayPos] = GaussianFunction1Dim(i, radius)
		arrayPos:+ 1
		
	Next
	
	Return kernel
	
End Function

Function GetKernelSum:Double(kernel:Double[])
	
	Local sum:Double
	
	For Local i:Int = 0 To kernel.length - 1
		
		sum:+ kernel[i]
		
	Next
	
	Return sum
	
End Function

Function ProcessBlurAxis:TPixmap(src:TPixmap, kernel:Double[], sum:Double, axis:Int)
	
	Local srcARGB:Int, srcA:Double, srcR:Double, srcG:Double, srcB:Double
	Local dest:TPixmap = src.copy()
	Local destARGB:Int, destA:Double, destR:Double, destG:Double, destB:Double
	Local halfRange:Int = kernel.length / 2
	Local i:Int	

	For Local y:Int = 0 To src.height - 1
		
		For Local x:Int = 0 To src.width - 1
			
			destA = (src.ReadPixel(x, y) Shr 24) & $FF 
			destR = 0
			destG = 0
			destB = 0
			destARGB = 0
                                    srcARGB = 0
			
			For Local move:Int = - halfRange To halfRange
				
				i = move + halfRange
				
				If axis = 0
					If x + move >= 0 And x + move < dest.width
						srcARGB = src.ReadPixel(x + move, y)
						
					Else If x + move < 0
						srcARGB = src.ReadPixel(dest.width + move, y)
						
					Else If x + move > dest.width - 1
						srcARGB = src.ReadPixel(x - move, y)

					End If
						
					srcR = (srcARGB Shr 16) & $FF
					srcG = (srcARGB Shr 8) & $FF
					srcB = (srcARGB) & $FF
					
					destR:+ (srcR * kernel[i]) / sum
					destG:+ (srcG * kernel[i]) / sum
					destB:+ (srcB * kernel[i]) / sum
					
				Else If axis = 1
				
					If y + move >= 0 And y + move < dest.height
					
						srcARGB = src.ReadPixel(x, y + move)
					
					End If
					
					srcR = (srcARGB Shr 16) & $FF
					srcG = (srcARGB Shr 8) & $FF
					srcB = (srcARGB) & $FF
					
					destR:+ (srcR * kernel[i]) / sum
					destG:+ (srcG * kernel[i]) / sum
					destB:+ (srcB * kernel[i]) / sum	
				
				End If	
				
			Next
				
			If destR > 255 destR = 255
			If destG > 255 destG = 255
			If destB > 255 destB = 255
				
			destARGB = Int(destA) Shl 24 + Int(destR) Shl 16 + Int(destG) Shl 8 + Int(destB)
			dest.WritePixel(x, y, destARGB)
				
	      	Next

	Next
	
	Return dest
	
End Function 

Function Processblur:TPixmap(src:TPixmap, kernel:Double[])
	
	Local dest:TPixmap
	Local sum:Double = GetKernelSum(kernel)
	
	dest = ProcessBlurAxis(src, kernel, sum, 0)
	dest = ProcessBlurAxis(dest, kernel, sum, 1)
	
	Return dest
	
End Function

SuperStrict

Include ""

Global kernel:Double[] = CalculateKernel(7, 3) 'Je höher range(erster Parameter) sowie radius(2.Parameter), desto höher der Effekt

Graphics 800, 600, 0, 60

Global image:TImage
Global pixmap:TPixmap = LoadPixmap("")

pixmap = ProcessBlur(pixmap, kernel)

image = LoadImage(pixmap)

Repeat
	
	Cls
	
		DrawImage image, 0, 0
	
	Flip
	
Until KeyHit(KEY_ESCAPE)