Index: /trunk/data/gpx/brown2green.txt =================================================================== --- /trunk/data/gpx/brown2green.txt (revision 11431) +++ /trunk/data/gpx/brown2green.txt (revision 11431) @@ -0,0 +1,15 @@ +# License: GPL. For details,see LICENSE file. +# +# diverging brown to green, designed by http://colorbrewer2.org/ +# +# color map must start at first line without comment +# +0,0,0 +1,102,9 +53,151,143 +128,205,193 +199,234,229 +246,232,195 +223,194,125 +191,129,45 +140,81,10 Index: /trunk/data/gpx/inferno.txt =================================================================== --- /trunk/data/gpx/inferno.txt (revision 11431) +++ /trunk/data/gpx/inferno.txt (revision 11431) @@ -0,0 +1,267 @@ +# License: GPL. For details,see LICENSE file. +# +# based on color map aka inferno with adjustment to more brighter values +# Used to reconstruct the colormap in viscm (http://bids.github.io/colormap/) +# parameters = {'xp': [-2.059155383623448,55.527989656842408,34.409268195655187,4.76708575112832,-9.505963894261754}, +# 'yp': [-25.66489361702122,-20.376712328767127,26.997716894977174,20.56737588652487,32.047872340425585}, +# 'min_Jp': 33.3692722372, +# max_Jp': 95} +# +# color map must start at first line without comment +# +0.21520753,0.27038249,0.57012105 +0.22312459,0.27103303,0.57166455 +0.23080347,0.27168503,0.57324007 +0.23833063,0.27231877,0.57483869 +0.24568074,0.27294692,0.57646522 +0.25289476,0.2735611,0.57811579 +0.25997831,0.27416334,0.57979067 +0.2669379,0.27475519,0.58148978 +0.27380298,0.27532947,0.58321 +0.28055428,0.27589622,0.58495399 +0.287239,0.2764405,0.58671621 +0.29381911,0.27697939,0.58850116 +0.30035424,0.27749166,0.59030167 +0.3067935,0.27799996,0.59212335 +0.31320428,0.2784783,0.59395808 +0.31952836,0.27895311,0.59581191 +0.32583529,0.27939586,0.59767646 +0.3320659,0.27983431,0.59955752 +0.33828602,0.28023999,0.60144712 +0.34443919,0.2806404,0.60335045 +0.35058925,0.28100652,0.60525968 +0.35668082,0.28136625,0.60717967 +0.36277287,0.28169157,0.60910303 +0.3688165,0.28200806,0.61103375 +0.37486069,0.28229156,0.61296536 +0.38086771,0.28256263,0.61490057 +0.38687304,0.28280326,0.61683417 +0.39285321,0.28302691,0.61876728 +0.39882725,0.28322388,0.6206963 +0.40478897,0.28339829,0.62262037 +0.41073803,0.28355108,0.62453795 +0.41668846,0.28367469,0.62644568 +0.42261777,0.28378305,0.62834468 +0.42856299,0.28385455,0.63022847 +0.43448626,0.28391267,0.63210021 +0.44042184,0.28393692,0.63395343 +0.44634815,0.28394123,0.63578925 +0.45227252,0.28392157,0.63760476 +0.45820558,0.28387152,0.63939628 +0.46412436,0.28380662,0.6411656 +0.47006356,0.28370439,0.64290476 +0.47599406,0.28358471,0.64461676 +0.48192565,0.28344156,0.64629781 +0.48786962,0.28326756,0.64794343 +0.49380435,0.28307827,0.64955593 +0.49975251,0.28285825,0.65112821 +0.50570289,0.28261587,0.65266041 +0.51164619,0.2823585,0.65415271 +0.51760901,0.28206718,0.65559589 +0.52356861,0.28175913,0.65699349 +0.52952249,0.28143693,0.65834417 +0.5354961,0.28108192,0.65963775 +0.54146547,0.28071283,0.66087903 +0.54742976,0.28033111,0.66206616 +0.55340844,0.27992224,0.66318972 +0.55938599,0.27949898,0.66425255 +0.56535835,0.27906539,0.66525388 +0.57133473,0.2786149,0.66618743 +0.57731677,0.27814689,0.66704956 +0.58329279,0.27767173,0.66784277 +0.58926275,0.27719044,0.66856469 +0.59523878,0.27669389,0.66920646 +0.601212,0.27619042,0.66976956 +0.60717734,0.27568537,0.67025404 +0.61313444,0.27518023,0.67065755 +0.6190896,0.27467077,0.67097344 +0.62504118,0.27415958,0.67119949 +0.63098171,0.27365438,0.67133763 +0.63691049,0.27315721,0.67138563 +0.64282668,0.27267021,0.67134132 +0.64873334,0.2721922,0.67119941 +0.65463011,0.27172501,0.67095685 +0.66051031,0.27127617,0.67061602 +0.66637279,0.27084839,0.67017505 +0.67221629,0.27044454,0.66963216 +0.67803951,0.27006762,0.66898569 +0.68384101,0.26972075,0.66823411 +0.68962043,0.2694062,0.66737478 +0.69537788,0.26912584,0.66640432 +0.70110815,0.26888634,0.66532544 +0.70680955,0.26869125,0.66413723 +0.71248034,0.26854423,0.66283897 +0.71811869,0.26844898,0.66143017 +0.72372274,0.26840929,0.6599105 +0.72929057,0.26842895,0.65827991 +0.7348202,0.26851179,0.65653854 +0.74030966,0.26866163,0.65468679 +0.74575692,0.26888225,0.65272532 +0.75115994,0.26917738,0.65065505 +0.75651668,0.26955067,0.64847715 +0.76182512,0.27000568,0.64619309 +0.76708321,0.27054582,0.64380458 +0.77228898,0.27117434,0.64131363 +0.77744045,0.27189431,0.63872252 +0.78253571,0.27270861,0.63603377 +0.7875729,0.27361986,0.63325018 +0.79255022,0.27463045,0.6303748 +0.79746596,0.27574247,0.62741092 +0.80231908,0.27695738,0.62436032 +0.80710794,0.27827681,0.62122676 +0.81183046,0.27970239,0.6180159 +0.8164853,0.28123501,0.61473188 +0.82107123,0.28287522,0.611379 +0.82558714,0.28462328,0.60796168 +0.83003205,0.28647909,0.60448445 +0.8344051,0.28844227,0.60095193 +0.83870608,0.29051198,0.59736649 +0.84293394,0.29268742,0.59373445 +0.84708799,0.29496738,0.59006162 +0.8511679,0.29735032,0.58635274 +0.85517346,0.29983446,0.58261253 +0.85910459,0.30241779,0.57884566 +0.86296154,0.30509821,0.57505503 +0.8667442,0.30787334,0.57124668 +0.87045278,0.31074062,0.56742555 +0.87408763,0.3136974,0.5635959 +0.87764922,0.31674094,0.55976186 +0.88113814,0.31986844,0.55592693 +0.88455499,0.32307701,0.55209513 +0.88790044,0.32636363,0.54827073 +0.89117526,0.32972536,0.54445721 +0.89438031,0.33315921,0.54065783 +0.89751647,0.33666226,0.53687571 +0.90058468,0.34023153,0.53311396 +0.90358593,0.34386414,0.52937539 +0.90652122,0.34755725,0.52566255 +0.90939159,0.35130809,0.5219778 +0.91219812,0.35511391,0.51832354 +0.91494189,0.35897199,0.51470218 +0.91762398,0.36287988,0.51111515 +0.92024546,0.36683514,0.50756411 +0.92280743,0.3708354,0.50405059 +0.92531095,0.37487835,0.5005761 +0.92775723,0.37896156,0.49714278 +0.93014721,0.38308319,0.4937508 +0.93248195,0.38724127,0.49040111 +0.93476246,0.3914339,0.48709457 +0.93698975,0.39565929,0.48383192 +0.93916494,0.39991543,0.48061464 +0.94128894,0.40420083,0.47744286 +0.94336261,0.40851411,0.47431661 +0.94538686,0.4128538,0.47123623 +0.94736256,0.41721856,0.468202 +0.94929056,0.42160708,0.46521414 +0.95117192,0.42601776,0.46227381 +0.95300724,0.4304498,0.45938022 +0.95479724,0.43490219,0.4565332 +0.95654264,0.43937392,0.45373274 +0.95824414,0.44386407,0.45097877 +0.95990241,0.44837175,0.44827118 +0.96151825,0.45289592,0.44561039 +0.96309223,0.45743586,0.44299605 +0.9646248,0.46199106,0.44042751 +0.96611649,0.46656086,0.43790454 +0.96756782,0.47114466,0.43542688 +0.96897927,0.47574187,0.43299428 +0.9703513,0.48035197,0.43060645 +0.97168455,0.48497424,0.42826362 +0.9729793,0.48960837,0.42596514 +0.97423583,0.49425407,0.42371048 +0.97545448,0.49891094,0.42149932 +0.97663559,0.50357865,0.41933134 +0.97777945,0.50825686,0.41720624 +0.97888633,0.51294528,0.41512369 +0.97995654,0.5176436,0.41308347 +0.98099046,0.52235141,0.41108558 +0.98198808,0.5270687,0.40912927 +0.98294961,0.53179527,0.40721424 +0.98387521,0.53653092,0.40534022 +0.98476504,0.54127549,0.40350692 +0.98561924,0.54602881,0.40171405 +0.98643793,0.55079072,0.39996136 +0.98722122,0.55556111,0.3982486 +0.98796936,0.5603397,0.39657571 +0.98868226,0.56512655,0.39494219 +0.98936,0.56992153,0.3933478 +0.99000264,0.57472455,0.39179229 +0.99061026,0.57953551,0.39027544 +0.99118291,0.5843543,0.38879701 +0.99172063,0.58918085,0.38735678 +0.99222348,0.59401505,0.38595451 +0.99269152,0.59885681,0.38458997 +0.99312476,0.60370607,0.38326287 +0.99352325,0.60856274,0.38197295 +0.99388704,0.61342672,0.38071994 +0.9942162,0.61829793,0.37950355 +0.9945108,0.62317625,0.37832349 +0.99477091,0.62806159,0.37717942 +0.99499662,0.63295383,0.376071 +0.99518804,0.63785286,0.37499782 +0.99534511,0.64275869,0.37395927 +0.99546806,0.64767111,0.372955 +0.99555705,0.65258996,0.37198453 +0.99561226,0.65751512,0.37104728 +0.99563387,0.66244643,0.37014263 +0.99562207,0.66738375,0.36926988 +0.99557709,0.6723269,0.36842829 +0.99549919,0.67727574,0.367617 +0.99538832,0.68223028,0.3668348 +0.99524486,0.6871903,0.36608079 +0.99506928,0.69215551,0.36535402 +0.99486193,0.69712571,0.36465327 +0.99462316,0.70210071,0.36397724 +0.99435337,0.70708033,0.36332451 +0.99405297,0.71206436,0.36269354 +0.99372226,0.7170527,0.36208252 +0.99336115,0.72204548,0.36148919 +0.99297075,0.72704212,0.36091215 +0.99255157,0.73204239,0.36034933 +0.99210417,0.7370461,0.35979848 +0.9916291,0.74205305,0.35925722 +0.99112697,0.74706302,0.35872299 +0.99059766,0.75207625,0.35819249 +0.99004191,0.75709248,0.3576629 +0.98946091,0.76211118,0.35713157 +0.98885534,0.76713218,0.35659523 +0.98822592,0.77215526,0.3560504 +0.98757341,0.77718026,0.35549344 +0.98689724,0.78220771,0.35491939 +0.98619894,0.78723702,0.35432474 +0.98547981,0.79226775,0.35370552 +0.98474069,0.79729971,0.35305716 +0.98398247,0.80233272,0.35237485 +0.98320475,0.80736733,0.3516524 +0.98240874,0.81240322,0.35088461 +0.9815964,0.81743967,0.35006665 +0.9807688,0.8224765,0.34919255 +0.97992705,0.82751352,0.34825605 +0.97906945,0.83255201,0.34724796 +0.97819995,0.83759034,0.34616365 +0.97731989,0.84262826,0.34499577 +0.97643067,0.84766553,0.34373656 +0.97553084,0.85270337,0.34237486 +0.9746244,0.85774026,0.34090421 +0.97371347,0.86277567,0.3393158 +0.97279937,0.8678095,0.33759927 +0.97188135,0.87284272,0.33574113 +0.97096472,0.87787333,0.33373367 +0.97005177,0.88290083,0.33156512 +0.96914211,0.88792612,0.3292193 +0.9682402,0.89294775,0.32668465 +0.96735004,0.89796453,0.32394813 +0.96647255,0.90297683,0.32099108 +0.96561166,0.9079836,0.31779718 +0.96477281,0.91298312,0.31435094 +0.96395774,0.91797553,0.31062911 +0.96317157,0.92295935,0.30661145 +0.96242046,0.92793272,0.30227735 +0.96170672,0.93289563,0.29759626 +0.96103783,0.93784572,0.29254395 +0.96041973,0.94278138,0.2870899 +0.95985661,0.94770189,0.28119495 +0.95935719,0.95260448,0.27482525 +0.95892721,0.9574878,0.26793369 +0.95857402,0.9623498,0.2604697 +0.9583055,0.96718821,0.25237504 Index: /trunk/data/gpx/red2blue.txt =================================================================== --- /trunk/data/gpx/red2blue.txt (revision 11431) +++ /trunk/data/gpx/red2blue.txt (revision 11431) @@ -0,0 +1,18 @@ +# License: GPL. For details, see LICENSE file. +# +# diverging red to blue, designed by http://colorbrewer2.org/ +# +# color map must start at first line without comment +# +0,0,0 +49,54,149 +69,117,180 +116,173,209 +171,217,233 +224,243,248 +254,224,144 +253,174,97 +244,109,67 +215,48,39 +165,0,38 + Index: /trunk/data/gpx/viridis.txt =================================================================== --- /trunk/data/gpx/viridis.txt (revision 11431) +++ /trunk/data/gpx/viridis.txt (revision 11431) @@ -0,0 +1,267 @@ +# License: GPL. For details,see LICENSE file. +# +# Used to reconstruct the colormap in viscm (http://bids.github.io/colormap/) +# {'xp': [-8.9697272381347659,-14.962877923066287,-32.371553722153038,-30.373836827175865,-6.9720103431575922,-8.684339110280888 +# 'yp': [-25.513698630136986,15.296803652968038,-30.650684931506845,20.719178082191775,25.570776255707756,32.990867579908667 +# 'min_Jp': 33.3692722372, +# 'max_Jp': 95} +# +# color map must start at first line without comment +# +0.0331179,0.29975688,0.57579112 +0.04256739,0.3028265,0.57286799 +0.0512467,0.30584793,0.57009011 +0.05914659,0.30882508,0.5674503 +0.06654831,0.3117815,0.5647918 +0.07345228,0.31469781,0.56227052 +0.07995739,0.31757925,0.55986398 +0.08619278,0.32044241,0.55745447 +0.09212195,0.32327213,0.55517502 +0.09780928,0.32607626,0.55297584 +0.10331033,0.32886259,0.55080222 +0.10859491,0.33162106,0.54875221 +0.11372563,0.33436292,0.54673886 +0.11870231,0.33708616,0.54479015 +0.12351267,0.33978626,0.54295921 +0.12822783,0.3424784,0.541114 +0.13279867,0.34515022,0.53938101 +0.13725748,0.34780851,0.53770555 +0.14161799,0.35045603,0.53606914 +0.14585622,0.3530865,0.53454415 +0.15002582,0.35571293,0.5330082 +0.15408488,0.35832466,0.5315781 +0.15806357,0.36092928,0.53018482 +0.16195691,0.36352554,0.52884943 +0.16576237,0.36611275,0.52758751 +0.16949979,0.36869662,0.52634711 +0.1731454,0.37127046,0.52520656 +0.17673382,0.37384485,0.52406183 +0.18023309,0.37641026,0.52302135 +0.18367353,0.37897678,0.5219859 +0.18703181,0.38153698,0.52104134 +0.19032855,0.38409867,0.52011314 +0.19354787,0.38665632,0.5192658 +0.19670438,0.38921652,0.51843878 +0.19978526,0.39177424,0.51769017 +0.20280277,0.39433623,0.51695934 +0.20574448,0.39689659,0.51631112 +0.20862219,0.39946359,0.51567252 +0.21142395,0.40203013,0.51511745 +0.21415805,0.40460435,0.51457709 +0.21681705,0.40718098,0.51410601 +0.21940294,0.40976427,0.5136727 +0.22191346,0.4123542,0.51328427 +0.22434688,0.41494912,0.51295975 +0.22670152,0.4175556,0.51265342 +0.22897578,0.42016834,0.51241261 +0.23116721,0.42279102,0.51221511 +0.23327224,0.42542553,0.5120539 +0.23529113,0.42806929,0.51195199 +0.23721876,0.4307259,0.51189091 +0.23905088,0.43339672,0.51186833 +0.24078829,0.43607984,0.51190068 +0.24242777,0.43877648,0.5119848 +0.24395722,0.44149191,0.51209793 +0.24538089,0.44422266,0.51226326 +0.24669486,0.44696981,0.512479 +0.24789484,0.44973443,0.51274365 +0.24897073,0.45251957,0.51304809 +0.24992008,0.45532509,0.51339708 +0.25074106,0.45815079,0.51379462 +0.25142853,0.46099761,0.51423996 +0.2519772,0.46386643,0.51473252 +0.25238166,0.46675805,0.51527187 +0.25263645,0.46967322,0.51585774 +0.25273608,0.47261257,0.51648993 +0.25267511,0.47557666,0.51716828 +0.25244821,0.47856593,0.51789267 +0.25205017,0.4815807,0.51866293 +0.25147595,0.48462119,0.51947882 +0.25072074,0.48768749,0.52034 +0.24977992,0.49077954,0.52124597 +0.24864914,0.49389721,0.52219605 +0.24732429,0.4970402,0.52318934 +0.2458015,0.50020813,0.5242247 +0.24407712,0.50340048,0.52530069 +0.24213937,0.50661827,0.52641341 +0.23998809,0.50986008,0.52756205 +0.2376243,0.51312431,0.5287454 +0.23504515,0.51641008,0.52996075 +0.23223599,0.51971846,0.53120267 +0.22919943,0.52304738,0.53246911 +0.22593842,0.52639479,0.53375736 +0.22243635,0.52976175,0.53506084 +0.21869708,0.53314592,0.53637622 +0.21472177,0.53654544,0.53769908 +0.21049097,0.53996144,0.53902151 +0.20602332,0.5433894,0.54034076 +0.20129189,0.54683133,0.54164703 +0.19632014,0.5502822,0.54293704 +0.1910817,0.5537437,0.54420016 +0.1856016,0.55721085,0.54543206 +0.17986279,0.56068409,0.5466222 +0.17388472,0.56415953,0.54776421 +0.16767592,0.56763485,0.54884959 +0.16124118,0.57110836,0.54986858 +0.15461572,0.57457555,0.55081476 +0.14782653,0.57803342,0.55167986 +0.14090518,0.58147916,0.55245531 +0.13391472,0.5849079,0.5531362 +0.12692017,0.58831582,0.55371706 +0.12000191,0.59169907,0.55419371 +0.11326013,0.59505365,0.55456398 +0.10681409,0.59837568,0.55482785 +0.10079543,0.60166197,0.55498638 +0.09534887,0.60490977,0.55504241 +0.09063347,0.60811639,0.55500215 +0.08679049,0.61128079,0.55487004 +0.08394854,0.6144023,0.55465197 +0.08221537,0.61748019,0.55435753 +0.08164325,0.6205151,0.55399342 +0.08223013,0.62350855,0.55356369 +0.08394439,0.62646065,0.55308231 +0.08668611,0.6293742,0.55254872 +0.09034668,0.63225032,0.55197376 +0.09479378,0.63509139,0.55135952 +0.09989897,0.63789906,0.55071423 +0.10553908,0.64067585,0.55003665 +0.11160448,0.64342303,0.54933941 +0.11800283,0.64614329,0.54861541 +0.12465323,0.64883798,0.54787462 +0.13149053,0.65150897,0.54711829 +0.13846531,0.65415809,0.5463437 +0.1455335,0.65678673,0.54555555 +0.15265709,0.65939627,0.54476003 +0.15981518,0.66198821,0.54395146 +0.16698676,0.66456378,0.54313117 +0.17415531,0.66712409,0.54230031 +0.18130458,0.66967023,0.54146307 +0.18842545,0.67220323,0.54061925 +0.19551341,0.67472397,0.53976647 +0.2025629,0.67723331,0.53890516 +0.20956984,0.67973202,0.53803564 +0.2165314,0.68222082,0.53715809 +0.22344573,0.68470038,0.53627262 +0.23031175,0.6871713,0.53537923 +0.23712903,0.68963415,0.53447784 +0.24389765,0.69208946,0.53356833 +0.25061808,0.6945377,0.53265048 +0.25729111,0.69697932,0.53172407 +0.26391778,0.6994147,0.53078879 +0.27049933,0.70184423,0.52984433 +0.27703712,0.70426823,0.52889033 +0.28353264,0.70668701,0.52792642 +0.28998746,0.70910086,0.52695218 +0.29640321,0.71151001,0.52596722 +0.30278152,0.71391471,0.5249711 +0.30912407,0.71631516,0.52396339 +0.31543254,0.71871153,0.52294366 +0.3217086,0.72110401,0.52191145 +0.3279539,0.72349274,0.52086633 +0.33417008,0.72587784,0.51980786 +0.34035875,0.72825944,0.5187356 +0.34652147,0.73063763,0.51764911 +0.35265864,0.73301261,0.51654918 +0.35877137,0.73538448,0.51543583 +0.3648628,0.73775319,0.51430692 +0.37093438,0.74011877,0.51316203 +0.37698751,0.74248126,0.51200075 +0.38302357,0.7448407,0.51082267 +0.38904388,0.7471971,0.5096274 +0.39504973,0.74955049,0.50841457 +0.40104082,0.75190103,0.5071855 +0.40701899,0.75424866,0.50593917 +0.41298655,0.75659325,0.50467398 +0.41894464,0.75893479,0.50338958 +0.42489434,0.76127325,0.50208564 +0.43083671,0.76360862,0.50076184 +0.43677259,0.76594088,0.4994181 +0.44270136,0.7682702,0.49805594 +0.44862605,0.77059628,0.49667271 +0.45454756,0.77291909,0.49526814 +0.46046679,0.77523857,0.49384196 +0.46638456,0.77755469,0.4923939 +0.47230148,0.7798674,0.49092398 +0.47821759,0.78217677,0.48943283 +0.48413494,0.78448256,0.48791871 +0.49005423,0.78678471,0.48638138 +0.49597616,0.78908317,0.48482063 +0.50190137,0.79137786,0.48323626 +0.5078303,0.79366877,0.48162833 +0.5137638,0.79595578,0.47999631 +0.51970278,0.79823879,0.47833963 +0.52564777,0.80051774,0.47665809 +0.53159931,0.80279254,0.47495153 +0.53755788,0.80506315,0.47321975 +0.54352447,0.80732942,0.47146196 +0.54949945,0.80959129,0.46967805 +0.55548322,0.81184871,0.4678679 +0.56147617,0.8141016,0.46603131 +0.5674787,0.81634992,0.46416812 +0.57349149,0.81859354,0.46227771 +0.57951582,0.82083223,0.46035867 +0.58555114,0.82306609,0.45841193 +0.59159777,0.82529507,0.45643726 +0.59765599,0.82751909,0.45443444 +0.60372607,0.82973812,0.45240324 +0.60980907,0.83195194,0.45034236 +0.61590608,0.83416034,0.44825035 +0.62201604,0.83636352,0.44612867 +0.62813915,0.83856142,0.443977 +0.6342756,0.84075401,0.44179501 +0.64042559,0.84294124,0.43958235 +0.64658927,0.84512308,0.43733862 +0.65276961,0.84729891,0.43505957 +0.65896438,0.84946917,0.43274795 +0.66517356,0.85163387,0.43040351 +0.67139725,0.85379299,0.4280257 +0.67763555,0.85594651,0.42561396 +0.68388856,0.8580944,0.42316766 +0.69015635,0.86023667,0.42068611 +0.69643989,0.86237309,0.41816731 +0.70274062,0.86450334,0.41560843 +0.70905639,0.86662792,0.41301167 +0.71538721,0.86874683,0.41037609 +0.72173308,0.87086011,0.40770069 +0.72809396,0.87296778,0.40498434 +0.7344698,0.87506988,0.40222583 +0.74086053,0.87716647,0.39942384 +0.74726606,0.8792576,0.39657691 +0.75368625,0.88134336,0.39368347 +0.76012096,0.88342383,0.39074178 +0.76656999,0.88549913,0.38774996 +0.77303308,0.8875694,0.38470595 +0.77950995,0.88963477,0.38160749 +0.78600023,0.89169545,0.37845211 +0.79250349,0.89375165,0.37523713 +0.79901921,0.89580363,0.37195957 +0.80554676,0.8978517,0.36861621 +0.8120854,0.89989622,0.3652035 +0.81863422,0.90193761,0.36171754 +0.82519216,0.90397637,0.35815405 +0.83175795,0.9060131,0.35450833 +0.83833008,0.90804849,0.3507752 +0.84490673,0.91008337,0.34694895 +0.85148576,0.91211872,0.34302325 +0.85806684,0.91415505,0.33898699 +0.86465276,0.91619201,0.3348209 +0.87123317,0.91823316,0.33052851 +0.87780375,0.9202804,0.32609988 +0.88435971,0.92233593,0.32152327 +0.89091043,0.92439784,0.31675269 +0.89743393,0.9264737,0.31180336 +0.9039243,0.92856651,0.3066523 +0.91038551,0.93067656,0.30124469 +0.91678774,0.93281453,0.29559791 +0.92313653,0.9349809,0.28963085 +0.92939556,0.93718902,0.28335908 +0.93555967,0.93944353,0.2766966 +0.94159054,0.94175935,0.26963707 +0.94745672,0.94414992,0.26213946 +0.95312442,0.94662987,0.25415069 +0.9585465,0.94921781,0.24566287 +0.96367764,0.95193147,0.23667632 +0.96847776,0.95478608,0.22720755 +0.97291733,0.95779215,0.21729217 +0.97698301,0.96095356,0.20697158 + Index: /trunk/src/org/openstreetmap/josm/gui/layer/gpx/GpxDrawHelper.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/layer/gpx/GpxDrawHelper.java (revision 11430) +++ /trunk/src/org/openstreetmap/josm/gui/layer/gpx/GpxDrawHelper.java (revision 11431) @@ -5,10 +5,21 @@ import static org.openstreetmap.josm.tools.I18n.tr; +import java.awt.AlphaComposite; import java.awt.BasicStroke; import java.awt.Color; +import java.awt.Composite; import java.awt.Graphics2D; +import java.awt.LinearGradientPaint; +import java.awt.MultipleGradientPaint; +import java.awt.Paint; import java.awt.Point; +import java.awt.Rectangle; import java.awt.RenderingHints; import java.awt.Stroke; +import java.awt.image.BufferedImage; +import java.awt.image.DataBufferInt; +import java.awt.image.Raster; +import java.io.BufferedReader; +import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; @@ -28,5 +39,8 @@ import org.openstreetmap.josm.data.preferences.ColorProperty; import org.openstreetmap.josm.gui.MapView; +import org.openstreetmap.josm.io.CachedFile; import org.openstreetmap.josm.tools.ColorScale; +import org.openstreetmap.josm.tools.JosmRuntimeException; +import org.openstreetmap.josm.tools.Utils; /** @@ -46,9 +60,13 @@ // draw lines between points belonging to different segments private boolean forceLines; + // use alpha blending for line draw + private boolean alphaLines; // draw direction arrows on the lines private boolean direction; + /** width of line for paint **/ + private int lineWidth; /** don't draw lines if longer than x meters **/ - private int lineWidth; private int maxLineLength; + // draw lines private boolean lines; /** paint large dots for points **/ @@ -74,4 +92,5 @@ private ColorMode computeCacheColored; private int computeCacheColorTracksTune; + private int computeCacheHeatMapDrawColorTableIdx; //// Color-related fields @@ -105,4 +124,39 @@ }; + /** heat map parameters **/ + + // enabled or not (override by settings) + private boolean heatMapEnabled; + // draw small extra line + private boolean heatMapDrawExtraLine; + // used index for color table (parameter) + private int heatMapDrawColorTableIdx; + + // normal buffered image and draw object (cached) + private BufferedImage heatMapImgGray; + private Graphics2D heatMapGraph2d; + + // some cached values + Rectangle heatMapCacheScreenBounds = new Rectangle(); + int heatMapCacheVisibleSegments; + double heatMapCacheZoomScale; + int heatMapCacheLineWith; + + // copied value for line drawing + private List heatMapPolyX = new ArrayList<>(); + private List heatMapPolyY = new ArrayList<>(); + + // setup color maps used by heat map + private static Color[] heatMapLutColorJosmInferno = createColorFromResource("inferno"); + private static Color[] heatMapLutColorJosmViridis = createColorFromResource("viridis"); + private static Color[] heatMapLutColorJosmBrown2Green = createColorFromResource("brown2green"); + private static Color[] heatMapLutColorJosmRed2Blue = createColorFromResource("red2blue"); + + // user defined heatmap color + private Color[] heatMapLutUserColor = createColorLut(Color.BLACK, Color.WHITE); + + // heat map color in use + private Color[] heatMapLutColor; + private void setupColors() { hdopAlpha = Main.pref.getInteger("hdop.color.alpha", -1); @@ -112,4 +166,6 @@ dateScale = ColorScale.createHSBScale(256).addTitle(tr("Time")); directionScale = ColorScale.createCyclicScale(256).setIntervalCount(4).addTitle(tr("Direction")); + heatMapLutColor = heatMapLutUserColor; + systemOfMeasurementChanged(null, null); } @@ -128,5 +184,5 @@ */ public enum ColorMode { - NONE, VELOCITY, HDOP, DIRECTION, TIME; + NONE, VELOCITY, HDOP, DIRECTION, TIME, HEATMAP; static ColorMode fromIndex(final int index) { @@ -171,5 +227,5 @@ * Read coloring mode for specified layer from preferences * @param layerName name of the GpxLayer - * @return coloting mode + * @return coloring mode */ public ColorMode getColorMode(String layerName) { @@ -199,4 +255,5 @@ direction = Main.pref.getBoolean("draw.rawgps.direction", spec, false); lineWidth = Main.pref.getInteger("draw.rawgps.linewidth", spec, 0); + alphaLines = Main.pref.getBoolean("draw.rawgps.lines.alpha-blend", spec, false); if (!data.fromServer) { @@ -220,4 +277,9 @@ largePointAlpha = Main.pref.getInteger("draw.rawgps.large.alpha", -1) & 0xFF; + // get heatmap parameters + heatMapEnabled = Main.pref.getBoolean("draw.rawgps.heatmap.enabled", spec, false); + heatMapDrawExtraLine = Main.pref.getBoolean("draw.rawgps.heatmap.line-extra", spec, false); + heatMapDrawColorTableIdx = Main.pref.getInteger("draw.rawgps.heatmap.colormap", specName(layerName), 0); + neutralColor = getColor(layerName, true); velocityScale.setNoDataColor(neutralColor); @@ -229,5 +291,13 @@ } + /** + * Draw all enabled GPX elements of layer. + * @param g the common draw object to use + * @param mv the meta data to current displayed area + * @param visibleSegments segments visible in the current scope of mv + */ public void drawAll(Graphics2D g, MapView mv, List visibleSegments) { + + final long timeStart = System.currentTimeMillis(); checkCache(); @@ -238,6 +308,12 @@ } - Stroke storedStroke = g.getStroke(); - + fixColors(visibleSegments); + + // backup the environment + Composite oldComposite = g.getComposite(); + Stroke oldStroke = g.getStroke(); + Paint oldPaint = g.getPaint(); + + // set hints for the render g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, Main.pref.getBoolean("mappaint.gpx.use-antialiasing", false) ? @@ -247,13 +323,59 @@ g.setStroke(new BasicStroke(lineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); } - fixColors(visibleSegments); - drawLines(g, mv, visibleSegments); + + // global enabled or select via color + boolean useHeatMap = heatMapEnabled || ColorMode.HEATMAP == colored; + + // default global alpha level + float layerAlpha = 1.00f; + + // extract current alpha blending value + if (oldComposite instanceof AlphaComposite) { + layerAlpha = ((AlphaComposite) oldComposite).getAlpha(); + } + + // use heatmap background layer + if (useHeatMap) { + drawHeatMap(g, mv, visibleSegments); + } else { + // use normal line style or alpha-blending lines + if (!alphaLines) { + drawLines(g, mv, visibleSegments); + } else { + drawLinesAlpha(g, mv, visibleSegments, layerAlpha); + } + } + + // override global alpha settings (smooth overlay) + if (alphaLines || useHeatMap) { + g.setComposite(AlphaComposite.SrcOver.derive(0.25f * layerAlpha)); + } + + // normal overlays drawArrows(g, mv, visibleSegments); drawPoints(g, mv, visibleSegments); - if (lineWidth != 0) { - g.setStroke(storedStroke); - } - } - + + // restore environment + g.setPaint(oldPaint); + g.setStroke(oldStroke); + g.setComposite(oldComposite); + + // show some debug info + if (Main.isDebugEnabled() && !visibleSegments.isEmpty()) { + final long timeDiff = System.currentTimeMillis() - timeStart; + + Main.debug("gpxdraw::draw takes " + + Utils.getDurationString(timeDiff) + + "(" + + "segments= " + visibleSegments.size() + + ", per 10000 = " + Utils.getDurationString(10000 * timeDiff / visibleSegments.size()) + + ")" + ); + } + } + + /** + * Calculate colors of way segments based on latest configuration settings + */ public void calculateColors() { double minval = +1e10; @@ -392,7 +514,41 @@ } + // heat mode + if (ColorMode.HEATMAP == colored && neutralColor != null) { + + // generate new user color map + heatMapLutUserColor = createColorLut(Color.BLACK, neutralColor.darker(), + neutralColor, neutralColor.brighter(), Color.WHITE); + + // decide what, keep order is sync with setting on GUI + Color[][] lut = { + heatMapLutUserColor, + heatMapLutColorJosmInferno, + heatMapLutColorJosmViridis, + heatMapLutColorJosmBrown2Green, + heatMapLutColorJosmRed2Blue + }; + + // select by index + if (heatMapDrawColorTableIdx < lut.length) { + heatMapLutColor = lut[ heatMapDrawColorTableIdx ]; + } else { + // fallback + heatMapLutColor = heatMapLutUserColor; + } + + // force redraw of image + heatMapCacheVisibleSegments = 0; + } + computeCacheInSync = true; } + /** + * Draw all GPX ways segments + * @param g the common draw object to use + * @param mv the meta data to current displayed area + * @param visibleSegments segments visible in the current scope of mv + */ private void drawLines(Graphics2D g, MapView mv, List visibleSegments) { if (lines) { @@ -414,4 +570,10 @@ } + /** + * Draw all GPX arrays + * @param g the common draw object to use + * @param mv the meta data to current displayed area + * @param visibleSegments segments visible in the current scope of mv + */ private void drawArrows(Graphics2D g, MapView mv, List visibleSegments) { /**************************************************************** @@ -475,4 +637,10 @@ } + /** + * Draw all GPX points + * @param g the common draw object to use + * @param mv the meta data to current displayed area + * @param visibleSegments segments visible in the current scope of mv + */ private void drawPoints(Graphics2D g, MapView mv, List visibleSegments) { /**************************************************************** @@ -551,4 +719,416 @@ } + /** + * Draw GPX lines by using alpha blending + * @param g the common draw object to use + * @param mv the meta data to current displayed area + * @param visibleSegments segments visible in the current scope of mv + * @param layerAlpha the color alpha value set for that operation + */ + private void drawLinesAlpha(Graphics2D g, MapView mv, List visibleSegments, float layerAlpha) { + + // 1st. backup the paint environment ---------------------------------- + Composite oldComposite = g.getComposite(); + Stroke oldStroke = g.getStroke(); + Paint oldPaint = g.getPaint(); + + // 2nd. determine current scale factors ------------------------------- + + // adjust global settings + final int globalLineWidth = Math.min(Math.max(lineWidth, 1), 20); + + // cache scale of view + final double zoomScale = mv.getScale(); + + // 3rd. determine current paint parameters ----------------------------- + + // alpha value is based on zoom and line with combined with global layer alpha + float theLineAlpha = Math.min(Math.max((0.50f/(float) zoomScale)/(globalLineWidth + 1), 0.001f), 0.50f) * layerAlpha; + final int theLineWith = (int) (lineWidth / zoomScale) + 1; + + // 4th setup virtual paint area ---------------------------------------- + + // set line format and alpha channel for all overlays (more lines -> few overlap -> more transparency) + g.setStroke(new BasicStroke(theLineWith, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); + g.setComposite(AlphaComposite.SrcOver.derive(theLineAlpha)); + + // last used / calculated entries + Point lastPaintPnt = null; + + // 5th draw the layer --------------------------------------------------- + + // for all points + for (WayPoint trkPnt : visibleSegments) { + + // transform coordinates + final Point paintPnt = mv.getPoint(trkPnt.getEastNorth()); + + // skip single points + if (lastPaintPnt != null && trkPnt.drawLine && !lastPaintPnt.equals(paintPnt)) { + + // set different color + g.setColor(trkPnt.customColoring); + + // draw it + g.drawLine(lastPaintPnt.x, lastPaintPnt.y, paintPnt.x, paintPnt.y); + } + + lastPaintPnt = paintPnt; + } + + // @last restore modified paint environment ----------------------------- + g.setPaint(oldPaint); + g.setStroke(oldStroke); + g.setComposite(oldComposite); + } + + /** + * Creates a linear distributed colormap by linear blending between colors + * @param colors 1..n colors + * @return array of Color objects + */ + protected static Color[] createColorLut(Color... colors) { + + // number of lookup entries + int tableSize = 256; + + // create image an paint object + BufferedImage img = new BufferedImage(tableSize, 1, BufferedImage.TYPE_INT_RGB); + Graphics2D g = img.createGraphics(); + + float[] fract = new float[ colors.length ]; + + // distribute fractions (define position of color in map) + for (int i = 0; i < colors.length; ++i) { + fract[i] = i * (1.0f / colors.length); + } + + // draw the gradient map + LinearGradientPaint gradient = new LinearGradientPaint(0, 0, tableSize, 1, fract, colors, + MultipleGradientPaint.CycleMethod.NO_CYCLE); + g.setPaint(gradient); + g.fillRect(0, 0, tableSize, 1); + g.dispose(); + + // access it via raw interface + final Raster imgRaster = img.getData(); + + // the pixel storage + int[] pixel = new int[1]; + + Color[] colorTable = new Color[tableSize]; + + // map the range 0..255 to 0..pi/2 + final double mapTo90Deg = Math.PI / 2.0 / 255.0; + + // create the lookup table + for (int i = 0; i < tableSize; i++) { + + // get next single pixel + imgRaster.getDataElements((int) (i * (double) img.getWidth() / tableSize), 0, pixel); + + // get color and map + Color c = new Color(pixel[0]); + + // smooth alpha like sin curve + int alpha = (int) (Math.sin(i * mapTo90Deg) * 255); + + // alpha with pre-offset, first color -> full transparent + alpha = i > 0 ? (75 + alpha) : 0; + + // shrink to maximum bound + if (alpha > 255) { + alpha = 255; + } + + // increase transparency for higher values ( avoid big saturation ) + if (i > 240 && 255 == alpha) { + alpha -= (i - 240); + } + + // fill entry in table, assign a alpha value + colorTable[i] = new Color(c.getRed(), c.getGreen(), c.getBlue(), alpha); + } + + // transform into lookup table + return colorTable; + } + + /** + * Creates a colormap by using a static color map with 1..n colors (RGB 0.0 ..1.0) + * @param data array of multiple RGB color [n][3] + * @return a dynamic list of color objects + */ + protected static Color[] createColorFromRawArray(double[][] data) { + + // create the array + Color[] color = new Color[ data.length ]; + + for (int k = 0; k < data.length; k++) { + // cast an map to linear array + color[k] = new Color((float) data[k][0], (float) data[k][1], (float) data[k][2]); + } + + // forward + return createColorLut(color); + } + + /** + * Creates a colormap by using a static color map with 1..n colors (RGB 0.0 ..1.0) + * @param str the filename (without extension) to look for into data/gpx + * @return the parsed colormap + */ + protected static Color[] createColorFromResource(String str) { + + // create resource string + final String colorFile = "resource://data/gpx/" + str + ".txt"; + + List colorList = new ArrayList<>(); + + // try to load the file + try (CachedFile cf = new CachedFile(colorFile); BufferedReader br = cf.getContentReader()) { + + String line; + + // process lines + while ((line = br.readLine()) != null) { + + // use comma as separator + String[] column = line.split(","); + + // empty or comment line + if (column.length < 3 || column[0].startsWith("#")) { + continue; + } + + // extract RGB value + float r = Float.parseFloat(column[0]); + float g = Float.parseFloat(column[1]); + float b = Float.parseFloat(column[2]); + + // some color tables are 0..1.0 and some 0.255 + float scale = (r < 1 && g < 1 && b < 1) ? 1 : 255; + + colorList.add(new Color(r/scale, g/scale, b/scale)); + } + } catch (IOException e) { + throw new JosmRuntimeException(e); + } + + // fallback if empty or failed + if (colorList.isEmpty()) { + colorList.add(Color.BLACK); + colorList.add(Color.WHITE); + } + + return createColorLut(colorList.toArray(new Color[ colorList.size() ])); + } + + /** + * Draw gray heat map with current Graphics2D setting + * @param gB the common draw object to use + * @param mv the meta data to current displayed area + * @param listSegm segments visible in the current scope of mv + * @param foreComp composite use to draw foreground objects + * @param foreStroke stroke use to draw foreground objects + * @param backComp composite use to draw background objects + * @param backStroke stroke use to draw background objects + */ + private void drawHeatGrayMap(Graphics2D gB, MapView mv, List listSegm, + Composite foreComp, Stroke foreStroke, + Composite backComp, Stroke backStroke) { + + // draw foreground + boolean drawForeground = foreComp != null && foreStroke != null; + + // set initial values + gB.setStroke(backStroke); gB.setComposite(backComp); + + // for all points, draw single lines by using optimize drawing + for (WayPoint trkPnt : listSegm) { + + // something to paint or color changed (new segment needed, decrease performance ;-() + if (!trkPnt.drawLine && !heatMapPolyX.isEmpty()) { + + // convert to primitive type + final int[] polyXArr = heatMapPolyX.stream().mapToInt(Integer::intValue).toArray(); + final int[] polyYArr = heatMapPolyY.stream().mapToInt(Integer::intValue).toArray(); + + // a.) draw background + gB.drawPolyline(polyXArr, polyYArr, polyXArr.length); + + // b.) draw extra foreground + if (drawForeground && heatMapDrawExtraLine) { + + gB.setStroke(foreStroke); gB.setComposite(foreComp); + gB.drawPolyline(polyXArr, polyYArr, polyXArr.length); + gB.setStroke(backStroke); gB.setComposite(backComp); + } + + // drop used pints + heatMapPolyX.clear(); heatMapPolyY.clear(); + + } else { + + // get transformed coordinates + final Point paintPnt = mv.getPoint(trkPnt.getEastNorth()); + + // store only the integer part (make sense because pixel is 1:1 here) + heatMapPolyX.add((int) paintPnt.getX()); + heatMapPolyY.add((int) paintPnt.getY()); + } + } + } + + /** + * Map the gray map to heat map and draw them with current Graphics2D setting + * @param g the common draw object to use + * @param imgGray gray scale input image + * @param sampleRaster the line with for drawing + */ + private void drawHeatMapGrayMap(Graphics2D g, BufferedImage imgGray, int sampleRaster) { + + final int[] imgPixels = ((DataBufferInt) imgGray.getRaster().getDataBuffer()).getData(); + + // samples offset and bounds are scaled with line width derived from zoom level + final int offX = Math.max(1, sampleRaster / 2); + final int offY = Math.max(1, sampleRaster / 2); + + final int maxPixelX = imgGray.getWidth(); + final int maxPixelY = imgGray.getHeight(); + + int lastPixelY = 0; + int lastPixelColor = 0; + + // resample gray scale image with line linear weight of next sample in line + // process each line and draw pixels / rectangles with same color with one operations + for (int x = 0; x < maxPixelX; x += offX) { + for (int y = 0; y < maxPixelY; y += offY) { + + int thePixelColor = 0; + + // sample the image (it is gray scale) + int offset = (x * maxPixelX) + y; + + // merge next pixels of window of line + for (int k = 0; k < offX && offset + k < imgPixels.length; k++) { + thePixelColor += imgPixels[offset+k] & 0xFF; + } + + // mean value + thePixelColor /= offX; + + // restart -> use initial sample + if (0 == y) { + lastPixelY = 0; lastPixelColor = thePixelColor; + } + + // different color to last one ? + if (Math.abs(lastPixelColor - thePixelColor) > 1) { + + // draw only foreground pixels, skip small variations + if (lastPixelColor > 1+1) { + + // gray to RGB mapping + g.setColor(heatMapLutColor[ lastPixelColor ]); + + // start point for draw ( + int yN = lastPixelY > 0 ? lastPixelY : y; + + // box from from last Y pixel to current pixel + if (offX < sampleRaster) { + g.fillRect(yN, x, offY + y - yN, offX); + } else { + g.drawRect(yN, x, offY + y - yN, offX); + } + } + // restart detection + lastPixelY = y; lastPixelColor = thePixelColor; + } + } + } + } + + /** + * Collect and draw GPS segments and displays a heat-map + * @param g the common draw object to use + * @param mv the meta data to current displayed area + * @param visibleSegments segments visible in the current scope of mv + */ + private void drawHeatMap(Graphics2D g, MapView mv, List visibleSegments) { + + // get bounds of screen image and projection, zoom and adjust input parameters + final Rectangle screenBounds = g.getDeviceConfiguration().getBounds(); + final double zoomScale = mv.getScale(); + + // adjust global settings + final int globalLineWidth = Math.min(Math.max(lineWidth, 1), 20); + + // 1st setup virtual paint area ---------------------------------------- + + // HACK: sometime screen bounds does not return valid values when picture is shifted + // therefore we use a bigger area to avoid missing parts of image + screenBounds.width = screenBounds.width * 3 / 2; + screenBounds.height = screenBounds.height * 3 / 2; + + // new image buffer needed + final boolean imageSetup = null == heatMapImgGray || !heatMapCacheScreenBounds.equals(screenBounds); + + // screen bounds changed, need new image buffer ? + if (imageSetup) { + // we would use a "pure" grayscale image, but there is not efficient way to map gray scale values to RGB) + heatMapImgGray = new BufferedImage(screenBounds.width, screenBounds.height, BufferedImage.TYPE_INT_ARGB); + heatMapGraph2d = heatMapImgGray.createGraphics(); + heatMapGraph2d.setBackground(new Color(0, 0, 0, 255)); + heatMapGraph2d.setColor(Color.WHITE); + + // cache it + heatMapCacheScreenBounds = screenBounds; + } + + // 2nd. determine current scale factors ------------------------------- + + // the line width (foreground: draw extra small footprint line of track) + final int lineWidthB = Math.max((int) (globalLineWidth / zoomScale) + 1, 2); + final int lineWidthF = lineWidthB > 2 ? (globalLineWidth - 1) : 0; + + // recalculation of image needed + final boolean imageRecalc = heatMapCacheVisibleSegments != visibleSegments.size() || + heatMapCacheZoomScale != zoomScale || + heatMapCacheLineWith != globalLineWidth; + + // 3rd Calculate the heat map data by draw GPX traces with alpha value ---------- + + // need re-generation of gray image ? + if (imageSetup || imageRecalc) { + + // clear background + heatMapGraph2d.clearRect(0, 0, heatMapImgGray.getWidth(), heatMapImgGray.getHeight()); + + // alpha combines both values, therefore the foreground shall be lighter + final float lineAlphaB = Math.min(Math.max((0.40f/(float) zoomScale)/(globalLineWidth + 1), 0.001f), 0.50f); + final float lineAlphaF = lineAlphaB / 1.5f; + + // derive draw parameters and draw + drawHeatGrayMap(heatMapGraph2d, mv, visibleSegments, + lineWidthF > 1 ? AlphaComposite.SrcOver.derive(lineAlphaF) : null, + new BasicStroke(lineWidthF, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND), + AlphaComposite.SrcOver.derive(lineAlphaB), + new BasicStroke(lineWidthB, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND)); + + // remember draw parameters + heatMapCacheVisibleSegments = visibleSegments.size(); + heatMapCacheZoomScale = zoomScale; + heatMapCacheLineWith = lineWidth; + } + + // 4th. Draw data on target layer, map data via color lookup table -------------- + drawHeatMapGrayMap(g, heatMapImgGray, lineWidthB); + } + + /** + * Apply default color configuration to way segments + * @param visibleSegments segments visible in the current scope of mv + */ private void fixColors(List visibleSegments) { for (WayPoint trkPnt : visibleSegments) { @@ -565,5 +1145,7 @@ if ((computeCacheMaxLineLengthUsed != maxLineLength) || (!neutralColor.equals(computeCacheColorUsed)) || (computeCacheColored != colored) || (computeCacheColorTracksTune != colorTracksTune) - || (computeCacheColorDynamic != colorModeDynamic)) { + || (computeCacheColorDynamic != colorModeDynamic) + || (computeCacheHeatMapDrawColorTableIdx != heatMapDrawColorTableIdx) + ) { computeCacheMaxLineLengthUsed = maxLineLength; computeCacheInSync = false; @@ -572,13 +1154,26 @@ computeCacheColorTracksTune = colorTracksTune; computeCacheColorDynamic = colorModeDynamic; - } - } - + computeCacheHeatMapDrawColorTableIdx = heatMapDrawColorTableIdx; + } + } + + /** + * callback when data is changed, invalidate cached configuration parameters + */ public void dataChanged() { computeCacheInSync = false; } + /** + * Draw all GPX arrays + * @param g the common draw object to use + * @param mv the meta data to current displayed area + */ public void drawColorBar(Graphics2D g, MapView mv) { int w = mv.getWidth(); + + // set do default + g.setComposite(AlphaComposite.SrcOver.derive(1.00f)); + if (colored == ColorMode.HDOP) { hdopScale.drawColorBar(g, w-30, 50, 20, 100, 1.0); Index: /trunk/src/org/openstreetmap/josm/gui/preferences/display/GPXSettingsPanel.java =================================================================== --- /trunk/src/org/openstreetmap/josm/gui/preferences/display/GPXSettingsPanel.java (revision 11430) +++ /trunk/src/org/openstreetmap/josm/gui/preferences/display/GPXSettingsPanel.java (revision 11431) @@ -56,7 +56,10 @@ private final JRadioButton colorTypeDilution = new JRadioButton(tr("Dilution of Position (red = high, green = low, if available)")); private final JRadioButton colorTypeTime = new JRadioButton(tr("Track date")); + private final JRadioButton colorTypeHeatMap = new JRadioButton(tr("Heat Map (dark = few tracks, bright = many tracks)")); private final JRadioButton colorTypeNone = new JRadioButton(tr("Single Color (can be customized for named layers)")); private final JRadioButton colorTypeGlobal = new JRadioButton(tr("Use global settings")); private final JosmComboBox colorTypeVelocityTune = new JosmComboBox<>(new String[] {tr("Car"), tr("Bicycle"), tr("Foot")}); + private final JosmComboBox colorTypeHeatMapTune = new JosmComboBox<>(new String[] {tr("User"), tr("Inferno"), tr("Viridis"), + tr("Wood"), tr("Heat")}); private final JCheckBox makeAutoMarkers = new JCheckBox(tr("Create markers when reading GPX")); private final JCheckBox drawGpsArrows = new JCheckBox(tr("Draw Direction Arrows")); @@ -69,4 +72,5 @@ private final JosmTextField audioWaypointLabelPattern = new JosmTextField(); private final JCheckBox useGpsAntialiasing = new JCheckBox(tr("Smooth GPX graphics (antialiasing)")); + private final JCheckBox drawLineWithAlpha = new JCheckBox(tr("Draw with Opacity (alpha blending) ")); private String layerName; @@ -180,14 +184,14 @@ }); drawGpsArrows.setToolTipText(tr("Draw direction arrows for lines, connecting GPS points.")); - add(drawGpsArrows, GBC.eop().insets(40, 0, 0, 0)); + add(drawGpsArrows, GBC.eop().insets(20, 0, 0, 0)); // drawGpsArrowsFast drawGpsArrowsFast.setToolTipText(tr("Draw the direction arrows using table lookups instead of complex math.")); - add(drawGpsArrowsFast, GBC.eop().insets(60, 0, 0, 0)); + add(drawGpsArrowsFast, GBC.eop().insets(40, 0, 0, 0)); ExpertToggleAction.addVisibilitySwitcher(drawGpsArrowsFast); // drawGpsArrowsMinDist drawGpsArrowsMinDist.setToolTipText(tr("Do not draw arrows if they are not at least this distance away from the last one.")); - add(new JLabel(tr("Minimum distance (pixels)")), GBC.std().insets(60, 0, 0, 0)); + add(new JLabel(tr("Minimum distance (pixels)")), GBC.std().insets(40, 0, 0, 0)); add(drawGpsArrowsMinDist, GBC.eol().fill(GBC.HORIZONTAL).insets(5, 0, 0, 5)); @@ -210,4 +214,9 @@ add(useGpsAntialiasing, GBC.eop().insets(20, 0, 0, 0)); ExpertToggleAction.addVisibilitySwitcher(useGpsAntialiasing); + + // alpha blending + drawLineWithAlpha.setToolTipText(tr("Apply dynamic alpha-blending and adjust width based on zoom level for all GPX lines.")); + add(drawLineWithAlpha, GBC.eop().insets(20, 0, 0, 0)); + ExpertToggleAction.addVisibilitySwitcher(drawLineWithAlpha); // colorTracks @@ -221,4 +230,5 @@ colorGroup.add(colorTypeDilution); colorGroup.add(colorTypeTime); + colorGroup.add(colorTypeHeatMap); colorTypeVelocity.addChangeListener(e -> { @@ -226,4 +236,10 @@ colorDynamic.setEnabled(colorTypeVelocity.isSelected() || colorTypeDilution.isSelected()); }); + + colorTypeHeatMap.addChangeListener(e -> { + colorTypeHeatMapTune.setEnabled(colorTypeHeatMap.isSelected()); + colorDynamic.setEnabled(false); + }); + colorTypeDilution.addChangeListener(e -> colorDynamic.setEnabled(colorTypeVelocity.isSelected() || colorTypeDilution.isSelected())); @@ -234,7 +250,10 @@ tr("Colors points and track segments by dilution of position (HDOP). Your capture device needs to log that information.")); colorTypeTime.setToolTipText(tr("Colors points and track segments by its timestamp.")); + colorTypeHeatMap.setToolTipText(tr("Collected points and track segments for a position and displayed as heat map.")); // color Tracks by Velocity Tune colorTypeVelocityTune.setToolTipText(tr("Allows to tune the track coloring for different average speeds.")); + + colorTypeHeatMapTune.setToolTipText(tr("Selects the color schema for heat map.")); add(Box.createVerticalGlue(), GBC.eol().insets(0, 20, 0, 0)); @@ -250,4 +269,7 @@ add(colorTypeDilution, GBC.eol().insets(40, 0, 0, 0)); add(colorTypeTime, GBC.eol().insets(40, 0, 0, 0)); + add(colorTypeHeatMap, GBC.std().insets(40, 0, 0, 0)); + add(colorTypeHeatMapTune, GBC.eop().insets(5, 0, 0, 5)); + ExpertToggleAction.addVisibilitySwitcher(colorTypeDirection); ExpertToggleAction.addVisibilitySwitcher(colorTypeDilution); @@ -316,4 +338,5 @@ drawRawGpsMaxLineLength.setText(Integer.toString(Main.pref.getInteger("draw.rawgps.max-line-length", layerName, 200))); drawLineWidth.setText(Integer.toString(Main.pref.getInteger("draw.rawgps.linewidth", layerName, 0))); + drawLineWithAlpha.setSelected(Main.pref.getBoolean("draw.rawgps.lines.alpha-blend", layerName, false)); forceRawGpsLines.setSelected(Main.pref.getBoolean("draw.rawgps.lines.force", layerName, false)); drawGpsArrows.setSelected(Main.pref.getBoolean("draw.rawgps.direction", layerName, false)); @@ -323,4 +346,5 @@ largeGpsPoints.setSelected(Main.pref.getBoolean("draw.rawgps.large", layerName, false)); useGpsAntialiasing.setSelected(Main.pref.getBoolean("mappaint.gpx.use-antialiasing", false)); + drawRawGpsLinesActionListener.actionPerformed(null); @@ -337,4 +361,5 @@ case 3: colorTypeDirection.setSelected(true); break; case 4: colorTypeTime.setSelected(true); break; + case 5: colorTypeHeatMap.setSelected(true); break; default: Main.warn("Unknown color type: " + colorType); } @@ -342,4 +367,8 @@ colorTypeVelocityTune.setSelectedIndex(ccts == 10 ? 2 : (ccts == 20 ? 1 : 0)); colorTypeVelocityTune.setEnabled(colorTypeVelocity.isSelected() && colorTypeVelocity.isEnabled()); + + colorTypeHeatMapTune.setSelectedIndex(Main.pref.getInteger("draw.rawgps.heatmap.colormap", layerName, 0)); + colorTypeHeatMapTune.setEnabled(colorTypeHeatMap.isSelected() && colorTypeHeatMap.isEnabled()); + colorDynamic.setSelected(Main.pref.getBoolean("draw.rawgps.colors.dynamic", layerName, false)); colorDynamic.setEnabled(colorTypeVelocity.isSelected() || colorTypeDilution.isSelected()); @@ -386,4 +415,6 @@ Main.pref.put("draw.rawgps.large"+layerNameDot, largeGpsPoints.isSelected()); Main.pref.put("draw.rawgps.linewidth"+layerNameDot, drawLineWidth.getText()); + Main.pref.put("draw.rawgps.lines.alpha-blend"+layerNameDot, drawLineWithAlpha.isSelected()); + Main.pref.put("mappaint.gpx.use-antialiasing", useGpsAntialiasing.isSelected()); @@ -404,4 +435,6 @@ } else if (colorTypeTime.isSelected()) { Main.pref.putInteger("draw.rawgps.colors"+layerNameDot, 4); + } else if (colorTypeHeatMap.isSelected()) { + Main.pref.putInteger("draw.rawgps.colors"+layerNameDot, 5); } else { Main.pref.putInteger("draw.rawgps.colors"+layerNameDot, 0); @@ -410,4 +443,7 @@ int ccti = colorTypeVelocityTune.getSelectedIndex(); Main.pref.putInteger("draw.rawgps.colorTracksTune"+layerNameDot, ccti == 2 ? 10 : (ccti == 1 ? 20 : 45)); + + Main.pref.putInteger("draw.rawgps.heatmap.colormap"+layerNameDot, colorTypeHeatMapTune.getSelectedIndex()); + return false; }