git-fit 0.21.1 → 0.21.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30f139ea0a7c21e9a99189ac7541c8b80c35377f40742823843dbcd5b2ce604a
-  data.tar.gz: b554587d97956af6e3a532ab67b6eca755377005f82eec38c500414d7bd1c4c4
+  metadata.gz: f867a5ad738983c2d5e3a10d837b3f4c0f6de6bc303d1124fdec5fccf4a8796b
+  data.tar.gz: 50cefd5a1b88b2282396942ab3809c1a87f7ac6a6ac977c00cf77cf12a39ec04
 SHA512:
-  metadata.gz: 5b23770d805a5c42fdbe3b4322e3557bd4938033e2e7e3094e934354d16fbc8c6bb7d7ed028ae5ffe9684b785d7e5fdca560e17480fd020713c1b96302795bb2
-  data.tar.gz: 32dde756e5dc46d3f859a992779187ccf2e478e9de05b681f79184ba2c35838822f29586f9d4e9c79d26e1d8d767c1771d4ed80172fa6fd21ec9ff7851345720
+  metadata.gz: 4390df21b2c3a0cb8167c0d5b0deb5e9fc495391fe0993104f942199249e6520d7ea8923d96f80c23683331c8ddfdff1e3e5cb47e69add1c067185290fe4befd
+  data.tar.gz: 3bc09da8cf7493ba99b274fa2aecbbdee9843e5a2b83e8fb3d8e1ca8dfe3db4016978e240666ae13751f8fea09537b19f65fcbff7632ed4244f7b1a9aba5d56f

data/lib/git_fit/dedup/field_elector.rb

@@ -16,8 +16,8 @@ module GitFit
         average_cadence: :non_null,
         max_cadence: :non_null,
         summary_polyline: :best_polyline,
-        elevation_gain: :median,
-        elevation_loss: :median,
+        elevation_gain: :priority,
+        elevation_loss: :priority,
         elevation_min: :min,
         elevation_max: :max,
         steps: :median,
@@ -56,6 +56,8 @@ module GitFit
           candidates.max_by { |v| decode_polyline_size(v) }
         when :computed
           nil
+        when :priority
+          priority_pick(values, sources)
         when :best_name
           best_name(values, sources)
         when :earliest
@@ -76,6 +78,15 @@ module GitFit
         polyline.size / 3
       end
 
+      def priority_pick(values, sources)
+        pairs = values.zip(sources)
+        # keep only non-nil values with source priority
+        filtered = pairs.reject { |v, _| v.nil? }
+        return nil if filtered.empty?
+
+        filtered.min_by { |_, src| SOURCE_NAME_PRIORITY[src&.to_sym] || 99 }&.first
+      end
+
       def best_name(values, sources)
         pairs = values.zip(sources)
         pairs.min_by { |_, src| SOURCE_NAME_PRIORITY[src&.to_sym] || 99 }&.first

data/lib/git_fit/elevation/correct.rb

@@ -81,16 +81,21 @@ module GitFit
         l2 = JSON.parse(File.read(l2_path))
         return nil unless l2.is_a?(Array)
 
+        # L2 std has two coordinate key styles: keep/2bulu/apple_health/xingzhe
+        # write latitude/longitude, FIT-derived sources write positionLat/
+        # positionLong (same convention as Dedup::Trajectory and export/gpx).
         pts = l2.filter_map do |pt|
           next unless pt.is_a?(Hash)
-          next unless pt['latitude'] && pt['longitude'] && pt['altitude']
+          lat = pt['latitude'] || pt['positionLat']
+          lng = pt['longitude'] || pt['positionLong']
+          next unless lat && lng && pt['altitude']
 
-          pt
+          [lat.to_f, lng.to_f, pt['altitude'].to_f]
         end
         return nil if pts.size < 2
 
-        locations = pts.map { |pt| [pt['latitude'].to_f, pt['longitude'].to_f] }
-        alts_raw = pts.map { |pt| pt['altitude'].to_f }
+        locations = pts.map { |lat, lng, _alt| [lat, lng] }
+        alts_raw = pts.map { |_lat, _lng, alt| alt }
 
         dem_alts = dem_corrected_altitudes(locations, alts_raw)
         h = hysteresis_threshold(source, locations, alts_raw)

data/lib/git_fit/export/calculator.rb

@@ -71,6 +71,8 @@ module GitFit
         unique = rows.reject { |a| grouped_run_ids.include?(a[:run_id]) }
         unique_count = unique.size + (@db.table_exists?(:dedup_groups) ? @db[:dedup_groups].count : 0)
 
