Active and Targeted Color Management

Apple uses two different approaches to color management -- one is active color management, which is provided in OS X. Active color management is a dynamic process, applied to every pixel in real time on every frame. For each pixel a color match is performed from the source content's profile space to the destination space, possibly with an intermediate space or working space (requiring an additional color match) in between. This color matching can be GPU accelerated when rendering to the display, or vectorized accelerated on the CPU when not rendering to the display (for example, when sending output to disk). This color management provides the formula to perform the color match, and that formula is applied to every pixel in the different frameworks (Core Image, Core Animation, ColorSync, Accelerate and various others) and applications.

OS X provides Active Color Management with ColorSync. Active color management is all about flexibility. It allows you to use any content and view it on any display, certainly on a desktop environment where you have many different display devices or other forms of output devices such as printers.

The other type of color management used by Apple is targeted color management, which is a technique to apply color management during authoring on the Mac before delivering your content on iOS. See Targeted Color Management - iOS sRGB.

Display Referred Environment

The goal of ColorSync color management is to reproduce the Authoring Intent — what the author saw and signed-off on their own display or output device. This form of color management is called output referred (if you are targeting the display it may also be called display referred).

Authoring Intent

The creation of film images and other forms of media are creative endeavors. This means a newly recorded scene is typically not distributed as the finished product. Instead, it is manipulated first (in the industry, this is called color timing). The result is the authoring intent. Only after the scene has been manipulated to the author’s satisfaction does it get distributed.

For example, consider broadcast video. Once distributed, broadcast video is really only intended to be looked at on a TV in a specific viewing environment. According to standards, that viewing environment is a fairly dark 1950's era living room. Modern usage is of course very different, and varying. You are probably not viewing media content in your living room on a modern workstation or personal computer. Instead, you probably have a large, bright display. There are even more environments. There are mobile devices you look at outdoors in the sunshine, or you may be looking at these devices in a dark theatre environment. Clearly there is a need to produce a consistent color appearance on different devices in different environments. That's what color management begins to solve.

Controlling Color conversions

What is the color management workflow?

Figure 1 illustrates an example of a typical workflow for many Mac users.

A typical workflow starts with three devices processing digital media: a camera, a Mac and a printer. Images are first downloaded from the camera, then viewed on the Mac display and finally printed on the printer. The expectation is the colors the camera produces by taking a snapshot of a given scene will be reproduced faithfully on the Mac display. Similarly, when the image is printed, the printer will reflect what was captured by the camera. In other words, you expect the workflow will produce consistent color across different devices. This is what color management is all about:

Color management = a controlled conversion between different color representations in order to achieve a consistent color appearance.

This workflow can quickly become very complicated. The user may bring in additional color media from the web, and may present this media on other computers like workstations, laptops and portable devices such as the iPhone or iPad. In addition, digital video might be added to the mix -- it has slightly different requirements. In the end, the goal is to have a consistent color appearance across all devices.

Device Color Capabilities

Problem to Solve

The problem that must be solved is how to reproduce color on different devices knowing the gamut of the devices are different. In the simple workflow from above, there are three different gamuts; one each for camera, display and printer. Let’s say you want to reproduce a color from the camera across all the devices. You can express the color space of any given device mathematically. Figure 2 shows the different color spaces for the camera (Adobe RGB), Mac laptop display and inkjet printer.

As you can see, the color spaces are vastly different. You can convert color from one color space to another through a mathematical conversion called gamut mapping, but it really depends on which colors you are trying to reproduce. You are limited to what colors the device can represent. This has consequences in terms of organizing your workflow. For example, when proofing you should have a large size gamut on your device. Otherwise, the gamut mapping may result in colors which are not correct in terms of the original data.

Color conversions are non-linear. Conversion to a smaller gamut can cause irreversible damage. Once you convert down specific colors in this manner they will remain there. Let’s imagine your camera acquires a blue color as shown in Figure 3 below, and you want to display this color across all your devices. Gamut mapping will covert it from the camera gamut to the laptop display gamut. You can see it lands inside the display gamut after the conversion. There is no problem reproducing it in the different gamut. The same is true if you try to print it.

