本地化同步

.babelrc

@@ -0,0 +1,6 @@
+{
+  "presets": [
+    "es2015",
+    "stage-0"
+  ]
+}

.gitignore

@@ -0,0 +1,17 @@
+.DS_Store
+node_modules/
+/dist/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+/test/unit/coverage/
+/test/e2e/reports/
+selenium-debug.log
+
+# Editor directories and files
+.idea
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sln

.svn/entries

@@ -0,0 +1 @@
+12

.svn/format

@@ -0,0 +1 @@
+12

.svn/pristine/01/01963703e777672452f3105365044c24b692f3d1.svn-base

@@ -0,0 +1,73 @@
+import { threeLayer } from './initScene3D'
+
+function init(verticesArray, maxHeight) {
+  let len = verticesArray.length
+
+  for (let i = 0; i < len; i += 3) {
+    verticesArray[i + 2] = maxHeight
+  }
+}
+
+function singleAnimation (mesh, verticesArray, animateBuffArrays, stepTotal) {
+  let len = verticesArray.length
+  let pollIndex = 0;
+
+  return function () {
+    if (!mesh.visible) {
+      pollIndex = stepTotal - 1
+    }
+
+    for (let i = 0, index = 0; i < len; i += 3, index++) {
+      let Indexes = index * stepTotal + pollIndex
+      verticesArray[i + 2] = animateBuffArrays[Indexes]
+    }
+
+    pollIndex++
+    
+    if (mesh.isRemove) {
+      return true
+    } else if (pollIndex < stepTotal) {
+      mesh.geometry.attributes.position.needsUpdate = true;
+      return false
+    } else {
+      return true
+    }
+  }
+}
+
+
+const animation = (() => {
+  let taskStore = []
+  let runing = false
+
+  return function (...args) {
+    taskStore.push(singleAnimation(...args))
+    if (runing) return
+    runing = true;
+
+    function frame() {
+      requestAnimationFrame(() => {
+        for (let i = 0; i < taskStore.length; i++) {
+          if (taskStore[i]()) {
+            taskStore.splice(i, 1)
+            i--
+          }
+        }
+        threeLayer.renderScene()
+        if (taskStore.length === 0) {
+          runing = false
+        } else {
+          frame();
+        }
+      })
+    }
+
+    frame();
+  }
+})()
+
+
+export {
+  animation,
+  init
+}

.svn/pristine/0b/0b598119853f8913738b674547564bf539fbf6b7.svn-base

@@ -0,0 +1,37 @@
+import * as THREE from 'three'
+import { threeLayer } from './initScene3D'
+import { analysis } from '../business/statusManagement'
+
+let setCount = 0
+
+export default function (gl, scene, camera) {
+  let renderer = threeLayer.getThreeRenderer()
+  
+  global.scene = scene
+
+  let ambientLight = new THREE.AmbientLight( 0x262321, 1)
+  scene.add(ambientLight)
+
+  let frontLight = new THREE.DirectionalLight( 0xffffff, 0.2 );
+  frontLight.position.set(1,0,0)
+  scene.add( new THREE.DirectionalLightHelper(frontLight) )
+  scene.add( frontLight );
+
+  let backLight = new THREE.DirectionalLight( 0xffffff,  0.2);
+  backLight.position.set(-1,0,0)
+  scene.add( new THREE.DirectionalLightHelper(backLight) )
+  scene.add( backLight );
+
+  let sunLight = new THREE.DirectionalLight( 0xf2fee7, 1 );
+  sunLight.position.set(80,0,-80).normalize();
+  sunLight.castShadow = true;
+  scene.add( sunLight );
+  
+
+  renderer.shadowMapEnabled = true;
+  renderer.shadowMapSoft = true;
+
+  if (++setCount === 1) {
+    map.setPitch(analysis().pitch)
+  }
+}

.svn/pristine/0f/0f60927d03c3543cabed80c6e6a2536dfe91c06d.svn-base

@@ -0,0 +1,85 @@
+function init(verticesArray, maxHeight) {
+  // let len = verticesArray.length
+
+  // for (let i = 0; i < len; i += 3) {
+  //   verticesArray[i + 2] = maxHeight
+  // }
+}
+
+function singleAnimation (mesh, verticesArray, animateBuffArrays, stepTotal) {
+  let len = verticesArray.length
+  let pollIndex = 0;
+
+  return function () {
+    return true
+    // if (!mesh.visible) {
+    //   pollIndex = stepTotal - 1
+    // }
+
+    // for (let i = 0, index = 0; i < len; i += 3, index++) {
+    //   let Indexes = index * stepTotal + pollIndex
+    //   verticesArray[i + 2] = animateBuffArrays[Indexes]
+    // }
+
+    // pollIndex++
+    
+    // if (mesh.isRemove) {
+    //   return true
+    // } else if (pollIndex < stepTotal) {
+    //   mesh.geometry.attributes.position.needsUpdate = true;
+    //   return false
+    // } else {
+    //   return true
+    // }
+  }
+}
+
+
+const animation = (() => {
+  let taskStore = []
+  let runing = false
+  let pause = false
+
+  return function (...args) {
+    taskStore.push(singleAnimation(...args))
+    if (runing) return
+    runing = true;
+
+    // bus.off('addGeoing')
+    // bus.off('addGeoEnd')
+
+    // bus.on('addGeoing', () => {
+    //   pause = true
+    // })
+
+    // bus.on('addGeoEnd', () => {
+    //   pause = false
+    //   frame();
+    // })
+
+    function frame() {
+      requestAnimationFrame(() => {
+        for (let i = 0; i < taskStore.length; i++) {
+          if (taskStore[i]()) {
+            taskStore.splice(i, 1)
+            i--
+          }
+        }
+        threeLayer.renderScene()
+        if (taskStore.length === 0) {
+          runing = false
+        } else if (!pause){
+          frame();
+        }
+      })
+    }
+
+    frame();
+  }
+})()
+
+
+export {
+  animation,
+  init
+}

.svn/pristine/11/11b587c25841054840267bea823ffa7ebfbef49a.svn-base

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta http-equiv="X-UA-Compatible" content="ie=edge">
+  <title>4DMap</title>
+</head>
+<body>
+  <div id="map"></div>
+  <select id="theme"></select>
+</body>
+</html>

.svn/pristine/14/14b9facb013a33bdd2f7cdbee86fe034811a3763.svn-base

@@ -0,0 +1,77 @@
+import { cuttingString } from './util'
+
+function average(aver, curr, index) {
+  aver[0] += curr[0]
+  aver[1] += curr[1]
+  if (index) {
+    aver[0] /= 2
+    aver[1] /= 2
+  }
+  return aver
+}
+
+function getMaxPoint(points, index) {
+  let maxVal = points[0][index], 
+      maxIndex = 0;
+
+  for (let i = 1; i < points.length; i++) {
+    if (points[i][index] > maxVal) {
+      maxVal = points[i][index]
+      maxIndex = i
+    }
+  }
+
+  return points[maxIndex]
+}
+
+function getMinPoint(points, index) {
+  let minVal = points[0][index],
+    minIndex = 0;
+
+  for (let i = 1; i < points.length; i++) {
+    if (points[i][index] < minVal) {
+      minVal = points[i][index]
+      minIndex = i
+    }
+  }
+
+  return points[minIndex]
+}
+
+
+function grentText(features) {
+  let texts = []
+
+  features.forEach(fe => {
+    if (fe.properties.name) {
+      let name = cuttingString(fe.properties.name, 16)
+      let averagePoint = fe.geometry.coordinates.reduce((tPoint, geometry, index) => {
+        let mPoints = [
+          getMaxPoint(geometry, 0),
+          getMaxPoint(geometry, 1),
+          getMinPoint(geometry, 0),
+          getMinPoint(geometry, 1),
+        ]
+
+        return average(
+          tPoint,
+          mPoints.reduce(average, [0, 0]),
+          index
+        )
+      }, [0, 0])
+
+      
+      texts.push({
+        name: name.join('\n') + '\n|',
+        point: averagePoint,
+        top: fe.height-1,
+        width: name[0].length * 18 + 20,
+        height: name.length * 18 + 20,
+        id: fe.id
+      })
+    }
+  })
+
+  return texts
+}
+export default grentText

.svn/pristine/16/16ab95549775b6e8bb809ae65a2a5acaa330589b.svn-base

@@ -0,0 +1,7 @@
+export default {
+  stepTotal: 10,
+  levelHeight: 2,
+  defaultHeight: 12,
+  criticalZoom: 15,
+  manyOffset: 2
+}

.svn/pristine/18/18aa09d902cba5211ad56c23dced3e8aa8fbb5f3.svn-base

@@ -0,0 +1,43 @@
+{
+  "name": "maptalks-three",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "webpack-dev-server --mode development",
+    "build": "webpack --mode production"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "autoprefixer": "^9.1.5",
+    "babel-core": "^6.26.3",
+    "babel-loader": "^7.1.5",
+    "babel-polyfill": "^6.26.0",
+    "babel-preset-env": "^1.7.0",
+    "babel-preset-es2015": "^6.24.1",
+    "babel-preset-stage-0": "^6.24.1",
+    "css-loader": "^1.0.0",
+    "dat-gui": "^0.5.0",
+    "extract-text-webpack-plugin": "^3.0.2",
+    "file-loader": "^1.1.11",
+    "html-webpack-plugin": "^3.2.0",
+    "postcss-cssnext": "^3.1.0",
+    "postcss-loader": "^3.0.0",
+    "style-loader": "^0.23.0",
+    "url-loader": "^1.1.1",
+    "webpack": "^4.17.2",
+    "webpack-cli": "^3.1.0",
+    "webpack-dev-server": "^3.1.8",
+    "worker-loader": "^2.0.0"
+  },
+  "dependencies": {
+    "axios": "^0.18.0",
+    "maptalks": "^0.41.1",
+    "maptalks.three": "^0.5.0",
+    "three": "^0.96.0",
+    "three-obj-loader": "^1.1.3"
+  }
+}

.svn/pristine/21/219f8990fceedb413834305837ccd35b01ee5f90.svn-base

@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset='utf-8' />
+  <title></title>
+  <meta name='viewport' content='initial-scale=1,maximum-scale=1,user-scalable=no' />
+  <script src='https://api.tiles.mapbox.com/mapbox-gl-js/v0.29.0/mapbox-gl.js'></script>
+  <link href='https://api.tiles.mapbox.com/mapbox-gl-js/v0.29.0/mapbox-gl.css' rel='stylesheet' />
+  <style>
+    body {
+      margin: 0;
+      padding: 0;
+    }
+
+    #map {
+      position: absolute;
+      top: 0;
+      bottom: 0;
+      width: 100%;
+    }
+  </style>
+</head>
+
+<body>
+
+  <div id='map'></div>
+  <script>
+    mapboxgl.accessToken = '<your access token here>';
+    var map = new mapboxgl.Map({
+      style: 'mapbox://styles/mapbox/light-v9',
+      center: [-74.0066, 40.7135],
+      zoom: 15,
+      pitch: 45,
+      bearing: -17.6,
+      container: 'map'
+    });
+
+    // the 'building' layer in the mapbox-streets vector source contains building-height
+    // data from OpenStreetMap.
+    map.on('load', function () {
+      map.addLayer({
+        'id': '3d-buildings',
+        'source': 'composite',
+        'source-layer': 'building',
+        'filter': ['==', 'extrude', 'true'],  /* 过滤器 */
+        'type': 'fill-extrusion',
+        'minzoom': 15,
+        'paint': {
+          'fill-extrusion-color': '#aaa',
+          'fill-extrusion-height': {  /* 使用source中的height属性为fill-extrusion-height赋值 */
+            'type': 'identity',
+            'property': 'height'
+          },
+          'fill-extrusion-base': {
+            'type': 'identity',
+            'property': 'min_height'
+          },
+          'fill-extrusion-opacity': .6
+        }
+      });
+    });
+  </script>
+
+</body>
+
+</html>

.svn/pristine/22/22402a68ef8d222cc82ad20902337a18c256040f.svn-base

@@ -0,0 +1,113 @@
+import * as maptalks from 'maptalks'
+import { ThreeLayer } from 'maptalks.three'
+import { unMeshAll, meshStatus } from './meshStaus'
+import initAmbient from './initAmbient'
+import { addGeo } from '../core/dyWoker'
+import { referText } from './addText'
+import { singleDelay } from '../core/util'
+import config from './config'
+
+
+// 高层数据获取
+const canvasTile = new maptalks.CanvasTileLayer('tile', {
+  urlTemplate: 'https://{s}.data.osmbuildings.org/0.2/anonymous/tile/{z}/{x}/{y}.json',
+  subdomains: ['a', 'b', 'c', 'd'],
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  repeatWorld: false,
+  maxAvailableZoom: 15
+})
+
+// 3DThree与map结合
+const threeLayer = new ThreeLayer('t', {
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true
+})
+threeLayer.prepareToDraw = initAmbient
+
+global.threeLayer = threeLayer
+
+// Maker承载容器
+let vector = new maptalks.VectorLayer('vector', {
+  enableAltitude: true,        // enable altitude
+  altitudeProperty: 'altitude', // altitude property in properties, default by 'altitude',
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true
+})
+
+
+// 获取高层数据
+function getCurrTiles() {
+  let tileGrids = canvasTile.getTiles().tileGrids
+  for (var i = 0; i < tileGrids.length; i++) {
+    if (tileGrids[i].zoom >= 15) break
+  }
+  let zoom = tileGrids[i].zoom
+  let tiles = tileGrids[i].tiles
+  let maxX = tiles[0].x
+  let minX = tiles[0].x
+  let maxY = tiles[0].y
+  let minY = tiles[0].y
+
+  tiles.forEach(tile => {
+    tile.x > maxX && (maxX = tile.x)
+    tile.y > maxY && (maxY = tile.y)
+    tile.x < minX && (minX = tile.x)
+    tile.y < minY && (minY = tile.y)
+  })
+
+  for (let i = 1; i <= config.manyOffset; i++) {
+    let largeX = maxX + i
+    let smallX = minX - i
+    for (let i = 1; i <= config.manyOffset; i++) {
+      let largeY = maxY + i
+      let smallY = minY - i
+
+      tiles.push({ x: largeX, y: largeY, z: zoom })
+      tiles.push({ x: largeX, y: smallY, z: zoom })
+      tiles.push({ x: smallX, y: smallY, z: zoom })
+      tiles.push({ x: smallX, y: largeY, z: zoom })
+    }
+  }
+
+  console.log(tiles)
+
+  return tiles
+}
+
+let gAddGeo = singleDelay(() => addGeo(getCurrTiles()), 100)
+let isUninstall = false
+// 动态添加删除建筑
+let dyAddGeo = singleDelay(() => {
+  if (!isUninstall) {
+    meshStatus()
+    addGeo(getCurrTiles())
+  }
+}, 500);
+
+
+map.addLayer([canvasTile, threeLayer, vector])
+
+bus.on('install3D', () => {
+  isUninstall = false
+  gAddGeo()
+  
+  map.on('moveend zoomend dragrotateend', referText)
+  map.on('moving zoomend dragrotating', dyAddGeo)
+})
+
+bus.on('uninstall3D', () => {
+  isUninstall = true
+  map.off('moveend zoomend dragrotateend', referText)
+  map.off('moving zoomend dragrotating', dyAddGeo)
+  
+  unMeshAll()
+})
+
+export {
+  vector,
+  threeLayer
+}

.svn/pristine/22/22ef568d2ba25559146a4e57b8a5f02ef19c2c0a.svn-base

@@ -0,0 +1,109 @@
+import * as THREE from 'three'
+import { Map$1, Coordinate, MultiPolygon, Polygon } from './featuresToPolygon'
+
+
+let procssMap = new Map$1(null, {
+  center: [0, 0]
+})
+
+function sign(x) {
+  if (Math.sign) {
+    return Math.sign(x);
+  }
+
+  x = +x;
+
+  if (x === 0 || isNaN(x)) {
+    return Number(x);
+  }
+
+  return x > 0 ? 1 : -1;
+}
+
+function getAmount(amount, map) {
+  let zoom = map.maxNativeZoom
+  let center = procssMap.getCenter();
+  let target = procssMap.locate(center, amount, amount);
+  let p0 = procssMap.coordinateToPoint(center, zoom);
+  let p1 = procssMap.coordinateToPoint(target, zoom);
+  var x = Math.abs(p1.x - p0.x) * sign(amount);
+  var y = Math.abs(p1.y - p0.y) * sign(amount);
+  return new THREE.Vector3(x, y, 0).x;
+}
+
+function coordinateToVector3(coordinate, map) {
+  var z = 0;
+  var p = procssMap.coordinateToPoint(coordinate, map.maxNativeZoom)
+  return new THREE.Vector3(p.x, p.y, -z);
+};
+
+function toShape(polygon, map) {
+  var center = polygon.getCenter();
+  var centerPt = coordinateToVector3(center, map);
+  
+  var shell = polygon.getShell();
+  var outer = shell.map(function (c) {
+    return coordinateToVector3(c, map).sub(centerPt);
+  });
+  var shape = new THREE.Shape(outer);
+  var holes = polygon.getHoles();
+
+  if (holes && holes.length > 0) {
+    shape.holes = holes.map(function (item) {
+      var pts = item.map(function (c) {
+        return coordinateToVector3(c, map).sub(centerPt);
+      });
+      return new THREE.Shape(pts);
+    });
+  }
+
+  return shape;
+};
+
+function toExtrudeGeometry(polygon, map, height) {
+  if (!polygon || !(polygon instanceof MultiPolygon || polygon instanceof Polygon)) {
+    return null;
+  }
+
+  if (polygon instanceof MultiPolygon) {
+    return polygon.getGeometries().map(c =>
+      toExtrudeGeometry(c, map, height)
+    );
+  }
+
+  var shape = toShape(polygon, map);
+  var center = coordinateToVector3(polygon.getCenter(), map);
+  var amount = getAmount(height, map);
+  
+  var geom = new THREE.ExtrudeGeometry(shape, { 'depth': amount, 'bevelEnabled': false });
+
+  var vertices = geom.vertices
+  var vlength = vertices.length
+
+  for (let i = 0; i < vlength; i += 1) {
+    vertices[i].x += center.x
+    vertices[i].y += center.y
+    vertices[i].z += -amount
+  }
+
+  return geom
+}
+
+function reductive(map) {
+  procssMap.setCenter(new Coordinate(map.center))
+  // procssMap.width = map.size.width
+  // procssMap.height = map.size.height
+  // procssMap.setBearing(map.bearing)
+  // procssMap.setFov(map.fov)
+  // procssMap.setMaxZoom(map.maxZoom)
+  // procssMap.setMinZoom(map.minZoom)
+  // procssMap.setPitch(map.pitch)
+  // procssMap.setSpatialReference(map.spatialReference)
+}
+
+
+
+export {
+  reductive,
+  toExtrudeGeometry
+}

.svn/pristine/25/257f3c5447305af71de6dfaa0cb7ed95bc586ced.svn-base

@@ -0,0 +1,42 @@
+{
+  "name": "maptalks-three",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "webpack-dev-server --mode development",
+    "build": "webpack --mode production"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "autoprefixer": "^9.1.5",
+    "babel-core": "^6.26.3",
+    "babel-loader": "^7.1.5",
+    "babel-polyfill": "^6.26.0",
+    "babel-preset-env": "^1.7.0",
+    "babel-preset-es2015": "^6.24.1",
+    "babel-preset-stage-0": "^6.24.1",
+    "css-loader": "^1.0.0",
+    "extract-text-webpack-plugin": "^3.0.2",
+    "file-loader": "^1.1.11",
+    "html-webpack-plugin": "^3.2.0",
+    "postcss-cssnext": "^3.1.0",
+    "postcss-loader": "^3.0.0",
+    "style-loader": "^0.23.0",
+    "url-loader": "^1.1.1",
+    "webpack": "^4.17.2",
+    "webpack-cli": "^3.1.0",
+    "webpack-dev-server": "^3.1.8",
+    "worker-loader": "^2.0.0"
+  },
+  "dependencies": {
+    "axios": "^0.18.0",
+    "maptalks": "^0.41.1",
+    "maptalks.three": "^0.5.0",
+    "three": "^0.96.0",
+    "three-obj-loader": "^1.1.3"
+  }
+}

.svn/pristine/26/2622f39d1c7a5bd69f517c7bbed1b7ed1db5bb4c.svn-base

@@ -0,0 +1,92 @@
+import * as THREE from 'three'
+global.THREE = THREE
+require('three/examples/js/controls/OrbitControls')
+
+
+
+var dom = document.querySelector('#test')
+var scene = new THREE.Scene();
+var camera = new THREE.PerspectiveCamera(75, dom.offsetWidth / dom.offsetHeight, 0.1, 1000);
+camera.position.z = 150;
+var controls = new THREE.OrbitControls(camera, dom);
+
+var renderer = new THREE.WebGLRenderer({ antialias: true });
+renderer.setSize(dom.offsetWidth, dom.offsetHeight);
+dom.appendChild(renderer.domElement);
+
+
+var f = null
+var loader = new THREE.FontLoader();
+loader.load('http://localhost:3000/helvetiker_regular.typeface.json', function (font) {
+  var boxGeometry = new THREE.BoxBufferGeometry(50, 50, 50);
+  var y = getMaxHeight(boxGeometry.attributes.position.array) + 40
+  var material = new THREE.MeshBasicMaterial({ color: 0x000000 })
+  
+  var geometry = new THREE.TextBufferGeometry('Hello three.js!', {
+    font: font,
+    size: 12,
+    height: 1
+  });
+  f = new THREE.Mesh(geometry, material)
+  f.position.set(
+    -getWidth(geometry.attributes.position.array) / 2,
+    y, 
+    0
+  )
+  scene.add(f)
+  scene.add(
+    new THREE.Mesh(boxGeometry, material)
+  )
+});
+
+
+function getMaxHeight(verticesBuffArrays) {
+  let maxHeight = verticesBuffArrays[2]
+  let len = verticesBuffArrays.length
+
+  for (let i = 3; i < len; i += 3) {
+    if (maxHeight < verticesBuffArrays[i + 2]) {
+      maxHeight = verticesBuffArrays[i + 2]
+    }
+  }
+
+  return maxHeight
+}
+
+function getWidth(verticesBuffArrays) {
+  let args = {
+    minWidth: verticesBuffArrays[0],
+    maxWidth: verticesBuffArrays[0]
+  }
+  let len = verticesBuffArrays.length
+
+  for (let i = 3; i < len; i += 3) {
+    if (args.maxWidth < verticesBuffArrays[i]) {
+      args.maxWidth = verticesBuffArrays[i]
+    }
+
+    if (args.minWidth > verticesBuffArrays[i]) {
+      args.minWidth = verticesBuffArrays[i]
+    }
+  }
+
+  return args.maxWidth - args.minWidth
+}
+
+
+renderer.setClearColor(0xffffff)
+function animate() {
+  controls.update();
+  // console.log(f && f.quaternion)
+
+  f && f.quaternion.copy(camera.quaternion)
+  // console.log(camera.quaternion)
+  f && f.scale.copy(camera.scale)
+  // f && f.scale.copy(camera.scale)
+  // up
+  f && f.rotation.copy(camera.rotation)
+
+  requestAnimationFrame(animate);
+  renderer.render(scene, camera);
+}
+animate();

