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() ? "是" : "否"));
    }
}