Imagen central

Dado que la imagen de la captura de pantalla es estática, puede usar CIGaussianBlur desde Core Image (requiere iOS 6). Aquí está la muestra: https://github.com/evanwdavis/Fun-with-Masks/blob/master/Fun%20with%20Masks/EWDBlurExampleVC.m

Tenga en cuenta que esto es más lento que las otras opciones en esta página.

#import <QuartzCore/QuartzCore.h>

- (UIImage*) blur:(UIImage*)theImage
{   
    // ***********If you need re-orienting (e.g. trying to blur a photo taken from the device camera front facing camera in portrait mode)
    // theImage = [self reOrientIfNeeded:theImage];

    // create our blurred image
    CIContext *context = [CIContext contextWithOptions:nil];
    CIImage *inputImage = [CIImage imageWithCGImage:theImage.CGImage];

    // setting up Gaussian Blur (we could use one of many filters offered by Core Image)
    CIFilter *filter = [CIFilter filterWithName:@"CIGaussianBlur"];
    [filter setValue:inputImage forKey:kCIInputImageKey];
    [filter setValue:[NSNumber numberWithFloat:15.0f] forKey:@"inputRadius"];
    CIImage *result = [filter valueForKey:kCIOutputImageKey];

    // CIGaussianBlur has a tendency to shrink the image a little, 
    // this ensures it matches up exactly to the bounds of our original image
    CGImageRef cgImage = [context createCGImage:result fromRect:[inputImage extent]];

    UIImage *returnImage = [UIImage imageWithCGImage:cgImage];//create a UIImage for this function to "return" so that ARC can manage the memory of the blur... ARC can't manage CGImageRefs so we need to release it before this function "returns" and ends.
    CGImageRelease(cgImage);//release CGImageRef because ARC doesn't manage this on its own.

    return returnImage;

    // *************** if you need scaling
    // return [[self class] scaleIfNeeded:cgImage];
}

+(UIImage*) scaleIfNeeded:(CGImageRef)cgimg {
    bool isRetina = [[[UIDevice currentDevice] systemVersion] intValue] >= 4 && [[UIScreen mainScreen] scale] == 2.0;
    if (isRetina) {
        return [UIImage imageWithCGImage:cgimg scale:2.0 orientation:UIImageOrientationUp];
    } else {
        return [UIImage imageWithCGImage:cgimg];
    }
}

- (UIImage*) reOrientIfNeeded:(UIImage*)theImage{

    if (theImage.imageOrientation != UIImageOrientationUp) {

        CGAffineTransform reOrient = CGAffineTransformIdentity;
        switch (theImage.imageOrientation) {
            case UIImageOrientationDown:
            case UIImageOrientationDownMirrored:
                reOrient = CGAffineTransformTranslate(reOrient, theImage.size.width, theImage.size.height);
                reOrient = CGAffineTransformRotate(reOrient, M_PI);
                break;
            case UIImageOrientationLeft:
            case UIImageOrientationLeftMirrored:
                reOrient = CGAffineTransformTranslate(reOrient, theImage.size.width, 0);
                reOrient = CGAffineTransformRotate(reOrient, M_PI_2);
                break;
            case UIImageOrientationRight:
            case UIImageOrientationRightMirrored:
                reOrient = CGAffineTransformTranslate(reOrient, 0, theImage.size.height);
                reOrient = CGAffineTransformRotate(reOrient, -M_PI_2);
                break;
            case UIImageOrientationUp:
            case UIImageOrientationUpMirrored:
                break;
        }

        switch (theImage.imageOrientation) {
            case UIImageOrientationUpMirrored:
            case UIImageOrientationDownMirrored:
                reOrient = CGAffineTransformTranslate(reOrient, theImage.size.width, 0);
                reOrient = CGAffineTransformScale(reOrient, -1, 1);
                break;
            case UIImageOrientationLeftMirrored:
            case UIImageOrientationRightMirrored:
                reOrient = CGAffineTransformTranslate(reOrient, theImage.size.height, 0);
                reOrient = CGAffineTransformScale(reOrient, -1, 1);
                break;
            case UIImageOrientationUp:
            case UIImageOrientationDown:
            case UIImageOrientationLeft:
            case UIImageOrientationRight:
                break;
        }

        CGContextRef myContext = CGBitmapContextCreate(NULL, theImage.size.width, theImage.size.height, CGImageGetBitsPerComponent(theImage.CGImage), 0, CGImageGetColorSpace(theImage.CGImage), CGImageGetBitmapInfo(theImage.CGImage));

        CGContextConcatCTM(myContext, reOrient);

        switch (theImage.imageOrientation) {
            case UIImageOrientationLeft:
            case UIImageOrientationLeftMirrored:
            case UIImageOrientationRight:
            case UIImageOrientationRightMirrored:
                CGContextDrawImage(myContext, CGRectMake(0,0,theImage.size.height,theImage.size.width), theImage.CGImage);
                break;

            default:
                CGContextDrawImage(myContext, CGRectMake(0,0,theImage.size.width,theImage.size.height), theImage.CGImage);
                break;
        }

        CGImageRef CGImg = CGBitmapContextCreateImage(myContext);
        theImage = [UIImage imageWithCGImage:CGImg];

        CGImageRelease(CGImg);
        CGContextRelease(myContext);
    }

    return theImage;
}