.svn/pristine/27/27b1fc75ed376bdf08ea2e2315068860b488f2bd.svn-base

@@ -0,0 +1,44 @@
+import * as THREE from 'three'
+import { threeLayer } from './initScene3D'
+import { analysis } from '../business/statusManagement'
+
+let setCount = 0
+
+export default function (gl, scene, camera) {
+  let renderer = threeLayer.getThreeRenderer()
+  
+  global.scene = scene
+
+  let ambientLight = new THREE.AmbientLight( 0x262321, 0.3)
+  scene.add(ambientLight)
+
+  
+  let frontLight = new THREE.DirectionalLight( 0xffffff,  0.2);
+  frontLight.position.set(0,1,0)
+  scene.add( new THREE.DirectionalLightHelper(frontLight) )
+  scene.add( frontLight );
+
+
+  let backLight = new THREE.DirectionalLight( 0xffffff,  0.1);
+  backLight.position.set(0,0,1)
+  scene.add( new THREE.DirectionalLightHelper(backLight) )
+  scene.add( backLight );
+
+  
+
+  let sunLight = new THREE.DirectionalLight( 0xf2fee7, 0.6 );
+  sunLight.position.set(80,0,-80).normalize();
+  sunLight.castShadow = true;
+  scene.add( sunLight );
+  
+
+ 
+ 
+
+  renderer.shadowMapEnabled = true;
+  renderer.shadowMapSoft = true;
+
+  if (++setCount === 1) {
+    map.setPitch(analysis().pitch)
+  }
+}

.svn/pristine/29/29a4bd25f3b7a1cf622fb15dbfd78637d1a09766.svn-base

@@ -0,0 +1,28 @@
+* {
+  margin: 0;
+  padding: 0;
+}
+
+html {
+  --width: 100%;
+  --height: 100%;
+}
+html, body {
+  width: var(--width);
+  height: var(--height)
+}
+#map {
+  width: var(--width);
+  height: calc(var(--height));
+  overflow: hidden;
+}
+
+#test {
+  width: var(--width);
+  height: calc(var(--height) / 2);
+  overflow: hidden;
+}
+
+#map {
+  background: #ccc;
+}

.svn/pristine/29/29fe9aa0477af97308bc359b95f0d3b2f50c228d.svn-base

@@ -0,0 +1,133 @@
+import { Marker, Coordinate } from 'maptalks'
+import { mapGoto } from './statusManagement'
+
+function structText(args) {
+  var point = new Marker(args.point,
+    {
+      properties: {
+        altitude: args.top
+      },
+      visible: true,
+      editable: true,
+      cursor: 'pointer',
+      shadowBlur: 0,
+      shadowColor: 'black',
+      draggable: false,
+      dragShadow: false, // display a shadow during dragging
+      drawOnAxis: null,  // force dragging stick on a axis, can be: x, y
+      symbol: {
+        'textFaceName': 'sans-serif',
+        'textName': args.name,
+        'textFill': '#000000',
+        'textHorizontalAlignment': 'center',
+        'textVerticalAlignment': 'top',
+        'textSize': 12
+      }
+    }
+  );
+  point.on('click', () => {
+    mapGoto({ center: args.point, zoom: 19 })
+  })
+  point.__id = args.id
+  return point
+}
+
+function addToAttr(args) {
+  var point = new Coordinate(args.point),
+    containerPoint  = map.coordinateToContainerPoint(point).round();
+
+  args.position = [
+    Number(containerPoint.x),
+    Number(containerPoint.y)
+  ]
+}
+
+
+function checkIsAdd(texts, args) {
+  addToAttr(args)
+
+  let tMinX = args.position[0] - args.width / 2
+  let tMaxX = args.position[0] + args.width / 2
+  let tMinY = args.position[1]
+  let tMaxY = args.position[1] + args.height
+
+  let index = texts.findIndex(text => {
+    let minX = text._struct_attribute.position[0] - text._struct_attribute.width / 2
+    let minY = text._struct_attribute.position[1]
+    let maxX = text._struct_attribute.position[0] + text._struct_attribute.width / 2
+    let maxY = text._struct_attribute.position[1] + text._struct_attribute.height
+
+    return !(
+      (tMinX < minX && tMaxX < minX) || 
+      (tMinX > maxX && tMaxX > maxX) || 
+      (tMinY < minY && tMaxY < minY) || 
+      (tMinY > maxY && tMaxY > maxY)
+    )
+  })
+  
+  return !~index
+}
+
+
+function addText(mesh, textjsons) {
+  if (textjsons.length === 0) return;
+  let children = threeLayer.getScene().children
+  let texts = []
+  let newTexts = []
+
+  children.forEach(mesh => {
+    mesh.texts && texts.push(...mesh.texts)
+  })
+
+  textjsons.forEach(item => {
+    if (checkIsAdd(texts, item)) {
+      let text = structText(item)
+      newTexts.push(text)
+      text._struct_attribute = item
+      texts.push(text)
+    }
+  })
+
+  vector.addGeometry(newTexts)
+  mesh.texts = newTexts
+  mesh.textjsons = textjsons
+}
+
+
+
+function referText() {
+  let children = threeLayer.getScene().children
+  let checkTexts = []
+  
+  children.forEach(mesh => {
+    if (mesh.texts) {
+      for (let i = 0; i < mesh.texts.length; i++) {
+        let text = mesh.texts[i]
+        if (checkIsAdd(checkTexts, text._struct_attribute)) {
+          checkTexts.push(text)
+        } else {
+          vector.removeGeometry(text)
+          mesh.texts.splice(i, 1)
+          --i
+        }
+      }
+    }
+    
+    
+    if (mesh.textjsons) {
+      mesh.textjsons.map(item => {
+        let index = mesh.texts.findIndex(text => text.__id === item.id)
+        if (!~index && checkIsAdd(checkTexts, item)) {
+          let text = structText(item)
+          checkTexts.push(text)
+          text._struct_attribute = item
+          vector.addGeometry(text)
+          mesh.texts.push(text)
+        }
+      })
+    }
+  })
+}
+
+export { referText }
+export default addText

.svn/pristine/2b/2bd1988ac3cf0748c9ffb24ecbb3e8104d6dfa8e.svn-base

@@ -0,0 +1,65 @@
+
+function analysis () {
+  let result = {}
+  let args = location.search.substr(1)
+  args = args.split('&')
+  args.forEach(arg => {
+    let index = arg.indexOf('=')
+    if (~index) {
+      result[arg.substring(0, index)] = Number(arg.substr(index + 1))
+    }
+  })
+
+  if (!result.lat || !result.lon) {
+    result.lat = 22.252832648721693
+    result.lon = 113.57727389730132
+  }
+
+  result.zoom = result.zoom || 16
+  result.pitch = result.pitch || 60
+  result.bearing = result.bearing || 60
+  return result
+}
+
+let listStatus = (() => {
+  let args = analysis()
+  return function () {
+    let result = []
+    let center = map.getCenter()
+    args.lon = center.x
+    args.lat = center.y
+    args.zoom = map.getZoom()
+    args.pitch = map.getPitch()
+    args.bearing = map.getBearing()
+
+    for (let key in args) {
+      result.push(`${key}=${args[key]}`)
+    }
+
+
+    let url = location.pathname + '?' + result.join('&')
+    history.pushState({
+      url, 
+      title: document.title 
+    }, document.title, url)
+  }
+})()
+
+
+function mapGoto(args, duration = 1000) {
+  // map.animateTo({
+  //   center: [(map.getCenter().x + args.center[0]) / 2,
+  //   (map.getCenter().y + args.center[1]) / 2],
+  //   zoom: 15
+  // }, {duration: 2000});
+
+  // setTimeout(() => {
+    map.animateTo(args, {duration});
+  // }, 2000)
+}
+
+export {
+  mapGoto,
+  analysis, 
+  listStatus
+}

.svn/pristine/2d/2d22d656d2a8e031c0e6993c410734c5b27ca991.svn-base

@@ -0,0 +1,112 @@
+import * as maptalks from 'maptalks'
+import { ThreeLayer } from 'maptalks.three'
+import { unMeshAll, meshStatus } from './meshStaus'
+import initAmbient from './initAmbient'
+import { addGeo } from '../core/dyWoker'
+import { referText } from './addText'
+import { singleDelay } from '../core/util'
+import config from './config'
+
+
+// 高层数据获取
+const canvasTile = new maptalks.CanvasTileLayer('tile', {
+  urlTemplate: 'https://{s}.data.osmbuildings.org/0.2/anonymous/tile/{z}/{x}/{y}.json',
+  subdomains: ['a', 'b', 'c', 'd'],
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  repeatWorld: false,
+  maxAvailableZoom: 15
+})
+
+// 3DThree与map结合
+const threeLayer = new ThreeLayer('t', {
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true
+})
+threeLayer.prepareToDraw = initAmbient
+
+global.threeLayer = threeLayer
+
+// Maker承载容器
+let vector = new maptalks.VectorLayer('vector', {
+  enableAltitude: true,        // enable altitude
+  altitudeProperty: 'altitude', // altitude property in properties, default by 'altitude',
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true
+})
+
+
+// 获取高层数据
+function getCurrTiles() {
+  let tileGrids = canvasTile.getTiles().tileGrids
+  for (var i = 0; i < tileGrids.length; i++) {
+    if (tileGrids[i].zoom >= 15) break
+  }
+  let zoom = tileGrids[i].zoom
+  let tiles = tileGrids[i].tiles
+  let maxX = tiles[0].x
+  let minX = tiles[0].x
+  let maxY = tiles[0].y
+  let minY = tiles[0].y
+
+  tiles.forEach(tile => {
+    tile.x > maxX && (maxX = tile.x)
+    tile.y > maxY && (maxY = tile.y)
+    tile.x < minX && (minX = tile.x)
+    tile.y < minY && (minY = tile.y)
+  })
+
+  for (let i = 1; i <= config.manyOffset; i++) {
+    let largeX = maxX + i
+    let smallX = minX - i
+    for (let i = 1; i <= config.manyOffset; i++) {
+      let largeY = maxY + i
+      let smallY = minY - i
+
+      tiles.push({ x: largeX, y: largeY, z: zoom })
+      tiles.push({ x: largeX, y: smallY, z: zoom })
+      tiles.push({ x: smallX, y: smallY, z: zoom })
+      tiles.push({ x: smallX, y: largeY, z: zoom })
+    }
+  }
+
+
+  return tiles
+}
+
+let gAddGeo = singleDelay(() => addGeo(getCurrTiles()), 100)
+let isUninstall = false
+// 动态添加删除建筑
+let dyAddGeo = singleDelay(() => {
+  if (!isUninstall) {
+    meshStatus()
+    addGeo(getCurrTiles())
+  }
+}, 500);
+
+
+map.addLayer([canvasTile, threeLayer, vector])
+
+bus.on('install3D', () => {
+  isUninstall = false
+  gAddGeo()
+  
+  map.on('moveend zoomend dragrotateend', referText)
+  map.on('moving zoomend dragrotating', dyAddGeo)
+})
+
+bus.on('uninstall3D', () => {
+  isUninstall = true
+  map.off('moveend zoomend dragrotateend', referText)
+  map.off('moving zoomend dragrotating', dyAddGeo)
+  
+  unMeshAll()
+})
+
+export {
+  vector,
+  threeLayer
+}

.svn/pristine/2e/2ea258fb4c8dfb22bb71634056105d4aae10e53b.svn-base

@@ -0,0 +1,115 @@
+import * as THREE from 'three'
+import { Map$1, Coordinate, MultiPolygon, Polygon } from './featuresToPolygon'
+
+
+let procssMap = new Map$1(null, {
+  center: [0, 0]
+})
+
+function sign(x) {
+  if (Math.sign) {
+    return Math.sign(x);
+  }
+
+  x = +x;
+
+  if (x === 0 || isNaN(x)) {
+    return Number(x);
+  }
+
+  return x > 0 ? 1 : -1;
+}
+
+function getAmount(amount, map) {
+  let zoom = map.maxNativeZoom
+  let center = procssMap.getCenter();
+  let target = procssMap.locate(center, amount, amount);
+  let p0 = procssMap.coordinateToPoint(center, zoom);
+  let p1 = procssMap.coordinateToPoint(target, zoom);
+  var x = Math.abs(p1.x - p0.x) * sign(amount);
+  var y = Math.abs(p1.y - p0.y) * sign(amount);
+  return new THREE.Vector3(x, y, 0).x;
+}
+
+function coordinateToVector3(coordinate, map) {
+  var z = 0;
+  var p = procssMap.coordinateToPoint(coordinate, map.maxNativeZoom)
+  return new THREE.Vector3(p.x, p.y, -z);
+};
+
+function toShape(polygon, map) {
+  var center = polygon.getCenter();
+  var centerPt = coordinateToVector3(center, map);
+  
+  var shell = polygon.getShell();
+  var outer = shell.map(function (c) {
+    return coordinateToVector3(c, map).sub(centerPt);
+  });
+  var shape = new THREE.Shape(outer);
+  var holes = polygon.getHoles();
+
+  if (holes && holes.length > 0) {
+    shape.holes = holes.map(function (item) {
+      var pts = item.map(function (c) {
+        return coordinateToVector3(c, map).sub(centerPt);
+      });
+      return new THREE.Shape(pts);
+    });
+  }
+
+  return shape;
+};
+
+function toExtrudeGeometry(polygon, map, height) {
+  if (!polygon || !(polygon instanceof MultiPolygon || polygon instanceof Polygon)) {
+    return null;
+  }
+
+  if (polygon instanceof MultiPolygon) {
+    return polygon.getGeometries().map(c =>
+      toExtrudeGeometry(c, map, height)
+    );
+  }
+
+  var shape = toShape(polygon, map);
+  var center = coordinateToVector3(polygon.getCenter(), map);
+  var amount = getAmount(height, map);
+  
+  var geom = new THREE.ExtrudeGeometry(shape, { 'depth': amount, 'bevelEnabled': false });
+
+  var vertices = geom.vertices
+  var vlength = vertices.length
+
+  for (let i = 0; i < vlength; i += 1) {
+    vertices[i].x += center.x
+    vertices[i].y += center.y
+    vertices[i].z += -amount
+  }
+
+  return geom
+}
+
+function reductive(map) {
+  procssMap.setCenter(new Coordinate(map.center))
+  // procssMap.width = map.size.width
+  // procssMap.height = map.size.height
+  // procssMap.setBearing(map.bearing)
+  // procssMap.setFov(map.fov)
+  // procssMap.setMaxZoom(map.maxZoom)
+  // procssMap.setMinZoom(map.minZoom)
+  // procssMap.setPitch(map.pitch)
+  // procssMap.setSpatialReference(map.spatialReference)
+}
+
+function LatLngToPoint({ lat, lng }, map) {
+  var coord = new Coordinate({ x: lat, y: lng });
+  var center = coordinateToVector3(coord, map);
+
+  return center
+}
+
+export {
+  reductive,
+  toExtrudeGeometry,
+  LatLngToPoint
+}

.svn/pristine/31/319759b9aba93aa2246dcb61a85c1d7870bfd465.svn-base

@@ -0,0 +1,132 @@
+function mergeBigData(datas) {
+  let index = 0
+  let len = datas.reduce((p, c) => p + c.length, 0)
+  let v3 = new Float32Array(len * 3)
+
+  datas.forEach(data => {
+    let length = data.length
+    for (let i = 0; i < length; i++) {
+      v3[index] = data[i].x
+      v3[index + 1] = data[i].y
+      v3[index + 2] = data[i].z
+      index += 3
+    }
+  })
+
+  return v3
+}
+
+function getMaxHeight(verticesBuffArrays) {
+  let maxHeight = verticesBuffArrays[2]
+  let len = verticesBuffArrays.length
+
+  for (let i = 3; i < len; i += 3) {
+    if (maxHeight < verticesBuffArrays[i + 2]) {
+      maxHeight = verticesBuffArrays[i + 2]
+    }
+  }
+
+  return maxHeight
+}
+
+function grentAnimationArray(verticesBuffArrays, stepTotal, maxHeight) {
+  let len = verticesBuffArrays.length
+  let animateBuffArrays = new Float32Array(
+    (len / 3) * stepTotal
+  )
+
+  for (let i = 0, index = 0; i < len; i += 3, index++) {
+    let indexes = index * stepTotal
+    let origin = verticesBuffArrays[i + 2]
+    let average = (maxHeight - origin) / stepTotal
+    for (let j = 1; j < stepTotal + 1; j++) {
+      animateBuffArrays[indexes + j - 1] = maxHeight - (j * average)
+    }
+  }
+
+  return animateBuffArrays
+}
+
+
+function extractType(features) {
+  let types = []
+  let typeFeatures = [[]]
+
+  features.forEach(f => {
+    if (f.properties && f.properties.type) {
+      let index = types.indexOf(f.properties.type)
+      // index = 0
+      if (~index) {
+        typeFeatures[index + 1].push(f)
+      } else {
+        types.push(f.properties.type)
+        typeFeatures[types.length] = [f]
+      }
+    } else {
+      typeFeatures[0].push(f)
+    }
+  })
+
+  return {
+    typeFeatures,
+    types
+  }
+}
+
+
+
+function fromGeometry(geometry) {
+
+  var faces = geometry.faces;
+  var vertices = geometry.vertices;
+
+  if (vertices.length > 0 && faces.length === 0) {
+
+    console.error('THREE.DirectGeometry: Faceless geometries are not supported.');
+
+  }
+
+  var _vertices = [],
+    _normals = [];
+
+  for (var i = 0; i < faces.length; i++) {
+
+    var face = faces[i];
+
+    _vertices.push(vertices[face.a], vertices[face.b], vertices[face.c]);
+
+    var vertexNormals = face.vertexNormals;
+
+    if (vertexNormals.length === 3) {
+
+      _normals.push(vertexNormals[0], vertexNormals[1], vertexNormals[2]);
+
+    } else {
+
+      var normal = face.normal;
+
+      _normals.push(normal, normal, normal);
+
+    }
+
+  }
+
+  return {
+    vertices: _vertices,
+    normals: _normals,
+  }
+}
+
+function cuttingString(str, len = 1) {
+  let child = []
+  for (let i = 0; i < str.length; i += len) {
+    
+    child.push(
+      str.substr(i, i + len > str.length ? str.length - i : len)
+    )
+  }
+
+  return child
+}
+
+export { mergeBigData, getMaxHeight, grentAnimationArray, extractType, fromGeometry, cuttingString }

.svn/pristine/35/35afea3bf8f0e9601fb75c7664b49093e3f22b31.svn-base

@@ -0,0 +1,108 @@
+import 'babel-core/register'
+import 'babel-polyfill'
+import './style/public.css'
+import * as maptalks from 'maptalks'
+import { ThreeLayer } from 'maptalks.three'
+import meshStaus from './business/meshStaus'
+import initAmbient from './business/initAmbient'
+import { addGeo } from './core/dyWoker'
+import Event from './core/Event'
+import { referText } from './business/addText'
+import * as status from './business/statusManagement'
+
+import {Stats } from 'three-stats'
+
+let args = status.analysis()
+
+global.bus = new Event()
+global.map = new maptalks.Map('map', {
+  center: [args.lon, args.lat],
+  zoom: args.zoom,
+  bearing: args.bearing,
+  maxZoom: 20,
+  minZoom: 15,
+  maxPitch: 70,
+  maxVisualPitch: 100,
+  doubleClickZoom: false,
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  baseLayer: new maptalks.TileLayer('base', {
+    'urlTemplate': 'http://{s}.tile.osm.org/{z}/{x}/{y}.png',
+    'subdomains': ['a', 'b', 'c']
+  })
+})
+
+
+
+
+// 高层数据获取
+const canvasTile = new maptalks.CanvasTileLayer('tile', {
+  urlTemplate: 'https://{s}.data.osmbuildings.org/0.2/anonymous/tile/{z}/{x}/{y}.json',
+  subdomains: ['a', 'b', 'c', 'd'],
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  repeatWorld: false,
+  maxAvailableZoom: 15
+})
+
+map.addLayer(canvasTile)
+
+
+
+
+// 3DThree与map结合
+global.threeLayer = new ThreeLayer('t', {
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true
+})
+
+threeLayer.prepareToDraw = initAmbient
+
+
+
+let state = new Stats();
+threeLayer.draw = () => {
+  console.log(123)
+}
+
+
+// 获取高层数据
+function getCurrTiles() {
+  let tileGrids = canvasTile.getTiles().tileGrids
+  for (var i = 0; i < tileGrids.length; i++) {
+    if (tileGrids[i].zoom >= 15) break
+  }
+  return tileGrids[i].tiles
+}
+
+threeLayer.addTo(map)
+
+let timeout = null
+map.on('moving zoomend dragrotating', () => {
+  clearTimeout(timeout)
+  timeout = setTimeout(() => {
+    meshStaus()
+    addGeo(getCurrTiles())
+    status.listStatus()
+  }, 500)
+});
+
+map.on('moveend zoomend dragrotateend', referText)
+
+
+// Maker承载容器
+global.vector = new maptalks.VectorLayer('vector', {
+  enableAltitude: true,        // enable altitude
+  altitudeProperty: 'altitude', // altitude property in properties, default by 'altitude',
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true
+})
+vector.addTo(map)
+
+
+
+addGeo(getCurrTiles());

.svn/pristine/37/3755e36e48969f4dd5b16d931cb8d0f217718c00.svn-base

@@ -0,0 +1,51 @@
+import * as THREE from 'three'
+import {clearFids} from '../core/dyWoker'
+import {threeLayer, vector} from './initScene3D'
+
+const frustum = new THREE.Frustum();
+const cameraViewProjectionMatrix = new THREE.Matrix4();
+
+
+function meshStatus() {
+  let camera = threeLayer.getCamera();
+  if (!camera) return
+  camera.updateMatrixWorld();
+  camera.matrixWorldInverse.getInverse(camera.matrixWorld);
+  cameraViewProjectionMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+  frustum.setFromMatrix(cameraViewProjectionMatrix);
+  let scene = threeLayer.getScene()
+  let children = scene.children
+  for (let i = 0; i < children.length; i++) {
+    let m = children[i]
+    if (m.type === 'Mesh') {
+      let viewMesh = frustum.intersectsObject(m)
+      if (!viewMesh) {
+        scene.remove(m)
+        m.isRemove = true
+        vector.removeGeometry(m.texts)
+        clearFids(m.fids)
+        i--
+      }
+    }
+  }
+}
+
+
+function unMeshAll () {
+  let scene = threeLayer.getScene()
+  let children = scene.children
+  for (let i = 0; i < children.length; i++) {
+    let m = children[i]
+    if (m.type === 'Mesh') {
+      scene.remove(m)
+      m.isRemove = true
+      vector.removeGeometry(m.texts)
+      clearFids(m.fids)
+      i--
+    }
+  }
+}
+export {
+  unMeshAll,
+  meshStatus
+}

.svn/pristine/3f/3f7b872c278e56d68606e1e0eb99ae9b082af8bf.svn-base

