# ШАБЛОН ИЗМЕРИТЕЛЯ
import sys
import os
import time
import datetime
import json
import jsonpickle
import importlib
import urllib.request
from imageio import imread
import redis

import inspect
import math
import numpy as np
import cv2
import copy


currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0,parentdir)

def GetGeoCoordPolygon():
    result = []

    result.append([1, 'p1', 44.4659180457079, 38.6873701016652])
    result.append([2, 'p2', 44.462526525797, 38.68738820185])
    result.append([3, 'p3', 44.4611672309677, 38.6864482585788])
    result.append([4, 'p4', 44.4604862775639, 38.6855047173473])
    result.append([5, 'p5', 44.4598053163473, 38.6845611980494])
    result.append([6, 'p6', 44.4591217206884, 38.6826708654147])
    result.append([7, 'p7', 44.4584409611247, 38.6817273998504])
    result.append([8, 'p8', 44.4577599686841, 38.6807839574362])
    result.append([9, 'p9', 44.455722269564, 38.6798479499985])
    result.append([10, 'p10', 44.454368220996, 38.6808024349038])
    result.append([11, 'p11', 44.4496228632959, 38.6817752912265])
    result.append([12, 'p12', 44.4489471473096, 38.6827259594132])
    result.append([13, 'p13', 44.4482661623925, 38.6817826575606])
    result.append([14, 'p14', 44.4475851696673, 38.6808393776276])
    result.append([15, 'p15', 44.4462258185235, 38.6798998242442])
    result.append([16, 'p16', 44.4441883337288, 38.6789640282683])
    result.append([17, 'p17', 44.4428289675216, 38.6780248866211])
    result.append([18, 'p18', 44.4401131153494, 38.6770929457675])
    result.append([19, 'p19', 44.4394374369127, 38.6780435128605])
    result.append([20, 'p20', 44.4380780614025, 38.6771041539359])
    result.append([21, 'p21', 44.4373970294673, 38.6761610918177])
    result.append([22, 'p22', 44.4360378632821, 38.6752218077959])
    result.append([23, 'p23', 44.435356815724, 38.674278800308])
    result.append([24, 'p24', 44.4346757603643, 38.6733358147249])
    result.append([25, 'p25', 44.4340001124172, 38.6742863364226])
    result.append([26, 'p26', 44.4333244564149, 38.6752368362169])
    result.append([27, 'p27', 44.4326436338529, 38.6742938707564])
    result.append([28, 'p28', 44.430605874432, 38.6733584851322])
    result.append([29, 'p29', 44.429924811167, 38.6724155863542])
    result.append([30, 'p30', 44.4278872616884, 38.6714806217147])
    result.append([31, 'p31', 44.4265278304627, 38.6705415986733])
    result.append([32, 'p32', 44.4251683913241, 38.6696026190191])
    result.append([33, 'p33', 44.4231308167331, 38.6686675130155])
    result.append([34, 'p34', 44.4217713616748, 38.6677286307943])
    result.append([35, 'p35', 44.4210902515103, 38.666785939058])
    result.append([36, 'p36', 44.4204091344697, 38.6658435832524])
    result.append([37, 'p37', 44.4183715280345, 38.664908682866])
    result.append([38, 'p38', 44.4176876060369, 38.6630195998409])
    result.append([39, 'p39', 44.417006456891, 38.6620770283373])
    result.append([40, 'p40', 44.415646946975, 38.6611383963008])
    result.append([41, 'p41', 44.4149660072983, 38.6601958780638])
    result.append([42, 'p42', 44.4142848357004, 38.6592536970173])
    result.append([43, 'p43', 44.4136036553782, 38.6583112238388])
    result.append([44, 'p44', 44.4129224672666, 38.6573687725403])
    result.append([45, 'p45', 44.412241271366, 38.6564263431209])
    result.append([46, 'p46', 44.4115600676771, 38.65548393558])
    result.append([47, 'p47', 44.4101978629559, 38.6535994987889])
    result.append([48, 'p48', 44.4095166359077, 38.6526571568713])
    result.append([49, 'p49', 44.4074786945892, 38.6517228875476])
    result.append([50, 'p50', 44.4068032226682, 38.652673214561])
    result.append([51, 'p51', 44.4061279677586, 38.6536235183741])
    result.append([52, 'p52', 44.4040957710749, 38.6545814713852])
    result.append([53, 'p53', 44.4013797154905, 38.653651535034])
    result.append([54, 'p54', 44.4007013612607, 38.6536555370402])
    result.append([55, 'p55', 44.4000201340224, 38.6527133462321])
    result.append([56, 'p56', 44.3993388990004, 38.6517711772886])
    result.append([57, 'p57', 44.3986547598908, 38.649882859824])
    result.append([58, 'p58', 44.3973838898507, 38.6458096714798])
    result.append([59, 'p59', 44.3949781541395, 38.644309245034])
    result.append([60, 'p60', 44.3926372685399, 38.6452801897078])
    result.append([61, 'p61', 44.3899600151494, 38.648405704003])
    result.append([62, 'p62', 44.3885967954375, 38.6512839632378])
    result.append([63, 'p63', 44.3882077602254, 38.6549535962662])
    result.append([64, 'p64', 44.3889600490249, 38.6579787433921])
    result.append([65, 'p65', 44.3901093496205, 38.6599652249848])
    result.append([66, 'p66', 44.3919030825734, 38.6603293544403])
    result.append([67, 'p67', 44.393259793998, 38.6603215069267])
    result.append([68, 'p68', 44.3946190897309, 38.6612597665095])
    result.append([69, 'p69', 44.3946302501719, 38.6650441932705])
    result.append([70, 'p70', 44.3939518943338, 38.6650480627273])
    result.append([71, 'p71', 44.393965667335, 38.669778230694])
    result.append([72, 'p72', 44.3898957537269, 38.6698011154993])
    result.append([73, 'p73', 44.3871852820214, 38.6707623564453])
    result.append([74, 'p74', 44.3851531580966, 38.6717197169025])
    result.append([75, 'p75', 44.3831207992559, 38.6726766981676])
    result.append([76, 'p76', 44.3817667903306, 38.6736301581041])
    result.append([77, 'p77', 44.3810911310979, 38.6745798164272])
    result.append([78, 'p78', 44.3811045063608, 38.679308953279])
    result.append([79, 'p79', 44.380426373011, 38.6793126549743])
    result.append([80, 'p80', 44.3797533098955, 38.6812080952785])
    result.append([81, 'p81', 44.3783965924026, 38.6812154567928])
    result.append([82, 'p82', 44.3770372310579, 38.6802769926491])
    result.append([83, 'p83', 44.3749997278075, 38.6793422724467])
    result.append([84, 'p84', 44.3729673011012, 38.6802991368143])
    result.append([85, 'p85', 44.3709350905301, 38.68125593342])
    result.append([86, 'p86', 44.3648327094138, 38.6822346685803])
    result.append([87, 'p87', 44.3641517143432, 38.68129271776])
    result.append([88, 'p88', 44.3614411309088, 38.6822530013806])
    result.append([89, 'p89', 44.3594034137061, 38.6813184587325])
    result.append([90, 'p90', 44.3512608836489, 38.6804171605163])
    result.append([91, 'p91', 44.3485450112869, 38.679486536919])
    result.append([92, 'p92', 44.347185631022, 38.6785488989658])
    result.append([93, 'p93', 44.3458264670498, 38.6776109893391])
    result.append([94, 'p94', 44.344469741943, 38.6776184251181])
    result.append([95, 'p95', 44.3431130165116, 38.6776258603739])
    result.append([96, 'p96', 44.3397187551914, 38.676699220324])
    result.append([97, 'p97', 44.3376812114532, 38.6757652098747])
    result.append([98, 'p98', 44.3342867073089, 38.6748387622225])
    result.append([99, 'p99', 44.3336056493193, 38.673897384431])
    result.append([100, 'p100', 44.3329302048925, 38.6748462576814])
    result.append([101, 'p101', 44.3322545273675, 38.6757951103904])
    result.append([102, 'p102', 44.3315815124541, 38.6776890352354])
    result.append([103, 'p103', 44.3302274466335, 38.6786415377922])
    result.append([104, 'p104', 44.3288682801716, 38.6777038940574])
    result.append([105, 'p105', 44.3281925781365, 38.6786526483394])
    result.append([106, 'p106', 44.3288788826607, 38.6814837832314])
    result.append([107, 'p107', 44.3288893600735, 38.685263674471])
    result.append([108, 'p108', 44.3295674999582, 38.6852600479882])
    result.append([109, 'p109', 44.3302536418193, 38.6880916404546])
    result.append([110, 'p110', 44.3309371524797, 38.689978214465])
    result.append([111, 'p111', 44.32948445695, 38.694307429264])
    result.append([112, 'p112', 44.3279636912813, 38.6957090761143])
    result.append([113, 'p113', 44.3266306472892, 38.6960478051907])
    result.append([114, 'p114', 44.325535803427, 38.696385290125])
    result.append([115, 'p115', 44.3241567013882, 38.6973215091314])
    result.append([116, 'p116', 44.3231578355771, 38.6979239171256])
    result.append([117, 'p117', 44.3224455097053, 38.6987902881019])
    result.append([118, 'p118', 44.3221617645993, 38.6995880888015])
    result.append([119, 'p119', 44.3221490564382, 38.7013633576442])
    result.append([120, 'p120', 44.3235131656076, 38.7041910612533])
    result.append([121, 'p121', 44.3235277067607, 38.7098605507166])
    result.append([122, 'p122', 44.3255625828514, 38.7098505208004])
    result.append([123, 'p123', 44.3269217131372, 38.710788854888])
    result.append([124, 'p124', 44.3276000799235, 38.7107855216337])
    result.append([125, 'p125', 44.3282808355056, 38.7117272321884])
    result.append([126, 'p126', 44.3296397248837, 38.7126656538046])
    result.append([127, 'p127', 44.3303204648654, 38.7136074187004])
    result.append([128, 'p128', 44.3316795635819, 38.7145459149991])
    result.append([129, 'p129', 44.3330386535959, 38.7154841409492])
    result.append([130, 'p130', 44.3337191450892, 38.7164259938451])
    result.append([131, 'p131', 44.3343998538638, 38.7173678674429])
    result.append([132, 'p132', 44.3350782201477, 38.7173646091641])
    result.append([133, 'p133', 44.3364372872816, 38.7183032677223])
    result.append([134, 'p134', 44.3371179804205, 38.7192452064669])
    result.append([135, 'p135', 44.3384768067379, 38.7201839419164])
    result.append([136, 'p136', 44.3405142152876, 38.7211191903243])
    result.append([137, 'p137', 44.3432297568922, 38.7220516127325])
    result.append([138, 'p138', 44.3445887841732, 38.7229905088861])
    result.append([139, 'p139', 44.3466259437376, 38.7239262654469])
    result.append([140, 'p140', 44.3493416851586, 38.7248589120046])
    result.append([141, 'p141', 44.3500177689534, 38.7239103441836])
    result.append([142, 'p142', 44.3513833506936, 38.7276853271601])
    result.append([143, 'p143', 44.352742330372, 38.7286244829675])
    result.append([144, 'p144', 44.353427398491, 38.7314577007613])
    result.append([145, 'p145', 44.3541079821704, 38.7324000634193])
    result.append([146, 'p146', 44.3534340307103, 38.7342937363605])
    result.append([147, 'p147', 44.3527600483958, 38.73618767969])
    result.append([148, 'p148', 44.3520838627374, 38.7371361512301])
    result.append([149, 'p149', 44.3527643998366, 38.7380785583696])
    result.append([150, 'p150', 44.3534470846256, 38.7399661241458])
    result.append([151, 'p151', 44.3534577482993, 38.7446933782777])
    result.append([152, 'p152', 44.3541361138321, 38.7446904330586])
    result.append([153, 'p153', 44.3548165879432, 38.7456326469941])
    result.append([154, 'p154', 44.3554968298762, 38.7465751974038])
    result.append([155, 'p155', 44.3561835235385, 38.7503542541759])
    result.append([156, 'p156', 44.3568660056387, 38.7522420729526])
    result.append([157, 'p157', 44.3575464181079, 38.7531847318699])
    result.append([158, 'p158', 44.3589051882192, 38.7541245757442])
    result.append([159, 'p159', 44.3595833285202, 38.7541217397253])
    result.append([160, 'p160', 44.369077945145, 38.7531363106995])
    result.append([161, 'p161', 44.3697583492409, 38.7540791752275])
    result.append([162, 'p162', 44.3704387455217, 38.7550220615865])
    result.append([163, 'p163', 44.3731519761353, 38.7550107509623])
    result.append([164, 'p164', 44.3751850345083, 38.7540564649119])
    result.append([165, 'p165', 44.3792529481289, 38.7530935614664])
    result.append([166, 'p166', 44.3833249401503, 38.7540223879203])
    result.append([167, 'p167', 44.3846836981887, 38.7549626609326])
    result.append([168, 'p168', 44.3853600272727, 38.7540138659525])
    result.append([169, 'p169', 44.3873989475618, 38.755897339966])
    result.append([170, 'p170', 44.3894360507177, 38.7568345987727])
    result.append([171, 'p171', 44.3907945594397, 38.7577750350939])
    result.append([172, 'p172', 44.3914769180526, 38.7596643649869])
    result.append([173, 'p173', 44.3921552798197, 38.7596615887955])
    result.append([174, 'p174', 44.3935139899268, 38.7606021329726])
    result.append([175, 'p175', 44.3948724669899, 38.7615427214876])
    result.append([176, 'p176', 44.3975839330654, 38.7605855390979])
    result.append([177, 'p177', 44.39826229415, 38.7605827729585])
    result.append([178, 'p178', 44.3989443809502, 38.7624723765111])
    result.append([179, 'p179', 44.3996305491874, 38.7662541007363])
    result.append([180, 'p180', 44.4003127673058, 38.7681438136485])
    result.append([181, 'p181', 44.4003297345922, 38.7766590522782])
    result.append([182, 'p182', 44.4010080961192, 38.7766564716005])
    result.append([183, 'p183', 44.4016883038569, 38.7776001205472])
    result.append([184, 'p184', 44.4044015239342, 38.777589841155])
    result.append([185, 'p185', 44.4057563994695, 38.7766384051691])
    result.append([186, 'p186', 44.4064329059126, 38.7756895175987])
    result.append([187, 'p187', 44.4091442609228, 38.7747327983639])
    result.append([188, 'p188', 44.4098207515958, 38.7737841479511])
    result.append([189, 'p189', 44.4111755937757, 38.7728325358846])
    result.append([190, 'p190', 44.411851842614, 38.7718835175765])
    result.append([191, 'p191', 44.4138850280381, 38.7709291805253])
    result.append([192, 'p192', 44.4152398451879, 38.7699774363493])
    result.append([193, 'p193', 44.4159160696132, 38.7690283193127])
    result.append([194, 'p194', 44.4165925117321, 38.7680794935348])
    result.append([195, 'p195', 44.4165768874551, 38.7605080549689])
    result.append([196, 'p196', 44.4179336050055, 38.7605025171373])
    result.append([197, 'p197', 44.424040585978, 38.761424182107])
    result.append([198, 'p198', 44.4253950956009, 38.7604720539302])
    result.append([199, 'p199', 44.4260714643025, 38.7595226619368])
    result.append([200, 'p200', 44.4281045399161, 38.7585676634988])
    result.append([201, 'p201', 44.42742014509, 38.7557308395269])
    result.append([202, 'p202', 44.4274078578203, 38.7500512955488])
    result.append([203, 'p203', 44.4267295007449, 38.7500541862995])
    result.append([204, 'p204', 44.429438544454, 38.74814927275])
    result.append([205, 'p205', 44.4307973412196, 38.7490901438296])
    result.append([206, 'p206', 44.4355435263485, 38.7481230525118])
    result.append([207, 'p207', 44.4362197904926, 38.7471733537286])
    result.append([208, 'p208', 44.4368897011953, 38.7433835608333])
    result.append([209, 'p209', 44.4382419168918, 38.741483989634])
    result.append([210, 'p210', 44.438918125229, 38.7405341706792])
    result.append([211, 'p211', 44.4395943255354, 38.739584329815])
    result.append([212, 'p212', 44.4402705178104, 38.7386344670407])
    result.append([213, 'p213', 44.4409445243153, 38.7367380361829])
    result.append([214, 'p214', 44.44162046756, 38.7357881197551])
    result.append([215, 'p215', 44.4416049440028, 38.7291603387457])
    result.append([216, 'p216', 44.4429616522722, 38.7291540705923])
    result.append([217, 'p217', 44.4436377569745, 38.72820403318])
    result.append([218, 'p218', 44.4449922073847, 38.7272508174742])
    result.append([219, 'p219', 44.4470247777886, 38.7262943909821])
    result.append([220, 'p220', 44.4483792119631, 38.7253413899545])
    result.append([221, 'p221', 44.4497336369951, 38.7243880305646])
    result.append([222, 'p222', 44.4504071788205, 38.7224908171928])
    result.append([223, 'p223', 44.4517615793258, 38.7215373588195])
    result.append([224, 'p224', 44.4524376190424, 38.7205870907049])
    result.append([225, 'p225', 44.4531136514879, 38.7196371148845])
    result.append([226, 'p226', 44.455146154221, 38.7186802906937])
    result.append([227, 'p227', 44.4558221695395, 38.717729934653])
    result.append([228, 'p228', 44.4564958244093, 38.7158324467365])
    result.append([229, 'p229', 44.4578430397905, 38.7120376546159])
    result.append([230, 'p230', 44.4585189992017, 38.7110871783148])
    result.append([231, 'p231', 44.4591947254985, 38.7101366811957])
    result.append([232, 'p232', 44.4598658307401, 38.7072921477408])
    result.append([233, 'p233', 44.4605393110568, 38.7053944095129])
    result.append([234, 'p234', 44.4612152145413, 38.7044438129466])
    result.append([235, 'p235', 44.4618911099747, 38.7034931944457])
    result.append([236, 'p236', 44.4625595624527, 38.6997012480591])
    result.append([237, 'p237', 44.4625495390238, 38.695912737085])
    result.append([238, 'p238', 44.4632276636566, 38.6959092169409])
    result.append([239, 'p239', 44.4639034874546, 38.6949584675698])
    result.append([240, 'p240', 44.4645793031971, 38.6940076962611])
    result.append([241, 'p241', 44.465252561378, 38.6921096535156])
    result.append([242, 'p242', 44.4652422856561, 38.6883209710641])
    result.append([243, 'p243', 44.4659206345502, 38.6883173615017])

    return result


