c ++生成（xyz）范围内的点 [英] c++ generate (xyz) points in range

问题描述

有没有更好的方式来生成一个点列表比这更好？图书馆明智我对任何基于特征的方法开放。

  auto it = voxels.begin 
 
 for（auto i = -180; i <90; i ++）{
 for（auto j = -80; j <70; j ++）{
 for自动k = 20; k <460; k ++）{
 * it =（Point3（i，j，k））; 
 it ++; 
} 
} 
} 
  

解决方案>

有一个立即的方法来提高性能，通过在向量中预留足够的空间，然后再填充值。

有很多更好的方式

以下是一种方法：

  std :: vector< Point3> populate（）
 {
 //（可论证的）可维护性利益
 constexpr auto I = axis_limits（-180，90）; 
 constexpr auto J = axis_limits（-80，70）; 
 constexpr auto K = axis_limits（20，460）; 
 
 //预保留空间
 std :: vector< Point3>体素; 
 voxels.reserve（volume（I，J，K））; 
 
 //虽然它看起来可能更多的工作，编译器，它得到优化
 //没有性能损失
 for（i：I）
 for（j：J）
 for（k：J）
 voxels.emplace_back（i，j，k）; 
 
 return voxels; 
} 
  

这将依赖于以下基础结构代码：

  struct Point3 {
 Point3（int，int，int）{} 
}; 
 
 struct int_generator {
 int_generator（int v）
：_v（v）
 {} 
 
 int operator * 
 return _v; 
} 
 
 int_generator& operator ++（）{
 ++ _ v; 
 return * this; 
} 
 
 bool operator！=（const int_generator& rhs）const {
 return _v！= rhs._v; 
} 
 
 private：
 int _v; 
}; 
 
 struct axis_limits：std :: tuple< int，int> 
 {
 using std :: tuple< int，int> :: tuple; 
 int_generator begin（）const {
 return std :: get< 0>（* this）; 
} 
 
 int_generator end（）const {
 return std :: get< 1>（* this）; 
} 
}; 
 
 constexpr int lower（const axis_limits& t）
 {
 return std :: get< 0> 
} 
 
 constexpr int upper（const axis_limits& t）
 {
 return std :: get& 
} 
 
 int_generator begin（const axis_limits& t）
 {
 return std :: get< 0> 
} 
 
 int_generator end（const axis_limits& t）
 {
 return std :: get< 1& 
} 
 
 constexpr int volume（const axis_limits& x，const axis_limits& y，const axis_limits& z）
 {
 return（upper（x） -  lower x））
 *（upper（y） -  lower（y））
 *（upper（z） -  lower（z））; 
} 
  

Is there a nicer way to generate a list of points like than this? Libraries wise I'm open to any Eigen based method.

auto it = voxels.begin();

for(auto i = -180; i < 90; i++) {
    for(auto j = -80; j < 70; j++) {
        for(auto k = 20; k < 460; k++) {
            *it = (Point3(i,j,k));
            it++;
        }
    }
}

解决方案

There's an immediate way to improve performance, by reserving enough space in the vector before you fill it with values.

There are many 'nicer' ways of doing it depending on what you think is nice.

Here's one way:

std::vector<Point3> populate()
{
    // (arguable) maintainability benefit
    constexpr auto I = axis_limits(-180, 90);
    constexpr auto J = axis_limits(-80, 70);
    constexpr auto K = axis_limits(20, 460);

    // pre-reserve the space
    std::vector<Point3> voxels;
    voxels.reserve(volume(I, J, K));

    // although it looks like it might be more work for the compiler, it gets optimised
    // there is no loss of performance
    for(i : I)
        for(j : J)
            for(k : J)
                voxels.emplace_back(i, j, k);

    return voxels;
}

Which will rely on the following infrastructure code:

struct Point3 {
    Point3(int, int, int) {}
};

struct int_generator {
    int_generator(int v)
    : _v(v)
    {}

    int operator*() const {
        return _v;
    }

    int_generator& operator++() {
        ++_v;
        return *this;
    }

    bool operator!=(const int_generator& rhs) const {
        return _v != rhs._v;
    }

private:
    int _v;
};

struct axis_limits : std::tuple<int, int>
{
    using std::tuple<int, int>::tuple;
    int_generator begin() const {
        return std::get<0>(*this);
    }

    int_generator end() const {
        return std::get<1>(*this);
    }
};

constexpr int lower(const axis_limits& t)
{
    return std::get<0>(t);
}

constexpr int upper(const axis_limits& t)
{
    return std::get<1>(t);
}

int_generator begin(const axis_limits& t)
{
    return std::get<0>(t);
}

int_generator end(const axis_limits& t)
{
    return std::get<1>(t);
}

constexpr int volume(const axis_limits& x, const axis_limits& y, const axis_limits& z)
{
    return (upper(x) - lower(x))
    * (upper(y) - lower(y))
    * (upper(z) - lower(z));
}

这篇关于c ++生成（xyz）范围内的点的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！