3×2 Matrix{Float64}:
 0.0  0.0
 1.0  0.0
 0.0  1.0

👀 Reading hidden code

points = [

0.0 0

1.0 0

0.0 1

]

29.4 ms

👀 Reading hidden code

begin

import Pkg

eval(quote

Pkg.add(url="https://github.com/paulgb/PenPlots.jl")

end)

using PenPlots

end

    Updating git-repo `https://github.com/paulgb/PenPlots.jl`
    Updating registry at `~/.julia/registries/General.toml`
   Resolving package versions...
    Updating `/tmp/jl_laZNme/Project.toml`
  [61246389] ~ PenPlots v0.1.0 `https://github.com/paulgb/PenPlots.jl#master` ⇒ v0.1.0 `https://github.com/paulgb/PenPlots.jl#master`
    Updating `/tmp/jl_laZNme/Manifest.toml`
  [61246389] ~ PenPlots v0.1.0 `https://github.com/paulgb/PenPlots.jl#master` ⇒ v0.1.0 `https://github.com/paulgb/PenPlots.jl#master`
Precompiling project...
  ✓ PenPlots
  1 dependency successfully precompiled in 3 seconds (55 already precompiled)

15.9 s

👀 Reading hidden code

using Triangulate

950 ms

TriangulateIO(
pointlist=[0.3 0.2 … 0.6 0.3; 0.5 0.1 … 0.5 0.4],
pointmarkerlist=Int32[0, 1, 1, 0, 0, 1, 1, 0, 0],
trianglelist=Int32[2 9 … 4 8; 9 2 … 3 9; 1 5 … 7 5],
)

TriangulateIO(
)

👀 Reading hidden code

let n=10,raster=10

triin=Triangulate.TriangulateIO()

triin.pointlist=hcat(unique([ Cdouble[rand(1:raster)/raster, rand(1:raster)/raster] for i in 1:n])...)

display(triin)

(triout, vorout)=Triangulate.triangulate("Q", triin)

end

TriangulateIO(
pointlist=[0.3 0.2 … 0.6 0.3; 0.5 0.1 … 0.5 0.4],
)

972 ms

2×10 Matrix{Float64}:
 0.5  0.8  0.7  0.6  0.6  1.0  0.5  0.7  0.9  0.8
 1.0  0.9  0.9  0.3  0.9  0.8  0.9  0.5  0.6  0.5

let n=10,raster=10

hcat(unique([ Cdouble[rand(1:raster)/raster, rand(1:raster)/raster] for i in 1:n])...)

end

👀 Reading hidden code

105 ms

to_triangulate_mat (generic function with 1 method)

function to_triangulate_mat(ps::AbstractVector{<:SVector})

# const output_type = eltype(eltype(ps))

# output_type = Float64

A = Matrix{Float64}(undef, length(eltype(ps)), length(ps))

for (i,p) in enumerate(ps)

@inbounds A[:,i] .= p

end

👀 Reading hidden code

1.6 ms

2×10 Matrix{Float64}:
 0.072019  0.653422  0.067267  0.469533  …  0.278194  0.587419  0.267624  0.690063
 0.84958   0.747645  0.404671  0.507266     0.137883  0.517669  0.778086  0.412671

aa = rand(2,10)

👀 Reading hidden code

16.5 μs

Error message

MethodError: no method matching reinterpret(::Int64, ::Type{StaticArrays.SVector{Float64, 2}}, ::Matrix{Float64})

Closest candidates are:

reinterpret(::typeof(reshape), ::Type{T}, ::A) where {T, S, A<:(AbstractArray{S})} at /opt/hostedtoolcache/julia/1.7.3/x64/share/julia/base/reinterpretarray.jl:52

reinterpret(::typeof(reshape), ::Type{T}, ::Base.ReinterpretArray{T, N, S, A, true} where {T, N, S, A<:(AbstractArray{S})}) where T at /opt/hostedtoolcache/julia/1.7.3/x64/share/julia/base/reinterpretarray.jl:124

reinterpret(::typeof(reshape), ::Type{T}, ::AbstractArray{T}) where T at /opt/hostedtoolcache/julia/1.7.3/x64/share/julia/base/reinterpretarray.jl:78

...

Stack trace

Here is what happened, the most recent locations are first:

from This cell: line 1
```
reinterpret(10, SVector{Float64,2}, aa)
```

reinterpret(10, SVector{Float64,2}, aa)

👀 Reading hidden code

---

triangulate_raw (generic function with 1 method)

function triangulate_raw(ps::AbstractVector{<:SVector}; switches::String="Q")

mat = to_triangulate_mat(ps)

triin=Triangulate.TriangulateIO()

triin.pointlist=mat

Triangulate.triangulate(switches, triin)

end

👀 Reading hidden code

2.0 ms

TriangulateIO(
pointlist=[-4.873846249394214 -26.91271218406321 … -84.12017716925446 15.769584596147782; -54.792440557174885 20.496053224163802 … 15.799630037932474 -14.731784723663102],
pointmarkerlist=Int32[1, 0, 1, 1, 0, 1, 0, 0, 1, 0],
trianglelist=Int32[10 9 … 10 8; 2 2 … 1 3; 6 7 … 4 7],
)

