12 changed files with 660 additions and 72 deletions
|
Before Width: | Height: | Size: 3.2 KiB After Width: | Height: | Size: 3.9 KiB |
Binary file not shown.
@ -0,0 +1,38 @@ |
|||
#version 150 |
|||
precision highp float; |
|||
|
|||
uniform sampler2DRect tex0; // Your FBO texture (RGB FBO) |
|||
uniform float texW; // FBO texture width |
|||
uniform float texH; // FBO texture height |
|||
|
|||
out vec4 fragColor; // Output color |
|||
in vec2 varyingtexcoord; |
|||
|
|||
void main() { |
|||
float threshold = 0.7; |
|||
float depth = texture(tex0, varyingtexcoord).r; |
|||
|
|||
// Determine which quadrant we're in |
|||
int quadrantX = int(varyingtexcoord.x / (256.0 / 2.0)); |
|||
int quadrantY = int(varyingtexcoord.y / (336.0 / 2.0)); |
|||
int quadrant = quadrantY * 2 + quadrantX; |
|||
|
|||
vec3 baseColor; |
|||
vec3 mixColor = vec3(0.0); // White for mixing in all quadrants |
|||
|
|||
// Choose base color based on quadrant |
|||
if (quadrant == 0) { |
|||
baseColor = vec3(1.0, 0.0, 0.0); // Red for bottom-left |
|||
} else if (quadrant == 1) { |
|||
baseColor = vec3(0.0, 1.0, 0.0); // Green for bottom-right |
|||
} else if (quadrant == 2) { |
|||
baseColor = vec3(0.0, 0.0, 1.0); // Blue for top-left |
|||
} else { |
|||
baseColor = vec3(1.0, 1.0, 1.0); // White for top-right |
|||
} |
|||
|
|||
// Mix the base color with white based on the depth |
|||
vec3 color = mix(mixColor, baseColor, depth); |
|||
|
|||
fragColor = vec4(color, 1.0); |
|||
} |
|||
@ -0,0 +1,13 @@ |
|||
#version 150 |
|||
|
|||
uniform mat4 modelViewProjectionMatrix; |
|||
|
|||
in vec4 position; |
|||
in vec2 texcoord; |
|||
|
|||
out vec2 varyingtexcoord; |
|||
|
|||
void main(){ |
|||
varyingtexcoord = texcoord; |
|||
gl_Position = modelViewProjectionMatrix * position; |
|||
} |
|||
Binary file not shown.
@ -0,0 +1,292 @@ |
|||
/// @file KDTree.cpp
|
|||
/// @author J. Frederico Carvalho
|
|||
///
|
|||
/// This is an adaptation of the KD-tree implementation in rosetta code
|
|||
/// https://rosettacode.org/wiki/K-d_tree
|
|||
///
|
|||
/// It is a reimplementation of the C code using C++. It also includes a few
|
|||
/// more queries than the original, namely finding all points at a distance
|
|||
/// smaller than some given distance to a point.
|
|||
|
|||
#include <algorithm> |
|||
#include <cassert> |
|||
#include <cmath> |
|||
#include <functional> |
|||
#include <iterator> |
|||
#include <limits> |
|||
#include <memory> |
|||
#include <vector> |
|||
|
|||
#include "KDTree.hpp" |
|||
|
|||
KDNode::KDNode() = default; |
|||
|
|||
KDNode::KDNode(point_t const& pt, size_t const& idx_, KDNodePtr const& left_, |
|||
KDNodePtr const& right_) { |
|||
x = pt; |
|||
index = idx_; |
|||
left = left_; |
|||
right = right_; |
|||
} |
|||
|
|||
KDNode::KDNode(pointIndex const& pi, KDNodePtr const& left_, |
|||
KDNodePtr const& right_) { |
|||
x = pi.first; |
|||
index = pi.second; |
|||
left = left_; |
|||
right = right_; |
|||
} |
|||
|
|||
KDNode::~KDNode() = default; |
|||
|
|||
double KDNode::coord(size_t const& idx) { return x.at(idx); } |
|||
KDNode::operator bool() { return (!x.empty()); } |
|||
KDNode::operator point_t() { return x; } |
|||
KDNode::operator size_t() { return index; } |
|||
KDNode::operator pointIndex() { return std::make_pair(x, index); } |
|||
|
|||
KDNodePtr NewKDNodePtr() { |
|||
KDNodePtr mynode = std::make_shared<KDNode>(); |
|||
return mynode; |
|||
} |
|||
|
|||
inline double dist2(point_t const& a, point_t const& b) { |
|||
assert(a.size() == b.size()); |
|||
double distc = 0; |
|||
for (size_t i = 0; i < a.size(); i++) { |
|||
double di = a.at(i) - b.at(i); |
|||
distc += di * di; |
|||
} |
|||
return distc; |
|||
} |
|||
|
|||
inline double dist2(KDNodePtr const& a, KDNodePtr const& b) { |
|||
return dist2(a->x, b->x); |
|||
} |
|||
|
|||
comparer::comparer(size_t idx_) : idx{idx_} {} |
|||
|
|||
inline bool comparer::compare_idx(pointIndex const& a, pointIndex const& b) { |
|||
return (a.first.at(idx) < b.first.at(idx)); |
|||
} |
|||
|
|||
inline void sort_on_idx(pointIndexArr::iterator const& begin, |
|||
pointIndexArr::iterator const& end, size_t idx) { |
|||
comparer comp(idx); |
|||
comp.idx = idx; |
|||
|
|||
using std::placeholders::_1; |
|||
using std::placeholders::_2; |
|||
|
|||
std::nth_element(begin, begin + std::distance(begin, end) / 2, end, |
|||
std::bind(&comparer::compare_idx, comp, _1, _2)); |
|||
} |
|||
|
|||
namespace detail { |
|||
inline bool compare_node_distance(std::pair<KDNodePtr, double> a, |
|||
std::pair<KDNodePtr, double> b) { |
|||
return a.second < b.second; |
|||
} |
|||
} // namespace detail
|
|||
|
|||
using pointVec = std::vector<point_t>; |
|||
|
|||
KDNodePtr KDTree::make_tree(pointIndexArr::iterator const& begin, |
|||
pointIndexArr::iterator const& end, |
|||
size_t const& level) { |
|||
if (begin == end) { |
|||
return leaf_; // empty tree
|
|||
} |
|||
|
|||
assert(std::distance(begin, end) > 0); |
|||
|
|||
size_t const dim = begin->first.size(); |
|||
sort_on_idx(begin, end, level); |
|||
|
|||
auto const num_points = std::distance(begin, end); |
|||
auto const middle{std::next(begin, num_points / 2)}; |
|||
|
|||
size_t const next_level{(level + 1) % dim}; |
|||
KDNodePtr const left{make_tree(begin, middle, next_level)}; |
|||
KDNodePtr const right{make_tree(std::next(middle), end, next_level)}; |
|||
return std::make_shared<KDNode>(*middle, left, right); |
|||
} |
|||
|
|||
KDTree::KDTree(pointVec point_array) : leaf_{std::make_shared<KDNode>()} { |
|||
pointIndexArr arr; |
|||
for (size_t i = 0; i < point_array.size(); i++) { |
|||
arr.emplace_back(point_array.at(i), i); |
|||
} |
|||
root_ = KDTree::make_tree(arr.begin(), arr.end(), 0 /* level */); |
|||
} |
|||
|
|||
void KDTree::node_query_( |
|||
KDNodePtr const& branch, point_t const& pt, size_t const& level, |
|||
size_t const& num_nearest, |
|||
std::list<std::pair<KDNodePtr, double>>& k_nearest_buffer) { |
|||
if (!static_cast<bool>(*branch)) { |
|||
return; |
|||
} |
|||
knearest_(branch, pt, level, num_nearest, k_nearest_buffer); |
|||
double const dl = dist2(branch->x, pt); |
|||
// assert(*branch);
|
|||
auto const node_distance = std::make_pair(branch, dl); |
|||
auto const insert_it = |
|||
std::upper_bound(k_nearest_buffer.begin(), k_nearest_buffer.end(), |
|||
node_distance, detail::compare_node_distance); |
|||
if (insert_it != k_nearest_buffer.end() || |
|||
k_nearest_buffer.size() < num_nearest) { |
|||
k_nearest_buffer.insert(insert_it, node_distance); |
|||
} |
|||
while (k_nearest_buffer.size() > num_nearest) { |
|||
k_nearest_buffer.pop_back(); |
|||
} |
|||
} |
|||
|
|||
void KDTree::knearest_( |
|||
KDNodePtr const& branch, point_t const& pt, size_t const& level, |
|||
size_t const& num_nearest, |
|||
std::list<std::pair<KDNodePtr, double>>& k_nearest_buffer) { |
|||
if (branch == nullptr || !static_cast<bool>(*branch)) { |
|||
return; |
|||
} |
|||
|
|||
point_t branch_pt{*branch}; |
|||
size_t dim = branch_pt.size(); |
|||
assert(dim != 0); |
|||
assert(dim == pt.size()); |
|||
|
|||
double const dx = branch_pt.at(level) - pt.at(level); |
|||
double const dx2 = dx * dx; |
|||
|
|||
// select which branch makes sense to check
|
|||
KDNodePtr const close_branch = (dx > 0) ? branch->left : branch->right; |
|||
KDNodePtr const far_branch = (dx > 0) ? branch->right : branch->left; |
|||
|
|||
size_t const next_level = (level + 1) % dim; |
|||
node_query_(close_branch, pt, next_level, num_nearest, k_nearest_buffer); |
|||
|
|||
// only check the other branch if it makes sense to do so
|
|||
if (dx2 < k_nearest_buffer.back().second || |
|||
k_nearest_buffer.size() < num_nearest) { |
|||
node_query_(far_branch, pt, next_level, num_nearest, k_nearest_buffer); |
|||
} |
|||
}; |
|||
|
|||
// default caller
|
|||
KDNodePtr KDTree::nearest_(point_t const& pt) { |
|||
size_t level = 0; |
|||
std::list<std::pair<KDNodePtr, double>> k_buffer{}; |
|||
k_buffer.emplace_back(root_, dist2(static_cast<point_t>(*root_), pt)); |
|||
knearest_(root_, // beginning of tree
|
|||
pt, // point we are querying
|
|||
level, // start from level 0
|
|||
1, // number of nearest neighbours to return in k_buffer
|
|||
k_buffer // list of k nearest neigbours (to be filled)
|
|||
); |
|||
if (k_buffer.size() > 0) { |
|||
return k_buffer.front().first; |
|||
} |
|||
return nullptr; |
|||
}; |
|||
|
|||
point_t KDTree::nearest_point(point_t const& pt) { |
|||
return static_cast<point_t>(*nearest_(pt)); |
|||
} |
|||
|
|||
size_t KDTree::nearest_index(point_t const& pt) { |
|||
return static_cast<size_t>(*nearest_(pt)); |
|||
} |
|||
|
|||
pointIndex KDTree::nearest_pointIndex(point_t const& pt) { |
|||
KDNodePtr Nearest = nearest_(pt); |
|||
return static_cast<pointIndex>(*Nearest); |
|||
} |
|||
|
|||
pointIndexArr KDTree::nearest_pointIndices(point_t const& pt, |
|||
size_t const& num_nearest) { |
|||
size_t level = 0; |
|||
std::list<std::pair<KDNodePtr, double>> k_buffer{}; |
|||
k_buffer.emplace_back(root_, dist2(static_cast<point_t>(*root_), pt)); |
|||
knearest_(root_, // beginning of tree
|
|||
pt, // point we are querying
|
|||
level, // start from level 0
|
|||
num_nearest, // number of nearest neighbours to return in k_buffer
|
|||
k_buffer); // list of k nearest neigbours (to be filled)
|
|||
pointIndexArr output{num_nearest}; |
|||
std::transform(k_buffer.begin(), k_buffer.end(), output.begin(), |
|||
[](auto const& nodeptr_dist) { |
|||
return static_cast<pointIndex>(*(nodeptr_dist.first)); |
|||
}); |
|||
return output; |
|||
} |
|||
|
|||
pointVec KDTree::nearest_points(point_t const& pt, size_t const& num_nearest) { |
|||
auto const k_nearest{nearest_pointIndices(pt, num_nearest)}; |
|||
pointVec k_nearest_points(k_nearest.size()); |
|||
std::transform(k_nearest.begin(), k_nearest.end(), k_nearest_points.begin(), |
|||
[](pointIndex const& x) { return x.first; }); |
|||
return k_nearest_points; |
|||
} |
|||
|
|||
indexArr KDTree::nearest_indices(point_t const& pt, size_t const& num_nearest) { |
|||
auto const k_nearest{nearest_pointIndices(pt, num_nearest)}; |
|||
indexArr k_nearest_indices(k_nearest.size()); |
|||
std::transform(k_nearest.begin(), k_nearest.end(), |
|||
k_nearest_indices.begin(), |
|||
[](pointIndex const& x) { return x.second; }); |
|||
return k_nearest_indices; |
|||
} |
|||
|
|||
void KDTree::neighborhood_(KDNodePtr const& branch, point_t const& pt, |
|||
double const& rad2, size_t const& level, |
|||
pointIndexArr& nbh) { |
|||
if (!bool(*branch)) { |
|||
// branch has no point, means it is a leaf,
|
|||
// no points to add
|
|||
return; |
|||
} |
|||
|
|||
size_t const dim = pt.size(); |
|||
|
|||
double const d = dist2(static_cast<point_t>(*branch), pt); |
|||
double const dx = static_cast<point_t>(*branch).at(level) - pt.at(level); |
|||
double const dx2 = dx * dx; |
|||
|
|||
if (d <= rad2) { |
|||
nbh.push_back(static_cast<pointIndex>(*branch)); |
|||
} |
|||
|
|||
KDNodePtr const close_branch = (dx > 0) ? branch->left : branch->right; |
|||
KDNodePtr const far_branch = (dx > 0) ? branch->right : branch->left; |
|||
|
|||
size_t const next_level{(level + 1) % dim}; |
|||
neighborhood_(close_branch, pt, rad2, next_level, nbh); |
|||
if (dx2 < rad2) { |
|||
neighborhood_(far_branch, pt, rad2, next_level, nbh); |
|||
} |
|||
} |
|||
|
|||
pointIndexArr KDTree::neighborhood(point_t const& pt, double const& rad) { |
|||
pointIndexArr nbh; |
|||
neighborhood_(root_, pt, rad * rad, /*level*/ 0, nbh); |
|||
return nbh; |
|||
} |
|||
|
|||
pointVec KDTree::neighborhood_points(point_t const& pt, double const& rad) { |
|||
auto nbh = std::make_shared<pointIndexArr>(); |
|||
neighborhood_(root_, pt, rad * rad, /*level*/ 0, *nbh); |
|||
pointVec nbhp(nbh->size()); |
|||
auto const first = [](pointIndex const& x) { return x.first; }; |
|||
std::transform(nbh->begin(), nbh->end(), nbhp.begin(), first); |
|||
return nbhp; |
|||
} |
|||
|
|||
indexArr KDTree::neighborhood_indices(point_t const& pt, double const& rad) { |
|||
auto nbh = std::make_shared<pointIndexArr>(); |
|||
neighborhood_(root_, pt, rad * rad, /*level*/ 0, *nbh); |
|||
indexArr nbhi(nbh->size()); |
|||
auto const second = [](pointIndex const& x) { return x.second; }; |
|||
std::transform(nbh->begin(), nbh->end(), nbhi.begin(), second); |
|||
return nbhi; |
|||
} |
|||
@ -0,0 +1,179 @@ |
|||
#pragma once |
|||
|
|||
/// @file KDTree.hpp
|
|||
/// @author J. Frederico Carvalho
|
|||
///
|
|||
/// This is an adaptation of the KD-tree implementation in rosetta code
|
|||
/// https://rosettacode.org/wiki/K-d_tree
|
|||
/// It is a reimplementation of the C code using C++.
|
|||
/// It also includes a few more queries than the original
|
|||
|
|||
#include <algorithm> |
|||
#include <functional> |
|||
#include <list> |
|||
#include <memory> |
|||
#include <vector> |
|||
|
|||
/// The point type (vector of double precision floats)
|
|||
using point_t = std::vector<double>; |
|||
|
|||
/// Array of indices
|
|||
using indexArr = std::vector<size_t>; |
|||
|
|||
/// Pair of point and Index
|
|||
using pointIndex = typename std::pair<std::vector<double>, size_t>; |
|||
|
|||
class KDNode { |
|||
public: |
|||
using KDNodePtr = std::shared_ptr<KDNode>; |
|||
size_t index; |
|||
point_t x; |
|||
KDNodePtr left; |
|||
KDNodePtr right; |
|||
|
|||
// initializer
|
|||
KDNode(); |
|||
KDNode(point_t const&, size_t const&, KDNodePtr const&, KDNodePtr const&); |
|||
KDNode(pointIndex const&, KDNodePtr const&, KDNodePtr const&); |
|||
~KDNode(); |
|||
|
|||
// getter
|
|||
double coord(size_t const&); |
|||
|
|||
// conversions
|
|||
explicit operator bool(); |
|||
explicit operator point_t(); |
|||
explicit operator size_t(); |
|||
explicit operator pointIndex(); |
|||
}; |
|||
|
|||
using KDNodePtr = std::shared_ptr<KDNode>; |
|||
|
|||
KDNodePtr NewKDNodePtr(); |
|||
|
|||
// square euclidean distance
|
|||
inline double dist2(point_t const&, point_t const&); |
|||
inline double dist2(KDNodePtr const&, KDNodePtr const&); |
|||
|
|||
// Need for sorting
|
|||
class comparer { |
|||
public: |
|||
size_t idx; |
|||
explicit comparer(size_t idx_); |
|||
inline bool compare_idx(std::pair<std::vector<double>, size_t> const&, //
|
|||
std::pair<std::vector<double>, size_t> const& //
|
|||
); |
|||
}; |
|||
|
|||
using pointIndexArr = typename std::vector<pointIndex>; |
|||
|
|||
inline void sort_on_idx(pointIndexArr::iterator const&, //
|
|||
pointIndexArr::iterator const&, //
|
|||
size_t idx); |
|||
|
|||
using pointVec = std::vector<point_t>; |
|||
|
|||
class KDTree { |
|||
|
|||
public: |
|||
KDTree() = default; |
|||
|
|||
/// Build a KDtree
|
|||
explicit KDTree(pointVec point_array); |
|||
|
|||
/// Get the point which lies closest to the input point.
|
|||
/// @param pt input point.
|
|||
point_t nearest_point(point_t const& pt); |
|||
|
|||
/// Get the index of the point which lies closest to the input point.
|
|||
///
|
|||
/// @param pt input point.
|
|||
size_t nearest_index(point_t const& pt); |
|||
|
|||
/// Get the point and its index which lies closest to the input point.
|
|||
///
|
|||
/// @param pt input point.
|
|||
pointIndex nearest_pointIndex(point_t const& pt); |
|||
|
|||
/// Get both the point and the index of the points closest to the input
|
|||
/// point.
|
|||
///
|
|||
/// @param pt input point.
|
|||
/// @param num_nearest Number of nearest points to return.
|
|||
///
|
|||
/// @returns a vector containing the points and their respective indices
|
|||
/// which are at a distance smaller than rad to the input point.
|
|||
pointIndexArr nearest_pointIndices(point_t const& pt, |
|||
size_t const& num_nearest); |
|||
|
|||
/// Get the nearest set of points to the given input point.
|
|||
///
|
|||
/// @param pt input point.
|
|||
/// @param num_nearest Number of nearest points to return.
|
|||
///
|
|||
/// @returns a vector containing the points which are at a distance smaller
|
|||
/// than rad to the input point.
|
|||
pointVec nearest_points(point_t const& pt, size_t const& num_nearest); |
|||
|
|||
/// Get the indices of points closest to the input point.
|
|||
///
|
|||
/// @param pt input point.
|
|||
/// @param num_nearest Number of nearest points to return.
|
|||
///
|
|||
/// @returns a vector containing the indices of the points which are at a
|
|||
/// distance smaller than rad to the input point.
|
|||
indexArr nearest_indices(point_t const& pt, size_t const& num_nearest); |
|||
|
|||
/// Get both the point and the index of the points which are at a distance
|
|||
/// smaller than the input radius to the input point.
|
|||
///
|
|||
/// @param pt input point.
|
|||
/// @param rad input radius.
|
|||
///
|
|||
/// @returns a vector containing the points and their respective indices
|
|||
/// which are at a distance smaller than rad to the input point.
|
|||
pointIndexArr neighborhood(point_t const& pt, double const& rad); |
|||
|
|||
/// Get the points that are at a distance to the input point which is
|
|||
/// smaller than the input radius.
|
|||
///
|
|||
/// @param pt input point.
|
|||
/// @param rad input radius.
|
|||
///
|
|||
/// @returns a vector containing the points which are at a distance smaller
|
|||
/// than rad to the input point.
|
|||
pointVec neighborhood_points(point_t const& pt, double const& rad); |
|||
|
|||
/// Get the indices of points that are at a distance to the input point
|
|||
/// which is smaller than the input radius.
|
|||
///
|
|||
/// @param pt input point.
|
|||
/// @param rad input radius.
|
|||
///
|
|||
/// @returns a vector containing the indices of the points which are at a
|
|||
/// distance smaller than rad to the input point.
|
|||
indexArr neighborhood_indices(point_t const& pt, double const& rad); |
|||
|
|||
private: |
|||
KDNodePtr make_tree(pointIndexArr::iterator const& begin, |
|||
pointIndexArr::iterator const& end, |
|||
size_t const& level); |
|||
|
|||
void knearest_(KDNodePtr const& branch, point_t const& pt, |
|||
size_t const& level, size_t const& num_nearest, |
|||
std::list<std::pair<KDNodePtr, double>>& k_nearest_buffer); |
|||
|
|||
void node_query_(KDNodePtr const& branch, point_t const& pt, |
|||
size_t const& level, size_t const& num_nearest, |
|||
std::list<std::pair<KDNodePtr, double>>& k_nearest_buffer); |
|||
|
|||
// default caller
|
|||
KDNodePtr nearest_(point_t const& pt); |
|||
|
|||
void neighborhood_(KDNodePtr const& branch, point_t const& pt, |
|||
double const& rad2, size_t const& level, |
|||
pointIndexArr& nbh); |
|||
|
|||
KDNodePtr root_; |
|||
KDNodePtr leaf_; |
|||
}; |
|||
Loading…
Reference in new issue