Photos of Apps

Introducing: Lightroom Preset Renamer

July 12, 2022  |    0 comments  |  Apps

(A version of this post was recently shared on my other, non-photography-specific site [robotSprocket].)

I’m approaching 15 years of posting a new photo every day (as of this writing, that’s 5448 days of new photos). My main tool for managing, organizing and processing my photos is Adobe’s Lightroom (Classic), which I’ve used since version 1 when I started my “modern” photography hobby/side-business in 2007 (I’d done photography in the past, but had pretty much stopped after college as I no-longer had access to a darkroom, was too busy/poor/had other priorities/obligations for film and digital wasn’t cheap enough/good enough for what I wanted to do).


One of the key features of Lightroom is the ability to create and use presets, which apply develop settings to the selected image, adjusting exposure, color, crop, etc., without user intervention. Some photographers are adamantly against the idea of presets, as they view each photo to be processed as a clean slate that requires careful finessing of values to process. On the other end of the spectrum, you have lazy people who apply a preset without any additional work, export the photo and call it a day. However, most Lightroom users lie somewhere in the middle—using a preset as a starting point for processing an image, followed by fine-tuning it to perfection. 


I am one of the latter Lightroom users. I’ll often open a photo and scroll through my presets looking for a good starting point for the “look” I want a photo to have. Besides creating my own presets, I like to explore other people’s presets they’ve shared in the Lightoom (Cloud) or Mobile app (note that Adobe has two confusingly-named Lightroom applications…one is the professional version (Classic) that most serious photographers use and the stripped-down, amateur/mobile-focused Lightroom (Cloud) that doesn’t, in my opinion, have a place in a professional’s toolkit). In Lightroom Cloud, there’s a “Discover” section that allows you to browse shared presets and download them to use for yourself:


If you filter by “Preset downloadable”, you can scroll through the photo grid and download the preset for any photo:

Lightroom Cloud will then save it to your account and it can be used on any photo in Lightroom Cloud or Lightroom Mobile (the presets will sync to the Lightroom app on your phone).

At this point, however, you can’t use them in Classic, yet. Since the Lightroom Cloud presets don’t sync to Lightroom Classic, you have to do some work to get them there. 

