def testFullText(self):
    notice = area_notice.AreaNotice(
        area_notice.notice_type['cau_mammals_not_obs'],
        datetime.datetime(
            datetime.datetime.utcnow().year, 7, 6, 0, 0, 4), 60,
        10, source_mmsi=2)
    notice.add_subarea(area_notice.AreaNoticeCirclePt(-69.5, 42, radius=0))  # 1

    text_sections = (
        '12345678901234',  # 2
        'More text that',  # 3
        ' spans across ',  # 4
        'multiple lines',  # 5
        '  The text is ',  # 6
        'supposed to be',  # 7
        ' cated togethe',  # 8
        'r. 12345678901'  # 9
    )
    for text in text_sections:
      notice.add_subarea(area_notice.AreaNoticeFreeText(text=text))

    expected = ''.join(text_sections).upper()
    self.assertEqual(notice.get_merged_text(), expected)

    orig = geojson.loads(geojson.dumps(notice))
    decoded = geojson.loads(
        geojson.dumps(
            area_notice.AreaNotice(
                nmea_strings=[
                    line
                    for line in
                    notice.get_aivdm()])))
    self.assertAlmostEqualGeojson(orig, decoded)
Ejemplo n.º 2
0
def get_city_geojson(municipio):
    """
    Pega o geojson a partir do banco de dados
    :param municipio: geocódigo do municipio
    :return:
    """
    with db_engine.connect() as conn:
        head = r'{"type": "FeatureCollection", "features":['
        tail = ']}'

        res = conn.execute(
            '''
            select geocodigo, nome, geojson, populacao, uf
            from "Dengue_global"."Municipio" where geocodigo=%s
            ''', (municipio,)
        )
        datum = dict(res.fetchone().items())
        feat = geojson.loads(datum['geojson'])

        feat['type'] = 'Feature'

        feat['properties'] = {'geocodigo': datum['geocodigo'],
                              'nome': datum['nome'],
                              'populacao': datum['populacao']}

        geoj = geojson.loads(head + geojson.dumps(feat) + tail)

    return geoj
Ejemplo n.º 3
0
def compare_osm_kenyaopendata():
  osm = geojson.loads(readfile('kibera-schools-osm.geojson'))
  kod = geojson.loads(readfile('kibera-primary-secondary-schools.geojson'))
  result = {}
  result['type'] = 'FeatureCollection'
  result['features'] = []

  #TODO make sure all features in KOD are in OSM (through osmly)
  for feature in osm.features:
    points = [(feature.geometry.coordinates[0], feature.geometry.coordinates[1])]
    properties = {}
    #properties = feature.properties
    for osm_property in feature.properties.keys():
      properties[ "osm:" + osm_property ] = feature.properties[ osm_property ]

    if 'official_name' in feature.properties:
      for kod_feature in kod.features:
        if 'official_name' in kod_feature.properties and kod_feature.properties['official_name'] == feature.properties['official_name']:
          #print feature.properties['official_name']
          points.append((kod_feature.geometry.coordinates[0],  kod_feature.geometry.coordinates[1]))
          for kod_property in kod_feature.properties.keys():
            if kod_property != 'lat' and kod_property != 'lon':
              properties[ "kenyaopendata:" + kod_property] = kod_feature.properties[ kod_property ]

    geom = MultiPoint(points)
    result['features'].append( { "type": "Feature", "properties": properties, "geometry": geom })

  dump = geojson.dumps(result, sort_keys=True, indent=2)
  writefile('kibera-combined-schools.geojson',dump)
Ejemplo n.º 4
0
    def test_01_full_text(self):
        'full text'
        notice = an.AreaNotice(an.notice_type['cau_mammals_not_obs'],datetime.datetime(datetime.datetime.utcnow().year, 7, 6, 0, 0, 4),60,10, source_mmsi=2)
        notice.add_subarea(an.AreaNoticeCirclePt(-69.5, 42, radius=0)) # 1

        text_sections = (
            '12345678901234', # 2
            'More text that', # 3
            ' spans across ', # 4
            'multiple lines', # 5
            '  The text is ', # 6
            'supposed to be', # 7
            ' cated togethe', # 8
            'r. 12345678901'  # 9
            )
        for text in text_sections:
            notice.add_subarea(an.AreaNoticeFreeText(text=text))

        expected = ''.join(text_sections).upper()
        # if notice.get_merged_text() != expected:
        #     sys.exit('OH CRAP....\n  %s\n  %s\n' % (notice.get_merged_text(), expected) )
        self.failUnless(notice.get_merged_text() == expected)
        
        orig = geojson.loads( geojson.dumps(notice) )
        decoded = geojson.loads( geojson.dumps(an.AreaNotice(nmea_strings=[ line for line in notice.get_aivdm() ] )) )
        #sys.stderr.write('\norig:'+str(orig)+'\n')
        #sys.stderr.write('decoded:'+str(decoded)+'\n\n')
        #sys.stderr.write('orig:'+str(orig['bbm']['freetext'])+'\n')
        #sys.stderr.write('deco:'+str(decoded['bbm']['freetext'])+'\n')

        #if not almost_equal_geojson(orig, decoded):
        #    sys.exit('FULL FREETEXT FAIL')
        self.failUnless( almost_equal_geojson(orig, decoded) )
Ejemplo n.º 5
0
    def test_01point(self):
        'point'
        year = datetime.datetime.utcnow().year
        pt1 = an.AreaNotice(an.notice_type['cau_mammals_not_obs'],datetime.datetime(year,8,6,0,1,0),60,10, source_mmsi = 445566778)
        pt1.add_subarea(an.AreaNoticeCirclePt(-69.8, 42.0, radius=0))
        orig = geojson.loads( geojson.dumps(pt1) )

        decoded_pt = an.AreaNotice(nmea_strings=[ line for line in pt1.get_aivdm() ] )
        
        #sys.stderr.write('\npt1_start:       '+str(pt1.when)+'\n')
        #sys.stderr.write('decoded_pt_start:'+str(decoded_pt.when)+'\n')
        decoded = geojson.loads( geojson.dumps(decoded_pt) )

        #sys.stderr.write('pt1:'+str(pt1)+'\n')
        #sys.stderr.write('orig_start:'+str(   orig['bbm']['start'])+'\n')
        #sys.stderr.write('deco_start:'+str(decoded['bbm']['start'])+'\n')

        #sys.stderr.write('orig: ' + str(orig) + '\n')
        #sys.stderr.write('deco: ' + str(decoded) + '\n')

        if not almost_equal_geojson(orig, decoded, verbose=True):
            sys.exit('1: That had better work!  But it did not!!!')
        #else:
        #    sys.stderr.write('try_1: ok!\n')

        self.failUnless( almost_equal_geojson(orig, decoded) )
