A State Of Development

Camera View Overlay in iOS

June 7, 2011 16:00

iOS 4 and higher allow for an overlay view to be added to the view hierarchy in the UIImagePickerController when it is in Camera mode. I wanted to use this technique in Interlacer to allow the user to line up multiple shots. It seemed that this would be very straightforward:

1
2
3
4
5

That code will show the image as a translucent overlay, but it is not lined up correctly in the viewfinder. The image was off by about 50 pixels. To make this work, I needed to resize the image to the correct viewfinder size, place that image in a UIImageView whose frame was the size of the main screen, then position the content (the resized image) at the top of the frame:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// assume there is an instance of UIImagePickerController* named picker...
// assume that there is a UIImage* property named overlayImage...
UIImageView *overlay = [[UIImageView alloc] initWithFrame:[[UIScreen mainScreen] bounds]];

// with an image sized to fit in the viewfinder window
// (Resize using Trevor Harmon's UIImage+ categories)
overlay.image =
[self.overlayImage resizedImageWithContentMode:UIViewContentModeScaleAspectFill
bounds:CGSizeMake(320, 430)
interpolationQuality:kCGInterpolationDefault];
// tell the view to put the image at the top, and make it translucent
overlay.contentMode = UIViewContentModeTop;
overlay.alpha = 0.5f;
picker.cameraOverlayView = overlay;

This code is in an xcode project that demonstrates the overlay by allowing you to take a photo, then overlaying it in the camera view. You can find the code on github.

This fix will be in the next release of Interlacer.

Happy coding!

Adding EXIF Metadata To Images On The iPhone

May 26, 2011 16:00

EXIF metadata is embedded in most of the images created by digital cameras, and the iPhone is no exception. This can include information about the camera that made the photo, the software used to process it, the data and time, geolocation information, and many other pieces of interesting information.

When I was developing Interlacer, one of my goals was to include information about how the photo was created. Since Interlacer creates a new photo from multiple sources, the EXIF metadata block in the final image is missing. I didn’t want to just copy metadata from the source images, since there is no guarantee that the metadata in the source images would be relevant to the final image. I decided that I wanted to save the name and version of the app, some information about the source images that were used to create the final image, and the date and time the final image was created.

There are a lot of examples of how to manipulate the existing EXIF data in an image on the iPhone, but I didn’t find much information about how to add EXIF data to an image that did not contain any. The solution turned out to be quite straightforward. When an image is saved using the ALAssetsLibrary class, a dictionary of metadata can be included. This dictionary includes some basic metadata and can also include dictionaries of other metadata, such as EXIF and TIFF metadata. The keys for all these metadata values are constants declared in ImageIO/CGImageProperties.h.

Depending on the information you want to save, you may need several dictionaries, each containing a specific type of metadata. In Interlacer, the date and time and image dimensions are saved as EXIF metadata, and information about Interlacer and the source images is saved as TIFF metadata.

Here is the code showing how to create EXIF and TIFF dictionaries and save the information along with an image:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

- (void)saveImageAndAddMetadata:(UIImage *)image
{
// Format the current date and time
NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
[formatter setDateFormat:@"yyyy:MM:dd HH:mm:ss"];
NSString *now = [formatter stringFromDate:[NSDate date]];
[formatter release];

// Exif metadata dictionary
// Includes date and time as well as image dimensions
NSMutableDictionary *exifDictionary = [NSMutableDictionary dictionary];
[exifDictionary setValue:now forKey:(NSString *)kCGImagePropertyExifDateTimeOriginal];
[exifDictionary setValue:now forKey:(NSString *)kCGImagePropertyExifDateTimeDigitized];
[exifDictionary setValue:[NSNumber numberWithFloat:image.size.width] forKey:(NSString *)kCGImagePropertyExifPixelXDimension];
[exifDictionary setValue:[NSNumber numberWithFloat:image.size.height] forKey:(NSString *)kCGImagePropertyExifPixelYDimension];

// Tiff metadata dictionary
// Includes information about the application used to create the image
// "Make" is the name of the app, "Model" is the version of the app
NSMutableDictionary *tiffDictionary = [NSMutableDictionary dictionary];
[tiffDictionary setValue:now forKey:(NSString *)kCGImagePropertyTIFFDateTime];
[tiffDictionary setValue:@"Interlacer" forKey:(NSString *)kCGImagePropertyTIFFMake];

NSString *version = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleShortVersionString"];
NSString *build = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleVersion"];
[tiffDictionary setValue:[NSString stringWithFormat:@"%@ (%@)", version, build] forKey:(NSString *)kCGImagePropertyTIFFModel];

// Image metadata dictionary
// Includes image dimensions, as well as the EXIF and TIFF metadata
NSMutableDictionary *dict = [NSMutableDictionary dictionary];
[dict setValue:[NSNumber numberWithFloat:image.size.width] forKey:(NSString *)kCGImagePropertyPixelWidth];
[dict setValue:[NSNumber numberWithFloat:image.size.height] forKey:(NSString *)kCGImagePropertyPixelHeight];
[dict setValue:exifDictionary forKey:(NSString *)kCGImagePropertyExifDictionary];
[dict setValue:tiffDictionary forKey:(NSString *)kCGImagePropertyTIFFDictionary];

ALAssetsLibrary *al = [[ALAssetsLibrary alloc] init];

[al writeImageToSavedPhotosAlbum:[image CGImage]
metadata:dict
completionBlock:^(NSURL *assetURL, NSError *error) {
if (error == nil) {
// notify user image was saved
} else {
// handle error
}
}];

[al release];
}

