git-fit 0.13.0 → 0.14.0

data/lib/git_fit/fit/decoder.rb

@@ -24,6 +24,12 @@ module GitFit
         bytes = File.read(path, mode: 'rb').bytes
         CTX.eval("FitDecoder.fitSport(#{bytes.inspect})")
       end
+
+      def self.session(path)
+        bytes = File.read(path, mode: 'rb').bytes
+        json = CTX.eval("FitDecoder.fitSession(#{bytes.inspect})")
+        json ? JSON.parse(json) : nil
+      end
     end
   end
 end

data/lib/git_fit/import/apple_health.rb

@@ -147,7 +147,7 @@ module GitFit
 
         l2_points = nil
         polyline = nil
-        elevation_gain = nil
+        elevation = {}
 
         if route_paths&.any?
           gpx_l1_path = File.join(raw_dir, "#{run_id}.gpx")
@@ -189,14 +189,14 @@ module GitFit
 
             coords = l2_points.map { |pt| [pt[:lat], pt[:lng]] }
             polyline = GitFit::Geo::Polyline.encode(coords)
-            elevation_gain = elevation_gain_from_points(l2_points)
+            elevation = elevation_profile(l2_points)
           end
         end
 
         title = build_title(workout_type, start_date)
-        attrs = build_attrs(source_name, run_id, stats, meta, polyline, elevation_gain,
+        attrs = build_attrs(source_name, run_id, stats, meta, polyline,
                             workout_type, start_date, end_date, duration, duration_unit,
-                            hr_avg, hr_max)
+                            hr_avg: hr_avg, hr_max: hr_max, elevation: elevation)
         attrs[:title] = title
 
         if attrs[:start_date_local].nil? && l2_points&.any?
@@ -433,9 +433,9 @@ module GitFit
         nil
       end
 
-      def build_attrs(_source_name, run_id, stats, meta, polyline, elevation_gain,
+      def build_attrs(_source_name, run_id, stats, meta, polyline,
                       workout_type, start_date, end_date, duration, duration_unit,
-                      hr_avg = nil, hr_max = nil)
+                      hr_avg: nil, hr_max: nil, elevation: {})
         distance = nil
         calories = nil
 
@@ -470,7 +470,11 @@ module GitFit
           max_heartrate: hr_max,
           average_speed: avg_speed,
           calories: calories,
-          elevation_gain: elevation_gain&.round(1),
+          elevation_gain: elevation[:gain]&.round(1),
+          elevation_loss: elevation[:loss]&.round(1),
+          elevation_min: elevation[:min]&.round(1),
+          elevation_max: elevation[:max]&.round(1),
+          steps: steps_from_stats(stats),
           average_temperature: parse_temperature(meta['HKWeatherTemperature']),
           source: 'apple_health',
           external_id: meta['HKExternalUUID'],
@@ -569,6 +573,31 @@ module GitFit
         total
       end
 
+      def steps_from_stats(stats)
+        sum = stats.dig('HKQuantityTypeIdentifierStepCount', 'sum')
+        sum&.to_f&.round&.nonzero?
+      end
+
+      def elevation_profile(points)
+        {
+          gain: elevation_gain_from_points(points),
+          loss: elevation_loss_from_points(points),
+          min: points.map { |pt| pt[:ele] }.compact.min,
+          max: points.map { |pt| pt[:ele] }.compact.max,
+        }
+      end
+
+      def elevation_loss_from_points(points)
+        total = 0.0
+        (1...points.length).each do |i|
+          elev1 = points[i - 1][:ele] || 0.0
+          elev2 = points[i][:ele] || 0.0
+          diff = elev1 - elev2
+          total += diff if diff > 0
+        end
+        total
+      end
+
       def apple_utc_to_local(utc_iso8601, tz_name)
         return utc_iso8601 unless utc_iso8601 && tz_name
         t = Time.parse(utc_iso8601)

data/lib/git_fit/import/tbulu.rb

@@ -110,8 +110,8 @@ module GitFit
       end
 
       def upsert_activity(activity)
