public void DecodingJpegImagePreservesColorSpace()
{
var path = Path.Combine(PathToImages, "baboon.jpg");
var image = SKImage.FromEncodedData(path);
Assert.NotNull(image.ColorSpace);
}
public void ShouldDetectBoundingBoxes_ReasonablyWell(string image, List <YoloBoxRectangle> expectedRectangles)
{
var skImage = SKImage.FromEncodedData(new MemoryStream(File.ReadAllBytes(image)));
var result = _yoloV3Onnx.Detect(skImage);
var averageScore = CalculateAverageScore(result, expectedRectangles);
Assert.GreaterOrEqual(averageScore, 0.8);
}
public unsafe void DataCanBeResurrectedFromImage()
{
var released = false;
var bytes = File.ReadAllBytes(Path.Combine(PathToImages, "baboon.jpg"));
var gch = GCHandle.Alloc(bytes, GCHandleType.Pinned);
using (var image = DoWork(out var dataHandle))
{
Assert.Equal(2, dataHandle.GetReferenceCount(false));
Assert.False(released, "Data was disposed too soon.");
ResurrectData(image);
}
Assert.True(released, "Data was not disposed.");
gch.Free();
SKImage DoWork(out IntPtr handle)
{
var input = SKData.Create(gch.AddrOfPinnedObject(), bytes.Length, (_, __) => released = true);
handle = input.Handle;
var img = SKImage.FromEncodedData(input);
Assert.Equal(3, input.GetReferenceCount());
Assert.False(released, "Data was disposed too soon.");
var result = img.Encode();
Assert.Same(input, result);
Assert.Equal(3, input.GetReferenceCount());
Assert.False(released, "Data was disposed too soon.");
result.Dispose();
Assert.Equal(2, handle.GetReferenceCount(false));
Assert.False(released, "Data was disposed too soon.");
return(img);
}
void ResurrectData(SKImage img)
{
var encoded = img.EncodedData;
Assert.NotNull(encoded);
Assert.Equal(3, encoded.GetReferenceCount());
var handle = encoded.Handle;
encoded.Dispose();
Assert.Equal(2, handle.GetReferenceCount(false));
Assert.False(released, "Data was disposed too soon.");
}
}
public static Image FromStream(Stream ms)
{
var ans = new Bitmap()
{
nativeSkBitmap = SKBitmap.FromImage(SKImage.FromEncodedData(ms))
};
return(ans);
}
// ReSharper disable once InconsistentNaming
public static CachedResourceUsage <SKImage> GetAppPackageSKImage(string path)
{
return(Get(
$"{nameof(ResourceCache)}-AppPackage-{nameof(SKImage)}",
path,
() => SkiFile.OpenAppPackageFileAsync(path),
stream => Task.FromResult(SKImage.FromEncodedData(stream))
));
}
private static readonly SKPaint Paint = new SKPaint(); // Reuse for performance. Only for opacity
public static BitmapInfo LoadBitmap(Stream bitmapStream)
{
bitmapStream.Position = 0;
var image = SKImage.FromEncodedData(SKData.CreateCopy(bitmapStream.ToBytes()));
return(new BitmapInfo {
Bitmap = image
});
}
/// <summary>
/// Converts a base64 string to a SKImage, using minimal suppression via JPEG conversion
/// <param name="base64">The base64 string being converted.</param>
/// </summary>
public static SKImage Base64ToSKImage(string base64)
{
var data = Convert.FromBase64String(base64);
var stream = new MemoryStream(data);
var skData = SKData.Create(stream);
stream.Dispose();
return(SKImage.FromEncodedData(skData));
}
public void ToRasterImageReturnsSameRaster()
{
using var data = SKData.Create(Path.Combine(PathToImages, "baboon.jpg"));
using var image = SKImage.FromEncodedData(data);
Assert.True(image.IsLazyGenerated);
Assert.Null(image.PeekPixels());
Assert.Equal(image, image.ToRasterImage());
}
public void SupportsNonASCIICharactersInPath()
{
var fileName = Path.Combine(PathToImages, "上田雅美.jpg");
using (var image = SKImage.FromEncodedData(fileName))
{
Assert.NotNull(image);
}
}
public BlurFace(string file, int retryAttempts, int nextRetryDelay, List <RestrictedFaceArea> hiddenRects, int jpegQuality)
{
dtStart = DateTime.Now;
if (retryAttempts < 1)
{
retryAttempts = 1;
}
if (nextRetryDelay < 100)
{
nextRetryDelay = 100;
}
if (String.IsNullOrEmpty(file))
{
bytes = null;
}
else
{
bytes = null;
if (File.Exists(file))
{
bool fileIsReady = false;
FileStream fileStream = null;
try
{
do
{
try { fileStream = File.OpenRead(file); fileIsReady = true; }
catch (IOException exc) { Console.WriteLine("Ooops"); }
retryAttempts--;
if (!fileIsReady)
{
Thread.Sleep(nextRetryDelay);
}
}while (!fileIsReady && retryAttempts > 0);
if (fileStream != null)
{
fileStream.Position = 0;
using (SKData data = SKData.Create(fileStream))
using (SKImage image = SKImage.FromEncodedData(data))
{
if (image != null)
{
Process(image, hiddenRects, jpegQuality);
}
}
}
}
catch (Exception exc)
{
}
fileStream = null;
}
}
}
public SKImage RopeSKImage()
{
string resourceID = "RopuForms.rope.svg";
Assembly assembly = GetType().GetTypeInfo().Assembly;
using (Stream stream = assembly.GetManifestResourceStream(resourceID))
{
return(SKImage.FromEncodedData(stream));
}
}
public void EncodedDataBackedImageToUIImage(byte alpha)
{
using var bitmap = CreateTestBitmap(alpha);
using var data = bitmap.Encode(SKEncodedImageFormat.Png, 100);
using var image = SKImage.FromEncodedData(data);
using var uiImage = image.ToUIImage();
ValidateTestBitmap(uiImage, alpha);
}
public void OnImageAvailable(ImageReader reader)
{
Image image = reader.AcquireNextImage();
ByteBuffer buffer = image.GetPlanes()[0].Buffer;
byte[] bytes = new byte[buffer.Remaining()];
buffer.Get(bytes);
Owner.FrameReceived(bytes, SKImage.FromEncodedData(bytes));
image.Close();
}
public Task <SKImage> LoadTextureAsync(string path)
{
return(Task.Run(() =>
{
using (var stream = LoadStream(path))
{
return SKImage.FromEncodedData(stream);
}
}));
}
public void Setup()
{
using var client = new HttpClient();
var data = client.GetByteArrayAsync("https://via.placeholder.com/450").Result;
bitmap = SKBitmap.Decode(data);
image = SKImage.FromEncodedData(data);
surface = new SKBitmap(512, 512);
canvas = new SKCanvas(surface);
paint = new SKPaint();
}
private async void OnPickImage(object sender, EventArgs e)
{
pickedImage?.Dispose();
pickedImage = null;
var picked = await CrossFilePicker.Current.PickFile();
pickedImage = SKImage.FromEncodedData(picked.GetStream());
skiaView.InvalidateSurface();
}
private bool CompareBitmaps(Stream?bitmapStream1, Stream?bitmapStream2, int allowedColorDistance = 0, double proportionCorrect = 1)
{
// The bitmaps in WPF can slightly differ from test to test. No idea why. So introduced proportion correct.
long trueCount = 0;
long falseCount = 0;
if (bitmapStream1 == null && bitmapStream2 == null)
{
return(true);
}
if (bitmapStream1 == null || bitmapStream2 == null)
{
return(false);
}
bitmapStream1.Position = 0;
bitmapStream2.Position = 0;
using var skData1 = SKData.Create(bitmapStream1);
var bitmap1 = SKBitmap.FromImage(SKImage.FromEncodedData(skData1));
using var skData2 = SKData.Create(bitmapStream2);
var bitmap2 = SKBitmap.FromImage(SKImage.FromEncodedData(skData2));
for (var x = 0; x < bitmap1.Width; x++)
{
for (var y = 0; y < bitmap1.Height; y++)
{
var color1 = bitmap1.GetPixel(x, y);
var color2 = bitmap2.GetPixel(x, y);
if (color1 == color2)
{
trueCount++;
}
else
{
if (CompareColors(color1, color2, allowedColorDistance))
{
trueCount++;
}
else
{
falseCount++;
}
}
}
}
var proportion = (double)(trueCount - falseCount) / trueCount;
return(proportionCorrect <= proportion);
}
/// <inheritdoc/>
public Maybe <IImageWrapper> FromFile(string path)
{
if (!File.Exists(path))
{
return(F.None <IImageWrapper>(new M.ImageFileNotFoundMsg(path)));
}
// Create and return image object
using var image = SKImage.FromEncodedData(path);
return(new ImageWrapper(image.EncodedData));
}
public void TextureImageIsValidOnContext()
{
using var ctx = CreateGlContext();
ctx.MakeCurrent();
using var grContext = GRContext.CreateGl();
using var image = SKImage.FromEncodedData(Path.Combine(PathToImages, "baboon.jpg"));
using var texture = image.ToTextureImage(grContext);
Assert.True(texture.IsValid(grContext));
}
public async Task EncodedDataBackedImageToBitmap(byte alpha)
{
using var bitmap = CreateTestBitmap(alpha);
using var data = bitmap.Encode(SKEncodedImageFormat.Png, 100);
using var image = SKImage.FromEncodedData(data);
var source = (SKImageImageSource)image;
using var uiImage = await handler.LoadImageAsync(source);
ValidateTestBitmap(uiImage, alpha);
}
public void RasterImageIsValidAlways()
{
using var image = SKImage.FromEncodedData(Path.Combine(PathToImages, "baboon.jpg"));
Assert.True(image.IsValid(null));
using var ctx = CreateGlContext();
ctx.MakeCurrent();
using var grContext = GRContext.CreateGl();
Assert.True(image.IsValid(grContext));
}
public Image LoadImage(Stream stream)
{
var data = Image.FromStream(stream);
using var image = SKImage.FromEncodedData(data);
return(new Image
{
Data = data,
Width = image.Width,
Height = image.Height
});
}
/// <summary>
/// Imports image from path and resizes it to given dimensions.
/// </summary>
/// <param name="path">Path of image.</param>
public static Surface ImportSurface(string path)
{
using var image = SKImage.FromEncodedData(path);
if (image == null)
{
throw new CorruptedFileException();
}
Surface surface = new Surface(image.Width, image.Height);
surface.SkiaSurface.Canvas.DrawImage(image, new SKPoint(0, 0));
return(surface);
}
public void TestLazyImage()
{
var data = SKData.Create(Path.Combine(PathToImages, "baboon.jpg"));
Assert.NotNull(data);
var image = SKImage.FromEncodedData(data);
Assert.NotNull(image);
Assert.True(image.IsLazyGenerated);
}
public void EncodedDataBackedImageToBitmap(byte alpha)
{
using var bitmap = CreateTestBitmap(alpha);
using var data = bitmap.Encode(SKEncodedImageFormat.Png, 100);
using var image = SKImage.FromEncodedData(data);
using var androidBitmap = image.ToBitmap();
ValidateTestBitmap(androidBitmap, alpha);
androidBitmap.Recycle();
}
internal ExcelPicture(ExcelDrawings drawings, XmlNode node, FileInfo imageFile, Uri hyperlink) :
base(drawings, node, "xdr:pic/xdr:nvPicPr/xdr:cNvPr/@name")
{
XmlElement picNode = node.OwnerDocument.CreateElement("xdr", "pic", ExcelPackage.schemaSheetDrawings);
node.InsertAfter(picNode, node.SelectSingleNode("xdr:to", NameSpaceManager));
_hyperlink = hyperlink;
picNode.InnerXml = PicStartXml();
node.InsertAfter(node.OwnerDocument.CreateElement("xdr", "clientData", ExcelPackage.schemaSheetDrawings), picNode);
//Changed to stream 2/4-13 (issue 14834). Thnx SClause
var package = drawings.Worksheet._package.Package;
ContentType = GetContentType(imageFile.Extension);
var imagestream = new FileStream(imageFile.FullName, FileMode.Open, FileAccess.Read);
_image = SKImage.FromEncodedData(imagestream);
#if (Core)
var img = ImageCompat.GetImageAsByteArray(_image);
#else
ImageConverter ic = new ImageConverter();
var img = (byte[])ic.ConvertTo(_image, typeof(byte[]));
#endif
imagestream.Close();
UriPic = GetNewUri(package, "/xl/media/{0}" + imageFile.Name);
var ii = _drawings._package.AddImage(img, UriPic, ContentType);
string relID;
if (!drawings._hashes.ContainsKey(ii.Hash))
{
Part = ii.Part;
RelPic = drawings.Part.CreateRelationship(UriHelper.GetRelativeUri(drawings.UriDrawing, ii.Uri), Packaging.TargetMode.Internal, ExcelPackage.schemaRelationships + "/image");
relID = RelPic.Id;
_drawings._hashes.Add(ii.Hash, relID);
AddNewPicture(img, relID);
}
else
{
relID = drawings._hashes[ii.Hash];
var rel = _drawings.Part.GetRelationship(relID);
UriPic = UriHelper.ResolvePartUri(rel.SourceUri, rel.TargetUri);
}
ImageHash = ii.Hash;
_height = Image.Height;
_width = Image.Width;
SetPosDefaults(Image);
//Create relationship
node.SelectSingleNode("xdr:pic/xdr:blipFill/a:blip/@r:embed", NameSpaceManager).Value = relID;
package.Flush();
}
/// <summary>
/// Encodes an image for storage.
/// </summary>
/// <param name="imageStream">The image to encode.</param>
/// <returns>The encoded image, or null if decoding fails.</returns>
/// <remarks>
/// The image returned is guaranteed to have no side longer than
/// <see cref="F:HospitalAllocation.Providers.Image.Database.DbImageProvider.MaxSideLength"/> pixels.
/// </remarks>
private static SKData EncodeImage(IImageStream imageStream)
{
// Get the image
var imageArray = new byte[imageStream.Length];
var stream = new MemoryStream(imageArray);
imageStream.CopyTo(stream);
var data = SKData.CreateCopy(imageArray);
var image = SKImage.FromEncodedData(data);
// Decode failed
if (image == null)
{
return(null);
}
// Resize the image if required
if (Math.Max(image.Height, image.Width) > MaxSideLength)
{
int resizedHeight;
int resizedWidth;
float scale;
if (image.Height > image.Width)
{
resizedHeight = MaxSideLength;
scale = ((float)resizedHeight / image.Height);
resizedWidth = (int)Math.Round(image.Width * scale);
}
else
{
resizedWidth = MaxSideLength;
scale = ((float)resizedWidth / image.Width);
resizedHeight = (int)Math.Round(image.Height * scale);
}
var surface = SKSurface.Create(new SKImageInfo(resizedWidth, resizedHeight));
var paint = new SKPaint
{
FilterQuality = SKFilterQuality.High
};
surface.Canvas.Scale(scale);
surface.Canvas.DrawImage(image, 0, 0, paint);
surface.Canvas.Flush();
image = surface.Snapshot();
}
// Encode the image
return(image.Encode(SKEncodedImageFormat.Jpeg, JpegQualityLevel));
}
public MainPage()
{
InitializeComponent();
_currentMatrix = SKMatrix.MakeIdentity();
_images = new List <MyImage>();
_quality = SKFilterQuality.None;
var pinch = new PinchGestureRecognizer();
pinch.PinchUpdated += Pinch_PinchUpdated;
SkiaView.GestureRecognizers.Add(pinch);
SkiaView.EnableTouchEvents = true;
SkiaView.Touch += SkiaView_Touch;
var assembly = typeof(MainPage).GetTypeInfo().Assembly;
_buffer = new List <byte[]>();
for (int i = 0; i < 24; i++)
{
var names = assembly.GetManifestResourceNames();
using (Stream s = assembly.GetManifestResourceStream("SkiaXFPlayground.img" + i + ".jpg"))
{
if (s != null)
{
long length = s.Length;
var b = new byte[length];
s.Read(b, 0, (int)length);
_buffer.Add(b);
}
}
LogLabel.Text = "Loading image: " + i;
}
LogLabel.Text = "buffering finished";
var x = 0;
var y = 0;
var im = SKImage.FromEncodedData(_buffer.ElementAt(0));
var img = new MyImage()
{
Image = im
};
img.Destination = new SKRect(x, y, x + imagesize, y + imagesize);
LogLabel.Text = "image added ";
LogLabel.Text = "decoding finished " + _images.Count;
}
public void ToRasterImageTrueTrueReturnsNonLazy()
{
using var data = SKData.Create(Path.Combine(PathToImages, "baboon.jpg"));
using var image = SKImage.FromEncodedData(data);
Assert.True(image.IsLazyGenerated);
Assert.Null(image.PeekPixels());
using var nonLazy = image.ToRasterImage(true);
Assert.NotEqual(image, nonLazy);
Assert.False(nonLazy.IsLazyGenerated);
Assert.NotNull(nonLazy.PeekPixels());
Assert.Equal(nonLazy, nonLazy.ToRasterImage(true));
}
private static void DrawWebMercatorTilesToRasterCanvas(
SKCanvas outputCanvas,
int width,
int height,
Models.Bounds boundingBox,
IList <Models.TileDataset> sourceTiles,
uint backgroundColor,
int tileSize)
{
var zoom = sourceTiles[0].Z;
var tileMinX = sourceTiles.Min(t => t.X);
var tileMinY = sourceTiles.Min(t => t.Y);
var tilesCountX = sourceTiles.Max(t => t.X) - tileMinX + 1;
var tilesCountY = sourceTiles.Max(t => t.Y) - tileMinY + 1;
var canvasWidth = tilesCountX * tileSize;
var canvasHeight = tilesCountY * tileSize;
var imageInfo = new SKImageInfo(
width: canvasWidth,
height: canvasHeight,
colorType: SKColorType.Rgba8888,
alphaType: SKAlphaType.Premul);
using var surface = SKSurface.Create(imageInfo);
using var canvas = surface.Canvas;
canvas.Clear(new SKColor(backgroundColor));
// Draw all tiles
foreach (var sourceTile in sourceTiles)
{
var offsetX = (sourceTile.X - tileMinX) * tileSize;
var offsetY = (sourceTile.Y - tileMinY) * tileSize;
using var sourceImage = SKImage.FromEncodedData(sourceTile.ImageData);
canvas.DrawImage(sourceImage, SKRect.Create(offsetX, offsetY, tileSize, tileSize)); // Source tile scaled to dest rectangle, if needed
}
// Clip and scale to requested size of output image
var geoBBox = EntitiesConverter.MapRectangleToGeographicalBounds(boundingBox);
var pixelOffsetX = WebMercator.LongitudeToPixelXAtZoom(geoBBox.MinLongitude, zoom) - tileSize * tileMinX;
var pixelOffsetY = WebMercator.LatitudeToPixelYAtZoom(geoBBox.MaxLatitude, zoom) - tileSize * tileMinY;
var pixelWidth = WebMercator.LongitudeToPixelXAtZoom(geoBBox.MaxLongitude, zoom) - WebMercator.LongitudeToPixelXAtZoom(geoBBox.MinLongitude, zoom);
var pixelHeight = WebMercator.LatitudeToPixelYAtZoom(geoBBox.MinLatitude, zoom) - WebMercator.LatitudeToPixelYAtZoom(geoBBox.MaxLatitude, zoom);
var sourceRectangle = SKRect.Create((float)pixelOffsetX, (float)pixelOffsetY, (float)pixelWidth, (float)pixelHeight);
var destRectangle = SKRect.Create(0, 0, width, height);
using SKImage canvasImage = surface.Snapshot();
outputCanvas.DrawImage(canvasImage, sourceRectangle, destRectangle, new SKPaint {
FilterQuality = SKFilterQuality.High,
});
}
