Is it possible to store an image as a string in cocoa?

Question

I want to hard code the binary data for an image in a class file. When the class gets initialized, create an NSImage from that data. Storing the image in the resources folder is not an option.

Is this possible and how?

Answer 1

use NSData rather than NSString.

NSImage is NSCoding compliant - it knows how to archive itself, and how to create/read image representations of other file formats.

if you want to work with another image representation, you can use CGImage apis to create a CGImage, which can then be used to create a NSImage.

Answer 2

//get the image
NSImage *newImage = [[NSImage alloc] initWithContentsOfFile:@"~/Desktop/testImg.png"];
//convert to BitmapImageRep
NSBitmapImageRep *bitmap = [[newImage representations] objectAtIndex:0];
//convert to NSData
NSData *data = [bitmap representationUsingType: NSPNGFileType properties: nil];
//base64 encode and now I have the string. 
NSString *imageString = [data encodeBase64WithNewlines:NO];
NSLog(@"image %@", imageString);
//No that I have the string, I can hard code it into my source code (paste it in).

//When I want to create an image out of it I just get the imageString and convert it to an image
NSData *revData = [imageString decodeBase64WithNewlines:NO];
newImage = [[NSImage alloc] initWithData:revData];

I have 2 NSData Categories I use here (encodeBase64WithNewlines:NO and decodeBase64WithNewlines:NO) You will have to include libcrypto.dylib for them to work. I think I copied them from Cocoa Dev

- (NSString *) encodeBase64WithNewlines: (BOOL) encodeWithNewlines
{
// Create a memory buffer which will contain the Base64 encoded string
BIO * mem = BIO_new(BIO_s_mem());

// Push on a Base64 filter so that writing to the buffer encodes the data
BIO * b64 = BIO_new(BIO_f_base64());
if (!encodeWithNewlines)
    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
mem = BIO_push(b64, mem);

// Encode all the data
BIO_write(mem, [self bytes], [self length]);
int flushResult = BIO_flush(mem);
if(flushResult != 0){
    //throw some warning?
}

// Create a new string from the data in the memory buffer
char * base64Pointer;
long base64Length = BIO_get_mem_data(mem, &base64Pointer);
NSData * base64data = [NSData dataWithBytesNoCopy:base64Pointer length:base64Length freeWhenDone:NO];
NSString * base64String = [[NSString alloc] initWithData:base64data encoding:NSUTF8StringEncoding];

// Clean up and go home
BIO_free_all(mem);
return [base64String autorelease];
}



- (NSData *)decodeBase64WithNewLines:(BOOL)encodedWithNewlines
{
// Create a memory buffer containing Base64 encoded string data
BIO * mem = BIO_new_mem_buf((void *) [self bytes], [self length]);

// Push a Base64 filter so that reading from the buffer decodes it
BIO * b64 = BIO_new(BIO_f_base64());
if (!encodedWithNewlines)
    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
mem = BIO_push(b64, mem);

// Decode into an NSMutableData
NSMutableData * data = [NSMutableData data];
char inbuf[512];
int inlen;
while ((inlen = BIO_read(mem, inbuf, sizeof(inbuf))) > 0)
    [data appendBytes: inbuf length: inlen];

// Clean up and go home
BIO_free_all(mem);
return data;
}