public static async Task<WriteableBitmap> StorageFileToWriteableBitmapWithDirection(StorageFile file)
{
if (file == null)
return null;
using (IRandomAccessStream stream = await file.OpenReadAsync())
{
// Create a decoder from the stream. With the decoder, we can get
// the properties of the image.
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
PixelDataProvider pix = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Straight,
new BitmapTransform(),
ExifOrientationMode.RespectExifOrientation,
ColorManagementMode.DoNotColorManage);
byte[] pixels = pix.DetachPixelData();
WriteableBitmap Bmp = new WriteableBitmap((int)decoder.OrientedPixelWidth, (int)decoder.OrientedPixelHeight);
Stream pixStream = Bmp.PixelBuffer.AsStream();
pixStream.Write(pixels, 0, (int)(decoder.OrientedPixelWidth * decoder.OrientedPixelHeight * 4));
return Bmp;
}
}
public async Task AddFile(Action <ExpensesMobile.Models.File> postAction)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
picker.FileTypeFilter.Add(".pdf");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
var f = await file.OpenReadAsync();
var stream = f.AsStream();
var mStream = new MemoryStream();
stream.CopyTo(mStream);
postAction(new ExpensesMobile.Models.File
{
Name = file.Name,
Bytes = mStream.ToArray(),
Size = mStream.Length
});
}
public async void LoadData(IEnumerable<XElement> sprites, StorageFile spriteSheetFile, string appExtensionId)
{
var bitmapImage = new BitmapImage();
using (var stream = await spriteSheetFile.OpenReadAsync()) {
await bitmapImage.SetSourceAsync(stream);
}
//xaml
List<ImageListItem> listOfImages = new List<ImageListItem>();
foreach (var sprite in sprites) {
var row = int.Parse(sprite.Attributes("Row").First().Value);
var col = int.Parse(sprite.Attributes("Column").First().Value);
var brush = new ImageBrush();
brush.ImageSource = bitmapImage;
brush.Stretch = Stretch.UniformToFill;
brush.AlignmentX = AlignmentX.Left;
brush.AlignmentY = AlignmentY.Top;
brush.Transform = new CompositeTransform() { ScaleX = 2.35, ScaleY = 2.35, TranslateX = col * (-140), TranslateY = row * (-87) };
listOfImages.Add(new ImageListItem() {
Title = sprite.Attributes("Title").First().Value,
SpriteSheetBrush = brush,
File = sprite.Attributes("File").First().Value,
AppExtensionId = appExtensionId
});
}
lbPictures.ItemsSource = listOfImages;
}
private async void selectPhoto(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read))
{
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.DecodePixelWidth = 353;
await bitmapImage.SetSourceAsync(fileStream);
userFace.Source = bitmapImage;
var fileToSave = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("temp.png", CreationCollisionOption.ReplaceExisting);
var stream = await file.OpenReadAsync();
var bytes = await Temp.GetBytesFromStream(stream);
await FileIO.WriteBytesAsync(fileToSave, bytes);
}
}
}
//Button to add an Image to the document
private async void imgbtn_Click(object sender, RoutedEventArgs e)
{
Windows.Storage.Pickers.FileOpenPicker open = new Windows.Storage.Pickers.FileOpenPicker();
open.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
open.FileTypeFilter.Add(".jpg");
open.FileTypeFilter.Add(".png");
Windows.Storage.StorageFile file = await open.PickSingleFileAsync();
if (file != null)
{
try
{
using (IRandomAccessStream imagestram = await file.OpenReadAsync())
{
BitmapImage image = new BitmapImage();
await image.SetSourceAsync(imagestram);
editBox.Document.Selection.InsertImage(image.PixelWidth, image.PixelHeight, 0, Windows.UI.Text.VerticalCharacterAlignment.Baseline, "Image", imagestram);
}
}
catch (Exception)
{
ContentDialog errorDialog = new ContentDialog()
{
Title = "File open error",
Content = "Sorry, I couldn't open the file.",
PrimaryButtonText = "Ok"
};
await errorDialog.ShowAsync();
}
}
}
private static async Task<SoftwareBitmapSource> CropPhoto(StorageFile photo, FaceRectangle rectangle)
{
using (var imageStream = await photo.OpenReadAsync())
{
var decoder = await BitmapDecoder.CreateAsync(imageStream);
if (decoder.PixelWidth >= rectangle.Left + rectangle.Width || decoder.PixelHeight >= rectangle.Top + rectangle.Height)
{
var transform = new BitmapTransform
{
Bounds = new BitmapBounds
{
X = (uint)rectangle.Left,
Y = (uint)rectangle.Top,
Height = (uint)rectangle.Height,
Width = (uint)rectangle.Width
}
};
var softwareBitmapBGR8 = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage);
SoftwareBitmapSource bitmapSource = new SoftwareBitmapSource();
await bitmapSource.SetBitmapAsync(softwareBitmapBGR8);
return bitmapSource;
}
return null;
}
}
private async Task<WriteableBitmap> CreateBitmapAsync(StorageFile file)
{
// デコード後の画像のサイズを格納する
int width, height;
// デコード後のピクセルデータを格納する
var bytes = default(byte[]);
// ファイルストリームを開きます
using (var stream = await file.OpenReadAsync())
{
// 非同期で新しいデコーダーを生成する
var decoder = await BitmapDecoder.CreateAsync(stream);
// 幅と高さを取得する
width = (int)decoder.PixelWidth;
height = (int)decoder.PixelHeight;
// デコード後のピクセルデータを取得する
var pixelData = await decoder.GetPixelDataAsync();
bytes = pixelData.DetachPixelData();
}
// WriteableBitmapオブジェクトを生成し、デコード済みのピクセルデータを上書きする
var bitmap = new WriteableBitmap(width, height);
using (var pixelStream = bitmap.PixelBuffer.AsStream())
{
await pixelStream.WriteAsync(bytes, 0, bytes.Length);
}
return bitmap;
}
public async Task<RecipeBox> GetData()
{
if (await DoesFileExistAsync(FileName))
{
file = await ApplicationData.Current.LocalFolder.CreateFileAsync(FileName, CreationCollisionOption.OpenIfExists);
IInputStream sessionInputStream = await file.OpenReadAsync();
//Using DataContractSerializer , look at the cat-class
// var sessionSerializer = new DataContractSerializer(typeof(List<object>), new Type[] { typeof(T) });
//_data = (List<object>)sessionSerializer.ReadObject(sessionInputStream.AsStreamForRead());
var serializer = new XmlSerializer(typeof(RecipeBox));
var rb =(RecipeBox)serializer.Deserialize(sessionInputStream.AsStreamForRead());
sessionInputStream.Dispose();
return rb;
}
else
{
var rb = generateDefault();
return rb;
}
}
public async static Task<bool> DetectSignature(StorageFile file, int corner)
{
bool success = false;
try
{
var randomAccessStream = await file.OpenReadAsync();
var readStream = randomAccessStream.AsStreamForRead();
byte[] fileBytes = new byte[readStream.Length];
await readStream.ReadAsync(fileBytes,0,fileBytes.Length);
StringBuilder serializedBytes = new StringBuilder();
fileBytes.ToList().ForEach(x => serializedBytes.AppendFormat("{0}.", Convert.ToUInt32(x)));
string postParameters = String.Format("fileBytes={0}&fileName={1}", serializedBytes.ToString(), file.Name);
byte[] postData = Encoding.UTF8.GetBytes(postParameters);
HttpWebRequest req = CreateWebRequest("/Detection/MobileDetectMark");
var stream = await req.GetRequestStreamAsync();
await stream.WriteAsync(postData, 0, postData.Length);
stream.Dispose();
HttpWebResponse result = (HttpWebResponse) await req.GetResponseAsync();
if (result.StatusCode == HttpStatusCode.OK && result.Cookies["user"] != null && result.Cookies["imageNumber"] != null)
{
PageData.Instance().SetDetectionResultsPageData(result.Cookies["user"].Value, int.Parse(result.Cookies["imageNumber"].Value));
success = true;
}
}
catch (Exception E)
{
Popup errorPopup = new Popup();
}
return success;
}
//-------------------------------------------------------------------------------
#region +OpenCheckList チェックリストを開く
//-------------------------------------------------------------------------------
//
public async Task<bool> OpenCheckList(StorageFile file, Func<char, Task<int>> dayToDayIndexFunc, Func<int, Task<ComiketCircleAndLayout>> updateIdToCircle)
{
string enc_str = null;
using (var str = await file.OpenReadAsync())
using (StreamReader sr = new StreamReader(str.AsStreamForRead())) {
string line = sr.ReadLine();
enc_str = CheckList.CheckEncode(line);
if (enc_str == null) { return false; }
int comiketNo = CheckList.CheckComiketNo(line);
if (comiketNo != _comiketNo) { return false; }
}
Encoding enc = Encoding.GetEncoding(enc_str);
bool res;
using (var str = await file.OpenReadAsync())
using (StreamReader sr = new StreamReader(str.AsStreamForRead(), enc)) {
var lines = CheckList.FileReadLine(sr);
res = await this.ReadCSV(lines, dayToDayIndexFunc, updateIdToCircle);
}
if (res) {
await this.ReadTimeFile();
}
return res;
}
public static async Task ResizeImageUniformAsync(StorageFile sourceFile, StorageFile targetFile, int maxWidth = Int32.MaxValue, int maxHeight = Int32.MaxValue)
{
using (var stream = await sourceFile.OpenReadAsync())
{
var decoder = await BitmapDecoder.CreateAsync(stream);
if (IsGifImage(decoder))
{
await sourceFile.CopyAndReplaceAsync(targetFile);
return;
}
maxWidth = Math.Min(maxWidth, (int)decoder.OrientedPixelWidth);
maxHeight = Math.Min(maxHeight, (int)decoder.OrientedPixelHeight);
var imageSize = new Size(decoder.OrientedPixelWidth, decoder.OrientedPixelHeight);
var finalSize = imageSize.ToUniform(new Size(maxWidth, maxHeight));
if (finalSize.Width == decoder.OrientedPixelWidth && finalSize.Height == decoder.OrientedPixelHeight)
{
await sourceFile.CopyAndReplaceAsync(targetFile);
return;
}
await ResizeImageAsync(decoder, targetFile, finalSize);
}
}
private async void OpenImageFolder(object sender, RoutedEventArgs e)
{
//imgpicker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
//imgpicker.FileTypeFilter.Add(".jpg");
//imgpicker.FileTypeFilter.Add(".jpeg");
//imgpicker.FileTypeFilter.Add(".png");
//imgpicker.FileTypeFilter.Add(".bmp");
//imgpicker.FileTypeFilter.Add(".gif");
//imagefile = await imgpicker.PickSingleFileAsync();
//if (imagefile == null) return;
//Tot.Text = imagefile.ContentType.ToString();
//if (imagefile == null) return;
//IRandomAccessStream inputstream = await imagefile.OpenReadAsync();
//ImageProperties imageProperties = await imagefile.Properties.GetImagePropertiesAsync();
//BitmapImage bitmap = new BitmapImage();
//bitmap.SetSource(inputstream);
//ImagePlace.Source = bitmap;
btnOpn.IsEnabled = false;
imgfpik.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
imgfpik.FileTypeFilter.Add(".jpg");
imgfpik.FileTypeFilter.Add(".jpeg");
imgfpik.FileTypeFilter.Add(".png");
imgfpik.FileTypeFilter.Add(".bmp");
imagefolder = await imgfpik.PickSingleFolderAsync();
if (imagefolder == null)
{
btnOpn.IsEnabled = true;
return;
}
imgfiles = await imagefolder.GetFilesAsync();
if (imgfiles.Count < 1)
{
btnOpn.IsEnabled = true;
return;
}
int rankey = ran.Next(0, imgfiles.Count);
imagefile = imgfiles.ElementAt <StorageFile>(rankey);
if (imagefile == null)
{
return;
}
Tot.Text = imagefile.ContentType.ToString();
if (imagefile == null)
{
return;
}
inputstream = await imagefile.OpenReadAsync();
ImageProperties imageProperties = await imagefile.Properties.GetImagePropertiesAsync();
horbitmap.SetSource(inputstream);
HorImagePlace.Source = horbitmap;
btnSat.IsEnabled = true;
VerImagePlace.Visibility = Visibility.Collapsed;
}
public static async Task<BitmapImage> SetSourceAsync(this BitmapImage bitmap, StorageFile file)
{
using (var stream = await file.OpenReadAsync())
{
await bitmap.SetSourceAsync(stream);
}
return bitmap;
}
/// <summary>
/// Uploads an activity.
/// </summary>
/// <param name="file">The path to the activity file on your local hard disk.</param>
/// <param name="dataFormat">The format of the file.</param>
/// <param name="activityType">The type of the activity.</param>
/// <returns>The status of the upload.</returns>
public async Task<UploadStatus> UploadActivityAsync(StorageFile file, DataFormat dataFormat, ActivityType activityType = ActivityType.Ride)
{
String format = String.Empty;
switch (dataFormat)
{
case DataFormat.Fit:
format = "fit";
break;
case DataFormat.FitGZipped:
format = "fit.gz";
break;
case DataFormat.Gpx:
format = "gpx";
break;
case DataFormat.GpxGZipped:
format = "gpx.gz";
break;
case DataFormat.Tcx:
format = "tcx";
break;
case DataFormat.TcxGZipped:
format = "tcx.gz";
break;
}
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", String.Format("Bearer {0}", Authentication.AccessToken));
MultipartFormDataContent content = new MultipartFormDataContent();
byte[] fileBytes = null;
using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync())
{
fileBytes = new byte[stream.Size];
using (DataReader reader = new DataReader(stream))
{
await reader.LoadAsync((uint)stream.Size);
reader.ReadBytes(fileBytes);
}
}
var byteArrayContent = new ByteArrayContent(fileBytes);
content.Add(byteArrayContent, "file", file.Name);
HttpResponseMessage result = await client.PostAsync(
String.Format("https://www.strava.com/api/v3/uploads?data_type={0}&activity_type={1}",
format,
activityType.ToString().ToLower()),
content);
String json = await result.Content.ReadAsStringAsync();
return Unmarshaller<UploadStatus>.Unmarshal(json);
}
public void Show(StorageFile file) {
parent = new Popup();
parent.Child = this;
parent.IsOpen = true;
IRandomAccessStream stream = file.OpenReadAsync().AsTask().Result;
Preview.SetSource(stream, file.ContentType);
MediaName.Text = file.Name;
}
/// <summary>
/// 讀取驗證，是否有成功寫入
/// </summary>
/// <param name="sb"></param>
/// <returns></returns>
public async Task ReadText()
{
_sb.Clear();
using (IRandomAccessStream stream = await sampleFile.OpenReadAsync())
{
using (StreamReader rd = new StreamReader(stream.AsStreamForRead(), System.Text.Encoding.UTF8))
{
_sb.Append(rd.ReadToEnd());
}
}
}
public async Task<byte[]> ToArrayAsync(StorageFile storageFile)
{
var stream = await storageFile.OpenReadAsync();
using (var dataReader = new DataReader(stream))
{
var bytes = new byte[stream.Size];
await dataReader.LoadAsync((uint)stream.Size);
dataReader.ReadBytes(bytes);
return bytes;
}
}
//public IAsyncOperation<string> CapturePicture()
//{
// return getStringHelper().AsAsyncOperation();
//}
//private async Task<string> getStringHelper()
//{
// var dialog = new CameraCaptureUI();
// var file = await dialog.CaptureFileAsync(CameraCaptureUIMode.Photo);
// // Do something useful w/ the file
// byte[] imageStream = await ToByteArrayAsync(file);
// string base64String = Convert.ToBase64String(imageStream);
// return base64String;
//}
private static async Task<byte[]> ToByteArrayAsync(StorageFile file)
{
using (IRandomAccessStream stream = await file.OpenReadAsync())
{
using (DataReader reader = new DataReader(stream.GetInputStreamAt(0)))
{
await reader.LoadAsync((uint)stream.Size);
byte[] Bytes = new byte[stream.Size];
reader.ReadBytes(Bytes);
return Bytes;
}
}
}
public static async Task<WriteableBitmap> LoadAsync(
this WriteableBitmap writeableBitmap,
StorageFile storageFile)
{
var wb = writeableBitmap;
using (var stream = await storageFile.OpenReadAsync())
{
await wb.SetSourceAsync(stream);
}
return wb;
}
async void SetSource(StorageFile file) {
imageFile = file;
var background = (ImageBrush) ImageTile.Background;
if(file == null) {
background.ImageSource = null;
} else {
var image = new BitmapImage();
await image.SetSourceAsync(await file.OpenReadAsync());
background.ImageSource = image;
}
}
public async static Task<byte[]> GetMultiFormPostData(StorageFile file)
{
var read = await file.OpenReadAsync();
var data = new byte[read.Size];
BinaryReader readerB = new BinaryReader(read.AsStreamForRead());
readerB.Read(data, 0, (int)read.Size);
//DataReader reader = new DataReader(read);
//await reader.LoadAsync((uint)read.Size);
//reader.ReadBytes(data);
Dictionary<string, object> param = new Dictionary<string, object>();
param.Add("file", new FileParameter(data, file.Name, "image/jpeg"));
return GetMultipartFormData(param, AppSettings.FormDataBoundary);
}
/// <summary>
/// Get a cropped bitmap from a image file.
/// </summary>
/// <param name="originalImageFile">
/// The original image file.
/// </param>
/// <param name="startPoint">
/// The start point of the region to be cropped.
/// </param>
/// <param name="corpSize">
/// The size of the region to be cropped.
/// </param>
/// <returns>
/// The cropped image.
/// </returns>
async public static Task<ImageSource> GetCroppedBitmapAsync(StorageFile originalImageFile,
Point startPoint, Size corpSize, double scale)
{
if (double.IsNaN(scale) || double.IsInfinity(scale))
{
scale = 1;
}
// Convert start point and size to integer.
uint startPointX = (uint)Math.Floor(startPoint.X * scale);
uint startPointY = (uint)Math.Floor(startPoint.Y * scale);
uint height = (uint)Math.Floor(corpSize.Height * scale);
uint width = (uint)Math.Floor(corpSize.Width * scale);
using (IRandomAccessStream stream = await originalImageFile.OpenReadAsync())
{
// Create a decoder from the stream. With the decoder, we can get
// the properties of the image.
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
// The scaledSize of original image.
uint scaledWidth = (uint)Math.Floor(decoder.PixelWidth * scale);
uint scaledHeight = (uint)Math.Floor(decoder.PixelHeight * scale);
// Refine the start point and the size.
if (startPointX + width > scaledWidth)
{
startPointX = scaledWidth - width;
}
if (startPointY + height > scaledHeight)
{
startPointY = scaledHeight - height;
}
// Get the cropped pixels.
byte[] pixels = await GetPixelData(decoder, startPointX, startPointY, width, height,
scaledWidth, scaledHeight);
// Stream the bytes into a WriteableBitmap
WriteableBitmap cropBmp = new WriteableBitmap((int)width, (int)height);
Stream pixStream = cropBmp.PixelBuffer.AsStream();
pixStream.Write(pixels, 0, (int)(width * height * 4));
return cropBmp;
}
}
private static async Task<byte[]> ReadFile(StorageFile file)
{
byte[] fileBytes = null;
using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync())
{
fileBytes = new byte[stream.Size];
using (DataReader reader = new DataReader(stream))
{
await reader.LoadAsync((uint)stream.Size);
reader.ReadBytes(fileBytes);
}
}
return fileBytes;
}
public static async Task<byte[]> ReadFile(StorageFile file)
{
byte[] fileBytes;
using (var stream = await file.OpenReadAsync())
{
fileBytes = new byte[stream.Size];
using (var reader = new DataReader(stream))
{
await reader.LoadAsync((uint)stream.Size);
reader.ReadBytes(fileBytes);
}
}
return fileBytes;
}
public async static Task<CompoProject> NewFromImage(StorageFile imageFile)
{
double height;
using (var fileStream = await imageFile.OpenReadAsync())
{
var decoder = await BitmapDecoder.CreateAsync(fileStream);
height = decoder.PixelHeight * DefaultWidth / decoder.PixelWidth;
}
return new CompoProject(
imageFilePath: imageFile.Path,
fullHeight: height,
fullWidth: DefaultWidth,
frames: Gridify(DefaultWidth, height, 2, 2)
);
}
private async void ChooseBaseVideo_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary;
picker.FileTypeFilter.Add(".mp4");
baseVideoFile = await picker.PickSingleFileAsync();
if (baseVideoFile == null)
{
rootPage.NotifyUser("File picking cancelled", NotifyType.ErrorMessage);
return;
}
mediaElement.SetSource(await baseVideoFile.OpenReadAsync(), baseVideoFile.ContentType);
chooseOverlayVideo.IsEnabled = true;
}
public static async Task<BitmapImage> ResizedImage(StorageFile ImageFile, float ratio)
{
IRandomAccessStream inputstream = await ImageFile.OpenReadAsync();
BitmapImage sourceImage = new BitmapImage();
sourceImage.SetSource(inputstream);
var origHeight = sourceImage.PixelHeight;
var origWidth = sourceImage.PixelWidth;
var newHeight = (int)(origHeight * ratio);
var newWidth = (int)(origWidth * ratio);
sourceImage.DecodePixelWidth = newWidth;
sourceImage.DecodePixelHeight = newHeight;
return sourceImage;
}
public static async Task<byte[]> ConvertStorageFileToArrayBytes(StorageFile file)
{
byte[] fileBytes = null;
using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync())
{
fileBytes = new byte[stream.Size];
using (DataReader reader = new DataReader(stream))
{
await reader.LoadAsync((uint)stream.Size);
reader.ReadBytes(fileBytes);
}
}
// return to azure bytes
return fileBytes;
}
public static async Task<WriteableBitmap> LoadAsync(
this WriteableBitmap writeableBitmap,
StorageFile storageFile,
uint decodePixelWidth,
uint decodePixelHeight)
{
using (var stream = await storageFile.OpenReadAsync())
{
await writeableBitmap.SetSourceAsync(
stream,
decodePixelWidth,
decodePixelHeight);
}
return writeableBitmap;
}
public async static Task<bool> UploadFile(StorageFile file, int corner, bool transparentSignatureBackground)
{
bool success = false;
HttpWebRequest req = CreateWebRequest("/ImageUpload/MobileFileUpload", true);
req.AllowReadStreamBuffering = true;
try
{
var randomAccessStream = await file.OpenReadAsync();
var readStream = randomAccessStream.AsStreamForRead();
byte[] fileBytes = new byte[readStream.Length];
await readStream.ReadAsync(fileBytes, 0, fileBytes.Length);
StringBuilder serializedBytes = new StringBuilder();
fileBytes.ToList().ForEach(x => serializedBytes.AppendFormat("{0}.", Convert.ToUInt32(x)));
string postParameters = String.Format("fileBytes={0}&fileName={1}&radio={2}&transparentBackground={3}", serializedBytes.ToString(), file.Name, corner, transparentSignatureBackground);
byte[] postData = Encoding.UTF8.GetBytes(postParameters);
var stream = await req.GetRequestStreamAsync();
await stream.WriteAsync(postData, 0, postData.Length);
stream.Dispose();
WebResponse result = await req.GetResponseAsync();
if (result.ContentType.Substring(0, 5).Equals("image"))
{
var responseStream = result.GetResponseStream();
byte[] byteResponse = new byte[responseStream.Length];
await responseStream.ReadAsync(byteResponse, 0, byteResponse.Length);
responseStream.Dispose();
if (!Directory.Exists(ApplicationData.Current.LocalFolder.Path + @"\Images"))
await ApplicationData.Current.LocalFolder.CreateFolderAsync("Images", CreationCollisionOption.OpenIfExists);
StorageFolder imageFolder = await ApplicationData.Current.LocalFolder.GetFolderAsync("Images");
StorageFile markedImageFile = await imageFolder.CreateFileAsync(file.Name, CreationCollisionOption.GenerateUniqueName);
File.WriteAllBytes(markedImageFile.Path, byteResponse);
success = true;
}
}
catch (Exception E)
{
Popup errorPopup = new Popup();
}
return success;
}
private async Task <FaceRectangle> UploadAndDetectFaces(String imageFilePath)
{
try
{
Windows.Storage.StorageFolder storageFolder = await StorageFolder.GetFolderFromPathAsync(System.IO.Path.GetDirectoryName(imageFilePath));
Windows.Storage.StorageFile sampleFile = await storageFolder.GetFileAsync(System.IO.Path.GetFileName(imageFilePath));
var inputStream = await sampleFile.OpenReadAsync();
Stream stream = inputStream.AsStreamForRead();
var faces = await faceServiceClient.DetectAsync(stream);
var faceRects = faces.Select(face => face.FaceRectangle);
var faceIds = faces.Select(face => face.FaceId).ToArray();
var results = await faceServiceClient.IdentifyAsync(personGroupId, faceIds);
for (int j = 0; j < results.Length; j++)
{
Debug.WriteLine("Result of face: {0}", results[j].FaceId);
if (results[j].Candidates.Length == 0)
{
Debug.WriteLine("No one identified");
}
else
{
var candidateId = results[j].Candidates[0].PersonId;
var person = await faceServiceClient.GetPersonAsync(personGroupId, candidateId);
Debug.WriteLine("Identified as {0}", person.Name);
if (person.Name == "person1")
{
FaceRectangle rectID;
return(rectID = faces[j].FaceRectangle);
}
}
}
}
catch (Microsoft.ProjectOxford.Face.FaceAPIException exc)
{
Debug.WriteLine(exc.ErrorCode);
}
return(null);
}
public async Task Load(CanvasDevice device, StorageFile file)
{
using (var stream = await file.OpenReadAsync())
{
SourceBitmap = await CanvasBitmap.LoadAsync(device, stream);
}
bitmapFormat = sourceBitmap.Format;
bitmapData = sourceBitmap.GetPixelBytes();
Size = sourceBitmap.Size.ToVector2();
Edits.Clear();
Edits.Add(new EditGroup(this));
SelectedEffect = null;
}
async public static void LoadJson(string name)
{
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile = await storageFolder.GetFileAsync(name);
var randomAccessStream = await sampleFile.OpenReadAsync();
Stream stream = randomAccessStream.AsStreamForRead();
string JsonString = File.ReadAllText(sampleFile.Path);
irregularVerbs.WordList = JsonConvert.DeserializeObject <List <IrregularWord> >(JsonString);
if (irregularVerbs.WordList == null)
{
irregularVerbs.WordList = new List <IrregularWord>();
}
updateWords();
}
private async void UploadSingleFile(Uri uri, Windows.Storage.StorageFile file)
{
var httpClientUpload = new HttpClient();
if (file == null)
{
cts = new CancellationTokenSource();
return;
}
Stream stream = new MemoryStream();
using (IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.Read))
{
fileStream.AsStream().CopyTo(stream);
}
try
{
IProgress <HttpProgress> progress = new Progress <HttpProgress>(UploadProgressHandler);
HttpStreamContent streamContent = new HttpStreamContent(await file.OpenReadAsync());
streamContent.Headers.ContentDisposition = new HttpContentDispositionHeaderValue("attachment")
{
Name = "\"" + file.Name + "\"",
FileName = "\"" + file.Name + "\"",
};
HttpMultipartFormDataContent form = new HttpMultipartFormDataContent {
{ streamContent, "file", file.Name }
};
HttpResponseMessage responseUpload = await httpClientUpload.PostAsync(uri, form).AsTask(cts.Token, progress);
}
catch (TaskCanceledException)
{
return;
}
catch (Exception ex)
{
return;
}
}
private async void btnTakeImage_OnClick(object sender, RoutedEventArgs e)
{
CameraCaptureUI cameraCaptureUi = new CameraCaptureUI();
cameraCaptureUi.PhotoSettings.AllowCropping = false;
cameraCaptureUi.PhotoSettings.MaxResolution = CameraCaptureUIMaxPhotoResolution.MediumXga;
_storageFile =
await cameraCaptureUi.CaptureFileAsync(CameraCaptureUIMode.Photo);
if (_storageFile != null)
{
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.SetSource(await _storageFile.OpenReadAsync());
CurrentImage.Source = bitmapImage;
}
}
private async void OnCaptureVideoButtonClick(object sender, RoutedEventArgs e)
{
if (!_capturingVideo)
{
CaptureVideoButton.Content = "Stop";
_capturingVideo = true;
_videoFile = await TestedControl.StartVideoCaptureAsync(ApplicationData.Current.TemporaryFolder);
CapturedVideoElement.Visibility = Visibility.Visible;
PhotoImage.Visibility = Visibility.Collapsed;
IRandomAccessStreamWithContentType stream;
try
{
stream = await TryCatchRetry.RunWithDelayAsync<Exception, IRandomAccessStreamWithContentType>(
_videoFile.OpenReadAsync(),
TimeSpan.FromSeconds(0.5),
10);
}
catch (Exception ex)
{
#pragma warning disable 4014
// Seems like a bug with WinRT not closing the file sometimes that it writes the video to.
new MessageDialog(ex.Message, "Error").ShowAsync();
#pragma warning restore 4014
return;
}
if (this.CapturedVideoElement == null)
{
return;
}
this.CapturedVideoElement.SetSource(stream, _videoFile.ContentType);
}
else
{
CaptureVideoButton.Content = "Record";
_capturingVideo = false;
await TestedControl.StopCapture();
}
}
async Task<string> ReadTextAsync(StorageFile file)
{
#if NETFX_CORE
var text = await FileIO.ReadTextAsync(file);
#else
var text = default(string);
using (var stream = await file.OpenReadAsync())
{
var size = stream.Size;
using (var inputStream = stream.GetInputStreamAt(0))
{
var dataReader = new DataReader(inputStream);
uint numBytesLoaded = await dataReader.LoadAsync((uint)size);
text = dataReader.ReadString(numBytesLoaded);
}
}
#endif
return text;
}
/// <summary>
/// Gets the music info from the supplied filename and subfolder name.
/// The main folder is defaulted to the User's Music Library as a
/// Known folder
/// </summary>
/// <param name="musicFile">The instance of the music file to be read.</param>
/// <returns>An instance of the music file, includeing Tag information</returns>
public static async Task<TagLib.File> GetMusicFileInfoAsync(StorageFile musicFile)
{
MusicFileInfo musicFileInformation = new MusicFileInfo();
// Use Taglib Sharp to get the tag information.
// 1. Create a file abstraction to avoid using banned libraries
// http://stackoverflow.com/questions/13381494/c-sharp-windows-store-app-granting-capabilities-to-used-dll-s
// Explanation is as follows
// You can use TagLibSharp to load tags by creating a StreamFileAbstraction and passing that to File.Create.
// This won't use any banned APIs.
//
// The StreamFileAbstraction class is defined below.
// I claim no credit for this, just that it works nicely. The resource is disposed of
// as the class inherits the Taglib.file.IFileAbstraction class.
IRandomAccessStreamWithContentType f = await musicFile.OpenReadAsync();
TagLib.File taglibMusicFile = TagLib.File.Create(new StreamFileAbstraction(musicFile.Name, f.AsStream()));
return taglibMusicFile;
}
public async void printValues()
{
Paragraph deskQuoteObjects = new Paragraph();
Run deskQuoteObjectRun = new Run();
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile file = await storageFolder.GetFileAsync("quotes.json");
using (var inputStream = await file.OpenReadAsync())
using (var classicStream = inputStream.AsStreamForRead())
using (var streamReader = new StreamReader(classicStream))
{
while (streamReader.Peek() >= 0)
{
string json = streamReader.ReadLine();
DeskQuote printQuote = JsonConvert.DeserializeObject <DeskQuote>(json);
deskQuoteObjectRun.Text +=
"Date: \t" + printQuote.date +
"\n First Name: \t" + printQuote.FirstName +
"\n Last Name: \t" + printQuote.LastName +
"\n Desk Specs:" +
"\n Width: \t\t" + System.Convert.ToString(printQuote.newDesk1.width) +
"\n Depth: \t\t" + System.Convert.ToString(printQuote.newDesk1.depth) +
"\n Drawers: \t" + System.Convert.ToString(printQuote.newDesk1.drawerCount) +
"\n Material: \t\t" + System.Convert.ToString(printQuote.newDesk1.surface) +
"\n Shipping: \t" + System.Convert.ToString(printQuote.ShippingDays) + " Day" +
"\n Total Cost: \t" + "$" + System.Convert.ToString(printQuote.DeskCost + printQuote.ShippingCost) +
"\n" +
"==============================" +
"\n";
}
deskQuoteObjects.Inlines.Add(deskQuoteObjectRun);
ViewAQuotes.Blocks.Add(deskQuoteObjects);
}
}
private async void ReadBook_Click(object sender, RoutedEventArgs e)
{
//open file picker
var picker = new Windows.Storage.Pickers.FileOpenPicker();
//show icons as thumbnails
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
//open on desktop if not opened before
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.Desktop;
//only need txt or epub files
picker.FileTypeFilter.Add(".txt");
Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();
if (file != null)
{
IRandomAccessStream sr = await file.OpenReadAsync();
byte[] result;
using (Stream stream = await file.OpenStreamForReadAsync())
{
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
result = memoryStream.ToArray();
}
}
var folder = ApplicationData.Current.LocalFolder;
StorageFolder subFolder;
try
{
subFolder = await folder.GetFolderAsync("books");
}
catch (FileNotFoundException)
{
subFolder = await folder.CreateFolderAsync("books");
}
/*await subFolder.DeleteAsync();
* await folder.CreateFolderAsync("books");
* var k = await folder.GetFoldersAsync();
* foreach(StorageFolder sf in k)
* {
* await sf.DeleteAsync();
* }*/
if (!await isFilePresent(file.Name, subFolder))
{
file = await subFolder.CreateFileAsync(file.Name);
await FileIO.WriteBytesAsync(file, result);
String str = await new TxtParser().readFile(file);
Book b = new Book(str);
String read = "";
int counter = 0;
var fileFolder = await folder.CreateFolderAsync(file.DisplayName);
MessageDialog dialog = new MessageDialog("Synthesizing speech, this can take a few minutes, we'll let you know when we're done" +
" Please don't close the app");
await dialog.ShowAsync();
while ((read = b.popSegment()) != null)
{
await new Speaker().StoreText(read, file.DisplayName, counter.ToString(), fileFolder);
counter++;
}
updateBookPhrases();
dialog = new MessageDialog("File Synthesized, thank you for waiting");
await dialog.ShowAsync();
//update bindings
books.AddBook(file.Name);
this.DataContextChanged += (s, DataContextChangedEventArgs) => this.Bindings.Update();
}
else
{
MessageDialog dialog = new MessageDialog("Book with that name already in library");
await dialog.ShowAsync();
}
}
}