@@ -0,0 +1,58 @@
+/**
+ * 
+ * @param {*} geometry 
+ * @return {*} 
+ * morphTargetsPosition,
+ * morphTargetsNormal,
+ * _vertices
+  _normals
+  _colors
+  _uvs
+  _uvs2,
+  _skinIndices,
+  _skinWeights
+
+ */
+function fromGeometry(geometry) {
+
+  var faces = geometry.faces;
+  var vertices = geometry.vertices;
+
+  if (vertices.length > 0 && faces.length === 0) {
+
+    console.error('THREE.DirectGeometry: Faceless geometries are not supported.');
+
+  }
+
+  var _vertices = [],
+    _normals = [];
+
+  for (var i = 0; i < faces.length; i++) {
+
+    var face = faces[i];
+
+    _vertices.push(vertices[face.a], vertices[face.b], vertices[face.c]);
+
+    var vertexNormals = face.vertexNormals;
+
+    if (vertexNormals.length === 3) {
+
+      _normals.push(vertexNormals[0], vertexNormals[1], vertexNormals[2]);
+
+    } else {
+
+      var normal = face.normal;
+
+      _normals.push(normal, normal, normal);
+
+    }
+
+  }
+
+  return {
+    vertices: _vertices,
+    normals: _normals,
+  }
+}
+
+export default fromGeometry

.svn/pristine/41/411c2a3970fde5af727d4ae5f34578e31c94c2c3.svn-base

@@ -0,0 +1,76 @@
+import * as THREE from 'three'
+import { animation, init } from './meshAnimation'
+import grentMesh from './grentMesh'
+import config from './config'
+import { Marker } from 'maptalks'
+import { mapGoto } from './statusManagement'
+
+
+function addText(args) {
+  var point = new Marker(args.point,
+    {
+      properties: {
+        altitude: args.height + 5
+      },
+      visible: true,
+      editable: true,
+      cursor: 'pointer',
+      shadowBlur: 0,
+      shadowColor: 'black',
+      draggable: false,
+      dragShadow: false, // display a shadow during dragging
+      drawOnAxis: null,  // force dragging stick on a axis, can be: x, y
+      symbol: {
+        'textFaceName': 'sans-serif',
+        'textName': args.name,
+        'textFill': '#646464',
+        'textHorizontalAlignment': 'center',
+        'textSize': 12
+      }
+    }
+  );
+  point.on('click', () => {
+    mapGoto({ center: args.point, zoom: 19 })
+  })
+
+  return point
+}
+
+
+async function listener(event) {
+  let geoJsonArray = event.data.geoJsonArray
+  geoJsonArray.forEach(j => {
+    let {
+      maxHeight,
+      animateBuffArrays,
+      fids,
+      verticesBuffArrays: verticesArray,
+      normalsBuffArrays: normalsArray,
+      type,
+      texts
+    } = j
+
+    let geometry = new THREE.BufferGeometry()
+    geometry.addAttribute('position', new THREE.BufferAttribute(verticesArray, 3));
+    geometry.addAttribute('normal', new THREE.BufferAttribute(normalsArray, 3));
+
+    var mesh = grentMesh(geometry, type);
+    threeLayer.getScene().add(mesh)
+    mesh.maxHeight = maxHeight
+    mesh.fids = fids
+
+    init(verticesArray, maxHeight)
+    animation(mesh, verticesArray, animateBuffArrays, config.stepTotal)
+
+    mesh.texts = texts.map(addText)
+
+    vector.addGeometry(mesh.texts, {
+      enableAltitude: true,        // enable altitude
+      altitudeProperty: 'altitude'
+    })
+
+    console.log(mesh.texts[0], mesh.texts[0].getSize())
+  })
+}
+
+export default listener

.svn/pristine/43/43fe10adeb44c8b9a2298305995ce038cce7a637.svn-base

@@ -0,0 +1,23 @@
+import * as THREE from 'three'
+const m = new THREE.MeshLambertMaterial({ 
+
+  color: 0xffffff, 
+  reflectivity: 0.8,
+  emissive:0xffffff,
+  emissiveIntensity:0.5,
+  wireframe: false, 
+  flatShading: true,
+  
+});
+
+
+
+
+function grentMesh(geometry, type) {
+  let mesh = new THREE.Mesh(geometry, m)
+  mesh.castShadow = true; 
+  mesh.receiveShadow = true;
+  return mesh
+}
+
+export default grentMesh

.svn/pristine/4a/4ac5e1171e527fa9b9005a95dac449734e910825.svn-base

@@ -0,0 +1,53 @@
+import FeaturesToAttribute from '../worker/featuresToAttribute.worker'
+import addMesh from '../business/addMesh'
+
+let workers = [
+  new FeaturesToAttribute()
+]
+
+workers.forEach(worker => {
+  worker.addEventListener('message', event => {
+    if (event.data.incident === 'addGeo') {
+      addMesh(event)
+    }
+  })
+})
+
+let index = 0
+function getWorker() {
+  if (index >= workers.length) index = 0
+  return workers[index++]
+}
+
+
+function addGeo(tiles) {
+  let map = threeLayer.getMap()
+  let setting = {
+    center: map.getCenter(),
+    maxNativeZoom: map.getMaxNativeZoom()
+  }
+
+  bus.emit('addGeoing')
+
+  let length = workers.length
+  let len = Math.floor(tiles.length / length)
+  for (let i = 0; i < length; i++) {
+    getWorker().postMessage(JSON.stringify({
+      thing: 'getGeo',
+      map: setting,
+      tiles: tiles.slice(i * len, i === length - 1 ? tiles.length : len * (i + 1))
+    }))
+  }
+}
+
+function clearFids (fids) {
+  getWorker().postMessage(JSON.stringify({
+    thing: 'clearFids',
+    fids: fids
+  }))
+}
+
+export {
+  addGeo,
+  clearFids
+}

.svn/pristine/4d/4de81020cab904a53f56199162ed5ef1b81f16e1.svn-base

@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>瓦片图层与地理投影 - 百度投影底图</title>
+  <style type="text/css">
+    html,body{margin:0px;height:100%;width:100%}
+    .container{width:100%;height:100%}
+  </style>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/maptalks@0.41.1/dist/maptalks.css">
+  <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/maptalks@0.41.1/dist/maptalks.min.js"></script>
+  <body>
+    <div id="map" class="container"></div>
+
+    <script>
+      var map = new maptalks.Map('map', {
+        center: [105.08052356963802, 36.04231948670001],
+        zoom: 5,
+        minZoom:1,
+        maxZoom:19,
+        spatialReference:{
+          projection : 'baidu'
+        },
+        baseLayer: new maptalks.TileLayer('base', {
+          'urlTemplate' : 'http://online{s}.map.bdimg.com/onlinelabel/?qt=tile&x={x}&y={y}&z={z}&styles=pl&scaler=1&p=1',
+          'subdomains'  : [0,1,2,3,4,5,6,7,8,9],
+          'attribution' :  '&copy; <a target="_blank" href="http://map.baidu.com">Baidu</a>'
+        })
+      });
+
+    </script>
+  </body>
+</html>

.svn/pristine/4f/4f0f65394f0abac0a1018bf0fd5430e44594c7e3.svn-base

@@ -0,0 +1,40 @@
+import * as THREE from 'three'
+import { animation, init } from './meshAnimation'
+import grentMesh from './grentMesh'
+import config from './config'
+import addText from './addText'
+import { threeLayer } from './initScene3D'
+
+
+
+
+async function listener(event) {
+  let geoJsonArray = event.data.geoJsonArray
+  geoJsonArray.forEach(j => {
+    let {
+      maxHeight,
+      animateBuffArrays,
+      fids,
+      verticesBuffArrays: verticesArray,
+      normalsBuffArrays: normalsArray,
+      type,
+      texts
+    } = j
+
+    let geometry = new THREE.BufferGeometry()
+    geometry.addAttribute('position', new THREE.BufferAttribute(verticesArray, 3));
+    geometry.addAttribute('normal', new THREE.BufferAttribute(normalsArray, 3));
+
+    var mesh = grentMesh(geometry, type);
+    threeLayer.getScene().add(mesh)
+    mesh.maxHeight = maxHeight
+    mesh.fids = fids
+
+    init(verticesArray, maxHeight)
+    animation(mesh, verticesArray, animateBuffArrays, config.stepTotal)
+
+    addText(mesh, texts)
+  })
+}
+
+export default listener

.svn/pristine/4f/4f62549d62997f19e1d259e71b3ed9d405d080ae.svn-base

@@ -0,0 +1,126 @@
+import 'babel-core/register'
+import 'babel-polyfill'
+import featuresToPolygon from './featuresToPolygon'
+import config from '../business/config'
+import * as management from './dataManagement'
+import grentText from './grentText'
+import { mergeBigData, getMaxHeight, grentAnimationArray, extractType, fromGeometry } from './util'
+import { toExtrudeGeometry, reductive, LatLngToPoint } from './PolygonToGeom'
+
+
+function featureToAttribute(map, features, stepTotal) {
+  let polygons = featuresToPolygon(features)
+  let verticesArray = []
+  let normalsArray = []
+
+  polygons.forEach((polygon, index) => {
+    let height = features[index].properties.height 
+      || features[index].properties.levels * config.levelHeight
+      || config.defaultHeight
+
+    let geo = toExtrudeGeometry(polygon, map, height)
+
+    if (!geo) return;
+
+    features[index].height = height
+    let { vertices, normals } = fromGeometry(geo)
+    verticesArray.push(vertices)
+    normalsArray.push(normals)
+  })
+
+  verticesArray = mergeBigData(verticesArray)
+  normalsArray = mergeBigData(normalsArray)
+
+  let maxHeight = getMaxHeight(verticesArray)
+  let animateBuffArrays = grentAnimationArray(verticesArray, stepTotal, maxHeight)
+
+  return {
+    verticesBuffArrays: verticesArray,
+    normalsBuffArrays: normalsArray,
+    maxHeight,
+    animateBuffArrays
+  }
+}
+
+function featuresGrentAttribute(map, features) {
+  let { typeFeatures, types } = extractType(features)
+  let geoJsonArray = []
+
+  reductive(map)
+
+  typeFeatures.forEach((features, index) => {
+    if (features.length) {
+      geoJsonArray.push({
+        ...featureToAttribute(map, features, config.stepTotal),
+        texts: grentText(features),
+        fids: features.map(f => f.id),
+        type: index === 0 ? 'unknown' : types[index - 1]
+      })
+    }
+  })
+  
+  let transArray = []
+  geoJsonArray.forEach(geo => {
+    transArray.push(
+      geo.verticesBuffArrays.buffer,
+      geo.normalsBuffArrays.buffer,
+      geo.animateBuffArrays.buffer
+    )
+  })
+
+  return {
+    geoJsonArray,
+    transArray
+  }
+}
+
+
+let _interface = {
+  getGeo: (function () {
+    let ergodicIndex = 0
+    return data => {
+      ergodicIndex++
+      let runing = 0
+      let currErgodicIndex = ergodicIndex
+      self.postMessage({
+        incident: 'obsAddGeo'
+      })
+
+      for (let i = 0; i < data.tiles.length; i++) {
+        if (currErgodicIndex !== ergodicIndex) return;
+        let tile = data.tiles[i]
+        let { x, y, z } = tile
+        management.getFeatures(x, y, z)
+          .then(features => {
+            if (currErgodicIndex !== ergodicIndex) return;
+            let { geoJsonArray, transArray } = featuresGrentAttribute(data.map, features)
+            self.postMessage({
+              incident: 'addGeo',
+              geoJsonArray
+            }, transArray)
+
+            if (++runing === data.tiles.length) {
+              self.postMessage({
+                incident: 'addSuccess'
+              })
+            }
+          })
+      }
+
+      console.log('----?', LatLngToPoint({ lat: 113.583891, lng: 22.255409}, data.map))
+    }
+  })(),
+
+  clearFids: data => {
+    management.clearGeos(data.fids)
+  }
+}
+
+
+self.addEventListener('message', event => {
+  let data = event.data
+  if (typeof event.data === 'string') {
+    data = JSON.parse(event.data)
+  }
+  _interface[data.thing] && _interface[data.thing](data)
+})

.svn/pristine/53/5333120810bdbffbc0375c677208245d20d39d5a.svn-base

@@ -0,0 +1,98 @@
+import 'babel-core/register'
+import 'babel-polyfill'
+import './style/public.css'
+import * as maptalks from 'maptalks'
+import { ThreeLayer } from 'maptalks.three'
+import meshStaus from './business/meshStaus'
+import initAmbient from './business/initAmbient'
+import { addGeo } from './core/dyWoker'
+import Event from './core/Event'
+import * as status from './business/statusManagement'
+
+let args = status.analysis()
+
+global.bus = new Event()
+global.map = new maptalks.Map('map', {
+  center: [args.lon, args.lat],
+  zoom: args.zoom,
+  bearing: args.bearing,
+  maxZoom: 20,
+  minZoom: 15,
+  maxPitch: 70,
+  maxVisualPitch: 100,
+  doubleClickZoom: false,
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  baseLayer: new maptalks.TileLayer('base', {
+    'urlTemplate': 'http://{s}.tile.osm.org/{z}/{x}/{y}.png',
+    'subdomains': ['a', 'b', 'c']
+  })
+})
+
+
+
+
+// 高层数据获取
+const canvasTile = new maptalks.CanvasTileLayer('tile', {
+  urlTemplate: 'https://{s}.data.osmbuildings.org/0.2/anonymous/tile/{z}/{x}/{y}.json',
+  subdomains: ['a', 'b', 'c', 'd'],
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  repeatWorld: false,
+  maxAvailableZoom: 15
+})
+
+map.addLayer(canvasTile)
+
+
+
+
+// 3DThree与map结合
+global.threeLayer = new ThreeLayer('t', {
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true
+})
+
+threeLayer.prepareToDraw = initAmbient
+
+
+// 获取高层数据
+function getCurrTiles() {
+  let tileGrids = canvasTile.getTiles().tileGrids
+  for (var i = 0; i < tileGrids.length; i++) {
+    if (tileGrids[i].zoom >= 15) break
+  }
+  return tileGrids[i].tiles
+}
+
+threeLayer.draw = () => {
+  addGeo(getCurrTiles());
+  delete threeLayer.draw;
+}
+
+threeLayer.addTo(map)
+
+let timeout = null
+map.on('moving moveend zoomend dragrotating dragrotateend', () => {
+  clearTimeout(timeout)
+  timeout = setTimeout(() => {
+    meshStaus()
+    addGeo(getCurrTiles())
+    status.listStatus()
+  }, 500)
+});
+
+
+
+// Maker承载容器
+global.vector = new maptalks.VectorLayer('vector', {
+  enableAltitude: true,        // enable altitude
+  altitudeProperty: 'altitude', // altitude property in properties, default by 'altitude',
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true
+})
+vector.addTo(map)

.svn/pristine/5b/5b84c70150018a595d651b7d4974ea24c0c4c13e.svn-base

@@ -0,0 +1,123 @@
+import * as maptalks from 'maptalks'
+import FnTask from './Task.js'
+import Event from './Event'
+
+
+// 从远程中获取数据
+function getRemoteData (url) {
+  return new Promise((resolve, reject) => {
+    maptalks.Ajax.getJSON(url, (err, data) => {
+      if (err || !data || !data.features.length) {
+        reject()
+      } else {
+        resolve(data.features)
+      }
+    })
+  })
+}
+
+
+
+
+const LOADDING = 1;
+const SUCCESS = 2;
+
+class Reveal extends Event {
+  constructor() {
+    super()
+    this.urlStatue = {}
+    this.cache = {}
+    this.loaddingGeos = {}
+    this.remoteTask = new FnTask({maxParallel: 3})
+    this.loadTask = new FnTask({maxParallel: 5})
+  }
+
+  // 获取数据先从内存，再从远程获取
+  preloadingFeatures(url) {
+    this.urlStatue[url] = LOADDING
+    this.remoteTask.push(
+      async () => {
+        try {
+          return await getRemoteData(url)
+        } catch (e) {
+          delete this.urlStatue[url]
+          return null
+        }
+      },
+      data => {
+        this.emit(url, data)
+      }
+    )
+  }
+
+  checkFeatureState (id) {
+    for (let key in this.loaddingGeos) {
+      if (~this.loaddingGeos[key].indexOf(id)) return true
+    }
+  }
+
+  // 分批加载
+  async inBatches(url, features, addArchitecture) {
+    if (this.urlStatue[url] === LOADDING) {
+      for (let i = 0, len = features.length; i < len; i++) {
+        if (this.checkFeatureState(features[i].id)) {
+          features.splice(i, 1)
+          i--
+          len--
+        } else {
+          
+        }
+      }
+
+      this.loaddingGeos[url] = features.map(f => f.id)
+      this.cache[url] = await addArchitecture(features)
+      this.urlStatue[url] = SUCCESS
+    }
+  }
+
+  // 加载模型
+  async loaddingFeatures(url, cb) {
+    this.loadTask.push(async () => {
+      this.preloadingFeatures(url)
+      this.off(url)
+      this.once(url, features => {
+        if (features) {
+          if (document.hidden) {
+            this.once('visibilityshow', () => this.inBatches(url, features, cb))
+          } else {
+            this.inBatches(url, features, cb)
+          }
+        }
+      })
+    })
+  }
+
+  async loadRegion(urls, loadCb) {
+    for (let key of urls) {
+      if (this.urlStatue[key]) continue
+      this.loaddingFeatures(key, loadCb)
+    }
+  }
+
+  eliminate (urls) {
+    if (!Array.isArray(urls)) {
+      urls = [urls]
+    }
+
+    urls.forEach(url => {
+      delete this.urlStatue[url]
+      delete this.cache[url]
+      delete this.loaddingGeos[url]
+    })
+  }
+}
+
+const reveal = new Reveal()
+
+document.addEventListener('visibilitychange', function () {
+  if (!document.hidden) {
+    reveal.emit('visibilityshow')
+  }
+});
+
+export default reveal

.svn/pristine/5c/5cae243ca39cc7b54448f8cdbe8f75b5e8c55f34.svn-base

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta http-equiv="X-UA-Compatible" content="ie=edge">
+  <title>Document</title>
+</head>
+<body>
+  <div id="map"></div>
+  <!-- <div id="test"></div> -->
+</body>
+</html>

.svn/pristine/6d/6dda7dfaaa677423533bf6b93f33db8f721f0856.svn-base

@@ -0,0 +1,75 @@
+import * as THREE from 'three'
+import { animation, init } from './meshAnimation'
+import grentMesh from './grentMesh'
+import config from './config'
+import { Marker } from 'maptalks'
+import { mapGoto } from './statusManagement'
+
+
+function addText(args) {
+  var point = new Marker(args.point,
+    {
+      properties: {
+        altitude: args.height + 36
+      },
+      visible: true,
+      editable: true,
+      cursor: 'pointer',
+      shadowBlur: 0,
+      shadowColor: 'black',
+      draggable: false,
+      dragShadow: false, // display a shadow during dragging
+      drawOnAxis: null,  // force dragging stick on a axis, can be: x, y
+      symbol: {
+        'textFaceName': 'sans-serif',
+        'textName': args.name,
+        'textFill': '#646464',
+        'textHorizontalAlignment': 'center',
+        'textSize': 12
+      }
+    }
+  );
+
+  vector.addGeometry([point], {
+    enableAltitude: true,        // enable altitude
+    altitudeProperty: 'altitude'
+  })
+
+  point.on('click', () => {
+    mapGoto({ center: args.point })
+  })
+
+  return point
+}
+
+
+async function listener(event) {
+  let geoJsonArray = event.data.geoJsonArray
+  geoJsonArray.forEach(j => {
+    let {
+      maxHeight,
+      animateBuffArrays,
+      fids,
+      verticesBuffArrays: verticesArray,
+      normalsBuffArrays: normalsArray,
+      type,
+      texts
+    } = j
+
+    let geometry = new THREE.BufferGeometry()
+    geometry.addAttribute('position', new THREE.BufferAttribute(verticesArray, 3));
+    geometry.addAttribute('normal', new THREE.BufferAttribute(normalsArray, 3));
+
+    var mesh = grentMesh(geometry, type);
+    threeLayer.getScene().add(mesh)
+    mesh.maxHeight = maxHeight
+    mesh.fids = fids
+
+    init(verticesArray, maxHeight)
+    animation(mesh, verticesArray, animateBuffArrays, config.stepTotal)
+
+    texts.map(addText)
+  })
+}
+
+export default listener

.svn/pristine/6e/6eb9adc8dcbf8af53e21162c210b6d6b12c66854.svn-base

@@ -0,0 +1,54 @@
+import FeaturesToAttribute from '../worker/featuresToAttribute.worker'
+import addMesh from '../business/addMesh'
+import {threeLayer} from '../business/initScene3D'
+
+let workers = [
+  new FeaturesToAttribute()
+]
+
+workers.forEach(worker => {
+  worker.addEventListener('message', event => {
+    if (event.data.incident === 'addGeo') {
+      addMesh(event)
+    }
+  })
+})
+
+let index = 0
+function getWorker() {
+  if (index >= workers.length) index = 0
+  return workers[index++]
+}
+
+
+function addGeo(tiles) {
+  let map = threeLayer.getMap()
+  let setting = {
+    center: map.getCenter(),
+    maxNativeZoom: map.getMaxNativeZoom()
+  }
+
+  bus.emit('addGeoing')
+
+  let length = workers.length
+  let len = Math.floor(tiles.length / length)
+  for (let i = 0; i < length; i++) {
+    getWorker().postMessage(JSON.stringify({
+      thing: 'getGeo',
+      map: setting,
+      tiles: tiles.slice(i * len, i === length - 1 ? tiles.length : len * (i + 1))
+    }))
+  }
+}
+
+function clearFids (fids) {
+  getWorker().postMessage(JSON.stringify({
+    thing: 'clearFids',
+    fids: fids
+  }))
+}
+
+export {
+  addGeo,
+  clearFids
+}

.svn/pristine/74/7419a93c9fa1a2fb29d7f137961179e064dcc4f2.svn-base

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <meta http-equiv="X-UA-Compatible" content="ie=edge">
+  <title>Document</title>
+</head>
+<body>
+  <div id="map"></div>
+<script type="text/javascript" src="bundle.js"></script></body>
+</html>

.svn/pristine/7a/7a77187c81e4d5d209b45467e68d9ea3be78b02e.svn-base

