/// <summary>
/// This is the click handler for the 'Solution' button.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void bookmarkBtn_Click(object sender, RoutedEventArgs e)
{
InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream();
await webView8.CapturePreviewToStreamAsync(ms);
//Create a small thumbnail
int longlength = 180, width = 0, height = 0;
double srcwidth = webView8.ActualWidth, srcheight = webView8.ActualHeight;
double factor = srcwidth / srcheight;
if (factor < 1)
{
height = longlength;
width = (int)(longlength * factor);
}
else
{
width = longlength;
height = (int)(longlength / factor);
}
BitmapSource small = await resize(width, height, ms);
BookmarkItem item = new BookmarkItem();
item.Title = webView8.DocumentTitle;
item.PageUrl = webView8.Source;
item.Preview = small;
bookmarks.Add(item);
}
public static async Task <Windows.UI.Xaml.Media.Imaging.BitmapImage> GetBitmapAsync(byte[] data)
{
if (data is null)
{
return(null);
}
var bitmapImage = new Windows.UI.Xaml.Media.Imaging.BitmapImage();
using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
using (var writer = new Windows.Storage.Streams.DataWriter(stream))
{
writer.WriteBytes(data);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
}
stream.Seek(0);
await bitmapImage.SetSourceAsync(stream);
}
return(bitmapImage);
}
public static async Task<IRandomAccessStream> ConvertToRandomAccessStream(Stream source)
{
Stream streamToConvert = null;
if (!source.CanRead)
throw new Exception("The source cannot be read.");
if (!source.CanSeek)
{
var memStream = new MemoryStream();
await source.CopyToAsync(memStream);
streamToConvert = memStream;
}
else
{
streamToConvert = source;
}
var reader = new DataReader(streamToConvert.AsInputStream());
streamToConvert.Position = 0;
await reader.LoadAsync((uint) streamToConvert.Length);
var buffer = reader.ReadBuffer((uint) streamToConvert.Length);
var randomAccessStream = new InMemoryRandomAccessStream();
var outputStream = randomAccessStream.GetOutputStreamAt(0);
await outputStream.WriteAsync(buffer);
await outputStream.FlushAsync();
return randomAccessStream;
}
internal static Bitmap FromStream(Stream stream)
{
Bitmap bitmap = null;
Task.Run(async () =>
{
using (var raStream = new InMemoryRandomAccessStream())
{
await stream.CopyToAsync(raStream.AsStream());
var decoder = await BitmapDecoder.CreateAsync(raStream);
var pixelData = await decoder.GetPixelDataAsync();
var width = (int)decoder.OrientedPixelWidth;
var height = (int)decoder.OrientedPixelHeight;
const PixelFormat format = PixelFormat.Format32bppArgb;
var bytes = pixelData.DetachPixelData();
bitmap = new Bitmap(width, height, format);
var data = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, format);
Marshal.Copy(bytes, 0, data.Scan0, bytes.Length);
bitmap.UnlockBits(data);
}
}).Wait();
return bitmap;
}
public object Convert(object value, Type targetType, object parameter, string language)
{
if (value != null)
{
byte[] bytes = (byte[])value;
BitmapImage myBitmapImage = new BitmapImage();
if (bytes.Count() > 0)
{
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0));
writer.WriteBytes(bytes);
writer.StoreAsync().GetResults();
myBitmapImage.SetSource(stream);
}
else
{
myBitmapImage.UriSource = new Uri("ms-appx:///Assets/firstBackgroundImage.jpg");
}
return myBitmapImage;
}
else
{
return new BitmapImage();
}
}
public static async Task <byte[]> TranscodeImageFile(WriteableBitmap wb)
{
using (var ras = wb.PixelBuffer.AsStream().AsRandomAccessStream())
{
System.Diagnostics.Debug.WriteLine("1");
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(ras);
System.Diagnostics.Debug.WriteLine("2");
var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
System.Diagnostics.Debug.WriteLine("3");
BitmapEncoder encoder = await BitmapEncoder.CreateForTranscodingAsync(memStream, decoder);
encoder.BitmapTransform.ScaledWidth = 320;
encoder.BitmapTransform.ScaledHeight = 240;
System.Diagnostics.Debug.WriteLine("4");
await encoder.FlushAsync();
System.Diagnostics.Debug.WriteLine("5");
var outbuff = new byte[memStream.Size];
System.Diagnostics.Debug.WriteLine("6");
await memStream.WriteAsync(outbuff.AsBuffer());
System.Diagnostics.Debug.WriteLine("7");
return(outbuff);
}
}
private async void GetBijinPicture()
{
var date = DateTime.Now;
var url = "http://www.bijint.com/jp/tokei_images/" + date.ToString("HHmm") + ".jpg";
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Referrer = new Uri("http://www.bijint.com/jp/");
using (var strm = await client.GetStreamAsync(new Uri(url)))
{
// BitmapImageインスタンスへはStream型をそのまま読み込ませることができないため、
// InMemoryRandomAccessStreamへソースストリームをコピーする
InMemoryRandomAccessStream ims = new InMemoryRandomAccessStream();
var output = ims.GetOutputStreamAt(0);
await RandomAccessStream.CopyAsync(strm.AsInputStream(), output);
// BitmapImageへソースを設定し、Imageコントロールで表示させる
var bitmap = new BitmapImage();
bitmap.SetSource(ims);
image.Source = bitmap;
// Save用にbyte配列に保存
ims.Seek(0);
imageBuffer = new byte[ims.Size];
IBuffer ibuffer = imageBuffer.AsBuffer();
await ims.ReadAsync(ibuffer, (uint)ims.Size, InputStreamOptions.None);
}
}
/// <summary>
/// Continuously look for a QR code
/// NOTE: this method won't work if recording is enabled ('hey Cortana, start recording' thing).
/// </summary>
public static async Task<string> ReadAsync(CancellationToken token = default(CancellationToken))
{
var mediaCapture = new MediaCapture();
await mediaCapture.InitializeAsync();
await mediaCapture.AddVideoEffectAsync(new MrcVideoEffectDefinition(), MediaStreamType.Photo);
var reader = new BarcodeReader();
reader.Options.TryHarder = false;
while (!token.IsCancellationRequested)
{
var imgFormat = ImageEncodingProperties.CreateJpeg();
using (var ras = new InMemoryRandomAccessStream())
{
await mediaCapture.CapturePhotoToStreamAsync(imgFormat, ras);
var decoder = await BitmapDecoder.CreateAsync(ras);
using (var bmp = await decoder.GetSoftwareBitmapAsync())
{
Result result = await Task.Run(() =>
{
var source = new SoftwareBitmapLuminanceSource(bmp);
return reader.Decode(source);
});
if (!string.IsNullOrEmpty(result?.Text))
return result.Text;
}
}
await Task.Delay(DelayBetweenScans);
}
return null;
}
public byte[] DrawStrokeOnImageBackground(IReadOnlyList<InkStroke> strokes, byte[] backgroundImageBuffer)
{
var stmbuffer = new InMemoryRandomAccessStream();
stmbuffer.AsStreamForWrite().AsOutputStream().WriteAsync(backgroundImageBuffer.AsBuffer()).AsTask().Wait();
CanvasDevice device = CanvasDevice.GetSharedDevice();
var canbit = CanvasBitmap.LoadAsync(device, stmbuffer, 96).AsTask().Result;
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, canbit.SizeInPixels.Width, canbit.SizeInPixels.Height, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.Transparent);
if (backgroundImageBuffer != null)
{
ds.DrawImage(canbit);
}
ds.DrawInk(strokes);
}
var stm = new InMemoryRandomAccessStream();
renderTarget.SaveAsync(stm, CanvasBitmapFileFormat.Png).AsTask().Wait();
var readfrom = stm.GetInputStreamAt(0).AsStreamForRead();
var ms = new MemoryStream();
readfrom.CopyTo(ms);
var outputBuffer = ms.ToArray();
return outputBuffer;
}
public async static Task<Uri> ToQrDataUri(this ISdp sdp, int width, int height)
{
var qrCodeWriter = new QRCodeWriter();
var bitMatrix = qrCodeWriter.encode(sdp.ToString(), ZXing.BarcodeFormat.QR_CODE, width, height);
using (var canvasRenderTarget = new CanvasRenderTarget(CanvasDevice.GetSharedDevice(), 500, 500, 96))
{
using (var drawingSession = canvasRenderTarget.CreateDrawingSession())
{
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
drawingSession.DrawRectangle(x, y, 1, 1, bitMatrix.get(x, y) ? Color.FromArgb(0, 0, 0, 0) : Color.FromArgb(255, 255, 255, 255));
}
}
}
using (var inMemoryRandomAccessStream = new InMemoryRandomAccessStream())
{
await canvasRenderTarget.SaveAsync(inMemoryRandomAccessStream, CanvasBitmapFileFormat.Png);
inMemoryRandomAccessStream.Seek(0);
var buffer = new byte[inMemoryRandomAccessStream.Size];
await inMemoryRandomAccessStream.ReadAsync(buffer.AsBuffer(), (uint)inMemoryRandomAccessStream.Size, InputStreamOptions.None);
return new Uri($"data:image/png;base64,{Convert.ToBase64String(buffer)}");
}
}
}
private async void ImageUpload(string deviceId)
{
try
{
using (Windows.Storage.Streams.InMemoryRandomAccessStream captureStream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
await mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), captureStream);
await captureStream.FlushAsync();
captureStream.Seek(0);
// Drops file onto device file system for debugging only
#if DEBUG
IStorageFile photoFile = await KnownFolders.PicturesLibrary.CreateFileAsync("Timelapse.jpg", CreationCollisionOption.ReplaceExisting);
ImageEncodingProperties imageProperties = ImageEncodingProperties.CreateJpeg();
await mediaCapture.CapturePhotoToStorageFileAsync(imageProperties, photoFile);
#endif
LoggingService.Log("ImageUploadService Upload starting");
ImageUploadService.Upload(deviceId, captureStream);
LoggingService.Log("ImageUploadService Upload done");
}
}
catch (Exception ex)
{
LoggingService.Error($"Image capture or upload failed ", ex);
}
}
private async void Page_Loaded(object sender, RoutedEventArgs e)
{
await InitializeQrCode();
var imgProp = new ImageEncodingProperties { Subtype = "BMP", Width = 600, Height = 800 };
var bcReader = new BarcodeReader();
while (true)
{
var stream = new InMemoryRandomAccessStream();
await _mediaCapture.CapturePhotoToStreamAsync(imgProp, stream);
stream.Seek(0);
var wbm = new WriteableBitmap(600, 800);
await wbm.SetSourceAsync(stream);
var result = bcReader.Decode(wbm);
if (result != null)
{
var msgbox = new MessageDialog(result.Text);
await msgbox.ShowAsync();
}
}
}
async void BeginReadCCTV()
{
IsBeginRead = true;
ISExit = false;
tblCCTV cctvinfo=null;
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
() =>
{
cctvinfo = this.DataContext as tblCCTV;
});
// client=new HttpClient();
while (!ISExit)
{
try
{
Uri uri = new Uri("http://192.192.161.3/" + cctvinfo.REF_CCTV_ID.Trim() + ".jpg?" + rnd.Next(), UriKind.Absolute);
using (httpClient = new HttpClient())
{
httpClient.Timeout = TimeSpan.FromSeconds(0.5);
var contentBytes = await httpClient.GetByteArrayAsync(uri);
var ims = new InMemoryRandomAccessStream();
var dataWriter = new DataWriter(ims);
dataWriter.WriteBytes(contentBytes);
await dataWriter.StoreAsync();
//ims.seak 0
ims.Seek(0 );
await Dispatcher.RunAsync( Windows.UI.Core.CoreDispatcherPriority.Normal,()=>
{
BitmapImage bitmap = new BitmapImage();
bitmap.SetSource(ims );
this.imgCCTV.Source = bitmap;
imginx = (imginx + 1) % 90000;
this.RunFrameRate.Text = imginx.ToString();
});
}
}
catch (Exception ex)
{
// this.textBlock1.Text = ex.Message;
}
// BitmapImage img = new BitmapImage();
// img.SetSource(stream);
}
}
public async Task<BitmapSource> LoadImageAsync(Stream imageStream, Uri uri)
{
if (imageStream == null)
{
return null;
}
var stream = new InMemoryRandomAccessStream();
imageStream.CopyTo(stream.AsStreamForWrite());
stream.Seek(0);
BitmapImage bitmap = new BitmapImage();
await bitmap.SetSourceAsync(stream);
// convert to a writable bitmap so we can get the PixelBuffer back out later...
// in case we need to edit and/or re-encode the image.
WriteableBitmap bmp = new WriteableBitmap(bitmap.PixelHeight, bitmap.PixelWidth);
stream.Seek(0);
bmp.SetSource(stream);
List<Byte> allBytes = new List<byte>();
byte[] buffer = new byte[4000];
int bytesRead = 0;
while ((bytesRead = await imageStream.ReadAsync(buffer, 0, 4000)) > 0)
{
allBytes.AddRange(buffer.Take(bytesRead));
}
DataContainerHelper.Instance.WriteableBitmapToStorageFile(bmp, uri);
return bmp;
}
async Task<WriteableBitmap> ResizeImage(WriteableBitmap baseWriteBitmap, uint width, uint height)
{
Stream stream = baseWriteBitmap.PixelBuffer.AsStream();
byte[] pixels = new byte[(uint)stream.Length];
await stream.ReadAsync(pixels, 0, pixels.Length);
var inMemoryRandomStream = new InMemoryRandomAccessStream();
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, inMemoryRandomStream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)baseWriteBitmap.PixelWidth, (uint)baseWriteBitmap.PixelHeight, 96, 96, pixels);
await encoder.FlushAsync();
var transform = new BitmapTransform
{
ScaledWidth = width,
ScaledHeight = height
};
inMemoryRandomStream.Seek(0);
var decoder = await BitmapDecoder.CreateAsync(inMemoryRandomStream);
var pixelData = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Straight,
transform,
ExifOrientationMode.IgnoreExifOrientation,
ColorManagementMode.DoNotColorManage);
var sourceDecodedPixels = pixelData.DetachPixelData();
var inMemoryRandomStream2 = new InMemoryRandomAccessStream();
var encoder2 = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, inMemoryRandomStream2);
encoder2.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, width, height, 96, 96, sourceDecodedPixels);
await encoder2.FlushAsync();
inMemoryRandomStream2.Seek(0);
var bitmap = new WriteableBitmap((int)width, (int)height);
await bitmap.SetSourceAsync(inMemoryRandomStream2);
return bitmap;
}
public async static void GetImageSize(this Stream imageStream)
{
var image = new BitmapImage();
byte[] imageBytes = Convert.FromBase64String(imageStream.ToBase64String());
MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
ms.Write(imageBytes, 0, imageBytes.Length);
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0)))
{
try
{
writer.WriteBytes(imageBytes);
await writer.StoreAsync();
}
catch (Exception)
{
// ignored
}
}
try
{
await image.SetSourceAsync(stream);
}
catch (Exception)
{
// ignored
}
}
ImageSize = new Size(image.PixelWidth, image.PixelHeight);
}
// TODO: 一分ごとに画像と名前を取得する
private async void GetBijinInfo()
{
var date = this.Current;
getKawaii(this.path + this.Current.ToString("HHmm"));
var url = "http://www.bijint.com/" + Path + "/tokei_images/" + date.ToString("HHmm") + ".jpg";
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Referrer = new Uri("http://www.bijint.com/" + path);
using (var strm = await client.GetStreamAsync(new Uri(url)))
{
// BitmapImageインスタンスへはStream型をそのまま読み込ませることができないため、
// InMemoryRandomAccessStreamへソースストリームをコピーする
InMemoryRandomAccessStream ims = new InMemoryRandomAccessStream();
var output = ims.GetOutputStreamAt(0);
await RandomAccessStream.CopyAsync(strm.AsInputStream(), output);
// BitmapImageへソースを設定し、Imageコントロールで表示させる
var bitmap = new BitmapImage();
bitmap.SetSource(ims);
this.Image = bitmap;
}
var html = await client.GetStringAsync("http://www.bijint.com/" + Path + "/cache/" + date.ToString("HHmm") + ".html");
var lines = html.Split('\n').Select(input => input.Trim()).Where(input => input != "\r" || input != "").ToList();
var nameLineIndex = lines.IndexOf("<thead>") + 2;
var nameLine = lines[nameLineIndex];
var temp = nameLine.Substring(0, nameLine.Length - 5);
var lastEnd = temp.LastIndexOf('>');
this.Subtitle = temp.Substring(lastEnd + 1);
}
public async Task<BitmapImage> GetBijinPicture(string Path)
{
var date = DateTime.Now;
var url = "http://www.bijint.com/" + Path + "/tokei_images/" + date.ToString("HHmm") + ".jpg";
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Referrer = new Uri("http://www.bijint.com/" + Path);
BitmapImage bitmap;
using (var strm = await client.GetStreamAsync(new Uri(url)))
{
// BitmapImageインスタンスへはStream型をそのまま読み込ませることができないため、
// InMemoryRandomAccessStreamへソースストリームをコピーする
InMemoryRandomAccessStream ims = new InMemoryRandomAccessStream();
var output = ims.GetOutputStreamAt(0);
await RandomAccessStream.CopyAsync(strm.AsInputStream(), output);
// BitmapImageへソースを設定し、Imageコントロールで表示させる
bitmap = new BitmapImage();
bitmap.SetSource(ims);
}
return bitmap;
//var html = await client.GetStringAsync("http://www.bijint.com/kobe/cache/" + date.ToString("HHmm") + ".html");
//this.html.NavigateToString(html);
}
private async Task<byte[]> ImageToBytes(IRandomAccessStream sourceStream)
{
byte[] imageArray;
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(sourceStream);
var transform = new BitmapTransform { ScaledWidth = decoder.PixelWidth, ScaledHeight = decoder.PixelHeight };
PixelDataProvider pixelData = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Rgba8,
BitmapAlphaMode.Straight,
transform,
ExifOrientationMode.RespectExifOrientation,
ColorManagementMode.DoNotColorManage);
using (var destinationStream = new InMemoryRandomAccessStream())
{
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, destinationStream);
encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied, decoder.PixelWidth,
decoder.PixelHeight, 96, 96, pixelData.DetachPixelData());
await encoder.FlushAsync();
BitmapDecoder outputDecoder = await BitmapDecoder.CreateAsync(destinationStream);
await destinationStream.FlushAsync();
imageArray = (await outputDecoder.GetPixelDataAsync()).DetachPixelData();
}
return imageArray;
}
public async void ProccesImage(StorageFile imageFile)
{
var data = await FileIO.ReadBufferAsync(imageFile);
// create a stream from the file
var ms = new InMemoryRandomAccessStream();
var dw = new DataWriter(ms);
dw.WriteBuffer(data);
await dw.StoreAsync();
ms.Seek(0);
// find out how big the image is, don't need this if you already know
var bm = new BitmapImage();
await bm.SetSourceAsync(ms);
// create a writable bitmap of the right size
var wb = new WriteableBitmap(bm.PixelWidth, bm.PixelHeight);
ms.Seek(0);
// load the writable bitpamp from the stream
await wb.SetSourceAsync(ms);
Bitmap bmp = (Bitmap)wb;
//var filter1 = Grayscale.CommonAlgorithms.BT709;
//bmp = filter1.Apply(bmp);
wb = (WriteableBitmap)bmp;
var file = await this.WriteableBitmapToStorageFile(wb, FileFormat.Jpeg);
}
private async void OnDeferredImageRequestedHandler(DataProviderRequest request)
{
// In this delegate we provide updated Bitmap data using delayed rendering.
if (_imageFile != null)
{
// If the delegate is calling any asynchronous operations it needs to acquire
// the deferral first. This lets the system know that you are performing some
// operations that might take a little longer and that the call to SetData
// could happen after the delegate returns. Once you acquired the deferral object
// you must call Complete on it after your final call to SetData.
DataProviderDeferral deferral = request.GetDeferral();
InMemoryRandomAccessStream inMemoryStream = new InMemoryRandomAccessStream();
// Make sure to always call Complete when finished with the deferral.
try
{
// Decode the image and re-encode it at 50% width and height.
IRandomAccessStream imageStream = await _imageFile.OpenAsync(FileAccessMode.Read);
BitmapDecoder imageDecoder = await BitmapDecoder.CreateAsync(imageStream);
BitmapEncoder imageEncoder = await BitmapEncoder.CreateForTranscodingAsync(inMemoryStream, imageDecoder);
imageEncoder.BitmapTransform.ScaledWidth = (uint)(imageDecoder.OrientedPixelWidth * 0.5);
imageEncoder.BitmapTransform.ScaledHeight = (uint)(imageDecoder.OrientedPixelHeight * 0.5);
await imageEncoder.FlushAsync();
request.SetData(RandomAccessStreamReference.CreateFromStream(inMemoryStream));
}
finally
{
deferral.Complete();
}
}
}
public async Task<BitmapImage> Base64ToBitmapImage(string base64String)
{
BitmapImage img = new BitmapImage();
if (string.IsNullOrEmpty(base64String))
return img;
using (var ims = new InMemoryRandomAccessStream())
{
byte[] bytes = Convert.FromBase64String(base64String);
base64String = "";
using (DataWriter dataWriter = new DataWriter(ims))
{
dataWriter.WriteBytes(bytes);
bytes = null;
await dataWriter.StoreAsync();
ims.Seek(0);
await img.SetSourceAsync(ims); //not in RC
return img;
}
}
}
public async Task Should_read_correctly_formatted_stream()
{
using (var input = new InMemoryRandomAccessStream())
using (var expectedData = TestFiles.Read("IO.HashedBlockStream.Content.bin"))
{
await CopyData(input, "IO.HashedBlockStream.bin");
input.Seek(0);
expectedData.Seek(0);
using (var actualData = await HashedBlockFileFormat.Read(input))
{
Assert.Equal(expectedData.Size, (ulong)actualData.Length);
var actual = new byte[1024];
var expected = WindowsRuntimeBuffer.Create(actual.Length);
while (true)
{
expected = await expectedData.ReadAsync(expected);
var read = await actualData.ReadAsync(actual, 0, actual.Length);
Assert.Equal(expected.Length, (uint)read);
if (read == 0)
break;
Assert.Equal(expected.ToArray(), actual.Take(read));
}
}
}
}
public static async Task <byte[]> TranscodeImageFile(byte[] data)
{
using (IRandomAccessStream stream = data.AsBuffer().AsStream().AsRandomAccessStream())
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var outstream = new InMemoryRandomAccessStream();
BitmapEncoder encoder = await BitmapEncoder.CreateForTranscodingAsync(memStream, decoder);
encoder.BitmapTransform.ScaledWidth = 320;
encoder.BitmapTransform.ScaledHeight = 240;
await encoder.FlushAsync();
memStream.Seek(0);
await RandomAccessStream.CopyAsync(memStream, outstream);
memStream.Dispose();
var outbuff = new byte[outstream.Size];
await outstream.WriteAsync(outbuff.AsBuffer());
return(outbuff);
}
}
private async void Button_Click_2(object sender, RoutedEventArgs e)
{
var mem = new InMemoryRandomAccessStream();
var enc = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, mem);
int width = 140, height = 140;
int plane = 4;
byte[] data = new byte[width * height * plane];
int offset = 0;
for (int y = 0; y < width; y++)
{
for (int x = 0; x < height; x++)
{
data[offset + 0] = 0xFF; // R
data[offset + 1] = 0x00; // G
data[offset + 2] = 0x00; // B
data[offset + 3] = 0xFF; // Alpha
offset += 4;
}
}
enc.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight,
(uint)width, (uint)height, 96, 96, data);
await enc.FlushAsync();
BitmapImage bmp = new BitmapImage();
bmp.SetSource(mem);
image1.Source = bmp;
}
public async static Task<IRandomAccessStream> AsRandomAccessStreamAsync(this Stream stream)
{
Stream streamToConvert = null;
if (!stream.CanRead)
{
throw new Exception("Cannot read the source stream-");
}
if (!stream.CanSeek)
{
MemoryStream memoryStream = new MemoryStream();
await stream.CopyToAsync(memoryStream);
streamToConvert = memoryStream;
}
else
{
streamToConvert = stream;
}
DataReader dataReader = new DataReader(streamToConvert.AsInputStream());
streamToConvert.Position = 0;
await dataReader.LoadAsync((uint)streamToConvert.Length);
IBuffer buffer = dataReader.ReadBuffer((uint)streamToConvert.Length);
InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream();
IOutputStream outputstream = randomAccessStream.GetOutputStreamAt(0);
await outputstream.WriteAsync(buffer);
await outputstream.FlushAsync();
return randomAccessStream;
}
public async Task<byte[]> ConvertToGrayScale(byte[] imageBytes, int height, int width)
{
using (InMemoryRandomAccessStream rasStream = new InMemoryRandomAccessStream())
{
await rasStream.WriteAsync(imageBytes.AsBuffer());
var decoder = await BitmapDecoder.CreateAsync(rasStream);
var pixelData = await decoder.GetPixelDataAsync();
var pixels = pixelData.DetachPixelData();
if (_filter == null)
_filter = new ImageFilter();
await _filter.ToGrayScale(pixels.AsBuffer());
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, rasStream);
encoder.SetPixelData(decoder.BitmapPixelFormat, BitmapAlphaMode.Ignore, (uint)width, (uint)height, decoder.DpiX, decoder.DpiY, pixels);
await encoder.FlushAsync();
using (BinaryReader br = new BinaryReader(rasStream.AsStreamForRead()))
{
rasStream.Seek(0);
return br.ReadBytes((int)rasStream.AsStreamForRead().Length);
}
}
}
public static async Task<IRandomAccessStream> RenderToRandomAccessStream(this UIElement element) {
var rtb = new RenderTargetBitmap();
await rtb.RenderAsync(element);
IBuffer pixelBuffer = await rtb.GetPixelsAsync();
byte[] pixels = pixelBuffer.ToArray();
// Useful for rendering in the correct DPI
DisplayInformation displayInformation = DisplayInformation.GetForCurrentView();
var stream = new InMemoryRandomAccessStream();
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Premultiplied,
(uint)rtb.PixelWidth,
(uint)rtb.PixelHeight,
displayInformation.RawDpiX,
displayInformation.RawDpiY,
pixels);
await encoder.FlushAsync();
stream.Seek(0);
return stream;
}
private async Task RenderUIElement(FrameworkElement elm, string fileName, int width, int height) {
await System.Threading.Tasks.Task.Delay(TimeSpan.FromSeconds(1));
using (InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream())
{
var renderTargetBitmap = new RenderTargetBitmap();
await renderTargetBitmap.RenderAsync(elm);
var pixels = await renderTargetBitmap.GetPixelsAsync();
var logicalDpi = DisplayInformation.GetForCurrentView().LogicalDpi;
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, ms);
encoder.SetPixelData(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Ignore,
(uint)renderTargetBitmap.PixelWidth,
(uint)renderTargetBitmap.PixelHeight,
logicalDpi,
logicalDpi,
pixels.ToArray());
await encoder.FlushAsync();
await X.Services.Image.Service.Instance.GenerateResizedImageAsync(width, elm.ActualWidth, elm.ActualHeight, ms, fileName + ".png", Services.Image.Service.location.TileFolder, height);
}
}
public async Task<string> RenderToBase64(UIElement element)
{
RenderTargetBitmap rtb = new RenderTargetBitmap();
await rtb.RenderAsync(element);
var pixelBuffer = await rtb.GetPixelsAsync();
var pixels = pixelBuffer.ToArray();
// Useful for rendering in the correct DPI
var displayInformation = DisplayInformation.GetForCurrentView();
var stream = new InMemoryRandomAccessStream();
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Premultiplied,
(uint)rtb.PixelWidth,
(uint)rtb.PixelHeight,
displayInformation.RawDpiX,
displayInformation.RawDpiY,
pixels);
await encoder.FlushAsync();
stream.Seek(0);
// read bytes
var bytes = new byte[stream.Size];
await stream.AsStream().ReadAsync(bytes, 0, bytes.Length);
// create base64
return Convert.ToBase64String(bytes);
}
/// <summary>
/// Asynchronously saves the <paramref name="photo" /> given to the camera roll album.
/// </summary>
/// <param name="photo">Photo to save.</param>
/// <returns>Image with thumbnail.</returns>
/// <exception cref="ArgumentNullException"><paramref name="photo"/> is <see langword="null"/>.</exception>
public async Task<IThumbnailedImage> SaveResultToCameraRollAsync(ICapturedPhoto photo)
{
if (photo == null)
{
throw new ArgumentNullException("photo");
}
Tracing.Trace("StorageService: Trying to save picture to the Camera Roll.");
Picture cameraRollPicture;
string name = this.GeneratePhotoName();
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
// Convert image to JPEG format and rotate in accordance with the original photo orientation.
Tracing.Trace("StorageService: Converting photo to JPEG format. Size: {0}x{1}, Rotation: {2}", photo.Width, photo.Height, photo.Rotation);
byte[] pixelData = await photo.DetachPixelDataAsync();
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream);
encoder.BitmapTransform.Rotation = photo.Rotation;
encoder.BitmapTransform.Flip = photo.Flip;
encoder.IsThumbnailGenerated = true;
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, photo.Width, photo.Height, Constants.DefaultDpiX, Constants.DefaultDpiY, pixelData);
await encoder.FlushAsync();
cameraRollPicture = this.lazyMediaLibrary.Value.SavePictureToCameraRoll(name, stream.AsStream());
}
Tracing.Trace("StorageService: Saved to Camera Roll as {0}", name);
return new MediaLibraryThumbnailedImage(cameraRollPicture);
}
public object Convert(object value, Type targetType, object parameter, string language)
{
if (value != null && value is byte[])
{
//WriteableBitmap bitmap = new WriteableBitmap(100, 100);
//System.IO.Stream bitmapStream = null;
//bitmapStream = bitmap.PixelBuffer.AsStream();
//bitmapStream.Position = 0;
//bitmapStream.Write(value as byte[], 0, (value as byte[]).Length);
//bitmapStream.Flush();
InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream();
DataWriter writer = new DataWriter(randomAccessStream.GetOutputStreamAt(0));
writer.WriteBytes(value as byte[]);
var x = writer.StoreAsync().AsTask().Result;
BitmapImage image = new BitmapImage();
image.SetSource(randomAccessStream);
return image;
}
return null;
}
//</SnippetVertices>
/// <summary>
/// Fixes issue in API where textures are not saved correctly
/// </summary>
/// <param name="modelStream">3dmodel.model data</param>
/// <returns></returns>
private async Task <IRandomAccessStream> FixTextureContentType(IRandomAccessStream modelStream)
{
XDocument xmldoc = XDocument.Load(modelStream.AsStreamForRead());
var outputStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var writer = new Windows.Storage.Streams.DataWriter(outputStream);
writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
writer.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;
writer.WriteString("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
var text = xmldoc.ToString();
// ensure that content type is set correctly
// texture content can be either png or jpg
var replacedText = text.Replace("contenttype=\"\"", "contenttype=\"image/png\"");
writer.WriteString(replacedText);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
return(outputStream);
}
public static async Task<IBuffer> SaveAsPngIntoBufferAsync(this Canvas canvas, double _scaleFactor, int dpiForImage = 200)
{
//string currentresolution = Window.Current.Bounds.Width * scaleFactor + "*" + Window.Current.Bounds.Height * scaleFactor;
RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap();
await renderTargetBitmap.RenderAsync(canvas);
var pixels = await renderTargetBitmap.GetPixelsAsync();
using (IRandomAccessStream stream = new InMemoryRandomAccessStream())
{
var encoder = await
BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
byte[] bytes = pixels.ToArray();
await CoreWindow.GetForCurrentThread().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
encoder.SetPixelData(BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Ignore,
(uint)(canvas.ActualWidth * _scaleFactor), (uint)(canvas.ActualHeight * _scaleFactor),
dpiForImage, dpiForImage, bytes);
});
await encoder.FlushAsync();
stream.Seek(0);
var buffer = WindowsRuntimeBuffer.Create((int)stream.Size);
await stream.ReadAsync(buffer, (uint)stream.Size, InputStreamOptions.None);
return buffer;
}
}
public async Task <Windows.Storage.Streams.InMemoryRandomAccessStream> GetStreamUWP(double width, double height)
{
var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
await RenderToStreamAsync(stream, width, height);
return(stream);
}
private async Task WriteImage()
{
if (currentImageIndex == -1)
{
return;
}
try
{
await CreateFolder();
StorageFile outputFile = await projectFolder.CreateFileAsync(filesNames.ElementAt(currentImageIndex), CreationCollisionOption.ReplaceExisting);
var stream = (await outputFile.OpenStreamForWriteAsync()).AsRandomAccessStream();
Guid encoderId;
if (filesNames.ElementAt(currentImageIndex).Contains(".jpg"))
{
encoderId = Windows.Graphics.Imaging.BitmapEncoder.JpegEncoderId;
}
var inputStream = await files.ElementAt(currentImageIndex).OpenStreamForReadAsync();
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(inputStream.AsRandomAccessStream());
var inputProperties = decoder.BitmapProperties;
var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
BitmapEncoder encoder2 = await BitmapEncoder.CreateForTranscodingAsync(memStream, decoder);
WriteImageMetadata(encoder2, inputProperties);
await encoder2.FlushAsync();
memStream.Seek(0);
stream.Seek(0);
stream.Size = 0;
await RandomAccessStream.CopyAsync(memStream, stream);
memStream.Dispose();
stream.Dispose();
inputStream.Dispose();
if (latitude.Text != null)
{
await GeotagHelper.SetGeotagAsync(outputFile, myLocation);
}
}
catch (Exception err)
{
switch (err.HResult)
{
case unchecked ((int)0x88982F41): // WINCODEC_ERR_PROPERTYNOTSUPPORTED
// The file format does not support this property.
break;
default:
break;
}
}
}
/// <summary>
/// あとでファイルとして保存できるように共有Bitmapの情報を保存しておく.
/// </summary>
/// <param name="inStream"></param>
/// <returns></returns>
private async Task KeepSharedBitmapInfoAsync(Windows.Storage.Streams.IRandomAccessStreamWithContentType inStream)
{
var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(inStream);
this.fileName = DateTimeOffset.UtcNow.Ticks.ToString() + decoder.DecoderInformation.FileExtensions[0];
this.imageStream = new InMemoryRandomAccessStream();
inStream.Seek(0);
await Windows.Storage.Streams.RandomAccessStream.CopyAsync(inStream, imageStream);
}
private async void SaveSoftwareBitmapToFile(SoftwareBitmap softwareBitmap)
{
using (var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
// (IRandomAccessStream stream = await outputFile.OpenAsync(FileAccessMode.ReadWrite))
{
// Create an encoder with the desired format
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, memStream);
// Set the software bitmap
encoder.SetSoftwareBitmap(softwareBitmap);
// Set additional encoding parameters, if needed
encoder.BitmapTransform.ScaledWidth = 320;
encoder.BitmapTransform.ScaledHeight = 240;
//encoder.BitmapTransform.Rotation = Windows.Graphics.Imaging.BitmapRotation.Clockwise90Degrees;
encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Fant;
encoder.IsThumbnailGenerated = true;
try
{
await encoder.FlushAsync();
// UploadImage
// An array containing the decoded image data, which could be modified before being displayed
IBuffer buff = new Windows.Storage.Streams.Buffer((uint)memStream.Size);
memStream.Seek(0);
IBuffer c = await memStream.ReadAsync(buff, buff.Capacity, InputStreamOptions.None);
//WindowsRuntimeBufferExtensions.ToArray http://cctvapi.azurewebsites.net
//await UploadImage("http://localhost:56407/Api/File/", buff.ToArray()) ; http://peopledetectionapiapp.azurewebsites.net/swagger/ui/index
//await UploadImage("http://cctvapi.azurewebsites.net/Api/File/", buff.ToArray());
await UploadImage("http://peopledetectionapiapp.azurewebsites.net/swagger/ui/index", buff.ToArray());
}
catch (Exception err)
{
switch (err.HResult)
{
case unchecked ((int)0x88982F81): //WINCODEC_ERR_UNSUPPORTEDOPERATION
// If the encoder does not support writing a thumbnail, then try again
// but disable thumbnail generation.
encoder.IsThumbnailGenerated = false;
break;
default:
throw err;
}
}
if (encoder.IsThumbnailGenerated == false)
{
await encoder.FlushAsync();
}
}
}
private async void buttonTakePhotoClick(object sender, RoutedEventArgs e)
{
if (capturePreview.Source == null)
{
return;
}
// プレビューに付けた MediaCapture オブジェクトを取り出す
Windows.Media.Capture.MediaCapture capture = capturePreview.Source;
// 保存する画像ファイルのフォーマット (pngファイルを指定)
var imageProperties = Windows.Media.MediaProperties.ImageEncodingProperties.CreatePng();
// 撮影する。撮影した画像の stream が返ってくる。
// 自前のコードで WriteableBitmap に変換
using (var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
try
{
await capture.CapturePhotoToStreamAsync(imageProperties, memStream);
// キャプチャ開始から撮影までの間に許可を取り消されると、ここで例外が出る
// 「指定されたファイル ハンドルへのアクセスが取り消されました。 (HRESULT からの例外: 0x80070326)」
}
catch (Exception ex)
{
ShowRequestMessageAsync(ex);
return;
}
captureImage.Source = await memStream.ToWriteableBitmap();
}
// 撮影する。素直にいったんファイルに落とす方法
//StorageFile file = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("test.png", CreationCollisionOption.GenerateUniqueName);
//try
//{
// await capture.CapturePhotoToStorageFileAsync(imageProperties, file);
// // キャプチャ開始から撮影までの間に許可を取り消されると、ここで例外が出る
// // 「指定されたファイル ハンドルへのアクセスが取り消されました。 (HRESULT からの例外: 0x80070326)」
//}
//catch (Exception ex)
//{
// ShowRequestMessageAsync(ex);
// return;
//}
//using (var stream = await file.OpenReadAsync())
//{
// var bi = new BitmapImage();
// bi.SetSource(stream);
// captureImage.Source = bi;
//}
}
private async Task LoadBrushAsync()
{
using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
await ImageSource.ToStream(stream, BitmapEncoder.BmpEncoderId);
stream.Seek(0);
ImageEffectsBrush.LoadImageFromStream(stream);
}
}
private CDTrackStream(string deviceID, int startSector, int endSector)
{
DeviceID = deviceID;
StartSector = startSector;
EndSector = endSector;
WriteDataIndex = 0;
ReadDataIndex = 0;
internalStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
}
private async Task <Windows.Storage.Streams.IRandomAccessStream> toStream(Windows.Storage.Streams.IBuffer ibuffer)
{
var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var outputStream = stream.GetOutputStreamAt(0);
var datawriter = new Windows.Storage.Streams.DataWriter(outputStream);
datawriter.WriteBuffer(ibuffer);
await datawriter.StoreAsync();
await outputStream.FlushAsync();
return(stream);
}
public async Task <WriteableBitmap> GetImageSourceAsync()
{
WriteableBitmap bmp = new WriteableBitmap(ImageBitmap.PixelWidth, ImageBitmap.PixelHeight);
using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
await ImageBitmap.ToStream(stream, BitmapEncoder.BmpEncoderId);
stream.Seek(0);
await bmp.SetSourceAsync(stream);
}
return(bmp);
}
private async void MyBooksSelectionChanged(object sender, RoutedEventArgs e)
{
var selected = flipMyBooks.SelectedItem as EbookViewModel;
if (selected == null)
{
return;
}
ProgressRingBooks.IsActive = true;
ObservableCollection <ImageSource> pdf = null;
if (gvImages.ItemsSource != null)
{
pdf = gvImages.ItemsSource as ObservableCollection <ImageSource>;
gvImages.SelectedIndex = 0;
pdf.Clear();
}
else
{
pdf = new ObservableCollection <ImageSource>();
gvImages.ItemsSource = pdf;
}
var query = new GetAllEbookPartsQuery();
await query.ExecuteAsync(OAuthSettings.AccessToken, selected.Id, selected.PartCount,
async (sourceStream) =>
{
var stream = new InMemoryRandomAccessStream();
await sourceStream.CopyToAsync(stream.AsStreamForWrite());
var doc = await PdfDocument.LoadFromStreamAsync(stream);
for (uint i = 0; i < doc.PageCount; ++i)
{
var bmpStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
await doc.GetPage(i).RenderToStreamAsync(bmpStream);
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
var bmp = new BitmapImage();
bmp.SetSource(bmpStream);
pdf.Add(bmp);
});
}
});
ProgressRingBooks.IsActive = false;
}
private async Task LoadMyEbooksAsync()
{
List <EbookViewModel> viewModels = new List <EbookViewModel>();
var ebooks = await new GetMyEbooksQuery().ExecuteAsync(OAuthSettings.AccessToken);
foreach (var ebook in ebooks)
{
var img = new BitmapImage();
var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
stream.GetOutputStreamAt(0).AsStreamForWrite().Write(ebook.Thumbnail, 0, ebook.Thumbnail.Length);
await img.SetSourceAsync(stream);
viewModels.Add(new EbookViewModel(ebook, img));
}
flipMyBooks.ItemsSource = viewModels;
}
/// <summary>
/// 指定範囲のキャプチャ画像をSoftwareBitmap型として得る
/// </summary>
/// <param name="left">キャプチャ範囲の左端端x座標</param>
/// <param name="top">キャプチャ範囲の左端端y座標</param>
/// <param name="height">キャプチャ範囲の高さ</param>
/// <param name="width">キャプチャ範囲の幅</param>
/// <returns>指定された範囲のキャプチャ画像</returns>
public static async Task <SoftwareBitmap> CaptureAsSoftwareBitmap(int left, int top, int height, int width)
{
//ビットマップの保持領域を確保
Bitmap partialCapture = new Bitmap(width, height);
//描画インターフェイスの設定
Graphics draw = Graphics.FromImage(partialCapture);
//画面全体をコピーする
draw.CopyFromScreen(
left,
top,
0, 0,
partialCapture.Size
);
//解放
draw.Dispose();
MemoryStream memStream = new MemoryStream();
partialCapture.Save(memStream, ImageFormat.Bmp);
SoftwareBitmap softwareBitmap;
using (var randomAccessStream = new UwpInMemoryRandomAccessStream())
{
using (var outputStream = randomAccessStream.GetOutputStreamAt(0))
using (var writer = new UwpDataWriter(outputStream))
{
writer.WriteBytes(memStream.ToArray());
await writer.StoreAsync();
await outputStream.FlushAsync();
}
// IRandomAccessStreamをSoftwareBitmapに変換
// （ここはUWP APIのデコーダーを使う）
var decoder = await UwpBitmapDecoder.CreateAsync(randomAccessStream);
softwareBitmap = await decoder.GetSoftwareBitmapAsync(UwpBitmapPixelFormat.Bgra8, UwpBitmapAlphaMode.Premultiplied);
}
return(softwareBitmap);
}
void BitmapRequested(CustomMapTileDataSource sender, MapTileBitmapRequestedEventArgs args)
{
var deferral = args.Request.GetDeferral();
IRandomAccessStreamReference referenceStream;
double lat, lon = 0;
int pixelX, pixelY = 0;
Microsoft.MapPoint.TileSystem.TileXYToPixelXY(args.X, args.Y, out pixelX, out pixelY);
Microsoft.MapPoint.TileSystem.PixelXYToLatLong(pixelX, pixelY, args.ZoomLevel, out lat, out lon);
BasicGeoposition northWest = new BasicGeoposition {
Latitude = lat, Longitude = lon
};
Microsoft.MapPoint.TileSystem.PixelXYToLatLong(pixelX + (int)sizeOfMapTile, pixelY + (int)sizeOfMapTile, args.ZoomLevel, out lat, out lon);
BasicGeoposition southEast = new BasicGeoposition {
Latitude = lat, Longitude = lon
};
GeoboundingBox tileBox = new GeoboundingBox(northWest, southEast);
if (tileBox.CollidesWith(PathBox))
{
if (PathCache.pointInPolygon(northWest.Longitude, northWest.Latitude) &&
PathCache.pointInPolygon(southEast.Longitude, southEast.Latitude) &&
PathCache.pointInPolygon(northWest.Longitude, southEast.Latitude) &&
PathCache.pointInPolygon(southEast.Longitude, northWest.Latitude))
{
referenceStream = RandomAccessStreamReference.CreateFromStream(InTile);
}
else
{
var cutter = new Windows.Storage.Streams.InMemoryRandomAccessStream();
cutTile(cutter, pixelX, pixelY, args.ZoomLevel);
referenceStream = RandomAccessStreamReference.CreateFromStream(cutter);
}
}
else
{
referenceStream = RandomAccessStreamReference.CreateFromStream(OutTile);
}
args.Request.PixelData = referenceStream;
deferral.Complete();
}
private async Task updateImage(Image cameraImage, string url)
{
// Download the image into memory as a stream
System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
System.Net.Http.HttpResponseMessage imageResponse = await client.GetAsync(url);
InMemoryRandomAccessStream randomAccess =
new Windows.Storage.Streams.InMemoryRandomAccessStream();
DataWriter writer =
new Windows.Storage.Streams.DataWriter(randomAccess.GetOutputStreamAt(0));
writer.WriteBytes(await imageResponse.Content.ReadAsByteArrayAsync());
await writer.StoreAsync();
BitmapImage bit = new BitmapImage();
await bit.SetSourceAsync(randomAccess);
cameraImage.Source = bit;
}
// </SnippetCreateSoftwareBitmapFromSurface>
// <SnippetTranscodeImageFile>
private async void TranscodeImageFile(StorageFile imageFile)
{
using (IRandomAccessStream fileStream = await imageFile.OpenAsync(FileAccessMode.ReadWrite))
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream);
var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
BitmapEncoder encoder = await BitmapEncoder.CreateForTranscodingAsync(memStream, decoder);
encoder.BitmapTransform.ScaledWidth = 320;
encoder.BitmapTransform.ScaledHeight = 240;
await encoder.FlushAsync();
memStream.Seek(0);
fileStream.Seek(0);
fileStream.Size = 0;
await RandomAccessStream.CopyAsync(memStream, fileStream);
memStream.Dispose();
}
}
private async Task <IRandomAccessStream> FixTextureContentType(IRandomAccessStream modelStream)
{
XDocument xmldoc = XDocument.Load(modelStream.AsStreamForRead());
var outputStream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var writer = new Windows.Storage.Streams.DataWriter(outputStream);
writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
writer.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;
var text = xmldoc.ToString();
var replacedText = text.Replace("contenttype=\"\"", "contenttype=\"image/png\"");
writer.WriteString(replacedText);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
return(outputStream);
}
private async Task ImageUpdate(bool isCommand)
{
DateTime currentTime = DateTime.UtcNow;
// Just incase - stop code being called while photo already in progress
if (this.cameraBusy)
{
return;
}
this.cameraBusy = true;
try
{
using (Windows.Storage.Streams.InMemoryRandomAccessStream captureStream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
await this.mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), captureStream);
await captureStream.FlushAsync();
#if DEBUG
IStorageFile photoFile = await KnownFolders.PicturesLibrary.CreateFileAsync(ImageFilenameLocal, CreationCollisionOption.ReplaceExisting);
ImageEncodingProperties imageProperties = ImageEncodingProperties.CreateJpeg();
await this.mediaCapture.CapturePhotoToStorageFileAsync(imageProperties, photoFile);
#endif
string azureFilenameLatest = string.Format(this.azureStorageimageFilenameLatestFormat, currentTime);
string azureFilenameHistory = string.Format(this.azureStorageImageFilenameHistoryFormat, currentTime);
LoggingFields imageInformation = new LoggingFields();
imageInformation.AddDateTime("TakenAtUTC", currentTime);
imageInformation.AddBoolean("IsCommand", isCommand);
#if DEBUG
imageInformation.AddString("LocalFilename", photoFile.Path);
#endif
imageInformation.AddString("AzureFilenameLatest", azureFilenameLatest);
imageInformation.AddString("AzureFilenameHistory", azureFilenameHistory);
this.logging.LogEvent("Saving image(s) to Azure storage", imageInformation);
// Update the latest image in storage
if (!string.IsNullOrWhiteSpace(azureFilenameLatest))
{
captureStream.Seek(0);
Debug.WriteLine("AzureIoT Hub latest image upload start");
await this.azureIoTHubClient.UploadToBlobAsync(azureFilenameLatest, captureStream.AsStreamForRead());
Debug.WriteLine("AzureIoT Hub latest image upload done");
}
// Upload the historic image to storage
if (!string.IsNullOrWhiteSpace(azureFilenameHistory))
{
captureStream.Seek(0);
Debug.WriteLine("AzureIoT Hub historic image upload start");
await this.azureIoTHubClient.UploadToBlobAsync(azureFilenameHistory, captureStream.AsStreamForRead());
Debug.WriteLine("AzureIoT Hub historic image upload done");
}
}
}
catch (Exception ex)
{
this.logging.LogMessage("Image capture or AzureIoTHub storage upload failed " + ex.Message, LoggingLevel.Error);
}
finally
{
this.cameraBusy = false;
}
}
private async Task ImageUpdate(bool isCommand)
{
DateTime currentTime = DateTime.UtcNow;
// Just incase - stop code being called while photo already in progress
if (this.cameraBusy)
{
return;
}
this.cameraBusy = true;
this.displayGpioPin.Write(GpioPinValue.High);
// Check that enough time has passed for picture to be taken
if ((currentTime - this.imageLastCapturedAtUtc) < this.debounceTimeout)
{
this.displayOffTimer.Change(this.timerPeriodDetectIlluminated, this.timerPeriodInfinite);
return;
}
this.imageLastCapturedAtUtc = currentTime;
try
{
ImagePrediction imagePrediction;
using (Windows.Storage.Streams.InMemoryRandomAccessStream captureStream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
this.mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), captureStream).AsTask().Wait();
captureStream.FlushAsync().AsTask().Wait();
captureStream.Seek(0);
IStorageFile photoFile = await KnownFolders.PicturesLibrary.CreateFileAsync(ImageFilename, CreationCollisionOption.ReplaceExisting);
ImageEncodingProperties imageProperties = ImageEncodingProperties.CreateJpeg();
await this.mediaCapture.CapturePhotoToStorageFileAsync(imageProperties, photoFile);
switch (modelType)
{
case ModelType.Classification:
imagePrediction = await this.customVisionClient.ClassifyImageAsync(this.projectId, this.modelPublishedName, captureStream.AsStreamForRead());
break;
case ModelType.Detection:
imagePrediction = await this.customVisionClient.DetectImageAsync(this.projectId, this.modelPublishedName, captureStream.AsStreamForRead());
break;
default:
throw new ArgumentException("ModelType Invalid");
}
Debug.WriteLine($"Prediction count {imagePrediction.Predictions.Count}");
}
JObject telemetryDataPoint = new JObject();
LoggingFields imageInformation = new LoggingFields();
imageInformation.AddDateTime("TakenAtUTC", currentTime);
imageInformation.AddBoolean("IsCommand", isCommand);
imageInformation.AddDouble("Probability threshold", probabilityThreshold);
imageInformation.AddInt32("Predictions", imagePrediction.Predictions.Count);
// Display and log the results of the prediction
foreach (var prediction in imagePrediction.Predictions)
{
Debug.WriteLine($" Tag:{prediction.TagName} {prediction.Probability}");
imageInformation.AddDouble($"Tag:{prediction.TagName}", prediction.Probability);
}
// Post process the predictions based on the type of model
switch (modelType)
{
case ModelType.Classification:
// Use only the tags above the specified minimum probability
foreach (var prediction in imagePrediction.Predictions)
{
if (prediction.Probability >= probabilityThreshold)
{
// Display and log the individual tag probabilities
Debug.WriteLine($" Tag valid:{prediction.TagName} {prediction.Probability:0.00}");
imageInformation.AddDouble($"Tag valid:{prediction.TagName}", prediction.Probability);
telemetryDataPoint.Add(prediction.TagName, prediction.Probability);
}
}
break;
case ModelType.Detection:
// Group the tags to get the count, include only the predictions above the specified minimum probability
var groupedPredictions = from prediction in imagePrediction.Predictions
where prediction.Probability >= probabilityThreshold
group prediction by new { prediction.TagName }
into newGroup
select new
{
TagName = newGroup.Key.TagName,
Count = newGroup.Count(),
};
// Display and log the agregated predictions
foreach (var prediction in groupedPredictions)
{
Debug.WriteLine($" Tag valid:{prediction.TagName} {prediction.Count}");
imageInformation.AddInt32($"Tag valid:{prediction.TagName}", prediction.Count);
telemetryDataPoint.Add(prediction.TagName, prediction.Count);
}
break;
default:
throw new ArgumentException("ModelType Invalid");
}
this.logging.LogEvent("Captured image processed by Cognitive Services", imageInformation);
try
{
using (Message message = new Message(Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(telemetryDataPoint))))
{
Debug.WriteLine(" {0:HH:mm:ss} AzureIoTHubClient SendEventAsync start", DateTime.UtcNow);
await this.azureIoTHubClient.SendEventAsync(message);
Debug.WriteLine(" {0:HH:mm:ss} AzureIoTHubClient SendEventAsync finish", DateTime.UtcNow);
}
this.logging.LogEvent("SendEventAsync payload", imageInformation, LoggingLevel.Information);
}
catch (Exception ex)
{
imageInformation.AddString("Exception", ex.ToString());
this.logging.LogEvent("SendEventAsync payload", imageInformation, LoggingLevel.Error);
}
}
catch (Exception ex)
{
this.logging.LogMessage("Camera photo or save failed " + ex.Message, LoggingLevel.Error);
}
finally
{
this.displayGpioPin.Write(GpioPinValue.Low);
this.cameraBusy = false;
}
}
public void Dispose()
{
internalStream.Dispose();
internalStream = null;
}
public async Task CaptureThumbnail(Windows.Storage.Streams.InMemoryRandomAccessStream ms)
{
}
private async Task <string> ExecuteCommandLineString(string CommandString)
{
const string CommandLineProcesserExe = "c:\\windows\\system32\\cmd.exe";
const uint CommandStringResponseBufferSize = 8192;
string currentDirectory = "C:\\";
StringBuilder textOutput = new StringBuilder((int)CommandStringResponseBufferSize);
uint bytesLoaded = 0;
if (string.IsNullOrWhiteSpace(CommandString))
{
return("");
}
var commandLineText = CommandString.Trim();
var standardOutput = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var standardError = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var options = new Windows.System.ProcessLauncherOptions {
StandardOutput = standardOutput,
StandardError = standardError
};
try {
var args = "/C \"cd \"" + currentDirectory + "\" & " + commandLineText + "\"";
var result = await Windows.System.ProcessLauncher.RunToCompletionAsync(CommandLineProcesserExe, args, options);
//First write std out
using (var outStreamRedirect = standardOutput.GetInputStreamAt(0)) {
using (var dataReader = new Windows.Storage.Streams.DataReader(outStreamRedirect)) {
while ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0)
{
textOutput.Append(dataReader.ReadString(bytesLoaded));
}
new System.Threading.ManualResetEvent(false).WaitOne(10);
if ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0)
{
textOutput.Append(dataReader.ReadString(bytesLoaded));
}
}
}
//Then write std err
using (var errStreamRedirect = standardError.GetInputStreamAt(0)) {
using (var dataReader = new Windows.Storage.Streams.DataReader(errStreamRedirect)) {
while ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0)
{
textOutput.Append(dataReader.ReadString(bytesLoaded));
}
new System.Threading.ManualResetEvent(false).WaitOne(10);
if ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0)
{
textOutput.Append(dataReader.ReadString(bytesLoaded));
}
}
}
return(textOutput.ToString());
} catch (UnauthorizedAccessException uex) {
return("ERROR - " + uex.Message + "\n\nCmdNotEnabled");
} catch (Exception ex) {
return("ERROR - " + ex.Message + "\n");
}
}
private async void Stream_Click1(object sender, RoutedEventArgs e)
{
byte[] startSequence = { 0, 0, 0, 1, 0x27, 0x4d };
var options = new PropertySet();
//options.Add("framerate", "25");
//options.Add("vcodec", "copy");
_ws = new StreamWebSocket();
await _ws.ConnectAsync(new Uri(wsuri.Text, UriKind.Absolute));
bool isStarted = false;
bool isCreated = false;
var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
var output = stream.GetOutputStreamAt(0);
var writer = new DataWriter(output);
int maxdelay = 10;
int delay = maxdelay;
int index = 0;
DataReader reader = new DataReader(_ws.InputStream);
do
{
var loaded = await reader.LoadAsync(10 * 1024);
var buf = reader.ReadBuffer(loaded);
if (!isStarted)
{
isStarted = true;
var signature = buf.ToArray();
index = Helpers.FindSequence(signature, 0, startSequence);
if (index == -1)
{
Debug.WriteLine("signature not found, continuing");
continue;
}
buf = signature.AsBuffer(index, signature.Length - index);
Debug.WriteLine("buffer created");
//await output.WriteAsync(buf);
writer.WriteBuffer(buf);
}
else
{
//await output.WriteAsync(buf);
//await output.FlushAsync();
writer.WriteBuffer(buf);
}
await writer.StoreAsync();
if (delay > 0)
{
delay--;
Debug.Write("B");
//Debug.WriteLine(stream.Position);
continue;
}
//delay = maxdelay;
//Debug.Write(".");
try
{
//await output.WriteAsync(buf);
if (!isCreated)
{
isCreated = true;
//stream.Seek((ulong)0);
var decoder = FFmpegInterop.FFmpegInteropMSS.CreateFFmpegInteropMSSFromStream(
stream, false, false, options);
if (decoder == null)
{
Debug.WriteLine("decoder was null, will retry");
continue;
}
var source = decoder.GetMediaStreamSource();
source.Closed += Source_Closed;
source.Starting += Source_Starting;
source.SampleRequested += Source_SampleRequested;
source.SampleRendered += Source_SampleRendered;
//source.BufferTime = TimeSpan.FromSeconds(0.2);
media.SetMediaStreamSource(source);
media.Play();
}
}
catch (Exception err)
{
Debug.WriteLine(err.ToString());
stream.Dispose();
reader.Dispose();
return;
}
}while (true);
}
public void StartAdvertisement(
string serviceName,
bool autoAccept,
bool preferGO,
string pin,
IList <WiFiDirectServiceConfigurationMethod> configMethods,
WiFiDirectServiceStatus status,
uint customStatus,
string serviceInfo,
string deferredServiceInfo,
IList <String> prefixList
)
{
ThrowIfDisposed();
// Create Advertiser object for the service
// NOTE: service name is internally limited to up to 255 bytes in UTF-8 encoding
// Valid characters include alpha-numeric, '.', '-', and any multi-byte character
// characters a-z, A-Z are case-insensitive when discovering services
WiFiDirectServiceAdvertiser advertiser = new WiFiDirectServiceAdvertiser(serviceName);
// Auto-accept services will connect without interaction from advertiser
// NOTE: if the config method used for a connection requires a PIN, then the advertiser will have to accept the connection
advertiser.AutoAcceptSession = autoAccept;
// Set the Group Owner intent to a large value so that the advertiser will try to become the group owner (GO)
// NOTE: The GO of a P2P connection can connect to multiple clients while the client can connect to a single GO only
advertiser.PreferGroupOwnerMode = preferGO;
// Default status is "Available", but services may use a custom status code (value > 1) if applicable
advertiser.ServiceStatus = status;
advertiser.CustomServiceStatusCode = customStatus;
// Service information can be up to 65000 bytes.
// Service Seeker may explicitly discover this by specifying a short buffer that is a subset of this buffer.
// If seeker portion matches, then entire buffer is returned, otherwise, the service information is not returned to the seeker
// This sample uses a string for the buffer but it can be any data
if (serviceInfo != null && serviceInfo.Length > 0)
{
using (var tempStream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
using (var serviceInfoDataWriter = new Windows.Storage.Streams.DataWriter(tempStream))
{
serviceInfoDataWriter.WriteString(serviceInfo);
advertiser.ServiceInfo = serviceInfoDataWriter.DetachBuffer();
}
}
}
else
{
advertiser.ServiceInfo = null;
}
// This is a buffer of up to 144 bytes that is sent to the seeker in case the connection is "deferred" (i.e. not auto-accepted)
// This buffer will be sent when auto-accept is false, or if a PIN is required to complete the connection
// For the sample, we use a string, but it can contain any data
if (deferredServiceInfo != null && deferredServiceInfo.Length > 0)
{
using (var tempStream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
using (var deferredSessionInfoDataWriter = new Windows.Storage.Streams.DataWriter(tempStream))
{
deferredSessionInfoDataWriter.WriteString(deferredServiceInfo);
advertiser.DeferredSessionInfo = deferredSessionInfoDataWriter.DetachBuffer();
}
}
}
else
{
advertiser.DeferredSessionInfo = null;
}
// The advertiser supported configuration methods
// Valid values are PIN-only (either keypad entry, display, or both), or PIN (keypad entry, display, or both) and WFD Services default
// WFD Services Default config method does not require explicit PIN entry and offers a more seamless connection experience
// Typically, an advertiser will support PIN display (and WFD Services Default), and a seeker will connect with either PIN entry or WFD Services Default
if (configMethods != null)
{
advertiser.PreferredConfigurationMethods.Clear();
foreach (var configMethod in configMethods)
{
advertiser.PreferredConfigurationMethods.Add(configMethod);
}
}
// Advertiser may also be discoverable by a prefix of the service name. Must explicitly specify prefixes allowed here.
if (prefixList != null && prefixList.Count > 0)
{
advertiser.ServiceNamePrefixes.Clear();
foreach (var prefix in prefixList)
{
advertiser.ServiceNamePrefixes.Add(prefix);
}
}
// For this sample, we wrap the advertiser in our own object which handles the advertiser events
AdvertisementWrapper advertiserWrapper = new AdvertisementWrapper(advertiser, this, pin);
AddAdvertiser(advertiserWrapper);
RootPage.NotifyUser("Starting service...", NotifyType.StatusMessage);
try
{
// This may fail if the driver is unable to handle the request or if services is not supported
// NOTE: this must be called from the UI thread of the app
advertiser.Start();
}
catch (Exception ex)
{
RootPage.NotifyUser(String.Format(CultureInfo.InvariantCulture, "Failed to start service: {0}", ex.Message), NotifyType.ErrorMessage);
throw;
}
}
private async static void UriSourcePropertyChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Debug.WriteLine("我被触发了");
StorageCachedImage image = d as StorageCachedImage;
string i = e.NewValue as string;
int k = i.IndexOf("image");
string imagePath = i.Substring(k + 7);
string uri = App.Uri + "public/images/" + imagePath;
Debug.WriteLine(uri);
Uri imageUri = new Uri(uri);
HttpClient client = new HttpClient();
var response = await client.GetAsync(imageUri);
var buffer = await response.Content.ReadAsBufferAsync();
var memoryStream = new InMemoryRandomAccessStream();
await memoryStream.WriteAsync(buffer);
await memoryStream.FlushAsync();
await image.SetSourceAsync(memoryStream);
}
