BitmapPrimitiveShape.h

Go to the documentation of this file.

#ifndef BITMAPPRIMITIVESHAPE_HEADER
#define BITMAPPRIMITIVESHAPE_HEADER
#include <algorithm>
#include <istream>
 
#include "BasePrimitiveShape.h"
#include "IndexIterator.h"
#include <GfxTL/AABox.h>
#include <GfxTL/IndexedIterator.h>
#include <GfxTL/MathHelper.h>
#include <MiscLib/Pair.h>
#include <MiscLib/Performance.h>
#include <MiscLib/Vector.h>
#ifdef DOPARALLEL
#include <omp.h>
#endif
 
#ifndef DLL_LINKAGE
#define DLL_LINKAGE
#endif
 
struct BitmapInfo
{
    MiscLib::Vector<std::pair<float, float>> params;
    MiscLib::Vector<char> bitmap;
    GfxTL::AABox<GfxTL::Vector2Df> bbox;
    MiscLib::Vector<size_t> bmpIdx;
    size_t uextent, vextent;
};
 
class DLL_LINKAGE BitmapPrimitiveShape : public BasePrimitiveShape
{
public:
    bool Init(bool binary, std::istream* i);
    size_t ConnectedComponent(const PointCloud& pc,
                              float epsilon,
                              MiscLib::Vector<size_t>* indices,
                              bool doFiltering = true,
                              float* borderRatio = 0);
    size_t AllConnectedComponents(const PointCloud& pc,
                                  float epsilon,
                                  BitmapInfo& bitmapInfo,
                                  MiscLib::Vector<size_t>* indices,
                                  MiscLib::Vector<int>& componentsImg,
                                  MiscLib::Vector<std::pair<int, size_t>>& labels,
                                  bool doFiltering = true);
    void TrimmingPolygons(const PointCloud& pc,
                          float epsilon,
                          size_t begin,
                          size_t end,
                          std::deque<ComponentPolygons>* polys) const;
    void GenerateBitmapPoints(const PointCloud& pc,
                              float epsilon,
                              size_t begin,
                              size_t end,
                              PointCloud* bmpPc) const;
 
public:
    virtual void Parameters(const Vec3f& p, std::pair<float, float>* param) const = 0;
    virtual bool InSpace(float u, float v, Vec3f* p, Vec3f* n) const = 0;
    virtual void Parameters(
        GfxTL::IndexedIterator<MiscLib::Vector<size_t>::iterator, PointCloud::const_iterator> begin,
        GfxTL::IndexedIterator<MiscLib::Vector<size_t>::iterator, PointCloud::const_iterator> end,
        MiscLib::Vector<std::pair<float, float>>* bmpParams) const = 0;
    virtual void Parameters(GfxTL::IndexedIterator<IndexIterator, PointCloud::const_iterator> begin,
                            GfxTL::IndexedIterator<IndexIterator, PointCloud::const_iterator> end,
                            MiscLib::Vector<std::pair<float, float>>* bmpParams) const = 0;
    virtual void BitmapExtent(float epsilon,
                              GfxTL::AABox<GfxTL::Vector2Df>* bbox,
                              MiscLib::Vector<std::pair<float, float>>* params,
                              size_t* uextent,
                              size_t* vextent) = 0;
    virtual void InBitmap(const std::pair<float, float>& param,
                          float epsilon,
                          const GfxTL::AABox<GfxTL::Vector2Df>& bbox,
                          size_t uextent,
                          size_t vextent,
                          std::pair<int, int>* inBmp) const = 0;
    virtual void PreWrapBitmap(const GfxTL::AABox<GfxTL::Vector2Df>& bbox,
                               float epsilon,
                               size_t uextent,
                               size_t vextent,
                               MiscLib::Vector<char>* bmp) const;
    virtual void WrapBitmap(const GfxTL::AABox<GfxTL::Vector2Df>& bbox,
                            float epsilon,
                            bool* uwrap,
                            bool* vwrap) const = 0;
    virtual void WrapComponents(const GfxTL::AABox<GfxTL::Vector2Df>& bbox,
                                float epsilon,
                                size_t uextent,
                                size_t vextent,
                                MiscLib::Vector<int>* componentImg,
                                MiscLib::Vector<std::pair<int, size_t>>* labels) const;
    virtual bool InSpace(size_t u,
                         size_t v,
                         float epsilon,
                         const GfxTL::AABox<GfxTL::Vector2Df>& bbox,
                         size_t uextent,
                         size_t vextent,
                         Vec3f* p,
                         Vec3f* n) const = 0;
    template <class IteratorT>
    void BuildBitmap(const PointCloud& pc,
                     float* epsilon,
                     IteratorT begin,
                     IteratorT end,
                     MiscLib::Vector<std::pair<float, float>>* params,
                     GfxTL::AABox<GfxTL::Vector2Df>* bbox,
                     MiscLib::Vector<char>* bitmap,
                     size_t* uextent,
                     size_t* vextent,
                     MiscLib::Vector<size_t>* bmpIdx) const;
    template <class IteratorT>
    void BuildBitmap(const PointCloud& pc,
                     float* epsilon,
                     IteratorT begin,
                     IteratorT end,
                     MiscLib::Vector<std::pair<float, float>>* params,
                     GfxTL::AABox<GfxTL::Vector2Df>* bbox,
                     MiscLib::Vector<char>* bitmap,
                     size_t* uextent,
                     size_t* vextent,
                     MiscLib::Vector<size_t>* bmpIdx,
                     size_t border) const;
    void BuildPolygons(const PointCloud& pc,
                       float epsilon,
                       size_t begin,
                       size_t end,
                       GfxTL::AABox<GfxTL::Vector2Df>* bbox,
                       size_t* uextent,
                       size_t* vextent,
                       std::deque<ComponentPolygons>* polys) const;
 
protected:
    mutable GfxTL::AABox<GfxTL::Vector2Df> m_extBbox;
};
 