Ejemplo n.º 6
0
    def test_whales(self):
        'whales observed circle notice'
        zone_type = an.notice_type['cau_mammals_reduce_speed']
        circle = an.AreaNotice(zone_type,datetime.datetime(datetime.datetime.utcnow().year, 7, 6, 0, 0, 4),60,10, source_mmsi = 123456789)
        circle.add_subarea(an.AreaNoticeCirclePt(-69.8, 42.0, radius=4260))

        self.assertEqual(zone_type, 1)
        self.assertEqual(zone_type, circle.area_type)

        json = geojson.dumps(circle)
        data = geojson.loads(json) # Get the data as a dictionary so that we can verify the contents
        self.assertEqual(zone_type, data['bbm']['area_type'])
        self.assertEqual(an.notice_type[zone_type], data['bbm']['area_type_desc'])

        # now try to pass the message as nmea strings and decode the message
        aivdms = []
        for line in circle.get_aivdm():
            aivdms.append(line)

        del circle
        del data
        del json

        notice = an.AreaNotice(nmea_strings=aivdms)
        self.assertEqual(zone_type,notice.area_type)

        json = geojson.dumps(notice)
        data = geojson.loads(json) # Get the data as a dictionary so that we can verify the contents
        self.assertEqual(zone_type, data['bbm']['area_type'])
        self.assertEqual(an.notice_type[zone_type], data['bbm']['area_type_desc'])
  def testPoint(self):
    # One of each.
    notice = area_notice.AreaNotice(
        area_notice.notice_type['cau_mammals_not_obs'],
        datetime.datetime(
            datetime.datetime.utcnow().year, 7, 6, 0, 0, 4), 60,
        10, source_mmsi=666555444)
    notice.add_subarea(area_notice.AreaNoticeCirclePt(-69.8, 40.001, radius=0))
    notice.add_subarea(
        area_notice.AreaNoticeCirclePt(-69.8, 40.202, radius=2000))
    notice.add_subarea(
        area_notice.AreaNoticeRectangle(-69.6, 40.3003, 2000, 1000, 0))
    notice.add_subarea(
        area_notice.AreaNoticeSector(-69.4, 40.40004, 6000, 10, 50))
    notice.add_subarea(
        area_notice.AreaNoticePolyline([(170, 7400)], -69.2, 40.5000005))
    notice.add_subarea(
        area_notice.AreaNoticePolygon(
            [(10, 1400), (90, 1950)], -69.0, 40.6000001))
    notice.add_subarea(area_notice.AreaNoticeFreeText(text='Some Text'))

    orig = geojson.loads(geojson.dumps(notice))
    nmea_strings = [line for line in notice.get_aivdm()]
    decoded = geojson.loads(
        geojson.dumps(area_notice.AreaNotice(nmea_strings=nmea_strings)))
    self.assertAlmostEqualGeojson(orig, decoded)
Ejemplo n.º 8
0
def convert2geojson():
  #KOD
  os.system("rm kibera-primary-schools.geojson")
  os.system("ogr2ogr -f GeoJSON kibera-primary-schools.geojson kibera-primary-schools.vrt")
  os.system("rm kibera-secondary-schools.geojson")
  os.system("ogr2ogr -f GeoJSON kibera-secondary-schools.geojson kibera-secondary-schools.vrt")
  kod_primary = geojson.loads(readfile('kibera-primary-schools.geojson'))
  kod_secondary = geojson.loads(readfile('kibera-secondary-schools.geojson'))
  kod_primary.features.extend(kod_secondary.features)
  dump = geojson.dumps(kod_primary, sort_keys=True, indent=2)
  writefile('kibera-primary-secondary-schools.geojson',dump)

  #OSM
  os.system("osmtogeojson -e kibera-schools-osm.xml > kibera-schools-osm.geojson")
  os.system("osmtogeojson -e mathare-schools-osm.xml > mathare-schools-osm.geojson")
  os.system("osmtogeojson -e kangemi-schools-osm.xml > kangemi-schools-osm.geojson")
  clean_osm('kibera-schools-osm.geojson')
  clean_osm('mathare-schools-osm.geojson')
  clean_osm('kangemi-schools-osm.geojson')
  osm_kibera = geojson.loads(readfile('kibera-schools-osm.geojson'))
  osm_mathare = geojson.loads(readfile('mathare-schools-osm.geojson'))
  osm_kangemi = geojson.loads(readfile('kangemi-schools-osm.geojson'))
  osm_kibera.features.extend(osm_mathare.features)
  osm_kibera.features.extend(osm_kangemi.features)
  dump = geojson.dumps(osm_kibera, sort_keys=True, indent=2)
  writefile('nairobi-schools-osm.geojson', dump)
Ejemplo n.º 9
0
 def test_polygon(self):
     'polygon'
     poly1 = an.AreaNotice(an.notice_type['cau_divers'], datetime.datetime(datetime.datetime.utcnow().year, 7, 6, 0, 0, 4), 60, 10, source_mmsi=987123456)
     poly1.add_subarea(an.AreaNoticePolygon([(10,1400),(90,1950)], -69.8, 42.5 ))
     orig = geojson.loads( geojson.dumps(poly1) )
     poly2 = an.AreaNotice(nmea_strings=[ line for line in poly1.get_aivdm() ] )
     decoded = geojson.loads( geojson.dumps(poly2) )
     self.assertAlmostEqualGeojson(orig, decoded)
Ejemplo n.º 10
0
 def test_line(self):
     'line'
     line1 = an.AreaNotice(an.notice_type['report_of_icing'],datetime.datetime(datetime.datetime.utcnow().year, 7, 6, 0, 0, 4),60,10, source_mmsi=123456)
     line1.add_subarea(an.AreaNoticePolyline([(10,2400),], -69.8, 42.4 ))
     orig = geojson.loads( geojson.dumps(line1) )
     line2 = an.AreaNotice(nmea_strings=[ line for line in line1.get_aivdm() ] )
     decoded = geojson.loads( geojson.dumps(line2) )
     self.assertAlmostEqualGeojson(orig, decoded)
Ejemplo n.º 11
0
def _check_region_json(area):
    if area is not None:
        try:
            geojson.loads(json.dumps(area))
        except ValueError:
            raise_user_exc(REGION_INVALID)

    return True
Ejemplo n.º 12
0
 def test_sector(self):
     'sector'
     sec1 = an.AreaNotice(an.notice_type['cau_habitat_reduce_speed'],
                          datetime.datetime(datetime.datetime.utcnow().year, 7, 6, 0, 0, 4), 60, 10, source_mmsi = 456)
     sec1.add_subarea(an.AreaNoticeSector(-69.8, 42.3, 4000, 10, 50))
     orig = geojson.loads( geojson.dumps(sec1) )
     decoded = geojson.loads( geojson.dumps(an.AreaNotice(nmea_strings=[ line for line in sec1.get_aivdm() ] )) )
     self.assertAlmostEqualGeojson(orig, decoded)
Ejemplo n.º 13
0
def convert2geojson():
  os.system("ogr2ogr -f GeoJSON kibera-primary-schools.geojson kibera-primary-schools.vrt")
  os.system("ogr2ogr -f GeoJSON kibera-secondary-schools.geojson kibera-secondary-schools.vrt")
  kod_primary = geojson.loads(readfile('kibera-primary-schools.geojson'))
  kod_secondary = geojson.loads(readfile('kibera-secondary-schools.geojson'))
  kod_primary.features.extend(kod_secondary.features)
  dump = geojson.dumps(kod_primary, sort_keys=True, indent=2)
  writefile('kibera-primary-secondary-schools.geojson',dump)
  os.system("osmtogeojson kibera-schools-osm.xml > kibera-schools-osm.geojson")
Ejemplo n.º 14
0
 def extract(self, target, data):
     t = data.read()
     try:
         data = geojson.loads(t)
     except:
         # possibly malformed json?
         start = min(t.find('{'), t.find('['))
         data = geojson.loads(t[start:])
     result = geojson.is_valid(data)
     if result['valid'] == 'yes':
         return [('geojson', data)]
Ejemplo n.º 15
0
    def test_freetext(self):
        'freetext'
        text1 = an.AreaNotice(an.notice_type['res_military_ops'],datetime.datetime(datetime.datetime.utcnow().year, 7, 6, 0, 4, 0), 60,10, source_mmsi=300000000)
        text1.add_subarea(an.AreaNoticeCirclePt(-69.8, 42.6, radius=0))
        text1.add_subarea(an.AreaNoticeFreeText(text="Explanation"))

        orig = geojson.loads( geojson.dumps(text1) )
        text2 = an.AreaNotice(nmea_strings=[ line for line in text1.get_aivdm() ] )
        decoded = geojson.loads( geojson.dumps(text2) )

        self.assertAlmostEqualGeojson(orig, decoded)
Ejemplo n.º 16
0
    def test_rect(self):
        'rectangle'
        rect = an.AreaNotice( an.notice_type['cau_mammals_reduce_speed'],
                               datetime.datetime(datetime.datetime.utcnow().year, 7, 6, 0, 0, 4),
                               60, 10,
                               source_mmsi = 123
                               )
        rect.add_subarea( an.AreaNoticeRectangle(-69.8, 42, 4000, 1000, 0) )

        orig = geojson.loads( geojson.dumps(rect) )
        decoded = geojson.loads( geojson.dumps(an.AreaNotice(nmea_strings=[ line for line in rect.get_aivdm() ] )) )
        self.assertAlmostEqualGeojson(orig, decoded)
