RubyGems - git-fit - Versions diffs - 0.17.8 → 0.18.0 - Mend

git-fit 0.17.8 → 0.18.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

checksums.yaml +4 -4
data/lib/git-fit.rb +1 -0
data/lib/git_fit/cli/elevation.rb +68 -0
data/lib/git_fit/elevation/backfill.rb +64 -9
data/lib/git_fit/elevation/data/dem_coeff.json +71 -0
data/lib/git_fit/elevation/data/dem_lookup.json +258 -0
data/lib/git_fit/elevation/terrain_coeff.rb +126 -0
data/lib/git_fit/elevation/train/collector.rb +228 -0
data/lib/git_fit/elevation/train/fitter.rb +166 -0
data/lib/git_fit/elevation/train/runner.rb +66 -0
data/lib/git_fit/sync/base.rb +55 -0
data/lib/git_fit/sync/xingzhe.rb +3 -2
data/lib/git_fit/version.rb +1 -1
metadata +21 -1

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63105e40b78dfc16931efa9ffe2b88e9ac53b576f2ce14857401d818d6375c5a
-  data.tar.gz: 792778796644fd2117a9e57b1cb330b2a337ac02010f4297e170639f64b9fa4b
+  metadata.gz: f1036c14a867417be89ed1c100aa71de434f38695c49540ef56bf2b7e7d197f9
+  data.tar.gz: 66b405c18d393b552ac0e1c0000b92a66f695c6939432af2228f7a4230fd38fe
 SHA512:
-  metadata.gz: e6787fb194f869eb5dd48226b617e2d9757cbfb9ee6cfc657018f9e0f868f3018bb66b3a63718ef9d919836298ce0f3e612504bf77fc033a2286dcaaf7c9dd35
-  data.tar.gz: 1ef52c06c6a9ff330e7e22dd0bb89152bcbeeb861b430a04ffa1841e8e0280ff6e859e2b12007090784e0e692be2fa0b6a6488b1eae825ca44130a3de2d87a5b
+  metadata.gz: d2b3c47c8b27144718d11303a7127ed6a7734e7e6015cca0c9c40ab52ec6ea08c07b1f9d5df7b9f491eeb5928f6034bc6a94e56cf5616954b0298dbbfae3e46f
+  data.tar.gz: 7f022ddad0be9ff9709310aef97f3ec4016224d719747cb0a5e6c5f7f484390dafa5257633161c187b5f8d51efaaafcc86f6e7480ff5d5f6e905db1287885932

data/lib/git-fit.rb CHANGED Viewed

@@ -95,6 +95,7 @@ require_relative 'git_fit/cli/geo_cli'
 require_relative 'git_fit/strava_web/file_check'
 require_relative 'git_fit/cli/elevation'
 require_relative 'git_fit/elevation/backfill'
+require_relative 'git_fit/elevation/terrain_coeff'
 require_relative 'git_fit/cli/strava'
 require_relative 'git_fit/auth/garmin_token'
 require_relative 'git_fit/auth/strava'

data/lib/git_fit/cli/elevation.rb CHANGED Viewed

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'thor'
+require_relative '../elevation/train/runner'
 module GitFit
   class ElevationCLI < Thor
@@ -26,5 +27,72 @@ module GitFit
     rescue StandardError => e
       say_status :error, "Elevation backfill failed: #{e.message}", :red
     end
+    desc 'train', 'Train DEM terrain coefficient model from activity data'
+    option :sources, type: :string, default: nil, desc: 'Comma-separated source adapters (default: all)'
+    option :output, type: :string, default: nil, desc: 'Output path for model file'
+    def train
+      sources = options[:sources]&.split(',')&.map(&:strip)
+      output = options[:output]
+      say_status :info, 'Starting model training...', :green
+      runner = GitFit::Elevation::Train::Runner.new(sources: sources, output: output)
+      success = runner.run
+      if success
+        say_status :done, 'Training complete', :green
+      else
+        say_status :error, 'Training failed', :red
+        exit 1
+      end
+    rescue StandardError => e
+      say_status :error, "Training failed: #{e.message}", :red
+      say_status :error, e.backtrace.first(5).join("\n"), :red
+      exit 1
+    end
+    desc 'infer GAIN_PER_KM RANGE_PER_KM SEG_DENSITY', 'Infer optimal h threshold for terrain'
+    def infer(gain_per_km, range_per_km, seg_density)
+      g = gain_per_km.to_f
+      r = range_per_km.to_f
+      s = seg_density.to_f
+      m = GitFit::Elevation::TerrainCoeff.terrain_M(
+        gain_per_km: g,
+        range_per_km: r,
+        seg_density: s
+      )
+      h = GitFit::Elevation::TerrainCoeff.hysteresis_threshold(m)
+      spacing = GitFit::Elevation::TerrainCoeff.dem_spacing(
+        gain_per_km: g,
+        range_per_km: r,
+        seg_density: s
+      )
+      say "terrain_M: #{format('%.3f', m)}"
+      say "h_threshold: #{format('%.1f', h)}"
+      say "dem_spacing: #{spacing}m"
+    rescue StandardError => e
+      say_status :error, "Inference failed: #{e.message}", :red
+      exit 1
+    end
+    desc 'model-info', 'Show information about the loaded DEM model'
+    def model_info
+      model = GitFit::Elevation::TerrainCoeff.model
+      path = GitFit::Elevation::TerrainCoeff.model_path
+      say "Model path: #{path}"
+      say "n_samples: #{model['meta']['n_samples']}"
+      say "trained_at: #{model['meta']['trained_at']}"
+      say "sources: #{model['meta']['sources'].join(', ')}"
+      say "ridge_h: #{model['ridge_h'].map { |w| format('%.4f', w) }.join(', ')}"
+      say "norms: #{model['norms'].map { |n| format('%.4f', n) }.join(', ')}"
+      say "pav_h entries: #{model['pav_h'].size}"
+      say "lookup entries: #{model['lookup'].size}"
+    rescue StandardError => e
+      say_status :error, "Failed to load model: #{e.message}", :red
+      exit 1
+    end
   end
 end

