private int GetQuads(Bound2D box, out QuadTree <T>[] quads) { List <QuadTree <T> > listTree = new List <QuadTree <T> >(); if (bInternal) { bool bNegX = box.min.x <= treeCenter.x; bool bNegY = box.min.y <= treeCenter.y; bool bPosX = box.max.x >= treeCenter.x; bool bPosY = box.max.y >= treeCenter.y; if (bNegX && bNegY) { listTree.Add(subTrees[BottomLeft]); } if (bPosX && bNegY) { listTree.Add(subTrees[BottomRight]); } if (bNegX && bPosY) { listTree.Add(subTrees[TopLeft]); } if (bPosX && bPosY) { listTree.Add(subTrees[TopRight]); } } quads = listTree.ToArray(); return(listTree.Count); }
public QuadTree(Bound2D box, float minSize) { treeBox = box; treeCenter = box.center; minimumQuadSize = minSize; subTrees = new QuadTree <T> [NodeCapacity]; }
static public void DrawBounds(Bound2D box, Color c, Matrix4x4 mat) { Vector2 Extent = box.GetExtent(); Vector2 XExtent = new Vector2(Extent.x, 0.0f); Vector2 YExtent = new Vector2(0.0f, Extent.y); Vector2 C = box.center; Vector2 TM = C + YExtent + XExtent; Vector2 ML = C + YExtent - XExtent; Vector2 MR = C - YExtent - XExtent; Vector2 BM = C - YExtent + XExtent; GL.PushMatrix(); GL.MultMatrix(mat); GL.Begin(GL.LINES); GL.Color(c); GL.Vertex3(TM.x, 0, TM.y); GL.Vertex3(ML.x, 0, ML.y); GL.Vertex3(ML.x, 0, ML.y); GL.Vertex3(MR.x, 0, MR.y); GL.Vertex3(MR.x, 0, MR.y); GL.Vertex3(BM.x, 0, BM.y); GL.Vertex3(BM.x, 0, BM.y); GL.Vertex3(TM.x, 0, TM.y); GL.End(); GL.PopMatrix(); }
public void Insert(T element, Bound2D box) { if (!box.Intersect(treeBox)) { //todo log } InsertElementRecursive(element, box); }
public Tuple <Vector2, Vector2> GetScaleTranlslate(Room currentRoom, Bound2D realSpace) // v is currentRoom { Room v = currentRoom; Vector2 Scale = new Vector2(v.OriginSize.x / v.Size.x, v.OriginSize.y / v.Size.y); Vector2 Translate = realSpace.Position - v.Position; return(new Tuple <Vector2, Vector2>(Scale, Translate)); }
private void GetIntersectingElements(Bound2D box, List <T> elementsOut) { foreach (var node in nodeList) { if (box.Intersect(node.bound)) { elementsOut.Add(node.element); } } }
public bool IsIntersect(Bound2D other) // this와 point가 교차하는지 판단하는 함수 { if (IsIntersectInXAxis(other) && IsIntersectInYAxis(other)) { return(true); } else { return(false); } }
public bool IsIntersectInXAxis(Bound2D other) // x축 기준으로 this 와 otherbox가 교차하는지 판단하는 함수 { if ((this.Min.x - other.Max.x < 0.01f) && (this.Max.x - other.Min.x > 0.01f)) { return(true); } else { return(false); } }
public bool IsInside(Bound2D other) // this가 other 안에 들어오는지 판단하는 함수 { if (IsInsideInXAxis(other) && IsInsideInYAxis(other)) { return(true); } else { return(false); } }
public bool IsInsideInYAxis(Bound2D other) // y축 기준 this가 other 안에 들어오는지 판단하는 함수 { if ((other.Min.y - this.Min.y <= 0.05f) && (other.Max.y - this.Max.y >= 0.05f)) { return(true); } else { return(false); } }
public bool IsInsideInXAxis(Bound2D other) // x축 기준으로 this가 other 안에 들어오는지 판단하는 함수 { if ((other.Min.x - this.Min.x <= 0.05f) && (other.Max.x - this.Max.x >= 0.05f)) { return(true); } else { return(false); } }
/// <summary> /// 是否与当前包围盒相交 /// </summary> /// <param name="bound"></param> /// <returns></returns> public bool Intersects(Bound2D bound) { for (int i = 0; i < bound.concer.Length; i++) { if (Contain(bound.concer[i])) { return(true); } } return(false); }
public bool IsIntersectInYAxis(Bound2D other) // y축 기준 { if ((this.Min.y - other.Max.y < 0.01f) && (this.Max.y - other.Min.y > 0.01f)) { return(true); } else { return(false); } }
public bool Intersect(Bound2D Other) { if ((min.x > Other.max.x) || (Other.min.x > max.x)) { return(false); } if ((min.y > Other.max.y) || (Other.min.y > max.y)) { return(false); } return(true); }
public void GetElements(Bound2D box, List <T> elementsOut) { QuadTree <T>[] Quads; int NumQuads = GetQuads(box, out Quads); // Always include any nodes contained in this quad GetIntersectingElements(box, elementsOut); // As well as all relevant subtrees for (int QuadIndex = 0; QuadIndex < NumQuads; QuadIndex++) { Quads[QuadIndex].GetElements(box, elementsOut); } }
/// <summary> /// 是否与当前包围盒相交 /// </summary> /// <param name="bound"></param> /// <returns></returns> public bool Intersects(Bound2D bound, out int num) { num = 0; for (int i = 0; i < bound.concer.Length; i++) { if (Contain(bound.concer[i])) { num++; } } if (num > 0) { return(true); } return(false); }
public bool Remove(T element, Bound2D box) { bool bElementRemoved = false; QuadTree <T>[] Quads; int NumQuads = GetQuads(box, out Quads); // Remove from nodes referenced by this quad bElementRemoved = RemoveNodeForElement(element); // Try to remove from subtrees if necessary for (int QuadIndex = 0; QuadIndex < NumQuads && !bElementRemoved; QuadIndex++) { bElementRemoved = Quads[QuadIndex].Remove(element, box); } return(bElementRemoved); }
private void InsertElementRecursive(T element, Bound2D box) { QuadTree <T>[] Quads; int NumQuads = GetQuads(box, out Quads); if (NumQuads == 0) { // This should only happen for leaves //check(!bInternal); // It's possible that all elements in the leaf are bigger than the leaf or that more elements than NodeCapacity exist outside the top level quad // In either case, we can get into an endless spiral of splitting bool bCanSplitTree = treeBox.GetSize().magnitude > minimumQuadSize; if (!bCanSplitTree || nodeList.Count < NodeCapacity) { nodeList.Add(new QuadTreeNode(element, box)); if (!bCanSplitTree) { //UE_LOG(LogQuadTree, Warning, TEXT("Minimum size %f reached for quadtree at %s. Filling beyond capacity %d to %d"), minimumQuadSize, *Position.ToString(), NodeCapacity, Nodes.Num()); } } else { // This quad is at capacity, so split and try again Split(); InsertElementRecursive(element, box); } } else if (NumQuads == 1) { //check(bInternal); // Fully contained in a single subtree, so insert it there Quads[0].InsertElementRecursive(element, box); } else { // Overlaps multiple subtrees, store here //check(bInternal); nodeList.Add(new QuadTreeNode(element, box)); } }
public bool Contain(Bound2D bound) { int num = 0; for (int i = 0; i < bound.concer.Length; i++) { if (Contain(bound.concer[i])) { num++; } } if (num == 4) { return(true); } else { return(false); } }
public void Reduce(VirtualEnvironment virtualEnvironment, Room targetRoom, Room currentRoom, Bound2D realSpace) { float xMinDist = realSpace.Min.x - targetRoom.Min.x; float xMaxDist = realSpace.Max.x - targetRoom.Max.x; float yMinDist = realSpace.Min.y - targetRoom.Min.y; float yMaxDist = realSpace.Max.y - targetRoom.Max.y; if (xMinDist > 0) // 1벽 { virtualEnvironment.MoveWall(targetRoom, 1, xMinDist, currentRoom); } if (xMaxDist < 0) // 3벽 { virtualEnvironment.MoveWall(targetRoom, 3, xMaxDist, currentRoom); } if (yMinDist > 0) // 2벽 { virtualEnvironment.MoveWall(targetRoom, 2, yMinDist, currentRoom); } if (yMaxDist < 0) // 0벽 { virtualEnvironment.MoveWall(targetRoom, 0, yMaxDist, currentRoom); } }
public bool IsInside(Bound2D Other) { return(IsInside(Other.min) && IsInside(Other.max)); }
public QuadTreeNode(T v, Bound2D box) { bound = box; element = v; }