push latest updates

xinyzhou · xinyzhou · commit d8800b4707e4 · 2019-05-02T18:12:30.000-07:00
diff --git a/dotnet/InkRecognition/wpf-app/src/HTTP/HttpManager.cs b/dotnet/InkRecognition/wpf-app/src/HTTP/HttpManager.cs
@@ -1,5 +1,4 @@
 ﻿using Contoso.NoteTaker.JSON;
-using Contoso.NoteTaker.JSON.Format;
 using System;
 using System.Net;
 using System.Net.Http;
@@ -23,23 +22,24 @@ public HttpManager(string appKey, string baseAddress, string destinationUrl)
 
         public async Task<HttpResponseMessage> PutAsync(string jsonRequest)
         {
-            var httpContent = new StringContent(jsonRequest, Encoding.UTF8, "application/json");
-            var httpResponse = await httpClient.PutAsync(destinationUrl, httpContent);
-
-            // Throw exception for malformed/unauthorized http requests
-            if (httpResponse.StatusCode == HttpStatusCode.BadRequest || httpResponse.StatusCode == HttpStatusCode.NotFound || httpResponse.StatusCode == HttpStatusCode.Unauthorized)
+            try
             {
-                var errorJson = await httpResponse.Content.ReadAsStringAsync();
+                var httpContent = new StringContent(jsonRequest, Encoding.UTF8, "application/json");
+                var httpResponse = await httpClient.PutAsync(destinationUrl, httpContent);
 
-                var errDetail = JSONProcessor.ParseInkRecognitionError(errorJson);
-                ThrowExceptionForHttpError(errDetail);
+                // Throw exception for malformed/unauthorized http requests
+                if (httpResponse.StatusCode == HttpStatusCode.BadRequest || httpResponse.StatusCode == HttpStatusCode.Unauthorized)
+                {
+                    var errorJson = await httpResponse.Content.ReadAsStringAsync();
+                    var errDetail = JSONProcessor.ParseInkRecognitionError(errorJson);
+                    throw new HttpRequestException(errDetail.ToString());
+                }
+                return httpResponse;
+            }
+            catch(Exception e)
+            {
+                throw e;
             }
-            return httpResponse;
-        }
-
-        private void ThrowExceptionForHttpError(HttpErrorDetails httpError)
-        {
-            throw new HttpRequestException(httpError.ToString());
         }
     }
 }
diff --git a/dotnet/InkRecognition/wpf-app/src/Helpers/InkPointHelper.cs b/dotnet/InkRecognition/wpf-app/src/Helpers/InkPointHelper.cs
diff --git a/dotnet/InkRecognition/wpf-app/src/JSON/Converter/InkPointsToStringConverter.cs b/dotnet/InkRecognition/wpf-app/src/JSON/Converter/InkPointsToStringConverter.cs
@@ -1,20 +1,22 @@
 ﻿using Newtonsoft.Json;
-using Contoso.NoteTaker.Helpers;
 using System;
 using System.Collections.Generic;
 using Windows.UI.Input.Inking;
