KMP OpenHarmony 温度体感指数计算器

温度体感指数计算器实现本文介绍了一种基于KMP框架的温度体感指数计算器实现方案，支持在OpenHarmony鸿蒙平台上跨端调用。该工具提供多种体感温度计算功能：热指数计算：采用美国国家气象局公式，根据温度和湿度评估高温影响风寒指数计算：基于加拿大气象部门公式，考虑温度和风速评估低温影响综合体感温度：综合温度、湿度、风速和太阳辐射等因素计算舒适度评估：根据计算结果提供多级舒适度分类和健康建

2501_94444887

750人浏览 · 2025-12-07 17:31:49

2501_94444887 · 2025-12-07 17:31:49 发布

在这里插入图片描述

文章概述

温度体感指数（Heat Index、Wind Chill Index等）是气象学和人体舒适度研究中的重要概念。实际温度与人体感受到的温度往往不同，这取决于多个气象因素，如湿度、风速、太阳辐射等。温度体感指数计算器通过科学的算法，根据这些气象参数计算出人体实际感受到的温度，帮助人们更好地了解气候条件并做出相应的防护措施。

温度体感指数计算器在实际应用中有广泛的用途。在气象预报中，需要计算体感温度来提醒公众注意极端天气。在户外运动中，需要根据体感温度选择合适的衣着和活动强度。在健康管理中，需要根据体感温度评估中暑和冻伤的风险。在建筑设计中，需要根据体感温度设计空调系统。在工业安全中，需要根据体感温度制定工作时间和防护措施。

本文将深入探讨如何在KMP（Kotlin Multiplatform）框架下实现一套完整的温度体感指数计算器，并展示如何在OpenHarmony鸿蒙平台上进行跨端调用。我们将提供多种体感指数计算功能，包括热指数、风寒指数、体感温度等，帮助开发者和用户准确评估气候条件对人体的影响。

工具功能详解

核心功能

功能1：热指数计算（Heat Index Calculation）

根据温度和相对湿度计算热指数，用于评估高温天气对人体的影响。这是最常用的体感指数。

功能特点：

基于美国国家气象局公式
支持摄氏度和华氏度
返回详细的舒适度评级
提供健康建议

功能2：风寒指数计算（Wind Chill Index Calculation）

根据温度和风速计算风寒指数，用于评估低温和风对人体的影响。

功能特点：

基于加拿大气象部门公式
支持多种风速单位
返回冻伤风险评估
提供防护建议

功能3：综合体感温度（Apparent Temperature）

综合考虑多个气象因素计算综合体感温度。

功能特点：

综合多个气象参数
高精度计算
返回详细的参数影响分析
支持多种计算模型

功能4：舒适度评估（Comfort Assessment）

根据体感温度评估人体舒适度等级。

功能特点：

多级舒适度分类
返回详细的评估报告
提供活动建议
包含健康警告

功能5：混合气象分析（Hybrid Weather Analysis）

综合多种指数提供完整的气象分析报告。

功能特点：

综合多种计算方法
返回完整的分析报告
提供综合建议
支持历史数据对比

Kotlin实现

完整的Kotlin代码实现

/**
 * 温度体感指数计算器 - KMP OpenHarmony
 * 提供多种体感温度计算功能
 */
object TemperatureIndexUtils {
    
    /**
     * 功能1：热指数计算（Heat Index）
     * 基于美国国家气象局公式
     * 温度单位：摄氏度，返回摄氏度
     */
    fun calculateHeatIndex(tempC: Double, humidity: Double): Double {
        // 转换为华氏度
        val tempF = tempC * 9.0 / 5.0 + 32.0
        
        // 如果温度低于26.7°C，不计算热指数
        if (tempC < 26.7) return tempC
        
        // 美国国家气象局公式
        val c1 = -42.379
        val c2 = 2.04901523
        val c3 = 10.14333127
        val c4 = -0.22475541
        val c5 = -0.00683783
        val c6 = -0.05481717
        val c7 = 0.00122874
        val c8 = 0.00085282
        val c9 = -0.00000199
        
        val t = tempF
        val rh = humidity
        
        val heatIndexF = c1 + c2 * t + c3 * rh + c4 * t * rh + 
                         c5 * t * t + c6 * rh * rh + c7 * t * t * rh + 
                         c8 * t * rh * rh + c9 * t * t * rh * rh
        
        // 转换回摄氏度
        return (heatIndexF - 32.0) * 5.0 / 9.0
    }
    
