To get rid of these old simulators in your new Xcode 4.5, follow the next steps:

Step 1:
Go to /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs
and delete the SDK you no longer need, e.g. iPhoneSimulator5.0.sdk

Step 2:
Go to ~/Library/Caches/com.apple.dt.Xcode/Downloads and delete the simulator package so that Xcode does not ask you to install older simulators when you launch it, e.g. Xcode.SDK.iPhoneSimulator.5.0-5.0.1.1.dmg

In some cases you might want to get the alpha value for a specific point/pixel in an image. Let’s say for example that you have an image of a drum music instrument, and you want to check that the user is tapping on the drum graphic and not on the transparent areas around it.

To do that check you need to use the Core Graphics API. Let’s assume that we have a IHAlphaDataView class inheriting from UIView and that it contains a UIImageView. We want to get the alpha value at a specific point on the image where the user tapped. Our IHAlphaDataView interface would be:

typedef unsigned char byte;
 
@interface IHAlphaDataView : UIView
{
    UIImageView * imageView;
}
 
- (float)alphaAtPoint:(CGPoint)point;
 
@end

And the IHAlphaDataView implementation:

- (float)alphaAtPoint:(CGPoint)point
{
    byte data = 0;
 
    CGContextRef context = CGBitmapContextCreate(&data, 1, 1, 8, 1, NULL, kCGImageAlphaOnly);
 
    UIGraphicsPushContext(context);
    [imageView.image drawAtPoint:CGPointMake(-point.x, -point.y)];
 
    UIGraphicsPopContext();
    CGContextRelease(context);
 
    return data / 255.0f;
}

Let’s go through the implementation of the alphaAtPoint method that returns the alpha value for a specific point on the image.

First we declare our byte variable that will hold the alpha value. A byte is a type definition we added to our interface and is the same with a char data type.

Then we create a bitmap context. To do that we pass the following parameters to the CGBitmapContextCreate function:

1. a pointer to where the context will be drawn
2. the width of the bitmap that will be drawn
3. the height of the bitmap
4. the bits per component (we need 8 bits=1 byte for alpha)
5. the bytes per row (we will have one row with one pixel holding an alpha value, so that will be 1)
6. a color space (we pass a NULL color space since we do not care about the color)
7. other options (we pass the kCGImageAlphaOnly option there since we only want the alpha value).

Next we make the context we created active and we draw our image at the point that the method receives. Note that we use negative values, -x and -y. That is the point at which we want to draw the top left-corner of the image. In that way we are moving the image by x and y so that the context contains the point that we are interested in.

Finally we pop the context since we are done with it, release it and return our byte divided by 255.0f. We want to return values ranging from 0 to 1, that is why we do that division, the value of a byte ranges from 0 to 255.

Let’s assume that we have a IHAlphaDataView object (e.g. named myAlphaView) in a main view. We can make alpha checks in the following way:

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
    for(UITouch * touch in touches)
    {
        CGPoint point = [touch locationInView:self];
 
        if(CGRectContainsPoint(myAlphaView.frame, point))
        {
            CGPoint convertedPoint = [self convertPoint:point toView:myAlphaView];
 
            float alpha = [myAlphaView alphaAtPoint:convertedPoint];
        }
    }
}

That is all you need to get the alpha value of a point in an image. But what about getting the RGB values? Lets see how a colorAtPoint method should work:

typedef struct {
    byte red;
    byte green;
    byte blue;
    byte alpha;
} RGBAPixel;
 
- (UIColor *)colorAtPoint:(CGPoint)point
{
    RGBAPixel pixel = {0, 0, 0, 0};
 
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
 
    CGContextRef context = CGBitmapContextCreate(&pixel, 1, 1, 8, sizeof(RGBAPixel), colorSpace, kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
 
    UIGraphicsPushContext(context);
 
    [imageView.image drawAtPoint:CGPointMake(-point.x, -point.y)];
 
    UIGraphicsPopContext();
    CGContextRelease(context);
    CGColorSpaceRelease(colorSpace);
 
    CGFloat red = pixel.red / 255.0f;
    CGFloat green = pixel.green / 255.0f;
    CGFloat blue = pixel.blue / 255.0f;
    CGFloat alpha = pixel.alpha / 255.0f;            
 
    UIColor * color = [UIColor colorWithRed:red / alpha green:green / alpha blue:blue / alpha alpha:alpha];
 
    return color;
}

For more convenience and code readability, we have added another typedef named RGBAPixel which holds 4 bytes, 1 byte for each component. Our method starts by definining an RGBAPixel var and initializing it with 0s.

Then we are creating a color space because we need the colors now. While creating our context we pass it that color space.

The bytes per row that we pass this time is not 1, but sizeof(RGBAPixel) which is 4 bytes, and the last difference in our context creation is that we pass the kCGImageAlphaPremultipliedLast and kCGBitmapByteOrder32Big options combined.
kCGImageAlphaPremultipliedLast means that we want to put the alpha value in the least significant bits of our RGBAPixel variable and the kCGBitmapByteOrder32Big means that the least significant bits are in the last byte (higher address). If you check our RGBAPixel typedef, the last byte is our alpha, so everything will fall into place.
For more on endianness check http://en.wikipedia.org/wiki/Endianness

Next, we draw using the context like before and release it. We are also releasing the color space.

Finally we get the individual values and return a UIColor variable. Note that we divide each color by alpha, that is because the colors we got were alpha premultiplied (kCGImageAlphaPremultipliedLast), so we are undoing this by dividing with alpha.

That is how it all works!. Here is an app I created using this technique. It is called Drum Set+ itunes.apple.com/app/id492177760. Try tapping on the drums, you can only hit them when you tap them within their shape, and not in the corners.

You can find everything I described in this post, a working example and and some more functionality on my GitHub repository https://github.com/ioshero/RGBA
One feature that has been included, is caching the bitmap data and not drawing a new context every time you want to check the RGBA values of a point.

I hope you put this knowledge into good use and create something fun!