Java 如何将白色背景更改为黑色

在最近的一个项目中，我必须处理图像，但由于这对我来说是新的，我有点迷路了

我需要用常规扫描设备扫描手部。我可以完成这个，但背景是白色的，我需要它是黑色的。经过几天的研究，找到了改变颜色的方法，我只得到了一张用ms颜料剪切粘贴的图像

原始图像：

测试：

我需要的是这样的东西：

我正在尝试使用，框架。要查看我需要的SETP，我使用gimp、marving editor、斐济应用程序（但没有得到我想要的结果）。
我想我需要的是转换为灰度，应用某种阈值，但在一定的颜色范围内使用alpha颜色（但我没有找到方法，只对二值图像使用阈值），然后使用阈值灰度图像将遮罩应用到原始图像中，但我也不知道如何直接在Java中实现，或者使用我上面提到的任何框架。
任何帮助都将不胜感激

更新 基于m69所说的，我尝试使用luminiscent值播放，从rgb转换为hsl。我只设置了较暗的颜色，这些颜色会变亮

首先尝试使用0.5的光阈值：

第二次尝试，阈值为0.9灯光

浮动阈值=0.5f；
对于（int y=0；y 0 | | g2>0）{
g=g1*g2/数学最大值（g1，g2）；
}
如果（b1>0 | | b2>0）{
b=b1*b2/数学最大值（b1，b2）；
}
图像.setIntColor（x，y，r，g，b）；
}
}

工作几乎很好，但有一点小细节我无法解决。我们的想法是混合图像，就像在gimp中我做的那样：将灰度遮罩放在上层，将“颜色到alpha”函数应用于白色，得到以下结果：

使用我为marving framework编写的算法，我得到了下一幅图像：

不同的是，当原始图像上有更多的白色时，我的算法不能降低强度颜色，通过比较两幅图像可以看到这种效果。你知道怎么处理吗？这是在gimp中应用层组合后的图像结果：

---

你最好的选择是进入photo shop或GIMP，使用快速蒙版功能画出或画出你想要的，你可以得到非常详细的像素，然后退出快速蒙版模式，确保白色是你的行进蚂蚁周围的部分，并将其删除。继续，用背景填充一层黑色。你可能已经在边缘使用了一个轻微的羽毛，使其自然融合。关于如何做到这一点，还有更多具体的教程，但这就是我的方法。

您可能应该首先将RGB转换为HSL（色调、饱和度、亮度/亮度），然后对亮度应用曲线，以便高于某个级别（太亮）的值再次逐渐变回黑色。在亮度下降之前，亮度到底应该沿着对角线到达哪一点取决于照片的亮度和对比度。（我猜这些可能是图形框架中的标准函数。）

下面是两个应用于亮度的曲线示例，以演示您将获得的结果类型：

---

该方法取决于您分析的目的。第一种方法会影响整个图像，因此会更改手掌的纹理！第二种方法只影响手部边界

这两种方法都是使用

输入：

import marvin.image.MarvinImage;
import marvin.io.MarvinImageIO;

public class ScanTest {
    public static void main(String[] args) {
        MarvinImage image = MarvinImageIO.loadImage("./res/scan.jpg");
        int r,g,b;
        for(int y=0; y<image.getHeight(); y++){
            for(int x=0; x<image.getWidth(); x++){
                r = image.getIntComponent0(x, y);
                g = image.getIntComponent1(x, y);
                b = image.getIntComponent2(x, y);

                int gray = (int)((0.22*r)+(0.7*g)+(0.08*b));
                double t = transform(gray, 1.3);
                image.setIntColor(x, y, (int)(r*t), (int)(g*t), (int)(b*t));    
            }
        }
        MarvinImageIO.saveImage(image, "./res/scan_out.jpg");       
    }

    private static double transform(int gray, double brightness){
        if(gray < 127){
            return brightness;
        }
        else{
            return (1-((double)(gray-127)/128))*brightness;
        }
    }
}

