PIL Meilleure Façon De Remplacer la Couleur?

Je suis en train de retirer une certaine couleur de mon image mais il ne fonctionne pas aussi bien que je l'avais espéré. J'ai essayé de faire la même chose, comme ici, À l'aide de PIL à faire tous les pixels blancs transparents? cependant la qualité de l'image est un peu figé, donc ça laisse un peu de fantôme de l'étrange couleur des pixels autour de l'endroit où ce qui a été retiré. J'ai essayé de faire quelque chose comme changement de pixel si les trois valeurs sont en dessous de 100, mais parce que l'image est de mauvaise qualité les pixels environnants n'étaient même pas noir.

Personne ne sait d'une meilleure façon avec PIL en Python pour remplacer une couleur et tout ce qui l'entoure? C'est probablement la seule à même d'assurer la meilleure façon que je peux penser à supprimer les objets complètement cependant, je ne peux pas penser à une façon de le faire.

L'image a un fond blanc et un texte noir. Disons juste que je veux supprimer le texte entièrement à partir de l'image, sans laisser aucune artefacts derrière.

Apprécierais vraiment quelqu'un de vous aider! Grâce

OriginalL'auteur Cookies | 2009-10-24

Vous aurez besoin de représenter l'image comme un tableau en 2 dimensions. Cela veut dire faire une liste de listes de pixels, ou la visualisation de la dimension 1 tableau 2d avec quelques petits malins de mathématiques. Ensuite, pour chaque pixel qui est ciblé, vous aurez besoin de trouver tous les pixels environnants. Vous pouvez le faire avec un python générateur ainsi:

def targets(x,y):
    yield (x,y) # Center
    yield (x+1,y) # Left
    yield (x-1,y) # Right
    yield (x,y+1) # Above
    yield (x,y-1) # Below
    yield (x+1,y+1) # Above and to the right
    yield (x+1,y-1) # Below and to the right
    yield (x-1,y+1) # Above and to the left
    yield (x-1,y-1) # Below and to the left

Donc, vous pouvez l'utiliser comme ceci:

for x in range(width):
    for y in range(height):
        px = pixels[x][y]
        if px[0] == 255 and px[1] == 255 and px[2] == 255:
            for i,j in targets(x,y):
                newpixels[i][j] = replacementColor

OriginalL'auteur Benson

22

La meilleure façon de le faire est d'utiliser la "couleur vers alpha" algorithme utilisé dans Gimp pour remplacer une couleur. Il fonctionnera parfaitement dans votre cas. Je ré-implémenté cet algorithme à l'aide de PIL pour un open source python photo processeur phatch. Vous pouvez trouver la pleine mise en œuvre ici. Ce une pure LIP mise en œuvre et il n'a pas d'autres dépendances. Vous pouvez copier le code de la fonction et de l'utiliser. Voici un échantillon à l'aide de Gimp:

Vous pouvez appliquer la color_to_alpha la fonction de l'image en utilisant le noir comme couleur. Puis collez l'image sur une couleur de fond différente pour faire le remplacement.

Par ailleurs, cette application utilise le ImageMath module PIL. Il est beaucoup plus efficace que l'accès aux pixels à l'aide de getdata.

EDIT: Voici le code complet:
```
from PIL import Image, ImageMath
def difference1(source, color):
"""When source is bigger than color"""
return (source - color) / (255.0 - color)
def difference2(source, color):
"""When color is bigger than source"""
return (color - source) / color
def color_to_alpha(image, color=None):
image = image.convert('RGBA')
width, height = image.size
color = map(float, color)
img_bands = [band.convert("F") for band in image.split()]
# Find the maximum difference rate between source and color. I had to use two
# difference functions because ImageMath.eval only evaluates the expression
# once.
alpha = ImageMath.eval(
"""float(
max(
max(
max(
difference1(red_band, cred_band),
difference1(green_band, cgreen_band)
),
difference1(blue_band, cblue_band)
),
max(
max(
difference2(red_band, cred_band),
difference2(green_band, cgreen_band)
),
difference2(blue_band, cblue_band)
)
)
)""",
difference1=difference1,
difference2=difference2,
red_band = img_bands[0],
green_band = img_bands[1],
blue_band = img_bands[2],
cred_band = color[0],
cgreen_band = color[1],
cblue_band = color[2]
)
# Calculate the new image colors after the removal of the selected color
new_bands = [
ImageMath.eval(
"convert((image - color) /alpha + color, 'L')",
image = img_bands[i],
color = color[i],
alpha = alpha
)
for i in xrange(3)
]
# Add the new alpha band
new_bands.append(ImageMath.eval(
"convert(alpha_band * alpha, 'L')",
alpha = alpha,
alpha_band = img_bands[3]
))
return Image.merge('RGBA', new_bands)
image = color_to_alpha(image, (0, 0, 0, 255))
background = Image.new('RGB', image.size, (255, 255, 255))
background.paste(image.convert('RGB'), mask=image)
```
J'ai essayé d'obtenir que cela fonctionne, mais il a dit pas de module de base et des choses comme ça, c'était juste un gâchis. Je suis sans doute idiot, mais je ne pouvais pas le faire fonctionner. Merci de toute façon je suis sûr que votre réponse peut aider quelqu'un d'autre si.
Vous ne devriez pas essayer d'exécuter le fichier en entier. Il suffit de copier le color_to_alpha fonction elle-même. De toute façon, je suis content que vous avez trouvé une solution qui fonctionne pour vous. Si vous avez besoin d'une solution plus efficace, vous savez où regarder 😉
Je l'ai fait, et il dit d'abord de nom global "OPTIONS" n'est pas défini, alors j'ai copié la partie et ensuite, il dit _t n'est pas défini, mais c'est un module que je n'avais pas. C'est ce que je voulais dire par mess, j'ai essayé de le faire fonctionner mais ne le pouvait pas, la méthode proposée ci-dessous qui ont travaillé pour moi, c'est ok, mais si votre fonction pourrait vraiment prendre tous les pixels du fond de l'image, ce serait sympa. Il y a encore certains qui confondent tesseract.
J'ai mis à jour la solution avec la solution complète. Vous pouvez modifier les couleurs dans les 3 dernières lignes correspondent à ceux que vous voulez.
Merci, ça fonctionne, sauf qu'il laisse toujours derrière un fantôme de pixels contrairement à la solution ci-dessous. Fondamentalement, j'ai un solide de couleur sombre du texte, c'est noir/bleu comme un dégradé à cause de la mauvaise qualité. Je veux garder les objets solides et la suppression de tous les pixels qui l'entourent, qui sont en quelque sorte comme une ombre. Comme ceci: img36.imageshack.us/img36/6963/expuq.jpg je vais jouer avec elle un peu et voir si je peux faire quelque chose pour le travail.. Merci encore!

