Java中的图像规范化

我一直在从事手指图像处理，目前我想做标准化

我在网上研究过这个链接

标准化的思想在于改变每个像素的强度，以便将整个图像的均值和方差改变为一些预定义的值

你能给我推荐一些java代码或算法的例子吗

编辑：

我将图像像素的

平均值

和

方差

考虑在内，用于图像标准化：

这是我的密码：

public class NormalizeHistMeanVariance {
private static BufferedImage original, normalize;

public static void main(String[] args) throws IOException {
    final int N = 256; // Number of graylevels
    final int M = 250; // Max value in histogram for displaying purposes
    int nrows, ncols, size, in_img[][], out_img[][];
    int i, j, max, maxgray;
    double hist[] = new double[N], norm, mean, var, tmp;

    String f1 = "E:/single.jpg";
    String f2 = "E:/normImg";
    File original_f = new File(f1);
    original = ImageIO.read(original_f);

    Histogram histogram = new Histogram(original);
    in_img = histogram.getPixels(original);

    nrows = in_img.length;
    ncols = in_img[0].length;
    size = in_img.length * in_img[0].length;

    // Compute average gray and histogram
    for (i = 0; i < N; i++)
        hist[i] = 0;
    mean = 0;
    for (i = 0; i < nrows; i++) {
        for (j = 0; j < ncols; j++) {
            hist[in_img[i][j]]++;
            mean += in_img[i][j];
        }
    }
    mean /= size;
    System.out.println("Mean graylevel = " + mean);

    // Compute variance
    var = 0;
    for (i = 0; i < nrows; i++) {
        for (j = 0; j < ncols; j++) {
            tmp = in_img[i][j] - mean;
            var += tmp * tmp;
        }
    }
    var = Math.sqrt(var / (size));
    System.out.println("Variance = " + var);

    max = maxgray = 0;
    for (i = 0; i < N; i++) {
        if (max < hist[i]) {
            max = (int) hist[i];
            maxgray = i;
        }
    }
    System.out.println("Max count " + max + " (graylevel = " + maxgray
            + " )");

    // Normalize to M for better display effect
    norm = (double) M / maxgray;
    System.out.println("Norm = " + norm);

    out_img = new int[nrows][ncols];
    for (int x = 0; x < in_img.length; x++) {
        for (int y = 0; y < in_img[0].length; y++) {
            out_img[x][y] = (int) (in_img[x][y] * norm);
        }
    }
    normalize = ImageUtils.CreateImagefromIntArray(out_img);

    writeImage(f2);
}

private static void writeImage(String output) throws IOException {
    File file = new File(output + ".jpg");
    ImageIO.write(normalize, "jpg", file);
}
}