def GetPNG():

    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))

    if time_result is None or len(time_result) < 1:
        print("time result is empty")
        return

    itime = time_result[0]


    for itime in time_result:
        try:
            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")
            dirpath = os.getcwd() + r'\new_png'
            #dt = datetime.datetime.fromtimestamp(t=itime, tz=datetime.timezone.utc)
            urllib.request.urlretrieve(url = png_data_url, filename = dirpath + r'\dj_286m_{time}.png'.format(time = itime))
            print("data for time={dt} write....".format(dt=itime))
        except Exception as e:
            print("ERROR::{er}".format(er=e))

class Measurer():

    def get_lan_scale(self, geo_lan):
        result = -1.0
        store = {}
        store[0.0] = 111321.0
        store[1.0] = 111305.0
        store[2.0] = 111254.0
        store[3.0] = 111170.0
        store[4.0] = 111052.0
        store[5.0] = 110901.0
        store[6.0] = 110716.0
        store[7.0] = 110497.0
        store[8.0] = 110245.0
        store[9.0] = 109960.0
        store[10.0] = 109641.0
        store[11.0] = 109289.0
        store[12.0] = 108904.0
        store[13.0] = 108487.0
        store[14.0] = 108036.0
        store[15.0] = 107552.0
        store[16.0] = 107036.0
        store[17.0] = 106488.0
        store[18.0] = 105907.0
        store[19.0] = 105294.0
        store[20.0] = 104649.0
        store[21.0] = 103972.0
        store[22.0] = 103264.0
        store[23.0] = 102524.0
        store[24.0] = 101753.0
        store[25.0] = 100952.0
        store[26.0] = 100119.0
        store[27.0] = 99257.0
        store[28.0] = 98364.0
        store[29.0] = 97441.0
        store[30.0] = 96488.0
        store[31.0] = 95506.0
        store[32.0] = 94495.0
        store[33.0] = 93455.0
        store[34.0] = 92386.0
        store[35.0] = 91290.0
        store[36.0] = 90165.0
        store[37.0] = 89013.0
        store[38.0] = 87834.0
        store[39.0] = 86628.0
        store[40.0] = 85395.0
        store[41.0] = 84137.0
        store[42.0] = 82852.0
        store[43.0] = 81542.0
        store[44.0] = 80208.0
        store[45.0] = 78848.0
        store[46.0] = 77465.0
        store[47.0] = 76057.0
        store[48.0] = 74627.0
        store[49.0] = 73173.0
        store[50.0] = 71697.0
        store[51.0] = 70199.0
        store[52.0] = 68679.0
        store[53.0] = 67138.0
        store[54.0] = 65577.0
        store[55.0] = 63995.0
        store[56.0] = 62394.0
        store[57.0] = 60773.0
        store[58.0] = 59134.0
        store[59.0] = 57476.0
        store[60.0] = 55801.0
        store[61.0] = 54108.0
        store[62.0] = 52399.0
        store[63.0] = 50674.0
        store[64.0] = 48933.0
        store[65.0] = 47176.0
        store[66.0] = 45405.0
        store[67.0] = 43621.0
        store[68.0] = 41822.0
        store[69.0] = 40011.0
        store[70.0] = 38187.0
        store[71.0] = 36352.0
        store[72.0] = 34505.0
        store[73.0] = 32647.0
        store[74.0] = 30780.0
        store[75.0] = 28902.0
        store[76.0] = 27016.0
        store[77.0] = 25122.0
        store[78.0] = 23219.0
        store[79.0] = 21310.0
        store[80.0] = 19394.0
        store[81.0] = 17472.0
        store[82.0] = 15544.0
        store[83.0] = 13612.0
        store[84.0] = 11675.0
        store[85.0] = 9735.0
        store[86.0] = 7791.0
        store[87.0] = 5846.0
        store[88.0] = 3898.0
        store[89.0] = 1949.0
        store[90.0] = 0.0

        abs_lan = math.fabs(geo_lan)
        mantiss_lan, flan = math.modf(abs_lan)
        max_lan = store[flan]
        min_lan = store[flan + 1]
        result = min_lan
        result = result + (max_lan - min_lan) * mantiss_lan
        return result

    def get_pixelsize(self, scale):
        result = 0
        store = {}
        store[0] = 156543.0339
        store[1] = 78271.51696
        store[2] = 39135.75848
        store[3] = 19567.87924
        store[4] = 9783.939620
        store[5] = 4891.969810
        store[6] = 2445.984905
        store[7] = 1222.992452
        store[8] = 611.4962263
        store[9] = 305.7481131
        store[10] = 152.8740566
        store[11] = 76.43702829
        store[12] = 38.21851414
        store[13] = 19.10925707
        store[14] = 9.554728536
        store[15] = 4.777314268
        store[16] = 2.388657133
        store[17] = 1.194328566
        store[18] = 0.597164263
        store[19] = 0.298582142
        store[20] = 0.149291071
        store[21] = 0.074645535
        store[22] = 0.037322768
        store[23] = 0.018661384

        result = store[scale]
        return result

    def get_reg_type_info(self):
        result = dict(
            Name = "Измеритель осадков ДМРЛ",
            Description = r"Получает матрицу осадков ДМРЛ и рассчитывает средние осадки в мм/10 минут",
            GUID = "99921f68-e613-48e4-bae5-08f6b1f06ff8",
            Return_Data_Type_GUID = None,
            Default_Parameters = dict(
                geo_lan = 0.0,
                geo_lon = 0.0,
                size = 256,
                scale = 0.0,
                polygon = [],
                radar_a = 200,
                radar_n = 1.6,

            ),
            Default_Dynamic_Parameters = dict(k_reserv_volume_store = []),
            Default_Connections = dict(prec_meas_correction_guid = ""),
            Default_Station_Parameters = dict(geo_lan_lon_corr_station = ""),
            Module_Name = "mu_dmrl_precipitation"
        )

        return result

    def initialize(self,
        _id=None,
        _Name=None,
        _GUID=None,
        _Description=None,
        _Parameters = dict(
            geo_lan = 44.417242,
            geo_lon = 38.72287,
            scale = 10,
            size = 256,
            polygon = GetGeoCoordPolygon(),
            radar_a = 200,
            radar_n = 1.6),
        _Dynamic_Parameters = dict(k_reserv_volume_store = []),
        _Connections = dict(prec_meas_correction_guid = ""),
        _Station_Parameters = dict(geo_lan_lon_corr_station = '{"lan": 44.417242, "lon": 38.72287}'),
        _Is_Inherited = False,
        _Is_Bus_Sender = False,
        _Is_Work = False,
        _Save_Addition_Info = False):
        self.id = _id
        self.Name = _Name
        self.GUID = _GUID
        self.Description = _Description
        self.Parameters = _Parameters
        self.Dynamic_Parameters = _Dynamic_Parameters
        self.Connections = _Connections
        self.Station_Parameters = _Station_Parameters
        self.Is_Inherited = _Is_Inherited
        self.Is_Bus_Sender = _Is_Bus_Sender
        self.Is_Work = _Is_Work
        self.Save_Addition_Info = _Save_Addition_Info

        self.Return_Data_Type = None
        self.Current_TS_Is_Ready = False
        self.Current_TS = None

        # ПАРАМЕТРИЗАЦИЯ
        self.geo_lan = self.Parameters["geo_lan"]         # ГеоКоординаты центра (широта), число  - CALC FROM POLYGON
        self.geo_lon = self.Parameters["geo_lon"]         # ГеоКоординаты (долгота), число        - CALC FROM POLYGON
        self.size = self.Parameters["size"]               # Размеры квадратной картинки, пикселей по широте и высоте - CONST=256
        self.scale = self.Parameters["scale"]               # Размеры квадратной картинки, пикселей по широте и высоте - CONST=256
        self.lan_scale = self.get_lan_scale(self.geo_lan)     # Длина дуги по широте (метров на градус)   - CALC
        self.lon_scale = 111162.6                           # Длина дуги по долготе (метров на градус)  - CALC
        self.pixel_size = self.get_pixelsize(self.scale)   # Масштаб изображения
        self.polygon = self.Parameters["polygon"]         # Водосборный полигон, ([[id, name, lan, lon], [id, name, lan, lon], [id, name, lan, lon]...]) - INPUT
        self.radar_a = self.Parameters["radar_a"]         # Параметр А для расчёта осадков по ДБЗ - INPUT
        self.radar_n = self.Parameters["radar_n"]         # Параметр Н для расчета осадков по ДБЗ - INPUT

        self.corr_geo_lan = 0.0 # Координаты АГК для корректировки (широта) - см. set_station_parameter
        self.corr_geo_lon = 0.0 # Координаты АГК для корректировки (долгота) - см. set_station_parameter

        self.xy_poligon = []                    # Полигон в виде массива линейных координат (х, у) - CALC
        self.grad_by_px_lon = 0                 # Количество градусов в одном пикселе по долготе - CALC
        self.grad_by_px_lan = 0                 # Количество градусов в одном пикселе по широте - CALC
        self.min_lon = 0                        # Минимальная долгота картинки - CALC
        self.min_lan = 0                        # Минимальная широта картинки - CALC
        self.max_lon = 0                        # Максимальная долгота картинки - CALC
        self.max_lan = 0                        # Максимальная широта картинки - CALC
        self.corr_x = -1                        # Координаты корректировочного осадкомера (x)
        self.corr_y = -1                        # Координаты корректировочного осадкомера (y)
        self.squere = 0.0                       # Общая площадь водосбора

        self.grad_by_px_lon = self.pixel_size / self.lon_scale  # Количество градусов в одном пикселе по долготе
        self.grad_by_px_lan = self.pixel_size / self.lan_scale  # Количество градусов в одном пикселе по широте
        self.min_lon = self.geo_lon - ((self.size / 2) * self.grad_by_px_lon) # Минимальная долгота картинки
        self.min_lan = self.geo_lan - ((self.size / 2) * self.grad_by_px_lan) # Минимальная широта картинки
        self.max_lon = self.geo_lon + ((self.size / 2) * self.grad_by_px_lon) # Максимальная долгота картинки
        self.max_lan = self.geo_lan + ((self.size / 2) * self.grad_by_px_lan) # Максимальная широта картинки

        # Параметры для корректировки
        self.k_reserv_volume_store = dict(max_prec = -500.0, values = {})   # Резервное хранилище истории для поиска объёмов при отсутствии данных от ДМРЛ
        self.corr_x = 0 # см. set_station_parameter
        self.corr_y = 0 # см. set_station_parameter

        # ПЕРЕМЕННЫЕ ДЛЯ ХРАНЕНИЯ ДАННЫХ ДЛЯ РАСЧЕТА
        self.varCorrectionPrec = None           # Осадки для корректировки
        self.varMatrix = None                   # Матрица осадков по данным ДМРЛ
        self.varBaseMatrix = None               # Базовя матрица

        # Генерируем полигон вида (х, у)
        for point in self.polygon:
            xy_point = self.GetXYPoint(point[3], point[2])
            if xy_point["x"] != -1 and xy_point["y"] != -1:
                self.xy_poligon.append((xy_point["x"], xy_point["y"] ))

        # Считаем площадь водосбора
        img = np.zeros((self.size,self.size,4), np.uint8)

        for yy in img:
                for xx in yy:
                    xx[0] = 100
                    xx[1] = 100
                    xx[2] = 100
                    xx[3] = 100

        img_mask = np.zeros(img.shape, dtype=np.uint8)
        img_roi_corners = np.array([self.xy_poligon], 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)

        pcx_square_count = 0
        counter = 0

        for yy in img_masked_image:
                for xx in yy:
                    counter = counter + 1
                    if xx[0] == 100:
                        pcx_square_count = pcx_square_count + 1

        self.squere = self.pixel_size * self.pixel_size * pcx_square_count

        return

    # Получить осадки по значению dbZ
    def GetPrecByDBZ(self, _dbz):
        result = 0

        if _dbz == 0 or _dbz > 127:
            return result

        step1 = (_dbz - 32) / 10
        step2 = 10 ** step1
        step3 = step2 / self.radar_a
        step4 = step3 ** (1.0/self.radar_n)
        result = step4
        return result

    # Получить точку (х, у) точке полигона в географических координатах
    def GetXYPoint(self, _geo_lon, _geo_lan):

        if _geo_lan < self.min_lan or _geo_lan > self.max_lan:
            return dict(x = 0, y = -1)

        if _geo_lon < self.min_lon or _geo_lon > self.max_lon:
            return dict(x = -1, y = 0)

        lon_delta = _geo_lon - self.min_lon
        lan_delta = _geo_lan - self.max_lan

        y_delta = lan_delta * self.lan_scale
        x_delta = lon_delta * self.lon_scale

        my = y_delta // self.pixel_size
        mx = x_delta // self.pixel_size

        result = dict(x = abs(mx), y = abs(my))
        return result

    # Получить матрицу (из файла или онлайн)
    def GetMatrix(self, _datetime):

        result = None
        base_matrix = None
        file_path = r"d:\PYTHON\WebForecastDevelopment\png_06\dj_286m_1591083600.png"
        #result = imread(os.path.abspath(os.curdir) + file_path)
        result = imread(file_path)
        #base_matrix = imread(os.path.abspath(os.curdir) + file_path)
        base_matrix = imread(file_path)

        '''
        result = None
        base_matrix = None

        # Для web-режима
        # Определяем текущий тайм-слот
        current_ts_ts = _datetime.replace(tzinfo=datetime.timezone.utc).timestamp()

        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:
            return result, None

        img = None

        try:
            png_data_url = 'https://tilecache.rainviewer.com/v2/radar/{time}/{size}/{scale}/{lan}/{lon}/0/0_0.png'.format(
                time=int(current_ts_ts),
                size = self.size,
                scale = self.scale,
                lan=self.geo_lan,
                lon=self.geo_lon)

            img = imread(png_data_url)
        except:
            return result, None

        if img is not None:
            result = img
            base_matrix = copy.deepcopy(result)

        if result is not None:
            try:
                mask = np.zeros(result.shape, dtype=np.uint8)
                roi_corners = np.array([self.xy_poligon], dtype=np.int32)
                l_shape = len(result.shape)
                channel_count = result.shape[l_shape - 1]                             # 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(result, mask)
                result = masked_image
            except(BaseException):
                return result, None
        '''
        return result, base_matrix

    # Получить данные по осадкам при отсутствии данных от ДМРЛ
    def GetReservDataByPrec(self, _prec_value):
        result = 0.0

        x1 = -1.0
        x2 = -1.0
        y1 = -1.0
        y2 = -1.0
        u_sort_keys = sorted(self.k_reserv_volume_store["values"].keys(), reverse=True)
        sort_keys = sorted(self.k_reserv_volume_store["values"].keys(), reverse=False)

        if _prec_value > self.k_reserv_volume_store["max_prec"]:
            x1 = u_sort_keys[1]
            x2 = u_sort_keys[0]
        else:
            if _prec_value in sort_keys:
                result = self.k_reserv_volume_store["values"][_prec_value]["volume"]
                return result
            else:
                counter = -1
                for key in sort_keys:
                    if key > _prec_value:
                        x1 = sort_keys[counter]
                        x2 = key
                        break
                    counter = counter + 1

        y1 = self.k_reserv_volume_store["values"][x1]["volume"]
        y2 = self.k_reserv_volume_store["values"][x2]["volume"]

        result = ((x2 * y1 - x1 * y2) / (x2 - x1)) - (y1 - y2) * _prec_value
        result = (((y2-y1)/(x2-x1)) * (_prec_value - x1)) + y1

        if result < 0.0:
            result = 0.0

        return result

    # Добавить в историю резервных коэффициентов новое значение
    def SetNewReservKoefficient(self, _prec, _volume):

        if _prec == 0 and _volume == 0:
            return

        if _prec > self.k_reserv_volume_store["max_prec"]:
            self.k_reserv_volume_store["max_prec"] = _prec

        # 1. Если такого показателя осадков нет
        if _prec not in self.k_reserv_volume_store["values"].keys():
            self.k_reserv_volume_store["values"][_prec] = dict(volume = _volume, counter = 1)
            return

        if _prec in self.k_reserv_volume_store["values"].keys():
            ex_volume = self.k_reserv_volume_store["values"][_prec]["volume"]
            ex_counter =  self.k_reserv_volume_store["values"][_prec]["counter"]
            new_volume = ((ex_volume * ex_counter) + _volume) / (ex_counter + 1)
            self.k_reserv_volume_store["values"][_prec]["volume"] = new_volume
            self.k_reserv_volume_store["values"][_prec]["counter"] = ex_counter + 1
            return

        return

    def get_station_parameter_list(self):
        result = []
        result.append(self.Station_Parameters["geo_lan_lon_corr_station"])
        return result

    def set_station_parameters(self, params): #params - словарь типа ГУИД - значение
        for guid in params:
            if guid == self.Station_Parameters["geo_lan_lon_corr_station"]:
                value = params[guid]
                self.corr_geo_lan = value["lan"] # Координаты АГК для корректировки (широта) - см. set_station_parameter
                self.corr_geo_lon = value["lon"] # Координаты АГК для корректировки (долгота) - см. set_station_parameter
                xy_val = self.GetXYPoint(self.corr_geo_lon, self.corr_geo_lan)
                self.corr_x = xy_val['x']
                self.corr_y = xy_val['y']

    def set_parameters(self, _stat_paramms, _dym_params, _connections, _station_params):
        if _dym_params is not None:
            self.k_reserv_volume_store = _dym_params["k_reserv_volume_store"]

    def get_connections_list(self):
        result = []
        result.append(self.Connections["prec_meas_correction_guid"])
        return result

    def get_result(self):

        result = None
        _prec = self.varCorrectionPrec

        matrix = self.varMatrix
        base_matrix = self.varBaseMatrix

        # 2. Если ДМРЛ нет, но есть осадки
        # 3-4. Если есть ДМРЛ и есть (или нет) осадков с АГК - ОБЫЧНЫЙ АЛГОРИТМ
        # Определяем коэффициент корреляции, если оба значения есть и отличны от нуля
        cur_prec_value = 0.0
        dmrl_prec = -1.0
        k_point_correction = 1.0

        if _prec is not None:
            cur_prec_value = float(_prec["data"]["sum"])
            value = base_matrix[int(self.corr_y)][int(self.corr_x)][0]
            dmrl_prec = self.GetPrecByDBZ(value)
            dmrl_prec = dmrl_prec / 6

            if dmrl_prec > 0 and cur_prec_value > 0:
                k_point_correction = cur_prec_value / dmrl_prec

        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 * 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

        self.SetNewReservKoefficient(cur_prec_value, vol_water)

        # Формирование упрощённой матрицы
        simple_matrix = []
        sm_iteratior = -1
        all_pixels_sum = 0
        for yy in matrix:
            sm_iteratior = sm_iteratior + 1
            simple_matrix.append([])
            for xx in yy:
                simple_matrix[sm_iteratior].append(int(xx[0]))
                all_pixels_sum = all_pixels_sum + int(xx[0])

        if all_pixels_sum == 0:
            simple_matrix = []

        result = dict(
            reg_inf = dict(time = self.Current_TS, measurer_uuid  = self.GUID, station_uuid  = ""),
            data = dict(
                period = 600,
                sum = round((vol_water * 1000 / self.squere),3),
                intensity = (vol_water * 1000 * 6 / self.squere),
                type = 10),
                additional_info = dict(matrix=[1]))

        self.Current_TS_Is_Ready = True
        self.varMatrix = None
        self.varBaseMatrix = None
        self.varCorrectionPrec = None
        return result
