public async Task<bool> Recognise (CIImage image) { if (image == null) throw new ArgumentNullException ("image"); if (_busy) return false; _busy = true; try { return await Task.Run (() => { using (var blur = new CIGaussianBlur ()) using (var context = CIContext.Create ()) { blur.SetDefaults (); blur.Image = image; blur.Radius = 0; using (var outputCiImage = context.CreateCGImage (blur.OutputImage, image.Extent)) using (var newImage = new UIImage (outputCiImage)) { _api.Image = newImage; _api.Recognize (); return true; } } }); } finally { _busy = false; } }
public async Task<bool> Recognise (CIImage image) { CheckIfInitialized (); if (image == null) throw new ArgumentNullException ("image"); if (_busy) return false; _busy = true; try { return await Task.Run (() => { using (var blur = new CIGaussianBlur ()) using (var context = CIContext.Create ()) { blur.SetDefaults (); blur.Image = image; blur.Radius = 0; using (var outputCiImage = context.CreateCGImage (blur.OutputImage, image.Extent)) using (var newImage = new UIImage (outputCiImage)) { _size = newImage.Size; _api.Image = newImage; if (_rect.HasValue) { _api.Rect = new CGRect (_rect.Value.Left, _rect.Value.Top, _rect.Value.Width, _rect.Value.Height); } else { _api.Rect = new CGRect (0, 0, _size.Width, _size.Height); } _api.Recognize (); return true; } } }); } finally { _busy = false; } }
private static UIImage CreateBlurImage (UIImage image) { using (CIImage inputImage = new CIImage (image)) using (CIGaussianBlur blur = new CIGaussianBlur ()) using (CIContext context = CIContext.FromOptions (new CIContextOptions { UseSoftwareRenderer = false })) { blur.Image = inputImage; blur.Radius = 3; using (CIImage outputImage = blur.OutputImage) using (CIImage cgImage = context.CreateCGImage (outputImage, new CGRect (new CGPoint (0, 0), image.Size))) { return UIImage.FromImage (cgImage); } } }
public void CIKernel_BasicTest() { if (!TestRuntime.CheckSystemAndSDKVersion(8, 0)) { Assert.Inconclusive("Custom filters require iOS8+"); } Exception ex = null; var t = new Thread(() => { // This code will crash if an MKMapView has been created previously on // the same thread, so just run it on a different thread (MKMapViews can // only be created on the main thread). This is obviously an Apple bug, // and a radar has been filed: 19249153. ObjC test case: https://github.com/rolfbjarne/CIKernelMKMapViewCrash try { UIImage uiImg = new UIImage("CoreImage/Xam.png"); CIImage ciImg = new CIImage(uiImg); CIContext context = CIContext.FromOptions(null); foreach (CustomerFilterType type in Enum.GetValues(typeof(CustomerFilterType))) { MyCustomFilter filter = new MyCustomFilter(type); filter.MyImage = ciImg; CIImage outputImage = filter.OutputImage; CGImage cgImage = context.CreateCGImage(outputImage, outputImage.Extent); UIImage finalImg = new UIImage(cgImage); Assert.IsNotNull(finalImg, "CIKernel_BasicTest should not be null"); Assert.IsTrue(filter.CallbackHit, "CIKernel_BasicTest callback must be hit"); if (filter.IsColorKernel) { Assert.IsTrue(filter.kernel is CIColorKernel, "CIKernel_BasicTest we disagree that it is a color kernel"); } else { Assert.IsTrue(filter.kernel is CIWarpKernel, "CIKernel_BasicTest we disagree that it is a warp kernel"); } } } catch (Exception ex2) { ex = ex2; } }); t.Start(); t.Join(); if (ex != null) { throw ex; } }
public static NSImage Tint(this NSImage image, NSColor tint) { CIFilter colorGenerator = CIFilter.FromName("CIConstantColorGenerator"); CIColor color = CIColor.FromCGColor(tint.ToCG()); colorGenerator.SetValueForKey(color, CIFilterInputKey.Color); CIFilter colorFilter = CIFilter.FromName("CIColorControls"); colorFilter.SetValueForKey(colorGenerator.ValueForKey(CIFilterOutputKey.Image), CIFilterInputKey.Image); colorFilter.SetValueForKey(NSNumber.FromFloat(3f), CIFilterInputKey.Saturation); colorFilter.SetValueForKey(NSNumber.FromFloat(0.35f), CIFilterInputKey.Brightness); colorFilter.SetValueForKey(NSNumber.FromFloat(1f), CIFilterInputKey.Contrast); CIFilter monochromeFilter = CIFilter.FromName("CIColorMonochrome"); CIImage baseImage = CIImage.FromCGImage(image.CGImage); monochromeFilter.SetValueForKey(baseImage, CIFilterInputKey.Image); monochromeFilter.SetValueForKey(CIColor.FromRgb(0.75f, 0.75f, 0.75f), CIFilterInputKey.Color); monochromeFilter.SetValueForKey(NSNumber.FromFloat(1f), CIFilterInputKey.Intensity); CIFilter compositingFilter = CIFilter.FromName("CIMultiplyCompositing"); compositingFilter.SetValueForKey(colorFilter.ValueForKey(CIFilterOutputKey.Image), CIFilterInputKey.Image); compositingFilter.SetValueForKey(monochromeFilter.ValueForKey(CIFilterOutputKey.Image), CIFilterInputKey.BackgroundImage); CIImage outputImage = (CIImage)compositingFilter.ValueForKey(CIFilterOutputKey.Image); var extent = outputImage.Extent; var newsize = sd.Size.Truncate(extent.Size); var tintedImage = new NSImage(newsize); var newrep = new NSBitmapImageRep(IntPtr.Zero, newsize.Width, newsize.Height, 8, 4, true, false, NSColorSpace.DeviceRGB, 4 * newsize.Width, 32); tintedImage.AddRepresentation(newrep); var graphics = NSGraphicsContext.FromBitmap(newrep); NSGraphicsContext.GlobalSaveGraphicsState(); NSGraphicsContext.CurrentContext = graphics; var ciContext = CIContext.FromContext(graphics.GraphicsPort, new CIContextOptions { UseSoftwareRenderer = true }); ciContext.DrawImage(outputImage, extent, extent); NSGraphicsContext.GlobalRestoreGraphicsState(); newrep.Size = image.Size; return(tintedImage); }
NSImage ImageFromSampleBuffer(CMSampleBuffer sampleBuffer) #endif { #if __IOS__ UIImage image; #else NSImage image; #endif Random r = new Random(); int flag = r.Next(); // Get the CoreVideo image using (CVPixelBuffer pixelBuffer = sampleBuffer.GetImageBuffer() as CVPixelBuffer) { // Lock the base address pixelBuffer.Lock(CVPixelBufferLock.ReadOnly); using (CIImage cIImage = new CIImage(pixelBuffer)) { #if __IOS__ image = new UIImage(cIImage); #else image = null; AutoResetEvent e = new AutoResetEvent(false); //e.WaitOne(); //Semaphore s = new Semaphore(1, 1); //s.WaitOne(); BeginInvokeOnMainThread(delegate { NSCIImageRep rep = new NSCIImageRep(cIImage); Debug.WriteLine(String.Format("({2}) NSCIImageRep: {0}x{1}", rep.Size.Width, rep.Size.Height, flag)); image = new NSImage(rep.Size); image.AddRepresentation(rep); //s.Release(); //Monitor.Exit(this); Debug.WriteLine(String.Format("({2}) NSImage: {0}x{1}", image.Size.Width, image.Size.Height, flag)); e.Set(); }); e.WaitOne(); //Monitor.Enter(this); //Monitor.Exit(this); //s.WaitOne(); //s.Release(); #endif } pixelBuffer.Unlock(CVPixelBufferLock.ReadOnly); } Debug.WriteLine(String.Format("({2}) Recevied NSImage: {0}x{1}", image.Size.Width, image.Size.Height, flag)); return(image); }
void DetectFaceLandmarks(CIImage imageWithOrientation) { if (_detectFaceLandmarksRequest == null) { _detectFaceLandmarksRequest = new VNDetectFaceLandmarksRequest((request, error) => { RemoveSublayers(_shapeLayer); if (error != null) { throw new Exception(error.LocalizedDescription); } var results = request.GetResults <VNFaceObservation>(); foreach (var result in results) { if (result.Landmarks == null) { continue; } var boundingBox = result.BoundingBox; var scaledBoundingBox = Scale(boundingBox, _view.Bounds.Size); InvokeOnMainThread(() => { DrawLandmark(result.Landmarks.FaceContour, scaledBoundingBox, false, UIColor.White); DrawLandmark(result.Landmarks.LeftEye, scaledBoundingBox, true, UIColor.Green); DrawLandmark(result.Landmarks.RightEye, scaledBoundingBox, true, UIColor.Green); DrawLandmark(result.Landmarks.Nose, scaledBoundingBox, true, UIColor.Blue); DrawLandmark(result.Landmarks.NoseCrest, scaledBoundingBox, false, UIColor.Blue); DrawLandmark(result.Landmarks.InnerLips, scaledBoundingBox, true, UIColor.Yellow); DrawLandmark(result.Landmarks.OuterLips, scaledBoundingBox, true, UIColor.Yellow); DrawLandmark(result.Landmarks.LeftEyebrow, scaledBoundingBox, false, UIColor.Blue); DrawLandmark(result.Landmarks.RightEyebrow, scaledBoundingBox, false, UIColor.Blue); }); } }); } _sequenceRequestHandler.Perform(new[] { _detectFaceLandmarksRequest }, imageWithOrientation, out var requestHandlerError); if (requestHandlerError != null) { throw new Exception(requestHandlerError.LocalizedDescription); } }
/// <summary> /// Callback method for when a new image is recieved from the video. /// </summary> public override void DidOutputSampleBuffer(AVCaptureOutput captureOutput, CMSampleBuffer sampleBuffer, AVCaptureConnection connection) { var imageBuffer = sampleBuffer.GetImageBuffer(); var ciImage = new CIImage(imageBuffer); var cgImage = this.context.CreateCGImage(ciImage, ciImage.Extent); var current_color = ColorProcessor.AverageColor(cgImage); if (musicProcessor == null) { Console.WriteLine("Music processor is null. Waiting for init."); } else if (!recording) { musicProcessor.PlayColor(current_color, previous_color); } previous_color = current_color; if (!recording) { // we intentionally do not await these methods since it would // prohibit the rest of the app from working. // these methods are executed depending on the durationn of // the API call to Azure. // we handle the busy part here since if we handled it in PlayObjects // it would overcrowd the threads for async calls. if (generalObjectRecognition && !objectsProcessor.busy) { objectsProcessor.PlayObjects(cgImage); } if (customObjectRecognition && !customObjectsProcessor.busy) { customObjectsProcessor.PlayObjects(cgImage); } } BeginInvokeOnMainThread(async() => { // we need to change the background color on the main thread // this thread is the UI thred background.BackgroundColor = current_color; }); // we dispose the sample buffer since we are not able to process // all the images and we would overcrowd sampleBuffer.Dispose(); }
public static UIImage InvertColors(this UIImage img) { using (var coreImg = new CIImage(img.CGImage)) { var filter = new CIColorInvert { Image = coreImg }; var output = filter.OutputImage; var ctx = CIContext.FromOptions(null); var cgimage = ctx.CreateCGImage(output, output.Extent); return(UIImage.FromImage(cgimage)); } }
public static UIImage ToFilter(UIImage source, CIFilter filter) { using (var context = CIContext.FromOptions(new CIContextOptions { UseSoftwareRenderer = false })) using (var inputImage = CIImage.FromCGImage(source.CGImage)) { filter.Image = inputImage; using (var resultImage = context.CreateCGImage(filter.OutputImage, inputImage.Extent)) { return(new UIImage(resultImage)); } } }
public static void Colourize(NSView control, Color color, Action drawAction) { var size = control.Frame.Size; if (size.Width <= 0 || size.Height <= 0) { return; } var image = new NSImage(size); image.LockFocusFlipped(!control.IsFlipped); drawAction(); image.UnlockFocus(); var ciImage = CIImage.FromCGImage(image.CGImage); CGSize realSize; if (control.RespondsToSelector(selConvertSizeToBacking)) { realSize = control.ConvertSizeToBacking(size); } else { realSize = control.ConvertSizeToBase(size); } var filter2 = new CIColorControls(); filter2.SetDefaults(); filter2.Image = ciImage; filter2.Saturation = 0.0f; ciImage = (CIImage)filter2.ValueForKey(CIOutputImage); var filter3 = new CIColorMatrix(); filter3.SetDefaults(); filter3.Image = ciImage; filter3.RVector = new CIVector(0, color.R, 0); filter3.GVector = new CIVector(color.G, 0, 0); filter3.BVector = new CIVector(0, 0, color.B); ciImage = (CIImage)filter3.ValueForKey(CIOutputImage); // create separate context so we can force using the software renderer, which is more than fast enough for this var ciContext = CIContext.FromContext(NSGraphicsContext.CurrentContext.GraphicsPort, new CIContextOptions { UseSoftwareRenderer = true }); ciContext.DrawImage(ciImage, new CGRect(CGPoint.Empty, size), new CGRect(CGPoint.Empty, realSize)); }
CIImage Apply(BlurFilter blurFilter, CIImage input, bool dirty) { if (blurFilter == null || !blurFilter.Active || !dirty) { return(null); } CIFilter filter = new CIGaussianBlur { Image = input, Radius = blurFilter.BlurRadius * 50, }; return(filter.OutputImage); }
CIImage Apply(ModifyFilter modifyFilter, CIImage input, bool dirty) { if (modifyFilter == null || !modifyFilter.Active || !dirty) { return(null); } CIFilter filter = new CISepiaTone { Image = input, Intensity = modifyFilter.Intensity, }; return(filter.OutputImage); }
/// <summary> /// /// </summary> /// <param name="url"></param> /// <returns></returns> public static NSDictionary GetPhotoLibraryMetadata(NSUrl url) { NSDictionary meta = null; var image = PHAsset.FetchAssets(new NSUrl[] { url }, new PHFetchOptions()).firstObject as PHAsset; if (image == null) { return(null); } try { var imageManager = PHImageManager.DefaultManager; var requestOptions = new PHImageRequestOptions { Synchronous = true, NetworkAccessAllowed = true, DeliveryMode = PHImageRequestOptionsDeliveryMode.HighQualityFormat, }; imageManager.RequestImageData(image, requestOptions, (data, dataUti, orientation, info) => { try { var fullimage = CIImage.FromData(data); if (fullimage?.Properties != null) { meta = new NSMutableDictionary { [ImageIO.CGImageProperties.Orientation] = NSNumber.FromNInt((int)(fullimage.Properties.Orientation ?? CIImageOrientation.TopLeft)), [ImageIO.CGImageProperties.ExifDictionary] = fullimage.Properties.Exif?.Dictionary ?? new NSDictionary(), [ImageIO.CGImageProperties.TIFFDictionary] = fullimage.Properties.Tiff?.Dictionary ?? new NSDictionary(), [ImageIO.CGImageProperties.GPSDictionary] = fullimage.Properties.Gps?.Dictionary ?? new NSDictionary(), [ImageIO.CGImageProperties.IPTCDictionary] = fullimage.Properties.Iptc?.Dictionary ?? new NSDictionary(), [ImageIO.CGImageProperties.JFIFDictionary] = fullimage.Properties.Jfif?.Dictionary ?? new NSDictionary() }; } } catch (Exception ex) { Console.WriteLine(ex); } }); } catch { } return(meta); }
public static NSImage ToBlurred(NSImage source, float rad) { using (var inputImage = CIImage.FromCGImage(source.CGImage)) using (var filter = new CIGaussianBlur() { Image = inputImage, Radius = rad }) using (var resultImage = new NSCIImageRep(filter.OutputImage)) { var nsImage = new NSImage(resultImage.Size); nsImage.AddRepresentation(resultImage); return(nsImage); } }
public void HighlightShadowAdjust() { string file = Path.Combine(NSBundle.MainBundle.ResourcePath, "basn3p08.png"); using (var url = NSUrl.FromFilename(file)) using (var input = CIImage.FromUrl(url)) using (var filter = new CIHighlightShadowAdjust()) { filter.Image = input; filter.HighlightAmount = 0.75f; filter.ShadowAmount = 1.5f; // https://bugzilla.xamarin.com/show_bug.cgi?id=15465 Assert.NotNull(filter.OutputImage, "OutputImage"); } }
public static NSData GetJpegRepresentation(this CIImage image, float compressionQuality) { if (ciContext == null) { var eaglContext = new EAGLContext(EAGLRenderingAPI.OpenGLES2); ciContext = CIContext.FromContext(eaglContext); } using (CGImage outputImageRef = ciContext.CreateCGImage(image, image.Extent)) { using (UIImage uiImage = UIImage.FromImage(outputImageRef, 1f, UIImageOrientation.Up)) { return(uiImage.AsJPEG(compressionQuality)); } } }
public static NSImage ToSepia(NSImage source) { using (var inputImage = CIImage.FromCGImage(source.CGImage)) using (var filter = new CISepiaTone() { Image = inputImage }) using (var resultImage = new NSCIImageRep(filter.OutputImage)) { var nsImage = new NSImage(resultImage.Size); nsImage.AddRepresentation(resultImage); return(nsImage); } }
public static void DrawWithColorTransform(this NSView view, Color?color, Action drawDelegate) { if (color.HasValue) { var size = view.Frame.Size; if (size.Width <= 0 || size.Height <= 0) { return; } // render view to image var image = new NSImage(size); image.LockFocusFlipped(!view.IsFlipped); drawDelegate(); image.UnlockFocus(); // create Core image for transformation var ciImage = CIImage.FromCGImage(image.CGImage); CGSize displaySize; #pragma warning disable iOSAndMacApiUsageIssue if (view.RespondsToSelector(selConvertSizeToBacking)) { displaySize = view.ConvertSizeToBacking(size); } else { displaySize = view.ConvertSizeToBase(size); } #pragma warning restore iOSAndMacApiUsageIssue // apply color matrix var transformColor = new CIColorMatrix(); transformColor.SetDefaults(); transformColor.Image = ciImage; transformColor.RVector = new CIVector(0, (float)color.Value.Red, 0); transformColor.GVector = new CIVector((float)color.Value.Green, 0, 0); transformColor.BVector = new CIVector(0, 0, (float)color.Value.Blue); using (var key = new NSString("outputImage")) ciImage = (CIImage)transformColor.ValueForKey(key); var ciCtx = CIContext.FromContext(NSGraphicsContext.CurrentContext.GraphicsPort, null); ciCtx.DrawImage(ciImage, new CGRect(CGPoint.Empty, size), new CGRect(CGPoint.Empty, displaySize)); } else { drawDelegate(); } }
public static void Colourize(NSView control, Color color, Action drawAction) { var size = control.Frame.Size; var image = new NSImage(size); image.LockFocusFlipped(control.IsFlipped); drawAction(); image.UnlockFocus(); var ciImage = CIImage.FromData(image.AsTiff()); if (control.IsFlipped) { var realSize = control.ConvertSizeToBase(size); var affineTransform = new NSAffineTransform(); affineTransform.Translate(0, realSize.Height); affineTransform.Scale(1, -1); var filter1 = CIFilter.FromName("CIAffineTransform"); filter1.SetValueForKey(ciImage, CIInputImage); filter1.SetValueForKey(affineTransform, CIInputTransform); ciImage = filter1.ValueForKey(CIOutputImage) as CIImage; } var filter2 = CIFilter.FromName("CIColorControls"); filter2.SetDefaults(); filter2.SetValueForKey(ciImage, CIInputImage); filter2.SetValueForKey(new NSNumber(0.0f), CIInputSaturation); ciImage = filter2.ValueForKey(CIOutputImage) as CIImage; var filter3 = CIFilter.FromName("CIColorMatrix"); filter3.SetDefaults(); filter3.SetValueForKey(ciImage, CIInputImage); filter3.SetValueForKey(new CIVector(0, color.R, 0), CIInputRVector); filter3.SetValueForKey(new CIVector(color.G, 0, 0), CIInputGVector); filter3.SetValueForKey(new CIVector(0, 0, color.B), CIInputBVector); ciImage = filter3.ValueForKey(CIOutputImage) as CIImage; image = new NSImage(size); var rep = NSCIImageRep.FromCIImage(ciImage); image.AddRepresentation(rep); image.Draw(SD.PointF.Empty, new SD.RectangleF(SD.PointF.Empty, size), NSCompositingOperation.SourceOver, 1); /* Use this when implemented in maccore: * ciImage.Draw (SD.PointF.Empty, new SD.RectangleF (SD.PointF.Empty, size), NSCompositingOperation.SourceOver, 1); */ }
public static UIImage ToBlurred(UIImage source, float rad) { using (var context = CIContext.FromOptions(new CIContextOptions { UseSoftwareRenderer = false })) using (var inputImage = CIImage.FromCGImage(source.CGImage)) using (var filter = new CIGaussianBlur() { Image = inputImage, Radius = rad }) using (var resultImage = context.CreateCGImage(filter.OutputImage, inputImage.Extent)) { return(new UIImage(resultImage)); } }
private static UIImage CreateBlurImage(UIImage image) { using (CIImage inputImage = new CIImage(image)) using (CIGaussianBlur blur = new CIGaussianBlur()) using (CIContext context = CIContext.FromOptions(new CIContextOptions { UseSoftwareRenderer = false })) { blur.Image = inputImage; blur.Radius = 3; using (CIImage outputImage = blur.OutputImage) using (CIImage cgImage = context.CreateCGImage(outputImage, new CGRect(new CGPoint(0, 0), image.Size))) { return(UIImage.FromImage(cgImage)); } } }
public static UIImage CreateScreenshot(this ARSCNView view, UIDeviceOrientation interfaceOrientation) { if (view.Session.CurrentFrame == null) { return(null); } var ciImage = new CIImage(view.Session.CurrentFrame.CapturedImage); // TODO: check var keys = new NSString[] { CIFilterInputKey.Scale, CIFilterInputKey.AspectRatio }; var objects = new NSNumber[] { new NSNumber(0.5f), new NSNumber(1f) }; var dictionary = NSDictionary.FromObjectsAndKeys(objects, keys); var scaledImage = ciImage.CreateByFiltering("CILanczosScaleTransform", dictionary); var context = new CIContext(new CIContextOptions { UseSoftwareRenderer = false }); var cgimage = context.CreateCGImage(scaledImage, scaledImage.Extent); if (cgimage != null) { var orientation = UIImageOrientation.Right; switch (interfaceOrientation) { case UIDeviceOrientation.Portrait: orientation = UIImageOrientation.Right; break; case UIDeviceOrientation.PortraitUpsideDown: orientation = UIImageOrientation.Left; break; case UIDeviceOrientation.LandscapeLeft: orientation = UIImageOrientation.Up; break; case UIDeviceOrientation.LandscapeRight: orientation = UIImageOrientation.Down; break; } return(new UIImage(cgimage, 1f, orientation)); } return(null); }
CIImage WillDisplayImage(QTCaptureView view, CIImage image) { if (description == null) { return(image); } var selectedFilter = (NSString)description [filterNameKey]; var filter = CIFilter.FromName(selectedFilter); filter.SetDefaults(); filter.Image = image; return(filter.OutputImage); }
public static void ApplySepia(string imagePath, UIImageView imgview) { var uiimage = UIImage.FromFile (imagePath); var ciimage = new CIImage (uiimage); var sepia = new CISepiaTone(); sepia.Image = ciimage; sepia.Intensity = 0.8f; var output = sepia.OutputImage; var context = CIContext.FromOptions(null); var cgimage = context.CreateCGImage (output, output.Extent); var ui = UIImage.FromImage (cgimage); imgview.Image = ui; }
public static UIImage Inverted(this UIImage image) { // Convert to Core Image var ciImage = new CIImage(image); if (ciImage == null) { return(null); } // Apply filter ciImage = ciImage.CreateByFiltering("CIColorInvert", new NSDictionary()); // Return results return(new UIImage(ciImage)); }
public static void ApplyGreyscale(string imagePath, UIImageView imgview) { var uiimage = UIImage.FromFile (imagePath); var ciimage = new CIImage (uiimage); var greyscale = new CIColorControls(); greyscale.Image = ciimage; greyscale.Saturation = 0f; var output = greyscale.OutputImage; var context = CIContext.FromOptions(null); var cgimage = context.CreateCGImage (output, output.Extent); var ui = UIImage.FromImage (cgimage); imgview.Image = ui; }
/// <summary> /// Tint the icon with the specified colour /// </summary> /// <param name="colour">Colour to tint icon with</param> public void TintIcon(CIColor colour) { // Use CoreImage to tint the icon var statusImage = CIImage.FromUrl(NSUrl.FromFilename(NSBundle.MainBundle.PathForResource( Path.GetFileNameWithoutExtension(HighlightImagePath), Path.GetExtension(HighlightImagePath)))); var tintImage = CIImage.ImageWithColor(colour); var filter = CIFilter.FromName("CIMultiplyCompositing"); filter.SetValueForKey(tintImage, (NSString)"inputImage"); filter.SetValueForKey(statusImage, (NSString)"inputBackgroundImage"); var processedImage = (CIImage)filter.ValueForKey((NSString)"outputImage"); var outputImage = processedImage.ToNSImage(); _statusItemView.Image = outputImage; }
private void DrawFaces(CIImage image, CGRect cleanAperture) { if (image == null) { return; } var features = faceDetector.FeaturesInImage(image); if (features.Count() > 0) { IsFaceDetected = true; } DrawFaces(features, cleanAperture, UIDeviceOrientation.Portrait); }
/// <summary> /// Purchaseable feature. This function can't be called until the /// user has purchased the Greyscale Filter in-app product. /// </summary> public static void ApplyGreyscale(string imagePath, UIImageView imgview) { var uiimage = UIImage.FromFile(imagePath); var ciimage = new CIImage(uiimage); var greyscale = new CIColorControls(); greyscale.Image = ciimage; greyscale.Saturation = 0f; var output = greyscale.OutputImage; var context = CIContext.FromOptions(null); var cgimage = context.CreateCGImage(output, output.Extent); var ui = UIImage.FromImage(cgimage); imgview.Image = ui; }
public static UIImage ToUIImage(this CMSampleBuffer sampleBuffer) { UIImage image; using (CVPixelBuffer pixelBuffer = sampleBuffer.GetImageBuffer() as CVPixelBuffer) { // Lock the base address pixelBuffer.Lock(CVPixelBufferLock.ReadOnly); using (CIImage cIImage = new CIImage(pixelBuffer)) { image = new UIImage(cIImage); } pixelBuffer.Unlock(CVPixelBufferLock.ReadOnly); } //Debug.WriteLine(String.Format("({2}) Received NSImage: {0}x{1}", image.Size.Width, image.Size.Height, flag)); return(image); }
/// <summary> /// Resize image maintain aspect ratio /// </summary> /// <param name="imageSource"></param> /// <param name="scale"></param> /// <returns></returns> public static UIImage ResizeImageWithAspectRatio(this UIImage imageSource, float scale) { if (scale > 1.0f) { return(imageSource); } using (var c = CIContext.Create()) { var sourceImage = CIImage.FromCGImage(imageSource.CGImage); var orientation = imageSource.Orientation; imageSource?.Dispose(); CILanczosScaleTransform transform = null; /*if(UIDevice.CurrentDevice.CheckSystemVersion(13, 0)) * { * transform = new CILanczosScaleTransform * { * Scale = scale, * InputImage = sourceImage, * AspectRatio = 1.0f * }; * } * else*/ //{ transform = new CILanczosScaleTransform { Scale = scale, Image = sourceImage, AspectRatio = 1.0f }; //} var output = transform.OutputImage; using (var cgi = c.CreateCGImage(output, output.Extent)) { transform?.Dispose(); output?.Dispose(); sourceImage?.Dispose(); return(UIImage.FromImage(cgi, 1.0f, orientation)); } } }
protected override NSImage Transform(NSImage sourceBitmap, string path, Work.ImageSource source, bool isPlaceholder, string key) { return(Helpers.MainThreadDispatcher.PostForResult <NSImage>(() => { using (var inputImage = CIImage.FromCGImage(sourceBitmap.CGImage)) using (var filter = new CIPhotoEffectMono() { Image = inputImage }) using (var resultImage = new NSCIImageRep(filter.OutputImage)) { var nsImage = new NSImage(resultImage.Size); nsImage.AddRepresentation(resultImage); return nsImage; } })); }
/// <summary> /// Purchaseable feature. This function can't be called until the /// user has purchased the Sepia Filter in-app product. /// </summary> public static void ApplySepia(string imagePath, UIImageView imgview) { var uiimage = UIImage.FromFile(imagePath); var ciimage = new CIImage(uiimage); var sepia = new CISepiaTone(); sepia.Image = ciimage; sepia.Intensity = 0.8f; var output = sepia.OutputImage; var context = CIContext.FromOptions(null); var cgimage = context.CreateCGImage(output, output.Extent); var ui = UIImage.FromImage(cgimage); imgview.Image = ui; }
public void End() { if (_image == null || _realSize == null) { return; } _image.UnlockFocus(); var ciImage = CIImage.FromCGImage(_image.CGImage); #pragma warning disable CS0618 // Image => InputImage in Xamarin.Mac 6.6 var filter2 = new CIColorControls(); filter2.SetDefaults(); filter2.Image = ciImage; filter2.Saturation = 0.0f; ciImage = (CIImage)filter2.ValueForKey(CIOutputImage); var filter3 = new CIColorMatrix(); filter3.SetDefaults(); filter3.Image = ciImage; #pragma warning restore CS0618 var cgColor = Color.ToCG(); var components = cgColor.Components; if (components.Length >= 3) { filter3.RVector = new CIVector(0, components[0], 0); filter3.GVector = new CIVector(components[1], 0, 0); filter3.BVector = new CIVector(0, 0, components[2]); filter3.AVector = new CIVector(0, 0, 0, cgColor.Alpha); } ciImage = (CIImage)filter3.ValueForKey(CIOutputImage); // create separate context so we can force using the software renderer, which is more than fast enough for this var ciContext = CIContext.FromContext(NSGraphicsContext.CurrentContext.GraphicsPort, new CIContextOptions { UseSoftwareRenderer = true }); ciContext.DrawImage(ciImage, new CGRect(CGPoint.Empty, _image.Size), new CGRect(CGPoint.Empty, _realSize.Value)); ciImage.Dispose(); ciContext.Dispose(); filter2.Dispose(); filter3.Dispose(); }
void DarkenImage() { var img = image.Image; var ciImage = new CIImage(img); var hueAdjust = new CIHueAdjust(); // first filter hueAdjust.Image = ciImage; hueAdjust.Angle = 2.094f; var sepia = new CISepiaTone(); // second filter sepia.Image = hueAdjust.OutputImage; // output from last filter, input to this one sepia.Intensity = 0.3f; CIFilter color = new CIColorControls() { // third filter Saturation = 2, Brightness = 1, Contrast = 3, Image = sepia.OutputImage // output from last filter, input to this one }; var output = color.OutputImage; var context = CIContext.FromOptions(null); // ONLY when CreateCGImage is called do all the effects get rendered var cgimage = context.CreateCGImage(output, output.Extent); var ui = UIImage.FromImage(cgimage); image.Image = ui; }
void ConfigureCIObjects() { baseCIImage = CIImage.FromCGImage (PhotoView.Image.CGImage); }
/// <summary> /// Gets called by the VideoFrameSamplerDelegate if a new image has been captured. Does the rectangle detection. /// </summary> /// <param name="sender">Sender.</param> /// <param name="e">Event arguments</param> void HandleImageCaptured(object sender, ImageCaptureEventArgs e) { // Detect the rectangles in the captured image. // Important: case CGImage to CIImage. There is an implicit cast operator from CGImage to CIImage, but if we // pass the CGImage in to FeaturesInImage(), many many (implicit) CIImage instance will be created because this // method is called very often. The garbage collector cannot keep up with that and we runn out of memory. // By casting manually and using() the CIImage, it will be disposed immediately, freeing up memory. using (CIImage inputCIImage = (CIImage)e.Image) { // Let the detector do its work on the image. var rectangles = detector.FeaturesInImage (inputCIImage); // Find the biggest rectangle. Note: in my tests I have never seen that more than one rectangle would be detected, but better be prepared. nfloat maxWidth = 0f; nfloat maxHeight = 0f; CIRectangleFeature biggestRect = rectangles.Length > 0 ? (CIRectangleFeature)rectangles [0] : null; Console.WriteLine ("Found " + rectangles.Length + " rectangles."); foreach(CIRectangleFeature rect in rectangles) { Console.WriteLine ("Found rect: " + rect); nfloat minX = (nfloat)Math.Min (rect.TopLeft.X, rect.BottomLeft.X); nfloat minY = (nfloat)Math.Min (rect.TopLeft.Y, rect.TopRight.Y); nfloat maxX = (nfloat)Math.Min (rect.TopRight.X, rect.BottomRight.X); nfloat maxY = (nfloat)Math.Min (rect.BottomLeft.Y, rect.BottomRight.Y); if (maxX - minX > maxWidth && maxY - minY > maxHeight) { maxWidth = maxX - minX; maxHeight = maxY - minY; biggestRect = rect; } } if (biggestRect == null) { this.InvokeOnMainThread (() => { this.imageViewOverlay.Image = null; this.imageViewPerspective.Image = null; }); return; } Console.WriteLine ("Highlighting: top left = " + biggestRect.TopLeft + "; top right = " + biggestRect.TopRight + "; bottom left = " + biggestRect.BottomLeft + "; bottom right = " + biggestRect.BottomRight); // We are not on the main thread here. this.InvokeOnMainThread (() => { // Adjust the overlay image to the corners of the detected rectangle with CIPerspectiveTransformWithExtent. using(var dict = new NSMutableDictionary ()) { dict.Add (key: new NSString ("inputExtent"), value: new CIVector (inputCIImage.Extent)); dict.Add (key: new NSString ("inputTopLeft"), value: new CIVector (biggestRect.TopLeft)); dict.Add (key: new NSString ("inputTopRight"), value: new CIVector (biggestRect.TopRight)); dict.Add (key: new NSString ("inputBottomLeft"), value: new CIVector (biggestRect.BottomLeft)); dict.Add (key: new NSString ("inputBottomRight"), value: new CIVector (biggestRect.BottomRight)); // Create a semi-transparent CIImage which will show the detected rectangle. using(var overlayCIImage = new CIImage (color: CIColor.FromRgba (red: 1.0f, green: 0f, blue: 0f, alpha: 0.5f)) // Size it to the source image. .ImageByCroppingToRect (inputCIImage.Extent) // Apply perspective distortion to the overlay rectangle to map it to the current camera picture. .CreateByFiltering ("CIPerspectiveTransformWithExtent", dict) // Place overlay on the image. .CreateByCompositingOverImage (inputCIImage)) { // Must convert the CIImage into a CGImage and from there into a UIImage. // Could go directly from CIImage to UIImage but when assigning the result to a UIImageView, the ContentMode of // the image view will be ignored and no proper aspect scaling will take place. using(var ctx = CIContext.FromOptions(null)) using(CGImage convertedCGImage = ctx.CreateCGImage(overlayCIImage, overlayCIImage.Extent)) // This crashes with Xamarin.iOS //using(UIImage convertedUIImage = UIImage.FromImage(convertedCGImage, 1f, UIApplication.SharedApplication.StatusBarOrientation == UIInterfaceOrientation.LandscapeLeft ? UIImageOrientation.DownMirrored : UIImageOrientation.UpMirrored)) // This works. using(UIImage convertedUIImage = UIImage.FromImage(convertedCGImage)) { // Show converted image in UI. this.imageViewOverlay.Image = convertedUIImage; } } } // Apply a perspective correction with CIPerspectiveCorrection to the detected rectangle and display in another UIImageView. using(var dict = new NSMutableDictionary ()) { dict.Add (key: new NSString ("inputTopLeft"), value: new CIVector (biggestRect.TopLeft)); dict.Add (key: new NSString ("inputTopRight"), value: new CIVector (biggestRect.TopRight)); dict.Add (key: new NSString ("inputBottomLeft"), value: new CIVector (biggestRect.BottomLeft)); dict.Add (key: new NSString ("inputBottomRight"), value: new CIVector (biggestRect.BottomRight)); // Use again CIImage -> CGImage -> UIImage to prevent scaling issues (see above). using(var perspectiveCorrectedImage = inputCIImage.CreateByFiltering ("CIPerspectiveCorrection", dict)) using(var ctx = CIContext.FromOptions(null)) using(CGImage convertedCGImage = ctx.CreateCGImage(perspectiveCorrectedImage, perspectiveCorrectedImage.Extent)) using(UIImage convertedUIImage = UIImage.FromImage(convertedCGImage)) { this.imageViewPerspective.Image = convertedUIImage; } } }); } Console.WriteLine ("---------------------"); }
/// <summary> /// Detects the in image. /// </summary> /// <returns>The in image.</returns> /// <param name="ciimage">Ciimage.</param> /// <param name="imageOrientation">Image orientation.</param> public Face[] DetectInImage(CIImage ciimage, CGImageOrientation imageOrientation = CGImageOrientation.Default) { var rect = ciimage.Extent(); int imageHeight = (int)(rect.height * PreprocessImageScale); int imageWidth = (int)(rect.width * PreprocessImageScale); _finalScale = ProjectedScale / PreprocessImageScale; // create CIImage from bitmapdata // var ciimage:CIImage = CIImage.fromBitmapData(image, preprocessImageScale); //TODO // var ciimage = new CIImage(CGImage.FromTexture2D(image)); // orientation settings _imageOpts[CIDetector.ImageOrientation] = (int)imageOrientation; // detect var features = _detector.FeaturesInImage(ciimage, _imageOpts); // go through features and transform coords var faces = new Face[features.Length]; for (int i=0; i<features.Length; i++) { var feature = features[i] as CIFaceFeature; var face = new Face(); face.bounds = _FixRect(feature.bounds, imageHeight, imageWidth, imageOrientation); if (feature.hasMouthPosition) { face.hasMouthPosition = true; face.mouthPosition = _FixPoint(feature.mouthPosition, imageHeight, imageWidth, imageOrientation); } if (feature.hasLeftEyePosition) { face.hasLeftEyePosition = true; face.leftEyePosition = _FixPoint(feature.leftEyePosition, imageHeight, imageWidth, imageOrientation); } if (feature.hasRightEyePosition) { face.hasRightEyePosition = true; face.rightEyePosition = _FixPoint(feature.rightEyePosition, imageHeight, imageWidth, imageOrientation); } if (feature.RespondsToSelector("trackingID")) { if (feature.hasTrackingID) { face.hasTrackingID = true; face.trackingID = feature.trackingID; } if (feature.hasTrackingFrameCount) { face.hasTrackingFrameCount = true; face.trackingFrameCount = feature.trackingFrameCount; } } faces[i] = face; } return faces; }
/// <summary> /// Sets the input image from a Texture2D object. /// </summary> /// <param name='input'> /// input the input image. /// </param> public void SetInput(Texture2D input) { _image = CIImage.FromTexture2D(input); }
/// <summary> /// Sets the input image from a CIImage object. /// </summary> /// <param name='input'> /// input the input image. /// </param> public void SetInput(CIImage input) { _image = input; }
public async void Sample3Png () { await _api.Init ("eng"); using (var stream = LoadSample ("sample3.png")) using (var image = new CIImage (NSData.FromStream (stream))) using (var blur = new CIGaussianBlur ()) using (var context = CIContext.Create ()) { blur.SetDefaults (); blur.Image = image; blur.Radius = 0; using (var outputCiImage = context.CreateCGImage (blur.OutputImage, image.Extent)) using (var newImage = new UIImage (outputCiImage)) { var result = await ((TesseractApi)_api).Recognise (newImage); Assert.IsTrue (result); Assert.AreEqual ( "the quick brown fox\njumps over the lazy dog-\n\nTHE QUICK BROlLIN FOX\nJUMPS OVER THE LAZY DOG.\n\n", _api.Text); } } }
void Update() { if (CoreXT.IsDevice) { if (webCam.didUpdateThisFrame) { CGImageOrientation orientation = CGImageOrientation.RotatedLeft; switch (webCam.videoRotationAngle) { case 0: orientation = CGImageOrientation.Default; break; case 90: orientation = CGImageOrientation.RotatedLeft; break; case 180: orientation = CGImageOrientation.UpsideDown; break; case 270: orientation = CGImageOrientation.RotatedRight; break; } var ciimage = new CIImage(CGImage.FromWebCamTexture(webCam)); faceDetector.ProjectedScale = Screen.width / webCam.width; faces = faceDetector.DetectInImage(ciimage, orientation); // foreach (var face in faces) { // Log("face: " + face.Bounds + ", " + face.HasMouthPosition + ", " + face.LeftEyePosition + ", " + face.RightEyePosition); // } if (faces.Length == 1) { var face = faces[0]; if (face.Bounds.center.x < (Screen.width / 2)) GameObject.Find("Main Camera").GetComponent<Main>().rotateArmToLeft(); else GameObject.Find("Main Camera").GetComponent<Main>().rotateArmToRight(); // var newX = (face.Bounds.center.x / Screen.width) * diffX + minX; // var newZ = (face.Bounds.center.y / Screen.height) * diffY + minY; // var newY = (face.Bounds.width / diffFaceWidth) * diffFaceWidth + maxFaceWidth; // GameObject.Find("Main Camera").camera.transform.position = new Vector3(newX, newY, newZ); // GameObject.Find("Main Camera").GetComponent<Main>().Log("face: " + face.Bounds.center.x + ", " + face.Bounds.center.y + ", " + face.Bounds.width + ", " + face.Bounds.height // + "; " + newX + ", " + newY + ", " + newZ); } } } }
CIImage WillDisplayImage (QTCaptureView view, CIImage image) { if (description == null) return image; var selectedFilter = (NSString)description [filterNameKey]; var filter = CIFilter.FromName (selectedFilter); filter.SetDefaults (); filter.Image = image; return filter.OutputImage; }
/// <summary> /// Detects the in image. /// </summary> /// <returns>The in image.</returns> /// <param name="data">Pixel data.</param> /// <param name="width">Width of image.</param> /// <param name="height">Height of image.</param> /// <param name="imageOrientation">Image orientation.</param> public Face[] DetectInPixels32(Color32[] data, int width, int height, CGImageOrientation imageOrientation = CGImageOrientation.Default) { var cgimage = CGImage.FromPixels32(data, width, height, preprocessImageScale); var ciimage = new CIImage(cgimage); return DetectInImage(ciimage, imageOrientation); }
/* public void DetectInPixels32Async(Action<Face[]> callback, Color32[] data, int width, int height, CGImageOrientation imageOrientation = CGImageOrientation.Default) { if (_opQueue == null) _opQueue = new NSOperationQueue(); var cgimage = CGImage.FromPixels32(data, width, height, preprocessImageScale); data = null; _opQueue.AddOperation(delegate() { var ciimage = new CIImage(cgimage); cgimage = null; Face[] faces = DetectInImage(ciimage, imageOrientation); ciimage = null; CoreXT.RunOnMainThread(delegate() { callback(faces); faces = null; }); }); } */ /// <summary> /// Detects the in image. /// </summary> /// <returns>The in image.</returns> /// <param name="ciimage">Ciimage.</param> /// <param name="imageOrientation">Image orientation.</param> public Face[] DetectInImage(CIImage ciimage, CGImageOrientation imageOrientation = CGImageOrientation.Default) { var rect = ciimage.Extent(); int imageHeight = (int)rect.height; int imageWidth = (int)rect.width; _finalScale = projectedScale / preprocessImageScale; // options _imageOpts[CIDetector.ImageOrientation] = (int)imageOrientation; _imageOpts[CIDetector.Smile] = detectSmiles; _imageOpts[CIDetector.EyeBlink] = detectBlinks; // detect var features = _detector.FeaturesInImage(ciimage, _imageOpts); // go through features and transform coords var faces = new Face[features.Length]; for (int i=0; i<features.Length; i++) { var feature = features[i] as CIFaceFeature; var face = new Face(); face.bounds = _FixRect(feature.bounds, imageHeight, imageWidth, imageOrientation); if (feature.hasMouthPosition) { face.hasMouthPosition = true; face.mouthPosition = _FixPoint(feature.mouthPosition, imageHeight, imageWidth, imageOrientation); } if (feature.hasLeftEyePosition) { face.hasLeftEyePosition = true; face.leftEyePosition = _FixPoint(feature.leftEyePosition, imageHeight, imageWidth, imageOrientation); } if (feature.hasRightEyePosition) { face.hasRightEyePosition = true; face.rightEyePosition = _FixPoint(feature.rightEyePosition, imageHeight, imageWidth, imageOrientation); } if (feature.RespondsToSelector("trackingID")) { if (feature.hasTrackingID) { face.hasTrackingID = true; face.trackingID = feature.trackingID; } if (feature.hasTrackingFrameCount) { face.hasTrackingFrameCount = true; face.trackingFrameCount = feature.trackingFrameCount; } } if (feature.RespondsToSelector("faceAngle")) { if (feature.hasFaceAngle) { face.hasFaceAngle = true; face.faceAngle = feature.faceAngle; } face.hasSmile = feature.hasSmile; face.leftEyeClosed = feature.leftEyeClosed; face.rightEyeClosed = feature.rightEyeClosed; } faces[i] = face; } return faces; }
/// <summary> /// Detects the in image. /// </summary> /// <returns>The in image.</returns> /// <param name="image">Image.</param> /// <param name="imageOrientation">Image orientation.</param> public Face[] DetectInImage(Texture2D image, CGImageOrientation imageOrientation = CGImageOrientation.Default) { var cgimage = CGImage.FromTexture2D(image, preprocessImageScale); var ciimage = new CIImage(cgimage); return DetectInImage(ciimage, imageOrientation); }
UIImage CropImage( UIImage sourceImage, CGRect cropDimension ) { // step one, transform the crop region into image space. // (So pixelX is a pixel in the actual image, not the scaled screen) // convert our position on screen to where it should be in the image float pixelX = (float) (cropDimension.X * ScreenToImageScalar); float pixelY = (float) (cropDimension.Y * ScreenToImageScalar); // same for height, since the image was scaled down to fit the screen. float width = (float) cropDimension.Width * ScreenToImageScalar; float height = (float) cropDimension.Height * ScreenToImageScalar; // Now we're going to rotate the image to actually be "up" as the user // sees it. To do that, we simply rotate it according to the apple documentation. float rotationDegrees = 0.0f; switch ( sourceImage.Orientation ) { case UIImageOrientation.Up: { // don't do anything. The image space and the user space are 1:1 break; } case UIImageOrientation.Left: { // the image space is rotated 90 degrees from user space, // so do a CCW 90 degree rotation rotationDegrees = 90.0f; break; } case UIImageOrientation.Right: { // the image space is rotated -90 degrees from user space, // so do a CW 90 degree rotation rotationDegrees = -90.0f; break; } case UIImageOrientation.Down: { rotationDegrees = 180; break; } } // Now get a transform so we can rotate the image to be oriented the same as when the user previewed it CGAffineTransform fullImageTransform = GetImageTransformAboutCenter( rotationDegrees, sourceImage.Size ); // apply to the image CIImage ciCorrectedImage = new CIImage( sourceImage.CGImage ); CIImage ciCorrectedRotatedImage = ciCorrectedImage.ImageByApplyingTransform( fullImageTransform ); // create a context and render it back out to a CGImage. CIContext ciContext = CIContext.FromOptions( null ); CGImage rotatedCGImage = ciContext.CreateCGImage( ciCorrectedRotatedImage, ciCorrectedRotatedImage.Extent ); // now the image is properly orientated, so we can crop it. CGRect cropRegion = new CGRect( pixelX, pixelY, width, height ); CGImage croppedImage = rotatedCGImage.WithImageInRect( cropRegion ); return new UIImage( croppedImage ); }
void UpdateImage (bool coalesce, bool animate) { if (!TryInit (animate)) return; if (filtering) { needsFilter = true; return; } if (image == null) return; var blurFilter = (BlurFilter)GetFilter (BlurFilter.Key); var modifyFilter = (ModifyFilter)GetFilter (ModifyFilter.Key); bool dirty = blurFilter != null ? blurFilter.Dirty : false; dirty |= modifyFilter != null ? modifyFilter.Dirty : false; filtering = true; TryStartIndicatorForFilter (); Action runFilters = () => { var filterInput = new CIImage (image.CGImage); CIImage filteredCIImage = Apply(blurFilter, filterInput, dirty); filterInput = filteredCIImage ?? new CIImage (image.CGImage); filteredCIImage = Apply(modifyFilter, filterInput, dirty) ?? filteredCIImage; CGImage cgFilteredImage = null; if (filteredCIImage != null) { CIContext context = CIContext.FromOptions (new CIContextOptions{ UseSoftwareRenderer = false }); cgFilteredImage = context.CreateCGImage (filteredCIImage, filteredCIImage.Extent); } if (coalesce) InvokeOnMainThread (() => Apply(cgFilteredImage, image, dirty)); else Apply(cgFilteredImage, image, dirty); }; if (coalesce) Task.Delay (250).ContinueWith (_ => runFilters()); else runFilters (); blurFilter.Dirty = modifyFilter.Dirty = false; }
void ApplyPhotoFilter (CIFilter filter, PHContentEditingInput input, PHContentEditingOutput output, Action completion) { // Load the full size image. var inputImage = new CIImage (input.FullSizeImageUrl); // Apply the filter. filter.Image = inputImage.CreateWithOrientation (input.FullSizeImageOrientation); var outputImage = filter.OutputImage; // Write the edited image as a JPEG. // TODO: https://bugzilla.xamarin.com/show_bug.cgi?id=44503 NSError error; if (!ciContext.WriteJpegRepresentation (outputImage, output.RenderedContentUrl, inputImage.ColorSpace (), new NSDictionary(), out error)) throw new InvalidProgramException ($"can't apply filter to image: {error.LocalizedDescription}"); completion (); }
/// <summary> /// Sets the input image from an UIImage object. /// </summary> /// <param name='input'> /// input the input image. /// </param> public void SetInput(UIImage input) { _image = new CIImage(input); }
CIImage Apply(BlurFilter blurFilter, CIImage input, bool dirty) { if (blurFilter == null || !blurFilter.Active || !dirty) return null; CIFilter filter = new CIGaussianBlur { Image = input, Radius = blurFilter.BlurRadius * 50, }; return filter.OutputImage; }
public async Task<bool> Recognise (CGImage image) { using (var ciImage = new CIImage (image)) { return await Recognise (ciImage); } }
public async Task<bool> Recognise (CGImage image) { CheckIfInitialized (); using (var ciImage = new CIImage (image)) { return await Recognise (ciImage); } }
public void SetEnhancedImage() { using (CIImage ciImage = new CIImage (_parent.ImageView.Image)) { InvokeOnMainThread (() => { using (var dict = new NSMutableDictionary ()) { var topLeft = new CGPoint (ConvertScreenToImageCoords (_markers [0].Location)); var topRight = new CGPoint (ConvertScreenToImageCoords (_markers [1].Location)); var bottomRight = new CGPoint (ConvertScreenToImageCoords (_markers [2].Location)); var bottomLeft = new CGPoint (ConvertScreenToImageCoords (_markers [3].Location)); dict.Add (key: new NSString ("inputTopLeft"), value: new CIVector (topLeft)); dict.Add (key: new NSString ("inputTopRight"), value: new CIVector (topRight)); dict.Add (key: new NSString ("inputBottomRight"), value: new CIVector (bottomRight)); dict.Add (key: new NSString ("inputBottomLeft"), value: new CIVector (bottomLeft)); using (var perspectiveCorrectedImage = ciImage.CreateByFiltering ("CIPerspectiveCorrection", dict)) { using (var ctx = CIContext.FromOptions (null)) using (CGImage convertedCGImage = ctx.CreateCGImage (perspectiveCorrectedImage, perspectiveCorrectedImage.Extent)) using (UIImage convertedUIImage = UIImage.FromImage (convertedCGImage)) { NSData imageData = convertedUIImage.AsJPEG (); _encodedImage = imageData.GetBase64EncodedData (NSDataBase64EncodingOptions.None).ToString (); _parent.ShowViewController (new BPreviewController (encodedImage: _encodedImage), this); } } } }); } isCroppedImageDisplayed = false; }
/// <summary> /// Detects the in image. /// </summary> /// <returns>The in image.</returns> /// <param name="image">Image.</param> /// <param name="imageOrientation">Image orientation.</param> public Face[] DetectInImage(Texture2D image, CGImageOrientation imageOrientation = CGImageOrientation.Default) { var cgimage = CGImage.FromTexture2D(image); var ciimage = new CIImage(cgimage); // cgimage.Release(); return DetectInImage(ciimage, imageOrientation); }
public void UseDetector() { var options = new CIDetectorOptions { Accuracy = FaceDetectorAccuracy.High, AspectRatio = 1.41f }; detector = CIDetector.CreateRectangleDetector (context: null, detectorOptions: options); using (CIImage ciImage = new CIImage (_parent.ImageView.Image)) { InvokeOnMainThread (() => { using (var dict = new NSMutableDictionary ()) { var orient = GetExifOrientation (_parent.ImageView.Image); var rectangles = detector.FeaturesInImage (ciImage, orient); if (rectangles.Length > 0) { _currRect = (CIRectangleFeature)rectangles [0]; _markers [0].Location = ConvertImageToScreenCoords (_currRect.TopLeft); _markers [1].Location = ConvertImageToScreenCoords (_currRect.TopRight); _markers [2].Location = ConvertImageToScreenCoords (_currRect.BottomRight); _markers [3].Location = ConvertImageToScreenCoords (_currRect.BottomLeft); } } }); } }
/// <summary> /// Renders to CGImage. /// </summary> /// <returns>The CGImage.</returns> /// <param name="rect">Rect.</param> public CGImage RenderToCGImage(Rect rect) { if (_image == null) return null; CGImage cgimage = _ciContext.CreateCGImage(_image, rect); _image = null; return cgimage; }
/// <summary> /// Applies auto-adjust filters to the image. This method analyzes the image, determines what /// filters it needs, enhanced values for their parameters, and applies them. /// /// The imageOrientation argument is to detect faces in the image so it can apply some filters only to the faces. /// See constants in FaceDetector for a list of values. /// </summary> /// <returns> /// object itself, for chaining filters. /// </returns> /// <param name='imageOrientation'> /// the orientation of the image; default is FaceDetector.IMAGE_ORIENTATION_DEFAULT. /// </param> /// <param name='autoEnhance'> /// whether to auto enhance the image. /// </param> /// <param name='autoRedEye'> /// whether to apply red-eye reduction. /// </param> /// <exception cref='U3DXTException'> /// Is thrown when the error. /// </exception> public ImageFilter AutoAdjust(int imageOrientation = 1, Boolean autoEnhance = true, Boolean autoRedEye = true) { if (_image == null) throw new U3DXTException("Must call setInput() first."); Dictionary<object,object> options = new Dictionary<object,object>(); options["CIDetectorImageOrientation"] = imageOrientation; options[CIImage.kCIImageAutoAdjustEnhance] = autoEnhance; options[CIImage.kCIImageAutoAdjustRedEye] = autoRedEye; Array adjustments = _image.AutoAdjustmentFilters(options); foreach (CIFilter aFilter in adjustments) { aFilter.SetValueForKey(_image, CIFilter.kCIInputImageKey); _image = aFilter.ValueForKey(CIFilter.kCIOutputImageKey) as CIImage; } return this; }
CIImage Apply(ModifyFilter modifyFilter, CIImage input, bool dirty) { if (modifyFilter == null || !modifyFilter.Active || !dirty) return null; CIFilter filter = new CISepiaTone { Image = input, Intensity = modifyFilter.Intensity, }; return filter.OutputImage; }