pyresample API

pyresample.geometry

Classes for geometry operations

class pyresample.geometry.AreaDefinition(area_id, name, proj_id, proj_dict, x_size, y_size, area_extent, nprocs=1, lons=None, lats=None, dtype=<Mock object at 0x7fa6e376e250>)

Holds definition of an area.

Parameters:
area_id : str
ID of area
name : str
Name of area
proj_id : str
ID of projection
proj_dict : dict
Dictionary with Proj.4 parameters
x_size : int
x dimension in number of pixels
y_size : int
y dimension in number of pixels
area_extent : list
Area extent as a list (LL_x, LL_y, UR_x, UR_y)
nprocs : int, optional
Number of processor cores to be used
lons : numpy array, optional
Grid lons
lats : numpy array, optional
Grid lats
Attributes:
area_id : str
ID of area
name : str
Name of area
proj_id : str
ID of projection
proj_dict : dict
Dictionary with Proj.4 parameters
x_size : int
x dimension in number of pixels
y_size : int
y dimension in number of pixels
shape : tuple
Corresponding array shape as (rows, cols)
size : int
Number of points in grid
area_extent : tuple
Area extent as a tuple (LL_x, LL_y, UR_x, UR_y)
area_extent_ll : tuple
Area extent in lons lats as a tuple (LL_lon, LL_lat, UR_lon, UR_lat)
pixel_size_x : float
Pixel width in projection units
pixel_size_y : float
Pixel height in projection units
pixel_upper_left : list
Coordinates (x, y) of center of upper left pixel in projection units
pixel_offset_x : float
x offset between projection center and upper left corner of upper left pixel in units of pixels.
pixel_offset_y : float
y offset between projection center and upper left corner of upper left pixel in units of pixels..

Properties: proj4_string : str

Projection defined as Proj.4 string
lons : object
Grid lons
lats : object
Grid lats
cartesian_coords : object
Grid cartesian coordinates
projection_x_coords : object
Grid projection x coordinate
projection_y_coords : object
Grid projection y coordinate
get_lonlat(row, col)

Retrieves lon and lat values of single point in area grid

Parameters:

row : int col : int

Returns:

(lon, lat) : tuple of floats

get_lonlats(nprocs=None, data_slice=None, cache=False, dtype=None)

Returns lon and lat arrays of area.

Parameters:
nprocs : int, optional
Number of processor cores to be used. Defaults to the nprocs set when instantiating object
data_slice : slice object, optional
Calculate only coordinates for specified slice
cache : bool, optional
Store result the result. Requires data_slice to be None
Returns:
(lons, lats) : tuple of numpy arrays
Grids of area lons and and lats
get_proj_coords(data_slice=None, cache=False, dtype=None)

Get projection coordinates of grid

Parameters:
data_slice : slice object, optional
Calculate only coordinates for specified slice
cache : bool, optional
Store result the result. Requires data_slice to be None
Returns:
(target_x, target_y) : tuple of numpy arrays
Grids of area x- and y-coordinates in projection units
get_xy_from_lonlat(lon, lat)

Retrieve closest x and y coordinates (column, row indices) for the specified geolocation (lon,lat) if inside area. If lon,lat is a point a ValueError is raised if the return point is outside the area domain. If lon,lat is a tuple of sequences of longitudes and latitudes, a tuple of masked arrays are returned.

Input:

lon : point or sequence (list or array) of longitudes lat : point or sequence (list or array) of latitudes

Returns:

(x, y) : tuple of integer points/arrays

outer_boundary_corners

Returns the lon,lat of the outer edges of the corner points

proj4_string

Returns projection definition as Proj.4 string

class pyresample.geometry.BaseDefinition(lons=None, lats=None, nprocs=1)

Base class for geometry definitions

corners

Returns the corners of the current area.

get_area()

Get the area of the convex area defined by the corners of the current area.

get_boundary_lonlats()

