Example #1
0
    def test_point_collection(self):
        dt1 = datetime.date(2007, 12, 5)
        p1 = Point()
        p1.time = dt1
        p1.location = sPoint(-180, -90, 0)
        member1 = Member(value=5.4, unit='m', name='Sea Surface Height', description='sea height', standard='sea_surface_height')
        member2 = Member(value=8.1, unit='m', name='Wave Height', description='wave height', standard='wave_height')
        p1.add_member(member1)
        p1.add_member(member2)

        dt2 = datetime.date(2008, 2, 14)
        p2 = Point()
        p2.time = dt2
        p2.location = sPoint(-120, 50, 10)
        member3 = Member(value=5.4, unit='m', name='Sea Surface Height', description='sea height', standard='sea_surface_height')
        member4 = Member(value=8.1, unit='m', name='Wave Height', description='wave height', standard='wave_height')
        p2.add_member(member3)
        p2.add_member(member4)

        pc = PointCollection(elements=[p1,p2])
        pc.calculate_bounds()

        assert pc.size == 2
        assert pc.time_range[0] == dt1
        assert pc.time_range[-1] == dt2
        assert pc.depth_range[0] == p1.location.z
        assert pc.depth_range[-1] == p2.location.z
        assert pc.upper_right().equals(sPoint(p2.location.x, p2.location.y))
        assert pc.lower_left().equals(sPoint(p1.location.x, p1.location.y))
        
Example #2
0
    def test_trajectory(self):
        dt1 = datetime(2012, 4, 1, 0)
        p1 = Point()
        p1.time = dt1
        p1.location = sPoint(-121, 49, 40)
        member1 = Member(value=random.uniform(30,40), unit='°C', name='Water Temperatire', description='water temperature', standard='sea_water_temperature')
        member2 = Member(value=random.uniform(80,100), unit='PSU', name='Salinity', description='salinity', standard='salinity')
        p1.add_member(member1)
        p1.add_member(member2)

        dt2 = datetime(2012, 4, 1, 1)
        p2 = Point()
        p2.time = dt2
        p2.location = sPoint(-120, 50, 60)
        member3 = Member(value=random.uniform(30,40), unit='°C', name='Water Temperatire', description='water temperature', standard='sea_water_temperature')
        member4 = Member(value=random.uniform(80,100), unit='PSU', name='Salinity', description='salinity', standard='salinity')
        p2.add_member(member3)
        p2.add_member(member4)

        tr = Trajectory(elements=[p1,p2])
        tr.calculate_bounds()

        assert len(tr.get_path()) == 2
        assert tr.size == 2
        assert tr.type == "Trajectory"
        assert tr.time_range[0] == dt1
        assert tr.time_range[-1] == dt2
        assert tr.depth_range[0] == p1.location.z
        assert tr.depth_range[-1] == p2.location.z
        assert tr.upper_right().equals(sPoint(p2.location.x, p2.location.y))
        assert tr.lower_left().equals(sPoint(p1.location.x, p1.location.y))
        
Example #3
0
    def test_section(self):

        day = 1
        hour = 0
        sc = Section()
        dt = None

        # 10 profiles
        for x in xrange(0, 10):
            lat = random.randint(40, 44)
            lon = random.randint(-74, -70)
            loc = sPoint(lon, lat, 0)
            minute = 0
            dt = datetime(2012, 4, day, hour, minute)
            hour += 1

            prof = Profile()
            prof.location = loc
            prof.time = dt

            # Each with 20 depths
            for y in xrange(0, 20):
                p = Point()
                p.time = dt
                p.location = sPoint(loc.x, loc.y, y)
                m1 = Member(value=random.uniform(30, 40),
                            unit='°C',
                            name='Water Temperatire',
                            description='water temperature',
                            standard='sea_water_temperature')
                m2 = Member(value=random.uniform(80, 100),
                            unit='PSU',
                            name='Salinity',
                            description='salinity',
                            standard='salinity')
                p.add_member(m1)
                p.add_member(m2)
                prof.add_element(p)
                # Next depth is 2 minutes from now
                dt = dt + timedelta(minutes=2)

            sc.add_element(prof)

        sc.calculate_bounds()

        assert len(sc.get_path()) == 10

        assert sc.size == 10
        assert sc.point_size == 200
        assert sc.type == "Section"

        assert len(sc.time_range) == 200
        assert sc.time_range[0] == datetime(2012, 4, 1, 0, 0)
        assert sc.time_range[-1] == dt - timedelta(minutes=2)

        assert len(sc.depth_range) == 200
        assert sc.depth_range[0] == 0
        assert sc.depth_range[-1] == 19
    def test_section_collection(self):

        s_collection = SectionCollection()

        # 20 sections
        for x in range(0,20):

            day = 1
            hour = 0
            sc = Section()
            dt = None

            # 10 profiles per section
            for x in range(0,10):
                lat = random.randint(40,44)
                lon = random.randint(-74,-70)
                loc = sPoint(lon,lat,0)
                minute = 0
                dt = datetime(2012, 4, day, hour, minute)
                hour += 1

                prof = Profile()
                prof.location = loc
                prof.time = dt

                # Each with 20 depths
                for y in range(0,20):
                    p = Point()
                    p.time = dt
                    p.location = sPoint(loc.x, loc.y, y)
                    m1 = Member(value=random.uniform(30,40), unit='°C', name='Water Temperature', description='water temperature', standard='sea_water_temperature')
                    m2 = Member(value=random.uniform(80,100), unit='PSU', name='Salinity', description='salinity', standard='salinity')
                    p.add_member(m1)
                    p.add_member(m2)
                    prof.add_element(p)
                    # Next depth is 2 minutes from now
                    dt = dt + timedelta(minutes=2)

                sc.add_element(prof)

            s_collection.add_element(sc)

        s_collection.calculate_bounds()

        assert s_collection.depth_range[0] == 0
        assert s_collection.depth_range[-1] == 19
        assert s_collection.time_range[0] == datetime(2012, 4, 1, 0)

        for section in s_collection:
            assert section.type == "Section"
            for profile in section:
                assert profile.type == "Profile"
                for point in profile:
                    assert point.type == "Point"

        for point in s_collection.flatten():
            assert point.type == "Point"
    def test_section_collection(self):

        s_collection = SectionCollection()

        # 20 sections
        for x in xrange(0,20):

            day = 1
            hour = 0
            sc = Section()
            dt = None

            # 10 profiles per section
            for x in xrange(0,10):
                lat = random.randint(40,44)
                lon = random.randint(-74,-70)
                loc = sPoint(lon,lat,0)
                minute = 0
                dt = datetime(2012, 4, day, hour, minute)
                hour += 1

                prof = Profile()
                prof.location = loc
                prof.time = dt

                # Each with 20 depths
                for y in xrange(0,20):
                    p = Point()
                    p.time = dt
                    p.location = sPoint(loc.x, loc.y, y)
                    m1 = Member(value=random.uniform(30,40), unit='°C', name='Water Temperatire', description='water temperature', standard='sea_water_temperature')
                    m2 = Member(value=random.uniform(80,100), unit='PSU', name='Salinity', description='salinity', standard='salinity')
                    p.add_member(m1)
                    p.add_member(m2)
                    prof.add_element(p)
                    # Next depth is 2 minutes from now
                    dt = dt + timedelta(minutes=2)

                sc.add_element(prof)
                
            s_collection.add_element(sc)

        s_collection.calculate_bounds()

        assert s_collection.depth_range[0] == 0
        assert s_collection.depth_range[-1] == 19
        assert s_collection.time_range[0] == datetime(2012, 4, 1, 0)

        for section in s_collection:
            assert section.type == "Section"
            for profile in section:
                assert profile.type == "Profile"
                for point in profile:
                    assert point.type == "Point"

        for point in s_collection.flatten():
            assert point.type == "Point"
Example #6
0
    def __init__(self, **kwargs):
        super(SweTimeSeries,self).__init__(**kwargs)

        # Parse out GML point.  Defaults to 0 depth if none specified
        self.geo_srs = Crs(testXMLAttribute(self._location.find(nsp("Point", self.GML_NS)), 'srsName'))
        geo = [float(v) for v in testXMLValue(self._location.find(nsp("Point/pos", self.GML_NS))).split(" ")]

        if self.geo_srs.axisorder == "yx":
            self.geo = sPoint(geo[1], geo[0])
        else:
            self.geo = sPoint(geo[0], geo[1])

        try:
            self.geo.z = geo[2]
        except:
            pass


        pc = PointCollection()

        for row in self.results.data:
            p = Point()

            time = None
            z = None
            lat = None
            lon = None

            for field in row:

                if field.axis == "time":
                    t = dateutil.parser.parse(field.value)
                    p.time = t.astimezone(dateutil.tz.tzutc())
                elif field.axis == "Long":
                    lon = field
                elif field.axis == "Lat":
                    lat = field
                elif field.axis == "h":
                    z = field
                else:
                    m = Member(value=field.value,
                               unit=field.units,
                               units_definition=field.units_url,
                               name=field.name,
                               definition=field.definition,
                               standard=field.definition)
                    p.add_member(m)

            # Set the spatial point
            if lon.srs != lat.srs:
                raise ValueError("Longitude and Latitude need to have the same SRS/CRS!")
            p.location = sPoint(float(lon.value), float(lat.value), float(z.value))
            pc.add_element(p)


        self.data = pc
    def test_profile_collection(self):

        day = 1
        pc = ProfileCollection()
        dt = None

        # 10 profiles
        for x in range(0,10):
            lat = random.randint(40,44)
            lon = random.randint(-74,-70)
            loc = sPoint(lon,lat,0)
            hour = 0
            minute = 0
            dt = datetime(2012, 4, day, hour, minute)

            prof = Profile()
            prof.location = loc
            prof.time = dt

            # Each with 20 depths
            for y in range(0,20):
                p = Point()
                p.time = dt
                p.location = sPoint(loc.x, loc.y, y)
                m1 = Member(value=random.uniform(30,40), unit='°C', name='Water Temperature', description='water temperature', standard='sea_water_temperature')
                m2 = Member(value=random.uniform(80,100), unit='PSU', name='Salinity', description='salinity', standard='salinity')
                p.add_member(m1)
                p.add_member(m2)
                prof.add_element(p)
                # Next depth is 2 minutes from now
                dt = dt + timedelta(minutes=2)

            pc.add_element(prof)

        pc.calculate_bounds()

        assert pc.size == 10
        assert pc.point_size == 200

        assert len(pc.time_range) == 200
        assert pc.time_range[0] == datetime(2012, 4, 1, 0, 0)
        assert pc.time_range[-1] == dt - timedelta(minutes=2)

        assert len(pc.depth_range) == 200
        assert pc.depth_range[0] == 0
        assert pc.depth_range[-1] == 19

        for profile in pc:
            assert profile.type == "Profile"
            for point in profile:
                assert point.type == "Point"

        for point in pc.flatten():
            assert point.type == "Point"
