Example #1
0
def get_proj_dict(dem_dataset, epsg):
    dem_transform = {'upper_left_x': dem_dataset.GetGeoTransform()[0],
                     'x_res_m' : dem_dataset.GetGeoTransform()[1],
                     'x_rotation': dem_dataset.GetGeoTransform()[2],
                     'upper_left_y': dem_dataset.GetGeoTransform()[3],
                     'y_rotation': dem_dataset.GetGeoTransform()[4],
                     'y_res_m': dem_dataset.GetGeoTransform()[5],
                     'n_cols': dem_dataset.RasterXSize,
                     'n_rows': dem_dataset.RasterYSize}
    
    dem_transform['y_res_m'] *= -1
    dem_transform['east_min'] = dem_transform['upper_left_x']

    dem_transform['east_max'] = (dem_transform['x_res_m'] 
                                 * dem_transform['n_cols']
                                 + dem_transform['east_min'])
    
    dem_transform['north_max'] = dem_transform['upper_left_y']
    
    dem_transform['north_min'] = (-1 * dem_transform['y_res_m'] 
                                  * dem_transform['n_rows']
                                  + dem_transform['north_max'])

    wgs84 = pj.Proj(init='epsg:4326')
    utm = pj.Proj(init='epsg:{}'.format(epsg))
    
    dem_transform['lon_min'], dem_transform['lat_min'] = pj.transform(utm, wgs84,
                                                    dem_transform['east_min'], 
                                                    dem_transform['north_min'])
    
    dem_transform['lon_max'], dem_transform['lat_max'] = pj.transform(utm, wgs84,
                                                    dem_transform['east_max'], 
                                                    dem_transform['north_max'])
    return dem_transform
Example #2
0
def getDims(dims):
	inProj = Proj(init='epsg:4326') # this is lon/lat
	outProj = Proj(init='epsg:3857') # 900913
	coords = dims.split(" ")
	x0, y0 = transform(inProj, outProj, float(coords[0]), float(coords[1]))
	x1, y1 = transform(inProj, outProj, float(coords[2]), float(coords[3]))
	return str(x0) + " " + str(y0) + " " + str(x1) + " " + str(y1) # this is LCC
Example #3
0
File: geo.py Project: gem/oq-mbt
def get_idx_points_inside_polygon(plon, plat, poly_lon, poly_lat, 
                                  pnt_idxs, buff_distance=10.):
    """
    :parameter plon:
        Points longitude list
    :parameter plat: 
        Points latitude list
    :parameter poly_lon:
        A list containing the longitude coordinates of the polygon vertexes
    :parameter poly_lat:
        A list containing the latitude coordinates of the polygon vertexes
    :returns: 
        Indexes of the points inside the polygon
    """
    selected_idx = []
    # Fix the projections
    inProj = Proj(init='epsg:4326')
    outProj = Proj(init='epsg:3857')
    # Create polygon
    poly_xy = []
    for lo, la in zip(poly_lon, poly_lat):
        x, y = transform(inProj, outProj, lo, la)
        poly_xy.append((x,y))
    polygon = shapely.geometry.Polygon(poly_xy)    
    # Add buffer
    buff = polygon.buffer(buff_distance)
    # Find points inside
    for lo, la, jjj in zip(plon, plat, pnt_idxs):
        x, y = transform(inProj, outProj, lo, la)
        point = shapely.geometry.Point((x,y))
        if point.within(buff):
            selected_idx.append(jjj)
    return selected_idx
Example #4
0
def centroid_planar(longlat_pairs):
    """
    Centroid by projecting onto a plane. Inaccurate over long distances.
    """
    #
    # projections prep
    from pyproj import Proj, transform
    p_geodetic = Proj(proj='latlong')
    p_flat = Proj('+init=EPSG:27700')  # uk OS

    #
    # convert
    N = len(longlat_pairs)

    cartesians = np.zeros([N, 2])  # N-high
    for indx, pair in enumerate(longlat_pairs):
        lng, lat = map(float, pair)
        x, y = transform(p_geodetic, p_flat, lng, lat)
        cartesians[indx,:] = (x, y)

    x, y = np.average(cartesians, axis=0)

    lng, lat = transform(p_flat, p_geodetic, x, y)

    return (lng, lat)
Example #5
0
	def indices(self, srs, bbox, resolution):
		"""buggiest method ever!"""
		srs = srs.strip().lower()

		if srs != self.srs:
			# do reprojection
			proj = Proj(init=srs)
			(min_x, min_y) = transform(proj, self.proj, bbox.min_x, bbox.min_y)
			(max_x, max_y) = transform(proj, self.proj, bbox.max_x, bbox.max_y)
			bbox = Bbox(min_x, min_y, max_x, max_y)

		# completely outside boundary?
		outside_x = bbox.min_x >= self.bbox.max_x or bbox.max_x <= self.bbox.min_x
		outside_y = bbox.min_y >= self.bbox.max_y or bbox.max_y <= self.bbox.min_y
		if outside_x or outside_y:
			return None

		# truncate bbox
		min_x = max(bbox.min_x, self.bbox.min_x)
		max_x = min(bbox.max_x, self.bbox.max_x)
		min_y = max(bbox.min_y, self.bbox.min_y)
		max_y = min(bbox.max_y, self.bbox.max_y)

		cellsize_x = float(self.cellsize_x(resolution))
		cellsize_y = float(self.cellsize_y(resolution))

		# Note: upside-down rows compared to coordinates
		
		row_from = floor( (self.bbox.max_y - max_y) / cellsize_y )
		row_to   = floor( (self.bbox.max_y - min_y) / cellsize_y + 1.0 )
		col_from = floor( (min_x - self.bbox.min_x) / cellsize_x )
		col_to   = floor( (max_x - self.bbox.min_x) / cellsize_x + 1.0 )

		return (int(row_from), int(row_to), int(col_from), int(col_to))
Example #6
0
def get_map_geo():
    #przychodza w EPSG:3857
    if request.method == "GET":
        print "Heeelo"
        p3857 = pyproj.Proj(init="EPSG:3857")
        p4326 = pyproj.Proj(init="EPSG:4326")


        _long_min = request.args.get('long_min', None)
        _lat_min = request.args.get('lat_min', None)
        #_geo_diff = request.args.get('geo_diff', geo_diff)
        _long_max = request.args.get('long_max', None)
        _lat_max = request.args.get('lat_max', None)
        logger.debug(_long_min, _lat_min,)
        _long_min, _lat_min = pyproj.transform(p3857, p4326, _long_min, _lat_min)
        #logger.debug(str(_long_min), str(_lat_min), str(_long_max), str(_lat_max))
        _long_max, _lat_max = pyproj.transform(p3857, p4326, _long_max, _lat_max)
        print "bede preparowal"
        _wms_params = prepare_params_to_request_4326(_lat_min, _long_min, _lat_max, _long_max)
        print "spreparowalem " + str(_wms_params)
        response = get_map_image_in_b64(server_topo, _wms_params, "topo.jpg")
        print "przygotowuje odpowiedz"
        return Response(status=200)
    else:
        return Response(status=400)
Example #7
0
File: gps.py Project: Moouuzi/gimli
def GKtoUTM(R, H=None, zone=32, gk=None):
    """Transforms any Gauss-Krueger to UTM autodetect GK zone from offset."""
    if gk is None:

        if H is None:
            rr = R[0][0]
        else:
            if isinstance(R, list) or isinstance(R, tuple):
                rr = R[0]
            else:
                rr = R

        gkzone = int(floor(rr * 1e-6))
        print(gkzone)

        if gkzone <= 0 or gkzone >= 5:
            print("cannot detect valid GK zone")

        gk = Proj(init="epsg:"+str(31464+gkzone))

    if H is None:  # two-column matrix
        lon, lat = transform(gk, wgs84, R[0], R[1])
    else:
        lon, lat = transform(gk, wgs84, R, H)

    utm = Proj(proj='utm', zone=zone, ellps='WGS84')  # UTM

    return utm(lon, lat)
	def test_indices(self):
		"""docstring for test_indices"""
		srs = 'epsg:25832'
		bbox = self.bbox
		self.assertEqual(self.ts.indices(srs=srs, bbox=bbox, resolution=1), (0,4,0,8))
		# lower left
		bbox = Bbox(500000, 5000000, 500999, 5000487)
		self.assertEqual(self.ts.indices(srs=srs, bbox=bbox, resolution=1), (2,4,0,4))
		# single cell
		bbox = Bbox(500010, 5000900, 500020, 5000910)
		self.assertEqual(self.ts.indices(srs=srs, bbox=bbox, resolution=1), (0,1,0,1))
		# outside
		bbox = Bbox(200000, 1000000, 300000, 2000000)
		self.assertEqual(self.ts.indices(srs=srs, bbox=bbox, resolution=1), None)
		# trunc
		bbox = Bbox(200000, 1000000, 700000, 7000000)
		self.assertEqual(self.ts.indices(srs=srs, bbox=bbox, resolution=1), (0,4,0,8))
		# reproject
		srs = 'epsg:4326'		
		utm = proj.Proj(init='epsg:25832')
		geo = proj.Proj(init='epsg:4326')
		min_x, min_y = proj.transform(utm, geo, 500010, 5000900)
		max_x, max_y = proj.transform(utm, geo, 500020, 5000910)
		bbox = Bbox(min_x, min_y, max_x, max_y)
		print "Bbox: %f, %f, %f, %f, srs: %s" % (bbox.min_x, bbox.min_y, bbox.max_x, bbox.max_y, srs)
		self.assertEqual(self.ts.indices(srs=srs, bbox=bbox, resolution=1), (0,1,0,1))
Example #9
0
def distance(x1, y1, x2, y2):
    x1, y1 = transform(wgs84_projection,
        metric_projection, float(x1), float(y1), radians=False)
    x2, y2 = transform(wgs84_projection,
        metric_projection, float(x2), float(y2), radians=False)
    #print x1, y1, x2, y2
    return Point(x1, y1).distance(Point(x2, y2))
Example #10
0
def get_extrema(data,**kwargs):
	transform = False
	for key,value in kwargs.iteritems():
		if key == 'transform':
			transform = value
	north = data.top
	south = data.bottom
	west = data.left
	east = data.right

	extrema = {'n':north,'s':south,'w':west,'e':east}

	# newcorners
	ur_point = [extrema['e'],extrema['n']]
	ll_point = [extrema['w'],extrema['s']]


	if transform == True:
		p1 = pyproj.Proj(init='epsg:'+str(3857))
		p2 = pyproj.Proj(init='epsg:'+str(4326))

	 	ur_point = pyproj.transform(p1,p2,ur_point[0],ur_point[1])
	 	ll_point = pyproj.transform(p1,p2,ll_point[0],ll_point[1])

	 	print ll_point
	extrema = {'n':ur_point[1],'s':ll_point[1],'w':ll_point[0],'e':ur_point[0]}
	print extrema
	return extrema
Example #11
0
def degreesToMeters(arc):
    projWGS84 = Proj(proj='latlong', datum='WGS84')
    projLV03 = Proj(init='epsg:21781')
    chCenterWGS84 = [8.3, 46.85]
    p1 = transform(projWGS84, projLV03, *chCenterWGS84)
    p2 = transform(projWGS84, projLV03, chCenterWGS84[0] + arc, chCenterWGS84[1])
    return p2[0] - p1[0]
Example #12
0
def get_mbb_and_srs(layerDict):
    """Deprecated, please use get_crs and get_mbb"""
    #This function is unsatisfactory, it should actually be two different functions, one for the MBB and one for the SRS. Let's do that.
    for name in layerDict:
        with fiona.open(layerDict[name]['file']) as s:
            if 'minx' not in locals():
                minx, miny, maxx, maxy = s.bounds
                CRS = s.crs
                #very unclean way to get properly formatted SRS
                vector = ogr.GetDriverByName('ESRI Shapefile')
                src_ds = vector.Open(layerDict[name]['file'])
                src_lyr = src_ds.GetLayer(0)
                srs = osr.SpatialReference()
                srs.ImportFromWkt(src_lyr.GetSpatialRef().__str__())
            elif s.crs == CRS:
                x1, y1, x2, y2 = s.bounds
                if x1 < minx: minx = x1
                if y1 < miny: miny = y1
                if x2 > maxx: maxx = x2
                if y2 > maxy: maxy = y2
            else: #raise NameError('Layer: ' + str(name) + ' is of wrong CRS: ' + str(s.crs) + 'desired CRS: ' + str(CRS))
                x1, y1, x2, y2 = s.bounds
                proj1=pyproj.Proj(s.crs)
                proj2=pyproj.Proj(CRS,preserve_units=True)
                x1, y1 = pyproj.transform(proj1,proj2,x1,y1)
                x2, y2 = pyproj.transform(proj1,proj2,x2,y2)
                if x1 < minx: minx = x1
                if y1 < miny: miny = y1
                if x2 > maxx: maxx = x2
                if y2 > maxy: maxy = y2
    return (minx,miny,maxx,maxy),srs
