Jak uzyskać dane pikseli z interfejsu UIImage (Cocoa Touch) lub CGImage (Core Graphics)?

Jednym ze sposobów jest narysowanie obrazu do kontekstu bitmapowego, który jest wspierany przez dany bufor dla danej przestrzeni kolorów (w tym przypadku jest to RGB): (zauważ, że spowoduje to skopiowanie danych obrazu do tego bufora, więc chcesz go buforować zamiast wykonywać tę operację za każdym razem, gdy musisz uzyskać wartości pikseli)

Patrz poniżej jako próbka:

// First get the image into your data buffer
CGImageRef image = [myUIImage CGImage];
NSUInteger width = CGImageGetWidth(image);
NSUInteger height = CGImageGetHeight(image);
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
unsigned char *rawData = malloc(height * width * 4);
NSUInteger bytesPerPixel = 4;
NSUInteger bytesPerRow = bytesPerPixel * width;
NSUInteger bitsPerComponent = 8;
CGContextRef context = CGBitmapContextCreate(rawData, width, height, bitsPerComponent, bytesPerRow, colorSpace, kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
CGColorSpaceRelease(colorSpace);

CGContextDrawImage(context, CGRectMake(0, 0, width, height));
CGContextRelease(context);

// Now your rawData contains the image data in the RGBA8888 pixel format.
int byteIndex = (bytesPerRow * yy) + xx * bytesPerPixel;
red = rawData[byteIndex];
green = rawData[byteIndex + 1];
blue = rawData[byteIndex + 2];
alpha = rawData[byteIndex + 3];

Techniczne Q&A Qa1509 pokazuje następujące proste podejście:

CFDataRef CopyImagePixels(CGImageRef inImage)
{
    return CGDataProviderCopyData(CGImageGetDataProvider(inImage));
}

Użyj CFDataGetBytePtr, aby dostać się do rzeczywistych bajtów (i różnych metod CGImageGet*, aby zrozumieć, jak je interpretować).

Nie mogłem uwierzyć, że jest ani jednej poprawnej odpowiedzi proszę. Nie ma potrzeby przydzielania wskaźników, a niezapowiedziane wartości nadal muszą być znormalizowane. Aby przejść do sedna, oto prawidłowa wersja dla Swift 4. Dla UIImage Wystarczy użyć .cgImage.

extension CGImage {
    func colors(at: [CGPoint]) -> [UIColor]? {
        let colorSpace = CGColorSpaceCreateDeviceRGB()
        let bytesPerPixel = 4
        let bytesPerRow = bytesPerPixel * width
        let bitsPerComponent = 8
        let bitmapInfo: UInt32 = CGImageAlphaInfo.premultipliedLast.rawValue | CGBitmapInfo.byteOrder32Big.rawValue

        guard let context = CGContext(data: nil, width: width, height: height, bitsPerComponent: bitsPerComponent, bytesPerRow: bytesPerRow, space: colorSpace, bitmapInfo: bitmapInfo),
            let ptr = context.data?.assumingMemoryBound(to: UInt8.self) else {
            return nil
        }

        context.draw(self, in: CGRect(x: 0, y: 0, width: width, height: height))

        return at.map { p in
            let i = bytesPerRow * Int(p.y) + bytesPerPixel * Int(p.x)

            let a = CGFloat(ptr[i + 3]) / 255.0
            let r = (CGFloat(ptr[i]) / a) / 255.0
            let g = (CGFloat(ptr[i + 1]) / a) / 255.0
            let b = (CGFloat(ptr[i + 2]) / a) / 255.0

            return UIColor(red: r, green: g, blue: b, alpha: a)
        }
    }
}

Powodem, dla którego musisz najpierw narysować/przekonwertować obraz do bufora, jest to, że obrazy mogą mieć kilka różnych formatów. Ten krok jest wymagany do przekonwertowania go do spójnego formatu, który możesz przeczytać.

NSString * path = [[NSBundle mainBundle] pathForResource:@"filename" ofType:@"jpg"];
UIImage * img = [[UIImage alloc]initWithContentsOfFile:path];
CGImageRef image = [img CGImage];
CFDataRef data = CGDataProviderCopyData(CGImageGetDataProvider(image));
const unsigned char * buffer =  CFDataGetBytePtr(data);

Oto wątek SO gdzie @Matt renderuje tylko żądany piksel w kontekście 1x1, przesuwając obraz tak, aby żądany piksel wyrównał się z jednym pikselem w kontekście.

UIImage jest opakowaniem, którego bajty to CGImage lub CIImage

Zgodnie z referencją Apple na UIImage obiekt jest niezmienny i nie masz dostępu do bajtów kopii zapasowej. Chociaż prawdą jest, że możesz uzyskać dostęp do danych CGImage, jeśli wypełniłeś UIImage CGImage (jawnie lub pośrednio), zwróci NULL, jeśli UIImage jest wspierany przez CIImage i odwrotnie.

Obiekty obrazu nie zapewniają bezpośredniego dostępu do ich obrazu podstawowego data. Jednak Ty może pobierać dane obrazu w innych formatach dla użyj w aplikacji. W szczególności możesz użyć cgImage i ciImage właściwości umożliwiające pobranie wersji obrazu zgodnych z Core Graphics i Core Image, odpowiednio. Możesz również użyć UIImagePNGRepresentation (:) i UIImageJPEGRepresentation (:_:) funkcje do generowania obiektu NSData zawierającego dane obrazu w format PNG lub JPEG.

Typowe sztuczki, aby obejść to wydanie

Jak podano Twoje opcje to

• UIImagePNGRepresentation lub JPEG
• Określ, czy obraz ma dane z kopii zapasowej CGImage lub CIImage i wprowadź je tam

Żadna z tych sztuczek nie jest szczególnie dobra, jeśli chcesz, aby dane wyjściowe nie były danymi ARGB, PNG lub JPEG, a dane nie są jeszcze wspierane przez CIImage.

Moja rekomendacja, spróbuj CIImage

Podczas tworzenia projektu może być bardziej sensowne dla ciebie, aby uniknąć UIImage całkowicie i wybrać coś innego. UIImage, jako opakowanie obrazu Obj-C, jest często wspierany przez CGImage do punktu, w którym bierzemy to za pewnik. CIImage wydaje się być lepszym formatem wrappera, ponieważ możesz użyć CIContext , aby uzyskać pożądany format bez potrzeby wiedzieć, jak został stworzony. W Twoim przypadku uzyskanie bitmapy byłoby kwestią wywołania

- render: toBitmap:rowBytes:bounds:format: colorSpace:

Jako dodatkowy bonus możesz zacząć robić ładne manipulacje, aby obraz przez łączenie filtrów na obrazie. To rozwiązuje wiele problemów, w których obraz jest do góry nogami lub musi być obrócony / skalowany itp.

Opierając się na odpowiedzi Olie i Algal, oto zaktualizowana odpowiedź dla Swift 3

public func getRGBAs(fromImage image: UIImage, x: Int, y: Int, count: Int) -> [UIColor] {

var result = [UIColor]()

// First get the image into your data buffer
guard let cgImage = image.cgImage else {
    print("CGContext creation failed")
    return []
}

let width = cgImage.width
let height = cgImage.height
let colorSpace = CGColorSpaceCreateDeviceRGB()
let rawdata = calloc(height*width*4, MemoryLayout<CUnsignedChar>.size)
let bytesPerPixel = 4
let bytesPerRow = bytesPerPixel * width
let bitsPerComponent = 8
let bitmapInfo: UInt32 = CGImageAlphaInfo.premultipliedLast.rawValue | CGBitmapInfo.byteOrder32Big.rawValue

guard let context = CGContext(data: rawdata, width: width, height: height, bitsPerComponent: bitsPerComponent, bytesPerRow: bytesPerRow, space: colorSpace, bitmapInfo: bitmapInfo) else {
    print("CGContext creation failed")
    return result
}

context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))

