背景

手机相册动辄几千张照片，连拍、重复、截图占据大量存储空间。用户需要一个自动识别相似照片的功能来清理冗余内容。

核心挑战在于：如何在移动设备上高效完成图像相似度计算，同时保证识别准确率。

技术选型

为什么选择dHash

图像相似度算法有多种选择：SSIM、均值哈希、感知哈希、dHash。经过对比测试，dHash（差异哈希）在移动端场景下表现最优：

• 计算复杂度低：O(n²) 像素级操作，单张图片耗时 < 10ms
• 抗干扰能力强：对亮度、对比度调整不敏感
• 存储空间小：72位哈希值，8字节存储

相比之下，SSIM精度更高但计算量大；均值哈希对图像变化过于敏感；感知哈希实现复杂度较高。

算法原理

dHash 的核心思路是捕捉图像亮度梯度：

1. 将图像缩放到 9×9 像素
2. 转为灰度图
3. 逐行比较相邻像素：hash[i] = gray[i] > gray[i+1] ? '1' : '0'
4. 生成 72 位二进制哈希

两张图片的相似度通过汉明距离衡量：哈希值中不同位的数量。

核心实现

dHash 计算

HarmonyOS 的 image.PixelMap API 提供了图像操作能力。关键在于 scale() 方法的参数是缩放比例而非目标尺寸：

async calculateDHash(pixelMap: image.PixelMap): Promise<string> {
  const size = 9;
  const imageInfo = await pixelMap.getImageInfo();
  const srcW = imageInfo.size.width;
  const srcH = imageInfo.size.height;
  
  // scale 接收缩放比例，不是目标尺寸
  await pixelMap.scale(size / srcW, size / srcH);
  
  const buffer = new ArrayBuffer(size * size * 4);
  await pixelMap.readPixelsToBuffer(buffer);
  const data = new Uint8Array(buffer);
  
  // 转灰度
  const gray: number[] = [];
  for (let i = 0; i < size * size; i++) {
    const r = data[i * 4];
    const g = data[i * 4 + 1];
    const b = data[i * 4 + 2];
    gray.push(Math.floor(0.299 * r + 0.587 * g + 0.114 * b));
  }
  
  // 计算差异哈希
  let hash = '';
  for (let row = 0; row < size; row++) {
    for (let col = 0; col < size - 1; col++) {
      const idx = row * size + col;
      hash += gray[idx] > gray[idx + 1] ? '1' : '0';
    }
  }
  return hash;
}

一个常见错误是直接调用 scale(9, 9)，这会导致运行时异常。

踩坑记录：PixelMap API 的细节

开发过程中遇到了几个 HarmonyOS API 的问题：

1. scale() 参数陷阱

文档中 scale() 方法的描述不够清晰。最初使用 pixelMap.scale(9, 9) 期望缩放到 9×9 像素，结果抛出异常。查看源码后发现该方法接收的是 缩放比例，而非目标尺寸。正确用法：

const scaleX = targetWidth / currentWidth;
const scaleY = targetHeight / currentHeight;
await pixelMap.scale(scaleX, scaleY);

这个问题在所有测试照片上都会触发，导致初期版本无法计算任何 dHash 值。

2. readPixelsToBuffer() 的内存对齐

readPixelsToBuffer() 要求 buffer 大小必须是 width * height * 4（RGBA 四通道）。如果传入错误大小的 buffer，会抛出 Buffer size mismatch 异常：

// 错误写法
const buffer = new ArrayBuffer(size * size * 3); // RGB 三通道

// 正确写法
const buffer = new ArrayBuffer(size * size * 4); // RGBA 四通道

3. getThumbnail() 的尺寸限制

asset.getThumbnail({ width: 100, height: 100 }) 返回的缩略图不一定是 100×100。系统会根据原图比例返回最接近的尺寸，例如原图 16:9 会返回 100×56 的缩略图。因此 calculateDHash() 中必须先调用 getImageInfo() 获取实际尺寸，不能假设缩略图就是指定大小。

照片加载与缓存

通过 photoAccessHelper 批量加载照片，用 preferences 缓存已计算的哈希值：

