public static NSImage ToNS(this Image image, int?size = null)
{
if (image == null)
{
return(null);
}
var source = image.Handler as IImageSource;
if (source == null)
{
return(null);
}
var nsimage = source.GetImage();
if (size != null)
{
var mainScale = Screen.PrimaryScreen.RealScale;
var scales = new[] { 1f, 2f }; // generate both retina and non-retina representations
var sz = (float)Math.Ceiling(size.Value / mainScale);
sz = size.Value;
var imgsize = image.Size;
var max = Math.Max(imgsize.Width, imgsize.Height);
var newimagesize = new CGSize((nint)(sz * imgsize.Width / max), (nint)(sz * imgsize.Height / max));
var newimage = new NSImage(newimagesize);
foreach (var scale in scales)
{
sz = (float)Math.Ceiling(size.Value * scale / mainScale);
var rep = nsimage.BestRepresentation(new CGRect(0, 0, sz, sz), null, null);
max = (int)Math.Max(rep.PixelsWide, rep.PixelsHigh);
sz = (float)Math.Ceiling(size.Value * scale);
if (rep is NSCustomImageRep custom)
{
rep = custom.Copy() as NSImageRep;
rep.Size = newimagesize;
newimage.AddRepresentation(rep);
}
else
{
var newsize = new CGSize((nint)(sz * rep.PixelsWide / max), (nint)(sz * rep.PixelsHigh / max));
newimage.AddRepresentation(rep.Resize(newsize, imageSize: newimagesize));
}
}
nsimage = newimage;
}
return(nsimage);
}
internal static NSImage TakeSnapshot(NSView view, object data)
{
NSImage snapshot = null;
if (data is IDataObject idata)
{
if (idata.GetData("DragAndDropImage") is Drawing.Image image)
{
snapshot = image.ToNSImage();
}
}
if (snapshot == null && view is MonoView)
{
snapshot = CreateSwatch(new CGSize(32, 22));
}
if (snapshot == null)
{
var b = view.BitmapImageRepForCachingDisplayInRect(view.Bounds);
view.CacheDisplay(view.Bounds, b);
snapshot = new NSImage(view.Bounds.Size);
snapshot.AddRepresentation(b);
}
return(snapshot);
}
public static NSImage ToNSImage(this CMSampleBuffer sampleBuffer)
{
NSImage image;
using (CVPixelBuffer pixelBuffer = sampleBuffer.GetImageBuffer() as CVPixelBuffer)
{
// Lock the base address
pixelBuffer.Lock(CVPixelBufferLock.ReadOnly);
using (CIImage cIImage = new CIImage(pixelBuffer))
{
image = null;
AutoResetEvent e = new AutoResetEvent(false);
Xamarin.Forms.Device.BeginInvokeOnMainThread(delegate
{
NSCIImageRep rep = new NSCIImageRep(cIImage);
image = new NSImage(rep.Size);
image.AddRepresentation(rep);
e.Set();
});
e.WaitOne();
}
pixelBuffer.Unlock(CVPixelBufferLock.ReadOnly);
}
return(image);
}
public static NSImage ToNS(this Image image, int?size = null)
{
if (image == null)
{
return(null);
}
var source = image.Handler as IImageSource;
if (source == null)
{
return(null);
}
var nsimage = source.GetImage();
if (size != null)
{
var rep = nsimage.BestRepresentation(new CGRect(0, 0, size.Value, size.Value), null, null);
if (rep.PixelsWide > size.Value || rep.PixelsHigh > size.Value)
{
var max = Math.Max(nsimage.Size.Width, nsimage.Size.Height);
var newsize = new CGSize((int)(size.Value * nsimage.Size.Width / max), (int)(size.Value * nsimage.Size.Height / max));
nsimage = nsimage.Resize(newsize);
}
else
{
nsimage = new NSImage();
nsimage.AddRepresentation(rep);
}
}
return(nsimage);
}
public static NSImage ToNSImage(this CIImage image, System.Drawing.SizeF size)
{
var imageRep = NSCIImageRep.FromCIImage(image);
var nsImage = new NSImage(size);
nsImage.AddRepresentation(imageRep);
return(nsImage);
}
public object Create(IconFrame frame, Func <Stream> load)
{
var img = new NSImage();
img.AddRepresentation(new LazyImageRep {
Load = load
});
return(new Bitmap(new BitmapHandler(img)));
}
public override object CreateImage(object backend)
{
var gc = (CGContextBackend)backend;
var img = new NSImage(((CGBitmapContext)gc.Context).ToImage(), gc.Size);
var imageData = img.AsTiff();
var imageRep = (NSBitmapImageRep)NSBitmapImageRep.ImageRepFromData(imageData);
var im = new NSImage();
im.AddRepresentation(imageRep);
return(im);
}
void SetIcon(Icon icon)
{
using (var stream = icon.GetStream())
{
// Fun song and dance to avoid using the default 256/256 rep
var icn = NSImage.FromStream(stream).BestRepresentation(new CGRect(0, 0, 32, 32), null, null);
icn.Size = new CGSize(24, 24);
var image = new NSImage(icn.Size);
image.AddRepresentation(icn);
image.Template = true;
_item.Image = image;
}
}
public static NSImage ToFilter(NSImage source, CIFilter filter)
{
using (var inputImage = CIImage.FromCGImage(source.CGImage))
{
filter.Image = inputImage;
using (var resultImage = new NSCIImageRep(filter.OutputImage))
{
var nsImage = new NSImage(resultImage.Size);
nsImage.AddRepresentation(resultImage);
return(nsImage);
}
}
}
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}) Received NSImage: {0}x{1}", image.Size.Width, image.Size.Height, flag));
return(image);
}
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 override object RenderWidget(Widget w)
{
var view = ((ViewBackend)w.GetBackend()).Widget;
view.LockFocus();
var img = new NSImage(view.DataWithPdfInsideRect(view.Bounds));
var imageData = img.AsTiff();
var imageRep = (NSBitmapImageRep)NSBitmapImageRep.ImageRepFromData(imageData);
var im = new NSImage();
im.AddRepresentation(imageRep);
im.Size = new CGSize((nfloat)view.Bounds.Width, (nfloat)view.Bounds.Height);
return(im);
}
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 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);
*/
}
/// <summary>
/// Render a GTK widget to an AppKit NSImage
/// </summary>
public static NSImage RenderGtkWidget(Gtk.Widget widget)
{
var nativeView = GetNSView(widget);
widget.TranslateCoordinates(widget.Toplevel, widget.Allocation.X, widget.Allocation.Y, out int transX, out int transY);
var rect = new CoreGraphics.CGRect(transX, transY, widget.Allocation.Width, widget.Allocation.Height);
var imageRep = nativeView.BitmapImageRepForCachingDisplayInRect(rect);
nativeView.CacheDisplay(rect, imageRep);
var image = new NSImage(rect.Size);
image.AddRepresentation(imageRep);
return(image);
}
public static NSImage Resize(this NSImage image, CGSize newsize, ImageInterpolation interpolation = ImageInterpolation.Default)
{
var newimage = new NSImage(newsize);
var newrep = new NSBitmapImageRep(IntPtr.Zero, (nint)newsize.Width, (nint)newsize.Height, 8, 4, true, false, NSColorSpace.DeviceRGB, 4 * (nint)newsize.Width, 32);
newimage.AddRepresentation(newrep);
var graphics = NSGraphicsContext.FromBitmap(newrep);
NSGraphicsContext.GlobalSaveGraphicsState();
NSGraphicsContext.CurrentContext = graphics;
graphics.GraphicsPort.InterpolationQuality = interpolation.ToCG();
image.DrawInRect(new CGRect(CGPoint.Empty, newimage.Size), new CGRect(CGPoint.Empty, image.Size), NSCompositingOperation.SourceOver, 1f);
NSGraphicsContext.GlobalRestoreGraphicsState();
return(newimage);
}
public override object ConvertToBitmap(object handle, int pixelWidth, int pixelHeight, ImageFormat format)
{
if (handle is CustomImage)
{
var flags = CGBitmapFlags.ByteOrderDefault;
int bytesPerRow;
switch (format)
{
case ImageFormat.ARGB32:
bytesPerRow = pixelWidth * 4;
flags |= CGBitmapFlags.PremultipliedFirst;
break;
case ImageFormat.RGB24:
bytesPerRow = pixelWidth * 3;
flags |= CGBitmapFlags.None;
break;
default:
throw new NotImplementedException("ImageFormat: " + format.ToString());
}
var bmp = new CGBitmapContext(IntPtr.Zero, pixelWidth, pixelHeight, 8, bytesPerRow, Util.DeviceRGBColorSpace, flags);
bmp.TranslateCTM(0, pixelHeight);
bmp.ScaleCTM(1, -1);
var ctx = new CGContextBackend {
Context = bmp,
Size = new SizeF(pixelWidth, pixelHeight),
InverseViewTransform = bmp.GetCTM().Invert()
};
var ci = (CustomImage)handle;
ci.DrawInContext(ctx);
var img = new NSImage(((CGBitmapContext)bmp).ToImage(), new SizeF(pixelWidth, pixelHeight));
var imageData = img.AsTiff();
var imageRep = (NSBitmapImageRep)NSBitmapImageRep.ImageRepFromData(imageData);
var im = new NSImage();
im.AddRepresentation(imageRep);
return(im);
}
else
{
return(handle);
}
}
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;
}
}));
}
partial void addFrame(NSObject sender)
{
NSImage image;
lock (this){
if (currentImage == null)
{
return;
}
var img = CIImage.FromImageBuffer(currentImage);
Console.WriteLine(img);
var imageRep = NSCIImageRep.FromCIImage(CIImage.FromImageBuffer(currentImage));
image = new NSImage(imageRep.Size);
image.AddRepresentation(imageRep);
}
movie.AddImage(image, new QTTime(1, 10), attrs);
movie.CurrentTime = movie.Duration;
movieView.NeedsDisplay = true;
}
public void Badge()
{
using (NSAutoreleasePool a = new NSAutoreleasePool()) {
foreach (string path in this.paths)
{
string extension = Path.GetExtension(path.ToLower());
NSImage new_icon = new NSImage();
if (!this.icons.ContainsKey(extension))
{
foreach (int size in this.sizes)
{
NSImage file_icon = NSWorkspace.SharedWorkspace.IconForFileType(extension);
file_icon.Size = new SizeF(size, size);
// TODO: replace this with the sync icon
NSImage overlay_icon = NSWorkspace.SharedWorkspace.IconForFileType("sln");
overlay_icon.Size = new SizeF(size / 2, size / 2);
file_icon.LockFocus();
NSGraphicsContext.CurrentContext.ImageInterpolation = NSImageInterpolation.High;
overlay_icon.Draw(
new RectangleF(0, 0, file_icon.Size.Width / 3, file_icon.Size.Width / 3),
new RectangleF(), NSCompositingOperation.SourceOver, 1.0f);
file_icon.UnlockFocus();
new_icon.AddRepresentation(file_icon.Representations() [0]);
}
this.icons.Add(extension, new_icon);
}
else
{
new_icon = this.icons [extension];
}
NSWorkspace.SharedWorkspace.SetIconforFile(new_icon, path, 0);
}
}
}
public override object ConvertToBitmap(ImageDescription idesc, double scaleFactor, ImageFormat format)
{
double width = idesc.Size.Width;
double height = idesc.Size.Height;
int pixelWidth = (int)(width * scaleFactor);
int pixelHeight = (int)(height * scaleFactor);
if (idesc.Backend is CustomImage)
{
var flags = CGBitmapFlags.ByteOrderDefault;
int bytesPerRow;
switch (format)
{
case ImageFormat.ARGB32:
bytesPerRow = pixelWidth * 4;
flags |= CGBitmapFlags.PremultipliedFirst;
break;
case ImageFormat.RGB24:
bytesPerRow = pixelWidth * 3;
flags |= CGBitmapFlags.None;
break;
default:
throw new NotImplementedException("ImageFormat: " + format.ToString());
}
var bmp = new CGBitmapContext(IntPtr.Zero, pixelWidth, pixelHeight, 8, bytesPerRow, Util.DeviceRGBColorSpace, flags);
bmp.TranslateCTM(0, pixelHeight);
bmp.ScaleCTM((float)scaleFactor, (float)-scaleFactor);
var ctx = new CGContextBackend {
Context = bmp,
Size = new CGSize((nfloat)width, (nfloat)height),
InverseViewTransform = bmp.GetCTM().Invert(),
ScaleFactor = scaleFactor
};
var ci = (CustomImage)idesc.Backend;
ci.DrawInContext(ctx, idesc);
var img = new NSImage(((CGBitmapContext)bmp).ToImage(), new CGSize(pixelWidth, pixelHeight));
var imageData = img.AsTiff();
var imageRep = (NSBitmapImageRep)NSBitmapImageRep.ImageRepFromData(imageData);
var im = new NSImage();
im.AddRepresentation(imageRep);
im.Size = new CGSize((nfloat)width, (nfloat)height);
bmp.Dispose();
return(im);
}
else
{
NSImage img = (NSImage)idesc.Backend;
NSBitmapImageRep bitmap = img.Representations().OfType <NSBitmapImageRep> ().FirstOrDefault();
if (bitmap == null)
{
var imageData = img.AsTiff();
var imageRep = (NSBitmapImageRep)NSBitmapImageRep.ImageRepFromData(imageData);
var im = new NSImage();
im.AddRepresentation(imageRep);
im.Size = new CGSize((nfloat)width, (nfloat)height);
return(im);
}
return(idesc.Backend);
}
}
partial void AddFrame (NSButton sender)
{
NSImage image;
lock (this) {
if (currentImage == null)
return;
var img = CIImage.FromImageBuffer (currentImage);
Console.WriteLine (img);
var imageRep = NSCIImageRep.FromCIImage (CIImage.FromImageBuffer (currentImage));
image = new NSImage (imageRep.Size);
image.AddRepresentation (imageRep);
}
movie.AddImage (image, new QTTime (1, 10), attrs);
movie.CurrentTime = movie.Duration;
movieView.NeedsDisplay = true;
}
