@mapcatch/util 1.0.15 → 2.0.0

package/src/photo-parser/index.js

@@ -0,0 +1,181 @@
+import {getPhotoMetadata} from './exif'
+import moment from 'moment'
+import * as util from '../util'
+import _ from 'lodash'
+
+export async function parsePhoto (file) {
+  let tags = await getPhotoMetadata(file)
+  const {width, height, exif, xmp, filesize} = tags
+  let imageMetaData = {width, height, filesize}
+  let lng = NaN, lat = NaN, alt = NaN
+  let yaw = NaN, pitch = NaN, roll = NaN
+  let x_std = NaN, y_std = NaN, z_std = NaN
+  let pos = [lng, lat, alt]
+  let flatedXmp = util.flatObject(xmp)
+  let {GPSAltitude, GPSLatitude, GPSLatitudeRef, GPSLongitude, GPSLongitudeRef} = exif
+  if (GPSLongitude && GPSLatitude) {
+    pos = [
+      util.getGeoCoordOperator(GPSLongitudeRef) * util.toRadian(GPSLongitude),
+      util.getGeoCoordOperator(GPSLatitudeRef) * util.toRadian(GPSLatitude),
+      +GPSAltitude
+    ]
+  }
+  for(let key in flatedXmp) {
+    let value = flatedXmp[key]
+    if (key === 'drone-dji:GpsLongtitude' || key === 'drone-dji:GpsLongitude') {
+      lng = Number(value)
+    } else if (key === 'drone-dji:GpsLatitude') {
+      lat = Number(value)
+    } else if (key === 'drone-dji:AbsoluteAltitude') {
+      alt = Number(value)
+    } else if (key === 'drone-dji:GimbalYawDegree') {
+      yaw = Number(value)
+    } else if (key === 'drone-dji:GimbalPitchDegree') {
+      pitch = Number(value)
+    } else if (key === 'drone-dji:GimbalRollDegree') {
+      roll = Number(value)
+    } else if (key === 'drone-dji:RtkStdLon') {
+      x_std = Number(value)
+    } else if (key === 'drone-dji:RtkStdLat') {
+      y_std = Number(value)
+    } else if (key === 'drone-dji:RtkStdHgt') {
+      z_std = Number(value)
+    } else if (key === 'drone-dji:DewarpFlag') {
+      imageMetaData.dewarp_flag = Boolean(Number(value))
+    } else if (key === 'drone-dji:RtkFlag') {
+      imageMetaData.rtk_flag = Number(value)
+    } else if (key === 'drone-dji:RelativeAltitude') {
+      imageMetaData.relative_altitude = Number(value)
+    } else if (key === 'tiff:Model') {
+      imageMetaData.camera_model = value
+    } else if (key === 'drone-dji:DewarpData') {
+      let params = value.split(';')[1].split(',')
+      let pre_calib_param = params.map(d => Number(d))
+      pre_calib_param[2] = width / 2 + pre_calib_param[2]
+      pre_calib_param[3] = height / 2 + pre_calib_param[3]
+      imageMetaData.pre_calib_param = pre_calib_param
+    } else if (key === 'drone-dji:CaptureUUID') {
+      imageMetaData.capture_uuid = value
+    } else if (key === 'drone-dji:DroneID') {
+      imageMetaData.drone_id = value
+    }
+  }
+  for(let key in flatedXmp) {
+    let value = flatedXmp[key]
+    if (key === 'drone-dji:GpsStatus' && value === 'RTK' && Number.isNaN(x_std)) {
+      x_std = 0.02
+      y_std = 0.02
+    } else if (key === 'drone-dji:AltitudeType' && value === 'RtkAlt' && Number.isNaN(z_std)) {
+      z_std = 0.02
+    }
+  }
+  if (!Number.isNaN(x_std) && !Number.isNaN(y_std) && !Number.isNaN(z_std)) {
+    imageMetaData.pos_std = [x_std, y_std, z_std]
+  }
+  if (!Number.isNaN(yaw) && !Number.isNaN(pitch) && !Number.isNaN(roll)) {
+    imageMetaData.pitch_roll_yaw = [pitch, roll, yaw]
+    imageMetaData.orientation = util.getRotationMatrix(pitch, roll, yaw)
+  }
+  if (exif.DateTimeOriginal) {
+    imageMetaData.capture_time = moment(exif.DateTimeOriginal, 'YYYY:MM:DD HH:mm:ss').valueOf()
+  }
+  if (exif.FocalLengthIn35mmFilm) {
+    imageMetaData.focal_length_in_35mm = exif.FocalLengthIn35mmFilm
+  }
+  if (util.hasNaN(pos)) {
+    pos = [lng, lat, alt]
+  }
+  if (!util.hasNaN(pos)) {
+    imageMetaData.pos = pos
+    imageMetaData.absolute_altitude = pos[2]
+    imageMetaData.coordinate_system = {
+      type: 2,
+      label: 'WGS 84',
+      type_name: 'Geographic',
+      epsg_code: 4326
+    }
+    if (!util.hasNaN([x_std, y_std, z_std])) { // 估算pos_sigma
+      let pos_sigma = []
+      let accuracy = Math.sqrt(Math.pow(x_std, 2) + Math.pow(y_std, 2))
+      if (accuracy < 0.03) {
+        pos_sigma[0] = pos_sigma[1] = 0.03
+      } else if (accuracy < 0.2) {
+        pos_sigma[0] = pos_sigma[1] = 0.2
+      } else {
+        pos_sigma[0] = pos_sigma[1] = 2.0
+      }
+
+      if (z_std < 0.03) {
+        pos_sigma[2] = 0.06
+      } else if (z_std < 0.2) {
+        pos_sigma[2] = 0.5
+      } else {
+        pos_sigma[2] = 5.0
+      }
+      imageMetaData.pos_sigma = pos_sigma
+    } else {
+      imageMetaData.pos_sigma = [2, 2, 5]
+    }
+  }
+  return imageMetaData
+}
+
+export function parsePhotos (files, cb) {
+  let cameras = []
+  let processQueue = files
+  let total = files.length
+  let concurrence = 20 // 并发数
+  let request = 0   // 当前正在解析的照片数
+  
+  return new Promise((resolve) => {
+    const run = () => {
+      for(let i = request;i < concurrence;i++) {
+        let file = processQueue.pop()
+        if (!file) {
+          break
+        }
+        request++
+        this.parsePhoto(file).then(meta_data => {
+          request--
+          let ext = file.split('.').pop()
+          let camera = {
+            width: meta_data.width,
+            height: meta_data.height,
+            ext,
+            parameters: meta_data.pre_calib_param || null
+          }
+          let item = cameras.find(d => {
+            return d.width === camera.width && d.height === camera.height && d.ext === camera.ext && _.isEqual(d.parameters, camera.parameters)
+          })
+          if (!item) {
+            item = camera
+            item.fileList = []
+            cameras.push(item)
+          }
+          item.fileList.push({
+            name: file.split('\\').pop(),
+            filePath: file,
+            meta_data
+          })
+          done()
+        }).catch(err => {
+          request--
+          done()
+          console.error(err)
+        })
+      }
+    }
+    const done = () => {
+      if (processQueue.length) {
+        run()
+      } else if (!request) {
+        resolve(cameras)
+      }
+      let parsed = total - processQueue.length - request
+      if (cb) {
+        cb(parsed, total)
+      }
+    }
+    run()
+  })
+}