Example #8
0
    def test_station_profile(self):

        sp = StationProfile()
        sp.name = "Profile Station"
        sp.location = sPoint(-77, 33)
        sp.uid = "1234"
        sp.set_property("authority", "IOOS")

        # add a sequence of profiles
        for y in range(3):
            dt1 = datetime(2013, 1, 1, 12, 0, 10 * y)
            prof1 = Profile()
            prof1.location = sPoint(-77, 33)
            prof1.time = dt1

            # add a string of points going down in z
            for x in range(5):
                p1 = Point()
                p1.time = dt1
                p1.location = sPoint(-77, 33, -5 * x)

                member1 = Member(value=30 - (2 * x),
                                 units='°C',
                                 name='Water Temperature',
                                 description='water temperature',
                                 standard='sea_water_temperature')
                member2 = Member(value=80 + (2 * x),
                                 units='PSU',
                                 name='Salinity',
                                 description='salinity',
                                 standard='salinity')
                p1.add_member(member1)
                p1.add_member(member2)

                prof1.add_element(p1)

            sp.add_element(prof1)

        sp.calculate_bounds()

        assert sp.size == 3
        assert len(sp.time_range) == 3

        assert sp.depth_range[0] == -20
        assert sp.depth_range[-1] == 0

        assert sp.get_property("authority") == "IOOS"
        assert sp.uid == "1234"

        assert len(sp.get_unique_members()) == 2
    def _parse_location(self, loc_el, station_point):
        vector         = loc_el.content

        srss           = vector.referenceFrame.split("&")

        hsrs = None
        try:
            hsrs = Crs(srss[0])
        except ValueError:
            pass

        vsrs = None
        try:
            vsrs = Crs(srss[-1].replace("2=http:", "http:"))
        except ValueError:
            pass

        local_frame    = vector.localFrame
        lat            = vector.get_by_name("latitude").content.value
        lon            = vector.get_by_name("longitude").content.value
        z              = vector.get_by_name("height").content.value

        loc = [lon, lat]
        if z:
            loc.append(z)
        else:
            loc.append(station_point.z)

        location = {'horizontal_srs' : hsrs,
                    'vertical_srs'   : vsrs,
                    'localFrame'     : local_frame,
                    'point'          : sPoint(*loc)}

        return location
Example #10
0
    def _paths_to_cost(self):

        print "Analyzing paths..."
        count = 0
        for path in self.paths:
            count += 1
            print "\t%d of %d" % (count, len(self.paths))
            distances = np.empty((self.height, self.width))
            distances.fill(np.inf)

            min_x, min_y, max_x, max_y = path.bounds
            faraway = 5
            min_x -= faraway
            min_y -= faraway
            max_x += faraway
            max_y += faraway
            print "\t\tPath bounding  box area: %fm by %fm" % (
                abs(max_x - min_x), abs(max_y - min_y))
            for x in np.arange(min_x, max_x, self.resolution):
                for y in np.arange(min_y, max_y, self.resolution):
                    i, j = self._world_to_map(x, y)
                    pt = sPoint(x, y)
                    distances[i, j] = path.distance(pt)

            self.cost_grid += np.exp(-(distances**2))
Example #11
0
    def test_trajectory(self):
        dt1 = datetime(2012, 4, 1, 0)
        p1 = Point()
        p1.time = dt1
        p1.location = sPoint(-121, 49, 40)
        member1 = Member(value=random.uniform(30, 40),
                         unit='°C',
                         name='Water Temperatire',
                         description='water temperature',
                         standard='sea_water_temperature')
        member2 = Member(value=random.uniform(80, 100),
                         unit='PSU',
                         name='Salinity',
                         description='salinity',
                         standard='salinity')
        p1.add_member(member1)
        p1.add_member(member2)

        dt2 = datetime(2012, 4, 1, 1)
        p2 = Point()
        p2.time = dt2
        p2.location = sPoint(-120, 50, 60)
        member3 = Member(value=random.uniform(30, 40),
                         unit='°C',
                         name='Water Temperatire',
                         description='water temperature',
                         standard='sea_water_temperature')
        member4 = Member(value=random.uniform(80, 100),
                         unit='PSU',
                         name='Salinity',
                         description='salinity',
                         standard='salinity')
        p2.add_member(member3)
        p2.add_member(member4)

        tr = Trajectory(elements=[p1, p2])
        tr.calculate_bounds()

        assert len(tr.get_path()) == 2
        assert tr.size == 2
        assert tr.type == "Trajectory"
        assert tr.time_range[0] == dt1
        assert tr.time_range[-1] == dt2
        assert tr.depth_range[0] == p1.location.z
        assert tr.depth_range[-1] == p2.location.z
        assert tr.upper_right().equals(sPoint(p2.location.x, p2.location.y))
        assert tr.lower_left().equals(sPoint(p1.location.x, p1.location.y))
Example #12
0
def get_pwqmn(station_id, **kwargs):
    conn = sqlite3.connect(app.config.get("DATABASE"))
    with conn:
        conn.row_factory = sqlite3.Row
        cur = conn.cursor()
        cur.execute("SELECT * FROM stations WHERE STATION='%s'" % station_id)
        row = cur.fetchone()
        if row is not None:
            # Serve out OME
            s = pStation()
            s.uid = row["STATION"]
            s.name = row["NAME"]
            s.description = row["LOCATION"]
            s.location = sPoint(row["Longitude"], row["Latitude"], 0)
            s.set_property("country", "CA")
            s.set_property("organization_name", "Ontario Ministry of the Environment")
            s.set_property("organization_id", "ENE")

            filters = []
            starting = kwargs.get("starting", None)
            ending = kwargs.get("ending", None)
            obs = kwargs.get("observedProperties", None)
            if starting is not None:
                filters.append("AND DATE > %s" % starting.strftime("%Y-%m-%dT%H:%M:%S"))
            if ending is not None:
                filters.append("AND DATE < %s" % ending.strftime("%Y-%m-%dT%H:%M:%S"))
            if obs is not None:
                obs = map(lambda x: "'%s'" % x, obs)
                filters.append("AND PARM in (%s)" % ",".join(obs))

            cur.execute("SELECT * FROM data WHERE STATION='%s' %s ORDER BY DATE ASC" % (station_id, " ".join(filters)))
            rows = cur.fetchall()

            for d, members in itertools.groupby(rows, key=lambda s: s[3]):
                p = Point()
                p.time = datetime.strptime(d, "%Y-%m-%dT%H:%M:%S").replace(tzinfo=pytz.utc)

                for m in members:
                    p.add_member(
                        Member(
                            value=m["RESULT"],
                            unit=m["UNITS"],
                            name=m["PARM"],
                            description=m["PARM_DESCRIPTION"],
                            standard=None,
                            method_id=m["METHOD"],
                            method_name=m["METHOD"],
                        )
                    )

                s.add_element(p)

            s.calculate_bounds()
            publisher = {
                "name": "Ontario Ministry of the Environment",
                "url": "http://www.ene.gov.on.ca/environment/en/resources/collection/data_downloads/index.htm#PWQMN",
            }
            return s, publisher
    return None, None
    def test_trajectory_collection(self):

        t_collection = TrajectoryCollection()

        # 20 trajectories
        for x in range(0, 20):

            tr = Trajectory()

            month = random.randint(1, 12)
            dt = datetime(2012, month, 1, 0)

            # Starting point
            lat = random.randint(40, 44)
            lon = random.randint(-74, -70)
            depth = 0

            # 100 points in each trajectory
            for l in range(0, 100):

                lat += random.uniform(-0.25, 0.25)
                lon += random.uniform(-0.25, 0.25)
                depth += random.randint(-4, 4)
                if depth < 0:
                    depth = 0

                p1 = Point()
                p1.location = sPoint(lon, lat, depth)
                dt += timedelta(hours=1)
                p1.time = dt
                member1 = Member(value=random.uniform(30, 40),
                                 unit='°C',
                                 name='Water Temperature',
                                 description='water temperature',
                                 standard='sea_water_temperature')
                member2 = Member(value=random.uniform(80, 100),
                                 unit='PSU',
                                 name='Salinity',
                                 description='salinity',
                                 standard='salinity')
                p1.add_member(member1)
                p1.add_member(member2)

                tr.add_element(p1)

            t_collection.add_element(tr)

        t_collection.calculate_bounds()

        assert len(t_collection.time_range) == 2000
        assert len(t_collection.depth_range) == 2000

        for trajectory in t_collection:
            assert trajectory.type == "Trajectory"
            for point in trajectory:
                assert point.type == "Point"

        for point in t_collection.flatten():
            assert point.type == "Point"
Example #14
0
    def __init__(self, wqx_metadata, wqx_data):
        if not isinstance(wqx_metadata, WqxOutbound):
            wqx_metadata = WqxOutbound(wqx_metadata)

        if not isinstance(wqx_data, WqxOutbound):
            wqx_data = WqxOutbound(wqx_data)

        if wqx_data.failed or wqx_metadata.failed:
            self.feature = None
        else:
            stations = []
            station_lookup = []
            # Create a station for every MonitoringLocation
            for org in wqx_metadata.organizations:
                for ml in org.locations:
                    s = Station()
                    s.uid = ml.id
                    s.name = ml.name
                    s.set_property("station_type", ml.type)
                    s.set_property("location_description", ml.description)
                    s.set_property("huc", ml.huc)
                    s.set_property("county", ml.county)
                    s.set_property("state", ml.state)
                    s.set_property("country", ml.country)
                    s.set_property("organization_id", org.description.id)
                    s.set_property("organization_name", org.description.name)
                    s.set_property("vertical_units", ml.vertical_measure_units)
                    s.set_property("horizontal_crs", ml.horizontal_crs_name)
                    s.set_property("vertical_crs", ml.vertical_crs_name)

                    # Now set the station's location
                    vertical = 0
                    try:
                        vertical = float(ml.vertical_measure_value)
                    except:
                        pass

                    # convert the vertical to meters if it is ft (which it always is)
                    if ml.vertical_measure_units == "ft":
                        vertical /= 3.28084
                        s.set_property("vertical_units", "m")
                    s.location = sPoint(float(ml.longitude), float(ml.latitude), vertical)

                    stations.append(s)
                    station_lookup.append(s.uid)

            for org in wqx_data.organizations:
                for a in org.activities:
                    p = Point()
                    p.time = a.start_time
                    for r in a.results:
                        p.add_member(Member(value=r.value, unit=r.units, name=r.name, description=r.short_name, standard=None, quality=r.quality, method_id=a.method_id, method_name=a.method_name))

                    # Assign data to the correct station pulled from the metadata
                    station = stations[station_lookup.index(a.location_id)]
                    p.location = station.location
                    station.add_element(p)

            self.feature = StationCollection(elements=stations)
Example #15
0
    def __init__(self, wqx_metadata, wqx_data):
        if not isinstance(wqx_metadata, WqxOutbound):
            wqx_metadata = WqxOutbound(wqx_metadata)

        if not isinstance(wqx_data, WqxOutbound):
            wqx_data = WqxOutbound(wqx_data)

        if wqx_data.failed or wqx_metadata.failed:
            self.feature = None
        else:
            stations = []
            station_lookup = []
            # Create a station for every MonitoringLocation
            for org in wqx_metadata.organizations:
                for ml in org.locations:
                    s = Station()
                    s.uid = ml.id
                    s.name = ml.name
                    s.set_property("station_type", ml.type)
                    s.set_property("location_description", ml.description)
                    s.set_property("huc", ml.huc)
                    s.set_property("county", ml.county)
                    s.set_property("state", ml.state)
                    s.set_property("country", ml.country)
                    s.set_property("organization_id", org.description.id)
                    s.set_property("organization_name", org.description.name)
                    s.set_property("vertical_units", ml.vertical_measure_units)
                    s.set_property("horizontal_crs", ml.horizontal_crs_name)
                    s.set_property("vertical_crs", ml.vertical_crs_name)

                    # Now set the station's location
                    vertical = 0
                    try:
                        vertical = float(ml.vertical_measure_value)
                    except:
                        pass

                    # convert the vertical to meters if it is ft (which it always is)
                    if ml.vertical_measure_units == "ft":
                        vertical /= 3.28084
                        s.set_property("vertical_units", "m")
                    s.location = sPoint(float(ml.longitude), float(ml.latitude), vertical)

                    stations.append(s)
                    station_lookup.append(s.uid)

            for org in wqx_data.organizations:
                for a in org.activities:
                    p = Point()
                    p.time = a.start_time
                    for r in a.results:
                        p.add_member(Member(value=r.value, unit=r.units, name=r.name, description=r.short_name, standard=None, quality=r.quality, method_id=a.method_id, method_name=a.method_name))

                    # Assign data to the correct station pulled from the metadata
                    station = stations[station_lookup.index(a.location_id)]
                    p.location = station.location
                    station.add_element(p)

            self.feature = StationCollection(elements=stations)
