Apendice.tex

\chapter*{Apéndice}
\appendix
%\markboth{Appendices}{}
\addcontentsline{toc}{chapter}{Apéndice}
\renewcommand{\thesection}{A.\arabic{section}}

\section{Traza de la generación de la estructura inicial para la ontología Pizza}
\label{apx:traza_pizza}

\centering
\setlength{\parindent}{1em}
\begin{verbatim}

Comienza la clasificación de las Entidades
para seleccionar los temas principales:
Participación de cada clase en la ontología
(cantidad de veces que aparece en un dominio):
    Pizza: 2
    BaseDePizza: 1
    Comida: 1
    CoberturaDePizza: 1
Suma total de participación: 5.0
Promedio de participación (suma total de participación
divido por la cantidad de clases que 
participaron de la suma):
    5.0/4 = 1.25
Clases que superan el promedio y por lo tanto
son consideradas temas principales:
[Pizza] -> porcentaje de participación en 
los dominios de la ontología: 40.0%
Temas principales reconocidos:[Pizza]

Comienza a crear los grupos para la Clase: Pizza
Crea subnivel
Comienza a crear el grupo para: PizzaConCarne
Comienza a crear el grupo para: PizzaPicante
Comienza a crear el grupo para: PizzaNoVegetariana
Comienza a crear el grupo para: PizzaConNombre
Crea subnivel
...
Sale del subnivel actual.
...
Comienza a crear el grupo para: PizzaVegetariana
Comienza a crear el grupo para: tieneIngrediente
Crea subnivel
Comienza a crear el grupo para: tieneCobertura
Crea subnivel
Comienza a crear el grupo para: CoberturaDePizza
Crea subnivel
...
Sale del subnivel actual.
Comienza a crear el grupo para: tieneBase
Crea subnivel
Comienza a crear el grupo para: BaseDePizza
Crea subnivel
Comienza a crear el grupo para: BaseGruesa
Comienza a crear el grupo para: BaseDelgadaYCrujiente
Sale del subnivel actual.
Sale del subnivel actual.
Sale del subnivel actual.
Sale del subnivel actual.
Finalizó la creación de la Sección rincipal.

Las siguientes Entidades no poseen su propia Sección,
por lo que serán agregadas a Otras Secciones: 
Comienza a crear el grupo para: DomainConcept
Crea subnivel
Comienza a crear el grupo para: Comida
...
Comienza a crear el grupo para: Pais
...
Sale del subnivel actual.
Comienza a crear el grupo para: ValuePartition
Crea subnivel
Comienza a crear el grupo para: Picante
Crea subnivel
Comienza a crear el grupo para: PocoPicante
Comienza a crear el grupo para: AlgoPicante
Comienza a crear el grupo para: MuyPicante
Sale del subnivel actual.
Sale del subnivel actual.
Finalizó la creación de Otras Secciones
\end{verbatim}

\section{Implementación Organizador de Información}
\label{apx:impl_org_inf}

\subsection{Clase \texttt{OntologyManager}}
\label{sec:clase_ontologymanager}

\begin{minted}[autogobble,linenos]{java}
public class OntologyManager {

    /*nameOf guarda el valor 0 o 1 para reconocer de donde tiene que
    extraer el nombre de las entidades*/
    private static int nameOf; // 0 -> iri, 1 -> label.
    /*lang setea el valor del lenguaje para buscar los nombres
    de las entidades en los labels correctos*/
    private static String lang; // "en" -> ingles, "es" -> español.

