public IObservable <Unit> CreateSketchAsync(string sketchName, SketchData sketchData)
{
Contract.Requires(!string.IsNullOrEmpty(sketchName));
Contract.Requires(sketchData != null);
Contract.Ensures(Contract.Result <IObservable <Unit> >() != null);
return(null);
}
/// <summary>
/// App startup
/// </summary>
protected override async void OnStart()
{
AppCenter.Start(
"android=585676e3-a68b-48f0-8090-119788c6b1e5;" +
//"uwp={Your UWP App secret here};" +
"ios={87bd45a1-e43a-4c0f-9401-0ac71509de57}",
typeof(Analytics), typeof(Crashes)); //, typeof(Distribute));
await Task.Run(async delegate
{
var path = SketchDataPath;
if (File.Exists(path))
{
var json = File.ReadAllText(path);
LoadSketch(json);
}
else
{
if (VersionTracking.IsFirstLaunchEver)
{
await LoadInitialSketchAsync().ConfigureAwait(true);
}
else
{
_sketchData = new SketchData();
_splitPage.SketchDataUpdated(_sketchData);
}
}
}).ConfigureAwait(false);
}
public IObservable <Unit> SaveSketchAsync(string sketchName, SketchData sketchData)
{
var result =
from info in GetSketchMetadataAsync(sketchName)
from _ in SaveModellingDataAsync(info.ModelFile, sketchData)
select default(Unit);
return(result);
}
public IObservable <Unit> CreateSketchAsync(string sketchName, SketchData sketchData)
{
var result =
from catalog in LoadCatalogAsync()
from i1 in Observable.If(() => !ExistsSketch(catalog, sketchName), AddToCatalogAsync(catalog, sketchName))
from i2 in SaveSketchAsync(sketchName, sketchData)
select default(Unit);
return(result);
}
public void Push(SketchData sketchData)
{
var sketchDataWithoutDistanceTransforms = GetSketchDataWithoutDistanceTransforms(sketchData);
using (var stream = new MemoryStream())
{
formatter.Serialize(stream, sketchDataWithoutDistanceTransforms);
stream.Flush();
stack.Push(stream.ToArray());
}
}
private static SketchData GetSketchDataWithoutDistanceTransforms(SketchData sketchData)
{
var result = new SketchData()
{
Annotations = sketchData.Annotations,
Curves = sketchData.Curves,
NewPrimitives = sketchData.NewPrimitives,
SnappedPrimitives = sketchData.SnappedPrimitives,
};
return(result);
}
private IObservable <Unit> SaveModellingDataAsync(string fileName, SketchData sketchData)
{
Action saveAction = () =>
{
using (var stream = File.Create(fileName))
using (var compressed = new DeflateStream(stream, CompressionMode.Compress, true))
using (var buffered = new BufferedStream(compressed, 65536))
{
var serializer = new BinaryFormatter();
serializer.Serialize(buffered, sketchData);
}
};
return(Observable.ToAsync(saveAction)());
}
/// <summary>
/// Serialize the sketch data
/// </summary>
/// <returns></returns>
public string SerializeSketchData()
{
lock (_sketchData)
{
var sketchData = new SketchData
{
BackgroundColor = _sketchData.BackgroundColor,
Height = _sketchData.Height,
InkStrokes = _sketchData.InkStrokes.ToArray(),
Width = _sketchData.Width,
Name = _sketchData.Name,
Start = _sketchData.Start
};
var options = CreateSerializationOptions();
var json = JsonSerializer.Serialize(sketchData, options);
return(json);
}
}
private IObservable <SketchData> LoadModellingDataAsync(string modelFile, VectorImageData vectorImage)
{
Func <SketchData> loadAction = () =>
{
SketchData sketchData;
if (File.Exists(modelFile))
{
using (var stream = File.OpenRead(modelFile))
using (var compressed = new DeflateStream(stream, CompressionMode.Decompress, true))
{
var serializer = new BinaryFormatter();
sketchData = (SketchData)serializer.Deserialize(compressed);
}
}
else
{
sketchData = new SketchData();
}
if (sketchData.Curves == null)
{
sketchData.Curves = vectorImage.PolyLines.Cast <PointsSequence>().Concat(vectorImage.Polygons).ToArray();
}
if (sketchData.DistanceTransforms == null)
{
sketchData.DistanceTransforms =
sketchData.Curves
.AsParallel()
.Select(c => ComputeDistanceTransform(c))
.ToArray();
Parallel.ForEach(sketchData.DistanceTransforms, dt => Negate(dt));
}
return(sketchData);
};
return(Observable.ToAsync(loadAction)());
}
/// <summary>
/// Load a sketch from a JSON string
/// </summary>
/// <param name="json">the JSON string</param>
public bool LoadSketch(string json)
{
if (string.IsNullOrWhiteSpace(json))
{
return(false);
}
var options = CreateSerializationOptions();
try
{
var sketchData = JsonSerializer.Deserialize <SketchData>(json, options);
foreach (var stroke in sketchData.InkStrokes)
{
if (stroke.DrawingAttributes.Color.A == 0)
{
stroke.DrawingAttributes.Color = Xamarin.Forms.Color.FromRgba(stroke.DrawingAttributes.Color.R, stroke.DrawingAttributes.Color.G, stroke.DrawingAttributes.Color.B, 255);
}
stroke.UpdateBounds();
}
_sketchData = sketchData;
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine($"Error deserializing SketchData: {e.Message}");
_sketchData = new SketchData();
Crashes.TrackError(e);
}
_splitPage.SketchDataUpdated(_sketchData);
return(true);
}
private void OnTestCase(object ignore)
{
// data from which the cylinder and its curve representations will be created
var axis = RotationHelper.RotateVector(MathUtils3D.UnitY, MathUtils3D.UnitX, -20);
var center = MathUtils3D.Origin;
var radius = 0.2;
var halfLength = 0.3;
// basis vectors for the cylinder top/bottom planes
var xBase = MathUtils3D.NormalVector(axis);
var yBase = Vector3D.CrossProduct(xBase, axis);
// generators for the top/bottom circles.
var topGenerator = new PolarPointsGenerator(center + halfLength * axis, xBase, yBase);
var bottomGenerator = new PolarPointsGenerator(center - halfLength * axis, xBase, yBase);
// angles to use for circles generation.
const int COUNT = 50;
var angles =
from i in Enumerable.Range(0, COUNT)
select 2 * Math.PI * i / COUNT;
// generate top/bottom circles in 3D
var topCircle3d =
from angle in angles
select topGenerator.GetPoint(angle, radius);
var bottomCircle3d =
from angle in angles
select bottomGenerator.GetPoint(angle, radius);
// generate the left line from top to bottom
var leftLine3d =
from i in Enumerable.Range(0, COUNT)
let top = topGenerator.GetPoint(0, radius)
let bottom = bottomGenerator.GetPoint(0, radius)
let fraction = i / (double)(COUNT - 1)
select MathUtils3D.Lerp(top, bottom, fraction);
// generate right line from top to bottom
var rightLine3d =
from i in Enumerable.Range(0, COUNT)
let top = topGenerator.GetPoint(Math.PI, radius)
let bottom = bottomGenerator.GetPoint(Math.PI, radius)
let fraction = i / (double)(COUNT - 1)
select MathUtils3D.Lerp(top, bottom, fraction);
// project all lines to 2D
var topCircle2d = Project(topCircle3d);
var bottomCircle2d = Project(bottomCircle3d);
var leftLine2d = Project(leftLine3d);
var rightLine2d = Project(rightLine3d);
// generate curve data
var topCurve = new Polygon {
CurveCategory = CurveCategories.Feature, Points = topCircle2d.ToArray()
};
var bottomCurve = new Polygon {
CurveCategory = CurveCategories.Feature, Points = bottomCircle2d.ToArray()
};
var leftCurve = new Polyline {
CurveCategory = CurveCategories.Silhouette, Points = leftLine2d.ToArray()
};
var rightCurve = new Polyline {
CurveCategory = CurveCategories.Silhouette, Points = rightLine2d.ToArray()
};
// generate new primitive that exactly matches the curves
var newcylinder = new NewCylinder();
newcylinder.Axis.Value = axis;
newcylinder.Center.Value = center;
newcylinder.Length.Value = halfLength * 2;
newcylinder.Diameter.Value = radius * 2;
// reset session data
var sketchData =
new SketchData
{
NewPrimitives = new NewPrimitive[] { newcylinder },
Curves = new PointsSequence[] { topCurve, bottomCurve, leftCurve, rightCurve },
SnappedPrimitives = new SnappedPrimitive[0],
Annotations = new Annotation[0],
};
sessionData.SketchData = sketchData;
sessionData.Annotations.Clear();
sessionData.Annotations.AddRange(sketchData.Annotations);
sessionData.NewPrimitives.Clear();
sessionData.NewPrimitives.AddRange(sketchData.NewPrimitives);
sessionData.SketchObjects = sketchData.Curves.ToArray();
sessionData.SnappedPrimitives.Clear();
sessionData.SnappedPrimitives.AddRange(sessionData.SnappedPrimitives);
}