Example #16
0
 def point_to_node(pt):
     ''' converts a Steiner point (which by definition has node=None)
         into a Branch node.  Make sure we do this only once as we
         want to use that node in a graph later on.  This is as simple
         as just assigning the node property to the generated Branch '''
     if pt.node is None:
         pt.node = types.Branch(sPoint(pt.x, pt.y), net=net)
     return pt.node
Example #17
0
    def __init__(self, response_list, nerrs_stations=None):
        assert isinstance(response_list, dict)

        if nerrs_stations is None:
            from pyoos.collectors.nerrs.nerrs_soap import NerrsSoap
            nerrs_stations = NerrsSoap().stations

        def get_station(feature):
            for s in nerrs_stations:
                if s['Station_Code'].lower() == feature.lower():
                    return s

        skip_tags = ["DateTimeStamp", "utcStamp", "data", "MaxWSpdT"]

        stations = []
        for feature, response in response_list.iteritems():
            if not isinstance(response, etree._Element):
                response = etree.fromstring(response)

            feature = get_station(feature)

            s = Station()
            s.uid = feature['Station_Code']
            s.name = feature['Station_Name']
            s.location = sPoint(float(feature['Longitude']),
                                float(feature['Latitude']), 0)
            s.set_property("state", feature['State'])
            s.set_property("siteid", feature['NERR_Site_ID'])
            s.set_property("horizontal_crs", "EPSG:4326")
            s.set_property("vertical_units", "m")
            s.set_property("vertical_crs", "EPSG:4297")
            s.set_property("location_description", feature['Reserve_Name'])

            for data in response.findall(".//data"):
                p = Point()
                t = AsaTime.parse(testXMLValue(data.find("utcStamp")))
                t = t.replace(tzinfo=pytz.utc)
                p.time = t
                p.location = s.location
                for child in data:
                    if child.tag not in skip_tags:
                        try:
                            val = float(child.text)
                            p.add_member(
                                Member(value=val,
                                       unit=units(child.tag),
                                       name=child.tag,
                                       description=child.tag,
                                       standard=standard(child.tag)))
                        except TypeError:
                            # Value was None
                            pass

                s.add_element(p)

            stations.append(s)

        self.feature = StationCollection(elements=stations)
Example #18
0
    def test_station(self):
        dt1 = datetime(2012, 1, 1, 12, 0)
        p1 = Point()
        p1.time = dt1
        member1 = Member(value=34.7, unit='°C', name='Water Temperature', description='water temperature', standard='sea_water_temperature')
        member2 = Member(value=80, unit='PSU', name='Salinity', description='salinity', standard='salinity')
        p1.add_member(member1)
        p1.add_member(member2)

        dt2 = datetime(2012, 1, 1, 12, 10)
        p2 = Point()
        p2.time = dt2
        member3 = Member(value=34.1, unit='°C', name='Water Temperature', description='water temperature', standard='sea_water_temperature')
        member4 = Member(value=70, unit='PSU', name='Salinity', description='salinity', standard='salinity')
        p2.add_member(member3)
        p2.add_member(member4)

        dt3 = datetime(2012, 1, 1, 12, 20)
        p3 = Point()
        p3.time = dt3
        member5 = Member(value=32.6, unit='°C', name='Water Temperature', description='water temperature', standard='sea_water_temperature')
        member6 = Member(value=60, unit='PSU', name='Salinity', description='salinity', standard='salinity')
        member6 = Member(value=112, unit='%', name='DO', description='do', standard='do')
        p3.add_member(member5)
        p3.add_member(member6)

        pc = Station(elements=[p1,p2,p3])
        pc.name = "Super Station"
        pc.location = sPoint(-120, 50, 0)
        pc.location_name = "Just south of the super pier"
        pc.uid = "123097SDFJL2"
        pc.set_property("authority", "IOOS")
        pc.calculate_bounds()

        assert pc.size == 3
        assert len(pc.time_range) == 3
        assert pc.time_range[0] == dt1
        assert pc.time_range[-1] == dt3
        assert len(pc.depth_range) == 3
        assert pc.depth_range[0] == p1.location.z
        assert pc.upper_right().equals(pc.location)
        assert pc.lower_left().equals(pc.location)

        assert pc.get_property("authority") == "IOOS"
        assert pc.uid == "123097SDFJL2"
        assert pc.location_name == "Just south of the super pier"

        assert len(pc.get_unique_members()) == 3

        filtered_elements = pc.filter_by_time(starting=dt1, ending=dt2)
        assert len(list(filtered_elements)) == 2

        filtered_variables = pc.filter_by_variable("sea_water_temperature")
        assert len(list(filtered_variables)) == 3

        filtered_variables = pc.filter_by_variable("do")
        assert len(list(filtered_variables)) == 1
Example #19
0
    def test_station(self):
        dt1 = datetime(2012, 1, 1, 12, 0)
        p1 = Point()
        p1.time = dt1
        member1 = Member(value=34.7, unit='°C', name='Water Temperature', description='water temperature', standard='sea_water_temperature')
        member2 = Member(value=80, unit='PSU', name='Salinity', description='salinity', standard='salinity')
        p1.add_member(member1)
        p1.add_member(member2)

        dt2 = datetime(2012, 1, 1, 12, 10)
        p2 = Point()
        p2.time = dt2
        member3 = Member(value=34.1, unit='°C', name='Water Temperature', description='water temperature', standard='sea_water_temperature')
        member4 = Member(value=70, unit='PSU', name='Salinity', description='salinity', standard='salinity')
        p2.add_member(member3)
        p2.add_member(member4)

        dt3 = datetime(2012, 1, 1, 12, 20)
        p3 = Point()
        p3.time = dt3
        member5 = Member(value=32.6, unit='°C', name='Water Temperature', description='water temperature', standard='sea_water_temperature')
        member6 = Member(value=60, unit='PSU', name='Salinity', description='salinity', standard='salinity')
        member6 = Member(value=112, unit='%', name='DO', description='do', standard='do')
        p3.add_member(member5)
        p3.add_member(member6)

        pc = Station(elements=[p1,p2,p3])
        pc.name = "Super Station"
        pc.location = sPoint(-120, 50, 0)
        pc.location_name = "Just south of the super pier"
        pc.uid = "123097SDFJL2"
        pc.set_property("authority", "IOOS")
        pc.calculate_bounds()

        assert pc.size == 3
        assert len(pc.time_range) == 3
        assert pc.time_range[0] == dt1
        assert pc.time_range[-1] == dt3
        assert len(pc.depth_range) == 3
        assert pc.depth_range[0] == p1.location.z
        assert pc.upper_right().equals(pc.location)
        assert pc.lower_left().equals(pc.location)

        assert pc.get_property("authority") == "IOOS"
        assert pc.uid == "123097SDFJL2"
        assert pc.location_name == "Just south of the super pier"

        assert len(pc.get_unique_members()) == 3

        filtered_elements = pc.filter_by_time(starting=dt1, ending=dt2)
        assert len(list(filtered_elements)) == 2

        filtered_variables = pc.filter_by_variable("sea_water_temperature")
        assert len(list(filtered_variables)) == 3

        filtered_variables = pc.filter_by_variable("do")
        assert len(list(filtered_variables)) == 1
Example #20
0
    def test_profile(self):
        dt1 = datetime(2012, 1, 1, 12, 0)
        p1 = Point()
        p1.time = dt1
        p1.location = sPoint(-120, 50, 0)
        member1 = Member(value=34.7, unit='°C', name='Water Temperatire', description='water temperature', standard='sea_water_temperature')
        member2 = Member(value=80, unit='PSU', name='Salinity', description='salinity', standard='salinity')
        p1.add_member(member1)
        p1.add_member(member2)

        dt2 = datetime(2012, 1, 1, 12, 10)
        p2 = Point()
        p2.time = dt2
        p2.location = sPoint(-120, 50, 10)
        member3 = Member(value=34.1, unit='°C', name='Water Temperatire', description='water temperature', standard='sea_water_temperature')
        member4 = Member(value=70, unit='PSU', name='Salinity', description='salinity', standard='salinity')
        p2.add_member(member3)
        p2.add_member(member4)

        dt3 = datetime(2012, 1, 1, 12, 20)
        p3 = Point()
        p3.time = dt3
        p3.location = sPoint(-120, 50, 20)
        member5 = Member(value=32.6, unit='°C', name='Water Temperatire', description='water temperature', standard='sea_water_temperature')
        member6 = Member(value=60, unit='PSU', name='Salinity', description='salinity', standard='salinity')
        p3.add_member(member5)
        p3.add_member(member6)

        pc = Profile(elements=[p1,p2,p3])
        pc.location = sPoint(-120, 50)
        pc.time = dt1
        pc.calculate_bounds()

        assert pc.size == 3
        assert pc.time == dt1
        assert len(pc.time_range) == 3
        assert pc.time_range[0] == dt1
        assert pc.time_range[-1] == dt3
        assert len(pc.depth_range) == 3
        assert pc.depth_range[0] == p1.location.z
        assert pc.depth_range[-1] == p3.location.z
        assert pc.upper_right().equals(pc.location)
        assert pc.lower_left().equals(pc.location)
    def test_station_profile(self):

        sp = StationProfile()
        sp.name = "Profile Station"
        sp.location = sPoint(-77, 33)
        sp.uid = "1234"
        sp.set_property("authority", "IOOS")

        # add a sequence of profiles
        for y in xrange(3):
            dt1 = datetime(2013, 1, 1, 12, 0, 10 * y)
            prof1          = Profile()
            prof1.location = sPoint(-77, 33)
            prof1.time     = dt1

            # add a string of points going down in z
            for x in xrange(5):
                p1 = Point()
                p1.time = dt1
                p1.location = sPoint(-77, 33, -5 * x)

                member1 = Member(value=30 - (2 * x), units='°C', name='Water Temperature', description='water temperature', standard='sea_water_temperature')
                member2 = Member(value=80 + (2 * x), units='PSU', name='Salinity', description='salinity', standard='salinity')
                p1.add_member(member1)
                p1.add_member(member2)

                prof1.add_element(p1)

            sp.add_element(prof1)

        sp.calculate_bounds()

        assert sp.size == 3
        assert len(sp.time_range) == 3

        assert sp.depth_range[0] == -20
        assert sp.depth_range[-1] == 0

        assert sp.get_property("authority") == "IOOS"
        assert sp.uid == "1234"

        assert len(sp.get_unique_members()) == 2
