def twirl(self, imagen, valor=0):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
filas, columnas = imagen.shape
width = float(filas)
height = float(columnas)
resultado = cp.copy(imagen)
for i in range(int(width)):
for j in range(int(height)):
x = (j / height) - 0.5
y = (i / width) - 0.5
angulo = mt.atan2(y, x)
radio = mt.sqrt((x * x) + (y * y))
angulo += radio * (valor / 10.0)
xr = ((radio * mt.sin(angulo)) + 0.5) * width
yr = ((radio * mt.cos(angulo)) + 0.5) * height
k = min(width - 1, max(0.0, xr))
m = min(height - 1, max(0.0, yr))
imagen[i, j] = resultado[int(k), int(m)]
imagen_final = imagen
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def or_(self, imagen, imagen_dos=None, valor=0, limitar=True):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
if imagen_dos is None:
for i in range(len(imagen)):
for j in range(len(imagen[i])):
resultado = imagen[i, j] | valor
if limitar:
resultado = hca.limitar(resultado)
imagen[i, j] = resultado
imagen_final = imagen
else:
imagen = hcv.normalizar_imagen(imagen)
imagen_dos = hcv.normalizar_imagen(imagen_dos)
for i in range(len(imagen)):
for j in range(len(imagen[i])):
resultado = imagen[i, j] | imagen_dos[i, j]
if limitar:
resultado = hca.limitar(resultado)
imagen[i, j] = resultado
imagen_final = imagen
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def conservative(self, imagen, valor=0, tamanio=0):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
imagen_final = cv.bilateralFilter(imagen, tamanio, valor, valor)
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def gaussian(self, imagen, valor=0):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
imagen_final = cv.GaussianBlur(imagen, (valor, valor), 0)
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def histogram_equalization(self, imagen):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
imagen_final = cv.equalizeHist(imagen)
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def selective_search(self, imagen):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
imagen_final = []
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(
nombre_imagen, True), hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def shear(self, imagen, value=0):
nombre_imagen = hnm.generar_nombre_imagen()
"""
Inicio del algoritmo
"""
imagen_shear = tf.AffineTransform(shear=value)
imagen_final = tf.warp(imagen, inverse_map=imagen_shear)
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
255 * imagen_final)
return hnm.ontener_nombre_archivo(nombre_imagen)
def thresholding(self, imagen, valor=127, tipo=0):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
ret, imagen_final = cv.threshold(imagen, valor, hca.MAX_VALUE, tipo)
print(ret)
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def translate(self, imagen, valor_x=0, valor_y=0):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
filas, columnas = imagen.shape
M = np.matrix([[1, 0, valor_x], [0, 1, valor_y]], np.float)
imagen_final = cv.warpAffine(imagen, M, (columnas, filas))
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def mean(self, imagen, valor=0):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
valor_cuadrado = mt.pow(valor, 2)
kernel = np.ones((valor, valor), np.float) / valor_cuadrado
imagen_final = cv.filter2D(imagen, -1, kernel)
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def rotate(self, imagen, grados=0):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
filas, columnas = imagen.shape
M = cv.getRotationMatrix2D((columnas / 2, filas / 2), grados, 1)
imagen_final = cv.warpAffine(imagen, M, (columnas, filas))
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def sift(self, imagen):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
sift = cv.SIFT()
gray = cv.cvtColor(imagen, cv.COLOR_BGR2GRAY)
kp = sift.detect(gray, None)
imagen_final = cv.drawKeypoints(gray, kp)
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(
nombre_imagen, True), hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def scale(self, imagen, valor=0):
nombre_imagen = hnm.generar_nombre_imagen()
"""
Inicio del algoritmo
"""
imagen_final = cv.resize(imagen,
None,
fx=valor,
fy=valor,
interpolation=cv.INTER_CUBIC)
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
imagen_final)
return hnm.ontener_nombre_archivo(nombre_imagen)
def hog(self, imagen, orientacion=0):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
fd, imagen_final = hog(imagen, orientations=orientacion, pixels_per_cell=(16, 16),
cells_per_block=(1, 1), visualise=True, block_norm='L2-Hys')
print(fd)
imagen_final = exposure.rescale_intensity(imagen_final, in_range=(0, 10))
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(
nombre_imagen, True), hnp.unir_imagen(imagen_inicial, 255 * imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def invert(self, imagen, limitar=True):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
for i in range(len(imagen)):
for j in range(len(imagen[i])):
resultado = 255 - imagen[i, j]
if limitar:
resultado = hca.limitar(resultado)
imagen[i, j] = resultado
imagen_final = imagen
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def exponential(self, imagen, limitar=True):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
c = hca.MAX_VALUE / (mt.log(1 + imagen.max()))
for i in range(len(imagen)):
for j in range(len(imagen[i])):
resultado = c * (mt.pow(1.01, imagen[i, j]) - 1)
if limitar:
resultado = hca.limitar(resultado)
imagen[i, j] = resultado
imagen_final = imagen
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def raise_to_power(self, imagen, constante=0, limitar=True):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
r = float(0.5)
for i in range(len(imagen)):
for j in range(len(imagen[i])):
resultado = constante * (mt.pow(imagen[i, j], r))
if limitar:
resultado = hca.limitar(resultado)
imagen[i, j] = resultado
imagen_final = imagen
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def blending(self, imagen, imagen_dos, valor=0, limitar=True):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
imagen = hcv.normalizar_imagen(imagen)
imagen_dos = hcv.normalizar_imagen(imagen_dos)
for i in range(len(imagen)):
for j in range(len(imagen[i])):
resultado = (valor * imagen[i, j]) + ((1 - valor) * imagen_dos[i, j])
if limitar:
resultado = hca.limitar(resultado)
imagen[i, j] = resultado
imagen_final = imagen
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(
nombre_imagen, True), hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
def contrast_stretching(self,
imagen,
valor_minimo=0,
valor_maximo=255,
limitar=True):
nombre_imagen = hnm.generar_nombre_imagen()
imagen_inicial = cp.copy(imagen)
"""
Inicio del algoritmo
"""
for i in range(len(imagen)):
for j in range(len(imagen[i])):
resultado = ((imagen[i, j] - valor_minimo) /
(valor_maximo - valor_minimo)) * hca.MAX_VALUE
if limitar:
resultado = hca.limitar(resultado)
imagen[i, j] = resultado
imagen_final = imagen
"""
Fin del algoritmo
"""
hcv.guardar_imagen(hnm.ontener_nombre_archivo(nombre_imagen, True),
hnp.unir_imagen(imagen_inicial, imagen_final))
return hnm.ontener_nombre_archivo(nombre_imagen)