@@ -0,0 +1,121 @@
+import axios from 'axios'
+import * as db from '../core/db'
+import ReqEvent from '../core/Event'
+
+const store = {}
+const geos = []
+
+const getData = (() => {
+  let joinKeys = []
+  let urlTemplate = 'https://{s}.data.osmbuildings.org/0.2/anonymous/tile/{z}/{x}/{y}.json'
+  let subdomains = ['a', 'b', 'c', 'd']
+  let index = 0
+  let requestings = []
+  let event = new ReqEvent()
+
+  async function ajaxGetData(key, url) {
+    let index = requestings.indexOf(key)
+    if (~index) {
+      return new Promise((resolve, reject) => {
+        event.once(key, (data, error) => {
+          if (error) {
+            reject(error)
+          } else {
+            data.data && (data.data.__once = false)
+            resolve(data)
+          }
+        })
+      })
+    } else {
+      requestings.push(key)
+
+      function result(res, err) {
+        if (err) {
+          event.emit(key, null, res)
+        } else {
+          event.emit(key, res)
+          res.data && (res.data.__once = true)
+        }
+        let index = requestings.indexOf(key)
+        requestings.splice(index, 1)
+        return res
+      }
+
+      return axios.get(url).then(res => result(res)).catch(res => result(res, 1))
+    }
+  }
+
+  function getSubdomain() {
+    index === subdomains.length && (index = 0)
+    return subdomains[index++]
+  }
+
+  function storeCtrl(key, data) {
+    db.add({id: key, ...data})
+    store[key] = data
+  }
+
+  function obtain(key) {
+    let index = joinKeys.indexOf(key)
+    joinKeys.splice(index, 1)
+    joinKeys.push(key)
+  }
+
+  async function getData(x, y, z) {
+    let key = `${x}-${y}-${z}`
+    let url = urlTemplate
+      .replace('{s}', getSubdomain())
+      .replace('{x}', x)
+      .replace('{y}', y)
+      .replace('{z}', z)
+
+    let obj = await db.get(key)
+
+    if (obj) {
+      return obj
+    } else {
+      let data = await ajaxGetData(key, url).then(res => res.data)
+      if (data && data.__once) {
+        storeCtrl(key, data)
+      }
+      return data
+    }
+  }
+
+  return getData
+})();
+
+function filter(features) {
+  let result = []
+
+  features.forEach(item => {
+    if (!~geos.indexOf(item.id)) {
+      geos.push(item.id)
+      result.push(item)
+    }
+  })
+
+  return result
+}
+
+async function getFeatures(x, y, z) {
+  
+  let data = await getData(x, y, z)
+  let features = data && data.features ? filter(data.features) : []
+
+  return features
+}
+
+function clearGeos (ids) {
+  ids.forEach(id => {
+    let index = geos.indexOf(id)
+    if (~index) {
+      geos.splice(index, 1)
+    }
+  })
+}
+
+export {
+  getFeatures,
+  clearGeos
+}

.svn/pristine/7c/7c642f41cae9959a3e6f8f95323fa1d981a1a932.svn-base

@@ -0,0 +1,53 @@
+import FeaturesToAttribute from '../worker/featuresToAttribute.worker'
+import dyUpdateGeo from '../business/dyUpdateGeo'
+
+let workers = [
+  new FeaturesToAttribute()
+]
+
+workers.forEach(worker => {
+  worker.addEventListener('message', event => {
+    if (event.data.incident === 'addGeo') {
+      dyUpdateGeo(event)
+    }
+  })
+})
+
+let index = 0
+function getWorker() {
+  if (index >= workers.length) index = 0
+  return workers[index++]
+}
+
+
+function addGeo(tiles) {
+  let map = threeLayer.getMap()
+  let setting = {
+    center: map.getCenter(),
+    maxNativeZoom: map.getMaxNativeZoom()
+  }
+
+  bus.emit('addGeoing')
+
+  let length = workers.length
+  let len = Math.floor(tiles.length / length)
+  for (let i = 0; i < length; i++) {
+    getWorker().postMessage(JSON.stringify({
+      thing: 'getGeo',
+      map: setting,
+      tiles: tiles.slice(i * len, i === length - 1 ? tiles.length : len * (i + 1))
+    }))
+  }
+}
+
+function clearFids (fids) {
+  getWorker().postMessage(JSON.stringify({
+    thing: 'clearFids',
+    fids: fids
+  }))
+}
+
+export {
+  addGeo,
+  clearFids
+}

.svn/pristine/81/812c151760040730d36090692b167203e6ca3528.svn-base

@@ -0,0 +1,122 @@
+import reveal from '../core/reveal'
+import * as THREE from 'three'
+import { animation, init } from './meshAnimation'
+import config from './config'
+import FeaturesToAttribute from '../worker/featuresToAttribute.worker'
+import Event from '../core/Event'
+import {clearFids} from '../core/dyWoker'
+
+const worker = new FeaturesToAttribute()
+const cache = reveal.cache
+const frustum = new THREE.Frustum();
+const cameraViewProjectionMatrix = new THREE.Matrix4();
+const hideMeshs = []
+const $event = new Event()
+
+
+worker.addEventListener('message', listener)
+
+function listener(event) {
+  $event.emit(
+    event.data.incident,
+    event.data.animationArray
+  )
+}
+
+const showMesh = function() {
+  let IN_ID = 0
+
+  return function showMesh(mesh, index) {
+    if (mesh.visible) return;
+
+    let incident = 'grentAnimation' + (IN_ID++)
+    let verticesArray = mesh.geometry.attributes.position.array;
+    let postObj = {
+      thing: 'grentAnimationArray',
+      verticesBuffArrays: verticesArray,
+      maxHeight: mesh.maxHeight,
+      incident
+    }
+
+    worker.postMessage(postObj)
+
+    $event.once(incident, animationArray => {
+      init(mesh.geometry.attributes.position.array, mesh.maxHeight)
+      setTimeout(() => {
+        mesh.visible = true
+        animation(mesh, verticesArray, animationArray, config.stepTotal)
+      }, 300)
+      threeLayer.renderScene()
+    })
+  }
+}();
+
+function hideMesh(mesh, index) {
+  mesh.visible = false
+  threeLayer.renderScene()
+}
+
+
+function meshStatus_() {
+  const camera = threeLayer.getCamera();
+  camera.updateMatrixWorld();
+  camera.matrixWorldInverse.getInverse(camera.matrixWorld);
+  cameraViewProjectionMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+  frustum.setFromMatrix(cameraViewProjectionMatrix);
+
+  for (let url in cache) {
+    let meshs = cache[url]
+    if (!Array.isArray(meshs)) continue;
+
+    for (let i = 0; i < meshs.length; i++) {
+      let mesh = meshs[i]
+      let index = hideMeshs.indexOf(mesh)
+      let viewMesh = frustum.intersectsObject(mesh)
+
+      if (viewMesh) {
+        mesh.hideCount = 0
+      } else {
+        mesh.hideCount = (mesh.hideCount || 0) + 1;
+      }
+
+      if (viewMesh && ~index) {
+        showMesh(mesh, index)
+        hideMeshs.splice(index, 1)
+      } else if (!viewMesh && !~index) {
+        if (mesh.visible && mesh.hideCount >= 30) {
+          hideMesh(mesh, index)
+          hideMeshs.push(mesh)
+        }
+      }
+
+      if (mesh.hideCount > 300) {
+        threeLayer.getScene().remove(mesh)
+        reveal.eliminate(url);
+        break;
+      }
+    }
+  }
+}
+
+
+function meshStatus() {
+  const camera = threeLayer.getCamera();
+  camera.updateMatrixWorld();
+  camera.matrixWorldInverse.getInverse(camera.matrixWorld);
+  cameraViewProjectionMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+  frustum.setFromMatrix(cameraViewProjectionMatrix);
+  let scene = threeLayer.getScene()
+  let children = scene.children
+  children.forEach(m => {
+    if (m.type === 'Mesh') {
+      let viewMesh = frustum.intersectsObject(m)
+      if (!viewMesh) {
+        scene.remove(m)
+        m.isRemove = true
+        clearFids(m.fids)
+      }
+    }
+  })
+}
+
+export default meshStatus

.svn/pristine/82/823724565768497d9818d94c4aa1205b9a230b15.svn-base

@@ -0,0 +1,45 @@
+{
+  "name": "maptalks-three",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "webpack-dev-server --mode development",
+    "build": "webpack --mode production"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "autoprefixer": "^9.1.5",
+    "babel-core": "^6.26.3",
+    "babel-loader": "^7.1.5",
+    "babel-polyfill": "^6.26.0",
+    "babel-preset-env": "^1.7.0",
+    "babel-preset-es2015": "^6.24.1",
+    "babel-preset-stage-0": "^6.24.1",
+    "css-loader": "^1.0.0",
+    "dat-gui": "^0.5.0",
+    "extract-text-webpack-plugin": "^3.0.2",
+    "file-loader": "^1.1.11",
+    "html-webpack-plugin": "^3.2.0",
+    "postcss-cssnext": "^3.1.0",
+    "postcss-loader": "^3.0.0",
+    "style-loader": "^0.23.0",
+    "url-loader": "^1.1.1",
+    "webpack": "^4.17.2",
+    "webpack-cli": "^3.1.0",
+    "webpack-dev-server": "^3.1.8",
+    "worker-loader": "^2.0.0"
+  },
+  "dependencies": {
+    "axios": "^0.18.0",
+    "dat-gui": "^0.5.0",
+    "maptalks": "^0.41.1",
+    "maptalks.three": "^0.5.0",
+    "three": "^0.96.0",
+    "three-obj-loader": "^1.1.3",
+    "three-stats": "^1.0.1"
+  }
+}

.svn/pristine/84/845394df2f41d801525b8efbf51e318894b35811.svn-base

@@ -0,0 +1,77 @@
+import { cuttingString } from './util'
+
+function average(aver, curr, index) {
+  aver[0] += curr[0]
+  aver[1] += curr[1]
+  if (index) {
+    aver[0] /= 2
+    aver[1] /= 2
+  }
+  return aver
+}
+
+function getMaxPoint(points, index) {
+  let maxVal = points[0][index], 
+      maxIndex = 0;
+
+  for (let i = 1; i < points.length; i++) {
+    if (points[i][index] > maxVal) {
+      maxVal = points[i][index]
+      maxIndex = i
+    }
+  }
+
+  return points[maxIndex]
+}
+
+function getMinPoint(points, index) {
+  let minVal = points[0][index],
+    minIndex = 0;
+
+  for (let i = 1; i < points.length; i++) {
+    if (points[i][index] < minVal) {
+      minVal = points[i][index]
+      minIndex = i
+    }
+  }
+
+  return points[minIndex]
+}
+
+
+function grentText(features) {
+  let texts = []
+
+  features.forEach(fe => {
+    if (fe.properties.name) {
+      let name = cuttingString(fe.properties.name, 15)
+      let averagePoint = fe.geometry.coordinates.reduce((tPoint, geometry, index) => {
+        let mPoints = [
+          getMaxPoint(geometry, 0),
+          getMaxPoint(geometry, 1),
+          getMinPoint(geometry, 0),
+          getMinPoint(geometry, 1),
+        ]
+
+        return average(
+          tPoint,
+          mPoints.reduce(average, [0, 0]),
+          index
+        )
+      }, [0, 0])
+
+      
+      texts.push({
+        name: name.join('\n') + '\n|',
+        point: averagePoint,
+        top: fe.height-1,
+        width: name[0].length * 18 + 20,
+        height: name.length * 18 + 20,
+        id: fe.id
+      })
+    }
+  })
+
+  return texts
+}
+export default grentText

.svn/pristine/85/85f2b475e0a02e8e916383c963ea25f77339cc3d.svn-base

@@ -0,0 +1,76 @@
+import * as THREE from 'three'
+import { analysis } from '../business/statusManagement'
+
+export default function (gl, scene, camera) {
+  let renderer = threeLayer.getThreeRenderer()
+  
+
+  global.scene = scene
+  
+  // camera.add(new THREE.PointLight(0xffffff))
+  // // camera.far = 60000
+  // camera.updateProjectionMatrix()
+  // map.setPitch(60)
+
+
+  /*
+  var ground = new THREE.Mesh( new THREE.PlaneGeometry( 10000,10000,2,2 ), new THREE.MeshLambertMaterial({ color:0xffff00, side:THREE.DoubleSide,  }))
+  ground.name = "ground";
+  ground.position.set(10030408, -46147088, 5.999996185302734);
+
+  ground.receiveShadow = true;
+  ground.castShadow = true
+  scene.add(ground);
+
+  var box = new THREE.Mesh(new THREE.BoxGeometry(1000, 1000, 1000), new THREE.MeshLambertMaterial({ color: 0xff0000 }));
+  box.position.set(10030208, -46146088, -1000.01798629760742);
+  box.castShadow = true;
+  
+
+  scene.add(box);
+  
+  let directionalLight = new THREE.DirectionalLight(0xffffff, 10);
+  directionalLight.position.set(10030808, -46146088, -2100);
+  directionalLight.castShadow = true;
+  directionalLight.shadow.camera.near = 100;
+  directionalLight.shadow.camera.far = 10000;
+  directionalLight.shadow.camera.left = -10000;
+  directionalLight.shadow.camera.bottom = -10000;
+  directionalLight.shadow.camera.right = 10000;
+  directionalLight.shadow.camera.top = 10000;
+  
+  directionalLight.target = box;
+  scene.add(directionalLight);
+  let helper = new THREE.DirectionalLightHelper(directionalLight);
+  helper.scale.set(1000,1000,1000)
+  scene.add(helper);
+*/
+
+  let ambientLight = new THREE.AmbientLight( 0x262321, 1)
+  scene.add(ambientLight)
+
+  let frontLight = new THREE.DirectionalLight( 0xffffff, 0.2 );
+  frontLight.position.set(1,0,0)
+  scene.add( new THREE.DirectionalLightHelper(frontLight) )
+  scene.add( frontLight );
+
+  let backLight = new THREE.DirectionalLight( 0xffffff,  0.2);
+  backLight.position.set(-1,0,0)
+  scene.add( new THREE.DirectionalLightHelper(backLight) )
+  scene.add( backLight );
+
+  let sunLight = new THREE.DirectionalLight( 0xf2fee7, 1 );
+  sunLight.position.set(80,0,-80).normalize();
+  sunLight.castShadow = true;
+  scene.add( sunLight );
+  
+  map.setPitch(analysis().pitch)
+  
+
+  
+
+  renderer.shadowMapEnabled = true;
+  renderer.shadowMapSoft = true;
+
+
+}

.svn/pristine/87/87d12beac09803420b8bb7f4ae1bcc164e60c6e8.svn-base

@@ -0,0 +1,124 @@
+import 'babel-core/register'
+import 'babel-polyfill'
+import featuresToPolygon from './featuresToPolygon'
+import config from '../business/config'
+import * as management from './dataManagement'
+import grentText from './grentText'
+import { mergeBigData, getMaxHeight, grentAnimationArray, extractType, fromGeometry } from './util'
+import { toExtrudeGeometry, reductive } from './PolygonToGeom'
+
+
+function featureToAttribute(map, features, stepTotal) {
+  let polygons = featuresToPolygon(features)
+  let verticesArray = []
+  let normalsArray = []
+
+  polygons.forEach((polygon, index) => {
+    let height = features[index].properties.height 
+      || features[index].properties.levels * config.levelHeight
+      || config.defaultHeight
+
+    let geo = toExtrudeGeometry(polygon, map, height)
+
+    if (!geo) return;
+
+    features[index].height = height
+    let { vertices, normals } = fromGeometry(geo)
+    verticesArray.push(vertices)
+    normalsArray.push(normals)
+  })
+
+  verticesArray = mergeBigData(verticesArray)
+  normalsArray = mergeBigData(normalsArray)
+
+  let maxHeight = getMaxHeight(verticesArray)
+  let animateBuffArrays = grentAnimationArray(verticesArray, stepTotal, maxHeight)
+
+  return {
+    verticesBuffArrays: verticesArray,
+    normalsBuffArrays: normalsArray,
+    maxHeight,
+    animateBuffArrays
+  }
+}
+
+function featuresGrentAttribute(map, features) {
+  let { typeFeatures, types } = extractType(features)
+  let geoJsonArray = []
+
+  reductive(map)
+
+  typeFeatures.forEach((features, index) => {
+    if (features.length) {
+      geoJsonArray.push({
+        ...featureToAttribute(map, features, config.stepTotal),
+        texts: grentText(features),
+        fids: features.map(f => f.id),
+        type: index === 0 ? 'unknown' : types[index - 1]
+      })
+    }
+  })
+  
+  let transArray = []
+  geoJsonArray.forEach(geo => {
+    transArray.push(
+      geo.verticesBuffArrays.buffer,
+      geo.normalsBuffArrays.buffer,
+      geo.animateBuffArrays.buffer
+    )
+  })
+
+  return {
+    geoJsonArray,
+    transArray
+  }
+}
+
+
+let _interface = {
+  getGeo: (function () {
+    let ergodicIndex = 0
+    return data => {
+      ergodicIndex++
+      let runing = 0
+      let currErgodicIndex = ergodicIndex
+      self.postMessage({
+        incident: 'obsAddGeo'
+      })
+
+      for (let i = 0; i < data.tiles.length; i++) {
+        if (currErgodicIndex !== ergodicIndex) return;
+        let tile = data.tiles[i]
+        let { x, y, z } = tile
+        management.getFeatures(x, y, z)
+          .then(features => {
+            if (currErgodicIndex !== ergodicIndex) return;
+            let { geoJsonArray, transArray } = featuresGrentAttribute(data.map, features)
+            self.postMessage({
+              incident: 'addGeo',
+              geoJsonArray
+            }, transArray)
+
+            if (++runing === data.tiles.length) {
+              self.postMessage({
+                incident: 'addSuccess'
+              })
+            }
+          })
+      }
+    }
+  })(),
+
+  clearFids: data => {
+    management.clearGeos(data.fids)
+  }
+}
+
+
+self.addEventListener('message', event => {
+  let data = event.data
+  if (typeof event.data === 'string') {
+    data = JSON.parse(event.data)
+  }
+  _interface[data.thing] && _interface[data.thing](data)
+})

.svn/pristine/8c/8ca1652d4b5dd838780e70da17f180c4143915f2.svn-base

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <meta http-equiv="X-UA-Compatible" content="ie=edge">
+  <title>Document</title>
+</head>
+<body>
+  <div id="map"></div>
+  <select id="theme"></select>
+<script type="text/javascript" src="bundle.js"></script></body>
+</html>

.svn/pristine/8e/8ebb1bbb3acabd38dcb02076acec5820ba8ad09d.svn-base

@@ -0,0 +1,55 @@
+import FeaturesToAttribute from '../worker/featuresToAttribute.worker'
+import addMesh from '../business/addMesh'
+import {threeLayer} from '../business/initScene3D'
+
+let workers = [
+  new FeaturesToAttribute()
+]
+
+workers.forEach(worker => {
+  worker.addEventListener('message', event => {
+    if (event.data.incident === 'addGeo') {
+      addMesh(event)
+    }
+  })
+})
+
+let index = 0
+function getWorker() {
+  if (index >= workers.length) index = 0
+  return workers[index++]
+}
+
+
+function addGeo(tiles) {
+  console.log('add')
+  let map = threeLayer.getMap()
+  let setting = {
+    center: map.getCenter(),
+    maxNativeZoom: map.getMaxNativeZoom()
+  }
+
+  bus.emit('addGeoing')
+
+  let length = workers.length
+  let len = Math.floor(tiles.length / length)
+  for (let i = 0; i < length; i++) {
+    getWorker().postMessage(JSON.stringify({
+      thing: 'getGeo',
+      map: setting,
+      tiles: tiles.slice(i * len, i === length - 1 ? tiles.length : len * (i + 1))
+    }))
+  }
+}
+
+function clearFids (fids) {
+  getWorker().postMessage(JSON.stringify({
+    thing: 'clearFids',
+    fids: fids
+  }))
+}
+
+export {
+  addGeo,
+  clearFids
+}

.svn/pristine/91/91a76e42cf128f30f5bc2085bfe2c190bb43f7c0.svn-base

@@ -0,0 +1,78 @@
+import * as THREE from 'three'
+import { analysis } from '../business/statusManagement'
+
+
+export default function (gl, scene, camera) {
+  let renderer = threeLayer.getThreeRenderer()
+  
+
+  global.scene = scene
+  
+  // camera.add(new THREE.PointLight(0xffffff))
+  // // camera.far = 60000
+  // camera.updateProjectionMatrix()
+  // map.setPitch(60)
+
+
+  /*
+  var ground = new THREE.Mesh( new THREE.PlaneGeometry( 10000,10000,2,2 ), new THREE.MeshLambertMaterial({ color:0xffff00, side:THREE.DoubleSide,  }))
+  ground.name = "ground";
+  ground.position.set(10030408, -46147088, 5.999996185302734);
+
+  ground.receiveShadow = true;
+  ground.castShadow = true
+  scene.add(ground);
+
+  var box = new THREE.Mesh(new THREE.BoxGeometry(1000, 1000, 1000), new THREE.MeshLambertMaterial({ color: 0xff0000 }));
+  box.position.set(10030208, -46146088, -1000.01798629760742);
+  box.castShadow = true;
+  
+
+  scene.add(box);
+  
+  let directionalLight = new THREE.DirectionalLight(0xffffff, 10);
+  directionalLight.position.set(10030808, -46146088, -2100);
+  directionalLight.castShadow = true;
+  directionalLight.shadow.camera.near = 100;
+  directionalLight.shadow.camera.far = 10000;
+  directionalLight.shadow.camera.left = -10000;
+  directionalLight.shadow.camera.bottom = -10000;
+  directionalLight.shadow.camera.right = 10000;
+  directionalLight.shadow.camera.top = 10000;
+  
+  directionalLight.target = box;
+  scene.add(directionalLight);
+  let helper = new THREE.DirectionalLightHelper(directionalLight);
+  helper.scale.set(1000,1000,1000)
+  scene.add(helper);
+*/
+
+  let ambientLight = new THREE.AmbientLight( 0x262321, 0.3)
+  scene.add(ambientLight)
+
+  
+  let frontLight = new THREE.DirectionalLight( 0xffffff,  0.2);
+  frontLight.position.set(0,1,0)
+  scene.add( new THREE.DirectionalLightHelper(frontLight) )
+  scene.add( frontLight );
+
+
+  let backLight = new THREE.DirectionalLight( 0xffffff,  0.1);
+  backLight.position.set(0,0,1)
+  scene.add( new THREE.DirectionalLightHelper(backLight) )
+  scene.add( backLight );
+
+  
+
+  let sunLight = new THREE.DirectionalLight( 0xf2fee7, 0.6 );
+  sunLight.position.set(80,0,-80).normalize();
+  sunLight.castShadow = true;
+  scene.add( sunLight );
+  
+  map.setPitch(analysis().pitch)
+  
+
+ 
+ 
+
+}

.svn/pristine/94/947a5034627e77dcacc27301bbe043e4aa13cdd6.svn-base