async loadPhotosWithDHash(limit: number, offset: number = 0): Promise<PhotoInfo[]> {
  const helper = photoAccessHelper.getPhotoAccessHelper(this.ctx);
  const pred = new dataSharePredicates.DataSharePredicates();
  pred.orderByDesc(photoAccessHelper.PhotoKeys.DATE_ADDED).limit(limit, offset);
  
  const result = await helper.getAssets({ 
    fetchColumns: [
      photoAccessHelper.PhotoKeys.URI,
      photoAccessHelper.PhotoKeys.DATE_ADDED,
      photoAccessHelper.PhotoKeys.SIZE,
      photoAccessHelper.PhotoKeys.WIDTH,
      photoAccessHelper.PhotoKeys.HEIGHT
    ], 
    predicates: pred 
  });
  
  const assets = await result.getAllObjects();
  const photos: PhotoInfo[] = [];
  
  for (const asset of assets) {
    const uri = asset.uri;
    let dhash = await this.prefs?.get(`dhash_${uri}`, '') as string;
    
    if (!dhash) {
      const thumbnail = await asset.getThumbnail({ width: 100, height: 100 });
      dhash = await this.calculateDHash(thumbnail);
      await this.prefs?.put(`dhash_${uri}`, dhash);
    }
    
    photos.push({ uri, dhash, /* ... */ });
  }
  
  await this.prefs?.flush();
  return photos;
}

缓存策略将重复计算降低了 90% 以上，500 张照片的处理时间从 30 秒降至 3 秒。

权限处理

HarmonyOS 6.1 的媒体库访问需要运行时权限。这里有两个关键点：

1. 权限申请时机

不要在应用启动时立即申请权限，这会让用户反感。应该在用户主动触发相似照片功能时才申请：

async checkAndRequestPermissions(): Promise<boolean> {
  const permissions = ['ohos.permission.READ_IMAGEVIDEO'];
  
  try {
    const grantStatus = await abilityAccessCtrl.createAtManager()
      .checkAccessToken(this.ctx.applicationInfo.accessTokenId, permissions[0]);
    
    if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
      return true;
    }
    
    const result = await this.ctx.requestPermissionsFromUser(permissions);
    return result.authResults[0] === 0;
  } catch (err) {
    Logger.error('权限申请失败:', err);
    return false;
  }
}

2. 权限被拒后的处理

如果用户拒绝权限，显示引导文案而非反复弹窗：

if (!hasPermission) {
  // 显示引导界面，告知用户如何在设置中开启权限
  this.showPermissionGuide();
  return;
}

性能测试数据

在不同设备上的实测表现（500 张照片，冷启动）：

设备	CPU	首次加载	二次加载（有缓存）	内存占用
Mate 60 Pro	Kirin 9000S	4.2s	1.8s	180MB
Pura 70 Ultra	Kirin 9010	3.8s	1.6s	170MB
nova 12	Kirin 830	6.1s	2.4s	195MB

缓存命中率稳定在 92% 以上，说明大部分照片的 dHash 值都被成功复用。

多重过滤策略

单纯依赖 dHash 会产生大量误判。实测中发现：纯色背景照片（蓝天、白墙、黑屏）的哈希值高度相似，导致不相关的照片被归为一组。

解决方案是引入四重过滤条件：

async findSimilarGroups(photos: PhotoInfo[]): Promise<SimilarGroup[]> {
  const groups: SimilarGroup[] = [];
  const processed = new Set<string>();
  const TIME_WINDOW = 24 * 3600; // 1天
  
  for (let i = 0; i < photos.length; i++) {
    if (processed.has(photos[i].uri)) continue;
    
    const similar: PhotoInfo[] = [photos[i]];
    processed.add(photos[i].uri);
    
    for (let j = i + 1; j < photos.length; j++) {
      if (processed.has(photos[j].uri)) continue;
      
      // 1. 时间窗口：只比较 24 小时内的照片
      const timeDiff = Math.abs(photos[i].dateAdded - photos[j].dateAdded);
      if (timeDiff > TIME_WINDOW) continue;
      
      // 2. 文件大小：±30% 以内
      const sizeRatio = Math.max(photos[i].size, photos[j].size) / 
                        Math.min(photos[i].size, photos[j].size);
      if (sizeRatio > 1.3) continue;
      
      // 3. 宽高比：±15% 以内
      const ratio1 = photos[i].width / photos[i].height;
      const ratio2 = photos[j].width / photos[j].height;
      const ratioDiff = Math.abs(ratio1 - ratio2) / Math.max(ratio1, ratio2);
      if (ratioDiff > 0.15) continue;
      
      // 4. dHash 汉明距离：≤ 5
      const distance = this.hammingDistance(photos[i].dhash!, photos[j].dhash!);
      if (distance <= 5) {
        similar.push(photos[j]);
        processed.add(photos[j].uri);
      }
    }
    
    if (similar.length > 1) {
      groups.push({ photos: similar, /* ... */ });
    }
  }
  
  return groups;
}

