(六)pcl-common篇-random.h

UniformGenerator与NormalGenerator
随机点云包括均匀分布和高斯分布，并且可以设置对应的参数。

#include <pcl/point_types.h>
#include <pcl/io/pcd_io.h>
#include <pcl/common/generate.h>
#include <pcl/common/random.h>
#include <pcl/console/print.h>
#include <pcl/console/parse.h>
#include <pcl/console/time.h>

using namespace std;
using namespace pcl;
using namespace pcl::io;
using namespace pcl::common;
using namespace pcl::console;

typedef PointXYZ PointType;
typedef PointCloud<PointXYZ> Cloud;
typedef const Cloud::ConstPtr ConstCloudPtr;

std::string default_distribution = "uniform";
float default_xmin = 0.0f;
float default_xmax = 1.0f;
float default_xmean = 0.0f;
float default_xstddev = 1.0f;
float default_ymin = 0.0f;
float default_ymax = 1.0f;
float default_ymean = 0.0f;
float default_ystddev = 1.0f;
float default_zmin = 0.0f;
float default_zmax = 1.0f;
float default_zmean = 0.0f;
float default_zstddev = 1.0f;
int default_size = 10000;

void
printHelp(int, char** argv)
{
    print_error("Syntax is: %s output.pcd <options>\n", argv[0]);
    print_info("  where options are:\n");
    print_info("                     -distribution X = the distribution to be used (options: uniform / normal) (default: ");
    print_value("%s", default_distribution.c_str()); print_info(")\n");
    print_info("                     -size X = number of points in cloud (default: ");
    print_value("%d", default_size); print_info(")\n");
    print_info("                Options for uniform distribution:\n");
    print_info("                     -[x|y|z]min X = minimum for the [x|y|z] dimension (defaults: ");
    print_value("%f, %f, %f", default_xmin, default_ymin, default_zmin); print_info(")\n");
    print_info("                     -[x|y|z]max X = maximum for the [x|y|z] dimension (defaults: ");
    print_value("%f, %f, %f", default_xmax, default_ymax, default_zmax); print_info(")\n");
    print_info("                Options for normal distribution:\n");
    print_info("                     -[x|y|z]mean X = mean for the [x|y|z] dimension (defaults: ");
    print_value("%f, %f, %f", default_xmean, default_ymean, default_zmean); print_info(")\n");
    print_info("                     -[x|y|z]stddev X = standard deviation for the [x|y|z] dimension (defaults: ");
    print_value("%f, %f, %f", default_xstddev, default_ystddev, default_zstddev); print_info(")\n");
}

void
saveCloud(const std::string& filename, const Cloud& output)
{
    TicToc tt;
    tt.tic();

    print_highlight("Saving "); print_value("%s ", filename.c_str());

    PCDWriter w;
    w.writeBinaryCompressed(filename, output);

    print_info("[done, "); print_value("%g", tt.toc()); print_info(" ms : "); print_value("%d", output.width * output.height); print_info(" points]\n");
}

/* ---[ */
int
main(int argc, char** argv)
{
    //if (find_switch(argc, argv, "-h"))
    //{
    //    printHelp(argc, argv);
    //    return (0);
    //}

    //print_info("Generate a random point cloud. For more information, use: %s -h\n", argv[0]);

    //if (argc < 2)
    //{
    //    printHelp(argc, argv);
    //    return (-1);
    //}

    // Command line parsing
    std::string distribution = default_distribution;
    float xmin = default_xmin;
    float xmax = default_xmax;
    float xmean = default_xmean;
    float xstddev = default_xstddev;
    float ymin = default_ymin;
    float ymax = default_ymax;
    float ymean = default_ymean;
    float ystddev = default_ystddev;
    float zmin = default_zmin;
    float zmax = default_zmax;
    float zmean = default_zmean;
    float zstddev = default_zstddev;
    int size = default_size;
    parse_argument(argc, argv, "-distribution", distribution);
    parse_argument(argc, argv, "-xmin", xmin);
    parse_argument(argc, argv, "-xmax", xmax);
    parse_argument(argc, argv, "-xmean", xmean);
    parse_argument(argc, argv, "-xstddev", xstddev);
    parse_argument(argc, argv, "-ymin", ymin);
    parse_argument(argc, argv, "-ymax", ymax);
    parse_argument(argc, argv, "-ymean", ymean);
    parse_argument(argc, argv, "-ystddev", ystddev);
    parse_argument(argc, argv, "-zmin", zmin);
    parse_argument(argc, argv, "-zmax", zmax);
    parse_argument(argc, argv, "-zmean", zmean);
    parse_argument(argc, argv, "-zstddev", zstddev);
    parse_argument(argc, argv, "-size", size);

    // Perform the feature estimation
    Cloud output;

    if (distribution == "uniform")
    {
        CloudGenerator<pcl::PointXYZ, UniformGenerator<float> > generator;
        uint32_t seed = static_cast<uint32_t> (time(NULL));
        UniformGenerator<float>::Parameters x_params(xmin, xmax, seed++);
        generator.setParametersForX(x_params);
        UniformGenerator<float>::Parameters y_params(ymin, ymax, seed++);
        generator.setParametersForY(y_params);
        UniformGenerator<float>::Parameters z_params(zmin, zmax, seed++);
        generator.setParametersForZ(z_params);

        generator.fill(size, 1, output);
    }
    else if (distribution == "normal")
    {
        CloudGenerator<pcl::PointXYZ, NormalGenerator<float> > generator;
        uint32_t seed = static_cast<uint32_t> (time(NULL));
        NormalGenerator<float>::Parameters x_params(xmean, xstddev, seed++);
        generator.setParametersForX(x_params);
        NormalGenerator<float>::Parameters y_params(ymean, ystddev, seed++);
        generator.setParametersForY(y_params);
        NormalGenerator<float>::Parameters z_params(zmean, zstddev, seed++);
        generator.setParametersForZ(z_params);

        generator.fill(size, 1, output);
    }
    else
    {
        PCL_ERROR("%s is not a valid generator! Quitting!\n", distribution.c_str());
        return (0);
    }

    system("pause");
    return 0;
}

参考文章：
https://blog.csdn.net/com1098247427/article/details/120696577
http://pointclouds.org/documentation/random_8h.html
http://pointclouds.org/documentation/random_8h_source.html