track_loader.bas

Go to the documentation of this file.

DECLARE FUNCTION atanh CDECL ALIAS"atanh"(BYVAL AS DOUBLE) AS DOUBLE

DECLARE FUNCTION tanh CDECL ALIAS"tanh"(BYVAL AS DOUBLE) AS DOUBLE

CONST AS LONG _

  TILESIZE = 256 _ 
, TILESIZEd2 = 128 


#INCLUDE ONCE "parser_gpx.bi"

#INCLUDE ONCE "parser_nmea.bi"

#INCLUDE ONCE "datetime.bi"







#DEFINE EXTREM(_V_) _

  IF _V_ > Mx##_V_ THEN Mx##_V_ = _V_ ELSE IF _V_ < Mn##_V_ THEN Mn##_V_ = _V_







FUNCTION lat2pixel(BYVAL V AS float, BYVAL Z AS LONG) AS LONG

  VAR y = atanh(SIN(V)) * TILESIZE * (1 SHL Z) / PIx2

  RETURN -INT(y) + ((1 SHL Z) * TILESIZEd2)

END FUNCTION







FUNCTION lon2pixel(BYVAL V AS float, BYVAL Z AS LONG) AS LONG

  VAR x = V * TILESIZE * (1 SHL Z) / PIx2

  RETURN  INT(x) + ((1 SHL Z) * TILESIZEd2)

END FUNCTION







FUNCTION pixel2lon(BYVAL Z AS long, BYVAL X AS LONG) AS float

  RETURN ((X - (EXP(LN2 * Z) * TILESIZEd2)) * PIx2) _

       / (TILESIZE * EXP(LN2 * Z))

END FUNCTION







FUNCTION pixel2lat(BYVAL Z AS long, BYVAL Y AS LONG) AS float

  VAR lat_m = ((EXP(LN2 * Z) * TILESIZEd2 - Y) * PIx2) _

            / (TILESIZE * EXP(LN2 * Z))

  RETURN ASIN(tanh(lat_m))

END FUNCTION




#DEFINE LOG2(_X_) LOG(_X_) / LN2


#DEFINE MIN(V1, V2) IIF(V1 > V2, V2, V1)







FUNCTION latlon2zoom CDECL( _

  BYVAL W AS LONG _

, BYVAL H AS LONG _

, BYVAL La0 AS float _

, BYVAL La1 AS float _

, BYVAL Lo0 AS float _

, BYVAL Lo1 AS float) AS LONG

  DIM AS DOUBLE dlon = Lo1 - Lo0

  dlon = IIF(dlon, LOG2(ABS(W * PIx2 / TILESIZE / dlon)), 20.)

  DIM AS DOUBLE dlat = atanh(SIN(La1)) - atanh(SIN(La0))

  dlat = IIF(dlat, LOG2(ABS(H * PIx2 / TILESIZE / dlat)), 20.)

  RETURN MIN(INT(dlon), INT(dlat))

END FUNCTION







CONSTRUCTOR TrackLoader(BYVAL Fnam AS CONST ZSTRING PTR)

  STATIC AS UINTEGER dile = CAST(UINTEGER, -1) SHR 1

  IF 0 = Fnam ORELSE Fnam[0] = 0 THEN Errr = @"no file name" : EXIT CONSTRUCTOR

  VAR fnr = FREEFILE

  IF OPEN(*Fnam FOR INPUT AS fnr) THEN Errr = @"open failed" : EXIT CONSTRUCTOR



  VAR want = LOF(fnr) : IF 0 = want THEN CLOSE #fnr : Errr = @"no contents" : EXIT CONSTRUCTOR

  IF want = dile THEN CLOSE #fnr : Errr = @"directory" : EXIT CONSTRUCTOR

  Buff = ALLOCATE(want+1) : IF 0 = Buff THEN CLOSE #fnr : Errr = @"out of memory" : EXIT CONSTRUCTOR

  GET #fnr, ,*Buff, want, Byt

  CLOSE #fnr

  Buff[Byt + 1] = 0 ' terminate



  IF UCASE(RIGHT(*Fnam, 4)) = ".GPX" THEN

    WITH TYPE<GPX>(@THIS)

      Desc = _

         Byt & " bytes: " _

      & .Trk & " track[s] (" & .Seg &  " segments[s]), " _

      & .Pnt & " point[s] (" & .Ext & !" extension[s])\n\n" _

      & .TiX + .LoX + .LaX + .ElX + .SpX + .AnX & " err/miss: " _

      & .TiX & " <time>, " _

      & .LoX & " <lon>, " _

      & .LaX & " <lat>, " _

      & .ElX & " <ele>, " _

      & .SpX & " <g_spd>, " _

      & .AnX & " <dir>"

    END WITH

  ELSE

    WITH TYPE<NMEA>(@THIS)

      Desc = _

         " bytes (file/mem): " & Byt & "/" & Siz & ": " _

      & .Lin & " lines, " & (Siz \ SIZEOF(TrP)) & " points (" _

      & .Enr & " error[s])"

    END WITH

  END IF

  IF Siz <= 0 THEN Errr = @"no track points" : EXIT CONSTRUCTOR

  VAR x = REALLOCATE(Buff, Siz) : IF x THEN Buff = x



  Az = Siz \ SIZEOF(TrP) - 1

  V = CAST(TrP PTR, Buff)



  Mn = V[0]

  Mx = V[0] : Mx.Tim = V[Az].Tim

  FOR i AS INTEGER = 1 TO Az

  WITH V[i]

    EXTREM(.Lat)

    EXTREM(.Lon)

    EXTREM(.Ele)

    EXTREM(.Spd)

    EXTREM(.Ang)

  END WITH

  NEXT

