KPConv-PyTorch/cpp_wrappers/cpp_utils/cloud/cloud.h

186 lines
3.3 KiB
C
Raw Normal View History

2020-03-31 19:42:35 +00:00
//
//
// 0==========================0
// | Local feature test |
// 0==========================0
//
// version 1.0 :
// >
//
//---------------------------------------------------
//
// Cloud header
//
//----------------------------------------------------
//
// Hugues THOMAS - 10/02/2017
//
# pragma once
#include <vector>
#include <unordered_map>
#include <map>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <time.h>
// Point class
// ***********
class PointXYZ
{
public:
// Elements
// ********
float x, y, z;
// Methods
// *******
// Constructor
PointXYZ() { x = 0; y = 0; z = 0; }
PointXYZ(float x0, float y0, float z0) { x = x0; y = y0; z = z0; }
// array type accessor
float operator [] (int i) const
{
if (i == 0) return x;
else if (i == 1) return y;
else return z;
}
// opperations
float dot(const PointXYZ P) const
{
return x * P.x + y * P.y + z * P.z;
}
float sq_norm()
{
return x*x + y*y + z*z;
}
PointXYZ cross(const PointXYZ P) const
{
return PointXYZ(y*P.z - z*P.y, z*P.x - x*P.z, x*P.y - y*P.x);
}
PointXYZ& operator+=(const PointXYZ& P)
{
x += P.x;
y += P.y;
z += P.z;
return *this;
}
PointXYZ& operator-=(const PointXYZ& P)
{
x -= P.x;
y -= P.y;
z -= P.z;
return *this;
}
PointXYZ& operator*=(const float& a)
{
x *= a;
y *= a;
z *= a;
return *this;
}
};
// Point Opperations
// *****************
inline PointXYZ operator + (const PointXYZ A, const PointXYZ B)
{
return PointXYZ(A.x + B.x, A.y + B.y, A.z + B.z);
}
inline PointXYZ operator - (const PointXYZ A, const PointXYZ B)
{
return PointXYZ(A.x - B.x, A.y - B.y, A.z - B.z);
}
inline PointXYZ operator * (const PointXYZ P, const float a)
{
return PointXYZ(P.x * a, P.y * a, P.z * a);
}
inline PointXYZ operator * (const float a, const PointXYZ P)
{
return PointXYZ(P.x * a, P.y * a, P.z * a);
}
inline std::ostream& operator << (std::ostream& os, const PointXYZ P)
{
return os << "[" << P.x << ", " << P.y << ", " << P.z << "]";
}
inline bool operator == (const PointXYZ A, const PointXYZ B)
{
return A.x == B.x && A.y == B.y && A.z == B.z;
}
inline PointXYZ floor(const PointXYZ P)
{
return PointXYZ(std::floor(P.x), std::floor(P.y), std::floor(P.z));
}
PointXYZ max_point(std::vector<PointXYZ> points);
PointXYZ min_point(std::vector<PointXYZ> points);
struct PointCloud
{
std::vector<PointXYZ> pts;
// Must return the number of data points
inline size_t kdtree_get_point_count() const { return pts.size(); }
// Returns the dim'th component of the idx'th point in the class:
// Since this is inlined and the "dim" argument is typically an immediate value, the
// "if/else's" are actually solved at compile time.
inline float kdtree_get_pt(const size_t idx, const size_t dim) const
{
if (dim == 0) return pts[idx].x;
else if (dim == 1) return pts[idx].y;
else return pts[idx].z;
}
// Optional bounding-box computation: return false to default to a standard bbox computation loop.
// Return true if the BBOX was already computed by the class and returned in "bb" so it can be avoided to redo it again.
// Look at bb.size() to find out the expected dimensionality (e.g. 2 or 3 for point clouds)
template <class BBOX>
bool kdtree_get_bbox(BBOX& /* bb */) const { return false; }
};