from PIL import Image, ImageFilter, ImageDraw, ImagePath\r
from defines import *\r
from log import *\r
-from tiledb import *\r
+from tileinfo import *\r
from osmxml import *\r
from functions import *\r
from xp_normalmap import *\r
# Define layer size depending on what is wanted\r
self._imgsize = 0\r
self._isline = is_line\r
- if mstr_photores == 2048: self._imgsize = 3000\r
- if mstr_photores == 4096: self._imgsize = 6000\r
+ if mstr_photores == 2048: self._imgsize = 2048\r
+ #if mstr_photores == 4096: self._imgsize = 6000\r
#mstr_msg("layergen", "Layer gen initialized")\r
\r
# Define maximum latitude and longitude tile numbers\r
self._tiledb = mstr_tiledb(self._latitude, self._longitude, self._latlngfld)\r
self._tiledb.create_tables()\r
\r
+ # Tile info object\r
+ def open_tile_info(self):\r
+ self._tileinfo = mstr_tileinfo(self._latitude, self._longitude, self._latlngfld)\r
+\r
# This generates a "border" image, for example farmland usually has a small space of grass\r
# before the actual crop of farm field itself. This generates this "border" layer,\r
# and returns it.\r
mstr_msg("layergen", "Layer to be generated: " + str(self._latitude) + "-" + str(self._lat_number) + ":" + str(self._longitude) + "-" + str(self._lng_number) + " -- tag: " + self._tag + " - value: " + self._value )\r
\r
# Before we generate the layer, let's check for airports in this chunk\r
+ """\r
mstr_msg("layergen", "Checking for airport/s with ICAO code")\r
osmxml = mstr_osmxml(0,0)\r
icao = osmxml.find_icao_codes(mstr_datafolder + "_cache/tile.xml")\r
self._tiledb.insert_icao(i, self._lat_number, self._lng_number, self._latitude, self._longitude)\r
mstr_msg("layergen", "Airport/s noted in data file")\r
rw_surface = osmxml.find_runway_surface(mstr_datafolder + "_cache/tile.xml")\r
+ """\r
\r
# The image for the layer itself\r
layer = Image.new("RGBA", (self._imgsize, self._imgsize))\r
# tile in the center\r
# Since we already know the order in adjtiles, we can do this real easy\r
if self._is_completion == False:\r
- at = self._tiledb.get_adjacency_for_source(adjtiles[0][0], adjtiles[0][1], self._tag, self._value) # Top\r
- ar = self._tiledb.get_adjacency_for_source(adjtiles[1][0], adjtiles[1][1], self._tag, self._value) # Right\r
- ab = self._tiledb.get_adjacency_for_source(adjtiles[2][0], adjtiles[2][1], self._tag, self._value) # Bottom\r
- al = self._tiledb.get_adjacency_for_source(adjtiles[3][0], adjtiles[3][1], self._tag, self._value) # Left\r
+ at = self._tileinfo.get_adjacency_for_tag_and_value(adjtiles[0][0], adjtiles[0][1], self._tag, self._value) # Top\r
+ ar = self._tileinfo.get_adjacency_for_tag_and_value(adjtiles[1][0], adjtiles[1][1], self._tag, self._value) # Right\r
+ ab = self._tileinfo.get_adjacency_for_tag_and_value(adjtiles[2][0], adjtiles[2][1], self._tag, self._value) # Bottom\r
+ al = self._tileinfo.get_adjacency_for_tag_and_value(adjtiles[3][0], adjtiles[3][1], self._tag, self._value) # Left\r
+ #at = self._tiledb.get_adjacency_for_source(adjtiles[0][0], adjtiles[0][1], self._tag, self._value) # Top\r
+ #ar = self._tiledb.get_adjacency_for_source(adjtiles[1][0], adjtiles[1][1], self._tag, self._value) # Right\r
+ #ab = self._tiledb.get_adjacency_for_source(adjtiles[2][0], adjtiles[2][1], self._tag, self._value) # Bottom\r
+ #al = self._tiledb.get_adjacency_for_source(adjtiles[3][0], adjtiles[3][1], self._tag, self._value) # Left\r
if self._is_completion == True:\r
- at = self._tiledb.get_adjacency_for_completion(adjtiles[0][0], adjtiles[0][1]) # Top\r
- ar = self._tiledb.get_adjacency_for_completion(adjtiles[1][0], adjtiles[1][1]) # Right\r
- ab = self._tiledb.get_adjacency_for_completion(adjtiles[2][0], adjtiles[2][1]) # Bottom\r
- al = self._tiledb.get_adjacency_for_completion(adjtiles[3][0], adjtiles[3][1]) # Left\r
-\r
- if len(at) == 1:\r
- self._tag = at[0][2]\r
- self._value = at[0][3]\r
- if len(ar) == 1:\r
- self._tag = ar[0][2]\r
- self._value = ar[0][3]\r
- if len(ab) == 1:\r
- self._tag = ab[0][2]\r
- self._value = ab[0][3]\r
- if len(al) == 1:\r
- self._tag = al[0][2]\r
- self._value = al[0][3]\r
+ at = self._tileinfo.get_adjacency_for_completion(adjtiles[0][0], adjtiles[0][1]) # Top\r
+ ar = self._tileinfo.get_adjacency_for_completion(adjtiles[1][0], adjtiles[1][1]) # Right\r
+ ab = self._tileinfo.get_adjacency_for_completion(adjtiles[2][0], adjtiles[2][1]) # Bottom\r
+ al = self._tileinfo.get_adjacency_for_completion(adjtiles[3][0], adjtiles[3][1]) # Left\r
+ #at = self._tiledb.get_adjacency_for_completion(adjtiles[0][0], adjtiles[0][1]) # Top\r
+ #ar = self._tiledb.get_adjacency_for_completion(adjtiles[1][0], adjtiles[1][1]) # Right\r
+ #ab = self._tiledb.get_adjacency_for_completion(adjtiles[2][0], adjtiles[2][1]) # Bottom\r
+ #al = self._tiledb.get_adjacency_for_completion(adjtiles[3][0], adjtiles[3][1]) # Left\r
+\r
+ if len(at) == 4:\r
+ self._tag = at[0]\r
+ self._value = at[1]\r
+ if len(ar) == 4:\r
+ self._tag = ar[0]\r
+ self._value = ar[1]\r
+ if len(ab) == 4:\r
+ self._tag = ab[0]\r
+ self._value = ab[1]\r
+ if len(al) == 4:\r
+ self._tag = al[0]\r
+ self._value = al[1]\r
\r
root_folder = mstr_datafolder + "textures/"\r
for s in mstr_ortho_layers:\r
root_folder = root_folder + s[fld_main] + "/" + s[fld_sub]\r
\r
# We are south to the top tile.\r
- if len(at) == 1 and src == -1:\r
- if "b" in at[0][5]: src = int(at[0][4])\r
+ if len(at) == 2 and src == -1:\r
+ if "b" in at[1]: src = at[0]\r
# We are west to the right tile.\r
- if len(ar) == 1 and src == -1:\r
- if "l" in ar[0][5]: src = int(ar[0][4])\r
+ if len(ar) == 2 and src == -1:\r
+ if "l" in ar[1]: src = ar[0]\r
# We are north to the bottom tile.\r
- if len(ab) == 1 and src == -1:\r
- if "t" in ab[0][5]: src = int(ab[0][4])\r
+ if len(ab) == 2 and src == -1:\r
+ if "t" in ab[1]: src = ab[0]\r
# We are east to the left tile.\r
- if len(al) == 1 and src == -1:\r
- if "r" in al[0][5]: src = int(al[0][4])\r
+ if len(al) == 2 and src == -1:\r
+ if "r" in al[1]: src = al[0]\r
\r
# Should we be at the border of the degree for latitude and longitude, we need to perform\r
# additional checks\r
ald = []\r
if is_deg_brd_t == True:\r
if self._is_completion == False:\r
- atd = self._tiledb.get_adjacency_for_source_in_lat_lng(deg_tiles[0][0], deg_tiles[0][1], 1, self._lng_number, self._tag, self._value) # Top\r
+ atd = self._tileinfo.get_adjacency_for_tag_and_value_in_lat_lng(deg_tiles[0][0], deg_tiles[0][1], self._tag, self._value, 1, self._lng_number, "b") # Top\r
+ #atd = self._tiledb.get_adjacency_for_source_in_lat_lng(deg_tiles[0][0], deg_tiles[0][1], 1, self._lng_number, self._tag, self._value) # Top\r
if self._is_completion == True:\r
- atd = self._tiledb.get_adjacency_for_completion_in_lat_lng(deg_tiles[0][0], deg_tiles[0][1], 1, self._lng_number) # Top\r
+ atd = self._tileinfo.get_completion_in_lat_lng(deg_tiles[0][0], deg_tiles[0][1], 1, self._lng_number, "b")\r
+ #atd = self._tiledb.get_adjacency_for_completion_in_lat_lng(deg_tiles[0][0], deg_tiles[0][1], 1, self._lng_number) # Top\r
+ \r
if is_deg_brd_r == True:\r
if self._is_completion == False:\r
- ard = self._tiledb.get_adjacency_for_source_in_lat_lng(deg_tiles[1][0], deg_tiles[1][1], self._lat_number, 1, self._tag, self._value) # Right\r
+ ard = self._tileinfo.get_adjacency_for_tag_and_value_in_lat_lng(deg_tiles[1][0], deg_tiles[1][1], self._tag, self._value, self._lat_number, 1, "l") # Right\r
+ #ard = self._tiledb.get_adjacency_for_source_in_lat_lng(deg_tiles[1][0], deg_tiles[1][1], self._lat_number, 1, self._tag, self._value) # Right\r
if self._is_completion == True:\r
- ard = self._tiledb.get_adjacency_for_completion_in_lat_lng(deg_tiles[1][0], deg_tiles[1][1], self._lat_number, 1) # Right\r
+ ard = self._tileinfo.get_completion_in_lat_lng(deg_tiles[1][0], deg_tiles[1][1], self._lat_number, 1, "l")\r
+ #ard = self._tiledb.get_adjacency_for_completion_in_lat_lng(deg_tiles[1][0], deg_tiles[1][1], self._lat_number, 1) # Right\r
+ \r
if is_deg_brd_b == True:\r
- maxlatlng = self._tiledb.get_highest_latlong_from_tile(self._latitude-1, self._longitude)\r
+ #maxlatlng = self._tiledb.get_highest_latlong_from_tile(self._latitude-1, self._longitude)\r
if self._is_completion == False:\r
- abd = self._tiledb.get_adjacency_for_source_in_lat_lng(deg_tiles[2][0], deg_tiles[2][1], maxlatlng[0], self._lng_number, self._tag, self._value) # Bottom\r
+ abd = self._tileinfo.get_adjacency_for_tag_and_value_in_lat_lng(deg_tiles[2][0], deg_tiles[2][1], self._tag, self._value, self._lat_number, self._lng_number, "t")\r
+ #abd = self._tiledb.get_adjacency_for_source_in_lat_lng(deg_tiles[2][0], deg_tiles[2][1], maxlatlng[0], self._lng_number, self._tag, self._value) # Bottom\r
if self._is_completion == True:\r
- abd = self._tiledb.get_adjacency_for_completion_in_lat_lng(deg_tiles[2][0], deg_tiles[2][1], maxlatlng[0], self._lng_number) # Bottom\r
+ abd = self._tileinfo.get_completion_in_lat_lng(deg_tiles[2][0], deg_tiles[2][1], self._lat_number, self._lng_number, "t")\r
+ #abd = self._tiledb.get_adjacency_for_completion_in_lat_lng(deg_tiles[2][0], deg_tiles[2][1], maxlatlng[0], self._lng_number) # Bottom\r
+ \r
if is_deg_brd_l == True:\r
- maxlatlng = self._tiledb.get_highest_latlong_from_tile(self._latitude, self._longitude-1)\r
+ #maxlatlng = self._tiledb.get_highest_latlong_from_tile(self._latitude, self._longitude-1)\r
if self._is_completion == False:\r
- ald = self._tiledb.get_adjacency_for_source_in_lat_lng(deg_tiles[2][0], deg_tiles[2][1], self._lat_number, maxlatlng[1], self._tag, self._value) # Left\r
+ ald = self._tileinfo.get_adjacency_for_tag_and_value_in_lat_lng(deg_tiles[2][0], deg_tiles[2][1], self._tag, self._value, self._lat_number, self._lng_number, "r")\r
+ #ald = self._tiledb.get_adjacency_for_source_in_lat_lng(deg_tiles[2][0], deg_tiles[2][1], self._lat_number, maxlatlng[1], self._tag, self._value) # Left\r
if self._is_completion == True:\r
- ald = self._tiledb.get_adjacency_for_completion_in_lat_lng(deg_tiles[2][0], deg_tiles[2][1], self._lat_number, maxlatlng[1]) # Left\r
+ ald = self._tileinfo.get_completion_in_lat_lng(deg_tiles[2][0], deg_tiles[2][1], self._lat_number, self._lng_number, "r")\r
+ #ald = self._tiledb.get_adjacency_for_completion_in_lat_lng(deg_tiles[2][0], deg_tiles[2][1], self._lat_number, maxlatlng[1]) # Left\r
\r
if (is_deg_brd_t == True or is_deg_brd_r == True or is_deg_brd_b == True or is_deg_brd_l == True):\r
if src == -1 and self._is_completion == True:\r
- if len(atd) == 1:\r
- self._tag = atd[0][2]\r
- self._value = atd[0][3]\r
- if len(ard) == 1:\r
- self._tag = ard[0][2]\r
- self._value = ard[0][3]\r
- if len(abd) == 1:\r
- self._tag = abd[0][2]\r
- self._value = abd[0][3]\r
- if len(ald) == 1:\r
- self._tag = ald[0][2]\r
- self._value = ald[0][3]\r
+ if len(atd) == 4:\r
+ self._tag = atd[0]\r
+ self._value = atd[1]\r
+ if len(ard) == 4:\r
+ self._tag = ard[0]\r
+ self._value = ard[1]\r
+ if len(abd) == 4:\r
+ self._tag = abd[0]\r
+ self._value = abd[1]\r
+ if len(ald) == 4:\r
+ self._tag = ald[0]\r
+ self._value = ald[1]\r
\r
root_folder = mstr_datafolder + "textures/"\r
for s in mstr_ortho_layers:\r
# we need to make sure that we select the source we found. This should\r
# enable seamless tiling... around the entire planet\r
if is_deg_brd_t == True and len(at) == 0 and src == -1:\r
- if len(atd) == 1:\r
- if "b" in atd[0][5]: src = int(atd[0][4])\r
+ if len(atd) == 2:\r
+ if "b" in atd[3]: src = int(atd[2])\r
if is_deg_brd_r == True and len(ar) == 0 and src == -1:\r
- if len(ard) == 1:\r
- if "l" in ard[0][5]: src = int(ard[0][4])\r
+ if len(ard) == 2:\r
+ if "l" in ard[3]: src = int(ard[2])\r
if is_deg_brd_b == True and len(ab) == 0 and src == -1:\r
- if len(abd) == 1:\r
- if "t" in abd[0][5]: src = int(abd[0][4])\r
+ if len(abd) == 2:\r
+ if "t" in abd[3]: src = int(abd[2])\r
if is_deg_brd_l == True and len(al) == 0 and src == -1:\r
- if len(ald) == 1:\r
- if "r" in ald[0][5]: src = int(ald[0][4])\r
+ if len(ald) == 2:\r
+ if "r" in ald[3]: src = int(ald[2])\r
\r
mstr_msg("layergen", "Adjacency check completed")\r
\r
# Store into DB - but only if there is something to store\r
if adjstr != "":\r
if self._is_completion == False:\r
- r = self._tiledb.get_adjacency_for_source(self._lat_number, self._lng_number, self._tag, self._value)\r
+ r = self._tileinfo.get_adjacency_for_tag_and_value(self._lat_number, self._lng_number, self._tag, self._value)\r
+ #r = self._tiledb.get_adjacency_for_source(self._lat_number, self._lng_number, self._tag, self._value)\r
if len(r) == 0:\r
- self._tiledb.insert_info(self._lat_number, self._lng_number, self._tag, self._value, src, adjstr)\r
+ self._tileinfo.add_adjacency_data(self._lat_number, self._lng_number, self._tag, self._value, src, adjstr)\r
mstr_msg("layergen", "Adjacency info stored in database")\r
\r
if self._is_completion == True:\r
- r = self._tiledb.get_adjacency_for_completion(self._lat_number, self._lng_number)\r
+ r = self._tileinfo.get_adjacency_for_completion(self._lat_number, self._lng_number)\r
+ #r = self._tiledb.get_adjacency_for_completion(self._lat_number, self._lng_number)\r
if len(r) == 0:\r
- self._tiledb.insert_completion_info(self._lat_number, self._lng_number, self._tag, self._value, src, adjstr)\r
+ self._tileinfo.add_completion_data(self._lat_number, self._lng_number, self._tag, self._value, src, adjstr)\r
mstr_msg("layergen", "Adjacency info for completion stored in database")\r
\r
- self._tiledb.commit_query()\r
- self._tiledb.close_db()\r
+ #self._tiledb.commit_query()\r
+ #self._tiledb.close_db()\r
\r
# Create a water mask we need to remove from the DDS later\r
if (self._tag == "natural" and self._value == "water") or (self._tag == "water" and self._value == "lake") or (self._tag == "water" and self._value == "pond") or (self._tag == "water" and self._value == "river"):\r
--- /dev/null
+
+# -------------------------------------------------------------------
+# ORTHOGRAPHIC
+# Your personal aerial satellite. Always on. At any altitude.*
+# Developed by MarStrMind
+# License: Open Software License 3.0
+# Up to date version always on marstr.online
+# -------------------------------------------------------------------
+# tileinfo.py
+# Stores and retrieves information about which material borders on
+# which edge, aiding in the choice of material to generate seamless
+# images.
+# -------------------------------------------------------------------
+
+from defines import *
+from functions import *
+from log import *
+
+
+class mstr_tileinfo:
+
+ def __init__(self, lat, lng, latlngfld):
+ self._lat = lat
+ self._lng = lng
+ self._latlngfld = latlngfld
+ self._adjfile = mstr_datafolder + "z_orthographic/data/" + self._latlngfld + "/adjinfo"
+ self._cplfile = mstr_datafolder + "z_orthographic/data/" + self._latlngfld + "/cplinfo"
+ self.createDataFile()
+ self.createCompletionFile()
+
+
+ def createDataFile(self):
+ if os.path.isfile(self._adjfile) == False:
+ open(self._adjfile, 'a').close()
+
+
+ def createCompletionFile(self):
+ if os.path.isfile(self._cplfile) == False:
+ open(self._cplfile, 'a').close()
+
+
+ def add_adjacency_data(self, tv, th, tag, value, source, adj):
+ line = ""
+ line = line + str(tv) + " "
+ line = line + str(th) + " "
+ line = line + tag + " "
+ line = line + value + " "
+ line = line + str(source) + " "
+ line = line + str(adj) + "\n"
+
+ with open(self._adjfile, 'a') as textfile:
+ textfile.write(line)
+
+
+ def add_completion_data(self, tv, th, tag, value, source, adj):
+ line = ""
+ line = line + str(tv) + " "
+ line = line + str(th) + " "
+ line = line + tag + " "
+ line = line + value + " "
+ line = line + str(source) + " "
+ line = line + str(adj) + "\n"
+
+ with open(self._cplfile, 'a') as textfile:
+ textfile.write(line)
+
+
+ def get_adjacency_for_tag_and_value(self, tv, th, tag, value):
+ adj = []
+ fnlines = []
+ with open(self._adjfile) as textfile:
+ fnlines = textfile.readlines()
+
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[0]) == tv and int(l[1]) == th:
+ if l[2] == tag and l[3] == value:
+ l[5] = l[5].replace("\n", "")
+ adj.append(int(l[4]))
+ adj.append(l[5])
+ break
+
+ return adj
+
+
+ def get_adjacency_for_tag_and_value_in_lat_lng(self, lat, lng, tag, value, tv, th, brd):
+ latlngfld = self.latlng_folder([lat, lng])
+ adj = []
+ fn = mstr_datafolder + "z_orthographic/data/" + latlngfld + "/adjinfo"
+ if os.path.isfile(fn) == True:
+ fnlines = []
+ with open(fn) as textfile:
+ fnlines = textfile.readlines()
+
+ if brd == "b":
+ # Find highest tile number
+ top = 0
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[0]) > top:
+ top = int(l[0])
+
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[0]) == top and int(l[1]) == th:
+ if l[2] == tag and l[3] == value:
+ adj.append(int(l[4]))
+ adj.append(l[5])
+
+ if brd == "l":
+ # Find highest tile number
+ right = 0
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[1]) > right:
+ right = int(l[1])
+
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[1]) == right and int(l[0]) == tv:
+ if l[2] == tag and l[3] == value:
+ adj.append(int(l[4]))
+ adj.append(l[5])
+
+ if brd == "r":
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[0]) == 1 and int(l[1]) == tv:
+ if l[2] == tag and l[3] == value:
+ adj.append(int(l[4]))
+ adj.append(l[5])
+
+ if brd == "t":
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[1]) == 1 and int(l[0]) == th:
+ if l[2] == tag and l[3] == value:
+ adj.append(int(l[4]))
+ adj.append(l[5])
+
+ return adj
+
+
+ def get_completion_in_lat_lng(self, lat, lng, tv, th, brd):
+ latlngfld = self.latlng_folder([lat, lng])
+ adj = []
+ fn = mstr_datafolder + "z_orthographic/data/" + latlngfld + "/cplinfo"
+ if os.path.isfile(fn) == True:
+ fnlines = []
+ with open(fn) as textfile:
+ fnlines = textfile.readlines()
+
+ if brd == "b":
+ # Find highest tile number
+ top = 0
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[0]) > top:
+ top = int(l[0])
+
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[0]) == top and int(l[1]) == th:
+ adj.append(l[2])
+ adj.append(l[3])
+ adj.append(int(l[4]))
+ adj.append(l[5])
+
+ if brd == "l":
+ # Find highest tile number
+ right = 0
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[1]) > right:
+ right = int(l[1])
+
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[1]) == right and int(l[0]) == tv:
+ adj.append(l[2])
+ adj.append(l[3])
+ adj.append(int(l[4]))
+ adj.append(l[5])
+
+ if brd == "r":
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[0]) == 1 and int(l[1]) == tv:
+ adj.append(l[2])
+ adj.append(l[3])
+ adj.append(int(l[4]))
+ adj.append(l[5])
+
+ if brd == "t":
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[1]) == 1 and int(l[0]) == th:
+ adj.append(l[2])
+ adj.append(l[3])
+ adj.append(int(l[4]))
+ adj.append(l[5])
+
+ return adj
+
+
+
+ def get_adjacency_for_completion(self, tv, th):
+ adj = []
+ fnlines = []
+ with open(self._cplfile) as textfile:
+ fnlines = textfile.readlines()
+
+ for ln in fnlines:
+ l = ln.split(" ")
+ if int(l[0]) == tv and int(l[1]) == th:
+ l[5] = l[5].replace("\n", "")
+ adj.append(l[2])
+ adj.append(l[3])
+ adj.append(int(l[4]))
+ adj.append(l[5])
+ break
+
+ return adj
+
+
+ # Construct a folder name for latitude and longitude
+ def latlng_folder(self, numbers):
+ fstr = ""
+ if numbers[0] >= 0: fstr = "+"
+ if numbers[0] < 0: fstr = "-"
+ if abs(numbers[0]) < 10: fstr = fstr + "0" + str(numbers[0])
+ if abs(numbers[0]) >= 10 and numbers[0] <= 90: fstr = fstr + str(numbers[0])
+
+ if numbers[1] >= 0: fstr = fstr + "+"
+ if numbers[1] < 0: fstr = fstr + "-"
+ if abs(numbers[1]) < 10: fstr = fstr + "00" + str(numbers[1])
+ if abs(numbers[1]) >= 10 and numbers[0] <= 99: fstr = fstr + "0" + str(numbers[1])
+ if abs(numbers[1]) >= 100 : fstr = fstr + str(numbers[1])
+
+ return fstr
marstr / marstr / orthographic.git / commitdiff