Example #13
0
def get_image_tile(raster, x, y, z):
    try:
        bound = bounds(x, y, z)

        with rasterio.open(raster) as src:
            x_res, y_res = src.transform[0], src.transform[4]
            p1 = Proj({'init': 'epsg:4326'})
            p2 = Proj(**src.crs)

            # project tile boundaries from lat/lng to source CRS
            tile_ul_proj = transform(p1, p2, bound.west, bound.north)
            tile_lr_proj = transform(p1, p2, bound.east, bound.south)
            # get origin point from the TIF
            tif_ul_proj = (src.bounds.left, src.bounds.top)

            # use the above information to calculate the pixel indices of the window
            top = int((tile_ul_proj[1] - tif_ul_proj[1]) / y_res)
            left = int((tile_ul_proj[0] - tif_ul_proj[0]) / x_res)
            bottom = int((tile_lr_proj[1] - tif_ul_proj[1]) / y_res)
            right = int((tile_lr_proj[0] - tif_ul_proj[0]) / x_res)

            window = ((top, bottom), (left, right))

            # read the first three bands (assumed RGB) of the TIF into an array
            data = np.empty(shape=(3, 256, 256)).astype(src.profile['dtype'])
            for k in (1, 2, 3):
                src.read(k, window=window, out=data[k - 1], boundless=True)

            return Image.fromarray(np.moveaxis(data, 0, -1), mode='RGB')
    except Exception as err:
        raise TileNotFoundError(err)
def tricontourf_canvas(topology, datasetnc, request):
    """
    topology - netcdf topology object
    dataset - netcdf dataset object
    request - original http request
    """
    import wms_handler

    xmin, ymin, xmax, ymax = wms_handler.get_bbox(request)

    #proj = get_pyproj(request)
    #lonmin, latmin = proj(xmin, ymin, inverse=True)
    #lonmax, latmax = porj(xmax, ymax, inverse=True)
    CRS = get_pyproj(request)
    lonmin, latmin = pyproj.transform(CRS, EPSG4326, xmin, ymin)
    lonmax, latmax = pyproj.transform(CRS, EPSG4326, xmax, ymax)
    #logger.info("lonmin, latmin: {0} {1}".format(lonmin, latmin))
    #logger.info("lonmax, latmax: {0} {1}".format(lonmax, latmax))


    #compute triangular subset
    lon = topology.nodes[:,0]
    lat = topology.nodes[:,1]
    latlon_sub_idx = get_lat_lon_subset_idx(topology.nodes[:,0],
                                            topology[:,1],
                                            lonmin,
                                            latmin,
                                            lonmax,
                                            latmax)

    nv_sub_idx = get_nv_subset_idx(topology.faces[:], sub_idx)
Example #15
0
    def project(self, target_projection, edge_points=9):
        """
        target_projection must be a pyproj projection.
        Densifies the edges with edge_points points between corners, and projects all of them.
        Returns the outer bounds of the projected coords.

        Note: beware projection issues when going to projections that don't fully encapsulate the world domain
        (e.g., Web Mercator has singularities above and below latitudes of ~ 85).
        """

        assert self.projection and isinstance(target_projection, Proj)

        if target_projection.srs == self.projection.srs:
            return self.clone()

        if edge_points < 2:
            # use corners only
            x_values, y_values = transform(self.projection, target_projection, [self.xmin, self.xmax], [self.ymin, self.ymax])
            return BBox((x_values[0], y_values[0], x_values[1], y_values[1]), projection=target_projection)

        samples = range(0, edge_points)
        xstep = float(self.xmax-self.xmin)/(edge_points-1)
        ystep = float(self.ymax-self.ymin)/(edge_points-1)
        x_values = []
        y_values = []
        for i, j in product(samples, samples):
            x_values.append(self.xmin + xstep * i)
            y_values.append(self.ymin + ystep * j)
        # TODO: check for bidrectional consistency, as is done in ncserve BoundingBox.project() method
        x_values, y_values = transform(self.projection, target_projection, x_values, y_values)
        return BBox((min(x_values), min(y_values), max(x_values), max(y_values)), target_projection)
Example #16
0
    def getBoundsByAspect(bbList,aspect,projSrc,projDest):
        ''' Return bounds adjusted for aspect ratio '''
        bb = bbList
        bl = pyproj.transform(projSrc,projDest,bb[0],bb[1])
        tr = pyproj.transform(projSrc,projDest,bb[2],bb[3])

        projW = tr[0]-bl[0]
        projH = tr[1]-bl[1]
        projcx = (tr[0]+bl[0])/2
        projcy = (tr[1]+bl[1])/2

        pbb=[0,0,0,0]

        if projW/projH > aspect:
            pbb[0] = bl[0]
            pbb[2] = tr[0]
            pbb[1] = projcy-projW*0.5/aspect
            pbb[3] = projcy+projW*0.5/aspect
        else:
            pbb[1] = bl[1]
            pbb[3] = tr[1]
            pbb[0] = projcx-projH*0.5*aspect
            pbb[2] = projcx+projH*0.5*aspect

        nbl = pyproj.transform(projDest,projSrc,pbb[0],pbb[1])
        ntr = pyproj.transform(projDest,projSrc,pbb[2],pbb[3])

        return [nbl[0],nbl[1],ntr[0],ntr[1]]
Example #17
0
def _transform_polygon(source_prj: pyproj.Proj, target_prj: pyproj.Proj,
                       conservation_ratio: float, polygon: Union[Polygon, MultiLineString]) \
        -> Union[Point, Polygon, MultiLineString]:
    must_reproject = source_prj is not None
    must_pointify = conservation_ratio == 0.0
    must_simplify = 0.0 <= conservation_ratio < 1.0
    if not must_reproject and not must_simplify:
        return polygon
    if must_pointify:
        ring_coords = []
        for ring in polygon:
            ring_coords.extend(ring)
        x = np.array([coord[0] for coord in ring_coords])
        y = np.array([coord[1] for coord in ring_coords])
        px, py = np.zeros(1, dtype=x.dtype), np.zeros(1, dtype=y.dtype)
        pointify_geometry(x, y, px, py)
        if must_reproject:
            px, py = pyproj.transform(source_prj, target_prj, px, py)
        return float(px[0]), float(py[0])
    else:
        transformed_polygon = []
        for ring in polygon:
            x = np.array([coord[0] for coord in ring])
            y = np.array([coord[1] for coord in ring])
            if must_simplify:
                x, y = simplify_geometry(x, y, conservation_ratio)
            if must_reproject:
                x, y = pyproj.transform(source_prj, target_prj, x, y)
            transformed_polygon.append([(float(x), float(y)) for x, y in zip(x, y)])
        return transformed_polygon
Example #18
0
def load_grid(filename, proj_lat_long, proj_meters):
    print "loading:", filename
    grid_params = {}
    execfile(filename, grid_params)
    lon_min = grid_params['lon_min']
    lon_max = grid_params['lon_max']
    lat_min = grid_params['lat_min']
    lat_max = grid_params['lat_max']

    # project from lat-long
    ( x_min, y_min ) = pyproj.transform( proj_lat_long, proj_meters, lon_min, lat_min )
    ( x_max, y_max ) = pyproj.transform( proj_lat_long, proj_meters, lon_max, lat_max )

    grid = np.zeros( (grid_params['num_z'],
                      grid_params['num_lat'],
                      grid_params['num_lon'])
                     , np.double)
    return(grid,
           x_min,
           x_max,
           y_min,
           y_max,
           grid_params['z_min'],
           grid_params['z_max'],
           )
Example #19
0
def convert_points(pts, dst):
    """ Move (translate) points to a different origin point
        Parameters:
            pts -- list of points as WGS84 (lon,lat) pairs
            ref -- new reference point, first element of pts will be moved there
        Returns:
            list of new (lat, lon) coordinates
    """
    origin = pts[0]    

    utm_from = pyproj.Proj("+proj=utm +zone=%d +south +ellps=WGS84 +datum=WGS84 +units=m +no_defs" % utm_zone(origin[0]))
    utm_to = pyproj.Proj("+proj=utm +zone=%d +south +ellps=WGS84 +datum=WGS84 +units=m +no_defs" % utm_zone(dst[0]))
    wgs84 = pyproj.Proj("+init=EPSG:4326")

    pts_utm_from = [pyproj.transform(wgs84, utm_from, *p) for p in pts]

    origin_utm_from = pyproj.transform(wgs84, utm_from, *origin)
    dst_utm_to = pyproj.transform(wgs84, utm_to, *dst)

    pts_utm_to = []
    for p in pts_utm_from:
        x = dst_utm_to[0] + (p[0] - origin_utm_from[0])
        y = dst_utm_to[1] + (p[1] - origin_utm_from[1])
        pts_utm_to.append((x,y))

    return [pyproj.transform(utm_to, wgs84, *p) for p in pts_utm_to]
Example #20
0
    def reproject(self, crsish):
        in_proj = Proj(self.crs)
        coll = self.collection()
        out_schema = coll.schema.copy()
        out_crs = guess_crs(crsish)

        tmpds = self.tempds("reproject_%s" % crsish)
        with fiona.collection(tmpds, "w", "ESRI Shapefile",
                              out_schema, crs=out_crs) as out_collection:
            out_proj = Proj(out_collection.crs)
            for in_feature in coll:
                out_feature = in_feature.copy()

                if in_feature['geometry']['type'] == "Polygon":
                    new_coords = []
                    for ring in in_feature['geometry']['coordinates']:
                        x2, y2 = transform(in_proj, out_proj, *zip(*ring))
                        new_coords.append(zip(x2, y2))
                    out_feature['geometry']['coordinates'] = new_coords

                elif in_feature['geometry']['type'] == "Point":
                    x2, y2 = transform(in_proj, out_proj,
                                       *in_feature['geometry']['coordinates'])
                    out_feature['geometry']['coordinates'] = x2, y2

                out_collection.write(out_feature)

        return Layer(tmpds)
Example #21
0
    def create_circle(self, source, dist=1000, n_segments=20):
        """
        Create a circle around source in a given distance
        and with the given number of segments

        Parameters
        ----------
        source : Point-instance

        dist : float
            the distance around the point

        n_segments : int
            the number of segments of the (nearly) circle

        """
        if source.x is None:
            source_x, source_y = transform(self.p1, self.p2,
                                           source.lon, source.lat)
        else:
            source_x, source_y = source.x, source.y
        angel = np.linspace(0, np.pi*2, n_segments)
        x = source_x + dist * np.cos(angel)
        y = source_y + dist * np.sin(angel)
        lon, lat = transform(self.p2, self.p1, x, y)
        destinations = np.vstack([lon, lat]).T

        return destinations
Example #22
0
def contains(x1, y1, x2, y2, radius, origin1=WGS84, origin2=WGS84, destination=PA_SP_SOUTH):
    '''
    :param x: x coordinate or longitude
    :param y: y coordiante or latitude
    :param radius: radius in miles
    :param projection:
    :return:
    '''
    # project input x1,y1 to PA state plane
    try:
        x, y = pyproj.transform(pyproj.Proj(origin1),
                                pyproj.Proj(destination, preserve_units=True),
                                x1, y1)
        # get circle from first input
        p = Point(x, y)
        circle = p.buffer(radius * MILES)

        # project x2, y2 to same plane
        x, y = pyproj.transform(pyproj.Proj(origin2),
                                pyproj.Proj(destination, preserve_units=True),
                                x2, y2)
        p = Point(x, y)
        return circle.contains(p)
    except:
        return False
Example #23
0
    def saveKML(self, kmlFile):
        """
        Saves a KML template to use with google earth.  Assumes x/y coordinates
        are lat/long, and creates an overlay to display the heatmap within Google
        Earth.

        kmlFile ->  output filename for the KML.
        """
        if self.img is None:
            raise Exception("Must first run heatmap() to generate image file.")

        tilePath = os.path.splitext(kmlFile)[0] + ".png"
        self.img.save(tilePath)

        if self.override:
            ((west, south), (east, north)) = self.area
        else:
            ((west, south), (east, north)) = self._ranges()

        #convert overlay BBOX if required
        if use_pyproj and self.srcepsg is not None and self.srcepsg != 'EPSG:4326':
          source = pyproj.Proj(init=self.srcepsg)
          dest = pyproj.Proj(init='EPSG:4326')
          (east,south) = pyproj.transform(source,dest,east,south)
          (west,north) = pyproj.transform(source,dest,west,north)

        bytes = self.KML % (tilePath, north, south, east, west)
        fh = open(kmlFile, "w")
        fh.write(bytes)
        fh.close()
Example #24
0
    def extent(self):
        """Return extent of the image as a dict with keys minx, maxx,
        miny, maxy, in Google projection."""
        data = gdal.Open(self.filename)
        pixelsx = data.RasterXSize
        pixelsy = data.RasterYSize

        startx, dxx, dyx, starty, dxy, dyy = data.GetGeoTransform()

        endx = startx + (pixelsx - 1) * dxx
        endy = starty - (pixelsy - 1) * dyy

        startx, starty = transform(
            RD_PROJECTION, GOOGLE_PROJECTION, startx, starty)
        endx, endy = transform(
            RD_PROJECTION, GOOGLE_PROJECTION, endx, endy)

        if startx > endx:
            startx, endx = endx, startx
        if starty > endy:
            starty, endy = endy, starty

        return {
            'minx': startx,
            'maxx': endx,
            'miny': starty,
            'maxy': endy,
            }