Desenfoque de pila (Caja + Gaussiana)

• StackBlur Esto implementa una mezcla de Caja y desenfoque gaussiano. 7 veces más rápido que no acelerado gaussiano, pero no tan feo como el desenfoque de caja. Vea una demostración en aquí (versión de plugin de Java) o aquí (versión de JavaScript). Este algoritmo se utiliza en KDE y Camera+ y otros. No utiliza el marco de Aceleración, pero es rápido.

Accelerate Framework

• En la sesión "Implementing Engaging UI on iOS" de WWDC 2013 Apple explica cómo crear un fondo borroso (a las 14:30) y menciona un método applyLightEffect implemented in the código de ejemplo usando Accelerate.marco.

• GPUImage utiliza sombreadores OpenGL para crear desenfoques dinámicos. Tiene varios tipos de desenfoque: GPUImageBoxBlurFilter, GPUImageFastBlurFilter, GaussianSelectiveBlur, GPUImageGaussianBlurFilter. Incluso hay un GPUImageiOSBlurFilter que "debería replicar completamente el efecto de desenfoque proporcionado por el panel de control de iOS 7" (tweet, artículo ). El artículo es detallado y informativo.

    -(UIImage *)blurryGPUImage:(UIImage *)image withBlurLevel:(NSInteger)blur {
        GPUImageFastBlurFilter *blurFilter = [GPUImageFastBlurFilter new];
        blurFilter.blurSize = blur;
        UIImage *result = [blurFilter imageByFilteringImage:image];
        return result;
    }

• Desde indieambitions.com: Realiza un desenfoque usando vImage. El algoritmo también se utiliza en iOS-RealTimeBlur.

• De Nick Lockwood: https://github.com/nicklockwood/FXBlurView El ejemplo muestra el desenfoque sobre una vista de desplazamiento. Se difumina con dispatch_async, luego se sincroniza para llamar a las actualizaciones con UITrackingRunLoopMode para que el desenfoque no se retrase cuando UIKit da más prioridad al desplazamiento de UIScrollView. Esto se explica en el libro de Nick iOS Core Animation , que por cierto es genial.

• IOS-blur Esto toma la capa de desenfoque de la UIToolbar y la coloca en otro lugar. Apple rechazará tu aplicación si usas este método. Véase https://github.com/mochidev/MDBlurView/issues/4

• Desde el blog de Evadne: LiveFrost: Rápida, Instantánea Síncrona UIView Convolving. Gran código y una gran lectura. Algunas ideas de este post:

  • Utilice una cola serie para acelerar las actualizaciones de CADisplayLink.
  • Reutilice contextos de mapa de bits a menos que cambien los límites.
  • Dibuja imágenes más pequeñas usando -[CALayer renderInContext:] con un factor de escala de 0.5 f.

Otras cosas

Andy Matuschakdijo en Twitter: "ya sabes, muchos de los lugares donde parece que lo estamos haciendo en tiempo real, es estático con trucos inteligentes."

En doubleencore.com dicen " hemos encontró que un radio de desenfoque de 10 pt más un aumento de 10 pt en la saturación imita mejor el efecto de desenfoque de iOS 7 en la mayoría de las circunstancias".

Un vistazo a los encabezados privados de Apple SBFProceduralWallpaperView.

