anuga 1.3.5__zip

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/coordinate_transforms/lat_long_UTM_conversion.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python
+
+# Lat Long - UTM, UTM - Lat Long conversions
+#
+# see http://www.pygps.org
+#
+
+from math import pi, sin, cos, tan, sqrt
+
+#LatLong- UTM conversion..h
+#definitions for lat/long to UTM and UTM to lat/lng conversions
+#include <string.h>
+
+_deg2rad = pi / 180.0
+_rad2deg = 180.0 / pi
+
+_EquatorialRadius = 2
+_eccentricitySquared = 3
+
+_ellipsoid = [
+#  id, Ellipsoid name, Equatorial Radius, square of eccentricity
+# first once is a placeholder only, To allow array indices to match id numbers
+	[ -1, "Placeholder", 0, 0],
+	[ 1, "Airy", 6377563, 0.00667054],
+	[ 2, "Australian National", 6378160, 0.006694542],
+	[ 3, "Bessel 1841", 6377397, 0.006674372],
+	[ 4, "Bessel 1841 (Nambia] ", 6377484, 0.006674372],
+	[ 5, "Clarke 1866", 6378206, 0.006768658],
+	[ 6, "Clarke 1880", 6378249, 0.006803511],
+	[ 7, "Everest", 6377276, 0.006637847],
+	[ 8, "Fischer 1960 (Mercury] ", 6378166, 0.006693422],
+	[ 9, "Fischer 1968", 6378150, 0.006693422],
+	[ 10, "GRS 1967", 6378160, 0.006694605],
+	[ 11, "GRS 1980", 6378137, 0.00669438],
+	[ 12, "Helmert 1906", 6378200, 0.006693422],
+	[ 13, "Hough", 6378270, 0.00672267],
+	[ 14, "International", 6378388, 0.00672267],
+	[ 15, "Krassovsky", 6378245, 0.006693422],
+	[ 16, "Modified Airy", 6377340, 0.00667054],
+	[ 17, "Modified Everest", 6377304, 0.006637847],
+	[ 18, "Modified Fischer 1960", 6378155, 0.006693422],
+	[ 19, "South American 1969", 6378160, 0.006694542],
+	[ 20, "WGS 60", 6378165, 0.006693422],
+	[ 21, "WGS 66", 6378145, 0.006694542],
+	[ 22, "WGS-72", 6378135, 0.006694318],
+	[ 23, "WGS-84", 6378137, 0.00669438]
+]
+
+#Reference ellipsoids derived from Peter H. Dana's website-
+#http://www.utexas.edu/depts/grg/gcraft/notes/datum/elist.html
+#Department of Geography, University of Texas at Austin
+#Internet: pdana@mail.utexas.edu
+#3/22/95
+
+#Source
+#Defense Mapping Agency. 1987b. DMA Technical Report: Supplement to Department of Defense World Geodetic System
+#1984 Technical Report. Part I and II. Washington, DC: Defense Mapping Agency
+
+#def LLtoUTM(int ReferenceEllipsoid, const double Lat, const double Long,
+#			 double &UTMNorthing, double &UTMEasting, char* UTMZone)
+
+def LLtoUTM( Lat, Long, ReferenceEllipsoid=23):
+    """
+    converts lat/long to UTM coords.  Equations from USGS Bulletin 1532
+    East Longitudes are positive, West longitudes are negative.
+    North latitudes are positive, South latitudes are negative
+    Lat and Long are in decimal degrees
+    Written by Chuck Gantz- chuck.gantz@globalstar.com
+    """
+    a = _ellipsoid[ReferenceEllipsoid][_EquatorialRadius]
+    eccSquared = _ellipsoid[ReferenceEllipsoid][_eccentricitySquared]
+    k0 = 0.9996
+
+#Make sure the longitude is between -180.00 .. 179.9
+    LongTemp = (Long+180)-int((Long+180)/360)*360-180 # -180.00 .. 179.9
+
+    LatRad = Lat*_deg2rad
+    LongRad = LongTemp*_deg2rad
+
+    ZoneNumber = int((LongTemp + 180)/6) + 1
+
+    if Lat >= 56.0 and Lat < 64.0 and LongTemp >= 3.0 and LongTemp < 12.0:
+        ZoneNumber = 32
+
+    # Special zones for Svalbard
+    if Lat >= 72.0 and Lat < 84.0:
+        if  LongTemp >= 0.0  and LongTemp <  9.0:ZoneNumber = 31
+        elif LongTemp >= 9.0  and LongTemp < 21.0: ZoneNumber = 33
+        elif LongTemp >= 21.0 and LongTemp < 33.0: ZoneNumber = 35
+        elif LongTemp >= 33.0 and LongTemp < 42.0: ZoneNumber = 37
+
+    LongOrigin = (ZoneNumber - 1)*6 - 180 + 3 #+3 puts origin in middle of zone
+    LongOriginRad = LongOrigin * _deg2rad
+
+    #compute the UTM Zone from the latitude and longitude
+    UTMZone = "%d%c" % (ZoneNumber, _UTMLetterDesignator(Lat))
+
+    eccPrimeSquared = (eccSquared)/(1-eccSquared)
+    N = a/sqrt(1-eccSquared*sin(LatRad)*sin(LatRad))
+    T = tan(LatRad)*tan(LatRad)
+    C = eccPrimeSquared*cos(LatRad)*cos(LatRad)
+    A = cos(LatRad)*(LongRad-LongOriginRad)
+
+    M = a*((1
+            - eccSquared/4
+            - 3*eccSquared*eccSquared/64
+            - 5*eccSquared*eccSquared*eccSquared/256)*LatRad
+           - (3*eccSquared/8
+              + 3*eccSquared*eccSquared/32
+              + 45*eccSquared*eccSquared*eccSquared/1024)*sin(2*LatRad)
+           + (15*eccSquared*eccSquared/256 + 45*eccSquared*eccSquared*eccSquared/1024)*sin(4*LatRad)
+           - (35*eccSquared*eccSquared*eccSquared/3072)*sin(6*LatRad))
+
+    UTMEasting = (k0*N*(A+(1-T+C)*A*A*A/6
+                        + (5-18*T+T*T+72*C-58*eccPrimeSquared)*A*A*A*A*A/120)
+                  + 500000.0)
+
+    UTMNorthing = (k0*(M+N*tan(LatRad)*(A*A/2+(5-T+9*C+4*C*C)*A*A*A*A/24
+                                        + (61
+                                           -58*T
+                                           +T*T
+                                           +600*C
+                                           -330*eccPrimeSquared)*A*A*A*A*A*A/720)))
+
+    if Lat < 0:
+        UTMNorthing = UTMNorthing + 10000000.0; #10000000 meter offset for southern hemisphere
+    #UTMZone was originally returned here.  I don't know what the
+    #letter at the end was for.
+    return (ZoneNumber, UTMEasting, UTMNorthing)
+
+
+def _UTMLetterDesignator(Lat):
+#This routine determines the correct UTM letter designator for the given latitude
+#returns 'Z' if latitude is outside the UTM limits of 84N to 80S
+#Written by Chuck Gantz- chuck.gantz@globalstar.com
+
+    if 84 >= Lat >= 72: return 'X'
+    elif 72 > Lat >= 64: return 'W'
+    elif 64 > Lat >= 56: return 'V'
+    elif 56 > Lat >= 48: return 'U'
+    elif 48 > Lat >= 40: return 'T'
+    elif 40 > Lat >= 32: return 'S'
+    elif 32 > Lat >= 24: return 'R'
+    elif 24 > Lat >= 16: return 'Q'
+    elif 16 > Lat >= 8: return 'P'
+    elif  8 > Lat >= 0: return 'N'
+    elif  0 > Lat >= -8: return 'M'
+    elif -8> Lat >= -16: return 'L'
+    elif -16 > Lat >= -24: return 'K'
+    elif -24 > Lat >= -32: return 'J'
+    elif -32 > Lat >= -40: return 'H'
+    elif -40 > Lat >= -48: return 'G'
+    elif -48 > Lat >= -56: return 'F'
+    elif -56 > Lat >= -64: return 'E'
+    elif -64 > Lat >= -72: return 'D'
+    elif -72 > Lat >= -80: return 'C'
+    else: return 'Z'	# if the Latitude is outside the UTM limits
+
+#void UTMtoLL(int ReferenceEllipsoid, const double UTMNorthing, const double UTMEasting, const char* UTMZone,
+#			  double& Lat,  double& Long )
+
+def UTMtoLL(northing, easting, zone, isSouthernHemisphere=True,
+            ReferenceEllipsoid=23):
+    """
+    converts UTM coords to lat/long.  Equations from USGS Bulletin 1532
+    East Longitudes are positive, West longitudes are negative.
+    North latitudes are positive, South latitudes are negative
+    Lat and Long are in decimal degrees.
+    Written by Chuck Gantz- chuck.gantz@globalstar.com
+    Converted to Python by Russ Nelson <nelson@crynwr.com>
+
+    FIXME: This is set up to work for the Southern Hemisphere.
+
+Using
+http://www.ga.gov.au/geodesy/datums/redfearn_geo_to_grid.jsp
+
+    Site Name:    GDA-MGA: (UTM with GRS80 ellipsoid) 
+Zone:   36    
+Easting:  511669.521  Northing: 19328195.112 
+Latitude:   84  0 ' 0.00000 ''  Longitude: 34  0 ' 0.00000 '' 
+Grid Convergence:  0  -59 ' 40.28 ''  Point Scale: 0.99960166
+
+____________
+Site Name:    GDA-MGA: (UTM with GRS80 ellipsoid) 
+Zone:   36    
+Easting:  519384.803  Northing: 1118247.585 
+Latitude:   -80  0 ' 0.00000 ''  Longitude: 34  0 ' 0.00000 '' 
+Grid Convergence:  0  59 ' 5.32 ''  Point Scale: 0.99960459 
+___________
+Site Name:    GDA-MGA: (UTM with GRS80 ellipsoid) 
+Zone:   36    
+Easting:  611263.812  Northing: 10110547.106 
+Latitude:   1  0 ' 0.00000 ''  Longitude: 34  0 ' 0.00000 '' 
+Grid Convergence:  0  -1 ' 2.84 ''  Point Scale: 0.99975325 
+______________
+Site Name:    GDA-MGA: (UTM with GRS80 ellipsoid) 
+Zone:   36    
+Easting:  611263.812  Northing: 9889452.894 
+Latitude:   -1  0 ' 0.00000 ''  Longitude: 34  0 ' 0.00000 '' 
+Grid Convergence:  0  1 ' 2.84 ''  Point Scale: 0.99975325 
+
+So this uses a false northing of 10000000 in the both hemispheres.
+ArcGIS used a false northing of 0 in the northern hem though.
+Therefore it is difficult to actually know what hemisphere you are in.
+    """
+    k0 = 0.9996
+    a = _ellipsoid[ReferenceEllipsoid][_EquatorialRadius]
+    eccSquared = _ellipsoid[ReferenceEllipsoid][_eccentricitySquared]
+    e1 = (1-sqrt(1-eccSquared))/(1+sqrt(1-eccSquared))
+
+    x = easting - 500000.0 #remove 500,000 meter offset for longitude
+    y = northing
+
+    ZoneNumber = int(zone)
+    if isSouthernHemisphere:
+        y -= 10000000.0         # remove 10,000,000 meter offset used
+                                # for southern hemisphere
+
+    LongOrigin = (ZoneNumber - 1)*6 - 180 + 3  # +3 puts origin in middle of zone
+
+    eccPrimeSquared = (eccSquared)/(1-eccSquared)
+
+    M = y / k0
+    mu = M/(a*(1-eccSquared/4-3*eccSquared*eccSquared/64-5*eccSquared*eccSquared*eccSquared/256))
+
+    phi1Rad = (mu + (3*e1/2-27*e1*e1*e1/32)*sin(2*mu)
+               + (21*e1*e1/16-55*e1*e1*e1*e1/32)*sin(4*mu)
+               +(151*e1*e1*e1/96)*sin(6*mu))
+    phi1 = phi1Rad*_rad2deg;
+
+    N1 = a/sqrt(1-eccSquared*sin(phi1Rad)*sin(phi1Rad))
+    T1 = tan(phi1Rad)*tan(phi1Rad)
+    C1 = eccPrimeSquared*cos(phi1Rad)*cos(phi1Rad)
+    R1 = a*(1-eccSquared)/pow(1-eccSquared*sin(phi1Rad)*sin(phi1Rad), 1.5)
+    D = x/(N1*k0)
+
+    Lat = phi1Rad - (N1*tan(phi1Rad)/R1)*(D*D/2-(5+3*T1+10*C1-4*C1*C1-9*eccPrimeSquared)*D*D*D*D/24
+                                          +(61+90*T1+298*C1+45*T1*T1-252*eccPrimeSquared-3*C1*C1)*D*D*D*D*D*D/720)
+    Lat = Lat * _rad2deg
+
+    Long = (D-(1+2*T1+C1)*D*D*D/6+(5-2*C1+28*T1-3*C1*C1+8*eccPrimeSquared+24*T1*T1)
+            *D*D*D*D*D/120)/cos(phi1Rad)
+    Long = LongOrigin + Long * _rad2deg
+    return (Lat, Long)
+
+if __name__ == '__main__':
+    (z, e, n) = LLtoUTM(45.00, -75.00, 23)
+    print z, e, n
+    (lat, lon) = UTMtoLL(n, e, z, 23)
+    print lat, lon

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/coordinate_transforms/point.py

