MENU 
Photos of Apps

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(
          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:

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 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:

{"Image":"http://www.75centralphotography.com/wp-content/uploads/2018/12/las-vegas-bliss-dance-sculpture-hand.jpg","permalink":"http://www.75centralphotography.com/?post_type=post&p=38007"}

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)
            Application.DoEvents()
        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
            Try
                jRes = wc.DownloadString(url)
                retry = False

            Catch
                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 
           MemoryStream(tClient.DownloadData(url)))
        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 75CentralPhotography.com. 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:
    {"randomImage":"http://www.75centralphotography.com/wp-content/uploads/2018/05/tandy-hills-nature-area-sunrise-grass-fort-worth.jpg","permalink":"http://www.75centralphotography.com/?post_type=post&p=36891"} 

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 75CentralPhotography.com 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)
        wait(5)
        ClearAppData(AppDataPath)
        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)
            File.Delete(deleteFile)
        Next
    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 matt@75central.com!


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.

WTF?

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 Photos.app, 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?

Work-arounds

1. Use iCloud photo sync and Photos.app. (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…

 

…Success!

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 http://500px.com/photo/<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 “http://500px.com/photo/”.$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 lefty@leftyrodriguez.com to let me know.


Processing “The Last Supper”

January 17, 2012  |     2 comments  |  Apps Technique/Workflow
Pedro Alves asked in a comment on today’s photo if I could explain the processing.  So I thought I’d give it a quick try.
The original raw photo was shot at f/10 at ISO 100 and a shutter speed of 1/100 of a second, using a polarizing filter to darken up the sky a bit.  After importing to Lightroom, I pre-sharpened and adjusted the white balance, giving me this:
Not very exciting, eh?  I decided to tone map it to bring out the shadow and highlights detail in a sort-of “faux” HDR process.  Since I hadn’t shot multiple bracketed exposures, which would be necessary to do true HDR, I faked it, relying on the pure dynamic range that shooting RAW affords a photographer.
In Lightroom, I created four virtual copies of the photo, giving me five copies altogether, including the original.  I left the original’s exposure value at 0, then set the others at values of +1, +2, -1 and -2 respectively, imitating the bracketed exposures I’d get with a “real” HDR shot.  I then exported these to Photomatix to do the tone mapping, which resulted in this image:
This gave me great detail in the shadows, but killed the sky.  I didn’t really care, though, because I still had work to do.  I imported the original photo with the dark sky I liked and the tone-mapped photo I’d created in Photomatix into Photoshop for further work.
First step was to copy the tone-mapped version into a new layer over the original.  I then created a layer mask which allowed me to use a black paintbrush to “punch through” the tone-mapped layer to the original photo below.  I used a brush with an opacity set to roughly 50% to slowly bring the original sky into the tone-mapped layer.  Once I was satisfied, I applied the layer mask, resulting in a photo that had tone-mapped statues and mountains, but original dark sky.  I then used Topaz Adjust to bring out a bit of detail in the mountains and statues, because I feel like the tone-mapping process leaves the photos looking a bit flat detail-wise.
My next step was to convert to black and white.  For this, I used Nik Software’s excellent Silver Efex Pro 2.  I started with the built-in “high structure” preset, then added a bit of extra structure and a little bit more contrast, while dropping the exposure down a notch or two.  Then, I used Silver Efex’s control points feature to darken up the sky just a bit more while leaving the mountains and statues unaffected. Once this was done, I saved back to Lightroom, did some final noise reduction and a bit of sharpening and posted it to the site.
Here’s a before/after:

 


Randomly Viewing 500px

September 21, 2011  |    0 comments  |  Apps Site-related

Certainly, if you’re into photography, you’ve heard of 500px, the upstart photo-sharing site from Toronto that’s starting to “put the hurt on” Flickr.  One of the great advantages of 500px is that the quality of the photography seems to be a lot higher than that on Flickr, mainly because it’s not a dumping ground for family snapshots, crap art projects and Instragram-esque drivel.  Unfortunately, in my opinion, there’s one feature that I’ve found lacking on 500px—the ability to randomly traipse through the photos on the site, discovering new favorites and making new connections with fellow photographers.  Sure, they recently added a button on the bottom of the screen that welcomes the user to “StumbleThru 500px”, but all that does is let you use StumbleUpon to view photos on 500px that StumbleUpon’s users have favorited.  What I wanted was a way to randomly move about 500px in an uncontrolled manner.

So I created a way.

Introducing Lefty’s 500px Randomizer.  Using it is simple: follow that link or go to www.LeftyRodriguez.com/500px, click “Randomize” and a new random photo page from 500px will load in an iframe below.  Click “Permalink” to open that pic in a new tab so you can bookmark it.  Easy, eh?

I can’t promise that the Randomizer is bug-free and there are a few features I’d like to implement still, but it’s yours to use.  Have fun!


Tools of the Trade – FlickStackr

August 17, 2011  |    0 comments  |  Apps Technique/Workflow

As part of my photoblogging/sharing process, I generally have photos scheduled to be published at 05:30 on my photoblog, where they sit and get viewed and commented upon all day. Then, in the evening, after 19:00 CDT (or 18:00 CST), I upload them to Flickr, giving my site roughly 13-14 hours of exclusivity. The reason for trying to upload to Flickr as close as possible to these times is because that’s when Flickr’s “day” starts (it’s on GMT), which means that uploading at these times is the best way to maximize daily photo views, which are part of the mysterious algorithm Flickr uses to calculate things like “Interestingness” (not that I particularly worry about these things). Also, most people in North America seem to do their Flickr viewing in the evenings, so this time hits a nice spot when my photo will be landing in their “Contacts” photostream.

But how to do the upload? Some people use Flickr’s native upload functionality, but I find this kind of limited. Another option–and one that I occasionally use when uploading from my Mac or my PC–is Flickr Uploadr. Flickr Uploadr has a lot of nice features including the ability to tag photos and put them in sets, but is missing one of the most important–the ability to add a photo to groups from the application, meaning that after you upload, you still have to go into Flickr and add to groups from their interface. Which is okay, but not a favorite task because, for some reason, I constantly get this error when trying to add a photo to groups on the site itself:

(Flickr! Fix your code!)

Another issue with trying to stick to these times is that I’m usually walking our dog, Winston, between 19:00 and 20:00 during these times. Luckily, I have an iPhone with me and can upload on the go. I used to use the Flickr app, but, like the Flickr Uploadr, you can’t add photos to groups. So, after a bit of research, I discovered FlickStackr.

FlickStackr is everything Flickr’s app should be:

  • Profile view

and

  • Actions/Activity view

But the most relevant to this blog post is “Upload” and here are screencaps showing how you can set titles, tags, groups, geolocation and more when uploading:

As you can see, it’s the perfect iOS companion for Flickr users.  And it’s a universal app, so it will work on your iPad at native resolution!


© 1993-2019 Matt Harvey/75Central Photography - All Rights Reserved • Contact license@75central.com for image licensing and other queries.