  public static Ontology createOntology
            (OWLOntology ontology, int nameOfClass, String language) {
        nameOf = nameOfClass;
        lang = language;
        Ontology onto = new Ontology();
        
        //Obtiene el título de la ontología desde la etiqueta title.
        String title = getTitleOntology();
        onto.setTitle(title);
        
        //crear clases
        OWLClass rootClass = createClasses();

        //crear los dataProperty
        OWLDataProperty rootDataProp = createDataProperty();
        
        //crear properties
        OWLObjectProperty rootProp = createObjectProperty();
        //setea las objectProperty equivalentes, inversas y disjuntas.
        setListsToProperties();
        //setea el dominio y rango de las objectProperty
        setObjectPropertyDomainRange();
        //setea el dominio y rango de las dataProperty
        setDataPropertyDomain();
        
        //crear individuals
        createIndividuals();
        
        /*crear las clases anónimas para cada clase en onto.
        Setea listas para guardar los axiomas. Para cada clase en onto
        setea sus clases equivalentes, disjuntas y superClases.*/
        /*createAnonymousClasses debe ser llamado despues de haber
        creado las clases nombradas, las properties y los individuos.*/
        createAnonymousClasses();
        
        //agrega los componentes creados al objeto onto.
        addComponentsToOnto();
        
        //precomputeValues asocia a cada clase en onto una lista 
        //de propiedades en las que participa como dominio.
        onto.precomputeValues();
        return onto;
    }
}
\end{minted}

\subsection{Clase \texttt{Ontology}}
\label{sec:clase_ontology}
\begin{minted}[autogobble,linenos]{java}
public class Ontology {

    private String title;
    //guardan las Entidades de nivel mas alto en la jerarquía.
    private OWLClass rootClass;
    private OWLObjectProperty rootObjectProperty;
    private OWLDataProperty rootDataProp;

    //los siguientes hashmaps asocian IRIs a sus respectivas Entidades.
    private HashMap<IRI, OWLClass> classes;
    private HashMap<IRI, OWLObjectProperty> properties;
    private HashMap<IRI, OWLObjectProperty> anonProperties;
    private HashMap<IRI, OWLDataProperty> dataProperties;
    private HashMap<IRI, OWLIndividual> individuals;
    
    //Las siguientes listas guardan las Entidades presentes en la 
    //ontologia
    private LinkedList<OWLClass> listClasses;
    private LinkedList<OWLObjectProperty> listProps;
    private LinkedList<OWLObjectProperty> anonListProps;
    private LinkedList<OWLDataProperty> listDataProps;
    private LinkedList<OWLIndividual> listIndividuals;

    /*hashmaps para guardar que clases participan en el dominio
    de que propiedades*/
    HashMap<OWLClass, LinkedList<OWLObjectProperty>> classOnPropDomain;
    /*hashmaps para guardar que clases participan en el rango
    de que propiedades*/
    HashMap<OWLClass, LinkedList<OWLObjectProperty>> classOnPropRange;

    /*Retorna una lista de ObjectProperties que sean superProperties
    en comun de las properties de la lista prop.*/
    public LinkedList<OWLObjectProperty>
    getCommonSuperProperties(LinkedList<OWLObjectProperty> prop) {}

    /*Dada la clase cls, recorre las properties donde participa como dominio
    y busca las superProperties de mas alto nivel que encuentre 
    y las retorna. */
     public LinkedList<OWLObjectProperty>
     getCommonSuperPropertiesFromClass(OWLClass cls) {}

    /*Retorna el contenido necesario para crear un nuevo grupo
    de entidades a partir de la clase cls. Util para
    el modulo ContentGrouping */
    public LinkedList<OWLIntClass> 
    createTopicsGroupsFromClass(OWLClass cls) {
        LinkedList<OWLIntClass> res = new LinkedList<>();
        res.addAll(getCommonSuperPropertiesFromClass(cls));
        res.addAll(cls.getSubClass());
        res.addAll(cls.getIndividuals());
        return res;
    }
}
\end{minted}


\subsection{Clase \texttt{ContentClasification}}
\label{sec:clase_content_clasif}

\begin{minted}[autogobble,linenos]{java}
public class ContentClasification {