Jinx Updated

May 3, 2011 16:00

Jinx, a Java library to access the Flickr API, has been updated. The latest version supports these API entry points:
* activity
* auth
* blogs
* collections
* commons
* contacts
* favorites
* galleries
* groups
* groups.members
* photos
* photosets

You can get it on github.

Happy coding!

Knicker, a Wordnik API Library for Java

January 27, 2011 12:00

Wordnik is an online dictionary that bills itself as “The most comprehensive dictionary in the known universe”. Recently I wanted to add the ability to lookup word definitions to one of my applications, so I wrote a Java library to wrap the Wordnik API. The library is called Knicker, and is available under the terms of the GPL.

Using Knicker is simple:

Sign up for a Wordnik API key
Set the system property WORDNIK_API_KEY to your API key
Put the Knicker library in your classpath
Call methods on the library

Here’s an example of how to use the API to get a list of definitions for the word “siren”:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import java.util.List;
import net.jeremybrooks.knicker.Knicker;
import net.jeremybrooks.knicker.dto.Definition;
import net.jeremybrooks.knicker.dto.TokenStatus;

public class TestKnicker {

public static void main(String[] args) throws Exception {
// use your API key here
System.setProperty("WORDNIK_API_KEY", "");

// check the status of the API key
TokenStatus status = Knicker.status();
if (status.isValid()) {
System.out.println("API key is valid.");
} else {
System.out.println("API key is invalid!");
System.exit(1);
}

// get a list of definitions for a word
List<Definition> def = Knicker.definitions("siren");
System.out.println("Found " + def.size() + " definitions.");

int i = 1;
for (Definition d : def) {
System.out.println((i++) + ") " + d.getPartOfSpeech() + ": " + d.getText());
}

}
}

For more information about the Wordnik API, see their developers page.

Introducing Jinx

September 15, 2010 08:00

Jinx is a Java library that provides access to the Flickr API. It is pure Java, with no external dependencies.

The package structure is straightforward. Each Flickr API section (activity, auth, blogs, etc) has a corresponding class in the net.jeremybrooks.jinx.api package. The API classes are named ActivityApi, AuthApi, BlogsApi, etc. Each API class is implemented as a singleton. You can obtain an instance of an API class with a call to getInstance():

1	BlogsApi bApi = BlogsApi.getInstance();

Each Flickr method has a corresponding method in the API class. So if you want to call the Flickr flickr.blogs.getList method, you will call the getList() method on BlogsApi:

1	BlogsApi.getInstance().getList();

The API methods that return data will generally return instances of the Data Transfer Objects located in the net.jeremybrooks.jinx.dto package. The DTO’s are very simple classes, containing getter and setter methods and no other logic. All DTO’s implement java.io.Serializable.

Flickr returns a status message along with data for every API call. Jinx will check that status message for you. If Flickr reports an error, an instance of net.jeremybrooks.jinx.JinxException will be thrown. The Flickr error code and error message can be retrieved by calling getErrorCode and getErrorMessage.

This project is currently being used in SuprSetr. Currently, the following Flickr API sections are implemented:

Activity
Auth
Blogs
Collections
Commons
Photos
Photosets

Other sections of the Flickr API will be implemented over time. If you want to use Jinx now, you can get the source code from github and build it with ant. If you just want the binary jar file, you can download it at the Jinx home page. Javadocs are located here.

