stackprepare

#! /bin/bash
# stackprepare - prepare image stack with ImageMagick

# Notes:
# add --meanbalance?
# add --align?

usage() {
  echo "
stackprepare - prepare image stack

Usage:
  stackprepare [OPTIONS] IMAGES ...

Options:
 -f, --force                  Force to write into already existing folder.
 -h, --help                   Show this help.
 -o, --output DIR             Store prepared images in directory DIR.
                              Default: ./prepared
 -V, --showimage              Show images in image viewer geeqie.
 -1, --one                    Show one middle image only, do not store.


For the following options and their arguments see also documentation of
ImageMagick options with same name.
 --compose [=MODE]            Compose image with itself with mode MODE.
                              Possible MODE see: magick -list compose
                              Some modes of interest:  Interpolate Overlay
                              SoftBurn SoftDodge SoftLight HardLight 
                              Bumpmap Screen Multiply Freeze VividLight
                              Modulate ColorBurn.          Default: Interpolate
 --contrast                   Enhance contrast the simple way.
 --contrast-stretch [=ARG]    Contrast with color stretch. Default: auto
 --crop [=GEOMETRY]           Crop a part of the images. GEOMETRY is WxH+X+Y.
                              Use only once within a preparestack command.
                              Instead of a geometry you can specify a region
                              with TBLRM for top, bottom, left, right, middle,
                              e.g. --crop=TL for a square from the top left.
                                         Default: 800x800 from the middle.
 --gamma [=ARG]               Adjust image gamma.          Default: auto
 --level [=ARG]               Adjust image level.          Default: auto
 --resize [=ARG]              Resize images.               Default: 50%
 --rotate [=DEGREE]           Rotate images clockwise.     Default: 90
 --sharpen [=ARG]             Sharpen images.              Default: 2x1
 --shave [=ARG]               Shave edges from images.     Default: 30%
 --sigmoidal-contrast [=ARG]  Enhance contrast.            Default: 3x50%
 --im OPTIONS                 ImageMagick options to apply literally.

Option sets:
 --set [=SET]                 Apply a predefined set of options. SET can be:
                                gamma1   gamma2   gamma3
                                level1   level2   level3
                                stretch1 stretch2 stretch3
                                sharp1   sharp2   sharp3
Depends on:
 - ImageMagick
 - geeqie (optional)
"
}

### messages
showimage() {
  [ "$Showimageprocessing" = "yes" ] && geeqie -t -r --File:"${1:-}" 2>/dev/null &
  #viewnior ${1:-} &
  return 0
}
error() {
  echo "preparestack ERROR: ${1:-}" >&2
  exit 1
}

### misc
digitonly() {
  echo "${1//[^0-9.]/}"
}
printsameline() {
  # print $1 without newline at begin of current line
  echo -ne "${1:-}\033[0K\r" >&2
}

