old mode 100755

new mode 100644

@@ -1,5 +1,5 @@

 Package: NetPathMiner

-Version: 0.99.0

+Version: 0.99.3

 Date: 2014 onwards

 Title: NetPathMiner for Biological Network Construction, Path Mining

         and Visualization

@@ -15,12 +15,12 @@ Description: NetPathMiner is a general framework for network path mining using

     provides static and interactive visualizations of networks and paths to aid

     manual investigation.

 Depends: igraph (>= 0.6)

-Suggests: rBiopaxParser, RCurl, RCytoscape

+Suggests: rBiopaxParser (>= 2.1), RCurl, RCytoscape

 License: GPL (>= 2)

 URL: https://github.com/ahmohamed/NetPathMiner

 NeedsCompilation: yes

-SystemRequurements: libxml2, libSBML (>= 5.5)

+SystemRequirements: libxml2, libSBML (>= 5.5)

+Biarch: TRUE

 biocViews: GraphAndNetwork, Pathways, Network, Clustering,

         Classification

-Biarch: TRUE

-Packaged: 2014-03-10 09:06:56 UTC; mohamedahmed

+Packaged: 2014-04-09 08:45:28 UTC; ahmedmohamed

@@ -66,7 +66,6 @@ check.file <- function(filename, ext=".xml"){

 #' 

 #'     # Process KGML file as a signaling network

 #'     g <- KGML2igraph(filename, parse.as="signaling", expand.complexes=TRUE)

-#'     dev.new()

 #'     plotNetwork(g)

 #' }

 #' 

@@ -97,13 +96,19 @@ KGML2igraph <- function(filename, parse.as=c("metabolic","signaling"), expand.co

                         function(x) .Call("readkgmlfile", FILENAME = x, VERBOSE=verbose)

             , USE.NAMES=FALSE), recursive=FALSE)

-        #Resolve reactions particiapting in multiple pathways

-        dup.rns = lapply(zkgml[duplicated(names(zkgml))], "[[", "miriam.kegg.pathway")

+        dup.zkgml <- duplicated(names(zkgml))

+        dup.rns <- sapply(zkgml[dup.zkgml], "[[", "miriam.kegg.pathway")

+        zkgml <- zkgml[!dup.zkgml] # Remove duplicated reactions.

+        

+        

         if(length(dup.rns)>0){

-            lapply(1:length(dup.rns), 

-                function(x) zkgml[[ names(dup.rns)[x] ]]$miriam.kegg.pathway <<- 

-                            unique( c(zkgml[[ names(dup.rns)[x] ]]$miriam.kegg.pathway, dup.rns[[x]] )

-                ))            

+            dup.rns <- split( unname(dup.rns), names(dup.rns))	# contains pathway info for removed rns.

+            zkgml[names(dup.rns)] <- mapply(

+                                    function(x, dup){

+                                        x$miriam.kegg.pathway <- c(x$miriam.kegg.pathway, dup)

+                                        return(x)

+                                    }, zkgml[names(dup.rns)], dup.rns, 

+                                    SIMPLIFY=FALSE)			

         }

     }

@@ -252,14 +257,21 @@ SBML2igraph <- function(filename, parse.as=c("metabolic","signaling"), miriam.at

         names(zsbml) <- c("reactions", "species")

         #Resolve reactions and species particiapting in multiple pathways

-        dup.rns = lapply(zsbml$reactions[duplicated(names(zsbml$reactions))], "[[", "pathway")

+        dup.zsbml <- duplicated(names(zsbml$reactions))

+        dup.rns <- sapply(zsbml$reactions[dup.zsbml], "[[", "pathway")

+        zsbml$reactions <- zsbml$reactions[!dup.zsbml] # Remove duplicated reactions.

+        

+        

         if(length(dup.rns)>0){

-            lapply(1:length(dup.rns), 

-                    function(x) zsbml$reactions[[ names(dup.rns)[x] ]]$pathway <<- 

-                                unique( c(zsbml$reactions[[ names(dup.rns)[x] ]]$pathway, dup.rns[[x]] )

-                                ))            

+            dup.rns <- split( unname(dup.rns), names(dup.rns))	# contains pathway info for removed rns.

+            zsbml$reactions[names(dup.rns)] <- mapply(

+                    function(x, dup){

+                        x$pathway <- c(x$pathway, dup)

+                        return(x)

+                    }, zsbml$reactions[names(dup.rns)], dup.rns, 

+                    SIMPLIFY=FALSE)		

         }

-    

+            

         zsbml$species <- zsbml$species[!duplicated(names(zsbml$species))]

     }

     if(verbose) message("SBML files processed successfully")

