কীভাবে একটি ইউআইআইমেজ 90 ডিগ্রি ঘোরান?

Question

আমি একটি আছে UIImageযে UIImageOrientationUp(প্রতিকৃতি) যে আমি (ভূদৃশ্য পর্যন্ত) 90 ডিগ্রী ঘোরান ঘড়ির কাঁটার বিপরীতে চাই। আমি একটি ব্যবহার করতে চাই না CGAffineTransform। আমি পিক্সেলগুলি চাই UIImageপ্রকৃতপক্ষে অবস্থান পরিবর্তন করতে। আমি কোডের একটি ব্লক ব্যবহার করছি (নীচে দেখানো হয়েছে) মূলত এটি করার জন্য একটি আকার পরিবর্তন করার উদ্দেশ্যে UIImage। আমি বর্তমানের আকার হিসাবে একটি টার্গেট আকার সেট করেছি UIImageতবে আমি একটি ত্রুটি পেয়েছি:

(ত্রুটি): সিজিবিটম্যাপকন্টেক্সটক্রিয়াট: অবৈধ ডেটা বাইটস / সারি: 8 ইন্টিজার বিট / উপাদান, 3 উপাদান, কেসিজিমেজআল্ফপ্রিমুলিটিপ্লাস্টলাস্টের জন্য কমপক্ষে 1708 হওয়া উচিত।

(আমি যখনই লক্ষ্য আকার বিটিডাব্লু হিসাবে একটি ছোট আকার সরবরাহ করি তখন আমি ত্রুটি পাই না)। UIImageবর্তমান আকার সংরক্ষণের সময় আমি কীভাবে আমার মূল ডিগ্রি সিসিডব্লু ঘোরান?

-(UIImage*)reverseImageByScalingToSize:(CGSize)targetSize:(UIImage*)anImage
{
    UIImage* sourceImage = anImage; 
    CGFloat targetWidth = targetSize.height;
    CGFloat targetHeight = targetSize.width;

    CGImageRef imageRef = [sourceImage CGImage];
    CGBitmapInfo bitmapInfo = CGImageGetBitmapInfo(imageRef);
    CGColorSpaceRef colorSpaceInfo = CGImageGetColorSpace(imageRef);

    if (bitmapInfo == kCGImageAlphaNone) {
        bitmapInfo = kCGImageAlphaNoneSkipLast;
    }

    CGContextRef bitmap;

    if (sourceImage.imageOrientation == UIImageOrientationUp || sourceImage.imageOrientation == UIImageOrientationDown) {
        bitmap = CGBitmapContextCreate(NULL, targetHeight, targetWidth, CGImageGetBitsPerComponent(imageRef), CGImageGetBytesPerRow(imageRef), colorSpaceInfo, bitmapInfo);

    } else {


        bitmap = CGBitmapContextCreate(NULL, targetWidth, targetHeight, CGImageGetBitsPerComponent(imageRef), CGImageGetBytesPerRow(imageRef), colorSpaceInfo, bitmapInfo);

    }       


    if (sourceImage.imageOrientation == UIImageOrientationRight) {
        CGContextRotateCTM (bitmap, radians(90));
        CGContextTranslateCTM (bitmap, 0, -targetHeight);

    } else if (sourceImage.imageOrientation == UIImageOrientationLeft) {
        CGContextRotateCTM (bitmap, radians(-90));
        CGContextTranslateCTM (bitmap, -targetWidth, 0);

    } else if (sourceImage.imageOrientation == UIImageOrientationDown) {
        // NOTHING
    } else if (sourceImage.imageOrientation == UIImageOrientationUp) {
        CGContextRotateCTM (bitmap, radians(90));
        CGContextTranslateCTM (bitmap, 0, -targetHeight);
    }

    CGContextDrawImage(bitmap, CGRectMake(0, 0, targetWidth, targetHeight), imageRef);
    CGImageRef ref = CGBitmapContextCreateImage(bitmap);
    UIImage* newImage = [UIImage imageWithCGImage:ref];

    CGContextRelease(bitmap);
    CGImageRelease(ref);

    return newImage; 
}

Comments

আমি আরেকটি দরকারী লিঙ্কটি পেয়েছি .. আশা করি এটি কিছুটা সাহায্য করবে .. mobiledevelopertips.com/user-interface/…

— দিলীপ রাজকুমার

সমাধান .......... stackoverflow.com/questions/5427656/...

— Fattie

আমার সমস্যাটি হল যে অ্যামাজন এস 3 এ আপলোড করা ফটোগুলি ঘোরানো হয়েছিল। এই সমাধানটি দৃষ্টিশক্তিযুক্ত এবং আপলোড করে সমস্যার সমাধান করেছে।

— ক্রিশালিক

stackoverflow.com/questions/30701578/... হেই nilam আমি মুছে ফেলবে দেখার পর এই দেখতে

— হৃষিকেশ দেশপান্ডে

Answer 1

যেমন কিছু সম্পর্কে:

static inline double radians (double degrees) {return degrees * M_PI/180;}
UIImage* rotate(UIImage* src, UIImageOrientation orientation)
{
    UIGraphicsBeginImageContext(src.size);

    CGContextRef context = UIGraphicsGetCurrentContext();

    if (orientation == UIImageOrientationRight) {
        CGContextRotateCTM (context, radians(90));
    } else if (orientation == UIImageOrientationLeft) {
        CGContextRotateCTM (context, radians(-90));
    } else if (orientation == UIImageOrientationDown) {
        // NOTHING
    } else if (orientation == UIImageOrientationUp) {
        CGContextRotateCTM (context, radians(90));
    }

    [src drawAtPoint:CGPointMake(0, 0)];

    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return image;
}

Comments

