ECOv003-L2T-STARS 1.0.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

ECOv003_L2T_STARS/VNP43NRT_jl/Project.toml

@@ -0,0 +1,15 @@
+name = "VNP43NRT"
+uuid = "ebab2807-db99-43b5-90ec-49665e98c321"
+authors = ["Gregory Halverson <gregory.h.halverson@jpl.nasa.gov>"]
+version = "0.1.0"
+
+[deps]
+ArchGDAL = "c9ce4bd3-c3d5-55b8-8973-c0e20141b8c3"
+Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+DimensionalData = "0703355e-b756-11e9-17c0-8b28908087d0"
+GDAL = "add2ef01-049f-52c4-9ee2-e494f65e021a"
+Glob = "c27321d9-0574-5035-807b-f59d2c89b15c"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca"
+Rasters = "a3a2b9e3-a471-40c9-b274-f788e487c689"
+Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"

ECOv003_L2T_STARS/VNP43NRT_jl/instantiate.jl

@@ -0,0 +1,25 @@
+using Pkg
+Pkg.activate(".")
+
+if haskey(ENV, "CONDA_PREFIX")
+    try
+        run(pipeline(`curl "https://raw.githubusercontent.com/JuliaLang/MbedTLS.jl/master/src/cacert.pem"`, stdout="$CONDA_PREFIX/share/julia/cert.pem"))
+    catch
+    end
+end
+
+try
+    run(pipeline(`curl "https://raw.githubusercontent.com/JuliaLang/MbedTLS.jl/master/src/cacert.pem"`, stdout="/opt/conda/share/julia/cert.pem"))
+catch
+end
+
+Pkg.add("IJulia")
+Pkg.build("IJulia")
+Pkg.add("HDF5")
+Pkg.build("HDF5")
+Pkg.add("CoordinateTransformations")
+Pkg.add(Pkg.PackageSpec(;name="DimensionalData",version="0.24.7"))
+Pkg.add(Pkg.PackageSpec(;name="Rasters",version="0.5.3"))
+Pkg.add(Pkg.PackageSpec(;name="GDAL",version="1.5.1"))
+Pkg.instantiate()
+Pkg.precompile()

ECOv003_L2T_STARS/VNP43NRT_jl/instantiate.py

@@ -0,0 +1,13 @@
+import subprocess
+from os.path import abspath, dirname
+
+directory = abspath(dirname(__file__))
+
+def main():
+    command = f'cd "{directory}" && julia instantiate.jl'
+    print(command)
+    # system(command)
+    subprocess.run(command, shell=True)
+
+if __name__ == "__main":
+    main()

ECOv003_L2T_STARS/VNP43NRT_jl/src/VNP43NRT.jl