data/lib/git_fit/elevation/backfill.rb CHANGED Viewed

@@ -5,6 +5,8 @@ module GitFit
     class Backfill
       SOURCES = %w[igpsport xoss strava garmin garmin_cn xingzhe].freeze
       BATCH_SIZE = 100
+      # Fallback threshold when detail.json elevation is absent (issue #83: baro 2m / GPS 3m).
+      ELEV_THRESHOLD = 2.0
       def initialize(db, force: false)
         @db = db
@@ -129,20 +131,47 @@ module GitFit
         end
         raw = JSON.parse(File.read(raw_path))
-        alts = raw.dig('stream', 'altitude') || []
+        alts = (raw.dig('stream', 'altitude') || raw.dig('data', 'altitude') || []).map(&:to_f)
         return nil if alts.size < 2
+        # detail.json stores the inner API payload ({workout:...}); legacy wraps it in
+        # {code,data:{workout:...},msg}. Prefer xingzhe's own processed elevation.
+        detail = xingzhe_detail_workout(natural_id)
+        dg = detail && detail['elevation_gain']
+        dl = detail && detail['elevation_loss']
+        dm = detail && detail['max_altitude']
+        gain = detail_gain?(dg) ? dg : elevation_gain_from_alts(alts, threshold: ELEV_THRESHOLD)
+        loss = detail_gain?(dl) ? dl : elevation_loss_from_alts(alts, threshold: ELEV_THRESHOLD)
+        # max: detail max_altitude is reliable (matches stream max in samples); else raw max.
+        # min: stream is per-track baro-offset, so only drop low spikes, keep the bulk.
+        filtered = self.class.filter_low_outliers(alts)
         {
-          elevation_gain: elevation_gain_from_alts(alts)&.round(1),
-          elevation_loss: elevation_loss_from_alts(alts)&.round(1),
-          elevation_min: alts.min&.round(1),
-          elevation_max: alts.max&.round(1),
+          elevation_gain: gain&.to_f&.round(1),
+          elevation_loss: loss&.to_f&.round(1),
+          elevation_min: (filtered.min || alts.min)&.round(1),
+          elevation_max: (dm.is_a?(Numeric) && dm > 0 ? dm : alts.max)&.round(1),
         }
       rescue StandardError => e
         warn "Elevation backfill [xingzhe][#{natural_id}]: #{e.message}"
         nil
       end
+      def xingzhe_detail_workout(natural_id)
+        path = File.join('data', 'raw', 'xingzhe', natural_id, 'detail.json')
+        return nil unless File.exist?(path)
+        d = JSON.parse(File.read(path))
+        d['workout'] || d.dig('data', 'workout')
+      rescue StandardError
+        nil
+      end
+      def detail_gain?(value)
+        value.is_a?(Numeric) && !value.zero?
+      end
       def fit_path_for(source, natural_id)
         case source
         when 'garmin', 'garmin_cn'
@@ -152,19 +181,19 @@ module GitFit
         end
       end
-      def elevation_gain_from_alts(alts)
+      def elevation_gain_from_alts(alts, threshold: 0.0)
         return 0.0 if alts.size < 2
         (1...alts.size).sum do |i|
           d = alts[i] - alts[i - 1]
-          d > 0 ? d : 0.0
+          d > threshold ? d : 0.0
         end
       end
-      def elevation_loss_from_alts(alts)
+      def elevation_loss_from_alts(alts, threshold: 0.0)
         return 0.0 if alts.size < 2
         (1...alts.size).sum do |i|
           d = alts[i - 1] - alts[i]
-          d > 0 ? d : 0.0
+          d > threshold ? d : 0.0
         end
       end
@@ -182,6 +211,32 @@ module GitFit
       def skip_row(_run_id)
         @skipped += 1
       end
+      class << self
+        # Drop only implausibly-low altitude spikes (baro dropouts), leaving the
+        # genuinely shifted bulk intact. Lower fence = median - factor*1.4826*MAD.
+        def filter_low_outliers(altitudes, factor = 2.0)
+          return altitudes if altitudes.size < 4
+          med = median(altitudes)
+          m = mad(altitudes)
+          return altitudes if m.zero?
+          fence = med - factor * 1.4826 * m
+          altitudes.reject { |x| x < fence }
+        end
+        def median(values)
+          s = values.sort
+          n = s.size
+          n.odd? ? s[n / 2] : (s[n / 2 - 1] + s[n / 2]) / 2.0
+        end
+        def mad(values)
+          med = median(values)
+          median(values.map { |x| (x - med).abs })
+        end
+      end
     end
   end
 end