আমার মন্তব্য ছিল যে সঠিক রোটেটেটিএম সেট করার জন্য কলের পরে ড্রআউটপয়েন্টটি কল করতে হতে পারে। ইউআইজিগ্রাফিকস গেট ইমেজফর্ম কর্নারআইমেজকন্টেক্সট এর ঠিক আগে অঙ্কনআউটপয়েন্টটি সরানোর চেষ্টা করুন

— ফ্রেব্রেটো

এটি কোনও পটভূমির থ্রেডে কাজ করবে না। ইউআইজিগ্রাফিকস গেটকোর্ন্টকন্টেক্সট () থ্রেড-নিরাপদ নয় এবং কেবলমাত্র (ইউআই) থ্রেডে কল করা উচিত।

— ক্রিস আর ডোনেলি

CGContextRotateCTM () এর শেষ কলটি 90 দ্বারা নয় সম্ভবত 180 দ্বারা ঘোরা উচিত In বাস্তবে,… ডাউনটি সম্ভবত 180 দ্বারা ঘোরা উচিত এবং… আপ সম্ভবত ঘোরানো উচিত নয়।

— ইভান ভুইকা

আইওএস 4 এবং তারপরে, আপনি আপনার অ্যাপ্লিকেশনটির যে কোনও থ্রেড থেকে ইউআইজিগ্রাফিকস গেটকর্নর কনটেক্সট ফাংশনটি কল করতে পারেন।

— বেন্টফোর্ড

CGContextTranslateCTM (সিটিএক্স, প্রস্থ / 2, উচ্চতা / 2) এর আগে এবং পরে বিপরীত হওয়া দরকার।

— গ্লেন মেইনার্ড

Answer 2

আমি বিশ্বাস করি সবচেয়ে সহজ উপায় (এবং থ্রেড নিরাপদও) করণীয়:

//assume that the image is loaded in landscape mode from disk
UIImage * landscapeImage = [UIImage imageNamed:imgname];
UIImage * portraitImage = [[UIImage alloc] initWithCGImage: landscapeImage.CGImage
                                                     scale: 1.0
                                               orientation: UIImageOrientationRight];

দ্রষ্টব্য: ব্রেইনওয়্যার যেমন বলেছিলেন এটি কেবলমাত্র চিত্রের ওরিয়েন্টেশন ডেটা সংশোধন করে - পিক্সেল ডেটাটি অচ্ছুত। কিছু অ্যাপ্লিকেশনগুলির জন্য, এটি যথেষ্ট নাও হতে পারে।

বা সুইফটে:

guard
    let landscapeImage = UIImage(named: "imgname"),
    let landscapeCGImage = landscapeImage.cgImage
else { return }
let portraitImage = UIImage(cgImage: landscapeCGImage, scale: landscapeImage.scale, orientation: .right)

Comments

এটিকে আরও সাধারণ করুন: ইউআইআইমেজ * অরিজিনমিগ = [ইউআইআইমেজ ইমেজ নামকরণ করা: @ "1.JPG"]; ইউআইআইমেজ * নির্দিষ্ট = [ইউআইআইমেজ ইমেজউথ সিজিআইমেজ: [অরিজিনিউজ সিজিআইমেজ] স্কেল: 1.0 অরিয়েন্টেশন: অরিজিনমিগ.আইমেজ ওরিয়েন্টেশন];

— কুলেন এসইএন

এটি চিত্রটি আবর্তিত করে না। এটি চিত্রটির একটি অনুলিপি তৈরি করে এবং চিত্রের ফ্ল্যাশ বৈশিষ্ট্যের চিত্রের ওরিয়েন্টেশন বিটগুলি 0, 1, 2 বা 3 তে সেট করে Some আপনার যদি সত্যিই চিত্রটি ঘোরানো দরকার হয়, তবে বেন গ্রোটের উত্তরটি দেখুন যা হার্ডি ম্যাকিয়ার ইউআইআইমেজ এক্সটেনশন।

— ব্রেইনওয়্যার

আপনার অ্যাপ্লিকেশনটি রেটিনা এবং নন-রেটিনা উভয় স্ক্রিনে ব্যবহার করা হয় যদি আপনাকে মুল ইমেজ.স্কেল নিতে হয় এবং স্কেল উপাদান হিসাবে এটি পাস করতে হয় তবে স্কেলটি 1.0 হিসাবে স্কেল করা কার্যকর হবে না।

— teradyl

আমি যতটা বলতে পারি iOS10 এ কাজ করা বন্ধ করে দিয়েছে বলে মনে হচ্ছে।

— নাইলার

let img = UIImage(cgImage: myImage!.cgImage!, scale: UIScreen.main.scale, orientation: .right)

— আলেকজান্দ্রে জি

Answer 3

হার্ডি ম্যাকিয়ার সহজ এবং দুর্দান্ত কোডটি এখানে দেখুন: কাটা-স্কেলিং-এবং-ঘোরানো-ইউআইমেজেস

শুধু কল

UIImage *rotatedImage = [originalImage imageRotatedByDegrees:90.0];

ধন্যবাদ হার্ডি ম্যাকিয়া!

শিরোলেখ:

• (UII छवि *) চিত্রঅ্যাটাক্ট: (সিজিআরেক্ট) রেক্ট;
• (ইউআইআইজিএইচ *) চিত্রবাইসাইক্লিংপ্রসূতভাবে টো মিনিমাম সাইজ: (সিজিএসাইজ) টার্গেট সাইজ;
• (ইউআইআইজিএইচ *) চিত্রবাইসাইক্লিংপ্রসূতভাবে তোসাইজ: (সিজি সাইজ) টার্গেট সাইজ;
• (UII छवि *) চিত্রবিসাইক্রিংটোসাইজ: (সিজি সাইজ) টার্গেট সাইজ;
• (ইউআইআইজিএইচ *) চিত্রটি ঘূর্ণিত বাইর্যাডিয়ানস: (সিজিফ্লোয়েট) রেডিয়ানস;
• (ইউআইআইজিএইচ *) চিত্রটি ঘূর্ণিত বাই ডিগ্রি: (সিজিফ্লোট) ডিগ্রি;

