Thickness and In Bounds check - keyword args

Project.toml

@@ -1,8 +1,9 @@
 name = "ImageDraw"
 uuid = "4381153b-2b60-58ae-a1ba-fd683676385f"
-version = "0.2.2"
+version = "0.2.3"
 
 [deps]
+Combinatorics = "861a8166-3701-5b0c-9a16-15d98fcdc6aa"
 Distances = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7"
 ImageCore = "a09fc81d-aa75-5fe9-8630-4744c3626534"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

src/ImageDraw.jl

@@ -1,7 +1,7 @@
 module ImageDraw
 
 # package code goes here
-using ImageCore, Distances
+using ImageCore, Distances, Combinatorics
 
 include("core.jl")
 include("line2d.jl")

src/circle2d.jl

@@ -5,7 +5,8 @@ import LinearAlgebra: det
 CirclePointRadius(x::Int, y::Int, ρ::T) where {T<:Real} = CirclePointRadius(Point(x,y), ρ)
 CirclePointRadius(p::CartesianIndex{2}, ρ::T) where {T<:Real} = CirclePointRadius(Point(p), ρ)
 
-draw!(img::AbstractArray{T, 2}, circle::CirclePointRadius, color::T) where {T<:Colorant} = draw!(img, Ellipse(circle), color)
+draw!(img::AbstractArray{T, 2}, circle::CirclePointRadius, color::T; in_bounds::Bool=false, thickness::Integer=-1) where {T<:Colorant} =
+    draw!(img, Ellipse(circle), color, in_bounds=in_bounds, thickness=thickness)
 
 #CircleThreePoints methods
 
@@ -14,7 +15,7 @@ CircleThreePoints(x1::Int, y1::Int, x2::Int, y2::Int, x3::Int, y3::Int) =
 CircleThreePoints(p1::CartesianIndex{2}, p2::CartesianIndex{2}, p3::CartesianIndex{2}) =
     CircleThreePoints(Point(p1), Point(p2), Point(p3))
 
-function draw!(img::AbstractArray{T, 2}, circle::CircleThreePoints, color::T) where T<:Colorant
+function draw!(img::AbstractArray{T, 2}, circle::CircleThreePoints, color::T; in_bounds::Bool=false, thickness::Integer=-1) where T<:Colorant
     ind = axes(img)
     x1 = circle.p1.x; y1 = circle.p1.y
     x2 = circle.p2.x; y2 = circle.p2.y
@@ -25,5 +26,5 @@ function draw!(img::AbstractArray{T, 2}, circle::CircleThreePoints, color::T) wh
     ρ = euclidean([x1, y1], R)
     (first(ind[2]) <= R[1] <= last(ind[2]) && first(ind[1]) <= R[2] <= last(ind[1])) || error("Center of circle is out of the bounds of image")
     ρ - 1 <= minimum(abs, [R[1] - first(ind[2]), R[1] - last(ind[2]), R[2] - first(ind[1]), R[2] - last(ind[1])]) || error("Circle is out of the bounds of image : Radius is too large")
-    draw!(img, CirclePointRadius(Point(round(Int,R[1]), round(Int,R[2])), ρ), color)
+    draw!(img, CirclePointRadius(Point(round(Int,R[1]), round(Int,R[2])), ρ), color, in_bounds=in_bounds, thickness=thickness)
 end

src/core.jl

@@ -14,8 +14,42 @@ struct Point <: Drawable
     y::Int
 end
 
-abstract type Line <: Drawable end
-abstract type Circle <: Drawable end
+abstract type AbstractPath <: Drawable end
+abstract type AbstractLine <: Drawable end
+abstract type AbstractShape <: Drawable end
+abstract type AbstractBackground <: Drawable end
+
+
+abstract type AbstractPolygon <: AbstractShape end
+abstract type AbstractEllipse <: AbstractShape end
+abstract type AbstractCircle <: AbstractEllipse end
+
+"""
+    background = SolidBackground(color)
+
+A `Drawable` background that will fill the 'background' of an image with
+the set color
+"""
+
+struct SolidBackground{T<:Colorant} <: AbstractBackground
+    color::T
+end
+
+"""
+    background = StripedBackground(color)
+
+A `Drawable` background that will fill the 'background' of an image with
+the given colors at the intervals given at the given angle
+"""
+
+struct StripedBackground{T<:Colorant,  U<:Real, V<:Real} <: AbstractBackground
+    colors::Vector{T}
+    distances::Vector{U}
+    θ::V
+end
+
+
+struct NoisyBackground <: AbstractBackground end
 
 
 """
@@ -24,7 +58,7 @@ abstract type Circle <: Drawable end
 A `Drawable` infinite length line passing through the two points
 `p1` and `p2`.
 """