@@ -0,0 +1,128 @@
+"""point.py - Represents a generic point on a sphere as a Python object.
+
+   See documentation of class Point for details.
+   Ole Nielsen, ANU 2002
+"""
+
+
+from math import cos, sin, pi
+
+def acos(c):
+  """acos -  Safe inverse cosine
+  
+     Input argument c is shrunk to admissible interval
+     to avoid case where a small rounding error causes
+     a math domain error.
+  """
+  from math import acos
+
+  if c > 1: c=1
+  if c < -1: c=-1
+
+  return acos(c)
+
+
+
+
+class Point:
+    """Definition of a generic point on the sphere.
+  
+    Defines a point in terms of latitude and longitude
+    and computes distances to other points on the sphere.
+
+    Initialise as
+      Point(lat, lon), where lat and lon are in decimal degrees (dd.dddd)
+      
+
+    Public Methods: 
+        distance_to(P)
+        bearing_to(P)
+        dist(P)
+
+    Author: Ole Nielsen, ANU 2002        
+    """
+     
+    # class constants
+    R = 6372000  # Approximate radius of Earth (m)
+    degrees2radians = pi/180.0
+    
+
+    def __init__(self, latitude, longitude):
+
+        assert(latitude >= -90 and latitude <= 90.0)
+        assert(longitude >= -180 and longitude <= 180.0)
+
+        self.latitude =  float(latitude)
+        self.longitude = float(longitude) 
+
+        lat = latitude * self.degrees2radians    # Converted to radians
+        lon = longitude * self.degrees2radians   # Converted to radians
+        self.coslat = cos(lat)
+        self.coslon = cos(lon)
+        self.sinlat = sin(lat)
+        self.sinlon = sin(lon)
+
+    def BearingTo(self,P):
+        """ Bearing (in degrees) to point P"""
+        AZ = self.AZ(P)
+        return int(round(AZ/self.degrees2radians))
+
+    
+    def DistanceTo(self,P):
+        """ Distance to point P"""           
+        GCA = self.GCA(P)
+        return self.R*GCA
+
+
+    def Dist(self,P):
+        """ Very cheap and rough approximation to distance"""
+        return max(abs(self.latitude-P.latitude),abs(self.longitude-P.longitude))
+
+
+    #--------------------------------------------------------------------------
+
+    def __repr__(self):
+        d = 2
+        lat = round(self.latitude,d)
+        lon = round(self.longitude,d)
+        return ' (' + str(lat)+ ', '+ str(lon)+')'
+
+
+    def GCA(self,P):
+        """ Compute the Creat Circle Angle (GCA) between current point and P.
+        """
+        
+        alpha = P.coslon*self.coslon + P.sinlon*self.sinlon
+        # The original formula is alpha = cos(self.lon - P.lon)
+        # but rewriting lets us make us of precomputed trigonometric values.
+        
+        x = alpha*self.coslat*P.coslat + self.sinlat*P.sinlat
+        return acos(x)
+
+    
+    def AZ(self,P):
+        """ Compute Azimuth bearing (AZ) from current point to P"""
+
+        # Compute cosine(AZ), where AZ is the azimuth angle
+        GCA = self.GCA(P)
+        c = P.sinlat - self.sinlat*cos(GCA)
+        c = c/self.coslat/sin(GCA)
+
+        AZ = acos(c)
+
+        # Reverse direction if bearing is westward, i.e. sin(self.lon - P.lon) > 0
+        # Without this correction the bearing due west, say, will be 90 degrees
+        # because the formulas work in the positive direction which is east.
+        #
+        # Precomputed trigonometric values are used to rewrite the formula:
+
+        if self.sinlon*P.coslon - self.coslon*P.sinlon > 0: AZ = 2*pi - AZ
+    
+        return AZ
+
+
+
+#-----------------------------------------------------------------------
+
+if __name__ == "__main__":
+    pass

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/coordinate_transforms/redfearn.py