data/lib/git_fit/elevation/data/dem_coeff.json ADDED Viewed

@@ -0,0 +1,71 @@
+{
+  "ridge_h": [
+    -9.077306137000443,
+    9.101690938636672,
+    9.807689833104916
+  ],
+  "ridge_sp": [
+    -5602.015438422995,
+    5616.104008380678,
+    5818.3088293975225
+  ],
+  "norms": [
+    77.2704957436896,
+    46.66281025695705,
+    14.46934427879514
+  ],
+  "m_sp_min": 63.198201967279374,
+  "m_sp_max": 2332.5556989722154,
+  "pav_h": [
+    [
+      0.1995542278184373,
+      2.35
+    ],
+    [
+      1.481813577725186,
+      2.5407407407407407
+    ],
+    [
+      3.828455149726031,
+      3.0
+    ]
+  ],
+  "pav_sp": [
+    [
+      63.198201967279374,
+      181
+    ],
+    [
+      79.26058601733692,
+      181
+    ],
+    [
+      137.69617766559736,
+      181
+    ],
+    [
+      189.56765019390437,
+      181
+    ],
+    [
+      408.8898267340851,
+      484.1666666666667
+    ],
+    [
+      941.936471891145,
+      1090.5
+    ],
+    [
+      1007.4609047802492,
+      1090.5
+    ],
+    [
+      1099.4112110983888,
+      1090.5
+    ],
+    [
+      1501.4530064189416,
+      1818.1
+    ]
+  ]
+}

data/lib/git_fit/elevation/data/dem_lookup.json ADDED Viewed

