package org.fnlp.demo.nlp;
import org.fnlp.nlp.cn.tag.POSTagger;
import org.fnlp.nlp.parser.dep.DependencyTree;
import org.fnlp.nlp.parser.dep.JointParser;

public class DepParser {
    private static JointParser parser;

    public static void main(String[] args) throws Exception {
        parser = new JointParser("../models/dep.m");

        System.out.println("得到支持的依存关系类型集合");
        System.out.println(parser.getSupportedTypes());

        String word = "中国进出口银行与中国银行加强合作。";
        test(word);

    }

    private static void test(String word) throws Exception {        
        POSTagger tag = new POSTagger("../models/seg.m","../models/pos.m");
        String[][] s = tag.tag2Array(word);
        try {
            DependencyTree tree = parser.parse2T(s[0],s[1]);
            System.out.println(tree.toString());
            String stree = parser.parse2String(s[0],s[1],true);
            System.out.println(stree);
        } catch (Exception e) {         
            e.printStackTrace();
        }
    }
}

#include <iostream>
#include <vector>

#include "ltp/parser_dll.h"

int main(int argc, char * argv[]) {
  if (argc < 2) {
    return -1;
  }

  void * engine = parser_create_parser(argv[1]);
  if (!engine) {
    return -1;
  }

  std::vector<std::string> words;
  std::vector<std::string> postags;

  words.push_back("一把手");  postags.push_back("n");
  words.push_back("亲自");    postags.push_back("d");
  words.push_back("过问");    postags.push_back("v");
  words.push_back("。");      postags.push_back("wp");

  std::vector<int>      heads;
  std::vector<std::string>  deprels;

  parser_parse(engine, words, postags, heads, deprels);

  for (int i = 0; i < heads.size(); ++ i) {
    std::cout << words[i] << "\t" << postags[i] << "\t"
              << heads[i] << "\t" << deprels[i] << std::endl;
  }

  parser_release_parser(engine);
  return 0;
}

package com.hankcs.demo;

import com.hankcs.hanlp.HanLP;
import com.hankcs.hanlp.corpus.dependency.CoNll.CoNLLSentence;
import com.hankcs.hanlp.corpus.dependency.CoNll.CoNLLWord;

public class DemoDependencyParser
{
    public static void main(String[] args)
    {
        CoNLLSentence sentence = HanLP.parseDependency("徐先生还具体帮助他确定了把画雄鹰、松鼠和麻雀作为主攻目标。");
        System.out.println(sentence);
        // 可以方便地遍历它
        for (CoNLLWord word : sentence)
        {
            System.out.printf("%s --(%s)--> %s\n", word.LEMMA, word.DEPREL, word.HEAD.LEMMA);
        }
        // 也可以直接拿到数组，任意顺序或逆序遍历
        CoNLLWord[] wordArray = sentence.getWordArray();
        for (int i = wordArray.length - 1; i >= 0; i--)
        {
            CoNLLWord word = wordArray[i];
            System.out.printf("%s --(%s)--> %s\n", word.LEMMA, word.DEPREL, word.HEAD.LEMMA);
        }
        // 还可以直接遍历子树，从某棵子树的某个节点一路遍历到虚根
        CoNLLWord head = wordArray[12];
        while ((head = head.HEAD) != null)
        {
            if (head == CoNLLWord.ROOT) System.out.println(head.LEMMA);
            else System.out.printf("%s --(%s)--> ", head.LEMMA, head.DEPREL);
        }
    }
}

package edu.stanford.nlp.parser.nndep.demo; 
import edu.stanford.nlp.util.logging.Redwood;

import edu.stanford.nlp.ling.HasWord;
import edu.stanford.nlp.ling.TaggedWord;
import edu.stanford.nlp.parser.nndep.DependencyParser;
import edu.stanford.nlp.process.DocumentPreprocessor;
import edu.stanford.nlp.tagger.maxent.MaxentTagger;
import edu.stanford.nlp.trees.GrammaticalStructure;

import java.io.StringReader;
import java.util.List;

public class DependencyParserDemo  {

  /** A logger for this class */
  private static Redwood.RedwoodChannels log = Redwood.channels(DependencyParserDemo.class);
  public static void main(String[] args) {
    String modelPath = DependencyParser.DEFAULT_MODEL;
    String taggerPath = "edu/stanford/nlp/models/pos-tagger/english-left3words/english-left3words-distsim.tagger";

    for (int argIndex = 0; argIndex < args.length; ) {
      switch (args[argIndex]) {
        case "-tagger":
          taggerPath = args[argIndex + 1];
          argIndex += 2;
          break;
        case "-model":
          modelPath = args[argIndex + 1];
          argIndex += 2;
          break;
        default:
          throw new RuntimeException("Unknown argument " + args[argIndex]);
      }
    }

    String text = "I can almost always tell when movies use fake dinosaurs.";

    MaxentTagger tagger = new MaxentTagger(taggerPath);
    DependencyParser parser = DependencyParser.loadFromModelFile(modelPath);

    DocumentPreprocessor tokenizer = new DocumentPreprocessor(new StringReader(text));
    for (List<HasWord> sentence : tokenizer) {
      List<TaggedWord> tagged = tagger.tagSentence(sentence);
      GrammaticalStructure gs = parser.predict(tagged);

      // Print typed dependencies
      log.info(gs);
    }
  }
}