Obtenez de l'image type de fichier par programmation dans swift

Je suis le téléchargement des images à partir d'analyser avec fichier bacs PNG et JPEG.

Lorsque l'image est téléchargée sur l'app j'ai besoin de déterminer quel est le type de fichier afin que je puisse manipuler l'image en conséquence.

Eu un coup d'oeil à l'API pour uiimageview et fait une recherche mais ne trouve pas de solution rapide.

Toute entrée apprécié

Essayer d'obtenir l'url de 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";                           
}

La poisse. Après j'ai télécharger l'image que j'ai enregistrer l'image localement sur l'appareil, puis enregistrer l'URL de base de données, c'est ici j'ai besoin d'identifier si c'est un PNG ou JPG

OriginalL'auteur dancingbush | 2015-04-15

Mise à jour pour Swift 3.0.2

Basé sur Hoa réponse et Kingfisher bibliothèque

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

Utilisation

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

Vous pouvez l'utiliser à la Fois en local et en ligne des images.

OriginalL'auteur XueYu

- Vous pour obtenir le premier octet de l'image en binaire. Cet octet indiquer quel genre de type d'image. Voici le code que j'ai utilisé pour mon projet, mais en 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");
        }

Essayez avec cette swift (1.2, sinon vous devez utiliser 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
}

Merci vais essayer de convertir rapidement et ont un look
Vous pouvez trouver plus d'infos ici: stackoverflow.com/questions/4147311/...
Salut, j'ai essayé ta solution et ça a fonctionné après j'ai changé: var c = [UInt8]() var c = [UInt8](count: 1, repeatedValue: 0) La matrice a de l'espace pour au moins un octet.

OriginalL'auteur Duyen-Hoa

Je voulais savoir quelle extension est mon image de fois que je l'ai choisi. J'ai utilisé ceci:

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

OriginalL'auteur user1019042

0

Pourquoi ne pas simplement faire ce qui suit:
```
let ext = NSURL(fileURLWithPath: path/of/your/file as! String).pathExtension
print(ext!)
```
Cela vous donnera l'extension du fichier.

OriginalL'auteur Christopher Smit

Vous pouvez tester en projet https://github.com/bonyadmitr/ImageFormat

Ajouter au projet

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

À l'aide de

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

OriginalL'auteur zdaecq

@XueYu réponse m'a beaucoup aidée.
Heres une mise à jour de Données, plutôt que de NSData

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 Data {
    var imageFormat: ImageFormat {
        var buffer = [UInt8](repeating: 0, count: 1)
        copyBytes(to: &buffer, from: 0..<1)
        if buffer == ImageHeaderData.PNG { return .PNG }
        if buffer == ImageHeaderData.JPEG { return .JPEG }
        if buffer == ImageHeaderData.GIF { return .GIF }
        if buffer == ImageHeaderData.TIFF_01 || 
           buffer == ImageHeaderData.TIFF_02 {
            return .TIFF
        }
        return .Unknown
    }
}

Vous n'avez pas à vous de vérifier que le premier octet de données? L'utilisation d'un tableau d'un seul octet est inutile.

OriginalL'auteur Andrew Olson

Vous devez vous connecter pour publier un commentaire.