精华内容
下载资源
问答
  • Quadtree

    2017-05-10 05:37:19
    Being somewhat experienced in cryptography, Florida Jones recognizes the code immediately as the famous Quadtree Encoding Scheme that has been invented 3000 years ago. With the Quadtree system, secret...
  • Quadtree Quadtree

    2018-05-21 10:41:16
    Quadtree
  • QuadTree演示 该项目包含一个Java简单的QuadTree实现,并带有Swing视觉演示。
  • gdx_quadtree Quadtree实用程序
  • QuadTree-开源

    2021-04-24 12:23:41
    与XNA一起使用的C#中的通用类型QuadTree实现。 该QuadTree可以存储实现接口IHasRectangle的任何对象。 这提供了一种非常快速地访问虚拟空间中的对象的方法。 开发已移至:https://bitbucket.org/C3/quadtree/
  • 四叉树例子(几乎不大不小JavaScript库)与 。 四叉树 ...const quadtree = new QuadTree ( r , capacity ) ; 测验 要运行测试,请使用以下命令之一 用于连续测试 npm run test-watch 对于单次运行
  • QuadTree compression and uncompression of BMP with QuadTree algorithm 本项目使用线性四叉树快速动态压缩编码的方法,实现了对8位bmp图像文件的压缩和解压缩 各文件意义如下: QuadTree.cpp main函数 bmp.h bmp...
  • 四叉树 C#中 QuadTree 实现的 Github 镜像
  • QUADTREE地形

    2007-12-07 10:23:25
    QUADTREE地形
  • D3D11_QuadTree

    2017-01-03 10:29:40
    D3D11_QuadTree
  • 碰撞检测和QuadTree 演示视频: : 一个简单的碰撞检测系统。 包括两种算法: 蛮力检查所有身体与其他所有身体,这可能会影响性能,建议仅在100个以下的身体中使用。 QuadTree查询QuadTree仅测试与附近物体的...
  • quadtree 对于一个我正在从事的项目,我需要一个QuadTree来快速便捷地访问给定范围内的对象。 我学到了很多工作,并认为与Bytes社区共享代码可能是个好主意。 要使用它,请创建一个新的QuadTree并告诉它要覆盖的...

    quadtree

    对于一个我正在从事的项目,我需要一个QuadTree来快速便捷地访问给定范围内的对象。 我学到了很多工作,并认为与Bytes社区共享代码可能是个好主意。

    要使用它,请创建一个新的QuadTree并告诉它要覆盖的区域。 然后,只需使用Insert方法将对象插入其中即可。 您可以使用Remove方法将对象取出。 移除时,如果四边形的子级为空,则这些子级将被移除。

    一些笔记,没有特别的顺序...

    *此QuadTree可容纳任何类型,只要该类型继承自IHasRectangle并实现接口定义的属性即可。 这样,QuadTree就知道对象的边界是什么。

    *在此实现中,当四边形包含两个以上的对象时,将对其进行细分。 也就是说,一个四边形将只包含一个对象

    完全包含。 如果四边形的子级不能包含对象,则该对象将位于四边形本身中。

    *该代码是使用XNA矩形构建的。 修改代码以便与System.Drawing甚至自定义Rectangle对象一起使用应该很容易。 只要对象提供了适当的方法(包含和相交),移植就需要进行最少的工作。

    *此代码是免费提供的,请尽情享受!

    *鉴于上述情况,请注意,不能保证它没有错误。 我已经对其进行了相当广泛的测试,但是很有可能我错过了一些东西。 我绝对愿意接受反馈,但请保持建设性。

    *我仍在做一些工作,但这会使XNA更加具体。 这是对象的通用版本。 我可能会在以后发布更新。

    杂乱无章...这是代码。

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using Microsoft.Xna.Framework; 
    namespace QuadTree
    {
        /// <summary>
        /// Interface to define Rect, so that QuadTree knows how to store the object.
        /// </summary>
        public interface IHasRectangle
        {
            /// <summary>
            /// The rectangle that defines the object's boundaries.
            /// </summary>
            Rectangle Rect { get; }
        } 
        /// <summary>
        /// A QuadTree Object that provides fast and efficient storage of objects in a world space.
        /// </summary>
        /// <typeparam name="T">Any object iheriting from IHasRect.</typeparam>
        public class QuadTree<T> where T : IHasRectangle
        {
            #region Constants
            // How many objects can exist in a QuadTree before it sub divides itself
            private const int MAX_OBJECTS_PER_NODE = 2;
            #endregion 
            #region Private Members
            private List<T> m_objects = null;       // The objects in this QuadTree
            private Rectangle m_rect;               // The area this QuadTree represents 
            private QuadTree<T> m_childTL = null;   // Top Left Child
            private QuadTree<T> m_childTR = null;   // Top Right Child
            private QuadTree<T> m_childBL = null;   // Bottom Left Child
            private QuadTree<T> m_childBR = null;   // Bottom Right Child
            #endregion 
            #region Public Properties
            /// <summary>
            /// The area this QuadTree represents.
            /// </summary>
            public Rectangle QuadRect { get { return m_rect; } } 
            /// <summary>
            /// The top left child for this QuadTree
            /// </summary>
            public QuadTree<T> TopLeftChild { get { return m_childTL; } } 
            /// <summary>
            /// The top right child for this QuadTree
            /// </summary>
            public QuadTree<T> TopRightChild { get { return m_childTR; } } 
            /// <summary>
            /// The bottom left child for this QuadTree
            /// </summary>
            public QuadTree<T> BottomLeftChild { get { return m_childBL; } } 
            /// <summary>
            /// The bottom right child for this QuadTree
            /// </summary>
            public QuadTree<T> BottomRightChild { get { return m_childBR; } } 
            /// <summary>
            /// The objects contained in this QuadTree at it's level (ie, excludes children)
            /// </summary>
            public List<T> Objects { get { return m_objects; } } 
            /// <summary>
            /// How many total objects are contained within this QuadTree (ie, includes children)
            /// </summary>
            public int Count { get { return this.ObjectCount(); } }
            #endregion 
            #region Constructor
            /// <summary>
            /// Creates a QuadTree for the specified area.
            /// </summary>
            /// <param name="rect">The area this QuadTree object will encompass.</param>
            public QuadTree(Rectangle rect)
            {
                m_rect = rect;
            } 
            /// <summary>
            /// Creates a QuadTree for the specified area.
            /// </summary>
            /// <param name="x">The top-left position of the area rectangle.</param>
            /// <param name="y">The top-right position of the area reactangle.</param>
            /// <param name="width">The width of the area rectangle.</param>
            /// <param name="height">The height of the area rectangle.</param>
            public QuadTree(int x, int y, int width, int height)
            {
                m_rect = new Rectangle(x, y, width, height);
            }
            #endregion 
            #region Private Members
            /// <summary>
            /// Add an item to the object list.
            /// </summary>
            /// <param name="item">The item to add.</param>
            private void Add(T item)
            {
                if (m_objects == null)
                    m_objects = new List<T>(); 
                m_objects.Add(item);
            } 
            /// <summary>
            /// Remove an item from the object list.
            /// </summary>
            /// <param name="item">The object to remove.</param>
            private void Remove(T item)
            {
                if (m_objects != null && m_objects.Contains(item))
                    m_objects.Remove(item);
            } 
            /// <summary>
            /// Get the total for all objects in this QuadTree, including children.
            /// </summary>
            /// <returns>The number of objects contained within this QuadTree and its children.</returns>
            private int ObjectCount()
            {
                int count = 0; 
                // Add the objects at this level
                if (m_objects != null) count += m_objects.Count; 
                // Add the objects that are contained in the children
                if (m_childTL != null)
                {
                    count += m_childTL.ObjectCount();
                    count += m_childTR.ObjectCount();
                    count += m_childBL.ObjectCount();
                    count += m_childBR.ObjectCount();
                } 
                return count;
            } 
            /// <summary>
            /// Subdivide this QuadTree and move it's children into the appropriate Quads where applicable.
            /// </summary>
            private void Subdivide()
            {
                // We've reached capacity, subdivide...
                Point size = new Point(m_rect.Width / 2, m_rect.Height / 2);
                Point mid = new Point(m_rect.X + size.X, m_rect.Y + size.Y); 
                m_childTL = new QuadTree<T>(new Rectangle(m_rect.Left, m_rect.Top, size.X, size.Y));
                m_childTR = new QuadTree<T>(new Rectangle(mid.X, m_rect.Top, size.X, size.Y));
                m_childBL = new QuadTree<T>(new Rectangle(m_rect.Left, mid.Y, size.X, size.Y));
                m_childBR = new QuadTree<T>(new Rectangle(mid.X, mid.Y, size.X, size.Y)); 
                // If they're completely contained by the quad, bump objects down
                for (int i = 0; i < m_objects.Count; i++)
                {
                    QuadTree<T> destTree = GetDestinationTree(m_objects[i]); 
                    if (destTree != this)
                    {
                        // Insert to the appropriate tree, remove the object, and back up one in the loop
                        destTree.Insert(m_objects[i]);
                        Remove(m_objects[i]);
                        i--;
                    }
                }
            } 
            /// <summary>
            /// Get the child Quad that would contain an object.
            /// </summary>
            /// <param name="item">The object to get a child for.</param>
            /// <returns></returns>
            private QuadTree<T> GetDestinationTree(T item)
            {
                // If a child can't contain an object, it will live in this Quad
                QuadTree<T> destTree = this; 
                if (m_childTL.QuadRect.Contains(item.Rect))
                {
                    destTree = m_childTL;
                }
                else if (m_childTR.QuadRect.Contains(item.Rect))
                {
                    destTree = m_childTR;
                }
                else if (m_childBL.QuadRect.Contains(item.Rect))
                {
                    destTree = m_childBL;
                }
                else if (m_childBR.QuadRect.Contains(item.Rect))
                {
                    destTree = m_childBR;
                } 
                return destTree;
            }
            #endregion 
            #region Public Methods
            /// <summary>
            /// Clears the QuadTree of all objects, including any objects living in its children.
            /// </summary>
            public void Clear()
            {
                // Clear out the children, if we have any
                if (m_childTL != null)
                {
                    m_childTL.Clear();
                    m_childTR.Clear();
                    m_childBL.Clear();
                    m_childBR.Clear();
                } 
                // Clear any objects at this level
                if (m_objects != null)
                {
                    m_objects.Clear();
                    m_objects = null;
                } 
                // Set the children to null
                m_childTL = null;
                m_childTR = null;
                m_childBL = null;
                m_childBR = null;
            } 
            /// <summary>
            /// Deletes an item from this QuadTree. If the object is removed causes this Quad to have no objects in its children, it's children will be removed as well.
            /// </summary>
            /// <param name="item">The item to remove.</param>
            public void Delete(T item)
            {
                // If this level contains the object, remove it
                bool objectRemoved = false;
                if (m_objects != null && m_objects.Contains(item))
                {
                    Remove(item);
                    objectRemoved = true;
                } 
                // If we didn't find the object in this tree, try to delete from its children
                if (m_childTL != null && !objectRemoved)
                {
                    m_childTL.Delete(item);
                    m_childTR.Delete(item);
                    m_childBL.Delete(item);
                    m_childBR.Delete(item);
                } 
                if (m_childTL != null)
                {
                    // If all the children are empty, delete all the children
                    if (m_childTL.Count == 0 &&
                        m_childTR.Count == 0 &&
                        m_childBL.Count == 0 &&
                        m_childBR.Count == 0)
                    {
                        m_childTL = null;
                        m_childTR = null;
                        m_childBL = null;
                        m_childBR = null;
                    }
                }
            } 
            /// <summary>
            /// Insert an item into this QuadTree object.
            /// </summary>
            /// <param name="item">The item to insert.</param>
            public void Insert(T item)
            {
                // If this quad doesn't intersect the items rectangle, do nothing
                if (!m_rect.Intersects(item.Rect))
                    return; 
                if (m_objects == null || 
                    (m_childTL == null && m_objects.Count + 1 <= MAX_OBJECTS_PER_NODE))
                {
                    // If there's room to add the object, just add it
                    Add(item);
                }
                else
                {
                    // No quads, create them and bump objects down where appropriate
                    if (m_childTL == null)
                    {
                        Subdivide();
                    } 
                    // Find out which tree this object should go in and add it there
                    QuadTree<T> destTree = GetDestinationTree(item);
                    if (destTree == this)
                    {
                        Add(item);
                    }
                    else
                    {
                        destTree.Insert(item);
                    }
                }
            } 
            /// <summary>
            /// Get the objects in this tree that intersect with the specified rectangle.
            /// </summary>
            /// <param name="rect">The rectangle to find objects in.</param>
            /// <param name="results">A reference to a list that will be populated with the results.</param>
            public void GetObjects(Rectangle rect, ref List<T> results)
            {
                // We can't do anything if the results list doesn't exist
                if (results != null)
                {
                    if (rect.Contains(m_rect))
                    {
                        // If the search area completely contains this quad, just get every object this quad and all it's children have
                        GetAllObjects(ref results);
                    }
                    else if (rect.Intersects(m_rect))
                    {
                        // Otherwise, if the quad isn't fully contained, only add objects that intersect with the search rectangle
                        if (m_objects != null)
                        {
                            for (int i = 0; i < m_objects.Count; i++)
                            {
                                if (rect.Intersects(m_objects[i].Rect))
                                {
                                    results.Add(m_objects[i]);
                                }
                            }
                        } 
                        // Get the objects for the search rectangle from the children
                        if (m_childTL != null)
                        {
                            m_childTL.GetObjects(rect, ref results);
                            m_childTR.GetObjects(rect, ref results);
                            m_childBL.GetObjects(rect, ref results);
                            m_childBR.GetObjects(rect, ref results);
                        }
                    }
                }
            } 
            /// <summary>
            /// Get all objects in this Quad, and it's children.
            /// </summary>
            /// <param name="results">A reference to a list in which to store the objects.</param>
            public void GetAllObjects(ref List<T> results)
            {
                // If this Quad has objects, add them
                if (m_objects != null)
                    results.AddRange(m_objects); 
                // If we have children, get their objects too
                if (m_childTL != null)
                {
                    m_childTL.GetAllObjects(ref results);
                    m_childTR.GetAllObjects(ref results);
                    m_childBL.GetAllObjects(ref results);
                    m_childBR.GetAllObjects(ref results);
                }
            }
            #endregion
        }
    } 

    翻译自: https://bytes.com/topic/c-sharp/insights/880968-generic-quadtree-implementation

    quadtree

    展开全文
  • QuadTree JS是用JavaScript实现的库,适合想要减少游戏中路口检测次数的游戏开发人员。 它已在LGPL v3上获得许可。
  • 四叉树 由 Mapnificent 的创建者 Stefan Wehrmeyer 实施的 Quadtree。 我从分叉了这个实现,目的是将 Mapnificent 集成到 NodeJS 模块中。 :copyright: 2014 Stefan Wehrmeyer
  • 在这个例子中,我使用的QuadTree<int> ,但如果你是开发一个游戏,你可以使用更方便的值,如QuadTreeQuadTree // Create our quad tree and a list of quads var tree = new QuadTree ( 50 , 0f , 0f , 1000f , ...
  • 项目包括几个演示场景来清楚地展示 QuadTree 的可用性: Only balls(飞球) - QuadTree 中二维对象的简单可视化 Collisions - 检测两个球之间的碰撞(大约 150 个球) 简单碰撞 - 与第二个场景相同,但只有四个...
  • QuadTree c++实现

    热门讨论 2014-02-18 08:24:35
    该代码实现了QuadTree的创建于简单的查询功能 并以真实数据集(City of Oldenburg OL Road Network)共6105个节点进行了简单的测试 该数据集(sortData txt)经过处理按照第一列(精度)从小到大进行了排序
  • QuadTree 2.0 C++

    2014-02-18 20:42:17
    QuadTree的第二个版本,与第一个版本的主要区别为该版本中的叶子可以包含多个数据点,从而避免了内存的搞消耗。详细实验结果见:http://blog.csdn.net/woniu317/article/details/19424587
  • 四叉树演示 基本QuadTree实施
  • QuadTree索引。 QuadTree索引的Java实现。 QuadTree索引假设:索引范围是整个世界使用maxCapacity Integer创建QuadTree,该整数是Items的最大数量(此实现为DataEntry)。 班级 GeoLocation:使用经度和纬度表示...
  • 这是Quadtree的Java实现,Quadtree是一种树数据结构,可用于存储2D位置数据。 用法 创建新的四叉树 从点(0,0)开始以400 x 400尺寸初始化世界 // init. Dimension dimension = new Dimension ( 400 , 400 ); ...
  • open_quadtree_mapping.bag

    2021-05-06 14:01:37
    open_quadtree_mapping.bag的bag文件,用于算法测试的数据
  • 关于使用某些Java 8新功能(例如lambda函数和聚合操作)的Quadtree实现的演示。 这种数据结构使程序员可以快速定位2D空间中包含点的对象,这对于碰撞检测算法很有用。 还可以使用RTS样式的单击并拖动框来选择单位。
  • virtualenv quadtree_test source quadtree_test/bin/activate 安装: pip install smartquadtree 如果没有可用的版本,则可以编译自己的版本: pip install git+git://github.com/xoolive/quadtree 用法 ...
  • 前端项目-d3-quadtree.zip

    2019-09-02 21:01:48
    前端项目-d3-quadtree,二维递归空间细分。
  • Algorithm-QuadTree-Cpp.zip

    2019-09-17 18:04:36
    Algorithm-QuadTree-Cpp.zip,用SFML演示程序编写C 中的简单四叉树,算法是为计算机程序高效、彻底地完成任务而创建的一组详细的准则。
  • qtdecompQuadtree decompositionDescriptionS = qtdecomp(I)performs a quadtree decomposition on the grayscale image I andreturns the quadtree structure in the sparse matrix S. Bydefault, qtdecomp splits ...

    qtdecomp

    Quadtree decomposition

    Description

    S = qtdecomp(I)

    performs a quadtree decomposition on the grayscale image I and

    returns the quadtree structure in the sparse matrix S. By

    default, qtdecomp splits a block unless all elements in the block

    are equal.

    S = qtdecomp(I,threshold)

    splits a block if the maximum value of the block elements minus the minimum value of

    the block elements is greater than threshold.

    mindim, even if the

    resulting blocks do not meet the threshold condition.

    mindim or larger than

    maxdim. Blocks larger than maxdim are

    split even if they meet the threshold condition.

    S = qtdecomp(I,fun)

    uses the function fun to determine whether to split a

    block.

    Examples

    Perform Quadtree Decomposition of Sample Matrix

    Create a small sample matrix.

    I = uint8([1 1 1 1 2 3 6 6;...

    1 1 2 1 4 5 6 8;...

    1 1 1 1 7 7 7 7;...

    1 1 1 1 6 6 5 5;...

    20 22 20 22 1 2 3 4;...

    20 22 22 20 5 4 7 8;...

    20 22 20 20 9 12 40 12;...

    20 22 20 20 13 14 15 16]);

    Perform the quadtree decomposition and display the results.

    S = qtdecomp(I,.05);

    disp(full(S));

    4 0 0 0 4 0 0 0

    0 0 0 0 0 0 0 0

    0 0 0 0 0 0 0 0

    0 0 0 0 0 0 0 0

    4 0 0 0 2 0 2 0

    0 0 0 0 0 0 0 0

    0 0 0 0 2 0 1 1

    0 0 0 0 0 0 1 1

    View Block Representation of Quadtree Decomposition

    Read image into the workspace.

    I = imread('liftingbody.png');

    Perform the quadtree decomposition and display the block representation in a figure.

    S = qtdecomp(I,.27);

    blocks = repmat(uint8(0),size(S));

    for dim = [512 256 128 64 32 16 8 4 2 1];

    numblocks = length(find(S==dim));

    if (numblocks > 0)

    values = repmat(uint8(1),[dim dim numblocks]);

    values(2:dim,2:dim,:) = 0;

    blocks = qtsetblk(blocks,S,dim,values);

    end

    end

    blocks(end,1:end) = 1;

    blocks(1:end,end) = 1;

    imshow(I)

    4ed280593c6bb67ac9f64b3962ad982d.png

    figure

    imshow(blocks,[])

    e9edb4d2f0391d9f36763455b01a8691.png

    Input Arguments

    I — Grayscale image

    m-by-n numeric matrix

    Grayscale image, specified as an

    m-by-n numeric matrix. If the

    syntax includes a function handle, fun, then the image

    can be of any class supported by the function.

    Data Types:single | double | int16 | uint8 | uint16 | logical

    threshold — Threshold of block homogeneity

    scalar in the range [0, 1]

    Threshold of block homogeneity, specified as a scalar in the range [0, 1].

    If I is of class

    uint8, then qtdecomp

    multiplies the value of threshold by 255 to

    determine the actual threshold to use.

    If I is of class

    uint8, then qtdecomp

    multiplies the value of threshold by 65535

    to determine the actual threshold to use.

    mindim — Minimum block dimension

    positive integer

    Minimum block size, specified as a positive integer.

    mindim must be a factor of the image size.

    maxdim — Maximum block dimension

    positive integer

    Maximum block size, specified as a positive integer.

    maxdim/mindim

    must be a power of 2.

    fun — Function handle

    handle

    Function handle, specified as a handle. The function must accept as input

    all m-by-m blocks stacked into an

    m-by-m-by-k

    array, where k is the number of blocks. The function must

    return a logical k-element vector, whose values are

    1 if the corresponding block should be split, and

    0 otherwise. For example, if

    k(3) is 0, then

    the third m-by-m block should not be

    split.

    For more information about function handles, see Create Function Handle.

    Output Arguments

    S — Quadtree structure

    sparse matrix

    Quadtree structure, returned as a sparse matrix. If

    S(k,m) is nonzero, then (k,m) is

    the upper left corner of a block in the decomposition, and the size of the

    block is given by S(k,m).

    Data Types:double

    Tips

    qtdecomp is appropriate primarily for square images whose

    dimensions are a power of 2, such as 128-by-128 or 512-by-512. These images can

    be divided until the blocks are as small as 1-by-1. If you use

    qtdecomp with an image whose dimensions are not a power

    of 2, at some point the blocks cannot be divided further. For example, if an

    image is 96-by-96, it can be divided into blocks of size 48-by-48, then

    24-by-24, 12-by-12, 6-by-6, and finally 3-by-3. No further division beyond

    3-by-3 is possible. To process this image, you must set

    mindim to 3 (or to 3 times a power of 2); if you are

    using the syntax that includes a function, fun, the

    function must return 0 at the point when the block cannot be

    divided further.

    Algorithms

    The qtdecomp function divides a square image into four equal-sized

    square blocks, and then tests each block to see if it meets some criterion of

    homogeneity. If a block meets the criterion, it is not divided any further. If it does

    not meet the criterion, it is subdivided again into four blocks, and the test criterion

    is applied to those blocks. This process is repeated iteratively until each block meets

    the criterion. The result can have blocks of several different sizes.

    Introduced before R2006a

    展开全文
  • 因此,如果您要使用Quadtree的python实现,请随时将quadtree.py复制并粘贴到您的项目中。 整个实现在quadtree / quadtee.py文件中。 示例用法可在example / draw_quadtree.py和example / draw_quadtree_query.py中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,886
精华内容 754
关键字:

Quadtree