Example #25
0
 def get_buscar_ruta(self, **kwargs):
     values = json.loads(kwargs['rutas_wp'])
     google = pyproj.Proj("+init=EPSG:3857")
     gps = pyproj.Proj("+init=EPSG:4326")
     start = pyproj.transform(gps, google, values['start']['lng'], values['start']['lat'])
     finish = pyproj.transform(gps, google, values['end']['lng'], values['end']['lat'])
     sql = """SELECT id
         FROM movilidad_sostenible_oferta o
         WHERE ST_DWithin(o.shape, ST_SetSRID(ST_MakePoint(%s, %s), 900913), 500) AND
         ST_DWithin(o.shape, ST_SetSRID(ST_MakePoint(%s, %s), 900913), 500)
     """ # Busca rutas que esten a 500 metros de los puntos origen y destino seleccionados
     params = (start[0], start[1], finish[0], finish[1])
     request.env.cr.execute(sql, params)
     res = request.env.cr.fetchall()
     #print values['start']['lng'], values['start']['lat']
     #print values['end']['lng'], values['end']['lat']
     #print sql
     #print params
     #print res
     rutas_ids = [ i[0] for i in res ]
     rutas_model = request.env['movilidad_sostenible.oferta']
     rutas = rutas_model.browse(rutas_ids)
     #print rutas
     values.update(kwargs=kwargs.items())
     return http.request.render('movilidad_sostenible.lista_rutas_ofertar', {
         'lista_ofertas': rutas,
     })
Example #26
0
def check_grid_consistency(grid1,grid2,proj1,proj2):
    ''' Given two 2D (mesh)grids and their respective projections,
        perform a number of checks to verify their consistency '''

    def print_diffs(xt,yt,x2,y2):
        print 'Total accumulated longitude mismatch:',(xt-x2).sum()
        print 'Total accumulated latitude mismatch:',(yt-y2).sum()
        print 'Average longitudinal grid mismatch:',(xt-x2).mean()
        print 'Average latitudinal mismatch:',(yt-y2).mean()
        print 'Maximum longitudinal grid mismatch:',(xt-x2).max(),np.unravel_index((xt-x2).argmax(),xt.shape)
        print 'Maximum latitudinal mismatch:',(yt-y2).max(),np.unravel_index((yt-y2).argmax(),yt.shape),'\n'
        return

    for grid in ['mass_grid','u_grid','v_grid']:
        print 'Performing transformation on the %s'%grid

        x1,y1 = grid1['mass_grid']
        x2,y2 = grid2['mass_grid']

        # Transform proj1 to proj 2
        print 'Transform proj1 to proj2 (probably LCC to lat/lon)'
        xt,yt = pyproj.transform(proj1,proj2,x1,y1)
        print_diffs(xt,yt,x2,y2)

        # Transform proj2 to proj 1
        print 'Transform proj2 to proj1 (probably lat/lon to LCC)'
        xt,yt = pyproj.transform(proj2,proj1,x2,y2)
        print_diffs(xt,yt,x1,y1)

    return
def get_kml_poly(trans):
    outProj = Proj(init='EPSG:4326')
    inProj = Proj(init='EPSG:3857')

    kml = dict()
    kml['lonUL'], kml['latUL'] = transform(inProj, outProj, trans['lonUL'], trans['latUL'])
    kml['lonUR'], kml['latUR'] = transform(inProj, outProj, trans['lonUR'], trans['latUR'])
    kml['lonLL'], kml['latLL'] = transform(inProj, outProj, trans['lonLL'], trans['latLL'])
    kml['lonLR'], kml['latLR'] = transform(inProj, outProj, trans['lonLR'], trans['latLR'])

    return """
    <Polygon>
      <extrude>1</extrude>
      <altitudeMode>clampToGround</altitudeMode>
      <outerBoundaryIs>
        <LinearRing>
          <coordinates>
            {lonUL},{latUL},0
            {lonUR},{latUR},0
            {lonLR},{latLR},0
            {lonLL},{latLL},0
            {lonUL},{latUL},0
          </coordinates>
        </LinearRing>
      </outerBoundaryIs>
    </Polygon>
    """.format(**kml)
Example #28
0
    def _limit(self, lon, lat, target_cs): # TODO: lat long boundaries are not rectangular
        data_proj = Proj("+init=EPSG:4326")  # WGS84
        target_proj = Proj(target_cs)

        # Find bounding box in ERA projection
        bbox = self.bounding_box
        bb_proj = transform(target_proj, data_proj, bbox[0], bbox[1])
        lon_min, lon_max = min(bb_proj[0]), max(bb_proj[0])
        lat_min, lat_max = min(bb_proj[1]), max(bb_proj[1])
        #print(lon_min,lon_max,lat_min,lat_max)

        # Limit data
        lon_upper = lon >= lon_min
        lon_lower = lon <= lon_max

        lat_upper = lat >= lat_min
        lat_lower = lat <= lat_max

        lon_inds = np.nonzero(lon_upper == lon_lower)[0]
        lat_inds = np.nonzero(lat_upper == lat_lower)[0]
        # Masks
        lon_mask = lon_upper == lon_lower
        lat_mask = lat_upper == lat_lower
        
        #print (lon_inds,lat_inds)
        #print (lon[lon_inds],lat[lat_inds])

        if lon_inds.size == 0:
            raise ERAInterimDataRepositoryError("Bounding box longitudes don't intersect with dataset.")
        if lat_inds.size == 0:
            raise ERAInterimDataRepositoryError("Bounding box latitudes don't intersect with dataset.")

        x, y = transform(data_proj, target_proj, *np.meshgrid(lon[lon_inds], lat[lat_inds]))

        return x, y, (lon_mask, lat_mask), (lon_inds, lat_inds)
Example #29
0
def reproject_cutline_gmerc(src_proj, points):
    if points:
        points = densify_linestring(points)
        points1 = zip(*pyproj.transform(src_proj, proj_gmerc, *zip(*points)))
        points2 = zip(*pyproj.transform(src_proj, proj_gmerc_180, *zip(*points)))
        return points1 if calc_area(points1) <= calc_area(points2) else points2
    return []
Example #30
0
    def _get_projected_extent(self, src_srs, target_srs, edge_points=9):
        """
        Densifies the edges with edge_points points between corners, and projects all of them.
        Returns the outer bounds of the projected coords.
        Geographic latitudes must be bounded to  -85.0511 <= y <= 85.0511 prior to calling this or things will fail!
        """

        srcProj = Proj(init=src_srs) if src_srs.strip().lower().startswith('epsg:') else Proj(str(src_srs))
        targetProj = Proj(init=target_srs) if ':' in target_srs else Proj(str(target_srs))
        if edge_points < 2:  # cannot densify (calculations below will fail), just use corners
            x_values, y_values = transform(srcProj, targetProj, [self.xmin, self.xmax], [self.ymin, self.ymax])
            return x_values[0], y_values[0], x_values[1], y_values[1]

        samples = range(0, edge_points)
        x_diff, y_diff = self.get_dimensions()
        xstep = x_diff/(edge_points-1)
        ystep = y_diff/(edge_points-1)
        x_values = []
        y_values = []
        for i, j in product(samples, samples):
            x_values.append(self.xmin + xstep * i)
            y_values.append(self.ymin + ystep * j)
        # TODO: check for bidrectional consistency, as is done in ncserve BoundingBox.project() method
        x_values, y_values = transform(srcProj, targetProj, x_values, y_values)
        return min(x_values), min(y_values), max(x_values), max(y_values)