Example #22
0
    def test_point(self):
        dt = datetime.utcnow()
        p = Point()
        p.location = sPoint(-123.17, 48.33, 10)
        p.time = dt

        assert p.location.x == -123.17
        assert p.location.y == 48.33
        assert p.location.z == 10
        assert p.time == dt
        assert p.type == "Point"
Example #23
0
    def test_point(self):
        dt = datetime.utcnow()
        p = Point()
        p.location = sPoint(-123.17, 48.33, 10)
        p.time = dt

        assert p.location.x == -123.17
        assert p.location.y == 48.33
        assert p.location.z == 10
        assert p.time == dt
        assert p.type == "Point"
Example #24
0
    def __init__(self, response_list, nerrs_stations=None):
        assert isinstance(response_list, dict)

        if nerrs_stations is None:
            from pyoos.collectors.nerrs.nerrs_soap import NerrsSoap
            nerrs_stations = NerrsSoap().stations

        def get_station(feature):
            for s in nerrs_stations:
                if s['Station_Code'].lower() == feature.lower():
                    return s

        skip_tags = ["DateTimeStamp", "utcStamp", "data", "MaxWSpdT"]

        stations = []
        for feature, response in response_list.items():
            if not isinstance(response, etree._Element):
                response = etree.fromstring(response)

            feature = get_station(feature)

            s = Station()
            s.uid = feature['Station_Code']
            s.name = feature['Station_Name']
            s.location = sPoint(feature['Longitude'], feature['Latitude'], 0)
            s.set_property("state", feature['State'])
            s.set_property("siteid", feature['NERR_Site_ID'])
            s.set_property("horizontal_crs", "EPSG:4326")
            s.set_property("vertical_units", "m")
            s.set_property("vertical_crs", "EPSG:4297")
            s.set_property("location_description", feature['Reserve_Name'])

            for data in response.findall(".//data"):
                p = Point()
                t = AsaTime.parse(testXMLValue(data.find("utcStamp")))
                t = t.replace(tzinfo=pytz.utc)
                p.time = t
                p.location = s.location
                for child in data:
                    if child.tag not in skip_tags:
                        try:
                            val = float(child.text)
                            p.add_member(Member(value=val, name=child.tag, description=child.tag,
                                                unit=units(child.tag), standard=standard(child.tag)))
                        except TypeError:
                            # Value was None
                            pass

                s.add_element(p)

            stations.append(s)

        self.feature = StationCollection(elements=stations)
    def test_trajectory_collection(self):

        t_collection = TrajectoryCollection()

        # 20 trajectories
        for x in xrange(0,20):

            tr = Trajectory()

            month = random.randint(1,12)
            dt = datetime(2012, month, 1, 0)

            # Starting point
            lat = random.randint(40,44)
            lon = random.randint(-74,-70)
            depth = 0

            # 100 points in each trajectory
            for l in xrange(0,100):

                lat += random.uniform(-0.25,0.25)
                lon += random.uniform(-0.25,0.25)
                depth += random.randint(-4,4)
                if depth < 0:
                    depth = 0

                p1 = Point()
                p1.location = sPoint(lon,lat,depth)
                dt += timedelta(hours=1)
                p1.time = dt
                member1 = Member(value=random.uniform(30,40), unit='°C', name='Water Temperature', description='water temperature', standard='sea_water_temperature')
                member2 = Member(value=random.uniform(80,100), unit='PSU', name='Salinity', description='salinity', standard='salinity')
                p1.add_member(member1)
                p1.add_member(member2)

                tr.add_element(p1)
        
            t_collection.add_element(tr)

        t_collection.calculate_bounds()

        assert len(t_collection.time_range) == 2000
        assert len(t_collection.depth_range) == 2000

        for trajectory in t_collection:
            assert trajectory.type == "Trajectory"
            for point in trajectory:
                assert point.type == "Point"

        for point in t_collection.flatten():
            assert point.type == "Point"
    def _build_obs_point(self, sensor_info, obs_recs):
        """
        Pulls bin/profile height info out and calcs a z.

        TODO: currently extremely naive

        Returns a 2-tuple: point, remaining obs_recs
        """
        cur_point = sensor_info['location']['point']

        keys = [m['name'] for m in obs_recs]
        if 'binIndex' in keys:
            zidx      = keys.index('binIndex')
            bin_index = int(obs_recs[zidx]['value'])
            z         = sensor_info['profile_heights']['values'][bin_index]

            point     = sPoint(cur_point.x, cur_point.y, cur_point.z + z)

        elif 'profileIndex' in keys:
            zidx      = keys.index('profileIndex')
            bin_index = int(obs_recs[zidx]['value'])

            # @TODO take into account orientation, may change x/y/z
            # @TODO bin edges?
            z         = sensor_info['profile_bins']['bin_center']['values'][bin_index]

            point     = sPoint(cur_point.x, cur_point.y, cur_point.z + z)

        else:
            raise ValueError("no binIndex or profileIndex in Member: %s", keys)

        # remove z related Member
        obs_recs = obs_recs[:]
        obs_recs.pop(zidx)

        return point, obs_recs
 def _get_point(self, profile, point):
     """
     Finds the given point in the profile, or adds it in sorted z order.
     """
     cur_points_z = [p.location.z for p in profile.elements]
     try:
         cur_idx = cur_points_z.index(point.z)
         return profile.elements[cur_idx]
     except ValueError:
         new_idx            = bisect_left(cur_points_z, point.z)
         new_point          = Point()
         new_point.location = sPoint(point)
         new_point.time     = profile.time
         profile.elements.insert(new_idx, new_point)
         return new_point
Example #28
0
    def __init__(self, wqx_metadata, wqx_data):
        if not isinstance(wqx_metadata, WqxOutbound):
            wqx_metadata = WqxOutbound(wqx_metadata)

        if not isinstance(wqx_data, WqxOutbound):
            wqx_data = WqxOutbound(wqx_data)

        if wqx_data.failed or wqx_metadata.failed:
            self.feature = None
        else:
            s = Station()
            s.uid = wqx_metadata.location.id
            s.name = wqx_metadata.location.name
            s.set_property("station_type", wqx_metadata.location.type)
            s.set_property("location_description", wqx_metadata.location.description)
            s.set_property("huc", wqx_metadata.location.huc)
            s.set_property("county", wqx_metadata.location.county)
            s.set_property("state", wqx_metadata.location.state)
            s.set_property("country", wqx_metadata.location.country)
            s.set_property("organization_id", wqx_metadata.organization.id)
            s.set_property("organization_name", wqx_metadata.organization.name)
            s.set_property("vertical_units", wqx_metadata.location.vertical_measure_units)
            s.set_property("horizontal_crs", wqx_metadata.location.horizontal_crs_name)
            s.set_property("vertical_crs", wqx_metadata.location.vertical_crs_name)

            for a in wqx_data.activities:
                p = Point()
                p.time = a.start_time

                for r in a.results:
                    p.add_member(Member(value=r.value, unit=r.units, name=r.name, description=r.short_name, standard=None, quality=r.quality, method_id=a.method_id, method_name=a.method_name))

                s.add_element(p)

            # Now set the station's location
            vertical = 0
            try:
                vertical = float(wqx_metadata.location.vertical_measure_value)
            except:
                pass

            # convert the vertical to meters if it is ft (which it always is)
            if wqx_metadata.location.vertical_measure_units == "ft":
                vertical /= 3.28084
                s.set_property("vertical_units", "m")
            s.location = sPoint(float(wqx_metadata.location.longitude), float(wqx_metadata.location.latitude), vertical)

            self.feature = s
    def _get_profile(self, sensor, t):
        sens_loc_tuple = (sensor['location']['point'].x, sensor['location']['point'].y, sensor['station'])
        profile_od     = self._cache[sens_loc_tuple]

        if t not in profile_od:
            profile          = Profile()
            profile.location = sPoint(*sens_loc_tuple[0:2])
            profile.time     = t

            # @TODO this is a hack until we can figure out how to assoc stations properly
            profile.station  = sensor['station']

            profile_od[t]    = profile
            return profile

        return profile_od[t]
	def _paths_to_cost(self):
		
		print "Analyzing paths..."
		count = 0
		for path in self.paths:
			count += 1
			print "\t%d of %d" % (count, len(self.paths))
			distances = np.empty((self.height, self.width))
			distances.fill(np.inf)

			min_x, min_y, max_x, max_y = path.bounds
			faraway = 5
			min_x -= faraway; min_y -= faraway
			max_x += faraway; max_y += faraway
			print "\t\tPath bounding  box area: %fm by %fm" % ( abs(max_x - min_x), abs(max_y - min_y) )
			for x in np.arange(min_x, max_x, self.resolution):
				for y in np.arange(min_y, max_y, self.resolution):
					i, j = self._world_to_map(x, y)
					pt = sPoint(x, y)
					distances[i, j] = path.distance(pt)

			self.cost_grid += np.exp(-(distances ** 2))
Example #31
0
def groupNearbyCrossRoads(crossRoads, radius):
    """ 
    crossRoads as a geojson feature collection
    using UTM coords for metric distance 
    and also setting the edgeCount for every CrossRoad
    """

    shapelyPoints = []
    graph = nx.Graph()

    for location, newProperties in crossRoads.items():
        point = sPoint(wgsToUtm(*location))
        point.id = location
        graph.add_node(location)
        shapelyPoints.append(point)
    
    index = STRtree(shapelyPoints)

    for point in shapelyPoints:
        searchArea = point.buffer(radius)
        crossRoadPoints = [p for p in index.query(searchArea) if not p == point] 
        for otherPoint in crossRoadPoints:
            graph.add_edge(otherPoint.id, point.id)

    result = crossRoads.copy()

    components = [component for component in nx.connected_components(graph) if not len(component) == 1]
    for crossRoadLocations in components:
        nearbyCrossRoads = {loc: result.pop(loc) for loc in crossRoadLocations}

        center = tuple(sMultiPoint(list(crossRoadLocations)).centroid.coords[0])
        newProperties = CrossRoadProperties()

        for oldProp in nearbyCrossRoads.values():
            newProperties.union(oldProp)
        newProperties.computeEdgeCount()
        result[center] = newProperties
    return crossRoadsToFeatures(result)