Now imagine your camera acquires a very saturated green. The problem is this color does not exist in the gamuts of the other two devices. What happens in this case is the color is pushed inside the gamut. As a result, the saturated green becomes somewhat yellow. It is no longer the same color it was originally. In the case of the printer, the color shift isn’t very big. It's still very close to the original green.

This illustrates an important point: color conversions are very often irreversible. If you commit to the wrong colorspace when designing your workflow you may lose color information.

Color Values in Perspective

This illustrates another point. RGB device color values are not the same across different color spaces. These values are dependent upon the color space they are defined in.

For example, if you are given some RGB device values but you don't know what color space they came from, they really tell you nothing. Figure 4 compares the two color spaces discussed previously, Adobe RGB vs the smaller LCD display.

As you can see, the fully saturated green on the laptop display RGB is somewhere in the middle of chromaticity diagram. By contrast, the fully saturated Adobe RGB green is high up in the greens. These are not the same colors even though the RGB values are the same. This underscores the importance of knowing where the color values are coming from.

The conclusion to be drawn from this is color values are only meaningful when they are tagged with the proper profile.

How Does ColorSync Work?

Consider an image taken from a digital camera. The image will contain a profile characterizing that color space. Profiles contain tags that describe how to convert data between the device color space and the PCS. Profile connection spaces are based on spaces derived from the CIE color space. ColorSync supports two of these spaces, XYZ and L*a*b. The CIE color spaces can fully represent all the visible colors, thus ensuring there are no errors incurred during the process.

The profile that is associated with the image and describes the characteristics of the device on which the image was created is called the source profile. Displaying the image requires another profile, which is associated with the output device, such as a display. The profile for the output device is called the destination profile. If the image is destined for a display, a color match is performed by the CMM using the display’s profile (the destination profile) along with the image source profile to match the image colors to the display gamut. To perform the color match, the CMM creates a transform which converts color data from the source device to the destination through the PCS. See Figure 6.

This workflow can be repeated for many different devices. For example, you can scan an image on a scanner and view it on the display. If the image is printed, the ColorSync color matching will use the printer profile to match the image colors to the printer. If you have a properly built profile, you can analyze all the properties of your printer, and before commiting ink on paper (which can be costly) you can simulate the printer using a printer profile. This is called soft proofing. Soft proofing allows you to view on your computer monitor what your printout will look like when it is on a specific paper. The paper and ink combination is defined by the profile that you or someone else has made for your printer paper and ink combination. When a printer profile is made, the color of the paper is one of the factors that is figured into the profile. If you are able to view your image through the printer profile, you can see how that particular combination of ink and paper will reproduce it, taking into account the gamut as well as other characteristics of the inks used.

Quartz 2D (Core Graphics)

The Quartz 2D API is part of the Core Graphics framework (CoreGraphics.framework). Quartz 2D is an advanced, two-dimensional drawing engine. Quartz 2D provides low-level, lightweight 2D rendering with advanced color management that provides unmatched output fidelity regardless of display or printing device.

Core Animation

Core Animation is a graphics rendering and animation infrastructure that you use to animate the views and other visual elements of your app. With Core Animation, most of the work required to draw each frame of an animation is done for you. All you have to do is configure a few animation parameters, and Core Animation does the rest, handing most of the actual drawing work off to the onboard graphics hardware to accelerate the rendering. This automatic graphics acceleration results in high frame rates and smooth animations without burdening the CPU and slowing down your app. Color management is applied as necessary.

Core Image

Core Image is an image processing and analysis technology designed to provide near real-time processing for still and video images. It operates on image data types from the Core Graphics, Core Video, and Image I/O frameworks, using either a GPU or CPU rendering path. Core Image hides the details of low-level graphics processing by providing an easy-to-use application programming interface (API) so you don’t need to know the details of OpenGL to leverage the power of the GPU. The entire pipleline is color managed.

AV Foundation

AV Foundation is a powerful framework for playing and creating time-based audiovisual media. It allows you to add audio and video playback, capture, and encoding to your application. It delivers efficient media playback, and provides a GPU accelerated, color managed video pipeline. AV Foundation automatically applies color management to video on input, during playback, and on output. For more information, see Video Color Management in AV Foundation and QTKit.

Application Kit

