Tôi làm cách nào để autocrop một UIImage?

Question

Tôi có UIImage chứa hình dạng; phần còn lại là minh bạch. Tôi muốn có được một UIImage khác bằng cách cắt ra càng nhiều phần trong suốt càng tốt, vẫn giữ lại tất cả các pixel không trong suốt - tương tự như chức năng autocrop trong GIMP. Tôi sẽ đi đâu để tới đó?

Answer 1

Cách tiếp cận này có thể xâm lấn hơn một chút so với những gì bạn đang hy vọng, nhưng nó hoàn thành công việc. Những gì tôi đang làm là tạo ra một bối cảnh bitmap cho UIImage, lấy một con trỏ đến dữ liệu hình ảnh thô, sau đó chọn lọc thông qua nó tìm kiếm các điểm ảnh không trong suốt. Phương thức của tôi trả về một CGRect mà tôi sử dụng để tạo một UIImage mới.

- (CGRect)cropRectForImage:(UIImage *)image { 

CGImageRef cgImage = image.CGImage; 
CGContextRef context = [self createARGBBitmapContextFromImage:cgImage]; 
if (context == NULL) return CGRectZero; 

size_t width = CGImageGetWidth(cgImage); 
size_t height = CGImageGetHeight(cgImage); 
CGRect rect = CGRectMake(0, 0, width, height); 

CGContextDrawImage(context, rect, cgImage); 

unsigned char *data = CGBitmapContextGetData(context); 
CGContextRelease(context); 

//Filter through data and look for non-transparent pixels. 
int lowX = width; 
int lowY = height; 
int highX = 0; 
int highY = 0; 
if (data != NULL) { 
    for (int y=0; y<height; y++) { 
     for (int x=0; x<width; x++) { 
      int pixelIndex = (width * y + x) * 4 /* 4 for A, R, G, B */; 
      if (data[pixelIndex] != 0) { //Alpha value is not zero; pixel is not transparent. 
       if (x < lowX) lowX = x; 
       if (x > highX) highX = x; 
       if (y < lowY) lowY = y; 
       if (y > highY) highY = y; 
      } 
     } 
    } 
    free(data); 
} else { 
    return CGRectZero; 
} 

return CGRectMake(lowX, lowY, highX-lowX, highY-lowY); 
} 

Phương pháp để tạo ra bối cảnh Bitmap:

- (CGContextRef)createARGBBitmapContextFromImage:(CGImageRef)inImage { 

CGContextRef context = NULL; 
CGColorSpaceRef colorSpace; 
void *bitmapData; 
int bitmapByteCount; 
int bitmapBytesPerRow; 

// Get image width, height. We'll use the entire image. 
size_t width = CGImageGetWidth(inImage); 
size_t height = CGImageGetHeight(inImage); 

// Declare the number of bytes per row. Each pixel in the bitmap in this 
// example is represented by 4 bytes; 8 bits each of red, green, blue, and 
// alpha. 
bitmapBytesPerRow = (width * 4); 
bitmapByteCount = (bitmapBytesPerRow * height); 

// Use the generic RGB color space. 
colorSpace = CGColorSpaceCreateDeviceRGB(); 
if (colorSpace == NULL) return NULL; 

// Allocate memory for image data. This is the destination in memory 
// where any drawing to the bitmap context will be rendered. 
bitmapData = malloc(bitmapByteCount); 
if (bitmapData == NULL) 
{ 
    CGColorSpaceRelease(colorSpace); 
    return NULL; 
} 

// Create the bitmap context. We want pre-multiplied ARGB, 8-bits 
// per component. Regardless of what the source image format is 
// (CMYK, Grayscale, and so on) it will be converted over to the format 
// specified here by CGBitmapContextCreate. 
context = CGBitmapContextCreate (bitmapData, 
           width, 
           height, 
           8,  // bits per component 
           bitmapBytesPerRow, 
           colorSpace, 
           kCGImageAlphaPremultipliedFirst); 
if (context == NULL) free (bitmapData); 

// Make sure and release colorspace before returning 
CGColorSpaceRelease(colorSpace); 

return context; 
} 

Và cuối cùng, có UIImage cắt mới của bạn từ CGRect trả về:

CGRect newRect = [self cropRectForImage:oldImage]; 
CGImageRef imageRef = CGImageCreateWithImageInRect(oldImage.CGImage, newRect); 
UIImage *newImage = [UIImage imageWithCGImage:imageRef]; 
CGImageRelease(imageRef); 

Tôi túm lấy một chút mã mà từ this very useful article. Hy vọng nó giúp!

Answer 2

Swift Version:

