diff -r 000000000000 -r bb616224c02a kml/config.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kml/config.py	Mon May 18 08:48:51 2020 +0200
@@ -0,0 +1,246 @@
+import json
+import os
+
+import targets
+from kml import *
+
+
+class Config:
+    class Value:
+        def __init__(self, key, val):
+            self.key = key
+            self.val = val
+            self.chk = True
+            self.keyact = key + '_actual'
+
+        def extract(self, p):
+            if self.key in p:
+                self.val = p[self.key][0]
+            self.chk = True
+
+    class ValueN(Value):
+        def extract(self, p):
+            if self.key in p:
+                try:
+                    self.val = float(p[self.key][0])
+                    self.chk = True
+                except:
+                    self.val = p[self.key][0]
+                    self.chk = False
+
+    def __init__(self):
+        # -------------------------------------------------
+        # zadání - vstupní veličiny
+        # -------------------------------------------------
+        self.name = self.Value('NA', 'flyby')
+        self.targname = self.Value('TA', '')
+        self.lat = self.ValueN('LA', targets.Stalin.lat)
+        self.long = self.ValueN('LO', targets.Stalin.long)
+        self.h0 = self.ValueN('H0', 300)
+        self.x0 = self.ValueN('X0', 8000)
+        self.y0 = self.ValueN('Y0', -12000)
+        self.z0 = self.ValueN('Z0', 12000)
+        self.x1 = self.ValueN('X1', 0)
+        self.y1 = self.ValueN('Y1', -150)
+        self.z1 = self.ValueN('Z1', 100)
+        self.exp = self.ValueN('EX', 2)
+        self.steps = self.ValueN('ST', 600)
+        self.speedfact = self.ValueN('SPF', 1)
+        self.slowdown = self.Value('SLD', 'tangential')
+        self.slowdfact = self.ValueN('SLF', 1)
+        self.flyby = self.ValueN('FL', 1)
+        self.influentials = ['name', 'targname', 'lat', 'long', 'h0', 'x0', 'y0', 'z0',
+                       'x1', 'y1', 'z1', 'exp', 'steps', 'speedfact', 'slowdown', 'slowdfact', 'flyby']
+
+        # -------------------------------------------------
+        # počáteční podmínky
+        # -------------------------------------------------
+        self.dXmin = 0.1            # min delta X při numerické konvergenci
+        self.minZ = 60				# minimální přípustná výška nad terénem v metrech
+        self.dHmax = 5				# empirické maximální přípustné otočení pohledu v jednom kroku ve stupních
+        self.durOpt = 23			# empirické optimum: rychlost otáčení pohledu = 23°/sec
+        self.stepsMax = 9999
+
+        # -------------------------------------------------
+        # provozní konstanty
+        # -------------------------------------------------
+        self.configsrv = 'kml'
+        self.dnldsrv = 'flyby'
+        if 'HTTP_HOST' in os.environ:
+            h = os.environ['HTTP_HOST'].split('.')
+            self.srvhost = h[0].lower()
+            self.srvdomain = '.'.join(h[1:])
+            self.dnldqual = '.'.join((self.dnldsrv, self.srvdomain))
+            self.configqual = '.'.join((self.configsrv, self.srvdomain))
+            _reqPath = os.environ['HTTP_HOST'] + os.environ['REQUEST_URI'].split('?')[0]
+            _configKeyWord = 'kml'
+            _dnldKeyWord = 'flyby'
+            self.configReq = _reqPath.lower().find(_configKeyWord) > -1
+            self.dnldReq = _reqPath.lower().find(_dnldKeyWord) > -1
+            _reqUrl = '{scheme}://{host}:{port}{path}'.\
+                format(scheme=os.environ['REQUEST_SCHEME'],
+                       host=os.environ['HTTP_HOST'],
+                       port=os.environ['SERVER_PORT'],
+                       path=os.environ['REQUEST_URI'].split('?')[0])
+            self.dnldUrl = _reqUrl.lower().replace(_configKeyWord, _dnldKeyWord)
+            deb('self.dnldUrl=%s' % self.dnldUrl)
+            self.dnldPath = _reqPath.lower().replace(_configKeyWord, _dnldKeyWord)
+            deb('self.dnldPath=%s' % self.dnldPath)
+        self.defaultlat = 50.1
+        self.defaultlong = 14.3
+        self.parmsdir = 'params'
+        self.targsdir = 'targets'
+        self.kmlfn = 'flyby'		# jméno výstupu - neměnné
+        self.zipped = False
+        # zipping se nedá v současnosti používat, protože Google Earth se s ním nechová standardně
+        # - viz .../memo/googleearth
+        self.kmlfile = '{}.{}'.format(self.kmlfn, 'kmz' if self.zipped else 'kml')
+        self.urlfile = 'url.kml'
+        self.msg = ''
+        self.flagged = False
+
+    def adjust(self):
+        self.x0.val = fabs(self.x0.val)
+        if self.x0.val < self.dXmin:
+            self.x0.val = 0
+        self.x1.val = 0
+        if self.z0.val < self.minZ:
+            self.z0.val = self.minZ
+        if self.z1.val < self.minZ:
+            self.z1.val = self.minZ
+        self.steps.val = int(round(self.steps.val))
+        if self.steps.val <= 0:
+            self.steps.val = 20
+        if self.steps.val > self.stepsMax:
+            self.steps.val = self.stepsMax
+        self.exp.val = fabs(self.exp.val)
+        self.flyby.val = int(fabs(self.flyby.val))
+
+        if self.x0.val > 0:
+            self.r0 = degrees(atan(self.y0.val / self.x0.val))				# lokální azimut na startu
+            self.r1 = 90 if self.y1.val < 0 else -90						# lokální azimut v průletu
+            if self.y1.val == 0:
+                if self.y0.val == 0:
+                    self.r1 = 90
+                else:
+                    self.r1 = 90 * fabs(self.y0.val) / self.y0.val
+                    if self.exp.val <= 1:
+                        self.r1 = -self.r1
+            self.h1 = can360(self.h0.val + self.r0 + self.r1)				# azimut v průletu
+            self.h2 = can360(self.h0.val + 2 * (self.h1 - self.h0.val))		# azimut na konci
+
+        dY = self.y1.val - self.y0.val
+        dZ = self.z1.val - self.z0.val
+        if dY == 0:
+            self.A = pi / 2 if dZ < 0 else -pi / 2
+        else:
+            self.A = atan(dZ / dY)											# sklon roviny letu, horiz = 0
+            if dY > 0:
+                self.A = self.A + pi if dZ <= 0 else self.A - pi
+
+        F = sqrt(pow(dY, 2) + pow(dZ, 2))									# maximální funkční hodnota
+        if self.x0.val > 0:
+            self.K = F / pow(self.x0.val, self.exp.val)		# koeficient paraboly
+
+        sa = SpeedAdjust(self.speedfact.val, self.slowdfact.val, self.steps.val, self)
+        self.speedAdjust = sa.slowdowns[self.slowdown.val](sa)
+
+        self.lastH = self.h0.val
+        self.lastX, self.lastY, self.lastZ = self.x0.val, self.y0.val, self.z0.val
+        self.dX = -2 * self.x0.val / self.steps.val
+        if fabs(self.dX) < self.dXmin:
+            self.dX = -self.dXmin
+        self.sumSteps, self.sumDur = 0, 0
+        self.rr = []
+
+    def update_influentials(self, p):
+        for n in self.influentials:
+            v = eval('self.{}'.format(n))
+            v.extract(p)
+            self.flagged += (not v.chk)
+
+        v = self.lat
+        if v.chk:
+            v.chk = (v.val >= -90 and v.val <= 90)
+        v = self.long
+        if v.chk:
+            v.chk = v.val >= -180 and v.val <= 180
+        v = self.slowdown
+        v.chk = v.val in SpeedAdjust.keys
+
+        self.flagged = False
+        for n in self.influentials:
+            v = eval('self.{}'.format(n))
+            self.flagged += (not v.chk)
+
+    def parmspath(self):
+        return os.path.join(self.parmsdir, self.name.val)
+
+    def parmsls(self):
+        l = os.listdir(self.parmsdir)
+        l.sort()
+        #deb("l={}".format(l))
+        return l
+
+    def targspath(self, name):
+        return os.path.join(self.targsdir, name)
+
+    def targsls(self):
+        l = os.listdir(self.targsdir)
+        l.sort()
+        return l
+
+    def gettarget(self, name):
+        fn = name if name != '' else 'point'
+        path = self.targspath(fn)
+        long = self.defaultlong
+        lat = self.defaultlat
+        if os.path.exists(path):
+            g = {}
+            for p in open(path).read().split(','):
+                k, v = p.split('=')
+                g[k] = v
+            if self.long.key in g:
+                long = g[self.long.key]
+            if self.lat.key in g:
+                lat = g[self.lat.key]
+        return long, lat
+
+    def storetarget(self, name, long, lat):
+        fn = name if name != '' else 'point'
+        path = self.targspath(fn)
+        open(path, mode='w').write('{}={},{}={}'.format(self.lat.key, lat, self.long.key, long))
+
+    def restoreparms(self):
+        if not os.path.exists(self.parmspath()):
+            return
+        parms = dict(json.load(open(self.parmspath())))
+        # for p in open(self.parmspath()).read().split(','):
+        #     k,v = p.split('=')
+        #     parms[k] = [v]
+        self.update_influentials(parms)
+
+    def storeparms(self):
+        if not self.name:
+            return
+        # s = []
+        p = {}
+        for n in self.influentials:
+            v = eval('self.{}'.format(n))
+            # s = s + ['='.join((v.key,str(v.val)))]
+            p[v.key] = [str(v.val)]
+        # open(self.parmspath(), mode='w').write(','.join(s))
+        json.dump(p, open(self.parmspath(), mode='w'), ensure_ascii=False)
+
+    def printparms(self):
+        s = []
+        for n in self.influentials:
+            v = eval('self.{}'.format(n))
+            s = s + ['{}={}'.format(v.key, v.val)]
+        return '\n'.join(s)
+
+    def adjustenv(self):
+        p = {}
+        for k in os.environ:
+            p[k] = [os.environ[k]]
+        return p