You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@opennlp.apache.org by bg...@apache.org on 2012/09/20 00:01:03 UTC
svn commit: r1387791 - in
/opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code: ./
NL2Obj.java NL2ObjCreateAssign.java ObjectControlOp.java ObjectPhrase.java
ObjectPhraseListForSentence.java
Author: bgalitsky
Date: Wed Sep 19 22:01:02 2012
New Revision: 1387791
URL: http://svn.apache.org/viewvc?rev=1387791&view=rev
Log:
OPENNLP-538
Another illustration for similarity component: converting natural language task into Java code
Added:
opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/
opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/NL2Obj.java
opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/NL2ObjCreateAssign.java
opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectControlOp.java
opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectPhrase.java
opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectPhraseListForSentence.java
Added: opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/NL2Obj.java
URL: http://svn.apache.org/viewvc/opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/NL2Obj.java?rev=1387791&view=auto
==============================================================================
--- opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/NL2Obj.java (added)
+++ opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/NL2Obj.java Wed Sep 19 22:01:02 2012
@@ -0,0 +1,273 @@
+package opennlp.tools.nl2code;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import opennlp.tools.textsimilarity.ParseTreeChunk;
+import opennlp.tools.textsimilarity.ParseTreeChunkListScorer;
+import opennlp.tools.textsimilarity.TextSimilarityBagOfWords;
+import opennlp.tools.textsimilarity.chunker2matcher.ParserChunker2MatcherProcessor;
+
+public class NL2Obj {
+ ObjectControlOp prevOp;
+
+ public NL2Obj() {
+ prevOp = new ObjectControlOp();
+ prevOp.setOperatorIf("");
+ prevOp.setOperatorFor("");
+ }
+
+ public static String[] epistemicStatesList = new String[] {
+ "select", "verify", "find", "start", "stop", "go", "check"
+ };
+
+ public static String[] instantiatedStatesList = new String[] {
+ "get", "set"
+ };
+ public static String[] propStatesList = new String[] {
+ "otherwise",
+ };
+
+ protected ParserChunker2MatcherProcessor parser;
+ private TextSimilarityBagOfWords parserBOW = new TextSimilarityBagOfWords();
+ private ParseTreeChunkListScorer parseTreeChunkListScorer = new ParseTreeChunkListScorer();
+
+ public ObjectPhraseListForSentence convertSentenceToControlObjectPhrase(String sentence){
+
+ List<ObjectPhrase> oPhrases = new ArrayList<ObjectPhrase>();
+ parser = ParserChunker2MatcherProcessor.getInstance();
+ List<List<ParseTreeChunk>> lingPhrases =
+ parser.formGroupedPhrasesFromChunksForSentence(sentence);
+
+ ObjectControlOp op = extractControlPart(lingPhrases, prevOp);
+ prevOp = op;
+
+ //start with verb phrases
+ List<ParseTreeChunk> actionWithObject = lingPhrases.get(1);
+
+ actionWithObject = applyWhichRuleOnVP(actionWithObject);
+ System.out.println("=== "+actionWithObject+" \n extracted op = "+op);
+
+ for(ParseTreeChunk verbChunk: actionWithObject){
+
+ if (verbChunk.getPOSs().get(0).startsWith("VB")){
+ ObjectPhrase oPhrase = new ObjectPhrase();
+ String methodOrControlOp = verbChunk.getLemmas().get(0).toLowerCase();
+ if (!isControlOp(methodOrControlOp)){
+ oPhrase.setMethod(methodOrControlOp);
+ List<String> paramValues = verbChunk.getLemmas(), paramPOSs = verbChunk.getPOSs();
+
+ paramValues.remove(0); paramPOSs.remove(0);
+ // the subject of a verb refers to the object
+ try {
+ String objectCandidatePOS = paramPOSs.get(paramValues.size()-1);
+ if (objectCandidatePOS.startsWith("NN")){
+ oPhrase.setObjectName(paramValues.get(paramValues.size()-1));
+ paramValues.remove(paramValues.size()-1);
+ paramPOSs.remove(paramPOSs.size()-1);
+ } else if (paramPOSs.get(paramValues.size()-2).startsWith("NN")){
+ oPhrase.setObjectName(paramValues.get(paramValues.size()-2));
+ paramValues.remove(paramValues.size()-2);
+ paramPOSs.remove(paramPOSs.size()-2);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ oPhrase.setParamValues(paramValues);
+ oPhrase.setParamChunk(paramValues, paramPOSs);
+
+ // object name/instance
+ if (oPhrase.getObjectName() == null){
+ List<ParseTreeChunk> objectName = lingPhrases.get(0);
+ ParseTreeChunk objNameChunk = objectName.get(0);
+ if ( objNameChunk.getPOSs().get(0).equals("NN")){
+ oPhrase.setObjectName( objNameChunk.getLemmas().get(0));
+ }
+ }
+ } else { // verb = 'verify' attribute prep prep object
+
+ List<String> paramValues = verbChunk.getLemmas(), paramPOSs = verbChunk.getPOSs();
+ paramValues.remove(0); paramPOSs.remove(0); // we dont need 'verify'
+
+ // start with getting right-most noun as object
+ String objectCandidatePOS = paramPOSs.get(paramValues.size()-1);
+ if (objectCandidatePOS.startsWith("NN")){
+ oPhrase.setObjectName(paramValues.get(paramValues.size()-1));
+ paramValues.remove(paramValues.size()-1);
+ paramPOSs.remove(paramPOSs.size()-1);
+ } else if (paramPOSs.get(paramValues.size()-2).startsWith("NN")){
+ oPhrase.setObjectName(paramValues.get(paramValues.size()-2));
+ paramValues.remove(paramValues.size()-2);
+ paramPOSs.remove(paramPOSs.size()-2);
+ }
+ // attempt to find attribute
+ for(int i = paramValues.size()-1; i>=0; i--){
+ if (paramPOSs.get(i).equals("IN") || paramPOSs.get(i).equals("DT"))
+ continue;
+ else if (paramPOSs.get(i).startsWith("NN")||paramPOSs.get(i).startsWith("JJ")||paramPOSs.get(i).startsWith("CD")){
+ oPhrase.setMethod(paramValues.get(i));
+ paramValues = paramValues.subList(0, i-1);
+ paramPOSs = paramPOSs.subList(0, i-1);
+ oPhrase.setParamValues(paramValues);
+ oPhrase.setParamChunk(paramValues, paramPOSs);
+ break;
+ }
+ }
+ }
+ oPhrase.setOrigPhrase(verbChunk);
+ oPhrase.cleanArgs();
+ //if (oPhrase.getMethod()!=null || oPhrase.getObjectName()!=null)
+ oPhrases.add(oPhrase);
+ }
+ }
+
+ ObjectPhraseListForSentence oplfs = new ObjectPhraseListForSentence( oPhrases, op);
+ oplfs.cleanMethodNamesIsAre();
+ oplfs.substituteNullObjectIntoEmptyArg();
+ oplfs.substituteIntoEmptyArgs(); //area.size([]), threshold.([below])
+ oplfs.clearInvalidObject(); //[null.2([])]
+ return oplfs;
+ }
+
+ private boolean isControlOp(String methodOrControlOp) {
+ return Arrays.asList(epistemicStatesList).contains(methodOrControlOp);
+ }
+
+ protected List<ParseTreeChunk> applyWhichRuleOnVP(List<ParseTreeChunk> actionWithObject) {
+ for(String connector: new String[]{ "which", "so"}){
+ for(ParseTreeChunk ch1: actionWithObject)
+ for(ParseTreeChunk ch2: actionWithObject){
+ if ((ch1.getLemmas().get(ch1.getLemmas().size()-1).equals(connector)) &&
+ !ch2.getLemmas().get(ch2.getLemmas().size()-1).equals(connector)){
+ actionWithObject.remove(ch2);
+ actionWithObject.remove(ch1);
+
+ List<String> ch1Tmp = ch1.getLemmas();
+ ch1Tmp.addAll(ch2.getLemmas());
+ ch1.setLemmas(ch1Tmp);
+
+ ch1Tmp = ch1.getPOSs();
+ ch1Tmp.addAll(ch2.getPOSs());
+ ch1.setPOSs(ch1Tmp);
+ actionWithObject.add(ch1);
+ return actionWithObject;
+
+ }
+ }
+ }
+ return actionWithObject;
+ }
+
+ public ObjectControlOp extractControlPart(List<List<ParseTreeChunk>> lingPhrases, ObjectControlOp prevOp){
+ ObjectControlOp op = new ObjectControlOp();
+ List<ParseTreeChunk> parsedSent = lingPhrases.get(4);
+ List<String> lems = parsedSent.get(0).getLemmas();
+ boolean bIfSet=false, bForSet=false;
+ for(int i=0; i<lems.size(); i++){
+ String c=lems.get(i).toLowerCase();
+ if (!bForSet){
+ if ((c.equals("all") || c.equals("each") || c.equals("exists")) && i<lems.size()-1){
+ String loopSubject = lems.get(i+1).toLowerCase();
+ String iterator = "_iterator_";
+ if (loopSubject.endsWith("s"))
+ iterator = loopSubject.substring(0,loopSubject.length()-1 );
+ op.setOperatorFor("for(_data_type "+iterator + ": "+loopSubject+")");
+ bForSet=true;
+ }
+
+ if (c.equals("then") && prevOp.getOperatorIf()!=null && prevOp.getOperatorIf().equals("if")){
+ op.setOperatorFor("then");
+ op.setLinkUp(" if");
+ bForSet=true;
+ }
+
+ if (c.equals("stop")){
+ op.setOperatorFor("return");
+ bForSet=true;
+ }
+ }
+
+ if (!bIfSet){
+ if (c.equals("check") || c.equals("verify") || c.equals("sure") ){
+ op.setOperatorIf("if");
+ bIfSet=true;
+ }
+ if (c.equals("otherwise") && prevOp.getOperatorIf()!=null && prevOp.getOperatorIf().equals("if")){
+ op.setOperatorIf("else");
+ op.setLinkUp("if");
+ bIfSet=true;
+ }
+
+
+ if ((c.equals("so")||c.equals("such")) && lems.get(i+1).toLowerCase().equals("that")){
+ op.setOperatorIf("if");
+ bIfSet=true;
+ }
+
+ if((c.equals("go") && lems.get(i+1).toLowerCase().equals("to")) || c.equals("goto") ){
+ op.setOperatorIf(" break "+lems.get(i+1).toLowerCase()+" _label_ ");
+ bIfSet=true;
+ }
+ }
+ }
+ return op;
+ }
+ /*
+ public ObjectPhrase convertSentenceToControlObjectPhraseSingleObj(String sentence){
+ parser = ParserChunker2MatcherProcessor.getInstance();
+ List<List<ParseTreeChunk>> lingPhrases =
+ parser.formGroupedPhrasesFromChunksForSentence(sentence);
+
+ ObjectControlOp op = extractControlPart(lingPhrases, prevOp);
+ prevOp = op;
+
+ ObjectPhrase oPhrase = new ObjectPhrase();
+ //start with verb phrases
+ List<ParseTreeChunk> actionWithObject = lingPhrases.get(1);
+ ParseTreeChunk verbChunk = actionWithObject.get(0);
+ if (verbChunk.getPOSs().get(0).startsWith("VB")){
+ oPhrase.setMethod(verbChunk.getLemmas().get(0));
+ List<String> paramValues = verbChunk.getLemmas();
+ paramValues.remove(0);
+ // the subject of a verb refers to the object
+ oPhrase.setObjectName(paramValues.get(paramValues.size()-1));
+ paramValues.remove(paramValues.size()-1);
+ oPhrase.setParamValues(paramValues);
+ oPhrase.setOrigPhrase(verbChunk);
+ }
+ // object name/instance
+ if (oPhrase.getObjectName() == null){
+ List<ParseTreeChunk> objectName = lingPhrases.get(0);
+ ParseTreeChunk objNameChunk = objectName.get(0);
+ if ( objNameChunk.getPOSs().get(0).equals("NN")){
+ oPhrase.setObjectName( objNameChunk.getLemmas().get(0));
+ }
+ }
+
+ return oPhrase;
+
+ }
+ */
+
+
+ public static void main(String[] args){
+ String[] text = new String[]{
+ "Randomly select a pixel at an image.",
+ "Find a convex area this pixel belongs, so that all pixels are less than 128", //area->REGION
+ "Check that the border of the selected area has all pixels more than 128",
+ "If the above verification succeeds, stop with positive result",
+ "Otherwise, add all pixels which are less than 128 to the area",
+ "Check that the size of area is below the threshold. ",
+ "Then go to 2",
+ "Otherwise, stop with negative result"
+ };
+
+ NL2Obj compiler = new NL2Obj();
+ for(String sent:text){
+ ObjectPhraseListForSentence opls = compiler.convertSentenceToControlObjectPhrase(sent);
+ System.out.println(sent+"\n"+opls+"\n");
+ }
+
+ }
+}
\ No newline at end of file
Added: opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/NL2ObjCreateAssign.java
URL: http://svn.apache.org/viewvc/opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/NL2ObjCreateAssign.java?rev=1387791&view=auto
==============================================================================
--- opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/NL2ObjCreateAssign.java (added)
+++ opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/NL2ObjCreateAssign.java Wed Sep 19 22:01:02 2012
@@ -0,0 +1,230 @@
+package opennlp.tools.nl2code;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import opennlp.tools.textsimilarity.ParseTreeChunk;
+import opennlp.tools.textsimilarity.chunker2matcher.ParserChunker2MatcherProcessor;
+
+public class NL2ObjCreateAssign extends NL2Obj {
+
+ private boolean classBeingDefined = false;
+ public static String[] declarationStatesList = new String[] {
+ "create", "assign", "set",
+ };
+
+ public static String[] dataTypesList = new String[] {
+ "text", "double", "array",
+ };
+
+ public static String[] arrayElementList = new String[] {
+ "first", "second", "third", "fourth"
+ };
+
+ public static String[] arrayElementListInsdex = new String[] {
+ "0", "1", "2", "3"
+ };
+
+
+ @Override
+ public ObjectPhraseListForSentence convertSentenceToControlObjectPhrase(String sentence){
+ String expression = null;
+ if (sentence.indexOf(":")>-1){
+ expression = sentence.split(":")[1];
+ sentence = sentence.split(":")[0]+".";
+ }
+
+
+ List<ObjectPhrase> oPhrases = new ArrayList<ObjectPhrase>();
+ parser = ParserChunker2MatcherProcessor.getInstance();
+ List<List<ParseTreeChunk>> lingPhrases =
+ parser.formGroupedPhrasesFromChunksForSentence(sentence);
+
+ ObjectControlOp op = extractControlPart(lingPhrases, prevOp);
+ prevOp = op;
+
+ //start with verb phrases
+ List<ParseTreeChunk> actionWithObject = lingPhrases.get(1);
+ actionWithObject.addAll( lingPhrases.get(4));
+
+ System.out.println(" === "+actionWithObject);
+
+ for(ParseTreeChunk verbChunk: actionWithObject){
+ ObjectPhrase oPhrase = new ObjectPhrase();
+
+ List<String> lems = verbChunk.getLemmas();
+ String declarativeAction = verbChunk.getLemmas().get(0).toLowerCase();
+ if (declarativeAction.equals("define")){
+ if (verbChunk.getLemmas().get(1).toLowerCase().equals("class") ||
+ verbChunk.getLemmas().get(2).toLowerCase().equals("class")){
+ // new class
+ String className = verbChunk.getLemmas().get(verbChunk.getLemmas().size()-1).toLowerCase();
+ className = className.substring(0, 1).toUpperCase()+className.substring(1, className.length());
+ op.setOperatorIf("class "+className + "{");
+ op.setOperatorFor("{");
+ classBeingDefined = true;
+ break;
+ }
+ String dataType = verbChunk.getLemmas().get(1).toLowerCase();
+
+ if (classBeingDefined && Arrays.asList(dataTypesList).contains(dataType) && verbChunk.getLemmas().get(2).toLowerCase().equals("attribute")){
+ op.setOperatorFor(dataType + " "+verbChunk.getLemmas().get(verbChunk.getLemmas().size()-1).toLowerCase());
+ classBeingDefined = true;
+ break;
+ }
+ if (Arrays.asList(dataTypesList).contains(dataType) && verbChunk.getLemmas().get(2).toLowerCase().equals("attribute")){
+ op.setOperatorFor(dataType + " "+verbChunk.getLemmas().get(verbChunk.getLemmas().size()-1).toLowerCase());
+ classBeingDefined = true;
+ break;
+ }
+ } else if (declarativeAction.equals("create")){
+
+ // now substituting array
+ if (verbChunk.getLemmas().get(1).toLowerCase().equals("array")){
+
+ if(lems.contains("class")){
+ int indClass = lems.indexOf("class");
+ int numElements = lems.indexOf("elements");
+ if (numElements<0)
+ numElements = lems.indexOf("objects");
+ if (numElements<0)
+ numElements = lems.indexOf("members");
+ String arraySize = lems.get(numElements-1);
+ op.setOperatorFor(lems.get(indClass+1)+"[] "+verbChunk.getLemmas().get(verbChunk.getLemmas().size()-1).toLowerCase()
+ +" = new "+lems.get(indClass+1)+"["+arraySize+"]");
+ classBeingDefined = false;
+ break;
+ }
+ }
+ } else if (declarativeAction.equals("assign")){
+ int numElements = lems.indexOf("element");
+ if (numElements<0)
+ numElements = lems.indexOf("object");
+ if (numElements<0)
+ numElements = lems.indexOf("member");
+ if (Arrays.asList(arrayElementList).contains(lems.get(numElements-1))){
+ int arrIndex = Arrays.asList(arrayElementList).indexOf(lems.get(numElements-1));
+ String indexValue = arrayElementListInsdex[arrIndex];
+
+ String arrayName = lems.get(lems.size()-1);
+ if (expression!=null)
+ op.setOperatorFor(arrayName+"["+indexValue+"]."+ expression);
+ break;
+ }
+ } else if (declarativeAction.equals("set")){
+ int indQuantifier = lems.indexOf("all");
+ if (indQuantifier>-1 &&
+ (lems.get(indQuantifier+1).equals("elements") || lems.get(indQuantifier+1).equals("members") )){
+
+ String arrayName = lems.get(lems.size()-1);
+ if (expression!=null)
+ op.setOperatorFor("for(int i=0; i<"+ arrayName+".size(); i++) "+
+ arrayName+"[i]."+ expression);
+ break;
+ }
+ }
+ /*
+ else {
+ List<String> paramValues = verbChunk.getLemmas(), paramPOSs = verbChunk.getPOSs();
+
+ paramValues.remove(0); paramPOSs.remove(0);
+ // the subject of a verb refers to the object
+ try {
+ String objectCandidatePOS = paramPOSs.get(paramValues.size()-1);
+ if (objectCandidatePOS.startsWith("NN")){
+ oPhrase.setObjectName(paramValues.get(paramValues.size()-1));
+ paramValues.remove(paramValues.size()-1);
+ paramPOSs.remove(paramPOSs.size()-1);
+ } else if (paramPOSs.get(paramValues.size()-2).startsWith("NN")){
+ oPhrase.setObjectName(paramValues.get(paramValues.size()-2));
+ paramValues.remove(paramValues.size()-2);
+ paramPOSs.remove(paramPOSs.size()-2);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ oPhrase.setParamValues(paramValues);
+ oPhrase.setParamChunk(paramValues, paramPOSs);
+
+ // object name/instance
+ if (oPhrase.getObjectName() == null){
+ List<ParseTreeChunk> objectName = lingPhrases.get(0);
+ ParseTreeChunk objNameChunk = objectName.get(0);
+ if ( objNameChunk.getPOSs().get(0).equals("NN")){
+ oPhrase.setObjectName( objNameChunk.getLemmas().get(0));
+ }
+ }
+ } else { // verb = 'verify' attribute prep prep object
+
+ List<String> paramValues = verbChunk.getLemmas(), paramPOSs = verbChunk.getPOSs();
+ paramValues.remove(0); paramPOSs.remove(0); // we dont need 'verify'
+
+ // start with getting right-most noun as object
+ String objectCandidatePOS = paramPOSs.get(paramValues.size()-1);
+ if (objectCandidatePOS.startsWith("NN")){
+ oPhrase.setObjectName(paramValues.get(paramValues.size()-1));
+ paramValues.remove(paramValues.size()-1);
+ paramPOSs.remove(paramPOSs.size()-1);
+ } else if (paramPOSs.get(paramValues.size()-2).startsWith("NN")){
+ oPhrase.setObjectName(paramValues.get(paramValues.size()-2));
+ paramValues.remove(paramValues.size()-2);
+ paramPOSs.remove(paramPOSs.size()-2);
+ }
+ // attempt to find attribute
+ for(int i = paramValues.size()-1; i>=0; i--){
+ if (paramPOSs.get(i).equals("IN") || paramPOSs.get(i).equals("DT"))
+ continue;
+ else if (paramPOSs.get(i).startsWith("NN")||paramPOSs.get(i).startsWith("JJ")||paramPOSs.get(i).startsWith("CD")){
+ oPhrase.setMethod(paramValues.get(i));
+ paramValues = paramValues.subList(0, i-1);
+ paramPOSs = paramPOSs.subList(0, i-1);
+ oPhrase.setParamValues(paramValues);
+ oPhrase.setParamChunk(paramValues, paramPOSs);
+ break;
+ }
+ }
+ }
+ oPhrase.setOrigPhrase(verbChunk);
+ oPhrase.cleanArgs();
+ //if (oPhrase.getMethod()!=null || oPhrase.getObjectName()!=null)
+ oPhrases.add(oPhrase);
+
+ } */
+ }
+
+ ObjectPhraseListForSentence oplfs = new ObjectPhraseListForSentence( oPhrases, op);
+ oplfs.cleanMethodNamesIsAre();
+ oplfs.substituteNullObjectIntoEmptyArg();
+
+ return oplfs;
+ }
+
+ public static void main(String[] args){
+
+ String[] text = new String[]{
+ "Define a class and name it Employee. ",
+ "Define text attribute and name it m_name. ",
+ "Define double attribute and name it m_salary.",
+ "Create array of objects of class Employee for 10 elements, name the object as workforce.",
+ "Assign the first element in array workforce: m_name=Boss",
+ "Assign the second element in array workforce: m_name=His wife",
+ // "Comment: We just started our small business company and expect to hire 8 more people soon.",
+ "Set for all elements in array workforce: m_salary=0 ",
+ "Print the list of all m_name attributes for workforce."
+
+ };
+
+ NL2Obj compiler = new NL2ObjCreateAssign();
+ for(String sent:text){
+ ObjectPhraseListForSentence opls=null;
+ try {
+ opls = compiler.convertSentenceToControlObjectPhrase(sent);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ System.out.println(sent+"\n"+opls+"\n");
+ }
+
+ }
+}
Added: opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectControlOp.java
URL: http://svn.apache.org/viewvc/opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectControlOp.java?rev=1387791&view=auto
==============================================================================
--- opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectControlOp.java (added)
+++ opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectControlOp.java Wed Sep 19 22:01:02 2012
@@ -0,0 +1,43 @@
+package opennlp.tools.nl2code;
+
+public class ObjectControlOp {
+ String operatorFor;
+ String operatorIf;
+ String linkUp;
+ String linkDown;
+
+
+ public ObjectControlOp() {
+ operatorFor="";
+ operatorIf="";
+ }
+ public String getOperatorFor() {
+ return operatorFor;
+ }
+ public void setOperatorFor(String operatorFor) {
+ this.operatorFor = operatorFor;
+ }
+ public String getOperatorIf() {
+ return operatorIf;
+ }
+ public void setOperatorIf(String operatorIf) {
+ this.operatorIf = operatorIf;
+ }
+ public String getLinkUp() {
+ return linkUp;
+ }
+ public void setLinkUp(String linkUp) {
+ this.linkUp = linkUp;
+ }
+ public String getLinkDown() {
+ return linkDown;
+ }
+ public void setLinkDown(String linkDown) {
+ this.linkDown = linkDown;
+ }
+
+ public String toString(){
+ return operatorFor+ "(" + operatorIf;
+ }
+
+}
Added: opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectPhrase.java
URL: http://svn.apache.org/viewvc/opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectPhrase.java?rev=1387791&view=auto
==============================================================================
--- opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectPhrase.java (added)
+++ opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectPhrase.java Wed Sep 19 22:01:02 2012
@@ -0,0 +1,108 @@
+package opennlp.tools.nl2code;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import opennlp.tools.textsimilarity.ParseTreeChunk;
+
+public class ObjectPhrase {
+ private String objectName;
+ private String objectInstance;
+ private String epistemicAction;
+ private String controlAction;
+ private String method;
+ private List<String> paramType;
+ private List<String> paramValues;
+ private ParseTreeChunk origPhrase;
+
+ private ParseTreeChunk paramChunk;
+
+ public ParseTreeChunk getParamChunk() {
+ return paramChunk;
+ }
+ public void setParamChunk(ParseTreeChunk paramChunk) {
+ this.paramChunk = paramChunk;
+ }
+
+ public void setParamChunk(List<String> lemmas, List<String> pOSs) {
+ this.paramChunk = new ParseTreeChunk("", lemmas, pOSs);
+ }
+
+ public ObjectPhrase(){
+ paramType = new ArrayList<String>();
+ paramValues = new ArrayList<String>();
+ }
+ public String getObjectName() {
+ return objectName;
+ }
+ public void setObjectName(String objectName) {
+ this.objectName = objectName;
+ }
+ public String getObjectInstance() {
+ return objectInstance;
+ }
+ public void setObjectInstance(String objectInstance) {
+ this.objectInstance = objectInstance;
+ }
+ public String getEpistemicAction() {
+ return epistemicAction;
+ }
+ public void setEpistemicAction(String epistemicAction) {
+ this.epistemicAction = epistemicAction;
+ }
+ public String getControlAction() {
+ return controlAction;
+ }
+ public void setControlAction(String controlAction) {
+ this.controlAction = controlAction;
+ }
+
+ public String getMethod() {
+ return method;
+ }
+ public void setMethod(String method) {
+ this.method = method;
+ }
+
+ public List<String> getParamType() {
+ return paramType;
+ }
+ public void setParamType(List<String> paramType) {
+ this.paramType = paramType;
+ }
+ public List<String> getParamValues() {
+ return paramValues;
+ }
+ public void setParamValues(List<String> paramValues) {
+ this.paramValues = paramValues;
+ }
+
+ public String toString(){
+ return objectName+"."+method+"("+paramValues.toString()+")";
+ }
+ public ParseTreeChunk getOrigPhrase() {
+ return origPhrase;
+ }
+ public void setOrigPhrase(ParseTreeChunk origPhrase) {
+ this.origPhrase = origPhrase;
+ }
+
+ public void cleanArgs(){
+ List<String> comparativePrpList = Arrays.asList(new String[]{"below", "more", "less", "above"});
+ if (this.getParamChunk()==null)
+ return;
+ List<String> pOSs = this.getParamChunk().getPOSs(), lemmas = this.getParamChunk().getLemmas(), cleanedArgs = new ArrayList<String>();
+
+ for(int i=0; i<pOSs.size(); i++){
+ String pos = pOSs.get(i);
+
+ if (pos.startsWith("NN")|| pos.startsWith("JJ")|| pos.startsWith("CD")|| pos.startsWith("RB ")
+ || comparativePrpList.contains(lemmas.get(i)))
+ cleanedArgs.add(lemmas.get(i));
+
+ }
+ this.paramValues = cleanedArgs;
+ }
+
+}
Added: opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectPhraseListForSentence.java
URL: http://svn.apache.org/viewvc/opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectPhraseListForSentence.java?rev=1387791&view=auto
==============================================================================
--- opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectPhraseListForSentence.java (added)
+++ opennlp/sandbox/opennlp-similarity/src/main/java/opennlp/tools/nl2code/ObjectPhraseListForSentence.java Wed Sep 19 22:01:02 2012
@@ -0,0 +1,87 @@
+package opennlp.tools.nl2code;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ObjectPhraseListForSentence {
+ List<ObjectPhrase> oPhrases;
+ ObjectControlOp contrOp;
+
+ public ObjectPhraseListForSentence(List<ObjectPhrase> oPhrases2,
+ ObjectControlOp op) {
+ this.oPhrases = oPhrases2;
+ this.contrOp=op;
+ }
+
+ public String toString(){
+ String ret= "";
+ ret+= contrOp.getOperatorFor();
+ ret+= contrOp.getOperatorIf();
+ ret+=" "+oPhrases.toString();
+ return ret;
+ }
+
+ public void cleanMethodNamesIsAre(){
+ for(int i=0; i<oPhrases.size(); i++){
+ ObjectPhrase o1 = oPhrases.get(i);
+ if (o1.getMethod()!=null && (o1.getMethod().equals("is")|| o1.getMethod().equals("are")
+ || o1.getMethod().equals("have") || o1.getMethod().equals("has"))){
+ ObjectPhrase o1new = new ObjectPhrase();
+ o1new.setObjectName(o1.getObjectName());
+ o1new.setMethod("");
+ o1new.setParamValues(o1.getParamValues());
+ oPhrases.set(i, o1new);
+ }
+ }
+ }
+ //[pixel.area([]), pixels.belongs([]), null.are([less, 128])
+ public void substituteNullObjectIntoEmptyArg(){
+ for(int i=0; i<oPhrases.size(); i++)
+ for(int j=i+1; j<oPhrases.size(); j++){
+ ObjectPhrase o1 = oPhrases.get(i), o2 = oPhrases.get(j);
+ if (o2.getObjectName()==null && o1.getParamValues().size()<1){
+ String newArgs = o2.getMethod()+"("+o2.getParamValues()+")";
+ ObjectPhrase o1new = new ObjectPhrase();
+ o1new.setObjectName(o1.getObjectName());
+ o1new.setMethod(o1.getMethod());
+ List<String> paramValues = new ArrayList<String>();
+ paramValues.add(newArgs);
+ o1new.setParamValues(paramValues);
+ oPhrases.set(i, o1new);
+ oPhrases.remove(j);
+ }
+ }
+ }
+
+ //area.size([]), threshold.([below])
+ public void substituteIntoEmptyArgs() {
+ for(int i=0; i<oPhrases.size(); i++)
+ for(int j=i+1; j<oPhrases.size(); j++){
+ ObjectPhrase o1 = oPhrases.get(i), o2 = oPhrases.get(j);
+ if (o1.getParamValues().size()<1 && o2.getMethod().equals("")){
+ String newArgs = o2.getMethod()+"("+o2.getParamValues()+")";
+ ObjectPhrase o1new = new ObjectPhrase();
+ o1new.setObjectName(o1.getObjectName());
+ o1new.setMethod(o1.getMethod());
+ List<String> paramValues = new ArrayList<String>();
+ paramValues.add(newArgs);
+ o1new.setParamValues(paramValues);
+ oPhrases.set(i, o1new);
+ oPhrases.remove(j);
+ }
+ }
+ }
+
+ ////[null.2([])]
+ public void clearInvalidObject() {
+ for(int i=0; i<oPhrases.size(); i++){
+ ObjectPhrase o1 = oPhrases.get(i);
+ if (o1.getObjectName()==null && o1.getParamValues().size()<1){
+
+ oPhrases.remove(i);
+ }
+ }
+ }
+
+
+}