0

我遇到了一个小问题，我得到了一个代码，它读取所有像素并获取像素的 RGB 颜色。但在此之前，我将图片切成块，这样我也可以计算更大的图像，而不会超出内存。这是代码：

Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);

            try {
                decoder_image = BitmapRegionDecoder.newInstance(filePath,
                        false);


            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                boolean bool_pixel = true;
                final int width = decoder_image.getWidth();
                final int height = decoder_image.getHeight();
                // Divide the bitmap into 1100x1100 sized chunks and process it.
                // This makes sure that the app will not be "overloaded"
                int wSteps = (int) Math.ceil(width / 1100.0);
                int hSteps = (int) Math.ceil(height / 1100.0);
                Rect rect = new Rect();
                for (int h = 0; h < hSteps; h++) {
                    for (int w = 0; w < wSteps; w++) {
                        int w2 = Math.min(width, (w + 1) * 1100);
                        int h2 = Math.min(height, (h + 1) * 1100);
                        rect.set(w * 1100, h * 1100, w2, h2);
                        bitmap_image = decoder_image.decodeRegion(rect,
                                null);

                        try {
                            int bWidth = bitmap_image.getWidth();
                            int bHeight = bitmap_image.getHeight();
                            int[] pixels = new int[bWidth * bHeight];
                            bitmap_image.getPixels(pixels, 0, bWidth, 0, 0,
                                    bWidth, bHeight);
                            for (int y = 0; y < bHeight; y++) {
                                for (int x = 0; x < bWidth; x++) {

                                    int index = y * bWidth + x;
                                    int R = (pixels[index] >> 16) & 0xff; //bitwise shifting
                                    int G = (pixels[index] >> 8) & 0xff;
                                    int B = pixels[index] & 0xff;
                                    total++;

                                    if (R == 255){
                                    //Save x,y position                                     
                                    }
                                    if ((G > (R+2)) && (G > (B+2))) {
                                    counter++;
                                    }
                                }
                            }
                        } finally {
                            bitmap_image.recycle();
                        }
                    }
                }
            } finally {
                decoder_image.recycle();                    
            }

这就像一个魅力。从互联网上获得了一些信息，我为自己的代码重新制作了这个。

但是我现在想要什么，那就是：当他检测到一个“完整的”红色像素（255）时，他必须显示该像素的 x,y 位置。

我认为这很容易做到，但是因为我将图像切成夹头，所以我得到了非常奇怪的 x,y 位置（我的想法）。

我将快速解释为什么我想要这个：在图像中，它们是 2 个红色像素，而这 2 个必须转换成一个矩形，但我没有得到好的 x,y 位置。

所以要弄清楚问题：如何获得红色像素的 x,y 位置。

也许很容易，但不知何故，我只是没有找到正确的位置，甚至没有靠近。我通过在 Photoshop 中打开图像来检查这一点，看看红色像素的 x、y 是什么，但我的应用程序给出了非常奇怪的坐标。

如果您需要更多信息或其他内容，请发表评论。

已经谢谢了， Bigflow

4

2 回答 2

1

坐标应该是 rect.left + x 和 rect.top + y。你已经试过了吗？

于 2012-03-29T13:22:25.863 回答
0

x 和 y 是图像中的水平和垂直像素位置，全局坐标取决于您尊重的坐标系的原点以及图像如何根据它移动。

于 2012-03-29T13:24:57.837 回答