hpo

<?php
/**
 * A basic Human Phenotype Ontology Class
 *
 * @author Csaba
 *
 */
require_once 'Term.class.php';

class HPO {

    /**
     * Holds the version of the ontology
     * @type string
     */
    protected $version;

    /**
     * Holds the format information of the ontology
     * @type string
     */
    protected $formatInfo;

    /**
     * Holds the terms in the ontology
     * @var unknown
     */
    protected $terms = array();

    /**
     * Adds an HPO term to the collection
     * @param Term $obj
     * @param string $key
     * @throws KeyHasUseException
     */
    public function addTerm(&$obj, $key) {

            if (isset($this->terms[$key])) {
                throw new KeyHasUseException("Key $key already in use.");
            }
            else {
                $this->terms[$key] = $obj;
            }

    }

    /**
     * Removes a Term from the collection
     * @param string $key
     * @throws KeyInvalidException
     */
    public function deleteTerm($key) {
        if (isset($this->terms[$key])) {
            unset($this->terms[$key]);
        }
        else {
            throw new KeyInvalidException("Invalid key $key.");
        }
    }

    /**
     * Returns a Term from the collection
     * @param string $key
     * @throws KeyInvalidException
     */
    public function getTerm($key) {
        if (isset($this->terms[$key])) {
            return $this->terms[$key];
        }
        else {
            throw new KeyInvalidException("Invalid key $key.");
        }
    }
    /**
     * Returns the number of Terms in the collection
     */
    public function length() {
        return count($this->terms);
    }

    /**
     * Determines whether a given key exists in the collection
     * @param string $key
     */
    public function keyExists($key) {
        return isset($this->terms[$key]);
    }

    /**
     * Returns the keys already being in use
     */
    public function keys() {
        return array_keys($this->terms);
    }


    /**
     * Loads an .obo file and creates the HPO graph
     * @param string $filename
     */
    public function load($filename){
        // determines if the first term was read already
        $firstTermNotRead = true;
        $newTerm = null;

        $finishedTerm = false;
        // opens the hp.obo file to read
        $handle = fopen ( $filename, "r" );
        if ($handle) {
            while ( ($line = fgets ( $handle )) !== false) {
                // remove special characters from the line
                $line = trim ( str_replace ( PHP_EOL, '', $line ) );
                $line = trim ( str_replace ( '"', '', $line ) );
                // read version and format info before finding the first term
                if ($firstTermNotRead && $line != "[Term]"){
                    $words = explode ( ":", $line, 2 );
                    if ($words[0]=="format-version"){
                        $this->formatInfo=trim($words[1]);
                    }
                    if ($words[0]=="data-version"){
                        $this->version=trim($words[1]);
                    }

                }

                // if a term definition is find
                if ($line == "[Term]") {
                    $firstTermNotRead = false;


                    // if a term is already been finished
                    if ($finishedTerm) {
                        // insert the term to the ontology
                        $this->addTerm($newTerm,$newTerm->getId());

                        $finishedTerm = false;

                        //reset newTerm
                        $newTerm = new Term();


                    }// if it is a new term
                    else {
                        // create a new term object

                        $newTerm = new Term();
                        $finishedTerm = false;
                    }
                }
                // if it is a term attribute line
                if ($line != "[Term]" && strlen ( $line ) > 2) {
                    $words = explode ( ":", $line, 2 );
                    //set object id
                    if (trim($words[0])=="id"){
                        $newTerm->setId(trim($words[1]));
                    }
                    //set object name
                    if (trim($words[0])=="name"){
                        $newTerm->setName(trim($words[1]));
                    }
                    //set object def
                    if (trim($words[0])=="def"){
                        //removing "[HPO:...]"
                        $definition = explode("[",$words[1],2);

                        $newTerm->setDef(trim($definition[0]));
                    }
                    //set object comment
                    if (trim($words[0])=="comment"){
                        $newTerm->setComment(trim($words[1]));
                    }

                    //add object synonym
                    if (trim($words[0])=="synonym"){
                        $newTerm->addSynonym(trim($words[1]));
                    }
                    //add object xref
                    if (trim($words[0]) =="xref"){
                        $subString = explode ( " ", trim($words[1]), 2 );
                        //addXref(xrefId,xrefName)
                        if ( ! isset($subString[1])) {
                            $subString[1] = null;
                        }
                        $newTerm->addXref(trim($subString[0]),trim($subString[1]));
                    }
                    //add object is_a
                    if (trim($words[0])=="is_a"){
                        $subString = explode ( "!", trim($words[1]), 2 );
                        //addIs_a(is_aId,is_aName)
                        $newTerm->addIs_a(trim($subString[0]),trim($subString[1]));
                    }
                }
                // if the first term was already been read and it is an empty line
                if(!($firstTermNotRead) && strlen ( $line ) < 2){
                    //we finished a term, make it ready to insert
                    $finishedTerm = true;
                }
            }
        } else {
            // error opening the file.
        }

        // insert the term to the ontology
        $this->addTerm($newTerm,$newTerm->getId());
    }