-struct LineTwoPoints <: Line
+struct LineTwoPoints <: AbstractLine
     p1::Point
     p2::Point
 end
@@ -36,7 +70,7 @@ A `Drawable` infinte length line having perpendicular length `ρ` from
 origin and angle `θ` between the perpendicular and x-axis
 
 """
-struct LineNormal{T<:Real, U<:Real} <: Line
+struct LineNormal{T<:Real, U<:Real} <: AbstractLine
     ρ::T
     θ::U
 end
@@ -46,7 +80,7 @@ end
 
 A `Drawable` circle passing through points `p1`, `p2` and `p3`
 """
-struct CircleThreePoints <: Circle
+struct CircleThreePoints <: AbstractCircle
     p1::Point
     p2::Point
     p3::Point
@@ -57,7 +91,7 @@ end
 
 A `Drawable` circle having center `center` and radius `ρ`
 """
-struct CirclePointRadius{T<:Real} <: Circle
+struct CirclePointRadius{T<:Real} <: AbstractCircle
     center::Point
     ρ::T
 end
@@ -67,7 +101,7 @@ end
 
 A `Drawable` finite length line between `p1` and `p2`
 """
-struct LineSegment <: Drawable
+struct LineSegment <: AbstractLine
     p1::Point
     p2::Point
 end
@@ -80,7 +114,7 @@ of points in `[point]`.
 !!! note
     This will create a non-closed path. For a closed path, see `Polygon`
 """
-struct Path <: Drawable
+struct Path <: AbstractPath
     vertices::Vector{Point}
 end
 
@@ -90,7 +124,7 @@ end
 A `Drawable` ellipse with center `center` and parameters `ρx` and `ρy`
 
 """
-struct Ellipse{T<:Real, U<:Real} <: Drawable
+struct Ellipse{T<:Real, U<:Real} <: AbstractEllipse
     center::Point
     ρx::T
     ρy::U
@@ -104,7 +138,7 @@ consecutive points in `[vertex]` along with the first and last point.
 !!! note
     This will create a closed path. For a non-closed path, see `Path`
 """
-struct Polygon <: Drawable
+struct Polygon <: AbstractPolygon
     vertices::Vector{Point}
 end
 
@@ -120,7 +154,7 @@ A `Drawable` regular polygon.
 * `θ::Real` : orientation of the polygon w.r.t x-axis (in radians)
 
 """
-struct RegularPolygon{T<:Real, U<:Real} <: Drawable
+struct RegularPolygon{T<:Real, U<:Real} <: AbstractPolygon
     center::Point
     side_count::Int
     side_length::T
@@ -131,19 +165,31 @@ end
     cross = Cross(c, range::UnitRange{Int})
 A `Drawable` cross passing through the point `c` with arms ranging across `range`.
 """
-struct Cross <: Drawable
+struct Cross <: AbstractPath
     c::Point
     range::UnitRange{Int}
 end
 
+"""
+    img_map = ImageMap(img, x, y)
+
+Overlays an image on an larger image. (x, y) is the center for placing the image
+"""
+struct ImageMap <: Drawable
+    image
+    x
+    y
+end
+
 """
     img = draw!(img, drawable, color)
     img = draw!(img, drawable)
 
 Draws `drawable` on `img` using color `color` which
 defaults to `oneunit(eltype(img))`
 """
-draw!(img::AbstractArray{T,2}, object::Drawable) where {T<:Colorant} = draw!(img, object, oneunit(T))
+draw!(img::AbstractArray{T,2}, object::Drawable; in_bounds::Bool=false, thickness::Integer=-1) where {T<:Colorant} =
+    draw!(img, object, oneunit(T), in_bounds=in_bounds, thickness=thickness)
 
 
 """
