add all files

+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Текущий файл",
+            "type": "python",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        }
+    ]
+}
\ No newline at end of file

+{
+    "python.pythonPath": "C:\\Users\\user\\AppData\\Local\\Programs\\Python\\Python38\\python.exe"
+}
\ No newline at end of file

+import time
+import logging
+import pika
+import json
+import time
+import datetime
+import pytz
+
+from threading import Thread
+from queue import Queue, Empty
+from ocm_fwk.ocm_mq import OcmMqBase
+
+import config as cfg
+
+'''
+class MyJSONEncoder(json.JSONEncoder):
+        #Override the default method
+        def default(self, obj):
+            if isinstance(obj, (datetime.date, datetime.datetime)):
+                return obj.replace(tzinfo=datetime.timezone.utc).isoformat()
+            if isinstance(obj, np.ndarray):
+                return obj.tolist()
+'''
+
+class test_cons(OcmMqBase):
+
+    def __init__(self, settings, consumer_queue=None, consumer_routing_key=None, consume_only_routing_key=True,
+                 message_ttl_ms=None):
+        super(test_cons, self).__init__(settings)
+        self.logger = logging.getLogger(__name__)
+
+        if consumer_queue is None:
+            raise TypeError
+        if consumer_routing_key is None:
+            raise TypeError
+
+        self.consumer_queue = consumer_queue
+        self.consumer_routing_key = consumer_routing_key
+        self.consume_only_routing_key = consume_only_routing_key
+        self.message_ttl_ms = message_ttl_ms
+
+        self._loop_thread = Thread(target=self._main_loop)
+        self._stop_flag = False
+
+        self.mms_main_query = Queue()
+
+    def consume(self, routing_key, message_object):
+        self.mms_main_query.put(message_object)
+        print("{} ->  consume bu rout {} messege :{}".format(datetime.datetime.now(), routing_key, message_object))
+        return True
+
+    def get_lazy_data(self):
+        result = []
+        while self.mms_main_query.qsize() != 0:
+            result.append(self.mms_main_query.get())
+        return result
+
+    def _consumer_callback(self, ch, method, properties, body):
+        # проверка правильности подписки на routing_key
+        if self.consume_only_routing_key:
+            if isinstance(self.consumer_routing_key, str):      # если routing key - одна строка
+                if self.consumer_routing_key != method.routing_key:
+                    # сообщение не может быть обработано и посылать его повторно не нужно
+                    ch.basic_nack(delivery_tag=method.delivery_tag, requeue=False)
+                    self.logger.warning('MQ: routing key({}) not proper'.format(method.routing_key))
+                    return
+            elif isinstance(self.consumer_routing_key, tuple):  # если routing key - кортеж строк
+                if method.routing_key not in self.consumer_routing_key:
+                    # сообщение не может быть обработано и посылать его повторно не нужно
+                    ch.basic_nack(delivery_tag=method.delivery_tag, requeue=False)
+                    self.logger.warning('MQ: routing key({}) not proper'.format(method.routing_key))
+                    return
+            else:
+                ch.basic_nack(delivery_tag=method.delivery_tag, requeue=False)
+                self.logger.warning('MQ: routing key has not proper type')
+                return
+
+        # преобразование сообщения в нативный объект
+        try:
+            obj = json.loads(body.decode('utf-8'))
+        except Exception:
+            self.logger.exception("MQ: json conversion error")
+            # сообщение не может быть обработано и посылать его повторно не нужно
+            ch.basic_nack(delivery_tag=method.delivery_tag, requeue=False)
+            return
+
+        # callback может вернуть
+        #   None - простым вызовом return или по завершению кода обработчика, то же самое, что False
+        #   True - сообщение обработано, можно посылать ack - удаляет сообщение из очереди
+        #  False - сообщение не обработано, нужно его отправить обратно в очередь - послать nack(requeue=True)
+        ack = None
+        try:
+            ack = self.consume(method.routing_key, obj)
+        except Exception:
+            ch.basic_nack(delivery_tag=method.delivery_tag, requeue=False)
+            self.logger.exception("MQ: message not consumed")
+            raise
+
+        # если callback не возвратил логический тип, значит ack - False
+        if ack is None:
+            ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True)
+        elif ack:
+            ch.basic_ack(delivery_tag=method.delivery_tag)
+        else:
+            ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True)
+
+    def _main_loop(self):
+        while not self._stop_flag:
+            connection = None
+            ch_consumer = None
+            try:
+                connection = pika.BlockingConnection(self.parameters)
+                ch_consumer = connection.channel()
+                ch_consumer.basic_qos(prefetch_count=100)       # todo: вынести в настройки
+
+                # определение очереди сообщений, в случае отсутствия, будет создана
+                if self.message_ttl_ms is not None:
+                    queue = ch_consumer.queue_declare(
+                        queue=self.consumer_queue,
+                        durable=True,
+                        exclusive=False,
+                        arguments={'x-message-ttl': self.message_ttl_ms, },
+                    ).method.queue
+                else:
+                    queue = ch_consumer.queue_declare(
+                        queue=self.consumer_queue,
+                        durable=True,
+                        exclusive=False,
+                    ).method.queue
+
+                # привязка к очереди
+                if isinstance(self.consumer_routing_key, str):  # если routing key - одна строка
+                    ch_consumer.queue_bind(
+                        exchange=self.EXCHANGE,
+                        queue=queue,
+                        routing_key=self.consumer_routing_key,
+                    )
+                elif isinstance(self.consumer_routing_key, tuple):  # если routing key - кортеж строк
+                    for key in self.consumer_routing_key:
+                        ch_consumer.queue_bind(
+                            exchange=self.EXCHANGE,
+                            queue=queue,
+                            routing_key=key
+                        )
+                else:
+                    raise TypeError
+
+                # настройка обработчика получения сообщений
+                ch_consumer.basic_consume(
+                    consumer_callback=self._consumer_callback,
+                    queue=queue,
+                    no_ack=False,
+                    consumer_tag="ocm_mq_consumer"
+                )
+
+                self.consumer_queue = queue
+
+                # блокирующий вызов ожидания входящих сообщений
+                try:
+                    ch_consumer.start_consuming()
+                except:
+                    ch_consumer.stop_consuming()
+                    raise
+
+            except Exception:
+                self.logger.exception('mq consuming error, attempting to reconnect...')
+            finally:
+                try:
+                    ch_consumer.close()
+                except:
+                    pass
+
+                try:
+                    connection.close()
+                except:
+                    pass
+
+            time.sleep(self.RECONNECT_SLEEP_SECONDS)
+
+        try:
+            ch_consumer.close()
+        except:
+            pass
+
+        try:
+            connection.close()
+        except:
+            pass
+
+    def start(self):
+        """ Запуск подписчика для шины ОКМ """
+        self._loop_thread.start()
+
+    def stop(self):
+        self._stop_flag = True
+
+bus_TS = test_cons(cfg, "makeyev_L", "measurement.precipitation.*", consume_only_routing_key=False)
+bus_LO = test_cons(cfg, "makeyev_C", "metering.rainfall", consume_only_routing_key=False)
+print("begin...\n")
+#cons.stop()
+bus_LO.start()
+bus_TS.start()
+
+i = 0
+
+while i < 100:
+    i = i + 1
+    print("Iterator={}\t\tdata:{}".format(i, bus_LO.get_lazy_data()))
+    print("Iterator={}\t\tdata:{}".format(i, bus_TS.get_lazy_data()))
+    time.sleep(30)
+
+
+
+'''
+АГК-34Д uuid = "0efefaee-eada-446f-a2a0-f95acabfc0a7" Л
+АГК-77Д uuid = "c3f0ecb7-c65e-4273-93a9-6f39a65dcd4a" Л
+АГК-141 uuid = "83b895ae-3a21-4585-8289-e28da5d0cc43" C
+АГК-040 uuid = "a6f44e50-ad18-4ee9-a6bb-ffae6a85d2a3" С
+АГК-286 uuid = "33ce9a80-27df-41dd-8dbe-cf3ec918b4c2" С
+'''
+

+import time
+import logging
+import pika
+import json
+import datetime
+import pytz
+
+from threading import Thread
+from queue import Queue, Empty
+from ocm_fwk.ocm_mq import OcmMqBase, OcmMqBlockingPublisher
+
+import config as cfg
+
+pub = OcmMqBlockingPublisher(cfg)
+pub.publish("rk_1", 123)
+pub.publish("rk_1", 666)
+pub.publish("rk_1", 999)
+
+

+#user_db_name = "web_forecast_7"
+user_db_name = "qwer"
+db_postgres_connection = dict(host="localhost",database=user_db_name, user="postgres", password="postgres")
+redis_connection = dict(host='localhost', port=6379, db=0, password=None)
+OCM_MQ = dict(
+    HOST = 'evolution.emercit.com',
+    PORT = 5672,
+    VIRTUAL_HOST = 'ocm',
+    EXCHANGE = 'monitoring',
+    USER = 'emercit',
+    PASSWORD = 'xfnLAW5pff3RpNFh')