    /**
     * Performs a search on the terms
     * @param string $subString
     * @param int $maxResults
     */
    function search($subString, $maxResults = 15){
        $resultArray = array();
        $resCount = 0;

        $resultTermsInName = array();
        $resultTermsInSynonym = array();
        $resultTermsInDescription = array();

        //if the passed value is a number or it starts with "HP:"
        if (is_numeric($subString) || substr(strtolower($subString), 0, 3) === "hp:"){

            foreach($this->terms as $t){
                //match the name
                if (strpos ( strtolower ($t->getId()), strtolower ($subString) ) !== false) {
                    $resultTermsInName[]=$t;
                    $resCount++;
                    //if the maximum element has been reached, stop the search
                    if ($resCount>=$maxResults) break;
                }
            }
        }
        // if it is not a number nor starts with "HP:"
        else {
            //check if a term starts with the substring
            foreach ($this->terms as $t){
                $length = strlen($subString);
                if (substr(strtolower($t->getName()), 0, $length) === strtolower($subString)) {
                            $resultTermsInName[]=$t;
                            $resCount++;
                            if ($resCount>=$maxResults) break;
                        }
            }

            foreach($this->terms as $t){
                //if the maximum element has been reached, stop the search
                if ($resCount>=$maxResults) break;
                //match the name
                if (strpos ( strtolower ($t->getName()), strtolower ( $subString ) ) !== false) {
                    if (!in_array($t,$resultTermsInName)){
                    $resultTermsInName[]=$t;
                    $resCount++;}
                }

                else {
                    //match synonyms
                    foreach ($t->getSynonyms() as $key=>$syns){
                        //if the maximum element has been reached, stop the search
                        if ($resCount>=$maxResults) break;
                        if (strpos ( strtolower ($syns), strtolower ( $subString ) ) !== false) {
                            $resultTermsInSynonym[]=$t;
                            $resCount++;
                        }
                    }
                }
            }
            // if there were no results in names and synonyms, nor in HPO ids, perform a search on descriptions
            if (count($resultTermsInName)==0 && count($resultTermsInSynonym)==0) {

                foreach($this->terms as $t){
                    //match the description
                    if (strpos ( strtolower ($t->getDef()), strtolower ( $subString ) ) !== false) {
                        $resultTermsInDescription[]=$t;
                        $resCount++;
                        //if the maximum element has been reached, stop the search
                        if ($resCount>=$maxResults) break;
                    }
                }
            }
        }
        $resultArray['serviceProvider']="CIT Cambridge";
        $resultArray['ontology']="Human Phenotype Ontology";
        $resultArray['ontoVersion']=$this->version;
        $resultArray['result']=$resCount;
        $resultArray['resultsInName']=$resultTermsInName;
        $resultArray['resultsInSynonym']=$resultTermsInSynonym;
        $resultArray['resultsInDescription']=$resultTermsInDescription;

        return $resultArray;
    }//end of search
    /**
     * Returns all child element of a parent term
     *
     * @param string $parentTerm
     * @return multitype:array of Terms
     */
    public function getChildren($parentTerm){
        $children = array();

        foreach ($this->terms as $t){
            //if there is at least one is_a reference
            if (count($t->getIs_aKeys())>0) {
                foreach ($t->getIs_aKeys() as $keys){
                    if ($keys==$parentTerm){
                        if (!in_array($t->getId(),$children)){
                            $children[]=$t;
                        }
                    }
                }
            }
        }
        return $children;

    }

    /**
     * Returns true if the passed term has got at least one child element
     * @param string $parentTerm
     * @return boolean
     */
    public function hasChild($parentTerm){
        $children = array();
        $children = $this->getChildren($parentTerm);
        if (empty($children)){
            return false;
        }
        return true;

    }



    /**
     * Returns the children elements of a term
     * @param string $parentTerm
     */
    public function children($parentTerm){

        $resultArray = array();
        $resCount = 0;
        $childall = $this->getChildren($parentTerm);

        $resultArray['serviceProvider']="CIT Cambridge";
        $resultArray['ontology']="Human Phenotype Ontology";
        $resultArray['ontoVersion']=$this->version;
        $resultArray['result']= count($childall);
        $resultArray['children']=$childall;

    return $resultArray;
    }//end of children

    /**
     * Returns the sub graph of the ontology excluding the parent Term
     * @param string $parentTerm
     * @return array of Terms
     */
    public function subGraph($parentTerm){
        $subGraph = array();
        $keys = array();
        //get the children elements of the parent Term

        $tempChildren = array();
        $tempChildren = $this->getChildren($parentTerm);
        for ($i=0;$i<count($tempChildren);$i++){

            $subGraph[]=$tempChildren[$i];
            $keys[] = $tempChildren[$i]->getId();
        }


        //get all the terms and their subterms
        $tempChildren = array();

        for ($i=0;$i<count($keys);$i++){
            $tempChildren = $this->getChildren($keys[$i]);

            for($j=0;$j<count($tempChildren);$j++){

                $id = $tempChildren[$j]->getId();

                if (!in_array($id,$keys)){
                    $subGraph[]=$tempChildren[$j];
                    $keys[]=$id;
                }
            }
            $tempChildren = array();
        }

        return $subGraph;
    }




}//end of class


?>