From 2aab374321d5b62ac07ce8de7b6054ee6fb49953 Mon Sep 17 00:00:00 2001 From: Skylar Gering Date: Thu, 18 Jan 2024 09:44:19 -0800 Subject: [PATCH 01/12] Add angle code --- test/methods/angles.jl | 241 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 241 insertions(+) create mode 100644 test/methods/angles.jl diff --git a/test/methods/angles.jl b/test/methods/angles.jl new file mode 100644 index 000000000..afd55479a --- /dev/null +++ b/test/methods/angles.jl @@ -0,0 +1,241 @@ + +angles(geom; ::Type{T} = Float64) where T = _angles(T, GI.trait(geom), geom) + +_angles(::Type{T}, ::Union{GI.PointTrait, GI.LineTrait}, geom) where T = T[] + +function _angles(::Type{T}, ::Union{GI.LineStringTrait, GI.LinearRingTrait}, geom) + angle_list = Vector{T}(undef, GI.npoints(geom) - 2) + + return +end + +function _angles(::Type{T}, ::GI.Polygon, geom) + angle_list = Vector{T}(undef, GI.npoints(geom) - 1) # TODO add in check for repeted last coordinate + local p1, last_diff + start_diff = (zero(T), zero(T)) + for (i, p2) in enumerate(GI.getpoint(geom)) + if i > 1 + current_diff = (GI.x(p2) - GI.x(p1), GI.y(p2) - GI.y(p1)) + if i == 2 + start_diff = current_diff + else + + end + last_diff = current_diff + end + p1 = p2 + end + # Calculate needed vectors + pdiff = diff(coords[1]) + npoints = length(pdiff) + v1 = -pdiff + v2 = vcat(pdiff[2:end], pdiff[1:1]) + v1_dot_v2 = [sum(v1[i] .* v2[i]) for i in collect(1:npoints)] + mag_v1 = sqrt.([sum(v1[i].^2) for i in collect(1:npoints)]) + mag_v2 = sqrt.([sum(v2[i].^2) for i in collect(1:npoints)]) + # Protect against division by 0 caused by very close points + replace!(mag_v1, 0=>eps(FT)) + replace!(mag_v2, 0=>eps(FT)) + angles = real.( + acos.( + clamp!(v1_dot_v2 ./ mag_v1 ./ mag_v2, FT(-1), FT(1)) + ) * 180 / pi + ) + + #= The first angle computed was for the second vertex, and the last was for + the first vertex. Scroll one position down to make the last vertex be the + first. =# + sangles = circshift(angles, 1) + # Now determine if any vertices are concave and adjust angles accordingly. + sgn = convex_angle_test(coords[1]) + for i in eachindex(sangles) + sangles[i] = (sgn[i] == -1) ? (-sangles[i] + 360) : sangles[i] + end + return sangles + +end + +""" + polyedge(p1, p2) + +Outputs the coefficients of the line passing through p1 and p2. +The line is of the form w1x + w2y + w3 = 0. +Inputs: + p1 [x, y] point + p2 [x, y] point +Outputs: + Three-element vector for coefficents of line passing through p1 and p2 +Note: + See note on calc_poly_angles for credit for this function. +""" +function polyedge(p1::Vector{<:FT}, p2) where FT + x1 = p1[1] + y1 = p1[2] + x2 = p2[1] + y2 = p2[2] + w = if x1 == x2 + [-1/x1, 0, 1] + elseif y1 == y2 + [0, -1/y1, 1] + elseif x1 == y1 && x2 == y2 + [1, 1, 0] + else + v = (y1 - y2)/(x1*(y2 - y1) - y1*(x2 - x1) + eps(FT)) + [v, -v*(x2 - x1)/(y2 - y1), 1] + end + return w +end + +""" + orient_coords(coords) + +Take given coordinates and make it so that the first point has the smallest +x-coordiante and so that the coordinates are ordered in a clockwise sequence. +Duplicates vertices will be removed and the coordiantes will be closed (first +and last point are the same). + +Input: + coords vector of points [x, y] +Output: + coords oriented clockwise with smallest x-coordinate first +""" +function orient_coords(coords::RingVec) + # extreem_idx is point with smallest x-value - if tie, choose lowest y-value + extreem_idx = 1 + for i in eachindex(coords) + ipoint = coords[i] + epoint = coords[extreem_idx] + if ipoint[1] < epoint[1] + extreem_idx = i + elseif ipoint[1] == epoint[1] && ipoint[2] < epoint[2] + extreem_idx = i + end + end + # extreem point must be first point in list + new_coords = similar(coords) + circshift!(new_coords, coords, -extreem_idx + 1) + valid_ringvec!(new_coords) + + # if coords are counterclockwise, switch to clockwise + orient_matrix = hcat( + ones(3), + vcat(new_coords[1]', new_coords[2]', new_coords[end-1]') # extreem/adjacent points + ) + if det(orient_matrix) > 0 + reverse!(new_coords) + end + return new_coords +end + +""" + convex_angle_test(coords::RingVec{T}) + +Determine which angles in the polygon are convex, with the assumption that the +first angle is convex, no other vertex has a smaller x-coordinate, and the +vertices are assumed to be ordered in a clockwise sequence. The test is based on +the fact that every convex vertex is on the positive side of the line passing +through the two vertices immediately following each vertex being considered. +Inputs: + coords Vector of [x, y] vectors that make up the exterior + of a polygon +Outputs: + sgn One element for each [x,y] pair - if 1 then + the angle at that vertex is convex, if it is -1 then the angle is + concave. +""" +function convex_angle_test(coords::RingVec{T}) where T + L = 10^25 + # Extreme points used in following loop, apended by a 1 for dot product + top_left = [-L, -L, 1] + top_right = [-L, L, 1] + bottom_left = [L, -L, 1] + bottom_right = [L, L, 1] + sgn = [1] # First vertex is convex + + for k in collect(2:length(coords)-1) + p1 = coords[k-1] + p2 = coords[k] # Testing this point for concavity + p3 = coords[k+1] + # Coefficents of polygon edge passing through p1 and p2 + w = polyedge(p1, p2) + + #= Establish the positive side of the line w1x + w2y + w3 = 0. + The positive side of the line should be in the right side of the vector + (p2- p3).Δx and Δy give the direction of travel, establishing which of + the extreme points (see above) should be on the + side. If that point is + on the negative side of the line, then w is replaced by -w. =# + Δx = p2[1] - p1[1] + Δy = p2[2] - p1[2] + if Δx == Δy == 0 + throw(ArgumentError("Data into convextiy test is 0 or duplicated")) + end + vector_product = + if Δx <= 0 && Δy >= 0 # Bottom_right should be on + side. + dot(w, bottom_right) + elseif Δx <= 0 && Δy <=0 # Top_right should be on + side. + dot(w, top_right) + elseif Δx>=0 && Δy<=0 # Top_left should be on + side. + dot(w, top_left) + else # Bottom_left should be on + side. + dot(w, bottom_left) + end + w *= sign(vector_product) + + # For vertex at p2 to be convex, p3 has to be on + side of line + if (w[1]*p3[1] + w[2]*p3[2] + w[3]) < 0 + push!(sgn, -1) + else + push!(sgn, 1) + end + end + return sgn +end + +""" + calc_poly_angles(coords::PolyVec{T}) + +Computes internal polygon angles (in degrees) of an arbitrary simple polygon. +The program eliminates duplicate points, except that the first row must equal +the last, so that the polygon is closed. +Inputs: + coords coordinates from a polygon +Outputs: + Vector of polygon's interior angles in degrees + +Note - Translated into Julia from the following program (including helper + functions convex_angle_test and polyedge): + Copyright 2002-2004 R. C. Gonzalez, R. E. Woods, & S. L. Eddins + Digital Image Processing Using MATLAB, Prentice-Hall, 2004 + Revision: 1.6 Date: 2003/11/21 14:44:06 +Warning - Assumes polygon has clockwise winding order. Use orient_coords! to + update coordinates prior to use +""" +function calc_poly_angles(coords::PolyVec{FT}) where {FT<:AbstractFloat} + # Calculate needed vectors + pdiff = diff(coords[1]) + npoints = length(pdiff) + v1 = -pdiff + v2 = vcat(pdiff[2:end], pdiff[1:1]) + v1_dot_v2 = [sum(v1[i] .* v2[i]) for i in collect(1:npoints)] + mag_v1 = sqrt.([sum(v1[i].^2) for i in collect(1:npoints)]) + mag_v2 = sqrt.([sum(v2[i].^2) for i in collect(1:npoints)]) + # Protect against division by 0 caused by very close points + replace!(mag_v1, 0=>eps(FT)) + replace!(mag_v2, 0=>eps(FT)) + angles = real.( + acos.( + clamp!(v1_dot_v2 ./ mag_v1 ./ mag_v2, FT(-1), FT(1)) + ) * 180 / pi + ) + + #= The first angle computed was for the second vertex, and the last was for + the first vertex. Scroll one position down to make the last vertex be the + first. =# + sangles = circshift(angles, 1) + # Now determine if any vertices are concave and adjust angles accordingly. + sgn = convex_angle_test(coords[1]) + for i in eachindex(sangles) + sangles[i] = (sgn[i] == -1) ? (-sangles[i] + 360) : sangles[i] + end + return sangles +end \ No newline at end of file From 5c8514761ae7f8cef6ed1ae5853c6ad7950663cc Mon Sep 17 00:00:00 2001 From: Skylar Gering Date: Thu, 18 Jan 2024 17:41:05 -0800 Subject: [PATCH 02/12] Finish angle code --- src/GeometryOps.jl | 5 + src/methods/angles.jl | 164 +++++++++++++++++++++++++ src/methods/area.jl | 2 +- test/methods/angles.jl | 271 +++++------------------------------------ test/runtests.jl | 27 ++-- 5 files changed, 214 insertions(+), 255 deletions(-) create mode 100644 src/methods/angles.jl diff --git a/src/GeometryOps.jl b/src/GeometryOps.jl index 81e7a89d2..755273966 100644 --- a/src/GeometryOps.jl +++ b/src/GeometryOps.jl @@ -17,10 +17,15 @@ const GB = GeometryBasics const TuplePoint = Tuple{Float64,Float64} const Edge = Tuple{TuplePoint,TuplePoint} +const MultiGeomTrait = Union{ + GI.MultiPointTrait, GI.MultiCurveTrait, + GI.MultiPolygonTrait, GI.GeometryCollectionTrait} + include("primitives.jl") include("utils.jl") +include("methods/angles.jl") include("methods/area.jl") include("methods/barycentric.jl") include("methods/bools.jl") diff --git a/src/methods/angles.jl b/src/methods/angles.jl new file mode 100644 index 000000000..55a69f5eb --- /dev/null +++ b/src/methods/angles.jl @@ -0,0 +1,164 @@ +# # Angles +export angles + +#= +## What is angles? + +Angles are the angles formed by a given geometries line segments, if it has line segments. + +To provide an example, consider this rectangle: +```@example angles +using GeometryOps +using GeometryOps.GeometryBasics +using Makie + +rect = Polygon([Point(0,0), Point(0,1), Point(1,1), Point(1,0), Point(0, 0)]) +f, a, p = poly(rect; axis = (; aspect = DataAspect())) +``` +This is clearly a rectangle, with angles of 90 degrees. +```@example angles +lines!(a, rect; color = 1:length(coordinates(rect))+1) +f +angles(area) +``` + +## Implementation + +This is the GeoInterface-compatible implementation. First, we implement a +wrapper method that dispatches to the correct implementation based on the +geometry trait. This is also used in the implementation, since it's a lot less +work! +=# + +""" + angles(geom, ::Type{T} = Float64) + +Returns the angles of a geometry or collection of geometries. +This is computed differently for different geometries: + + - The angles of a point is an empty vector. + - The angles of a single line segment is an empty vector. + - The angles of a linestring or linearring is a vector of angles formed by the curve. + - The angles of a polygin is a vector of vectors of angles formed by each ring. + - The angles of a multi-geometry collection is a vector of the angles of each of the + sub-geometries as defined above. + +Result will be a Vector, or nested set of vectors, of type T where an optional argument with +a default value of Float64. +""" +angles(geom, ::Type{T} = Float64) where T <: AbstractFloat = + _angles(T, GI.trait(geom), geom) + +# Points and single line segments have no angles +_angles(::Type{T}, ::Union{GI.PointTrait, GI.LineTrait}, geom) where T = T[] + +#= The angles of a linestring are the angles formed by the line. If the first and last point +are not explicitly repeated, the geom is not considered closed. The angles should all be on +one side of the line, but a particular side is not guaranteed by this function. =# +function _angles(::Type{T}, ::Union{GI.LineStringTrait}, geom) where T + npoints = GI.npoint(geom) + first_last_equal = equals(GI.getpoint(geom, 1), GI.getpoint(geom, npoints)) + angle_list = Vector{T}(undef, npoints - (first_last_equal ? 1 : 2)) + _find_angles!( + T, angle_list, geom; + offset = first_last_equal, close_geom = false, + ) + return angle_list +end + +#= The angles of a linearring are the angles within the closed line and include the angles +formed by connecting the first and last points of the curve. =# +function _angles(::Type{T}, ::GI.LinearRingTrait, geom) where T + npoints = GI.npoint(geom) + first_last_equal = equals(GI.getpoint(geom, 1), GI.getpoint(geom, npoints)) + angle_list = Vector{T}(undef, npoints - (first_last_equal ? 1 : 0)) + _find_angles!( + T, angle_list, geom; + offset = true, close_geom = !first_last_equal, + ) + return angle_list +end + +#= The angles of a polygon is a vector of lists angles of its rings. Note that +this means that the angles of any holes will be the exterior angles of the holes +outside of the geometry, rather than the interior angles=# +_angles(::Type{T}, ::GI.PolygonTrait, geom) where T = + [_angles(T, GI.LinearRingTrait(), g) for g in GI.getring(geom)] + +# Angles of a multi-geometry is simply a list of the angles of its sub-geometries. +_angles(::Type{T}, ::MultiGeomTrait, geom) where T = [angles(g, T) for g in GI.getgeom(geom)] + +#= +Find angles of a curve and insert the values into the angle_list. If offset is true, then +save space for the angle at the first vertex, as the curve is closed, at the front of +angle_list. If close_geom is true, then despite the first and last point not being +explicitly repeated, the curve is closed and the angle of the last point should be added to +angle_list. +=# +function _find_angles!(::Type{T}, angle_list, geom; offset, close_geom) where T + local p1, prev_p1_diff, p2_p1_diff + local start_point, start_diff + local extreem_idx, extreem_x, extreem_y + i_offset = offset ? 1 : 0 + # Loop through the curve and find each of the angels + for (i, p2) in enumerate(GI.getpoint(geom)) + xp2, yp2 = GI.x(p2), GI.y(p2) + #= Find point with smallest x values (and smallest y in case of a tie) as this point + is know to be convex. =# + if i == 1 || (xp2 < extreem_x || (xp2 == extreem_x && yp2 < extreem_y)) + extreem_idx = i + extreem_x, extreem_y = xp2, yp2 + end + if i > 1 + p2_p1_diff = (xp2 - GI.x(p1), yp2 - GI.y(p1)) + if i == 2 + start_point = p1 + start_diff = p2_p1_diff + else + angle_list[i - 2 + i_offset] = _diffs_calc_angle(T, prev_p1_diff, p2_p1_diff) + end + prev_p1_diff = -1 .* p2_p1_diff + end + p1 = p2 + end + # If the last point of geometry should be the same as the first, calculate closing angle + if close_geom + p2_p1_diff = (GI.x(start_point) - GI.x(p1), GI.y(start_point) - GI.y(p1)) + angle_list[end] = _diffs_calc_angle(T, prev_p1_diff, p2_p1_diff) + prev_p1_diff = -1 .* p2_p1_diff + end + # If needed, calculate first angle corresponding to the first point + if offset + angle_list[1] = _diffs_calc_angle(T, prev_p1_diff, start_diff) + end + #= Make sure that all of the angles are on the same side of the line and inside of the + closed ring if the input geometry is closed. =# + convex_sgn = sign(angle_list[extreem_idx]) + for i in eachindex(angle_list) + idx_sgn = sign(angle_list[i]) + if idx_sgn == -1 + angle_list[i] = abs(angle_list[i]) + end + if idx_sgn != convex_sgn + angle_list[i] = 360 - angle_list[i] + end + end + return +end + +#= +Calculate the angle between two vectors defined by the previous and current Δx and Δys. +Angle will have a sign corresponding to the sign of the cross product between the two +vectors. All angles of one sign in a given geometry are convex, while those of the other +sign are concave. However, the sign corresponding to each of these can vary based on +geometry and thus you must compare to an angle that is know to be convex or concave. +=# +function _diffs_calc_angle(::Type{T}, (Δx_prev, Δy_prev), (Δx_curr, Δy_curr)) where T + cross_prod = Δx_prev * Δy_curr - Δy_prev * Δx_curr + dot_prod = Δx_prev * Δx_curr + Δy_prev * Δy_curr + prev_mag = max(sqrt(Δx_prev^2 + Δy_prev^2), eps(T)) + curr_mag = max(sqrt(Δx_curr^2 + Δy_curr^2), eps(T)) + val = clamp(dot_prod / (prev_mag * curr_mag), -one(T), one(T)) + angle = real(acos(val) * 180 / π) + return angle * (cross_prod < 0 ? -1 : 1) +end \ No newline at end of file diff --git a/src/methods/area.jl b/src/methods/area.jl index 04505d1a2..5e25d0a45 100644 --- a/src/methods/area.jl +++ b/src/methods/area.jl @@ -49,7 +49,7 @@ const _AREA_TARGETS = Union{GI.PolygonTrait,GI.AbstractCurveTrait,GI.MultiPointT area(geom, ::Type{T} = Float64)::T Returns the area of a geometry or collection of geometries. -This is computed slighly differently for different geometries: +This is computed slightly differently for different geometries: - The area of a point/multipoint is always zero. - The area of a curve/multicurve is always zero. diff --git a/test/methods/angles.jl b/test/methods/angles.jl index afd55479a..98eb83f73 100644 --- a/test/methods/angles.jl +++ b/test/methods/angles.jl @@ -1,241 +1,30 @@ - -angles(geom; ::Type{T} = Float64) where T = _angles(T, GI.trait(geom), geom) - -_angles(::Type{T}, ::Union{GI.PointTrait, GI.LineTrait}, geom) where T = T[] - -function _angles(::Type{T}, ::Union{GI.LineStringTrait, GI.LinearRingTrait}, geom) - angle_list = Vector{T}(undef, GI.npoints(geom) - 2) - - return -end - -function _angles(::Type{T}, ::GI.Polygon, geom) - angle_list = Vector{T}(undef, GI.npoints(geom) - 1) # TODO add in check for repeted last coordinate - local p1, last_diff - start_diff = (zero(T), zero(T)) - for (i, p2) in enumerate(GI.getpoint(geom)) - if i > 1 - current_diff = (GI.x(p2) - GI.x(p1), GI.y(p2) - GI.y(p1)) - if i == 2 - start_diff = current_diff - else - - end - last_diff = current_diff - end - p1 = p2 - end - # Calculate needed vectors - pdiff = diff(coords[1]) - npoints = length(pdiff) - v1 = -pdiff - v2 = vcat(pdiff[2:end], pdiff[1:1]) - v1_dot_v2 = [sum(v1[i] .* v2[i]) for i in collect(1:npoints)] - mag_v1 = sqrt.([sum(v1[i].^2) for i in collect(1:npoints)]) - mag_v2 = sqrt.([sum(v2[i].^2) for i in collect(1:npoints)]) - # Protect against division by 0 caused by very close points - replace!(mag_v1, 0=>eps(FT)) - replace!(mag_v2, 0=>eps(FT)) - angles = real.( - acos.( - clamp!(v1_dot_v2 ./ mag_v1 ./ mag_v2, FT(-1), FT(1)) - ) * 180 / pi - ) - - #= The first angle computed was for the second vertex, and the last was for - the first vertex. Scroll one position down to make the last vertex be the - first. =# - sangles = circshift(angles, 1) - # Now determine if any vertices are concave and adjust angles accordingly. - sgn = convex_angle_test(coords[1]) - for i in eachindex(sangles) - sangles[i] = (sgn[i] == -1) ? (-sangles[i] + 360) : sangles[i] - end - return sangles - -end - -""" - polyedge(p1, p2) - -Outputs the coefficients of the line passing through p1 and p2. -The line is of the form w1x + w2y + w3 = 0. -Inputs: - p1 [x, y] point - p2 [x, y] point -Outputs: - Three-element vector for coefficents of line passing through p1 and p2 -Note: - See note on calc_poly_angles for credit for this function. -""" -function polyedge(p1::Vector{<:FT}, p2) where FT - x1 = p1[1] - y1 = p1[2] - x2 = p2[1] - y2 = p2[2] - w = if x1 == x2 - [-1/x1, 0, 1] - elseif y1 == y2 - [0, -1/y1, 1] - elseif x1 == y1 && x2 == y2 - [1, 1, 0] - else - v = (y1 - y2)/(x1*(y2 - y1) - y1*(x2 - x1) + eps(FT)) - [v, -v*(x2 - x1)/(y2 - y1), 1] - end - return w -end - -""" - orient_coords(coords) - -Take given coordinates and make it so that the first point has the smallest -x-coordiante and so that the coordinates are ordered in a clockwise sequence. -Duplicates vertices will be removed and the coordiantes will be closed (first -and last point are the same). - -Input: - coords vector of points [x, y] -Output: - coords oriented clockwise with smallest x-coordinate first -""" -function orient_coords(coords::RingVec) - # extreem_idx is point with smallest x-value - if tie, choose lowest y-value - extreem_idx = 1 - for i in eachindex(coords) - ipoint = coords[i] - epoint = coords[extreem_idx] - if ipoint[1] < epoint[1] - extreem_idx = i - elseif ipoint[1] == epoint[1] && ipoint[2] < epoint[2] - extreem_idx = i - end - end - # extreem point must be first point in list - new_coords = similar(coords) - circshift!(new_coords, coords, -extreem_idx + 1) - valid_ringvec!(new_coords) - - # if coords are counterclockwise, switch to clockwise - orient_matrix = hcat( - ones(3), - vcat(new_coords[1]', new_coords[2]', new_coords[end-1]') # extreem/adjacent points - ) - if det(orient_matrix) > 0 - reverse!(new_coords) - end - return new_coords -end - -""" - convex_angle_test(coords::RingVec{T}) - -Determine which angles in the polygon are convex, with the assumption that the -first angle is convex, no other vertex has a smaller x-coordinate, and the -vertices are assumed to be ordered in a clockwise sequence. The test is based on -the fact that every convex vertex is on the positive side of the line passing -through the two vertices immediately following each vertex being considered. -Inputs: - coords Vector of [x, y] vectors that make up the exterior - of a polygon -Outputs: - sgn One element for each [x,y] pair - if 1 then - the angle at that vertex is convex, if it is -1 then the angle is - concave. -""" -function convex_angle_test(coords::RingVec{T}) where T - L = 10^25 - # Extreme points used in following loop, apended by a 1 for dot product - top_left = [-L, -L, 1] - top_right = [-L, L, 1] - bottom_left = [L, -L, 1] - bottom_right = [L, L, 1] - sgn = [1] # First vertex is convex - - for k in collect(2:length(coords)-1) - p1 = coords[k-1] - p2 = coords[k] # Testing this point for concavity - p3 = coords[k+1] - # Coefficents of polygon edge passing through p1 and p2 - w = polyedge(p1, p2) - - #= Establish the positive side of the line w1x + w2y + w3 = 0. - The positive side of the line should be in the right side of the vector - (p2- p3).Δx and Δy give the direction of travel, establishing which of - the extreme points (see above) should be on the + side. If that point is - on the negative side of the line, then w is replaced by -w. =# - Δx = p2[1] - p1[1] - Δy = p2[2] - p1[2] - if Δx == Δy == 0 - throw(ArgumentError("Data into convextiy test is 0 or duplicated")) - end - vector_product = - if Δx <= 0 && Δy >= 0 # Bottom_right should be on + side. - dot(w, bottom_right) - elseif Δx <= 0 && Δy <=0 # Top_right should be on + side. - dot(w, top_right) - elseif Δx>=0 && Δy<=0 # Top_left should be on + side. - dot(w, top_left) - else # Bottom_left should be on + side. - dot(w, bottom_left) - end - w *= sign(vector_product) - - # For vertex at p2 to be convex, p3 has to be on + side of line - if (w[1]*p3[1] + w[2]*p3[2] + w[3]) < 0 - push!(sgn, -1) - else - push!(sgn, 1) - end - end - return sgn -end - -""" - calc_poly_angles(coords::PolyVec{T}) - -Computes internal polygon angles (in degrees) of an arbitrary simple polygon. -The program eliminates duplicate points, except that the first row must equal -the last, so that the polygon is closed. -Inputs: - coords coordinates from a polygon -Outputs: - Vector of polygon's interior angles in degrees - -Note - Translated into Julia from the following program (including helper - functions convex_angle_test and polyedge): - Copyright 2002-2004 R. C. Gonzalez, R. E. Woods, & S. L. Eddins - Digital Image Processing Using MATLAB, Prentice-Hall, 2004 - Revision: 1.6 Date: 2003/11/21 14:44:06 -Warning - Assumes polygon has clockwise winding order. Use orient_coords! to - update coordinates prior to use -""" -function calc_poly_angles(coords::PolyVec{FT}) where {FT<:AbstractFloat} - # Calculate needed vectors - pdiff = diff(coords[1]) - npoints = length(pdiff) - v1 = -pdiff - v2 = vcat(pdiff[2:end], pdiff[1:1]) - v1_dot_v2 = [sum(v1[i] .* v2[i]) for i in collect(1:npoints)] - mag_v1 = sqrt.([sum(v1[i].^2) for i in collect(1:npoints)]) - mag_v2 = sqrt.([sum(v2[i].^2) for i in collect(1:npoints)]) - # Protect against division by 0 caused by very close points - replace!(mag_v1, 0=>eps(FT)) - replace!(mag_v2, 0=>eps(FT)) - angles = real.( - acos.( - clamp!(v1_dot_v2 ./ mag_v1 ./ mag_v2, FT(-1), FT(1)) - ) * 180 / pi - ) - - #= The first angle computed was for the second vertex, and the last was for - the first vertex. Scroll one position down to make the last vertex be the - first. =# - sangles = circshift(angles, 1) - # Now determine if any vertices are concave and adjust angles accordingly. - sgn = convex_angle_test(coords[1]) - for i in eachindex(sangles) - sangles[i] = (sgn[i] == -1) ? (-sangles[i] + 360) : sangles[i] - end - return sangles -end \ No newline at end of file +pt1 = GI.Point((0.0, 0.0)) +l1 = GI.Line([(0.0, 0.0), (0.0, 1.0)]) + +concave_coords = [(0.0, 0.0), (0.0, 1.0), (-1.0, 1.0), (-1.0, 2.0), (2.0, 2.0), (2.0, 0.0), (0.0, 0.0)] +l2 = GI.LineString(concave_coords) +l3 = GI.LineString(concave_coords[1:(end - 1)]) +r1 = GI.LinearRing(concave_coords) +r2 = GI.LinearRing(concave_coords[1:(end - 1)]) +concave_angles = [90.0, 270.0, 90.0, 90.0, 90.0, 90.0] + +p1 = GI.Polygon([[(1.0, 1.0), (1.0, 2.0), (2.0, 2.0), (2.0, 1.0), (1.0, 1.0)]]) +p2 = GI.Polygon([[(0.0, 0.0), (0.0, 4.0), (3.0, 0.0), (0.0, 0.0)]]) +p3 = GI.Polygon([[(-3.0, -2.0), (0.0,0.0), (5.0, 0.0), (-3.0, -2.0)]]) +p4 = GI.Polygon([r1]) + +# Points and lines +@test isempty(GO.angles(pt1)) +@test isempty(GO.angles(l1)) + +# LineStrings and Linear Rings +@test all(isapprox.(GO.angles(l2), concave_angles, atol = 1e-3)) +@test all(isapprox.(GO.angles(l3), concave_angles[2:(end - 1)], atol = 1e-3)) +@test all(isapprox.(GO.angles(r1), concave_angles, atol = 1e-3)) +@test all(isapprox.(GO.angles(r2), concave_angles, atol = 1e-3)) + +# Polygons +@test all(isapprox.(GO.angles(p1)[1], [90.0, 90.0, 90.0, 90.0], atol = 1e-3)) +@test all(isapprox.(GO.angles(p2)[1], [90.0, 36.8699, 53.1301], atol = 1e-3)) +@test all(isapprox.(GO.angles(p3)[1], [19.6538, 146.3099, 14.0362], atol = 1e-3)) +@test all(isapprox.(GO.angles(p4)[1], concave_angles, atol = 1e-3)) \ No newline at end of file diff --git a/test/runtests.jl b/test/runtests.jl index e5710f4a6..72f353d88 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -15,17 +15,18 @@ const GO = GeometryOps @testset "GeometryOps.jl" begin @testset "Primitives" begin include("primitives.jl") end # # Methods - @testset "Area" begin include("methods/area.jl") end - @testset "Barycentric coordinate operations" begin include("methods/barycentric.jl") end - @testset "Bools" begin include("methods/bools.jl") end - @testset "Centroid" begin include("methods/centroid.jl") end - @testset "Distance" begin include("methods/distance.jl") end - @testset "Equals" begin include("methods/equals.jl") end - @testset "DE-9IM Geom Relations" begin include("methods/geom_relations.jl") end - # # Transformations - @testset "Embed Extent" begin include("transformations/extent.jl") end - @testset "Reproject" begin include("transformations/reproject.jl") end - @testset "Flip" begin include("transformations/flip.jl") end - @testset "Simplify" begin include("transformations/simplify.jl") end - @testset "Transform" begin include("transformations/transform.jl") end + @testset "Angles" begin include("methods/angles.jl") end + # @testset "Area" begin include("methods/area.jl") end + # @testset "Barycentric coordinate operations" begin include("methods/barycentric.jl") end + # @testset "Bools" begin include("methods/bools.jl") end + # @testset "Centroid" begin include("methods/centroid.jl") end + # @testset "Distance" begin include("methods/distance.jl") end + # @testset "Equals" begin include("methods/equals.jl") end + # @testset "DE-9IM Geom Relations" begin include("methods/geom_relations.jl") end + # # # Transformations + # @testset "Embed Extent" begin include("transformations/extent.jl") end + # @testset "Reproject" begin include("transformations/reproject.jl") end + # @testset "Flip" begin include("transformations/flip.jl") end + # @testset "Simplify" begin include("transformations/simplify.jl") end + # @testset "Transform" begin include("transformations/transform.jl") end end From 25e8934d0bfc01044efb507eb3f12b653b16393e Mon Sep 17 00:00:00 2001 From: Skylar Gering Date: Thu, 18 Jan 2024 17:51:36 -0800 Subject: [PATCH 03/12] Add tests back in --- test/runtests.jl | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/test/runtests.jl b/test/runtests.jl index 72f353d88..1bb337d63 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -16,17 +16,17 @@ const GO = GeometryOps @testset "Primitives" begin include("primitives.jl") end # # Methods @testset "Angles" begin include("methods/angles.jl") end - # @testset "Area" begin include("methods/area.jl") end - # @testset "Barycentric coordinate operations" begin include("methods/barycentric.jl") end - # @testset "Bools" begin include("methods/bools.jl") end - # @testset "Centroid" begin include("methods/centroid.jl") end - # @testset "Distance" begin include("methods/distance.jl") end - # @testset "Equals" begin include("methods/equals.jl") end - # @testset "DE-9IM Geom Relations" begin include("methods/geom_relations.jl") end - # # # Transformations - # @testset "Embed Extent" begin include("transformations/extent.jl") end - # @testset "Reproject" begin include("transformations/reproject.jl") end - # @testset "Flip" begin include("transformations/flip.jl") end - # @testset "Simplify" begin include("transformations/simplify.jl") end - # @testset "Transform" begin include("transformations/transform.jl") end + @testset "Area" begin include("methods/area.jl") end + @testset "Barycentric coordinate operations" begin include("methods/barycentric.jl") end + @testset "Bools" begin include("methods/bools.jl") end + @testset "Centroid" begin include("methods/centroid.jl") end + @testset "Distance" begin include("methods/distance.jl") end + @testset "Equals" begin include("methods/equals.jl") end + @testset "DE-9IM Geom Relations" begin include("methods/geom_relations.jl") end + # # Transformations + @testset "Embed Extent" begin include("transformations/extent.jl") end + @testset "Reproject" begin include("transformations/reproject.jl") end + @testset "Flip" begin include("transformations/flip.jl") end + @testset "Simplify" begin include("transformations/simplify.jl") end + @testset "Transform" begin include("transformations/transform.jl") end end From 1ddd181430af39f24070ff3d549aeee2032f22ab Mon Sep 17 00:00:00 2001 From: Skylar Gering Date: Mon, 22 Jan 2024 15:46:17 -0800 Subject: [PATCH 04/12] Change hole angles to interior --- src/methods/angles.jl | 44 ++++++++++++++++++++++++++---------------- test/methods/angles.jl | 22 ++++++++++++++++----- 2 files changed, 44 insertions(+), 22 deletions(-) diff --git a/src/methods/angles.jl b/src/methods/angles.jl index 55a69f5eb..fcab359f3 100644 --- a/src/methods/angles.jl +++ b/src/methods/angles.jl @@ -30,6 +30,8 @@ geometry trait. This is also used in the implementation, since it's a lot less work! =# +const _ANGLE_TARGETS = Union{GI.PolygonTrait,GI.AbstractCurveTrait,GI.MultiPointTrait,GI.PointTrait} + """ angles(geom, ::Type{T} = Float64) @@ -46,8 +48,11 @@ This is computed differently for different geometries: Result will be a Vector, or nested set of vectors, of type T where an optional argument with a default value of Float64. """ -angles(geom, ::Type{T} = Float64) where T <: AbstractFloat = - _angles(T, GI.trait(geom), geom) +function angles(geom, ::Type{T} = Float64; threaded =false) where T <: AbstractFloat + applyreduce(vcat, _ANGLE_TARGETS, geom; threaded, init = Vector{T}()) do g + _angles(T, GI.trait(g), g) + end +end # Points and single line segments have no angles _angles(::Type{T}, ::Union{GI.PointTrait, GI.LineTrait}, geom) where T = T[] @@ -55,7 +60,7 @@ _angles(::Type{T}, ::Union{GI.PointTrait, GI.LineTrait}, geom) where T = T[] #= The angles of a linestring are the angles formed by the line. If the first and last point are not explicitly repeated, the geom is not considered closed. The angles should all be on one side of the line, but a particular side is not guaranteed by this function. =# -function _angles(::Type{T}, ::Union{GI.LineStringTrait}, geom) where T +function _angles(::Type{T}, ::GI.LineStringTrait, geom) where T npoints = GI.npoint(geom) first_last_equal = equals(GI.getpoint(geom, 1), GI.getpoint(geom, npoints)) angle_list = Vector{T}(undef, npoints - (first_last_equal ? 1 : 2)) @@ -68,34 +73,39 @@ end #= The angles of a linearring are the angles within the closed line and include the angles formed by connecting the first and last points of the curve. =# -function _angles(::Type{T}, ::GI.LinearRingTrait, geom) where T +function _angles(::Type{T}, ::GI.LinearRingTrait, geom; interior = true) where T npoints = GI.npoint(geom) first_last_equal = equals(GI.getpoint(geom, 1), GI.getpoint(geom, npoints)) angle_list = Vector{T}(undef, npoints - (first_last_equal ? 1 : 0)) _find_angles!( T, angle_list, geom; - offset = true, close_geom = !first_last_equal, + offset = true, close_geom = !first_last_equal, interior = interior, ) return angle_list end -#= The angles of a polygon is a vector of lists angles of its rings. Note that -this means that the angles of any holes will be the exterior angles of the holes -outside of the geometry, rather than the interior angles=# -_angles(::Type{T}, ::GI.PolygonTrait, geom) where T = - [_angles(T, GI.LinearRingTrait(), g) for g in GI.getring(geom)] - -# Angles of a multi-geometry is simply a list of the angles of its sub-geometries. -_angles(::Type{T}, ::MultiGeomTrait, geom) where T = [angles(g, T) for g in GI.getgeom(geom)] +#= The angles of a polygon is a vector of polygon angles. Note that if there are holes +within the polyogn, the angles will be listed after the exterior ring angles in order of the +holes. All angles, including the hole angles, are interior angles of the polygon.=# +function _angles(::Type{T}, ::GI.PolygonTrait, geom) where T + angles = _angles(T, GI.LinearRingTrait(), GI.getexterior(geom); interior = true) + for h in GI.gethole(geom) + append!(angles, _angles(T, GI.LinearRingTrait(), h; interior = false)) + end + return angles +end #= Find angles of a curve and insert the values into the angle_list. If offset is true, then save space for the angle at the first vertex, as the curve is closed, at the front of angle_list. If close_geom is true, then despite the first and last point not being explicitly repeated, the curve is closed and the angle of the last point should be added to -angle_list. +angle_list. If interior is true, then all angles will be on the same side of the line =# -function _find_angles!(::Type{T}, angle_list, geom; offset, close_geom) where T +function _find_angles!( + ::Type{T}, angle_list, geom; + offset, close_geom, interior = true, +) where T local p1, prev_p1_diff, p2_p1_diff local start_point, start_diff local extreem_idx, extreem_x, extreem_y @@ -133,13 +143,13 @@ function _find_angles!(::Type{T}, angle_list, geom; offset, close_geom) where T end #= Make sure that all of the angles are on the same side of the line and inside of the closed ring if the input geometry is closed. =# - convex_sgn = sign(angle_list[extreem_idx]) + inside_sgn = sign(angle_list[extreem_idx]) * (interior ? 1 : -1) for i in eachindex(angle_list) idx_sgn = sign(angle_list[i]) if idx_sgn == -1 angle_list[i] = abs(angle_list[i]) end - if idx_sgn != convex_sgn + if idx_sgn != inside_sgn angle_list[i] = 360 - angle_list[i] end end diff --git a/test/methods/angles.jl b/test/methods/angles.jl index 98eb83f73..c61dbb6c7 100644 --- a/test/methods/angles.jl +++ b/test/methods/angles.jl @@ -6,12 +6,17 @@ l2 = GI.LineString(concave_coords) l3 = GI.LineString(concave_coords[1:(end - 1)]) r1 = GI.LinearRing(concave_coords) r2 = GI.LinearRing(concave_coords[1:(end - 1)]) +r3 = GI.LinearRing([(1.0, 1.0), (1.0, 1.5), (1.5, 1.5), (1.5, 1.0), (1.0, 1.0)]) concave_angles = [90.0, 270.0, 90.0, 90.0, 90.0, 90.0] -p1 = GI.Polygon([[(1.0, 1.0), (1.0, 2.0), (2.0, 2.0), (2.0, 1.0), (1.0, 1.0)]]) +p1 = GI.Polygon([r3]) p2 = GI.Polygon([[(0.0, 0.0), (0.0, 4.0), (3.0, 0.0), (0.0, 0.0)]]) p3 = GI.Polygon([[(-3.0, -2.0), (0.0,0.0), (5.0, 0.0), (-3.0, -2.0)]]) p4 = GI.Polygon([r1]) +p5 = GI.Polygon([r1, r3]) + +mp1 = GI.MultiPolygon([p2, p3]) +c1 = GI.GeometryCollection([pt1, l2, p2]) # Points and lines @test isempty(GO.angles(pt1)) @@ -24,7 +29,14 @@ p4 = GI.Polygon([r1]) @test all(isapprox.(GO.angles(r2), concave_angles, atol = 1e-3)) # Polygons -@test all(isapprox.(GO.angles(p1)[1], [90.0, 90.0, 90.0, 90.0], atol = 1e-3)) -@test all(isapprox.(GO.angles(p2)[1], [90.0, 36.8699, 53.1301], atol = 1e-3)) -@test all(isapprox.(GO.angles(p3)[1], [19.6538, 146.3099, 14.0362], atol = 1e-3)) -@test all(isapprox.(GO.angles(p4)[1], concave_angles, atol = 1e-3)) \ No newline at end of file +p2_angles = [90.0, 36.8699, 53.1301] +p3_angles = [19.6538, 146.3099, 14.0362] +@test all(isapprox.(GO.angles(p1), [90.0 for _ in 1:4], atol = 1e-3)) +@test all(isapprox.(GO.angles(p2), p2_angles, atol = 1e-3)) +@test all(isapprox.(GO.angles(p3), p3_angles, atol = 1e-3)) +@test all(isapprox.(GO.angles(p4), concave_angles, atol = 1e-3)) +@test all(isapprox.(GO.angles(p5), vcat(concave_angles, [270.0 for _ in 1:4]), atol = 1e-3)) + +# Multi-geometries +@test all(isapprox.(GO.angles(mp1), [p2_angles; p3_angles], atol = 1e-3)) +@test all(isapprox.(GO.angles(c1), [concave_angles; p2_angles], atol = 1e-3)) \ No newline at end of file From ac0f4b84af6a14dbbb96af545679b5638c57c9c3 Mon Sep 17 00:00:00 2001 From: Skylar Gering Date: Mon, 22 Jan 2024 19:03:54 -0800 Subject: [PATCH 05/12] Fix angle docs --- src/methods/angles.jl | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/methods/angles.jl b/src/methods/angles.jl index fcab359f3..a6362098b 100644 --- a/src/methods/angles.jl +++ b/src/methods/angles.jl @@ -17,9 +17,7 @@ f, a, p = poly(rect; axis = (; aspect = DataAspect())) ``` This is clearly a rectangle, with angles of 90 degrees. ```@example angles -lines!(a, rect; color = 1:length(coordinates(rect))+1) -f -angles(area) +angles(rect) ``` ## Implementation From 0070049efb8a09f0535dfc8f1eec67f6ff553089 Mon Sep 17 00:00:00 2001 From: Skylar Gering Date: Mon, 22 Jan 2024 19:29:45 -0800 Subject: [PATCH 06/12] Add multipoints --- src/GeometryOps.jl | 4 ---- src/methods/angles.jl | 5 +++-- test/methods/angles.jl | 2 ++ 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/src/GeometryOps.jl b/src/GeometryOps.jl index 755273966..d626e7bc2 100644 --- a/src/GeometryOps.jl +++ b/src/GeometryOps.jl @@ -17,10 +17,6 @@ const GB = GeometryBasics const TuplePoint = Tuple{Float64,Float64} const Edge = Tuple{TuplePoint,TuplePoint} -const MultiGeomTrait = Union{ - GI.MultiPointTrait, GI.MultiCurveTrait, - GI.MultiPolygonTrait, GI.GeometryCollectionTrait} - include("primitives.jl") include("utils.jl") diff --git a/src/methods/angles.jl b/src/methods/angles.jl index a6362098b..0ffb8932a 100644 --- a/src/methods/angles.jl +++ b/src/methods/angles.jl @@ -10,10 +10,11 @@ To provide an example, consider this rectangle: ```@example angles using GeometryOps using GeometryOps.GeometryBasics -using Makie +using Makie, CairoMakie rect = Polygon([Point(0,0), Point(0,1), Point(1,1), Point(1,0), Point(0, 0)]) f, a, p = poly(rect; axis = (; aspect = DataAspect())) +f ``` This is clearly a rectangle, with angles of 90 degrees. ```@example angles @@ -53,7 +54,7 @@ function angles(geom, ::Type{T} = Float64; threaded =false) where T <: AbstractF end # Points and single line segments have no angles -_angles(::Type{T}, ::Union{GI.PointTrait, GI.LineTrait}, geom) where T = T[] +_angles(::Type{T}, ::Union{GI.PointTrait, GI.MultiPointTrait, GI.LineTrait}, geom) where T = T[] #= The angles of a linestring are the angles formed by the line. If the first and last point are not explicitly repeated, the geom is not considered closed. The angles should all be on diff --git a/test/methods/angles.jl b/test/methods/angles.jl index c61dbb6c7..3b4a24854 100644 --- a/test/methods/angles.jl +++ b/test/methods/angles.jl @@ -1,4 +1,5 @@ pt1 = GI.Point((0.0, 0.0)) +mpt1 = GI.MultiPoint([pt1, pt1]) l1 = GI.Line([(0.0, 0.0), (0.0, 1.0)]) concave_coords = [(0.0, 0.0), (0.0, 1.0), (-1.0, 1.0), (-1.0, 2.0), (2.0, 2.0), (2.0, 0.0), (0.0, 0.0)] @@ -20,6 +21,7 @@ c1 = GI.GeometryCollection([pt1, l2, p2]) # Points and lines @test isempty(GO.angles(pt1)) +@test isempty(GO.angles(mpt1)) @test isempty(GO.angles(l1)) # LineStrings and Linear Rings From 2e0457eed759282e9985502257fd175301171c65 Mon Sep 17 00:00:00 2001 From: Skylar Gering Date: Tue, 23 Jan 2024 13:49:04 -0800 Subject: [PATCH 07/12] Update doc manifest --- docs/Manifest.toml | 907 ++++++++++++++++++++++++++++++--------------- 1 file changed, 606 insertions(+), 301 deletions(-) diff --git a/docs/Manifest.toml b/docs/Manifest.toml index 35f1e686a..895acb6b0 100644 --- a/docs/Manifest.toml +++ b/docs/Manifest.toml @@ -1,6 +1,6 @@ # This file is machine-generated - editing it directly is not advised -julia_version = "1.9.0" +julia_version = "1.9.2" manifest_format = "2.0" project_hash = "5c6e0f991b7e6ef7bde730ae272d855da989b6f6" @@ -11,13 +11,19 @@ version = "0.0.1" [[deps.AbstractFFTs]] deps = ["LinearAlgebra"] -git-tree-sha1 = "16b6dbc4cf7caee4e1e75c49485ec67b667098a0" +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" -version = "1.3.1" -weakdeps = ["ChainRulesCore"] +version = "1.5.0" +weakdeps = ["ChainRulesCore", "Test"] [deps.AbstractFFTs.extensions] AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + +[[deps.AbstractLattices]] +git-tree-sha1 = "222ee9e50b98f51b5d78feb93dd928880df35f06" +uuid = "398f06c4-4d28-53ec-89ca-5b2656b7603d" +version = "0.3.0" [[deps.AbstractTrees]] git-tree-sha1 = "faa260e4cb5aba097a73fab382dd4b5819d8ec8c" @@ -26,9 +32,9 @@ version = "0.4.4" [[deps.Adapt]] deps = ["LinearAlgebra", "Requires"] -git-tree-sha1 = "cc37d689f599e8df4f464b2fa3870ff7db7492ef" +git-tree-sha1 = "0fb305e0253fd4e833d486914367a2ee2c2e78d0" uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" -version = "3.6.1" +version = "4.0.1" weakdeps = ["StaticArrays"] [deps.Adapt.extensions] @@ -44,35 +50,57 @@ version = "0.4.1" uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" version = "1.1.1" +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra", "Requires", "SparseArrays", "SuiteSparse"] +git-tree-sha1 = "bbec08a37f8722786d87bedf84eae19c020c4efa" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.7.0" + + [deps.ArrayInterface.extensions] + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + [[deps.Artifacts]] uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" [[deps.Automa]] -deps = ["Printf", "ScanByte", "TranscodingStreams"] -git-tree-sha1 = "d50976f217489ce799e366d9561d56a98a30d7fe" +deps = ["PrecompileTools", "TranscodingStreams"] +git-tree-sha1 = "588e0d680ad1d7201d4c6a804dcb1cd9cba79fbb" uuid = "67c07d97-cdcb-5c2c-af73-a7f9c32a568b" -version = "0.8.2" +version = "1.0.3" [[deps.AxisAlgorithms]] deps = ["LinearAlgebra", "Random", "SparseArrays", "WoodburyMatrices"] -git-tree-sha1 = "66771c8d21c8ff5e3a93379480a2307ac36863f7" +git-tree-sha1 = "01b8ccb13d68535d73d2b0c23e39bd23155fb712" uuid = "13072b0f-2c55-5437-9ae7-d433b7a33950" -version = "1.0.1" +version = "1.1.0" [[deps.AxisArrays]] deps = ["Dates", "IntervalSets", "IterTools", "RangeArrays"] -git-tree-sha1 = "1dd4d9f5beebac0c03446918741b1a03dc5e5788" +git-tree-sha1 = "16351be62963a67ac4083f748fdb3cca58bfd52f" uuid = "39de3d68-74b9-583c-8d2d-e117c070f3a9" -version = "0.4.6" +version = "0.4.7" [[deps.Base64]] uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" [[deps.Bzip2_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "19a35467a82e236ff51bc17a3a44b69ef35185a2" +git-tree-sha1 = "9e2a6b69137e6969bab0152632dcb3bc108c8bdd" uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0" -version = "1.0.8+0" +version = "1.0.8+1" [[deps.CEnum]] git-tree-sha1 = "eb4cb44a499229b3b8426dcfb5dd85333951ff90" @@ -82,6 +110,18 @@ version = "0.4.2" [[deps.CRC32c]] uuid = "8bf52ea8-c179-5cab-976a-9e18b702a9bc" +[[deps.CRlibm]] +deps = ["CRlibm_jll"] +git-tree-sha1 = "32abd86e3c2025db5172aa182b982debed519834" +uuid = "96374032-68de-5a5b-8d9e-752f78720389" +version = "1.0.1" + +[[deps.CRlibm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "e329286945d0cfc04456972ea732551869af1cfc" +uuid = "4e9b3aee-d8a1-5a3d-ad8b-7d824db253f0" +version = "1.0.1+0" + [[deps.Cairo]] deps = ["Cairo_jll", "Colors", "Glib_jll", "Graphics", "Libdl", "Pango_jll"] git-tree-sha1 = "d0b3f8b4ad16cb0a2988c6788646a5e6a17b6b1b" @@ -89,10 +129,10 @@ uuid = "159f3aea-2a34-519c-b102-8c37f9878175" version = "1.0.5" [[deps.CairoMakie]] -deps = ["Base64", "Cairo", "Colors", "FFTW", "FileIO", "FreeType", "GeometryBasics", "LinearAlgebra", "Makie", "SHA", "SnoopPrecompile"] -git-tree-sha1 = "2aba202861fd2b7603beb80496b6566491229855" +deps = ["CRC32c", "Cairo", "Colors", "FFTW", "FileIO", "FreeType", "GeometryBasics", "LinearAlgebra", "Makie", "PrecompileTools"] +git-tree-sha1 = "ec7c21818710774e72195bda25c70fd6c56bc005" uuid = "13f3f980-e62b-5c42-98c6-ff1f3baf88f0" -version = "0.10.4" +version = "0.11.5" [[deps.Cairo_jll]] deps = ["Artifacts", "Bzip2_jll", "CompilerSupportLibraries_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "LZO_jll", "Libdl", "Pixman_jll", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"] @@ -107,10 +147,14 @@ uuid = "49dc2e85-a5d0-5ad3-a950-438e2897f1b9" version = "0.5.1" [[deps.ChainRulesCore]] -deps = ["Compat", "LinearAlgebra", "SparseArrays"] -git-tree-sha1 = "c6d890a52d2c4d55d326439580c3b8d0875a77d9" +deps = ["Compat", "LinearAlgebra"] +git-tree-sha1 = "c1deebd76f7a443d527fc0430d5758b8b2112ed8" uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" -version = "1.15.7" +version = "1.19.1" +weakdeps = ["SparseArrays"] + + [deps.ChainRulesCore.extensions] + ChainRulesCoreSparseArraysExt = "SparseArrays" [[deps.ColorBrewer]] deps = ["Colors", "JSON", "Test"] @@ -120,9 +164,9 @@ version = "0.4.0" [[deps.ColorSchemes]] deps = ["ColorTypes", "ColorVectorSpace", "Colors", "FixedPointNumbers", "PrecompileTools", "Random"] -git-tree-sha1 = "be6ab11021cd29f0344d5c4357b163af05a48cba" +git-tree-sha1 = "67c1f244b991cad9b0aa4b7540fb758c2488b129" uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4" -version = "3.21.0" +version = "3.24.0" [[deps.ColorTypes]] deps = ["FixedPointNumbers", "Random"] @@ -131,10 +175,14 @@ uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f" version = "0.11.4" [[deps.ColorVectorSpace]] -deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "SpecialFunctions", "Statistics", "TensorCore"] -git-tree-sha1 = "600cc5508d66b78aae350f7accdb58763ac18589" +deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "Requires", "Statistics", "TensorCore"] +git-tree-sha1 = "a1f44953f2382ebb937d60dafbe2deea4bd23249" uuid = "c3611d14-8923-5661-9e6a-0046d554d3a4" -version = "0.9.10" +version = "0.10.0" +weakdeps = ["SpecialFunctions"] + + [deps.ColorVectorSpace.extensions] + SpecialFunctionsExt = "SpecialFunctions" [[deps.Colors]] deps = ["ColorTypes", "FixedPointNumbers", "Reexport"] @@ -142,11 +190,22 @@ git-tree-sha1 = "fc08e5930ee9a4e03f84bfb5211cb54e7769758a" uuid = "5ae59095-9a9b-59fe-a467-6f913c188581" version = "0.12.10" +[[deps.Combinatorics]] +git-tree-sha1 = "08c8b6831dc00bfea825826be0bc8336fc369860" +uuid = "861a8166-3701-5b0c-9a16-15d98fcdc6aa" +version = "1.0.2" + +[[deps.CommonSubexpressions]] +deps = ["MacroTools", "Test"] +git-tree-sha1 = "7b8a93dba8af7e3b42fecabf646260105ac373f7" +uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" +version = "0.3.0" + [[deps.Compat]] -deps = ["UUIDs"] -git-tree-sha1 = "7a60c856b9fa189eb34f5f8a6f6b5529b7942957" +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "75bd5b6fc5089df449b5d35fa501c846c9b6549b" uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" -version = "4.6.1" +version = "4.12.0" weakdeps = ["Dates", "LinearAlgebra"] [deps.Compat.extensions] @@ -155,18 +214,18 @@ weakdeps = ["Dates", "LinearAlgebra"] [[deps.CompilerSupportLibraries_jll]] deps = ["Artifacts", "Libdl"] uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" -version = "1.0.2+0" +version = "1.0.5+0" [[deps.ConstructionBase]] deps = ["LinearAlgebra"] -git-tree-sha1 = "89a9db8d28102b094992472d333674bd1a83ce2a" +git-tree-sha1 = "c53fc348ca4d40d7b371e71fd52251839080cbc9" uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9" -version = "1.5.1" +version = "1.5.4" weakdeps = ["IntervalSets", "StaticArrays"] [deps.ConstructionBase.extensions] - IntervalSetsExt = "IntervalSets" - StaticArraysExt = "StaticArrays" + ConstructionBaseIntervalSetsExt = "IntervalSets" + ConstructionBaseStaticArraysExt = "StaticArrays" [[deps.Contour]] git-tree-sha1 = "d05d9e7b7aedff4e5b51a029dced05cfb6125781" @@ -180,15 +239,15 @@ uuid = "150eb455-5306-5404-9cee-2592286d6298" version = "0.6.3" [[deps.DataAPI]] -git-tree-sha1 = "e8119c1a33d267e16108be441a287a6981ba1630" +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" -version = "1.14.0" +version = "1.16.0" [[deps.DataStructures]] deps = ["Compat", "InteractiveUtils", "OrderedCollections"] -git-tree-sha1 = "d1fff3a548102f48987a52a2e0d114fa97d730f0" +git-tree-sha1 = "ac67408d9ddf207de5cfa9a97e114352430f01ed" uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" -version = "0.18.13" +version = "0.18.16" [[deps.DataValueInterfaces]] git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" @@ -199,23 +258,43 @@ version = "1.0.0" deps = ["Printf"] uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +[[deps.DelaunayTriangulation]] +deps = ["DataStructures", "EnumX", "ExactPredicates", "Random", "SimpleGraphs"] +git-tree-sha1 = "26eb8e2331b55735c3d305d949aabd7363f07ba7" +uuid = "927a84f5-c5f4-47a5-9785-b46e178433df" +version = "0.8.11" + +[[deps.DiffResults]] +deps = ["StaticArraysCore"] +git-tree-sha1 = "782dd5f4561f5d267313f23853baaaa4c52ea621" +uuid = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" +version = "1.1.0" + +[[deps.DiffRules]] +deps = ["IrrationalConstants", "LogExpFunctions", "NaNMath", "Random", "SpecialFunctions"] +git-tree-sha1 = "23163d55f885173722d1e4cf0f6110cdbaf7e272" +uuid = "b552c78f-8df3-52c6-915a-8e097449b14b" +version = "1.15.1" + [[deps.Distributed]] deps = ["Random", "Serialization", "Sockets"] uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" [[deps.Distributions]] -deps = ["FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SparseArrays", "SpecialFunctions", "Statistics", "StatsBase", "StatsFuns", "Test"] -git-tree-sha1 = "180538ef4e3aa02b01413055a7a9e8b6047663e1" +deps = ["FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"] +git-tree-sha1 = "7c302d7a5fec5214eb8a5a4c466dcf7a51fcf169" uuid = "31c24e10-a181-5473-b8eb-7969acd0382f" -version = "0.25.88" +version = "0.25.107" [deps.Distributions.extensions] DistributionsChainRulesCoreExt = "ChainRulesCore" DistributionsDensityInterfaceExt = "DensityInterface" + DistributionsTestExt = "Test" [deps.Distributions.weakdeps] ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" DensityInterface = "b429d917-457f-4dbc-8f4c-0cc954292b1d" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" [[deps.DocStringExtensions]] deps = ["LibGit2"] @@ -224,10 +303,10 @@ uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" version = "0.9.3" [[deps.Documenter]] -deps = ["ANSIColoredPrinters", "Base64", "Dates", "DocStringExtensions", "IOCapture", "InteractiveUtils", "JSON", "LibGit2", "Logging", "Markdown", "REPL", "Test", "Unicode"] -git-tree-sha1 = "58fea7c536acd71f3eef6be3b21c0df5f3df88fd" +deps = ["ANSIColoredPrinters", "AbstractTrees", "Base64", "Dates", "DocStringExtensions", "Downloads", "Git", "IOCapture", "InteractiveUtils", "JSON", "LibGit2", "Logging", "Markdown", "MarkdownAST", "Pkg", "PrecompileTools", "REPL", "RegistryInstances", "SHA", "Test", "Unicode"] +git-tree-sha1 = "2613dbec8f4748273bbe30ba71fd5cb369966bac" uuid = "e30172f5-a6a5-5a46-863b-614d45cd2de4" -version = "0.27.24" +version = "1.2.1" [[deps.Downloads]] deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] @@ -246,34 +325,39 @@ git-tree-sha1 = "e3290f2d49e661fbd94046d7e3726ffcb2d41053" uuid = "5ae413db-bbd1-5e63-b57d-d24a61df00f5" version = "2.2.4+0" +[[deps.EnumX]] +git-tree-sha1 = "bdb1942cd4c45e3c678fd11569d5cccd80976237" +uuid = "4e289a0a-7415-4d19-859d-a7e5c4648b56" +version = "1.0.4" + +[[deps.ExactPredicates]] +deps = ["IntervalArithmetic", "Random", "StaticArrays"] +git-tree-sha1 = "e8b8c949551f417e040f16e5c431b6e83e306e54" +uuid = "429591f6-91af-11e9-00e2-59fbe8cec110" +version = "2.2.7" + [[deps.Expat_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "bad72f730e9e91c08d9427d5e8db95478a3c323d" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "4558ab818dcceaab612d1bb8c19cee87eda2b83c" uuid = "2e619515-83b5-522b-bb60-26c02a35a201" -version = "2.4.8+0" +version = "2.5.0+0" [[deps.Extents]] -git-tree-sha1 = "5e1e4c53fa39afe63a7d356e30452249365fba99" +git-tree-sha1 = "2140cd04483da90b2da7f99b2add0750504fc39c" uuid = "411431e0-e8b7-467b-b5e0-f676ba4f2910" -version = "0.1.1" - -[[deps.FFMPEG]] -deps = ["FFMPEG_jll"] -git-tree-sha1 = "b57e3acbe22f8484b4b5ff66a7499717fe1a9cc8" -uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a" -version = "0.4.1" +version = "0.1.2" [[deps.FFMPEG_jll]] -deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "PCRE2_jll", "Pkg", "Zlib_jll", "libaom_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"] -git-tree-sha1 = "74faea50c1d007c85837327f6775bea60b5492dd" +deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "PCRE2_jll", "Zlib_jll", "libaom_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"] +git-tree-sha1 = "466d45dc38e15794ec7d5d63ec03d776a9aff36e" uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5" -version = "4.4.2+2" +version = "4.4.4+1" [[deps.FFTW]] deps = ["AbstractFFTs", "FFTW_jll", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] -git-tree-sha1 = "f9818144ce7c8c41edf5c4c179c684d92aa4d9fe" +git-tree-sha1 = "4820348781ae578893311153d69049a93d05f39d" uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" -version = "1.6.0" +version = "1.8.0" [[deps.FFTW_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -283,18 +367,52 @@ version = "3.3.10+0" [[deps.FileIO]] deps = ["Pkg", "Requires", "UUIDs"] -git-tree-sha1 = "299dc33549f68299137e51e6d49a13b5b1da9673" +git-tree-sha1 = "c5c28c245101bd59154f649e19b038d15901b5dc" uuid = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" -version = "1.16.1" +version = "1.16.2" + +[[deps.FilePaths]] +deps = ["FilePathsBase", "MacroTools", "Reexport", "Requires"] +git-tree-sha1 = "919d9412dbf53a2e6fe74af62a73ceed0bce0629" +uuid = "8fc22ac5-c921-52a6-82fd-178b2807b824" +version = "0.8.3" + +[[deps.FilePathsBase]] +deps = ["Compat", "Dates", "Mmap", "Printf", "Test", "UUIDs"] +git-tree-sha1 = "9f00e42f8d99fdde64d40c8ea5d14269a2e2c1aa" +uuid = "48062228-2e41-5def-b9a4-89aafe57970f" +version = "0.9.21" [[deps.FileWatching]] uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" [[deps.FillArrays]] -deps = ["LinearAlgebra", "Random", "SparseArrays", "Statistics"] -git-tree-sha1 = "fc86b4fd3eff76c3ce4f5e96e2fdfa6282722885" +deps = ["LinearAlgebra", "Random"] +git-tree-sha1 = "5b93957f6dcd33fc343044af3d48c215be2562f1" uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" -version = "1.0.0" +version = "1.9.3" +weakdeps = ["PDMats", "SparseArrays", "Statistics"] + + [deps.FillArrays.extensions] + FillArraysPDMatsExt = "PDMats" + FillArraysSparseArraysExt = "SparseArrays" + FillArraysStatisticsExt = "Statistics" + +[[deps.FiniteDiff]] +deps = ["ArrayInterface", "LinearAlgebra", "Requires", "Setfield", "SparseArrays"] +git-tree-sha1 = "73d1214fec245096717847c62d389a5d2ac86504" +uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" +version = "2.22.0" + + [deps.FiniteDiff.extensions] + FiniteDiffBandedMatricesExt = "BandedMatrices" + FiniteDiffBlockBandedMatricesExt = "BlockBandedMatrices" + FiniteDiffStaticArraysExt = "StaticArrays" + + [deps.FiniteDiff.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" [[deps.FixedPointNumbers]] deps = ["Statistics"] @@ -314,23 +432,33 @@ git-tree-sha1 = "8339d61043228fdd3eb658d86c926cb282ae72a8" uuid = "59287772-0a20-5a39-b81b-1366585eb4c0" version = "0.4.2" +[[deps.ForwardDiff]] +deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] +git-tree-sha1 = "cf0fe81336da9fb90944683b8c41984b08793dad" +uuid = "f6369f11-7733-5829-9624-2563aa707210" +version = "0.10.36" +weakdeps = ["StaticArrays"] + + [deps.ForwardDiff.extensions] + ForwardDiffStaticArraysExt = "StaticArrays" + [[deps.FreeType]] deps = ["CEnum", "FreeType2_jll"] -git-tree-sha1 = "cabd77ab6a6fdff49bfd24af2ebe76e6e018a2b4" +git-tree-sha1 = "907369da0f8e80728ab49c1c7e09327bf0d6d999" uuid = "b38be410-82b0-50bf-ab77-7b57e271db43" -version = "4.0.0" +version = "4.1.1" [[deps.FreeType2_jll]] -deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"] -git-tree-sha1 = "87eb71354d8ec1a96d4a7636bd57a7347dde3ef9" +deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "d8db6a5a2fe1381c1ea4ef2cab7c69c2de7f9ea0" uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7" -version = "2.10.4+0" +version = "2.13.1+0" [[deps.FreeTypeAbstraction]] deps = ["ColorVectorSpace", "Colors", "FreeType", "GeometryBasics"] -git-tree-sha1 = "38a92e40157100e796690421e34a11c107205c86" +git-tree-sha1 = "055626e1a35f6771fe99060e835b72ca61a52621" uuid = "663a7486-cb36-511b-a19d-713bb74d65c9" -version = "0.10.0" +version = "0.10.1" [[deps.FriBidi_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -344,29 +472,29 @@ uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820" [[deps.GPUArraysCore]] deps = ["Adapt"] -git-tree-sha1 = "1cd7f0af1aa58abc02ea1d872953a97359cb87fa" +git-tree-sha1 = "ec632f177c0d990e64d955ccc1b8c04c485a0950" uuid = "46192b85-c4d5-4398-a991-12ede77f4527" -version = "0.1.4" +version = "0.1.6" [[deps.GeoFormatTypes]] -git-tree-sha1 = "434166198434a5c2fcc0a1a59d22c3b0ad460889" +git-tree-sha1 = "59107c179a586f0fe667024c5eb7033e81333271" uuid = "68eda718-8dee-11e9-39e7-89f7f65f511f" -version = "0.4.1" +version = "0.4.2" [[deps.GeoInterface]] deps = ["Extents"] -git-tree-sha1 = "bb198ff907228523f3dee1070ceee63b9359b6ab" +git-tree-sha1 = "d4f85701f569584f2cff7ba67a137d03f0cfb7d0" uuid = "cf35fbd7-0cd7-5166-be24-54bfbe79505f" -version = "1.3.1" +version = "1.3.3" [[deps.GeometryBasics]] -deps = ["EarCut_jll", "GeoInterface", "IterTools", "LinearAlgebra", "StaticArrays", "StructArrays", "Tables"] -git-tree-sha1 = "659140c9375afa2f685e37c1a0b9c9a60ef56b40" +deps = ["EarCut_jll", "Extents", "GeoInterface", "IterTools", "LinearAlgebra", "StaticArrays", "StructArrays", "Tables"] +git-tree-sha1 = "424a5a6ce7c5d97cca7bcc4eac551b97294c54af" uuid = "5c1252a2-5f33-56bf-86c9-59e7332b4326" -version = "0.4.7" +version = "0.4.9" [[deps.GeometryOps]] -deps = ["GeoInterface", "GeometryBasics", "Proj"] +deps = ["ExactPredicates", "GeoInterface", "GeometryBasics", "LinearAlgebra", "Proj", "Statistics"] path = ".." uuid = "3251bfac-6a57-4b6d-aa61-ac1fef2975ab" version = "0.0.1-DEV" @@ -377,11 +505,23 @@ git-tree-sha1 = "9b02998aba7bf074d14de89f9d37ca24a1a0b046" uuid = "78b55507-aeef-58d4-861c-77aaff3498b1" version = "0.21.0+0" +[[deps.Git]] +deps = ["Git_jll"] +git-tree-sha1 = "51764e6c2e84c37055e846c516e9015b4a291c7d" +uuid = "d7ba0133-e1db-5d97-8f8c-041e4b3a1eb2" +version = "1.3.0" + +[[deps.Git_jll]] +deps = ["Artifacts", "Expat_jll", "JLLWrappers", "LibCURL_jll", "Libdl", "Libiconv_jll", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +git-tree-sha1 = "b30c473c97fcc1e1e44fab8f3e88fd1b89c9e9d1" +uuid = "f8c6e375-362e-5223-8a59-34ff63f689eb" +version = "2.43.0+0" + [[deps.Glib_jll]] -deps = ["Artifacts", "Gettext_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE2_jll", "Pkg", "Zlib_jll"] -git-tree-sha1 = "d3b3624125c1474292d0d8ed0f65554ac37ddb23" +deps = ["Artifacts", "Gettext_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE2_jll", "Zlib_jll"] +git-tree-sha1 = "e94c92c7bf4819685eb80186d51c43e71d4afa17" uuid = "7746bdde-850d-59dc-9ae8-88ece973131d" -version = "2.74.0+2" +version = "2.76.5+0" [[deps.Graphics]] deps = ["Colors", "LinearAlgebra", "NaNMath"] @@ -397,9 +537,9 @@ version = "1.3.14+0" [[deps.GridLayoutBase]] deps = ["GeometryBasics", "InteractiveUtils", "Observables"] -git-tree-sha1 = "678d136003ed5bceaab05cf64519e3f956ffa4ba" +git-tree-sha1 = "af13a277efd8a6e716d79ef635d5342ccb75be61" uuid = "3955a311-db13-416c-9275-1d80ed98e5e9" -version = "0.9.1" +version = "0.10.0" [[deps.Grisu]] git-tree-sha1 = "53bb909d1151e57e2484c3d1b53e19552b887fb2" @@ -414,45 +554,45 @@ version = "2.8.1+1" [[deps.HypergeometricFunctions]] deps = ["DualNumbers", "LinearAlgebra", "OpenLibm_jll", "SpecialFunctions"] -git-tree-sha1 = "432b5b03176f8182bd6841fbfc42c718506a2d5f" +git-tree-sha1 = "f218fe3736ddf977e0e772bc9a586b2383da2685" uuid = "34004b35-14d8-5ef3-9330-4cdb6864b03a" -version = "0.3.15" +version = "0.3.23" [[deps.IOCapture]] deps = ["Logging", "Random"] -git-tree-sha1 = "f7be53659ab06ddc986428d3a9dcc95f6fa6705a" +git-tree-sha1 = "8b72179abc660bfab5e28472e019392b97d0985c" uuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89" -version = "0.2.2" +version = "0.2.4" [[deps.ImageAxes]] deps = ["AxisArrays", "ImageBase", "ImageCore", "Reexport", "SimpleTraits"] -git-tree-sha1 = "c54b581a83008dc7f292e205f4c409ab5caa0f04" +git-tree-sha1 = "2e4520d67b0cef90865b3ef727594d2a58e0e1f8" uuid = "2803e5a7-5153-5ecf-9a86-9b4c37f5f5ac" -version = "0.6.10" +version = "0.6.11" [[deps.ImageBase]] deps = ["ImageCore", "Reexport"] -git-tree-sha1 = "b51bb8cae22c66d0f6357e3bcb6363145ef20835" +git-tree-sha1 = "eb49b82c172811fd2c86759fa0553a2221feb909" uuid = "c817782e-172a-44cc-b673-b171935fbb9e" -version = "0.1.5" +version = "0.1.7" [[deps.ImageCore]] -deps = ["AbstractFFTs", "ColorVectorSpace", "Colors", "FixedPointNumbers", "Graphics", "MappedArrays", "MosaicViews", "OffsetArrays", "PaddedViews", "Reexport"] -git-tree-sha1 = "acf614720ef026d38400b3817614c45882d75500" +deps = ["AbstractFFTs", "ColorVectorSpace", "Colors", "FixedPointNumbers", "MappedArrays", "MosaicViews", "OffsetArrays", "PaddedViews", "PrecompileTools", "Reexport"] +git-tree-sha1 = "fc5d1d3443a124fde6e92d0260cd9e064eba69f8" uuid = "a09fc81d-aa75-5fe9-8630-4744c3626534" -version = "0.9.4" +version = "0.10.1" [[deps.ImageIO]] deps = ["FileIO", "IndirectArrays", "JpegTurbo", "LazyModules", "Netpbm", "OpenEXR", "PNGFiles", "QOI", "Sixel", "TiffImages", "UUIDs"] -git-tree-sha1 = "342f789fd041a55166764c351da1710db97ce0e0" +git-tree-sha1 = "bca20b2f5d00c4fbc192c3212da8fa79f4688009" uuid = "82e4d734-157c-48bb-816b-45c225c6df19" -version = "0.6.6" +version = "0.6.7" [[deps.ImageMetadata]] deps = ["AxisArrays", "ImageAxes", "ImageBase", "ImageCore"] -git-tree-sha1 = "36cbaebed194b292590cba2593da27b34763804a" +git-tree-sha1 = "355e2b974f2e3212a75dfb60519de21361ad3cb7" uuid = "bc367c6b-8a6b-528e-b4bd-a4b897500b49" -version = "0.9.8" +version = "0.9.9" [[deps.Imath_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] @@ -466,15 +606,20 @@ uuid = "9b13fd28-a010-5f03-acff-a1bbcff69959" version = "1.0.0" [[deps.Inflate]] -git-tree-sha1 = "5cd07aab533df5170988219191dfad0519391428" +git-tree-sha1 = "ea8031dea4aff6bd41f1df8f2fdfb25b33626381" uuid = "d25df0c9-e2be-5dd7-82c8-3ad0b3e990b9" -version = "0.1.3" +version = "0.1.4" + +[[deps.IntegerMathUtils]] +git-tree-sha1 = "b8ffb903da9f7b8cf695a8bead8e01814aa24b30" +uuid = "18e54dd8-cb9d-406c-a71d-865a43cbb235" +version = "0.1.2" [[deps.IntelOpenMP_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "0cb9352ef2e01574eeebdb102948a58740dcaf83" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "5fdf2fe6724d8caabf43b557b84ce53f3b7e2f6b" uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" -version = "2023.1.0+0" +version = "2024.0.2+0" [[deps.InteractiveUtils]] deps = ["Markdown"] @@ -482,15 +627,36 @@ uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" [[deps.Interpolations]] deps = ["Adapt", "AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "Requires", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"] -git-tree-sha1 = "721ec2cf720536ad005cb38f50dbba7b02419a15" +git-tree-sha1 = "88a101217d7cb38a7b481ccd50d21876e1d1b0e0" uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59" -version = "0.14.7" +version = "0.15.1" + + [deps.Interpolations.extensions] + InterpolationsUnitfulExt = "Unitful" + + [deps.Interpolations.weakdeps] + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.IntervalArithmetic]] +deps = ["CRlibm", "RoundingEmulator"] +git-tree-sha1 = "c274ec586ea58eb7b42afd0c5d67e50ff50229b5" +uuid = "d1acc4aa-44c8-5952-acd4-ba5d80a2a253" +version = "0.22.5" +weakdeps = ["DiffRules", "RecipesBase"] + + [deps.IntervalArithmetic.extensions] + IntervalArithmeticDiffRulesExt = "DiffRules" + IntervalArithmeticRecipesBaseExt = "RecipesBase" [[deps.IntervalSets]] -deps = ["Dates", "Random", "Statistics"] -git-tree-sha1 = "16c0cc91853084cb5f58a78bd209513900206ce6" +deps = ["Dates", "Random"] +git-tree-sha1 = "3d8866c029dd6b16e69e0d4a939c4dfcb98fac47" uuid = "8197267c-284f-5f27-9208-e0e47529a953" -version = "0.7.4" +version = "0.7.8" +weakdeps = ["Statistics"] + + [deps.IntervalSets.extensions] + IntervalSetsStatisticsExt = "Statistics" [[deps.IrrationalConstants]] git-tree-sha1 = "630b497eafcc20001bba38a4651b327dcfc491d2" @@ -504,9 +670,9 @@ uuid = "f1662d9f-8043-43de-a69a-05efc1cc6ff4" version = "0.1.1" [[deps.IterTools]] -git-tree-sha1 = "fa6287a4469f5e048d763df38279ee729fbd44e5" +git-tree-sha1 = "42d5f897009e7ff2cf88db414a389e5ed1bdd023" uuid = "c8e1da08-722c-5040-9ed9-7db0dc04731e" -version = "1.4.0" +version = "1.10.0" [[deps.IteratorInterfaceExtensions]] git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" @@ -514,10 +680,10 @@ uuid = "82899510-4779-5014-852e-03e436cf321d" version = "1.0.0" [[deps.JLLWrappers]] -deps = ["Preferences"] -git-tree-sha1 = "abc9885a7ca2052a736a600f7fa66209f96506e1" +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7e5d6779a1e09a36db2a7b6cff50942a0a7d0fca" uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" -version = "1.4.1" +version = "1.5.0" [[deps.JSON]] deps = ["Dates", "Mmap", "Parsers", "Unicode"] @@ -527,21 +693,21 @@ version = "0.21.4" [[deps.JpegTurbo]] deps = ["CEnum", "FileIO", "ImageCore", "JpegTurbo_jll", "TOML"] -git-tree-sha1 = "106b6aa272f294ba47e96bd3acbabdc0407b5c60" +git-tree-sha1 = "fa6d0bcff8583bac20f1ffa708c3913ca605c611" uuid = "b835a17e-a41a-41e7-81f0-2f016b05efe0" -version = "0.1.2" +version = "0.1.5" [[deps.JpegTurbo_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "6f2675ef130a300a112286de91973805fcc5ffbc" +git-tree-sha1 = "60b1194df0a3298f460063de985eae7b01bc011a" uuid = "aacddb02-875f-59d6-b918-886e6ef4fbf8" -version = "2.1.91+0" +version = "3.0.1+0" [[deps.KernelDensity]] deps = ["Distributions", "DocStringExtensions", "FFTW", "Interpolations", "StatsBase"] -git-tree-sha1 = "90442c50e202a5cdf21a7899c66b240fdef14035" +git-tree-sha1 = "fee018a29b60733876eb557804b5b109dd3dd8a7" uuid = "5ab0869b-81aa-558d-bb23-cbf5423bbe9b" -version = "0.6.7" +version = "0.6.8" [[deps.LAME_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -555,6 +721,12 @@ git-tree-sha1 = "bf36f528eec6634efc60d7ec062008f171071434" uuid = "88015f11-f218-50d7-93a8-a6af411a945d" version = "3.0.0+1" +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d986ce2d884d49126836ea94ed5bfb0f12679713" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "15.0.7+0" + [[deps.LZO_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] git-tree-sha1 = "e5b909bcf985c5e2605737d2ce278ed791b89be6" @@ -562,9 +734,14 @@ uuid = "dd4b983a-f0e5-5f8d-a1b7-129d4a5fb1ac" version = "2.10.1+0" [[deps.LaTeXStrings]] -git-tree-sha1 = "f2355693d6778a178ade15952b7ac47a4ff97996" +git-tree-sha1 = "50901ebc375ed41dbf8058da26f9de442febbbec" uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" -version = "1.3.0" +version = "1.3.1" + +[[deps.LazilyInitializedFields]] +git-tree-sha1 = "8f7f3cabab0fd1800699663533b6d5cb3fc0e612" +uuid = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" +version = "1.2.2" [[deps.LazyArtifacts]] deps = ["Artifacts", "Pkg"] @@ -616,10 +793,10 @@ uuid = "7add5ba3-2f88-524e-9cd5-f83b8a55f7b8" version = "1.42.0+0" [[deps.Libiconv_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "c7cb1f5d892775ba13767a87c7ada0b980ea0a71" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "f9557a255370125b405568f9767d6d195822a175" uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" -version = "1.16.1+2" +version = "1.17.0+0" [[deps.Libmount_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -628,10 +805,10 @@ uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9" version = "2.35.0+0" [[deps.Libtiff_jll]] -deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "LERC_jll", "Libdl", "Pkg", "Zlib_jll", "Zstd_jll"] -git-tree-sha1 = "3eb79b0ca5764d4799c06699573fd8f533259713" +deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "LERC_jll", "Libdl", "XZ_jll", "Zlib_jll", "Zstd_jll"] +git-tree-sha1 = "6355fb9a4d22d867318db186fd09b09b35bd2ed7" uuid = "89763e89-9b03-5906-acba-b20f662cd828" -version = "4.4.0+0" +version = "4.6.0+0" [[deps.Libuuid_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -639,21 +816,39 @@ git-tree-sha1 = "7f3efec06033682db852f8b3bc3c1d2b0a0ab066" uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700" version = "2.36.0+0" +[[deps.LightXML]] +deps = ["Libdl", "XML2_jll"] +git-tree-sha1 = "3a994404d3f6709610701c7dabfc03fed87a81f8" +uuid = "9c8b4983-aa76-5018-a973-4c85ecc9e179" +version = "0.9.1" + +[[deps.LineSearches]] +deps = ["LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "Printf"] +git-tree-sha1 = "7bbea35cec17305fc70a0e5b4641477dc0789d9d" +uuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" +version = "7.2.0" + [[deps.LinearAlgebra]] deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +[[deps.LinearAlgebraX]] +deps = ["LinearAlgebra", "Mods", "Primes", "SimplePolynomials"] +git-tree-sha1 = "d76cec8007ec123c2b681269d40f94b053473fcf" +uuid = "9b3f67b0-2d00-526e-9884-9e4938f8fb88" +version = "0.2.7" + [[deps.Literate]] deps = ["Base64", "IOCapture", "JSON", "REPL"] -git-tree-sha1 = "1c4418beaa6664041e0f9b48f0710f57bff2fcbe" +git-tree-sha1 = "bad26f1ccd99c553886ec0725e99a509589dcd11" uuid = "98b081ad-f1c9-55d3-8b20-4c87d4299306" -version = "2.14.0" +version = "2.16.1" [[deps.LogExpFunctions]] deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] -git-tree-sha1 = "0a1b7c2863e44523180fdb3146534e265a91870b" +git-tree-sha1 = "7d6dd4e9212aebaeed356de34ccf262a3cd415aa" uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" -version = "0.3.23" +version = "0.3.26" [deps.LogExpFunctions.extensions] LogExpFunctionsChainRulesCoreExt = "ChainRulesCore" @@ -669,60 +864,55 @@ version = "0.3.23" uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" [[deps.MKL_jll]] -deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "Pkg"] -git-tree-sha1 = "2ce8695e1e699b68702c03402672a69f54b8aca9" +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "72dc3cf284559eb8f53aa593fe62cb33f83ed0c0" uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" -version = "2022.2.0+0" +version = "2024.0.0+0" [[deps.MacroTools]] deps = ["Markdown", "Random"] -git-tree-sha1 = "42324d08725e200c23d4dfb549e0d5d89dede2d2" +git-tree-sha1 = "2fa9ee3e63fd3a4f7a9a4f4744a52f4856de82df" uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" -version = "0.5.10" +version = "0.5.13" [[deps.Makie]] -deps = ["Animations", "Base64", "ColorBrewer", "ColorSchemes", "ColorTypes", "Colors", "Contour", "Distributions", "DocStringExtensions", "Downloads", "FFMPEG", "FileIO", "FixedPointNumbers", "Formatting", "FreeType", "FreeTypeAbstraction", "GeometryBasics", "GridLayoutBase", "ImageIO", "InteractiveUtils", "IntervalSets", "Isoband", "KernelDensity", "LaTeXStrings", "LinearAlgebra", "MakieCore", "Markdown", "Match", "MathTeXEngine", "MiniQhull", "Observables", "OffsetArrays", "Packing", "PlotUtils", "PolygonOps", "Printf", "Random", "RelocatableFolders", "Setfield", "Showoff", "SignedDistanceFields", "SnoopPrecompile", "SparseArrays", "StableHashTraits", "Statistics", "StatsBase", "StatsFuns", "StructArrays", "TriplotBase", "UnicodeFun"] -git-tree-sha1 = "74657542dc85c3b72b8a5a9392d57713d8b7a999" +deps = ["Animations", "Base64", "CRC32c", "ColorBrewer", "ColorSchemes", "ColorTypes", "Colors", "Contour", "DelaunayTriangulation", "Distributions", "DocStringExtensions", "Downloads", "FFMPEG_jll", "FileIO", "FilePaths", "FixedPointNumbers", "Formatting", "FreeType", "FreeTypeAbstraction", "GeometryBasics", "GridLayoutBase", "ImageIO", "InteractiveUtils", "IntervalSets", "Isoband", "KernelDensity", "LaTeXStrings", "LinearAlgebra", "MacroTools", "MakieCore", "Markdown", "MathTeXEngine", "Observables", "OffsetArrays", "Packing", "PlotUtils", "PolygonOps", "PrecompileTools", "Printf", "REPL", "Random", "RelocatableFolders", "Scratch", "Setfield", "ShaderAbstractions", "Showoff", "SignedDistanceFields", "SparseArrays", "StableHashTraits", "Statistics", "StatsBase", "StatsFuns", "StructArrays", "TriplotBase", "UnicodeFun"] +git-tree-sha1 = "a37c6610dd20425b131caf65d52abdf859da5ab1" uuid = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" -version = "0.19.4" +version = "0.20.4" [[deps.MakieCore]] -deps = ["Observables"] -git-tree-sha1 = "9926529455a331ed73c19ff06d16906737a876ed" +deps = ["Observables", "REPL"] +git-tree-sha1 = "ec5db7bb2dc9b85072658dcb2d3ad09569b09ac9" uuid = "20f20a25-4f0e-4fdf-b5d1-57303727442b" -version = "0.6.3" +version = "0.7.2" [[deps.MappedArrays]] -git-tree-sha1 = "e8b359ef06ec72e8c030463fe02efe5527ee5142" +git-tree-sha1 = "2dab0221fe2b0f2cb6754eaa743cc266339f527e" uuid = "dbb5928d-eab1-5f90-85c2-b9b0edb7c900" -version = "0.4.1" +version = "0.4.2" [[deps.Markdown]] deps = ["Base64"] uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" -[[deps.Match]] -git-tree-sha1 = "1d9bc5c1a6e7ee24effb93f175c9342f9154d97f" -uuid = "7eb4fadd-790c-5f42-8a69-bfa0b872bfbf" -version = "1.2.0" +[[deps.MarkdownAST]] +deps = ["AbstractTrees", "Markdown"] +git-tree-sha1 = "465a70f0fc7d443a00dcdc3267a497397b8a3899" +uuid = "d0879d2d-cac2-40c8-9cee-1863dc0c7391" +version = "0.1.2" [[deps.MathTeXEngine]] -deps = ["AbstractTrees", "Automa", "DataStructures", "FreeTypeAbstraction", "GeometryBasics", "LaTeXStrings", "REPL", "RelocatableFolders", "Test", "UnicodeFun"] -git-tree-sha1 = "8f52dbaa1351ce4cb847d95568cb29e62a307d93" +deps = ["AbstractTrees", "Automa", "DataStructures", "FreeTypeAbstraction", "GeometryBasics", "LaTeXStrings", "REPL", "RelocatableFolders", "UnicodeFun"] +git-tree-sha1 = "96ca8a313eb6437db5ffe946c457a401bbb8ce1d" uuid = "0a4f8689-d25c-4efe-a92b-7142dfc1aa53" -version = "0.5.6" +version = "0.5.7" [[deps.MbedTLS_jll]] deps = ["Artifacts", "Libdl"] uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" version = "2.28.2+0" -[[deps.MiniQhull]] -deps = ["QhullMiniWrapper_jll"] -git-tree-sha1 = "9dc837d180ee49eeb7c8b77bb1c860452634b0d1" -uuid = "978d7f02-9e05-4691-894f-ae31a51d76ca" -version = "0.4.0" - [[deps.Missings]] deps = ["DataAPI"] git-tree-sha1 = "f66bdc5de519e8f8ae43bdc598782d35a25b1272" @@ -732,6 +922,11 @@ version = "1.1.0" [[deps.Mmap]] uuid = "a63ad114-7e13-5084-954f-fe012c677804" +[[deps.Mods]] +git-tree-sha1 = "924f962b524a71eef7a21dae1e6853817f9b658f" +uuid = "7475f97c-0381-53b1-977b-4c60186c8d62" +version = "2.2.4" + [[deps.MosaicViews]] deps = ["MappedArrays", "OffsetArrays", "PaddedViews", "StackViews"] git-tree-sha1 = "7b86a5d4d70a9f5cdf2dacb3cbe6d251d1a61dbe" @@ -742,6 +937,17 @@ version = "0.3.4" uuid = "14a3606d-f60d-562e-9121-12d972cd8159" version = "2022.10.11" +[[deps.Multisets]] +git-tree-sha1 = "8d852646862c96e226367ad10c8af56099b4047e" +uuid = "3b2b4ff1-bcff-5658-a3ee-dbcf1ce5ac09" +version = "0.4.4" + +[[deps.NLSolversBase]] +deps = ["DiffResults", "Distributed", "FiniteDiff", "ForwardDiff"] +git-tree-sha1 = "a0b464d183da839699f4c79e7606d9d186ec172c" +uuid = "d41bc354-129a-5804-8e4c-c37616107c6c" +version = "7.8.3" + [[deps.NaNMath]] deps = ["OpenLibm_jll"] git-tree-sha1 = "0877504529a3e5c3343c6f8b4c0381e57e4387e4" @@ -750,24 +956,27 @@ version = "1.0.2" [[deps.Netpbm]] deps = ["FileIO", "ImageCore", "ImageMetadata"] -git-tree-sha1 = "5ae7ca23e13855b3aba94550f26146c01d259267" +git-tree-sha1 = "d92b107dbb887293622df7697a2223f9f8176fcd" uuid = "f09324ee-3d7c-5217-9330-fc30815ba969" -version = "1.1.0" +version = "1.1.1" [[deps.NetworkOptions]] uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" version = "1.2.0" [[deps.Observables]] -git-tree-sha1 = "6862738f9796b3edc1c09d0890afce4eca9e7e93" +git-tree-sha1 = "7438a59546cf62428fc9d1bc94729146d37a7225" uuid = "510215fc-4207-5dde-b226-833fc4488ee2" -version = "0.5.4" +version = "0.5.5" [[deps.OffsetArrays]] -deps = ["Adapt"] -git-tree-sha1 = "82d7c9e310fe55aa54996e6f7f94674e2a38fcb4" +git-tree-sha1 = "6a731f2b5c03157418a20c12195eb4b74c8f8621" uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" -version = "1.12.9" +version = "1.13.0" +weakdeps = ["Adapt"] + + [deps.OffsetArrays.extensions] + OffsetArraysAdaptExt = "Adapt" [[deps.Ogg_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -798,10 +1007,10 @@ uuid = "05823500-19ac-5b8b-9628-191a04bc5112" version = "0.8.1+0" [[deps.OpenSSL_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "9ff31d101d987eb9d66bd8b176ac7c277beccd09" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "cc6e1927ac521b659af340e0ca45828a3ffc748f" uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" -version = "1.1.20+0" +version = "3.0.12+0" [[deps.OpenSpecFun_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] @@ -809,6 +1018,12 @@ git-tree-sha1 = "13652491f6856acfd2db29360e1bbcd4565d04f1" uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e" version = "0.5.5+0" +[[deps.Optim]] +deps = ["Compat", "FillArrays", "ForwardDiff", "LineSearches", "LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "PositiveFactorizations", "Printf", "SparseArrays", "StatsBase"] +git-tree-sha1 = "01f85d9269b13fedc61e63cc72ee2213565f7a72" +uuid = "429524aa-4258-5aef-a3af-852621145aeb" +version = "1.7.8" + [[deps.Opus_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] git-tree-sha1 = "51a08fb14ec28da2ec7a927c4337e4332c2a4720" @@ -816,9 +1031,9 @@ uuid = "91d4177d-7536-5919-b921-800302f37372" version = "1.3.2+0" [[deps.OrderedCollections]] -git-tree-sha1 = "d321bf2de576bf25ec4d3e4360faca399afca282" +git-tree-sha1 = "dfdf5519f235516220579f949664f1bf44e741c5" uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" -version = "1.6.0" +version = "1.6.3" [[deps.PCRE2_jll]] deps = ["Artifacts", "Libdl"] @@ -827,21 +1042,21 @@ version = "10.42.0+0" [[deps.PDMats]] deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] -git-tree-sha1 = "67eae2738d63117a196f497d7db789821bce61d1" +git-tree-sha1 = "949347156c25054de2db3b166c52ac4728cbad65" uuid = "90014a1f-27ba-587c-ab20-58faa44d9150" -version = "0.11.17" +version = "0.11.31" [[deps.PNGFiles]] deps = ["Base64", "CEnum", "ImageCore", "IndirectArrays", "OffsetArrays", "libpng_jll"] -git-tree-sha1 = "f809158b27eba0c18c269cf2a2be6ed751d3e81d" +git-tree-sha1 = "67186a2bc9a90f9f85ff3cc8277868961fb57cbd" uuid = "f57f5aa1-a3ce-4bc8-8ab9-96f992907883" -version = "0.3.17" +version = "0.4.3" [[deps.PROJ_jll]] -deps = ["Artifacts", "JLLWrappers", "LibCURL_jll", "Libdl", "Libtiff_jll", "Pkg", "SQLite_jll"] -git-tree-sha1 = "fcb3f39ae1184a056ecc415863d46d2109aa6947" +deps = ["Artifacts", "JLLWrappers", "LibCURL_jll", "Libdl", "Libtiff_jll", "SQLite_jll"] +git-tree-sha1 = "f3e45027ea0f44a2725fbedfdb7ed118d5deec8d" uuid = "58948b4f-47e0-5654-a9ad-f609743f8632" -version = "900.100.0+0" +version = "901.300.0+0" [[deps.Packing]] deps = ["GeometryBasics"] @@ -856,56 +1071,104 @@ uuid = "5432bcbf-9aad-5242-b902-cca2824c8663" version = "0.5.12" [[deps.Pango_jll]] -deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "FriBidi_jll", "Glib_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "84a314e3926ba9ec66ac097e3635e270986b0f10" +deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "FriBidi_jll", "Glib_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "4745216e94f71cb768d58330b059c9b76f32cb66" uuid = "36c8627f-9965-5494-a995-c6b170f724f3" -version = "1.50.9+0" +version = "1.50.14+0" + +[[deps.Parameters]] +deps = ["OrderedCollections", "UnPack"] +git-tree-sha1 = "34c0e9ad262e5f7fc75b10a9952ca7692cfc5fbe" +uuid = "d96e819e-fc66-5662-9728-84c9c7592b0a" +version = "0.12.3" [[deps.Parsers]] -deps = ["Dates", "SnoopPrecompile"] -git-tree-sha1 = "478ac6c952fddd4399e71d4779797c538d0ff2bf" +deps = ["Dates", "PrecompileTools", "UUIDs"] +git-tree-sha1 = "8489905bcdbcfac64d1daa51ca07c0d8f0283821" uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" -version = "2.5.8" +version = "2.8.1" + +[[deps.Permutations]] +deps = ["Combinatorics", "LinearAlgebra", "Random"] +git-tree-sha1 = "eb3f9df2457819bf0a9019bd93cc451697a0751e" +uuid = "2ae35dd2-176d-5d53-8349-f30d82d94d4f" +version = "0.4.20" + +[[deps.PikaParser]] +deps = ["DocStringExtensions"] +git-tree-sha1 = "d6ff87de27ff3082131f31a714d25ab6d0a88abf" +uuid = "3bbf5609-3e7b-44cd-8549-7c69f321e792" +version = "0.6.1" [[deps.Pixman_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "b4f5d02549a10e20780a24fce72bea96b6329e29" +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "64779bc4c9784fee475689a1752ef4d5747c5e87" uuid = "30392449-352a-5448-841d-b1acce4e97dc" -version = "0.40.1+0" +version = "0.42.2+0" [[deps.Pkg]] deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"] uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" -version = "1.9.0" +version = "1.9.2" [[deps.PkgVersion]] deps = ["Pkg"] -git-tree-sha1 = "f6cf8e7944e50901594838951729a1861e668cb8" +git-tree-sha1 = "f9501cc0430a26bc3d156ae1b5b0c1b47af4d6da" uuid = "eebad327-c553-4316-9ea0-9fa01ccd7688" -version = "0.3.2" +version = "0.3.3" [[deps.PlotUtils]] deps = ["ColorSchemes", "Colors", "Dates", "PrecompileTools", "Printf", "Random", "Reexport", "Statistics"] -git-tree-sha1 = "f92e1315dadf8c46561fb9396e525f7200cdc227" +git-tree-sha1 = "862942baf5663da528f66d24996eb6da85218e76" uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043" -version = "1.3.5" +version = "1.4.0" [[deps.PolygonOps]] git-tree-sha1 = "77b3d3605fc1cd0b42d95eba87dfcd2bf67d5ff6" uuid = "647866c9-e3ac-4575-94e7-e3d426903924" version = "0.1.2" +[[deps.Polynomials]] +deps = ["LinearAlgebra", "RecipesBase", "Setfield", "SparseArrays"] +git-tree-sha1 = "a9c7a523d5ed375be3983db190f6a5874ae9286d" +uuid = "f27b6e38-b328-58d1-80ce-0feddd5e7a45" +version = "4.0.6" + + [deps.Polynomials.extensions] + PolynomialsChainRulesCoreExt = "ChainRulesCore" + PolynomialsFFTWExt = "FFTW" + PolynomialsMakieCoreExt = "MakieCore" + PolynomialsMutableArithmeticsExt = "MutableArithmetics" + + [deps.Polynomials.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" + MakieCore = "20f20a25-4f0e-4fdf-b5d1-57303727442b" + MutableArithmetics = "d8a4904e-b15c-11e9-3269-09a3773c0cb0" + +[[deps.PositiveFactorizations]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "17275485f373e6673f7e7f97051f703ed5b15b20" +uuid = "85a6dd25-e78a-55b7-8502-1745935b8125" +version = "0.2.4" + [[deps.PrecompileTools]] deps = ["Preferences"] -git-tree-sha1 = "d0984cc886c48e5a165705ce65236dc2ec467b91" +git-tree-sha1 = "03b4c25b43cb84cee5c90aa9b5ea0a78fd848d2f" uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" -version = "1.1.0" +version = "1.2.0" [[deps.Preferences]] deps = ["TOML"] -git-tree-sha1 = "47e5f437cc0e7ef2ce8406ce1e7e24d44915f88d" +git-tree-sha1 = "00805cd429dcb4870060ff49ef443486c262e38e" uuid = "21216c6a-2e73-6563-6e65-726566657250" -version = "1.3.0" +version = "1.4.1" + +[[deps.Primes]] +deps = ["IntegerMathUtils"] +git-tree-sha1 = "1d05623b5952aed1307bf8b43bec8b8d1ef94b6e" +uuid = "27ebfcd6-29c5-5fa9-bf4b-fb8fc14df3ae" +version = "0.5.5" [[deps.Printf]] deps = ["Unicode"] @@ -913,15 +1176,15 @@ uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" [[deps.ProgressMeter]] deps = ["Distributed", "Printf"] -git-tree-sha1 = "d7a7aef8f8f2d537104f170139553b14dfe39fe9" +git-tree-sha1 = "00099623ffee15972c16111bcf84c58a0051257c" uuid = "92933f4c-e287-5a05-a399-4b506db050ca" -version = "1.7.2" +version = "1.9.0" [[deps.Proj]] -deps = ["CEnum", "CoordinateTransformations", "GeoFormatTypes", "NetworkOptions", "PROJ_jll"] -git-tree-sha1 = "495a52a7c491d0570a170f6de48a74860a1c1ece" +deps = ["CEnum", "CoordinateTransformations", "GeoFormatTypes", "GeoInterface", "NetworkOptions", "PROJ_jll"] +git-tree-sha1 = "76ab3cbf876f3c859b6cc5817d8262809add3e13" uuid = "c94c279d-25a6-4763-9509-64d165bea63e" -version = "1.4.0" +version = "1.7.0" [[deps.QOI]] deps = ["ColorTypes", "FileIO", "FixedPointNumbers"] @@ -929,23 +1192,11 @@ git-tree-sha1 = "18e8f4d1426e965c7b532ddd260599e1510d26ce" uuid = "4b34888f-f399-49d4-9bb3-47ed5cae4e65" version = "1.0.0" -[[deps.QhullMiniWrapper_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Qhull_jll"] -git-tree-sha1 = "607cf73c03f8a9f83b36db0b86a3a9c14179621f" -uuid = "460c41e3-6112-5d7f-b78c-b6823adb3f2d" -version = "1.0.0+1" - -[[deps.Qhull_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "238dd7e2cc577281976b9681702174850f8d4cbc" -uuid = "784f63db-0788-585a-bace-daefebcd302b" -version = "8.0.1001+0" - [[deps.QuadGK]] deps = ["DataStructures", "LinearAlgebra"] -git-tree-sha1 = "6ec7ac8412e83d57e313393220879ede1740f9ee" +git-tree-sha1 = "9b23c31e76e333e6fb4c1595ae6afa74966a729e" uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc" -version = "2.8.2" +version = "2.9.4" [[deps.REPL]] deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"] @@ -962,24 +1213,36 @@ version = "0.3.2" [[deps.Ratios]] deps = ["Requires"] -git-tree-sha1 = "6d7bb727e76147ba18eed998700998e17b8e4911" +git-tree-sha1 = "1342a47bf3260ee108163042310d26f2be5ec90b" uuid = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439" -version = "0.4.4" +version = "0.4.5" weakdeps = ["FixedPointNumbers"] [deps.Ratios.extensions] RatiosFixedPointNumbersExt = "FixedPointNumbers" +[[deps.RecipesBase]] +deps = ["PrecompileTools"] +git-tree-sha1 = "5c3d09cc4f31f5fc6af001c250bf1278733100ff" +uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +version = "1.3.4" + [[deps.Reexport]] git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" uuid = "189a3867-3050-52da-a836-e630ba90ab69" version = "1.2.2" +[[deps.RegistryInstances]] +deps = ["LazilyInitializedFields", "Pkg", "TOML", "Tar"] +git-tree-sha1 = "ffd19052caf598b8653b99404058fce14828be51" +uuid = "2792f1a3-b283-48e8-9a74-f99dce5104f3" +version = "0.1.0" + [[deps.RelocatableFolders]] deps = ["SHA", "Scratch"] -git-tree-sha1 = "90bc7a7c96410424509e4263e277e43250c05691" +git-tree-sha1 = "ffdaf70d81cf6ff22c2b6e733c900c3321cab864" uuid = "05181044-ff0b-4ac5-8273-598c1e38db00" -version = "1.0.0" +version = "1.0.1" [[deps.Requires]] deps = ["UUIDs"] @@ -987,6 +1250,12 @@ git-tree-sha1 = "838a3a4188e2ded87a4f9f184b4b0d78a1e91cb7" uuid = "ae029012-a4dd-5104-9daa-d747884805df" version = "1.3.0" +[[deps.RingLists]] +deps = ["Random"] +git-tree-sha1 = "f39da63aa6d2d88e0c1bd20ed6a3ff9ea7171ada" +uuid = "286e9d63-9694-5540-9e3c-4e6708fa07b2" +version = "0.2.8" + [[deps.Rmath]] deps = ["Random", "Rmath_jll"] git-tree-sha1 = "f65dcb5fa46aee0cf9ed6274ccbd597adc49aa7b" @@ -999,33 +1268,26 @@ git-tree-sha1 = "6ed52fdd3382cf21947b15e8870ac0ddbff736da" uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f" version = "0.4.0+0" +[[deps.RoundingEmulator]] +git-tree-sha1 = "40b9edad2e5287e05bd413a38f61a8ff55b9557b" +uuid = "5eaf0fd0-dfba-4ccb-bf02-d820a40db705" +version = "0.2.1" + [[deps.SHA]] uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" version = "0.7.0" -[[deps.SIMD]] -deps = ["SnoopPrecompile"] -git-tree-sha1 = "8b20084a97b004588125caebf418d8cab9e393d1" -uuid = "fdea26ae-647d-5447-a871-4b548cad5224" -version = "3.4.4" - [[deps.SQLite_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] -git-tree-sha1 = "4619dd3363610d94fb42a95a6dc35b526a26d0ef" +git-tree-sha1 = "81f7d934b52b2441f7b44520bd982fdb3607b0da" uuid = "76ed43ae-9a5d-5a62-8c75-30186b810ce8" -version = "3.42.0+0" - -[[deps.ScanByte]] -deps = ["Libdl", "SIMD"] -git-tree-sha1 = "2436b15f376005e8790e318329560dcc67188e84" -uuid = "7b38b023-a4d7-4c5e-8d43-3f3097f304eb" -version = "0.3.3" +version = "3.43.0+0" [[deps.Scratch]] deps = ["Dates"] -git-tree-sha1 = "30449ee12237627992a99d5e30ae63e4d78cd24a" +git-tree-sha1 = "3bac05bc7e74a75fd9cba4295cde4045d9fe2386" uuid = "6c6a2e73-6563-6170-7368-637461726353" -version = "1.2.0" +version = "1.2.1" [[deps.Serialization]] uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" @@ -1036,6 +1298,12 @@ git-tree-sha1 = "e2cc6d8c88613c05e1defb55170bf5ff211fbeac" uuid = "efcf1570-3423-57d1-acb7-fd33fddbac46" version = "1.1.1" +[[deps.ShaderAbstractions]] +deps = ["ColorTypes", "FixedPointNumbers", "GeometryBasics", "LinearAlgebra", "Observables", "StaticArrays", "StructArrays", "Tables"] +git-tree-sha1 = "db0219befe4507878b1a90e07820fed3e62c289d" +uuid = "65257c39-d410-5151-9873-9b3e5be5013e" +version = "0.4.0" + [[deps.SharedArrays]] deps = ["Distributed", "Mmap", "Random", "Serialization"] uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383" @@ -1052,6 +1320,30 @@ git-tree-sha1 = "d263a08ec505853a5ff1c1ebde2070419e3f28e9" uuid = "73760f76-fbc4-59ce-8f25-708e95d2df96" version = "0.4.0" +[[deps.SimpleGraphs]] +deps = ["AbstractLattices", "Combinatorics", "DataStructures", "IterTools", "LightXML", "LinearAlgebra", "LinearAlgebraX", "Optim", "Primes", "Random", "RingLists", "SimplePartitions", "SimplePolynomials", "SimpleRandom", "SparseArrays", "Statistics"] +git-tree-sha1 = "f65caa24a622f985cc341de81d3f9744435d0d0f" +uuid = "55797a34-41de-5266-9ec1-32ac4eb504d3" +version = "0.8.6" + +[[deps.SimplePartitions]] +deps = ["AbstractLattices", "DataStructures", "Permutations"] +git-tree-sha1 = "e9330391d04241eafdc358713b48396619c83bcb" +uuid = "ec83eff0-a5b5-5643-ae32-5cbf6eedec9d" +version = "0.3.1" + +[[deps.SimplePolynomials]] +deps = ["Mods", "Multisets", "Polynomials", "Primes"] +git-tree-sha1 = "7063828369cafa93f3187b3d0159f05582011405" +uuid = "cc47b68c-3164-5771-a705-2bc0097375a0" +version = "0.2.17" + +[[deps.SimpleRandom]] +deps = ["Distributions", "LinearAlgebra", "Random"] +git-tree-sha1 = "3a6fb395e37afab81aeea85bae48a4db5cd7244a" +uuid = "a6525b86-64cd-54fa-8f65-62fc48bdc0e8" +version = "0.3.1" + [[deps.SimpleTraits]] deps = ["InteractiveUtils", "MacroTools"] git-tree-sha1 = "5d7e3f4e11935503d3ecaf7186eac40602e7d231" @@ -1060,24 +1352,18 @@ version = "0.9.4" [[deps.Sixel]] deps = ["Dates", "FileIO", "ImageCore", "IndirectArrays", "OffsetArrays", "REPL", "libsixel_jll"] -git-tree-sha1 = "8fb59825be681d451c246a795117f317ecbcaa28" +git-tree-sha1 = "2da10356e31327c7096832eb9cd86307a50b1eb6" uuid = "45858cf5-a6b0-47a3-bbea-62219f50df47" -version = "0.1.2" - -[[deps.SnoopPrecompile]] -deps = ["Preferences"] -git-tree-sha1 = "e760a70afdcd461cf01a575947738d359234665c" -uuid = "66db9d55-30c0-4569-8b51-7e840670fc0c" -version = "1.0.3" +version = "0.1.3" [[deps.Sockets]] uuid = "6462fe0b-24de-5631-8697-dd941f90decc" [[deps.SortingAlgorithms]] deps = ["DataStructures"] -git-tree-sha1 = "a4ada03f999bd01b3a25dcaa30b2d929fe537e00" +git-tree-sha1 = "66e0a8e672a0bdfca2c3f5937efb8538b9ddc085" uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c" -version = "1.1.0" +version = "1.2.1" [[deps.SparseArrays]] deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] @@ -1085,19 +1371,19 @@ uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" [[deps.SpecialFunctions]] deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] -git-tree-sha1 = "ef28127915f4229c971eb43f3fc075dd3fe91880" +git-tree-sha1 = "e2cfc4012a19088254b3950b85c3c1d8882d864d" uuid = "276daf66-3868-5448-9aa4-cd146d93841b" -version = "2.2.0" +version = "2.3.1" weakdeps = ["ChainRulesCore"] [deps.SpecialFunctions.extensions] SpecialFunctionsChainRulesCoreExt = "ChainRulesCore" [[deps.StableHashTraits]] -deps = ["CRC32c", "Compat", "Dates", "SHA", "Tables", "TupleTools", "UUIDs"] -git-tree-sha1 = "0b8b801b8f03a329a4e86b44c5e8a7d7f4fe10a3" +deps = ["Compat", "PikaParser", "SHA", "Tables", "TupleTools"] +git-tree-sha1 = "662f56ffe22b3985f3be7474f0aecbaf214ecf0f" uuid = "c5dd0088-6c3f-4803-b00e-f31a60c170fa" -version = "0.3.1" +version = "1.1.6" [[deps.StackViews]] deps = ["OffsetArrays"] @@ -1106,15 +1392,20 @@ uuid = "cae243ae-269e-4f55-b966-ac2d0dc13c15" version = "0.1.1" [[deps.StaticArrays]] -deps = ["LinearAlgebra", "Random", "StaticArraysCore", "Statistics"] -git-tree-sha1 = "c262c8e978048c2b095be1672c9bee55b4619521" +deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] +git-tree-sha1 = "f68dd04d131d9a8a8eb836173ee8f105c360b0c5" uuid = "90137ffa-7385-5640-81b9-e52037218182" -version = "1.5.24" +version = "1.9.1" +weakdeps = ["ChainRulesCore", "Statistics"] + + [deps.StaticArrays.extensions] + StaticArraysChainRulesCoreExt = "ChainRulesCore" + StaticArraysStatisticsExt = "Statistics" [[deps.StaticArraysCore]] -git-tree-sha1 = "6b7ba252635a5eff6a0b0664a41ee140a1c9e72a" +git-tree-sha1 = "36b3d696ce6366023a0ea192b4cd442268995a0d" uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" -version = "1.4.0" +version = "1.4.2" [[deps.Statistics]] deps = ["LinearAlgebra", "SparseArrays"] @@ -1123,15 +1414,15 @@ version = "1.9.0" [[deps.StatsAPI]] deps = ["LinearAlgebra"] -git-tree-sha1 = "45a7769a04a3cf80da1c1c7c60caf932e6f4c9f7" +git-tree-sha1 = "1ff449ad350c9c4cbc756624d6f8a8c3ef56d3ed" uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0" -version = "1.6.0" +version = "1.7.0" [[deps.StatsBase]] deps = ["DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"] -git-tree-sha1 = "d1bf48bfcc554a3761a133fe3a9bb01488e06916" +git-tree-sha1 = "1d77abd07f617c4868c33d4f5b9e1dbb2643c9cf" uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" -version = "0.33.21" +version = "0.34.2" [[deps.StatsFuns]] deps = ["HypergeometricFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"] @@ -1148,10 +1439,10 @@ version = "1.3.0" InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" [[deps.StructArrays]] -deps = ["Adapt", "DataAPI", "GPUArraysCore", "StaticArraysCore", "Tables"] -git-tree-sha1 = "521a0e828e98bb69042fec1809c1b5a680eb7389" +deps = ["Adapt", "ConstructionBase", "DataAPI", "GPUArraysCore", "StaticArraysCore", "Tables"] +git-tree-sha1 = "1b0b1205a56dc288b71b1961d48e351520702e24" uuid = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" -version = "0.6.15" +version = "0.6.17" [[deps.SuiteSparse]] deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"] @@ -1174,10 +1465,10 @@ uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" version = "1.0.1" [[deps.Tables]] -deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "OrderedCollections", "TableTraits", "Test"] -git-tree-sha1 = "1544b926975372da01227b382066ab70e574a3ec" +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "cb76cf677714c095e535e3501ac7954732aeea2d" uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" -version = "1.10.1" +version = "1.11.1" [[deps.Tar]] deps = ["ArgTools", "SHA"] @@ -1196,15 +1487,18 @@ uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" [[deps.TiffImages]] deps = ["ColorTypes", "DataStructures", "DocStringExtensions", "FileIO", "FixedPointNumbers", "IndirectArrays", "Inflate", "Mmap", "OffsetArrays", "PkgVersion", "ProgressMeter", "UUIDs"] -git-tree-sha1 = "8621f5c499a8aa4aa970b1ae381aae0ef1576966" +git-tree-sha1 = "34cc045dd0aaa59b8bbe86c644679bc57f1d5bd0" uuid = "731e570b-9d59-4bfa-96dc-6df516fadf69" -version = "0.6.4" +version = "0.6.8" [[deps.TranscodingStreams]] -deps = ["Random", "Test"] -git-tree-sha1 = "9a6ae7ed916312b41236fcef7e0af564ef934769" +git-tree-sha1 = "1fbeaaca45801b4ba17c251dd8603ef24801dd84" uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa" -version = "0.9.13" +version = "0.10.2" +weakdeps = ["Random", "Test"] + + [deps.TranscodingStreams.extensions] + TestExt = ["Test", "Random"] [[deps.TriplotBase]] git-tree-sha1 = "4d4ed7f294cda19382ff7de4c137d24d16adc89b" @@ -1212,14 +1506,19 @@ uuid = "981d1d27-644d-49a2-9326-4793e63143c3" version = "0.1.0" [[deps.TupleTools]] -git-tree-sha1 = "3c712976c47707ff893cf6ba4354aa14db1d8938" +git-tree-sha1 = "155515ed4c4236db30049ac1495e2969cc06be9d" uuid = "9d95972d-f1c8-5527-a6e0-b4b365fa01f6" -version = "1.3.0" +version = "1.4.3" [[deps.UUIDs]] deps = ["Random", "SHA"] uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +[[deps.UnPack]] +git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b" +uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" +version = "1.0.2" + [[deps.Unicode]] uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" @@ -1231,15 +1530,15 @@ version = "0.4.1" [[deps.WoodburyMatrices]] deps = ["LinearAlgebra", "SparseArrays"] -git-tree-sha1 = "de67fa59e33ad156a590055375a30b23c40299d3" +git-tree-sha1 = "c1a7aa6219628fcd757dede0ca95e245c5cd9511" uuid = "efce3f68-66dc-5838-9240-27a6d6f5f9b6" -version = "0.5.5" +version = "1.0.0" [[deps.XML2_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "Zlib_jll"] -git-tree-sha1 = "93c41695bc1c08c46c5899f4fe06d6ead504bb73" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "801cbe47eae69adc50f36c3caec4758d2650741b" uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" -version = "2.10.3+0" +version = "2.12.2+0" [[deps.XSLT_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgcrypt_jll", "Libgpg_error_jll", "Libiconv_jll", "Pkg", "XML2_jll", "Zlib_jll"] @@ -1247,23 +1546,29 @@ git-tree-sha1 = "91844873c4085240b95e795f692c4cec4d805f8a" uuid = "aed1982a-8fda-507f-9586-7b0439959a61" version = "1.1.34+0" +[[deps.XZ_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "522b8414d40c4cbbab8dee346ac3a09f9768f25d" +uuid = "ffd25f8a-64ca-5728-b0f7-c24cf3aae800" +version = "5.4.5+0" + [[deps.Xorg_libX11_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxcb_jll", "Xorg_xtrans_jll"] -git-tree-sha1 = "5be649d550f3f4b95308bf0183b82e2582876527" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxcb_jll", "Xorg_xtrans_jll"] +git-tree-sha1 = "afead5aba5aa507ad5a3bf01f58f82c8d1403495" uuid = "4f6342f7-b3d2-589e-9d20-edeb45f2b2bc" -version = "1.6.9+4" +version = "1.8.6+0" [[deps.Xorg_libXau_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "4e490d5c960c314f33885790ed410ff3a94ce67e" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6035850dcc70518ca32f012e46015b9beeda49d8" uuid = "0c0b7dd1-d40b-584c-a123-a41640f87eec" -version = "1.0.9+4" +version = "1.0.11+0" [[deps.Xorg_libXdmcp_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "4fe47bd2247248125c428978740e18a681372dd4" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "34d526d318358a859d7de23da945578e8e8727b7" uuid = "a3789734-cfe1-5b06-b2d0-1dd0d9d62d05" -version = "1.1.3+4" +version = "1.1.4+0" [[deps.Xorg_libXext_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"] @@ -1278,22 +1583,22 @@ uuid = "ea2f1a96-1ddc-540d-b46f-429655e07cfa" version = "0.9.10+4" [[deps.Xorg_libpthread_stubs_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "6783737e45d3c59a4a4c4091f5f88cdcf0908cbb" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "8fdda4c692503d44d04a0603d9ac0982054635f9" uuid = "14d82f49-176c-5ed1-bb49-ad3f5cbd8c74" -version = "0.1.0+3" +version = "0.1.1+0" [[deps.Xorg_libxcb_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "XSLT_jll", "Xorg_libXau_jll", "Xorg_libXdmcp_jll", "Xorg_libpthread_stubs_jll"] -git-tree-sha1 = "daf17f441228e7a3833846cd048892861cff16d6" +deps = ["Artifacts", "JLLWrappers", "Libdl", "XSLT_jll", "Xorg_libXau_jll", "Xorg_libXdmcp_jll", "Xorg_libpthread_stubs_jll"] +git-tree-sha1 = "b4bfde5d5b652e22b9c790ad00af08b6d042b97d" uuid = "c7cfdc94-dc32-55de-ac96-5a1b8d977c5b" -version = "1.13.0+3" +version = "1.15.0+0" [[deps.Xorg_xtrans_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "79c31e7844f6ecf779705fbc12146eb190b7d845" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e92a1a012a10506618f10b7047e478403a046c77" uuid = "c5fb5394-a638-5e4d-96e5-b29de1b5cf10" -version = "1.4.0+3" +version = "1.5.0+0" [[deps.Zlib_jll]] deps = ["Libdl"] @@ -1327,7 +1632,7 @@ version = "0.15.1+0" [[deps.libblastrampoline_jll]] deps = ["Artifacts", "Libdl"] uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" -version = "5.7.0+0" +version = "5.8.0+0" [[deps.libfdk_aac_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] @@ -1336,10 +1641,10 @@ uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280" version = "2.0.2+0" [[deps.libpng_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"] -git-tree-sha1 = "94d180a6d2b5e55e447e2d27a29ed04fe79eb30c" +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "93284c28274d9e75218a416c65ec49d0e0fcdf3d" uuid = "b53b4c65-9356-5827-b1ea-8c7a1a84506f" -version = "1.6.38+0" +version = "1.6.40+0" [[deps.libsixel_jll]] deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Pkg", "libpng_jll"] From 89b3ae435f2487ccc199bbb58be817d77716effb Mon Sep 17 00:00:00 2001 From: Skylar Gering Date: Tue, 23 Jan 2024 14:12:40 -0800 Subject: [PATCH 08/12] Update makedocs keywords --- docs/make.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/make.jl b/docs/make.jl index d1ad2ed52..5fea229c2 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -50,7 +50,7 @@ makedocs(; "Home" => "index.md", "Source code" => literate_pages ], - strict=false, + warnonly = true, ) deploydocs(; From 7c6bea84ef4b3f16014595a7b2ef4a86aab82e0c Mon Sep 17 00:00:00 2001 From: Skylar Gering Date: Tue, 23 Jan 2024 14:36:13 -0800 Subject: [PATCH 09/12] Add documenter source code to gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 6977e6f71..95a0b30a8 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ /Manifest.toml /docs/build/ +/docs/src/source/ .vscode/ \ No newline at end of file From 7bb30586d9869484a9908579c94aba36e372430d Mon Sep 17 00:00:00 2001 From: Skylar Gering Date: Fri, 26 Jan 2024 13:28:37 -0800 Subject: [PATCH 10/12] Update comment examples to find error --- src/methods/angles.jl | 11 +- src/methods/area.jl | 18 ++- src/methods/barycentric.jl | 162 ++++++++++++----------- src/methods/geom_relations/contains.jl | 9 +- src/methods/geom_relations/coveredby.jl | 15 +-- src/methods/geom_relations/covers.jl | 13 +- src/methods/geom_relations/crosses.jl | 8 +- src/methods/geom_relations/disjoint.jl | 7 +- src/methods/geom_relations/intersects.jl | 22 ++- src/methods/geom_relations/overlaps.jl | 7 +- src/methods/geom_relations/touches.jl | 13 +- src/methods/geom_relations/within.jl | 9 +- 12 files changed, 148 insertions(+), 146 deletions(-) diff --git a/src/methods/angles.jl b/src/methods/angles.jl index 0ffb8932a..7f29baee2 100644 --- a/src/methods/angles.jl +++ b/src/methods/angles.jl @@ -8,17 +8,16 @@ Angles are the angles formed by a given geometries line segments, if it has line To provide an example, consider this rectangle: ```@example angles -using GeometryOps -using GeometryOps.GeometryBasics +import GeometryOps as GO +import GeoInterface as GI using Makie, CairoMakie -rect = Polygon([Point(0,0), Point(0,1), Point(1,1), Point(1,0), Point(0, 0)]) -f, a, p = poly(rect; axis = (; aspect = DataAspect())) -f +rect = GI.Polygon([[(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0), (0.0, 0.0)]]) +f, a, p = poly(collect(GI.getpoint(rect)); axis = (; aspect = DataAspect())) ``` This is clearly a rectangle, with angles of 90 degrees. ```@example angles -angles(rect) +GO.angles(rect) # [90, 90, 90, 90] ``` ## Implementation diff --git a/src/methods/area.jl b/src/methods/area.jl index 5e25d0a45..9b26c0d24 100644 --- a/src/methods/area.jl +++ b/src/methods/area.jl @@ -13,20 +13,26 @@ negative area. The area is the absolute value of the signed area. To provide an example, consider this rectangle: ```@example rect -using GeometryOps -using GeometryOps.GeometryBasics +import GeometryOps as GO +import GeoInterface as GI using Makie +using CairoMakie -rect = Polygon([Point(0,0), Point(0,1), Point(1,1), Point(1,0), Point(0, 0)]) -f, a, p = poly(rect; axis = (; aspect = DataAspect())) +rect = GI.Polygon([[(0,0), (0,1), (1,1), (1,0), (0, 0)]]) +f, a, p = poly(collect(GI.getpoint(rect)); axis = (; aspect = DataAspect())) ``` This is clearly a rectangle, etc. But now let's look at how the points look: ```@example rect -lines!(a, rect; color = 1:length(coordinates(rect))+1) +lines!( + collect(GI.getpoint(rect)); + color = 1:GI.npoint(rect), linewidth = 10.0) f ``` -The points are ordered in a clockwise fashion, which means that the signed area +The points are ordered in a counterclockwise fashion, which means that the signed area is negative. If we reverse the order of the points, we get a postive area. +```@example rect +GO.signed_area(rect) # -1.0 +``` ## Implementation diff --git a/src/methods/barycentric.jl b/src/methods/barycentric.jl index 8a91a701c..027fb0886 100644 --- a/src/methods/barycentric.jl +++ b/src/methods/barycentric.jl @@ -24,88 +24,90 @@ export MeanValue # ## Example # This example was taken from [this page of CGAL's documentation](https://doc.cgal.org/latest/Barycentric_coordinates_2/index.html). +#= +```@example barycentric +import GeometryOps as GO +using GeometryOps.GeometryBasics +using Makie +using CairoMakie +# Define a polygon +polygon_points = Point3f[ +(0.03, 0.05, 0.00), (0.07, 0.04, 0.02), (0.10, 0.04, 0.04), +(0.14, 0.04, 0.06), (0.17, 0.07, 0.08), (0.20, 0.09, 0.10), +(0.22, 0.11, 0.12), (0.25, 0.11, 0.14), (0.27, 0.10, 0.16), +(0.30, 0.07, 0.18), (0.31, 0.04, 0.20), (0.34, 0.03, 0.22), +(0.37, 0.02, 0.24), (0.40, 0.03, 0.26), (0.42, 0.04, 0.28), +(0.44, 0.07, 0.30), (0.45, 0.10, 0.32), (0.46, 0.13, 0.34), +(0.46, 0.19, 0.36), (0.47, 0.26, 0.38), (0.47, 0.31, 0.40), +(0.47, 0.35, 0.42), (0.45, 0.37, 0.44), (0.41, 0.38, 0.46), +(0.38, 0.37, 0.48), (0.35, 0.36, 0.50), (0.32, 0.35, 0.52), +(0.30, 0.37, 0.54), (0.28, 0.39, 0.56), (0.25, 0.40, 0.58), +(0.23, 0.39, 0.60), (0.21, 0.37, 0.62), (0.21, 0.34, 0.64), +(0.23, 0.32, 0.66), (0.24, 0.29, 0.68), (0.27, 0.24, 0.70), +(0.29, 0.21, 0.72), (0.29, 0.18, 0.74), (0.26, 0.16, 0.76), +(0.24, 0.17, 0.78), (0.23, 0.19, 0.80), (0.24, 0.22, 0.82), +(0.24, 0.25, 0.84), (0.21, 0.26, 0.86), (0.17, 0.26, 0.88), +(0.12, 0.24, 0.90), (0.07, 0.20, 0.92), (0.03, 0.15, 0.94), +(0.01, 0.10, 0.97), (0.02, 0.07, 1.00)] +# Plot it! +# First, we'll plot the polygon using Makie's rendering: +f, a1, p1 = poly( + polygon_points; + color = last.(polygon_points), colormap = cgrad(:jet, 18; categorical = true), + axis = (; + aspect = DataAspect(), title = "Makie mesh based polygon rendering", subtitle = "CairoMakie" + ), + figure = (; resolution = (800, 400),) +) + +Makie.update_state_before_display!(f) # We have to call this explicitly, to get the axis limits correct +# Now that we've plotted the first polygon, +# we can render it using barycentric coordinates. +a1_bbox = a1.finallimits[] # First we get the extent of the axis +ext = GeometryOps.GI.Extent(NamedTuple{(:X, :Y)}(zip(minimum(a1_bbox), maximum(a1_bbox)))) + +a2, p2box = poly( # Now, we plot a cropping rectangle around the axis so we only show the polygon + f[1, 2], + GeometryOps.GeometryBasics.Polygon( # This is a rectangle with an internal hole shaped like the polygon. + Point2f[(ext.X[1], ext.Y[1]), (ext.X[2], ext.Y[1]), (ext.X[2], ext.Y[2]), (ext.X[1], ext.Y[2]), (ext.X[1], ext.Y[1])], + [reverse(Point2f.(polygon_points))] + ); + color = :white, xautolimits = false, yautolimits = false, + axis = (; + aspect = DataAspect(), title = "Barycentric coordinate based polygon rendering", subtitle = "GeometryOps", + limits = (ext.X, ext.Y), + ) +) +hidedecorations!(a1) +hidedecorations!(a2) +cb = Colorbar(f[2, :], p1.plots[1]; vertical = false, flipaxis = true) +# Finally, we perform barycentric interpolation on a grid, +xrange = LinRange(ext.X..., widths(a2.scene.px_area[])[1] * 4) # 2 rendered pixels per "physical" pixel +yrange = LinRange(ext.Y..., widths(a2.scene.px_area[])[2] * 4) # 2 rendered pixels per "physical" pixel +@time mean_values = barycentric_interpolate.( + (MeanValue(),), # The barycentric coordinate algorithm (MeanValue is the only one for now) + (Point2f.(polygon_points),), # The polygon points as `Point2f` + (last.(polygon_points,),), # The values per polygon point - can be anything which supports addition and division + Point2f.(xrange, yrange') # The points at which to interpolate +) +# and render! +hm = heatmap!( + a2, xrange, yrange, mean_values; + colormap = p1.colormap, # Use the same colormap as the original polygon plot + colorrange = p1.plots[1].colorrange[], # Access the rendered mesh plot's colorrange directly + transformation = (; translation = Vec3f(0,0,-1)), # This gets the heatmap to render "behind" the previously plotted polygon + xautolimits = false, yautolimits = false +) +f +``` -# ```@example barycentric -# using GeometryOps, Makie -# using GeometryOps.GeometryBasics -# # Define a polygon -# polygon_points = Point3f[ -# (0.03, 0.05, 0.00), (0.07, 0.04, 0.02), (0.10, 0.04, 0.04), -# (0.14, 0.04, 0.06), (0.17, 0.07, 0.08), (0.20, 0.09, 0.10), -# (0.22, 0.11, 0.12), (0.25, 0.11, 0.14), (0.27, 0.10, 0.16), -# (0.30, 0.07, 0.18), (0.31, 0.04, 0.20), (0.34, 0.03, 0.22), -# (0.37, 0.02, 0.24), (0.40, 0.03, 0.26), (0.42, 0.04, 0.28), -# (0.44, 0.07, 0.30), (0.45, 0.10, 0.32), (0.46, 0.13, 0.34), -# (0.46, 0.19, 0.36), (0.47, 0.26, 0.38), (0.47, 0.31, 0.40), -# (0.47, 0.35, 0.42), (0.45, 0.37, 0.44), (0.41, 0.38, 0.46), -# (0.38, 0.37, 0.48), (0.35, 0.36, 0.50), (0.32, 0.35, 0.52), -# (0.30, 0.37, 0.54), (0.28, 0.39, 0.56), (0.25, 0.40, 0.58), -# (0.23, 0.39, 0.60), (0.21, 0.37, 0.62), (0.21, 0.34, 0.64), -# (0.23, 0.32, 0.66), (0.24, 0.29, 0.68), (0.27, 0.24, 0.70), -# (0.29, 0.21, 0.72), (0.29, 0.18, 0.74), (0.26, 0.16, 0.76), -# (0.24, 0.17, 0.78), (0.23, 0.19, 0.80), (0.24, 0.22, 0.82), -# (0.24, 0.25, 0.84), (0.21, 0.26, 0.86), (0.17, 0.26, 0.88), -# (0.12, 0.24, 0.90), (0.07, 0.20, 0.92), (0.03, 0.15, 0.94), -# (0.01, 0.10, 0.97), (0.02, 0.07, 1.00)] -# # Plot it! -# # First, we'll plot the polygon using Makie's rendering: -# f, a1, p1 = poly( -# polygon_points; -# color = last.(polygon_points), colormap = cgrad(:jet, 18; categorical = true), -# axis = (; -# aspect = DataAspect(), title = "Makie mesh based polygon rendering", subtitle = "CairoMakie" -# ), -# figure = (; resolution = (800, 400),) -# ) -# -# Makie.update_state_before_display!(f) # We have to call this explicitly, to get the axis limits correct -# # Now that we've plotted the first polygon, -# # we can render it using barycentric coordinates. -# a1_bbox = a1.finallimits[] # First we get the extent of the axis -# ext = GeometryOps.GI.Extent(NamedTuple{(:X, :Y)}(zip(minimum(a1_bbox), maximum(a1_bbox)))) -# -# a2, p2box = poly( # Now, we plot a cropping rectangle around the axis so we only show the polygon -# f[1, 2], -# GeometryOps.GeometryBasics.Polygon( # This is a rectangle with an internal hole shaped like the polygon. -# Point2f[(ext.X[1], ext.Y[1]), (ext.X[2], ext.Y[1]), (ext.X[2], ext.Y[2]), (ext.X[1], ext.Y[2]), (ext.X[1], ext.Y[1])], -# [reverse(Point2f.(polygon_points))] -# ); -# color = :white, xautolimits = false, yautolimits = false, -# axis = (; -# aspect = DataAspect(), title = "Barycentric coordinate based polygon rendering", subtitle = "GeometryOps", -# limits = (ext.X, ext.Y), -# ) -# ) -# hidedecorations!(a1) -# hidedecorations!(a2) -# cb = Colorbar(f[2, :], p1.plots[1]; vertical = false, flipaxis = true) -# # Finally, we perform barycentric interpolation on a grid, -# xrange = LinRange(ext.X..., widths(a2.scene.px_area[])[1] * 4) # 2 rendered pixels per "physical" pixel -# yrange = LinRange(ext.Y..., widths(a2.scene.px_area[])[2] * 4) # 2 rendered pixels per "physical" pixel -# @time mean_values = barycentric_interpolate.( -# (MeanValue(),), # The barycentric coordinate algorithm (MeanValue is the only one for now) -# (Point2f.(polygon_points),), # The polygon points as `Point2f` -# (last.(polygon_points,),), # The values per polygon point - can be anything which supports addition and division -# Point2f.(xrange, yrange') # The points at which to interpolate -# ) -# # and render! -# hm = heatmap!( -# a2, xrange, yrange, mean_values; -# colormap = p1.colormap, # Use the same colormap as the original polygon plot -# colorrange = p1.plots[1].colorrange[], # Access the rendered mesh plot's colorrange directly -# transformation = (; translation = Vec3f(0,0,-1)), # This gets the heatmap to render "behind" the previously plotted polygon -# xautolimits = false, yautolimits = false -# ) -# f -# ``` +## Barycentric-coordinate API +In some cases, we actually want barycentric interpolation, and have no interest +in the coordinates themselves. -# ## Barycentric-coordinate API -# In some cases, we actually want barycentric interpolation, and have no interest -# in the coordinates themselves. -# -# However, the coordinates can be useful for debugging, and when performing 3D rendering, -# multiple barycentric values (depth, uv) are needed for depth buffering. -# +However, the coordinates can be useful for debugging, and when performing 3D rendering, +multiple barycentric values (depth, uv) are needed for depth buffering. +=# const _VecTypes = Union{Tuple{Vararg{T, N}}, GeometryBasics.StaticArraysCore.StaticArray{Tuple{N}, T, 1}} where {N, T} diff --git a/src/methods/geom_relations/contains.jl b/src/methods/geom_relations/contains.jl index 1f7b2dd8d..79ec841e1 100644 --- a/src/methods/geom_relations/contains.jl +++ b/src/methods/geom_relations/contains.jl @@ -12,8 +12,8 @@ boundary of the second geometry is not in the exterior of the first geometry. To provide an example, consider these two lines: ```@example contains -using GeometryOps -using GeometryOps.GeometryBasics +import GeometryOps as GO +import GeoInterface as GI using Makie using CairoMakie @@ -23,12 +23,13 @@ f, a, p = lines(GI.getpoint(l1), color = :blue) scatter!(GI.getpoint(l1), color = :blue) lines!(GI.getpoint(l2), color = :orange) scatter!(GI.getpoint(l2), color = :orange) +f ``` We can see that all of the points and edges of l2 are within l1, so l1 contains l2. However, l2 does not contain l1. ```@example contains -contains(l1, l2) # returns true -contains(l2, l1) # returns false +GO.contains(l1, l2) # returns true +GO.contains(l2, l1) # returns false ``` ## Implementation diff --git a/src/methods/geom_relations/coveredby.jl b/src/methods/geom_relations/coveredby.jl index 0f71317b9..6825ce9bf 100644 --- a/src/methods/geom_relations/coveredby.jl +++ b/src/methods/geom_relations/coveredby.jl @@ -12,22 +12,21 @@ of the first geometry isn't outside of the second geometry. To provide an example, consider this point and line: ```@example coveredby -using GeometryOps -using GeometryOps.GeometryBasics +import GeometryOps as GO +import GeoInterface as GI using Makie using CairoMakie -p1 = Point(0.0, 0.0) -p2 = Point(1.0, 1.0) -l1 = Line(p1, p2) - -f, a, p = lines([p1, p2]) +p1 = (0.0, 0.0) +l1 = GI.Line([p1, (1.0, 1.0)]) +f, a, p = lines(GI.getpoint(l1)) scatter!(p1, color = :red) +f ``` As we can see, `p1` is on the endpoint of l1. This means it is not `within`, but it does meet the definition of `coveredby`. ```@example coveredby -coveredby(p1, l1) # true +GO.coveredby(p1, l1) # true ``` ## Implementation diff --git a/src/methods/geom_relations/covers.jl b/src/methods/geom_relations/covers.jl index 714d14643..f7e61bd00 100644 --- a/src/methods/geom_relations/covers.jl +++ b/src/methods/geom_relations/covers.jl @@ -12,17 +12,18 @@ The interiors do not need to overlap. To provide an example, consider these two lines: ```@example covers -using GeometryOps -using GeometryOps.GeometryBasics +import GeometryOps as GO +import GeoInterface as GI using Makie using CairoMakie -p1 = Point(0.0, 0.0) -p2 = Point(1.0, 1.0) -l1 = Line(p1, p2) +p1 = (0.0, 0.0) +p2 = (1.0, 1.0) +l1 = GI.Line([p1, p2]) -f, a, p = lines([p1, p2]) +f, a, p = lines(GI.getpoint(l1)) scatter!(p1, color = :red) +f ``` ```@example covers diff --git a/src/methods/geom_relations/crosses.jl b/src/methods/geom_relations/crosses.jl index fc5f7a843..b9f0cbcab 100644 --- a/src/methods/geom_relations/crosses.jl +++ b/src/methods/geom_relations/crosses.jl @@ -12,13 +12,7 @@ TODO: broken ## Examples ```julia import GeoInterface as GI, GeometryOps as GO - -line1 = GI.LineString([(1, 1), (1, 2), (1, 3), (1, 4)]) -line2 = GI.LineString([(-2, 2), (4, 2)]) - -GO.crosses(line1, line2) -# output -true +# TODO: Add working example ``` """ crosses(g1, g2)::Bool = crosses(trait(g1), g1, trait(g2), g2)::Bool diff --git a/src/methods/geom_relations/disjoint.jl b/src/methods/geom_relations/disjoint.jl index e65bc70fb..7d7876a5a 100644 --- a/src/methods/geom_relations/disjoint.jl +++ b/src/methods/geom_relations/disjoint.jl @@ -9,8 +9,8 @@ without sharing any boundaries or interiors. To provide an example, consider these two lines: ```@example disjoint -using GeometryOps -using GeometryOps.GeometryBasics +import GeometryOps as GO +import GeoInterface as GI using Makie using CairoMakie @@ -20,6 +20,7 @@ f, a, p = lines(GI.getpoint(l1), color = :blue) scatter!(GI.getpoint(l1), color = :blue) lines!(GI.getpoint(l2), color = :orange) scatter!(GI.getpoint(l2), color = :orange) +f ``` We can see that none of the edges or vertices of l1 interact with l2 so they are disjoint. @@ -59,7 +60,7 @@ Return `true` if the first geometry is disjoint from the second geometry. The interiors and boundaries of both geometries must not intersect. ## Examples -```jldoctest setup=:(using GeometryOps, GeometryBasics) +```jldoctest setup=:(using GeometryOps, GeoInterface) import GeometryOps as GO, GeoInterface as GI line = GI.LineString([(1, 1), (1, 2), (1, 3), (1, 4)]) diff --git a/src/methods/geom_relations/intersects.jl b/src/methods/geom_relations/intersects.jl index 524746181..f735890cd 100644 --- a/src/methods/geom_relations/intersects.jl +++ b/src/methods/geom_relations/intersects.jl @@ -22,25 +22,21 @@ of tuple points. To provide an example, consider these two lines: ```@example intersects_intersection -using GeometryOps -using GeometryOps.GeometryBasics +import GeometryOps as GO +import GeoInterface a GI using Makie using CairoMakie -point1, point2 = Point(124.584961,-12.768946), Point(126.738281,-17.224758) -point3, point4 = Point(123.354492,-15.961329), Point(127.22168,-14.008696) -line1 = Line(point1, point2) -line2 = Line(point3, point4) -f, a, p = lines([point1, point2]) -lines!([point3, point4]) + +line1 = GI.Line([(124.584961,-12.768946), (126.738281,-17.224758)]) +line2 = GI.Line([(123.354492,-15.961329), (127.22168,-14.008696)]) +f, a, p = lines(GI.getpoint(line1)) +lines!(GI.getpoint(line2)) +f ``` We can see that they intersect, so we expect intersects to return true, and we can visualize the intersection point in red. ```@example intersects_intersection -int_bool = GO.intersects(line1, line2) -println(int_bool) -int_point = GO.intersection(line1, line2) -scatter!(int_point, color = :red) -f +GO.intersects(line1, line2) # true ``` ## Implementation diff --git a/src/methods/geom_relations/overlaps.jl b/src/methods/geom_relations/overlaps.jl index 32b9b6583..09c0396a6 100644 --- a/src/methods/geom_relations/overlaps.jl +++ b/src/methods/geom_relations/overlaps.jl @@ -15,8 +15,8 @@ each line is colinear. To provide an example, consider these two lines: ```@example overlaps -using GeometryOps -using GeometryOps.GeometryBasics +import GeometryOps as GO +import GeoInterface as GI using Makie using CairoMakie @@ -26,10 +26,11 @@ f, a, p = lines(GI.getpoint(l1), color = :blue) scatter!(GI.getpoint(l1), color = :blue) lines!(GI.getpoint(l2), color = :orange) scatter!(GI.getpoint(l2), color = :orange) +f ``` We can see that the two lines overlap in the plot: ```@example overlaps -overlap(l1, l2) +GO.overlaps(l1, l2) # true ``` ## Implementation diff --git a/src/methods/geom_relations/touches.jl b/src/methods/geom_relations/touches.jl index 21f9259d7..0c8845bad 100644 --- a/src/methods/geom_relations/touches.jl +++ b/src/methods/geom_relations/touches.jl @@ -13,16 +13,17 @@ geometies interior or boundary. To provide an example, consider these two lines: ```@example touches -using GeometryOps -using GeometryOps.GeometryBasics +import GeometryOps as GO +import GeoInterface as GI using Makie using CairoMakie -l1 = Line([Point(0.0, 0.0), Point(1.0, 0.0)]) -l2 = Line([Point(1.0, 0.0), Point(1.0, -1.0)]) +l1 = GI.Line([(0.0, 0.0), (1.0, 0.0)]) +l2 = GI.Line([(1.0, 0.0), (1.0, -1.0)]) -f, a, p = lines(l1) -lines!(l2) +f, a, p = lines(GI.getpoint(l1)) +lines!(GI.getpoint(l2)) +f ``` We can see that these two lines touch only at their endpoints. ```@example touches diff --git a/src/methods/geom_relations/within.jl b/src/methods/geom_relations/within.jl index f2833a11b..dfaaa9b29 100644 --- a/src/methods/geom_relations/within.jl +++ b/src/methods/geom_relations/within.jl @@ -11,8 +11,8 @@ boundary of the first geometry is not in the exterior of the second geometry. To provide an example, consider these two lines: ```@example within -using GeometryOps -using GeometryOps.GeometryBasics +import GeometryOps as GO +import GeoInterface as GI using Makie using CairoMakie @@ -22,12 +22,13 @@ f, a, p = lines(GI.getpoint(l1), color = :blue) scatter!(GI.getpoint(l1), color = :blue) lines!(GI.getpoint(l2), color = :orange) scatter!(GI.getpoint(l2), color = :orange) +f ``` We can see that all of the points and edges of l2 are within l1, so l2 is within l1, but l1 is not within l2 ```@example within -within(l1, l2) # returns false -within(l2, l1) # returns true +within(l1, l2) # false +within(l2, l1) # true ``` ## Implementation From 83820f332a3ffdc6b2fafdbaae3c08652b4388e2 Mon Sep 17 00:00:00 2001 From: Skylar Gering Date: Fri, 26 Jan 2024 13:58:10 -0800 Subject: [PATCH 11/12] More comment example fixes --- src/methods/centroid.jl | 15 ++++++--------- src/methods/distance.jl | 22 +++++++++++----------- src/methods/equals.jl | 7 ++++--- src/methods/geom_relations/covers.jl | 4 ++-- src/methods/geom_relations/disjoint.jl | 2 +- src/methods/geom_relations/intersects.jl | 2 +- 6 files changed, 25 insertions(+), 27 deletions(-) diff --git a/src/methods/centroid.jl b/src/methods/centroid.jl index 464f01275..7097d45cd 100644 --- a/src/methods/centroid.jl +++ b/src/methods/centroid.jl @@ -14,21 +14,18 @@ centroids are calculated by weighting edge's by their 'area components'. To provide an example, consider this concave polygon in the shape of a 'C': ```@example cshape -using GeometryOps -using GeometryOps.GeometryBasics +import GeometryOps as GO +import GeoInterface as GI using Makie using CairoMakie -cshape = Polygon([ - Point(0,0), Point(0,3), Point(3,3), Point(3,2), Point(1,2), - Point(1,1), Point(3,1), Point(3,0), Point(0,0), -]) -f, a, p = poly(cshape; axis = (; aspect = DataAspect())) +cshape = GI.Polygon([[(0,0), (0,3), (3,3), (3,2), (1,2), (1,1), (3,1), (3,0), (0,0)]]) +f, a, p = poly(collect(GI.getpoint(cshape)); axis = (; aspect = DataAspect())) ``` Let's see what the centroid looks like (plotted in red): ```@example cshape -cent = centroid(cshape) -scatter!(a, GI.x(cent), GI.y(cent), color = :red) +cent = GO.centroid(cshape) +scatter!(GI.x(cent), GI.y(cent), color = :red) f ``` diff --git a/src/methods/distance.jl b/src/methods/distance.jl index 13c6811f8..f103d8dd7 100644 --- a/src/methods/distance.jl +++ b/src/methods/distance.jl @@ -16,25 +16,25 @@ either be postitive or 0. To provide an example, consider this rectangle: ```@example rect -using GeometryOps -using GeometryOps.GeometryBasics +import GeometryOps as GO +import GeoInterface as GI using Makie -rect = Polygon([Point(0,0), Point(0,1), Point(1,1), Point(1,0), Point(0, 0)]) -point_in = Point(0.5, 0.5) -point_out = Point(0.5, 1.5) -f, a, p = poly(rect; axis = (; aspect = DataAspect())) -scatter!(f, point_in) -scatter!(f, point_out) +rect = GI.Polygon([[(0,0), (0,1), (1,1), (1,0), (0, 0)]]) +point_in = (0.5, 0.5) +point_out = (0.5, 1.5) +f, a, p = poly(collect(GI.getpoint(rect)); axis = (; aspect = DataAspect())) +scatter!(GI.x(point_in), GI.y(point_in); color = :red) +scatter!(GI.x(point_out), GI.y(point_out); color = :orange) f ``` This is clearly a rectangle with one point inside and one point outside. The points are both an equal distance to the polygon. The distance to point_in is negative while the distance to point_out is positive. ```@example rect -distance(point_in, poly) # == 0 -signed_distance(point_in, poly) # < 0 -signed_distance(point_out, poly) # > 0 +GO.distance(point_in, poly) # == 0 +GO.signed_distance(point_in, poly) # < 0 +GO.signed_distance(point_out, poly) # > 0 ``` ## Implementation diff --git a/src/methods/equals.jl b/src/methods/equals.jl index c797432d5..15761d63e 100644 --- a/src/methods/equals.jl +++ b/src/methods/equals.jl @@ -10,8 +10,8 @@ share the same set of points and edges to define the same shape. To provide an example, consider these two lines: ```@example equals -using GeometryOps -using GeometryOps.GeometryBasics +import GeometryOps as GO +import GeoInterface as GI using Makie using CairoMakie @@ -21,11 +21,12 @@ f, a, p = lines(GI.getpoint(l1), color = :blue) scatter!(GI.getpoint(l1), color = :blue) lines!(GI.getpoint(l2), color = :orange) scatter!(GI.getpoint(l2), color = :orange) +f ``` We can see that the two lines do not share a commen set of points and edges in the plot, so they are not equal: ```@example equals -equals(l1, l2) # returns false +GO.equals(l1, l2) # returns false ``` ## Implementation diff --git a/src/methods/geom_relations/covers.jl b/src/methods/geom_relations/covers.jl index f7e61bd00..465e4a51c 100644 --- a/src/methods/geom_relations/covers.jl +++ b/src/methods/geom_relations/covers.jl @@ -27,8 +27,8 @@ f ``` ```@example covers -covers(l1, p1) # returns true -covers(p1, l1) # returns false +GO.covers(l1, p1) # returns true +GO.covers(p1, l1) # returns false ``` ## Implementation diff --git a/src/methods/geom_relations/disjoint.jl b/src/methods/geom_relations/disjoint.jl index 7d7876a5a..3ec64898c 100644 --- a/src/methods/geom_relations/disjoint.jl +++ b/src/methods/geom_relations/disjoint.jl @@ -25,7 +25,7 @@ f We can see that none of the edges or vertices of l1 interact with l2 so they are disjoint. ```@example disjoint -disjoint(l1, l2) # returns true +GO.disjoint(l1, l2) # returns true ``` ## Implementation diff --git a/src/methods/geom_relations/intersects.jl b/src/methods/geom_relations/intersects.jl index f735890cd..8e0a71027 100644 --- a/src/methods/geom_relations/intersects.jl +++ b/src/methods/geom_relations/intersects.jl @@ -23,7 +23,7 @@ of tuple points. To provide an example, consider these two lines: ```@example intersects_intersection import GeometryOps as GO -import GeoInterface a GI +import GeoInterface as GI using Makie using CairoMakie From 336c7eec6b48c8773a9f1fba9c15f5bab0bf5d79 Mon Sep 17 00:00:00 2001 From: Skylar Gering Date: Fri, 26 Jan 2024 14:11:22 -0800 Subject: [PATCH 12/12] More document fixes --- src/methods/distance.jl | 11 ++++++----- src/methods/geom_relations/touches.jl | 2 +- src/methods/geom_relations/within.jl | 4 ++-- 3 files changed, 9 insertions(+), 8 deletions(-) diff --git a/src/methods/distance.jl b/src/methods/distance.jl index f103d8dd7..3973b5cc6 100644 --- a/src/methods/distance.jl +++ b/src/methods/distance.jl @@ -19,6 +19,7 @@ To provide an example, consider this rectangle: import GeometryOps as GO import GeoInterface as GI using Makie +using CairoMakie rect = GI.Polygon([[(0,0), (0,1), (1,1), (1,0), (0, 0)]]) point_in = (0.5, 0.5) @@ -32,9 +33,9 @@ This is clearly a rectangle with one point inside and one point outside. The points are both an equal distance to the polygon. The distance to point_in is negative while the distance to point_out is positive. ```@example rect -GO.distance(point_in, poly) # == 0 -GO.signed_distance(point_in, poly) # < 0 -GO.signed_distance(point_out, poly) # > 0 +GO.distance(point_in, rect) # == 0 +GO.signed_distance(point_in, rect) # < 0 +GO.signed_distance(point_out, rect) # > 0 ``` ## Implementation @@ -117,7 +118,7 @@ _distance(::Type{T}, ::GI.PointTrait, point, ::GI.LinearRingTrait, geom) where T _distance_curve(T, point, geom; close_curve = true) # Point-Polygon function _distance(::Type{T}, ::GI.PointTrait, point, ::GI.PolygonTrait, geom) where T - GI.within(point, geom) && return zero(T) + within(point, geom) && return zero(T) return _distance_polygon(T, point, geom) end @@ -176,8 +177,8 @@ end # Point-Polygon function _signed_distance(::Type{T}, ::GI.PointTrait, point, ::GI.PolygonTrait, geom) where T min_dist = _distance_polygon(T, point, geom) + return within(point, geom) ? -min_dist : min_dist # negative if point is inside polygon - return GI.within(point, geom) ? -min_dist : min_dist end diff --git a/src/methods/geom_relations/touches.jl b/src/methods/geom_relations/touches.jl index 0c8845bad..9f92497bd 100644 --- a/src/methods/geom_relations/touches.jl +++ b/src/methods/geom_relations/touches.jl @@ -27,7 +27,7 @@ f ``` We can see that these two lines touch only at their endpoints. ```@example touches -touches(l1, l2) # true +GO.touches(l1, l2) # true ``` ## Implementation diff --git a/src/methods/geom_relations/within.jl b/src/methods/geom_relations/within.jl index dfaaa9b29..da8b851cb 100644 --- a/src/methods/geom_relations/within.jl +++ b/src/methods/geom_relations/within.jl @@ -27,8 +27,8 @@ f We can see that all of the points and edges of l2 are within l1, so l2 is within l1, but l1 is not within l2 ```@example within -within(l1, l2) # false -within(l2, l1) # true +GO.within(l1, l2) # false +GO.within(l2, l1) # true ``` ## Implementation