triangulate_raw(xx; switches="Q")[1]

👀 Reading hidden code

488 ms

triangulate (generic function with 1 method)

function triangulate(args...; kwargs...)

t, v = triangulate_raw(args...; kwargs...)

z = t.trianglelist

[

SVector{4,Int}(z[1,j], z[2,j], z[3,j], z[1,j] )

for j in 1:size(z,2)

]

end

👀 Reading hidden code

2.4 ms

n (generic function with 1 method)

n(prefix::String, value::Float64) = "$(prefix)$(@sprintf("%.15f",value))"

👀 Reading hidden code

5.7 ms

n (generic function with 2 methods)

n(prefix::String, value::Bool) = prefix

👀 Reading hidden code

386 μs

n (generic function with 3 methods)

n(prefix::String, value::Nothing) = ""

👀 Reading hidden code

387 μs

# let n=10,raster=10

# triin=Triangulate.TriangulateIO()

# triin.pointlist=hcat(unique([ Cdouble[rand(1:raster)/raster, rand(1:raster)/raster] for i in 1:n])...)

# display(triin)

# Triangulate.triangulate("Qa38.986q18.986037025490717", triin)[1].trianglelist

# end

👀 Reading hidden code

8.9 μs

build_switches (generic function with 1 method)

function build_switches(;

max_area::Union{Float64,Nothing}=nothing,

min_angle::Union{Float64,Nothing}=nothing,

quiet::Bool=true,

)

@assert isnothing(min_angle) || min_angle < 28.6 "Oh ohhh"

string(

n("Q", quiet),

n("a", max_area),

n("q", min_angle),

)

end

👀 Reading hidden code

2.2 ms

triangulate_true (generic function with 1 method)

function triangulate_true(args...; kwargs...)

t, v = triangulate_raw(args...; switches=build_switches(;kwargs...))

pl = t.pointlist

new_pl = [

SVector{2,Float64}(pl[1,j], pl[2,j] )

for j in 1:size(pl,2)

]

tl = t.trianglelist

new_tl = [

SVector{4,Int}(tl[1,j], tl[2,j], tl[3,j], tl[1,j] )

for j in 1:size(tl,2)

]

new_pl, new_tl

end

👀 Reading hidden code

3.5 ms

using HypertextLiteral

👀 Reading hidden code

5.5 ms

using CoordinateTransformations

👀 Reading hidden code

1.1 s

using Rotations

👀 Reading hidden code

132 μs

@label_bind (macro with 1 method)

👀 Reading hidden code

689 μs

max_area:

👀 Reading hidden code

384 ms

min_angle:

👀 Reading hidden code

716 ms

👀 Reading hidden code

1.2 s

StaticArrays.SVector{2, Float64}

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

-4.87385

-54.7924

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

-26.9127

20.4961

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

27.9032

52.8561

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

55.2015

17.2834

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

28.6224

5.67014

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

-8.26455

-52.0795

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

-13.1068

32.5014

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

12.0815

3.64507

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

-84.1202

15.7996

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

15.7696

-14.7318

xx = 30 .* randn(SVector{2,Float64},10)

👀 Reading hidden code

314 ms

Path([

SVector(1,2),

SVector(2,2),

SVector(1.2,1),

SVector(1,1.9),

])

👀 Reading hidden code

40.2 ms

# xx = [10000*SVector(p...) for p in small_dot.points[20:end]]

👀 Reading hidden code

12.8 μs

StaticArrays.SVector{2, Float64}

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

-38.951

-15.1554

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

-11.3598

-4.65926

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

-2.05894

-11.3297

const fillable_tri = 20*randn(SVector{2,Float64},3)

👀 Reading hidden code

24.0 ms

@bind fill_angle Slider(LinRange(0,2π,500))

👀 Reading hidden code

23.0 ms

[

fill_with_pattern(

fillable_tri;

step=2,

direction=SVector(cos(fill_angle),sin(fill_angle))

)...,

[

Path(200 .* (degree_rotation(rand(0:0)),) .* (small_dot.points) .+ (x,))

for x in fillable_tri

]...,

]

👀 Reading hidden code

249 ms

rotate_90 (generic function with 1 method)

rotate_90(p::SVector{2,<:Real}) = SVector(-p[2], p[1])

👀 Reading hidden code

678 μs

0.0

dot([1,1], rotate_90(SVector(0.5,0.5)))

👀 Reading hidden code

21.4 μs

-0.5

dot([1,0], rotate_90(SVector(0.5,0.5)))

👀 Reading hidden code

18.0 μs

👀 Reading hidden code

68.8 μs

fill_with_pattern (generic function with 1 method)

function fill_with_pattern(triangle_corners; step::Real=1.5, direction)

a, b, c = triangle_corners

AB = b - a

AC = c - a

BC = c - b

crossAB = rotate_90(AB)

z1, z2 = dot(rotate_90(direction), AC), dot(rotate_90(direction), BC)