Example #31
0
def rocket(thrust_bias: np.ndarray):

    assert len(thrust_bias) == 24, "Bad guide length."

    # Covert ang to rads
    def rad(ang):
        return (ang / 360) * 2 * (3.1415926)

    # air density (simple model based on nasa function online)
    def air_density(alt):
        if alt <= 11000:
            T = 15.04 - (0.00649 * alt)
            p = 101.29 * math.pow((T + 273.1) / 288.08, 5.256)
        elif alt <= 25000:
            T = -56.46
            p = float(22.65 * (math.exp(1.73 - 0.000157 * alt))).real
        else:
            T = -131.21 + (0.00299 * alt)
            p = 2.488 * (((T + 273.1) / 216.6)**-11.388).real
        d = p / (0.2869 * (T + 273.1))
        return d

    def alt(Ex, Ey, Ez):
        ecef = pyproj.Proj(proj='geocent', ellps='WGS84', datum='WGS84')
        lla = pyproj.Proj(proj='latlong', ellps='WGS84', datum='WGS84')
        _, _, alt = pyproj.transform(ecef, lla, Ex, Ey, Ez, radians=True)
        return alt

    def grav_force(Ex, Ey, Ez, m):
        #lat = rad(lat)
        G = -6.67408 * (1 /
                        (10**11))  # Gravitational Constant (m^3 kg^-1 s^-2)
        M = 5.972 * (10**24)  # Earth Mass (kg)
        #a = 6398137  # equatoral radius
        #b = 6356752  # polar radius
        #R = math.sqrt((math.pow(math.pow(a, 2) * math.cos(lat), 2) + (math.pow(math.pow(b, 2) * math.sin(lat), 2))) / (
        #            math.pow(a * math.cos(lat), 2) + (math.pow(b * math.sin(lat), 2))))  # Radius of earth (m)
        r = (Ex**2 + Ey**2 + Ez**2)**0.5
        F = (G * M * m) / (r**2)  # Force of gravity (N)
        F_z = F * Ez / r
        F_x = F * (Ex / ((Ex**2 + Ey**2)**0.5))
        F_y = F * (Ey / ((Ex**2 + Ey**2)**0.5))
        print(F_x, F_y, F_z, sep='\t')
        return F_x, F_y, F_z  # in the -r direction

    def drag_force(Ex, Ey, Ez, Evx, Evy, Evz):
        cd = 0.94  # coefficent of drag
        a = 0.00487  # cross sectional area m^2
        p = air_density(alt(Ex, Ey, Ez))  # air density with respect to alt
        # drag = (1/2)*p*v_sqrd*cd*a*(vy/(math.sqrt(v)))
        v_sqrd = (Evx**2) + (Evy**2) + (Evz**2)
        if Evx == 0:
            Ex_drag = 0
        else:
            Ex_drag = (1 / 2) * p * v_sqrd * cd * a * (-Evx /
                                                       (math.sqrt(v_sqrd)))
        if Evy == 0:
            Ey_drag = 0
        else:
            Ey_drag = (1 / 2) * p * v_sqrd * cd * a * (
                -Evy / (math.sqrt(Evx**2 + Evy**2)))
        if Evz == 0:
            Ez_drag = 0
        else:
            Ez_drag = (1 / 2) * p * v_sqrd * cd * a * (
                -Evz / (math.sqrt(Evx**2 + Evy**2)))
        return Ex_drag, Ey_drag, Ez_drag

    # Net Force
    def net_force(Ex, Ey, Ez, Evx, Evy, Evz, m):
        Fx_drag, Fy_drag, Fz_drag = drag_force(Ex, Ey, Ez, Evx, Evy, Evz)
        Fx_grav, Fy_grav, Fz_grav = grav_force(Ex, Ey, Ez, m)
        Fx = Fx_drag + Fx_grav
        Fy = Fy_drag + Fy_grav
        Fz = Fz_drag + Fz_grav
        return Fx, Fy, Fz

    ##def lift_force        lift -> pitching moment by reference length

    ##def side_force        side -> yaw moment by reference length

    ##Areodynaminc forces are applied at center of pressfrom math import *

    # Need to find ideal coefficient of drag
    # Diameter assumed 0.3m
    # Burn time 175 s +- 20 s
    # avg thrust 1540 N
    # Total mass 700 kg
    # Propellant mass 1st stage 85% of first stage mass -> 510 kg +- x
    # Total 2nd stage 98 kg
    # 2nd Stage propellant 83 kg

    ## GOAL FOR FINAL CODE (this refers to the original code, this does not apply here at least in the foreseeable future)
    # Iterate through launch angels to minimize delta V in the y(rocket frame) direction, to 150km
    # after thrust, maximize delta v in the x(rocket frame) direction
    # Minimize time for initial trust burn as third priority
    # looking for initial launch angle, relative angle after thrust is 0, final velocity

    ## Inertial Earth Frame. Reference fram centered at the earth center of gravity (z-up, x-forward, y-right)
    # a = 6398137  # equatoral radius
    # b = 6356752  # polar radius
    # radius = R = math.sqrt((math.pow(math.pow(a, 2) * math.cos(latitude), 2) + (math.pow(math.pow(b, 2) * math.sin(latitude), 2))) / (
    #                 math.pow(a * math.cos(latitude), 2) + (math.pow(b * math.sin(latitude), 2))))  # Radius of earth (m)
    # Ez = radius * sin(latitude)  # Zero at earths center of gravity, going up through north pole
    # Ex = radius * cos(latitude) * cos(longitude)  # Zero at earths center of gravity, going through equator forward
    # Ey = radius * cos(latitude) * sin(longitude)  # Zero at earths center of gravity, going through equator right
    # with open('LLA.csv', 'r') as f:
    # #     next(f)
    # #     reader = csv.reader(f, 'excel')
    # #     data = []
    # #     for row in reader:
    # #         data.append(float(row[0]))
    # #     latitude = rad(data[0])
    # #     longitude = rad(data[1])
    # #     altitude = data[2]

    # This is not the same as in the original code (just minor modifications).
    altitude = float(0)
    latitude = rad(float(28.5729))
    longitude = rad(float(80.659))
    #Altitude,Latitude,Longitude
    #0,28.5729,80.659

    # Black Rock Navada. From 25km. 45 degrees from out of earth, due east.
    # latitude = rad(28.5729)  # N. Latitude
    # longitude = rad(80.6490)  # W. Longitude
    # altitude = 0    # Altitude of rocket in meters
    ecef = pyproj.Proj(proj='geocent', ellps='WGS84', datum='WGS84')
    lla = pyproj.Proj(proj='latlong', ellps='WGS84', datum='WGS84')
    Ex, Ey, Ez = pyproj.transform(lla,
                                  ecef,
                                  longitude,
                                  latitude,
                                  altitude,
                                  radians=True)
    Evx, Evy, Evz = 0, 0, 0
    r_initial = (Ex**2 + Ey**2 + Ez**2)**0.5
    #print(Ex, Ey, Ez, r_initial, sep="\t")

    ## Rocket specs
    roc_mass = 0.0472  # mass of rocket in kg (not including engine
    theta = 45  # Angle of launch from z
    phi = 45  # Angle of launch from x
    # Original code: eng_file = "C6.csv"  # engine file location
    eng_mass_initial = 0.024  # Loaded engine mass in kg
    eng_mass_final = 0.0132  # empty engine mass in kg
    total_mass = roc_mass + eng_mass_initial
    final_roc_mass = roc_mass + eng_mass_final

    ## Earth rotation speed at inital position
    ## Position Velocity Attitude(Earth Centric x-forward y-right z-up)
    ## latitude and longitude position

    # Adapted from the orignal code (minor modifications).
    thrust = np.asarray([[0.0, 0.0], [0.946, 0.031], [4.826, 0.092],
                         [9.936, 0.139], [14.09, 0.192], [11.446, 0.209],
                         [7.381, 0.231], [6.151, 0.248], [5.489, 0.292],
                         [4.921, 0.37], [4.448, 0.475], [4.258, 0.671],
                         [4.542, 0.702], [4.164, 0.723], [4.448, 0.85],
                         [4.353, 1.063], [4.353, 1.211], [4.069, 1.242],
                         [4.258, 1.303], [4.353, 1.468], [4.448, 1.656],
                         [4.448, 1.821], [2.933, 1.834], [1.325, 1.847],
                         [0.0, 1.86]])

    thrust_list = np.asarray(
        [thrust[int(i)][0] for i in range(len(thrust) - 1)])
    thrust_time_list = np.asarray(
        [thrust[i + 1][1] - thrust[i][1] for i in range(0,
                                                        len(thrust) - 1)])
    total_thrust = np.sum(np.multiply(thrust_list, thrust_time_list))

    # We moodify the thrust while preserving the sum (this is an adaptation to Nevergrad).
    # 1: we modify.
    thrust_list = np.multiply(thrust_list, np.exp(thrust_bias))
    # 2: we normalize.
    thrust_list = thrust_list * total_thrust / np.sum(
        np.multiply(thrust_list, thrust_time_list))

    for i in range(len(thrust) - 1):
        thrust[i][0] = thrust_list[i]
    # total_mass vs time curve
    # this is used to represent the mass loss while the rocket burns fuel
    mass_time = []
    #total_thrust = 0
    #for row in thrust:
    #    total_thrust += row[0]

    mass_loss = eng_mass_initial - eng_mass_final
    mass_reman = eng_mass_initial
    for row in thrust:
        # Equation below weird to me: this is not normalized by time ? the mass which is lost should be proportional
        # to thrust x delta-time, right ?
        #percentage = row[0] / total_thrust   # percentage of total thrust to find percentage of mass lost
        percentage = row[0] / np.sum(
            thrust_list
        )  # percentage of total thrust to find percentage of mass lost
        assert percentage >= 0.
        assert percentage <= 1.
        mass_loss = mass_reman * percentage
        mass_reman -= mass_loss
        total_mass = roc_mass + mass_reman
        mass_time.append([total_mass, row[1]])
    mass_list = [mass_time[i][0] for i in range(0, len(thrust))]

    # Lists used to store data and later import data to excel
    Ex_list, Ey_list, Ez_list = np.asarray([Ex]), np.asarray([Ey]), np.asarray(
        [Ez])
    Evx_list, Evy_list, Evz_list = np.asarray([Evx]), np.asarray(
        [Evy]), np.asarray([Evz])
    time_list = np.asarray([0])
    r_list = np.asarray([(Ex**2 + Ey**2 + Ez**2)**0.5])

    # Initializing variables
    time = 0.  # time in seconds

    # while thrust is greater than zero
    # this is while the rocket engine is firing
    for i in range(len(thrust) - 2):
        r = (Ex**2 + Ey**2 + Ez**2)**0.5
        dt = thrust[i][1]
        Efx, Efy, Efz = net_force(Ex, Ey, Ez, Evx, Evy, Evz, mass_list[i])
        Ex += (Evx * dt)
        Ey += (Evy * dt)
        Ez += (Evz * dt)
        dt = thrust[i + 1][1] - thrust[i][1]
        Evz += ((((thrust[i][0] * math.cos(theta)) + Efz) * dt) / mass_list[i])
        Evx += (((thrust[i][0] * math.sin(theta) * math.cos(phi)) + Efx) *
                dt) / mass_list[i]
        Evy += (((
            (thrust[i][0] * math.sin(theta) * math.sin(phi)) + Efy) * dt) /
                mass_list[i])
        time += dt
        Ex_list = np.append(Ex_list, (round(Ex, 6)))
        Ey_list = np.append(Ey_list, (round(Ey, 6)))
        Ez_list = np.append(Ez_list, (round(Ez, 6)))
        Evx_list = np.append(Evx_list, (round(Evx, 6)))
        Evy_list = np.append(Evy_list, (round(Evy, 6)))
        Evz_list = np.append(Evz_list, (round(Evz, 6)))
        time_list = np.append(time_list, (round(time, 6)))
        r_list = np.append(r_list, (round(r, 6)))

    # After thrust
    # This is when the engine is out of fuel and there is no longer a thrust force
    time_step = .05  # time time_step in seconds
    dt = time_step
    while r > r_initial:
        r = (Ex**2 + Ey**2 + Ez**2)**0.5
        Efx, Efy, Efz = net_force(Ex, Ey, Ez, Evx, Evy, Evz, final_roc_mass)
        Ex += (Evx * dt)
        Ey += (Evy * dt)
        Ez += (Evz * dt)
        Evx += ((Efx * dt) / final_roc_mass)
        Evy += ((Efy * dt) / final_roc_mass)
        Evz += ((Efz * dt) / final_roc_mass)
        #print(Evx, Evy, Evz, r, sep='\t')
        time += dt
        #update(Ex, Ey, Ez, Evx, Evy, Evz, time, r)
        Ex_list = np.append(Ex_list, (round(Ex, 6)))
        Ey_list = np.append(Ey_list, (round(Ey, 6)))
        Ez_list = np.append(Ez_list, (round(Ez, 6)))
        Evx_list = np.append(Evx_list, (round(Evx, 6)))
        Evy_list = np.append(Evy_list, (round(Evy, 6)))
        Evz_list = np.append(Evz_list, (round(Evz, 6)))
        time_list = np.append(time_list, (round(time, 6)))
        r_list = np.append(r_list, (round(r, 6)))

    return 1.0 - max(
        Ez_list) / 3032708.353202  # Should be 0 for input (0.,....,0.)
Example #32
0
# Reproject to 3857
# Necessary because original intersection extraction had null projection
print "reprojecting raw intersection shapefile"
inters = fiona.open(inters_shp_path_raw)
inproj = pyproj.Proj(init='epsg:4326')
outproj = pyproj.Proj(init='epsg:3857')

with fiona.open(inters_shp_path,
                'w',
                crs=from_epsg(3857),
                schema=inters.schema,
                driver='ESRI Shapefile') as output:
    for inter in inters:
        coords = inter['geometry']['coordinates']
        re_point = pyproj.transform(inproj, outproj, coords[0], coords[1])
        point = Point(re_point)
        output.write({
            'geometry': mapping(point),
            'properties': inter['properties']
        })

# Read in boston segments + mass DOT join
roads_shp_path = MAP_FP + '/ma_cob_spatially_joined_streets.shp'
roads = [(shape(road['geometry']), road['properties'])
         for road in fiona.open(roads_shp_path)]
print "read in {} road segments".format(len(roads))

# unique id did not get included in shapfile, need to add it for adjacency
for i, road in enumerate(roads):
    road[1]['orig_id'] = int(str(99) + str(i))
Example #33
0
def trans_egsa_wgs(x, y, z):
    wx, wy, wz = transform(egsa, wgs, x, y, z)
    return wx, wy, wz
Example #34
0
def trans_wgs_egsa(x, y, z):
    ex, ey, ez = transform(wgs, egsa, x, y, z)
    return ex, ey, ez

def trans_egsa_wgs(x, y, z):
    wx, wy, wz = transform(egsa, wgs, x, y, z)
    return wx, wy, wz

def dm_to_decimal(f):
	moires, lepta = str(f).split('.')
	lepta = int(int(lepta) * 100 / 60)
	res = moires + '.' + str(lepta)
	return float(res)

# a = Proj('+proj=latlong +ellps=GRS80 +towgs84=-199.87,74.79,246.62')
astlon = 23.7163375

alat = dm_to_decimal(39.39)
alon = dm_to_decimal(-1.57)
blat = dm_to_decimal(39.45)
blon = dm_to_decimal(-1.45)

# Bessel params.... check + and - (probably inverted)
# towgs84='456.39,372.62,496.82,-12.664e-6,-5.620e-6,-10.854e-6,15.9e-6'

a = Proj(proj='aeqd',ellps='bessel',pm='athens',lon_0=alon,lat_0=alat)
b = Proj(proj='aeqd',ellps='bessel',pm='athens',lon_0=blon,lat_0=blat)

x, y, z = transform(a, b, -1500, -5000, 0)
print(x, y)
Example #35
0
 def coordConvert(x, y):
     return transform(inProj, outProj, x, y)
Example #36
0
def main(file):
    
    # Access global variable
    global k_iter
    
    # Determine if the file is empty
    if os.stat(file).st_size == 0:
        return
    
    # Read CSV file
    data = pd.read_csv(file, engine="c", header=None, delim_whitespace=True)
    
    # Convert to numpy array and floats
    data = np.float64(pd.DataFrame.as_matrix(data))

    # Wrap longitude to -180 to 180 degrees
    data[:, 1] = wrapTo180(data[:, 1])
    
    # Get quality flag - keep valid records
    I_flag = (data[:, 12] == 0) & (data[:, 15] == 0)
    
    # Only keep valid records
    data = data[I_flag, :]
    
    # If mask avaliable
    if fmask != 'None':
        
        # Reproject coordinates
        (x, y) = pyproj.transform(projGeo, projGrd, data[:, 1], data[:, 0])

        # Interpolation of grid to points for masking
        Ii = bilinear2d(Xm, Ym, Zm, x.T, y.T, order=1)
    
        # Set all NaN's to zero
        Ii[np.isnan(Ii)] = 0
    
        # Convert to boolean
        Im = Ii == 1
    
        # Keep only data inside mask
        data = data[Im, :]
    
    # If file is empty - skip file
    if len(data) == 0:
        return
    
    # Load satellite parameters
    cyc      = data[:, 3]            # Cycle number
    rel      = data[:, 4]            # Relative orbit
    lat      = data[:, 0]            # Latitude (deg)
    lon      = data[:, 1]            # Longitude (deg)
    t_sec    = data[:, 2]            # Time (secs since 2000)
    r_ice1   = data[:,13] * 1e-3     # Range ICE-1 retracker (m)
    a_sat    = data[:, 5] * 1e-3     # Altitude of satellite (m)
    bs_ice1  = data[:,14] * 1e-2     # Backscatter of ICE-1 retracker (dB)
    lew_ice2 = data[:,19] * 1e-3     # Leading edge width from ICE-2 (m)
    tes_ice2 = data[:,20]            # Trailing edge slope fram ICE-2 (1/m)
    #orb_type = data[:,22]            # Orbit type A(0)/D(1)

    # Load geophysical corrections - (mm -> m)
    h_ion = data[:, 6] * 1e-3        # Ionospheric cor
    h_dry = data[:, 7] * 1e-3        # Dry tropo cor
    h_wet = data[:, 8] * 1e-3        # Wet tropo cor
    h_geo = data[:, 9] * 1e-3        # Pole tide
    h_sol = data[:,10] * 1e-3        # Solid tide
    
    # Compute correct time - add back year 2000 in secs
    t_sec += 2000 * 365.25 * 24 * 3600.

    # Compute time in decimal years 
    t_year = t_sec / (365.25 * 24 * 3600.)

    # Compute time since 1970 - remove year 1970 in secs
    t_sec -= 1970 * 365.25 * 24 * 3600.

    # Sum all corrections
    h_cor = h_ion + h_dry + h_wet + h_geo + h_sol
    
    # Correct range
    r_ice1_cor = (r_ice1 + h_cor)
    
    # Compute surface elevation
    h_ice1 = a_sat - r_ice1_cor

    # Separate tracks into asc/des orbits
    (i_asc, i_des) = track_type(t_sec, lat)
    
    # Create orbit number container
    orb = np.zeros(lat.shape)
    orb_type = np.zeros(lat.shape)
    
    # Set orbit numbers
    if len(lat[i_asc]) > 0:
        
        # Create independent track references
        orbit_num = np.char.add(str(index), str(k_iter)).astype('int')
        
        # Set vector to number
        orb[i_asc] = orbit_num
        
        # Set orbit type
        orb_type[i_asc] = 0
        
        # Increase counter
        k_iter += 1
    
    # Set orbit numbers
    if len(lat[i_des]) > 0:
        
        # Create independent track references
        orbit_num = np.char.add(str(index), str(k_iter)).astype('int')
        
        # Set vector to number
        orb[i_des] = orbit_num
        
        # Set orbit type
        orb_type[i_des] = 1
        
        # Increase counter
        k_iter += 1

    # Sum all corrections
    h_cor = h_ion + h_dry + h_wet + h_geo + h_sol

    # Correct range
    r_ice1_cor = (r_ice1 + h_cor)

    # Compute surface elevation
    h_ice1 = a_sat - r_ice1_cor

    # Current file
    iFile = np.column_stack((
              orb, lat, lon, t_sec, h_ice1, t_year,
              bs_ice1, lew_ice2, tes_ice2, r_ice1_cor,
              h_ion, h_dry, h_wet, h_geo, h_sol, orb_type))

    # Create varibales names
    fields = ['orbit', 'lat', 'lon', 't_sec', 'h_cor', 't_year',
              'bs', 'lew', 'tes', 'r_ice1_cor',
              'h_ion', 'h_dry', 'h_wet', 'h_geo', 'h_sol', 'orb_type']

    # Save ascending file
    if len(lat[i_asc]) > 0:
        
        # Create file ending
        str_orb = '_READ_A'
        
        # Change path/name of read file
        name, ext = os.path.splitext(os.path.basename(file))
        ofile = os.path.join(outdir, name + str_orb + ext)
        ofile = ofile.replace('.txt', '.h5')
        
        # Write to file
        with h5py.File(ofile, 'w') as f:
            [f.create_dataset(k, data=d) for k, d in zip(fields, iFile[i_asc].T)]
        
        # What file are we reading
        print ofile
    
    # Save descending file
    if len(lat[i_des]) > 0:
        
        # Create file ending
        str_orb = '_READ_D'
        
        # Change path/name of read file
        name, ext = os.path.splitext(os.path.basename(file))
        ofile = os.path.join(outdir, name + str_orb + ext)
        ofile = ofile.replace('.txt', '.h5')
        
        # Write to file
        with h5py.File(ofile, 'w') as f:
            [f.create_dataset(k, data=d) for k, d in zip(fields, iFile[i_des].T)]
        
        # What file are we reading
        print ofile
