/*
|
* Copyright 2012 ZXing authors
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#import "ZXBitMatrix.h"
|
#import "ZXImage.h"
|
|
#if TARGET_OS_EMBEDDED || TARGET_IPHONE_SIMULATOR
|
#import <ImageIO/ImageIO.h>
|
#endif
|
|
@implementation ZXImage
|
|
- (ZXImage *)initWithCGImageRef:(CGImageRef)image {
|
if (self = [super init]) {
|
_cgimage = CGImageRetain(image);
|
}
|
|
return self;
|
}
|
|
- (ZXImage *)initWithURL:(NSURL const *)url {
|
if (self = [super init]) {
|
CGDataProviderRef provider = CGDataProviderCreateWithURL((__bridge CFURLRef)url);
|
|
if (provider) {
|
CGImageSourceRef source = CGImageSourceCreateWithDataProvider(provider, 0);
|
|
if (source) {
|
_cgimage = CGImageSourceCreateImageAtIndex(source, 0, 0);
|
CFRelease(source);
|
}
|
|
CGDataProviderRelease(provider);
|
}
|
}
|
|
return self;
|
}
|
|
- (size_t)width {
|
return CGImageGetWidth(self.cgimage);
|
}
|
|
- (size_t)height {
|
return CGImageGetHeight(self.cgimage);
|
}
|
|
- (void)dealloc {
|
if (_cgimage) {
|
CGImageRelease(_cgimage);
|
}
|
}
|
|
+ (ZXImage *)imageWithMatrix:(ZXBitMatrix *)matrix {
|
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceGray();
|
|
CGFloat blackComponents[] = {0.0f, 1.0f};
|
CGColorRef black = CGColorCreate(colorSpace, blackComponents);
|
CGFloat whiteComponents[] = {1.0f, 1.0f};
|
CGColorRef white = CGColorCreate(colorSpace, whiteComponents);
|
|
CFRelease(colorSpace);
|
|
ZXImage *result = [self imageWithMatrix:matrix onColor:black offColor:white];
|
|
CGColorRelease(white);
|
CGColorRelease(black);
|
|
return result;
|
}
|
|
+ (ZXImage *)imageWithMatrix:(ZXBitMatrix *)matrix onColor:(CGColorRef)onColor offColor:(CGColorRef)offColor {
|
int8_t onIntensities[4], offIntensities[4];
|
|
[self setColorIntensities:onIntensities color:onColor];
|
[self setColorIntensities:offIntensities color:offColor];
|
|
int width = matrix.width;
|
int height = matrix.height;
|
int8_t *bytes = (int8_t *)malloc(width * height * 4);
|
for (int y = 0; y < height; y++) {
|
for (int x = 0; x < width; x++) {
|
BOOL bit = [matrix getX:x y:y];
|
for (int i = 0; i < 4; i++) {
|
int8_t intensity = bit ? onIntensities[i] : offIntensities[i];
|
bytes[y * width * 4 + x * 4 + i] = intensity;
|
}
|
}
|
}
|
|
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
|
CGContextRef c = CGBitmapContextCreate(bytes, width, height, 8, 4 * width, colorSpace, kCGBitmapAlphaInfoMask & kCGImageAlphaPremultipliedLast);
|
CFRelease(colorSpace);
|
CGImageRef image = CGBitmapContextCreateImage(c);
|
CFRelease(c);
|
free(bytes);
|
|
ZXImage *zxImage = [[ZXImage alloc] initWithCGImageRef:image];
|
|
CFRelease(image);
|
return zxImage;
|
}
|
|
+ (void)setColorIntensities:(int8_t *)intensities color:(CGColorRef)color {
|
memset(intensities, 0, 4);
|
|
size_t numberOfComponents = CGColorGetNumberOfComponents(color);
|
const CGFloat *components = CGColorGetComponents(color);
|
|
if (numberOfComponents == 4) {
|
for (int i = 0; i < 4; i++) {
|
intensities[i] = components[i] * 255;
|
}
|
} else if (numberOfComponents == 2) {
|
for (int i = 0; i < 3; i++) {
|
intensities[i] = components[0] * 255;
|
}
|
intensities[3] = components[1] * 255;
|
}
|
}
|
|
@end
|
