#!/bin/bash

# plasma (forked from noiseAndDirt )

# give me some plasma and noise and dirt for wallpaper

# required: imagemagick, nitrogen, xrandr

# usage: plasma --help

# benchmark start
START=$(date +%s.%N)

# checks
command -v convert >/dev/null 2>&1 || { echo "I need imagemagick convert, exiting." >&2; exit 1; }
command -v nitrogen >/dev/null 2>&1 || { echo "I need nitrogen, exiting." >&2; exit 1; }
command -v xrandr >/dev/null 2>&1 || { echo "I need xrandr, exiting." >&2; exit 1; }

# store & vars
tmp="/tmp/noiseAndDirt-$RANDOM-$$"
trap '[ -n "$tmp" ] && rm -fr "$tmp"' EXIT # comment out this line to keep all images
mkdir -m 700 "$tmp" || { echo '!! unable to create a tmpdir' >&2; tmp=; exit 1; }

# these are temporary
noise="$tmp/noise.png"   # noise
dirt="$tmp/dirt.png"     # dirt
dirt2="$tmp/dirt2.png"   # dirt2
dirt3="$tmp/dirt3.png"   # dirt3
tmpcomp="$tmp/tmp.png"   # tmpcomp
tmpcomp2="$tmp/tmp2.png" # tmpcomp2
tmpcomp3="$tmp/tmp3.png" # tmpcomp3
final="$tmp/final.png"   # final

# keep backups and where
keepsome="1" # bool
keep="$HOME/data/noiseAndDirt"
    
# boolean, if true single image is generated
monitorsforce="0" 

# for me
debug="0"

# resolution
mx=1920; my=1200
(( monitorsforce )) && mx=3840 # if single-tile then we need bigger res

# if backup/keepsome is enabled, then we want pngcrush
if (( keepsome )); then
    command -v pngcrush >/dev/null 2>&1 || { echo "I need pngcrush, exiting." >&2; exit 1; }
    mkdir -p "$keep" || exit
fi 

# print progress
dot () {
    printf "."
}

touch "$noise" "$dirt" "$dirt2" "$tmpcomp" "$final" || exit

# help
if [[ "$1" == "-h" ]] || [[ "$1" == "--help" ]]; then

cat <<EOF
Order of parameters does matter:

    plasma brightnes saturation hue level-dynamics level-start degradeFX
           1         2          3   4              5           6
    # degradeFX is disabled by default.

examples:

    plasma                           # default
    plasma - +++                     # default, but 10% darker and 30% more saturated

EOF

exit 

fi

# modulate bright,color,hue
def="100" ; bri="100" ; col="100" ; hue="100"

