Selection.hpp

#ifndef SELECTION_HPP
#define SELECTION_HPP
 
#include "fish/fiber/grid/types/LineSet.hpp"
#include <fish/fiber/baseop/ExpandBBox.hpp>
#include "gridopDllApi.h"
 
// #define SELECTIONBYSHAPE_TEST
 
namespace Fiber
{
 
 
#if 1
 
RefPtr<Chunk<bool> > gridop_API computeIndicesSelectionByShape(const std::vector<Eagle::PhysicalSpace::point>&polygon_coords,
                                                    const std::vector<LineSet::LineIndices_t>&polygon_indices,
                                                    const std::vector<Eagle::PhysicalSpace::point>&pointcloud,
                                                    const RefPtr<Eagle::BoundingBox>&frag_bbox);
 
RefPtr<Chunk<uint32_t> > gridop_API computeIndicesSelectionByShape(const std::vector<Eagle::PhysicalSpace::point>&polygon_coords,
                                                    const std::vector<LineSet::LineIndices_t>&polygon_indices,
                                                    const std::vector<Eagle::PhysicalSpace::point>&pointcloud,
                                                    const RefPtr<Eagle::BoundingBox>&frag_bbox,
                                                    bool Inverse);
 
 
 
#else
 
template<typename T>
std::vector<bool> computeIndicesSelectionByShape(const T& polygon_coords,
                                                 const MultiArray<1,std::vector<uint32_t>>& polygon_indices,
                                                 const MultiArray<1,Eagle::PhysicalSpace::point>& pointcloud,
                                                 const RefPtr<Eagle::BoundingBox>& frag_bbox)
{
std::vector<std::vector<Eagle::PhysicalSpace::point>> clipping(polygon_indices.nElements());
 
        for (unsigned i = 0; i < polygon_indices.nElements(); i++)
                clipping[i] = polygonClipping(polygon_coords, polygon_indices[i], frag_bbox);
 
const unsigned size = pointcloud.nElements();
 
std::vector<bool> inside(size, false);
std::vector<bool> part_of_polygon(size, false);
 
#ifdef USE_OPENMP
#pragma omp parallel for schedule(dynamic, 50000)
#endif
        for (unsigned i = 0; i < size; i++)
        {
        const Eagle::PhysicalSpace::point& p = pointcloud[i];
 
                for (std::vector<Eagle::PhysicalSpace::point> v : clipping)
                {
                        if (v.size() < 3) continue;
 
                int value = pointInPolygon(p,v);
 
                        if (value == 0)
                        {
                                part_of_polygon[i] = true;
                                break;
                        }
 
                        if (value > 0)
                        {
                                inside[i] = true;
                                break;
                        }
                }
        }
 
// handle case where the points are part of the polygon
 
        if (std::count(part_of_polygon.begin(), part_of_polygon.end(), true) > 0)
        {
//              std::cout << "----- investigation of part_of_polygon points: " << std::count(part_of_polygon.begin(), part_of_polygon.end(), true) << " points" << std::endl;
 
#ifdef USE_OPENMP
#pragma omp parallel for schedule(dynamic, 50000)
#endif
                for (unsigned i = 0; i < size; i++)
                {
                        if (!part_of_polygon[i]) continue; // only look at points which lie on the polygon
 
                const Eagle::PhysicalSpace::point& p = pointcloud[i];
 
                        for (std::vector<uint32_t> line : polygon_indices)
                        {
                                if (line.size() < 3) continue;
 
                                if (pointInPolygon(p,polygon_coords,line) >= 0)
                                {
                                        inside[i] = true;
                                        break;
                                }
                        }
                }
        }
//      else
//              std::cout << "----- no investigation of part_of_polygon points" << std::endl;
 
        return inside;
}
 
#endif
 
}
 
#endif // SELECTION_HPP