hj-gis-sdk 1.0.0 → 1.0.2

package/hj-gis-sdk/addons/tools/ghost.ts

@@ -0,0 +1,31 @@
+import Tool from './base'
+import UERPC from './../../core/ue-rpc'
+import UERPCNode from '../node/ue-node'
+// 虚化
+export default class Ghost extends Tool {
+  constructor(rpc: UERPC) {
+    super(rpc)
+  }
+  async ghost(node: UERPCNode) {
+    await this._rpc.callModule('Visual', 'Ghost', {
+      Ghost: true,
+      handle: node.key
+    })
+    return new GhostHandle(node, this._rpc)
+  }
+}
+
+export class GhostHandle {
+  private _node: UERPCNode
+  private _rpc: UERPC
+  constructor(node: UERPCNode, rpc: UERPC) {
+    this._node = node
+    this._rpc = rpc
+  }
+  async restore() {
+    await this._rpc.callModule('Visual', 'Ghost', {
+      handle: this._node.key,
+      Ghost: false
+    })
+  }
+}

package/hj-gis-sdk/addons/tools/heat-map.ts

@@ -0,0 +1,95 @@
+import Tool from './base'
+import UERPC from '../../core/ue-rpc'
+import { Vector3 } from '@math.gl/core'
+import World from '../world'
+import UERPCNode, { AssetType } from '../node/ue-node'
+import { RPCTransform, Transform } from '../transform'
+
+/**
+ * 热力图点数据类型
+ */
+type HeatMapPoint = {
+  /** 点的 X 坐标 */
+  x: number
+  /** 点的 Y 坐标 */
+  y: number
+  /** 点的权重值 */
+  count: number
+}
+
+type HeatMapParams = {
+  /** 灰度图地址（提供则按图生成，不提供则按点集生成） */
+  url?: string
+  transform: Transform
+  /** 标记字符串（用于后续定位或分组） */
+  tag?: string
+  /** 每格网格尺寸（{ X, Y }，或分别提供 MeshSizeX/MeshSizeY） */
+  meshSize?: { X: number; Y: number } | { MeshSizeX: number; MeshSizeY: number }
+  /** 网格分段数（{ X, Y }，或分别提供 MeshSegX/MeshSegY） */
+  meshSegment?:
+    | { X: number; Y: number }
+    | { MeshSegX: number; MeshSegY: number }
+  /** 整体抬升高度（UU） */
+  heatmapAltitude?: number
+  /** 热值插值缩放（影响平滑度） */
+  lerpScale?: number
+  /** 高度映射比例（影响高度表现） */
+  heightScale?: number
+  /** 不透明度（0–1） */
+  opacity?: number
+  /** 零值处的不透明度（0–1） */
+  zeroValueOpacity?: number
+  /** 影响半径/范围（整数） */
+  influenceSize?: number
+  /** 自发光强度（影响亮度/可视效果） */
+  emissiveStrength?: number
+  /** 点集模式下的点数组（每项 { x, y, count }） */
+  heatMapPoints?: HeatMapPoint[]
+}
+
+/**
+ * 热力图工具类，用于创建热力图
+ */
+export default class HeatMap extends Tool {
+  private _world: World
+  constructor(rpc: UERPC, world: World) {
+    super(rpc)
+    this._world = world
+  }
+  async create(params: HeatMapParams) {
+    let _transform = params.transform || Transform.default()
+    let response = await this._rpc.callModule('HeatMap', 'Create', {
+      url: params.url,
+      X: _transform.position.x,
+      Y: _transform.position.y,
+      Z: _transform.position.z,
+      ScaleX: _transform.scale.x,
+      ScaleY: _transform.scale.y,
+      ScaleZ: _transform.scale.z,
+      Pitch: _transform.rotation.pitch,
+      Yaw: _transform.rotation.yaw,
+      Roll: _transform.rotation.roll,
+      Tag: params.tag,
+      MeshSize: params.meshSize,
+      MeshSegment: params.meshSegment,
+      LerpScale: params.lerpScale,
+      Opacity: params.opacity,
+      HeightScale: params.heightScale,
+      ZeroValueOpacity: params.zeroValueOpacity,
+      InfluenceSize: params.influenceSize,
+      EmissiveStrength: params.emissiveStrength,
+      HeatMapPoints: params.heatMapPoints
+    })
+    let _node = new UERPCNode(
+      this._rpc,
+      response.Handle,
+      {
+        assetType: AssetType.Other
+      },
+      _transform,
+      params.tag
+    )
+    this._world.root.__dangerousRawAdd(_node)
+    return _node
+  }
+}

