timesat-cli 1.0.0__tar.gz → 1.3.1__tar.gz

{timesat_cli-1.0.0 → timesat_cli-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: timesat-cli
-Version: 1.0.0
+Version: 1.3.1
 Summary: Python-based command line interface for TIMESAT
 Author: Zhanzhang Cai
 License: GPL-3.0-only
@@ -16,9 +16,7 @@ Requires-Python: >=3.10
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: rasterio
-Requires-Dist: timesat
-Provides-Extra: parallel
-Requires-Dist: ray; extra == 'parallel'
+Requires-Dist: timesat>=4.1.11
 Description-Content-Type: text/markdown
 
 # TIMESAT CLI
@@ -91,19 +89,6 @@ pip install timesat-cli
 
 ---
 
-## ⚙️ Optional: Parallel Processing Support
-
-`timesat-cli` provides an optional extra for **parallel execution** using [`ray`](https://www.ray.io/).
-
-To install with parallel-processing support:
-
-```bash
-pip install timesat-cli[parallel]
-```
-
-This installs the base package plus the ray dependency.
-
----
 
 ## Running the Application
 

{timesat_cli-1.0.0 → timesat_cli-1.3.1}/README.md

@@ -68,19 +68,6 @@ pip install timesat-cli
 
 ---
 
-## ⚙️ Optional: Parallel Processing Support
-
-`timesat-cli` provides an optional extra for **parallel execution** using [`ray`](https://www.ray.io/).
-
-To install with parallel-processing support:
-
-```bash
-pip install timesat-cli[parallel]
-```
-
-This installs the base package plus the ray dependency.
-
----
 
 ## Running the Application
 

{timesat_cli-1.0.0 → timesat_cli-1.3.1}/pyproject.toml

@@ -23,17 +23,12 @@ dependencies = [
   "numpy",
   "rasterio",
   "pandas",
-  "timesat",
+  "timesat>=4.1.11",
 ]
 
 [dependency-groups] 
 dev = ["pre-commit", "ruff", "matplotlib"]
 
-[project.optional-dependencies]
-parallel = [
-'ray',
-]
-
 [tool.hatch.version]
 source = "vcs"                                    # <-- tell Hatch to use Git tags
 

{timesat_cli-1.0.0 → timesat_cli-1.3.1}/src/timesat_cli/__init__.py

@@ -12,7 +12,7 @@ Email:
     zhanzhang.cai@nateko.lu.se
 """
 
-__version__ = "0.1.0"
+__version__ = "1.2.6"
 __all__ = ["run"]
 
 from .processing import run

timesat_cli-1.3.1/src/timesat_cli/__main__.py

@@ -0,0 +1,28 @@
+import os
+import json
+import argparse
+
+def main():
+    parser = argparse.ArgumentParser(description="Run TIMESAT processing pipeline.")
+    parser.add_argument("settings_json", help="Path to the JSON configuration file.")
+    args = parser.parse_args()
+
+    # read config first (pure Python)
+    with open(args.settings_json) as f:
+        s = json.load(f)
+
+    # thread control BEFORE heavy imports
+    threads = s.get("threads")
+    if threads:
+        threads = str(int(threads))
+        os.environ["OMP_NUM_THREADS"] = threads
+        os.environ.setdefault("OPENBLAS_NUM_THREADS", threads)
+        os.environ.setdefault("MKL_NUM_THREADS", threads)
+        os.environ.setdefault("NUMEXPR_NUM_THREADS", threads)
+
+    # late import of processing (safe)
+    from .processing import run
+    run(args.settings_json)
+
+if __name__ == "__main__":
+    main()

{timesat_cli-1.0.0 → timesat_cli-1.3.1}/src/timesat_cli/config.py

@@ -39,13 +39,12 @@ class Settings:
     p_outlier: int
     p_printflag: int
     max_memory_gb: float
-    para_check: int
-    ray_dir: str
     scale: float
     offset: float
     p_hrvppformat: int
     p_nclasses: int
     classes: List[ClassParams]
+    outputvariables: int
 
 
 @dataclass
@@ -104,11 +103,10 @@ def load_config(jsfile: str) -> Config:
         p_outlier=int(s["p_outlier"]["value"]),
         p_printflag=int(s["p_printflag"]["value"]),
         max_memory_gb=float(s["max_memory_gb"]["value"]),
-        para_check=int(s["para_check"]["value"]),
-        ray_dir=s["ray_dir"]["value"],
         scale=float(s["scale"]["value"]),
         offset=float(s["offset"]["value"]),
         p_hrvppformat=int(s["p_hrvppformat"]["value"]),
+        outputvariables=int(s["outputvariables"]["value"]),
         p_nclasses=nclasses,
         classes=classes,
     )

timesat_cli-1.3.1/src/timesat_cli/dateutils.py

@@ -0,0 +1,95 @@
+"""
+Utility functions for handling date operations in TIMESAT processing.
+"""
+
+from __future__ import annotations
+
+import datetime
+import numpy as np
+
+__all__ = ["date_with_ignored_day", "build_monthly_sample_indices"]
+
+
+def is_leap_year(y: int) -> bool:
+    """
+    Return True if year y is a Gregorian leap year, False otherwise.
+    """
+    return (y % 4 == 0 and y % 100 != 0) or (y % 400 == 0)
+
+
+def date_with_ignored_day(yrstart: int, i_tv: int, p_ignoreday: int) -> datetime.date:
+    """
+    Convert a synthetic TIMESAT time index (1-based, assuming 365 days/year)
+    into a real calendar date while skipping one day in leap years.
+    """
+
+    # ---- Step 1: synthetic 365-day calendar ----
+    i = int(i_tv)
+    year_offset, doy_365 = divmod(i - 1, 365)
+    doy_365 += 1
+    year = yrstart + year_offset
+
+    jan1 = datetime.date(year, 1, 1)
+
+    if is_leap_year(year):
+        if not (1 <= p_ignoreday <= 366):
+            raise ValueError("p_ignoreday must be in [1, 366] for leap years")
+
+        if p_ignoreday == 1:
+            real_ordinal = doy_365 + 1
+        elif p_ignoreday == 366:
+            real_ordinal = doy_365
+        else:
+            real_ordinal = doy_365 if doy_365 < p_ignoreday else doy_365 + 1
+    else:
+        real_ordinal = doy_365
+
+    return jan1 + datetime.timedelta(days=real_ordinal - 1)
+
+
+def build_monthly_sample_indices(yrstart: int, yr: int) -> np.ndarray:
+    """
+    Build a synthetic time index (1-based) for sampling the 1st, 11th, and 21st
+    of each month across multiple years.
+
+    The synthetic timeline always uses 365 days per year.
+    In leap years we:
+        - keep Feb 29
+        - drop Dec 31
+    so that each year still has 365 synthetic days.
+
+    Parameters
+    ----------
+    yrstart : int
+        Starting year of the period.
+
+    yr : int
+        Number of years to include.
+
+    Returns
+    -------
+    np.ndarray
+        A 1D array of indices into the synthetic timeline (1-based).
+    """
+
+    indices: list[int] = []
+    year_offset = 0  # offset of each synthetic year start (0, 365, 730, ...)
+
+    for year in range(yrstart, yrstart + yr):
+        if is_leap_year(year):
+            # Include Feb 29, drop Dec 31
+            days_in_month = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 30]
+        else:
+            days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
+        cum = 0  # cumulative day count within the current year
+
+        for dim in days_in_month:
+            for d in (1, 11, 21):
+                if d <= dim:
+                    indices.append(year_offset + cum + d)
+            cum += dim
+
+        year_offset += 365
+
+    return np.array(indices, dtype=int)

timesat_cli-1.3.1/src/timesat_cli/fsutils.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+import os
+import math
+
+__all__ = ["create_output_folders", "close_all"]
+
+
+def create_output_folders(outfolder: str) -> tuple[str, str]:
+    vpp_folder = os.path.join(outfolder, "VPP")
+    st_folder  = os.path.join(outfolder, "ST")
+    os.makedirs(vpp_folder, exist_ok=True)
+    os.makedirs(st_folder,  exist_ok=True)
+    return st_folder, vpp_folder
+
+
+def memory_plan(
+    dx: int,
+    dy: int,
+    z: int,
+    p_outindex_num: int,
+    yr: int,
+    max_memory_gb: float,
+) -> tuple[int, int]:
+    num_layers = (
+        2 * z                  # VI + QA
+        + 2 * p_outindex_num   # yfit + yfit QA
+        + 2 * 13 * 2 * yr      # VPP + VPP QA
+        + yr                   # nseason
+    )
+    
+    bytes_per = 4  # float32
+    safety = 0.8   # keep 60% margin for overhead
+    max_bytes = max_memory_gb * (2 ** 30) * safety
+
+    dy_max = max_bytes / (dx * num_layers * bytes_per) if num_layers > 0 else dy
+    y_slice_size = int(min(math.floor(dy_max), dy)) if dy_max > 0 else dy
+    y_slice_size = max(1, y_slice_size)
+    num_block = int(math.ceil(dy / y_slice_size))
+    return y_slice_size, num_block
+
+
+def close_all(*items):
+    """
+    Close datasets or other objects that have a .close() method.
+    Accepts individual objects and iterables (lists/tuples/etc).
+    Ignores None safely.
+    """
+    for obj in items:
+        if obj is None:
+            continue
+
+        # If it's an iterable of objects (e.g. list of datasets)
+        if isinstance(obj, (list, tuple, set)):
+            for x in obj:
+                if x is None:
+                    continue
+                close = getattr(x, "close", None)
+                if callable(close):
+                    close()
+        else:
+            # Single object
+            close = getattr(obj, "close", None)
+            if callable(close):
+                close()

timesat_cli-1.3.1/src/timesat_cli/processing.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+import math, os, datetime
+
+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, build_monthly_sample_indices
+
+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
+
+
+def run(jsfile: str) -> None:
+
+    import numpy as np
+    import rasterio
+    import timesat  # external dependency
+
+    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)
+
+    if int(s.p_st_timestep)>0:
+        p_outindex = np.arange(1, yr * 365 + 1)[:: int(s.p_st_timestep)]
+    elif int(s.p_st_timestep)<0:
+        p_outindex = build_monthly_sample_indices(yrstart, yr)
+    elif int(s.p_st_timestep)==0:
+        p_outindex = np.arange(1, yr * 365 + 1)[:: int(9999)]
+    p_outindex_num = len(p_outindex)
+
+    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])
+
+    st_folder, vpp_folder = create_output_folders(s.outputfolder)
+
+    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 memory 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))
+
+    s3_opts = getattr(s, "s3", None)
+
+    if s3_opts:
+        # Open all files inside a single S3 environment
+        with rasterio.Env(**s3_opts):
+            data_datasets = [rasterio.open(p, "r") for p in flist]
+            qa_datasets   = [rasterio.open(p, "r") for p in qlist] if qlist else []
+            lc_dataset    = rasterio.open(s.lc_file, "r") if s.lc_file else None
+    else:
+        # Local files
+        data_datasets = [rasterio.open(p, "r") for p in flist]
+        qa_datasets   = [rasterio.open(p, "r") for p in qlist] if qlist else []
+        lc_dataset    = rasterio.open(s.lc_file, "r") if s.lc_file else None
+
+    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(
+            x_map, y_map, x, y,
+            data_datasets,
+            qa_datasets,
+            lc_dataset,
+            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)
+
+        if s.scale == 1 and s.offset == 0:
+            yfit = np.moveaxis(yfit, -1, 0).astype(img_profile['dtype'])
+        else:
+            yfit = np.moveaxis(yfit, -1, 0).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(
+        data_datasets,
+        qa_datasets,
+        lc_dataset,
+        st_datasets,
+        stqa_datasets,
+    )
+
+    if s.outputvariables == 1:
+        close_all(
+            vpp_datasets,
+            vppqa_datasets,
+            ns_dataset,
+        )
+
+    

timesat_cli-1.3.1/src/timesat_cli/readers.py

@@ -0,0 +1,159 @@
+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"]
+
+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_datasets: list,
+    qa_datasets: list,
+    lc_dataset,
+    data_type: str,
+    p_a,
+    layer: int,
+):
+    """
+    Read VI, QA, and LC blocks using already-open rasterio datasets.
+    This is fast because we do NOT call rasterio.open() for each block.
+    """
+
+    z = len(data_datasets)
+
+    # allocate arrays
+    vi = np.ndarray((y, x, z), order="F", dtype=data_type)
+    qa = np.ndarray((y, x, z), order="F", dtype=data_type)
+    lc = np.ndarray((y, x), order="F", dtype=np.uint8)
+
+    win = Window(x_map, y_map, x, y)
+
+    # -----------------------------------------------------------
+    # 1) Read VI stack
+    # -----------------------------------------------------------
+    for i, ds in enumerate(data_datasets):
+        arr = ds.read(layer, window=win)
+        if arr.ndim == 3:
+            arr = arr[0, :, :]
+        vi[:, :, i] = arr
+
+    # -----------------------------------------------------------
+    # 2) Read QA stack (or fill with ones)
+    # -----------------------------------------------------------
+    if len(qa_datasets) == 0:
+        qa[:] = 1
+    else:
+        for i, ds in enumerate(qa_datasets):
+            arr = ds.read(layer, window=win)
+            if arr.ndim == 3:
+                arr = arr[0, :, :]
+            qa[:, :, i] = arr
+
+        # Weight QA
+        from .qa import assign_qa_weight
+        qa = assign_qa_weight(p_a, qa)
+
+    # -----------------------------------------------------------
+    # 3) Land cover (single layer)
+    # -----------------------------------------------------------
+    if lc_dataset is None:
+        lc[:] = 1
+    else:
+        arr = lc_dataset.read(1, window=win)
+        if arr.ndim == 3:
+            arr = arr[0, :, :]
+        lc[:, :] = arr.astype(np.uint8)
+
+    return vi, qa, lc
+

timesat_cli-1.3.1/src/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.0.0/src/timesat_cli/__main__.py

@@ -1,12 +0,0 @@
-# src/timesat_cli/__main__.py
-import argparse
-from .processing import run
-
-def main():
-    parser = argparse.ArgumentParser(description="Run TIMESAT processing pipeline.")
-    parser.add_argument("settings_json", help="Path to the JSON configuration file.")
-    args = parser.parse_args()
-    run(args.settings_json)
-
-if __name__ == "__main__":
-    main()

timesat_cli-1.0.0/src/timesat_cli/fsutils.py

@@ -1,25 +0,0 @@
-from __future__ import annotations
-import os
-import math
-from typing import Tuple
-
-__all__ = ["create_output_folders"]
-
-
-def create_output_folders(outfolder: str) -> Tuple[str, str]:
-    vpp_folder = os.path.join(outfolder, "VPP")
-    st_folder  = os.path.join(outfolder, "ST")
-    os.makedirs(vpp_folder, exist_ok=True)
-    os.makedirs(st_folder,  exist_ok=True)
-    return st_folder, vpp_folder
-
-
-def memory_plan(dx: int, dy: int, z: int, p_outindex_num: int, yr: int, max_memory_gb: float) -> Tuple[int, int]:
-    num_layers = p_outindex_num + z * 2 + (13 * 2) * yr
-    bytes_per = 4  # float32
-    max_bytes = max_memory_gb * (2 ** 30)
-    dy_max = max_bytes / (dx * num_layers * bytes_per)
-    y_slice_size = int(min(math.floor(dy_max), dy)) if dy_max > 0 else dy
-    y_slice_size = max(1, y_slice_size)
-    num_block = int(math.ceil(dy / y_slice_size))
-    return y_slice_size, num_block

timesat_cli-1.0.0/src/timesat_cli/parallel.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-__all__ = ["maybe_init_ray"]
-
-
-def maybe_init_ray(para_check: int, ray_dir: str | None = None) -> bool:
-    """
-    Initialize Ray if parallelism is requested.
-
-    Parameters
-    ----------
-    para_check : int
-        Number of CPUs to use (if >1, Ray will be initialized).
-    ray_dir : str or None, optional
-        Temporary directory for Ray logs/state. If None or empty,
-        Ray will use its default temp location.
-
-    Returns
-    -------
-    bool
-        True if Ray was initialized, False otherwise.
-    """
-    if para_check > 1:
-        import ray
-        kwargs = {"num_cpus": para_check}
-        if ray_dir:  # only include if user provided a valid path
-            kwargs["_temp_dir"] = ray_dir
-
-        ray.init(**kwargs)
-        return True
-
-    return False

timesat_cli-1.0.0/src/timesat_cli/processing.py

@@ -1,167 +0,0 @@
-from __future__ import annotations
-import math, os, datetime
-from typing import List, Tuple
-
-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
-from .writers import prepare_profiles, write_vpp_layers, write_st_layers
-from .parallel import maybe_init_ray
-
-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):
-    outyfitfn = []
-    for i_tv in p_outindex:
-        yfitdate = datetime.date(yrstart, 1, 1) + datetime.timedelta(days=int(i_tv)) - datetime.timedelta(days=1)
-        outyfitfn.append(os.path.join(st_folder, f"TIMESAT_{yfitdate.strftime('%Y%m%d')}.tif"))
-
-    outvppfn = []
-    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"))
-    outnsfn = os.path.join(vpp_folder, 'TIMESAT_nsperyear.tif')
-    return outyfitfn, outvppfn, outnsfn
-
-
-def run(jsfile: str) -> None:
-    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')
-
-    ray_inited = maybe_init_ray(s.para_check, s.ray_dir)
-
-    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)
-
-    p_outindex = np.arange(
-        (datetime.datetime(yrstart, 1, 1) - datetime.datetime(yrstart, 1, 1)).days + 1,
-        (datetime.datetime(yrstart + yr - 1, 12, 31) - datetime.datetime(yrstart, 1, 1)).days + 1
-    )[:: int(s.p_st_timestep)]
-    p_outindex_num = len(p_outindex)
-
-    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])
-
-    imgprocessing = not (s.imwindow[2] + s.imwindow[3] == 2)
-
-    if imgprocessing:
-        st_folder, vpp_folder = create_output_folders(s.outputfolder)
-        outyfitfn, outvppfn, outnsfn = _build_output_filenames(st_folder, vpp_folder, p_outindex, yrstart, yrend)
-        img_profile_st, img_profile_vpp, img_profile_ns = prepare_profiles(img_profile, s.p_nodata, s.scale, s.offset)
-        # pre-create files
-        for path in outvppfn:
-            with rasterio.open(path, 'w', **img_profile_vpp):
-                pass
-        for path in outyfitfn:
-            with rasterio.open(path, 'w', **img_profile_st):
-                pass
-
-    # compute memory 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(
-            x_map, y_map, x, y, flist, qlist if qlist else '', s.lc_file,
-            img_profile['dtype'], s.p_a, s.para_check, 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
-
-        if s.para_check > 1 and ray_inited:
-            import ray
-
-            @ray.remote
-            def runtimesat(vi_temp, qa_temp, lc_temp):
-                vpp_para, vppqa, nseason_para, yfit_para, yfitqa, seasonfit, tseq = timesat.tsf2py(
-                    yr, vi_temp, qa_temp, timevector, lc_temp, 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,
-                    1, x, len(flist), p_outindex_num
-                )
-                vpp_para = vpp_para[0, :, :]
-                yfit_para = yfit_para[0, :, :]
-                nseason_para = nseason_para[0, :]
-                return vpp_para, yfit_para, nseason_para
-
-            futures = [
-                runtimesat.remote(
-                    np.expand_dims(vi[i, :, :], axis=0),
-                    np.expand_dims(qa[i, :, :], axis=0),
-                    np.expand_dims(lc[i, :], axis=0)
-                ) for i in range(y)
-            ]
-            results = ray.get(futures)
-            vpp = np.stack([r[0] for r in results], axis=0)
-            yfit = np.stack([r[1] for r in results], axis=0)
-            nseason = np.stack([r[2] for r in results], axis=0)
-        else:
-            vpp, vppqa, nseason, yfit, yfitqa, seasonfit, tseq = timesat.tsf2py(
-                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,
-                y, x, len(flist), p_outindex_num)
-
-        vpp  = np.moveaxis(vpp, -1, 0)
-        if s.scale == 0 and s.offset == 0:
-            yfit = np.moveaxis(yfit, -1, 0).astype(img_profile['dtype'])
-        else:
-            yfit = np.moveaxis(yfit, -1, 0).astype('float32')
-
-        print('--- start writing geotif ---  starttime: ' + str(datetime.datetime.now()))
-        window = (x_map, y_map, x, y)
-        write_vpp_layers(outvppfn, vpp, window, img_profile_vpp)
-        write_st_layers(outyfitfn, yfit, window, img_profile_st)
-
-        print(f'Block: {iblock + 1}/{num_block}  finishedtime: {datetime.datetime.now()}')

timesat_cli-1.0.0/src/timesat_cli/readers.py

@@ -1,204 +0,0 @@
-from __future__ import annotations
-
-import datetime
-import os
-import re
-from typing import List, Tuple
-
-import numpy as np
-import rasterio
-from rasterio.windows import Window
-
-from .qa import assign_qa_weight
-
-try:
-    import ray
-except Exception:  # optional
-    ray = None
-
-__all__ = ["read_file_lists", "open_image_data"]
-
-
-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,
-    yflist: List[str],
-    wflist: List[str] | str,
-    lcfile: str,
-    data_type: str,
-    p_a,
-    para_check: int,
-    layer: int,
-    s3: dict | None = None,
-):
-    """Read VI, QA, and LC blocks as arrays."""
-    z = len(yflist)
-    vi = np.ndarray((y, x, z), order="F", dtype=data_type)
-    qa = np.ndarray((y, x, z), order="F", dtype=data_type)
-    lc = np.ndarray((y, x, z), order="F", dtype=np.uint8)
-
-    # VI stack
-    if para_check > 1 and ray is not None:
-        vi_para = np.ndarray((y, x), order="F", dtype=data_type)
-
-        @ray.remote
-        def _readimgpara_(yfname, s3=s3):
-            if s3 is not None:
-                with rasterio.Env(**s3):
-                    with rasterio.open(yfname, "r") as temp:
-                        vi_para[:, :] = temp.read(
-                            layer, window=Window(x_map, y_map, x, y)
-                        )
-            else:
-                with rasterio.open(yfname, "r") as temp:
-                    vi_para[:, :] = temp.read(layer, window=Window(x_map, y_map, x, y))
-            return vi_para
-
-        futures = [_readimgpara_.remote(i) for i in yflist]
-        vi = np.stack(ray.get(futures), axis=2)
-    else:
-        for i, yfname in enumerate(yflist):
-            if s3 is not None:
-                with rasterio.Env(**s3):
-                    with rasterio.open(yfname, "r") as temp:
-                        vi[:, :, i] = temp.read(
-                            layer, window=Window(x_map, y_map, x, y)
-                        )
-            else:
-                with rasterio.open(yfname, "r") as temp:
-                    vi[:, :, i] = temp.read(layer, window=Window(x_map, y_map, x, y))
-
-    # QA stack
-    if wflist == "" or wflist == []:
-        qa = np.ones((y, x, z))
-    else:
-        if para_check > 1 and ray is not None:
-            qa_para = np.ndarray((y, x), order="F", dtype=data_type)
-
-            @ray.remote
-            def _readqapara_(wfname, s3=s3):
-                if s3 is not None:
-                    with rasterio.Env(**s3):
-                        with rasterio.open(wfname, "r") as temp:
-                            qa_para[:, :] = temp.read(
-                                layer, window=Window(x_map, y_map, x, y)
-                            )
-                else:
-                    with rasterio.open(wfname, "r") as temp:
-                        qa_para[:, :] = temp.read(
-                            layer, window=Window(x_map, y_map, x, y)
-                        )
-                return qa_para
-
-            futures = [_readqapara_.remote(i) for i in wflist]
-            qa = np.stack(ray.get(futures), axis=2)
-        else:
-            for i, wfname in enumerate(wflist):
-                if s3 is not None:
-                    with rasterio.Env(**s3):
-                        with rasterio.open(wfname, "r") as temp2:
-                            qa[:, :, i] = temp2.read(
-                                1, window=Window(x_map, y_map, x, y)
-                            )
-                else:
-                    with rasterio.open(wfname, "r") as temp2:
-                        qa[:, :, i] = temp2.read(1, window=Window(x_map, y_map, x, y))
-        qa = assign_qa_weight(p_a, qa)
-
-    # LC
-    if lcfile == "":
-        lc = np.ones((y, x))
-    else:
-        if s3 is not None:
-            with rasterio.Env(**s3):
-                with rasterio.open(lcfile, "r") as temp3:
-                    lc = temp3.read(1, window=Window(x_map, y_map, x, y))
-        else:
-            with rasterio.open(lcfile, "r") as temp3:
-                lc = temp3.read(1, window=Window(x_map, y_map, x, y))
-
-    return vi, qa, lc

timesat_cli-1.0.0/src/timesat_cli/writers.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-from typing import List, Tuple
-import rasterio
-from rasterio.windows import Window
-
-__all__ = ["prepare_profiles", "write_vpp_layers", "write_st_layers"]
-
-
-def prepare_profiles(img_profile, p_nodata: float, scale: float, offset: float):
-    import copy
-    img_profile_st = copy.deepcopy(img_profile)
-    img_profile_st.update(compress='lzw')
-    if scale != 0 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_ns = copy.deepcopy(img_profile)
-    img_profile_ns.update(nodata=255, compress='lzw')
-    return img_profile_st, img_profile_vpp, img_profile_ns
-
-
-def write_vpp_layers(paths: List[str], arrays, window: Tuple[int, int, int, int], img_profile_vpp):
-    x_map, y_map, x, y = window
-    for i, arr in enumerate(arrays, 1):
-        with rasterio.open(paths[i - 1], 'r+', **img_profile_vpp) as outvppfile:
-            outvppfile.write(arr, window=Window(x_map, y_map, x, y), indexes=1)
-
-
-def write_st_layers(paths: List[str], arrays, window: Tuple[int, int, int, int], img_profile_st):
-    x_map, y_map, x, y = window
-    for i, arr in enumerate(arrays, 1):
-        with rasterio.open(paths[i - 1], 'r+', **img_profile_st) as outstfile:
-            outstfile.write(arr, window=Window(x_map, y_map, x, y), indexes=1)