যেহেতু লিঙ্কটি মারা যেতে পারে, এখানে সম্পূর্ণ কোড

//
//  UIImage-Extensions.h
//
//  Created by Hardy Macia on 7/1/09.
//  Copyright 2009 Catamount Software. All rights reserved.
//
#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>

@interface UIImage (CS_Extensions)
- (UIImage *)imageAtRect:(CGRect)rect;
- (UIImage *)imageByScalingProportionallyToMinimumSize:(CGSize)targetSize;
- (UIImage *)imageByScalingProportionallyToSize:(CGSize)targetSize;
- (UIImage *)imageByScalingToSize:(CGSize)targetSize;
- (UIImage *)imageRotatedByRadians:(CGFloat)radians;
- (UIImage *)imageRotatedByDegrees:(CGFloat)degrees;

@end;

//
//  UIImage-Extensions.m
//
//  Created by Hardy Macia on 7/1/09.
//  Copyright 2009 Catamount Software. All rights reserved.
//

#import "UIImage-Extensions.h"

CGFloat DegreesToRadians(CGFloat degrees) {return degrees * M_PI / 180;};
CGFloat RadiansToDegrees(CGFloat radians) {return radians * 180/M_PI;};

@implementation UIImage (CS_Extensions)

-(UIImage *)imageAtRect:(CGRect)rect
{

   CGImageRef imageRef = CGImageCreateWithImageInRect([self CGImage], rect);
   UIImage* subImage = [UIImage imageWithCGImage: imageRef];
   CGImageRelease(imageRef);

   return subImage;

}

- (UIImage *)imageByScalingProportionallyToMinimumSize:(CGSize)targetSize {

   UIImage *sourceImage = self;
   UIImage *newImage = nil;

   CGSize imageSize = sourceImage.size;
   CGFloat width = imageSize.width;
   CGFloat height = imageSize.height;

   CGFloat targetWidth = targetSize.width;
   CGFloat targetHeight = targetSize.height;

   CGFloat scaleFactor = 0.0;
   CGFloat scaledWidth = targetWidth;
   CGFloat scaledHeight = targetHeight;

   CGPoint thumbnailPoint = CGPointMake(0.0,0.0);

   if (CGSizeEqualToSize(imageSize, targetSize) == NO) {

      CGFloat widthFactor = targetWidth / width;
      CGFloat heightFactor = targetHeight / height;

      if (widthFactor > heightFactor) 
         scaleFactor = widthFactor;
      else
         scaleFactor = heightFactor;

      scaledWidth  = width * scaleFactor;
      scaledHeight = height * scaleFactor;

      // center the image

      if (widthFactor > heightFactor) {
         thumbnailPoint.y = (targetHeight - scaledHeight) * 0.5; 
      } else if (widthFactor < heightFactor) {
         thumbnailPoint.x = (targetWidth - scaledWidth) * 0.5;
      }
   }


   // this is actually the interesting part:

   UIGraphicsBeginImageContext(targetSize);

   CGRect thumbnailRect = CGRectZero;
   thumbnailRect.origin = thumbnailPoint;
   thumbnailRect.size.width  = scaledWidth;
   thumbnailRect.size.height = scaledHeight;

   [sourceImage drawInRect:thumbnailRect];

   newImage = UIGraphicsGetImageFromCurrentImageContext();
   UIGraphicsEndImageContext();

   if(newImage == nil) NSLog(@"could not scale image");


   return newImage ;
}


- (UIImage *)imageByScalingProportionallyToSize:(CGSize)targetSize {

   UIImage *sourceImage = self;
   UIImage *newImage = nil;

   CGSize imageSize = sourceImage.size;
   CGFloat width = imageSize.width;
   CGFloat height = imageSize.height;

   CGFloat targetWidth = targetSize.width;
   CGFloat targetHeight = targetSize.height;

   CGFloat scaleFactor = 0.0;
   CGFloat scaledWidth = targetWidth;
   CGFloat scaledHeight = targetHeight;

   CGPoint thumbnailPoint = CGPointMake(0.0,0.0);

   if (CGSizeEqualToSize(imageSize, targetSize) == NO) {

      CGFloat widthFactor = targetWidth / width;
      CGFloat heightFactor = targetHeight / height;

      if (widthFactor < heightFactor) 
         scaleFactor = widthFactor;
      else
         scaleFactor = heightFactor;

      scaledWidth  = width * scaleFactor;
      scaledHeight = height * scaleFactor;

      // center the image

      if (widthFactor < heightFactor) {
         thumbnailPoint.y = (targetHeight - scaledHeight) * 0.5; 
      } else if (widthFactor > heightFactor) {
         thumbnailPoint.x = (targetWidth - scaledWidth) * 0.5;
      }
   }


   // this is actually the interesting part:

   UIGraphicsBeginImageContext(targetSize);

   CGRect thumbnailRect = CGRectZero;
   thumbnailRect.origin = thumbnailPoint;
   thumbnailRect.size.width  = scaledWidth;
   thumbnailRect.size.height = scaledHeight;

   [sourceImage drawInRect:thumbnailRect];

   newImage = UIGraphicsGetImageFromCurrentImageContext();
   UIGraphicsEndImageContext();

   if(newImage == nil) NSLog(@"could not scale image");


   return newImage ;
}