    /* Es el método principal que retorna las entidades
    más relevantes para agregar en el primer nivel de
    la jerarquía del Árbol de Entidades. */
    public static HashMap<OWLIntClass, LinkedList<OWLObjectProperty>>
    getMainContent(Ontology ontology) {
        
        cls2Cant = getClassesToCantProperties(ontology);
        mainClasses = getMainClasses(cls2Cant);

        /*insertar en un nuevo hashmap cls2SuperProp las clases de mainClasses
        asociadas a las superProperties en común que haya entre las properties 
        donde participa como dominio*/
        for (OWLClass mainClass : mainClasses) {
            cls2SuperProp.put(mainClass,
            ontology.getCommonSuperPropertiesFromClass(mainClass));
        }
        
        /*Si existe una Clase c y alguna SuperClase de c, 
        entonces c se elimina por ser mas específica*/
        cls2SuperProp = removeSubClass(cls2SuperProp);

        /*si el hashmap es vacio, entonces se agregan todas las
        clases sin objproperties*/
        if (cls2SuperProp.isEmpty()) {
            for (OWLClass cls : ontology.getClasses()) {
                cls2SuperProp.put(cls, new LinkedList<>());
            }
        }
        return cls2SuperProp;
    }
    
    /*Devuelve una Lista de HashMaps desde Clases a Integers. Cada
     Hashmap tiene una sola entrada, que va desde una Clase a la
     cantidad de properties en las que participa como dominio.*/
    private static LinkedList<HashMap<OWLClass, Integer>>
    getClassesToCantProperties(Ontology ontology) {}
    
    /*Devuelve una lista de Clases. Las Clases retornadas son las
     que participan en mas cantidad de properties, y que superan 
     el promedio calculado como la suma de todas las properties
     dividido entre la cantidad de clases.*/
    private static LinkedList<OWLClass>
    getMainClasses(LinkedList<HashMap<OWLClass, Integer>> cls) {}
}

\end{minted}


\subsection{Clase \texttt{ContentGrouping}}
\label{sec:clase_content_grouping}

\begin{minted}[autogobble,linenos]{java}
public class ContentGrouping {

    /*A partir de la clase cls y la rama branch a la que pertenece,
    se genera un nuevo grupo de Entidades, y se verifica que cada
    Entidad aún no pertenezca a la rama*/
    public static LinkedList<OWLIntClass>
    generateNewTopics(Ontology ontology, OWLClass cls, 
                LinkedList<OWLIntClass> branch) {
        LinkedList<OWLIntClass> tops = ontology.createTopicsGroupsFromClass(cls);
        for (OWLIntClass r : tops) {
            if (!r.getType().equals("property")) {
                    if (!branch.contains(r)) {
                        res.add(r);
                    }
            }
        }
        for (OWLIntClass r : tops) {
            if (r.getType().equals("property")) {
                checkProperties((OWLObjectProperty) r, res, branch);
            }
        }
        return res;
    }

    /*A partir de una property prop y la clase dom que pertenece
    a su dominio, busca crear un nuevo grupo de Entidades.
    Primero busca subProperties de prop. Si no tiene subProperties, 
    entonces intenta agregar el Rango de prop.*/
    public static LinkedList<OWLIntClass> 
    generateNewTopics(Ontology ontology, OWLObjectProperty prop,
                    OWLClass dom) {
        
        /*obtiene las subProperties de prop*/
        LinkedList<OWLIntClass> newTopics = prop.getSubPropWithDomain(dom);
        
        if (newTopics.isEmpty()) {
            newTopics = prop.getRange();
        }
        return newTopics;
    }
    
    /*A partir de prop busca agregar a ella o una superProperty
    de ella en res. Agrega a prop si tiene una superProperty en branch.
    Si no puede agregar a prop busca agregar un ancestro de prop que 
    tenga una superProperty en branch.*/
    private static boolean checkProperties(OWLObjectProperty prop,
    LinkedList<OWLIntClass> res, LinkedList<OWLIntClass> branch) {}
}
\end{minted}