Returns Boundary objects

get_cartesian_coords(nprocs=None, data_slice=None, cache=False)

Retrieve cartesian coordinates of geometry definition

Parameters:
nprocs : int, optional
Number of processor cores to be used. Defaults to the nprocs set when instantiating object
data_slice : slice object, optional
Calculate only cartesian coordnates for the defined slice
cache : bool, optional
Store result the result. Requires data_slice to be None
Returns:

cartesian_coords : numpy array

get_lonlat(row, col)

Retrieve lon and lat of single pixel

Parameters:

row : int col : int

Returns:

(lon, lat) : tuple of floats

get_lonlats(data_slice=None, **kwargs)

Base method for lon lat retrieval with slicing

intersection(other)

Returns the corners of the intersection polygon of the current area with other.

Parameters:
other : object
Instance of subclass of BaseDefinition
Returns:

(corner1, corner2, corner3, corner4) : tuple of points

overlap_rate(other)

Get how much the current area overlaps an other area.

Parameters:
other : object
Instance of subclass of BaseDefinition
Returns:

overlap_rate : float

overlaps(other)

Tests if the current area overlaps the other area. This is based solely on the corners of areas, assuming the boundaries to be great circles.

Parameters:
other : object
Instance of subclass of BaseDefinition
Returns:

overlaps : bool

class pyresample.geometry.Boundary(side1, side2, side3, side4)

Container for geometry boundary. Labelling starts in upper left corner and proceeds clockwise

class pyresample.geometry.CoordinateDefinition(lons, lats, nprocs=1)

Base class for geometry definitions defined by lons and lats only

class pyresample.geometry.GridDefinition(lons, lats, nprocs=1)

Grid defined by lons and lats

Parameters:

lons : numpy array lats : numpy array nprocs : int, optional

Number of processor cores to be used for calculations.
Attributes:
shape : tuple
Grid shape as (rows, cols)
size : int
Number of elements in grid

Properties: lons : object

Grid lons
lats : object
Grid lats
cartesian_coords : object
Grid cartesian coordinates
class pyresample.geometry.SwathDefinition(lons, lats, nprocs=1)

Swath defined by lons and lats

Parameters:

lons : numpy array lats : numpy array nprocs : int, optional

Number of processor cores to be used for calculations.
Attributes:
shape : tuple
Swath shape
size : int
Number of elements in swath
ndims : int
Swath dimensions

Properties: lons : object

Swath lons
lats : object
Swath lats
cartesian_coords : object
Swath cartesian coordinates

pyresample.image

Handles resampling of images with assigned geometry definitions

class pyresample.image.ImageContainer(image_data, geo_def, fill_value=0, nprocs=1)

Holds image with geometry definition. Allows indexing with linesample arrays.

Parameters:
image_data : numpy array
Image data
geo_def : object
Geometry definition
fill_value : {int, None} optional
Set undetermined pixels to this value. If fill_value is None a masked array is returned with undetermined pixels masked
nprocs : int, optional
Number of processor cores to be used
Attributes:
image_data : numpy array
Image data
geo_def : object
Geometry definition
fill_value : {int, None}
Resample result fill value
nprocs : int
Number of processor cores to be used for geometry operations
get_array_from_linesample(row_indices, col_indices)

Samples from image based on index arrays.

Parameters:
row_indices : numpy array
Row indices. Dimensions must match col_indices
col_indices : numpy array
Col indices. Dimensions must match row_indices
Returns:
image_data : numpy_array
Resampled image data
get_array_from_neighbour_info(*args, **kwargs)

Base method for resampling from preprocessed data.

resample(target_geo_def)

Base method for resampling

class pyresample.image.ImageContainerNearest(image_data, geo_def, radius_of_influence, epsilon=0, fill_value=0, reduce_data=True, nprocs=1, segments=None)

Holds image with geometry definition. Allows nearest neighbour resampling to new geometry definition.

