कैसे एक UIImage की अस्पष्टता / अल्फा सेट करने के लिए?

Question

मुझे पता है कि आप इसे UIImageView के साथ कर सकते हैं, लेकिन क्या इसे UIImageView किया जा सकता है? मैं UIImageView की एनीमेशन इमेजेज एरे प्रॉपर्टी को एक ही इमेज की एक सरणी होना चाहता हूं, लेकिन अलग-अलग ओपेसिटीज के साथ। विचार?

Answer 1

मुझे बस ऐसा करने की आवश्यकता थी, लेकिन सोचा कि स्टीवन का समाधान धीमा होगा। यह आशा है कि ग्राफिक्स HW का उपयोग करना चाहिए। UIImage पर एक श्रेणी बनाएँ:

- (UIImage *)imageByApplyingAlpha:(CGFloat) alpha {
    UIGraphicsBeginImageContextWithOptions(self.size, NO, 0.0f);

    CGContextRef ctx = UIGraphicsGetCurrentContext();
    CGRect area = CGRectMake(0, 0, self.size.width, self.size.height);

    CGContextScaleCTM(ctx, 1, -1);
    CGContextTranslateCTM(ctx, 0, -area.size.height);

    CGContextSetBlendMode(ctx, kCGBlendModeMultiply);

    CGContextSetAlpha(ctx, alpha);

    CGContextDrawImage(ctx, area, self.CGImage);

    UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();

    UIGraphicsEndImageContext();

    return newImage;
}

Comments

यह भी याद नहीं है कि मुझे इसकी आवश्यकता क्यों है :)

— मार्टी

महान समाधान! थैंक यू निक!

— क्रिस्टोफर

बस सुनिश्चित करें कि आप UIGraphicsBeginImageContextWithOptions को मुख्य थ्रेड पर बुला रहे हैं क्योंकि बैकग्राउंड रेंडरिंग अप्रत्याशित होगी।

— स्टीवन वेल्टेमा

Apple के अनुसार आप iOS 4 और बाद के किसी भी धागे पर UIGraphicsBeginImageContextWithOptions कॉल कर सकते हैं।

— चींटियों

महान काम करता है, एक टन धन्यवाद। आईओएस विकास के आसपास के लॉजिस्टिक्स के अन्य न्यूबियों के लिए, यहां UIImage के लिए एक श्रेणी बनाने के चरण दिए गए हैं। 1. अपने प्रोजेक्ट के डायरेक्टर पर राइट क्लिक करें और न्यू फाइल को चुनें। 2. दिखाई देने वाली स्क्रीन में, Objective-C श्रेणी फ़ाइल प्रकार का चयन करें। 3. .m फ़ाइल में उत्तर का कोड और .h फ़ाइल में विधि के लिए एक घोषणा जोड़ें। 4. उस फ़ाइल में जो छवि का उपयोग पारदर्शी होने के लिए करती है, फ़ाइल को #import करें। 5. UIImage के उदाहरण पर विधि imageByApplyingAlpha का उपयोग करें।

— डैनी

Answer 2

इसके दृश्य की अस्पष्टता निर्धारित करें जो इसमें दिखाया गया है।

UIImageView *imageView = [[UIImageView alloc] initWithImage:[UIImage imageWithName:@"SomeName.png"]];
imageView.alpha = 0.5; //Alpha runs from 0.0 to 1.0

एक एनीमेशन में यह प्रयोग करें। आप एक अवधि के लिए एक एनीमेशन में अल्फा बदल सकते हैं।

[UIView beginAnimations:nil context:NULL];
[UIView setAnimationDuration:1.0];
//Set alpha
[UIView commitAnimations];

Comments

हाँ, मैं सोच रहा था कि मैं इसे एक टाइमर के साथ ऐसा कर सकता हूँ लगातार अस्पष्टता को बदलने के लिए, बस सोचा था कि एनीमेशन चित्रों की संपत्ति के लिए एक सरणी रखना बहुत आसान होगा ताकि यह अपने आप ही चेतन हो जाए।

— मार्टी

आप इसे एनीमेशन प्रतिनिधि के साथ दिल की धड़कन की तरह 'इन' और 'आउट' कर सकते हैं। टाइमर का उपयोग न करें, एनीमेशन अल्फा को सुचारू रूप से बदल देगा। सौभाग्य।