-        # steps/total_up/total_down are hash-only signals, not DB columns
-        persistable = activity.reject { |k, _| %i[steps total_up total_down].include?(k) }
+        # total_up/total_down are hash-only signals, not DB columns (mapped to elevation_gain/loss by the parser)
+        persistable = activity.reject { |k, _| %i[total_up total_down].include?(k) }
         super(persistable)
       end
 

data/lib/git_fit/parser/base.rb

@@ -46,6 +46,28 @@ module GitFit
         end
       end
 
+      def elevation_loss(points)
+        return 0.0 if points.length < 2
+        (1...points.length).sum do |i|
+          elev1 = points[i - 1][2] || 0.0
+          elev2 = points[i][2] || 0.0
+          loss = elev1 - elev2
+          loss > 0 ? loss : 0.0
+        end
+      end
+
+      def elevation_min(points)
+        elevations(points).min
+      end
+
+      def elevation_max(points)
+        elevations(points).max
+      end
+
+      def elevations(points)
+        points.map { |p| p[2] }.compact
+      end
+
       def moving_time_from_points(points, threshold_s: 30)
         return 0 if points.length < 2
         total = 0
@@ -112,6 +134,10 @@ module GitFit
           average_heartrate: data[:average_heartrate]&.round(1),
           average_speed: data[:distance] && data[:moving_time].to_f.positive? ? (data[:distance].to_f / data[:moving_time]).round(2) : data[:average_speed],
           elevation_gain: data[:elevation_gain]&.round(1),
+          elevation_loss: data[:elevation_loss]&.round(1),
+          elevation_min: data[:elevation_min]&.round(1),
+          elevation_max: data[:elevation_max]&.round(1),
+          steps: data[:steps]&.round,
           source: @source_name || data[:source],
         }
       end

data/lib/git_fit/parser/fit.rb

@@ -25,6 +25,15 @@ module GitFit
 
         sport_type = GitFit::FIT::Decoder.sport(path)
 
+        session = GitFit::FIT::Decoder.session(path)
+        if session && (session['totalAscent'].is_a?(Numeric) || session['totalDescent'].is_a?(Numeric))
+          elevation_gain = session['totalAscent'] || 0.0
+          elevation_loss = session['totalDescent'] || 0.0
+        else
+          elevation_gain = elevation_gain(points)
+          elevation_loss = elevation_loss(points)
+        end
+
         [build_activity_attrs({
           run_id: build_run_id('fit', SecureRandom.hex(8)),
           name: nil,
@@ -38,7 +47,10 @@ module GitFit
           location_country: nil,
           summary_polyline: simplify_polyline(points.map { |p| [p[0], p[1]] }),
           average_heartrate: average_heartrate(points),
-          elevation_gain: elevation_gain(points),
+          elevation_gain: elevation_gain,
+          elevation_loss: elevation_loss,
+          elevation_min: elevation_min(points),
+          elevation_max: elevation_max(points),
           source: 'fit',
         })]
       end
@@ -51,7 +63,8 @@ module GitFit
         return nil unless lat && lon
         ts = rec['timestamp']
         time = ts.is_a?(Numeric) ? FIT_EPOCH + ts : parse_time(ts)
-        [lat, lon, rec['altitude'], time, rec['heartRate']]
+        altitude = rec['enhancedAltitude'] || rec['altitude']
+        [lat, lon, altitude, time, rec['heartRate']]
       end
 
       def average_heartrate(points)

data/lib/git_fit/parser/gpx.rb

@@ -41,6 +41,9 @@ module GitFit
           summary_polyline: simplify_polyline(points.map { |p| [p[0], p[1]] }),
           average_heartrate: average_heartrate(points),
           elevation_gain: elevation_gain(points),
+          elevation_loss: elevation_loss(points),
+          elevation_min: elevation_min(points),
+          elevation_max: elevation_max(points),
           source: 'gpx',
         }
         build_activity_attrs(data)

data/lib/git_fit/parser/tbulu.rb

@@ -82,7 +82,10 @@ module GitFit
           location_country: nil,
           summary_polyline: nil,
           average_heartrate: nil,