package/hj-gis-sdk/addons/tools/index.ts

@@ -0,0 +1,25 @@
+import Tool from './base'
+import MatchViewTool from './match-view'
+import WeatherTool from './weather'
+import PickCastTool from './pick-cast'
+import HeatMapTool from './heat-map'
+import ScatterTool from './scatter'
+import FenceTool from './fence'
+import BuildingTool from './building'
+import MeasurementTool from './measurement'
+import DaytimeTool from './daytime'
+import GhostTool from './ghost'
+
+export default {
+  Tool,
+  MatchViewTool,
+  WeatherTool,
+  PickCastTool,
+  HeatMapTool,
+  ScatterTool,
+  FenceTool,
+  BuildingTool,
+  MeasurementTool,
+  DaytimeTool,
+  GhostTool
+}

package/hj-gis-sdk/addons/tools/match-view.ts

@@ -0,0 +1,35 @@
+import { PixelStreaming } from '@epicgames-ps/lib-pixelstreamingfrontend-ue5.5'
+import UERPC from './../../core/ue-rpc'
+import Tool from './base'
+
+const maxView4K = (width: number, height: number) => {
+  const maxWidth = 3840
+  const maxHeight = 2160
+
+  // 如果宽或高任一超过4K限制
+  if (width > maxWidth || height > maxHeight) {
+    const ratio = Math.min(maxWidth / width, maxHeight / height)
+    return {
+      width: Math.ceil(width * ratio),
+      height: Math.ceil(height * ratio)
+    }
+  }
+
+  // 未超过限制，返回原尺寸
+  return { width, height }
+}
+
+export default class MatchView extends Tool {
+  constructor(rpc: UERPC) {
+    super(rpc)
+  }
+  excute() {
+    this._rpc.emitCommand({
+      Command: 'MatchView',
+      'Resolution.Width': maxView4K(window.innerWidth, window.innerHeight)
+        .width,
+      'Resolution.Height': maxView4K(window.innerWidth, window.innerHeight)
+        .height
+    })
+  }
+}

package/hj-gis-sdk/addons/tools/measurement.ts

@@ -0,0 +1,25 @@
+import Tool from './base'
+import UERPC from './../../core/ue-rpc'
+
+export enum MeasurementType {
+  Path = 'Path',
+  Height = 'Height',
+  Area = 'Area'
+}
+
+export default class Measurement extends Tool {
+  constructor(rpc: UERPC) {
+    super(rpc)
+  }
+
+  draw(type: MeasurementType | string) {
+    return this._rpc.callModule('Measurement', 'SetDrawType', {
+      Type: type
+    })
+  }
+  clean() {
+    return this._rpc.callModule('Measurement', 'SetDrawType', {
+      Type: 'Null'
+    })
+  }
+}

package/hj-gis-sdk/addons/tools/pick-cast.ts