公共类规范化HistMeans方差{
私有静态缓冲区原始图像，规范化；
公共静态void main（字符串[]args）引发IOException{
final int N=256；//灰度级数
final int M=250；//用于显示的直方图中的最大值
整数nrows、ncols、大小、输入img[]、输出img[]；
int i，j，max，maxgray；
双历史[]=新双[N]，范数，均值，var，tmp；
字符串f1=“E:/single.jpg”；
字符串f2=“E:/norimg”；
文件原始\u f=新文件（f1）；
原件=图像读取（原件）；
直方图=新直方图（原始）；
in_img=直方图.getPixels（原始）；
nrows=英寸长度；
ncols=in_img[0]。长度；
大小=英寸。长度*英寸[0]。长度；
//计算平均灰度和直方图
对于（i=0；i

---

我想要的是像这样标准化后的平滑图像。但我没有得到想要的结果。有人能帮我吗？

这是一个执行图像规范化的Java项目，包括以下代码：

处理图像时，使用的术语是（均方根）对比度和亮度，而不是方差和平均值。 （请确保指定使用哪种对比度定义。）

本页中的信息似乎暗示这是关于直方图均衡化的。

---

关于wikipedia的信息：

这里是一个Java项目，用于图像标准化，包括代码：

处理图像时，使用的术语是（均方根）对比度和亮度，而不是方差和平均值。 （请确保指定使用哪种对比度定义。）

本页中的信息似乎暗示这是关于直方图均衡化的。

---

关于维基百科的信息：

我可以帮助您实现本文中使用的图像规范化

尝试使用，在下一个版本（1.2）中，我将在框架中编写图像规范化代码

---

Zernike Moments也准备好了，就像Hu Moments一样，如果你想像本文那样做。

我可以帮助你实现本文中使用的图像标准化

尝试使用，在下一个版本（1.2）中，我将在框架中编写图像规范化代码

---

Zernike Moments也像Hu Moments一样准备好了，如果你想像本文那样做。

因此，你不需要使用直方图来执行此筛选

// Parameters to ImageNormalization
float mean = 160;
float variance = 150;

int width = fastBitmap.getWidth();
int height = fastBitmap.getHeight();

float globalMean = Mean(fastBitmap);
float globalVariance = Variance(fastBitmap, globalMean);

for (int i = 0; i < height; i++) {
    for (int j = 0; j < width; j++) {

        int g = fastBitmap.getGray(i, j);
        float common = (float)Math.sqrt((variance * (float)Math.pow(g - globalMean, 2)) / globalVariance);
        int n = 0;
        if (g > globalMean){
            n = (int)(mean + common);
        }
        else{
            n = (int)(mean - common);
        }

        n = n > 255 ? 255 : n;
        n = n < 0 ? 0 : n;

        fastBitmap.setGray(i, j, n);
    }
}

private float Mean(FastBitmap fb){
    int height = fb.getHeight();
    int width = fb.getWidth();

    float mean = 0;
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            mean += fastBitmap.getGray(i, j);
        }
    }
    return mean / (width * height);
}

private float Variance(FastBitmap fb, float mean){
    int height = fb.getHeight();
    int width = fb.getWidth();

    float sum = 0;
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            sum += Math.pow(fastBitmap.getGray(i, j) - mean, 2);
        }
    }
    return sum / (float)((width * height) - 1);
}

//用于图像规范化的参数
浮动平均值=160；
浮动方差=150；
int-width=fastBitmap.getWidth（）；
int height=fastBitmap.getHeight（）；
浮点全局平均值=平均值（快速位图）；
float globalVariance=方差（快速位图、全局平均）；
对于（int i=0；i全局平均值）{
n=（int）（平均值+普通值）；
}
否则{
n=（int）（平均值-普通值）；
}
n=n>255？255:n；
n=n<0？0:n；
setGray（i，j，n）；
}
}
私人浮动平均值（快速位图fb）{
int height=fb.getHeight（）；
int width=fb.getWidth（）；
浮动平均值=0；
对于（int i=0；i

因此，您不需要使用直方图来执行此筛选

// Parameters to ImageNormalization
float mean = 160;
float variance = 150;

int width = fastBitmap.getWidth();
int height = fastBitmap.getHeight();

float globalMean = Mean(fastBitmap);
float globalVariance = Variance(fastBitmap, globalMean);

for (int i = 0; i < height; i++) {
    for (int j = 0; j < width; j++) {

        int g = fastBitmap.getGray(i, j);
        float common = (float)Math.sqrt((variance * (float)Math.pow(g - globalMean, 2)) / globalVariance);
        int n = 0;
        if (g > globalMean){
            n = (int)(mean + common);
        }
        else{
            n = (int)(mean - common);
        }

        n = n > 255 ? 255 : n;
        n = n < 0 ? 0 : n;

        fastBitmap.setGray(i, j, n);
    }
}

private float Mean(FastBitmap fb){
    int height = fb.getHeight();
    int width = fb.getWidth();

    float mean = 0;
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            mean += fastBitmap.getGray(i, j);
        }
    }
    return mean / (width * height);
}

private float Variance(FastBitmap fb, float mean){
    int height = fb.getHeight();
    int width = fb.getWidth();

    float sum = 0;
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            sum += Math.pow(fastBitmap.getGray(i, j) - mean, 2);
        }
    }
    return sum / (float)((width * height) - 1);
}

//用于图像规范化的参数
浮动平均值=160；
浮动方差=150；
int-width=fastBitmap.getWidth（）；
int height=fastBitmap.getHeight（）；
浮点全局平均值=平均值（快速位图）；
float globalVariance=方差（快速位图、全局平均）；
对于（int i=0；i