Ejemplo n.º 17
0
    def test_freetext(self):
        'freetext'
        text1 = an.AreaNotice(an.notice_type['res_military_ops'],datetime.datetime(datetime.datetime.utcnow().year, 7, 6, 0, 4, 0), 60,10, source_mmsi=300000000)
        text1.add_subarea(an.AreaNoticeCirclePt(-69.8, 42.6, radius=0))
        text1.add_subarea(an.AreaNoticeFreeText(text="Explanation"))

        orig = geojson.loads( geojson.dumps(text1) )
        text2 = an.AreaNotice(nmea_strings=[ line for line in text1.get_aivdm() ] )
        decoded = geojson.loads( geojson.dumps(text2) )

        if not almost_equal_geojson(orig, decoded, verbose=True):
            sys.exit('FREE TEXT FAIL')
        self.failUnless( almost_equal_geojson(orig, decoded, verbose=True) )
Ejemplo n.º 18
0
    def test_02circle(self):
        'circle'
        now = datetime.datetime.utcnow()
        circle1 = an.AreaNotice(an.notice_type['cau_mammals_reduce_speed'],
                                # Don't use seconds.  Can only use minutes
                                datetime.datetime(now.year, 7, 6, 0, 0, 0),
                                60, 10,
                                source_mmsi = 2)
        circle1.add_subarea(an.AreaNoticeCirclePt(-69.8, 42.1, radius=4260))

        orig = geojson.loads( geojson.dumps(circle1) )
        nmea_strings=[ line for line in circle1.get_aivdm()]
        decoded = geojson.loads( geojson.dumps(an.AreaNotice(nmea_strings=nmea_strings)))

        self.assertAlmostEqualGeojson(orig, decoded)
Ejemplo n.º 19
0
    def test_01point(self):
        'point'
        year = datetime.datetime.utcnow().year
        pt1 = an.AreaNotice(an.notice_type['cau_mammals_not_obs'],datetime.datetime(year,8,6,0,1,0),60,10, source_mmsi = 445566778)
        pt1.add_subarea(an.AreaNoticeCirclePt(-69.8, 42.0, radius=0))
        orig = geojson.loads( geojson.dumps(pt1) )

        decoded_pt = an.AreaNotice(nmea_strings=[ line for line in pt1.get_aivdm() ] )

        decoded = geojson.loads( geojson.dumps(decoded_pt) )

        self.assertAlmostEqualGeojson(orig, decoded, verbose=True)


        self.assertAlmostEqualGeojson(orig, decoded)
Ejemplo n.º 20
0
    def test_polygon(self):
        'polygon'
        poly1 = an.AreaNotice(an.notice_type['cau_divers'], datetime.datetime(datetime.datetime.utcnow().year, 7, 6, 0, 0, 4), 60, 10, source_mmsi=987123456)
        poly1.add_subarea(an.AreaNoticePolygon([(10,1400),(90,1950)], -69.8, 42.5 ))
        #print 'poly1:',poly1
        #print 'poly1:',poly1.areas[0]
        orig = geojson.loads( geojson.dumps(poly1) )
        poly2 = an.AreaNotice(nmea_strings=[ line for line in poly1.get_aivdm() ] )
        #print 'line2',line2
        #print 'line2:',str(line2.areas[0])
        decoded = geojson.loads( geojson.dumps(poly2) )

        #print orig
        #print decoded
        self.failUnless( almost_equal_geojson(orig, decoded) ) #, verbose=True) )
Ejemplo n.º 21
0
 def test_decode(self):
     """
     Ensure a GeoJSON string can be decoded into GeoJSON objects
     """
     actual = geojson.loads(self.restaurant_str)
     expected = self.restaurant1.__geo_interface__
     self.assertEqual(expected, actual)
def getChips(sr, project_id, plotid, collection, chip_name, vis, poly):
	"""retrieve image chips.

	Args:
		collection (ee.ImageCollection): a image colleciton to extract chips.
		vis (dictionary): visualization parameters.
		point (ee.Geometry.Point): pixel sample.
		size (int): image chip dimension in pixels.
`
	Returns:
		none
	"""
	print '\t\t', 'chipping', sr, project_id, plotid, chip_name

	first = ee.Image(collection.first()).visualize(**vis).unmask()
	result = collection.iterate(lambda img, prev: ee.Image(prev).addBands(ee.Image(img).visualize(**vis).unmask()), first)

	this_job = '%s_project_%d_plot_%d_%s' % (sr, project_id, plotid, chip_name)
	this_folder = 'prj_%s' % project_id
	#
	# task = Export.image.toDrive(ee.Image(result), this_job, this_folder, this_job, None,
	# 							poly.transform(None, 15).getInfo()['coordinates'], None,
	# 							CRS, CRS_TRANSFORM, 1e13)

	task = Export.image.toDrive(ee.Image(result), this_job, this_folder, this_job, None,
								ee.Geometry(geojson.loads(json.dumps(poly.getInfo()))), None,
								CRS, CRS_TRANSFORM, 1e13)

	task.start()
Ejemplo n.º 23
0
def lidar_shp(request):
    """
        Transform the profile line (2D) to ESRI shapefile
    """

    # set up paths
    geom = geojson.loads(request.params['geom'], object_hook =  geojson.GeoJSON.to_instance)
    outputDir = request.registry.settings['lidar_output_dir'].replace('\\', '/') 
    outputShp= outputDir + str(uuid.uuid4())

    # Create pyshp polyline ESRI shapfile and write it to disk
    shapeParts = []
    outShp = shapefile.Writer(shapefile.POLYLINE)
    outShp.line(parts=[geom.coordinates])
    outShp.field('FIRST_FLD','C','40')
    outShp.record('First','Line')
    outShp.save(outputShp)

    # zip the shapefile for nice single output
    zipShp = zip(outputShp +'.zip', mode='w')
    zipShp.write(outputShp + '.shp', os.path.basename(outputShp + '.shp'))
    zipShp.write(outputShp + '.dbf', os.path.basename(outputShp + '.dbf'))
    zipShp.write(outputShp + '.shx', os.path.basename(outputShp + '.shx'))
    zipShp.close()

    # remove files
    os.remove(outputShp + '.shx')
    os.remove(outputShp + '.shp')
    os.remove(outputShp + '.dbf')

    return FileResponse(outputShp + '.zip', request = request, content_type = 'application/zip')
Ejemplo n.º 24
0
Archivo: models.py Proyecto: La0/beers
 def get_polygon(self):
   if not self.geojson:
     return None
   polygon = geojson.loads(self.geojson)
   if polygon['type'] != 'Polygon':
     return None
   return polygon['coordinates']
Ejemplo n.º 25
0
Archivo: models.py Proyecto: La0/beers
 def get_point(self):
   if not self.geojson:
     return None
   point = geojson.loads(self.geojson)
   if point['type'] != 'Point':
     return None
   return (float(point['coordinates'][0]), float(point['coordinates'][1]))
Ejemplo n.º 26
0
def get_coordinates(geojson_file, feature_number=0):
    """Return the coordinates of a polygon of a GeoJSON file."""
    geojson_obj = geojson.loads(open(geojson_file, 'r').read())
    coordinates = geojson_obj['features'][feature_number]['geometry']['coordinates'][0]
    # precision of 7 decimals equals 1mm at the equator
    coordinates = ['%.7f %.7f' % tuple(coord) for coord in coordinates]
    return ','.join(coordinates)