@@ -0,0 +1,67 @@
+import Tool from './base'
+import UERPC from '../../core/ue-rpc'
+import { throttle } from './../../utils'
+
+type PickCastResponse = {
+  Geo: {
+    Height: number
+    Latitude: number
+    Longitude: number
+  }
+  HitActor: string
+  Screen: {
+    X: number
+    Y: number
+  }
+  World: {
+    X: number
+    Y: number
+    Z: number
+  }
+}
+
+export default class PickCast extends Tool {
+  constructor(rpc: UERPC) {
+    super(rpc)
+  }
+
+  hover(
+    callback: (data: PickCastResponse) => void,
+    maxDistance = 1_000_000,
+    highlight = false
+  ) {
+    let stream = this._rpc.getStream()
+    let videoElementParent = stream.videoElementParent
+    const onMousemove = throttle(async (event: MouseEvent) => {
+      // console.log(event)
+      const offsetX = event.offsetX
+      const offsetY = event.offsetY
+      let response = await this._rpc.pickPointByScreen(
+        offsetX,
+        offsetY,
+        maxDistance,
+        highlight
+      )
+      callback && callback(response)
+    }, 50)
+    videoElementParent.addEventListener('mousemove', onMousemove)
+    return function finish() {
+      videoElementParent.removeEventListener('mousemove', onMousemove)
+    }
+  }
+  pick(callback: (data: PickCastResponse) => void , maxDistance= 1_000_000 , highlight = true) {
+    let videoElementParent = this._rpc.getStream().videoElementParent
+    let rpc = this._rpc
+    async function onPick(event: MouseEvent) {
+      const offsetX = event.offsetX
+      const offsetY = event.offsetY
+      let response = await rpc.pickPointByScreen(offsetX, offsetY, maxDistance , highlight)
+      callback && callback(response)
+    }
+
+    videoElementParent.addEventListener('click', onPick)
+    return function finish() {
+      videoElementParent.removeEventListener('click', onPick)
+    }
+  }
+}

package/hj-gis-sdk/addons/tools/scatter.ts