- (UIImage *)imageByScalingToSize:(CGSize)targetSize {

   UIImage *sourceImage = self;
   UIImage *newImage = nil;

   //   CGSize imageSize = sourceImage.size;
   //   CGFloat width = imageSize.width;
   //   CGFloat height = imageSize.height;

   CGFloat targetWidth = targetSize.width;
   CGFloat targetHeight = targetSize.height;

   //   CGFloat scaleFactor = 0.0;
   CGFloat scaledWidth = targetWidth;
   CGFloat scaledHeight = targetHeight;

   CGPoint thumbnailPoint = CGPointMake(0.0,0.0);

   // this is actually the interesting part:

   UIGraphicsBeginImageContext(targetSize);

   CGRect thumbnailRect = CGRectZero;
   thumbnailRect.origin = thumbnailPoint;
   thumbnailRect.size.width  = scaledWidth;
   thumbnailRect.size.height = scaledHeight;

   [sourceImage drawInRect:thumbnailRect];

   newImage = UIGraphicsGetImageFromCurrentImageContext();
   UIGraphicsEndImageContext();

   if(newImage == nil) NSLog(@"could not scale image");


   return newImage ;
}


- (UIImage *)imageRotatedByRadians:(CGFloat)radians
{
   return [self imageRotatedByDegrees:RadiansToDegrees(radians)];
}

- (UIImage *)imageRotatedByDegrees:(CGFloat)degrees 
{   
   // calculate the size of the rotated view's containing box for our drawing space
   UIView *rotatedViewBox = [[UIView alloc] initWithFrame:CGRectMake(0,0,self.size.width, self.size.height)];
   CGAffineTransform t = CGAffineTransformMakeRotation(DegreesToRadians(degrees));
   rotatedViewBox.transform = t;
   CGSize rotatedSize = rotatedViewBox.frame.size;
   [rotatedViewBox release];

   // Create the bitmap context
   UIGraphicsBeginImageContext(rotatedSize);
   CGContextRef bitmap = UIGraphicsGetCurrentContext();

   // Move the origin to the middle of the image so we will rotate and scale around the center.
   CGContextTranslateCTM(bitmap, rotatedSize.width/2, rotatedSize.height/2);

   //   // Rotate the image context
   CGContextRotateCTM(bitmap, DegreesToRadians(degrees));

   // Now, draw the rotated/scaled image into the context
   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;

}

@end;

Comments

... লিঙ্কটি মারা গেছে। সম্পূর্ণ কোড অন্তর্ভুক্ত করার জন্য +1

— গ্রেগ

Answer 4

যতটা অদ্ভুত মনে হয়, নিম্নলিখিত কোডটি আমার জন্য সমস্যার সমাধান করেছে:

+ (UIImage*)unrotateImage:(UIImage*)image {
    CGSize size = image.size;
    UIGraphicsBeginImageContext(size);
    [image drawInRect:CGRectMake(0,0,size.width ,size.height)];
    UIImage* newImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();

    return newImage;
}

Comments

এটি কাজ করে কারণ একবার আপনি আয়ত্তে আঁকলে চিত্রের ওরিয়েন্টেশনটি সংরক্ষণ করা হয়নি।

— Mercurial

হ্যাঁ, এটি কোনও চিত্র থেকে ওরিয়েন্টেশন সরানোর জন্য কার্যকর হবে

— শিহাব

ফাংশনের নামটি ওরিয়েন্টেশনপ্রোপার্টি

— শিহাব

Answer 5

একটি থ্রেড নিরাপদ ঘূর্ণন ফাংশন নিম্নলিখিত (এটি আরও ভাল কাজ করে):

-(UIImage*)imageByRotatingImage:(UIImage*)initImage fromImageOrientation:(UIImageOrientation)orientation
{
CGImageRef imgRef = initImage.CGImage;

CGFloat width = CGImageGetWidth(imgRef);
CGFloat height = CGImageGetHeight(imgRef);

CGAffineTransform transform = CGAffineTransformIdentity;
CGRect bounds = CGRectMake(0, 0, width, height);
CGSize imageSize = CGSizeMake(CGImageGetWidth(imgRef), CGImageGetHeight(imgRef));
CGFloat boundHeight;
UIImageOrientation orient = orientation;
switch(orient) {

    case UIImageOrientationUp: //EXIF = 1
        return initImage;
        break;

    case UIImageOrientationUpMirrored: //EXIF = 2
        transform = CGAffineTransformMakeTranslation(imageSize.width, 0.0);
        transform = CGAffineTransformScale(transform, -1.0, 1.0);
        break;

    case UIImageOrientationDown: //EXIF = 3
        transform = CGAffineTransformMakeTranslation(imageSize.width, imageSize.height);
        transform = CGAffineTransformRotate(transform, M_PI);
        break;

    case UIImageOrientationDownMirrored: //EXIF = 4
        transform = CGAffineTransformMakeTranslation(0.0, imageSize.height);
        transform = CGAffineTransformScale(transform, 1.0, -1.0);
        break;

    case UIImageOrientationLeftMirrored: //EXIF = 5
        boundHeight = bounds.size.height;
        bounds.size.height = bounds.size.width;
        bounds.size.width = boundHeight;
        transform = CGAffineTransformMakeTranslation(imageSize.height, imageSize.width);
        transform = CGAffineTransformScale(transform, -1.0, 1.0);
        transform = CGAffineTransformRotate(transform, 3.0 * M_PI / 2.0);
        break;

    case UIImageOrientationLeft: //EXIF = 6
        boundHeight = bounds.size.height;
        bounds.size.height = bounds.size.width;
        bounds.size.width = boundHeight;
        transform = CGAffineTransformMakeTranslation(0.0, imageSize.width);
        transform = CGAffineTransformRotate(transform, 3.0 * M_PI / 2.0);
        break;

    case UIImageOrientationRightMirrored: //EXIF = 7
        boundHeight = bounds.size.height;
        bounds.size.height = bounds.size.width;
        bounds.size.width = boundHeight;
        transform = CGAffineTransformMakeScale(-1.0, 1.0);
        transform = CGAffineTransformRotate(transform, M_PI / 2.0);
        break;

    case UIImageOrientationRight: //EXIF = 8
        boundHeight = bounds.size.height;
        bounds.size.height = bounds.size.width;
        bounds.size.width = boundHeight;
        transform = CGAffineTransformMakeTranslation(imageSize.height, 0.0);
        transform = CGAffineTransformRotate(transform, M_PI / 2.0);
        break;

    default:
        [NSException raise:NSInternalInconsistencyException format:@"Invalid image orientation"];

}
// Create the bitmap context
CGContextRef    context = NULL;
void *          bitmapData;
int             bitmapByteCount;
int             bitmapBytesPerRow;

// Declare the number of bytes per row. Each pixel in the bitmap in this
// example is represented by 4 bytes; 8 bits each of red, green, blue, and
// alpha.
bitmapBytesPerRow   = (bounds.size.width * 4);
bitmapByteCount     = (bitmapBytesPerRow * bounds.size.height);
bitmapData = malloc( bitmapByteCount );
if (bitmapData == NULL)
{
    return nil;
}

// Create the bitmap context. We want pre-multiplied ARGB, 8-bits
// per component. Regardless of what the source image format is
// (CMYK, Grayscale, and so on) it will be converted over to the format
// specified here by CGBitmapContextCreate.
CGColorSpaceRef colorspace = CGImageGetColorSpace(imgRef);
context = CGBitmapContextCreate (bitmapData,bounds.size.width,bounds.size.height,8,bitmapBytesPerRow,
                                 colorspace, kCGBitmapAlphaInfoMask & kCGImageAlphaPremultipliedLast);

if (context == NULL)
    // error creating context
    return nil;

CGContextScaleCTM(context, -1.0, -1.0);
CGContextTranslateCTM(context, -bounds.size.width, -bounds.size.height);

CGContextConcatCTM(context, transform);

// Draw the image to the bitmap context. Once we draw, the memory
// allocated for the context for rendering will then contain the
// raw image data in the specified color space.
CGContextDrawImage(context, CGRectMake(0,0,width, height), imgRef);

CGImageRef imgRef2 = CGBitmapContextCreateImage(context);
CGContextRelease(context);
free(bitmapData);
UIImage * image = [UIImage imageWithCGImage:imgRef2 scale:initImage.scale orientation:UIImageOrientationUp];
CGImageRelease(imgRef2);
return image;
}

