// Use this for initialization void Start() { VD = GetComponent <VertexDriver>(); Inter = Intersector.Instance; // create target TargetI = (float)(TargetDistance * Math.Tan(DegToRad(VD.TargetFOV.x / 2.0))); TargetJ = (float)(TargetDistance * Math.Tan(DegToRad(VD.TargetFOV.y / 2.0))); Vector3 TargetBotLeft = new Vector3(-TargetI, -TargetJ, TargetDistance); Vector3 TargetBotRight = new Vector3(TargetI, -TargetJ, TargetDistance); Vector3 TargetTopLeft = new Vector3(-TargetI, TargetJ, TargetDistance); Vector3 TargetTopRight = new Vector3(TargetI, TargetJ, TargetDistance); TargetLines = new List <Vector3[]>(); TargetLines.Add(new Vector3[] { TargetBotLeft, TargetBotRight }); // bottom TargetLines.Add(new Vector3[] { TargetBotRight, TargetTopRight }); // right TargetLines.Add(new Vector3[] { TargetTopRight, TargetTopLeft }); // top TargetLines.Add(new Vector3[] { TargetTopLeft, TargetBotLeft }); // left OcLines = new List <Vector3[]>(); for (int i = 1; i < Inter.OccGridSize.x; i++) { float offset = i * (2f * Math.Abs(TargetI)) / Inter.OccGridSize.x; Vector3 bot = new Vector3(TargetBotLeft.x + offset, TargetBotLeft.y, TargetBotLeft.z); Vector3 top = new Vector3(TargetTopLeft.x + offset, TargetTopLeft.y, TargetTopLeft.z); OcLines.Add(new Vector3[] { bot, top }); } for (int i = 1; i < Inter.OccGridSize.y; i++) { float offset = i * (2f * Math.Abs(TargetJ)) / Inter.OccGridSize.y; Vector3 left = new Vector3(TargetBotLeft.x, TargetBotLeft.y + offset, TargetBotLeft.z); Vector3 right = new Vector3(TargetBotRight.x, TargetBotRight.y + offset, TargetBotRight.z); OcLines.Add(new Vector3[] { left, right }); } TargetContainer = new GameObject(); TargetContainer.name = "TargetContainer"; for (int i = 0; i < TargetLines.Count; i++) { Vector3[] line = TargetLines[i]; VertexDriver.DrawLine(line[0], line[1], TargetContainer, TargetSize, TargetMaterial, i.ToString()); } OcContainer = new GameObject(); OcContainer.name = "OcContainer"; for (int i = 0; i < OcLines.Count; i++) { Vector3[] line = OcLines[i]; VertexDriver.DrawLine(line[0], line[1], OcContainer, OcGridSize, TargetMaterial, i.ToString()); } // create diagnostics panel Diagnostics = new GameObject(); Diagnostics.transform.position = DiagnosticsPosition; DiagnosticsText.transform.parent = Diagnostics.transform; DiagnosticsText.transform.position = Diagnostics.transform.TransformPoint(DiagnosticsText.transform.position); DiagnosticsBackground.transform.parent = Diagnostics.transform; DiagnosticsBackground.transform.position = Diagnostics.transform. TransformPoint(DiagnosticsBackground.transform.position); }
public void Test_Intersect_Between_Arrays_Comparison_Hash() { long averageMs = 0; long averageTicks = 0; int count = 0; Console.WriteLine("Test_Intersect_Between_Arrays_Hash_Average"); for (var i = 0; i < COMPARISON_LOOP; i++) { var stopWatch = new Stopwatch(); stopWatch.Start(); var intersection = Intersector.IntersectionWithHashSet(colorsArray, namesArray, comparer: new CustomComparer(), formatFunction: (i1, i2) => new string[] { i1[0], i1[1], i2[1] }); stopWatch.Stop(); Console.WriteLine($"Ran in {stopWatch.ElapsedTicks} ticks,{stopWatch.ElapsedMilliseconds}ms"); if (i != 0) { averageTicks += stopWatch.ElapsedTicks; averageMs += stopWatch.ElapsedMilliseconds; count++; } } averageMs = averageMs / count; averageTicks = averageTicks / count; Console.WriteLine($"Average in {averageTicks} ticks,{averageMs}ms"); }
private List <TopologyIntersection> FindAllIntersections(Face2D target, List <ICuttableEdge> edges2cut) { Intersector intersector = new Intersector(); List <TopologyIntersection> res_list = new List <TopologyIntersection>(); for (int loop_idx = 0; loop_idx < target.Loops.Count; ++loop_idx) { var loop = target.Loops[loop_idx]; for (int target_edge_idx = 0; target_edge_idx < loop.Count; ++target_edge_idx) { List <TopologyIntersection> sorted_is = new List <TopologyIntersection>(); for (int tool_edge_idx = 0; tool_edge_idx < edges2cut.Count; ++tool_edge_idx) { var intersections = intersector.Intersect(loop[target_edge_idx], edges2cut[tool_edge_idx]); foreach (var intersection in intersections) { TopologyIntersection res = new TopologyIntersection( loop_idx, target_edge_idx, tool_edge_idx, intersection); sorted_is.Add(res); } } sorted_is.Sort(new TopologyIntersectionCompare_ByTarget()); res_list.AddRange(sorted_is); } } return(res_list); }
public ImageSensorData Measure() { var tmpLocation = GetCameraLocation(_robot); var result = new KinectData(_settings.VerticalResolution, _settings.HorisontalResolution); var horisontalAngle = -_settings.HorisontalViewAngle / 2.0; var verticalAngle = -_settings.VerticalViewAngle / 2.0; for (int i = 0; i < _settings.VerticalResolution; i++) { Frame3D mediateDirection = SensorRotation.VerticalFrameRotation(tmpLocation, -verticalAngle); horisontalAngle = -_settings.HorisontalViewAngle / 2.0; for (int j = 0; j < _settings.HorisontalResolution; j++) { Frame3D direction = SensorRotation.HorisontalFrameRotation(mediateDirection, horisontalAngle); Ray ray = new Ray(tmpLocation.ToPoint3D(), SensorRotation.GetFrontDirection(direction)); var dist = double.PositiveInfinity; foreach (var body in _worldRoot.GetSubtreeChildrenFirst()) { if (_settings.Exclude.All(a => a != body)) { var inter = Intersector.Intersect(body, ray); dist = Math.Min(dist, inter); } } result.Depth[i, j] = dist; //verticalAngle += _settings.VStep; horisontalAngle += _settings.HStep; } verticalAngle += _settings.VStep; } return(new ImageSensorData(result.GetBytes())); }
// Use this for initialization void Awake() { // gather dependencies MeshMan = MeshManager.Instance; VoxGridMan = new VoxelGridManager <byte>(myMinSize: DefaultVoxGridRes, myDefaultSize: DefaultVoxelSize); VertVis = new Visualizer("VertexMarkers", "Marker", "Line", DefaultMaterial); VertexInter = new Intersector(); Observer = GetComponent <SpatialMappingObserver>(); // finish setup SensorField.Transform = Camera.main.transform; SensorField.FOV = new Intersector.ViewVector((int)SensorFOV.x, (int)SensorFOV.y); MeshDensity = MeshMan.Density; SensorData = new byte[(int)SensorPixelCount.x, (int)SensorPixelCount.y]; for (int i = 0; i < SensorPixelCount.x; i++) { for (int j = 0; j < SensorPixelCount.y; j++) { SensorData[i, j] = (byte)(255f * (float)(i + j) / (SensorPixelCount.x + SensorPixelCount.y)); } } // finish dependendencies setup: some variables must be created in Start() MeshMan.BoundsVis = new Visualizer("MeshBounds", "Marker", "Line", DefaultMaterial); VerticesRendered = DefaultRenderVerts; }
private Dictionary <Edge, Operation> GenerateLoop(string input, string output, List <Edge> edges, Dictionary <Edge, Operation> mapping) { //foreach 0 <= k1, k2, k3 < Length(s) // eSet1 = GenerateStr(sigma, s[k1 : k2]); // eSet2 = GenerateStr(sigma, s[k2 : k3]); // eSet = Unify(eSet1, eSet2); // if ([[Loop(lambda W : eSet)]]sigma = {s[k1 : k3]}) // W(<k1, k3>) = W'(<k1, k3>) U {Loop(lambda W : eSet)}; int len = output.Length; for (int i = 0; i < len; ++i) { for (int j = i; j < len; ++j) { for (int k = j; k < len; ++k) { var traceSet1 = GenerateStr(input, output.Substring(i, j - i)); var traceSet2 = GenerateStr(input, output.Substring(j, k - j)); var traceSet = new Intersector().Unify(traceSet1, traceSet2); Loop loop = new Loop(traceSet); if (loop.Apply(input).Equals(output.Substring(i, k - i))) { Edge targetEdge = new Edge(i, k); //mapping[targetEdge] = mapping[targetEdge] U loop; } } } } return(mapping); }
public void IntersectConvexTest() { var intersect = Intersector.IntersectConvex(m_diamond, m_squarePoly); Assert.AreEqual(0.5f, intersect.Area); Assert.Throws <GeomException>(() => Intersector.IntersectConvex(m_diamond, m_arrow)); }
public bool GetGroundPosition(Vec3D position, Vec3 direction, out MapPos result, ClampFlags flags = ClampFlags.DEFAULT) { result = new MapPos(); // Coordinate is now in world Cartesian coordinates (Roi Position) Vec3D origo = new Vec3D(0, 0, 0); // Set used origo Intersector isect = new Intersector(); // Check camera frustrum ----------------------------------------------------------- if (_camera != null && _camera.IsValid()) { origo = _camera.Position; if ((flags & ClampFlags.FRUSTRUM_CULL) != 0) { isect.SetCamera(_camera); } } // Adjust intersector to use origo as center position = position - origo; isect.SetStartPosition((Vec3)position); isect.SetDirection(direction); if (isect.Intersect(_currentMap, IntersectQuery.NEAREST_POINT | IntersectQuery.NORMAL | ((flags & ClampFlags.WAIT_FOR_DATA) != 0 ? IntersectQuery.WAIT_FOR_DYNAMIC_DATA : 0), 1, true, origo)) { IntersectorResult res = isect.GetResult(); IntersectorData data = res.GetData(0); result.position = data.position + origo; result.normal = data.normal; result.clamped = true; } isect.Dispose(); // Drop handle and ignore GC if (_topRoi != null) { RoiNode roi = _topRoi.GetClosestRoiNode(result.position); result.node = roi; // Remove roiNode position as offset - Go to local RoiNode based coordinate system if (roi != null && roi.IsValid()) { result.position -= roi.Position; } } return(true); }
// Use this for initialization void Start() { TextObj = TextContainer.GetComponent <TextMesh>(); Driver = EFPContainer.GetComponent <ExternalFeedDriver>(); MeshManagerObj = EFPContainer.GetComponent <MeshManager>(); GridManager = EFPContainer.GetComponent <VoxelGridManager>(); Intersect = EFPContainer.GetComponent <Intersector>(); }
public void Test_Intersect_Between_Arrays_Linear_Search() { var intersection = Intersector.IntersectionWithLinearSearch(colorsArray, namesArray, formatFunction: (i1, i2) => new string[] { i1[0], i1[1], i2[1] }); var result = string.Join("\r\n", intersection.Select(x => $"{x[0]},{x[1]},{x[2]}")); Assert.AreEqual(expectedResult, result); }
public void Test_Intersect_Between_Arrays_Hash() { var intersection = Intersector.IntersectionWithHashSet(colorsArray, namesArray, comparer: new CustomComparer(), formatFunction: (i1, i2) => new string[] { i1[0], i1[1], i2[1] }); var result = string.Join("\r\n", intersection.Select(x => $"{x[0]},{x[1]},{x[2]}")); // Assert.AreEqual(expectedResult, result); }
void Start() { observer = GetComponent <SpatialMappingObserver>(); Density = observer.Density; MeshInter = new Intersector(); TotalMeshCount = 0; MeshesInView = 0; TrianglesInView = 0; VerticesInView = 0; }
void Start() { observer = GetComponent <SpatialMappingObserver>(); Density = observer.TrianglesPerCubicMeter; MeshInter = new Intersector(); BoundsVis = new Visualizer("MeshBounds", "Marker", "Line", DefaultMaterial); BoundsVisualized = DefaultVisualizeBounds; TotalMeshCount = 0; MeshesInView = 0; TrianglesInView = 0; VerticesInView = 0; }
// Use this for initialization void Start() { // finish setup FOV = new ViewVector(TargetFOV.x, TargetFOV.y); ViewField = new Frustum(Camera.main.transform, FOV); CubeMin = new Vector3(CubeCenter.x - CubeSize / 2f, CubeCenter.y - CubeSize / 2f, CubeCenter.z - CubeSize / 2f); CubeMax = new Vector3(CubeCenter.x + CubeSize / 2f, CubeCenter.y + CubeSize / 2f, CubeCenter.z + CubeSize / 2f); for (int i = 0; i < Vertices; i++) { Points.Add(RandomPoint(CubeMin, CubeMax, Rand)); } Scale = new Vector3(VertexSize, VertexSize, VertexSize); Inter = Intersector.Instance; // create point markers Parent = new GameObject(); Parent.name = "VertexMarkers"; for (int i = 0; i < Vertices; i++) { GameObject Child = GameObject.CreatePrimitive(PrimitiveType.Sphere); Child.AddComponent <MeshFilter>(); Child.AddComponent <MeshRenderer>(); Child.AddComponent <SphereCollider>(); Child.name = "Marker" + i.ToString(); Child.transform.parent = Parent.transform; Child.transform.position = Points[i]; Child.transform.localScale = Scale; Child.GetComponent <MeshRenderer>().material = OutViewMaterial; if (ViewVectorLabels) { GameObject VVLabelT = Instantiate(VVLabelText); VVLabelT.transform.parent = Parent.transform; VVLabelT.name = "Text" + i.ToString(); VVLabelT.transform.position = Points[i] + VVLabelOffset; GameObject VVLabelB = Instantiate(VVLabelBackground); VVLabelB.transform.parent = Parent.transform; VVLabelB.name = "Background" + i.ToString(); VVLabelB.transform.position = Points[i] + VVLabelOffset + new Vector3(0, 0, 0.01f); } } // draw bounds box GameObject BoxParent = new GameObject(); BoxParent.name = "BoxParent"; DrawBox(CubeMin, CubeMax, BoxParent, LineSize, LineMaterial); }
// Use this for initialization void Awake() { // gather dependencies MeshMan = MeshManager.Instance; VoxGridMan = new VoxelGridManager <byte>(myMinSize: DefaultVoxGridRes, myDefaultSize: DefaultVoxelSize); VertVis = new Visualizer("VertexMarkers", "Marker", "Line", DefaultMaterial); VertexInter = new Intersector(); Observer = GetComponent <SpatialMappingObserver>(); SensorDataUpdater = DataUpdateContainer.GetComponent <Receiving.ImageReceiver>(); // finish setup SensorField.Transform = Camera.main.transform; SensorField.FOV = new Intersector.ViewVector((int)(SensorFOV.x * SensorFOVReduction.x), (int)(SensorFOV.y * SensorFOVReduction.y)); MeshDensity = MeshMan.Density; SensorData = new byte[SensorDataHeight * SensorDataWidth]; // sync state to default values VerticesRendered = DefaultRenderVerts; ProximityConfig = DefaultToProximity; }
/// <summary> /// Calculates total area owned by each player separately. /// </summary> private void UpdatePlayerAreaOwned() { m_playerArea = new float[2] { 0, 0 }; foreach (var inputNode in m_delaunay.Vertices) { // get dcel face containing input node var face = m_DCEL.GetContainingFace(inputNode); if (m_ownership[inputNode] != EOwnership.UNOWNED) { // update player area with face that intersects with window var playerIndex = m_ownership[inputNode] == EOwnership.PLAYER1 ? 0 : 1; m_playerArea[playerIndex] += Intersector.IntersectConvex(m_meshRect, face.Polygon.Outside).Area; } } // update GUI to reflect new player area owned m_GUIManager.SetPlayerAreaOwned(m_playerArea[0], m_playerArea[1]); }
public EdgeVisitor(Intersector intersector) { m_intersector = intersector; m_e1c = null; m_e1l = null; }
/// <summary> /// Creates ViewVector from spatialVector. /// Note: spatialVector MUST originate from origin. /// </summary> public ViewVector(Vector3 spatialVector) { Theta = Intersector.RadToDeg(AdjAtanTheta(spatialVector.x, spatialVector.z)); Phi = Intersector.RadToDeg(AdjAtanPhi(spatialVector)); }
// Tests Intersector class // Currently tests: // Vector (T1) // InverseTransformVector (T2 - not implemented) // ViewVector alt. constructor (T3) // Intersection (small scale) (T4 - not implemented) // Intersection (large scale) (T5 - not implemented) static string TestIntersector(Intersector IntersectorObj) { string output = "\n<size=144>Testing Intersector...</size>\n\n"; // Test 1: Vector from two points output += "<b>Test 1</b>\n"; Vector3 p1 = new Vector3(0, 0, 0); Vector3 p2 = new Vector3(2, 2, 2); output += String.Format("Vector from two points: {0} to {1}\n", pointToStr(p1), pointToStr(p2)); Vector3 result = new Vector3(); IntersectorObj.Vector(p1, p2, ref result); output += String.Format("Resultant vector: {0}\n\n", pointToStr(result)); // Cannot test Unity Library outside of Unity... // Test 2: InverseTransformVector output += "<b>Test 2</b>\n"; GameObject view2 = new GameObject(); view2.name = "ViewFieldTest2"; view2.transform.Rotate(new Vector3(90, 90, 0)); output += String.Format("InverseTransformVector... view-field position: {0}, view-field euler angles: {1}\n", pointToStr(view2.transform.position), pointToStr(view2.transform.eulerAngles)); Vector3[] unitVectors = unitVectorsArray(); for (int i = 0; i < 8; i++) { output += String.Format("Vector{0}: World Space: {1}, View-Field Local Space: {2}\n", i + 1, pointToStr(unitVectors[i]), pointToStr(view2.transform.InverseTransformVector(unitVectors[i]))); } output += "\n"; // */ // Test 3: View Vector alt. constructor output += "<b>Test 3</b>\n"; output += String.Format("ViewVector creation from position vector (in local space)... 2D cross-sectional plane is XY plane.\n"); Vector3 forward = new Vector3(0, 0, 1); for (int i = 0; i < 8; i++) { output += String.Format("Vector{0} {1}: ViewVector{0} (deg): {2}\n", i + 1, pointToStr(unitVectors[i]), viewVectorToStr(new ViewVector(unitVectors[i]))); } output += String.Format("Vector {0}: ViewVector (deg): {1}\n", pointToStr(forward), viewVectorToStr(new ViewVector(forward))); output += "\n"; // Cannot test Unity Library outside of Unity... // Test 4: Intersection (small scale) output += "<b>Test 4</b>\n"; List <Vector3> unitVectorList = new List <Vector3>(); for (int i = 0; i < 8; i++) { unitVectorList.Add(unitVectors[i]); } GameObject view4 = new GameObject(); view4.name = "ViewFieldTest4"; ViewVector FOV4 = new ViewVector(170, 170); Frustum projection4 = new Frustum(view4.transform, FOV4); byte[,] raster4 = new byte[100, 100]; output += String.Format("Intersection... Raster: ({0}x{1}), Frustum FOV: ({2}x{3}), " + "Frustum Pos: {4}, Frustum EA's: {5}\n" + "Tested all 8 unit vectors, found intersection points...\n", raster4.GetLength(0), raster4.GetLength(1), FOV4.Theta, FOV4.Phi, pointToStr(projection4.Transform.position), pointToStr(projection4.Transform.eulerAngles)); List <PointValue <byte> > intersect = Intersector.Instance.Intersection(projection4, raster4, unitVectorList); foreach (PointValue <byte> pv in intersect) { output += String.Format("Point: {0}, ViewVector: {1}\n", pointToStr(pv.Point), viewVectorToStr(new ViewVector(pv.Point))); } output += "\n"; // Cannot test Unity Library outside of Unity... // Test 5: Intersection (large scale) output += "<b>Test 5</b>\n"; System.Random rand = new System.Random(); GameObject view5 = new GameObject(); view5.name = "ViewFieldTest5"; ViewVector FOV5 = new ViewVector(179, 179); Frustum projection5 = new Frustum(view5.transform, FOV5); byte[,] raster5 = new byte[100, 100]; int iterations = 100; Stopwatch stopWatch = new Stopwatch(); Vector3 boundsMin = new Vector3(-5, -5, -5); Vector3 boundsMax = new Vector3(5, 5, 5); List <Vector3> randVectors = new List <Vector3>(); for (int i = 0; i < iterations; i++) { randVectors.Add(randomPoint(boundsMin, boundsMax, rand)); } output += String.Format("Intersection... Raster: ({0}x{1}), Frustum FOV: ({2}x{3}). {4} Iterations...\n", raster5.GetLength(0), raster5.GetLength(1), FOV5.Theta, FOV5.Phi, randVectors.Count); Intersector tmp = Intersector.Instance; stopWatch.Reset(); stopWatch.Start(); List <PointValue <byte> > result5 = tmp.Intersection(projection5, raster5, randVectors); stopWatch.Stop(); long ms = (long)1000 * stopWatch.ElapsedTicks / Stopwatch.Frequency; output += String.Format("Took {0} ms ({1} us / op)... {2} vectors in view\n", ms, ms / (double)iterations * 1000.0, result5.Count); output += "\n"; // Test 6: RequiredGrid output += "<b>Test 6</b>\n"; ViewVector FOV6 = new ViewVector(60, 60); output += String.Format("Testing RequiredGrid... FOV: {0}\n", viewVectorToStr(FOV6)); Dictionary <string, int> pixels = Intersector.Instance.RequiredGrid(FOV6); output += String.Format("i: {0}, j: {1}\n", pixels["i"], pixels["j"]); output += "\n"; /// Test 7: Occlusion (basic) output += "<b>Test 7</b>\n"; GameObject view7 = new GameObject(); view7.name = "ViewFieldTest7"; ViewVector FOV7 = new ViewVector(170, 170); Frustum projection7 = new Frustum(view7.transform, FOV7); byte[,] raster7 = new byte[100, 100]; for (int i = 0; i < raster7.GetLength(0); i++) { for (int j = 0; j < raster7.GetLength(1); j++) { raster7[i, j] = (byte)(i + j); } } output += String.Format("Created Frustum: pos: {0}, EA's {1}, FOV: {2}\n", pointToStr(projection7.Transform.position), pointToStr(projection7.Transform.eulerAngles), viewVectorToStr(projection7.FOV)); output += String.Format("Created Raster: {0}x{1}\n", raster7.GetLength(0), raster7.GetLength(1)); Vector3 v1 = new Vector3(1, 1, 1); Vector3 v2 = new Vector3(2, 2, 2); Vector3 v3 = new Vector3(0, 0, 1); List <Vector3> vertices7 = new List <Vector3>(); vertices7.Add(v2); vertices7.Add(v1); vertices7.Add(v2); vertices7.Add(v3); output += String.Format("Trying vertices: v1: {0}, v2: {1}, v3: {2}. Intersection return...\n", pointToStr(v1), pointToStr(v2), pointToStr(v3)); List <PointValue <byte> > intersectRet = Intersector.Instance.Intersection(projection7, raster7, vertices7); for (int i = 0; i < intersectRet.Count; i++) { output += String.Format("Point: {0}, Value: {1}\n", pointToStr(intersectRet[i].Point), intersectRet[i].Value); } output += "\n"; // Test 8: Occlusion (large scale) output += "<b>Test 8</b>\n"; GameObject view8 = new GameObject(); view8.name = "ViewFieldTest8"; ViewVector FOV8 = new ViewVector(170, 170); Frustum projection8 = new Frustum(view8.transform, FOV8); byte[,] raster8 = new byte[100, 100]; output += String.Format("Created Frustum: pos: {0}, EA's {1}, FOV: {2}\n", pointToStr(projection8.Transform.position), pointToStr(projection8.Transform.eulerAngles), viewVectorToStr(projection8.FOV)); output += String.Format("Created Raster: {0}x{1}\n", raster8.GetLength(0), raster8.GetLength(1)); // create 'wall' vertices double wallSize = 4.0; double wallRes = 0.05; double wallDistance = 3.0; float wallWiggle = 0.001f; int wallPixels = (int)(wallSize / wallRes); double wallBotLeft = -(wallSize / 2.0); int wallValue = 0; int wallCount = (int)Math.Pow(wallPixels, 2); List <Vector3> vertices = new List <Vector3>(); for (int i = 0; i < wallPixels; i++) { for (int j = 0; j < wallPixels; j++) { float vertX = (float)(i * wallRes + wallBotLeft); float vertY = (float)(j * wallRes + wallBotLeft); float vertZ = (float)wallDistance; Vector3 vert = new Vector3(vertX, vertY, vertZ); vertices.Add(wiggleVert(vert, wallWiggle, rand)); } } // create 'box' vertices float boxSize = 1f; Vector3 boxMin = new Vector3(-boxSize / 2, -boxSize / 2, (float)(wallDistance + 1)); Vector3 boxMax = new Vector3(boxSize / 2, boxSize / 2, (float)(wallDistance + 1 + boxSize)); int boxCount = 10000; for (int i = 0; i < boxCount; i++) { vertices.Add(randomPoint(boxMin, boxMax, rand)); } // report progress output += String.Format("Created wall... ({0},{0}) to ({1},{1}), z: {2}, wiggle: {3}, " + "vertices: {4}, resolution (m): {5}\n", wallBotLeft, wallBotLeft + wallSize, wallDistance, wallWiggle, wallCount, wallRes); output += String.Format("Created box: {0} to {1}, vertices: {2}\n", pointToStr(boxMin), pointToStr(boxMax), boxCount); // run intersection List <PointValue <byte> > intersectRet8 = Intersector.Instance.Intersection(projection8, raster8, vertices); int wallCountRet = 0; int boxCountRet = 0; for (int i = 0; i < intersectRet8.Count; i++) { Vector3 point = intersectRet8[i].Point; if (within(point, boxMin, boxMax)) { boxCountRet++; } else { wallCountRet++; } } output += String.Format("Intersection Return... wall vertices: {0}/{1}, box vertices: {2}/{3}", wallCountRet, wallCount, boxCountRet, boxCount); return(output); }
// Use this for initialization void Start() { TextObj = TextContainer.GetComponent <TextMesh>(); IntersectorObj = IntersectorContainer.GetComponent <Intersector>(); TextObj.text = TestIntersector(IntersectorObj); }
public bool UpdatePosition(ref MapPos result, GroundClampType groundClamp = GroundClampType.NONE, ClampFlags flags = ClampFlags.DEFAULT) { if (groundClamp != GroundClampType.NONE) { // Add ROINode position as offset - Go to global 3D coordinate system as we need to clamp in global 3D if (result.roiNode != null && result.roiNode.IsValid()) { result.position += result.roiNode.Position; } Intersector isect = new Intersector(); Vec3D eyePos = new Vec3D(0, 0, 0); if (_camera != null && _camera.IsValid()) { eyePos = _camera.Position; if ((flags & ClampFlags.FRUSTRUM_CULL) != 0) { isect.SetCamera(_camera); } } if ((flags & ClampFlags.ISECT_LOD_QUALITY) != 0) // Lets stand in the ray to get highest quality { eyePos = result.position; } Vec3 up = new Vec3(result.local_orientation.v13, result.local_orientation.v23, result.local_orientation.v33); // TODO: Fix this.... if (up.x == 0 && up.y == 0 && up.z == 0) { up.y = 1; } isect.SetStartPosition((Vec3)(result.position - eyePos) + 10000.0f * up); isect.SetDirection(-up); if (isect.Intersect(_currentMap, IntersectQuery.NEAREST_POINT | IntersectQuery.NORMAL | ((flags & ClampFlags.WAIT_FOR_DATA) != 0 ? IntersectQuery.WAIT_FOR_DYNAMIC_DATA : 0), 1, true, eyePos)) { IntersectorResult res = isect.GetResult(); IntersectorData data = res.GetData(0); result.position.x = data.position.x + eyePos.x; result.position.y = data.position.y + eyePos.y; result.position.z = data.position.z + eyePos.z; result.normal = data.normal; result.clamped = true; } else { result.normal = up; result.clamped = false; } if (groundClamp == GroundClampType.GROUND) { result.normal = result.local_orientation.GetCol(2); } isect.Dispose(); // Drop handle and ignore GC // Remove ROINode position as offset - Go to local coordinate system under ROI Node if (result.roiNode != null && result.roiNode.IsValid()) { result.position -= result.roiNode.Position; } } return(true); }
public bool GetScreenGroundPosition(int x, int y, uint size_x, uint size_y, out MapPos result, ClampFlags flags = ClampFlags.DEFAULT) { result = new MapPos(); Vec3D position; Vec3 direction; if (!GetScreenVectors(x, y, size_x, size_y, out position, out direction)) { return(false); } Intersector isect = new Intersector(); if ((flags & ClampFlags.FRUSTRUM_CULL) != 0 && _camera != null && _camera.IsValid()) { isect.SetCamera(_camera); if (_camera.RoiPosition) { position = position - _camera.Position; } } isect.SetStartPosition((Vec3)(position)); isect.SetDirection(direction); if (isect.Intersect(_currentMap, IntersectQuery.NEAREST_POINT | IntersectQuery.NORMAL | ((flags & ClampFlags.WAIT_FOR_DATA) != 0 ? IntersectQuery.WAIT_FOR_DYNAMIC_DATA : 0), 1, true, _camera.Position)) { IntersectorResult res = isect.GetResult(); IntersectorData data = res.GetData(0); result.position = data.position; if (_camera.RoiPosition) { result.position = result.position + _camera.Position; } result.normal = data.normal; result.clamped = true; } isect.Dispose(); // Drop handle and ignore GC if (_topRoi != null) { result.roiNode = _topRoi.GetClosestRoiNode(result.position); // Remove roiNode position as offset - Go to local RoiNode based coordinate system if (result.roiNode != null && result.roiNode.IsValid()) { result.position -= result.roiNode.Position; } } return(true); }
/// <summary> /// Get a Local mappos in Global ray direction /// </summary> /// <param name="global_position"></param> /// <param name="direction"></param> /// <param name="result"></param> /// <param name="flags"></param> /// <returns></returns> public bool GetGroundPosition(Vec3D global_position, Vec3 direction, out MapPos result, ClampFlags flags = ClampFlags.DEFAULT) { result = new MapPos(); // Coordinate is now in world Cartesian coordinates (Roi Position) Vec3D origo = new Vec3D(0, 0, 0); // Set used origo for clamp operation Intersector isect = new Intersector(); // Check camera frustrum ----------------------------------------------------------- if (_camera != null && _camera.IsValid()) { origo = _camera.Position; if ((flags & ClampFlags.FRUSTRUM_CULL) != 0) { isect.SetCamera(_camera); } } // Adjust intersector to use origo as center global_position = global_position - origo; isect.SetStartPosition((Vec3)global_position); isect.SetDirection(direction); if (isect.Intersect(_currentMap, IntersectQuery.ABC_TRI | IntersectQuery.NEAREST_POINT | (flags.HasFlag(ClampFlags.ALIGN_NORMAL_TO_SURFACE) ? IntersectQuery.NORMAL : 0) | //IntersectQuery.NORMAL | (flags.HasFlag(ClampFlags.WAIT_FOR_DATA) ? IntersectQuery.WAIT_FOR_DYNAMIC_DATA : 0), 1, true, origo)) { IntersectorResult res = isect.GetResult(); IntersectorData data = res.GetData(0); result.position = data.coordinate + origo; if ((data.resultMask & IntersectQuery.NORMAL) != 0) { result.normal = data.normal; } if (data.resultMask.HasFlag(IntersectQuery.ABC_TRI)) { result.a = data.a + origo; result.b = data.b + origo; result.c = data.c + origo; } result.clampResult = data.resultMask; } else { result.clampResult = IntersectQuery.NULL; } isect.Dispose(); // Drop handle and ignore GC result.local_orientation = GetLocalOrientation(result.position); if (result.clampResult == IntersectQuery.NULL) { result.normal = result.local_orientation.GetCol(2); } return(ToLocal(result)); }
public bool UpdatePosition(MapPos result, GroundClampType groundClamp = GroundClampType.NONE, ClampFlags flags = ClampFlags.DEFAULT) { if (_currentMap == null) // No map { return(false); } result.normal = result.local_orientation.GetCol(2); if (groundClamp != GroundClampType.NONE) { // Add ROINode position as offset - Go to global 3D coordinate system as we need to clamp in global 3D RoiNode roi = result.node as RoiNode; if (roi != null && roi.IsValid()) { result.position += roi.Position; } // The defined down vector Vec3 down = new Vec3(-result.local_orientation.v13, -result.local_orientation.v23, -result.local_orientation.v33); // Check triangel ground if (result.clampResult.HasFlag(IntersectQuery.ABC_TRI)) { if (Intersect(result.position, down, result.a, result.b, result.c, out Vec3D p)) { result.position = p; ToLocal(result); return(true); } } // Check new intersector Intersector isect = new Intersector(); Vec3D origo = new Vec3D(0, 0, 0); // Check camera frustrum ----------------------------------------------------------- if (_camera != null && _camera.IsValid()) { origo = _camera.Position; if ((flags & ClampFlags.FRUSTRUM_CULL) != 0) { isect.SetCamera(_camera); } } if ((flags & ClampFlags.ISECT_LOD_QUALITY) != 0) // Lets stand in the ray to get highest quality { origo = result.position; } isect.SetStartPosition((Vec3)(result.position - origo) - 10000.0f * down); // Move backwards isect.SetDirection(down); if (isect.Intersect(_currentMap, IntersectQuery.NEAREST_POINT | IntersectQuery.ABC_TRI | (flags.HasFlag(ClampFlags.ALIGN_NORMAL_TO_SURFACE) ? IntersectQuery.NORMAL : 0) | //IntersectQuery.NORMAL | (flags.HasFlag(ClampFlags.WAIT_FOR_DATA) ? IntersectQuery.WAIT_FOR_DYNAMIC_DATA : 0) | (flags.HasFlag(ClampFlags.UPDATE_DATA) ? IntersectQuery.UPDATE_DYNAMIC_DATA : 0) , 1, true, origo)) { IntersectorResult res = isect.GetResult(); IntersectorData data = res.GetData(0); result.position = data.coordinate + origo; if ((data.resultMask & IntersectQuery.NORMAL) != 0) { result.normal = data.normal; } if (data.resultMask.HasFlag(IntersectQuery.ABC_TRI)) { result.a = data.a + origo; result.b = data.b + origo; result.c = data.c + origo; } result.clampResult = data.resultMask; } else { result.clampResult = IntersectQuery.NULL; } //if (groundClamp == GroundClampType.GROUND) //{ // result.normal = result.local_orientation.GetCol(2); //} isect.Dispose(); // Drop handle and ignore GC // Remove ROINode position as offset - Go to local coordinate system under ROI Node ToLocal(result); } result.clampFlags = flags; result.clampType = groundClamp; return(true); }
/// <summary> /// Find cut line through the intersection of dcel faces. /// Each dcel face is bounded by lines in the dual plane, representing the points to separate equally. /// </summary> /// <param name="a_region1"></param> /// <param name="a_region2"></param> /// <param name="a_region3"></param> /// <returns></returns> public static List <Line> FindCutlinesInDual(List <Face> a_region1, List <Face> a_region2, List <Face> a_region3) { a_region1.Sort((f1, f2) => f1.BoundingBox().xMin.CompareTo(f2.BoundingBox().xMin)); a_region2.Sort((f1, f2) => f1.BoundingBox().xMin.CompareTo(f2.BoundingBox().xMin)); a_region3.Sort((f1, f2) => f1.BoundingBox().xMin.CompareTo(f2.BoundingBox().xMin)); var region1 = a_region1.Select(x => x.Polygon.Outside).ToList(); var region2 = a_region2.Select(x => x.Polygon.Outside).ToList(); var region3 = a_region3.Select(x => x.Polygon.Outside).ToList(); var intermediateList = new List <Polygon2D>(); //Intersect first two lists var list1index = 0; var list2index = 0; while (list1index < region1.Count && list2index < region2.Count) { //progress trough y coordinates var intersection = Intersector.IntersectConvex(region1[list1index], region2[list2index]); if (intersection != null) { intermediateList.Add(intersection); } if (region2[list2index].BoundingBox().xMax < region1[list1index].BoundingBox().xMax) { list2index++; } else { list1index++; } } var result = new List <Polygon2D>(); //Intersect intermediate list and last list var intermediateIndex = 0; var list3index = 0; while (intermediateIndex < intermediateList.Count && list3index < region3.Count) { //progress trough y coordinates var intersection = Intersector.IntersectConvex(intermediateList[intermediateIndex], region3[list3index]); if (intersection != null) { result.Add(intersection); } if (region3[list3index].BoundingBox().xMax < intermediateList[intermediateIndex].BoundingBox().xMax) { list3index++; } else { intermediateIndex++; } } //Convert polygons to lines return(FindCutLinesInDual(result)); }
public void Connect() { // check validness (1) 2pts, (2) line segment not exist; (3) not crossed with existing segments (5) not intersecting existing polygon if (m_selected_points.Count < 2) { return; } var seg = new P2Segment(m_selected_points[0].Pos, m_selected_points[1].Pos, player1Turn); var segLS = new LineSegment(m_selected_points[0].Pos, m_selected_points[1].Pos); //Debug.Log(seg.Segment.Point1 + "," + seg.Segment.Point2); if (m_segments.Contains(segLS)) { return; } foreach (P2Segment s in PlayerSegments[playerIndex]) { if (LineSegment.IntersectProper(s.Segment, seg.Segment) != null) { return; } } if (SegIntersectPolygon(seg, playerIndex)) { return; } //points on existing polygon cannot be selected. //Some explanations: If we can select points on existing polygon, we need to deal with the case: one line segement connecting two polygon //If we want to find a largest circle, this is NP-hard problem(Hamilton Cycle) operated = true; //add both vertices and segment to current player PlayerPoints[playerIndex].Add(seg.Segment.Point1); PlayerPoints[playerIndex].Add(seg.Segment.Point2); PlayerPoints[playerIndex] = PlayerPoints[playerIndex].Distinct().ToList(); PlayerSegments[playerIndex].Add(seg); m_segments.Add(segLS); //draw line segment, var mesh = Instantiate(PlayerLineMeshesPrefab[playerIndex], Vector3.forward, Quaternion.identity) as GameObject; mesh.transform.parent = LineMeshCollection[playerIndex].transform; mesh.GetComponent <P2Segment>().CopySegment(seg); instantObjects.Add(mesh); PlayerLineMeshes[playerIndex].Add(mesh); var meshScript = mesh.GetComponent <ReshapingMesh>(); meshScript.CreateNewMesh(seg.Segment.Point1, seg.Segment.Point2); // add new convex hull (if exist) to current player, draw convex hull, update score Polygon2D newpolygon = FindPolygon(playerIndex, seg.Segment.Point1); if (newpolygon != null) { Debug.Log("new polygon v cnt: " + newpolygon.VertexCount.ToString()); PlayerPolygons[playerIndex].Add(newpolygon); CanvasPlayerPolygons[playerIndex].Add(PolygonOnCanvas(newpolygon)); string printtext = ""; foreach (var v in newpolygon.Vertices) { printtext += "(" + v.x + "," + v.y + ") "; } Debug.Log(printtext); UpdateMesh(newpolygon, playerIndex, true); if (newpolygon.VertexCount > 0) { PlayerScore[playerIndex] += newpolygon.Area; } //For the other player, disable the merging for polygon with intersection foreach (Polygon2D polygon in PlayerPolygons[1 - playerIndex]) { int i = PlayerPolygons[1 - playerIndex].IndexOf(polygon); Debug.Log("Polygon in oppo1: " + PolygonOnCanvas(polygon).VertexCount); Debug.Log("Polygon in oppo2: " + PolygonOnCanvas(newpolygon).VertexCount); if (Intersector.ifIntersect(PolygonOnCanvas(polygon), PolygonOnCanvas(newpolygon))) { PlayerPolygonObjects[1 - playerIndex][i].GetComponent <P2Hull>().mergeChance = false; } } UpdateScore(); } UpdateTrapezoidalDecomposition(); }
public void Merge() { //check validness (1) 2 polygon, (2) mergechance > 1; if (m_selected_convexhulls.Count < 2) { return; } foreach (GameObject hullObject in m_selected_convexhulls) { if (!hullObject.GetComponent <P2Hull>().mergeChance) { return; } } //Compute new convex hull, add new convex hull to current player, update score operated = true; Polygon2D newhull = ConvexHull.ComputeConvexHull(m_selected_convexhulls[0].GetComponent <P2Hull>().hull, m_selected_convexhulls[1].GetComponent <P2Hull>().hull); Debug.Log(m_selected_convexhulls[0].GetComponent <P2Hull>().hull.Area + ", " + m_selected_convexhulls[1].GetComponent <P2Hull>().hull.Area + "=" + newhull.Area); PlayerPolygons[playerIndex].Add(newhull); foreach (var v in newhull.Vertices) { PlayerPointsOnPolygons[playerIndex].Add(v); } CanvasPlayerPolygons[playerIndex].Add(PolygonOnCanvas(newhull)); foreach (var v in newhull.Vertices) { PlayerPoints[playerIndex].Add(v); } foreach (var seg in newhull.Segments) { PlayerSegments[playerIndex].Add(new P2Segment(seg.Point1, seg.Point2, player1Turn)); } //disable merges m_selected_convexhulls[0].GetComponent <P2Hull>().mergeChance = false; m_selected_convexhulls[1].GetComponent <P2Hull>().mergeChance = false; foreach (Polygon2D polygon in PlayerPolygons[1 - playerIndex]) { int i = PlayerPolygons[1 - playerIndex].IndexOf(polygon); if (Intersector.ifIntersect(PolygonOnCanvas(polygon), PolygonOnCanvas(newhull))) { PlayerPolygonObjects[1 - playerIndex][i].GetComponent <P2Hull>().mergeChance = false; } } UpdateMesh(newhull, playerIndex, false); if (newhull.VertexCount > 0) { PlayerScore[playerIndex] += newhull.Area; } UpdateScore(); UpdateTrapezoidalDecomposition(); }