@@ -0,0 +1,85 @@
+import 'babel-core/register'
+import 'babel-polyfill'
+import './style/public.css'
+import * as maptalks from 'maptalks'
+import { ThreeLayer } from 'maptalks.three'
+import meshStaus from './business/meshStaus'
+import initAmbient from './business/initAmbient'
+import { addGeo } from './core/dyWoker'
+import Event from './core/Event'
+import * as status from './business/statusManagement'
+// import './business/test'
+
+let args = status.analysis()
+
+global.bus = new Event()
+global.map = new maptalks.Map('map', {
+  center: [args.lon, args.lat],
+  zoom: args.zoom,
+  bearing: args.bearing,
+  maxZoom: 20,
+  minZoom: 15,
+  maxPitch: 70,
+  maxVisualPitch: 100,
+  doubleClickZoom: false,
+  attribute: {'content': ''},
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  baseLayer: new maptalks.TileLayer('tile', {
+    'urlTemplate': 'http://tile0.f4map.com/tiles/f4_3d/{z}/{x}/{y}.png',
+    // http://tile0.f4map.com/tiles/f4_3d/{z}/{x}/{y}.png
+    // http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png
+    'subdomains': ['a', 'b', 'c', 'd']
+  })
+})
+
+
+
+const canvasTile = new maptalks.CanvasTileLayer('tile', {
+  urlTemplate: 'https://{s}.data.osmbuildings.org/0.2/anonymous/tile/{z}/{x}/{y}.json',
+  subdomains: ['a', 'b', 'c', 'd'],
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  repeatWorld: false,
+  maxAvailableZoom: 15
+})
+
+map.addLayer(canvasTile)
+
+
+global.threeLayer = new ThreeLayer('t', {
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true
+})
+
+threeLayer.prepareToDraw = initAmbient
+
+
+
+function getCurrTiles() {
+  let tileGrids = canvasTile.getTiles().tileGrids
+  for (var i = 0; i < tileGrids.length; i++) {
+    if (tileGrids[i].zoom >= 15) break
+  }
+  return tileGrids[i].tiles
+}
+
+threeLayer.draw = () => {
+  addGeo(getCurrTiles());
+  delete threeLayer.draw;
+}
+
+threeLayer.addTo(map)
+
+let timeout = null
+map.on('moving moveend zoomend dragrotating dragrotateend', () => {
+  clearTimeout(timeout)
+  timeout = setTimeout(() => {
+    meshStaus()
+    addGeo(getCurrTiles())
+    status.listStatus()
+  }, 500)
+});

.svn/pristine/95/955d8dfa0d0aaa26a0119aeb92bea568bab00dc6.svn-base

@@ -0,0 +1,99 @@
+import 'babel-core/register'
+import 'babel-polyfill'
+import './style/public.css'
+import * as maptalks from 'maptalks'
+import { ThreeLayer } from 'maptalks.three'
+import meshStaus from './business/meshStaus'
+import initAmbient from './business/initAmbient'
+import { addGeo } from './core/dyWoker'
+import Event from './core/Event'
+import { referText } from './business/addText'
+import * as status from './business/statusManagement'
+
+let args = status.analysis()
+
+global.bus = new Event()
+global.map = new maptalks.Map('map', {
+  center: [args.lon, args.lat],
+  zoom: args.zoom,
+  bearing: args.bearing,
+  maxZoom: 20,
+  minZoom: 15,
+  maxPitch: 70,
+  maxVisualPitch: 100,
+  doubleClickZoom: false,
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  baseLayer: new maptalks.TileLayer('base', {
+    'urlTemplate': 'http://{s}.tile.osm.org/{z}/{x}/{y}.png',
+    'subdomains': ['a', 'b', 'c']
+  })
+})
+
+
+
+
+// 高层数据获取
+const canvasTile = new maptalks.CanvasTileLayer('tile', {
+  urlTemplate: 'https://{s}.data.osmbuildings.org/0.2/anonymous/tile/{z}/{x}/{y}.json',
+  subdomains: ['a', 'b', 'c', 'd'],
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  repeatWorld: false,
+  maxAvailableZoom: 15
+})
+
+map.addLayer(canvasTile)
+
+
+
+
+// 3DThree与map结合
+global.threeLayer = new ThreeLayer('t', {
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true
+})
+
+threeLayer.prepareToDraw = initAmbient
+
+
+// 获取高层数据
+function getCurrTiles() {
+  let tileGrids = canvasTile.getTiles().tileGrids
+  for (var i = 0; i < tileGrids.length; i++) {
+    if (tileGrids[i].zoom >= 15) break
+  }
+  return tileGrids[i].tiles
+}
+
+threeLayer.addTo(map)
+
+let timeout = null
+map.on('moving zoomend dragrotating', () => {
+  clearTimeout(timeout)
+  timeout = setTimeout(() => {
+    meshStaus()
+    addGeo(getCurrTiles())
+    status.listStatus()
+  }, 500)
+});
+
+map.on('moveend zoomend dragrotateend', referText)
+
+
+// Maker承载容器
+global.vector = new maptalks.VectorLayer('vector', {
+  enableAltitude: true,        // enable altitude
+  altitudeProperty: 'altitude', // altitude property in properties, default by 'altitude',
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true
+})
+vector.addTo(map)
+
+
+
+addGeo(getCurrTiles());

.svn/pristine/9b/9bae8c73bb06385ce34716558cd6caa09ad856e8.svn-base

@@ -0,0 +1,234 @@
+import 'babel-core/register'
+import 'babel-polyfill'
+import featuresToPolygon from './featuresToPolygon'
+import { toExtrudeGeometry, reductive } from './PolygonToGeom'
+import geoGrentAttribute from './geoGrentAttribute'
+import config from '../business/config'
+import grentText from './grentText'
+import * as management from './dataManagement'
+
+function mergeBigData(datas) {
+  let index = 0
+  let len = datas.reduce((p, c) => p + c.length, 0)
+  let v3 = new Float32Array(len * 3)
+
+  datas.forEach(data => {
+    let length = data.length
+    for (let i = 0; i < length; i++) {
+      v3[index] = data[i].x
+      v3[index + 1] = data[i].y
+      v3[index + 2] = data[i].z
+      index += 3
+    }
+  })
+
+  return v3
+}
+
+function getMaxHeight(verticesBuffArrays) {
+  let maxHeight = verticesBuffArrays[2]
+  let len = verticesBuffArrays.length
+
+  for (let i = 3; i < len; i += 3) {
+    if (maxHeight < verticesBuffArrays[i + 2]) {
+      maxHeight = verticesBuffArrays[i + 2]
+    }
+  }
+
+  return maxHeight
+}
+
+function grentAnimationArray(verticesBuffArrays, stepTotal, maxHeight) {
+  let len = verticesBuffArrays.length
+  let animateBuffArrays = new Float32Array(
+    (len / 3) * stepTotal
+  )
+
+  for (let i = 0, index = 0; i < len; i += 3, index++) {
+    let indexes = index * stepTotal
+    let origin = verticesBuffArrays[i + 2]
+    let average = (maxHeight - origin) / stepTotal
+    for (let j = 1; j < stepTotal + 1; j++) {
+      animateBuffArrays[indexes + j - 1] = maxHeight - (j * average)
+    }
+  }
+
+  return animateBuffArrays
+}
+
+function grentVerticesNormals(map, features) {
+  let polygons = featuresToPolygon(features)
+  let verticesArray = []
+  let normalsArray = []
+  let textVerticesArray = []
+  let textNormalsArray = []
+
+  polygons.forEach((polygon, index) => {
+    let geo = toExtrudeGeometry(
+      polygon,
+      map,
+      features[index].properties.height || 
+      features[index].properties.levels * 5 || 5
+    )
+
+    if (!geo) return;
+
+    let { vertices, normals } = geoGrentAttribute(geo)
+    verticesArray.push(vertices)
+    normalsArray.push(normals)
+    
+    if (features[index].properties.name) {
+      let { textVertices, textNormals } = grentText(features[index].properties.name, vertices)
+      textVerticesArray.push(textVertices)
+      textNormalsArray.push(textNormals)
+    }
+  })
+
+  return {
+    verticesArray: mergeBigData(verticesArray),
+    normalsArray: mergeBigData(normalsArray),
+    textVerticesArray: mergeBigData(textVerticesArray),
+    textNormalsArray: mergeBigData(textNormalsArray)
+  } 
+}
+
+function grentAttribute(map, features, stepTotal) {
+  let {verticesArray, normalsArray} = grentVerticesNormals(map, features)
+  let maxHeight = getMaxHeight(verticesArray)
+  let animateBuffArrays = grentAnimationArray(
+    verticesArray,
+    stepTotal,
+    maxHeight
+  )
+  
+  return {
+    verticesBuffArrays: verticesArray,
+    normalsBuffArrays: normalsArray,
+    maxHeight,
+    animateBuffArrays
+  }
+}
+
+function extractType(features) {
+  let types = []
+  let typeFeatures = [[]]
+
+  features.forEach(f => {
+    if (f.properties && f.properties.type) {
+      let index = types.indexOf(f.properties.type)
+      // index = 0
+      if (~index) {
+        typeFeatures[index + 1].push(f)
+      } else {
+        types.push(f.properties.type)
+        typeFeatures[types.length] = [f]
+      }
+    } else {
+      typeFeatures[0].push(f)
+    }
+  })
+
+  return {
+    typeFeatures,
+    types
+  }
+}
+
+function featuresGrentAttribute(map, features) {
+  let { typeFeatures, types } = extractType(features)
+  let geoJsonArray = []
+
+  reductive(map)
+
+  typeFeatures.forEach((features, index) => {
+    if (features.length) {
+      geoJsonArray.push({
+        ...grentAttribute(map, features, config.stepTotal),
+        fids: features.map(f => f.id),
+        type: index === 0 ? 'unknown' : types[index - 1]
+      })
+    }
+  })
+  
+  let transArray = []
+  geoJsonArray.forEach(geo => {
+    transArray.push(
+      geo.verticesBuffArrays.buffer,
+      geo.normalsBuffArrays.buffer,
+      geo.animateBuffArrays.buffer
+    )
+  })
+
+  return {
+    geoJsonArray,
+    transArray
+  }
+}
+
+
+let _interface = {
+  initialAttribute: data => {
+    let map = JSON.parse(data.map)
+    let incident = data.incident || 'grentAttribute'
+    let features = JSON.parse(data.features)
+    let { geoJsonArray, transArray} = featuresGrentAttribute(map, features)
+
+    self.postMessage({
+      incident,
+      geoJsonArray
+    }, transArray)
+  },
+
+  grentAnimationArray: data => {
+    let verticesBuffArrays = data.verticesBuffArrays
+    let maxHeight = getMaxHeight(verticesBuffArrays)
+    let incident = data.incident || 'grentAnimationArray'
+    let animationArray = grentAnimationArray(
+      verticesBuffArrays, 
+      config.stepTotal, 
+      maxHeight
+    )
+
+    self.postMessage({
+      animationArray,
+      incident
+    }, [animationArray.buffer])
+  },
+
+  getGeo: (function () {
+    let ergodicIndex = 0
+    return async data => {
+      ergodicIndex++
+      let currErgodicIndex = ergodicIndex
+      self.postMessage({
+        incident: 'obsAddGeo'
+      })
+
+      for (let i = 0; i < data.tiles.length; i++) {
+        if (currErgodicIndex !== ergodicIndex) return;
+        let tile = data.tiles[i]
+        let { x, y, z } = tile
+        let features = await management.getFeatures(x, y, z)
+        if (currErgodicIndex !== ergodicIndex) return;
+        let { geoJsonArray, transArray } = featuresGrentAttribute(data.map, features)
+        self.postMessage({
+          incident: 'addGeo',
+          geoJsonArray
+        }, transArray)
+      }
+    }
+  })(),
+
+  clearFids: data => {
+    management.clearGeos(data.fids)
+  }
+}
+
+
+self.addEventListener('message', event => {
+  let data = event.data
+  if (typeof event.data === 'string') {
+    data = JSON.parse(event.data)
+  }
+  _interface[data.thing] && _interface[data.thing](data)
+})

.svn/pristine/9f/9fe1438bf26bf7dc7452767d52f3e18e94b17509.svn-base

@@ -0,0 +1,52 @@
+import { Map } from 'maptalks'
+import 'babel-core/register'
+import 'babel-polyfill'
+import './style/public.css'
+import Event from './core/Event'
+import { listStatus, analysis, mapGoto } from './business/statusManagement'
+import { singleDelay } from './core/util'
+import config from './business/config'
+import getTile from './business/selectTile'
+
+
+global.bus = new Event()
+
+let args = analysis()
+global.map = new Map('map', {
+  center: [args.lon, args.lat],
+  zoom: args.zoom,
+  bearing: args.bearing,
+  maxZoom: 19,
+  minZoom: 6,
+  maxPitch: 70,
+  maxVisualPitch: 100,
+  doubleClickZoom: false,
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  baseLayer: getTile(),
+})
+
+
+require('./business/initScene3D.js')
+
+// url状态
+let status = singleDelay(listStatus, 500)
+map.on('moving zoomend dragrotating', status);
+map.on('zoomend', args => {
+  if (args.to <= config.criticalZoom && args.from > config.criticalZoom) {
+    mapGoto({ pitch: 1, bearing: 7.5 }, 300)
+    bus.emit('uninstall3D')
+    bus.emit('install2D')
+  } else if (args.to > config.criticalZoom && args.from <= config.criticalZoom) {
+    bus.emit('uninstall2D')
+    bus.emit('install3D')
+    mapGoto({ pitch: 62, bearing: 90 }, 300)
+  }
+})
+
+if (args.zoom > config.criticalZoom) {
+  bus.emit('install3D')
+} else {
+  bus.emit('install2D')
+}

.svn/pristine/a0/a04a1b1166b61a1eafc32b52d9ee46347bd0f855.svn-base

@@ -0,0 +1,38 @@
+import { cuttingString } from './util'
+
+function average(aver, curr, index) {
+  aver[0] += curr[0]
+  aver[1] += curr[1]
+  if (index) {
+    aver[0] /= 2
+    aver[1] /= 2
+  }
+  return aver
+}
+
+
+function grentText(features) {
+  let texts = []
+
+  features.forEach(fe => {
+    if (fe.properties.name) {
+      let averagePoint = fe.geometry.coordinates.reduce((tPoint, geometry, index) => {
+        return average(
+          tPoint,
+          geometry.reduce(average, [0, 0]),
+          index
+        )
+      }, [0, 0])
+      let name = cuttingString(fe.properties.name, 15)
+      texts.push({
+        name: name.join('\n'),
+        point: averagePoint,
+        height: fe.height + 3 * name.length + 5 
+      })
+    }
+  })
+
+  return texts
+}
+
+export default grentText

.svn/pristine/a1/a10a9ab94dcea02cc818912a5a4d4e53f7b1cac6.svn-base

@@ -0,0 +1,117 @@
+import 'babel-core/register'
+import 'babel-polyfill'
+import featuresToPolygon from './featuresToPolygon'
+import config from '../business/config'
+import * as management from './dataManagement'
+import grentText from './grentText'
+import { mergeBigData, getMaxHeight, grentAnimationArray, extractType, fromGeometry } from './util'
+import { toExtrudeGeometry, reductive } from './PolygonToGeom'
+
+
+function featureToAttribute(map, features, stepTotal) {
+  let polygons = featuresToPolygon(features)
+  let verticesArray = []
+  let normalsArray = []
+
+  polygons.forEach((polygon, index) => {
+    let height = features[index].properties.height 
+      || features[index].properties.levels * config.levelHeight
+      || config.defaultHeight
+
+    let geo = toExtrudeGeometry(polygon, map, height)
+
+    if (!geo) return;
+
+    features[index].height = height
+    let { vertices, normals } = fromGeometry(geo)
+    verticesArray.push(vertices)
+    normalsArray.push(normals)
+  })
+
+  verticesArray = mergeBigData(verticesArray)
+  normalsArray = mergeBigData(normalsArray)
+
+  let maxHeight = getMaxHeight(verticesArray)
+  let animateBuffArrays = grentAnimationArray(verticesArray, stepTotal, maxHeight)
+
+  return {
+    verticesBuffArrays: verticesArray,
+    normalsBuffArrays: normalsArray,
+    maxHeight,
+    animateBuffArrays
+  }
+}
+
+function featuresGrentAttribute(map, features) {
+  let { typeFeatures, types } = extractType(features)
+  let geoJsonArray = []
+
+  reductive(map)
+
+  typeFeatures.forEach((features, index) => {
+    if (features.length) {
+      geoJsonArray.push({
+        ...featureToAttribute(map, features, config.stepTotal),
+        texts: grentText(features),
+        fids: features.map(f => f.id),
+        type: index === 0 ? 'unknown' : types[index - 1]
+      })
+    }
+  })
+  
+  let transArray = []
+  geoJsonArray.forEach(geo => {
+    transArray.push(
+      geo.verticesBuffArrays.buffer,
+      geo.normalsBuffArrays.buffer,
+      geo.animateBuffArrays.buffer
+    )
+  })
+
+  return {
+    geoJsonArray,
+    transArray
+  }
+}
+
+
+let _interface = {
+  getGeo: (function () {
+    let ergodicIndex = 0
+    return data => {
+      ergodicIndex++
+      let currErgodicIndex = ergodicIndex
+      self.postMessage({
+        incident: 'obsAddGeo'
+      })
+
+      for (let i = 0; i < data.tiles.length; i++) {
+        if (currErgodicIndex !== ergodicIndex) return;
+        let tile = data.tiles[i]
+        let { x, y, z } = tile
+        management.getFeatures(x, y, z)
+          .then(features => {
+            if (currErgodicIndex !== ergodicIndex) return;
+            let { geoJsonArray, transArray } = featuresGrentAttribute(data.map, features)
+            self.postMessage({
+              incident: 'addGeo',
+              geoJsonArray
+            }, transArray)
+          })
+      }
+    }
+  })(),
+
+  clearFids: data => {
+    management.clearGeos(data.fids)
+  }
+}
+
+
+self.addEventListener('message', event => {
+  let data = event.data
+  if (typeof event.data === 'string') {
+    data = JSON.parse(event.data)
+  }
+  _interface[data.thing] && _interface[data.thing](data)
+})

.svn/pristine/af/af5e07e97c2ef269b147398ed77a7f02de9639e8.svn-base

@@ -0,0 +1,123 @@
+import reveal from '../core/reveal'
+import * as THREE from 'three'
+import { animation, init } from './meshAnimation'
+import config from './config'
+import FeaturesToAttribute from '../worker/featuresToAttribute.worker'
+import Event from '../core/Event'
+import {clearFids} from '../core/dyWoker'
+
+const worker = new FeaturesToAttribute()
+const cache = reveal.cache
+const frustum = new THREE.Frustum();
+const cameraViewProjectionMatrix = new THREE.Matrix4();
+const hideMeshs = []
+const $event = new Event()
+
+
+worker.addEventListener('message', listener)
+
+function listener(event) {
+  $event.emit(
+    event.data.incident,
+    event.data.animationArray
+  )
+}
+
+const showMesh = function() {
+  let IN_ID = 0
+
+  return function showMesh(mesh, index) {
+    if (mesh.visible) return;
+
+    let incident = 'grentAnimation' + (IN_ID++)
+    let verticesArray = mesh.geometry.attributes.position.array;
+    let postObj = {
+      thing: 'grentAnimationArray',
+      verticesBuffArrays: verticesArray,
+      maxHeight: mesh.maxHeight,
+      incident
+    }
+
+    worker.postMessage(postObj)
+
+    $event.once(incident, animationArray => {
+      init(mesh.geometry.attributes.position.array, mesh.maxHeight)
+      setTimeout(() => {
+        mesh.visible = true
+        animation(mesh, verticesArray, animationArray, config.stepTotal)
+      }, 300)
+      threeLayer.renderScene()
+    })
+  }
+}();
+
+function hideMesh(mesh, index) {
+  mesh.visible = false
+  threeLayer.renderScene()
+}
+
+
+function meshStatus_() {
+  const camera = threeLayer.getCamera();
+  camera.updateMatrixWorld();
+  camera.matrixWorldInverse.getInverse(camera.matrixWorld);
+  cameraViewProjectionMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+  frustum.setFromMatrix(cameraViewProjectionMatrix);
+
+  for (let url in cache) {
+    let meshs = cache[url]
+    if (!Array.isArray(meshs)) continue;
+
+    for (let i = 0; i < meshs.length; i++) {
+      let mesh = meshs[i]
+      let index = hideMeshs.indexOf(mesh)
+      let viewMesh = frustum.intersectsObject(mesh)
+
+      if (viewMesh) {
+        mesh.hideCount = 0
+      } else {
+        mesh.hideCount = (mesh.hideCount || 0) + 1;
+      }
+
+      if (viewMesh && ~index) {
+        showMesh(mesh, index)
+        hideMeshs.splice(index, 1)
+      } else if (!viewMesh && !~index) {
+        if (mesh.visible && mesh.hideCount >= 30) {
+          hideMesh(mesh, index)
+          hideMeshs.push(mesh)
+        }
+      }
+
+      if (mesh.hideCount > 300) {
+        threeLayer.getScene().remove(mesh)
+        reveal.eliminate(url);
+        break;
+      }
+    }
+  }
+}
+
+
+function meshStatus() {
+  const camera = threeLayer.getCamera();
+  camera.updateMatrixWorld();
+  camera.matrixWorldInverse.getInverse(camera.matrixWorld);
+  cameraViewProjectionMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+  frustum.setFromMatrix(cameraViewProjectionMatrix);
+  let scene = threeLayer.getScene()
+  let children = scene.children
+  children.forEach(m => {
+    if (m.type === 'Mesh') {
+      let viewMesh = frustum.intersectsObject(m)
+      if (!viewMesh) {
+        scene.remove(m)
+        m.isRemove = true
+        vector.removeGeometry(m.texts)
+        clearFids(m.fids)
+      }
+    }
+  })
+}
+
+export default meshStatus

.svn/pristine/b6/b65be6c9f9674e0172f0d82e0791e99c385eea37.svn-base

@@ -0,0 +1,84 @@
+function init(verticesArray, maxHeight) {
+  let len = verticesArray.length
+
+  for (let i = 0; i < len; i += 3) {
+    verticesArray[i + 2] = maxHeight
+  }
+}
+
+function singleAnimation (mesh, verticesArray, animateBuffArrays, stepTotal) {
+  let len = verticesArray.length
+  let pollIndex = 0;
+
+  return function () {
+    if (!mesh.visible) {
+      pollIndex = stepTotal - 1
+    }
+
+    for (let i = 0, index = 0; i < len; i += 3, index++) {
+      let Indexes = index * stepTotal + pollIndex
+      verticesArray[i + 2] = animateBuffArrays[Indexes]
+    }
+
+    pollIndex++
+    
+    if (mesh.isRemove) {
+      return true
+    } else if (pollIndex < stepTotal) {
+      mesh.geometry.attributes.position.needsUpdate = true;
+      return false
+    } else {
+      return true
+    }
+  }
+}
+
+
+const animation = (() => {
+  let taskStore = []
+  let runing = false
+  let pause = false
+
+  return function (...args) {
+    taskStore.push(singleAnimation(...args))
+    if (runing) return
+    runing = true;
+
+    // bus.off('addGeoing')
+    // bus.off('addGeoEnd')
+
+    // bus.on('addGeoing', () => {
+    //   pause = true
+    // })
+
+    // bus.on('addGeoEnd', () => {
+    //   pause = false
+    //   frame();
+    // })
+
+    function frame() {
+      requestAnimationFrame(() => {
+        for (let i = 0; i < taskStore.length; i++) {
+          if (taskStore[i]()) {
+            taskStore.splice(i, 1)
+            i--
+          }
+        }
+        threeLayer.renderScene()
+        if (taskStore.length === 0) {
+          runing = false
+        } else if (!pause){
+          frame();
+        }
+      })
+    }
+
+    frame();
+  }
+})()
+
+
+export {
+  animation,
+  init
+}

.svn/pristine/b6/b6f88988de790295fe3287962ea60c0330f940f1.svn-base

