Java指纹匹配功能的完整实现代码

import java.util.arraylist;
import java.util.list;
 
/**
 * 指纹特征点实体类：存储特征点核心信息
 */
class fingerprintminutia {
    private int x;          // 特征点x坐标
    private int y;          // 特征点y坐标
    private int direction;  // 特征点方向（0-359度，简化为整数）
    private minutiatype type; // 特征点类型：端点/分叉点
 
    // 特征点类型枚举
    public enum minutiatype {
        end_point,    // 端点
        bifurcation   // 分叉点
    }
 
    public fingerprintminutia(int x, int y, int direction, minutiatype type) {
        this.x = x;
        this.y = y;
        this.direction = direction % 360; // 确保方向在0-359范围内
        this.type = type;
    }
 
    // getter方法
    public int getx() { return x; }
    public int gety() { return y; }
    public int getdirection() { return direction; }
    public minutiatype gettype() { return type; }
}
 
/**
 * 指纹匹配核心算法类
 */
public class fingerprintmatcher {
    // 距离权重（特征点坐标相似度占比）
    private static final double distance_weight = 0.6;
    // 方向权重（特征点方向相似度占比）
    private static final double direction_weight = 0.3;
    // 类型权重（特征点类型匹配占比）
    private static final double type_weight = 0.1;
    // 匹配阈值（相似度≥此值则判定匹配）
    private static final double match_threshold = 0.8;
 
    /**
     * 计算两个特征点的相似度
     * @param m1 待匹配指纹特征点
     * @param m2 模板指纹特征点
     * @return 单个特征点相似度（0-1）
     */
    private double calculateminutiasimilarity(fingerprintminutia m1, fingerprintminutia m2) {
        // 1. 计算坐标欧式距离相似度（归一化到0-1）
        double distance = math.sqrt(math.pow(m1.getx() - m2.getx(), 2) + math.pow(m1.gety() - m2.gety(), 2));
        // 假设特征点坐标范围0-500，距离越大相似度越低
        double distancesimilarity = math.max(0, 1 - distance / 500);
 
        // 2. 计算方向相似度（角度差越小相似度越高）
        int directiondiff = math.abs(m1.getdirection() - m2.getdirection());
        directiondiff = math.min(directiondiff, 360 - directiondiff); // 取最小角度差（如350度差等价于10度）
        double directionsimilarity = math.max(0, 1 - directiondiff / 180.0);
 
        // 3. 计算类型相似度（类型相同为1，不同为0）
        double typesimilarity = m1.gettype() == m2.gettype() ? 1 : 0;
 
        // 加权求和得到单个特征点相似度
        return distancesimilarity * distance_weight
                + directionsimilarity * direction_weight
                + typesimilarity * type_weight;
    }
 
    /**
     * 指纹特征点集匹配（最优匹配策略：每个待匹配点找模板中最相似的点）
     * @param targetminutiae 待匹配指纹特征点集
     * @param templateminutiae 模板指纹特征点集
     * @return 整体相似度（0-1），及是否匹配
     */
    public matchresult match(list<fingerprintminutia> targetminutiae, list<fingerprintminutia> templateminutiae) {
        // 空值/空集校验
        if (targetminutiae == null || targetminutiae.isempty() || templateminutiae == null || templateminutiae.isempty()) {
            return new matchresult(0.0, false);
        }
 
        double totalsimilarity = 0.0;
        int matchedcount = 0;
 
        // 遍历待匹配特征点，为每个点找模板中最相似的点
        for (fingerprintminutia target : targetminutiae) {
            double maxsimilarity = 0.0;
            for (fingerprintminutia template : templateminutiae) {
                double sim = calculateminutiasimilarity(target, template);
                if (sim > maxsimilarity) {
                    maxsimilarity = sim;
                }
            }
            // 仅当单特征点相似度≥0.5时，计入有效匹配
            if (maxsimilarity >= 0.5) {
                totalsimilarity += maxsimilarity;
                matchedcount++;
            }
        }
 
        // 计算整体相似度（有效匹配点的平均相似度）
        double overallsimilarity = matchedcount == 0 ? 0 : totalsimilarity / matchedcount;
        boolean ismatched = overallsimilarity >= match_threshold;
 
        return new matchresult(overallsimilarity, ismatched);
    }
 
    /**
     * 匹配结果实体类
     */
    public static class matchresult {
        private double similarity; // 整体相似度
        private boolean ismatched;  // 是否匹配
 
        public matchresult(double similarity, boolean ismatched) {
            this.similarity = similarity;
            this.ismatched = ismatched;
        }
 
        public double getsimilarity() { return similarity; }
        public boolean ismatched() { return ismatched; }
    }
 
    // 测试用例
    public static void main(string[] args) {
        fingerprintmatcher matcher = new fingerprintmatcher();
 
        // 1. 构建模板指纹特征点集（模拟真实指纹提取的特征点）
        list<fingerprintminutia> template = new arraylist<>();
        template.add(new fingerprintminutia(100, 200, 30, fingerprintminutia.minutiatype.end_point));
        template.add(new fingerprintminutia(150, 250, 60, fingerprintminutia.minutiatype.bifurcation));
        template.add(new fingerprintminutia(200, 300, 90, fingerprintminutia.minutiatype.end_point));
 
        // 2. 构建待匹配指纹1（匹配：特征点与模板高度相似）
        list<fingerprintminutia> target1 = new arraylist<>();
        target1.add(new fingerprintminutia(102, 201, 32, fingerprintminutia.minutiatype.end_point));
        target1.add(new fingerprintminutia(149, 252, 58, fingerprintminutia.minutiatype.bifurcation));
        target1.add(new fingerprintminutia(201, 301, 91, fingerprintminutia.minutiatype.end_point));
 
        // 3. 构建待匹配指纹2（不匹配：特征点差异大）
        list<fingerprintminutia> target2 = new arraylist<>();
        target2.add(new fingerprintminutia(300, 400, 120, fingerprintminutia.minutiatype.end_point));
        target2.add(new fingerprintminutia(350, 450, 150, fingerprintminutia.minutiatype.bifurcation));
        target2.add(new fingerprintminutia(400, 500, 180, fingerprintminutia.minutiatype.end_point));
 
        // 4. 执行匹配并输出结果
        matchresult result1 = matcher.match(target1, template);
        system.out.println("待匹配指纹1：");
        system.out.println("整体相似度：" + string.format("%.2f", result1.getsimilarity()));
        system.out.println("是否匹配：" + (result1.ismatched() ? "是" : "否"));
 
        matchresult result2 = matcher.match(target2, template);
        system.out.println("\n待匹配指纹2：");
        system.out.println("整体相似度：" + string.format("%.2f", result2.getsimilarity()));
        system.out.println("是否匹配：" + (result2.ismatched() ? "是" : "否"));
    }
}