calculateOpenlayersCenterOfGeometry: function(propertyModel) { var lineObject = propertyModel.getPoints().map(function(coordinate) { return convertPointCoordinate(coordinate) }) var extent = Openlayers.extent.boundingExtent(lineObject) return Openlayers.extent.getCenter(extent) },
calculateOpenlayersCenterOfGeometry: function(geometry) { var lineObject = geometry.getAllPoints().map(function(coordinate) { return convertPointCoordinate(coordinate); }); var extent = Openlayers.extent.boundingExtent(lineObject); return Openlayers.extent.getCenter(extent); },
calculateOpenlayersCenterOfGeometries: function(geometries) { var allPoints = _.flatten(geometries.map(function(geometry) { return geometry.getAllPoints(); }), true).map(function(coordinate) { return convertPointCoordinate(coordinate); }); var extent = Openlayers.extent.boundingExtent(allPoints); return Openlayers.extent.getCenter(extent); },
calculateOpenlayersCenterOfGeometries: function(propertyModels) { var allPoints = _.flatten( propertyModels.map(function(propertyModel) { return propertyModel.getPoints() }), true ).map(function(coordinate) { return convertPointCoordinate(coordinate) }) var extent = Openlayers.extent.boundingExtent(allPoints) return Openlayers.extent.getCenter(extent) },
features.forEach(function(feature, index) { var center = ol.extent.getCenter(feature.getGeometry().getExtent()); var distance = getDistance(center, coord); if (distance < current_distance) { current_distance = distance; current = index; } });
this.get('source').forEachFeatureInExtent(extent, feature => { let coordinates = feature.getGeometry().getCoordinates(); let lastCoord = coordinates[0]; let nextCoord = null; let end = coordinates.length; let lastRel = ol.extent.containsCoordinate(extent, lastCoord); total_min = Math.min(total_min, lastCoord[3]); if (lastRel === true) { min = Math.min(lastCoord[3], min); } for (let i = 1; i < end; i += 1) { nextCoord = coordinates[i]; let nextRel = ol.extent.containsCoordinate(extent, nextCoord); // current vector completely within extent. do nothing. // current vector completely outside extent. do nothing. // last vertice was inside extent, next one is outside. if (lastRel && !nextRel) { max = Math.max(nextCoord[3], max); lastRel = nextRel; } else if (!lastRel && nextRel) { // last vertice was outside extent, next one is inside min = Math.min(lastCoord[3], min); } lastCoord = nextCoord; lastRel = nextRel; } if (lastRel === true) { max = Math.max(lastCoord[3], max); } total_max = Math.max(total_max, lastCoord[3]); });
zoomToExtent: function(coords) { var lineObject = coords.map(function(coordinate) { return convertPointCoordinate(coordinate) }) var extent = Openlayers.extent.boundingExtent(lineObject) map.getView().fit(extent, { size: map.getSize(), duration: 500, }) },
zoomToExtent: function(coords, opts = {}) { const lineObject = coords.map(function(coordinate) { return convertPointCoordinate(coordinate) }) const extent = Openlayers.extent.boundingExtent(lineObject) map.getView().fit(extent, { size: map.getSize(), duration: 500, ...opts, }) },
panToExtent: function(coords) { if (coords.constructor === Array && coords.length > 0) { const lineObject = coords.map(function(coordinate) { return convertPointCoordinate(coordinate) }) const extent = Openlayers.extent.boundingExtent(lineObject) map.getView().fit(extent, { size: map.getSize(), maxZoom: map.getView().getZoom(), duration: 500, }) } },
zoomToExtent: function(coords) { var zoom = Openlayers.animation.zoom({ duration: 250, resolution: map.getView().getResolution() }); var pan1 = Openlayers.animation.pan({ duration: 250, source: map.getView().getCenter() }); var lineObject = coords.map(function(coordinate) { return convertPointCoordinate(coordinate); }); var extent = Openlayers.extent.boundingExtent(lineObject) map.beforeRender(pan1, zoom); map.getView().fit(extent, map.getSize()); },
var key = this.attr('mapModel.mapObject').on('postrender', function() { self.attr('popupModel').centerPopup(ol.extent.getCenter(extent)); self.attr('mapModel.mapObject').unByKey(key); });
get: function() { //if no features, return null if (!this.attr('features').length) { //update Map layer this.updateSelectedFeature(null); return null; } //get this active feature by array index var feature = this.attr('features')[this.attr('activeFeatureIndex')]; //update Map layer this.updateSelectedFeature(feature); //get the layer key name. Layer id is returned from wms by LayerName.fetureID var layer = feature.getId().split('.'); var index = layer[1]; layer = layer[0]; //get the configured layer properties object key this.layerProperties.layerName var layerProperties = ['layerProperties', layer].join('.'); var template, fieldProperties, prop, attributes = {}; var title; //if its provided parse the alias and formatters if (this.attr(layerProperties)) { //set the layer alias title = this.attr([layerProperties, 'alias'].join('.')); //set the correct template for this feature this.layerproperties.layername.template template = this.attr([layerProperties, 'template'].join('.')); } //get the field properties like alias and formatters this.layerproperties.layername.properties fieldProperties = this.attr([layerProperties, 'properties'].join('.')); var featureProperties = feature.getProperties(); if (layerProperties && fieldProperties) { //build a new attribute list for (prop in featureProperties) { if (featureProperties.hasOwnProperty(prop) && //if we don't have field properties for this layer or we do //and the exclude property is false or undefined, show this field (!fieldProperties || !fieldProperties.attr([prop, 'exclude'].join('.')))) { attributes[prop] = { //alias defaults to the property name if not provided alias: fieldProperties.attr([prop, 'alias'].join('.')) || prop, //value gets formatted if there's a formatter function value: typeof fieldProperties.attr([prop, 'formatter'].join('.')) === 'function' ? fieldProperties.attr([prop, 'formatter'].join('.'))(featureProperties[prop], featureProperties) : can.esc(featureProperties[prop]), //rawValue in case you need access to it rawValue: featureProperties[prop] }; } } } else { //if we don't have a layerProperties for this layer, build a simpler //attribute list for (prop in featureProperties) { if (featureProperties.hasOwnProperty(prop) && //if we don't have field properties for this layer or we do //and the exclude property is false or undefined, show this field (!fieldProperties || !fieldProperties.attr([prop, 'exclude'].join('.')))) { attributes[prop] = { alias: prop, value: featureProperties[prop], rawValue: featureProperties[prop] }; } } } //show popup if used if (this.attr('popupModel')) { var self = this; //there seems to be a bug when loading geojson features var extent = feature .getGeometry() .getExtent(); self.attr('popupModel').centerPopup(ol.extent.getCenter(extent)); } return { feature: feature, featureTemplate: template || featureTemplate, defaultTemplate: featureTemplate, attributes: attributes, layer: layer, title: title || layer, index: index }; }
module.exports = function OpenlayersMap( insertionElement, selectionInterface, notificationEl, componentElement, mapModel ) { let overlays = {} let shapes = [] const map = createMap(insertionElement) listenToResize() setupTooltip(map) const drawingTools = setupDrawingTools(map) function setupTooltip(map) { map.on('pointermove', function(e) { const point = unconvertPointCoordinate(e.coordinate) if (!offMap(point)) { mapModel.updateMouseCoordinates({ lat: point[1], lon: point[0], }) } else { mapModel.clearMouseCoordinates() } }) } function setupDrawingTools(map) { return { bbox: new DrawBBox.Controller({ map, notificationEl, }), circle: new DrawCircle.Controller({ map, notificationEl, }), polygon: new DrawPolygon.Controller({ map, notificationEl, }), line: new DrawLine.Controller({ map, notificationEl, }), } } function resizeMap() { map.updateSize() } function listenToResize() { wreqr.vent.on('resize', resizeMap) } function unlistenToResize() { wreqr.vent.off('resize', resizeMap) } const exposedMethods = _.extend({}, Map, { drawLine(model) { drawingTools.line.draw(model) }, drawBbox(model) { drawingTools.bbox.draw(model) }, drawCircle(model) { drawingTools.circle.draw(model) }, drawPolygon(model) { drawingTools.polygon.draw(model) }, destroyDrawingTools() { drawingTools.line.destroy() drawingTools.polygon.destroy() drawingTools.circle.destroy() drawingTools.bbox.destroy() }, onLeftClick(callback) { $(map.getTargetElement()).on('click', function(e) { const boundingRect = map.getTargetElement().getBoundingClientRect() callback(e, { mapTarget: determineIdFromPosition( [e.clientX - boundingRect.left, e.clientY - boundingRect.top], map ), }) }) }, onRightClick(callback) { $(map.getTargetElement()).on('contextmenu', function(e) { const boundingRect = map.getTargetElement().getBoundingClientRect() callback(e) }) }, onMouseMove(callback) { $(map.getTargetElement()).on('mousemove', function(e) { const boundingRect = map.getTargetElement().getBoundingClientRect() callback(e, { mapTarget: determineIdFromPosition( [e.clientX - boundingRect.left, e.clientY - boundingRect.top], map ), }) }) }, onCameraMoveStart(callback) { map.on('movestart', callback) }, onCameraMoveEnd(callback) { map.on('moveend', callback) }, doPanZoom(coords) { const that = this that.zoomOut({ duration: 1000 }, () => { setTimeout(() => { that.zoomToExtent(coords, { duration: 2000 }) }, 0) }) }, zoomOut(opts, next) { next() }, zoomToSelected() { if (selectionInterface.getSelectedResults().length === 1) { this.panToResults(selectionInterface.getSelectedResults()) } }, panToResults(results) { const coordinates = _.flatten( results.map(function(result) { return result.getPoints() }), true ) this.panToExtent(coordinates) }, panToExtent(coords) { if (coords.constructor === Array && coords.length > 0) { const lineObject = coords.map(function(coordinate) { return convertPointCoordinate(coordinate) }) const extent = Openlayers.extent.boundingExtent(lineObject) map.getView().fit(extent, { size: map.getSize(), maxZoom: map.getView().getZoom(), duration: 500, }) } }, zoomToExtent(coords, opts = {}) { const lineObject = coords.map(function(coordinate) { return convertPointCoordinate(coordinate) }) const extent = Openlayers.extent.boundingExtent(lineObject) map.getView().fit(extent, { size: map.getSize(), duration: 500, ...opts, }) }, zoomToBoundingBox({ north, east, south, west }) { this.zoomToExtent([[west, south], [east, north]]) }, limit(value, min, max) { return Math.min(Math.max(value, min), max) }, getBoundingBox() { const extent = map.getView().calculateExtent(map.getSize()) let longitudeEast = wrapNum(extent[2], -180, 180) const longitudeWest = wrapNum(extent[0], -180, 180) //add 360 degrees to longitudeEast to accommodate bounding boxes that span across the anti-meridian if (longitudeEast < longitudeWest) { longitudeEast += 360 } return { north: this.limit(extent[3], -90, 90), east: longitudeEast, south: this.limit(extent[1], -90, 90), west: longitudeWest, } }, overlayImage(model) { const metacardId = model.get('properties').get('id') this.removeOverlay(metacardId) const coords = model.getPoints('location') const array = _.map(coords, function(coord) { return convertPointCoordinate(coord) }) const polygon = new Openlayers.geom.Polygon([array]) const extent = polygon.getExtent() const projection = Openlayers.proj.get(properties.projection) const overlayLayer = new Openlayers.layer.Image({ source: new Openlayers.source.ImageStatic({ url: model.get('currentOverlayUrl'), projection, imageExtent: extent, }), }) map.addLayer(overlayLayer) overlays[metacardId] = overlayLayer }, removeOverlay(metacardId) { if (overlays[metacardId]) { map.removeLayer(overlays[metacardId]) delete overlays[metacardId] } }, removeAllOverlays() { for (const overlay in overlays) { if (overlays.hasOwnProperty(overlay)) { map.removeLayer(overlays[overlay]) } } overlays = {} }, getCartographicCenterOfClusterInDegrees(cluster) { return utility.calculateCartographicCenterOfGeometriesInDegrees( cluster.get('results').map(function(result) { return result }) ) }, getWindowLocationsOfResults(results) { return results.map(function(result) { const openlayersCenterOfGeometry = utility.calculateOpenlayersCenterOfGeometry( result ) const center = map.getPixelFromCoordinate(openlayersCenterOfGeometry) if (center) { return center } else { return undefined } }) }, /* Adds a billboard point utilizing the passed in point and options. Options are a view to relate to, and an id, and a color. */ addPointWithText(point, options) { const pointObject = convertPointCoordinate(point) const feature = new Openlayers.Feature({ geometry: new Openlayers.geom.Point(pointObject), }) feature.setId(options.id) feature.setStyle( new Openlayers.style.Style({ image: new Openlayers.style.Icon({ img: DrawingUtility.getCircleWithText({ fillColor: options.color, text: options.id.length, }), imgSize: [44, 44], }), }) ) const vectorSource = new Openlayers.source.Vector({ features: [feature], }) const vectorLayer = new Openlayers.layer.Vector({ source: vectorSource, zIndex: 1, }) map.addLayer(vectorLayer) return vectorLayer }, /* Adds a billboard point utilizing the passed in point and options. Options are a view to relate to, and an id, and a color. */ addPoint(point, options) { const pointObject = convertPointCoordinate(point) const feature = new Openlayers.Feature({ geometry: new Openlayers.geom.Point(pointObject), name: options.title, }) feature.setId(options.id) let x = 39, y = 40 if (options.size) { x = options.size.x y = options.size.y } feature.setStyle( new Openlayers.style.Style({ image: new Openlayers.style.Icon({ img: DrawingUtility.getPin({ fillColor: options.color, icon: options.icon, }), imgSize: [x, y], anchor: [x / 2, 0], anchorOrigin: 'bottom-left', anchorXUnits: 'pixels', anchorYUnits: 'pixels', }), }) ) const vectorSource = new Openlayers.source.Vector({ features: [feature], }) const vectorLayer = new Openlayers.layer.Vector({ source: vectorSource, zIndex: 1, }) map.addLayer(vectorLayer) return vectorLayer }, /* Adds a polyline utilizing the passed in line and options. Options are a view to relate to, and an id, and a color. */ addLine(line, options) { const lineObject = line.map(function(coordinate) { return convertPointCoordinate(coordinate) }) const feature = new Openlayers.Feature({ geometry: new Openlayers.geom.LineString(lineObject), name: options.title, }) feature.setId(options.id) const styles = [ new Openlayers.style.Style({ stroke: new Openlayers.style.Stroke({ color: 'white', width: 8, }), }), new Openlayers.style.Style({ stroke: new Openlayers.style.Stroke({ color: options.color || defaultColor, width: 4, }), }), ] feature.setStyle(styles) const vectorSource = new Openlayers.source.Vector({ features: [feature], }) const vectorLayer = new Openlayers.layer.Vector({ source: vectorSource, }) map.addLayer(vectorLayer) return vectorLayer }, /* Adds a polygon fill utilizing the passed in polygon and options. Options are a view to relate to, and an id. */ addPolygon(polygon, options) {}, /* Updates a passed in geometry to reflect whether or not it is selected. Options passed in are color and isSelected. */ updateCluster(geometry, options) { if (geometry.constructor === Array) { geometry.forEach( function(innerGeometry) { this.updateCluster(innerGeometry, options) }.bind(this) ) } else { const feature = geometry.getSource().getFeatures()[0] const geometryInstance = feature.getGeometry() if (geometryInstance.constructor === Openlayers.geom.Point) { geometry.setZIndex(options.isSelected ? 2 : 1) feature.setStyle( new Openlayers.style.Style({ image: new Openlayers.style.Icon({ img: DrawingUtility.getCircleWithText({ fillColor: options.color, strokeColor: options.outline, text: options.count, textColor: options.textFill, }), imgSize: [44, 44], }), }) ) } else if ( geometryInstance.constructor === Openlayers.geom.LineString ) { const styles = [ new Openlayers.style.Style({ stroke: new Openlayers.style.Stroke({ color: 'rgba(255,255,255, .1)', width: 8, }), }), new Openlayers.style.Style({ stroke: new Openlayers.style.Stroke({ color: 'rgba(0,0,0, .1)', width: 4, }), }), ] feature.setStyle(styles) } } }, /* Updates a passed in geometry to reflect whether or not it is selected. Options passed in are color and isSelected. */ updateGeometry(geometry, options) { if (geometry.constructor === Array) { geometry.forEach( function(innerGeometry) { this.updateGeometry(innerGeometry, options) }.bind(this) ) } else { const feature = geometry.getSource().getFeatures()[0] const geometryInstance = feature.getGeometry() if (geometryInstance.constructor === Openlayers.geom.Point) { let x = 39, y = 40 if (options.size) { x = options.size.x y = options.size.y } geometry.setZIndex(options.isSelected ? 2 : 1) feature.setStyle( new Openlayers.style.Style({ image: new Openlayers.style.Icon({ img: DrawingUtility.getPin({ fillColor: options.color, strokeColor: options.isSelected ? 'black' : 'white', icon: options.icon, }), imgSize: [x, y], anchor: [x / 2, 0], anchorOrigin: 'bottom-left', anchorXUnits: 'pixels', anchorYUnits: 'pixels', }), }) ) } else if ( geometryInstance.constructor === Openlayers.geom.LineString ) { const styles = [ new Openlayers.style.Style({ stroke: new Openlayers.style.Stroke({ color: options.isSelected ? 'black' : 'white', width: 8, }), }), new Openlayers.style.Style({ stroke: new Openlayers.style.Stroke({ color: options.color || defaultColor, width: 4, }), }), ] feature.setStyle(styles) } } }, /* Updates a passed in geometry to be hidden */ hideGeometry(geometry) { geometry.setVisible(false) }, /* Updates a passed in geometry to be shown */ showGeometry(geometry) { geometry.setVisible(true) }, removeGeometry(geometry) { map.removeLayer(geometry) }, showPolygonShape(locationModel) { const polygon = new DrawPolygon.PolygonView({ model: locationModel, map, }) shapes.push(polygon) }, showCircleShape(locationModel) { const circle = new DrawCircle.CircleView({ model: locationModel, map, }) shapes.push(circle) }, showLineShape(locationModel) { const line = new DrawLine.LineView({ model: locationModel, map, }) shapes.push(line) }, showMultiLineShape(locationModel) { let lineObject = locationModel .get('multiline') .map(line => line.map(coords => convertPointCoordinate(coords))) let feature = new Openlayers.Feature({ geometry: new Openlayers.geom.MultiLineString(lineObject), }) feature.setId(locationModel.cid) const styles = [ new Openlayers.style.Style({ stroke: new Openlayers.style.Stroke({ color: locationModel.get('color') || defaultColor, width: 4, }), }), ] feature.setStyle(styles) return this.createVectorLayer(locationModel, feature) }, createVectorLayer(locationModel, feature) { let vectorSource = new Openlayers.source.Vector({ features: [feature], }) let vectorLayer = new Openlayers.layer.Vector({ source: vectorSource, }) map.addLayer(vectorLayer) overlays[locationModel.cid] = vectorLayer return vectorLayer }, destroyShape(cid) { const shapeIndex = shapes.findIndex(shape => cid === shape.model.cid) if (shapeIndex >= 0) { shapes[shapeIndex].destroy() shapes.splice(shapeIndex, 1) } }, destroyShapes() { shapes.forEach(function(shape) { shape.destroy() }) shapes = [] }, getOpenLayersMap() { return map }, destroy() { this.destroyDrawingTools() unlistenToResize() }, }) return exposedMethods }
var ol = require('openlayers'); var fs = require('fs'); var fastCsv = require('fast-csv'); var csvParser = require('csv-parser'); var stream = require('stream'); var sfExtent = [-122.384591, 37.703211, -122.510850, 37.808675]; var sf = ol.extent.getCenter(sfExtent); var halfMileInMeters = 804.672; var wgs84Sphere = new ol.Sphere(6378137); function stringStream(string) { // http://stackoverflow.com/questions/12755997/how-to-create-streams-from-string-in-node-js var s = new stream.Readable(); s._read = function noop() {}; // redundant? see update below s.push(string); s.push(null); return s; } function makeLayer(csvStream, color) { var style = new ol.style.Style({ stroke: new ol.style.Stroke({ color: color, width: 1 }), fill: new ol.style.Fill({ color: color, }) });
function unconvertPointCoordinate(point) { return Openlayers.proj.transform(point, properties.projection, 'EPSG:4326') } /* A variety of helpful functions for dealing with Openlayers */ module.exports = { /* Calculates the center of given a geometry (WKT) */ calculateOpenlayersCenterOfGeometry(propertyModel) { const lineObject = propertyModel.getPoints().map(function(coordinate) { return convertPointCoordinate(coordinate) }) const extent = Openlayers.extent.boundingExtent(lineObject) return Openlayers.extent.getCenter(extent) }, /* Calculates the center of given a geometry (WKT) */ calculateCartographicCenterOfGeometryInDegrees(propertyModel) { const openlayersCenter = this.calculateOpenlayersCenterOfGeometry( propertyModel ) return unconvertPointCoordinate(openlayersCenter) }, /* Calculates the center of given geometries (WKT) */ calculateOpenlayersCenterOfGeometries(propertyModels) {
willDestroyElement() { this.get('map').un('postcompose', this.onPostCompose, this); }, onPostCompose(e) { this.renderMarkers(e.vectorContext); }, renderMarkers(context) { this.renderMarker(context, this.get('startStyle'), this.get('startPoint')); this.renderMarker(context, this.get('endStyle'), this.get('endPoint')); }, renderMarker(context, style, coordinate) { if (coordinate) { context.setStyle(style); context.drawGeometry(coordinate); } }, adjustMapView() { let coordinates = this.get('coordinates'); if (coordinates) { let map = this.get('map'); let extent = ol.extent.boundingExtent(coordinates); let padding = this.getWithDefault('calculatePadding', Ember.K)(); map.getView().fit(extent, map.getSize(), { padding }); } }, });