timesat-cli 0.0.0__py3-none-any.whl

timesat_cli/__init__.py

@@ -0,0 +1,18 @@
+"""TIMESAT Runner package.
+
+This package provides a Python interface and CLI wrapper for running TIMESAT
+processing pipelines.
+
+Authors:
+    Zhanzhang Cai (Lund University)
+    Lars Eklundh (Lund University)
+    Per Jönsson (Malmö University)
+
+Email:
+    zhanzhang.cai@nateko.lu.se
+"""
+
+__version__ = "0.1.0"
+__all__ = ["run"]
+
+from .processing import run

timesat_cli/__main__.py

@@ -0,0 +1,12 @@
+# 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/config.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+import json
+from dataclasses import dataclass
+from typing import List, Sequence, Tuple
+import numpy as np
+
+
+@dataclass
+class ClassParams:
+    landuse: int
+    p_fitmethod: int
+    p_smooth: float
+    p_nenvi: int
+    p_wfactnum: float
+    p_startmethod: int
+    p_startcutoff: Tuple[float, float]
+    p_low_percentile: float
+    p_fillbase: int
+    p_seasonmethod: int
+    p_seapar: float
+
+
+@dataclass
+class Settings:
+    image_file_list: str
+    quality_file_list: str
+    tv_list: str
+    lc_file: str
+    outputfolder: str
+    imwindow: Sequence[int]
+
+    p_band_id: int
+    p_ignoreday: int
+    p_ylu: np.ndarray
+    p_a: List[List[float]]
+    p_st_timestep: int
+    p_nodata: float
+    p_davailwin: int
+    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]
+
+
+@dataclass
+class Config:
+    settings: Settings
+
+
+def _as_array(value, dtype=float, fortran=False):
+    arr = np.array(value, dtype=dtype)
+    if fortran:
+        arr = np.asfortranarray(arr)
+    return arr
+
+
+def load_config(jsfile: str) -> Config:
+    with open(jsfile, "r") as f:
+        data = json.load(f)
+
+    s = data["settings"]
+    nclasses = int(s["p_nclasses"]["value"])
+
+    classes: List[ClassParams] = []
+    for i in range(nclasses):
+        k = f"class{i+1}"
+        c = data[k]
+        classes.append(
+            ClassParams(
+                landuse=int(c["landuse"]["value"]),
+                p_fitmethod=int(c["p_fitmethod"]["value"]),
+                p_smooth=float(_as_array(c["p_smooth"]["value"], dtype="double")),
+                p_nenvi=int(c["p_nenvi"]["value"]),
+                p_wfactnum=float(_as_array(c["p_wfactnum"]["value"], dtype="double")),
+                p_startmethod=int(c["p_startmethod"]["value"]),
+                p_startcutoff=tuple(_as_array(c["p_startcutoff"]["value"], dtype="double", fortran=True)),
+                p_low_percentile=float(_as_array(c["p_low_percentile"]["value"], dtype="double")),
+                p_fillbase=int(c["p_fillbase"]["value"]),
+                p_seasonmethod=int(c["p_seasonmethod"]["value"]),
+                p_seapar=float(_as_array(c["p_seapar"]["value"], dtype="double")),
+            )
+        )
+
+    settings = Settings(
+        image_file_list=s["image_file_list"]["value"],
+        quality_file_list=s["quality_file_list"]["value"],
+        tv_list=s["tv_list"]["value"],
+        lc_file=s["lc_file"]["value"],
+        outputfolder=s["outputfolder"]["value"],
+        imwindow=s["imwindow"]["value"],
+        p_band_id=int(s["p_band_id"]["value"]),
+        p_ignoreday=int(s["p_ignoreday"]["value"]),
+        p_ylu=_as_array(s["p_ylu"]["value"], dtype="double", fortran=True),
+        p_a=s["p_a"]["value"],
+        p_st_timestep=int(s["p_st_timestep"]["value"]),
+        p_nodata=float(s["p_nodata"]["value"]),
+        p_davailwin=int(s["p_davailwin"]["value"]),
+        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"]),
+        p_nclasses=nclasses,
+        classes=classes,
+    )
+
+    return Config(settings=settings)
+
+
+def build_param_array(
+    s,
+    attr: str,
+    dtype,
+    size: int = 255,
+    shape: Tuple[int, ...] | None = None,
+    fortran_2d: bool = False
+):
+    """
+    Build a parameter array for TIMESAT class settings.
+
+    Parameters
+    ----------
+    s : object
+        Settings container with `classes` iterable.
+    attr : str
+        Attribute on each class object in `s.classes` (e.g., 'p_smooth').
+    dtype : numpy dtype or dtype string (e.g., 'uint8', 'double').
+    size : int
+        Length of the first dimension (TIMESAT expects 255).
+    shape : tuple[int, ...] | None
+        Extra trailing shape for per-class vectors (e.g., (2,) for p_startcutoff).
+    fortran_2d : bool
+        If True and `shape==(2,)`, allocate (size,2) with order='F' to mirror legacy layout.
+
+    Returns
+    -------
+    np.ndarray
+        Filled parameter array.
+    """
+    if shape is None:
+        arr = np.zeros(size, dtype=dtype)
+        for i, c in enumerate(s.classes):
+            arr[i] = getattr(c, attr)
+        return arr
+
+    full_shape = (size, *shape)
+    order = 'F' if fortran_2d and len(shape) == 1 and shape[0] > 1 else 'C'
+    arr = np.zeros(full_shape, dtype=dtype, order=order)
+    for i, c in enumerate(s.classes):
+        arr[i, ...] = getattr(c, attr)
+    return arr