+import urllib.request
+import json
+import os
+import datetime
+from imageio import imread
+import cv2
+import numpy as np
+import loca_data
+import duamel_model
+import matplotlib.pyplot as plt
+import sher_duam_class
+import dateutil.parser
+import dmrl_prec_file
+
+class DMRLPrecFile_3SC(dmrl_prec_file.DMRLPrecFile):
+
+    # Получить результаты расчёта
+    def GetResult(self, _prec, _test_datetime=None):
+        """
+        _prec это JSON вида:
+            {"time": "2020-03-20T10:00:00Z",
+            "period": 600,
+            "sum": 0.0,
+            "intensity": 0.0,
+            "type": 0}
+        """
+
+        result = None
+        if _prec["sum"] == " ":
+            _prec = None
+
+        """
+        result это JSON вида:
+            {"time": "2020-03-20T10:00:00Z",    - время расчета
+            "water_volume": 0.0,                - общее воличество выпавшей воды в м^3
+            "prec_square": 0.0,                 - площадь выпадения осадков в м^2
+            "all_square": 0.0}            - общая площадь водосбора в м^2
+        """
+
+        #self.k_point_correction = 1                                 # Коэффициент корректировки точечный (интенсивность на осадкомере к интенсивносьти по радару в точке)
+        #self.k_reserv_volume_prec = 1                               # Резервный коэффициент (объем воды / текущие осадки на осадкомере)
+        temp_datetime = datetime.datetime.now()
+        temp_cur_min = (temp_datetime.minute // 10) * 10
+        cur_datetime = datetime.datetime(temp_datetime.year, temp_datetime.month, temp_datetime.day, temp_datetime.hour, temp_cur_min, 0, 0)
+
+        if _prec is not None:
+            #cur_datetime = dateutil.parser.parse(_prec["time"], ignoretz=False).replace(tzinfo=datetime.timezone.utc).astimezone(tz=None)
+            cur_datetime = dateutil.parser.parse(_prec["time"])
+
+        if _test_datetime is not None:
+            cur_datetime = _test_datetime
+
+        matrix = self.GetMatrix(cur_datetime)
+
+        #####################################
+        # TODO Delete!!!!
+        #temp_val = int(cur_datetime.timestamp())
+        #temp_f_p = os.path.abspath(os.curdir) + '\\result\\{}.png'.format(int(cur_datetime.timestamp()))
+        #cv2.imwrite(temp_f_p, matrix)
+        #####################################
+
+        # 1. Если ДМРЛ нет и нет осадков
+        if matrix is None and _prec is None:
+            result = dict(time = cur_datetime.__str__(),
+                water_volume = -1.0,
+                prec_square = -1.0,
+                all_square = -1.0,
+                dmrl_prec = -1.0)
+            return json.dumps(result)
+
+
+        # 2. Если ДМРЛ нет, но есть осадки
+        if matrix is None and _prec is not None:
+            temp_volume = self.GetReservDataByPrec(float(_prec["sum"]))
+
+            result = dict(time = cur_datetime.__str__(),
+                water_volume = temp_volume,
+                prec_square = self.squere,
+                all_square = -1.0)
+            return json.dumps(result)
+
+        # 3-4. Если есть ДМРЛ и есть (или нет) осадков с АГК - ОБЫЧНЫЙ АЛГОРИТМ
+        # Определяем коэффициент корреляции, если оба значения есть и отличны от нуля
+        cur_prec_value = 0
+        if _prec is not None:
+            cur_prec_value = float(_prec["sum"])
+
+            test = matrix[0]
+            test = test[0]
+            test = test[0]
+
+            value = matrix[int(self.corr_y)][int(self.corr_x)][0]
+            dmrl_prec = self.GetPrecByDBZ(value)
+            dmrl_prec = dmrl_prec / 6
+
+            ####################################################################
+            # Работаем с коэффициентами корректировки
+            temp_k_point_correction = 1
+
+            if dmrl_prec > 0 and cur_prec_value > 0:
+                temp_k_point_correction = cur_prec_value / dmrl_prec
+
+                if self.k_point_correction == 1 and self.k_count_point_correction == 0:
+                    self.k_count_point_correction = 1
+                    self.k_math_waiting = temp_k_point_correction
+                    self.k_dispersion = 0
+                    self.k_point_correction = temp_k_point_correction
+                else:
+                    new_count = self.k_count_point_correction + 1                       # Новое количество успешных попыток
+
+                    mval1 = self.k_math_waiting * self.k_count_point_correction         # сумма всех старых значений
+                    mval2 = mval1 + self.k_point_correction                             # новая сумма значеий
+                    mval3 = mval2 / new_count                                           # Новое среднее (матожидание)
+
+                    dval1 = (self.k_dispersion ** 2) * self.k_count_point_correction    # сумма всех квадратов дельт старых
+                    dval2 = (mval3 - temp_k_point_correction) ** 2                      # новый квадрат дельты
+                    dval4 = (dval1 + dval2) / new_count                                 # общая сумма к общему кол-ву новая
+                    dval5 = dval4 ** 0.5                                                # новое среднеквадратичное отклонение (типа дисперсия)
+
+                    cval1 = temp_k_point_correction - mval3                             # новое отклонение с учетом данной попытки
+
+                    # Проверка на 3 сигмы
+                    if abs(cval1) > abs(dval5) * 3.0:
+                        temp_k_point_correction = mval3 + abs(dval5) * 3.0 * np.sign(cval1)
+
+                self.k_point_correction = temp_k_point_correction
+
+            ####################################################################
+
+        sum_squere = 0.0
+        vol_water = 0.0
+        pixel_counter = 0.0
+        for yy in matrix:
+            for xx in yy:
+                lm_value = xx[0]
+                m_prec = self.GetPrecByDBZ(lm_value) / 6.0
+
+                vol_local = self.pixel_size * self.pixel_size * (1.0/1000.0) * m_prec * self.k_point_correction
+                vol_water = vol_water + vol_local
+
+                if vol_local > 0.0:
+                    sum_squere = sum_squere + 1.0
+                    pixel_counter += 1.0
+
+        sum_squere = sum_squere * self.pixel_size * self.pixel_size
+
+        result = dict(time = cur_datetime.__str__(),
+            water_volume = vol_water,
+            prec_square = sum_squere,
+            all_square = self.squere)
+
+        self.SetNewReservKoefficient(cur_prec_value, vol_water)
+
+        return json.dumps(result)
+########################################################################

+import urllib.request
+import json
+import os
+import datetime
+from imageio import imread
+import cv2
+import numpy as np
+import loca_data
+import duamel_model
+import matplotlib.pyplot as plt
+import sher_duam_class
+import dateutil.parser
+import dmrl_prec_file
+
+class DMRLPrecFile_WOC(dmrl_prec_file.DMRLPrecFile):
+
+    # Получить результаты расчёта
+    def GetResult(self, _prec, _test_datetime=None):
+        """
+        _prec это JSON вида:
+            {"time": "2020-03-20T10:00:00Z",
+            "period": 600,
+            "sum": 0.0,
+            "intensity": 0.0,
+            "type": 0}
+        """
+
+        result = None
+        if _prec["sum"] == " ":
+            _prec = None
+
+        temp_datetime = datetime.datetime.now()
+        temp_cur_min = (temp_datetime.minute // 10) * 10
+        cur_datetime = datetime.datetime(temp_datetime.year, temp_datetime.month, temp_datetime.day, temp_datetime.hour, temp_cur_min, 0, 0)
+
+        if _prec is not None:
+            cur_datetime = dateutil.parser.parse(_prec["time"])
+
+        if _test_datetime is not None:
+            cur_datetime = _test_datetime
+
+        matrix = self.GetMatrix(cur_datetime)
+
+        # 1. Если ДМРЛ нет и нет осадков
+        if matrix is None:
+            result = dict(time = cur_datetime.__str__(),
+                water_volume = 0.0,
+                prec_square = 0.0,
+                all_square = -1.0,
+                dmrl_prec = -1.0)
+            return json.dumps(result)
+
+        # 3-4. Если есть ДМРЛ и есть (или нет) осадков с АГК - ОБЫЧНЫЙ АЛГОРИТМ
+        # Определяем коэффициент корреляции, если оба значения есть и отличны от нуля
+        cur_prec_value = 0
+        dmrl_prec = -1.0
+
+        sum_squere = 0.0
+        vol_water = 0.0
+        vol_water_wc = 0.0
+        pixel_counter = 0.0
+        for yy in matrix:
+            for xx in yy:
+                lm_value = xx[0]
+                m_prec = self.GetPrecByDBZ(lm_value) / 6.0
+
+                vol_local_wc = self.pixel_size * self.pixel_size * (1.0/1000.0) * m_prec
+
+                vol_water_wc = vol_water_wc + vol_local_wc
+
+                if vol_water_wc > 0.0:
+                    sum_squere = sum_squere + 1.0
+                    pixel_counter += 1.0
+
+        sum_squere = sum_squere * self.pixel_size * self.pixel_size
+
+        if self.squere != 0.0:
+            dmrl_prec = vol_water_wc / self.squere
+
+        result = dict(
+            time = cur_datetime.__str__(),          # Дата
+            water_volume = vol_water_wc,            # объём воды (метры в кубе)
+            prec_square = sum_squere,               # площадь выпадения осадков
+            all_square = self.squere,               # общая площадь водосбора
+            dmrl_prec = dmrl_prec)                  # осадки (в мм) ОБЪЕМ ПРИВЕДЕННЫЙ К ОБЩЕЙ ПЛОЩАДИ ВОДОСБОРА
+
+        return json.dumps(result)
+########################################################################

+import math
+
+# Общие константы
+DELTA_CONST = 1e-6
+MIN_PART_DELTA_VAL = 1e-4
+MIN_DUML_INGRL_VAL = 1e-4
+
+# Единичный интеграл дюамеля
+class DuhamelPart():
+
+    def __init__(self, _beg_time, _amp, _t_per):
+        self.beg_time = _beg_time
+        self.amp = _amp
+        self.t_per = _t_per
+        self.is_const = False
+
+    def part_step(self, _calc_time):
+        if self.is_const:
+            return self.amp
+        exp_val = math.exp( (self.beg_time - _calc_time)/self.t_per )
+        self.is_const = exp_val < DELTA_CONST
+        return self.amp * (1. - exp_val)
+
+    def const_part(self):
+        return self.is_const
+
+
+# совокупность интегралов дюамеля
+class DuhamelIntegral():
+
+    def __init__(self, _up_per = 1.0, _down_per = 20.0):
+        # параметры интеграла
+        # вроде как вначале одинаковые для всех
+        self.curr_time = -1.0
+        self.curr_src_val = 0.0
+
+        # непосредственно влияющие на интеграл
+        self.up_per = _up_per
+        self.down_per = _down_per
+
+        self.parts_set = []
+        self.duml_val = 0.0
+
+    def add_part(self, delta):
+        if abs(delta) < MIN_PART_DELTA_VAL:
+            return
+        if delta > 0:
+            self.parts_set.append(DuhamelPart(self.curr_time, delta, self.up_per))
+        else:
+            self.parts_set.append(DuhamelPart(self.curr_time, delta, self.down_per))
+
+    def calc_step(self, calc_time):
+        self.duml_val = 0.
+        for part in self.parts_set:
+            self.duml_val += part.part_step(calc_time)
+
+        return self.duml_val
+
+    def duml_step(self, time, value):
+        self.add_part(value - self.curr_src_val)
+        self.curr_time = time
+        self.curr_src_val = value
+        return self.calc_step(self.curr_time)
+
+    def clear_parts_set(self):
+        if abs(self.duml_val) >= MIN_DUML_INGRL_VAL:
+            return
+        for part in self.parts_set:
+            if not part.const_part():
+                return
+        self.parts_set = []
+
+# Полная модель интегралов дюамеля с учетом корректирующих коэффициентов
+class DumlRiverModel:
+
+    def __init__(self, _k_n = 1.0, _k_korr = 25.0, _res_add_val = 20.0, _dmi_up_per = 1.0, _dmi_down_per = 20.0):
+
+        self.duml_intgrl = DuhamelIntegral(_down_per=_dmi_down_per, _up_per=_dmi_up_per)
+
+        self.k_n = _k_n             # константный коэффициент коррекции результата
+        self.save_k_n = self.k_n
+
+        self.k_korr = _k_korr       # настраиваемый коэффициент коррекции результата
+        self.save_k_korr = self.k_korr
+
+        self.res_add_val = _res_add_val # аддитивная величина коррекции результата
+        self.save_add_val = self.res_add_val
+
+    def model_step(self, time, value):
+        return self.k_n * self.k_korr * self.duml_intgrl.duml_step(time, value) + self.res_add_val
+
+# Расчёт стока с водосборов
+class CatchmentArea():
+    def __init__(self, _capacity = 22.2, _in_filter = 1.0, _out_filter = 0.009):
+        # параметры водосбора
+        self.capacity = _capacity  # вместимость водосбора, мм
+        self.in_filter = _in_filter  # инфильтрация в почву за ед. периода, мм (за 10 мин)
+        self.out_filter = _out_filter  # фильтрация из почвы за ед. периода, мм (за 10 мин)
+        self.level_delta = self.capacity
+
+    def calc_surface_flow(self, _rainfall):
+        мах_in = min(_rainfall, self.in_filter)
+        if мах_in <= self.level_delta:
+            self.level_delta -= мах_in
+            self.level_delta += self.out_filter
+            if self.level_delta > self.capacity:
+                self.level_delta = self.capacity
+        else:
+            self.level_delta += self.out_filter
+            if self.level_delta > self.capacity:
+                self.level_delta = self.capacity
+            мах_in = min(мах_in, self.level_delta)
+            self.level_delta -= мах_in
+
+        return _rainfall - мах_in
+
+# реализация метода ньютона-рафсона
+def newton_raphson(study_func, target_val, start_x, max_iter_count=10, max_err=1e-3, delta_x=1e-6):
+
+    # начальное значение аргумента
+    finded_x = start_x
+
+    # Цикл нахождения решения
+    iter_count = 0
+    err_y = 1e20
+
+    # цикл поиска решения
+    while (iter_count <= max_iter_count) and (abs(err_y) > max_err):
+
+        # Вычисляем производную dy/dx в точке x
+        # dfdx в принципе нам может быть известен аналитически, и в таком случае
+        # предпочтительно использовать аналитическое выражение.
+        dfdx = (study_func(finded_x + 0.5 * delta_x) - study_func(finded_x - 0.5 * delta_x)) / delta_x
+
+        # Находим приращение по y
+        err_y = study_func(finded_x) - target_val
+        # и по x
+        err_x = err_y / dfdx
+        # Получаем новое решение
+        finded_x = finded_x - err_x
+
+        # меняем к - во итераций
+        iter_count += 1
+
+    return finded_x
+
+# для расчёта уровня воды по расходу в створе
+class RiverCrossSection():
+
+    def __init__(self, _left_slope = 5.0, _bottom = 18.0, _right_slope = 5.0, _max_h = 3.6, _zero_bsv = -1.06, _n_roughness = 0.035, _i_bias = 0.00244):
+        # параметры трапеции
+        self._zero_wlevel = _zero_bsv
+        self._trap_a = _left_slope  # ширина левого склона трапеции русла
+        self._trap_b = _bottom  # ширина дна трапеции русла
+        self._trap_c = _right_slope # ширина правого склона трапеции русла
+        self._trap_d = _max_h  # высота трапеции русла
+        if self._trap_d >= 0:
+            self._trap_leftCtg = self._trap_a / self._trap_d  # котангенс левого угла трапеции русла
+            self._trap_rightCtg = self._trap_c / self._trap_d  # котангенс правого угла трапеции русла
+        else:
+            self._trap_leftCtg = 0  # котангенс левого угла трапеции русла
+            self._trap_rightCtg = 0  # котангенс правого угла трапеции русла
+
+        self._i_rb_part = _i_bias  # уклон русла
+        self._n_rb_part = _n_roughness  # шероховатость русла
+
+    # площадь сечения (м^2)
+    def f_trap_area(self, h):
+      return self._trap_b * h + (self._trap_leftCtg + self._trap_rightCtg) * h * h / 2
+
+    # смоченный периметр (м)
+    def f_trap_perimetr(self, h):
+      return self._trap_b + \
+             math.sqrt(self._trap_leftCtg ** 2 + 1) * h + \
+             math.sqrt(self._trap_rightCtg ** 2 + 1) * h
+
+    # гидрологический радиус
+    def f_hydro_r(self, h):
+        return self.f_trap_area(h) / self.f_trap_perimetr(h)
+
+    # скорость потока (м/с)
+    def f_flow_speed(self, h):
+        return self.f_hydro_r(h)**(2./3) * math.sqrt(self._i_rb_part) / self._n_rb_part
+
+    # расход воды (м^3/с)
+    def f_flow_rate(self, h):
+        if h <= 0.:
+            return 0.
+        return self.f_trap_area(h) * self.f_flow_speed(h)
+
+    # расход воды (м^3/с)
+    def f_flow_rate_by_bs_h(self, bs_h):
+        return self.f_flow_rate(bs_h - self._zero_wlevel)
+
+    # уровень воды (м), определяемый по расходу воды (м^3/с)
+    def high_by_flow_rate(self, flow_rate):
+        if flow_rate <= 0.:
+            return 0.
+        return newton_raphson(self.f_flow_rate, flow_rate, 1.)
+
+    # уровень воды (м), определяемый по расходу воды (м^3/с) по балтийской системе высот
+    def bs_water_level(self, flow_rate):
+        return self.high_by_flow_rate(flow_rate) + self._zero_wlevel

+import urllib.request
+import json
+import os
+import datetime
+from imageio import imread
+import cv2
+import numpy as np
+import loca_data
+import duamel_model
+import matplotlib.pyplot as plt
+import sher_duam_class
+
+data_store = dict(max_prec = -500.0, values = {})
+
+prec_store = []
+prec_store.append([0.0, 0.0])
+prec_store.append([1.0, 2.0])
+prec_store.append([2.0, 4.0])
+prec_store.append([6.0, 12.0])
+prec_store.append([3.0, 6.0])
+prec_store.append([4.0, 8.0])
+prec_store.append([5.0, 10.0])
+
+
+for p in prec_store:
+    if p[0] > data_store["max_prec"]:
+        data_store["max_prec"] = p[0]
+
+    key = p[0]
+    sd = data_store["values"]
+    sd[key] = p[1]
+
+print(data_store)
+print(sorted(data_store["values"].keys()))
+
+value = 0.0
+new_prec = 4.32
+
+x1 = -1.0
+x2 = -1.0
+y1 = -1.0
+y2 = -1.0
+u_sort_keys = sorted(data_store["values"].keys(), reverse=True)
+sort_keys = sorted(data_store["values"].keys(), reverse=False)
+
+if new_prec > data_store["max_prec"]:
+    x1 = u_sort_keys[1]
+    x2 = u_sort_keys[0]
+    data_store["max_prec"] = new_prec
+else:
+    if new_prec in sort_keys:
+        value = data_store["values"][new_prec]
+        print(value)
+        exit()
+    else:
+        counter = 0
+        for key in sort_keys:
+            if key > new_prec:
+                x1 = sort_keys[counter-1]
+                x2 = key
+                break
+            counter = counter + 1
+
+y1 = data_store["values"][x1]
+y2 = data_store["values"][x2]
+
+value = ((x2 * y1 - x1 * y2) / (x2 - x1)) - (y1 - y2) * new_prec
+print(value)
+
+
+
+
+
+#print("{}|{}^^{}|{}".format(x1, y1, x2, y2))
+#
+
+
+

+import cv2
+import numpy as np
+
+# original image
+# -1 loads as-is so if it will be 3 or 4 channel as the original
+image = cv2.imread('test.png', -1)
+# mask defaulting to black for 3-channel and transparent for 4-channel
+# (of course replace corners with yours)
+mask = np.zeros(image.shape, dtype=np.uint8)
+roi_corners = np.array([[(10,10), (20,20), (10,30)]], dtype=np.int32)
+# fill the ROI so it doesn't get wiped out when the mask is applied
+channel_count = image.shape[2]  # i.e. 3 or 4 depending on your image
+ignore_mask_color = (255,)*channel_count
+cv2.fillPoly(mask, roi_corners, ignore_mask_color)
+# from Masterfool: use cv2.fillConvexPoly if you know it's convex
+
+# apply the mask
+masked_image = cv2.bitwise_and(image, mask)
+
+# save the result
+cv2.imwrite('image_masked.png', masked_image)
\ No newline at end of file

+import urllib.request
+import json
+import os
+import datetime
+from imageio import imread
+import cv2
+import numpy as np
+import loca_data
+import duamel_model
+import matplotlib.pyplot as plt
+import sher_duam_class
+import dateutil.parser
+import psycopg2
+import pathlib
+
+
+def get_connection():
+    DBConnection = psycopg2.connect(
+        host="localhost",
+        port = "15432",
+        database="wf71",
+        user="wf71",
+        password="wf71")
+    print("Connect is success!")
+    DBConnection.autocommit = True
+    return DBConnection
+
+def write_png(filename = "test.png", px_array = None):
+    if px_array is None:
+        px_array = np.zeros(10,10)
+    path = pathlib.Path(__file__).parent.absolute()
+    path = str(path) + filename
+    cv2.imwrite(path, px_array)
+
+def get_png_data_from_db():
+    DBConnection = get_connection()
+    print("Connect is success!")
+    cur = DBConnection.cursor()
+    query = "select measuretime, additional_info from md_precipitation where measurer_uuid = '1bc2b71c-d505-4034-a939-df0252b3f7c6' and measuretime >= '2020-07-08 07:00:00' and measuretime <= '2020-07-09 07:00:00'"
+    cur.execute(query)
+    result = cur.fetchall()
+    radar_a = 200
+    radar_n = 1.6
+    for_txt = []
+
+    for var in result:
+        matrix = []
+        m_dt = var[0]
+        mx = json.loads(var[1])
+        value = 0.0
+
+        error = mx.get("error", False)
+
+        if error == "Radar matrix is not exist":
+            value = 0.0
+        else:
+            matrix = mx["matrix"]
+            if len(matrix) > 1:
+                _dbz = matrix[143][107]
+                if _dbz == 0 or _dbz > 127:
+                    value = 0.0
+                else:
+                    step1 = (_dbz - 32) / 10
+                    step2 = 10 ** step1
+                    step3 = step2 / radar_a
+                    step4 = step3 ** (1.0/radar_n)
+                    step5 = step4 / 6.0
+                    value = step5
+
+        #delta_dt = datetime.timedelta(hours=3)
+        #m_dt = datetime.datetime.strptime(str(m_dt), '%Y-%m-%d %H:%M:%S') - delta_dt
+        for_txt.append([str(m_dt), value])
+
+    cur.close()
+    f = open('result_from_db.txt', 'w')
+    f.write(str(for_txt))
+    f.close()
+
+def get_png_picture_from_db():
+    DBConnection = get_connection()
+    print("Connect is success!")
+    cur = DBConnection.cursor()
+    query = "select measuretime, additional_info from md_precipitation where measurer_uuid = '1bc2b71c-d505-4034-a939-df0252b3f7c6' and measuretime >= '2020-07-08 07:00:00' and measuretime <= '2020-07-09 07:00:00'"
+    cur.execute(query)
+    result = cur.fetchall()
+    i = -1
+
+
+    for var in result:
+        matrix = []
+        m_dt = var[0]
+        td = datetime.timedelta(hours=3)
+        m_dt = m_dt+td
+        print(m_dt)
+        mx = json.loads(var[1])
+        img = np.zeros((256,256, 4),dtype=np.uint8)
+
+        error = mx.get("error", False)
+
+        if error == "Radar matrix is not exist":
+            continue
+        else:
+            matrix = mx["matrix"]
+            if len(matrix) > 1:
+                #png_data = []
+                #for line in matrix:
+                #    new_line = []
+                #    for column in line:
+                #        new_line.append([column, column, column, 255])
+                #    png_data.append(new_line)
+                #png_data = np.array(png_data)
+                x = -1
+                for line in matrix:
+                    x = x + 1
+                    y = -1
+                    for column in line:
+                        y = y + 1
+                        img[x][y] = [column, column, column, 255]
+
+                fn_dt = '{}_{}_{}__{}_{}.png'.format(m_dt.timetuple()[0], m_dt.timetuple()[1], m_dt.timetuple()[2], m_dt.timetuple()[3], m_dt.timetuple()[4])
+                #write_png(filename=r"/png_07/{}".format(fn_dt), px_array=png_data)
+                write_png(filename=r"/png_07/{}".format(fn_dt), px_array=img)
+    cur.close()
+    #get_png_picture_from_db
+
+
+#get_png_data_from_db()
+get_png_picture_from_db()
+

+import urllib.request
+import json
+import os
+import datetime
+from imageio import imread
+import cv2
+import numpy as np
+import loca_data
+import duamel_model
+import matplotlib.pyplot as plt
+import sher_duam_class
+
+
+png_path = r"d:\PYTHON\tests\test1\test_png\dj_286m_1580308200.png"
+save_path = r"d:\PYTHON\tests\test1\test_png\test.png"
+
+lenght_lan = 79497.3714882
+lenght_lon = 111162.6
+base_pixel_len = 152.8740566
+str_limiter = '||'
+
+d1plan_g = base_pixel_len / lenght_lan
+d1plon_g = base_pixel_len / lenght_lon
+x286lon = 38.72287
+x286lan = 44.417242
+
+base_lon = x286lon - (128 * d1plon_g)
+min_lon = x286lon - (128 * d1plon_g)
+max_lon = x286lon + (128 * d1plon_g)
+
+base_lan = x286lan + (128 * d1plan_g)
+min_lan = x286lan - (128 * d1plan_g)
+max_lan = x286lan + (128 * d1plan_g)
+
+pol_store = []
+prec_meas = []
+
+# Сгенерировать полигон по набору геокоординат
+def GeneratePolygons(_meas_list, _number, _name):
+    # Максимальные значения координат Х и У для полигона
+    max_x = 0
+    max_y = 0
+    min_x = 256
+    min_y = 256
+
+    #Временный полигон
+    tmp_pol = []
+
+    # Перебрать измерители последовательно и сформировать полигон как набор пар (х, у) плюс данные о границах полигона (прямоугольных)
+    for imeas in _meas_list:
+        mx =imeas["x"]
+        my = imeas["y"]
+        # Ищем прямоугольные границы полигона
+        if mx > max_x:
+            max_x = mx
+        if my > max_y:
+            max_y = my
+        if mx < min_x:
+            min_x = mx
+        if my < min_y:
+            min_y = my
+        tmp_pol.append((mx, my))
+
+    #result = dict(number = _number, name = _name, max_x = max_x, max_y = max_y, min_x = min_x, min_y = min_y, pol = tmp_pol)
+    result = tmp_pol
+    return result
+
+# получить измеритель (имя, номер, х-коорд картинки и у-коорд картинки) из широты и долготы
+def GetMeas(_number, _name, _lan, _lon):
+    if _lan <= min_lan or _lan >= max_lan:
+        print("MeasUnit named {} have not current lan ({})".format(_name, _lan))
+        return None
+    if _lon <= min_lon or _lon >= max_lon:
+        print("MeasUnit named {} have not current lon ({})".format(_name, _lon))
+        return None
+
+    lan_delta = _lan - base_lan
+    lon_delta = _lon - base_lon
+
+    y_delta = lan_delta * lenght_lan
+    x_delta = lon_delta * lenght_lon
+
+    my = y_delta // base_pixel_len
+    mx = x_delta // base_pixel_len
+
+    result = dict(number = _number, name = _name, x = abs(mx), y = abs(my))
+    return result
+
+_image = imread(png_path)
+
+# Получение координат полигона водосбора Джубги
+pcs = loca_data.GetGeoCoordPolygon()
+
+# Последняя запись - для отбрасывания дублей пикселей
+p_last = dict(x = -1.0, y = 0.0)
+
+all_result = []
+
+# Получаем список точек полигона
+for pc in pcs:
+    p = GetMeas(pc[0], pc[1], pc[2], pc[3])
+
+    if p_last['x'] == -1.0:
+        p_last['x'] = p['x']
+        p_last['y'] = p['y']
+        all_result.append(p)
+    else:
+        if p_last['x'] != p['x'] and p_last['y'] != p['y']:
+            all_result.append(p)
+
+        p_last['x'] = p['x']
+        p_last['y'] = p['y']
+
+polygon = GeneratePolygons(all_result, 0, "All")
+#polygon = all_result
+
+
+##################################################
+# пробуем создать пустое изображение и заполнить его полигоном
+img = np.zeros((256,256,4), np.uint8)
+
+for yy in img:
+        for xx in yy:
+            xx[0] = 255
+            xx[1] = 0
+            xx[2] = 0
+            xx[3] = 255
+
+img_mask = np.zeros(img.shape, dtype=np.uint8)
+img_roi_corners = np.array([polygon], dtype=np.int32)
+img_ignore_mask_color = (255,)*4
+cv2.fillPoly(img_mask, img_roi_corners, img_ignore_mask_color)
+img_masked_image = cv2.bitwise_and(img, img_mask)
+
+cv2.imwrite(save_path, img_masked_image)
+
+pcx_square_count = 0
+
+for yy in img_masked_image:
+        for xx in yy:
+            if xx[0] == 255:
+                pcx_square_count = pcx_square_count + 1
+
+print(pcx_square_count)
+
+squere = base_pixel_len * base_pixel_len * pcx_square_count
+
+print(squere)
+
+
+
+##################################################
+
+
+'''mask = np.zeros(_image.shape, dtype=np.uint8)
+
+roi_corners = np.array([polygon], dtype=np.int32)
+
+channel_count = _image.shape[2]  # i.e. 3 or 4 depending on your image
+
+ignore_mask_color = (255,)*channel_count
+
+cv2.fillPoly(mask, roi_corners, ignore_mask_color)
+
+masked_image = cv2.bitwise_and(_image, mask)'''
+
+

+import urllib.request
+import json
+import os
+import datetime
+from imageio import imread
+
+
+png_path = r"d:\PYTHON\tests\test1\png"
+
+lenght_lan = 79497.3714882
+lenght_lon = 111162.6
+base_pixel_len = 152.8740566
+str_limiter = '||'
+
+d1plan_g = base_pixel_len / lenght_lan
+d1plon_g = base_pixel_len / lenght_lon
+x286lon = 38.72287
+x286lan = 44.417242
+
+base_lon = x286lon - (128 * d1plon_g)
+min_lon = x286lon - (128 * d1plon_g)
+max_lon = x286lon + (128 * d1plon_g)
+
+base_lan = x286lan + (128 * d1plan_g)
+min_lan = x286lan - (128 * d1plan_g)
+max_lan = x286lan + (128 * d1plan_g)
+
+# Генерировать измерители
+def GenerateMeasurements():
+
+    result = []
+    l_dlan = d1plan_g * 48
+    l_dlon = d1plon_g * 48
+    result.append(GetMeas(1, 'X286|sp_dm', x286lan+l_dlan,    x286lon-l_dlon))
+    result.append(GetMeas(2, 'X286|sp_d0', x286lan+l_dlan,    x286lon-0))
+    result.append(GetMeas(3, 'X286|sp_dp', x286lan+l_dlan,    x286lon+l_dlon))
+    result.append(GetMeas(4, 'X286|s0_dm', x286lan+0,         x286lon-l_dlon))
+    result.append(GetMeas(5, 'X286|s0_d0', x286lan+0,         x286lon-0))
+    result.append(GetMeas(6, 'X286|s0_dp', x286lan+0,         x286lon+l_dlon))
+    result.append(GetMeas(7, 'X286|sm_dm', x286lan-l_dlan,    x286lon-l_dlon))
+    result.append(GetMeas(8, 'X286|sm_d0', x286lan-l_dlan,    x286lon-0))
+    result.append(GetMeas(9, 'X286|sm_dp', x286lan-l_dlan,    x286lon+l_dlon))
+
+    '''
+    result.append(GetMeas(1, 'TEST_01', 44.3251277777778, 38.6788694444444))
+    result.append(GetMeas(2, 'TEST_02', 44.3727555555556, 38.7005))
+    result.append(GetMeas(3, 'TEST_03', 44.4186305555556, 38.6651361111111))
+    result.append(GetMeas(4, 'TEST_04', 44.4545888888889, 38.6328638888889))
+    result.append(GetMeas(5, 'TEST_05', 44.4508222222222, 38.6833333333333))
+    result.append(GetMeas(6, 'TEST_06', 44.4329277777778, 38.7327722222222))
+    result.append(GetMeas(7, 'TEST_07', 44.4106166666667, 38.7633277777778))
+    result.append(GetMeas(8, 'TEST_08', 44.3846138888889, 38.7533722222222))
+    result.append(GetMeas(9, 'TEST_09', 44.3416583333333, 38.735175))
+    '''
+
+    return result
+
+# получить измеритель (имя, номер, х-коорд картинки и у-коорд картинки) из широты и долготы
+def GetMeas(_number, _name, _lan, _lon):
+    if _lan <= min_lan or _lan >= max_lan:
+        print("MeasUnit named {} have not current lan ({})".format(_name, _lan))
+        return None
+    if _lon <= min_lon or _lon >= max_lon:
+        print("MeasUnit named {} have not current lon ({})".format(_name, _lon))
+        return None
+
+    lan_delta = _lan - base_lan
+    lon_delta = _lon - base_lon
+
+    y_delta = lan_delta * lenght_lan
+    x_delta = lon_delta * lenght_lon
+
+    my = y_delta // base_pixel_len
+    mx = x_delta // base_pixel_len
+
+    result = dict(number = _number, name = _name, x = abs(mx), y = abs(my))
+    return result
+
+# Получить осадки по значению dbZ
+def GetPrecByDBZ_2(_dbz):
+    result = 0
+
+    if _dbz == 0 or _dbz > 127:
+        return result
+
+    step1 = (_dbz - 32) / 10
+    step2 = 10 ** step1
+    step3 = step2 / 200
+    step4 = step3 ** 0.625
+    result = step4
+    return result
+
+# Получаем все файлы из директории с сохранёнными изображениями
+png_files = os.listdir(png_path)
+print(png_files)
+print("Lan border = {} - {}".format(min_lan, max_lan))
+print("Lon border = {} - {}".format(min_lon, max_lon))
+
+# Сформировать массив "матрица картинки-время" (время из названия файла)
+store = []
+for png_f in png_files:
+    dt_value = png_f.replace('dj_286m_', '').replace('.png', '')
+    dt_value = int(dt_value)
+    dt_value = datetime.datetime.fromtimestamp(dt_value)
+    date_diff = datetime.timedelta(hours=0)
+    dt_value = dt_value + date_diff
+    file_data = imread(png_path + '\\' + png_f)
+    st_unit = dict(
+        datetime = dt_value,
+        matrix = file_data
+    )
+    store.append(st_unit)
+
+# Генерируем тестовые измерители
+prec_meas = GenerateMeasurements()
+
+# Болванка для шапки в Эксель
+shapka = 'Date\t'
+x_y = ''
+
+# Формируем шапку для Экселя
+for mes in prec_meas:
+    if mes is not None:
+        shapka += mes["name"] + str_limiter
+        x_y += "N={} X={} Y={}{}".format(mes["number"], mes["x"], mes["y"], str_limiter)
+
+print(shapka)
+
+# Формируем данные
+main_data = ""
+
+# Последниё интервал расчёта
+last_datetime = store[0]["datetime"]
+
+# Дельта (служебная) между интервалами расчёта
+dt =  datetime.timedelta(minutes=10)
+
+# Пробегаемся по всем картинкам в хранилище
+for prec_data in store:
+
+    # Формируем локальные переменные для цикла
+    lmatrix = prec_data["matrix"]
+    ldatetime = prec_data["datetime"]
+    date_diff = ldatetime - last_datetime
+    local_data = ""
+
+    # Фиксим (пустой строкой) промежутки между измерениями, если таковые имеются
+    while date_diff.seconds >= 1200:
+        local_data = ""
+        last_datetime = last_datetime + dt
+        local_data += last_datetime.__str__() + str_limiter
+        main_data += local_data + "\n"
+        date_diff = ldatetime - last_datetime
+
+    # Формируем для каждого измерителя оасдки в точке, согласно его прямоугольным координатам относительно картинки
+    local_data = ""
+    local_data += ldatetime.__str__() + str_limiter
+    for mes in prec_meas:
+        y = int(mes["y"])
+        x = int(mes["x"])
+        value = lmatrix[y][x][0]
+        prec = GetPrecByDBZ_2(value)
+        local_data += prec.__str__() + str_limiter
+
+    # Ищем максимум осадков на картинке
+    prec_max = 0
+    '''
+    for yy in lmatrix:
+        for xx in yy:
+            lm_value = xx[0]
+            m_prec = GetPrecByDBZ_2(lm_value)
+            if m_prec > prec_max:
+                prec_max = m_prec
+
+    local_data += prec_max.__str__() + str_limiter
+    '''
+    # Вываливаем данные
+    main_data += local_data + "\n"
+    last_datetime = ldatetime
+
+# Заменяем временные разделители и прочие символы для правильного отобраежния в Эксель
+main_data = main_data.replace("||", "\t")
+main_data = main_data.replace(".", ",")
+
+# Пишем результат в текстовый файл
+f = open('result.txt', 'w')
+f.write(main_data)
+f.close()
+
+
+"""
+1. Для каждого измерителя ищем разницу в широте и долготе лот базовых координат
+1.1 Проверяем на выход за предельные значения
+2. По здначениям дельты и длинам градусов ищем разницу в метрах
+3. По разнице в метрах и базовому размеру пикселя ищем нужный квадрат как количество целых делений дельты в метрах на базовую длину градуса
+"""
+

+import sys
+import os
+import time
+import datetime
+import json
+import jsonpickle
+import importlib
+import urllib.request
+from imageio import imread
+import redis
+import requests
+import dateutil.parser
+
+time_result = None
+
+try:
+    time_url = 'https://tilecache.rainviewer.com/api/maps.json'
+    time_result = json.load(urllib.request.urlopen(time_url))
+except Exception as e:
+    print("ERROR::{er}".format(er=e))
+    exit()
+
+if time_result is None or len(time_result) < 1:
+    print("time result is empty")
+    exit()
+
+itime = time_result[0]
+last_number = len(time_result) - 1
+
+last = 0
+for in_dt in time_result:
+    dt_value = datetime.datetime.fromtimestamp(in_dt)
+    print("{}-{}".format(in_dt, dt_value))
+    print("DELTA = {}".format(in_dt - last))
+    last = in_dt
+
+dt_value = datetime.datetime.fromtimestamp(time_result[last_number])
+print("Текущий - {} -> {}".format(time_result[last_number], dt_value))
+
+
+# Определяем текущий тайм-слот
+_datetime = datetime.datetime.now()
+cur_min = (_datetime.minute // 10) * 10
+current_ts = datetime.datetime(_datetime.year, _datetime.month, _datetime.day, _datetime.hour, cur_min, 0, 0)
+current_ts_ts = current_ts.timestamp()
+last_ts = int(current_ts.timestamp()) + 600
+
+'''
+while datetime.datetime.now().timestamp() < last_ts:
+
+    time_result = None
+    time_url = 'https://tilecache.rainviewer.com/api/maps.json'
+    time_result = json.load(urllib.request.urlopen(time_url))
+
+    if time_result is None or len(time_result) < 1 or current_ts_ts not in time_result:
+        print("{}  No data...".format(datetime.datetime.now()))
+        time.sleep(30)
+        continue
+
+    png_data_url = 'https://tilecache.rainviewer.com/v2/radar/{time}/256/10/{lan}/{lon}/0/0_0.png'.format(time=itime,
+        lan="44.417242",
+        lon="38.72287")
+
+    img = imread(png_data_url)
+'''
+
+url_ocm = r'http://10.110.0.37:8888/monitoring/rest/precipitation-measurements/33ce9a80-27df-41dd-8dbe-cf3ec918b4c2?time-from=2020-03-20 10:00:00&time-to=2020-03-20 16:00:00'
+ocm_data = requests.get(url_ocm)
+print(ocm_data.json())
+data = ocm_data.json()
+
+for data_item in data:
+    print("value = time-{}, sum - {}".format(data_item["time"], data_item["sum"]))
+    #cur_cs = datetime.datetime.fromisoformat(data_item["time"])
+    str = data_item["time"]
+    cur_cs = datetime.datetime.strptime(data_item["time"], '%Y-%m-%dT%H:%M:%SZ')
+    cs2 = dateutil.parser.parse(str, ignoretz=False)
+
+    cs3 = cs2.replace(tzinfo=datetime.timezone.utc).astimezone(tz=None)
+    cs4 = dateutil.parser.parse(str, ignoretz=False).replace(tzinfo=datetime.timezone.utc).astimezone(tz=None)
+
+    #dateutil.parser.parse(data_item["time"])
+    print(cur_cs)
+    print(cs2)
+    print(cs3)
+    print(cs4)
+

+import urllib.request
+import json
+import os
+import datetime
+from imageio import imread
+import cv2
+import numpy as np
+
+
+
+png_path = r"d:\PYTHON\tests\test1\png"
+png_result_path = r"d:\PYTHON\tests\test1\cutted"
+
+lenght_lan = 79497.3714882
+lenght_lon = 111162.6
+base_pixel_len = 152.8740566
+str_limiter = '||'
+
+d1plan_g = base_pixel_len / lenght_lan
+d1plon_g = base_pixel_len / lenght_lon
+x286lon = 38.72287
+x286lan = 44.417242
+
+base_lon = x286lon - (128 * d1plon_g)
+min_lon = x286lon - (128 * d1plon_g)
+max_lon = x286lon + (128 * d1plon_g)
+
+base_lan = x286lan + (128 * d1plan_g)
+min_lan = x286lan - (128 * d1plan_g)
+max_lan = x286lan + (128 * d1plan_g)
+
+# Генерировать измерители
+def GenerateMeasurements():
+
+    result = []
+    l_dlan = d1plan_g * 48
+    l_dlon = d1plon_g * 48
+    '''
+    result.append(GetMeas(1, 'X286|sp_dm', x286lan+l_dlan,    x286lon-l_dlon))
+    result.append(GetMeas(2, 'X286|sp_d0', x286lan+l_dlan,    x286lon-0))
+    result.append(GetMeas(3, 'X286|sp_dp', x286lan+l_dlan,    x286lon+l_dlon))
+    result.append(GetMeas(4, 'X286|s0_dm', x286lan+0,         x286lon-l_dlon))
+    result.append(GetMeas(5, 'X286|s0_d0', x286lan+0,         x286lon-0))
+    result.append(GetMeas(6, 'X286|s0_dp', x286lan+0,         x286lon+l_dlon))
+    result.append(GetMeas(7, 'X286|sm_dm', x286lan-l_dlan,    x286lon-l_dlon))
+    result.append(GetMeas(8, 'X286|sm_d0', x286lan-l_dlan,    x286lon-0))
+    result.append(GetMeas(9, 'X286|sm_dp', x286lan-l_dlan,    x286lon+l_dlon))
+
+    '''
+    result.append(GetMeas(0, 'TEST_00', x286lan, x286lon))
+    result.append(GetMeas(1, 'TEST_01', 44.3251277777778, 38.6788694444444))
+    result.append(GetMeas(2, 'TEST_02', 44.3727555555556, 38.7005))
+    result.append(GetMeas(3, 'TEST_03', 44.4186305555556, 38.6651361111111))
+    result.append(GetMeas(4, 'TEST_04', 44.4545888888889, 38.6328638888889))
+    result.append(GetMeas(5, 'TEST_05', 44.4508222222222, 38.6833333333333))
+    result.append(GetMeas(6, 'TEST_06', 44.4329277777778, 38.7327722222222))
+    result.append(GetMeas(7, 'TEST_07', 44.4106166666667, 38.7633277777778))
+    result.append(GetMeas(8, 'TEST_08', 44.3846138888889, 38.7533722222222))
+    result.append(GetMeas(9, 'TEST_09', 44.3416583333333, 38.735175))
+
+
+    return result
+
+# получить измеритель (имя, номер, х-коорд картинки и у-коорд картинки) из широты и долготы
+def GetMeas(_number, _name, _lan, _lon):
+    if _lan <= min_lan or _lan >= max_lan:
+        print("MeasUnit named {} have not current lan ({})".format(_name, _lan))
+        return None
+    if _lon <= min_lon or _lon >= max_lon:
+        print("MeasUnit named {} have not current lon ({})".format(_name, _lon))
+        return None
+
+    lan_delta = _lan - base_lan
+    lon_delta = _lon - base_lon
+
+    y_delta = lan_delta * lenght_lan
+    x_delta = lon_delta * lenght_lon
+
+    my = y_delta // base_pixel_len
+    mx = x_delta // base_pixel_len
+
+    result = dict(number = _number, name = _name, x = abs(mx), y = abs(my))
+    return result
+
+# Получить осадки по значению dbZ
+def GetPrecByDBZ_2(_dbz):
+    result = 0
+
+    if _dbz == 0 or _dbz > 127:
+        return result
+
+    step1 = (_dbz - 32) / 10
+    step2 = 10 ** step1
+    step3 = step2 / 200
+    step4 = step3 ** 0.625
+    result = step4
+    return result
+
+# Сгенерировать полигон по набору геокоординат
+def GeneratePolygons(_meas_list, _number, _name):
+    # Максимальные значения координат Х и У для полигона
+    max_x = 0
+    max_y = 0
+    min_x = 256
+    min_y = 256
+
+    #Временный полигон
+    tmp_pol = []
+
+    # Перебрать измерители последовательно и сформировать полигон как набор пар (х, у) плюс данные о границах полигона (прямоугольных)
+    for imeas in _meas_list:
+        mx =imeas["x"]
+        my = imeas["y"]
+        # Ищем прямоугольные границы полигона
+        if mx > max_x:
+            max_x = mx
+        if my > max_y:
+            max_y = my
+        if mx < min_x:
+            min_x = mx
+        if my < min_y:
+            min_y = my
+        tmp_pol.append((mx, my))
+
+    result = dict(number = _number, name = _name, max_x = max_x, max_y = max_y, min_x = min_x, min_y = min_y, pol = tmp_pol)
+    result["pol"] = tmp_pol
+    return result
+
+# Получить "обрезанную" матрицу по полигону
+def GetCuttedMatrix(_image, _mpolygon):
+    matrix = _mpolygon["pol"]
+    max_x = int(_mpolygon["max_x"])
+    max_y = int(_mpolygon["max_y"])
+    min_x = int(_mpolygon["min_x"])
+    min_y = int(_mpolygon["min_y"])
+    mask = np.zeros(_image.shape, dtype=np.uint8)
+    roi_corners = np.array([matrix], dtype=np.int32)
+    channel_count = _image.shape[2]  # i.e. 3 or 4 depending on your image
+    ignore_mask_color = (255,)*channel_count
+    cv2.fillPoly(mask, roi_corners, ignore_mask_color)
+    masked_image = cv2.bitwise_and(_image, mask)
+    masked_image = masked_image[min_y:max_y, min_x:max_x]
+    return masked_image
+
+
+# Получаем все файлы из директории с сохранёнными изображениями
+png_files = os.listdir(png_path)
+print(png_files)
+print("Lan border = {} - {}".format(min_lan, max_lan))
+print("Lon border = {} - {}".format(min_lon, max_lon))
+
+# Сформировать массив "матрица картинки-время" (время из названия файла)
+store = []
+for png_f in png_files:
+    dt_value = png_f.replace('dj_286m_', '').replace('.png', '')
+    dt_value = int(dt_value)
+    dt_value = datetime.datetime.fromtimestamp(dt_value)
+    date_diff = datetime.timedelta(hours=2)
+    dt_value = dt_value + date_diff
+    file_data = imread(png_path + '\\' + png_f)
+    st_unit = dict(
+        datetime = dt_value,
+        matrix = file_data
+    )
+    store.append(st_unit)
+
+# Генерируем тестовые измерители
+prec_meas = GenerateMeasurements()
+
+# Формируем данные
+main_data = ""
+
+################################################################
+# TEST - генерация обрезанных файлов
+
+main_pol = GeneratePolygons([prec_meas[0], prec_meas[3], prec_meas[4], prec_meas[5], prec_meas[6]], 1, "Verh")
+main_pol = GeneratePolygons([prec_meas[0], prec_meas[6], prec_meas[7], prec_meas[8], prec_meas[9], prec_meas[1], prec_meas[2]], 2, "Nige_Polkovnichego")
+pol_store = []
+pol_store.append(main_pol)
+cutted_store  = []
+
+'''
+for m_image in store:
+    image = m_image["matrix"]
+    masked_image = GetCuttedMatrix(image, main_pol)
+    path_to_save = "d:\\PYTHON\\tests\\test1\\cutted\\{name}_{dt}.png".format(name = main_pol["name"], dt = m_image["datetime"].timestamp())
+    #cv2.imwrite(path_to_save, masked_image)
+    cutted_store.append(masked_image)
+'''
+################################################################
+
+# Последниё интервал расчёта
+last_datetime = store[0]["datetime"]
+
+# Дельта (служебная) между интервалами расчёта
+dt =  datetime.timedelta(minutes=10)
+
+# Пробегаемся по всем картинкам в хранилище
+for prec_data in store:
+
+    # Формируем локальные переменные для цикла
+    lmatrix = prec_data["matrix"]
+    ldatetime = prec_data["datetime"]
+    date_diff = ldatetime - last_datetime
+    local_data = ""
+
+    # Фиксим (пустой строкой) промежутки между измерениями, если таковые имеются
+    while date_diff.seconds >= 1200:
+        local_data = ""
+        last_datetime = last_datetime + dt
+        local_data += last_datetime.__str__() + str_limiter
+        main_data += local_data + "\n"
+        date_diff = ldatetime - last_datetime
+
+    # Формируем для каждого полигона осадки, согласно его прямоугольным координатам относительно картинки
+    local_data = ""
+    local_data += ldatetime.__str__() + str_limiter
+    for pol in pol_store:
+        masked_image = GetCuttedMatrix(lmatrix, pol)
+        sum_prec = 0
+        for yy in masked_image:
+                for xx in yy:
+                    lm_value = xx[0]
+                    m_prec = GetPrecByDBZ_2(lm_value)
+                    sum_prec += m_prec
+        local_data += sum_prec.__str__() + str_limiter
+    # Вываливаем данные
+    main_data += local_data + "\n"
+    last_datetime = ldatetime
+
+# Заменяем временные разделители и прочие символы для правильного отобраежния в Эксель
+main_data = main_data.replace("||", "\t")
+main_data = main_data.replace(".", ",")
+
+# Пишем результат в текстовый файл
+f = open('result.txt', 'w')
+f.write(main_data)
+f.close()
+
+
+"""
+1. Для каждого измерителя ищем разницу в широте и долготе лот базовых координат
+1.1 Проверяем на выход за предельные значения
+2. По здначениям дельты и длинам градусов ищем разницу в метрах
+3. По разнице в метрах и базовому размеру пикселя ищем нужный квадрат как количество целых делений дельты в метрах на базовую длину градуса
+"""
+

+Проект "Треугольные осадки"
+I ЭТАП - ОТРАБОТКА ОБЩЕГО МАТЕМАТИЧСКОГО РЕШЕНИЯ
+. Задать три точки с координатами Р1, Р2, Р3 - (х1у1с1,  х2у2с2, х3у3с3)
+. Определить "площадь решения" в виде плоского рисунка
+. Нарисовать треугольник Т по трём точкам Рх
+. Определить формулу плоскости ПЛ по трем точкам Рх
+. Определить формулу принадлежности произвольной точки Рн треугольнику Р1Р2Р3
+. Пройтись по каждой точке Рпр площади решения и определить, принадлежит ли выбранная точка треугольнику Т
+. Если принадлежит - то определить цвет по формуле ПЛ и установить его на площади решения
+. Сохранить результат в виде рисунка png

+import numpy as np
+import matplotlib.pyplot as plt
+import datetime
+import os.path
+import loca_data
+import math
+
+'''
+# реализация метода ньютона-рафсона
+def newton_raphson(study_func, target_val, start_x, max_iter_count=10, max_err=1e-3, delta_x=1e-6):
+
+    # начальное значение аргумента
+    finded_x = start_x
+
+    # Цикл нахождения решения
+    iter_count = 0
+    err_y = 1e20
+
+    # цикл поиска решения
+    while (iter_count <= max_iter_count) and (abs(err_y) > max_err):
+
+        # Вычисляем производную dy/dx в точке x
+        # dfdx в принципе нам может быть известен аналитически, и в таком случае
+        # предпочтительно использовать аналитическое выражение.
+        dfdx = (study_func(finded_x + 0.5 * delta_x) - study_func(finded_x - 0.5 * delta_x)) / delta_x
+
+        # Находим приращение по y
+        err_y = study_func(finded_x) - target_val
+        # и по x
+        err_x = err_y / dfdx
+        # Получаем новое решение
+        finded_x = finded_x - err_x
+
+        # меняем к - во итераций
+        iter_count += 1
+
+    return finded_x
+'''
+'''
+x = np.random.randint(low=1, high=11, size=50)
+y = x + np.random.randint(1, 5, size=x.size)
+data = np.column_stack((x, y))
+
+fig, (ax1, ax2) = plt.subplots(
+    nrows=1, ncols=2,
+    figsize=(8, 4)
+)
+
+ax1.scatter(x=x, y=y, marker='o', c='r', edgecolor='b')
+ax1.set_title('Scatter: $x$ versus $y$')
+ax1.set_xlabel('$x$')
+ax1.set_ylabel('$y$')
+
+ax2.hist(
+    data, bins=np.arange(data.min(), data.max()),
+    label=('x', 'y')
+)
+
+ax2.legend(loc=(0.65, 0.8))
+ax2.set_title('Frequencies of $x$ and $y$')
+ax2.yaxis.tick_right()
+
+x =  [0,1,2,3,4,5]
+y1 = [1,1,2,2,4,0]
+y2 = [5,1,3,6,4,10]
+y3 = [0,1,3,2,6,8]
+
+fig, ax = plt.subplots()
+
+ax.plot(x, y1, label = 'TEST1')
+ax.plot(x, y2, label = 'ЕУЫЕ2')
+ax.plot(x, y3, label = 'tmp3')
+
+ax.legend()
+
+#fig.set_figheight(5)
+#fig.set_figwidth(8)
+plt.show()
+
+
+class Test():
+    def __init__(self, _id, _data1, _data2):
+        self.id = _id
+        self.data1 = _data1
+        self.data2 = _data2
+
+res = {
+    1:Test(1, "12345", "54321"),
+    2:Test(2, "11111", "aaaaa"),
+    3:Test(3, "ddddd", "qwqwqw")
+}
+
+for val in res.keys():
+    print(res[val].data1)
+
+datetime_min = datetime.datetime(2020, 1, 29, 22, 50, 0)
+timestamp = int(datetime_min.timestamp())
+png_path = r"d:\PYTHON\tests\test1\png"
+file_path = "{}\\dj_286m_{}.png".format(png_path, timestamp)
+print(file_path)
+print(os.path.exists(file_path))
+
+zero = -1.06
+class RiverCrossSection():
+
+    def __init__(self, _left_slope = 5.0, _bottom = 18.0, _right_slope = 5.0, _max_h = 3.6, _zero_bsv = -1.06, _n_roughness = 0.035, _i_bias = 0.00244):
+        # параметры трапеции
+        self._zero_wlevel = _zero_bsv
+        self._trap_a = _left_slope  # ширина левого склона трапеции русла
+        self._trap_b = _bottom  # ширина дна трапеции русла
+        self._trap_c = _right_slope # ширина правого склона трапеции русла
+        self._trap_d = _max_h  # высота трапеции русла
+        if self._trap_d >= 0:
+            self._trap_leftCtg = self._trap_a / self._trap_d  # котангенс левого угла трапеции русла
+            self._trap_rightCtg = self._trap_c / self._trap_d  # котангенс правого угла трапеции русла
+        else:
+            self._trap_leftCtg = 0  # котангенс левого угла трапеции русла
+            self._trap_rightCtg = 0  # котангенс правого угла трапеции русла
+
+        self._i_rb_part = _i_bias  # уклон русла
+        self._n_rb_part = _n_roughness  # шероховатость русла
+
+    # площадь сечения (м^2)
+    def f_trap_area(self, h):
+      return self._trap_b * h + (self._trap_leftCtg + self._trap_rightCtg) * h * h / 2
+
+    # смоченный периметр (м)
+    def f_trap_perimetr(self, h):
+      return self._trap_b + \
+             math.sqrt(self._trap_leftCtg ** 2 + 1) * h + \
+             math.sqrt(self._trap_rightCtg ** 2 + 1) * h
+
+    # гидрологический радиус
+    def f_hydro_r(self, h):
+        return self.f_trap_area(h) / self.f_trap_perimetr(h)
+
+    # скорость потока (м/с)
+    def f_flow_speed(self, h):
+        return self.f_hydro_r(h)**(2./3) * math.sqrt(self._i_rb_part) / self._n_rb_part
+
+    # расход воды (м^3/с)
+    def f_flow_rate(self, h):
+        if h <= 0.:
+            return 0.
+        return self.f_trap_area(h) * self.f_flow_speed(h)
+
+    # расход воды (м^3/с)
+    def f_flow_rate_by_bs_h(self, bs_h):
+        return self.f_flow_rate(bs_h - self._zero_wlevel)
+
+    # уровень воды (м), определяемый по расходу воды (м^3/с)
+    def high_by_flow_rate(self, flow_rate):
+        if flow_rate <= 0.:
+            return 0.
+        return newton_raphson(self.f_flow_rate, flow_rate, 1.)
+
+    # уровень воды (м), определяемый по расходу воды (м^3/с) по балтийской системе высот
+    def bs_water_level(self, flow_rate):
+        return self.high_by_flow_rate(flow_rate) + self._zero_wlevel
+
+
+real34 = loca_data.GetLevel34()
+get_flow = RiverCrossSection()
+min_flow = 100
+max_flow = 0
+for key in real34.keys():
+    real_level = real34[key]
+    #real_level = real_level - zero
+    flow = get_flow.f_flow_rate_by_bs_h(real_level)
+
+    if flow < min_flow:
+        min_flow = flow
+
+    if flow > max_flow:
+        max_flow = flow
+
+    print("{}-{}".format(real_level, flow))
+
+print("{}-{}".format(min_flow, max_flow))
+
+
+datetime_min = datetime.datetime(2020, 1, 29, 22, 50, 0)
+datetime_max = datetime.datetime(2020, 2, 1, 0, 0, 0)
+
+date_diff = datetime_max - datetime_min
+print(date_diff.seconds / 600)
+'''
+
+first_dic = dict(a = "123", b = 1.9, c = 567)
+first_dic1 = dict(a = "124", b = 2.9, c = 1567)
+first_dic2 = dict(a = "125", b = 3.9, c = 2567)
+first_dic3 = dict(a = "126", b = 4.9, c = 3567)
+first_dic35 = None
+first_dic4 = dict(a = "127", b = 5.9, c = 4567)
+secon_dic = dict(aa = "qwe", bb = 0.0, cc = 3214)
+
+
+def GetAllValues(_dict_with_pref):
+    key_store = []
+    value_store = []
+    for dwp_k in _dict_with_pref.keys():
+        dwp = _dict_with_pref[dwp_k]
+        if dwp is not None:
+            for k in dwp.keys():
+                key_store.append(str(dwp_k) + "_" + str(k))
+                value_store.append(str(dwp[k]))
+
+    return key_store, value_store
+
+ks, vs = GetAllValues(dict(fd = first_dic, sd = secon_dic))
+
+#print("\t".join(ks))
+#print("\t".join(vs))
+
+#timestamp = int(_datetime.timestamp())
+#file_path = r"\png\dj_286m_{}.png".format(timestamp)
+
+#print(os.listdir('.\\png\\'))
+
+files = os.listdir('.\\png\\')
+
+for f in files:
+    ts = int(f.replace("dj_286m_","").replace(".png",""))
+    dt = datetime.datetime.fromtimestamp(ts)
+    print(dt)
+
+# 2. Ищем файл и формируем матрицу
+#if not os.path.exists(os.path.abspath(os.curdir) + file_path):
+#    return result