Make many of the datasets functions parametric. Other annotations changes.

Author: joa-quim

src/extras/weather.jl

@@ -929,7 +929,7 @@ function _meteostat(ID::String, granularity::String, startdate::String, enddate:
 		n_years = (year2 - year1 + 1)
 		D = load_meteostat(ID, granul, year1, verbose)
 		if (n_years > 1)						# If more than one year, read multiple files
-			Dv = Vector{GMTdataset}(undef, n_years-1)
+			Dv = Vector{GMTdataset{Float64,2}}(undef, n_years-1)
 			for k = year1+1:year2
 				Dv[k-year1] = load_meteostat(ID, granul, k, verbose)
 			end

src/gdal_utils.jl

@@ -990,7 +990,7 @@ function lonlat2xy(xy::Vector{<:Real}, t_srs_=nothing; t_srs=nothing, s_srs=prj4
 end
 lonlat2xy(x::Real, y::Real, t_srs_=nothing; t_srs=nothing, s_srs=prj4WGS84) = lonlat2xy([x y], t_srs_; t_srs=t_srs, s_srs=s_srs)
 
-function lonlat2xy(xy::Matrix{<:Real}, t_srs_=nothing; t_srs=nothing, s_srs=prj4WGS84)
+function lonlat2xy(xy::Matrix{T}, t_srs_=nothing; t_srs=nothing, s_srs=prj4WGS84) where {T <: Real}
 	(t_srs_ !== nothing) && (t_srs = t_srs_)
 	isa(s_srs, Int) && (s_srs = epsg2wkt(s_srs))
 	isa(t_srs, Int) && (t_srs = epsg2wkt(t_srs))
@@ -1002,7 +1002,7 @@ function lonlat2xy(xy::Matrix{<:Real}, t_srs_=nothing; t_srs=nothing, s_srs=prj4
 end
 
 lonlat2xy(D::GMTdataset, t_srs_=nothing; t_srs=nothing, s_srs=prj4WGS84) = lonlat2xy([D], t_srs_; t_srs=t_srs, s_srs=s_srs)
-function lonlat2xy(D::Vector{<:GMTdataset}, t_srs_=nothing; t_srs=nothing, s_srs=prj4WGS84)
+function lonlat2xy(D::Vector{<:GMTdataset{T,2}}, t_srs_=nothing; t_srs=nothing, s_srs=prj4WGS84) where {T<:Real}
 	(t_srs_ !== nothing) && (t_srs = t_srs_)
 	isa(t_srs, Int) && (t_srs = epsg2wkt(t_srs))
 	isa(s_srs, Int) && (s_srs = epsg2wkt(s_srs))
@@ -1129,7 +1129,7 @@ Return a vector of GMTdatasets from a vector of WKT strings.
 """
 function readgeom(wkt::Vector{String})
 	n_ds = length(wkt)
-	D = Vector{GMTdataset}(undef, n_ds)
+	D = Vector{GMTdataset{Float64,2}}(undef, n_ds)
 	for k = 1:n_ds
 		D[k] = gd2gmt(fromWKT(wkt[k]))
 	end

src/gmt_main.jl

@@ -1405,7 +1405,7 @@ function ogr2GMTdataset(in::Ptr{OGR_FEATURES}, drop_islands=false)::Union{GMTdat
 
 			if (OGR_F.n_islands == 0)
 				geom_type = unsafe_string(OGR_F.type)
-				geom = (geom_type == "Polygon") ? wkbPolygon : ((geom_type == "LineString") ? wkbLineString : wkbPoint)
+				geom::Int = (geom_type == "Polygon") ? wkbPolygon : ((geom_type == "LineString") ? wkbLineString : wkbPoint)
 				(is3D && (geom == wkbPolygon || geom == wkbPoint)) && (geom == wkbPolygon ? wkbPointZ : wkbPointZM)	# Convert 2D to 3D
 				data = is3D ? [unsafe_wrap(Array, OGR_F.x, OGR_F.np) unsafe_wrap(Array, OGR_F.y, OGR_F.np) unsafe_wrap(Array, OGR_F.z, OGR_F.np)] : [unsafe_wrap(Array, OGR_F.x, OGR_F.np) unsafe_wrap(Array, OGR_F.y, OGR_F.np)]
 				D[n] = GMTdataset(data, Float64[], Float64[], attrib, coln, String[], hdr, String[], proj4, wkt, 0, Int(geom))

src/gmtspatial.jl

@@ -50,10 +50,23 @@ Parameters
     end points in the directions implied by the line ends.
 
 """
-function gmtspatial(cmd0::String="", arg1=nothing, arg2 = nothing; kwargs...)
+gmtspatial(cmd0::String, arg1=nothing; kw...) = gmtspatial_helper(cmd0, arg1, nothing; kw...)
+gmtspatial(arg1; kw...) = gmtspatial_helper("", arg1, nothing; kw...)
+gmtspatial(arg1, arg2; kw...) = gmtspatial_helper("", arg1, arg2; kw...)
 
+# ---------------------------------------------------------------------------------------------------
+function gmtspatial_helper(cmd0::String, arg1, arg2; kw...)
 	(cmd0 == "" && arg1 === nothing && arg2 === nothing && length(kwargs) == 0) && return gmt("gmtspatial")
-	d = init_module(false, kwargs...)[1]		# Also checks if the user wants ONLY the HELP mode
+	d = init_module(false, kw...)[1]			# Also checks if the user wants ONLY the HELP mode
+	isa(arg1, Matrix) && (arg1 = mat2ds(arg1))
+	_gmtspatial_helper(cmd0, arg1, arg2, d)
+end
+
+#function gmtspatial(cmd0::String="", arg1=nothing, arg2 = nothing; kwargs...)
+function _gmtspatial_helper(cmd0::String, arg1, arg2, d::Dict)::Union{GMTdataset{Float64,2}, Vector{<:GMTdataset{Float64,2}}}
+
+	#(cmd0 == "" && arg1 === nothing && arg2 === nothing && length(kwargs) == 0) && return gmt("gmtspatial")
+	#d = init_module(false, kwargs...)[1]		# Also checks if the user wants ONLY the HELP mode
 	arg3 = nothing;     arg4 = nothing
 
 	cmd, = parse_common_opts(d, "", [:R :V_params :b :d :e :f :g :h :i :o :yx])
@@ -88,6 +101,7 @@ function gmtspatial(cmd0::String="", arg1=nothing, arg2 = nothing; kwargs...)
 		D.data = D.data[ind, :]
 		!isempty(D.text) && (D.text = D.text[ind])
 	end
+
 	if contains(cmd, "-N+i")
 		D.colnames = ["x","y","polID"]
 		sz = hasID ? 0 : size(D,1)
@@ -105,4 +119,4 @@ function gmtspatial(cmd0::String="", arg1=nothing, arg2 = nothing; kwargs...)
 end
 
 # ---------------------------------------------------------------------------------------------------
-gmtspatial(arg1, arg2=nothing; kw...) = gmtspatial("", arg1, arg2; kw...)
+#gmtspatial(arg1, arg2=nothing; kw...) = gmtspatial("", arg1, arg2; kw...)

src/laszip/lazread.jl

@@ -2,7 +2,7 @@ Base.@kwdef struct lasout_types
 	stored::String = ""
 	grd::GMTgrid = GMTgrid()
 	ds::GMTdataset = GMTdataset()
-	dsv::Vector{GMTdataset{Float64}} = [GMTdataset()]
+	dsv::Vector{GMTdataset{Float64,2}} = [GMTdataset()]
 	function lasout_types(stored, grd, ds, dsv)
 		stored = !isempty(grd) ? "grd" : (!isempty(ds) ? "ds" : (!isempty(dsv) ? "dsv" : ""))
 		new(stored, grd, ds, dsv)

src/psscale.jl

@@ -54,8 +54,9 @@ function colorbar(arg1::Union{Nothing, GMTcpt}=nothing; first=true, kwargs...)
 
 	parse_paper(d)		# See if user asked to temporarily pass into paper mode coordinates
 
+	isBnone = (get(d, :B, nothing) == :none)
 	cmd = parse_BJR(d, "", "", O, "")[1]
-	opt_B = (!contains(cmd, " -B") && !IamModern[1]) ? DEF_FIG_AXES[1] : ""
+	opt_B = (!contains(cmd, " -B") && !IamModern[1] && !isBnone) ? DEF_FIG_AXES[1] : ""
 	cmd = parse_JZ(d, cmd; O=O, is3D=(CTRL.pocket_J[3] != ""))[1]		# We can't use parse_J(d)[1]
 	cmd = parse_common_opts(d, cmd, [:F :UVXY :params :margin :c :p :t]; first=first)[1]
 	cmd = parse_these_opts(cmd, d, [[:G :truncate], [:I :shade], [:M :monochrome], [:N :dpi],

src/psxy.jl

@@ -156,7 +156,7 @@ function _common_plot_xyz(cmd0::String, arg1, caller::String, O::Bool, K::Bool,
 	opt_W::String = add_opt_pen(d, [:W :pen], opt="W")
 	arg1, opt_W, got_color_line_grad, made_it_vector = helper_psxy_line(d, cmd, opt_W, is3D, arg1, arg2, arg3)
 
-	arg1, cmd = check_ribbon(d, arg1, cmd, opt_W)	# Do this check here, after -W is known and before parsing -G & -L
+	isa(arg1, GDtype) && (arg1, cmd = check_ribbon(d, arg1, cmd, opt_W))	# Do this check here, after -W is known and before parsing -G & -L
 
 	mcc, bar_ok = false, (sub_module == "bar" && !check_bar_group(arg1))
 	if (!got_color_line_grad && !is_gridtri && (arg1 !== nothing && !isa(arg1, GMTcpt)) && ((!got_Zvars && !is_ternary) || bar_ok))
@@ -259,7 +259,7 @@ end
 
 # ---------------------------------------------------------------------------------------------------
 # If the input is a GMTdataset and one of its columns is a Time column, automatically set the -fT
-function set_fT(D::GMTdataset, cmd::String, opt_f::String)
+function set_fT(D::GMTdataset{T,N}, cmd::String, opt_f::String)::String where {T,N}
 	if ((Tc = get(D.attrib, "Timecol", "")) != "")
 		tc::Int = parse(Int, Tc) - 1
 		_opt_f = (opt_f == "") ? " -f$(tc)T" : opt_f * ",$(tc)T"
@@ -284,7 +284,7 @@ function parse_grid2tri_case(d, cmd, caller, is3D, isFV, O, arg1)
 	(opt_p == "" && !is3D && !O) && (CURRENT_VIEW[1] = "")	# Make sure it empty under these conditions
 	(opt_p == "") ? (opt_p = CURRENT_VIEW[1]; cmd *= opt_p)	: (CURRENT_VIEW[1] = opt_p) # Save for eventual use in other modules.
 
-	if (is3D && isFV)			# case of 3D faces
+	if (is3D && isFV)				# case of 3D faces
 		arg1 = (is_in_dict(d, [:replicate]) !== nothing) ? replicant(arg1, d) : deal_faceverts(arg1, d; del=find_in_dict(d, [:nocull])[1] === nothing)
 		(!O && !haskey(d, :aspect3) && is_in_dict(d, [:JZ :Jz :zsize :zscale]) === nothing && !isgeog(arg1)) && (d[:aspect3] = "equal")
 		(!O && !haskey(d, :aspect3) && isgeog(arg1)) && (d[:aspect] = "equal")
@@ -296,12 +296,12 @@ function parse_grid2tri_case(d, cmd, caller, is3D, isFV, O, arg1)
 end
 
 # ---------------------------------------------------------------------------------------------------
-function parse_Ebars(d, cmd, arg1)
+function parse_Ebars(d::Dict{Symbol, Any}, cmd::String, arg1)
 	got_Ebars = false
 	val, symb = find_in_dict(d, [:E :error :errorbars :error_bars], false)
 	if (val !== nothing)
 		if isa(val, String)
-			cmd *= " -E" * val
+			cmd::String *= " -E" * val
 		else
 			_mat = (arg1 === nothing) ? arg1 : isa(arg1, GMTdataset) ? arg1.data : arg1[1].data
 			cmd, mat_t = add_opt(add_opt, (d, cmd, "E", [symb]),
@@ -316,7 +316,7 @@ function parse_Ebars(d, cmd, arg1)
 end
 
 # ---------------------------------------------------------------------------------------------------
-function parse_color_request(d, cmd, N_args, arg1, arg2)
+function parse_color_request(d::Dict{Symbol, Any}, cmd::String, N_args::Int, arg1, arg2)
 	opt_Z, args, n, got_Zvars = add_opt(d, "", "Z", [:Z :level :levels], :data, Any[arg1, arg2], (outline="_o", nofill="_f"))
 	(opt_Z == " -Z" && n == 0) && error("The 'level' option (Z) must be set a single value, a file name or a vector os reals.")
 	if (isa(arg1, Vector{<:GMTdataset}) && ((ind_att = findfirst('=', opt_Z)) !== nothing))
@@ -353,7 +353,7 @@ function set_avatar_defaults(d, cmd, mcc, caller, got_usr_R, opt_B, opt_Gsymb, o
 end
 
 # ---------------------------------------------------------------------------------------------------
-function parse_plot_G_L(d, cmd, g_bar_fill, is_ternary)
+function parse_plot_G_L(d::Dict{Symbol, Any}, cmd::String, g_bar_fill::Vector{String}, is_ternary::Bool)
 	opt_G::String = ""
 	if (isempty(g_bar_fill))					# Otherwise bar fill colors are dealt with somewhere else
 		((opt_G = add_opt_fill("", d, [:G :fill], 'G')) != "") && (cmd *= opt_G)	# Also keep track if -G was set
@@ -374,7 +374,7 @@ function parse_plot_G_L(d, cmd, g_bar_fill, is_ternary)
 end
 
 # ---------------------------------------------------------------------------------------------------
-function parse_plot_callers(d, gmt_proggy, caller, is3D, O, arg1)
+function parse_plot_callers(d::Dict{Symbol, Any}, gmt_proggy::String, caller::String, is3D::Bool, O::Bool, arg1)
 	isFV = (isa(arg1, GMTfv) || isa(arg1, Vector{GMTfv}))
 	(arg1 !== nothing && !isa(arg1, GDtype) && !isa(arg1, Matrix{<:Real}) && !isFV) &&
 		(arg1 = tabletypes2ds(arg1, ((val = find_in_dict(d, [:interp])[1]) !== nothing) ? interp=val : interp=0))
@@ -407,9 +407,9 @@ function parse_plot_callers(d, gmt_proggy, caller, is3D, O, arg1)
 end
 
 # ---------------------------------------------------------------------------------------------------
-plt_txt_attrib!(D::GMTdataset, d::Dict, _cmd::Vector{String}) = plt_txt_attrib!([D], d, _cmd)
-function plt_txt_attrib!(D::Vector{<:GMTdataset}, d::Dict, _cmd::Vector{String})
-	# Plot TEXT attributed labels and serve as function barrier agains to f Anys
+plt_txt_attrib!(D::GMTdataset{T,N}, d::Dict{Symbol, Any}, _cmd::Vector{String}) where {T,N} = plt_txt_attrib!([D], d, _cmd)
+function plt_txt_attrib!(D::Vector{<:GMTdataset{T,N}}, d::Dict{Symbol, Any}, _cmd::Vector{String}) where {T,N}
+	# Plot TEXT attributed labels and serve as function barrier agains the f Any's (not sure if succeeds)
 	((val = find_in_dict(d, [:labels])[1]) === nothing) && return nothing
 
 	s_val::String = string(val)
@@ -422,13 +422,13 @@ function plt_txt_attrib!(D::Vector{<:GMTdataset}, d::Dict, _cmd::Vector{String})
 	if ((fnt = add_opt(d, "", "", [:font], (angle="+a", font=("+f", font)); del=false)) != "")
 		(fnt[1] != '+') && (fnt = "+f" * fnt)
 		delete!(d, :font)
-		ct.text = make_attrtbl(D, att=ts)[1]
+		ct.text = vec(make_attrtbl(D, att=ts)[1])
 	else
 		nc::Int = round(Int, sqrt(length(D)))				# A crude guess of the number of columns
 		fnt = (nc < 5) ? "7p" : (nc < 9 ? "5p" : "4p")		# A simple heuristic
 		outline = fnt * ",black=~0.75p,white "				# Apply the outline trick
 		fnt = "+f"
-		ct.text = outline .* make_attrtbl(D, att=ts)[1]
+		ct.text = outline .* vec(make_attrtbl(D, att=ts)[1])
 	end
 	(CTRL.pocket_call[1] === nothing) ? (CTRL.pocket_call[1] = ct) : (CTRL.pocket_call[2] = ct)
 	append!(_cmd, ["pstext -R -J -F" * fnt * "+jMC"])
@@ -510,7 +510,7 @@ function if_multicols(d, arg1, is3D::Bool)
 	MULTI_COL[1] && (d2[:multi] = true)			# MULTI_COL was set in cat_2_arg2() when 2nd arg had 2 or more cols.
 	arg1 = ds2ds(arg1; is3D=is3D, d2...)		# Pass a 'd' copy and remove possible kw that are also parsed in psxy
 	delete!(d, [[:multi, :multicol, :multicols], [:lt, :linethick], [:ls, :linestyle], [:fill], [:fillalpha], [:color]])
-	MULTI_COL[1] = false							# If it was true, its jobe is done.
+	MULTI_COL[1] = false						# If it was true, its jobe is done.
 	return arg1
 end
 
@@ -545,6 +545,7 @@ function check_grouping!(d, arg1)
 end
 
 # ---------------------------------------------------------------------------------------------------
+#=
 function check_ribbon(d, arg1, cmd::String, opt_W::String)
 	((val = find_in_dict(d, [:ribbon :band])[1]) === nothing) && return arg1, cmd
 	add_2 = true
@@ -561,6 +562,7 @@ function check_ribbon(d, arg1, cmd::String, opt_W::String)
 	else
 		error("Wrong data type for ribbon/band $(typeof(val))")
 	end
+	ec1, ec2, add_2 = helper_check_ribbon(val)
 	if (isa(arg1, Vector{<:GMTdataset}))
 		if (add_2)
 			for k = 1:numel(arg1)  add2ds!(arg1[k], ec2; names=["Zbnd1","Zbnd2"])  end
@@ -574,6 +576,49 @@ function check_ribbon(d, arg1, cmd::String, opt_W::String)
 	(!occursin(cmd, "-W") && opt_W == "") && (cmd *= " -W0.5p")		# Do not leave without a line specification
 	return arg1, cmd
 end
+=#
+
+function check_ribbon(d, arg1::GMTdataset{T,N}, cmd::String, opt_W::String) where {T,N}
+	((val = find_in_dict(d, [:ribbon :band])[1]) === nothing) && return arg1, cmd
+	ec1, ec2, add_2 = helper_check_ribbon(val)		# Function barrier agains Anys
+	(add_2) ? add2ds!(arg1, ec2; names=["Zbnd1","Zbnd2"]) : add2ds!(arg1, ec1; name="Zbnd")
+	d[:L] = (add_2) ? "+D" : "+d"
+	(!occursin(cmd, "-W") && opt_W == "") && (cmd *= " -W0.5p")		# Do not leave without a line specification
+	return arg1, cmd
+end
+
+function check_ribbon(d, arg1::Vector{<:GMTdataset{T,N}}, cmd::String, opt_W::String) where {T,N}
+	((val = find_in_dict(d, [:ribbon :band])[1]) === nothing) && return arg1, cmd
+	ec1, ec2, add_2 = helper_check_ribbon(val)		# Function barrier agains Anys
+	if (add_2)
+		for k = 1:numel(arg1)  add2ds!(arg1[k], ec2; names=["Zbnd1","Zbnd2"])  end
+	else
+		for k = 1:numel(arg1)  add2ds!(arg1[k], ec1; name="Zbnd")  end
+	end
+	d[:L] = (add_2) ? "+D" : "+d"
+	(!occursin(cmd, "-W") && opt_W == "") && (cmd *= " -W0.5p")		# Do not leave without a line specification
+	return arg1, cmd
+end
+
+function helper_check_ribbon(val)::Tuple{Vector{Float64}, Matrix{Float64}, Bool}
+	# Isolate here the fact that 'val' is a Any
+	add_2 = true
+	ec1, ec2 = Float64[], Matrix{Float64}[]
+	if isa(val, Real)
+		ec1 = repeat([float(val)::Float64], size(arg1,1)::Int)
+		add_2 = false
+	elseif (isa(val, VecOrMat{<:Real}) || isa(val, Tuple{<:Real, <:Real}))
+		(length(val)::Int == 2) ? (ec2 = repeat([float(val[1])::Float64 float(val[2])::Float64], size(arg1,1)::Int)) :
+		                           ec2 = [Float64.(vec(val)) Float64.(vec(val))]
+	elseif isa(val, Tuple{Vector{<:Real}, Vector{<:Real}})
+		ec2 = [Float64.(val[1]) Float64.(val[2])]
+	elseif (isa(val, Matrix{<:Real}) && size(val,2) == 2)
+		ec2 = val
+	else
+		error("Wrong data type for ribbon/band $(typeof(val))")
+	end
+	ec1, ec2, add_2
+end
 
 # ---------------------------------------------------------------------------------------------------
 function with_xyvar(d::Dict, arg1::GMTdataset, no_x::Bool=false)::Union{GMTdataset, Vector{<:GMTdataset}}

src/utils.jl

@@ -628,7 +628,7 @@ function delrows(D::GMTdataset; rows::Vector{<:Integer}=Int[], nodata=nothing, c
 	return size(mat,1) != size(D,1) ? mat2ds(mat, D) : D	# If nothing found, just return the original dataset
 end
 function delrows(D::Vector{<:GMTdataset}; rows::Vector{<:Integer}=Int[], nodata=nothing, col=0)
-	Dv = Vector{GMTdataset{typeof(D[1])}}(undef, length(D))
+	Dv = Vector{GMTdataset{typeof(D[1]),2}}(undef, length(D))
 	for k = 1:length(D)
 		Dv[k] = delrows(D[k], rows=rows, nodata=nodata, col=col)
 	end
@@ -1011,7 +1011,7 @@ Returns the shorter vector `y` and indices of picked points in `ind`
 
 See https://skemman.is/bitstream/1946/15343/3/SS_MSthesis.pdf
 """
-function lttb(D::GMTdataset, decfactor::Int=10)::GMTdataset
+function lttb(D::GMTdataset{T,2}, decfactor::Int=10)::GMTdataset{T,2} where T
 	y, ind = lttb(view(D.data, :, 2), decfactor)
 	(size(D,2) == 2) ? mat2ds([D.data[ind,1] y], ref=D) : mat2ds([D.data[ind,1] y D.data[ind,3:end]], ref=D)
 end