@@ -0,0 +1,258 @@
+[
+  {
+    "id": "56279644",
+    "gain_per_km": 4.765179852943763,
+    "range_per_km": 0.7625839940557885,
+    "seg_density": 1.8781327759159456,
+    "h_opt": 3.0,
+    "spacing_opt": 181
+  },
+  {
+    "id": "56076463",
+    "gain_per_km": 2.5838808834684825,
+    "range_per_km": 1.1287975976320341,
+    "seg_density": 0.9807431090537306,
+    "h_opt": 3.0,
+    "spacing_opt": 181
+  },
+  {
+    "id": "56368591",
+    "gain_per_km": 5.241385983727518,
+    "range_per_km": 4.475337263028882,
+    "seg_density": 1.8143259174441408,
+    "h_opt": 2.8,
+    "spacing_opt": 181
+  },
+  {
+    "id": "56796734",
+    "gain_per_km": 2.0541248195793695,
+    "range_per_km": 1.2965635861184979,
+    "seg_density": 0.9585915824703723,
+    "h_opt": 3.0,
+    "spacing_opt": 181
+  },
+  {
+    "id": "55976107",
+    "gain_per_km": 6.7209275220280364,
+    "range_per_km": 1.925247972449297,
+    "seg_density": 1.6589631225259078,
+    "h_opt": 2.4,
+    "spacing_opt": 181
+  },
+  {
+    "id": "180371339",
+    "gain_per_km": 25.97697790333317,
+    "range_per_km": 7.576618555138841,
+    "seg_density": 5.4118703965277435,
+    "h_opt": 2.7,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "56401403",
+    "gain_per_km": 2.7229837022259686,
+    "range_per_km": 1.8266921193985366,
+    "seg_density": 0.2866298633922072,
+    "h_opt": 2.4,
+    "spacing_opt": 181
+  },
+  {
+    "id": "179672989",
+    "gain_per_km": 20.280751374432,
+    "range_per_km": 12.60695355707935,
+    "seg_density": 3.288770493151135,
+    "h_opt": 2.1,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "56760049",
+    "gain_per_km": 5.749624549516914,
+    "range_per_km": 16.696909691797117,
+    "seg_density": 1.8398798558454126,
+    "h_opt": 3.0,
+    "spacing_opt": 181
+  },
+  {
+    "id": "179545783",
+    "gain_per_km": 1.8039361887638827,
+    "range_per_km": 7.648689440358862,
+    "seg_density": 0.6013120629212942,
+    "h_opt": 2.4,
+    "spacing_opt": 181
+  },
+  {
+    "id": "56368216",
+    "gain_per_km": 1.6348493836617806,
+    "range_per_km": 1.3127840550804097,
+    "seg_density": 0.7006497358550489,
+    "h_opt": 2.9,
+    "spacing_opt": 181
+  },
+  {
+    "id": "56773391",
+    "gain_per_km": 1.547936269252457,
+    "range_per_km": 2.0156341563194493,
+    "seg_density": 0.663401258251053,
+    "h_opt": 3.0,
+    "spacing_opt": 181
+  },
+  {
+    "id": "180413248",
+    "gain_per_km": 21.454009754423105,
+    "range_per_km": 12.872405852653861,
+    "seg_density": 3.5756682924038503,
+    "h_opt": 2.1,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "55976106",
+    "gain_per_km": 34.171060177704426,
+    "range_per_km": 22.758524258835656,
+    "seg_density": 1.7945414535337114,
+    "h_opt": 2.7,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "179764068",
+    "gain_per_km": 21.476015892251763,
+    "range_per_km": 13.80601021644756,
+    "seg_density": 3.06800227032168,
+    "h_opt": 2.1,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "59677573",
+    "gain_per_km": 2.221466453476413,
+    "range_per_km": 1.0819070549014291,
+    "seg_density": 0.6347047009932608,
+    "h_opt": 2.8,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "62178115",
+    "gain_per_km": 1.665072953982141,
+    "range_per_km": 1.4533708212615546,
+    "seg_density": 0.5946689121364789,
+    "h_opt": 2.4,
+    "spacing_opt": 181
+  },
+  {
+    "id": "56736143",
+    "gain_per_km": 6.182563686588538,
+    "range_per_km": 10.307570178280413,
+    "seg_density": 1.4838152847812491,
+    "h_opt": 2.0,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "179741390",
+    "gain_per_km": 15.338810730874666,
+    "range_per_km": 15.732113570127863,
+    "seg_density": 2.753119874772376,
+    "h_opt": 2.1,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "60509717",
+    "gain_per_km": 3.755389344804926,
+    "range_per_km": 1.178662648079095,
+    "seg_density": 0.48146017241088795,
+    "h_opt": 2.9,
+    "spacing_opt": 181
+  },
+  {
+    "id": "180371336",
+    "gain_per_km": 22.172949002217294,
+    "range_per_km": 7.390983000739098,
+    "seg_density": 4.106101667077277,
+    "h_opt": 2.1,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "60220082",
+    "gain_per_km": 1.441196526868075,
+    "range_per_km": 0.9058299433609764,
+    "seg_density": 0.6826720390427724,
+    "h_opt": 2.5,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "179909296",
+    "gain_per_km": 19.591333127693808,
+    "range_per_km": 8.3367375011463,
+    "seg_density": 3.7515318755158353,
+    "h_opt": 2.1,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "180371341",
+    "gain_per_km": 20.886092473174426,
+    "range_per_km": 7.83228467744041,
+    "seg_density": 4.351269265244672,
+    "h_opt": 2.0,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "56700083",
+    "gain_per_km": 0.8884413776764299,
+    "range_per_km": 0.5341013415464805,
+    "seg_density": 0.19743141726142888,
+    "h_opt": 2.1,
+    "spacing_opt": 181
+  },
+  {
+    "id": "61808448",
+    "gain_per_km": 1.1360659928112273,
+    "range_per_km": 0.7833175020433414,
+    "seg_density": 0.4418034416488107,
+    "h_opt": 2.0,
+    "spacing_opt": 181
+  },
+  {
+    "id": "179802794",
+    "gain_per_km": 22.273614770723942,
+    "range_per_km": 9.004227247739466,
+    "seg_density": 5.212973669743901,
+    "h_opt": 2.0,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "179709155",
+    "gain_per_km": 21.558002680184117,
+    "range_per_km": 6.409135931946629,
+    "seg_density": 5.243838489774515,
+    "h_opt": 2.8,
+    "spacing_opt": 2000
+  },
+  {
+    "id": "28381323",
+    "gain_per_km": 5.663397691876494,
+    "range_per_km": 5.132309683832157,
+    "seg_density": 1.8492727157147735,
+    "h_opt": 2.9,
+    "spacing_opt": 181
+  },
+  {
+    "id": "59677574",
+    "gain_per_km": 2.483839907960171,
+    "range_per_km": 0.51876770649111,
+    "seg_density": 0.9183945878172062,
+    "h_opt": 3.0,
+    "spacing_opt": 181
+  },
+  {
+    "id": "56151030",
+    "gain_per_km": 2.193824384358032,
+    "range_per_km": 3.9247518236165186,
+    "seg_density": 1.9744419459222284,
+    "h_opt": 2.9,
+    "spacing_opt": 181
+  },
+  {
+    "id": "56300530",
+    "gain_per_km": 5.034207439551756,
+    "range_per_km": 1.833613248175197,
+    "seg_density": 1.858784285372956,
+    "h_opt": 2.8,
+    "spacing_opt": 181
+  }
+]

