timesat-cli 1.4.3__py3-none-any.whl

timesat_cli/processing.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+import math, os, datetime
+
+def run(jsfile: str) -> None:
+
+    import numpy as np
+    import rasterio
+    import timesat  # external dependency
+
+    from .config import load_config, build_param_array
+    from .readers import read_file_lists, open_image_data
+    from .fsutils import create_output_folders, memory_plan, close_all
+    from .writers import prepare_profiles, write_layers
+    from .dateutils import date_with_ignored_day, generate_output_timeseries_dates
+
+    VPP_NAMES = ["SOSD","SOSV","LSLOPE","EOSD","EOSV","RSLOPE","LENGTH",
+                 "MINV","MAXD","MAXV","AMPL","TPROD","SPROD"]
+
+    def _build_output_filenames(st_folder: str, vpp_folder: str, p_outindex, yrstart: int, yrend: int, p_ignoreday: int):
+        outyfitfn = []
+        outyfitqafn = []
+        for i_tv in p_outindex:
+            yfitdate = date_with_ignored_day(yrstart, int(i_tv), p_ignoreday)
+            outyfitfn.append(os.path.join(st_folder, f"TIMESAT_{yfitdate.strftime('%Y%m%d')}.tif"))
+            outyfitqafn.append(os.path.join(st_folder, f"TIMESAT_{yfitdate.strftime('%Y%m%d')}_QA.tif"))
+
+        outvppfn = []
+        outvppqafn = []
+        outnsfn = []
+        for i_yr in range(yrstart, yrend + 1):
+            for i_seas in range(2):
+                for name in VPP_NAMES:
+                    outvppfn.append(os.path.join(vpp_folder, f"TIMESAT_{name}_{i_yr}_season_{i_seas+1}.tif"))
+                outvppqafn.append(os.path.join(vpp_folder, f"TIMESAT_QA_{i_yr}_season_{i_seas+1}.tif"))
+            outnsfn.append(os.path.join(vpp_folder, f"TIMESAT_{i_yr}_numseason.tif"))
+        return outyfitfn, outyfitqafn, outvppfn, outvppqafn, outnsfn
+
+
+    print(jsfile)
+    cfg = load_config(jsfile)
+    s = cfg.settings
+
+    if s.outputfolder == '':
+        print('Nothing to do...')
+        return
+
+    # Precompute arrays once per block to pass into timesat
+    landuse_arr          = build_param_array(s, 'landuse', 'uint8')
+    p_fitmethod_arr      = build_param_array(s, 'p_fitmethod', 'uint8')
+    p_smooth_arr         = build_param_array(s, 'p_smooth', 'double')
+    p_nenvi_arr          = build_param_array(s, 'p_nenvi', 'uint8')
+    p_wfactnum_arr       = build_param_array(s, 'p_wfactnum', 'double')
+    p_startmethod_arr    = build_param_array(s, 'p_startmethod', 'uint8')
+    p_startcutoff_arr    = build_param_array(s, 'p_startcutoff', 'double', shape=(2,), fortran_2d=True)
+    p_low_percentile_arr = build_param_array(s, 'p_low_percentile', 'double')
+    p_fillbase_arr       = build_param_array(s, 'p_fillbase', 'uint8')
+    p_seasonmethod_arr   = build_param_array(s, 'p_seasonmethod', 'uint8')
+    p_seapar_arr         = build_param_array(s, 'p_seapar', 'double')
+
+
+    timevector, flist, qlist, yr, yrstart, yrend = read_file_lists(s.tv_list, s.image_file_list, s.quality_file_list)
+ 
+    z = len(flist)
+    print(f'num of images: {z}')
+    print('First image: ' + os.path.basename(flist[0]))
+    print('Last  image: ' + os.path.basename(flist[-1]))
+    print(yrstart)
+
+    # -------load inputs----------------
+    use_s3  = getattr(s, "s3env", None)
+    if use_s3:
+        from .config_s3 import load_s3_config, build_rasterio_s3_opts, to_vsis3_paths
+        cfg_s3 = load_s3_config()
+        s3_opts = build_rasterio_s3_opts(cfg_s3)
+        flist = [to_vsis3_paths(s3_opts, cfg_s3["S3_BUCKET"], k) for k in flist]
+        qlist = [to_vsis3_paths(s3_opts, cfg_s3["S3_BUCKET"], k) for k in qlist] if qlist else []
+    else:
+        s3_opts = None
+
+    # batch_size = int(getattr(s, "read_batch_size", 32))  # recommended: 16–32 (S3), 64–128 (local SSD)
+
+    # ------load image info---------------
+    with rasterio.open(flist[0], "r") as temp:
+        img_profile = temp.profile
+
+    if sum(s.imwindow) == 0:
+        dx, dy = img_profile['width'], img_profile['height']
+    else:
+        dx, dy = int(s.imwindow[2]), int(s.imwindow[3])
+
+
+    # ------output-----------------
+    st_folder, vpp_folder = create_output_folders(s.outputfolder)
+
+    p_outindex, p_outindex_num = generate_output_timeseries_dates(s.p_st_timestep, yr, yrstart)
+
+    outyfitfn, outyfitqafn, outvppfn, outvppqafn, outnsfn = _build_output_filenames(st_folder, vpp_folder, p_outindex, yrstart, yrend, s.p_ignoreday)
+
+    img_profile_st, img_profile_vpp, img_profile_qa, img_profile_ns = prepare_profiles(img_profile, s.p_nodata, s.scale, s.offset)
+    # Open output datasets once and reuse them for all blocks
+    st_datasets = []
+    stqa_datasets = []
+    vpp_datasets = []
+    vppqa_datasets = []
+    ns_dataset = []
+
+    # VPP outputs
+    if s.outputvariables == 1:
+        for path in outvppfn:
+            ds = rasterio.open(path, "w", **img_profile_vpp)
+            vpp_datasets.append(ds)
+        for path in outvppqafn:
+            ds = rasterio.open(path, "w", **img_profile_qa)
+            vppqa_datasets.append(ds)
+        for path in outnsfn:
+            ds = rasterio.open(path, "w", **img_profile_ns)
+            ns_dataset.append(ds)
+
+    # ST (yfit) outputs
+    for path in outyfitfn:
+        ds = rasterio.open(path, "w", **img_profile_st)
+        st_datasets.append(ds)
+    for path in outyfitqafn:
+        ds = rasterio.open(path, "w", **img_profile_qa)
+        stqa_datasets.append(ds)
+
+    
+    # compute blocks
+    y_slice_size, num_block = memory_plan(dx, dy, z, p_outindex_num, yr, s.max_memory_gb)
+    y_slice_end = dy % y_slice_size if (dy % y_slice_size) > 0 else y_slice_size
+    print('y_slice_size = ' + str(y_slice_size))
+
+    for iblock in range(num_block):
+        print(f'Processing block: {iblock + 1}/{num_block}  starttime: {datetime.datetime.now()}')
+        x = dx
+        y = int(y_slice_size) if iblock != num_block - 1 else int(y_slice_end)
+        x_map = int(s.imwindow[0])
+        y_map = int(iblock * y_slice_size + s.imwindow[1])
+
+        # vi, qa, lc = open_image_data_batched(
+        #     x_map, y_map, x, y,
+        #     flist,
+        #     qlist,
+        #     (s.lc_file if s.lc_file else None),
+        #     img_profile['dtype'],
+        #     s.p_a,
+        #     s.p_band_id,
+        #     batch_size=batch_size,
+        #     s3_opts=s3_opts,
+        # )
+        vi, qa, lc = open_image_data(
+            x_map, y_map, x, y,
+            flist,
+            qlist,
+            (s.lc_file if s.lc_file else None),
+            img_profile['dtype'],
+            s.p_a,
+            s.p_band_id,
+        )
+
+        print('--- start TIMESAT processing ---  starttime: ' + str(datetime.datetime.now()))
+
+        if s.scale != 1 or s.offset != 0:
+            vi = vi * s.scale + s.offset
+
+        vpp, vppqa, nseason, yfit, yfitqa, seasonfit, tseq = timesat.tsfprocess(
+            yr, vi, qa, timevector, lc, s.p_nclasses, landuse_arr, p_outindex,
+            s.p_ignoreday, s.p_ylu, s.p_printflag, p_fitmethod_arr, p_smooth_arr,
+            s.p_nodata, s.p_davailwin, s.p_outlier,
+            p_nenvi_arr, p_wfactnum_arr, p_startmethod_arr, p_startcutoff_arr,
+            p_low_percentile_arr, p_fillbase_arr, s.p_hrvppformat,
+            p_seasonmethod_arr, p_seapar_arr, s.outputvariables)
+
+        print('--- start writing geotif ---  starttime: ' + str(datetime.datetime.now()))
+        window = (x_map, y_map, x, y)
+
+        if s.outputvariables == 1:
+            vpp  = np.moveaxis(vpp, -1, 0)
+            write_layers(vpp_datasets, vpp, window)
+
+            vppqa  = np.moveaxis(vppqa, -1, 0)
+            write_layers(vppqa_datasets, vppqa, window)
+
+            nseason  = np.moveaxis(nseason, -1, 0)
+            write_layers(ns_dataset, nseason, window)
+
+        # Move to (t, y, x)
+        yfit = np.moveaxis(yfit, -1, 0)
+
+        nodata_val = img_profile_st.get("nodata", s.p_nodata)
+        yfit = np.nan_to_num(yfit, nan=nodata_val, posinf=nodata_val, neginf=nodata_val)
+
+        if s.scale == 1 and s.offset == 0:
+            yfit = yfit.astype(img_profile['dtype'])
+        else:
+            yfit = yfit.astype('float32')
+        write_layers(st_datasets, yfit, window)
+
+        yfitqa  = np.moveaxis(yfitqa, -1, 0)
+        write_layers(stqa_datasets, yfitqa, window)
+
+        print(f'Block: {iblock + 1}/{num_block}  finishedtime: {datetime.datetime.now()}')
+
+    close_all(
+        st_datasets,
+        stqa_datasets,
+    )
+
+    if s.outputvariables == 1:
+        close_all(
+            vpp_datasets,
+            vppqa_datasets,
+            ns_dataset,
+        )
+
+    

