Ein Algorithmus zum Iterieren über einen rechteckigen Bereich innerhalb eines 1-dimensionalen Arrays (Bitmapping)

Question

Dies ist eine seltsame Frage, für die ich Schwierigkeiten hatte, einen Titel zu schreiben.

Ich arbeite mit Pixeln (Bitmaps, genauer gesagt) und kann die (einfache) Mathematik für den pragmatischen Zugriff auf jede Array-Zelle nicht herausfinden.

Meine Leinwand ist [n16 x 16] Pixel, n ist immer 1 oder größer.

Hier ist ein Foto von einem Grunde n = 2 Leinwand:

http://i.imgur.com/mabwQfJ.png

Was ich mein magischer Algorithmus will, ist 0-495 laufen zu tun, ohne dann, dass leichtere Grauzone zu berühren gehe von 16 zu 512 (was eigentlich Zelle 511 ist, mein Schlechter), ohne den dunkelgrauen Bereich zu berühren.

So, 0-15, fahren 16 bis 31, gefolgt von 32 bis 47 usw.

Und für n = 3:

http://i.imgur.com/TqJMWl6.png

In diesem Fall ist es wäre 0-735, die helleren grauen Bereiche überspringend, 16-751 die Bereiche auf jeder Seite überspringend und 32-767 die dunkleren grauen Bereiche überspringend.

Was ich versucht:

ein Auszug aus meinem Code Hier ist, hoffentlich ist es sinnvoll und zeigt, was ich schon versucht. Es ist der Teil, der den Wert für "idxpos" ermittelt.

// Let's say length = 3 for now. 
for (int character = 0; character < length; ++character) 
{ 
    // in case you're wondering, it grabs 16x16 characters from an ASCII spritesheet 
    charpos = (string[character] - ' ') * 16 * 16; 

    // Runs through the spritesheet character map 
    // this is a huge 16x1520 bitmap. 
    for (int pixel = 0; pixel < 16 * 16; ++pixel) 
    { 
     // ignore this, just me messing around with pixel tinting 
     r = (((CharMap[charpos + pixel] >> 0) & 0xFF) + 255 - u); 
     g = (((CharMap[charpos + pixel] >> 8) & 0xFF) + 255 - v); 
     b = (((CharMap[charpos + pixel] >> 16) & 0xFF) + 255 - w); 
     newcolour = RGB(r, g, b); 

     // THIS is the part I am stuck on: 
     idxpos = pixel + (character * 16 * 16); 

     bitmap[idxpos] = CharMap[charpos + j]; 
    } 
} 

Sie bekommen wahrscheinlich die Idee. Es klingt für mich einfach tot, aber ich kann es nicht herausfinden.

Oh, und ich bin nicht an einer magischen Bibliothek interessiert, die all meine Bitmap-Sachen für mich verarbeiten kann, ich bin nicht in einer Position, in der ich eine verwenden kann.

Answer 1

Wenn ich Ihre Frage richtig beantworte, möchten Sie sie in der von Ihnen genannten Reihenfolge aufrufen. Hier ist der Code, der das tut (da Ihre n):

for(int i = 0; i < n; i++) //which section we are going through 
{ 
    for(int row = 0; row < size; row++) //size = 16, better use on of your constants 
    { 
    for(int col = 0; col < size; col++) 
    { 
     int pixelIndex = size * (row * n) + col + size * i; 
     /*the last one is an offset - it moves the 
     index to the right as far as we need. 
     If you need two coordinates (as in (x,y)) 
     instead of one number, it is: */ 
     int x = row, y = col + size * i; 
     doSomethingWithPixel(pixelIndex); 
    } 
    } 
} 

Hoffnung, das hilft.

Answer 2

Es ist einfach genug. Unter n als Rechteck Gesamtbreite Multiplikator und bitmap als Rechteck Daten:

for (int i = 0; i < 16*16; ++i) // 16*16 because you want a 16x16 area 
{ 
    int x = i % 16; 
    int y = i/16; 
    bitmap[x + y * 16 * n] = value; 
} 

Jetzt sagen Sie es auf dem zweiten Platz tun wollen, oder Quadrat Index square = 1:

for (int i = 0; i < 16*16; ++i) 
{ 
    int x = i % 16; 
    int y = i/16; 
    bitmap[x + y * 16 * n + 16 * square] = value; 
} 

Sie können auch eine generische Funktion für alle Formen von Bitmaps haben, die ein Rect verwenden und es Ihnen ermöglichen, Daten in jedem beliebigen Rechteck in Ihrer Bitmap zu ändern.Es braucht nur das Bitmap width als Referenz:

void bitmap_fill(int* bitmap, int width, int top, int left, int right, int bottom) 
{ 
    for (; top <= bottom; ++top) 
     for (int x = left; x <= right; ++x) 
      bitmap[top * width + x] = value; 
} 

Answer 3

Die folgenden sollte funktionieren:

void fill(int n, int p[], int w, int h) { // n: number of squares; p: data array; w: width; h: height 
    for (int i = 0; i < n; ++i) { // for the i-th square 
     for (int j = 0, pos = i * w; j < h; ++j, pos += w * n) { 
      std::fill(p + pos, p + pos + w, 0); // fill the j-th row of the i-th square 
     } 
    } 
} 

Answer 4

einfach eine xy-Schleife

for (int sprite_number=0; sprite_number<n; sprite_number++) { 
    for (int y=0; y<height; y++) { 
     for (int x=0; x<width; x++) { 
      int final_x = sprite_number * width + x; 

      ... use bitmap[y*bitmap_width + final_x] ... 
     } 
    } 
}