\subsection{Clase \texttt{GeneratorTreeManager}}
\label{sec:clase_generator_tree}

\begin{minted}[autogobble,linenos]{java}
public class GeneratorTreeManager {

    public static LinkedList<OWLIntClass> getText(Ontology onto) {

        HashMap<OWLIntClass, LinkedList<OWLObjectProperty>> mainClass =
        ContentClasification.getMainContent(onto);
        
        /*agregar las clases de mainClass al primer nivel del árbol. 
        mainEntities representa el primer nivel del árbol 
        (las entidades mas relevantes)*/
        mainEntities.add(mainClass);
        
        /*para cada clase de mainClass crear una nueva rama y agregar 
        sus Nuevos grupos de Entidades*/
        for (Map.Entry<OWLIntClass, LinkedList<OWLObjectProperty>> entrySet : 
                mainClass.entrySet()) {
            /*navigation mantiene las clases del primer nivel y
            las Entidades de la rama que se está creando*/
            navigation.add(mainClass);
            OWLClass mClass = entrySet.getKey();
            LinkedList<OWLIntClass> newEntities =
            ContentGrouping.generateNewTopics(onto, mClass, null);
            addBranchFromEntity(newBranch, mClass, newEntities, navigation,
            onto);
            mainEntities.addNewBranchToEntity(mClass, newBranch);
            navigation.clear();
            
        }
        /*agregar informacion marginada*/
        mainEntities.addNewBranch(addAbsentClass(onto));
        return mainEntities;
    }
    
    /*Recorre las newEntities creando sus respectivos niveles de jerarquía 
    en el Árbol de Entidades.*/
    private static void addBranchFromEntity(newBranch, OWLClass actualClass,
    newEntities, navigation, onto) {
        for (OWLIntClass enti : newEntities) {
            if (!navigation.contains(enti)) {
                navigation.addLast(enti);
                if (enti.getType().equals("class")) {
                    sub2 = ContentGrouping.generateNewTopics(onto, enti, navigation);
                    addBranchFromEntity(newSubBranch, enti, sub2, navigation, onto);
                }else if (enti.getType().equals("property")) {
                    sub2 = ContentGrouping.generateNewTopics(onto, enti, actualClass);
                    addBranchFromEntity(newSubBranch, actualClass, sub2, navigation, onto);
                }
                navigation.removeLast();
                newBranch.addNewBranchToEntity(enti, newSubBranch);
            }
        }
    }
}
\end{minted}


\section{Implementación Micro Planificación}
\label{apx:impl_micro_plan}

\subsection{Implementación de la verbalización del constructor \emph{OWLObjectComplementOf} en español}
\label{sec:clase_OWLObjectComplementOf}

\begin{minted}[autogobble,linenos]{java}
public class OWLObjectComplementOf extends OWLRestriction{

    public OWLObjectComplementOf(String type, String lang) {
        super(type, lang);
    }

/*La StatementComponent que retorna tiene la lista de Word 'resList',
que representa la oración parcial que se compone en este constructor.
Nótose que a esta lista se le inserta el 'enlace + clase', que se
corresponde con la definición de su gramática.*/

@Override
    protected StatementComponent generateStatementSpanish(TextCotext c) {
        LinkedList<StatementComponent> stmsClasses = new LinkedList<>();
        stmsClasses.add(classes.get(0).generateStatement(c));
        LinkedList<Word> resList = new LinkedList<>();
        LinkedList<Word> enlace = getEnlaceSpanish(stmsClasses.get(0));
        resList.addAll(enlace);
        resList.addAll(stmsClasses.get(0).getListWords());
        StatementComponent stm = new StatementComponentSpanish(c, resList, "ON", type);
        stm.setComplementList(resList);
        return stm;
    }
    