public class ScanTest {
    public static void main(String[] args) {
        MarvinImage image = MarvinImageIO.loadImage("./res/scan.jpg");
        int r,g,b;
        int rgb[] = new int[1];
        double hsv[];
        for(int y=0; y<image.getHeight(); y++){
            for(int x=0; x<image.getWidth(); x++){
                r = image.getIntComponent0(x, y);
                g = image.getIntComponent1(x, y);
                b = image.getIntComponent2(x, y);
                rgb[0] = image.getIntColor(x, y);
                hsv = MarvinColorModelConverter.rgbToHsv(rgb);

                if(r >= 235 && g >= 235 && b >=235){
                    image.setIntColor(x, y, 0,0,0);
                }
                else if(hsv[1] <= 0.12 && hsv[2] >= 0.6){
                    double diff = 1-hsv[2];
                    if(diff > 0.02){
                        diff = Math.max(diff,0.2);
                    }
                    diff*=3;
                    image.setIntColor(x, y, (int)(r*diff), (int)(g*diff*0.75), (int)(b*diff*0.75));
                }
            }
        }
        MarvinImageIO.saveImage(image, "./res/scan_out.jpg");       
    }
}

APROACH 1:

import marvin.image.MarvinImage;
import marvin.io.MarvinImageIO;

public class ScanTest {
    public static void main(String[] args) {
        MarvinImage image = MarvinImageIO.loadImage("./res/scan.jpg");
        int r,g,b;
        for(int y=0; y<image.getHeight(); y++){
            for(int x=0; x<image.getWidth(); x++){
                r = image.getIntComponent0(x, y);
                g = image.getIntComponent1(x, y);
                b = image.getIntComponent2(x, y);

                int gray = (int)((0.22*r)+(0.7*g)+(0.08*b));
                double t = transform(gray, 1.3);
                image.setIntColor(x, y, (int)(r*t), (int)(g*t), (int)(b*t));    
            }
        }
        MarvinImageIO.saveImage(image, "./res/scan_out.jpg");       
    }

    private static double transform(int gray, double brightness){
        if(gray < 127){
            return brightness;
        }
        else{
            return (1-((double)(gray-127)/128))*brightness;
        }
    }
}

public class ScanTest {
    public static void main(String[] args) {
        MarvinImage image = MarvinImageIO.loadImage("./res/scan.jpg");
        int r,g,b;
        int rgb[] = new int[1];
        double hsv[];
        for(int y=0; y<image.getHeight(); y++){
            for(int x=0; x<image.getWidth(); x++){
                r = image.getIntComponent0(x, y);
                g = image.getIntComponent1(x, y);
                b = image.getIntComponent2(x, y);
                rgb[0] = image.getIntColor(x, y);
                hsv = MarvinColorModelConverter.rgbToHsv(rgb);

                if(r >= 235 && g >= 235 && b >=235){
                    image.setIntColor(x, y, 0,0,0);
                }
                else if(hsv[1] <= 0.12 && hsv[2] >= 0.6){
                    double diff = 1-hsv[2];
                    if(diff > 0.02){
                        diff = Math.max(diff,0.2);
                    }
                    diff*=3;
                    image.setIntColor(x, y, (int)(r*diff), (int)(g*diff*0.75), (int)(b*diff*0.75));
                }
            }
        }
        MarvinImageIO.saveImage(image, "./res/scan_out.jpg");       
    }
}

根据用户m69的建议，基于灰度值的颜色转换

输出：

import marvin.image.MarvinImage;
import marvin.io.MarvinImageIO;

public class ScanTest {
    public static void main(String[] args) {
        MarvinImage image = MarvinImageIO.loadImage("./res/scan.jpg");
        int r,g,b;
        for(int y=0; y<image.getHeight(); y++){
            for(int x=0; x<image.getWidth(); x++){
                r = image.getIntComponent0(x, y);
                g = image.getIntComponent1(x, y);
                b = image.getIntComponent2(x, y);

                int gray = (int)((0.22*r)+(0.7*g)+(0.08*b));
                double t = transform(gray, 1.3);
                image.setIntColor(x, y, (int)(r*t), (int)(g*t), (int)(b*t));    
            }
        }
        MarvinImageIO.saveImage(image, "./res/scan_out.jpg");       
    }

    private static double transform(int gray, double brightness){
        if(gray < 127){
            return brightness;
        }
        else{
            return (1-((double)(gray-127)/128))*brightness;
        }
    }
}

public class ScanTest {
    public static void main(String[] args) {
        MarvinImage image = MarvinImageIO.loadImage("./res/scan.jpg");
        int r,g,b;
        int rgb[] = new int[1];
        double hsv[];
        for(int y=0; y<image.getHeight(); y++){
            for(int x=0; x<image.getWidth(); x++){
                r = image.getIntComponent0(x, y);
                g = image.getIntComponent1(x, y);
                b = image.getIntComponent2(x, y);
                rgb[0] = image.getIntColor(x, y);
                hsv = MarvinColorModelConverter.rgbToHsv(rgb);

                if(r >= 235 && g >= 235 && b >=235){
                    image.setIntColor(x, y, 0,0,0);
                }
                else if(hsv[1] <= 0.12 && hsv[2] >= 0.6){
                    double diff = 1-hsv[2];
                    if(diff > 0.02){
                        diff = Math.max(diff,0.2);
                    }
                    diff*=3;
                    image.setIntColor(x, y, (int)(r*diff), (int)(g*diff*0.75), (int)(b*diff*0.75));
                }
            }
        }
        MarvinImageIO.saveImage(image, "./res/scan_out.jpg");       
    }
}