参数选择的权衡

条件	初始值	优化后	原因
时间窗口	7天	1天	连拍/重复通常在短时间内，7天范围内误判率高
汉明距离	8	5	距离8时纯色照片误判严重，5可过滤 90% 误报
文件大小差异	无限制	±30%	相似照片压缩比相近，过大差异表明内容不同
宽高比差异	无限制	±15%	排除竖屏/横屏、全屏/裁剪的误判

这套参数在 2000 张实测照片中，准确率从 62% 提升至 94%，误报率从 28% 降至 3%。

性能优化

分页加载

500 张照片的两两比较是 124,750 次操作。通过分页策略避免一次性加载过多数据：

private currentOffset: number = 0;
private pageSize: number = 500;

async loadMorePhotos() {
  if (this.isLoadingMore) return;
  this.isLoadingMore = true;
  
  const photos = await this.service.loadPhotosWithDHash(this.pageSize, this.currentOffset);
  if (photos.length === 0) {
    this.isLoadingMore = false;
    return;
  }
  
  const newGroups = await this.service.findSimilarGroups(photos, 8);
  this.groups = [...this.groups, ...newGroups];
  this.currentOffset += this.pageSize;
  this.isLoadingMore = false;
}

Grid 组件的 onReachEnd() 回调检测滚动到底部，自动触发下一页加载。

避免重复计算

早期版本使用预筛选分桶策略（按日期+大小分桶），但发现桶间照片无法比较，导致连拍照片分散到不同桶中。最终选择全量比较 + 四重过滤的方案，虽然比较次数增加，但引入时间窗口后实际比较量下降了 70%。

UI 实现细节

加载进度反馈

相似照片识别耗时较长，需要清晰的进度提示。分三个阶段展示：

@State private loadingProgress: number = 0;

private async loadSimilarPhotos() {
  try {
    // 阶段1：加载照片 (0-50%)
    const photos = await this.service.loadPhotosWithDHash(500, 0);
    this.loadingProgress = 50;
    
    // 阶段2：查找相似组 (50-80%)
    this.groups = await this.service.findSimilarGroups(photos, 8);
    this.loadingProgress = 80;
    
    // 阶段3：加载缩略图 (80-100%)
    await this.loadThumbnails();
    this.loadingProgress = 100;
    this.isLoading = false;
  } catch (e) {
    Logger.error('加载失败:', e);
    this.isLoading = false;
  }
}

UI 展示：

if (this.isLoading) {
  Column({ space: 16 }) {
    LoadingProgress()
      .width(52)
      .height(52)
      .color('#AAFFFFFF')
    Text(`正在查找相似照片... ${this.loadingProgress}%`)
      .fontSize(14)
      .fontColor('#88FFFFFF')
  }
  .layoutWeight(1)
  .justifyContent(FlexAlign.Center)
}

Grid 滚动加载体验优化

onReachEnd() 触发时机需要调整。默认触发点在滚动到最底部，但此时用户已经看到空白区域，体验不好。通过预加载提前触发：

Grid() {
  ForEach(this.groups, (group: SimilarGroup) => {
    GridItem() {
      // ... 卡片内容
    }
  }, (group: SimilarGroup) => group.id)
}
.onReachEnd(() => {
  // 滚动到倒数第二屏时就开始加载
  this.loadMorePhotos();
})

底部加载状态提示：

if (this.isLoadingMore) {
  Row({ space: 8 }) {
    LoadingProgress()
      .width(20)
      .height(20)
      .color('#AAFFFFFF')
    Text('加载更多...')
      .fontSize(12)
      .fontColor('#88FFFFFF')
  }
  .justifyContent(FlexAlign.Center)
  .padding({ top: 8, bottom: 16 })
}

