shareloc.geomodels.grid ======================= .. py:module:: shareloc.geomodels.grid .. autoapi-nested-parse:: Localisation functions from multi h direct grids. Classes ------- .. autoapisummary:: shareloc.geomodels.grid.Grid Functions --------- .. autoapisummary:: shareloc.geomodels.grid.coloc Module Contents --------------- .. py:class:: Grid(geomodel_path) Bases: :py:obj:`shareloc.geomodels.geomodel_template.GeoModelTemplate` multi H direct localization grid handling class. please refer to the main documentation grid format Derives from GeoModelTemplate :param row0: grid first pixel center along Y axis (row). :type row0: float :param col0: grid first pixel center along X axis (column). :type col0: float :param nbrow: grid size in row :type nbrow: int :param nbcol: grid size in col :type nbcol: int :param steprow: grid step in row :type steprow: float :param stepcol: grid step in col :type stepcol: float :param rowmax: last row in grid :type rowmax: float :param colmax: last col in grid :type colmax: float :param repter: ground coordinate system :type repter: str :param epsg: epsg code corresponding to shareloc.grid.Grid.repter :type epsg: int :param nbalt: number of altitude layers :type nbalt: int :param lon_data: longitude array :type lon_data: np.ndarray of size (nbalt,nbrow,nbcol) size :param lat_data: latitude array :type lat_data: np.ndarray of size (nbalt,nbrow,nbcol) size :param alts_down: altitudes in decreasing order :type alts_down: list :param type: geometric model type :type type: str .. py:attribute:: type :value: 'multi H grid' .. py:attribute:: geomodel_path .. py:attribute:: row0 :value: None .. py:attribute:: col0 :value: None .. py:attribute:: nbrow :value: None .. py:attribute:: nbcol :value: None .. py:attribute:: steprow :value: None .. py:attribute:: stepcol :value: None .. py:attribute:: repter :value: None .. py:attribute:: nbalt :value: None .. py:attribute:: lon_data :value: None .. py:attribute:: lat_data :value: None .. py:attribute:: alts_down :value: None .. py:attribute:: rowmax :value: None .. py:attribute:: colmax :value: None .. py:attribute:: pred_col_min :value: None .. py:attribute:: pred_row_min :value: None .. py:attribute:: pred_col_max :value: None .. py:attribute:: pred_row_max :value: None .. py:attribute:: pred_ofset_scale_lon :value: None .. py:attribute:: pred_ofset_scale_lat :value: None .. py:attribute:: pred_ofset_scale_row :value: None .. py:attribute:: pred_ofset_scale_col :value: None .. py:attribute:: alt_normalise_interp .. py:attribute:: interpolator_lonlat .. py:method:: load(geomodel_path) :classmethod: Load grid and fill Class attributes. The grid is read as an shareloc.image. Image and class attributes are filled. Shareloc geotiff grids are stored by increasing altitude H0 ... Hx 2 data cubes are defined: - lon_data : [alt,row,col] - lat_data : [alt,row,col] .. py:method:: read() Load grid and fill Class attributes. The grid is read as an shareloc.image. Image and class attributes are filled. Shareloc geotiff grids are stored by increasing altitude H0 ... Hx 2 data cubes are defined: - lon_data : [alt,row,col] - lat_data : [alt,row,col] .. py:method:: check_status_band(metadata) parse metadata to check if status band are present :param metadata: Geotiff metadata :type metadata: dict :return True if grid contains status band, False otherwise .. py:method:: parse_metadata_alti(metadata, status_band=False) parse metadata to sort altitude in decreasing order :param metadata: Geotiff metadata :type metadata: dict :param status_band: status_band :type status_band: bool :return lon indexes .. py:method:: get_alt_min_max() returns altitudes min and max layers :return: alt_min,lat_max :rtype: list .. py:method:: direct_loc_h(row, col, alt, fill_nan=False) direct localization at constant altitude :param row: line sensor position :type row: float or 1D numpy.ndarray dtype=float64 :param col: column sensor position :type col: float or 1D numpy.ndarray dtype=float64 :param alt: altitude :type alt: float :param fill_nan: not used, preserved for API symmetry :type fill_nan: boolean :return: ground position (lon,lat,h) :rtype: numpy.ndarray 2D dimension with (N,3) shape, where N is number of input coordinates .. py:method:: compute_los(row, col, epsg) Compute Line of Sight :param row: line sensor position :type row: float :param col: column sensor position :type col: float :param epsg: epsg code :type epsg: int :return: los :rtype: numpy.array .. py:method:: direct_loc_dtm(row, col, dtm) direct localization on dtm :param row: line sensor position :type row: float :param col: column sensor position :type col: float :param dtm: dtm model :type dtm: shareloc.dtm :return: ground position (lon,lat,h) in dtm coordinates system. :rtype: numpy.ndarray 2D dimension with (N,3) shape, where N is number of input coordinates .. py:method:: los_extrema(row, col, alt_min, alt_max) compute los extrema :param row: line sensor position :type row: float :param col: column sensor position :type col: float :param alt_min: los alt min :type alt_min: float :param alt_max: los alt max :type alt_max: float :return: los extrema :rtype: numpy.array (2x3) .. py:method:: interpolate_grid_in_plani(row, col) interpolate positions on multi h grid :param row: line sensor position :type row: np.ndarray :param col: column sensor position :type col: np.ndarray :return: interpolated positions :rtype: np.ndarray .. py:method:: interpolate_grid_in_altitude(nbrow, nbcol, nbalt=None) interpolate equally spaced grid (in altitude) :param nbrow: grid nb row :type nbrow: int :param nbcol: grid nb col :type nbcol: int :param nbalt: grid nb alt, of None self.nbalt is used instead :type nbalt: int :return: equally spaced grid :rtype: numpy.array .. py:method:: direct_loc_grid_dtm(row0, col0, steprow, stepcol, nbrow, nbcol, dtm) direct localization grid on dtm :param row0: grid origin (row) :type row0: int :param col0: grid origin (col) :type col0: int :param steprow: grid step (row) :type steprow: int :param stepcol: grid step (col) :type stepcol: int :param nbrow: grid nb row :type nbrow: int :param nbcol: grid nb col :type nbcol: int :param dtm: dtm model :type dtm: shareloc.dtm :return: direct localization grid :rtype: numpy.array .. py:method:: return_grid_index(alt) return layer index enclosing a given altitude :param alt: altitude :type alt: float :return: grid index (up,down) :rtype: tuple .. py:method:: direct_loc_grid_h(row0, col0, steprow, stepcol, nbrow, nbcol, alt) direct localization grid at constant altitude :param row0: grid origin (row) :type row0: int :param col0: grid origin (col) :type col0: int :param steprow: grid step (row) :type steprow: int :param stepcol: grid step (col) :type stepcol: int :param nbrow: grid nb row :type nbrow: int :param nbcol: grid nb col :type nbcol: int :param alt: altitude of the grid :type alt: float :return: direct localization grid :rtype: numpy.array .. py:method:: estimate_inverse_loc_predictor(nbrow_pred=3, nbcol_pred=3) initialize inverse localization polynomial predictor it composed of 4 polynoms estimated on a grid at hmin and hmax col_min = a0 + a1*lon + a2*lat + a3*lon**2 + a4*lat**2 + a5*lon*lat row_min = b0 + b1*lon + b2*lat + b3*lon**2 + b4*lat**2 + b5*lon*lat col_max = a0 + a1*lon + a2*lat + a3*lon**2 + a4*lat**2 + a5*lon*lat row_max = b0 + b1*lon + b2*lat + b3*lon**2 + b4*lat**2 + b5*lon*lat least squarred method is used to calculate coefficients, which are noramlized in [-1,1] :param nbrow_pred: predictor nb row (3 by default) :type nbrow_pred: int :param nbcol_pred: predictor nb col (3 by default) :type nbcol_pred: int .. py:method:: inverse_loc_predictor(lon, lat, alt=0.0) evaluate inverse localization predictor at a given geographic position :param lon: longitude :type lon: float :param lat: latitude :type lat: float :param alt: altitude (0.0 by default) :type alt: float :return: sensor position and extrapolation state (row,col, is extrapolated) :rtype: tuple (float, float, boolean) .. py:method:: inverse_partial_derivative(row, col, alt=0) calculate partial derivative at a given geographic position it gives the matrix to apply to get sensor shifts from geographic ones it returns M matrix : [dcol,drow]T = M x [dlon,dlat]T dlon/dlat in microrad M is calculated on each node of grid M is necessary for direct localization inversion in iterative inverse loc :param lon: longitude :type lon: float :param lat: latitude :type lat: float :param alt: altitude (0.0 by default) :type alt: float :return: matrix :rtype: numpy.array .. py:method:: inverse_loc(lon, lat, alt=0.0, nb_iterations=15) Inverse localization at a given geographic position First initialize position, * apply inverse predictor lon,lat,at -> col_0,row_0 * direct loc col_0,row_0 -> lon_0, lat_0 Then iterative process: * calculate geographic error dlon,dlat * calculate sensor correction dlon,dlat -> dcol,drow * apply direct localization -> lon_i,lat_i * compute localisation error * compute local inverse gradient * move along derivatives to compute row_i,col_i * loop until measurement error is below threshold or max number of iterations TODO optimization (for loop,...) :param lon: longitude :type lon: float or 1D numpy.ndarray dtype=float64 :param lat: latitude :type lat: float or 1D numpy.ndarray dtype=float64 :param alt: altitude :type alt: float or 1D numpy.ndarray dtype=float64 :param nb_iterations: max number of iterations (15 by default) :type nb_iterations: int :return: sensor position (row,col,alt) :rtype: tuple(1D np.array row position, 1D np.array col position, 1D np.array alt) .. py:function:: coloc(multi_h_grid_src, multi_h_grid_dst, dtm, origin, step, size) colocalization grid on dtm localization on dtm from src grid, then inverse localization in right grid :param multi_h_grid_src: source grid :type multi_h_grid_src: shareloc.grid :param multi_h_grid_dst: destination grid :type multi_h_grid_dst: shareloc.grid :param origin: grid origin in src grid (row,col) :type origin: list(int) :param step: grid step (row,col) :type step: list(int) :param size: grid nb row and nb col :type size: list(int) :return: colocalization grid :rtype: numpy.array