### run commands on all CPUs
multicore() {
  # Run multiple processes in parallel, but not more than $Multicore_maxprocesses
  # $1 Command
  # $2 Image to show if $1 is finished
  # Run multicore_wait afterwards to wait for the last processes to finish.

  local Process Command
  local Mem_needed Zram

  [ "${1:-}" = "-t1" ] && {
    shift
    [ "$Multicore_processcount" -gt 0 ] && {
      multicore_wait || return 1
    }
  }

  [ "$Multicore_processcount" = "$Multicore_maxprocesses" ] && {
    multicore_wait || return 1
  }
  [ "$Multicore_processcount" = "0" ] && Multicore_memorymax="$(printfreememory)"  
  Mem_needed=0
  for Process in $(seq $Multicore_maxprocesses); do
    Mem_needed="$(awk "BEGIN {print $Mem_needed + ${Multicore_memory[$Process]:-0} }" )"
  done
  Mem_needed="$((Mem_needed+${3:-0}))"
  [ "$Mem_needed" -gt "$Multicore_memorymax" ] && {
    note "multicore: Low memory. Waiting for $Multicore_processcount running processes to finish. Need: $((Mem_needed/1000)) MB, Available: $((Multicore_memorymax/1000)) MB"
    [ "$Mem_needed" -gt "$Multicore_memorymax" ] && [ "$Multicore_processcount" = "0" ] && note "multicore: Likely hard disk cache will be used and slow down the calculation."
    multicore_wait || return 1
  }

  ifcmdbreak && return 1

  Multicore_processcount=$((Multicore_processcount +1))

  Command="$(cut -d ' ' -f1 <<< "${1:-}")"
  case $(type -t "$Command") in
    file) Command="nice ${1:-}" ;;
    *)    Command="${1:-}" ;;
  esac

  #verbose "multicore: ${1:-}"
  eval "$Command &"

  Multicore_process[Multicore_processcount]=$!
  Multicore_image[Multicore_processcount]="${2:-}"
  Multicore_memory[Multicore_processcount]="${3:-0}"

  return 0
}
multicore_wait() {
  local Process Error=
  for Process in $(seq ${Multicore_maxprocesses:-0}); do
    [ "${Multicore_process[$Process]}" ] && {
      multicore_waitprocess "${Multicore_process[$Process]}" || {
        multicore_break
        Error=1
      }
      [ "$Error" ] && break
      [ "${Multicore_image[$Process]}" ] && showimage "${Multicore_image[$Process]}"
    }
    Multicore_process[$Process]=""
    Multicore_image[$Process]=""
    Multicore_memory[$Process]="0"
  done
  [ "$Error" ] && return 1
  Multicore_processcount=0
  return 0
}
multicore_waitprocess() {
  local Error=
  while sleep 0.2 ; do
    ps -p "${1:-}" >/dev/null || break
    ifcmdbreak && Error=1
    [ "$Error" ] && break
  done
  [ "$Error" ] && return 1
  wait "${1:-}"
  return $?
}
multicore_break() {
  local Process
  for Process in $(seq ${Multicore_maxprocesses:-0}); do
    [ "${Multicore_process[$Process]}" ] && {
      verbose "multicore_break: Sending SIGINT to $(ps -p ${Multicore_process[$Process]})"
      kill "${Multicore_process[$Process]}"
      wait "${Multicore_process[$Process]}"
      Multicore_process[$Process]=""
      Multicore_image[$Process]=""
      Multicore_memory[$Process]="0"
    }
  done
}
multicore_init() {
  # declare global variables
  local Process
  Multicore_maxprocesses="$(nproc)"
  Multicore_maxprocesses="${Multicore_maxprocesses:-1}"
  Multicore_maxprocesses="$((Multicore_maxprocesses * 2))"
  for Process in $(seq $Multicore_maxprocesses); do
    Multicore_process[$Process]=""
    Multicore_image[$Process]=""
    Multicore_memory[$Process]="0"
  done
  Multicore_processcount=0
  Multicore_minram=250000
  Multicore_maxprocesses=$Multicore_maxprocesses
}
printfreememory() {
  # print current free memory including zram
  local Memory Line Zram
  Memory="$(LC_ALL=C free | grep "Mem:" | LC_ALL=C awk '{print $7}')"
  while read Line; do
    Zram="$(LC_ALL=C awk 'BEGIN {OFMT = "%.0f"} {print ($3 - $4)}' <<< "$Line")"
    Zram="$(LC_ALL=C awk 'BEGIN {OFMT = "%.0f"} {print $1 / 1000}' <<< "$Zram")"
    #Memory="$((Memory + Zram))"
  done < <(/sbin/swapon --bytes | grep zram)
  echo $Memory
}
ifcmdbreak() {
  #[ -e "$Cachedir/exit" ]
  return 1
}

