/shared/development/google_code/rssoft/libccsoft/lib/CC_SequentialDecodingInternal.h

Go to the documentation of this file.

/*
 Copyright 2013 Edouard Griffiths <f4exb at free dot fr>

 This file is part of CCSoft. A Convolutional Codes Soft Decoding library

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Boston, MA  02110-1301  USA

 Convolutional soft-decision sequential decoder generic (virtual) class
 Based on node+edge combination in the code tree

 */
#ifndef __CC_SEQUENTIAL_DECODING_INERNAL_H__
#define __CC_SEQUENTIAL_DECODING_INERNAL_H__

#include "CC_TreeNodeEdge.h"
#include "CC_ReliabilityMatrix.h"
#include "CC_TreeGraphviz.h"

#include <cmath>
#include <algorithm>
#include <iostream>



namespace ccsoft
{

template<typename T_Register, typename T_IOSymbol, typename T_Tag>
class CC_SequentialDecodingInternal
{
public:
        CC_SequentialDecodingInternal() :
        root_node(0)
        {}

        virtual ~CC_SequentialDecodingInternal()
        {
        if (root_node)
        {
            delete root_node;
            root_node = 0;
        }
        }

    void reset()
    {
        if (root_node)
        {
            delete root_node;
            root_node = 0;
        }
    }

protected:
    float log2(float x)
    {
        return log(x)/log(2.0);
    }

    void init_root()
    {
        root_node = new CC_TreeNodeEdge<T_IOSymbol, T_Register, T_Tag>(0, 0, 0, 0.0, 0.0, -1);
    }

    virtual void visit_node_forward(CC_TreeNodeEdge<T_IOSymbol, T_Register, T_Tag>* node, const CC_ReliabilityMatrix& relmat) = 0;

    void back_track(CC_TreeNodeEdge<T_IOSymbol, T_Register, T_Tag>* node_edge, std::vector<T_IOSymbol>& decoded_message, bool mark_nodes = false)
    {
        std::vector<T_IOSymbol> reversed_message;
        CC_TreeNodeEdge<T_IOSymbol, T_Register, T_Tag> *cur_node_edge = node_edge;
        CC_TreeNodeEdge<T_IOSymbol, T_Register, T_Tag> *incoming_node_edge;

        reversed_message.push_back(cur_node_edge->get_in_symbol());

        while (incoming_node_edge = (cur_node_edge->get_incoming_node_edge()))
        {
            cur_node_edge->set_on_final_path(mark_nodes);

            if (incoming_node_edge->get_depth() >= 0) // don't take root node
            {
                reversed_message.push_back(incoming_node_edge->get_in_symbol());
            }

            cur_node_edge = incoming_node_edge;
        }

        decoded_message.resize(reversed_message.size());
        std::reverse_copy(reversed_message.begin(), reversed_message.end(), decoded_message.begin());
    }

    void print_dot_internal(std::ostream& os)
    {
        CC_TreeGraphviz<T_IOSymbol, T_Register, T_Tag>::create_dot(root_node, os);
    }
    
    CC_TreeNodeEdge<T_IOSymbol, T_Register, T_Tag> *root_node; 
};


} // namespace ccsoft


#endif // __CC_SEQUENTIAL_DECODING_INERNAL_H__