#graphicsmagick

This is one of thousands of images like it (each unique though) I've recently generated with an experimental process. The experiment is a success if I may say so.

This is the process to (potentially) get some way cool procedural images from satellite (or any!) images, accomplished with a new script at https://github.com/earthbound19/_ebArt/blob/master/recipes/diff_avg_supercomposites.sh :

Phase I. – collect several cool satellite images of civilization and/or wilderness, e.g. from this site: https://earthview.withgoogle.com/ – for every image pair in the collection, make a "diff" image (subtract the RGB values of every pixel in one image from every pixel in the other image), and save the result – for every image pair in the collection, make an averaged image (average the RGB values of every pixel in one image with another), and save the result Phase II. – liberally delete less impressive results Phase III. – for every diffed result, average it with an averaged result and save that. – for every averaged result, subtract (diff) a diffed result. – liberally delete less impressive results. Good luck–with 17 source images and heavy pruning in Phase II, this will give me 17k+ results, so far all of them compellingly cool.

(Phase IV: sort all results by approx. nearest most similar and string them together in a movie of crossfades to see works between the works.)

(Phase V: accidentally produce glitch art because your computer ran out of hard drive space and memory doing all this, but the processing script keeps calling the utilities that do this, and the utilities break. I'll post some glitch results later).

(Phase VI: realize you have a storage and bandwidth problem for your new many gigabytes of images.)

I hope this post syndicated from my art blog ok. This is the first post attempting to do so via NEXTSCRIPTS AutoPoster, an amazing WordPress plugin.

Syndicated from: https://earthbound.io/blog/diff_avg_supercomposites-sh-example-output/

In 2013, I wrote a UDF called isImageCMYK to determine if an image file was CMYK using Java.  I tried using ExifTool (free) and it was a little faster, but not fast enough.  GraphicsMagick’s “Identify” didn’t return the information and I had to enable “verbose” which took longer.  I recently tried MediaInfo (opensource) and it is MUCH faster.  The function call has gone from 300-600ms to 15-45ms since using this third-party library.

I noticed another failed JPG file in ColdFusion’s "temp” directory.  I opened it and it was a 5mb iPhone 4S photo taken in 2012 (download image).  I’m able to successfully open & process it using the programs & services listed below whereas ColdFusion responds with “Invalid image format”.

I tested the JPG file using the ImageRead() function with Windows ColdFusion 10,0,16,293499 Developer w/Java 1.7.0_80.

“Topologi Image Judge” uses Java and confirmed that the image conforms to the “Standard ISO 10198-1 JPEG (JFIF)” specification.  How is it possible that Adobe ColdFusion is the only software unable to read it?

Software Incapable of Reading an iPhone 4S JPG Photo

Adobe ColdFusion 9 & 10 (11 not tested)

Software Capable of Reading an iPhone 4S JPG Photo

JPEGmini http://jpegmini.com/

GraphicsMagick http://www.graphicsmagick.org/ CF_GraphicsMagick is a ColdFusion Tag that leverages GraphicsMagick. It’s faster, more reliable w/CMYK images & requires less memory.

ExifTool http://www.sno.phy.queensu.ca/~phil/exiftool/

Jeffrey's Exif Viewer http://regex.info/exif.cgi

TinEye http://www.tineye.com/

FastStone Image Viewer http://www.faststone.org/FSViewerDetail.htm

Paint.NET http://www.getpaint.net/

Topologi Image Judge http://www.topologi.com/products/utilities/imagejudge.html

JPEGsnoop http://www.impulseadventure.com/photo/jpeg-snoop.html

We have been encountering some ColdFusion performance issues recently and I think I’ve finally determined that it’s due to large JPG files causing uncatchable, generic Java Heap errors.

When image files are uploaded, we initially tested them with isImageFile() before moving it to a directory and performing any image manipulations. We’ve discovered that isImageFile() is broken as ImageRead() occasionally failed with certain types of CMYK images that isImageFile() identifed as “valid”, so we decided to write our own function to perform an ImageRead() with CFTry/Catch around it.

Using ImageRead() with CFTry/Catch proved to be a better solution EXCEPT we now discovered that any JPG image that is too large to read will cause an unstoppable “Java Heap Space” error.

I contacted Adobe ColdFusion Support regarding it. They kept attempting to address tuning web request max limits (which have nothing to do with this as it’s a file that already on the local file system.)  I asked if it was possible to catch this error when attempting to read a file that is too big for the JVM and, after 3-4 email exchanges, they finally responded with “JVM heap error can't be catch” and stated that I needed to tune the HEAP memory.

Fair enough... I increased the HEAP memory. After doing this, I was able to read & resize the uploaded 20mb JPG image, but it took 80 seconds!  I can perform the same manipulation using CF_GraphicsMagick without changing the JVM and it only takes 500ms.  (NOTE: GraphicsMagick is used by Flickr & Etsy and supports over 88 different formats.)

ColdFusion 9, 10 & 11′s image performance is not as good as it should be considering it comes from the makers of Adobe PhotoShop, Illustrator & Acrobat. I was using CFX_OpenImage (a CFX C++ tag for ColdFusion), but it didn’t support the newer “gravity” features of GraphicsMagick.  I wrote my own wrapper for GraphicsMagic that supports some of the more common functions that we need.  I figured that this was a good technology choice since both Flickr & Etsy use it.I’ve discovered that it’s much faster to call CFExecute and use GraphicsMagic than using built-in CFImage functions.  The resulting files are usually smaller in filesize too.  Even if no resizing is performed, we added an “optimize” function to ensure that uploaded JPGs are converted to a non-CMYK format that could cause problems with ColdFusion.  (We've encountered a couple of CMYK images that CF still can’t read properly.)

Here's a screenshot with some execution time & filesize comparisons versus CFImage. (GraphicsMagick results are on the left.) http://i.imgur.com/6t9iy7d.jpg

ImageMagick Vs GraphicsMagick

We found that GraphicsMagick was usually considerably faster at executing image processing operations from the command line than ImageMagick 6.5.8-10 was. One ImageMagick algorithm ran as much as 770 times slower. GraphicsMagick clearly ran much more efficiently under Microsoft Windows.

http://ift.tt/VBysCG

所以当时的实验室使用GraphicsMagick是有原因的，可惜那位老师并没有告诉我这个原因。

I recently finished the Responsive Images Course on Udacity. I'd recommend giving it a go as I learned a lot about images and techniques for optimizing and serving them on the web. It's a self paced course, plus it's free. You can't beat that price.

A useful tool I found through the course was GraphicsMagick. GraphicsMagick is an image processing system. It can be used to edit images such as resizing and compressing. Once you've downloaded and installed it, you can use it with the Grunt plugin grunt-responsive-images.

Grunt is a task runner that automates repetitive tasks such as compiling files, minifying JavaScript and CSS files, running tests and so on. It makes life a lot simpler and allows a developer to use their time more efficiently.

With the grunt-responsive-images plugin, you can automate creating different size of images. Why would you want to do this? To use it with the picture element. The picture element allows you to change the source of an image depending on different circumstances such as screen size or screen resolution. It's useful so that you don't serve a large image file for a small device and waste data or to swap an image if the device has a retina display, which requires a larger image so it doesn't look pixelated.   

There are other options for the plugin such as applying filters or lowering the quality to lessen the file size, which can be found here: https://github.com/andismith/grunt-responsive-images.       

Since support for these nifty picture element features isn't quite there yet, you'll need to use Picturefill, a polyfill that uses JavaScript to get the functionality to work across several browsers.   

Automating this task is a life safer. Imagine having 25 images for your site. Now imagine opening each image in an image editor like Photoshop or GIMP, then having to resize them into 3 different sizes. Then you have to save them using the Save for Web option. I’ve been there. It’s not fun, a bit mind numbing even. With Grunt, you only need to set up the Gruntfile.js file once with the options you want and type in a single line on the command line. That’s it. You’re done. If you get more images down the road you need to put up on a site, it’s got you covered.

I highly recommend taking the Udacity course if you want to learn more about responsive images. Even if you know plenty, you might pick up a thing or two. 

List of Links

Responsive Images Course

GraphicsMagick

Grunt

grunt-responsive-images