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");
}
private static void AddGeometry(SolverGeometricObject geometry, List <SolverGeometricObject> solverGeometry)
{
if (geometry != null && !geometry.IsEmpty)
{
solverGeometry.Add(geometry);
}
}
private static void AddOriginPoint(List <SolverGeometricObject> solverGeometry)
{
var originPoint = new SolverGeometricObject(null);
originPoint.AddPoint(new SolverDataPoint(new Point3D()));
AddGeometry(originPoint, solverGeometry);
}
/// <summary>
/// Builds the solver info (magic points and planes) receiving as parameter a shape.
/// </summary>
/// <param name = "solverObject"></param>
/// <param name = "shape"></param>
/// <param name = "parallelPrecision"></param>
/// <param name = "computeParallelism"></param>
public static void BuildSolverInfo(SolverGeometricObject solverObject, Node shape,
double parallelPrecision, bool computeParallelism)
{
var solidShape = ShapeUtils.ExtractShape(solverObject.Parent);
// Build a list with the magic points made by the vertexes
BuildPointList(shape, solverObject);
var functionName = shape.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name;
if (functionName == FunctionNames.LineTwoPoints || functionName == FunctionNames.Arc ||
functionName == FunctionNames.Arc3P || functionName == FunctionNames.Circle ||
functionName == FunctionNames.Ellipse)
{
// Build a list with the edges
BuildEdgeList(solidShape, solverObject);
}
// Build a list with the magic points made by the faces/surfaces
BuildFaceList(solidShape, solverObject);
// Build a list with parallel axis
if (!computeParallelism)
{
return;
}
if (NodeBuilderUtils.NodeIsOnSketch(new NodeBuilder(shape)))
{
BuildParallelAxisList(solidShape, solverObject, parallelPrecision);
}
}
public void GeometryParallelismTest()
{
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 parallelMatch = new ParallelLineMatch(solver, 5.0 / 180 * Math.PI);
var initialPosition = new Point3D(3, 1, 0);
var currentPosition = new Point3D(4.05, 1.95, 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 solution = parallelMatch.GeometryParallel(currentPosition, initialPosition);
Assert.IsTrue(solution.Point.X - 4 < Precision.Confusion, "Invalid X axis parallelism");
Assert.IsTrue(solution.Point.Y - 2 < Precision.Confusion, "Invalid Y axis parallelism");
Assert.IsTrue(solution.Point.Z < Precision.Confusion, "Invalid Z axis parallelism");
}
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 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");
}
protected override bool Extract(SolverGeometricObject solverObject)
{
if (!ShapeUtils.HasShape(solverObject.Parent))
{
return(false);
}
NodeHelper.BuildSolverInfo(solverObject, solverObject.Parent, AnglePrecision,
ComputeParallelism);
return(true);
}
protected override bool Extract(SolverGeometricObject data)
{
var builder = Builder;
var firstPoint = builder[0].TransformedPoint3D.AddCoordinate(new Point3D(-1000, 0, 0));
var secondPoint = firstPoint.AddCoordinate(new Point3D(2000, 0, 0));
var edge = new BRepBuilderAPIMakeEdge(firstPoint.GpPnt, secondPoint.GpPnt).Edge;
data.Edges.Add(new SolverEdge(edge));
return(true);
}
public SolverGeometricObject ExtractSolverGeometry(Node node)
{
var result = new SolverGeometricObject(node);
if (!HasShapeOrInteractive(node))
{
return(result);
}
Builder = new NodeBuilder(node);
return(Extract(result) ? result : null);
}
protected override bool Extract(SolverGeometricObject data)
{
if (data.Builder[0].Name == FunctionNames.Point)
{
data.Points.Add(new SolverDataPoint(data.Builder[0].RefTransformedPoint3D));
}
if (data.Builder[0].Name == FunctionNames.AxisHandle)
{
data.Points.Add(new SolverDataPoint(data.Builder[0].Axis3D.Location));
}
return(base.Extract(data));
}
protected override bool Extract(SolverGeometricObject data)
{
if (!ShapeUtils.HasShape(data.Parent))
{
return(false);
}
var pointCount = data.Builder[0].Integer;
for (var i = 1; i <= pointCount; i++)
{
data.Points.Add(new SolverDataPoint(data.Builder[i].TransformedPoint3D));
}
return(true);
}
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");
}
private static void BuildPointList(TopoDSShape solidShape, SolverGeometricObject solverObject)
{
var listOfVertexes = GeomUtils.ExtractPoints(solidShape);
if (listOfVertexes.Count <= 0)
{
return;
}
var index = 1;
foreach (var pnt in listOfVertexes)
{
BuildSolverVertex(solverObject, pnt, GeometryType.EndPoint, index++);
}
}
private static void BuildEdgeList(TopoDSShape solidShape, SolverGeometricObject solverObject)
{
var listOfEdges = GeomUtils.ExtractEdges(solidShape);
if (listOfEdges.Count <= 0)
{
return;
}
var edgeIndex = 1;
foreach (var edge in listOfEdges)
{
solverObject.Edges.Add(new SolverEdge(edge, GeometryType.Edge, solverObject.Parent));
BuildMidPointVertex(solverObject, edgeIndex, edge);
edgeIndex++;
}
}
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 void BuildIntersectionsPointList(List <SolverGeometricObject> solverGeometry)
{
var qosLock = QosFactory.Instance.Get(QosNames.EdgeIntersectionLock) ??
QosFactory.Instance.Create(QosNames.EdgeIntersectionLock, 120,
"Edge Intersection precomputation works too slow! Do you want to disable it?");
qosLock.Begin();
var intersectedGeometryContainer = new SolverGeometricObject(null);
var intersections = BuildEdgeIntersectionList(solverGeometry);
intersections = GeomUtils.SortAndCompactListPoints(intersections).ToArray();
foreach (var intersectdPoint in intersections)
{
intersectedGeometryContainer.Points.Add(new SolverDataPoint(intersectdPoint,
GeometryType.EdgeIntersection));
}
solverGeometry.Add(intersectedGeometryContainer);
qosLock.End();
}
private static void BuildPointList(Node shape, SolverGeometricObject solverObject)
{
if (shape.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name == FunctionNames.Point)
{
var point = new NodeBuilder(shape).Dependency[1].TransformedPoint3D;
solverObject.Points.Add(new SolverDataPoint(point, GeometryType.EndPoint));
return;
}
if (shape.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name == FunctionNames.LineTwoPoints)
{
var point = new NodeBuilder(shape).Dependency[0].RefTransformedPoint3D;
solverObject.Points.Add(new SolverDataPoint(point, GeometryType.EndPoint));
point = new NodeBuilder(shape).Dependency[1].RefTransformedPoint3D;
solverObject.Points.Add(new SolverDataPoint(point, GeometryType.EndPoint));
return;
}
if (shape.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name == FunctionNames.Circle)
{
var point = new NodeBuilder(shape).Dependency[0].RefTransformedPoint3D;
solverObject.Points.Add(new SolverDataPoint(point, GeometryType.EndPoint));
return;
}
if (shape.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name == FunctionNames.Arc ||
shape.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name == FunctionNames.Arc3P)
{
var point = new NodeBuilder(shape).Dependency[0].RefTransformedPoint3D;
solverObject.Points.Add(new SolverDataPoint(point, GeometryType.EndPoint));
point = new NodeBuilder(shape).Dependency[1].RefTransformedPoint3D;
solverObject.Points.Add(new SolverDataPoint(point, GeometryType.EndPoint));
point = new NodeBuilder(shape).Dependency[2].RefTransformedPoint3D;
solverObject.Points.Add(new SolverDataPoint(point, GeometryType.EndPoint));
}
if (shape.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name == FunctionNames.Extrude ||
shape.Get <ShapeFunctionsInterface.Functions.FunctionInterpreter>().Name == FunctionNames.Cut)
{
var points = GeomUtils.ExtractPoints(new NodeBuilder(shape).Shape);
foreach (var point in points)
{
solverObject.Points.Add(new SolverDataPoint(point, GeometryType.EndPoint));
}
}
}
private static void BuildMidPointVertex(SolverGeometricObject solverObject, int edgeIndex, TopoDSEdge edge)
{
Point3D?first, last;
GeomUtils.EdgeRange(edge, out first, out last);
if (first == null || last == null)
{
return;
}
var firstPoint = (Point3D)first;
var lastPoint = (Point3D)last;
var midPoint = new Point3D((firstPoint.X + lastPoint.X) / 2,
(firstPoint.Y + lastPoint.Y) / 2,
(firstPoint.Z + lastPoint.Z) / 2);
solverObject.Points.Add(new SolverDataPoint(midPoint)
{
GeometryType = GeometryType.MidPoint
});
}
private static void BuildEdgeIntersections(SolverGeometricObject geometricObject,
SolverGeometricObject destinationObject,
List <Point3D> intersectionList)
{
foreach (var edge in geometricObject.Edges)
{
var edgeIntersector = edge.Edge;
foreach (var destinationEdge in destinationObject.Edges)
{
var edgeToIntersect = destinationEdge.Edge;
if (edgeIntersector.IsSame(edgeToIntersect))
{
continue;
}
var intersectionPoints = GeomUtils.IntersectionPoints(edgeIntersector, edgeToIntersect);
intersectionList.AddRange(intersectionPoints);
}
}
}
private static void BuildParallelAxisList(TopoDSShape solidShape, SolverGeometricObject solverObject,
double angle)
{
var listOfEdges = GeomUtils.ExtractEdges(solidShape);
if (listOfEdges.Count <= 0)
{
return;
}
var extractedAxises = new List <SolverParallelAxis>();
foreach (var edge in listOfEdges)
{
var curve = new BRepAdaptorCurve(TopoDS.Edge(edge));
if (curve.GetType != GeomAbsCurveType.GeomAbs_Line)
{
continue;
}
var buildAxis = new SolverParallelAxis(edge);
var isParallelWithPreviousAxes = false;
foreach (var axis in extractedAxises)
{
if (!axis.IsParallel(buildAxis.Vector, angle))
{
continue;
}
isParallelWithPreviousAxes = true;
break;
}
if (!isParallelWithPreviousAxes)
{
extractedAxises.Add(buildAxis);
}
}
foreach (var extractedAxis in extractedAxises)
{
solverObject.ParallelAxis.Add(extractedAxis);
}
}
private static void InitializeGeometry(ICollection <SolverGeometricObject> geometry)
{
// Make a rectangle
var rectObject = new SolverGeometricObject(null);
// Add some dummy points
rectObject.Points.Add(new SolverDataPoint(new Point3D(0, 0, 0), GeometryType.EndPoint));
rectObject.Points.Add(new SolverDataPoint(new Point3D(10, 10, 0), GeometryType.EndPoint));
rectObject.Points.Add(new SolverDataPoint(new Point3D(0, 10, 0), GeometryType.EndPoint));
rectObject.Points.Add(new SolverDataPoint(new Point3D(10, 0, 0), GeometryType.EndPoint));
rectObject.Points.Add(new SolverDataPoint(new Point3D(-10, -10, 0), GeometryType.EndPoint));
// Add two edges to intersect
var edge1 = new BRepBuilderAPIMakeEdge(new Point3D(0, 0, 0).GpPnt, new Point3D(10, 10, 0).GpPnt).Edge;
rectObject.Edges.Add(new SolverEdge(edge1));
var edge2 = new BRepBuilderAPIMakeEdge(new Point3D(0, 10, 0).GpPnt, new Point3D(10, 0, 0).GpPnt).Edge;
rectObject.Edges.Add(new SolverEdge(edge2));
geometry.Add(rectObject);
}
private static void BuildFaceList(TopoDSShape solidShape, SolverGeometricObject solverObject)
{
var listOfFaces = GeomUtils.ExtractFaces(solidShape);
if (listOfFaces.Count <= 0)
{
return;
}
foreach (var face in listOfFaces)
{
var surf = BRepTool.Surface(face);
solverObject.Surfaces.Add(new SolverSurface(surf, GeometryType.Face));
// Check if surface is planar
var aFaceElementAdaptor = new BRepAdaptorSurface(face, true);
var surfaceType = aFaceElementAdaptor.GetType;
if (surfaceType != GeomAbsSurfaceType.GeomAbs_Plane)
{
continue;
}
GeomPlane pl = surf.Convert <GeomPlane>();
solverObject.Planes.Add(new SolverPlane(pl.Pln, GeometryType.Plane, solverObject.Parent));
}
}
public override List <SolverPreviewObject> InterestingShapeAroundPoint(gpPln planeOfTheView, Point3D point)
{
var qosLock = QosFactory.Instance.Get(QosNames.EdgeMatchLock);
qosLock.Begin();
foreach (var edge in Geometry.SelectMany(geometricObject => geometricObject.Edges))
{
// Calculate the distance from the point to the curve
GeomCurve curve;
var first = 0.0;
var last = 0.0;
unsafe
{
curve = BRepTool.Curve(edge.Edge, ref first, ref last);
}
if (curve == null)
{
continue;
}
// Add a curve domain protection
if (first > last)
{
continue;
}
ExtremaExtPC extrema = null;
try
{
var adaptor = new GeomAdaptorCurve(curve, first, last);
extrema = new ExtremaExtPC(point.GpPnt, adaptor, Precision.Confusion);
}
catch
{
Log.Debug("Exception on generate extrema points");
}
if (extrema == null)
{
continue;
}
if (!extrema.IsDone)
{
continue;
}
if (extrema.NbExt < 1)
{
continue;
}
// The point is on edge
if (extrema.SquareDistance(1) >= CoreGlobalPreferencesSingleton.Instance.ZoomLevel * _precision)
{
continue;
}
// Generate a point on the edge by projecting
var projectionPoint = new GeomAPIProjectPointOnCurve(point.GpPnt, curve);
if (projectionPoint.NbPoints <= 0)
{
continue;
}
List <SolverGeometricObject> selectedEdge = Geometry.Where(geomObj => geomObj.Edges.Contains(edge)).ToList();
//LastGeometry.Clear();
//LastGeometry.AddRange(selectedEdge);
var originPoint = new SolverGeometricObject(null);
originPoint.AddPoint(new SolverDataPoint(new Point3D()));
var result = GeomUtils.ProjectPointOnPlane(new Point3D().GpPnt, planeOfTheView, Precision.Confusion);
//if(result == new gpPnt(0,0,0))
//{
// LastGeometry.Add(originPoint);
//}
if (selectedEdge.Count > 0 && selectedEdge.First().Edges.Count > 0)
{
return new List <SolverPreviewObject>()
{
new SolverPointResult(new Point3D(projectionPoint.NearestPoint), selectedEdge.First().Edges.First().ParentIndex)
}
}
; // {Text = "On Edge"};
else
{
return new List <SolverPreviewObject>()
{
new SolverPointResult(new Point3D(projectionPoint.NearestPoint))
}
};
}
qosLock.End();
return(new List <SolverPreviewObject>());
}
}
private static void AddVertexToSolver(SolverGeometricObject solverObject, Point3D point, GeometryType type,
int pointIndex)
{
solverObject.Points.Add(new SolverDataPoint(point, type));
}
/// <summary>
/// Adds to a solver description object a vertex
/// </summary>
/// <param name = "solverObject"></param>
/// <param name = "point"></param>
/// <param name = "type"></param>
/// <param name = "pointIndex"></param>
private static void BuildSolverVertex(SolverGeometricObject solverObject, Point3D point, GeometryType type,
int pointIndex)
{
AddVertexToSolver(solverObject, point, type, pointIndex);
}
protected abstract bool Extract(SolverGeometricObject data);
protected override bool Extract(SolverGeometricObject data)
{
data.Points.Add(new SolverDataPoint(data.Builder[0].RefTransformedPoint3D));
return(base.Extract(data));
}