Art board in ImageMagick -> transform passport photo / rectangle to fit square

[Oni64]

Hi,
In Photoshop its called an art board.

I need to shrink a RAW photo to fit a 64 * 64 pixel square.

In Photshop - once an art board is setup you can drag in an image into it. The image shrinks to fit, centered, within the 64 * 64 board (retaining aspect ratio). You can then click and drag the edges to the left/right/bottom boundaries.

Is there a way to automatically do this in ImageMagick?

So load and shrink image onto a 64 * 64 pixel canvas, centered, retain aspect ration:

Automatically drag image left and right until left/right boundary are hit by non background colour pixels:

OR keep going until - Drag image until bottom boundary is hit by non background colour pixels

Thanks so much

[fmw42]

I am not quite sure what you want. Is the image getting distorted by resizing to 64x64 square exactly?

Can you show an input and an output example?

Also please identify your ImageMagick version and platform, since syntax may vary.

Perhaps this is what you want, if you use ImageMagick 7?

magick monet2.jpg -set option:aspect "%w:%h" -resize 64x64 -gravity north -crop "%[aspect]" +repage result1.jpg

and similarly

magick barn.jpg -set option:aspect "%w:%h" -resize 64x64 -gravity north -crop "%[aspect]" +repage result2.jpg

[Oni64]

Thank you !!! The command works for photos where the shoulders are high.

But for shoulders that are low I need an OR command within convert to then only go to the bottom boundary.

When shoulders are high go to the left and right boundary (as per your command) OR
where shoulders are low I'd like this output:

Not down to the chin:

Input file:

Hopefully this is possible

[fmw42]

I do not know unless you provide a proper example of the desired output for a given input. If this is the same input image as before and you want some other output, then I do not know that ImageMagick can tell the contents of the image to be able to know where the shoulders are in the image and which way to choose. So show me an example input and the desired output from Photoshop.

But for shoulders that are low I need an OR command within convert to then only go to the bottom boundary.

When shoulders are high go to the left and right boundary (as per your command) OR
where shoulders are low I'd like this output:

I do not know what you want here. Your result is not square and is not the same aspect ratio as the input. I do not know where you want to stop at the bottom given full width! How are you determining that in Photoshop. If arbitrarily chosen by visual inspection, then ImageMagick is not going to know how to do that.

[Oni64]

Hopefully this helps. Lets say the passport photo has a blue background.
The raw file is shrunk to fit inside the 64 * 64 (leaving the grey quillotined bits).

The logic (thinking about it now) is:
Going from the bottom up determine where the highest point is on the left or right for the background colour (blue).

Now drag the image SE + SW until that point either hits the left / right boundary OR bottom boundary.

My ImageMagick knowledge is zero. However I have seen advanced, almost AI like commands.
Plus I can upgrade to the latest version... so I was hoping it had the above smarts.

[fmw42]

ImageMagick has no such feature for finding the bottom of the background. You would have to script something to search the borders for the bottom of the background color, assuming the background color is nearly constant within some tolerance (fuzz value). That is doable, but not built into ImageMagick.

ImageMagick does not have any AI or Deep learning built in, either.

[fmw42]

This is a Unix bash shell script. It requires ImageMagick 7.0.9.0 or higher.

infile="portrait.jpg"
bgcolor="white"
toler=1
y1=`convert "$infile" -gravity west -crop 1x+0+0 +repage -background "$bgcolor" \
-fuzz 1% -define trim:percent-background=0% -trim -format "%Y" info:`
y2=`convert "$infile" -gravity east -crop 1x+0+0 +repage -background "$bgcolor" \
-fuzz $toler% -define trim:percent-background=0% -trim -format "%Y" info:`
hh=`convert xc: -format "%[fx:max($y1,$y2)]" info:`
convert "$infile" -crop x${hh}+0+0 +repage -resize 64x64 result.jpg

Does that do what you want?

I have taken the lower of the two sides for finding where the background ends. You can change max to min if you want the higher of the two sides.

infile="portrait.jpg"
bgcolor="white"
toler=1
y1=`convert "$infile" -gravity west -crop 1x+0+0 +repage -background "$bgcolor" \
-fuzz 1% -define trim:percent-background=0% -trim -format "%Y" info:`
y2=`convert "$infile" -gravity east -crop 1x+0+0 +repage -background "$bgcolor" \
-fuzz $toler% -define trim:percent-background=0% -trim -format "%Y" info:`
hh=`convert xc: -format "%[fx:min($y1,$y2)]" info:`
convert "$infile" -crop x${hh}+0+0 +repage -resize 64x64 result2.jpg

