# pyresample API

## pyresample.geometry

Classes for geometry operations.

class `pyresample.geometry.``AreaDefinition`(area_id, description, proj_id, projection, width, height, area_extent, rotation=None, nprocs=1, lons=None, lats=None, dtype=<class 'numpy.float64'>)

  Holds definition of an area.

  Parameters:

  - area_id (str) – Identifier for the area
  - description (str) – Human-readable description of the area
  - proj_id (str) – ID of projection
  - projection (dict or str) – Dictionary or string of Proj.4 parameters
  - width (int) – x dimension in number of pixels, aka number of grid columns
  - height (int) – y dimension in number of pixels, aka number of grid rows
  - rotation (float) – rotation in degrees (negative is cw)
  - area_extent (list) – Area extent as a list (lower_left_x, lower_left_y, upper_right_x, upper_right_y)
  - nprocs (int, optional) – Number of processor cores to be used for certain calculations

  `area_id`

    Identifier for the area

    Type: | str

  `description`

    Human-readable description of the area

    Type: | str

  `proj_id`

    ID of projection

    Type: | str

  `projection`

    Dictionary or string with Proj.4 parameters

    Type: | dict or str

  `width`

    x dimension in number of pixels, aka number of grid columns

    Type: | int

  `height`

    y dimension in number of pixels, aka number of grid rows

    Type: | int

  `rotation`

    rotation in degrees (negative is cw)

    Type: | float

  `shape`

    Corresponding array shape as (height, width)

    Type: | tuple

  `size`

    Number of points in grid

    Type: | int

  `area_extent`

    Area extent as a tuple (lower_left_x, lower_left_y, upper_right_x, upper_right_y)

    Type: | tuple

  `area_extent_ll`

    Area extent in lons lats as a tuple (lower_left_lon, lower_left_lat, upper_right_lon, upper_right_lat)

    Type: | tuple

  `pixel_size_x`

    Pixel width in projection units

    Type: | float

  `pixel_size_y`

    Pixel height in projection units

    Type: | float

  `resolution`

    the resolution of the resulting area as (pixel_size_x, pixel_size_y).

    Type: | tuple

  `upper_left_extent`

    Coordinates (x, y) of upper left corner of upper left pixel in projection units

    Type: | tuple

  `pixel_upper_left`

    Coordinates (x, y) of center of upper left pixel in projection units

    Type: | tuple

  `pixel_offset_x`

    x offset between projection center and upper left corner of upper left pixel in units of pixels.

    Type: | float

  `pixel_offset_y`

    y offset between projection center and upper left corner of upper left pixel in units of pixels..

    Type: | float

  `proj_str`

    Projection defined as Proj.4 string

    Type: | str

  `cartesian_coords`

    Grid cartesian coordinates

    Type: | object

  `projection_x_coords`

    Grid projection x coordinate

    Type: | object

  `projection_y_coords`

    Grid projection y coordinate

    Type: | object

  `aggregate`(**dims)

    Return an aggregated version of the area.

  `colrow2lonlat`(cols, rows)

    Return lons and lats for the given image columns and rows.

    Both scalars and arrays are supported. To be used with scarse data points instead of slices (see get_lonlats).

  `copy`(**override_kwargs)

    Make a copy of the current area.

    This replaces the current values with anything in override_kwargs.

  `create_areas_def`()

    Generate YAML formatted representation of this area.

  `create_areas_def_legacy`()

    Create area definition in legacy format.

  `crop_around`(other_area)

    Crop this area around other_area.

  classmethod `from_area_of_interest`(area_id, projection, shape, center, resolution, units=None, **kwargs)

    Create an AreaDefinition from center, resolution, and shape.

    Parameters:

    - area_id (str) – ID of area
    - projection (dict or str) – Projection parameters as a proj4_dict or proj4_string
    - shape (list) – Number of pixels in the y and x direction (height, width)
    - center (list) – Center of projection (x, y)
    - resolution (list or float) – Size of pixels: (dx, dy). Can be specified with one value if dx == dy
    - units (str, optional) –

      Units that provided arguments should be interpreted as. This can be one of ‘deg’, ‘degrees’, ‘meters’, ‘metres’, and any parameter supported by the cs2cs -lu command. Units are determined in the following priority:

      1. units expressed with each variable through a DataArray’s attrs attribute.
      2. units passed to `units`
      3. units used in `projection`
      4. meters
    - description (str, optional) – Description/name of area. Defaults to area_id
    - proj_id (str, optional) – ID of projection
    - rotation (float, optional) – rotation in degrees (negative is cw)
    - nprocs (int, optional) – Number of processor cores to be used
    - lons (numpy array, optional) – Grid lons
    - lats (numpy array, optional) – Grid lats

    Returns: | AreaDefinition
    Return type: | AreaDefinition

  classmethod `from_circle`(area_id, projection, center, radius, shape=None, resolution=None, units=None, **kwargs)

    Create an AreaDefinition from center, radius, and shape or from center, radius, and resolution.

    Parameters:

    - area_id (str) – ID of area
    - projection (dict or str) – Projection parameters as a proj4_dict or proj4_string
    - center (list) – Center of projection (x, y)
    - radius (list or float) – Length from the center to the edges of the projection (dx, dy)
    - shape (list, optional) – Number of pixels in the y and x direction (height, width)
    - resolution (list or float, optional) – Size of pixels: (dx, dy)
    - units (str, optional) –

      Units that provided arguments should be interpreted as. This can be one of ‘deg’, ‘degrees’, ‘meters’, ‘metres’, and any parameter supported by the cs2cs -lu command. Units are determined in the following priority:

      1. units expressed with each variable through a DataArray’s attrs attribute.
      2. units passed to `units`
      3. units used in `projection`
      4. meters
    - description (str, optional) – Description/name of area. Defaults to area_id
    - proj_id (str, optional) – ID of projection
    - rotation (float, optional) – rotation in degrees (negative is cw)
    - nprocs (int, optional) – Number of processor cores to be used
    - lons (numpy array, optional) – Grid lons
    - lats (numpy array, optional) – Grid lats
    - optimize_projection – Whether the projection parameters have to be optimized for a DynamicAreaDefinition.

    Returns: | AreaDefinition or DynamicAreaDefinition – If shape or resolution are provided, an AreaDefinition object is returned. Else a DynamicAreaDefinition object is returned
    Return type: | AreaDefinition or DynamicAreaDefinition

    Notes

    - `resolution` and `radius` can be specified with one value if dx == dy
  classmethod `from_extent`(area_id, projection, shape, area_extent, units=None, **kwargs)

    Create an AreaDefinition object from area_extent and shape.

    Parameters:

    - area_id (str) – ID of area
    - projection (dict or str) – Projection parameters as a proj4_dict or proj4_string
    - shape (list) – Number of pixels in the y and x direction (height, width)
    - area_extent (list) – Area extent as a list (lower_left_x, lower_left_y, upper_right_x, upper_right_y)
    - units (str, optional) –

      Units that provided arguments should be interpreted as. This can be one of ‘deg’, ‘degrees’, ‘meters’, ‘metres’, and any parameter supported by the cs2cs -lu command. Units are determined in the following priority:

      1. units expressed with each variable through a DataArray’s attrs attribute.
      2. units passed to `units`
      3. units used in `projection`
      4. meters
    - description (str, optional) – Description/name of area. Defaults to area_id
    - proj_id (str, optional) – ID of projection
    - rotation (float, optional) – rotation in degrees (negative is cw)
    - nprocs (int, optional) – Number of processor cores to be used
    - lons (numpy array, optional) – Grid lons
    - lats (numpy array, optional) – Grid lats

    Returns: | AreaDefinition
    Return type: | AreaDefinition

  classmethod `from_ul_corner`(area_id, projection, shape, upper_left_extent, resolution, units=None, **kwargs)

    Create an AreaDefinition object from upper_left_extent, resolution, and shape.

    Parameters:

    - area_id (str) – ID of area
    - projection (dict or str) – Projection parameters as a proj4_dict or proj4_string
    - shape (list) – Number of pixels in the y and x direction (height, width)
    - upper_left_extent (list) – Upper left corner of upper left pixel (x, y)
    - resolution (list or float) – Size of pixels in meters: (dx, dy). Can be specified with one value if dx == dy
    - units (str, optional) –

      Units that provided arguments should be interpreted as. This can be one of ‘deg’, ‘degrees’, ‘meters’, ‘metres’, and any parameter supported by the cs2cs -lu command. Units are determined in the following priority:

      1. units expressed with each variable through a DataArray’s attrs attribute.
      2. units passed to `units`
      3. units used in `projection`
      4. meters
    - description (str, optional) – Description/name of area. Defaults to area_id
    - proj_id (str, optional) – ID of projection
    - rotation (float, optional) – rotation in degrees (negative is cw)
    - nprocs (int, optional) – Number of processor cores to be used
    - lons (numpy array, optional) – Grid lons
    - lats (numpy array, optional) – Grid lats

    Returns: | AreaDefinition
    Return type: | AreaDefinition

  `geocentric_resolution`(ellps='WGS84', radius=None)

    Find best estimate for overall geocentric resolution.

  `get_area_slices`(area_to_cover, shape_divisible_by=None)

    Compute the slice to read based on an area_to_cover.

  `get_lonlat`(row, col)

    Retrieve lon and lat values of single point in area grid.

    Parameters:

    - row (int) –
    - col (int) –

    Returns: | (lon, lat)
    Return type: | tuple of floats

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

    Return 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
    - dtype (numpy.dtype, optional) – Data type of the returned arrays
    - chunks (int or tuple, optional) – Create dask arrays and use this chunk size

    Returns: | (lons, lats) – Grids of area lons and and lats
    Return type: | tuple of numpy arrays

  `get_lonlats_dask`(chunks=None, dtype=None)

    Get longitudes and latitudes.

  `get_proj_coords`(data_slice=None, dtype=None, chunks=None)

    Get projection coordinates of grid.

    Parameters:

    - data_slice (slice object, optional) – Calculate only coordinates for specified slice
    - dtype (numpy.dtype, optional) – Data type of the returned arrays
    - chunks (int or tuple, optional) – Create dask arrays and use this chunk size

    Returns:

    - (target_x, target_y) (tuple of numpy arrays) – Grids of area x- and y-coordinates in projection units
    - .. versionchanged:: 1.11.0 – Removed ‘cache’ keyword argument and add ‘chunks’ for creating dask arrays.

  `get_proj_coords_dask`(chunks=None, dtype=None)

    Get projection coordinates.

  `get_proj_vectors`(dtype=None, chunks=None)

    Calculate 1D projection coordinates for the X and Y dimension.

    Parameters:

    - dtype (numpy.dtype) – Numpy data type for the returned arrays
    - chunks (int or tuple) – Return dask arrays with the chunk size specified. If this is a tuple then the first element is the Y array’s chunk size and the second is the X array’s chunk size.

    Returns:

    - tuple ((X, Y) where X and Y are 1-dimensional numpy arrays)
    - The data type of the returned arrays can be controlled with the
    - dtype keyword argument. If chunks is provided then dask arrays
    - are returned instead.

  `get_proj_vectors_dask`(chunks=None, dtype=None)

    Get projection vectors.

  `get_xy_from_lonlat`(lon, lat)

    Retrieve closest x and y coordinates.

    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

  `get_xy_from_proj_coords`(xm, ym)

    Find closest grid cell index for a specified projection coordinate.

    If xm, ym is a tuple of sequences of projection coordinates, a tuple of masked arrays are returned.

    Parameters:

    - xm (list or array) – point or sequence of x-coordinates in meters (map projection)
    - ym (list or array) – point or sequence of y-coordinates in meters (map projection)

    Returns: | column and row grid cell indexes as 2 scalars or arrays
    Return type: | x, y
    Raises: | `ValueError` – if the return point is outside the area domain

  `lonlat2colrow`(lons, lats)

    Return image columns and rows for the given lons and lats.

    Both scalars and arrays are supported. Same as get_xy_from_lonlat, renamed for convenience.

  `name`

    Return area name.

  `outer_boundary_corners`

    Return the lon,lat of the outer edges of the corner points.

  `proj4_string`

    Return projection definition as Proj.4 string.

  `proj_dict`

    Return the projection dictionary.

  `proj_str`

    Return PROJ projection string.

  `projection_x_coords`

    Return projection X coordinates.

  `projection_y_coords`

    Return projection Y coordinates.

  `resolution`

    Return area resolution in X and Y direction.

  `shape`

    Return area shape.

  `to_cartopy_crs`()

    Convert projection to cartopy CRS object.

  `update_hash`(the_hash=None)

    Update a hash, or return a new one if needed.

  `x_size`

    Return area width.

  `y_size`

    Return area height.

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

  Base class for geometry definitions.

  Changed in version 1.8.0: BaseDefinition no longer checks the validity of the provided longitude and latitude coordinates to improve performance. Longitude arrays are expected to be between -180 and 180 degrees, latitude -90 to 90 degrees. Use `check_and_wrap()` to preprocess your arrays.

  `corners`

    Return the corners of the current area.

  `get_area`()

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

  `get_area_extent_for_subset`(row_LR, col_LR, row_UL, col_UL)

    Calculate extent for a subdomain of this area.

    Rows are counted from upper left to lower left and columns are counted from upper left to upper right.

    Parameters:

    - row_LR (int) – row of the lower right pixel
    - col_LR (int) – col of the lower right pixel
    - row_UL (int) – row of the upper left pixel
    - col_UL (int) – col of the upper left pixel

    Returns: | Area extent (LL_x, LL_y, UR_x, UR_y) of the subset
    Return type: | area_extent (tuple)

    Author:
      Ulrich Hamann
  `get_area_slices`(area_to_cover)

    Compute the slice to read based on an area_to_cover.

  `get_bbox_lonlats`()

    Return the bounding box lons and lats.

  `get_boundary_lonlats`()

    Return 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
    Return type: | numpy array

  `get_lonlat`(row, col)

    Retrieve lon and lat of single pixel.

    Parameters:

    - row (int) –
    - col (int) –

    Returns: | (lon, lat)
    Return type: | tuple of floats

  `get_lonlats`(data_slice=None, chunks=None, **kwargs)

    Get longitude and latitude arrays representing this geometry.

    Returns: | (lon, lat) – If chunks is provided then the arrays will be dask arrays with the provided chunk size. If chunks is not provided then the returned arrays are the same as the internal data types of this geometry object (numpy or dask).
    Return type: | tuple of numpy arrays

  `get_lonlats_dask`(chunks=None)

    Get the lon lats as a single dask array.

  `intersection`(other)

    Return 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)
    Return type: | 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
    Return type: | float

  `overlaps`(other)

    Test 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
    Return type: | bool

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

  Base class for geometry definitions defined by lons and lats only.

  `append`(other)

    Append another coordinate definition to existing one.

  `concatenate`(other)

    Concatenate coordinate definitions.

  `geocentric_resolution`(ellps='WGS84', radius=None, nadir_factor=2)

    Calculate maximum geocentric pixel resolution.

    If lons is a `xarray.DataArray` object with a resolution attribute, this will be used instead of loading the longitude and latitude data. In this case the resolution attribute is assumed to mean the nadir resolution of a swath and will be multiplied by the nadir_factor to adjust for increases in the spatial resolution towards the limb of the swath.

    Parameters:

    - ellps (str) – PROJ Ellipsoid for the Cartographic projection used as the target geocentric coordinate reference system. Default: ‘WGS84’. Ignored if radius is provided.
    - radius (float) – Spherical radius of the Earth to use instead of the definitions in ellps.
    - nadir_factor (int) – Number to multiply the nadir resolution attribute by to reflect pixel size on the limb of the swath.

    Returns: Estimated maximum pixel size in meters on a geocentric
      coordinate system (X, Y, Z) representing the Earth.
    Raises: RuntimeError if a simple search for valid longitude/latitude
      data points found no valid data points.

