def eqHist (Image):
### Imports
import numpy as np
import matplotlib.pyplot as plt
import math as m
import navFunc as nf
A = Image
size = nf.structtype()
size.A = nf.structtype()
size.A.lin, size.A.col = A.shape
#################### Equalize Histogram
## Pre-sets:
newA = np.zeros((size.A.lin, size.A.col))
for j in range((0), size.A.lin):
for k in range((0), size.A.col):
newA[j, k] = np.ceil(255*(
(A[j, k] - A.min()) /
(A.max() - A.min())))
newImage = np.uint8(newA)
print('################################')
print('Process finished')
print('Histogram has been equalized')
print('################################')
return newImage
def filterLaplace(Filter):
### Imports
import numpy as np
import matplotlib.pyplot as plt
import math as m
import navFunc as nf
# Load image into numpy matrix
A = Filter.img
size = nf.structtype()
size.A = nf.structtype()
size.A.lin, size.A.col = A.shape
#################### Laplace filter
## Pre-set steps:
Filter.kernel = np.ones((Filter.kernelSize, Filter.kernelSize))
Filter.kernel[int(Filter.kernelSize / 2),
int(Filter.kernelSize /
2)] = -1 * (np.sum(Filter.kernel) - 1)
#################
central = m.floor((Filter.kernelSize / 2))
C = np.zeros((size.A.lin + central * 2, size.A.col + central * 2))
C[(0 + central):(size.A.lin + central),
(0 + central):(size.A.col + central)] = A
#################
## Run the kernel over the matrix (similar to convolution):
#################
soma = 0
D = np.zeros(A.shape)
for j in range((0), size.A.lin):
for k in range((0), size.A.col):
# Run kernel in one matrix's elements
for kl in range(0, Filter.kernelSize):
for kk in range(0, Filter.kernelSize):
# print(C[j + kl, k + kk])
# print(kernel[kl, kk])
# print('Result is: %d ' %(C[j + kl,k + kk] * kernel[kl,kk]))
soma = (C[j + kl, k + kk] * Filter.kernel[kl, kk]) + soma
# print('Pixel has finished')
value = m.ceil((soma / (Filter.kernelSize * Filter.kernelSize)))
soma = 0
D[j, k] = value
# print('LINE has finished')
D = np.uint8(D)
print('################################')
print('Process finished')
print('Filter have been applied')
print('################################')
return D
def filterMedian(Filter):
### Imports
import numpy as np
import matplotlib.pyplot as plt
import math as m
import navFunc as nf
import time
# Load image into numpy matrix
A = Filter.img
size = nf.structtype()
size.A = nf.structtype()
size.A.lin, size.A.col = A.shape
#################### Mean filter
## Pre-set steps:
Filter.kernel = np.ones((Filter.kernelSize, Filter.kernelSize))
#################
central = m.floor((Filter.kernelSize / 2))
C = np.zeros((size.A.lin + central * 2, size.A.col + central * 2))
C[(0 + central):(size.A.lin + central),
(0 + central):(size.A.col + central)] = A
#################
## Run the kernel over the matrix (similar to convolution):
#################
buffer = np.zeros((Filter.kernelSize * Filter.kernelSize))
D = np.zeros(A.shape)
# for each line:
for j in range((0), size.A.lin):
# for each collumn:
for k in range((0), size.A.col):
# Run kernel in one matrix's elements
## for each line:
for kl in range(0, Filter.kernelSize):
## for each collumn:
for kk in range(0, Filter.kernelSize):
buffer[(Filter.kernelSize * kl + kk)] = (C[j + kl, k + kk])
buffer = np.sort(buffer)
value = buffer[int(np.floor((Filter.kernelSize**2) / 2))]
D[j, k] = value
# print('LINE has finished')
D = np.uint8(D)
print('################################')
print('Process finished')
print('Filter have been applied')
print('################################')
return D
def filterGaussian(Filter):
### Imports
import numpy as np
import matplotlib.pyplot as plt
import math as m
import navFunc as nf
# Load image into numpy matrix
A = Filter.img
size = nf.structtype()
size.A = nf.structtype()
size.A.lin, size.A.col = A.shape
#################### Gaussian filter
## Pre-set steps:
### Generate two kernersl (horizontal and vertical)
#
Filter.kernel = gaussianKernel(Filter.kernelSize, Filter.kernelSize)
#################
central = m.floor((Filter.kernelSize / 2))
C = np.zeros((size.A.lin + central * 2, size.A.col + central * 2))
C[(0 + central):(size.A.lin + central),
(0 + central):(size.A.col + central)] = A
#################
## Run the kernel over the matrix (similar to convolution):
#################
soma = 0
D = np.zeros(A.shape)
for j in range((0), size.A.lin):
for k in range((0), size.A.col):
# Run kernel in one matrix's elements
for kl in range(0, Filter.kernelSize):
for kk in range(0, Filter.kernelSize):
soma = (C[j + kl, k + kk] * Filter.kernel[kl, kk]) + soma
#value = m.ceil((soma / (Filter.kernelSize * Filter.kernelSize)))
value = m.ceil((soma))
soma = 0
D[j, k] = value
D = np.uint8(D)
print('################################')
print('Process finished')
print('Filter have been applied')
print('################################')
return D
def limiar (Filter):
### Imports
import numpy as np
import matplotlib.pyplot as plt
import math as m
import navFunc as nf
# Load image into numpy matrix
A = Filter.img
size = nf.structtype()
size.A = nf.structtype()
size.A.lin, size.A.col = A.shape
#################### Limiar
Tmin = np.min(A)
Tmax = np.max(A)
D = np.zeros(A.shape)
for j in range((0), size.A.lin):
for k in range((0), size.A.col):
if A[j,k] > Filter.limiar:
D[j, k] = Tmax
else:
D[j, k] = Tmin
D = np.uint8(D)
print('################################')
print('Process finished')
print('Limiar has been applied')
print('################################')
return D
def calcHist (Image):
### Imports
import numpy as np
import matplotlib.pyplot as plt
import math as m
import navFunc as nf
# Load image into numpy matrix
A = Image
size = nf.structtype()
size.A = nf.structtype()
size.A.lin, size.A.col = A.shape
#################### Calculate Histogram
## Pre-setes:
if A.dtype == 'uint8':
#buffer = np.linspace(0, 255, num = 2**8)
#buffer = np.zeros((A.max()+1) - (A.min()))
buffer = np.zeros((256))
## Read the intire matrix element-by-element:
for j in range((0), size.A.lin):
for k in range((0), size.A.col):
buffer[(A[j, k])] += 1
print('################################')
print('Process finished')
print('Histogram has been calculated')
print('################################')
return 100*buffer/(size.A.lin*size.A.col)
##########################################################################################
# Load necessary(or not) modules
import cv2
import numpy as np
import matplotlib.pyplot as plt
import math as m
import navFunc as nf
from navFunc.cls import cls
##########################################################################################
#### Open imagem:
img = cv2.imread('navar.png', cv2.IMREAD_GRAYSCALE)
##### Pre-sets #######################################################################
# Load image into numpy matrix
Filter = nf.structtype() # Cria variavel do tipo struct (similar ao matlab)
Filter.img = np.array(img)
Filter.imgSize = nf.structtype()
Filter.imgSize.lin, Filter.imgSize.col = Filter.img.shape
#################### Filtro da média
Filter.ftype = 50
# Kernel def:
Filter.kernelSize = 3
numAp = 1
U = np.zeros((numAp, Filter.imgSize.lin, Filter.imgSize.col))
import cv2
import numpy as np
import matplotlib.pyplot as plt
import math as m
import navFunc as nf
img = cv2.imread('../figs/lena_color_256.tif', cv2.IMREAD_GRAYSCALE)
# Cria variavel do tipo struct (similar ao matlab):
Filter = nf.structtype()
Filter.img = np.array(img)
Filter.imgSize = nf.structtype()
Filter.imgSize.lin, Filter.imgSize.col = Filter.img.shape
Hist = nf.calcHist(Filter.img)
#############################################################################################
########## Plot images:
########## Using matplotlib #################
plt.figure(1)
#plt.subplot(121)
plt.imshow(img, 'gray')
plt.title('Imagem Original')
#plt.subplot(122)
plt.figure(2)
plt.stem(Hist)
def filterPrewit(Filter):
### Imports
import numpy as np
import matplotlib.pyplot as plt
import math as m
import navFunc as nf
# Load image into numpy matrix
A = Filter.img
size = nf.structtype()
size.A = nf.structtype()
size.A.lin, size.A.col = A.shape
#################### Prewit filter
## Pre-set steps:
### Generate two kernersl (horizontal and vertical)
Filter.kernel = nf.structtype()
Filter.kernel.horz = np.zeros((Filter.kernelSize, Filter.kernelSize))
Filter.kernel.horz[:, 0] = -1
Filter.kernel.horz[:, (Filter.kernelSize - 1)] = 1
Filter.kernel.vert = np.zeros((Filter.kernelSize, Filter.kernelSize))
Filter.kernel.vert[0, :] = -1
Filter.kernel.vert[(Filter.kernelSize - 1), :] = 1
#################
central = m.floor((Filter.kernelSize / 2))
C = np.zeros((size.A.lin + central * 2, size.A.col + central * 2))
C[(0 + central):(size.A.lin + central),
(0 + central):(size.A.col + central)] = A
#################
## Run the kernel over the matrix (similar to convolution):
#################
somaHorz = 0
somaVert = 0
D = np.zeros(A.shape)
for j in range((0), size.A.lin):
for k in range((0), size.A.col):
# Run kernel in one matrix's elements
for kl in range(0, Filter.kernelSize):
for kk in range(0, Filter.kernelSize):
somaHorz = (C[j + kl, k + kk] *
Filter.kernel.horz[kl, kk]) + somaHorz
somaVert = (C[j + kl, k + kk] *
Filter.kernel.vert[kl, kk]) + somaVert
Ph = m.ceil((somaHorz / (Filter.kernelSize**2)))
Pv = m.ceil((somaVert / (Filter.kernelSize**2)))
somaHorz = 0
somaVert = 0
D[j, k] = np.sqrt(Ph**2 + Pv**2)
# print('LINE has finished')
D = np.uint8(D)
print('################################')
print('Process finished')
print('Filter have been applied')
print('################################')
return D
def multiLimiar(Filter):
### Imports
import numpy as np
import matplotlib.pyplot as plt
import math as m
import navFunc as nf
# Load image into numpy matrix
A = Filter.img
size = nf.structtype()
size.A = nf.structtype()
size.A.lin, size.A.col = A.shape
if Filter.multiLimiar.size == 2:
T2 = Filter.multiLimiar[1]
T1 = Filter.multiLimiar[0]
Gmin = 0
Gmed = 127
Gmax = 255
if Filter.multiLimiar.size == 3:
T3 = Filter.multiLimiar[2]
T2 = Filter.multiLimiar[1]
T1 = Filter.multiLimiar[0]
Gmin = 0
Gmed1 = Filter.multiRange[0]
Gmed2 = Filter.multiRange[1]
Gmax = 255
#################### Limiar
D = np.zeros(A.shape)
for j in range((0), size.A.lin):
for k in range((0), size.A.col):
if Filter.multiLimiar.size == 3:
if A[j, k] > T3:
D[j, k] = Gmax
elif A[j, k] <= T3 and A[j, k] > T2:
D[j, k] = Gmed2
elif A[j, k] <= T2 and A[j, k] > T1:
D[j, k] = Gmed1
elif A[j, k] <= T1:
D[j, k] = Gmin
elif Filter.multiLimiar.size == 2:
if A[j, k] > T2:
D[j, k] = Gmax
elif A[j, k] <= T2 and A[j, k] > T1:
D[j, k] = Gmed
elif A[j, k] <= T1:
D[j, k] = Gmin
D = np.uint8(D)
print('################################')
print('Process finished')
print('Multilimiar have been applied')
print('################################')
return D