// Now your rawData contains the image data in the RGBA8888 pixel format.
var byteIndex = bytesPerRow * y + bytesPerPixel * x

for _ in 0..<count {
    let alpha = CGFloat(rawdata!.load(fromByteOffset: byteIndex + 3, as: UInt8.self)) / 255.0
    let red = CGFloat(rawdata!.load(fromByteOffset: byteIndex, as: UInt8.self)) / alpha
    let green = CGFloat(rawdata!.load(fromByteOffset: byteIndex + 1, as: UInt8.self)) / alpha
    let blue = CGFloat(rawdata!.load(fromByteOffset: byteIndex + 2, as: UInt8.self)) / alpha
    byteIndex += bytesPerPixel

    let aColor = UIColor(red: red, green: green, blue: blue, alpha: alpha)
    result.append(aColor)
}

free(rawdata)

return result
}

Swift

Wersja Swift 5

Odpowiedzi tutaj są nieaktualne lub nieprawidłowe, ponieważ nie biorą pod uwagę:

1. rozmiar piksela obrazu może różnić się od jego rozmiaru punktu, który jest zwracany przez image.size.width/image.size.height.
2. w obrazie mogą występować różne układy używane przez komponenty pikseli, takie jak BGRA, ABGR, ARGB itp. lub może w ogóle nie mieć komponentu Alfa, takiego jak BGR i RGB. Na przykład metoda UIView.drawHierarchy(in:afterScreenUpdates:) może produkować BGRA obrazy.
3. komponenty kolorów mogą być wstępnie przemnożone przez Alfę dla wszystkich pikseli obrazu i muszą być podzielone przez Alfę, aby przywrócić oryginalny kolor.
4. dla optymalizacji pamięci używanej przez CGImage, rozmiar wiersza piksela w bajtach może być większy niż zwykłe pomnożenie szerokości piksela przez 4.

