Как уменьшить масштаб UIImage в IOS по размеру данных

Question

Я ищу в UIImage в iOS.

Я видел другие вопросы ниже и их подход к тому, как уменьшить изображение по размеру. Resizing Images Objective-C
How to resize the image programmatically in objective-c in iphone
The simplest way to resize an UIImage?

Эти вопросы основаны на изменение размера изображения до определенного размера. В моем случае я ищу, чтобы изменить размер/уменьшить масштаб изображения на основе максимального размера.

В качестве примера я хотел бы установить максимальный размер NSData размером 500 КБ. Я знаю, что я могу получить размер изображения, как это: // Проверить размер изображения возвращается

NSData *imageData = UIImageJPEGRepresentation(image, 0.5); 

// Log out the image size 
NSLog(@"%lu KB",(imageData.length/1024)); 

То, что я хотел бы сделать, это некоторая форма петли здесь. Если размер больше, чем максимальный размер, который я установил, я хотел бы немного уменьшить изображение, а затем проверить размер. Если размер по-прежнему слишком крупный, нажмите снова, а затем снова проверьте, пока он не станет меньше максимального установленного размера.

Я не уверен, какой лучший подход для этого. В идеале я не хочу масштабировать изображение до определенного размера все время, но только слегка уменьшает изображение каждый раз. Таким образом, у меня может быть самый большой (размер w/h) самого изображения и максимальный размер (байты). Если я немного уменьшусь только за раз, какой был бы лучший способ сделать это?

EDIT Чтобы подтвердить, я ищу, чтобы изменить размер фактического изображения, но изменить размер изображения таким образом, что оно меньше, чем максимальное NSData Length. Например:
-проверить NSData Длина
-Если выше максимума я хочу передать UIImage в метод
-Затем петлю с помощью этого метода несколько повторно проклейки фактический размер изображения каждый раз, когда
-Until него находится под максимальной длиной NSData, а затем вернуть изображение?

Answer 1

Прямо сейчас, у вас есть рутина, которая говорит:

// Check if the image size is too large 
if ((imageData.length/1024) >= 1024) { 

    while ((imageData.length/1024) >= 1024) { 
     NSLog(@"While start - The imagedata size is currently: %f KB",roundf((imageData.length/1024))); 

     // While the imageData is too large scale down the image 

     // Get the current image size 
     CGSize currentSize = CGSizeMake(image.size.width, image.size.height); 

     // Resize the image 
     image = [image resizedImage:CGSizeMake(roundf(((currentSize.width/100)*80)), roundf(((currentSize.height/100)*80))) interpolationQuality:kMESImageQuality]; 

     // Pass the NSData out again 
     imageData = UIImageJPEGRepresentation(image, kMESImageQuality); 

    } 
} 

Я не советовал бы рекурсивно изменение размера изображения. Каждый раз, когда вы изменяете размер, вы теряете некоторое качество (часто проявляющееся как «смягчение» изображения с потерей детализации, с кумулятивными эффектами). Вы всегда хотите вернуться к оригинальному изображению и изменить размер, который все меньше и меньше. (В качестве несовершеннолетнего в сторону, что if заявление является излишним, тоже.)

Я мог бы предложить следующее:

NSData *imageData = UIImageJPEGRepresentation(image, kMESImageQuality); 
double factor  = 1.0; 
double adjustment = 1.0/sqrt(2.0); // or use 0.8 or whatever you want 
CGSize size   = image.size; 
CGSize currentSize = size; 
UIImage *currentImage = image; 

while (imageData.length >= (1024 * 1024)) 
{ 
    factor  *= adjustment; 
    currentSize = CGSizeMake(roundf(size.width * factor), roundf(size.height * factor)); 
    currentImage = [image resizedImage:currentSize interpolationQuality:kMESImageQuality]; 
    imageData = UIImageJPEGRepresentation(currentImage, kMESImageQuality); 
} 

Примечание, я не прикасаясь image, исходное изображение, а назначая currentImage по каждый раз изменяя размер исходного изображения, уменьшая масштаб каждый раз.

Кстати, если вы задаетесь вопросом о моем загадочном 1.0/sqrt(2.0), я пытался нанести компромисс между вашим итеративным 80% фактором и моим желанием одобрить изменение размера в 2 раза, когда я могу (потому что уменьшение сохраняет более резкость когда это делается силой 2). Но используйте любой нужный вам фактор adjustment.

Наконец, если вы делаете это на огромных изображениях, вы можете подумать об использовании блоков @autoreleasepool. Вы хотите профилировать свое приложение в разделе «Распределения в инструментах» и посмотреть, где находится ваша высокая отметка уровня воды, так как при отсутствии пулов автоопределения это может представлять собой довольно агрессивное использование памяти.

Answer 2

Помимо максимального размера вам также необходимо выбрать минимальный размер, а также принять решение о производительности. Например, вы можете проверить размер UIImageJPEGRepresentation(image, 1.0). Если вы слишком большой, то вы затем проверяете 0.95 или 0.1?