Finalmente, esto no es un desenfoque real, pero recuerde que puede configurar Rasterizationsscale para obtener una imagen pixelada: http://www.dimzzy.com/blog/2010/11/blur-effect-for-uiview /

Decidí publicar una versión escrita de Objective-C de la respuesta aceptada solo para proporcionar más opciones en esta pregunta..

- (UIView *)applyBlurToView:(UIView *)view withEffectStyle:(UIBlurEffectStyle)style andConstraints:(BOOL)addConstraints
{
  //only apply the blur if the user hasn't disabled transparency effects
  if(!UIAccessibilityIsReduceTransparencyEnabled())
  {
    UIBlurEffect *blurEffect = [UIBlurEffect effectWithStyle:style];
    UIVisualEffectView *blurEffectView = [[UIVisualEffectView alloc] initWithEffect:blurEffect];
    blurEffectView.frame = view.bounds;

    [view addSubview:blurEffectView];

    if(addConstraints)
    {
      //add auto layout constraints so that the blur fills the screen upon rotating device
      [blurEffectView setTranslatesAutoresizingMaskIntoConstraints:NO];

      [view addConstraint:[NSLayoutConstraint constraintWithItem:blurEffectView
                                                       attribute:NSLayoutAttributeTop
                                                       relatedBy:NSLayoutRelationEqual
                                                          toItem:view
                                                       attribute:NSLayoutAttributeTop
                                                      multiplier:1
                                                        constant:0]];

      [view addConstraint:[NSLayoutConstraint constraintWithItem:blurEffectView
                                                       attribute:NSLayoutAttributeBottom
                                                       relatedBy:NSLayoutRelationEqual
                                                          toItem:view
                                                       attribute:NSLayoutAttributeBottom
                                                      multiplier:1
                                                        constant:0]];

      [view addConstraint:[NSLayoutConstraint constraintWithItem:blurEffectView
                                                       attribute:NSLayoutAttributeLeading
                                                       relatedBy:NSLayoutRelationEqual
                                                          toItem:view
                                                       attribute:NSLayoutAttributeLeading
                                                      multiplier:1
                                                        constant:0]];

      [view addConstraint:[NSLayoutConstraint constraintWithItem:blurEffectView
                                                       attribute:NSLayoutAttributeTrailing
                                                       relatedBy:NSLayoutRelationEqual
                                                          toItem:view
                                                       attribute:NSLayoutAttributeTrailing
                                                      multiplier:1
                                                        constant:0]];
    }
  }
  else
  {
    view.backgroundColor = [[UIColor blackColor] colorWithAlphaComponent:0.7];
  }

  return view;
}

Las restricciones podrían eliminarse si desea en caso de que solo admita el modo retrato o simplemente agregue una bandera a esta función para usarlas o no..

No creo que se me permita publicar el código, pero la publicación anterior que menciona el código de ejemplo de WWDC es correcta. Aquí está el enlace: https://developer.apple.com/downloads/index.action?name=WWDC%202013

El archivo que está buscando es la categoría en UIImage, y el método es applyLightEffect.

Como señalé anteriormente en un comentario, el Desenfoque de Apple tiene saturación y otras cosas que suceden además del desenfoque. Un simple desenfoque no servirá... si usted está buscando para emular su estilo.

Creo que la solución más fácil para esto es anular UIToolbar, que difumina todo detrás de él en iOS 7. Es bastante astuto, pero es muy simple de implementar, y rápido!

Puedes hacerlo con cualquier vista, solo haz que sea una subclase de UIToolbar en lugar de UIView. Incluso puede hacerlo con una propiedad UIViewController's view, por ejemplo...

1) cree una nueva clase que sea una "subclase de" UIViewController y marque la casilla "Con XIB para interfaz de usuario".

2) Seleccione la vista y vaya al inspector de identidad en el panel derecho (alt-command-3). Cambie la" Clase " a UIToolbar. Ahora vaya al inspector de atributos (alt-command-4) y cambie el color "Background" a "Clear Color".

3) Agregue una subview a la vista principal y conéctela a un IBOutlet en su interfaz. Llámalo backgroundColorView. Se verá algo como esto, como una categoría privada en el archivo de implementación (.m).

@interface BlurExampleViewController ()
@property (weak, nonatomic) IBOutlet UIView *backgroundColorView;
@end

