public void QuantizeEntity()
{
var settings = new QuantizeSettings(distanceQuantum: OneSixteenth, angleQuantum: 1.0);
var line = new Line(new Point(1.4999999999, 1.5000000001, 0.0), new Point(2.50000000001, 2.4999999999, 0.0));
var quantized = (Line)EditUtilities.Quantize(line, settings);
Assert.Equal(new Point(1.5, 1.5, 0.0), quantized.P1);
Assert.Equal(new Point(2.5, 2.5, 0.0), quantized.P2);
}
protected override Drawing DoEdit(Drawing drawing, IEnumerable <Entity> entities, Vector delta)
{
foreach (var ent in entities)
{
drawing = drawing.Replace(ent, EditUtilities.Move(ent, delta));
}
return(drawing);
}
protected override Drawing DoEdit(Drawing drawing, IEnumerable <Entity> entities, Vector delta)
{
foreach (var ent in entities)
{
var layer = drawing.ContainingLayer(ent);
drawing = drawing.Add(layer, EditUtilities.Move(ent, delta));
}
return(drawing);
}
public void CircleOffsetOutsideTest()
{
var circle = (Circle)EditUtilities.Offset(
Workspace,
new Circle(Point.Origin, 2.0, Vector.ZAxis),
new Point(3, 0, 0),
1.0);
Assert.Equal(Point.Origin, circle.Center);
Assert.Equal(3.0, circle.Radius);
}
public void VerticalLineOffsetRightTest()
{
var offset = (Line)EditUtilities.Offset(
Workspace,
new Line(new Point(1, 0, 0), new Point(1, 1, 0)),
new Point(2, 0, 0),
1.0);
Assert.Equal(new Point(2, 0, 0), offset.P1);
Assert.Equal(new Point(2, 1, 0), offset.P2);
}
public void HorizontalLineOffsetDownTest()
{
var offset = (Line)EditUtilities.Offset(
Workspace,
new Line(new Point(0, 1, 0), new Point(1, 1, 0)),
Point.Origin,
1.0);
Assert.Equal(new Point(0, 0, 0), offset.P1);
Assert.Equal(new Point(1, 0, 0), offset.P2);
}
public void OffsetLineFromEndpoint()
{
var scaled = (Line)EditUtilities.Scale(
new Line(new Point(1.0, 1.0, 0.0), new Point(2.0, 2.0, 0.0)),
new Point(1.0, 1.0, 0.0),
2.0
);
Assert.Equal(new Point(1.0, 1.0, 0.0), scaled.P1);
Assert.Equal(new Point(3.0, 3.0, 0.0), scaled.P2);
}
public void DiagonalLineOffsetTest()
{
var offset = (Line)EditUtilities.Offset(
Workspace,
new Line(new Point(0, 1, 0), new Point(1, 2, 0)),
Point.Origin,
1.0);
AssertClose(new Point(0.707106781186547, 0.292893218813453, 0), offset.P1);
AssertClose(new Point(1.707106781186547, 1.292893218813453, 0), offset.P2);
}
public void CircleTtrTest()
{
var ellipse = EditUtilities.Ttr(
Workspace.DrawingPlane,
new SelectedEntity(new Line(Point.Origin, new Point(3, 0, 0)), new Point(1, 0, 0)),
new SelectedEntity(new Line(Point.Origin, new Point(0, 3, 0)), new Point(0, 1, 0)),
1.0);
Assert.Equal(1.0, ellipse.MinorAxisRatio);
Assert.Equal(1.0, ellipse.MajorAxis.Length);
Assert.Equal(new Point(1, 1, 0), ellipse.Center);
Assert.Equal(Workspace.DrawingPlane.Normal, ellipse.Normal);
}
public void CircleOffsetProjectionBug()
{
// enuse we're using the correct projection matrix when verifying
// whether the offset point is inside the circle or not
var offset = (Circle)EditUtilities.Offset(
Workspace,
new Circle(new Point(100, 0, 0), 50, Vector.ZAxis),
new Point(100, 0, 0),
10);
Assert.Equal(new Point(100, 0, 0), offset.Center);
Assert.Equal(40, offset.Radius);
}
public void CircleTtrWithCirclesTest()
{
// from test.dxf
var el = EditUtilities.Ttr(
Workspace.DrawingPlane,
new SelectedEntity(new Circle(new Point(100, 0, 0), 50, Vector.ZAxis), new Point(140, 30, 0)),
new SelectedEntity(new Circle(new Point(100, 100, 0), 50, Vector.ZAxis), new Point(140, 70, 0)),
30.0);
Assert.Equal(1.0, el.MinorAxisRatio);
Assert.Equal(30, el.MajorAxis.Length);
AssertClose(new Point(162.449979983983, 50, 0), el.Center);
Assert.Equal(Workspace.DrawingPlane.Normal, el.Normal);
}
public static Drawing ScaleEntities(this Drawing drawing, IEnumerable <Entity> entities, Point basePoint, double scaleFactor)
{
var result = drawing;
foreach (var e in entities)
{
var layer = result.ContainingLayer(e);
var scaledEntity = EditUtilities.Scale(e, basePoint, scaleFactor);
var updatedLayer = layer.Remove(e).Add(scaledEntity);
result = result.Remove(layer).Add(updatedLayer);
}
return(result);
}
public void CircleOffsetInsideTest()
{
var offset = EditUtilities.Offset(
Workspace,
new Circle(Point.Origin, 2.0, Vector.ZAxis),
Point.Origin,
1.0);
Assert.True(offset is Circle);
var circle = (Circle)offset;
Assert.Equal(Point.Origin, circle.Center);
Assert.Equal(1.0, circle.Radius);
}
public async Task <bool> Execute(IWorkspace workspace, object arg)
{
var entities = await workspace.InputService.GetEntities();
if (entities.Cancel || !entities.HasValue)
{
return(false);
}
if (!entities.Value.Any())
{
return(true);
}
var origin = await workspace.InputService.GetPoint(new UserDirective("Point of rotation"));
if (origin.Cancel || !origin.HasValue)
{
return(false);
}
var angleText = await workspace.InputService.GetText(prompt : "Angle of rotation");
if (angleText.Cancel || !angleText.HasValue)
{
return(false);
}
double angle;
if (double.TryParse(angleText.Value, out angle))
{
var drawing = workspace.Drawing;
foreach (var ent in entities.Value)
{
drawing = drawing.Replace(ent, EditUtilities.Rotate(ent, origin.Value, angle));
}
workspace.Update(drawing: drawing);
return(true);
}
return(false);
}
public void OffsetPointDirectlyOnEntity()
{
// line
var offset = EditUtilities.Offset(
Workspace,
new Line(new Point(-1, 0, 0), new Point(1, 0, 0)),
Point.Origin,
1.0);
Assert.Null(offset);
// circle
offset = EditUtilities.Offset(
Workspace,
new Circle(Point.Origin, 1.0, Vector.ZAxis),
new Point(1.0, 0, 0),
1.0);
Assert.Null(offset);
}
private void DoTrim(IEnumerable <Entity> existingEntities,
Entity entityToTrim,
Point selectionPoint,
bool expectTrim,
IEnumerable <Entity> expectedAdded)
{
expectedAdded = expectedAdded ?? new Entity[0];
// prepare the drawing
foreach (var ent in existingEntities)
{
Workspace.AddToCurrentLayer(ent);
}
var boundary = Workspace.Drawing.GetEntities().SelectMany(e => e.GetPrimitives());
Workspace.AddToCurrentLayer(entityToTrim);
// trim
IEnumerable <Entity> removed;
IEnumerable <Entity> added;
EditUtilities.Trim(
new SelectedEntity(entityToTrim, selectionPoint),
boundary,
out removed,
out added);
// verify deleted
Assert.Equal(expectTrim, removed.Any());
if (expectTrim)
{
Assert.Single(removed);
Assert.True(removed.Single().EquivalentTo(entityToTrim));
}
// verify added
Assert.Equal(expectedAdded.Count(), added.Count());
var expectedText = string.Join("\n ", expectedAdded.Select(e => e.ToString()));
var actualText = string.Join("\n ", added.Select(e => e.ToString()));
Assert.True(expectedAdded.Zip(added, (a, b) => a.EquivalentTo(b)).All(b => b), $"Expected:\n {expectedText}\nActual:\n {actualText}");
}
public async Task <bool> Execute(IWorkspace workspace, object arg)
{
var entities = await workspace.InputService.GetEntities();
if (entities.Cancel || !entities.HasValue)
{
return(false);
}
if (!entities.Value.Any())
{
return(true);
}
var origin = await workspace.InputService.GetPoint(new UserDirective("Point of rotation"));
if (origin.Cancel || !origin.HasValue)
{
return(false);
}
var entityPrimitives = entities.Value.SelectMany(e => e.GetPrimitives()).ToArray();
var angleValue = await workspace.InputService.GetAngleInDegrees("Angle of rotation", onCursorMove : angleInDegrees => entityPrimitives.Select(p => EditUtilities.Rotate(p, origin.Value, angleInDegrees)));
if (angleValue.Cancel || !angleValue.HasValue)
{
return(false);
}
var rotationAngle = angleValue.Value;
var drawing = workspace.Drawing;
foreach (var ent in entities.Value)
{
drawing = drawing.Replace(ent, EditUtilities.Rotate(ent, origin.Value, rotationAngle));
}
workspace.Update(drawing: drawing);
return(true);
}
private void DoExtend(IEnumerable <Entity> existingEntities,
Entity entityToExtend,
Point selectionPoint,
bool expectExtend,
IEnumerable <Entity> expectedAdded)
{
expectedAdded = expectedAdded ?? new Entity[0];
// prepare the drawing
foreach (var ent in existingEntities)
{
Workspace.AddToCurrentLayer(ent);
}
var boundary = Workspace.Drawing.GetEntities().SelectMany(e => e.GetPrimitives());
Workspace.AddToCurrentLayer(entityToExtend);
// extend
IEnumerable <Entity> removed;
IEnumerable <Entity> added;
EditUtilities.Extend(
new SelectedEntity(entityToExtend, selectionPoint),
boundary,
out removed,
out added);
// verify deleted
Assert.Equal(expectExtend, removed.Any());
if (expectExtend)
{
Assert.Equal(1, removed.Count());
Assert.True(removed.Single().EquivalentTo(entityToExtend));
}
// verify added
Assert.Equal(expectedAdded.Count(), added.Count());
Assert.True(expectedAdded.Zip(added, (a, b) => a.EquivalentTo(b)).All(b => b));
}
protected override void DoTrimExtend(SelectedEntity selectedEntity, IEnumerable <Primitives.IPrimitive> boundaryPrimitives, out IEnumerable <Entity> removed, out IEnumerable <Entity> added)
{
EditUtilities.Extend(selectedEntity, boundaryPrimitives, out removed, out added);
}
public async Task <bool> Execute(IWorkspace workspace, object arg)
{
var drawingPlane = workspace.DrawingPlane;
var distance = await workspace.InputService.GetDistance(defaultDistance : lastOffsetDistance);
if (distance.Cancel)
{
return(false);
}
double dist;
if (distance.HasValue)
{
dist = distance.Value;
}
else
{
dist = lastOffsetDistance;
}
workspace.OutputService.WriteLine("Using offset distance of {0}", dist);
lastOffsetDistance = dist;
var selection = await workspace.InputService.GetEntity(new UserDirective("Select entity"));
while (!selection.Cancel && selection.HasValue)
{
var ent = selection.Value.Entity;
if (!EditUtilities.CanOffsetEntity(ent))
{
workspace.OutputService.WriteLine("Unable to offset {0}", ent.Kind);
selection = await workspace.InputService.GetEntity(new UserDirective("Select entity"));
continue;
}
if (!drawingPlane.Contains(ent))
{
workspace.OutputService.WriteLine("Entity must be entirely on the drawing plane to offset");
selection = await workspace.InputService.GetEntity(new UserDirective("Select entity"));
continue;
}
workspace.SelectedEntities.Clear();
workspace.SelectedEntities.Add(ent);
var point = await workspace.InputService.GetPoint(new UserDirective("Side to offset"));
if (point.Cancel || !point.HasValue)
{
break;
}
if (!drawingPlane.Contains(point.Value))
{
workspace.OutputService.WriteLine("Point must be on the drawing plane to offset");
selection = await workspace.InputService.GetEntity(new UserDirective("Select entity"));
continue;
}
// do the actual offset
var updated = EditUtilities.Offset(workspace, ent, point.Value, dist);
if (updated != null)
{
var oldLayer = workspace.Drawing.ContainingLayer(ent);
workspace.Add(oldLayer, updated);
}
workspace.SelectedEntities.Clear();
selection = await workspace.InputService.GetEntity(new UserDirective("Select entity"));
}
return(true);
}
public async Task <bool> Execute(IWorkspace workspace, object arg = null)
{
// get entities
var entities = await workspace.InputService.GetEntities();
if (entities.Cancel || !entities.HasValue)
{
return(false);
}
if (!entities.Value.Any())
{
return(true);
}
// get distance quantum
var distance = await workspace.InputService.GetDistance(new UserDirective("Distance quantum"), defaultDistance : LastDistanceQuantum);
if (distance.Cancel)
{
return(false);
}
double distanceQuantum;
if (distance.HasValue)
{
distanceQuantum = distance.Value;
}
else
{
distanceQuantum = LastDistanceQuantum;
}
LastDistanceQuantum = distanceQuantum;
// get angle quantum
var angle = await workspace.InputService.GetDistance(new UserDirective("Angle quantum"), defaultDistance : LastAngleQuantum);
if (angle.Cancel)
{
return(false);
}
double angleQuantum;
if (angle.HasValue)
{
angleQuantum = angle.Value;
}
else
{
angleQuantum = LastAngleQuantum;
}
LastAngleQuantum = angleQuantum;
// do it
var settings = new QuantizeSettings(distanceQuantum, angleQuantum);
var drawing = workspace.Drawing;
foreach (var entity in entities.Value)
{
var quantized = EditUtilities.Quantize(entity, settings);
var layer = drawing.ContainingLayer(entity);
var originalLayer = layer;
layer = layer.Remove(entity);
layer = layer.Add(quantized);
drawing = drawing.Remove(originalLayer);
drawing = drawing.Add(layer);
}
workspace.Update(drawing: drawing);
return(true);
}
public async Task <bool> Execute(IWorkspace workspace, object arg)
{
Entity circle = null;
var drawingPlane = workspace.DrawingPlane;
var cen = await workspace.InputService.GetPoint(new UserDirective("Select center, [ttr], or [th]ree-point", "ttr", "th"));
if (cen.Cancel)
{
return(false);
}
if (cen.HasValue)
{
var mode = CircleMode.Radius;
while (circle == null)
{
switch (mode)
{
case CircleMode.Radius:
{
var rad = await workspace.InputService.GetPoint(new UserDirective("Enter radius or [d]iameter/[i]sometric", "d", "i"), (p) =>
{
return(new IPrimitive[]
{
new PrimitiveLine(cen.Value, p),
new PrimitiveEllipse(cen.Value, (p - cen.Value).Length, drawingPlane.Normal)
});
});
if (rad.Cancel)
{
return(false);
}
if (rad.HasValue)
{
circle = new Circle(cen.Value, (rad.Value - cen.Value).Length, drawingPlane.Normal);
}
else // switch modes
{
if (rad.Directive == null)
{
return(false);
}
switch (rad.Directive)
{
case "d":
mode = CircleMode.Diameter;
break;
case "i":
mode = CircleMode.Isometric;
break;
}
}
break;
}
case CircleMode.Diameter:
{
var dia = await workspace.InputService.GetPoint(new UserDirective("Enter diameter or [r]adius/[i]sometric", "r", "i"), (p) =>
{
return(new IPrimitive[]
{
new PrimitiveLine(cen.Value, p),
new PrimitiveEllipse(cen.Value, (p - cen.Value).Length, drawingPlane.Normal)
});
});
if (dia.Cancel)
{
return(false);
}
if (dia.HasValue)
{
circle = new Circle(cen.Value, (dia.Value - cen.Value).Length * 0.5, drawingPlane.Normal);
}
else // switch modes
{
if (dia.Directive == null)
{
return(false);
}
switch (dia.Directive)
{
case "r":
mode = CircleMode.Radius;
break;
case "i":
mode = CircleMode.Isometric;
break;
}
}
break;
}
case CircleMode.Isometric:
{
var isoRad = await workspace.InputService.GetPoint(new UserDirective("Enter isometric-radius or [r]adius/[d]iameter", "r", "d"), (p) =>
{
return(new IPrimitive[]
{
new PrimitiveLine(cen.Value, p),
new PrimitiveEllipse(cen.Value,
Vector.SixtyDegrees * (p - cen.Value).Length *MathHelper.SqrtThreeHalves,
drawingPlane.Normal,
IsoMinorRatio,
0.0,
360.0)
});
});
if (isoRad.Cancel)
{
return(false);
}
if (isoRad.HasValue)
{
circle = new Ellipse(cen.Value,
Vector.SixtyDegrees * (isoRad.Value - cen.Value).Length * MathHelper.SqrtThreeHalves,
IsoMinorRatio,
0.0,
360.0,
drawingPlane.Normal);
}
else // switch modes
{
if (isoRad.Directive == null)
{
return(false);
}
switch (isoRad.Directive)
{
case "r":
mode = CircleMode.Radius;
break;
case "d":
mode = CircleMode.Diameter;
break;
}
}
break;
}
}
}
}
else
{
switch (cen.Directive)
{
case "ttr":
var firstEntity = await workspace.InputService.GetEntity(new UserDirective("First entity"));
if (firstEntity.Cancel || !firstEntity.HasValue)
{
break;
}
var secondEntity = await workspace.InputService.GetEntity(new UserDirective("Second entity"));
if (secondEntity.Cancel || !secondEntity.HasValue)
{
break;
}
var radius = await workspace.InputService.GetDistance();
var ellipse = EditUtilities.Ttr(drawingPlane, firstEntity.Value, secondEntity.Value, radius.Value);
if (ellipse != null)
{
circle = ellipse.ToEntity();
}
break;
case "2":
break;
case "th":
var first = await workspace.InputService.GetPoint(new UserDirective("First point"));
if (first.Cancel || !first.HasValue)
{
break;
}
var second = await workspace.InputService.GetPoint(new UserDirective("Second point"), p =>
new[]
{
new PrimitiveLine(first.Value, p)
});
if (second.Cancel || !second.HasValue)
{
break;
}
var third = await workspace.InputService.GetPoint(new UserDirective("Third point"), p =>
{
var c = PrimitiveEllipse.ThreePointCircle(first.Value, second.Value, p);
if (c == null)
{
return new IPrimitive[]
{
new PrimitiveLine(first.Value, second.Value),
new PrimitiveLine(second.Value, p),
new PrimitiveLine(p, first.Value)
}
}
;
else
{
return new IPrimitive[]
{
new PrimitiveLine(first.Value, second.Value),
new PrimitiveLine(second.Value, p),
new PrimitiveLine(p, first.Value),
c
}
};
});
if (third.Cancel || !third.HasValue)
{
break;
}
var circ = PrimitiveEllipse.ThreePointCircle(first.Value, second.Value, third.Value);
if (circ != null)
{
circle = new Circle(circ.Center, circ.MajorAxis.Length, circ.Normal);
}
break;
}
}
if (circle != null)
{
workspace.AddToCurrentLayer(circle);
}
return(true);
}
public async Task <bool> Execute(IWorkspace workspace, object arg)
{
// get all inputs
var selection = await workspace.InputService.GetEntities("Select entities");
if (selection.Cancel || !selection.HasValue)
{
return(false);
}
var entities = selection.Value;
var basePointValue = await workspace.InputService.GetPoint(new UserDirective("Select base point"));
if (basePointValue.Cancel || !basePointValue.HasValue)
{
return(false);
}
var basePoint = basePointValue.Value;
var scaleFactorValue = await workspace.InputService.GetDistance(new UserDirective("Scale factor or [r]eference", "r"));
if (scaleFactorValue.Cancel || (!scaleFactorValue.HasValue && string.IsNullOrEmpty(scaleFactorValue.Directive)))
{
return(false);
}
double scaleFactor;
if (scaleFactorValue.Directive == "r")
{
var firstDistanceValue = await workspace.InputService.GetDistance(new UserDirective("First scale distance"));
if (firstDistanceValue.Cancel ||
!firstDistanceValue.HasValue ||
firstDistanceValue.Value == 0.0)
{
return(false);
}
var entityPrimitives = entities.SelectMany(e => e.GetPrimitives()).ToArray();
var secondDistanceValue = await workspace.InputService.GetDistance(
new UserDirective("Second scale distance"),
onCursorMove : distance =>
{
var scaleFactor = distance / firstDistanceValue.Value;
return(entityPrimitives.Select(p => EditUtilities.Scale(p, basePoint, scaleFactor)));
});
if (secondDistanceValue.Cancel ||
!secondDistanceValue.HasValue ||
secondDistanceValue.Value == 0.0)
{
return(false);
}
scaleFactor = secondDistanceValue.Value / firstDistanceValue.Value;
}
else
{
scaleFactor = scaleFactorValue.Value;
}
// now do it
var drawing = workspace.Drawing.ScaleEntities(entities, basePoint, scaleFactor);
workspace.Update(drawing: drawing);
return(true);
}
private void DoRotate(Entity entityToRotate, Vector origin, double angleInDegrees, Entity expectedResult)
{
var actual = EditUtilities.Rotate(entityToRotate, origin, angleInDegrees);
Assert.True(expectedResult.EquivalentTo(actual));
}