exception `pyresample.geometry.``DimensionError`

  Wrap ValueError.

class `pyresample.geometry.``DynamicAreaDefinition`(area_id=None, description=None, projection=None, width=None, height=None, area_extent=None, resolution=None, optimize_projection=False, rotation=None)

  An AreaDefintion containing just a subset of the needed parameters.

  The purpose of this class is to be able to adapt the area extent and shape of the area to a given set of longitudes and latitudes, such that e.g. polar satellite granules can be resampled optimaly to a give projection.

  `compute_domain`(corners, resolution=None, shape=None)

    Compute shape and area_extent from corners and [shape or resolution] info.

    Corners represents the center of pixels, while area_extent represents the edge of pixels.

    Note that `shape` is (rows, columns) and `resolution` is (x_size, y_size); the dimensions are flipped.

  `freeze`(lonslats=None, resolution=None, shape=None, proj_info=None)

    Create an AreaDefinition from this area with help of some extra info.

    Parameters:

    - lonlats (SwathDefinition or tuple) – The geographical coordinates to contain in the resulting area. A tuple should be `(lons, lats)`.
    - resolution – the resolution of the resulting area.
    - shape – the shape of the resulting area.
    - proj_info – complementing parameters to the projection info.
    - and shape parameters are ignored if the instance is created (Resolution) –
    - the optimize_projection flag set to True. (with) –

  `pixel_size_x`

    Return pixel size in X direction.

  `pixel_size_y`

    Return pixel size in Y direction.

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.

  `shape`

    Grid shape as (rows, cols)

    Type: | tuple

  `size`

    Number of elements in grid

    Type: | int

  `lons`

    Grid lons

    Type: | object

  `lats`

    Grid lats

    Type: | object

  `cartesian_coords`

    Grid cartesian coordinates

    Type: | object

