cdts 0.1.0__tar.gz

cdts-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: cdts
+Version: 0.1.0
+Summary: Change Detection Python Library (LandTrendr, CCDC, etc)
+Requires-Dist: numpy
+Requires-Dist: numba>=0.53.0
+Requires-Dist: rasterio
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: dask[array]
+Requires-Dist: xarray
+Requires-Dist: pystac-client
+Requires-Dist: stackstac
+Requires-Dist: geopandas
+Requires-Dist: torch
+Requires-Dist: einops
+Requires-Dist: transformers
+Requires-Dist: planetary-computer
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"

cdts-0.1.0/README.md

@@ -0,0 +1,274 @@
+# CDTS: Change Detection and Time-Series for Python
+
+<p align="center">
+  <img src="docs/assets/logo.png" alt="CDTS Logo" width="400">
+</p>
+
+[![Build and Publish Wheels](https://github.com/sacridini/cdts/actions/workflows/build_wheels.yml/badge.svg)](https://github.com/sacridini/cdts/actions/workflows/build_wheels.yml) [![Tests](https://github.com/sacridini/cdts/actions/workflows/tests.yml/badge.svg)](https://github.com/sacridini/cdts/actions/workflows/tests.yml)
+
+`cdts` is an ultra-fast, cloud-native Python library for **Remote Sensing Time-Series Analysis and Change Detection**. 
+
+Designed to replace heavy dependencies on Google Earth Engine, `cdts` handles the entire geospatial pipeline locally or on cloud clusters: from directly streaming satellite imagery via **STAC** APIs, to scaling memory lazily with **Dask/Xarray**, down to executing heavy statistical regression in native **C++**.
+
+It provides state-of-the-art algorithms:
+*   **LandTrendr** (Landsat-based detection of Trends in Disturbance and Recovery)
+*   **CCDC** (Continuous Change Detection and Classification)
+*   **COLD** (Continuous monitoring of Land Disturbance)
+
+## Installation
+
+The easiest way to install `cdts` is via `pip`. We provide pre-compiled binaries (wheels) for Windows, macOS, and Linux (Python 3.9+), which means **you do not need a C++ compiler** installed on your machine!
+
+```bash
+pip install cdts
+```
+*(This will automatically install Python dependencies like `xarray`, `dask`, `scikit-learn`, `rasterio`, `torch`, and `pystac-client`)*.
+
+### Development / From Source
+
+If you want to modify the C++ backend or install the bleeding-edge version directly from GitHub, you will need a C++ Compiler (GCC, Clang, or MSVC) and Python 3.9+:
+
+```bash
+git clone https://github.com/sacridini/cdts.git
+cd cdts
+pip install -e .
+```
+
+---
+
+### Docker
+Because `cdts` relies on heavy C++ compilation and GPU-accelerated PyTorch, the easiest way to deploy it to the cloud or share it with other researchers is via our official Docker container.
+
+```bash
+# This will build the C++ engines, install PyTorch with CUDA, and launch a JupyterLab environment on port 8888.
+docker-compose up --build
+```
+
+---
+
+## Core Architecture
+
+1.  **C++ Engine (`pybind11` & `Eigen3`)**: The core statistical fitting (OLS, Robust Iteratively Reweighted Least Squares, Exact F-Statistics, Chi-Square CDFs) is fully written in C++ for maximum single-core speed.
+2.  **Cloud-Native Data Fetching (`STAC` & `stackstac`)**: Download-free pipelines! Query AWS or Microsoft servers for imagery and stream only the exact pixels you need.
+3.  **Horizontal Scaling (`xarray` & `dask`)**: Data is lazily chunked. Run processing over 100,000 km² without blowing up your RAM by distributing tasks across multiple CPU threads or remote Dask workers.
+
+---
+
+## Supported Cloud Data Services (STAC)
+
+Because `cdts` relies on the open **SpatioTemporal Asset Catalog (STAC)** standard, it can pull time-series data from virtually any modern satellite provider.
+
+| Provider / Service | Default ID in `cdts` | Highlights |
+| :--- | :--- | :--- |
+| **AWS Earth Search (Element84)** | `"earth_search"` | Free, public Sentinel-2 L2A and Landsat Collection 2. No authentication needed! |
+| **Microsoft Planetary Computer** | `"planetary_computer"` | Huge catalog (ALOS, MODIS, NAIP, Sentinel, Landsat). *Note: Requires a free token for heavy downloads.* |
+| **Brazil Data Cube (INPE)** | `"brazil_data_cube"` | High-quality ARD cubes for Brazil (CBERS-4/4A, Amazonia-1). *Note: Requires INPE token.* |
+| **Copernicus Data Space** | Custom URL | The official European Space Agency hub for Sentinel 1/2/3/5P. |
+
+---
+
+## Advanced Tutorial: End-to-End Pipeline
+
+Here is a complete workflow demonstrating how to go from zero data to a classified map of persistent water using `cdts`.
+
+### 1. Stream Virtual Data (STAC)
+No downloading required. We define a Bounding Box in Mato Grosso (Brazil) and request 2 years of Sentinel-2 data.
+
+```python
+from cdts import build_time_series
+import cdts.xarray_api # Registers the .cdts accessor on Xarray
+
+# Builds a Dask-backed virtual datacube
+cube = build_time_series(
+    source="earth_search",       
+    collection="sentinel-2-l2a",
+    bbox=[-54.0, -12.0, -53.9, -11.9],
+    start_date="2020-01-01",
+    end_date="2022-12-31",
+    cloud_cover_max=30,
+    bands=["red", "green", "blue", "nir", "swir16"],
+    epsg=3857,
+    resolution=30
+)
+print(cube.shape) # e.g., (Time: 45, Bands: 5, Y: 1000, X: 1000)
+```
+
+### 2. Run CCDC / COLD (Distributed via Dask)
+Using the Xarray accessor, we pipe the virtual cube directly into our C++ engine.
+
+```python
+# 'conseq_anom=6' activates the rigorous COLD algorithm (6 consecutive anomalies required to flag deforestation).
+# This returns a lazy map of harmonic coefficients (Intercept, Slopes, Sine, Cosine).
+ccdc_lazy_results = cube.cdts.run_ccdc(max_segments=6, conseq_anom=6, return_coefs=True)
+
+# Actually execute the download + calculation in parallel threads
+coef_stack = ccdc_lazy_results.compute()
+```
+
+### 3. Extract Physical Masks & Classify
+With the harmonic coefficients calculated, we can derive physical parameters. For instance, extracting persistent rivers/lakes by comparing the Intercept coefficients of Green (index 1) and SWIR (index 4).
+
+```python
+from cdts import extract_water_mask, predict_synthetic_image
+
+# 1. Physical Extraction: Isolate rivers and lakes
+water_mask = extract_water_mask(coef_stack.values, green_band_idx=1, swir_band_idx=4)
+
+# 2. Synthetic Imagery: Generate a cloud-free image for Julian Day 150
+cloud_free_rgb = predict_synthetic_image(coef_stack.values, target_julian_day=150, num_bands=3)
+```
+
+If you have training data, you can run a full Random Forest classification on the coefficients:
+```python
+from cdts import train_ccdc_classifier, classify_ccdc_stack
+
+clf = train_ccdc_classifier(X_train_data, y_train_labels)
+classify_ccdc_stack(clf, coef_stack_path="output/coefs.tif", output_path="landcover.tif")
+```
+
+### Pre & Post-Processing (Smoothing & Spatial Filters)
+Before classifying, it is highly recommended to smooth the temporal trajectories to remove atmospheric noise. After classifying, pixel-based maps often suffer from "salt and pepper" noise. `cdts` provides fast functions to regularize your data in both dimensions:
+
+```python
+from cdts import apply_savgol_filter, apply_majority_filter, apply_mmu_filter
+
+# 1. Temporal Smoothing: Apply Savitzky-Golay filter across the time axis (e.g. axis 0)
+smoothed_cube = apply_savgol_filter(raw_cube, window_length=5, polyorder=2)
+
+# ... (Run Classification to get `land_cover_map`) ...
+
+# 2. Spatial Regularization: Force pixels to match their 3x3 neighborhood (Mode filter)
+regularized_map = apply_majority_filter(land_cover_map, size=3)
+
+# 3. Minimum Mapping Unit (MMU): Erase any isolated patches smaller than 10 pixels
+final_map = apply_mmu_filter(regularized_map, min_pixels=10)
+```
+
+---
+
+## LandTrendr Specifics (FTV)
+If your focus is on forest recovery, `cdts` natively supports LandTrendr. A key feature is **FTV (Fitted to Vertices)**, which allows you to find structural breakpoints in an index (like NBR) and apply them to smooth out noisy raw bands (like SWIR).
+
+```python
+from cdts import run_landtrendr, apply_vertices
+
+# 1. Fit the trajectory on the main index to find the breakpoint years
+vertices = run_landtrendr(years, nbr_time_series)
+vertex_years = [v["year"] for v in vertices]
+
+# 2. Force the raw SWIR band to conform to the NBR breakpoints!
+swir_fitted = apply_vertices(vertex_years, years, raw_swir_time_series)
+```
+
+---
+
+## Deep Learning & Foundation Models (`cdts.ai`)
+Beyond statistical algorithms like CCDC, `cdts` embraces the next generation of Spatio-Temporal Artificial Intelligence. Built on **PyTorch**, the new `cdts.ai` module provides modern neural network architectures tailored for earth observation:
+
+### 1. U-TAE and TempCNN (Time-Series Neural Networks)
+Instead of processing individual pixels, **U-TAE** consumes entire 3D Data Cubes (Spatial + Temporal) simultaneously to naturally ignore cloud noise. If you prefer pixel-based time-series classification, `cdts` also provides **TempCNN**, a lightweight 1D-CNN (inspired by INPE's `sits` package) that is incredibly fast to train.
+
+```python
+from cdts.ai import UTAE, TempCNN
+import torch
+
+# U-TAE: Input shape (Batch, Time, Channels, Height, Width)
+model_3d = UTAE(in_channels=6, num_classes=5)
+
+# TempCNN: Input shape (Batch, Channels, Time)
+model_1d = TempCNN(in_channels=6, num_classes=5)
+```
+
+### 2. Bi-Temporal Siamese CNNs
+Perfect for disaster mapping (floods, fires, landslides). A Siamese Network processes a T0 ("Before") image and a T1 ("After") image through shared convolutional weights, then extracts absolute differences deep in the feature space.
+
+```python
+from cdts.ai import SiameseChangeDetector
+
+model = SiameseChangeDetector(in_channels=4, num_classes=2)
+img_before = torch.randn(1, 4, 512, 512)
+img_after = torch.randn(1, 4, 512, 512)
+
+# Outputs a spatial change map directly
+change_map = model(img_before, img_after)
+```
+
+### 3. Geospatial Foundation Models (ViT)
+`cdts.ai.GeoFoundationViT` acts as a wrapper/stub to plug in large-scale Vision Transformers (like the **NASA/IBM Prithvi** model). It enables you to take pre-trained planetary representations and fine-tune them for specific downstream tasks like deforestation or crop classification.
+
+### 4. Specialized Change Detection Losses
+Remote sensing datasets are highly imbalanced (usually >99% unchanged pixels). Standard Cross-Entropy fails here. `cdts.ai.losses` provides battle-tested loss functions specifically for Change Detection:
+```python
+from cdts.ai.losses import FocalLoss, TverskyLoss, ContrastiveSiameseLoss
+
+# Focal Loss: Forces the network to focus gradients on hard-to-detect subtle changes
+criterion1 = FocalLoss(alpha=0.25, gamma=2.0)
+
+# Tversky Loss: Penalizes False Negatives heavier than False Positives (beta=0.7)
+criterion2 = TverskyLoss(alpha=0.3, beta=0.7)
+```
+
+---
+
+## Tmask: Time-Series Cloud Masking
+Before running CCDC or deep learning models, you must have clean data. While STAC APIs provide QA bands (like Fmask), `cdts` natively implements **Tmask** (Zhu & Woodcock 2014) to dynamically find undetected clouds and shadows.
+
+Tmask runs a robust harmonic regression on Green and SWIR bands. If a pixel suddenly flashes bright green or dark SWIR without altering the long-term structural trajectory, it is flagged as noise.
+
+```python
+from cdts import apply_tmask_stack
+
+# Outputs a Boolean mask (True = Clear, False = Cloud/Shadow)
+# Uses robust Huber regression under the hood
+clear_sky_mask = apply_tmask_stack(dates_julian, green_cube, swir_cube)
+```
+
+---
+
+## Exporting & Saving Data (IO)
+Instead of dealing with complex `rasterio` profiles, `cdts` includes a powerful `save_raster` utility that automatically extracts the geotransform and CRS from the downloaded STAC Datacube and exports your PyTorch/Numpy predictions into professional, ready-to-use GeoTIFFs.
+
+```python
+from cdts import save_raster, get_georef
+
+# Extract geospatial reference explicitly if needed
+geo_info = get_georef(cube)
+print(geo_info["crs"]) # e.g. "EPSG:3857"
+
+# Or save the array seamlessly using the original cube as reference!
+# Handles 2D, 3D, and even 4D cubes out-of-the-box.
+save_raster(prediction_array, "output/final_map.tif", reference_cube=cube, nodata=255)
+```
+
+---
+
+## End-to-End Examples
+We provide **6 complete example scripts** in the `examples/` directory. They cover everything from downloading STAC data to temporal smoothing and classification using both statistical and AI models. Running these scripts will automatically output georeferenced GeoTIFFs into `examples/data/`.
+
+- `example_01_landtrendr.py` (LandTrendr Disturbance Year)
+- `example_02_ccdc_cold.py` (CCDC / COLD Synthetic Image Generation)
+- `example_03_ai_siamese.py` (Siamese Neural Network)
+- `example_04_ai_utae.py` (U-TAE 4D processing)
+- `example_05_ai_tempcnn.py` (TempCNN time-series)
+- `example_06_ai_vit.py` (Geospatial Foundation Model)
+
+```bash
+# Try one!
+python examples/example_05_ai_tempcnn.py
+```
+
+---
+
+## Command Line Interface (CLI)
+
+Prefer the terminal? If you already have a massive GeoTIFF locally, you can process it chunk-by-chunk using the CLI.
+
+```bash
+# Run LandTrendr (Extracting just the break years)
+cdts landtrendr input_stack.tif output_folder/ \
+    --start-year 1990 --event-type loss --jobs -1
+
+# Run COLD (Extracting the harmonic coefficient matrix)
+cdts ccdc multi_band_stack.tif output_folder/ \
+    --num-bands 6 --max-segments 6 --cold --jobs -1
+```

cdts-0.1.0/cdts/__init__.py

@@ -0,0 +1,27 @@
+from .landtrendr import run_landtrendr, desawtooth, apply_vertices
+from .raster import run_landtrendr_array, run_landtrendr_image, run_ccdc_array, run_ccdc_image
+from .metrics import extract_events
+from .ccdc import predict_synthetic_image
+from .classify import train_ccdc_classifier, classify_ccdc_stack
+from .spatial import apply_mmu_filter, apply_majority_filter
+from .smooth import apply_savgol_filter
+from .masks import extract_water_mask
+from .tmask import run_tmask_pixel, apply_tmask_stack
+from .cube import build_time_series
+from .io import save_raster, get_georef
+import cdts.xarray_api # This registers the xarray accessor automatically
+import cdts.ai
+
+__all__ = [
+    "run_landtrendr", "desawtooth", "apply_vertices", 
+    "run_landtrendr_array", "run_landtrendr_image", 
+    "run_ccdc_array", "run_ccdc_image", 
+    "extract_events", "predict_synthetic_image",
+    "train_ccdc_classifier", "classify_ccdc_stack",
+    "apply_mmu_filter", "apply_majority_filter", "apply_savgol_filter", 
+    "extract_water_mask",
+    "run_tmask_pixel", "apply_tmask_stack",
+    "build_time_series",
+    "save_raster",
+    "ai"
+]

cdts-0.1.0/cdts/ccdc.py

@@ -0,0 +1,89 @@
+import numpy as np
+from typing import List, Dict, Any, Union
+from . import _core
+
+def run_ccdc(
+    dates: Union[np.ndarray, List[float]], 
+    values: Union[np.ndarray, List[List[float]]], 
+    qa: Union[np.ndarray, List[int]], 
+    min_obs: int = 12, 
+    conseq_anom: int = 3, 
+    chi2_prob_threshold: float = 0.99
+) -> List[Dict[str, Any]]:
+    """
+    Continuous Change Detection and Classification (CCDC).
+    
+    This function wraps the C++ implementation.
+    """
+    dates_list = dates.tolist() if isinstance(dates, np.ndarray) else list(dates)
+    
+    params = _core.ccdc.CCDCParams()
+    params.min_obs = min_obs
+    params.conseq_anom = conseq_anom
+    params.chi2_prob_threshold = chi2_prob_threshold
+    
+    # Ensure values is 2D: (num_bands, num_dates)
+    if isinstance(values, np.ndarray):
+        if values.ndim == 1:
+            values_list = [values.tolist()]
+        else:
+            values_list = values.tolist()
+    else:
+        # If it's a list, check if it's 1D or 2D
+        if len(values) > 0 and not isinstance(values[0], (list, tuple, np.ndarray)):
+            values_list = [values]
+        else:
+            values_list = values
+            
+    qa_list = qa.tolist() if isinstance(qa, np.ndarray) else list(qa)
+    
+    segments = _core.ccdc.fit_ccdc(dates_list, values_list, qa_list, params)
+    
+    return [
+        {
+            "t_start": s.t_start,
+            "t_end": s.t_end,
+            "t_break": s.t_break,
+            "coefs": s.coefs,
+            "rmse": s.rmse,
+            "magnitude": s.magnitude
+        } for s in segments
+    ]
+
+def predict_synthetic_image(ccdc_coefs_stack: np.ndarray, target_julian_day: int, num_bands: int = 6) -> np.ndarray:
+    """
+    Generates a cloud-free synthetic image for a specific day using CCDC harmonic coefficients.
+    ccdc_coefs_stack: 4D numpy array output from run_ccdc_array() or read from _coefs.tif.
+    """
+    import numpy as np
+    
+    _, bands_dim, rows, cols = ccdc_coefs_stack.shape
+    
+    W = 2.0 * np.pi / 365.25
+    t = float(target_julian_day)
+    
+    terms = np.array([
+        1.0, t, np.cos(W * t), np.sin(W * t), np.cos(2.0 * W * t), np.sin(2.0 * W * t)
+    ])
+    
+    synthetic_image = np.zeros((num_bands, rows, cols), dtype=np.float32)
+    
+    for r in range(rows):
+        for c in range(cols):
+            best_seg = 0
+            for i in range(ccdc_coefs_stack.shape[0]):
+                t_start = ccdc_coefs_stack[i, 0, r, c]
+                t_end = ccdc_coefs_stack[i, 1, r, c]
+                
+                if t_start <= t <= t_end:
+                    best_seg = i
+                    break
+            
+            idx = 3
+            for b in range(num_bands):
+                idx += 1 # skip RMSE
+                coefs = ccdc_coefs_stack[best_seg, idx:idx+6, r, c]
+                idx += 6
+                synthetic_image[b, r, c] = np.dot(coefs, terms)
+                
+    return synthetic_image

cdts-0.1.0/cdts/classify.py

@@ -0,0 +1,51 @@
+import numpy as np
+from sklearn.ensemble import RandomForestClassifier
+import rasterio
+from typing import Optional
+
+def train_ccdc_classifier(X_train: np.ndarray, y_train: np.ndarray, n_estimators: int = 100, random_state: int = 42) -> RandomForestClassifier:
+    """
+    Trains a Random Forest classifier for CCDC land cover classification.
+    X_train: array-like of shape (n_samples, n_features). Features should be the harmonic coefficients and RMSE.
+    y_train: array-like of shape (n_samples,). The land cover class labels.
+    """
+    clf = RandomForestClassifier(n_estimators=n_estimators, random_state=random_state, n_jobs=-1)
+    clf.fit(X_train, y_train)
+    return clf
+
+def classify_ccdc_stack(clf: RandomForestClassifier, coef_stack_path: str, output_path: str, chunk_size: int = 512) -> None:
+    """
+    Applies the trained Random Forest classifier to a full CCDC coefficient GeoTIFF stack.
+    Assumes the model was trained on the exact band configuration present in the TIFF.
+    """
+    with rasterio.open(coef_stack_path) as src:
+        profile = src.profile
+        profile.update(count=1, dtype="uint8", nodata=0)
+        
+        with rasterio.open(output_path, "w", **profile) as dst:
+            for row in range(0, src.height, chunk_size):
+                for col in range(0, src.width, chunk_size):
+                    window = rasterio.windows.Window(
+                        col, row, 
+                        min(chunk_size, src.width - col), 
+                        min(chunk_size, src.height - row)
+                    )
+                    
+                    data = src.read(window=window)
+                    n_features, h, w = data.shape
+                    
+                    data_reshaped = data.transpose(1, 2, 0).reshape(-1, n_features)
+                    
+                    mask = (data_reshaped[:, 0] != 0) | (data_reshaped[:, 1] != 0)
+                    
+                    predictions = np.zeros(h * w, dtype=np.uint8)
+                    
+                    if np.any(mask):
+                        preds = clf.predict(data_reshaped[mask])
+                        predictions[mask] = preds
+                        
+                    out_img = predictions.reshape(1, h, w)
+                    dst.write(out_img, window=window)
+                    
+    print(f"Classification saved to {output_path}")
+

cdts-0.1.0/cdts/cli.py

@@ -0,0 +1,112 @@
+import argparse
+import sys
+from typing import Optional, List
+
+from .raster import run_landtrendr_image, run_ccdc_image
+
+def run_landtrendr(args: argparse.Namespace) -> None:
+    try:
+        run_landtrendr_image(
+            input_path=args.input,
+            output_dir=args.output_dir,
+            start_year=args.start_year,
+            max_segments=args.max_segments,
+            chunk_size=args.chunk_size,
+            n_jobs=args.jobs,
+            save_vertices=args.save_vertices,
+            event_type=args.event_type,
+            sort_by=args.sort_by,
+            min_mag=args.min_mag,
+            min_dur=args.min_dur,
+            pre_val_thresh=args.pre_val_thresh,
+            prefix=args.prefix,
+            output_scale_factor=args.output_scale
+        )
+    except Exception as e:
+        print(f"Error running LandTrendr: {e}")
+        sys.exit(1)
+
+def run_ccdc_cli(args: argparse.Namespace) -> None:
+    try:
+        # User needs to provide a list of dates. We'll read it from a text/csv file.
+        # Alternatively, if not provided, we can simulate dates for testing (but throw warning)
+        import os
+        import numpy as np
+        
+        dates: List[int] = []
+        if args.dates_file and os.path.exists(args.dates_file):
+            with open(args.dates_file, 'r') as f:
+                dates = [int(line.strip()) for line in f if line.strip().isdigit()]
+        else:
+            print("WARNING: No --dates-file provided. Assuming 1 observation every 16 days (Landsat).")
+            # We don't know the number of dates until we open the file, so we'll 
+            # let process_file_ccdc handle it or we can hack it.
+            # Actually, we should force it or read the TIF first.
+            import rasterio
+            with rasterio.open(args.input) as src:
+                num_dates = src.count // args.num_bands
+            dates = list(np.arange(1, 1 + num_dates * 16, 16))
+            
+        run_ccdc_image(
+            input_path=args.input,
+            output_dir=args.output_dir,
+            dates=dates,
+            num_bands=args.num_bands,
+            qa_band_idx=args.qa_band,
+            max_segments=args.max_segments,
+            chunk_size=args.chunk_size,
+            n_jobs=args.jobs,
+            prefix=args.prefix,
+            conseq_anom=6 if args.cold else 3
+        )
+    except Exception as e:
+        print(f"Error running CCDC: {e}")
+        sys.exit(1)
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="cdts: Change Detection Python Library")
+    subparsers = parser.add_subparsers(dest="command", help="Available algorithms")
+    
+    # LandTrendr Subparser
+    lt_parser = subparsers.add_parser("landtrendr", help="Run LandTrendr algorithm")
+    lt_parser.add_argument("input", help="Path to input multi-band GeoTIFF")
+    lt_parser.add_argument("output_dir", help="Directory to save the outputs")
+    lt_parser.add_argument("--start-year", type=int, default=2000, help="Year of the first band (default: 2000)")
+    lt_parser.add_argument("--max-segments", type=int, default=6, help="Maximum number of segments (default: 6)")
+    lt_parser.add_argument("--jobs", type=int, default=-1, help="Number of CPU cores to use (-1 for all, default: -1)")
+    lt_parser.add_argument("--save-vertices", action="store_true", help="Save the raw vertices stack")
+    lt_parser.add_argument("--chunk-size", type=int, default=512, help="Size of the image chunks to process at once (default: 512)")
+    
+    # Event Extraction options
+    lt_parser.add_argument("--event-type", choices=["loss", "gain"], default="loss", help="Event type to map (default: loss)")
+    lt_parser.add_argument("--sort-by", choices=["greatest", "newest", "fastest", "longest"], default="greatest", help="How to select the event (default: greatest)")
+    lt_parser.add_argument("--min-mag", type=float, default=0.0, help="Minimum magnitude filter")
+    lt_parser.add_argument("--min-dur", type=int, default=1, help="Minimum duration filter")
+    lt_parser.add_argument("--pre-val-thresh", type=float, default=0.0, help="Pre-value threshold filter")
+    lt_parser.add_argument("--prefix", default="lt_event", help="Prefix for output metric files")
+    lt_parser.add_argument("--output-scale", type=float, default=1.0, help="Scale factor to multiply output values (e.g. 0.0001 to convert back to float NDVI)")
+    
+    # CCDC Subparser
+    ccdc_parser = subparsers.add_parser("ccdc", help="Run CCDC algorithm")
+    ccdc_parser.add_argument("input", help="Path to input stacked multi-band GeoTIFF")
+    ccdc_parser.add_argument("output_dir", help="Directory to save the outputs")
+    ccdc_parser.add_argument("--num-bands", type=int, default=6, help="Number of bands per date in the stack (default: 6)")
+    ccdc_parser.add_argument("--qa-band", type=int, default=-1, help="Index of QA band for cloud masking within the block (0-based, default: -1 for none)")
+    ccdc_parser.add_argument("--dates-file", help="Path to text file containing Julian dates (one per line)")
+    ccdc_parser.add_argument("--max-segments", type=int, default=6, help="Maximum number of segments (default: 6)")
+    ccdc_parser.add_argument("--chunk-size", type=int, default=512, help="Size of the image chunks to process at once (default: 512)")
+    ccdc_parser.add_argument("--jobs", type=int, default=-1, help="Number of CPU cores to use (-1 for all, default: -1)")
+    ccdc_parser.add_argument("--cold", action="store_true", help="Use COLD algorithm logic (6 consecutive anomalies instead of 3)")
+    ccdc_parser.add_argument("--prefix", default="ccdc", help="Prefix for output files (default: ccdc)")
+    
+    args = parser.parse_args()
+    
+    if args.command == "landtrendr":
+        run_landtrendr(args)
+    elif args.command == "ccdc":
+        run_ccdc_cli(args)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()