/// <summary>
/// Receives click events. Called at mouse down and at mouse up.
/// </summary>
/// <param name = "mouseData"></param>
protected override void OnMouseClick3DAction(Mouse3DPosition mouseData)
{
if (Document == null)
{
return;
}
var entities =
Inputs[InputNames.SelectionContainerPipe].GetData(NotificationNames.GetEntities).Get
<List <SceneSelectedEntity> >();
// At mouse down pick the selected edge
if (!mouseData.MouseDown)
{
return;
}
// Store the mouse coordinate used to calculate the extrusion height
Log.Info("Direction - shown");
InitSession();
var selectedNodes = entities;
if (selectedNodes.Count != 1)
{
return;
}
_currentSelectedEntity = selectedNodes[0];
// If click on the same shape reverse the face direction
var reverseFace = false;
if ((_previousSelectedEntity != null) && (_previousSelectedEntity.Node == _currentSelectedEntity.Node))
{
reverseFace = true;
}
_previousSelectedEntity = _currentSelectedEntity;
// If no selected node
if ((_currentSelectedEntity == null) || (_currentSelectedEntity.ShapeType != TopAbsShapeEnum.TopAbs_FACE))
{
return;
}
ExitFaceSelectionMode();
var topoFace =
GeomUtils.ExtractShapeType(_currentSelectedEntity.Node.Get <TopoDsShapeInterpreter>().Shape,
_currentSelectedEntity.ShapeType,
_currentSelectedEntity.ShapeCount);
var face = TopoDS.Face(topoFace);
if (reverseFace)
{
ReverseFaceDirection(face);
}
ShowFaceDirection(face);
// Prepare for a new direction
Reset();
}
//--------------------------------------------------------------------------------------------------
public static List <TopoDS_Face> Faces(this TopoDS_Shape shape, bool distinct = true)
{
Debug.Assert(shape != null);
var faces = new List <TopoDS_Face>();
var exp = new TopExp_Explorer(shape, TopAbs_ShapeEnum.TopAbs_FACE, TopAbs_ShapeEnum.TopAbs_SHAPE);
while (exp.More())
{
var face = TopoDS.Face(exp.Current());
exp.Next();
if (distinct)
{
var otherIndex = faces.FindIndex(e => e.IsSame(face));
if (otherIndex >= 0)
{
if (faces[otherIndex].Orientation() == TopAbs_Orientation.TopAbs_REVERSED &&
face.Orientation() == TopAbs_Orientation.TopAbs_FORWARD)
{
// Replace with forward face, this is prefered
faces[otherIndex] = face;
}
// Edge already present or replaced, skip adding
continue;
}
}
faces.Add(face);
}
return(faces);
}
//--------------------------------------------------------------------------------------------------
void _OnActionFinished(ToolAction toolAction)
{
bool finished = false;
var selectAction = toolAction as SelectSubshapeAction;
Debug.Assert(selectAction != null);
if (selectAction.SelectedSubshapeType == SubshapeTypes.Face)
{
var face = TopoDS.Face(selectAction.SelectedSubshape);
var brepAdaptor = new BRepAdaptor_Surface(face, true);
if (brepAdaptor.GetGeomType() != GeomAbs_SurfaceType.GeomAbs_Plane)
{
StatusText = "Selected face is not a plane type surface.";
}
else
{
selectAction.Stop();
Stop();
finished = true;
FaceAlgo.GetCenteredPlaneFromFace(face, out _Plane);
CreateSketch();
}
}
if (!finished)
{
selectAction.Reset();
}
WorkspaceController.Invalidate();
}
public static void DisplayTemporaryDimension(Document animationDocument, Node extrusion, bool enableSelection)
{
var subShape = new NodeBuilder(animationDocument, FunctionNames.SubShape);
subShape[0].Reference = extrusion;
subShape[1].Integer = 1;
subShape[2].Integer = (int)TopAbsShapeEnum.TopAbs_EDGE;
subShape.ExecuteFunction();
if (subShape.Shape == null)
{
return;
}
var edge = TopoDS.Edge(subShape.Shape);
var pnt = new Point3D();
var computedPoint = GeomUtils.CalculateEdgeMidPoint(edge);
if (computedPoint != null)
{
pnt = (Point3D)computedPoint;
}
var dimension = new NodeBuilder(animationDocument, FunctionNames.Dimension);
dimension[0].Reference = subShape.Node;
dimension[1].TransformedPoint3D = pnt;
dimension.EnableSelection = enableSelection;
dimension.ExecuteFunction();
subShape.Visibility = ObjectVisibility.Hidden;
}
//--------------------------------------------------------------------------------------------------
public static List <TopoDS_Edge> Edges(this TopoDS_Shape shape, bool distinct = true)
{
var edges = new List <TopoDS_Edge>();
var exp = new TopExp_Explorer(shape, TopAbs_ShapeEnum.TopAbs_EDGE, TopAbs_ShapeEnum.TopAbs_SHAPE);
while (exp.More())
{
var edge = TopoDS.Edge(exp.Current());
exp.Next();
if (distinct)
{
var otherEdgeIndex = edges.FindIndex(e => e.IsSame(edge));
if (otherEdgeIndex >= 0)
{
if (edges[otherEdgeIndex].Orientation() == TopAbs_Orientation.TopAbs_REVERSED &&
edge.Orientation() == TopAbs_Orientation.TopAbs_FORWARD)
{
// Replace with forward edge, this is prefered
edges[otherEdgeIndex] = edge;
}
// Edge already present or replaced, skip adding
continue;
}
}
edges.Add(edge);
}
return(edges);
}
private static void AddFaceFilletVertex(TopoDSShape face, int filletChamferType, double radius,
SceneSelectedEntity firstEntity, SceneSelectedEntity secondEntity,
BRepFilletAPIMakeFillet2d fillet)
{
var firstWire = GeomUtils.ExtractShapeType(face, firstEntity.ShapeType, firstEntity.ShapeCount);
var secondWire = GeomUtils.ExtractShapeType(face, secondEntity.ShapeType, secondEntity.ShapeCount);
var listOfCommonVertex = GeomUtils.CommonVertexes(firstWire, secondWire);
if (listOfCommonVertex.Count >= 1)
{
// If operation type is fillet
if (filletChamferType == (int)FilletChamferTypes.SimpleFillet2D)
{
foreach (var vertex in listOfCommonVertex)
{
fillet.AddFillet(vertex, radius);
}
}
else
{
// If operation type is chamfer
fillet.AddChamfer(TopoDS.Edge(firstWire), listOfCommonVertex[0], radius,
GeomUtils.DegreesToRadians(45));
}
}
else
{
return;
}
return;
}
private void DetectFaceUnderMouse(DataPackage data)
{
if (InteractiveWorkSuspended)
{
return;
}
var mousePosition = data.Get <Mouse3DPosition>();
Inputs[InputNames.SelectionContainerPipe].Send(NotificationNames.BuildSelections, mousePosition);
var selectedEntities =
Inputs[InputNames.SelectionContainerPipe].GetData(NotificationNames.GetEntities).Get
<List <SceneSelectedEntity> >();
if (selectedEntities.Count <= 0)
{
Face = null;
return;
}
var shape = selectedEntities[0].TargetShape();
if (shape == null)
{
Face = null;
return;
}
if (shape.ShapeType == TopAbsShapeEnum.TopAbs_FACE)
{
Face = TopoDS.Face(shape);
}
var container =
Inputs[InputNames.SelectionContainerPipe].GetData(NotificationNames.GetContainer).Get
<SelectionContainer>();
// BuildDragAxis(container.Document, shape, 1);
}
public static TriangleMesh Process(TopoDSShape shapeFused)
{
var result = new TriangleMesh();
var builder = new BRepBuilder();
var comp = new TopoDSCompound();
builder.MakeCompound(comp);
BRepMesh.Mesh(shapeFused, 1);
var ex = new TopExpExplorer(shapeFused,
TopAbsShapeEnum.TopAbs_FACE,
TopAbsShapeEnum.TopAbs_SHAPE);
while (ex.More)
{
var shapeResult = new TriangleMesh();
var face = TopoDS.Face(ex.Current);
var location = new TopLocLocation();
var facing = BRepTool.Triangulation(face, location);
var tab = new TColgpArray1OfPnt(1, facing.NbNodes);
// facing.Nodes(tab);
var tri = new PolyArray1OfTriangle(1, facing.NbTriangles);
// facing.Triangles(tri);
var triCount = facing.NbTriangles;
var listPoints = new List <Point3D>();
for (var i = 1; i <= triCount; i++)
{
var trian = tri.Value(i);
int index1 = 0, index2 = 0, index3 = 0;
trian.Get(ref index1, ref index2, ref index3);
var firstPoint = new Point3D(tab.Value(index1));
var secondPoint = new Point3D(tab.Value(index2));
var thirdPoint = new Point3D(tab.Value(index3));
listPoints.Add(firstPoint);
listPoints.Add(secondPoint);
listPoints.Add(thirdPoint);
}
shapeResult.Points.Clear();
foreach (var point in listPoints)
{
shapeResult.Points.Add(point);
}
shapeResult.Points = GeomUtils.SortAndCompactListPoints(shapeResult.Points);
var triangleIndex = 0;
var triangleArray = new int[3];
foreach (var point in listPoints)
{
triangleArray[triangleIndex] = shapeResult.ComputePointId(point);
triangleIndex = (triangleIndex + 1) % 3;
if (triangleIndex == 0)
{
shapeResult.AddTriangle(triangleArray);
}
}
ex.Next();
result = result.Combine(shapeResult);
}
return(result);
}
public static void DisplayTemporaryDimension(Document animationDocument, Node baseNode, Node extrusion, Mouse3DPosition mouseData, bool enableSelection)
{
var subShape = new NodeBuilder(animationDocument, FunctionNames.SubShape);
subShape[0].Reference = extrusion;
subShape[1].Integer = 1;
subShape[2].Integer = (int)TopAbsShapeEnum.TopAbs_EDGE;
subShape.ExecuteFunction();
if (subShape.Shape == null)
{
return;
}
var edge = TopoDS.Edge(subShape.Shape);
var baseNodeBuilder = new NodeBuilder(baseNode);
var gravityCenter = GeomUtils.ExtractGravityCenter(baseNodeBuilder.Shape);
var firstPoint = new Point3D();
var firstPointCalculated = GeomUtils.CalculateEdgeFirstPoint(edge);
if (firstPointCalculated != null)
{
firstPoint = (Point3D)firstPointCalculated;
}
var secondPoint = new Point3D();
var secondPointCalculated = GeomUtils.CalculateEdgeLastPoint(edge);
if (secondPointCalculated != null)
{
secondPoint = (Point3D)secondPointCalculated;
}
var middlePoint = GeomUtils.ComputeMidPoint(firstPoint, secondPoint);
// Translate the dimenion text at some distance from the extrude
var vector = new gpVec(firstPoint.GpPnt, gravityCenter.GpPnt);
vector.Reverse();
vector.Normalize();
vector.Multiply(2);
middlePoint = GeomUtils.BuildTranslation(middlePoint, vector);
subShape.Visibility = ObjectVisibility.Hidden;
// Build a distance dimension just for animation purposes
var animationBuilder = new NodeBuilder(animationDocument, FunctionNames.PointsDimension);
animationBuilder[0].TransformedPoint3D = firstPoint;
animationBuilder[1].TransformedPoint3D = secondPoint;
animationBuilder[2].TransformedPoint3D = middlePoint;
animationBuilder[3].Integer = (int)DsgPrsArrowSide.DsgPrs_AS_FIRSTPT_LASTAR;
animationBuilder[4].Real = 1;
animationBuilder.EnableSelection = false;
animationBuilder.Color = Color.Black;
animationBuilder.ExecuteFunction();
}
//--------------------------------------------------------------------------------------------------
void _OnActionFinished(ToolAction toolAction)
{
bool finished = false;
var selectAction = toolAction as SelectSubshapeAction;
Debug.Assert(selectAction != null);
if (selectAction.SelectedSubshapeType == SubshapeTypes.Face)
{
var face = TopoDS.Face(selectAction.SelectedSubshape);
var brepAdaptor = new BRepAdaptor_Surface(face, true);
if (brepAdaptor.GetGeomType() != GeomAbs_SurfaceType.GeomAbs_Plane)
{
StatusText = "Selected face is not a plane type surface.";
}
else
{
double centerU = brepAdaptor.FirstUParameter() + (brepAdaptor.LastUParameter() - brepAdaptor.FirstUParameter()) / 2;
double centerV = brepAdaptor.FirstVParameter() + (brepAdaptor.LastVParameter() - brepAdaptor.FirstVParameter()) / 2;
var centerPnt = brepAdaptor.Value(centerU, centerV);
WorkspaceController.Workspace.WorkingPlane = new Pln(centerPnt, brepAdaptor.Plane().Axis.Direction);
finished = true;
}
}
else if (selectAction.SelectedSubshapeType == SubshapeTypes.Edge)
{
var edge = TopoDS.Edge(selectAction.SelectedSubshape);
double firstParam = 0, lastParam = 0;
var curve = BRep_Tool.Curve(edge, ref firstParam, ref lastParam);
if (curve != null)
{
var midpoint = curve.Value(firstParam + (lastParam - firstParam) / 2);
WorkspaceController.Workspace.WorkingPlane = new Pln(midpoint, WorkspaceController.Workspace.WorkingPlane.Axis.Direction);
finished = true;
}
}
else if (selectAction.SelectedSubshapeType == SubshapeTypes.Vertex)
{
var vertex = TopoDS.Vertex(selectAction.SelectedSubshape);
WorkspaceController.Workspace.WorkingPlane = new Pln(BRep_Tool.Pnt(vertex), WorkspaceController.Workspace.WorkingPlane.Axis.Direction);
finished = true;
}
if (finished)
{
selectAction.Stop();
Stop();
}
else
{
selectAction.Reset();
}
WorkspaceController.Invalidate();
}
//--------------------------------------------------------------------------------------------------
void _OnActionFinished(ToolAction toolAction)
{
bool finished = false;
var selectAction = toolAction as SelectSubshapeAction;
Debug.Assert(selectAction != null);
if (selectAction.SelectedSubshapeType == SubshapeTypes.Face)
{
var face = TopoDS.Face(selectAction.SelectedSubshape);
var brepAdaptor = new BRepAdaptor_Surface(face, true);
if (brepAdaptor.GetGeomType() != GeomAbs_SurfaceType.GeomAbs_Plane)
{
StatusText = "Selected face is not a plane type surface.";
}
else
{
selectAction.Stop();
Stop();
finished = true;
var faceRef = _TargetShape.GetSubshapeReference(_TargetShape.GetTransformedBRep(), face);
if (faceRef == null)
{
Messages.Error("A subshape reference could not be produced for this face.");
return;
}
if (_Mode == ToolMode.CreateNew)
{
// Create new
var flangeSheet = FlangeSheet.Create(_TargetBody, faceRef);
if (flangeSheet != null)
{
InteractiveContext.Current.UndoHandler.Commit();
InteractiveContext.Current.WorkspaceController.Selection.SelectEntity(_TargetBody);
}
}
else if (_Mode == ToolMode.ReselectFace)
{
// Reselected face
_FlangeToChange.Face = faceRef;
_FlangeToChange.Invalidate();
InteractiveContext.Current.UndoHandler.Commit();
}
}
}
if (!finished)
{
selectAction.Reset();
}
WorkspaceController.Invalidate();
}
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");
}
public static TopoDSFace ComposeWires(List <SceneSelectedEntity> cutShapes, bool skipFaceValidityCheck)
{
if (cutShapes.Count > 0)
{
alreadyDone.Add(cutShapes[0].Node);
var mkWire = new BRepBuilderAPIMakeWire();
foreach (var cutShape in cutShapes)
{
var node = cutShape.Node;
var shape = node.Get <TopoDsShapeInterpreter>().Shape;
if (shape == null)
{
break;
}
if (shape.ShapeType != TopAbsShapeEnum.TopAbs_WIRE)
{
continue;
}
var wire = TopoDS.Wire(shape);
mkWire.Add(wire);
}
if (mkWire.IsDone)
{
// If the wire generation succeeded generate a Face from it
var wireProfile = mkWire.Wire;
if (!wireProfile.IsNull)
{
var faceProfile = new BRepBuilderAPIMakeFace(wireProfile, true).Face;
if (!faceProfile.IsNull)
{
// The face is generated not checking if it is a valid face
if (skipFaceValidityCheck)
{
return(faceProfile);
}
// Check if it is a valid shape
var analyzer = new BRepCheckAnalyzer(faceProfile, true);
if (analyzer.IsValid())
{
return(faceProfile);
}
}
}
}
}
return(null);
}
private void BuildOffset(NodeBuilder builder)
{
if (Dependency.Steps[1].Data is Mouse3DPosition)
{
var mouse = Dependency.Steps[1].Data as Mouse3DPosition;
var face = TopoDS.Face(Dependency.Steps[0].Get <SceneSelectedEntity>().TargetShape());
var direction = GetOffsetDirection(face, mouse.Point.GpPnt);
Dependency.Steps[1].Data = mouse.Point.GpPnt.Distance(_previousMouseClick.Point.GpPnt) * direction;
}
builder[0].Reference = (Dependency.Steps[0].Get <SceneSelectedEntity>()).Node;
builder[1].Real = Dependency.Steps[1].Get <double>();
builder.ExecuteFunction();
}
public static gpPln ExtractPlaneFromFaceShape(TopoDSShape targetFace)
{
var face = TopoDS.Face(targetFace);
var surf = BRepTool.Surface(face);
var pl = new GeomPlane(new gpAx3());
pl = surf.Convert <GeomPlane>();
//surf.DownCast(ref pl);
var faceElementAdaptor = new BRepAdaptorSurface(face, true);
//TO DO: Investigate why this is not working
Ensure.AreEqual(faceElementAdaptor.GetType, GeomAbsSurfaceType.GeomAbs_Plane);
return(pl.Pln);
}
//--------------------------------------------------------------------------------------------------
void _OnFaceSelected(SelectSubshapeAction selectAction)
{
if (selectAction.SelectedSubshapeType == SubshapeTypes.Face)
{
var face = TopoDS.Face(selectAction.SelectedSubshape);
var brepAdaptor = new BRepAdaptor_Surface(face, true);
if (brepAdaptor.GetGeomType() != GeomAbs_SurfaceType.GeomAbs_Plane &&
brepAdaptor.GetGeomType() != GeomAbs_SurfaceType.GeomAbs_Cylinder &&
brepAdaptor.GetGeomType() != GeomAbs_SurfaceType.GeomAbs_Cone)
{
StatusText = "Selected face is not a plane, cylinder or cone type surface.";
selectAction.Reset();
return;
}
selectAction.Stop();
_TargetFace = face;
_Phase = Phase.BaseEdgeOrVertex;
_SubshapesOfFace = new List <TopoDS_Shape>();
var edges = face.Edges().Where(
edge =>
{
var analysis = new ShapeAnalysis_Edge();
return(!analysis.IsSeam(edge, face));
}).ToList();
_SubshapesOfFace.AddRange(edges);
var vertices = face.Vertices().Where(
vertex =>
{
var vertexEdges = edges.Where(edge => edge.Vertices().ContainsSame(vertex));
return(vertexEdges.Count() > 1);
});
_SubshapesOfFace.AddRange(vertices);
var newAction = new SelectSubshapeAction(this, _SubshapesOfFace);
if (!WorkspaceController.StartToolAction(newAction))
{
Stop();
return;
}
newAction.Previewed += _OnActionPreview;
newAction.Finished += _OnActionFinished;
StatusText = "Select base edge or vertex to define direction of taper.";
WorkspaceController.HudManager?.SetCursor(Cursors.SelectEdge);
}
}
/// <summary>
/// Returns 1 if the point is outside te face and -1 is inside or on the face.
/// </summary>
/// <param name = "point"></param>
/// <returns></returns>
private int GetDirection(gpPnt point)
{
var direction = 1;
if (_selectedNodes[0].ShapeType == TopAbsShapeEnum.TopAbs_FACE)
{
var face = TopoDS.Face(_selectedNodes[0].Node.Get <TopoDsShapeInterpreter>().Shape);
var classifier = new IntToolsContext();
if (classifier.IsValidPointForFace(point, face, Precision.Confusion))
{
direction = -1;
}
}
return(direction);
}
private static TopoDSShape MakePipe(TopoDSShape path, TopoDSShape profile)
{
try
{
var baseEx = new TopExpExplorer();
baseEx.Init(path, TopAbsShapeEnum.TopAbs_WIRE, TopAbsShapeEnum.TopAbs_SHAPE);
var spline = TopoDS.Wire(baseEx.Current);
return(new BRepOffsetAPIMakePipe(spline, profile).Shape);
}
catch (Exception ex)
{
Log.Error("Error on making pipe: " + ex.Message);
return(null);
}
}
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);
}
public static TopoDSShape ExtractSubShape(
TopoDSShape originalShape,
int facePosition,
TopAbsShapeEnum shapeType)
{
if (originalShape == null)
{
return(null);
}
// Find the face
var baseEx = new TopExpExplorer();
baseEx.Init(originalShape, shapeType, TopAbsShapeEnum.TopAbs_SHAPE);
while (baseEx.More && (facePosition != 1))
{
baseEx.Next();
facePosition--;
}
//if (!baseEx.More())
// return null;
TopoDSShape shape = null;
switch (shapeType)
{
case TopAbsShapeEnum.TopAbs_VERTEX:
shape = TopoDS.Vertex(baseEx.Current);
break;
case TopAbsShapeEnum.TopAbs_EDGE:
shape = TopoDS.Edge(baseEx.Current);
break;
case TopAbsShapeEnum.TopAbs_WIRE:
shape = TopoDS.Wire(baseEx.Current);
break;
case TopAbsShapeEnum.TopAbs_FACE:
shape = TopoDS.Face(baseEx.Current);
break;
case TopAbsShapeEnum.TopAbs_SOLID:
case TopAbsShapeEnum.TopAbs_COMPOUND:
return(originalShape);
}
return(shape);
}
//--------------------------------------------------------------------------------------------------
void _OnActionFinished(ToolAction toolAction)
{
bool finished = false;
var selectAction = toolAction as SelectSubshapeAction;
Debug.Assert(selectAction != null);
if (selectAction.SelectedSubshapeType == SubshapeTypes.Face)
{
var face = TopoDS.Face(selectAction.SelectedSubshape);
selectAction.Stop();
Stop();
finished = true;
var faceRef = _TargetShape.GetSubshapeReference(_TargetShape.GetTransformedBRep(), face);
if (faceRef == null)
{
Messages.Error("A subshape reference could not be produced for this face.");
return;
}
if (_Mode == ToolMode.CreateNew)
{
// Create new
var extrude = Extrude.Create(_TargetBody, faceRef);
if (extrude != null)
{
InteractiveContext.Current.UndoHandler.Commit();
InteractiveContext.Current.WorkspaceController.Selection.SelectEntity(_TargetBody);
}
}
else if (_Mode == ToolMode.ReselectFace)
{
// Reselected face
_ExtrudeToChange.Face = faceRef;
_ExtrudeToChange.Invalidate();
InteractiveContext.Current.UndoHandler.Commit();
}
}
if (!finished)
{
selectAction.Reset();
}
WorkspaceController.Invalidate();
}
/// <summary>
/// Detects the referenced shape type and generates an appropiate
/// dimension for it
/// </summary>
public static AISInteractiveObject CreateDependency(TopoDSShape referenceShape, gpPnt textLocation, DsgPrsArrowSide arrowType, bool isOffset = false, gpPnt offset = null)
{
if (referenceShape == null || referenceShape.ShapeType != TopAbsShapeEnum.TopAbs_EDGE)
{
return(null);
}
var curve = new BRepAdaptorCurve(TopoDS.Edge(referenceShape));
if (curve.GetType == GeomAbsCurveType.GeomAbs_Circle)
{
return(BuildCircleDimension(referenceShape, textLocation));
}
return(curve.GetType == GeomAbsCurveType.GeomAbs_Line
? BuildLineDimension(TopoDS.Edge(referenceShape), textLocation, null, arrowType, isOffset, offset)
: null);
}
private void GetLength(ref object resultvalue)
{
if (Builder[0].ReferenceBuilder.FunctionName == FunctionNames.Circle)
{
var radius = Builder[0].ReferenceBuilder.Dependency[1].Real;
resultvalue = radius * 2;
return;
}
var referenceShape = ShapeUtils.ExtractSubShape(Builder[0].ReferenceData);
var edge = TopoDS.Edge(referenceShape);
var curve = new BRepAdaptorCurve(edge);
var firstPoint = curve.Value(curve.FirstParameter);
var lastPoint = curve.Value(curve.LastParameter);
var length = firstPoint.Distance(lastPoint);
resultvalue = length;
}
//--------------------------------------------------------------------------------------------------
void _SelectFaceAction_OnFinished(ToolAction toolaction)
{
Debug.Assert(toolaction == _SelectFaceAction);
if (_SelectFaceAction.SelectedSubshapeType == SubshapeTypes.Face)
{
var face = TopoDS.Face(_SelectFaceAction.SelectedSubshape);
var brepAdaptor = new BRepAdaptor_Surface(face, true);
if (brepAdaptor.GetGeomType() != GeomAbs_SurfaceType.GeomAbs_Plane)
{
StatusText = "Selected face is not a plane type surface.";
_SelectFaceAction.Reset();
return;
}
var subshapeReference = _Body.Shape.GetSubshapeReference(_ShapeForFaceSelection.GetTransformedBRep(), _SelectFaceAction.SelectedSubshape);
if (subshapeReference != null)
{
if (_Component == null)
{
_CreateComponent();
}
_Component.ReferenceFace = subshapeReference;
InteractiveContext.Current.UndoHandler.Commit();
}
else
{
Messages.Error("A subshape reference could not be produced for this subshape.");
}
}
ToggleFaceSelection();
if (_Component != null)
{
_InitInteractions();
}
else
{
Stop();
}
}
private static AISInteractiveObject BuildCircleDimension(TopoDSShape referenceShape, gpPnt textLocation)
{
var edge = TopoDS.Edge(referenceShape);
var curve = new BRepAdaptorCurve(edge);
if (curve.GetType != GeomAbsCurveType.GeomAbs_Circle)
{
return(null);
}
// For a circle use a diameter dimension
var circle = curve.Circle;
var diameter = 2.0 * circle.Radius;
var text = new TCollectionExtendedString(String.Format("{0:0.00}", diameter));
var rd = new AISDiameterDimension(referenceShape, diameter, text, textLocation,
DsgPrsArrowSide.DsgPrs_AS_BOTHAR, true, ArrowSize);
rd.SetColor(QuantityNameOfColor.Quantity_NOC_RED);
return(rd);
}
public static bool IsPlanarFace(TopoDSShape shape)
{
TopoDSFace face;
try
{
if ((shape.IsNull) || (shape.ShapeType != TopAbsShapeEnum.TopAbs_FACE))
{
return(false);
}
face = TopoDS.Face(shape);
}
catch
{
return(false);
}
var aFaceElementAdaptor = new BRepAdaptorSurface(face, true);
var surfaceType = aFaceElementAdaptor.GetType;
return(surfaceType == GeomAbsSurfaceType.GeomAbs_Plane);
}
public override bool Execute()
{
var edgeNode = Dependency[0].Reference;
var edgeIndexNode = Dependency[0].ReferenceData.ShapeCount;
if (ShapeUtils.ExtractShape(edgeNode) == null)
{
return(false);
}
var edge =
TopoDS.Edge(ShapeUtils.ExtractSubShape(edgeNode, edgeIndexNode, TopAbsShapeEnum.TopAbs_EDGE));
var distance = Dependency[1].Real;
var referenceShape = Dependency[2].Reference;
var referebceShapePointIndex = Dependency[3].Integer;
if (referenceShape == null)
{
return(false);
}
var point = NodeBuilderUtils.GetNodePoint(referenceShape[referebceShapePointIndex]);
if (point != null)
{
var projectionPoint = GeomUtils.ProjectPointOnEdge(edge, ((Point3D)point).GpPnt);
var newPoint = new Point3D(projectionPoint);
var currentDistance = projectionPoint.Distance(((Point3D)point).GpPnt);
if (Math.Abs(currentDistance - distance) > 0.01)
{
var scale = currentDistance / distance;
if (Math.Abs(scale - 1) > Precision.Confusion)
{
newPoint = TreeUtils.ScaleSegment(newPoint, ((Point3D)point), scale);
}
}
NodeBuilderUtils.SetupNodePoint(referenceShape[referebceShapePointIndex], newPoint);
}
return(true);
}
public override bool Execute()
{
// Get the extrusion referenece shape, height and extrusion type
var offsetShape = Dependency[0].ReferedShape;
var offsetLength = Dependency[1].Real;
// Don't allow 0 offset
if (Math.Abs(offsetLength) < Precision.Confusion)
{
return(false);
}
//TopoDSShape resultShape = NodeUtils.GenerateWireOffset(offsetShapes, offsetLength);
// ! Currently only offset on 2D closed shapes of type Face can be made
if (offsetShape.ShapeType != TopAbsShapeEnum.TopAbs_FACE)
{
return(false);
}
var face = TopoDS.Face(offsetShape);
var resultShape = GeomUtils.GenerateFaceOffset(face, offsetLength);
if ((resultShape == null) || (resultShape.IsNull))
{
return(false);
}
var wire = TopoDS.Wire(resultShape);
var offsetFace = new BRepBuilderAPIMakeFace(wire, false).Face;
if (offsetFace.IsNull)
{
return(false);
}
// Set the result in the NamedShapeInterpreter and make the shape visible
Shape = offsetFace;
return(true);
}
//--------------------------------------------------------------------------------------------------
#endregion
#region Property List
void _InitProperties()
{
if (_Properties != null)
{
return;
}
_Properties = new List <BRepTopologyTreeProperty>();
try
{
_AddDefaultProperties();
switch (BrepShape.ShapeType())
{
case TopAbs_ShapeEnum.TopAbs_SHELL:
_AddShellProperties(BrepShape as TopoDS_Shell ?? TopoDS.Shell(BrepShape));
break;
case TopAbs_ShapeEnum.TopAbs_FACE:
_AddFaceProperties(BrepShape as TopoDS_Face ?? TopoDS.Face(BrepShape));
break;
case TopAbs_ShapeEnum.TopAbs_WIRE:
_AddWireProperties(BrepShape as TopoDS_Wire ?? TopoDS.Wire(BrepShape));
break;
case TopAbs_ShapeEnum.TopAbs_EDGE:
_AddEdgeProperties(BrepShape as TopoDS_Edge ?? TopoDS.Edge(BrepShape));
break;
case TopAbs_ShapeEnum.TopAbs_VERTEX:
_AddVertexProperties(BrepShape as TopoDS_Vertex ?? TopoDS.Vertex(BrepShape));
break;
}
}
catch (Exception e)
{
Messages.Exception($"Error getting properties for B-Rep shape {Name}", e);
}
}
//--------------------------------------------------------------------------------------------------
void _OnActionFinished(ToolAction toolAction)
{
bool finished = false;
var selectAction = toolAction as SelectSubshapeAction;
Debug.Assert(selectAction != null);
if (selectAction.SelectedSubshapeType == SubshapeTypes.Face)
{
var face = TopoDS.Face(selectAction.SelectedSubshape);
var brepAdaptor = new BRepAdaptor_Surface(face, true);
if (brepAdaptor.GetGeomType() != GeomAbs_SurfaceType.GeomAbs_Plane)
{
StatusText = "Selected face is not a plane type surface.";
}
finished = true;
}
if (finished)
{
var subshapeReference = _TargetShape.GetSubshapeReference(_TargetShape.GetTransformedBRep(), selectAction.SelectedSubshape);
selectAction.Stop();
Stop();
if (subshapeReference == null)
{
Messages.Error("A subshape reference could not be produced for this subshape.");
return;
}
_SelectedFunc.Invoke(subshapeReference);
}
else
{
selectAction.Reset();
}
WorkspaceController.Invalidate();
}
public static List<TessalatedShape> Triangulate(TopoDS.Shape topoShape)
{
TopExp.Explorer ex = new TopExp.Explorer(topoShape, TopAbs.ShapeEnum.FACE, TopAbs.ShapeEnum.SHAPE);
BRepMesh.General.Mesh(topoShape, 0.1);
List<TessalatedShape> faces = new List<TessalatedShape>();
// Loop all faces
while (ex.More())
{
TessalatedShape shape = new TessalatedShape();
TopoDS.Face F = TopoDS.General.Face(ex.Current());
TopLoc.Location location = new TopLoc.Location();
Poly.Triangulation triangulation = BRep.Tool.Triangulation(F, location);
Poly.Array1OfTriangle arrayOfTriangle = triangulation.Triangles();
TColgp.Array1OfPnt p3d = triangulation.Nodes();
shape.points = new gp.Pnt[p3d.Length()];
for (int i = 0; i < shape.points.Length; ++i)
{
shape.points[i] = p3d.Value(i + 1);
}
if (location != null)
{
gp.Trsf trsf = location.Transformation();
for (int i = 0; i < shape.points.Length; ++i)
{
trsf.Transforms(out shape.points[i].x, out shape.points[i].y, out shape.points[i].z);
}
}
TColgp.Array1OfPnt2d p2d = triangulation.UVNodes();
if (p2d != null)
{
shape.uvpoints = new gp.Pnt2d[p2d.Length()];
for (int i = 0; i < shape.uvpoints.Length; ++i)
{
shape.uvpoints[i] = p2d.Value(i + 1);
}
}
else
{
shape.uvpoints = null;
}
shape.triangles = new int[arrayOfTriangle.Length() * 3];
int l = arrayOfTriangle.Length();
for (int i = 0; i < l; ++i)
{
Poly.Triangle t = arrayOfTriangle.Value(i + 1);
shape.triangles[3 * i] = t.Value(1) - 1;
shape.triangles[3 * i + 1] = t.Value(2) - 1;
shape.triangles[3 * i + 2] = t.Value(3) - 1;
}
faces.Add(shape);
ex.Next();
}
return faces;
}
public void Add(TopoDS.Shape shape)
{
viewedShapes.Add(shape);
triangulations.AddRange(Utility.Triangulate(shape));
}