@@ -0,0 +1,233 @@
+"""Implementation of Redfearn's formula to compute UTM projections from latitude and longitude
+
+Based in part on spreadsheet
+www.icsm.gov.au/gda/gdatm/redfearn.xls
+downloaded from INTERGOVERNMENTAL COMMITTEE ON SURVEYING & MAPPING (ICSM)
+http://www.icsm.gov.au/icsm/
+
+"""
+from anuga.coordinate_transforms.geo_reference import Geo_reference, DEFAULT_ZONE
+
+
+def degminsec2decimal_degrees(dd,mm,ss):
+    assert abs(mm) == mm
+    assert abs(ss) == ss    
+
+    if dd < 0:
+        sign = -1
+    else:
+        sign = 1
+    
+    return sign * (abs(dd) + mm/60. + ss/3600.)      
+    
+def decimal_degrees2degminsec(dec):
+
+    if dec < 0:
+        sign = -1
+    else:
+        sign = 1
+
+    dec = abs(dec)    
+    dd = int(dec)
+    f = dec-dd
+
+    mm = int(f*60)
+    ss = (f*60-mm)*60
+    
+    return sign*dd, mm, ss
+
+def redfearn(lat, lon, false_easting=None, false_northing=None,
+             zone=None, central_meridian=None, scale_factor=None):
+    """Compute UTM projection using Redfearn's formula
+
+    lat, lon is latitude and longitude in decimal degrees
+
+    If false easting and northing are specified they will override
+    the standard
+
+    If zone is specified reproject lat and long to specified zone instead of
+    standard zone
+
+    If meridian is specified, reproject lat and lon to that instead of zone. In this case
+    zone will be set to -1 to indicate non-UTM projection
+
+    Note that zone and meridian cannot both be specifed
+    """
+
+
+    from math import pi, sqrt, sin, cos, tan
+    
+
+
+    # GDA Specifications
+    a = 6378137.0                       #Semi major axis
+    inverse_flattening = 298.257222101  #1/f
+    if scale_factor is None:
+        K0 = 0.9996                         #Central scale factor    
+    else:
+        K0 = scale_factor
+    zone_width = 6                      #Degrees
+
+    longitude_of_central_meridian_zone0 = -183    
+    longitude_of_western_edge_zone0 = -186
+
+    if false_easting is None:
+        false_easting = 500000
+
+    if false_northing is None:
+        if lat < 0:
+            false_northing = 10000000  #Southern hemisphere
+        else:
+            false_northing = 0         #Northern hemisphere)
+        
+    
+    # Derived constants
+    f = 1.0/inverse_flattening
+    b = a*(1-f)       #Semi minor axis
+
+    e2 = 2*f - f*f#    = f*(2-f) = (a^2-b^2/a^2   #Eccentricity
+    e = sqrt(e2)
+    e2_ = e2/(1-e2)   # = (a^2-b^2)/b^2 #Second eccentricity
+    e_ = sqrt(e2_)
+    e4 = e2*e2
+    e6 = e2*e4
+
+    # Foot point latitude
+    n = (a-b)/(a+b) #Same as e2 - why ?
+    n2 = n*n
+    n3 = n*n2
+    n4 = n2*n2
+
+    G = a*(1-n)*(1-n2)*(1+9*n2/4+225*n4/64)*pi/180
+
+
+    phi = lat*pi/180     #Convert latitude to radians
+
+    sinphi = sin(phi)   
+    sin2phi = sin(2*phi)
+    sin4phi = sin(4*phi)
+    sin6phi = sin(6*phi)
+
+    cosphi = cos(phi)
+    cosphi2 = cosphi*cosphi
+    cosphi3 = cosphi*cosphi2
+    cosphi4 = cosphi2*cosphi2
+    cosphi5 = cosphi*cosphi4    
+    cosphi6 = cosphi2*cosphi4
+    cosphi7 = cosphi*cosphi6
+    cosphi8 = cosphi4*cosphi4        
+
+    t = tan(phi)
+    t2 = t*t
+    t4 = t2*t2
+    t6 = t2*t4
+    
+    # Radius of Curvature
+    rho = a*(1-e2)/(1-e2*sinphi*sinphi)**1.5
+    nu = a/(1-e2*sinphi*sinphi)**0.5
+    psi = nu/rho
+    psi2 = psi*psi
+    psi3 = psi*psi2
+    psi4 = psi2*psi2
+
+    # Meridian distance
+    A0 = 1 - e2/4 - 3*e4/64 - 5*e6/256
+    A2 = 3.0/8*(e2+e4/4+15*e6/128)
+    A4 = 15.0/256*(e4+3*e6/4)
+    A6 = 35*e6/3072
+    
+    term1 = a*A0*phi
+    term2 = -a*A2*sin2phi
+    term3 = a*A4*sin4phi
+    term4 = -a*A6*sin6phi
+
+    m = term1 + term2 + term3 + term4 #OK
+
+    if zone is not None and central_meridian is not None:
+        msg = 'You specified both zone and central_meridian. Provide only one of them'
+        raise Exception, msg
+    
+    # Zone
+    if zone is None:
+        zone = int((lon - longitude_of_western_edge_zone0)/zone_width)
+
+    # Central meridian
+    if central_meridian is None:
+        central_meridian = zone*zone_width+longitude_of_central_meridian_zone0
+    else:
+        zone = -1
+
+    omega = (lon-central_meridian)*pi/180 #Relative longitude (radians)
+    omega2 = omega*omega
+    omega3 = omega*omega2
+    omega4 = omega2*omega2
+    omega5 = omega*omega4
+    omega6 = omega3*omega3
+    omega7 = omega*omega6
+    omega8 = omega4*omega4
+     
+    # Northing
+    term1 = nu*sinphi*cosphi*omega2/2  
+    term2 = nu*sinphi*cosphi3*(4*psi2+psi-t2)*omega4/24
+    term3 = nu*sinphi*cosphi5*\
+            (8*psi4*(11-24*t2)-28*psi3*(1-6*t2)+\
+             psi2*(1-32*t2)-psi*2*t2+t4-t2)*omega6/720
+    term4 = nu*sinphi*cosphi7*(1385-3111*t2+543*t4-t6)*omega8/40320
+    northing = false_northing + K0*(m + term1 + term2 + term3 + term4)
+
+    # Easting
+    term1 = nu*omega*cosphi
+    term2 = nu*cosphi3*(psi-t2)*omega3/6
+    term3 = nu*cosphi5*(4*psi3*(1-6*t2)+psi2*(1+8*t2)-2*psi*t2+t4)*omega5/120
+    term4 = nu*cosphi7*(61-479*t2+179*t4-t6)*omega7/5040
+    easting = false_easting + K0*(term1 + term2 + term3 + term4)
+    
+    return zone, easting, northing
+
+
+
+def convert_from_latlon_to_utm(points=None,
+                               latitudes=None,
+                               longitudes=None,
+                               false_easting=None,
+                               false_northing=None):
+    """Convert latitude and longitude data to UTM as a list of coordinates.
+
+
+    Input
+
+    points: list of points given in decimal degrees (latitude, longitude) or
+    latitudes: list of latitudes   and
+    longitudes: list of longitudes 
+    false_easting (optional)
+    false_northing (optional)
+
+    Output
+
+    points: List of converted points
+    zone:   Common UTM zone for converted points
+
+
+    Notes
+
+    Assume the false_easting and false_northing are the same for each list.
+    If points end up in different UTM zones, an ANUGAerror is thrown.    
+    """
+
+    old_geo = Geo_reference()    
+    utm_points = []
+    if points == None:
+        assert len(latitudes) == len(longitudes)
+        points =  map(None, latitudes, longitudes)
+        
+    for point in points:
+        
+        zone, easting, northing = redfearn(float(point[0]),
+                                           float(point[1]),
+                                           false_easting=false_easting,
+                                           false_northing=false_northing)
+        new_geo = Geo_reference(zone)
+        old_geo.reconcile_zones(new_geo)        
+        utm_points.append([easting, northing])
+
+    return utm_points, old_geo.get_zone()

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/coordinate_transforms/setup.py

