| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| |
| import BoundingRect from 'zrender/src/core/BoundingRect'; |
| import * as bbox from 'zrender/src/core/bbox'; |
| import * as vec2 from 'zrender/src/core/vector'; |
| import * as polygonContain from 'zrender/src/contain/polygon'; |
| import { GeoJSON, GeoSVGGraphicRoot } from './geoTypes'; |
| import * as matrix from 'zrender/src/core/matrix'; |
| import Element from 'zrender/src/Element'; |
| |
| const TMP_TRANSFORM = [] as number[]; |
| |
| export class Region { |
| |
| readonly name: string; |
| readonly type: 'geoJSON' | 'geoSVG'; |
| |
| constructor( |
| name: string |
| ) { |
| this.name = name; |
| } |
| |
| /** |
| * Get center point in data unit. That is, |
| * for GeoJSONRegion, the unit is lat/lng, |
| * for GeoSVGRegion, the unit is SVG local coord. |
| */ |
| getCenter(): number[] { |
| return; |
| } |
| |
| } |
| |
| |
| export class GeoJSONRegion extends Region { |
| |
| readonly type = 'geoJSON'; |
| |
| readonly geometries: { |
| type: 'polygon'; // FIXME:TS Is there other types? |
| exterior: number[][]; |
| interiors?: number[][][]; |
| }[]; |
| |
| private _center: number[]; |
| |
| // Injected outside. |
| properties: GeoJSON['features'][0]['properties']; |
| |
| private _rect: BoundingRect; |
| |
| |
| constructor( |
| name: string, |
| geometries: GeoJSONRegion['geometries'], |
| cp: GeoJSON['features'][0]['properties']['cp'] |
| ) { |
| super(name); |
| |
| this.geometries = geometries; |
| |
| if (!cp) { |
| const rect = this.getBoundingRect(); |
| cp = [ |
| rect.x + rect.width / 2, |
| rect.y + rect.height / 2 |
| ]; |
| } |
| else { |
| cp = [cp[0], cp[1]]; |
| } |
| this._center = cp; |
| } |
| |
| getBoundingRect(): BoundingRect { |
| const rect = this._rect; |
| if (rect) { |
| return rect; |
| } |
| |
| const MAX_NUMBER = Number.MAX_VALUE; |
| const min = [MAX_NUMBER, MAX_NUMBER]; |
| const max = [-MAX_NUMBER, -MAX_NUMBER]; |
| const min2 = [] as number[]; |
| const max2 = [] as number[]; |
| const geometries = this.geometries; |
| let i = 0; |
| for (; i < geometries.length; i++) { |
| // Only support polygon |
| if (geometries[i].type !== 'polygon') { |
| continue; |
| } |
| // Doesn't consider hole |
| const exterior = geometries[i].exterior; |
| bbox.fromPoints(exterior, min2, max2); |
| vec2.min(min, min, min2); |
| vec2.max(max, max, max2); |
| } |
| // No data |
| if (i === 0) { |
| min[0] = min[1] = max[0] = max[1] = 0; |
| } |
| |
| return (this._rect = new BoundingRect( |
| min[0], min[1], max[0] - min[0], max[1] - min[1] |
| )); |
| } |
| |
| contain(coord: number[]): boolean { |
| const rect = this.getBoundingRect(); |
| const geometries = this.geometries; |
| if (!rect.contain(coord[0], coord[1])) { |
| return false; |
| } |
| loopGeo: for (let i = 0, len = geometries.length; i < len; i++) { |
| // Only support polygon. |
| if (geometries[i].type !== 'polygon') { |
| continue; |
| } |
| const exterior = geometries[i].exterior; |
| const interiors = geometries[i].interiors; |
| if (polygonContain.contain(exterior, coord[0], coord[1])) { |
| // Not in the region if point is in the hole. |
| for (let k = 0; k < (interiors ? interiors.length : 0); k++) { |
| if (polygonContain.contain(interiors[k], coord[0], coord[1])) { |
| continue loopGeo; |
| } |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| transformTo(x: number, y: number, width: number, height: number): void { |
| let rect = this.getBoundingRect(); |
| const aspect = rect.width / rect.height; |
| if (!width) { |
| width = aspect * height; |
| } |
| else if (!height) { |
| height = width / aspect; |
| } |
| const target = new BoundingRect(x, y, width, height); |
| const transform = rect.calculateTransform(target); |
| const geometries = this.geometries; |
| for (let i = 0; i < geometries.length; i++) { |
| // Only support polygon. |
| if (geometries[i].type !== 'polygon') { |
| continue; |
| } |
| const exterior = geometries[i].exterior; |
| const interiors = geometries[i].interiors; |
| for (let p = 0; p < exterior.length; p++) { |
| vec2.applyTransform(exterior[p], exterior[p], transform); |
| } |
| for (let h = 0; h < (interiors ? interiors.length : 0); h++) { |
| for (let p = 0; p < interiors[h].length; p++) { |
| vec2.applyTransform(interiors[h][p], interiors[h][p], transform); |
| } |
| } |
| } |
| rect = this._rect; |
| rect.copy(target); |
| // Update center |
| this._center = [ |
| rect.x + rect.width / 2, |
| rect.y + rect.height / 2 |
| ]; |
| } |
| |
| cloneShallow(name: string): GeoJSONRegion { |
| name == null && (name = this.name); |
| const newRegion = new GeoJSONRegion(name, this.geometries, this._center); |
| newRegion._rect = this._rect; |
| newRegion.transformTo = null; // Simply avoid to be called. |
| return newRegion; |
| } |
| |
| getCenter() { |
| return this._center; |
| } |
| |
| setCenter(center: number[]) { |
| this._center = center; |
| } |
| |
| } |
| |
| export class GeoSVGRegion extends Region { |
| |
| readonly type = 'geoSVG'; |
| |
| private _center: number[]; |
| |
| // Can only be used to calculate, but not be modified. |
| // Becuase this el may not belongs to this view, |
| // but been displaying on some other view. |
| private _elOnlyForCalculate: Element; |
| |
| constructor( |
| name: string, |
| elOnlyForCalculate: Element |
| ) { |
| super(name); |
| this._elOnlyForCalculate = elOnlyForCalculate; |
| } |
| |
| getCenter() { |
| let center = this._center; |
| if (!center) { |
| // In most cases there are no need to calculate this center. |
| // So calculate only when called. |
| center = this._center = this._calculateCenter(); |
| } |
| return center; |
| } |
| |
| private _calculateCenter(): number[] { |
| const el = this._elOnlyForCalculate; |
| const rect = el.getBoundingRect(); |
| const center = [ |
| rect.x + rect.width / 2, |
| rect.y + rect.height / 2 |
| ]; |
| |
| const mat = matrix.identity(TMP_TRANSFORM); |
| |
| let target = el; |
| while (target && !(target as GeoSVGGraphicRoot).isGeoSVGGraphicRoot) { |
| matrix.mul(mat, target.getLocalTransform(), mat); |
| target = target.parent; |
| } |
| |
| matrix.invert(mat, mat); |
| |
| vec2.applyTransform(center, center, mat); |
| |
| return center; |
| } |
| |
| } |
| |