4) Vaya al archivo de implementación del controlador de vista (.m) y cambie el método -viewDidLoad, que se verá como sigue:

- (void)viewDidLoad
{
    [super viewDidLoad];
    self.view.barStyle = UIBarStyleBlack; // this will give a black blur as in the original post
    self.backgroundColorView.opaque = NO;
    self.backgroundColorView.alpha = 0.5;
    self.backgroundColorView.backgroundColor = [UIColor colorWithWhite:0.3 alpha:1];
}

Esto te dará una vista gris oscura, que borra todo lo que hay detrás. Sin negocios divertidos, sin desenfoque de imagen de núcleo lento, utilizando todo lo que está a su alcance proporcionado por el OS/SDK.

Puede agregar la vista de este controlador de vista a otra vista, de la siguiente manera:

[self addChildViewController:self.blurViewController];
[self.view addSubview:self.blurViewController.view];
[self.blurViewController didMoveToParentViewController:self];

// animate the self.blurViewController into view

Hágame saber si algo no está claro, ¡estaré encantado de ayudar!

Editar

UIToolbar se ha cambiado en 7.0.3 para dar posiblemente-efecto indeseable cuando se utiliza un desenfoque de color.

Solíamos ser capaces de establecer el color usando barTintColor, pero si estabas haciendo esto antes, necesitarás establecer el componente alfa en menos de 1. De lo contrario, su UIToolbar será de color completamente opaco, sin desenfoque.

Esto puede lograrse de la siguiente manera: (teniendo en cuenta que self es una subclase de UIToolbar)

UIColor *color = [UIColor blueColor]; // for example
self.barTintColor = [color colorWithAlphaComponent:0.5];

Esto le dará un tinte azul a la vista borrosa.

Aquí está una implementación rápida en Swift usando CIGaussianBlur:

func blur(image image: UIImage) -> UIImage {
    let radius: CGFloat = 20;
    let context = CIContext(options: nil);
    let inputImage = CIImage(CGImage: image.CGImage!);
    let filter = CIFilter(name: "CIGaussianBlur");
    filter?.setValue(inputImage, forKey: kCIInputImageKey);
    filter?.setValue("\(radius)", forKey:kCIInputRadiusKey);
    let result = filter?.valueForKey(kCIOutputImageKey) as! CIImage;
    let rect = CGRectMake(radius * 2, radius * 2, image.size.width - radius * 4, image.size.height - radius * 4)
    let cgImage = context.createCGImage(result, fromRect: rect);
    let returnImage = UIImage(CGImage: cgImage);

    return returnImage;
}

La respuesta aceptada es correcta, pero falta un paso importante aquí, en caso de que esta vista, para la que desea un fondo borroso, se presente utilizando

[self presentViewController:vc animated:YES completion:nil]

De forma predeterminada, esto negará el desenfoque ya que UIKit elimina la vista del presentador, que en realidad está borrosa. Para evitar esa eliminación, agregue esta línea antes de la anterior

vc.modalPresentationStyle = UIModalPresentationOverFullScreen;

O usar otros estilos Over.

OBJETIVO-C

UIVisualEffect *blurEffect;
blurEffect = [UIBlurEffect effectWithStyle:UIBlurEffectStyleDark];
UIVisualEffectView *visualEffectView;
visualEffectView = [[UIVisualEffectView alloc] initWithEffect:blurEffect];
visualEffectView.frame = self.accessImageView.bounds;
[self.accessImageView addSubview:visualEffectView];

SWIFT 3.0

let blurEffect = UIBlurEffect(style: UIBlurEffectStyle.dark)
let blurEffectView = UIVisualEffectView(effect: blurEffect)
blurEffectView.frame = view.bounds
blurEffectView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
view.addSubview(blurEffectView)

De : https://stackoverflow.com/a/24083728/4020910

Encontrado esto por accidente, me da realmente grande (casi duplicado con Apple) resultados y utiliza el marco de aceleración. -- http://pastebin.com/6cs6hsyQ *No escrito por mí