    /**
     * 功能2：风寒指数计算（Wind Chill Index）
     * 基于加拿大气象部门公式
     * 温度单位：摄氏度，风速单位：km/h
     */
    fun calculateWindChill(tempC: Double, windSpeedKmh: Double): Double {
        // 如果温度高于0°C或风速低于4.8 km/h，不计算风寒指数
        if (tempC > 0 || windSpeedKmh < 4.8) return tempC
        
        // 加拿大公式
        val windChillC = 13.12 + 0.6215 * tempC - 11.37 * Math.pow(windSpeedKmh, 0.16) + 
                         0.3965 * tempC * Math.pow(windSpeedKmh, 0.16)
        
        return windChillC
    }
    
    /**
     * 功能3：综合体感温度（Apparent Temperature）
     * 综合考虑温度、湿度、风速、太阳辐射
     */
    fun calculateApparentTemperature(
        tempC: Double, 
        humidity: Double, 
        windSpeedMps: Double, 
        solarRadiation: Double = 0.0
    ): Double {
        // 基于Steadman模型的简化版本
        val windFactor = 0.5 * Math.sqrt(windSpeedMps) * (tempC - 37.0)
        val humidityFactor = 0.1 * (humidity - 45.0) * (tempC - 20.0) / 100.0
        val radiationFactor = solarRadiation / 100.0
        
        return tempC + windFactor + humidityFactor + radiationFactor
    }
    
    /**
     * 功能4：舒适度评估
     */
    fun assessComfort(apparentTempC: Double): Map<String, Any> {
        val assessment = mutableMapOf<String, Any>()
        
        val (level, description, activity, warning) = when {
            apparentTempC < -40 -> {
                Tuple4("极度严寒", "极其危险，可能导致冻伤和低体温症", 
                       "避免任何户外活动", "立即寻求庇护所")
            }
            apparentTempC < -25 -> {
                Tuple4("严寒", "非常危险，长期暴露会导致冻伤", 
                       "仅在必要时进行户外活动，穿着厚重衣物", "限制户外时间")
            }
            apparentTempC < -10 -> {
                Tuple4("寒冷", "危险，需要防护措施", 
                       "户外活动需要保暖衣物", "注意冻伤风险")
            }
            apparentTempC < 0 -> {
                Tuple4("冷", "不舒适，需要保暖", 
                       "户外活动需要外套和手套", "保持温暖")
            }
            apparentTempC < 10 -> {
                Tuple4("凉爽", "略感不适，可穿外套", 
                       "适合户外活动，穿着外套", "正常活动")
            }
            apparentTempC < 20 -> {
                Tuple4("舒适", "舒适温度", 
                       "适合各种户外活动", "无特殊警告")
            }
            apparentTempC < 30 -> {
                Tuple4("温暖", "舒适，略感温暖", 
                       "适合户外活动，穿着轻薄衣物", "正常活动")
            }
            apparentTempC < 40 -> {
                Tuple4("炎热", "不舒适，需要防晒和补水", 
                       "户外活动需要防晒和充足水分", "注意中暑风险")
            }
            apparentTempC < 50 -> {
                Tuple4("极热", "危险，高中暑风险", 
                       "限制户外活动，需要充足水分和防晒", "高中暑风险")
            }
            else -> {
                Tuple4("致命高温", "极其危险", 
                       "避免任何户外活动", "立即寻求冷却环境")
            }
        }
        
        assessment["舒适度等级"] = level
        assessment["描述"] = description
        assessment["活动建议"] = activity
        assessment["健康警告"] = warning
        
        return assessment
    }
    