Ejemplo n.º 27
0
 def create(self, request):
     """ Read the GeoJSON feature collection from the request body and
         create new objects in the database. """
     if self.readonly:
         return HTTPMethodNotAllowed(headers={'Allow': 'GET, HEAD'})
     collection = loads(request.body, object_hook=GeoJSON.to_instance)
     if not isinstance(collection, FeatureCollection):
         return HTTPBadRequest()
     session = self.Session()
     objects = []
     for feature in collection.features:
         create = False
         obj = None
         if hasattr(feature, 'id') and feature.id is not None:
             obj = session.query(self.mapped_class).get(feature.id)
         if self.before_create is not None:
             self.before_create(request, feature, obj)
         if obj is None:
             obj = self.mapped_class(feature)
             create = True
         else:
             obj.__update__(feature)
         if create:
             session.add(obj)
         objects.append(obj)
     session.flush()
     collection = FeatureCollection(objects) if len(objects) > 0 else None
     request.response.status_int = 201
     return collection
Ejemplo n.º 28
0
    def import_from_geojson(self, input):
        collection = geojson.loads(input,
                                   object_hook=geojson.GeoJSON.to_instance)

        tasks = []
        hasPolygon = False

        if not hasattr(collection, "features") or \
                len(collection.features) < 1:
            raise ValueError("GeoJSON file doesn't contain any feature.")
        for feature in collection.features:
            geometry = shapely.geometry.asShape(feature.geometry)
            if isinstance(geometry, shapely.geometry.Polygon):
                hasPolygon = True
            elif not isinstance(geometry, shapely.geometry.Polygon):
                continue
            tasks.append(Task(None, None, None, 'SRID=4326;%s' % geometry.wkt))

        if not hasPolygon:
            raise ValueError("GeoJSON file doesn't contain any polygon.")

        self.tasks = tasks

        bounds = DBSession.query(ST_Convexhull(ST_Collect(Task.geometry))) \
            .filter(Task.project_id == self.id).one()
        self.area = Area(bounds[0])

        return len(tasks)
Ejemplo n.º 29
0
def parse_geometry(geometry_raw, rewrite_circle=False):


    geometry_statement = None
    # is it WKT?
    try:
        geometry_statement = sqlalchemy.sql.expression.func.GeomFromText(
            geomet.wkt.dumps(geomet.wkt.loads(geometry_raw)))
    except ValueError as err:
        logging.debug('    ... not WKT')
    # is it GeoJSON?
    if not geometry_statement:
        try:
            geometry_statement = sqlalchemy.sql.expression.func.GeomFromText(
                geomet.wkt.dumps(geojson.loads(geometry_raw)))
        except ValueError as err:
            logging.debug('    ... not GeoJSON')
    if not geometry_statement and rewrite_circle and 'CIRCLE' in geometry_raw:
        # now see if it a CIRCLE(long lat, rad_in_m)
        re_res = re.findall(
            r'CIRCLE\s*\(\s*([0-9.-]+)\s+([0-9.-]+)\s*,\s*([0-9.]+)\s*\)',
            geometry_raw)
        if re_res and len(re_res[0]) == 3:
            lng = float(re_res[0][0])
            lat = float(re_res[0][1])
            rad = float(re_res[0][2])
            geometry_statement = sqlalchemy.sql.expression.func.Buffer(
                sqlalchemy.sql.expression.func.POINT(lng, lat),
                rad / 1000 / 111.045)
        else:
            logging.warn('ignoring malformed intersects statement:%s',
                         geometry_raw)
    logging.info('%s becomes %s', geometry_raw, geometry_statement)
    return geometry_statement
Ejemplo n.º 30
0
def plot_save():
    with open('data.json', 'r') as f:
        load = geojson.loads(f.read())
    features = load.features
    data = pandas.DataFrame()
    data['x'] = [x['geometry']['coordinates'][0] for x in features]
    data['y'] = [x['geometry']['coordinates'][1] for x in features]
    data['value'] = [(x['properties']['re']+x['properties']['rei']) for x in features]
    data['trees'] = [math.ceil(math.log1p(x['properties']['trs'])*1.17)+1 for x in features]
    
    data = data[data['value'] < data['value'].quantile(.99)]
    print data.trees.describe()
    print data.value.quantile(.1), data.value.quantile(.9)
    print data.value.describe()
    plt.figure(figsize=(20, 15)) 
    #plt.xlabel('Leafiness Index')
    #plt.ylabel('Real Estate Value')
    
    #plt.scatter(data.x, data.y, c=data.trees, s=4, alpha=0.1)
    #plt.ylim([0, 3000000])
    #plt.boxplot([data[data.trees==x].value for x in range(1, 11)])
    plt.hist(data.trees, bins=10)
    #data.to_csv("data.csv", index=False)
        
    return
Ejemplo n.º 31
0
def read_report_dir(rptdir, total_parcel_count=0):
    #rpt dir passed in, just read the preprossed report data
    rpt = FloodReport()
    rpt.total_parcel_count = total_parcel_count
    rpt.model = swmmio.Model(os.path.dirname(rptdir))
    rpt.scenario = rpt.model.scenario
    rpt.parcel_flooding = pd.read_csv(
        os.path.join(rptdir, 'parcel_flood_comparison.csv'))
    rpt.parcel_hrs_flooded = rpt.parcel_flooding.HoursFloodedProposed.sum()
    rpt.parcel_vol_flooded = rpt.parcel_flooding.TotalFloodVolProposed.sum()
    costcsv = os.path.join(rptdir, 'cost_estimate.csv')
    conduits_geojson_path = os.path.join(rptdir, 'new_conduits.json')

    if os.path.exists(costcsv):
        #calc the cost estimate total in millions
        cost_df = pd.read_csv(costcsv)
        rpt.cost_estimate = cost_df.TotalCostEstimate.sum() / math.pow(10, 6)

    if os.path.exists(conduits_geojson_path):
        with open(conduits_geojson_path, 'r') as f:
            rpt.new_conduits_geojson = geojson.loads(f.read())

    return rpt
Ejemplo n.º 32
0
def search_source_locations(
    vial_http: urllib3.connectionpool.ConnectionPool,
    **kwds: Any,
) -> Iterator[dict]:
    """Wrapper around search source locations api. Returns geojson."""
    params = {
        **kwds,
        "format": "nlgeojson",
    }

    query = urllib.parse.urlencode(params)

    resp = vial_http.request("GET",
                             f"/api/searchSourceLocations?{query}",
                             preload_content=False)

    for line in resp:
        try:
            yield geojson.loads(line)
        except json.JSONDecodeError:
            logger.warning("Invalid json record in search response: %s", line)

    resp.release_conn()
    def search_projects(search_dto: ProjectSearchDTO, user) -> ProjectSearchResultsDTO:
        """ Searches all projects for matches to the criteria provided by the user """
        all_results, paginated_results = ProjectSearchService._filter_projects(
            search_dto, user
        )
        if paginated_results.total == 0:
            raise NotFound()

        dto = ProjectSearchResultsDTO()
        dto.results = [
            ProjectSearchService.create_result_dto(
                p,
                search_dto.preferred_locale,
                Project.get_project_total_contributions(p[0]),
            )
            for p in paginated_results.items
        ]
        dto.pagination = Pagination(paginated_results)
        if search_dto.omit_map_results:
            return dto

        features = []
        for project in all_results:
            # This loop creates a geojson feature collection so you can see all active projects on the map
            properties = {
                "projectId": project.id,
                "priority": ProjectPriority(project.priority).name,
            }
            # centroid = project.centroid
            feature = geojson.Feature(
                geometry=geojson.loads(project.centroid), properties=properties
            )
            features.append(feature)
        feature_collection = geojson.FeatureCollection(features)
        dto.map_results = feature_collection

        return dto
Ejemplo n.º 34
0
def json2geojson(data):
    mileuzones = data["milieuzones"]
    features = []
    for element in mileuzones:
        if "milieuzone" in element:
            milieuzone = element["milieuzone"]
            multipolygon = None
            geo = loads(milieuzone["geo"])
            # Extract multipolygon
            if type(geo) is Polygon:
                multipolygon = MultiPolygon(f)
            elif type(geo) is MultiPolygon:
                multipolygon = geo
            elif type(geo) is GeometryCollection:
                for f in geo["geometries"]:
                    if type(f) is Polygon:
                        multipolygon = MultiPolygon(f)
                        break
                    elif type(f) is MultiPolygon:
                        multipolygon = f
                        break

            if multipolygon is None:
                raise Exception("Missing (multi)polygon")

            properties = {
                key: milieuzone[key]
                for key in ("id", "verkeerstype", "vanafdatum")
            }
            features.append({
                "type": "Feature",
                "geometry": multipolygon,
                "properties": properties,
            })

    geojson = {"type": "FeatureCollection", "features": [f for f in features]}
    return geojson