+        uniq = compute_unique_totals(rows)
+
         {
           total_activities: rows.size,
           unique_activities: unique_count,
@@ -79,6 +81,11 @@ module GitFit
           total_elevation_gain_m: total_elev,
           total_elevation_loss_m: total_loss,
           total_steps: total_steps,
+          unique_total_distance_km: uniq[:distance_km],
+          unique_total_moving_time_h: uniq[:moving_time_h],
+          unique_total_elevation_gain_m: uniq[:elev_gain],
+          unique_total_elevation_loss_m: uniq[:elev_loss],
+          unique_total_steps: uniq[:steps],
           avg_cadence: cadences.any? ? (cadences.sum / cadences.size).round(1) : nil,
           avg_power: powers.any? ? (powers.sum / powers.size).round(1) : nil,
           max_power: max_powers.any? ? max_powers.max.round(1) : nil,
@@ -90,6 +97,76 @@ module GitFit
         }
       end
 
+      def compute_unique_totals(rows)
+        return { distance_km: 0.0, moving_time_h: 0.0, elev_gain: 0.0, elev_loss: 0.0, steps: 0 } if rows.empty?
+        return dedup_aware_totals(rows) if dedup_tables_present?
+
+        {
+          distance_km: rows.sum { |r| r[:distance] || 0 } / 1000.0,
+          moving_time_h: rows.sum { |r| r[:moving_time] || 0 } / 3600.0,
+          elev_gain: rows.sum { |r| r[:elevation_gain_terrain] || r[:elevation_gain] || 0 },
+          elev_loss: rows.sum { |r| r[:elevation_loss_terrain] || r[:elevation_loss] || 0 },
+          steps: rows.sum { |r| r[:steps] || 0 },
+        }
+      end
+
+      def dedup_tables_present?
+        @db.table_exists?(:dedup_groups) && @db.table_exists?(:dedup_group_members)
+      end
+
+      def dedup_aware_totals(rows)
+        run_id_to_row = rows.each_with_object({}) { |r, h| h[r[:run_id]] = r }
+        grouped_ids = @db[:dedup_group_members].select_map(:run_id)
+        unique_rows = rows.reject { |r| grouped_ids.include?(r[:run_id]) }
+
+        uniq_dist = unique_rows.sum { |r| r[:distance] || 0 }
+        uniq_time = unique_rows.sum { |r| r[:moving_time] || 0 }
+        uniq_gain = unique_rows.sum { |r| r[:elevation_gain_terrain] || r[:elevation_gain] || 0 }
+        uniq_loss = unique_rows.sum { |r| r[:elevation_loss_terrain] || r[:elevation_loss] || 0 }
+        uniq_steps = unique_rows.sum { |r| r[:steps] || 0 }
+
+        @db[:dedup_groups].select_map(:group_id).each do |gid|
+          member_ids = @db[:dedup_group_members].where(group_id: gid).select_map(:run_id)
+          members = member_ids.filter_map { |rid| run_id_to_row[rid] }
+          next if members.empty?
+
+          uniq_dist += median_value(members.map { |r| r[:distance] })
+          uniq_time += median_value(members.map { |r| r[:moving_time] })
+          uniq_gain += priority_elevation(members, :elevation_gain)
+          uniq_loss += priority_elevation(members, :elevation_loss)
+          uniq_steps += median_value(members.map { |r| r[:steps] })
+        end
+
+        {
+          distance_km: (uniq_dist / 1000.0).round(1),
+          moving_time_h: (uniq_time / 3600.0).round(1),
+          elev_gain: uniq_gain.round(0),
+          elev_loss: uniq_loss.round(0),
+          steps: uniq_steps,
+        }
+      end
+
+      def median_value(values)
+        vals = values.compact
+        return 0 if vals.empty?
+
+        sorted = vals.sort
+        sorted[sorted.size / 2]
+      end
+
+      def priority_elevation(members, field)
+        terrain_field = :"#{field}_terrain"
+        pairs = members.map do |r|
+          v = r[terrain_field] || r[field]
+          [v, r[:source]&.to_sym]
+        end
+        filtered = pairs.reject { |v, _| v.nil? }
+        return 0 if filtered.empty?
+
+        pri = GitFit::Dedup::FieldElector::SOURCE_NAME_PRIORITY
+        filtered.min_by { |_, src| pri[src] || 99 }[0]
+      end
+
       def compute_monthly(rows)
         monthly = Hash.new do |h, k|
           h[k] = { count: 0, distance_km: 0.0, moving_time_h: 0.0,
@@ -99,10 +176,19 @@ module GitFit
                    total_power: 0.0, power_count: 0,
                    max_power_peak: 0.0, total_max_power: 0.0, max_power_count: 0 }
         end
+        @_monthly_rows = Hash.new { |h, k| h[k] = [] }
+
+        rows.each do |row|
+          accumulate_monthly_row(monthly, row)
+          next unless row[:start_date_local] || row[:start_date]
 
-        rows.each { |row| accumulate_monthly_row(monthly, row) }
+          ym = (row[:start_date_local] || row[:start_date])[0..6]
+          @_monthly_rows[ym] << row
+        end
 