Parameters:
image_data : numpy array
Image data
geo_def : object
Geometry definition
radius_of_influence : float
Cut off distance in meters
epsilon : float, optional
Allowed uncertainty in meters. Increasing uncertainty reduces execution time
fill_value : {int, None} optional
Set undetermined pixels to this value. If fill_value is None a masked array is returned with undetermined pixels masked
reduce_data : bool, optional
Perform coarse data reduction before resampling in order to reduce execution time
nprocs : int, optional
Number of processor cores to be used for geometry operations
segments : {int, None}
Number of segments to use when resampling. If set to None an estimate will be calculated
Attributes:
image_data : numpy array
Image data
geo_def : object
Geometry definition
radius_of_influence : float
Cut off distance in meters
epsilon : float
Allowed uncertainty in meters
fill_value : {int, None}
Resample result fill value
reduce_data : bool
Perform coarse data reduction before resampling
nprocs : int
Number of processor cores to be used
segments : {int, None}
Number of segments to use when resampling
resample(target_geo_def)

Resamples image to area definition using nearest neighbour approach

Parameters:
target_geo_def : object
Target geometry definition
Returns:
image_container : object
ImageContainerNearest object of resampled geometry
class pyresample.image.ImageContainerQuick(image_data, geo_def, fill_value=0, nprocs=1, segments=None)

Holds image with area definition. ‘ Allows quick resampling within area.

Parameters:
image_data : numpy array
Image data
geo_def : object
Area definition as AreaDefinition object
fill_value : {int, None} optional
Set undetermined pixels to this value. If fill_value is None a masked array is returned with undetermined pixels masked
nprocs : int, optional
Number of processor cores to be used for geometry operations
segments : {int, None}
Number of segments to use when resampling. If set to None an estimate will be calculated
Attributes:
image_data : numpy array
Image data
geo_def : object
Area definition as AreaDefinition object
fill_value : {int, None}
Resample result fill value If fill_value is None a masked array is returned with undetermined pixels masked
nprocs : int
Number of processor cores to be used
segments : {int, None}
Number of segments to use when resampling
resample(target_area_def)

Resamples image to area definition using nearest neighbour approach in projection coordinates.

Parameters:
target_area_def : object
Target area definition as AreaDefinition object
Returns:
image_container : object
ImageContainerQuick object of resampled area

pyresample.grid

Resample image from one projection to another using nearest neighbour method in cartesian projection coordinate systems

pyresample.grid.get_image_from_linesample(row_indices, col_indices, source_image, fill_value=0)

Samples from image based on index arrays.

Parameters:
row_indices : numpy array
Row indices. Dimensions must match col_indices
col_indices : numpy array
Col indices. Dimensions must match row_indices
source_image : numpy array
Source image
fill_value : {int, None} optional
Set undetermined pixels to this value. If fill_value is None a masked array is returned with undetermined pixels masked
Returns:
image_data : numpy array
Resampled image
pyresample.grid.get_image_from_lonlats(lons, lats, source_area_def, source_image_data, fill_value=0, nprocs=1)

Samples from image based on lon lat arrays using nearest neighbour method in cartesian projection coordinate systems.

Parameters:
lons : numpy array
Lons. Dimensions must match lats
lats : numpy array
Lats. Dimensions must match lons
source_area_def : object
Source definition as AreaDefinition object
source_image_data : numpy array
Source image data
fill_value : {int, None} optional
Set undetermined pixels to this value. If fill_value is None a masked array is returned with undetermined pixels masked
nprocs : int, optional
Number of processor cores to be used
Returns:
image_data : numpy array
Resampled image data
pyresample.grid.get_linesample(lons, lats, source_area_def, nprocs=1)

Returns index row and col arrays for resampling

