# 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, rotation=None, nprocs=1, lons=None, lats=None, dtype=<class 'numpy.float64'>)

  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
  - rotation (float) – rotation in degrees (negative is cw)
  - 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

  `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

  `rotation`

    float – rotation in degrees (negative is cw)

  `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..

  `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

  `colrow2lonlat`(cols, rows)

    Return longitudes and latitudes 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).

  `get_lonlat`(row, col)

    Retrieves 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)

    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) – Grids of area lons and and lats
    Return type: | tuple of numpy arrays

  `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 the result. Requires data_slice to be None

    Returns: | (target_x, target_y) – Grids of area x- and y-coordinates in projection units
    Return type: | tuple of numpy arrays

  `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

  `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 longitudes and latitudes. Both scalars and arrays are supported. Same as get_xy_from_lonlat, renamed for convenience.

  `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

  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 pyresample.utils.check_and_wrap to preprocess your arrays.

  `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_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_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
    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, **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)
    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)

    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
    Return type: | 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.``DynamicAreaDefinition`(area_id=None, description=None, proj_dict=None, x_size=None, y_size=None, area_extent=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 size 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, size=None)

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

  `freeze`(lonslats=None, resolution=None, size=None, proj_info=None, rotation=None)

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

    lonlats:
      the geographical coordinates to contain in the resulting area.
    resolution:
      the resolution of the resulting area.
    size:
      the size of the resulting area.
    proj_info:
      complementing parameters to the projection info.
    rotation:
      rotation in degrees (negative is cw)

    Resolution and Size parameters are ignored if the instance is created with the optimize_projection flag set to True.

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`

    tuple – Grid shape as (rows, cols)

  `size`

    int – Number of elements in grid

  `lons`

    object – Grid lons

  `lats`

    object – Grid lats

  `cartesian_coords`

    object – Grid cartesian coordinates

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)

    Return lon and lat arrays of the area.

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

    “Return lon and lat dask arrays of the area.

  `proj4_string`

    Returns projection definition as Proj.4 string

  `squeeze`()

    Generate a single AreaDefinition if possible.

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`

    tuple – Swath shape

  `size`

    int – Number of elements in swath

  `ndims`

    int – Swath dimensions

  `lons`

    object – Swath lons

  `lats`

    object – Swath lats

  `cartesian_coords`

    object – Swath cartesian coordinates

  `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.

  `get_edge_lonlats`()

    Get the concatenated boundary of the current swath.

  `get_lonlats_dask`(chunks=4096)

    Get the lon lats as a single dask array.

`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.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`

    numpy array – Image data

  `geo_def`

    object – Geometry definition

  `fill_value`

    int or 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 – 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=True, 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`

    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 or 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 or None – Number of segments to use when resampling

  `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`

    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 or 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 or 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 – 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`

    numpy array – Image data

  `geo_def`

    object – Area definition as AreaDefinition object

  `fill_value`

    int or 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 or 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 – 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

`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.``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.kd_tree.``which_kdtree`()

  Returns the name of the kdtree used for resampling

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

Utility functions for pyresample

exception `pyresample.utils.``AreaNotFound`

  Exception raised when specified are is no found in file

`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.``get_area_def`(area_id, area_name, proj_id, proj4_args, x_size, y_size, area_extent, rotation=0)

  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
  - 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.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 – 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: | object or list
  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 of AreaDefinition objects
  Return type: | list
  Raises: | AreaNotFound: – If a specified area is not found

`pyresample.utils.``proj4_dict_to_str`(proj4_dict, sort=False)

  Convert a dictionary of PROJ.4 parameters to a valid PROJ.4 string

`pyresample.utils.``proj4_radius_parameters`(proj4_dict)

  Calculate ‘a’ and ‘b’ radius parameters.

  Parameters: | proj4_dict (str or dict) – PROJ.4 parameters
  Returns: | equatorial and polar radius
  Return type: | a (float), b (float)

`pyresample.utils.``proj4_str_to_dict`(proj4_str)

  Convert PROJ.4 compatible string definition to dict

  Note: Key only parameters will be assigned a value of True.

`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.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

`pyresample.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
  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='c', backend='AGG', cmap='jet')

  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’

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

  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