@@ -0,0 +1,230 @@
+import Tool from './base'
+import UERPC from './../../core/ue-rpc'
+import { RPCTransform, Transform } from '../transform'
+import { Collector, createDeepProxy } from '../proxy'
+
+interface PointParam {
+  id?: string
+  location: RPCTransform['Location']
+  rotation?: RPCTransform['Rotation']
+  scale?: RPCTransform['Scale']
+  tag?: string
+  textContent?: string
+}
+
+type ScatterParams = {
+  pointParams: PointParam[]
+  widgetSpace?: 'Screen' | 'World'
+}
+
+export default class Scatter extends Tool {
+  constructor(rpc: UERPC) {
+    super(rpc)
+  }
+
+  async create(params: ScatterParams): Promise<ScatterGroupHandler> {
+    let response = await this._rpc.callModule('Point', 'Create', {
+      WidgetSpace: params.widgetSpace,
+      PointParams: params.pointParams.map((item) => {
+        return {
+          Id: item.id,
+          Location: item.location,
+          Rotation: item.rotation,
+          Scale: item.scale,
+          Tag: item.tag,
+          TextContent: item.textContent
+        }
+      })
+    })
+    let _params = [] as PointParam[]
+    for (let i = 0; i < response.CreatedIDs.length; i++) {
+      let id = response.CreatedIDs[i]
+      let param = params.pointParams[i]
+      _params.push({
+        ...param,
+        id
+      })
+    }
+
+    return createScatterGroupHandler(this._rpc, _params)
+  }
+}
+
+class ScatterGroupHandler {
+  private _rpc: UERPC
+  children: PointHandler[] = []
+  get pointsMap() {
+    return this.children.reduce((acc, cur) => {
+      acc[cur.id] = cur
+      return acc
+    }, {} as any)
+  }
+  get tagMap() {
+    return this.children.reduce((acc, cur) => {
+      if (!acc[cur.tag]) {
+        acc[cur.tag] = []
+      }
+      acc[cur.tag].push(cur)
+      return acc
+    }, {} as any)
+  }
+  constructor(rpc: UERPC) {
+    this._rpc = rpc
+  }
+
+  getById(id: string): PointHandler {
+    return this.pointsMap[id]
+  }
+
+  async removeById(id: string) {
+    let handle = this.getById(id)
+    if (handle) {
+      this.children = this.children.filter((child) => child.id !== id)
+      handle.group = undefined
+      await handle.remove()
+    }
+  }
+
+  async removeAll() {
+    let childrenIds = this.children.map((child) => child.id)
+    this.children = []
+    await this._rpc.callModule('Point', 'DeleteByIds', {
+      PointParams: childrenIds.map((item) => {
+        return {
+          Id: item
+        }
+      })
+    })
+  }
+  async removeByTag(tag: string) {
+    let childrenIds: string[] = this.tagMap[tag].map(
+      (child: PointHandler) => child.id
+    )
+    this.children = this.children.filter((child) => child.tag !== tag)
+    await this._rpc.callModule('Point', 'DeleteByIds', {
+      PointParams: childrenIds.map((item) => {
+        return {
+          Id: item
+        }
+      })
+    })
+  }
+}
+
+class PointHandler {
+  private _id: string
+  private _transform: Transform
+  private _textContent?: string
+  private _collector: Collector
+  private _tag: string
+  private _remoteUpdateFlag: boolean
+  private _rpc: UERPC
+  group?: ScatterGroupHandler
+  constructor(
+    id: string,
+    params: {
+      rpc: UERPC
+      transform?: Transform
+      textContent?: string
+      tag?: string
+      group?: ScatterGroupHandler
+    }
+  ) {
+    this._id = id
+    this._rpc = params.rpc
+    this._transform = params.transform || Transform.default()
+    this._textContent = params.textContent
+    this._tag = params.tag || ''
+    this._remoteUpdateFlag = false
+    this._collector = new Collector(this._triggerRemoteUpdate.bind(this))
+    this.group = params.group
+  }
+  get tag() {
+    return this._tag
+  }
+  get id() {
+    return this._id
+  }
+
+  get transform() {
+    return createDeepProxy(this._transform, {}, this._collector)
+  }
+
+  get textContent(): string | undefined {
+    return this._textContent
+  }
+
+  set textContent(value: string) {
+    this._textContent = value
+    this._triggerRemoteUpdate()
+  }
+
+  private _triggerRemoteUpdate() {
+    if (!this._remoteUpdateFlag) {
+      this._remoteUpdateFlag = true
+      this.remoteUpdate()
+    }
+  }
+
+  private remoteUpdate() {
+    let transformObj = this.transform.toRPCJSON()
+    this._rpc.callModule('Point', 'Update', {
+      PointParams: [
+        {
+          Id: this.id,
+          textContent: this.textContent,
+          Location: transformObj.Location,
+          Rotation: transformObj.Rotation,
+          Scale: transformObj.Scale
+        }
+      ]
+    })
+
+    this._remoteUpdateFlag = false
+  }
+
+  async remove() {
+    if (this.group) {
+      // this.group = undefined
+      return this.group.removeById(this.id)
+    }
+    await this._rpc.callModule('Point', 'DeleteByIds', {
+      IDs: [this.id]
+    })
+  }
+}
+
+function createScatterGroupHandler(
+  rpc: UERPC,
+  params: PointParam[]
+): ScatterGroupHandler {
+  let scatterhandler = new ScatterGroupHandler(rpc)
+  let phandler = params.map((param) =>
+    createPointHandler(
+      rpc,
+      {
+        ...param
+      },
+      scatterhandler
+    )
+  )
+
+  scatterhandler.children = phandler
+  return scatterhandler
+}
+
+function createPointHandler(
+  rpc: UERPC,
+  param: PointParam,
+  group?: ScatterGroupHandler
+): PointHandler {
+  // return new PointHandlerQuery()
+  let handler = new PointHandler(param.id!, {
+    rpc,
+    transform: Transform.fromRPCObject({}),
+    textContent: param.textContent,
+    tag: param.tag,
+    group: group
+  })
+  return handler
+}

package/hj-gis-sdk/addons/tools/weather.ts

@@ -0,0 +1,40 @@
+import UERPC from './../../core/ue-rpc'
+
+/**
+ * 天气类型枚举，定义了不同的天气状态
+ */
+export enum WeatherType {
+  /** 晴天 */
+  SUNNY = 'Sunny',
+  /** 雾天 */
+  Foggy = 'Foggy',
+  /** 雨天 */
+  RAIN = 'Rain',
+  /** 雪天 */
+  SNOW = 'Snow'
+}
+
+/**
+ * 天气类，用于管理和控制场景中的天气
+ */
+class Weather {
+  private _rpc: UERPC
+
+  /**
+   * 构造函数
+   */
+  constructor(rpc: UERPC) {
+    this._rpc = rpc
+  }
+
+  /**
+   * 设置天气类型
+   * @param type 天气类型
+   */
+  async setWeather(type: WeatherType | string) {
+    return this._rpc.callModule('Enviorment', 'SetWeather', {
+      Preset: type
+    })
+  }
+}
+export default Weather

