回复
鸿蒙跨端天文观测指南系统开发指南 原创
进修的泡芙
发布于 2025-6-22 18:06
浏览
0收藏
鸿蒙跨端天文观测指南系统开发指南
一、系统架构设计
基于HarmonyOS的定位能力和分布式技术，构建智能天文观测系统：
定位服务层：获取用户位置和朝向信息
天文计算层：计算可见星座和天体位置
AR展示层：通过AR技术叠加星座信息
跨端同步层：多设备间同步观测数据和发现
!https://example.com/harmony-astronomy-system-arch.png
二、核心代码实现
天文观测服务
// AstronomyService.ets
import geoLocation from ‘@ohos.geoLocation’;
import distributedData from ‘@ohos.distributedData’;
import { CelestialObject, ObservationRecord, Constellation } from ‘./AstronomyTypes’;
class AstronomyService {
private static instance: AstronomyService = null;
private locationManager: geoLocation.LocationManager;
private dataManager: distributedData.DataManager;
private listeners: AstronomyListener[] = [];
private currentObjects: CelestialObject[] = [];
private currentConstellations: Constellation[] = [];
private constructor() {
this.initLocationManager();
this.initDataManager();
public static getInstance(): AstronomyService {
if (!AstronomyService.instance) {
AstronomyService.instance = new AstronomyService();
return AstronomyService.instance;
private initLocationManager(): void {
try {
this.locationManager = geoLocation.createLocationManager(getContext());
// 监听位置变化
this.locationManager.on('locationChange', (location) => {
this.handleLocationChange(location);
});
// 监听方向变化
this.locationManager.on('orientationChange', (orientation) => {
this.handleOrientationChange(orientation);
});
catch (err) {
console.error('初始化定位管理器失败:', JSON.stringify(err));
}
private initDataManager(): void {
this.dataManager = distributedData.createDataManager({
bundleName: ‘com.example.astronomy’,
area: distributedData.Area.GLOBAL,
isEncrypted: true
});
this.dataManager.registerDataListener('astronomy_sync', (data) => {
this.handleSyncData(data);
});
public async requestPermissions(): Promise<boolean> {
try {
const permissions = [
'ohos.permission.LOCATION',
'ohos.permission.DISTRIBUTED_DATASYNC',
'ohos.permission.CAMERA'
];
const result = await abilityAccessCtrl.requestPermissionsFromUser(
getContext(),
permissions
);
return result.grantedPermissions.length === permissions.length;
catch (err) {
console.error('请求权限失败:', JSON.stringify(err));
return false;
}
public async startObservation(): Promise<void> {
try {
await this.locationManager.startLocating({
priority: geoLocation.LocationRequestPriority.FIRST_FIX,
scenario: geoLocation.LocationRequestScenario.NAVIGATION
});
await this.locationManager.startOrientation({
interval: 1000
});
this.isObserving = true;
catch (err) {
console.error('开始观测失败:', JSON.stringify(err));
throw err;
}
public async stopObservation(): Promise<void> {
try {
await this.locationManager.stopLocating();
await this.locationManager.stopOrientation();
this.isObserving = false;
catch (err) {
console.error('停止观测失败:', JSON.stringify(err));
throw err;
}
private handleLocationChange(location: geoLocation.Location): void {
this.currentLocation = location;
this.updateVisibleObjects();
this.syncLocation(location);
private handleOrientationChange(orientation: geoLocation.Orientation): void {
this.currentOrientation = orientation;
this.updateVisibleObjects();
this.syncOrientation(orientation);
private updateVisibleObjects(): void {
if (!this.currentLocation || !this.currentOrientation) return;
// 计算当前可见的天体和星座
const visibleObjects = this.calculateVisibleObjects(
this.currentLocation,
this.currentOrientation,
new Date()
);
this.currentObjects = visibleObjects.objects;
this.currentConstellations = visibleObjects.constellations;
this.notifyObjectsUpdated(this.currentObjects);
this.notifyConstellationsUpdated(this.currentConstellations);
private calculateVisibleObjects(
location: geoLocation.Location,
orientation: geoLocation.Orientation,
time: Date
): { objects: CelestialObject[], constellations: Constellation[] } {
// 简化的天文计算（实际应用中应使用更精确的天文算法）
const latitude = location.latitude;
const longitude = location.longitude;
const altitude = location.altitude || 0;
const azimuth = orientation.azimuth;
const pitch = orientation.pitch;
const roll = orientation.roll;
// 根据位置和时间计算可见星座
const visibleConstellations = this.getConstellationsForLocation(
latitude,
longitude,
time
);
// 过滤当前朝向可见的星座
const filteredConstellations = visibleConstellations.filter(constellation =>
this.isInView(constellation, azimuth, pitch)
);
// 获取这些星座中的主要恒星
const visibleStars = filteredConstellations.flatMap(
constellation => constellation.stars
);
// 添加太阳系内可见天体（月亮、行星等）
const solarSystemObjects = this.getSolarSystemObjects(time);
return {
objects: [...visibleStars, ...solarSystemObjects],
constellations: filteredConstellations
};
private getConstellationsForLocation(
latitude: number,
longitude: number,
time: Date
): Constellation[] {
// 简化的星座可见性计算
// 实际应用中应使用专业的天文计算库
const season = this.getSeason(time, latitude);
const isNorthernHemisphere = latitude >= 0;
// 根据季节和半球返回可见星座
const allConstellations = this.getAllConstellations();
return allConstellations.filter(constellation => {
if (isNorthernHemisphere) {
return constellation.visibility.northern.includes(season);
else {
return constellation.visibility.southern.includes(season);
});
private getSolarSystemObjects(time: Date): CelestialObject[] {
// 返回当前可见的太阳系天体
// 简化实现，实际应用中应使用精确星历计算
return [
id: ‘moon’,
name: 'Moon',
type: 'planet',
magnitude: -12.7,
rightAscension: this.calculateMoonPosition(time).ra,
declination: this.calculateMoonPosition(time).dec,
distance: 384400 // km
},
id: ‘venus’,
name: 'Venus',
type: 'planet',
magnitude: -4.4,
rightAscension: this.calculateVenusPosition(time).ra,
declination: this.calculateVenusPosition(time).dec,
distance: 108.2 * 1e6 // km
// 添加其他行星…
];
private isInView(
object: CelestialObject | Constellation,
azimuth: number,
pitch: number
): boolean {
// 简化的可见性判断
// 实际应用中应考虑视野范围、遮挡等因素
const objectAzimuth = this.calculateAzimuth(object);
const objectAltitude = this.calculateAltitude(object);
const azimuthDiff = Math.abs(azimuth - objectAzimuth);
const altitudeDiff = Math.abs(pitch - objectAltitude);
return azimuthDiff < 45 && altitudeDiff < 30; // 45度方位角内和30度仰角内
private syncLocation(location: geoLocation.Location): void {
this.dataManager.syncData('location_sync', {
type: 'location_update',
data: location,
timestamp: Date.now()
});
private syncOrientation(orientation: geoLocation.Orientation): void {
this.dataManager.syncData('orientation_sync', {
type: 'orientation_update',
data: orientation,
timestamp: Date.now()
});
private syncDiscovery(discovery: DiscoveryRecord): void {
this.dataManager.syncData('discovery_sync', {
type: 'object_discovered',
data: discovery,
timestamp: Date.now()
});
private handleSyncData(data: any): void {
if (!data) return;
switch (data.type) {
case 'location_update':
this.handleLocationUpdate(data.data);
break;
case 'orientation_update':
this.handleOrientationUpdate(data.data);
break;
case 'object_discovered':
this.handleObjectDiscovered(data.data);
break;
}
private handleLocationUpdate(location: geoLocation.Location): void {
if (this.currentUserLocation &&
this.currentUserLocation.deviceId !== this.localDeviceId) {
this.otherUserLocations = {
…this.otherUserLocations,
[location.deviceId]: location
};
}
private handleOrientationUpdate(orientation: geoLocation.Orientation): void {
if (this.currentUserOrientation &&
this.currentUserOrientation.deviceId !== this.localDeviceId) {
this.otherUserOrientations = {
…this.otherUserOrientations,
[orientation.deviceId]: orientation
};
}
private handleObjectDiscovered(discovery: DiscoveryRecord): void {
this.discoveryRecords = […this.discoveryRecords, discovery];
this.notifyDiscovery(discovery);
private notifyObjectsUpdated(objects: CelestialObject[]): void {
this.listeners.forEach(listener => {
listener.onObjectsUpdated?.(objects);
});
private notifyConstellationsUpdated(constellations: Constellation[]): void {
this.listeners.forEach(listener => {
listener.onConstellationsUpdated?.(constellations);
});
private notifyDiscovery(discovery: DiscoveryRecord): void {
this.listeners.forEach(listener => {
listener.onObjectDiscovered?.(discovery);
});
public async recordDiscovery(objectId: string): Promise<void> {
if (!this.currentLocation || !this.currentOrientation) return;
const object = this.currentObjects.find(obj => obj.id === objectId);
if (!object) return;
const record: DiscoveryRecord = {
id: {objectId}_{Date.now()},
objectId,
objectName: object.name,
location: this.currentLocation,
orientation: this.currentOrientation,
timestamp: Date.now(),
deviceId: this.localDeviceId,
userId: this.localUserId
};
this.discoveryRecords = [...this.discoveryRecords, record];
this.syncDiscovery(record);
public addListener(listener: AstronomyListener): void {
if (!this.listeners.includes(listener)) {
this.listeners.push(listener);
}
public removeListener(listener: AstronomyListener): void {
this.listeners = this.listeners.filter(l => l !== listener);
}
interface AstronomyListener {
onObjectsUpdated?(objects: CelestialObject[]): void;
onConstellationsUpdated?(constellations: Constellation[]): void;
onObjectDiscovered?(discovery: DiscoveryRecord): void;
export const astronomyService = AstronomyService.getInstance();
AR展示组件
// ARView.ets
import { astronomyService } from ‘./AstronomyService’;
import { CelestialObject, Constellation } from ‘./AstronomyTypes’;
import { ARNode, ARScene } from ‘@ohos.ar’;
@Component
export struct ARView {
@State visibleObjects: CelestialObject[] = [];
@State visibleConstellations: Constellation[] = [];
@State showLabels: boolean = true;
@State showConstellations: boolean = true;
@State showPlanets: boolean = true;
@State showStars: boolean = true;
private arScene: ARScene | null = null;
private arNodes: Map<string, ARNode> = new Map();
build() {
Stack() {
// AR场景Surface
Surface({
id: ‘ar_surface’,
type: SurfaceType.SURFACE_TEXTURE,
width: ‘100%’,
height: ‘100%’
})
.onAppear(() => {
this.initARScene();
})
.onDisappear(() => {
this.releaseARScene();
})
// 控制面板
Column() {
Row() {
Toggle({ type: ToggleType.Checkbox, isOn: this.showLabels })
.onChange((isOn) => {
this.showLabels = isOn;
this.updateLabelsVisibility();
})
Text('显示标签')
.fontSize(14)
.margin({ left: 5 })
.margin({ bottom: 10 })
Row() {
Toggle({ type: ToggleType.Checkbox, isOn: this.showConstellations })
.onChange((isOn) => {
this.showConstellations = isOn;
this.updateConstellationsVisibility();
})
Text('显示星座连线')
.fontSize(14)
.margin({ left: 5 })
.margin({ bottom: 10 })
Row() {
Toggle({ type: ToggleType.Checkbox, isOn: this.showPlanets })
.onChange((isOn) => {
this.showPlanets = isOn;
this.updateObjectsVisibility();
})
Text('显示行星')
.fontSize(14)
.margin({ left: 5 })
.margin({ bottom: 10 })
Row() {
Toggle({ type: ToggleType.Checkbox, isOn: this.showStars })
.onChange((isOn) => {
this.showStars = isOn;
this.updateObjectsVisibility();
})
Text('显示恒星')
.fontSize(14)
.margin({ left: 5 })
}
.padding(10)
.backgroundColor('rgba(0,0,0,0.7)')
.borderRadius(8)
.position({ x: 20, y: 20 })
.width(‘100%’)
.height('100%')
.onAppear(() => {
astronomyService.addListener({
onObjectsUpdated: (objects) => {
this.handleObjectsUpdated(objects);
},
onConstellationsUpdated: (constellations) => {
this.handleConstellationsUpdated(constellations);
});
})
.onDisappear(() => {
astronomyService.removeListener({
onObjectsUpdated: (objects) => {
this.handleObjectsUpdated(objects);
},
onConstellationsUpdated: (constellations) => {
this.handleConstellationsUpdated(constellations);
});
})
private initARScene(): void {
try {
this.arScene = new ARScene('ar_surface');
this.arScene.on('planeDetected', (plane) => {
this.handlePlaneDetected(plane);
});
this.arScene.start();
catch (err) {
console.error('初始化AR场景失败:', JSON.stringify(err));
}
private releaseARScene(): void {
if (this.arScene) {
this.arScene.stop();
this.arScene = null;
this.arNodes.clear();
private handleObjectsUpdated(objects: CelestialObject[]): void {
this.visibleObjects = objects;
this.updateARObjects();
private handleConstellationsUpdated(constellations: Constellation[]): void {
this.visibleConstellations = constellations;
this.updateARConstellations();
private updateARObjects(): void {
if (!this.arScene) return;
// 移除不再可见的节点
this.arNodes.forEach((node, id) => {
if (!this.visibleObjects.some(obj => obj.id === id)) {
this.arScene?.removeNode(node);
this.arNodes.delete(id);
});
// 添加或更新可见天体
this.visibleObjects.forEach(object => {
if (!this.shouldShowObject(object)) return;
if (this.arNodes.has(object.id)) {
this.updateObjectNode(object);
else {
this.createObjectNode(object);
});
private updateARConstellations(): void {
if (!this.arScene) return;
// 简化实现：只处理星座连线
// 实际应用中可能需要更复杂的处理
this.visibleConstellations.forEach(constellation => {
if (!this.showConstellations) return;
// 创建或更新星座连线
this.updateConstellationLines(constellation);
});
private shouldShowObject(object: CelestialObject): boolean {
if (object.type = 'planet' || object.type = 'moon') {
return this.showPlanets;
else if (object.type === ‘star’) {
return this.showStars;
return true;
private createObjectNode(object: CelestialObject): void {
if (!this.arScene) return;
const node = this.arScene.createNode();
// 根据天体类型设置不同的外观
if (object.type === 'star') {
const size = this.calculateStarSize(object.magnitude);
node.createSphere(size);
node.setColor(this.calculateStarColor(object));
else {
node.createSphere(0.1); // 行星较小
node.setColor(this.getPlanetColor(object.id));
// 设置位置
const position = this.calculateARPosition(object);
node.setPosition(position.x, position.y, position.z);
// 添加标签
if (this.showLabels) {
const label = this.arScene?.createLabel(object.name, 0.3);
label?.setPosition(position.x + 0.2, position.y + 0.2, position.z);
node.addChild(label);
this.arScene.addNode(node);
this.arNodes.set(object.id, node);
private updateObjectNode(object: CelestialObject): void {
const node = this.arNodes.get(object.id);
if (!node || !this.arScene) return;
const position = this.calculateARPosition(object);
node.setPosition(position.x, position.y, position.z);
// 更新标签
if (this.showLabels) {
let label = node.getChildByName('label');
if (!label) {
label = this.arScene.createLabel(object.name, 0.3);
label.setName('label');
node.addChild(label);
label.setPosition(position.x + 0.2, position.y + 0.2, position.z);
else {
const label = node.getChildByName('label');
if (label) {
node.removeChild(label);
}
private updateConstellationLines(constellation: Constellation): void {
// 创建星座连线
const linesId = constellation_${constellation.id}_lines;
if (this.arNodes.has(linesId)) {
this.updateConstellationLinesNode(constellation);
else {
this.createConstellationLinesNode(constellation);
}
private createConstellationLinesNode(constellation: Constellation): void {
if (!this.arScene) return;
const node = this.arScene.createNode();
const lines = this.arScene.createLines();
// 获取星座中恒星的位置
const starPositions = constellation.stars
.filter(star => this.visibleObjects.some(obj => obj.id === star.id))
.map(star => {
const object = this.visibleObjects.find(obj => obj.id === star.id);
if (!object) return null;
return this.calculateARPosition(object);
})
.filter(pos => pos !== null) as { x: number, y: number, z: number }[];
// 根据星座定义创建连线
constellation.lines.forEach(line => {
const from = starPositions[line.from];
const to = starPositions[line.to];
if (from && to) {
lines.addLine(from.x, from.y, from.z, to.x, to.y, to.z);
});
node.addChild(lines);
this.arScene.addNode(node);
this.arNodes.set(constellation_${constellation.id}_lines, node);
private updateConstellationLinesNode(constellation: Constellation): void {
// 简化实现：重新创建连线
const linesId = constellation_${constellation.id}_lines;
const node = this.arNodes.get(linesId);
if (node && this.arScene) {
this.arScene.removeNode(node);
this.arNodes.delete(linesId);
this.createConstellationLinesNode(constellation);
}
private calculateARPosition(object: CelestialObject): { x: number, y: number, z: number } {
// 简化的位置计算
// 实际应用中应根据天体的方位角、高度角和距离计算AR空间中的位置
const distance = object.type === ‘star’ ? 10 : 5; // 恒星更远
// 将天体的赤经赤纬转换为AR坐标
const azimuth = this.convertRAtoAzimuth(object.rightAscension);
const altitude = this.convertDecToAltitude(object.declination);
// 转换为AR空间坐标
const x = distance Math.sin(azimuth) Math.cos(altitude);
const y = distance * Math.sin(altitude);
const z = -distance Math.cos(azimuth) Math.cos(altitude);
return { x, y, z };
private convertRAtoAzimuth(rightAscension: number): number {
// 将赤经转换为方位角（简化）
return rightAscension * (Math.PI / 12); // 每小时15度
private convertDecToAltitude(declination: number): number {
// 将赤纬转换为高度角（简化）
return declination * (Math.PI / 180);
private calculateStarSize(magnitude: number): number {
// 根据星等计算大小
return 0.1 + (6 - Math.min(6, magnitude)) * 0.05;
private calculateStarColor(object: CelestialObject): number {
// 根据恒星类型返回颜色
if (object.type === 'star') {
// 简化实现，实际应根据光谱类型
return object.magnitude < 0 ? 0xFFD700 : 0xFFFFFF; // 亮星金色，其他白色
return 0xFFFFFF;
private getPlanetColor(planetId: string): number {
const colors: Record<string, number> = {
'mercury': 0xA9A9A9,
'venus': 0xFFA500,
'mars': 0xFF4500,
'jupiter': 0xDAA520,
'saturn': 0xF0E68C,
'uranus': 0xAFEEEE,
'neptune': 0x1E90FF,
'moon': 0xFFFFFF
};
return colors[planetId] || 0xFFFFFF;
private updateLabelsVisibility(): void {
this.arNodes.forEach(node => {
const label = node.getChildByName('label');
if (label) {
label.setVisible(this.showLabels);
});
private updateObjectsVisibility(): void {
this.visibleObjects.forEach(object => {
const node = this.arNodes.get(object.id);
if (node) {
node.setVisible(this.shouldShowObject(object));
});
private updateConstellationsVisibility(): void {
this.visibleConstellations.forEach(constellation => {
const node = this.arNodes.get(constellation_${constellation.id}_lines);
if (node) {
node.setVisible(this.showConstellations);
});
private handlePlaneDetected(plane: ARPlane): void {
// 可以在地面平面上放置参考网格等
}
主界面实现
// MainScreen.ets
import { astronomyService } from ‘./AstronomyService’;
import { DiscoveryRecord, Constellation } from ‘./AstronomyTypes’;
@Component
export struct MainScreen {
@State hasPermission: boolean = false;
@State isObserving: boolean = false;
@State currentDiscovery: DiscoveryRecord[] = [];
@State showDiscoveryList: boolean = false;
@State showConstellationDetails: boolean = false;
@State selectedConstellation: Constellation | null = null;
build() {
Stack() {
// AR视图
ARView()
.width(‘100%’)
.height(‘100%’)
// 控制栏
Column() {
Button(this.isObserving ? '停止观测' : '开始观测')
.width(200)
.height(50)
.fontSize(18)
.onClick(() => {
this.toggleObservation();
})
.margin({ bottom: 20 })
Button('我的发现')
.width(200)
.height(50)
.fontSize(18)
.onClick(() => {
this.showDiscoveryList = true;
})
.width(‘100%’)
.position({ x: 0, y: '80%' })
.alignItems(HorizontalAlign.Center)
// 发现列表
if (this.showDiscoveryList) {
DiscoveryList({
discoveries: this.currentDiscovery,
onClose: () => {
this.showDiscoveryList = false;
},
onSelect: (discovery) => {
this.showDiscoveryDetails(discovery);
})
// 星座详情
if (this.showConstellationDetails && this.selectedConstellation) {
ConstellationDetail({
constellation: this.selectedConstellation,
onClose: () => {
this.showConstellationDetails = false;
})
}
.width('100%')
.height('100%')
.onAppear(() => {
this.checkPermissions();
astronomyService.addListener({
onObjectDiscovered: (discovery) => {
this.handleDiscovery(discovery);
});
})
.onDisappear(() => {
astronomyService.removeListener({
onObjectDiscovered: (discovery) => {
this.handleDiscovery(discovery);
});
if (this.isObserving) {
astronomyService.stopObservation();
})
private toggleObservation(): void {
if (this.isObserving) {
astronomyService.stopObservation();
this.isObserving = false;
else {
if (this.hasPermission) {
astronomyService.startObservation();
this.isObserving = true;
else {
this.requestPermissions();
}
private async checkPermissions(): Promise<void> {
try {
const permissions = [
'ohos.permission.LOCATION',
'ohos.permission.CAMERA',
'ohos.permission.DISTRIBUTED_DATASYNC'
];
const result = await abilityAccessCtrl.verifyPermissions(
getContext(),
permissions
);
this.hasPermission = result.every(perm => perm.granted);
catch (err) {
console.error('检查权限失败:', JSON.stringify(err));
this.hasPermission = false;
}
private async requestPermissions(): Promise<void> {
this.hasPermission = await astronomyService.requestPermissions();
if (!this.hasPermission) {
prompt.showToast({ message: '授权失败，无法使用天文观测功能' });
}
private handleDiscovery(discovery: DiscoveryRecord): void {
this.currentDiscovery = […this.currentDiscovery, discovery];
private showDiscoveryDetails(discovery: DiscoveryRecord): void {
// 导航到发现详情页面
router.push({
url: 'pages/DiscoveryDetail',
params: { discoveryId: discovery.id }
});
private showConstellationDetails(constellation: Constellation): void {
this.selectedConstellation = constellation;
this.showConstellationDetails = true;
}
// 发现列表组件
@Component
struct DiscoveryList {
private discoveries: DiscoveryRecord[];
private onClose: () => void;
private onSelect: (discovery: DiscoveryRecord) => void;
build() {
Column() {
Row() {
Text(‘我的发现’)
.fontSize(20)
.fontWeight(FontWeight.Bold)
.layoutWeight(1)
Button('关闭')
.width(80)
.onClick(() => {
this.onClose();
})
.padding(15)
.width('100%')
if (this.discoveries.length === 0) {
Column() {
Text('暂无发现')
.fontSize(18)
.margin({ bottom: 10 })
Text('开始观测并发现天体后，记录将显示在这里')
.fontSize(16)
.fontColor('#666666')
.padding(20)
.width('90%')
.backgroundColor('#F5F5F5')
.borderRadius(8)
.margin({ top: 50 })
else {
List({ space: 10 }) {
ForEach(this.discoveries, (discovery) => {
ListItem() {
Row() {
Column() {
Text(discovery.objectName)
.fontSize(16)
.fontWeight(FontWeight.Bold)
.margin({ bottom: 5 })
Text(this.formatDateTime(discovery.timestamp))
.fontSize(14)
.fontColor('#666666')
.layoutWeight(1)
Button('查看')
.width(80)
.onClick(() => {
this.onSelect(discovery);
})
.padding(10)
.width('100%')
})
.height(400)
}
.width('90%')
.height('80%')
.backgroundColor('#FFFFFF')
.borderRadius(8)
.position({ x: '5%', y: '10%' })
private formatDateTime(timestamp: number): string {
const date = new Date(timestamp);
return {date.getFullYear()}/{date.getMonth() + 1}/{date.getDate()} {date.getHours()}:${date.getMinutes().toString().padStart(2, '0')};
}
// 星座详情组件
@Component
struct ConstellationDetail {
private constellation: Constellation;
private onClose: () => void;
build() {
Column() {
Row() {
Text(this.constellation.name)
.fontSize(20)
.fontWeight(FontWeight.Bold)
.layoutWeight(1)
Button('关闭')
.width(80)
.onClick(() => {
this.onClose();
})
.padding(15)
.width('100%')
Image(this.constellation.image)
.width(200)
.height(200)
.margin({ bottom: 20 })
Text(this.constellation.description)
.fontSize(16)
.margin({ bottom: 20 })
.padding(10)
Column() {
Text('主要恒星:')
.fontSize(16)
.fontWeight(FontWeight.Bold)
.margin({ bottom: 10 })
ForEach(this.constellation.stars.slice(0, 5), (star) => {
Text(· {star.name} ({star.magnitude.toFixed(1)}等))
.fontSize(14)
.margin({ bottom: 5 })
})
.width(‘100%’)
.padding(10)
.width(‘90%’)
.height('80%')
.backgroundColor('#FFFFFF')
.borderRadius(8)
.padding(20)
.position({ x: '5%', y: '10%' })
}
类型定义
// AstronomyTypes.ets
export interface CelestialObject {
id: string;
name: string;
type: ‘star’ ‘planet’ ‘moon’ ‘galaxy’
‘nebula’;
magnitude: number; // 视星等
rightAscension: number; // 赤经 (小时)
declination: number; // 赤纬 (度)
distance?: number; // 距离 (光年或km)
export interface Constellation {
id: string;
name: string;
abbreviation: string;
stars: CelestialObject[];
lines: { from: number, to: number }[]; // 星座连线
image: Resource;
description: string;
visibility: {
northern: string[]; // 北半球可见季节
southern: string[]; // 南半球可见季节
};
export interface DiscoveryRecord {
id: string;
objectId: string;
objectName: string;
location: geoLocation.Location;
orientation: geoLocation.Orientation;
timestamp: number;
deviceId: string;
userId: string;
export interface ObservationSession {
id: string;
startTime: number;
endTime?: number;
location: geoLocation.Location;
discoveries: string[]; // DiscoveryRecord IDs
participants: string[]; // User IDs
三、项目配置与权限
权限配置
// module.json5
“module”: {
"requestPermissions": [
“name”: “ohos.permission.LOCATION”,
"reason": "获取用户位置以计算可见星座"
},
“name”: “ohos.permission.CAMERA”,
"reason": "使用AR功能展示星座"
},
“name”: “ohos.permission.DISTRIBUTED_DATASYNC”,
"reason": "同步观测数据和发现记录"
],
"abilities": [
“name”: “MainAbility”,
"type": "page",
"visible": true
},
“name”: “ARAbility”,
"type": "service",
"backgroundModes": ["location"]
]
}
四、总结与扩展
本天文观测指南系统实现了以下核心功能：
实时星座识别：根据用户位置和朝向识别可见星座
AR星座展示：通过AR技术将星座信息叠加到现实世界
天体发现记录：记录用户发现的天体和星座
多设备协作：支持多人同时观测并共享发现
扩展方向：
天文事件提醒：提供流星雨、日食等天文事件提醒
天文摄影辅助：帮助定位天体进行天文摄影
天文知识库：集成星座神话和天体科学知识
望远镜控制：支持连接和控制智能望远镜
夜间模式：优化夜间观测的界面显示
社区分享：分享观测记录和天文照片
通过HarmonyOS的分布式技术，我们构建了一个智能化的天文观测助手，能够帮助天文爱好者更方便地识别和观测星座，并在多人观测时实现数据和体验的无缝同步。
©著作权归作者所有，如需转载，请注明出处，否则将追究法律责任
赞
收藏
回复
相关推荐