Example #37
0
    def execute(self,
                stream,
                process_limits=None,
                origin_resource=None,
                channels=None,
                **kwargs):
        ''' Execute the stack node.

        Parameters
        ----------
        stream : :class:`obspy.core.Stream`
            The data to process.
        '''
        # Check for needed keyword arguments.
        if not self.kwargs_exists(['event'], **kwargs):
            raise RuntimeError(
                "The needed event argument was not passed to the execute method."
            )

        event = kwargs['event']

        # Load the quarry_blast information.
        blast_filename = self.pref_manager.get_value('blast_file')
        if os.path.exists(blast_filename):
            with open(blast_filename, 'r') as fp:
                quarry_blast = json.load(
                    fp=fp, cls=quarry_blast_validation.QuarryFileDecoder)
        else:
            raise RuntimeError("Couldn't open the blast file %s.",
                               blast_filename)

        # Get the baumit quarry blast id from the event tags.
        id_tag = [x for x in event.tags if x.startswith('baumit_id:')]
        if id_tag:
            id_tag = id_tag[0]
        else:
            self.logger.error(
                "No baumit quarry blast id tag found for event %d.",
                event.db_id)
            return
        spec, baumit_id = id_tag.split(':')

        # Compute the resultant of the stations.
        res_stream = obspy.core.Stream()
        res3d_stream = obspy.core.Stream()
        orig_stream = obspy.core.Stream()
        res_stations = []
        for cur_detection in event.detections:
            # TODO: Select the detection timespan only.
            cur_stream = stream.select(network=cur_detection.scnl[2],
                                       station=cur_detection.scnl[0],
                                       location=cur_detection.scnl[3])

            resultant_channels = ['Hnormal', 'Hparallel']
            resultant_3d_channels = ['Hnormal', 'Hparallel', 'Z']

            # Compute the 2D-resultant used for the magnitude computation.
            cur_res_stream = self.compute_resultant(cur_stream,
                                                    resultant_channels)
            if not cur_res_stream:
                continue

            #Compute the 3D-resultant used for reporting of the DUBA stations.
            cur_res3d_stream = self.compute_resultant(cur_stream,
                                                      resultant_3d_channels)

            orig_stream = orig_stream + cur_stream
            res_stream = res_stream + cur_res_stream
            res3d_stream = res3d_stream + cur_res3d_stream
            res_stations.append(cur_detection.channel.parent_station)

        # Handle the DUBAM station separately. Due to a time-error relative to
        # DUBA, the DUBAM detections are most likely not included in the event
        # detections.
        stat_dubam = [x for x in res_stations if x.name == 'DUBAM']
        self.logger.debug(
            "##################### DUBAM HANDLING ###############")
        self.logger.debug(stat_dubam)
        if not stat_dubam:
            cur_stream = stream.select(network='MSSNet',
                                       station='DUBAM',
                                       location='00')
            self.logger.debug(cur_stream)
            # Compute the 2D-resultant used for the magnitude computation.
            resultant_channels = ['Hnormal', 'Hparallel']
            cur_res_stream = self.compute_resultant(cur_stream,
                                                    resultant_channels)
            if cur_res_stream:
                #Compute the 3D-resultant used for reporting of the DUBA stations.
                resultant_3d_channels = ['Hnormal', 'Hparallel', 'Z']
                cur_res3d_stream = self.compute_resultant(
                    cur_stream, resultant_3d_channels)

                orig_stream = orig_stream + cur_stream
                res_stream = res_stream + cur_res_stream
                res3d_stream = res3d_stream + cur_res3d_stream
                cur_station = self.project.geometry_inventory.get_station(
                    name='DUBAM')[0]
                res_stations.append(cur_station)

        self.logger.debug("res_stations: %s", res_stations)
        self.logger.debug("res_stream: %s", res_stream)
        self.logger.debug("res3d_stream: %s", res3d_stream)

        # Handle possible coordinate changes of station DUBAM.
        # If the field x_dubam_1 is set, the alternative DUBAM position is
        # used.
        stat_dubam = [x for x in res_stations if x.name == 'DUBAM']
        if stat_dubam:
            stat_dubam = stat_dubam[0]
            if quarry_blast[baumit_id]['x_dubam_1'] is not None:
                stat_dubam.x = quarry_blast[baumit_id]['x_dubam_1']
                stat_dubam.y = quarry_blast[baumit_id]['y_dubam_1']
                stat_dubam.z = quarry_blast[baumit_id]['z_dubam_1']
                stat_dubam.coord_system = 'epsg:31256'

        # TODO: Check if all expected stations have got a trigger. Test the
        # missing stations for available data an eventually missed events. Use
        # a threshold value of the maximum amplitude as a rule whether to
        # include the missed station into the PGV computation or not.

        # Compute the max. PGV.
        max_pgv = [
            (str.join(':',
                      (x.stats.station, x.stats.network, x.stats.location)),
             np.max(x.data)) for x in res_stream
        ]
        max_pgv_3d = [
            (str.join(':',
                      (x.stats.station, x.stats.network, x.stats.location)),
             np.max(x.data)) for x in res3d_stream
        ]

        # Compute the magnitude.
        # TODO: Check the standard for the sign of the station correction.
        # Brueckl subtracts the station correction.
        proj_baumit = pyproj.Proj(init='epsg:' +
                                  quarry_blast[baumit_id]['epsg'])
        proj_wgs84 = pyproj.Proj(init='epsg:4326')
        if res_stations:
            stat_lonlat = np.array([x.get_lon_lat() for x in res_stations])
            stat_x, stat_y = pyproj.transform(proj_wgs84, proj_baumit,
                                              stat_lonlat[:, 0],
                                              stat_lonlat[:, 1])
            stat_z = np.array([x.z for x in res_stations])
            quarry_x = quarry_blast[baumit_id]['x']
            quarry_y = quarry_blast[baumit_id]['y']
            quarry_z = quarry_blast[baumit_id]['z']
            hypo_dist = np.sqrt((stat_x - quarry_x)**2 +
                                (stat_y - quarry_y)**2 +
                                (stat_z - quarry_z)**2)
            stat_corr = np.zeros(len(max_pgv))
            magnitude = np.log10([
                x[1] * 1000 for x in max_pgv
            ]) + 1.6 * np.log10(hypo_dist) - 2.074 + stat_corr
        else:
            hypo_dist = []
            magnitude = []

        # Compute the PSD.
        psd_data = {}
        for cur_trace in orig_stream:
            cur_psd_data = self.compute_psd(cur_trace)
            cur_scnl = util.traceid_to_scnl(cur_trace.id)
            cur_scnl_string = ':'.join(cur_scnl)
            psd_data[cur_trace.id] = cur_psd_data

        # Compute the dominant frequency.
        dom_frequ = {}
        dom_stat_frequ = {}
        for cur_station in res_stations:
            cur_psd_keys = [
                x for x in psd_data.keys()
                if x.startswith(cur_station.network + '.' + cur_station.name +
                                '.')
            ]
            cur_df = []
            for cur_key in cur_psd_keys:
                cur_nfft = psd_data[cur_key]['n_fft']
                left_fft = int(np.ceil(cur_nfft / 2.))
                max_ind = np.argmax(psd_data[cur_key]['psd'][1:left_fft])
                dom_frequ[cur_key] = psd_data[cur_key]['frequ'][max_ind]
                cur_df.append(dom_frequ[cur_key])

            dom_stat_frequ[cur_station.snl_string] = np.mean(cur_df)

        # Update the quarry blast information dictionary.
        export_max_pgv = dict(max_pgv)
        export_magnitude = dict(
            list(zip([x.snl_string for x in res_stations], magnitude)))
        quarry_blast[baumit_id]['computed_on'] = utcdatetime.UTCDateTime()
        quarry_blast[baumit_id]['event_time'] = event.start_time
        quarry_blast[baumit_id]['max_pgv'] = {}
        quarry_blast[baumit_id]['max_pgv']['data'] = export_max_pgv
        quarry_blast[baumit_id]['max_pgv'][
            'used_channels'] = resultant_channels
        quarry_blast[baumit_id]['max_pgv_3d'] = {}
        quarry_blast[baumit_id]['max_pgv_3d']['data'] = dict(max_pgv_3d)
        quarry_blast[baumit_id]['max_pgv_3d'][
            'used_channels'] = resultant_3d_channels
        quarry_blast[baumit_id]['magnitude'] = {}
        quarry_blast[baumit_id]['magnitude']['station_mag'] = export_magnitude
        quarry_blast[baumit_id]['magnitude']['network_mag'] = np.mean(
            magnitude)
        quarry_blast[baumit_id]['magnitude']['network_mag_std'] = np.std(
            magnitude)
        quarry_blast[baumit_id]['dom_frequ'] = dom_frequ
        quarry_blast[baumit_id]['dom_stat_frequ'] = dom_stat_frequ
        quarry_blast[baumit_id]['hypo_dist'] = dict(
            list(zip([x.snl_string for x in res_stations], hypo_dist)))

        # Save the quarry blast information.
        with open(blast_filename, 'w') as fp:
            json.dump(quarry_blast,
                      fp=fp,
                      cls=quarry_blast_validation.QuarryFileEncoder)

        # Write a result file for the event.
        output_dir = self.pref_manager.get_value('report_data_dir')
        filename = 'blast_report_data_event_%010d.pkl' % event.db_id
        report_data = {}
        report_data['baumit_id'] = baumit_id
        report_data['blast_data'] = quarry_blast[baumit_id]
        report_data['psd_data'] = psd_data
        with open(os.path.join(output_dir, filename), 'w') as fp:
            pickle.dump(report_data, fp)

        # Clear the computation request flag in the event database.
        event.tags.remove('mss_result_needed')
        event.tags.append('mss_result_computed')
        event.write_to_database(self.project)
    def plot(self,alt=np.array([None])):
        fig, ax = plt.subplots()
        ax.ticklabel_format(useOffset=False)
        plt.subplot(141)
        plt.plot(self.times,self.mu_history[0,:])
        plt.title("X vs Time")
        plt.xlabel("Time [hrs]")
        plt.ylabel("X [m]")

        plt.subplot(142)
        plt.plot(self.times,self.mu_history[1,:])
        plt.title("Y vs Time")
        plt.xlabel("Time [hrs]")
        plt.ylabel("Y [m]")

        plt.subplot(143)
        plt.plot(self.times,self.mu_history[2,:])
        plt.title("Z vs Time")
        plt.xlabel("Time [hrs]")
        plt.ylabel("Z [m]")

        plt.subplot(144)
        plt.plot(self.times,self.mu_history[3,:])
        plt.title("Time Bias vs Time")
        plt.xlabel("Time [hrs]")
        plt.ylabel("Time Bias [m]")

        # covariance plot
        plt.figure()
        plt.title("Trace of Covariance Matrix vs. Time")
        plt.xlabel("Time [hrs]")
        plt.ylabel("Trace")
        plt.plot(self.times,self.P_history)

        # trajectory plot
        lla_traj = np.zeros((len(self.times),3))
        if alt.all() == None:
            lon, lat, alt = pyproj.transform(self.ecef, self.lla, self.mu_history[0,:], self.mu_history[1,:], self.mu_history[2,:], radians=False)
        else:
            lon, lat, reject = pyproj.transform(self.ecef, self.lla, self.mu_history[0,:], self.mu_history[1,:], self.mu_history[2,:], radians=False)
        print("alt shape",alt.shape)
        lla_traj[:,0] = lat
        lla_traj[:,1] = lon
        lla_traj[:,2] = alt
        fig, ax = plt.subplots()
        ax.ticklabel_format(useOffset=False)
        plt.plot(lla_traj[:,1],lla_traj[:,0],label="Our Position Solution")

        if self.odom_file != None:
            lat_truth = self.odom_df['GPS(0):Lat[degrees]'].to_numpy()
            lon_truth = self.odom_df['GPS(0):Long[degrees]'].to_numpy()
            plt.plot(lon_truth,lat_truth,'g',label="DJI's Position Solution")
        plt.legend()
        plt.xlim([-122.1759,-122.1754])
        plt.ylim([37.42620,37.42660])
        ax.set_yticks([37.4262,37.4263,37.4264,37.4265,37.4266])
        plt.xlabel("Longitude [deg]")
        plt.ylabel("Latitude [deg]")

        fig = plt.figure()
        ax = fig.gca(projection='3d')
        ax.plot(lla_traj[:,1], lla_traj[:,0], lla_traj[:,2], label='our solution')
        if self.odom_file != None:
            lat_truth = self.odom_df['GPS(0):Lat[degrees]'].to_numpy()[self.truth_indexes]
            lon_truth = self.odom_df['GPS(0):Long[degrees]'].to_numpy()[self.truth_indexes]
            h_truth = self.odom_df['GPS(0):heightMSL[meters]'].to_numpy()[self.truth_indexes]
            latf = self.odom_df['GPS(0):Lat[degrees]'].values[-1]
            lonf = self.odom_df['GPS(0):Long[degrees]'].values[-1]
            hf = h_truth[-1]
            lat0 = self.odom_df['GPS(0):Lat[degrees]'][0]
            lon0 = self.odom_df['GPS(0):Long[degrees]'][0]
            h0 = h_truth[0]
            plt.plot([lon0],[lat0],[h0],'go')
            plt.plot([lonf],[latf],[hf],'ro')
            plt.plot(lon_truth,lat_truth,h_truth,'g',label="DJI's Position Solution")

        ax.legend()
        ax.ticklabel_format(useOffset=False)
        ax.set_xlim([-122.1759,-122.1754])
        ax.set_ylim([37.42620,37.42660])
        ax.set_zlim([0.,2.5])
        ax.set_xlabel('\n\n Longitude [deg]')
        ax.set_ylabel('Latitude [deg]')
        ax.set_zlabel('Altitude [m]')
        ax.set_xticks([-122.1759, -122.17565, -122.1754])
        ax.set_yticks([37.42630,37.42640,37.42650])
        ax.view_init(elev=10., azim=20.)

        if self.odom_file != None:
            steps = np.arange(len(lat_truth))
            lat_error = np.abs(lat_truth-lla_traj[:,0])
            lon_error = np.abs(lon_truth-lla_traj[:,1])
            h_error = np.abs(h_truth-lla_traj[:,2])
            print("lat avg: ",np.mean(lat_error))
            print("lon avg: ",np.mean(lon_error))
            print("h avg: ",np.mean(h_error))
            plt.figure()
            plt.subplot(131)
            plt.title("Latitude Error [degrees latitude]")
            plt.ylabel("Latitude Error [degrees latitude]")
            plt.xlabel("Time Step")
            plt.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
            plt.plot(steps,lat_error)
            plt.subplot(132)
            plt.xlabel("Time Step")
            plt.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
            plt.title("Longitude Error [degrees longitude]")
            plt.ylabel("Longitude Error [degrees longitude]")
            plt.plot(steps,lon_error)
            plt.subplot(133)
            plt.xlabel("Time Step")
            plt.title("Altitude Error [m]")
            plt.ylabel("Altitude Error [m]")
            plt.plot(steps,h_error)

        # save to file
        df_traj = pd.DataFrame()
        df_traj['latitude'] = lla_traj[:,0]
        df_traj['longitude'] = lla_traj[:,1]
        df_traj['elevation'] = lla_traj[:,2]
        df_traj.to_csv('./data/calculated_trajectory.csv',index=False)

        plt.show()