Parameters:
lons : numpy array
Lons. Dimensions must match lats
lats : numpy array
Lats. Dimensions must match lons
source_area_def : object
Source definition as AreaDefinition object
nprocs : int, optional
Number of processor cores to be used
Returns:
(row_indices, col_indices) : tuple of numpy arrays
Arrays for resampling area by array indexing
pyresample.grid.get_resampled_image(target_area_def, source_area_def, source_image_data, fill_value=0, nprocs=1, segments=None)

Resamples image using nearest neighbour method in cartesian projection coordinate systems.

Parameters:
target_area_def : object
Target definition as AreaDefinition object
source_area_def : object
Source definition as AreaDefinition object
source_image_data : numpy array
Source image data
fill_value : {int, None} optional
Set undetermined pixels to this value. If fill_value is None a masked array is returned with undetermined pixels masked
nprocs : int, optional
Number of processor cores to be used
segments : {int, None} optional
Number of segments to use when resampling. If set to None an estimate will be calculated.
Returns:
image_data : numpy array
Resampled image data

pyresample.kd_tree

Handles reprojection of geolocated data. Several types of resampling are supported

pyresample.kd_tree.get_neighbour_info(source_geo_def, target_geo_def, radius_of_influence, neighbours=8, epsilon=0, reduce_data=True, nprocs=1, segments=None)

Returns neighbour info

Parameters:
source_geo_def : object
Geometry definition of source
target_geo_def : object
Geometry definition of target
radius_of_influence : float
Cut off distance in meters
neighbours : int, optional
The number of neigbours to consider for each grid point
epsilon : float, optional
Allowed uncertainty in meters. Increasing uncertainty reduces execution time
fill_value : {int, None}, optional
Set undetermined pixels to this value. If fill_value is None a masked array is returned with undetermined pixels masked
reduce_data : bool, optional
Perform initial coarse reduction of source dataset in order to reduce execution time
nprocs : int, optional
Number of processor cores to be used
segments : {int, None}
Number of segments to use when resampling. If set to None an estimate will be calculated
Returns:

(valid_input_index, valid_output_index, index_array, distance_array) : tuple of numpy arrays

Neighbour resampling info
pyresample.kd_tree.get_sample_from_neighbour_info(resample_type, output_shape, data, valid_input_index, valid_output_index, index_array, distance_array=None, weight_funcs=None, fill_value=0, with_uncert=False)

Resamples swath based on neighbour info

Parameters:
resample_type : {‘nn’, ‘custom’}
‘nn’: Use nearest neighbour resampling ‘custom’: Resample based on weight_funcs
output_shape : (int, int)
Shape of output as (rows, cols)
data : numpy array
Source data
valid_input_index : numpy array
valid_input_index from get_neighbour_info
valid_output_index : numpy array
valid_output_index from get_neighbour_info
index_array : numpy array
index_array from get_neighbour_info
distance_array : numpy array, optional
distance_array from get_neighbour_info Not needed for ‘nn’ resample type
weight_funcs : list of function objects or function object, optional
List of weight functions f(dist) to use for the weighting of each channel 1 to k. If only one channel is resampled weight_funcs is a single function object. Must be supplied when using ‘custom’ resample type
fill_value : {int, None}, optional
Set undetermined pixels to this value. If fill_value is None a masked array is returned with undetermined pixels masked
Returns:
result : numpy array
Source data resampled to target geometry
pyresample.kd_tree.resample_custom(source_geo_def, data, target_geo_def, radius_of_influence, weight_funcs, neighbours=8, epsilon=0, fill_value=0, reduce_data=True, nprocs=1, segments=None, with_uncert=False)

Resamples data using kd-tree custom radial weighting neighbour approach