package/src/report/annotations_report.js

@@ -0,0 +1,446 @@
+import _ from 'lodash'
+import { formatDate, getAnnotationFeature } from '../util'
+import {mapStyle, layerFolders} from '../constants'
+import * as turf from '@turf/turf'
+import mapboxgl from 'mapbox-gl'
+mapboxgl.accessToken =
+  'pk.eyJ1Ijoid2FueWFueWFuIiwiYSI6Im1uNVZnTncifQ.90XY40_yjpItUHO8HnbbpA'
+
+export async function generateReport (params) {
+  let {projectInfo, taskInfo, annotations} = params
+  return {
+    title: '标注报告',
+    projectName: projectInfo.name,
+    taskName: taskInfo.name,
+    user_id: taskInfo.user_id,
+    project_id: taskInfo.project_id,
+    task_id: taskInfo.task_id,
+    data_type: taskInfo.data_type,
+    sections: [
+      {
+        title: '任务概览',
+        content: [
+          {
+            type: 'form',
+            items: getTaskPreview(taskInfo)
+          },
+          {
+            type: 'image',
+            imageType: 'overview'
+          }
+        ]
+      },
+      {
+        title: '标注列表',
+        content: [
+          {
+            type: 'sub-title',
+            label: '点标注'
+          },
+          {
+            type: 'annotation-list',
+            colums: getPointColums(taskInfo.data_type),
+            data: getAnnoData(annotations, 'point')
+          },
+          {
+            type: 'sub-title',
+            label: '线标注'
+          },
+          {
+            type: 'annotation-list',
+            colums: getLineColums(taskInfo.data_type),
+            data: getAnnoData(annotations, 'line')
+          },
+          {
+            type: 'sub-title',
+            label: '面标注'
+          },
+          {
+            type: 'annotation-list',
+            colums: getPolygonColums(taskInfo.data_type),
+            data: getAnnoData(annotations, 'polygon')
+          },
+          {
+            type: 'page-line'  // 分页
+          }
+        ]
+      },
+      {
+        title: '标注详情',
+        content: [
+          {
+            type: 'details',
+            data: getAnnotationDetails(annotations, taskInfo)
+          }
+        ]
+      }
+    ]
+  }
+}
+
+function getTaskPreview (taskInfo) {
+  return [
+    {
+      label: '任务名称',
+      value: taskInfo.name
+    },
+    {
+      label: '任务类型',
+      value: getDataType(taskInfo.data_type)
+    },
+    {
+      label: '数据采集时间',
+      value: formatDate(taskInfo.captured_at)
+    },
+    {
+      label: '重建时间',
+      value: formatDate(taskInfo.completed_at)
+    }
+  ]
+}
+
+function getDataType (type) {
+  if (type === 'infrared') {
+    return '热红外'
+  } else if (type === 'multispectral') {
+    return '多光谱'
+  } else {
+    return '可见光'
+  }
+}
+
+function getPointColums (data_type) {
+  return [
+    {
+      title: '',
+      slot: 'color',
+      key: 'color',
+      width: 100
+    },
+    {
+      title: '名称',
+      key: 'name'
+    },
+    {
+      title: '经度（X）',
+      key: 'x'
+    },
+    {
+      title: '纬度（Y）',
+      key: 'y'
+    },
+    {
+      title: data_type === 'infrared' ? '温度（℃）' : '高度（Z）',
+      key: data_type === 'infrared' ? 'temprature' : 'height'
+    }
+  ]
+}
+
+function getLineColums (data_type) {
+  if (data_type === 'infrared') {
+    return [
+      {
+        title: '',
+        slot: 'color',
+        key: 'color',
+        width: 100
+      },
+      {
+        title: '名称',
+        key: 'name'
+      },
+      {
+        title: '长度（m）',
+        key: 'distance2d'
+      },
+      {
+        title: '最低温度（℃）',
+        key: 'temprature_min'
+      },
+      {
+        title: '最高温度（℃）',
+        key: 'temprature_max'
+      }
+    ]
+  } else {
+    return [
+      {
+        title: '',
+        slot: 'color',
+        key: 'color',
+        width: 100
+      },
+      {
+        title: '名称',
+        key: 'name'
+      },
+      {
+        title: '2D长度（m）',
+        key: 'distance2d'
+      },
+      {
+        title: '3D长度（m）',
+        key: 'distance3d'
+      },
+      {
+        title: '最小坡度（°）',
+        key: 'slope_min'
+      },
+      {
+        title: '最大坡度（°）',
+        key: 'slope_max'
+      },
+      {
+        title: '最小高度（m）',
+        key: 'height_min'
+      },
+      {
+        title: '最大高度（m）',
+        key: 'height_max'
+      }
+    ]
+  }
+}
+
+function getPolygonColums (data_type) {
+  if (data_type === 'infrared') {
+    return [
+      {
+        title: '',
+        slot: 'color',
+        key: 'color',
+        width: 100
+      },
+      {
+        title: '名称',
+        key: 'name'
+      },
+      {
+        title: '面积（㎡）',
+        key: 'area2d'
+      },
+      {
+        title: '周长（m）',
+        key: 'distance2d'
+      },
+      {
+        title: '最低温度（℃）',
+        key: 'temprature_min'
+      },
+      {
+        title: '最高温度（℃）',
+        key: 'temprature_max'
+      }
+    ]
+  } else {
+    return [
+      {
+        title: '',
+        slot: 'color',
+        key: 'color',
+        width: 100
+      },
+      {
+        title: '名称',
+        key: 'name'
+      },
+      {
+        title: '2D面积（㎡）',
+        key: 'area2d'
+      },
+      {
+        title: '3D面积（㎡）',
+        key: 'area3d'
+      },
+      {
+        title: '2D周长（m）',
+        key: 'distance2d'
+      },
+      {
+        title: '3D周长（m）',
+        key: 'distance3d'
+      },
+      {
+        title: '最小高度（m）',
+        key: 'height_min'
+      },
+      {
+        title: '最大高度（m）',
+        key: 'height_max'
+      }
+    ]
+  }
+}
+
+function getAnnoData (annotations, type) {
+  return annotations.filter(d => d.type === type).map(d => {
+    let obj = _.cloneDeep(d)
+    if (type === 'point') {
+      let coord = d.geometry.coordinates
+      obj.x = _.round(coord[0], 6)
+      obj.y = _.round(coord[1], 6)
+    }
+    delete obj.geometry
+    return obj
+  })
+}
+
+function getAnnotationDetails (annotations, taskInfo) {
+  let {data_type} = taskInfo
+  let colums = {
+    point: getPointColums(data_type),
+    line: getLineColums(data_type),
+    polygon: getPolygonColums(data_type)
+  }
+  let sortIndex = {point: 1, line: 2, polygon: 3}
+  let sorted = annotations.sort((a, b) => sortIndex[a.type] - sortIndex[b.type])
+  let items = []
+  let features = []
+  sorted.forEach(anno => {
+    let {id, type, name, color} = anno
+    let data = {}
+    colums[type].forEach(col => {
+      if (col.key === 'color' || col.key === 'name') {
+        return
+      }
+      if (type === 'point') {
+        let coord = anno.geometry.coordinates
+        anno.x = _.round(coord[0], 6)
+        anno.y = _.round(coord[1], 6)
+      }
+      data[col.title] = anno[col.key]
+    })
+    let feature = getAnnotationFeature(anno)
+    features.push(feature)
+    items.push({
+      id, 
+      name,
+      type,
+      color,
+      data,
+      feature,
+      image: ''
+    })
+  })
+  return items
+}
+
+function getStyle (features, report) {
+  let style = _.cloneDeep(mapStyle)
+  style.layers.push({
+    id: 'background',
+    type: 'background',
+    paint: {
+      'background-color': '#000000'
+    }
+  })
+  let {taskName, projectName, user_id, data_type} = report
+  let type = data_type === 'infrared' ? 'tmp' : 'dom'
+  let tileUrl = `http://127.0.0.1:10024/${user_id}/${projectName}/${taskName}/result/2D/${layerFolders[type]}/{z}/{x}/{y}.webp`
+  style.sources.dom_image = {
+    'type': 'raster',
+    'tiles': [ tileUrl ],
+    'tileSize': 512
+  }
+  style.sources.annotation = {
+    type: 'geojson',
+    data: {
+      type: 'FeatureCollection',
+      features
+    }
+  }
+  style.layers.push({
+    'id': 'dom_image',
+    'source': 'dom_image',
+    'type': 'raster'
+  })
+  style.layers.push({
+    'id': 'annotation-point',
+    'type': 'circle',
+    filter: ['==', '$type', 'Point'],
+    source: 'annotation',
+    'paint': {
+      'circle-radius': 10,
+      'circle-color': ['get', 'color']
+    }
+  })
+  style.layers.push({
+    'id': 'annotation-line',
+    'type': 'line',
+    filter: ['!=', '$type', 'Point'],
+    source: 'annotation',
+    'layout': {
+      'line-cap': 'round',
+      'line-join': 'round'
+    },
+    'paint': {
+      'line-color': ['get', 'color'],
+      'line-width': 4
+    }
+  })
+  style.layers.push({
+    'id': 'annotation-polygon',
+    'type': 'fill',
+    filter: ['==', '$type', 'Polygon'],
+    source: 'annotation',
+    'paint': {
+      'fill-color': ['get', 'color'],
+      'fill-opacity': 0.1
+    }
+  })
+  return style
+}
+
+export function initMap (features, report) {
+  return new Promise((resolve) => {
+    let style = getStyle(features, report)
+    let div = document.createElement('div')
+    div.style.width = '800px'
+    div.style.height = '400px'
+    div.style.position = 'absolute'
+    div.style.zIndex = '-1'
+    document.body.appendChild(div)
+    let map = new mapboxgl.Map({
+      container: div,
+      style: style,
+      bearing: 0,
+      pitch: 0,
+      center: [110.9, 32.79],
+      zoom: 4.2,
+      interactive: true,
+      doubleClickZoom: false,
+      dragRotate: false,
+      pitchWithRotate: false,
+      preserveDrawingBuffer: true,
+      localFontFamily: 'sans-serif'
+    })
+    map.on('load', () => {
+      resolve(map)
+    })
+  })
+  
+}
+
+export function removeMap (map) {
+  map.remove()
+  document.body.removeChild(map.getContainer())
+}
+
+export function getImage (map, feature) {
+  let extent = turf.bbox(feature)
+  let {id} = feature.properties
+  map.fitBounds(extent, {
+    animate: false,
+    padding: 50,
+    maxZoom: 19
+  })
+  map.setFilter('annotation-point', ['all', ['==', '$type', 'Point'], ['==', 'id', id]])
+  map.setFilter('annotation-line', ['all', ['!=', '$type', 'Point'], ['==', 'id', id]])
+  map.setFilter('annotation-polygon', ['all', ['==', '$type', 'Polygon'], ['==', 'id', id]])
+  return new Promise((resolve) => {
+    map.once('idle', () => {
+      let canvas = map.getCanvas()
+      resolve(canvas.toDataURL('image/png'))
+    })
+  })
+}