    /**
     * 功能5：混合气象分析
     */
    fun analyzeWeather(
        tempC: Double,
        humidity: Double,
        windSpeedKmh: Double,
        solarRadiation: Double = 0.0
    ): Map<String, Any> {
        val analysis = mutableMapOf<String, Any>()
        
        analysis["实际温度"] = String.format("%.1f°C", tempC)
        analysis["相对湿度"] = String.format("%.1f%%", humidity)
        analysis["风速"] = String.format("%.1f km/h", windSpeedKmh)
        
        val heatIndex = calculateHeatIndex(tempC, humidity)
        val windChill = calculateWindChill(tempC, windSpeedKmh)
        val apparentTemp = calculateApparentTemperature(tempC, humidity, windSpeedKmh / 3.6, solarRadiation)
        
        analysis["热指数"] = String.format("%.1f°C", heatIndex)
        analysis["风寒指数"] = String.format("%.1f°C", windChill)
        analysis["体感温度"] = String.format("%.1f°C", apparentTemp)
        
        val comfort = assessComfort(apparentTemp)
        analysis["舒适度"] = comfort["舒适度等级"]
        analysis["活动建议"] = comfort["活动建议"]
        analysis["健康警告"] = comfort["健康警告"]
        
        return analysis
    }
    
    /**
     * 获取温度范围的舒适度统计
     */
    fun getComfortStats(): Map<String, String> {
        return mapOf(
            "极度严寒" to "低于 -40°C",
            "严寒" to "-40°C 至 -25°C",
            "寒冷" to "-25°C 至 -10°C",
            "冷" to "-10°C 至 0°C",
            "凉爽" to "0°C 至 10°C",
            "舒适" to "10°C 至 20°C",
            "温暖" to "20°C 至 30°C",
            "炎热" to "30°C 至 40°C",
            "极热" to "40°C 至 50°C",
            "致命高温" to "高于 50°C"
        )
    }
}

// 辅助数据类
data class Tuple4<A, B, C, D>(val first: A, val second: B, val third: C, val fourth: D)

// 使用示例
fun main() {
    println("KMP OpenHarmony 温度体感指数计算器演示\n")
    
    val testCases = listOf(
        Triple(35.0, 80.0, 10.0),  // 炎热潮湿
        Triple(-15.0, 50.0, 30.0), // 寒冷有风
        Triple(25.0, 60.0, 5.0),   // 舒适
        Triple(45.0, 40.0, 2.0)    // 极热干燥
    )
    
    for ((temp, humidity, wind) in testCases) {
        println("气象条件：温度 $temp°C，湿度 $humidity%，风速 $wind km/h")
        
        val analysis = TemperatureIndexUtils.analyzeWeather(temp, humidity, wind)
        println("分析结果：")
        analysis.forEach { (k, v) -> println("  $k: $v") }
        println()
    }
}

Kotlin实现的详细说明

Kotlin实现提供了五个核心功能。热指数计算使用美国国家气象局的标准公式，考虑温度和湿度的综合影响。风寒指数计算使用加拿大气象部门的公式，评估低温和风对人体的影响。综合体感温度基于Steadman模型，综合考虑多个气象参数。舒适度评估根据体感温度提供详细的舒适度等级和建议。混合气象分析综合多种指数提供完整的分析报告。

JavaScript实现

完整的JavaScript代码实现

/**
 * 温度体感指数计算器 - JavaScript版本
 */
class TemperatureIndexJS {
    /**
     * 功能1：热指数计算
     */
    static calculateHeatIndex(tempC, humidity) {
        const tempF = tempC * 9.0 / 5.0 + 32.0;
        
        if (tempC < 26.7) return tempC;
        
        const c1 = -42.379;
        const c2 = 2.04901523;
        const c3 = 10.14333127;
        const c4 = -0.22475541;
        const c5 = -0.00683783;
        const c6 = -0.05481717;
        const c7 = 0.00122874;
        const c8 = 0.00085282;
        const c9 = -0.00000199;
        
        const t = tempF;
        const rh = humidity;
        
        const heatIndexF = c1 + c2 * t + c3 * rh + c4 * t * rh + 
                          c5 * t * t + c6 * rh * rh + c7 * t * t * rh + 
                          c8 * t * rh * rh + c9 * t * t * rh * rh;
        
        return (heatIndexF - 32.0) * 5.0 / 9.0;
    }
    