func blurBackgroundUsingImage(image: UIImage)
{
    var frame                   = CGRectMake(0, 0, self.view.frame.width, self.view.frame.height)
    var imageView               = UIImageView(frame: frame)
    imageView.image             = image
    imageView.contentMode       = .ScaleAspectFill
    var blurEffect              = UIBlurEffect(style: .Light)
    var blurEffectView          = UIVisualEffectView(effect: blurEffect)
    blurEffectView.frame        = frame
    var transparentWhiteView    = UIView(frame: frame)
    transparentWhiteView.backgroundColor = UIColor(white: 1.0, alpha: 0.30)
    var viewsArray              = [imageView, blurEffectView, transparentWhiteView]

    for index in 0..<viewsArray.count {
        if let oldView = self.view.viewWithTag(index + 1) {
            var oldView         = self.view.viewWithTag(index + 1)
            // Must explicitly unwrap oldView to access its removeFromSuperview() method as of Xcode 6 Beta 5
            oldView!.removeFromSuperview()
        }
        var viewToInsert        = viewsArray[index]
        self.view.insertSubview(viewToInsert, atIndex: index + 1)
        viewToInsert.tag        = index + 1
    }
}

Apple ha proporcionado una extensión para la clase UIImage llamada UIImage+ImageEffects.h. En esta clase tiene los métodos deseados para difuminar su vista

Usando UIImageEffects

Para las personas que quieren más control, usted podría hacer uso de Apple UIImageEffects código de ejemplo.

Puedes copiar el código de UIImageEffects de la Biblioteca de Desarrolladores de Apple: Desenfocar y Teñir una imagen

Y aquí está cómo aplicarlo:

#import "UIImageEffects.h"
...

self.originalImageView.image = [UIImageEffects imageByApplyingLightEffectToImage:[UIImage imageNamed:@"yourImage.png"]];

Esta respuesta se basa en La excelente respuesta anterior de Mitja Semolic. Lo he convertido a swift 3, agregado una explicación a lo que está sucediendo en comentarios, hecho una extensión de un UIViewController para que cualquier VC pueda llamarlo a voluntad, agregado una vista no borrosa para mostrar la aplicación selectiva, y agregado un bloque de finalización para que el controlador de vista que llama pueda hacer lo que quiera al completar el desenfoque.

    import UIKit
//This extension implements a blur to the entire screen, puts up a HUD and then waits and dismisses the view.
    extension UIViewController {
        func blurAndShowHUD(duration: Double, message: String, completion: @escaping () -> Void) { //with completion block
            //1. Create the blur effect & the view it will occupy
            let blurEffect = UIBlurEffect(style: UIBlurEffectStyle.light)
            let blurEffectView = UIVisualEffectView()//(effect: blurEffect)
            blurEffectView.frame = self.view.bounds
            blurEffectView.autoresizingMask = [.flexibleWidth, .flexibleHeight]

        //2. Add the effect view to the main view
            self.view.addSubview(blurEffectView)
        //3. Create the hud and add it to the main view
        let hud = HudView.getHUD(view: self.view, withMessage: message)
        self.view.addSubview(hud)
        //4. Begin applying the blur effect to the effect view
        UIView.animate(withDuration: 0.01, animations: {
            blurEffectView.effect = blurEffect
        })
        //5. Halt the blur effects application to achieve the desired blur radius
        self.view.pauseAnimationsInThisView(delay: 0.004)
        //6. Remove the view (& the HUD) after the completion of the duration
        DispatchQueue.main.asyncAfter(deadline: .now() + duration) {
            blurEffectView.removeFromSuperview()
            hud.removeFromSuperview()
            self.view.resumeAnimationsInThisView()
            completion()
        }
    }
}

extension UIView {
    public func pauseAnimationsInThisView(delay: Double) {
        let time = delay + CFAbsoluteTimeGetCurrent()
        let timer = CFRunLoopTimerCreateWithHandler(kCFAllocatorDefault, time, 0, 0, 0, { timer in
            let layer = self.layer
            let pausedTime = layer.convertTime(CACurrentMediaTime(), from: nil)
            layer.speed = 0.0
            layer.timeOffset = pausedTime
        })
        CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer, CFRunLoopMode.commonModes)
    }
    public func resumeAnimationsInThisView() {
        let pausedTime  = layer.timeOffset

        layer.speed = 1.0
        layer.timeOffset = 0.0
        layer.beginTime = layer.convertTime(CACurrentMediaTime(), from: nil) - pausedTime
    }
}

He confirmado que funciona tanto con iOS 10.3.1 y iOS 11

Un suplemento importante a la respuesta de @ Joey