# @info "asdf" z1 z2

# if z1 == 0

# if

# return fill_with_pattern((b,c,a); step, direction)

# end

# if z2 == 0

# # that's fine

# end

if z1 < 0

return fill_with_pattern((c,b,a); step, direction)

end

if z2 > 0

return fill_with_pattern((a,c,b); step, direction)

end

# direction = @something(direction, crossAB)

# if dot(AB,AC) < 0

# return fill_with_pattern((b,a,c))

# end

# if dot(-AB,BC) < 0

# return fill_with_pattern((a,c,b))

# end

ABlength = norm(AB)

AClength = norm(AC)

BClength = norm(BC)

direction *= ABlength / norm(direction)

step_AB = step / abs(dot(crossAB,direction)) * ABlength

map(step_AB/2:step_AB:1) do x

s = a + x * AB

yAC = x * dot(AC,crossAB) / dot(direction,rotate_90(AC))

yBC = -(1-x) * dot(BC,crossAB) / dot(direction,rotate_90(BC))

eAC = s + (

z1 == 0 ? yBC :

z2 == 0 ? yAC :

minabs(yAC, yBC)

) * direction

# eAC = s + yAC * direction

Path([s,eAC])

end

👀 Reading hidden code

4.9 ms

minabs (generic function with 1 method)

minabs(a,b) = abs(a) < abs(b) ? a : b

👀 Reading hidden code

455 μs

10-element LinRange{SVector{2, Float64}, Int64}:
 [-38.951, -15.1554],[-35.8853, -13.9892],…,[-14.4255, -5.8255],[-11.3598, -4.65926]

LinRange(fillable_tri[1], fillable_tri[2], 10)

👀 Reading hidden code

17.5 μs

using Interpolations

👀 Reading hidden code

3.1 s

using LinearAlgebra

👀 Reading hidden code

174 μs

split_lines

Split a Path into the single-line paths that it consists of, but check the return type...

"Split a `Path` into the single-line paths that it consists of, but check the return type..."

split_lines(p::Path)::Vector{Tuple{Point,Point}} = [

# Use `extrema` to "sort" the two points (which just works apparently!). This will canonalize the result.

extrema((p.points[i], p.points[i+1]))

for i in 1:length(p.points)-1

]

👀 Reading hidden code

1.8 ms

using BenchmarkTools

👀 Reading hidden code

129 ms

without_duplicate_lines (generic function with 1 method)

function without_duplicate_lines(paths::MultiPath)::MultiPath

original_lines = flatmap(split_lines, paths)

unique_lines = Set(original_lines)

sort([Path([l...]) for l in unique_lines])

end

👀 Reading hidden code

1.1 ms

without_duplicate_lines(result) .|> length |> sum

👀 Reading hidden code

460 μs

result .|> length |> sum

👀 Reading hidden code

87.9 ms

flatmap (generic function with 1 method)

flatmap(args...) = vcat(map(args...)...)

👀 Reading hidden code

510 μs

👀 Reading hidden code

66.8 μs

using PlutoUI

👀 Reading hidden code

311 ms

using Printf

👀 Reading hidden code

136 μs

random_subset (generic function with 1 method)

random_subset(xs) = xs[rand(Bool, length(xs))]

👀 Reading hidden code

437 μs

[

Path(xx[t])

for t in triangulate(xx; switches="Q")

]...,

[

Path(small_dot.points .+ (x,))

for x in xx

]...,

]

👀 Reading hidden code

291 ms

small_triangle = Path([

SVector(-.1, -.1),

SVector(0, .07),

SVector(.1, -.1),

SVector(-.1, -.1),

] .* .2)

👀 Reading hidden code

56.3 ms

small_dot = Path([

0.01 * x * SVector(cos(x*2π), sin(x*2π))

for x in LinRange(0,2,100)

])

👀 Reading hidden code

160 ms

StaticArrays.SVector{2, Float64}

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

-4.87385

-54.7924

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

-26.9127

20.4961

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

27.9032

52.8561

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

55.2015

17.2834

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

28.6224

5.67014

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

-8.26455

-52.0795

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

-13.1068

32.5014

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

12.0815

3.64507

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

-84.1202

15.7996

StaticArrays.SVector{2, Float64}: StaticArrays.SVector{2, Float64}:

15.7696

-14.7318

👀 Reading hidden code

10.5 μs

TriangulateIO(
pointlist=[-4.87385 -26.9127 … -84.1202 15.7696; -54.7924 20.4961 … 15.7996 -14.7318],
pointmarkerlist=Int32[1, 0, 1, 1, 0, 1, 0, 0, 1, 0],
trianglelist=Int32[4 2 … 5 10; 5 7 … 8 8; 10 9 … 10 2],
)

TriangulateIO(
)

triangulate_raw(xx; switches="QiC")

👀 Reading hidden code

95.1 μs

using StaticArrays

👀 Reading hidden code

168 μs

👀 Reading hidden code

67.5 μs

In the cloud (experimental)

On your computer

Frontmatter

Preview