OriginalL'auteur Nadia Alramli
12

Utilisation de numpy et PIL:

Cette charge l'image dans un tableau numpy de forme (W,H,3), où W est l'
la largeur et la H est à la hauteur. Le troisième axe de la matrice représente les 3 couleurs
canaux, R,G,B.
```
import Image
import numpy as np
orig_color = (255,255,255)
replacement_color = (0,0,0)
img = Image.open(filename).convert('RGB')
data = np.array(img)
data[(data == orig_color).all(axis = -1)] = replacement_color
img2 = Image.fromarray(data, mode='RGB')
img2.show()
```
Depuis orig_color est un n-uplet de longueur 3, et data a
forme (W,H,3), NumPy
diffusions
orig_color à une matrice de la forme (W,H,3) pour effectuer la comparaison data == orig_color. Le résultat en est un booléen tableau de forme (W,H,3).

(data == orig_color).all(axis = -1) est un booléen tableau de forme (W,H) qui
est Vrai, où la couleur RVB dans data est original_color.

OriginalL'auteur unutbu

#!/usr/bin/python
from PIL import Image
import sys
img = Image.open(sys.argv[1])
img = img.convert("RGBA")
pixdata = img.load()
# Clean the background noise, if color != white, then set to black.
# change with your color
for y in xrange(img.size[1]):
for x in xrange(img.size[0]):
if pixdata[x, y] == (255, 255, 255, 255):
pixdata[x, y] = (0, 0, 0, 255)

OriginalL'auteur Yuda Prawira

4

Si les pixels ne sont pas facilement identifiables.e.g vous dire (r < 100 et g < 100 et b < 100) aussi ne pas correspondre correctement le noir de la région, cela signifie que vous avez beaucoup de bruit.

Meilleure façon serait d'identifier une région, et le remplir avec la couleur que vous voulez, vous pouvez identifier la région manuellement ou peut être par la détection de contours par exemple http://bitecode.co.uk/2008/07/edge-detection-in-python/

ou plus sophistiqué approche serait d'utiliser la bibliothèque comme opencv (http://opencv.willowgarage.com/wiki/) pour identifier des objets.

OriginalL'auteur Anurag Uniyal

C'est la partie de mon code, le résultat serait comme:
source

cible

import os
import struct
from PIL import Image
def changePNGColor(sourceFile, fromRgb, toRgb, deltaRank = 10):
fromRgb = fromRgb.replace('#', '')
toRgb = toRgb.replace('#', '')
fromColor = struct.unpack('BBB', bytes.fromhex(fromRgb))
toColor = struct.unpack('BBB', bytes.fromhex(toRgb))
img = Image.open(sourceFile)
img = img.convert("RGBA")
pixdata = img.load()
for x in range(0, img.size[0]):
for y in range(0, img.size[1]):
rdelta = pixdata[x, y][0] - fromColor[0]
gdelta = pixdata[x, y][0] - fromColor[0]
bdelta = pixdata[x, y][0] - fromColor[0]
if abs(rdelta) <= deltaRank and abs(gdelta) <= deltaRank and abs(bdelta) <= deltaRank:
pixdata[x, y] = (toColor[0] + rdelta, toColor[1] + gdelta, toColor[2] + bdelta, pixdata[x, y][3])
img.save(os.path.dirname(sourceFile) + os.sep + "changeColor" + os.path.splitext(sourceFile)[1])
if __name__ == '__main__':
changePNGColor("./ok_1.png", "#000000", "#ff0000")

OriginalL'auteur Joseph

Vous devez vous connecter pour publier un commentaire.