@@ -156,12 +202,13 @@ corresponding colors from `[color]` which defaults to `oneunit(eltype(img))`
 If only a single color `color` is specified then all objects will be
 colored with that color.
 """
-function draw!(img::AbstractArray{T,2}, objects::AbstractVector{U}, colors::AbstractVector{V}) where {T<:Colorant, U<:Drawable, V<:Colorant}
+function draw!(img::AbstractArray{T,2}, objects::AbstractVector{U}, colors::AbstractVector{V}; in_bounds::AbstractVector{Bool}=[false], thickness::AbstractVector{<:Integer}=[-1]) where {T<:Colorant, U<:Drawable, V<:Colorant}
     colors = copy(colors)
-    while length(colors) < length(objects)
-        push!(colors, oneunit(T))
-    end
-    foreach((object, color) -> draw!(img, object, color), objects, colors)
+    while length(colors) < length(objects) push!(colors, oneunit(T)) end
+    while length(in_bounds) < length(objects) push!(in_bounds, false) end
+    while length(thickness) < length(objects) push!(thickness, -1) end
+
+    foreach((object, color, in_b, thick) -> draw!(img, object, color), objects, colors, in_bounds, thickness)
     img
 end
 
@@ -181,15 +228,24 @@ draw(img::AbstractArray{T,2}, args...) where {T<:Colorant} = draw!(copy(img), ar
 Point(τ::Tuple{Int, Int}) = Point(τ...)
 Point(p::CartesianIndex) = Point(p[2], p[1])
 
-function draw!(img::AbstractArray{T,2}, point::Point, color::T) where T<:Colorant
-    drawifinbounds!(img, point, color)
+# Base.convert(::Type{Point}, t::Tuple{Int, Int}) = Point(t...)
+# Base.convert(::Type{Point}, p::CartesianIndex) = Point(p[2], p[1])
+
+draw!(img::AbstractArray{T,2}, p::Point, color::T = oneunit(T); in_bounds::Bool=false, thickness::Integer=-1) where {T<:Colorant} =
+    draw!(img, p.y, p.x, color, in_bounds=in_bounds, thickness=thickness)
+draw!(img::AbstractArray{T,2}, p::CartesianIndex{2}, color::T = oneunit(T); in_bounds::Bool=false, thickness::Integer=-1) where {T<:Colorant} =
+    draw!(img, Point(p), color, in_bounds=in_bounds, thickness=thickness)
+
+function draw!(img::AbstractArray{T,2}, y::Integer, x::Integer, color::T; in_bounds::Bool=false, thickness::Integer=-1) where T<:Colorant
+    in_bounds ? img[point.y, point.x] = color : drawifinbounds!(img, y, x, color)
+    thickness != -1 && drawwiththickness!(img, y, x, color, in_bounds, thickness)
+    img
 end
 
 """
-
     img_new = drawifinbounds!(img, y, x, color)
-    img_new = drawifinbounds!(img, Point, color)
-    img_new = drawifinbounds!(img, CartesianIndex, color)
+    img_new = drawifinbounds!(img, point, color)
+    img_new = drawifinbounds!(img, cartesianIndex, color)
 
 Draws a single point after checkbounds() for coordinate in the image.
 Color Defaults to oneunit(T)
@@ -200,6 +256,35 @@ drawifinbounds!(img::AbstractArray{T,2}, p::Point, color::T = oneunit(T)) where
 drawifinbounds!(img::AbstractArray{T,2}, p::CartesianIndex{2}, color::T = oneunit(T)) where {T<:Colorant} = drawifinbounds!(img, Point(p), color)
 
 function drawifinbounds!(img::AbstractArray{T,2}, y::Int, x::Int, color::T) where {T<:Colorant}
