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);
}
public override gpAx2 GetPointLocation(int index)
{
var ax2 = new gpAx2();
var axis = new gpAx1();
var point = new gpPnt();
var transform = NodeBuilderUtils.GetGlobalTransformation(new NodeBuilder(NodeBuilderUtils.FindSketchNode(Node)));
point = Dependency[0].Name == InterpreterNames.Reference ? Dependency[index].RefTransformedPoint3D.GpPnt : Dependency[index].TransformedPoint3D.GpPnt;
axis.Location = (point);
axis.Direction = axis.Direction.Transformed(transform);
ax2.Axis = (axis);
return(ax2);
}
private void ListBoxOnKeyDown(object sender, KeyEventArgs keyEventArgs)
{
if (((ListBox)sender).SelectedItems.Count > 0 && keyEventArgs.Key == Key.Delete)
{
var selectedItem = ((ListBox)sender).SelectedItems[0];
var node = ((ConstraintInfo)((ListBox)sender).SelectedItems[0]).ConstraintNode.Node;
var document = NodeBuilderUtils.FindSketchNode(node).Root.Get <DocumentContextInterpreter>().Document;
NodeBuilderUtils.DeleteConstraintNode(document, node);
UpdateFieldValue();
keyEventArgs.Handled = true;
}
}
private void HighlightCurrentSketchNodes(Node currentSketch)
{
var results = new List <NodeBuilder>();
results.AddRange(from node in Document.Root.ChildrenList
let builder = new NodeBuilder(node)
where FunctionNames.GetSketchShapes().Contains(builder.FunctionName)
select builder);
foreach (var nodeBuilder in results)
{
var sketchNode = NodeBuilderUtils.FindSketchNode(nodeBuilder.Node);
nodeBuilder.Color = sketchNode.Index == currentSketch.Index? Color.DarkTurquoise : Color.Gray;
}
}
private void MakeArrayPattern(int rows, int columns, double rowDistance, double colomnsDistance, int reverseRows,
int reverseColomns, bool previewMode)
{
var indexColomns = 1;
Document document = null;
var sketchNodes = new List <Node>();
for (var indexRows = 0; indexRows < rows; indexRows++)
{
for (; indexColomns < columns; indexColomns++)
{
var affectedPoints = NodeBuilderUtils.CopyPaste(_selectedNodes[0]);
foreach (var child in affectedPoints)
{
var node = NodeBuilderUtils.FindSketchNode(child);
var transformInterpreter = child.Set <TransformationInterpreter>();
transformInterpreter.ApplyGeneralArrayPattern(_axis, _ColumnAxis,
indexRows * rowDistance * reverseRows,
indexColomns * colomnsDistance * reverseColomns);
if (node != null)
{
sketchNodes.Add(node);
}
var nb = new NodeBuilder(child);
nb.ExecuteFunction();
}
}
indexColomns = 0;
}
if (sketchNodes.Count > 0)
{
document = sketchNodes[0].Root.Get <DocumentContextInterpreter>().Document;
int shapeIndex = 0;
foreach (var sketchNode in sketchNodes)
{
if (NodeUtils.SketchHas3DApplied(document, sketchNode, out shapeIndex))
{
sketchNode.Children[2].Set <MeshTopoShapeInterpreter>().Shape = AutoGroupLogic.RebuildSketchFace(sketchNode, document);
}
}
}
if (!previewMode)
{
CommitFinal("Apply Array Pattern");
UpdateView();
RebuildTreeView();
}
}
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;
}
private void MakeCircularPattern(int number, double angle, double heigth, int reverse, bool previewMode)
{
var sketchNodes = new List <Node>();
for (var index = 1; index < number; index++)
{
var affectedPoints = NodeBuilderUtils.CopyPaste(_selectedNodes[0]);
foreach (var child in affectedPoints)
{
var node = NodeBuilderUtils.FindSketchNode(child);
var transformInterpreter = child.Get <TransformationInterpreter>();
transformInterpreter.ApplyGeneralCircularPattern(_axis, index * angle, index * heigth * reverse);
if (node != null)
{
sketchNodes.Add(node);
}
var nb = new NodeBuilder(child);
nb.ExecuteFunction();
}
}
if (sketchNodes.Count > 0)
{
var document = sketchNodes[0].Root.Get <DocumentContextInterpreter>().Document;
int shapeIndex = 0;
foreach (var sketchNode in sketchNodes)
{
if (NodeUtils.SketchHas3DApplied(document, sketchNode, out shapeIndex))
{
sketchNode.Children[2].Set <MeshTopoShapeInterpreter>().Shape = AutoGroupLogic.RebuildSketchFace(sketchNode, document);
}
}
}
if (!previewMode)
{
CommitFinal("Apply Circular Pattern");
UpdateView();
RebuildTreeView();
}
}
public override gpAx2 GetPointLocation(int index)
{
//var transform = Node.Get<TransformationInterpreter>().CurrTransform;
var transform = NodeBuilderUtils.GetGlobalTransformation(new NodeBuilder(NodeBuilderUtils.FindSketchNode(Node)));
var ax2 = new gpAx2();
var centerAxis = new gpAx1();
if (Dependency[0].Name == InterpreterNames.Reference)
{
var circleLocation = Dependency[0].RefTransformedPoint3D.GpPnt;
var pointBuilder = Dependency[0].ReferenceBuilder;
var circleNormal = pointBuilder[0].Reference.Children[1].Get <Axis3DInterpreter>().Axis.Direction;
centerAxis = new gpAx1(circleLocation, new gpDir(circleNormal.GpPnt.XYZ).Transformed(transform));
ax2.Axis = (centerAxis);
}
if (Dependency[0].Name == InterpreterNames.Axis3D)
{
centerAxis = Dependency[0].TransformedAxis3D;
ax2.Axis = (centerAxis);
}
var circleCenter = centerAxis;
var pointOnCircle = GetPointOnCircle(centerAxis, Dependency[1].Real, transform);
var radius = pointOnCircle.Distance(circleCenter.Location);
var leftArrowVector = new gpVec(circleCenter.Location, pointOnCircle);
leftArrowVector.Normalize();
leftArrowVector.Multiply(radius + DistanceToObject);
var leftArrowLocation = circleCenter.Location.Translated(leftArrowVector);
var rightArrowVector = leftArrowVector.Reversed;
var rightArrowLocation = circleCenter.Location.Translated(rightArrowVector);
var topArrowVector = new gpVec(leftArrowVector.XYZ);
topArrowVector.Cross(new gpVec(ax2.Direction));
topArrowVector.Normalize();
topArrowVector.Multiply(radius + DistanceToObject);
var topArrowLocation = circleCenter.Location.Translated(topArrowVector);
var bottomArrowVector = topArrowVector.Reversed;
var bottomArrowLocation = circleCenter.Location.Translated(bottomArrowVector);
switch (index)
{
case 0:
ax2.Location = (leftArrowLocation);
ax2.XDirection = (new gpDir(leftArrowVector));
return(ax2);
case 1:
ax2.Location = (topArrowLocation);
ax2.XDirection = (new gpDir(topArrowVector));
return(ax2);
case 2:
ax2.Location = (rightArrowLocation);
ax2.XDirection = (new gpDir(rightArrowVector));
return(ax2);
case 3:
ax2.Location = (bottomArrowLocation);
ax2.XDirection = (new gpDir(bottomArrowVector));
return(ax2);
default:
return(null);
}
}
public override bool Execute()
{
var axis = Dependency[1].ReferedShape;
var angle = Dependency[2].Real / 180.0 * Math.PI;
var revolvedNode = Dependency[0].ReferenceBuilder.Node;
TopoDSShape originalShape = Dependency[0].ReferedShape;
var sketchShapes = new List <Node>();
var nodesOnSketch = new List <Node>();
var sketchNode = NodeBuilderUtils.FindSketchNode(revolvedNode);
var document = sketchNode.Root.Get <DocumentContextInterpreter>().Document;
nodesOnSketch.AddRange(NodeUtils.GetSketchNodes(sketchNode, document, true));
if (revolvedNode.Get <FunctionInterpreter>().Name == FunctionNames.Sketch)
{
var face = revolvedNode.Children[2].Get <MeshTopoShapeInterpreter>().Shape;
originalShape = AutoGroupLogic.RebuildFaces(face);
}
else
{
foreach (var node in nodesOnSketch)
{
if (node.Get <FunctionInterpreter>().Name != FunctionNames.Point && node.Index != Dependency[1].ReferenceBuilder.Node.Index)
{
sketchShapes.Add(node);
}
}
}
if (sketchShapes.Count > 0)
{
var shapes = new List <TopoDSShape>();
foreach (var node in sketchShapes)
{
var nb = new NodeBuilder(node);
var tempShape = MakeRevolve(axis, nb.Shape, angle);
if (tempShape != null)
{
shapes.Add(tempShape);
}
}
TopoDSShape finalShape = null;
if (shapes.Count > 0)
{
finalShape = shapes[0];
for (int i = 1; i < shapes.Count; i++)
{
if (shapes[i] == null)
{
continue;
}
var sew = new BRepBuilderAPISewing(1.0e-06, true, true, true, false);
sew.Add(finalShape);
sew.Add(shapes[i]);
var messg = new MessageProgressIndicator();
sew.Perform(messg);
finalShape = sew.SewedShape;
}
Shape = finalShape;
foreach (var node in nodesOnSketch)
{
NodeUtils.Hide(node);
}
return(true);
}
}
if (originalShape == null)
{
return(false);
}
Shape = MakeRevolve(axis, originalShape, angle);
if (Shape == null)
{
return(false);
}
// Hide the referenece shape
//NodeUtils.Hide(Dependency[0].Reference);
foreach (var node in nodesOnSketch)
{
NodeUtils.Hide(node);
}
return(true);
}
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 gpAx2 GetPointLocation(int index)
{
var transform = NodeBuilderUtils.GetGlobalTransformation(new NodeBuilder(NodeBuilderUtils.FindSketchNode(Node)));
var nodeAxis = Dependency[0].ReferenceBuilder[0].ReferenceBuilder[0].Node;
var sketchAxis = nodeAxis.Get <Axis3DInterpreter>().Axis.GpAxis;
sketchAxis.Direction = sketchAxis.Direction.Transformed(transform);
var ax2 = new gpAx2();
if (index == 0)
{
sketchAxis.Location = (Dependency[0].RefTransformedPoint3D.GpPnt);
ax2.Axis = (sketchAxis);
return(ax2);
}
if (index == 1)
{
sketchAxis.Location = (Dependency[1].RefTransformedPoint3D.GpPnt);
ax2.Axis = (sketchAxis);
return(ax2);
}
return(null);
}
public override void UpdatePointPosition(int index, Mouse3DPosition vertex)
{
var transform = NodeBuilderUtils.GetGlobalTransformation(new NodeBuilder(NodeBuilderUtils.FindSketchNode(Node)));
var pointBuilder2 = Dependency[0].ReferenceBuilder;
var arcNormal = pointBuilder2[0].Reference.Children[1].Get <Axis3DInterpreter>().Axis;
var circleLocation = Dependency[0].RefTransformedPoint3D.GpPnt;
var projection = GeomUtils.ProjectPointOnArc(new gpAx1(circleLocation, new gpDir(arcNormal.Direction.GpPnt.XYZ).Transformed(transform)),
Dependency[1].RefTransformedPoint3D, vertex.Point, vertex.Point,
true);
if (projection != null)
{
Dependency[index].RefTransformedPoint3D = new Point3D(projection);
}
//ArcMetaAction.ArcAnimation(_gizmoDocument, Dependency[0].TransformedAxis3D, Dependency[1].TransformedPoint3D, Dependency[2].TransformedPoint3D);
}
public override gpAx2 GetPointLocation(int index)
{
if (index < 0 || index > 2)
{
return(null);
}
var ax2 = new gpAx2();
var transform = NodeBuilderUtils.GetGlobalTransformation(new NodeBuilder(NodeBuilderUtils.FindSketchNode(Node)));
var arcLocation = Dependency[index].RefTransformedPoint3D.GpPnt;
var pointBuilder = Dependency[0].ReferenceBuilder;
var arcNormal = pointBuilder[0].Reference.Children[1].Get <Axis3DInterpreter>().Axis.Direction;
ax2.Axis = new gpAx1(arcLocation, new gpDir(arcNormal.GpPnt.XYZ).Transformed(transform));
return(ax2);
}