@@ -0,0 +1,137 @@
+import { Marker, Coordinate } from 'maptalks'
+import { mapGoto } from './statusManagement'
+import { threeLayer, vector } from './initScene3D'
+
+function structText(args) {
+  var point = new Marker(args.point,
+    {
+      properties: {
+        altitude: args.top
+      },
+      visible: true,
+      editable: true,
+      cursor: 'pointer',
+      shadowBlur: 0,
+      shadowColor: 'black',
+      draggable: false,
+      dragShadow: false, // display a shadow during dragging
+      drawOnAxis: null,  // force dragging stick on a axis, can be: x, y
+      symbol: {
+        'textFaceName': 'sans-serif',
+        'textName': args.name,
+        'textFill': '#000000',
+        'textHaloFill': '#fff',
+        'textHaloRadius': 2,
+        'textHorizontalAlignment': 'center',
+        'textVerticalAlignment': 'top',
+        'textSize': 12
+      }
+    }
+  );
+  point.on('click', () => {
+    mapGoto({ center: args.point, zoom: 19 })
+  })
+  point.__id = args.id
+  return point
+}
+
+function addToAttr(args) {
+  var point = new Coordinate(args.point),
+    containerPoint  = map.coordinateToContainerPoint(point).round();
+
+  args.position = [
+    Number(containerPoint.x),
+    Number(containerPoint.y)
+  ]
+}
+
+
+function checkIsAdd(texts, args) {
+  addToAttr(args)
+
+  let tMinX = args.position[0] - args.width / 2
+  let tMaxX = args.position[0] + args.width / 2
+  let tMinY = args.position[1]
+  let tMaxY = args.position[1] + args.height
+
+  let index = texts.findIndex(text => {
+    let minX = text._struct_attribute.position[0] - text._struct_attribute.width / 2
+    let minY = text._struct_attribute.position[1]
+    let maxX = text._struct_attribute.position[0] + text._struct_attribute.width / 2
+    let maxY = text._struct_attribute.position[1] + text._struct_attribute.height
+
+    return !(
+      (tMinX < minX && tMaxX < minX) || 
+      (tMinX > maxX && tMaxX > maxX) || 
+      (tMinY < minY && tMaxY < minY) || 
+      (tMinY > maxY && tMaxY > maxY)
+    )
+  })
+  
+  return !~index
+}
+
+
+function addText(mesh, textjsons) {
+  if (textjsons.length === 0) return;
+  let children = threeLayer.getScene().children
+  let texts = []
+  let newTexts = []
+
+  children.forEach(mesh => {
+    mesh.texts && texts.push(...mesh.texts)
+  })
+
+  textjsons.forEach(item => {
+    if (checkIsAdd(texts, item)) {
+      let text = structText(item)
+      newTexts.push(text)
+      text._struct_attribute = item
+      texts.push(text)
+    }
+  })
+
+  vector.addGeometry(newTexts)
+  mesh.texts = newTexts
+  mesh.textjsons = textjsons
+}
+
+
+
+function referText() {
+  let children = threeLayer.getScene().children
+  let checkTexts = []
+  
+  children.forEach(mesh => {
+    
+    if (mesh.texts) {
+      for (let i = 0; i < mesh.texts.length; i++) {
+        let text = mesh.texts[i]
+        if (checkIsAdd(checkTexts, text._struct_attribute)) {
+          checkTexts.push(text)
+        } else {
+          vector.removeGeometry(text)
+          mesh.texts.splice(i, 1)
+          --i
+        }
+      }
+    }
+    
+    
+    if (mesh.textjsons) {
+      mesh.textjsons.map(item => {
+        let index = mesh.texts.findIndex(text => text.__id === item.id)
+        if (!~index && checkIsAdd(checkTexts, item)) {
+          let text = structText(item)
+          checkTexts.push(text)
+          text._struct_attribute = item
+          vector.addGeometry(text)
+          mesh.texts.push(text)
+        }
+      })
+    }
+  })
+}
+
+export { referText }
+export default addText

.svn/pristine/b7/b752bb5e458949b0dd2ba20c3e1664de8756b44f.svn-base

@@ -0,0 +1,64 @@
+import { TileLayer } from 'maptalks'
+
+let tiles = [
+  new TileLayer('base', {
+    'offset': [100000, 10000],
+    'urlTemplate': function(x, y, z, domain) {
+      for (var a = "", c = x, d = y, e = 0; e < z; e++) {
+        a = ((c & 1) + 2 * (d & 1)).toString() + a;
+        c >>= 1;
+        d >>= 1
+      }
+      return 'http://dynamic.t'+domain+'.tiles.ditu.live.com/comp/ch/' + a + '?it=G,VE,BX,L,LA&mkt=zh-cn,syr&n=z&og=111&ur=CN&cstl=w4c'
+    },
+    'subdomains': ['0', '1', '2', '3']
+  }),
+  new TileLayer('base', {
+    'urlTemplate': 'https://tileserver.memomaps.de/tilegen/{z}/{x}/{y}.png',
+    'subdomains': ['a', 'b', 'c']
+  }),
+  new TileLayer('base', {
+    'urlTemplate': 'http://{s}.tile.stamen.com/watercolor/{z}/{x}/{y}.png',
+    'subdomains': ['a', 'b', 'c']
+  }),
+  new TileLayer('base', {
+    'urlTemplate': 'http://{s}.tiles.wmflabs.org/hikebike/{z}/{x}/{y}.png',
+    'subdomains': ['a', 'b', 'c']
+  }),
+
+  new TileLayer('base', {
+    'urlTemplate': 'http://{s}.tile.osm.org/{z}/{x}/{y}.png',
+    'subdomains': ['a', 'b', 'c']
+  }),
+  new TileLayer('Carto light', {
+    'urlTemplate': 'http://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png',
+    'subdomains': ['a', 'b', 'c', 'd']
+  }),
+  new TileLayer('Carto dark', {
+    'urlTemplate': 'http://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png',
+    'subdomains': ['a', 'b', 'c', 'd']
+  }),
+  new TileLayer('base', {
+    spatialReference: {
+      projection: 'EPSG:3857'
+    },
+    urlTemplate: 'http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
+    subdomains: ['a', 'b', 'c'],
+    attribution: '&copy; <a href="http://www.osm.org" target="_blank">OpenStreetMap</a> contributors'
+  })
+]
+let index = localStorage.getItem('theme') || 1
+
+let theme = document.querySelector('#theme')
+
+theme.innerHTML = tiles.map((t, i) => `<option value="${i}">主题${i+1}</option>`).join('')
+theme.value = index
+
+theme.addEventListener('change', () => {
+  localStorage.setItem('theme', theme.value)
+  location.reload()
+})
+
+export default () => {
+  return tiles[index]
+}

.svn/pristine/b7/b7c022ed129ac9055cfa34b3a43d003595705044.svn-base

@@ -0,0 +1,121 @@
+import axios from 'axios'
+import * as db from '../core/db'
+import ReqEvent from '../core/Event'
+
+const store = {}
+const geos = []
+
+const getData = (() => {
+  let joinKeys = []
+  let urlTemplate = 'https://{s}.data.osmbuildings.org/0.2/anonymous/tile/{z}/{x}/{y}.json'
+  let subdomains = ['a', 'b', 'c', 'd']
+  let index = 0
+  let requestings = []
+  let event = new ReqEvent()
+
+  async function ajaxGetData(key, url) {
+    let index = requestings.indexOf(key)
+    if (~index) {
+      return new Promise((resolve, reject) => {
+        event.once(key, (data, error) => {
+          if (error) {
+            reject(error)
+          } else {
+            data.data && (data.data.__once = false)
+            resolve(data)
+          }
+        })
+      })
+    } else {
+      requestings.push(key)
+
+      function result(res, err) {
+        if (err) {
+          event.emit(key, null, res)
+        } else {
+          event.emit(key, res)
+          res.data && (res.data.__once = true)
+        }
+        let index = requestings.indexOf(key)
+        requestings.splice(index, 1)
+        return res
+      }
+
+      return axios.get(url).then(res => result(res)).catch(res => result(res, 1))
+    }
+  }
+
+  function getSubdomain() {
+    index === subdomains.length && (index = 0)
+    return subdomains[index++]
+  }
+
+  function storeCtrl(key, data) {
+    db.add({id: key, ...data})
+    store[key] = data
+  }
+
+  function obtain(key) {
+    let index = joinKeys.indexOf(key)
+    joinKeys.splice(index, 1)
+    joinKeys.push(key)
+  }
+
+  async function getData(x, y, z) {
+    let key = `${x}-${y}-${z}`
+    let url = urlTemplate
+      .replace('{s}', getSubdomain())
+      .replace('{x}', x)
+      .replace('{y}', y)
+      .replace('{z}', z)
+
+    let obj = await db.get(key)
+
+    if (obj) {
+      return obj
+    } else {
+      let data = await ajaxGetData(key, url).then(res => res.data)
+      if (data.__once) {
+        storeCtrl(key, data)
+      }
+      return data
+    }
+  }
+
+  return getData
+})();
+
+function filter(features) {
+  let result = []
+
+  features.forEach(item => {
+    if (!~geos.indexOf(item.id)) {
+      geos.push(item.id)
+      result.push(item)
+    }
+  })
+
+  return result
+}
+
+async function getFeatures(x, y, z) {
+  
+  let data = await getData(x, y, z)
+  let features = data.features ? filter(data.features) : []
+
+  return features
+}
+
+function clearGeos (ids) {
+  ids.forEach(id => {
+    let index = geos.indexOf(id)
+    if (~index) {
+      geos.splice(index, 1)
+    }
+  })
+}
+
+export {
+  getFeatures,
+  clearGeos
+}

.svn/pristine/b8/b81158edf62198004326b13fb88c3c028bcc1869.svn-base

@@ -0,0 +1,51 @@
+
+function analysis () {
+  let result = {}
+  let args = location.search.substr(1)
+  args = args.split('&')
+  args.forEach(arg => {
+    let index = arg.indexOf('=')
+    if (~index) {
+      result[arg.substring(0, index)] = Number(arg.substr(index + 1))
+    }
+  })
+
+  if (!result.lat || !result.lon) {
+    result.lat = 22.252832648721693
+    result.lon = 113.57727389730132
+  }
+
+  result.zoom = result.zoom || 15
+  result.pitch = result.pitch || 60
+  result.bearing = result.bearing || 60
+  return result
+}
+
+let listStatus = (() => {
+  let args = analysis()
+  return function () {
+    let result = []
+    let center = map.getCenter()
+    args.lon = center.x
+    args.lat = center.y
+    args.zoom = map.getZoom()
+    args.pitch = map.getPitch()
+    args.bearing = map.getBearing()
+
+    for (let key in args) {
+      result.push(`${key}=${args[key]}`)
+    }
+
+
+    let url = location.pathname + '?' + result.join('&')
+    history.pushState({
+      url, 
+      title: document.title 
+    }, document.title, url)
+  }
+})()
+
+export {
+  analysis, 
+  listStatus
+}

.svn/pristine/b8/b854f630198fd5e4319b8f89e08b8eb35a485ccd.svn-base

@@ -0,0 +1,128 @@
+const DB = {
+  name: 'mapDB',
+  version: 1,
+  objName: 'mapAnimationData',
+  fidName: 'fidsData'
+}
+
+
+function getDB () {
+  return new Promise((resolve, reject) => {
+    if (DB.db) {
+      resolve(DB.db)
+    } else {
+      let request = indexedDB.open(DB.name, DB.version)
+      
+      request.onsuccess = e => {
+        DB.db = e.target.result
+        resolve(DB.db)
+      }
+
+      request.onerror = reject
+
+      request.onupgradeneeded = e => {
+        console.log(`${DB.name} versiton changed to ${DB.version}`)
+        initDB(e.target.result)
+      }
+    }
+  })
+}
+
+function close () {
+  if (DB.db) {
+    DB.db.close()
+  }
+}
+
+function deleteDB () {
+  indexedDB.deleteDatabase(DB.name)
+}
+
+function initDB (db) {
+  let objectStore = db.createObjectStore(DB.objName, {
+    keyPath: 'id',
+    autoIncrement: true
+  })
+  
+  objectStore.createIndex('id', 'id', {unique: true})
+  objectStore.createIndex('type', 'type');
+  objectStore.createIndex('features', 'features');
+
+  objectStore = db.createObjectStore(DB.fidName, {
+    keyPath: 'id',
+    autoIncrement: true
+  })
+  objectStore.createIndex('fid', 'fids')
+}
+
+async function update (newItem, tab = DB.objName) {
+  let request = (await getDB())
+    .transaction([tab], "readwrite")
+    .objectStore(tab)
+    .put(newItem)
+
+  return new Promise((resolve, reject) => {
+    request.onsuccess = e => resolve(e.target.result)
+    request.onerror = reject
+  })
+}
+
+async function add (newItem, tab = DB.objName) {
+  let request = (await getDB())
+    .transaction([tab], "readwrite")
+    .objectStore(tab)
+    .add(newItem)
+  
+  return new Promise((resolve, reject) => {
+    request.onsuccess = e => resolve(e.target.result)
+    request.onerror = reject
+  })
+}
+
+async function get(id, tab = DB.objName) {
+  let request = (await getDB())
+    .transaction([tab])
+    .objectStore(tab)
+    .get(id)
+
+  return new Promise((resolve, reject) => {
+    request.onsuccess = e => {
+      if (request.result) {
+        resolve(request.result)
+      } else {
+        resolve()
+      }
+    }
+
+    request.onerror = e => {
+      reject
+    }
+  })
+
+}
+
+async function clear(tab = DB.objName) {
+  let request = (await getDB())
+    .transaction([tab], 'readwrite')
+    .objectStore(tab)
+    .clear()
+
+  return new Promise((resolve, reject) => {
+    request.onsuccess = resolve
+    request.onerror = reject
+  })
+}
+
+
+
+clear(DB.fidName).then(resolve => {
+  add({id: 1, fids: []}, DB.fidName)
+})
+
+
+export {
+  get,
+  add,
+  update,
+  clear
+}

.svn/pristine/b9/b9da6dcea0df4fa3a56c82014458378e055031eb.svn-base

@@ -0,0 +1,6 @@
+{
+  "presets": [
+    "es2015",
+    "stage-0"
+  ]
+}

.svn/pristine/ba/ba467acd7b39894d16f02fd49528c4c9e84c0a4b.svn-base

@@ -0,0 +1,68 @@
+const webpack = require('webpack')
+const path = require('path')
+const HtmlWebpackPlugin = require('html-webpack-plugin')
+
+const config =
+{
+  output: {
+    path: path.join(__dirname, 'dist'),
+    filename: 'bundle.js',
+    globalObject: 'this'
+  },
+  module: {
+    rules: [
+      {
+        test: /\.worker\.js$/, //以.worker.js结尾的文件将被worker-loader加载
+        use: { loader: 'worker-loader' }
+      },
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        use: {
+          loader: 'babel-loader'
+        }
+      },
+      {
+        test: /\.css$/,
+        use: [
+          {loader: 'style-loader'},
+          {loader: 'css-loader'},
+          {
+            loader: 'postcss-loader',
+            options: {
+              plugins: [require('autoprefixer')]
+            }
+          }
+        ]
+      },
+      {
+        test: /\.(png|jpg|gif|woff|eot|ttf|svg)$/,
+        use: {
+          loader: 'url-loader',
+          options: {
+            limit: 8192,
+            name: "assets/[name].[ext]"
+          }
+        }
+      }
+    ]
+  },
+  plugins: [
+    new webpack.HotModuleReplacementPlugin(),
+    new HtmlWebpackPlugin({
+      template: path.join(__dirname, 'src/index.html'),
+      minify: {
+        removeComments: false,
+        collapseWhitespace: false
+      }
+    })
+  ]
+  // ,
+  // devServer: {
+  //   contentBase: path.join(__dirname, "dist"),
+  //   port: 8000,
+  //   hot: true
+  // }
+}
+
+module.exports = config

.svn/pristine/ba/bae1806c27510f2a40780b9a75aa4b90e465fc72.svn-base

@@ -0,0 +1,135 @@
+import * as THREE from 'three'
+
+const defaultMaterial = new THREE.MeshLambertMaterial({
+  color: 0xffffff,
+  reflectivity: 0.8,
+  emissive: 0xffffff,
+  emissiveIntensity: 0.5,
+  wireframe: false,
+  flatShading: true
+});
+
+let materials = {
+  // 贸易大厦
+  commercial: new THREE.MeshLambertMaterial({
+    color: 0xc1e8e4,
+    reflectivity: 0.8,
+    emissive: 0xc1e8e4,
+    emissiveIntensity: 0.5,
+    wireframe: false,
+    flatShading: true
+  }),
+  // 屋顶
+  roof: new THREE.MeshLambertMaterial({
+    color: 0xdbc315,
+    reflectivity: 0.8,
+    emissive: 0xdbc315,
+    emissiveIntensity: 0.5,
+    wireframe: false,
+    flatShading: true
+  }),
+  // 商业
+  commercial: new THREE.MeshLambertMaterial({
+    color: 0xcc6f3e,
+    reflectivity: 0.8,
+    emissive: 0xcc6f3e,
+    emissiveIntensity: 0.5,
+    wireframe: false,
+    flatShading: true
+  }),
+  // 零售业
+  retail: new THREE.MeshLambertMaterial({
+    color: 0xaeaaa3,
+    reflectivity: 0.8,
+    emissive: 0xaeaaa3,
+    emissiveIntensity: 0.5,
+    wireframe: false,
+    flatShading: true
+  }),
+  // 公寓
+  apartments: new THREE.MeshLambertMaterial({
+    color: 0xba673a,
+    reflectivity: 0.8,
+    emissive: 0xba673a,
+    emissiveIntensity: 0.5,
+    wireframe: false,
+    flatShading: true
+  }),
+  // 住宅区
+  residential: new THREE.MeshLambertMaterial({
+    color: 0xba673a,
+    reflectivity: 0.8,
+    emissive: 0xba673a,
+    emissiveIntensity: 0.5,
+    wireframe: false,
+    flatShading: true
+  }),
+  // 温室
+  greenhouse: new THREE.MeshLambertMaterial({
+    color: 0x750000,
+    reflectivity: 0.8,
+    emissive: 0x750000,
+    emissiveIntensity: 0.5,
+    wireframe: false,
+    flatShading: true
+  }),
+  // 医院
+  hospital: new THREE.MeshLambertMaterial({
+    color: 0xbc6067,
+    reflectivity: 0.8,
+    emissive: 0xbc6067,
+    emissiveIntensity: 0.5,
+    wireframe: false,
+    flatShading: true
+  }),
+  // 桥
+  bridge: new THREE.MeshLambertMaterial({
+    color: 0x3f3f3e,
+    reflectivity: 0.8,
+    emissive: 0x3f3f3e,
+    emissiveIntensity: 0.5, 
+    wireframe: false,
+    flatShading: true
+  }),
+  // 火车站
+  train_station: new THREE.MeshLambertMaterial({
+    color: 0x896343,
+    reflectivity: 0.8,
+    emissive: 0x896343,
+    emissiveIntensity: 0.5,
+    wireframe: false,
+    flatShading: true
+  }),
+  // 学校
+  school: new THREE.MeshLambertMaterial({
+    color: 0x668142,
+    reflectivity: 0.8,
+    emissive: 0x668142,
+    emissiveIntensity: 0.5,
+    wireframe: false,
+    flatShading: true
+  }),
+  // 建设中
+  construction: new THREE.MeshLambertMaterial({
+    color: 0xe6cb00,
+    reflectivity: 0.8,
+    emissive: 0xe6cb00,
+    emissiveIntensity: 0.5,
+    wireframe: false,
+    flatShading: true
+  }),
+}
+
+
+
+
+
+function grentMesh(geometry, type) {
+  console.log(type)
+  let mesh = new THREE.Mesh(geometry, materials[type] || defaultMaterial)
+  mesh.castShadow = true; 
+  mesh.receiveShadow = true;
+  return mesh
+}
+
+export default grentMesh

.svn/pristine/bb/bbee0ba341ce21ba68c40e6cde66e46d2713cd97.svn-base

@@ -0,0 +1,39 @@
+import * as THREE from 'three'
+import { animation, init } from './meshAnimation'
+import grentMesh from './grentMesh'
+import config from './config'
+import addText from '../business/addText'
+
+
+
+
+async function listener(event) {
+  let geoJsonArray = event.data.geoJsonArray
+  geoJsonArray.forEach(j => {
+    let {
+      maxHeight,
+      animateBuffArrays,
+      fids,
+      verticesBuffArrays: verticesArray,
+      normalsBuffArrays: normalsArray,
+      type,
+      texts
+    } = j
+
+    let geometry = new THREE.BufferGeometry()
+    geometry.addAttribute('position', new THREE.BufferAttribute(verticesArray, 3));
+    geometry.addAttribute('normal', new THREE.BufferAttribute(normalsArray, 3));
+
+    var mesh = grentMesh(geometry, type);
+    threeLayer.getScene().add(mesh)
+    mesh.maxHeight = maxHeight
+    mesh.fids = fids
+
+    init(verticesArray, maxHeight)
+    animation(mesh, verticesArray, animateBuffArrays, config.stepTotal)
+
+    addText(mesh, texts)
+  })
+}
+
+export default listener

.svn/pristine/bd/bd083f705488cdc8aa5b6af1a7ed81e40cbdee5e.svn-base

@@ -0,0 +1,65 @@
+
+function analysis () {
+  let result = {}
+  let args = location.search.substr(1)
+  args = args.split('&')
+  args.forEach(arg => {
+    let index = arg.indexOf('=')
+    if (~index) {
+      result[arg.substring(0, index)] = Number(arg.substr(index + 1))
+    }
+  })
+
+  if (!result.lat || !result.lon) {
+    result.lat = 22.252832648721693
+    result.lon = 113.57727389730132
+  }
+
+  result.zoom = result.zoom || 15
+  result.pitch = result.pitch || 60
+  result.bearing = result.bearing || 60
+  return result
+}
+
+let listStatus = (() => {
+  let args = analysis()
+  return function () {
+    let result = []
+    let center = map.getCenter()
+    args.lon = center.x
+    args.lat = center.y
+    args.zoom = map.getZoom()
+    args.pitch = map.getPitch()
+    args.bearing = map.getBearing()
+
+    for (let key in args) {
+      result.push(`${key}=${args[key]}`)
+    }
+
+
+    let url = location.pathname + '?' + result.join('&')
+    history.pushState({
+      url, 
+      title: document.title 
+    }, document.title, url)
+  }
+})()
+
+
+function mapGoto(args) {
+  // map.animateTo({
+  //   center: [(map.getCenter().x + args.center[0]) / 2,
+  //   (map.getCenter().y + args.center[1]) / 2],
+  //   zoom: 15
+  // }, {duration: 2000});
+
+  // setTimeout(() => {
+    map.animateTo(args, {duration: 1000});
+  // }, 2000)
+}
+
+export {
+  mapGoto,
+  analysis, 
+  listStatus
+}

.svn/pristine/c0/c05f975cce168b9aaa67f9b844936de842f24453.svn-base

