test-kivy-app/kivy_venv/lib/python3.11/site-packages/kivy/tools/image-testsuite/imagemagick-testsuite.sh

239 lines
7.2 KiB
Bash
Raw Normal View History

2024-09-15 12:12:16 +00:00
#!/usr/bin/env sh
# ImageMagickFormat:extension
FMT_OPAQUE="TIFF:tiff BMP:bmp BMP3:bmp PNG:png GIF87:gif CUR:cur \
PPM:ppm FITS:fits RAS:ras"
FMT_BINARY="BMP:bmp GIF:gif PNG8:png PNG24:png PNG48:png ICO:ico"
FMT_ALPHA="PNG32:png PNG64:png TGA:tga SGI:sgi DPX:dpx"
# FIXME: Magick output is not completely predictable. Some images
# become gray+alpha, some palette, some bitonal, and it's not obvious
# how/if this can be controlled better
#FMT_BITONAL=""
FMT_GRAY_OPAQUE="PGM:pgm FITS:fits RAS:ras"
FMT_GRAY_BINARY="PNG8:png"
FMT_GRAY_ALPHA="PNG:png TGA:tga"
# Pixel values used for different tests
PIX_alpha="twxrgbcyp48A"
PIX_opaque="wxrgbcyp48A"
PIX_binary="twrgbcyp48A"
PIX_gray_opaque="0123456789ABCDEF"
PIX_gray_binary="t123456789ABCDEF"
PIX_gray_alpha="t0123456789ABCDEF"
usage() { cat <<EOM
Usage: $0 <target-directory>
Creates test images in many formats using ImageMagick 'convert'
utility. The pixel values are encoded in the filename, so they
can be reconstructed and verified independently. This system
is referred to as the image test protocol (version 0).
More info: kivy/tools/image-testsuite/README.md
EOM
}
# Outputs command line arguments for convert to draw pixels from the
# specified pattern in the specified direction. It is always 1 in w or h.
draw_pattern() {
pattern=$1
direction="${2:-x}"
pos=0
for char in $(echo $pattern | fold -w1); do
case $char in
t) fill="#00000000" ;;
w) fill="#FFFFFF${TESTALPHA}" ;;
x) fill="#000000${TESTALPHA}" ;;
r) fill="#FF0000${TESTALPHA}" ;;
g) fill="#00FF00${TESTALPHA}" ;;
b) fill="#0000FF${TESTALPHA}" ;;
y) fill="#FFFF00${TESTALPHA}" ;;
c) fill="#00FFFF${TESTALPHA}" ;;
p) fill="#FF00FF${TESTALPHA}" ;;
0|1|2|3|4|5|6|7|8|9|A|B|C|D|E|F)
fill="#${char}${char}${char}${char}${char}${char}${TESTALPHA}"
;;
*) (>&2 echo "Error: Invalid pattern char: $char"); exit 100 ;;
esac
case $direction in
y|height) echo -n "-draw 'fill $fill color 0, $pos point' " ;;
x|width) echo -n "-draw 'fill $fill color $pos, 0 point' " ;;
esac
pos=$((pos+1))
done
}
# Creates 1xN and Nx1 test images from the given pattern, in the given
# format. Only use alpha != FF if you are actually testing alpha.
make_images() {
pattern=$1
len=${#pattern}
if [ -z $pattern ] || [ -z $TESTFMT ] || [ -z $TESTEXT ]; then
(>&2 echo "make_images() missing required arguments/environment")
exit 101
fi
if [ ${#TESTALPHA} != 2 ]; then
(>&2 echo "make_images() invalid TESTALPHA: $TESTALPHA")
exit 102
fi
# Nx1
ending="${TESTALPHA}_${TESTFMT}_${TESTNAME}_magick.${TESTEXT}"
outfile="v0_${len}x1_${pattern}_${ending}"
eval convert -size ${len}x1 xc:none -quality 100% $TESTARGS \
$(draw_pattern "$pattern" "x") \
${convert_args} \
"${TESTFMT}:$destdir/$outfile"
# 1xN - don't create duplicates for single pixel
if [ $len -ne 1 ]; then
outfile="v0_1x${len}_${pattern}_${ending}"
eval convert -size 1x${len} xc:none -quality 100% $TESTARGS \
$(draw_pattern "$pattern" "y") \
"${TESTFMT}:$destdir/$outfile"
fi
}
# Make a random pattern from given characters $1 at length $2
# FIXME: portability?
mkpattern() {
< /dev/urandom LC_ALL=C tr -dc "$1" | head -c $2
}
# Makes simple permutations and random patterns, optionally with
# prefix and postfix (args are pattern, prefix, postfix)
permutepattern() {
if [ -z "$1" ]; then
(>&2 echo "permutepattern() missing required argument")
exit 200
fi
# Individual pixel values + poor permutation FIXME
for char in $(echo $1 | fold -w1); do
echo -n "$2${char}$3 "
if [ ! -z $p1 ]; then echo -n "$2${char}${p1}$3 "; fi
# Uncomment for more data
# if [ ! -z $p2 ]; then echo -n "$2${char}${p1}${p2}$3 "; fi
# if [ ! -z $p3 ]; then echo -n "$2${char}${p1}${p2}${p3}$3 "; fi
# if [ ! -z $p4 ]; then echo -n "$2${char}${p1}${p2}${p3}${p4}$3 "; fi
p4=$p3 ; p3=$p2 ; p2=$p1 ; p1=$char
done
# Random
for i in $(seq 3 9) $(seq 14 17) $(seq 31 33); do
echo -n "$2$(mkpattern "$1" "$i")$3 "
done
}
# ------------------------------------------------------------
# Main
# ------------------------------------------------------------
if [ "$#" -ne 1 ] || [ -z "$1" ]; then
echo "Usage: $0 <target-directory> (or -h for help)"
exit 1
fi
case $1 in
-h|--help) usage; exit 1 ;;
esac
if [ ! -d "$1" ]; then
(>&2 echo "Error: Destination directory '$1' does not exist")
exit 2
elif [ ! -w "$1" ]; then
(>&2 echo "Error: Destination directory '$1' not writeable")
exit 2
fi
destdir=$(cd "$1"; echo $(pwd))
if [ ! -x "$(command -v convert)" ]; then
(2>&1 echo "Required ImageMagick 'convert' not found in path")
exit 3
fi
# - Opaque patterns only include solid colors, alpha is fixed at FF
# - Binary patterns MUST include 't' pixels and MUST NOT include 'x' or '0'
# - Alpha can combine any pixel value and use alpha != FF
PAT_opaque=$(permutepattern "$PIX_opaque")
PAT_binary=$(permutepattern "$PIX_binary" "t")
PAT_alpha="${PAT_binary} $(permutepattern "$PIX_alpha")"
# Grayscale patterns use only grayscale pixel values + 't' and alpha,
# ie #000 #111 #222 .. #EEE #FFF (0 1 2 .. E F in patterns)
PAT_gray_opaque=$(permutepattern "$PIX_gray_opaque")
PAT_gray_binary=$(permutepattern "$PIX_gray_binary" "t")
PAT_gray_alpha="${PAT_gray_binary} $(permutepattern "$PIX_gray_alpha")"
start() {
TESTNAME="$1"
TESTARGS="$2"
TESTALPHA="FF"
TESTFMT=""
TESTEXT=""
}
inform() {
echo "[${TESTNAME}] Creating ${TESTFMT} (.${TESTEXT}) test images..."
}
# OPAQUE / GRAY_OPAQUE
start "OPAQUE" "-alpha off"
for rawfmt in $FMT_OPAQUE $FMT_BINARY $FMT_ALPHA; do
TESTFMT=${rawfmt%:*}; TESTEXT=${rawfmt#*:}; inform
for pat in $PAT_opaque; do
make_images "$pat"
done
done
start "GRAY-OPAQUE" "-alpha off -colorspace Gray"
for rawfmt in $FMT_GRAY_OPAQUE $FMT_GRAY_BINARY $FMT_GRAY_ALPHA; do
TESTFMT=${rawfmt%:*}; TESTEXT=${rawfmt#*:}; inform
for pat in $PAT_gray_opaque; do
make_images "$pat"
done
done
# BINARY / GRAY_BINARY
start "BINARY" "-alpha on"
for rawfmt in $FMT_BINARY $FMT_ALPHA; do
TESTFMT=${rawfmt%:*}; TESTEXT=${rawfmt#*:}; inform
for pat in $PAT_binary; do
make_images "$pat"
done
done
start "GRAY-BINARY" "-alpha on -colorspace Gray"
for rawfmt in $FMT_GRAY_BINARY $FMT_GRAY_ALPHA; do
TESTFMT=${rawfmt%:*}; TESTEXT=${rawfmt#*:}; inform
for pat in $PAT_gray_binary; do
make_images "$pat"
done
done
# ALPHA / GRAY_ALPHA
start "ALPHA" "-alpha on"
for rawfmt in $FMT_ALPHA; do
TESTFMT=${rawfmt%:*}; TESTEXT=${rawfmt#*:}; inform
for alpha in 7F F0; do
TESTALPHA=$alpha
for pat in $PAT_alpha; do
make_images "$pat"
done
done
done
start "GRAY-ALPHA" "-alpha on -colorspace Gray"
for rawfmt in $FMT_GRAY_ALPHA; do
TESTFMT=${rawfmt%:*}; TESTEXT=${rawfmt#*:}; inform
for alpha in 7F F0; do
TESTALPHA=$alpha
for pat in $PAT_gray_alpha; do
make_images "$pat"
done
done
done