internal double Evaluate(Point3D point)
{
var x = point.X;
var y = point.Y;
var z = point.Z;
var components = new[] {
x * x, y * y, z * z, 2 * x * y, 2 * x * z, 2 * y * z, 2 * x, 2 * y, 2 * z, +1
};
var result = 0.0;
for (var i = 0; i < 10; ++i) {
result += _coefficients[i] * components[i];
}
return result;
}
/// <summary>
/// Cuts the mesh with the specified plane. (Modified from HelixToolkit.Wpf version)
/// </summary>
/// <param name="mesh">
/// The mesh.
/// </param>
/// <param name="plane">
/// The plane origin.
/// </param>
/// <param name="normal">
/// The plane normal.
/// </param>
/// <returns>
/// The <see cref="MeshGeometry3D"/>.
/// </returns>
public static MeshGeometry3D CutMesh(this MeshGeometry3D mesh, Media3D.Point3D plane, Vector3 normal)
{
var hasTextureCoordinates = mesh.TextureCoordinates != null && mesh.TextureCoordinates.Count > 0;
var hasNormals = mesh.Normals != null && mesh.Normals.Count > 0;
var meshBuilder = new MeshBuilder(hasNormals, hasTextureCoordinates);
var contourHelper = new HelixToolkit.Wpf.SharpDX.Helpers.ContourHelperDX(plane, normal, mesh);
foreach (var position in mesh.Positions)
{
meshBuilder.Positions.Add(position);
}
if (hasTextureCoordinates)
{
foreach (var textureCoordinate in mesh.TextureCoordinates)
{
meshBuilder.TextureCoordinates.Add(textureCoordinate);
}
}
if (hasNormals)
{
foreach (var n in mesh.Normals)
{
meshBuilder.Normals.Add(n);
}
}
for (var i = 0; i < mesh.Indices.Count; i += 3)
{
var index0 = mesh.Indices[i];
var index1 = mesh.Indices[i + 1];
var index2 = mesh.Indices[i + 2];
Vector3[] positions;
Vector3[] normals;
Vector2[] textureCoordinates;
int[] triangleIndices;
contourHelper.ContourFacet(index0, index1, index2, out positions, out normals, out textureCoordinates, out triangleIndices);
foreach (var p in positions)
{
meshBuilder.Positions.Add(p);
}
foreach (var tc in textureCoordinates)
{
meshBuilder.TextureCoordinates.Add(tc);
}
foreach (var n in normals)
{
meshBuilder.Normals.Add(n);
}
foreach (var ti in triangleIndices)
{
meshBuilder.TriangleIndices.Add(ti);
}
}
return meshBuilder.ToMeshGeometry3D();
}
/// <summary>
/// Initializes a new instance of the <see cref="ContourHelperDX" /> class.
/// </summary>
/// <param name="planeOrigin">The plane origin.</param>
/// <param name="planeNormal">The plane normal.</param>
/// <param name="originalMesh">The original mesh.</param>
public ContourHelperDX(Media3D.Point3D planeOrigin, Vector3 planeNormal, MeshGeometry3D originalMesh)
{
var hasNormals = originalMesh.Normals != null && originalMesh.Normals.Count > 0;
var hasTextureCoordinates = originalMesh.TextureCoordinates != null && originalMesh.TextureCoordinates.Count > 0;
this.normals = hasNormals ? new Vector3[3] : null;
this.textures = hasTextureCoordinates ? new Vector2[3] : null;
this.positionCount = originalMesh.Positions.Count;
this.meshPositions = originalMesh.Positions.ToArray();
this.meshNormals = hasNormals ? originalMesh.Normals.ToArray() : null;
this.meshTextureCoordinates = hasTextureCoordinates ? originalMesh.TextureCoordinates.ToArray() : null;
// Determine the equation of the plane as
// ax + by + cz + d = 0
var l = (float)Math.Sqrt((planeNormal.X * planeNormal.X) + (planeNormal.Y * planeNormal.Y) + (planeNormal.Z * planeNormal.Z));
this.a = planeNormal.X / l;
this.b = planeNormal.Y / l;
this.c = planeNormal.Z / l;
this.d = -(float)((planeNormal.X * planeOrigin.X) + (planeNormal.Y * planeOrigin.Y) + (planeNormal.Z * planeOrigin.Z));
}