extension UIImage { 
func cropRect() -> CGRect { 
    let cgImage = self.CGImage! 
    let context = createARGBBitmapContextFromImage(cgImage) 
    if context == nil { 
     return CGRectZero 
    } 

    let height = CGFloat(CGImageGetHeight(cgImage)) 
    let width = CGFloat(CGImageGetWidth(cgImage)) 

    let rect = CGRectMake(0, 0, width, height) 
    CGContextDrawImage(context, rect, cgImage) 

    let data = UnsafePointer<CUnsignedChar>(CGBitmapContextGetData(context)) 

    if data == nil { 
     return CGRectZero 
    } 

    var lowX = width 
    var lowY = height 
    var highX: CGFloat = 0 
    var highY: CGFloat = 0 

    //Filter through data and look for non-transparent pixels. 
    for (var y: CGFloat = 0 ; y < height ; y++) { 
     for (var x: CGFloat = 0; x < width ; x++) { 
      let pixelIndex = (width * y + x) * 4 /* 4 for A, R, G, B */ 

      if data[Int(pixelIndex)] != 0 { //Alpha value is not zero pixel is not transparent. 
       if (x < lowX) { 
        lowX = x 
       } 
       if (x > highX) { 
        highX = x 
       } 
       if (y < lowY) { 
        lowY = y 
       } 
       if (y > highY) { 
        highY = y 
       } 
      } 
     } 
    } 


    return CGRectMake(lowX, lowY, highX-lowX, highY-lowY) 
} 
} 

Phương pháp để tạo ra bối cảnh Bitmap:

func createARGBBitmapContextFromImage(inImage: CGImageRef) -> CGContextRef? { 

    let width = CGImageGetWidth(inImage) 
    let height = CGImageGetHeight(inImage) 

    let bitmapBytesPerRow = width * 4 
    let bitmapByteCount = bitmapBytesPerRow * height 

    let colorSpace = CGColorSpaceCreateDeviceRGB() 
    if colorSpace == nil { 
     return nil 
    } 

    let bitmapData = malloc(bitmapByteCount) 
    if bitmapData == nil { 
     return nil 
    } 

    let context = CGBitmapContextCreate (bitmapData, 
     width, 
     height, 
     8,  // bits per component 
     bitmapBytesPerRow, 
     colorSpace, 
     CGImageAlphaInfo.PremultipliedFirst.rawValue) 

    return context 
} 

Và cuối cùng, có UIImage cắt mới của bạn từ CGRect trả về:

let image = // UIImage Source 
let newRect = image.cropRect() 
if let imageRef = CGImageCreateWithImageInRect(image.CGImage!, newRect) { 
    let newImage = UIImage(CGImage: imageRef) 
    // Use this new Image 
} 

Answer 3

Swift 3 (nó không phải là một phần mở rộng UIImage, tôi cần nó trong lớp khác) nó có thể tiết kiệm thời gian cho ai đó:

class EditImage { 

static func cropRect(_ image: UIImage) -> CGRect { 
    let cgImage = image.cgImage 
    let context = createARGBBitmapContextFromImage(inImage: cgImage!) 
    if context == nil { 
     return CGRect.zero 
    } 

    let height = CGFloat(cgImage!.height) 
    let width = CGFloat(cgImage!.width) 

    let rect = CGRect(x: 0, y: 0, width: width, height: height) 
    context?.draw(cgImage!, in: rect) 

    //let data = UnsafePointer<CUnsignedChar>(CGBitmapContextGetData(context)) 
    let data = context?.data?.assumingMemoryBound(to: UInt8.self) 

    if data == nil { 
     return CGRect.zero 
    } 

    var lowX = width 
    var lowY = height 
    var highX: CGFloat = 0 
    var highY: CGFloat = 0 

    let heightInt = Int(height) 
    let widthInt = Int(width) 
    //Filter through data and look for non-transparent pixels. 
    for y in (0 ..< heightInt) { 
     let y = CGFloat(y) 
     for x in (0 ..< widthInt) { 
      let x = CGFloat(x) 
      let pixelIndex = (width * y + x) * 4 /* 4 for A, R, G, B */ 

      if data?[Int(pixelIndex)] != 0 { //Alpha value is not zero pixel is not transparent. 
       if (x < lowX) { 
        lowX = x 
       } 
       if (x > highX) { 
        highX = x 
       } 
       if (y < lowY) { 
        lowY = y 
       } 
       if (y > highY) { 
        highY = y 
       } 
      } 
     } 
    } 


    return CGRect(x: lowX, y: lowY, width: highX - lowY, height: highY - lowY) 
} 

static func createARGBBitmapContextFromImage(inImage: CGImage) -> CGContext? { 

    let width = inImage.width 
    let height = inImage.height 

    let bitmapBytesPerRow = width * 4 
    let bitmapByteCount = bitmapBytesPerRow * height 

    let colorSpace = CGColorSpaceCreateDeviceRGB() 
    if colorSpace == nil { 
     return nil 
    } 

    let bitmapData = malloc(bitmapByteCount) 
    if bitmapData == nil { 
     return nil 
    } 

    let context = CGContext (data: bitmapData, 
     width: width, 
     height: height, 
     bitsPerComponent: 8,  // bits per component 
     bytesPerRow: bitmapBytesPerRow, 
     space: colorSpace, 
    bitmapInfo: CGImageAlphaInfo.premultipliedFirst.rawValue) 

    return context 
} 
} 