Ejemplo n.º 35
0
    def search_projects(
            search_dto: ProjectSearchDTO) -> ProjectSearchResultsDTO:
        """ Searches all projects for matches to the criteria provided by the user """

        filtered_projects = ProjectSearchService._filter_projects(search_dto)

        if filtered_projects.total == 0:
            raise NotFound()

        dto = ProjectSearchResultsDTO()
        for project in filtered_projects.items:
            # TODO would be nice to get this for an array rather than individually would be more efficient
            project_info_dto = ProjectInfo.get_dto_for_locale(
                project.id, search_dto.preferred_locale,
                project.default_locale)

            result_dto = ProjectSearchResultDTO()
            result_dto.project_id = project.id
            result_dto.locale = project_info_dto.locale
            result_dto.name = project_info_dto.name
            result_dto.priority = ProjectPriority(project.priority).name
            result_dto.mapper_level = MappingLevel(project.mapper_level).name
            result_dto.short_description = project_info_dto.short_description
            result_dto.aoi_centroid = geojson.loads(project.centroid)
            result_dto.organisation_tag = project.organisation_tag
            result_dto.campaign_tag = project.campaign_tag
            result_dto.percent_mapped = round(
                (project.tasks_mapped /
                 (project.total_tasks - project.tasks_bad_imagery)) * 100, 0)
            result_dto.percent_validated = round(
                ((project.tasks_validated + project.tasks_bad_imagery) /
                 project.total_tasks) * 100, 0)

            dto.results.append(result_dto)

        dto.pagination = Pagination(filtered_projects)
        return dto
Ejemplo n.º 36
0
def area_distance(geoalchemy_polygon: WKBElement,
                  geocode_geo_json=None) -> Dict[str, int]:
    """calculates area of polygon wkbelement and
    optionally distance to a geojson gemetry if it is provided.

    Args:
        geoalchemy_polygon (WKBElement): polygon whose area is desired
        geocode_geo_json (geojson geometry): geometry to calculate distance to

    Returns:
        Dict[str, int]: {'area': area in sqm, 'distance': distance in meters}
        if no input geojson geometry for distance calculation then returns -1 for distance
    """

    input_polygon_shapely_geometry = geoalchemy2.shape.to_shape(
        geoalchemy_polygon)
    # project
    project_in = pyproj.Transformer.from_proj(
        pyproj.Proj(init='epsg:4326'),  # source
        pyproj.Proj(init='epsg:3857'))  # destination

    # get area
    input_polygon_projected = transform(project_in.transform,
                                        input_polygon_shapely_geometry)
    area = round(input_polygon_projected.area)

    # get distance
    if geocode_geo_json:
        geocode_json_geometry = json.dumps(geocode_geo_json)
        geocode_geo_json_obj = geojson.loads(geocode_json_geometry)
        geocode_shapely = geometry.shape(geocode_geo_json_obj)
        geocode_projected = transform(project_in.transform, geocode_shapely)
        distance = round(
            geocode_projected.distance(input_polygon_projected.centroid))
        return {'area': area, 'distance': distance}

    return {'area': area, 'distance': -1}
Ejemplo n.º 37
0
    def get(self, request, **kwargs):
        """
        Returns geojson if requested, otherwise handles request as normal.
        """

        geojson_requested = self.request.query_params.get('geojson') == 'true'

        # if geojson requested, create a query that returns each well's geometry as GeoJSON
        # so that we can easily create a FeatureCollection.
        # This might be more performant in the database using json_agg and ST_AsGeoJSON
        # vs creating geojson Features here in Python.
        if geojson_requested:
            qs = self.get_queryset()
            locations = self.filter_queryset(qs)
            count = locations.count()
            # return an empty response if there are too many wells to display
            if count > self.MAX_LOCATION_COUNT:
                raise PermissionDenied(
                    'Too many wells to display on map. '
                    'Please zoom in or change your search criteria.')

            locations = locations.annotate(
                geometry=Cast(Func('geom', function='ST_AsGeoJSON'),
                              output_field=TextField())).values(
                                  "well_tag_number",
                                  "identification_plate_number", "geometry",
                                  "street_address", "city")

            # create a group of features
            features = [
                Feature(geometry=geojson.loads(x.pop('geometry')),
                        properties=dict(x)) for x in locations
            ]

            return HttpResponse(geojson.dumps(FeatureCollection(features)))

        return super().get(request)
Ejemplo n.º 38
0
def read_json_string_to_df(json_string: str) -> GeoDataFrame:
    geom_json = geojson.loads(json_string.replace("'", '"'))
    if isinstance(geom_json, dict):
        if geom_json["type"] == "FeatureCollection":
            # st.info("Reading FeatureCollection ...")
            fc = geom_json
        if geom_json["type"] == "Feature":
            # st.info("Reading Feature ...")
            fc = FeatureCollection(features=[geom_json])
        elif geom_json["type"] in [
            "Polygon",
            "MultiPolygon",
            "Point",
            "MultiPoint",
            "LineString",
            "MultiLineString",
            "LinearRing",
        ]:
            # st.info("Reading Geometry ...")
            fc = FeatureCollection([Feature(geometry=geom_json)])
    elif isinstance(geom_json, list):
        if len(geom_json) == 4 and isinstance(geom_json[0], float):
            # st.info("Reading bbox (Polygon) ...")
            geometry = mapping(box(*geom_json))
            fc = FeatureCollection([Feature(geometry=geometry)])
        elif isinstance(geom_json[0], list) and isinstance(geom_json[0][0], list):
            # st.info("Reading Coordinates (Polygon)...")
            geometry = {"type": "Polygon", "coordinates": geom_json}
            fc = FeatureCollection([Feature(geometry=geometry)])
    else:
        st.error(
            "Could not read json string! Check missing brackets! Only FeatureCollection, "
            "Feature, Geometry, Coordinates, or bbox are allowed!"
        )
        st.stop()
    df = gpd.GeoDataFrame.from_features(fc, crs="EPSG:4326")
    return df
Ejemplo n.º 39
0
def save_supplement(public_id, df, output_dir, category, name, props=None):
    ''' Save a geopandas dataframe to geojson file.
    '''
    logger_name = __name__
    logger = logging.getLogger(logger_name)
    event_dir = event_dir_from_publicid(public_id)

    supp_map = get_supplement_map()
    if category not in supp_map.keys():
        logger.error(
            'The category %s was not found in the available categories.',
            category)
        return

    supplement_sub_dir = supp_map[category][name]['subdir']
    supplement_name = supp_map[category][name]['name']
    output_dir = os.path.join(output_dir, event_dir, supplement_sub_dir)

    fc = geojson.loads(df.to_json())

    # Add foreign members to the feature collection.
    fc.name = supplement_name
    fc.properties = {
        'public_id': public_id,
        'computation_time': isoformat_tz(obspy.UTCDateTime())
    }

    if props is not None:
        fc.properties.update(props)

    filepath = write_geojson_file(fc,
                                  category=category,
                                  name=supplement_name,
                                  prefix=public_id,
                                  output_dir=output_dir)

    return filepath
Ejemplo n.º 40
0
def validate_geojson_point(obj):
    """
  Validate that input object is a valid json and has valid GeoJSON format for a "Point".
  Required Arg (json|dict): GeoJSON Point object (we can handle json-str or dict)
  Raises: InvalidGeoJson() if object does not meet criteria for valid GeoJSON Point
  Returns: dict representation of GeoJSON Point 
  """

    d_point = None

    ## basic json validation
    try:
        d_point = basic_json_validation(obj)
    except Exception as e:
        raise

    ## GeoJSON Point validation
    point = geojson.dumps(d_point)
    dprint(1, point)
    json_point = geojson.loads(point)
    dprint(1, json_point)

    try:
        point = geojson.Point(json_point)
    except ValueError as e:
        raise InvalidGeoJson("Invalid GeoJSON Point: %s" % e)
    dprint(1, point)

    valid = point.is_valid
    dprint(1, "VALID=%s" % valid)
    if not valid:
        l_errors = point.errors()
        dprint(1, "ERRORS:%s" % l_errors)
        raise InvalidGeoJson("Invalid GeoJSON Point: %s" % str(l_errors))

    return (d_point)