exception `pyresample.geometry.``IncompatibleAreas`

  Error when the areas to combine are not compatible.

class `pyresample.geometry.``StackedAreaDefinition`(*definitions, **kwargs)

  Definition based on muliple vertically stacked AreaDefinitions.

  `append`(definition)

    Append another definition to the area.

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

    Return lon and lat arrays of the area.

  `get_lonlats_dask`(chunks=None, dtype=None)

    Return lon and lat dask arrays of the area.

  `height`

    Return height of the area definition.

  `proj4_string`

    Return projection definition as Proj.4 string.

  `proj_str`

    Return projection definition as Proj.4 string.

  `shape`

    Return shape of the area definition.

  `size`

    Return size of the area definition.

  `squeeze`()

    Generate a single AreaDefinition if possible.

  `update_hash`(the_hash=None)

    Update the hash.

  `width`

    Return width of the area definition.

  `x_size`

    Return width of the area definition.

  `y_size`

    Return height of the area definition.

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.

  `shape`

    Swath shape

    Type: | tuple

  `size`

    Number of elements in swath

    Type: | int

  `ndims`

    Swath dimensions

    Type: | int

  `lons`

    Swath lons

    Type: | object

  `lats`

    Swath lats

    Type: | object

  `cartesian_coords`

    Swath cartesian coordinates

    Type: | object

  `aggregate`(**dims)

    Aggregate the current swath definition by averaging.

    For example, averaging over 2x2 windows: sd.aggregate(x=2, y=2)

  `compute_bb_proj_params`(proj_dict)

    Compute BB projection parameters.

  `compute_optimal_bb_area`(proj_dict=None)

    Compute the “best” bounding box area for this swath with proj_dict.

    By default, the projection is Oblique Mercator (omerc in proj.4), in which case the right projection angle alpha is computed from the swath centerline. For other projections, only the appropriate center of projection and area extents are computed.

    The height and width are computed so that the resolution is approximately the same across dimensions.

  `copy`()

    Copy the current swath.

  `get_edge_lonlats`()

    Get the concatenated boundary of the current swath.

  `update_hash`(the_hash=None)

    Update the hash.

