PointCloud.h

Go to the documentation of this file.

#ifndef _POINTCLOUD_H
#define _POINTCLOUD_H
#include <cstdio>
#ifndef _USE_MATH_DEFINES
#define _USE_MATH_DEFINES
#endif
#include <cmath>
#include <MiscLib/Vector.h>
#include <limits>
#include <GfxTL/VectorXD.h>
#include "basic.h"
#include <MiscLib/Vector.h>
#include <MiscLib/AlignedAllocator.h>
#undef min
#undef max
 
#ifndef DLL_LINKAGE
#define DLL_LINKAGE
#endif
 
struct DLL_LINKAGE Point
{
    enum { Dim = 3 };
    typedef float ScalarType;
    typedef float value_type;
    Vec3f pos;
    Vec3f normal;
#ifdef POINTSWITHINDEX
    size_t index;
#endif
    //unsigned int meshFaceIndex;
    Point() {}
    Point(const Vec3f& Pos)
    {
        /*index = -1;*/ pos = Pos;
        normal = Vec3f(0, 0, 0);
    }
    Point(const Vec3f& Pos, const Vec3f& Normal)
    {
        pos = Pos;
        normal = Normal;
    }
    const float operator[](unsigned int i) const
    {
        return pos[i];
    }
    float& operator[](unsigned int i)
    {
        return pos[i];
    }
    operator const Vec3f& () const
    {
        return pos;
    }
    operator Vec3f& ()
    {
        return pos;
    }
    operator GfxTL::VectorXD< 3, float >& ()
    {
        return *reinterpret_cast< GfxTL::Vector3Df* >(&pos);
    }
    operator const GfxTL::VectorXD< 3, float >& () const
    {
        return *reinterpret_cast< const GfxTL::Vector3Df* >(&pos);
    }
};
 
class DLL_LINKAGE PointCloud
    : public MiscLib::Vector< Point >
{
public:
    PointCloud();
    PointCloud(Point* points, unsigned int size);
    PointCloud& operator+=(const PointCloud& other)
    {
        size_t oldSize = size();
        resize(oldSize + other.size());
        std::copy(other.begin(), other.end(), begin() + oldSize);
        m_min = Vec3f(std::min(m_min[0], other.m_min[0]),
                      std::min(m_min[1], other.m_min[1]),
                      std::min(m_min[2], other.m_min[2]));
        m_max = Vec3f(std::max(m_max[0], other.m_max[0]),
                      std::max(m_max[1], other.m_max[1]),
                      std::max(m_max[2], other.m_max[2]));
        return *this;
    }
    void swapPoints(unsigned int i, unsigned int j)
    {
        std::swap(at(i), at(j));
    }
    void calcNormals(float radius, unsigned int kNN = 20, unsigned int maxTries = 100);
    void reset(size_t s = 0);
    void setBBox(Vec3f bbl, float size)
    {
        m_min = bbl;
        m_max = m_min + Vec3f(size, size, size);
    }
    void setBBox(Vec3f min, Vec3f max)
    {
        m_min = min;
        m_max = max;
    }
    void widenBBox(float delta)
    {
        Vec3f d(delta, delta, delta);
        m_min -= d;
        m_max += d;
    }
    float getScale() const
    {
        Vec3f diff = m_max - m_min;
        return std::max(std::max(diff[0], diff[1]), diff[2]);
    }
    const Vec3f& getOffset() const
    {
        return m_min;
    }
    float* getBbox() const;
    // returns a transfromed bbox if m_transformed is true
    void GetCurrentBBox(Vec3f* min, Vec3f* max) const;
    const Vec3f& GetBBoxMin() const
    {
        return m_min;
    }
    const Vec3f& GetBBoxMax() const
    {
        return m_max;
    }
    Vec3f& GetBBoxMin()
    {
        return m_min;
    }
    Vec3f& GetBBoxMax()
    {
        return m_max;
    }
    void Translate(const Vec3f& trans);
 
private:
    Vec3f m_min, m_max;
};
 
#endif