data/lib/git_fit/elevation/terrain_coeff.rb ADDED Viewed

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+require 'msgpack'
+require 'net/http'
+require 'uri'
+module GitFit
+  module Elevation
+    module TerrainCoeff
+      CACHE_DIR = ENV.fetch('GIT_FIT_DEM_CACHE_DIR', 'data/cache/dem_fit')
+      DEM_CACHE_DIR = File.join(CACHE_DIR, 'cache')
+      BUNDLED_MODEL_DIR = File.expand_path('model', __dir__)
+      BUNDLED_MODEL = File.join(BUNDLED_MODEL_DIR, 'dem_model.msgpack')
+      MODEL_FILE = 'dem_model.msgpack'
+      DEM_URL = 'https://api.opentopodata.org/v1/srtm30m'
+      GRID = 0.0003
+      class << self
+        def model_path
+          @model_path ||= find_model
+        end
+        def model
+          @model ||= MessagePack.unpack(File.read(model_path))
+        end
+        def find_model
+          cache_path = File.join(CACHE_DIR, MODEL_FILE)
+          return cache_path if File.exist?(cache_path)
+          return BUNDLED_MODEL if File.exist?(BUNDLED_MODEL)
+          raise "No #{MODEL_FILE} found in cache (#{CACHE_DIR}) or bundled (#{BUNDLED_MODEL})"
+        end
+        def reset!
+          @model_path = nil
+          @model = nil
+        end
+        def terrain_M(gain_per_km:, range_per_km:, seg_density:)
+          g = gain_per_km.to_f
+          r = range_per_km.to_f
+          s = seg_density.to_f
+          norms = model['norms']
+          g_n = g / norms[0]
+          r_n = r / norms[1]
+          s_n = s / norms[2]
+          w = model['ridge_h']
+          g_n * w[0] + r_n * w[1] + s_n * w[2]
+        end
+        def hysteresis_threshold(m)
+          return 2.0 if m <= 0
+          pav = model['pav_h']
+          return 2.0 if m <= pav[0][0]
+          return pav[-1][1] if m >= pav[-1][0]
+          pav.each_with_index do |(xk, yk), i|
+            next unless i + 1 < pav.size
+            return yk if m <= pav[i + 1][0]
+          end
+          pav[-1][1]
+        end
+        def dem_spacing(gain_per_km:, range_per_km:, seg_density:)
+          nearest_neighbor_spacing(gain_per_km, range_per_km, seg_density)
+        rescue => e
+          warn "TerrainCoeff: dem_spacing fallback to 181m (#{e.message})"
+          181
+        end
+        def elevations_for(locations)
+          uniq = {}
+          locations.each { |lat, lng| uniq[grid_key(lat, lng)] ||= [lat, lng] }
+          uniq_vals = uniq.values
+          elevs = {}
+          uniq_vals.each_slice(100).with_index do |slice, bi|
+            qs = slice.map { |la, ln| "#{la},#{ln}" }.join('|')
+            uri = URI("#{DEM_URL}?locations=#{URI.encode_www_form_component(qs)}")
+            begin
+              res = Net::HTTP.get_response(uri)
+              if res.code == '200'
+                results = JSON.parse(res.body)['results']
+                slice.each_with_index do |(lat, lng), i|
+                  elevs[grid_key(lat, lng)] = results[i]['elevation'] if results[i]
+                end
+              else
+                warn "DEM batch #{bi} HTTP #{res.code}"
+              end
+            rescue StandardError => e
+              warn "DEM batch #{bi}: #{e.message}"
+            end
+            sleep 0.15
+          end
+          locations.map { |lat, lng| elevs[grid_key(lat, lng)] }
+        end
+        def grid_key(lat, lng)
+          "#{(lat / GRID).round}/#{(lng / GRID).round}"
+        end
+        def lookup
+          model['lookup']
+        end
+        private
+        def nearest_neighbor_spacing(gain_per_km, range_per_km, seg_density)
+          best = nil
+          best_dist = Float::INFINITY
+          lookup.each do |ref|
+            d = Math.sqrt(
+              (gain_per_km.to_f - ref['gk'])**2 +
+              (range_per_km.to_f - ref['rk'])**2 +
+              (seg_density.to_f - ref['sd'])**2
+            )
+            next unless d < best_dist
+            best_dist = d
+            best = ref
+          end
+          best ? best['sp'] : 181
+        end
+      end
+    end
+  end
+end