Poniższy kod ma zapewnić uniwersalne rozwiązanie Swift 5, aby uzyskać UIColor piksela dla wszystkich takich szczególnych przypadków. Kod jest zoptymalizowany pod kątem użyteczności i klarowność, Nie dla wydajności.

public extension UIImage {

    var pixelWidth: Int {
        return cgImage?.width ?? 0
    }

    var pixelHeight: Int {
        return cgImage?.height ?? 0
    }

    func pixelColor(x: Int, y: Int) -> UIColor {
        assert(
            0..<pixelWidth ~= x && 0..<pixelHeight ~= y,
            "Pixel coordinates are out of bounds")

        guard
            let cgImage = cgImage,
            let data = cgImage.dataProvider?.data,
            let dataPtr = CFDataGetBytePtr(data),
            let colorSpaceModel = cgImage.colorSpace?.model,
            let componentLayout = cgImage.bitmapInfo.componentLayout
        else {
            assertionFailure("Could not get a pixel of an image")
            return .clear
        }

        assert(
            colorSpaceModel == .rgb,
            "The only supported color space model is RGB")
        assert(
            cgImage.bitsPerPixel == 32 || cgImage.bitsPerPixel == 24,
            "A pixel is expected to be either 4 or 3 bytes in size")

        let bytesPerRow = cgImage.bytesPerRow
        let bytesPerPixel = cgImage.bitsPerPixel/8
        let pixelOffset = y*bytesPerRow + x*bytesPerPixel

        if componentLayout.count == 4 {
            let components = (
                dataPtr[pixelOffset + 0],
                dataPtr[pixelOffset + 1],
                dataPtr[pixelOffset + 2],
                dataPtr[pixelOffset + 3]
            )

            var alpha: UInt8 = 0
            var red: UInt8 = 0
            var green: UInt8 = 0
            var blue: UInt8 = 0

            switch componentLayout {
            case .bgra:
                alpha = components.3
                red = components.2
                green = components.1
                blue = components.0
            case .abgr:
                alpha = components.0
                red = components.3
                green = components.2
                blue = components.1
            case .argb:
                alpha = components.0
                red = components.1
                green = components.2
                blue = components.3
            case .rgba:
                alpha = components.3
                red = components.0
                green = components.1
                blue = components.2
            default:
                return .clear
            }

            // If chroma components are premultiplied by alpha and the alpha is `0`,
            // keep the chroma components to their current values.
            if cgImage.bitmapInfo.chromaIsPremultipliedByAlpha && alpha != 0 {
                let invUnitAlpha = 255/CGFloat(alpha)
                red = UInt8((CGFloat(red)*invUnitAlpha).rounded())
                green = UInt8((CGFloat(green)*invUnitAlpha).rounded())
                blue = UInt8((CGFloat(blue)*invUnitAlpha).rounded())
            }

            return .init(red: red, green: green, blue: blue, alpha: alpha)

        } else if componentLayout.count == 3 {
            let components = (
                dataPtr[pixelOffset + 0],
                dataPtr[pixelOffset + 1],
                dataPtr[pixelOffset + 2]
            )

            var red: UInt8 = 0
            var green: UInt8 = 0
            var blue: UInt8 = 0

            switch componentLayout {
            case .bgr:
                red = components.2
                green = components.1
                blue = components.0
            case .rgb:
                red = components.0
                green = components.1
                blue = components.2
            default:
                return .clear
            }

            return .init(red: red, green: green, blue: blue, alpha: UInt8(255))

        } else {
            assertionFailure("Unsupported number of pixel components")
            return .clear
        }
    }

}

