佳为好友

UIImage *viewImage = [[(id)objc_getClass("PLCameraController") 
                       performSelector:@selector(sharedInstance)] 
                      performSelector:@selector(_createPreviewImage)];
 

extern CGImageRef UIGetScreenImage();
 
CGImageRef cgoriginal = UIGetScreenImage();
 CGImageRef cgimg = CGImageCreateWithImageInRect(cgoriginal, rect);            
 UIImage *viewImage = [UIImage imageWithCGImage:cgimg];    
 CGImageRelease(cgoriginal);                
CGImageRelease(cgimg);  
 

"After carefully considering the issue, Apple is now allowing applications to use the function UIGetScreenImage() to programmatically capture the current screen contents." The function prototype is as follows:

CGImageRef UIGetScreenImage();

Image *fromCGImage(CGImageRef srcImage, CGRect srcRect) {
 Image *result=createImage(srcRect.size.width, srcRect.size.height);
 // get hold of the image bytes
 CGColorSpaceRef colorSpace=CGColorSpaceCreateDeviceGray();
  CGContextRef context=CGBitmapContextCreate(result->rawImage,  
         result->width, 
         result->height, 
         8, 
         result->width, 
         colorSpace, 
         kCGImageAlphaNone);
  // lowest possible quality for speed
 CGContextSetInterpolationQuality(context, kCGInterpolationNone);
 CGContextSetShouldAntialias(context, NO);
 // get the rectangle of interest from the image
 CGImageRef subImage=CGImageCreateWithImageInRect(srcImage, srcRect);
  // draw it into our bitmap context
 CGContextDrawImage(context, CGRectMake(0,0, result->width, result->height), subImage);
 // cleanup
 CGContextRelease(context);
 CGColorSpaceRelease(colorSpace);
 CGImageRelease(subImage);
  return result;
}

CGImageRef toCGImage(Image *srcImage) {
 // generate space for the result
 uint8_t *rgbData=(uint8_t *) calloc(srcImage->width*srcImage->height*sizeof(uint32_t),1);
 // process the greyscale image back to rgb
  for(int i=0; iheight*srcImage->width; i++) {   
  // no alpha
  rgbData[i*4]=0;
  int val=srcImage->rawImage[i];
  // rgb values
  rgbData[i*4+1]=val;
  rgbData[i*4+2]=val;
  rgbData[i*4+3]=val;
  }
 // create the CGImage from this data
 CGColorSpaceRef colorSpace=CGColorSpaceCreateDeviceRGB();
 CGContextRef context=CGBitmapContextCreate(rgbData, 
      srcImage->width, 
      srcImage->height, 
       8, 
      srcImage->width*sizeof(uint32_t), 
      colorSpace, 
      kCGBitmapByteOrder32Little|kCGImageAlphaNoneSkipLast);
 // cleanup
 CGImageRef image=CGBitmapContextCreateImage(context);
 CGContextRelease(context);
  CGColorSpaceRelease(colorSpace);
 free(rgbData);
 return image;
}

typedef struct {
 uint8_t *rawImage; // the raw pixel data
 uint8_t **pixels; // 2D array of pixels e.g. use pixels[y][x]
 int width;
 int height;
} Image;

Image *createImage(int width, int height) {
  Image *result=(Image *) malloc(sizeof(Image));
 result->width=width;
 result->height=height;
 result->rawImage=(uint8_t *) calloc(result->width*result->height, 1);
 // create a 2D aray - this makes using the data a lot easier
  result->pixels=(uint8_t **) malloc(sizeof(uint8_t *)*result->height);
 for(int y=0; yheight; y++) {
  result->pixels[y]=result->rawImage+y*result->width;
 }
 return result;
}

void destroyImage(Image *image) {
  free(image->rawImage);
 free(image->pixels);
 free(image);
}

- (id)initWithFrame:(CGRect)frame {
    if (self = [super initWithFrame:frame]) {
  // create the mask image
  Image *checkerBoardImage=createImage(self.bounds.size.width, self.bounds.size.height);
   for(int y=0;yheight; y+=2) {
   for(int x=0; xwidth; x+=2) {
    checkerBoardImage->pixels[y][x]=255;
   }
  }
  for(int y=1;yheight; y+=2) {
   for(int x=1; xwidth; x+=2) {
    checkerBoardImage->pixels[y][x]=255;
    }
  }
  // convert to a CGImage
  maskImage=toCGImage(checkerBoardImage);
  // cleanup
  destroyImage(checkerBoardImage);
    }
    return self;
}

