// Figure out if we can collapse edge eid=[a,b] under current constraint set.
// First we resolve vertex constraints using can_collapse_vtx(). However this
// does not catch some topological cases at the edge-constraint level, which
// which we will only be able to detect once we know if we are losing a or b.
// See comments on can_collapse_vtx() for what collapse_to is for.
protected bool can_collapse_constraints(int eid, int a, int b, int c, int d, int tc, int td, out int collapse_to)
{
collapse_to = -1;
if (constraints == null)
{
return(true);
}
bool bVtx = can_collapse_vtx(eid, a, b, out collapse_to);
if (bVtx == false)
{
return(false);
}
// when we lose a vtx in a collapse, we also lose two edges [iCollapse,c] and [iCollapse,d].
// If either of those edges is constrained, we would lose that constraint.
// This would be bad.
int iCollapse = (collapse_to == a) ? b : a;
if (c != DMesh3.InvalidID)
{
int ec = mesh.FindEdgeFromTri(iCollapse, c, tc);
if (constraints.GetEdgeConstraint(ec).IsUnconstrained == false)
{
return(false);
}
}
if (d != DMesh3.InvalidID)
{
int ed = mesh.FindEdgeFromTri(iCollapse, d, td);
if (constraints.GetEdgeConstraint(ed).IsUnconstrained == false)
{
return(false);
}
}
return(true);
}
protected virtual ProcessResult CollapseEdge(int edgeID, Vector3d vNewPos, out int collapseToV)
{
collapseToV = DMesh3.InvalidID;
RuntimeDebugCheck(edgeID);
EdgeConstraint constraint =
(constraints == null) ? EdgeConstraint.Unconstrained : constraints.GetEdgeConstraint(edgeID);
if (constraint.NoModifications)
{
return(ProcessResult.Ignored_EdgeIsFullyConstrained);
}
if (constraint.CanCollapse == false)
{
return(ProcessResult.Ignored_EdgeIsFullyConstrained);
}
// look up verts and tris for this edge
int a = 0, b = 0, t0 = 0, t1 = 0;
if (mesh.GetEdge(edgeID, ref a, ref b, ref t0, ref t1) == false)
{
return(ProcessResult.Failed_NotAnEdge);
}
bool bIsBoundaryEdge = (t1 == DMesh3.InvalidID);
// look up 'other' verts c (from t0) and d (from t1, if it exists)
Index3i T0tv = mesh.GetTriangle(t0);
int c = IndexUtil.find_tri_other_vtx(a, b, T0tv);
Index3i T1tv = (bIsBoundaryEdge) ? DMesh3.InvalidTriangle : mesh.GetTriangle(t1);
int d = (bIsBoundaryEdge) ? DMesh3.InvalidID : IndexUtil.find_tri_other_vtx(a, b, T1tv);
Vector3d vA = mesh.GetVertex(a);
Vector3d vB = mesh.GetVertex(b);
double edge_len_sqr = (vA - vB).LengthSquared;
if (edge_len_sqr > MinEdgeLength * MinEdgeLength)
{
return(ProcessResult.Ignored_EdgeTooLong);
}
begin_collapse();
// check if we should collapse, and also find which vertex we should collapse to,
// in cases where we have constraints/etc
int collapse_to = -1;
bool bCanCollapse = can_collapse_constraints(edgeID, a, b, c, d, t0, t1, out collapse_to);
if (bCanCollapse == false)
{
return(ProcessResult.Ignored_Constrained);
}
// if we have a boundary, we want to collapse to boundary
if (PreserveBoundary && HaveBoundary)
{
if (collapse_to != -1)
{
if ((IsBoundaryV(b) && collapse_to != b) ||
(IsBoundaryV(a) && collapse_to != a))
{
return(ProcessResult.Ignored_Constrained);
}
}
if (IsBoundaryV(b))
{
collapse_to = b;
}
else if (IsBoundaryV(a))
{
collapse_to = a;
}
}
// optimization: if edge cd exists, we cannot collapse or flip. look that up here?
// funcs will do it internally...
// (or maybe we can collapse if cd exists? edge-collapse doesn't check for it explicitly...)
ProcessResult retVal = ProcessResult.Failed_OpNotSuccessful;
int iKeep = b, iCollapse = a;
// if either vtx is fixed, collapse to that position
if (collapse_to == b)
{
vNewPos = vB;
}
else if (collapse_to == a)
{
iKeep = a; iCollapse = b;
vNewPos = vA;
}
else
{
vNewPos = get_projected_collapse_position(iKeep, vNewPos);
}
// check if this collapse will create a normal flip. Also checks
// for invalid collapse nbrhood, since we are doing one-ring iter anyway.
// [TODO] could we skip this one-ring check in CollapseEdge? pass in hints?
if (creates_flip_or_invalid(a, b, ref vNewPos, t0, t1) || creates_flip_or_invalid(b, a, ref vNewPos, t0, t1))
{
retVal = ProcessResult.Ignored_CreatesFlip;
goto skip_to_end;
}
// lots of cases where we cannot collapse, but we should just let
// mesh sort that out, right?
COUNT_COLLAPSES++;
DMesh3.EdgeCollapseInfo collapseInfo;
MeshResult result = mesh.CollapseEdge(iKeep, iCollapse, out collapseInfo);
if (result == MeshResult.Ok)
{
collapseToV = iKeep;
mesh.SetVertex(iKeep, vNewPos);
if (constraints != null)
{
constraints.ClearEdgeConstraint(edgeID);
constraints.ClearEdgeConstraint(collapseInfo.eRemoved0);
if (collapseInfo.eRemoved1 != DMesh3.InvalidID)
{
constraints.ClearEdgeConstraint(collapseInfo.eRemoved1);
}
constraints.ClearVertexConstraint(iCollapse);
}
OnEdgeCollapse(edgeID, iKeep, iCollapse, collapseInfo);
DoDebugChecks();
retVal = ProcessResult.Ok_Collapsed;
}
skip_to_end:
end_collapse();
return(retVal);
}
protected virtual ProcessResult ProcessEdge(int edgeID)
{
RuntimeDebugCheck(edgeID);
EdgeConstraint constraint =
(constraints == null) ? EdgeConstraint.Unconstrained : constraints.GetEdgeConstraint(edgeID);
if (constraint.NoModifications)
{
return(ProcessResult.Ignored_EdgeIsFullyConstrained);
}
// look up verts and tris for this edge
int a = 0, b = 0, t0 = 0, t1 = 0;
if (mesh.GetEdge(edgeID, ref a, ref b, ref t0, ref t1) == false)
{
return(ProcessResult.Failed_NotAnEdge);
}
bool bIsBoundaryEdge = (t1 == DMesh3.InvalidID);
// look up 'other' verts c (from t0) and d (from t1, if it exists)
Index3i T0tv = mesh.GetTriangle(t0);
int c = IndexUtil.find_tri_other_vtx(a, b, T0tv);
Index3i T1tv = (bIsBoundaryEdge) ? DMesh3.InvalidTriangle : mesh.GetTriangle(t1);
int d = (bIsBoundaryEdge) ? DMesh3.InvalidID : IndexUtil.find_tri_other_vtx(a, b, T1tv);
Vector3d vA = mesh.GetVertex(a);
Vector3d vB = mesh.GetVertex(b);
double edge_len_sqr = (vA - vB).LengthSquared;
begin_collapse();
// check if we should collapse, and also find which vertex we should collapse to,
// in cases where we have constraints/etc
int collapse_to = -1;
bool bCanCollapse = EnableCollapses &&
constraint.CanCollapse &&
edge_len_sqr < MinEdgeLength * MinEdgeLength &&
can_collapse_constraints(edgeID, a, b, c, d, t0, t1, out collapse_to);
// optimization: if edge cd exists, we cannot collapse or flip. look that up here?
// funcs will do it internally...
// (or maybe we can collapse if cd exists? edge-collapse doesn't check for it explicitly...)
// if edge length is too short, we want to collapse it
bool bTriedCollapse = false;
if (bCanCollapse)
{
int iKeep = b, iCollapse = a;
Vector3d vNewPos = (vA + vB) * 0.5;
// if either vtx is fixed, collapse to that position
if (collapse_to == b)
{
vNewPos = vB;
}
else if (collapse_to == a)
{
iKeep = a; iCollapse = b;
vNewPos = vA;
}
else
{
vNewPos = get_projected_collapse_position(iKeep, vNewPos);
}
// TODO be smart about picking b (keep vtx).
// - swap if one is bdry vtx, for example?
// lots of cases where we cannot collapse, but we should just let
// mesh sort that out, right?
COUNT_COLLAPSES++;
DMesh3.EdgeCollapseInfo collapseInfo;
MeshResult result = mesh.CollapseEdge(iKeep, iCollapse, out collapseInfo);
if (result == MeshResult.Ok)
{
mesh.SetVertex(iKeep, vNewPos);
if (constraints != null)
{
constraints.ClearEdgeConstraint(edgeID);
constraints.ClearEdgeConstraint(collapseInfo.eRemoved0);
if (collapseInfo.eRemoved1 != DMesh3.InvalidID)
{
constraints.ClearEdgeConstraint(collapseInfo.eRemoved1);
}
constraints.ClearVertexConstraint(iCollapse);
}
OnEdgeCollapse(edgeID, iKeep, iCollapse, collapseInfo);
DoDebugChecks();
return(ProcessResult.Ok_Collapsed);
}
else
{
bTriedCollapse = true;
}
}
end_collapse();
begin_flip();
// if this is not a boundary edge, maybe we want to flip
bool bTriedFlip = false;
if (EnableFlips && constraint.CanFlip && bIsBoundaryEdge == false)
{
// don't want to flip if it will invert triangle...tetrahedron sign??
// can we do this more efficiently somehow?
bool a_is_boundary_vtx = (MeshIsClosed) ? false : (bIsBoundaryEdge || mesh.vertex_is_boundary(a));
bool b_is_boundary_vtx = (MeshIsClosed) ? false : (bIsBoundaryEdge || mesh.vertex_is_boundary(b));
bool c_is_boundary_vtx = (MeshIsClosed) ? false : mesh.vertex_is_boundary(c);
bool d_is_boundary_vtx = (MeshIsClosed) ? false : mesh.vertex_is_boundary(d);
int valence_a = mesh.GetVtxEdgeCount(a), valence_b = mesh.GetVtxEdgeCount(b);
int valence_c = mesh.GetVtxEdgeCount(c), valence_d = mesh.GetVtxEdgeCount(d);
int valence_a_target = (a_is_boundary_vtx) ? valence_a : 6;
int valence_b_target = (b_is_boundary_vtx) ? valence_b : 6;
int valence_c_target = (c_is_boundary_vtx) ? valence_c : 6;
int valence_d_target = (d_is_boundary_vtx) ? valence_d : 6;
// if total valence error improves by flip, we want to do it
int curr_err = Math.Abs(valence_a - valence_a_target) + Math.Abs(valence_b - valence_b_target)
+ Math.Abs(valence_c - valence_c_target) + Math.Abs(valence_d - valence_d_target);
int flip_err = Math.Abs((valence_a - 1) - valence_a_target) + Math.Abs((valence_b - 1) - valence_b_target)
+ Math.Abs((valence_c + 1) - valence_c_target) + Math.Abs((valence_d + 1) - valence_d_target);
if (flip_err < curr_err)
{
// try flip
DMesh3.EdgeFlipInfo flipInfo;
COUNT_FLIPS++;
MeshResult result = mesh.FlipEdge(edgeID, out flipInfo);
if (result == MeshResult.Ok)
{
DoDebugChecks();
return(ProcessResult.Ok_Flipped);
}
else
{
bTriedFlip = true;
}
}
}
end_flip();
begin_split();
// if edge length is too long, we want to split it
bool bTriedSplit = false;
if (EnableSplits && constraint.CanSplit && edge_len_sqr > MaxEdgeLength * MaxEdgeLength)
{
DMesh3.EdgeSplitInfo splitInfo;
COUNT_SPLITS++;
MeshResult result = mesh.SplitEdge(edgeID, out splitInfo);
if (result == MeshResult.Ok)
{
update_after_split(edgeID, a, b, splitInfo);
OnEdgeSplit(edgeID, a, b, splitInfo);
DoDebugChecks();
return(ProcessResult.Ok_Split);
}
else
{
bTriedSplit = true;
}
}
end_split();
if (bTriedFlip || bTriedSplit || bTriedCollapse)
{
return(ProcessResult.Failed_OpNotSuccessful);
}
else
{
return(ProcessResult.Ignored_EdgeIsFine);
}
}