package/hj-gis-sdk/addons/transform.ts

@@ -0,0 +1,126 @@
+/**
+ * 变换模块，提供变换相关的类和功能
+ * 用于表示对象的位置、旋转和缩放信息
+ */
+import { Euler, Vector3 } from '@math.gl/core'
+
+export type RPCTransform = {
+  Location?: {
+    X: number
+    Y: number
+    Z: number
+  }
+  Rotation?: {
+    Pitch: number
+    Yaw: number
+    Roll: number
+  }
+  Scale?: {
+    X: number
+    Y: number
+    Z: number
+  }
+}
+
+/**
+ * 变换基类，用于表示对象的位置、旋转和缩放
+ */
+export class OTransform {
+  /** 位置向量 */
+  position: Vector3
+  /** 旋转欧拉角 */
+  rotation: Euler
+  /** 缩放向量 */
+  scale: Vector3
+
+  /**
+   * 构造函数
+   * @param position 位置向量
+   * @param rotation 旋转欧拉角
+   * @param scale 缩放向量
+   */
+  constructor(position: Vector3, rotation: Euler, scale: Vector3) {
+    this.position = position
+    this.rotation = rotation
+    this.scale = scale
+  }
+
+  /**
+   * 创建默认的变换对象
+   * @param params 可选参数对象
+   * @param params.position 位置向量，默认值为新的Vector3实例
+   * @param params.rotation 旋转欧拉角，默认值为新的Euler实例
+   * @param params.scale 缩放向量，默认值为Vector3(1, 1, 1)
+   * @returns 默认的变换对象
+   */
+  static default(params?: {
+    position?: Vector3
+    rotation?: Euler
+    scale?: Vector3
+  }): OTransform {
+    return new OTransform(
+      params?.position || new Vector3(),
+      params?.rotation || new Euler(),
+      params?.scale || new Vector3(1, 1, 1)
+    )
+  }
+}
+
+/**
+ * 变换类，继承自OTransform，用于表示带有标识符的变换对象
+ */
+export class Transform extends OTransform {
+  /**
+   * 构造函数
+ 
+   * @param position 位置向量
+   * @param rotation 旋转欧拉角
+   * @param scale 缩放向量
+   */
+  constructor(position: Vector3, rotation: Euler, scale: Vector3) {
+    super(position, rotation, scale)
+  }
+
+  toRPCJSON() {
+    return {
+      Location: {
+        X: this.position.x,
+        Y: this.position.y,
+        Z: this.position.z
+      },
+      Rotation: {
+        Pitch: this.rotation.pitch,
+        Yaw: this.rotation.yaw,
+        Roll: this.rotation.roll
+      },
+      Scale: {
+        X: this.scale.x,
+        Y: this.scale.y,
+        Z: this.scale.z
+      }
+    }
+  }
+
+  /**
+   * 创建默认的变换对象
+   * @param handle 变换对象的唯一标识符
+   * @returns 默认的变换对象
+   */
+  static default(): Transform {
+    return new Transform(new Vector3(), new Euler(), new Vector3(1, 1, 1))
+  }
+
+  static fromRPCObject(obj: RPCTransform) {
+    return new Transform(
+      obj.Location
+        ? new Vector3(obj.Location.X, obj.Location.Y, obj.Location.Z)
+        : new Vector3(),
+      obj.Rotation
+        ? new Euler(obj.Rotation.Pitch, obj.Rotation.Yaw, obj.Rotation.Roll)
+        : new Euler(),
+      obj.Scale
+        ? new Vector3(obj.Scale.X, obj.Scale.Y, obj.Scale.Z)
+        : new Vector3(1, 1, 1)
+    )
+  }
+}