########################################################################
    # Задаём новый тайм-слот
    def set_new_time_slot(self, _ts):
        result = None
        if self.Current_TS_Is_Ready == False:
            if self.is_ready_to_calculation() == True:
                result = self.get_result()
            else:
                if self.varCorrectionPrec is not None:
                    var = self.GetReservDataByPrec(float(self.varCorrectionPrec["data"]["sum"]))
                    var = round(var, 3)
                    result = dict(
                        reg_inf = dict(time = _ts, measurer_uuid  = self.GUID, station_uuid  = ""),
                        data = dict(
                            period = 600,
                            sum = round((var * 1000 / self.squere),3),
                            intensity = (var * 1000 * 6 / self.squere),
                            type = 10),
                        additional_info = dict(matrix = [0]))
                else:
                    # Задаём псевдо-осадки (отрицательные) - корректировка в этом случае отсутствует
                    self.varCorrectionPrec = dict(data=dict(sum=-1.0))
                    result = self.get_result()

        self.varMatrix = None
        self.varBaseMatrix = None
        self.varCorrectionPrec = None
        self.Current_TS = _ts
        self.Current_TS_Is_Ready = False

        return result

    # Возвращает ЛОЖЬ или ПРАВДУ
    def is_ready_to_calculation(self):
        self.varMatrix, self.varBaseMatrix = self.GetMatrix(self.Current_TS)
        return True

    #Возвращает РЕЗУЛЬТАТ или NONE
    def set_value(self, _input_value):
        result = None
        _Default_Value = dict(
            reg_inf = dict(time = None, measurer_uuid  = None, station_uuid  = None),
            data = dict(period = 0, sum = 0.3, intensity = 0.0, type = 0),
            additional_info = dict())
        self.varCorrectionPrec = _Default_Value

        if self.is_ready_to_calculation() == True:
            var = self.get_result()
            if var is not None:
                result = var

        return result

#GetPNG()

test = Measurer()
test.initialize()
test.set_station_parameters(dict(geo_lan_lon_corr_station = '{"lan": 44.417242, "lon": 38.72287}'))
test.set_value(None)