+using System.Linq;
+using System.Reflection;
 
 namespace Contoso.NoteTaker.JSON.Converter
 {
     public class InkPointsToStringConverter : JsonConverter
     {
         public override bool CanConvert(Type objectType)
         {
-            throw new NotImplementedException();
+            return typeof(IReadOnlyList<InkPoint>).IsAssignableFrom(objectType);
         }
 
         public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
         {
+            // Since CanRead flag is false, this function will not be called
             throw new NotImplementedException();
         }
 
@@ -23,7 +25,10 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
             var points = value as IReadOnlyList<InkPoint>;
             if (points != null)
             {
-                var pointsStr = InkPointHelper.InkPointsToString(points);
+                var pointsStr = string.Join(",",
+                                    points.Select(p => Convert.ToSingle(p.Position.X) + "," +
+                                                        Convert.ToSingle(p.Position.Y))
+                                );
                 serializer.Serialize(writer, pointsStr);
             }
             else
diff --git a/dotnet/InkRecognition/wpf-app/src/JSON/Converter/InkRecognitionResponseConverter.cs b/dotnet/InkRecognition/wpf-app/src/JSON/Converter/InkRecognitionResponseConverter.cs
@@ -15,6 +15,7 @@ public override bool CanConvert(Type objectType)
 
         public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
         {
+            // Since CanWrite flag is false, this function will not be called
             throw new NotImplementedException();
         }
 
diff --git a/dotnet/InkRecognition/wpf-app/src/JSON/Format/HttpErrorDetails.cs b/dotnet/InkRecognition/wpf-app/src/JSON/Format/HttpErrorDetails.cs
@@ -19,20 +19,9 @@ public class HttpErrorDetails
         public override string ToString()
         {
             string msg = "";
-            if (ErrorCode != null)
-            {
-                msg += "Http Error code: " + ErrorCode;
-            }
-
-            if (Target != null)
-            {
-                msg += " Target: " + Target;
-            }
-
-            if (Message != null)
-            {
-                msg += " Message : " + Message;
-            }
+            msg += (ErrorCode != null) ? " Http Error code : " + ErrorCode : "";
+            msg += (Target != null) ? " Target : " + Target : "";
+            msg += (Message != null) ? " Message : " + Message : "";
 
             if (Details != null)
             {
diff --git a/dotnet/InkRecognition/wpf-app/src/JSON/Format/InkRecognitionUnit.cs b/dotnet/InkRecognition/wpf-app/src/JSON/Format/InkRecognitionUnit.cs
@@ -1,9 +1,7 @@
 ﻿using Newtonsoft.Json;
-using Contoso.NoteTaker.JSON.Converter;
+using System;
 using System.Collections.Generic;
 using System.Runtime.Serialization;
-using Windows.Foundation;
-using System;
 
 namespace Contoso.NoteTaker.JSON.Format
 {
diff --git a/dotnet/InkRecognition/wpf-app/src/JSON/Format/InkRecognizerStroke.cs b/dotnet/InkRecognition/wpf-app/src/JSON/Format/InkRecognizerStroke.cs
@@ -1,21 +1,20 @@
-﻿
-using Contoso.NoteTaker.Helpers;
-using Contoso.NoteTaker.JSON.Converter;
+﻿using Contoso.NoteTaker.JSON.Converter;
 using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
 using System.Runtime.Serialization;
+using Windows.Foundation;
 using Windows.UI.Input.Inking;
 
 namespace Contoso.NoteTaker.JSON.Format
 {
     public class InkRecognizerStroke
     {
         [JsonIgnore]
-        private InkStroke InkStroke { get; set; }
+        private InkStroke inkStrokeInternal { get; set; }
 
         [JsonProperty(PropertyName = "id")]
-        public UInt64 Id { get { return InkStroke.Id; } }
+        public UInt64 Id { get { return inkStrokeInternal.Id; } }
 
         [JsonProperty(PropertyName = "language", NullValueHandling = NullValueHandling.Ignore)]
         public string Language { get; set; } = null;
@@ -26,20 +25,31 @@ public class InkRecognizerStroke
         [JsonProperty(PropertyName = "points"), JsonConverter(typeof(InkPointsToStringConverter))]
         public IReadOnlyList<InkPoint> Points { get; protected set; }
 
-        [JsonProperty(PropertyName = "drawingAttributes")]
-        public InkDrawingAttributes DrawingAttributes { get { return InkStroke.DrawingAttributes; } }
-
         public InkRecognizerStroke(InkStroke stroke, float DpiX, float DpiY)
         {
-            InkStroke = stroke;
+            inkStrokeInternal = stroke;
 
-            var pointsInPixels = GetInkPoints();
-            Points = InkPointHelper.ConvertPixelsToMillimeters(pointsInPixels, DpiX, DpiY).AsReadOnly();
+            var pointsInPixels = inkStrokeInternal.GetInkPoints();
+            Points = ConvertPixelsToMillimeters(pointsInPixels, DpiX, DpiY).AsReadOnly();
         }
 
-        public IReadOnlyList<InkPoint> GetInkPoints()
+        private List<InkPoint> ConvertPixelsToMillimeters(IReadOnlyList<InkPoint> pointsInPixels, float DpiX, float DpiY)
         {
-            return InkStroke.GetInkPoints();
+            var transformedInkPoints = new List<InkPoint>();
+            const float inchToMillimeterFactor = 25.4f;
+
+
+            foreach (var point in pointsInPixels)
+            {
+                var transformedX = (point.Position.X / DpiX) * inchToMillimeterFactor;
+                var transformedY = (point.Position.Y / DpiY) * inchToMillimeterFactor;
+                var transformedPoint = new Point(transformedX, transformedY);
+                var transformedInkPoint = new InkPoint(transformedPoint, point.Pressure);
+
+                transformedInkPoints.Add(transformedInkPoint);
+            }
+
+            return transformedInkPoints;
         }
     }
 
diff --git a/dotnet/InkRecognition/wpf-app/src/JSON/Format/RecognitionUnitKind.cs b/dotnet/InkRecognition/wpf-app/src/JSON/Format/RecognitionUnitKind.cs
@@ -5,13 +5,13 @@ namespace Contoso.NoteTaker.JSON.Format
     public enum RecognitionUnitKind
     {
         [EnumMember(Value = "writingRegion")]
-        InkWritingRegion,
+        WritingRegion,
 
         [EnumMember(Value = "paragraph")]
-        InkParagraph,
+        Paragraph,
 
         [EnumMember(Value = "line")]
-        InkLine,
+        Line,
 
         [EnumMember(Value = "inkWord")]
         InkWord,
@@ -20,7 +20,7 @@ public enum RecognitionUnitKind
         InkDrawing,
 
         [EnumMember(Value = "listItem")]
-        InkListItem,
+        ListItem,
 
         [EnumMember(Value = "inkBullet")]
         InkBullet,
diff --git a/dotnet/InkRecognition/wpf-app/src/JSON/Format/Rectangle.cs b/dotnet/InkRecognition/wpf-app/src/JSON/Format/Rectangle.cs
@@ -5,15 +5,15 @@ namespace Contoso.NoteTaker.JSON.Format
     public class Rectangle
     {
         [JsonProperty(PropertyName = "topX")]
-        public float topX { get; set; }
+        public float TopX { get; set; }
 
         [JsonProperty(PropertyName = "topY")]
-        public float topY { get; set; }
+        public float TopY { get; set; }
 
         [JsonProperty(PropertyName = "width")]
-        public float width { get; set; }
+        public float Width { get; set; }
 
         [JsonProperty(PropertyName = "height")]
-        public float height { get; set; }
+        public float Height { get; set; }
     }
 }
diff --git a/dotnet/InkRecognition/wpf-app/src/JSON/JSONProcessor.cs b/dotnet/InkRecognition/wpf-app/src/JSON/JSONProcessor.cs
@@ -28,7 +28,7 @@ public static InkRecognitionRoot ParseInkRecognizerResponse(string responseJson)
             try
             {
                 var responseObj = JsonConvert.DeserializeObject<InkRecognitionResponse>(responseJson,
-                        new InkRecognitionResponseConverter());
+                                                    new InkRecognitionResponseConverter());
                 var result = new InkRecognitionRoot(responseObj);
                 return result;
             }
@@ -40,8 +40,16 @@ public static InkRecognitionRoot ParseInkRecognizerResponse(string responseJson)
 
         public static HttpErrorDetails ParseInkRecognitionError(string errorJson)
         {
-            var error = JsonConvert.DeserializeObject<HttpErrorDetails>(errorJson);
-            return error;
+            try
+            {
+                var error = JsonConvert.DeserializeObject<HttpErrorDetails>(errorJson);
+                return error;
+            }
+            catch(Exception e)
+            {
+                throw new JsonReaderException(e.Message);
+            }
+            
         }
     }
 }
diff --git a/dotnet/InkRecognition/wpf-app/src/MainWindow.xaml.cs b/dotnet/InkRecognition/wpf-app/src/MainWindow.xaml.cs
@@ -52,7 +52,7 @@ private async void DispatcherTimer_Tick(object sender, object e)
                 {
                     inkRecognizer.AddStroke(stroke);
                 }
-                var status = await inkRecognizer.AnalyzeAsync();
+                var status = await inkRecognizer.RecognizeAsync();
                 if (status == HttpStatusCode.OK)
                 {
                     var root = inkRecognizer.GetRecognizerRoot();
@@ -63,12 +63,12 @@ private async void DispatcherTimer_Tick(object sender, object e)
                 }
                 else
                 {
-                    output.Text = $"Http status error: {status}";
+                    output.Text = OutputWriter.PrintError($"Http Status: {status}");
                 }
             }
             catch (Exception ex)
             {
-                output.Text = $"Error: {ex.ToString()}";
+                output.Text = OutputWriter.PrintError(ex.ToString());
             }
         }
 
diff --git a/dotnet/InkRecognition/wpf-app/src/NoteTaker.csproj b/dotnet/InkRecognition/wpf-app/src/NoteTaker.csproj
@@ -78,7 +78,6 @@
     <Reference Include="System.Runtime.Serialization" />
     <Reference Include="System.Runtime.WindowsRuntime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>C:\Windows\Microsoft.NET\Framework\v4.0.30319\System.Runtime.WindowsRuntime.dll</HintPath>
     </Reference>
     <Reference Include="System.Xml" />
     <Reference Include="Microsoft.CSharp" />
@@ -121,7 +120,6 @@
       <DependentUpon>App.xaml</DependentUpon>
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="Helpers\InkPointHelper.cs" />
     <Compile Include="JSON\Converter\InkPointsToStringConverter.cs" />
     <Compile Include="JSON\Format\Alternates.cs" />
     <Compile Include="JSON\Format\InkBullet.cs" />
diff --git a/dotnet/InkRecognition/wpf-app/src/OutputWriter.cs b/dotnet/InkRecognition/wpf-app/src/OutputWriter.cs
@@ -24,9 +24,7 @@ public static string PrintShapes(InkRecognitionRoot root)
         public static string Print(InkRecognitionRoot root)
         {
             var output = new StringBuilder();
-            // Print lines
             output.Append(PrintLines(root));
-            // Print shapes
             output.Append(PrintShapes(root));
 
             return output.ToString();
@@ -49,9 +47,9 @@ private static string PrintRecoUnits(InkRecognitionRoot root, IEnumerable<InkRec
                         recognizedText.Append(word.RecognizedText).Append(" ");
                         break;
 
-                    case RecognitionUnitKind.InkLine:
+                    case RecognitionUnitKind.Line:
                         var line = recoUnit as InkLine;
-                        var lineChildren = root.GetChildNodesOf(line.Id).ToList();
+                        var lineChildren = root.GetChildNodesById(line.Id).ToList();
                         recognizedText.Append(PrintLineChildren(root, lineChildren)).AppendLine();
                         break;
 
diff --git a/dotnet/InkRecognition/wpf-app/src/Services/Ink/InkRecognitionRoot.cs b/dotnet/InkRecognition/wpf-app/src/Services/Ink/InkRecognitionRoot.cs
diff --git a/dotnet/InkRecognition/wpf-app/src/Services/Ink/InkRecognizer.cs b/dotnet/InkRecognition/wpf-app/src/Services/Ink/InkRecognizer.cs

Original file line number	Diff line number	Diff line change
`@@ -1,20 +1,22 @@`
`1`	`1`	`using Newtonsoft.Json;`
`2`		`-using Contoso.NoteTaker.Helpers;`
`3`	`2`	`using System;`
`4`	`3`	`using System.Collections.Generic;`
`5`	`4`	`using Windows.UI.Input.Inking;`
	`5`	`+using System.Linq;`
	`6`	`+using System.Reflection;`
`6`	`7`
`7`	`8`	`namespace Contoso.NoteTaker.JSON.Converter`
`8`	`9`	`{`
`9`	`10`	`public class InkPointsToStringConverter : JsonConverter`
`10`	`11`	`{`
`11`	`12`	`public override bool CanConvert(Type objectType)`
`12`	`13`	`{`
`13`		`- throw new NotImplementedException();`
	`14`	`+ return typeof(IReadOnlyList<InkPoint>).IsAssignableFrom(objectType);`
`14`	`15`	`}`
`15`	`16`
`16`	`17`	`public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)`
`17`	`18`	`{`
	`19`	`+ // Since CanRead flag is false, this function will not be called`
`18`	`20`	`throw new NotImplementedException();`
`19`	`21`	`}`
`20`	`22`
`@@ -23,7 +25,10 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s`
`23`	`25`	`var points = value as IReadOnlyList<InkPoint>;`
`24`	`26`	`if (points != null)`
`25`	`27`	`{`
`26`		`- var pointsStr = InkPointHelper.InkPointsToString(points);`
	`28`	`+ var pointsStr = string.Join(",",`
	`29`	`+ points.Select(p => Convert.ToSingle(p.Position.X) + "," +`
	`30`	`+ Convert.ToSingle(p.Position.Y))`
	`31`	`+ );`
`27`	`32`	`serializer.Serialize(writer, pointsStr);`
`28`	`33`	`}`
`29`	`34`	`else`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ public override bool CanConvert(Type objectType)`
`15`	`15`
`16`	`16`	`public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)`
`17`	`17`	`{`
	`18`	`+ // Since CanWrite flag is false, this function will not be called`
`18`	`19`	`throw new NotImplementedException();`
`19`	`20`	`}`
`20`	`21`
Original file line number	Diff line number	Diff line change
`@@ -5,15 +5,15 @@ namespace Contoso.NoteTaker.JSON.Format`
`5`	`5`	`public class Rectangle`
`6`	`6`	`{`
`7`	`7`	`[JsonProperty(PropertyName = "topX")]`
`8`		`- public float topX { get; set; }`
	`8`	`+ public float TopX { get; set; }`
`9`	`9`
`10`	`10`	`[JsonProperty(PropertyName = "topY")]`
`11`		`- public float topY { get; set; }`
	`11`	`+ public float TopY { get; set; }`
`12`	`12`
`13`	`13`	`[JsonProperty(PropertyName = "width")]`
`14`		`- public float width { get; set; }`
	`14`	`+ public float Width { get; set; }`
`15`	`15`
`16`	`16`	`[JsonProperty(PropertyName = "height")]`
`17`		`- public float height { get; set; }`
	`17`	`+ public float Height { get; set; }`
`18`	`18`	`}`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public static InkRecognitionRoot ParseInkRecognizerResponse(string responseJson)`
`28`	`28`	`try`
`29`	`29`	`{`
`30`	`30`	`var responseObj = JsonConvert.DeserializeObject<InkRecognitionResponse>(responseJson,`
`31`		`- new InkRecognitionResponseConverter());`
	`31`	`+ new InkRecognitionResponseConverter());`
`32`	`32`	`var result = new InkRecognitionRoot(responseObj);`
`33`	`33`	`return result;`
`34`	`34`	`}`
`@@ -40,8 +40,16 @@ public static InkRecognitionRoot ParseInkRecognizerResponse(string responseJson)`
`40`	`40`
`41`	`41`	`public static HttpErrorDetails ParseInkRecognitionError(string errorJson)`
`42`	`42`	`{`
`43`		`- var error = JsonConvert.DeserializeObject<HttpErrorDetails>(errorJson);`
`44`		`- return error;`
	`43`	`+ try`
	`44`	`+ {`
	`45`	`+ var error = JsonConvert.DeserializeObject<HttpErrorDetails>(errorJson);`
	`46`	`+ return error;`
	`47`	`+ }`
	`48`	`+ catch(Exception e)`
	`49`	`+ {`
	`50`	`+ throw new JsonReaderException(e.Message);`
	`51`	`+ }`
	`52`	`+`
`45`	`53`	`}`
`46`	`54`	`}`
`47`	`55`	`}`