Method: MapPLZ.standardize_geo

Defined in:

lib/mapplz.rb

.standardize_geo(user_geo, lonlat = false, db = nil) ⇒ Object

# File 'lib/mapplz.rb', line 335

def self.standardize_geo(user_geo, lonlat = false, db = nil)
  return [user_geo] if user_geo.is_a?(GeoItem)
  geo_objects = []

  if user_geo.is_a?(File)
    file_type = File.extname(user_geo)
    if ['.csv', '.tsv', '.tdv', '.txt', '.geojson', '.json'].include?(file_type)
      # parse this as if it were sent as a string
      user_geo = user_geo.read
    else
      # convert this with ogr2ogr and parse as a string
      begin
        `ogr2ogr -f "GeoJSON" tmp.geojson #{File.path(user_geo)}`
        user_geo = File.open('tmp.geojson').read
      rescue
        raise 'gdal was not installed, or format was not accepted by ogr2ogr'
      end
    end
  end

  if user_geo.is_a?(String)
    begin
      user_geo = JSON.parse(user_geo)
    rescue
      # not JSON - attempt CSV
      begin
        CSV.parse(user_geo.gsub('\"', '""'), headers: true) do |row|
          geo_objects += standardize_geo(row, lonlat, db)
        end
        return geo_objects
      rescue
        # not JSON or CSV - attempt mapplz parse
        raise MapPLZException, 'call code() to parse mapplz language'
      end
    end
  end

  if user_geo.is_a?(Array) && user_geo.length > 0
    if user_geo[0].is_a?(Array) && user_geo[0].length > 0
      if user_geo[0][0].is_a?(Array) || (user_geo[0][0].is_a?(Hash) && user_geo[0][0].key?(:lat) && user_geo[0][0].key?(:lng))
        # lines and shapes
        user_geo.map! do |path|
          path_pts = []
          path.each do |path_pt|
            if lonlat
              lat = path_pt[1] || path_pt[:lat]
              lng = path_pt[0] || path_pt[:lng]
            else
              lat = path_pt[0] || path_pt[:lat]
              lng = path_pt[1] || path_pt[:lng]
            end
            path_pts << [lat, lng]
          end

          # polygon border repeats first point
          if path_pts[0] == path_pts.last
            geo_type = 'polygon'
            path_pts = [path_pts]
          else
            geo_type = 'polyline'
          end

          geoitem = GeoItem.new(db)
          geoitem[:path] = path_pts
          geoitem[:type] = geo_type
          geoitem
        end
        return user_geo
      end
    end

    # multiple objects being added? iterate through
    if user_geo[0].is_a?(Hash) || user_geo[0].is_a?(Array)
      user_geo.each do |geo_piece|
        geo_objects += standardize_geo(geo_piece, lonlat, db)
      end
      return geo_objects
    end

    # first two spots are a coordinate
    validate_lat = user_geo[0].to_f != 0 || user_geo[0].to_s == '0'
    validate_lng = user_geo[1].to_f != 0 || user_geo[1].to_s == '0'

    if validate_lat && validate_lng
      geo_object = GeoItem.new(db)
      geo_object[:type] = 'point'

      if lonlat
        geo_object[:lat] = user_geo[1].to_f
        geo_object[:lng] = user_geo[0].to_f
      else
        geo_object[:lat] = user_geo[0].to_f
        geo_object[:lng] = user_geo[1].to_f
      end
    else
      fail 'no latitude or longitude found'
    end

    # assume user properties are an ordered array of values known to the user
    user_properties = user_geo.drop(2)

    # only one property and it's a string? check for JSON hash
    if user_properties.length == 1 && user_properties[0].is_a?(String)
      begin
        user_properties[0] = JSON.parse(user_properties[0])
      rescue
      end
    end

    # only one property and it's a hash? it's a hash of properties
    if user_properties.length == 1 && user_properties[0].is_a?(Hash)
      user_properties[0].keys.each do |key|
        geo_object[key.to_sym] = user_properties[0][key]
      end
    else
      geo_object[:properties] = user_properties
    end

    geo_objects << geo_object

  elsif user_geo.is_a?(Hash) || user_geo.is_a?(CSV::Row)
    if user_geo.is_a?(CSV::Row)
      # convert CSV::Row to geo hash
      geo_hash = {}
      user_geo.headers.each do |header|
        geo_hash[header] = user_geo[header]
      end
      user_geo = geo_hash
    end

    # check for lat and lng
    validate_lat = false
    validate_lat = 'lat' if user_geo.key?('lat') || user_geo.key?(:lat)
    validate_lat ||= 'latitude' if user_geo.key?('latitude') || user_geo.key?(:latitude)

    validate_lng = false
    validate_lng = 'lng' if user_geo.key?('lng') || user_geo.key?(:lng)
    validate_lng ||= 'lon' if user_geo.key?('lon') || user_geo.key?(:lon)
    validate_lng ||= 'long' if user_geo.key?('long') || user_geo.key?(:long)
    validate_lng ||= 'longitude' if user_geo.key?('longitude') || user_geo.key?(:longitude)

    if validate_lat && validate_lng
      # single hash
      geo_object = GeoItem.new(db)
      geo_object[:lat] = user_geo[validate_lat].to_f
      geo_object[:lng] = user_geo[validate_lng].to_f
      geo_object[:type] = 'point'

      user_geo.keys.each do |key|
        next if key == validate_lat || key == validate_lng
        geo_object[key.to_sym] = user_geo[key]
      end
      geo_objects << geo_object
    elsif user_geo.key?('path') || user_geo.key?(:path)
      # try line or polygon
      path_pts = []
      path = user_geo['path'] if user_geo.key?('path')
      path = user_geo[:path] if user_geo.key?(:path)

      if path_pts[0].is_a?(Array) && path_pts[0][0].is_a?(Array)
        # ring polygon
        path.each do |ring|
          ring.map! do |path_pt|
            if lonlat
              lat = path_pt[1] || path_pt[:lat]
              lng = path_pt[0] || path_pt[:lng]
            else
              lat = path_pt[0] || path_pt[:lat]
              lng = path_pt[1] || path_pt[:lng]
            end
            [lat, lng]
          end
        end
        path_pts = path
      else
        path.each do |path_pt|
          if lonlat
            lat = path_pt[1] || path_pt[:lat]
            lng = path_pt[0] || path_pt[:lng]
          else
            lat = path_pt[0] || path_pt[:lat]
            lng = path_pt[1] || path_pt[:lng]
          end
          path_pts << [lat, lng]
        end

        # polygon border repeats first point
        if path_pts[0] == path_pts.last
          geo_type = 'polygon'
          path_pts = [path_pts]
        else
          geo_type = 'polyline'
        end
      end

      geoitem = GeoItem.new(db)
      geoitem[:path] = path_pts
      geoitem[:type] = geo_type

      property_list = user_geo.clone
      property_list = property_list[:properties] if property_list.key?(:properties)
      property_list = property_list['properties'] if property_list.key?('properties')
      property_list.delete(:path)
      property_list.keys.each do |prop|
        geoitem[prop.to_sym] = property_list[prop]
      end

      geo_objects << geoitem
    elsif user_geo.key?('geo') || user_geo.key?(:geo)
      # this key is GeoJSON or WKT
      geotext = (user_geo['geo'] || user_geo[:geo])
      if geotext.upcase.index('POINT(') || geotext.upcase.index('LINESTRING(') || geotext.upcase.index('POLYGON(')
        # try WKT
        geoitem = GeoItem.new(db)
        geoitem = MapPLZ.parse_wkt(geoitem, geotext)
      else
        # GeoJSON
        begin
          geoitem = standardize_geo(JSON.parse(geotext), lonlat, db)[0]
        rescue
          # did not recognize format
          raise 'did not recognize format in CSV geo column'
        end
      end
      user_geo.keys.each do |key|
        next if ['lat', 'lng', 'geo', 'geom', 'geojson', 'wkt', :lat, :lng, :geo, :geom, :geojson, :wkt].include?(key)
        geoitem[key.to_sym] = user_geo[key]
      end
      geo_objects << geoitem
    else
      # try GeoJSON
      if user_geo.key?(:type)
        user_geo['type'] = user_geo[:type] || ''
        user_geo['features'] = user_geo[:features] if user_geo.key?(:features)
        user_geo['properties'] = user_geo[:properties] || {}
        if user_geo.key?(:geometry)
          user_geo['geometry'] = user_geo[:geometry]
          user_geo['geometry']['type'] = user_geo[:geometry][:type]
          user_geo['geometry']['coordinates'] = user_geo[:geometry][:coordinates]
        end
      end
      if user_geo.key?('type')
        if user_geo['type'] == 'FeatureCollection' && user_geo.key?('features')
          # recursive onto features
          user_geo['features'].each do |feature|
            geo_objects += standardize_geo(feature, lonlat, db)
          end
        elsif user_geo.key?('geometry') && user_geo['geometry'].key?('coordinates')
          # each feature
          coordinates = user_geo['geometry']['coordinates']

          if user_geo['geometry']['type'] == 'Point'
            geo_object = GeoItem.new(db)
            geo_object[:lat] = coordinates[1].to_f
            geo_object[:lng] = coordinates[0].to_f
            geo_object[:type] = 'point'
            geo_objects << geo_object
          elsif user_geo['geometry']['type'] == 'LineString'
            geo_object = GeoItem.new(db)
            MapPLZ.flip_path(coordinates)
            geo_object[:path] = coordinates
            geo_object[:type] = 'polyline'
            geo_objects << geo_object
          elsif user_geo['geometry']['type'] == 'Polygon'
            geo_object = GeoItem.new(db)
            coordinates.map! do |ring|
              MapPLZ.flip_path(ring)
            end
            geo_object[:path] = coordinates
            geo_object[:type] = 'polygon'
            geo_objects << geo_object
          elsif user_geo['geometry']['type'] == 'MultiPoint'
            coordinates.each do |point|
              geo_object = GeoItem.new(db)
              geo_object[:lat] = point[1].to_f
              geo_object[:lng] = point[0].to_f
              geo_object[:type] = 'point'
              geo_objects << geo_object
            end
          elsif user_geo['geometry']['type'] == 'MultiLineString'
            coordinates.each do |line|
              geo_object = GeoItem.new(db)
              geo_object[:path] = MapPLZ.flip_path(line)
              geo_object[:type] = 'polyline'
              geo_objects << geo_object
            end
          elsif user_geo['geometry']['type'] == 'MultiPolygon'
            coordinates.each do |poly|
              geo_object = GeoItem.new(db)
              poly.map! do |ring|
                MapPLZ.flip_path(ring)
              end
              geo_object[:path] = poly
              geo_object[:type] = 'polygon'
              geo_objects << geo_object
            end
          end

          # store properties on all generated geometries
          prop_keys = {}
          if user_geo.key?('properties')
            user_geo['properties'].keys.each do |key|
              prop_keys[key.to_sym] = user_geo['properties'][key]
            end
          end
          geo_objects.each do |geo|
            prop_keys.keys.each do |key|
              geo[key] = prop_keys[key]
            end
          end
        end
      end
    end
  end

  geo_objects
end