@mapcatch/util 1.0.15 → 2.0.0

package/src/measure/index.js

@@ -0,0 +1,198 @@
+import cdt2d from 'cdt2d'
+import _ from 'lodash'
+import TileCache from './tile_cache'
+import { getTileCoord, getTilePixelCoord, geographicToCartesian } from '../transform'
+import { rgbaToFloat } from '../util'
+
+class Measurement {
+  constructor (options) {
+    if (!options.loadTileImage) {
+      throw new Error('未指定加载瓦片数据的方法')
+    }
+    this.tileCache = new TileCache({
+      loadTileImage: options.loadTileImage,
+      maxCacheSize: options.maxCacheSize || 200
+    })
+  }
+
+  
+  // 从dsm中获取指定位置的高程
+  async getFloatValue (lngLat, options) {
+    if (lngLat[2]) {
+      // 如果传入的坐标本身带有高程，则不用去dsm中获取高程
+      return _.round(lngLat[2], 4)
+    }
+    let {tilejson} = options
+    if (!tilejson) {
+      // 没有dsm
+      return 0
+    }
+    let { max_zoom } = tilejson
+    let { min, max } = tilejson.metadata
+    let tileCoord = getTileCoord(max_zoom, lngLat)
+    let pixelCoord = getTilePixelCoord(max_zoom, lngLat)
+    let tile = this.tileCache.getTile(tileCoord, options)
+    if (!tile) {
+      tile = this.tileCache.addTile(tileCoord, options)
+    }
+    if (!tile.loaded) {
+      await tile.tileData
+    }
+    if (!tile.tileData) {
+      // 没找到瓦片，说明该点超出瓦片范围，默认给一个平均值
+      return _.round((min + max) / 2, 4)
+    }
+    let pixelIndex = (pixelCoord.y * 512 + pixelCoord.x) * 4
+    let value = rgbaToFloat([
+      tile.tileData[pixelIndex],
+      tile.tileData[pixelIndex + 1],
+      tile.tileData[pixelIndex + 2],
+      tile.tileData[pixelIndex + 3]
+    ])
+    if (Math.abs(value + 99999) <= Math.max(Math.abs(value), Math.abs(-99999)) * 0.0001) {
+      // 无效值
+      return _.round((min + max) / 2, 4)
+    }
+    return _.round(value, 4)
+  }
+
+  async getMeasureInfo (options) {
+    let { data_type, geometry } = options
+    let type = geometry.type
+    let properties = {}
+    if (type === 'Point') {
+      // 点要素
+      let value = await this.getFloatValue(geometry.coordinates, options)
+      if (data_type === 'infrared') {
+        // 红外
+        properties.temprature = _.round(value, 4)
+        properties.lng = geometry.coordinates[0]
+        properties.lat = geometry.coordinates[1]
+      } else {
+        geometry.coordinates[2] = value
+        properties.height = value
+        properties.lng = geometry.coordinates[0]
+        properties.lat = geometry.coordinates[1]
+      }
+    } else if (type === 'LineString') {
+      let coordinates = geometry.coordinates
+      let slopes = []
+      let values = await Promise.all(coordinates.map(coord => this.getFloatValue(coord, options)))
+      if (data_type === 'infrared') {
+        // 红外
+        properties.distance2d = this.getDistance2D(coordinates)
+        properties.temprature_min = _.round(_.min(values), 4)
+        properties.temprature_max = _.round(_.max(values), 4)
+      } else {
+        coordinates.forEach((coord, index) => {
+          coord[2] = values[index]
+          if (index > 0) {
+            slopes.push(this.getSlope(coordinates[index - 1], coordinates[index]))
+          }
+        })
+        properties.distance2d = this.getDistance2D(coordinates)
+        properties.distance3d = this.getDistance3D(coordinates)
+        properties.height_min = _.min(values)
+        properties.height_max = _.max(values)
+        properties.slope_min = _.min(slopes)
+        properties.slope_max = _.max(slopes)
+      }
+    } else if (type === 'Polygon') {
+      let coordinates = geometry.coordinates[0]
+      let values = await Promise.all(coordinates.map(coord => this.getFloatValue(coord, options)))
+      if (data_type === 'infrared') {
+        // 红外
+        properties.distance2d = this.getDistance2D(coordinates)
+        properties.area2d = this.getArea(coordinates).area2d
+        properties.temprature_min = _.round(_.min(values), 4)
+        properties.temprature_max = _.round(_.max(values), 4)
+      } else {
+        coordinates.forEach((coord, index) => {
+          coord[2] = values[index]
+        })
+        properties.distance2d = this.getDistance2D(coordinates)
+        properties.distance3d = this.getDistance3D(coordinates)
+        properties.height_min = _.min(values)
+        properties.height_max = _.max(values)
+        let area = this.getArea(coordinates)
+        properties.area2d = area.area2d
+        properties.area3d = area.area3d
+      }
+    }
+    return { geometry, properties }
+  }
+
+  getSlope (from, to) {
+    let d = this.getDistance3D([from, to])
+    let hDiff = Math.abs(from[2] - to[2]) // 高差
+    return _.round((Math.asin(hDiff / d) * 180) / Math.PI, 4)
+  }
+
+  getDistance2D (coordinates) {
+    let d = 0
+    for (let i = 1; i < coordinates.length; i++) {
+      let p1 = geographicToCartesian([coordinates[i - 1][0], coordinates[i - 1][1], 0])
+      let p2 = geographicToCartesian([coordinates[i][0], coordinates[i][1], 0])
+      d += Math.sqrt(
+        Math.pow(p1[0] - p2[0], 2) + Math.pow(p1[1] - p2[1], 2) + Math.pow(p1[2] - p2[2], 2)
+      )
+    }
+    return _.round(d, 4)
+  }
+
+  getDistance3D (coordinates) {
+    let d = 0
+    for (let i = 1; i < coordinates.length; i++) {
+      let p1 = geographicToCartesian(coordinates[i - 1])
+      let p2 = geographicToCartesian(coordinates[i])
+      d += Math.sqrt(
+        Math.pow(p1[0] - p2[0], 2) + Math.pow(p1[1] - p2[1], 2) + Math.pow(p1[2] - p2[2], 2)
+      )
+    }
+    return _.round(d, 4)
+  }
+
+  getArea (coordinates) {
+    let triangles = []
+    let flatCoordinates
+    let projs = [coordinates.map(d => [d[0], d[1]]), coordinates.map(d => [d[0], d[2]]), coordinates.map(d => [d[1], d[2]])] // 三个投影平面
+    let flatCoordinates2d = projs[0] // 2D地图的投影平面
+
+    while (!triangles.length && projs.length) { // 寻找可成功分解的投影平面
+      flatCoordinates = projs.shift()
+      flatCoordinates.pop() // 去掉最后一个重复的点
+      let edges = []
+      flatCoordinates.forEach((coord, index) => {
+        if (index === flatCoordinates.length - 1) {
+          edges.push([index, 0])
+        } else {
+          edges.push([index, index + 1])
+        }
+      })
+      triangles = cdt2d(flatCoordinates, edges, { exterior: false })
+    }
+
+    let area2d = 0,
+      area3d = 0
+    triangles.forEach(triangle => {
+      let [i1, i2, i3] = triangle
+      area2d += this.getTriangleArea(
+        [flatCoordinates2d[i1][0], flatCoordinates2d[i1][1], 0],
+        [flatCoordinates2d[i2][0], flatCoordinates2d[i2][1], 0],
+        [flatCoordinates2d[i3][0], flatCoordinates2d[i3][1], 0]
+      )
+      area3d += this.getTriangleArea(coordinates[i1], coordinates[i2], coordinates[i3])
+    })
+    return { area2d: _.round(area2d, 4), area3d: _.round(area3d, 4) }
+  }
+
+  // 海伦公式：空间中三角形三个顶点坐标(经纬度），计算三角形面积
+  getTriangleArea (p1, p2, p3) {
+    let a = this.getDistance3D([p1, p2])
+    let b = this.getDistance3D([p2, p3])
+    let c = this.getDistance3D([p3, p1])
+    return Math.sqrt((a + b + c) * (a + b - c) * (a + c - b) * (b + c - a)) / 4
+  }
+}
+
+export default Measurement

