如何找到包含所有给定盒子的盒子？

Question

我有一系列提升几何框类型，并希望找到包含所有这些对象的框的尺寸。

我注意到boost几何提供了encompass函数，这看起来像我要求的一般几何概念，但我不知道如何为一系列的盒子做这个。

基本上我只需要自己滚动，但我想知道是否可以简单地将一系列方框转换为“几何”，以便我可以简单地应用envelope函数。这是我目前写的：

// elsewhere in my code:
using Location = boost::geometry::model::d2::point_xy<double>;
using Box = boost::geometry::model::box<Location>;

// calculate the smallest box that fully encompasses all provided boxes            
template <template <typename...> class IterableContainer>                          
Box Envelope(const IterableContainer<Box>& sequence)                               
{                                                                                  
    Location minCorner(                                                            
        std::numeric_limits<double>::max(),                                        
        std::numeric_limits<double>::max());                                       

    Location maxCorner(                                                            
        std::numeric_limits<double>::lowest(),                                        
        std::numeric_limits<double>::lowest());                                       

    for (auto& box : sequence)                                                     
    {                                                                              
        if (box.min_corner().x() < minCorner.x())                                  
            minCorner.x() == box.min_corner().x();                                 

        if (box.min_corner().y() < minCorner.y())                                  
            minCorner.y() == box.min_corner().y();                                 

        if (box.max_corner().x() > maxCorner.x())                                  
            maxCorner.x() == box.max_corner().x();                                 

        if (box.max_corner().y() > maxCorner.y())                                  
            maxCorner.y() == box.max_corner().y();                                 
    }                                                                              

    return Box(minCorner, maxCorner);                                              
}                                                                                  

Answer 1

您正在寻找的功能称为std::accumulate。你需要为它提供一个盒子联合功能。

using Location = boost::geometry::model::d2::point_xy<double>;
using Box = boost::geometry::model::box<Location>;
double pinfi = std::numeric_limits<double>::max();
double ninfi = std::numeric_limits<double>::lowest();

Box u = std::accumulate(container.begin(), container.end(), 
                        Box(Location(pinfi,pinfi), Location(ninfi,ninfi)),
                        [](const Box& a, const Box& b) { 
                            return Box(
                                    Location(
                                     std::min(a.min_corner().x(),b.min_corner().x()),
                                     std::min(a.min_corner().y(),b.min_corner().y())),
                                    Location(
                                     std::max(a.max_corner().x(),b.max_corner().x()),
                                     std::min(a.max_corner().y(),b.max_corner().y())));

                        });

更新：此函数的构建块已存在于boost :: geometry中。这是完整的测试代码：

template <typename T>
Box box_encompass (T beg, T end)
{
    return std::accumulate(beg, end, boost::geometry::make_inverse<Box>(),
                [](Box a, const Box& b) -> Box {
                    boost::geometry::expand(a,b);
                    return a;
                });
}