-          elevation_gain: elevation_gain(points),
+          elevation_gain: ti['totalup']&.to_f || elevation_gain(points),
+          elevation_loss: ti['totaldown']&.to_f || elevation_loss(points),
+          elevation_min: elevation_min(points),
+          elevation_max: elevation_max(points),
           source: '2bulu',
         })
         attach_sensor_stats(attrs, ti)
@@ -204,7 +207,10 @@ module GitFit
           location_country: nil,
           summary_polyline: nil,
           average_heartrate: nil,
-          elevation_gain: elevation_gain(points),
+          elevation_gain: ext['ElevationGain']&.to_f || elevation_gain(points),
+          elevation_loss: ext['ElevationLoss']&.to_f || elevation_loss(points),
+          elevation_min: elevation_min(points),
+          elevation_max: elevation_max(points),
           source: '2bulu',
         })
         attach_kml_stats(attrs, ext)

data/lib/git_fit/parser/tcx.rb

@@ -27,6 +27,7 @@ module GitFit
         total_moving_time = lap_data.sum { |ld| ld[:moving_time] || 0 }
         total_elapsed_time = lap_data.sum { |ld| ld[:elapsed_time] || 0 }
         elevation_gain = lap_data.sum { |ld| ld[:elevation_gain] || 0.0 }
+        elevation_loss = lap_data.sum { |ld| ld[:elevation_loss] || 0.0 }
         avg_hr = lap_data.map { |ld| ld[:avg_hr] }.compact
         all_points = lap_data.flat_map { |ld| ld[:points] }
         times = all_points.map { |p| p[3] }.compact
@@ -45,6 +46,9 @@ module GitFit
           summary_polyline: simplify_polyline(all_points.map { |p| [p[0], p[1]] }),
           average_heartrate: avg_hr.empty? ? nil : (avg_hr.sum / avg_hr.size).round(1),
           elevation_gain: elevation_gain,
+          elevation_loss: elevation_loss,
+          elevation_min: elevation_min(all_points),
+          elevation_max: elevation_max(all_points),
           source: 'tcx',
         }
         build_activity_attrs(data)
@@ -58,10 +62,11 @@ module GitFit
         avg_hr_node = lap.at_xpath('tcx:AverageHeartRateBpm/tcx:Value', NS)
         avg_hr = avg_hr_node&.text&.to_f
         elev_gain = points.length >= 2 ? elevation_gain(points) : 0.0
+        elev_loss = points.length >= 2 ? elevation_loss(points) : 0.0
         moving_time = moving_time_from_points(points, threshold_s: 30)
         { distance: distance, elapsed_time: total_time&.round,
           moving_time: moving_time > 0 ? moving_time : (total_time&.round || 0),
-          avg_hr: avg_hr, elevation_gain: elev_gain, points: points }
+          avg_hr: avg_hr, elevation_gain: elev_gain, elevation_loss: elev_loss, points: points }
       end
 
       def parse_track(lap)

data/lib/git_fit/sync/garmin_base.rb

@@ -199,7 +199,7 @@ module GitFit
       end
 
       def save_secret_to_config
-        path = @config['config_path'] || 'config/config.yml'
+        path = @config['config_path'] || GitFit::Config.default_path
         return unless File.exist?(path)
 
         cfg = YAML.safe_load(File.read(path)) || {}
@@ -477,7 +477,7 @@ module GitFit
       end
 
       def reauth_hint
-        "Re-auth: set sync.#{source_prefix}.secret in config/config.yml"
+        "Re-auth: set sync.#{source_prefix}.secret in #{GitFit::Config.default_path}"
       end
 
       def build_attrs(detail, activity_id, type, polyline = nil)
@@ -509,6 +509,10 @@ module GitFit
           average_temperature: summary['avgTemperature']&.to_f,
           average_speed: summary['averageSpeed']&.to_f,
           elevation_gain: summary['elevationGain']&.to_f,
+          elevation_loss: summary['elevationLoss']&.to_f,
+          elevation_min: summary['minElevation']&.to_f,
+          elevation_max: summary['maxElevation']&.to_f,
+          steps: summary['steps']&.to_i,
           source: source_prefix,
         }
       end