public extension UIColor {

    convenience init(red: UInt8, green: UInt8, blue: UInt8, alpha: UInt8) {
        self.init(
            red: CGFloat(red)/255,
            green: CGFloat(green)/255,
            blue: CGFloat(blue)/255,
            alpha: CGFloat(alpha)/255)
    }

}

public extension CGBitmapInfo {

    enum ComponentLayout {

        case bgra
        case abgr
        case argb
        case rgba
        case bgr
        case rgb

        var count: Int {
            switch self {
            case .bgr, .rgb: return 3
            default: return 4
            }
        }

    }

    var componentLayout: ComponentLayout? {
        guard let alphaInfo = CGImageAlphaInfo(rawValue: rawValue & Self.alphaInfoMask.rawValue) else { return nil }
        let isLittleEndian = contains(.byteOrder32Little)

        if alphaInfo == .none {
            return isLittleEndian ? .bgr : .rgb
        }
        let alphaIsFirst = alphaInfo == .premultipliedFirst || alphaInfo == .first || alphaInfo == .noneSkipFirst

        if isLittleEndian {
            return alphaIsFirst ? .bgra : .abgr
        } else {
            return alphaIsFirst ? .argb : .rgba
        }
    }

    var chromaIsPremultipliedByAlpha: Bool {
        let alphaInfo = CGImageAlphaInfo(rawValue: rawValue & Self.alphaInfoMask.rawValue)
        return alphaInfo == .premultipliedFirst || alphaInfo == .premultipliedLast
    }

}

Bazując na różnych odpowiedziach, ale głównie na to , to działa na to, czego potrzebuję:

UIImage *image1 = ...; // The image from where you want a pixel data
int pixelX = ...; // The X coordinate of the pixel you want to retrieve
int pixelY = ...; // The Y coordinate of the pixel you want to retrieve

uint32_t pixel1; // Where the pixel data is to be stored
CGContextRef context1 = CGBitmapContextCreate(&pixel1, 1, 1, 8, 4, CGColorSpaceCreateDeviceRGB(), kCGImageAlphaNoneSkipFirst);
CGContextDrawImage(context1, CGRectMake(-pixelX, -pixelY, CGImageGetWidth(image1.CGImage), CGImageGetHeight(image1.CGImage)), image1.CGImage);
CGContextRelease(context1);

W wyniku tych linii będziesz miał piksel w formacie aarrggbb z alfą zawsze ustawioną na FF W 4-bajtowej niepodpisanej liczbie całkowitej pixel1.

Aby uzyskać dostęp do surowych wartości RGB interfejsu UIImage w systemie Swift 5, użyj bazowego CGImage i jego dataProvider:

import UIKit

let image = UIImage(named: "example.png")!

guard let cgImage = image.cgImage,
    let data = cgImage.dataProvider?.data,
    let bytes = CFDataGetBytePtr(data) else {
    fatalError("Couldn't access image data")
}
assert(cgImage.colorSpace?.model == .rgb)

let bytesPerPixel = cgImage.bitsPerPixel / cgImage.bitsPerComponent
for y in 0 ..< cgImage.height {
    for x in 0 ..< cgImage.width {
        let offset = (y * cgImage.bytesPerRow) + (x * bytesPerPixel)
        let components = (r: bytes[offset], g: bytes[offset + 1], b: bytes[offset + 2])
        print("[x:\(x), y:\(y)] \(components)")
    }
    print("---")
}

Https://www.ralfebert.de/ios/examples/image-processing/uiimage-raw-pixels/