timesat_cli/qa.py

@@ -0,0 +1,25 @@
+import numpy as np
+
+__all__ = ["assign_qa_weight"]
+
+
+def assign_qa_weight(p_a, qa: np.ndarray) -> np.ndarray:
+    """Map QA values to weights using rules in p_a."""
+    p_a = np.asarray(p_a)
+    if qa.size == 0:
+        return qa
+    qa_out = np.zeros_like(qa, dtype=float)
+    if p_a.size == 0:
+        return qa_out
+
+    if p_a.shape[1] == 2:
+        for qa_value, weight in p_a:
+            mask = (qa == qa_value)
+            qa_out[mask] = weight
+    elif p_a.shape[1] == 3:
+        for min_val, max_val, weight in p_a:
+            mask = (qa >= min_val) & (qa <= max_val)
+            qa_out[mask] = weight
+    else:
+        raise ValueError("p_a must have either 2 or 3 columns.")
+    return qa_out

timesat_cli/readers.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import datetime
+import os
+import re
+
+import numpy as np
+import rasterio
+from rasterio.windows import Window
+
+from .qa import assign_qa_weight
+
+__all__ = ["read_file_lists", "open_image_data","open_image_data_batched"]
+
+def _parse_dates_from_name(name: str) -> tuple[int, int, int]:
+    date_regex1 = r"\d{4}-\d{2}-\d{2}"
+    date_regex2 = r"\d{4}\d{2}\d{2}"
+    try:
+        dates = re.findall(date_regex1, name)
+        position = name.find(dates[0])
+        y = int(name[position : position + 4])
+        m = int(name[position + 5 : position + 7])
+        d = int(name[position + 8 : position + 10])
+        return y, m, d
+    except Exception:
+        try:
+            dates = re.findall(date_regex2, name)
+            position = name.find(dates[0])
+            y = int(name[position : position + 4])
+            m = int(name[position + 4 : position + 6])
+            d = int(name[position + 6 : position + 8])
+            return y, m, d
+        except Exception as e:
+            raise ValueError(f"No date found in filename: {name}") from e
+
+
+def _read_time_vector(tlist: str, filepaths: list[str]):
+    """Return (timevector, yr, yrstart, yrend) in YYYYDOY format."""
+    flist = [os.path.basename(p) for p in filepaths]
+    timevector = np.ndarray(len(flist), order="F", dtype="uint32")
+    if tlist == "":
+        for i, fname in enumerate(flist):
+            y, m, d = _parse_dates_from_name(fname)
+            doy = (datetime.date(y, m, d) - datetime.date(y, 1, 1)).days + 1
+            timevector[i] = y * 1000 + doy
+    else:
+        with open(tlist, "r") as f:
+            lines = f.read().splitlines()
+        for idx, val in enumerate(lines):
+            n = len(val)
+            if n == 8:  # YYYYMMDD
+                dt = datetime.datetime.strptime(val, "%Y%m%d")
+                timevector[idx] = int(f"{dt.year}{dt.timetuple().tm_yday:03d}")
+            elif n == 7:  # YYYYDOY
+                _ = datetime.datetime.strptime(val, "%Y%j")
+                timevector[idx] = int(val)
+            else:
+                raise ValueError(f"Unrecognized date format: {val}")
+
+    yrstart = int(np.floor(timevector.min() / 1000))
+    yrend = int(np.floor(timevector.max() / 1000))
+    yr = yrend - yrstart + 1
+    return timevector, yr, yrstart, yrend
+
+
+def _unique_by_timevector(flist: list[str], qlist: list[str], timevector):
+    tv_unique, indices = np.unique(timevector, return_index=True)
+    flist2 = [flist[i] for i in indices]
+    qlist2 = [qlist[i] for i in indices] if qlist else []
+    return tv_unique, flist2, qlist2
+
+
+def read_file_lists(
+    tlist: str, data_list: str, qa_list: str
+) -> tuple[np.ndarray, list[str], list[str], int, int, int]:
+    qlist: list[str] | str = ""
+    with open(data_list, "r") as f:
+        flist = f.read().splitlines()
+    if qa_list != "":
+        with open(qa_list, "r") as f:
+            qlist = f.read().splitlines()
+        if len(flist) != len(qlist):
+            raise ValueError("No. of Data and QA are not consistent")
+
+    timevector, yr, yrstart, yrend = _read_time_vector(tlist, flist)
+    timevector, flist, qlist = _unique_by_timevector(flist, qlist, timevector)
+    return (
+        timevector,
+        flist,
+        (qlist if isinstance(qlist, list) else []),
+        yr,
+        yrstart,
+        yrend,
+    )
+
+def open_image_data(
+    x_map: int,
+    y_map: int,
+    x: int,
+    y: int,
+    data_files: list[str],
+    qa_files: list[str],
+    lc_file: str | None,
+    data_type: str,
+    p_a,
+    layer: int,
+):
+    """
+    Open each raster, read the window immediately, and close it.
+    Suitable for local paths or presigned HTTPS URLs.
+
+    NOTE: This does not use rasterio.Env (AWS options blocked in your env).
+    """
+    z = len(data_files)
+    if qa_files and len(qa_files) != z:
+        raise ValueError(f"qa_files length ({len(qa_files)}) must match data_files length ({z})")
+
+    win = Window(x_map, y_map, x, y)
+
+    # Allocate final outputs
+    vi = np.empty((y, x, z), order="F", dtype=data_type)
+    qa = np.empty((y, x, z), order="F", dtype=data_type)
+    lc = np.empty((y, x), order="F", dtype=np.uint8)
+
+    # 1) VI: open -> read -> close (per file)
+    for i, path in enumerate(data_files):
+        with rasterio.open(path, "r") as ds:
+            # Read returns (y, x) when a single band is selected
+            vi[:, :, i] = ds.read(layer, window=win)
+
+    # 2) QA: open -> read -> close (per file), or fill with ones
+    if not qa_files:
+        qa.fill(1)
+    else:
+        for i, path in enumerate(qa_files):
+            with rasterio.open(path, "r") as ds:
+                # QA is commonly band 1; change if needed
+                qa[:, :, i] = ds.read(1, window=win)
+        print('data read')
+        qa = assign_qa_weight(p_a, qa)
+
+    # 3) LC: open -> read -> close (once)
+    if not lc_file:
+        lc.fill(1)
+    else:
+        with rasterio.open(lc_file, "r") as ds:
+            lc[:, :] = ds.read(1, window=win)
+        if lc.dtype != np.uint8:
+            lc[:] = lc.astype(np.uint8, copy=False)
+
+    return vi, qa, lc
+
+
+def open_image_data_batched(
+    x_map: int,
+    y_map: int,
+    x: int,
+    y: int,
+    data_files: list[str],
+    qa_files: list[str],
+    lc_file: str | None,
+    data_type: str,
+    p_a,
+    layer: int,
+    batch_size: int = 32,
+    s3_opts: dict | None = None,  # kept for API compatibility, but NOT used
+):
+    """
+    Read VI, QA, and LC blocks by opening datasets in small batches.
+
+    IMPORTANT:
+    - Do NOT use rasterio.Env(AWS_...) in this environment (blocked).
+    - For S3/S3-compatible, pass presigned HTTPS URLs in data_files/qa_files/lc_file.
+    """
+
+    z = len(data_files)
+    if qa_files and len(qa_files) != z:
+        raise ValueError(f"qa_files length ({len(qa_files)}) must match data_files length ({z})")
+
+    vi = np.empty((y, x, z), order="F", dtype=data_type)
+    qa = np.empty((y, x, z), order="F", dtype=data_type)
+    lc = np.empty((y, x), order="F", dtype=np.uint8)
+
+    win = Window(x_map, y_map, x, y)
+    def _read_stack(paths: list[str], out_arr: np.ndarray, band: int):
+        for j0 in range(0, z, batch_size):
+            j1 = min(z, j0 + batch_size)
+            dss = [rasterio.open(p, "r") for p in paths[j0:j1]]
+            try:
+                for k, ds in enumerate(dss):
+                    ds.read(band, window=win, out=out_arr[:, :, j0 + k])
+            finally:
+                for ds in dss:
+                    try:
+                        ds.close()
+                    except Exception:
+                        pass
+
+    # 1) VI
+    _read_stack(data_files, vi, band=layer)
+
+    # 2) QA
+    if not qa_files:
+        qa.fill(1)
+    else:
+        # QA is usually band 1; change if your QA files differ
+        _read_stack(qa_files, qa, band=1)
+        qa = assign_qa_weight(p_a, qa)
+
+    # 3) LC
+    if not lc_file:
+        lc.fill(1)
+    else:
+        with rasterio.open(lc_file, "r") as ds:
+            ds.read(1, window=win, out=lc)
+        if lc.dtype != np.uint8:
+            lc[:] = lc.astype(np.uint8, copy=False)
+
+    return vi, qa, lc
+