[Oni64]

Had to use the following process:

1. convert statement -> output all photos to directory 1
2. python script -> output all photos to directory 2
3. select best photo; directory 1 (80% of photos) OR directory 2 (15% of photos) -> move to third directory
4. people with big hair / white shirts etc (5%) manually adjust image(s) using Photoshop art-board

1. convert statement
convert portrait.jpg -resize 64x64^ -gravity north -crop 64x64+0+0 result.jpg

2. python script

import numpy as np
import cv2
from PIL import Image
import sys

def crop_by_shoulders(img):
    (h, w) = img.shape[:2]
    h -= 1; w -= 1
    b,g,r = img[h, w]
    left_shoulder, right_shoulder, higher_shoulder = None, None, None
    for pixel in range(h, 0, -1):
        if img[pixel, w][0] == 0:
            b,g,r = img[pixel, w]
            if b == 0 and g == 0 and r == 0:
                right_shoulder = pixel+1
                break
    for pixel in range(h, 0, -1):
        if img[pixel, 0][0] == 0:
            b,g,r = img[pixel, 0]
            if b == 0 and g == 0 and r == 0:
                left_shoulder = pixel+1
                break
    if left_shoulder <= right_shoulder:
        higher_shoulder = left_shoulder
    else:
        higher_shoulder = right_shoulder
    #img = cv2.line(img, (0, higher_shoulder), (w, higher_shoulder), (0,255,0))

    crop_img = img[0:higher_shoulder, 0:w]
    #M = np.float32([[1,0,0],[0,1,h-higher_shoulder]])
    #img = cv2.warpAffine(img,M,(w+1,h+1))
    return crop_img

def background_to_white(img):
    (h, w) = img.shape[:2]

    for x in range(w):
        for y in range(h):
            if img[y, x][0] == 0:
                b,g,r = img[y, x]
                if b == 0 and g == 0 and r == 0:
                    img[y, x][0] = 255; img[y, x][1] = 255; img[y, x][2] = 255;
    return img

def center_in_canvas(img):
    resized = cv2.resize(img, (h, h), interpolation = cv2.INTER_AREA)

def get_holes(image, thresh):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    im_bw = cv2.threshold(gray, thresh, 255, cv2.THRESH_BINARY)[1]
    im_bw_inv = cv2.bitwise_not(im_bw)

    contour, _ = cv2.findContours(im_bw_inv, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
    for cnt in contour:
        cv2.drawContours(im_bw_inv, [cnt], 0, 255, -1)

    nt = cv2.bitwise_not(im_bw)
    im_bw_inv = cv2.bitwise_or(im_bw_inv, nt)
    return im_bw_inv

def remove_background(image, thresh, scale_factor=.25, kernel_range=range(1, 15), border=None):
    border = border or kernel_range[-1]

    holes = get_holes(image, thresh)
    small = cv2.resize(holes, None, fx=scale_factor, fy=scale_factor)
    bordered = cv2.copyMakeBorder(small, border, border, border, border, cv2.BORDER_CONSTANT)

    for i in kernel_range:
        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2*i+1, 2*i+1))
        bordered = cv2.morphologyEx(bordered, cv2.MORPH_CLOSE, kernel)

    unbordered = bordered[border: -border, border: -border]
    mask = cv2.resize(unbordered, (image.shape[1], image.shape[0]))
    fg = cv2.bitwise_and(image, image, mask=mask)
    return fg

def Resize(image):
    width = None; height = None
    (h, w) = image.shape[:2]
    if w >= h:
        width = 800
    else:
        height = 400
    inter = cv2.INTER_AREA
    dim = None
    if width is None:
        r = height / float(h)
        dim = (int(w * r), height)
    else:
        r = width / float(w)
        dim = (width, int(h * r))

    resized = cv2.resize(image, dim, interpolation = inter)
    return resized

img_src = sys.argv[1]
scale_factor = 2.8
img_output = "output.jpg"

if len(sys.argv) >= 3:
    img_output = sys.argv[2]
if len(sys.argv) >= 4:
    scale_factor = sys.argv[3]

img = cv2.imread(img_src)
img = Resize(img)

img = remove_background(img, 230)
img = crop_by_shoulders(img)

img = background_to_white(img)

(h, w) = img.shape[:2]
offset = int((h-w)/2)

if (offset > 0):
    img = cv2.copyMakeBorder(img, 0, 0, offset, offset, cv2.BORDER_CONSTANT, value=(255, 255, 255))
img = cv2.resize(img, (64, 64), interpolation=3)

cv2.imwrite(img_output, img)```