iphone - create - ¿Cómo recortar el UIImage?

uiimage frame swift 4

Question

Desarrollé una aplicación en la que procesé la imagen utilizando sus píxeles, pero en ese procesamiento de imagen lleva mucho tiempo. Por lo tanto, quiero recortar UIImage (solo la parte central de la imagen, es decir, eliminar / recortar la parte delimitada de la imagen).

- (NSInteger) processImage1: (UIImage*) image
{

 CGFloat width = image.size.width;
 CGFloat height = image.size.height;
 struct pixel* pixels = (struct pixel*) calloc(1, image.size.width * image.size.height * sizeof(struct pixel));
 if (pixels != nil)
 {
  // Create a new bitmap
  CGContextRef context = CGBitmapContextCreate(
              (void*) pixels,
              image.size.width,
              image.size.height,
              8,
              image.size.width * 4,
              CGImageGetColorSpace(image.CGImage),
              kCGImageAlphaPremultipliedLast
              );
  if (context != NULL)
  {
   // Draw the image in the bitmap
   CGContextDrawImage(context, CGRectMake(0.0f, 0.0f, image.size.width, image.size.height), image.CGImage);
   NSUInteger numberOfPixels = image.size.width * image.size.height;

   NSMutableArray *numberOfPixelsArray = [[[NSMutableArray alloc] initWithCapacity:numberOfPixelsArray] autorelease];
}

¿Cómo tomo (recortando fuera delimitado) la parte media de UIImage ?????????

Answer 1

Como lo necesitaba ahora, aquí está el código de MV en Swift 4:

func imageWithImage(image: UIImage, croppedTo rect: CGRect) -> UIImage {

    UIGraphicsBeginImageContext(rect.size)
    let context = UIGraphicsGetCurrentContext()

    let drawRect = CGRect(x: -rect.origin.x, y: -rect.origin.y, 
                          width: image.size.width, height: image.size.height)

    context?.clip(to: CGRect(x: 0, y: 0, 
                             width: rect.size.width, height: rect.size.height))

    image.draw(in: drawRect)

    let subImage = UIGraphicsGetImageFromCurrentImageContext()

    UIGraphicsEndImageContext()
    return subImage!
}

Answer 2

En última instancia, sería más rápido, con una creación de imagen mucho menor a partir de atlas de sprites, si pudiera configurar no solo la imagen para un UIImageView, sino también el desplazamiento de la parte superior izquierda para mostrar dentro de ese UIImage. Tal vez esto sea posible. ¡Sin duda eliminaría mucho esfuerzo!

Mientras tanto, creé estas funciones útiles en una clase de utilidad que uso en mis aplicaciones. Crea un UIImage de parte de otro UIImage, con opciones para rotar, escalar y voltear usando los valores estándar de UIImageOrientation para especificar. La escala de píxeles se conserva de la imagen original.

Mi aplicación crea una gran cantidad de UIImages durante la inicialización, y esto necesariamente lleva tiempo. Pero algunas imágenes no son necesarias hasta que se selecciona una pestaña determinada. Para dar la apariencia de una carga más rápida, podría crearlos en un subproceso separado generado en el inicio, y luego esperar a que termine cuando se seleccione esa pestaña.

Este código también se publica en la forma más eficiente de dibujar parte de una imagen en iOS

+ (UIImage*)imageByCropping:(UIImage *)imageToCrop toRect:(CGRect)aperture {
    return [ChordCalcController imageByCropping:imageToCrop toRect:aperture withOrientation:UIImageOrientationUp];
}

// Draw a full image into a crop-sized area and offset to produce a cropped, rotated image
+ (UIImage*)imageByCropping:(UIImage *)imageToCrop toRect:(CGRect)aperture withOrientation:(UIImageOrientation)orientation {

            // convert y coordinate to origin bottom-left
    CGFloat orgY = aperture.origin.y + aperture.size.height - imageToCrop.size.height,
            orgX = -aperture.origin.x,
            scaleX = 1.0,
            scaleY = 1.0,
            rot = 0.0;
    CGSize size;

    switch (orientation) {
        case UIImageOrientationRight:
        case UIImageOrientationRightMirrored:
        case UIImageOrientationLeft:
        case UIImageOrientationLeftMirrored:
            size = CGSizeMake(aperture.size.height, aperture.size.width);
            break;
        case UIImageOrientationDown:
        case UIImageOrientationDownMirrored:
        case UIImageOrientationUp:
        case UIImageOrientationUpMirrored:
            size = aperture.size;
            break;
        default:
            assert(NO);
            return nil;
    }


    switch (orientation) {
        case UIImageOrientationRight:
            rot = 1.0 * M_PI / 2.0;
            orgY -= aperture.size.height;
            break;
        case UIImageOrientationRightMirrored:
            rot = 1.0 * M_PI / 2.0;
            scaleY = -1.0;
            break;
        case UIImageOrientationDown:
            scaleX = scaleY = -1.0;
            orgX -= aperture.size.width;
            orgY -= aperture.size.height;
            break;
        case UIImageOrientationDownMirrored:
            orgY -= aperture.size.height;
            scaleY = -1.0;
            break;
        case UIImageOrientationLeft:
            rot = 3.0 * M_PI / 2.0;
            orgX -= aperture.size.height;
            break;
        case UIImageOrientationLeftMirrored:
            rot = 3.0 * M_PI / 2.0;
            orgY -= aperture.size.height;
            orgX -= aperture.size.width;
            scaleY = -1.0;
            break;
        case UIImageOrientationUp:
            break;
        case UIImageOrientationUpMirrored:
            orgX -= aperture.size.width;
            scaleX = -1.0;
            break;
    }

    // set the draw rect to pan the image to the right spot
    CGRect drawRect = CGRectMake(orgX, orgY, imageToCrop.size.width, imageToCrop.size.height);

    // create a context for the new image
    UIGraphicsBeginImageContextWithOptions(size, NO, imageToCrop.scale);
    CGContextRef gc = UIGraphicsGetCurrentContext();

    // apply rotation and scaling
    CGContextRotateCTM(gc, rot);
    CGContextScaleCTM(gc, scaleX, scaleY);

    // draw the image to our clipped context using the offset rect
    CGContextDrawImage(gc, drawRect, imageToCrop.CGImage);

    // pull the image from our cropped context
    UIImage *cropped = UIGraphicsGetImageFromCurrentImageContext();

    // pop the context to get back to the default
    UIGraphicsEndImageContext();

    // Note: this is autoreleased
    return cropped;
}

Answer 3

Estaba buscando una forma de obtener un recorte rectangular arbitrario (es decir, una sub-imagen) de un UIImage.

La mayoría de las soluciones que probé no funcionan si la orientación de la imagen no es UIImageOrientationUp.

Por ejemplo:

http://www.hive05.com/2008/11/crop-an-image-using-the-iphone-sdk/

Normalmente, si usa la cámara de su iPhone, tendrá otras orientaciones como UIImageOrientationLeft, y no obtendrá un recorte correcto con lo anterior. Esto se debe al uso de CGImageRef / CGContextDrawImage que difieren en el sistema de coordenadas con respecto a UIImage.

El siguiente código utiliza los métodos de UI * (no CGImageRef), y he probado esto con imágenes orientadas hacia arriba / abajo / izquierda / derecha, y parece que funciona muy bien.

// get sub image
- (UIImage*) getSubImageFrom: (UIImage*) img WithRect: (CGRect) rect {

    UIGraphicsBeginImageContext(rect.size);
    CGContextRef context = UIGraphicsGetCurrentContext();

    // translated rectangle for drawing sub image 
    CGRect drawRect = CGRectMake(-rect.origin.x, -rect.origin.y, img.size.width, img.size.height);

    // clip to the bounds of the image context
    // not strictly necessary as it will get clipped anyway?
    CGContextClipToRect(context, CGRectMake(0, 0, rect.size.width, rect.size.height));

    // draw image
    [img drawInRect:drawRect];

    // grab image
    UIImage* subImage = UIGraphicsGetImageFromCurrentImageContext();

    UIGraphicsEndImageContext();

    return subImage;
}

Answer 4

Intenta algo como esto:

CGImageRef imageRef = CGImageCreateWithImageInRect([largeImage CGImage], cropRect);
image = [UIImage imageWithCGImage:imageRef]; 
CGImageRelease(imageRef);

Nota: cropRect es un rectángulo más pequeño con la parte central de la imagen ...

Answer 5

Quería poder recortar desde una región en función de una relación de aspecto y escalar a un tamaño en función de una extensión delimitadora externa. Aquí está mi variación:

import AVFoundation
import ImageIO

class Image {

    class func crop(image:UIImage, source:CGRect, aspect:CGSize, outputExtent:CGSize) -> UIImage {

        let sourceRect = AVMakeRectWithAspectRatioInsideRect(aspect, source)
        let targetRect = AVMakeRectWithAspectRatioInsideRect(aspect, CGRect(origin: CGPointZero, size: outputExtent))

        let opaque = true, deviceScale:CGFloat = 0.0 // use scale of device''s main screen
        UIGraphicsBeginImageContextWithOptions(targetRect.size, opaque, deviceScale)

        let scale = max(
            targetRect.size.width / sourceRect.size.width,
            targetRect.size.height / sourceRect.size.height)

        let drawRect = CGRect(origin: -sourceRect.origin * scale, size: image.size * scale)
        image.drawInRect(drawRect)

        let scaledImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()

        return scaledImage
    }
}

Hay un par de cosas que me parecieron confusas, las preocupaciones separadas de recortar y cambiar el tamaño. El recorte se maneja con el origen del rect que pasas a drawInRect, y la escala se maneja por la parte del tamaño. En mi caso, necesitaba relacionar el tamaño del recorte recto en la fuente, con mi salida de la misma relación de aspecto. El factor de escala es entonces la salida / entrada, y esto debe aplicarse al drawRect (pasado a drawInRect).

Una advertencia es que este enfoque asume efectivamente que la imagen que está dibujando es más grande que el contexto de la imagen. No he probado esto, pero creo que puede usar este código para manejar el recorte / zoom, pero definiendo explícitamente el parámetro de escala como el parámetro de escala mencionado anteriormente. Por defecto, UIKit aplica un multiplicador basado en la resolución de la pantalla.

Finalmente, se debe tener en cuenta que este enfoque UIKit tiene un nivel más alto que los enfoques CoreGraphics / Quartz y Core Image, y parece manejar los problemas de orientación de la imagen. También vale la pena mencionar que es bastante rápido, después de ImageIO, según esta publicación aquí: http://nshipster.com/image-resizing/

Answer 6

Si quieres un retrato recorta el centro de cada foto.

Use la solución @MV, y reemplace cropRect.

CGFloat height = imageTaken.size.height;
CGFloat width = imageTaken.size.width;

CGFloat newWidth = height * 9 / 16;
CGFloat newX = abs((width - newWidth)) / 2;

CGRect cropRect = CGRectMake(newX,0, newWidth ,height);

Answer 7

Usando la funcion

CGContextClipToRect(context, CGRectMake(0, 0, size.width, size.height));

Aquí hay un código de ejemplo, que se utiliza para un propósito diferente, pero los clips están bien.

- (UIImage *)aspectFillToSize:(CGSize)size
{
    CGFloat imgAspect = self.size.width / self.size.height;
    CGFloat sizeAspect = size.width/size.height;

    CGSize scaledSize;

        if (sizeAspect > imgAspect) { // increase width, crop height
            scaledSize = CGSizeMake(size.width, size.width / imgAspect);
        } else { // increase height, crop width
            scaledSize = CGSizeMake(size.height * imgAspect, size.height);
        }
    UIGraphicsBeginImageContextWithOptions(size, NO, 0.0f);
    CGContextRef context = UIGraphicsGetCurrentContext();
    CGContextClipToRect(context, CGRectMake(0, 0, size.width, size.height));
    [self drawInRect:CGRectMake(0.0f, 0.0f, scaledSize.width, scaledSize.height)];
    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return image;
}