`pyresample.geometry.``combine_area_extents_vertical`(area1, area2)

  Combine the area extents of areas 1 and 2.

`pyresample.geometry.``concatenate_area_defs`(area1, area2, axis=0)

  Append area2 to area1 and return the results.

`pyresample.geometry.``get_array_hashable`(arr)

  Compute a hashable form of the array arr.

  Works with numpy arrays, dask.array.Array, and xarray.DataArray.

`pyresample.geometry.``get_geostationary_angle_extent`(geos_area)

  Get the max earth (vs space) viewing angles in x and y.

`pyresample.geometry.``get_geostationary_bounding_box`(geos_area, nb_points=50)

  Get the bbox in lon/lats of the valid pixels inside geos_area.

  Parameters: | nb_points – Number of points on the polygon

`pyresample.geometry.``invproj`(data_x, data_y, proj_dict)

  Perform inverse projection.

`pyresample.geometry.``ordered_dump`(data, stream=None, Dumper=<class 'yaml.dumper.Dumper'>, **kwds)

  Dump the data to YAML in ordered fashion.

## 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 or 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

  `image_data`

    Image data

    Type: | numpy array

  `geo_def`

    Geometry definition

    Type: | object

  `fill_value`

    Resample result fill value

    Type: | int or None

  `nprocs`

    Number of processor cores to be used for geometry operations

    Type: | int

  `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 – Resampled image data
    Return type: | numpy_array

  `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.``ImageContainerBilinear`(image_data, geo_def, radius_of_influence, epsilon=0, fill_value=0, reduce_data=False, nprocs=1, segments=None, neighbours=32)

  Holds image with geometry definition. Allows bilinear 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 or 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 or None) – Number of segments to use when resampling. If set to None an estimate will be calculated

  `image_data`

    Image data

    Type: | numpy array

  `geo_def`

    Geometry definition

    Type: | object

  `radius_of_influence`

    Cut off distance in meters

    Type: | float

  `epsilon`

    Allowed uncertainty in meters

    Type: | float

  `fill_value`

    Resample result fill value

    Type: | int or None

  `reduce_data`

    Perform coarse data reduction before resampling

    Type: | bool

  `nprocs`

    Number of processor cores to be used

    Type: | int

  `segments`

    Number of segments to use when resampling

    Type: | int or None

  `resample`(target_geo_def)

    Resamples image to area definition using bilinear approach

    Parameters: | target_geo_def (object) – Target geometry definition
    Returns: | image_container – ImageContainerBilinear object of resampled geometry
    Return type: | object

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 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 or 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 or None) – Number of segments to use when resampling. If set to None an estimate will be calculated

  `image_data`

    Image data

    Type: | numpy array

  `geo_def`

    Geometry definition

    Type: | object

  `radius_of_influence`

    Cut off distance in meters

    Type: | float

  `epsilon`

    Allowed uncertainty in meters

    Type: | float

  `fill_value`

    Resample result fill value

    Type: | int or None

  `reduce_data`

    Perform coarse data reduction before resampling

    Type: | bool

  `nprocs`

    Number of processor cores to be used

    Type: | int

  `segments`

    Number of segments to use when resampling

    Type: | int or None

  `resample`(target_geo_def)

    Resamples image to area definition using nearest neighbour approach

    Parameters: | target_geo_def (object) – Target geometry definition
    Returns: | image_container – ImageContainerNearest object of resampled geometry
    Return type: | object

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 or 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 or None) – Number of segments to use when resampling. If set to None an estimate will be calculated

  `image_data`

    Image data

    Type: | numpy array

  `geo_def`

    Area definition as AreaDefinition object

    Type: | object

  `fill_value`

    Resample result fill value If fill_value is None a masked array is returned with undetermined pixels masked

    Type: | int or None

  `nprocs`

    Number of processor cores to be used

    Type: | int

  `segments`

    Number of segments to use when resampling

    Type: | int or None

  `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 – ImageContainerQuick object of resampled area
    Return type: | object