@@ -0,0 +1,35 @@
+* {
+  margin: 0;
+  padding: 0;
+}
+
+html {
+  --width: 100%;
+  --height: 100%;
+}
+html, body {
+  width: var(--width);
+  height: var(--height)
+}
+#map {
+  width: var(--width);
+  height: calc(var(--height));
+  overflow: hidden;
+}
+
+#test {
+  width: var(--width);
+  height: calc(var(--height) / 2);
+  overflow: hidden;
+}
+
+#map {
+  background: #ccc;
+}
+
+.point {
+  width: 150px;
+  font-size: 12px;
+  text-align: center;
+  margin-bottom: 10px;
+}

.svn/pristine/c1/c1b30988fcef0c93d77df89f5244cc88852266f7.svn-base

@@ -0,0 +1,122 @@
+import axios from 'axios'
+import * as db from '../core/db'
+import ReqEvent from '../core/Event'
+
+const store = {}
+const geos = []
+
+const getData = (() => {
+  let joinKeys = []
+  let urlTemplate = 'https://{s}.data.osmbuildings.org/0.2/anonymous/tile/{z}/{x}/{y}.json'
+  let subdomains = ['a', 'b', 'c', 'd']
+  let index = 0
+  let requestings = []
+  let event = new ReqEvent()
+
+  async function ajaxGetData(key, url) {
+    console.log('get', url)
+    let index = requestings.indexOf(key)
+    if (~index) {
+      return new Promise((resolve, reject) => {
+        event.once(key, (data, error) => {
+          if (error) {
+            reject(error)
+          } else {
+            data.data && (data.data.__once = false)
+            resolve(data)
+          }
+        })
+      })
+    } else {
+      requestings.push(key)
+
+      function result(res, err) {
+        if (err) {
+          event.emit(key, null, res)
+        } else {
+          event.emit(key, res)
+          res.data && (res.data.__once = true)
+        }
+        let index = requestings.indexOf(key)
+        requestings.splice(index, 1)
+        return res
+      }
+
+      return axios.get(url).then(res => result(res)).catch(res => result(res, 1))
+    }
+  }
+
+  function getSubdomain() {
+    index === subdomains.length && (index = 0)
+    return subdomains[index++]
+  }
+
+  function storeCtrl(key, data) {
+    db.add({id: key, ...data})
+    store[key] = data
+  }
+
+  function obtain(key) {
+    let index = joinKeys.indexOf(key)
+    joinKeys.splice(index, 1)
+    joinKeys.push(key)
+  }
+
+  async function getData(x, y, z) {
+    let key = `${x}-${y}-${z}`
+    let url = urlTemplate
+      .replace('{s}', getSubdomain())
+      .replace('{x}', x)
+      .replace('{y}', y)
+      .replace('{z}', z)
+
+    let obj = await db.get(key)
+
+    if (obj) {
+      return obj
+    } else {
+      let data = await ajaxGetData(key, url).then(res => res.data)
+      if (data && data.__once) {
+        storeCtrl(key, data)
+      }
+      return data
+    }
+  }
+
+  return getData
+})();
+
+function filter(features) {
+  let result = []
+
+  features.forEach(item => {
+    if (!~geos.indexOf(item.id)) {
+      geos.push(item.id)
+      result.push(item)
+    }
+  })
+
+  return result
+}
+
+async function getFeatures(x, y, z) {
+  
+  let data = await getData(x, y, z)
+  let features = data && data.features ? filter(data.features) : []
+
+  return features
+}
+
+function clearGeos (ids) {
+  ids.forEach(id => {
+    let index = geos.indexOf(id)
+    if (~index) {
+      geos.splice(index, 1)
+    }
+  })
+}
+
+export {
+  getFeatures,
+  clearGeos
+}

.svn/pristine/c2/c2e59c133f0606eef9b630980473864c24436b6a.svn-base

@@ -0,0 +1,134 @@
+function mergeBigData(datas) {
+  let index = 0
+  let len = datas.reduce((p, c) => p + c.length, 0)
+  let v3 = new Float32Array(len * 3)
+
+  datas.forEach(data => {
+    let length = data.length
+    for (let i = 0; i < length; i++) {
+      v3[index] = data[i].x
+      v3[index + 1] = data[i].y
+      v3[index + 2] = data[i].z
+      index += 3
+    }
+  })
+
+  return v3
+}
+
+function getMaxHeight(verticesBuffArrays) {
+  let maxHeight = verticesBuffArrays[2]
+  let len = verticesBuffArrays.length
+
+  for (let i = 3; i < len; i += 3) {
+    if (maxHeight < verticesBuffArrays[i + 2]) {
+      maxHeight = verticesBuffArrays[i + 2]
+    }
+  }
+
+  return maxHeight
+}
+
+function grentAnimationArray(verticesBuffArrays, stepTotal, maxHeight) {
+  let len = verticesBuffArrays.length
+  let animateBuffArrays = new Float32Array(
+    (len / 3) * stepTotal
+  )
+
+  for (let i = 0, index = 0; i < len; i += 3, index++) {
+    let indexes = index * stepTotal
+    let origin = verticesBuffArrays[i + 2]
+    let average = (maxHeight - origin) / stepTotal
+    for (let j = 1; j < stepTotal + 1; j++) {
+      animateBuffArrays[indexes + j - 1] = maxHeight - (j * average)
+    }
+  }
+
+  return animateBuffArrays
+}
+
+
+function extractType(features) {
+  let types = []
+  let typeFeatures = [[]]
+
+  features.forEach(f => {
+    if (f.properties && f.properties.type) {
+      let index = types.indexOf(f.properties.type)
+      // index = 0
+      if (~index) {
+        typeFeatures[index + 1].push(f)
+      } else {
+        types.push(f.properties.type)
+        typeFeatures[types.length] = [f]
+      }
+    } else {
+      typeFeatures[0].push(f)
+    }
+  })
+
+  return {
+    typeFeatures,
+    types
+  }
+}
+
+
+
+function fromGeometry(geometry) {
+
+  var faces = geometry.faces;
+  var vertices = geometry.vertices;
+
+  if (vertices.length > 0 && faces.length === 0) {
+
+    console.error('THREE.DirectGeometry: Faceless geometries are not supported.');
+
+  }
+
+  var _vertices = [],
+    _normals = [];
+
+  for (var i = 0; i < faces.length; i++) {
+
+    var face = faces[i];
+
+    _vertices.push(vertices[face.a], vertices[face.b], vertices[face.c]);
+
+    var vertexNormals = face.vertexNormals;
+
+    if (vertexNormals.length === 3) {
+
+      _normals.push(vertexNormals[0], vertexNormals[1], vertexNormals[2]);
+
+    } else {
+
+      var normal = face.normal;
+
+      _normals.push(normal, normal, normal);
+
+    }
+
+  }
+
+  return {
+    vertices: _vertices,
+    normals: _normals,
+  }
+}
+
+function cuttingString(str, len = 1) {
+  let child = []
+  // var re = /[^/u4e00-/u9fa5]/;
+  // str.indexOf()
+  for (let i = 0; i < str.length; i += len) {
+    
+    child.push(
+      str.substr(i, i + len > str.length ? str.length - i : len)
+    )
+  }
+
+  return child
+}
+
+export { mergeBigData, getMaxHeight, grentAnimationArray, extractType, fromGeometry, cuttingString }

.svn/pristine/c3/c3ebc4798b20bff066f0e3ed126c3ee3827a6c5d.svn-base

@@ -0,0 +1,42 @@
+* {
+  margin: 0;
+  padding: 0;
+}
+
+html {
+  --width: 100%;
+  --height: 100%;
+}
+html, body {
+  width: var(--width);
+  height: var(--height)
+}
+#map {
+  width: var(--width);
+  height: calc(var(--height));
+  overflow: hidden;
+}
+
+#test {
+  width: var(--width);
+  height: calc(var(--height) / 2);
+  overflow: hidden;
+}
+
+#map {
+  background: #ccc;
+}
+
+.point {
+  width: 150px;
+  font-size: 12px;
+  text-align: center;
+  margin-bottom: 10px;
+}
+
+#theme {
+  position: absolute;
+  right: 0;
+  top: 0;
+  padding: 5px;
+}

.svn/pristine/c5/c5154a16ee4b84523e39887b44e7fdf36c4bd86f.svn-base

@@ -0,0 +1,109 @@
+import * as THREE from 'three'
+import { Map$1, Coordinate, MultiPolygon, Polygon } from './featuresToPolygon'
+
+
+let procssMap = new Map$1(null, {
+  center: [0, 0]
+})
+
+function sign(x) {
+  if (Math.sign) {
+    return Math.sign(x);
+  }
+
+  x = +x;
+
+  if (x === 0 || isNaN(x)) {
+    return Number(x);
+  }
+
+  return x > 0 ? 1 : -1;
+}
+
+function getAmount(amount, map) {
+  let zoom = map.maxNativeZoom
+  let center = procssMap.getCenter();
+  let target = procssMap.locate(center, amount, amount);
+  let p0 = procssMap.coordinateToPoint(center, zoom);
+  let p1 = procssMap.coordinateToPoint(target, zoom);
+  var x = Math.abs(p1.x - p0.x) * sign(amount);
+  var y = Math.abs(p1.y - p0.y) * sign(amount);
+  return new THREE.Vector3(x, y, 0).x;
+}
+
+function coordinateToVector3(coordinate, map) {
+  var z = 0;
+  var p = procssMap.coordinateToPoint(coordinate, map.maxNativeZoom)
+  return new THREE.Vector3(p.x, p.y, -z);
+};
+
+function toShape(polygon, map) {
+  var center = polygon.getCenter();
+  var centerPt = coordinateToVector3(center, map);
+  
+  var shell = polygon.getShell();
+  var outer = shell.map(function (c) {
+    return coordinateToVector3(c, map).sub(centerPt);
+  });
+  var shape = new THREE.Shape(outer);
+  var holes = polygon.getHoles();
+
+  if (holes && holes.length > 0) {
+    shape.holes = holes.map(function (item) {
+      var pts = item.map(function (c) {
+        return coordinateToVector3(c, map).sub(centerPt);
+      });
+      return new THREE.Shape(pts);
+    });
+  }
+
+  return shape;
+};
+
+function toExtrudeGeometry(polygon, map, height) {
+  if (!polygon || !(polygon instanceof MultiPolygon || polygon instanceof Polygon)) {
+    return null;
+  }
+
+  if (polygon instanceof MultiPolygon) {
+    return polygon.getGeometries().map(c =>
+      toExtrudeGeometry(c, map, height)
+    );
+  }
+
+  var shape = toShape(polygon, map);
+  var center = coordinateToVector3(polygon.getCenter(), map);
+  var amount = getAmount(height, map);
+  
+  var geom = new THREE.ExtrudeGeometry(shape, { 'depth': amount, 'bevelEnabled': true });
+
+  var vertices = geom.vertices
+  var vlength = vertices.length
+
+  for (let i = 0; i < vlength; i += 1) {
+    vertices[i].x += center.x
+    vertices[i].y += center.y
+    vertices[i].z += -amount
+  }
+
+  return geom
+}
+
+function reductive(map) {
+  procssMap.setCenter(new Coordinate(map.center))
+  // procssMap.width = map.size.width
+  // procssMap.height = map.size.height
+  // procssMap.setBearing(map.bearing)
+  // procssMap.setFov(map.fov)
+  // procssMap.setMaxZoom(map.maxZoom)
+  // procssMap.setMinZoom(map.minZoom)
+  // procssMap.setPitch(map.pitch)
+  // procssMap.setSpatialReference(map.spatialReference)
+}
+
+
+
+export {
+  reductive,
+  toExtrudeGeometry
+}

.svn/pristine/c5/c572b8245b73b8bd39c109a87b4aee9b2716f743.svn-base

@@ -0,0 +1,128 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' 
+    ? factory(module) 
+    : typeof define === 'function' && define.amd 
+      ? define(['exports', function (exports) {
+        var module = { exports: {} };
+        factory(module);
+        exports = module.exports;
+      }])
+      : (function () {
+        var module = { exports: {} };
+        factory(module);
+        global.Event = module.exports;
+      }())
+})(this, function (module) {
+
+  /**
+   * 判断某个函数是否由浏览器自身实现
+   */
+  function isNative (Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+  }
+
+  // 延迟回调触发器
+  var delay;
+  {
+    if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+      delay = setImmediate;
+    } else if (isNative(typeof Promise !== 'undefined' && Promise)) {
+      delay = function (fn) {
+        Promise.resolve()
+          .then(fn)
+      }
+    } else {
+      delay = function (fn) {
+        setTimeout(fn, 0);
+      }
+    }
+  }
+
+  /**
+   * 回调函数处理器,用于统一话调用回调
+   */
+  function fnHandle (fns) {
+    if (!Array.isArray(fns)) {
+      fns = [fns];
+    }
+
+    var handle = function handle() {
+      for (var i = 0; i < fns.length; i++) {
+        fns[i].apply(this, arguments);
+      }
+    }
+    handle.fns = fns;
+
+    return handle
+  }
+  
+  /* ------------- */
+
+  function Event () {
+    // 事件回调存储栈
+    this.stacks = {}
+  }
+
+  /**
+   * 绑定事件统一处理器
+   */
+  Event.prototype.__bind = function __bind (name, fns) {
+    var fn = fnHandle(fns);
+
+    if (!this.stacks[name]) {
+      this.stacks[name] = fnHandle(function() { })
+    }
+
+    this.stacks[name].fns.push(fn);
+
+    return fn;
+  }
+
+  /**
+   * 绑定事件及回调函数
+   */
+  Event.prototype.on = function on (name, fns) {
+    this.__bind(name, fns);
+  }
+
+  /**
+   * 接触绑定事件
+   */
+  Event.prototype.off = function on(name) {
+    this.stacks[name] && (this.stacks[name] = fnHandle(function () { }))
+  }
+
+  /**
+   * 单次绑定,一次触发就失效
+   */
+  Event.prototype.once = function once (name, fns) {
+    var fn = this.__bind(name, fns);
+    fn.isOnce = true;
+  }
+
+  /**
+   * 发布事件,及如果事一次绑定的移除引用调用
+   */
+  Event.prototype.emit = function emit (name) {
+    var callback = this.stacks[name];
+    var args = Array.prototype.slice.call(arguments, 1);
+
+    if (callback) {
+      delay(function () {
+        callback.apply(this, args);
+        var fns = callback.fns,
+            i = 0;
+        while (fns[i]) {
+          if (fns[i].isOnce) {
+            fns.splice(i, 1);
+          } else {
+            i++
+          }
+        }
+      })
+    }
+  }
+  
+  module.exports = Event;
+});
+

.svn/pristine/c9/c958a6b4e509a3bfec77448d0e2ba61b85f831d0.svn-base

@@ -0,0 +1,120 @@
+function mergeBigData(datas) {
+  let index = 0
+  let len = datas.reduce((p, c) => p + c.length, 0)
+  let v3 = new Float32Array(len * 3)
+
+  datas.forEach(data => {
+    let length = data.length
+    for (let i = 0; i < length; i++) {
+      v3[index] = data[i].x
+      v3[index + 1] = data[i].y
+      v3[index + 2] = data[i].z
+      index += 3
+    }
+  })
+
+  return v3
+}
+
+function getMaxHeight(verticesBuffArrays) {
+  let maxHeight = verticesBuffArrays[2]
+  let len = verticesBuffArrays.length
+
+  for (let i = 3; i < len; i += 3) {
+    if (maxHeight < verticesBuffArrays[i + 2]) {
+      maxHeight = verticesBuffArrays[i + 2]
+    }
+  }
+
+  return maxHeight
+}
+
+function grentAnimationArray(verticesBuffArrays, stepTotal, maxHeight) {
+  let len = verticesBuffArrays.length
+  let animateBuffArrays = new Float32Array(
+    (len / 3) * stepTotal
+  )
+
+  for (let i = 0, index = 0; i < len; i += 3, index++) {
+    let indexes = index * stepTotal
+    let origin = verticesBuffArrays[i + 2]
+    let average = (maxHeight - origin) / stepTotal
+    for (let j = 1; j < stepTotal + 1; j++) {
+      animateBuffArrays[indexes + j - 1] = maxHeight - (j * average)
+    }
+  }
+
+  return animateBuffArrays
+}
+
+
+function extractType(features) {
+  let types = []
+  let typeFeatures = [[]]
+
+  features.forEach(f => {
+    if (f.properties && f.properties.type) {
+      let index = types.indexOf(f.properties.type)
+      // index = 0
+      if (~index) {
+        typeFeatures[index + 1].push(f)
+      } else {
+        types.push(f.properties.type)
+        typeFeatures[types.length] = [f]
+      }
+    } else {
+      typeFeatures[0].push(f)
+    }
+  })
+
+  return {
+    typeFeatures,
+    types
+  }
+}
+
+
+
+function fromGeometry(geometry) {
+
+  var faces = geometry.faces;
+  var vertices = geometry.vertices;
+
+  if (vertices.length > 0 && faces.length === 0) {
+
+    console.error('THREE.DirectGeometry: Faceless geometries are not supported.');
+
+  }
+
+  var _vertices = [],
+    _normals = [];
+
+  for (var i = 0; i < faces.length; i++) {
+
+    var face = faces[i];
+
+    _vertices.push(vertices[face.a], vertices[face.b], vertices[face.c]);
+
+    var vertexNormals = face.vertexNormals;
+
+    if (vertexNormals.length === 3) {
+
+      _normals.push(vertexNormals[0], vertexNormals[1], vertexNormals[2]);
+
+    } else {
+
+      var normal = face.normal;
+
+      _normals.push(normal, normal, normal);
+
+    }
+
+  }
+
+  return {
+    vertices: _vertices,
+    normals: _normals,
+  }
+}
+
+export { mergeBigData, getMaxHeight, grentAnimationArray, extractType, fromGeometry }

.svn/pristine/cf/cfa7674d92f1c03365ff146dd85493543598d0d6.svn-base

@@ -0,0 +1,3 @@
+export default {
+  stepTotal: 10
+}

.svn/pristine/d0/d0f5c96528a2cbccfaa89b4b6980e1b93aab0137.svn-base

@@ -0,0 +1,15 @@
+
+function singleDelay(func, time) {
+  let timeout;
+
+  return function() {
+    clearTimeout(timeout)
+    timeout = setTimeout(function() {
+      func.apply(this, arguments)
+    }, time)
+  }
+}
+
+export {
+  singleDelay
+}

.svn/pristine/d6/d6dcd36577e2ca1ef452b543a2175b87ec3cd393.svn-base

@@ -0,0 +1,53 @@
+import { Map } from 'maptalks'
+import 'babel-core/register'
+import 'babel-polyfill'
+import './style/public.css'
+import Event from './core/Event'
+import { listStatus, analysis, mapGoto } from './business/statusManagement'
+import { singleDelay } from './core/util'
+import config from './business/config'
+import getTile from './business/selectTile'
+// import './business/testAddMesh.js'
+
+
+global.bus = new Event()
+
+let args = analysis()
+global.map = new Map('map', {
+  center: [args.lon, args.lat],
+  zoom: args.zoom,
+  bearing: args.bearing,
+  maxZoom: 19,
+  minZoom: 6,
+  maxPitch: 70,
+  maxVisualPitch: 100,
+  doubleClickZoom: false,
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  baseLayer: getTile(),
+})
+
+
+require('./business/initScene3D.js')
+
+// url状态
+let status = singleDelay(listStatus, 500)
+map.on('moving zoomend dragrotating', status);
+map.on('zoomend', args => {
+  if (args.to <= config.criticalZoom && args.from > config.criticalZoom) {
+    mapGoto({ pitch: 1, bearing: 7.5 }, 300)
+    bus.emit('uninstall3D')
+    bus.emit('install2D')
+  } else if (args.to > config.criticalZoom && args.from <= config.criticalZoom) {
+    bus.emit('uninstall2D')
+    bus.emit('install3D')
+    mapGoto({ pitch: 62, bearing: 90 }, 300)
+  }
+})
+
+if (args.zoom > config.criticalZoom) {
+  bus.emit('install3D')
+} else {
+  bus.emit('install2D')
+}

.svn/pristine/e1/e1752ac91a7ed5c43fc0947ae6ea432d80ce7517.svn-base

@@ -0,0 +1,33 @@
+import * as THREE from 'three'
+import { animation, init } from './meshAnimation'
+import grentMesh from './grentMesh'
+import config from './config'
+
+
+async function listener(event) {
+  let geoJsonArray = event.data.geoJsonArray
+  geoJsonArray.forEach(j => {
+    let {
+      maxHeight,
+      animateBuffArrays,
+      fids,
+      verticesBuffArrays: verticesArray,
+      normalsBuffArrays: normalsArray,
+      type
+    } = j
+
+    let geometry = new THREE.BufferGeometry()
+    geometry.addAttribute('position', new THREE.BufferAttribute(verticesArray, 3));
+    geometry.addAttribute('normal', new THREE.BufferAttribute(normalsArray, 3));
+
+    var mesh = grentMesh(geometry, type);
+    threeLayer.getScene().add(mesh)
+    mesh.maxHeight = maxHeight
+    mesh.fids = fids
+
+    init(verticesArray, maxHeight)
+    animation(mesh, verticesArray, animateBuffArrays, config.stepTotal)
+  })
+}
+
+export default listener

.svn/pristine/e6/e65405b867e1a61182f47e7e9c1b2e42c670ab25.svn-base

@@ -0,0 +1,121 @@
+import axios from 'axios'
+import * as db from '../core/db'
+import ReqEvent from '../core/Event'
+
+const store = {}
+const geos = []
+
+const getData = (() => {
+  let joinKeys = []
+  let urlTemplate = 'http://www.4dage.com/4DMap/data/{z}_{x}_{y}.json'
+  let subdomains = ['a', 'b', 'c', 'd']
+  let index = 0
+  let requestings = []
+  let event = new ReqEvent()
+
+  async function ajaxGetData(key, url) {
+    let index = requestings.indexOf(key)
+    if (~index) {
+      return new Promise((resolve, reject) => {
+        event.once(key, (data, error) => {
+          if (error) {
+            reject(error)
+          } else {
+            data.data && (data.data.__once = false)
+            resolve(data)
+          }
+        })
+      })
+    } else {
+      requestings.push(key)
+
+      function result(res, err) {
+        if (err) {
+          event.emit(key, null, res)
+        } else {
+          event.emit(key, res)
+          res.data && (res.data.__once = true)
+        }
+        let index = requestings.indexOf(key)
+        requestings.splice(index, 1)
+        return res
+      }
+
+      return axios.get(url).then(res => result(res)).catch(res => result(res, 1))
+    }
+  }
+
+  function getSubdomain() {
+    index === subdomains.length && (index = 0)
+    return subdomains[index++]
+  }
+
+  function storeCtrl(key, data) {
+    db.add({id: key, ...data})
+    store[key] = data
+  }
+
+  function obtain(key) {
+    let index = joinKeys.indexOf(key)
+    joinKeys.splice(index, 1)
+    joinKeys.push(key)
+  }
+
+  async function getData(x, y, z) {
+    let key = `${x}-${y}-${z}`
+    let url = urlTemplate
+      .replace('{s}', getSubdomain())
+      .replace('{x}', x)
+      .replace('{y}', y)
+      .replace('{z}', z)
+
+    let obj = await db.get(key)
+
+    if (obj) {
+      return obj
+    } else {
+      let data = await ajaxGetData(key, url).then(res => res.data)
+      if (data && data.__once) {
+        storeCtrl(key, data)
+      }
+      return data
+    }
+  }
+
+  return getData
+})();
+
+function filter(features) {
+  let result = []
+
+  features.forEach(item => {
+    if (!~geos.indexOf(item.id)) {
+      geos.push(item.id)
+      result.push(item)
+    }
+  })
+
+  return result
+}
+
+async function getFeatures(x, y, z) {
+  
+  let data = await getData(x, y, z)
+  let features = data && data.features ? filter(data.features) : []
+
+  return features
+}
+
+function clearGeos (ids) {
+  ids.forEach(id => {
+    let index = geos.indexOf(id)
+    if (~index) {
+      geos.splice(index, 1)
+    }
+  })
+}
+
+export {
+  getFeatures,
+  clearGeos
+}