The Application Kit framework contains the objects you need to implement a graphical, event-driven user interface. The Application Kit handles all the details for you as it efficiently draws on the screen. AppKit also color manages all the interface elements that you typically use in your windows.

vImage

vImage is a CPU-based, high-performance image processing framework. It is a subframework of the Accelerate framework. The vImage framework uses vectorized code that makes use of Single Instruction Multiple Data (SIMD) vector units, when available. It uses the best code for the hardware it is running on, in a manner completely transparent to the calling application. It includes high-level functions for image manipulation—convolutions, geometric transformations, histogram operations, morphological transformations, and alpha compositing—as well as utility functions for format conversions and other operations.

Quartz (Core Graphics)

Quartz provides rendering with advanced color management. Quartz defines a number of basic objects that allow you to describe and process color. Here are the objects pertaining to color:

• CGColorSpaceRef

• CGColorRef

• CGImageRef

• CGContextRef

The first is CGColorSpace. The CGColorSpace object allows Quartz to interpret your color data.

Color spaces can be created many different ways, but here is a simple API:

Listing 1  Creating a color space.

CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);

Color spaces can also be created directly from an ICC profile:

Listing 2  Creating a color space from an ICC profile.

CGColorSpaceRef colorspace = CGColorSpaceCreateWithICCProfile(<#Data containing the ICC Profile#>);

The CGColorRef object contains a set of components values (such as red, green, and blue) that uniquely define a color, and a color space that specifies how those components should be interpreted.

Listing 3  Creating a CGColorRef.

CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);

if (colorspace != NULL)

{

    CGFloat comp[4] = {0.5, 1.0, 0.7, 1.0}; // Last component is alpha

    // Create CGColorRef

    CGColorRef color = CGColorCreate(colorspace, comp);

        // do something with CGColorRef here.

        CGColorRelease(color); // Release CGColorRef when done

    // Release CGColorSpaceRef when done

    CGColorSpaceRelease(colorspace);

}

CGImageRef

CGImage consists of a CGColorSpaceRef and array of component values organized in rows and columns. These component values correspond to color space primaries.

Listing 4  Creating a CGImage.

CGImageRef image = CGImageCreate(width,

                                 height,

                                 ...

                                 ...

                                 colorSpace,

                                 ...

                                 renderingIntent);

To create a CGImageRef from a image file on disk, you can do as follows:

Listing 5  Create a CGImageRef from a image file on disk.

CFURLRef path = <#A path to an image#>; // Path to image

CGImageSourceRef imageSource = CGImageSourceCreateWithURL( path, NULL );

// Make sure the image source exists before continuing

if (imageSource != NULL)

{

    // Create an image from the first item in the image source.

    CGImageRef myImage = CGImageSourceCreateImageAtIndex(imageSource, 0, NULL);

        // do something with CGImageRef here.

        CGImageRelease(myImage); // Release CGImageRef when done

    // Release CGImageSourceRef when done

    CFRelease(imageSource);

}

Similarly, with a chunk of compressed image data in memory:

Listing 6  Create a CGImageRef from image data in memory.

CFDataRef data = <#Your image data#>;

CGImageSourceRef imageSource = CGImageSourceCreateWithData(data, NULL);

// Make sure the image source exists before continuing

if (imageSource != NULL)

{

    // Create an image from the first item in the image source.

    CGImageRef myImage = CGImageSourceCreateImageAtIndex(imageSource, 0, NULL);

        // do something with CGImageRef here.

        CGImageRelease(myImage); // Release CGImageRef when done

    // Release CGImageSourceRef when done

    CFRelease(imageSource);

}

CGContextRef

The CGContextRef represents a Quartz 2D drawing destination. A graphics context contains drawing parameters and all the device-specific information needed to render the paint on a page to the destination, whether the destination is a window in an application, a bitmap image, a PDF document, or a printer.

Listing 7  Drawing into a graphics context.

CGContextRef cgcontext = <#A graphics context#>

CGContextDrawImage(cgcontext,...);

...

CGContextStrokeRect(cgcontext,...);

CGContextFillRect(cgcontext,...);

Quartz provides creation functions for various flavors of Quartz graphics contexts including bitmap images and PDF. The most significant difference between different types of contexts is there are some that contain their own color space, and others that do not require color conversion because they are recording contexts.

These contexts let you specify a CGColorSpace:

