C++ Octree::isLeaf方法代码示例

/**
 * Simple octree color quantization: Similar to http://rosettacode.org/wiki/Color_quantization#C
 */
void octreeColorQuantize(const RGBAImage& image, size_t max_colors,
		std::vector<RGBAPixel>& colors, Octree** octree) {
	assert(max_colors > 0);

	// have an octree with the colors as leaves
	Octree* internal_octree = new Octree();
	// and a priority queue of leaves to be processed
	// the order of leaves is very important, see NodeComparator
	std::priority_queue<Octree*, std::vector<Octree*>, NodeComparator> queue;

	// insert the colors into the octree
	for (int x = 0; x < image.getWidth(); x++) {
		for (int y = 0; y < image.getHeight(); y++) {
			RGBAPixel color = image.pixel(x, y);
			Octree* node = Octree::findOrCreateNode(internal_octree, color);
			node->setColor(color);
			// add the leaf only once to the queue
			if (node->getCount() == 1)
				queue.push(node);
		}
	}

	// now: reduce the leaves until we have less colors than maximum
	while (queue.size() > max_colors) {
		Octree* node = queue.top();
		assert(node->isLeaf());
		queue.pop();
		
		// add the color value of the leaf to the parent
		node->reduceToParent();
		Octree* parent = node->getParent();
		// delete the leaf (leaf is automatically removed from parent in reduceToParent())
		delete node;

		// add parent to queue if it is a leaf now
		if (parent->isLeaf())
			queue.push(parent);
	}

	// gather the quantized colors
	while (queue.size()) {
		Octree* node = queue.top();
		assert(node->isLeaf());
		node->setColorID(colors.size());
		colors.push_back(node->getColor());
		queue.pop();
	}

	if (octree != nullptr)
		*octree = internal_octree;
	else
		delete internal_octree;
}

void testOctreeWithImage(const RGBAImage& image) {
	std::set<RGBAPixel> colors;
	int r = 0, g = 0, b = 0, count = 0;

	Octree octree;

	// insert all pixels into an octree
	for (int x = 0; x < image.getWidth(); x++) {
		for (int y = 0; y < image.getHeight(); y++) {
			RGBAPixel color = image.getPixel(x, y);
			colors.insert(color);
			r += rgba_red(color);
			g += rgba_green(color);
			b += rgba_blue(color);
			count++;

			Octree::findOrCreateNode(&octree, color)->setColor(color);
		}
	}

	// make sure that all colors are inserted correctly
	BOOST_CHECK(octree.isRoot() && !octree.isLeaf());
	BOOST_CHECK(!octree.hasColor());

	// reduce all colors up to the root of the tree
	// the color should be the overall average color
	traverseReduceOctree(&octree);
	BOOST_CHECK(octree.hasColor());

	RGBAPixel average1 = octree.getColor();
	RGBAPixel average2 = rgba(r / count, g / count, b / count, 255);
	BOOST_CHECK_EQUAL(average1, average2);

	BOOST_TEST_MESSAGE("Overall colors: " << colors.size());
	BOOST_TEST_MESSAGE("Pixels per color: " << (double) (image.getWidth() * image.getHeight()) / colors.size());
	BOOST_TEST_MESSAGE("Average color: " << (int) rgba_red(average1) << ","
			<< (int) rgba_green(average1) << "," << (int) rgba_blue(average1));
}

    MeshComponent* OctreeSpatialPartitions::RayCast(Ray ray, float* outDistance)
    {
        ScopedLock _lock(octree.elementsLock);

        if (filterDuplicates)
            lastRaycastBucket = nullptr;
        
        Octree* currentLeaf = &octree;
        float dist = 0;
        Vector<3> point = ray.origin;

        MeshComponent* result = nullptr;
        float distance = 0;

        while (true)
        {
            if (currentLeaf == nullptr)
                break;

            point = ray.origin + ray.direction * dist;
            while (!currentLeaf->isLeaf())
            {
                currentLeaf = currentLeaf->child(point[0] > currentLeaf->centerX(), point[1] > currentLeaf->centerY(), point[2] > currentLeaf->centerZ());
            }

            float xDist = (ray.direction[0] < 0 ? currentLeaf->minX() : currentLeaf->maxX()) - point[0];
            float yDist = (ray.direction[1] < 0 ? currentLeaf->minY() : currentLeaf->maxY()) - point[1];
            float zDist = (ray.direction[2] < 0 ? currentLeaf->minZ() : currentLeaf->maxZ()) - point[2];

            float xNext = dist + xDist / ray.direction[0];
            float yNext = dist + yDist / ray.direction[1];
            float zNext = dist + zDist / ray.direction[2];

            float currentDistance;
            MeshComponent* currentResult = RayCastPartition(currentLeaf, ray, &currentDistance);
            if (currentResult != nullptr)
            {
                if (aggressiveShortCircuit)
                {
                    result = currentResult;
                    distance = currentDistance;
                    break;
                }
                else
                {
                    if (result == nullptr || currentDistance < distance)
                    {
                        result = currentResult;
                        distance = currentDistance;
                    }
                }
            }

            if (!aggressiveShortCircuit && result != nullptr && distance < xNext && distance < yNext && distance < zNext)
            {
                break;
            }

            if (xNext < yNext)
            {
                if (xNext < zNext)
                {
                    dist = xNext;
                    currentLeaf = currentLeaf->neighborX(ray.direction[0] > 0);
                    continue;
                }
            }
            else if (yNext < zNext)
            {
                dist = yNext;
                currentLeaf = currentLeaf->neighborY(ray.direction[1] > 0);
                continue;
            }
            dist = zNext;
            currentLeaf = currentLeaf->neighborZ(ray.direction[2] > 0);
        }
        
        if (result != nullptr)
            *outDistance = distance;
        return result;
    }