.svn/pristine/eb/eb1b089352dc1eace1a677dde568fce2109570a0.svn-base

@@ -0,0 +1,138 @@
+import { Marker, Coordinate } from 'maptalks'
+import { mapGoto } from './statusManagement'
+import { threeLayer, vector } from './initScene3D'
+
+function structText(args) {
+  var point = new Marker(args.point,
+    {
+      properties: {
+        altitude: args.top
+      },
+      visible: true,
+      editable: true,
+      cursor: 'pointer',
+      shadowBlur: 0,
+      shadowColor: 'black',
+      draggable: false,
+      dragShadow: false, // display a shadow during dragging
+      drawOnAxis: null,  // force dragging stick on a axis, can be: x, y
+      symbol: {
+        'textFaceName': 'sans-serif',
+        'textName': args.name,
+        'textFill': '#000000',
+        'textHaloFill': '#fff',
+        'textHaloRadius': 2,
+        'textHorizontalAlignment': 'center',
+        'textVerticalAlignment': 'top',
+        'textSize': 12
+      }
+    }
+  );
+  point.on('click', () => {
+    mapGoto({ center: args.point, zoom: 19 })
+  })
+  point.__id = args.id
+  return point
+}
+
+function addToAttr(args) {
+  var point = new Coordinate(args.point),
+    containerPoint  = map.coordinateToContainerPoint(point).round();
+
+  args.position = [
+    Number(containerPoint.x),
+    Number(containerPoint.y)
+  ]
+}
+
+
+function checkIsAdd(texts, args) {
+  addToAttr(args)
+
+  let tMinX = args.position[0] - args.width / 2
+  let tMaxX = args.position[0] + args.width / 2
+  let tMinY = args.position[1]
+  let tMaxY = args.position[1] + args.height
+
+  let index = texts.findIndex(text => {
+    let minX = text._struct_attribute.position[0] - text._struct_attribute.width / 2
+    let minY = text._struct_attribute.position[1]
+    let maxX = text._struct_attribute.position[0] + text._struct_attribute.width / 2
+    let maxY = text._struct_attribute.position[1] + text._struct_attribute.height
+
+    return !(
+      (tMinX < minX && tMaxX < minX) || 
+      (tMinX > maxX && tMaxX > maxX) || 
+      (tMinY < minY && tMaxY < minY) || 
+      (tMinY > maxY && tMaxY > maxY)
+    )
+  })
+  
+  return !~index
+}
+
+
+function addText(mesh, textjsons) {
+  if (textjsons.length === 0) return;
+  let children = threeLayer.getScene().children
+  let texts = []
+  let newTexts = []
+
+  children.forEach(mesh => {
+    mesh.texts && texts.push(...mesh.texts)
+  })
+
+  textjsons.forEach(item => {
+    if (checkIsAdd(texts, item)) {
+      let text = structText(item)
+      newTexts.push(text)
+      text._struct_attribute = item
+      texts.push(text)
+    }
+  })
+
+  vector.addGeometry(newTexts)
+  mesh.texts = newTexts
+  mesh.textjsons = textjsons
+}
+
+
+
+function referText() {
+  let children = threeLayer.getScene().children
+  let checkTexts = []
+  
+  console.log(children)
+  children.forEach(mesh => {
+    
+    if (mesh.texts) {
+      for (let i = 0; i < mesh.texts.length; i++) {
+        let text = mesh.texts[i]
+        if (checkIsAdd(checkTexts, text._struct_attribute)) {
+          checkTexts.push(text)
+        } else {
+          vector.removeGeometry(text)
+          mesh.texts.splice(i, 1)
+          --i
+        }
+      }
+    }
+    
+    
+    if (mesh.textjsons) {
+      mesh.textjsons.map(item => {
+        let index = mesh.texts.findIndex(text => text.__id === item.id)
+        if (!~index && checkIsAdd(checkTexts, item)) {
+          let text = structText(item)
+          checkTexts.push(text)
+          text._struct_attribute = item
+          vector.addGeometry(text)
+          mesh.texts.push(text)
+        }
+      })
+    }
+  })
+}
+
+export { referText }
+export default addText

.svn/pristine/ed/ed168f49cae99218c630f753e3286125d1b78870.svn-base

@@ -0,0 +1,37 @@
+
+function average(aver, curr, index) {
+  aver[0] += curr[0]
+  aver[1] += curr[1]
+  if (index) {
+    aver[0] /= 2
+    aver[1] /= 2
+  }
+  return aver
+}
+
+
+function grentText(features) {
+  let texts = []
+
+  features.forEach(fe => {
+    if (fe.properties.name) {
+      let averagePoint = fe.geometry.coordinates.reduce((tPoint, geometry, index) => {
+        return average(
+          tPoint,
+          geometry.reduce(average, [0, 0]),
+          index
+        )
+      }, [0, 0])
+
+      texts.push({
+        name: fe.properties.name,
+        point: averagePoint,
+        height: fe.height
+      })
+    }
+  })
+
+  return texts
+}
+
+export default grentText

.svn/pristine/ed/ed6f1d8d579d93d40be2a3353452dab22783ef5b.svn-base

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta http-equiv="X-UA-Compatible" content="ie=edge">
+  <title>Document</title>
+</head>
+<body>
+  <div id="map"></div>
+  <select id="theme"></select>
+</body>
+</html>

.svn/pristine/ee/ee7c5501663f0ed87c9c1b5c4a50a62088f9fd7e.svn-base

@@ -0,0 +1,14 @@
+import * as THREE from 'three'
+const m = new THREE.MeshPhongMaterial({ color: 0xffffff, opacity: 1 });
+
+
+
+
+function grentMesh(geometry, type) {
+  let mesh = new THREE.Mesh(geometry, m)
+  mesh.castShadow = true; 
+  mesh.receiveShadow = true;
+  return mesh
+}
+
+export default grentMesh

.svn/pristine/f2/f27832056e0aeb1e1f1fe045812ece27db83c662.svn-base

@@ -0,0 +1,50 @@
+function getType(value) {
+  return Object.prototype.toString.call(value).slice(8, -1)
+}
+
+class Task {
+  constructor({ maxParallel }) {
+    this.maxParallel = maxParallel
+    this.runningTotal = 0
+    this.storage = []
+    this.resultCb = this.resultCb.bind(this)
+  }
+
+  push(mission, cb) {
+    this.storage.push({mission, cb})
+    this.run()
+  }
+
+  resultCb() {
+    this.runningTotal--
+    this.run()
+  }
+
+  run() {
+    if (this.storage.length === 0 ||
+      this.maxParallel <= this.runningTotal)
+      return;
+    
+    this.runningTotal++
+
+    let {mission: fn, cb} = this.storage.shift()
+    let type = getType(fn)
+    
+    let promise = 
+      type === 'Function' ? Promise.resolve(fn()) :
+        type === 'Promise' ? fn :
+          type === 'AsyncFunction' ? fn() : Promise.resolve(fn)
+
+    promise.then(data => {
+      cb && cb(data)
+      this.resultCb()
+    }).catch(error => {
+      cb && cb()
+      this.resultCb()
+    })
+
+    this.run()
+  }
+}
+
+export default Task

.svn/pristine/f4/f4147a7e4adb98953bdb755b381ec99a4dcba887.svn-base

@@ -0,0 +1,63 @@
+import * as THREE from 'three'
+import { analysis } from '../business/statusManagement'
+
+export default function (gl, scene, camera) {
+  let renderer = threeLayer.getThreeRenderer()
+
+ 
+  global.scene = scene
+  
+  // camera.add(new THREE.PointLight(0xffffff))
+  // // camera.far = 60000
+  // camera.updateProjectionMatrix()
+  // map.setPitch(60)
+
+
+  /*
+  var ground = new THREE.Mesh( new THREE.PlaneGeometry( 10000,10000,2,2 ), new THREE.MeshLambertMaterial({ color:0xffff00, side:THREE.DoubleSide,  }))
+  ground.name = "ground";
+  ground.position.set(10030408, -46147088, 5.999996185302734);
+
+  ground.receiveShadow = true;
+  ground.castShadow = true
+  scene.add(ground);
+
+  var box = new THREE.Mesh(new THREE.BoxGeometry(1000, 1000, 1000), new THREE.MeshLambertMaterial({ color: 0xff0000 }));
+  box.position.set(10030208, -46146088, -1000.01798629760742);
+  box.castShadow = true;
+  
+
+  scene.add(box);
+  
+  let directionalLight = new THREE.DirectionalLight(0xffffff, 10);
+  directionalLight.position.set(10030808, -46146088, -2100);
+  directionalLight.castShadow = true;
+  directionalLight.shadow.camera.near = 100;
+  directionalLight.shadow.camera.far = 10000;
+  directionalLight.shadow.camera.left = -10000;
+  directionalLight.shadow.camera.bottom = -10000;
+  directionalLight.shadow.camera.right = 10000;
+  directionalLight.shadow.camera.top = 10000;
+  
+  directionalLight.target = box;
+  scene.add(directionalLight);
+  let helper = new THREE.DirectionalLightHelper(directionalLight);
+  helper.scale.set(1000,1000,1000)
+  scene.add(helper);
+*/
+
+  let pointLight = new THREE.PointLight(0xffffff);
+  // pointLight.castShadow = true;
+  // pointLight.shadow.camera.far = 50000;
+  
+  
+  map.setPitch(analysis().pitch)
+  camera.add(pointLight )
+
+  
+
+  renderer.shadowMapEnabled = true;
+  renderer.shadowMapSoft = false;
+
+
+}

.svn/pristine/f5/f5262f56c3bccce00469899b5bbf32c68de8c646.svn-base

@@ -0,0 +1,93 @@
+import 'babel-core/register'
+import 'babel-polyfill'
+import './style/public.css'
+import * as maptalks from 'maptalks'
+import { ThreeLayer } from 'maptalks.three'
+import meshStaus from './business/meshStaus'
+import initAmbient from './business/initAmbient'
+import { addGeo } from './core/dyWoker'
+import Event from './core/Event'
+import * as status from './business/statusManagement'
+
+let args = status.analysis()
+
+global.bus = new Event()
+global.map = new maptalks.Map('map', {
+  center: [args.lon, args.lat],
+  zoom: args.zoom,
+  bearing: args.bearing,
+  maxZoom: 20,
+  minZoom: 15,
+  maxPitch: 70,
+  maxVisualPitch: 100,
+  doubleClickZoom: false,
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  baseLayer: new maptalks.TileLayer('base', {
+    'urlTemplate': 'http://{s}.tile.osm.org/{z}/{x}/{y}.png',
+    'subdomains': ['a', 'b', 'c']
+  })
+})
+
+
+// Maker承载容器
+global.vector = new maptalks.VectorLayer('vector', {
+  enableAltitude: true,        // enable altitude
+  altitudeProperty: 'altitude' // altitude property in properties, default by 'altitude'
+})
+vector.addTo(map)
+
+
+
+// 高层数据获取
+const canvasTile = new maptalks.CanvasTileLayer('tile', {
+  urlTemplate: 'https://{s}.data.osmbuildings.org/0.2/anonymous/tile/{z}/{x}/{y}.json',
+  subdomains: ['a', 'b', 'c', 'd'],
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true,
+  repeatWorld: false,
+  maxAvailableZoom: 15
+})
+
+map.addLayer(canvasTile)
+
+
+
+
+// 3DThree与map结合
+global.threeLayer = new ThreeLayer('t', {
+  forceRenderOnMoving: true,
+  forceRenderOnZooming: true,
+  forceRenderOnRotating: true
+})
+
+threeLayer.prepareToDraw = initAmbient
+
+
+// 获取高层数据
+function getCurrTiles() {
+  let tileGrids = canvasTile.getTiles().tileGrids
+  for (var i = 0; i < tileGrids.length; i++) {
+    if (tileGrids[i].zoom >= 15) break
+  }
+  return tileGrids[i].tiles
+}
+
+threeLayer.draw = () => {
+  addGeo(getCurrTiles());
+  delete threeLayer.draw;
+}
+
+threeLayer.addTo(map)
+
+let timeout = null
+map.on('moving moveend zoomend dragrotating dragrotateend', () => {
+  clearTimeout(timeout)
+  timeout = setTimeout(() => {
+    meshStaus()
+    addGeo(getCurrTiles())
+    status.listStatus()
+  }, 500)
+});

.svn/pristine/f5/f52fae959ff5aeaa8bec51740b8392fe8efd309a.svn-base

@@ -0,0 +1,38 @@
+
+function singleAnimation( verticesArray, animateBuffArrays, stepTotal) {
+  let len = verticesArray.length
+  let pollIndex = 0;
+
+  return function () {
+    for (let i = 0, index = 0; i < len; i += 3, index++) {
+      let Indexes = index * stepTotal + pollIndex
+      verticesArray[i + 2] = animateBuffArrays[Indexes]
+    }
+
+    pollIndex++
+    
+    if (pollIndex < stepTotal) {
+      // mesh.geometry.attributes.position.needsUpdate = true;
+      return false
+    } else {
+      return true
+    }
+  }
+}
+
+
+self.addEventListener('message', event => {
+  let data = event.data
+  let id = data.id
+  let fns = singleAnimation(
+    data.verticesArray,
+    data.animateBuffArrays,
+    data.stepTotal
+  )
+  let interval = setInterval(() => {
+    if (fns()) {
+      clearInterval(interval)
+      self.postMessage(id)
+    }
+  }, 16)
+})

.svn/pristine/f7/f72dd58052cae248b0f85ba8faaafc3e121f99c9.svn-base

@@ -0,0 +1,70 @@
+import Event from '../core/Event'
+import * as THREE from 'three'
+import {animation, init} from './meshAnimation'
+import grentMesh from './grentMesh'
+import FeaturesToAttribute from '../worker/featuresToAttribute.worker'
+import config from './config'
+
+
+let $event = new Event()
+let EVENT_ID = 0
+let worker = new FeaturesToAttribute()
+
+
+
+worker.addEventListener('message', listener)
+
+async function listener(event) {
+  let incident = event.data.incident
+  let geoJsonArray = event.data.geoJsonArray
+  let meshs = geoJsonArray.map(j => {
+    let {
+      maxHeight,
+      animateBuffArrays,
+      verticesBuffArrays: verticesArray,
+      normalsBuffArrays: normalsArray,
+      type
+    } = j
+
+    let geometry = new THREE.BufferGeometry()
+    geometry.addAttribute('position', new THREE.BufferAttribute(verticesArray, 3));
+    geometry.addAttribute('normal', new THREE.BufferAttribute(normalsArray, 3));
+
+    var mesh = grentMesh(geometry, type);
+    threeLayer.getScene().add(mesh)
+    mesh.maxHeight = maxHeight
+
+    init(verticesArray, maxHeight)
+    animation(mesh, verticesArray, animateBuffArrays, config.stepTotal)
+
+    return mesh
+  })
+
+  $event.emit(incident, meshs)
+}
+
+async function addArchitecture(features) {
+  let incident = 'grentAttribute' + EVENT_ID++
+  let map = threeLayer.getMap()
+  let setting = {
+    center: map.getCenter(),
+    maxNativeZoom: map.getMaxNativeZoom()
+  }
+
+  let promise = new Promise(resolve => {
+    $event.once(incident, mesh => {
+      resolve(mesh)
+    })
+  })
+
+  worker.postMessage({
+    thing: 'initialAttribute',
+    features: JSON.stringify(features),
+    map: JSON.stringify(setting),
+    incident
+  })
+
+  return promise
+}
+
+export default addArchitecture

.svn/pristine/fa/fa9bb64d51b4c0ab701ae8aa2450f52ff80c2d82.svn-base

@@ -0,0 +1,5 @@
+export default {
+  stepTotal: 10,
+  levelHeight: 2,
+  defaultHeight: 12
+}

.svn/pristine/fd/fd8342c4ce881345456516b158212f9c50267da6.svn-base

@@ -0,0 +1,60 @@
+import * as THREE from 'three'
+
+function extractArgs(vertices) {
+  let args = {
+    minHeight: verticesBuffArrays[2],
+    center: {}
+  }
+  let total = {x: 0, y: 0}
+  let len = verticesBuffArrays.length
+  let toLen = Math.floor(len / 3)
+
+  for (let i = 3; i < len; i += 3) {
+    total.x += verticesBuffArrays[i]
+    total.y += verticesBuffArrays[i + 1]
+
+    if (args.minHeight > verticesBuffArrays[i + 2]) {
+      args.minHeight = verticesBuffArrays[i + 2]
+    }
+  }
+
+  args.center.x = total.x / toLen
+  args.center.y = total.y / toLen
+
+  return args
+}
+
+function getSeftArgs(vertices) {
+  let args = {
+    minWidth: verticesBuffArrays[0],
+    maxWidth: verticesBuffArrays[0]
+  }
+  let len = verticesBuffArrays.length
+
+  for (let i = 3; i < len; i += 3) {
+    if (args.maxWidth < verticesBuffArrays[i]) {
+      args.maxWidth = verticesBuffArrays[i]
+    }
+
+    if (args.minWidth > verticesBuffArrays[i]) {
+      args.minWidth = verticesBuffArrays[i]
+    }
+  }
+
+  return args
+}
+
+
+
+function grent(text, vertices) {
+  // extractArgs(vertices)
+
+
+  return {
+    textVertices: [], 
+    textNormals: []
+  }
+}
+
+
+export default grent

.svn/pristine/fe/fe253c4a24d4c218971618dbda15bf681459fa54.svn-base

@@ -0,0 +1,92 @@
+import * as THREE from 'three'
+global.THREE = THREE
+require('three/examples/js/controls/OrbitControls')
+
+
+
+var dom = document.querySelector('#test')
+var scene = new THREE.Scene();
+var camera = new THREE.PerspectiveCamera(75, dom.offsetWidth / dom.offsetHeight, 0.1, 1000);
+camera.position.z = 150;
+var controls = new THREE.OrbitControls(camera, dom);
+
+var renderer = new THREE.WebGLRenderer();
+renderer.setSize(dom.offsetWidth, dom.offsetHeight);
+dom.appendChild(renderer.domElement);
+
+
+var f = null
+var loader = new THREE.FontLoader();
+loader.load('http://localhost:3000/helvetiker_regular.typeface.json', function (font) {
+  var boxGeometry = new THREE.BoxBufferGeometry(50, 50, 50);
+  var y = getMaxHeight(boxGeometry.attributes.position.array) + 40
+  var material = new THREE.MeshBasicMaterial({ color: 0x000000 })
+  
+  var geometry = new THREE.TextBufferGeometry('Hello three.js!', {
+    font: font,
+    size: 12,
+    height: 1
+  });
+  f = new THREE.Mesh(geometry, material)
+  f.position.set(
+    -getWidth(geometry.attributes.position.array) / 2,
+    y, 
+    0
+  )
+  scene.add(f)
+  scene.add(
+    new THREE.Mesh(boxGeometry, material)
+  )
+});
+
+
+function getMaxHeight(verticesBuffArrays) {
+  let maxHeight = verticesBuffArrays[2]
+  let len = verticesBuffArrays.length
+
+  for (let i = 3; i < len; i += 3) {
+    if (maxHeight < verticesBuffArrays[i + 2]) {
+      maxHeight = verticesBuffArrays[i + 2]
+    }
+  }
+
+  return maxHeight
+}
+
+function getWidth(verticesBuffArrays) {
+  let args = {
+    minWidth: verticesBuffArrays[0],
+    maxWidth: verticesBuffArrays[0]
+  }
+  let len = verticesBuffArrays.length
+
+  for (let i = 3; i < len; i += 3) {
+    if (args.maxWidth < verticesBuffArrays[i]) {
+      args.maxWidth = verticesBuffArrays[i]
+    }
+
+    if (args.minWidth > verticesBuffArrays[i]) {
+      args.minWidth = verticesBuffArrays[i]
+    }
+  }
+
+  return args.maxWidth - args.minWidth
+}
+
+
+renderer.setClearColor(0xffffff)
+function animate() {
+  controls.update();
+  // console.log(f && f.quaternion)
+
+  f && f.quaternion.copy(camera.quaternion)
+  // console.log(camera.quaternion)
+  f && f.scale.copy(camera.scale)
+  // f && f.scale.copy(camera.scale)
+  // up
+  f && f.rotation.copy(camera.rotation)
+
+  requestAnimationFrame(animate);
+  renderer.render(scene, camera);
+}
+animate();

README.md

@@ -0,0 +1,30 @@
+# 4dagehome
+
+> A Vue.js project
+
+## Build Setup
+
+``` bash
+# install dependencies
+npm install
+
+# serve with hot reload at localhost:8080
+npm run dev
+
+# build for production with minification
+npm run build
+
+# build for production and view the bundle analyzer report
+npm run build --report
+
+# run unit tests
+npm run unit
+
+# run e2e tests
+npm run e2e
+
+# run all tests
+npm test
+```
+
+For a detailed explanation on how things work, check out the [guide](http://vuejs-templates.github.io/webpack/) and [docs for vue-loader](http://vuejs.github.io/vue-loader).

package.json

@@ -0,0 +1,47 @@
+{
+  "name": "maptalks-three",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "webpack-dev-server --mode development",
+    "build": "webpack --mode production"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "autoprefixer": "^9.1.5",
+    "babel-core": "^6.26.3",
+    "babel-loader": "^7.1.5",
+    "babel-polyfill": "^6.26.0",
+    "babel-preset-env": "^1.7.0",
+    "babel-preset-es2015": "^6.24.1",
+    "babel-preset-stage-0": "^6.24.1",
+    "css-loader": "^1.0.0",
+    "dat-gui": "^0.5.0",
+    "extract-text-webpack-plugin": "^3.0.2",
+    "file-loader": "^1.1.11",
+    "html-webpack-plugin": "^3.2.0",
+    "postcss-cssnext": "^3.1.0",
+    "postcss-loader": "^3.0.0",
+    "style-loader": "^0.23.0",
+    "url-loader": "^1.1.1",
+    "webpack": "^4.17.2",
+    "webpack-cli": "^3.1.0",
+    "webpack-dev-server": "^3.1.8",
+    "worker-loader": "^2.0.0"
+  },
+  "dependencies": {
+    "axios": "^0.18.0",
+    "dat-gui": "^0.5.0",
+    "maptalks": "^0.41.1",
+    "maptalks.three": "^0.5.0",
+    "ol": "^5.3.0",
+    "proj4": "^2.5.0",
+    "three": "^0.96.0",
+    "three-obj-loader": "^1.1.3",
+    "three-stats": "^1.0.1"
+  }
+}