data/lib/git_fit/elevation/train/collector.rb ADDED Viewed

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+require_relative '../terrain_coeff'
+module GitFit
+  module Elevation
+    module Train
+      class Collector
+        SPACINGS = [2000, 1236, 764, 472, 292, 181].freeze
+        BUDGET = 2.0
+        def initialize(sources: nil)
+          @sources = sources
+        end
+        def collect
+          samples = []
+          each_source_sample do |sample|
+            result = evaluate_sample(sample)
+            samples << result if result
+          end
+          samples
+        end
+        def each_source_sample(&block)
+          adapters = @sources ? resolve_sources(@sources) : all_adapters
+          adapters.each do |adapter|
+            begin
+              adapter.training_samples.each(&block)
+            rescue StandardError => e
+              warn "Collector: #{adapter.name} failed: #{e.message}"
+            end
+          end
+        end
+        def all_adapters
+          Sync::Base.adapters
+        end
+        def resolve_sources(names)
+          names.map do |name|
+            Sync::Base.adapters.find { |a| a.name.demodulize.downcase == name.to_s.downcase }
+          end.compact
+        end
+        def evaluate_sample(sample)
+          altitudes = sample[:altitudes]
+          distances = sample[:distances]
+          locations = sample[:locations]
+          source = sample[:source]
+          id = sample[:id]
+          return nil if altitudes.size < 2
+          return nil if distances.empty? || distances.last < 1000
+          return nil if sample[:altitudes].size < 2
+          dem = TerrainCoeff.elevations_for(locations)
+          return nil if dem.empty? || dem.compact.size < 2
+          truth_min = dem.compact.min
+          truth_max = dem.compact.max
+          sm = smooth(altitudes)
+          best = nil
+          (2.0..3.0).step(0.1).each do |h|
+            h = h.round(2)
+            segs = segments(sm, h)
+            chosen = nil
+            SPACINGS.each do |sp|
+              sel = sample_indices(sm, segs, distances, sp)
+              lmin, lmax, npts = layered_estimate(dem, sel)
+              err = [ (lmin - truth_min).abs, (lmax - truth_max).abs ].max
+              if err <= BUDGET
+                chosen = { h: h, spacing: sp, err: err, npts: npts }
+                break
+              end
+            end
+            unless chosen
+              sel = sample_indices(sm, segs, distances, SPACINGS.last)
+              lmin, lmax, npts = layered_estimate(dem, sel)
+              err = [ (lmin - truth_min).abs, (lmax - truth_max).abs ].max
+              chosen = { h: h, spacing: SPACINGS.last, err: err, npts: npts }
+            end
+            best = chosen if best.nil? || chosen[:npts] < best[:npts]
+          end
+          return nil unless best
+          f = features(altitudes, distances, locations)
+          {
+            id: id,
+            source: source,
+            truth_min: truth_min,
+            truth_max: truth_max,
+            h_opt: best[:h],
+            spacing_opt: best[:spacing],
+            err: best[:err].round(2),
+            npts: best[:npts],
+            gain_per_km: f[:gain_per_km],
+            range_per_km: f[:range_per_km],
+            seg_density: f[:seg_density]
+          }
+        end
+        def features(altitudes, distances, locations)
+          return nil if altitudes.empty? || distances.empty?
+          dm = distances.last
+          km = [dm / 1000.0, 1e-6].max
+          gain = elevation_gain(altitudes)
+          range = altitudes.empty? ? 0.0 : (altitudes.max - altitudes.min)
+          gain_per_km = gain / km
+          range_per_km = range / km
+          seg_density = segments(smooth(altitudes), 2.5).size / km
+          {
+            gain_per_km: gain_per_km,
+            range_per_km: range_per_km,
+            seg_density: seg_density,
+            distance_m: dm,
+            npts: altitudes.size
+          }
+        end
+        def elevation_gain(alts)
+          total = 0.0
+          (1...alts.size).each do |i|
+            diff = alts[i] - alts[i - 1]
+            total += diff if diff > 0
+          end
+          total
+        end
+        def smooth(vals)
+          moving_avg(moving_median(vals, 9), 9)
+        end
+        def moving_median(vals, w)
+          half = w / 2
+          (0...vals.size).map do |i|
+            lo = [0, i - half].max
+            hi = [vals.size - 1, i + half].min
+            vals[lo..hi].sort[(hi - lo) / 2]
+          end
+        end
+        def moving_avg(vals, w)
+          half = w / 2
+          (0...vals.size).map do |i|
+            lo = [0, i - half].max
+            hi = [vals.size - 1, i + half].min
+            vals[lo..hi].sum.to_f / (hi - lo + 1)
+          end
+        end
+        def segments(smooth, h, min_len: 20)
+          n = smooth.size
+          return [[0, n - 1]] if n < 2
+          segs = []
+          seg_start = 0
+          ext_val = smooth[0]
+          ext_idx = 0
+          rising = nil
+          (1...n).each do |i|
+            v = smooth[i]
+            if rising.nil?
+              if v > ext_val
+                ext_val = v; ext_idx = i; rising = true
+              elsif v < ext_val
+                ext_val = v; ext_idx = i; rising = false
+              end
+            elsif rising
+              if v > ext_val
+                ext_val = v; ext_idx = i
+              elsif ext_val - v >= h
+                segs << [seg_start, ext_idx] if ext_idx - seg_start >= min_len
+                seg_start = ext_idx if ext_idx - seg_start >= min_len
+                rising = false
+                ext_val = v; ext_idx = i
+              end
+            else
+              if v < ext_val
+                ext_val = v; ext_idx = i
+              elsif v - ext_val >= h
+                segs << [seg_start, ext_idx] if ext_idx - seg_start >= min_len
+                seg_start = ext_idx if ext_idx - seg_start >= min_len
+                rising = true
+                ext_val = v; ext_idx = i
+              end
+            end
+          end
+          segs << [seg_start, n - 1] if n - 1 - seg_start >= min_len
+          segs.empty? ? [[0, n - 1]] : segs
+        end
+        def sample_indices(smooth, segs, dist, spacing)
+          sel = Set.new
+          segs.each { |a, b| sel << a; sel << b }
+          segs.each do |a, b|
+            next if b - a < 2
+            d0 = dist[a].to_f
+            d1 = dist[b].to_f
+            len = d1 - d0
+            seg_range = smooth[a..b].max - smooth[a..b].min
+            next unless len > 500 && seg_range < 3.0
+            k = 1
+            while d0 + k * spacing < d1
+              target = d0 + k * spacing
+              idx = a + ((b - a) * (target - d0) / len).round
+              sel << idx
+              k += 1
+            end
+          end
+          sel.to_a.sort
+        end
+        def layered_estimate(dem, sel)
+          vals = sel.map { |i| dem[i] }.compact
+          return [nil, nil, 0] if vals.empty?
+          [vals.min, vals.max, vals.size]
+        end
+      end
+    end
+  end
+end