template <class IteratorT>
void
BitmapPrimitiveShape::BuildBitmap(const PointCloud& pc,
                                  float* epsilon,
                                  IteratorT begin,
                                  IteratorT end,
                                  MiscLib::Vector<std::pair<float, float>>* params,
                                  GfxTL::AABox<GfxTL::Vector2Df>* bbox,
                                  MiscLib::Vector<char>* bitmap,
                                  size_t* uextent,
                                  size_t* vextent,
                                  MiscLib::Vector<size_t>* bmpIdx) const
{
    int size = end - begin;
    params->resize(size);
    // compute parameters and extent
    Parameters(
        GfxTL::IndexIterate(begin, pc.begin()), GfxTL::IndexIterate(end, pc.begin()), params);
    bbox->Min() = GfxTL::Vector2Df(std::numeric_limits<float>::infinity(),
                                   std::numeric_limits<float>::infinity());
    bbox->Max() = -bbox->Min();
    for (size_t i = 0; i < (size_t)size; ++i)
    {
        if ((*params)[i].first < bbox->Min()[0])
        {
            bbox->Min()[0] = (*params)[i].first;
        }
        if ((*params)[i].first > bbox->Max()[0])
        {
            bbox->Max()[0] = (*params)[i].first;
        }
        if ((*params)[i].second < bbox->Min()[1])
        {
            bbox->Min()[1] = (*params)[i].second;
        }
        if ((*params)[i].second > bbox->Max()[1])
        {
            bbox->Max()[1] = (*params)[i].second;
        }
    }
    // bbox gives the bounding box in parameter space
    // we can now set up the bitmap
    const_cast<BitmapPrimitiveShape*>(this)->BitmapExtent(*epsilon, bbox, params, uextent, vextent);
    if (*uextent < 2)
    {
        *uextent = 2;
    }
    if (*vextent < 2)
    {
        *vextent = 2;
    }
    bitmap->resize((*uextent) * (*vextent));
    std::fill(bitmap->begin(), bitmap->end(), false);
    // set all true bits in bitmap
    bmpIdx->resize(params->size());
    //#pragma omp parallel for schedule(static)
    for (int i = 0; i < size; ++i)
    {
        std::pair<int, int> bmpParam;
        InBitmap((*params)[i], *epsilon, *bbox, *uextent, *vextent, &bmpParam);
        // clamp bitmap coords
        bmpParam.first = GfxTL::Math<int>::Clamp(bmpParam.first, 0, *uextent - 1);
        bmpParam.second = GfxTL::Math<int>::Clamp(bmpParam.second, 0, *vextent - 1);
        (*bitmap)[(*bmpIdx)[i] = bmpParam.first + bmpParam.second * (*uextent)] = true;
    }
}
 
template <class IteratorT>
void
BitmapPrimitiveShape::BuildBitmap(const PointCloud& pc,
                                  float* epsilon,
                                  IteratorT begin,
                                  IteratorT end,
                                  MiscLib::Vector<std::pair<float, float>>* params,
                                  GfxTL::AABox<GfxTL::Vector2Df>* bbox,
                                  MiscLib::Vector<char>* bitmap,
                                  size_t* uextent,
                                  size_t* vextent,
                                  MiscLib::Vector<size_t>* bmpIdx,
                                  size_t border) const
{
    params->resize(end - begin);
    // compute parameters and extent
    Parameters(pc[*begin].pos, &(*params)[0]);
    bbox->Min() = bbox->Max() = GfxTL::Vector2Df((*params)[0].first, (*params)[0].second);
    size_t j = 1;
    IteratorT i = begin;
    for (++i; i != end; ++i, ++j)
    {
        Parameters(pc[*i].pos, &(*params)[j]);
        if (bbox->Min()[0] > (*params)[j].first)
        {
            bbox->Min()[0] = (*params)[j].first;
        }
        else if (bbox->Max()[0] < (*params)[j].first)
        {
            bbox->Max()[0] = (*params)[j].first;
        }
        if (bbox->Min()[1] > (*params)[j].second)
        {
            bbox->Min()[1] = (*params)[j].second;
        }
        else if (bbox->Max()[1] < (*params)[j].second)
        {
            bbox->Max()[1] = (*params)[j].second;
        }
    }
    // bbox gives the bounding box in parameter space
    // we can now set up the bitmap
    const_cast<BitmapPrimitiveShape*>(this)->BitmapExtent(*epsilon, bbox, params, uextent, vextent);
    if (*uextent < 2)
    {
        *uextent = 2;
    }
    if (*vextent < 2)
    {
        *vextent = 2;
    }
    bitmap->resize(((*uextent) + 2 * border) * ((*vextent) + 2 * border));
    std::fill(bitmap->begin(), bitmap->end(), false);
    // set all true bits in bitmap
    bmpIdx->resize(params->size());
    size_t lineWidth = (*uextent) + 2 * border;
    for (size_t i = 0; i < params->size(); ++i)
    {
        std::pair<int, int> bmpParam;
        InBitmap((*params)[i], *epsilon, *bbox, *uextent, *vextent, &bmpParam);
        // clamp bitmap coords
        bmpParam.first = GfxTL::Math<int>::Clamp(bmpParam.first, 0, *uextent - 1);
        bmpParam.second = GfxTL::Math<int>::Clamp(bmpParam.second, 0, *vextent - 1);
        (*bitmap)[(*bmpIdx)[i] = bmpParam.first + border + (bmpParam.second + border) * lineWidth] =
            true;
    }
}
 
#endif