Parameters:
source_geo_def : object
Geometry definition of source
data : numpy array
Array of single channel data points or (source_geo_def.shape, k) array of k channels of datapoints
target_geo_def : object
Geometry definition of target
radius_of_influence : float
Cut off distance in meters
weight_funcs : list of function objects or function object
List of weight functions f(dist) to use for the weighting of each channel 1 to k. If only one channel is resampled weight_funcs is a single function object.
neighbours : int, optional
The number of neigbours to consider for each grid point
epsilon : float, optional
Allowed uncertainty in meters. Increasing uncertainty reduces execution time
fill_value : {int, None}, optional
Set undetermined pixels to this value. If fill_value is None a masked array is returned with undetermined pixels masked
reduce_data : bool, optional
Perform initial coarse reduction of source dataset in order to reduce execution time
nprocs : int, optional
Number of processor cores to be used
segments : {int, None}
Number of segments to use when resampling. If set to None an estimate will be calculated
Returns:
data : numpy array (default)
Source data resampled to target geometry
data, stddev, counts : numpy array, numpy array, numpy array (if with_uncert == True)
Source data resampled to target geometry. Weighted standard devaition for all pixels having more than one source value Counts of number of source values used in weighting per pixel
pyresample.kd_tree.resample_gauss(source_geo_def, data, target_geo_def, radius_of_influence, sigmas, neighbours=8, epsilon=0, fill_value=0, reduce_data=True, nprocs=1, segments=None, with_uncert=False)

Resamples data using kd-tree gaussian weighting neighbour approach

Parameters:
source_geo_def : object
Geometry definition of source
data : numpy array
Array of single channel data points or (source_geo_def.shape, k) array of k channels of datapoints
target_geo_def : object
Geometry definition of target
radius_of_influence : float
Cut off distance in meters
sigmas : list of floats or float
List of sigmas to use for the gauss weighting of each channel 1 to k, w_k = exp(-dist^2/sigma_k^2). If only one channel is resampled sigmas is a single float value.
neighbours : int, optional
The number of neigbours to consider for each grid point
epsilon : float, optional
Allowed uncertainty in meters. Increasing uncertainty reduces execution time
fill_value : {int, None}, optional
Set undetermined pixels to this value. If fill_value is None a masked array is returned with undetermined pixels masked
reduce_data : bool, optional
Perform initial coarse reduction of source dataset in order to reduce execution time
nprocs : int, optional
Number of processor cores to be used
segments : {int, None}
Number of segments to use when resampling. If set to None an estimate will be calculated
with_uncert : bool, optional
Calculate uncertainty estimates
Returns:
data : numpy array (default)
Source data resampled to target geometry
data, stddev, counts : numpy array, numpy array, numpy array (if with_uncert == True)
Source data resampled to target geometry. Weighted standard devaition for all pixels having more than one source value Counts of number of source values used in weighting per pixel
pyresample.kd_tree.resample_nearest(source_geo_def, data, target_geo_def, radius_of_influence, epsilon=0, fill_value=0, reduce_data=True, nprocs=1, segments=None)

Resamples data using kd-tree nearest neighbour approach

Parameters:
source_geo_def : object
Geometry definition of source
data : numpy array
1d array of single channel data points or (source_size, k) array of k channels of datapoints
target_geo_def : object
Geometry definition of target
radius_of_influence : float
Cut off distance in meters
epsilon : float, optional
Allowed uncertainty in meters. Increasing uncertainty reduces execution time
fill_value : {int, None}, optional
Set undetermined pixels to this value. If fill_value is None a masked array is returned with undetermined pixels masked
reduce_data : bool, optional
Perform initial coarse reduction of source dataset in order to reduce execution time
nprocs : int, optional
Number of processor cores to be used
segments : {int, None}
Number of segments to use when resampling. If set to None an estimate will be calculated
Returns:
data : numpy array
Source data resampled to target geometry
pyresample.kd_tree.which_kdtree()

Returns the name of the kdtree used for resampling

pyresample.utils

Utility functions for pyresample

exception pyresample.utils.AreaNotFound

Exception raised when specified are is no found in file

pyresample.utils.fwhm2sigma(fwhm)

Calculate sigma for gauss function from FWHM (3 dB level)