Answer 4

Cải thiện từ @ câu trả lời Danny182 của, tôi cũng nói thêm trắng-không gian (bất kỳ điểm ảnh sáng hơn 0xe0e0e0) trang trí cho nhu cầu của riêng tôi.

Cách sử dụng:

let newimage = UIImage(named: "XXX")!.trim() 

---

import UIKit 

extension UIImage { 

    func trim() -> UIImage { 
     let newRect = self.cropRect 
     if let imageRef = self.cgImage!.cropping(to: newRect) { 
      return UIImage(cgImage: imageRef) 
     } 
     return self 
    } 

    var cropRect: CGRect { 
     let cgImage = self.cgImage 
     let context = createARGBBitmapContextFromImage(inImage: cgImage!) 
     if context == nil { 
      return CGRect.zero 
     } 

     let height = CGFloat(cgImage!.height) 
     let width = CGFloat(cgImage!.width) 

     let rect = CGRect(x: 0, y: 0, width: width, height: height) 
     context?.draw(cgImage!, in: rect) 

     //let data = UnsafePointer<CUnsignedChar>(CGBitmapContextGetData(context)) 
     guard let data = context?.data?.assumingMemoryBound(to: UInt8.self) else { 
      return CGRect.zero 
     } 

     var lowX = width 
     var lowY = height 
     var highX: CGFloat = 0 
     var highY: CGFloat = 0 

     let heightInt = Int(height) 
     let widthInt = Int(width) 
     //Filter through data and look for non-transparent pixels. 
     for y in (0 ..< heightInt) { 
      let y = CGFloat(y) 
      for x in (0 ..< widthInt) { 
       let x = CGFloat(x) 
       let pixelIndex = (width * y + x) * 4 /* 4 for A, R, G, B */ 

       if data[Int(pixelIndex)] == 0 { continue } // crop transparent 

       if data[Int(pixelIndex+1)] > 0xE0 && data[Int(pixelIndex+2)] > 0xE0 && data[Int(pixelIndex+3)] > 0xE0 { continue } // crop white 

       if (x < lowX) { 
        lowX = x 
       } 
       if (x > highX) { 
        highX = x 
       } 
       if (y < lowY) { 
        lowY = y 
       } 
       if (y > highY) { 
        highY = y 
       } 

      } 
     } 

     return CGRect(x: lowX, y: lowY, width: highX - lowX, height: highY - lowY) 
    } 

    func createARGBBitmapContextFromImage(inImage: CGImage) -> CGContext? { 

     let width = inImage.width 
     let height = inImage.height 

     let bitmapBytesPerRow = width * 4 
     let bitmapByteCount = bitmapBytesPerRow * height 

     let colorSpace = CGColorSpaceCreateDeviceRGB() 

     let bitmapData = malloc(bitmapByteCount) 
     if bitmapData == nil { 
      return nil 
     } 

     let context = CGContext (data: bitmapData, 
           width: width, 
           height: height, 
           bitsPerComponent: 8,  // bits per component 
      bytesPerRow: bitmapBytesPerRow, 
      space: colorSpace, 
      bitmapInfo: CGImageAlphaInfo.premultipliedFirst.rawValue) 

     return context 
    } 
} 

Answer 5

Swift 4

extension UIImage { 

func cropAlpha() -> UIImage { 

    let cgImage = self.cgImage!; 

    let width = cgImage.width 
    let height = cgImage.height 

    let colorSpace = CGColorSpaceCreateDeviceRGB() 
    let bytesPerPixel:Int = 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 self 
    } 

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

    var minX = width 
    var minY = height 
    var maxX: Int = 0 
    var maxY: Int = 0 

    for x in 1 ..< width { 
     for y in 1 ..< height { 

      let i = bytesPerRow * Int(y) + bytesPerPixel * Int(x) 
      let a = CGFloat(ptr[i + 3])/255.0 

      if(a>0) { 
       if (x < minX) { minX = x }; 
       if (x > maxX) { maxX = x }; 
       if (y < minY) { minY = y}; 
       if (y > maxY) { maxY = y}; 
      } 
     } 
    } 

    let rect = CGRect(x: CGFloat(minX),y: CGFloat(minY), width: CGFloat(maxX-minX), height: CGFloat(maxY-minY)) 
    let imageScale:CGFloat = self.scale 
    let croppedImage = self.cgImage!.cropping(to: rect)! 
    let ret = UIImage(cgImage: croppedImage, scale: imageScale, orientation: self.imageOrientation) 

    return ret; 
} 

}