From fa59c80e88d36a85ac3697e8a89a08dcab3c5146 Mon Sep 17 00:00:00 2001 From: rafaqz Date: Tue, 19 Mar 2024 01:25:25 +0100 Subject: [PATCH] up --- ext/RastersArchGDALExt/gdal_source.jl | 6 ++-- src/Rasters.jl | 2 +- src/array.jl | 45 +++++++++++++-------------- src/sources/grd.jl | 2 +- src/stack.jl | 20 ++++++------ 5 files changed, 36 insertions(+), 39 deletions(-) diff --git a/ext/RastersArchGDALExt/gdal_source.jl b/ext/RastersArchGDALExt/gdal_source.jl index 8eee57d2c..e4cd27da1 100644 --- a/ext/RastersArchGDALExt/gdal_source.jl +++ b/ext/RastersArchGDALExt/gdal_source.jl @@ -36,9 +36,9 @@ const GDAL_VIRTUAL_FILESYSTEMS = "/vsi" .* ( # Array ######################################################################## -function RA.FileArray{GDALsource}(raster::AG.RasterDataset{T}, filename; kw...) where {T} - eachchunk, haschunks = DA.eachchunk(raster), DA.haschunks(raster) - RA.FileArray{GDALsource,T,3}(filename, size(raster); eachchunk, haschunks, kw...) +function RA.FileArray{GDALsource}(ds::AG.RasterDataset{T}, filename; kw...) where {T} + eachchunk, haschunks = DA.eachchunk(ds), DA.haschunks(ds) + RA.FileArray{GDALsource,T,3}(filename, size(ds); eachchunk, haschunks, kw...) end RA.cleanreturn(A::AG.RasterDataset) = Array(A) diff --git a/src/Rasters.jl b/src/Rasters.jl index 426f21023..e0c2eb5ff 100644 --- a/src/Rasters.jl +++ b/src/Rasters.jl @@ -98,6 +98,7 @@ include("dimensions.jl") include("filearray.jl") include("filestack.jl") include("openstack.jl") +include("sources/sources.jl") include("array.jl") include("stack.jl") include("series.jl") @@ -106,7 +107,6 @@ include("crs.jl") const RasterStackOrArray = Union{AbstractRasterStack,AbstractRaster} const RasterSeriesOrStack = Union{AbstractRasterSeries,AbstractRasterStack} -include("sources/sources.jl") include("utils.jl") include("skipmissing.jl") diff --git a/src/array.jl b/src/array.jl index b625698cb..2e23e9246 100644 --- a/src/array.jl +++ b/src/array.jl @@ -217,14 +217,14 @@ struct Raster{T,N,D<:Tuple,R<:Tuple,A<:AbstractArray{T,N},Na,Me,Mi} <: AbstractR metadata::Me missingval::Mi end -function Raster(A::AbstractArray, dims::Tuple; +function Raster(A::AbstractArray{T}, dims::Tuple; refdims=(), name=Symbol(""), metadata=NoMetadata(), - missingval=missing, + missingval=Missing <: T ? missing : nothing, crs=nokw, mappedcrs=nokw -) +) where T A = Raster(A, Dimensions.format(dims, A), refdims, name, metadata, missingval) A = crs isa NoKW ? A : setcrs(A, crs) A = mappedcrs isa NoKW ? A : setmappedcrs(A, mappedcrs) @@ -236,11 +236,11 @@ function Raster(A::AbstractArray{<:Any,1}, dims::Tuple{<:Dimension,<:Dimension,V Raster(reshape(A, map(length, dims)), dims; kw...) end function Raster(table, dims::Tuple; - name=first(_not_a_dimcol(table, dims)), + name=nokw, kw... ) Tables.istable(table) || throw(ArgumentError("First argument to `Raster` is not a table or other known object: $table")) - isnothing(name) && throw(UndefKeywordError(:name)) + name = isnothing(name) ? first(_not_a_dimcol(table, dims)) : name cols = Tables.columns(table) A = reshape(cols[name], map(length, dims)) return Raster(A, dims; name, kw...) @@ -257,40 +257,39 @@ function Raster(A::AbstractDimArray; ) return Raster(data, dims; refdims, name, metadata, missingval, kw...) end -function Raster(filename::AbstractString, dims::Tuple{<:Dimension,<:Dimension,Vararg}; +function Raster(filename::AbstractString, dims::Tuple{<:Dimension,<:Dimension,Vararg}; kw... ) Raster(filename; dims, kw...) end function Raster(filename::AbstractString; - name=nothing, - key=name, + name=nokw, # nothing may mean take the first available key in the dataset source=nothing, kw... ) source = isnothing(source) ? _sourcetype(filename) : _sourcetype(source) _open(filename; source) do ds - key = filekey(ds, key) - Raster(ds, filename, key; source, kw...) + key = filekey(ds, name) + Raster(ds, filename, key; source, name, kw...) end end -function Raster(ds, filename::AbstractString, key=nothing; - crs=nokw, - mappedcrs=nokw, - dims=nothing, +function Raster(ds, filename::AbstractString, key::Union{Symbol,AbstractString,Nothing,NoKW}=nothing; + crs=nokw, + mappedcrs=nokw, + dims=nokw, refdims=(), - name=Symbol(key isa Nothing ? "" : string(key)), - metadata=metadata(ds), + name=key isa Union{NoKW,Nothing} ? Symbol("") : Symbol(key), + metadata=metadata(ds), missingval=missingval(ds), - source=nothing, - write=false, - lazy=false, + source=nothing, + write=false, + lazy=false, dropband=true, ) source = isnothing(source) ? _sourcetype(filename) : _sourcetype(source) crs = defaultcrs(source, crs) mappedcrs = defaultmappedcrs(source, mappedcrs) - dims = dims isa Nothing ? DD.dims(ds, crs, mappedcrs) : dims + dims = dims isa NoKW ? DD.dims(ds, crs, mappedcrs) : dims data = if lazy FileArray{source}(ds, filename; key, write) else @@ -303,9 +302,9 @@ function Raster(ds, filename::AbstractString, key=nothing; return dropband ? _drop_single_band(raster, lazy) : raster end # TODO what was this method for -function Raster{T,N,D,R,A,Na,Me,Mi}(ras::Raster{T,N,D,R,A,Na,Me,Mi}) where {T,N,D,R,A,Na,Me,Mi} - return Raster(ras.data, ras.dims, ras.refdims, ras.name, ras.metadata, ras.missingval) -end +# function Raster{T,N,D,R,A,Na,Me,Mi}(ras::Raster{T,N,D,R,A,Na,Me,Mi}) where {T,N,D,R,A,Na,Me,Mi} + # return Raster(ras.data, ras.dims, ras.refdims, ras.name, ras.metadata, ras.missingval) +# end filekey(ds, key) = key filekey(filename::String) = Symbol(splitext(basename(filename))[1]) diff --git a/src/sources/grd.jl b/src/sources/grd.jl index d9b0d0cf2..9fffacf61 100644 --- a/src/sources/grd.jl +++ b/src/sources/grd.jl @@ -38,7 +38,7 @@ end attrib(grd::GRDattrib) = grd.attrib filename(grd::GRDattrib) = grd.filename -filekey(grd::GRDattrib, key::Nothing) = get(attrib(grd), "layername", Symbol("")) +filekey(grd::GRDattrib, key::NoKW) = get(attrib(grd), "layername", Symbol("")) function DD.dims(grd::GRDattrib, crs=nothing, mappedcrs=nothing) attrib = grd.attrib diff --git a/src/stack.jl b/src/stack.jl index b233e01a6..af4c01f96 100644 --- a/src/stack.jl +++ b/src/stack.jl @@ -343,19 +343,18 @@ RasterStack(st::AbstractRasterStack, dims::Tuple; kw...) = RasterStack(st; dims, # Stack from table and dims args function RasterStack(table, dims::Tuple; name=_not_a_dimcol(table, dims), - keys=name, kw... ) Tables.istable(table) || throw(ArgumentError("object $(typeof(table)) is not a valid input to `RasterStack`")) # TODO use `name` everywhere, not keys - if keys isa Symbol - col = Tables.getcolumn(table, keys) - layers = NamedTuple{(keys,)}((reshape(col, map(length, dims)),)) + if name isa Symbol + col = Tables.getcolumn(table, name) + layers = NamedTuple{(name,)}((reshape(col, map(length, dims)),)) else - layers = map(keys) do k + layers = map(name) do k col = Tables.getcolumn(table, k) reshape(col, map(length, dims)) - end |> NamedTuple{keys} + end |> NamedTuple{name} end return RasterStack(layers, dims; kw...) end @@ -375,11 +374,10 @@ function RasterStack( end # RasterStack from another stack function RasterStack(s::AbstractDimStack; - name=cleankeys(Base.keys(s)), - keys=name, - data=NamedTuple{keys}(s[key] for key in keys), - dims=dims(s), - refdims=refdims(s), + name::Tuple=Base.keys(s), + data::NamedTuple=NamedTuple{name}(s[n] for n in name), + dims::Tuple=dims(s), + refdims::Tuple=refdims(s), layerdims=DD.layerdims(s), metadata=metadata(s), layermetadata=DD.layermetadata(s),