(Note that the following instructions are for MacOS, but should be similar on Windows)


  1. Find your Lightroom Cloud library (~/Pictures/Lightroom Library.lrlibrary)
  2. Right click and select “Show Package Contents”
  3. In that folder, there are 4 subfolders. One has a bunch of random characters; the others are profiles, TemporaryEdits and user.
  4. Click into the random characters folder.
  5. Find the cr_settings subfolder and click into it.
  6. The .xmp files here are your presets.
  7. Copy these to where your Classic presets are stored (should be something like ~/Library/Application Support/Adobe/CameraRaw/Settings
  8. Restart Classic


Voila! Your presets should be there in the Presets pane in Lightroom Classic. The problem with this is that Adobe saves the presets to your local drive as a guid rather than a human-readable name:


If you’re like me, though, this is unacceptable. I want to be able to read the names of the presets while in Finder. So, to solve this, I built a tiny MacOS application I call Lightroom Preset Renamer. This is how I use it:


  1. Copy the .xmp preset files you found in the Lightroom Library.lrlibrary file to a temporary folder.
  2. Run the Preset Renamer application and choose this folder by clicking the “Choose Preset Folder to Process”:
  3. Once you’ve chosen the folder, it will automatically process any .xmp file in that folder, renaming it to it’s “proper name”, while preserving the original file by changing the extension to “xmp_old”:

  4. Now, copy these .xmp files to the CameraRaw/Settings folder as outlined above and then reset Classic.


A couple of notes: 

  1. This app isn’t signed, so you may need to follow the instructions here to run it. Or, if you’re adventurous and have to run unsigned apps often, you can disable Gatekeeper by following these instructions.
  2. If you’re concerned about security, you can inspect the source code and build the app yourself in Visual Studio Mac by going to this Github repository.
  3. Since this is built on .Net, I plan on building a Windows version soon…stay tuned!
  4. You can download the application at the link below:

Download the latest release here

A Lightweight EXIF Data Viewer

May 18, 2020  |    0 comments  |  Apps

(Note: This post originally appeared on my new mostly-non-photography blog [robotsprocket])

If you’ve read the title of this post and are wondering “what is this EXIF thing?”, then here’s a bit of information. EXIF is an acronym for EXchangeable Image File Format. And, no, I don’t know why it’s not “EXIFF”. Basically, it’s metadata tagged onto a digital image that contains information about that image. This, along with another group of metadata, IPTC, is used by digital photographers to keep track of information about such things as camera/lens settings, geographic information and copyright of a given photo.

Some photographers post their images online with this information intact, while others will strip it out when posting, keeping their secret sauce to themselves. For myself, I keep it intact as I hope it might be helpful to other photographers to understand how a photo was capture as well as being an aid in enforcing copyright. Most, if not all, photos on my photography site have this data tagged onto them and the basic data can be viewed by clicking the “View Photo Data and Location” button under the photo:

Basic EXIF data on 75CentralPhotography.Com

However, there are a lot of times that I want to view this data locally for unpublished photos on my PC. To make this easy, I wrote a simple Windows application that will display this data for a selected photo:

Main Interface

It displays the most-commonly used EXIF data on the main interface; and, if there’s GPS information embedded in the metadata, it shows a button to view the photo’s location on Google Maps. If you want all the EXIF data, you can click “File→Show All EXIF Data…” and a dialog will appear showing everything:

Everything, Everything

This application is written in VB.NET and the source code is available on GitHub. If you want to install it, you’re welcome to download it here.

A couple of installation notes:

When downloading the installer, you may get this warning:

Because this app hasn’t been installed enough times for Windows to “trust” it, Windows Defender wants you to really think about it before installing. To continue, click the three dots and choose “Keep”.

You might then get another warning:

Go ahead and click the down arrow next to “Show more” and click “Keep Anyway”. Then, navigate to your download location and doubleclick EXIFViewer.msi to install. You might get another warning:

Click More info and you’ll get the option to run anyway. At this point, the installer will launch and you can install the application.

A lot of rigmarole to install an app, but it’s for most people’s own good, as Windows tries its best to prevent you from installing malicious software using Defender Smartscreen. In this case, you’re going to have to trust me that this isn’t malicious. You have the option, of course, to review the source code at the Github repository listed above. And you know where to find me. If enough people install, Windows will eventually allow it past Smartscreen without complaint.

If you download and use the EXIFViewer and have any feedback or find any bugs, please submit an issue here or send me an email at

Nightmare Fuel*

February 7, 2020  |    0 comments  |  Apps

*Or how a neural network changed everyday people into Eldritch Abominations.

I recently came across a story on The Verge about a guy who used software to upscale the Lumière Brothers’ 1896 short film L’Arrivée d’un train en gare de La Ciotat to 4K resolution at 60 frames per second. This was accomplished using Topaz Labs’ Gigapixel-AI software, which purports to use advanced neural networks to enhance resolution of low-resolution photos (i.e. “make small photos big”). You can see this video here:

While it’s not perfect, it’s intriguing to see what the late 1800s might have looked like if we took modern video cameras back in time and did some shooting. For reference, here’s the original version of the film:

My interest piqued, I wanted to give this software a try on some of my old, low-res photos, so I downloaded a trial copy and started playing around with it. One of my first tests was to try it on an old scan of a photo my father took in 1980 when Ronald Reagan visited our town while campaigning for president:

As I’d scanned this roughly 13 years ago with my first negative scanner, the quality isn’t great and the resolution is a measly 2171×1443.

However, after putting it through Gigapixel-AI, I got this pretty-good-looking result:

Good-looking, that is, until I zoomed in on the people. It soon became obvious something terrible had happened:

What happened to their faces!?!?!?!?

The software’s neural network attempted to use information it already “knows” about faces to “fill in the gaps” in the low-resolution original, but it seems that it doesn’t always to a great job of this.

Luckily, Topaz Labs seems to have anticipated this and added an option to turn off or reduce face refinement. Once I turned this off, the results were much-better:

Still not perfect, but considering how little detail was in the original, pretty-impressive. For reference, here are the same areas in the original, unprocessed scan:

And, if you’re curious, the enhanced version of the photo without face refinement enabled:

All-in-all, Gigapixel-AI seems like a nice bit of software for “rescuing” old photos that need to be enlarged for print or web display, just don’t look too-closely.

My Geo-Tagging Workflow

February 28, 2019  |    0 comments  |  Apps GPS Logs Technique/Workflow

In my last post, wherein I outlined how I added a link to each photo’s location on Google Maps, I mentioned that I thought I’d done a writeup on how I geo-tag photos, but couldn’t find it. After extensive searching of the archives, I can confirm that I don’t seem to actually have ever written about my process. Today, I’ll rectify that oversight.

Let’s take a look at the tools I use, then I’ll walk you through how it all comes together.

First, we need a way to record a GPS log. Typically, these are in the format of a .gpx file, which is a type of XML file that can contain a geotrack, which is, at its most-basic, a series of GPS fixes in latitude and longitude along with a timestamp for each point that allows software to reconstruct a route. It may also, but not necessarily, contain speed and heading information. It can also contain a series of waypoints, which are GPS fixes that aren’t linked in a time dimension, so no track can be generated from these as there’s no way of knowing which order the GPS fixes/points were gathered, as order in the file doesn’t necessarily mean that’s the order they were gathered. In addition, we’ll need the time information later to match the time a photo was taken to a spot on our geotrack.

To build a .gpx file while out taking photos, we need a GPS receiver that has the ability to periodically record our current location in a file then export it for consumption by another tool to actually tag the photos. For this, I use a couple of different tools:

When I was using an iPhone as my day-to-day phone, I used an app called MotionX GPS to record my tracks.

Now that I’m using a Google Pixel 2 XL as my phone, I’ve had to find a different app to record tracks as MotionX GPS isn’t available for Android. I tried a few an eventually settled on GPSLogger. The UI isn’t as pretty as MotionX GPS, but it gets the job done.

The next tool we need is a way to merge the location and time data in our .gpx file with our photo data. Since I’m an Adobe Lightroom user (Classic, none of that CC nonsense for me!), I could use Lightroom’s rudimentary built-in geo-tagging feature (a tutorial can be found here), but I prefer some fine control over the process, so I use Jeffrey Friedl’s excellent Geoencoding Support plugin.

This allows us to fine-tune all sorts of fiddly bits in the process, such as correcting for the camera’s time being off a bit from the actual GPS time, which brings us to our next point:

How do I ensure that my time is correct on my camera?

There are a few ways to do it. If you’re lucky, your camera’s companion smartphone app supports synchronizing your phone’s time with your camera’s time, such as the Panasonic Image App (Android/IOS) does. If you’re not-as-lucky, you have to manually sync it, which means opening your camera’s settings and setting the date/time to match the phone’s as close as possible. Fortunately, it doesn’t need to be precise as most geotagging tools, such as Jeffrey’s Lightroom Geoencoding Support, allow for some “fuzziness” to the time matching algorithm.

Once you’ve tagged your photos, you can manually tag any misses in Lightroom’s Map tab. Now you have a precise log of your adventures and the photos you’ve taken.

In addition, you can open the .gpx file in Google Earth and get a nice map of your adventure. Here’s one from a visit I made to the Great Smoky Mountains last year:

So, there you have it, my geotagging workflow. However, I would be remiss in failing to mention that I’m currently testing using a GPS watch (the Suunto Traverse) for tracking as I don’t need to worry about killing my phone’s battery life while logging my location. So far, so good. I might do a write up in the future about my experiences with it.

Even More Nerdiness

February 12, 2019  |    1 comment  |  Apps

Last week, I wrote about a simple Windows app I built to automatically set my Windows 10 wallpaper to a random photo from 75CentralPhotography.Com. This week, I ran into another issue/want/need that required me to once again dust off my Windows development skills to solve.

I thought it would be nice if all my Chromecast-connected TVs and my Google Home Hub would display my photos as part of their screensaver feature. However, to do this, I’d need to have a folder in Google Photos of all my published photos. Building this collection of photos is actually a bit harder than it sounds, believe it or not! Why not just export all of the photos from your Photoblog collection in Lightroom?, you ask. Well, the problem there is that that collection actually contains about 600 other photos that have either not been published or were mistakenly tagged as a photoblog item, so any export would have a lot of cruft. So, I needed a way to get all of the photos. Downloading from the backend of 75CentralPhotography.Com was also an option, except that there’d be a lot of extraneous files there as well for a couple of reasons: 1) since the site runs on WordPress, any time an image is uploaded, WordPress helpfully generates a few versions of the file in addition to the original for thumbnail and featured images and, 2), there are leftover files from revisions to posts, so for any photo I’ve ever re-edited and republished, there’s the old version lurking about. Also, a few years ago, we painstakingly re-edited each post to upsize the photos to more-pleasing, easier-to-appreciate dimensions, so the previous versions are out there as well.

