public MyPoint GetClosestPoint(int x, int y)
{
MyPoint closest = Points.FirstOrDefault();
if (!Points.Any())
{
return(null);
}
double closestDistance = Hypothenuse(x, y, closest.X, closest.Y);
foreach (var point in Points)
{
var currentHyp = Hypothenuse(x, y, point.X, point.Y);
if (currentHyp < closestDistance)
{
closest = point;
closestDistance = currentHyp;
}
}
if (closest == Points.Last())
{
return(null);
}
return(closest);
}
private void RemovePoint()
{
if (Points.Any())
{
Points.RemoveAt(Points.Count - 1);
}
}
private void ThrowIfInvalidGapInterval()
{
if (Points.Any() && (Points.First().Type == PointType.Gap || Points.Last().Type == PointType.Gap))
{
throw new ExpectedException($"You can only insert manual {nameof(PointType.Gap)} points in between valid timestamps.");
}
}
/// <summary>
/// Checks whether the current <see cref="Points"/> collection is not empty.
/// </summary>
/// <exception cref="InvalidOperationException">Thrown when <see cref="Points"/> is empty.</exception>
private void ValidateHasPoints()
{
if (!Points.Any())
{
throw new InvalidOperationException(Resources.MechanismSurfaceLineBase_SurfaceLine_has_no_Geometry);
}
}
private void ThrowIfGapsNotSupported(IAquariusClient client)
{
if (Points.Any(p => p.Type == PointType.Gap) && client.ServerVersion.IsLessThan(MinimumGapVersion))
{
throw new ExpectedException($"You can't insert manual {nameof(PointType.Gap)} points before AQTS v{MinimumGapVersion}");
}
}
/// <summary>
/// Render loop
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void CompositionTarget_Rendering(object sender, EventArgs e)
{
TimeSpan timeSinceLastRender = DateTime.Now.TimeOfDay - LastRenderTime;
if (timeSinceLastRender.TotalSeconds < (1.0 / FrameLimiter))
{
return;
}
LastRenderTime = DateTime.Now.TimeOfDay;
// Stop animation if there is no more points
if (!Points.Any())
{
CompositionTarget.Rendering -= CompositionTarget_Rendering;
IsBusy = false;
IsPlaying = false;
Demo.PositionPoints.Clear();
Points.Clear();
CommandManager.InvalidateRequerySuggested();
return;
}
// Draw points for each player
foreach (List <PositionPoint> positionPoints in Points)
{
if (positionPoints.Any())
{
// get the first point of the list
PositionPoint positionPoint = positionPoints.First();
// If there is an event at this point, draw it
if (positionPoint.Event != null)
{
if (!string.IsNullOrWhiteSpace(positionPoint.Event.Message))
{
_events.Add(positionPoint.Event);
}
_drawService.DrawEvent(positionPoint);
}
else
{
// Draw it
_drawService.DrawPixel(positionPoint);
_drawService.DrawPlayerMarker(positionPoint);
}
// Remove this point
positionPoints.Remove(positionPoint);
// If there is no more points remove the list from all the lists
if (!positionPoints.Any())
{
Points.Remove(positionPoints);
break;
}
}
}
}
public Geometry GetGeometry(bool includePending)
{
if (!Points.Any())
{
return(new EllipseGeometry(PendingPoint, 0.025, 0.025));
}
if (Points.Count == 1)
{
return(new GeometryGroup
{
Children = new GeometryCollection
{
new EllipseGeometry(Points.First(), 0.025, 0.025),
new EllipseGeometry(PendingPoint, 0.025, 0.025)
}
});
}
var pathFigure = new PathFigure(Points.First(), new List <PathSegment>(), true);
var pathGeometry = new PathGeometry();
pathGeometry.Figures.Add(pathFigure);
foreach (var point in Points.Skip(1))
{
pathFigure.Segments.Add(new LineSegment(point, true));
}
if (includePending)
{
pathFigure.Segments.Add(new LineSegment(PendingPoint, true));
}
return(pathGeometry);
}
public override bool OnMouseDown(Point point)
{
if (!Points.Any <Point>())
{
//Move the selection
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
{
return(false);
}
//Start a new selection (otherwise, add to the selection)
else if (!(Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift)))
{
Document.Selections.Clear();
}
Points.Add(point);
Points.Add(point);
Preview = new PointCollection(Points);
}
else
{
if (Points.Last <Point>() == point)
{
point = new Point(point.X + 1, point.Y + 1);
}
Points.Add(point);
Preview = new PointCollection(Points);
}
base.OnMouseDown(point);
return(true);
}
/// <summary>
/// Проверка - есть ли точка с таким id в расчете
/// </summary>
public bool HasPoint(ObjectId idPoint)
{
if (Points == null || Points.Count == 0)
{
return(false);
}
return(Points.Any(p => p.DBPointId == idPoint));
}
public void AddPoint(double x, double y)
{
if (Points.Any(p => Math.Abs(p.Item1 - x) < CompareMargin))
{
throw new WrongValueException("X values can not be repeated");
}
Points.Add(new Tuple <double, double>(x, y));
}
public void AddPoint(Tuple <double, double> point)
{
if (Points.Any(p => Math.Abs(p.Item1 - point.Item1) < CompareMargin))
{
throw new WrongValueException("X values can not be repeated");
}
Points.Add(point);
}
/// <summary>
/// Moves the specified blocks.
/// </summary>
/// <param name="blocks">The blocks.</param>
private void Move(int blocks)
{
// Store starting point.
string startPoint = Coordinates();
for (var i = 0; i < blocks; i++)
{
// Move 1 block at a time - required for Part 2
int x = CurrentPoint.X;
int y = CurrentPoint.Y;
switch (CurrentDirection)
{
case Direction.East:
x++;
break;
case Direction.West:
x--;
break;
case Direction.North:
y++;
break;
case Direction.South:
y--;
break;
default:
Console.WriteLine(
$"Huh? It seems that you're trying to move in a non-standard direction. ({CurrentDirection})");
break;
}
// Set current position.
CurrentPoint = new Point(x, y);
// If there are any points in our log of previously visited points (X and Y coordinates match),
// and we have not found a previously-visited block, set this block as our first revisited block.
if (Points.Any(point => CurrentPoint.X == point.X && CurrentPoint.Y == point.Y) &&
FirstRevisitedPoint.X == 0 &&
FirstRevisitedPoint.Y == 0)
{
FirstRevisitedPoint = CurrentPoint;
}
// Add the current point to our log of positions.
Points.Add(CurrentPoint);
}
// Add the current movement to our log.
Sb.AppendLine(string.Join(",", CurrentDirection.ToString(), blocks.ToString(), CurrentPoint.X.ToString(),
CurrentPoint.Y.ToString()));
Console.WriteLine(
$"Travelled {blocks.ToString().PadLeft(6)} blocks {CurrentDirection.ToString().PadRight(10)} from {startPoint.PadRight(5)} to {Coordinates().PadRight(8)}");
}
private void CompressCoordinates()
{
double scaleX = 1.0 / 9.5;
double scaleY = 1.0 / 16.9;
Points.ForEach(p =>
{
p.X = Math.Round(p.X * scaleX, 0);
p.Y = Math.Round(p.Y * scaleY, 0);
});
do
{
List <Tuple <double, double> > usedPoints = new List <Tuple <double, double> >();
double minX = Points.Min(p => p.X);
double minY = Points.Min(p => p.Y);
Points.ForEach(p =>
{
double tempX = p.X - minX;
double tempY = p.Y - minY;
int offsetStart = 0;
int offsetEnd = 0;
int offsetX = 0;
int offsetY = 0;
while (usedPoints.Any(pt => pt.Item1 == tempX + offsetX && pt.Item2 == tempY + offsetY))
{
bool hasFoundFree = false;
offsetStart -= 4;
offsetEnd += 4;
for (int i = offsetStart; !hasFoundFree && i <= offsetEnd; i++)
{
for (int j = offsetStart; !hasFoundFree && j <= offsetEnd; j++)
{
if (!usedPoints.Any(pt => pt.Item1 == tempX + i && pt.Item2 == tempY + j))
{
offsetX = i;
offsetY = j;
hasFoundFree = true;
}
}
}
}
p.X = tempX + offsetX;
p.Y = tempY + offsetY;
usedPoints.Add(Tuple.Create(p.X, p.Y));
});
} while (Points.Any(p => p.X < 0 || p.Y < 0));
}
/// <inheritdoc/>
public override string ToString()
{
// If there is a specific configuration object, we include it
var objectPart = ConfigurationObject == null ? "" : $"{ConfigurationObject.Id}";
// If there are points, include them
var pointsPart = Points.Any() ? $"({Points.Select(point => point.ToString()).Ordered().ToJoinedString()})" : "";
// Construct the final string including the points
return($"{objectPart}{pointsPart}");
}
//--------------------------------------------------------------------------------------------------
void _UpdateTrihedron()
{
if (!Points.Any())
{
return;
}
// Calc Center
var center = new XY();
Points.ForEach(i => center.Add(_Sketch.Points[i].Coord));
center.Divide(Points.Count);
_Center2D = center.ToPnt();
//Debug.WriteLine("MoveSketchPointAction - Center {0} {1}", center.X(), center.Y());
// Project center point onto sketch plane
var center3D = ElSLib.Value(center.X, center.Y, _Sketch.Plane);
//Debug.WriteLine("MoveSketchPointAction - Center3D {0} {1} {2}", center3D.X(), center3D.Y(), center3D.Z());
// Calculate center point on working plane
if (_Sketch.Plane.Location.IsEqual(WorkspaceController.Workspace.WorkingPlane.Location, 0.00001))
{
_Center2DOnWorkingPlane = _Center2D;
}
else
{
double u = 0, v = 0;
ElSLib.Parameters(WorkspaceController.Workspace.WorkingPlane, _Sketch.Plane.Location, ref u, ref v);
_Center2DOnWorkingPlane = _Center2D.Translated(new Vec2d(u, v));
}
// Use plane from sketch, but translate it to center position
var plane = _Sketch.Plane;
plane.Location = center3D;
_GizmoPlane = new Geom_Plane(plane);
_GeomPlane = new Geom_Plane(plane);
// Create Gizmo
if (Gizmo == null)
{
Gizmo = new AIS_TranslationGizmo2D(_GizmoPlane);
Gizmo.SetLength(100);
WorkspaceController.Workspace.AisContext.Display(Gizmo, false);
}
else
{
Gizmo.SetComponent(_GeomPlane);
WorkspaceController.Workspace.AisContext.Redisplay(Gizmo, false);
}
}
public void Log()
{
for (var rowIndex = BoundingRect.MinYValue; rowIndex <= BoundingRect.MaxYValue; rowIndex++)
{
for (var columnIndex = BoundingRect.MinXValue; columnIndex <= BoundingRect.MaxXValue; columnIndex++)
{
var printChar = Points.Any(p => p.xPosition == columnIndex && p.yPosition == rowIndex) ? '#' : '.';
System.Console.Write($"{printChar}");
}
System.Console.WriteLine("");
}
}
private void PointsPropertyChanged()
{
if (Points == null || !Points.Any())
{
if (_children.Count > 4)
{
_children.RemoveRange(_children.Count - 4, 4);
}
else if (_children.Count > 1)
{
_children.RemoveRange(1, _children.Count - 1);
}
}
}
/// <summary>
/// Проверка есть ли уже такая точка в списке точек инсоляции
/// </summary>
/// <param name="dubl">Дублируется ли эта точка - т.е. если такая точка только одна, то ок, а две и больше - дубликаты</param>
public bool HasPoint(Point3d pt, bool dubl = false)
{
if (Points == null || Points.Count == 0)
{
return(false);
}
if (dubl)
{
return(Points.Where(p => p.Point.IsEqualTo(pt, TolerancePoints)).Skip(1).Any());
}
else
{
return(Points.Any(p => p.Point.IsEqualTo(pt, TolerancePoints)));
}
}
//--------------------------------------------------------------------------------------------------
void Sketch_ElementsChanged(Sketch sketch, Sketch.ElementType types)
{
if (types.HasFlag(Sketch.ElementType.Point))
{
// Check for lost points
var lostPoints = Points.Where(i => !_Sketch.Points.ContainsKey(i)).ToArray();
foreach (var lostPoint in lostPoints)
{
Points.Remove(lostPoint);
}
if (!Points.Any())
{
RaiseFinished();
}
UpdateTrihedron();
}
}
private void btn_AddNew_Click(object sender, RoutedEventArgs e)
{
var point = new WeatherData();
if (Points.Any())
{
point.TimeRate = Points.Last().TimeRate + 10;
if (point.TimeRate > 100)
{
point.TimeRate = 100;
}
}
Points.Add(point);
lb_WeatherParamList.Items.Refresh();
if (Points.Count == 1)
{
CurrentPoint = Points[0];
}
SetPointDescription();
}
/// <summary>
/// Update the bounds of the stroke
/// </summary>
public void UpdateBounds()
{
if (!Points.Any())
{
return;
}
foreach (var point in Points)
{
var pointRect = ToRect(point);
if (BoundingRect.IsEmpty)
{
BoundingRect = pointRect;
}
else
{
BoundingRect = Rectangle.Union(BoundingRect, pointRect);
}
}
}
private void LoadLines(Lines lines)
{
lines.LineEntity.ForEach(e =>
{
if (Points.Any(p => p.Id == e.FirstEnd) && Points.Any(p => p.Id == e.SecondEnd))
{
GridPoint first = Points.Single(p => p.Id == e.FirstEnd);
GridPoint last = Points.Single(p => p.Id == e.SecondEnd);
if (!Lines.Any(l => (l.Points.First() == first && l.Points.Last() == last) || (l.Points.First() == last && l.Points.Last() == first)))
{
GridPoint breakPoint = new GridPoint()
{
X = last.X, Y = first.Y, Type = GridPointType.Intersection
};
Points.Add(breakPoint);
GridLine lineStart = new GridLine()
{
Id = e.Id,
};
lineStart.Points.Add(first);
lineStart.Points.Add(breakPoint);
Lines.Add(lineStart);
GridLine lineEnd = new GridLine()
{
Id = e.Id,
};
lineEnd.Points.Add(breakPoint);
lineEnd.Points.Add(last);
Lines.Add(lineEnd);
}
}
});
}
/// <summary>
/// Sets the geometry of the surface line.
/// </summary>
/// <param name="points">The collection of points defining the surface line geometry.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="points"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when any element of <paramref name="points"/> is <c>null</c>.</exception>
public void SetGeometry(IEnumerable <Point3D> points)
{
if (points == null)
{
throw new ArgumentNullException(nameof(points), Resources.MechanismSurfaceLineBase_Collection_of_points_for_geometry_is_null);
}
if (points.Any(p => p == null))
{
throw new ArgumentException(Resources.MechanismSurfaceLineBase_A_point_in_the_collection_was_null);
}
Points = points.Select(p => new Point3D(p)).ToArray();
if (Points.Any())
{
StartingWorldPoint = Points.First();
EndingWorldPoint = Points.Last();
}
LocalGeometry = new RoundedPoint2DCollection(numberOfDecimalPlaces, Points.ProjectToLZ());
}
public void DumpPoints()
{
int maxX = Points.Max(p => p.X);
int maxY = Points.Max(p => p.Y);
Debug.WriteLine("---------------------------------");
for (int y = 0; y <= maxY; y++)
{
for (int x = 0; x <= maxX; x++)
{
if (Points.Any(p => p.X == x && p.Y == y))
{
Debug.Write("#");
}
else
{
Debug.Write(" ");
}
}
Debug.WriteLine(".");
}
Debug.WriteLine("---------------------------------");
}
public void WriteTo(BinaryWriter writer)
{
writer.Write(SRID);
if (SRID == -1)
{
return;
}
writer.Write(Version);
var properties = SerializationProperties.None;
if (ZValues.Any())
{
properties |= SerializationProperties.HasZValues;
}
if (MValues.Any())
{
properties |= SerializationProperties.HasMValues;
}
if (IsValid)
{
properties |= SerializationProperties.IsValid;
}
if (Shapes.First().Type == OpenGisType.Point && Points.Any())
{
properties |= SerializationProperties.IsSinglePoint;
}
if (Shapes.First().Type == OpenGisType.LineString && Points.Count == 2)
{
properties |= SerializationProperties.IsSingleLineSegment;
}
if (IsLargerThanAHemisphere)
{
properties |= SerializationProperties.IsLargerThanAHemisphere;
}
writer.Write((byte)properties);
if (!properties.HasFlag(SerializationProperties.IsSinglePoint) &&
!properties.HasFlag(SerializationProperties.IsSingleLineSegment))
{
writer.Write(Points.Count);
}
foreach (var point in Points)
{
point.WriteTo(writer);
}
foreach (var z in ZValues)
{
writer.Write(z);
}
foreach (var m in MValues)
{
writer.Write(m);
}
if (properties.HasFlag(SerializationProperties.IsSinglePoint) ||
properties.HasFlag(SerializationProperties.IsSingleLineSegment))
{
return;
}
writer.Write(Figures.Count);
if (Version == 1)
{
for (var shapeIndex = 0; shapeIndex < Shapes.Count; shapeIndex++)
{
var shape = Shapes[shapeIndex];
if (shape.FigureOffset == -1 || shape.IsCollection())
{
continue;
}
var nextShapeIndex = shapeIndex + 1;
while (nextShapeIndex < Shapes.Count && Shapes[nextShapeIndex].FigureOffset == -1)
{
nextShapeIndex++;
}
var lastFigureIndex = nextShapeIndex >= Shapes.Count
? Figures.Count - 1
: Shapes[nextShapeIndex].FigureOffset - 1;
if (Shapes[shapeIndex].Type == OpenGisType.Polygon)
{
// NB: Although never mentioned in MS-SSCLRT (v20170816), exterior rings must be first
writer.Write((byte)LegacyFigureAttribute.ExteriorRing);
writer.Write(Figures[shape.FigureOffset].PointOffset);
for (var figureIndex = shape.FigureOffset + 1; figureIndex <= lastFigureIndex; figureIndex++)
{
writer.Write((byte)LegacyFigureAttribute.InteriorRing);
writer.Write(Figures[figureIndex].PointOffset);
}
continue;
}
for (var figureIndex = shape.FigureOffset; figureIndex <= lastFigureIndex; figureIndex++)
{
writer.Write((byte)LegacyFigureAttribute.Stroke);
writer.Write(Figures[figureIndex].PointOffset);
}
}
}
else
{
foreach (var figure in Figures)
{
figure.WriteTo(writer);
}
}
writer.Write(Shapes.Count);
foreach (var shape in Shapes)
{
shape.WriteTo(writer);
}
if (Segments.Any())
{
writer.Write(Segments.Count);
foreach (var segment in Segments)
{
segment.WriteTo(writer);
}
}
}
//--------------------------------------------------------------------------------------------------
protected override bool MakeInternal(MakeFlags flags)
{
if (!Segments.Any() || !Points.Any())
{
var makeVertex = new BRepBuilderAPI_MakeVertex(Pnt.Origin);
BRep = makeVertex.Vertex();
HasErrors = false;
return(base.MakeInternal(flags));
}
// Create edges
var freeSegmentEdges = new Dictionary <SketchSegment, TopoDS_Edge>();
foreach (var segmentKvp in _Segments)
{
var segment = segmentKvp.Value;
if (segment.IsAuxilliary)
{
continue;
}
var segEdge = segment.MakeEdge(_Points);
if (segEdge == null)
{
Messages.Warning($"The segment {segmentKvp.Key} of type {segment.GetType().Name} failed creating an edge.");
continue;
}
freeSegmentEdges.Add(segment, segEdge);
AddNamedSubshape("seg", segEdge, segmentKvp.Key);
}
// Create wires
var wires = new List <TopoDS_Wire>();
while (freeSegmentEdges.Any())
{
var nextSegmentEdge = freeSegmentEdges.First();
var frontSegment = nextSegmentEdge.Key;
freeSegmentEdges.Remove(nextSegmentEdge.Key);
var makeWire = new BRepBuilderAPI_MakeWire(nextSegmentEdge.Value);
if ((frontSegment.StartPoint != -1) || (frontSegment.EndPoint != -1))
{
var backSegment = frontSegment;
while (freeSegmentEdges.Any())
{
nextSegmentEdge = freeSegmentEdges.FirstOrDefault(kvp => kvp.Key.IsConnected(frontSegment));
if (nextSegmentEdge.Value != null)
{
frontSegment = nextSegmentEdge.Key;
}
else
{
nextSegmentEdge = freeSegmentEdges.FirstOrDefault(kvp => kvp.Key.IsConnected(backSegment));
if (nextSegmentEdge.Value != null)
{
backSegment = nextSegmentEdge.Key;
}
else
{
// disconnected segment
break;
}
}
makeWire.Add(nextSegmentEdge.Value);
freeSegmentEdges.Remove(nextSegmentEdge.Key);
}
}
// Get wire shape
var wire = makeWire.Wire();
if (wire == null)
{
Messages.Error("Error when creating a wire.");
return(false);
}
wires.Add(wire);
}
// Create resulting shape
var builder = new TopoDS_Builder();
var shape = new TopoDS_Compound();
builder.MakeCompound(shape);
foreach (var wire in wires)
{
builder.Add(shape, wire);
}
BRep = shape;
return(base.MakeInternal(flags));
}
public void Render()
{
try
{
double CanvasWidth = (ActualWidth - 24) * Zoom;
double CanvasHeight = Height - 14;
CanvasPlot.Children.Clear();
if (CanvasWidth <= 0 || CanvasHeight <= 0)
{
return;
}
#region Determine axis range
ValueMin = double.MaxValue;
ValueMax = -double.MaxValue;
if (!double.IsNaN(AxisMin))
{
ValueMin = AxisMin;
}
else if (Points != null && Points.Count > 0)
{
foreach (var point in Points)
{
if (!double.IsNaN(point.Value))
{
ValueMin = Math.Min(ValueMin, point.Value);
}
}
}
else
{
ValueMin = 0;
}
if (!double.IsNaN(AxisMax))
{
ValueMax = AxisMax;
}
else if (Points != null && Points.Count > 0 && Points.Any(v => !double.IsNaN(v.Value)))
{
foreach (var point in Points)
{
if (!double.IsNaN(point.Value))
{
ValueMax = Math.Max(ValueMax, point.Value);
}
}
}
else
{
ValueMax = 1;
}
double Range = ValueMax - ValueMin;
if (ValueMin == ValueMax) // Range = 0, probably only one point
{
ValueMax += 1;
ValueMin -= 1;
}
else // Make sure there are a few pixels left to draw the points at the extremes
{
if (double.IsNaN(AxisMax))
{
ValueMax += Range / CanvasHeight * PointRadius;
}
if (double.IsNaN(AxisMin))
{
ValueMin -= Range / CanvasHeight * PointRadius;
}
}
Range = ValueMax - ValueMin;
Dispatcher.Invoke(() =>
{
string FloatFormat = "F0";
if (Math.Max(ValueMax, ValueMin) < 100)
{
FloatFormat = "F1";
}
if (Math.Max(ValueMax, ValueMin) < 10)
{
FloatFormat = "F2";
}
TextLineBottom.Text = ValueMin.ToString(FloatFormat, CultureInfo.InvariantCulture);
TextLineCenter.Text = ((ValueMin + ValueMax) * 0.5).ToString(FloatFormat, CultureInfo.InvariantCulture);
TextLineTop.Text = ValueMax.ToString(FloatFormat, CultureInfo.InvariantCulture);
});
#endregion
#region Adjust range highlight
double RangeHighlightClampedMin = Math.Max(ValueMin, RangeHighlightMin);
double RangeHighlightClampedMax = Math.Min(ValueMax, RangeHighlightMax);
PanelRangeHighlight.Margin = new Thickness(0, 7 + (ValueMax - RangeHighlightClampedMax) / Range * CanvasHeight, 0, 0);
PanelRangeHighlight.Height = Math.Max(0, RangeHighlightClampedMax - RangeHighlightClampedMin) / Range * CanvasHeight;
#endregion
if (Range < 0 || Points == null || Points.Count == 0)
{
ImagePlot.Source = null;
return;
}
float[] HistogramBins = new float[50];
DrawingGroup DGroup = new DrawingGroup();
using (DrawingContext DContext = DGroup.Open())
{
DContext.PushClip(new RectangleGeometry(new Rect(new Size(CanvasWidth, CanvasHeight))));
Pen OutlinePen = new Pen(Brushes.Transparent, 0);
OutlinePen.Freeze();
SolidColorBrush BackgroundBrush = new SolidColorBrush(Colors.Transparent);
BackgroundBrush.Freeze();
DContext.DrawRectangle(BackgroundBrush, OutlinePen, new Rect(new Size(CanvasWidth, CanvasHeight)));
SolidColorBrush[] ColorBrushes = PointColors.Count > 0
? PointColors.Select(c =>
{
SolidColorBrush Brush = new SolidColorBrush(Color.FromArgb(255, c.R, c.G, c.B));
Brush.Freeze();
return(Brush);
}).ToArray()
: new[] { new SolidColorBrush(Color.FromArgb(150, Colors.DeepSkyBlue.R, Colors.DeepSkyBlue.G, Colors.DeepSkyBlue.B)) };
StepX = (CanvasWidth - PointRadius * 2) / Points.Count;
OffsetX = StepX / 2 + PointRadius;
StepY = CanvasHeight / Range;
PointCenters = new System.Windows.Point[Points.Count];
for (int i = 0; i < Points.Count; i++)
{
if (double.IsNaN(Points[i].Value))
{
continue;
}
double X = i * StepX + OffsetX;
double Y = (ValueMax - Points[i].Value) * StepY;
DContext.DrawEllipse(ColorBrushes[Points[i].ColorID], OutlinePen, new System.Windows.Point(X, Y), PointRadius, PointRadius);
PointCenters[i] = new System.Windows.Point(X, Y);
HistogramBins[Math.Max(0, Math.Min(HistogramBins.Length - 1, (int)((Points[i].Value - ValueMin) / Range * (HistogramBins.Length - 1) + 0.5)))]++;
}
}
DrawingImage Plot = new DrawingImage(DGroup);
Plot.Freeze();
Dispatcher.Invoke(() => ImagePlot.Source = Plot);
Dispatcher.Invoke(() =>
{
float[] HistogramConv = new float[HistogramBins.Length];
float[] ConvKernel = { 0.11f, 0.37f, 0.78f, 1f, 0.78f, 0.37f, 0.11f };
for (int i = 0; i < HistogramBins.Length; i++)
{
float Sum = 0;
float Samples = 0;
for (int j = 0; j < ConvKernel.Length; j++)
{
int ij = i - 3 + j;
if (ij < 0 || ij >= HistogramBins.Length)
{
continue;
}
Sum += ConvKernel[j] * HistogramBins[ij];
Samples += ConvKernel[j];
}
HistogramConv[i] = Sum / Samples;
}
float HistogramMax = MathHelper.Max(HistogramConv);
if (HistogramMax > 0)
{
HistogramConv = HistogramConv.Select(v => v / HistogramMax * 16).ToArray();
}
Polygon HistogramPolygon = new Polygon()
{
Stroke = Brushes.Transparent,
Fill = Brushes.Gray,
Opacity = 0.15
};
PointCollection HistogramPoints = new PointCollection(HistogramConv.Length);
HistogramPoints.Add(new System.Windows.Point(16, 0));
HistogramPoints.Add(new System.Windows.Point(16, CanvasHeight));
for (int i = 0; i < HistogramConv.Length; i++)
{
double X = 15 - HistogramConv[i];
double Y = CanvasHeight - (i / (float)(HistogramConv.Length - 1) * CanvasHeight);
HistogramPoints.Add(new System.Windows.Point(X, Y));
}
HistogramPolygon.Points = HistogramPoints;
CanvasHistogram.Children.Clear();
CanvasHistogram.Children.Add(HistogramPolygon);
Canvas.SetRight(HistogramPolygon, 0);
});
}
catch
{
}
}
/// <summary>
/// コンストラクタ
/// </summary>
public MouseViewModel()
{
ClickCommand = new DelegateCommand <object>(
(_id) => {
// 変換
var id = int.Parse(_id.ToString());
// ランダム値
Random rnd = new System.Random();
// 要素取得
var pt = Points.First(x => x.Coordinate.Id == id);
// クリックイベント発行
mousePositionModel.ClickMouse(pt.Coordinate.X + rnd.Next(-20, 10), pt.Coordinate.Y + rnd.Next(-20, 10));
// クリックが完了するまでSleepする
System.Threading.Thread.Sleep(100);
// Windowをアクティブにする
WindowManager.ShowOrActivate <Views.Mouse>();
}
);
SaveCommand = new DelegateCommand(SavePoints);
LoadCommand = new DelegateCommand(
() => {
LoadPoints();
}
);
AddCommand = new DelegateCommand(
() => {
var id = Points.Count() + 1;
Points.Add(new CoordinateDispInfo(new Models.Coordinate(id, 0, 0)));
Subscribe?.RaiseCanExecuteChanged();
}
);
DeleteCommand = new DelegateCommand(
() => {
for (int index = 0; index < Points.Count; index++)
{
if (Points[index].IsSelected)
{
Points.RemoveAt(index);
Subscribe?.RaiseCanExecuteChanged();
}
}
}
);
StopCommand = new DelegateCommand(() => { State = "停止中"; Subscription?.Dispose(); });
var mousemove = Observable.FromEvent <EventHandler <Models.MousePosition.MouseEventArgs>, Models.MousePosition.MouseEventArgs>(
h => (s, e) => h(e),
h => mousePositionModel.Publish += h,
h => mousePositionModel.Publish -= h
);
mousemove.Subscribe(s =>
{
//Console.WriteLine("x:{0},y:{1}", s.Value.X, s.Value.Y);
PosX = (int)s.Value.X;
PosY = (int)s.Value.Y;
//Console.WriteLine("ClickPos => x:{0},y:{1}", s.Value.X, s.Value.Y);
});
// マウス自動クリックイベント購読開始
Subscribe = new DelegateCommand(
() =>
{
Subscription?.Dispose();
State = "実行中";
Subscription = this.Source.ObserveOnDispatcher().
Where(i => Points.Any(x => x.Coordinate.Id == i)).
Subscribe(
i =>
{
Console.WriteLine($"{i} times");
ClickCommand?.Execute(i);
}
,
ex => Console.WriteLine("OnError({0})", ex.Message),
() =>
{
Console.WriteLine("Completed()");
State = "停止中";
}
);
},
CanExecute
);
Dispose = new DelegateCommand(() => Subscription?.Dispose());
//LoadPoints();
mousePositionModel.Start();
}
public bool IsCheckersLeft(CheckerColor color)
{
return(Points.Any(p => p.Color == color));
}
public bool Intersect(PointType point) => Points.Any(p => (p.Position - point.Position).magnitude < IntersectSize);