### image processing
meanproperties() {
  Imageproperties="$($Magickbin $Sourceimagelist -evaluate-sequence mean -format '
Imageautogamma=%[fx:log(mean)/log(0.5)]
Imageminlevel=%[fx:minima*100]
Imagemaxlevel=%[fx:maxima*100]
Imagewidth=%[w]
Imageheight=%[h]
' -write info: \
  -filter box -resize 1x1! -format "Imagemeancolor='%[pixel:u]'" -write info: \
  -delete 0 \
  -exit)"
  eval $Imageproperties
}
check_imagesize() {
  Imageproperties="$($Magickbin $(head -n1 <<< "$Sourceimagelist") -format '
Imagewidth=%[w]
Imageheight=%[h]
' -write info: \
  -delete 0 \
  -exit)"
  eval $Imageproperties
}
prepare_focusstack() {
  local Image Outputimage Command Count

  Count=0
  while read Image; do
    Count="$((Count+1))"
    Outputimage="$(rev <<< "$Image" | cut -d. -f2- | rev).tif"
    Outputimage="$(basename "$Outputimage")"
    Outputimage="$Destinationdir/$Outputimage"

    printsameline "preparestack: Processing image $Count / $Imagenumber"

    Command="
$Magickbin
  $Image
    $Prepareoptions
    $Storeimage
    -write $Outputimage
    -delete 0
  -exit"
    #$Command
    multicore "$(tr -d "\n" <<< "$Command")" "$Outputimage"

    Error="$?"
    [ "$Error" != "0" ] && break
    #showimage "$Outputimage"
  done <<< "$Sourceimagelist"
  multicore_wait
  echo ""

  [ "$Oneimageonly" = "yes" ] && echo "$Command"
  [ "$Error" != "0" ] && error "magick failed: $Command"

  return 0
}

