Comment puis-je faire Pivoter Une UIImage et les Données d'Image de 90 Degrés

J'ai une UIImageView qui contient une image. À la minute où l'utilisateur peut cliquer pour enregistrer l'image au sein de la UIImageView sur le disque.

Je voudrais faire en sorte que l'utilisateur peut cliquer pour faire tourner le UIImageView et aussi faire tourner les comme uimage à l'intérieur de la vue, de sorte que lorsque l'image est enregistrée, il garde la nouvelle rotation.

À la minute où j'ai

- (IBAction)rotateImage:(id)sender {

float degrees = 90; //the value in degrees
self.imagePreview.transform = CGAffineTransformMakeRotation(degrees * M_PI/180);

}

Quelqu'un peut me pointer dans la bonne direction en ce qui concerne la conservation de la rotation actuelle.

Grâce

Si vous voulez la rotation de persister après l'image est enregistrée, vous devriez être en rotation de l'UIImage, pas la UIImageView.
double possible de Comment faire pivoter UIImage

OriginalL'auteur ORStudios | 2013-07-28

J'ai ce code dans mon ancienne application. Mais ce code peut être simplifié parce que vous n'avez pas besoin de la faire tourner sur la non-angle de 90 degrés.

Objective-C

@implementation UIImage (Rotation)

- (UIImage *)imageRotatedOnDegrees:(CGFloat)degrees
{
  //Follow ing code can only rotate images on 90, 180, 270.. degrees.
  CGFloat roundedDegrees = (CGFloat)(round(degrees / 90.0) * 90.0);
  BOOL sameOrientationType = ((NSInteger)roundedDegrees) % 180 == 0;
  CGFloat radians = M_PI * roundedDegrees / 180.0;
  CGSize newSize = sameOrientationType ? self.size : CGSizeMake(self.size.height, self.size.width);

  UIGraphicsBeginImageContext(newSize);
  CGContextRef ctx = UIGraphicsGetCurrentContext();
  CGImageRef cgImage = self.CGImage;
  if (ctx == NULL || cgImage == NULL) {
    UIGraphicsEndImageContext();
    return self;
  }

  CGContextTranslateCTM(ctx, newSize.width / 2.0, newSize.height / 2.0);
  CGContextRotateCTM(ctx, radians);
  CGContextScaleCTM(ctx, 1, -1);
  CGPoint origin = CGPointMake(-(self.size.width / 2.0), -(self.size.height / 2.0));
  CGRect rect = CGRectZero;
  rect.origin = origin;
  rect.size = self.size;
  CGContextDrawImage(ctx, rect, cgImage);
  UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
  UIGraphicsEndImageContext();
  return image ?: self;
}

@end

Swift

extension UIImage {

  func imageRotated(on degrees: CGFloat) -> UIImage {
    //Following code can only rotate images on 90, 180, 270.. degrees.
    let degrees = round(degrees / 90) * 90
    let sameOrientationType = Int(degrees) % 180 == 0
    let radians = CGFloat.pi * degrees / CGFloat(180)
    let newSize = sameOrientationType ? size : CGSize(width: size.height, height: size.width)

    UIGraphicsBeginImageContext(newSize)
    defer {
      UIGraphicsEndImageContext()
    }

    guard let ctx = UIGraphicsGetCurrentContext(), let cgImage = cgImage else {
      return self
    }

    ctx.translateBy(x: newSize.width / 2, y: newSize.height / 2)
    ctx.rotate(by: radians)
    ctx.scaleBy(x: 1, y: -1)
    let origin = CGPoint(x: -(size.width / 2), y: -(size.height / 2))
    let rect = CGRect(origin: origin, size: size)
    ctx.draw(cgImage, in: rect)
    let image = UIGraphicsGetImageFromCurrentImageContext()
    return image ?? self
  }

}

pourquoi est-ce la commutation des images de direction?
Pour plus de 180 degrés, cette bascule de l'image.
Ce n'est pas la même rotation de 180 degrés (à l'envers), que le retournement (recto verso).
Ressemble le code Objective-C avait un problème avec l'application de l'échelle. Maintenant, il doit être fixé.

OriginalL'auteur Timur Bernikovich

Cela permettra de faire pivoter une image, par quelque radians.

Remarque cela fonctionne 2x et 3x rétine ainsi

