--- /dev/null
+#!/bin/bash
+#
+# Developed by Fred Weinhaus 12/24/2009 .......... revised 8/1/2021
+#
+# ------------------------------------------------------------------------------
+#
+# Licensing:
+#
+# Copyright © Fred Weinhaus
+#
+# My scripts are available free of charge for non-commercial use, ONLY.
+#
+# For use of my scripts in commercial (for-profit) environments or
+# non-free applications, please contact me (Fred Weinhaus) for
+# licensing arrangements. My email address is fmw at alink dot net.
+#
+# If you: 1) redistribute, 2) incorporate any of these scripts into other
+# free applications or 3) reprogram them in another scripting language,
+# then you must contact me for permission, especially if the result might
+# be used in a commercial or for-profit environment.
+#
+# My scripts are also subject, in a subordinate manner, to the ImageMagick
+# license, which can be found at: http://www.imagemagick.org/script/license.php
+#
+# ------------------------------------------------------------------------------
+#
+####
+#
+# USAGE: downsize [-s size] [-t toler] [-m maxiter] [-c copy] [-S strip]
+# infile outfile
+# USAGE: downsize [-help]
+#
+# OPTIONS:
+#
+# -s size desired output file size in kilobytes; float>0;
+# default=200
+# -t toler tolerance or allowed size of result greater than
+# desired size expressed as percent of desired size;
+# float>=0; default=10
+# -m maxiter maximum number of iterations to stop; integer>1;
+# default=20
+# -c copy copy to output when not downsizing and no image
+# format change; yes (y) or no (n); default=yes
+# -S strip strip all meta data; yes (y) or no (n); default=yes
+#
+###
+#
+# NAME: DOWNSIZE
+#
+# PURPOSE: To downsize (reduce) an image to a specified file size.
+#
+# DESCRIPTION: DOWNSIZE reduces an image's dimensions to achieve a specified
+# file size. For non-JPG images, processing will continue until either the
+# desired tolerance is achieved or the maximum number of iterations is reached.
+# For JPG images, processing will continue as above, but may stop when no
+# change of file size (or quality) occurs. Thus the desired file size may not
+# full be achieved to within the specified tolerance. Approximately 1%
+# tolerance is practical amount that can be achieved for non-JPG images. For
+# JPG images, the value may or may not be achieved. When strip is no,
+# processing will be skipped, if the input file size is less than or equal to
+# the combined desired file size plus the size of the meta data or if the
+# desired size is less than the meta data size.
+#
+# OPTIONS:
+#
+# -s size ... SIZE is the desired output image size in kilobytes. Values are
+# floats>0. The default=200
+#
+# -t toler ... TOLER is allowed size of the result within than the desire
+# size expressed as a percent of the desired size. Values are floats>=0.
+# The default=10. Processing will iterate until the resulting image size
+# is within the tolerance. If the tolerance is too low, then iterations will
+# stop when it reaches a value of maxiter. The default=10 (10%). If both toler
+# and maxiter are too small, then iteration could continue indefinitely,
+# since the algorithm may not be able to get as close as desired.
+#
+# -m maxiter ... MAXITER is the maximum number of iterations to stop. Values
+# are integer>1. The default=20. If both toler and maxiter are too small,
+# then iteration could continue indefinitely, since the algorithm may not
+# be able to get as close as desired.
+#
+# -c copy ... COPY will copy the input to the output when both no downsize
+# processing happens and the input and output formats are the same.
+# Values are either: yes (y) or no (n). Yes means make a copy of the input
+# with the output name and no means simply skip processing and do not copy
+# The input data to the output file. The default=yes.
+#
+# -S strip ... STRIP all meta data. Choices are: yes (y) or no (n). The
+# default=yes. Note that if you do not strip, the file size will be limited
+# to the size of the meta data.
+#
+# NOTE: Images will be converted to 8 bits/pixel/channel.
+#
+# CAVEAT: No guarantee that this script will work on all platforms,
+# nor that trapping of inconsistent parameters is complete and
+# foolproof. Use At Your Own Risk.
+#
+######
+#
+
+# set default values
+size=200 # desired output filesize in kilobytes
+toler=10 # tolerance as percent of size; toler>=0
+maxiter=20 # maximum iterations
+copy="yes" # copy to output when not downsizing if no image format change
+strip="yes" # strip meta data; yes or no
+toler1=10 # initial iteration for jpg; final iteration uses toler
+
+
+# set directory for temporary files
+dir="/tmp" # suggestions are dir="." or dir="/tmp"
+
+# set up functions to report Usage and Usage with Description
+PROGNAME=`type $0 | awk '{print $3}'` # search for executable on path
+PROGDIR=`dirname $PROGNAME` # extract directory of program
+PROGNAME=`basename $PROGNAME` # base name of program
+usage1()
+ {
+ echo >&2 ""
+ echo >&2 "$PROGNAME:" "$@"
+ sed >&2 -e '1,/^####/d; /^###/g; /^#/!q; s/^#//; s/^ //; 4,$p' "$PROGDIR/$PROGNAME"
+ }
+usage2()
+ {
+ echo >&2 ""
+ echo >&2 "$PROGNAME:" "$@"
+ sed >&2 -e '1,/^####/d; /^######/g; /^#/!q; s/^#*//; s/^ //; 4,$p' "$PROGDIR/$PROGNAME"
+ }
+
+
+# function to report error messages
+errMsg()
+ {
+ echo ""
+ echo $1
+ echo ""
+ usage1
+ exit 1
+ }
+
+
+# function to test for minus at start of value of second part of option 1 or 2
+checkMinus()
+ {
+ test=`echo "$1" | grep -c '^-.*$'` # returns 1 if match; 0 otherwise
+ [ $test -eq 1 ] && errMsg "$errorMsg"
+ }
+
+# test for correct number of arguments and get values
+if [ $# -eq 0 ]
+ then
+ # help information
+ echo ""
+ usage2
+ exit 0
+elif [ $# -gt 12 ]
+ then
+ errMsg "--- TOO MANY ARGUMENTS WERE PROVIDED ---"
+else
+ while [ $# -gt 0 ]
+ do
+ # get parameter values
+ case "$1" in
+ -help) # help information
+ echo ""
+ usage2
+ exit 0
+ ;;
+ -c) # get copy
+ shift # to get the next parameter
+ # test if parameter starts with minus sign
+ errorMsg="--- INVALID COPY SPECIFICATION ---"
+ checkMinus "$1"
+ copy=`echo "$1" | tr '[A-Z]' '[a-z]'`
+ case "$copy" in
+ yes|y) copy="yes";;
+ no|n) copy="no";;
+ *) errMsg "--- COPY=$copy IS AN INVALID VALUE ---"
+ esac
+ ;;
+ -s) # get size
+ shift # to get the next parameter
+ # test if parameter starts with minus sign
+ errorMsg="--- INVALID SIZE SPECIFICATION ---"
+ checkMinus "$1"
+ size=`expr "$1" : '\([.0-9]*\)'`
+ sizetest=`echo "$size <= 0" | bc`
+ [ $sizetest -eq 1 ] && errMsg "--- SIZE=$size MUST BE A FLOAT GREATER THAN 0 ---"
+ ;;
+ -t) # get toler
+ shift # to get the next parameter
+ # test if parameter starts with minus sign
+ errorMsg="--- INVALID TOLER SPECIFICATION ---"
+ checkMinus "$1"
+ toler=`expr "$1" : '\([.0-9]*\)'`
+ tolertest=`echo "$toler < 0" | bc`
+ [ $tolertest -eq 1 ] && errMsg "--- TOLER=$toler MUST BE A NON-NEGATIVE FLOAT ---"
+ ;;
+ -m) # get maxiter
+ shift # to get the next parameter
+ # test if parameter starts with minus sign
+ errorMsg="--- INVALID MAXITER SPECIFICATION ---"
+ checkMinus "$1"
+ maxiter=`expr "$1" : '\([0-9]*\)'`
+ maxitertest=`echo "$maxiter < 1" | bc`
+ [ $maxitertest -eq 1 ] && errMsg "--- MAXITER=$maxiter MUST BE A POSITIVE INTEGER ---"
+ ;;
+ -S) # get strip
+ shift # to get the next parameter
+ # test if parameter starts with minus sign
+ errorMsg="--- INVALID STRIP SPECIFICATION ---"
+ checkMinus "$1"
+ strip=`echo "$1" | tr '[A-Z]' '[a-z]'`
+ case "$strip" in
+ yes|y) strip="yes";;
+ no|n) strip="no";;
+ *) errMsg "--- STRIP=$strip IS AN INVALID VALUE ---"
+ esac
+ ;;
+ -) # STDIN and end of arguments
+ break
+ ;;
+ -*) # any other - argument
+ errMsg "--- UNKNOWN OPTION ---"
+ ;;
+ *) # end of arguments
+ break
+ ;;
+ esac
+ shift # next option
+ done
+ #
+ # get infile and outfile
+ infile="$1"
+ outfile="$2"
+fi
+
+# test that infile provided
+[ "$infile" = "" ] && errMsg "NO INPUT FILE SPECIFIED"
+
+# test that outfile provided
+[ "$outfile" = "" ] && errMsg "NO OUTPUT FILE SPECIFIED"
+
+
+# setup for stripping meta data
+if [ "$strip" = "yes" ]; then
+ stripping="-strip"
+else
+ stripping=""
+fi
+
+# get file type of input
+# ftypes are: JPEG, TIFF, PNG and GIF
+ftype=`convert "$infile" -ping -format "%m" info:`
+
+# get suffix of outfile
+outlist=`echo $outfile | tr "." " "`
+partsArray=($outlist)
+numparts=${#partsArray[*]}
+suffix=${partsArray[$numparts-1]}
+suffix=`echo $suffix | tr "[:lower:]" "[:upper:]"`
+[ "$suffix" = "JPG" ] && suffix="JPEG"
+[ "$suffix" = "TIF" ] && suffix="TIFF"
+
+# if ftype != suffix, set ftype to suffix
+# IM can deal with ftype TIFF or TIF and JPEG or JPG
+[ "$ftype" != "$suffix" ] && changetype="yes" || changetype="no"
+[ "$ftype" != "$suffix" ] && ftype=$suffix
+
+# if JPG, then set quality to 100
+if [ "$ftype" = "JPEG" ]; then
+ setquality="-quality 100"
+ setunits="-units pixelsperinch"
+else
+ setquality=""
+ setunits=""
+fi
+
+# get input compression
+compression=`convert "$infile" -ping -format "%C" info:`
+
+if [ "$ftype" = "TIFF" -a "$compresson" = "JPEG" ]; then
+ setcompression="-compress none"
+elif [ "$ftype" = "TIFF" -a "$compresson" != "JPEG" ]; then
+ setcompression="-compress $compression"
+else
+ setcompression=""
+fi
+
+# if strip is no, get size of meta data in bytes
+if [ "$strip" = "no" ]; then
+ meta_list=`identify -verbose "$infile" | grep "Profile-" | sed 's/^[ ]*//' | cut -d\ -f2`
+ meta_sum=0
+ for amt in $meta_list; do
+ meta_sum=$((meta_sum+amt))
+ done
+fi
+
+# set up temp file
+tmpA1="$dir/downsize_1_$$.$suffix"
+
+trap "rm -f $tmpA1;" 0
+trap "rm -f $tmpA1; exit 1" 1 2 3 15
+#trap "rm -f $tmpA1; exit 1" ERR
+
+# read the input image into the temp files and test validity.
+convert -quiet "$infile"[0] $stripping -depth 8 $setcompression $setquality $setunits +repage ${ftype}:$tmpA1 ||
+ errMsg "--- FILE $infile DOES NOT EXIST OR IS NOT AN ORDINARY FILE, NOT READABLE OR HAS ZERO SIZE ---"
+
+# get filesize
+# fullsize is converted to bytes
+# size2 is size converted to bytes
+test1=`convert $tmpA1 -ping -format "%b" info:- | grep "MB"`
+test2=`convert $tmpA1 -ping -format "%b" info:- | grep "KB"`
+test3=`convert $tmpA1 -ping -format "%b" info:- | grep "B"`
+fullsize=`convert -ping $tmpA1 -format "%b" info: | tr -d "[:alpha:]"`
+if [ "$test1" != "" ]; then
+ fullsize=`convert xc: -format "%[fx:$fullsize*1000000]" info:`
+elif [ "$test2" != "" ]; then
+ fullsize=`convert xc: -format "%[fx:$fullsize*1000]" info:`
+elif [ "$test3" != "" ]; then
+ fullsize=$fullsize
+else
+ errMsg="--- UNRECOGNIZED FILESIZE SUFFIX ---"
+fi
+size2=`convert xc: -format "%[fx:$size*1000]" info:`
+#echo "test1=$test1; test2=$test2; test3=$test3; ftype=$ftype; fullsize=$fullsize; size2=$size2;"
+
+# process image for strip=yes, if input size > desired size
+# process image for strip=no, if input size > desired size + meta size
+# and the desired size is greater than the meta size
+if [ "$strip" = "yes" ]; then
+ test4=`convert xc: -format "%[fx:($fullsize>$size2)?1:0]" info:`
+elif [ "$strip" = "no" ]; then
+ test4=`convert xc: -format "%[fx:($fullsize>$size2+$meta_size) && ($size2>=$meta_size)?1:0]" info:`
+ size2=$((size2+meta_size))
+fi
+
+if [ $test4 -eq 1 ]; then
+ # iterate
+ i=1
+ diffsize=0
+ iterate=1
+ newsize=$fullsize
+ if [ "$ftype" = "JPEG" ]; then
+ # iterate from previous image to new image as outfile
+ # this may give blurry results but close values
+ # so get the final images size and resize one last time from the original
+ # also use -define jpeg:extent=${size}KB which will change the quality to get closer
+ # if used the alternate method below with JPEG, sometimes got overshoots and pratio=nan since newsize became negative
+ convert $tmpA1 "$outfile"
+ while [ $iterate -eq 1 -a $i -lt $maxiter ]; do
+ # get sqrt size ratio in percent
+ pratio=`convert xc: -format "%[fx:100*sqrt($size/$newsize)]" info:`
+ #echo "i=$i; fullsize=$fullsize; size=$size; size2=$size2; newsize=${newsize}kB; pratio=$pratio;"
+
+ # resize image
+ convert "$outfile" -resize ${pratio}% -depth 8 $setquality $setunits ${ftype}:"$outfile"
+
+ # set newsize in KB
+ testa=`convert "$outfile" -ping -format "%b" info:- | grep "MB"`
+ testb=`convert "$outfile" -ping -format "%b" info:- | grep "KB"`
+ testc=`convert "$outfile" -ping -format "%b" info:- | grep "B"`
+ if [ "$testa" != "" ]; then
+ newsize=`convert "$outfile" $setquality ${ftype}:- | convert - -format "%b" info: | tr -d "[:alpha:]"`
+ newsize=`convert xc: -format "%[fx:$newsize*1000]" info:`
+ elif [ "$testb" != "" ]; then
+ newsize=`convert "$outfile" $setquality ${ftype}:- | convert - -format "%b" info: | tr -d "[:alpha:]"`
+ elif [ "$testc" != "" ]; then
+ newsize=`convert "$outfile" $setquality ${ftype}:- | convert - -format "%b" info: | tr -d "[:alpha:]"`
+ newsize=`convert xc: -format "%[fx:$newsize/1000]" info:`
+ fi
+ echo "i=$i newsize=${newsize}kB quality=100"
+ diffsize=`convert xc: -format "%[fx:($newsize-$size)]" info:`
+ iterate=`convert xc: -format "%[fx:abs($diffsize)>($toler1*$size/100)?1:0]" info:`
+ #echo "PART1: i=$i; newsize=${newsize}kB; diffsize=$diffsize; iterate=$iterate;"
+ i=$(($i+1))
+ done
+
+ # get final size of iterated outfile and then use that to resize the original
+ dim=`convert "$outfile" -format "%wx%h" info:`
+ convert $tmpA1 -resize $dim -define jpeg:extent=${size}KB -depth 8 $setquality $setunits ${ftype}:"$outfile"
+ # set newsize in KB
+ testa=`convert "$outfile" -ping -format "%b" info:- | grep "MB"`
+ testb=`convert "$outfile" -ping -format "%b" info:- | grep "KB"`
+ testc=`convert "$outfile" -ping -format "%b" info:- | grep "B"`
+ oldsize=$newsize
+ if [ "$testa" != "" ]; then
+ newsize=`convert -ping "$outfile" -format "%b" info: | tr -d "[:alpha:]"`
+ newsize=`convert xc: -format "%[fx:$newsize*1000]" info:`
+ elif [ "$testb" != "" ]; then
+ newsize=`convert -ping "$outfile" -format "%b" info: | tr -d "[:alpha:]"`
+ elif [ "$testc" != "" ]; then
+ newsize=`convert -ping "$outfile" -format "%b" info: | tr -d "[:alpha:]"`
+ newsize=`convert xc: -format "%[fx:$newsize/1000]" info:`
+ fi
+ quality=`convert -ping "$outfile" -format "%Q" info:`
+ echo "i=$i newsize=${newsize}kB quality=$quality"
+ diffsize=`convert xc: -format "%[fx:($size-$newsize)]" info:`
+ #newsign=`convert xc: -format "%[fx:sign($size-$newsize)]" info:`
+ #oldsign=$newsign
+ size1=`convert xc: -format "%[fx:$size+$diffsize]" info:`
+ iterate=`convert xc: -format "%[fx:abs($diffsize)>($toler*$size/100)?1:0]" info:`
+ #echo "PART2: i=$i; newsign=$newsign; oldsign=$oldsign; quality=$quality; size1=${size1}KB; newsize=${newsize}KB; diffsize=$diffsize; iterate=$iterate;"
+ i=$((i+1))
+
+ # iterate again changing jpeg write extent size
+# while [ $iterate -eq 1 -a $i -lt $maxiter -a $newsign -eq $oldsign -a "$newsize" != "$oldsize" ]; do
+ while [ $iterate -eq 1 -a $i -lt $maxiter -a "$newsize" != "$oldsize" ]; do
+ convert $tmpA1 -resize $dim -define jpeg:extent=${size1}KB -depth 8 $setquality $setunits ${ftype}:"$outfile"
+ # set newsize in KB
+ testa=`convert "$outfile" -ping -format "%b" info:- | grep "MB"`
+ testb=`convert "$outfile" -ping -format "%b" info:- | grep "KB"`
+ testc=`convert "$outfile" -ping -format "%b" info:- | grep "B"`
+ oldsize=$newsize
+ if [ "$testa" != "" ]; then
+ newsize=`convert -ping "$outfile" -format "%b" info: | tr -d "[:alpha:]"`
+ newsize=`convert xc: -format "%[fx:$newsize*1000]" info:`
+ elif [ "$testb" != "" ]; then
+ newsize=`convert -ping "$outfile" -format "%b" info: | tr -d "[:alpha:]"`
+ elif [ "$testc" != "" ]; then
+ newsize=`convert -ping "$outfile" -format "%b" info: | tr -d "[:alpha:]"`
+ newsize=`convert xc: -format "%[fx:$newsize/1000]" info:`
+ fi
+ quality=`convert -ping "$outfile" -format "%Q" info:`
+ echo "i=$i newsize=${newsize}kB quality=$quality"
+ diffsize=`convert xc: -format "%[fx:($size-$newsize)]" info:`
+ #oldsign=$newsign
+ #newsign=`convert xc: -format "%[fx:sign($size-$newsize)]" info:`
+ size1=`convert xc: -format "%[fx:0.5*($size+$newsize)]" info:`
+ iterate=`convert xc: -format "%[fx:abs($diffsize)>($toler*$size/100)?1:0]" info:`
+ #echo "PART3: i=$i; newsign=$newsign; oldsign=$oldsign; quality=$quality; size1=${size1}KB; newsize=${newsize}KB; diffsize=$diffsize; iterate=$iterate;"
+ i=$(($i+1))
+ done
+
+
+
+ else
+ while [ $iterate -eq 1 -a $i -lt $maxiter ]; do
+ # get sqrt size ratio in percent
+ size2=`convert xc: -format "%[fx:max($size2-($diffsize*1000),0)]" info:`
+ pratio=`convert xc: -format "%[fx:100*sqrt($size2/$fullsize)]" info:`
+ #echo "i=$i; fullsize=$fullsize; size=$size; size2=$size2; pratio=$pratio;"
+
+ testd=`convert xc: -format "%[fx:$size2<($toler*$size/100)?1:0]" info:`
+ [ $testd -eq 1 ] && break
+
+ # resize image
+ convert $tmpA1 -resize ${pratio}% -depth 8 $setcompression $setquality $setunits ${ftype}:"$outfile"
+ printsize=`convert "$outfile" -ping -format "%b" info:`
+ echo "i=$i; size=${printsize}"
+
+ testa=`convert "$outfile" -ping -format "%b" info:- | grep -i "MB"`
+ testb=`convert "$outfile" -ping -format "%b" info:- | grep -i "KB"`
+ testc=`convert "$outfile" -ping -format "%b" info:- | grep -i "B"`
+ if [ "$testa" != "" ]; then
+ newsize=`convert "$outfile" -depth 8 $setcompression $setquality $setunits ${ftype}:- | convert - -ping -format "%b" info: | tr -d "[:alpha:]"`
+ newsize=`convert xc: -format "%[fx:$newsize*1000]" info:`
+ elif [ "$testb" != "" ]; then
+ newsize=`convert "$outfile" -depth 8 $setcompression $setquality $setunits ${ftype}:- | convert - -ping -format "%b" info: | tr -d "[:alpha:]"`
+ elif [ "$testc" != "" ]; then
+ newsize=`convert "$outfile" -depth 8 $setcompression $setquality $setunits ${ftype}:- | convert - -ping -format "%b" info: | tr -d "[:alpha:]"`
+ #newsize=`convert xc: -format "%[fx:$fullsize/1000]" info:`
+ newsize=`convert xc: -format "%[fx:$newsize/1000]" info:`
+ fi
+ #echo "i=$i; newsize=${newsize}kB"
+ diffsize=`convert xc: -format "%[fx:($newsize-$size)]" info:`
+ iterate=`convert xc: -format "%[fx:abs($diffsize)>($toler*$size/100)?1:0]" info:`
+ #echo "i=$i; newsize=${newsize}kB; diffsize=$diffsize; iterate=$iterate;"
+ i=$(($i+1))
+ done
+ fi
+
+elif [ "$changetype" = "no" -a "$copy" = "yes" ]; then
+ convert "$infile" "$outfile"
+
+else
+ convert $tmpA1 -depth 8 $setcompression $setquality $setunits "$outfile"
+fi
+
+finalsize=`convert "$outfile" -format "%b" info:`
+echo "final size = $finalsize"
+
+exit
projects / geeqie.git / commitdiff