Ejemplo n.º 41
0
def cache_images():
    combined = geojson.loads(readfile('nairobi-combined-schools.geojson'))
    for index, feature in enumerate(combined.features):
        images = []
        large_images = []
        for prop in [
                "osm:image:classroom", "osm:image:compound", "osm:image:other",
                "osm:image:outside"
        ]:
            if prop in feature['properties']:
                #cache_image(feature['properties']['osm:id'], feature['properties']['osm:name'], prop, feature['properties'][prop])
                image = get_image_cache(feature['properties']['osm:id'], prop,
                                        feature['properties'][prop], 'med')
                images.append(image)
                image = get_image_cache(feature['properties']['osm:id'], prop,
                                        feature['properties'][prop], 'large')
                large_images.append(image)
        if len(images) > 0:
            combined.features[index]['properties']['osm:images'] = ','.join(
                images)
            combined.features[index]['properties'][
                'osm:large_images'] = ','.join(large_images)
    dump = geojson.dumps(combined, sort_keys=True, indent=2)
    writefile('nairobi-combined-schools.geojson', dump)
Ejemplo n.º 42
0
def GetLipasData(typecode, typename):
    """
    This function fetches LIPAS data from WFS and sets its crs. LIPAS data is returned to the user with simplified attributes; id, name of the sport place in Finnish and Swedish, type code and type name in Finnish. 
    Arguments: First argument is 4 digit typecode of the sport facility and second is the typename of the sport facility in Finnish. Exhaustive list of these can be found from data/Codes_LIPAS.csv.
    """
    # Fetching data from WFS using requests, in json format, using bounding box over the helsinki area
    r = requests.get(
        """http://lipas.cc.jyu.fi/geoserver/lipas/ows?service=wfs&version=2.0.0&request=GetFeature&typeNames=lipas:lipas_"""
        + typecode + """_""" + typename +
        """&bbox=361500.0001438780454919,6665250.0001345984637737,403750.0001343561452813,6698000.0001281434670091,EPSG:3067&outputFormat=json"""
    )

    # Creating GeoDataFrame from geojson
    lipas_data = gpd.GeoDataFrame.from_features(geojson.loads(r.content))

    # Removing unnecessary attributes from lipas_data
    lipas_data = lipas_data[[
        "geometry", "id", "nimi_fi", "nimi_se", "tyyppikoodi", "tyyppi_nimi_fi"
    ]]

    # Define crs for lipas_data
    lipas_data.crs = {'init': 'epsg:3067'}

    return lipas_data
Ejemplo n.º 43
0
def getmapminerfeatures(request):
    """
    End-point to retrieve geographical features
    from regions of interest.

    Parameters
    ----------
    request : HttpRequest
        An HTTP 'POST' request with:
        - regions of interest (GeoJSON)
        - Map miner Id (str)
        - Feature Name (str)
        
        E.g.:

        {
            'mapMinerId': 'osm',
            'featureName': 'streets'
            'regions': <GeoJSON>
        }

    Returns
    -------
    JsonResponse: GeoJSON
        The response will be a GeoJSON object
        with the requested feature collected,
        from the Map Miner selected, inside
        the region(s) of interest.
    """
    jsondata = request.data
    mapMinerId = jsondata["mapMinerId"]
    query = jsondata["featureName"]
    region = geojson.loads(jsondata["regions"])
    
    ret = mapMinerManager.requestQueryToMapMiner(mapMinerId, query, region)
    return JsonResponse(ret, CustomJSONEncoder)
Ejemplo n.º 44
0
def _buffer(json_geometry: str, distance: int) -> WKBElement:
    """assumes source crs is 4326 and projected crs to use is 3857"""

    geo_json_obj = geojson.loads(json_geometry)
    shapely_geo_json = geometry.shape(geo_json_obj)
    # project to create buffer
    project_in = pyproj.Transformer.from_proj(
        pyproj.Proj(init='epsg:4326'),  # source
        pyproj.Proj(init='epsg:3857'))  # destination
    shapely_geo_json_projected = transform(project_in.transform,
                                           shapely_geo_json)
    # buffer
    shapely_geojson_buffer_project = shapely_geo_json_projected.buffer(
        distance)
    # project back
    project_out = pyproj.Transformer.from_proj(
        pyproj.Proj(init='epsg:3857'),  # source
        pyproj.Proj(init='epsg:4326'))  # destination
    shapely_geo_json_buffered = transform(
        project_out.transform, shapely_geojson_buffer_project)
    # convert to geoalchemy element
    geoalchemy_element = geoalchemy2.shape.from_shape(
        shapely_geo_json_buffered)
    return geoalchemy_element
    def execute(trial=False):
        '''Retrieve some data sets (not using the API here for the sake of simplicity).'''
        startTime = datetime.datetime.now()

        # Set up the database connection.
        client = dml.pymongo.MongoClient()
        repo = client.repo
        repo.authenticate('colinstu', 'colinstu')
        url = 'https://mapc-admin.carto.com/api/v2/sql?q=SELECT%20a.seq_id%2Ca.muni_id%2Ca.municipal%2Ca.countyname%2Ca.areaname%2Ca.fy_year%2Ca.median%2Ca.il_50_1%2Ca.il_50_2%2Ca.il_50_3%2Ca.il_50_4%2Ca.il_50_5%2Ca.il_50_6%2Ca.il_50_7%2Ca.il_50_8%2Ca.il_30_1%2Ca.il_30_2%2Ca.il_30_3%2Ca.il_30_4%2Ca.il_30_5%2Ca.il_30_6%2Ca.il_30_7%2Ca.il_30_8%2Ca.il_80_1%2Ca.il_80_2%2Ca.il_80_3%2Ca.il_80_4%2Ca.il_80_5%2Ca.il_80_6%2Ca.il_80_7%2Ca.il_80_8%2C%20b.the_geom%2C%20b.the_geom_webmercator%20%20FROM%20hous_section8_income_limits_by_year_m%20a%20%20INNER%20JOIN%20ma_municipalities%20b%20ON%20a.muni_id%20%3D%20b.muni_id%20WHERE%20a.fy_year%20IN%20(%272017%27)&format=geojson&filename=hous_section8_income_limits_by_year_m'
        response = urllib.request.urlopen(url).read().decode("utf-8")

        r = geojson.loads(response)
        s = geojson.dumps(r, sort_keys=True, indent=2)
        repo.dropCollection("HUDincome")
        repo.createCollection("HUDincome")
        repo['colinstu.HUDincome'].insert_many(r['features'])
        repo['colinstu.HUDincome'].metadata({'complete': True})
        print(repo['colinstu.HUDincome'].metadata())

        repo.logout()

        endTime = datetime.datetime.now()

        return {"start": startTime, "end": endTime}
    def export_geojson(self, file, **kwargs):

        path = os.path.abspath(file)

        fh = open(path, 'r')

        if kwargs.get('line_delimited', False):

            for ln in fh.readlines():

                data = geojson.loads(ln)

                if not data:
                    logging.warning("failed to parse line")
                    logging.debug(ln)
                    continue

                self.export_feature(data)

        else:

            try:
                data = geojson.load(fh)
            except Exception, e:
                logging.error("Failed to load JSON for %s, because" %
                              (path, e))
                return False

            features = data.get('features', [])

            if len(features) == 0:
                logging.warning("%s has not features" % path)
                return False

            for f in features:
                self.export_feature(f, **kwargs)
