mirror of
https://github.com/enzet/map-machine.git
synced 2025-05-11 16:16:51 +02:00
120 lines
4.3 KiB
Python
120 lines
4.3 KiB
Python
#!/usr/bin/env python
|
|
|
|
"""
|
|
Author: Sergey Vartanov (me@enzet.ru)
|
|
"""
|
|
|
|
import math
|
|
import sys
|
|
|
|
sys.path.append('../lib')
|
|
|
|
from vector import Vector
|
|
|
|
|
|
class Flinger(object):
|
|
"""
|
|
Flinger. Coordinates repositioning.
|
|
"""
|
|
def __init__(self, minimum, maximum, target_minimum=None, target_maximum=None, ratio=None):
|
|
self.minimum = minimum
|
|
self.maximum = maximum
|
|
|
|
if not target_minimum:
|
|
target_minimum = Vector()
|
|
if not target_maximum:
|
|
target_maximum = maximum - minimum
|
|
|
|
space = Vector()
|
|
|
|
if ratio:
|
|
if ratio == 'geo':
|
|
ratio = math.sin((90.0 - ((self.maximum.y + self.minimum.y) / 2.0)) / 180.0 * math.pi)
|
|
|
|
current_ratio = (self.maximum.x - self.minimum.x) * ratio / (self.maximum.y - self.minimum.y)
|
|
target_ratio = (target_maximum.x - target_minimum.x) / (target_maximum.y - target_minimum.y)
|
|
|
|
if current_ratio >= target_ratio:
|
|
n = (target_maximum.x - target_minimum.x) / (maximum.x - minimum.x) / ratio
|
|
space.y = ((target_maximum.y - target_minimum.y) - (maximum.y - minimum.y) * n) / 2.0
|
|
space.x = 0
|
|
else:
|
|
n = (target_maximum.y - target_minimum.y) / (maximum.y - minimum.y)
|
|
space.x = ((target_maximum.x - target_minimum.x) - (maximum.x - minimum.x) * n) / 2.0
|
|
space.y = 0
|
|
|
|
target_minimum.x += space
|
|
target_maximum.x += space
|
|
|
|
self.target_minimum = target_minimum
|
|
self.target_maximum = target_maximum
|
|
|
|
def fling(self, current):
|
|
"""
|
|
Fling current point to the surface.
|
|
"""
|
|
x = map_(current.x, self.minimum.x, self.maximum.x, self.target_minimum.x, self.target_maximum.x)
|
|
y = map_(current.y, self.minimum.y, self.maximum.y, self.target_minimum.y, self.target_maximum.y)
|
|
return Vector(x, y)
|
|
|
|
|
|
class Geo:
|
|
def __init__(self, lat, lon):
|
|
self.lat = lat
|
|
self.lon = lon
|
|
def __add__(self, other):
|
|
return Geo(self.lat + other.lat, self.lon + other.lon)
|
|
def __sub__(self, other):
|
|
return Geo(self.lat - other.lat, self.lon - other.lon)
|
|
def __repr__(self):
|
|
return `self.lat` + ', ' + `self.lon`
|
|
|
|
|
|
class GeoFlinger:
|
|
def __init__(self, minimum, maximum, target_minimum=None, target_maximum=None):
|
|
self.minimum = minimum
|
|
self.maximum = maximum
|
|
|
|
# Ratio is depended of latitude. It is always <= 1.
|
|
# In one latitude degree is always 40 000 / 360 km.
|
|
# In one current longitude degree is about 40 000 / 360 * ratio km.
|
|
|
|
ratio = math.sin((90.0 - ((self.maximum.lat + self.minimum.lat) / 2.0)) / 180.0 * math.pi)
|
|
|
|
# Longitude displayed as x.
|
|
# Latitude displayed as y.
|
|
|
|
# Ratio is x / y.
|
|
|
|
space = Vector()
|
|
current_ratio = (self.maximum.lon - self.minimum.lon) * ratio / (self.maximum.lat - self.minimum.lat)
|
|
target_ratio = (target_maximum.x - target_minimum.x) / (target_maximum.y - target_minimum.y)
|
|
|
|
if current_ratio >= target_ratio:
|
|
n = (target_maximum.x - target_minimum.x) / (maximum.lon - minimum.lon) / ratio
|
|
space.y = ((target_maximum.y - target_minimum.y) - (maximum.lat - minimum.lat) * n) / 2.0
|
|
space.x = 0
|
|
else:
|
|
n = (target_maximum.y - target_minimum.y) / (maximum.lat - minimum.lat) * ratio
|
|
space.x = ((target_maximum.x - target_minimum.x) - (maximum.lon - minimum.lon) * n) / 2.0
|
|
space.y = 0
|
|
|
|
self.target_minimum = target_minimum + space
|
|
self.target_maximum = target_maximum - space
|
|
|
|
self.space = space
|
|
|
|
def fling(self, current):
|
|
x = map_(current.lon, self.minimum.lon, self.maximum.lon,
|
|
self.target_minimum.x, self.target_maximum.x)
|
|
y = map_(self.maximum.lat + self.minimum.lat - current.lat,
|
|
self.minimum.lat, self.maximum.lat,
|
|
self.target_minimum.y, self.target_maximum.y)
|
|
return Vector(x, y)
|
|
|
|
|
|
def map_(value, current_min, current_max, target_min, target_max):
|
|
"""
|
|
Map current value in bounds of current_min and current_max to bounds of target_min and target_max.
|
|
"""
|
|
return target_min + (value - current_min) / (current_max - current_min) * (target_max - target_min)
|