Impossible de comprendre le bug dans ce code

Question

Donc, je fais l'un des exercices de Princeton ici: http://www.cs.princeton.edu/courses/archive/fall10/cos126/assignments/lfsr.html et j'ai entièrement testé par classe LFSR avec les données qui ont été fournies, donc je suis sûr que je n'ai pas mal tourné là-bas. Cependant, ma classe PhotoMagic donne une photo cryptée de la pipe comme ci-dessous:

Ce n'est pas comment cela devrait apparaître. Une idée de l'endroit où mon code a mal tourné?

import java.awt.Color; 

public class PhotoMagic 
{ 
    private LFSR lfsr; 

public static void main(String args[]) 
{ 
    new PhotoMagic("src/pictures/shield.png","01101000010100010000",16); 

} 

public PhotoMagic(String imageName,String binaryPassword,int tap) 
{ 
    Picture pic = new Picture(imageName); 
    lfsr = new LFSR(binaryPassword,tap); 


    for (int x = 0; x < pic.width(); x++) 
    { 
     for (int y = 0; y < pic.height(); y++) 
     { 
      Color color = pic.get(x, y); 
      int red = color.getRed(); 
      int blue = color.getBlue(); 
      int green = color.getGreen(); 
      int transparency = color.getTransparency(); 
      int alpha = color.getAlpha(); 

      int newRed = xor(Integer.toBinaryString(red),paddedBitPattern(lfsr.generate(8))); 

      int newGreen = xor(Integer.toBinaryString(green),paddedBitPattern(lfsr.generate(8))); 

      int newBlue = xor(Integer.toBinaryString(blue),paddedBitPattern(lfsr.generate(8))); 

      Color newColor = new Color(newRed, newGreen, newBlue); 
      pic.set(x, y, newColor); 
     } 
    } 
    pic.show(); 
} 

/** 
* Pads bit pattern to the left with 0s if it is not 8 bits long 
* @param bitPattern 
* @return 
*/ 
public String paddedBitPattern(int bitPattern) 
{ 
    String tempBit = Integer.toBinaryString(bitPattern); 
    String newPattern = ""; 
    for(int i = 1; i < 9-tempBit.length(); i++) 
    { 
     newPattern += "0"; 
    } 
    newPattern += tempBit; 
    return newPattern; 
} 

/** 
* Performs the bitwise XOR 
* @param colorComponent 
* @param generatedBit 
* @return 
*/ 
public int xor(String colorComponent, String generatedBit) 
{ 
    String newColor = ""; 

    for(int i = 0; i < colorComponent.length(); i++) 
    { 
     if(colorComponent.charAt(i) != generatedBit.charAt(i)) 
     { 
      newColor += 1; 
     } 
     else 
     { 
      newColor += 0; 
     } 
    } 
    return Integer.valueOf(newColor,2); 
} 

}

Answer 1

Vous devez remplir le résultat de Integer.toBinaryString() lors du calcul de newRed, newGreen et newBlue. Il peut ne pas avoir la longueur 8.

Answer 2

La question est probable dans ce bloc de code

public String paddedBitPattern(int bitPattern) 
{ 
    String tempBit = Integer.toBinaryString(bitPattern); 
    String newPattern = ""; 
    for(int i = 1; i < 9-tempBit.length(); i++) 
    { 
     newPattern += "0"; 
    } 
    newPattern += tempBit; 
    return newPattern; 
} 

Notez que votre newPattern commence comme la chaîne de longueur zéro, puis vous ajoutez un texte zéro à ce pour chacun des bits dans bitPattern. Ensuite, vous ajoutez le bitPattern dans le newPattern et renvoyez le résultat. Cela conduit à un résultat 100% non aléatoire qui est une version à zéro remplissage du même bitPattern que vous venez de soumettre.

Donc, si l'entrée est

0010101101 

la sortie sera

00000000000010101101 

qui (lors de la suppression des zéros) est exactement l'entrée

0010101101 

Comme il n'y a plus de complexité, il ne gâche pas la capacité de l'esprit à la détection des contours: il est assez facile de voir le motif.

Answer 3

J'ai modifié comme suit. Ça a marché. Pourquoi avez-vous tout transformé en `String`s?

int newRed = xor(paddedBitPattern(red),paddedBitPattern(lfsr.generate(8)));  
int newGreen = xor(paddedBitPattern(green),paddedBitPattern(lfsr.generate(8))); 
int newBlue = xor(paddedBitPattern(blue),paddedBitPattern(lfsr.generate(8)));