private void ApplyCut()
{
var cutType = cutBuilder[2].Integer;
var cutDepth = cutBuilder[1].Real;
Document.Transact();
var sketchNode = AutoGroupLogic.FindSketchNode(_selectedNode.Node);
// Apply Cut on it
cutBuilder = new NodeBuilder(TreeUtils.Cut(Document, sketchNode, cutDepth, cutType == 0? CutTypes.ToDepth:CutTypes.ThroughAll));
if (cutBuilder == null)
{
Document.Revert();
}
else
{
cutBuilder.ExecuteFunction();
NodeUtils.SetSketchTransparency(Document, sketchNode, ObjectVisibility.Hidden);
// Commit
Document.Commit("Apply Cut");
UpdateView();
AddNodeToTree(cutBuilder.Node);
ResetWorkingPlane();
}
Inputs[InputNames.FacePickerPlane].Send(NotificationNames.Resume);
BackToNeutralModifier();
//Inputs[InputNames.FacePickerPlane].Send(NotificationNames.Resume);
}
public static List <Node> GetVisibleSketchNodes(Document document)
{
var results = new List <Node>();
var visibleNodes = new List <Node>();
var root = document.Root;
var found = true;
while (found)
{
found = false;
results.AddRange(from node in root.ChildrenList
let builder = new NodeBuilder(node)
where FunctionNames.GetSketchShapes().Contains(builder.FunctionName)
select node);
}
var sketchNodes = new Dictionary <Node, bool>();
foreach (var node in results)
{
var sketchNode = AutoGroupLogic.FindSketchNode(node);
if (!sketchNodes.ContainsKey(sketchNode))
{
int index;
sketchNodes.Add(sketchNode, SketchHas3DApplied(document, sketchNode, out index));
}
if (!sketchNodes[sketchNode])
{
visibleNodes.Add(node);
}
}
return(visibleNodes);
}
public static void AddRectangleToNode(Document document, int point1, int point2)
{
if (!document.Root.Children.ContainsKey(point1) || !document.Root.Children.ContainsKey(point2))
{
return;
}
var sketchNode = AutoGroupLogic.FindSketchNode(document.Root[point1]);
var axis = new gpAx2();
axis.Axis = (sketchNode.Children[1].Get <Axis3DInterpreter>().Axis.GpAxis);
var pointLinker = new SketchCreator(document).PointLinker;
var point3Ds = new List <Point3D>();
var nb1 = new NodeBuilder(document.Root[point1]);
var nb2 = new NodeBuilder(document.Root[point2]);
var _firstPoint = nb1.Dependency[1].TransformedPoint3D;
var _secondPoint = nb2.Dependency[1].TransformedPoint3D;
var firstPoint2D = _firstPoint.ToPoint2D(axis);
var secondPoint2D = _secondPoint.ToPoint2D(axis);
var x1 = firstPoint2D.X;
var y1 = firstPoint2D.Y;
var x2 = secondPoint2D.X;
var y2 = secondPoint2D.Y;
point3Ds.Add(GeomUtils.Point2DTo3D(axis, x1, y1));
point3Ds.Add(GeomUtils.Point2DTo3D(axis, x2, y1));
point3Ds.Add(GeomUtils.Point2DTo3D(axis, x2, y2));
point3Ds.Add(GeomUtils.Point2DTo3D(axis, x1, y2));
document.Root.Remove(nb1.Node.Index);
document.Root.Remove(nb2.Node.Index);
BuildLine(document, pointLinker, point3Ds[0], point3Ds[1]);
BuildLine(document, pointLinker, point3Ds[1], point3Ds[2]);
BuildLine(document, pointLinker, point3Ds[2], point3Ds[3]);
BuildLine(document, pointLinker, point3Ds[3], point3Ds[0]);
}
public override void UpdatePointPosition(int index, Mouse3DPosition vertex)
{
var nodeBuilder = new NodeBuilder(Node);
if (nodeBuilder.FunctionName == FunctionNames.Trim)
{
return;
}
var gravityCenter = GeomUtils.ExtractGravityCenter(nodeBuilder.Shape);
var newPoint = GetPointForIndex(vertex.Point, gravityCenter, index);
var mouseTranslation = GeomUtils.BuildTranslation((gravityCenter), newPoint);
var translateValue = newPoint.SubstractCoordinate(gravityCenter);
var document = Dependency[0].Node.Root.Get <DocumentContextInterpreter>().Document;
if (!NodeUtils.NodeIsOnSketch(nodeBuilder))
{
NodeUtils.Translate3DNode(nodeBuilder, document, translateValue);//, gravityCenter);
}
else
{
var sketchNode = AutoGroupLogic.FindSketchNode(Node);
NodeUtils.TranslateSketchNode(nodeBuilder, translateValue, sketchNode);// mouseTranslation);
var constraintMapper = new ConstraintDocumentHelper(document, sketchNode);
constraintMapper.SetMousePosition(Dependency[0].Reference.Index);
var error = constraintMapper.ImpactAndSolve(Dependency[0].Node.Get <ReferenceInterpreter>().Node);
}
}
private Point3D ExtractCenterAndRadius(Node node, ref double radius)
{
var nb = new NodeBuilder(node);
if (node.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name == FunctionNames.Arc)
{
var P1 = nb.Dependency[0].RefTransformedPoint3D;
var P2 = nb.Dependency[1].RefTransformedPoint3D;
radius = Math.Sqrt((P1.X - P2.X) * (P1.X - P2.X) + (P1.Y - P2.Y) * (P1.Y - P2.Y) + (P1.Z - P2.Z) * (P1.Z - P2.Z));
return(P1);
}
if (node.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name == FunctionNames.Circle)
{
radius = nb.Dependency[1].Real;
return(nb.Dependency[0].RefTransformedPoint3D);
}
if (node.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name == FunctionNames.Arc3P)
{
var sketchNode = AutoGroupLogic.FindSketchNode(node);
var sketchAx2 = GeomUtils.ExtractSketchNormal(sketchNode);
var P1 = GeomUtils.Point3DTo2D(sketchAx2, nb.Dependency[0].RefTransformedPoint3D);
var P2 = GeomUtils.Point3DTo2D(sketchAx2, nb.Dependency[1].RefTransformedPoint3D);
var P3 = GeomUtils.Point3DTo2D(sketchAx2, nb.Dependency[2].RefTransformedPoint3D);
var center = GeomUtils.CircleCenter(P1, P2, P3);
radius = Math.Sqrt((P1.X - center.X) * (P1.X - center.X) + (P1.Y - center.Y) * (P1.Y - center.Y));
var centerPoint = GeomUtils.Point2DTo3D(sketchAx2, center);
return(new Point3D(centerPoint));
}
return(new Point3D(0, 0, 0));
}
public static List <Node> GetSketchNodes(Node sketchNode, Document document, bool includeAuxiliaryNodes)
{
var results = new List <Node>();
var root = document.Root;
var found = true;
var functionNames = new List <string> {
FunctionNames.Circle, FunctionNames.Ellipse, FunctionNames.LineTwoPoints, FunctionNames.Arc, FunctionNames.Arc3P, FunctionNames.Point
};
if (includeAuxiliaryNodes)
{
functionNames.Add(FunctionNames.LineHints);
}
while (found)
{
found = false;
results.AddRange(from node in root.ChildrenList
let builder = new NodeBuilder(node)
where functionNames.Contains(builder.FunctionName)
let currentSketchNode = AutoGroupLogic.FindSketchNode(node)
where currentSketchNode.Index == sketchNode.Index
select node);
}
return(results);
}
protected override void OnMouseUpAction(Mouse3DPosition mouseData)
{
base.OnMouseUpAction(mouseData);
_dragging = false;
if (_extrudeStages == ExtrudeStages.SelectSketch)
{
var entities = Inputs[InputNames.SelectionContainerPipe].GetData(NotificationNames.GetEntities).Get
<List <SceneSelectedEntity> >();
if (entities.Count <= 0)
{
return;
}
_sketchNode = AutoGroupLogic.FindSketchNode(entities[0].Node);
Ensure.IsNotNull(_sketchNode);
PreviewExtrudes(true);
_extrudeStages = ExtrudeStages.SelectAutoFace;
Inputs[InputNames.FacePickerPlane].Send(NotificationNames.Resume);
}
else if (_extrudeStages == ExtrudeStages.SelectAutoFace)
{
ProposeSelectedReferenceShape(_underMouseFace, mouseData);
PreviewExtrudes(true);
_extrudeStages = ExtrudeStages.ExtrudeAnimation;
}
else if (_extrudeStages == ExtrudeStages.ExtrudeAnimation)
{
}
}
public static List <Node> GetSketchPoints(Node sketchNode, Document document)
{
var results = new List <Node>();
var root = document.Root;
var found = true;
while (found)
{
found = false;
results.AddRange(from node in root.ChildrenList
let builder = new NodeBuilder(node)
where builder.FunctionName == FunctionNames.Point
let currentSketchNode = AutoGroupLogic.FindSketchNode(node)
where currentSketchNode.Index == sketchNode.Index
select node);
}
return(results);
}
public CutDialog(Document document, V3dView view, SceneSelectedEntity sceneSelectedEntity)
{
InitializeComponent();
_document = document;
_view = view;
var selNode = sceneSelectedEntity.Node;
var sketchNode = AutoGroupLogic.FindSketchNode(selNode);
_cutNode = new NodeBuilder(document, FunctionNames.Cut);
_cutNode[0].Reference = sketchNode;
cutTypeComboBox.Items.Add(CutThroughAll);
cutTypeComboBox.Items.Add(CutToDepth);
cutTypeComboBox.SelectedIndex = 0;
CutDepth = 100;
UpdateView();
}
protected override bool ApplyFunction()
{
var builder = new NodeBuilder(Document, FunctionNames.Revolve);
var sketchNode = AutoGroupLogic.FindSketchNode(FirstShape);
Node node = FirstShape;
if (sketchNode != null)
{
if (sketchNode.Children[2].Get <MeshTopoShapeInterpreter>() == null)
{
var tempFace = AutoGroupLogic.RebuildSketchFace(sketchNode, Document);
if (tempFace != null)
{
sketchNode.Children[2].Set <MeshTopoShapeInterpreter>().Shape = tempFace;
NodeUtils.SetSketchTransparency(Document, sketchNode, ObjectVisibility.Hidden);
sketchNode.Set <DrawingAttributesInterpreter>().Transparency = 1;
sketchNode.Set <DrawingAttributesInterpreter>().Visibility = ObjectVisibility.Hidden;
Document.Commit("Sketch face generated");
node = sketchNode;
}
}
else
{
node = sketchNode;
}
}
builder[0].Reference = node;
builder[1].Reference = SecondShape;
builder[2].Real = 360.0;
if (builder.ExecuteFunction())
{
AddNodeToTree(builder.Node);
if (node == sketchNode)
{
NodeUtils.SetSketchTransparency(Document, sketchNode, ObjectVisibility.Hidden);
}
return(true);
}
return(false);
}
public static void AddArrayPatternNodes(Document document, int axis, int columnAxis, int shape, int rows, int columns, int rowDistance, int colDistance)
{
var indexColomns = 1;
var node = document.Root[shape];
var axisNode = document.Root[axis];
var _axis = GeomUtils.ExtractAxis(new NodeBuilder(axisNode).Shape);
var columnAxisNode = document.Root[columnAxis];
var _ColumnAxis = GeomUtils.ExtractAxis(new NodeBuilder(columnAxisNode).Shape);
var reverseRows = 1;
var reverseColumns = 1;
for (var indexRows = 0; indexRows < rows; indexRows++)
{
for (; indexColomns < columns; indexColomns++)
{
var sourceCopyBuilder = new NodeBuilder(Document.CopyPaste(node));
sourceCopyBuilder.ShapeName = "Patterned" +
sourceCopyBuilder.ShapeName.Substring(0, sourceCopyBuilder.ShapeName.
Length - 1) +
(indexRows * columns + indexColomns);
sourceCopyBuilder.Node.Set <DrawingAttributesInterpreter>().Visibility = ObjectVisibility.ToBeDisplayed;
var transformInterpreter = sourceCopyBuilder.Node.Get <TransformationInterpreter>();
transformInterpreter.ApplyGeneralArrayPattern(_axis, _ColumnAxis, indexRows * rowDistance * reverseRows,
indexColomns * colDistance * reverseColumns);
}
indexColomns = 0;
}
var slectedNode = node;
var sketchNode = AutoGroupLogic.FindSketchNode(slectedNode);
NodeUtils.SetSketchTransparency(document, sketchNode, 0);
var face = AutoGroupLogic.RebuildSketchFace(sketchNode, document);
sketchNode.Children[2].Set <MeshTopoShapeInterpreter>().Shape = face;
sketchNode.Set <DrawingAttributesInterpreter>().Transparency = 1;
sketchNode.Set <DrawingAttributesInterpreter>().Visibility = ObjectVisibility.Hidden;
NodeUtils.SetSketchTransparency(document, sketchNode, 0);
}
public void GetSketchNodeTest()
{
var document = TestUtils.DefaultsSetup();
document.Transact();
var sketchCreator = new SketchCreator(document, false);
var sketchNode = sketchCreator.BuildSketchNode();
var line = TestUtils.Line(document, sketchNode, new Point3D(10, 10, 0), new Point3D(10, 0, 0));
Assert.IsTrue(line.LastExecute);
var sketchCreator2 = new SketchCreator(document, false);
var sketchNode2 = sketchCreator2.BuildSketchNode();
var circle = TestUtils.Circle(document, sketchNode2, new Point3D(0, 0, 0), 5);
Assert.IsTrue(circle.ExecuteFunction());
var sphereBuilder = new NodeBuilder(document, FunctionNames.Sphere);
sphereBuilder[0].TransformedPoint3D = new Point3D(10, 10, 0);
sphereBuilder[1].Real = 3;
Assert.IsTrue(sphereBuilder.ExecuteFunction());
var firstNode = new NodeBuilder(AutoGroupLogic.FindSketchNode(line.Node));
Assert.AreEqual(firstNode.FunctionName, FunctionNames.Sketch);
Assert.AreEqual(firstNode.ShapeName, "Sketch-1");
var secondNode = new NodeBuilder(AutoGroupLogic.FindSketchNode(circle.Node));
Assert.AreEqual(secondNode.FunctionName, FunctionNames.Sketch);
Assert.AreEqual(secondNode.ShapeName, "Sketch-2");
Assert.IsNull(AutoGroupLogic.FindSketchNode(sphereBuilder.Node));
}
private void UpdatePoints()
{
var root = this.Builder.Node.Root;
var pointNodes = from node in root.ChildrenList
let builder = new NodeBuilder(node)
where builder.FunctionName == FunctionNames.Point
let currentSketchNode = AutoGroupLogic.FindSketchNode(node)
where currentSketchNode.Index == this.Builder.Node.Index
select node;
var points = pointNodes.ToList();
var sketchAx2 = new gpAx2 {
Axis = NodeBuilderUtils.GetTransformedAxis(Builder)
};
var sketchPlane = new gpPln(new gpAx3(sketchAx2));
foreach (var point in points)
{
var nb = new NodeBuilder(point);
var current = nb[1].TransformedPoint3D;
var projectedPlane = GeomUtils.ProjectPointOnPlane(current.GpPnt, sketchPlane, Precision.Confusion);
nb[1].TransformedPoint3D = new Point3D(projectedPlane);
nb.ExecuteFunction();
}
}
/// <summary>
/// Called when Enter Sketch is pressed. If a node is selected in the tree or a shape is selected on the drawing stage,
/// the sketch containing that node/shape is selected for editing, otherwise a new sketch will be created in OnMouseDownAction
/// </summary>
public override void OnActivate()
{
base.OnActivate();
if (Document.Root.Children.Count > 0)
{
Inputs[InputNames.SelectionContainerPipe].Send(NotificationNames.SwitchSelectionMode,
TopAbsShapeEnum.TopAbs_FACE);
}
else
{
Inputs[InputNames.SelectionContainerPipe].Send(NotificationNames.SwitchSelectionMode,
TopAbsShapeEnum.TopAbs_SOLID);
}
ActionsGraph[InputNames.CoordinateParser].Send(CoordinatateParserNames.SetStage, ParserStage.Unknown);
Inputs[InputNames.SelectionContainerPipe].Send(NotificationNames.Enable);
Inputs[InputNames.FacePickerPlane].Send(NotificationNames.Disable);
Reset();
ShowHint(ModelingResources.StartSketch);
Inputs[InputNames.GeometricSolverPipe].Send(NotificationNames.DisableAll);
var uiBuilder = ActionsGraph[InputNames.UiBuilderInput].Get <UiBuilder>();
var sketchControl = uiBuilder.GetItemAtPath("Ribbon/Modelling/Sketch/Sketch");
_sketchButton = (ISketchButton)sketchControl;
var selected = Inputs[InputNames.SelectionContainerPipe].GetData(NotificationNames.GetEntities).Get <List <SceneSelectedEntity> >();
Node node = null;
if (selected.Count > 0)
{
node = selected[0].Node;
}
else
{
node = Inputs[InputNames.NodeSelect].GetData(NotificationNames.GetValue).Get <Node>();
}
if (node != null)
{
Node sketchNode = AutoGroupLogic.FindSketchNode(node);
if (sketchNode != null)
{
Document.Transact();
Document.Root.Get <DocumentContextInterpreter>().ActiveSketch = sketchNode.Index;
NodeUtils.SetSketchTransparency(Document, sketchNode, 0);
Inputs[InputNames.Mouse3DEventsPipe].Send(NotificationNames.Resume);
var axis = new NodeBuilder(sketchNode)[0].TransformedAxis3D;
var plane = new gpPln(new gpAx3(axis.Location, axis.Direction));
Inputs[InputNames.Mouse3DEventsPipe].Send(NotificationNames.SetPlane, plane);
//if (Inputs[InputNames.Mouse3DEventsPipe].GetData(NotificationNames.GetPlane).Data == null)
//{
// var plane = new gpPln(new gpAx3());
// Inputs[InputNames.Mouse3DEventsPipe].Send(NotificationNames.SetPlane, plane);
// //ActionsGraph[InputNames.View].Send(NotificationNames.SwitchView, plane);
//}
_sketchButton.Block();
HighlightCurrentSketchNodes(sketchNode);
Document.Commit("Started editing sketch");
BackToNeutralModifier();
Log.Info("StartSketch - current sketch exists");
_sketchButton.Block();
return;
}
}
if (Document.Root.Children.Count == 0)
{
CreatePlane(new Point3D(-20, -10, 0), new Point3D(20, -10, 0),
new Point3D(20, 10, 0), new Point3D(-20, 10, 0), "Top");
CreatePlane(new Point3D(-20, 0, -10), new Point3D(20, 0, -10),
new Point3D(20, 0, 10), new Point3D(-20, 0, 10), "Right");
CreatePlane(new Point3D(0, -20, -10), new Point3D(0, 20, -10),
new Point3D(0, 20, 10), new Point3D(0, -20, 10), "Front");
Document.Commit("Default planes created");
}
Inputs[InputNames.FacePickerPlane].Send(NotificationNames.Enable);
Inputs[InputNames.SelectionContainerPipe].Send(NotificationNames.SwitchSelectionMode,
TopAbsShapeEnum.TopAbs_FACE);
Inputs[InputNames.Mouse3DEventsPipe].Send(NotificationNames.Resume);
var sketchCreator = new SketchCreator(Document, false);
if (sketchCreator.CurrentSketch == null)
{
ShowHint(ModelingResources.StartSketch);
Log.Info("StartSketch - no current sketch");
}
}
protected override void OnMouseUpAction(Mouse3DPosition mouseData)
{
base.OnMouseUpAction(mouseData);
if (_extrudeStages == ExtrudeStages.SelectSketch)
{
var entities = Inputs[InputNames.SelectionContainerPipe].GetData(NotificationNames.GetEntities).Get
<List <SceneSelectedEntity> >();
if (entities.Count <= 0)
{
return;
}
_sketchNode = AutoGroupLogic.FindSketchNode(entities[0].Node);
if (_sketchNode == null)
{
return;
}
if (_sketchNode.Children[2].Get <MeshTopoShapeInterpreter>() == null)
{
// the sketch shape was not generated - this is the case when we open a file and perform extrude without any edits
var tempFace = AutoGroupLogic.RebuildSketchFace(_sketchNode, Document);
if (tempFace == null)
{
return;
}
_sketchNode.Children[2].Set <MeshTopoShapeInterpreter>().Shape = tempFace;
NodeUtils.SetSketchTransparency(Document, _sketchNode, ObjectVisibility.Hidden);
_sketchNode.Set <DrawingAttributesInterpreter>().Transparency = 1;
_sketchNode.Set <DrawingAttributesInterpreter>().Visibility = ObjectVisibility.Hidden;
Document.Commit("Sketch face generated");
}
var face = _sketchNode.Children[2].Get <MeshTopoShapeInterpreter>().Shape;
_shapePlane = GeomUtils.ExtractPlane(face);
PreviewExtrude(false, mouseData);
ResetWorkingPlane();
Inputs[InputNames.SelectionContainerPipe].Send(NotificationNames.Disable);
_extrudeStages = ExtrudeStages.ExtrudeAnimation;
}
else if (_extrudeStages == ExtrudeStages.ExtrudeAnimation)
{
var sketchBuilder = new NodeBuilder(_sketchNode);
var extrudeHeight = sketchBuilder[0].Axis3D.Location.Distance(mouseData.Point);
if (extrudeHeight < 1e-12)
{
return;
}
PreviewExtrude(false, mouseData);
NodeUtils.SetSketchTransparency(Document, _sketchNode, ObjectVisibility.Hidden);
CommitFinal("Extrudes build");
Inputs[InputNames.FacePickerPlane].Send(NotificationNames.Resume);
//Inputs[InputNames.SelectionContainerPipe].Send(NotificationNames.SwitchSelectionMode,
// TopAbsShapeEnum.TopAbs_SOLID);
RebuildTreeView();
UpdateView();
BackToNeutralModifier();
}
}
private void MouseClickHandler(Mouse3DPosition mousePosition)
{
if (!Enabled)
{
return;
}
var matchingSketches = new List <int>();
if (mousePosition.MouseDown == false)
{
var linesEdges = (from line in lines where line != null && line.Shape != null select GeomUtils.ExtractEdge(line.Shape)).ToList();
_document.Revert();
// continue only if we have a drag action
if (Math.Abs(mousePosition.Initial2Dx - startX) < 3 && Math.Abs(mousePosition.Initial2Dy - startY) < 3)
{
return;
}
bool leftToRight = startX < mousePosition.Initial2Dx ? true : false;
if (selectionFace == null)
{
return;
}
var sketchNodes = NodeUtils.GetDocumentNodesOfType(_document, FunctionNames.Sketch);
// find all sketches that are on the same plane as the selection
matchingSketches.AddRange(from sketchNodeIndex in sketchNodes
let nb = new NodeBuilder(_document.Root[sketchNodeIndex])
let normal = nb.Dependency[0].TransformedAxis3D
where normal.IsParallel(viewPlane.Axis, Precision.Confusion)
select sketchNodeIndex);
var pointsToShapeMapping = new Dictionary <int, List <int> >();
var shapeToPointMapping = new Dictionary <int, List <int> >();
var functionNames = new List <string> {
FunctionNames.Circle, FunctionNames.Ellipse, FunctionNames.LineTwoPoints, FunctionNames.Arc, FunctionNames.Arc3P
};
var selectedShapes = new List <int>();
foreach (var index in matchingSketches)
{
var sketchPoints = NodeUtils.GetSketchPoints(_document.Root[index], _document);
// find all shapes and points on the matching sketches
foreach (var node in _document.Root.Children)
{
var builder = new NodeBuilder(node.Value);
if (functionNames.Contains(builder.FunctionName))
{
var currentSketchNode = AutoGroupLogic.FindSketchNode(node.Value);
if (currentSketchNode.Index == index)
{
if (builder.FunctionName == FunctionNames.Circle)
{
if (!pointsToShapeMapping.ContainsKey(builder.Dependency[0].Node.Index))
{
pointsToShapeMapping.Add(builder.Dependency[0].ReferenceBuilder.Node.Index,
new List <int> {
builder.Node.Index
});
}
else
{
pointsToShapeMapping[builder.Dependency[0].ReferenceBuilder.Node.Index].Add(builder.Node.Index);
}
shapeToPointMapping.Add(builder.Node.Index, new List <int> {
builder.Dependency[0].ReferenceBuilder.Node.Index
});
}
else
{
var pointsList = new List <int>();
for (int k = 0; k < builder.Dependency.Count; k++)
{
if (!pointsToShapeMapping.ContainsKey(builder.Dependency[k].ReferenceBuilder.Node.Index))
{
pointsToShapeMapping.Add(builder.Dependency[k].ReferenceBuilder.Node.Index, new List <int> {
builder.Node.Index
});
}
else
{
pointsToShapeMapping[builder.Dependency[k].ReferenceBuilder.Node.Index].Add(builder.Node.Index);
}
pointsList.Add(builder.Dependency[k].ReferenceBuilder.Node.Index);
}
shapeToPointMapping.Add(builder.Node.Index, pointsList);
}
}
var edge = GeomUtils.ExtractEdge(builder.Shape);
if (edge != null && !edgeMappings.ContainsKey(builder.Node.Index))
{
edgeMappings.Add(builder.Node.Index, edge);
}
}
}
var selectedPoints = new List <int>();
// check which points are inside the selection
foreach (var point in sketchPoints)
{
var shapeFace = new NodeBuilder(point).Shape;
if (shapeFace == null)
{
continue;
}
var common = new BRepAlgoAPICommon(selectionFace, shapeFace);
if (common.IsDone)
{
var commonArea = GeomUtils.GetFaceArea(common.Shape);
if (commonArea > 0)
{
selectedPoints.Add(point.Index);
}
}
_document.Transact();
}
// Left->Right - only shapes that are fully inside the selection box are selected
if (leftToRight)
{
foreach (var point in selectedPoints)
{
if (!pointsToShapeMapping.ContainsKey(point))
{
selectedShapes.Add(point);
continue;
}
var shapes = pointsToShapeMapping[point];
foreach (var shape in shapes)
{
var points = shapeToPointMapping[shape];
var allPointsAreSelected = true;
foreach (var pointIndex in points)
{
if (!selectedPoints.Contains(pointIndex))
{
allPointsAreSelected = false;
break;
}
}
if (allPointsAreSelected)
{
selectedShapes.Add(shape);
}
}
}
selectedShapes = selectedShapes.Distinct().ToList();
}
else
{
// Right->Left - shapes that are corssed by the selection box are also included in the selection
foreach (var point in selectedPoints)
{
if (pointsToShapeMapping.ContainsKey(point))
{
selectedShapes.AddRange(pointsToShapeMapping[point]);
}
else
{
selectedShapes.Add(point);
}
}
foreach (var edgeMapping in edgeMappings)
{
if (!selectedShapes.Contains(edgeMapping.Key))
{
foreach (var line in linesEdges)
{
var intersection = GeomUtils.IntersectionPoints(line, edgeMapping.Value);
if (intersection.Count > 0)
{
selectedShapes.Add(edgeMapping.Key);
break;
}
}
}
}
}
}
selectedShapes = selectedShapes.Distinct().ToList();
_selectionContainer.BuildSelections(selectedShapes);
Inputs[InputNames.UiElementsItem].Send(NotificationNames.RefreshPropertyTabMultipleSelections, _selectionContainer.Entities);
_document.Transact();
return;
}
selectedNodesIndexes.Clear();
startX = mousePosition.Initial2Dx;
startY = mousePosition.Initial2Dy;
startPoint = mousePosition.Point;
var correctedMousePosition = CalculateCorrectCoordinate(mousePosition);
_context.MoveTo(correctedMousePosition.Initial2Dx, correctedMousePosition.Initial2Dy, ViewItems.View);
if (mousePosition.MouseDown)
{
if (mousePosition.ShiftDown)
{
_context.ShiftSelect(true);
}
else
{
_context.Select(true);
}
}
// Perform click selection using the corrected coordinate
_selectionContainer.BuildSelections(correctedMousePosition);
if (_selectionContainer.Entities.Count == 2)
{
Inputs[InputNames.UiElementsItem].Send(NotificationNames.RefreshPropertyTabTwoSelections, _selectionContainer.Entities);
}
if (_selectionContainer.Entities.Count == 1)
{
Inputs[InputNames.UiElementsItem].Send(NotificationNames.SelectNode, _selectionContainer.Entities[0].Node);
}
}
public int Solve()
{
if (!_shapeList.Any() || !_constraints.Any())
{
return(0);
}
// transform parameters
var sketchNode = AutoGroupLogic.FindSketchNode(_document.Root[_shapeList.First()]);
var axisAll = NodeBuilderUtils.GetTransformedAxis(new NodeBuilder(sketchNode));
var sketchAx2 = new gpAx2(axisAll.Location, axisAll.Direction);
LoadParameters(sketchAx2);
LoadConstraints();
if (SetConstraintsList.Size == 0)
{
return(0);
}
var freeParametersCount = 1;
var maxFreeParametersCount = Parameters.Count - 2;
var error = 1;
var dfpSolver = new DFPSolver();
while (error == 1 && freeParametersCount <= maxFreeParametersCount)
{
error = dfpSolver.SolveRef(ref Parameters, freeParametersCount, ConstraintList, 1);
freeParametersCount++;
}
Sketch2DSolver solver;
if (error == 1)
{
var bfgsSolver = new BFGSSolver();
freeParametersCount = 1;
while (error == 1 && freeParametersCount <= maxFreeParametersCount)
{
error = bfgsSolver.SolveRef(ref Parameters, freeParametersCount, ConstraintList, 1);
freeParametersCount++;
}
solver = bfgsSolver;
}
else
{
solver = dfpSolver;
}
if (error == 0)
{
// update point position with the values returned by the solver
int index = 0;
foreach (var shape in ShapeToParamIndex.Keys)
{
//if (index > maxFreeParametersCount)
// break;
var nodeBuilder = new NodeBuilder(_document.Root[shape]);
if (nodeBuilder.FunctionName == FunctionNames.Point)
{
nodeBuilder[1].TransformedPoint3D = GeomUtils.Point2DTo3D(sketchAx2,
Parameters[ShapeToParamIndex[shape]],
Parameters[
ShapeToParamIndex[shape] + 1]);
index += 2;
}
if (nodeBuilder.FunctionName == FunctionNames.Circle)
{
nodeBuilder[0].RefTransformedPoint3D = GeomUtils.Point2DTo3D(sketchAx2, Parameters[ShapeToParamIndex[shape]], Parameters[ShapeToParamIndex[shape] + 1]);
nodeBuilder[1].Real = Parameters[ShapeToParamIndex[shape] + 2];
index += 3;
}
}
foreach (var shape in _document.Root.Children)
{
//if (index > maxFreeParametersCount)
// break;
var nodeBuilder = new NodeBuilder(shape.Value);
if (nodeBuilder.FunctionName == FunctionNames.Arc)
{
if (ShapeToParamIndex.Keys.Contains(nodeBuilder.Dependency[0].Reference.Index))
{
var centre = nodeBuilder.Dependency[0].RefTransformedPoint3D;
var start = nodeBuilder.Dependency[1].RefTransformedPoint3D;
var currentEnd = nodeBuilder.Dependency[2].RefTransformedPoint3D;
var newEnd = GeomUtils.ProjectPointOnCircle(centre, start, currentEnd);
if (newEnd != null)
{
var End = new Point3D(newEnd);
nodeBuilder[2].RefTransformedPoint3D = new Point3D(End.X, End.Y, End.Z);
}
}
error = 1;
freeParametersCount = 0;
while (error == 1 && freeParametersCount <= maxFreeParametersCount)
{
error = solver.SolveRef(ref Parameters, freeParametersCount, SetConstraintsList, 1);
freeParametersCount += 2;
}
}
}
}
foreach (var constr in softConstraints)
{
_document.Root.Remove(constr);
}
return(error);
}
private List <Node> BuildAutoFaces(Node sketchNode)
{
var results = new List <Node>();
var root = Document.Root;
InitSession();
var found = true;
var circleNodes = new List <Node>();
while (found)
{
found = false;
foreach (var node in root.ChildrenList)
{
var builder = new NodeBuilder(node);
if (builder.FunctionName == FunctionNames.Circle || builder.FunctionName == FunctionNames.Ellipse)
{
var currentSketchNode = AutoGroupLogic.FindSketchNode(node);
if (currentSketchNode.Index == sketchNode.Index)
{
circleNodes.Add(node);
}
}
if (builder.FunctionName == FunctionNames.LineTwoPoints ||
builder.FunctionName == FunctionNames.Arc ||
builder.FunctionName == FunctionNames.Arc3P)
{
var currentSketchNode = AutoGroupLogic.FindSketchNode(node);
if (currentSketchNode.Index != sketchNode.Index)
{
continue;
}
var result = AutoGroupLogic.TryAutoGroup(Document, builder.Node);
if (result == null)
{
continue;
}
found = true;
results.Add(result);
// var faceBuilder = new NodeBuilder(result) {Transparency = 0.5};
break;
}
}
}
foreach (var node in circleNodes)
{
var builder = new NodeBuilder(node);
var addedEntiy = new SceneSelectedEntity {
Node = builder.Node, ShapeType = TopAbsShapeEnum.TopAbs_WIRE
};
var builder2 = new NodeBuilder(Document, FunctionNames.Face);
builder2[0].ReferenceList = new List <SceneSelectedEntity> {
addedEntiy
};
builder2.ExecuteFunction();
results.Add(builder2.Node);
}
return(results);
}