Example #39
0
def latlon_to_xy(lat, lon, base_crs=albers_conus_crs()):
    p1 = Proj(base_crs)
    p2 = Proj(proj='latlong', datum='WGS84')
    x, y = transform(p2, p1, np.asarray(lon), np.asarray(lat))
    return x, y
Example #40
0
    def save(self, calculator):
        self.generatePointsLayer(calculator)
        self.generatePolygonsLayer(calculator)

        # 转换成投影坐标
        srcCRS = pyproj.Proj(proj='latlon', datum='WGS84')  # 定义数据地理坐标系
        targetCRS = pyproj.Proj(proj='merc', datum='WGS84')  # 定义转换投影坐标系
        for i in range(len(self.x)):

            #x1, y1 = srcCRS(self.x[i], self.y[i])
            x2, y2 = pyproj.transform(srcCRS, targetCRS, self.x[i], self.y[i])
            self.x[i] = x2
            self.y[i] = y2

            #print(x2,y2, self.z[i])

        points = [(self.x[i], self.y[i], self.z[i])
                  for i in range(len(self.x))]

        # face_data = np.array([([0, pIndex, pIndex + 1], 255, 255, 255),
        #                       ([0, pIndex, pIndex + 3], 255,   0,   0),
        #                      ],
        #             dtype=[('vertex_indices', 'i4', (3,)),
        #                    ('red', 'u1'), ('green', 'u1'),
        #                    ('blue', 'u1')])

        totalStations = 0
        for line in calculator.points:
            totalStations = totalStations + len(line)
        vetexCount = len(self.x)
        edgeCount = totalStations * 4
        faceCount = totalStations * 4
        rectCount = totalStations

        print("total station:", totalStations)
        print("The vetex count:", vetexCount)
        print("The edge count:", edgeCount)
        print("The tri face count:", faceCount)
        print("The rect face count:", rectCount)

        vertex = np.array(points,
                          dtype=[('x', 'f8'), ('y', 'f8'), ('z', 'f8')])
        print("vertex array shape:", vertex.shape)

        with open(self.filename, 'w') as file:
            file.write("""ply
format ascii 1.0
element vertex {}
comment vertices
property double x
property double y
property double z
property uint8 red
property uint8 green
property uint8 blue
element edge {}
property int32 vertex1
property int32 vertex2
property uint8 red
property uint8 green 
property uint8 blue 
element face {}
property list uchar int vertex_indices
end_header
""".format(vetexCount, edgeCount, faceCount + rectCount))

            # write vexex
            colors = np.zeros((totalStations, 3), dtype=np.uint8)
            for i in range(len(self.x)):
                if i < totalStations:
                    colors[i, :] = random.randint(0, 255), random.randint(
                        0, 255), random.randint(0, 255)
                    file.write("{} {} {} {} {} {}\n".format(
                        self.x[i], self.y[i], self.z[i], *colors[i, :]))
                    file.flush()
                else:
                    index = int((i - totalStations) / 4)
                    #print("对应的摄站点为:",index)
                    file.write("{} {} {} {} {} {}\n".format(
                        self.x[i], self.y[i], self.z[i], *colors[index, :]))
                    file.flush()

            # write edge
            for i in range(totalStations):
                pIndex = totalStations + i * 4

                file.write("{} {} 0 255 0\n".format(i, pIndex))
                file.flush()
                file.write("{} {} 0 255 0\n".format(i, pIndex + 1))
                file.flush()
                file.write("{} {} 0 255 0\n".format(i, pIndex + 2))
                file.flush()
                file.write("{} {} 0 255 0\n".format(i, pIndex + 3))
                file.flush()

            # write face
            for i in range(totalStations):

                pIndex = totalStations + i * 4
                #print("Current station:{}, pIndex:{}".format(i,pIndex))

                f1 = (i, pIndex, pIndex + 1)
                f2 = (i, pIndex, pIndex + 3)
                f3 = (i, pIndex + 3, pIndex + 2)
                f4 = (i, pIndex + 2, pIndex + 1)

                #print("conic:", i, f1,f2,f3,f4)

                file.write("3 {} {} {}\n".format(f1[0], f1[1], f1[2]))
                file.flush()
                file.write("3 {} {} {}\n".format(f2[0], f2[1], f2[2]))
                file.flush()
                file.write("3 {} {} {}\n".format(f3[0], f3[1], f3[2]))
                file.flush()
                file.write("3 {} {} {}\n".format(f4[0], f4[1], f4[2]))
                file.flush()

            # write rect
            for i in range(totalStations):
                pIndex = totalStations + i * 4

                file.write("4 {} {} {} {}\n".format(pIndex, pIndex + 1,
                                                    pIndex + 2, pIndex + 3))
                file.flush()

        return True
        xmax = nodes[triangles[k, 2], 0]
        ymin = nodes[triangles[k, 0], 1]
        ymax = nodes[triangles[k, 2], 1]
        if ((xmin > x0hole) & (xmax < x1hole)) & ((ymin > y0hole) &
                                                  (ymax < y1hole)):
            solid_id[k] = 1
        else:
            solid_id[k] = 0
    print('done tagging hole')
nsolid = int(max(solid_id))

if args.proj != '':
    print('projecting the node coordinates')
    x0, y0, z0 = pyproj.transform(lla,
                                  myproj,
                                  nodes[:, 0],
                                  nodes[:, 1],
                                  1e3 * nodes[:, 2],
                                  radians=False)
    nodes[:, 0] = x0
    nodes[:, 1] = y0
    nodes[:, 2] = z0
    print(nodes)
    print('done projecting')
    del x0, y0, z0

_, ext = os.path.splitext(args.output_file)

