mapcomplete/scripts/onwheels/convertData.ts

import { parse } from "csv-parse/sync";
import { readFileSync, writeFileSync } from "fs";
import { Feature, FeatureCollection, GeoJsonProperties } from "geojson";
import Constants from "./constants";

/**
 * Function to determine the tags for a category
 *
 * @param category The category of the item
 * @returns List of tags for the category
 */
function categoryTags(category: string): GeoJsonProperties {
  const tags = {
    tags: Object.keys(Constants.categories[category]).map((tag) => {
      return `${tag}=${Constants.categories[category][tag]}`;
    }),
  };
  if (!tags) {
    throw `Unknown category: ${category}`;
  }
  return tags;
}

/**
 * Rename tags to match the OSM standard
 *
 * @param item The item to convert
 * @returns GeoJsonProperties for the item
 */
function renameTags(item): GeoJsonProperties {
  const properties: GeoJsonProperties = {};
  properties.tags = [];
  for (const key in item) {
    if (Constants.names[key] && item[key]) {
      if (Constants.names[key] == "name" || Constants.names[key] == "id") {
        properties[Constants.names[key]] = item[key];
      }
      if (Constants.names[key] !== "id") {
        properties.tags.push(Constants.names[key] + "=" + item[key]);
      }
    }
  }
  return properties;
}

function convertTypes(properties: GeoJsonProperties): GeoJsonProperties {
  for (const property in properties) {
    // Determine the original tag by looking at the value in the names table
    const originalTag = Object.keys(Constants.names).find(
      (tag) => Constants.names[tag] === property
    );
    // Check if we need to convert the value
    if (Constants.types[originalTag]) {
      switch (Constants.types[originalTag]) {
        case "boolean":
          properties[property] = properties[property] === "1" ? "yes" : "no";
          break;
        default:
          break;
      }
    }
  }
  return properties;
}

/**
 * Function to add units to the properties if necessary
 *
 * @param properties The properties to add units to
 * @returns The properties with units added
 */
function addUnits(properties: GeoJsonProperties): GeoJsonProperties {
  for (const property in properties) {
    // Check if the property needs units, and doesn't already have them
    if (Constants.units[property] && property.match(/.*([A-z]).*/gi) === null) {
      properties[
        property
      ] = `${properties[property]} ${Constants.units[property]}`;
    }
  }
  return properties;
}

/**
 * Function that adds Maproulette instructions and blurb to each item
 *
 * @param properties The properties to add Maproulette tags to
 * @param item The original CSV item
 */
function addMaprouletteTags(properties: GeoJsonProperties, item: any): GeoJsonProperties {
  properties[
    "blurb"
  ] = `This is feature out of the ${item["Categorie"]} category.
  It may match another OSM item, if so, you can add any missing tags to it.
  If it doesn't match any other OSM item, you can create a new one.
  Here is a list of tags that can be added:
  ${properties["tags"].split(";").join("\n")}
  You can also easily import this item using MapComplete: https://mapcomplete.osm.be/onwheels.html#${properties["id"]}`;
  return properties;
}

/**
 * Main function to convert original CSV into GeoJSON
 *
 * @param args List of arguments [input.csv]
 */
function main(args: string[]): void {
  const csvOptions = {
    columns: true,
    skip_empty_lines: true,
    trim: true,
  };
  const file = args[0];
  const output = args[1];

  // Create an empty list to store the converted features
  var items: Feature[] = [];

  // Read CSV file
  const csv: Record<any, string>[] = parse(readFileSync(file), csvOptions);

  // Loop through all the entries
  for (var i = 0; i < csv.length; i++) {
    const item = csv[i];

    // Determine coordinates
    const lat = Number(item["Latitude"]);
    const lon = Number(item["Longitude"]);

    // Check if coordinates are valid
    if (isNaN(lat) || isNaN(lon)) {
      throw `Not a valid lat or lon for entry ${i}: ${JSON.stringify(item)}`;
    }

    // Create a new collection to store the converted properties
    var properties: GeoJsonProperties = {};

    // Add standard tags for category
    const category = item["Categorie"];
    const tagsCategory = categoryTags(category);

    // Add the rest of the needed tags
    properties = { ...properties, ...renameTags(item) };

    // Merge them together
    properties.tags = [...tagsCategory.tags, ...properties.tags];
    properties.tags = properties.tags.join(";");

    // Convert types
    properties = convertTypes(properties);

    // Add units if necessary
    addUnits(properties);

    // Add Maproulette tags
    properties = addMaprouletteTags(properties, item);

    // Create the new feature
    const feature: Feature = {
      type: "Feature",
      id: item["ID"],
      geometry: {
        type: "Point",
        coordinates: [lon, lat],
      },
      properties,
    };

    // Push it to the list we created earlier
    items.push(feature);
  }

  // Make a FeatureCollection out of it
  const featureCollection: FeatureCollection = {
    type: "FeatureCollection",
    features: items,
  };

  // Output the data to the console
  console.log(JSON.stringify(featureCollection));

  // Write the data to a file
  if (output) {
    writeFileSync(
      `${output}.geojson`,
      JSON.stringify(featureCollection, null, 2)
    );
  }
}

// Execute the main function, with the stripped arguments
main(process.argv.slice(2));