souplesse/frontend/src/Point.elm

module Point exposing(Pos, Point, decoder, downsample)

import Json.Decode as D

type alias Pos =
    { lat : Float
    , lon : Float
    , ele : Maybe Float
    }


type alias Point =
    { time : Float
    , pos : Pos
    , cadence : Maybe Int
    , power : Maybe Int
    , heartRate : Maybe Int
    }

posDecoder : D.Decoder Pos
posDecoder = D.map3 Pos
             (D.field "lat" D.float)
             (D.field "lon" D.float)
             (D.field "ele" (D.maybe D.float))


decoder : D.Decoder Point
decoder = D.map5 Point
          (D.field "time" D.float)
          (D.field "pos" posDecoder)
          (D.field "cadence" (D.maybe D.int))
          (D.field "power" (D.maybe D.int))
          (D.field "heartRate" (D.maybe D.int))


llast x xs =
    case xs of
        [] -> x
        (x_::xs_) -> llast x_ xs_

tracef x = Debug.log (String.fromFloat x) x

-- divide the points into n equal time buckets and return the first
-- point in each
downsample n points =
    let
        nextpoint step prev points_ =
            case points_ of
                (next::rest) ->
                    if next.time - prev.time > step
                    then prev :: (nextpoint step next rest)
                    else nextpoint step prev rest
                _ -> [prev]
    in
        case points of
            (first::rest) ->
                let last = llast first rest
                    duration = last.time - first.time
                    step = duration / (toFloat n)
                in nextpoint step first rest
            [] -> []