comment charger une image à partir d'un chemin local ios swift (par voie)

Dossier /B2A1EE50- ... change à chaque fois que vous exécutez l'application.

../Application/B2A1EE50-D800-4BB0-B475-6C7F210C913C/Documents/..

Qui fonctionne pour moi est de stocker le nom de fichier et obtenir les documents du dossier.

Swift 3 +

Créer des accesseurs pour le dossier

var documentsUrl: URL {
    return FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
}

Enregistrer l'image :

private func save(image: UIImage) -> String? {
    let fileName = "FileName"
    let fileURL = documentsUrl.appendingPathComponent(fileName)
    if let imageData = UIImageJPEGRepresentation(image, 1.0) {
       try? imageData.write(to: fileURL, options: .atomic)
       return fileName //----> Save fileName
    }
    print("Error saving image")
    return nil
}

Chargement de l'image :

private func load(fileName: String) -> UIImage? {
    let fileURL = documentsUrl.appendingPathComponent(fileName)
    do {
        let imageData = try Data(contentsOf: fileURL)
        return UIImage(data: imageData)
    } catch {
        print("Error loading image : \(error)")
    }
    return nil
}

Ce code fonctionne pour moi

func getImageFromDir(_ imageName: String) -> UIImage? {

    if let documentsUrl = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first {
        let fileURL = documentsUrl.appendingPathComponent(imageName)
        do {
            let imageData = try Data(contentsOf: fileURL)
            return UIImage(data: imageData)
        } catch {
            print("Not able to load image")
        }
    }
    return nil
}

Cet exemple de code peut sauver quelqu'un quelques frappes,

écrire une UIImage sur le disque dans votre propre répertoire:

IM = UIImage, your image. for example, IM = someUIView.image or from the camera

let newPhotoFileName = randomNameString() + ".jpeg"
let imagePath = checkedImageDirectoryStringPath() + "/" + newPhotoFileName

let imData = UIImageJPEGRepresentation(IM, 0.20)
FileManager.default.createFile(atPath: imagePath, contents: imData, attributes: nil)

print("saved at filename \(newPhotoFileName)")

plus tard pour lire cette image ...

.. et la convertir à une UIImage comme dans une UIImageView

NAME = that filename, like jahgfdfs.jpg

let p = checkedImageDirectoryStringPath() + "/" + NAME
devCheckExists(fullPath: p)

var imageData: Data? = nil
do {
    let u = URL(fileURLWithPath: p)
    imageData = try Data(contentsOf: u)
}
catch {
    print("catastrophe loading file?? \(error)")
    return
}

//and then to "make that an image again"...

imageData != nil {

    picture.image = UIImage(data: imageData!)
    print("that seemed to work")
}
else {

    print("the imageData is nil?")
}

//or for example...

Alamofire.upload(
    multipartFormData: { (multipartFormData) in
        multipartFormData.append(imageData!,
           withName: "file", fileName: "", mimeType: "image/jpeg")
    ...

Voici les très pratique, les fonctions utilisées ci-dessus...

func checkedImageDirectoryStringPath()->String {

    //create/check OUR OWN IMAGE DIRECTORY for use of this app.

    let paths = NSSearchPathForDirectoriesInDomains(
                      .documentDirectory, .userDomainMask, true)

    if paths.count < 1 {
        print("some sort of disaster finding the our Image Directory - giving up")
        return "x"
        //any return will lead to disaster, so just do that
        //(it will then gracefully fail when you "try" to write etc)
    }

    let docDirPath: String = paths.first!
    let ourDirectoryPath = docDirPath.appending("/YourCompanyName")
    //so simply makes a directory called "YourCompanyName"
    //which will be there for all time, for your use

    var ocb: ObjCBool = true
    let exists = FileManager.default.fileExists(
                  atPath: ourDirectoryPath, isDirectory: &ocb)

    if !exists {
        do {
            try FileManager.default.createDirectory(
                    atPath: ourDirectoryPath,
                    withIntermediateDirectories: false,
                    attributes: nil)

            print("we did create our Image Directory, for the first time.")
            //never need to again
            return ourDirectoryPath
        }
        catch {
            print(error.localizedDescription)
            print("disaster trying to make our Image Directory?")
            return "x"
            //any return will lead to disaster, so just do that
        }
    }

    else {

        //already exists, as usual.
        return ourDirectoryPath
    }
}

et

func randomNameString(length: Int = 7)->String{

    enum s {
        static let c = Array("abcdefghjklmnpqrstuvwxyz12345789".characters)
        static let k = UInt32(c.count)
    }

    var result = [Character](repeating: "a", count: length)

    for i in 0..<length {
        let r = Int(arc4random_uniform(s.k))
        result[i] = s.c[r]
    }

    return String(result)
}

et

func devCheckExists(fullPath: String) {

    var ocb: ObjCBool = false
    let itExists = FileManager.default.fileExists(atPath: fullPath, isDirectory: &ocb)
    if !itExists {
        //alert developer. processes will fail at next step
        print("\n\nDOES NOT EXIST\n\(fullPath)\n\n")
    }
}

1.cellule.image.sd_setShowActivityIndicatorView(vrai)

2.cellule.image.sd_setIndicatorStyle(.gris)

3.cellule.image.image = UIImage(contentsOfFile: urlString!)