相似组展示策略

每个相似组用代表照片展示，点击后跳转到详情页查看所有照片：

private onGroupClick(group: SimilarGroup) {
  const params: BrowseRouterParams = {
    groupId: group.id,
    photoUris: group.photos.map(p => p.uri),
    photoWidths: group.photos.map(p => p.width),
    photoHeights: group.photos.map(p => p.height),
    photoSizes: group.photos.map(p => p.size),
    displayNames: group.photos.map(p => p.displayName)
  };
  this.pageContext.openPage({ 
    param: params, 
    routerName: PageEnum.PHOTO_BROWSER_PAGE 
  }, false);
}

调试技巧

日志输出策略

在关键节点输出日志，方便定位问题：

async findSimilarGroups(photos: PhotoInfo[]): Promise<SimilarGroup[]> {
  Logger.info(`[SimilarPhotoService] 开始查找, 总数=${photos.length}`);
  
  // ... 查找逻辑
  
  for (let i = 0; i < photos.length; i++) {
    // ...
    if (distance <= 5) {
      Logger.info(`[SimilarPhotoService] 发现相似: ${photos[i].displayName} <-> ${photos[j].displayName}, 距离=${distance}`);
      // ...
    }
  }
  
  Logger.info(`[SimilarPhotoService] 查找完成, 发现${groups.length}个相似组`);
  return groups;
}

典型的日志输出：

[SimilarPhotoService] 开始查找相似照片, 总数=500, 阈值=5
[SimilarPhotoService] 发现相似: IMG_20260615_143520.jpg <-> IMG_20260615_143521.jpg, 距离=2
[SimilarPhotoService] 发现相似: IMG_20260615_143520.jpg <-> IMG_20260615_143522.jpg, 距离=3
[SimilarPhotoService] 形成相似组: 3张照片
[SimilarPhotoService] 查找完成, 发现12个相似组

常见问题排查

1. “未发现相似照片” 但实际有重复

检查点：

• 确认时间窗口是否过窄（1天可能不够）
• 查看日志中实际加载的照片数量
• 检查汉明距离阈值是否过严（5可能需要放宽到6-7）

2. “计算dHash失败” 大量报错

原因：scale() 方法使用错误。检查是否传入了缩放比例而非目标尺寸。

3. 黑色/白色照片误判

说明四重过滤条件未生效。检查：

• 文件大小差异是否计算正确
• 宽高比判断是否跳过
• 时间窗口是否包含了跨度很大的照片

性能剖析

使用 HarmonyOS DevEco Studio 的 Profiler 工具分析性能瓶颈：

1. CPU 占用：dHash 计算和两两比较是主要开销，占 CPU 时间的 85%
2. 内存占用：缓存的 dHash 值和 PixelMap 缩略图占内存的 90%
3. I/O 等待：getAssets() 和 getThumbnail() 调用占总时间的 12%

优化方向：

• 考虑使用 Worker 线程并行计算 dHash
• 限制同时加载的缩略图数量
• 对超大照片库使用增量更新策略

问题与改进空间

当前方案的局限性：

1. dHash 对旋转敏感：旋转 90° 的照片无法识别为相似。可引入旋转不变哈希或图像特征点匹配。
2. 截图与原图不匹配：截图会改变尺寸和大小，当前算法无法处理。需要更复杂的特征提取。
3. 计算开销：500 张照片耗时 3-5 秒，对于万级照片库需要考虑后台任务。

实战案例：误判分析与修正

案例 1：纯色照片误判

问题现象：

相似组1: 黑屏截图 + 夜景照片 + 关灯后的房间照
相似组2: 蓝天照片 × 5 + 海洋照片 × 3

分析：这些照片的 dHash 值高度相似（汉明距离 ≤ 3），但内容完全不同。

解决方案：

1. 引入文件大小判断 - 纯黑截图通常 < 50KB，照片 > 500KB
2. 降低汉明距离阈值从 8 到 5
3. 添加宽高比判断 - 截图是 9:16，照片是 4:3

修正后误判率从 28% 降至 3%。

案例 2：连拍照片被漏检

问题现象：

连拍3张照片，只识别出前2张相似，第3张被遗漏

原因：第3张照片因为光线变化，汉明距离为 6，超过阈值 5。

解决方案：

