@mapcatch/util 2.0.6 → 2.0.7

package/src/photo-parser/image-size/types/pnm.js

@@ -1,74 +0,0 @@
-import { toUTF8String } from './utils'
-
-const PNMTypes = {
-  P1: 'pbm/ascii',
-  P2: 'pgm/ascii',
-  P3: 'ppm/ascii',
-  P4: 'pbm',
-  P5: 'pgm',
-  P6: 'ppm',
-  P7: 'pam',
-  PF: 'pfm'
-}
-
-const handlers = {
-  default: (lines) => {
-    let dimensions = []
-
-    while (lines.length > 0) {
-      const line = lines.shift()
-      if (line[0] === '#') {
-        continue
-      }
-      dimensions = line.split(' ')
-      break
-    }
-
-    if (dimensions.length === 2) {
-      return {
-        height: parseInt(dimensions[1], 10),
-        width: parseInt(dimensions[0], 10)
-      }
-    } else {
-      throw new TypeError('Invalid PNM')
-    }
-  },
-  pam: (lines) => {
-    const size = {}
-    while (lines.length > 0) {
-      const line = lines.shift()
-      if (line.length > 16 || line.charCodeAt(0) > 128) {
-        continue
-      }
-      const [key, value] = line.split(' ')
-      if (key && value) {
-        size[key.toLowerCase()] = parseInt(value, 10)
-      }
-      if (size.height && size.width) {
-        break
-      }
-    }
-
-    if (size.height && size.width) {
-      return {
-        height: size.height,
-        width: size.width
-      }
-    } else {
-      throw new TypeError('Invalid PAM')
-    }
-  }
-}
-
-export const PNM = {
-  validate: (input) => toUTF8String(input, 0, 2) in PNMTypes,
-
-  calculate (input) {
-    const signature = toUTF8String(input, 0, 2)
-    const type = PNMTypes[signature]
-    // TODO: this probably generates garbage. move to a stream based parser
-    const lines = toUTF8String(input, 3).split(/[\r\n]+/)
-    const handler = handlers[type] || handlers.default
-    return handler(lines)
-  }
-}

package/src/photo-parser/image-size/types/psd.js

@@ -1,10 +0,0 @@
-import { toUTF8String, readUInt32BE } from './utils'
-
-export const PSD = {
-  validate: (input) => toUTF8String(input, 0, 4) === '8BPS',
-
-  calculate: (input) => ({
-    height: readUInt32BE(input, 14),
-    width: readUInt32BE(input, 18)
-  })
-}

package/src/photo-parser/image-size/types/svg.js