- (UIImage *)imageRotatedByDegrees:(CGFloat)degrees {
    CGFloat radians = DegreesToRadians(degrees);

    UIView *rotatedViewBox = [[UIView alloc] initWithFrame:CGRectMake(0,0, self.size.width, self.size.height)];
    CGAffineTransform t = CGAffineTransformMakeRotation(radians);
    rotatedViewBox.transform = t;
    CGSize rotatedSize = rotatedViewBox.frame.size;

    UIGraphicsBeginImageContextWithOptions(rotatedSize, NO, [[UIScreen mainScreen] scale]);
    CGContextRef bitmap = UIGraphicsGetCurrentContext();

    CGContextTranslateCTM(bitmap, rotatedSize.width / 2, rotatedSize.height / 2);

    CGContextRotateCTM(bitmap, radians);

    CGContextScaleCTM(bitmap, 1.0, -1.0);
    CGContextDrawImage(bitmap, CGRectMake(-self.size.width / 2, -self.size.height / 2 , self.size.width, self.size.height), self.CGImage );

    UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();

    return newImage;
}

Cela fonctionne parfaitement, cependant je l'ai remplacé CGFloat radians = DegreesToRadians(degrees); avec CGFloat radians = degrees * (M_PI / 180.0); pour un peu plus de "contenu" solution
l'une des rares solutions qui ont travaillé, +1, merci!

OriginalL'auteur RyanG

La surbrillance d'un UIButton n'a pas pris la bonne orientation de la normale inséré tourné image. J'ai donc eu le rafraîchissement de l'image comme @RyanG a montré. Voici la Swift 2.2 code:

extension UIImage
{
    ///Rotate an image by any given radians.
    ///Works for 2x and 3x retina as well.
    func imageRotatedByDegrees(degrees: Double) -> UIImage
    {
        let radians = CGFloat(degrees * (M_PI / 180.0))

        let rotatedViewBox = UIView(frame: CGRect(origin: CGPointZero, size: self.size))
        let t: CGAffineTransform = CGAffineTransformMakeRotation(radians)
        rotatedViewBox.transform = t
        let rotatedSize = rotatedViewBox.frame.size

        UIGraphicsBeginImageContextWithOptions(rotatedSize, false, self.scale)
        let bitmap = UIGraphicsGetCurrentContext()

        CGContextTranslateCTM(bitmap, rotatedSize.width / 2, rotatedSize.height / 2)
        CGContextRotateCTM(bitmap, radians)
        CGContextScaleCTM(bitmap, 1.0, -1.0)
        CGContextDrawImage(bitmap, CGRect(origin: CGPoint(x: -self.size.width / 2, y: -self.size.height / 2), size: self.size), self.CGImage)

        let newImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        return newImage
    }
}

OriginalL'auteur FBente

Swift version faite à partir de la réponse de @RyanG avec quelques corrections:

func rotated(by degrees: CGFloat) -> UIImage {
    let radians : CGFloat = degrees * CGFloat(.pi / 180.0)
    let rotatedViewBox = UIView(frame: CGRect(x: 0, y: 0, width: self.size.width, height: self.size.height))
    let t = CGAffineTransform(rotationAngle: radians)
    rotatedViewBox.transform = t
    let rotatedSize = rotatedViewBox.frame.size
    UIGraphicsBeginImageContextWithOptions(rotatedSize, false, self.scale)
    defer { UIGraphicsEndImageContext() }
    guard let bitmap = UIGraphicsGetCurrentContext(), let cgImage = self.cgImage else {
      return self
    }
    bitmap.translateBy(x: rotatedSize.width / 2, y: rotatedSize.height / 2)
    bitmap.rotate(by: radians)
    bitmap.scaleBy(x: 1.0, y: -1.0)
    bitmap.draw(cgImage, in: CGRect(x: -self.size.width / 2, y: -self.size.height / 2, width: self.size.width, height: self.size.height))
    guard let newImage = UIGraphicsGetImageFromCurrentImageContext() else {
      return self
    }
    return newImage
  }

Je commençais à une augmentation de la taille de l'image après rotation, donc j'ai ajouter ceci:

let rotatedSize = rotatedViewBox.frame.size;     let roundedSize = CGSize(width: Int(rotatedSize.width), height: Int(rotatedSize.height));     UIGraphicsBeginImageContextWithOptions(roundedSize, false, self.scale);

OriginalL'auteur Alexander Mayatsky

0

Dans Swift 4

imageView.transform = CGAffineTransform(rotationAngle: CGFloat(Double.pi/2))

OriginalL'auteur iVignesh
-1

self.imageview.transform = CGAffineTransformMakeRotation(M_PI/2);

C'est l'équivalent de ce que l'OP a déjà fait voir que 90 * pi / 180 est égal à M_PI/2.
Ou la M_PI_2 constante
Ce n'est pas de faire pivoter les données de l'image elle-même

OriginalL'auteur 123

Vous devez vous connecter pour publier un commentaire.