@@ -0,0 +1,21 @@
+from __future__ import division, print_function
+
+import os
+import sys
+
+from os.path import join
+
+def configuration(parent_package='',top_path=None):
+    
+    from numpy.distutils.misc_util import Configuration
+    from numpy.distutils.system_info import get_info
+    
+    config = Configuration('coordinate_transforms', parent_package, top_path)
+
+    config.add_data_dir('tests')
+
+    return config
+    
+if __name__ == '__main__':
+    from numpy.distutils.core import setup
+    setup(configuration=configuration)

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/coordinate_transforms/tests/__init__.py

@@ -0,0 +1,8 @@
+"""Make directory available as a Python package
+"""
+
+pass
+
+
+
+

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/coordinate_transforms/tests/data/projection_test_points.csv

@@ -0,0 +1,11 @@
+index,longitude,latitude,x,y
+1938,137.3667,-36.6833,488090.4787,5940250.976
+1939,137.45,-36.7667,495537.6414,5931006.682
+1940,137.5833,-36.85,507426.2409,5921764.169
+1941,137.7333,-36.9167,520780.755,5914342.892
+1942,137.8833,-36.9833,534112.0546,5906911.57
+1943,138.05,-37.0333,548915.6962,5901292.137
+1944,138.2167,-37.05,563727.8276,5899340.788
+1945,138.5333,-37.0167,591920.2434,5902775.993
+1946,138.7,-37.05,606703.4855,5898907.643
+1947,138.8667,-37.0667,621500.4703,5896854.808

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/coordinate_transforms/tests/data/projection_test_points.lic