timesat_cli/writers.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import copy
+
+import numpy as np
+import rasterio
+from rasterio.windows import Window
+
+__all__ = ["prepare_profiles", "write_layers"]
+
+
+def prepare_profiles(img_profile, p_nodata: float, scale: float, offset: float):
+    img_profile_st = copy.deepcopy(img_profile)
+    img_profile_st.update(compress="lzw")
+    if scale != 1 or offset != 0:
+        img_profile_st.update(dtype=rasterio.float32)
+
+    img_profile_vpp = copy.deepcopy(img_profile)
+    img_profile_vpp.update(nodata=p_nodata, dtype=rasterio.float32, compress="lzw")
+
+    img_profile_qa = copy.deepcopy(img_profile)
+    img_profile_qa.update(nodata=0, dtype=rasterio.uint8, compress="lzw")
+
+    img_profile_ns = copy.deepcopy(img_profile)
+    img_profile_ns.update(nodata=255, dtype=rasterio.uint8, compress="lzw")
+
+    return img_profile_st, img_profile_vpp, img_profile_qa, img_profile_ns
+
+
+def write_layers(
+    datasets: list[rasterio.io.DatasetWriter],
+    arrays: np.ndarray,
+    window: tuple[int, int, int, int],
+) -> None:
+    """
+    Write a block (window) for each array into the corresponding open dataset.
+
+    datasets : list of open rasterio DatasetWriter objects
+    arrays   : np.ndarray with shape (n_layers, y, x) or iterable of 2D arrays
+    window   : (x_map, y_map, x, y)
+    """
+    x_map, y_map, x, y = window
+    win = Window(x_map, y_map, x, y)
+
+    for i, arr in enumerate(arrays, 1):
+        dst = datasets[i - 1]
+        dst.write(arr, window=win, indexes=1)

