pysits 2.0.0.dev0__tar.gz → 2.0.0.dev2__tar.gz

pysits-2.0.0.dev2/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(Rscript -e 'cat\\(length\\(getNamespaceExports\\(\"sits\"\\)\\), \"\\\\n\"\\)')",
+      "Bash(uv run python -c ' *)"
+    ]
+  }
+}

{pysits-2.0.0.dev0 → pysits-2.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysits
-Version: 2.0.0.dev0
+Version: 2.0.0.dev2
 Summary: Python wrapper for the sits R package
 Project-URL: Homepage, https://github.com/e-sensing/pysits
 Project-URL: Issue Tracker, https://github.com/e-sensing/pysits/issues

{pysits-2.0.0.dev0 → pysits-2.0.0.dev2}/pyproject.toml

@@ -17,7 +17,7 @@
 
 [project]
 name = "pysits"
-version = "2.0.0.dev0"
+version = "2.0.0.dev2"
 description = "Python wrapper for the sits R package"
 readme = "README.md"
 requires-python = ">=3.10,<4"

{pysits-2.0.0.dev0 → pysits-2.0.0.dev2}/pysits/__init__.py

@@ -20,7 +20,6 @@
 from .conversions.dsl.mask import MaskValue
 from .conversions.dsl.tuning import hparam
 from .settings import __version__
-from .sits.classification import sits_classify, sits_label_classification, sits_smooth
 from .sits.colors import (
     sits_colors,
     sits_colors_reset,
@@ -62,6 +61,9 @@ from .sits.data import (
     sits_apply,
     sits_bands,
     sits_bbox,
+    sits_classify,
+    sits_encode,
+    sits_label_classification,
     sits_labels,
     sits_labels_summary,
     sits_list_collections,
@@ -69,10 +71,17 @@ from .sits.data import (
     sits_mixture_model,
     sits_reduce,
     sits_select,
+    sits_smooth,
     sits_timeline,
 )
 from .sits.data import sits_summary as summary
-from .sits.exporters import sits_as_geopandas, sits_as_xarray, sits_to_csv, sits_to_xlsx
+from .sits.exporters import (
+    sits_as_geopandas,
+    sits_as_xarray,
+    sits_timeseries_to_csv,
+    sits_to_csv,
+    sits_to_xlsx,
+)
 from .sits.impute import (
     impute_linear,
     impute_mean,
@@ -87,6 +96,7 @@ from .sits.ml import (
     sits_kfold_validate,
     sits_lightgbm,
     sits_lighttae,
+    sits_lstm_fcn,
     sits_mlp,
     sits_model_export,
     sits_pre_train,
@@ -107,7 +117,6 @@ from .sits.ts import (
     sits_cluster_clean,
     sits_cluster_dendro,
     sits_cluster_frequency,
-    sits_encode,
     sits_geo_dist,
     sits_get_class,
     sits_get_data,
@@ -118,6 +127,7 @@ from .sits.ts import (
     sits_pred_references,
     sits_pred_sample,
     sits_predictors,
+    sits_random_sampling,
     sits_reduce_imbalance,
     sits_sample,
     sits_sampling_design,
@@ -125,6 +135,7 @@ from .sits.ts import (
     sits_som_clean_samples,
     sits_som_evaluate_cluster,
     sits_som_map,
+    sits_som_remove_samples,
     sits_stats,
     sits_stratified_sampling,
     sits_validate,
@@ -137,13 +148,21 @@ from .sits.utils import (
     read_rds,
 )
 from .sits.visualization import sits_plot as plot
-from .sits.visualization import sits_view
+from .sits.visualization import sits_sankey, sits_view
 
 __all__ = (
     # Classification
     "sits_classify",
     "sits_smooth",
     "sits_label_classification",
+    # Embeddings
+    "sits_pre_train",
+    "sits_encode",
+    "sits_ssl_mae",
+    "sits_ssl_lejepa",
+    "sits_ssl_vicreg",
+    "sits_barlow_twins",
+    "sits_contrastive_learning",
     # Cube
     "sits_cube",
     "sits_clean",
@@ -170,7 +189,7 @@ __all__ = (
     "sits_config_user_file",
     "sits_config_value",
     "sits_parallel",
-    # Data management
+    # Data
     "sits_bands",
     "sits_timeline",
     "sits_labels",
@@ -194,6 +213,7 @@ __all__ = (
     "sits_resnet",
     "sits_tempcnn",
     "sits_lighttae",
+    "sits_lstm_fcn",
     "sits_svm",
     "sits_xgboost",
     "sits_lightgbm",
@@ -202,12 +222,6 @@ __all__ = (
     "sits_model_export",
     "sits_formula_linear",
     "sits_formula_logref",
-    "sits_ssl_mae",
-    "sits_ssl_lejepa",
-    "sits_ssl_vicreg",
-    "sits_barlow_twins",
-    "sits_contrastive_learning",
-    "sits_pre_train",
     # Impute
     "impute_linear",
     "impute_mean",
@@ -228,13 +242,14 @@ __all__ = (
     "sits_som_map",
     "sits_som_evaluate_cluster",
     "sits_som_clean_samples",
+    "sits_som_remove_samples",
     "sits_geo_dist",
     "sits_patterns",
     "sits_sample",
     "sits_reduce_imbalance",
     "sits_sampling_design",
     "sits_stratified_sampling",
-    "sits_encode",
+    "sits_random_sampling",
     # Tiles
     "sits_tiles_to_roi",
     "sits_roi_to_tiles",
@@ -249,12 +264,14 @@ __all__ = (
     "sits_as_xarray",
     "sits_as_geopandas",
     "sits_to_xlsx",
+    "sits_timeseries_to_csv",
     # Tuning
     "sits_tuning_hparams",
     "sits_tuning",
     # Visualization
     "plot",
     "sits_view",
+    "sits_sankey",
     # DSL Variables
     "MaskValue",
     "hparam",

{pysits-2.0.0.dev0 → pysits-2.0.0.dev2}/pysits/conversions/tibble.py

@@ -480,7 +480,8 @@ def geopandas_to_tibble(data: GeoPandasDataFrame) -> RDataFrame:
             f"Warning: Dropping columns with embedded DataFrames: {dropped_columns}"
         )
 
-    data_safe = data[safe_columns].copy()
+    # Geometries are transferred as WKT, so the result is a plain data frame
+    data_safe = PandasDataFrame(data[safe_columns].copy())
 
     if isinstance(data, GeoPandasDataFrame):
         geom_col = data.geometry.name

pysits-2.0.0.dev2/pysits/docs/content/impute_linear.md

@@ -0,0 +1,10 @@
+Replace NA values by linear interpolation
+
+Remove NA by linear interpolation
+
+Args:
+    data (list): A time series vector or matrix.
+
+Returns:
+    R: A set of filtered time series using the imputation function.
+

pysits-2.0.0.dev2/pysits/docs/content/impute_mean.md

@@ -0,0 +1,9 @@
+Remove NA using mean
+
+Remove NA using mean
+
+Args:
+    data (list[float] | SITSMatrix): A time series vector or matrix.
+
+Returns:
+    R: A set of filtered time series using the imputation function.

pysits-2.0.0.dev2/pysits/docs/content/impute_mean_window.md

@@ -0,0 +1,23 @@
+Remove NA using weighted moving average
+
+Remove NA using weighted moving average
+
+Args:
+    data (list[float]): A time series vector or matrix.
+    k (int): Width of the moving average window. Expands to both sides
+        of the center element e.g. k = 2 means 4 observations (2 left,
+        2 right) are taken into account. If all observations in the
+        current window are NA, the window size is automatically
+        increased until there are at least 2 non-NA values present.
+    weighting (str): Weighting strategy to be used. More details below
+        (default is "simple").
+
+Returns:
+    R: A set of filtered time series using the imputation function.
+
+Notes:
+    The `weighting` parameter defines the weighting strategy used in the
+    moving window. The strategies available are:
+    - `simple` - Simple Moving Average (SMA) (default option)
+    - `linear` - Linear Weighted Moving Average (LWMA)
+    - `exponential` - Exponential Weighted Moving Average (EWMA)

pysits-2.0.0.dev2/pysits/docs/content/impute_median.md

@@ -0,0 +1,9 @@
+Remove NA using median
+
+Remove NA using median
+
+Args:
+    data (list | SITSMatrix): A time series vector or matrix.
+
+Returns:
+    R: A set of filtered time series using the imputation function.

pysits-2.0.0.dev2/pysits/docs/content/plot.md

@@ -0,0 +1,117 @@
+Plot sits objects.
+
+A single dispatching function that produces a plot appropriate to the type
+of the object passed as `x`. It covers data cubes (raster, SAR, DEM,
+vector), probability and uncertainty products, variance cubes, patterns,
+time-series predictions, embeddings, clustering and SOM outputs, accuracy
+tables, and trained models. Depending on the object type, the plot is
+rendered as a map, a chart, or a raster image.
+
+The accepted keyword arguments depend on the type of `x`. The sections
+below group the parameters by the kind of object being plotted.
+
+Args:
+    x (SITSCubeModel | SITSTimeSeriesModel | SITSTimeSeriesPatternsModel | SITSMachineLearningMethod | SITSConfusionMatrix):
+        Object to be plotted. Supported kinds include raster, SAR, DEM,
+        and vector cubes; classified, probability, uncertainty, and
+        variance cubes; patterns; time-series and embedding predictions;
+        geographic distances; clustering and SOM outputs; accuracy
+        tables; t-SNE projections; and trained models.
+    y: Ignored. Present for compatibility with the generic `plot`.
+    band (str): For raster, SAR, DEM, and vector cubes, the band used to
+        plot a grey (B/W) image. For SOM maps, the band to be plotted.
+    red (str): Band assigned to the red channel for RGB plots of raster,
+        SAR, and vector cubes.
+    green (str): Band assigned to the green channel for RGB plots.
+    blue (str): Band assigned to the blue channel for RGB plots.
+    tile (str): Tile to be plotted (for cube objects).
+    dates (list[str]): Dates to be plotted (raster, SAR, and vector
+        cubes).
+    roi (dict): Spatial extent (region of interest) to plot, in WGS 84.
+        See notes.
+    labels (list[str]): Labels to plot (probability, variance, and vector
+        cubes).
+    bands (list[str]): Bands to be viewed (for patterns and time-series
+        predictions).
+    legend (dict): Maps labels to colors (class cubes, SOM maps, and
+        cluster confusion plots).
+    legend_position (str): Where to place the legend. Typical default is
+        `"inside"` for RGB/grey plots and `"outside"` for classified and
+        probability maps.
+    legend_title (str): Title of the legend for probability and variance
+        cubes (for example `"probs"` or `"logvar"`).
+    palette (str): An `RColorBrewer` or `cols4all` palette. For
+        chart-based plots (predictions, embeddings, clusters, t-SNE), an
+        HCL palette name.
+    rev (bool): Whether to reverse the color order in the palette.
+    scale (float): Relative scale (roughly 0.4 to 1.0) of the plot text
+        and map.
+    quantile (float): Minimum quantile to plot (probability and variance
+        cubes).
+    first_quantile (float): First quantile used for stretching images.
+    last_quantile (float): Last quantile used for stretching images.
+    max_cog_size (int): Maximum size of COG (Cloud Optimized GeoTIFF)
+        overviews, in lines/columns (pixels).
+    seg_color (str): Color used for segment borders in vector cubes.
+    line_width (float): Line width used for segment borders in vector
+        cubes.
+    type (str): Type of plot. For accuracy objects, either
+        `"confusion_matrix"` or `"metrics"`. For variance cubes, `"map"`
+        or `"hist"`. For SOM maps, `"codes"` (neuron weight time series)
+        or `"mapping"` (number of samples per neuron).
+    year_grid (bool): For patterns, whether to plot a grid of panels
+        using labels as columns and years as rows (default `False`).
+    cluster: For clustering plots, the cluster object produced by
+        `sits_cluster_dendro`.
+    cutree_height (float): For clustering plots, the height at which to
+        draw a dashed horizontal line indicating where the dendrogram is
+        cut.
+    name_cluster (str): For SOM cluster evaluation, the cluster to plot.
+    title (str): For SOM cluster evaluation, the title of the plot.
+    tree_idx (int): For XGBoost models, the index of the tree to be
+        plotted.
+    plot_embedding (str): For embedding predictions, either `"none"` (plot
+        only the predicted class intervals) or `"area"` (overlay a
+        smoothed vertical embedding profile per year).
+    stretch (list[float]): For embedding predictions, the lower and upper
+        quantiles used to stretch embedding values before plotting
+        (default `[0.02, 0.98]`).
+    class_alpha (float): For embedding predictions, transparency of the
+        class polygons in `[0, 1]` (default `0.7`).
+    area_alpha (float): For embedding predictions, transparency of the
+        embedding area in `[0, 1]` (default `0.25`).
+    area_width (float): For embedding predictions, the horizontal width
+        fraction of the embedding area along the time axis.
+    area_spar (float): For embedding predictions, the smoothing parameter
+        passed to the spline fit (default `0.6`); higher values produce
+        smoother profiles.
+    **kwargs (dict): Further specifications for the plot. The keywords
+        understood depend on the type of `x` (see below).
+
+Returns:
+    None: A plot appropriate to the type of `x` is drawn. Maps of cubes
+        yield color or B/W raster images (optionally overlaid with segment
+        boundaries for vector cubes); probability, uncertainty, and
+        variance cubes yield per-class or per-pixel maps; classified cubes
+        yield color maps where each pixel is colored by its label.
+        Chart-based plots (patterns, predictions, embeddings, clusters,
+        t-SNE, model diagnostics) render the corresponding plot. Some
+        methods (accuracy tables, SOM diagnostics, model summaries) are
+        called only for their side effect of drawing the plot.
+
+Notes:
+        The set of valid keyword arguments depends on the type of `x`;
+        passing arguments that do not apply to a given object type has no
+        effect. When a region of interest (`roi`) is supported, it defines
+        the spatial extent to plot in WGS 84.
+
+Examples:
+    from pysits import *
+
+    # Plot a set of time-series patterns (one average pattern per label)
+    patterns = sits_patterns(samples_modis_ndvi)
+    plot(patterns)
+
+    # Train a random forest model and plot its important variables
+    rf_model = sits_train(samples_modis_ndvi, ml_method=sits_rfor())
+    plot(rf_model)

pysits-2.0.0.dev2/pysits/docs/content/sits_accuracy.md

@@ -0,0 +1,81 @@
+Assess classification accuracy
+
+This function calculates the accuracy of the classification result. The
+input is either a set of classified time series or a classified data cube.
+Classified time series are produced by `sits_classify`. Classified images
+are generated using `sits_classify` followed by
+`sits_label_classification`.
+For a set of time series, `sits_accuracy` creates a confusion matrix and
+calculates the resulting statistics. For a classified image, the function
+uses an area-weighted technique proposed by Olofsson et al. according to
+references [1-3] to produce reliable accuracy estimates at 95% confidence
+level. In both cases, it provides an accuracy assessment of the
+classified, including Overall Accuracy, Kappa, User's Accuracy, Producer's
+Accuracy and error matrix (confusion matrix).
+
+Args:
+    data (SITSCubeModel | SITSTimeSeriesModel): Either a data cube with
+        classified images or a set of time series.
+    prediction_attr (str): Name of the column of the segments that contains
+        the predicted values (only for vector class cubes).
+    reference_attr (str): Name of the column of the segments that contains
+        the reference values (only for vector class cubes).
+    validation (str | pathlib.Path | pandas.DataFrame | geopandas.GeoDataFrame | SITSTimeSeriesModel):
+        Samples for validation (see below). Only required when data is a
+        raster class cube.
+    method (str): Either 'olofsson' or 'pixel' to compute accuracy (only
+        for raster class cubes).
+    **kwargs (dict): Specific parameters.
+
+Returns:
+    SITSData: The error_matrix, the class_areas, the unbiased estimated
+    areas, the standard error areas, confidence interval 95 and the
+    accuracy (user, producer, and overall), or `None` if the data is
+    empty. The result can be visualized directly on the screen.
+
+Notes:
+    The `validation` data needs to contain the following columns:
+    "latitude", "longitude", "start_date", "end_date", and "label". It can
+    be either a path to a CSV file, a `SITSTimeSeriesModel`, a
+    `pandas.DataFrame`, or a `geopandas.GeoDataFrame`.
+    When `validation` is a `geopandas.GeoDataFrame`, the columns "latitude"
+    and "longitude" are not required as the locations are extracted from the
+    geometry column. The `centroid` is calculated before extracting the
+    location values for any geometry type.
+
+Examples:
+    from pysits import *
+    import tempfile
+
+    # show accuracy for a set of samples
+    train_data = sits_sample(samples_modis_ndvi, frac=0.5)
+    test_data = sits_sample(samples_modis_ndvi, frac=0.5)
+    rfor_model = sits_train(train_data, sits_rfor())
+    points_class = sits_classify(
+        data=test_data, ml_model=rfor_model
+    )
+    acc = sits_accuracy(points_class)
+
+    # show accuracy for a data cube classification
+    # create a random forest model
+    rfor_model = sits_train(samples_modis_ndvi, sits_rfor())
+    # create a data cube from local files
+    data_dir = r_package_dir("extdata/raster/mod13q1", package="sits")
+    cube = sits_cube(
+        source="BDC",
+        collection="MOD13Q1-6.1",
+        data_dir=data_dir
+    )
+    # classify a data cube
+    probs_cube = sits_classify(
+        data=cube, ml_model=rfor_model, output_dir=tempfile.gettempdir()
+    )
+    # label the probability cube
+    label_cube = sits_label_classification(
+        probs_cube,
+        output_dir=tempfile.gettempdir()
+    )
+    # obtain the ground truth for accuracy assessment
+    ground_truth = r_package_dir("extdata/samples/samples_sinop_crop.csv", package="sits")
+    # make accuracy assessment
+    as_ = sits_accuracy(label_cube, validation=ground_truth)

pysits-2.0.0.dev2/pysits/docs/content/sits_accuracy_summary.md

@@ -0,0 +1,11 @@
+Print accuracy summary
+
+Adaptation of the caret::print.confusionMatrix method for the more
+common usage in Earth Observation.
+
+Args:
+    x (SITSConfusionMatrix): Accuracy assessment object.
+    digits (int): Number of significant digits when printed.
+
+Returns:
+    SITSData: Called for side effects.

pysits-2.0.0.dev2/pysits/docs/content/sits_add_base_cube.md

@@ -0,0 +1,55 @@
+Add base maps to a time series data cube
+
+This function add base maps to time series data cube. Base maps have
+information that is stable in time (e.g, DEM) which provide relevant
+information for modelling and classification.
+To add a base cube to an existing data cube, they should share the same
+sensor, resolution, bounding box, timeline, and have different bands.
+
+Args:
+    cube1 (SITSCubeModel): Data cube.
+    cube2 (SITSCubeModel): Base data cube (e.g., DEM).
+
+Returns:
+    SITSCubeModel: a merged data cube with the inclusion of base
+        information.
+
+Examples:
+    from pysits import *
+    import tempfile
+    import os
+
+    s2_cube = sits_cube(
+        source="MPC",
+        collection="SENTINEL-2-L2A",
+        tiles="18HYE",
+        bands=["B8A", "CLOUD"],
+        start_date="2022-01-01",
+        end_date="2022-03-31"
+    )
+    output_dir = os.path.join(tempfile.gettempdir(), "reg")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    dem_cube = sits_cube(
+        source="MPC",
+        collection="COP-DEM-GLO-30",
+        tiles="18HYE",
+        bands="ELEVATION"
+    )
+    s2_reg = sits_regularize(
+        cube=s2_cube,
+        period="P1M",
+        res=240,
+        output_dir=output_dir,
+        multicores=2,
+        memsize=4
+    )
+    dem_reg = sits_regularize(
+        cube=dem_cube,
+        res=240,
+        tiles="18HYE",
+        output_dir=output_dir,
+        multicores=2,
+        memsize=4
+    )
+    s2_reg = sits_add_base_cube(s2_reg, dem_reg)

pysits-2.0.0.dev2/pysits/docs/content/sits_apply.md

@@ -0,0 +1,102 @@
+Apply a function on a set of time series
+
+Apply a named expression to a set of time series or a data cube to be
+evaluated and generate new bands (indices). In the case of data cubes, it
+creates a new band in `output_dir`.
+
+Args:
+    data (SITSTimeSeriesModel | SITSCubeModel): Valid time series or data
+        cube.
+    window_size (int): An odd number representing the size of the sliding
+        window of kernel functions used in expressions (for a list of
+        supported kernel functions, please see details).
+    memsize (int): Memory available for classification (in GB).
+    multicores (int): Number of cores to be used for classification.
+    normalized (bool): Does the expression produces a normalized band?
+    output_dir (str | pathlib.Path): Directory where files will be saved.
+    progress (bool): Show progress bar?
+    **kwargs (dict): Named expressions to be evaluated (see details).
+
+Returns:
+    SITSFrame: A set of time series or a data cube with new bands, produced
+    according to the requested expression.
+
+Notes:
+    The main `sits` classification workflow has the following steps:
+    1. `sits_cube`: selects a ARD image collection from a cloud provider.
+    2. `sits_cube_copy`: copies an ARD image collection from a cloud provider
+       to a local directory for faster processing.
+    3. `sits_regularize`: create a regular data cube from an ARD image
+       collection.
+    4. `sits_apply`: create new indices by combining bands of a regular data
+       cube (optional).
+    5. `sits_get_data`: extract time series from a regular data cube based on
+       user-provided labelled samples.
+    6. `sits_train`: train a machine learning model based on image time series.
+    7. `sits_classify`: classify a data cube using a machine learning model and
+       obtain a probability cube.
+    8. `sits_smooth`: post-process a probability cube using a spatial smoother
+       to remove outliers and increase spatial consistency.
+    9. `sits_label_classification`: produce a classified map by selecting the
+       label with the highest probability from a smoothed cube.
+    `sits_apply()` allows any valid expression to compute new bands. Besides
+    arithmetic operators, you can use virtually any function that can be
+    applied to elements of a matrix (functions that are unaware of matrix
+    sizes, e.g. `sqrt()`, `sin()`, `log()`).
+    Examples of valid expressions:
+    1. `NDVI = (B08 - B04) / (B08 + B04)` for Sentinel-2 images.
+    2. `EVI = 2.5 * (B05 ook04) / (B05 + 6 * B04 7.5 * B02 + 1)` for
+       Landsat-8/9 images.
+    3. `VV_VH_RATIO = VH/VV` for Sentinel-1 images. In this case, set the
+       `normalized` parameter to False.
+    4. `VV_DB = 10 * log10(VV)` to convert Sentinel-1 RTC images available in
+       Planetary Computer to decibels. Also, set the `normalized` parameter to
+       False.
+    `sits_apply()` also accepts a predefined set of kernel functions (see
+    below) that can be applied to pixels considering its neighborhood. The
+    function considers a neighborhood of a pixel as a set of pixels equidistant
+    to it (including itself). This neighborhood forms a square window (also
+    known as kernel) around the central pixel (Moore neighborhood). Users can
+    set the `window_size` parameter to adjust the size of the kernel window.
+    The image is conceptually mirrored at the edges so that neighborhood
+    including a pixel outside the image is equivalent to take the 'mirrored'
+    pixel inside the edge.
+    `sits_apply()` applies a function to the kernel and its result is assigned
+    to a corresponding central pixel on a new matrix. The kernel slides
+    throughout the input image and this process generates an entire new matrix,
+    which is returned as a new band to the cube. The kernel functions ignores
+    any `None` values inside the kernel window. If all pixels in the window are
+    `None` the result will be `None`.
+    By default, the indexes generated by `sits_apply()` function are normalized
+    between -1 and 1, scaled by a factor of 0.0001. Normalized indexes are
+    saved as INT2S (Integer with sign). If the `normalized` parameter is False,
+    no scaling factor will be applied and the index will be saved as FLT4S
+    (signed float) and the values will vary between -3.4e+38 and 3.4e+38.
+
+Examples:
+    from pysits import *
+    import tempfile
+
+    # get a time series
+    # Apply a normalization function
+    point2 = sits_apply(
+        sits_select(point_mt_6bands, "NDVI"),
+        NDVI_norm="(NDVI - min(NDVI)) / (max(NDVI) - min(NDVI))"
+    )
+
+    # Example of generation texture band with variance
+    # Create a data cube from local files
+    data_dir = r_package_dir("extdata/raster/mod13q1", package="sits")
+    cube = sits_cube(
+        source="BDC",
+        collection="MOD13Q1-6.1",
+        data_dir=data_dir
+    )
+
+    # Generate a texture images with variance in NDVI images
+    cube_texture = sits_apply(
+        data=cube,
+        NDVITEXTURE="w_median(NDVI)",
+        window_size=5,
+        output_dir=tempfile.mkdtemp()
+    )

pysits-2.0.0.dev2/pysits/docs/content/sits_as_geopandas.md

@@ -0,0 +1,28 @@
+Return a set of time series or a data cube as a `geopandas.GeoDataFrame`.
+
+Converts a set of time series or a data cube to a `geopandas.GeoDataFrame`.
+
+Args:
+    data (SITSTimeSeriesModel | SITSCubeModel): a set of time series or
+            a data cube.
+    crs (CRS): input coordinate reference system.
+    as_crs (CRS): output coordinate reference system.
+    **kwargs (dict): additional parameters.
+
+Returns:
+    SITSFrame: a point or polygon geometry object.
+
+Examples:
+    from pysits import *
+
+    # convert sits tibble to a GeoPandas object (point)
+    geo_object = sits_as_geopandas(cerrado_2classes)
+
+    # convert sits cube to a GeoPandas object (polygon)
+    data_dir = r_package_dir("extdata/raster/mod13q1", package="sits")
+    cube = sits_cube(
+        source="BDC",
+        collection="MOD13Q1-6.1",
+        data_dir=data_dir
+    )
+    geo_object = sits_as_geopandas(cube)

pysits-2.0.0.dev2/pysits/docs/content/sits_bands.md

@@ -0,0 +1,30 @@
+Get the names of the bands
+
+Finds the names of the bands of a set of time series or of a data cube
+
+Args:
+    x (SITSTimeSeriesModel | SITSCubeModel): time series or data cube.
+    value (list[str]): new value for the bands.
+
+Returns:
+    list: the names of the bands.
+
+Examples:
+    from pysits import *
+
+    # Create a data cube from local files
+    data_dir = r_package_dir("extdata/raster/mod13q1", package="sits")
+    cube = sits_cube(
+        source="BDC",
+        collection="MOD13Q1-6.1",
+        data_dir=data_dir
+    )
+    # Get the bands from a data cube
+    bands = sits_bands(cube)
+    # Get the bands from a sits tibble
+    bands = sits_bands(samples_modis_ndvi)
+    # Get the bands from patterns
+    bands = sits_bands(sits_patterns(samples_modis_ndvi))
+    # Get the bands from ML model
+    rf_model = sits_train(samples_modis_ndvi, sits_rfor())
+    bands = sits_bands(rf_model)