gtfs_stops_clustering 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32c396f8f9377660da84a4b29d78657e23efcfefe01e6d05368894dd1ffbf07d
-  data.tar.gz: 42f3961fb4a896fb3f25c3f113672a0ac8894d74458270bfce2fef82f5e50e11
+  metadata.gz: d10d21f2d65afcf335560f35f8a34e4c8e46b3e6eeb6b7c74d9edf73e3336227
+  data.tar.gz: 67f4f260b43a6ac2f8af21b8c1a5471ee241b3c86f6a8532c55e0554268cdaa0
 SHA512:
-  metadata.gz: 197ec5fb775f93c61c1207392bb2b0a136c09b61572327d2855b9f0c73bf1dc94f552b6665d842a757c20e06248692001ff013c23407e3bc94ed7a024ca5dbd0
-  data.tar.gz: 88c0c3d4106abf305d0ac7a4196a6612f40745bf2632ffadab32673d3fb60f04800a2d4de44027fa9fb4a3c8c03db206881dccc91505fb15e48253e56e85952c
+  metadata.gz: e5ef45bb1402420422984e19918edfe60c5cc73fac8d503be3f605bd83c4b97460a688e79bba16e901cb42ecf358571cc1380467920e2c9b051be08b0fcff5fb
+  data.tar.gz: '0349797d0744abe6432ab20f262ac766118b2a3153b1e5dbb2796d2c3eb359fccc109bdadc17affbe43b9824457701daa5d3a1c434fe43ab40c3c1534dbce382'

data/lib/gtfs_stops_clustering/data_import.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 # lib/data_import.rb
 
-require 'csv'
-require 'gtfs'
+require "csv"
+require "gtfs"
 
+# DataImport module
 module DataImport
-  VERSION='0.0.1'
   attr_accessor :data_import
 
+  # DataImport class
   class DataImport
     attr_accessor :stops, :stops_config_file, :stops_names, :stops_corner_cases, :stops_data, :stops_redis_geodata
 
@@ -22,13 +25,13 @@ module DataImport
     end
 
     def import_stops_corner_cases
-      if File.exist?(@stops_config_file)
-        CSV.foreach(@stops_config_file, headers: true) do |row|
-          stop_name = row['stop_name']
-          cluster_name = row['cluster_name']
+      return unless File.exist?(@stops_config_file)
+
+      CSV.foreach(@stops_config_file, headers: true) do |row|
+        stop_name = row["stop_name"]
+        cluster_name = row["cluster_name"]
 
-          stops_corner_cases << { stop_name: stop_name, cluster_name: cluster_name }
-        end
+        stops_corner_cases << { stop_name: stop_name, cluster_name: cluster_name }
       end
     end
 
@@ -38,13 +41,20 @@ module DataImport
         longitude = row.lon
         stop_name = row.name
 
-        stop_name = @stops_corner_cases.find { |entry| entry[:stop_name] == stop_name }[:cluster_name] if stops_corner_cases.find { |entry| entry[:stop_name] == stop_name }
+        stop_name = stop_name_from_corner_cases(stop_name)
 
         @stops_names << stop_name
         @stops_data << [latitude, longitude]
         @stops_redis_geodata << [longitude, latitude, "#{longitude},#{latitude}"]
       end
     end
+
+    def stop_name_from_corner_cases(stop_name)
+      csv_entry = @stops_corner_cases.find do |entry|
+        entry[:stop_name] == stop_name
+      end
+      csv_entry.nil? ? stop_name : csv_entry[:cluster_name]
+    end
   end
 
   def import_stops_data(*args)
@@ -56,5 +66,3 @@ module DataImport
     }
   end
 end
-
-include DataImport

data/lib/gtfs_stops_clustering/dbscan.rb

@@ -1,33 +1,47 @@
-## https://github.com/shiguodong/dbscan (fork)
+# frozen_string_literal: true
 
-require 'distance_measures'
-require 'text'
-require 'geocoder'
-require_relative 'redis_geodata'
+# lib/gtfs_stops_clustering/dbscan.rb
 
+require "distance_measures"
+require "text"
+require "geocoder"
+require_relative "redis_geodata"
+
+# Array class
 class Array
-  def haversine_distance2(n)
-    Geocoder::Calculations.distance_between(self, n)
+  def haversine_distance2(other)
+    Geocoder::Calculations.distance_between(self, other)
   end
 end
 
+# DBSCAN module
 module DBSCAN
+  # Clusterer class
   class Clusterer
+    include RedisGeodata
     attr_accessor :points, :options, :clusters
 
     def initialize(points, stops_redis_geodata, options = {})
       options[:distance] = :euclidean_distance unless options[:distance]
       options[:labels] = [] unless options[:labels]
 
