source: cpp/frams/_demos/neuro_layout_test.cpp @ 976

// This file is a part of Framsticks SDK.  http://www.framsticks.com/
// Copyright (C) 1999-2020  Maciej Komosinski and Szymon Ulatowski.
// See LICENSE.txt for details.

#include <common/virtfile/stdiofile.h>
#include <frams/util/sstringutils.h>
#include <frams/genetics/preconfigured.h>
#include <frams/model/model.h>
#include <common/loggers/loggertostdout.h>
#include <frams/canvas/nn_layout_model.h>

#include <algorithm>

/**
 @file
 Sample code: Neuron layout tester

 Hint: Use loader_test to extract genotypes from Framsticks *.gen files:
 loader_test "data/walking.gen" "Walking Lizard" | neuro_layout_test -
*/

// stl is fun? ;-) ForwardIterator implementation for element coordinates (required by min_element/max_element)
template <int MEMBER> struct NNIter : public std::iterator<std::forward_iterator_tag, int> //MEMBER: 0..3=x/y/w/h
{
        NNLayoutState *nn; int index;
        NNIter() {}
        NNIter(NNLayoutState *_nn, int _index) :nn(_nn), index(_index) {}
        int operator*() { return nn->GetXYWH(index)[MEMBER]; }
        NNIter& operator++() { index++; return *this; }
        bool operator!=(const NNIter& it) { return index != it.index; }
        bool operator==(const NNIter& it) { return index == it.index; }

        static NNIter begin(NNLayoutState *_nn) { return NNIter(_nn, 0); }
        static NNIter end(NNLayoutState *_nn) { return NNIter(_nn, _nn->GetElements()); }
};

class Screen
{
        int min_x, max_x, min_y, max_y, scale_x, scale_y;
        int rows, columns;
        char* screen;

public:

        Screen(int _min_x, int _max_x, int _min_y, int _max_y, int _scale_x, int _scale_y)
                :min_x(_min_x), max_x(_max_x), min_y(_min_y), max_y(_max_y), scale_x(_scale_x), scale_y(_scale_y)
        {
                columns = (max_x - min_x + scale_x - 1) / scale_x;
                rows = (max_y - min_y + scale_y - 1) / scale_y;
                screen = new char[rows * columns];
                memset(screen, ' ', rows * columns);
        }

        ~Screen()
        {
                delete[] screen;
        }

        void put(int x, int y, const char *str)
        {
                x = (x - min_x) / scale_x;
                y = (y - min_y) / scale_y;
                if (x < 0) return;
                if (y < 0) return;
                if (y >= rows) return;
                for (; *str; str++, x++)
                {
                        if (x >= columns) return;
                        screen[columns * y + x] = *str;
                }
        }

        void print()
        {
                for (int y = 0; y < rows; y++)
                {
                        fwrite(&screen[columns * y], 1, columns, stdout);
                        printf("\n");
                }
        }
};

int main(int argc, char*argv[])
{
        LoggerToStdout messages_to_stdout(LoggerBase::Enable);
        PreconfiguredGenetics genetics;

        if (argc <= 1)
        {
                puts("Parameters:\n"
                        " 1. Genotype (or - character indicating the genotype will be read from stdin)\n"
                        " 2. (Optional) layout type (the only useful layout is 2, which is the default, see nn_simple_layout.cpp");
                return 10;
        }
        SString gen(argv[1]);
        if (!strcmp(gen.c_str(), "-"))
        {
                gen = 0;
                StdioFILEDontClose in(stdin);
                loadSString(&in, gen);
        }
        int layout_type = 2;
        if (argc > 2) layout_type = atol(argv[2]);
        Geno g(gen);
        if (!g.isValid()) { puts("invalid genotype"); return 5; }
        Model m(g, Model::SHAPE_UNKNOWN);
        if (!m.getNeuroCount()) { puts("no neural network"); return 1; }
        printf("%d neurons,", m.getNeuroCount());

        NNLayoutState_Model nn_layout(&m);
        struct NNLayoutFunction &nnfun = nn_layout_functions[layout_type];
        printf(" using layout type=%d (%s)\n", layout_type, nnfun.name);
        nnfun.doLayout(&nn_layout);

        for (int i = 0; i < nn_layout.GetElements(); i++)
        {
                int *xywh = nn_layout.GetXYWH(i);
                printf("#%-3d %s\t%d,%d\t%dx%d\n", i, m.getNeuro(i)->getClassName().c_str(),
                        xywh[0], xywh[1], xywh[2], xywh[3]);
        }

        Screen screen(*std::min_element(NNIter<0>::begin(&nn_layout), NNIter<0>::end(&nn_layout)) - 30,
                *std::max_element(NNIter<0>::begin(&nn_layout), NNIter<0>::end(&nn_layout)) + 70,
                *std::min_element(NNIter<1>::begin(&nn_layout), NNIter<1>::end(&nn_layout)),
                *std::max_element(NNIter<1>::begin(&nn_layout), NNIter<1>::end(&nn_layout)) + 30,
                10, 35);

        printf("===========================================\n");
        for (int i = 0; i < nn_layout.GetElements(); i++)
        {
                int *xywh = nn_layout.GetXYWH(i);
                SString label = SString::sprintf("%d:%s", i, m.getNeuro(i)->getClassName().c_str());
                screen.put(xywh[0], xywh[1], label.c_str());
        }
        screen.print();
        printf("===========================================\n");

}