Один из возможных подходов - получить размер UIImageJPEGRepresentation(image, 1.0) и посмотреть, на каком проценте он слишком большой. Например, скажем, это 600 КБ. Затем вы должны вычислить 500.0/600, который составляет примерно 0.83. Тогда сделайте UIImageJPEGRepresentation(image, 0.83). Это не даст ровно 500 КБ, но может быть достаточно близко.

Другой подход заключается в том, чтобы начать с UIImageJPEGRepresentation(image, 1.0). Это слишком большой, а затем UIImageJPEGRepresentation(image, 0.5) Если слишком большой, то перейдите с 0.25, но если слишком маленький, пойдите с 0.75. Продолжайте разделить разницу, пока не получите приемлемый диапазон желаемого размера.

Answer 3

В своем пересмотренном вопросе вы пояснили, что ваша цель состояла в том, чтобы указать ограничения размера файла при загрузке изображений. В этом случае, игра с параметрами сжатия JPEG прекрасна, как было предложено rmaddy.

Интересный вопрос заключается в том, что у вас есть две переменные для воспроизведения, сжатия JPEG и размеров изображения (есть и другие, но я сохраню это просто). Как вы хотите расставить приоритеты друг над другом? Например, я не думаю, что имеет смысл сохранять полное разрешение, абсурдно сжатое изображение (например, коэффициент качества 0,1). Также не имеет смысла сохранять крошечное разрешение, несжатое изображение. Лично я исправлял качество, как было предложено rmaddy, но установил некоторый разумный уровень (например, качество JPEG не меньше, скажем 0,70). В этот момент я мог бы рассмотреть возможность изменения размеров изображения (и это тоже быстро изменит размер файла) и изменить размеры до тех пор, пока итоговый NSData не станет подходящим.

В любом случае, в моем первоначальном ответе я сосредоточился на потреблении памяти в приложении (в отличие от размера файла). Ради потомства, видим, что ответ ниже:

---

Если вы пытаетесь контролировать, сколько памяти используется при загрузке изображения в UIImage объекты, которые будут использоваться в UIKit объектов, а затем играть с JPEG сжатия воны» t поможет вам, потому что внутреннее представление изображений после их загрузки в объекты UIKit несжато. Таким образом, в этом случае параметры сжатия JPEG не достигают многого (кроме ущерба качеству изображения).

Чтобы проиллюстрировать эту идею, у меня есть изображение 1920 x 1080. У меня есть формат PNG (файл 629kb), сжатый формат JPEG (217kb) и минимально сжатый формат JPEG (1.1mb) , Но, когда я загружаю эти три различных изображения в UIImageView объектов (даже если они имеют очень маленький frame), «Отчисления» инструмент Instrument показывает мне, что они каждый из которых принимает до 7.91mb:

Этот потому что, когда вы загружаете изображение в представление изображения, внутреннее несжатое представление этих трех изображений составляет четыре байта на пиксель (байт для красного, один для зеленого, один для синего и один для альфа). Таким образом, мои 1920 x 1080 изображений занимают 1920 x 1080 x 4 = 8,249,400 = 7,91 МБ.

Итак, если вы не хотите, чтобы они загружали более 500 килобайт в память при загрузке их в объекты просмотра изображений, это означает, что вы хотите изменить их размер так, чтобы произведение ширины по высоте было равно 128 000 или меньше (т. е. если квадрат, менее 358 х 358 пикселей).

Но если ваша проблема связана с пропускной способностью сети при загрузке изображений или постоянной памяти, тогда продолжайте играть со значениями сжатия JPEG, как это предлагает превосходный ответ rmaddy. Но если вы пытаетесь решить проблемы с потреблением памяти, пока изображения загружаются в объекты UIKit, не делайте акцент на сжатии, но фокусируйтесь на изменении размера изображения.

Answer 4

Это был мой подход:

// Check if the image size is too large 
if ((imageData.length/1024) >= 1024) { 

    while ((imageData.length/1024) >= 1024) { 
     NSLog(@"While start - The imagedata size is currently: %f KB",roundf((imageData.length/1024))); 

     // While the imageData is too large scale down the image 

     // Get the current image size 
     CGSize currentSize = CGSizeMake(image.size.width, image.size.height); 

     // Resize the image 
     image = [image resizedImage:CGSizeMake(roundf(((currentSize.width/100)*80)), roundf(((currentSize.height/100)*80))) interpolationQuality:kMESImageQuality]; 

     // Pass the NSData out again 
     imageData = UIImageJPEGRepresentation(image, kMESImageQuality); 

    } 
} 

Метод изменения размера изображения следующим образом:

