Utilice Python para crear programas para comparar similitudes.

def red_average(imagen):

''Devuelve un número entero que representa el color rojo promedio de la imagen.

'''

Total = 0

Para los píxeles de la imagen:

total = total + media.get_red(pixel )

red_average = total/(media . get _ width(pic)* media . get _ height(pic))

Devuelve red_average

def green_average( image):

''Devuelve un número entero que representa el color verde promedio de la imagen

'''

Total = 0

Para los píxeles de la imagen:

total = total + media.get_green(pixel)

verde _ promedio = total/(media . get _ width(pic)* media .get_height (pic))

Devuelve green_average

def blue_average(imagen):

''Devuelve un valor que representa el color azul promedio de la imagen Entero

'''

Total = 0

Para píxeles en la imagen:

total = total + media.get_blue(pixel )

azul _ promedio = total/(media . get _ width(pic)* media . get _ height(pic))

Devuelve azul _average

def scale_red(imagen) , valor):

''Devuelve la imagen en la que el valor promedio del rojo es el valor establecido.

'''

average=red_average(imagen)

factor=float(value)/average

Para píxeles en la imagen :

new_red = min(255, int(factor * media.get_red(pixel)))

media.set_red(pixel, new_red)

Devuelve el imagen

def scale_green(imagen, valor):

''Devuelve el valor promedio de verde a la imagen que se ha configurado.

'''

average=green_average(imagen)

factor=float(value)/average

Para píxeles en la imagen :

new_green = min(255, int(factor * media . get _ green(pixel)))

media.set_green(pixel, new_green)

Devuelve la imagen

def scale_blue(imagen, valor):

''Devuelve la imagen cuyo valor azul promedio es el valor establecido.

'''

Promedio=promedio_azul(imagen)

Factor=punto flotante(valor)/promedio

Para los píxeles en la imagen:

new_blue = min(255, int(factor * media . get_blue(pixel)))

media.set_blue(pixel, new_blue )

Imagen de retorno

def expand_height(imagen, factor):

''Devuelve una nueva imagen que se ha estirado verticalmente según el factor establecido.

'''

new_width = pic.get_width()

new_height = pic.get_height()*factor

nueva imagen = media. create_pic(new_width, new_height, media.black)

Para píxeles en la imagen:

x = media.get_x(pixel)

y = media.get_y(pixel)

nuevo píxel = media.get_pixel(nueva imagen, x, y*factor)

Para nuevo píxel en nueva imagen:

new_red = media.get_red(pixel)

new_green = media.get_green(pixel)

new_blue = media.get_blue(pixel)

media.set_red(newpixel, new_red)

media.set_green(nuevo píxel, nuevo verde)

media.set_blue(nuevo píxel, nuevo azul)

Devolver una nueva imagen

def expand_width(imagen, factor):

' ' 'Devuelve una nueva imagen que ha sido estirada horizontalmente por el factor establecido.

'''

new_width = pic.get_width() *factor

new_height = pic.get_height()

nueva imagen = media.create_pic(new_width, new_height, media.black)

Para newpixel en newpic:

x = media.get_x(newpixel)

y = media. get_y(newpixel)

pixel = media.get_pixel(pic,x/factor,y)

new_red = media.get_red(pixel)

new_green = medios .get_green(pixel)

new_blue = media.get_blue(pixel)

media.set_red(newpixel, new_red)

media.set_green (nuevo píxel, nuevo verde)

media.set_blue(nuevo píxel, nuevo azul)

Devolver nueva imagen

def reduce_height(imagen, factor):

' ' 'Devuelve una nueva imagen que ha sido comprimida verticalmente por el coeficiente establecido

'''

# Creada con la nueva altura apropiada Una nueva imagen completamente negra con

#old width; (todos los componentes de color son cero).

nueva _ anchura = imagen . getwidth

nueva _ altura =(imagen . get _ altura()-1)/factor+1

nueva imagen = media.create_pic(new_width, new_height, media.black)

#Recorre todos los píxeles de la imagen original (grande) y luego copia

#Cambiar la parte A de la El componente de color se convierte a la posición correcta

# píxeles en la imagen más pequeña.

Para píxeles en la imagen:

#Encuentra el píxel correspondiente en la nueva imagen.

x = media.get_x(píxel)

y = media.get_y(píxel)

nuevo píxel = media.get_pixel(nueva imagen,x, y /factor)

#Agregue la parte apropiada del componente de color de ese píxel

# al componente del píxel correspondiente en la nueva imagen.

nuevo _ rojo = nuevo píxel. obtener _ rojo()+píxel. obtener _ rojo()/factor

nuevo _ verde = nuevo píxel. . get _ green()/factor

new _ blue = nuevo píxel. get _ blue()+pixel . get _ blue()/factor

media.set_red(newpixel, new_red)

media.set_green(nuevo píxel, nuevo verde)

media.set_blue(nuevo píxel, nuevo azul)

Volver a la nueva imagen

def reduce_width(pic, factor):

' ' 'Devuelve una nueva imagen que ha sido comprimida horizontalmente por el factor establecido.

'''

new _ width =(media . get _ width()-1)/factor+1

new_height = media.get_height()

new pic = media . create_pic(new_width, new_height, media.black)

Para píxeles en la imagen:

x = media get_x(pixel).

y = media.get_y(pixel)

new_pixel = media.get_pixel(nueva imagen,x/factor,y)

new _ red = nuevo píxel . obtener _ rojo()+píxel . obtener _ rojo()/factor

nuevo _ verde = nuevo píxel . new _ blue = nuevo píxel . get _ blue()+pixel . get()/factor

media.set_red(newpixel, new_red)

media.set_green(nuevo píxel, nuevo verde)

media.set_blue(nuevo píxel, nuevo azul)

Devolver nueva imagen

Definir distancia (píxel1, píxel2):

rojo 1 = medios . get_red(píxel 1)

verde1 = media.get_green(píxel 1)

azul 1 = medios get _ azul(píxel 1)

rojo2 = media.get_red(pixel2)

verde2 = media.get_green(pixel2)

azul2 = media.get_blue(píxel2)

suma = abs(rojo1-rojo2) + abs(verde1-verde2) + abs(azul1-azul2)

Devuelve la suma

def simple _difference(imagen 1, imagen2):

Para píxeles en la imagen 1:

x = media.get_x(pixel)

y = media.get_y(pixel)

pixel2 = media. get_pixel(pic2, x, y)

suma = media.distance(pixel, pixel2)

Suma devuelta

def smart_difference(pic1, pic2):

altura 1 = media . get_height(imagen 1)

altura2 = media.get_height (pic2)

factorh = float(altura1/altura2)

Si factor>= 1:

altura 1 = medios reducir _ altura (imagen 1, factorh)

De lo contrario:

altura 2 = medios. reducir_height(imagen 2, 1/factorh)

ancho 1 = medios .get _ ancho(imagen 1)

ancho

2 = media.get_width(pic2)

factorw = float(ancho1/ancho2)

if factorw & gt= 1:

ancho 1 = reducir _ ancho (imagen 1, factorw)

De lo contrario:

ancho2 = reducir_ancho(pic2, 1/factorw)

rojo 1 = rojo _ promedio(imagen 1)

verde 1 = verde _mean(pic1)

azul 1 = azul _mean(pic1)

rojo2 = media.scale_red(pic2, red1)

verde2 = media.scale_green(pic2, verde1)

azul2 = media.scale_blue(pic2, azul1)

#if __name__ == '__main__ ':

#media.show(nueva imagen)