— मैट स्टिज्लार्ट

यह केवल तभी काम करता है जब डेवलपर UIImageView का उपयोग कर रहा हो। प्रश्न स्पष्ट रूप से कहता है कि ऐसा नहीं है।

— राउल हर्टा

यह एक काइलेयर में प्रस्तुत UIImage के साथ काम करता है, केवल आप परत को सेट करते हैं। छवि को बिल्कुल संशोधित किए बिना। धन्यवाद मैट!

— क्रिस

महान! काम करता है UIButton, वास्तव में मुझे क्या चाहिए।

— NecipAllef

Answer 3

एलेक्सी इश्कोव के जवाब पर आधारित है, लेकिन स्विफ्ट में

मैंने UIImage क्लास के एक्सटेंशन का उपयोग किया।

स्विफ्ट 2:

UIImage एक्सटेंशन:

extension UIImage {
    func imageWithAlpha(alpha: CGFloat) -> UIImage {
        UIGraphicsBeginImageContextWithOptions(size, false, scale)
        drawAtPoint(CGPointZero, blendMode: .Normal, alpha: alpha)
        let newImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        return newImage
    }
}

काम में लाना:

let image = UIImage(named: "my_image")
let transparentImage = image.imageWithAlpha(0.5)

स्विफ्ट 3/4/5:

ध्यान दें कि यह कार्यान्वयन एक वैकल्पिक UIImage देता है। इसकी वजह है स्विफ्ट 3UIGraphicsGetImageFromCurrentImageContext अब एक वैकल्पिक रिटर्न है। यदि संदर्भ शून्य है या क्या नहीं बनाया गया है, तो यह मान शून्य हो सकता है UIGraphicsBeginImageContext।

UIImage एक्सटेंशन:

extension UIImage {
    func image(alpha: CGFloat) -> UIImage? {
        UIGraphicsBeginImageContextWithOptions(size, false, scale)
        draw(at: .zero, blendMode: .normal, alpha: alpha)
        let newImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        return newImage
    }
}

काम में लाना:

let image = UIImage(named: "my_image")
let transparentImage = image?.image(alpha: 0.5)

Comments

मैं इस Swift 3संस्करण को पसंद करता हूं ।

— अचोइलियू

धन्यवाद। यह स्विफ्ट 4 में समान काम करता है, मैंने इसे प्रतिबिंबित करने के लिए उत्तर अपडेट किया।

— जीशान

ब्रावो सर, ब्रावो

— रयान ब्रॉडी

Answer 4

बहुत आसान उपाय है:

- (UIImage *)tranlucentWithAlpha:(CGFloat)alpha
{
    UIGraphicsBeginImageContextWithOptions(self.size, NO, self.scale);
    [self drawAtPoint:CGPointZero blendMode:kCGBlendModeNormal alpha:alpha];
    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return image;
}

Comments

संभवतः स्वीकृत उत्तर होना चाहिए था। परिणाम प्राप्त करने का सबसे तेज़ / सबसे प्रभावी तरीका

— विल वॉन उल्रिच

Answer 5

मुझे लगता है कि यह काफी देर हो चुकी है, लेकिन मुझे कुछ इस तरह की आवश्यकता थी इसलिए मैंने ऐसा करने के लिए एक त्वरित और गंदे तरीके को उड़ा दिया।

