鸿蒙跨设备智能热量分析系统：分布式菜品识别与多终端卡路里同步原创

进修的泡芙

发布于 2025-6-22 17:22

浏览

0收藏

鸿蒙跨设备智能热量分析系统：分布式菜品识别与多终端卡路里同步

一、系统架构设计

!https://example.com/harmonyos-calorie-arch.png

采用四层架构：
采集层：多设备摄像头图像采集

识别层：分布式菜品识别与成分分析

计算层：热量估算与营养分析

展示层：跨终端数据可视化与健康建议

二、核心模块实现
菜品识别与成分分析

// FoodAnalyzer.ts
import image from ‘@ohos.multimedia.image’;
import foodRecognition from ‘@ohos.ai.foodRecognition’;

interface FoodItem {
name: string;
ingredients: Ingredient[];
portionSize: number; // 克
interface Ingredient {

name: string;
weight: number; // 克
calories: number; // 千卡/100克
export class FoodAnalyzer {

private recognizer: foodRecognition.FoodRecognizer;

async init() {
this.recognizer = await foodRecognition.createRecognizer({
model: ‘food_v2’,
nutritionDatabase: ‘standard’
});
async analyze(image: image.Image): Promise<FoodItem> {

const result = await this.recognizer.recognize(image);
return this.parseResult(result);

private parseResult(result: foodRecognition.RecognitionResult): FoodItem {

return {
  name: result.dishName,
  ingredients: result.ingredients.map(i => ({
    name: i.name,
    weight: i.estimatedWeight,
    calories: i.caloriesPer100g
  })),
  portionSize: result.estimatedWeight
};

calculateCalories(food: FoodItem): number {

return food.ingredients.reduce((sum, ing) => 
  sum + (ing.weight * ing.calories / 100), 0);

}

分布式数据管理

// CalorieSync.ts
import distributedData from ‘@ohos.data.distributedData’;

interface MealRecord {
recordId: string;
deviceId: string;
timestamp: number;
foodItems: FoodItem[];
totalCalories: number;
mealType: ‘breakfast’ ‘lunch’ ‘dinner’
‘snack’;
export class CalorieSync {

private kvManager: distributedData.KVManager;
private kvStore: distributedData.KVStore;

async init() {
const context = getContext(this);
this.kvManager = distributedData.createKVManager({ context });

const options = {
  createIfMissing: true,
  encrypt: true,
  autoSync: true,
  kvStoreType: distributedData.KVStoreType.SINGLE_VERSION,
  securityLevel: distributedData.SecurityLevel.S1
};

this.kvStore = await this.kvManager.getKVStore('meal_records', options);
this.setupListeners();

async addMealRecord(record: Omit<MealRecord, ‘recordId’>): Promise<string> {

const recordId = meal_${Date.now()};
const fullRecord = { ...record, recordId };

await this.kvStore.put(recordId, fullRecord);
return recordId;

async getTodayIntake(deviceIds: string[]): Promise<number> {

const todayStart = new Date().setHours(0, 0, 0, 0);
const entries = await this.kvStore.entries('meal_');

return entries
  .filter(([_, v]) => 
    deviceIds.includes(v.deviceId) && 
    v.timestamp >= todayStart
  )
  .reduce((sum, [_, record]) => sum + record.totalCalories, 0);

private setupListeners() {

this.kvStore.on('dataChange', distributedData.SubscribeType.SUBSCRIBE_TYPE_REMOTE, 
  (changes) => {
    changes.forEach(({ key, value }) => {
      if (key.startsWith('meal_')) {
        this.handleNewMeal(value);

});

});

// 其他方法…

主页面实现（ArkUI）

// CalorieTracker.ets
import { FoodAnalyzer } from ‘./FoodAnalyzer’;
import { CalorieSync } from ‘./CalorieSync’;

@Entry
@Component
struct CalorieTrackerApp {
@State currentMeal?: FoodItem[];
@State todayIntake: number = 0;
@State deviceIntakes: Record<string, number> = {};

private analyzer = new FoodAnalyzer();
private syncManager = new CalorieSync();
private cameraController?: CameraController;

async aboutToAppear() {
await this.analyzer.init();
await this.syncManager.init();
this.loadTodayData();
async analyzeFood(image: image.Image) {

const foodItem = await this.analyzer.analyze(image);
this.currentMeal = [foodItem];

const calories = this.analyzer.calculateCalories(foodItem);
await this.syncManager.addMealRecord({
  deviceId: 'local_device',
  timestamp: Date.now(),
  foodItems: [foodItem],
  totalCalories: calories,
  mealType: this.getMealType()
});

this.loadTodayData();

private getMealType(): MealRecord[‘mealType’] {

const hours = new Date().getHours();
if (hours < 11) return 'breakfast';
if (hours < 15) return 'lunch';
if (hours < 20) return 'dinner';
return 'snack';

async loadTodayData() {

const devices = await this.getTrustedDevices();
this.todayIntake = await this.syncManager.getTodayIntake(['local_device', ...devices]);

this.deviceIntakes = {};
await Promise.all(devices.map(async deviceId => {
  this.deviceIntakes[deviceId] = await this.syncManager.getTodayIntake([deviceId]);
}));

build() {

Column() {
  // 当前菜品分析
  if (this.currentMeal) {
    FoodAnalysisCard(this.currentMeal)

// 今日摄入总量

  DailyIntakeDisplay(this.todayIntake)
  
  // 设备摄入对比
  DeviceIntakeComparison(this.deviceIntakes)
  
  // 控制按钮
  Button('拍摄食物')
    .onClick(() => this.startCamera())

}

// 其他方法…
@Component

struct FoodAnalysisCard {
@Prop foodItems: FoodItem[];

build() {
Column() {
Text(‘当前食物分析’)
.fontSize(18)

  ForEach(this.foodItems, (food) => {
    Column() {
      Text(food.name)
        .fontSize(16)
      
      Text(分量: ${food.portionSize}g)
      Text(热量: ${this.calculateCalories(food)}千卡)
      
      if (food.ingredients.length > 0) {
        Text('主要成分:')
        ForEach(food.ingredients, (ing) => {
          Text({ing.name} {ing.weight}g (${ing.calories}千卡/100g))
        })

}

    .margin(10)
  })

}

private calculateCalories(food: FoodItem): number {
return food.ingredients.reduce((sum, ing) =>
sum + (ing.weight * ing.calories / 100), 0);
}

@Component
struct DailyIntakeDisplay {
@Prop intake: number;

build() {
Column() {
Text(‘今日总摄入’)
.fontSize(16)
Text(${this.intake}千卡)
.fontSize(24)
.fontColor(this.getColor())
}

private getColor(): Resource {
if (this.intake > 2000) return $r(‘app.color.warning’);
if (this.intake > 1500) return $r(‘app.color.normal’);
return $r(‘app.color.good’);
}

三、跨设备协同关键实现
多设备数据融合

// 在CalorieSync中添加
async getCombinedIntake(userId: string): Promise<CombinedIntake> {
const devices = await this.getUserDevices(userId);
const records = await this.getUserRecords(userId);

return {
totalCalories: records.reduce((sum, r) => sum + r.totalCalories, 0),
byMealType: this.groupByMealType(records),
byDevice: this.groupByDevice(records, devices)
};
private groupByMealType(records: MealRecord[]): Record<string, number> {

return records.reduce((acc, record) => {
acc[record.mealType] = (acc[record.mealType] || 0) + record.totalCalories;
return acc;
}, {} as Record<string, number>);

健康建议协同生成

// HealthAdvisor.ts
export class HealthAdvisor {
static async generateAdvice(intake: CombinedIntake, goal: number): Promise<string[]> {
const advice: string[] = [];
const diff = goal - intake.totalCalories;

if (diff < -500) {
  advice.push('今日摄入已超标，建议适当运动消耗多余热量');

else if (diff > 300) {

  advice.push('还可以补充约300千卡的健康零食');

// 分析各餐次分布

const breakfastRatio = (intake.byMealType.breakfast || 0) / intake.totalCalories;
if (breakfastRatio < 0.2) {
  advice.push('早餐摄入不足，建议明天增加早餐分量');

return advice;

}

分布式提醒设置

// 在CalorieSync中添加
async syncReminders(userId: string, reminders: Reminder[]) {
const devices = await this.getUserDevices(userId);
await Promise.all(devices.map(device =>
this.setDeviceReminder(device.deviceId, reminders)
));
private async setDeviceReminder(deviceId: string, reminders: Reminder[]) {

try {
await distributedNotification.publish({
targetDevice: deviceId,
message: JSON.stringify({
type: ‘set_reminders’,
reminders
})
});
catch (err) {

console.error(设置设备${deviceId}提醒失败:, err);

}

四、性能优化方案
图像处理优化

// 在FoodAnalyzer中添加
private optimizeImageProcessing(image: image.Image): image.Image {
// 缩小处理区域提高性能
const smallImage = image.resize(800, 600);

// 增强对比度
return smallImage.adjustContrast(1.2);

数据同步压缩

// 在CalorieSync中添加
private compressMealRecord(record: MealRecord): CompressedRecord {
return {
i: record.recordId,
d: record.deviceId,
t: record.timestamp,
f: record.foodItems.map(f => ({
n: f.name,
p: f.portionSize,
i: f.ingredients.map(i => ({
n: i.name.substring(0, 3), // 缩写名称
w: i.weight,
c: i.calories
}))
})),
c: record.totalCalories,
m: record.mealType[0] // ‘b’‘l’ ‘d’
‘s’
};

本地缓存策略

const foodCache = new Map<string, FoodItem>();

async getCachedFood(imageHash: string): Promise<FoodItem | undefined> {
if (foodCache.has(imageHash)) {
return foodCache.get(imageHash);
const image = await this.loadImage(imageHash);

if (!image) return undefined;

const food = await this.analyzer.analyze(image);
foodCache.set(imageHash, food);
return food;

五、应用场景扩展
饮食计划协同

class MealPlanner {
async syncPlanToDevices(plan: WeeklyPlan) {
// 将饮食计划同步到所有设备
}

家庭健康挑战

class FamilyChallenge {
async startCalorieChallenge(members: string[]) {
// 家庭成员热量控制挑战
}

餐厅营养分析

class RestaurantGuide {
async analyzeMenu(menuImage: image.Image) {
// 识别餐厅菜单热量信息
}

智能购物建议

class ShoppingAdvisor {
async suggestAlternatives(currentItem: FoodItem) {
// 推荐更健康的替代品
}

本系统充分利用HarmonyOS分布式能力，实现了：
多设备协同识别：综合多个设备的识别结果提高准确率

实时摄入统计：秒级的热量数据同步