• CGBitmapContext

• CGWindowContext

And these do not:

• CGPDFContext

• CGPostScriptContext

You can create a context with a specific color space and draw content into it with many types of color. Automatic color management is performed in the graphics context if the context’s CGColorSpace is different from the source CGColorSpace. For example, you can create an sRGB context and draw a CMYK image into it and composite that with monochrome or some other color. In this scenario, since the color space of the context destination is different than the source Core Graphics will automatically invoke ColorSync and perform the necessary color correction.

Other frameworks in Quartz

[NSView layer].contents = <#CGImageRef to display#>; // set layer contents to CGImageRef

CIImage* image = [CIImage imageWithContentsOfURL: <#NSURL location of the file#>];

if (image != NULL)

{

    image = [[[CIFilter filterWithName:@"CISepiaTone" keysAndValues:

          kCIInputImageKey, image,

          kCIInputIntensityKey, [NSNumber numberWithFloat:1.0], nil]

          valueForKey: kCIOutputImageKey];

    image = [[[CIFilter filterWithName:@"CIHueAdjust" keysAndValues:

          kCIInputImageKey, image,

          kCIInputAngleKey, [NSNumber numberWithFloat:1.57], nil]

          valueForKey: kCIOutputImageKey];

    [context drawImage: image atPoint:CGPointZero fromRect:[image extent]];

}

Image I/O

The Image I/O framework allows applications to read and write most image file formats. It is highly efficient, allows easy access to metadata, and provides color management.

Many file formats allow you to directly embed a color profile to characterize the image. When Image I/O reads an image file it will retrieve all the color metric information contained in any embedded color profile or metadata and create a CGColorSpace. You as the programmer need not worry about this.

The Image I/O framework provides opaque data types for reading image data from a source (CGImageSourceRef):

Listing 10  Reading image data - Create a CGImageSourceRef and acquire a CGImageRef.

CFURLRef path = <#A path to an image#>; // Path to image

CGImageSourceRef imageSource = CGImageSourceCreateWithURL( path, NULL );

// Make sure the image source exists before continuing

if (imageSource != NULL)

{

// Create an image from the first item in the image source.

CGImageRef myImage = CGImageSourceCreateImageAtIndex(imageSource, 0, NULL);

// do something with CGImageRef here.

CGImageRelease(myImage); // Release CGImageRef when done

// Release CGImageSourceRef when done

CFRelease(imageSource);

}

and writing image data to a destination (CGImageDestinationRef):

Listing 11  Writing image data - Create a CGImageDestinationRef in a specified file format and add a CGImageRef.

CFURLRef url = <#URL of image destination#>;

CGImageDestinationRef myImageDest = CGImageDestinationCreateWithURL(url, kUTTypePNG, 1, NULL);

// Make sure the image destination exists before continuing

if (myImageDest != NULL)

{

CGImageRef image = <#Image to add#>;

// Add an image to the image destination

CGImageDestinationAddImage(myImageDest, image, NULL);

CGImageDestinationFinalize(myImageDest);

CFRelease(myImageDest);

}

You create an image from an image source with functions like CGImageSourceCreateImageAtIndex, which will retrieve any color matching information in the image and create an appropriate CGColorSpace.

An image destination abstracts the data-writing task and eliminates the need for you to manage data through a raw buffer. You create an image destination with functions like CGImageDestinationCreateWithURL or CGImageDestinationCreateWithData. After you create an image destination, you can add an image to it by calling the CGImageDestinationAddImage or CGImageDestinationAddImageFromSource functions. Calling the function CGImageDestinationFinalize signals Image I/O that you are finished adding images.

Application Kit

The Application Kit is a framework containing the objects you need to implement a graphical, event-driven user interface. The Application Kit handles all the details for you as it efficiently draws on the screen. AppKit also color manages all the interface elements that you typically use in your windows.

To draw into a window using the OS X frameworks in Quartz you will need to access the CGContextRef for the window. Here’s how:

Listing 12  Acquire CGContextRef for the window.

CGContextRef cgcontext = [[NSGraphicsContext currentContext] graphicsPort];

When a window is created, AppKit automatically sets the window backing store color space. In OS X, the graphics context are connected to a window backing store. By default, the window context is tagged with the current display profile. However, in certain situations the color space can be changed by the application:

Listing 13  Setting the window's color space.

NSWindow *myWindow = <#Your window#>

[myWindow setColorSpace: [NSColorSpace sRGBColorSpace]];

You can then can draw different types of images and composite them together to this window graphics context and your custom color space will be used. See Figure 8.

You can also register for display change notifications (NSWindowDidChangeScreenProfileNotification):

Listing 14  Register for Display Change Notification.

NSWindow *myWindow = <#Your window#>

[myWindow setDisplaysWhenScreenProfileChanges:YES];

The display change notification is posted whenever the display profile for the screen containing the window changes. This notification is sent only if the window returns YES from the NSWindow displaysWhenScreenProfileChanges method as shown here:

Listing 15  Indicates whether the window context should be updated when the screen profile changes or when the window moves to a different screen.

- (BOOL)displaysWhenScreenProfileChanges

{

return YES;

}

The NSWindowDidChangeScreenProfileNotification may be sent when a majority of the window is moved to a different screen (whose profile is also different from the previous screen) or when the ColorSync profile for the current screen changes.

If you are caching information that is tied to the display you should discard it to allow for the proper color matching of your content.

After the window context is updated, the window is told to display itself. If you need to update offscreen caches for the window, you should register to receive the NSWindowDidChangeScreenProfileNotification notification.

Example - What happens in an Application using Color Managed Frameworks

Let's put this all together and see what happens in a simple app that acquires an image from a camera.

If the app is using Image Capture to acquire the image (as a CGImageRef), it will be properly tagged, and contain all the necessary color metric information (see previous Image Capture section). See Figure 10.

If the app then wants to draw the image on the screen, it simply calls the proper Quartz functions to perform the drawing; no further steps are necessary. Quartz will consult ColorSync to find the proper display profile, and convert the image data to the display profile color space to ensure it is displayed correctly. See Figure 10.

Printing an image is a similar process. If you are using CUPS, you don't even need to know which printer the user has selected. The CUPS printing architecture will determine the proper profile for the selected printer, and convert the data and print the job. See Figure 10.

In summary, OS X provides automatic color management through the various frameworks integrated with ColorSync.

Pixel Buffers should be Tagged

If you are working with pixel buffers explicitly you should make sure they have a CGColorSpace attached to them (the term tagging is used to describe this). Tagging pixel buffers is especially important if your application is synthesizing these buffers.

If you are reading pixel buffers from Core Media, AV Foundation, ImageIO or other framework, or even from another application, chances are they are already tagged -- if taken from a media file, the file will likely have a tag associated with it. Nevertheless, it is good practice to check them programmatically and make sure they are tagged. Pixel data that is not tagged is considered undefined, and can cause your colors to come out looking wrong. It is good practice to make sure everything is tagged, even programmatically. Untagged content should be tagged with something, and you'll need to determine what is most appropriate. For example, if you have untagged content that was intended for the web or PC, chances are it should be tagged as sRGB.

Graphics Contexts must be fully specified

The OS X frameworks very often require you setup a graphics context. Make sure your contexts are fully specified with an appropriate color space in order to be properly color managed.

Use of device RGB colors is problematic

RGB device values without any color space information really tell you nothing. The colors produced by RGB (and CMYK) are specific to a device. Because their color appearance is device dependent, these spaces are actually the worst choice for faithful color reproduction across different devices. Devices (displays, printers, scanners, cameras) don't treat color the same way; each has its own range of colors that the device can produce faithfully. A color produced on one device might not be able to be produced on another device. Therefore, device RGB color usage is strongly discouraged. Don’t expect consistent results when using device RGB colors with the OS X frameworks because each individual framework may treat these differently.

vImage

With vImage you can perform explicit color management of images. Of particular interest with regard to color management are the transformation and format conversion functions. Image transformation operations alter the values of pixels in an image as defined by custom functions provided as a callback. With vImage, you can use image transformation operations on the following sorts of functions:

• Matrix multiplication

  Color space conversion

  Hue, saturation, brightness

  Color effects

• Gamma correction

You use a vImageConverter object to convert an image from one format to another. A vImageConverter interoperates with Core Graphics by supporting the CGImageRef object. To use a vImageConverter you define a vImage_CGImageFormat structure which describes your image format. The vImage_CGImageFormat structure defines the ordering of the color channels, how many there are, the size and type of the data in the color channels, whether the data is premultiplied by alpha or not, and the color space model for the pixel data. This format mirrors the image format descriptors used by CoreGraphics to create things like CGImageRef and CGBitmapContextRef:

Listing 16  The vImage_CGImageFormat structure.

typedef struct

{

   uint32_t                bitsPerComponent; /* # bits in each color channel */

   uint32_t                bitsPerPixel; /* # of bits in each pixel. */

   CGColorSpaceRef         colorSpace; /* color space model for the pixels */

   CGBitmapInfo            bitmapInfo; /* describes the color channels */

   uint32_t                version; /* Reserved for future expansion */

   const CGFloat           *decode; /* Decode parameter */

   CGColorRenderingIntent  renderingIntent; /* See CGColorSpace.h */

}vImage_CGImageFormat;

vImage functions use a vImage_Buffer structure to receive and supply the pixel data. The vImage_Buffer contains a pointer to the pixel data, the height and width of the buffer, and the number of bytes in a pixel row. The following example shows how to initialize a vImage_Buffer of a desired format, from a file referenced by a CFURLRef:

Listing 17  Initializing a vImage_Buffer of a desired format.

CFURLRef url = <#A url to your source image file#>;

CGImageSourceRef imageSource = CGImageSourceCreateWithURL(url, NULL);

CGImageRef image = CGImageSourceCreateImageAtIndex( imageSource, 0, NULL );

vImage_Buffer result;

vImage_CGImageFormat format = {

    .bitsPerComponent = (uint32_t) CGImageGetBitsPerComponent(image),

    .bitsPerPixel = (uint32_t) CGImageGetBitsPerPixel(image),

    .bitmapInfo = CGImageGetBitmapInfo(image),

    .colorSpace = CGImageGetColorSpace(image)

}; // .version, .renderingIntent and .decode all initialized to 0 per C rules

vImage_Error err = vImageBuffer_InitWithCGImage( &result, &format, NULL, image, kvImageNoFlags );

A vImageConverter object is used to convert an image. A vImageConverter object is created by specifying a source and destination vImage_CGImageFormat, optionally with a custom colorspace transform. Listing 18 shows how to create a vImageConverter, and uses a colorspace transform you pass in. This gives you greater control over the fine details of colorspace conversion, for exacting color fidelity.

Listing 18  Creating a vImageConverter.

CFArrayRef profileSequence = <#A set of profiles to be used in the transform#>;

CFTypeRef codeFragment = NULL;

/* transform to be used for converting color */

ColorSyncTransformRef transform = ColorSyncTransformCreate (profileSequence, NULL);

/* get the code fragment specifying the full conversion */

codeFragment = ColorSyncTransformCopyProperty(transform, kColorSyncTransformFullConversionData, NULL);

if (transform) CFRelease (transform);

vImage_CGImageFormat inpFormat = { /* Your source image format */ };

vImage_CGImageFormat outFormat = { /* Your output image format */ };

vImage_Error err;

/* create a converter to do the image format conversion. */

vImageConverterRef converter = vImageConverter_CreateWithColorSyncCodeFragment( codeFragment, &inpFormat, &outFormat, NULL, kvImageNoFlags, &err );

You call the vImageConvert_AnyToAny function with an appropriately configured vImageConverter to convert the image.

Listing 19  Converting an image with the vImageConvert_AnyToAny function.

vImageConverterRef converter = <#A configured image converter#>;

vImage_Buffer srcBuf = <#an array of vImage_Buffer structs describing the source data planes#>;

vImage_Buffer destBuf = <#an array of vImage_Buffer structs describing the destination data planes#>;

vImage_Error err;

err = vImageConvert_AnyToAny(converter, & srcBuf, & destBuf, NULL, kvImageNoFlags );

Finally, call the vImageCreateCGImageFromBuffer function to create a CGImageRef from the converted image data in the vImage_Buffer.

Listing 20  Calling vImageCreateCGImageFromBuffer to create a CGImageRef from the converted image data.

vImage_Error err;

vImage_Buffer destBuf = <#A buffer with the converted image data#>;

vImage_CGImageFormat outFormat = { /*The output image format */ };

CGImageRef outImage = vImageCreateCGImageFromBuffer( &destBuf, &outFormat, NULL, NULL, kvImageNoAllocate, &err );

OpenGL - Explicit Color Management Example

OpenGL is not color managed. As a consequence, it might require additional effort to devise solutions to specific color problems you may encounter when using it. The fundamental problem is OpenGL has one set of assumptions, and the display buffer has another.

OpenGL has a linear light model. For example, if you apply a garoud shade to a scene in OpenGL you are working with a linear light model.

OpenGL has RGB values, but they are not RGB specific in any particular gamut.

The display buffer is largely sRGB 2.2 gamma.

How do you go from the OpenGL linear model into something that is appropriate for the display buffer? There are two different strategies you can take: a simple one, and one slightly more sophisticated.

result = pow(fvalue, (source / destination));

result = sqrt(fvalue); // approximation

FragmentInfo = ColorSyncTransformCopyProperty (transform, kColorSyncTransformFullConversionData, NULL);

Authoring Content for iOS - Best Practices

Consider some typical scenarios: let's say you have a company logo, and you want your iOS app's logo to have the same appearance as your company logo. Or what if you are targeting a specific color from a color chart for some particular elements in your app. How do you go about it?

Here’s some general guidelines to follow to ensure your colors come out looking right when authoring content for iOS apps.

Preview

The Preview app is color managed, and is a great tool for opening your content and making sure it looks correct. If you bring up the inspector window (Tools > Show Inspector menu item) it will tell you if there is a tag attached.

This is important, because you could be looking at untagged content. Very often it won't be obvious if a particular image is tagged or untagged. In addition, untagged content may look correct — even non color managed content may look corrrect on a particular display, but it is almost guaranteed to look different on another person’s display. Color management not only makes things look correct, but it makes them consistent.

With Preview, you can tag an image with a color profile using the Tools > Assign Profile menu item.

This allows you to set the color space for an image. Note it doesn't change the pixel values in your file, it changes the information that is associated with it. It tells the color management system how to render those pixels.

ColorSync Utility

ColorSync Utility is very powerful app. There are a number of different things you can do with it, such as assign a profile to image data. You can also perform a profile match operation. This is an operation that actually modifies pixels. For instance, if you open a ProPhoto wide gamut image you can have it matched to sRGB so that all the pixel values are converted to sRGB and saved in the file. The file will then have an sRGB profile associated with it.

You can compare ICC profiles in three dimensions. This becomes very useful when comparing gamuts. As a case in point, if you want to figure out if all the colors in an image in a certain color space can be represented in another color space, you can compare both of those in 3D, and spin the result around and see if any stick out. Those colors that stick out cannot be represented in that color space.

ColorSync Utility also has a calculator that allows you to perform math calculations. For instance, you can use the calculator to determine what a value in the ProPhoto color space is in sRGB. This can be useful if you are authoring RGB values for OpenGL rendering and you want to match something that is color managed. It can also be useful for HTML or for the web.

Automator Profile action

Automator is an Apple app that automates repetitive procedures on OS X. With Automator, users can construct arbitrarily complex workflows from modular units called actions. An action performs a discrete task, such as opening a file or cropping an image. A workflow is a number of actions in a particular sequence.

Apple includes a suite of ready-made actions with Automator. These include an action that allows you to apply a selected ColorSync profile to an image. For instance, you could use this action to create a workflow that assigns an sRGB profile to all the images in a specified folder.

sips —matchto “/System/Library/ColorSync/Profiles/sRGB Profile.icc” *.jpg

Evaluating Results

How do you evaluate the results of any image editing to make sure the colors are correct? One very powerful technique is to use what is called a “trick” profile. Here’s an explanation:

Content with Embedded Trick Profile

This is special content with an embedded “trick” profile. A “trick” profile is not a regular profile you would expect to see in an image file. Instead, it is a profile specially made to allow you to easily tell whether or not ColorSync color management is being performed when the image is drawn or printed. If you view this special content in a non color managed application you can see it is clearly wrong.

If you look at it in a color managed application such as Preview you can see it is correct.

You can use this content in your own applications too. It is part of the ImageApp. See also the Image Color Management for more information.