@@ -0,0 +1,17 @@
+<?xml version='1.0' encoding='iso-8859-1'?>
+<ga_license_file>
+  <metadata>
+    <author>Ole Nielsen</author>
+  </metadata>
+  
+  <datafile>
+    <filename>projection_test_points.csv</filename>
+    <checksum>3110012168</checksum>
+    <publishable>Yes</publishable>
+    <accountable>Ole Nielsen</accountable>
+    <source>Generated by Leharne Fountainfrom Geoscience Australia</source>
+    <IP_owner>Geoscience Australia</IP_owner>
+    <IP_info>Test points using nonstandard meridian for use with the ANUGA test suite</IP_info>    
+  </datafile>
+
+</ga_license_file>

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/coordinate_transforms/tests/data/projection_test_points_z53.csv

@@ -0,0 +1,11 @@
+index,longitude,latitude,x,y
+1938,137.3667,-36.6833,711467.1571,5937649.285
+1939,137.45,-36.7667,718674.6241,5928208.411
+1940,137.5833,-36.85,730324.6941,5918652.234
+1941,137.7333,-36.9167,743489.2693,5910878.287
+1942,137.8833,-36.9833,756630.9716,5903093.775
+1943,138.05,-37.0333,771294.0973,5897082.226
+1944,138.2167,-37.05,786063.3258,5894739.807
+1945,138.5333,-37.0167,814365.6385,5897435.082
+1946,138.7,-37.05,829058.9322,5893174.241
+1947,138.8667,-37.0667,843814.9366,5890729.536