Parameters:
fwhm : float
FWHM of gauss function (3 dB level of beam footprint)
Returns:
sigma : float
sigma for use in resampling gauss function
pyresample.utils.generate_nearest_neighbour_linesample_arrays(source_area_def, target_area_def, radius_of_influence, nprocs=1)

Generate linesample arrays for nearest neighbour grid resampling

Parameters:
source_area_def : object
Source area definition as AreaDefinition object
target_area_def : object
Target area definition as AreaDefinition object
radius_of_influence : float
Cut off distance in meters
nprocs : int, optional
Number of processor cores to be used
Returns:

(row_indices, col_indices) : tuple of numpy arrays

pyresample.utils.generate_quick_linesample_arrays(source_area_def, target_area_def, nprocs=1)

Generate linesample arrays for quick grid resampling

Parameters:
source_area_def : object
Source area definition as AreaDefinition object
target_area_def : object
Target area definition as AreaDefinition object
nprocs : int, optional
Number of processor cores to be used
Returns:

(row_indices, col_indices) : tuple of numpy arrays

pyresample.utils.get_area_def(area_id, area_name, proj_id, proj4_args, x_size, y_size, area_extent)

Construct AreaDefinition object from arguments

Parameters:
area_id : str
ID of area
proj_id : str
ID of projection
area_name :str
Description of area
proj4_args : list or str
Proj4 arguments as list of arguments or string
x_size : int
Number of pixel in x dimension
y_size : int
Number of pixel in y dimension
area_extent : list
Area extent as a list of ints (LL_x, LL_y, UR_x, UR_y)
Returns:
area_def : object
AreaDefinition object
pyresample.utils.load_area(area_file_name, *regions)

Load area(s) from area file

Parameters:
area_file_name : str
Path to area definition file
regions : str argument list
Regions to parse. If no regions are specified all regions in the file are returned
Returns:
area_defs : object or list
If one area name is specified a single AreaDefinition object is returned If several area names are specified a list of AreaDefinition objects is returned
Raises:
AreaNotFound
If a specified area name is not found
pyresample.utils.parse_area_file(area_file_name, *regions)

Parse area information from area file

Parameters:
area_file_name : str
Path to area definition file
regions : str argument list
Regions to parse. If no regions are specified all regions in the file are returned
Returns:
area_defs : list
List of AreaDefinition objects
Raises:
AreaNotFound
If a specified area is not found
pyresample.utils.wrap_longitudes(lons)