package/src/measure/tile_cache.js

@@ -0,0 +1,88 @@
+import { decode, toRGBA8 } from 'upng-js'
+import _ from 'lodash'
+
+class TileCache {
+  constructor (options) {
+    this.tiles = []
+    this._loadTileImage = options.loadTileImage
+    this.MAX_SIZE = options.maxCacheSize
+  }
+
+  addTile (tileCoord, options) {
+    let { user_id, project_id, task_id, data_type } = options
+    let tile = {
+      loaded: false,
+      user_id,
+      project_id,
+      task_id,
+      data_type,
+      tileCoord
+    }
+    tile.tileData = this._loadTileData(tile, options)
+    this.tiles.push(tile)
+    return tile
+  }
+
+  async _loadTileData (tile) {
+    let { user_id, project_id, task_id, data_type, tileCoord } = tile
+    let originalTile = null
+    try {
+      originalTile = await this._loadTileImage(user_id, project_id, task_id, data_type, tileCoord)
+    } catch (err) {
+      console.error(err)
+      originalTile = null
+    }
+    if (!originalTile) {
+      tile.loaded = true
+      tile.lastVisited = new Date()
+      tile.tileData = null
+      return tile
+    }
+    const img = decode(originalTile)
+    const rgba = new Uint8Array(toRGBA8(img)[0])
+    tile.loaded = true
+    tile.lastVisited = new Date()
+    tile.tileData = rgba
+
+    if (this.tiles.length > this.MAX_SIZE) {
+      this.removeTile()
+    }
+    return tile
+  }
+
+  getTile (tileCoord, options) {
+    let { user_id, task_id, data_type } = options
+    for (let tile of this.tiles) {
+      if (
+        tile.user_id === user_id &&
+        tile.task_id === task_id &&
+        tile.data_type === data_type &&
+        _.isEqual(tile.tileCoord, tileCoord)
+      ) {
+        tile.lastVisited = new Date()
+        return tile
+      }
+    }
+    return null
+  }
+
+  removeTile () {
+    // 删除离上次访问时间最长的那个瓦片
+    let tileIndex = -1,
+      tile = null
+    for (let i = 0; i < this.tiles.length; i++) {
+      if (tile && tile.lastVisited > this.tiles[i].lastVisited) {
+        continue
+      }
+      tileIndex = i
+      tile = this.tiles[i]
+    }
+    this.tiles.splice(tileIndex, 1)
+  }
+
+  clear () {
+    this.tiles = []
+  }
+}
+
+export default TileCache

