Method __str__

pygorithm/data_structures/quadtree.py:511–552

Create a human-readable representation of this quad tree .. caution:: Because of the complexity of quadtrees it takes a fair amount of calculation to produce something somewhat legible. All returned statistics have paired functions.

(self)

        return "quadtree(bucket_size={}, max_depth={}, location={}, depth={}, entities={}, children={})".format(self.bucket_size, self.max_depth, repr(self.location), self.depth, self.entities, self.children)
    
    def __str__(self):
        """
        Create a human-readable representation of this quad tree
        
        .. caution::
            
            Because of the complexity of quadtrees it takes a fair amount of calculation to
            produce something somewhat legible. All returned statistics have paired functions.
            This uses only iterative algorithms to calculate statistics.
        
        Example:
        
        .. code-block:: python
            
            from pygorithm.geometry import (vector2, rect2)
            from pygorithm.data_structures import quadtree
            
            # create a tree with a up to 2 entities in a bucket that 
            # can have a depth of up to 5.
            _tree = quadtree.QuadTree(2, 5, rect2.Rect2(100, 100))
            
            # add a few entities to the tree
            _tree.insert_and_think(quadtree.QuadTreeEntity(rect2.Rect2(2, 2, vector2.Vector2(5, 5))))
            _tree.insert_and_think(quadtree.QuadTreeEntity(rect2.Rect2(2, 2, vector2.Vector2(95, 5))))
            
            # prints quadtree(at rect(100x100 at <0, 0>) with 0 entities here (2 in total); (nodes, entities) per depth: [ 0: (1, 0), 1: (4, 2) ] (allowed max depth: 5, actual: 1), avg ent/leaf: 0.5 (target 1), misplaced weight 0.0 (0 best, >1 bad)
            print(_tree)
        
        :returns: human-readable representation of this quad tree
        :rtype: string
        """
        
        nodes_per_depth = self.find_nodes_per_depth()
        _ents_per_depth = self.find_entities_per_depth()
        
        _nodes_ents_per_depth_str = "[ {} ]".format(', '.join("{}: ({}, {})".format(dep, nodes_per_depth[dep], _ents_per_depth[dep]) for dep in nodes_per_depth.keys()))
        
        _sum = self.sum_entities(entities_per_depth=_ents_per_depth)
        _max_depth = max(_ents_per_depth.keys())
        _avg_ent_leaf = self.calculate_avg_ents_per_leaf()
        _mispl_weight = self.calculate_weight_misplaced_ents(sum_entities=_sum)
        return "quadtree(at {} with {} entities here ({} in total); (nodes, entities) per depth: {} (allowed max depth: {}, actual: {}), avg ent/leaf: {} (target {}), misplaced weight {} (0 best, >1 bad)".format(self.location, len(self.entities), _sum, _nodes_ents_per_depth_str, self.max_depth, _max_depth, _avg_ent_leaf, self.bucket_size, _mispl_weight)
        
    @staticmethod
    def get_code():