data/lib/git_fit/elevation/train/fitter.rb ADDED Viewed

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+require 'msgpack'
+require_relative '../terrain_coeff'
+module GitFit
+  module Elevation
+    module Train
+      class Fitter
+        def initialize(samples)
+          @samples = samples
+        end
+        def fit
+          return nil if @samples.empty?
+          ridge_h = fit_ridge_h
+          norms = compute_norms
+          pav_h = fit_pav_h
+          lookup = build_lookup
+          meta = build_meta
+          {
+            ridge_h: ridge_h,
+            norms: norms,
+            pav_h: pav_h,
+            lookup: lookup,
+            meta: meta
+          }
+        end
+        def write_msgpack(path)
+          model = fit
+          return false unless model
+          dir = File.dirname(path)
+          FileUtils.mkdir_p(dir)
+          tmp = "#{path}.tmp"
+          File.write(tmp, model.to_msgpack)
+          File.rename(tmp, path)
+          true
+        end
+        private
+        def fit_ridge_h
+          g = @samples.map { |s| s[:gain_per_km] }
+          r = @samples.map { |s| s[:range_per_km] }
+          sd = @samples.map { |s| s[:seg_density] }
+          h = @samples.map { |s| s[:h_opt] }
+          n = g.size
+          return [0, 0, 0] if n < 2
+          g_mean = g.sum.to_f / n
+          r_mean = r.sum.to_f / n
+          sd_mean = sd.sum.to_f / n
+          h_mean = h.sum.to_f / n
+          g_std = Math.sqrt(g.map { |x| (x - g_mean)**2 }.sum / n)
+          r_std = Math.sqrt(r.map { |x| (x - r_mean)**2 }.sum / n)
+          sd_std = Math.sqrt(sd.map { |x| (x - sd_mean)**2 }.sum / n)
+          g_std = 1.0 if g_std.zero?
+          r_std = 1.0 if r_std.zero?
+          sd_std = 1.0 if sd_std.zero?
+          g_n = g.map { |x| (x - g_mean) / g_std }
+          r_n = r.map { |x| (x - r_mean) / r_std }
+          sd_n = sd.map { |x| (x - sd_mean) / sd_std }
+          numerator0 = (0...n).sum { |i| g_n[i] * (h[i] - h_mean) }
+          numerator1 = (0...n).sum { |i| r_n[i] * (h[i] - h_mean) }
+          numerator2 = (0...n).sum { |i| sd_n[i] * (h[i] - h_mean) }
+          denominator = (0...n).sum { |i| g_n[i]**2 }
+          w0 = numerator0 / denominator
+          w1 = numerator1 / denominator
+          w2 = numerator2 / denominator
+          [w0, w1, w2]
+        end
+        def compute_norms
+          g = @samples.map { |s| s[:gain_per_km] }
+          r = @samples.map { |s| s[:range_per_km] }
+          sd = @samples.map { |s| s[:seg_density] }
+          n = g.size
+          return [1.0, 1.0, 1.0] if n < 2
+          g_mean = g.sum.to_f / n
+          r_mean = r.sum.to_f / n
+          sd_mean = sd.sum.to_f / n
+          g_std = Math.sqrt(g.map { |x| (x - g_mean)**2 }.sum / n)
+          r_std = Math.sqrt(r.map { |x| (x - r_mean)**2 }.sum / n)
+          sd_std = Math.sqrt(sd.map { |x| (x - sd_mean)**2 }.sum / n)
+          [g_std, r_std, sd_std]
+        end
+        def fit_pav_h
+          m_values = @samples.map { |s| terrain_M(s) }
+          h_values = @samples.map { |s| s[:h_opt] }
+          sorted = @samples.map.with_index { |_, i| [m_values[i], h_values[i]] }.sort_by(&:first)
+          pav = []
+          current_m = nil
+          current_h = nil
+          count = 0
+          sorted.each do |m, h|
+            if current_m.nil? || (m - current_m).abs < 0.01
+              current_m = m unless current_m
+              current_h ||= h
+              current_h = [current_h, h].min
+              count += 1
+            else
+              pav << [current_m, current_h.round(1)] if count > 0
+              current_m = m
+              current_h = h
+              count = 1
+            end
+          end
+          pav << [current_m, current_h.round(1)] if count > 0
+          pav
+        end
+        def terrain_M(sample)
+          g = sample[:gain_per_km].to_f
+          r = sample[:range_per_km].to_f
+          s = sample[:seg_density].to_f
+          norms = compute_norms
+          g_n = g / norms[0]
+          r_n = r / norms[1]
+          s_n = s / norms[2]
+          w = fit_ridge_h
+          g_n * w[0] + r_n * w[1] + s_n * w[2]
+        end
+        def build_lookup
+          @samples.map do |s|
+            {
+              'gk' => s[:gain_per_km],
+              'rk' => s[:range_per_km],
+              'sd' => s[:seg_density],
+              'h' => s[:h_opt],
+              'sp' => s[:spacing_opt]
+            }
+          end
+        end
+        def build_meta
+          {
+            'n_samples' => @samples.size,
+            'trained_at' => Time.now.strftime('%Y-%m-%d'),
+            'sources' => @samples.map { |s| s[:source] }.uniq
+          }
+        end
+      end
+    end
+  end
+end