package/src/mvs/index.js

@@ -0,0 +1,26 @@
+import Pbf from 'pbf'
+import getProtoStr from './protos'
+import {compile} from 'pbf/compile'
+import schema from 'protocol-buffers-schema'
+
+function _getProtoVersion (taskInfo) {
+  let version = '1.0'
+  if (taskInfo.metadata?.environment) {
+    return taskInfo.metadata.environment.protoVersion
+  }
+  return version
+}
+
+export function parseMVS (buffer, taskInfo) {
+  if (!taskInfo.task_id || !buffer) {
+    return
+  }
+  let protoVersion = _getProtoVersion(taskInfo)
+  let protoStr = getProtoStr(protoVersion)
+  if (!protoStr) {
+    throw new Error('不支持的格式')
+  }
+  let proto = schema.parse(protoStr)
+  let {MVSBlock} = compile(proto)
+  return MVSBlock.read(new Pbf(buffer))
+}

package/src/mvs/protos/index.js

@@ -0,0 +1,12 @@
+import proto_10 from './proto_10'
+
+function getProtoStr (version) {
+  switch (version) {
+    case '1.0':
+      return proto_10
+    default:
+      return ''
+  }
+}
+
+export default getProtoStr

package/src/mvs/protos/proto_10.js

@@ -0,0 +1,155 @@
+export default `
+syntax = "proto2";
+package mipmap.engine.message;
+
+message Point3d {
+    required double x = 1;
+    required double y = 2;
+    required double z = 3;
+}
+
+message Point2f {
+    required float x = 1;
+    required float y = 2;
+}
+
+message Point3f {
+    required float x = 1;
+    required float y = 2;
+    required float z = 3;
+}
+
+message ImageRect {
+    required int32 x = 1;
+    required int32 y = 2;
+    required int32 width = 3;
+    required int32 height = 4;
+}
+
+message BoundingBox3d {
+    repeated Point3d corner = 1; //长度为8，按照Eigen::BoundingBox3d排列
+}
+
+message CoordinateSystem {
+    enum CoordinateSystemType {
+        LOCAL_ENU = 0;
+        LOCAL = 1;
+        Geographic = 2;
+        Projected = 3;
+        Geocentric = 4;
+        Unsupported = 5;
+    };
+    required CoordinateSystemType type = 1;
+    optional int32 epsg_code  = 2;
+    optional string wkt = 3;
+    repeated double offset = 4;
+    repeated double origin_point = 5;
+}
+
+message ImageMetaData {
+    optional Point3d position = 2;
+    optional CoordinateSystem position_cs = 201;
+    optional Point3d position_sigma = 3;
+    optional Point3d pitch_roll_yaw = 4;
+    repeated double rotation_c2w = 5; //size = 9
+    optional double relative_altitude = 6;
+    optional double absolute_altitude = 7;
+
+    enum BandType {
+        RGB = 1;
+        Red = 2;
+        Green= 3;
+        Blue = 4;
+        NIR = 5;
+        RedEdge = 6;
+    };
+    optional BandType band_type = 8;
+    optional string capture_uuid = 9;
+    optional string drone_id = 10;
+    // 多光谱影像相关参数
+    optional double black_current = 11;
+    repeated double vignetting_data = 12; //size = 6
+    optional double sensor_gain = 13;
+    optional double sensor_gain_adjustment = 14;
+    optional double exposure_time = 15;
+    optional double irradiance = 16;
+
+    optional string camera_model = 17;
+    required int32 width = 18;
+    required int32 height = 19;
+    optional bool dewrap_flag = 20;
+    optional int32 rtk_flag = 21;
+    optional uint64 capture_time = 22;
+    optional uint32 focal_length_in_35mm = 23;
+    optional uint32 camera_id = 24;
+    repeated double pre_calib_parameters = 25;
+    optional bool position_constant = 26;
+    optional double f_number = 27;
+    optional double ios_speed_rating = 28;
+}
+
+message ControlPoint {
+    required string ctrl_id = 1;
+    required uint32 usage = 2; // 0 for control point, 1 for check point, 2 for no usage
+    required Point3d point = 3;
+    required Point3d sigma = 4;
+    repeated uint32 img_id = 5;
+    repeated Point2f observation = 6;
+}
+
+message ControlPointGroup {
+    repeated ControlPoint points = 1;
+    required CoordinateSystem coordiante_system = 2;
+}
+
+message MVSCamera {
+    enum DistortionType {
+        OPENCV_K1K2K3P1P2 = 1;
+        UnKnow = 2;
+    };
+    required DistortionType distortion_type = 1;
+    optional int32 camera_id = 2;
+    repeated double camera_params = 3;
+    required int32 width = 4;
+    required int32 height = 5;
+}
+
+message MVSImage {
+    required uint32 img_id = 1;
+    optional string img_path = 2;
+    required uint32 camera_id = 3;
+    repeated double projection_matrix = 4;
+    required ImageRect image_rect = 5;
+    repeated double color_params = 6;
+}
+
+message MVSPoint {
+    required Point3d point = 1;
+    optional int32 rgb = 2; // (r << 16) | (g << 8) | b
+}
+
+message MVSObservation {
+    required float x = 1;
+    required float y = 2;
+    required int32 img_index = 3;
+    required int32 pnt_index = 4;
+    optional int32 rgb = 5; // (r << 16) | (g << 8) | b
+}
+
+message ImageMetaDataWithID {
+    required uint32 id=1;
+    required ImageMetaData meta_data=2;
+} 
+
+message MVSBlock {
+    repeated MVSCamera camera = 1;
+    repeated MVSImage image = 2;
+    repeated MVSPoint point = 3;
+    required CoordinateSystem mvs_image_coordinate_system = 5;
+    required BoundingBox3d bounding_box = 6;
+    required BoundingBox3d tight_bounding_box = 7;
+    optional CoordinateSystem meta_data_coordinate_system = 9;
+    optional ControlPointGroup control_point_group = 10;
+    optional string version = 11;
+}
+`

