Algorithm-QuadTree-XS

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

op_linklist|5.013006|5.013006|
op_lvalue|5.013007|5.013007|x
op_lvalue_flags|||ciu
OP_LVALUE_NO_CROAK|5.015001||Viu
OpMAYBESIB_set|5.021011|5.003007|p
opmethod_stash|5.021007||Viu
OpMORESIB_set|5.021011|5.003007|p
OP_NAME|5.007003|5.007003|
op_null|5.007002|5.007002|
OPpALLOW_FAKE|5.015006||Viu
op_parent|5.025001|5.025001|n
OPpARG1_MASK|5.021004||Viu
OPpARG2_MASK|5.021004||Viu
OPpARG3_MASK|5.021004||Viu
OPpARG4_MASK|5.021004||Viu
OPpARGELEM_AV|5.025004||Viu
OPpARGELEM_HV|5.025004||Viu
OPpARGELEM_MASK|5.025004||Viu
OPpARGELEM_SV|5.025004||Viu
OPpASSIGN_BACKWARDS|5.003007||Viu
OPpASSIGN_COMMON_AGG|5.023002||Viu

ppport.h  view on Meta::CPAN

#ifndef OpSIBLING
#  define OpSIBLING(o)                   (0 + (o)->op_sibling)
#endif

#ifndef OpMORESIB_set
#  define OpMORESIB_set(o, sib)          ((o)->op_sibling = (sib))
#endif

#ifndef OpLASTSIB_set
#  define OpLASTSIB_set(o, parent)       ((o)->op_sibling = NULL)
#endif

#ifndef OpMAYBESIB_set
#  define OpMAYBESIB_set(o, sib, parent) ((o)->op_sibling = (sib))
#endif

#ifndef HEf_SVKEY
#  define HEf_SVKEY                      -2
#endif

#if defined(DEBUGGING) && !defined(__COVERITY__)
#ifndef __ASSERT_
#  define __ASSERT_(statement)           assert(statement),
#endif

qtbase.c  view on Meta::CPAN

		}
	}

	destroy_array(root->objects);
	root->objects = new_list;

	/* NOTE: no shape destruction here, since "adopt_object" does not create it */
	hv_delete_ent(root->backref, value, 0, 0);
}

QuadTreeNode* create_nodes(int count, QuadTreeNode *parent)
{
	QuadTreeNode *node = malloc(count * sizeof *node);

	int i;
	for (i = 0; i < count; ++i) {
		node[i].values = NULL;
		node[i].children = NULL;
		node[i].parent = parent;
		node[i].has_objects = false;
	}

	return node;
}

/* NOTE: does not actually free the node, but frees its children nodes */
void destroy_node(QuadTreeNode *node)
{
	if (node->values != NULL) {

qtbase.c  view on Meta::CPAN

void clear_has_objects (QuadTreeNode *node)
{
	if (node->values == NULL) {
		int i;
		for (i = 0; i < CHILDREN_PER_NODE; ++i) {
			if (node->children[i].has_objects) return;
		}
	}

	node->has_objects = false;
	if (node->parent != NULL) {
		clear_has_objects(node->parent);
	}
}

QuadTreeRootNode* create_root()
{
	QuadTreeRootNode *root = malloc(sizeof *root);
	root->node = create_nodes(1, NULL);
	root->backref = newHV();
	root->objects = create_array();

qtbase.h  view on Meta::CPAN

#include "ppport.h"

typedef struct QuadTreeNode QuadTreeNode;
typedef struct QuadTreeRootNode QuadTreeRootNode;
typedef struct DynArr DynArr;
typedef enum ShapeType ShapeType;
typedef struct Shape Shape;

struct QuadTreeNode {
	QuadTreeNode *children;
	QuadTreeNode *parent;
	DynArr *values;
	double xmin, ymin, xmax, ymax;
	bool has_objects;
};

struct QuadTreeRootNode {
	QuadTreeNode *node;
	HV *backref;
	DynArr *objects;
};

qtbase.h  view on Meta::CPAN

typedef enum ShapeType ShapeType;

Shape* create_shape();
void destroy_shape(Shape *s);

DynArr* create_array();
void destroy_array(DynArr* arr);
void push_array(DynArr *arr, void *ptr);

QuadTreeNode* create_nodes(int count, QuadTreeNode *parent);
void destroy_node(QuadTreeNode *node);
QuadTreeRootNode* create_root();

void adopt_object (QuadTreeRootNode *root, SV *value, Shape *s);
void disown_object (QuadTreeRootNode *root, SV *value);

void node_add_level(QuadTreeNode* node, double xmin, double ymin, double xmax, double ymax, int depth);
void find_nodes(QuadTreeNode *node, HV *ret, Shape *param);
bool fill_nodes(QuadTreeNode *node, SV *value, Shape *param);
void delete_nodes(QuadTreeNode *node, SV *value, Shape *param);