The test directory contains sample code showing how to use Jinx to access the Flickr API. Here is the TestAuthorization class, showing how to authorize an application to use Flickr:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

import java.io.File;
import net.jeremybrooks.jinx.Jinx;
import net.jeremybrooks.jinx.JinxConstants;
import net.jeremybrooks.jinx.api.AuthApi;
import net.jeremybrooks.jinx.dto.Frob;
import net.jeremybrooks.jinx.dto.Token;

/**
* This test class demonstrates how to perform authorization for your application.
*
* Your application must have its own key and secret. These can be obtained here:
* http://www.flickr.com/services/apps/create/apply/?
*
*
* @author jeremyb
*/
public class TestAuthorizaion {

/*
* Get a key for your app here:
* http://www.flickr.com/services/apps/create/apply/?
*/
private static final String KEY = "";
private static final String SECRET = "";

public static void main(String[] args) {

File tokenFile = new File("/tmp/myToken");
Token token = null;

try {
// Attempt to initialize with an existing token
if (tokenFile.exists()) {
token = new Token();
token.load(tokenFile);
Jinx.getInstance().init(KEY, SECRET, token);

} else {

// No token exists, so initialize with our key and secret,
// then prompt user to authorize our application
Jinx.getInstance().init(KEY, SECRET);
Frob frob = AuthApi.getInstance().getFrob(JinxConstants.PERMS_READ);

// Send user to the login URL
// In a real application, you would probably do this in a GUI
// of some sort
System.out.println("Please go to this URL and allow access: " + frob.getLoginUrl());
System.out.println("After you have authorized this application, press a key.");

// Wait for user to press a key
System.in.read();

// Complete authorization by getting the token and telling
// Jinx about it
token = AuthApi.getInstance().getToken(frob);
Jinx.getInstance().setToken(token);

System.out.println("Authorization successful.");

// The token can be stored for future use, and is valid until
// the user revokes access
token.store(new File("/tmp/myToken"));
}
} catch (Exception e) {
System.out.println("Oops, something went wrong!");
e.printStackTrace();
}
}
}

Jinx is released under the Gnu General Public License.

Continue reading Introducing Jinx
Author: jeremybrooks
Comment on Introducing Jinx »
Tags:
- Java,
- jinx,
- library,
- programming

Commenting Is Not An Option

March 22, 2010 20:58

Commenting code is a part of development and engineering that is overlooked all too often. It might be that developers are simply under so much pressure that they feel there is no time for commenting. It might be viewed as a hassle. And, it is not something that is required for the code to compile and execute.

The compiler sees comments as optional, but that does not mean that developers should see them the same way.

Commenting is a vital, I would even go as far as to say critical, part of any software engineering effort. If you have been in the business for any length of time, you have undoubtedly come across code that is missing meaningful comments. You probably spent a significant amount of time trying to figure out not only what the code was doing, but what the original author was intending to do. Perhaps you have even experienced this with your own code!

Try to get in the habit of adding meaningful comments while you are coding, and do not consider the project finished until the comments are in place. Often, the comments in code are the most up-to-date documentation that a project will have. Requirements and technical specs may be out of date once the coding actually starts, and keeping documentation up to date which is separate from the code is a much more complex task than keeping comments up to date. If you use Java, take a look at the article How to Write Doc Comments for the Javadoc Tool. Look at the Java source and see how the comments are formatted. With a little practice, commenting will become second nature.

What if you do not use Java? That’s ok — every language has some way to leave comments, and the principles apply just the same.

Here are five ways to make commenting work for you:

1) Comment the method signature before you write any code inside the method. Then write the code implementing the described behavior.

2) Comment private methods and fields, not just public ones. You can then tell the javadoc tool to include private classes in the generated documentation. The resulting javadocs will be invaluable for anybody that needs to maintain the program in the future. You can easily generate two sets of documents if needed, one for public use and one for private, internal use.

3) Update comments when you modify the code. Comments that do not match what the code is doing are not helpful.

4) Take advantage of version control keyword expansion in your comments. For example, including the CVS keyword $Id$ in your comment will tell you who checked in the file last, the date, the RCS filename, and the revision number.

5) Let your IDE do the work. Modern IDE’s understand javadoc comment format, and can often generate the boilerplate of the comment for you, including @param, @return, and @throws tags. You just have to fill in the blanks.

What other ways do you make comments in code work for you? Feel free to leave a comment below, and tell us about it!

A State Of Development tales from a software engineer

Pages