@@ -384,7 +396,9 @@ biopax2igraph <- function(biopax, parse.as=c("metabolic","signaling"),

     if (!require(rBiopaxParser))

         stop("This functions needs the rBiopaxParser library installed. Check out the installation instructions!")

     if (!("biopax" %in% class(biopax))) 

-        stop("Error: pathway2RegulatoryGraph: parameter biopax has to be of class biopax.")

+        stop("Error: biopax2igraph: parameter biopax has to be of class biopax.")

+    

+    biopax$df <- as.data.frame(biopax$dt)

     if(missing(parse.as) || parse.as=="metabolic"){

         if(biopax$biopaxlevel == 3)

             return(bpMetabolicL3(biopax, verbose))

@@ -400,6 +414,8 @@ biopax2igraph <- function(biopax, parse.as=c("metabolic","signaling"),

 bpMetabolicL3 <- function(biopax, verbose){

     if(verbose) message("Processing BioPAX (level 3) object as a metabolic network", appendLF=FALSE) 

+    to.df <- function(dt) return(as.data.frame(dt))

+    

     df <- biopax$df

     df$property = tolower(df$property)

@@ -413,9 +429,9 @@ bpMetabolicL3 <- function(biopax, verbose){

     # Metabolic reactions takes only small molecules as substrates/products.

     # The following lines removes any Biochemical reactions with non-small molecules

     #   participants.

-    classes <- listInstances(biopax,lefts[,1])

+    classes <- df[ rBiopaxParser::selectInstances(biopax, lefts[,1], returnValues=FALSE), c("class", "id")]

     sig.reactions <- lefts[match(classes$id, lefts[,1])[classes$class !="SmallMolecule"],2]

-    classes <- listInstances(biopax,rights[,2])

+    classes <- df[ rBiopaxParser::selectInstances(biopax, rights[,2], returnValues=FALSE), c("class", "id")]

     sig.reactions <- unlist(list(sig.reactions, 

                     rights[ match(classes$id, rights[,2])[classes$class !="SmallMolecule"], 1]))

@@ -432,13 +448,13 @@ bpMetabolicL3 <- function(biopax, verbose){

     XRefs <- bpGetReferences(biopax, V(graph)$name)

     names(XRefs) <- V(graph)$name

-    cat.r <- striph(selectInstances(biopax, class="Catalysis", property="controlled")$property_attr_value)

-    cat.gene <- striph(selectInstances(biopax, class="Catalysis", property="controller")$property_attr_value)

+    cat.r <- striph(to.df(rBiopaxParser::selectInstances(biopax, class="Catalysis", property="controlled"))$property_attr_value)

+    cat.gene <- striph(to.df(rBiopaxParser::selectInstances(biopax, class="Catalysis", property="controller"))$property_attr_value)

     gene.xref <- bpGetReferences(biopax, cat.gene)

     names(gene.xref) <- cat.r

-    lapply(names(gene.xref), function(x) XRefs[[x]] <<- c(XRefs[[x]],gene.xref[[x]]))

-    

+    XRefs[names(gene.xref)] <- mapply(c, XRefs[names(gene.xref)], gene.xref, SIMPLIFY=FALSE)

+

     ##############################################################

     # Getting attribute lists (name, compartment, pathway, MIRIAM)

     # For reactions (name, reactants, reactant.stoichiometry, products, product.stoichiomentry,

@@ -448,17 +464,17 @@ bpMetabolicL3 <- function(biopax, verbose){

     attr <- bpGetAnnFromXRef(df, XRefs[V(graph)$name])

     # Name attributes

-    v.names <- listInstances(biopax, id=V(graph)$name)

+    v.names <- to.df(rBiopaxParser::listInstances(biopax, id=V(graph)$name))

     v.names <- v.names[match(V(graph)$name, v.names$id), "name"]

     # Pathway attributes##########################

     ## Get Pathway name and annotations

-    pw <- listInstances(biopax, class="pathway")

+    pw <- to.df(rBiopaxParser::listInstances(biopax, class="pathway"))

     pwXRef <- bpGetReferences(biopax, pw$id)

     #pw.ann <- bpGetAnnFromXRef(df, pwXRef)

     ## Get pathway components (only reactions are returned)

-    pwcomp <- lapply(pw$id, function(x)listPathwayComponents(biopax,x, returnIDonly=TRUE))

+    pwcomp <- lapply(pw$id, function(x)rBiopaxParser::listPathwayComponents(biopax,x, returnIDonly=TRUE))

     pwcomp <- do.call("rbind", lapply(1:length(pwcomp), 

                     function(x)data.frame(id=x, comp=pwcomp[[x]])))

@@ -485,7 +501,7 @@ bpMetabolicL3 <- function(biopax, verbose){

     ## while reactions inherit them from their catalysts.

     ## Get Compartment name and annotations

-    comp <- listInstances(biopax, class="cellularLocationvocabulary", returnIDonly=TRUE)

+    comp <- rBiopaxParser::listInstances(biopax, class="cellularLocationvocabulary", returnIDonly=TRUE)

     comp.terms <- as.character(bpGetAttrbyID(df, comp, "term")$property_value)

     #compXRef <- bpGetReferences(biopax, comp)

     comp.ann <- bpGetAnnFromXRef(df, bpGetReferences(biopax, comp) )

@@ -512,7 +528,7 @@ bpMetabolicL3 <- function(biopax, verbose){

     ##Products

     products <- split(rights[,2], rights[,1], drop=TRUE)

     ##Genes

-    cat.gene.name <- listInstances(biopax,cat.gene)

+    cat.gene.name <- to.df(rBiopaxParser::listInstances(biopax,cat.gene))

     cat.gene.name <- cat.gene.name[match(cat.gene,cat.gene.name$id),"name"]

     genes <- split(cat.gene.name, cat.r, drop=TRUE)

@@ -525,7 +541,9 @@ bpMetabolicL3 <- function(biopax, verbose){

     edges <- rbind(lefts,rights)

     edges<- cbind(edges, st=NA)

-    apply(st[,c(1,4,5)], 1, function(x) edges[edges$id==x[[1]] & edges$property_attr_value==x[[2]],"st"] <<-x[[3]])

+    for(i in 1:nrow(st)){

+        edges[ edges[,1]==st[i,4] & edges[,2]==st[i,1], "st"] <- as.character(st[i,5])

+    }

     edges$st <- as.numeric(edges$st)

     r.stoic <- split(edges[1:nrow(lefts),3], edges[1:nrow(lefts),2], drop=TRUE)

@@ -594,6 +612,7 @@ bpMetabolicL3 <- function(biopax, verbose){

 bpMetabolicL2 <- function(biopax, verbose){

     if(verbose) message("Processing BioPAX (level 2) object as a metabolic network", appendLF=FALSE)

+    to.df <- function(dt) return(as.data.frame(dt))

     df <- biopax$df

     df$property = tolower(df$property)

@@ -615,13 +634,13 @@ bpMetabolicL2 <- function(biopax, verbose){

     XRefs <- bpGetReferences(biopax, V(graph)$name)

     names(XRefs) <- V(graph)$name

-    cat.r <- striph(selectInstances(biopax, class="Control", property="controlled")$property_attr_value)

-    cat.gene <- striph(selectInstances(biopax, class="Control", property="controller")$property_attr_value)

+    cat.r <- striph(to.df(rBiopaxParser::selectInstances(biopax, class="Control", property="controlled"))$property_attr_value)

+    cat.gene <- striph(to.df(rBiopaxParser::selectInstances(biopax, class="Control", property="controller"))$property_attr_value)

     gene.xref <- bpGetReferences(biopax, cat.gene, followProperties="physical-entity")#

     names(gene.xref) <- cat.r

-    lapply(names(gene.xref), function(x) XRefs[[x]] <<- c(XRefs[[x]],gene.xref[[x]]))

-    

+    XRefs[names(gene.xref)] <- mapply(c, XRefs[names(gene.xref)], gene.xref, SIMPLIFY=FALSE)

+

     ##############################################################

     # Getting attribute lists (name, compartment, pathway, MIRIAM)

     # For reactions (name, reactants, reactant.stoichiometry, products, product.stoichiomentry,

@@ -631,17 +650,17 @@ bpMetabolicL2 <- function(biopax, verbose){

     attr <- bpGetAnnFromXRef(df, XRefs[V(graph)$name])

     # Name attributes

-    v.names <- listInstances(biopax, id=V(graph)$name)

+    v.names <- to.df(rBiopaxParser::listInstances(biopax, id=V(graph)$name))

     v.names <- v.names[match(V(graph)$name, v.names$id), "name"]

     # Pathway attributes##########################

     ## Get Pathway name and annotations

-    pw <- listInstances(biopax, class="pathway")

+    pw <- rBiopaxParser::listInstances(biopax, class="pathway")

     pwXRef <- bpGetReferences(biopax, pw$id)

     #pw.ann <- bpGetAnnFromXRef(df, pwXRef)

     ## Get pathway components (only reactions are returned)

-    pwcomp <- lapply(pw$id, function(x)listPathwayComponents(biopax,x, returnIDonly=TRUE))

+    pwcomp <- lapply(pw$id, function(x)rBiopaxParser::listPathwayComponents(biopax,x, returnIDonly=TRUE))

     pwcomp <- do.call("rbind", lapply(1:length(pwcomp), 

                     function(x)data.frame(id=x, comp=pwcomp[[x]])))

@@ -668,7 +687,7 @@ bpMetabolicL2 <- function(biopax, verbose){

     ## while reactions inherit them from their catalysts.

     ## Get Pathway name and annotations

-    comp <- listInstances(biopax, class="openControlledVocabulary", returnIDonly=TRUE)#

+    comp <- rBiopaxParser::listInstances(biopax, class="openControlledVocabulary", returnIDonly=TRUE)#

     comp.terms <- as.character(bpGetAttrbyID(df, comp, "term")$property_value)

     compXRef <- bpGetReferences(biopax, comp)#

     #comp.ann <- bpGetAnnFromXRef(df, bpGetReferences(biopax, comp) )

@@ -705,7 +724,7 @@ bpMetabolicL2 <- function(biopax, verbose){

     products <- split(rights[,2], rights[,1], drop=TRUE)

     ##Genes ##totally different from level3 function

     cat.gene.ref <- bpGetAttrbyID(df,cat.gene, "physical-entity", "property_attr_value")

-    cat.gene.name <- listInstances(biopax, cat.gene.ref[,3])

+    cat.gene.name <- to.df(rBiopaxParser::listInstances(biopax, cat.gene.ref[,3]))

     cat.gene.ref$name <- cat.gene.name$name[match(striph(cat.gene.ref[,3]), cat.gene.name$id)]

     cat.gene.ref <- cat.gene.ref[match(cat.gene,cat.gene.ref$id),"name"]    

@@ -790,6 +809,7 @@ bpMetabolicL2 <- function(biopax, verbose){

 # TODO: edge attributes in signaling networks

 bpSignalingL3 <- function(biopax, expand.complexes=FALSE, inc.sm.molecules=FALSE, verbose=TRUE){

     if(verbose) message("Processing BioPAX (level 3) object as a signaling network", appendLF=FALSE) 

+    to.df <- function(dt) return(as.data.frame(dt))

     df <- biopax$df

     df$property = tolower(df$property)

@@ -803,15 +823,15 @@ bpSignalingL3 <- function(biopax, expand.complexes=FALSE, inc.sm.molecules=FALSE

     # Identifying Metabolic and signaling reactions.

     # Metabolic reactions takes only small molecules as substrates/products.

     # Signaling reactions have at least one non-small-molecule participant.  

-    classes.left <- listInstances(biopax,lefts[,1])

+    classes.left <- df[ rBiopaxParser::selectInstances(biopax, lefts[,1], returnValues=FALSE), c("class", "id")]

     sig.reactions <- lefts[match(classes.left$id, lefts[,1])[classes.left$class !="SmallMolecule"],2]

-    classes.right <- listInstances(biopax,rights[,2])

+    classes.right <- df[ rBiopaxParser::selectInstances(biopax, rights[,2], returnValues=FALSE), c("class", "id")]

     sig.reactions <- unlist(list(sig.reactions, 

                     rights[ match(classes.right$id, rights[,2])[classes.right$class !="SmallMolecule"], 1]))

-    controlled <- striph(selectInstances(biopax, class="Catalysis", property="controlled")$property_attr_value)

-    controller <- striph(selectInstances(biopax, class="Catalysis", property="controller")$property_attr_value)

+    controlled <- striph(to.df(rBiopaxParser::selectInstances(biopax, class="Catalysis", property="controlled"))$property_attr_value)

+    controller <- striph(to.df(rBiopaxParser::selectInstances(biopax, class="Catalysis", property="controller"))$property_attr_value)

     # Metabolic reactions are represented in signaling networks by their "Controller"

@@ -865,7 +885,7 @@ bpSignalingL3 <- function(biopax, expand.complexes=FALSE, inc.sm.molecules=FALSE

     sig.vertices <- unique(all.sig)

     # Combining the signaling reactions with the metabolic one.

-    graph <- graph + vertices(sig.vertices[!sig.vertices %in% V(graph)$name]) + igraph::edges(all.sig) 

+    graph <- graph + vertices(sig.vertices[!sig.vertices %in% V(graph)$name], attr=list(list())) + igraph::edges(all.sig) 

     if(expand.complexes){

         comsp <- bpSplitComplex(biopax,V(graph)$name, inc.sm.molecules)

@@ -887,22 +907,22 @@ bpSignalingL3 <- function(biopax, expand.complexes=FALSE, inc.sm.molecules=FALSE

     attr <- bpGetAnnFromXRef(df, XRefs[V(graph)$name])

     # Name attributes

-    v.names <- listInstances(biopax, id=V(graph)$name)

+    v.names <- to.df(rBiopaxParser::listInstances(biopax, id=V(graph)$name))

     v.names <- v.names[match(V(graph)$name, v.names$id), "name"]

     ## Get Pathway name and annotations

-    pw <- listInstances(biopax, class="pathway")

+    pw <- to.df(rBiopaxParser::listInstances(biopax, class="pathway"))

     pwXRef <- bpGetReferences(biopax, pw$id)

     ## Get pathway components (only reactions are returned)

-    pwcomp <- lapply(pw$id, function(x)listPathwayComponents(biopax,x, returnIDonly=FALSE))

+    pwcomp <- lapply(pw$id, function(x) rBiopaxParser::listPathwayComponents(biopax,x, returnIDonly=TRUE))

     pwcomp <- do.call("rbind", lapply(1:length(pwcomp), 

                     function(x)data.frame(id=x, comp=pwcomp[[x]])))

     ## Restrict Pathway components to Conversion reactions (Removing PathwayStep, Control).

-    pwcomp <- pwcomp[pwcomp$comp.class %in% c("Conversion", getSubClasses("Conversion", biopaxlevel=3)) ,]

+    pwcomp <- pwcomp[pwcomp$comp %in% rBiopaxParser::listInstances(biopax, class="Conversion", includeSubClasses=TRUE, returnIDonly=TRUE),]

-    pwcomp <- split(pwcomp$id, pwcomp$comp.id, drop=TRUE)

+    pwcomp <- split(pwcomp$id, pwcomp$comp, drop=TRUE)

     ## Since Conversions (reactions) are no longer present in the network 

     #   (either their controllers or substrate/products are retained), vertices inherit

@@ -922,7 +942,7 @@ bpSignalingL3 <- function(biopax, expand.complexes=FALSE, inc.sm.molecules=FALSE

     ## Compartment attributes #######################

     ### Get Compartment name and annotations

-    comp <- listInstances(biopax, class="cellularLocationvocabulary", returnIDonly=TRUE)

+    comp <- rBiopaxParser::listInstances(biopax, class="cellularLocationvocabulary", returnIDonly=TRUE)

     comp.terms <- as.character(bpGetAttrbyID(df, comp, "term")$property_value)

     comp.ann <- bpGetAnnFromXRef(df, bpGetReferences(biopax, comp) )

@@ -1005,7 +1025,7 @@ bpSplitComplex<-function (biopax, complexid, inc.sm.molecules)

         return(NULL)

     ref = do.call("rbind", lapply( na.omit(names(ref)), function(x) cbind( x, striph(ref[[x]]) ) ) )

-    referenced = listInstances(biopax, id = unique(ref[,2]))

+    referenced = biopax$df[rBiopaxParser::selectInstances(biopax, id = unique(ref[,2]), returnValues=FALSE), c("class", "id")]

     sel = referenced[ tolower(referenced$class) %in% classes, "id"]

     if (length(sel)==0) 

         return(NULL)

@@ -246,7 +246,7 @@ vertexDeleteReconnect <- function(graph, vids, reconnect.threshold=vcount(graph)

     #Get Actual shortest paths for vertices that passed the threshold, to copy edge attributes.

     attr <- NULL

     if(!is.null(copy.attr)){

-        paths <- mapply(function(from, to) get.shortest.paths(graph.sub, from, to, output="both",mode="out")$vpath,

+        paths <- mapply(function(from, to) igraph::get.shortest.paths(graph.sub, from, to, output="both",mode="out")$vpath,

                         new.edges[1,], new.edges[2,])

         if(!is.list(copy.attr)) copy.attr <- sapply(list.edge.attributes(graph.sub), function(x)copy.attr)

@@ -374,7 +374,9 @@ expandComplexes <- function(graph, v.attr,

     }

     gout <- setAttribute(gout, v.attr, V(gout)$name)

-    lapply(list.edge.attributes(graph), function(x) gout<<-set.edge.attribute(gout, x, value=get.edge.attribute(graph, x)[z$e.parents] ))

+    for(i in list.edge.attributes(graph)){

+        gout <- set.edge.attribute(gout, i, value=get.edge.attribute(graph, i)[z$e.parents] )

+    }

     return(gout);

 }

@@ -98,7 +98,9 @@ setAttribute <- function(graph, attr.name, attr.value){

     if(is.null(attr))

         attr<-rep(list(list()), vcount(graph))    #initialize the attr as lists.

-    lapply(1:vcount(graph), function(i) attr[[i]][attr.name] <<- attr.value[i])

+    attr <- mapply(function(attr_, attr_val){

+                        attr_[[attr.name]] <- attr_val; return(attr_);

+                    }, attr, attr.value, SIMPLIFY=FALSE)

     V(graph)$attr <- attr

     return(graph)

 }

@@ -113,8 +115,8 @@ setAttribute <- function(graph, attr.name, attr.value){

 rmAttribute <- function(graph, attr.name){

     if(is.null(V(graph)$attr))

         stop("Graph is not annotated.")

-

-    lapply(1:vcount(graph), function(i) V(graph)$attr[[i]][attr.name] <<- NULL)

+    

+    V(graph)$attr <- lapply(V(graph)$attr, function(x) {x[[attr.name]] <- NULL; return(x);})

     return(graph)

 }

@@ -188,7 +190,7 @@ stdAttrNames <- function(graph, return.value=c("matches", "graph")){

 fetchAttribute <- function(graph, organism="Homo sapiens", target.attr, source.attr, bridge.web=NPMdefaults("bridge.web")){

     if(!require(RCurl))

         stop("This function uses RCurl package. Required package not installed.")

-    if(!url.exists(bridge.web))

+    if(!RCurl::url.exists(bridge.web))

         stop("Couldn't access BridgeDB webservice.\nThere may be a internet connection problem, or the server is down.")    

     if(!organism %in% NPMdefaults("bridge.organisms"))

         stop(organism, " is not supported. Here are supported organisms:\n",

@@ -228,7 +230,7 @@ fetchAttribute <- function(graph, organism="Homo sapiens", target.attr, source.a

                         ))

         uris = paste(base.urls[i],"/", unique(s.attr[,2]), "?dataSource=", t.code,sep="")

-        query = lapply(getURI(uris, async=TRUE, verbose=TRUE), 

+        query = lapply(RCurl::getURI(uris, async=TRUE, verbose=TRUE), 

                     function(x) if(x!="") as.character(read.table(text=x)$V1) )

         s.attr[,2] <- match(s.attr[,2], unique(s.attr[,2]))

@@ -422,7 +424,7 @@ assignEdgeWeights <- function(microarray, graph, use.attr, y, weight.method="com

         # Add missing values.

         if(length(missing)>0){

             missing.val <- ms.func(na.omit(edge.weights[!samegenes,1]))

-            edge.weight <- rbind(edge.weights,cbind(edge.weights=NA, id=missing))            

+            edge.weights <- rbind(edge.weights,cbind(edge.weights=missing.val, id=missing))            

         }

         # Complexes

@@ -577,7 +579,10 @@ toGraphNEL<- function(graph, export.attr=""){

     attr.names  <- grep(export.attr, attr.names, value=TRUE)

     new.graph <- remove.vertex.attribute(graph, "attr")

-    lapply(attr.names, function(x) new.graph <<- set.vertex.attribute(new.graph, x, value=getAttribute(graph, x)))

+    

+    for(i in attr.names){

+        new.graph <- set.vertex.attribute(new.graph, i, value=getAttribute(graph, i))

+    }

     return(igraph.to.graphNEL(new.graph))

 }

@@ -47,6 +47,9 @@

 pathsToBinary <- function(ypaths) {

   makeBin <- function(pathGenes,allGenes) return(as.numeric(allGenes %in% pathGenes$genes))

+  if(length(ypaths$path)==0){

+    stop("ypaths is a an empty list. Please rerun pathRanker with different parameters.")

+  }

   # if there are response labels

   if (!is.null(names(ypaths$paths))) { 

     all.genes <- c()

@@ -56,6 +59,8 @@ pathsToBinary <- function(ypaths) {

     resp <- c()

     for (p in 1:length(ypaths$paths)) {

+      if(length(ypaths$paths[[p]])==0) next;

+      

       binpaths <- data.frame(t(sapply(ypaths$paths[[p]],makeBin,allGenes = all.genes)))

       names(binpaths) <- all.genes

@@ -48,11 +48,11 @@

 #' 

 #' 	## Get ranked paths using probabilistic shortest paths.

 #'  ranked.p <- pathRanker(rgraph, method="prob.shortest.path", 

-#' 					K=20, minPathSize=6)

+#' 					K=20, minPathSize=8)

 #' 	

 #' 	## Convert paths to binary matrix. 

 #' 	ybinpaths <- pathsToBinary(ranked.p)

-#' 	p.cluster <- pathCluster(ybinpaths, M=3)

+#' 	p.cluster <- pathCluster(ybinpaths, M=2)

 #' 	plotClusters(ybinpaths, p.cluster)

 #'  

 pathCluster <- function(ybinpaths, M, iter=1000) {

@@ -149,11 +149,11 @@ pathCluster <- function(ybinpaths, M, iter=1000) {

 #' 

 #' 	## Get ranked paths using probabilistic shortest paths.

 #'  ranked.p <- pathRanker(rgraph, method="prob.shortest.path", 

-#' 					K=20, minPathSize=6)

+#' 					K=20, minPathSize=8)

 #' 	

 #' 	## Convert paths to binary matrix. 

 #' 	ybinpaths <- pathsToBinary(ranked.p)

-#' 	p.cluster <- pathCluster(ybinpaths, M=3)

+#' 	p.cluster <- pathCluster(ybinpaths, M=2)

 #' 

 #' 	## just an example of how to predict cluster membership.

 #' 	pclust.pred <- predictPathCluster(p.cluster,ybinpaths$paths)

@@ -217,11 +217,11 @@ predictPathCluster <- function(pfit,newdata) {

 #' 

 #' 	## Get ranked paths using probabilistic shortest paths.

 #'  ranked.p <- pathRanker(rgraph, method="prob.shortest.path", 

-#' 					K=20, minPathSize=6)

+#' 					K=20, minPathSize=8)

 #' 	

 #' 	## Convert paths to binary matrix. 

 #' 	ybinpaths <- pathsToBinary(ranked.p)

-#' 	p.cluster <- pathCluster(ybinpaths, M=3)

+#' 	p.cluster <- pathCluster(ybinpaths, M=2)

 #' 	plotPathCluster(ybinpaths, p.cluster, m=2, tol=0.05)

 #'  

 plotPathCluster <- function(ybinpaths, clusters, m, tol = NULL) {

@@ -377,12 +377,12 @@ plotClusterProbs <- function(clusters, col=rainbow(clusters$params$M)){

 #' 

 #' 	## Get ranked paths using probabilistic shortest paths.

 #'  ranked.p <- pathRanker(rgraph, method="prob.shortest.path", 

-#' 					K=20, minPathSize=6)

+#' 					K=20, minPathSize=8)

 #' 	

 #' 	## Convert paths to binary matrix. 

 #' 	ybinpaths <- pathsToBinary(ranked.p)

-#' 	p.cluster <- pathCluster(ybinpaths, M=3)

-#' 	plotClusters(ybinpaths, p.cluster, col=c("red", "green", "blue") )

+#' 	p.cluster <- pathCluster(ybinpaths, M=2)

+#' 	plotClusters(ybinpaths, p.cluster, col=c("red", "blue") )

 #'  

 plotClusters <- function(ybinpaths, clusters, col,...){

 	if(missing(col)) 

@@ -97,17 +97,19 @@ extractPathNetwork <- function(paths, graph){

 #' 

 getPathsAsEIDs <- function(paths, graph){

     if(length(paths$y.labels)>1){

-        eids = lapply(paths$paths, getPaths, graph, paths$source.net)            

+        eids <- lapply(paths$paths, getPaths, graph, paths$source.net)            

         names(eids) = paths$y.labels

     }else{

-        eids = getPaths(paths$paths, graph, paths$source.net)        

+        eids <- getPaths(paths$paths, graph, paths$source.net)        

     }

     return(eids)

 }        

 getPaths <- function(paths, graph, source.net){

+    if(length(paths)==0) return(list())

+

     # graph source unknown

     if(is.null(graph$type) || is.null(source.net))

         return(lapply(paths, function(x) E(graph,path=x$genes)))

@@ -138,7 +140,7 @@ getPaths <- function(paths, graph, source.net){

     # It must be MR.graph

     eid <- list()

     for(i in 1:length(paths)){

-        deleted.edges = unlist(lapply(lapply(grep("->",paths[[i]]$compounds),

+        deleted.edges <- unlist(lapply(lapply(grep("->",paths[[i]]$compounds),

                                 function(x) unlist(strsplit(paths[[i]]$compounds[[x]], "->"))), 

                         function(y) mapply(

                                     function(from,to)get.shortest.paths(graph, from, to, mode="out", output="epath"), 

@@ -289,15 +291,24 @@ rankShortestPaths <- function(graph, K=10, minPathSize=1, start, end, normalize

                 K=K,minpathsize = minPathSize+2)    #add 2 nodes to min path length ("s" & "t")

+                

         idx <- which(sapply(ps,is.null))        

         if (length(idx)>0) ps <- ps[-idx]

+        if(length(ps)==0){

+            if(ncol(pg$weights) > 1)

+                message("  Warning:Counldn't find paths matching the criteria for ",graph$y.labels[i])

+            else message("  Warning:Counldn't find paths matching the criteria.")

+        }

         ps <- ps[order(sapply(ps,"[[", "distance"))] #order paths by distance

-        if (ncol(pg$weights) > 1) zret[[i]] <- ps

-        else zret <- ps

+        if (ncol(pg$weights) > 1){

+            zret[[i]] <- ps

+        }else zret <- ps

     }

+    if(length(zret)==0)return(NULL)

+    

     if (ncol(pg$weights) > 1) {

         names(zret) <- graph$y.labels

         colnames(pg$weights) <- paste("prob",graph$y.labels,sep = ":")

@@ -472,9 +483,12 @@ processNetwork <- function(graph, start, end, scale=c("ecdf", "rescale"), normal

     edge.weights <- do.call("rbind", as.list(E(graph)$edge.weights))

     if(sum(!is.finite(edge.weights))>0){

         warning("Edge weights contain non-finite numbers. Setting them to the minimum edge weight")

-        lapply(1:ncol(edge.weights), function(x) 

-                    edge.weights[,x][!is.finite(edge.weights[,x])] <<- min(edge.weights[,x][is.finite(edge.weights[,x])])

-            )        

+        

+        edge.weights <- apply(edge.weights, 2, 

+                            function(x){

+                                x[ !is.finite(x) ] <- min( x[ is.finite(x) ] )

+                                return(x)

+                            })        

     }

     if(scale=="ecdf")

@@ -277,19 +277,20 @@ layoutVertexByAttr <- function(graph, attr.name, cluster.strength = 1,layout=lay

 colorVertexByAttr <- function(graph, attr.name, col.palette = palette()){

     attr <- getAttribute(graph, attr.name)

     attr <- do.call("rbind", lapply(1:length(attr), 

-                    function(i) cbind(id=i, val=if(length(attr[[i]])==0) NA else attr[[i]] )))

+                    function(i) data.frame(id=i, val=if(length(attr[[i]])==0) NA else attr[[i]] )))

+    

+    attr$val <- as.factor(attr$val)

-    rownames(attr) <- as.character(attr[,2]) 

-    attr.vals <- na.omit(unique(attr[,2]))

     if(!is.function(col.palette))

         col.palette <- colorRampPalette(col.palette)

-    col <- col.palette(length(attr.vals) + 1)

-    

+    col <- col.palette(nlevels(attr$val) + 1)

+    names(col) <- c(levels(attr$val), "NA_value_color")

+

+    col.vector <- col[attr$val]

+    col.vector[is.na(col.vector)] <- col[["NA_value_color"]] 

-    lapply(1:length(attr.vals), function(i) attr[attr[,2]==attr.vals[[i]] ,2] <<- col[[i]])

-    attr[is.na(attr[,2]), 2] <- col[[length(attr.vals) + 1]]

-    return(split(attr[,2], as.numeric(attr[,1])))

+    return( split(col.vector, as.numeric(attr$id)) )

 }

 #' Plots an annotated igraph object in Cytoscape.

@@ -335,23 +336,27 @@ plotCytoscape <- function(graph, title, layout=layout.auto,

         V(graph)$color <- vertex.color

     nel <- igraph.to.graphNEL(graph)

-    nel <- initEdgeAttribute(nel, "weight", "numeric", 1)

+    nel <- RCytoscape::initEdgeAttribute(nel, "weight", "numeric", 1)

     ## Initializing vertex attributes

     v.attrs <- sapply(list.vertex.attributes(graph), function(x) is.numeric(get.vertex.attribute(graph,x)))

-    mapply(function(...) nel<<-initNodeAttribute(nel,...), names(v.attrs), 

-            ifelse(v.attrs, "numeric", "char"), 

-            ifelse(v.attrs, 1, ""))

+    for(i in 1:length(v.attrs)){

+        nel <- RCytoscape::initNodeAttribute(nel, names(v.attrs)[[i]],

+                                ifelse(v.attrs[[i]], "numeric", "char"),

+                                ifelse(v.attrs, 1, ""))

+    }

     e.attrs <- sapply(list.edge.attributes(graph), function(x) is.numeric(get.edge.attribute(graph,x)))

-    mapply(function(...) nel<<-initEdgeAttribute(nel,...), names(e.attrs), 

-            ifelse(e.attrs, "numeric", "char"), 

-            ifelse(e.attrs, 1, ""))

-    

-    cw <- new.CytoscapeWindow (title, graph=nel)

-    displayGraph(cw)

-    setNodePosition(cw, V(graph)$name, layout[,1], layout[,2])

-    redraw(cw)

+    for(i in 1:length(e.attrs)){

+        nel <- RCytoscape::initEdgeAttribute(nel, names(e.attrs)[[i]],

+                ifelse(e.attrs[[i]], "numeric", "char"),

+                ifelse(e.attrs, 1, ""))

+    }

+    

+    cw <- RCytoscape::new.CytoscapeWindow (title, graph=nel)

+    RCytoscape::displayGraph(cw)

+    RCytoscape::setNodePosition(cw, V(graph)$name, layout[,1], layout[,2])

+    RCytoscape::redraw(cw)

     #v.size

     if(!missing(vertex.size)){

         if(length(vertex.size)==1)

@@ -359,24 +364,24 @@ plotCytoscape <- function(graph, title, layout=layout.auto,

         vertex.size <- as.integer(vertex.size)

         if(length(vertex.size) == vcount(graph)){

-            setNodeSizeDirect(cw, as.character(V(graph)$name), vertex.size)

+            RCytoscape::setNodeSizeDirect(cw, as.character(V(graph)$name), vertex.size)

         }else

             warning("Vertex sizes length and number of vertices don't match")

     }else if(!is.null(V(graph)$size)){

-        setNodeSizeDirect(cw, as.character(V(graph)$name), as.integer(V(graph)$size))

+        RCytoscape::setNodeSizeDirect(cw, as.character(V(graph)$name), as.integer(V(graph)$size))

     }

     #v.label

     if(!missing(vertex.label)){

         vertex.label <- as.character(vertex.label)

         if(length(vertex.label) == vcount(graph)){

-            setNodeLabelDirect(cw, as.character(V(graph)$name), vertex.label)

+            RCytoscape::setNodeLabelDirect(cw, as.character(V(graph)$name), vertex.label)

         }else

             warning("Vertex lebels length and number of vertices don't match")

     }else if(!is.null(V(graph)$label)){

-        setNodeLabelDirect(cw, as.character(V(graph)$name),as.character(V(graph)$label))

+        RCytoscape::setNodeLabelDirect(cw, as.character(V(graph)$name),as.character(V(graph)$label))

     }

     #v.shape

@@ -391,12 +396,12 @@ plotCytoscape <- function(graph, title, layout=layout.auto,

             vertex.shape <- rep(vertex.shape, vcount(graph))

         if(length(vertex.shape) == vcount(graph)){

-            setNodeShapeDirect(cw, as.character(V(graph)$name), vertex.shape)

+            RCytoscape::setNodeShapeDirect(cw, as.character(V(graph)$name), vertex.shape)

         }else

             warning("Vertex shapes length and number of vertices don't match")

     }else if(!is.null(V(graph)$shape)){

-        setNodeShapeDirect(cw, as.character(V(graph)$name),igraphShape2Cyto(V(graph)$shape))

+        RCytoscape::setNodeShapeDirect(cw, as.character(V(graph)$name),igraphShape2Cyto(V(graph)$shape))

     }

     #v.color

@@ -409,15 +414,15 @@ plotCytoscape <- function(graph, title, layout=layout.auto,

         if(length(vertex.color) == vcount(graph)){

             vertex.color <- split(V(graph)$name, vertex.color)

             names(vertex.color) <- col2hex(names(vertex.color))            

-            lapply(names(vertex.color), function(x) setNodeColorDirect(cw, as.character(vertex.color[[x]]), x))

-        }else

+            lapply(names(vertex.color), function(x) RCytoscape::setNodeColorDirect(cw, as.character(vertex.color[[x]]), x))

+        }else{

             warning("Vertex colors length and number of vertices don't match")

-        

+        }

     }else if(!is.null(V(graph)$color)){

         vertex.color <- split(V(graph)$name, V(graph)$color)

         names(vertex.color) <- col2hex(names(vertex.color))

-        lapply(names(vertex.color), function(x) setNodeColorDirect(cw, as.character(vertex.color[[x]]), x))

+        lapply(names(vertex.color), function(x) RCytoscape::setNodeColorDirect(cw, as.character(vertex.color[[x]]), x))

     }

     #e.color

@@ -427,16 +432,16 @@ plotCytoscape <- function(graph, title, layout=layout.auto,

             edge.color <- rep(edge.color, ecount(graph))

         if(length(edge.color) == ecount(graph)){

-            setEdgeAttributesDirect(cw, "color", "char", cy2.edge.names(cw@graph), edge.color)

-            setEdgeColorRule(cw, "color", unique(edge.color),unique(edge.color), mode="lookup")

+            RCytoscape::setEdgeAttributesDirect(cw, "color", "char", cy2.edge.names(cw@graph), edge.color)

+            RCytoscape::setEdgeColorRule(cw, "color", unique(edge.color),unique(edge.color), mode="lookup")

         }else

             warning("Edge colors length and number of vertices don't match")

     }else if(!is.null(E(graph)$color)){

-        setEdgeColorRule(cw, "color", unique(E(graph)$color),unique(col2hex(E(graph)$color)), mode="lookup")

+        RCytoscape::setEdgeColorRule(cw, "color", unique(E(graph)$color),unique(col2hex(E(graph)$color)), mode="lookup")

     }

-    redraw(cw)    

+    RCytoscape::redraw(cw)    

     return(cw)

 }

@@ -27,7 +27,7 @@ may be missing. To install libxml2 and the headers:

 ##### Installing libSBML 

 Installing libSBML for Unix users is optional. However, NetPathMiner will not be able to process SBML

-files. If you will not use them, you can skip this part. 

+files. If you will not use SBML functions, you can skip this part. 

 From the website of libSBML http://sbml.org/Software/libSBML, you can directly download the

 binaries suitable for your system from ``Download libSBML'' link. You can follow the installation instructions

@@ -36,7 +36,7 @@ on the website.

 #### Prerequisites for Windows users

 Since installing libxml2 and libSBML under Windows is challenging, we have prepared all dependencies in 

 a tar file, downloadable from https://github.com/ahmohamed/NPM_dependencies . Please download the file

-and place in in the home directory of R (type <code>R HOME</code> in command prompt to locate it). Unless

+and place in in the home directory of R (type <code>R RHOME</code> in command prompt to locate it). Unless

 you want to use customized libraries, you can skip the rest of this section.

 To use customized libraries, you have to compile them and provide them to R at the time of installation.

@@ -66,7 +66,7 @@ Add `mingw/bin` to your PATH, by editing eviroment variables.

 Second, you need CMake http://www.cmake.org/ . You can follow the instructions at http://sbml.org/Software/libSBML/docs/java-api/libsbml-installation.html#windows-configuring , however, choose "MinGW Makefiles" instead of "Visual Studio 10".

 After finishing the CMake step, use the MinGW's `make.exe` to compile libSBML. Copy the dependencies you used

-during the cimpilation to the `bin` directory. Set the enviroment variable `LIBSBML` to point the installation 

+during the compilation to the `bin` directory. Set the enviroment variable `LIB_SBML` to point the installation 

 directory, which should now contain dll files inder `bin` and header files under `include`

@@ -95,10 +95,12 @@ To install R package devtools call:

 ##### RCurl

 For Unix users, make sure your Linux has library libcurl installed. Check out:

+

 <code>

-    locate libcurl

+    locate libcurl   

     locate curl-config

 </code>

+

 If these are not found (usually the developer version is missing), most Linux

 users will be able to fix this by running:

 <code>

@@ -124,20 +126,22 @@ call:

 to install it right away.

 ##### RCytoscape

-Package RCytoscapeis available on Bioconductor. For installation instructions check 

-out http://www.bioconductor.org/packages/release/bioc/html/RCytoscape.html or

-call:

+Package RCytoscape is available on Bioconductor. For installation instructions check 

+out http://www.bioconductor.org/packages/release/bioc/html/RCytoscape.html . Please note 

+that RCytoscape requires Cytoscape 2.8 installed with XMLRPC plugin. Cytoscape 3 is not yet 

+supported. After installing Cytoscape, call:

+

 <code>

-    source("http://bioconductor.org/biocLite.R")

+    source("http://bioconductor.org/biocLite.R")   

     biocLite("RCytoscape")

 </code>

-to install it right away.

+to install RCytoscape.

 ### NetPathMiner InstallationS

 If everything went well you will be able to install the NetPathMiner package from GitHub using devtools:

 <code>

-    library(devtools)

+    library(devtools)   

     install_github(repo="NetPathMiner", username="ahmohamed")

 </code>

@@ -2,21 +2,9 @@

 echo "removing boost headers..."

 cd src; rm -rf boost

-if test -f kgml_interface.c__;

-	then mv kgml_interface.c__ kgml_interface.cpp; 

-fi;

-

-if test -f sbml_interface.c__;

-	then mv sbml_interface.c__ sbml_interface.cpp; 

-fi;

-

-if test -f sbml_interface.h__;

-	then mv sbml_interface.h__ sbml_interface.h; 

-fi;

-

 echo "restoring Makevars.in file..."

 mv _Makevars.in_ Makevars.in; 

 rm Makevars

 echo "removing compiled code..."

-rm *.o

\ No newline at end of file

+rm *.o

old mode 100644

new mode 100755

@@ -3,29 +3,12 @@ cd src;

 echo "removing boost headers..."

 rm -rf boost

-if test -f kgml_interface.c__;

-	then mv kgml_interface.c__ kgml_interface.cpp; 

-fi;

-

-if test -f sbml_interface.c__;

-	then mv sbml_interface.c__ sbml_interface.cpp; 

-fi;

-

-if test -f sbml_interface.h__;

-	then mv sbml_interface.h__ sbml_interface.h; 

-fi;

-

 echo "restoring handelsegfault file..."

-if test -f handlesegfault.c__;

-	then 

-		mv handlesegfault.c handlesegfault.cwin;

-		mv handlesegfault.c__ handlesegfault.c; 

-fi;

-if test -f Makevars.win_;

+if test -f Makevars.win;

 	then 

-		mv Makevars.win_ Makevars.win;

+		rm Makevars.win;

 fi;

@@ -2905,17 +2905,18 @@ fi

 		if test -n "${SBMLPC}"

 			then

 				echo "libsbml.pc found. Using pkg-config to extract it."

-				SBML_INCDIR=`${PKG_CONFIG} --cflags ${SBMLPC}`

+				SBML_INCDIR="-DHAVE_SBML `${PKG_CONFIG} --cflags ${SBMLPC}`"

 				SBML_LIBS=`${PKG_CONFIG} --libs ${SBMLPC}`

 			else

 				echo "Couldn't find libsbml.pc. Searching for libsbml in candidate directories."

 				if test -d /usr/include/sbml

-					then SBML_INCDIR="-I/usr/include/"

+					then SBML_INCDIR="-DHAVE_SBML -I/usr/include/"

 					else

 						if test -d /usr/local/include/sbml

-							then SBML_INCDIR="-I/usr/local/include/"

+							then SBML_INCDIR="-DHAVE_SBML -I/usr/local/include/"

 						fi;

 				fi;

+		fi;

 	for ac_prog in xml2-config

 do

@@ -2962,12 +2963,11 @@ fi

   test -n "$XML_CONFIG" && break

 done

-	LIBXML_INCDIR=`${XML_CONFIG} --cflags`

+	LIBXML_INCDIR="-DHAVE_XML `${XML_CONFIG} --cflags`"