-      c = 0
       redis_geodata_import(stops_redis_geodata, options[:epsilon])
-      @points = points.map { |e| po = Point.new(e, options[:labels][c]); c +=1; po }
       @options = options
-      @clusters = {-1 => []}
+      init_points(points)
+      @clusters = { -1 => [] }
 
       clusterize!
     end
 
+    def init_points(points)
+      c = 0
+      @points = points.map do |e|
+        po = Point.new(e, @options[:labels][c])
+        c += 1
+        po
+      end
+    end
+
     def clusterize!
       current_cluster = -1
       @points.each do |point|
@@ -49,10 +63,10 @@ module DBSCAN
           # Get Cluster Position
           cluster_pos = find_cluster_position(clusters[current_cluster])
 
-          clusters[current_cluster].each { |e|
+          clusters[current_cluster].each do |e|
             e.cluster_name = cluster_name
             e.cluster_pos = cluster_pos
-          }
+          end
         else
           clusters[-1].push(point)
         end
@@ -91,9 +105,11 @@ module DBSCAN
       neighbors = []
       geosearch_results = geosearch(point.items[1], point.items[0])
       geosearch_results.each do |neighbor_pos|
-        coordinates = neighbor_pos.split(',')
-        neighbor = @points.find { |point| point.items[0] == coordinates[1] &&
-                                  point.items[1] == coordinates[0] }
+        coordinates = neighbor_pos.split(",")
+        neighbor = @points.find do |elem|
+          elem.items[0] == coordinates[1] &&
+            elem.items[1] == coordinates[0]
+        end
         next unless neighbor
 
         string_distance = Text::Levenshtein.distance(point.label.downcase, neighbor.label.downcase)
@@ -112,9 +128,7 @@ module DBSCAN
 
           if new_points.size >= options[:min_points]
             new_points.each do |p|
-              unless neighbors.include?(p)
-                neighbors.push(p)
-              end
+              neighbors.push(p) unless neighbors.include?(p)
             end
           end
         end
@@ -127,32 +141,31 @@ module DBSCAN
 
       cluster_points
     end
-  end
 
-  def find_cluster_name(labels)
-    words = labels.map { |label| label.strip.split }
-    common_title = ''
+    def find_cluster_name(labels)
+      words = labels.map { |label| label.strip.split }
+      common_title = ""
 
-    # Loop through each word index starting from the first
-    (0...words.first.length).each do |i|
-      words_at_index = words.map { |word_list| word_list[i] }
+      # Loop through each word index starting from the first
+      (0...words.first.length).each do |i|
+        words_at_index = words.map { |word_list| word_list[i] }
 
-      break unless words_at_index.uniq.length == 1
+        break unless words_at_index.uniq.length == 1
 
-      common_title += " #{words_at_index.first.capitalize}"
-    end
-
-    common_title.strip! ? common_title : labels.first
-  end
+        common_title += " #{words_at_index.first.capitalize}"
+      end
 
-  def find_cluster_position(cluster)
-    total_lat = cluster.map { |e| e.items[0].to_f }.sum
-    total_lon = cluster.map { |e| e.items[1].to_f }.sum
-    avg_lat = total_lat / cluster.size
-    avg_lon = total_lon / cluster.size
-    [avg_lat, avg_lon]
+      common_title.strip ? common_title : labels.first
+    end
+    def find_cluster_position(cluster)
+      total_lat = cluster.map { |e| e.items[0].to_f }.sum
+      total_lon = cluster.map { |e| e.items[1].to_f }.sum
+      avg_lat = total_lat / cluster.size
+      avg_lon = total_lon / cluster.size
+      [avg_lat, avg_lon]
+    end
   end
-
+  # Point class
   class Point
     attr_accessor :items, :cluster, :visited, :label, :cluster_name, :cluster_pos
 
@@ -176,5 +189,3 @@ module DBSCAN
     clusterer.labeled_results
   end
 end
-
-include DBSCAN