-        format_monthly(monthly.sort)
+        result = format_monthly(monthly.sort)
+        @_monthly_rows = nil
+        result
       end
 
       def accumulate_monthly_row(monthly, row)
@@ -134,11 +220,17 @@ module GitFit
       end
 
       def format_monthly(sorted)
+        # For dedup-aware per-month unique totals, compute via filtered rows
+        # Cache rows grouped by ym to reuse dedup_aware logic
+        # Need original rows; reconstruct from monthly accumulation is lossy,
+        # so compute via second pass if caller provides rows? Instead compute
+        # unique via dedup_aware if tables present, else mirror totals.
+        # We store original rows in thread-local via compute_monthly caller.
         sorted.map do |ym, v|
           pace = if v[:moving_time_h] > 0 && v[:distance_km] > 0
                    format_pace(v[:moving_time_h] * 3600 / v[:distance_km])
                  end
-          {
+          base = {
             year: ym[0..3].to_i,
             month: ym[5..6].to_i,
             count: v[:count],
@@ -154,9 +246,37 @@ module GitFit
             elevation_loss_m: v[:total_loss].round(0),
             steps: v[:total_steps],
           }
+          if defined?(@_monthly_rows)
+            month_rows = @_monthly_rows[ym] || []
+            uniq = if dedup_tables_present?
+                     dedup_aware_totals(month_rows)
+                   else
+                     {
+                       distance_km: v[:distance_km], moving_time_h: v[:moving_time_h],
+                       elev_gain: v[:total_elev], elev_loss: v[:total_loss], steps: v[:total_steps]
+                     }
+                   end
+            base[:unique_distance_km] = uniq[:distance_km]
+            base[:unique_moving_time_h] = uniq[:moving_time_h]
+            base[:unique_elevation_gain_m] = uniq[:elev_gain].round(0)
+            base[:unique_elevation_loss_m] = uniq[:elev_loss].round(0)
+            base[:unique_steps] = uniq[:steps]
+            base[:unique_count] = dedup_tables_present? ? unique_count_for_rows(month_rows) : v[:count]
+          end
+          base
         end
       end
 
+      def unique_count_for_rows(rows)
+        return rows.size unless dedup_tables_present?
+
+        grouped = @db[:dedup_group_members].select_map(:run_id)
+        rows.count { |r| !grouped.include?(r[:run_id]) } + rows.map { |r|
+          gid = @db[:dedup_group_members].where(run_id: r[:run_id]).get(:group_id)
+          gid
+        }.compact.uniq.size
+      end
+
       def compute_yearly(rows)
         by_year = Hash.new { |h, k| h[k] = [] }
         rows.each do |r|
@@ -176,13 +296,30 @@ module GitFit
 
           year_max_powers = acts.map { |r| r[:max_power] }.compact
 
-          { year: year, count: acts.size, distance_km: total_dist.round(1),
-            moving_time_h: (total_time / 3600.0).round(1),
-            longest_km: longest.round(1), streak: streak,
-            elevation_gain_m: total_elev.round(0), elevation_loss_m: total_loss.round(0),
-            steps: total_steps,
-            max_power: year_max_powers.any? ? year_max_powers.max.round(0) : nil,
-            avg_max_power: year_max_powers.any? ? (year_max_powers.sum / year_max_powers.size).round(0) : nil }
+          base = { year: year, count: acts.size, distance_km: total_dist.round(1),
+                   moving_time_h: (total_time / 3600.0).round(1),
+                   longest_km: longest.round(1), streak: streak,
+                   elevation_gain_m: total_elev.round(0), elevation_loss_m: total_loss.round(0),
+                   steps: total_steps,
+                   max_power: year_max_powers.any? ? year_max_powers.max.round(0) : nil,
+                   avg_max_power: year_max_powers.any? ? (year_max_powers.sum / year_max_powers.size).round(0) : nil }
+          if dedup_tables_present?
+            uniq = dedup_aware_totals(acts)
+            base[:unique_distance_km] = uniq[:distance_km]
+            base[:unique_moving_time_h] = uniq[:moving_time_h]
+            base[:unique_elevation_gain_m] = uniq[:elev_gain].round(0)
+            base[:unique_elevation_loss_m] = uniq[:elev_loss].round(0)
+            base[:unique_steps] = uniq[:steps]
+            base[:unique_count] = unique_count_for_rows(acts)
+          else
+            base[:unique_distance_km] = total_dist.round(1)
+            base[:unique_moving_time_h] = (total_time / 3600.0).round(1)
+            base[:unique_elevation_gain_m] = total_elev.round(0)
+            base[:unique_elevation_loss_m] = total_loss.round(0)
+            base[:unique_steps] = total_steps
+            base[:unique_count] = acts.size
+          end
+          base
         end
       end
 

data/lib/git_fit/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-fit
 version: !ruby/object:Gem::Version
-  version: 0.21.1
+  version: 0.21.3
 platform: ruby
 authors:
 - Lax