2012-01-06 21 views
7

में परिवर्तन पर यूआईएममेज को धुंधला करें मैंने गॉसियन ब्लर की कोशिश की है और स्टैक ओवरफ्लो पर सभी प्रश्नों की जांच की है, लेकिन उनमें से कोई भी मेरे क्रैश मुद्दे को हल नहीं करता है। कृपया मदद करें कि गॉसियन ब्लर एल्गोरिदम के अलावा अन्य छवि को धुंधला करने का कोई अन्य तरीका है। मेरा छवि आकार 768x1024 है और लूप 2 * 1024 * 768 बार के लिए पुनरावृत्त होते हैं और यह संभव नहीं है।स्लाइडर

CGContextRef NYXImageCreateARGBBitmapContext(const size_t width, const size_t height, const size_t bytesPerRow) 
{ 
/// Use the generic RGB color space 
/// We avoid the NULL check because CGColorSpaceRelease() NULL check the value anyway, and worst case scenario = fail to create context 
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB(); 

/// Create the bitmap context, we want pre-multiplied ARGB, 8-bits per component 
CGContextRef bmContext = CGBitmapContextCreate(NULL, width, height, 8/*Bits per component*/, bytesPerRow, colorSpace, kCGBitmapByteOrderDefault | kCGImageAlphaPremultipliedFirst); 

CGColorSpaceRelease(colorSpace); 

return bmContext; 
} 



-(UIImage*)blurredImageUsingGaussFactor:(NSUInteger)gaussFactor andPixelRadius:(NSUInteger)pixelRadius 
{ 
CGImageRef cgImage = self.CGImage; 
const size_t originalWidth = CGImageGetWidth(cgImage); 
const size_t originalHeight = CGImageGetHeight(cgImage); 
const size_t bytesPerRow = originalWidth * 4; 
CGContextRef context = NYXImageCreateARGBBitmapContext(originalWidth, originalHeight, bytesPerRow); 
if (!context) 
    return nil; 

unsigned char *srcData, *destData, *finalData; 

size_t width = CGBitmapContextGetWidth(context); 
size_t height = CGBitmapContextGetHeight(context); 
size_t bpr = CGBitmapContextGetBytesPerRow(context); 
size_t bpp = CGBitmapContextGetBitsPerPixel(context)/8; 
CGRect rect = {{0.0f, 0.0f}, {width, height}}; 

CGContextDrawImage(context, rect, cgImage); 

// Now we can get a pointer to the image data associated with the bitmap 
// context. 
srcData = (unsigned char*)CGBitmapContextGetData(context); 
if (srcData != NULL) 
{ 
    size_t dataSize = bpr * height; 
    finalData = malloc(dataSize); 
    destData = malloc(dataSize); 
    memcpy(finalData, srcData, dataSize); 
    memcpy(destData, srcData, dataSize); 

    int sums[gaussFactor]; 
    size_t i, /*x, y,*/ k; 
    int gauss_sum = 0; 
    size_t radius = pixelRadius * 2 + 1; 
    int *gauss_fact = malloc(radius * sizeof(int)); 

    for (i = 0; i < pixelRadius; i++) 
    { 
     gauss_fact[i] = 1 + (gaussFactor * i); 
     gauss_fact[radius - (i + 1)] = 1 + (gaussFactor * i); 
     gauss_sum += (gauss_fact[i] + gauss_fact[radius - (i + 1)]); 
    } 
    gauss_fact[(radius - 1)/2] = 1 + (gaussFactor*pixelRadius); 
    gauss_sum += gauss_fact[(radius - 1)/2]; 

    unsigned char *p1, *p2, *p3; 

    for (size_t y = 0; y < height; y++) 
    { 
     for (size_t x = 0; x < width; x++) 
     { 
      p1 = srcData + bpp * (y * width + x); 
      p2 = destData + bpp * (y * width + x); 

      for (i = 0; i < gaussFactor; i++) 
       sums[i] = 0; 

      for (k = 0; k < radius ; k++) 
      { 
       if ((y - ((radius - 1) >> 1) + k) < height) 
        p1 = srcData + bpp * ((y - ((radius - 1) >> 1) + k) * width + x); 
       else 
        p1 = srcData + bpp * (y * width + x); 

       for (i = 0; i < bpp; i++) 
        sums[i] += p1[i] * gauss_fact[k]; 

      } 
      for (i = 0; i < bpp; i++) 
       p2[i] = sums[i]/gauss_sum; 
     } 
    } 
    for (size_t y = 0; y < height; y++) 
    { 
     for (size_t x = 0; x < width; x++) 
     { 
      p2 = destData + bpp * (y * width + x); 
      p3 = finalData + bpp * (y * width + x); 

      for (i = 0; i < gaussFactor; i++) 
       sums[i] = 0; 

      for(k = 0; k < radius ; k++) 
      { 
       if ((x - ((radius - 1) >> 1) + k) < width) 
        p1 = srcData + bpp * (y * width + (x - ((radius - 1) >> 1) + k)); 
       else 
        p1 = srcData + bpp * (y * width + x); 

       for (i = 0; i < bpp; i++) 
        sums[i] += p2[i] * gauss_fact[k]; 

      } 
      for (i = 0; i < bpp; i++) 
      { 
       p3[i] = sums[i]/gauss_sum; 
      } 
     } 
    } 
} 

size_t bitmapByteCount = bpr * height; 

///////Here was the problem.. you had given srcData instead of destData.. Rest all 
//were perfect... 
CGDataProviderRef dataProvider = CGDataProviderCreateWithData(NULL, destData, bitmapByteCount, NULL); 

CGImageRef blurredImageRef = CGImageCreate(width, height, CGBitmapContextGetBitsPerComponent(context), CGBitmapContextGetBitsPerPixel(context), CGBitmapContextGetBytesPerRow(context), CGBitmapContextGetColorSpace(context), CGBitmapContextGetBitmapInfo(context), dataProvider, NULL, true, kCGRenderingIntentDefault); 

CGDataProviderRelease(dataProvider); 
CGContextRelease(context); 
if (destData) 
    free(destData); 
if (finalData) 
    free(finalData); 

UIImage* retUIImage = [UIImage imageWithCGImage:blurredImageRef]; 

CGImageRelease(blurredImageRef); 

return retUIImage; 
} 
+0