data/lib/gtfs_stops_clustering/input_consistency_checks.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# lib/input_consistency_checks.rb
+
+# InputConsistencyChecks module
+module InputConsistencyChecks
+  # InputConsistencyChecks class
+  class InputConsistencyChecks
+    attr_accessor :gtfs_paths, :epsilon, :min_points, :names_similarity, :stops_config_path
+
+    def initialize(gtfs_paths, epsilon, min_points, names_similarity, stops_config_path)
+      @gtfs_paths = gtfs_paths
+      @stops_config_path = stops_config_path
+      @epsilon = epsilon
+      @min_points = min_points
+      @names_similarity = names_similarity
+      input_consistency_checks
+    end
+
+    def input_consistency_checks
+      gtfs_paths_check
+      epsilon_check
+      min_points_check
+      names_similarity_check
+    end
+
+    def gtfs_paths_check
+      raise ArgumentError, "gtfs_paths cannot be nil" if @gtfs_paths.nil?
+      raise ArgumentError, "gtfs_paths must be an Array" unless @gtfs_paths.is_a?(Array)
+      raise ArgumentError, "gtfs_paths must not be empty" if @gtfs_paths.empty?
+    end
+
+    def epsilon_check
+      raise ArgumentError, "epsilon must be a Float" unless @epsilon.is_a?(Float)
+      raise ArgumentError, "epsilon must be greater than 0" if @epsilon.negative?
+    end
+
+    def min_points_check
+      raise ArgumentError, "min_points must be an Integer" unless @min_points.is_a?(Integer)
+      raise ArgumentError, "min_points must be greater than 0" if @min_points.negative?
+    end
+
+    def names_similarity_check
+      raise ArgumentError, "names_similarity must be a Float" unless @names_similarity.is_a?(Float)
+      raise ArgumentError, "names_similarity must be between 0 and 1" if @names_similarity.negative? || @names_similarity > 1
+    end
+  end
+
+  def input_consistency_checks(gtfs_paths, epsilon, min_points, names_similarity, stop_config_path)
+    @input_consistency_checks = InputConsistencyChecks.new(gtfs_paths, epsilon, min_points, names_similarity, stop_config_path)
+  end
+end

data/lib/gtfs_stops_clustering/redis_geodata.rb

@@ -1,17 +1,21 @@
-# lib/redis_geodata.rb
-require 'redis'
+# frozen_string_literal: true
 
+# lib/gtfs_stops_clustering/redis_geodata.rb
+
+require "redis"
+
+# RedisGeodata module
 module RedisGeodata
-  VERSION='0.0.1'
   attr_accessor :redis
 
+  # RedisGeodata class
   class RedisGeodata
     attr_accessor :stops, :key, :redis, :epsilon
 
     def initialize(stops, epsilon)
-      @redis = Redis.new(url: 'redis://127.0.0.1:6379')
+      @redis = Redis.new(url: "redis://127.0.0.1:6379")
       @stops = stops
-      @key = 'stops'
+      @key = "stops"
       @epsilon = epsilon
       geoadd
     end
@@ -22,8 +26,8 @@ module RedisGeodata
     end
 
     def geosearch(longitude, latitude)
-      list = @redis.georadius(@key, longitude, latitude, @epsilon, 'km')
-      list.reject! { |point| point == longitude.to_s + "," + latitude.to_s }
+      list = @redis.georadius(@key, longitude, latitude, @epsilon, "km")
+      list.reject! { |point| point == "#{longitude},#{latitude}" }
       list
     end
   end
@@ -36,5 +40,3 @@ module RedisGeodata
     @redis.geosearch(*args)
   end
 end
-
-include RedisGeodata

data/lib/gtfs_stops_clustering/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GtfsStopsClustering
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/gtfs_stops_clustering.rb

@@ -1,31 +1,37 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
+
 # lib/gtfs_stops_clustering.rb
-require 'rubygems'
-require 'bundler/setup'
+
+require "rubygems"
+require "bundler/setup"
 require_relative "gtfs_stops_clustering/version"
-require 'gtfs'
-require 'csv'
-require_relative './gtfs_stops_clustering/data_import'
-require_relative './gtfs_stops_clustering/dbscan'
+require "gtfs"
+require "csv"
+require_relative "./gtfs_stops_clustering/data_import"
+require_relative "./gtfs_stops_clustering/dbscan"
+require_relative "./gtfs_stops_clustering/input_consistency_checks"
 
+# GtfsStopClustering module
 module GtfsStopsClustering
-  VERSION = GtfsStopsClustering::VERSION
   attr_accessor :gtfs_stops_clustering
 
+  # GtfsStopsClustering class
   class GtfsStopsClustering
-    attr_accessor :clusters, :gtfs_urls, :gtfs_stops, :stops_config_path, :epsilon, :min_points, :names_similarity
+    include InputConsistencyChecks
+    include DataImport
+    include DBSCAN
+    attr_accessor :clusters, :gtfs_paths, :gtfs_stops, :stops_config_path, :epsilon, :min_points, :names_similarity
 
-    def initialize(gtfs_urls, epsilon, min_points, names_similarity, stops_config_path)
+    def initialize(gtfs_paths, epsilon, min_points, names_similarity, stops_config_path)
+      @gtfs_paths = gtfs_paths
+      @stops_config_path = stops_config_path
+      @epsilon = epsilon
+      @min_points = min_points
+      @names_similarity = names_similarity
+      input_consistency_checks(@gtfs_paths, @epsilon, @min_points, @names_similarity, @stops_config_path)
       @clusters = []
