forest_handler.h

Go to the documentation of this file.

// Copyright (c) 2020, the GRAPHGEN contributors, as
// shown by the AUTHORS file. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
 
#ifndef GRAPHGEN_FOREST_HANDLER_H_
#define GRAPHGEN_FOREST_HANDLER_H_
 
#include "output_generator.h"
 
 
DEFINE_ENUM_CLASS_FLAGS(ForestHandlerFlags,
    CENTER_LINES = 1, 
    FIRST_LINE   = 2, 
    LAST_LINE    = 4, 
    SINGLE_LINE  = 8, 
)
 
 
class ForestHandler {
public:
    std::map<ForestHandlerFlags, LineForestHandler> f_;
    std::map<ForestHandlerFlags, std::string> names = {
                                                         {ForestHandlerFlags::CENTER_LINES, "center"},
                                                         {ForestHandlerFlags::FIRST_LINE  , "first"},
                                                         {ForestHandlerFlags::LAST_LINE   , "last"},
                                                         {ForestHandlerFlags::SINGLE_LINE , "single"}
                                                       };
    std::map<ForestHandlerFlags, std::string> prefixs = {
                                                         {ForestHandlerFlags::CENTER_LINES, "cl"},
                                                         {ForestHandlerFlags::FIRST_LINE  , "fl"},
                                                         {ForestHandlerFlags::LAST_LINE   , "ll"},
                                                         {ForestHandlerFlags::SINGLE_LINE , "sl"}
                                                       };
public:
 
    ForestHandler(const BinaryDrag<conact>& bd,
        const pixel_set& ps,
        ForestHandlerFlags flag = ForestHandlerFlags::CENTER_LINES | ForestHandlerFlags::FIRST_LINE)
    {
        // Center lines forest generation
        if (ForestHandlerFlags::CENTER_LINES & flag) {
            f_[ForestHandlerFlags::CENTER_LINES] = LineForestHandler(bd, ps);
        }
 
        // First line forest generation
        if (ForestHandlerFlags::FIRST_LINE & flag) {
            constraints first_line_constr;
            for (const auto& p : ps) {
                if (p.GetDy() < 0)
                    first_line_constr[p.name_] = 0;
            }
            f_[ForestHandlerFlags::FIRST_LINE] = LineForestHandler(bd, ps, first_line_constr);
        }
        // Last line forest generation
        if (ForestHandlerFlags::LAST_LINE & flag) {
            constraints last_line_constr;
            for (const auto& p : ps) {
                if (p.GetDy() > 0)
                    last_line_constr[p.name_] = 0;
            }
            f_[ForestHandlerFlags::LAST_LINE] = LineForestHandler(bd, ps, last_line_constr);
        }
        // Single line forest generation
        if (ForestHandlerFlags::SINGLE_LINE & flag) {
            constraints single_line_constr;
            for (const auto& p : ps) {
                if (p.GetDy() != 0)
                    single_line_constr[p.name_] = 0;
            }
            f_[ForestHandlerFlags::SINGLE_LINE] = LineForestHandler(bd, ps, single_line_constr);
        }
    }
 
    void DrawOnFile(const std::string& prefix, DrawDagFlags flags = DrawDagFlags::NONE)
    {
        for (auto& x : f_) {
            DrawForestOnFile(prefix + "_" + names[x.first], x.second, flags);
        }
    }
 
    void GenerateCode(BEFORE_AFTER_FUNC(before_main)       = BeforeMainShiftOne,
                      BEFORE_AFTER_FUNC(after_main)        = DefaultEmptyFunc,
                      BEFORE_AFTER_FUNC(before_end)        = BeforeEnd,
                      BEFORE_AFTER_FUNC(after_end)         = AfterEnd,
                      BEFORE_AFTER_FUNC(after_end_no_loop) = AfterEndNoLoop,
                      int flags = 0 /* no flags available right now */)
    {
        size_t last_id = 0;
        for (const auto& i : f_) {
            std::filesystem::path filepath = conf.GetForestCodePath(names[i.first] + "_line");
            std::ofstream os(filepath);
            if (!os) {
                std::cout << "Something went wrong during the generation of " << conf.algorithm_name_ << "forest code\n";
                return;
            }
            if (i.first != ForestHandlerFlags::CENTER_LINES) {
                last_id = GenerateLineForestCode(os, i.second, prefixs[i.first] + "_", last_id, before_main, after_main, before_end, after_end_no_loop);
                os << prefixs[i.first] + "_" << ":;\n";
            }
            else {
                last_id = GenerateLineForestCode(os, i.second, prefixs[i.first] + "_", last_id, before_main, after_main, before_end, after_end);
            }
        }
    }
 
    void Compress(DragCompressorFlags flags = DragCompressorFlags::PRINT_STATUS_BAR | DragCompressorFlags::IGNORE_LEAVES, int iterations = - 1) {
       for (auto& x : f_) {
           DragCompressor(x.second, iterations, flags);
       }
    }
 
    LineForestHandler& GetLineForestHandler(ForestHandlerFlags forest_id) {
        return f_.at(forest_id);
    }
};
 
 
#endif // FOREST_HANDLER_H_