Ejemplo n.º 47
0
def subset_s2(path, file, aoi):
    # Read Data________________________________________________________________
    print("SUBSET: Read Product...")
    sentinel = ProductIO.readProduct(path+file)
    print("SUBSET: Done reading!")
    # Get Band Names and print info
    name = sentinel.getName()
    print("SUBSET: Image ID:        %s" % name)
    band_names = sentinel.getBandNames()
    print("SUBSET: Bands:       %s" % (list(band_names)))
    # Preprocessing ___________________________________________________________
    # Resampling
    parameters = HashMap()
    parameters.put('targetResolution', 10)
    print("SUBSET: resample target resolution: 10m")
    product_resample = snappy.GPF.createProduct('Resample', parameters, sentinel)
    # Geojson to wkt
    with open(aoi) as f:
            gjson = json.load(f)       
    for feature in gjson['features']:
        polygon = (feature['geometry'])
    str_poly = json.dumps(polygon)
    gjson_poly = geojson.loads(str_poly)
    poly_shp = shape(gjson_poly)
    wkt = poly_shp.wkt
    # Subset
    geom = WKTReader().read(wkt)
    op = SubsetOp()
    op.setSourceProduct(product_resample)
    op.setGeoRegion(geom)
    product_sub = op.getTargetProduct()            
    # Write Data_______________________________________________________            
    print("SUBSET: Writing subset.")
    subset = path + name + '_subset_'
    ProductIO.writeProduct(product_sub, subset, "BEAM-DIMAP")    
    print("SUBSET: Done and saved in %s" % path)
Ejemplo n.º 48
0
def clean_osm(file):
    osm = geojson.loads(readfile(file))

    for feature in osm.features:
        properties = {}
        #properties = feature.properties
        for osm_property in feature.properties['tags'].keys():
            properties["osm:" +
                       osm_property] = feature.properties['tags'][osm_property]
        properties["osm:_user"] = feature.properties['meta']['user']
        properties["osm:_timestamp"] = datetime.strptime(
            feature.properties['meta']['timestamp'],
            '%Y-%m-%dT%H:%M:%SZ').strftime('%Y-%m-%d')
        properties["osm:id"] = feature['id']  #TODO change to "_id"?
        properties["osm:location"] = os.path.splitext(
            os.path.basename(file))[0].split('-')[0]

        feature.properties = properties
        for prop in feature.properties.keys():
            if prop.startswith('osm:polling_station:'):
                feature.properties.pop(prop, None)

    dump = geojson.dumps(osm, sort_keys=True, indent=2)
    writefile(file, dump)
Ejemplo n.º 49
0
 def _get_details_at_map(self, place):
     soup = self._get_soup(place['map'])
     script = soup.find(string=re.compile('var points'))
     pattern = r"""L.marker\(pos,\{title : "(.*)", icon : stateIcons\[(\d)\]\}\).addTo\(map\).bindPopup\('<h2>.*</h2><img src="(.*)" height="100" /><p>GPS: (.*), (.*)</p>'\);"""
     matches = re.findall(pattern, script)
     markers = []
     for match in matches:
         marker = {'title': match[0],
                   'image': 'https://www.kafelanka.cz' + match[2],
                   'latitude': float(match[3]),
                   'longitude': float(match[4]),
                   'accessibility': self.accessibilities[int(match[1]) - 1]}
         markers.append(marker)
     place['image'] = markers[0]['image']
     place['latitude'] = markers[0]['latitude']
     place['longitude'] = markers[0]['longitude']
     place['accessibility'] = markers[0]['accessibility']
     place['markers'] = markers
     pattern = r'L.geoJSON\(([\s\S]*)\).addTo\(map\);'
     match = re.search(pattern, script)
     if match:
         feature_collection = geojson.loads(match.group(1))
         place['features'] = feature_collection['features']
     return place
Ejemplo n.º 50
0
    def get_masked_latlongs(band_tif_file: str, geo_json: json,
                            no_data_value: int) -> array:
        '''
        Retruns the latitudes and lognitudes of the pixel(inside geo_json) centroids
        :param str band_tif_file: tiff file path
        :param json geo_json: geo json of the area of interest
        :param str no_data_value: no data value
        :return: returns latitudes and longitudes of the given band pixel centroids after masking given geo_json
        '''
        with rasterio.open(band_tif_file) as src:
            shape_jsons = []
            shape_jsons.append(geojson.loads(geo_json))
            masked_band, out_transform = rasterio.mask.mask(
                dataset=src,
                shapes=shape_jsons,
                crop=True,
                nodata=no_data_value)

            # All rows and columns
            cols, rows = np.meshgrid(np.arange(masked_band.shape[2]),
                                     np.arange(masked_band.shape[1]))

            # Flatten all rows, cols, masked_band
            rows = rows.flatten()
            cols = cols.flatten()
            masked_band = masked_band.flatten()

            # Add half the cell size to get pixel centroid(latitude and longitude)
            (upper_left_x, x_size, x_rotation, upper_left_y, y_rotation,
             y_size) = out_transform.to_gdal()
            lng = cols * x_size + upper_left_x + (x_size / 2)
            lat = rows * y_size + upper_left_y + (y_size / 2)
            extent_lng_lat = np.column_stack([lng, lat])
            farm_lng_lat = extent_lng_lat[masked_band != no_data_value]

        return (extent_lng_lat, farm_lng_lat)
Ejemplo n.º 51
0
 async def _fetch(self,
                  method: str = "GET",
                  headers=None,
                  params=None) -> Tuple[str, Optional[FeatureCollection]]:
     """Fetch GeoJSON data from external source."""
     try:
         timeout = aiohttp.ClientTimeout(
             total=self._client_session_timeout())
         async with self._websession.request(method,
                                             self._url,
                                             headers=headers,
                                             params=params,
                                             timeout=timeout) as response:
             try:
                 response.raise_for_status()
                 text = await response.text()
                 feature_collection = geojson.loads(text)
                 return UPDATE_OK, feature_collection
             except client_exceptions.ClientError as client_error:
                 _LOGGER.warning("Fetching data from %s failed with %s",
                                 self._url, client_error)
                 return UPDATE_ERROR, None
             except JSONDecodeError as decode_ex:
                 _LOGGER.warning("Unable to parse JSON from %s: %s",
                                 self._url, decode_ex)
                 return UPDATE_ERROR, None
     except client_exceptions.ClientError as client_error:
         _LOGGER.warning(
             "Requesting data from %s failed with "
             "client error: %s", self._url, client_error)
         return UPDATE_ERROR, None
     except asyncio.TimeoutError:
         _LOGGER.warning(
             "Requesting data from %s failed with "
             "timeout error", self._url)
         return UPDATE_ERROR, None
Ejemplo n.º 52
0
    def POST(self):
        # Read POST body as JSON (TODO: validate Content-Type is correct first)
        data = geojson.loads(web.data())

        # Since this endpoint returns application/json, let's set the right header
        web.header('Content-Type', 'application/json')
        web.header('Access-Control-Allow-Origin', '*')
        web.header('Access-Control-Allow-Methods', 'POST')

        # Fetch all properties within distance specified from point specified
        query_db(
            """
            SELECT id, ST_X(geocode_geo::geometry) AS longitude, ST_Y(geocode_geo::geometry) AS latitude
            FROM properties
            WHERE ST_Distance_Sphere(geocode_geo::geometry, ST_MakePoint(%s, %s)) <= %s
            """, [
                data.geometry.coordinates[0], data.geometry.coordinates[1],
                data["x-distance"]
            ])

        return json.dumps([{
            'propertyId': row[0],
            'coordinates': [row[1], row[2]]
        } for row in cur.fetchall()])