@@ -0,0 +1,411 @@
+module VNP43NRT
+
+using Dates
+using LinearAlgebra
+using Statistics
+using Rasters
+using DimensionalData.Dimensions.LookupArrays
+using ProgressMeter
+
+SINUSOIDAL_CRS = WellKnownText("PROJCS[\"unknown\",GEOGCS[\"unknown\",DATUM[\"unknown\",SPHEROID[\"unknown\",6371007.181,0]],PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]]],PROJECTION[\"Sinusoidal\"],PARAMETER[\"longitude_of_center\",0],PARAMETER[\"false_easting\",0],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH]]")
+
+function sinusoidal_tile_dims(h::Int, v::Int, tile_width_cells::Int)::Tuple{X,Y}
+    # boundaries of sinusodial projection
+    GLOBE_UPPER_LEFT_X = -20015109.355798
+    GLOBE_UPPER_LEFT_Y = 10007554.677899
+    GLOBE_LOWER_RIGHT_X = 20015109.355798
+    GLOBE_LOWER_RIGHT_Y = -10007554.677899
+
+    # size across (width or height) of any equal-area sinusoidal tile
+    TILE_SIZE = 1111950.5197665554
+
+    # rows and columns of sinusoidal tile grid
+    TOTAL_ROWS = 18
+    TOTAL_COLUMNS = 36
+
+    cell_size = TILE_SIZE / tile_width_cells
+    tile_left_x = GLOBE_UPPER_LEFT_X + h * TILE_SIZE
+    tile_right_x = GLOBE_UPPER_LEFT_X + (h + 1) * TILE_SIZE - cell_size
+    tile_upper_y = GLOBE_LOWER_RIGHT_Y + (TOTAL_ROWS - v) * TILE_SIZE - cell_size
+    tile_lower_y = GLOBE_LOWER_RIGHT_Y + (TOTAL_ROWS - 1 - v) * TILE_SIZE
+    sampling = Intervals(Start())
+    x_dim = X(Projected(LinRange(tile_left_x, tile_right_x, tile_width_cells), order=ForwardOrdered(), span=Regular(cell_size), sampling=sampling, crs=SINUSOIDAL_CRS))
+    y_dim = Y(Projected(LinRange(tile_upper_y, tile_lower_y, tile_width_cells), order=ReverseOrdered(), span=Regular(-cell_size), sampling=sampling, crs=SINUSOIDAL_CRS))
+    dims = (x_dim, y_dim)
+
+    return dims
+end
+
+export sinusoidal_tile_dims
+
+struct BRDFParameters
+    brdf::AbstractMatrix
+    se::AbstractVector
+    R2::AbstractVector
+    uncert::AbstractArray{Float64,3}
+end
+
+function zenith_from_solarnoon_time(tm::Float64, lat::Float64, lon::Float64)
+    rad = π/180.0
+
+    Jd = tm/86400.0 + 2440587.5
+    Jc = (Jd - 2451545.0)/36525.0
+    L0 = mod((280.46646 + Jc * (36000.76983 + 0.0003032 * Jc)),360)
+    M = 357.52911 + Jc * (35999.05029 - 0.0001537 * Jc)
+    e = 0.016708634 - Jc * (4.2037e-05 + 1.267e-07 * Jc)
+    eqctr = sin(rad * M) * (1.914602 - Jc * (0.004817 + 1.4e-05 *
+        Jc)) + sin(rad * 2.0 * M) * (0.019993 - 0.000101 * Jc) +
+        sin(rad * 3.0 * M) * 0.000289
+    lambda0 = L0 + eqctr
+    omega = 125.04 - 1934.136 * Jc
+    lambda = lambda0 - 0.00569 - 0.00478 * sin(rad * omega)
+    seconds = 21.448 - Jc * (46.815 + Jc * (0.00059 - Jc * (0.001813)))
+    obliq0 = 23.0 + (26.0 + (seconds/60.0))/60.0
+    obliq = obliq0 + 0.00256 * cos(rad * omega)
+    y = tan(rad * obliq/2)^2
+    eqnTime = 4/rad * (y*sin(rad*2*L0) - 2*e*sin(rad*M) +
+        4*e*y*sin(rad*M)*cos(rad*2*L0) - y^2/2*sin(rad*4*L0) -
+        e^2*1.25*sin(rad*2*M))
+    solarDec = asin(sin(rad*obliq)*sin(rad*lambda))
+    sinSolarDec = sin(solarDec)
+    cosSolarDec = cos(solarDec)
+    solarTime = (mod(Jd-1/2,1)*1440+eqnTime)/4
+    hourAngle = solarTime+lon-180
+    cosZenith = sin(rad*lat)*sinSolarDec+cos(rad*lat)*cosSolarDec*cos(rad*hourAngle)
+
+    if cosZenith < -1
+        cosZenith=-1
+    end
+
+    if cosZenith > 1
+        cosZenith=1
+    end
+
+    return acos(cosZenith)/rad
+end
+
+function zenith_from_solarnoon_vec(tm::Vector{Float64}, lat::Vector{Float64}, lon::Vector{Float64})
+    n = length(tm)
+    szn = Vector{Float64}(undef, n)
+    
+    for i in 1:n
+        szn[i] = zenith_from_solarnoon_time(tm[i], lat[i], lon[i])
+    end
+
+    return szn
+end
+
+function Kvol(sz::Matrix, vz::Matrix, rz::Matrix)::Matrix
+    sc = π / 180
+    eps = acos.(cos.(sc .* sz) .* cos.(sc .* vz) .+ sin.(sc .* sz) .* sin.(sc .* vz) .* cos.(sc .* rz))
+    Kvol = 1 ./ (cos.(sc .* sz) .+ cos.(sc .* vz)) .* ((π / 2 .- eps) .* cos.(eps) .+ sin.(eps)) .- π / 4
+
+    return Kvol
+end
+
+function Kvol_vec(sz::AbstractVector, vz::AbstractVector, rz::AbstractVector)
+    sc = pi/180
+    eps = acos.(cos.(sc .* sz) .* cos.(sc .* vz) .+ sin.(sc .* sz) .* sin.(sc .* vz) .* cos.(sc .* rz))
+    Kvol_vec = 1 ./ (cos.(sc .* sz) .+ cos.(sc .* vz)) .* ((pi/2 .- eps) .* cos.(eps) .+ sin.(eps)) .- pi/4
+
+    return Kvol_vec
+end
+
+function Kvol_sc(sz::Real, vz::Real, rz::Real)
+    sc = pi/180
+    eps = acos(cos(sc*sz)*cos(sc*vz) + sin(sc*sz)*sin(sc*vz)*cos(sc*rz))
+    Kvol_sc = 1/(cos(sc*sz) + cos(sc*vz))*((pi/2-eps)*cos(eps) + sin(eps)) - pi/4
+
+    return Kvol_sc
+end
+
+function Kgeo_sc(sz::Real, vz::Real, rz::Real)
+    sc = pi/180
+    eps = acos(cos(sc*sz)*cos(sc*vz) + sin(sc*sz)*sin(sc*vz)*cos(sc*rz))
+    D = sqrt(tan(sc*sz)^2 + tan(sc*vz)^2 - 2*tan(sc*sz)*tan(sc*vz)*cos(sc*rz))
+    cost = 2*sqrt(D^2 + (tan(sc*sz)*tan(sc*vz)*sin(sc*rz))^2)/(1/cos(sc*sz) + 1/cos(sc*vz))
+    cost = clamp(cost, -1.0, 1.0)
+    t = acos(cost)
+    O = 1/pi*(t-sin(t)*cos(t))*(1/cos(sc*sz) + 1/cos(sc*vz))
+    O = max(O, 0)
+    Kgeo_sc = O - 1/cos(sc*sz) - 1/cos(sc*vz) + 0.5*(1+cos(eps))/cos(sc*sz)/cos(sc*vz)
+
+    return Kgeo_sc
+end
+
+function Kgeo(sz::AbstractMatrix, vz::AbstractMatrix, rz::AbstractMatrix)
+    n, t = size(sz)
+    Kg = zeros(n, t)
+    for i in 1:n
+        for j in 1:t
+            Kg[i,j] = Kgeo_sc(sz[i,j], vz[i,j], rz[i,j])
+        end
+    end
+    return Kg
+end
+
+function Kgeo_vec(sz::AbstractVector, vz::AbstractVector, rz::AbstractVector)
+    t = length(vz)
+    Kg = zeros(t)
+    
+    for j in 1:t
+        Kg[j] = Kgeo_sc(sz[j], vz[j], rz[j])
+    end
+
+    return Kg
+end
+
+function NRT_BRDF(Y::AbstractMatrix, kv::AbstractMatrix, kg::AbstractMatrix, weighted::Bool, scale::Real)
+    n, p = size(Y)
+    brdf = fill(NaN, n, 3)
+    R2 = fill(NaN, n)
+    se = fill(NaN, n)
+    uncert = fill(NaN, 3, 3, n)
+
+    x = ones(3, p)
+    for i in 1:n
+        yt = Y[i,:]
+        non_missing = findall(isfinite.(yt))
+        nt = length(non_missing)
+
+        if nt < 7
+            continue
+        else
+            x[2,:] = kv[i,:]
+            x[3,:] = kg[i,:]
+
+            xt = x[:,non_missing]
+            ytt = yt[non_missing]
+
+            Si = inv(xt * xt')
+            brdf[i,:] = (Si * xt * ytt)'
+            yp = (brdf[i,:] * xt)'
+            uncert[:,:,i] = Si
+            se[i] = sqrt(sum((ytt - yp).^2)/(nt-3))
+            R2[i] = 1 - se[i]^2 * (nt-3) / var(ytt; corrected=true) / nt
+        end
+    end
+
+    return BRDFParameters(brdf, se, R2, uncert)
+end
+
+function NRT_BRDF_albedo(Y::AbstractMatrix, sz::AbstractMatrix, vz::AbstractMatrix, rz::AbstractMatrix, soz_noon::AbstractVector, weighted::Bool, scale::Real)
+    # RossThick constant
+    g0vol = -0.007574
+    g1vol = -0.070987
+    g2vol = 0.307588
+
+    # LiSparseR constant
+    g0geo = -1.284909
+    g1geo = -0.166314
+    g2geo = 0.041840
+
+    gwsa = [1.0, 0.189184, -1.377622]
+    gbsa = [1.0, 0.0, 0.0]
+
+    n, p = size(Y)
+    @info "reflectance n: $(n) p: $(p)"
+    results = fill(NaN, n, 7) # (wsa, bsa, wsa_se, bsa_se, rmse, R2, nt)
+    @info "results shape rows: $(size(results)[1]) cols: $(size(results)[2])"
+
+    x = ones(3, p)
+    for i in 1:n
+        yt = Y[i,:]
+        non_missing = findall(isfinite.(yt))
+        nt = length(non_missing)
+
+        if nt < 7
+            continue
+        else
+            sznrad = soz_noon[i] * pi/180
+            gbsa[2] = g0vol + g1vol * sznrad^2 + g2vol * sznrad^3
+            gbsa[3] = g0geo + g1geo * sznrad^2 + g2geo * sznrad^3
+
+            x[2,:] = Kvol_vec(sz[i,:], vz[i,:], rz[i,:])
+            x[3,:] = Kgeo_vec(sz[i,:], vz[i,:], rz[i,:])
+
+            xt = x[:,non_missing]
+            ytt = yt[non_missing]
+
+            if weighted
+                xx = exp.(-0.5 .* range(p-1, stop=0; length=p) ./ scale)
+                xxt = xx[non_missing]
+
+                SSi = Diagonal(xxt)
+                Si = inv(xt * SSi * xt')
+                brdf = Si * xt * SSi * ytt
+                yp = (brdf' * xt)'
+                se = sqrt(sum(((ytt - yp) .* xxt).^2)/(nt-3))
+            else
+                Si = inv(xt * xt')
+                brdf = Si * xt * ytt
+                yp = (brdf' * xt)'
+                se = sqrt(sum((ytt - yp).^2)/(nt-3))
+            end
+
+            results[i,1] = dot(gwsa, brdf) # wsa
+            results[i,2] = dot(gbsa, brdf) # bsa
+
+            results[i,3] = se * sqrt(dot(gwsa, Si * gwsa)) # wsa se
+            results[i,4] = se * sqrt(dot(gbsa, Si * gbsa)) # bsa se
+
+            results[i,5] = se # brdf rmse
+            results[i,6] = 1 - se^2 * (nt-3) / var(ytt; corrected=true) / nt # brdf R2
+            results[i,7] = nt # number of obs for brdf estimation
+        end
+    end
+
+    return results
+end
+
+function NRT_BRDF_nadir(Y::AbstractMatrix, sz::AbstractMatrix, vz::AbstractMatrix, rz::AbstractMatrix, soz_noon::AbstractVector, weighted::Bool, scale::Real)
+    n, p = size(Y)
+    results = fill(NaN, n, 5) # (nadir, nadir_se, rmse, R2, nt)
+    x = ones(3, p)
+    Knadir = [1.0, 0.0, 0.0]
+
+    for i in 1:n
+        yt = Y[i,:]
+        non_missing = findall(isfinite.(yt))
+        nt = length(non_missing)
+
+        if nt < 7
+            continue
+        else
+            szn = soz_noon[i]
+            x[2,:] = Kvol_vec(sz[i,:], vz[i,:], rz[i,:])
+            x[3,:] = Kgeo_vec(sz[i,:], vz[i,:], rz[i,:])
+
+            xt = x[:,non_missing]
+            ytt = yt[non_missing]
+
+            if weighted
+                xx = exp.(-0.5 .* range(p-1, stop=0; length=p) ./ scale)
+                xxt = xx[non_missing]
+                SSi = Diagonal(xxt)
+                Si = inv(xt * SSi * xt')
+                brdf = Si * xt * SSi * ytt
+                yp = (brdf' * xt)'
+                se = sqrt(sum(((ytt - yp) .* xxt).^2)/(nt-3))
+            else
+                Si = inv(xt * xt')
+                brdf = Si * xt * ytt
+                yp = (brdf' * xt)'
+                se = sqrt(sum((ytt - yp).^2)/(nt-3))
+            end
+
+            Knadir[2] = Kvol_sc(szn, 0.0, 0.0)
+            Knadir[3] = Kgeo_sc(szn, 0.0, 0.0)
+            results[i,1] = dot(Knadir, brdf) # nadir
+            results[i,2] = se * sqrt(dot(Knadir, Si * Knadir)) # nadir se
+            results[i,3] = se # brdf rmse
+            results[i,4] = 1 - se^2 * (nt-3) / var(ytt; corrected=true) / nt # brdf R2
+            results[i,5] = nt # number of obs for brdf estimation
+        end
+    end
+
+    return results
+end
+
+function NRT_BRDF_all(Y::AbstractMatrix, sz::AbstractMatrix, vz::AbstractMatrix, rz::AbstractMatrix, soz_noon::AbstractVector, weighted::Bool = true, scale::Real = 1.87)
+    # the rows are separate locations and the columns are separate times
+    @info "processing BRDF"
+    @info "reflectance rows: $(size(Y)[1]) cols: $(size(Y)[2])"
+    @info "solar zenith rows: $(size(sz)[1]) cols: $(size(sz)[2])"
+    @info "sensor zenith rows: $(size(vz)[1]) cols: $(size(vz)[2])"
+    @info "relative azimuth rows: $(size(rz)[1]) cols: $(size(rz)[2])"
+    @info "solar zenith noon size: $(size(soz_noon)[1])"
+
+    # RossThick constants
+    g0vol = -0.007574
+    g1vol = -0.070987
+    g2vol = 0.307588
+
+    # LiSparseR constants
+    g0geo = -1.284909
+    g1geo = -0.166314
+    g2geo = 0.041840
+
+    gwsa = [1.0, 0.189184, -1.377622]
+    gbsa = [1.0, 0.0, 0.0]
+    gnbar = [1.0, 0.0, 0.0]
+
+    n, p = size(Y)
+    @info "n: $(n) p: $(p)"
+    results = fill(NaN, n, 9) # (wsa, bsa, nadir, wsa_se, bsa_se, nadir_se, rmse, R2, nt)
+    @info "results rows: $(size(results)[1]) cols: $(size(results)[2])"
+
+    x = ones(3, p)
+
+    @showprogress for i in 1:n
+        yt = Y[i,:]
+        non_missing = findall(isfinite.(yt))
+        nt = length(non_missing)
+
+        if nt < 7
+            continue
+        else
+            sznrad = soz_noon[i] * pi/180
+            gbsa[2] = g0vol + g1vol * sznrad^2 + g2vol * sznrad^3
+            gbsa[3] = g0geo + g1geo * sznrad^2 + g2geo * sznrad^3
+
+            gnbar[2] = Kvol_sc(soz_noon[i], 0.0, 0.0)
+            gnbar[3] = Kgeo_sc(soz_noon[i], 0.0, 0.0)
+
+            x[2,:] = Kvol_vec(sz[i,:], vz[i,:], rz[i,:])
+            x[3,:] = Kgeo_vec(sz[i,:], vz[i,:], rz[i,:])
+
+            xt = x[:,non_missing]
+            ytt = yt[non_missing]
+
+            if weighted
+                xx = exp.(-0.5 .* range(p-1, stop=0; length=p) ./ scale)
+                xxt = xx[non_missing]
+
+                SSi = Diagonal(xxt)
+                Si = inv(xt * SSi * xt')
+                brdf = Si * xt * SSi * ytt
+                yp = (brdf' * xt)'
+                se = sqrt(sum(((ytt - yp) .* xxt).^2)/(nt-3))
+            else
+                Si = inv(xt * xt')
+                brdf = Si * xt * ytt
+                yp = (brdf' * xt)'
+                se = sqrt(sum((ytt - yp).^2)/(nt-3))
+            end
+
+            results[i,1] = dot(gwsa, brdf) # wsa
+            results[i,2] = dot(gbsa, brdf) # bsa
+            results[i,3] = dot(gnbar, brdf) # nadir
+
+            results[i,4] = se * sqrt(dot(gwsa, Si * gwsa)) # wsa se
+            results[i,5] = se * sqrt(dot(gbsa, Si * gbsa)) # bsa se
+            results[i,6] = se * sqrt(dot(gnbar, Si * gnbar)) # nadir se
+
+            results[i,7] = se # brdf rmse
+            results[i,8] = 1 - se^2 * (nt-3) / var(ytt; corrected=true) / nt # brdf R2
+            results[i,9] = nt # number of obs for brdf estimation
+
+            replace!(results, missing=>NaN)
+        end
+    end
+
+    return results
+end
+
+export NRT_BRDF_all
+
+function date_range(start::Date, stop::Date)::Vector{Date}
+    return collect(start:Day(1):stop)
+end
+
+function calculate_SZA(day_of_year::Array{Int64,1}, hour_of_day::Union{Array{Float64,1}, Float64}, lat::Array{Float64,1})::Array{Float64,1}
+    day_angle = (2 * pi * (day_of_year .- 1)) / 365
+    lat = deg2rad.(lat)
+    dec = deg2rad.((0.006918 .- 0.399912 .* cos.(day_angle) .+ 0.070257 .* sin.(day_angle) .- 0.006758 .* cos.(2 .* day_angle) .+ 0.000907 .* sin.(2 .* day_angle) .- 0.002697 .* cos.(3 .* day_angle) .+ 0.00148 .* sin.(3 .* day_angle)) .* (180 / pi))
+    hour_angle = deg2rad.(hour_of_day * 15.0 .- 180.0)
+    SZA = rad2deg.(acos.(sin.(lat) .* sin.(dec) .+ cos.(lat) .* cos.(dec) .* cos.(hour_angle)))
+    return SZA
+end
+
+end

ECOv003_L2T_STARS/__init__.py

@@ -0,0 +1,3 @@
+from .version import __version__, __author__
+from .ECOv003_L2T_STARS import *
+from .ECOv003_DL import *

ECOv003_L2T_STARS/calibrate_fine_to_coarse.py

@@ -0,0 +1,60 @@
+import logging
+
+import numpy as np
+from scipy import stats
+
+from rasters import Raster
+
+logger = logging.getLogger(__name__)
+
+def calibrate_fine_to_coarse(fine_image: Raster, coarse_image: Raster) -> Raster:
+    """
+    Calibrates a fine-resolution raster image to a coarse-resolution raster image
+    using linear regression.
+
+    This function aggregates the fine image to the geometry of the coarse image,
+    then performs a linear regression between the aggregated fine image and the
+    original coarse image. The derived slope and intercept are then applied to
+    the original fine image for calibration.
+
+    Args:
+        fine_image (Raster): The higher-resolution raster image to be calibrated.
+        coarse_image (Raster): The lower-resolution raster image used as the reference
+                                for calibration.
+
+    Returns:
+        Raster: The calibrated fine-resolution raster image. If too few valid
+                data points are available for regression (less than 30), the
+                original fine_image is returned.
+    """
+    # Aggregate the fine image to the coarse image's geometry for comparison
+    aggregated_image = fine_image.to_geometry(coarse_image.geometry, resampling="average")
+    x = np.array(aggregated_image).flatten()  # Independent variable (aggregated fine)
+    y = np.array(coarse_image).flatten()  # Dependent variable (coarse)
+
+    # Create a mask to remove NaN values from both arrays, ensuring valid data points for regression
+    mask = ~np.isnan(x) & ~np.isnan(y)
+
+    # Check if there are enough valid data points for a meaningful linear regression
+    if np.count_nonzero(mask) < 30:
+        logger.warning(
+            f"Insufficient valid data points ({np.count_nonzero(mask)}) for calibration. "
+            "Returning original fine image."
+        )
+        return fine_image
+
+    # Apply the mask to get only valid data points
+    x = x[mask]
+    y = y[mask]
+
+    # Perform linear regression
+    slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)
+    logger.info(
+        f"Linear regression for calibration: slope={slope:.4f}, intercept={intercept:.4f}, "
+        f"R-squared={r_value**2:.4f}"
+    )
+
+    # Apply the derived calibration to the original fine image
+    calibrated_image = fine_image * slope + intercept
+
+    return calibrated_image

ECOv003_L2T_STARS/constants.py

@@ -0,0 +1,38 @@
+from os.path import join, abspath, dirname
+
+# Template file for generating the L2T_STARS run configuration XML.
+L2T_STARS_TEMPLATE = join(abspath(dirname(__file__)), "ECOv003_L2T_STARS.xml")
+
+# Default directories and parameters for the L2T_STARS processing.
+DEFAULT_WORKING_DIRECTORY = "."  # Current directory
+DEFAULT_BUILD = "0700"  # Default build ID
+PRIMARY_VARIABLE = "NDVI"  # Primary variable of interest
+DEFAULT_OUTPUT_DIRECTORY = "L2T_STARS_output"
+DEFAULT_STARS_SOURCES_DIRECTORY = "L2T_STARS_SOURCES"
+DEFAULT_STARS_INDICES_DIRECTORY = "L2T_STARS_INDICES"
+DEFAULT_STARS_MODEL_DIRECTORY = "L2T_STARS_MODEL"
+DEFAULT_STARS_PRODUCTS_DIRECTORY = "STARS_products"
+DEFAULT_HLS_DOWNLOAD_DIRECTORY = "HLS2_download"
+DEFAULT_LANDSAT_DOWNLOAD_DIRECTORY = "HLS2_download"  # Redundant but kept for clarity
+DEFAULT_HLS_PRODUCTS_DIRECTORY = "HLS2_products"
+DEFAULT_VIIRS_DOWNLOAD_DIRECTORY = "VIIRS_download"
+DEFAULT_VIIRS_PRODUCTS_DIRECTORY = "VIIRS_products"
+DEFAUL_VIIRS_MOSAIC_DIRECTORY = "VIIRS_mosaic"
+DEFAULT_GEOS5FP_DOWNLOAD_DIRECTORY = "GEOS5FP_download"
+DEFAULT_GEOS5FP_PRODUCTS_DIRECTORY = "GEOS5FP_products"
+DEFAULT_VNP09GA_PRODUCTS_DIRECTORY = "VNP09GA_products"
+DEFAULT_VNP43NRT_PRODUCTS_DIRECTORY = "VNP43NRT_products"
+
+# Processing parameters
+VIIRS_GIVEUP_DAYS = 4  # Number of days to give up waiting for VIIRS data
+DEFAULT_SPINUP_DAYS = 7  # Spin-up period for time-series analysis
+DEFAULT_TARGET_RESOLUTION = 70  # Target output resolution in meters
+DEFAULT_NDVI_RESOLUTION = 490  # NDVI coarse resolution in meters
+DEFAULT_ALBEDO_RESOLUTION = 980  # Albedo coarse resolution in meters
+DEFAULT_USE_SPATIAL = False  # Flag for using spatial interpolation (currently unused)
+DEFAULT_USE_VNP43NRT = True  # Flag for using VNP43NRT VIIRS product
+DEFAULT_CALIBRATE_FINE = False  # Flag for calibrating fine resolution data to coarse
+
+# Product short and long names
+L2T_STARS_SHORT_NAME = "ECO_L2T_STARS"
+L2T_STARS_LONG_NAME = "ECOSTRESS Tiled Auxiliary NDVI and Albedo L2 Global 70 m"

ECOv003_L2T_STARS/daterange/__init__.py

@@ -0,0 +1 @@
+from .daterange import *

ECOv003_L2T_STARS/daterange/daterange.py

@@ -0,0 +1,35 @@
+import datetime
+import logging
+from typing import List, Union
+
+from dateutil import parser
+
+logger = logging.getLogger(__name__)
+
+
+def get_date(dt: Union[datetime.date, datetime.datetime, str]) -> datetime.date or None:
+    if dt is None:
+        return None
+    elif isinstance(dt, datetime.datetime):
+        return dt.date()
+    elif isinstance(dt, datetime.date):
+        return dt
+    elif isinstance(dt, str):
+        return parser.parse(dt).date()
+    else:
+        raise ValueError(f"invalid date type: {type(dt)}")
+
+
+def date_range(start: Union[datetime.date, str], end: Union[datetime.date, str]) -> List[datetime.date]:
+    start = get_date(start)
+    end = get_date(end)
+
+    try:
+        count = (end - start).days
+    except TypeError as e:
+        logger.exception(e)
+        raise TypeError(f"start type: {type(start)} end type: {type(end)}")
+
+    dates = [start + datetime.timedelta(days=days) for days in range(count + 1)]
+
+    return dates