public override void OnActivate()
{
_pointAdded = false;
var firstShape = NodeBuilderUtils.IdentifySelectedObjectLabel(Document.Root);
if (firstShape == null)
{
ErrorSplineSelected();
return;
}
_function = firstShape.Get <FunctionInterpreter>();
if (_function == null)
{
ErrorSplineSelected();
return;
}
if (_function.Name != FunctionNames.Spline)
{
ErrorSplineSelected();
return;
}
Document.Transact();
_pointAdded = true;
var mouseCursorInput = Inputs[InputNames.MouseCursorInput];
mouseCursorInput.Send(NotificationNames.SetResourceManager, MetaActionResource.ResourceManager);
mouseCursorInput.Send(NotificationNames.SetCursorName, "splineaddpoint.cur");
}
/// <summary>
/// Builds the solver info (magic points and planes) receiving as parameter a shape.
/// </summary>
/// <param name = "solverObject"></param>
/// <param name = "shape"></param>
/// <param name = "parallelPrecision"></param>
/// <param name = "computeParallelism"></param>
public static void BuildSolverInfo(SolverGeometricObject solverObject, Node shape,
double parallelPrecision, bool computeParallelism)
{
var solidShape = ShapeUtils.ExtractShape(solverObject.Parent);
// Build a list with the magic points made by the vertexes
BuildPointList(shape, solverObject);
var functionName = shape.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name;
if (functionName == FunctionNames.LineTwoPoints || functionName == FunctionNames.Arc ||
functionName == FunctionNames.Arc3P || functionName == FunctionNames.Circle ||
functionName == FunctionNames.Ellipse)
{
// Build a list with the edges
BuildEdgeList(solidShape, solverObject);
}
// Build a list with the magic points made by the faces/surfaces
BuildFaceList(solidShape, solverObject);
// Build a list with parallel axis
if (!computeParallelism)
{
return;
}
if (NodeBuilderUtils.NodeIsOnSketch(new NodeBuilder(shape)))
{
BuildParallelAxisList(solidShape, solverObject, parallelPrecision);
}
}
private void GetRotateValue(ref object resultvalue)
{
var nb = new NodeBuilder(Parent);
if (nb.FunctionName != FunctionNames.Sketch)
{
return;
}
var interpreter = Parent.Get <TransformationInterpreter>();
if (interpreter == null)
{
return;
}
var transformations = NodeBuilderUtils.GetTransformations(nb);
var multiplied = new gpTrsf();
foreach (var trsf in transformations)
{
multiplied = multiplied.Multiplied(trsf);
}
var matr = multiplied.VectorialPart;
// extract rotation from matrix
}
private void ProposeSelectedReferenceShape(TopoDSShape face, Mouse3DPosition mouseData)
{
SceneSelectedEntity selectedNode = null;
if (face != null)
{
selectedNode = GeomUtils.IdentifyNode(Document.Root, face);
if (selectedNode == null)
{
return;
}
}
else
{
var node = NodeBuilderUtils.IdentifySelectedObjectLabel(Document.Root);
if (node != null)
{
selectedNode = new SceneSelectedEntity(node);
}
}
if (selectedNode == null)
{
return;
}
if (_axisBuilder.Node != null && selectedNode.Node.Index == _axisBuilder.Node.Index)
{
SetWorkingPlane();
_dragging = true;
_startDragPos = mouseData.Point;
return;
}
// The scene selected entity is hold as reference
Propose(selectedNode);
}
private void SetLength(object data)
{
if (Builder[0].ReferenceBuilder.FunctionName == FunctionNames.Circle)
{
BeginUpdate();
var nb = new NodeBuilder(Builder[0].ReferenceBuilder.Node);
nb[1].Real = (double)data / 2;
nb.ExecuteFunction();
EndVisualUpdate("Updated radius");
}
if (Builder[0].ReferenceBuilder.FunctionName != FunctionNames.LineTwoPoints)
{
return;
}
BeginUpdate();
TreeUtils.SetLineLength(Builder[0].ReferenceBuilder.Node, (double)data);
var document = _viewInfo.Document;
var constraint = NodeBuilderUtils.ShapeHasConstraint(Builder[0].ReferenceBuilder.Node, Constraint2DNames.LineLengthFunction, document);
if (constraint != -1)
{
var nb = new NodeBuilder(document.Root[constraint]);
nb.Dependency[2].Real = (double)data;
nb.ExecuteFunction();
}
CallSolverForLineChanges(Builder[0].ReferenceBuilder.Node);
EndVisualUpdate("Updated Length");
}
public void DeleteCircleTest()
{
var document = TestUtils.DefaultsSetup();
document.Transact();
var sketchCreator = new SketchCreator(document, false);
var sketchNode = sketchCreator.BuildSketchNode();
var pointBuilder = new NodeBuilder(document, FunctionNames.Point);
pointBuilder[0].Reference = sketchNode;
pointBuilder[1].TransformedPoint3D = new Point3D();
pointBuilder.ExecuteFunction();
var circleBuilder = new NodeBuilder(document, FunctionNames.Circle);
circleBuilder[0].Reference = pointBuilder.Node;
circleBuilder[1].Real = 20;
circleBuilder.ExecuteFunction();
//document.Commit("Draw first circle");
var nodeToDelete = document.Root[2];
NodeBuilderUtils.DeleteNode(nodeToDelete, document);
document.Commit("Deleted");
Assert.AreEqual(1, document.Root.Children.Count, "Circle is not deleted");
Assert.AreEqual(FunctionNames.Sketch, document.Root[0].Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name);
}
private void SetInternalRadius(object data)
{
BeginUpdate();
Builder[1].Real = (double)data;
NodeBuilderUtils.UpdateSketchesOnFaces(new NodeBuilder(Parent));
EndVisualUpdate("Fillet 2D radius changed");
}
private void BuildAndEnterSketch(Document document)
{
var sketchCreator = new SketchCreator(document);
var currentSketch = sketchCreator.CurrentSketch;
var sketchNodeBuilder = new NodeBuilder(currentSketch);
Document.Transact();
Log.InfoFormat("StartSketch - Command line input");
var firstvector = new gpDir(Points[1].GpPnt.X - Points[0].GpPnt.X, Points[1].GpPnt.Y - Points[0].GpPnt.Y, Points[1].GpPnt.Z - Points[0].GpPnt.Z);
var secondvector = new gpDir(Points[2].GpPnt.X - Points[0].GpPnt.X, Points[2].GpPnt.Y - Points[0].GpPnt.Y, Points[2].GpPnt.Z - Points[0].GpPnt.Z);
var normal = firstvector.Crossed(secondvector);
var _normalOnPlane = new gpAx1(Points[0].GpPnt, normal);
var sketchAx2 = new gpAx2();
sketchAx2.Axis = (_normalOnPlane);
var plane = new gpPln(new gpAx3(sketchAx2));
Inputs[InputNames.Mouse3DEventsPipe].Send(NotificationNames.SetPlane, plane);
sketchNodeBuilder[0].Axis3D = new Axis(sketchNodeBuilder[0].Axis3D.Location, new Point3D(new gpPnt(_normalOnPlane.Direction.XYZ)));
HighlightCurrentSketchNodes(sketchNodeBuilder.Node);
NodeBuilderUtils.HidePlanes(Document);
Document.Commit("sketch created");
AddNodeToTree(sketchNodeBuilder.Node);
Document.Transact();
Document.Root.Get <DocumentContextInterpreter>().ActiveSketch = sketchNodeBuilder.Node.Index;
_sketchButton.Block();
Document.Commit("Started editing sketch");
}
private void SetTranslateValue(object data)
{
var nodeBuilder = new NodeBuilder(Parent);
var _3dShapesFunctions = new List <string>();
_3dShapesFunctions.AddRange(new[] { FunctionNames.Sphere, FunctionNames.Box, FunctionNames.Cylinder,
FunctionNames.Torus, FunctionNames.Cone, FunctionNames.Boolean });
if (_3dShapesFunctions.Contains(nodeBuilder.FunctionName))
{
NodeUtils.TranslateSolids(nodeBuilder, (Point3D)data);
return;
}
var sketchNode = NodeBuilderUtils.FindBaseSketchNode(Parent);
var document = sketchNode.Root.Get <DocumentContextInterpreter>().Document;
var newPoint = (Point3D)data;
document.Transact();
if (NodeUtils.NodeIsOnSketch(nodeBuilder))
{
NodeUtils.TranslateSketchNode(nodeBuilder, newPoint, sketchNode);
}
else
{
NodeUtils.Translate3DNode(nodeBuilder, document, newPoint);
}
document.Commit("Translated");
EndVisualUpdate("Translate object");
}
protected override void OnMouseDownAction(Mouse3DPosition mouseData)
{
if (Points.Count == 0)
{
Points.Add(mouseData.Point);
_firstCoordinateSet = true;
Points.Add(new Point3D());
return;
}
if (Points.Count == 2)
{
InitSession();
var sketchCreator = new SketchCreator(Document);
var normalOnPlane = sketchCreator.NormalOnSketch.Value.GpAxis;
var builder = NodeBuilderUtils.BuildLineInDocument(Document, false, normalOnPlane, Points[0], Points[1]);
NodeBuilderUtils.BuildDimensionForLine(Document, builder, Points[0], Points[1]);
UpdateView();
Points.Clear();
AddNodeToTree(builder.Node);
RebuildTreeView();
Document.Commit("Added Dimension");
}
}
protected void UpdateLineLock()
{
BeginUpdate();
var constraint = NodeBuilderUtils.ShapeHasConstraint(Parent, Constraint2DNames.LineLengthFunction, _viewInfo.Document);
if (constraint != -1)
{
_viewInfo.Document.Root.Remove(constraint);
// remove dimension
var dimensionNodeIndex = 0;
foreach (var child in _viewInfo.Document.Root.Children)
{
if (child.Value.Get <FunctionInterpreter>().Name == FunctionNames.Dimension)
{
if (child.Value.Children[1].Get <ReferenceInterpreter>().Node.Index == Parent.Index)
{
dimensionNodeIndex = child.Value.Index;
break;
}
}
}
if (dimensionNodeIndex != 0)
{
_viewInfo.Document.Root.Remove(dimensionNodeIndex);
}
}
else
{
NodeBuilderUtils.AddLengthAndDimensionConstraint(_viewInfo.Document, Parent, true);
}
EndVisualUpdate("Update constraint");
}
private void RemoveButtonClick(object sender, EventArgs e)
{
var constraintDesc = (ConstraintListItem)listConstraints.SelectedItem;
NodeBuilderUtils.DeleteNode(constraintDesc.Builder.Node, _document);
RefreshList();
}
public void CutDeleteBaseTest2()
{
var document = TestUtils.DefaultsSetup();
var sketchCreator = new SketchCreator(document, false);
var sketchNode = sketchCreator.BuildSketchNode();
document.Transact();
var circleBuilder = TestUtils.Circle(document, sketchNode, new Point3D(0, 0, 0), 10);
TestUtils.Circle(document, sketchNode, new Point3D(20, 20, 0), 10);
Assert.AreEqual(circleBuilder.LastExecute, true);
sketchNode.Children[2].Set <MeshTopoShapeInterpreter>().Shape = AutoGroupLogic.RebuildSketchFace(sketchNode, document);
var extrudeBuilder = new NodeBuilder(document, FunctionNames.Extrude);
extrudeBuilder[0].Reference = sketchNode;
extrudeBuilder[1].Integer = 0;
extrudeBuilder[2].Real = 10;
extrudeBuilder.ExecuteFunction();
Assert.AreEqual(extrudeBuilder.LastExecute, true);
document.Commit("Extrude created");
document.Transact();
var volume = GeomUtils.GetSolidVolume(extrudeBuilder.Shape);
Assert.AreEqual(volume, 2 * Math.PI * 1000);
Assert.AreEqual(document.Root.Children.Count, 6);
var sketchNode2 = sketchCreator.BuildSketchNode();
document.Commit("Second sketch created");
document.Transact();
TestUtils.Circle(document, sketchNode2, new Point3D(0, 0, 0), 5);
sketchNode2.Children[2].Set <MeshTopoShapeInterpreter>().Shape = AutoGroupLogic.RebuildSketchFace(sketchNode2, document);
var cutBuilder = new NodeBuilder(document, FunctionNames.Cut);
cutBuilder[0].Reference = sketchNode2;
cutBuilder[2].Integer = (int)ExtrusionTypes.MidPlane;
cutBuilder[1].Real = 10000;
cutBuilder.ExecuteFunction();
Assert.AreEqual(cutBuilder.LastExecute, true);
volume = GeomUtils.GetSolidVolume(cutBuilder.Shape);
Assert.AreEqual(volume, 2 * Math.PI * 1000 - Math.PI * 250);
Assert.AreEqual(document.Root.Children.Count, 10);
var nodeToDelete = document.Root[2];
NodeBuilderUtils.DeleteNode(nodeToDelete, document);
document.Commit("Deleted");
document.Transact();
NodeUtils.RebuildAllSketchFaces(document);
extrudeBuilder.ExecuteFunction();
cutBuilder.ExecuteFunction();
document.Commit("Finished");
Assert.IsTrue(cutBuilder.LastExecute);
volume = GeomUtils.GetSolidVolume(cutBuilder.Shape);
Assert.AreEqual(8, document.Root.Children.Count, "Circle is not deleted");
Assert.AreEqual(volume, Math.PI * 1000);
}
/// <summary>
/// Creates a fused face (FaceFuse node) with all the coliding shapes
/// </summary>
/// <param name="colidingShapes"></param>
private static void CreateFusedShape(List <Node> colidingShapes, Document _document)
{
var builder = new NodeBuilder(_document, FunctionNames.FaceFuse);
var colidingList = new List <SceneSelectedEntity>();
foreach (var node in colidingShapes)
{
colidingList.Add(new SceneSelectedEntity(node));
}
builder.Dependency[0].ReferenceList = colidingList;
bool result = builder.ExecuteFunction();
if (result == false)
{
NodeBuilderUtils.DeleteNode(builder.Node, _document);
_nodeFused = null;
}
else
{
_nodeFused = builder.Node;
}
// The fused face is not visible in the scene, neither in the tree view
if (_nodeFused != null)
{
Hide(_nodeFused);
_nodeFused.Set <TreeViewVisibilityInterpreter>();
}
}
private void MouseDownHandler(Mouse3DPosition mouseData)
{
if (_currentHandler == null)
{
return;
}
_currentHandler.previousMousePosition = mouseData.Point.GpPnt;
_currentHandler.startX = mouseData.Initial2Dx;
_currentHandler.startY = mouseData.Initial2Dy;
var selectedNodes = NodeBuilderUtils.IdentifyShapesUnderMouse(_editingDocument.Root, mouseData.Initial2Dx,
mouseData.Initial2Dy, ViewInfo.View);
if (selectedNodes.Count <= 0 && (_currentHandler.SelectedEntity == null || _currentHandler.SelectedEntity.Node == null))
{
return;
}
if (selectedNodes.Count > 0)
{
_currentHandler.StartDragging(selectedNodes[0]);
}
else
{
_currentHandler.StartDragging(_currentHandler.SelectedEntity);
}
var pusherInput = ActionsGraph[InputNames.CommandLinePrePusher];
pusherInput.Send(NotificationNames.Reset);
pusherInput.Send(NotificationNames.PushValue, _currentHandler);
pusherInput.Send(NotificationNames.PushValue, _editingDocument);
_editingDocument.Transact();
ViewInfo.SwitchAction(ModifierNames.HandleDragging);
}
public static void TranslateSketchNode(NodeBuilder nodeBuilder, Point3D translateValue, Node sketchNode)//, gpTrsf translation)
{
if (nodeBuilder.FunctionName == FunctionNames.Point)
{
gpTrsf translation = new gpTrsf();
var sketchAxisLocation = NodeBuilderUtils.GetTransformedAxis(new NodeBuilder(sketchNode)).Location;
var newValue = new Point3D(sketchAxisLocation.X + translateValue.X, sketchAxisLocation.Y + translateValue.Y,
sketchAxisLocation.Z + translateValue.Z);
translation.SetTranslation(sketchAxisLocation, newValue.GpPnt);
nodeBuilder.Node.Set <TransformationInterpreter>().CurrTransform = translation;
nodeBuilder.ExecuteFunction();
}
else
{
var affectedPoints = GetPointNodes(nodeBuilder.Node);
if (affectedPoints == null)
{
return;
}
var sketchAxisLocation = NodeBuilderUtils.GetTransformedAxis(new NodeBuilder(sketchNode)).Location;
foreach (var point in affectedPoints)
{
var nb = new NodeBuilder(point);
var oldValue = nb[1].TransformedPoint3D;
var newValue = new Point3D(oldValue.X + translateValue.X, oldValue.Y + translateValue.Y,
oldValue.Z + translateValue.Z);
var translation = new gpTrsf();
translation.SetTranslation(sketchAxisLocation, newValue.GpPnt);
nb.Node.Set <TransformationInterpreter>().CurrTransform = translation;
nb.ExecuteFunction();
}
}
}
public override bool Execute()
{
var nodes = NodeBuilderUtils.CopyPaste(Dependency[0].ReferenceBuilder.Node);
var nb = new NodeBuilder(Dependency[1].ReferenceBuilder.Node);
var sketchNodes = new List <Node>();
foreach (var point in nodes)
{
var transformation = point.Set <TransformationInterpreter>();
transformation.CurrTransform.SetMirror(nb.Dependency[1].TransformedPoint3D.GpPnt);
var node = NodeBuilderUtils.FindSketchNode(point);
if (node != null)
{
sketchNodes.Add(node);
}
var nb1 = new NodeBuilder(point);
nb1.ExecuteFunction();
}
if (sketchNodes.Count > 0)
{
var document = sketchNodes[0].Root.Get <DocumentContextInterpreter>().Document;
foreach (var sketchNode in sketchNodes)
{
int shapeIndex = 0;
if (NodeUtils.SketchHas3DApplied(document, sketchNode, out shapeIndex))
{
sketchNode.Children[2].Set <MeshTopoShapeInterpreter>().Shape = AutoGroupLogic.RebuildSketchFace(sketchNode, document);
}
}
}
return(true);
}
protected override void PreviewFillet()
{
InitSession();
bool result;
bool linesChamfer = _filletNodes[0].Node.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name == FunctionNames.LineTwoPoints &&
_filletNodes[1].Node.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name == FunctionNames.LineTwoPoints;
if (!linesChamfer)
{
Builder = new NodeBuilder(Document, FunctionNames.Fillet2D);
Builder[0].ReferenceList = SelectedShapes;
Builder[1].Real = SizeWindow.Value;
Builder[2].Integer = (int)FilletChamferTypes.SimpleChamfer2D;
result = Builder.ExecuteFunction();
SizeWindow.FailedValue = !result;
}
else
{
result = NodeBuilderUtils.BuildChamfer(_filletNodes[0], _filletNodes[1], AnimationDocument, Document, SizeWindow.Value);
AnimationDocument.Revert();
}
if (!result)
{
InitSession();
}
Send(InputNames.View, NotificationNames.RefreshView);
}
public void DeleteLineTest()
{
var document = TestUtils.DefaultsSetup();
document.Transact();
var sketchCreator = new SketchCreator(document, false);
var sketchNode = sketchCreator.BuildSketchNode();
var pointBuilder = new NodeBuilder(document, FunctionNames.Point);
pointBuilder[0].Reference = sketchNode;
pointBuilder[1].TransformedPoint3D = new Point3D();
var pointBuilder2 = new NodeBuilder(document, FunctionNames.Point);
pointBuilder2[0].Reference = sketchNode;
pointBuilder2[1].TransformedPoint3D = new Point3D(1, 1, 0);
pointBuilder.ExecuteFunction();
var lineBuilder = new NodeBuilder(document, FunctionNames.LineTwoPoints);
lineBuilder[0].Reference = pointBuilder.Node;
lineBuilder[1].Reference = pointBuilder2.Node;
lineBuilder.ExecuteFunction();
var nodeToDelete = document.Root[3];
NodeBuilderUtils.DeleteNode(nodeToDelete, document);
document.Commit("Deleted");
Assert.AreEqual(1, document.Root.Children.Count, "Line is not deleted");
Assert.AreEqual(FunctionNames.Sketch, document.Root[0].Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name);
}
private void SetRotateValue(object data)
{
BeginUpdate();
var nodeBuilder = new NodeBuilder(Parent);
var mouseRotation = TransformationInterpreter.GetRotateTrsf((Point3D)data);
var sketchNode = NodeBuilderUtils.FindBaseSketchNode(Parent);
var document = sketchNode.Root.Get <DocumentContextInterpreter>().Document;
if (!NodeUtils.NodeIsOnSketch(nodeBuilder))
{
var list = NodeBuilderUtils.GetAllContained3DNodesIndexes(nodeBuilder.Node).Distinct().ToList();
var sketchNodes = new List <Node>();
foreach (var nodeIndex in list)
{
var node = document.Root[nodeIndex.Key];
var shapeNodeBuilder = new NodeBuilder(node);
if (FunctionNames.GetSolids().Contains(nodeBuilder.FunctionName))
{
continue;
}
var affectedSketchNode = shapeNodeBuilder.Dependency[0].ReferenceBuilder.Node;
if (affectedSketchNode != null)
{
var nb1 = new NodeBuilder(affectedSketchNode);
if (nb1.Dependency[2].Reference == null)
{
sketchNodes.Add(affectedSketchNode);
}
}
}
document.Transact();
foreach (var solid in sketchNodes)
{
var nb = new NodeBuilder(solid);
var trsfCurrent = nb.Node.Get <TransformationInterpreter>().CurrTransform;
trsfCurrent = trsfCurrent.Multiplied(mouseRotation);
// we need to invert the transformation to make it positive for the x-axis
trsfCurrent = trsfCurrent.Inverted;
var transformationInfo = new TransformationInfo
{
SketchIndex = solid.Index,
Transformation = mouseRotation,
TrsfIndex = TransformationInfo.maxTrsfIndex,
RefSketchIndex = -2
};
TransformationInfo.maxTrsfIndex++;
TransformationInterpreter.Transformations.Add(transformationInfo);
nb.Node.Set <TransformationInterpreter>().CurrTransform = trsfCurrent;
nb.ExecuteFunction();
}
document.Commit("Rotated");
}
EndVisualUpdate("Rotate object");
}
public void SetArcInternalAngleBothPositiveTest()
{
var sketchCreator = new SketchCreator(_document, false);
var sketchNode = sketchCreator.BuildSketchNode();
_document.Transact();
// s >0, e > 0, s > e
var arcBuilder = TestUtils.Arc(_document, sketchNode, new Point3D(4, 0, 0), new Point3D(0.535898, 2, 0),
new Point3D(7.464101, 2, 0));
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetInternalAngle(arcBuilder) - 240) < 0.00001, "Incorrect internal angle");
var endPoint = NodeBuilderUtils.SetInternalAngle(arcBuilder, 300);
Assert.IsTrue(Math.Abs(endPoint.X - 4) < 0.00001);
Assert.IsTrue(Math.Abs(endPoint.Y - 4) < 0.00001);
arcBuilder = TestUtils.Arc(_document, sketchNode, new Point3D(4, 0, 0), new Point3D(0.535898, 2, 0),
new Point3D(7.464101, 2, 0));
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetInternalAngle(arcBuilder) - 240) < 0.00001, "Incorrect internal angle");
endPoint = NodeBuilderUtils.SetInternalAngle(arcBuilder, 180);
Assert.IsTrue(Math.Abs(endPoint.X - 7.464101) < 0.00001);
Assert.IsTrue(Math.Abs(endPoint.Y + 2) < 0.00001);
arcBuilder = TestUtils.Arc(_document, sketchNode, new Point3D(4, 0, 0), new Point3D(4, 4, 0),
new Point3D(7.464101, 2, 0));
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetInternalAngle(arcBuilder) - 300) < 0.00001, "Incorrect internal angle");
endPoint = NodeBuilderUtils.SetInternalAngle(arcBuilder, 60);
Assert.IsTrue(Math.Abs(endPoint.X - 0.535898) < 0.00001);
Assert.IsTrue(Math.Abs(endPoint.Y - 2) < 0.00001);
// s >0, e > 0, s < e
arcBuilder = TestUtils.Arc(_document, sketchNode, new Point3D(4, 0, 0), new Point3D(7.464101, 2, 0), new Point3D(0.535898, 2, 0));
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetInternalAngle(arcBuilder) - 120) < 0.00001, "Incorrect internal angle");
endPoint = NodeBuilderUtils.SetInternalAngle(arcBuilder, 60);
Assert.IsTrue(Math.Abs(endPoint.X - 4) < 0.00001);
Assert.IsTrue(Math.Abs(endPoint.Y - 4) < 0.00001);
arcBuilder = TestUtils.Arc(_document, sketchNode, new Point3D(4, 0, 0), new Point3D(7.464101, 2, 0), new Point3D(0.535898, 2, 0));
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetInternalAngle(arcBuilder) - 120) < 0.00001, "Incorrect internal angle");
endPoint = NodeBuilderUtils.SetInternalAngle(arcBuilder, 180);
Assert.IsTrue(Math.Abs(endPoint.X - 0.535898) < 0.00001);
Assert.IsTrue(Math.Abs(endPoint.Y + 2) < 0.00001);
arcBuilder = TestUtils.Arc(_document, sketchNode, new Point3D(4, 0, 0), new Point3D(4, 4, 0), new Point3D(0.535898, 2, 0));
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetInternalAngle(arcBuilder) - 60) < 0.00001, "Incorrect internal angle");
endPoint = NodeBuilderUtils.SetInternalAngle(arcBuilder, 300);
Assert.IsTrue(Math.Abs(endPoint.X - 7.464101) < 0.00001);
Assert.IsTrue(Math.Abs(endPoint.Y - 2) < 0.00001);
}
public override bool Execute()
{
var axis = NodeBuilderUtils.GetTransformedAxis(Dependency[0].ReferenceBuilder);
var zoomLevel = CoreGlobalPreferencesSingleton.Instance.ZoomLevel;
Shape = OccShapeCreatorCode.CreateCircle(axis, zoomLevel);
return(true);
}
private void PreviewLine()
{
InitSession();
var builder = NodeBuilderUtils.BuildLineInDocument(Document, false, normalOnPlane, Points[0], Points[1]);
PreviewLineInDocument(Document, Points[0], Points[1]);
NodeBuilderUtils.BuildDimensionForLine(Document, builder, Points[0], Points[1]);
}
private void SetInternalRadius(object data)
{
BeginUpdate();
Builder[2].Real = (double)data;
NodeBuilderUtils.UpdateSketchesOnFaces(Builder);
EndVisualUpdate("Extrude depth changed");
}
private void OnSetLengthValueHandler(object data)
{
BeginUpdate();
TreeUtils.SetLineLength(Parent, (double)data);
CallSolverForLineChanges(Parent);
NodeBuilderUtils.UpdateSketchesOnFaces(new NodeBuilder(Parent));
EndVisualUpdate("Updated length");
}
public void GetArcAnglesTest()
{
var sketchCreator = new SketchCreator(_document, false);
var sketchNode = sketchCreator.BuildSketchNode();
_document.Transact();
var arcBuilder = TestUtils.Arc(_document, sketchNode, new Point3D(4, 3, 0), new Point3D(8, 3, 0),
new Point3D(4, 7, 0));
Assert.AreEqual(NodeBuilderUtils.GetStartAngle(arcBuilder), 0);
Assert.AreEqual(NodeBuilderUtils.GetEndAngle(arcBuilder), 90);
Assert.AreEqual(NodeBuilderUtils.GetInternalAngle(arcBuilder), 90);
// s >0, e > 0, s < e
arcBuilder = TestUtils.Arc(_document, sketchNode, new Point3D(4, 0, 0), new Point3D(7.464101, 2, 0),
new Point3D(0.535898, 2, 0));
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetStartAngle(arcBuilder) - 30) < 0.00001, "Incorrect start angle");
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetEndAngle(arcBuilder) - 150) < 0.00001, "Incorrect end angle");
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetInternalAngle(arcBuilder) - 120) < 0.00001, "Incorrect internal angle");
// s >0, e > 0, s > e
arcBuilder = TestUtils.Arc(_document, sketchNode, new Point3D(4, 0, 0), new Point3D(0.535898, 2, 0), new Point3D(7.464101, 2, 0));
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetStartAngle(arcBuilder) - 150) < 0.00001, "Incorrect start angle");
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetEndAngle(arcBuilder) - 30) < 0.00001, "Incorrect end angle");
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetInternalAngle(arcBuilder) - 240) < 0.00001, "Incorrect internal angle");
// s < 0, e < 0, s > e
arcBuilder = TestUtils.Arc(_document, sketchNode, new Point3D(4, 0, 0), new Point3D(7.464101, -2, 0),
new Point3D(0.535898, -2, 0));
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetStartAngle(arcBuilder) + 30) < 0.00001, "Incorrect start angle");
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetEndAngle(arcBuilder) + 150) < 0.00001, "Incorrect end angle");
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetInternalAngle(arcBuilder) - 240) < 0.00001, "Incorrect internal angle");
// s < 0, e < 0, s < e
arcBuilder = TestUtils.Arc(_document, sketchNode, new Point3D(4, 0, 0), new Point3D(0.535898, -2, 0), new Point3D(7.464101, -2, 0));
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetStartAngle(arcBuilder) + 150) < 0.00001, "Incorrect start angle");
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetEndAngle(arcBuilder) + 30) < 0.00001, "Incorrect end angle");
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetInternalAngle(arcBuilder) - 120) < 0.00001, "Incorrect internal angle");
// s > 0, e < 0
arcBuilder = TestUtils.Arc(_document, sketchNode, new Point3D(4, 0, 0), new Point3D(7.464101, 2, 0),
new Point3D(7.464101, -2, 0));
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetStartAngle(arcBuilder) - 30) < 0.00001, "Incorrect start angle");
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetEndAngle(arcBuilder) + 30) < 0.00001, "Incorrect end angle");
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetInternalAngle(arcBuilder) - 300) < 0.00001, "Incorrect internal angle");
// s < 0, e > 0
arcBuilder = TestUtils.Arc(_document, sketchNode, new Point3D(4, 0, 0), new Point3D(7.464101, -2, 0), new Point3D(7.464101, 2, 0));
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetStartAngle(arcBuilder) + 30) < 0.00001, "Incorrect start angle");
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetEndAngle(arcBuilder) - 30) < 0.00001, "Incorrect end angle");
Assert.IsTrue(Math.Abs(NodeBuilderUtils.GetInternalAngle(arcBuilder) - 60) < 0.00001, "Incorrect internal angle");
}
private void AddNewPoint(Point3D coordinate)
{
if (Points.Count == 2 && Points[0].IsEqual(coordinate))
{
return;
}
SetCoordinate(coordinate);
AddNewEmptyPoint();
if (Points.Count <= 2)
{
return;
}
var builder = BuildLine();
AddNodeToTree(builder.Node);
Hinter2D.SetOrigin(builder[0].RefTransformedPoint3D);
Hinter2D.Populate();
Hinter2D.ApplyAlgorithms(new NodeBuilder(builder[0].Reference));
Hinter2D.ApplyAlgorithms(new NodeBuilder(builder[1].Reference));
var axis = NodeBuilderUtils.GetTransformedAxis(new NodeBuilder(sketchNode));
var result = Hinter2D.ApplyAlgorithms(builder);
var constraints = new List <NodeBuilder>();
foreach (var res in result)
{
constraints.AddRange(res.constraintNodes);
}
foreach (var constraint in constraints)
{
if (constraint.FunctionName == Constraint2DNames.ParallelFunction || constraint.FunctionName == Constraint2DNames.PerpendicularFunction)
{
var secondNode = constraint.Dependency[0].Reference.Index == builder.Node.Index ? constraint.Dependency[1].Reference : constraint.Dependency[0].Reference;
NodeBuilderUtils.AdddHintsForNode(Document, secondNode, constraint.Node, axis);
}
}
var sseList = constraints.Select(c => new SceneSelectedEntity(c.Node)).ToList();
var newNode = new NodeBuilder(Document, FunctionNames.LineHints);
newNode[0].Reference = builder.Node;
newNode[1].ReferenceList = sseList;
newNode[2].Axis3D = new Axis(axis);
newNode.Color = Color.Black;
newNode.Node.Set <TransformationInterpreter>().Translate = new gpPnt();
if (!newNode.ExecuteFunction())
{
Document.Root.Remove(newNode.Node.Index);
}
CommitFinal("Added line to scene");
UpdateView();
Reset();
Inputs[InputNames.UiElementsItem].Send(NotificationNames.SelectNode, builder.Node);
}
private void SetMinorRadius(object data)
{
BeginUpdate();
var previousMajor = GetPreviousMajorRadius();
SetRadius(previousMajor, (double)data);
NodeBuilderUtils.UpdateSketchesOnFaces(new NodeBuilder(Parent));
EndUpdate(PropertyDescriptorsResources.EllipseTab_Set_minor_radius);
}
private void SetInternalAngleValue(object data)
{
if (Builder.Node.Children.Count == 0)
return;
BeginUpdate();
var angle = (double)data;
Builder[2].RefTransformedPoint3D = NodeBuilderUtils.SetInternalAngle(Builder, angle);
EndVisualUpdate("");
}
public override void OnActivate()
{
Reset();
_selectedNode = NodeBuilderUtils.IdentifySelectedObjectLabel(Document.Root);
if (_selectedNode == null)
{
BackToNeutralModifier();
}
}