Ejemplo n.º 53
0
def download(request):
    if request.method == 'POST':
        data = json.loads(request.body)
        footprint = geojson_to_wkt(geojson.loads(data['geoJson']))
        username = config.username  # ask ITC for the username and password
        password = config.password
        api = SentinelAPI(username, password,
                          "https://apihub.copernicus.eu/apihub/"
                          )  # fill with SMARTSeeds user and password
        tanggal = '[{0} TO {1}]'.format(data['dateFrom'].replace('.000Z', 'Z'),
                                        data['dateTo'].replace('.000Z', 'Z'))
        print(tanggal)
        products = api.query(footprint,
                             producttype=config.producttype,
                             orbitdirection=config.orbitdirection,
                             platformname='Sentinel-1',
                             date=tanggal)
        #menyimpan di folder sentineldata
        dirpath = os.getcwd() + '/sentineldata'
        for product in products:
            try:
                api.download(product, directory_path=dirpath, checksum=True)
            except:
                continue
        for item in os.listdir(dirpath):
            if item.endswith(".incomplete"):
                os.remove(os.path.join(dirpath, item))
        #fungsi notifikasi
        email = send_mail(  #libary django untuk mengirim email
            'Your Download was successful!',  #subject email
            'Terima kasih sudah menggunakan aplikasi webgis data yang anda unduh sudah masuk kedalam sistem website!',  #isi email
            settings.EMAIL_HOST_USER,  #email host pengirim notifikasi
            [request.user.email],  #email penerima notifikasi
            fail_silently=False,
        )
        return HttpResponse(request.body)
Ejemplo n.º 54
0
def read_geojson(geojson_fn):
    with open(geojson_fn, encoding="utf-8") as src:
        gj = geojson.loads(src.read())

    polys = []
    for ind, feature in enumerate(gj.features):
        if feature['geometry']['type'] == 'MultiPolygon':
            for pol in feature['geometry']['coordinates']:
                if len(pol) == 1:
                    polys.append(Polygon(pol[0], holes = None)) 
                else:
                    holes = []
                    for hole in pol[1:]:
                        holes.append(hole) 
                    polys.append(Polygon(pol[0], holes = holes)) 
        else:
            if len(feature['geometry']['coordinates']) == 1:
                    polys.append(Polygon(feature['geometry']['coordinates'][0], holes = None)) 
            else:
                holes = []
                for hole in feature['geometry']['coordinates'][1:]:
                    holes.append(hole) #[0]
                polys.append(Polygon(feature['geometry']['coordinates'][0], holes = holes)) 
    return polys
Ejemplo n.º 55
0
def polygon_add(request):

    response = {}

    if request.is_ajax() and request.method == 'POST':
        info = request.POST

        year = info.get('year')
        source = info.get('source')
        layer = info.get('layer')
        polygon = info.get('polygon')
        polygon = geojson.loads(polygon)
        geom = shape(polygon)

        Session = GloVli.get_persistent_store_database('layers', as_sessionmaker=True)
        session = Session()
        point_obj = Polygons(layer_name=layer, year=year, source=source, approved=False, geometry=geom.wkt)
        session.add(point_obj)
        session.commit()
        session.close()

        response = {"success": "success"}

        return JsonResponse(response)
Ejemplo n.º 56
0
def geojson_to_polygons(js_):
    """Convert the geojson into Shapely Polygons.
    Adapted from: https://gist.github.com/drmalex07/5a54fc4f1db06a66679e

    :param js_: geojson with segments as Polygons
    :return: list of Shapely Polygons of segments"""

    polys = []
    for i, feat in enumerate(js_['features']):
        o = {
            "coordinates": feat['geometry']['coordinates'],
            "type": feat['geometry']['type']
        }
        s = json.dumps(o)

        # convert to geojson.geometry.Polygon
        g1 = geojson.loads(s)

        # covert to shapely.geometry.polygon.Polygon
        g2 = shape(g1)

        polys.append(g2)

    return polys
Ejemplo n.º 57
0
    def execute(trial = False, log=False):
        '''Retrieve existing bike network data.'''
        startTime = datetime.datetime.now()

        # Set up the database connection.
        client = dml.pymongo.MongoClient()
        repo = client.repo
        repo.authenticate('bmroach', 'bmroach')
        
        # Do retrieving of data
        repo.dropCollection("bike_network")
        repo.createCollection("bike_network")    
        
        url = 'http://bostonopendata-boston.opendata.arcgis.com/datasets/d02c9d2003af455fbc37f550cc53d3a4_0.geojson'
        response = urllib.request.urlopen(url).read().decode("utf-8")
        gj = geojson.loads(response)
        geoDict = dict(gj)
        geoList = geoDict['features']
        
        repo['bmroach.bike_network'].insert_many( geoList )
        repo['bmroach.bike_network'].metadata({'complete':True})  
        repo.logout()
        endTime = datetime.datetime.now()
        return {"start":startTime, "end":endTime}
Ejemplo n.º 58
0
def get_coordinates(geojson_file=None, tile=None, feature_number=0):
    """Return the coordinates of a polygon of a GeoJSON file.

    Parameters
    ----------
    geojson_file : str
        location of GeoJSON file_path
    tile : str
        Sentinel-2 tileID (can be given instead of geojson file). But if geojson_file is given, tile will be ignored.
    feature_number : int
        Feature to extract polygon from (in case of MultiPolygon
        FeatureCollection), defaults to first Feature

    Returns
    -------
    string of comma separated coordinate tuples (lon, lat) for polygons or a single (lat, long) for points (if tile is given) to be used by SentinelAPI
    """
    assert (geojson_file is not None) | (
        tile is not None), "Either geojson_file or tile must be provided."

    if geojson_file is not None:
        geojson_obj = geojson.loads(open(geojson_file, 'r').read())
        coordinates = geojson_obj['features'][feature_number]['geometry'][
            'coordinates'][0]
        # precision of 7 decimals equals 1mm at the equator
        coordinates = ['%.7f %.7f' % tuple(coord) for coord in coordinates]
    elif tile is not None:
        assert hasPandas, "pandas must be installed to use 'tile' option."
        csv_file = "{0}/data/tile_centroids.csv".format(
            dirname(realpath(__file__)))
        tile_centroids = pd.read_csv(csv_file)
        tile_subset = tile_centroids[tile_centroids['tile'] == tile]
        coordinates = [float(tile_subset['lat']), float(tile_subset['lon'])]
        coordinates = ['%.7f' % coord for coord in coordinates]

    return ','.join(coordinates)
Ejemplo n.º 59
0
    def get_masked_band(band_tif_file: str, geo_json: json,
                        no_data_value: int) -> array:
        '''
        Masks the pixels outside the given boundary with no_data_value
        :param str band_tif_file: tiff file path
        :param json geo_json: geo json of the area of interest
        :param str no_data_value: no data value
        :return: returns masked band after masking given geo_json
        '''
        masked_band = None
        with rasterio.open(band_tif_file) as src:
            if src.count > 1:
                raise Exception('Incorrect number of bands in tif file %d',
                                src.count)
            else:
                shape_jsons = []
                shape_jsons.append(geojson.loads(geo_json))
                masked_band, out_transform = rasterio.mask.mask(
                    dataset=src,
                    shapes=shape_jsons,
                    crop=True,
                    nodata=no_data_value)

        return masked_band
Ejemplo n.º 60
0
def make_geojson(request, entry):
    map_geojson = serialize(
        "geojson",
        [entry],
        geometry_field="census_blocks_polygon",
        fields=(
            "entry_name",
            "cultural_interests",
            "economic_interests",
            "comm_activities",
            "other_considerations",
        ),
    )
    gj = geojson.loads(map_geojson)
    gj = rewind(gj)
    del gj["crs"]
    user_map = entry
    if user_map.organization:
        gj["features"][0]["properties"][
            "organization"
        ] = user_map.organization.name
    if user_map.drive:
        gj["features"][0]["properties"]["drive"] = user_map.drive.name
    if request.user.is_authenticated:
        is_org_leader = user_map.organization and (
            request.user.is_org_admin(user_map.organization_id)
        )
        if is_org_leader or request.user == user_map.user:
            gj["features"][0]["properties"]["author_name"] = user_map.user_name
            for a in Address.objects.filter(entry=user_map):
                addy = (
                    a.street + " " + a.city + ", " + a.state + " " + a.zipcode
                )
                gj["features"][0]["properties"]["address"] = addy
    feature = gj["features"][0]
    return feature