public void CheckAppliedConstraintTest()
{
var document = TestUtils.DefaultsSetup();
var sketch = new SketchCreator(document);
var sketchNode = sketch.BuildSketchNode();
document.Transact();
var pointLinker = sketch.PointLinker;
var line = ConstraintUtils.BuildLine(document, pointLinker, new Point3D(1, 1, 0), new Point3D(3, 1.5, 0));
var line2 = ConstraintUtils.BuildLine(document, pointLinker, new Point3D(1, 3, 0), new Point3D(3, 2.5, 0));
var constraintBuilder = new NodeBuilder(document, Constraint2DNames.ParallelFunction);
constraintBuilder[0].Reference = line.Node;
constraintBuilder[1].Reference = line2.Node;
document.Commit("Draw");
var constraintMapper = new ConstraintDocumentHelper(document, sketchNode);
var result = constraintMapper.CheckAppliedConstraints(new List <Node> {
line.Node, line2.Node
});
var appliedFunctions = GetAppliedFunctions(result);
Assert.IsTrue(appliedFunctions.Contains(Constraint2DNames.ParallelFunction));
}
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 void AddNewPoint(Point3D coordinate)
{
if (Points.Count == 2 && Points[0].IsEqual(coordinate))
{
return;
}
SetCoordinate(coordinate);
AddNewEmptyPoint();
if (Points.Count <= 2)
{
return;
}
var lines = PreviewRectangleLines(Document, _sketchNode);
var constraintMapper = new ConstraintDocumentHelper(Document, _sketchNode);
ApplyLinesConstraint(constraintMapper, lines[0], lines[2], Constraint2DNames.ParallelFunction);
ApplyLineConstraint(constraintMapper, lines[0], Constraint2DNames.HorizontalFunction);
ApplyLineConstraint(constraintMapper, lines[2], Constraint2DNames.HorizontalFunction);
ApplyLineConstraint(constraintMapper, lines[1], Constraint2DNames.VerticalFunction);
ApplyLineConstraint(constraintMapper, lines[3], Constraint2DNames.VerticalFunction);
ApplyLinesConstraint(constraintMapper, lines[1], lines[3], Constraint2DNames.ParallelFunction);
ApplyLinesConstraint(constraintMapper, lines[0], lines[1], Constraint2DNames.PerpendicularFunction);
CommitFinal("Added rectangle to scene");
UpdateView();
RebuildTreeView();
Reset();
}
public void AppliedConstraintsMappingTest()
{
var document = TestUtils.DefaultsSetup();
var sketch = new SketchCreator(document);
var sketchNode = sketch.BuildSketchNode();
document.Transact();
var pointLinker = sketch.PointLinker;
var line = ConstraintUtils.BuildLine(document, pointLinker, new Point3D(1, 1, 0), new Point3D(3, 1.5, 0));
var line2 = ConstraintUtils.BuildLine(document, pointLinker, new Point3D(1, 3, 0), new Point3D(3, 2.5, 0));
const string constraintFunctionName = Constraint2DNames.ParallelFunction;
var constraintBuilder = new NodeBuilder(document, constraintFunctionName);
constraintBuilder[0].Reference = line.Node;
constraintBuilder[1].Reference = line2.Node;
document.Commit("Draw");
var constraintMapper = new ConstraintDocumentHelper(document, sketchNode);
var selection = new List <Node> {
line.Node, line2.Node
};
var condition = constraintMapper.IsApplied(selection, constraintFunctionName);
Assert.IsTrue(condition);
}
private void AddNewPoint(Point3D coordinate)
{
SetCoordinate(coordinate);
AddNewEmptyPoint();
if (Points.Count == 3)
{
ShowHint(ModelingResources.RectangleStep3);
return;
}
if (Points.Count != 4)
{
return;
}
var lines = PreviewRectangle(Document, _sketchNode);
var constraintMapper = new ConstraintDocumentHelper(Document, _sketchNode);
ApplyLinesConstraint(constraintMapper, lines[0], lines[2], Constraint2DNames.ParallelFunction);
ApplyLinesConstraint(constraintMapper, lines[1], lines[3], Constraint2DNames.ParallelFunction);
ApplyLinesConstraint(constraintMapper, lines[0], lines[1], Constraint2DNames.PerpendicularFunction);
CommitFinal("Added rectangle to scene");
UpdateView();
RebuildTreeView();
Reset();
}
private void PopulateConstraintNames(Document document)
{
_helper = new ConstraintDocumentHelper(document, _sketchNode);
var constraintFunctions = _helper.ConstraintMapper.Constraints.Keys;
_constraintNames = new SortedDictionary<string, bool>();
foreach (var functionName in constraintFunctions)
_constraintNames[functionName] = false;
}
public void Setup(Sketch3DTo2DTranslator coordinateTranslator, SketchHinterOptions options,
ConstraintDocumentHelper constraintMapper, Hinter2D hinter2D)
{
Hinter2D = hinter2D;
CoordinateTranslator = coordinateTranslator;
Options = options;
_constraintMapper = constraintMapper;
constraintNodes = new List <NodeBuilder>();
}
private void CallSolverForLineChanges(Node Parent)
{
var dependency = TreeUtils.GetFunctionDependency(Parent);
var sketchNode = dependency[0].ReferenceBuilder[0].ReferenceBuilder[0].Node;
var constraintMapper =
new ConstraintDocumentHelper(dependency[0].Node.Root.Get <DocumentContextInterpreter>().Document,
sketchNode);
constraintMapper.SetMousePosition(dependency[0].Reference.Index);
constraintMapper.ImpactAndSolve(Parent);
}
private void OnPreModify()
{
_sketchNode = _document.Root.Get<DocumentContextInterpreter>().ActiveSketch == -1 ? new SketchCreator(_document, false).CurrentSketch :
_document.Root[_document.Root.Get<DocumentContextInterpreter>().ActiveSketch];
if (_sketchNode == null)
return;
if (_constraintNames == null)
PopulateConstraintNames(_document);
_helper = new ConstraintDocumentHelper(_document, _sketchNode);
_helper.ComputeSolverOnImpactedNodes(_constraintNames);
}
private int CallSolverForPointChanges(Node Parent)
{
var dependency = TreeUtils.GetFunctionDependency(Parent);
var sketchNode = Parent.Children[1].Get <ReferenceInterpreter>().Node;
var constraintMapper =
new ConstraintDocumentHelper(dependency[0].Node.Root.Get <DocumentContextInterpreter>().Document,
sketchNode);
constraintMapper.SetMousePosition(Parent.Index);//dependency[0].Reference.Index);
var error = constraintMapper.ImpactAndSolve(Parent);
return(error);
}
public override void OnActivate()
{
base.OnActivate();
Inputs[InputNames.GeometricSolverPipe].Send(NotificationNames.DisableAll);
var sketchCreator = new SketchCreator(Document);
_sketchNode = sketchCreator.CurrentSketch;
_constraintDocumentHelper = new ConstraintDocumentHelper(Document, _sketchNode);
_view = new ConstraintMapperView(_constraintDocumentHelper);
_view.OnSceneChanged += SceneChanged;
RibbonPanel.Children.Add(_view);
_view.UpdateSelection(new List <Node>());
}
private void CallSolverForLineChanges(Node Parent)
{
var dependency = TreeUtils.GetFunctionDependency(Parent);
var sketchNode = dependency[0].ReferenceBuilder[0].ReferenceBuilder[0].Node;
var document = dependency[0].Node.Root.Get <DocumentContextInterpreter>().Document;
var constraintMapper =
new ConstraintDocumentHelper(document, sketchNode);
constraintMapper.SetMousePosition(Parent.Index);
constraintMapper.ImpactAndSolve(dependency[0].ReferenceBuilder.Node);
var pnt = dependency[0].RefTransformedPoint3D;
dependency[0].RefTransformedPoint3D = pnt;
document.Commit("Dimension constraint updated");
}
private void OnGetPossibleConstraints(ref object resultValue)
{
_constraintsProperty.UpdateFieldValue();
var document = _viewInfo.Document;
var sketchNode = NodeBuilderUtils.FindSketchNode(Builder.Node);
var constraintDocumentHelper = new ConstraintDocumentHelper(document, sketchNode);
var constraintList = constraintDocumentHelper.GetAvailableConstraints(new List<Node> {Builder.Node}, existingConstraints);
var possibleConstraints = constraintList.Select(constraint => new NewConstraintInfo()
{
ConstraintName = constraint.Replace("Function", string.Empty),
ConstraintFunctionName = constraint, SketchNode = sketchNode, SelectedNodes = new List<Node> {Builder.Node}
}).ToList();
resultValue = possibleConstraints;
}
public override void UpdatePointPosition(int index, Mouse3DPosition vertex)
{
var radiusConstraint = NodeBuilderUtils.ShapeHasConstraint(Node, Constraint2DNames.CircleRadiusFunction,
Dependency[0].Node.Root.Get
<DocumentContextInterpreter>().Document);
// allow edits only if we don't have a radius constraint
if (radiusConstraint == -1)
{
var transform = Node.Get <TransformationInterpreter>();
switch (index)
{
case 0:
case 1:
case 2:
case 3:
// The radius is the distance between the center and the new point
var dependency = TreeUtils.GetFunctionDependency(Node);
if (Dependency[0].Name == FunctionNames.Point || Dependency[0].Name == InterpreterNames.Reference)
{
dependency[1].Real =
vertex.Point.GpPnt.Distance(
Dependency[0].RefTransformedPoint3D.GpPnt.Transformed(transform.CurrTransform));
}
if (Dependency[0].Name == FunctionNames.AxisHandle)
{
dependency[1].Real =
vertex.Point.GpPnt.Distance(
Dependency[0].TransformedAxis3D.Location.Transformed(transform.CurrTransform));
}
break;
}
if (Dependency[0].Name == FunctionNames.Point || Dependency[0].Name == InterpreterNames.Reference)
{
var document = Dependency[0].Node.Root.Get <DocumentContextInterpreter>().Document;
var sketchNode = Dependency[0].ReferenceBuilder[0].ReferenceBuilder[0].Node;
var constraintMapper =
new ConstraintDocumentHelper(document,
sketchNode);
constraintMapper.SetMousePosition(Dependency[0].Reference.Index);
var error = constraintMapper.ImpactAndSolve(Dependency[0].Node.Parent);
}
}
}
private void InitializeFields()
{
_hinterShapeCreators = new SortedDictionary <string, HinterShapeCreatorBase>();
HinterShapes = new SortedDictionary <int, HinterShapeBase>();
_algorithms = new List <SketchHinterAlgorithmBase>();
var nodeBuilder = new NodeBuilder(_sketchNode);
_coordinateTranslator = new Sketch3DTo2DTranslator(nodeBuilder[0].Axis3D);
_constraintMapper = new ConstraintDocumentHelper(_document, _sketchNode);
Register(FunctionNames.LineTwoPoints, new LineHinterCreatorShape());
Register(FunctionNames.Point, new PointHinterCreatorShape());
Populate();
AddAlgorithm <LineHorizontalAlgorithm>();
AddAlgorithm <LineVerticalAlgorithm>();
AddAlgorithm <LineParallelAlgorithm>();
AddAlgorithm <LinePerpendicularAlgorithm>();
AddAlgorithm <PointOnLineAlgorithm>();
}
public void ApplyConstraintTest()
{
var document = TestUtils.DefaultsSetup();
var sketch = new SketchCreator(document);
var sketchNode = sketch.BuildSketchNode();
document.Transact();
var pointLinker = sketch.PointLinker;
var line = ConstraintUtils.BuildLine(document, pointLinker, new Point3D(1, 1, 0), new Point3D(3, 1.5, 0));
var line2 = ConstraintUtils.BuildLine(document, pointLinker, new Point3D(1, 3, 0), new Point3D(3, 2.5, 0));
document.Commit("Draw");
var constraintMapper = new ConstraintDocumentHelper(document, sketchNode);
var result = constraintMapper.ApplyConstraint(new List <Node> {
line.Node, line2.Node
},
Constraint2DNames.ParallelFunction);
Assert.IsTrue(result.LastExecute);
}
private void ListBoxOnSelectionChanged(object sender, SelectionChangedEventArgs selectionChangedEventArgs)
{
if (((ListBox)sender).SelectedItems.Count > 0)
{
var sketchNode = ((NewConstraintInfo)((ListBox)sender).SelectedItems[0]).SketchNode;
var currentNodes = ((NewConstraintInfo)((ListBox)sender).SelectedItems[0]).SelectedNodes;
var document = sketchNode.Root.Get <DocumentContextInterpreter>().Document;
document.Transact();
var constraintDocumentHelper = new ConstraintDocumentHelper(document, sketchNode);
var firstPointIndex = NodeUtils.GetFirstPointIndex(currentNodes[0]);
constraintDocumentHelper.SetMousePosition(firstPointIndex);
var constraintAdded = constraintDocumentHelper.ApplyConstraint(currentNodes,
((NewConstraintInfo)((ListBox)sender).SelectedItems[0]).ConstraintFunctionName);
if (currentNodes.Count == 1)
{
NodeBuilderUtils.AdddHintsForNode(document, currentNodes[0], constraintAdded.Node);
}
constraintDocumentHelper.ImpactAndSolve(currentNodes[0]);
document.Commit("Added constraint to scene");
UpdateFieldValue();
}
}
public override void UpdatePointPosition(int index, Mouse3DPosition vertex)
{
var sketchNode = Dependency[0].ReferenceBuilder[0].ReferenceBuilder[0].Node;
var transform = NodeBuilderUtils.GetGlobalTransformation(new NodeBuilder(NodeBuilderUtils.FindSketchNode(Node)));
var sketchAx2 = new gpAx2 {
Axis = (sketchNode.Get <Axis3DInterpreter>().Axis.GpAxis)
};
sketchAx2.Direction = sketchAx2.Direction.Transformed(transform);
var sketchPlane = new gpPln(new gpAx3(sketchAx2));
var projectedPoint = GeomUtils.ProjectPointOnPlane(vertex.Point.GpPnt, sketchPlane, Precision.Confusion);
var originalFirstPoint = Dependency[0].RefTransformedPoint3D;
var originalSecondPoint = Dependency[1].RefTransformedPoint3D;
if (index == 0)
{
var secondPoint = Dependency[1].RefTransformedPoint3D;
Dependency[0].RefTransformedPoint3D = new Point3D(projectedPoint);
Dependency[1].RefTransformedPoint3D = secondPoint;
}
if (index == 1)
{
Dependency[1].RefTransformedPoint3D = new Point3D(projectedPoint);
}
var document = Dependency[0].Node.Root.Get <DocumentContextInterpreter>().Document;
var constraintMapper =
new ConstraintDocumentHelper(document,
sketchNode);
constraintMapper.SetMousePosition(Dependency[index].Reference.Index);
var error = constraintMapper.ImpactAndSolve(Dependency[0].Node.Parent);
if (error == 1)
{
Dependency[0].RefTransformedPoint3D = originalFirstPoint;
Dependency[1].RefTransformedPoint3D = originalSecondPoint;
}
}
public override void UpdatePointPosition(int index, Mouse3DPosition vertex)
{
if (SelectedEntity.TargetShape() == null)
{
return;
}
var faceToChangeIndex = 0;
Node nodeToChange = null;
var faceShape = new TopoDSShape();
if (SelectedEntity.Node.Get <FunctionInterpreter>().Name == FunctionNames.Cut)
{
var nb = new NodeBuilder(SelectedEntity.Node);
var affectedShapes = NodeBuilderUtils.GetCutNodeBaseExtrudeNodes(nb).ToList();//nb.Dependency[3];
var clickedPlane = GeomUtils.ExtractPlane(SelectedEntity.TargetShape());
if (clickedPlane == null)
{
return;
}
foreach (var node in affectedShapes)
{
var faces = GeomUtils.ExtractFaces(new NodeBuilder(node).Shape);
int count = 1;
foreach (var face in faces)
{
var direction = GeomUtils.ExtractPlane(face);
if (direction == null)
{
count++;
continue;
}
count++;
if (direction.Axis.Direction.IsParallel(clickedPlane.Axis.Direction, Precision.Confusion))
{
var projectedPnt = GeomUtils.ProjectPointOnPlane(direction.Location, clickedPlane, Precision.Confusion);
if (projectedPnt.IsEqual(direction.Location, Precision.Confusion))
{
faceShape = face;
break;
}
}
}
// if the face matches the clicked plane, count will be > 0 and will hold the face index on the extruded solid
if (count > 0)
{
faceToChangeIndex = count - 1;
nodeToChange = node;
break;
}
}
}
if (SelectedEntity.Node.Get <FunctionInterpreter>().Name == FunctionNames.Extrude)
{
faceToChangeIndex = SelectedEntity.ShapeCount;
nodeToChange = SelectedEntity.Node;
faceShape = SelectedEntity.TargetShape();
}
if (prevFaceCount < 0)
{
prevFaceCount = faceToChangeIndex;
}
if (faceToChangeIndex != prevFaceCount)
{
return;
}
if (nodeToChange == null)
{
return;
}
var distance = 0.0;
var numberOfFaces = GeomUtils.ExtractFaces(new NodeBuilder(nodeToChange).Shape).Count;
if (faceToChangeIndex == numberOfFaces) //top of shape
{
distance = GeomUtils.CalculateDistance(vertex.Point.GpPnt,
new NodeBuilder(nodeToChange).Dependency[0].
ReferenceBuilder.Shape);
var extrudeNb = new NodeBuilder(nodeToChange);
if (Math.Abs(distance) < Precision.Confusion)
{
distance = 0.1;
}
extrudeNb.Dependency[2].Real = distance;
extrudeNb.ExecuteFunction();
}
if (faceToChangeIndex == (numberOfFaces - 1))
{
// bottom of shape - sketch which was extruded
var extrudeNb = new NodeBuilder(nodeToChange);
var extrudeHeight = extrudeNb.Dependency[2].Real;
var baseSketch = extrudeNb.Dependency[0].ReferenceBuilder;
var faces = GeomUtils.ExtractFaces(extrudeNb.Shape);
var topFace = faces[numberOfFaces - 1];
var distanceTopFace = GeomUtils.CalculateDistance(vertex.Point.GpPnt,
topFace);
distance = GeomUtils.CalculateDistance(vertex.Point.GpPnt,
SelectedEntity.TargetShape());
var dirBottomFace = GeomUtils.ExtractDirection(SelectedEntity.TargetShape());
var orientationBottomFace = SelectedEntity.TargetShape().Orientation();
if (orientationBottomFace != TopAbsOrientation.TopAbs_REVERSED)
{
dirBottomFace.Reverse();
}
var bottomFaceGravityCenter = GeomUtils.ExtractGravityCenter(topFace);
var vertexOnDir = TransformationInterpreter.ProjectPointOnLine(bottomFaceGravityCenter,
dirBottomFace, vertex.Point).Value;
var startPointOnDir = TransformationInterpreter.ProjectPointOnLine(bottomFaceGravityCenter,
dirBottomFace, new Point3D(previousMousePosition)).Value;
var vertexvector = new gpVec(startPointOnDir.GpPnt, vertexOnDir.GpPnt);
var normalvector = new gpVec(dirBottomFace);
var isOpposite = false;
try
{
isOpposite = vertexvector.IsOpposite(normalvector, Precision.Angular);
}
catch { return; }
// calculate new height for the solid
var newHeight = 0.0;
if (isOpposite)
{
newHeight = Math.Abs(extrudeHeight) - Math.Abs(distance);
}
else
{
newHeight = Math.Abs(extrudeHeight) + Math.Abs(distance);
}
newHeight *= Math.Sign(extrudeHeight);
var face = SelectedEntity.TargetShape();
if (face == null)
{
return;
}
// calculate the new position for the solid
var transformation = baseSketch.Node.Get <TransformationInterpreter>().CurrTransform;
var locationOld = new gpPnt(0, 0, 0).Transformed(transformation);
var shape = SelectedEntity.TargetShape();
var dir = GeomUtils.ExtractDirection(shape);
var orientation = shape.Orientation();
if (orientation != TopAbsOrientation.TopAbs_REVERSED)
{
dir.Reverse();
}
if (isOpposite)
{
dir.Reverse();
}
var locationNew = new gpPnt
{
X = locationOld.X + dir.X * Math.Abs(distance),
Y = locationOld.Y + dir.Y * Math.Abs(distance),
Z = locationOld.Z + dir.Z * Math.Abs(distance)
};
// set the new transformation for the base sketch
var T = new gpTrsf();
var oldSystemAxis = new gpAx3(new gpPnt(0, 0, 0), new gpDir(0, 0, 1));
var newSystemAxis = new gpAx3(locationNew, dir);
T.SetTransformation(oldSystemAxis, newSystemAxis);
var transformationSet = baseSketch.Node.Set <TransformationInterpreter>();
transformationSet.CurrTransform = T.Inverted;
extrudeNb.Dependency[2].Real = newHeight;
baseSketch.ExecuteFunction();
previousMousePosition = vertex.Point.GpPnt;
}
if (faceToChangeIndex < (numberOfFaces - 1))
{
var shape = faceShape;
var gravityCenter = GeomUtils.ExtractGravityCenter(shape);
var extrudeNb = new NodeBuilder(nodeToChange);
var baseSketch = extrudeNb.Dependency[0].ReferenceBuilder;
var transformation = baseSketch.Node.Get <TransformationInterpreter>().CurrTransform;
var locationSketch = new gpPnt(0, 0, 0).Transformed(transformation);
var directionSketch = new gpDir(0, 0, 1).Transformed(transformation);
var sketchPlane = new gpPln(locationSketch, directionSketch);
var pointOnPlane = new Point3D(GeomUtils.ProjectPointOnPlane(gravityCenter.GpPnt, sketchPlane, Precision.Confusion));
var sketchNodes = NodeUtils.GetSketchNodes(baseSketch.Node, baseSketch.Node.Root.Get <DocumentContextInterpreter>().Document, true);
NodeBuilder draggedLine = null;
foreach (var node in sketchNodes)
{
var nb = new NodeBuilder(node);
if (nb.FunctionName != FunctionNames.LineTwoPoints)
{
continue;
}
var edges = GeomUtils.ExtractEdges(nb.Shape);
if (edges.Count != 1)
{
continue;
}
if (GeomUtils.PointIsOnEdge(edges[0], pointOnPlane))
{
draggedLine = nb;
break;
}
}
if (draggedLine != null)
{
var axisLength = CoreGlobalPreferencesSingleton.Instance.ZoomLevel * 10;
var faceDirection = GeomUtils.ExtractDirection(shape);
var orientation = shape.Orientation();
if (orientation != TopAbsOrientation.TopAbs_REVERSED)
{
faceDirection.Reverse();
}
var vertexOnPlane = new Point3D(GeomUtils.ProjectPointOnPlane(vertex.Point.GpPnt, sketchPlane, Precision.Confusion));
vertexOnPlane.X = (vertexOnPlane.X) * Math.Abs(faceDirection.X);
vertexOnPlane.Y = (vertexOnPlane.Y) * Math.Abs(faceDirection.Y);
vertexOnPlane.Z = (vertexOnPlane.Z) * Math.Abs(faceDirection.Z);
var pointOnPlaneAxis = new Point3D
{
X = pointOnPlane.X * Math.Abs(faceDirection.X),
Y = pointOnPlane.Y * Math.Abs(faceDirection.Y),
Z = pointOnPlane.Z * Math.Abs(faceDirection.Z)
};
var translateValue = vertexOnPlane.SubstractCoordinate(pointOnPlaneAxis);
NodeUtils.TranslateSketchNode(draggedLine, translateValue, baseSketch.Node);
var constraintMapper = new ConstraintDocumentHelper(baseSketch.Node.Root.Get <DocumentContextInterpreter>().Document, baseSketch.Node);
constraintMapper.SetMousePosition(draggedLine.Dependency[0].Reference.Index);
var error = constraintMapper.ImpactAndSolve(draggedLine.Dependency[1].Node.Get <ReferenceInterpreter>().Node);
baseSketch.ExecuteFunction();
extrudeNb.Color = solidColor;
extrudeNb.ExecuteFunction();
}
}
}
private static void ApplyLinesConstraint(ConstraintDocumentHelper mapper, NodeBuilder firstLine,
NodeBuilder secondLine, string constraint)
{
mapper.ApplyConstraint(firstLine.Node, secondLine.Node, constraint);
}
private static void ApplyLineConstraint(ConstraintDocumentHelper mapper, NodeBuilder line,
string constraint)
{
mapper.ApplyConstraint(line.Node, constraint);
}
