private List <PlaneHelper> GetPlaneHelpers([NotNull] IFeature feature)
{
const bool includeAssociatedParts = true;
SegmentsPlaneProvider planeProvider =
SegmentsPlaneProvider.Create(feature, includeAssociatedParts);
var indexedMultiPatch = (IIndexedMultiPatch)planeProvider.IndexedSegments;
var result = new List <PlaneHelper>();
SegmentsPlane segmentsPlane;
while ((segmentsPlane = planeProvider.ReadPlane()) != null)
{
result.Add(PlaneHelper.Create(segmentsPlane, indexedMultiPatch, this));
}
return(result);
}
public static GpuDemGeometry CreateGeometry(RasterDatabase.RasterDatabase rDatabase, Device gDevice,
out float maxValue, GDALReader reader)
{
// create actual geometry - tesselated plane
IndexBuffer geomPlaneIndices;
PlaneHelper.CreateIndexBuffer(gDevice, 14, 14, out geomPlaneIndices);
VertexBuffer geomPlaneVerts;
PlaneHelper.CreateVertexBufferInside(gDevice, 16, 16, new Vector2(1, 1), out geomPlaneVerts);
VertexBuffer geomPatchVerts;
PlaneHelper.CreatePatchVertexBuffer(gDevice, 16, 16, new Vector2(1, 1), out geomPatchVerts);
IndexBuffer geomPatchIndices;
PlaneHelper.CreatePatchIndexBuffer(gDevice, 16, 16, out geomPatchIndices);
// create cache of all depths
RectangleGroupQuadTree rTree = rDatabase.ProduceLayerMipMap(0, 256);
RectangleGroupQuadTree.GroupNode[][] dataNodes = new RectangleGroupQuadTree.GroupNode[rTree.Depth][];
for (int depth = 0; depth < rTree.Depth; depth++)
{
RectangleGroupQuadTree.GroupNode[] nodes;
rTree.GetNodes(depth + 1, out nodes);
dataNodes[depth] = nodes;
}
GpuDemGeometry geom = new GpuDemGeometry(new Vector3(), new Vector3(10, 0, 10), new Vector3(5, 0, 5),
16 * 16, 15 * 15 * 2, PrimitiveType.TriangleList,
gDevice);
geom.geomPlaneVerts = geomPlaneVerts;
geom.geomPlaneIndices = geomPlaneIndices;
geom.geomPatchIndices = geomPatchIndices;
geom.geomPatchVerts = geomPatchVerts;
geom.reader = reader;
geom.dataNodes = dataNodes;
geom.ViewUpdated(new Vector3());
maxValue = 1;
return(geom);
}
private bool IsCoincident([NotNull] PlaneHelper planeHelper,
[NotNull] Pnt point,
double xyTolerance)
{
double near = Math.Max(xyTolerance, PointCoincidence);
double near2 = near * near;
double nearEdge2 = 0;
if (EdgeCoincidence > 0)
{
double nearEdge = Math.Max(xyTolerance, EdgeCoincidence);
nearEdge2 = nearEdge * nearEdge;
}
const bool as3D = true;
foreach (SegmentProxy segment in planeHelper.GetSegments())
{
if (segment.GetStart(as3D).Dist2(point) < near2)
{
return(true);
}
if (EdgeCoincidence > 0)
{
double fraction =
SegmentUtils.GetClosestPointFraction(segment, point, as3D);
if (fraction >= 0 && fraction <= 1)
{
IPnt edgePoint = segment.GetPointAt(fraction, as3D);
if (point.Dist2(edgePoint) < nearEdge2)
{
return(true);
}
}
}
}
return(false);
}
// Use this for initialization
void Start()
{
// generate the mesh
planeMesh = PlaneHelper.CreatePlane(resolution, resolution);
// add this whenever you'll be updating the mesh frequently
planeMesh.MarkDynamic();
// add these components for our GameObject to be able to display meshes
MeshFilter mf = gameObject.AddComponent <MeshFilter>();
MeshRenderer mr = gameObject.AddComponent <MeshRenderer>();
// assign our new mesh to this gameobject
// sharedMesh means the data will be a pointer instead of copied
mf.sharedMesh = planeMesh;
mr.material = material;
// cache the vertex array so we won't need to allocate each frame
cacheVertices = planeMesh.vertices;
perlin = new ImprovedPerlin();
}
private int Check([NotNull] PlaneHelper planeHelper,
[NotNull] IPointsEnumerator points,
[NotNull] IFeature feature,
[NotNull] IFeature related)
{
var errorCount = 0;
if (ReportNonCoplanarity)
{
errorCount += planeHelper.ReportErrors(feature);
}
if (!planeHelper.IsPlaneDefined)
{
return(errorCount);
}
if (IgnoreNonCoplanarFaces && !planeHelper.IsCoplanar)
{
return(errorCount);
}
if (_minimumSlopeTan2 > 0 && planeHelper.GetSlopeTan2() < _minimumSlopeTan2)
{
return(errorCount);
}
IBox box = planeHelper.GetSearchBox();
foreach (Pnt point in points.GetPoints(box))
{
errorCount += Check(planeHelper, point, points.XYTolerance, CheckMethod,
feature, related);
}
return(errorCount);
}
private int CheckNonCoincidentVertical([NotNull] PlaneHelper planeHelper,
[NotNull] Pnt point,
[NotNull] IFeature feature,
[NotNull] IFeature related)
{
if (!planeHelper.IsInFootprint(point))
{
return(NoError);
}
double zMin = planeHelper.GetMinPlaneZ(point);
if (double.IsNaN(zMin))
{
return(NoError); // TODO revise
}
double dzMin = zMin - point[2];
double zMax = planeHelper.GetMaxPlaneZ(point);
double dzMax = point[2] - zMax;
if (PlaneCoincidence >= 0 &&
(dzMax - PlaneCoincidence) < 0 &&
(dzMin - PlaneCoincidence) < 0)
{
// TODO : is this the right criteria to ignore checks?
return(NoError);
}
var errorCount = 0;
if (dzMin >= 0 && dzMin < _minimumDistanceBelow)
{
string cmp =
FormatLengthComparison(
dzMin, "<", _minimumDistanceBelow,
feature.Shape.SpatialReference);
errorCount +=
ReportError(
$"Point is {cmp} below face",
GeometryFactory.CreatePoint(point.X, point.Y, point[2]),
Codes[Code.PointTooCloseBelowFace], null,
feature, related);
}
if (dzMax >= 0 && dzMax < _minimumDistanceAbove)
{
string cmp =
FormatLengthComparison(
dzMax, "<", _minimumDistanceAbove,
feature.Shape.SpatialReference);
errorCount +=
ReportError(
$"Point is {cmp} above face",
GeometryFactory.CreatePoint(point.X, point.Y, point[2]),
Codes[Code.PointTooCloseAboveFace], null,
feature, related);
}
if (dzMin <= 0 && dzMax <= 0)
{
errorCount +=
ReportError(
"Point is within non-coplanarity of face",
GeometryFactory.CreatePoint(point.X, point.Y, point[2]),
Codes[Code.PointInNonCoplanarityOfFace], null,
feature, related);
}
return(errorCount);
}
private void intersectToolStripMenuItem_Click(object sender, EventArgs e)
{
if (listView1.SelectedItems.Count != 2)
{
return;
}
var i0 = listView1.SelectedItems[0].Tag as HelperItem;
var i1 = listView1.SelectedItems[1].Tag as HelperItem;
var objs = new[] { i0, i1 };
if (i0 is LineHelper lh0 && i1 is LineHelper lh1)
{
var inter = Geometry.Intersect3dCrossedLines(new Line3D()
{
Start = lh0.Start, End = lh0.End
}, new Line3D()
{
Start = lh1.Start, End = lh1.End
});
if (inter != null && !double.IsNaN(inter.Value.X) && !double.IsInfinity(inter.Value.X))
{
Helpers.Add(new PointHelper()
{
Position = inter.Value
});
updateHelpersList();
}
else
{
SetStatus("no intersection", StatusTypeEnum.Warning);
}
}
if (objs.Any(z => z is LineHelper) && objs.Any(z => z is PointHelper))
{
var pl = objs.First(z => z is PointHelper) as PointHelper;
var th = objs.First(z => z is LineHelper) as LineHelper;
var l = new Line3D()
{
Start = th.Start, End = th.End
};
if (l.IsPointOnLine(pl.Position))
{
SetStatus($"point is on line ({(l.IsPointInsideSegment(pl.Position) ? "inside" : "not inside")})", StatusTypeEnum.Information);
}
else
{
SetStatus("point is not on line", StatusTypeEnum.Warning);
}
}
if (objs.Any(z => z is TriangleHelper) && objs.Any(z => z is PlaneHelper))
{
var pl = objs.First(z => z is PlaneHelper) as PlaneHelper;
var th = objs.First(z => z is TriangleHelper) as TriangleHelper;
var n0 = th.V2 - th.V0;
var n1 = th.V1 - th.V0;
var normal = Vector3d.Cross(n0, n1);
var pln = new PlaneHelper()
{
Position = th.V0, Normal = normal
};
var ln = pln.Intersect(pl);
if (ln != null)
{
Helpers.Add(new LineHelper()
{
Start = ln.Start, End = ln.End
});
updateHelpersList();
}
}
if (objs.All(z => z is PlaneHelper))
{
var pl = objs[0] as PlaneHelper;
var pl2 = objs[1] as PlaneHelper;
var ln = pl2.Intersect(pl);
if (ln != null)
{
Helpers.Add(new LineHelper()
{
Start = ln.Start, End = ln.End
});
updateHelpersList();
}
}
}
