@mapcatch/util 2.0.5 → 2.0.7

package/src/measure/tile_cache.js

@@ -1,88 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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

@@ -1,168 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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'
-}

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

@@ -1,22 +0,0 @@
-export default {
-  0x0100: 'ImageWidth',
-  0x0101: 'ImageHeight',
-  0x0102: 'BitsPerSample',
-  0x0103: 'Compression',
-  0x0106: 'PhotometricInterpretation',
-  0x0111: 'StripOffsets',
-  0x0112: 'Orientation',
-  0x0115: 'SamplesPerPixel',
-  0x0116: 'RowsPerStrip',
-  0x0117: 'StripByteCounts',
-  0x011A: 'XResolution',
-  0x011B: 'YResolution',
-  0x011C: 'PlanarConfiguration',
-  0x0128: 'ResolutionUnit',
-  0x0201: 'JpegIFOffset',    // When image format is JPEG, this value show offset to JPEG data stored.(aka "ThumbnailOffset" or "JPEGInterchangeFormat")
-  0x0202: 'JpegIFByteCount', // When image format is JPEG, this value shows data size of JPEG image (aka "ThumbnailLength" or "JPEGInterchangeFormatLength")
-  0x0211: 'YCbCrCoefficients',
-  0x0212: 'YCbCrSubSampling',
-  0x0213: 'YCbCrPositioning',
-  0x0214: 'ReferenceBlackWhite'
-}

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

@@ -1,143 +0,0 @@
-import {getData} from './parse_image'
-import {imageSize} from '../image-size'
-import util from './util'
-import SparkMD5 from 'spark-md5'
-
-export const getPhotoMetadata = async (file) => {
-  let extent = getFileExtent(file)
-  let data = {}
-  if (extent === 'jpg' || extent === 'jpeg') {
-    try {
-      data = await _formatMetadata(file)
-    } catch(err) {
-      data = await getImageSize(file)
-    }
-  } else {
-    data = await getImageSize(file)
-  }
-  data.filesize = getFileSize(file)
-  return data
-}
-
-async function _formatMetadata (file, index = 1) {
-  let buffer = await getFileBuffer(file, index)
-  let md5 = getMd5(buffer)
-  return new Promise((resolve, reject) => {
-    getData(buffer, function (img, err) {
-      if (err) {
-        if (err.message === 'Offset is outside the bounds of the DataView' && index < 3) {// 如果前64kb没找到，则尝试搜索128k，最多搜索192k
-          return resolve(_formatMetadata(file, index + 1))
-        } else {
-          return reject(err)
-        }
-      }
-      let {exif, xmp} = getAllTags(img)
-      exif = JSON.parse(JSON.stringify(exif).replaceAll('\\u0000', '')) || {}
-      if (exif.PixelXDimension && exif.PixelYDimension && exif.PixelXDimension != 65535 && exif.PixelYDimension != 65535) {
-        resolve({
-          exif, xmp,
-          width: exif.PixelXDimension,
-          height: exif.PixelYDimension,
-          md5
-        })
-      } else {
-        getImageSize(file).then(size => {
-          resolve({
-            exif, xmp,
-            width: size.width,
-            height: size.height,
-            md5
-          })
-        })
-      }
-    })
-  })
-}
-
-async function getImageSize (file) {
-  try {
-    let buffer = await getFileBuffer(file)
-    let size = imageSize(buffer)
-    let md5 = getMd5(buffer)
-    return {
-      width: size.width,
-      height: size.height,
-      md5
-    }
-  } catch (err) {
-    return {
-      width: 0,
-      height: 0
-    }
-  }  
-}
-
-function getAllTags (img) {
-  if (!util.imageHasData(img)) return {
-    exif: {},
-    xmp: {}
-  }
-  return {
-    exif: img.exifdata || {},
-    xmp: img.xmpdata || {}
-  }
-}
-
-function getFileExtent (file) {
-  if (typeof file === 'string') {
-    return file.split('.').pop().toLowerCase()
-  } else {
-    return file.name.split('.').pop().toLowerCase()
-  }
-}
-
-async function getFileBuffer (file, index) {
-  if ((typeof file) === 'string') {
-    const fs = require('fs')
-    if (!index) {
-      let buffer = fs.readFileSync(file)
-      return buffer.buffer
-    } else {
-      let fd = fs.openSync(file)
-      let buffer = Buffer.alloc(65536 * index)
-      await new Promise((resolve) => {
-        fs.read(fd, buffer, 0, buffer.length, 0, () => {
-          resolve()
-          fs.closeSync(fd)
-        })
-      })
-      return buffer.buffer
-    }
-  } else {
-    if (index) {
-      file = file.slice(0, 65536 * index)
-    }
-    return await new Promise((resolve, reject) => {
-      var fileReader = new FileReader()
-      fileReader.readAsArrayBuffer(file)
-      fileReader.onload = (e) => {
-        resolve(e.target.result)
-      }
-      fileReader.onerror = (error) => {
-        reject(error)
-      }
-    })
-    
-  }
-}
-
-function getFileSize(file) {
-  if (typeof file === 'string') {
-    let stat = fs.statSync(file)
-    data.filesize = stat.size
-  } else {
-    return file.size
-  }
-}
-
-function getMd5 (buffer) {
-  let spark = new SparkMD5.ArrayBuffer()
-  spark.append(buffer)
-  let md5 = spark.end()
-  return md5
-}