public DVectorArray3(int nCount = 0) { vector = new DVector <T>(); if (nCount > 0) { vector.resize(nCount * 3); } }
/// <summary> /// resize the list-of-lists /// </summary> public void Resize(int new_size) { int cur_size = list_heads.size; if (new_size > cur_size) { list_heads.resize(new_size); for (int k = cur_size; k < new_size; ++k) { list_heads[k] = Null; } } }
public MeshTriInfoCache(DMesh3 mesh) { int NT = mesh.TriangleCount; Centroids = new DVector <Vector3d>(); Centroids.resize(NT); Normals = new DVector <Vector3d>(); Normals.resize(NT); Areas = new DVector <double>(); Areas.resize(NT); gParallel.ForEach(mesh.TriangleIndices(), (tid) => { Vector3d c, n; double a; mesh.GetTriInfo(tid, out n, out a, out c); Centroids[tid] = c; Normals[tid] = n; Areas[tid] = a; }); }
protected virtual void InitializeVertexBufferForPass() { if (vBufferV.size < mesh.MaxVertexID) { vBufferV.resize(mesh.MaxVertexID + mesh.MaxVertexID / 5); } if (vModifiedV.Length < mesh.MaxVertexID) { vModifiedV = new BitArray(2 * mesh.MaxVertexID); } else { vModifiedV.SetAll(false); } }
public void EnableVertexColors(Vector3f initial_color) { if (HasVertexColors) { return; } colors = new DVector <float>(); int NV = MaxVertexID; colors.resize(3 * NV); for (int i = 0; i < NV; ++i) { int vi = 3 * i; colors[vi] = initial_color.x; colors[vi + 1] = initial_color.y; colors[vi + 2] = initial_color.z; } }
// TODO: parallel version, cache tri normals void Compute_FaceAvg_AreaWeighted() { int NV = Mesh.MaxVertexID; if (NV != Normals.size) { Normals.resize(NV); } for (int i = 0; i < NV; ++i) { Normals[i] = Vector3d.Zero; } var Normals_lock = new SpinLock(); gParallel.ForEach(Mesh.TriangleIndices(), (ti) => { Index3i tri = Mesh.GetTriangle(ti); Vector3d va = Mesh.GetVertex(tri.a); Vector3d vb = Mesh.GetVertex(tri.b); Vector3d vc = Mesh.GetVertex(tri.c); Vector3d N = MathUtil.Normal(ref va, ref vb, ref vc); double a = MathUtil.Area(ref va, ref vb, ref vc); bool taken = false; Normals_lock.Enter(ref taken); Normals[tri.a] += a * N; Normals[tri.b] += a * N; Normals[tri.c] += a * N; Normals_lock.Exit(); }); gParallel.BlockStartEnd(0, NV - 1, (vi_start, vi_end) => { for (int vi = vi_start; vi <= vi_end; vi++) { if (Normals[vi].LengthSquared > MathUtil.ZeroTolerancef) { Normals[vi] = Normals[vi].Normalized; } } }); }
// TODO: parallel version, cache tri normals void Compute_FaceAvg_AreaWeighted() { int NV = Mesh.MaxVertexID; if (NV != Normals.size) { Normals.resize(NV); } for (int i = 0; i < NV; ++i) { Normals[i] = Vector3d.Zero; } int NT = Mesh.MaxTriangleID; for (int ti = 0; ti < NT; ++ti) { if (Mesh.IsTriangle(ti) == false) { continue; } Index3i tri = Mesh.GetTriangle(ti); Vector3d va = Mesh.GetVertex(tri.a); Vector3d vb = Mesh.GetVertex(tri.b); Vector3d vc = Mesh.GetVertex(tri.c); Vector3d N = MathUtil.Normal(va, vb, vc); double a = MathUtil.Area(va, vb, vc); Normals[tri.a] += a * N; Normals[tri.b] += a * N; Normals[tri.c] += a * N; } for (int vi = 0; vi < NV; ++vi) { if (Normals[vi].LengthSquared > MathUtil.ZeroTolerancef) { Normals[vi].Normalize(); } } }
public void trim(int maxIndex) { free_indices = new DVector <int>(); ref_counts.resize(maxIndex); used_count = maxIndex; }
public void Resize(int count) { vector.resize(3 * count); }
public DVectorArray2(int nCount = 0) { vector = new DVector <T>(); vector.resize(nCount * 2); }
protected virtual void do_split(Line2d line, bool insert_edges, int insert_gid) { if (EdgeSigns.Length < Graph.MaxVertexID) { EdgeSigns.resize(Graph.MaxVertexID); } foreach (int vid in Graph.VertexIndices()) { EdgeSigns[vid] = line.WhichSide(Graph.GetVertex(vid), OnVertexTol); } hits.Clear(); foreach (int eid in Graph.EdgeIndices()) { Index2i ev = Graph.GetEdgeV(eid); var signs = new Index2i(EdgeSigns[ev.a], EdgeSigns[ev.b]); if (signs.a * signs.b > 0) { continue; // both positive or negative, ignore } var hit = new edge_hit() { hit_eid = eid, vtx_signs = signs, hit_vid = -1 }; Vector2d a = Graph.GetVertex(ev.a); Vector2d b = Graph.GetVertex(ev.b); // parallel-edge case (both are zero) if (signs.a == signs.b) { if (a.DistanceSquared(b) > MathUtil.Epsilon) { // we need to somehow not insert a new segment for this span below. // so, insert two hit points for the ray-interval, with same eid. // This will result in this span being skipped by the same-eid test below // *however*, if other edges self-intersect w/ this segment, this will *not work* // and duplicate edges will be inserted hit.hit_vid = ev.a; hit.line_t = line.Project(a); hits.Add(hit); hit.hit_vid = ev.b; hit.line_t = line.Project(b); hits.Add(hit); } else { // degenerate edge - fall through to a == 0 case below signs.b = 1; } } if (signs.a == 0) { hit.hit_pos = a; hit.hit_vid = ev.a; hit.line_t = line.Project(a); } else if (signs.b == 0) { hit.hit_pos = b; hit.hit_vid = ev.b; hit.line_t = line.Project(b); } else { var intr = new IntrLine2Segment2(line, new Segment2d(a, b)); if (intr.Find() == false) { throw new Exception("GraphSplitter2d.Split: signs are different but ray did not it?"); } if (intr.IsSimpleIntersection) { hit.hit_pos = intr.Point; hit.line_t = intr.Parameter; } else { throw new Exception("GraphSplitter2d.Split: got parallel edge case!"); } } hits.Add(hit); } // sort by increasing ray-t hits.Sort((hit0, hit1) => { return(hit0.line_t.CompareTo(hit1.line_t)); }); // insert segments between successive intersection points int N = hits.Count; for (int i = 0; i < N - 1; ++i) { int j = i + 1; // note: skipping parallel segments depends on this eid == eid test (see above) if (hits[i].line_t == hits[j].line_t || hits[i].hit_eid == hits[j].hit_eid) { continue; } int vi = hits[i].hit_vid; int vj = hits[j].hit_vid; if (vi == vj && vi >= 0) { continue; } if (vi >= 0 && vj >= 0) { int existing = Graph.FindEdge(vi, vj); if (existing >= 0) { continue; } } if (vi == -1) { DGraph2.EdgeSplitInfo split; var result = Graph.SplitEdge(hits[i].hit_eid, out split); if (result != MeshResult.Ok) { throw new Exception("GraphSplitter2d.Split: first edge split failed!"); } vi = split.vNew; Graph.SetVertex(vi, hits[i].hit_pos); edge_hit tmp = hits[i]; tmp.hit_vid = vi; hits[i] = tmp; } if (vj == -1) { DGraph2.EdgeSplitInfo split; var result = Graph.SplitEdge(hits[j].hit_eid, out split); if (result != MeshResult.Ok) { throw new Exception("GraphSplitter2d.Split: second edge split failed!"); } vj = split.vNew; Graph.SetVertex(vj, hits[j].hit_pos); edge_hit tmp = hits[j]; tmp.hit_vid = vj; hits[j] = tmp; } // check if we actually want to add this segment if (InsideTestF != null) { Vector2d midpoint = 0.5 * (Graph.GetVertex(vi) + Graph.GetVertex(vj)); if (InsideTestF(midpoint) == false) { continue; } } if (insert_edges) { Graph.AppendEdge(vi, vj, insert_gid); } } }
public StandardSculptCurveDeformation() { NewV = new DVector <Vector3d>(); NewV.resize(256); ModifiedV = new BitArray(256); }
public override DeformInfo Apply(Frame3f vNextPos) { Interval1d edgeRangeSqr = Interval1d.Empty; int N = Curve.VertexCount; if (N > NewV.size) { NewV.resize(N); } if (N > ModifiedV.Length) { ModifiedV = new BitArray(2 * N); } // clear modified ModifiedV.SetAll(false); bool bSmooth = (SmoothAlpha > 0 && SmoothIterations > 0); double r2 = Radius * Radius; // deform pass if (DeformF != null) { for (int i = 0; i < N; ++i) { Vector3d v = Curve[i]; double d2 = (v - vPreviousPos.Origin).LengthSquared; if (d2 < r2) { double t = WeightFunc(Math.Sqrt(d2), Radius); Vector3d vNew = DeformF(i, t); if (bSmooth == false) { if (i > 0) { edgeRangeSqr.Contain(vNew.DistanceSquared(Curve[i - 1])); } if (i < N - 1) { edgeRangeSqr.Contain(vNew.DistanceSquared(Curve[i + 1])); } } NewV[i] = vNew; ModifiedV[i] = true; } } } else { // anything? } // smooth pass if (bSmooth) { for (int j = 0; j < SmoothIterations; ++j) { int iStart = (Curve.Closed) ? 0 : 1; int iEnd = (Curve.Closed) ? N : N - 1; for (int i = iStart; i < iEnd; ++i) { Vector3d v = (ModifiedV[i]) ? NewV[i] : Curve[i]; double d2 = (v - vPreviousPos.Origin).LengthSquared; if (ModifiedV[i] || d2 < r2) // always smooth any modified verts { double a = SmoothAlpha * WeightFunc(Math.Sqrt(d2), Radius); int iPrev = (i == 0) ? N - 1 : i - 1; int iNext = (i + 1) % N; Vector3d vPrev = (ModifiedV[iPrev]) ? NewV[iPrev] : Curve[iPrev]; Vector3d vNext = (ModifiedV[iNext]) ? NewV[iNext] : Curve[iNext]; Vector3d c = (vPrev + vNext) * 0.5f; NewV[i] = (1 - a) * v + (a) * c; ModifiedV[i] = true; if (i > 0) { edgeRangeSqr.Contain(NewV[i].DistanceSquared(Curve[i - 1])); } if (i < N - 1) { edgeRangeSqr.Contain(NewV[i].DistanceSquared(Curve[i + 1])); } } } } } // bake for (int i = 0; i < N; ++i) { if (ModifiedV[i]) { Curve[i] = NewV[i]; } } return(new DeformInfo() { minEdgeLenSqr = edgeRangeSqr.a, maxEdgeLenSqr = edgeRangeSqr.b }); }