Recherche d'un moyen de faire XOR bitwise sur les images

Je suis à la recherche d'un moyen d'obtenir la XOR au niveau du bit de deux images sur la ligne de commande(ou d'une autre manière qui peut être mis en œuvre dans un programme ou un script).

Ce qui devrait résulter en la même image finale que l'utilisation de la XOR mode de Fusion incrustation d'éditeurs qui le prennent en charge (Paint.NET, Photoshop, etc)

Comme un exemple, dire que j'ai Image de Une:

et Image B:

Recherche d'un moyen de faire XOR bitwise sur les images

alors le résultat devrait ressembler à:

Recherche d'un moyen de faire XOR bitwise sur les images

La partie la plus amusante de ce est, bien sûr, que lorsque vous XOR image C image B de nouveau, vous obtiendrez une copie exacte de l'image A.

Maintenant, j'ai été à la recherche partout sur l'internet un moyen de le faire par programmation, mais je n'ai rien trouvé. Même ImageMagick ne supporte pas de faire un XOR au niveau du bit sur les images.

Ne sombebody connais un moyen de faire cela?

source d'informationauteur Qqwy

19

ImageMagick peut le faire, même si c'est un peu compliqué. Une façon est:
```
convert img1 img2 -fx "(((255*u)&(255*(1-v)))|((255*(1-u))&(255*v)))/255" img_out
```
(img1,img2,img_out sont les deux signaux d'entrée et de sortie des noms de fichier, respectivement).

Explication

C'est un peu moche (je suis sûr que quelqu'un avec plus d'ImageMagick-fu que moi n'est pas nettoyé, mais il fonctionne comme ceci:
1. -fx "xxx" dit en gros "effectuer l'opération xxx sur l'image".
  Dans l'expression ci-dessus, u et v stand pour la première et deuxième images d'entrée, respectivement.
2. Maintenant, -fx seulement a bit à bit ET & et bit à bit OU | dans la voie des opérateurs au niveau du bit.
  Pour reconstruire XOR au niveau du bit, nous avons besoin de
```
convert img1 img2 -fx "(u & NOT v) | (NOT u & v)" img_out
```
3. Pour obtenir le NOT (il y a une logique NOT mais pas au niveau du bit NOT), nous nous souvenons que NOT x = 255-x si x est de 8 bits.
  Donc, pour obtenir NOT u nous pouvons juste faire 255-u, en supposant que l'image u est de 8 bits.
  Par conséquent, la ImageMagick commande serait:
```
convert img1.png img2.img -fx "((255-u)&v)|(u&(255-v))" image_xor.png
```
4. - Le seul problème ici est que quand ImageMagick ne fx il normalise tous les pixels de u et v dans la gamme [0,1] au lieu de [0,255] comme nous le pensons, et de faire au niveau du bit sur des nombres non entiers vis des trucs.
  - Par conséquent, nous devons multiplier tous occurrences de u et v dans l'expression ci-dessus par 255 (de sorte que les opérations bit à bit de travail), et de diviser par 255 à la fin pour revenir dans la gamme [0,1] que ImageMagick attend.
Cela nous donne la commande d'origine,
```
convert img1 img2 -fx "(((255*u)&(255*(1-v)))|((255*(1-u))&(255*v)))/255" img_out
```
Voila!
9

J'ai trouvé un besoin pour xor sur une image et de la G'MIC outil fonctionne pour moi. G'MIC est incroyablement puissant, comme l'est l'Image de la Magie, mais cela vaut le coup pour la résolution de certains difficiles problèmes de traitement de l'image.
```
gmic a.png b.png -blend xor -o result.png
```
G'MIC travaille aussi directement sur les images postées ci-dessus.
```
gmic http://i.stack.imgur.com/Ws6e8.png http://i.stack.imgur.com/hoBIM.png -blend xor -o result.png
```
Pour obtenir de l'aide,
```
gmic -h -blend
```

Voici comment j'allais le faire en Java:

Parcourir tous les pixels des deux images à la fois. (pour la boucle (x) à l'intérieur d'une boucle for (y)). Bien sûr, utiliser un BufferedImage. Vous pouvez obtenir la couleur du pixel en faisant:

int color = img.getRGB(x, y);

Faire la même chose pour l'autre image et ainsi effectuer l'opération xor sur les deux couleurs. Stocker la valeur dans une nouvelle BufferedImage avec les mêmes dimensions que les deux images d'entrée.

Voici un exemple de code:

public static BufferedImage xorEffect(BufferedImage imageA, BufferedImage imageB) {
    if (imageA.getWidth() != imageB.getWidth() ||
        imageA.getHeight() != imageB.getHeight())
    {
        throw new IllegalArgumentException("Dimensions are not the same!");
    }
    BufferedImage img = new BufferedImage(imageA.getWidth(),
                                          imageA.getHeight(),
                                          BufferedImage.TYPE_INT_ARGB_PRE);

    for (int y = 0; y < imageA.getHeight(); ++y) {
        for (int x = 0; x < imageA.getWidth(); ++x) {
           int pixelA = imageA.getRGB(x, y);
           int pixelB = imageB.getRGB(x, y);
           int pixelXOR = pixelA ^ pixelB;
           img.setRGB(x, y, pixelXOR);
        }
    }
    return img;
}

Pour charger une image à partir d'un fichier utilisation:

BufferedImage imageA = ImageIO.read(new File("/home/username/image.png"));

2

Si vous voulez le faire vous-même, faire pixel par pixel.
Si vous voulez une bibliothèque, je recommande OpenCV. C'est très joli et la bibliothèque open source avec d'énormes opérations soutenues dans le traitement de l'image de la zone. Il prend en charge directe XOR à l'aide de ^ de l'opérateur.
Bonne Chance.
1

Sachant que

A XOR B = (A ET NON B) OU (NON A ET B).

et que la plupart du commun des outils de traitement d'image ont et, ou et non des opérations le reste est assez facile 🙂

De travail en Python, vous pourriez avoir un simple script qui effectue l'opération, et même l'ajout d'un plugin gimp 😉
0

OpenCV a tous les opérateurs logiques sur les images et numpy images à l'aide de bitwise_# Où # peut être xor, et, et, ... Voir OpenCV - Intersection entre deux images binaires

Vous devez vous connecter pour publier un commentaire.

Explication