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");
}
public override List <SolverPreviewObject> InterestingShapeAroundPoint(gpPln planeOfTheView, Point3D point)
{
var qosLock = QosFactory.Instance.Get(QosNames.HorizontalLineMatchLock);
qosLock.Begin();
foreach (var solverGeometricObject in LastGeometry)
{
foreach (HorizontalLineSolverDataConstraint line in solverGeometricObject.HorizontalLines)
{
var range = _range * CoreGlobalPreferencesSingleton.Instance.ZoomLevel;
if (Math.Abs(point.Y - line.Y) >= range)
{
continue;
}
point.Y = line.Y;
line.Point = point;
return(new List <SolverPreviewObject> {
new SolverPointResult(point)
{
Text = "Horizontal Match"
}
});
}
}
qosLock.End();
return(new List <SolverPreviewObject>());
}
public override List <SolverPreviewObject> InterestingShapeAroundPoint(gpPln planeOfTheView, Point3D point)
{
var qosLock = QosFactory.Instance.Get(QosNames.PlaneMatchLock);
qosLock.Begin();
foreach (var geometricObject in Geometry)
{
foreach (var pln in geometricObject.Planes)
{
var distance = pln.Plane.Distance(point.GpPnt);
var precision = _precision * CoreGlobalPreferencesSingleton.Instance.ZoomLevel;
if (distance >= precision)
{
continue;
}
var plane = new GeomPlane(pln.Plane);
var projectionPoint = new GeomAPIProjectPointOnSurf(point.GpPnt, plane, Precision.Confusion, ExtremaExtAlgo.Extrema_ExtAlgo_Grad);
if (projectionPoint.NbPoints <= 0)
{
continue;
}
return(new List <SolverPreviewObject>()
{
new SolverPointResult(new Point3D(projectionPoint.NearestPoint), pln.ParentIndex)
});
}
}
qosLock.End();
return(new List <SolverPreviewObject>());
}
public void AllocDeallocSimpleTest()
{
//NaroMessage.Show("start test");
//Console.WriteLine("---- wrapper start test ----");
var watch = new Stopwatch();
watch.Start();
for (var i = 0; i < 300000; i++)
{
var pnt = new gpPnt(i, i, i);
var pnt2 = new gpPnt(i + 10, i + 10, i + 10);
var aEdge = new BRepBuilderAPIMakeEdge(pnt, pnt2).Edge;
var wire = new BRepBuilderAPIMakeWire(aEdge).Wire;
TopoDSShape shape = wire;
new AISShape(shape);
var pln = new gpPln(i + 10, i + 10, i + 10, i + 10);
var geomPln = new GeomPlane(pln);
var trsf = new gpTrsf();
geomPln.Transform(trsf);
}
watch.Stop();
//Console.WriteLine("---- wrapper end test - took {0} ms ----", watch.ElapsedMilliseconds);
//NaroMessage.Show(String.Format("---- wrapper end test - took {0} ms ----", watch.ElapsedMilliseconds));
}
public gpPnt2d ToPoint2D(gpAx2 ax2)
{
var pointPlane = new gpPln(new gpAx3(ax2));
var point2D = ProjLib.Project(pointPlane, GpPnt);
return(point2D);
}
public void EdgeContinuationDetectionTest()
{
var plnOfTheView = new gpPln(new gpPnt(0, 0, 0), new gpDir(0, 0, 1));
var document = TestUtils.DefaultsSetup();
var solver = new Solver(document);
document.Transact();
var sketchCreator = new SketchCreator(document, false);
var sketchNode = sketchCreator.BuildSketchNode();
document.Commit("Added sketch");
document.Transact();
// Test parallelism
var linecontinuationMatch = new EdgeContinuationMatch(solver, 5.0 / 180 * Math.PI);
var currentPosition = new Point3D(4.02, 4, 0);
var line = TestUtils.Line(document, sketchNode, new Point3D(1, 1, 0), new Point3D(3, 3, 0));
var result = new SolverGeometricObject(line.Node);
NodeHelper.BuildSolverInfo(result, result.Parent, 0.0872,
true);
solver.Refresh();
var solutions = linecontinuationMatch.InterestingShapeAroundPoint(plnOfTheView, currentPosition);
Assert.AreEqual(solutions.Count, 1);
var solution = solutions.First();
Assert.IsTrue(solution.Point.X - 4.01 < Precision.Confusion, "Invalid X solution");
Assert.IsTrue(solution.Point.Y - 4.01 < Precision.Confusion, "Invalid Y solution");
Assert.IsTrue(solution.Point.Z < Precision.Confusion, "Invalid Z solution");
}
public static gpTrsf ExtractPlaneMirrorTransform(gpPln plane)
{
var transform = new gpTrsf();
transform.SetMirror(plane.Position.Ax2);
return(transform);
}
public List <SolverPreviewObject> GetInterestingCloseGeometry(gpPln planeOfTheView, Point3D currentPoint,
Point3D initialPosition)
{
var result = new List <SolverPreviewObject>();
foreach (var rule in Rules.Values)
{
if (!rule.Enabled)
{
continue;
}
var solveResult = rule.InterestingShapeAroundPoint(planeOfTheView, currentPoint);
if (solveResult != null)
{
//log.Debug("GetInterestingCloseGeometry - add single magic point");
result.AddRange(solveResult);
}
var solveResultInitial = rule.InterestingShapeAroundPoint(planeOfTheView, currentPoint, initialPosition);
if (solveResultInitial == null)
{
continue;
}
result.Add(solveResultInitial);
}
return(result);
}
public void GeometryPerpendicularTest()
{
var plnOfTheView = new gpPln(new gpPnt(0, 0, 0), new gpDir(0, 0, 1));
var document = TestUtils.DefaultsSetup();
var solver = new Solver(document);
document.Transact();
var sketchCreator = new SketchCreator(document, false);
var sketchNode = sketchCreator.BuildSketchNode();
document.Commit("Added sketch");
document.Transact();
// Test parallelism
var perpendicularMatch = new OrthogonalLineMatch(solver, 5.0 / 180 * Math.PI);
var initialPosition = new Point3D(6, 2, 0);
var currentPosition = new Point3D(3.9, 4, 0);
var line = TestUtils.Line(document, sketchNode, new Point3D(1, 1, 0), new Point3D(4, 4, 0));
var result = new SolverGeometricObject(line.Node);
NodeHelper.BuildSolverInfo(result, result.Parent, 0.0872, true);
solver.Refresh();
var solution = perpendicularMatch.InterestingShapeAroundPoint(plnOfTheView, currentPosition, initialPosition);
Assert.IsTrue(solution.Point.X - 3.95 < Precision.Confusion, "Invalid X solution");
Assert.IsTrue(solution.Point.Y - 4.05 < Precision.Confusion, "Invalid Y solution");
Assert.IsTrue(solution.Point.Z < Precision.Confusion, "Invalid Z solution");
}
public void SameXCoordinateMatch()
{
var document = TestUtils.DefaultsSetup();
var solver = new Solver(document);
document.Transact();
var sketchCreator = new SketchCreator(document, false);
var sketchNode = sketchCreator.BuildSketchNode();
document.Commit("Added sketch");
document.Transact();
var point = new SolverGeometricObject(sketchNode);
point.AddPoint(new SolverDataPoint(new Point3D(10, 2, 0)));
solver.Geometry.Add(point);
solver.LastGeometry.Add(point);
var coordinateMatch = new SameCoordinatePoints(solver, 2);
var pointN = new Point3D(10 + 0.1, 20 - 0.1, 0.1);
var plnOfTheView = new gpPln(new gpPnt(0, 0, 0), new gpDir(0, 0, 1));
var solutions = coordinateMatch.InterestingShapeAroundPoint(plnOfTheView, pointN);
Assert.AreEqual(solutions.Count, 1);
var solution = solutions.First();
Assert.IsTrue(solution != null, "A solution should be found");
Assert.IsTrue(solution is SolverEdgeTwoPointsResult, "Invalid solution type");
Assert.IsTrue(solution.Point.IsEqual(new Point3D(10, 19.9, 0)), "Invalid magic point found");
}
public DirectCoordinateMouseEventsPipe(V3dView view)
: base(InputNames.Mouse3DEventsPipe)
{
Plane = new gpPln(new gpAx3());
var wnd = view.Window();
WNTWindow wnt = wnd.Convert <WNTWindow>();
}
public static Point3D Translate(Axis normalOnSketch, Point3D coordinate)
{
var sketchPlane = new gpPln(normalOnSketch.Location.GpPnt,
new gpDir(normalOnSketch.Direction.GpPnt.XYZ));
var projectionPoint = GeomUtils.ProjectPointOnPlane(coordinate.GpPnt, sketchPlane, Precision.Confusion);
return(new Point3D(projectionPoint));
}
protected override void OnNotification(string name, DataPackage dataPackage)
{
switch (name)
{
case NotificationNames.SetPlane:
Plane = dataPackage.Get <gpPln>();
break;
}
}
private bool IfParallelWithPlaneSwitchAction(gpPln plane, gpPln planeToCompare, string actionName)
{
var distance = Math.Abs(plane.Distance(planeToCompare));
if (plane.Position.IsCoplanar(planeToCompare.Position, 1e-6, 1e-5) || distance > 1e-5)
{
ActionsGraph.SwitchAction(actionName);
return(true);
}
return(false);
}
private void PreprocesHeight(gpPln basePlane)
{
if (!(Dependency.Steps[2].Data is Mouse3DPosition))
{
return;
}
var fourthPoint = Dependency.Steps[2].Get <Mouse3DPosition>().Point;
var height = CalculateBoxHeight(basePlane, fourthPoint);
Dependency.Steps[2].Data = height;
}
public void BuildFaceDraftExecutionTest()
{
var box = _testBoxBuilder.Shape;
var draft = new BRepOffsetAPIDraftAngle(box);
var basePlane = new gpPln(new gpPnt(0, 0, 0), new gpDir(0, 0, 1));
Assert.IsTrue(AngleDraftFunction.BuildFaceDraft(draft,
TopoDS.Face(_boxRightFace.TargetShape()),
new gpDir(0, 0, 1), 10, basePlane),
"BuildFaceDraft failed");
}
private void SetSecondPointDraggingHandle(gpVec vectorV2V1, Mouse3DPosition vertex, Point3D secondPoint)
{
if (_secondPointProjectionDirection == null)
{
_secondPointProjectionDirection = new gpDir(vectorV2V1);
}
var secondPointProjectionPlane = new gpPln(vertex.Point.GpPnt, _secondPointProjectionDirection);
var secondProjectedPoint = GeomUtils.ProjectPointOnPlane(secondPoint.GpPnt, secondPointProjectionPlane,
Precision.Confusion);
Dependency[1].TransformedPoint3D = new Point3D(secondProjectedPoint);
Dependency[2].TransformedPoint3D = vertex.Point;
}
public override SolverPreviewObject InterestingShapeAroundPoint(gpPln planeOfTheView, Point3D currentPoint,
Point3D initialPosition)
{
if (currentPoint.IsEqual(initialPosition))
{
return(null);
}
var qosLock = QosFactory.Instance.Get(QosNames.ParallelLineLock);
qosLock.Begin();
var vec = new gpVec(initialPosition.GpPnt, currentPoint.GpPnt);
foreach (var solverGeometricObject in Geometry)
{
if (solverGeometricObject.ParallelAxis.Count == 0)
{
continue;
}
foreach (var axis in solverGeometricObject.ParallelAxis)
{
if (vec.IsNormal(axis.Vector, _precision))
{
var planeNormal = vec.Crossed(axis.Vector);
var planeNormalAxis = new gpAx1(initialPosition.GpPnt, new gpDir(planeNormal));
gpVec v2 = axis.Vector.Normalized;
v2.Rotate(planeNormalAxis, Math.PI / 2.0);
var parallelLine = new gceMakeLin(initialPosition.GpPnt, new gpDir(v2)).Value;
var geomLine = new GeomLine(parallelLine);
var projectionPoint = new GeomAPIProjectPointOnCurve(currentPoint.GpPnt, geomLine);
if (projectionPoint.NbPoints <= 0)
{
return(null);
}
var secondPoint = new Point3D(projectionPoint.NearestPoint);
var solverPoint = new SolverEdgeTwoPointsResult(secondPoint, initialPosition, Color.Black)
{
Type = "Perpendicular Line"
};
return(solverPoint);
}
}
}
qosLock.End();
return(null);
}
public void XYCoordinatesMatch()
{
var document = TestUtils.DefaultsSetup();
var solver = new Solver(document);
document.Transact();
var sketchCreator = new SketchCreator(document, false);
var sketchNode = sketchCreator.BuildSketchNode();
document.Commit("Added sketch");
document.Transact();
var point = new SolverGeometricObject(sketchNode);
point.AddPoint(new SolverDataPoint(new Point3D(4, 11, 0)));
solver.Geometry.Add(point);
solver.LastGeometry.Add(point);
var interestingPoints = new List <SolverPreviewObject>();
var pointN = new Point3D(3.9, 2.9, 0.1);
var plnOfTheView = new gpPln(new gpPnt(0, 0, 0), new gpDir(0, 0, 1));
var coordinateMatch = new SameCoordinatePoints(solver, 2);
var solutions = coordinateMatch.InterestingShapeAroundPoint(plnOfTheView, pointN);
Assert.AreEqual(solutions.Count, 1);
var solution = solutions.First();
Assert.IsTrue(solution != null, "A solution should be found");
Assert.IsTrue(solution is SolverEdgeTwoPointsResult, "Invalid solution type");
interestingPoints.Add(solution);
point = new SolverGeometricObject(sketchNode);
point.AddPoint(new SolverDataPoint(new Point3D(10, 3, 0)));
solver.Geometry.Clear();
solver.LastGeometry.Clear();
solver.Geometry.Add(point);
solver.LastGeometry.Add(point);
coordinateMatch = new SameCoordinatePoints(solver, 2);
solutions = coordinateMatch.InterestingShapeAroundPoint(plnOfTheView, pointN);
Assert.AreEqual(solutions.Count, 1);
solution = solutions.First();
interestingPoints.Add(solution);
Assert.IsTrue(solution != null, "A solution should be found");
Assert.IsTrue(solution is SolverEdgeTwoPointsResult, "Invalid solution type");
var results = SolverTestsUtils.GetIntersectionPoints(interestingPoints, document);
Assert.AreEqual(results.Count, 1, "Wrong number of intersection results!");
Assert.IsTrue(results[0].IsEqual(new Point3D(4, 3, 0)), "Invalid magic point found");
}
public Point3D?Project(Point3D point)
{
var normalOnSketch = NormalOnSketch;
if (normalOnSketch == null)
{
return(null);
}
var normalTransformation = CurrentSketch.Get <TransformationInterpreter>().CurrTransform;
var transformedNormal = normalOnSketch.Value.GpAxis.Transformed(normalTransformation);
var sketchPlane = new gpPln(transformedNormal.Location, transformedNormal.Direction);
var projectedPoint = GeomUtils.ProjectPointOnPlane(point.GpPnt, sketchPlane, Precision.Confusion);
return(new Point3D(projectedPoint));
}
private static gpPln BuildNormalPlane(gpDir dir, Axis gravityAxis)
{
var gravityCenter = gravityAxis.Location;
var plane = new gpPln(gravityCenter.GpPnt, dir);
var newPoint = gravityCenter;
newPoint.X += 1;
newPoint.Y += 2;
newPoint.Z += 3;
var result = GeomUtils.ProjectPointOnPlane(newPoint.GpPnt, plane, Precision.Confusion);
var resultPlane = GeomUtils.BuildPlane(gravityCenter, new Point3D(result),
gravityAxis.Location.AddCoordinate(gravityAxis.Direction));
return(resultPlane);
}
public override SolverPreviewObject InterestingShapeAroundPoint(gpPln planeOfTheView, Point3D currentPoint,
Point3D initialPosition)
{
if (currentPoint.IsEqual(initialPosition))
{
return(null);
}
var result = AxisParallel(currentPoint, initialPosition);
if (result == null)
{
return(null);
}
result.Text = "";
return(result);
}
public override bool Execute()
{
var draftedShape = Dependency[0].ReferedShape;
var draftedFace = TopoDS.Face(Dependency[0].ReferenceData.TargetShape());
var draftReferenceShape = Dependency[1].ReferenceData.TargetShape();
Ensure.IsTrue(draftReferenceShape.ShapeType == TopAbsShapeEnum.TopAbs_FACE);
var draftReferenceFace = TopoDS.Face(draftReferenceShape);
var draftDirection = GeomUtils.ExtractDirection(draftReferenceFace).Reversed;
var angle = Dependency[3].Real;
if (Math.Abs(angle) < Precision.Angular)
{
return(false);
}
var neutralPlaneNormal = Dependency[2].Axis3D.GpAxis;
var neutralPlane = new gpPln(neutralPlaneNormal.Location, neutralPlaneNormal.Direction);
var draft = new BRepOffsetAPIDraftAngle(draftedShape);
var draftSuceeded = BuildFaceDraft(draft, draftedFace, draftDirection, angle, neutralPlane);
if (!draftSuceeded)
{
return(false);
}
draft.Build();
if (!draft.IsDone)
{
return(false);
}
if (draft.Status != DraftErrorStatus.Draft_NoError)
{
return(false);
}
var refNode = Dependency[0].Reference;
NodeUtils.Hide(refNode);
Shape = draft.Shape;
return(true);
}
private void MouseMoveHandler(Mouse3DPosition mousePosition)
{
_context.MoveTo(mousePosition.Initial2Dx, mousePosition.Initial2Dy, ViewItems.View);
if (!Enabled)
{
return;
}
if (mousePosition.MouseDown == false)
{
return;
}
Inputs[InputNames.GeometricSolverPipe].Send(NotificationNames.DisableAll);
Inputs[InputNames.GeometricSolverPipe].Send(NotificationNames.Enable, SolverRuleNames.EdgeMatch);
Inputs[InputNames.GeometricSolverPipe].Send(NotificationNames.Enable, SolverRuleNames.PlaneMatch);
var solverPipe = Inputs[InputNames.GeometricSolverPipe];
var eventsPipePlane = Inputs[InputNames.Mouse3DEventsPipe].GetData(NotificationNames.GetPlane);
viewPlane = new gpPln();
if (eventsPipePlane.Data == null)
{
viewPlane = GeomUtils.PlaneOfTheView(ViewItems.View);
}
else
{
viewPlane = (gpPln)eventsPipePlane.Data;
}
if (_selectionContainer.Entities.Count == 1 && _selectionContainer.Entities[0].ShapeType == TopAbsShapeEnum.TopAbs_FACE)
{
return;
}
DrawSelectionRectangle(new gpAx2(viewPlane.Axis.Location, viewPlane.Axis.Direction), startPoint, mousePosition.Point);
var geometricSolver = solverPipe.GetData(NotificationNames.GetSolver).Get <GeometricSolver>();
var results = geometricSolver.GetInterestingCloseGeometry(viewPlane, mousePosition.Point);
foreach (var result in results)
{
var solverPointResult = result as SolverPointResult;
if (solverPointResult != null && !selectedNodesIndexes.Contains((solverPointResult).ParentIndex))
{
selectedNodesIndexes.Add((solverPointResult).ParentIndex);
}
}
}
private void BoxHeight(bool updateShape)
{
var axis = Dependency.Steps[0].Get <gpAx1>();
var secondPoint = Dependency.Steps[1].Get <Point3D>();
var basePoint = axis.Location;
var excludedPlane = new gpPln(basePoint, axis.Direction);
// Prevent the mouse from generating point on the base
Dependency.Inputs.Inputs[InputNames.Mouse3DEventsPipe].Send(NotificationNames.ExcludedPlane, excludedPlane);
// After the base is drawn disable the face picker
Dependency.Inputs.Inputs[InputNames.FacePickerPlane].Send(NotificationNames.Suspend);
PreprocesHeight(excludedPlane);
var height = Dependency.Steps[2].Get <double>();
BoxAnimation(axis, height, secondPoint);
}
public List <SolverPreviewObject> GetInterestingCloseGeometry(gpPln planeOfTheView, Point3D coordinate)
{
var result = new List <SolverPreviewObject>();
foreach (var rule in Rules.Values)
{
if (!rule.Enabled)
{
continue;
}
var solverResult = rule.InterestingShapeAroundPoint(planeOfTheView, coordinate);
if (solverResult != null)
{
result.AddRange(solverResult);
}
}
return(result);
}
private static void InitializeGeometry(ICollection <SolverGeometricObject> geometry)
{
var document = TestUtils.DefaultsSetup();
// Make a rectangle
var rectObject = new SolverGeometricObject(null);
rectObject.Points.Add(new SolverDataPoint(new Point3D(0, 0, 0), GeometryType.EndPoint));
rectObject.Points.Add(new SolverDataPoint(new Point3D(0, 0, 100), GeometryType.EndPoint));
rectObject.Points.Add(new SolverDataPoint(new Point3D(100, 0, 0), GeometryType.EndPoint));
rectObject.Points.Add(new SolverDataPoint(new Point3D(100, 0, 100), GeometryType.EndPoint));
var pln = new gpPln(new gpPnt(0, 0, 0), new gpDir(0, 1, 0));
var plane = new SolverPlane(pln);
rectObject.Planes.Add(plane);
geometry.Add(rectObject);
}
public static bool BuildFaceDraft(BRepOffsetAPIDraftAngle draft, TopoDSFace draftedFace,
gpDir draftDirection, double angle, gpPln neutralPlane)
{
try
{
draft.Add(draftedFace, draftDirection, angle, neutralPlane, true);
if (!draft.AddDone)
{
//draft.Remove(draftedFace);
return(false);
}
}
catch (Exception)
{
return(false);
}
return(true);
}
protected override void OnNotification(string name, DataPackage dataPackage)
{
switch (name)
{
case NotificationNames.SetFace:
SelectedItem = dataPackage.Get <SelectionInfo>();
break;
case NotificationNames.SetPlane:
if (_ignorePlanes)
{
return;
}
Plane = dataPackage.Get <gpPln>();
break;
case NotificationNames.ExcludedPlane:
if (_ignorePlanes)
{
return;
}
ExcludedPlane = dataPackage.Get <gpPln>();
break;
case NotificationNames.GetPlane:
ReturnData = new DataPackage(Plane);
break;
case NotificationNames.GetFace:
ReturnData = new DataPackage(SelectedItem);
break;
case NotificationNames.Suspend:
_ignorePlanes = true;
break;
case NotificationNames.Resume:
_ignorePlanes = false;
break;
}
}
public Node CreateDefaultSketchNode(Document Document)
{
var sketchBuilder = new SketchCreator(Document);
//var testSketch = sketchBuilder.Project(new Point3D(0, 0, 0));
//if (testSketch == null)
//{
// BackToNeutralModifier();
// return null;
//}
//normalOnPlane = sketchBuilder.NormalOnSketch.Value.GpAxis;
//var trsf = sketchBuilder.CurrentSketch.Get<TransformationInterpreter>().CurrTransform;
//normalOnPlane = normalOnPlane.Transformed(trsf);
var sketchNode = sketchBuilder.CurrentSketch;
var plane = new gpPln(new gpAx3());
Inputs[InputNames.Mouse3DEventsPipe].Send(NotificationNames.SetPlane, plane);
AddNodeToTree(sketchNode);
Document.Commit("Created default sketch plane");
return(sketchNode);
}