    /**
     * 功能2：风寒指数计算
     */
    static calculateWindChill(tempC, windSpeedKmh) {
        if (tempC > 0 || windSpeedKmh < 4.8) return tempC;
        
        const windChillC = 13.12 + 0.6215 * tempC - 11.37 * Math.pow(windSpeedKmh, 0.16) + 
                          0.3965 * tempC * Math.pow(windSpeedKmh, 0.16);
        
        return windChillC;
    }
    
    /**
     * 功能3：综合体感温度
     */
    static calculateApparentTemperature(tempC, humidity, windSpeedMps, solarRadiation = 0.0) {
        const windFactor = 0.5 * Math.sqrt(windSpeedMps) * (tempC - 37.0);
        const humidityFactor = 0.1 * (humidity - 45.0) * (tempC - 20.0) / 100.0;
        const radiationFactor = solarRadiation / 100.0;
        
        return tempC + windFactor + humidityFactor + radiationFactor;
    }
    
    /**
     * 功能4：舒适度评估
     */
    static assessComfort(apparentTempC) {
        let level, description, activity, warning;
        
        if (apparentTempC < -40) {
            level = '极度严寒';
            description = '极其危险，可能导致冻伤和低体温症';
            activity = '避免任何户外活动';
            warning = '立即寻求庇护所';
        } else if (apparentTempC < -25) {
            level = '严寒';
            description = '非常危险，长期暴露会导致冻伤';
            activity = '仅在必要时进行户外活动，穿着厚重衣物';
            warning = '限制户外时间';
        } else if (apparentTempC < -10) {
            level = '寒冷';
            description = '危险，需要防护措施';
            activity = '户外活动需要保暖衣物';
            warning = '注意冻伤风险';
        } else if (apparentTempC < 0) {
            level = '冷';
            description = '不舒适，需要保暖';
            activity = '户外活动需要外套和手套';
            warning = '保持温暖';
        } else if (apparentTempC < 10) {
            level = '凉爽';
            description = '略感不适，可穿外套';
            activity = '适合户外活动，穿着外套';
            warning = '正常活动';
        } else if (apparentTempC < 20) {
            level = '舒适';
            description = '舒适温度';
            activity = '适合各种户外活动';
            warning = '无特殊警告';
        } else if (apparentTempC < 30) {
            level = '温暖';
            description = '舒适，略感温暖';
            activity = '适合户外活动，穿着轻薄衣物';
            warning = '正常活动';
        } else if (apparentTempC < 40) {
            level = '炎热';
            description = '不舒适，需要防晒和补水';
            activity = '户外活动需要防晒和充足水分';
            warning = '注意中暑风险';
        } else if (apparentTempC < 50) {
            level = '极热';
            description = '危险，高中暑风险';
            activity = '限制户外活动，需要充足水分和防晒';
            warning = '高中暑风险';
        } else {
            level = '致命高温';
            description = '极其危险';
            activity = '避免任何户外活动';
            warning = '立即寻求冷却环境';
        }
        
        return {
            '舒适度等级': level,
            '描述': description,
            '活动建议': activity,
            '健康警告': warning
        };
    }
    
    /**
     * 功能5：混合气象分析
     */
    static analyzeWeather(tempC, humidity, windSpeedKmh, solarRadiation = 0.0) {
        const analysis = {};
        
        analysis['实际温度'] = tempC.toFixed(1) + '°C';
        analysis['相对湿度'] = humidity.toFixed(1) + '%';
        analysis['风速'] = windSpeedKmh.toFixed(1) + ' km/h';
        
        const heatIndex = this.calculateHeatIndex(tempC, humidity);
        const windChill = this.calculateWindChill(tempC, windSpeedKmh);
        const apparentTemp = this.calculateApparentTemperature(tempC, humidity, windSpeedKmh / 3.6, solarRadiation);
        
        analysis['热指数'] = heatIndex.toFixed(1) + '°C';
        analysis['风寒指数'] = windChill.toFixed(1) + '°C';
        analysis['体感温度'] = apparentTemp.toFixed(1) + '°C';
        
        const comfort = this.assessComfort(apparentTemp);
        analysis['舒适度'] = comfort['舒适度等级'];
        analysis['活动建议'] = comfort['活动建议'];
        analysis['健康警告'] = comfort['健康警告'];
        
        return analysis;
    }
    