来源：

import marvin.image.MarvinImage;
import marvin.io.MarvinImageIO;

public class ScanTest {
    public static void main(String[] args) {
        MarvinImage image = MarvinImageIO.loadImage("./res/scan.jpg");
        int r,g,b;
        for(int y=0; y<image.getHeight(); y++){
            for(int x=0; x<image.getWidth(); x++){
                r = image.getIntComponent0(x, y);
                g = image.getIntComponent1(x, y);
                b = image.getIntComponent2(x, y);

                int gray = (int)((0.22*r)+(0.7*g)+(0.08*b));
                double t = transform(gray, 1.3);
                image.setIntColor(x, y, (int)(r*t), (int)(g*t), (int)(b*t));    
            }
        }
        MarvinImageIO.saveImage(image, "./res/scan_out.jpg");       
    }

    private static double transform(int gray, double brightness){
        if(gray < 127){
            return brightness;
        }
        else{
            return (1-((double)(gray-127)/128))*brightness;
        }
    }
}

public class ScanTest {
    public static void main(String[] args) {
        MarvinImage image = MarvinImageIO.loadImage("./res/scan.jpg");
        int r,g,b;
        int rgb[] = new int[1];
        double hsv[];
        for(int y=0; y<image.getHeight(); y++){
            for(int x=0; x<image.getWidth(); x++){
                r = image.getIntComponent0(x, y);
                g = image.getIntComponent1(x, y);
                b = image.getIntComponent2(x, y);
                rgb[0] = image.getIntColor(x, y);
                hsv = MarvinColorModelConverter.rgbToHsv(rgb);

                if(r >= 235 && g >= 235 && b >=235){
                    image.setIntColor(x, y, 0,0,0);
                }
                else if(hsv[1] <= 0.12 && hsv[2] >= 0.6){
                    double diff = 1-hsv[2];
                    if(diff > 0.02){
                        diff = Math.max(diff,0.2);
                    }
                    diff*=3;
                    image.setIntColor(x, y, (int)(r*diff), (int)(g*diff*0.75), (int)(b*diff*0.75));
                }
            }
        }
        MarvinImageIO.saveImage(image, "./res/scan_out.jpg");       
    }
}

导入marvin.image.MarvinImage；
导入marvin.io.MarvinImageIO；
公共类扫描测试{
公共静态void main（字符串[]args）{
MarvinImage=MarvinImageIO.loadImage（“./res/scan.jpg”）；
int r，g，b；
对于（int y=0；y 0.02）{
差异=数学最大值（差异，0.2）；
}
差值*=3；
setIntColor（x，y，（int）（r*diff），（int）（g*diff*0.75），（int）（b*diff*0.75））；
}
}
}
MarvinImageIO.saveImage（image，“./res/scan_out.jpg”）；
}
}

这似乎是一个非常愚蠢的建议，但是你能打开扫描仪盖扫描你的手吗？使用白色背景的唯一原因是扫描仪的内盖是白色的，并且反射来自扫描仪本身的光线。如果你打开盖子，在黑暗的房间里扫描你的手，你的效果应该非常接近你提到的脚的照片

---

这不是一个软件解决方案，但它可能会让你更接近你想要的结果。这也有助于解决食指和中指的过饱和问题。

谢谢你的回答，但我需要软件自动完成。我认为白色边框是因为在曲线的临界点处使用了方向的突然变化，而不是像我在示例中所做的圆形弯曲。检查您的框架是否有任何方法来创建亮度样条曲线，或者使用圆的一部分或其他东西滚动您自己的曲线。如果您仍在处理此项目，并且希望进一步讨论，您可以在ImageJ论坛上发布此内容：。那里有相当多的图像处理专家，他们可能会对你的分析非常感兴趣，并提供建议和努力。没有人，嘴唇张开，仍然在白色背景下扫描，但感谢你的告别。这很奇怪，我昨晚确实用扫描仪做了一个测试，结果成功了。你是在暗室里打开盖子进行扫描的吗？今晚晚些时候我会发布我的一些照片。