package/src/observation_pretict.js

@@ -0,0 +1,168 @@
+import {mat3, vec3, vec2} from 'gl-matrix'
+import satellite_geo_calc from 'satellite-geo-calc'
+import { transformCoordinateToLngLat } from './transform'
+import * as math from 'mathjs'
+
+// 刺点预测
+/**
+ * 
+ * @param {*} cameraInfo.images 照片列表，包含{img_id, img_path, camera_id, image_rect, projection_matrix}
+ * @param {*} cameraInfo.cameras 相机列表，包含{camera_id， camera_params, width, height}
+ * @param {*} controlPoint 当前控制点，包含{id, coordinate, usage, observations}
+ */
+export function predictObservations (cameraInfo, controlPoint, control_coordinate_system) {
+  let {observations} = controlPoint
+  if (observations.length > 1) {
+    return predictOptimize(cameraInfo, controlPoint)
+  } else {
+    return predictBeforeAT(cameraInfo, controlPoint, control_coordinate_system)
+  }
+}
+
+function predictBeforeAT (cameraInfo, controlPoint, control_coordinate_system) {
+  let {images, cameras, coordinateSystem} = cameraInfo
+  let camersMap = {}
+  cameras.forEach(c => camersMap[c.camera_id] = c)
+  let {coordinate} = controlPoint
+  let Xw = vec3.fromValues(0, 0, 0)
+  if (control_coordinate_system.type === 1) {
+    Xw = vec3.fromValues(coordinate[1], coordinate[1], coordinate[2])
+  } else {
+    let lngLat = transformCoordinateToLngLat(coordinate, control_coordinate_system)
+    let originalPoint = coordinateSystem.origin_point // enu的坐标原点
+    let Xenu = satellite_geo_calc.coordinateTransfer.lla_to_enu({ lon:lngLat[0], lat:lngLat[1], alt: lngLat[2] || 0}, {lon: originalPoint[0], lat: originalPoint[1], alt: originalPoint[2]})
+    Xw = vec3.fromValues(Xenu.x, Xenu.y, Xenu.z)
+  }
+  let predicts = {}
+  images.forEach(image => {
+    let {img_id, camera_id, projection_matrix, image_rect} = image
+    let parameters = camersMap[camera_id].camera_params
+    let {width, height} = image_rect
+    let P = projection_matrix
+    let R = mat3.fromValues(P[0], P[4], P[8], P[1], P[5], P[9], P[2], P[6], P[10]) // 旋转矩阵， 列主序
+    let T = vec3.fromValues(P[3], P[7], P[11]) // 平移向量
+    let K = mat3.fromValues(parameters[0], 0, 0, 0, parameters[1], 0, parameters[2], parameters[3], 1)
+    let ph = vec3.transformMat3(vec3.create(), vec3.add(vec3.create(), vec3.transformMat3(vec3.create(), Xw, R), T), K)
+    let pixelCoord = vec3.scale(vec3.create, ph, 1 / ph[2])
+    if (pixelCoord[0] > 0 && pixelCoord[0] < width && pixelCoord[1] > 0 && pixelCoord[1] < height) {
+      // 加上相机畸变
+      let p_vec = vec3.fromValues(pixelCoord[0], pixelCoord[1], 1)
+      let x_n = vec3.transformMat3(vec3.create(), p_vec, mat3.invert(mat3.create(), K))
+      let dist = distortPoint(x_n, parameters)
+      pixelCoord = vec3.transformMat3(vec3.create(), vec3.fromValues(...dist, 1), K)
+      predicts[img_id] = [pixelCoord[0], pixelCoord[1]]
+      image.predict = {
+        uv: [pixelCoord[0], pixelCoord[1]],
+        position: {left: pixelCoord[0] * 100 / width, top: pixelCoord[1] * 100 / height},
+        distance: Math.hypot(pixelCoord[0] - width / 2, pixelCoord[1] - height / 2)
+      }
+    } else {
+      image.predict = undefined
+    }
+  })
+  return predicts
+}
+
+function predictOptimize (cameraInfo, controlPoint) {
+  let {images, cameras} = cameraInfo
+  let {observations} = controlPoint
+  let camersMap = {}
+  cameras.forEach(c => camersMap[c.camera_id] = c)
+  let predicts = {}, observedImages = [] // 已经刺点的图像
+  let obsevedMap = new Map()
+  observations.forEach((d) => obsevedMap.set(d.id, d.uv))
+  images.forEach(image => { // 第一次循环，找出已经完成刺点的图像，后面需要用这些刺点坐标列方程
+    if (!obsevedMap.has(image.img_id)) {
+      image.observation = undefined
+      return
+    }
+    image.observation = {
+      id: image.img_id,
+      uv: obsevedMap.get(image.img_id)
+    }
+    observedImages.push(image)
+  })
+  // 根据已经刺的点计算控制点的空间坐标
+  let a = [], b = [] // A矩阵和B矩阵的数组，满足Ax + B = 0，其中x未待求的坐标值，行优先
+  observedImages.forEach(observedImage => {
+    let P_m = observedImage.projection_matrix
+    let parameters_m = camersMap[observedImage.camera_id].camera_params
+    let undistort_uv = undistortPoint(observedImage.observation.uv, parameters_m)
+    let R_m = mat3.fromValues(P_m[0], P_m[4], P_m[8], P_m[1], P_m[5], P_m[9], P_m[2], P_m[6], P_m[10]) // 旋转矩阵， 列主序
+    let t_m = vec3.fromValues(P_m[3], P_m[7], P_m[11]) // 平移向量
+    let K_m = mat3.fromValues(parameters_m[0], 0, 0, 0, parameters_m[1], 0, parameters_m[2], parameters_m[3], 1)
+    let K_m_invert = mat3.invert(mat3.create(), K_m) // K_m的逆矩阵
+    // 满足rX = l
+    let undistort_uv_norm = vec3.transformMat3(vec3.create(), undistort_uv, K_m_invert) 
+    a.push([R_m[0] - R_m[2] * undistort_uv_norm[0], R_m[3] - R_m[5] * undistort_uv_norm[0], R_m[6] - R_m[8] * undistort_uv_norm[0]])
+    a.push([R_m[1] - R_m[2] * undistort_uv_norm[1], R_m[4] - R_m[5] * undistort_uv_norm[1], R_m[7] - R_m[8] * undistort_uv_norm[1]])
+    b.push(t_m[2] * undistort_uv_norm[0] - t_m[0], t_m[2] * undistort_uv_norm[1] - t_m[1])
+  })
+  let A = math.matrix(a)
+  let B = math.matrix(b)
+  let A_t = math.transpose(A)
+  let result = math.multiply(math.multiply(math.inv(math.multiply(A_t, A)), A_t), B)
+  let X = vec3.fromValues(result.get([0]), result.get([1]), result.get([2]))
+
+  images.forEach(image => { // 第二次循环，计算未刺点图像上的预测坐标
+    let {img_id, camera_id, projection_matrix, image_rect} = image
+    let parameters = camersMap[camera_id].camera_params
+    let {width, height} = image_rect
+    if (image.observation) { // 已经刺点，不需要预测
+      return image.predict = {
+        uv: image.observation.uv,
+        position: {left: image.observation.uv[0] * 100 / width, top: image.observation.uv[1] * 100 / height},
+        distance: Math.hypot(image.observation.uv[0] - width / 2, image.observation.uv[1] - height / 2)
+      }
+    }
+    let P_n = projection_matrix
+    let R_n = mat3.fromValues(P_n[0], P_n[4], P_n[8], P_n[1], P_n[5], P_n[9], P_n[2], P_n[6], P_n[10]) // 旋转矩阵， 列主序
+    let t_n = vec3.fromValues(P_n[3], P_n[7], P_n[11]) // 平移向量
+    let K_n = mat3.fromValues(parameters[0], 0, 0, 0, parameters[1], 0, parameters[2], parameters[3], 1)
+    let p = vec3.add(vec3.create(), vec3.transformMat3(vec3.create(), X, R_n), t_n)
+    let pixelCoord = vec3.transformMat3(vec3.create(), vec3.fromValues(p[0] / p[2], p[1] / p[2], 1), K_n)
+    if (pixelCoord[0] > 0 && pixelCoord[0] < width && pixelCoord[1] > 0 && pixelCoord[1] < height) {
+      let p_vec = vec3.fromValues(...pixelCoord, 1)
+      let x_n = vec3.transformMat3(vec3.create(), p_vec, mat3.invert(mat3.create(), K_n))
+      let dist = distortPoint(x_n, parameters)
+      pixelCoord = vec3.transformMat3(vec3.create(), vec3.fromValues(...dist, 1), K_n)
+      predicts[img_id] = [pixelCoord[0], pixelCoord[1]]
+      image.predict = {
+        uv: [pixelCoord[0], pixelCoord[1]],
+        position: {left: pixelCoord[0] * 100 / width, top: pixelCoord[1] * 100 / height},
+        distance: Math.hypot(pixelCoord[0] - width / 2, pixelCoord[1] - height / 2)
+      }
+    } else {
+      image.predict = undefined
+    }
+  })
+  return predicts
+}
+
+function undistortPoint (p, parameters) {
+  let K = mat3.fromValues(parameters[0], 0, 0, 0, parameters[1], 0, parameters[2], parameters[3], 1)
+  let p_vec = vec3.transformMat3(vec3.create(), vec3.fromValues(...p, 1), mat3.invert(mat3.create(), K)) // 归一化以后的坐标
+  let iterators = 100
+  let epsilon = 1e-10
+  let undistort = vec2.fromValues(p_vec[0], p_vec[1])
+  let dist = vec2.subtract(vec2.create(), distortPoint(undistort, parameters), undistort)
+  let diff = vec2.subtract(vec2.create(), vec2.add(vec2.create(), undistort, dist), p_vec)
+  while((Math.abs(diff[0]) + Math.abs(diff[1])) > epsilon && iterators-- > 0) {
+    undistort = vec2.subtract(vec2.create(), p_vec, dist)
+    dist = vec2.subtract(vec2.create(), distortPoint(undistort, parameters), undistort)
+    diff = vec2.subtract(vec2.create(), vec2.add(vec2.create(), undistort, dist), p_vec)
+  }
+  return vec3.transformMat3(vec3.create(), vec3.fromValues(...undistort, 1), K)
+}
+
+function distortPoint (p, parameters) {
+  let x3 = [p[0], p[1]]
+  let r2 = x3[0] * x3[0] + x3[1] * x3[1]
+  let r4 = Math.pow(r2, 2)
+  let r6 = Math.pow(r2, 3)
+  let x3_ = [
+    x3[0] * (1 + parameters[4] * r2 + parameters[5] * r4 + parameters[6] * r6) + 2 * parameters[7] * x3[0] * x3[1] + parameters[8] * (r2 + 2 * x3[0] * x3[0]),
+    x3[1] * (1 + parameters[4] * r2 + parameters[5] * r4 + parameters[6] * r6) + 2 * parameters[8] * x3[0] * x3[1] + parameters[7] * (r2 + 2 * x3[1] * x3[1])
+  ]
+  return vec2.fromValues(...x3_)
+}

