public static void ShowFaceDirection(TopoDSFace face, Document Document)
{
var p1 = new gpPnt();
var v1 = new gpVec();
var v2 = new gpVec();
var sf = new BRepAdaptorSurface(face, true);
var u = sf.FirstUParameter;
var x = sf.LastUParameter;
if (Precision.IsInfinite(u))
{
u = (Precision.IsInfinite(x)) ? 0.0 : x;
}
else if (!Precision.IsInfinite(x))
{
u = (u + x) / 2.0;
}
var v = sf.FirstVParameter;
x = sf.LastVParameter;
if (Precision.IsInfinite(v))
{
v = (Precision.IsInfinite(x)) ? 0.0 : x;
}
else if (!Precision.IsInfinite(x))
{
v = (v + x) / 2.0;
}
sf.D1(u, v, p1, v1, v2);
var vector = v1.Crossed(v2);
x = vector.Magnitude;
// The direction vector length
const double length = 70.0;
if (x > 0.0000001)
{
vector.Multiply(length / x);
}
else
{
vector.SetCoord(length / 2.0, 0, 0);
}
var p2 = new gpPnt(p1.X, p1.Y, p1.Z);
p2.Translate(vector);
if (p1.IsEqual(p2, Precision.Confusion))
{
return;
}
DrawArrow(Document, p1, p2, face.Orientation());
}
/// <summary>
/// Calculates the computer radiuses knowing the center position and two points located on the two axis
/// </summary>
public static bool ComputeEllipseRadiuses(Point3D center, Point3D secondPoint, Point3D thirdPoint,
out double minorRadius, out double majorRadius,
out bool reversed, ref gpDir dirX, ref gpDir dirY)
{
// Calculate the major radius
majorRadius = center.GpPnt.Distance(secondPoint.GpPnt);
// Calculate also the axis/direction of the major radus
var vecX = new gpVec(center.GpPnt, secondPoint.GpPnt);
dirX = new gpDir(vecX);
var line = new gpLin(center.GpPnt, dirX);
// Calculate the minor radius
minorRadius = line.Distance(thirdPoint.GpPnt);
reversed = false;
if (minorRadius < Precision.Confusion || majorRadius < Precision.Confusion)
{
return(false);
}
// Calculate also the axis/direction of the major radus
var vecY = new gpVec(center.GpPnt, thirdPoint.GpPnt);
// We want the direction to be perpendicular on the direction of the major radius
var vecZ = vecX.Crossed(vecY);
vecY = vecX.Crossed(vecZ);
dirY = new gpDir(vecY);
// Major radius must be bigger than minor radius
if (minorRadius > majorRadius)
{
var aux = majorRadius;
majorRadius = minorRadius;
minorRadius = aux;
reversed = true;
}
return(true);
}
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);
}
// The rectangle is like the following:
// vertex2------vertex3
// vertex1------vertex4
public override gpAx2 GetPointLocation(int index)
{
var firstPoint = Dependency[0].TransformedPoint3D;
var secondPoint = Dependency[1].TransformedPoint3D;
var thirdPoint = Dependency[2].TransformedPoint3D;
var vectorV2V1 = new gpVec(secondPoint.GpPnt, firstPoint.GpPnt);
var vectorV2V3 = new gpVec(secondPoint.GpPnt, thirdPoint.GpPnt);
var rectangleNormalVector = vectorV2V1.Crossed(vectorV2V3);
var rectangleNormalDirection = new gpDir(rectangleNormalVector);
var rectangleCenter = new gpPnt((firstPoint.X + thirdPoint.X) / 2, (firstPoint.Y + thirdPoint.Y) / 2,
(firstPoint.Z + thirdPoint.Z) / 2);
vectorV2V3.Normalize();
vectorV2V1.Normalize();
vectorV2V3.Multiply(DistanceToObject);
vectorV2V1.Multiply(DistanceToObject);
var leftArrowVector = vectorV2V3.Reversed;
var leftArrowMidPoint = GeomUtils.ComputeMidPoint(firstPoint, secondPoint);
var leftArrowPoint = GeomUtils.BuildTranslation(leftArrowMidPoint, leftArrowVector);
var leftArrowAxis = new gpAx2(leftArrowPoint.GpPnt, rectangleNormalDirection)
{
XDirection = (new gpDir(leftArrowVector))
};
var topArrowVector = vectorV2V1.Reversed;
var topArrowMidPoint = GeomUtils.ComputeMidPoint(secondPoint, thirdPoint);
var topArrowPoint = GeomUtils.BuildTranslation(topArrowMidPoint, topArrowVector);
var topArrowAxis = new gpAx2(topArrowPoint.GpPnt, rectangleNormalDirection);
topArrowAxis.XDirection = (new gpDir(topArrowVector));
var bottomArrowPoint = new gpPnt(2 * rectangleCenter.X - topArrowPoint.X,
2 * rectangleCenter.Y - topArrowPoint.Y,
2 * rectangleCenter.Z - topArrowPoint.Z);
var bottomArrowAxis = new gpAx2(bottomArrowPoint, rectangleNormalDirection);
bottomArrowAxis.XDirection = (new gpDir(topArrowVector.Reversed));
var rightArrowPoint = new gpPnt(2 * rectangleCenter.X - leftArrowPoint.X,
2 * rectangleCenter.Y - leftArrowPoint.Y,
2 * rectangleCenter.Z - leftArrowPoint.Z);
var rightArrowAxis = new gpAx2(rightArrowPoint, rectangleNormalDirection);
rightArrowAxis.XDirection = new gpDir(leftArrowVector.Reversed);
var pointLocation = new gpAx2();
pointLocation.Direction = rectangleNormalDirection;
switch (index)
{
case 0:
pointLocation.Location = (firstPoint.GpPnt);
pointLocation.XDirection = (new gpDir(vectorV2V3));
return(pointLocation);
case 1:
pointLocation.Location = (thirdPoint.GpPnt);
pointLocation.XDirection = (new gpDir(vectorV2V3));
return(pointLocation);
case 2:
return(leftArrowAxis);
case 3:
return(topArrowAxis);
case 4:
return(rightArrowAxis);
case 5:
return(bottomArrowAxis);
default:
return(null);
}
}
public override void UpdatePointPosition(int index, Mouse3DPosition vertex)
{
var firstPoint = Dependency[0].TransformedPoint3D;
var secondPoint = Dependency[1].TransformedPoint3D;
var thirdPoint = Dependency[2].TransformedPoint3D;
if (firstPoint.IsEqual(vertex.Point) || secondPoint.IsEqual(vertex.Point) ||
thirdPoint.IsEqual(vertex.Point))
{
return;
}
if (firstPoint.IsEqual(new Point3D(0, 0, 0)))
{
var projectionOnP1P2 = GeomUtils.ProjectPointOnLine(firstPoint,
new gpDir(new gpVec(firstPoint.GpPnt,
secondPoint.GpPnt)),
vertex.Point);
if (projectionOnP1P2 != null)
{
if (projectionOnP1P2.Value.Distance(firstPoint) < Precision.Confusion)
{
return;
}
}
var projectionOnP2P3 = GeomUtils.ProjectPointOnLine(secondPoint,
new gpDir(new gpVec(secondPoint.GpPnt,
thirdPoint.GpPnt)),
vertex.Point);
if (projectionOnP2P3 != null)
{
if (projectionOnP2P3.Value.Distance(secondPoint) < Precision.Confusion)
{
return;
}
}
}
var vectorV2V1 = new gpVec(secondPoint.GpPnt, firstPoint.GpPnt);
var vectorV2V3 = new gpVec(secondPoint.GpPnt, thirdPoint.GpPnt);
if (vectorV2V1.IsParallel(vectorV2V3, Precision.Angular))
{
return;
}
var rectangleNormalVector = vectorV2V1.Crossed(vectorV2V3);
if (rectangleNormalVector.Magnitude < Precision.Confusion)
{
return;
}
switch (index)
{
case 0:
SetFirstPointDraggingHandle(thirdPoint, vertex);
break;
case 1:
SetSecondPointDraggingHandle(vectorV2V1, vertex, secondPoint);
break;
case 2:
SetLeftArrowDraggingHandle(firstPoint, vertex, thirdPoint);
break;
case 3:
SetTopArrowDraggingHandle(thirdPoint, vertex, firstPoint);
break;
case 4:
SetRightArrowDraggingHandle(vertex);
break;
case 5:
SetBottomArrowDraggingHandle(firstPoint, vertex);
break;
}
}