+ (UIImage *) image:(UIImage *)image withAlpha:(CGFloat)alpha{

    // Create a pixel buffer in an easy to use format
    CGImageRef imageRef = [image CGImage];
    NSUInteger width = CGImageGetWidth(imageRef);
    NSUInteger height = CGImageGetHeight(imageRef);
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();

    UInt8 * m_PixelBuf = malloc(sizeof(UInt8) * height * width * 4);

    NSUInteger bytesPerPixel = 4;
    NSUInteger bytesPerRow = bytesPerPixel * width;
    NSUInteger bitsPerComponent = 8;
    CGContextRef context = CGBitmapContextCreate(m_PixelBuf, width, height,
                                                 bitsPerComponent, bytesPerRow, colorSpace,
                                                 kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);

    CGContextDrawImage(context, CGRectMake(0, 0, width, height), imageRef);
    CGContextRelease(context);

    //alter the alpha
    int length = height * width * 4;
    for (int i=0; i<length; i+=4)
    {
        m_PixelBuf[i+3] =  255*alpha;
    }


    //create a new image
    CGContextRef ctx = CGBitmapContextCreate(m_PixelBuf, width, height,
                                                 bitsPerComponent, bytesPerRow, colorSpace,
                                                 kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);

    CGImageRef newImgRef = CGBitmapContextCreateImage(ctx);  
    CGColorSpaceRelease(colorSpace);
    CGContextRelease(ctx);  
    free(m_PixelBuf);

    UIImage *finalImage = [UIImage imageWithCGImage:newImgRef];
    CGImageRelease(newImgRef);  

    return finalImage;
}

Comments

बेहतर नाम होगाsetImage:withAlpha:

— अलेक्जेंडर

सेट आमतौर पर संपत्तियों को संदर्भित करता है, किसी तरह से रिसीवर की स्थिति को बदल देता है। इसे नाम देना बेहतर होगा image:withAlpha:?

— जोनाथन।

हाँ। इसके अलावा कॉलिंग सेट नई छवि को वापस करने के बजाय, उसी ऑब्जेक्ट को सेट करने में लागू होता है।

— प्रणाली

Answer 6

हे Xamarin उपयोगकर्ता से हे धन्यवाद! :) यहाँ यह c # के लिए अनुवादित है

//***************************************************************************
public static class ImageExtensions
//***************************************************************************
{
    //-------------------------------------------------------------
    public static UIImage WithAlpha(this UIImage image, float alpha)  
    //-------------------------------------------------------------
        {
        UIGraphics.BeginImageContextWithOptions(image.Size,false,image.CurrentScale);
        image.Draw(CGPoint.Empty, CGBlendMode.Normal, alpha);
        var newImage = UIGraphics.GetImageFromCurrentImageContext();
        UIGraphics.EndImageContext();
        return newImage;
        }

}

उपयोग उदाहरण:

var MySupaImage = UIImage.FromBundle("opaquestuff.png").WithAlpha(0.15f);

Answer 7

दूसरों के रूप में एक ही परिणाम, अलग शैली:

extension UIImage {

    func withAlpha(_ alpha: CGFloat) -> UIImage {
        return UIGraphicsImageRenderer(size: size).image { _ in
            draw(at: .zero, blendMode: .normal, alpha: alpha)
        }
    }

}

Answer 8

स्विफ्ट 5:

extension UIImage {
  func withAlphaComponent(_ alpha: CGFloat) -> UIImage? {
    UIGraphicsBeginImageContextWithOptions(size, false, scale)
    defer { UIGraphicsEndImageContext() }

    draw(at: .zero, blendMode: .normal, alpha: alpha)
    return UIGraphicsGetImageFromCurrentImageContext()
  }
}

Answer 9

यदि आप धातु प्रतिपादन के साथ प्रयोग कर रहे हैं और आप पहले उत्तर में imageByApplyingAlpha द्वारा उत्पन्न CGImage निकाल रहे हैं, तो आप एक धातु प्रतिपादन के साथ समाप्त हो सकते हैं जो आपकी अपेक्षा से बड़ा है। धातु के साथ प्रयोग करते समय, आप छवि में कोड की एक पंक्ति बदलना चाह सकते हैं।

    UIGraphicsBeginImageContextWithOptions (self.size, NO, 1.0f);
//  UIGraphicsBeginImageContextWithOptions (self.size, NO, 0.0f);

यदि आप iPhone 11 प्रो मैक्स की तरह 3.0 के पैमाने कारक के साथ एक उपकरण का उपयोग कर रहे हैं, तो ऊपर दिखाया गया 0.0 पैमाने कारक आपको एक CGImage देगा जो आपकी अपेक्षा से तीन गुना बड़ा है। स्केल फैक्टर को 1.0 में बदलने से किसी भी स्केलिंग से बचना चाहिए।

उम्मीद है, इस जवाब से शुरुआती लोगों को काफी नुकसान होगा।