// fstext/remap-leaves.h

// Copyright 2009-2011 Microsoft Corporation

// See ../../COPYING for clarification regarding multiple authors

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED

// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,

// MERCHANTABLITY OR NON-INFRINGEMENT.

// See the Apache 2 License for the specific language governing permissions and

// limitations under the License.

#ifndef KALDI_FSTEXT_REMAP_LEAVES_H_

#define KALDI_FSTEXT_REMAP_LEAVES_H_

/*

Things in this header relate to transforming an FST whose symbols on the

left are sequences of phones (as created in context-fst.h) into a

representation where the individual leaves are on arcs

(not sequences of leaves). We also introduce a mapping on the leaves, which

is intended to allow us to reconstruct the phone sequence (basically, if

different phones/HMM-positions share a leaf then we introduce new leaf-ids).

The way that this is intended be used is: create C as a special FST as in

context-fst.h, create C o L o G (somehow), use functions declared in this

header to create essentially H o C o L o G (with remapping but with no

self-loops), and then afterwards determinize and factor the result. Then

we will create a wrapper class that "expands" the factored form on the

fly into a full representation of H o C o L o G with self-loops included

and possibly with different leaf-ids to disambiguate self-loops from

forward transitions. Note also that this wrapper class may also need

to expand leaf-ids that actually represent HMMs rather than single states,

as this is a possibility too.

*/

#include <fst/fstlib.h>

#include <fst/fst-decl.h>

#include "fstext/context-fst.h"

#include "itf/context-dep-itf.h"

namespace fst {

//! ContextExpandLeaves transforms the sequences of phones on the input of C,

//! into sequences of states. However it outputs the new symbols as "mangled"

//! state-names that contain sufficient information to obtain the phone ids.

//! ctx_dep [in] object that

template<typename L>

bool ContextExpandLeaves(const kaldi::ContextDependencyInterface &ctx_dep,

const vector<L> &phones,

const vector<L> &disambig_syms,

const vector<vector<L> > &symbol_map_in,

vector<vector<L> > *symbol_map_out,

vector<L> *aug_to_leaf_out,

vector<L> *aug_to_phone_out);

/// DfsSort sorts the states in an FST in depth-first-search order.

/// May be useful after ExpandSequences. This is equivalent to TopSort

/// for acyclic FSTs but it does apply the DFS order even for FSTs with cycles.

template <class Arc>

void DfsSort(MutableFst<Arc> *fst);

/// The following function doesn't exactly belong here.

/// It creates an FST that transduces the isymbol to its matching osymbols, wherever

/// they share the same string. It's useful for remapping symbol tables.

/// You will have to explicitly specify the Arc template argument when you call this

/// function, e.g. MakeRemapper<StdArc>(isyms, osyms).

template<class Arc>

VectorFst<Arc> *MakeRemapper(const SymbolTable *isymbols, const SymbolTable *osymbols);

} // namespace fst

#include "remap-leaves-inl.h"

#endif