    /*Diferentes enlaces dependiendo el tipo de oracion parcial que recibe*/
    private LinkedList<Word> getEnlaceSpanish(StatementComponent stm) {
        LinkedList<Word> enlace = new LinkedList<>();
        if (stm.getType().equals("T")) {
            WordSpanish lo = new WordSpanish("LO", WordSpanish.TYPE_PRONOUN);
            WordSpanish opuesto = new WordSpanish("OPUESTO", WordSpanish.TYPE_ADJETIVE);
            WordSpanish de = new WordSpanish("DE", WordSpanish.TYPE_PREPOSITION);
            enlace.add(lo);
            enlace.add(opuesto);
            enlace.add(de);
        } else if (stm.getType().equals("SV")) {
            WordSpanish no = new WordSpanish("NO", WordSpanish.TYPE_ADV_NEG);
            enlace.add(no);
        } else if (stm.getType().equals("ON")) {
            WordSpanish ni = new WordSpanish("NI", WordSpanish.TYPE_CONJUNTION_COORD);
            enlace.add(ni);
        }else {
            WordSpanish no = new WordSpanish("EXCEPTO", WordSpanish.TYPE_ADV_NEG);
            enlace.add(no);
        }
        return enlace;
    }
}
\end{minted}


\subsection{Método para generar las Expresiones de Referencia en español}
\label{sec:met_exp_ref}

\begin{minted}[autogobble,linenos]{java}
public LinkedList<Word> getReferenceExpression(TextCotext c) {
    LinkedList<Word> resList = new LinkedList<>();
    Random r = new Random();
    int x = r.nextInt(10);
    /*Tiene un 20% de probabilidad de utilizar como expresión
    de referencia el nombre de su superClase si posee una*/
    if (superClass.size() == 1 && x < 2) {
        TextCotext cot = new TextCotext(null, this, "init", 0, language);
        Word n = superClass.get(0).generateStatement(cot).getNoun();
        String gen = ((WordSpanish) n).getGender();
        resList.add(getPronounDemostrative(gen));
        resList.add(n.getUpercaseWord());
    }else{
        Word noun = statement.getNoun();
        String gen = ((WordSpanish) noun).getGender();
        resList.add(getPronounDemostrative(gen));
    }
    return resList;
}

private WordSpanish getPronounDemostrative(String gen) {
    WordSpanish w;
    if (gen.equals("femenino")) {
        w = new WordSpanish("ESTA", WordSpanish.TYPE_PRONOUN_DEMONSTRATIVE);
    } else {
        w = new WordSpanish("ESTE", WordSpanish.TYPE_PRONOUN_DEMONSTRATIVE);
    }
    return w;
}
\end{minted}

\section{Implementación Realizador}
\label{sec:impl_realizador}
\subsection{Clase \texttt{Section}}
\label{sec:clase_section}

\begin{minted}[autogobble,linenos]{java}
public class Section {
    private LinkedList<OWLIntClass> topics;
    private Title title;
    private LinkedList<Paragraph> paragraphs;
    private LinkedList<Section> subSections;
    private String language;

    public Section(OWLIntClass topic, String lang) {
        init(lang);
        topics.add(topic);
        title = new Title(topic, lang);
        if (topic.getType().equals("class") ||
        topic.getType().equals("individual")) {
            //crear el Paragraph para la informacion de la seccion
            Paragraph inf = new Paragraph(topic, lang);
            paragraphs.add(inf);
        } 
    }
    
    public String generateText() {
    String textF = "";
    textF = titulo de la Section
    textF += contenido de los Parrafos de la Section
    for (Section s: subSections){
        if (s no cumple los criterios para verbalizar como sección){
            textF += contenido de s en forma de párrafo
        }
    }
    /*La realización de las subsecciones se separa en dos
    recorridos distintos para que todos los párrafos estén
    juntos, y luego aparezcan todas las secciones.*/
    for (Section s: subSections){
        if (s cumple los criterios para verbalizar como sección){
            textF += s.generateText();
        }
    }
    
    return textF;
    }
}
\end{minted}