package/src/photo-parser/exif/gps_tags.js

@@ -0,0 +1,33 @@
+export default {
+  0x0000: 'GPSVersionID',
+  0x0001: 'GPSLatitudeRef',
+  0x0002: 'GPSLatitude',
+  0x0003: 'GPSLongitudeRef',
+  0x0004: 'GPSLongitude',
+  0x0005: 'GPSAltitudeRef',
+  0x0006: 'GPSAltitude',
+  0x0007: 'GPSTimeStamp',
+  0x0008: 'GPSSatellites',
+  0x0009: 'GPSStatus',
+  0x000A: 'GPSMeasureMode',
+  0x000B: 'GPSDOP',
+  0x000C: 'GPSSpeedRef',
+  0x000D: 'GPSSpeed',
+  0x000E: 'GPSTrackRef',
+  0x000F: 'GPSTrack',
+  0x0010: 'GPSImgDirectionRef',
+  0x0011: 'GPSImgDirection',
+  0x0012: 'GPSMapDatum',
+  0x0013: 'GPSDestLatitudeRef',
+  0x0014: 'GPSDestLatitude',
+  0x0015: 'GPSDestLongitudeRef',
+  0x0016: 'GPSDestLongitude',
+  0x0017: 'GPSDestBearingRef',
+  0x0018: 'GPSDestBearing',
+  0x0019: 'GPSDestDistanceRef',
+  0x001A: 'GPSDestDistance',
+  0x001B: 'GPSProcessingMethod',
+  0x001C: 'GPSAreaInformation',
+  0x001D: 'GPSDateStamp',
+  0x001E: 'GPSDifferential'
+}