package/src/report/index.js

@@ -0,0 +1,2 @@
+export {default as generateReconstructReport} from './report'
+export * as annotationReport from './annotations_report'

package/src/report/map_util.js

@@ -0,0 +1,81 @@
+import * as turf from '@turf/turf'
+import _ from 'lodash'
+import { transformCoordinateToLngLat } from '../transform'
+
+const EARTH_RADIUS = 6378137
+
+export function getFeatures (photoList, imagePosDiff, zoom) {
+  let features = []
+  let minDiff_z = Infinity
+  let maxDiff_z = -Infinity
+  let ratio = getRatio(zoom, imagePosDiff)
+  let endPoints = []
+  // 先获取坐标系
+  let item = photoList.find(d => d.meta_data.pos)
+  if (item) {
+    let coordinate_system = _.cloneDeep(item.meta_data.coordinate_system)
+    photoList.forEach((photo, index) => {
+      let {meta_data} = photo
+      let startPoint = transformCoordinateToLngLat(meta_data.pos, coordinate_system)
+      if (!startPoint) {
+        return
+      }
+      let id = index + 1
+      let diffItem = imagePosDiff.find(d => d.id === id)
+      if (!diffItem) {
+        return
+      }
+      // 计算z方向的误差最大值，用于给椭圆设置颜色
+      let diffs = diffItem.pos_diff
+      minDiff_z = Math.min(minDiff_z, diffs[2])
+      maxDiff_z = Math.max(maxDiff_z, diffs[2])
+      let endPoint = _.cloneDeep(startPoint)
+      endPoint[0] += diffs[0] * ratio * getDegreePerMeters()
+      endPoint[1] += diffs[1] * ratio * getDegreePerMeters()
+      endPoints.push(endPoint)
+      features.push(turf.lineString([startPoint, endPoint], {
+        diff_x: 100 * diffs[0],
+        diff_y: 100 * diffs[1],
+        diff_z: 100 * diffs[2]
+      }))
+    })
+  }
+  return {
+    geojson: turf.featureCollection(features),
+    ratio,
+    minDiff_z,
+    maxDiff_z,
+    endPoints
+  }
+}
+
+// 获取误差椭圆的缩放系数。要把误差直观反应到地图上需要对误差椭圆进行缩放，其缩放的大小跟误差的大小和当前地图的级别有关
+// 本函数假设要让最大的误差在当前地图层级上显示出30像素的大小，以此来预估缩放系数
+function getRatio (zoom, diffs) {
+  // 最大误差值
+  let max = diffs.reduce((m, item) => {
+    if (!item.pos_diff?.length) {
+      return m
+    }
+    let d = Math.max(Math.abs(item.pos_diff[0]), Math.abs(item.pos_diff[1]))
+    return m > d ? m : d
+  })
+  // 地图上30像素代表的距离
+  let distance = 30 * 2 * Math.PI * EARTH_RADIUS / (Math.pow(2, zoom) * 512)
+  let ratio = distance / max
+  if (ratio < 1) {
+    return Number(ratio.toFixed(1))
+  }
+  if (ratio < 10) {
+    return Math.round(ratio)
+  }
+  if (ratio < 100) {
+    return 10 * parseInt(ratio / 10)
+  }
+  return Math.max(Math.round(ratio / 100) * 100, 100)
+}
+
+// 墨卡托坐标系每米对应的经纬度度数
+function getDegreePerMeters () {
+  return 180 / (Math.PI * EARTH_RADIUS)
+}