### main
declare_variables() {
  # Global variables with default values
  Cropgeometry=""
  Destinationdir="./prepared"
  Force="no"
  Imageautogamma=""
  Imageheight=""
  Imagemaxlevel=""
  Imagemeancolor=""
  Imageminlevel=""
  Imagenumber=""
  Imagewidth=""
  Magickbin=""
  Oneimageonly=""
  Prepareoptions=""
  Showimageprocessing=""
  Sourceimagelist=""
  Storeimage="
    -orient undefined
    +repage
    -compress lzw
    -type TrueColor
    -define png:compression-filter=2
    -define png:compression-level=4
    -define png:compression-strategy=1"
  X=""
  Y=""
  W=""
  H=""
  return 0
}
parse_options() {
  local Shortoptions Longoptions Parsedoptions Terminate= Arg=

  Shortoptions="1fho:V"
  Longoptions="force,help,one,output:,showimage"
  Longoptions="$Longoptions,im:,set::"
  Longoptions="$Longoptions,compose::,contrast,contrast-stretch::,crop::,gamma::,level::,resize::,rotate::,sharpen::,shave::,sigmoidal-contrast::"

  Parsedoptions="$(getopt --options "$Shortoptions" --longoptions "$Longoptions" --name "$0" -- "$@")" || error "Option parsing error."
  eval set -- "$Parsedoptions"

  while [ $# -gt 0 ]; do
    case "${1:-}" in
      -h|--help)
        usage
        Terminate="yes"
        break
      ;;
      -1|--one)
        Oneimageonly="yes"
      ;;
      -o|--output)
        Destinationdir="${2:-}"
        shift
      ;;
      -f|--force)
        Force="yes"
      ;;
      -V|--showimage)
        Showimageprocessing="yes"
      ;;
      ### Imagemagick options
      --compose)
        Prepareoptions="$Prepareoptions
    -write mpr:composeimage
      mpr:composeimage
      -compose ${2:-PegtopLight}
      -composite
      +set registry:composeimage"
        shift
      ;;
      --contrast)
        Prepareoptions="$Prepareoptions
    -contrast"
        shift
      ;;
      --contrast-stretch)
        Arg="${2:-auto}"
        [ "$Arg" = "auto" ] && Arg=""
        Arg="${2:-"IMAGEMINLEVELxIMAGEMAXLEVEL"}"
        Prepareoptions="$Prepareoptions
    -contrast-stretch $Arg"
        shift
      ;;
      --crop)
        Arg="${2:-M}"
        Cropgeometry="${Arg:-}"
        Prepareoptions="$Prepareoptions
    -crop IMAGECROPGEOMETRY"
        shift
      ;;
      --gamma)
        Arg="${2:-auto}"
        [ "$Arg" = "auto" ] && Arg=""
        Arg="${2:-"IMAGEAUTOGAMMA"}"
        Prepareoptions="$Prepareoptions
    -gamma $Arg"
        shift
      ;;
      --im)
        Prepareoptions="$Prepareoptions
    ${2:-}"
        shift
      ;;
      --level)
        Arg="${2:-auto}"
        [ "$Arg" = "auto" ] && Arg=""
        Arg="${2:-"IMAGEMINLEVEL%xIMAGEMAXLEVEL%"}"
        Prepareoptions="$Prepareoptions
    -level $Arg"
        shift
      ;;
      --resize)
        Arg="${2:-"50%"}"
        Prepareoptions="$Prepareoptions
    -resize $Arg"
        shift
      ;;
      --rotate)
        Arg="${2:-0}"
        Prepareoptions="$Prepareoptions
    -background transparent
    -rotate ${2:-}"
        shift
      ;;
      --set)
        Arg="${2:-"gamma1"}"
        case "$Arg" in
          gamma1)
            Prepareoptions="$Prepareoptions
    -gamma IMAGEAUTOGAMMA
    -sigmoidal-contrast 3x50%
    -sharpen 0x1"
          ;;
          gamma2)
            Prepareoptions="$Prepareoptions
    -gamma IMAGEAUTOGAMMA
    -sigmoidal-contrast 5x50%
    -sharpen 0x2"
          ;;
          gamma3)
            Prepareoptions="$Prepareoptions
    -gamma IMAGEAUTOGAMMA
    -sigmoidal-contrast 7x50%
    -sharpen 0x4"
          ;;
          level1)
            Prepareoptions="$Prepareoptions
    -level IMAGEMINLEVEL%xIMAGEMAXLEVEL%
    -sigmoidal-contrast 3x50%
    -sharpen 0x1"
          ;;
          level2)
            Prepareoptions="$Prepareoptions
    -level IMAGEMINLEVEL%xIMAGEMAXLEVEL%
    -sigmoidal-contrast 5x50%
    -sharpen 0x2"
          ;;
          level3)
            Prepareoptions="$Prepareoptions
    -level IMAGEMINLEVEL%xIMAGEMAXLEVEL%
    -sigmoidal-contrast 7x50%
    -sharpen 0x4"
          ;;
          stretch1)
            Prepareoptions="$Prepareoptions
    -sigmoidal-contrast 3x50%
    -sharpen 0x1
    -contrast-stretch IMAGEMINLEVELxIMAGEMAXLEVEL"
          ;;
          stretch2)
            Prepareoptions="$Prepareoptions
    -sigmoidal-contrast 5x50%
    -sharpen 0x2
    -contrast-stretch IMAGEMINLEVELxIMAGEMAXLEVEL"
          ;;
          stretch3)
            Prepareoptions="$Prepareoptions
    -sigmoidal-contrast 7x50%
    -sharpen 0x4
    -contrast-stretch IMAGEMINLEVELxIMAGEMAXLEVEL"
          ;;
          sharp1)
            Prepareoptions="$Prepareoptions
    -contrast
    -sigmoidal-contrast 3x50%
    -sharpen 0x1"
          ;;
          sharp2)
            Prepareoptions="$Prepareoptions
    -contrast
    -sigmoidal-contrast 5x50%
    -sharpen 0x2"
          ;;
          sharp3)
            Prepareoptions="$Prepareoptions
    -contrast
    -sigmoidal-contrast 7x50%
    -sharpen 0x4"
          ;;
          *)
            echo "Option --set: Unknown set '$Arg'" >&2
            Terminate="yes"
            break
          ;;
        esac
        shift
      ;;
      --sharpen)
        Arg="${2:-"2x1"}"
        grep -q "x" <<< "$Arg" || Arg="${Arg}x1"
        Prepareoptions="$Prepareoptions
    -sigmoidal-contrast $Arg"
        shift
      ;;
      --shave)
        Arg="${2:-"30%"}"
        Prepareoptions="$Prepareoptions
    -shave $Arg
    +repage"
        shift
      ;;
      --sigmoidal-contrast)
        Arg="${2:-"3x50%"}"
        grep -q "x" <<< "$Arg" || Arg="${Arg}x50%"
        Prepareoptions="$Prepareoptions
    -sigmoidal-contrast $Arg"
        shift
      ;;
      --) ;;
      *)
        Sourceimagelist="$Sourceimagelist