Comments

আপনার কোড নিয়ে সমস্যা আছে ... এটি চিত্রের চারপাশে একটি অদ্ভুত সাদা ফ্রেম যুক্ত করে UIImageOrientationDown।

— iosfreak

আপনি এই কলটি সিজি কালারস্পেসরিজ রিলিজ (কালারস্পেস) এ চান না, স্ট্যাকওভারফ্লো দেখুন / প্রশ্নগুলি দেখুন / ৫২৯৯৮১৫/২

— শেঠ

হ্যাঁ, এই প্রকাশের জন্য দুঃখিত

— পোড়ামনকারী 11

Answer 6

অনুমোদিত উত্তর সহ উপরের ll নিয়ে আমার সমস্যা হয়েছিল। আমি হার্ডির ক্যাটাগরিটিকে আবার একটি পদ্ধতিতে রূপান্তরিত করলাম যেহেতু আমি যা চেয়েছিলাম তা একটি চিত্র ঘোরানো। এখানে কোড এবং ব্যবহার:

- (UIImage *)imageRotatedByDegrees:(UIImage*)oldImage deg:(CGFloat)degrees{
// calculate the size of the rotated view's containing box for our drawing space
UIView *rotatedViewBox = [[UIView alloc] initWithFrame:CGRectMake(0,0,oldImage.size.width, oldImage.size.height)];
CGAffineTransform t = CGAffineTransformMakeRotation(degrees * M_PI / 180);
rotatedViewBox.transform = t;
CGSize rotatedSize = rotatedViewBox.frame.size;
// Create the bitmap context
UIGraphicsBeginImageContext(rotatedSize);
CGContextRef bitmap = UIGraphicsGetCurrentContext();

// Move the origin to the middle of the image so we will rotate and scale around the center.
CGContextTranslateCTM(bitmap, rotatedSize.width/2, rotatedSize.height/2);

//   // Rotate the image context
CGContextRotateCTM(bitmap, (degrees * M_PI / 180));

// Now, draw the rotated/scaled image into the context
CGContextScaleCTM(bitmap, 1.0, -1.0);
CGContextDrawImage(bitmap, CGRectMake(-oldImage.size.width / 2, -oldImage.size.height / 2, oldImage.size.width, oldImage.size.height), [oldImage CGImage]);

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

এবং ব্যবহার:

UIImage *image2 = [self imageRotatedByDegrees:image deg:90];

ধন্যবাদ হার্ডি!

Answer 7

চিত্রটি 90 ডিগ্রি (ঘড়ির কাঁটার দিকের / ঘড়ির কাঁটার বিপরীত দিকের) দ্বারা ঘোরান

ফাংশন কল -

 UIImage *rotatedImage = [self rotateImage:originalImage clockwise:YES];

বাস্তবায়ন:

- (UIImage*)rotateImage:(UIImage*)sourceImage clockwise:(BOOL)clockwise
  {
    CGSize size = sourceImage.size;
    UIGraphicsBeginImageContext(CGSizeMake(size.height, size.width));
    [[UIImage imageWithCGImage:[sourceImage CGImage]
                         scale:1.0
                   orientation:clockwise ? UIImageOrientationRight : UIImageOrientationLeft]
                   drawInRect:CGRectMake(0,0,size.height ,size.width)];

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

   return newImage;
  }

Comments

এটি চিত্রের আকার বাড়ে

— শশীকান্ত

Answer 8

আপনি যদি এমন কোনও ফটো ঘোরানোর বোতাম যুক্ত করতে চান যা 90 ডিগ্রি বর্ধিত ক্ষেত্রে ফটো ঘোরানো থাকবে, আপনি এখানে যান। ( finalImageএটি একটি ইউআইআইমেজ যা ইতিমধ্যে অন্য কোথাও তৈরি করা হয়েছে))