// Returns a rescaled copy of the image, taking into account its orientation 
// The image will be scaled disproportionately if necessary to fit the bounds specified by the parameter 
- (UIImage *)resizedImage:(CGSize)newSize interpolationQuality:(CGInterpolationQuality)quality { 
    BOOL drawTransposed; 

    switch (self.imageOrientation) { 
     case UIImageOrientationLeft: 
     case UIImageOrientationLeftMirrored: 
     case UIImageOrientationRight: 
     case UIImageOrientationRightMirrored: 
      drawTransposed = YES; 
      break; 

     default: 
      drawTransposed = NO; 
    } 

    return [self resizedImage:newSize 
        transform:[self transformForOrientation:newSize] 
       drawTransposed:drawTransposed 
     interpolationQuality:quality]; 
} 

Последовал:

// Returns a copy of the image that has been transformed using the given affine transform and scaled to the new size 
// The new image's orientation will be UIImageOrientationUp, regardless of the current image's orientation 
// If the new size is not integral, it will be rounded up 
- (UIImage *)resizedImage:(CGSize)newSize 
       transform:(CGAffineTransform)transform 
      drawTransposed:(BOOL)transpose 
    interpolationQuality:(CGInterpolationQuality)quality { 
    CGRect newRect = CGRectIntegral(CGRectMake(0, 0, newSize.width, newSize.height)); 
    CGRect transposedRect = CGRectMake(0, 0, newRect.size.height, newRect.size.width); 
    CGImageRef imageRef = self.CGImage; 

    // Build a context that's the same dimensions as the new size 
    CGContextRef bitmap = CGBitmapContextCreate(NULL, 
               newRect.size.width, 
               newRect.size.height, 
               CGImageGetBitsPerComponent(imageRef), 
               0, 
               CGImageGetColorSpace(imageRef), 
               CGImageGetBitmapInfo(imageRef)); 

    // Rotate and/or flip the image if required by its orientation 
    CGContextConcatCTM(bitmap, transform); 

    // Set the quality level to use when rescaling 
    CGContextSetInterpolationQuality(bitmap, quality); 

    // Draw into the context; this scales the image 
    CGContextDrawImage(bitmap, transpose ? transposedRect : newRect, imageRef); 

    // Get the resized image from the context and a UIImage 
    CGImageRef newImageRef = CGBitmapContextCreateImage(bitmap); 
    UIImage *newImage = [UIImage imageWithCGImage:newImageRef]; 

    // Clean up 
    CGContextRelease(bitmap); 
    CGImageRelease(newImageRef); 

    return newImage; 
} 

// Дополнительные методы для справки

// Returns an affine transform that takes into account the image orientation when drawing a scaled image 
- (CGAffineTransform)transformForOrientation:(CGSize)newSize { 
    CGAffineTransform transform = CGAffineTransformIdentity; 

    switch (self.imageOrientation) { 
     case UIImageOrientationDown:   // EXIF = 3 
     case UIImageOrientationDownMirrored: // EXIF = 4 
      transform = CGAffineTransformTranslate(transform, newSize.width, newSize.height); 
      transform = CGAffineTransformRotate(transform, M_PI); 
      break; 

     case UIImageOrientationLeft:   // EXIF = 6 
     case UIImageOrientationLeftMirrored: // EXIF = 5 
      transform = CGAffineTransformTranslate(transform, newSize.width, 0); 
      transform = CGAffineTransformRotate(transform, M_PI_2); 
      break; 

     case UIImageOrientationRight:   // EXIF = 8 
     case UIImageOrientationRightMirrored: // EXIF = 7 
      transform = CGAffineTransformTranslate(transform, 0, newSize.height); 
      transform = CGAffineTransformRotate(transform, -M_PI_2); 
      break; 
     default: 
      break; 
    } 

    switch (self.imageOrientation) { 
     case UIImageOrientationUpMirrored:  // EXIF = 2 
     case UIImageOrientationDownMirrored: // EXIF = 4 
      transform = CGAffineTransformTranslate(transform, newSize.width, 0); 
      transform = CGAffineTransformScale(transform, -1, 1); 
      break; 

     case UIImageOrientationLeftMirrored: // EXIF = 5 
     case UIImageOrientationRightMirrored: // EXIF = 7 
      transform = CGAffineTransformTranslate(transform, newSize.height, 0); 
      transform = CGAffineTransformScale(transform, -1, 1); 
      break; 
     default: 
      break; 
    } 

    return transform; 
} 

Answer 5

-(NSData*)testData 
{ 
    UIImage *imageToUpload=[UIImage imageNamed:@"images/lifestyle2.jpg"]; 
    NSData *imgData=UIImageJPEGRepresentation(imageToUpload,1.0); 
    float compressionRate=10; 
    while (imgData.length>1024) 
    { 
     if (compressionRate>0.5) 
     { 
      compressionRate=compressionRate-0.5; 
      imgData=UIImageJPEGRepresentation(imageToUpload,compressionRate/10); 
     } 
     else 
     { 
      return imgData; 
     } 
    } 
    return imgData; 
} 

Поддерживает качество изображения не менее 1 МБ.

Зов его,

NSData *compressedImageData=[self testData]; 
NSLog(@"%lu KB",compressedImageData.length);