coco
20 KiB
20 KiB
排卵试纸识别技术实现方案
版本: 1.0 | 日期: 2026-07-13
一、总体架构
┌──────────────────────────────────────────────────────────────┐
│ CameraX ImageAnalysis (RGBA_8888, 每帧回调) │
│ ↓ │
│ OvImageAnalyzer.analyze(ImageProxy) │
│ ├─ ImageProxy → OpenCV Mat (RGBA) │
│ ├─ StripLocator.locate() → 试纸定位 │
│ │ ├─ 找到两个绿色定位块 │
│ │ ├─ 旋转矫正 │
│ │ ├─ 找到 C线 / T线 / 白块 区域 │
│ │ └─ 在原图上绘制标记框（无论成功与否都绘制） │
│ ├─ 定位成功 → FeatureExtractor.extract() → 60维特征向量 │
│ │ └─ 存入内存数组 (容量: 15) │
│ ├─ Mat → Bitmap → 返回 UI 显示 │
│ └─ 异步处理: 上一帧未处理完 → 跳过当前帧（直接返回原图） │
│ │
│ 当累积到 15 组特征: │
│ ├─ 每组调用 OvRandomForest.score() → 5分类概率 → argmax │
│ ├─ 15个结果取众数 (mode) → 最终结果 │
│ ├─ 停止摄像头采集 │
│ └─ UI 显示最终结果 │
└──────────────────────────────────────────────────────────────┘
分类结果映射
| index | 含义 | 对应 hCG 浓度 |
|---|---|---|
| 0 | 阴性 | 0 |
| 1 | 也算阴性 | 10 |
| 2 | 阳性 | 25 |
| 3 | 阳性 | 50 |
| 4 | 强阳 | 75, 100 |
二、项目模块划分
app/src/main/java/com/pinkbear/pinkov/
├── opencv/ # OpenCV 3.0 Java 封装
│ └── org/opencv/
│ ├── core/ (Mat, Scalar, Rect, Point, Size, Core, CvType)
│ ├── imgproc/ (Imgproc)
│ └── android/ (Utils — matToBitmap / bitmapToMat)
├── processing/
│ ├── ImageConverter.kt # ImageProxy ↔ Mat ↔ Bitmap
│ ├── StripLocator.kt # 试纸定位（核心）
│ └── FeatureExtractor.kt # 60维特征提取
├── classifier/
│ └── OvRandomForest.kt # 随机森林分类器
├── ui/
│ ├── scan/
│ │ ├── OvImageAnalyzer.kt # CameraX 分析器
│ │ ├── ScanPage.kt # 扫描页面
│ │ └── ScanViewModel.kt # 扫描状态管理
│ └── ...
三、模块详细设计
3.1 OpenCV 集成
来源: prostate_DataAcq1/openCVLibrary300/src/main/java/org/opencv/
操作: 将 org.opencv.core, org.opencv.imgproc, org.opencv.android.Utils 的 Java 源码复制到 Pink 项目。
不需要的包（Camera部分，由 CameraX 替代）:
org.opencv.android.CameraBridgeViewBaseorg.opencv.android.JavaCameraView
不需要 Gradle 依赖，纯 Java 源码集成。
3.2 图像格式转换 (ImageConverter.kt)
object ImageConverter {
/**
* CameraX ImageProxy (RGBA_8888) → OpenCV Mat (CV_8UC4)
*/
fun imageProxyToMat(image: ImageProxy): Mat {
val buffer = image.planes[0].buffer
val bytes = ByteArray(buffer.remaining())
buffer.get(bytes)
val mat = Mat(image.height, image.width, CvType.CV_8UC4)
mat.put(0, 0, bytes)
return mat
}
/**
* OpenCV Mat (RGBA) → Android Bitmap
*/
fun matToBitmap(mat: Mat): Bitmap {
val bitmap = Bitmap.createBitmap(mat.width(), mat.height(), Bitmap.Config.ARGB_8888)
Utils.matToBitmap(mat, bitmap)
return bitmap
}
}
3.3 试纸定位器 (StripLocator.kt)
仅支持绿色排卵试纸。基于 ImageLocationOvulation.GetPositions() 移植。
3.3.1 数据结构
data class LocationResult(
val success: Boolean,
val leftImg: Mat?, // C线区域 (RGB)
val rightImg: Mat?, // T线区域 (RGB), 阴性时为 null
val wbImg: Mat?, // 白色参考块 (RGB)
val isNegative: Boolean, // 是否阴性（只有 C 线）
val definition: Double, // 清晰度评分
val errorCode: Int, // 0=成功, 非0=失败
val annotatedMat: Mat // 绘制了标记框的结果图像
)
3.3.2 定位算法 (共 11 步)
输入: Mat (RGBA, 完整相机帧), 无 ROI 限制
步骤1: 预处理
RGBA → RGB (丢弃 Alpha 通道)
中值滤波 (5x5, 核大小 5)
步骤2: 找到两个绿色定位块
RGB → HSV (COLOR_RGB2HSV)
提取 S 通道
OTSU 二值化 (THRESH_BINARY | THRESH_OTSU)
形态学开运算 (MORPH_OPEN, 核大小 15x15)
步骤3: 验证定位块
查找轮廓 (RETR_EXTERNAL, CHAIN_APPROX_SIMPLE)
期望: 恰好 2 个轮廓
验证面积比: 1.5 ≤ maxArea / secondArea ≤ 4.5
验证宽高比: 4.25 ≤ whRatio ≤ 13.5
验证边界: 不超出图像范围
步骤4: 判定试纸颜色 (仅接受绿色)
在大定位块中心取正方形区域 (边长 = 半高)
转 HSV, 计算 H 通道均值 meanH 和标准差 stddevH
条件: stddevH < 22.5 且 meanH ∈ [30.5, 85.0]
不满足 → 返回失败 (errorCode = -1)
步骤5: 计算旋转角度
确定大定位块在左还是右
计算旋转角度 angle
计算中心点距离 distRadio
距离比例系数: 1.0 ~ 1.65
动态调整偏移系数: 1.1 ~ 1.25
步骤6: 旋转矫正
构建旋转矩形 ROI (覆盖两定位块之间的白色区域)
getRotationMatrix2D + warpAffine
提取矫正后 G 通道
步骤7: 找到 C 线和 T 线
G 通道: 中值滤波(3x3) + 高斯模糊(5x5)
自适应二值化 (ADAPTIVE_THRESH_MEAN_C, blockSize=37, C=4)
查找轮廓
多层筛选:
RightBottomX ∈ [15%, 95%] 图像宽度
LeftTopX ∈ [5%, 90%] 图像宽度
Rectangularity ∈ [0.30, 1.15]
Width ∈ [4.5%, 20%] 图像宽度
Height ∈ [65%, 110%] 图像高度
按 CenterX 排序
步骤8: 处理识别结果
情况A: 2 个轮廓 → C线 + T线 都存在 (正常有反应)
leftImg = 左侧轮廓, rightImg = 右侧轮廓
isNegative = false
情况B: 1 个轮廓 → 只有 C线 (阴性)
判断轮廓在左侧还是右侧
人造另一个 T 线区域 (偏移 C 线位置 4×宽度)
isNegative = true
情况C: 0 个轮廓 → C线和T线都不存在 → 失败
情况D: C线不存在 → 轮廓在错误位置 → 失败
步骤9: 提取三个 ROI 区域
leftImg: C 线区域 (控制线)
rightImg: T 线区域 (测试线)
wbImg: C线中心附近取白块区域 (白平衡参考)
步骤10: 清晰度评估
Scharr 算子 (CV_16S, 1, 0 和 0, 1)
absdiff + add → 梯度幅值
逐行分析亮度变化 → 清晰度值
步骤11: 绘制标记框
在原图上绘制:
- 绿色 ROI 外框
- 定位块轮廓 (红色)
- C线/T线矩形框
无论成功与否都返回带标记的图像
输出: LocationResult
3.3.3 关键移植表
| 旧项目代码 (Java) | 新项目 (Kotlin) |
|---|---|
ImageLocationOvulation.GetPositions() |
StripLocator.locate() |
ContourGf |
Kotlin data class ContourGf |
ContourSelector.CalContoursGf() |
StripLocator 内部方法 |
ContourSelector.SelectContour() |
Kotlin 重写，List.filter |
ContourSelector.SortContoursByGf() |
Kotlin sortedBy |
CalImgDefinition() (Scharr) |
直接移植 |
JudgePaperColor() |
StripLocator 内部方法，仅检查绿色 |
DrawRect() |
StripLocator.drawAnnotations() |
3.4 特征提取器 (FeatureExtractor.kt)
3.4.1 特征说明
根据 ov_alg.txt，仅保留 HSV 和灰度特征，删除所有 RGB 和 Lab 特征。
每个区域提取:
| 类别 | 通道 | 统计量 | 数量 |
|---|---|---|---|
| HSV | H, S, V | mean (均值) | 3 |
| HSV | H, S, V | stddev (标准差) | 3 |
| HSV | H, S, V | hist (直方图峰值) | 3 |
| HSV | H, S, V | max (最大值) | 3 |
| HSV | H, S, V | min (最小值) | 3 |
| HSV 小计 | 15 | ||
| Gray | - | mean (均值) | 1 |
| Gray | - | stddev (标准差) | 1 |
| Gray | - | hist (直方图峰值) | 1 |
| Gray | - | max (最大值) | 1 |
| Gray | - | min (最小值) | 1 |
| Gray 小计 | 5 |
总计: 3 个区域 × (15 HSV + 5 Gray) = 60 维特征
3.4.2 精确特征顺序 (必须与训练数据列顺序一致)
索引 特征名
[0] left_block_H
[1] left_block_S
[2] left_block_V
[3] left_block_H_stddev
[4] left_block_S_stddev
[5] left_block_V_stddev
[6] left_block_H_hist
[7] left_block_S_hist
[8] left_block_V_hist
[9] left_block_H_max
[10] left_block_S_max
[11] left_block_V_max
[12] left_block_H_min
[13] left_block_S_min
[14] left_block_V_min
[15] right_block_H
[16] right_block_S
[17] right_block_V
[18] right_block_H_stddev
[19] right_block_S_stddev
[20] right_block_V_stddev
[21] right_block_H_hist
[22] right_block_S_hist
[23] right_block_V_hist
[24] right_block_H_max
[25] right_block_S_max
[26] right_block_V_max
[27] right_block_H_min
[28] right_block_S_min
[29] right_block_V_min
[30] whiteBlock_H
[31] whiteBlock_S
[32] whiteBlock_V
[33] whiteBlock_H_stddev
[34] whiteBlock_S_stddev
[35] whiteBlock_V_stddev
[36] whiteBlock_H_hist
[37] whiteBlock_S_hist
[38] whiteBlock_V_hist
[39] whiteBlock_H_max
[40] whiteBlock_S_max
[41] whiteBlock_V_max
[42] whiteBlock_H_min
[43] whiteBlock_S_min
[44] whiteBlock_V_min
[45] left_grayValue
[46] left_grayStddevValue
[47] left_grayHist
[48] left_grayMax
[49] left_grayMin
[50] right_grayValue
[51] right_grayStddevValue
[52] right_grayHist
[53] right_grayMax
[54] right_grayMin
[55] white_grayValue
[56] white_grayStddevValue
[57] white_grayHist
[58] white_grayMax
[59] white_grayMin
3.4.3 实现
class FeatureExtractor {
fun extract(leftImg: Mat, rightImg: Mat, wbImg: Mat): FloatArray {
val features = FloatArray(60)
// left block HSV: [0-14]
extractBlockHsv(leftImg, features, 0)
// right block HSV: [15-29]
extractBlockHsv(rightImg, features, 15)
// white block HSV: [30-44]
extractBlockHsv(wbImg, features, 30)
// left block gray: [45-49]
extractBlockGray(leftImg, features, 45)
// right block gray: [50-54]
extractBlockGray(rightImg, features, 50)
// white block gray: [55-59]
extractBlockGray(wbImg, features, 55)
return features
}
private fun extractBlockHsv(mat: Mat, features: FloatArray, offset: Int) {
val hsv = Mat()
Imgproc.cvtColor(mat, hsv, Imgproc.COLOR_RGB2HSV_FULL)
// mean + stddev
val mean = MatOfDouble()
val stddev = MatOfDouble()
Core.meanStdDev(hsv, mean, stddev)
features[offset + 0] = mean.toArray()[0].toFloat() // H mean
features[offset + 1] = mean.toArray()[1].toFloat() // S mean
features[offset + 2] = mean.toArray()[2].toFloat() // V mean
features[offset + 3] = stddev.toArray()[0].toFloat() // H stddev
features[offset + 4] = stddev.toArray()[1].toFloat() // S stddev
features[offset + 5] = stddev.toArray()[2].toFloat() // V stddev
// histogram peaks
for (ch in 0..2) {
val hist = Mat()
Imgproc.calcHist(
listOf(hsv), MatOfInt(ch), Mat(),
hist, MatOfInt(255), MatOfFloat(0f, 255f)
)
val mm = Core.minMaxLoc(hist)
features[offset + 6 + ch] = mm.maxLoc.y.toFloat()
hist.release()
}
// minMaxLoc
val channels = ArrayList<Mat>()
Core.split(hsv, channels)
for (ch in 0..2) {
val mm = Core.minMaxLoc(channels[ch])
features[offset + 9 + ch] = mm.maxVal.toFloat() // max
features[offset + 12 + ch] = mm.minVal.toFloat() // min
channels[ch].release()
}
hsv.release()
}
private fun extractBlockGray(mat: Mat, features: FloatArray, offset: Int) {
val gray = Mat()
Imgproc.cvtColor(mat, gray, Imgproc.COLOR_RGB2GRAY)
// mean + stddev
val mean = MatOfDouble()
val stddev = MatOfDouble()
Core.meanStdDev(gray, mean, stddev)
features[offset + 0] = mean.toArray()[0].toFloat()
features[offset + 1] = stddev.toArray()[0].toFloat()
// histogram peak
val hist = Mat()
Imgproc.calcHist(
listOf(gray), MatOfInt(0), Mat(),
hist, MatOfInt(255), MatOfFloat(0f, 255f)
)
val histMm = Core.minMaxLoc(hist)
features[offset + 2] = histMm.maxLoc.y.toFloat()
hist.release()
// minMaxLoc
val mm = Core.minMaxLoc(gray)
features[offset + 3] = mm.maxVal.toFloat()
features[offset + 4] = mm.minVal.toFloat()
gray.release()
}
}
3.5 随机森林分类器 (OvRandomForest.kt)
来源: C:\Users\hukou\Documents\pailuan\master\clf\ov_rtree50_f20_20260708.java
算法: Random Forest, 50 棵树, min_samples_leaf=20
输入: 60 维特征向量 (DoubleArray(60))
输出: 5 分类概率分布 (DoubleArray(5))
准确率: ~99.3%
object OvRandomForest {
/**
* 对输入特征进行评分
* @param input 60 维特征向量
* @return 5 分类概率分布 [class0, class1, class2, class3, class4]
*/
fun score(input: DoubleArray): DoubleArray {
// 直接从 ov_rtree50_f20_20260708.java 的 Model.score() 移植
// 50 棵决策树的 if-else 逻辑
}
/**
* 预测分类
* @return 0-4 的类别 index
*/
fun predict(features: FloatArray): Int {
val input = DoubleArray(60) { features[it].toDouble() }
val probs = score(input)
return probs.indices.maxByOrNull { probs[it] } ?: 0
}
}
移植方式: 将 Java 的 Model.score() 方法体直接复制到 Kotlin 的 score() 方法中。模型是纯 if-else 树结构，无外部依赖。
3.6 扫描状态管理 (ScanViewModel.kt)
class ScanViewModel : ViewModel() {
// 处理状态
private val isProcessing = AtomicBoolean(false)
private val isScanning = AtomicBoolean(true)
// UI 状态
val currentBitmap = mutableStateOf<Bitmap?>(null)
val statusText = mutableStateOf("请将试纸置于扫描框内")
val finalResult = mutableStateOf<Int?>(null)
val resultText = mutableStateOf<String?>(null)
// 特征缓冲区 (线程安全)
private val featuresBuffer = Collections.synchronizedList(mutableListOf<FloatArray>())
private val MAX_SAMPLES = 15
private val stripLocator = StripLocator()
private val featureExtractor = FeatureExtractor()
/**
* 处理一帧图像
* - 如果上一帧还在处理 → 跳过，返回原图
* - 如果扫描已完成 → 跳过，返回原图
* - 异步执行定位和特征提取
*/
fun processFrame(mat: Mat): Bitmap {
if (isProcessing.get() || !isScanning.get()) {
return ImageConverter.matToBitmap(mat)
}
isProcessing.set(true)
viewModelScope.launch(Dispatchers.Default) {
try {
val result = stripLocator.locate(mat)
// 更新显示的图像 (带标记框)
withContext(Dispatchers.Main) {
currentBitmap.value = ImageConverter.matToBitmap(result.annotatedMat)
}
if (result.success) {
val features = featureExtractor.extract(
result.leftImg!!, result.rightImg!!, result.wbImg!!
)
featuresBuffer.add(features)
withContext(Dispatchers.Main) {
statusText.value = "已识别: ${featuresBuffer.size}/$MAX_SAMPLES"
}
if (featuresBuffer.size >= MAX_SAMPLES) {
finalizeResult()
}
}
} finally {
isProcessing.set(false)
}
}
return ImageConverter.matToBitmap(mat)
}
/**
* 完成识别: 15 组特征分别预测 → 取众数
*/
private fun finalizeResult() {
isScanning.set(false)
val predictions = featuresBuffer.map { OvRandomForest.predict(it) }
val mode = predictions.groupBy { it }.maxByOrNull { it.value.size }?.key ?: 0
val resultMap = mapOf(
0 to "阴性",
1 to "阴性 (10)",
2 to "阳性 (25)",
3 to "阳性 (50)",
4 to "强阳 (75/100)"
)
viewModelScope.launch(Dispatchers.Main) {
finalResult.value = mode
resultText.value = resultMap[mode] ?: "未知"
statusText.value = "识别完成"
}
}
fun reset() {
featuresBuffer.clear()
isScanning.set(true)
finalResult.value = null
resultText.value = null
statusText.value = "请将试纸置于扫描框内"
}
}
3.7 异步帧处理策略
时间线:
Frame 1 → 开始处理 (定位 ~100-200ms)
Frame 2 → 跳过 (Frame 1 还在处理) → 返回原图
Frame 3 → 跳过 → 返回原图
Frame 4 → Frame 1 完成，开始处理 Frame 4
Frame 5 → 跳过
...
Frame N → 定位成功 → 提取特征 → 存入缓冲区
...
当缓冲区满 15 → 分类器投票 → 结果 → 停止扫描
关键实现:
AtomicBoolean isProcessing: 保证同一时间只有一帧在处理- 跳过时直接返回原图 Mat → Bitmap，不阻塞 UI
- 识别过程在
Dispatchers.Default协程中执行
3.8 阴性处理逻辑
定位结果分析:
2 个轮廓:
├─ 正常情况: leftImg=C线, rightImg=T线
└─ isNegative = false
1 个轮廓:
├─ 判断轮廓位置 (在图像中线左侧还是右侧)
├─ 人造另一个区域 (偏移 4×宽度)
├─ 如果是 C 线位置正确 → isNegative = true
└─ 如果是 T 线位置 (C 线缺失) → success = false
0 个轮廓:
└─ C 线和 T 线都不存在 → success = false
四、实施步骤
| 阶段 | 内容 | 预估时间 |
|---|---|---|
| Phase 1 | OpenCV 集成: 复制 openCVLibrary300 源码，验证基础功能 | 1 天 |
| Phase 2 | 图像转换: ImageProxy → Mat, Mat → Bitmap | 0.5 天 |
| Phase 3 | 试纸定位: 移植 StripLocator (11步定位算法) | 3-4 天 |
| Phase 4 | 特征提取: 60 维特征提取，确保顺序正确 | 1-2 天 |
| Phase 5 | 分类器: 移植 Java 随机森林模型到 Kotlin | 1 天 |
| Phase 6 | 状态管理: ScanViewModel 帧处理 + 15帧缓冲 + 众数投票 | 1-2 天 |
| Phase 7 | UI 集成: 改造 ScanPage 显示实时标记图像和结果 | 1-2 天 |
| Phase 8 | 测试调优: 定位准确率、性能、内存管理 | 2-3 天 |
总计: 约 11-15 天
五、关键技术决策
| 决策 | 选择 | 理由 |
|---|---|---|
| OpenCV 版本 | openCVLibrary300 (纯 Java) | 与旧项目一致，无需 JNI，直接复用 |
| 试纸类型 | 仅绿色排卵试纸 | 用户明确要求，代码中无类型判断 |
| 特征集 | 60维 (HSV + 灰度) | 与 ov_alg.txt 和训练模型一致 |
| 特征顺序 | 严格按训练数据列顺序 | 确保模型输入正确 |
| 分类器 | 随机森林 50 树 | m2cgen 导出的纯 Java 代码 |
| 帧处理 | 异步 + AtomicBoolean 跳过 | 避免处理积压，保证 UI 流畅 |
| 结果决策 | 15 帧投票众数 | 提高单帧识别的稳定性 |
| 数据存储 | 无 | 识别完成后直接出结果 |
| ROI 限制 | 无 (全图定位) | 用户要求去掉 10%-25% 限制 |
| 阴性处理 | 保留人造 T 线逻辑 | 兼容只有 C 线的情况 |