    /**
     * 获取温度范围的舒适度统计
     */
    static getComfortStats() {
        return {
            '极度严寒': '低于 -40°C',
            '严寒': '-40°C 至 -25°C',
            '寒冷': '-25°C 至 -10°C',
            '冷': '-10°C 至 0°C',
            '凉爽': '0°C 至 10°C',
            '舒适': '10°C 至 20°C',
            '温暖': '20°C 至 30°C',
            '炎热': '30°C 至 40°C',
            '极热': '40°C 至 50°C',
            '致命高温': '高于 50°C'
        };
    }
}

// 导出供Node.js使用
if (typeof module !== 'undefined' && module.exports) {
    module.exports = TemperatureIndexJS;
}

JavaScript实现的详细说明

JavaScript版本充分利用了JavaScript的数学函数。热指数计算使用标准公式处理温度和湿度。风寒指数计算使用加拿大公式。综合体感温度基于Steadman模型。舒适度评估根据温度范围提供详细的分类。混合气象分析综合多种指数提供完整的分析。

ArkTS调用实现

完整的ArkTS代码实现

/**
 * 温度体感指数计算器 - ArkTS版本（OpenHarmony鸿蒙）
 */
import { webview } from '@kit.ArkWeb';
import { common } from '@kit.AbilityKit';

@Entry
@Component
struct TemperatureIndexPage {
    @State temperature: string = '25';
    @State humidity: string = '60';
    @State windSpeed: string = '10';
    @State result: string = '';
    @State selectedTool: string = '完整分析';
    @State isLoading: boolean = false;
    @State allResults: string = '';
    
    webviewController: webview.WebviewController = new webview.WebviewController();
    
    calculateHeatIndex(tempC: number, humidity: number): number {
        const tempF = tempC * 9.0 / 5.0 + 32.0;
        
        if (tempC < 26.7) return tempC;
        
        const c1 = -42.379;
        const c2 = 2.04901523;
        const c3 = 10.14333127;
        const c4 = -0.22475541;
        const c5 = -0.00683783;
        const c6 = -0.05481717;
        const c7 = 0.00122874;
        const c8 = 0.00085282;
        const c9 = -0.00000199;
        
        const t = tempF;
        const rh = humidity;
        
        const heatIndexF = c1 + c2 * t + c3 * rh + c4 * t * rh + 
                          c5 * t * t + c6 * rh * rh + c7 * t * t * rh + 
                          c8 * t * rh * rh + c9 * t * t * rh * rh;
        
        return (heatIndexF - 32.0) * 5.0 / 9.0;
    }
    
    calculateWindChill(tempC: number, windSpeedKmh: number): number {
        if (tempC > 0 || windSpeedKmh < 4.8) return tempC;
        
        const windChillC = 13.12 + 0.6215 * tempC - 11.37 * Math.pow(windSpeedKmh, 0.16) + 
                          0.3965 * tempC * Math.pow(windSpeedKmh, 0.16);
        
        return windChillC;
    }
    
    calculateApparentTemperature(tempC: number, humidity: number, windSpeedMps: number): number {
        const windFactor = 0.5 * Math.sqrt(windSpeedMps) * (tempC - 37.0);
        const humidityFactor = 0.1 * (humidity - 45.0) * (tempC - 20.0) / 100.0;
        
        return tempC + windFactor + humidityFactor;
    }
    