if ext == '.ts':
    fout = open(args.output_file, 'w')
    for sid in range(nsolid + 1):
        fout.write("GOCAD TSURF 1\nHEADER {\nname:" + args.objectname +
    def __init__(self,sat_file,odom_file=None):
        # read in data files as dataframe
        self.sat_df = pd.read_csv(sat_file, index_col=0)
        self.odom_file = odom_file
        if odom_file != None:
            self.odom_df = pd.read_csv(odom_file, index_col=0)

            # initial lat and lon from dji data
            lat0 = np.mean(self.odom_df['GPS(0):Lat[degrees]'][0])
            lon0 = np.mean(self.odom_df['GPS(0):Long[degrees]'][0])
            h0 = 0.0

            # convert lat lon to ecef frame
            self.lla = pyproj.Proj(proj='latlong', ellps='WGS84', datum='WGS84')
            self.ecef = pyproj.Proj(proj='geocent', ellps='WGS84', datum='WGS84')
            x0, y0, z0 = pyproj.transform(self.lla, self.ecef, lon0, lat0, h0 , radians=False)

            # concatenate possible time steps from each data file
            self.times = np.concatenate((self.odom_df['seconds of week [s]'].to_numpy(),self.sat_df['seconds of week [s]'].to_numpy()))

            # sort timesteps and force unique
            self.times = np.sort(np.unique(self.times))

            self.initialized_odom = False

            def find_nearest(array, value):
                array = np.asarray(array)
                idx = (np.abs(array - value)).argmin()
                return idx

            # indexes for plotting truth later
            self.truth_indexes = []
            for ii in range(len(self.times)):
                ix = find_nearest(self.odom_df['seconds of week [s]'].to_numpy(),self.times[ii])
                self.truth_indexes.append(ix)

        else:
            # set initial positions
            x0 = 0.
            y0 = 0.
            z0 = 0.

            # initialize times
            self.times = self.sat_df['seconds of week [s]'].to_numpy()



        # initialize state vector [ x, y, z ]
        self.mu = np.array([[x0,y0,z0,0.0]]).T
        self.mu_n = self.mu.shape[0]
        self.mu_history = self.mu.copy()

        # initialize covariance matrix
        self.P = np.eye(self.mu_n)*10E2
        self.P_history = [np.trace(self.P)]

        if odom_file != None:
            t0 = self.sat_df['seconds of week [s]'].to_numpy()[0]
            x_calc = [x0,y0,z0]
            bu_calc = 0.0
            input = self.sat_df[self.sat_df['seconds of week [s]'] == t0]
            for ii in range(20):
                x_calc, bu_calc = self.least_squares(x_calc,bu_calc,input)

            self.mu[3][0] = bu_calc

        if odom_file != None and 'pr [m]' in self.sat_df.columns:
            # only use the best satellites
            self.cutoff_angle = 20.0
            self.check_data(self.mu,lat0,lon0,False)
Example #43
0
    def generate_ows_link(self, endpoint, service_type, service_version):
        if service_version in ("1.1.0", "1.1"):
            service_version = "1.1.0"
        elif service_version in ("2.0.0", "2", "2.0"):
            service_version = "2.0.0"
        elif service_version in ("1", "1.0", "1.0.0"):
            service_version = "1.0.0"

        endpoint = endpoint.strip()
        original_endpoint = endpoint
        #parse endpoint's parameters
        endpoint = endpoint.split("?", 1)
        endpoint, endpoint_parameters = (
            endpoint[0], endpoint[1]) if len(endpoint) == 2 else (endpoint[0],
                                                                  None)
        endpoint_parameters = endpoint_parameters.split(
            "&") if endpoint_parameters else None
        endpoint_parameters = dict(
            [(p.split("=", 1)[0].upper(), p.split("=", 1))
             for p in endpoint_parameters] if endpoint_parameters else [])

        #get target_crs
        target_crs = None
        if service_type == "WFS":
            target_crs = [
                endpoint_parameters.get(k)[1] for k in ["SRSNAME"]
                if k in endpoint_parameters
            ]
        elif service_type in ["WMS", "GWC"]:
            target_crs = [
                endpoint_parameters.get(k)[1] for k in ["SRS", "CRS"]
                if k in endpoint_parameters
            ]

        if target_crs:
            target_crs = target_crs[0].upper()
        else:
            target_crs = self.crs.upper() if self.crs else None

        #transform the bbox between coordinate systems, if required
        bbox = self.bbox or []
        if bbox:
            if target_crs != self.crs:
                try:
                    if self.crs.upper() in epsg_extra:
                        p1 = pyproj.Proj(epsg_extra[self.crs.upper()])
                    else:
                        p1 = pyproj.Proj(init=self.crs)

                    if target_crs in epsg_extra:
                        p2 = pyproj.Proj(epsg_extra[target_crs])
                    else:
                        p2 = pyproj.Proj(init=target_crs)

                    bbox[0], bbox[1] = pyproj.transform(
                        p1, p2, bbox[0], bbox[1])
                    bbox[2], bbox[3] = pyproj.transform(
                        p1, p2, bbox[2], bbox[3])
                except Exception as e:
                    raise ValidationError(
                        "Transform the bbox of layer({0}) from crs({1}) to crs({2}) failed.{3}"
                        .format(self.identifier, self.crs, target_crs, str(e)))

            if service_type == "WFS":
                #to limit the returned features, shrink the original bbox to 10 percent
                percent = 0.1
                shrinked_min = lambda min, max: (max - min) / 2 - (
                    max - min) * percent / 2
                shrinked_max = lambda min, max: (max - min) / 2 + (
                    max - min) * percent / 2
                shrinked_bbox = [
                    shrinked_min(bbox[0], bbox[2]),
                    shrinked_min(bbox[1], bbox[3]),
                    shrinked_max(bbox[0], bbox[2]),
                    shrinked_max(bbox[1], bbox[3])
                ]
        else:
            shrinked_bbox = None

        bbox2str = lambda bbox, service, version: ', '.join(
            str(c) for c in bbox
        ) if service != "WFS" or version == "1.0.0" else ", ".join(
            [str(c) for c in [bbox[1], bbox[0], bbox[3], bbox[2]]])

        if service_type == "WFS":
            kvp = {
                "SERVICE": "WFS",
                "REQUEST": "GetFeature",
                "VERSION": service_version,
            }
            parameters = {}
            if self.crs:
                kvp["SRSNAME"] = self.crs.upper()

            if target_crs:
                parameters["crs"] = target_crs

            is_geoserver = endpoint.find("geoserver") >= 0

            if service_version == "1.1.0":
                if is_geoserver:
                    kvp["maxFeatures"] = 20
                elif shrinked_bbox:
                    kvp["BBOX"] = bbox2str(shrinked_bbox, service_type,
                                           service_version)
                kvp["TYPENAME"] = self.identifier
            elif service_version == "2.0.0":
                if is_geoserver:
                    kvp["count"] = 20
                elif shrinked_bbox:
                    kvp["BBOX"] = bbox2str(shrinked_bbox, service_type,
                                           service_version)
                kvp["TYPENAMES"] = self.identifier
            else:
                if shrinked_bbox:
                    kvp["BBOX"] = bbox2str(shrinked_bbox, service_type,
                                           service_version)
                kvp["TYPENAME"] = self.identifier
        elif service_type == "WMS":
            kvp = {
                "SERVICE": "WMS",
                "REQUEST": "GetMap",
                "VERSION": service_version,
                "LAYERS": self.identifier,
                ("SRS", "CRS"): self.crs.upper(),
                "WIDTH": self.width,
                "HEIGHT": self.height,
                "FORMAT": "image/png"
            }

            parameters = {
                "crs":
                target_crs,
                "format":
                endpoint_parameters["FORMAT"][1]
                if "FORMAT" in endpoint_parameters else kvp["FORMAT"],
            }
            if bbox:
                kvp["BBOX"] = bbox2str(bbox, service_type, service_version)
        elif service_type == "GWC":
            service_type = "WMS"
            kvp = {
                "SERVICE": "WMS",
                "REQUEST": "GetMap",
                "VERSION": service_version,
                "LAYERS": self.identifier,
                ("SRS", "CRS"): self.crs.upper(),
                "WIDTH": 1024,
                "HEIGHT": 1024,
                "FORMAT": "image/png"
            }
            parameters = {
                "crs":
                target_crs,
                "format":
                endpoint_parameters["FORMAT"][1]
                if "FORMAT" in endpoint_parameters else kvp["FORMAT"],
                "width":
                endpoint_parameters["WIDTH"][1]
                if "WIDTH" in endpoint_parameters else kvp["WIDTH"],
                "height":
                endpoint_parameters["HEIGHT"][1]
                if "HEIGHT" in endpoint_parameters else kvp["HEIGHT"],
            }
            if not bbox:
                #bbox is null, use australian bbox
                bbox = [108.0000, -45.0000, 155.0000, -10.0000]
                p1 = pyproj.Proj(init="EPSG:4326")
                p2 = pyproj.Proj(init=target_crs)
                bbox[0], bbox[1] = pyproj.transform(p1, p2, bbox[0], bbox[1])
                bbox[2], bbox[3] = pyproj.transform(p1, p2, bbox[2], bbox[3])

            if not hasattr(PreviewTile, target_crs.replace(":", "_")):
                raise Exception(
                    "GWC service don't support crs({}) ".format(target_crs))

            tile_bbox = getattr(PreviewTile, target_crs.replace(":",
                                                                "_"))(bbox)

            kvp["BBOX"] = bbox2str(tile_bbox, service_type, service_version)
        else:
            raise Exception("Unknown service type({})".format(service_type))

        is_exist = lambda k: any([
            n.upper() in endpoint_parameters
            for n in (k
                      if isinstance(k, tuple) or isinstance(k, list) else [k])
        ])

        querystring = "&".join([
            "{}={}".format(
                k[0] if isinstance(k, tuple) or isinstance(k, list) else k, v)
            for k, v in kvp.items() if not is_exist(k)
        ])
        if querystring:
            if original_endpoint[-1] in ("?", "&"):
                link = "{}{}".format(original_endpoint, querystring)
            elif '?' in original_endpoint:
                link = "{}&{}".format(original_endpoint, querystring)
            else:
                link = "{}?{}".format(original_endpoint, querystring)
        else:
            link = original_endpoint

        #get the endpoint after removing ows related parameters
        if endpoint_parameters:
            is_exist = lambda k: any([
                any([k == key.upper() for key in item_key])
                if isinstance(item_key, tuple) or isinstance(item_key, list)
                else k == item_key.upper() for item_key in kvp
            ])
            endpoint_querystring = "&".join([
                "{}={}".format(*v) for k, v in endpoint_parameters.items()
                if not is_exist(k)
            ])
            if endpoint_querystring:
                endpoint = "{}?{}".format(endpoint, endpoint_querystring)

        #schema =  '{{"protocol":"OGC:{0}", "linkage":"{1}", "version":"{2}"}}'.format(service_type.upper(), endpoint, service_version)
        schema = {
            "protocol": "OGC:{}".format(service_type.upper()),
            "linkage": endpoint,
            "version": service_version,
        }
        schema.update(parameters)

        return 'None\tNone\t{0}\t{1}'.format(json.dumps(schema), link)
Example #44
0
print("MicMac: XifGps2Txt > Extract GPS data from EXIF")
subprocess.call("mm3d XifGps2Txt '.*[JPG|jpg]' > img2ortho.log", shell=True)

# WGS84 proj to local
wgs = Proj(init='epsg:4326')
local = Proj(init='epsg:2154')

# get lat/lon from micmac generated txt file
with open('GpsCoordinatesFromExif.txt') as gpscsv:
    gpsdata = csv.reader(gpscsv, delimiter=' ')
    print("Reproject to local X/Y")
    with open('LocalCoordinatesFromExif.txt', mode='w') as localcsv:
        localdata = csv.writer(localcsv, delimiter=' ')
        localdata.writerow(['#F=N', 'X', 'Y', 'Z'])
        for gps in gpsdata:
            x2, y2 = transform(wgs, local, gps[1], gps[2])
            localdata.writerow([gps[0], x2, y2, gps[3]])

print("Micmac: OriConvert")
subprocess.call(
    'mm3d OriConvert OriTxtInFile LocalCoordinatesFromExif.txt gps NameCple=FileImagesNeighbour.xml >> img2ortho.log',
    shell=True)

print("Micmac: Tapioca > search for similarities between images")
subprocess.call(
    'mm3d Tapioca MulScale .*.JPG 300 1200 ExpTxt=0 >> img2ortho.log',
    shell=True)
print("Micmac: Tapas > find relative position/orientation between images")
subprocess.call(
    'mm3d Tapas RadialBasic .*.JPG Out=Arbitrary ExpTxt=0 >> img2ortho.log',
    shell=True)
Example #45
0
def jtsk2wgs(coords):
    return pyproj.transform(jtsk, wgs, coords[0], coords[1])
Example #46
0
def statistic(request):
    if request.GET.items() != []:
        req = str(request.GET.items()[0])
        search = re.findall('[\d]+\.[\d]+', str(req))
        if len(search) > 7:
            try:
                tuple_of_coordinates = []
                print search
                inProj = Proj(init='epsg:3857')
                outProj = Proj(init='epsg:4326')
                for i in range(0, len(search) - 1, 2):
                    print 123
                    tuple_of_coordinates.append(
                        (transform(inProj, outProj, float(search[i]),
                                   float(search[i + 1]))))
                queryset = Finalelim.objects.filter(
                    geom__contained=(Polygon(tuple(tuple_of_coordinates))))

                pl = sum(
                    map(lambda i: queryset[i].area_ha, range(len(queryset))))
                type_fields = map(lambda i: queryset[i].comment,
                                  range(len(queryset)))
                print type_fields[0]
                cnt_crop = Counter(type_fields)
                k = cnt_crop[u'кукурудза']
                sn = cnt_crop[u'соняшник']
                sy = cnt_crop[u'соя']
                ins = cnt_crop[u'інші культури']
                k_q = queryset.filter(comment="кукурудза")
                sn_q = queryset.filter(comment="соняшник")
                sy_q = queryset.filter(comment="соя")
                ins_q = queryset.filter(comment="інші культури")
                if k > 0:
                    pl_k = sum(map(lambda i: k_q[i].area_ha, range(len(k_q))))
                else:
                    pl_k = 0
                if sn > 0:
                    pl_sn = sum(
                        map(lambda i: sn_q[i].area_ha, range(len(sn_q))))
                else:
                    pl_sn = 0
                if sy > 0:
                    pl_sy = sum(
                        map(lambda i: sy_q[i].area_ha, range(len(sy_q))))
                else:
                    pl_sy = 0
                if ins > 0:
                    pl_ins = sum(
                        map(lambda i: ins_q[i].area_ha, range(len(ins_q))))
                else:
                    pl_ins = 0

                count = queryset.count()

                if count > 0:
                    return render_to_response(
                        "statistic.html", {
                            "count": queryset.count(),
                            "soya_ha": pl_sy,
                            "soya_cnt": sy,
                            "son_ha": pl_sn,
                            "son_cnt": sn,
                            "k_ha": pl_k,
                            "k_cnt": k,
                            "in_ha": pl_ins,
                            "in_cnt": ins,
                            "pl": pl
                        })
            except:
                return render_to_response("statistic.html", {
                    "count": '0',
                    "pl": '0'
                })
Example #47
0
def convert_from_EPSG4326(xy, dataset):
    """given a list of (lat, lon) encoded in EPSG:4326, returns a list of (x, y) encoded in dataset.crs"""
    inproj, outproj = Proj('EPSG:4326'), dataset.crs

    return list(zip(*transform(inproj, outproj, *zip(*xy))))
Example #48
0
def wgs2jtsk(coords):
    return pyproj.transform(wgs, jtsk, coords[0], coords[1])
Example #49
0
# Read data from differetn file formats
if ifile.endswith('.npy'):

    # Load Numpy binary file to memory
    Points = np.load(ifile)

else:

    # Load ASCII file to memory
    Points = pd.read_csv(ifile, engine="c", header=None, delim_whitespace=True)

    # Convert to numpy array
    Points = pd.DataFrame.as_matrix(Points)

# Convert into stenographic coordinates
(xp, yp) = pyproj.transform(projGeo, projGrd, Points[:, cx], Points[:, cy])

# Test for different types of input
if len(bbox) == 6:

    # Extract bounding box elements
    (xmin, xmax, ymin, ymax) = bbox

else:

    # Create bounding box limits
    (xmin, xmax, ymin,
     ymax) = (xp.min() - 10.0 * dx), (xp.max() +
                                      10.0 * dx), (yp.min() -
                                                   10.0 * dy), (yp.max() +
                                                                10.0 * dy)
def center_to_scene_boundaries(center_lat, center_lon,
                               previous_center_lat,
                               previous_center_lon):
    """
    Given a ll center coordinate generate a polygon geometry
    representing the scenes boundaries

    Input:
      center_lat, center_lon: scene center, degrees
      previous_center_lat, previous_center_lon: previous scene center,
        degrees
    """

    i_proj = Proj('+init=EPSG:4326')

    # Choose appropriate UTM projection for plain coordinates
    w_proj = Proj(longitude_to_utm_epsg(center_lon))
    
    center_ll = (center_lon, center_lat, 0)
    previous_center_ll = (previous_center_lon, previous_center_lat, 0)

    center_plain = transform(i_proj, w_proj, *center_ll)
    previous_center_plain = transform(i_proj, w_proj, *previous_center_ll)
    
    # Compute orbit inclination, which will be the
    # value used for image rotation
    rotation = math.degrees(math.atan((center_plain[1] -
                                       previous_center_plain[1])/
                                      (center_plain[0] -
                                       previous_center_plain[0])))

    #print center_plain
    # Half scene in meters
    hm = 20 * 2906

    plain = dict()
    plain['ul'] = (center_plain[0] - hm, center_plain[1] + hm, 0)
    plain['ur'] = (center_plain[0] + hm, center_plain[1] + hm, 0)
    plain['lr'] = (center_plain[0] + hm, center_plain[1] - hm, 0)
    plain['ll'] = (center_plain[0] - hm, center_plain[1] - hm, 0)
    #print plain

    # Generate and rotate plain polygon
    plain_pol = geometry.Polygon([plain['ul'][:2],plain['ur'][:2],plain['lr'][:2],plain['ll'][:2]])
    plain_pol = rotate(plain_pol, angle=rotation,
                       origin=center_plain[:2], use_radians=False)
    x, y = plain_pol.exterior.coords.xy
    
    # Plain to ll
    llc = dict()
    llc['ul'] = transform(w_proj, i_proj, x[0], y[0], 0)
    llc['ur'] = transform(w_proj, i_proj, x[1], y[1], 0)
    llc['lr'] = transform(w_proj, i_proj, x[2], y[2], 0)
    llc['ll'] = transform(w_proj, i_proj, x[3], y[3], 0)

    # Adjust for dateline crossing
    ref_lon = llc['ul'][0]
    dateline_crossing = False
    for coord in llc:
        if abs(llc[coord][0] - ref_lon) > 10.:
            # We are crossing the dateline
            dateline_crossing = True
    llc_adjusted = dict()        
    if dateline_crossing:
        # All longitudes are adjusted to positive values
        for coord in llc:
            if llc[coord][0] < 0.:
                llc_adjusted[coord] = (360. + llc[coord][0], llc[coord][1], llc[coord][2])
            else:
                llc_adjusted[coord] = llc[coord]
    else:
        llc_adjusted = llc
    
    # Create output geometry
    pol = geometry.Polygon([llc_adjusted['ul'][:2],llc_adjusted['ur'][:2],
                            llc_adjusted['lr'][:2],llc_adjusted['ll'][:2]])
   
    return pol
Example #51
0
def match_satellite_to_insitu(tile_ids, primary_b, matchup_b, parameter_b,
                              tt_b, rt_b, platforms_b, bounding_wkt_b,
                              depth_min_b, depth_max_b):
    the_time = datetime.now()
    tile_ids = list(tile_ids)
    if len(tile_ids) == 0:
        return []
    tile_service = NexusTileService()

    # Determine the spatial temporal extents of this partition of tiles
    tiles_bbox = tile_service.get_bounding_box(tile_ids)
    tiles_min_time = tile_service.get_min_time(tile_ids)
    tiles_max_time = tile_service.get_max_time(tile_ids)

    # Increase spatial extents by the radius tolerance
    matchup_min_lon, matchup_min_lat = add_meters_to_lon_lat(
        tiles_bbox.bounds[0], tiles_bbox.bounds[1], -1 * rt_b.value)
    matchup_max_lon, matchup_max_lat = add_meters_to_lon_lat(
        tiles_bbox.bounds[2], tiles_bbox.bounds[3], rt_b.value)

    # Don't go outside of the search domain
    search_min_x, search_min_y, search_max_x, search_max_y = wkt.loads(
        bounding_wkt_b.value).bounds
    matchup_min_lon = max(matchup_min_lon, search_min_x)
    matchup_min_lat = max(matchup_min_lat, search_min_y)
    matchup_max_lon = min(matchup_max_lon, search_max_x)
    matchup_max_lat = min(matchup_max_lat, search_max_y)

    # Find the centroid of the matchup bounding box and initialize the projections
    matchup_center = box(matchup_min_lon, matchup_min_lat, matchup_max_lon,
                         matchup_max_lat).centroid.coords[0]
    aeqd_proj = pyproj.Proj(proj='aeqd',
                            lon_0=matchup_center[0],
                            lat_0=matchup_center[1])
    lonlat_proj = pyproj.Proj(proj='lonlat')

    # Increase temporal extents by the time tolerance
    matchup_min_time = tiles_min_time - tt_b.value
    matchup_max_time = tiles_max_time + tt_b.value
    print "%s Time to determine spatial-temporal extents for partition %s to %s" % (
        str(datetime.now() - the_time), tile_ids[0], tile_ids[-1])

    # Query edge for all points within the spatial-temporal extents of this partition
    the_time = datetime.now()
    edge_session = requests.Session()
    edge_results = []
    with edge_session:
        for insitudata_name in matchup_b.value.split(','):
            bbox = ','.join([
                str(matchup_min_lon),
                str(matchup_min_lat),
                str(matchup_max_lon),
                str(matchup_max_lat)
            ])
            edge_response = query_edge(insitudata_name,
                                       parameter_b.value,
                                       matchup_min_time,
                                       matchup_max_time,
                                       bbox,
                                       platforms_b.value,
                                       depth_min_b.value,
                                       depth_max_b.value,
                                       session=edge_session)
            if edge_response['totalResults'] == 0:
                continue
            r = edge_response['results']
            for p in r:
                p['source'] = insitudata_name
            edge_results.extend(r)
    print "%s Time to call edge for partition %s to %s" % (
        str(datetime.now() - the_time), tile_ids[0], tile_ids[-1])
    if len(edge_results) == 0:
        return []

    # Convert edge points to utm
    the_time = datetime.now()
    matchup_points = np.ndarray((len(edge_results), 2), dtype=np.float32)
    for n, edge_point in enumerate(edge_results):
        try:
            x, y = wkt.loads(edge_point['point']).coords[0]
        except ReadingError:
            try:
                x, y = Point(
                    *[float(c)
                      for c in edge_point['point'].split(' ')]).coords[0]
            except ValueError:
                y, x = Point(
                    *[float(c)
                      for c in edge_point['point'].split(',')]).coords[0]

        matchup_points[n][0], matchup_points[n][1] = pyproj.transform(
            p1=lonlat_proj, p2=aeqd_proj, x=x, y=y)
    print "%s Time to convert match points for partition %s to %s" % (
        str(datetime.now() - the_time), tile_ids[0], tile_ids[-1])

    # Build kdtree from matchup points
    the_time = datetime.now()
    m_tree = spatial.cKDTree(matchup_points, leafsize=30)
    print "%s Time to build matchup tree" % (str(datetime.now() - the_time))

    # The actual matching happens in the generator. This is so that we only load 1 tile into memory at a time
    match_generators = [
        match_tile_to_point_generator(tile_service, tile_id, m_tree,
                                      edge_results, bounding_wkt_b.value,
                                      parameter_b.value, rt_b.value,
                                      lonlat_proj, aeqd_proj)
        for tile_id in tile_ids
    ]

    return chain(*match_generators)
Example #52
0
    def convert_to_EPSG4326(self, xy, dataset):
        """given a list of (x, y) encoded in dataset.crs, returns a list of (x, y) encoded in EPSG4326"""

        inproj, outproj = dataset.crs, Proj('EPSG:4326')

        return list(zip(*transform(inproj, outproj, *zip(*xy))))
def covert_coordinate_from_4326_to_DC(lat, lon):
    # covert to meter
    inProj = Proj(init='epsg:4326')
    outProj = Proj(init='epsg:26985')
    lon2, lat2 = transform(inProj, outProj, lon, lat)
    return (lat2, lon2)
Example #54
0
def transform(x_coords, y_coords, src_prj=None, dst_prj=None):
    """Calculate projection coordinates."""
    return pyproj.transform(src_prj, dst_prj, x_coords, y_coords)
Example #55
0
def xy_to_latlon(image, x, y):
    east, north = image.xy(x, y)
    p1 = Proj(image.crs)
    p2 = Proj(proj=LATLONG, datum=WGS84)
    lon, lat = transform(p1, p2, east, north)
    return lat, lon
def covert_coordinate_from_DC_to_4326(lat, lon):
    outProj = Proj(init='epsg:4326')
    inProj = Proj(init='epsg:26985')
    lon2, lat2 = transform(inProj, outProj, lon, lat)
    return (lat2, lon2)
        #except: pass
        print(
            "Humm... an empty response. Are you sure about the exact OSM tag for your region ?"
        )
        print("Exiting with no extent created.")
        del (vector_map)
        time.sleep(1)
        sys.exit(0)
    if epsg_code != '4326':
        name += '_' + epsg_code
        print("Changing coordinates to match EPSG code")
        import pyproj
        import shapely.ops
        s_proj = pyproj.Proj(init='epsg:4326')
        t_proj = pyproj.Proj(init='epsg:' + epsg_code)
        reprojection = lambda x, y: pyproj.transform(s_proj, t_proj, x, y)
        multipolygon_area = shapely.ops.transform(reprojection,
                                                  multipolygon_area)

    vector_map.encode_MultiPolygon(multipolygon_area,
                                   VECT.dummy_alt,
                                   'WATER',
                                   check=True,
                                   cut=False)
    vector_map.write_node_file(name + '.node')
    vector_map.write_poly_file(name + '.poly')
    print("Triangulate...")
    MESH.triangulate(name, os.path.join(os.path.dirname(sys.argv[0]), '..'))
    ((xmin, ymin, xmax, ymax),
     mask_im) = triangulation_to_image(name, pixel_size, grid_size_or_bbox)
    print("Mask size : ", mask_im.size, "pixels.")
Example #58
0
def xyz2lb(x,y,z):
    inproj = pyproj.Proj("+proj=geocent +datum=WGS84 +units=m +no_defs")
    outproj = pyproj.Proj("+proj=longlat +datum=WGS84 +no_defs")
    val= pyproj.transform(inproj, outproj, x,y,z)
    return([val[1],val[0]])
Example #59
0
def trans_wgs_egsa(x, y, z):
    ex, ey, ez = transform(wgs, egsa, x, y, z)
    return ex, ey, ez
Example #60
0
    def init_from_wgs84_params(
            cls,
            sensor_lon_decimal_degrees,  # type: float
            sensor_lat_decimal_degrees,  # type: float
            sensor_altitude,  # type: float
            omega,  # type: float
            phi,  # type: float
            kappa,  # type: float
            npix_x,  # type: int
            npix_y,  # type: int
            pixel_pitch_x,  # type: float
            pixel_pitch_y,  # type: float
            focal_length,  # type: float
            alt_units='meters',  # type: str
            omega_units='radians',  # type: str
            phi_units='radians',  # type: str
            kappa_units='radians',  # type: str
            pixel_pitch_x_units='micrometer',  # type: str
            pixel_pitch_y_units='micrometer',  # type: str
            focal_length_units='mm',  # type: str
            flip_x=False,  # type: bool
            flip_y=False,  # type: bool
    ):  # type: (...) -> IdealPinholeFpaLocalUtmPointCalc
        """

        :param sensor_lon_decimal_degrees:
        :param sensor_lat_decimal_degrees:
        :param sensor_altitude:
        :param omega:
        :param phi:
        :param kappa:
        :param npix_x:
        :param npix_y:
        :param pixel_pitch_x:
        :param pixel_pitch_y:
        :param focal_length:
        :param alt_units:
        :param omega_units:
        :param phi_units:
        :param kappa_units:
        :param pixel_pitch_x_units:
        :param pixel_pitch_y_units:
        :param focal_length_units:
        :param flip_x:
        :param flip_y:
        :return:

        For now the altitude must be relative to the DEM used for orthorectification.
        For example, if the DEM is relative to the geoid, then sensor_altitude must also be relative to the geoid too.
        """
        native_proj = proj_utils.decimal_degrees_to_local_utm_proj(
            sensor_lon_decimal_degrees, sensor_lat_decimal_degrees)
        proj_4326 = crs_defs.PROJ_4326

        sensor_x_local, sensor_y_local = transform(proj_4326, native_proj,
                                                   sensor_lon_decimal_degrees,
                                                   sensor_lat_decimal_degrees)

        utm_point_calc = IdealPinholeFpaLocalUtmPointCalc()

        pinhole_camera = PinholeCamera()
        pinhole_camera.init_pinhole_from_coeffs(
            sensor_x_local,
            sensor_y_local,
            sensor_altitude,
            omega,
            phi,
            kappa,
            focal_length,
            x_units='meters',
            y_units='meters',
            z_units=alt_units,
            omega_units=omega_units,
            phi_units=phi_units,
            kappa_units=kappa_units,
            focal_length_units=focal_length_units)

        utm_point_calc.set_projection(native_proj)

        pp_x_meters = pixel_pitch_x * ureg.parse_expression(
            pixel_pitch_x_units)
        pp_y_meters = pixel_pitch_y * ureg.parse_expression(
            pixel_pitch_y_units)

        pp_x_meters = pp_x_meters.to('meters').magnitude
        pp_y_meters = pp_y_meters.to('meters').magnitude

        utm_point_calc._pixel_pitch_x_meters = pp_x_meters
        utm_point_calc._pixel_pitch_y_meters = pp_y_meters
        utm_point_calc.set_approximate_lon_lat_center(sensor_x_local,
                                                      sensor_y_local)
        utm_point_calc._npix_x = npix_x
        utm_point_calc._npix_y = npix_y
        utm_point_calc._flip_x = flip_x
        utm_point_calc._flip_y = flip_y
        utm_point_calc._pinhole_camera = pinhole_camera
        return utm_point_calc