Comment inverser cette fonction

Question

J'ai déjà demandé à propos de l'opposé de Bitwise ET (&) et vous m'a dit son impossible à inverser. Eh bien, voici la situation: Le serveur envoie une image, qui est encodée avec la fonction que je veux inverser, puis il est codé avec zlib.

Voilà comment je reçois l'image du serveur:

 UInt32[] image = new UInt32[200 * 64]; 
     int imgIndex = 0; 
     byte[] imgdata = new byte[compressed]; 
     byte[] imgdataout = new byte[uncompressed]; 

     Array.Copy(data, 17, imgdata, 0, compressed); 
     imgdataout = zlib.Decompress(imgdata); 
     for (int h = 0; h < height; h++) 
     { 
      for (int w = 0; w < width; w++) 
      { 
       imgIndex = (int)((height - 1 - h) * width + w); 
       image[imgIndex] = 0xFF000000; 
       if (((1 << (Int32)(0xFF & (w & 0x80000007))) & imgdataout[((h * width + w) >> 3)]) > 0) 
       { 
        image[imgIndex] = 0xFFFFFFFF; 
       } 
      } 
     } 

largeur, hauteur, image décompressée et image longueur comprimée sont toujours les mêmes.

Lorsque cette fonction est terminée, je mets une image (tableau UInt32 []) dans un bitmap et je l'ai.

Maintenant, je veux être le serveur et l'envoyer image.I doivent faire deux choses:

inverse cette fonction, puis compressent avec zlib.

Comment inverser cette fonction, je peux coder l'image?

for (int h = 0; h < height; h++) 
    { 
     for (int w = 0; w < width; w++) 
     { 
      imgIndex = (int)((height - 1 - h) * width + w); 
      image[imgIndex] = 0xFF000000; 
      if (((1 << (Int32)(0xFF & (w & 0x80000007))) & imgdataout[((h * width + w) >> 3)]) > 0) 
      { 
       image[imgIndex] = 0xFFFFFFFF; 
      } 
     } 
    } 

EDIT: Le format est 32bppRGB

Answer 1

L'hypothèse selon laquelle l'opérateur & est toujours irréversible est incorrect.

Oui, en général si vous avez

c = a & b 

et tout ce que vous connaissez est la valeur de c, alors vous ne pouvez pas savoir quelles sont les valeurs a ou b avaient avant la main.

Cependant, il est très fréquent pour les & à utiliser pour extrait certains bits d'une valeur plus où ces bits étaient regroupés en même temps que l'opérateur | et où chaque « champ de bits » est indépendant de tous les autres. La différence fondamentale avec les opérateurs génériques & ou | qui rend cette opération réversible est que les bits d'origine étaient tous auparavant et les autres bits dans le mot sont laissés inchangés. i.e.:

0xc0 | 0x03 = 0xc3 // combine two nybbles 

0xc3 & 0xf0 = 0xc0 // extract the top nybble 
0xc3 & 0x0f = 0x03 // extract the bottom nybble 

Dans ce cas, votre fonction actuelle semble être l'extraction d'un 1 bit par pixel (image monochrome) et le convertir en RVBA 32 bits.

Vous aurez besoin de quelque chose comme:

int source_image[]; 
byte dest_image[]; 

for (int h = 0; h < height; ++h) { 
    for (int w = 0; w < width; ++w) { 
     int offset = (h * width) + w; 
     if (source_image[offset] == 0xffffffff) { 
      int mask = w % 8; // these two lines convert from one int-per-pixel 
      offset /= 8;  // offset to one-bit-per-pixel 
      dest_image[offset] |= (1 << mask); // only changes _one_ bit 
     } 
    } 
} 

NB: Suppose l'image est un multiple de 8 pixels de large, que le tableau dest_image était auparavant tous les zéros. J'ai utilisé % et / dans ce test interne, car il est plus facile à comprendre et le compilateur devrait convertir pour masquer/décaler lui-même. Normalement, je ferais le masquage et je me déplacerais.