如何在Java中检测图像纹理？机器视觉果蔬识别APP技术需求

嘿，针对你开发机器视觉应用（识别苹果/橙子）的需求，我来分享几个在Java里处理byte[]格式图像、检测纹理的实用方案：

直接对着原始byte[]处理纹理太折腾，咱们先把它转成Java标准的BufferedImage，后续所有纹理分析都基于这个对象来做：

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import javax.imageio.ImageIO;

public class ImageConverter {
    public static BufferedImage byteArrayToBufferedImage(byte[] imageBytes) throws IOException {
        try (ByteArrayInputStream bais = new ByteArrayInputStream(imageBytes)) {
            return ImageIO.read(bais);
        }
    }
}

水果的纹理差异（比如苹果细腻、橙子粗糙）可以通过两种经典算法捕捉，这里给你简化的实现代码：

1. 灰度共生矩阵（GLCM） #

GLCM会统计图像中像素灰度的空间分布关系，通过计算对比度、能量、熵这些特征值，就能量化纹理的粗细程度：

import java.awt.Color;
import java.awt.image.BufferedImage;

public class GLCMTextureAnalyzer {
    // 先把彩色图转灰度图
    private static BufferedImage toGrayscale(BufferedImage img) {
        BufferedImage grayImg = new BufferedImage(img.getWidth(), img.getHeight(), BufferedImage.TYPE_BYTE_GRAY);
        for (int x = 0; x < img.getWidth(); x++) {
            for (int y = 0; y < img.getHeight(); y++) {
                Color color = new Color(img.getRGB(x, y));
                int gray = (int) (color.getRed()*0.299 + color.getGreen()*0.587 + color.getBlue()*0.114);
                grayImg.setRGB(x, y, new Color(gray, gray, gray).getRGB());
            }
        }
        return grayImg;
    }

    // 计算GLCM的对比度特征（仅考虑水平方向相邻像素，适合快速检测）
    public static double calculateContrast(BufferedImage img) {
        BufferedImage grayImg = toGrayscale(img);
        int width = grayImg.getWidth();
        int height = grayImg.getHeight();
        int[][] glcm = new int[256][256];

        // 统计水平相邻的灰度对
        for (int x = 0; x < width - 1; x++) {
            for (int y = 0; y < height; y++) {
                int g1 = grayImg.getRGB(x, y) & 0xFF;
                int g2 = grayImg.getRGB(x+1, y) & 0xFF;
                glcm[g1][g2]++;
            }
        }

        // 计算对比度值
        double contrast = 0.0;
        int totalPairs = (width-1)*height;
        for (int i = 0; i < 256; i++) {
            for (int j = 0; j < 256; j++) {
                double prob = (double) glcm[i][j] / totalPairs;
                contrast += prob * Math.pow(i-j, 2);
            }
        }
        return contrast;
    }
}

2. 局部二值模式（LBP） #

LBP是轻量高效的纹理算法，通过对比每个像素和邻域像素的灰度值生成二进制编码，再统计编码的直方图，就能快速区分不同纹理：

import java.awt.image.BufferedImage;

public class LBPTextureAnalyzer {
    // 计算单个像素的8邻域LBP值
    private static int getLBPValue(BufferedImage grayImg, int x, int y) {
        int centerGray = grayImg.getRGB(x, y) & 0xFF;
        int lbp = 0;
        // 8个邻域的坐标偏移
        int[][] neighbors = {{-1,-1}, {-1,0}, {-1,1}, {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}};

        for (int i = 0; i < 8; i++) {
            int nx = x + neighbors[i][0];
            int ny = y + neighbors[i][1];
            // 边界处理：超出图像范围的像素用中心灰度值代替
            int neighborGray = (nx >=0 && nx < grayImg.getWidth() && ny >=0 && ny < grayImg.getHeight())
                ? (grayImg.getRGB(nx, ny) & 0xFF)
                : centerGray;
            lbp |= (neighborGray >= centerGray) ? (1 << (7 - i)) : 0;
        }
        return lbp;
    }

    // 生成LBP直方图
    public static int[] generateLBPHistogram(BufferedImage img) {
        BufferedImage grayImg = GLCMTextureAnalyzer.toGrayscale(img);
        int[] histogram = new int[256]; // 8位LBP对应256种编码
        for (int x = 0; x < grayImg.getWidth(); x++) {
            for (int y = 0; y < grayImg.getHeight(); y++) {
                int lbp = getLBPValue(grayImg, x, y);
                histogram[lbp]++;
            }
        }
        return histogram;
    }
}

拿到纹理特征后，你可以用简单的K近邻（KNN）分类器来做识别：先收集一批苹果、橙子的样本，提取它们的纹理特征作为训练集；对新图像提取特征后，找训练集中最相似的样本，判断类别。

简化的KNN实现示例：

public class SimpleFruitClassifier {
    // 计算两个LBP直方图的欧氏距离（越小越相似）
    private static double calculateDistance(int[] hist1, int[] hist2) {
        double sum = 0.0;
        for (int i = 0; i < hist1.length; i++) {
            sum += Math.pow(hist1[i] - hist2[i], 2);
        }
        return Math.sqrt(sum);
    }

    // K=3的简化分类逻辑
    public static String classify(int[] testHist, int[][] appleHists, int[][] orangeHists) {
        int appleMatches = 0;
        int orangeMatches = 0;
        double threshold = 1000.0; // 可根据你的样本调整阈值

        // 统计苹果样本中符合阈值的数量
        for (int[] hist : appleHists) {
            if (calculateDistance(testHist, hist) < threshold) {
                appleMatches++;
                if (appleMatches >=3) break;
            }
        }

        // 统计橙子样本中符合阈值的数量
        for (int[] hist : orangeHists) {
            if (calculateDistance(testHist, hist) < threshold) {
                orangeMatches++;
                if (orangeMatches >=3) break;
            }
        }

        return appleMatches > orangeMatches ? "苹果" : "橙子";
    }
}

1. 调用byteArrayToBufferedImage把你的byte[]转成BufferedImage
2. 用GLCM或LBP算法提取纹理特征
3. 传入分类器判断是苹果还是橙子

内容的提问来源于stack exchange，提问作者user9478379