# bright
mul="0"
if [[ "$1" == +* ]]; then # lighter
    mul=$(( 10 * ${#1} )) ; bri=$(( def + mul ))    
    shift    
elif [[ "$1" == -* ]]; then # darker
    mul=$(( 10 * ${#1} )) ; bri=$(( def - mul ))
    shift
elif [[ "$1" == "_" ]]; then # the same
    shift
fi

# saturation
mul="0"
if [[ "$1" == +* ]]; then # more saturated
    mul=$(( 10 * ${#1} )) ; col=$(( def + mul ))    
    shift    
elif [[ "$1" == -* ]]; then # less saturated
    mul=$(( 10 * ${#1} )) ; col=$(( def - mul ))
    shift
elif [[ "$1" == "_" ]]; then # the same
    shift
fi

# hue
mul="0"
if [[ "$1" == +* ]]; then # more saturated
    mul=$(( 2 * ${#1} )) ; hue=$(( def + mul ))    
    shift    
elif [[ "$1" == -* ]]; then # less saturated
    mul=$(( 2 * ${#1} )) ; hue=$(( def - mul ))
    shift
elif [[ "$1" == "_" ]]; then # the same
    shift
fi

# level dynamics/range
low="5" ; high="59"

mul="0"
if [[ "$1" == +* ]]; then # higher dynamics
    mul=${#1} ; low=$(( low - mul )) ; high=$(( high + mul )) 
    shift    
elif [[ "$1" == -* ]]; then # less dynamics
    mul=${#1} ; low=$(( low + mul )) ; high=$(( high - mul ))
    shift
elif [[ "$1" == "_" ]]; then # the same
    shift
fi

# level start
mul="0"
if [[ "$1" == +* ]]; then # higher (low and high)
    mul=${#1} ; low=$(( low + mul )) ; high=$(( high + mul )) 
    shift    
elif [[ "$1" == -* ]]; then # lower (low and high)
    mul=${#1} ; low=$(( low - mul )) ; high=$(( high - mul ))
    shift
elif [[ "$1" == "_" ]]; then # the same
    shift
fi

# video degrade
mul="0" ; degrade="4"
if [[ "$1" == +* ]]; then # more pattern
    mul=$(( 1 * ${#1} )) ; degrade=$(( degrade + mul ))    
    shift    
elif [[ "$1" == -* ]]; then # less pattern
    mul=$(( 1 * ${#1} )) ; degrade=$(( degrade - mul ))
    shift
elif [[ "$1" == "_" ]]; then # the same
    shift
fi

# noise
noise () {
(( debug )) && set -x
convert -size "${mx}x${my}" xc:"gray(50%)" -seed "${RANDOM}" -attenuate 4 +noise poisson +level 0%,80% +repage "$noise"
(( debug )) && set +x
dot
}
# +level 18%,24%
# -sharpen 0x1
# -modulate bright,color,hue

# See
# http://brunogirin.blogspot.com/2009/09/making-noise-with-imagemagick.html
# -virtual-pixel tile 

# dirt
dirt () {
(( debug )) && set -x
convert "$noise" -canny 0x.3+0%+30% -blur 0x.3 -negate +level 0%,80% "$dirt"
dot
}

# dirt2
dirt2 () {
convert "$noise" -canny 0x3+0%+10% -blur 0x.5 -negate +level 0%,30% "$dirt2"
dot
}

# dirt3 (big and blurry)
dirt3 () {
convert "$noise" -canny 0x4+0%+55% -blur 0x160 -negate +level 0%,60% "$dirt3"
# -blur 0x140
#convert "$noise" -canny 0x50+0%+50% -blur 0x140 -negate +level 0%,60% "$dirt3"
#convert "$noise" -canny 0x$((RANDOM % 100 + 1))+0%+$((RANDOM % 100 + 1))% -blur 0x$((RANDOM % 200 + 1)) -negate +level 0%,$((RANDOM % 80 + 1))% "$dirt3"
(( debug )) && set +x
dot
}
# $((RANDOM % 100 + 1))

# plasma generate
plasmagen () {
#convert -size "${mx}x${my}" xc: -seed "${RANDOM}" -attenuate 2 +noise poisson +repage -virtual-pixel tile -blur 0x500 -auto-level -blur 0x300 +level 3%,95% "$tmp/plasma.png"
#blur="$(( RANDOM % 550 ))" && printf "$blur"
# convert -scale 10% -blur 0x2.5 -resize 1000% sample.jpg blurred_fast.jpg

blur="$((10 + RANDOM % 50))"  && printf "%s" "$blur"

#convert -size "${mx}x${my}" xc: -seed "${RANDOM}" -attenuate 2 +noise poisson +repage -virtual-pixel tile -blur 0x${blur} -auto-level -blur 0x190 +level 3%,45% "$tmp/plasma.png"

convert -size "${mx}x${my}" xc: -seed "${RANDOM}" -attenuate 2 +noise poisson +repage -scale 10% -virtual-pixel tile -blur 0x${blur} -auto-level -blur 0x23 +level 3%,55% -resize 1000% "$tmp/plasma.png"
#convert -size "${mx}x${my}" xc: -seed "${RANDOM}" -attenuate 2 +noise poisson +repage -scale 20% -virtual-pixel tile -blur 0x${blur} -auto-level -blur 0x23 +level 3%,55% -resize 500% "$tmp/plasma.png"

# -blur 0x23
#mxs=$(( mx / 10 ))
#mys=$(( my / 10 ))

#convert -size "${mxs}x${mys}" xc: -seed "${RANDOM}" +noise poisson +repage -virtual-pixel tile -blur 0x${blur} -auto-level -blur 0x23 +level 3%,55% -resize 1000% "$tmp/plasma.png"

#mogrify -channel Red -evaluate set 0 +channel "$tmp/plasma.png"

printf "p"

# remove red channel
# convert plasma-32550.png -channel Red -evaluate set 0 +channel test.png
# -blur 0x300 -auto-level -blur 0x300
}

# compose
compose () {
(( debug )) && set -x
convert "$dirt" +level 3%,45% "$noise" +level 3%,35% -compose plus -composite +repage "$tmpcomp" &
convert "$dirt3" +level 3%,45% +repage "$tmpcomp2" ; wait
dot
convert "$tmpcomp" "$tmpcomp2" -compose plus -composite +repage "$tmpcomp3"
dot

# final compose
convert "$tmpcomp3" "$dirt2" -compose plus -composite +repage "$final"
dot

# plasma post-compose
#convert "$final" "$tmp/plasma.png" -compose colorize -composite +level ${low}%,${high}% -modulate "$bri,$col,$hue" "$tmp/final_plasma.png"
convert "$final" "$tmp/plasma.png" -compose colorize -composite +level ${low}%,${high}% -modulate "$bri,$col,$hue" "$tmp/final_plasma.png"
mv "$tmp/final_plasma.png" "$final"
# -compose modulate -define compose:args=10,70
dot
(( debug )) && set +x
}

degrade () {
# video degradation large 3x3 fx
# draw 6x6 pixel tile that will be used for video-degradation effect
# similar as gimps large_3x3
convert -size 6x6 xc:black -fill red \
-draw 'point 0,0' -draw 'point 0,1' -draw 'point 1,0' -draw 'point 1,1' \
-fill green1 -draw 'point 2,0' -draw 'point 2,1' -draw 'point 3,0' -draw 'point 3,1' \
-fill blue -draw 'point 4,0' -draw 'point 4,1' -draw 'point 5,0' -draw 'point 5,1' \
-draw 'point 0,2' -draw 'point 1,2' -draw 'point 0,3' -draw 'point 1,3' \
-fill red -draw 'point 2,2' -draw 'point 3,2' -draw 'point 2,3' -draw 'point 3,3' \
-fill green1 -draw 'point 4,2' -draw 'point 5,2' -draw 'point 4,3' -draw 'point 5,3' \
-draw 'point 0,5' -draw 'point 1,5' -draw 'point 0,4' -draw 'point 1,4' \
-fill blue -draw 'point 2,5' -draw 'point 3,5' -draw 'point 2,4' -draw 'point 3,4' \
-fill red -draw 'point 4,5' -draw 'point 5,5' -draw 'point 4,4' -draw 'point 5,4' "$tmp/large3x3.png"

# overlay the tile
(( debug )) && set -x
convert "$final" -size "${mx}x${my}" tile:"$tmp/large3x3.png" -compose modulate -define compose:args=${degrade},100 -composite "$tmp/final_fx.png"
mv "$tmp/final_fx.png" "$final"
(( debug )) && set +x
dot
}

# rotate maybe
rotateMaybe () {
(( debug )) && set -x
if (( RANDOM %2 )) ; then
    mogrify -rotate 180 "$final"
    printf "r"
else
    printf "n"
fi
(( debug )) && set +x
}

restart() {
if pgrep -x "$1" > /dev/null
then
    (echo "$1 running, restarting"
    killall -w "$1"
    "${1}" &) &
else
    echo "$1 wasn't running"
fi
}

setwall () {
    nitrogen --set-tiled "$final"
}

keepfunc () {
    backup="$keep/noiseAndPlasma-${RANDOM}.png"
    cp "$final" "$backup"
    #mogrify -depth 8 "$backup" # convert to 8 bit per channel
    cd "$keep" || exit
    pngcrush -q -ow "$backup"
    printf "b%s" "$c"
    #echo "stored as $backup"
    
    #cp "$tmp/plasma.png" "$keep/plasma-${RANDOM}.png"
}

# How many monitors connected
if (( monitorsforce )); then
    monitors="1"
else
    monitors=$(xrandr -d :0 -q | grep ' connected' -c)
fi

# is monitors a number
if ! [[ $monitors =~ ^[1-9]+$ ]]; then
    >&2 echo "No monitors detected, assuming one."
    monitors="1"
fi

for (( c=1; c<=monitors; c++ ))
do
	(( debug )) && echo "monitor $c"
        printf " %s " "$c"
    noise
        (( debug )) && echo
    dirt & dirt2 & dirt3 & plasmagen; wait 
        (( debug )) && echo
    compose
    
    rotateMaybe
        
    #degrade
    
    if (( monitorsforce )); then
        # tile just one
        nitrogen --set-tiled "$final" > /dev/null 2>&1 || exit
    else
        # each monitor has its own bitmap
        nitrogen --head=$(( c - 1 )) --set-tiled "$final" > /dev/null 2>&1 || exit
    fi

        (( keepsome )) && keepfunc &
    
        (( debug )) && beepspeakers
done

restart wbar > /dev/null 2>&1

wait

# benchmark end
printf " "
END=$(date +%s.%N)
DIFF=$(echo "$END - $START" | bc -l)
printf "noiseAndDirt done in %.0f seconds\n" "$DIFF"

# report disk usage if backup/keepsome is enabled
(( keepsome )) &&  printf " backup disk space used: " && du -hs "$keep"