    assessComfort(apparentTempC: number): Record<string, string> {
        let level = '未知';
        let description = '';
        let activity = '';
        let warning = '';
        
        if (apparentTempC < -40) {
            level = '极度严寒';
            description = '极其危险';
            activity = '避免任何户外活动';
            warning = '立即寻求庇护所';
        } else if (apparentTempC < -25) {
            level = '严寒';
            description = '非常危险';
            activity = '仅在必要时进行户外活动';
            warning = '限制户外时间';
        } else if (apparentTempC < 10) {
            level = '寒冷';
            description = '需要保暖';
            activity = '户外活动需要保暖衣物';
            warning = '注意防寒';
        } else if (apparentTempC < 20) {
            level = '舒适';
            description = '舒适温度';
            activity = '适合各种户外活动';
            warning = '无特殊警告';
        } else if (apparentTempC < 30) {
            level = '温暖';
            description = '舒适温暖';
            activity = '适合户外活动';
            warning = '正常活动';
        } else if (apparentTempC < 40) {
            level = '炎热';
            description = '需要防晒补水';
            activity = '户外活动需要防晒';
            warning = '注意中暑风险';
        } else {
            level = '极热';
            description = '极其危险';
            activity = '限制户外活动';
            warning = '高中暑风险';
        }
        
        return {
            '舒适度等级': level,
            '描述': description,
            '活动建议': activity,
            '健康警告': warning
        };
    }
    
    analyzeWeather(tempC: number, humidity: number, windSpeedKmh: number): string {
        const analysis: Record<string, any> = {};
        
        analysis['实际温度'] = tempC.toFixed(1) + '°C';
        analysis['相对湿度'] = humidity.toFixed(1) + '%';
        analysis['风速'] = windSpeedKmh.toFixed(1) + ' km/h';
        
        const heatIndex = this.calculateHeatIndex(tempC, humidity);
        const windChill = this.calculateWindChill(tempC, windSpeedKmh);
        const apparentTemp = this.calculateApparentTemperature(tempC, humidity, windSpeedKmh / 3.6);
        
        analysis['热指数'] = heatIndex.toFixed(1) + '°C';
        analysis['风寒指数'] = windChill.toFixed(1) + '°C';
        analysis['体感温度'] = apparentTemp.toFixed(1) + '°C';
        
        const comfort = this.assessComfort(apparentTemp);
        analysis['舒适度'] = comfort['舒适度等级'];
        analysis['活动建议'] = comfort['活动建议'];
        analysis['健康警告'] = comfort['健康警告'];
        
        return JSON.stringify(analysis, null, 2);
    }
    
    async executeCalculation() {
        this.isLoading = true;
        
        try {
            const temp = parseFloat(this.temperature);
            const humidity = parseFloat(this.humidity);
            const wind = parseFloat(this.windSpeed);
            
            if (isNaN(temp) || isNaN(humidity) || isNaN(wind)) {
                this.result = '请输入有效的数值';
                this.isLoading = false;
                return;
            }
            
            let result = '';
            switch (this.selectedTool) {
                case '热指数':
                    const heatIndex = this.calculateHeatIndex(temp, humidity);
                    result = `热指数: ${heatIndex.toFixed(1)}°C`;
                    break;
                case '风寒指数':
                    const windChill = this.calculateWindChill(temp, wind);
                    result = `风寒指数: ${windChill.toFixed(1)}°C`;
                    break;
                case '体感温度':
                    const apparent = this.calculateApparentTemperature(temp, humidity, wind / 3.6);
                    result = `体感温度: ${apparent.toFixed(1)}°C`;
                    break;
                case '舒适度评估':
                    const apparent2 = this.calculateApparentTemperature(temp, humidity, wind / 3.6);
                    const comfort = this.assessComfort(apparent2);
                    result = `舒适度: ${comfort['舒适度等级']}\n${comfort['活动建议']}`;
                    break;
                case '完整分析':
                    result = this.analyzeWeather(temp, humidity, wind);
                    break;
            }
            
            this.result = result;
            
            const allRes = [];
            allRes.push(`热指数: ${this.calculateHeatIndex(temp, humidity).toFixed(1)}°C`);
            allRes.push(`风寒指数: ${this.calculateWindChill(temp, wind).toFixed(1)}°C`);
            allRes.push(`体感温度: ${this.calculateApparentTemperature(temp, humidity, wind / 3.6).toFixed(1)}°C`);
            allRes.push(`完整分析:\n${this.analyzeWeather(temp, humidity, wind)}`);
            
            this.allResults = `所有结果:\n${allRes.join('\n\n')}`;
        } catch (error) {
            this.result = '执行错误：' + error;
        }
        
        this.isLoading = false;
    }
    