-      unless gtfs_urls.empty?
-        @gtfs_paths = gtfs_urls
-        @stops_config_path = stops_config_path
-        @epsilon = epsilon
-        @min_points = min_points
-        @names_similarity = names_similarity
-        @gtfs_stops = create_stops_merged
-        clusterize_stops_csv(@gtfs_stops)
-      end
+      @gtfs_stops = create_stops_merged
+      clusterize_stops
     end
 
     def create_stops_merged
@@ -37,11 +43,20 @@ module GtfsStopsClustering
       gtfs_stops.flatten
     end
 
-    def clusterize_stops_csv(stops_merged)
-      data = import_stops_data(stops_merged, @stops_config_path)
-      @clusters = DBSCAN( data[:stops_data], data[:stops_redis_geodata], :epsilon => @epsilon, :min_points => @min_points, :similarity => @names_similarity, :distance => :haversine_distance2, :labels => data[:stops_names] )
+    def clusterize_stops
+      data = import_stops_data(@gtfs_stops, @stops_config_path)
+      @clusters = DBSCAN(data[:stops_data],
+                         data[:stops_redis_geodata],
+                         epsilon: @epsilon,
+                         min_points: @min_points,
+                         similarity: @names_similarity,
+                         distance: :haversine_distance2,
+                         labels: data[:stops_names])
+      map_clustered_stops
+    end
 
-      @clusters.each do |cluster_id, cluster|
+    def map_clustered_stops
+      @clusters.each_value do |cluster|
         cluster.each do |stop|
           gtfs_stop = @gtfs_stops.find { |e| e.lat == stop[:stop_lat] && e.lon == stop[:stop_lon] }
           stop[:stop_id] = gtfs_stop.id
@@ -49,24 +64,11 @@ module GtfsStopsClustering
           stop[:parent_station] = gtfs_stop.parent_station
         end
       end
-
-      output_path = 'stop_clusters.txt'
-      File.open(output_path, 'w') do |file|
-        @clusters.each do |cluster_id, cluster |
-          file.puts "Cluster #{cluster_id}"
-          cluster.each do |point|
-            file.puts point.inspect
-          end
-          file.puts
-        end
-      end
     end
   end
 
-  def build(gtfs_urls, epsilon, min_points, names_similarity = 1, stop_config_path = '')
-    @gtfs_stops_clustering = GtfsStopsClustering.new(gtfs_urls, epsilon, min_points, names_similarity, stop_config_path)
+  def build_clusters(gtfs_paths, epsilon, min_points, names_similarity = 1, stop_config_path = "")
+    @gtfs_stops_clustering = GtfsStopsClustering.new(gtfs_paths, epsilon, min_points, names_similarity, stop_config_path)
     @gtfs_stops_clustering.clusters
   end
 end
-
-include GtfsStopsClustering

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: gtfs_stops_clustering
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
-- Visco01
+- Pietro Visconti
 autorequire:
 bindir: exe
 cert_chain: []
 date: 2023-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: gtfs
+  name: csv
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.1
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.1
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.8
 - !ruby/object:Gem::Dependency
   name: distance_measures
   requirement: !ruby/object:Gem::Requirement
@@ -39,85 +45,107 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.0.6
 - !ruby/object:Gem::Dependency
-  name: text
+  name: geocoder
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.8'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.1
+        version: 1.8.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.8'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.1
+        version: 1.8.2
 - !ruby/object:Gem::Dependency
-  name: geocoder
+  name: gtfs
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.8.2
+        version: 0.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.8.2
+        version: 0.4.1
 - !ruby/object:Gem::Dependency
-  name: csv
+  name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '5.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.8
+        version: 5.0.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '5.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.8
+        version: 5.0.8
 - !ruby/object:Gem::Dependency
-  name: redis
+  name: text
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '1.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.8
+        version: 1.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '1.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.8
+        version: 1.3.1
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.2
 description: A gem to read GTFS stops data and create clusters based on coordinates
   and stop names' similarities.
 email:
@@ -129,6 +157,7 @@ files:
 - lib/gtfs_stops_clustering.rb
 - lib/gtfs_stops_clustering/data_import.rb
 - lib/gtfs_stops_clustering/dbscan.rb
+- lib/gtfs_stops_clustering/input_consistency_checks.rb
 - lib/gtfs_stops_clustering/redis_geodata.rb
 - lib/gtfs_stops_clustering/version.rb
 homepage: https://github.com/Visco01/gtfs_stops_clustering