root/points/trunk/points.py

#!/usr/bin/env python

"""
Generate glider goto list.

Usage:

   python points.py [glider_lat glider_lon
                     [ target_lat target_lon
                     [ steps ]]]

   where glider_lat and glider_lon are the present glider
       latitude and longitude in ISO format (+/-ddmm.mmmm),

   where target_lat and target_lon are the desired glider
       latitude and longitude in ISO format (+/-ddmm.mmmm),

   and where steps are the number of steps to take between
       present and desired glider positions.
"""

import sys
import os
import shutil
from datetime import datetime

months = {1: 'Jan',
          2: 'Feb',
          3: 'Mar',
          4: 'Apr',
          5: 'May',
          6: 'Jun',
          7: 'Jul',
          8: 'Aug',
          9: 'Sep',
          10: 'Oct',
          11: 'Nov',
          12: 'Dec'}

LB1MOOR = [3310.353, -7819.800]
LB1ADCP = [3310.172, -7820.007]
LB2MOOR = [3256.491, -7805.667]
LB2ADCP = [3256.419, -7805.926]
LB3MOOR = [3251.142, -7800.793]
LB3ADCP = [3251.142, -7800.793]

glider_dir = '/var/opt/gmc/gliders'

goto_name = "goto_l10.ma"
glider_name = "ramses"
glider_pos = [3240.576, -7821.149]
target = [3240.576, -7751.149]
steps = 10

first_template = \
"""#
# Filename: %s
# File creation time: %s
# Generated by: %s
#

behavior_name=goto_list

<start:b_arg>
        b_arg: num_legs_to_run(nodim) -2 # -1 loop, -2 run once, > 0 = this m$
        b_arg: start_when(enum) 0       # 0 baw_immediately
        b_arg: list_stop_when(enum) 7   # BAW_WHEN_WPT_DIST

        # SATISFYING RADIUS
        b_arg: list_when_wpt_dist(m) 100

        # LIST PARAMETERS
        b_arg: initial_wpt(enum) 0      # 0 to n-1, -1 first after last, -2 c$
        b_arg: num_waypoints(nodim) %u
<end:b_arg>

<start:waypoints>
"""

last_template = \
"""<end:waypoints>

"""

def ddmm2decdeg(ddmm):
    sign = ddmm < 0
    ddmm = abs(ddmm)
    dd = (ddmm // 100)
    mm = ddmm - (dd * 100)
    dm = mm / 60
    if sign:
        decdeg = -(dd + dm)
    else:
        decdeg = dd + dm
    return decdeg

def decdeg2ddmm(decdeg):
    dd = int(decdeg)
    dm = decdeg - dd
    mm = dm * 60
    ddmm = (dd * 100) + mm
    return ddmm

def latlondict(latlonlist):
    return {'lat': latlonlist[0],
            'lon': latlonlist[1]}

def latlonlist(latlondict):
    return [latlondict['lat'], latlondict['lon']]

def line(origin, target, steps=steps):
    vector = {'lat': target['lat'] - origin['lat'],
              'lon': target['lon'] - origin['lon']}
    divs = {'lat': vector['lat'] / steps,
            'lon': vector['lon'] / steps}
    points = [{'lat': origin['lat'] + (x * divs['lat']),
               'lon': origin['lon'] + (x * divs['lon'])}
              for x in range(1, steps + 1)]
    return points

def swap(seq):
    return [seq[1], seq[0]]

if __name__ == "__main__":
    num_args = len(sys.argv) - 1
    if not (num_args == 0 or
            num_args == 2 or
            num_args == 4 or
            num_args == 5):
        sys.exit(__doc__)

    if num_args > 0:
        try:
            glider_pos[0] = float(sys.argv[1])
            glider_pos[1] = float(sys.argv[2])
        except:
            sys.exit(__doc__)

    if num_args > 2:
        try:
            target[0] = float(sys.argv[3])
            target[1] = float(sys.argv[4])
        except:
            sys.exit(__doc__)

    if num_args > 4:
        try:
            steps = int(sys.argv[5])
        except:
            sys.exit(__doc__)

    glider_pos = map(ddmm2decdeg, glider_pos)
    target = map(ddmm2decdeg, target)

    glider_pos = latlondict(glider_pos)
    target = latlondict(target)

    points = line(glider_pos, target, steps)
    points = [latlonlist(point) for point in points]
    points = [map(decdeg2ddmm, point) for point in points]

    points = [swap(point) for point in points]

    now = datetime.now()
    now_string = "%02d-%s-%04d %02d:%02d:%02d UTC" % (now.day,
                                                      months[now.month],
                                                      now.year,
                                                      now.hour,
                                                      now.minute,
                                                      now.second,
                                                     )
    now_stamp = "%04d%02d%02dT%02d%02d%02d" % (now.year,
                                               now.month,
                                               now.day,
                                               now.hour,
                                               now.minute,
                                               now.second)

    backup_dir = os.path.join(os.path.dirname(
                                  os.path.abspath(__file__)),
                              "archive",
                              glider_name)
    backup_name = "%s_%s_%s" % (glider_name,
                                goto_name,
                                now_stamp)
    goto_path = os.path.join(glider_dir,
                             glider_name,
                             "to-glider",
                             goto_name)
    try:
        os.makedirs(backup_dir)
    except:
        pass
    backup_path = os.path.join(backup_dir,
                               backup_name)

    handle = open(backup_path, "w")
    handle.write(first_template % (goto_name, now_string, __file__, steps))
    handle.writelines(["\t%.3f\t%.3f\n" % tuple(point) for point in points])
    handle.write(last_template)
    handle.close()
    shutil.copy2(backup_path, goto_path)