Java 如何使用色差检测改进BRISK算法的最佳匹配结果？

我正在将BRISK应用到我的android应用程序中。代码是：

 public boolean runBRISK(String filename1, String filename2)
        {       
            BRISK detectorAndExtractor = BRISK.create();
            
            final MatOfKeyPoint keyPointsLarge = new MatOfKeyPoint();
            final MatOfKeyPoint keyPointsSmall = new MatOfKeyPoint();
    
            Mat largeImage = Imgcodecs.imread(filename1, Imgcodecs.IMREAD_COLOR);
            Mat smallImage = Imgcodecs.imread(filename2, Imgcodecs.IMREAD_COLOR);
            
            detectorAndExtractor.detect(largeImage, keyPointsLarge);
            detectorAndExtractor.detect(smallImage, keyPointsSmall);
    
            //System.out.println("keyPoints.size() : "+keyPointsLarge.size());
            //System.out.println("keyPoints2.size() : "+keyPointsSmall.size());
    
            Mat descriptorsLarge = new Mat();
            Mat descriptorsSmall = new Mat();
    
            detectorAndExtractor.compute(largeImage, keyPointsLarge, descriptorsLarge);
            detectorAndExtractor.compute(smallImage, keyPointsSmall, descriptorsSmall);
    
            //System.out.println("descriptorsA.size() : "+descriptorsLarge.size());
            //System.out.println("descriptorsB.size() : "+descriptorsSmall.size());
    
            MatOfDMatch matches = new MatOfDMatch();
    
            DescriptorMatcher matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMINGLUT);
            matcher.match(descriptorsLarge, descriptorsSmall, matches);
    
            System.out.println("matches.size() : "+matches.size());
    
            MatOfDMatch matchesFiltered = new MatOfDMatch();
    
            List<DMatch> matchesList = matches.toList();
            List<DMatch> bestMatches= new ArrayList<DMatch>();
    
            Double max_dist = 0.0;
            Double min_dist = 100.0;
    
            for (int i = 0; i < matchesList.size(); i++)
            {
                Double dist = (double) matchesList.get(i).distance;
    
                if (dist < min_dist && dist != 0)
                {
                    min_dist = dist;
                }
    
                if (dist > max_dist)
                {
                    max_dist = dist;
                }
    
            }
    
            //System.out.println("max_dist : "+max_dist);
            //System.out.println("min_dist : "+min_dist);
    
            if(min_dist > 50 )
            {
                //System.out.println("No match found");
                //System.out.println("Just return ");
                return false;
            }
    
            double threshold = 3 * min_dist;
            double threshold2 = 2 * min_dist;
    
            if (threshold > 75)
            {
                threshold  = 75;
            }
            else if (threshold2 >= max_dist)
            {
                threshold = min_dist * 1.1;
            }
            else if (threshold >= max_dist)
            {
                threshold = threshold2 * 1.4;
            }
    
            //System.out.println("Threshold : "+threshold);
    
            for (int i = 0; i < matchesList.size(); i++)
            {
                Double dist = (double) matchesList.get(i).distance;
    
                if (dist < threshold)
                {
                    bestMatches.add(matches.toList().get(i));
                    //System.out.println(String.format(i + " best match added : %s", dist));
                }
            }
    
            matchesFiltered.fromList(bestMatches);
    
            System.out.println("matchesFiltered.size() : " + matchesFiltered.size());
    
    
            if(matchesFiltered.rows() >= 1) //TODO >= 4
            {
                System.out.println("match found");
                return true;
            }
            else
            {
                return false;
            }
        }

public boolean runBRISK（字符串filename1，字符串filename2）
{       
BRISK detectorAndExtractor=BRISK.create（）；
最终MatOfKeyPoint关键点RGE=新MatOfKeyPoint（）；
最终MatOfKeyPoint keyPointsSmall=新MatOfKeyPoint（）；
Mat largeImage=Imgcodecs.imread（文件名1，Imgcodecs.imread\u颜色）；
Mat smallImage=Imgcodecs.imread（文件名2，Imgcodecs.imread\u颜色）；
Detector和Extractor.detect（大图像，关键点大）；
Detector和Extractor.detect（小图像，关键点小）；
//System.out.println（“keyPoints.size（）：”+keyPointsLarge.size（））；
//System.out.println（“keyPoints2.size（）：”+keyPointsSmall.size（））；
Mat描述符大=新Mat（）；
材料描述符小=新材料（）；
detector和extractor.compute（大图像、关键点大、描述符大）；
detectorAndExtractor.compute（smallImage，keyPointsSmall，descriptorsmall）；
//System.out.println（“descriptorrsa.size（）：”+descriptorsragle.size（））；
//System.out.println（“descriptorsB.size（）：”+descriptorsmall.size（））；
MatOfDMatch matches=新的MatOfDMatch（）；
DescriptorMatcher matcher=DescriptorMatcher.create（DescriptorMatcher.BRUTEFORCE_HAMMINGLUT）；
matcher.match（描述符大，描述符小，匹配）；
System.out.println（“matches.size（）：”+matches.size（））；
MatOfDMatch matchesFiltered=新的MatOfDMatch（）；
List matchesList=matches.toList（）；
List bestMatches=new ArrayList（）；
双最大距离=0.0；
双最小距离=100.0；
对于（int i=0；i最大距离）
{
最大距离=距离；
}
}
//系统输出打印项次（“最大距离：+最大距离”）；
//系统输出打印项次（“最小距离：+最小距离”）；
如果（最小距离>50）
{
//System.out.println（“未找到匹配项”）；
//System.out.println（“刚刚返回”）；
返回false；
}
双阈值=3*最小距离；
双阈值2=2*最小距离；
如果（阈值>75）
{
阈值=75；
}
否则如果（阈值2>=最大距离）
{
阈值=最小距离*1.1；
}
否则如果（阈值>=最大距离）
{
阈值=阈值2*1.4；
}
//System.out.println（“阈值：+阈值”）；
对于（int i=0；i=1）//TODO>=4
{
System.out.println（“找到匹配项”）；
返回true；
}
其他的
{
返回false；
}
}

以下是图片：

图像#1和#2几乎相同，唯一的区别是颜色

问题是，当将它们与图像0进行比较时，我得到99个与图像1的最佳匹配，86个与图像2的最佳匹配。但是，图像#0和#2与主对象具有相同的颜色（深紫色）

如何添加色差检测以改进特征匹配