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 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 static async Task<InMemoryRandomAccessStream> ConvertToInMemoryStream(byte[] arr)
{
var randomAccessStream = new InMemoryRandomAccessStream();
await randomAccessStream.WriteAsync(arr.AsBuffer());
randomAccessStream.Seek(0);
await randomAccessStream.FlushAsync(); // TODO: don't sure it's needed
return randomAccessStream;
}
public void SetSource(byte[] bytes)
{
var ms = new InMemoryRandomAccessStream();
ms.WriteAsync(bytes.AsBuffer());
ms.FlushAsync().AsTask().Wait();
ms.Seek(0);
bitmap = new BitmapImage();
bitmap.SetSource(ms);
}
public async Task SaveBitmapAsync(string albumFolder, uint size, string songPath)
{
var songFile = await StorageFile.GetFileFromPathAsync(songPath);
using (var thumbnail = await songFile.GetThumbnailAsync(ThumbnailMode.MusicView, size) ??
await songFile.GetThumbnailAsync(ThumbnailMode.VideosView, size))
{
if (thumbnail == null)
return;
var reader = new DataReader(thumbnail);
var fileLength = (uint)thumbnail.Size;
await reader.LoadAsync(fileLength);
var buffer = reader.ReadBuffer(fileLength);
var memStream = new InMemoryRandomAccessStream();
await memStream.WriteAsync(buffer);
await memStream.FlushAsync();
memStream.Seek(0);
await ApplicationData.Current.LocalFolder.CreateFolderAsync(AlbumArtFolderName(albumFolder), CreationCollisionOption.OpenIfExists);
var albumArtFileName = AlbumArtFileName(albumFolder, size);
var outputFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(albumArtFileName, CreationCollisionOption.ReplaceExisting);
// http://social.msdn.microsoft.com/Forums/windowsapps/en-US/1dda3a15-d299-40e0-b668-ec690a683f6e/how-to-resize-an-image-as-storagefile?forum=winappswithcsharp
var decoder = await BitmapDecoder.CreateAsync(memStream);
var transform = new BitmapTransform { ScaledHeight = size, ScaledWidth = size };
var pixelData = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Rgba8,
BitmapAlphaMode.Straight,
transform,
ExifOrientationMode.RespectExifOrientation,
ColorManagementMode.DoNotColorManage);
using (var destinationStream = await outputFile.OpenAsync(FileAccessMode.ReadWrite))
{
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, destinationStream);
encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied, size, size, 96, 96, pixelData.DetachPixelData());
await encoder.FlushAsync();
}
}
}
private async void DownloadAndScale(string outfileName, string downloadUriString)
{
Uri downLoadingUri = new Uri(downloadUriString);
var client = new HttpClient();
using (var response = await client.GetAsync(downLoadingUri))
{
var buffer = await response.Content.ReadAsBufferAsync();
var memoryStream = new InMemoryRandomAccessStream();
await memoryStream.WriteAsync(buffer);
await memoryStream.FlushAsync();
var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(memoryStream);
var pixelProvider = await decoder.GetPixelDataAsync();
var localFolder = Windows.Storage.KnownFolders.PicturesLibrary;
var scaledFile = await localFolder.CreateFileAsync(outfileName, CreationCollisionOption.GenerateUniqueName);
using (var scaledFileStream = await scaledFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
{
var encoder = await Windows.Graphics.Imaging.BitmapEncoder.CreateAsync( BitmapEncoder.JpegEncoderId, scaledFileStream);
var pixels = pixelProvider.DetachPixelData();
encoder.SetPixelData(
decoder.BitmapPixelFormat,
decoder.BitmapAlphaMode,
decoder.PixelWidth,
decoder.PixelHeight,
decoder.DpiX,
decoder.DpiY,
pixels
);
await encoder.FlushAsync();
}
}
}
/// <summary>
/// Perform image capture from mediaCapture object
/// </summary>
/// <param name="cancelToken">
/// The cancel Token.
/// </param>
/// <returns>
/// Decoded barcode string.
/// </returns>
private async Task<Result> GetCameraImage(CancellationToken cancelToken)
{
if (cancelToken.IsCancellationRequested)
{
throw new OperationCanceledException(cancelToken);
}
imageStream = new InMemoryRandomAccessStream();
await capture.CapturePhotoToStreamAsync(encodingProps, imageStream);
await imageStream.FlushAsync();
var decoder = await BitmapDecoder.CreateAsync(imageStream);
byte[] pixels = (await decoder.GetPixelDataAsync(BitmapPixelFormat.Rgba8,
BitmapAlphaMode.Ignore,
new BitmapTransform(),
ExifOrientationMode.IgnoreExifOrientation,
ColorManagementMode.DoNotColorManage)).DetachPixelData();
const BitmapFormat format = BitmapFormat.RGB32;
imageStream.Dispose();
var result =
await
Task.Run(
() => barcodeReader.Decode(pixels, (int)decoder.PixelWidth, (int)decoder.PixelHeight, format),
cancelToken);
return result;
}
private async Task<bool> LoadImageFromHttpResponse(HttpResponseMessage response, Tile tile, BitmapSource image, string cacheKey)
{
using (var stream = new InMemoryRandomAccessStream())
{
using (var content = response.Content)
{
await content.WriteToStreamAsync(stream);
}
await stream.FlushAsync();
stream.Seek(0);
var loaded = await LoadImageFromStream(tile, image, stream);
if (loaded && cacheKey != null)
{
var buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size);
stream.Seek(0);
await stream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None);
var maxAge = DefaultCacheExpiration;
if (response.Headers.CacheControl.MaxAge.HasValue &&
response.Headers.CacheControl.MaxAge.Value < maxAge)
{
maxAge = response.Headers.CacheControl.MaxAge.Value;
}
await Cache.SetAsync(cacheKey, buffer, DateTime.UtcNow.Add(maxAge));
}
return loaded;
}
}
private async void AnalyzeButton_Click(object sender, RoutedEventArgs e)
{
if (processingImage)
{
// Ignore button presses while processing the image
return;
}
if (inCaptureState)
{
processingImage = true;
inCaptureState = false;
// Make the 'Processing...' label visible
canvasControl.Visibility = Visibility.Visible;
AnalyzeButton.Content = "...";
canvasControl.Invalidate();
var originalPhoto = new InMemoryRandomAccessStream();
var reencodedPhoto = new InMemoryRandomAccessStream();
await mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), originalPhoto);
await originalPhoto.FlushAsync();
originalPhoto.Seek(0);
captureElement.Visibility = Visibility.Collapsed;
// Store the captured photo as a Win2D type for later use
photoCanvasBitmap = await CanvasBitmap.LoadAsync(canvasControl, originalPhoto);
// Send the photo to Project Oxford to detect the faces
lastCapturedFaces = await faceServiceClient.DetectAsync(originalPhoto.AsStreamForRead(), true, true, true, false);
// Force the canvasControl to be redrawn now that the photo is available
canvasControl.Invalidate();
processingImage = false;
AnalyzeButton.Content = "Restart";
}
else
{
canvasControl.Visibility = Visibility.Collapsed;
captureElement.Visibility = Visibility.Visible;
AnalyzeButton.Content = "Capture Photo";
photoCanvasBitmap = null;
canvasControl.Invalidate();
inCaptureState = true;
}
}
public async Task<IRandomAccessStream> DownloadPDFAsync(LibrelioUrl magUrl, StorageFolder folder, bool isd, IProgress<int> progress = null, CancellationToken cancelToken = default(CancellationToken))
{
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Add("user-agent", "LibrelioWinRT");
var url = magUrl.AbsoluteUrl;
if (isd) url = url.Replace("_.", ".");
//HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, url);
//int read = 0;
//int offset = 0;
//byte[] responseBuffer = new byte[1024];
//var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancelToken);
//response.EnsureSuccessStatusCode();
//var length = response.Content.Headers.ContentLength;
//cancelToken.ThrowIfCancellationRequested();
//var stream = new InMemoryRandomAccessStream();
//using (var responseStream = await response.Content.ReadAsStreamAsync())
//{
// do
// {
// cancelToken.ThrowIfCancellationRequested();
// read = await responseStream.ReadAsync(responseBuffer, 0, responseBuffer.Length);
// cancelToken.ThrowIfCancellationRequested();
// await stream.AsStream().WriteAsync(responseBuffer, 0, read);
// offset += read;
// uint val = (uint)(offset * 100 / length);
// if (val >= 100) val = 99;
// if (val <= 0) val = 1;
// progress.Report((int)val);
// }
// while (read != 0);
//}
//progress.Report(100);
//await stream.FlushAsync();
////var folder = await AddMagazineFolderStructure(magUrl);
////var folder = await StorageFolder.GetFolderFromPathAsync(folderUrl);
var name = magUrl.FullName;
if (isd) name = name.Replace("_.", ".");
var file = await folder.CreateFileAsync(name, CreationCollisionOption.ReplaceExisting);
//using (var protectedStream = await DownloadManager.ProtectPDFStream(stream))
//using (var fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
////using (var unprotectedStream = await DownloadManager.UnprotectPDFStream(protectedStream))
//{
// await RandomAccessStream.CopyAsync(protectedStream, fileStream.GetOutputStreamAt(0));
// await fileStream.FlushAsync();
//}
progress.Report(0);
BackgroundDownloader downloader = new BackgroundDownloader();
DownloadOperation download = downloader.CreateDownload(new Uri(url), file);
await HandleDownloadAsync(download, true, progress, cancelToken);
progress.Report(100);
if (cancelToken.IsCancellationRequested)
return null;
var stream = await download.ResultFile.OpenAsync(FileAccessMode.ReadWrite);
var returnStream = new InMemoryRandomAccessStream();
await RandomAccessStream.CopyAsync(stream.GetInputStreamAt(0), returnStream.GetOutputStreamAt(0));
await returnStream.FlushAsync();
var protectedStram = await DownloadManager.ProtectPDFStream(stream);
await RandomAccessStream.CopyAndCloseAsync(protectedStram.GetInputStreamAt(0), stream.GetOutputStreamAt(0));
await protectedStram.FlushAsync();
await stream.FlushAsync();
protectedStram.Dispose();
stream.Dispose();
var pdfStream = new MagazineData();
pdfStream.folderUrl = folder.Path + "\\";
pdfStream.stream = returnStream;
//var fileHandle =
// await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(@"Assets\test\testmagazine.pdf");
//pdfStream.folderUrl = "C:\\Users\\Dorin\\Documents\\Magazines\\wind_355\\";
//pdfStream.stream = await fileHandle.OpenReadAsync();
return pdfStream.stream;
}
private async Task<IRandomAccessStream> ResizeStreamAsync(IRandomAccessStream stream, Size size, PhotoOrientation orientation)
{
var rotation = 0;
switch (orientation)
{
case PhotoOrientation.Rotate180:
{
rotation = -180;
};
break;
case PhotoOrientation.Rotate270:
{
rotation = -270;
};
break;
case PhotoOrientation.Rotate90:
{
rotation = -90;
};
break;
}
using (var resizedStream = new InMemoryRandomAccessStream())
{
var buffer = new byte[stream.Size].AsBuffer();
stream.Seek(0);
await stream.ReadAsync(buffer, buffer.Length, InputStreamOptions.None);
var resizeConfiguration = new AutoResizeConfiguration(
(uint)(size.Width * size.Height * 4 * 2), size,
new Size(0, 0), AutoResizeMode.Automatic, 0.7, ColorSpace.Yuv420);
buffer = await JpegTools.AutoResizeAsync(buffer, resizeConfiguration);
await resizedStream.WriteAsync(buffer);
await resizedStream.FlushAsync();
if (rotation != 0)
{
resizedStream.Seek(0);
var filters = new List<IFilter>() { new RotationFilter(rotation) };
using (var source = new RandomAccessStreamImageSource(resizedStream))
using (var effect = new FilterEffect(source) { Filters = filters })
using (var renderer = new JpegRenderer(effect))
{
buffer = await renderer.RenderAsync();
using (var rotatedResizedStream = new InMemoryRandomAccessStream())
{
await rotatedResizedStream.WriteAsync(buffer);
await rotatedResizedStream.FlushAsync();
return rotatedResizedStream.CloneStream();
}
}
}
else
{
return resizedStream.CloneStream();
}
}
}
public Windows.Foundation.IAsyncOperation <bool> FlushAsync()
{
return(internalStream.FlushAsync());
}
public static async Task<IRandomAccessStream> UnprotectPDFStream(IRandomAccessStream source)
{
// Create a DataProtectionProvider object.
DataProtectionProvider Provider = new DataProtectionProvider();
InMemoryRandomAccessStream unprotectedData = new InMemoryRandomAccessStream();
IOutputStream dest = unprotectedData.GetOutputStreamAt(0);
await Provider.UnprotectStreamAsync(source.GetInputStreamAt(0), dest);
await unprotectedData.FlushAsync();
unprotectedData.Seek(0);
return unprotectedData;
}
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 LoadImageFromBuffer(IBuffer buffer, BitmapImage bitmap)
{
using (var stream = new InMemoryRandomAccessStream())
{
await stream.WriteAsync(buffer);
await stream.FlushAsync();
stream.Seek(0);
await bitmap.Dispatcher.RunAsync(CoreDispatcherPriority.Low, async () =>
{
try
{
await bitmap.SetSourceAsync(stream);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
});
}
}
private async Task LoadImageFromHttpResponse(HttpResponseMessage response, BitmapImage bitmap, string cacheKey)
{
if (response.IsSuccessStatusCode)
{
var stream = new InMemoryRandomAccessStream();
using (var content = response.Content)
{
await content.WriteToStreamAsync(stream);
}
await stream.FlushAsync();
stream.Seek(0);
await bitmap.Dispatcher.RunAsync(CoreDispatcherPriority.Low, async () =>
{
try
{
await bitmap.SetSourceAsync(stream);
// cache image asynchronously, after successful decoding
var task = Task.Run(async () =>
{
var buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size);
stream.Seek(0);
await stream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None);
stream.Dispose();
await Cache.SetAsync(cacheKey, buffer);
});
}
catch (Exception ex)
{
Debug.WriteLine("{0}: {1}", response.RequestMessage.RequestUri, ex.Message);
stream.Dispose();
}
});
}
else
{
Debug.WriteLine("{0}: {1}", response.RequestMessage.RequestUri, response.StatusCode);
}
}
public async Task<IRandomAccessStream> DownloadPDFAsync(LibrelioLocalUrl magUrl, StorageFolder folder, IProgress<int> progress = null, CancellationToken cancelToken = default(CancellationToken))
{
HttpClient client = new HttpClient();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, magUrl.Url);
int read = 0;
int offset = 0;
byte[] responseBuffer = new byte[1024];
var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancelToken);
response.EnsureSuccessStatusCode();
var length = response.Content.Headers.ContentLength;
cancelToken.ThrowIfCancellationRequested();
var stream = new InMemoryRandomAccessStream();
using (var responseStream = await response.Content.ReadAsStreamAsync())
{
do
{
cancelToken.ThrowIfCancellationRequested();
read = await responseStream.ReadAsync(responseBuffer, 0, responseBuffer.Length);
cancelToken.ThrowIfCancellationRequested();
await stream.AsStream().WriteAsync(responseBuffer, 0, read);
offset += read;
uint val = (uint)(offset * 100 / length);
if (val >= 100) val = 99;
if (val <= 0) val = 1;
progress.Report((int)val);
}
while (read != 0);
}
progress.Report(100);
await stream.FlushAsync();
//var folder = await AddMagazineFolderStructure(magUrl);
//var folder = await StorageFolder.GetFolderFromPathAsync(folderUrl);
var file = await folder.CreateFileAsync(magUrl.FullName, CreationCollisionOption.ReplaceExisting);
using (var protectedStream = await DownloadManager.ProtectPDFStream(stream))
using (var fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
//using (var unprotectedStream = await DownloadManager.UnprotectPDFStream(protectedStream))
{
await RandomAccessStream.CopyAsync(protectedStream, fileStream.GetOutputStreamAt(0));
await fileStream.FlushAsync();
}
var pdfStream = new MagazineData();
pdfStream.folderUrl = folder.Path + "\\";
pdfStream.stream = stream;
//var fileHandle =
// await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(@"Assets\test\testmagazine.pdf");
//pdfStream.folderUrl = "C:\\Users\\Dorin\\Documents\\Magazines\\wind_355\\";
//pdfStream.stream = await fileHandle.OpenReadAsync();
return pdfStream.stream;
}
private async Task ShowVehicleLocations()
{
var vehicleLocations = await searchVm.GetBusLocations();
while (vehicleCounter > 0)
{
SearchMap.MapElements.RemoveAt(SearchMap.MapElements.Count - 1);
vehicleCounter--;
}
var inboundBM = new WriteableBitmap(40, 40);
await inboundBM.SetSourceAsync(await RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Inbound.png")).OpenReadAsync());
var outboundBM = new WriteableBitmap(40, 40);
await outboundBM.SetSourceAsync(await RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Outbound.png")).OpenReadAsync());
foreach (Bus bus in vehicleLocations)
{
if (bus.direction.Equals("inbound"))
{
var rotatedImage = inboundBM.RotateFree(bus.busHeading, false);
var stream = new InMemoryRandomAccessStream();
await rotatedImage.ToStream(stream, BitmapEncoder.PngEncoderId);
var busMarker = new MapIcon
{
Image = RandomAccessStreamReference.CreateFromStream(stream),
CollisionBehaviorDesired = MapElementCollisionBehavior.RemainVisible,
Location = new Geopoint(new BasicGeoposition { Latitude = bus.latitude, Longitude = bus.longitude }),
NormalizedAnchorPoint = new Point(0.5, 0.5),
ZIndex = 99
};
SearchMap.MapElements.Add(busMarker);
await stream.FlushAsync();
stream.Dispose();
rotatedImage = null;
}
else if (bus.direction.Equals("outbound"))
{
var rotatedImage = outboundBM.RotateFree(bus.busHeading, false);
var stream = new InMemoryRandomAccessStream();
await rotatedImage.ToStream(stream, BitmapEncoder.PngEncoderId);
var busMarker = new MapIcon
{
Image = RandomAccessStreamReference.CreateFromStream(stream),
CollisionBehaviorDesired = MapElementCollisionBehavior.RemainVisible,
Location = new Geopoint(new BasicGeoposition { Latitude = bus.latitude, Longitude = bus.longitude }),
NormalizedAnchorPoint = new Point(0.5, 0.5),
ZIndex = 99
};
SearchMap.MapElements.Add(busMarker);
await stream.FlushAsync();
stream.Dispose();
rotatedImage = null;
}
vehicleCounter++;
}
inboundBM = null;
outboundBM = null;
}
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 static async Task<BitmapImage> ConvertByteArrayToBitmapImage(byte[] byteValue)
{
var img = new BitmapImage();
var ras = new InMemoryRandomAccessStream();
await ras.WriteAsync(byteValue.AsBuffer());
await ras.FlushAsync();
ras.Seek(0);
img.SetSource(ras);
return img;
}
private async void DoImageProcessing()
{
var ps = new InMemoryRandomAccessStream();
while (processImage)
{
await capturePreview.Source.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), ps);
await ps.FlushAsync();
ps.Seek(0);
WriteableBitmap bitmap = new WriteableBitmap(424, 240);
bitmap.SetSource(ps);
int bitmapSize = bitmap.PixelHeight * bitmap.PixelWidth * 4;
using (Stream imageStream = bitmap.PixelBuffer.AsStream())
{
byte[] bitmapPixelArray = new byte[bitmapSize];
await imageStream.ReadAsync(bitmapPixelArray, 0, bitmapSize);
for (int i = 0; i < bitmapSize; i += 4)
{
selectedPixelFunction(bitmapPixelArray, i);
}
imageStream.Seek(0, SeekOrigin.Begin);
await imageStream.WriteAsync(bitmapPixelArray, 0, bitmapSize);
}
imageProcess.Source = bitmap;
}
selectedPixelFunction = null;
}
public override object generatePeerImage()
{
int width = getWidth();
int height = getHeight();
if (width <= 0 || height <= 0)
{
width = getPreferredW();
height = getPreferredH();
}
CodenameOneImage img = new CodenameOneImage();
img.@this();
img.name = "PeerImage: " + element.ToString();
IRandomAccessStream stream = new InMemoryRandomAccessStream();
CanvasBitmap cb = null;
SilverlightImplementation.dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
{
if (element is WebView)
{
await ((WebView)element).CapturePreviewToStreamAsync(stream);
await stream.FlushAsync();
stream.Seek(0);
cb = await CanvasBitmap.LoadAsync(SilverlightImplementation.screen, stream);
}
else
{
RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap();
await renderTargetBitmap.RenderAsync(element);
byte[] buf = renderTargetBitmap.GetPixelsAsync().AsTask().ConfigureAwait(false).GetAwaiter().GetResult().ToArray();
cb = CanvasBitmap.CreateFromBytes(SilverlightImplementation.screen, buf, width, height,
SilverlightImplementation.pixelFormat, SilverlightImplementation.screen.Dpi);
}
img.image = new CanvasRenderTarget(SilverlightImplementation.screen, cb.SizeInPixels.Width, cb.SizeInPixels.Height, cb.Dpi);
img.graphics.destination.drawImage(cb, 0, 0);
img.graphics.destination.dispose();
}).AsTask().GetAwaiter().GetResult();
return ui.Image.createImage(img);
}
//
// TODO: implement code needed to share item from main page
//
public async void GetSharedData(DataTransferManager sender, DataRequestedEventArgs args)
{
try
{
var currentCam = MappableListView.SelectedItem as APIMASH_TomTom.TomTomCameraViewModel;
if (currentCam != null)
{
DataRequestDeferral deferral = args.Request.GetDeferral();
args.Request.Data.Properties.Title = String.Format("TomTom Camera: {0}", currentCam.CameraId);
args.Request.Data.Properties.Description = currentCam.Name;
// share a file
var file = await StorageFile.CreateStreamedFileAsync(
String.Format("{0}_{1}.jpg", currentCam.CameraId, DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss")),
async stream =>
{
await stream.WriteAsync(currentCam.ImageBytes.AsBuffer());
await stream.FlushAsync();
stream.Dispose();
},
null);
args.Request.Data.SetStorageItems(new List<IStorageItem> { file });
// share as bitmap
InMemoryRandomAccessStream raStream = new InMemoryRandomAccessStream();
await raStream.WriteAsync(currentCam.ImageBytes.AsBuffer());
await raStream.FlushAsync();
args.Request.Data.SetBitmap(RandomAccessStreamReference.CreateFromStream(raStream));
deferral.Complete();
}
else
{
args.Request.FailWithDisplayText("Select a camera to share its image.");
}
}
catch (Exception ex)
{
args.Request.FailWithDisplayText(ex.Message);
}
}
private async Task LoadPendingTiles(TileSource tileSource, string sourceName)
{
PendingTile pendingTile;
while (pendingTiles.TryDequeue(out pendingTile))
{
var tile = pendingTile.Tile;
var uri = pendingTile.Uri;
var image = pendingTile.Image;
var extension = Path.GetExtension(uri.LocalPath);
if (string.IsNullOrEmpty(extension) || extension == ".jpeg")
{
extension = ".jpg";
}
var cacheKey = string.Format(@"{0}\{1}\{2}\{3}{4}", sourceName, tile.ZoomLevel, tile.XIndex, tile.Y, extension);
var cacheItem = await Cache.GetAsync(cacheKey);
var loaded = false;
if (cacheItem == null || cacheItem.Expires <= DateTime.UtcNow)
{
loaded = await DownloadImage(tile, image, uri, cacheKey);
}
if (!loaded && cacheItem != null && cacheItem.Buffer != null)
{
using (var stream = new InMemoryRandomAccessStream())
{
await stream.WriteAsync(cacheItem.Buffer);
await stream.FlushAsync();
stream.Seek(0);
await LoadImageFromStream(tile, image, stream);
}
}
}
Interlocked.Decrement(ref taskCount);
}
public override object generatePeerImage()
{
int width = getWidth();
int height = getHeight();
if (width <= 0 || height <= 0)
{
width = getPreferredW();
height = getPreferredH();
}
if (element.Parent == null)
{
if (peerImage != null)
{
return peerImage;
}
return com.codename1.ui.Image.createImage(width, height);
}
CodenameOneImage img = new CodenameOneImage();
img.@this();
img.name = "PeerImage: " + element.ToString();
IRandomAccessStream stream = new InMemoryRandomAccessStream();
CanvasBitmap cb = null;
using (AutoResetEvent are = new AutoResetEvent(false))
{
SilverlightImplementation.dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (element is WebView)
{
try
{
Task.Delay(TimeSpan.FromTicks(4).Duration()).GetAwaiter().GetResult();
((WebView)element).CapturePreviewToStreamAsync(stream).AsTask().GetAwaiter().GetResult();
stream.FlushAsync().AsTask().GetAwaiter().GetResult();
stream.Seek(0);
Task.Delay(TimeSpan.FromMilliseconds(10)).GetAwaiter().GetResult();
cb = CanvasBitmap.LoadAsync(SilverlightImplementation.screen, stream).AsTask().GetAwaiter().GetResult();
}
catch (Exception)
{
throw;
}
}
else
{
RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap();
renderTargetBitmap.RenderAsync(element).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();
byte[] buf = renderTargetBitmap.GetPixelsAsync().AsTask().ConfigureAwait(false).GetAwaiter().GetResult().ToArray();
cb = CanvasBitmap.CreateFromBytes(SilverlightImplementation.screen, buf, width, height, SilverlightImplementation.pixelFormat, SilverlightImplementation.screen.Dpi);
}
img.image = new CanvasRenderTarget(SilverlightImplementation.screen, cb.SizeInPixels.Width, cb.SizeInPixels.Height, cb.Dpi);
img.graphics.destination.drawImage(cb, 0, 0);
img.graphics.destination.dispose();
are.Set();
}).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();
are.WaitOne();
}
return com.codename1.ui.Image.createImage(img);
// return com.codename1.ui.Image.createImage(width, height);
}
private async Task<bool> SaveImage(int id, String folderName, byte[] img)
{
String fileName = String.Format("{0}.jpg", id);
try
{
using (var streamWeb = new InMemoryRandomAccessStream())
{
using (var writer = new DataWriter(streamWeb.GetOutputStreamAt(0)))
{
writer.WriteBytes(img);
await writer.StoreAsync();
var albumPic = await ApplicationData.Current.LocalFolder.CreateFolderAsync(folderName, CreationCollisionOption.OpenIfExists);
var file = await albumPic.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists);
Debug.WriteLine("Writing file " + folderName + " " + id);
using (var raStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
using (var thumbnailStream = streamWeb.GetInputStreamAt(0))
{
using (var stream = raStream.GetOutputStreamAt(0))
{
await RandomAccessStream.CopyAsync(thumbnailStream, stream);
await stream.FlushAsync();
}
}
await raStream.FlushAsync();
}
await writer.FlushAsync();
}
await streamWeb.FlushAsync();
}
return true;
}
catch (Exception e)
{
Debug.WriteLine("Error saving album art: " + e);
return false;
}
}
/// <summary>
/// 异步从网络下载图片
/// </summary>
/// <param name="outfileName">下载保存到本地的图片文件名</param>
/// <param name="downloadUriString">图片uri</param>
/// <param name="scaleSize">图片尺寸</param>
/// <returns></returns>
public static async Task DownloadAndScale(string outfileName, string downloadUriString, Size scaleSize)
{
try
{
Uri downLoadingUri = new Uri(downloadUriString);//创建uri对象
HttpClient client = new HttpClient();//实例化httpclient对象
using (var response = await client.GetAsync(downLoadingUri))
{
var buffer = await response.Content.ReadAsBufferAsync();//从返回的数据中读取buffer
var memoryStream = new InMemoryRandomAccessStream();
await memoryStream.WriteAsync(buffer);//将buffer写入memorystream
await memoryStream.FlushAsync();//刷新
var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(memoryStream);//解密文件流
//确定图片大小
var bt = new Windows.Graphics.Imaging.BitmapTransform();
bt.ScaledWidth = (uint)scaleSize.Width;
bt.ScaledHeight = (uint)scaleSize.Height;
//得到像素数值
var pixelProvider = await decoder.GetPixelDataAsync(
decoder.BitmapPixelFormat, decoder.BitmapAlphaMode, bt,
ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.ColorManageToSRgb);
//下面保存图片
// Now that we have the pixel data, get the destination file
var localFolder = ApplicationData.Current.LocalFolder;
//var resultsFolder = await localFolder.CreateFolderAsync("Results", CreationCollisionOption.OpenIfExists);
var scaledFile = await localFolder.CreateFileAsync(outfileName, CreationCollisionOption.ReplaceExisting);
using (var scaledFileStream = await scaledFile.OpenAsync(FileAccessMode.ReadWrite))
{
var encoder = await BitmapEncoder.CreateAsync(
BitmapEncoder.JpegEncoderId, scaledFileStream);
var pixels = pixelProvider.DetachPixelData();
encoder.SetPixelData(
decoder.BitmapPixelFormat,
decoder.BitmapAlphaMode,
(uint)scaleSize.Width,
(uint)scaleSize.Height,
decoder.DpiX,
decoder.DpiY,
pixels
);
await encoder.FlushAsync();
}
}
}
catch (Exception) { Debug.WriteLine("工具，图片异常"); }
}
private async void OnTap(object sender, TappedRoutedEventArgs e)
{
ImageEncodingProperties imageProperties = ImageEncodingProperties.CreateJpeg();
var fPhotoStream = new InMemoryRandomAccessStream();
await mediaCapture.CapturePhotoToStreamAsync(imageProperties, fPhotoStream);
await fPhotoStream.FlushAsync();
fPhotoStream.Seek(0);
var _bmp = new BitmapImage();
_bmp.SetSource(fPhotoStream);
PreviewImage.Source = _bmp;
}
public async Task<string> GetImageAsBase64Encoded()
{
// Adapted from
// http social.msdn.microsoft.com/Forums/wpapps/en-US/.../image-to-base64-encoding [Win Phone 7, 2010] and
// <same site> /sharing-a-writeablebitmap and
// www.charlespetzold.com/blog/2012/08/WritableBitmap-Pixel-Arrays-in-CSharp-and-CPlusPlus.html
// example in WebcamPage.xaml.cs
string results = "";
try
{
//using (Stream stream = App.CurrentPatient.ImageWriteableBitmap.PixelBuffer.AsStream())
using (Stream stream = ImageWriteableBitmap.PixelBuffer.AsStream()) //There are 4 bytes per pixel.
{
byte[] pixels = await ConvertStreamToByteArray(stream);
// Now render the object in a known format, e.g., jpeg:
//InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream();
IRandomAccessStream ms = new InMemoryRandomAccessStream();
// If calling from a synchronous function, add AsTask().ConfigureAwait(false) to avoid hanging UI thread
// If image as optionally cropped is over 1.5Mp, then apply aggressive compression to get it to that size (approximately)
double quality = 1.0; //Max quality, the default. For jpeg, 1.0 - quality = compression ratio
UInt64 totalPixels = (ulong)ImageWriteableBitmap.PixelWidth * (ulong)ImageWriteableBitmap.PixelHeight;
if (totalPixels > 1500000L)
quality = Math.Round(((double)1500000.0 / (double)totalPixels), 2, MidpointRounding.AwayFromZero); // for debug purposes, round quality to 2 fractional digits
// For encoding options, wee msdn.microsoft.com/en-us/library/windows/apps/jj218354.aspx "How to use encoding options".
var encodingOptions = new BitmapPropertySet();
var qualityValue = new BitmapTypedValue(quality, Windows.Foundation.PropertyType.Single);
encodingOptions.Add("ImageQuality", qualityValue);
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, ms, encodingOptions); //.AsTask().ConfigureAwait(false);
/*
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.BmpEncoderId, ms); */
encoder.SetPixelData(
BitmapPixelFormat.Bgra8, //Rgba8, //Bgra8,
BitmapAlphaMode.Straight, // .Ignore
(uint)ImageWriteableBitmap.PixelWidth,//(uint)App.CurrentPatient.ImageWriteableBitmap.PixelWidth,
(uint)ImageWriteableBitmap.PixelHeight,//(uint)App.CurrentPatient.ImageWriteableBitmap.PixelHeight,
96.0, 96.0, pixels);
await encoder.FlushAsync(); //.AsTask().ConfigureAwait(false);
byte[] jpgEncoded = await ConvertMemoryStreamToByteArray(ms);
results = Convert.ToBase64String(jpgEncoded);
await ms.FlushAsync(); // cleanup
}
}
catch (Exception ex)
{
Debug.WriteLine("Error when encoding image: " + ex.Message);
}
return results;
}
private async Task RenderFirstPDFPageAsync(string docUri, double height, double width)
{
try
{
var pdfFile = await StorageFile.GetFileFromPathAsync(docUri).AsTask().ConfigureAwait(false);
var pdfDocument = await PdfDocument.LoadFromFileAsync(pdfFile).AsTask().ConfigureAwait(false);
if (pdfDocument?.PageCount > 0)
{
using (var pdfPage = pdfDocument.GetPage(0))
{
var renderOptions = GetPdfRenderOptions(pdfPage, height, width);
if (renderOptions != null)
{
IsMultiPage = pdfDocument.PageCount > 1; // LOLLO TODO MAYBE deal with multi pages with tiff too ?
using (var stream = new InMemoryRandomAccessStream())
{
await pdfPage.RenderToStreamAsync(stream, renderOptions).AsTask().ConfigureAwait(false);
await stream.FlushAsync().AsTask().ConfigureAwait(false);
await DisplayImageFileAsync(stream).ConfigureAwait(false);
}
}
}
}
}
catch (Exception ex)
{
await Logger.AddAsync(ex.ToString(), Logger.ForegroundLogFilename).ConfigureAwait(false);
}
}
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);
}