data/lib/git_fit/elevation/train/runner.rb ADDED Viewed

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+require_relative 'collector'
+require_relative 'fitter'
+require 'fileutils'
+module GitFit
+  module Elevation
+    module Train
+      class Runner
+        CACHE_DIR = 'data/cache/dem_fit'
+        MODEL_FILE = 'dem_model.msgpack'
+        def initialize(sources: nil, output: nil)
+          @sources = sources
+          @output = output || default_output_path
+        end
+        def run
+          puts "Collecting samples..."
+          collector = Collector.new(sources: @sources)
+          samples = collector.collect
+          if samples.empty?
+            warn "No samples collected"
+            return false
+          end
+          puts "Collected #{samples.size} samples"
+          puts "Fitting model..."
+          fitter = Fitter.new(samples)
+          model = fitter.fit
+          unless model
+            warn "Fitting failed"
+            return false
+          end
+          puts "Writing model to #{@output}..."
+          unless fitter.write_msgpack(@output)
+            warn "Failed to write model"
+            return false
+          end
+          puts "Model trained successfully!"
+          puts "  n_samples: #{model[:meta]['n_samples']}"
+          puts "  sources: #{model[:meta]['sources'].join(', ')}"
+          puts "  ridge_h: #{model[:ridge_h].map { |w| format('%.2f', w) }.join(', ')}"
+          puts "  output: #{@output}"
+          true
+        end
+        def default_output_path
+          File.join(CACHE_DIR, MODEL_FILE)
+        end
+        def self.run!(sources: nil, output: nil)
+          runner = new(sources: sources, output: output)
+          runner.run
+        end
+      end
+    end
+  end
+end

data/lib/git_fit/sync/base.rb CHANGED Viewed

@@ -208,6 +208,61 @@ module GitFit
         raise NotImplementedError, "#{self.class} must implement #raw_path"
       end
+      def self.training_samples
+        std = File.join('data', 'std', config_key)
+        return [] unless Dir.exist?(std)
+        Dir.children(std).filter_map do |f|
+          next unless f.end_with?('.json')
+          pts = JSON.parse(File.read(File.join(std, f))) rescue next
+          next unless pts.is_a?(Array) && pts.any?
+          altitudes = pts.filter_map { |p| p['altitude']&.to_f }
+          next if altitudes.size < 2
+          locations = pts.filter_map { |p| extract_location(p) }
+          next if locations.size < 2
+          distances = cumulative_distances(locations)
+          {
+            altitudes: altitudes,
+            distances: distances,
+            locations: locations,
+            source: config_key,
+            id: File.basename(f, '.json')
+          }
+        end
+      end
+      def self.extract_location(p)
+        lat = p['positionLat'] || p['latitude'] || p['lat']
+        lng = p['positionLong'] || p['longitude'] || p['lng']
+        return nil unless lat && lng
+        [lng.to_f, lat.to_f]
+      end
+      def self.cumulative_distances(locations)
+        return [] if locations.size < 2
+        dists = [0.0]
+        (1...locations.size).each do |i|
+          dists << dists.last + haversine(locations[i - 1], locations[i])
+        end
+        dists
+      end
+      def self.haversine(a, b)
+        r = 6_371_000.0
+        dlat = (b[0] - a[0]) * Math::PI / 180
+        dlon = (b[1] - a[1]) * Math::PI / 180
+        la1 = a[0] * Math::PI / 180
+        la2 = b[0] * Math::PI / 180
+        h = Math.sin(dlat / 2)**2 + Math.cos(la1) * Math.cos(la2) * Math.sin(dlon / 2)**2
+        2 * r * Math.asin(Math.sqrt(h))
+      end
       def write_source_archive(data, platform_id, ext = 'json')
         dir = raw_dir
         FileUtils.mkdir_p(dir)

data/lib/git_fit/sync/xingzhe.rb CHANGED Viewed

@@ -352,8 +352,9 @@ module GitFit
       end
       def derive_elevation_min(stream, detail_workout)
-        if stream && (alt = stream['altitude']) && alt.is_a?(Array) && alt.any?
-          v = alt.compact.min
+        if stream && (alt = stream['altitude']) && alt.is_a?(Array) && alt.size >= 2
+          alts = alt.compact.map(&:to_f)
+          v = GitFit::Elevation::Backfill.filter_low_outliers(alts).min
           return v.to_f if v
         end
         if detail_workout && (segs = detail_workout['segments_km']) && segs.is_a?(Array) && segs.any?

data/lib/git_fit/version.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module GitFit
-  VERSION = '0.17.8'
+  VERSION = '0.18.0'
 end

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-fit
 version: !ruby/object:Gem::Version
-  version: 0.17.8
+  version: 0.18.0
 platform: ruby
 authors:
 - Lax
@@ -233,6 +233,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: A git extension CLI for aggregating, managing, and exporting fitness
   activity data from multiple sources (Garmin, Strava, Keep, etc.)
 email:
@@ -279,6 +293,12 @@ files:
 - lib/git_fit/dedup/service.rb
 - lib/git_fit/dedup/trajectory.rb
 - lib/git_fit/elevation/backfill.rb
+- lib/git_fit/elevation/data/dem_coeff.json
+- lib/git_fit/elevation/data/dem_lookup.json
+- lib/git_fit/elevation/terrain_coeff.rb
+- lib/git_fit/elevation/train/collector.rb
+- lib/git_fit/elevation/train/fitter.rb
+- lib/git_fit/elevation/train/runner.rb
 - lib/git_fit/export.rb
 - lib/git_fit/export/calculator.rb
 - lib/git_fit/export/csv.rb