## 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 or 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 – Resampled image
  Return type: | numpy array

`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 or 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 – Resampled image data
  Return type: | numpy array

`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) – Arrays for resampling area by array indexing
  Return type: | tuple of numpy arrays

`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 – Resampled image data
  Return type: | numpy array

## pyresample.kd_tree

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

exception `pyresample.kd_tree.``EmptyResult`

`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
  - 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 or 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 or None, optional) – Set undetermined pixels to this value. If fill_value is None a masked array is returned with undetermined pixels masked

  Returns: | result – Source data resampled to target geometry
  Return type: | numpy array

`pyresample.kd_tree.``query_no_distance`(target_lons, target_lats, valid_output_index, mask=None, valid_input_index=None, neighbours=None, epsilon=None, radius=None, kdtree=None)

  Query the kdtree. No distances are returned.

  NOTE: Dask array arguments must always come before other keyword arguments
    for da.blockwise arguments to work.

`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 or 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 or 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 or None) – Number of segments to use when resampling. If set to None an estimate will be calculated

  Returns: | data – Source data resampled to target geometry
  Return type: | numpy array

## pyresample.bilinear

Code for resampling using bilinear algorithm for irregular grids.

The algorithm is taken from

http://www.ahinson.com/algorithms_general/Sections/InterpolationRegression/InterpolationIrregularBilinear.pdf

`pyresample.bilinear.``get_bil_info`(source_geo_def, target_area_def, radius=50000.0, neighbours=32, nprocs=1, masked=False, reduce_data=True, segments=None, epsilon=0)

  Calculate information needed for bilinear resampling.

  source_geo_def : object
    Geometry definition of source data
  target_area_def : object
    Geometry definition of target area
  radius : float, optional
    Cut-off distance in meters
  neighbours : int, optional
    Number of neighbours to consider for each grid point when searching the closest corner points
  nprocs : int, optional
    Number of processor cores to be used for getting neighbour info
  masked : bool, optional
    If true, return masked arrays, else return np.nan values for invalid points (default)
  reduce_data : bool, optional
    Perform initial coarse reduction of source dataset in order to reduce execution time
  segments : int or None
    Number of segments to use when resampling. If set to None an estimate will be calculated
  epsilon : float, optional
    Allowed uncertainty in meters. Increasing uncertainty reduces execution time

  Returns:

  - t__ (numpy array) – Vertical fractional distances from corner to the new points
  - s__ (numpy array) – Horizontal fractional distances from corner to the new points
  - input_idxs (numpy array) – Valid indices in the input data
  - idx_arr (numpy array) – Mapping array from valid source points to target points

`pyresample.bilinear.``get_sample_from_bil_info`(data, t__, s__, input_idxs, idx_arr, output_shape=None)

  Resample data using bilinear interpolation.

  Parameters:

  - data (numpy array) – 1d array to be resampled
  - t (numpy array) – Vertical fractional distances from corner to the new points
  - s (numpy array) – Horizontal fractional distances from corner to the new points
  - input_idxs (numpy array) – Valid indices in the input data
  - idx_arr (numpy array) – Mapping array from valid source points to target points
  - output_shape (tuple, optional) – Tuple of (y, x) dimension for the target projection. If None (default), do not reshape data.

  Returns: | result – Source data resampled to target geometry
  Return type: | numpy array

`pyresample.bilinear.``resample_bilinear`(data, source_geo_def, target_area_def, radius=50000.0, neighbours=32, nprocs=1, fill_value=0, reduce_data=True, segments=None, epsilon=0)

  Resample using bilinear interpolation.

  data : numpy array
    Array of single channel data points or (source_geo_def.shape, k) array of k channels of datapoints
  source_geo_def : object
    Geometry definition of source data
  target_area_def : object
    Geometry definition of target area
  radius : float, optional
    Cut-off distance in meters
  neighbours : int, optional
    Number of neighbours to consider for each grid point when searching the closest corner points
  nprocs : int, optional
    Number of processor cores to be used for getting neighbour info
  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
  segments : int or None
    Number of segments to use when resampling. If set to None an estimate will be calculated
  epsilon : float, optional
    Allowed uncertainty in meters. Increasing uncertainty reduces execution time

  Returns: | data – Source data resampled to target geometry
  Return type: | numpy array

## pyresample.utils

Miscellaneous utility functions for pyresample.

`pyresample.utils.``check_and_wrap`(lons, lats)

  Wrap longitude to [-180:+180[ and check latitude for validity.

  Parameters:

  - lons (ndarray) – Longitude degrees
  - lats (ndarray) – Latitude degrees

  Returns:

  Longitude degrees in the range [-180:180[ and the original

    latitude array

  Return type: | lons, lats
  Raises: | `ValueError` – If latitude array is not between -90 and 90

`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 – sigma for use in resampling gauss function
  Return type: | float

