public virtual void Update()
{
base.begin_update();
if (MeshSource == null)
{
throw new Exception("TrimMeshFromCurveOp: must set valid MeshSource to compute!");
}
if (CurveSource == null)
{
throw new Exception("TrimMeshFromCurveOp: must set valid CurveSource to compute!");
}
IMesh meshIn = MeshSource.GetIMesh();
//ISpatial spatialIn = MeshSource.GetSpatial();
DCurve3 curve = new DCurve3(CurveSource.GetICurve());
TrimmedMesh = new DMesh3(meshIn, MeshHints.None);
AxisAlignedBox3d bounds = TrimmedMesh.CachedBounds;
Vector3d seed = bounds.Center + bounds.Extents.y * Vector3d.AxisY;
MeshTrimLoop trim = new MeshTrimLoop(TrimmedMesh, curve, seed, null);
trim.Trim();
ApplyModifiers(TrimmedMesh);
base.complete_update();
}
void CreateNewPreview(bool bIsCurve)
{
preview = null;
curvePreview = null;
if (bIsCurve)
{
curvePreview = new CurveRevolvePreview();
curvePreview.Create(scene.TransparentNewSOMaterial, scene.RootGameObject, -1);
sceneCurve = new DCurve3();
curvePreview.RevolveCurve = sceneCurve;
axisCurve = new DCurve3();
curvePreview.AxisCurve = axisCurve;
curvePreview.Visible = false;
}
else
{
preview = new RevolvePreview();
preview.Create(scene.TransparentNewSOMaterial, scene.RootGameObject, -1);
sceneCurve = new DCurve3();
preview.Curve = sceneCurve;
preview.Axis = scene.SceneFrame;
preview.Visible = false;
}
// need to do this if we switch between revolve-around-object and revolve-around-curve
if (curveSO != null)
{
update_curve_vertices(curveSO);
}
}
// figuring out a decent line width is tricky. Want to be responsive to camera
// pos, so line doesn't get super-thick when zoomed in. So we want to measure
// screen-space radius. But off-screen vertices are a problem. So, only consider
// vertices within a level, pointing-forward view cone (can't be actual view cone
// because then line thickness changes as you turn head!).
//
// Also sub-sample verts for efficiency. Probably we don't need to do this
// every frame...but how to distribute?
//
// ***returns 0*** if we couldn't find any points in view cone
public static float EstimateStableCurveWidth(FScene scene,
Frame3f curveFrameS, DCurve3 curve, float fVisualAngleDeg)
{
// do computations in Scene coords..."safest"?
Vector3f camPos = scene.ActiveCamera.GetPosition();
Vector3f camForward = scene.ActiveCamera.Forward();
// use level-forward
camForward[1] = 0; camForward.Normalize();
camPos = scene.ToSceneP(camPos);
camForward = scene.ToSceneN(camForward);
const float ViewConeDotThresh = 0.707106f; // 45 degrees
int nSubSampleInc = Math.Max(2, curve.VertexCount / 10);
float rSum = 0; int iSum = 0;
for (int k = 0; k < curve.VertexCount; k += nSubSampleInc)
{
Vector3f vS = (Vector3f)curve.GetVertex(k);
vS = curveFrameS.FromFrameP(vS);
Vector3f dv = (vS - camPos).Normalized;
if (dv.Dot(camForward) < ViewConeDotThresh)
{
continue;
}
float r = VRUtil.GetVRRadiusForVisualAngle(vS, camPos, fVisualAngleDeg);
rSum += r; iSum++;
}
return((rSum == 0) ? 0 : scene.ToWorldDimension(rSum / (float)iSum));
}
void draw_lines(LineSet lines, Vector3f cameraPos)
{
GL.Begin(GL.LINES);
GL.Color(lines.Color);
int NS = lines.Segments.Count;
for (int k = 0; k < NS; ++k)
{
Segment3d seg = lines.Segments[k];
GL.Vertex((Vector3)seg.P0);
GL.Vertex((Vector3)seg.P1);
}
GL.End();
int NC = lines.Curves.Count;
for (int k = 0; k < NC; ++k)
{
DCurve3 c = lines.Curves[k];
GL.Begin(GL.LINE_STRIP);
GL.Color(lines.Color);
int NV = c.VertexCount;
for (int i = 0; i < NV; ++i)
{
GL.Vertex((Vector3)c[i]);
}
if (c.Closed)
{
GL.Vertex((Vector3)c[0]);
}
GL.End();
}
}
/// <summary>
/// Request a copy of the internal curve from a background thread.
/// If curve is dirty, this will block until it is computed in PreRender (which will then signal this thread).
/// </summary>
public DCurve3 RequestCurveCopyFromBGThread()
{
if (FPlatform.InMainThread())
{
throw new Exception("ThreadSafePolyCurveSO.RequestCurveCopyFromBGThread: called from main thread!");
}
bool wait_for_compute = false;
lock (curve_copy_lock) {
if (curve_copy == null || this.curve.Timestamp != curve_timestamp || target_model_modified)
{
wait_for_compute = true;
}
}
if (wait_for_compute)
{
waiter.WaitOne();
}
DCurve3 result;
lock (curve_copy_lock) {
result = new DCurve3(curve_copy);
result.Timestamp = curve_copy.Timestamp;
}
return(result);
}
public override void PreRender()
{
base.PreRender();
if (this.curve.Timestamp != curve_timestamp || target_model_modified)
{
// lock copy-curve while we rebuild it
lock (curve_copy_lock) {
curve_copy = new DCurve3(this.curve);
if (TransformMode == OutputCurveTransform.ToTargetSO && TargetModelSO == null)
{
throw new InvalidOperationException("ThreadSafePolyCurveSO.PreRender: no TargetSO but target mode requested!");
}
for (int k = 0; k < curve_copy.VertexCount; ++k)
{
Vector3f f = (Vector3f)curve_copy[k];
f = SceneTransforms.ObjectToSceneP(this, f);
if (TransformMode == OutputCurveTransform.ToTargetSO)
{
f = SceneTransforms.SceneToObjectP(TargetModelSO, f);
}
curve_copy[k] = f;
}
curve_copy.Timestamp = this.curve.Timestamp;
}
waiter.Set(); // signal any threads waiting on this update
curve_timestamp = this.curve.Timestamp;
target_model_modified = false;
on_curve_validated();
}
}
/// <summary>
/// Creates ag3.DCurve from a geometry
/// </summary>
/// <param name="curve"> this curve</param>
/// <param name="geom"> the OGR geometry to ue as ths source</param>
/// <param name="crs"> the crs to u for the DCurve3 DEFAULT map default projections or EPG:4326 if none</param>
/// <returns></returns>
public static DCurve3 FromGeometry(this DCurve3 curve, Geometry geom, SpatialReference crs = null)
{
if (geom.GetSpatialReference() == null)
{
if (crs != null)
{
geom.AssignSpatialReference(crs);
}
else
{
geom.AssignSpatialReference(AppState.instance.projectCrs);
}
}
if (geom.TransformTo(AppState.instance.mapProj) != 0)
{
throw new NotSupportedException("projection failed");
}
if (geom.Transform(AppState.instance.mapTrans) != 0)
{
throw new NotSupportedException("axis change failed");
}
int n = geom.GetPointCount();
Vector3d[] ls = new Vector3d[n];
for (int i = 0; i < n; i++)
{
double[] argout = new double[3];
geom.GetPoint(i, argout);
ls[i] = new Vector3d(argout);
}
curve.ClearVertices();
curve.SetVertices(ls);
curve.Closed = geom.IsRing();
return(curve);
}
public PolyCurveSO Create(SOMaterial defaultMaterial)
{
if (curve == null)
{
LineGenerator gen = new LineGenerator()
{
Start = Vector3.zero, End = 10.0f * Vector3.up, StepSize = 0.1f
};
gen.Generate();
curve = new DCurve3();
gen.Make(curve);
}
// assumes type identifier is something like BlahBlahSO
root = new GameObject(UniqueNames.GetNext(Type.identifier.Remove(Type.identifier.Length - 2)));
if (EnableLineRenderer)
{
LineRenderer ren = root.AddComponent <LineRenderer>();
ren.startWidth = ren.endWidth = 0.05f;
ren.useWorldSpace = false;
}
AssignSOMaterial(defaultMaterial); // need to do this to setup BaseSO material stack
Material useMaterial = CurrentMaterial;
Create_internal(useMaterial);
UpdateGeometry();
increment_timestamp();
return(this);
}
public static void TestOffsetAnimation()
{
Window window = new Window("TestFill");
window.SetDefaultSize(600, 600);
window.SetPosition(WindowPosition.Center);
DMesh3 mesh = StandardMeshReader.ReadMesh("c:\\scratch\\remesh.obj");
MeshBoundaryLoops loops = new MeshBoundaryLoops(mesh);
DCurve3 curve = loops[0].ToCurve();
Polygon2d poly = new Polygon2d();
foreach (Vector3d v in curve.Vertices)
{
poly.AppendVertex(v.xy);
}
Outer = new GeneralPolygon2d(poly);
DebugViewCanvas view = new DebugViewCanvas();
view.AddPolygon(Outer, Colorf.Black);
DGraph2 graph = TopoOffset2d.QuickCompute(Outer, AnimOffset, AnimSpacing);
view.AddGraph(graph, Colorf.Red);
window.Add(view);
window.ShowAll();
Active = view;
}
void enable_circle_indicator(bool enable)
{
if (enable == false && circle_indicator == null)
{
return;
}
if (enable && circle_indicator == null)
{
LineSet lines = new LineSet();
lines.UseFixedNormal = true;
lines.FixedNormal = Vector3f.AxisY;
DCurve3 curve = new DCurve3(Polygon2d.MakeCircle(gizmoInitialRadius, 64), 0, 2);
lines.Curves.Add(curve);
lines.Width = 1.0f;
lines.WidthType = LineWidthType.Pixel;
lines.Segments.Add(
new Segment3d(Vector3d.Zero, gizmoInitialRadius * diagonals[nRotationAxis]));
lines.Color = Colorf.DimGrey;
circle_indicator = new fLineSetGameObject(new GameObject(), lines, "circle");
circle_indicator.SetLayer(FPlatform.WidgetOverlayLayer, true);
circle_indicator.SetLocalRotation(Quaternionf.FromTo(Vector3f.AxisY, Frame3f.Identity.GetAxis(nRotationAxis)));
RootGameObject.AddChild(circle_indicator, false);
}
circle_indicator.SetVisible(enable);
}
protected void GetPlanarPolys(PlanarRegion r, List <Polygon2d> polys)
{
try {
MeshRegionBoundaryLoops loops = new MeshRegionBoundaryLoops(r.Mesh, r.Triangles);
foreach (var loop in loops)
{
DCurve3 curve = loop.ToCurve();
Polygon2d poly = new Polygon2d();
int NV = curve.VertexCount;
for (int k = 0; k < NV; k++)
{
poly.AppendVertex(curve[k].xy);
}
polys.Add(poly);
}
} catch (Exception) {
// add each triangle as a polygon and let clipper sort it out
Vector3d v0 = Vector3d.Zero, v1 = Vector3d.Zero, v2 = Vector3d.Zero;
foreach (int tid in r.Triangles)
{
r.Mesh.GetTriVertices(tid, ref v0, ref v1, ref v2);
Polygon2d p = new Polygon2d();
p.AppendVertex(v0.xy); p.AppendVertex(v1.xy); p.AppendVertex(v2.xy);
polys.Add(p);
}
}
}
public override List <ISnapPoint> GeneratePoints(SceneObject so)
{
List <ISnapPoint> v = new List <ISnapPoint>();
if (so is PolyCurveSO)
{
PolyCurveSO curveSO = so as PolyCurveSO;
DCurve3 curve = curveSO.Curve;
Frame3f f = Frame3f.Identity;
Frame3f startFrame = new Frame3f((Vector3f)curve.Start, -(Vector3f)curve.Tangent(0), 1);
v.Add(new SOFrameSnapPoint(curveSO)
{
frame = f.FromFrame(startFrame)
});
Frame3f endFrame = new Frame3f((Vector3f)curve.End, (Vector3f)curve.Tangent(curve.VertexCount - 1), 1);
v.Add(new SOFrameSnapPoint(curveSO)
{
frame = f.FromFrame(endFrame)
});
}
if (base.EnableGeometry)
{
base.build_geometry(so, v);
}
return(v);
}
public ImplicitCurve3d(DCurve3 curve, double radius)
{
Curve = curve;
Radius = radius;
Box = curve.GetBoundingBox();
Box.Expand(Radius);
spatial = new DCurve3BoxTree(curve);
}
void draw_quads(LineSet lines, Vector3f cameraPos)
{
GL.Begin(GL.QUADS);
GL.Color(lines.Color);
int NS = lines.Segments.Count;
for (int k = 0; k < NS; ++k)
{
Segment3d seg = lines.Segments[k];
Vector3f start = (Vector3f)seg.P0, end = (Vector3f)seg.P1;
if (lines.UseFixedNormal)
{
draw_quad_fixednormal(ref start, ref end, ref lines.FixedNormal, lines.Width);
}
else
{
draw_quad_viewalign(ref start, ref end, ref cameraPos, lines.Width);
}
}
int NC = lines.Curves.Count;
for (int k = 0; k < NC; ++k)
{
DCurve3 c = lines.Curves[k];
int NV = c.VertexCount;
Vector3f prev = (Vector3f)c[0];
for (int i = 1; i < NV; ++i)
{
Vector3f cur = (Vector3f)c[i];
if (lines.UseFixedNormal)
{
draw_quad_fixednormal(ref prev, ref cur, ref lines.FixedNormal, lines.Width);
}
else
{
draw_quad_viewalign(ref prev, ref cur, ref cameraPos, lines.Width);
}
prev = cur;
}
if (c.Closed)
{
Vector3f cur = (Vector3f)c[0];
if (lines.UseFixedNormal)
{
draw_quad_fixednormal(ref prev, ref cur, ref lines.FixedNormal, lines.Width);
}
else
{
draw_quad_viewalign(ref prev, ref cur, ref cameraPos, lines.Width);
}
}
}
GL.End();
}
public DCurve3 RequestCurveCopyFromMainThread()
{
DCurve3 result;
lock (curve_copy_lock) {
result = new DCurve3(curve_copy);
}
return(result);
}
/// <summary>
/// Creates g3.DCurve from Vector3[]
/// </summary>
/// <param name="curve">DCurve</param>
/// <param name="verteces">Vextor3[]</param>
/// <param name="bClosed">whether the line is closed</param>
public static DCurve3 Vector3(this DCurve3 curve, Vector3[] verteces, bool bClosed)
{
curve.ClearVertices();
curve.Closed = bClosed;
foreach (Vector3 vertex in verteces)
{
curve.AppendVertex(vertex);
}
return(curve);
}
public static void compute_distance_image()
{
DMesh3 mesh = StandardMeshReader.ReadMesh("c:\\scratch\\remesh.obj");
MeshBoundaryLoops loops = new MeshBoundaryLoops(mesh);
DCurve3 curve = loops[0].ToCurve();
Polygon2d poly = new Polygon2d();
foreach (Vector3d v in curve.Vertices)
{
poly.AppendVertex(v.xy);
}
int N = 1024;
double cellsize = poly.Bounds.MaxDim / (double)N;
Vector2d o = poly.Bounds.Min;
o -= 4 * cellsize * Vector2d.One;
N += 8;
ShiftGridIndexer2 indexer = new ShiftGridIndexer2(poly.Bounds.Min, cellsize);
double[] df = new double[N * N];
double maxd = 0;
for (int yi = 0; yi < N; ++yi)
{
for (int xi = 0; xi < N; ++xi)
{
Vector2d p = indexer.FromGrid(new Vector2i(xi, yi));
double d = Math.Sqrt(poly.DistanceSquared(p));
df[yi * N + xi] = d;
maxd = Math.Max(d, maxd);
}
}
SKBitmap bmp = new SKBitmap(N, N);
for (int yi = 0; yi < N; ++yi)
{
for (int xi = 0; xi < N; ++xi)
{
double d = df[yi * N + xi];
float f = (float)(d / maxd);
byte b = (byte)(int)(f * 255);
bmp.SetPixel(xi, yi, new SKColor(b, b, b));
}
}
using (var image = SKImage.FromBitmap(bmp))
using (var data = image.Encode(SKEncodedImageFormat.Png, 80)) {
// save the data to a stream
using (var stream = File.OpenWrite("c:\\scratch\\distances.png")) {
data.SaveTo(stream);
}
}
}
public static DCurve3 ExtractLoopV(IMesh mesh, int[] vertices)
{
DCurve3 curve = new DCurve3();
for (int i = 0; i < vertices.Length; ++i)
{
curve.AppendVertex(mesh.GetVertex(vertices[i]));
}
curve.Closed = true;
return(curve);
}
public static Rhino.Geometry.PolylineCurve ToRhino(this DCurve3 _crv)
{
List <Rhino.Geometry.Point3d> pts = new List <Rhino.Geometry.Point3d>(_crv.VertexCount);
for (int i = 0; i < _crv.VertexCount; i++)
{
pts.Add(_crv[i].ToRhinoPt());
}
return(new Rhino.Geometry.PolylineCurve(pts));
}
public static void Store(DCurve3 curve, BinaryWriter writer)
{
writer.Write(curve.Closed);
writer.Write(curve.VertexCount);
for (int i = 0; i < curve.VertexCount; ++i)
{
writer.Write(curve[i].x);
writer.Write(curve[i].y);
writer.Write(curve[i].z);
}
}
public static void PreserveBoundaryLoops(MeshConstraints cons, NGonsCore.geometry3Sharp.mesh.DMesh3 mesh)
{
MeshBoundaryLoops loops = new MeshBoundaryLoops(mesh);
foreach (EdgeLoop loop in loops)
{
DCurve3 loopC = MeshUtil.ExtractLoopV(mesh, loop.Vertices);
DCurveProjectionTarget target = new DCurveProjectionTarget(loopC);
ConstrainVtxLoopTo(cons, mesh, loop.Vertices, target);
}
}
public static DCurve3 ExtractLoopV(IMesh mesh, IEnumerable <int> vertices)
{
DCurve3 curve = new DCurve3();
foreach (int vid in vertices)
{
curve.AppendVertex(mesh.GetVertex(vid));
}
curve.Closed = true;
return(curve);
}
/// <summary>
/// Converts DCurve3 whihc is in Local Vector3d coordinates to Vector3[] World coordinates
/// </summary>
/// <param name="curve">input curve</param>
/// <returns>Vector3[] in world coordinates</returns>
public static Vector3[] ToWorld(this DCurve3 curve)
{
List <Vector3> ret = new List <Vector3>();
List <Vector3d> vertexes = curve.Vertices as List <Vector3d>;
for (int i = 0; i < curve.VertexCount; i++)
{
Vector3 local = (Vector3)vertexes[i];
ret.Add(AppState.instance.map.transform.TransformVector(local));
}
return(ret.ToArray());
}
public virtual SceneObject BuildSO(Func <DCurve3, SceneObject> SOBuilderF, SOMaterial material, float scale = 1.0f)
{
// create shifted curve
Vector3d vCenter = curve.GetBoundingBox().Center;
DCurve3 shifted = bake_transform(-vCenter);
Frame3f shiftedFrame = new Frame3f((Vector3f)vCenter, Quaternionf.Identity);
SceneObject so = SOBuilderF(shifted);
so.SetLocalFrame(shiftedFrame, CoordSpace.WorldCoords);
return(so);
}
public DCurve3 ExtractDCurve()
{
if (!curve_valid)
{
Update();
}
var result = Curve;
Curve = null;
curve_valid = false;
return(result);
}
public static void Restore(DCurve3 curve, BinaryReader reader)
{
curve.Closed = reader.ReadBoolean();
int count = reader.ReadInt32();
for (int i = 0; i < count; ++i)
{
double x = reader.ReadDouble();
double y = reader.ReadDouble();
double z = reader.ReadDouble();
curve.AppendVertex(new Vector3D(x, y, z));
}
}
void project_to_target()
{
PolyCurveSO sourceSO = targets[0];
DCurve3 curve = sourceSO.Curve;
int N = curve.VertexCount;
for (int i = 0; i < N; ++i)
{
Vector3f v = (Vector3f)curve[i];
Vector3f vW = SceneTransforms.TransformTo(v, sourceSO, CoordSpace.ObjectCoords, CoordSpace.WorldCoords);
vW = (Vector3f)ProjectionTarget.Project(vW);
curve[i] = SceneTransforms.TransformTo(vW, sourceSO, CoordSpace.WorldCoords, CoordSpace.ObjectCoords);
}
}
public void Create(SOMaterial useMaterial, fGameObject parent)
{
if (curve == null)
{
curve = new DCurve3();
}
meshObject = GameObjectFactory.CreateMeshGO("mesh_tube_preview");
//meshObject.SetMesh(new fMesh())
meshObject.SetMaterial(MaterialUtil.ToMaterialf(useMaterial));
bUpdatePending = true;
parent.AddChild(meshObject, false);
}
public MeshFacesFromLoop(NGonsCore.geometry3Sharp.mesh.DMesh3 Mesh, DCurve3 SpaceCurve, ISpatial Spatial, int tSeed)
{
this.Mesh = Mesh;
int N = SpaceCurve.VertexCount;
InitialLoopT = new int[N];
for (int i = 0; i < N; ++i)
{
InitialLoopT[i] = Spatial.FindNearestTriangle(SpaceCurve[i]);
}
find_path();
find_interior_from_seed(tSeed);
}
/// <summary>
/// Estimates the 3D centroid of a DCurve
/// </summary>
/// <param name="curve">DCurve</param>
/// <returns>Vector3[]</returns>
public static Vector3d Center(this DCurve3 curve)
{
Vector3d center = Vector3d.Zero;
int len = curve.SegmentCount;
if (!curve.Closed)
{
len++;
}
for (int i = 0; i < len; i++)
{
center += curve.GetVertex(i);
}
center /= len;
return(center);
}