data/lib/git_fit/sync/igpsport.rb

@@ -103,8 +103,9 @@ module GitFit
         write_standardized_json(wgs_points, ride_id)
         polyline = Geo::Polyline.encode(wgs_points.map { |pt| [pt['positionLat'], pt['positionLong']] })
         sensor_summary = compute_sensor_summary(wgs_points)
+        elevation_stats = elevation_stats_from_records(wgs_points, fit_path)
 
-        attrs = build_attrs(act, ride_id, polyline, sensor_summary)
+        attrs = build_attrs(act, ride_id, polyline, sensor_summary, elevation_stats)
         return false unless attrs
 
         upsert_activity(attrs)
@@ -153,7 +154,7 @@ module GitFit
         JSON.parse(resp.body).dig('data', 'rows')
       end
 
-      def build_attrs(act, ride_id, polyline = nil, sensor = {})
+      def build_attrs(act, ride_id, polyline = nil, sensor = {}, elevation_stats = {})
         type = map_sport(act['exerciseType'])
         start_t = @fit_start_utc || parse_date(act['startTime'])
         start_t_local = @fit_start_local || start_t
@@ -182,6 +183,9 @@ module GitFit
           average_temperature: sensor[:average_temperature],
           average_speed: avg_speed > 0 ? avg_speed : nil,
           elevation_gain: act['totalAscent'].to_f.nonzero?,
+          elevation_loss: elevation_stats[:elevation_loss],
+          elevation_min: elevation_stats[:elevation_min],
+          elevation_max: elevation_stats[:elevation_max],
           summary_polyline: polyline,
           source: 'igpsport',
         }
@@ -204,6 +208,28 @@ module GitFit
         }
       end
 
+      def elevation_stats_from_records(records, fit_path)
+        alts = records.map { |r| r['enhancedAltitude'] || r['altitude'] }.compact
+        points_loss = 0.0
+        (1...alts.size).each do |i|
+          d = alts[i - 1] - alts[i]
+          points_loss += d if d > 0
+        end
+
+        session_descent = begin
+          session = FIT::Decoder.session(fit_path)
+          session && session['totalDescent'].is_a?(Numeric) ? session['totalDescent'] : nil
+        rescue StandardError
+          nil
+        end
+
+        {
+          elevation_loss: (session_descent || (alts.size >= 2 ? points_loss : nil))&.round(1),
+          elevation_min: alts.min&.round(1),
+          elevation_max: alts.max&.round(1),
+        }
+      end
+
       def map_sport(exercise_type)
         EXERCISE_MAP[exercise_type] || 'other'
       end

data/lib/git_fit/sync/keep.rb

@@ -306,12 +306,14 @@ module GitFit
 
         polyline_str = nil
         total_elevation = run_data['elevation']
+        total_elevation_loss = nil
         computed_distance = run_data['distance']
 
         if wgs_points.any?
           if wgs_points.any? { |pt| pt[3] }
             computed_distance ||= total_distance_haversine(wgs_points)
             total_elevation ||= elevation_gain_from_points(wgs_points)
+            total_elevation_loss = elevation_loss_from_points(wgs_points)
           end
 
           polyline_str = Geo::Polyline.encode(wgs_points.map { |pt| [pt[0], pt[1]] })
@@ -336,6 +338,9 @@ module GitFit
           average_heartrate: avg_hr&.round(1),
           average_speed: computed_distance && moving_time&.positive? ? (computed_distance.to_f / moving_time).round(2) : nil,
           elevation_gain: total_elevation&.round(1),
+          elevation_loss: total_elevation_loss&.round(1),
+          elevation_min: elevation_min_from_points(wgs_points),
+          elevation_max: elevation_max_from_points(wgs_points),
           source: 'keep',
         }
       end
@@ -424,6 +429,25 @@ module GitFit
         total
       end
 
