/// <summary>
/// Apply Transform to vertices and normals of mesh
/// </summary>
public static void PerVertexTransform(IDeformableMesh mesh, TransformSequence xform)
{
int NV = mesh.MaxVertexID;
if (mesh.HasVertexNormals)
{
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
mesh.SetVertex(vid, xform.TransformP(mesh.GetVertex(vid)));
mesh.SetVertexNormal(vid, (Vector3f)xform.TransformV(mesh.GetVertexNormal(vid)));
}
}
}
else
{
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
mesh.SetVertex(vid, xform.TransformP(mesh.GetVertex(vid)));
}
}
}
}
public static void FlipLeftRightCoordSystems(IDeformableMesh mesh)
{
int NV = mesh.MaxVertexID;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d v = mesh.GetVertex(vid);
v.z = -v.z;
mesh.SetVertex(vid, v);
if (mesh.HasVertexNormals)
{
Vector3f n = mesh.GetVertexNormal(vid);
n.z = -n.z;
mesh.SetVertexNormal(vid, n);
}
}
}
if (mesh is DMesh3)
{
(mesh as DMesh3).ReverseOrientation(false);
}
else
{
throw new Exception("argh don't want this in IDeformableMesh...but then for SimpleMesh??");
}
}
/// <summary>
/// Apply TransformF to subset of vertices of mesh
/// </summary>
public static void PerVertexTransform(IDeformableMesh mesh, IEnumerable <int> vertices, Func <Vector3d, int, Vector3d> TransformF)
{
foreach (int vid in vertices)
{
if (mesh.IsVertex(vid))
{
Vector3d newPos = TransformF(mesh.GetVertex(vid), vid);
mesh.SetVertex(vid, newPos);
}
}
}
/// <summary>
/// Apply TransformF to subset of mesh vertices defined by MapV[vertices]
/// </summary>
public static void PerVertexTransform(IDeformableMesh targetMesh, IDeformableMesh sourceMesh, int[] mapV, Func <Vector3d, int, int, Vector3d> TransformF)
{
foreach (int vid in sourceMesh.VertexIndices())
{
int map_vid = mapV[vid];
if (targetMesh.IsVertex(map_vid))
{
Vector3d newPos = TransformF(targetMesh.GetVertex(map_vid), vid, map_vid);
targetMesh.SetVertex(map_vid, newPos);
}
}
}
public static void ConvertYUpToZUp(IDeformableMesh mesh)
{
int NV = mesh.MaxVertexID;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d v = mesh.GetVertex(vid);
mesh.SetVertex(vid, new Vector3d(v.x, -v.z, v.y));
}
}
}
public static void Rotate(IDeformableMesh mesh, Vector3d origin, Quaterniond rotation)
{
int NV = mesh.MaxVertexID;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d v = rotation * (mesh.GetVertex(vid) - origin) + origin;
mesh.SetVertex(vid, v);
}
}
}
public static void PerVertexTransform(IDeformableMesh mesh, Func <Vector3d, Vector3f, Vector3d> TransformF)
{
int NV = mesh.MaxVertexID;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d newPos = TransformF(mesh.GetVertex(vid), mesh.GetVertexNormal(vid));
mesh.SetVertex(vid, newPos);
}
}
}
public static void VertexNormalOffset(IDeformableMesh mesh, double offsetDistance)
{
int NV = mesh.MaxVertexID;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d newPos = mesh.GetVertex(vid) + offsetDistance * (Vector3d)mesh.GetVertexNormal(vid);
mesh.SetVertex(vid, newPos);
}
}
}
public static void Scale(IDeformableMesh mesh, double sx, double sy, double sz)
{
int NV = mesh.MaxVertexID;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d v = mesh.GetVertex(vid);
v.x *= sx; v.y *= sy; v.z *= sz;
mesh.SetVertex(vid, v);
}
}
}
public static void FromFrame(IDeformableMesh mesh, Frame3f f)
{
int NV = mesh.MaxVertexID;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d vf = mesh.GetVertex(vid);
Vector3d v = f.FromFrameP((Vector3f)vf);
mesh.SetVertex(vid, v);
}
}
}
public static void Translate(IDeformableMesh mesh, double tx, double ty, double tz)
{
int NV = mesh.MaxVertexID;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d v = mesh.GetVertex(vid);
v.x += tx; v.y += ty; v.z += tz;
mesh.SetVertex(vid, v);
}
}
}
public static void Rotate(IDeformableMesh mesh, Vector3d origin, Quaternionf rotation)
{
int NV = mesh.MaxVertexID;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d v = mesh.GetVertex(vid);
v -= origin;
v = (Vector3d)(rotation * (Vector3f)v);
v += origin;
mesh.SetVertex(vid, v);
}
}
}
public static void Scale(IDeformableMesh mesh, Vector3d scale, Vector3d origin)
{
int NV = mesh.MaxVertexID;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d v = mesh.GetVertex(vid);
v.x -= origin.x; v.y -= origin.y; v.z -= origin.z;
v.x *= scale.x; v.y *= scale.y; v.z *= scale.z;
v.x += origin.x; v.y += origin.y; v.z += origin.z;
mesh.SetVertex(vid, v);
}
}
}
/// <summary>
/// Transfer new vertex positions to target
/// </summary>
public void UpdateVertices(IDeformableMesh target)
{
bool bNormals = target.HasVertexNormals;
update_from();
foreach (int vid in target.VertexIndices())
{
int i = MapV[vid];
target.SetVertex(vid, From[i]);
if (bNormals)
{
target.SetVertexNormal(vid,
Rotation * target.GetVertexNormal(vid));
}
}
}
public static void Rotate(IDeformableMesh mesh, Vector3d origin, Quaterniond rotation)
{
bool bHasNormals = mesh.HasVertexNormals;
int NV = mesh.MaxVertexID;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d v = rotation * (mesh.GetVertex(vid) - origin) + origin;
mesh.SetVertex(vid, v);
if (bHasNormals)
{
mesh.SetVertexNormal(vid, (Vector3f)(rotation * mesh.GetVertexNormal(vid)));
}
}
}
}
public static void ConvertYUpToZUp(IDeformableMesh mesh)
{
int NV = mesh.MaxVertexID;
bool bHasNormals = mesh.HasVertexNormals;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d v = mesh.GetVertex(vid);
mesh.SetVertex(vid, new Vector3d(v.x, -v.z, v.y));
if (bHasNormals)
{
Vector3f n = mesh.GetVertexNormal(vid);
mesh.SetVertexNormal(vid, new Vector3f(n.x, -n.z, n.y));
}
}
}
}
/// <summary> Map mesh *from* local frame coordinates into "world" coordinates </summary>
public static void FromFrame(IDeformableMesh mesh, Frame3f f)
{
int NV = mesh.MaxVertexID;
bool bHasNormals = mesh.HasVertexNormals;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d vf = mesh.GetVertex(vid);
Vector3d v = f.FromFrameP((Vector3f)vf);
mesh.SetVertex(vid, v);
if (bHasNormals)
{
Vector3f n = mesh.GetVertexNormal(vid);
Vector3f nf = f.FromFrameV(n);
mesh.SetVertexNormal(vid, nf);
}
}
}
}
// Modeled after FlipLeftRightCoordSystems and ConvertYUpToZUp examples
public static void ApplyTransform(IDeformableMesh mesh, Matrix4X4 matrix, Vector2 printCenter)
{
int NV = mesh.MaxVertexID;
for (int vid = 0; vid < NV; ++vid)
{
if (mesh.IsVertex(vid))
{
Vector3d v = mesh.GetVertex(vid);
// Transform point to MatterControl bed translation
var vec3 = new Vector3(v.x, v.y, v.z);
var transformed = vec3.Transform(matrix);
// Update and reset
v.x = transformed.X - printCenter.X;
v.y = transformed.Y - printCenter.Y;
v.z = transformed.Z;
mesh.SetVertex(vid, v);
}
}
}
public static void Scale(IDeformableMesh mesh, double s)
{
Scale(mesh, s, s, s);
}
public static void Translate(IDeformableMesh mesh, Vector3d v)
{
Translate(mesh, v.x, v.y, v.z);
}
public static void Scale(IDeformableMesh mesh, double sx, double sy, double sz)
{
Scale(mesh, new Vector3d(sx, sy, sz), Vector3d.Zero);
}