`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 geometry definition object
  - target_area_def (object) – Target area definition as geometry definition 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)
  Return type: | 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 geometry definition object
  - target_area_def (object) – Target area definition as geometry definition object
  - nprocs (int, optional) – Number of processor cores to be used

  Returns: | (row_indices, col_indices)
  Return type: | tuple of numpy arrays

`pyresample.utils.``is_pyproj2`()

  Determine whether the current pyproj version is >= 2.0

`pyresample.utils.``recursive_dict_update`(d, u)

  Recursive dictionary update using

  Copied from:

  > http://stackoverflow.com/questions/3232943/update-value-of-a-nested-dictionary-of-varying-depth

`pyresample.utils.``wrap_longitudes`(lons)

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

  Parameters: | lons (numpy array) – Longitudes in degrees
  Returns: | lons – Longitudes wrapped into [-180:+180[ validity range
  Return type: | numpy array

## pyresample.area_config

exception `pyresample.area_config.``AreaNotFound`

  Exception raised when specified are is no found in file.

`pyresample.area_config.``convert_def_to_yaml`(def_area_file, yaml_area_file)

  Convert a legacy area def file to the yaml counter partself.

  yaml_area_file will be overwritten by the operation.

`pyresample.area_config.``create_area_def`(area_id, projection, width=None, height=None, area_extent=None, shape=None, upper_left_extent=None, center=None, resolution=None, radius=None, units=None, **kwargs)

  Takes data the user knows and tries to make an area definition from what can be found.

  Parameters:

  - area_id (str) – ID of area
  - projection (dict or str) – Projection parameters as a proj4_dict or proj4_string
  - description (str, optional) – Description/name of area. Defaults to area_id
  - proj_id (str, optional) – ID of projection (deprecated)
  - units (str, optional) –

    Units that provided arguments should be interpreted as. This can be one of ‘deg’, ‘degrees’, ‘meters’, ‘metres’, and any parameter supported by the cs2cs -lu command. Units are determined in the following priority:

    1. units expressed with each variable through a DataArray’s attrs attribute.
    2. units passed to `units`
    3. units used in `projection`
    4. meters
  - width (str, optional) – Number of pixels in the x direction
  - height (str, optional) – Number of pixels in the y direction
  - area_extent (list, optional) – Area extent as a list (lower_left_x, lower_left_y, upper_right_x, upper_right_y)
  - shape (list, optional) – Number of pixels in the y and x direction (height, width)
  - upper_left_extent (list, optional) – Upper left corner of upper left pixel (x, y)
  - center (list, optional) – Center of projection (x, y)
  - resolution (list or float, optional) – Size of pixels: (dx, dy)
  - radius (list or float, optional) – Length from the center to the edges of the projection (dx, dy)
  - rotation (float, optional) – rotation in degrees(negative is cw)
  - nprocs (int, optional) – Number of processor cores to be used
  - lons (numpy array, optional) – Grid lons
  - lats (numpy array, optional) – Grid lats
  - optimize_projection – Whether the projection parameters have to be optimized for a DynamicAreaDefinition.

  Returns: | AreaDefinition or DynamicAreaDefinition – If shape and area_extent are found, an AreaDefinition object is returned. If only shape or area_extent can be found, a DynamicAreaDefinition object is returned
  Return type: | AreaDefinition or DynamicAreaDefinition
  Raises: | ValueError: – If neither shape nor area_extent could be found

  Notes

  - `resolution` and `radius` can be specified with one value if dx == dy
  - If `resolution` and `radius` are provided as angles, center must be given or findable. In such a case, they represent [projection x distance from center[0] to center[0]+dx, projection y distance from center[1] to center[1]+dy]

`pyresample.area_config.``get_area_def`(area_id, area_name, proj_id, proj4_args, width, height, area_extent, rotation=0)

  Construct AreaDefinition object from arguments

  Parameters:

  - area_id (str) – ID of area
  - area_name (str) – Description of area
  - proj_id (str) – ID of projection
  - proj4_args (list, dict, or str) – Proj4 arguments as list of arguments or string
  - width (int) – Number of pixel in x dimension
  - height (int) – Number of pixel in y dimension
  - rotation (float) – Rotation in degrees (negative is cw)
  - area_extent (list) – Area extent as a list of ints (LL_x, LL_y, UR_x, UR_y)

  Returns: | area_def – AreaDefinition object
  Return type: | object

`pyresample.area_config.``load_area`(area_file_name, *regions)

  Load area(s) from area file.

  Parameters:

  - area_file_name (str or list) – One or more paths to area definition files
  - regions (str argument list) – Regions to parse. If no regions are specified all regions in the file are returned

  Returns: | area_defs – 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
  Return type: | AreaDefinition or list
  Raises: | AreaNotFound: – If a specified area name is not found

`pyresample.area_config.``parse_area_file`(area_file_name, *regions)

  Parse area information from area file

  Parameters:

  - area_file_name (str or list) – One or more paths to area definition files
  - regions (str argument list) – Regions to parse. If no regions are specified all regions in the file are returned

  Returns: | area_defs – List of AreaDefinition objects
  Return type: | list
  Raises: | AreaNotFound: – If a specified area is not found

## 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 – Boolean array of same size as lons and lats indicating relevant indices
  Return type: | numpy array

`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 – Boolean array of same size as lon and lat indicating relevant indices
  Return type: | numpy array