+      def elevation_loss_from_points(points)
+        total = 0.0
+        (1...points.length).each do |i|
+          elev1 = points[i - 1][2] || 0.0
+          elev2 = points[i][2] || 0.0
+          diff = elev1 - elev2
+          total += diff if diff > 0
+        end
+        total
+      end
+
+      def elevation_min_from_points(points)
+        points.map { |p| p[2] }.compact.min
+      end
+
+      def elevation_max_from_points(points)
+        points.map { |p| p[2] }.compact.max
+      end
+
       def spider_sleep
         sleep 0.1
       end

data/lib/git_fit/sync/lorem.rb

@@ -17,28 +17,32 @@ module GitFit
           location_country: 'CN', average_heartrate: 148.0, max_heartrate: 165.0,
           average_cadence: 172.0, max_cadence: 185.0, average_power: nil, max_power: nil,
           average_temperature: 22.0, calories: 380,
-          average_speed: 5200.0 / 1800, elevation_gain: 125.0, external_id: 'lorem_001' },
+          average_speed: 5200.0 / 1800, elevation_gain: 125.0, elevation_loss: 110.0,
+          elevation_min: 35.0, elevation_max: 160.0, steps: 8200, external_id: 'lorem_001' },
         { id: 'beta_002', name: 'Ipsum Cycling Session', sport_category: 'ride',
           distance: 35000.0, moving_time: 5400, elapsed_time: 6000,
           start_date: '2025-01-14T08:00:00Z', start_date_local: '2025-01-14T16:00:00+08:00',
           location_country: 'CN', average_heartrate: 138.0, max_heartrate: 155.0,
           average_cadence: 85.0, max_cadence: 105.0, average_power: 185.0, max_power: 420.0,
           average_temperature: 18.0, calories: 850,
-          average_speed: 35000.0 / 5400, elevation_gain: 450.0, external_id: 'lorem_002' },
+          average_speed: 35000.0 / 5400, elevation_gain: 450.0, elevation_loss: 430.0,
+          elevation_min: 12.0, elevation_max: 460.0, external_id: 'lorem_002' },
         { id: 'gamma_003', name: 'Dolor Hike', sport_category: 'hike',
           distance: 12000.0, moving_time: 7200, elapsed_time: 8100,
           start_date: '2025-01-13T09:00:00Z', start_date_local: '2025-01-13T17:00:00+08:00',
           location_country: 'CN', average_heartrate: 122.0, max_heartrate: 142.0,
           average_cadence: 110.0, max_cadence: 135.0, average_power: nil, max_power: nil,
           average_temperature: 15.0, calories: 620,
-          average_speed: 12000.0 / 7200, elevation_gain: 820.0, external_id: 'lorem_003' },
+          average_speed: 12000.0 / 7200, elevation_gain: 820.0, elevation_loss: 790.0,
+          elevation_min: 300.0, elevation_max: 900.0, steps: 15_200, external_id: 'lorem_003' },
         { id: 'delta_004', name: 'Sit Amet Walk', sport_category: 'walk',
           distance: 5000.0, moving_time: 3600, elapsed_time: 3900,
           start_date: '2025-01-12T18:00:00Z', start_date_local: '2025-01-12T18:00:00+08:00',
           location_country: 'CN', average_heartrate: 108.0, max_heartrate: 125.0,
           average_cadence: 105.0, max_cadence: 118.0, average_power: nil, max_power: nil,
           average_temperature: 20.0, calories: 280,
-          average_speed: 5000.0 / 3600, elevation_gain: 35.0, external_id: 'lorem_004' },
+          average_speed: 5000.0 / 3600, elevation_gain: 35.0, elevation_loss: 40.0,
+          steps: 6400, external_id: 'lorem_004' },
         { id: 'epsilon_005', name: 'Consectetur Swim', sport_category: 'swim',
           distance: 2000.0, moving_time: 2400, elapsed_time: 2700,
           start_date: '2025-01-11T07:00:00Z', start_date_local: '2025-01-11T15:00:00+08:00',
@@ -100,6 +104,10 @@ module GitFit
           calories: act[:calories],
           average_speed: act[:average_speed],
           elevation_gain: act[:elevation_gain],
+          elevation_loss: act[:elevation_loss],
+          elevation_min: act[:elevation_min],
+          elevation_max: act[:elevation_max],
+          steps: act[:steps],
           source: 'lorem',
           external_id: act[:external_id],
         }