- (void)rotatePhoto {
    UIImage *rotatedImage;

    if (finalImage.imageOrientation == UIImageOrientationRight)
        rotatedImage = [[UIImage alloc] initWithCGImage: finalImage.CGImage
                                              scale: 1.0
                                        orientation: UIImageOrientationDown];
    else if (finalImage.imageOrientation == UIImageOrientationDown)
        rotatedImage = [[UIImage alloc] initWithCGImage: finalImage.CGImage
                                              scale: 1.0
                                        orientation: UIImageOrientationLeft];
    else if (finalImage.imageOrientation == UIImageOrientationLeft)
        rotatedImage = [[UIImage alloc] initWithCGImage: finalImage.CGImage
                                              scale: 1.0
                                        orientation: UIImageOrientationUp];
    else
        rotatedImage = [[UIImage alloc] initWithCGImage: finalImage.CGImage
                                                     scale: 1.0
                                               orientation: UIImageOrientationRight];
    finalImage = rotatedImage;
}

Answer 9

সহজ। শুধু চিত্র ওরিয়েন্টেশন পতাকা পরিবর্তন করুন।

UIImage *oldImage = [UIImage imageNamed:@"whatever.jpg"];
UIImageOrientation newOrientation;
switch (oldImage.imageOrientation) {
    case UIImageOrientationUp:
        newOrientation = UIImageOrientationLandscapeLeft;
        break;
    case UIImageOrientationLandscapeLeft:
        newOrientation = UIImageOrientationDown;
        break;
    case UIImageOrientationDown:
        newOrientation = UIImageOrientationLandscapeRight;
        break;
    case UIImageOrientationLandscapeRight:
        newOrientation = UIImageOrientationUp;
        break;
    // you can also handle mirrored orientations similarly ...
}
UIImage *rotatedImage = [UIImage imageWithCGImage:oldImage.CGImage scale:1.0f orientation:newOrientation];

Answer 10

এখানে ইউআইআইমেজে একটি সুইফট এক্সটেনশন যা কোনও স্বেচ্ছাচারী কোণ দ্বারা চিত্রটি ঘোরায়। এর মতো এটিকে ব্যবহার করুন: let rotatedImage = image.rotated(byDegrees: degree)। আমি অন্য উত্তরের একটিতে অবজেক্টিভ-সি কোড ব্যবহার করেছি এবং কয়েকটি লাইন সরিয়েছি যা আমরা ভুল করেছি (ঘোরানো বক্স স্টাফ) এবং এটি ইউআইআইমেজ এর জন্য একটি এক্সটেনশনে রূপান্তরিত করেছি।

extension UIImage {

func rotate(byDegrees degree: Double) -> UIImage {
    let radians = CGFloat(degree*M_PI)/180.0 as CGFloat
    let rotatedSize = self.size
    let scale = UIScreen.mainScreen().scale
    UIGraphicsBeginImageContextWithOptions(rotatedSize, false, scale)
    let 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 );
    let newImage = UIGraphicsGetImageFromCurrentImageContext()

    return newImage
}
}

Comments

