Форум атеистов Рунета

#include "bitmap_image.hpp"
#include <cstdio>
#include <cstdlib>
#include <fstream>

const int MIN_POINT = 10;
const int MAX_POINT = 40;
int X_factor = 0;
int Y_factor = 0;

image_drawer *pdraw = NULL;
int n_points = 0;
int64_t out_threshold_top = 0;
int64_t out_threshold_low = 0;
int min_val = 100000;
int max_val = 0;
int min_threshold = 0;
int max_threshold = 0;
const int MAX_VALUE = 100000;

int64_t num_lived = 0;
int64_t num_dead = 0;


void step(int x, int y, int max, int min);

void step1(int x, int y, int max, int min)
{
    int x1 = x + rand() % 3 - 1; ///< add random from -1 to 1
    if (x1 >= 0) {
        int ky = y * Y_factor;
        pdraw->line_segment(x * X_factor, ky, x1 * X_factor, ky);
        /// top threshold trigger
        if (max == MAX_VALUE) {
            if (x1 < min) {
                min = x1;
                if (min <= min_threshold && min > 0) {
                    min = -MAX_VALUE; ///< set low trigger after top
                    ++out_threshold_low;
                }
            }
        }
        else if (max <= x1) {
            max = x1;
            if (max >= max_threshold) {
                ++out_threshold_top;
                max = MAX_VALUE; ///< set top threshold trigger
            }
        }
        if (max_val < x1)
            max_val = x1;
        if (min_val > x1)
            min_val = x1;
        step(x1, y, max, min);
    }
    else
        ++num_dead;
}

void step(int x, int y, int max, int min)
{
    if (--y < 0) {
        ++num_lived;
        return; ///< done
    }
    step1(x, y, max, min);
    step1(x, y, max, min);
}

int main(int argc, char *argv[])
{
    int n_seed = 0;
    min_threshold = 0;
    max_threshold = 0;
    enum {FIND_MAX, COUNT, UNKNOWN} mode = UNKNOWN;
    const char* path = "output.bmp";
    /// ARGS
    {
        int pos_points   = 1;
        int pos_seed     = 2;
        int pos_x_factor = 3;
        int pos_y_factor = 4;
        int pos_mode     = 5;
        int pos_path     = 6;
        if (argc > pos_mode) {
            n_points = std::atoi(argv[pos_points]);
            n_seed = std::atoi(argv[pos_seed]);
            X_factor = std::atoi(argv[pos_x_factor]);
            Y_factor = std::atoi(argv[pos_y_factor]);
            std::string sMode(argv[pos_mode]);
            if (sMode == std::string("-m") || sMode == std::string("--max")) {
                mode = FIND_MAX;
            }
            else if (sMode == std::string("-c") || sMode == std::string("--count")) {
                min_threshold = std::atoi(argv[pos_mode + 1]);
                max_threshold = std::atoi(argv[pos_mode + 2]);
                if (min_threshold > 0 && max_threshold > 0) {
                    mode = COUNT;
                }
                pos_path += 2;
            }
        }
        if (n_points < MIN_POINT || n_points > MAX_POINT
                || mode == UNKNOWN || n_seed == 0
                || X_factor == 0   || Y_factor == 0
                || (argc != pos_path && argc != pos_path + 1)) {
            std::cerr << "using:\n"
                      << argv[0] << " N S Xkof Ykof mode path"
                      << "\nN\t- integer number of points from " << MIN_POINT << " to " << MAX_POINT
                      << "\nS\t- integer random seed != 0"
                      << "\nXkof\t- output integer X-factor >= 1"
                      << "\nYkof\t- output integer Y-factor >= 1"
                      << "\nmode:"
                      << "\n\t-m\t- detect maximum"
                      << "\n    or"
                      << "\n\t-c LOW HIGH\t - set low and hight threshold"
                      << "\npath\t- path to output bmp-file. Default output.bmp\n";
            return -1;
        }
        if (argc == pos_path + 1)
            path = argv[pos_path];
    }
    /// PROCESS
    bitmap_image image(n_points  * X_factor, n_points * Y_factor);
    image.set_all_channels(255,255,255); ///< background to white

    image_drawer draw(image);
    pdraw = &draw;
    draw.pen_width(1);
    draw.pen_color(0,0,0); ///< black

    srand(n_seed); ///< initialize random seed

    std::cout << "PARAMS: points=" << n_points << ", random seed=" << n_seed;
    if (mode == COUNT) {
        std::cout << ", LOW=" << min_threshold << ", HIGH=" << max_threshold;
    }
    std::cout << std::endl;
    step(0, n_points, 0, MAX_VALUE);
    std::cout << "RESULTS: lived=" << num_lived << ", dead=" << num_dead
              << ", min=" << min_val << ", max=" << max_val;
    if (mode == FIND_MAX) {
        std::cout << std::endl;
        return 0;
    }
    std::cout << ",\n\tbeyond the upper threshold =" << out_threshold_top
              << ",\n\tthen beyond the lower threshold =" << out_threshold_low
              << std::endl;

    image.save_image(path);
    std::cout << "write successfully\n";
    return 0;
}