Esto se aplica a una situación en la que desea presentar un fondo borroso UIViewController con UINavigationController.

// suppose you've done blur effect with your presented view controller
UINavigationController *nav = [[UINavigationController alloc] initWithRootViewController];

// this is very important, if you don't do this, the blur effect will darken after view did appeared
// the reason is that you actually present navigation controller, not presented controller
// please note it's "OverFullScreen", not "OverCurrentContext"
nav.modalPresentationStyle = UIModalPresentationOverFullScreen;

UIViewController *presentedViewController = [[UIViewController alloc] init]; 
// the presented view controller's modalPresentationStyle is "OverCurrentContext"
presentedViewController.modalPresentationStyle = UIModalPresentationOverCurrentContext;

[presentingViewController presentViewController:nav animated:YES completion:nil];

Disfrute!

Desde Xcode puedes hacerlo fácilmente. Siga los pasos de xcode. Arrastre la vista de efectos visuales en su uiview o imageview.

Feliz codificación:)

Aquí está el código Swift 2.0 para la solución que se ha proporcionado en respuesta aceptada :

    //only apply the blur if the user hasn't disabled transparency effects
    if !UIAccessibilityIsReduceTransparencyEnabled() {
        self.view.backgroundColor = UIColor.clearColor()

        let blurEffect = UIBlurEffect(style: UIBlurEffectStyle.Dark)
        let blurEffectView = UIVisualEffectView(effect: blurEffect)
        //always fill the view
        blurEffectView.frame = self.view.bounds
        blurEffectView.autoresizingMask = [.FlexibleWidth, .FlexibleHeight]

        self.view.addSubview(blurEffectView) //if you have more UIViews, use an insertSubview API to place it where needed
    } else {
        self.view.backgroundColor = UIColor.blackColor()
    }

Si agrega una vista de desenfoque oscuro para tableView, esto lo hará maravillosamente:

tableView.backgroundColor = .clear
let blurEffect = UIBlurEffect(style: .dark)
let blurEffectView = UIVisualEffectView(effect: blurEffect)
blurEffectView.frame = tableView.bounds
blurEffectView.autoresizingMask = [.flexibleHeight, .flexibleWidth]


// Assigning blurEffectView to backgroundView instead of addSubview to tableView makes tableView cell not blocked by blurEffectView 
tableView.backgroundView = blurEffectView

Escala de desenfoque personalizada

Puedes probar UIVisualEffectView con configuración personalizada como -

class BlurViewController: UIViewController {
    private let blurEffect = (NSClassFromString("_UICustomBlurEffect") as! UIBlurEffect.Type).init()

    override func viewDidLoad() {
        super.viewDidLoad()
        let blurView = UIVisualEffectView(frame: UIScreen.main.bounds)
        blurEffect.setValue(1, forKeyPath: "blurRadius")
        blurView.effect = blurEffect
        view.addSubview(blurView)
    }   
}

Salida:- para blurEffect.setValue(1... & blurEffect.setValue(2..

Swift 4:

Para agregar una superposición, o la vista emergente, también puede usar la Vista Contenedor con la que obtiene un Controlador de Vista gratuito (obtiene la Vista Contenedor de la paleta/biblioteca de objetos habitual)

Pasos:

Tenga una vista (ViewForContainer en la imagen) que contenga esta Vista de contenedor, para atenuarla cuando se muestre el contenido de la Vista de contenedor. Conecte la toma de corriente dentro del controlador first View

Ocultar esta vista cuando 1st VC carga

Mostrar cuando Se hace clic en el botón ingrese la descripción de la imagen aquí

Para atenuar esta vista cuando se muestre el contenido de la Vista del contenedor, establezca el Fondo de las vistas en Negro y la opacidad en 30%

He agregado una respuesta a la creación de la vista popview en otra pregunta de Stackoverflow https://stackoverflow.com/a/49729431/5438240

La respuesta simple es Agregar una subview y cambiar su alfa.

UIView *mainView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 200, 200)];
UIView *subView = [[UIView alloc] initWithFrame:popupView.frame];
UIColor * backImgColor = [UIColor colorWithPatternImage:[UIImage imageNamed:@"blue_Img.png"]];
subView.backgroundColor = backImgColor;
subView.alpha = 0.5;
[mainView addSubview:subView];