`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) – Reduced swath data and coordinate set
  Return type: | list of numpy arrays

`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) – Reduced swath data and coordinate set
  Return type: | list of numpy arrays

`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) – Reduced swath data and coordinate set
  Return type: | list of numpy arrays

## pyresample.plot

Utility functions for quick and easy display.

`pyresample.plot.``area_def2basemap`(area_def, **kwargs)

  Get Basemap object from an AreaDefinition object.

  Parameters:

  - area_def (object) – geometry.AreaDefinition object
  - **kwargs (Keyword arguments) – Additional initialization arguments for Basemap

  Returns: | bmap
  Return type: | Basemap object

`pyresample.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)
  Return type: | semi-major and semi-minor axis

`pyresample.plot.``save_quicklook`(filename, area_def, data, vmin=None, vmax=None, label='Variable (units)', num_meridians=45, num_parallels=10, coast_res='110m', backend='AGG', cmap='RdBu_r')

  Display and save 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’

`pyresample.plot.``show_quicklook`(area_def, data, vmin=None, vmax=None, label='Variable (units)', num_meridians=45, num_parallels=10, coast_res='110m', cmap='RdBu_r')

  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
  Return type: | Basemap object

## pyresample.ewa

## pyresample.bucket

Code for resampling using bucket resampling.

