C# Bitmap.GetLength方法代碼示例

        public static Bitmap[,] ExtractAll(Bitmap[,] charsIn)
        {
            Bitmap[,] toRet = new Bitmap[charsIn.GetLength(0), charsIn.GetLength(1)];

            for(int i = 0; i < charsIn.GetLength(0); i++)
            {
                for(int j = 0; j < charsIn.GetLength(1); j++)
                {
                    toRet[i, j] = Extract(charsIn[i, j]);
                }
            }

            return toRet;
        }

        //Perform classification on a 2D array of images (returns probabilities for each possible class for each image)
        public double[][][] Classify(Bitmap[,] charImgs)
        {
            double[][][] toRet = new double[charImgs.GetLength(0)][][];

            for (int i = 0; i < toRet.Length; i++) //Col
            {
                toRet[i] = new double[charImgs.GetLength(1)][];

                for (int j = 0; j < toRet[i].Length; j++) //Row
                {
                    toRet[i][j] = this.Classify(charImgs[i, j]);
                }
            }

            return toRet;
        }

        private static Bitmap MergeResult(Bitmap[,] results, int sx, int sy, int n)
        {
            var ix = results.GetLength(0);
            var iy = results.GetLength(1);

            int stx = 9999;
            int sty = 9999;

            for (int x = 0; x < ix; x++)
            {
                for (int y = 0; y < iy; y++)
                {
                    if (results[x, y] != null)
                    {
                        stx = Math.Min(x, stx);
                        sty = Math.Min(y, sty);
                    }
                }
            }

            var result = new Bitmap(n * sx, n * sy);
            using (var g = Graphics.FromImage(result))
            {
                for (int x = 0; x < n; x++)
                {
                    for (int y = 0; y < n; y++)
                    {
                        g.DrawImage(results[stx + x, sty + y], x * sx, y * sy);
                    }
                }
            }
            return result;
        }

        /// <summary>
        /// Takes a 2-dimensional array of tiles and stitches it into a single Bitmap for display on the Map
        /// </summary>
        /// <param name="tiles">2-dimensional array of tiles, [x by y]</param>
        /// <param name="opacity">Opacity of final image</param>
        /// <returns>Bitmap of the tiles stitched together</returns>
        public static Bitmap StitchTiles(Bitmap[,] tiles, short opacity)
        {
            var width = tiles.GetLength(0) * 256;
            var height = tiles.GetLength(1) * 256;

            //create a bitmap to hold the combined image
            var finalImage = new Bitmap(width, height);

            //get a graphics object from the image so we can draw on it
            using (var g = Graphics.FromImage(finalImage))
            {
                //set background color
                g.Clear(Color.Transparent);

                using (var iaPic = new ImageAttributes())
                {
                    var cmxPic = new ColorMatrix {Matrix33 = opacity/100f};
                    iaPic.SetColorMatrix(cmxPic, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);

                    //go through each image and "draw" it on the final image
                    for (var y = 0; y < tiles.GetLength(1); y++)
                    {
                        for (var x = 0; x < tiles.GetLength(0); x++)
                        {
                            if (tiles[x, y] != null)
                            {
                                var tile = tiles[x, y];
                                g.DrawImage(tile, new Rectangle(x*256, y*256, tile.Width, tile.Height),
                                    0, 0, tile.Width, tile.Height, GraphicsUnit.Pixel, iaPic);
                            }
                        }
                    }
                }
            }

            return finalImage;
        }

        //Takes a 2D array of Bitmaps and makes them into a single Bitmap by putting them together in a grid pattern
        public static Bitmap Grid(Bitmap[,] charImgs)
        {
            //Validation: Check that there is at least one image
            if(charImgs.Length == 0)
            {
                throw new ArgumentException("Collection \"charImgs\" must have at least one element");
            }

            //Validation: Check that all images are in the same PixelFormat
            PixelFormat pixelFormat = charImgs[0, 0].PixelFormat;
            foreach(Bitmap charImg in charImgs)
            {
                if(charImg.PixelFormat != pixelFormat)
                {
                    throw new UnexpectedPixelFormatException("All images must have the same PixelFormat");
                }
            }

            //Validation: Check that all images in each column have the same width
            for(int i = 0; i < charImgs.GetLength(0); i++) //Cols
            {
                int colWidth = charImgs[i, 0].Width;

                for(int j = 1; j < charImgs.GetLength(1); j++) //Rows
                {
                    if(charImgs[i, j].Width != colWidth)
                    {
                        throw new InvalidImageDimensionsException("All images in each column must have the same Width in order to form a grid");
                    }
                }
            }

            //Validation: Check that all images in each row have the same height
            for(int i = 0; i < charImgs.GetLength(1); i++) //Row
            {
                int rowHeight = charImgs[0, i].Height;

                for(int j = 1; j < charImgs.GetLength(0); j++) //Col
                {
                    if(charImgs[j, i].Height != rowHeight)
                    {
                        throw new InvalidImageDimensionsException("All images in each row must have the same Height in order to form a grid");
                    }
                }
            }

            //Determine the number of bytes per pixel
            int bytesPerPixel = charImgs[0, 0].GetBitsPerPixel() / 8;

            //Calculate the total image Width & Height
            int imgWidth = 0;
            for(int i = 0; i < charImgs.GetLength(0); i++) //Cols
            {
                imgWidth += charImgs[i, 0].Width;
            }

            int imgHeight = 0;
            for(int i = 0; i < charImgs.GetLength(1); i++) //Rows
            {
                imgHeight += charImgs[0, i].Height;
            }

            Bitmap img = new Bitmap(imgWidth, imgHeight, pixelFormat);

            //Lock image for write so we can access it with pointers
            BitmapData imgData = img.LockBits(new Rectangle(0, 0, img.Width, img.Height),
                ImageLockMode.WriteOnly, img.PixelFormat);

            unsafe
            {
                byte* ptrImgData = (byte*)imgData.Scan0;

                //Keep track of how many pixels in from the left we are to the left of this col
                int colLeftIdx = 0;

                for(int col = 0; col < charImgs.GetLength(0); col++)
                {
                    //Keep track of how many pixels in from the top we are to the top of this row
                    int rowTopIdx = 0;

                    for(int row = 0; row < charImgs.GetLength(1); row++)
                    {
                        //Lock this char for read so we can copy it across to the new image
                        BitmapData charData = charImgs[col, row].LockBits(new Rectangle(0, 0, 
                            charImgs[col, row].Width, charImgs[col, row].Height), ImageLockMode.ReadOnly, pixelFormat);

                        byte* ptrCharData = (byte*)charData.Scan0;

                        //Loop over each pixel in this char img to be copied across
                        for (int i = 0; i < charImgs[col, row].Width; i++) //Cols
                        {
                            for(int j = 0; j < charImgs[col, row].Height; j++) //Rows
                            {
                                int imgOffset = (((rowTopIdx) + j) * imgData.Stride) + ((colLeftIdx + i) * bytesPerPixel);
                                int charImgOffset = (j * charData.Stride) + (i * bytesPerPixel);

                                //Copy the bytes for this pixel
                                for(int k = 0; k < bytesPerPixel; k++)
                                {
//.........這裏部分代碼省略.........

        public void DisplayCommodityResults(string[,] s, Bitmap[,] originalBitmaps, float[,] originalBitmapConfidences, string[] rowIds, string screenshotName)
        {
            if (InvokeRequired)
            {
                Invoke(new DisplayCommodityResultsDelegate(DisplayCommodityResults), s, originalBitmaps, originalBitmapConfidences, rowIds, screenshotName);
                return;
            }

            if (_commodityTexts != null && _correctionColumn < _commodityTexts.GetLength(1)) // there is an existingClassification screenshot being processed...
            {
                _screenshotResultsBuffer.Add(new ScreeenshotResults { originalBitmapConfidences = originalBitmapConfidences, originalBitmaps = originalBitmaps, s = s, rowIds = rowIds, screenshotName = screenshotName });
                ScreenshotsQueued("(" + (_screenshotResultsBuffer.Count + ocr.ScreenshotBuffer.Count + _preOcrBuffer.Count) + " queued)");
                return;
            }

            if (originalBitmaps.GetLength(0) != 0)
                BeginCorrectingScreenshot(s, originalBitmaps, originalBitmapConfidences, rowIds, screenshotName);
            else
                tbCommoditiesOcrOutput.Text = "No rows found...";
        }

        public static Bitmap[,] Grid(Bitmap img, uint rows, uint cols)
        {
            //Height must be divisible by rows & width must be divisible by cols, otherwise will require interpolation and will be much slower
            if (img.Height % rows != 0 || img.Width % cols != 0)
            {
                throw new UnexpectedImageSizeException("Image height must be divisible by num rows and Image width must be divisible by num cols");
            }

            //Determine the number of Bytes Per pixel in this image
            int bytesPerPixel = img.GetBitsPerPixel() / 8;

            Bitmap[,] chars = new Bitmap[cols, rows];

            //Lock image for read so we can access it with pointers
            BitmapData imgData = img.LockBits(new Rectangle(0, 0, img.Width, img.Height),
                ImageLockMode.ReadOnly, img.PixelFormat);

            int colWidth = img.Width / (int)cols;
            int rowHeight = img.Height / (int)rows;

            unsafe
            {
                byte* ptrImgData = (byte*)imgData.Scan0;

                for (int col = 0; col < chars.GetLength(0); col++)
                {
                    for (int row = 0; row < chars.GetLength(1); row++)
                    {
                        //Make a new Bitmap to hold the char
                        Bitmap charBitmap = new Bitmap(colWidth, rowHeight, img.PixelFormat);

                        //Lock image for write so we can write to it
                        BitmapData charData = charBitmap.LockBits(new Rectangle(0, 0, charBitmap.Width, charBitmap.Height),
                            ImageLockMode.WriteOnly, charBitmap.PixelFormat);

                        byte* ptrCharData = (byte*)charData.Scan0;

                        //Loop over each pixel in this char to be extracted
                        for (int i = 0; i < colWidth; i++)
                        {
                            for(int j = 0; j < rowHeight; j++)
                            {
                                int imgOffset = ((row * rowHeight) + j) * imgData.Stride + (((col * colWidth) + i) * bytesPerPixel);
                                int charOffset = (j * charData.Stride) + (i * bytesPerPixel);

                                //Copy the bytes for this pixel
                                for(int k = 0; k < bytesPerPixel; k++)
                                {
                                    ptrCharData[charOffset + k] = ptrImgData[imgOffset + k];
                                }
                            }
                        }

                        charBitmap.UnlockBits(charData);
                        chars[col, row] = charBitmap;
                    }
                }
            }

            img.UnlockBits(imgData);

            return chars;
        }

        public static Bitmap[,] Segment(Bitmap img, Segmentation segmentation)
        {
            //Validation: Check that the Bitmap has the dimensions listed in the Segmentation
            if(img.Width != segmentation.Width || img.Height != segmentation.Height)
            {
                throw new ArgumentException("Bitmap dimensions must match Segmentation dimensions");
            }

            //Determine the number of Bytes Per pixel in this image
            int bytesPerPixel = img.GetBitsPerPixel() / 8;

            Bitmap[,] chars = new Bitmap[segmentation.NumCols, segmentation.NumRows];

            //Lock the image for read so we can access it with pointers
            BitmapData imgData = img.LockBits(new Rectangle(0, 0, img.Width, img.Height),
                ImageLockMode.ReadOnly, img.PixelFormat);

            unsafe
            {
                byte* ptrImageData = (byte*)imgData.Scan0;

                for (int col = 0; col < chars.GetLength(0); col++)
                {
                    for(int row = 0; row < chars.GetLength(1); row++)
                    {
                        //Get the start & end indices of this char based on the segmentation points
                        int colStart = col == 0 ? 0 : segmentation.Cols[col - 1]; //If this is the first col, it starts at zero. Otherwise where the previous col ended
                        int colEnd = col == chars.GetLength(0) - 1 ? segmentation.Width - 1 : segmentation.Cols[col]; //If this is the last col, ends at width. Otherwise at the segmentation index

                        int rowStart = row == 0 ? 0 : segmentation.Rows[row - 1]; //If this is the first row, it starts at zero. Otherwise where the previous row ended
                        int rowEnd = row == chars.GetLength(1) - 1 ? segmentation.Height - 1 : segmentation.Rows[row]; //If this is the last row, ends at height. Otherwise at the segmentation index

                        //Make a new Bitmap to hold the char
                        Bitmap charBitmap = new Bitmap(colEnd + 1 - colStart, rowEnd + 1 - rowStart, img.PixelFormat);

                        //Lock image for write so we can write to it
                        BitmapData charData = charBitmap.LockBits(new Rectangle(0, 0, charBitmap.Width, charBitmap.Height),
                            ImageLockMode.WriteOnly, charBitmap.PixelFormat);

                        byte* ptrCharData = (byte*)charData.Scan0;

                        //Loop over each pixel in this char to be extracted
                        for(int pxCol = colStart; pxCol <= colEnd; pxCol++)
                        {
                            for(int pxRow = rowStart; pxRow <= rowEnd; pxRow++)
                            {
                                int imgOffset = (pxRow * imgData.Stride) + (pxCol * bytesPerPixel);
                                int charOffset = ((pxRow - rowStart) * charData.Stride) + ((pxCol - colStart) * bytesPerPixel);

                                //Copy the bytes for this pixel
                                for(int i = 0; i < bytesPerPixel; i++)
                                {
                                    ptrCharData[charOffset + i] = ptrImageData[imgOffset + i];
                                }
                            }
                        }

                        charBitmap.UnlockBits(charData);
                        chars[col, row] = charBitmap;
                    }
                }
            }

            img.UnlockBits(imgData);

            return chars;
        }

        private static string[,] Recognize(Bitmap[,] bitmaps)
        {
            Indicator.SetNcellImages(bitmaps.Length);
            string[,] result = new string[bitmaps.GetLength(0), bitmaps.GetLength(1)];
            for (int i = 0; i < bitmaps.GetLength(0); i++)
            {
                for (int j = 0; j < bitmaps.GetLength(1); j++)
                {
                    if (i == 24 & j == 4)
                    {

                    }
                    result[i, j] = Recognizer.Recognize(bitmaps[i, j], 10);
                    Indicator.IncRecognizeCellImage();
                }
            }
            return result;
        }