void computeVideoBruchTransform()
{
if (m_captureDevice == null)
return;
var tmptransform = new RotateTransform() { Angle = m_orientationAngle + m_captureDevice.SensorRotationInDegrees };
var previewSize = tmptransform.TransformBounds(new Rect(new Point(), new Size(m_captureDevice.PreviewResolution.Width, m_captureDevice.PreviewResolution.Height)));
double s1 = viewfinderCanvas.ActualWidth / previewSize.Width;
double s2 = viewfinderCanvas.ActualHeight / previewSize.Height;
//fit out
double scale = m_Mode == StrechMode.UniformFill ? Math.Max(s1, s2) : Math.Min(s1, s2);
var t = new TransformGroup();
if (m_sensorLocation == CameraSensorLocation.Front)
{
t.Children.Add(new CompositeTransform() { Rotation = -(m_orientationAngle + m_captureDevice.SensorRotationInDegrees), CenterX = viewfinderCanvas.ActualWidth / 2, CenterY = viewfinderCanvas.ActualHeight / 2, ScaleX = scale, ScaleY = scale });
t.Children.Add(new ScaleTransform() { ScaleX = -1, CenterX = viewfinderCanvas.ActualWidth / 2, CenterY = viewfinderCanvas.ActualHeight / 2 });
}
else
{
t.Children.Add(new CompositeTransform() { Rotation = m_orientationAngle + m_captureDevice.SensorRotationInDegrees, CenterX = viewfinderCanvas.ActualWidth / 2, CenterY = viewfinderCanvas.ActualHeight / 2, ScaleX = scale, ScaleY = scale });
}
viewfinderBrush.Transform = t;
}
private static Point DrawLineArrowInternal(DrawingContext dc, double half, Pen pen, Brush brush, double x, double y, double angle, ArrowStyle style)
{
Point pt;
bool doRectTransform = angle % 90.0 != 0.0;
var rt = new RotateTransform(angle, x, y);
double rx = style.RadiusX;
double ry = style.RadiusY;
double sx = 2.0 * rx;
double sy = 2.0 * ry;
switch (style.ArrowType)
{
default:
case ArrowType.None:
{
pt = new Point(x, y);
}
break;
case ArrowType.Rectangle:
{
pt = rt.Transform(new Point(x - sx, y));
var rect = new Rect(x - sx, y - ry, sx, sy);
if (doRectTransform)
{
dc.PushTransform(rt);
DrawRectangleInternal(dc, half, brush, pen, style.IsStroked, style.IsFilled, ref rect);
dc.Pop();
}
else
{
var bounds = rt.TransformBounds(rect);
DrawRectangleInternal(dc, half, brush, pen, style.IsStroked, style.IsFilled, ref bounds);
}
}
break;
case ArrowType.Ellipse:
{
pt = rt.Transform(new Point(x - sx, y));
dc.PushTransform(rt);
var c = new Point(x - rx, y);
DrawEllipseInternal(dc, half, brush, pen, style.IsStroked, style.IsFilled, ref c, rx, ry);
dc.Pop();
}
break;
case ArrowType.Arrow:
{
pt = rt.Transform(new Point(x, y));
var p11 = rt.Transform(new Point(x - sx, y + sy));
var p21 = rt.Transform(new Point(x, y));
var p12 = rt.Transform(new Point(x - sx, y - sy));
var p22 = rt.Transform(new Point(x, y));
DrawLineInternal(dc, half, pen, style.IsStroked, ref p11, ref p21);
DrawLineInternal(dc, half, pen, style.IsStroked, ref p12, ref p22);
}
break;
}
return pt;
}
private void AdjustOrientation()
{
if (_photoCaptureDevice != null)
{
double canvasAngle;
if (Orientation.HasFlag(PageOrientation.LandscapeLeft))
{
canvasAngle = _photoCaptureDevice.SensorRotationInDegrees - 90;
}
else if (Orientation.HasFlag(PageOrientation.LandscapeRight))
{
canvasAngle = _photoCaptureDevice.SensorRotationInDegrees + 90;
}
else // PageOrientation.PortraitUp
{
canvasAngle = _photoCaptureDevice.SensorRotationInDegrees;
}
var tmptransform = new RotateTransform() { Angle = canvasAngle };
var previewSize = tmptransform.TransformBounds(
new System.Windows.Rect(
new System.Windows.Point(),
new System.Windows.Size(_photoCaptureDevice.PreviewResolution.Width, _photoCaptureDevice.PreviewResolution.Height)
)
);
double s1 = viewfinderCanvas.ActualWidth / previewSize.Width;
double s2 = viewfinderCanvas.ActualHeight / previewSize.Height;
//video center match Viewfinder canvas center center
BackgroundVideoBrush.AlignmentX = AlignmentX.Center;
BackgroundVideoBrush.AlignmentY = AlignmentY.Center;
//Don't use a strech strategie.
BackgroundVideoBrush.Stretch = Stretch.None;
double scale = Math.Max(s1, s2); //UniformFill
// double scale = Math.Min(s1, s2); // Uniform
var t = new TransformGroup();
if (_cameraLocation == CameraSensorLocation.Front)
{
t.Children.Add(new CompositeTransform() { Rotation = -canvasAngle, CenterX = viewfinderCanvas.ActualWidth / 2, CenterY = viewfinderCanvas.ActualHeight / 2, ScaleX = scale, ScaleY = scale });
t.Children.Add(new ScaleTransform() { ScaleX = -1, CenterX = viewfinderCanvas.ActualWidth / 2, CenterY = viewfinderCanvas.ActualHeight / 2 });
}
else
{
t.Children.Add(new CompositeTransform() { Rotation = canvasAngle, CenterX = viewfinderCanvas.ActualWidth / 2, CenterY = viewfinderCanvas.ActualHeight / 2, ScaleX = scale, ScaleY = scale });
}
BackgroundVideoBrush.Transform = t;
}
}
/// <summary>
///
/// </summary>
/// <param name="dc"></param>
/// <param name="line"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object dc, XLine line, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var _dc = dc as DrawingContext;
var style = line.Style;
if (style == null)
return;
double zoom = _state.Zoom;
double thicknessLine = style.Thickness / zoom;
double halfLine = thicknessLine / 2.0;
double thicknessStartArrow = style.StartArrowStyle.Thickness / zoom;
double halfStartArrow = thicknessStartArrow / 2.0;
double thicknessEndArrow = style.EndArrowStyle.Thickness / zoom;
double halfEndArrow = thicknessEndArrow / 2.0;
// line style
Tuple<Brush, Pen> lineCache = null;
Brush fillLine;
Pen strokeLine;
if (_enableStyleCache
&& _styleCache.TryGetValue(style, out lineCache))
{
fillLine = lineCache.Item1;
strokeLine = lineCache.Item2;
}
else
{
fillLine = CreateBrush(style.Fill);
strokeLine = CreatePen(style, thicknessLine);
if (_enableStyleCache)
_styleCache.Add(style, Tuple.Create(fillLine, strokeLine));
}
// start arrow style
Tuple<Brush, Pen> startArrowCache = null;
Brush fillStartArrow;
Pen strokeStartArrow;
if (_enableArrowStyleCache
&& _arrowStyleCache.TryGetValue(style.StartArrowStyle, out startArrowCache))
{
fillStartArrow = startArrowCache.Item1;
strokeStartArrow = startArrowCache.Item2;
}
else
{
fillStartArrow = CreateBrush(style.StartArrowStyle.Fill);
strokeStartArrow = CreatePen(style.StartArrowStyle, thicknessStartArrow);
if (_enableArrowStyleCache)
_arrowStyleCache.Add(style.StartArrowStyle, Tuple.Create(fillStartArrow, strokeStartArrow));
}
// end arrow style
Tuple<Brush, Pen> endArrowCache = null;
Brush fillEndArrow;
Pen strokeEndArrow;
if (_enableArrowStyleCache
&& _arrowStyleCache.TryGetValue(style.EndArrowStyle, out endArrowCache))
{
fillEndArrow = endArrowCache.Item1;
strokeEndArrow = endArrowCache.Item2;
}
else
{
fillEndArrow = CreateBrush(style.EndArrowStyle.Fill);
strokeEndArrow = CreatePen(style.EndArrowStyle, thicknessEndArrow);
if (_enableArrowStyleCache)
_arrowStyleCache.Add(style.EndArrowStyle, Tuple.Create(fillEndArrow, strokeEndArrow));
}
// line max length
double x1 = line.Start.X + dx;
double y1 = line.Start.Y + dy;
double x2 = line.End.X + dx;
double y2 = line.End.Y + dy;
XLine.SetMaxLength(line, ref x1, ref y1, ref x2, ref y2);
// arrow transforms
var sas = style.StartArrowStyle;
var eas = style.EndArrowStyle;
double a1 = Math.Atan2(y1 - y2, x1 - x2) * 180.0 / Math.PI;
double a2 = Math.Atan2(y2 - y1, x2 - x1) * 180.0 / Math.PI;
bool doRectTransform1 = a1 % 90.0 != 0.0;
bool doRectTransform2 = a2 % 90.0 != 0.0;
var t1 = new RotateTransform(a1, x1, y1);
var t2 = new RotateTransform(a2, x2, y2);
Point pt1;
Point pt2;
// draw start arrow
double radiusX1 = sas.RadiusX;
double radiusY1 = sas.RadiusY;
double sizeX1 = 2.0 * radiusX1;
double sizeY1 = 2.0 * radiusY1;
switch (sas.ArrowType)
{
default:
case ArrowType.None:
{
pt1 = new Point(x1, y1);
}
break;
case ArrowType.Rectangle:
{
pt1 = t1.Transform(new Point(x1 - sizeX1, y1));
var rect = new Rect(x1 - sizeX1, y1 - radiusY1, sizeX1, sizeY1);
if (doRectTransform1)
{
_dc.PushTransform(t1);
DrawRectangleInternal(_dc, halfStartArrow, fillStartArrow, strokeStartArrow, sas.IsStroked, sas.IsFilled, ref rect);
_dc.Pop();
}
else
{
var bounds = t1.TransformBounds(rect);
DrawRectangleInternal(_dc, halfStartArrow, fillStartArrow, strokeStartArrow, sas.IsStroked, sas.IsFilled, ref bounds);
}
}
break;
case ArrowType.Ellipse:
{
pt1 = t1.Transform(new Point(x1 - sizeX1, y1));
_dc.PushTransform(t1);
var c = new Point(x1 - radiusX1, y1);
DrawEllipseInternal(_dc, halfStartArrow, fillStartArrow, strokeStartArrow, sas.IsStroked, sas.IsFilled, ref c, radiusX1, radiusY1);
_dc.Pop();
}
break;
case ArrowType.Arrow:
{
pt1 = t1.Transform(new Point(x1, y1));
var p11 = t1.Transform(new Point(x1 - sizeX1, y1 + sizeY1));
var p21 = t1.Transform(new Point(x1, y1));
var p12 = t1.Transform(new Point(x1 - sizeX1, y1 - sizeY1));
var p22 = t1.Transform(new Point(x1, y1));
DrawLineInternal(_dc, halfStartArrow, strokeStartArrow, sas.IsStroked, ref p11, ref p21);
DrawLineInternal(_dc, halfStartArrow, strokeStartArrow, sas.IsStroked, ref p12, ref p22);
}
break;
}
// draw end arrow
double radiusX2 = eas.RadiusX;
double radiusY2 = eas.RadiusY;
double sizeX2 = 2.0 * radiusX2;
double sizeY2 = 2.0 * radiusY2;
switch (eas.ArrowType)
{
default:
case ArrowType.None:
{
pt2 = new Point(x2, y2);
}
break;
case ArrowType.Rectangle:
{
pt2 = t2.Transform(new Point(x2 - sizeX2, y2));
var rect = new Rect(x2 - sizeX2, y2 - radiusY2, sizeX2, sizeY2);
if (doRectTransform2)
{
_dc.PushTransform(t2);
DrawRectangleInternal(_dc, halfEndArrow, fillEndArrow, strokeEndArrow, eas.IsStroked, eas.IsFilled, ref rect);
_dc.Pop();
}
else
{
var bounds = t2.TransformBounds(rect);
DrawRectangleInternal(_dc, halfEndArrow, fillEndArrow, strokeEndArrow, eas.IsStroked, eas.IsFilled, ref bounds);
}
}
break;
case ArrowType.Ellipse:
{
pt2 = t2.Transform(new Point(x2 - sizeX2, y2));
_dc.PushTransform(t2);
var c = new Point(x2 - radiusX2, y2);
DrawEllipseInternal(_dc, halfEndArrow, fillEndArrow, strokeEndArrow, eas.IsStroked, eas.IsFilled, ref c, radiusX2, radiusY2);
_dc.Pop();
}
break;
case ArrowType.Arrow:
{
pt2 = t2.Transform(new Point(x2, y2));
var p11 = t2.Transform(new Point(x2 - sizeX2, y2 + sizeY2));
var p21 = t2.Transform(new Point(x2, y2));
var p12 = t2.Transform(new Point(x2 - sizeX2, y2 - sizeY2));
var p22 = t2.Transform(new Point(x2, y2));
DrawLineInternal(_dc, halfEndArrow, strokeEndArrow, eas.IsStroked, ref p11, ref p21);
DrawLineInternal(_dc, halfEndArrow, strokeEndArrow, eas.IsStroked, ref p12, ref p22);
}
break;
}
// draw line using points from arrow transforms
DrawLineInternal(_dc, halfLine, strokeLine, line.IsStroked, ref pt1, ref pt2);
}
private void AdjustOrientation()
{
if (_photoCaptureDevice != null)
{
double canvasAngle;
if (Orientation.HasFlag(PageOrientation.LandscapeLeft))
{
canvasAngle = _photoCaptureDevice.SensorRotationInDegrees - 90;
}
else if (Orientation.HasFlag(PageOrientation.LandscapeRight))
{
canvasAngle = _photoCaptureDevice.SensorRotationInDegrees + 90;
}
else // PageOrientation.PortraitUp
{
canvasAngle = _photoCaptureDevice.SensorRotationInDegrees;
}
var tmptransform = new RotateTransform() { Angle = canvasAngle };
var previewSize = tmptransform.TransformBounds(
new System.Windows.Rect(
new System.Windows.Point(),
new System.Windows.Size(_photoCaptureDevice.PreviewResolution.Width, _photoCaptureDevice.PreviewResolution.Height)
)
);
double s1 = viewfinderCanvas.ActualWidth / previewSize.Width;
double s2 = viewfinderCanvas.ActualHeight / previewSize.Height;
//video center match Viewfinder canvas center center
BackgroundVideoBrush.AlignmentX = AlignmentX.Center;
BackgroundVideoBrush.AlignmentY = AlignmentY.Center;
//Don't use a strech strategie.
BackgroundVideoBrush.Stretch = Stretch.None;
double scale = Math.Max(s1, s2); //UniformFill
// double scale = Math.Min(s1, s2); // Uniform
if (_photoCaptureDevice.SensorLocation == CameraSensorLocation.Back)
{
BackgroundVideoBrush.Transform = new CompositeTransform() { Rotation = canvasAngle, CenterX = viewfinderCanvas.ActualWidth / 2, CenterY = viewfinderCanvas.ActualHeight / 2, ScaleX = scale, ScaleY = scale };
}
else
{
//Front viewfinder need to be flipped
BackgroundVideoBrush.Transform = new CompositeTransform() { Rotation = canvasAngle, CenterX = viewfinderCanvas.ActualWidth / 2, CenterY = viewfinderCanvas.ActualHeight / 2, ScaleX = -scale, ScaleY = scale };
}
_photoCaptureDevice.SetProperty(KnownCameraGeneralProperties.EncodeWithOrientation, canvasAngle);
}
}