पोस्ट कोड के लिए सिर्फ इतना है कि रीडमी पर लिखने में कोई त्रुटि है, "सामान्यीकृत" - इस तरह आप इसे –

+0

ठीक करने में सहायता प्राप्त कर सकते हैं ठीक है, मैं बस अपना कोड पोस्ट करता हूं। – Leena

+0

इस SO प्रश्न की जांच करें: http://stackoverflow.com/questions/1356250/iphone-blur-uiimage –

उत्तर

15

मैंने यूआईएममेज में एक छोटा स्टैकब्लर एक्सटेंशन बनाया है। StackBlur GaussianBlur के करीब है लेकिन बहुत तेज़ है।

पर यह जाँच करें: https://github.com/tomsoft1/StackBluriOS


छोटे नोट ... आपकी गाऊसी धुंधला कार्यान्वयन के लिए "सामान्य"

+0

धन्यवाद यह वास्तव में ठीक काम करता है और आसानी से काम करता है .... – Leena

+0

इससे मुझे बहुत मदद मिली। बहुत धन्यवाद – Meet

+1

बहुत अच्छा काम करता है, क्या आप आईओएस पर किसी भी स्टैकब्लर कार्यान्वयन के बारे में जानते हैं जो पारदर्शिता को संभालने में मदद करता है? – mmc

2

किसी छवि को धुंधला करने के बारे में सुनिश्चित नहीं है। यह मदद कर सकता है कि आप blur an UIImageView or any view चाहते हैं।

UIView *myView = self.theImageView; 
    CALayer *layer = [myView layer]; 
    [layer setRasterizationScale:0.25]; 
    [layer setShouldRasterize:YES]; 

आप के लिए 1.

[layer setRasterizationScale:1.0]; 

अद्यतन रैस्टराइज़ेशन पैमाने वापस निर्धारित करके इसे पूर्ववत कर सकते हैं:

एप्पल नीचे नमूना कोड एक कलंक/तेज प्रभाव भी शामिल है। (ओपन जीएल का उपयोग करके) देखें कि यह मदद करता है, http://developer.apple.com/library/ios/#samplecode/GLImageProcessing/Introduction/Intro.html

+0

मैं अपनी धुंधली छवि को सहेजना चाहता हूं। – Leena

+0

के, एक नमूना कोड के लिंक जोड़ा गया। देखें कि क्या यह आपकी मदद करता है। – sElanthiraiyan

+0

मैंने कोशिश की है लेकिन यह गॉसियन ब्लर – Leena

1

आप जो चाहते हैं वह एक बॉक्स ब्लर एल्गोरिदम है। यह गॉसियन धुंध से लगभग 10 गुना तेज है और अच्छे परिणाम पैदा करता है। मेरे पास एंड्रॉइड पर चल रहा कोड है, मैंने अभी तक इसे आईओएस पर पोर्ट नहीं किया है। यहां source है।

आईओएस में पोर्ट के लिए केवल 10 मिनट लगना चाहिए। फ़ंक्शन इस तरह काम करेंगे, आपको केवल छवि बाइट्स तक पहुंचने की आवश्यकता है (जैसा कि आप उपरोक्त स्रोत कोड में कर रहे हैं) और उन्हें फ़ंक्शंस में फ़ीड करें।

+0

के रूप में उतना अच्छा नहीं है, ठीक है, मैं कोशिश करता हूं, मदद के लिए धन्यवाद। – Leena

+0

बॉक्स ब्लर कोर छवि के हिस्से के रूप में उपलब्ध है। – Abizern

+1

बॉक्स ब्लर केवल मैक के लिए उपलब्ध है इस लिंक को चेक करें: -http: //developer.apple.com/library/mac/#documentation/GraphicsImaging/Reference/CoreImageFilterReference/Reference/reference.html#//apple_ref/doc/uid/ टीपी 30000136-SW69 – Leena

संबंधित मुद्दे