/**
|
* 相机视锥投影模块 - Camera Frustum Projection Module
|
*
|
* 参考来源：
|
* 1. demo/Cloud-API-Demo-Web-main - DJI Cloud API Web Demo
|
* 2. demo/DJI-Cloud-API-Demo-main - DJI Cloud API Backend Demo
|
*
|
* 核心功能：将云台相机的姿态转换到绝对的位置和姿态，实现相机视锥投影到地图场景中
|
*
|
* 基于DJI Cloud API Demo中的以下数据结构：
|
* - DockDronePayload: gimbalPitch, gimbalRoll, gimbalYaw
|
* - MediaFileMetadata: gimbalYawDegree, shootPosition, absoluteAltitude
|
* - PayloadControl: CameraAim, PostCameraAimBody
|
*/
|
|
class CameraFrustumProjection {
|
constructor(cesiumViewer) {
|
this.viewer = cesiumViewer;
|
this.frustumEntities = new Map(); // 存储视锥实体
|
this.cameraParams = {
|
// 默认相机参数 - 参考DJI M30系列
|
fov: 84, // 视场角 (度)
|
aspectRatio: 16/9, // 宽高比
|
near: 1.0, // 近裁剪面 (米)
|
far: 1000.0 // 远裁剪面 (米)
|
};
|
}
|
|
/**
|
* 更新相机视锥投影
|
* 基于DJI Cloud API中的云台姿态数据
|
*
|
* @param {Object} droneData - 无人机数据
|
* @param {number} droneData.longitude - 无人机经度
|
* @param {number} droneData.latitude - 无人机纬度
|
* @param {number} droneData.altitude - 无人机高度
|
* @param {Object} gimbalData - 云台姿态数据 (参考DockDronePayload)
|
* @param {number} gimbalData.gimbalPitch - 云台俯仰角 (度)
|
* @param {number} gimbalData.gimbalRoll - 云台滚转角 (度)
|
* @param {number} gimbalData.gimbalYaw - 云台偏航角 (度)
|
* @param {string} droneId - 无人机标识符
|
*/
|
updateCameraFrustum(droneData, gimbalData, droneId = 'default') {
|
try {
|
// 1. 计算相机在世界坐标系中的位置
|
const cameraPosition = this.calculateCameraPosition(droneData, gimbalData);
|
|
// 2. 计算相机姿态矩阵 - 参考DJI Cloud API的姿态数据处理
|
const orientation = this.calculateCameraOrientation(droneData, gimbalData);
|
|
// 3. 创建或更新视锥几何体
|
this.createOrUpdateFrustumEntity(droneId, cameraPosition, orientation);
|
|
console.log(`Camera frustum updated for drone ${droneId}`, {
|
position: cameraPosition,
|
gimbal: gimbalData
|
});
|
|
} catch (error) {
|
console.error('Failed to update camera frustum:', error);
|
}
|
}
|
|
/**
|
* 计算相机位置
|
* 基于DJI Cloud API Demo的精确位置计算
|
* 考虑无人机机体姿态和云台安装偏移
|
*
|
* @param {Object} droneData - 无人机位置数据
|
* @param {Object} gimbalData - 云台数据
|
* @returns {Cesium.Cartesian3} 相机世界坐标位置
|
*/
|
calculateCameraPosition(droneData, gimbalData) {
|
// 1. 无人机位置（地心坐标系）
|
const droneCartesian = Cesium.Cartesian3.fromDegrees(
|
droneData.longitude,
|
droneData.latitude,
|
droneData.altitude
|
);
|
|
// 2. 云台相对于无人机机体的偏移向量
|
// 基于DJI M30/M30T系列的实际测量数据
|
const gimbalOffset = new Cesium.Cartesian3(0, 0, -0.12); // 云台位于机体下方12cm
|
|
// 3. 考虑无人机机体姿态对偏移的影响
|
let droneAttitude = droneData.attitude || { heading: 0, pitch: 0, roll: 0 };
|
|
// 构建机体姿态变换矩阵
|
const droneHeading = Cesium.Math.toRadians(droneAttitude.heading || 0);
|
const dronePitch = Cesium.Math.toRadians(droneAttitude.pitch || 0);
|
const droneRoll = Cesium.Math.toRadians(droneAttitude.roll || 0);
|
|
// 4. 计算局部坐标系变换
|
const eastNorthUpTransform = Cesium.Transforms.eastNorthUpToFixedFrame(droneCartesian);
|
|
// 机体姿态旋转矩阵
|
const droneRotation = Cesium.Matrix3.fromHeadingPitchRoll(
|
new Cesium.HeadingPitchRoll(droneHeading, dronePitch, droneRoll)
|
);
|
|
// 5. 将云台偏移向量从机体坐标系转换到世界坐标系
|
// 先应用机体姿态，再应用局部坐标系变换
|
const localGimbalOffset = Cesium.Matrix3.multiplyByVector(
|
droneRotation,
|
gimbalOffset,
|
new Cesium.Cartesian3()
|
);
|
|
const worldGimbalOffset = Cesium.Matrix4.multiplyByPointAsVector(
|
eastNorthUpTransform,
|
localGimbalOffset,
|
new Cesium.Cartesian3()
|
);
|
|
// 6. 计算云台/相机的最终世界坐标位置
|
const cameraPosition = Cesium.Cartesian3.add(
|
droneCartesian,
|
worldGimbalOffset,
|
new Cesium.Cartesian3()
|
);
|
|
return cameraPosition;
|
}
|
|
/**
|
* 计算相机姿态矩阵
|
* 基于DJI Cloud API Demo的精确姿态转换算法
|
* 将云台相对姿态转换为绝对姿态 - 关键算法
|
*
|
* @param {Object} droneData - 无人机数据
|
* @param {Object} gimbalData - 云台姿态数据
|
* @returns {Cesium.Quaternion} 相机姿态四元数
|
*/
|
calculateCameraOrientation(droneData, gimbalData) {
|
// 1. 获取无人机位置用于坐标系计算
|
const dronePosition = Cesium.Cartesian3.fromDegrees(
|
droneData.longitude,
|
droneData.latitude,
|
droneData.altitude
|
);
|
|
// 2. 建立局部东北天(ENU)坐标系变换矩阵
|
// 这是DJI云台姿态的参考坐标系
|
const eastNorthUpTransform = Cesium.Transforms.eastNorthUpToFixedFrame(dronePosition);
|
|
// 3. 处理无人机机体姿态 (如果数据中包含)
|
// 注意：DJI Cloud API中通常云台姿态已经是相对于地理坐标系的绝对姿态
|
let droneAttitude = droneData.attitude || { heading: 0, pitch: 0, roll: 0 };
|
|
// 4. 云台姿态转换 - 基于DJI Cloud API的角度定义和坐标系约定
|
// DJI标准：
|
// - Pitch(俯仰): 绕Y轴旋转，向下为正
|
// - Roll(滚转): 绕X轴旋转，右倾为正
|
// - Yaw(偏航): 绕Z轴旋转，顺时针为正（从上往下看）
|
|
const gimbalPitch = Cesium.Math.toRadians(gimbalData.gimbalPitch || 0);
|
const gimbalRoll = Cesium.Math.toRadians(gimbalData.gimbalRoll || 0);
|
const gimbalYaw = Cesium.Math.toRadians(gimbalData.gimbalYaw || 0);
|
|
// 无人机机体姿态
|
const droneHeading = Cesium.Math.toRadians(droneAttitude.heading || 0);
|
const dronePitch = Cesium.Math.toRadians(droneAttitude.pitch || 0);
|
const droneRoll = Cesium.Math.toRadians(droneAttitude.roll || 0);
|
|
// 5. 构建复合姿态变换
|
// 按照DJI的姿态叠加原理：机体姿态 + 云台相对姿态
|
|
// 5.1 机体姿态四元数
|
const droneQuaternion = Cesium.Quaternion.fromHeadingPitchRoll(
|
new Cesium.HeadingPitchRoll(droneHeading, dronePitch, droneRoll)
|
);
|
|
// 5.2 云台相对姿态四元数
|
// 注意：DJI云台的Yaw通常是相对于地理北向的绝对方位，而不是相对于机体
|
const gimbalQuaternion = Cesium.Quaternion.fromHeadingPitchRoll(
|
new Cesium.HeadingPitchRoll(gimbalYaw, gimbalPitch, gimbalRoll)
|
);
|
|
// 5.3 组合姿态计算
|
// 对于DJI云台，通常gimbalYaw已经是绝对角度，所以可以直接使用
|
const finalQuaternion = Cesium.Quaternion.multiply(
|
Cesium.Matrix4.getRotation(eastNorthUpTransform, new Cesium.Matrix3()),
|
gimbalQuaternion,
|
new Cesium.Quaternion()
|
);
|
|
// 6. 相机坐标系修正
|
// DJI相机坐标系：X右，Y下，Z前
|
// Cesium坐标系：X右，Y前，Z上
|
// 需要进行坐标系转换
|
const cameraCorrection = Cesium.Quaternion.fromAxisAngle(
|
Cesium.Cartesian3.UNIT_X,
|
Cesium.Math.toRadians(-90) // 绕X轴逆时针旋转90度
|
);
|
|
const correctedOrientation = Cesium.Quaternion.multiply(
|
finalQuaternion,
|
cameraCorrection,
|
new Cesium.Quaternion()
|
);
|
|
return correctedOrientation;
|
}
|
|
/**
|
* 创建或更新视锥实体
|
*
|
* @param {string} droneId - 无人机ID
|
* @param {Cesium.Cartesian3} position - 相机位置
|
* @param {Cesium.Quaternion} orientation - 相机姿态
|
*/
|
createOrUpdateFrustumEntity(droneId, position, orientation) {
|
const entityId = `camera_frustum_${droneId}`;
|
|
// 移除已存在的视锥
|
if (this.frustumEntities.has(droneId)) {
|
this.viewer.entities.remove(this.frustumEntities.get(droneId));
|
}
|
|
// 计算视锥几何参数
|
const frustumGeometry = this.createFrustumGeometry();
|
|
// 创建新的视锥实体
|
const frustumEntity = this.viewer.entities.add({
|
id: entityId,
|
position: position,
|
orientation: orientation,
|
|
// 使用自定义几何体或Cesium内置几何体
|
polylineVolume: {
|
positions: frustumGeometry.positions,
|
shape: frustumGeometry.shape,
|
material: Cesium.Color.YELLOW.withAlpha(0.3),
|
outline: true,
|
outlineColor: Cesium.Color.YELLOW
|
},
|
|
// 备选方案：使用线框表示
|
polyline: {
|
positions: frustumGeometry.wireframe,
|
material: Cesium.Color.CYAN,
|
width: 2,
|
clampToGround: false
|
},
|
|
label: {
|
text: `Camera ${droneId}`,
|
font: '12pt sans-serif',
|
fillColor: Cesium.Color.WHITE,
|
outlineColor: Cesium.Color.BLACK,
|
outlineWidth: 1,
|
verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
|
pixelOffset: new Cesium.Cartesian2(0, -20)
|
}
|
});
|
|
this.frustumEntities.set(droneId, frustumEntity);
|
}
|
|
/**
|
* 创建视锥几何体
|
* 基于相机参数计算视锥的几何形状
|
*
|
* @returns {Object} 视锥几何数据
|
*/
|
createFrustumGeometry() {
|
const { fov, aspectRatio, near, far } = this.cameraParams;
|
|
// 计算视锥顶点
|
const fovRad = Cesium.Math.toRadians(fov);
|
const halfHeight = Math.tan(fovRad / 2);
|
const halfWidth = halfHeight * aspectRatio;
|
|
// 近裁剪面顶点 (相机坐标系)
|
const nearTopLeft = new Cesium.Cartesian3(-halfWidth * near, halfHeight * near, -near);
|
const nearTopRight = new Cesium.Cartesian3(halfWidth * near, halfHeight * near, -near);
|
const nearBottomLeft = new Cesium.Cartesian3(-halfWidth * near, -halfHeight * near, -near);
|
const nearBottomRight = new Cesium.Cartesian3(halfWidth * near, -halfHeight * near, -near);
|
|
// 远裁剪面顶点 (相机坐标系)
|
const farTopLeft = new Cesium.Cartesian3(-halfWidth * far, halfHeight * far, -far);
|
const farTopRight = new Cesium.Cartesian3(halfWidth * far, halfHeight * far, -far);
|
const farBottomLeft = new Cesium.Cartesian3(-halfWidth * far, -halfHeight * far, -far);
|
const farBottomRight = new Cesium.Cartesian3(halfWidth * far, -halfHeight * far, -far);
|
|
// 原点 (相机位置)
|
const origin = new Cesium.Cartesian3(0, 0, 0);
|
|
// 视锥轮廓线
|
const wireframe = [
|
// 从相机到近裁剪面的连线
|
origin, nearTopLeft,
|
origin, nearTopRight,
|
origin, nearBottomLeft,
|
origin, nearBottomRight,
|
|
// 近裁剪面矩形
|
nearTopLeft, nearTopRight,
|
nearTopRight, nearBottomRight,
|
nearBottomRight, nearBottomLeft,
|
nearBottomLeft, nearTopLeft,
|
|
// 到远裁剪面的连线
|
nearTopLeft, farTopLeft,
|
nearTopRight, farTopRight,
|
nearBottomLeft, farBottomLeft,
|
nearBottomRight, farBottomRight,
|
|
// 远裁剪面矩形
|
farTopLeft, farTopRight,
|
farTopRight, farBottomRight,
|
farBottomRight, farBottomLeft,
|
farBottomLeft, farTopLeft
|
];
|
|
return {
|
positions: [origin, farTopLeft, farTopRight, farBottomRight, farBottomLeft], // 用于polylineVolume
|
shape: [new Cesium.Cartesian2(-halfWidth, halfHeight),
|
new Cesium.Cartesian2(halfWidth, halfHeight),
|
new Cesium.Cartesian2(halfWidth, -halfHeight),
|
new Cesium.Cartesian2(-halfWidth, -halfHeight)], // 截面形状
|
wireframe: wireframe
|
};
|
}
|
|
/**
|
* 设置相机参数
|
*
|
* @param {Object} params - 相机参数
|
* @param {number} params.fov - 视场角 (度)
|
* @param {number} params.aspectRatio - 宽高比
|
* @param {number} params.near - 近裁剪面距离
|
* @param {number} params.far - 远裁剪面距离
|
*/
|
setCameraParams(params) {
|
this.cameraParams = { ...this.cameraParams, ...params };
|
}
|
|
/**
|
* 移除指定无人机的视锥投影
|
*
|
* @param {string} droneId - 无人机ID
|
*/
|
removeFrustum(droneId) {
|
if (this.frustumEntities.has(droneId)) {
|
this.viewer.entities.remove(this.frustumEntities.get(droneId));
|
this.frustumEntities.delete(droneId);
|
}
|
}
|
|
/**
|
* 清除所有视锥投影
|
*/
|
clearAllFrustums() {
|
this.frustumEntities.forEach((entity, droneId) => {
|
this.viewer.entities.remove(entity);
|
});
|
this.frustumEntities.clear();
|
}
|
|
/**
|
* 基于DJI CameraAim API的目标瞄准功能
|
* 参考PostCameraAimBody接口
|
*
|
* @param {Object} aimData - 瞄准数据
|
* @param {string} aimData.payload_index - 载荷索引
|
* @param {number} aimData.camera_type - 相机类型
|
* @param {boolean} aimData.locked - 是否锁定
|
* @param {number} aimData.x - 屏幕X坐标 (0-1)
|
* @param {number} aimData.y - 屏幕Y坐标 (0-1)
|
* @returns {Object} 瞄准目标的世界坐标
|
*/
|
calculateAimTarget(aimData, droneData, gimbalData) {
|
// 将屏幕坐标转换为相机射线
|
const { x, y } = aimData;
|
|
// 归一化设备坐标 (NDC)
|
const ndcX = (x - 0.5) * 2; // 转换到 [-1, 1]
|
const ndcY = (0.5 - y) * 2; // 转换到 [-1, 1], Y轴翻转
|
|
// 计算射线方向 (相机坐标系)
|
const fovRad = Cesium.Math.toRadians(this.cameraParams.fov);
|
const halfHeight = Math.tan(fovRad / 2);
|
const halfWidth = halfHeight * this.cameraParams.aspectRatio;
|
|
const rayDirection = new Cesium.Cartesian3(
|
ndcX * halfWidth,
|
ndcY * halfHeight,
|
-1 // 相机坐标系中Z轴向前为负
|
);
|
|
// 转换到世界坐标系
|
const cameraPosition = this.calculateCameraPosition(droneData, gimbalData);
|
const cameraOrientation = this.calculateCameraOrientation(droneData, gimbalData);
|
|
// 将射线方向转换到世界坐标系
|
const worldRayDirection = Cesium.Matrix3.multiplyByVector(
|
Cesium.Matrix3.fromQuaternion(cameraOrientation),
|
rayDirection,
|
new Cesium.Cartesian3()
|
);
|
|
// 与地面求交 (简化处理，假设地面高度为0)
|
const ray = new Cesium.Ray(cameraPosition, worldRayDirection);
|
const intersection = this.viewer.scene.globe.pick(ray, this.viewer.scene);
|
|
return intersection;
|
}
|
}
|
|
// 导出模块
|
window.CameraFrustumProjection = CameraFrustumProjection;
|
|
// 使用示例和API说明
|
/**
|
* 使用示例：
|
*
|
* // 1. 初始化
|
* const frustumProjection = new CameraFrustumProjection(viewer);
|
*
|
* // 2. 设置相机参数 (可选)
|
* frustumProjection.setCameraParams({
|
* fov: 84, // DJI M30系列典型视场角
|
* aspectRatio: 16/9,
|
* near: 1.0,
|
* far: 500.0
|
* });
|
*
|
* // 3. 更新视锥投影
|
* const droneData = {
|
* longitude: 116.3974,
|
* latitude: 39.9093,
|
* altitude: 100
|
* };
|
*
|
* const gimbalData = {
|
* gimbalPitch: -30, // 向下30度
|
* gimbalRoll: 0, // 无滚转
|
* gimbalYaw: 45 // 向右偏转45度
|
* };
|
*
|
* frustumProjection.updateCameraFrustum(droneData, gimbalData, 'drone_001');
|
*
|
* // 4. 计算瞄准目标 (基于DJI CameraAim API)
|
* const aimData = {
|
* payload_index: "52-0-0",
|
* camera_type: 1,
|
* locked: true,
|
* x: 0.5, // 屏幕中心
|
* y: 0.5
|
* };
|
*
|
* const target = frustumProjection.calculateAimTarget(aimData, droneData, gimbalData);
|
*/
|