data/lib/git_fit/sync/strava.rb

@@ -86,7 +86,8 @@ module GitFit
                      act.dig('map', 'summary_polyline')
                    end
 
-        attrs = build_attrs(act, type, polyline, external_id: external_id)
+        attrs = build_attrs(act, type, polyline, external_id: external_id,
+                                                 elevation_loss: l2 ? elevation_loss_from_stream(l2) : nil)
         upsert_activity(attrs)
         attrs
       end
@@ -170,7 +171,7 @@ module GitFit
         data && i < data.size ? data[i] : nil
       end
 
-      def build_attrs(act, category, polyline = nil, external_id: nil)
+      def build_attrs(act, category, polyline = nil, external_id: nil, elevation_loss: nil)
         start_t = Time.parse(act['start_date']) rescue nil
         local_t = Time.parse(act['start_date_local']) rescue nil
 
@@ -196,11 +197,23 @@ module GitFit
           average_temperature: act['average_temp'],
           average_speed: act['average_speed'],
           elevation_gain: act['total_elevation_gain'],
+          elevation_loss: elevation_loss&.round(1),
+          elevation_min: act['elev_low'],
+          elevation_max: act['elev_high'],
           source: 'strava',
           external_id: external_id,
         }
       end
 
+      def elevation_loss_from_stream(l2)
+        alts = l2.filter_map { |pt| pt[:altitude] }
+        return nil if alts.size < 2
+        (1...alts.size).sum do |i|
+          diff = alts[i - 1] - alts[i]
+          diff > 0 ? diff : 0.0
+        end
+      end
+
       def map_sport_type(type, sport_type)
         SportMapper.canonicalize(sport_type || type)
       end

data/lib/git_fit/sync/xingzhe.rb

@@ -251,6 +251,7 @@ module GitFit
           start_date_local: start_t.iso8601,
           average_speed: (act['avg_speed'].to_f / 3.6).round(2).nonzero?,
           elevation_gain: act['elevation_gain'].to_f.nonzero?,
+          elevation_loss: act['elevation_loss'].to_f.nonzero?,
           source: 'xingzhe',
         }
 

data/lib/git_fit/sync/xoss.rb

@@ -316,6 +316,7 @@ module GitFit
               pts = wgs_points.map { |pt| [pt['positionLat'], pt['positionLong']] }
               attrs[:summary_polyline] = Geo::Polyline.encode(pts)
               attrs.merge!(compute_sensor_summary(wgs_points))
+              attrs.merge!(elevation_stats_from_records(wgs_points, raw_path(act_id)))
             end
           end
         end
@@ -371,6 +372,28 @@ module GitFit
         }
       end
 
+      def elevation_stats_from_records(records, fit_path)
+        alts = records.map { |r| r['enhancedAltitude'] || r['altitude'] }.compact
+        points_loss = 0.0
+        (1...alts.size).each do |i|
+          d = alts[i - 1] - alts[i]
+          points_loss += d if d > 0
+        end
+
+        session_descent = begin
+          session = FIT::Decoder.session(fit_path)
+          session && session['totalDescent'].is_a?(Numeric) ? session['totalDescent'] : nil
+        rescue StandardError
+          nil
+        end
+
+        {
+          elevation_loss: (session_descent || (alts.size >= 2 ? points_loss : nil))&.round(1),
+          elevation_min: alts.min&.round(1),
+          elevation_max: alts.max&.round(1),
+        }
+      end
+
       def map_sport(sport)
         SPORT_MAP[sport] || 'other'
       end

data/lib/git_fit/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-fit
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Lax
@@ -244,6 +244,7 @@ extra_rdoc_files: []
 files:
 - db/migrations/001_full_schema.rb
 - db/migrations/002_iso8601_time_format.rb
+- db/migrations/003_add_elevation_fields.rb
 - exe/git-fit
 - lib/git-fit.rb
 - lib/git_fit/auth/garmin.rb