Example #32
0
    def __init__(self, element):

        record = DataRecord(element)

        # Top level org structure
        stations_field = record.get_by_name("stations")
        stations = {}
        sensors = {}
        for station in stations_field.content.field:
            s = Station()
            s.name  = station.name
            s.uid   = station.content.get_by_name("stationID").content.value

            # Location
            vector  = station.content.get_by_name("platformLocation").content
            srss = vector.referenceFrame.split("&amp;")
            hsrs = None
            try:
                hsrs = Crs(srss[0])
            except ValueError:
                pass

            vsrs = None
            try:
                vsrs = Crs(srss[-1].replace("2=http:", "http:"))
            except ValueError:
                pass

            s.set_property("horizontal_srs", hsrs)
            s.set_property("vertical_srs",   vsrs)
            s.set_property("localFrame",     vector.localFrame)

            lat = vector.get_by_name("latitude").content.value
            lon = vector.get_by_name("longitude").content.value
            z   = vector.get_by_name("height").content.value

            loc = [lon, lat]
            if z:
                loc.append(z)

            s.location = sPoint(*loc)

            # Sensors
            for sensor in station.content.get_by_name("sensors").content.field:
                name        = sensor.name
                uri         = sensor.content.get_by_name("sensorID").content.value
                height      = None
                location_quantity = sensor.content.get_by_name("height").content
                if location_quantity.referenceFrame == "#%s_frame" % s.name:
                    # Uses the station as reference frame
                    if location_quantity.value and z:
                        height      = z + location_quantity.value
                    horizontal_srs  = s.get_property("horizontal_srs")
                    vertical_srs    = s.get_property("vertical_srs")
                else:
                    # Uses its own height
                    if location_quantity.value:
                        height      = location_quantity.value
                    horizontal_srs  = None
                    vertical_srs    = None
                    if hasattr(sensor, 'referenceFrame'):
                        srss            = sensor.referenceFrame.split("&amp;")
                        try:
                            horizontal_srs = Crs(srss[0])
                        except ValueError:
                            pass
                        try:
                            vertical_srs = Crs(srss[-1].replace("2=http:", "http:"))
                        except ValueError:
                            pass

                loc = [s.location.x, s.location.y]
                if height:
                    loc.append(height)

                location            = sPoint(*loc)

                sensors[name] = {   'station'           : s.uid,
                                    'name'              : name,
                                    'uri'               : uri,
                                    'horizontal_srs'    : horizontal_srs,
                                    'vertical_srs'      : vertical_srs,
                                    'location'          : location,
                                    'columns'           : [], # Array of Members representing the columns
                                    'values'            : []  # Array of Points (the actual data)
                                }

            stations[s.uid] = s


        # Start building the column structure
        data_array = record.get_by_name("observationData").content
        data_record = data_array.elementType.content

        columns = []
        # Data outside of the <field name="sensors"> DataChoice element
        for f in data_record.field:
            columns.append(f)

        # Data inside of DataChoice
        sensor_data = data_record.get_by_name("sensor")
        for sendata in sensor_data.content.item:
            if sendata.content is not None:
                sensors[sendata.name]['columns'] = []
                sensors[sendata.name]['values'] = []
                for f in sendata.content.field:
                    # Create a model Member for each column that will be copied and filled with data from each row
                    sensors[sendata.name]['columns'].append(f)

        decimalSeparator    = data_array.encoding.decimalSeparator
        tokenSeparator      = data_array.encoding.tokenSeparator
        blockSeparator      = data_array.encoding.blockSeparator
        collapseWhiteSpaces = data_array.encoding.collapseWhiteSpaces

        data_values = data_array.values
        self.raw_data = copy(data_values)

        for row in filter(lambda x: x != "", data_values.split(blockSeparator)):

            pt = None
            members     = []
            values      = row.split(tokenSeparator)
            sensor_key  = None
            i           = 0

            for x in columns:

                if isinstance(x.content, Time) and x.content.definition == "http://www.opengis.net/def/property/OGC/0/SamplingTime":
                    pt      = Point()
                    pt.time = parser.parse(values[i])

                elif isinstance(x.content, DataChoice):
                    sensor_key = values[i]
                    dc_cols = sensors[sensor_key]['columns']

                    for j,c in enumerate(dc_cols):
                        if isinstance(c.content, AbstractSimpleComponent):
                            m = Member( units=c.content.uom,
                                        name=c.name,
                                        standard=c.content.definition,
                                        value=float(values[i+1]))
                            members.append(m)

                        elif isinstance(c.content, Time) and c.content.definition == "http://www.opengis.net/def/property/OGC/0/SamplingTime":
                            pt      = Point()
                            pt.time = parser.parse(v)

                        # For each data column
                        i += 1
                
                elif isinstance(x.content, AbstractSimpleComponent):
                    m = Member( units=x.content.uom,
                                name=x.name,
                                standard=x.content.definition,
                                value=float(values[i]))
                    members.append(m)

                else:
                    print "WHAT AM I"

                i += 1

            pt.members = members
            pt.location = stations[sensors[sensor_key]['station']].location
            sensors[sensor_key]['values'].append(pt)

        for k,v in stations.iteritems():
            for sk, sv in sensors.iteritems():
                # Match on station uid
                if sv['station'] == k:
                    v.elements = self._merge_points(v.elements or [], sv['values'])

        if len(stations) > 1:
            self.feature = StationCollection(elements=stations)
        elif len(stations) == 1:
            self.feature = next(stations.itervalues())
        else:
            print "No stations found!"
Example #33
0
    def _build_station_collection(self, parsed_metadata, parsed_data):

        stations = []
        for station_code, station_metadata in parsed_metadata.iteritems():
            s = Station()
            s.uid = station_code
            s.name = station_metadata['nwsli']
            s.location = sPoint(station_metadata['longitude'],
                                station_metadata['latitude'],
                                0)  # hads always vertically zero

            s.set_property("location_description" , station_metadata['location_text'])
            s.set_property("state"                , station_metadata['state'])
            s.set_property("country"              , "USA")   # @TODO
            s.set_property("vertical_units"       , "ft")
            s.set_property("horizontal_crs"       , "EPSG:4326")
            s.set_property("vertical_crs"         , None)
            s.set_property("hsa"                  , station_metadata['hsa'])
            s.set_property("init_transmit"        , station_metadata['init_transmit'])
            s.set_property("manufacturer"         , station_metadata['manufacturer'])
            s.set_property("owner"                , station_metadata['owner'])
            s.set_property("channel"              , station_metadata['channel'])

            stations.append(s)

            # data

            # possibility no data for this station, or vars filtered all out
            if station_code not in parsed_data:
                continue

            # need to group into distinct time/z value pairs

            # create a keyfunc (creates string of <z>-<timestamp>)
            zandtime = lambda x: str(x[3]) + "-" + str(time.mktime(x[1].timetuple()))

            # annotate data with z values, sort, group by keyfunc (z/time)
            grouped_data = groupby(sorted(map(lambda x: (x[0],
                                                         x[1],
                                                         x[2],
                                                         parsed_metadata[station_code]['variables'][x[0]]['base_elevation']),
                                              parsed_data[station_code]),
                                          key=zandtime),
                                   zandtime)

            for _, group in grouped_data:

                # group is an iterator, turn it into a list (it will have at least one item)
                groupvals = list(group)

                p = Point()
                p.time = groupvals[0][1]
                p.location = sPoint(station_metadata['longitude'],
                                    station_metadata['latitude'],
                                    groupvals[0][3])

                for val in groupvals:
                    std_var = self.get_variable_info(val[0])
                    if std_var is None:
                        print "Unknown PE Code, ignoring:", val[0], "(station:", station_code, ")"
                        continue

                    p.add_member(Member(value=val[2],
                                        standard=std_var[0],
                                        unit=std_var[1],
                                        name=std_var[2],
                                        description=std_var[3]))

                s.add_element(p)

        return StationCollection(elements=stations)
Example #34
0
    def __init__(self, waterml_data):
        
        if isinstance(waterml_data, str) or isinstance(waterml_data, unicode):
            try:
                self._root = etree.fromstring(str(waterml_data))
            except ValueError:
                # Strip out the XML header due to UTF8 encoding declaration
                self._root = etree.fromstring(waterml_data[56:])
        else:
            self._root = waterml_data

        response = WaterML_1_1(self._root).response

        stations = []
        station_lookup = []

        for timeseries in response.time_series:
            station_code = sorted(timeseries.source_info.site_codes)[0]
            # Create station if we have not seen it
            if station_code not in station_lookup:
                s = Station()
                s.uid = station_code

                info = timeseries.source_info
                s.name = info.site_name
                s.set_property("station_type", info.site_types)
                s.set_property("huc", info.site_properties.get("hucCd"))
                s.set_property("county", info.site_properties.get("countyCd"))
                s.set_property("state", info.site_properties.get("stateCd"))

                # Now set the station's location
                vertical = info.elevation
                if vertical is None:
                    vertical = 0

                try:
                    location = info.location.geo_coords[0]
                    srs = info.location.srs[0]
                except:
                    print "Could not find a location for %s... skipping station" % s.uid
                    continue

                s.location = sPoint(float(location[0]), float(location[1]), vertical)
                s.set_property("horizontal_crs", srs)
                s.set_property("vertical_units", "m")
                s.set_property("vertical_crs", info.vertical_datum)
                s.set_property("location_description", info.location.notes)

                stations.append(s)
                station_lookup.append(s.uid)


            times = {}
            variable = timeseries.variable
            for variable_timeseries in timeseries.values:
                for r in variable_timeseries:
                    dt = r.date_time
                    if dt.tzinfo is None:
                        dt = dt.replace(tzinfo=pytz.utc)
                    dt = dt.astimezone(pytz.utc)
                    
                    if dt not in times.keys():
                        times[dt] = []

                    times[dt].append(Member(value=r.value, unit=variable.unit.code, name=variable.variable_name, description=variable.variable_description, standard=variable.variable_code))

            station = stations[station_lookup.index(station_code)]
            for dts,members in times.iteritems():
                p = Point()
                p.time = dts
                p.location = station.location
                p.members = members
                station.add_element(p)
        
        self.feature = StationCollection(elements=stations)
Example #35
0
def draw_scatter(
    ds: DiagramSettings,
    canvas: svgwrite.drawing.Drawing,
    plot: ScatterPlot,
    xmapping: IntervalMapping,
) -> svgwrite.container.Group:
    """
    given a xmapping, draw the scatter plot svg group

    Args:
        ds: the settings/constants to use for building the svg
        canvas: the svgwrite object used to create new svg elements
        plot: the plot to be drawn
        xmapping: dict used for conversion of coordinates in the xaxis to pixel positions
    """
    from shapely.geometry import Point as sPoint

    # generate the y coordinate mapping
    plot_group = canvas.g(class_='scatter_plot')

    yratio = plot.height / (abs(plot.ymax - plot.ymin))
    px_points = []
    circles = []
    for x_pos, y_pos in plot.points:
        try:
            x_px = Interval.convert_ratioed_pos(xmapping,
                                                x_pos,
                                                forward_to_reverse=False)
            y_px = Interval(plot.height -
                            abs(min(y_pos, plot.ymax) - plot.ymin) * yratio)
            current_circle = sPoint(x_px.center, y_px.center).buffer(
                ds.scatter_marker_radius)
            if circles:
                ratio = circles[-1].intersection(
                    current_circle).area / current_circle.area
                if ratio > plot.density:
                    continue
            circles.append(current_circle)
            px_points.append((
                x_px,
                y_px,
                plot.ymax_color if y_pos > plot.ymax else plot.colors.get(
                    (x_pos, y_pos), '#000000'),
            ))
        except IndexError:
            pass
    logger.info(
        f'drew {len(circles)} of {len(plot.points)} points (density={plot.density})'
    )

    for x_px, y_px, color in px_points:
        if x_px.length() > ds.scatter_marker_radius:
            plot_group.add(
                canvas.line(
                    (x_px.start, y_px.center),
                    (x_px.end, y_px.center),
                    stroke='#000000',
                    stroke_width=ds.scatter_error_bar_stroke_width,
                ))
        if y_px.length() > ds.scatter_marker_radius:
            plot_group.add(
                canvas.line(
                    (x_px.center, y_px.start),
                    (x_px.center, y_px.end),
                    stroke='#000000',
                    stroke_width=ds.scatter_error_bar_stroke_width,
                ))
        plot_group.add(
            canvas.circle(center=(x_px.center, y_px.center),
                          fill=color,
                          r=ds.scatter_marker_radius))

    xmax = Interval.convert_ratioed_pos(xmapping,
                                        plot.xmax,
                                        forward_to_reverse=False).end
    for py in plot.hmarkers:
        py = plot.height - abs(py - plot.ymin) * yratio
        plot_group.add(
            canvas.line(start=(0, py), end=(xmax, py), stroke='blue'))
    # draw left y axis
    plot_group.add(
        canvas.line(start=(0, 0), end=(0, plot.height), stroke='#000000'))
    ytick_labels = [0]
    # draw start and end markers on the y axis
    for y in plot.yticks:
        ytick_labels.append(len(str(y)))
        py = plot.height - abs(y - plot.ymin) * yratio
        plot_group.add(
            canvas.line(start=(0 - ds.scatter_yaxis_tick_size, py),
                        end=(0, py),
                        stroke='#000000'))
        plot_group.add(
            canvas.text(
                str(y),
                insert=(
                    0 - ds.scatter_yaxis_tick_size - ds.padding,
                    py +
                    ds.scatter_ytick_font_size * ds.font_central_shift_ratio,
                ),
                fill=ds.label_color,
                style=ds.font_style.format(
                    font_size=ds.scatter_ytick_font_size, text_anchor='end'),
            ))

    shift = max(ytick_labels)
    x = (0 - ds.padding * 2 - ds.scatter_axis_font_size -
         ds.scatter_yaxis_tick_size -
         ds.scatter_ytick_font_size * ds.font_width_height_ratio * shift)
    y = plot.height / 2
    yaxis = canvas.text(
        plot.y_axis_label,
        insert=(x, y),
        fill=ds.label_color,
        style=ds.font_style.format(font_size=ds.scatter_axis_font_size,
                                   text_anchor='start'),
        class_='y_axis_label',
    )
    plot_group.add(yaxis)
    cx = len(plot.y_axis_label
             ) * ds.font_width_height_ratio * ds.scatter_axis_font_size / 2
    yaxis.rotate(270, (x + cx, y))
    yaxis.translate(0, 0)

    y = plot.height
    setattr(plot_group, 'height', y)
    return plot_group