Wrap longitudes to the [-180:+180[ validity range (preserves dtype)

Parameters:
lons : numpy array
Longitudes in degrees
Returns:
lons : numpy array
Longitudes wrapped into [-180:+180[ validity range

pyresample.data_reduce

Reduce data sets based on geographical information

pyresample.data_reduce.get_valid_index_from_cartesian_grid(cart_grid, lons, lats, radius_of_influence)

Calculates relevant data indices using coarse data reduction of swath data by comparison with cartesian grid

Parameters:
chart_grid : numpy array
Grid of area cartesian coordinates
lons : numpy array
Swath lons
lats : numpy array
Swath lats
data : numpy array
Swath data
radius_of_influence : float
Cut off distance in meters
Returns:
valid_index : numpy array
Boolean array of same size as lons and lats indicating relevant indices
pyresample.data_reduce.get_valid_index_from_lonlat_boundaries(boundary_lons, boundary_lats, lons, lats, radius_of_influence)

Find relevant indices from grid boundaries using the winding number theorem

pyresample.data_reduce.get_valid_index_from_lonlat_grid(grid_lons, grid_lats, lons, lats, radius_of_influence)

Calculates relevant data indices using coarse data reduction of swath data by comparison with lon lat grid

Parameters:
chart_grid : numpy array
Grid of area cartesian coordinates
lons : numpy array
Swath lons
lats : numpy array
Swath lats
data : numpy array
Swath data
radius_of_influence : float
Cut off distance in meters
Returns:
valid_index : numpy array
Boolean array of same size as lon and lat indicating relevant indices
pyresample.data_reduce.swath_from_cartesian_grid(cart_grid, lons, lats, data, radius_of_influence)

Makes coarse data reduction of swath data by comparison with cartesian grid

Parameters:
chart_grid : numpy array
Grid of area cartesian coordinates
lons : numpy array
Swath lons
lats : numpy array
Swath lats
data : numpy array
Swath data
radius_of_influence : float
Cut off distance in meters
Returns:
(lons, lats, data) : list of numpy arrays
Reduced swath data and coordinate set
pyresample.data_reduce.swath_from_lonlat_boundaries(boundary_lons, boundary_lats, lons, lats, data, radius_of_influence)

Makes coarse data reduction of swath data by comparison with lon lat boundary

Parameters:
boundary_lons : numpy array
Grid of area lons
boundary_lats : numpy array
Grid of area lats
lons : numpy array
Swath lons
lats : numpy array
Swath lats
data : numpy array
Swath data
radius_of_influence : float
Cut off distance in meters
Returns:
(lons, lats, data) : list of numpy arrays
Reduced swath data and coordinate set
pyresample.data_reduce.swath_from_lonlat_grid(grid_lons, grid_lats, lons, lats, data, radius_of_influence)

Makes coarse data reduction of swath data by comparison with lon lat grid

Parameters:
grid_lons : numpy array
Grid of area lons
grid_lats : numpy array
Grid of area lats
lons : numpy array
Swath lons
lats : numpy array
Swath lats
data : numpy array
Swath data
radius_of_influence : float
Cut off distance in meters
Returns:
(lons, lats, data) : list of numpy arrays
Reduced swath data and coordinate set

pyresample.plot

plot.area_def2basemap(area_def, **kwargs)

Get Basemap object from AreaDefinition

Parameters:
area_def : object
geometry.AreaDefinition object
**kwargs: Keyword arguments
Additional initialization arguments for Basemap
Returns:

bmap : Basemap object

plot.ellps2axis(ellps_name)

Get semi-major and semi-minor axis from ellipsis definition

Parameters:
ellps_name : str
Standard name of ellipsis
Returns:

(a, b) : semi-major and semi-minor axis

plot.save_quicklook(filename, area_def, data, vmin=None, vmax=None, label='Variable (units)', num_meridians=45, num_parallels=10, coast_res='c', backend='AGG')

Display default quicklook plot

Parameters:
filename : str
path to output file
area_def : object
geometry.AreaDefinition object
data : numpy array | numpy masked array
2D array matching area_def. Use masked array for transparent values
vmin : float, optional
Min value for luminescence scaling
vmax : float, optional
Max value for luminescence scaling
label : str, optional
Label for data
num_meridians : int, optional
Number of meridians to plot on the globe
num_parallels : int, optional
Number of parallels to plot on the globe
coast_res : {‘c’, ‘l’, ‘i’, ‘h’, ‘f’}, optional
Resolution of coastlines
backend : str, optional
matplotlib backend to use’
plot.show_quicklook(area_def, data, vmin=None, vmax=None, label='Variable (units)', num_meridians=45, num_parallels=10, coast_res='c')

Display default quicklook plot

Parameters:
area_def : object
geometry.AreaDefinition object
data : numpy array | numpy masked array
2D array matching area_def. Use masked array for transparent values
vmin : float, optional
Min value for luminescence scaling
vmax : float, optional
Max value for luminescence scaling
label : str, optional
Label for data
num_meridians : int, optional
Number of meridians to plot on the globe
num_parallels : int, optional
Number of parallels to plot on the globe
coast_res : {‘c’, ‘l’, ‘i’, ‘h’, ‘f’}, optional
Resolution of coastlines
Returns:

bmap : Basemap object

Table Of Contents

Previous topic

Reduction of swath data

This Page