    build() {
        Column() {
            Row() {
                Text('温度体感指数计算器')
                    .fontSize(24)
                    .fontWeight(FontWeight.Bold)
                    .fontColor(Color.White)
            }
            .width('100%')
            .height(60)
            .backgroundColor('#1565C0')
            .justifyContent(FlexAlign.Center)
            
            Scroll() {
                Column({ space: 16 }) {
                    Column() {
                        Text('温度 (°C):')
                            .fontSize(14)
                            .fontWeight(FontWeight.Bold)
                            .width('100%')
                        
                        TextInput({ placeholder: '请输入温度' })
                            .value(this.temperature)
                            .onChange((value: string) => {
                                this.temperature = value;
                            })
                            .width('100%')
                            .height(60)
                            .padding(8)
                            .backgroundColor(Color.White)
                            .borderRadius(4)
                    }
                    .width('100%')
                    .padding(12)
                    .backgroundColor('#E3F2FD')
                    .borderRadius(8)
                    
                    Column() {
                        Text('相对湿度 (%):')
                            .fontSize(14)
                            .fontWeight(FontWeight.Bold)
                            .width('100%')
                        
                        TextInput({ placeholder: '请输入湿度' })
                            .value(this.humidity)
                            .onChange((value: string) => {
                                this.humidity = value;
                            })
                            .width('100%')
                            .height(60)
                            .padding(8)
                            .backgroundColor(Color.White)
                            .borderRadius(4)
                    }
                    .width('100%')
                    .padding(12)
                    .backgroundColor('#E3F2FD')
                    .borderRadius(8)
                    
                    Column() {
                        Text('风速 (km/h):')
                            .fontSize(14)
                            .fontWeight(FontWeight.Bold)
                            .width('100%')
                        
                        TextInput({ placeholder: '请输入风速' })
                            .value(this.windSpeed)
                            .onChange((value: string) => {
                                this.windSpeed = value;
                            })
                            .width('100%')
                            .height(60)
                            .padding(8)
                            .backgroundColor(Color.White)
                            .borderRadius(4)
                    }
                    .width('100%')
                    .padding(12)
                    .backgroundColor('#E3F2FD')
                    .borderRadius(8)
                    
                    Column() {
                        Text('选择工具:')
                            .fontSize(14)
                            .fontWeight(FontWeight.Bold)
                            .width('100%')
                        
                        Select([
                            { value: '热指数' },
                            { value: '风寒指数' },
                            { value: '体感温度' },
                            { value: '舒适度评估' },
                            { value: '完整分析' }
                        ])
                            .value(this.selectedTool)
                            .onSelect((index: number, value: string) => {
                                this.selectedTool = value;
                            })
                            .width('100%')
                    }
                    .width('100%')
                    .padding(12)
                    .backgroundColor('#E3F2FD')
                    .borderRadius(8)
                    
                    if (this.result) {
                        Column() {
                            Text('结果:')
                                .fontSize(14)
                                .fontWeight(FontWeight.Bold)
                                .width('100%')
                            
                            Text(this.result)
                                .fontSize(12)
                                .width('100%')
                                .padding(8)
                                .backgroundColor('#F5F5F5')
                                .borderRadius(4)
                        }
                        .width('100%')
                        .padding(12)
                        .backgroundColor('#F5F5F5')
                        .borderRadius(8)
                    }
                    
                    if (this.allResults) {
                        Column() {
                            Text('所有结果:')
                                .fontSize(14)
                                .fontWeight(FontWeight.Bold)
                                .width('100%')
                            
                            Text(this.allResults)
                                .fontSize(12)
                                .width('100%')
                                .padding(8)
                                .backgroundColor('#E8F5E9')
                                .borderRadius(4)
                        }
                        .width('100%')
                        .padding(12)
                        .backgroundColor('#E8F5E9')
                        .borderRadius(8)
                    }
                    
                    Button('计算')
                        .width('100%')
                        .onClick(() => this.executeCalculation())
                        .enabled(!this.isLoading)
                    
                    if (this.isLoading) {
                        LoadingProgress()
                            .width(40)
                            .height(40)
                    }
                }
                .width('100%')
                .padding(16)
            }
            .layoutWeight(1)
        }
        .width('100%')
        .height('100%')
        .backgroundColor('#FAFAFA')
    }
}