public virtual void Update()
{
base.begin_update();
if (MeshSource == null)
{
throw new Exception("VectorDisplacementMapOp: must set valid MeshSource to compute!");
}
IMesh imesh = MeshSource.GetIMesh();
if (imesh.HasVertexNormals == false)
{
throw new Exception("VectorDisplacementMapOp: input mesh does not have surface normals...");
}
if (imesh is DMesh3 == false)
{
throw new Exception("VectorDisplacementMapOp: in current implementation, input mesh must be a DMesh3. Ugh.");
}
DMesh3 mesh = imesh as DMesh3;
lock (Displacement) {
if (have_set_displacement)
{
lock (set_displacement) {
if (set_displacement.Count == mesh.MaxVertexID)
{
Displacement.Set(set_displacement);
}
have_set_displacement = false;
}
}
else if (Displacement.Count != mesh.MaxVertexID)
{
Displacement.Clear();
Displacement.Resize(mesh.MaxVertexID);
}
}
base.complete_update();
}
public virtual void Update()
{
if (MeshSource == null)
{
throw new Exception("PlaneBandExpansionOp: must set valid MeshSource to compute!");
}
IMesh imesh = MeshSource.GetIMesh();
if (imesh.HasVertexNormals == false)
{
throw new Exception("PlaneBandExpansionOp: input mesh does not have surface normals...");
}
if (imesh is DMesh3 == false)
{
throw new Exception("RegionOffsetOp: in current implementation, input mesh must be a DMesh3. Ugh.");
}
DMesh3 mesh = imesh as DMesh3;
IList <int> faces = IndexSource.GetIndices();
// [RMS] this is all f'n ugly!
MeshVertexSelection selection = new MeshVertexSelection(mesh);
selection.SelectTriangleVertices(faces);
// ugly
List <Vector2d> seeds = new List <Vector2d>();
foreach (int vid in selection)
{
foreach (int nbrvid in mesh.VtxVerticesItr(vid))
{
if (selection.IsSelected(nbrvid) == false)
{
seeds.Add(new Vector2d(vid, 0));
break;
}
}
}
Func <int, int, float> distanceF = (a, b) => { return((float)mesh.GetVertex(a).Distance(mesh.GetVertex(b))); };
Func <int, bool> nodeF = (vid) => { return(selection.IsSelected(vid)); };
DijkstraGraphDistance dijkstra = new DijkstraGraphDistance(mesh.MaxVertexID, true, nodeF, distanceF, mesh.VtxVerticesItr, seeds);
dijkstra.Compute();
float maxDist = dijkstra.MaxDistance;
Displacement.Clear();
Displacement.Resize(mesh.MaxVertexID);
// todo: can do this in parallel...
foreach (int vid in selection)
{
//Vector3d v = mesh.GetVertex(vid);
// [TODO]...
double dist = maxDist - dijkstra.GetDistance(vid);
double falloff = MathUtil.WyvillFalloff(dist, maxDist * 0.0, maxDist);
Vector3d n = mesh.GetVertexNormal(vid);
n = n - n.Dot(normal) * normal;
n.Normalize();
Displacement[vid] = falloff * offset_distance * n;
}
// smooth it?
result_valid = true;
}
public virtual void Update()
{
if (MeshSource == null)
{
throw new Exception("EnclosedRegionOffsetOp: must set valid MeshSource to compute!");
}
if (MeshSource.HasSpatial == false)
{
throw new Exception("EnclosedRegionOffsetOp: MeshSource must have spatial data structure!");
}
IMesh imesh = MeshSource.GetIMesh();
if (imesh.HasVertexNormals == false)
{
throw new Exception("EnclosedRegionOffsetOp: input mesh does not have surface normals...");
}
if (imesh is DMesh3 == false)
{
throw new Exception("RegionOffsetOp: in current implementation, input mesh must be a DMesh3. Ugh.");
}
DMesh3 mesh = imesh as DMesh3;
ISpatial spatial = MeshSource.GetSpatial();
DCurve3 curve = new DCurve3(CurveSource.GetICurve());
MeshFacesFromLoop loop = new MeshFacesFromLoop(mesh, curve, spatial);
// extract submesh
RegionOperator op = new RegionOperator(mesh, loop.InteriorTriangles);
DMesh3 submesh = op.Region.SubMesh;
// find boundary verts and nbr ring
HashSet <int> boundaryV = new HashSet <int>(MeshIterators.BoundaryEdgeVertices(submesh));
HashSet <int> boundaryNbrs = new HashSet <int>();
foreach (int vid in boundaryV)
{
foreach (int nbrvid in submesh.VtxVerticesItr(vid))
{
if (boundaryV.Contains(nbrvid) == false)
{
boundaryNbrs.Add(nbrvid);
}
}
}
// [TODO] maybe should be not using vertex normal here?
// use an averaged normal, or a constant for patch?
// offset mesh if requested
if (Math.Abs(offset_distance) > 0.0001)
{
foreach (int vid in submesh.VertexIndices())
{
if (boundaryV.Contains(vid))
{
continue;
}
// if inner ring is non-zero, then it gets preserved below, and
// creates a crease...
//double dist = boundaryNbrs.Contains(vid) ? (offset_distance / 2) : offset_distance;
double dist = boundaryNbrs.Contains(vid) ? 0 : offset_distance;
submesh.SetVertex(vid,
submesh.GetVertex(vid) + (float)dist * submesh.GetVertexNormal(vid));
}
}
//double t = MathUtil.Clamp(1.0 - SmoothAlpha, 0.1, 1.0);
double t = 1.0 - SmoothAlpha;
t = t * t;
double boundary_t = 5.0;
double ring_t = 1.0;
// smooth submesh, with boundary-ring constraints
LaplacianMeshSmoother smoother = new LaplacianMeshSmoother(submesh);
foreach (int vid in submesh.VertexIndices())
{
if (boundaryV.Contains(vid))
{
smoother.SetConstraint(vid, submesh.GetVertex(vid), boundary_t, true);
}
else if (boundaryNbrs.Contains(vid))
{
smoother.SetConstraint(vid, submesh.GetVertex(vid), ring_t);
}
else
{
smoother.SetConstraint(vid, submesh.GetVertex(vid), t);
}
}
smoother.SolveAndUpdateMesh();
// turn into displacement vectors
Displacement.Clear();
Displacement.Resize(mesh.MaxVertexID);
foreach (int subvid in op.Region.SubMesh.VertexIndices())
{
Vector3d subv = op.Region.SubMesh.GetVertex(subvid);
int basevid = op.Region.SubToBaseV[subvid];
Vector3d basev = op.Region.BaseMesh.GetVertex(basevid);
Displacement[basevid] = subv - basev;
}
result_valid = true;
}