PFFile হিসাবে পার্সে আপলোড করার আগে কোনও চিত্রের আকার হ্রাস করার সংকোচন কীভাবে করবেন? (সুইফ্ট)

Question 1

আমি সরাসরি ফোনে ছবি তোলার পরে পার্সিতে একটি চিত্র ফাইল আপলোড করার চেষ্টা করছিলাম। তবে এটি একটি ব্যতিক্রম ছোঁড়ে:

'এনএসআইএনওডিয়ালআরগমেন্ট এক্সেক্সেশন' ব্যতীত ব্যতিরেকে অ্যাপ্লিকেশনটি সমাপ্ত করা হচ্ছে, কারণ: 'পিএফফায়াল 10485760 বাইটের চেয়ে বড় হতে পারে না'

আমার কোডটি এখানে:

প্রথম দর্শনে নিয়ন্ত্রক:

override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
    if (segue.identifier == "getImage")
    {
        var svc = segue.destinationViewController as! ClothesDetail
        svc.imagePassed = imageView.image
    }
}

চিত্রটি আপলোড করে এমন নিয়ামক দেখুন:

let imageData = UIImagePNGRepresentation(imagePassed)
let imageFile = PFFile(name: "\(picName).png", data: imageData)

var userpic = PFObject(className:"UserPic")
userpic["picImage"] = imageFile`

তবে এখনও আমার সেই ছবিটি পার্সে আপলোড করতে হবে। ছবির আকার বা রেজোলিউশন হ্রাস করার কোনও উপায় আছে কি?

Question 2

হ্যাঁ আপনি UIImageJPEGRepresentationপরিবর্তে ব্যবহার করতে পারেনUIImagePNGRepresentation আপনার চিত্রের ফাইলের আকার হ্রাস করার । আপনি কেবল অনুসরণ হিসাবে একটি এক্সটেনশন ইউআইআইমেজ তৈরি করতে পারেন:

এক্সকোড 8.2 • সুইফ্ট 3.0.2

extension UIImage {
    enum JPEGQuality: CGFloat {
        case lowest  = 0
        case low     = 0.25
        case medium  = 0.5
        case high    = 0.75
        case highest = 1
    }

    /// Returns the data for the specified image in JPEG format.
    /// If the image object’s underlying image data has been purged, calling this function forces that data to be reloaded into memory.
    /// - returns: A data object containing the JPEG data, or nil if there was a problem generating the data. This function may return nil if the image has no data or if the underlying CGImageRef contains data in an unsupported bitmap format.
    func jpeg(_ quality: JPEGQuality) -> Data? {
        return UIImageJPEGRepresentation(self, quality.rawValue)
    }
}

সম্পাদনা / আপডেট:

এক্সকোড 10 সুইফট 4.2

extension UIImage {
    enum JPEGQuality: CGFloat {
        case lowest  = 0
        case low     = 0.25
        case medium  = 0.5
        case high    = 0.75
        case highest = 1
    }

    /// Returns the data for the specified image in JPEG format.
    /// If the image object’s underlying image data has been purged, calling this function forces that data to be reloaded into memory.
    /// - returns: A data object containing the JPEG data, or nil if there was a problem generating the data. This function may return nil if the image has no data or if the underlying CGImageRef contains data in an unsupported bitmap format.
    func jpeg(_ jpegQuality: JPEGQuality) -> Data? {
        return jpegData(compressionQuality: jpegQuality.rawValue)
    }
}

ব্যবহার:

if let imageData = image.jpeg(.lowest) {
    print(imageData.count)
}

Question 3

আপনি যদি আকারের কিছু কংক্রিট মান সীমাবদ্ধ করতে চান তবে আপনি নিম্নলিখিত হিসাবে করতে পারেন:

import UIKit

extension UIImage {
    // MARK: - UIImage+Resize
    func compressTo(_ expectedSizeInMb:Int) -> UIImage? {
        let sizeInBytes = expectedSizeInMb * 1024 * 1024
        var needCompress:Bool = true
        var imgData:Data?
        var compressingValue:CGFloat = 1.0
        while (needCompress && compressingValue > 0.0) {
        if let data:Data = UIImageJPEGRepresentation(self, compressingValue) {
            if data.count < sizeInBytes {
                needCompress = false
                imgData = data
            } else {
                compressingValue -= 0.1
            }
        }
    }

    if let data = imgData {
        if (data.count < sizeInBytes) {
            return UIImage(data: data)
        }
    }
        return nil
    } 
}

Question 4

  //image compression
func resizeImage(image: UIImage) -> UIImage {
    var actualHeight: Float = Float(image.size.height)
    var actualWidth: Float = Float(image.size.width)
    let maxHeight: Float = 300.0
    let maxWidth: Float = 400.0
    var imgRatio: Float = actualWidth / actualHeight
    let maxRatio: Float = maxWidth / maxHeight
    let compressionQuality: Float = 0.5
    //50 percent compression

    if actualHeight > maxHeight || actualWidth > maxWidth {
        if imgRatio < maxRatio {
            //adjust width according to maxHeight
            imgRatio = maxHeight / actualHeight
            actualWidth = imgRatio * actualWidth
            actualHeight = maxHeight
        }
        else if imgRatio > maxRatio {
            //adjust height according to maxWidth
            imgRatio = maxWidth / actualWidth
            actualHeight = imgRatio * actualHeight
            actualWidth = maxWidth
        }
        else {
            actualHeight = maxHeight
            actualWidth = maxWidth
        }
    }

    let rect = CGRectMake(0.0, 0.0, CGFloat(actualWidth), CGFloat(actualHeight))
    UIGraphicsBeginImageContext(rect.size)
    image.drawInRect(rect)
    let img = UIGraphicsGetImageFromCurrentImageContext()
    let imageData = UIImageJPEGRepresentation(img!,CGFloat(compressionQuality))
    UIGraphicsEndImageContext()
    return UIImage(data: imageData!)!
}

Question 5

এক্সকোড 7 এর জন্য জাস ফিক্সিং, 09/21/2015 এ পরীক্ষা করা হয়েছে এবং ঠিকঠাক কাজ করছে:

কেবল UIImageঅনুসরণ হিসাবে একটি এক্সটেনশন তৈরি করুন:

extension UIImage
{
    var highestQualityJPEGNSData: NSData { return UIImageJPEGRepresentation(self, 1.0)! }
    var highQualityJPEGNSData: NSData    { return UIImageJPEGRepresentation(self, 0.75)!}
    var mediumQualityJPEGNSData: NSData  { return UIImageJPEGRepresentation(self, 0.5)! }
    var lowQualityJPEGNSData: NSData     { return UIImageJPEGRepresentation(self, 0.25)!}
    var lowestQualityJPEGNSData: NSData  { return UIImageJPEGRepresentation(self, 0.0)! }
}

তারপরে আপনি এটি ব্যবহার করতে পারেন:

let imageData = imagePassed.lowestQualityJPEGNSData

Question 6

চিত্রটি সংকোচনের জন্য সুইফ্ট 4 বাইনারি পদ্ধতির

আমি বিশ্বাস করি যে এই প্রশ্নের উত্তর দিতে দেরি হয়ে গেছে তবে এখানে আমার প্রশ্নের সমাধান যা অনুকূলিত হয় আমি অনুকূল মান সন্ধান করতে বাইনারি অনুসন্ধান ব্যবহার করছি । সুতরাং, উদাহরণস্বরূপ, 62% পৌঁছানোর জন্য স্বাভাবিক বিয়োগ পদ্ধতির মাধ্যমে বলুন 38 টি সংকোচনের প্রচেষ্টা দরকার, * বাইনারি অনুসন্ধান ** পদ্ধতির সর্বাধিক লগ (100) = প্রায় 7 টি প্রচেষ্টাতে প্রয়োজনীয় সমাধানে পৌঁছানো হবে।

তবে আপনাকে এটিও জানাতে চাই যে UIImageJPEGRepresentationফাংশনটি লৈঙ্গিকভাবে আচরণ করে না বিশেষত যখন সংখ্যা 1 এর কাছাকাছি পৌঁছে যায় তবে এখানে স্ক্রিন গ্র্যাব রয়েছে যেখানে আমরা দেখতে পাই যে ফ্লোট মান> 0.995 হওয়ার পরে চিত্রটি সংকোচ করা বন্ধ করে দেয়। এমন একটি ব-দ্বীপ বাফার করা যেমন আচরণগুলি পরিচালনা করতে পারে তেমন আচরণটি এতটাই অনাকাঙ্ক্ষিত।

এটির জন্য কোডটি এখানে

extension UIImage {
    func resizeToApprox(sizeInMB: Double, deltaInMB: Double = 0.2) -> Data {
        let allowedSizeInBytes = Int(sizeInMB * 1024 * 1024)
        let deltaInBytes = Int(deltaInMB * 1024 * 1024)
        let fullResImage = UIImageJPEGRepresentation(self, 1.0)
        if (fullResImage?.count)! < Int(deltaInBytes + allowedSizeInBytes) {
            return fullResImage!
        }

        var i = 0

        var left:CGFloat = 0.0, right: CGFloat = 1.0
        var mid = (left + right) / 2.0
        var newResImage = UIImageJPEGRepresentation(self, mid)

        while (true) {
            i += 1
            if (i > 13) {
                print("Compression ran too many times ") // ideally max should be 7 times as  log(base 2) 100 = 6.6
                break
            }


            print("mid = \(mid)")

            if ((newResImage?.count)! < (allowedSizeInBytes - deltaInBytes)) {
                left = mid
            } else if ((newResImage?.count)! > (allowedSizeInBytes + deltaInBytes)) {
                right = mid
            } else {
                print("loop ran \(i) times")
                return newResImage!
            }
             mid = (left + right) / 2.0
            newResImage = UIImageJPEGRepresentation(self, mid)

        }

        return UIImageJPEGRepresentation(self, 0.5)!
    }
}

Question 7

এটি UIImageএক্সটেনশন সহ খুব সহজ

extension UIImage {

func resizeByByte(maxByte: Int, completion: @escaping (Data) -> Void) {
    var compressQuality: CGFloat = 1
    var imageData = Data()
    var imageByte = UIImageJPEGRepresentation(self, 1)?.count

    while imageByte! > maxByte {
        imageData = UIImageJPEGRepresentation(self, compressQuality)!
        imageByte = UIImageJPEGRepresentation(self, compressQuality)?.count
        compressQuality -= 0.1
    }

    if maxByte > imageByte! {
        completion(imageData)
    } else {
        completion(UIImageJPEGRepresentation(self, 1)!)
    }
}

ব্যবহার করা

// max 300kb
image.resizeByByte(maxByte: 300000) { (resizedData) in
    print("image size: \(resizedData.count)")
}

Question 8

সুইফট 4.2 আপডেট । আমি এই এক্সটেনশনটি ইউআইআইমেজ আকার কমাতে তৈরি করেছি।
এখানে আপনার দুটি পদ্ধতি রয়েছে, প্রথমটি শতাংশ গ্রহণ করে এবং দ্বিতীয়টি চিত্রটি 1MB তে হ্রাস করে।
অবশ্যই আপনি দ্বিতীয় পদ্ধতিটি 1KB বা যে কোনও আকারের আকারে পরিণত করতে পারেন।

import UIKit

extension UIImage {

    func resized(withPercentage percentage: CGFloat) -> UIImage? {
        let canvasSize = CGSize(width: size.width * percentage, height: size.height * percentage)
        UIGraphicsBeginImageContextWithOptions(canvasSize, false, scale)
        defer { UIGraphicsEndImageContext() }
        draw(in: CGRect(origin: .zero, size: canvasSize))
        return UIGraphicsGetImageFromCurrentImageContext()
    }

    func resizedTo1MB() -> UIImage? {
        guard let imageData = self.pngData() else { return nil }
        let megaByte = 1000.0

        var resizingImage = self
        var imageSizeKB = Double(imageData.count) / megaByte // ! Or devide for 1024 if you need KB but not kB

        while imageSizeKB > megaByte { // ! Or use 1024 if you need KB but not kB
            guard let resizedImage = resizingImage.resized(withPercentage: 0.5),
            let imageData = resizedImage.pngData() else { return nil }

            resizingImage = resizedImage
            imageSizeKB = Double(imageData.count) / megaByte // ! Or devide for 1024 if you need KB but not kB
        }

        return resizingImage
    }
}

Question 9

@ থিয়াগো অ্যারেগুয়ে উত্তর হিসাবে সুইফট 5-এ

extension UIImage {

    var highestQualityJPEGNSData: Data { return self.jpegData(compressionQuality: 1.0)! }
    var highQualityJPEGNSData: Data    { return self.jpegData(compressionQuality: 0.75)!}
    var mediumQualityJPEGNSData: Data  { return self.jpegData(compressionQuality: 0.5)! }
    var lowQualityJPEGNSData: Data     { return self.jpegData(compressionQuality: 0.25)!}
    var lowestQualityJPEGNSData: Data  { return self.jpegData(compressionQuality: 0.0)! }

}

এবং আপনি এটি কল করতে পারেন:

let imageData = imagePassed.lowestQualityJPEGNSData

Question 10

সুইফটে

func ResizeImageFromOriginalSize(targetSize: CGSize) -> UIImage {
        var actualHeight: Float = Float(self.size.height)
        var actualWidth: Float = Float(self.size.width)
        let maxHeight: Float = Float(targetSize.height)
        let maxWidth: Float = Float(targetSize.width)
        var imgRatio: Float = actualWidth / actualHeight
        let maxRatio: Float = maxWidth / maxHeight
        var compressionQuality: Float = 0.5
        //50 percent compression

        if actualHeight > maxHeight || actualWidth > maxWidth {
            if imgRatio < maxRatio {
                //adjust width according to maxHeight
                imgRatio = maxHeight / actualHeight
                actualWidth = imgRatio * actualWidth
                actualHeight = maxHeight
            }
            else if imgRatio > maxRatio {
                //adjust height according to maxWidth
                imgRatio = maxWidth / actualWidth
                actualHeight = imgRatio * actualHeight
                actualWidth = maxWidth
            }
            else {
                actualHeight = maxHeight
                actualWidth = maxWidth
                compressionQuality = 1.0
            }
        }
        let rect = CGRect(x: 0.0, y: 0.0, width: CGFloat(actualWidth), height: CGFloat(actualHeight))
        UIGraphicsBeginImageContextWithOptions(rect.size, false, CGFloat(compressionQuality))
        self.draw(in: rect)
        let newImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        return newImage!
    }

Question 11

func jpegData(compressionQuality: CGFloat) -> Data?আপনার যদি একটি নির্দিষ্ট আকারের সংকোচনের প্রয়োজন না হয় তবে ব্যবহার করা ভাল কাজ করে । যাইহোক, নির্দিষ্ট চিত্রগুলির জন্য, আমি একটি নির্দিষ্ট ফাইলের আকারের নীচে সংক্ষেপে সক্ষম হতে সুবিধাজনক বলে মনে করি। সেক্ষেত্রে, jpegDataঅবিশ্বস্ত, এবং পুনরাবৃত্ত FILESIZE আউট plateauing একটি চিত্র ফলাফল সংকুচিত (এবং সত্যিই ব্যয়বহুল হতে পারে)। পরিবর্তে, আমি নিজেই ইউআইআইজেজের আকার হ্রাস করতে পছন্দ করি, তারপরে জেপিগডাটাতে রূপান্তর করব এবং আমি যে মানটি বেছে নিয়েছি তার নীচে হ্রাস করা আকারটি রয়েছে কিনা তা পরীক্ষা করে দেখুন (আমি যে ত্রুটিটির একটি নির্দিষ্ট প্রান্ত সেট করেছি)। আমি সবচেয়ে ব্যয়বহুল যা প্রথম পুনরাবৃত্তি গতি বাড়ানোর জন্য পছন্দসই ফাইল আকারের অনুপাতের ভিত্তিতে সংক্ষেপণ পদক্ষেপের গুণককে সামঞ্জস্য করি।

সুইফট 5

extension UIImage {
    func resized(withPercentage percentage: CGFloat, isOpaque: Bool = true) -> UIImage? {
        let canvas = CGSize(width: size.width * percentage, height: size.height * percentage)
        let format = imageRendererFormat
        format.opaque = isOpaque
        return UIGraphicsImageRenderer(size: canvas, format: format).image {
            _ in draw(in: CGRect(origin: .zero, size: canvas))
        }
    }

    func compress(to kb: Int, allowedMargin: CGFloat = 0.2) -> Data {
        let bytes = kb * 1024
        var compression: CGFloat = 1.0
        let step: CGFloat = 0.05
        var holderImage = self
        var complete = false
        while(!complete) {
            if let data = holderImage.jpegData(compressionQuality: 1.0) {
                let ratio = data.count / bytes
                if data.count < Int(CGFloat(bytes) * (1 + allowedMargin)) {
                    complete = true
                    return data
                } else {
                    let multiplier:CGFloat = CGFloat((ratio / 5) + 1)
                    compression -= (step * multiplier)
                }
            }
            
            guard let newImage = holderImage.resized(withPercentage: compression) else { break }
            holderImage = newImage
        }
        return Data()
    }
}

এবং ব্যবহার:

let data = image.compress(to: 300)

ইউআইআইমেজ resizedএক্সটেনশানটি এসেছে: আপলোড চিত্রের আকার হ্রাস করতে আমি কীভাবে ইউআইআইমেজকে পুনরায় আকার দেব

Question 12

সুইফট 3

@ লিও-ডাবসের উত্তরটি সুইফ্ট 3-এর জন্য সংশোধিত হয়েছে

    extension UIImage {
    var uncompressedPNGData: Data?      { return UIImagePNGRepresentation(self)        }
    var highestQualityJPEGNSData: Data? { return UIImageJPEGRepresentation(self, 1.0)  }
    var highQualityJPEGNSData: Data?    { return UIImageJPEGRepresentation(self, 0.75) }
    var mediumQualityJPEGNSData: Data?  { return UIImageJPEGRepresentation(self, 0.5)  }
    var lowQualityJPEGNSData: Data?     { return UIImageJPEGRepresentation(self, 0.25) }
    var lowestQualityJPEGNSData:Data?   { return UIImageJPEGRepresentation(self, 0.0)  }
}

Question 13

সুইফ্ট 4-এ আমি এই এক্সটেনশনটি তৈরি করেছি যা প্রত্যাশিত আকারটি এটি পৌঁছানোর চেষ্টা করবে।

extension UIImage {

    enum CompressImageErrors: Error {
        case invalidExSize
        case sizeImpossibleToReach
    }
    func compressImage(_ expectedSizeKb: Int, completion : (UIImage,CGFloat) -> Void ) throws {

        let minimalCompressRate :CGFloat = 0.4 // min compressRate to be checked later

        if expectedSizeKb == 0 {
            throw CompressImageErrors.invalidExSize // if the size is equal to zero throws
        }

        let expectedSizeBytes = expectedSizeKb * 1024
        let imageToBeHandled: UIImage = self
        var actualHeight : CGFloat = self.size.height
        var actualWidth : CGFloat = self.size.width
        var maxHeight : CGFloat = 841 //A4 default size I'm thinking about a document
        var maxWidth : CGFloat = 594
        var imgRatio : CGFloat = actualWidth/actualHeight
        let maxRatio : CGFloat = maxWidth/maxHeight
        var compressionQuality : CGFloat = 1
        var imageData:Data = UIImageJPEGRepresentation(imageToBeHandled, compressionQuality)!
        while imageData.count > expectedSizeBytes {

            if (actualHeight > maxHeight || actualWidth > maxWidth){
                if(imgRatio < maxRatio){
                    imgRatio = maxHeight / actualHeight;
                    actualWidth = imgRatio * actualWidth;
                    actualHeight = maxHeight;
                }
                else if(imgRatio > maxRatio){
                    imgRatio = maxWidth / actualWidth;
                    actualHeight = imgRatio * actualHeight;
                    actualWidth = maxWidth;
                }
                else{
                    actualHeight = maxHeight;
                    actualWidth = maxWidth;
                    compressionQuality = 1;
                }
            }
            let rect = CGRect(x: 0.0, y: 0.0, width: actualWidth, height: actualHeight)
            UIGraphicsBeginImageContext(rect.size);
            imageToBeHandled.draw(in: rect)
            let img = UIGraphicsGetImageFromCurrentImageContext();
            UIGraphicsEndImageContext();
                if let imgData = UIImageJPEGRepresentation(img!, compressionQuality) {
                if imgData.count > expectedSizeBytes {
                    if compressionQuality > minimalCompressRate {
                        compressionQuality -= 0.1
                    } else {
                        maxHeight = maxHeight * 0.9
                        maxWidth = maxWidth * 0.9
                    }
                }
                imageData = imgData
            }


        }

        completion(UIImage(data: imageData)!, compressionQuality)
    }


}

ব্যবহার করা

        do {
            try UiImageView.image?.compressImage(100, completion: { (image, compressRatio) in
                print(image.size) 
                imageData = UIImageJPEGRepresentation(image, compressRatio)
                base64data = imageData?.base64EncodedString()

            })
        } catch {
                 print("Error")
        }