timesat_cli-1.4.3.dist-info/METADATA

@@ -0,0 +1,199 @@
+Metadata-Version: 2.4
+Name: timesat-cli
+Version: 1.4.3
+Summary: Python-based command line interface for TIMESAT
+Author: Zhanzhang Cai
+License: GPL-3.0-only
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.10
+Requires-Dist: boto3
+Requires-Dist: dotenv
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: rasterio
+Requires-Dist: timesat>=4.1.19
+Description-Content-Type: text/markdown
+
+# TIMESAT CLI
+
+`TIMESAT CLI` is a command line interface and workflow manager for the [TIMESAT](https://pypi.org/project/timesat/) package. 
+It provides a convenient way to configure and execute TIMESAT processing pipelines directly from the command line or automated scripts. 
+
+---
+
+## Requirements
+
+Before you begin, make sure you have:
+
+- **Miniconda** or **Anaconda** (for environment management)  
+  Download: [https://docs.conda.io/en/latest/miniconda.html](https://docs.conda.io/en/latest/miniconda.html)
+- **Python 3.10+**
+
+---
+
+## Installation
+
+`timesat-cli` is available on **PyPI** and can be installed using **pip** or **uv**.  
+Although it is not published on Conda, you can safely install it *inside* a Conda environment.
+
+### Option 1 — Install inside a Conda environment
+
+```bash
+conda create -n timesat-cli python=3.12
+conda activate timesat-cli
+pip install timesat-cli
+```
+
+> This approach uses Conda only for environment isolation.  
+> The installation itself is handled by pip, which will automatically install `timesat` and all required dependencies.
+
+---
+
+### Option 2 — Install via uv (recommended for pure Python environments)
+
+[`uv`](https://github.com/astral-sh/uv) is a modern, high-performance alternative to pip and venv.
+
+1. Install `uv`:
+
+   ```bash
+   pip install uv
+   # or
+   curl -LsSf https://astral.sh/uv/install.sh | sh
+   ```
+
+2. Create a virtual environment and install the package:
+
+   ```bash
+   uv venv .venv
+   source .venv/bin/activate
+   uv pip install timesat-cli
+   ```
+
+> `uv` provides faster dependency resolution and caching.  
+> It will automatically install `timesat` and related dependencies.
+
+---
+
+### Option 3 — Direct installation with pip
+
+If you already have Python 3.10+ installed:
+
+```bash
+pip install timesat-cli
+```
+
+---
+
+
+## Running the Application
+
+After installation, start the GUI with:
+
+```bash
+timesat-cli path/to/settings.json
+```
+
+or equivalently:
+
+```bash
+python -m timesat_cli path/to/settings.json
+```
+
+---
+
+## Advanced Usage
+
+If you wish to customize or extend the workflow, you can also run or modify the main script directly:
+
+```bash
+python timesat_run.py
+```
+
+The file 'timesat_run.py' contains the full example pipeline that invokes core modules from the 'timesat_cli' package, including configuration loading, file management, TIMESAT processing, and output writing.
+
+---
+
+## HRVPP Notes — QFLAG2 weights
+If you work with HRVPP quality flags (`QFLAG2`), the following weights `w` are commonly applied:
+
+| QFLAG2 value | Weight `w` |
+|---:|---:|
+| 1     | 1.0 |
+| 4097  | 1.0 |
+| 8193  | 1.0 |
+| 12289 | 1.0 |
+| 1025  | 0.5 |
+| 9217  | 0.5 |
+| 2049  | 0.5 |
+| 6145  | 0.5 |
+| 3073  | 0.5 |
+
+Example (settings.json):
+
+```python
+"p_a": {
+  "value": [
+    [1, 1.0],
+    [4097, 1.0],
+    [8193, 1.0],
+    [12289, 1.0],
+    [1025, 0.5],
+    [9217, 0.5],
+    [2049, 0.5],
+    [6145, 0.5],
+    [3073, 0.5]
+  ],
+  "description": "QA weighting rules. Leave empty [] to keep original QA values. Use [qa_value, weight] for exact matches or [min, max, weight] for ranges."
+}
+```
+
+---
+
+## License
+
+**TIMESAT-CLI** is released under the **GNU General Public License (GPL)**.  
+You are free to use, modify, and distribute this software under the terms of the GPL.
+
+The GPL license applies **only to the TIMESAT-CLI source code and assets** provided in this repository.
+
+### 📦 Dependency Licenses
+
+- `timesat` may install additional open-source dependencies (e.g., Flask, pandas, NumPy).  
+- Each dependency retains its own license (MIT, BSD, Apache, etc.).  
+- Before redistributing or bundling this software, review the license terms of each dependency carefully.
+
+### ⚖️ Summary
+
+| Component        | License Type | Notes |
+|------------------|--------------|-------|
+| TIMESAT-CLI      | GPL v3       | Open source, modification and redistribution permitted under GPL. |
+| TIMESAT          | Proprietary  | All rights reserved. Redistribution and modification prohibited without written consent. |
+| Other Dependencies | Various (MIT/BSD/Apache) | Check individual package licenses before redistribution. |
+
+For detailed license information, refer to the license files distributed with each installed package.
+
+---
+
+## Citation
+
+If you use **TIMESAT**, **TIMESAT-CLI** or **TIMESAT-GUI** in your research, please cite the corresponding release on Zenodo:
+
+> Cai, Z., Eklundh, L., & Jönsson, P. (2025). *TIMESAT4:  is a software package for analysing time-series of satellite sensor data* (Version 4.1.x) [Computer software]. Zenodo.   
+> [https://doi.org/10.5281/zenodo.17369757](https://doi.org/10.5281/zenodo.17369757)
+
+---
+
+## Acknowledgments
+
+- [TIMESAT](https://www.nateko.lu.se/TIMESAT) — Original analysis framework for satellite time-series data.  
+- This project acknowledges the Swedish National Space Agency (SNSA), the European Environment Agency (EEA), and the European Space Agency (ESA) for their support and for providing access to satellite data and related resources that made this software possible.
+
+---
+