Example #36
0
angle_sum = Dec(0)
for v in vertices:
    angle_sum += v.ang
theoretical_angle_sum = Dec(int((len(vertices)-2)*180))

# 9-kampio krastine D1
D1 = Dec('174.667') + C
# Daugiakampio pasukimo kampas (K1)
K1 = Dec('13.147') + B
# Atstumas iki tikrosios uzliejimo zonos (A1) (0.001 tikslumu)
A1 = Dec('67.536') + B

circle_radius = float(D1)/2/sin(pi/7)-float(A1)
heptagon_area = heptagon(float(D1)).area
circle_area = sPoint(0,0).buffer(circle_radius).area

# Points is vertice map by id
Points = {}
for v in vertices:
    Points[v.point] = v

CONTINUOUS = (1,0)
DASHDOTX2 = (10,3,2,3)
DASHED = (100,20)

keliai = {
    'A-08': kelias(
        virsunes=[1,2,3],
        plotis=A08_plotis,
        kat=KAT1,
    def __init__(self, element):
        record = DataRecord(element)

        stations_field = record.get_by_name("stations")

        stations = {}
        sensors = {}

        for station in stations_field.content.field:
            s      = StationProfile()
            s.name = station.name
            s.uid  = station.content.get_by_name("stationID").content.value

            # Location
            vector  = station.content.get_by_name("platformLocation").content
            srss = vector.referenceFrame.split("&amp;")
            hsrs = None
            try:
                hsrs = Crs(srss[0])
            except ValueError:
                pass

            vsrs = None
            try:
                vsrs = Crs(srss[-1].replace("2=http:", "http:"))
            except ValueError:
                pass

            s.set_property("horizontal_srs", hsrs)
            s.set_property("vertical_srs",   vsrs)
            s.set_property("localFrame",     vector.localFrame)

            lat = vector.get_by_name("latitude").content.value
            lon = vector.get_by_name("longitude").content.value
            z   = vector.get_by_name("height").content.value

            loc = [lon, lat]
            if z:
                loc.append(z)

            s.location = sPoint(*loc)

            # sensors
            for sensor in station.content.get_by_name("sensors").content.field:
                name           = sensor.name
                uri            = sensor.content.get_by_name("sensorID").content.value

                sensors[name] = {'station'        : s.uid,
                                 'name'           : name,
                                 'uri'            : uri}
                # orientation
                ori_el = sensor.content.get_by_name("sensorOrientation")
                if ori_el:
                    orientation = self._parse_sensor_orientation(ori_el)
                    sensors[name]['sensor_orientation'] = orientation

                # location
                loc_el = sensor.content.get_by_name("sensorLocation")
                if loc_el:
                    location = self._parse_location(loc_el, s.location)
                    sensors[name]['location'] = location

                # profile bins
                profbins_el = sensor.content.get_by_name("profileBins")
                if profbins_el:
                    profile_bins = self._parse_profile_bins(profbins_el)
                    sensors[name]['profile_bins'] = profile_bins

                # OR profile heights
                profheights_el = sensor.content.get_by_name('profileHeights')
                if profheights_el:
                    profile_heights = self._parse_profile_heights(profheights_el)
                    sensors[name]['profile_heights'] = profile_heights

            s.sensors = sensors

            stations[s.uid] = s

        sensor_data = self._parse_sensor_data(record.get_by_name('observationData'), sensors)

        # sensor data is dict of station id -> profile collection
        for station_id, sensor_profile_data in sensor_data.iteritems():
            stations[station_id].elements.extend(sensor_profile_data._elements)

        if len(stations) > 1:
            self.feature = StationCollection(elements=stations)
        elif len(stations) == 1:
            self.feature = next(stations.itervalues())
        else:
            print "No stations found!"
            self.feature = None
Example #38
0
    def __init__(self, element):

        record = DataRecord(element)

        # Top level org structure
        stations_field = record.get_by_name("stations")
        stations = {}
        sensors = {}
        for station in stations_field.content.field:
            s = Station()
            s.name = station.name
            s.uid = station.content.get_by_name("stationID").content.value

            # Location
            vector = station.content.get_by_name("platformLocation").content
            srss = vector.referenceFrame.split("&amp;")
            hsrs = None
            try:
                hsrs = Crs(srss[0])
            except ValueError:
                pass

            vsrs = None
            try:
                vsrs = Crs(srss[-1].replace("2=http:", "http:"))
            except ValueError:
                pass

            s.set_property("horizontal_srs", hsrs)
            s.set_property("vertical_srs", vsrs)
            s.set_property("localFrame", vector.localFrame)

            lat = vector.get_by_name("latitude").content.value
            lon = vector.get_by_name("longitude").content.value
            z = vector.get_by_name("height").content.value

            loc = [lon, lat]
            if z:
                loc.append(z)

            s.location = sPoint(*loc)

            # Sensors
            for sensor in station.content.get_by_name("sensors").content.field:
                name = sensor.name
                uri = sensor.content.get_by_name("sensorID").content.value
                height = None
                location_quantity = sensor.content.get_by_name(
                    "height").content
                if location_quantity.referenceFrame == "#%s_frame" % s.name:
                    # Uses the station as reference frame
                    if location_quantity.value and z:
                        height = z + location_quantity.value
                    horizontal_srs = s.get_property("horizontal_srs")
                    vertical_srs = s.get_property("vertical_srs")
                else:
                    # Uses its own height
                    if location_quantity.value:
                        height = location_quantity.value
                    horizontal_srs = None
                    vertical_srs = None
                    if hasattr(sensor, 'referenceFrame'):
                        srss = sensor.referenceFrame.split("&amp;")
                        try:
                            horizontal_srs = Crs(srss[0])
                        except ValueError:
                            pass
                        try:
                            vertical_srs = Crs(srss[-1].replace(
                                "2=http:", "http:"))
                        except ValueError:
                            pass

                loc = [s.location.x, s.location.y]
                if height:
                    loc.append(height)

                location = sPoint(*loc)

                sensors[name] = {
                    'station': s.uid,
                    'name': name,
                    'uri': uri,
                    'horizontal_srs': horizontal_srs,
                    'vertical_srs': vertical_srs,
                    'location': location,
                    'columns': [],  # Array of Members representing the columns
                    'values': []  # Array of Points (the actual data)
                }

            stations[s.uid] = s

        # Start building the column structure
        data_array = record.get_by_name("observationData").content
        data_record = data_array.elementType.content

        columns = []
        # Data outside of the <field name="sensors"> DataChoice element
        for f in data_record.field:
            columns.append(f)

        # Data inside of DataChoice
        sensor_data = data_record.get_by_name("sensor")
        for sendata in sensor_data.content.item:
            if sendata.content is not None:
                sensors[sendata.name]['columns'] = []
                sensors[sendata.name]['values'] = []
                for f in sendata.content.field:
                    # Create a model Member for each column that will be copied and filled with data from each row
                    sensors[sendata.name]['columns'].append(f)

        decimalSeparator = data_array.encoding.decimalSeparator
        tokenSeparator = data_array.encoding.tokenSeparator
        blockSeparator = data_array.encoding.blockSeparator
        collapseWhiteSpaces = data_array.encoding.collapseWhiteSpaces

        data_values = data_array.values
        self.raw_data = copy(data_values)

        for row in filter(lambda x: x != "",
                          data_values.split(blockSeparator)):

            pt = None
            members = []
            values = row.split(tokenSeparator)
            sensor_key = None
            i = 0

            for x in columns:

                if isinstance(
                        x.content, Time
                ) and x.content.definition == "http://www.opengis.net/def/property/OGC/0/SamplingTime":
                    pt = Point()
                    pt.time = parser.parse(values[i])

                elif isinstance(x.content, DataChoice):
                    sensor_key = values[i]
                    dc_cols = sensors[sensor_key]['columns']

                    for j, c in enumerate(dc_cols):
                        if isinstance(c.content, AbstractSimpleComponent):
                            m = Member(units=c.content.uom,
                                       name=c.name,
                                       standard=c.content.definition,
                                       value=float(values[i + 1]))
                            members.append(m)

                        elif isinstance(
                                c.content, Time
                        ) and c.content.definition == "http://www.opengis.net/def/property/OGC/0/SamplingTime":
                            pt = Point()
                            pt.time = parser.parse(values[i])

                        # For each data column
                        i += 1

                elif isinstance(x.content, AbstractSimpleComponent):
                    m = Member(units=x.content.uom,
                               name=x.name,
                               standard=x.content.definition,
                               value=float(values[i]))
                    members.append(m)

                else:
                    print "WHAT AM I"

                i += 1

            pt.members = members
            pt.location = stations[sensors[sensor_key]['station']].location
            sensors[sensor_key]['values'].append(pt)

        for k, v in stations.iteritems():
            for sk, sv in sensors.iteritems():
                # Match on station uid
                if sv['station'] == k:
                    v.elements = self._merge_points(v.elements or [],
                                                    sv['values'])

        if len(stations) > 1:
            self.feature = StationCollection(elements=stations)
        elif len(stations) == 1:
            self.feature = next(stations.itervalues())
        else:
            print "No stations found!"
Example #39
0
    def __init__(self, waterml_data):

        if isinstance(waterml_data, str) or isinstance(waterml_data, unicode):
            try:
                self._root = etree.fromstring(str(waterml_data))
            except ValueError:
                # Strip out the XML header due to UTF8 encoding declaration
                self._root = etree.fromstring(waterml_data[56:])
        else:
            self._root = waterml_data

        response = WaterML_1_1(self._root).response

        stations = []
        station_lookup = []

        for timeseries in response.time_series:
            station_code = sorted(timeseries.source_info.site_codes)[0]
            # Create station if we have not seen it
            if station_code not in station_lookup:
                s = Station()
                s.uid = station_code

                info = timeseries.source_info
                s.name = info.site_name
                s.set_property("station_type", info.site_types)
                s.set_property("huc", info.site_properties.get("hucCd"))
                s.set_property("county", info.site_properties.get("countyCd"))
                s.set_property("state", info.site_properties.get("stateCd"))

                # Now set the station's location
                vertical = info.elevation
                if vertical is None:
                    vertical = 0

                try:
                    location = info.location.geo_coords[0]
                    srs = info.location.srs[0]
                except:
                    print "Could not find a location for %s... skipping station" % s.uid
                    continue

                s.location = sPoint(float(location[0]), float(location[1]),
                                    vertical)
                s.set_property("horizontal_crs", srs)
                s.set_property("vertical_units", "m")
                s.set_property("vertical_crs", info.vertical_datum)
                s.set_property("location_description", info.location.notes)

                stations.append(s)
                station_lookup.append(s.uid)

            times = {}
            variable = timeseries.variable
            for variable_timeseries in timeseries.values:
                for r in variable_timeseries:
                    dt = r.date_time
                    if dt.tzinfo is None:
                        dt = dt.replace(tzinfo=pytz.utc)
                    dt = dt.astimezone(pytz.utc)

                    if dt not in times.keys():
                        times[dt] = []

                    times[dt].append(
                        Member(value=r.value,
                               unit=variable.unit.code,
                               name=variable.variable_name,
                               description=variable.variable_description,
                               standard=variable.variable_code))

            station = stations[station_lookup.index(station_code)]
            for dts, members in times.iteritems():
                p = Point()
                p.time = dts
                p.location = station.location
                p.members = members
                station.add_element(p)

        self.feature = StationCollection(elements=stations)
Example #40
0
prev_dirang = float(K1) * pi / 180
step = 5 / 7 * pi
heptagon = [np.array(Points[6].xy)]
for i in range(1, 7):
    dxy = np.array(
        [float(D1) * cos(prev_dirang),
         float(D1) * sin(prev_dirang)])
    heptagon.append(heptagon[i - 1] + dxy)
    prev_dirang += pi - step
ax.add_patch(
    PolygonPatch(asPolygon(heptagon),
                 linewidth=2,
                 fc='xkcd:white',
                 ec='xkcd:magenta'))

# septynkampio centras
x0, y0 = Points[6].xy
x = x0 + float(D1) / (2 * sin(pi / 7)) * sin(pi / 7 - float(K1) * pi / 180)
y = y0 + float(D1) / (2 * sin(pi / 7)) * cos(pi / 7 - float(K1) * pi / 180)
center = sPoint(x, y)

# užlieta erdvė apskritimas
radius = float(D1) / 2 / sin(pi / 7) - float(A1)
angles = np.linspace(0, 2 * pi, num=360)
circle_y = y + np.sin(angles) * radius
circle_x = x + np.cos(angles) * radius
ax.plot(circle_x, circle_y)

if __name__ == '__main__':
    plt.show()
Example #41
0
    def __init__(self, **kwargs):
        super(SweTimeSeries, self).__init__(**kwargs)

        # Parse out GML point.  Defaults to 0 depth if none specified
        self.geo_srs = Crs(
            testXMLAttribute(self._location.find(nsp("Point", self.GML_NS)),
                             'srsName'))
        geo = [
            float(v) for v in testXMLValue(
                self._location.find(nsp("Point/pos", self.GML_NS))).split(" ")
        ]

        if self.geo_srs.axisorder == "yx":
            self.geo = sPoint(geo[1], geo[0])
        else:
            self.geo = sPoint(geo[0], geo[1])

        try:
            self.geo.z = geo[2]
        except:
            pass

        pc = PointCollection()

        for row in self.results.data:
            p = Point()

            time = None
            z = None
            lat = None
            lon = None

            for field in row:

                if field.axis == "time":
                    t = dateutil.parser.parse(field.value)
                    p.time = t.astimezone(dateutil.tz.tzutc())
                elif field.axis == "Long":
                    lon = field
                elif field.axis == "Lat":
                    lat = field
                elif field.axis == "h":
                    z = field
                else:
                    m = Member(value=field.value,
                               unit=field.units,
                               units_definition=field.units_url,
                               name=field.name,
                               definition=field.definition,
                               standard=field.definition)
                    p.add_member(m)

            # Set the spatial point
            if lon.srs != lat.srs:
                raise ValueError(
                    "Longitude and Latitude need to have the same SRS/CRS!")
            p.location = sPoint(float(lon.value), float(lat.value),
                                float(z.value))
            pc.add_element(p)

        self.data = pc
Example #42
0
    def _build_station_collection(self, parsed_metadata, parsed_data):

        stations = []
        for station_code, station_metadata in parsed_metadata.items():
            s = Station()
            s.uid = station_code
            s.name = station_metadata['nwsli']
            s.location = sPoint(station_metadata['longitude'],
                                station_metadata['latitude'],
                                0)  # hads always vertically zero

            s.set_property("location_description",
                           station_metadata['location_text'])
            s.set_property("state", station_metadata['state'])
            s.set_property("country", "USA")  # @TODO
            s.set_property("vertical_units", "ft")
            s.set_property("horizontal_crs", "EPSG:4326")
            s.set_property("vertical_crs", None)
            s.set_property("hsa", station_metadata['hsa'])
            s.set_property("init_transmit", station_metadata['init_transmit'])
            s.set_property("manufacturer", station_metadata['manufacturer'])
            s.set_property("owner", station_metadata['owner'])
            s.set_property("channel", station_metadata['channel'])

            stations.append(s)

            # data

            # possibility no data for this station, or vars filtered all out
            if station_code not in parsed_data:
                continue

            # need to group into distinct time/z value pairs

            # create a keyfunc (creates string of <z>-<timestamp>)
            zandtime = lambda x: str(x[3]) + "-" + str(
                time.mktime(x[1].timetuple()))

            # annotate data with z values, sort, group by keyfunc (z/time)
            grouped_data = groupby(
                sorted([(x[0], x[1], x[2], parsed_metadata[station_code]
                         ['variables'][x[0]]['base_elevation'])
                        for x in parsed_data[station_code]],
                       key=zandtime), zandtime)

            for _, group in grouped_data:

                # group is an iterator, turn it into a list (it will have at least one item)
                groupvals = list(group)

                p = Point()
                p.time = groupvals[0][1]
                p.location = sPoint(station_metadata['longitude'],
                                    station_metadata['latitude'],
                                    groupvals[0][3])

                for val in groupvals:
                    std_var = self.get_variable_info(val[0])
                    if std_var is None:
                        print("Unknown PE Code, ignoring: {} (station: {}).".
                              format(val[0], station_code))
                        continue

                    p.add_member(
                        Member(value=val[2],
                               standard=std_var[0],
                               unit=std_var[1],
                               name=std_var[2],
                               description=std_var[3]))

                s.add_element(p)

        return StationCollection(elements=stations)
Example #43
0
File: awc.py Project: ioos/pyoos
    def __init__(self, awc_list):
        for awc_data in awc_list:
            try:
                self._root = etree.fromstring(awc_data.encode())
            except Exception as e:
                warnings.warn(
                    "Could not read from {!r}, got {}".format(awc_data, e)
                )
                continue

            """Code to get station iterator goes here."""
            stations = []
            station_lookup = []
            times = []

            for metar in self._root.iter("METAR"):
                uid = metar.find("station_id").text
                if uid not in station_lookup:
                    s = Station()
                    s.uid = uid
                    vertical = metar.find("elevation_m").text
                    if vertical is None:
                        vertical = 0
                    s.location = sPoint(
                        float(metar.find("latitude").text),
                        float(metar.find("longitude").text),
                        float(vertical),
                    )
                    s.set_property("metar_type", metar.find("metar_type").text)
                    s.set_property("horizontal_crs", "GCS")
                    s.set_property("vertical_units", "m")
                    s.set_property("vertical_crs", "AGL")

                    stations.append(s)
                    station_lookup.append(s.uid)
                    times.append({})
                else:
                    s = stations[station_lookup.index(uid)]

                variables = [
                    "elevation_m",
                    "raw_text",
                    "temp_c",
                    "dewpoint_c",
                    "wind_dir_degrees",
                    "wind_speed_kt",
                    "visibility_statute_mi",
                    "altim_in_hg",
                    "wx_string",
                    "sky_condition",
                    "flight_category",
                ]
                for variable in variables:
                    time_string = metar.find("observation_time").text
                    dt = datetime.strptime(time_string, "%Y-%m-%dT%H:%M:%SZ")
                    if dt.tzinfo is None:
                        dt = dt.replace(tzinfo=pytz.utc)
                    dt = dt.astimezone(pytz.utc)

                    if dt not in list(
                        times[station_lookup.index(s.uid)].keys()
                    ):
                        times[station_lookup.index(s.uid)][dt] = []

                    if metar.find(variable):
                        if variable in {"raw_text", "flight_category", "wx_string"}:
                            times[station_lookup.index(s.uid)][dt].append(
                                Member(
                                    value=metar.find(variable).text,
                                    unit=None,
                                    name=variable,
                                    description=variable,
                                    standard=None,
                                )
                            )
                        elif variable == "sky_condition":
                            sky_condition = []
                            for cond in metar.findall(variable):
                                cover = cond.attrib["sky_cover"]
                                try:
                                    alt = cond.attrib["cloud_base_ft_agl"]
                                except Exception:
                                    alt = None
                                sky_condition.append(
                                    {
                                        "sky_cover": cover,
                                        "cloud_base_ft_agl": alt,
                                    }
                                )
                            times[station_lookup.index(s.uid)][dt].append(
                                Member(
                                    value=sky_condition,
                                    unit="ft_above_ground_level",
                                    name=variable,
                                    description=variable,
                                    standard=None,
                                )
                            )
                        else:
                            times[station_lookup.index(s.uid)][dt].append(
                                Member(
                                    value=float(metar.find(variable).text),
                                    unit=variable.split("_")[-1],
                                    name=variable,
                                    description=variable,
                                    standard=None,
                                )
                            )

            for time_dict, station in zip(times, stations):
                for dts, members in time_dict.items():
                    p = Point()
                    p.time = dts
                    p.location = station.location
                    p.members = members
                    station.add_element(p)

        self.feature = StationCollection(elements=stations)
Example #44
0
File: awc.py Project: emiliom/pyoos
    def __init__(self, awc_list):
        for awc_data in awc_list:
            if isinstance(awc_data, str) or isinstance(awc_data, unicode):
                try:
                    self._root = etree.fromstring(str(awc_data))
                except ValueError:
                    # Strip out the XML header due to UTF8 encoding declaration
                    self._root = etree.fromstring(awc_data[56:])
            else:
                raise ValueError("Cannot parse response into ElementTree xml object")

            '''Code to get station iterator goes here
            '''
            stations = []
            station_lookup = []
            times = []

            for metar in self._root.iter('METAR'):
                uid = metar.find("station_id").text
                if uid not in station_lookup:
                    s = Station()
                    s.uid = uid
                    vertical = metar.find("elevation_m").text
                    if vertical is None:
                        vertical = 0
                    s.location = sPoint(float(metar.find("latitude").text), float(metar.find("longitude").text), float(vertical))
                    s.set_property("metar_type", metar.find("metar_type").text)
                    s.set_property("horizontal_crs", "GCS")
                    s.set_property("vertical_units", "m")
                    s.set_property("vertical_crs", "AGL")

                    stations.append(s)
                    station_lookup.append(s.uid)
                    times.append({})
                else:
                    s = stations[station_lookup.index(uid)]

                variables = ["elevation_m", "raw_text", "temp_c", "dewpoint_c", "wind_dir_degrees", "wind_speed_kt", "visibility_statute_mi", "altim_in_hg", "wx_string", "sky_condition", "flight_category"]
                for variable in variables:
                    time_string = metar.find("observation_time").text
                    dt = datetime.strptime(time_string, "%Y-%m-%dT%H:%M:%SZ")
                    if dt.tzinfo is None:
                        dt = dt.replace(tzinfo=pytz.utc)
                    dt = dt.astimezone(pytz.utc)

                    if dt not in times[station_lookup.index(s.uid)].keys():
                        times[station_lookup.index(s.uid)][dt] = []

                    if metar.find(variable) != None:
                        if variable in set(["raw_text", "flight_category", "wx_string"]):
                            times[station_lookup.index(s.uid)][dt].append(Member(value=metar.find(variable).text, unit=None, name=variable, description=variable, standard=None))
                        elif variable == "sky_condition":
                            sky_condition = []
                            for cond in metar.findall(variable):
                                cover = cond.attrib["sky_cover"]
                                try:
                                    alt = cond.attrib["cloud_base_ft_agl"]
                                except:
                                    alt = None
                                sky_condition.append({"sky_cover" : cover, "cloud_base_ft_agl" : alt})
                            times[station_lookup.index(s.uid)][dt].append(Member(value=sky_condition, unit="ft_above_ground_level", name=variable, description=variable, standard=None))
                        else:
                            times[station_lookup.index(s.uid)][dt].append(Member(value=float(metar.find(variable).text), unit=variable.split("_")[-1], name=variable, description=variable, standard=None))

            for time_dict, station in zip(times, stations):
                for dts, members in time_dict.iteritems():
                    p = Point()
                    p.time = dts
                    p.location = station.location
                    p.members = members
                    station.add_element(p)

        self.feature = StationCollection(elements=stations)
Example #45
0
    def __init__(self, awc_list):
        for awc_data in awc_list:
            self._root = etree.fromstring(awc_data.encode())
            '''Code to get station iterator goes here.'''
            stations = []
            station_lookup = []
            times = []

            for metar in self._root.iter('METAR'):
                uid = metar.find("station_id").text
                if uid not in station_lookup:
                    s = Station()
                    s.uid = uid
                    vertical = metar.find("elevation_m").text
                    if vertical is None:
                        vertical = 0
                    s.location = sPoint(float(metar.find("latitude").text),
                                        float(metar.find("longitude").text),
                                        float(vertical))
                    s.set_property("metar_type", metar.find("metar_type").text)
                    s.set_property("horizontal_crs", "GCS")
                    s.set_property("vertical_units", "m")
                    s.set_property("vertical_crs", "AGL")

                    stations.append(s)
                    station_lookup.append(s.uid)
                    times.append({})
                else:
                    s = stations[station_lookup.index(uid)]

                variables = [
                    "elevation_m", "raw_text", "temp_c", "dewpoint_c",
                    "wind_dir_degrees", "wind_speed_kt",
                    "visibility_statute_mi", "altim_in_hg", "wx_string",
                    "sky_condition", "flight_category"
                ]
                for variable in variables:
                    time_string = metar.find("observation_time").text
                    dt = datetime.strptime(time_string, "%Y-%m-%dT%H:%M:%SZ")
                    if dt.tzinfo is None:
                        dt = dt.replace(tzinfo=pytz.utc)
                    dt = dt.astimezone(pytz.utc)

                    if dt not in list(times[station_lookup.index(
                            s.uid)].keys()):
                        times[station_lookup.index(s.uid)][dt] = []

                    if metar.find(variable) != None:
                        if variable in set(
                            ["raw_text", "flight_category", "wx_string"]):
                            times[station_lookup.index(s.uid)][dt].append(
                                Member(value=metar.find(variable).text,
                                       unit=None,
                                       name=variable,
                                       description=variable,
                                       standard=None))
                        elif variable == "sky_condition":
                            sky_condition = []
                            for cond in metar.findall(variable):
                                cover = cond.attrib["sky_cover"]
                                try:
                                    alt = cond.attrib["cloud_base_ft_agl"]
                                except:
                                    alt = None
                                sky_condition.append({
                                    "sky_cover": cover,
                                    "cloud_base_ft_agl": alt
                                })
                            times[station_lookup.index(s.uid)][dt].append(
                                Member(value=sky_condition,
                                       unit="ft_above_ground_level",
                                       name=variable,
                                       description=variable,
                                       standard=None))
                        else:
                            times[station_lookup.index(s.uid)][dt].append(
                                Member(value=float(metar.find(variable).text),
                                       unit=variable.split("_")[-1],
                                       name=variable,
                                       description=variable,
                                       standard=None))

            for time_dict, station in zip(times, stations):
                for dts, members in time_dict.items():
                    p = Point()
                    p.time = dts
                    p.location = station.location
                    p.members = members
                    station.add_element(p)

        self.feature = StationCollection(elements=stations)
Example #46
0
    def test_profile(self):
        dt1 = datetime(2012, 1, 1, 12, 0)
        p1 = Point()
        p1.time = dt1
        p1.location = sPoint(-120, 50, 0)
        member1 = Member(value=34.7,
                         unit='°C',
                         name='Water Temperatire',
                         description='water temperature',
                         standard='sea_water_temperature')
        member2 = Member(value=80,
                         unit='PSU',
                         name='Salinity',
                         description='salinity',
                         standard='salinity')
        p1.add_member(member1)
        p1.add_member(member2)

        dt2 = datetime(2012, 1, 1, 12, 10)
        p2 = Point()
        p2.time = dt2
        p2.location = sPoint(-120, 50, 10)
        member3 = Member(value=34.1,
                         unit='°C',
                         name='Water Temperatire',
                         description='water temperature',
                         standard='sea_water_temperature')
        member4 = Member(value=70,
                         unit='PSU',
                         name='Salinity',
                         description='salinity',
                         standard='salinity')
        p2.add_member(member3)
        p2.add_member(member4)

        dt3 = datetime(2012, 1, 1, 12, 20)
        p3 = Point()
        p3.time = dt3
        p3.location = sPoint(-120, 50, 20)
        member5 = Member(value=32.6,
                         unit='°C',
                         name='Water Temperatire',
                         description='water temperature',
                         standard='sea_water_temperature')
        member6 = Member(value=60,
                         unit='PSU',
                         name='Salinity',
                         description='salinity',
                         standard='salinity')
        p3.add_member(member5)
        p3.add_member(member6)

        pc = Profile(elements=[p1, p2, p3])
        pc.location = sPoint(-120, 50)
        pc.time = dt1
        pc.calculate_bounds()

        assert pc.size == 3
        assert pc.time == dt1
        assert len(pc.time_range) == 3
        assert pc.time_range[0] == dt1
        assert pc.time_range[-1] == dt3
        assert len(pc.depth_range) == 3
        assert pc.depth_range[0] == p1.location.z
        assert pc.depth_range[-1] == p3.location.z
        assert pc.upper_right().equals(pc.location)
        assert pc.lower_left().equals(pc.location)
Example #47
0
    def test_section(self):

        day = 1
        hour = 0
        sc = Section()
        dt = None

        # 10 profiles
        for x in xrange(0, 10):
            lat = random.randint(40, 44)
            lon = random.randint(-74, -70)
            loc = sPoint(lon, lat, 0)
            minute = 0
            dt = datetime(2012, 4, day, hour, minute)
            hour += 1

            prof = Profile()
            prof.location = loc
            prof.time = dt

            # Each with 20 depths
            for y in xrange(0, 20):
                p = Point()
                p.time = dt
                p.location = sPoint(loc.x, loc.y, y)
                m1 = Member(
                    value=random.uniform(30, 40),
                    unit="°C",
                    name="Water Temperatire",
                    description="water temperature",
                    standard="sea_water_temperature",
                )
                m2 = Member(
                    value=random.uniform(80, 100),
                    unit="PSU",
                    name="Salinity",
                    description="salinity",
                    standard="salinity",
                )
                p.add_member(m1)
                p.add_member(m2)
                prof.add_element(p)
                # Next depth is 2 minutes from now
                dt = dt + timedelta(minutes=2)

            sc.add_element(prof)

        sc.calculate_bounds()

        assert len(sc.get_path()) == 10

        assert sc.size == 10
        assert sc.point_size == 200
        assert sc.type == "Section"

        assert len(sc.time_range) == 200
        assert sc.time_range[0] == datetime(2012, 4, 1, 0, 0)
        assert sc.time_range[-1] == dt - timedelta(minutes=2)

        assert len(sc.depth_range) == 200
        assert sc.depth_range[0] == 0
        assert sc.depth_range[-1] == 19
Example #48
0
    def __init__(self, wqx_metadata, wqx_data):
        if not isinstance(wqx_metadata, WqxOutbound):
            wqx_metadata = WqxOutbound(wqx_metadata)

        if not isinstance(wqx_data, WqxOutbound):
            wqx_data = WqxOutbound(wqx_data)

        if wqx_data.failed or wqx_metadata.failed:
            self.feature = None
        else:
            s = Station()
            s.uid = wqx_metadata.location.id
            s.name = wqx_metadata.location.name
            s.set_property("station_type", wqx_metadata.location.type)
            s.set_property("location_description",
                           wqx_metadata.location.description)
            s.set_property("huc", wqx_metadata.location.huc)
            s.set_property("county", wqx_metadata.location.county)
            s.set_property("state", wqx_metadata.location.state)
            s.set_property("country", wqx_metadata.location.country)
            s.set_property("organization_id", wqx_metadata.organization.id)
            s.set_property("organization_name", wqx_metadata.organization.name)
            s.set_property("vertical_units",
                           wqx_metadata.location.vertical_measure_units)
            s.set_property("horizontal_crs",
                           wqx_metadata.location.horizontal_crs_name)
            s.set_property("vertical_crs",
                           wqx_metadata.location.vertical_crs_name)

            for a in wqx_data.activities:
                p = Point()
                p.time = a.start_time

                for r in a.results:
                    p.add_member(
                        Member(value=r.value,
                               unit=r.units,
                               name=r.name,
                               description=r.short_name,
                               standard=None,
                               quality=r.quality,
                               method_id=a.method_id,
                               method_name=a.method_name))

                s.add_element(p)

            # Now set the station's location
            vertical = 0
            try:
                vertical = float(wqx_metadata.location.vertical_measure_value)
            except:
                pass

            # convert the vertical to meters if it is ft (which it always is)
            if wqx_metadata.location.vertical_measure_units == "ft":
                vertical /= 3.28084
                s.set_property("vertical_units", "m")
            s.location = sPoint(float(wqx_metadata.location.longitude),
                                float(wqx_metadata.location.latitude),
                                vertical)

            self.feature = s