To solve this, I decided that I could reuse a lot of the code I’d written for the previous wallpaper project and build a couple of items:

  1. A new RESTful API that would return the photo from a particular date presented to it.
  2. A Windows application to iterate through every day since we started publishing photos (August 12, 2007) until the present day, calling the aforementioned webservice and downloading the photo that was returned by the service.

To accomplish the first step, I made a copy of the code from the webservice built for my previous project and modified it expect a date query string parameter, so calling the service looks something like this:

{base URL}/photodate/?date=12/14/2018

The webservice parses the date element into three strings for month, day and year and adds them to an argument array for WordPress’ WP_Query() function:

$datep=  $_GET['date'];
$pieces = explode("/", $datep);

  $args = array(
      'date_query' => array(
              'year' => $pieces[2],
              'month' => $pieces[0],
              'day' => $pieces[1]

$your_query = new WP_Query( $args );

WordPress automatically performs the query, and if results are returned, assigns the results to variables:

  while ($your_query->have_posts()) :
    $imageurl= catch_that_image();
    $permlink = get_post_permalink();


We use the catch_that_image() function again to get the URL to the first (and, in our case, only) image in the post. We then serialize this into a JSON string and return the results:


Moving on to the Windows app part of the solution, I built a simple UI that would let me choose a start date, choose a folder to save the images to, and a button to actual start the process:

On the backend, clicking the Process button calls this bit of code:

 Dim startdate As Date = Me.DateTimePicker1.Value.Date()
        Dim today As Date = Date.Now()
        Dim i As Integer
        Dim wo As New WebOps
        Dim rP As Bitmap
        Dim currUrl As String
        While startdate <= today
            currUrl = wo.getURL(startdate)
            rP = tempPB(currUrl)
            rP.Save(Me.FolderBrowserDialog1.SelectedPath & "\" & i & ".jpg", Imaging.ImageFormat.Jpeg)
            i = i + 1
            startdate = startdate.AddDays(1)
        End While

First, we declare our variables and objects:

  • today is obviously today’s date and sets the upper bound of possible days that images have been published
  • i is the counter for how many times we’ve looped through the download process (we also use that to build our filenames so that our output is a nicely-ordered list of published photos in order of published date
  • wo instantiates a copy of a class I built called WebOps, which does the heavy-lifting of calling the webservice and returning the results
  • rp is a Bitmap object, basic a blob of data that represents our image file that we’ve downloaded
  • currlURL represents the URL we’re calling, in this case, the base URL for the service with the date parameter appended

Next, we start the actual processing:

  • We wrap everything in a while loop. This loop starts at the date chosen in the datepicker control on the user interface and iterates through each day until today by adding a day to startdate on each pass through the loop.
  • We first set the value of currUrl by calling the getURL function in the WebOps class:
        Dim format As String = "MM/dd/yyyy"
        Dim fdate As String = getdate.ToString(format)
        Dim url As String = baseURL & "?date=" & fdate
        Dim wc As New WebClient
        Dim jRes As String
        wc = New WebClient
        Dim retry = True
        While retry
                jRes = wc.DownloadString(url)
                retry = False

                retry = True
            End Try
        End While
        Dim tempPost = New With {Key .Image = ""}
        Dim post = JsonConvert.DeserializeAnonymousType(jRes, tempPost)
        Dim com As String = post.Image
        Dim tempURL = New With {Key .permalink = ""}
        Dim pURL = JsonConvert.DeserializeAnonymousType(jRes, tempURL)
        Dim plink As String = pURL.permalink
        Dim u As New utilities
        wc = Nothing
        Return com

This returns the URL of the photo posted on the specific date passed into the webservice (you’ll notice that we also get the permalink, but we don’t use it…this is simply because I reused this code from the wallpaper app).

  • We pass the currUrl into the tempPB function, which does the work of downloading the image and setting its data to the rp bitmap object
Private Function tempPB(url As String) As Bitmap 
        Dim tClient As WebClient = New WebClient
        Dim tImage As Bitmap = Bitmap.FromStream(New 
        Return tImage
End Function
  • Then we save rp to disk as a .jpg file, targeting the folder chosen in the user interface and using the value if i as the filename.
  • We then increment our startdate value and i‘s value
  • Finally, we through in a call to Application.DoEvents(), which is a simple, though not-necessarily-the-best, way to ensure that the application’s interface doesn’t freeze while in a loop.

When the application runs, it iterates from the chosen date to today and saves the files locally. When it finishes running, which is in the case of starting on August 12, 2007 and ending today, we end up with a folder of of over 4200 ordered .jpg files of every published photo on 75CentralPhotography.Com:

To get these into Google Photos for casting to Chromecast devices, we create a folder in Google Photos and upload:

Finally, we hop into the Google Home app and set the album as the source of images for the Chromecast’s Ambient Mode:

More Nerdiness

February 8, 2019  |    1 comment  |  Apps

As you may or may not know, in addition to taking fine photos, I enjoy designing and building software. For the last several years, I’ve been working in the cloud, mainly on the Force.Com platform, but before that, I was a Windows developer. Occasionally, I like to build a little software project on my own just to make sure I can still develop desktop applications or to build little tools to make my life easier. I did this much more often when I was a strictly-Windows guy, but since moving to an iMac as my desktop machine for day-to-day use and post-processing, I don’t get to do it as often as I’d like as I haven’t the time to learn Objective-C or Swift. Luckily, to sate my need for Windows-related development, I have a Windows 10 Virtual Machine on my iMac running under Parallels as well as a Dell XPS laptop.

For my latest “me project”, I thought it would be cool if I could have my Windows desktop wallpaper periodically change to one of the photos on To accomplish this, I knew I’d need a couple of pieces of software running in different places:

  1. A webservice or some other means of fetching a random photo from the site
  2. A local application running on Windows that would periodically make a call to the aforementioned webservice and get the random photo

So, for the first part, I build a RESTful API on 75CentralPhotography.Com that looks for photos on the site that I’ve specified as wallpaper candidates and returns one at random. Since our site runs on WordPress, a lot of the functionality was already in place. The process works like this:

  1. A new post custom metadata field called 75Wallpaper was created that can be set to TRUE if that photo should be used as wallpaper.
  2. A new webservice was written in PHP that uses WordPress’ WP_Query method to return a random photo with the above criteria
    $args = array( 'meta_key' => '75wallpaper', 'meta_value'=>'TRUE', 'posts_per_page' => '1', 'orderby' => 'rand' ); $your_query = new WP_Query( $args ); if($your_query->have_posts()){ while ($your_query->have_posts()) : $your_query->the_post(); $imageurl= catch_that_image(); $permlink = get_post_permalink(); endwhile; } 

    We use a handy function I found on the web some time back called “catch_that_image” that grabs the URL of the first image on a post, which ensures we get the link to the image. We also go ahead and grab the permalink to the image.

  3. We then serialize these results into some JSON so that making a call to this service results in a response that looks like this:

Now to build the Windows portion. For this, I chose to build a .Net application in VB.Net, however, I could’ve just as easily used C#.

To start, I created a simple UI with a couple of buttons and a picture box. One button would let the user interactively set a new background by calling the above webservice’s randomImage element and the second would use the permalink element to open the current wallpaper’s page on in the default browser. The picturebox would display the current wallpaper and was really just there for testing purposes (i.e. I needed to ensure I was retreiving the image properly before I wrote the code to set as the wallpaper).

I then started writing some code to do the magic.

  1. First, I needed to build a function to call the webservice and retrieve and store the results, including downloading the image to the Windows AppData folder:
Public Function ProcessWallpaper() As Boolean
        Dim wOPs As New WebOps
        Dim AppDataPath As String
        Dim u As New utilities
        Dim doesAppDataPathExists As Boolean
        Dim rP As Bitmap
        Dim setSuccess As Boolean
        Dim randomfilename As String = u.createRandomFilename()
        rP = tempPB(GetRandomImageURL()) ' fill form picturebox for testing
        AppDataPath = u.getAppDataPath()
        doesAppDataPathExists = u.checkfolderexists(AppDataPath)
        If doesAppDataPathExists Then
            rP.Save(AppDataPath & "\75Central\" & randomfilename, Imaging.ImageFormat.Jpeg)
        End If
        setSuccess = u.setWallPaper(AppDataPath & "\75Central\" & randomfilename)
        Return True
    End Function

This code is called in three places:

  1. When the application loads, immediately setting a new wallpaper
  2. When the “Set New Wallpaper Now” button is clicked
  3. Every ten minutes after the application starts running, ensuring that a new wallpaper is set on a regular schedule

2. Secondly, I needed some code to actually set the wallpaper. Luckily, .Net already has a function to do this, so I just needed to call it and pass the path of the image downloaded:

Public Function setWallPaper(imagefile As String) As Boolean
        SystemParametersInfo(SETDESKWALLPAPER, 0, imagefile, UPDATEINIFILE)
        Return True
    End Function

3. Finally, I needed to cleanup the download. Once a Windows 10 wallpaper is set, it’s stored internally in the operating system and no longer needs to persist as a separate file, so there’s no reason to have a high-res version of my photo hanging around on my PC, taking up space:

Private Sub ClearAppData(apppath As String)
        Dim directoryName As String = apppath & "\75Central\"
        For Each deleteFile In Directory.GetFiles(directoryName, "*.jpg", SearchOption.TopDirectoryOnly)
    End Sub

All of this code is tied together to work, and upon launch, the app nicely minimizes into the system tray out of the way until the icon is double clicked to show the UI

So, there you have it, my latest nerdy project. If there’s sufficient interest, I might release this as a free download so that you can have automated new fun wallpapers. If you’re interested, shoot me an email at!

Snapseed 2.0 (for iOS) Woes

April 27, 2015  |    0 comments  |  Apps

So, after a long time, wherein I, along with most of the rest of the world (or at least those who care about these things), assumed that Snapseed was dead, Google surprised us with an updated version of Snapseed.

If you’re not familiar with Snapseed, then here’s a quick rundown…
In the summer of 2011, Nik Software, the creators of a few of my favorite Lightroom and Photoshop plugins (Silver Efex, Color Efex and Analog Efex), released Snapseed for the iPad, followed shortly by a version for the iPhone. Apple named it the iPad App of the Year in 2011 and an awesome desktop version was released as well (you could even configure it work as an external editor for Lightroom). In 2012, Nik was bought out by Google, who released a version for Android (good) but killed off the desktop version (bad). (Incidentally, they did lower the price of the Nik software suite (sans Snapseed, of course), so that was a nice outcome of Google’s takeover). The discontinued desktop version’s features were slowly integrated into the photo editing tools of Google+, while the mobile versions were left to seemingly-rot, only occasionally receiving minor updates to fix compatibility issues.

I continued to use Snapseed, wondering how long it would be until it no longer worked with newer generations of iOS devices (in fact, it initially ran super-buggy under iOS 8, but, thnakfully, Google released an update to address these issues). In the meantime, I experimented with other mobile editing apps, including the recently-released and much-praised Enlight, bracing for the day that an update to iOS finally broke Snapseed.

So, imagine my delight when, a couple of weeks ago, iOS’ app store informed me that an update for Snapseed was available. Perusing the release notes as it downloaded, I was pleased to learn that it was a complete overhaul/modernization of the app.

After it installed, I launched it and dug right in. The new transform tools are great for leveling horizons and uprighting buildings, while the stacks concept is an awesome way to go back and tweak previously-made edits.

A few days after it was released, I left for a trip to Key West and the Bahamas. As is my habit, I took a lot of photos with my iPhone for posting to Instagram or to send as postcards to family and friends via the excellent app Postagram.

After arriving back in Addison, I downloaded the several thousand photos I shot with my cameras to Lightroom, then, as my usual practice, plugged my iPhone into my Mac to download its photos to Lightroom.

As they downloaded, I noticed something strange…the photos I’d edited with Snapseed 2.0 didn’t actually have any edits applied.


A bit of Googling led me to learn that the new version of Snapseed uses Apple’s .aae sidecar files to store edits to photos, rather than actually “burning in” the edits as in previous versions. And, much to my chagrin, there’s not a way to force a “burned in” version to be saved.

So, whose fault is this?

1. Snapseed claims that they’re being “good iOS citizens” by following Apple’s guidelines for using .aae files to store edits. However, I don’t see why they can’t also include an option for creating new .jpg files with the edits permanently recorded to the file.
2. Apple’s guidelines are to use .aae files, but I can’t find anywhere that says “do it our way and don’t create new .jpgs with edits embedded”. On top of that, even using their own new, the .aae edits don’t carry over with imported photos (they only seem to show if you use iCloud photo storage), so their implementation of sidecar file-enabled editing seems half-assed in my opinion.
3. Adobe could always elect to download and interpret .aae files in Lightroom, though why should they?


1. Use iCloud photo sync and (Nope…sticking to Lightroom).
2. Use an iOS app that recognizes .aae photos and allows transfer, such as emailing or iMessaging them to myself. (Nope…I just want to plug in and download to Lightroom).
3. When ready to commit changes to an image for download to Lightroom, choose “Share” in Snapseed, then select “Copy”. Tap Open, paste from Clipboard and save. This creates a “burned in” copy of the image that can then be downloaded. (Ugh…I shouldn’t have to go through hoops).

So, What Can Be Done?

Complain to Google. Post angry messages on their Snapseed product forum. Use Enlight or and other sane iOS photo editing app. Switch to Android (which doesn’t, of course, use .aae files), though if you switch platforms for one app, then that’s kind of weird.

In the meantime, I still like the results and ease-of-use of Snapseed. That said, I can’t see myself going through the process outlined in work-around 3 for every image I edit in it, so I’m just going to have to live with the fact that maybe not all of my Snapseed edits will make it into my Lightroom catalog.

How To Download The Canon EOS Utility If You Lose Your Installation CD [Mac]

October 24, 2012  |    0 comments  |  Apps Video

If you’re like me, you have a dog that occasionally likes to eat things.  In this case, Winston at my EOS Utility install disc before I got a chance to install it on my iMac.  This wasn’t initially a problem for me, as I use Lightroom and don’t shoot tethered.  But then I discovered the CineStyle Picture Style by Techicolor and wanted to experiment with it while shooting video.  Unfortunately, to load picture styles onto a Canon camera, you need the EOS Utility (this hasn’t been an issue before, since I shoot RAW when shooting stills).  Luckily, I found the following instructions for installing without the disc.

How To Download The Canon EOS Utility If You Lose Your Installation CD [Mac].

Wherein Lefty Does A Good Deed

April 24, 2012  |    0 comments  |  Apps Elsewhere

I regularly peruse the photography subreddit on Reddit.Com and earlier tonight, while taking a break from day job-related stuff that overflowed into my non day-job timeframe, I came across a post from a fellow Redditor asking for help reconstructing a RAW file.  Specifically, he asked posted the following:

Being in a generous mood, I decided to help him.  Of course, as he stated, Photoshop was going to be difficult, so I wasn’t about to give that a shot.  (I’m not that altrustic!)

So I gave it a shot in Lightroom 4.  No dice.  Then I remember that I’d played around a bit with an app called Raw Photo Processor.  So I loaded it up, imported the file and…



I converted the file to a jpg, uploaded to imgur and posted the link.

Sadly, my fellow Redditor didn’t recognize the subject of the photo, so who knows what or where it came from…it’s just some random kid:

And while it didn’t really help this guy, it was fun doing some detective work, if only for a few minutes.


Update! It might be the father’s ex-girlfriend’s kid!

My 500px Randomizer

January 27, 2012  |    0 comments  |  Apps Code

I’ve mentioned this before, but I thought I’d revisit it since I’ve recently rolled out a few changes.

In the last year or so, 500px has exploded to become the “serious” alternative to Flickr—a place where you show off your best work while not being crowded out by the kinds of people on Flickr that upload every lame snapshot of their kids or dump their entire CF or SD card into their stream everytime they come back from an outing.

Unfortunately, one of the big problems with 500px is that there’s no “good” way to randomly view images, save for a link at the bottom of their homepage inviting you to “StumbleThru 500px”, which simply uses user-submitted links on third-party service StumbleUpon.

I found this to be inadequate, as it only relied on photos that users had bothered to “Stumble”.  This meant that the number of images were somewhat limited as well as confined to mostly the more popular images—ones that the hive mind of the 500px viewership community had decided were “the best” and worthy of linking to.  After a few clicks on the Stumble button, I found that I was getting the same few images over and over again—some of them were even months old.

What I wanted to do was see truly random images from 500px, so I set out to make a tool to do the randomizing for me.

My first iteration was simple.  Since, at the time, 500px didn’t have a publicly-exposed API, I had to be “kludgey”.  A bit of poking around revealed that 500px simply numbers photos sequentially as they are uploaded—in fact, you can easily go see the first photo uploaded publicly thanks to the ridiculously-easy-to-reverse-engineer URL convention of<number of photo>.  This made it extremely easy to create a php application that would simply generate a random number between 1 and whatever the largest number used is.  The php code is easy:

$iPic =  mt_rand(  1 , $iMax );
return “”.$iPic;

Where $iMax is whatever the largest number used is. Since I didn’t want to have to bother writing an overly-long script to figure out what the latest number used was, I’d simply manually update $iMax every couple of days with the photo ID of the first image on 500px’s Fresh page.

In my app, I embedded an iFrame to hold the photo’s page while the app acted as a wrapper around it, keeping the “Randomize” button and “Permalink” link visible at all times.  And this worked great, but I wasn’t happy.  I quickly found that while 500px has tons of great work on it, there’s a lot of cruft.  Especially amongst the older photos submitted before the community really “took off”.  What I really wanted was to be able to randomly browse photos that were of a bit higher quality and were on the newer side (and this, I suppose, is where my application lost it’s complete randomness).  Unfortunately, this wasn’t really possible at the time, so I let the project sit on the backburner for a while.

Then 500px opened up its API.  And I leveraged it.  I quickly figured out how to use JSON queries to return arrays of recent photos in the Fresh, Editors’ Choice, Upcoming and Favorites categories.  Not really caring about Fresh since that’s the initial “dumping ground” for everything uploaded, I concentrated on the other categories.  I quickly produced some code that queried the API and returned a random photo from the user’s choice of categories, replacing my previous code that haphazardly propelled you around 500px and instead allowed you to randomly view more-curated photos.

A bit of Javascript trickery also allowed me to make a feature to view the photographer’s 500px homepage using a window blind effect so that a user can quickly check out other photos by that photographer as well as follow them without leaving my app.

So, there you have it, the story behind my 500px Randomizer.  Feel free to use it all you want;  just keep in mind that it’s still a work in progress and if you find any bugs, feel free to send me an email at to let me know.


© 1993-2021 Matt Harvey/75Central Photography - All Rights Reserved • Contact for image licensing and other queries.