${1:-}"
        [ -f "${1:-}" ] || error "File not found: ${1:-}"
      ;;
    esac
    shift
  done

  Sourceimagelist="$(grep .  <<< "$Sourceimagelist")"
  Sourceimagelist="$(sort -V <<< "$Sourceimagelist")"
  Imagenumber="$(grep -c .   <<< "$Sourceimagelist")"
  [ "$Imagenumber" = "0" ] && error "No source images specified."
  [ "$Terminate" ] && finish 1
  return 0
}
finish() {
  trap - SIGINT
  trap - EXIT
  trap - ERR
  multicore_break
  exit 0
}
main() {
  set -Eu
  trap finish SIGINT
  trap finish EXIT
  trap finish ERR

  declare_variables
  parse_options "$@"
  multicore_init

  # -1, --one
  [ "$Oneimageonly" = "yes" ] && {
    Sourceimagelist="$(head -n5 <<< "$Sourceimagelist" | tail -n1)"
    Imagenumber="1"
    Destinationdir="/tmp"
    Showimageprocessing="yes"
  }

  # check dependencies
  command -v convert >/dev/null && Magickbin="convert"
  command -v magick  >/dev/null && Magickbin="magick"
  [ -z "$Magickbin" ] && error "Error: imagemagick not found."

  # -V, --showimage
  [ "$Showimageprocessing" = "yes" ] && {
    command -v geeqie >/dev/null || error "-V, --showimage: geeqie not found."
    geeqie -t -r --File:"$(head -n1 <<< "$Sourceimagelist")"
  }

  # get and insert some image stack properties if needed
  grep -q -E 'IMAGE|CROPGEOMETRY' <<< "$Prepareoptions" && {
    grep -q -E 'LEVEL|GAMMA' <<< "$Prepareoptions" && meanproperties
    [ -z "$Imagewidth" ] && check_imagesize

    # --crop
    [ "$Imagewidth"  -gt 640 ] && W="800" || W="$((Imagewidth/2))"
    [ "$Imageheight" -gt 480 ] && H="800" || H="$((Imageheight/2))"
    Cropgeometry="${Cropgeometry:-"M"}"
    grep -q M <<< "$Cropgeometry" && X="$(( Imagewidth/2    -W/2 ))" && Y="$(( Imageheight/2   -H/2 ))"
    grep -q T <<< "$Cropgeometry" && Y="$(( Imageheight/4   -H/2 ))"
    grep -q B <<< "$Cropgeometry" && Y="$(( Imageheight*3/4 -H/2 ))"
    grep -q L <<< "$Cropgeometry" && X="$(( Imagewidth/4    -W/2 ))"
    grep -q R <<< "$Cropgeometry" && X="$(( Imagewidth*3/4  -W/2 ))"
    Cropgeometry="$(tr -d "MTBLR" <<< "$Cropgeometry")"
    [ -z "$Cropgeometry" ] && Cropgeometry="${W}x${H}+${X}+${Y}"

    Prepareoptions="$(sed "s/IMAGEMINLEVEL/$Imageminlevel/g ; s/IMAGEMAXLEVEL/$Imagemaxlevel/g ; s/IMAGEAUTOGAMMA/$Imageautogamma/g ; s/IMAGECROPGEOMETRY/$Cropgeometry/g" <<< "$Prepareoptions")"
  }

  # --output
  [ -e "$Destinationdir" ] && [ "$Destinationdir" != "/tmp" ] && case "$Force" in
    "yes")
      case "$Destinationdir" in
        ""|"$HOME"|"/")
          error "--output: Invalid output directory: '$Destinationdir'"
        ;;
        *)
          #rm -r "$Destinationdir" || return 1
        ;;
      esac
    ;;
    "no")
      error "Output directory already exists:
  $Destinationdir
  You can force to use it with option --force."
    ;;
  esac
  mkdir -p "$Destinationdir" || return 1

  # run
  prepare_focusstack         || return 1

  return 0
}
main "$@"
finish