Comment réduire la résolution d'une UIImage dans IOS par la taille des Données

Droit maintenant, vous avez une routine qui dit:

//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);

    }
}

Je ne le conseille pas récursivement le redimensionnement de l'image. Chaque fois que vous redimensionnez, vous perdez une partie de la qualité (souvent manifeste lui-même comme un "adoucissement" de l'image, avec une perte de détails, avec des effets cumulatifs). On a toujours envie de revenir en arrière à l'original de l'image et la redimensionner, que de plus en plus petites. (Comme un mineur de côté, que if déclaration est redondant, trop.)

Je pourrais suggérer le suivant:

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

Remarque, je ne suis pas toucher image, l'image d'origine, mais plutôt l'attribution currentImage en faisant un redimensionnement de l'image d'origine à chaque fois, par une diminution de l'échelle à chaque fois.

BTW, si vous vous demandez à propos de mon cryptique 1.0 /sqrt(2.0), j'ai essayé de dessiner un compromis entre votre itératif facteur de 80% et mon désir de favoriser le redimensionnement par une puissance de 2 où je peux (car une réduction conserve plus de netteté quand c'est fait par une puissance de 2). Mais quelle que soit l'utilisation adjustment facteur que vous voulez.

Enfin, si vous êtes en train de faire cela sur des images énormes, vous pouvez penser à l'aide de @autoreleasepool blocs. Vous aurez envie de profil de votre application dans les Affectations dans les Instruments et de voir où votre marque des hautes eaux est, comme en l'absence d'autorelease piscines, ce qui peut constituer une assez agressif utilisation de la mémoire.

OriginalL'auteur Rob

C'était mon approche:

//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);

    }
}

Le redimensionnement de l'image de la méthode est comme suit:

//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];
}

Suivie par:

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

//Autres méthodes de référence

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

OriginalL'auteur StuartM

Dans votre nouvelle question, vous avez précisé que votre objectif est-à-dire dans les limitations de taille de fichier lors du téléchargement d'images. Dans ce cas, de jouer avec les options de compression JPEG est très bien comme suggéré par rmaddy.

La question intéressante est que vous avez deux variables de jouer avec, la compression JPEG et les dimensions de l'image (il y en a d'autres, trop, mais je vais faire simple). Comment voulez-vous mettre la priorité sur un sur l'autre? Par exemple, je ne pense pas qu'il est logique de garder une pleine résolution, par l'absurde image compressée (par exemple de 0,1 facteur de qualité). Ni est-il judicieux de garder une petite résolution, l'image non compressée. Personnellement, je serais de manière itérative ajuster la qualité comme suggéré par rmaddy, mais certaines raisonnable étage (par exemple, JPEG de qualité ne sont pas moins de, disons de 0,70). À ce point, je pourrais envisager de changer les dimensions de l'image (et que les changements de taille de fichier très vite, trop), et en modifiant les dimensions jusqu'à ce que le NSData était d'une taille appropriée.

De toute façon, dans ma réponse originale à cette question, je me suis concentré sur la consommation de mémoire au sein de l'application (par opposition à la taille du fichier). Dans un souci de postérité, voir la réponse ci-dessous:

Si vous essayez de contrôler la quantité de mémoire est utilisée lorsque vous chargez les images dans UIImage objets à être utilisé dans UIKit objets, puis de jouer avec la compression JPEG ne vous aidera pas beaucoup, parce que la représentation interne des images une fois que vous chargez dans UIKit objets n'est pas compressé. Ainsi, dans ce scénario, la compression JPEG options de ne pas accomplir beaucoup (autres que de sacrifier la qualité d'image).

Pour illustrer cette idée, j'ai une image qui est de 1920 x 1080. Je l'ai en format PNG (le fichier est 629kb), un comprimé le format JPEG (217kb), et un peu compressé au format JPEG (1.1 mo). Mais, lorsque je charge ces trois images différentes en UIImageView objets (même si ils ont un très petit frame), de l'Instrument de "Dotations" outil me montre qu'ils sont chaque prise de 7.91 mb:

C'est parce que lorsque vous chargez une image dans une image de la vue, de l'intérieur, non compressé, la représentation de ces trois images est de quatre octets par pixel (un octet pour le rouge, un pour le vert et un pour le bleu, et un pour l'alpha). Ainsi, un de mes 1920 x 1080 images prendre jusqu'à 1920 x 1080 x 4 = 8,249,400 = 7.91 mb.

Donc, si vous ne voulez pas qu'ils prennent plus de 500 ko en mémoire lors de leur chargement dans l'affichage de l'image des objets, ce qui signifie que vous souhaitez redimensionner, tels que le produit de la largeur de fois la hauteur sera de 128 000 ou moins (c'est à dire si square, moins de 358 x 358 pixels).

Mais, si votre préoccupation est l'un de la bande passante du réseau que vous télécharger des images ou persistante de la capacité de stockage, puis aller de l'avant et de jouer avec les valeurs de compression JPEG comme suggéré par rmaddy excellente réponse. Mais si vous êtes tenter de répondre à des problèmes de consommation de mémoire, tandis que les images sont chargées dans UIKit objets, alors ne mettez pas l'accent sur la compression, mais se concentrer sur le redimensionnement de l'image.

OriginalL'auteur Rob