1 आयामी सरणी (बिटमैपिंग)

Question

के अंदर एक आयताकार क्षेत्र पर पुनरावृत्ति के लिए एक एल्गोरिदम यह एक अजीब सवाल है जिसके लिए मुझे एक शीर्षक लिखना कठिन समय था।

मैं पिक्सल (बिटमैप्स, अधिक विशेष रूप से) के साथ काम कर रहा हूं और प्रत्येक सरणी सेल को व्यावहारिक रूप से एक्सेस करने के लिए (सरल) गणित को नहीं समझ सकता।

मेरा कैनवास [एन 16 x 16] पिक्सेल है, एन हमेशा 1 या अधिक होता है।

यहाँ एक बुनियादी एन की एक तस्वीर है = 2 कैनवास:

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

मुझे क्या करना मेरी जादुई एल्गोरिथ्म को छू कि हल्के ग्रे क्षेत्र तो बिना 0 से 495 के लिए चलाया जाता है क्या चाहते हैं अंधेरे भूरे रंग के क्षेत्र को छूए बिना 16 से 512 तक (जो वास्तव में सेल 511 है, मेरा बुरा)।

तो, 0 से 15, को छोड़ 31 32 से 47 के द्वारा पीछा करने के लिए 16, आदि

और n के लिए = 3:

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

इस मामले में यह 0-735 हल्के भूरे रंग के क्षेत्रों को छोड़कर, 16-751 प्रत्येक तरफ के क्षेत्रों को छोड़कर और गहरे भूरे रंग के क्षेत्रों को छोड़कर 32-767 होगा।

मैं क्या करने की कोशिश की:

यहाँ मेरी कोड से एक उद्धरण है, उम्मीद है कि यह उपयोगी है और पता चलता है कि मैं पहले से ही करने की कोशिश की। यह वह हिस्सा है जो 'idxpos' के मान को दर्शाता है।

// 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]; 
    } 
} 

आपको शायद यह विचार मिलता है। यह मेरे लिए आसान सरल लगता है लेकिन मैं इसे समझ नहीं सकता।

ओह, और मुझे कुछ जादुई पुस्तकालय में दिलचस्पी नहीं है जो मेरे लिए मेरे सभी बिटमैप सामान को संभाल सकता है, मैं ऐसी स्थिति में नहीं हूं जहां मैं एक का उपयोग कर सकूं।

Answer 1

यदि मुझे आपका प्रश्न ठीक से मिलता है, तो आप उनके द्वारा उल्लिखित क्रम में उनसे मिलना चाहते हैं।

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); 
    } 
    } 
} 

आशा इस मदद करता है: यहाँ कोड है कि कि (दिए गए अपने n) है।

Answer 2

यह काफी आसान है।

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; 
} 

अब कहते हैं कि तुम दूसरे वर्ग पर यह करने के लिए चाहते हैं, या सूचकांक 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; 
} 

आप भी कर सकते हैं अपने आयत डेटा के रूप में n आयत कुल चौड़ाई गुणक के रूप में और bitmap ले रहा है बिटमैप्स के सभी आकारों के लिए एक अधिक सामान्य कार्य है जो एक रेक्ट लेता है और आपको अपने बिटमैप के अंदर इच्छित किसी भी आयत में डेटा को संशोधित करने की अनुमति देता है।

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

निम्नलिखित काम करना चाहिए:

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

बस प्रत्येक स्प्राइट

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] ... 
     } 
    } 
}