Pobierz typ pliku obrazu programowo w trybie szybkiego pobierania

Question

Pobierane są obrazy z analizy z plikami PNG i JPEG.

Po pobraniu obrazu do aplikacji muszę określić typ pliku, aby odpowiednio obsłużyć obraz.

Przyjrzeliśmy się interfejsowi API dla uiimageview i przeszukaliśmy go, ale nie znaleźliśmy żadnego rozwiązania w szybkim tempie.

Wszelkie dane wejściowe doceniane

Próbuje URL z PFFIle §:

let imageURLFromParse = NSURL(string : caseImageFile2.url); 

// Error here: 'NSURL?' does not have a member named 'pathExtension'     
if(imageURLFromParse.pathExtension!.lowercaseString == ".jpg" || imageURLFromParse.pathExtension.lowercaseString == ".jpeg"){ 

    println("Parse image ext is a jpg: \(imageURLFromParse.pathExtension.lowercaseString)"); 

    fileExtenion = ".jpg"; 

} else {       
    println("Parse image is a png: \(imageURLFromParse.pathExtension.lowercaseString)"); 

    fileExtenion = ".png";       
} 

Answer 1

Aktualizacja dla Swift 3.0.2

oparciu o odpowiedź Hoa i Kingfisher library

import UIKit 
import ImageIO 

struct ImageHeaderData{ 
    static var PNG: [UInt8] = [0x89] 
    static var JPEG: [UInt8] = [0xFF] 
    static var GIF: [UInt8] = [0x47] 
    static var TIFF_01: [UInt8] = [0x49] 
    static var TIFF_02: [UInt8] = [0x4D] 
} 

enum ImageFormat{ 
    case Unknown, PNG, JPEG, GIF, TIFF 
} 


extension NSData{ 
    var imageFormat: ImageFormat{ 
     var buffer = [UInt8](repeating: 0, count: 1) 
     self.getBytes(&buffer, range: NSRange(location: 0,length: 1)) 
     if buffer == ImageHeaderData.PNG 
     { 
      return .PNG 
     } else if buffer == ImageHeaderData.JPEG 
     { 
      return .JPEG 
     } else if buffer == ImageHeaderData.GIF 
     { 
      return .GIF 
     } else if buffer == ImageHeaderData.TIFF_01 || buffer == ImageHeaderData.TIFF_02{ 
      return .TIFF 
     } else{ 
      return .Unknown 
     } 
    } 
} 

Wykorzystanie

let imageURLFromParse = NSURL(string : "https://i.stack.imgur.com/R64uj.jpg") 
let imageData = NSData(contentsOf: imageURLFromParse! as URL) 
print(imageData!.imageFormat) 

Można to wykorzystać z lokalnych i obrazy online.

Answer 2

Musisz zdobyć pierwszy bajt obrazu w formacie binarnym. Ten bajt wskazuje rodzaj obrazu. Oto kod, który użyłem do mojego projektu, ale w Objective-C:

uint8_t c; 
     [_receivedData getBytes:&c length:1]; 

     NSString *extension = @"jpg"; 

     switch (c) { 
      case 0xFF: 
      { 
       extension = @"jpg"; 
      } 
      case 0x89: 
      { 
       extension = @"png"; 
      } 
       break; 
      case 0x47: 
      { 
       extension = @"gif"; 
      } 
       break; 
      case 0x49: 
      case 0x4D: 
      { 
       extension = @"tiff"; 
      } 
       break; 
      default: 
       FLog(@"unknown image type"); 
     } 

Spróbuj z tym w szybki (1.2, w przeciwnym wypadku trzeba użyć var ext):

func imageType(imgData : NSData) -> String 
{ 
    var c = [UInt8](count: 1, repeatedValue: 0) 
    imgData.getBytes(&c, length: 1) 

    let ext : String 

    switch (c[0]) { 
    case 0xFF: 

     ext = "jpg" 

    case 0x89: 

     ext = "png" 
    case 0x47: 

     ext = "gif" 
    case 0x49, 0x4D : 
     ext = "tiff" 
    default: 
     ext = "" //unknown 
    } 

    return ext 
} 

Answer 3

chciałem aby wiedzieć, jakie rozszerzenie jest moim obrazem po tym, jak go wybrałem. Ja korzystałem z tego:

func imagePickerController(picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [String : AnyObject]) { 
    if (!(picker.sourceType == UIImagePickerControllerSourceType.Camera)) { 
    let assetPath = info[UIImagePickerControllerReferenceURL] as! NSURL 
    if assetPath.absoluteString.hasSuffix("JPG") { 

Answer 4

Dlaczego nie po prostu wykonaj następujące czynności:

let ext = NSURL(fileURLWithPath: path/of/your/file as! String).pathExtension 
print(ext!) 

To daje rozszerzenie pliku.

Answer 5

można przetestować w ramach projektu https://github.com/bonyadmitr/ImageFormat

Dodaj do projektu

import Foundation 

/// can be done "heic", "heix", "hevc", "hevx" 
enum ImageFormat: String { 
    case png, jpg, gif, tiff, webp, heic, unknown 
} 

extension ImageFormat { 
    static func get(from data: Data) -> ImageFormat { 
     switch data[0] { 
     case 0x89: 
      return .png 
     case 0xFF: 
      return .jpg 
     case 0x47: 
      return .gif 
     case 0x49, 0x4D: 
      return .tiff 
     case 0x52 where data.count >= 12: 
      let subdata = data[0...11] 

      if let dataString = String(data: subdata, encoding: .ascii), 
       dataString.hasPrefix("RIFF"), 
       dataString.hasSuffix("WEBP") 
      {  
       return .webp 
      } 

     case 0x00 where data.count >= 12 : 
      let subdata = data[8...11] 

      if let dataString = String(data: subdata, encoding: .ascii), 
       Set(["heic", "heix", "hevc", "hevx"]).contains(dataString) 
       ///OLD: "ftypheic", "ftypheix", "ftyphevc", "ftyphevx" 
      {  
       return .heic 
      } 
     default: 
      break 
     } 
     return .unknown 
    } 

    var contentType: String { 
     return "image/\(rawValue)" 
    } 
} 

Korzystanie

for file in ["1.jpg", "2.png", "3.gif", "4.svg", "5.TIF", "6.webp", "7.HEIC"] { 
    if let data = Data(bundleFileName: file) { 
     print(file, ImageFormat.get(from: data)) 
    } 
} 

/// Result 
/// 1.jpg jpg 
/// 2.png png 
/// 3.gif gif 
/// 4.svg unknown 
/// 5.TIF tiff 
/// 6.webp webp 
/// 7.HEIC heic