দুর্দান্ত কাজ! আমি এটিকে কিছুটা পরিবর্তন করেছি যাতে আমি প্রস্থ এবং উচ্চতা অদলবদল করতে পারি: ফানক রোটেট (বাই ডিগ্রি ডিগ্রি: ডাবল, টো সাইজ: সিজি সাইজ? = নীল) -> ইউআইআইমেজ {ঘোরানো সাইজ = টু সাইজ ?? স্ব.সাইজ

— এডউইন

এটি চিত্রের সীমাটি ঠিকঠাকভাবে সেট করে না। আপনি একটি ঘোরানো চিত্রটি শেষ করবেন যা মূল সীমাটি উপচে পড়েছে।

— ডেভিন বি

এটার জন্য অনেক ধন্যবাদ। আশ্চর্যজনক যে আমি আজ এটিতে কতটা সময় ব্যয় করেছি।

— ক্রিসএইচ

Answer 11

সুইফট 3 ইউআইআইমেজ এক্সটেনশন:

func fixOrientation() -> UIImage {

    // No-op if the orientation is already correct
    if ( self.imageOrientation == .up ) {
        return self;
    }

    // We need to calculate the proper transformation to make the image upright.
    // We do it in 2 steps: Rotate if Left/Right/Down, and then flip if Mirrored.
    var transform: CGAffineTransform = .identity

    if ( self.imageOrientation == .down || self.imageOrientation == .downMirrored ) {
        transform = transform.translatedBy(x: self.size.width, y: self.size.height)
        transform = transform.rotated(by: .pi)
    }

    if ( self.imageOrientation == .left || self.imageOrientation == .leftMirrored ) {
        transform = transform.translatedBy(x: self.size.width, y: 0)
        transform = transform.rotated(by: .pi/2)
    }

    if ( self.imageOrientation == .right || self.imageOrientation == .rightMirrored ) {
        transform = transform.translatedBy(x: 0, y: self.size.height);
        transform = transform.rotated(by: -.pi/2);
    }

    if ( self.imageOrientation == .upMirrored || self.imageOrientation == .downMirrored ) {
        transform = transform.translatedBy(x: self.size.width, y: 0)
        transform = transform.scaledBy(x: -1, y: 1)
    }

    if ( self.imageOrientation == .leftMirrored || self.imageOrientation == .rightMirrored ) {
        transform = transform.translatedBy(x: self.size.height, y: 0);
        transform = transform.scaledBy(x: -1, y: 1);
    }

    // Now we draw the underlying CGImage into a new context, applying the transform
    // calculated above.
    let ctx: CGContext = CGContext(data: nil, width: Int(self.size.width), height: Int(self.size.height),
                                   bitsPerComponent: self.cgImage!.bitsPerComponent, bytesPerRow: 0,
                                   space: self.cgImage!.colorSpace!,
                                   bitmapInfo: self.cgImage!.bitmapInfo.rawValue)!;

    ctx.concatenate(transform)

    if ( self.imageOrientation == .left ||
        self.imageOrientation == .leftMirrored ||
        self.imageOrientation == .right ||
        self.imageOrientation == .rightMirrored ) {
        ctx.draw(self.cgImage!, in: CGRect(x: 0.0,y: 0.0,width: self.size.height,height: self.size.width))
    } else {
        ctx.draw(self.cgImage!, in: CGRect(x: 0.0,y: 0.0,width: self.size.width,height: self.size.height))
    }

    // And now we just create a new UIImage from the drawing context and return it
    return UIImage(cgImage: ctx.makeImage()!)
}

Answer 12

RawMean এর উত্তরের সুইফ্ট 4.2 সংস্করণ :

extension UIImage {

func rotated(byDegrees degree: Double) -> UIImage {
    let radians = CGFloat(degree * .pi) / 180.0 as CGFloat
    let rotatedSize = self.size
    let scale = UIScreen.main.scale
    UIGraphicsBeginImageContextWithOptions(rotatedSize, false, scale)
    let bitmap = UIGraphicsGetCurrentContext()
    bitmap?.translateBy(x: rotatedSize.width / 2, y: rotatedSize.height / 2)
    bitmap?.rotate(by: radians)
    bitmap?.scaleBy(x: 1.0, y: -1.0)
    bitmap?.draw(
        self.cgImage!,
        in: CGRect.init(x: -self.size.width / 2, y: -self.size.height / 2 , width: self.size.width, height: self.size.height))
    let newImage = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext() // this is needed
    return newImage!
}

}

Comments

কোনও চিত্রের ওজনটি বেলুনগুলি। আমি আমার পরীক্ষা: আবর্তনের আগে ============================== প্রস্থ 3024.0 উচ্চতা 3024.0 আকার 4952213 বাইট ======= ======================= পরে আবর্তন ========================= ===== প্রস্থ 3024.0 উচ্চতা 3024.0 আকার 35191195 বাইট

— ==============================

Answer 13

আমি এই কোডটি চেষ্টা করি, এটি কাজ করে এবং http://www.catamount.com/blog/1015/uiimage-extensions-for-cutting-scaling-and-rotating-uiimages/ থেকে নিয়েছি

+ (UIImage *)rotateImage:(UIImage*)src byRadian:(CGFloat)radian
{
    // calculate the size of the rotated view's containing box for our drawing space
    UIView *rotatedViewBox = [[UIView alloc] initWithFrame:CGRectMake(0,0, src.size.width, src.size.height)];
    CGAffineTransform t = CGAffineTransformMakeRotation(radian);
    rotatedViewBox.transform = t;
    CGSize rotatedSize = rotatedViewBox.frame.size;

    // Create the bitmap context
    UIGraphicsBeginImageContext(rotatedSize);
    CGContextRef bitmap = UIGraphicsGetCurrentContext();

    // Move the origin to the middle of the image so we will rotate and scale around the center.
    CGContextTranslateCTM(bitmap, rotatedSize.width/2, rotatedSize.height/2);

    //   // Rotate the image context
    CGContextRotateCTM(bitmap, radian);

    // Now, draw the rotated/scaled image into the context
    CGContextScaleCTM(bitmap, 1.0, -1.0);
    CGContextDrawImage(bitmap, CGRectMake(-src.size.width / 2, -src.size.height / 2, src.size.width, src.size.height), [src CGImage]);

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

Answer 14

হার্ডি ম্যাকিয়ার কোডের উপর ভিত্তি করে অন্য উত্তরগুলিতে সামান্য পরিবর্তন। UIViewঘোরানো চিত্রের সীমানা আয়তক্ষেত্র গণনা করার জন্য একটি সম্পূর্ণ অবজেক্ট তৈরি করার দরকার নেই । ব্যবহার করে চিত্রের আয়তক্ষেত্রে কেবল একটি ঘোরানো ট্রান্সফর্ম প্রয়োগ করুন CGRectApplyAffineTransform।

static CGFloat DegreesToRadians(CGFloat degrees) {return degrees * M_PI / 180;}
static CGFloat RadiansToDegrees(CGFloat radians) {return radians * 180/M_PI;}


- (CGSize)rotatedImageSize:(CGFloat)degrees
{
    CGAffineTransform t = CGAffineTransformMakeRotation(DegreesToRadians(degrees));
    CGRect originalImageRect = CGRectMake(0, 0, self.size.width, self.size.height);
    CGRect rotatedImageRect = CGRectApplyAffineTransform(originalImageRect, t);
    CGSize rotatedSize = rotatedImageRect.size;

    return rotatedSize;
}

- (UIImage*)imageRotatedByDegrees:(CGFloat)degrees
{
    // calculate the size of the rotated view's containing box for our drawing space
    CGSize rotatedSize = [self rotatedImageSize:degrees];

    // Create the bitmap context
    UIGraphicsBeginImageContext(rotatedSize);
    CGContextRef bitmap = UIGraphicsGetCurrentContext();

    // Move the origin to the middle of the image so we will rotate and scale around the center.
    CGContextTranslateCTM(bitmap, rotatedSize.width/2, rotatedSize.height/2);

    //   // Rotate the image context
    CGContextRotateCTM(bitmap, DegreesToRadians(degrees));

    // Now, draw the rotated/scaled image into the context
    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;
}

Answer 15

"টিন্ট ইউইমেজে গ্রেস্কেল" এটির জন্য উপযুক্ত গুগল-ফু বলে মনে হচ্ছে

সরাসরি আমি পেয়েছি:

https://discussions.apple.com/message/8104516?messageID=8104516ꩄ

https://discussions.apple.com/thread/2751445?start=0&tstart=0

আমি কীভাবে আইফোনটিতে প্রোগ্রামটিমে কোনও চিত্র আঁকিব?

Answer 16

আমি Peter Sarnowskiএর উত্তরের সরল কমনীয়তা পছন্দ করি তবে আপনি যখন EXIFমেটাডেটা এবং এর মতো নির্ভর করতে পারবেন না তখন এটি সমস্যার কারণ হতে পারে । এমন পরিস্থিতিতে যেখানে আপনার আসল চিত্রের ডেটাটি ঘোরানো দরকার আমি এই জাতীয় কিছু প্রস্তাব করব:

- (UIImage *)rotateImage:(UIImage *) img
{
    CGSize imgSize = [img size];
    UIGraphicsBeginImageContext(imgSize);
    CGContextRef context = UIGraphicsGetCurrentContext();
    CGContextRotateCTM(context, M_PI_2);
    CGContextTranslateCTM(context, 0, -640);
    [img drawInRect:CGRectMake(0, 0, imgSize.height, imgSize.width)];
    UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return newImage;
}

উপরের কোড যার অভিযোজন হয় একটি চিত্র লাগে Landscape(যদি এটা মনে করতে পারেন না Landscape Leftবা Landscape Right) এবং rotates মধ্যে Portrait। এটি একটি উদাহরণ যা আপনার প্রয়োজনের জন্য পরিবর্তন করা যেতে পারে।

আপনি যে কী যুক্তি দিয়ে খেলতে CGContextRotateCTM(context, M_PI_2)হবে তা হ'ল যেখানে আপনি কতটা ঘোরাতে চান তা স্থির করেন, তবে তারপরে আপনাকে নিশ্চিত করতে হবে যে চিত্রটি এখনও স্ক্রিনে টানছে এটি ব্যবহার করেCGContextTranslateCTM(context, 0, -640) । এই চিত্রটি খালি পর্দা নয় আপনি চিত্রটি দেখেছেন তা নিশ্চিত করার জন্য এই শেষ অংশটি বেশ গুরুত্বপূর্ণ।

আরও তথ্যের জন্য উত্সটি পরীক্ষা করে দেখুন ।

Comments

ভাঙা লিঙ্কের জন্য ডাউনভোট এবং -640 ম্যাজিক সংখ্যাটির কোনও ব্যাখ্যা নেই। ঠিক করা হলে বিপরীত হবে।

— Nate

Answer 17

আকার পরিবর্তন-এ-ইউআইইমেজ-দ্য-ডাই-র পদ্ধতিতে এটি করার জন্য অনেক কোড স্যাম্পলগুলির কয়েকটি ব্যাখ্যা করে এবং ইউআইআইমেজগুলি মোকাবেলায় সহায়তা করার জন্য কিছু কোড স্নিপেট রয়েছে - ইউআইআইমেজ + রাইজ.এইমে ব্যক্তিগত সহায়ক পদ্ধতিটি অনুমতি দেওয়ার জন্য একটি রূপান্তর গ্রহণ করে ঘূর্ণন, যাতে আপনার এটি প্রকাশের দরকার হবে একটি সর্বজনীন ইন্টারফেস হিসাবে।

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

এটি সেই ফাইলটির লাইসেন্স:

// Created by Trevor Harmon on 8/5/09.
// Free for personal or commercial use, with or without modification.
// No warranty is expressed or implied.

Answer 18

এনওয়াইএক্সআইমেজকিট নামে একটি অত্যন্ত দক্ষ ইউআইআইমেজ বিভাগ আছে। এটি যত তাড়াতাড়ি দ্রুত হতে ভিডিএসপি, কোরআইজেজ এবং ভিআইমেজ ব্যবহার করে। এটিতে একটি ইউআইআইমেজ + আবর্তিত বিভাগ রয়েছে যা আমার দিনটি বাঁচিয়েছে :)

https://github.com/Nyx0uf/NYXImagesKit

Answer 19

সুইফ্টের জন্য: এখানে ইউআইআইজেমে একটি সাধারণ বর্ধন রয়েছে:

//ImageRotation.swift

import UIKit

extension UIImage {  
    public func imageRotatedByDegrees(degrees: CGFloat, flip: Bool) -> UIImage {
        let radiansToDegrees: (CGFloat) -> CGFloat = {
            return $0 * (180.0 / CGFloat(M_PI))
        }
        let degreesToRadians: (CGFloat) -> CGFloat = {
            return $0 / 180.0 * CGFloat(M_PI)
        }

        // calculate the size of the rotated view's containing box for our drawing space
        let rotatedViewBox = UIView(frame: CGRect(origin: CGPointZero, size: size))
        let t = CGAffineTransformMakeRotation(degreesToRadians(degrees));
        rotatedViewBox.transform = t
        let rotatedSize = rotatedViewBox.frame.size

        // Create the bitmap context
        UIGraphicsBeginImageContext(rotatedSize)
        let bitmap = UIGraphicsGetCurrentContext()

        // Move the origin to the middle of the image so we will rotate and scale around the center.
        CGContextTranslateCTM(bitmap, rotatedSize.width / 2.0, rotatedSize.height / 2.0);

        //   // Rotate the image context
        CGContextRotateCTM(bitmap, degreesToRadians(degrees));

        // Now, draw the rotated/scaled image into the context
        var yFlip: CGFloat

        if(flip){
            yFlip = CGFloat(-1.0)
        } else {
            yFlip = CGFloat(1.0)
        }

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

        let newImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()

        return newImage
    }
}

( উত্স )

এটি দিয়ে ব্যবহার করুন:

rotatedPhoto = rotatedPhoto?.imageRotatedByDegrees(90, flip: false) 

প্রাক্তন কোনও চিত্র ঘোরান এবং ফ্লিপটি সত্য হিসাবে সেট করা থাকলে তা ফ্লিপ করবেন।

Comments

আপনি দয়া করে কিছুটা ব্যাখ্যা করতে পারেন?

— জি.আবিহিসেক

এটি কোনও কারণে অ্যাসপেক্ট রেশিওতে

— গণ্ডগোলিত