The basic idea of these commands is to create a compare, (A compare has defined a jpeg from past and one from the present, combine such as they will slide on each other and show before after images.)
e.g. https://media.evercam.io/v1/cameras/1lowe-scnoe/compares/lower-jreyh.gif
All the commands are written below, doing these operations
Resize before after image.
create a Gif using both images.
Add a log to Gif.
Create an MP4 file of from GIF.
Create a thumbnail from mp4 file.
the logo is:
we are making animation and mp4 files using FFmpeg and ImageMagick commands such as
ffmpeg -i before_image.jpg -s 1280x720 before_image_resize.jpg
ffmpeg -i after_image.jpg -s 1280x720 after_image_resize.jpg
The above commands are first to resize both images which are going to be used in animation.
This command is being used for creating a gif.
convert after_image_resize.jpg before_image_resize.jpg -write mpr:stack -delete 0--1 mpr:stack'[1]' \\( mpr:stack'[0]' -set delay 25 -crop 15x0 -reverse \\) mpr:stack'[0]' \\( mpr:stack'[1]' -set delay 27 -crop 15x0 \\) -set delay 2 -loop 0 temp.gif
This command to add a logo to the animation.
convert temp.gif -gravity SouthEast -geometry +15+15 null: evercam-logo.png -layers Composite compa-efxfphu.gif
Then to create an mp4 file as
ffmpeg -f gif -i compa-efxfphu.gif -pix_fmt yuv420p -c:v h264_nvenc -movflags +faststart -filter:v crop='floor(in_w/2)*2:floor(in_h/2)*2' compa-efxfphu.mp4
then to create a thumbnail from this mp4.
ffmpeg -i compa-efxfphu.mp4 -vframes 1 -vf scale=640:-1 -y thumb-compa-efxfphu.jpg
Is there any possibility to reduce any of these steps? This all takes a lot of time, I am merely interested in both convert commands, can we make them into one command?
Or do you see any chance to reduce these all 4 in one? any input will be so thankful.
Updated Answer
Here is my best shot at this, it runs in about 50% of the time of the original answer...
convert -depth 8 -gravity southeast -define jpeg:size=1280x720 \
logo.png -write MPR:logo +delete \
\( before.jpg -resize '1280x720!' MPR:logo -geometry +15+15 -composite -write MPR:before \) \
\( after.jpg -resize '1280x720!' MPR:logo -geometry +15+15 -composite -write MPR:after \) \
+append -quantize transparent -colors 250 -unique-colors +repage -write MPR:commonmap +delete \
MPR:after -map MPR:commonmap +repage -write MPR:after +delete \
MPR:before -map MPR:commonmap +repage -write MPR:before \
\( MPR:after -set delay 25 -crop 15x0 -reverse \) \
MPR:after \( MPR:before -set delay 27 -crop 15x0 \) \
-set delay 2 -loop 0 -write anim.gif \
-delete 1--1 -resize 640x thumb.jpg
Here's my thinking...
set the depth to 8 as we are using JPEG, set gravity and initialise libjpeg's "shrink-on-load" feature,
load the logo and save to MPR as we will be using it twice,
start some "aside processing" inside (...) to load the before image, resize it, paste on the logo and save to MPR for later use,
repeat previous step for the after image,
append the before and after images together and calculate a combined colormap suitable for both and save it,
map both before and after images to new, combined colormap,
delete all junk,
animate one way,
animate the other,
make animation endless, and save animation to GIF,
delete all except first frame, resize that and save as thumbnail.
Original Answer
Still a work in progress, but you can avoid the first two invocations of ffmpeg and do the resizing within ImageMagick, and also paste the logos on top in one go like this:
convert -gravity southeast logo.png -write MPR:logo \
\( before.jpg -resize '1280x720!' MPR:logo -geometry +15+15 -composite -write MPR:before \) \
\( after.jpg -resize '1280x720!' MPR:logo -geometry +15+15 -composite -write MPR:after \) \
-delete 0--1 \
MPR:before \( MPR:after -set delay 25 -crop 15x0 -reverse \) \
MPR:after \( MPR:before -set delay 27 -crop 15x0 \) \
-set delay 2 -loop 0 temp.gif
You can probably also create the thumbnail with that command too, if you change the last line from:
-set delay 2 -loop 0 temp.gif
to
-set delay 2 -loop 0 -write temp.gif \
-delete 1--1 -resize 640x thumbnail.jpg
You can also speed things up and reduce memory usage by using libjpeg's "shrink-on-load" feature. Basically, you tell it before reading the disk how big a file you need and it only reads a subset of the file thereby reducing I/O time and memory pressure:
convert -gravity southeast logo.png -write MPR:logo \
\( -define jpeg:size=1280x720 before.jpg -resize ... \
\( -define jpeg:size=1280x720 after.jpg -resize ...
That reduces the time by around 25-30% on my machine.
Here's my thinking...
set the gravity first as it is a setting and remains set till changed,
load the logo and save to an MPR because we will need to paste it twice and reading from disk twice is slow,
start some "aside processing" inside (...) to load the before image, resize it, paste on the logo and save to MPR for later use,
repeat previous step for the after image,
delete all junk,
animate one way,
animate the other,
make animation endless, and save animation to GIF,
delete all except first frame, resize that and save as thumbnail.
Keywords: animation, wiper effect, animated GIF
I have the following convert command in bash.
convert "$WALLPAPER1" -resize "${H[0]}"x"${V[0]}"^ -gravity center -crop "${H[0]}"x"${V[0]}"+0+0 "$WALLPAPERS/.temp1.jpg"
convert "$WALLPAPER2" -resize "${H[1]}"x"${V[1]}"^ -gravity center -crop "${H[1]}"x"${V[1]}"+0+0 jpg:- |
convert "$WALLPAPERS/.temp1.jpg" - +append "$WALLPAPERS/.temp.jpg"
Is there a way I can get rid of the "$WALLPAPERS/.temp1.jpg" intermediary? So is there a way to carry over the output of the first convert over to the input of the third convert?
convert "$WALLPAPER1" -resize "${H[0]}"x"${V[0]}"^ -gravity center -crop "${H[0]}"x"${V[0]}"+0+0 -write mpr:temp1 +delete \
"$WALLPAPER2" -resize "${H[1]}"x"${V[1]}"^ -gravity center -crop "${H[1]}"x"${V[1]}"+0+0 -write mpr:temp2 +delete \
-gravity north mpr:temp1 mpr:temp2 +append "$WALLPAPERS/.temp.jpg"
There was no need to have 3 convert calls. Instead of writing to file you can write to memory-program-register (mpr) and then recall later. The +delete deletes the original image.
Currently in my ZSH shell.
Doing this, gives me:
> gm convert -compress JPEG - - < input.jpg > output.jpg
gm convert: Corrupt JPEG data: 873 extraneous bytes before marker 0xd9 (/tmp/gmo1fx92).
However these 2 work without any problems:
> cat input.jpg | gm convert -compress JPEG - - > output.jpg
> gm convert -compress JPEG input.jpg output.jpg
What could be causing this difference?
For some reason,
-rotate 186.516 -crop 3194x1796+2350+2420 -resize 1920x1080
-rotate 186.522 -crop 3192x1795+2360+2420 -resize 1920x1080
-rotate 186.527 -crop 3190x1794+2370+2420 -resize 1920x1080
all output 1920x1080 images, and
-rotate 186.533 -crop 3188x1792+2380+2420 -resize 1920x1080
-rotate 186.538 -crop 3186x1791+2390+2420 -resize 1920x1080
-rotate 186.544 -crop 3184x1790+2400+2420 -resize 1920x1080
all output 1920x1079-sized images.
Correct me if I'm wrong, but that's not right. What can I do about this, when I absolutely need a 1920x1080 output every time, and prefer to keep this within imagemagick with only one pass?
Change the -resize 1920x1080 at the end of each command to -resize 1920x1080! to force exact dimensions.
I am using ImageMagick to generate small size JPEG versions of large TIFF images. For each TIFF image I must generate two smaller JPEG versions.
I am currently using two convert commands:
convert.exe 4096-by-3072px-120mb.tif -resize "1024x>" -strip -interlace Plane 1024px-wide-for-web.jpg
convert.exe 4096-by-3072px-120mb.tif -resize "1600x>" -strip -interlace Plane 1600px-wide-for-web.jpg
Converting TIFF to JPEG one-by-one is taking too much time. This approach is inefficient as each image is loaded across the network and processed twice. It will get worse as I plan to create more sizes for each TIFF (think 10,000 TIFFs x 5 sizes).
So, is it possible to generate two or more output files of different sizes using a single ImageMagick command?
Yes, it is possible, using the -write option:
convert 4096-by-3072px-120mb.tif -resize "1600x>" -strip -interlace Plane \
-write 1600px-wide-for-web.jpg -resize "1024x>" 1024px-wide-for-web.jpg
which rescales the input image to 1600 pixels wide, writes it out, then rescales the result to 1024 pixels wide and writes that. It's important to write the images in descending order of size, to avoid loss of quality due to scaling to a small size and then back up to a larger one.
If you prefer to rescale both images from the input image, use the +clone
option:
convert 4096-by-3072px-120mb.tif -strip -interlace Plane \
\( +clone -resize "1024x>" -write 1024px-wide-for-web.jpg +delete \) \
-resize "1600x>" 1600px-wide-for-web.jpg
In this case the order of writing images does not matter.
Here is an alternate command that uses memory program register:
magick.exe 4096-by-3072px-120mb.tif -write mpr:main +delete ^
mpr:main -resize "1024x>" -quality 80 -interlace Plane -strip -write 1024px-wide-for-web.jpg +delete ^
mpr:main -resize "1280x>" -quality 80 -interlace Plane -strip -write 1280px-wide-for-web.jpg +delete ^
mpr:main -resize "1600x>" -quality 80 -interlace Plane -strip -write 1600px-wide-for-web.jpg +delete ^
mpr:main -resize "2048x>" -quality 80 -interlace Plane -strip 2048px-wide-for-web.jpg
When tested:
the files generated with this command were identical to those created by separate convert commands
this command was twice as fast compared to separate commands
Note: ^ is the line continuation character on Windows.