@@ -1,100 +0,0 @@
-import { toUTF8String } from './utils'
-
-const svgReg = /<svg\s([^>"']|"[^"]*"|'[^']*')*>/
-
-const extractorRegExps = {
-  height: /\sheight=(['"])([^%]+?)\1/,
-  root: svgReg,
-  viewbox: /\sviewBox=(['"])(.+?)\1/i,
-  width: /\swidth=(['"])([^%]+?)\1/
-}
-
-const INCH_CM = 2.54
-const units = {
-  in: 96,
-  cm: 96 / INCH_CM,
-  em: 16,
-  ex: 8,
-  m: (96 / INCH_CM) * 100,
-  mm: 96 / INCH_CM / 10,
-  pc: 96 / 72 / 12,
-  pt: 96 / 72,
-  px: 1
-}
-
-const unitsReg = new RegExp(
-  `^([0-9.]+(?:e\\d+)?)(${Object.keys(units).join('|')})?$`
-)
-
-function parseLength (len) {
-  const m = unitsReg.exec(len)
-  if (!m) {
-    return undefined
-  }
-  return Math.round(Number(m[1]) * (units[m[2]] || 1))
-}
-
-function parseViewbox (viewbox) {
-  const bounds = viewbox.split(' ')
-  return {
-    height: parseLength(bounds[3]),
-    width: parseLength(bounds[2])
-  }
-}
-
-function parseAttributes (root) {
-  const width = root.match(extractorRegExps.width)
-  const height = root.match(extractorRegExps.height)
-  const viewbox = root.match(extractorRegExps.viewbox)
-  return {
-    height: height && (parseLength(height[2])),
-    viewbox: viewbox && (parseViewbox(viewbox[2])),
-    width: width && (parseLength(width[2]))
-  }
-}
-
-function calculateByDimensions (attrs) {
-  return {
-    height: attrs.height,
-    width: attrs.width
-  }
-}
-
-function calculateByViewbox (attrs, viewbox) {
-  const ratio = (viewbox.width) / (viewbox.height)
-  if (attrs.width) {
-    return {
-      height: Math.floor(attrs.width / ratio),
-      width: attrs.width
-    }
-  }
-  if (attrs.height) {
-    return {
-      height: attrs.height,
-      width: Math.floor(attrs.height * ratio)
-    }
-  }
-  return {
-    height: viewbox.height,
-    width: viewbox.width
-  }
-}
-
-export const SVG = {
-  // Scan only the first kilo-byte to speed up the check on larger files
-  validate: (input) => svgReg.test(toUTF8String(input, 0, 1000)),
-
-  calculate (input) {
-    const root = toUTF8String(input).match(extractorRegExps.root)
-    if (root) {
-      const attrs = parseAttributes(root[0])
-      if (attrs.width && attrs.height) {
-        return calculateByDimensions(attrs)
-      }
-      if (attrs.viewbox) {
-        return calculateByViewbox(attrs, attrs.viewbox)
-      }
-    }
-    throw new TypeError('Invalid SVG')
-  }
-}

package/src/photo-parser/image-size/types/tga.js

@@ -1,14 +0,0 @@
-import { readUInt16LE } from './utils'
-
-export const TGA = {
-  validate (input) {
-    return readUInt16LE(input, 0) === 0 && readUInt16LE(input, 4) === 0
-  },
-
-  calculate (input) {
-    return {
-      height: readUInt16LE(input, 14),
-      width: readUInt16LE(input, 12)
-    }
-  }
-}

package/src/photo-parser/image-size/types/tiff.js

@@ -1,92 +0,0 @@
-// based on http://www.compix.com/fileformattif.htm
-// TO-DO: support big-endian as well
-import { readUInt, toHexString, toUTF8String } from './utils'
-
-// Read IFD (image-file-directory) into a buffer
-function readIFD (input, isBigEndian) {
-  const ifdOffset = readUInt(input, 32, 4, isBigEndian)
-  return input.slice(ifdOffset + 2)
-}
-
-// TIFF values seem to be messed up on Big-Endian, this helps
-function readValue (input, isBigEndian) {
-  const low = readUInt(input, 16, 8, isBigEndian)
-  const high = readUInt(input, 16, 10, isBigEndian)
-  return (high << 16) + low
-}
-
-// move to the next tag
-function nextTag (input) {
-  if (input.length > 24) {
-    return input.slice(12)
-  }
-}
-
-// Extract IFD tags from TIFF metadata
-function extractTags (input, isBigEndian) {
-  const tags = {}
-
-  let temp = input
-  while (temp && temp.length) {
-    const code = readUInt(temp, 16, 0, isBigEndian)
-    const type = readUInt(temp, 16, 2, isBigEndian)
-    const length = readUInt(temp, 32, 4, isBigEndian)
-
-    // 0 means end of IFD
-    if (code === 0) {
-      break
-    } else {
-      // 256 is width, 257 is height
-      // if (code === 256 || code === 257) {
-      if (length === 1 && (type === 3 || type === 4)) {
-        tags[code] = readValue(temp, isBigEndian)
-      }
-
-      // move to the next tag
-      temp = nextTag(temp)
-    }
-  }
-
-  return tags
-}
-
-// Test if the TIFF is Big Endian or Little Endian
-function determineEndianness (input) {
-  const signature = toUTF8String(input, 0, 2)
-  if ('II' === signature) {
-    return 'LE'
-  } else if ('MM' === signature) {
-    return 'BE'
-  }
-}
-
-const signatures = [
-  // '492049', // currently not supported
-  '49492a00', // Little endian
-  '4d4d002a' // Big Endian
-  // '4d4d002a', // BigTIFF > 4GB. currently not supported
-]
-
-export const TIFF = {
-  validate: (input) => signatures.includes(toHexString(input, 0, 4)),
-
-  calculate (input) {
-    // Determine BE/LE
-    const isBigEndian = determineEndianness(input) === 'BE'
-
-    // read the IFD
-    const ifdBuffer = readIFD(input, isBigEndian)
-
-    // extract the tags from the IFD
-    const tags = extractTags(ifdBuffer, isBigEndian)
-
-    const width = tags[256]
-    const height = tags[257]
-
-    if (!width || !height) {
-      throw new TypeError('Invalid Tiff. Missing tags')
-    }
-
-    return { height, width }
-  }
-}

package/src/photo-parser/image-size/types/utils.js

@@ -1,83 +0,0 @@
-const decoder = new TextDecoder()
-export const toUTF8String = (
-  input,
-  start = 0,
-  end = input.length
-) => decoder.decode(input.slice(start, end))
-
-export const toHexString = (input, start = 0, end = input.length) =>
-  input
-    .slice(start, end)
-    .reduce((memo, i) => memo + ('0' + i.toString(16)).slice(-2), '')
-
-export const readInt16LE = (input, offset = 0) => {
-  const val = input[offset] + input[offset + 1] * 2 ** 8
-  return val | ((val & (2 ** 15)) * 0x1fffe)
-}
-
-export const readUInt16BE = (input, offset = 0) =>
-  input[offset] * 2 ** 8 + input[offset + 1]
-
-export const readUInt16LE = (input, offset = 0) =>
-  input[offset] + input[offset + 1] * 2 ** 8
-
-export const readUInt24LE = (input, offset = 0) =>
-  input[offset] + input[offset + 1] * 2 ** 8 + input[offset + 2] * 2 ** 16
-
-export const readInt32LE = (input, offset = 0) =>
-  input[offset] +
-  input[offset + 1] * 2 ** 8 +
-  input[offset + 2] * 2 ** 16 +
-  (input[offset + 3] << 24)
-
-export const readUInt32BE = (input, offset = 0) =>
-  input[offset] * 2 ** 24 +
-  input[offset + 1] * 2 ** 16 +
-  input[offset + 2] * 2 ** 8 +
-  input[offset + 3]
-
-export const readUInt32LE = (input, offset = 0) =>
-  input[offset] +
-  input[offset + 1] * 2 ** 8 +
-  input[offset + 2] * 2 ** 16 +
-  input[offset + 3] * 2 ** 24
-
-// Abstract reading multi-byte unsigned integers
-const methods = {
-  readUInt16BE,
-  readUInt16LE,
-  readUInt32BE,
-  readUInt32LE
-}
-
-export function readUInt (
-  input,
-  bits,
-  offset,
-  isBigEndian
-) {
-  offset = offset || 0
-  const endian = isBigEndian ? 'BE' : 'LE'
-  const methodName = 'readUInt' + bits + endian
-  return methods[methodName](input, offset)
-}
-
-function readBox (buffer, offset) {
-  if (buffer.length - offset < 4) return
-  const boxSize = readUInt32BE(buffer, offset)
-  if (buffer.length - offset < boxSize) return
-  return {
-    name: toUTF8String(buffer, 4 + offset, 8 + offset),
-    offset,
-    size: boxSize
-  }
-}
-
-export function findBox (buffer, boxName, offset) {
-  while (offset < buffer.length) {
-    const box = readBox(buffer, offset)
-    if (!box) break
-    if (box.name === boxName) return box
-    offset += box.size
-  }
-}

package/src/photo-parser/image-size/types/webp.js

@@ -1,67 +0,0 @@
-// based on https://developers.google.com/speed/webp/docs/riff_container
-import { toHexString, toUTF8String, readInt16LE, readUInt24LE } from './utils'
-
-function calculateExtended (input) {
-  return {
-    height: 1 + readUInt24LE(input, 7),
-    width: 1 + readUInt24LE(input, 4)
-  }
-}
-
-function calculateLossless (input) {
-  return {
-    height:
-      1 +
-      (((input[4] & 0xf) << 10) | (input[3] << 2) | ((input[2] & 0xc0) >> 6)),
-    width: 1 + (((input[2] & 0x3f) << 8) | input[1])
-  }
-}
-
-function calculateLossy (input) {
-  // `& 0x3fff` returns the last 14 bits
-  // TO-DO: include webp scaling in the calculations
-  return {
-    height: readInt16LE(input, 8) & 0x3fff,
-    width: readInt16LE(input, 6) & 0x3fff
-  }
-}
-
-export const WEBP = {
-  validate (input) {
-    const riffHeader = 'RIFF' === toUTF8String(input, 0, 4)
-    const webpHeader = 'WEBP' === toUTF8String(input, 8, 12)
-    const vp8Header = 'VP8' === toUTF8String(input, 12, 15)
-    return riffHeader && webpHeader && vp8Header
-  },
-
-  calculate (input) {
-    const chunkHeader = toUTF8String(input, 12, 16)
-    input = input.slice(20, 30)
-
-    // Extended webp stream signature
-    if (chunkHeader === 'VP8X') {
-      const extendedHeader = input[0]
-      const validStart = (extendedHeader & 0xc0) === 0
-      const validEnd = (extendedHeader & 0x01) === 0
-      if (validStart && validEnd) {
-        return calculateExtended(input)
-      } else {
-        // TODO: breaking change
-        throw new TypeError('Invalid WebP')
-      }
-    }
-
-    // Lossless webp stream signature
-    if (chunkHeader === 'VP8 ' && input[0] !== 0x2f) {
-      return calculateLossy(input)
-    }
-
-    // Lossy webp stream signature
-    const signature = toHexString(input, 3, 6)
-    if (chunkHeader === 'VP8L' && signature !== '9d012a') {
-      return calculateLossless(input)
-    }
-
-    throw new TypeError('Invalid WebP')
-  }
-}

package/src/photo-parser/index.js

@@ -1,185 +0,0 @@
-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, md5} = tags
-  let imageMetaData = {width, height, filesize, md5}
-  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?.DateTime) {
-    imageMetaData.capture_time = moment(exif.DateTime, 'YYYY:MM:DD HH:mm:ss').valueOf()
-  } else 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(),
-            filesize: meta_data.filesize,
-            md5: meta_data.md5,
-            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()
-  })
-}