- (void)drawRect:(CGRect)rect {
 // we're going to draw into an image using our checkerboard mask
  UIGraphicsBeginImageContext(self.bounds.size);
 CGContextRef context=UIGraphicsGetCurrentContext();
 CGContextClipToMask(context, self.bounds, maskImage);
 // do your drawing here

 ////////      
 UIImage *imageToDraw=UIGraphicsGetImageFromCurrentImageContext();
  UIGraphicsEndImageContext();

 // now do the actual drawing of the image
 CGContextRef drawContext=UIGraphicsGetCurrentContext();
 CGContextTranslateCTM(drawContext, 0.0, self.bounds.size.height);
 CGContextScaleCTM(drawContext, 1.0, -1.0);
  // very important to switch these off - we don't wnat our grid pattern to be disturbed in any way
 CGContextSetInterpolationQuality(drawContext, kCGInterpolationNone);
 CGContextSetShouldAntialias(drawContext, NO);
  CGContextDrawImage(drawContext, self.bounds, [imageToDraw CGImage]);

 // stash the results of our drawing so we can remove them later
 if(drawnImage) destroyImage(drawnImage);
 drawnImage=fromCGImage([imageToDraw CGImage], self.bounds); 
 }

 CGContextClipToMask(context, self.bounds, maskImage);

-(IBAction) runAugmentedReality {
 // set up our camera overlay view
 
 // tool bar - handy if you want to be able to exit from the image picker...
 UIToolbar *toolBar=[[[UIToolbar alloc] initWithFrame:CGRectMake(0, 480-44, 320, 44)] autorelease];
  NSArray *items=[NSArray arrayWithObjects:
     [[[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemFlexibleSpace  target:nil action:nil] autorelease],
     [[[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemDone  target:self action:@selector(finishedAugmentedReality)] autorelease],
      nil];
 [toolBar setItems:items];
 // create the overlay view
 overlayView=[[[OverlayView alloc] initWithFrame:CGRectMake(0, 0, 320, 480-44)] autorelease];
 // important - it needs to be transparent so the camera preview shows through!
  overlayView.opaque=NO;
 overlayView.backgroundColor=[UIColor clearColor];
 // parent view for our overlay
 UIView *parentView=[[[UIView alloc] initWithFrame:CGRectMake(0,0,320, 480)] autorelease];
 [parentView addSubview:overlayView];
  [parentView addSubview:toolBar];
 
 // configure the image picker with our overlay view
 UIImagePickerController *picker=[[UIImagePickerController alloc] init];
 picker.sourceType = UIImagePickerControllerSourceTypeCamera;
  UIImagePickerControllerSourceTypePhotoLibrary;
 // hide the camera controls
 picker.showsCameraControls=NO;
 picker.delegate = nil;
 picker.allowsImageEditing = NO;
 // and put our overlay view in
 picker.cameraOverlayView=parentView;
  [self presentModalViewController:picker animated:YES];  
 [picker release];
 // start our processing timer
 processingTimer=[NSTimer scheduledTimerWithTimeInterval:1/5.0f target:self selector:@selector(processImage) userInfo:nil repeats:YES];
 }

 // and put our overlay view in
 picker.cameraOverlayView=parentView;

// this is where is all happens
CGImageRef UIGetScreenImage();

-(void) processImage {
 // grab the screen
 CGImageRef screenCGImage=UIGetScreenImage();
 // turn it into something we can use
  Image *screenImage=fromCGImage(screenCGImage, overlayView.frame);
 CGImageRelease(screenCGImage);
 // process the image to remove our drawing - WARNING the edge pixels of the image are not processed
 Image *drawnImage=overlayView.drawnImage;
  for(int y=1;yheight-1; y++) {
  for(int x=1; xwidth-1; x++) {
   // if we draw to this pixel replace it with the average of the surrounding pixels
   if(drawnImage->pixels[y][x]!=0) {
    screenImage->pixels[y][x]=(screenImage[y-1][x]+screenImage[y+1][x]+
           screenImage[y][x-1]+screenImage[y][x+1])/4;
   }
  }
 }
 // do something clever with the image here and tell the overlay view to draw stuff
 // simple edge detection and following:
 CGMutablePathRef pathRef=CGPathCreateMutable();
  int lastX=-1000, lastY=-1000;
 for(int y=0; yheight-1; y++) {
  for(int x=0; xwidth-1; x++) {
   int edge=(abs(screenImage->pixels[y][x]-screenImage->pixels[y][x+1])+
       abs(screenImage->pixels[y][x]-screenImage->pixels[y+1][x]))/2;
    if(edge>10) {
    int dist=(x-lastX)*(x-lastX)+(y-lastY)*(y-lastY);
    if(dist>50) {
     CGPathMoveToPoint(pathRef, NULL, x, y);
     lastX=x;
     lastY=y;
    } else if(dist>10) {
     CGPathAddLineToPoint(pathRef, NULL, x, y);
      lastX=x;
     lastY=y;
    }
   }
  }
 }
 // update the overlay view
 [overlayView setPath:pathRef];
 //////////////

 // finished with the screen image
 destroyImage(screenImage);
 }

 // process the image to remove our drawing - WARNING the edge pixels of the image are not processed
 Image *drawnImage=overlayView.drawnImage;
 for(int y=1;yheight-1; y++) {
  for(int x=1; xwidth-1; x++) {
    // if we draw to this pixel replace it with the average of the surrounding pixels
   if(drawnImage->pixels[y][x]!=0) {
    screenImage->pixels[y][x]=(screenImage[y-1][x]+screenImage[y+1][x]+
          screenImage[y][x-1]+screenImage[y][x+1])/4;
    }
  }
 }