Get Bild-Dateityp programmgesteuert in swift

Question

Ich lade Bilder aus Parsen mit Datei-Totes PNG und JPEG.

Wenn Bild in die App heruntergeladen wird, muss ich bestimmen, was der Dateityp ist, damit ich Bild entsprechend behandeln kann.

Hatte einen Blick auf API für uiimageview und hat eine Suche, aber kann keine Lösung in swift finden.

Jede Eingabe geschätzt

Versuch url von PFFIle § zu bekommen:

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

Update für Swift 3.0.2

Basierend auf Hoa Antwort und 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 
     } 
    } 
} 

Nutzungs

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

diese Weise können Sie mit lokalen und Online-Bilder.

Answer 2

Sie haben das erste Byte des Bildes binär zu erhalten. Dieses Byte gibt an, um welche Art von Bildtyp es sich handelt. Hier ist der Code, den ich für mein Projekt verwendet habe, aber in 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"); 
     } 

mit diesem Versuchen in schnellen (1.2, sonst müssen Sie var ext verwenden):

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

Ich wollte zu wissen, welche Erweiterung mein Bild ist, nachdem ich es ausgewählt habe. Ich habe diese:

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

Warum nicht einfach die folgenden:

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

Dies gibt Ihnen die Erweiterung der Datei.

Answer 5

können Sie testen in Projekt https://github.com/bonyadmitr/ImageFormat

Add

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)" 
    } 
} 

Mit

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