class `pyresample.bucket.``BucketResampler`(target_area, source_lons, source_lats)

  Class for bucket resampling.

  Bucket resampling is useful for calculating averages and hit-counts when aggregating data to coarser scale grids.

  Below are examples how to use the resampler.

  Read data using Satpy. The resampling can also be done (apart from fractions) directly from Satpy, but this demonstrates the direct low-level usage.

      >>> from pyresample.bucket import BucketResampler
      >>> from satpy import Scene
      >>> from satpy.resample import get_area_def
      >>> fname = "hrpt_noaa19_20170519_1214_42635.l1b"
      >>> glbl = Scene(filenames=[fname])
      >>> glbl.load(['4'])
      >>> data = glbl['4']
      >>> lons, lats = data.area.get_lonlats()
      >>> target_area = get_area_def('euro4')

  Initialize the resampler

      >>> resampler = BucketResampler(adef, lons, lats)

  Calculate the sum of all the data in each grid location:

      >>> sums = resampler.get_sum(data)

  Calculate how many values were collected at each grid location:

      >>> counts = resampler.get_count()

  The average can be calculated from the above two results, or directly using the helper method:

      >>> average = resampler.get_average(data)

  Calculate fractions of occurrences of different values in each grid location. The data needs to be categorical (in integers), so we’ll create some categorical data from the brightness temperature data that were read earlier. The data are returned in a dictionary with the categories as keys.

      >>> data = da.where(data > 250, 1, 0)
      >>> fractions = resampler.get_fractions(data, categories=[0, 1])
      >>> import matplotlib.pyplot as plt
      >>> plt.imshow(fractions[0]); plt.show()

  `get_average`(data, fill_value=nan, mask_all_nan=False)

    Calculate bin-averages using bucket resampling.

    Parameters:

    - data (Numpy or Dask array) – Data to be binned and averaged
    - fill_value (float) – Fill value to replace missing values. Default: np.nan

    Returns: | average – Binned and averaged data.
    Return type: | Dask array

  `get_count`()

    Count the number of occurrences for each bin using drop-in-a-bucket resampling.

    Returns: | data – Bin-wise count of hits for each target grid location
    Return type: | Dask array

  `get_fractions`(data, categories=None, fill_value=nan)

    Get fraction of occurrences for each given categorical value.

    Parameters:

    - data (Numpy or Dask array) – Categorical data to be processed
    - categories (iterable or None) – One dimensional list of categories in the data, or None. If None, categories are determined from the data by fully processing the data and finding the unique category values.
    - fill_value (float) – Fill value to replace missing values. Default: np.nan

  `get_sum`(data, mask_all_nan=False)

    Calculate sums for each bin with drop-in-a-bucket resampling.

    Parameters:

    - data (Numpy or Dask array) –
    - mask_all_nan (boolean (optional)) – Mask bins that have only NaN results, default: False

    Returns: | data – Bin-wise sums in the target grid
    Return type: | Numpy or Dask array

`pyresample.bucket.``round_to_resolution`(arr, resolution)

  Round the values in arr to closest resolution element.

  Parameters:

  - arr (list, tuple, Numpy or Dask array) – Array to be rounded
  - resolution (float) – Resolution unit to which data are rounded

  Returns: | data – Source data rounded to the closest resolution unit
  Return type: | Numpy or Dask array