Question

Sorry I had no idea how set a topic which could express what help I need.

I have in an array of bytes, values for each pixel from a bitmap. It is a one dimensional array, from left to right. It takes each row and add it to the end of array’s index.

I would like to split a bitmap to 225(=15*15) pieces. Each brick has for example dimension 34×34 and the length of array is then 260100(=225*34*34). So as you see now we will need 15 bricks on width and on height.

Few months ago I was using two loops starting from 0 – 14. I wrote own long code to get all that 34×34 bricks. However I didn’t used any array which was storing all values.

Now I have a one dimensional array because marshal copy and bitmapdata with bitlocks were the best way to fast copy all pixels’ values to array.

But I stand face to face with problem how to get 34 elements then one row lower and another one knowing that on 35 level will be another brick with its own starting value..

PS. edit my post if something is not good.

Few people could say “first make any your test code”. I tried that but what I got was just trash and I really don’t know how to do that.

---

This method was used to crop image to smaller images containing bricks. But I don’t want store small images of brick. I need values storing in array of bytes.

Under, there is a proof.

private void OCropImage(int ii, int jj, int p, int p2)


   {
        ////We took letter and save value to binnary, then we search in dictionary by value
        this.rect = new Rectangle();
        this.newBitmap = new Bitmap(this.bitmap);
        for (ii = 0; ii < p; ii++)
        {
            for (jj = 0; jj < p2; jj++)
            {
                ////New bitmap
                this.newBitmap = new Bitmap(this.bitmap);

                ////Set rectangle working area with letters
                this.rect = new Rectangle(jj * this.miniszerokosc, ii * this.miniwysokosc, this.miniszerokosc, this.miniwysokosc);
                ////Cut single rectangle with letter
                this.newBitmap = this.newBitmap.Clone(this.rect, this.newBitmap.PixelFormat);
                ////Add frame to rectangle to delet bad noise
                this.OAddFrameToCropImage(this.newBitmap, this.rect.Width, this.rect.Height);
                this.frm1.SetIm3 = (System.Drawing.Image)this.newBitmap;

                ////Create image with letter which constains less background
                this.newBitmap = this.newBitmap.Clone(this.GetAreaLetter(this.newBitmap), this.newBitmap.PixelFormat);
                ////Count pixels in bitmap
                this.workingArea = this.GetBinnary(this.newBitmap);

                var keysWithMatchingValues = this.alphabetLetters.Where(x => x.Value == this.workingArea).Select(x => x.Key);
                foreach (var key in keysWithMatchingValues)
                {
                    this.chesswords += key.ToString();
                }
            }

            this.chesswords += Environment.NewLine;
            var ordered = this.alphabetLetters.OrderBy(x => x.Value);
        }
    }

PS2. sorry for my English, please correct it if it is needed.

Answer 1

If I get you right, then if you have an image like this

p00|p01|p02|...
---+---+-------
p10|p11|p12|...
---+---+-------
p20|p21|p22|...
---+---+---+---
...|...|...|...

Which is stored in an array in left-to-right row scan like this:

p00,p01,...,p0n, p10,p11,...,p1n, p20,p21, ...

If I understand you correctly, what you want to be able to do, is to take a given rectangle (from a certain x and y with a certain width and height) from the image. Here is code to do this, with explanations:

byte[] crop_area (byte[] source_image, int image_width, int image_height,
int start_x, int start_y, int result_width, int result_height)
{
    byte[] result = new byte[result_width * result_height];
    int endX = x + result_width;
    int endY = y + result_height;

    int pos = 0;

    for (int y = startY; y < endY; y++)
        for (int x = startX; x < endX; x++)
        {
            /* To get to the pixel in the row I (starting from I=1), we need
             * to skip I-1 rows. Since our y indexes start from row 0 (not 1),
             * then we don't need to subtract 1.
             *
             * So, the offset of the pixel at (x,y) is:
             *
             *     y * image_width      +        x
             * |-----------------------| |-----------------|
             *   Skip pixels of y rows    Offset inside row
             */
            result[pos] = source_image[y * image_width + x];

            /* Advance to the next pixel in the result image */
            pos++;
        }
    return result;
}

Then, to take the block in the row I and column J (I,J=0,…,14) do:

crop_area (source_image, image_width, image_height, J*image_width/15, I*image_height/15, image_width/15, image_height/15)