timesat_cli/csvutils.py

@@ -0,0 +1,93 @@
+# csvutils.py
+from __future__ import annotations
+from typing import Tuple, Iterable, Optional
+import numpy as np
+import pandas as pd
+import datetime as dt
+
+__all__ = ["read_timeseries_csv", "write_timesat_csv_outputs"]
+
+def _parse_time_column(col: Iterable[str | int]) -> np.ndarray:
+    """
+    Accepts YYYYDOY (e.g., 2020123) or YYYYMMDD (e.g., 20200123) or ISO 'YYYY-MM-DD'.
+    Returns uint32 vector in YYYYDOY.
+    """
+    out = []
+    for v in col:
+        s = str(v)
+        if len(s) == 7:  # YYYYDOY
+            # will raise if invalid
+            dt.datetime.strptime(s, "%Y%j")
+            out.append(int(s))
+        elif len(s) == 8 and s.isdigit():  # YYYYMMDD
+            d = dt.datetime.strptime(s, "%Y%m%d")
+            out.append(int(f"{d.year}{d.timetuple().tm_yday:03d}"))
+        else:  # try ISO
+            try:
+                d = dt.datetime.strptime(s, "%Y-%m-%d")
+                out.append(int(f"{d.year}{d.timetuple().tm_yday:03d}"))
+            except Exception as e:
+                raise ValueError(f"Unrecognized date format: {s}") from e
+    return np.array(out, dtype="uint32")
+
+def read_timeseries_csv(path: str) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Read a per-site (single pixel) time series CSV.
+
+    Expected columns:
+      - 'time'      : YYYYDOY or YYYYMMDD or YYYY-MM-DD
+      - 'vi'        : vegetation index values (float)
+      - 'qa'        : optional; quality or weights (float/int). If missing, set to 1.
+      - 'lc'        : optional; land cover code (int). If missing, set to 1.
+
+    Returns:
+      vi  : array shaped (1, 1, T)
+      qa  : array shaped (1, 1, T)
+      timevector : 1-D uint32 YYYYDOY of length T
+    """
+    df = pd.read_csv(path)
+    if "time" not in df or "vi" not in df:
+        raise ValueError("CSV must contain at least 'time' and 'vi' columns.")
+    timevector = _parse_time_column(df["time"])
+    vi = df["vi"].to_numpy(dtype="float64")
+    qa = df["qa"].to_numpy(dtype="float64") if "qa" in df else np.ones_like(vi, dtype="float64")
+    # shape to (y=1, x=1, z=T)
+    vi = vi.reshape(1, 1, -1, order="F")
+    qa = qa.reshape(1, 1, -1, order="F")
+    return vi, qa, timevector
+
+def write_timesat_csv_outputs(
+    out_folder: str,
+    timevector_out: np.ndarray,   # p_outindex dates in YYYYDOY
+    yfit: np.ndarray,             # shape (T_out,) for single site
+    vpp: Optional[np.ndarray],    # shape (13*2*yr,) flattened for single site
+    nseason: Optional[int]
+) -> None:
+    """
+    Writes three CSVs:
+      - yfit.csv: columns [time(YYYYDOY), yfit]
+      - vpp.csv : 13*2*yr parameters as columns VPP_1 ... VPP_N (optional if vpp is None)
+      - nseason.csv: single row with nseason (optional if nseason is None)
+    """
+    import os
+    os.makedirs(out_folder, exist_ok=True)
+
+    # yfit
+    yfit_df = pd.DataFrame({
+        "time": timevector_out.astype("uint32"),
+        "yfit": yfit.astype("float64")
+    })
+    yfit_df.to_csv(os.path.join(out_folder, "yfit.csv"), index=False)
+
+    # vpp
+    if vpp is not None:
+        vpp = vpp.ravel(order="F").astype("float64")
+        cols = [f"VPP_{i+1}" for i in range(vpp.size)]
+        vpp_df = pd.DataFrame([vpp], columns=cols)
+        vpp_df.to_csv(os.path.join(out_folder, "vpp.csv"), index=False)
+
+    # nseason
+    if nseason is not None:
+        pd.DataFrame({"nseason": [int(nseason)]}).to_csv(
+            os.path.join(out_folder, "nseason.csv"), index=False
+        )

timesat_cli/fsutils.py

@@ -0,0 +1,25 @@
+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/parallel.py

@@ -0,0 +1,32 @@
+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/processing.py

@@ -0,0 +1,169 @@
+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')
+
+    print(landuse_arr)
+
+    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/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,154 @@
+from __future__ import annotations
+import os, re, math, datetime
+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,
+):
+    """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):
+            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):
+            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.fill(1)
+    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):
+                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):
+                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.fill(1)
+    else:
+        with rasterio.open(lcfile, 'r') as temp3:
+            lc = temp3.read(1, window=Window(x_map, y_map, x, y))
+
+    return vi, qa, lc