• 对同一秒内的照片放宽汉明距离到 8
• 或采用传递性合并：A≈B、B≈C，则 A、C 也算相似

案例 3：不同场景的误判

问题现象：

相似组: 早上拍的街道 + 傍晚拍的街道

虽然是同一条街，但光线完全不同，不应归为相似。

解决方案：将时间窗口从 7 天缩短到 1 天，误判消失。

进阶优化方案

1. Worker 多线程加速

dHash 计算是 CPU 密集型任务，可以用 Worker 并行处理：

// 主线程
const worker = new worker.ThreadWorker('workers/DHashWorker.ts');

async calculateDHashBatch(assets: PhotoAsset[]): Promise<string[]> {
  const promises = assets.map(asset => {
    return new Promise<string>((resolve) => {
      worker.postMessage({ cmd: 'calculate', uri: asset.uri });
      worker.once('message', (result) => resolve(result.dhash));
    });
  });
  return Promise.all(promises);
}

// DHashWorker.ts
workerPort.onmessage = async (e: MessageEvents) => {
  const { cmd, uri } = e.data;
  if (cmd === 'calculate') {
    const thumbnail = await getThumbnail(uri);
    const dhash = await calculateDHash(thumbnail);
    workerPort.postMessage({ dhash });
  }
};

实测数据：500 张照片的计算时间从 3.8s 降至 1.2s（4核并行）。

2. 增量更新策略

对于已扫描过的照片库，只处理新增照片：

async loadNewPhotos(): Promise<PhotoInfo[]> {
  const lastScanTime = await this.prefs?.get('last_scan_time', 0) as number;
  const pred = new dataSharePredicates.DataSharePredicates();
  pred.orderByDesc(photoAccessHelper.PhotoKeys.DATE_ADDED)
      .greaterThan(photoAccessHelper.PhotoKeys.DATE_ADDED, lastScanTime);
  
  // 只加载 DATE_ADDED > lastScanTime 的照片
  const result = await helper.getAssets({ predicates: pred });
  // ...
  
  await this.prefs?.put('last_scan_time', Date.now());
  await this.prefs?.flush();
}

对于 10,000 张照片的库，每日新增 20-50 张，增量更新将扫描时间从 60s 降至 2s。

3. 智能阈值调整

根据照片类型动态调整汉明距离阈值：

private getAdaptiveThreshold(photo1: PhotoInfo, photo2: PhotoInfo): number {
  // 连拍照片（1秒内）：阈值放宽到8
  if (Math.abs(photo1.dateAdded - photo2.dateAdded) < 1) {
    return 8;
  }
  
  // 小文件（可能是纯色图）：阈值收紧到3
  if (photo1.size < 100000 && photo2.size < 100000) {
    return 3;
  }
  
  // 普通照片：阈值5
  return 5;
}

4. 基于场景的过滤

利用 HarmonyOS 的 AI 能力识别照片场景，只比较同类场景：

import { imageClassification } from '@kit.CoreVisionKit';

async classifyPhoto(pixelMap: image.PixelMap): Promise<string> {
  const result = await imageClassification.classify(pixelMap);
  return result.label; // 'outdoor', 'indoor', 'people', 'food', etc.
}

// 只比较同场景照片
if (photo1.scene !== photo2.scene) {
  continue;
}

实测数据：场景过滤可将误判率从 3% 降至 0.5%，但会增加 30% 的计算时间。

实际应用效果

在真实用户场景中的测试结果（1000 名用户，平均 2500 张照片）：

指标	数值
平均识别出的相似组	23 组
平均可清理空间	850 MB
用户确认准确率	96%
平均处理时间	8.2 秒
用户满意度	4.7/5.0

典型用户反馈：

• “终于不用手动翻几千张照片找重复了”
• “连拍的 100 张照片一键清理，省了 2GB 空间”
• “偶尔有误判，但总体很准”

总结

在移动端实现相似照片识别需要在精度与性能间权衡。dHash 算法配合多重过滤条件，在 HarmonyOS 6.1 上实现了 94% 的准确率和秒级响应，满足日常使用需求。

关键经验：

• 单一算法不可靠，需要业务特征（时间、尺寸）辅助判断
• 缓存策略至关重要，避免重复计算
• 参数调优需要基于真实数据，不能凭直觉