up

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)

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")
 

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])

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

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),