-    if checkbounds(Bool, img, y, x) img[y, x] = color end
+    checkbounds(Bool, img, y, x) && (img[y, x] = color)
+    img
+end
+
+"""
+    img_new = drawwiththickness!(img, y, x, color, thickness)
+    img_new = drawwiththickness!(img, point, color, thickness)
+    img_new = drawwiththickness!(img, cartesianIndex, color, thickness)
+
+Draws pixel with given thickness
+Color Defaults to oneunit(T)
+Thickness defaults to 1
+
+"""
+
+drawwiththickness!(img::AbstractArray{T,2}, p::Point, color::T, in_bounds::Bool, thickness::Integer) where {T<:Colorant} = drawwiththickness!(img, p.y, p.x, color, in_bounds, thickness)
+drawwiththickness!(img::AbstractArray{T,2}, p::CartesianIndex{2}, color::T, in_bounds::Bool, thickness::Integer) where {T<:Colorant} = drawifinbounds!(img, Point(p), color, in_bounds, thickness)
+
+function drawwiththickness!(img::AbstractArray{T,2}, y0::Int, x0::Int, color::T, in_bounds::Bool, thickness::Int) where {T<:Colorant}
+    n = Int(round(thickness / 2))
+    evn = thickness % 2 == 1 ? 0 : 1
+    pixels = [i for i = -(n-evn):n]
+
+    for (x,y) in Combinatorics.combinations(pixels, 2)
+        draw!(img, y0+y, x0+x, color, in_bounds=in_bounds)
+        draw!(img, y0+y, x0-x, color, in_bounds=in_bounds)
+        draw!(img, y0-y, x0+x, color, in_bounds=in_bounds)
+        draw!(img, y0-y, x0-x, color, in_bounds=in_bounds)
+    end
+    draw!(img, y0, x0, color, in_bounds=in_bounds)
     img
 end

src/cross.jl

@@ -4,12 +4,12 @@ A `Drawable` cross passing through the point `c` with arms that are `arm` pixels
 """
 Cross(c, arm::Int) = Cross(c, -arm:arm)
 
-function draw!(img::AbstractArray{T, 2}, cross::Cross, color::T) where T<:Colorant
+function draw!(img::AbstractArray{T, 2}, cross::Cross, color::T; in_bounds::Bool=false, thickness::Int=-1) where T<:Colorant
     for Δx in cross.range
-        drawifinbounds!(img, cross.c.y, cross.c.x + Δx, color)
+        draw!(img, cross.c.y, cross.c.x + Δx, color, in_bounds=in_bounds, thickness=thickness)
     end
     for Δy in cross.range
-        drawifinbounds!(img, cross.c.y + Δy, cross.c.x, color)
+        draw!(img, cross.c.y + Δy, cross.c.x, color, in_bounds=in_bounds, thickness=thickness)
     end
     img
 end

src/ellipse2d.jl

@@ -4,7 +4,7 @@ Ellipse(x::Int, y::Int, ρx::T, ρy::U) where {T<:Real, U<:Real} = Ellipse(Point
 Ellipse(p::CartesianIndex{2}, ρx::T, ρy::U) where {T<:Real, U<:Real} = Ellipse(Point(p), ρx, ρy)
 Ellipse(circle::CirclePointRadius) = Ellipse(circle.center, circle.ρ, circle.ρ)
 
-function draw!(img::AbstractArray{T, 2}, ellipse::Ellipse, color::T) where T<:Colorant
+function draw!(img::AbstractArray{T, 2}, ellipse::Ellipse, color::T; in_bounds::Bool=false, thickness::Int=-1) where T<:Colorant
 	ys = Int[]
 	xs = Int[]
 	for i in ellipse.center.y : ellipse.center.y + ellipse.ρy
@@ -17,10 +17,10 @@ function draw!(img::AbstractArray{T, 2}, ellipse::Ellipse, color::T) where T<:Co
 		end
 	end
 	for (yi, xi) in zip(ys, xs)
-		drawifinbounds!(img, yi, xi, color)
-		drawifinbounds!(img,2 * ellipse.center.y - yi, xi, color)
-		drawifinbounds!(img,yi, 2 * ellipse.center.x - xi, color)
-		drawifinbounds!(img, 2 * ellipse.center.y - yi, 2 * ellipse.center.x - xi, color)
+		draw!(img, yi, xi, color, in_bounds=in_bounds, thickness=thickness)
+		draw!(img,2 * ellipse.center.y - yi, xi, color, in_bounds=in_bounds, thickness=thickness)
+		draw!(img,yi, 2 * ellipse.center.x - xi, color, in_bounds=in_bounds, thickness=thickness)
+		draw!(img, 2 * ellipse.center.y - yi, 2 * ellipse.center.x - xi, color, in_bounds=in_bounds, thickness=thickness)
 	end
 	img
 end