Merge pull request #116 from JuliaImages/jc/alphacard

add two democards: "image difference view" and "alpha compositing"

Author: johnnychen94

Project.toml

@@ -20,6 +20,7 @@ ImageShow = "4e3cecfd-b093-5904-9786-8bbb286a6a31"
 Images = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
 MappedArrays = "dbb5928d-eab1-5f90-85c2-b9b0edb7c900"
 MosaicViews = "e94cdb99-869f-56ef-bcf0-1ae2bcbe0389"
+OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 PaddedViews = "5432bcbf-9aad-5242-b902-cca2824c8663"
 SimpleTraits = "699a6c99-e7fa-54fc-8d76-47d257e15c1d"
 TestImages = "5e47fb64-e119-507b-a336-dd2b206d9990"

docs/examples/spatial_transformation/alpha_compositing.jl

@@ -0,0 +1,103 @@
+# ---
+# title: Alpha Compositing
+# cover: assets/alpha_compositing.png
+# ---
+
+# This demonstration shows how [alpha compositing](https://en.wikipedia.org/wiki/Alpha_compositing)
+# can be done in 10 lines of code using
+# [OffsetArrays](https://github.com/JuliaArrays/OffsetArrays.jl) and
+# [PaddedViews](https://github.com/JuliaArrays/PaddedViews.jl)
+
+using Images, MosaicViews
+using OffsetArrays, PaddedViews # provide `OffsetArray` and `paddedviews`
+
+# ## 1. basic offset and pad operation
+
+# Assume that we have two objects with transparent color and we want to place them on a canvas
+# with partially overlapping.
+
+red_patch = fill(RGBA(1., 0., 0., 1), 24, 24)
+green_patch = fill(RGBA(0., 1., 0., 1), 32, 32)
+mosaicview(red_patch, green_patch; npad=20, nrow=1, fillvalue=colorant"white")
+
+# Assume the canvas axes starts from `(1, 1)`, here we keep the red patch unshifted,
+# and shift the green patch 6 pixels downward and 16 pixels rightward, and then
+# pad them to a common axes
+green_o = OffsetArray(green_patch, 6, 16)
+r, g = paddedviews(Gray(0.2), red_patch, green_o)
+mosaicview(r, g; npad=20, nrow=1, fillvalue=colorant"white")
+
+# Note that their axes and sizes are changed after shifting and padding:
+
+## Regardless of implementaion details, `Base.OneTo(32)` is mostly equivalent to `1:32`
+println("before shifting -- size: ", size(green_patch), " axes: ", axes(green_patch))
+println("after shifting  -- size: ", size(green_o), " axes: ", axes(green_o))
+println("after padding   -- size: ", size(g), " axes: ", axes(g))
+
+# Axes are preserved after padding, which means you can easily get original image from
+# padded results using
+
+r[axes(red_patch)...]
+g[axes(green_o)...]
+#md nothing #hide
+
+# As described [here](https://en.wikipedia.org/wiki/Alpha_compositing), there are several compositing
+# methods:
+
+## add operation
+out_add = r .+ g
+
+## clear operation
+out_clear = copy(r)
+out_clear[axes(green_o)...] .= colorant"black"
+
+## multiply operation
+out_mul = copy(r)
+## channel-wise multiplication
+channelview(out_mul)[:, axes(green_o)...] .*= channelview(green_o)
+
+## overlap operation
+out_over = copy(r)
+out_over[axes(green_o)...] .= green_o
+
+## display the results of these operation
+mosaicview(out_add, out_clear, out_mul, out_over;
+           npad=20, nrow=1, fillvalue=colorant"white")
+
+# ## 2. build the three-primary color panel
+
+# Now, let's use the same trick to build something more meaningful.
+# First we create three circles with colors red, green and blue
+
+using ImageDraw
+function make_circle(sz, c::T) where T
+    ## fill with transparent color to avoid black region
+    fillvalue = ARGB(c)
+    img = fill(ARGB{eltype(T)}(0., 0., 0., 0.), sz...)
+    origin = sz .÷ 2
+    r = sz .÷ 4
+    draw!(img, Ellipse(origin..., r...), fillvalue)
+    img
+end
+
+## create three circles with color red, green and blue
+red_c   = make_circle((256, 256), ARGB(1., 0., 0., 1.))
+green_c = make_circle((256, 256), ARGB(0., 1., 0., 1.))
+blue_c  = make_circle((256, 256), ARGB(0., 0., 1., 1.))
+
+mosaicview(red_c, green_c, blue_c; nrow=1)
+
+# Then, shift these circles to appropriate positions, pad them to common axes, and finally composite
+# using the add operation:
+
+r = size(red_c, 1) ÷ 8
+red_o   = OffsetArray(red_c,    r,  r)
+green_o = OffsetArray(green_c, -r,  0)
+blue_o  = OffsetArray(blue_c,   r, -r)
+
+color_panel = sum(paddedviews(zero(eltype(red_o)), red_o, green_o, blue_o))
+color_panel = color_panel[axes(red_c)...] # crop empty region
+
+# --- save covers --- #src
+using FileIO #src
+save("assets/alpha_compositing.png", color_panel) #src

docs/examples/spatial_transformation/image_diffview.jl

@@ -0,0 +1,44 @@
+# ---
+# title: Image Difference View
+# cover: assets/image_diffview.png
+# ---
+
+# This demonstration shows some common tricks in image comparision -- difference view
+
+# People with MATLAB experiences would miss the function
+# [`imshowpair`](https://www.mathworks.com/help/images/ref/imshowpair.html), but in JuliaImages
+# it is not that indispensable.
+
+using Images, MosaicViews
+using TestImages
+
+img = float.(testimage("cameraman"))
+## rotate img by 4 degrees and keep axes unchanged
+img_r = imrotate(img, -pi/45, axes(img))
+nothing #hide #md
+
+# `mosaicview` is a convenience tool to show multiple images, especially useful when they have
+# different sizes and colors.
+
+mosaicview(img, img_r; nrow=1, npad=20, fillvalue=colorant"white")
+
+# In some cases, when the differences of two images are relative insignificant, a plain
+# substraction can help amplify the difference.
+plain_diffview = @. img - img_r
+nothing #hide #md
+
+# For gray images, a fancy trick is to fill each image into different RGB channels
+# and make a RGB view
+RGB_diffview = colorview(RGB, channelview(img), channelview(img_r), fill(0., size(img)))
+nothing #hide #md
+
+# or convert the RGB view back to Gray image after that
+Gray_diffview = Gray.(RGB_diffview)
+
+mosaicview(plain_diffview, RGB_diffview, Gray_diffview;
+           nrow=1, npad=20, fillvalue=colorant"white")
+
+
+# --- save covers --- #src
+using FileIO #src
+save("assets/image_diffview.png", RGB_diffview) #src