Merge pull request #1 from Mihara/dev

Version 1.0.1

Author: Mihara

CHANGELOG.md

@@ -0,0 +1,9 @@
+
+## 1.0.1
+
+* Removed Python dependency: NimScript is now used to massage the database file into submission.
+* A silly bug that could result in getting a wrong city was fixed.
+
+## 1.0.0
+
+First public release. Well, it works.

README.md

@@ -42,7 +42,7 @@ The program will track writes to this file, and check every grid square it finds
 
 ## Compilation
 
-Ballpark is written in [Nim](https://nim-lang.org/). To prepare the database file for embedding into the executable you will also need Python 3.
+Ballpark is written in [Nim](https://nim-lang.org/). You shouldn't need anything else to compile it, though cross-platform building and producing static binaries is a different matter -- see comments in [ballpark.nimble](ballpark.nimble) for details.
 
 It builds for all flavors of Linux, including Raspbian, as well as Windows command line. There is currently no OSX build and I don't know how to do one properly without building on OSX itself, though there's no reason it shouldn't be possible.
 

ballpark.nimble

@@ -1,6 +1,6 @@
 # Package
 
-version = "1.0.0"
+version = "1.0.1"
 author = "Eugene Medvedev (R2AZE)"
 description = "An amateur radio tool to get you a ballpark estimate of where a given Maidenhead grid square is."
 license = "MIT"
@@ -20,18 +20,14 @@ import os
 import distros
 from macros import error
 
-if findExe("python3") == "":
-  error("You require a Python 3 somewhere in your PATH " &
-        "to build the database files.")
-
 task db, "Prepare city database.":
 
   if not fileExists("db/countries.json") or
      not fileExists("db/cities.json") or
      not fileExists("db/regions.json"):
 
     echo("=== Preparing city database for embedding.")
-    exec "python3 convert-db.py"
+    selfExec "--maxLoopIterationsVM:50000000 convertdb.nims"
 
 # Before building, ensure the database was converted.
 before build:

convert-db.py

@@ -0,0 +1,146 @@
+
+#[
+
+This started out as a Python script, but I rewrote it in NimScript to
+reduce dependencies and pave the way for native compilation on Windows
+with fewer headaches.
+
+Potentially, this could be done during compilation, however, the NimScript
+implementation is a lot slower than Python (surprisingly) so it stays where
+it is.
+
+]#
+
+import os
+import streams
+import json
+import parsecsv
+import parseutils
+import strutils
+import algorithm
+
+const
+  srcPath = "vendor"
+  dbPath = "db"
+
+# Slightly different from the types used in the actual program.
+type
+  Geo = tuple[lat: float, lon: float]
+  CityRecord = tuple[
+    name: string,
+    region: int,
+    country: int,
+    radius: float,
+    loc: Geo
+  ]
+
+var
+  cities: seq[CityRecord]
+  countries: seq[string]
+  regions: seq[string]
+
+var
+  csv: CsvParser
+  # A bit silly that this is how you have to do it in nimscript, but whatever.
+  db = newStringStream(readFile(os.joinpath(srcPath, "worldcities.csv")))
+
+csv.open(db, "worldcities.csv", ',', '\"')
+
+csv.readHeaderRow()
+
+while csv.readRow():
+  var
+    population = 0
+
+  # Clean up the population value: some entries in the database
+  # have a decimal point in there for some silly reason.
+  try:
+    population = parseInt(csv.rowEntry("population").replace(".", ""))
+  except ValueError:
+    continue
+
+  # We skip cities with population < 20000
+  # unless they're also marked as region capitals.
+  if len(csv.rowEntry("capital")) == 0 and population <= 20000:
+    continue
+
+  # Now take a guess at a city's effective radius, which
+  # we are using to solve the agglomeration problem.
+  # I am only guessing here, but I know Moscow's
+  # radius is about 15.3km,
+  # and the population is listed as 17125000.
+  let radius = float(population) / (17125000 / 15.3)
+
+  var
+    city: CityRecord
+
+    # Here we also clean up some bogus entries in regions:
+    # I'm not going to believe any country uses slashes to *start*
+    # their region names.
+    regionString = csv.rowEntry("admin_name").replace("//", "")
+
+    countryString = csv.rowEntry("country")
+    countryIndex = countries.find(countryString)
+    regionIndex = regions.find(regionString)
+
+  city.name = csv.rowEntry("city")
+  city.radius = radius
+
+  city.loc.lat = parseFloat(csv.rowEntry("lat"))
+  city.loc.lon = parseFloat(csv.rowEntry("lng"))
+
+  # Cities with an empty region name get the region name equal to the city itself.
+  if len(regionString) == 0:
+    regionString = csv.rowEntry("city")
+
+  if regionIndex > -1:
+    city.region = regionIndex
+  else:
+    regions.add(regionString)
+    city.region = len(regions)-1
+
+  if countryIndex > -1:
+    city.country = countryIndex
+  else:
+    countries.add(countryString)
+    city.country = len(countries)-1
+
+  cities.add(city)
+
+csv.close()
+
+# Sort the cities by population, highest first,
+# so that if the search lands inside the radius of two cities,
+# the bigger one wins.
+func compareCities(a: CityRecord, b: CityRecord): int =
+  if a.radius < b.radius: 1
+  elif a.radius == b.radius: 0
+  else: -1
+
+cities.sort(compareCities)
+
+# Now write our json files.
+# Simple with regions and countries, a bit more complicated for cities,
+# since they're not a simple structure.
+
+var
+  citiesJson = newJArray()
+
+for city in cities:
+  citiesJson.add( %* {
+    "Field0": city.name,
+    "Field1": city.region,
+    "Field2": city.country,
+    "Field3": city.radius,
+    "Field4": {
+      "Field0": city.loc.lat,
+      "Field1": city.loc.lon
+    }
+  })
+
+
+writeFile(os.joinpath(dbPath, "cities.json"), pretty(citiesJson))
+writeFile(os.joinpath(dbPath, "regions.json"), pretty(%regions))
+writeFile(os.joinpath(dbPath, "countries.json"), pretty(%countries))
+
+echo("Database preparation complete.")

convertdb.nims

@@ -59,9 +59,9 @@ func closestCity*(coords: Geo): City =
     let d = distance(coords, city.loc)
     if d < distance(coords, closest.loc):
       closest = city
-    # If we landed inside the radius of a big city, stop.
-    if d <= closest.radius:
-      break
+      # If we landed inside the radius of a big city, stop.
+      if d <= city.radius:
+         break
 
   result.name = closest.name
   result.loc = closest.loc