bool compute_outer_wall()
{
SocketMesh = new DMesh3(InnerMesh);
LastInnerGroupID = SocketMesh.AllocateTriangleGroup();
FaceGroupUtil.SetGroupID(SocketMesh, LastInnerGroupID);
if (DebugStep <= 1)
{
return(true);
}
double use_thickness = thickness;
MeshExtrudeMesh extrude = new MeshExtrudeMesh(SocketMesh);
extrude.ExtrudedPositionF = (v, n, vid) => {
return(v + use_thickness * (Vector3d)n);
};
if (extrude.Extrude() == false)
{
return(false);
}
LastExtrudeOuterGroupID = extrude.OffsetGroupID;
LastStitchGroupID = extrude.StitchGroupIDs[0];
return(true);
}
public List <int> FindPaintedTriangles(DMesh3 mesh, int colorId)
{
List <int> indices = FaceGroupUtil.FindTrianglesByGroup(mesh, colorId);
Debug.Log($"Painted Triangles: {indices.Count}");
if (indices.Count <= 0)
{
Debug.Log("No colored triangles found");
}
return(indices);
}
public static void test_region_boundary()
{
List<int> cases = new List<int>() { 0, 1, 2, 3 };
foreach ( int num in cases ) {
string name;
DMesh3 mesh = MakeBoundaryTestMesh(num, out name);
int[][] groups = FaceGroupUtil.FindTriangleSetsByGroup(mesh, 0);
System.Console.WriteLine("case {0}:", name);
for (int k = 0; k < groups.Length; ++k) {
int gid = mesh.GetTriangleGroup(groups[k][0]);
MeshRegionBoundaryLoops loops = new MeshRegionBoundaryLoops(mesh, groups[k]);
System.Console.WriteLine(" gid {0} : found {1} loops", gid, loops.Loops.Count);
}
}
}
/// <summary>
/// Cut a "partial" hole, ie we cut the mesh with the polygon once, and then
/// extrude downwards to a planar version of the cut boundary.
///
/// Currently only supports extruding downwards from topmost intersection.
///
/// </summary>
protected bool CutPartialHole(DMesh3 mesh, HoleInfo hi, Vector3d translate, bool bUpwards)
{
if (hi.IsVertical == false)
{
throw new Exception("unsupported!");
}
Vector3d basePoint = CombinedBounds.Center - CombinedBounds.Extents.y * Vector3d.AxisY + translate;
// do we need to compute spatial DS for each hole? not super efficient...
DMeshAABBTree3 spatial = new DMeshAABBTree3(mesh, true);
Vector3d direction = (bUpwards) ? Vector3d.AxisY : -Vector3d.AxisY;
Vector3d center = basePoint + new Vector3d(hi.XZOffset.x, 0, hi.XZOffset.y) - 10000 * direction;
Ray3d ray = new Ray3d(center, direction);
int hit_tid = spatial.FindNearestHitTriangle(ray);
if (hit_tid == DMesh3.InvalidID)
{
return(false);
}
IntrRay3Triangle3 intersection = MeshQueries.TriangleIntersection(mesh, hit_tid, ray);
Vector3d inter_pos = ray.PointAt(intersection.RayParameter);
Frame3f projectFrame = new Frame3f(ray.Origin, ray.Direction);
int nVerts = 32;
if (hi.Vertices != 0)
{
nVerts = hi.Vertices;
}
double angleShiftRad = hi.AxisAngleD * MathUtil.Deg2Rad;
Polygon2d circle = Polygon2d.MakeCircle(hi.Radius, nVerts, angleShiftRad);
try {
EdgeLoop loop = null;
MeshInsertProjectedPolygon insert = new MeshInsertProjectedPolygon(mesh, circle, projectFrame, hit_tid)
{
SimplifyInsertion = false
};
if (insert.Insert())
{
loop = insert.InsertedLoop;
// [RMS] do we need to simplify for this one?
//if (loop.VertexCount > circle.VertexCount)
// loop = simplify_loop(mesh, loop, circle.VertexCount);
MeshEditor editor = new MeshEditor(mesh);
Vector3d base_pos = inter_pos;
base_pos.y = basePoint.y + hi.PartialHoleBaseHeight;
int N = loop.VertexCount;
int[] newLoop = new int[N];
for (int k = 0; k < N; ++k)
{
newLoop[k] = mesh.AppendVertex(mesh, loop.Vertices[k]);
Vector3d cur_v = mesh.GetVertex(newLoop[k]);
cur_v.y = base_pos.y;
mesh.SetVertex(newLoop[k], cur_v);
}
int base_vid = mesh.AppendVertex(base_pos);
int[] fan_tris = editor.AddTriangleFan_OrderedVertexLoop(base_vid, newLoop);
FaceGroupUtil.SetGroupID(mesh, fan_tris, hi.PartialHoleGroupID);
int[] stitch_tris = editor.StitchLoop(loop.Vertices, newLoop);
// need to remesh fan region because otherwise we get pathological cases
RegionRemesher remesh = new RegionRemesher(mesh, fan_tris);
remesh.SetTargetEdgeLength(2.0);
remesh.SmoothSpeedT = 1.0;
remesh.PreventNormalFlips = true;
for (int k = 0; k < 25; ++k)
{
remesh.BasicRemeshPass();
}
//remesh.EnableCollapses = remesh.EnableFlips = remesh.EnableSplits = false;
//for (int k = 0; k < 20; ++k)
// remesh.BasicRemeshPass();
remesh.BackPropropagate();
return(true);
}
else
{
return(false);
}
} catch (Exception e) {
f3.DebugUtil.Log("partial hole {0} failed!! {1}", hi.nHole, e.Message);
return(false);
}
}
List <Polygon2d> decompose_cluster_up(DMesh3 mesh)
{
optimize_mesh(mesh);
mesh.CompactInPlace();
mesh.DiscardTriangleGroups(); mesh.EnableTriangleGroups(0);
double minLength = Settings.MaxBridgeWidthMM * 0.75;
double minArea = minLength * minLength;
Dictionary <int, double> areas = new Dictionary <int, double>();
Dictionary <int, HashSet <int> > trisets = new Dictionary <int, HashSet <int> >();
HashSet <int> active_groups = new HashSet <int>();
Action <int, int> add_tri_to_group = (tid, gid) => {
mesh.SetTriangleGroup(tid, gid);
areas[gid] = areas[gid] + mesh.GetTriArea(tid);
trisets[gid].Add(tid);
};
Action <int, int> add_group_to_group = (gid, togid) => {
var set = trisets[togid];
foreach (int tid in trisets[gid])
{
mesh.SetTriangleGroup(tid, togid);
set.Add(tid);
}
areas[togid] += areas[gid];
active_groups.Remove(gid);
};
Func <IEnumerable <int>, int> find_min_area_group = (tri_itr) => {
int min_gid = -1; double min_area = double.MaxValue;
foreach (int tid in tri_itr)
{
int gid = mesh.GetTriangleGroup(tid);
double a = areas[gid];
if (a < min_area)
{
min_area = a;
min_gid = gid;
}
}
return(min_gid);
};
foreach (int eid in MeshIterators.InteriorEdges(mesh))
{
Index2i et = mesh.GetEdgeT(eid);
if (mesh.GetTriangleGroup(et.a) != 0 || mesh.GetTriangleGroup(et.b) != 0)
{
continue;
}
int gid = mesh.AllocateTriangleGroup();
areas[gid] = 0;
trisets[gid] = new HashSet <int>();
active_groups.Add(gid);
add_tri_to_group(et.a, gid);
add_tri_to_group(et.b, gid);
}
foreach (int tid in mesh.TriangleIndices())
{
if (mesh.GetTriangleGroup(tid) != 0)
{
continue;
}
int gid = find_min_area_group(mesh.TriTrianglesItr(tid));
add_tri_to_group(tid, gid);
}
IndexPriorityQueue pq = new IndexPriorityQueue(mesh.MaxGroupID);
foreach (var pair in areas)
{
pq.Insert(pair.Key, (float)pair.Value);
}
while (pq.Count > 0)
{
int gid = pq.First;
pq.Remove(gid);
if (areas[gid] > minArea) // ??
{
break;
}
List <int> nbr_groups = find_neighbour_groups(mesh, gid, trisets[gid]);
int min_gid = -1; double min_area = double.MaxValue;
foreach (int ngid in nbr_groups)
{
double a = areas[ngid];
if (a < min_area)
{
min_area = a;
min_gid = ngid;
}
}
if (min_gid != -1)
{
add_group_to_group(gid, min_gid);
pq.Remove(min_gid);
pq.Insert(min_gid, (float)areas[min_gid]);
}
}
List <Polygon2d> result = new List <Polygon2d>();
int[][] sets = FaceGroupUtil.FindTriangleSetsByGroup(mesh);
foreach (var set in sets)
{
result.Add(make_poly(mesh, set));
}
return(result);
}
// [RMS] This doesn't work because I did something stupid when
// making unwrap meshes. The set of triangles aren't the same. argh.
public static DMesh3 ConvertUnwrapToUVs(RemoteControl rc, out DenseMeshUVSet UVSet, string mainName = "main")
{
int mainID = rc.FindObjectByName(mainName);
rc.CompactMesh(mainID);
DMesh3 mainMesh = ReadMeshFromMM(rc, mainID);
Debug.Assert(mainMesh.IsCompact);
List <int> all = rc.ListObjects();
List <int> unwrapIDs = new List <int>();
foreach (int id in all)
{
string sName = rc.GetObjectName(id);
if (sName.StartsWith("unwrap", StringComparison.OrdinalIgnoreCase))
{
unwrapIDs.Add(id);
}
}
int[] AllGroups = FaceGroupUtil.FindAllGroups(mainMesh).ToArray();
Dictionary <int, DMesh3> Unwraps = new Dictionary <int, DMesh3>();
foreach (int id in unwrapIDs)
{
DMesh3 mesh = ReadMeshFromMM(rc, id);
HashSet <int> subGroups = FaceGroupUtil.FindAllGroups(mesh);
Debug.Assert(subGroups.Count == 1);
int gid = subGroups.ToArray()[0];
Unwraps[gid] = mesh;
}
UVSet = new DenseMeshUVSet();
UVSet.TriangleUVs.resize(mainMesh.TriangleCount);
Dictionary <Index2i, int> UVSetMap = new Dictionary <Index2i, int>();
Dictionary <int, int> GroupCounters = new Dictionary <int, int>();
for (int i = 0; i < AllGroups.Length; ++i)
{
GroupCounters[AllGroups[i]] = 0;
}
for (int ti = 0; ti < mainMesh.TriangleCount; ++ti)
{
Index3i main_tri = mainMesh.GetTriangle(ti);
int gid = mainMesh.GetTriangleGroup(ti);
int sub_tid = GroupCounters[gid];
GroupCounters[gid]++;
DMesh3 SubMesh = Unwraps[gid];
Index3i sub_tri = SubMesh.GetTriangle(sub_tid);
for (int j = 0; j < 3; ++j)
{
int sub_vid = sub_tri[j];
Index2i key = new Index2i(gid, sub_vid);
int uvset_idx;
if (UVSetMap.TryGetValue(key, out uvset_idx) == false)
{
Vector3d v = SubMesh.GetVertex(sub_vid);
Vector2f uv = new Vector2f((float)v.x, (float)v.z);
uvset_idx = UVSet.AppendUV(uv);
UVSetMap[key] = uvset_idx;
}
sub_tri[j] = uvset_idx;
}
UVSet.TriangleUVs[ti] = sub_tri;
}
return(mainMesh);
}
public void Close_Flat()
{
double minlen, maxlen, avglen;
MeshQueries.EdgeLengthStats(Mesh, out minlen, out maxlen, out avglen, 1000);
double target_edge_len = (TargetEdgeLen <= 0) ? avglen : TargetEdgeLen;
// massage around boundary loop
cleanup_boundary(Mesh, InitialBorderLoop, avglen, 3);
// find new border loop
// [TODO] this just assumes there is only one!!
MeshBoundaryLoops loops = new MeshBoundaryLoops(Mesh);
EdgeLoop fill_loop = loops.Loops[0];
int extrude_group = (ExtrudeGroup == -1) ? Mesh.AllocateTriangleGroup() : ExtrudeGroup;
int fill_group = (FillGroup == -1) ? Mesh.AllocateTriangleGroup() : FillGroup;
// decide on projection plane
//AxisAlignedBox3d loopbox = fill_loop.GetBounds();
//Vector3d topPt = loopbox.Center;
//if ( bIsUpper ) {
// topPt.y = loopbox.Max.y + 0.25 * dims.y;
//} else {
// topPt.y = loopbox.Min.y - 0.25 * dims.y;
//}
//Frame3f plane = new Frame3f((Vector3f)topPt);
// extrude loop to this plane
MeshExtrusion extrude = new MeshExtrusion(Mesh, fill_loop);
extrude.PositionF = (v, n, i) => {
return(FlatClosePlane.ProjectToPlane((Vector3F)v, 1));
};
extrude.Extrude(extrude_group);
MeshValidation.IsBoundaryLoop(Mesh, extrude.NewLoop);
Debug.Assert(Mesh.CheckValidity());
// smooth the extrude loop
MeshLoopSmooth loop_smooth = new MeshLoopSmooth(Mesh, extrude.NewLoop);
loop_smooth.ProjectF = (v, i) => {
return(FlatClosePlane.ProjectToPlane((Vector3F)v, 1));
};
loop_smooth.Alpha = 0.5f;
loop_smooth.Rounds = 100;
loop_smooth.Smooth();
Debug.Assert(Mesh.CheckValidity());
// fill result
SimpleHoleFiller filler = new SimpleHoleFiller(Mesh, extrude.NewLoop);
filler.Fill(fill_group);
Debug.Assert(Mesh.CheckValidity());
// make selection for remesh region
MeshFaceSelection remesh_roi = new MeshFaceSelection(Mesh);
remesh_roi.Select(extrude.NewTriangles);
remesh_roi.Select(filler.NewTriangles);
remesh_roi.ExpandToOneRingNeighbours();
remesh_roi.ExpandToOneRingNeighbours();
remesh_roi.LocalOptimize(true, true);
int[] new_roi = remesh_roi.ToArray();
// get rid of extrude group
FaceGroupUtil.SetGroupToGroup(Mesh, extrude_group, 0);
/* clean up via remesh
* - constrain loop we filled to itself
*/
RegionRemesher r = new RegionRemesher(Mesh, new_roi);
DCurve3 top_curve = mesh.MeshUtil.ExtractLoopV(Mesh, extrude.NewLoop.Vertices);
DCurveProjectionTarget curve_target = new DCurveProjectionTarget(top_curve);
int[] top_loop = (int[])extrude.NewLoop.Vertices.Clone();
r.Region.MapVerticesToSubmesh(top_loop);
MeshConstraintUtil.ConstrainVtxLoopTo(r.Constraints, r.Mesh, top_loop, curve_target);
DMeshAABBTree3 spatial = new DMeshAABBTree3(Mesh);
spatial.Build();
MeshProjectionTarget target = new MeshProjectionTarget(Mesh, spatial);
r.SetProjectionTarget(target);
bool bRemesh = true;
if (bRemesh)
{
r.Precompute();
r.EnableFlips = r.EnableSplits = r.EnableCollapses = true;
r.MinEdgeLength = target_edge_len;
r.MaxEdgeLength = 2 * target_edge_len;
r.EnableSmoothing = true;
r.SmoothSpeedT = 1.0f;
for (int k = 0; k < 40; ++k)
{
r.BasicRemeshPass();
}
r.SetProjectionTarget(null);
r.SmoothSpeedT = 0.25f;
for (int k = 0; k < 10; ++k)
{
r.BasicRemeshPass();
}
Debug.Assert(Mesh.CheckValidity());
r.BackPropropagate();
}
// smooth around the join region to clean up ugliness
smooth_region(Mesh, r.Region.BaseBorderV, 3);
}