END CONSTRUCTOR



DESTRUCTOR TrackLoader()

  DEALLOCATE(Buff)

END DESTRUCTOR







FUNCTION TrackLoader.Pixel(BYVAL X AS LONG, BYVAL Y AS LONG, BYVAL Z AS LONG)AS BYTE

  IF 0 = Az THEN RETURN 1

  IF Z = CoZo THEN ' simple integer movement

    IF Co_X = X ANDALSO Co_Y = Y THEN RETURN 0

    VAR dx = Co_X - X, dy = Co_Y - Y

    FOR i AS INTEGER = 0 TO Az

      V[i].Xpix += dx

      V[i].Ypix += dy

    NEXT

  ELSE ' complex transformation for new zoom

    CoZo = Z

    FOR i AS INTEGER = 0 TO Az

      V[i].Xpix = lon2pixel(V[i].Lon, Z) - X

      V[i].Ypix = lat2pixel(V[i].Lat, Z) - Y

    NEXT

  END IF

  Co_X = X

  Co_Y = Y

  RETURN 0

END FUNCTION







FUNCTION TrackLoader.SkipOut(BYVAL Typ AS LONG, BYVAL Di AS float) AS LONG

  VAR st = -1L, e = 0L

  SELECT CASE AS CONST Typ

  CASE -2 : Di *= 5

  CASE -1

  CASE  1           : st =  1 : e = Az

  CASE  2 : Di *= 5 : st =  1 : e = Az

  CASE ELSE : RETURN Cur

  END SELECT

  FOR i AS LONG = Cur + st TO e STEP st

    IF Dist(Cur, i) > Di THEN RETURN i

  NEXT

  RETURN e

END FUNCTION







PROPERTY TrackLoader.ASpd() AS float

  VAR a = CAST(DOUBLE, V[0].Spd)

  FOR i AS INTEGER = 1 TO Az

    a += V[i].Spd

  NEXT : RETURN a / Az

END PROPERTY







PROPERTY TrackLoader.LTrk() AS float

  IF Az < 1 THEN RETURN NaN

  VAR l = Dist(0, 1)

  FOR i AS INTEGER = 2 TO Az

    l += Dist(i, i-1)

  NEXT : RETURN l

END PROPERTY







FUNCTION TrackLoader.Dist(BYVAL P0 AS ULONG, BYVAL P1 AS ULONG) AS DOUBLE

  IF P0 > Az ORELSE P1 > Az THEN RETURN NaN

  VAR r0 = V[P0].Ele + ERA    , r1 = V[P1].Ele + ERA _

    , a0 = COS(V[P0].Lat) * r0, a1 = COS(V[P1].Lat) * r1 _

    , dx = COS(V[P0].Lon) * a0   -   COS(V[P1].Lon) * a1 _

    , dy = SIN(V[P0].Lon) * a0   -   SIN(V[P1].Lon) * a1 _

    , dz = SIN(V[P0].Lat) * r0   -   SIN(V[P1].Lat) * r1

    RETURN SQR(dx*dx + dy*dy + dz*dz)

END FUNCTION







FUNCTION TrackLoader.Nearest(BYVAL Lon AS float, BYVAL Lat AS float)AS float

  VAR a = V[0].Lat - Lat, o = V[0].Lon - Lon, d = SQR(a*a + o*o)

  Tmp = 0

  FOR i AS LONG = 1 TO Az

    a = V[i].Lat - Lat : o = V[i].Lon - Lon : VAR x = SQR(a*a + o*o)

    IF x < d THEN d = x : Tmp = i

  NEXT : RETURN d

END FUNCTION







SUB TrackLoader.MapCenter(BYVAL W AS LONG, BYVAL H AS LONG)

  UsLo = .5 * (Mx.Lon + Mn.Lon)

  UsLa = .5 * (Mx.Lat + Mn.Lat)

  UsZo = latlon2zoom(W, H, Mn.Lat, Mx.Lat, Mn.Lon, Mx.Lon)

  UsLo *= Rad2Deg

  UsLa *= Rad2Deg

END SUB