edu.cmu.sphinx.result.Edge Maven / Gradle / Ivy
The newest version!
/*
* Copyright 1999-2002 Carnegie Mellon University.
* Portions Copyright 2002 Sun Microsystems, Inc.
* Portions Copyright 2002 Mitsubishi Electric Research Laboratories.
* All Rights Reserved. Use is subject to license terms.
*
* See the file "license.terms" for information on usage and
* redistribution of this file, and for a DISCLAIMER OF ALL
* WARRANTIES.
*
*/
package edu.cmu.sphinx.result;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;
/** Edges are part of Lattices. They connect Nodes, and contain the score associated with that sequence. */
public class Edge {
protected double acousticScore;
protected double lmScore;
protected final Node fromNode;
protected final Node toNode;
/**
* Create an Edge from fromNode to toNode with acoustic and Language Model scores.
*
* @param fromNode from node
* @param toNode to node
* @param acousticScore acoustic score
* @param lmScore langauge model score
*/
protected Edge(Node fromNode, Node toNode,
double acousticScore, double lmScore) {
this.acousticScore = acousticScore;
this.lmScore = lmScore;
this.fromNode = fromNode;
this.toNode = toNode;
}
@Override
public String toString() {
return "Edge(" + fromNode + "-->" + toNode + '[' + acousticScore
+ ',' + lmScore + "])";
}
/**
* Internal routine used when creating a Lattice from a .LAT file
*
* @param lattice
* @param tokens
*/
static void load(Lattice lattice, StringTokenizer tokens) {
String from = tokens.nextToken();
String to = tokens.nextToken();
double aScore = Double.parseDouble(tokens.nextToken());
double lmScore = Double.parseDouble(tokens.nextToken());
Node fromNode = lattice.getNode(from);
if (fromNode == null) {
throw new Error("Edge fromNode \"" + from + "\" does not exist");
}
Node toNode = lattice.getNode(to);
if (toNode == null) {
throw new Error("Edge toNode \"" + to + "\" does not exist");
}
lattice.addEdge(fromNode, toNode, aScore, lmScore);
}
/**
* Internal routine used when dumping a Lattice as a .LAT file
*
* @param f
* @throws IOException
*/
void dump(PrintWriter f) throws IOException {
f.println("edge: " + fromNode.getId() + ' ' + toNode.getId() + ' '
+ acousticScore + ' ' + lmScore);
}
/**
* Internal routine used when dumping a Lattice as an AiSee file
*
* @param f
* @throws IOException
*/
void dumpAISee(FileWriter f) throws IOException {
f.write("edge: { sourcename: \"" + fromNode.getId()
+ "\" targetname: \"" + toNode.getId()
+ "\" label: \"" + acousticScore + ',' + lmScore + "\" }\n");
}
/**
* Internal routine used when dumping a Lattice as an Graphviz file
*
* @param f file writer
* @throws IOException if error occured
*/
public void dumpDot(FileWriter f) throws IOException {
String label = "" + acousticScore + "," + lmScore;
f.write("\tnode" + fromNode.getId() + " -> node" + toNode.getId()
+ " [ label=\"" + label + "\" ]\n");
}
/**
* Get the acoustic score associated with an Edge. This is the acoustic
* score of the word that this edge is transitioning to, that is, the word
* represented by the node returned by the getToNode() method.
*
* @return the acoustic score of the word this edge is transitioning to
*/
public double getAcousticScore() {
return acousticScore;
}
/**
* Get the language model score associated with an Edge
*
* @return the score
*/
public double getLMScore() {
return lmScore;
}
/**
* Get the "from" Node associated with an Edge
*
* @return the Node
*/
public Node getFromNode() {
return fromNode;
}
/**
* Get the "to" Node associated with an Edge
*
* @return the Node
*/
public Node getToNode() {
return toNode;
}
/**
* Sets the acoustic score
*
* @param v the acoustic score.
*/
public void setAcousticScore(double v) {
acousticScore = v;
}
/**
* Sets the language model score
*
* @param v the lm score.
*/
public void setLMScore(double v) {
lmScore = v;
}
/**
* Returns true if the given edge is equivalent to this edge. Two edges are equivalent only if they have their
* 'fromNode' and 'toNode' are equivalent, and that their acoustic and language scores are the same.
*
* @param other the Edge to compare this Edge against
* @return true if the Edges are equivalent; false otherwise
*/
public boolean isEquivalent(Edge other) {
/*
* TODO: Figure out why there would be minute differences
* in the acousticScore. Therefore, the equality of the acoustic
* score is judge based on whether the difference is bigger than 1.
*/
double diff = Math.abs(acousticScore) * 0.00001;
return ((Math.abs(acousticScore - other.getAcousticScore()) <= diff &&
lmScore == other.getLMScore()) &&
(fromNode.isEquivalent(other.getFromNode()) &&
toNode.isEquivalent(other.getToNode())));
}
}