351:   path <- merge(merge1, symb, by = "gene")

65:     pathTable <- unique(keggPathwayDB(org_assembly))

71:     pathfreq <- as.data.frame(table(annot$pathway))

99:     pathT <- as.character(freq$Var1[enrich])

118:     pathways <- data.frame(unique(pathT))

203:     pathTable <- unique(reactomePathwayDB(org_assembly))

209:     pathfreq <- as.data.frame(table(annot$pathway))

235:     pathT <- as.character(freq$Var1[enrich])

540:   pathTable <- unique(WikiPathwayDB(org_assembly))

545:   pathfreq <- as.data.frame(table(annot$pathID))

571:   pathT <- as.character(freq$Var1[enrich])

578:   pathTerms <- as.character(r$pathTerm[match(pathT, r$pathID)])

628: pathwayEnrichment <- function(genes,

678:   pathfreq <- as.data.frame(table(annot$pathTerm))

710:   pathT <- as.character(freq$Var1[enrich])

718:   pathTerms <- as.character(r$pathTerm[match(pathT, r$pathID)])

270: reactomePathwayDB <- function(org_assembly = c("hg19",

357: keggPathwayDB <- function(org_assembly = c("hg19",

433: WikiPathwayDB <- function(org_assembly = c("hg19",

15: #' @param gmtFile File path of the gmt file

91:         file.path(x[1], x[2]))

95:         file.path(x[1], x[2]))

155: #' @param gmtFile File path of the gmt file

228:       file.path(x[1], x[2]))

231:       file.path(x[1], x[2]))

353:   return(path)

499: #' @param gmtFile File path of the gmt file

563:       file.path(x[1], x[2]))

567:       file.path(x[1], x[2]))

608: #' @param gmtFile File path of the gmt file

703:     file.path(x[1], x[2]))

706:     file.path(x[1], x[2]))

1: #' KEGG pathway enrichment

22: #' @return KEGG pathway enrichment results

68:     annot <- pathTable[which(pathTable$symbol %in% genes$g),]

72:     pathfreq <- pathfreq[which(pathfreq$Freq > 0),]

75:     geneSize = length(unique(pathTable$symbol))

77:     bckfreq <- as.data.frame(table(pathTable$pathway))

78:     notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]

79:     freq <- merge(pathfreq, notGene, by = "Var1")

104:     r <- annot[annot$pathway %in% pathT,]

106:     for (i in seq_along(pathT))

108:       if (length(which(pathT[i] == r$pathway)) > 0)

113:               as.character(r[which(pathT[i] == r$pathway),]$symbol)),

114:                      paste(pathT[i])))

119:     tmp <- character(length(pathT))

120:     if (nrow(pathways) > 0) {

122:         unlist(lapply(seq_len(nrow(pathways)), function(x)

123:           tmp[x] <- try(KEGGREST::keggGet(pathT[x])[[1]]$NAME)

129:         ID = pathT,

141: #' Reactome pathway enrichment

163: #' @return Reactome pathway enrichment results

206:     annot <- pathTable[which(pathTable$symbol %in% genes$g),]

210:     pathfreq <- pathfreq[which(pathfreq$Freq > 0),]

212:     geneSize = length(unique(pathTable$symbol))

214:     bckfreq <- as.data.frame(table(pathTable$pathway))

215:     notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]

216:     freq <- merge(pathfreq, notGene, by = "Var1")

240:     r <- annot[annot$pathway %in% pathT,]

244:     for (i in seq_along(pathT))

246:       if (length(which(pathT[i] == r$pathway)) > 0)

251:               list(as.character(r[which(pathT[i] == r$pathway),]$symbol)),

252:                      paste(pathT[i])))

258:         ID = pathT,

259:         Term = as.character(rt[order(match(rt$pathway, pathT)), ]$name),

279:   table1 <- data.frame(pathway = rep(names(xx), lapply(xx, length)),

282:   pn <- data.frame(pathway = rep(names(pn), lapply(pn, length)),

288:     ty <- table1[grepl("^R-HSA", table1$pathway),]

289:     pn1 <- pn[grepl("^R-HSA", pn$pathway),]

296:     ty <- table1[grepl("^R-MMU", table1$pathway),]

297:     pn1 <- pn[grepl("^R-MMU", pn$pathway),]

304:     ty <- table1[grepl("^R-DRE", table1$pathway),]

305:     pn1 <- pn[grepl("^R-DRE", pn$pathway),]

312:     ty <- table1[grepl("^R-RNO", table1$pathway),]

313:     pn1 <- pn[grepl("^R-RNO", pn$pathway),]

320:     ty <- table1[grepl("^R-CEL", table1$pathway),]

321:     pn1 <- pn[grepl("^R-CEL", pn$pathway),]

328:     ty <- table1[grepl("^R-SCE", table1$pathway),]

329:     pn1 <- pn[grepl("^R-SCE", pn$pathway),]

342:     ty <- table1[grepl("^R-DME", table1$pathway),]

343:     pn1 <- pn[grepl("^R-DME", pn$pathway),]

349:                   by = "pathway",

369:     kegg <- org.Hs.eg.db::org.Hs.egPATH2EG

377:     kegg <- org.Mm.eg.db::org.Mm.egPATH2EG

385:     kegg <- org.Dr.eg.db::org.Dr.egPATH2EG

393:     kegg <- org.Rn.eg.db::org.Rn.egPATH2EG

401:     kegg <- org.Ce.eg.db::org.Ce.egPATH2EG

409:     kegg <- org.Sc.sgd.db::org.Sc.sgdPATH2ORF

417:     kegg <- org.Dm.eg.db::org.Dm.egPATH2EG

423:   pathTable <-

424:     data.frame(pathway = paste0(prefix, rep(names(kegg2),

429:   pathTable <- merge(pathTable, x, by = "gene")

430:   return(pathTable)

472:     do.call(rbind, strsplit(as.character(gmtFile$pathTerm), '%'))

478:         pathID = tmp[, 3],

479:         pathTerm = tmp[, 1]

506: #' @return Wiki Pathway Enrichment

543:   annot <- pathTable[which(pathTable$gene %in% genes$g),]

546:   pathfreq <- pathfreq[which(pathfreq$Freq > 0),]

548:   geneSize = length(unique(pathTable$gene))

549:   bckfreq <- as.data.frame(table(pathTable$pathID))

550:   notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]

551:   freq <- merge(pathfreq, notGene, by = "Var1")

576:   r <- annot[annot$pathID %in% pathT,]

579:   for (i in seq_along(pathT))

581:     if (length(which(pathT[i] == r$pathID)) > 0)

585:           list(as.character(r[which(pathT[i] == r$pathID),]$gene)),

586:                           paste(pathT[i])))

593:       ID = pathT,

594:       Term = pathTerms,

604: #' For a given gmt file of a specific pathway database, pathway enrichment

626: #' @return Pathway Enrichment

670:     pathTable <-

675:     pathTable <- geneListEnrich(f = gmtFile, isSymbol = isSymbol)

677:   annot <- pathTable[which(pathTable$symbol %in% genes$g),]

679:   pathfreq <- pathfreq[which(pathfreq$Freq > 0),]

683:     geneSize = length(unique(pathTable$symbol))

688:   bckfreq <- as.data.frame(table(pathTable$pathTerm))

690:   notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]

691:   freq <- merge(pathfreq, notGene, by = "Var1")

716:   r <- annot[annot$pathTerm %in% pathT,]

720:   for (i in seq_along(pathT))

722:     if (length(which(pathT[i] == r$pathTerm)) > 0)

725:           list(as.character(r[which(pathT[i] == r$pathTerm),]$symbol)),

726:                           paste(pathT[i])))

731:       ID = pathT,

732:       Term = pathTerms,

742: #' Convert gmt formatted pathway file to the Pathway ID, Entrez, symbol

745: #' @param gmtName Custom pathway gmt file

814:     colnames(f) <- c('pathTerm', 'Entrez', 'symbol')

829:     colnames(f) <- c('pathTerm', 'symbol', 'Entrez')

851:     colnames(f) <- c('pathTerm', 'Entrez', 'symbol')

862:     colnames(f) <- c('pathTerm', 'symbol', 'Entrez')

278:   xx <- as.list(reactome.db::reactomePATHID2EXTID)

281:   pn <- as.list(reactome.db::reactomePATHID2NAME)

443:       rWikiPathways::downloadPathwayArchive(organism = "Homo sapiens",

447:       rWikiPathways::downloadPathwayArchive(organism = "Mus musculus",

451:       rWikiPathways::downloadPathwayArchive(organism = "Danio rerio",

455:       rWikiPathways::downloadPathwayArchive(organism = "Rattus norvegicus",

459:       rWikiPathways::downloadPathwayArchive(

463:       rWikiPathways::downloadPathwayArchive(

467:       rWikiPathways::downloadPathwayArchive(

485: #' WikiPathways Enrichment

928:    path <-paste(system.file(package="seq2pathway"),

856: get_python3_command_path <- function()

859:   python3_command_path <- Sys.which2("python")

1029:     script_path <- file.path(tempdir(), name)

275: pathwaygene<-length(intersect(toupper(gene_list[[i]]),

484: pathwaygene<-length(intersect(toupper(gsmap$genesets[[i]]),

843:   cmdpath <- Sys.which(cmdname)

1051: runseq2pathway<-function(inputfile,

1161: gene2pathway_result<-list()

1310: gene2pathway_test<-function(dat,DataBase="GOterm",FisherTest=TRUE,

1344: gene2pathway_result<-list()

854: #get_python3_command_path: funtion from Herve Pages, Bioconductor Maintainance Team, Oct 9 2020

858: #  python3_command_path <- Sys.which2("python3") #3/3/2021 by Holly

860:   if (python3_command_path != "")

864:           return(python3_command_path)}

873: #  python3_command_path <- Sys.which2("python")

874:   python3_command_path <- Sys.which2("python3")  #3/3/2021 by Holly

875:   if (python3_command_path != ""){

876:     print(paste0("python3 found: ",python3_command_path))

877:     return(python3_command_path)}

880:        "  'python3' (or 'python') executable is in your PATH.")

924:     ### assign the path of main function

932:     path <-paste(system.file(package="seq2pathway"),

976: 		sink(file.path(tempdir(),name,fsep = .Platform$file.sep))} 

994:     cat("'", path, "').load_module()",sep="")

1030:     if (!file.exists(script_path))

1032:     mypython <- get_python3_command_path()

1034:     response <- system2(mypython, args=script_path,

75: data(gencode_coding,package="seq2pathway.data")

155: data(gencode_coding,package="seq2pathway.data")

214: ####load GP pathway information

216:    data(GO_BP_list,package="seq2pathway.data")

217:    data(GO_MF_list,package="seq2pathway.data")

218:    data(GO_CC_list,package="seq2pathway.data") 

219:    data(Des_BP_list,package="seq2pathway.data")

220:    data(Des_MF_list,package="seq2pathway.data")

221:    data(Des_CC_list,package="seq2pathway.data")

223:          data(GO_BP_list,package="seq2pathway.data") 

224:          data(Des_BP_list,package="seq2pathway.data")

226:               data(GO_MF_list,package="seq2pathway.data") 

227:               data(Des_MF_list,package="seq2pathway.data")

229:                   data(GO_CC_list,package="seq2pathway.data")

230:                   data(Des_CC_list,package="seq2pathway.data")

237: data(GO_GENCODE_df_hg_v36,package="seq2pathway.data")

240: data(GO_GENCODE_df_hg_v19,package="seq2pathway.data")

243: data(GO_GENCODE_df_mm_vM25,package="seq2pathway.data")

246: data(GO_GENCODE_df_mm_vM1,package="seq2pathway.data")

280: c<-pathwaygene-a

289: mdat[i,7]<-pathwaygene

321: pathwaygene<-length(intersect(toupper(GO_BP_list[[i]]),

326: c<-pathwaygene-a

335: mdat[i,7]<-pathwaygene

367: pathwaygene<-length(intersect(toupper(GO_CC_list[[i]]),

372: c<-pathwaygene-a

381: mdat[i,7]<-pathwaygene

413: pathwaygene<-length(intersect(toupper(GO_MF_list[[i]]),

418: c<-pathwaygene-a

427: mdat[i,7]<-pathwaygene

455: data(Msig_GENCODE_df_hg_v36,package="seq2pathway.data")

458: data(Msig_GENCODE_df_hg_v19,package="seq2pathway.data")

461: data(Msig_GENCODE_df_mm_vM25,package="seq2pathway.data")

464: data(Msig_GENCODE_df_mm_vM1,package="seq2pathway.data")

489: c<-pathwaygene-a

498: mdat[i,7]<-pathwaygene

549: data(gencode_coding,package="seq2pathway.data")

647: rungene2pathway <-

704: colnames(res) <- c(paste(colnames(dat),"2pathscore",sep=""))

705: print("gene2pathway calculates score....... done")

711: rungene2pathway_EmpiricalP <-

770: colnames(res) <- c(paste(colnames(dat),"2pathscore",sep=""))

829: colnames(res_p) <- c(paste(colnames(dat),"2pathscore_Pvalue",sep=""))

832: print("pathwayscore Empirical Pvalue calculation..........done")

849:   success <- grepl(pattern1, cmdpath, fixed=TRUE) ||

850:     grepl(pattern2, cmdpath, fixed=TRUE)

851:   if (success) cmdpath else ""

1007:     #cat(paste("inputpath=","'",inputpath,"/'",sep=""),sep="\n")

1009:     #cat(paste("outputpath=","'",outputpath,"/'",sep=""),sep="\n")

1018:     cat(paste("pwd=","'",system.file(package="seq2pathway.data"),"/extdata/'",sep=""),sep="\n")

1103: data(GO_BP_list,package="seq2pathway.data")

1104: data(GO_MF_list,package="seq2pathway.data")

1105: data(GO_CC_list,package="seq2pathway.data")

1106: data(Des_BP_list,package="seq2pathway.data")

1107: data(Des_CC_list,package="seq2pathway.data")

1108: data(Des_MF_list,package="seq2pathway.data")

1134: #############################rungene2pathway,normalization,empiricalP,summary table

1166: GO_BP_FAIME<-rungene2pathway(dat=dat_CP,gsmap=GO_BP_list,alpha=alpha,logCheck=logCheck,

1171: GO_BP_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=GO_BP_list,

1174: ########gene2pathway table

1190: gene2pathway_result[[n.list]]<-GO_BP_N_P

1191: names(gene2pathway_result)[n.list]<-c("GO_BP")

1195: GO_MF_FAIME<-rungene2pathway(dat=dat_CP,gsmap=GO_MF_list,alpha=alpha,logCheck=logCheck,

1198: GO_MF_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=GO_MF_list,

1215: gene2pathway_result[[n.list]]<-GO_MF_N_P

1216: names(gene2pathway_result)[n.list]<-c("GO_MF")

1220: GO_CC_FAIME<-rungene2pathway(dat=dat_CP,gsmap=GO_CC_list,alpha=alpha,logCheck=logCheck,

1223: GO_CC_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=GO_CC_list,

1241: gene2pathway_result[[n.list]]<-GO_CC_N_P

1242: names(gene2pathway_result)[n.list]<-c("GO_CC")

1245: dat_FAIME<-rungene2pathway(dat=dat_CP,gsmap=DataBase,alpha=alpha,logCheck=logCheck,

1248: dat_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=DataBase,

1255: colnames(DB_N_P)<-c("score2pathscore_Normalized","score2pathscore_Pvalue")

1274: gene2pathway_result<-DB_N_P[,c(ncol(DB_N_P),1:(ncol(DB_N_P)-1))]

1276: print("gene2pathway analysis is done")

1279: if(exists("gene2pathway_result")&exists("FS_test")){

1283: TotalResult[[2]]<-gene2pathway_result

1284: names(TotalResult)[2]<-"gene2pathway_result.FAIME"

1286: names(TotalResult)[3]<-"gene2pathway_result.FET"

1289: }else if(exists("gene2pathway_result")&exists("FS_test")==FALSE){

1293: TotalResult[[2]]<-gene2pathway_result

1294: names(TotalResult)[2]<-"gene2pathway_result.FAIME"

1298: else if(exists("gene2pathway_result")==FALSE&exists("FS_test")){

1303: names(TotalResult)[2]<-"gene2pathway_result.FET"

1326: data(GO_BP_list,package="seq2pathway.data")

1327: data(GO_MF_list,package="seq2pathway.data")

1328: data(GO_CC_list,package="seq2pathway.data")

1329: data(Des_BP_list,package="seq2pathway.data")

1330: data(Des_CC_list,package="seq2pathway.data")

1331: data(Des_MF_list,package="seq2pathway.data")

1346: #############################rungene2pathway,normalization,empiricalP,summary table

1348: gene2pathway_result<-list()

1352:   GO_BP_method<-rungene2pathway(dat=dat,gsmap=GO_BP_list,alpha=alpha,logCheck=logCheck,

1358:     GO_BP_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=GO_BP_list,alpha=alpha,

1364:   ########gene2pathway table

1376:   gene2pathway_result[[n.list]]<-GO_BP_N_P

1377:   names(gene2pathway_result)[n.list]<-c("GO_BP")

1380:     GO_MF_method<-rungene2pathway(dat=dat,gsmap=GO_MF_list,alpha=alpha,logCheck=logCheck,

1384:       GO_MF_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=GO_MF_list,alpha=alpha,

1402:   gene2pathway_result[[n.list]]<-GO_MF_N_P

1403:   names(gene2pathway_result)[n.list]<-c("GO_MF")

1406:    GO_CC_method<-rungene2pathway(dat=dat,gsmap=GO_CC_list,alpha=alpha,logCheck=logCheck,

1410:       GO_CC_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=GO_CC_list,alpha=alpha,

1427:   gene2pathway_result[[n.list]]<-GO_CC_N_P

1428:   names(gene2pathway_result)[n.list]<-c("GO_CC")

1431: dat_method<-rungene2pathway(dat=dat,gsmap=DataBase,alpha=alpha,logCheck=logCheck,

1435: dat_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=DataBase,alpha=alpha,

1443: colnames(DB_N_P)<-c("score2pathscore_Normalized","score2pathscore_Pvalue")

1464: gene2pathway_result<-DB_N_P[,c(ncol(DB_N_P),1:(ncol(DB_N_P)-1))]

1466: print("gene2pathway analysis is done")

1470: if(exists("gene2pathway_result")&exists("FS_test")){

1472: TResult[[1]]<-gene2pathway_result

1473: names(TResult)[1]<-"gene2pathway_result.2"

1475: names(TResult)[2]<-"gene2pathway_result.FET"

1476: }else if(exists("gene2pathway_result")&exists("FS_test")==FALSE){

1477: TResult<-gene2pathway_result

1479: else if(exists("gene2pathway_result")==FALSE&exists("FS_test")){

101:         path <- paste(dir, file, sep='//')

34:         paths <- list.files(xmlDir) 

83: pathwayToGraph <- function (i, ...)

3: createPathwayGraphs <- function(org, pathways, edgeTypes, doubleEdges, choice,

141: getPathwayType                    <- function(filepath, file)

159: metabolicPathwayToGraph           <- function(filepath)

347: nonMetabolicPathwayToGraph <- function(filepath, doubleEdges, groupMode)

102:         gr   <- metabolicPathwayToGraph(path)

119:         path <- paste(dir, file, sep='//')

120:         gr   <- nonMetabolicPathwayToGraph(path, doubleEdges, groupMode)

225: removeCompoundsMetabolicGraph     <- function(path)

228:     if(path$name != gsub('ec','',path$name)) { nodeType<-"enzyme" }

229:     enzymes  <- which(path$vertices$type == nodeType)

230:     vid      <- path$vertices$id

233:     if ( length(path$edges) > 0 )

243:             for (r1 in path$edges[path$edges$e1 == 

244:                                 path$vertices[,'id'][enzymes[j]],]$e2)  

247:                 for (r2 in path$edges[path$edges$e1 == 

248:                                 path$vertices[,'id'][which(vid == r1)],]$e2)

252:                     nid <- vid[which(path$vertices$id == r2)]

267:     xid    <- path$vertices$id[enzymes]

268:     names  <- path$vertices$names[enzymes]       

513: removeCompoundsNonMetabolicGraph <- function(path, unique, edgeTypes)

515:     if (is.null(path)) return(NULL)

516:     vid      <- as.numeric(path$vertices$id)

517:     etype    <- path$vertices$type

519:     if(path$name != gsub('ko','',path$name)) { nodeType <- "ortholog" }

522:     genesIndx <- which(path$vertices$type == nodeType)

528:         neighbors <- path$edges$e2[path$edges$e1 == vid[gi]]

546:                 idx1 <- which( path$edges$e1 == vid[gi] )

547:                 idx2 <- which( path$edges$e2 == vid[nbrId] )

549:                 TT   <- c( TT, paste((path$edges$type[idx]), collapse='_') )

557:                 cpdNeighbors <- path$edges$e2[ 

558:                                         which(path$edges$e1 == vid[nbrId]) ]

586:         names            <- unique(path$vertices$names[genesIndx])

598:             idx1 <- which(path$vertices$id == source[i])

599:             idx2 <- which(path$vertices$id == destin[i])

600:             source[i] <- names[ names == path$vertices$names[idx1] ]

601:             destin[i] <- names[ names == path$vertices$names[idx2] ]

623:         gids                <- path$vertices$id[genesIndx]

624:         names               <- unname(path$vertices$names[genesIndx])

31:     # Choose valid pathways

32:     if (missing(pathways))  

37:     if (!missing(pathways)) 

39:         paths <- paste(org, pathways, '.xml', sep='') 

44:     # Create compact adjacency matrices for given pathways.

45:     types  <- getPathwayType(paste(xmlDir, paths, sep='//'))

46:     N <- length(paths)

56:                     funcName=pathwayToGraph,

59:                     N=length(paths),

61:                     xmlDir, paths, types, FALSE, edgeTypes, 

64:     names(cAdjMats) <- gsub('.xml', '', paths)

67:     eAdjMats <- .doSafeParallel(funcName=pathwayToGraph,

70:                                 N=length(paths),

72:                                 xmlDir, paths, types, TRUE, edgeTypes, 

75:     names(eAdjMats) <- gsub('.xml', '', paths)

143:     types <- vector(mode='numeric', length=length(filepath))

144:     for (i in 1:length(filepath))

146:         num <- tail(unlist(strsplit(filepath[i], '//')), 1)

156: # Graph from Metabolic Pathways

161:     xmlDoc <- tryCatch(xmlTreeParse(filepath,error=NULL),

344: # Graph from Mon Metabolic Pathways

350:     xmlDoc         <- tryCatch(xmlTreeParse(filepath,error=NULL),

49:         'nonMetabolicPathwayToGraph', 'expandMetabolicGraph', 

51:         'metabolicPathwayToGraph', 'expandNonMetabolicGraph',

609:                 # Set new interaction types to apathetic

732:     # apathetic  3

61:         path <- self$getEntry(path.id)

59:     for (path.id in id) {

127:     for (path.id in id) {

304:     path_idx <- sub('^[^0-9]+', '', id)

322:     path_idx <- sub('^[^0-9]+', '', id)

29: KeggPathwayConn <- R6::R6Class("KeggPathwayConn",

40:     super$initialize(db.name='pathway', db.abbrev='path', ...)

62:         if ( ! is.null(path) && path$hasField('kegg.module.id')) {

65:             for (mod.id in path$getFieldValue('kegg.module.id')) {

144:             graph[[path.id]]=list(vertices=vert, edges=edg)

147:             graph[[path.id]]=NULL

309:         params=c(org_name='map', mapno=path_idx,

325:     img_filename <- paste0('pathwaymap-', path_idx)

331:             biodb::error0('Impossible to find pathway image path inside',

335:         tmp_file <- file.path(cache$getTmpFolderPath(),

2: #' The connector class to KEGG Pathway database.

16: #' conn=mybiodb$getFactory()$createConn('kegg.pathway')

18: #' # Retrieve all reactions related to a mouse pathway:

21: #' # Get a pathway graph

44: #' Retrieves all reactions part of a KEGG pathway. Connects to

45: #'     KEGG databases, and walk through all pathways submitted, and

58:     # Loop on all Pathway IDs

89: #' Takes a list of pathways IDs and converts them to the specified organism,

92: #' @param org The organism in which to search for pathways, as a KEGG organism

113: #' Builds a pathway graph in the form of two tables of vertices and edges,

115: #' @param id A character vector of KEGG pathway entry IDs.

120: #' @return A named list whose names are the pathway IDs, and values are lists

126:     # Loop on all pathway IDs

158: #' Builds a pathway graph, as an igraph object, using KEGG database.

159: #' @param id A character vector of KEGG pathway entry IDs.

196: #' Create a pathway graph picture, with some of its elements colorized.

197: #' @param id A KEGG pathway ID.

227: #' Extracts shapes from a pathway map image.

228: #' @param id A KEGG pathway ID.

303:     # Extract pathway number

308:         'show_pathway'),

329:             'src="([^"]+)"(\\s+.*)?\\s+(name|id)="pathwayimage"')

332:                 ' HTML page for pathway ID ', id, '.')

342:     img_file <- cache$getFilePath(cid, img_filename, 'png')

22: #' graph=conn$buildPathwayGraph('mmu00260')

98: convertToOrgPathways=function(id, org) {

122: buildPathwayGraph=function(id, directed=FALSE, drop=TRUE) {

166: getPathwayIgraph=function(id, directed=FALSE, drop=TRUE) {

173:         g <- self$buildPathwayGraph(id=id, directed=directed, drop=FALSE)

210:         pix <- private$getPathwayImage(id)

213:         shapes <- self$extractPathwayMapShapes(id=id, color2ids=color2ids)

233: ,extractPathwayMapShapes=function(id, color2ids) {

237:     html <- private$getPathwayHtml(id)

301: ,getPathwayHtml=function(id) {

319: getPathwayImage=function(id) {

321:     html <- private$getPathwayHtml(id)

127: var path = svg.append('svg:g').selectAll('path'),

2499: function ShowShortestPath(){

2: var basePath1="./PPIinfo/";

3: var basePath2="./PPIinfo/";

2630: function ShowShortestPath1(){

2711: var swiss2paths={};

2765: function showPath10(){

2778: function addResultPath10(p){

2784: function addFirstPath10(p){

2800: function addLastPath10(p){

2823: function addPreviousPath10(p){

2842: function addNextPath10(p){

2560: var resultPaths=[];

2561: function ShowPaths(allPaths){

2616: function ShowPathView(index){

2712: function generatePaths(swiss, root){

2729: function ShowShortestPathExp(){

2763: var showPathFirst=0;

2764: var showPathEnd=10;

3044: function getCisPathJS(){

3065: function getCisPathJSRetry(urltry){

3096: function getPathsForTargetProtein(swissID){

3118: function getPathsForTargetProteinRetry(urltry){

53:   .append('svg:path')

68:   .append('svg:path')

94:   .append('svg:path')

109:   .append('svg:path')

115: var drag_line = svg.append('svg:path')

166:   path.attr('d', function(d) {

360:   // path (link) group

381:   path = path.data(links);

384:   path.classed('selected', function(d) { return d === selected_link; })

393:   path.enter().append('svg:path')

414:   path.exit().remove();

2384: ///////////////////////////////////////////////////////////////////////shortest path

2504:        alert("No path between this two proteins!");

2508:        alert("No path between this two proteins!");

2568:     addTh(mycurrent_row, "Path");

2601:         mycurrent_button.id = "path"+x;

2614:     ShowPathView("path0");

2701:        alert("Sorry, detect no path from "+swiss1+" to "+ swiss2);

3097:    var url="./js/"+swissID+"_path.js";

954: 	 document.getElementById("detectPath").disabled=true;

1380:   idx=pathLen-1-idx;

1415: 	var url=basePath2+sourceSwiss+".js";

1679: 	var url=basePath2+swiss1+".js";

1684:            if(this.url==(basePath2+swiss1+".js")){

1820:   var url=basePath2+"A0A5B9.js";

1827:         debugObj("basePath1:"+basePath1);

1831:         basePath1="../geneset20140628/";

1832:         basePath2="../20140628PPI/";

1833:         debugObj("basePath1:"+basePath1);

1845:   var url=basePath2+"gene2swiss.js";

1899: 	var url=basePath2+"swiss2gene.js";

1954: 	var url=basePath2+"swiss2swiss.js";

2021: 	var url=basePath1+"PPI.js";

2411:     	 ShowShortestPath();

2421:           document.getElementById("detectPath").disabled=false;

2426:        document.getElementById("detectPath").disabled=true;

2438:           document.getElementById("detectPath").disabled=false;

2443:        document.getElementById("detectPath").disabled=true;

2515:     document.getElementById("detectPath").disabled=true;

2530:           document.getElementById("detectPath").disabled=false;

2543:            setTimeout("ShowShortestPath1()",1000);

2549:     setTimeout("ShowShortestPath1()",1000);

2574: 	    mycurrent_row.id="pathrow"+x;

2608: 	showPath10();

2611:     document.getElementById("detectPath").disabled=false;

2625: 	  	document.getElementById("pathrow"+x).className="rowNotSelected";

2627: 	document.getElementById("pathrow"+i).className="rowSelected";

2705:     swiss2paths={};

2707:     debugObj(swiss2paths[swiss2]);

2708:     debugObj(swiss2paths[swiss2].length);

2709:     ShowPaths(swiss2paths[swiss2]);

2713:     swiss2paths[swiss]=[];

2715:        swiss2paths[swiss].push(swiss);

2724:         for(var y in swiss2paths[nodes[x]]){

2725:             swiss2paths[swiss].push(swiss2paths[nodes[x]][y]+"#"+swiss);

2760:     ShowShortestPath();

2771:     addResultPath10(p);

2772:     addFirstPath10(p);

2773:     addPreviousPath10(p);

2774:     addNextPath10(p);

2775:     addLastPath10(p);

2796:     resultSPAN.addEventListener("click", function(e){showPathFirst=0;showPath10();}, false);

2819:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2838:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2857:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2879: 	  	document.getElementById("pathrow"+i).style.display="none";

2882:         document.getElementById("pathrow"+i).style.display="";

3020: ...(31 bytes skipped)...ange", function(e){document.getElementById('targetPtxt').value=this.value;checkValid2();ShowShortestPath();}, false);

3108:         json.paths.pop();

3109:     	ShowPaths(json.paths);

3138:         json.paths.pop();

3139:     	ShowPaths(json.paths);

956: 	 document.getElementById("allShortestPaths").style.display="none";

957: 	 document.getElementById("allShortestPathsP").style.display="none";

1253: 	graphName = "cisPathValue#"+graphName;

1267:       if(key.substr(0,13)!="cisPathValue#"){

1285: 	graphName = "cisPathValue#"+graphName;

1306: 	graphName = "cisPathValue#"+graphName;

1327:       if(key.substr(0,13)!="cisPathValue#"){

1418:     callback: "cisPathCallBack",

1682:        callback: "cisPathCallBack",

1823:     callback: "cisPathCallBack",

1850:     callback: "cisPathCallBack",

1880:     callback: "cisPathCallBack",

1905:     callback: "cisPathCallBack",

1935:     callback: "cisPathCallBack",

1960:     callback: "cisPathCallBack",

1990:     callback: "cisPathCallBack",

2025:     callback: "cisPathCallBack",

2063:     callback: "cisPathCallBack",

2110: 	getCisPathJS();

2378:     var graphName="cisPathHTML";

2476: function ShowShortestPathWorker(){

2477:    var worker = new Worker("./D3/cisPathWorker.js");

2480:       var resultPaths=event.data.resultPaths;

2481:       ShowPaths(resultPaths);

2484:       var resultPaths=[];

2485:       ShowPaths(resultPaths);

2514:     document.getElementById("detectPathExp").disabled=true;

2521:     document.getElementById("allShortestPaths").style.display="none";

2522:     document.getElementById("allShortestPathsP").style.display="none";

2529:           document.getElementById("detectPathExp").disabled=false;

2533:           getPathsForTargetProtein(swiss2);

2539:            ShowShortestPathWorker();

2562:     resultPaths=allPaths;

2563:     var table=document.getElementById("allShortestPaths");

2571: 	for(var x in allPaths){

2572: 	    var nodes=allPaths[x].split("#");

2602:         mycurrent_button.addEventListener("click", function(e){ShowPathView(this.id);}, false);

2607: 	showPathFirst=0;

2610:     document.getElementById("detectPathExp").disabled=false;

2612:     document.getElementById("allShortestPaths").style.display="";

2613:     document.getElementById("allShortestPathsP").style.display="";

2617:     var total=resultPaths.length;

2619:     var nodes=resultPaths[i].split("#");

2706:     generatePaths(swiss2, swiss1);

2723:         generatePaths(nodes[x], root);

2767:     var p=document.getElementById("allShortestPathsP");

2780:     var content="Results: "+showPathFirst+"-"+showPathEnd+" of "+resultPaths.length+" ";

2790:     if(showPathFirst==0){

2805: 	var newFirst=(resultPaths.length-resultPaths.length%10);

2806: 	if(newFirst==resultPaths.length){

2807: 	   newFirst=resultPaths.length-10;

2813:     if(showPathEnd==resultPaths.length){

2828:     if(showPathFirst==0){

2834:     var newFirst=showPathFirst-10;

2847:     if(showPathEnd==resultPaths.length){

2853:     var newFirst=showPathFirst+10;

2854:     if(newFirst >= resultPaths.length){

2855:        newFirst = (resultPaths.length-resultPaths.length%10);

2863: 	var total=resultPaths.length;

2864: 	if(showPathFirst >= total){

2865: 	   showPathFirst=(total-total%10);

2867: 	if(showPathFirst == total){

2868: 	   showPathFirst = total-10;

2870:     if(showPathFirst < 0){

2871: 	   showPathFirst = 0;

2873: 	showPathFirst=showPathFirst-(showPathFirst%10);

2874: 	showPathEnd=showPathFirst+10;

2875: 	if(showPathEnd > total){

2876: 	   showPathEnd = total;

2881:     for(var i=showPathFirst;i<showPathEnd;i++){

3049:     callback: "cisPathCallBack",

3061:         getCisPathJSRetry(this.url);

3078:     callback: "cisPathCallBack",

3090:         getCisPathJSRetry(this.url);

3101:      callback: "cisPathCallBack",

3114:         getPathsForTargetProteinRetry(this.url);

3131:     callback: "cisPathCallBack",

3144:         getPathsForTargetProteinRetry(this.url);

3151: 	document.getElementById("detectPathExp").disabled=true;

3156: 	document.getElementById("detectPathExp").disabled=false;

127: var path = svg.append('svg:g').selectAll('path'),

2501: function ShowShortestPath(){

2: var basePath1="./PPIinfo/";

3: var basePath2="./PPIinfo/";

2632: function ShowShortestPath1(){

2719: var swiss2paths={};

2753: function showPath10(){

2766: function addResultPath10(p){

2772: function addFirstPath10(p){

2788: function addLastPath10(p){

2811: function addPreviousPath10(p){

2830: function addNextPath10(p){

2548: var resultPaths=[];

2549: function ShowPaths(allPaths){

2615: function ShowPathView(index){

2720: function generatePaths(swiss, root){

2737: function ShowShortestPathExp(){

2751: var showPathFirst=0;

2752: var showPathEnd=10;

53:   .append('svg:path')

68:   .append('svg:path')

94:   .append('svg:path')

109:   .append('svg:path')

115: var drag_line = svg.append('svg:path')

166:   path.attr('d', function(d) {

360:   // path (link) group

381:   path = path.data(links);

384:   path.classed('selected', function(d) { return d === selected_link; })

393:   path.enter().append('svg:path')

414:   path.exit().remove();

2386: ///////////////////////////////////////////////////////////////////////shortest path

2506:        alert("No path between this two proteins!");

2510:        alert("No path between this two proteins!");

2554:     	 alert("Sorry, detect no path from "+swiss1+" to "+ swiss2);

2566:     addTh(mycurrent_row, "Path");

2599:         mycurrent_button.id = "path"+x;

2613:       ShowPathView("path0");

2705:        alert("Sorry, detect no path from "+name1+" to "+ name2);

954: 	 document.getElementById("detectPath").disabled=true;

1380:   idx=pathLen-1-idx;

1415: 	var url=basePath2+sourceSwiss+".js";

1679: 	var url=basePath2+swiss1+".js";

1684:            if(this.url==(basePath2+swiss1+".js")){

1820:   var url=basePath2+"A0A5B9.js";

1827:         debugObj("basePath1:"+basePath1);

1831:         basePath1="../geneset20140628/";

1832:         basePath2="../20140628PPI/";

1833:         debugObj("basePath1:"+basePath1);

1845:   var url=basePath2+"gene2swiss.js";

1899: 	var url=basePath2+"swiss2gene.js";

1954: 	var url=basePath2+"swiss2swiss.js";

2021: 	var url=basePath1+"PPI.js";

2413:     	 ShowShortestPath();

2423:           document.getElementById("detectPath").disabled=false;

2428:        document.getElementById("detectPath").disabled=true;

2440:           document.getElementById("detectPath").disabled=false;

2445:        document.getElementById("detectPath").disabled=true;

2517:     document.getElementById("detectPath").disabled=true;

2531:            setTimeout("ShowShortestPath1()",1000);

2537:     setTimeout("ShowShortestPath1()",1000);

2558:        document.getElementById("detectPath").disabled=false;

2572: 	    mycurrent_row.id="pathrow"+x;

2606: 	showPath10();

2610:     document.getElementById("detectPath").disabled=false;

2627: 	  	document.getElementById("pathrow"+x).className="rowNotSelected";

2629: 	document.getElementById("pathrow"+i).className="rowSelected";

2709:        document.getElementById("detectPath").disabled=false;

2713:     swiss2paths={};

2715:     debugObj(swiss2paths[swiss2]);

2716:     debugObj(swiss2paths[swiss2].length);

2717:     ShowPaths(swiss2paths[swiss2]);

2721:     swiss2paths[swiss]=[];

2723:        swiss2paths[swiss].push(swiss);

2732:         for(var y in swiss2paths[nodes[x]]){

2733:             swiss2paths[swiss].push(swiss2paths[nodes[x]][y]+"#"+swiss);

2748:     ShowShortestPath();

2759:     addResultPath10(p);

2760:     addFirstPath10(p);

2761:     addPreviousPath10(p);

2762:     addNextPath10(p);

2763:     addLastPath10(p);

2784:     resultSPAN.addEventListener("click", function(e){showPathFirst=0;showPath10();}, false);

2807:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2826:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2845:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2867: 	  	document.getElementById("pathrow"+i).style.display="none";

2870:         document.getElementById("pathrow"+i).style.display="";

956: 	 document.getElementById("allShortestPaths").style.display="none";

957: 	 document.getElementById("allShortestPathsP").style.display="none";

1253: 	graphName = "cisPathValue#"+graphName;

1267:       if(key.substr(0,13)!="cisPathValue#"){

1285: 	graphName = "cisPathValue#"+graphName;

1306: 	graphName = "cisPathValue#"+graphName;

1327:       if(key.substr(0,13)!="cisPathValue#"){

1418:     callback: "cisPathCallBack",

1682:        callback: "cisPathCallBack",

1823:     callback: "cisPathCallBack",

1850:     callback: "cisPathCallBack",

1880:     callback: "cisPathCallBack",

1905:     callback: "cisPathCallBack",

1935:     callback: "cisPathCallBack",

1960:     callback: "cisPathCallBack",

1990:     callback: "cisPathCallBack",

2025:     callback: "cisPathCallBack",

2063:     callback: "cisPathCallBack",

2380:     var graphName="cisPathHTML";

2478: function ShowShortestPathWorker(){

2479:    var worker = new Worker("./D3/cisPathWorker.js");

2482:       var resultPaths=event.data.resultPaths;

2483:       ShowPaths(resultPaths);

2486:       var resultPaths=[];

2487:       ShowPaths(resultPaths);

2516:     document.getElementById("detectPathExp").disabled=true;

2523:     document.getElementById("allShortestPaths").style.display="none";

2524:     document.getElementById("allShortestPathsP").style.display="none";

2527:            ShowShortestPathWorker();

2550:     resultPaths=allPaths;

2551:     if(resultPaths.length==0){

2557:        document.getElementById("detectPathExp").disabled=false;

2561:     var table=document.getElementById("allShortestPaths");

2569: 	for(var x in allPaths){

2570: 	    var nodes=allPaths[x].split("#");

2600:         mycurrent_button.addEventListener("click", function(e){ShowPathView(this.id);}, false);

2605: 	showPathFirst=0;

2609:     document.getElementById("detectPathExp").disabled=false;

2611:     document.getElementById("allShortestPaths").style.display="";

2612:     document.getElementById("allShortestPathsP").style.display="";

2616:     var total=resultPaths.length;

2618:     if(i>=resultPaths.length){

2621:     var nodes=resultPaths[i].split("#");

2708:        document.getElementById("detectPathExp").disabled=false;

2714:     generatePaths(swiss2, swiss1);

2731:         generatePaths(nodes[x], root);

2755:     var p=document.getElementById("allShortestPathsP");

2768:     var content="Results: "+showPathFirst+"-"+showPathEnd+" of "+resultPaths.length+" ";

2778:     if(showPathFirst==0){

2793: 	var newFirst=(resultPaths.length-resultPaths.length%10);

2794: 	if(newFirst==resultPaths.length){

2795: 	   newFirst=resultPaths.length-10;

2801:     if(showPathEnd==resultPaths.length){

2816:     if(showPathFirst==0){

2822:     var newFirst=showPathFirst-10;

2835:     if(showPathEnd==resultPaths.length){

2841:     var newFirst=showPathFirst+10;

2842:     if(newFirst >= resultPaths.length){

2843:        newFirst = (resultPaths.length-resultPaths.length%10);

2851: 	var total=resultPaths.length;

2852: 	if(showPathFirst >= total){

2853: 	   showPathFirst=(total-total%10);

2855: 	if(showPathFirst == total){

2856: 	   showPathFirst = total-10;

2858:     if(showPathFirst < 0){

2859: 	   showPathFirst = 0;

2861: 	showPathFirst=showPathFirst-(showPathFirst%10);

2862: 	showPathEnd=showPathFirst+10;

2863: 	if(showPathEnd > total){

2864: 	   showPathEnd = total;

2869:     for(var i=showPathFirst;i<showPathEnd;i++){

2942: 	document.getElementById("detectPathExp").disabled=true;

2947: 	document.getElementById("detectPathExp").disabled=false;

1597:     path <- ucscURLTable[key]

364:   label_path <- "//select[@name = 'hgta_track']/option/text()"

366:   track_path <- "//select[@name = 'hgta_track']/option/@value"

365:   labels <- sub("\n.*$", "", sapply(getNodeSet(doc, label_path), xmlValue))

367:   tracks <- unlist(getNodeSet(doc, track_path))

1572:             upload <- fileUpload(path(object), "text/plain")

1598:     if (is.na(path))

1601:         path <- paste0(path, '?redirect="manual"')

1603:     paste(object@url, path, sep="")

568:         path<-h[2]

710:         path<-paste(stringr::str_sub(k, 1, 3),

858:             path<-stringr::str_split(s[1], "__")[[1]]

366:     notin_path<-vapply(elem_names, function(e){

369:         nb_path<-length(first_item[first_item %in% "X"])

387:     kegg_path<-pathways[stringr::str_sub(pathways, 1, 3) == "hsa"]

390:     path_walks_k<-vapply(kegg_path, function(x){

396:     wp_path<-pathways[stringr::str_sub(pathways, 1, 2) == "WP"]

397:     path_walks_w<-vapply(wp_path, function(x){

404:     path_walks_r<-vapply(first_walks_r, function(x){

425:     path_walks<-rbind(final_walks_r, path_walks_k,path_walks_w)

536:     cluster_elem<-save_cluster_elem<-listele[[1]];notin_path<-listele[[2]]

585:                 path_inter<-tagged[tagged$path == path,]

601:     heatmap<-listhtmp[[1]]; notin_path<-listhtmp[[2]]; hierapath<-listhtmp[[3]]

670:     rea_path<-sorted_path[stringr::str_sub(sorted_path, 1, 3) == "R-H"]

708:     kegg_path<-sorted_path[stringr::str_sub(sorted_path, 1, 3) == "hsa"]

740:     wp_path<-sorted_path[stringr::str_sub(sorted_path, 1, 2) == "WP"]

771: type_path<-function(sorted_path, hierapath){

800:     path_types<-unique(types$root)

802:         type_path<-types[types[, 2] %in% p, 1]#concerned pathways

948: filter_path<-function(tagged,size){

949:     path_inter<-as.vector(tagged[,4])

950:     sorted_path<-apply(size,1,function(x){ #sort pathways obtained

951:         path_elem<-as.integer(x[4])+as.integer(x[8])

965:     central<-listparam[[5]]; no_path<-listparam[[6]];

969:     sorted_path<-filter_path(tagged,size)

971:     path_walks<-listpath[[1]]; max<-listpath[[2]]

977:     heatmap<-listtab[[1]]; notin_path<-listtab[[2]]; hierapath<-listtab[[3]]

996:         path_cat<-stringr::str_split(i[6], ", ")[[1]]

435:     pathidtoname <- as.list(reactome.db::reactomePATHID2NAME)

516:     hierapath<-vapply(root_ids, function(r){

542:     heatmap<-listhiera[[1]]; hierapath<-listhiera[[2]]

963:     size<-listparam[[1]]; pathways<-listparam[[2]]; tagged<-listparam[[3]];

970:     listpath<-sort_hiera(sorted_path)

370:         if(element == TRUE && nb_path == 0){list(e)}

373:     notin_path<-unname(unlist(notin_path))

381:     if (element == TRUE){return(list(cluster, notin_path))}

388:     kegg_path<-paste(stringr::str_sub(kegg_path,1,3),

389:                         stringr::str_sub(kegg_path,5),sep="")

393:     path_walks_k<-as.data.frame(sort(unlist(path_walks_k)))

394:     if(ncol(path_walks_k) == 0){path_walks_k<-data.frame(walks=character())}

400:     path_walks_w<-as.data.frame(sort(unlist(path_walks_w)))

401:     if(ncol(path_walks_w) == 0){path_walks_w<-data.frame(walks=character())}

412:     path_walks_r<-rm_vector(unname(unlist(path_walks_r)))

413:     path_walks_r<-path_walks_r[stringr::str_detect(path_walks_r, ">")]

415:     final_walks_r<-vapply(path_walks_r, function(x){

416:         dupl<-which(stringr::str_detect(path_walks_r, x))

417:         dupl<-dupl[-which(dupl == which(path_walks_r == x))]

424:     names(final_walks_r)<-names(path_walks_w)<-names(path_walks_k)<-"walks"

426:     max<-max(stringr::str_count(path_walks[,1],">"))+1

427:     return(list(path_walks, max))

434:                                         treeview, no_path, list_elem){

455:                 paste("'", size[size$path == node, 2], "/",

456:                         size[size$path == node, 4], sep=""),

457:                 paste("'", size[size$path == node, 6], "/",

458:                         size[size$path == node, 8], sep=""),NA)

463:     colnames(heatmap)<-c("path_name", "path_id", "meta_ratio", "gene_ratio",

466:     heatmap[which(heatmap[, 4] == "'/"), 4]<-"'0/0";tags<-no_path$tag

480: cluster_hiera<-function(heatmap, size, tagged, no_path){

532: cluster_htmp<-function(heatmap, tags, size, tagged, no_path){

538:     cluster_elem<-cluster_elem[!(cluster_elem %in% notin_path)]

539:     heatmap<-heatmap[,c("path_name", "path_id", "meta_ratio", "gene_ratio",

541:     listhiera<-cluster_hiera(heatmap, size, tagged, no_path)

550:         if(x[2] %in% tagged$path){

556:     names(heatmap)<-c("path_name", "path_id", "meta_ratio", "gene_ratio",

558:     return(list(heatmap, notin_path, hierapath, save_cluster_elem))

562: final_tab<-function(build_hm, pathways, size, sorted_path, no_path,

564:     heatmap<-hiera_info(pathways, size, sorted_path, build_hm,

565:                         no_path, list_elem)

566:     sub_htmp<-heatmap[2:nrow(heatmap),]; tags<-no_path$tag #direct interactions

569:         pre_elem<-c(size[size$path %in% path, 3], size[size$path %in% path, 7])

586:                 path_inter<-path_inter[path_inter$tag ==

588:                 if(nrow(path_inter)>0){list("X")}

600:     listhtmp<-cluster_htmp(heatmap, tags, size, tagged, no_path)

603:     return(list(heatmap, notin_path, hierapath, save_cluster_elem))

625: infos_elem<-function(genes, notin_path, meta, keggchebiname, no_path,

634:     genetab<-pre_genetab[which(!(pre_genetab[,1] %in% notin_path)),]

635:     gene_notin<-pre_genetab[which(pre_genetab[,1] %in% notin_path),]

653:     intetab<-apply(no_path, 1, function(p){

664:                         "go", "path", "type")

669: type_reactome<-function(sorted_path){

672:     rea_types<-vapply(rea_path,function(r){

707: type_kegg<-function(sorted_path){

709:     kegg_types<-vapply(kegg_path, function(k){

712:         hiera<-kegg_hiera[stringr::str_detect(kegg_hiera[, 1], path), ]

725:         else if (path == "hsa01100"){

739: type_wp<-function(sorted_path){

741:     wp_types<-vapply(wp_path, function(w){

772:     kegg_type<-type_kegg(sorted_path)#kegg types

773:     rea_types<-type_reactome(sorted_path)#Reactome types

774:     wp_types<-type_wp(sorted_path)#wikipathways types

801:     hieratypes<-vapply(path_types, function(p){

804:             if(length(intersect(type_path, h[["name"]]))>0){h[["index"]]}

807:             if(length(intersect(type_path, h[["name"]]))>0){h[["name"]]}

872:                     list(paste("x : ",element,"\ny : ",path[length(path)],

881:                     list(paste("x : ", element, "\ny : ", path[length(path)],

952:         if (path_elem>0){

954:             if(num/path_elem>=0.2){x[1]}

957:     sorted_path<-unname(unlist(sorted_path))

958:     sorted_path<-rm_vector(c(sorted_path[!is.na(sorted_path)],path_inter))

959:     return(sorted_path)

972:     path_walks<-tidyr::separate(path_walks, 1, as.character(c(seq_len(max))),

974:     treeview<-tree_view(path_walks);names(treeview)<-c(seq_len(ncol(treeview)))

975:     listtab<-final_tab(treeview, pathways, size, sorted_path, no_path,

981:     listelm<-infos_elem(gene_list, notin_path, meta_list, keggchebiname,

982:                         no_path, go_genelist)

986:     listype<-type_path(sorted_path, hierapath)

998:                                           %in% path_cat),2]), collapse=", ")

1002:     names(intetab)<-c("tag", "first_item", "link", "sec_item", "go", "path",

341: ##find which elements are found in the same pathways, and put them together

342: ##find which pathways contain the same elements also

343: ##if element=T, also return user's elements which aren't in pathways

385: #filter entire pathways hierarchy to build a hierarchy concerning our pathways

386: sort_hiera<-function(pathways){

406:         if(length(pathways[pathways %in% rea_walks])>0){

407:             rea_walks<-rm_vector(rea_walks[c(1, which(rea_walks%in%pathways))])

430: #add informations about pathway hierarchies to the final heatmap

432: #names and ids of pathways in hierarchies

433: hiera_info<-function(pathways, size, sorted_pathways,

443:         name<-pathways[pathways[,2] == node, 1]

447:                             pathways[pathways[,2] == node, 1], sep=""))

450:             htmp<-c(htmp,paste(space, stringr::str_sub(pathidtoname[[node]],

451:                                     15, nchar(pathidtoname[[node]])), sep=""))

479: ##the hierarchy pathways are added to the root

527:     hierapath[length(hierapath)]=NULL

528:     return(list(heatmap, hierapath))

544:     hierapath<-lapply(hierapath,function(x){

549:     heatmap<-apply(heatmap,1,function(x){#pathway with direct interaction ?

561: ##build heatmap of hierarchies of pathways and elements included in them

668: #reactome pathways types

706: #kegg pathways types

738: #wikipathways pathways types

747:                 if(root%in%c("classic metabolic pathway", "regulatory pathway")

770: #pathways types=roots of pathways hierarchy

799:     ##list of concerned hierarchies by pathways types

803:         index<-lapply(hierapath, function(h){

806:         name<-lapply(hierapath, function(h){

947: #filter pathways regarding user's element ratio and direct interactions

1010:                 hierapath, save_cluster_elem, centrality, inter_values,

671:     mapnameid <- as.list(reactome.db::reactomePATHID2NAME) #id-name mapping

5439:             path <- env[['PATH_INFO']]

6044:             path <- env[['PATH_INFO']]

2147:                 pathsizes <- unlist(tapply(vi, gcll, length))

5059: pathway.pc.correlation.distance <- function(pcc, xv, n.cores = 10, target.ndf = NULL) {

6173:                        pathcl <- ifelse(is.null(req$params()$pathcl), 1, as.integer(req$params()$pathcl))

1877: pagoda.pathway.wPCA <- function(varinfo, setenv, n.components = 2, n.cores = detectCores(), min.pathway.size = 10, max.pathway.size = 1e3, n.randomizations = 10, n.internal.shuffles = 0, n.starts = 10, center = TRUE, batch....(55 bytes skipped)...

5558: t.view.pathways <- function(pathways, mat, matw, env, proper.names = rownames(mat), colcols = NULL, zlim = NULL, labRow = NA, vhc = ...(145 bytes skipped)...

5684: pagoda.show.pathways <- function(pathways, varinfo, goenv = NULL, n.genes = 20, two.sided = FALSE, n.pc = rep(1, length(pathways)), colcols = NULL, zlim = NULL, showRowLabels = FALSE, cexCol = 1, cexRow = 1, nstarts = 10, ce...(117 bytes skipped)...

5698: c.view.pathways <- function(pathways, mat, matw, goenv = NULL, batch = NULL, n.genes = 20, two.sided = TRUE, n.pc = rep(1, length(pathways)), colcols = NULL, zlim = NULL, labRow = NA, vhc = NULL, cexCol = 1, cexRow = 1, nstarts = 50, ...(93 bytes skipped)...

461: ##' @param name URL path name for this app

5443:             switch(path,

6047:             switch(path,

1: ##' Single-cell Differential Expression (with Pathway And Gene set Overdispersion Analysis)

6: ##' The scde package also contains the pagoda framework which applies pathway and gene set overdispersion analysis

9: ##' See vignette("pagoda") for a brief tutorial on pathway and gene set overdispersion analysis to identify and characterize cell subpopulations.

1292: ...(39 bytes skipped)...lowed for the estimated adjusted variance (capping of adjusted variance is recommended when scoring pathway overdispersion relative to randomly sampled gene sets)

1789: ##' such as ribosomal pathway variation) and subtracts it from the data so that it is controlled

1815: ##' cc.pattern <- pagoda.show.pathways(ls(go.env)[1:2], varinfo, go.env, show.cell.dendrogram = TRUE, showRowLabels = TRUE)  # Look at...(30 bytes skipped)...

1845: ##' @param min.pathway.size minimum number of observed genes that should be contained in a valid gene set

1846: ##' @param max.pathway.size maximum number of observed genes in a valid gene set

1847: ...(103 bytes skipped)...ith each gene set (can be kept at 5 or 10, but should be increased to 50-100 if the significance of pathway overdispersion will be determined relative to random gene set models)

1873: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

1901:         gsl <- gsl[gsl.ng >= min.pathway.size & gsl.ng<= max.pathway.size]

1905:         message("processing ", length(gsl), " valid pathways")

1954: ##' @param pwpca result of the pagoda.pathway.wPCA() call with n.randomizations > 1

1965: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

2148:                 names(pathsizes) <- pathsizes

2151:                     rsdv <- unlist(lapply(names(pathsizes), function(s) {

2156:                     return(data.frame(n = as.integer(pathsizes), var = unlist(sdv), round = i, rvar = rsdv))

2160:                 data.frame(n = as.integer(pathsizes), var = unlist(sdv), round = i)

2216: ##' @param pwpca output of pagoda.pathway.wPCA()

2242: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

2393:     # determine genes driving significant pathways

2435: ##' @param pwpca output of pagoda.pathway.wPCA()

2453: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

2460:     pclc <- pathway.pc.correlation.distance(c(pwpca, clpca$cl.goc), tam$xv, target.ndf = 100, n.cores = n.cores)

2521: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

2603: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

2654: ##' @param tamr Combined pathways that show similar expression patterns. Output of \code{\link{pagoda.reduce.redundancy}}

2655: ##' @param row.clustering Dendrogram of combined pathways clustering

2667: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

2724: ##' @param tamr Combined pathways that show similar expression patterns. Output of \code{\link{pagoda.reduce.redundancy}}

2725: ##' @param tam Combined pathways that are driven by the same gene sets. Output of \code{\link{pagoda.reduce.loading.redundancy}}...(0 bytes skipped)...

2728: ...(15 bytes skipped)...a Weighted PC magnitudes for each gene set provided in the \code{env}. Output of \code{\link{pagoda.pathway.wPCA}}

2732: ##' @param row.clustering Dendrogram of combined pathways clustering. Default NULL.

2733: ##' @param title Title text to be used in the browser label for the app. Default, set as 'pathway clustering'

2739: ...(47 bytes skipped)... env, pwpca, clpca = NULL, col.cols = NULL, cell.clustering = NULL, row.clustering = NULL, title = "pathway clustering", zlim = c(-1, 1)*quantile(tamr$xv, p = 0.95)) {

2764:     # prepare pathway df

3559: .onUnload <- function(libpath) {

3560:     library.dynam.unload("scde", libpath, verbose = TRUE)

5108:         #set scale at top pathway?

5560:     lab <- which(proper.names %in% na.omit(unlist(mget(pathways, envir = env, ifnotfound = NA))))

5564:         lab <- which(proper.names %in% pathways)

5569:     #table(rownames(mat) %in% mget(pathways, envir = env))

5660: ##' View pathway or gene weighted PCA

5662: ##' Takes in a list of pathways (or a list of genes), runs weighted PCA, optionally showing the result.

5663: ##' @param pathways character vector of pathway or gene names

5665: ##' @param goenv environment mapping pathways to genes

5668: ...(5 bytes skipped)...param n.pc optional integer vector giving the number of principal component to show for each listed pathway

5681: ##' @param ... additional arguments are passed to the \code{c.view.pathways}

5687:     x <- c.view.pathways(pathways, varinfo$mat, varinfo$matw, goenv, batch = varinfo$batch, n.genes = n.genes, two.sided = two.si...(213 bytes skipped)...

5695: # takes in a list of pathways with a list of corresponding PC numbers

5696: # recalculates PCs for each individual pathway, weighting gene loading in each pathway and then by total

5697: # pathway variance over the number of genes (rough approximation)

5699:     # are these genes or pathways being passed?

5701:         x <- pathways %in% ls(goenv)

5703:         x <- rep(FALSE, length(pathways))

5705:     if(sum(x) > 0) { # some pathways matched

5707:         message("WARNING: partial match to pathway names. The following entries did not match: ", paste(pathways[!x], collapse = " "))

5709:         # look up genes for each pathway

5710:         pathways <- pathways[x]

5711:         p.genes <- mget(pathways, goenv, ifnotfound = NA)

5713:         x <- pathways %in% rownames(mat)

5716: ...(9 bytes skipped)...       message("WARNING: partial match to gene names. The following entries did not match: ", paste(pathways[!x], collapse = " "))

5718:             p.genes <- list("genes" = pathways[x])

5719:             pathways <- c("genes");

5720:         } else { # neither genes nor pathways are passed

5721:             stop("ERROR: provided names do not match either gene nor pathway names (if the pathway environment was provided)")

5728:     # recalculate wPCA for each pathway

5729:     ppca <- pagoda.path...(130 bytes skipped)...s), n.cores = 1, n.randomizations = 0, n.starts = 2, n.components = max(n.pc), verbose = FALSE, min.pathway.size = 0, max.pathway.size = Inf, n.internal.shuffles = 0)

5731:     if(length(ppca) > 1) { # if more than one pathway was supplied, combine genes using appropriate loadings and use consensus PCA (1st PC) as a patte...(2 bytes skipped)...

5733:         scaled.gene.loadings <- unlist(lapply(seq_along(pathways), function(i) {

5734:             gl <- ppca[[pathways[i]]]$xp$rotation[, n.pc[i], drop = TRUE]*as.numeric(ppca[[pathways[i]]]$xp$sd)[n.pc[i]]/sqrt(ppca[[pathways[i]]]$n)

5735:             names(gl) <- rownames(ppca[[pathways[i]]]$xp$rotation)

5777:     } else { # only one pathway was provided

5970: ##' @field results Output of the pathway clustering and redundancy reduction

5972: ##' @field pathways

5983:     fields = c('results', 'genes', 'pathways', 'mat', 'matw', 'goenv', 'renv', 'name', 'trim', 'batch'),

5986:         initialize = function(results, pathways, genes, mat, matw, goenv, batch = NULL, name = "pathway overdispersion", trim = 1.1/ncol(mat)) {

5995:             pathways <<- pathways

6012:                 gcl <- t.view.pathways(genes, mat = mat, matw = matw, env = goenv, vhc = results$hvc, plot = FALSE, trim = ltrim)

6058: ...(21 bytes skipped)...                <link rel = "stylesheet" type = "text/css" href = "http://pklab.med.harvard.edu/sde/pathcl.css" / >

6064: ...(10 bytes skipped)...                           <script type = "text/javascript" src = "http://pklab.med.harvard.edu/sde/pathcl.js" > </script >

6072:                    '/pathcl.json' = { # report pathway clustering heatmap data

6126:                    '/pathwaygenes.json' = { # report heatmap data for a selected set of genes

6133:                        x <- c.view.pathways(gsub("^#PC\\d+# ", "", pws), mat, matw, goenv = goenv, n.pc = n.pcs, n.genes = ngenes, two.side...(75 bytes skipped)...

6134:                        #x <- t.view.pathways(gsub("^#PC\\d+# ", "", pws), mat, matw, env = goenv, vhc = results$hvc, plot = FALSE, trim = lt...(14 bytes skipped)...

6174:                        ii <- which(results$ct == pathcl)

6251:                    '/pathways.json' = {

6252:                        lgt <- pathways

313:     std::string path;

208:     Bamfile(const char * path) : holding(false) { 

209:         in = sam_open(path, "rb");

212:             out << "failed to open BAM file at '" << path << "'";

267:         path=converter.str();

292:             out=std::fopen(path.c_str(), "a");

294:             out=std::fopen(path.c_str(), "w"); // Overwrite any existing file, just to be safe.

298:             err << "failed to open output file at '" << path << "'"; 

326:     const Rcpp::String bampath=check_string(bamfile, "BAM file path");

512:                 outpaths[j]=collected[i][j].path;

595:     Rcpp::String bampath=check_string(incoming, "BAM file path");

334:     Bamfile input(bampath.get_cstring());

596:     Bamfile input(bampath.get_cstring());

507:     Rcpp::List filepaths(nc);

509:         Rcpp::StringVector outpaths(i+1);

515:         filepaths[i]=outpaths;

518:     return Rcpp::List::create(filepaths, 

357:                         path <- system.file("extdata",package=paste0(input$Summarycompselect,"Expr"))

716:                                           path <- system.file("extdata",package=paste0(input$Summarycompselect,"Expr"))

358:                         load(paste0(path,"/geneid.rda"))

378:                                     load(paste0(path,"/quality.rda"))

388:                                     load(paste0(path,"/quality.rda"))

475:                               path <- system.file("extdata",package=paste0(input$Summarycompselect,"Expr"))

482:                                           tmpgeneexpr <- rbind(tmpgeneexpr,t(h5read(paste0(path,"/data",h5id,".h5"),"expr",index=list(NULL,match(currenth5gene,h5gene))))/1000)

485:                                     tmpgeneexpr <- t(h5read(paste0(path,"/data.h5"),"expr",index=list(NULL,match(currentgeneset[,2],Maindata$geneid))))/1000

724: ...(9 bytes skipped)...                                                   tmpgeneexpr <- rbind(tmpgeneexpr,t(h5read(paste0(path,"/data",h5id,".h5"),"expr",index=list(NULL,match(currenth5gene,h5gene))))/1000)

727:                                                 tmpgeneexpr <- t(h5read(paste0(path,"/data.h5"),"expr",index=list(NULL,match(currentgeneset[,2],Maindata$geneid))))/1000

118:                         tmpfile <- read.table(GenesetFileHandle$datapath,header=input$InputGenesetheader,sep=input$InputGenesetsep,quote=input$InputGenesetquote,stringsAsFa...(30 bytes skipped)...

401:                         tmptab <- read.table(input$Summaryuploadtabfile$datapath,stringsAsFactors=F,blank.lines.skip=TRUE)

405: ...(8 bytes skipped)...                Maindata$uploadgeneexpr <- as.matrix(read.table(input$Summaryuploadgeneexprfile$datapath,stringsAsFactors=F,blank.lines.skip=TRUE,row.names=1))

1917:                               tmp <- read.table(input$GSCAinteractiveload$datapath)

1946: ...(35 bytes skipped)... updateTextInput(session,"Formulainputtext","Input Formula",readLines(input$GSCAinteractiveload$datapath))

2412:                         Utidata$Maindata <- Utidata$rawdata <- read.table(UtiFileHandle$datapath,header=input$Utiheader,sep=input$Utisep,quote=input$Utiquote,stringsAsFactors=F,blank.lines.skip=TR...(15 bytes skipped)...

2002:     Path <- Create_Path(c(Root.folders['matrices'],chr,chr))

498:         Bintable.group.path <- Create_Path(

1361:     Group.path <- Create_Path(c(Reference.object$hdf.matrices.root,chr1,chr2))

1456:     Group.path <- Create_Path(c(Reference.object$hdf.matrices.root,chr,chr))

2522:     Group.path <- Create_Path(c(Reference.object$hdf.matrices.root,

2585:     Group_path <- Create_Path(c(Reference_object$hdf.matrices.root, 

2678:     Group.path <- Create_Path(c(Reference.object$hdf.matrices.root, chr1,

205:     Config_filepath <- .make_configuration_path(output_directory)

895:     Brick_filepath <- BrickContainer_get_path_to_file(Brick,

964:     Brick_filepath <- BrickContainer_get_path_to_file(Brick, 

1339:     Brick_filepath <- BrickContainer_get_path_to_file(Brick, 

1434:     Brick_filepath <- BrickContainer_get_path_to_file(Brick, 

1849:     Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick, 

2034:     Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick, 

2524:     Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick, 

2587:     Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick, 

2676:     Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick, 

703:     Brick_paths <- BrickContainer_get_path_to_file(Brick = Brick,

760:     Brick_filepaths <- BrickContainer_list_files(Brick = Brick, 

812:     Brick_filepaths <- BrickContainer_get_path_to_file(Brick,

18: #' A string containing the path to the file to load as the binning table for

141: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 

143: #' out_dir <- file.path(tempdir(), "Creator_test")

145: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 

178:             "without an explicit path", "definition!", "If you want to create",

180:             "please provide", "the complete path. Or, you can",

182:             paste("file.path(getwd())", sep = ""), 

300: #' the function will provide the path to the created/tracked HDF file.

306: #' out_dir <- file.path(tempdir(),"mcool_test_dir")

307: #' dir.create(path = out_dir)

311: #' destfile = file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool"))

313: #' mcool <- file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool")

332:         stop("mcool must be provided as mcool= /path/to/something")

339:         mcool.version <- GetAttributes(Path = Create_Path(

355:         mcool.version <- GetAttributes(Path = NULL, File=mcool, 

391: #' out_dir <- file.path(tempdir(),"mcool_test_dir")

392: #' dir.create(path = out_dir)

397: #' destfile = file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool"))

399: #' mcool <- file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool")

452: #' out_dir <- file.path(tempdir(), "mcool_test_dir")

453: #' dir.create(path = out_dir)

457: #' destfile = file.path(out_dir, "H1-hESC-HiC-4DNFI7JNCNFB.mcool"))

459: #' mcool <- file.path(out_dir, "H1-hESC-HiC-4DNFI7JNCNFB.mcool")

476:     mcool.version <- GetAttributes(Path = NULL, File=mcool,

502:         Bintable.group.path <- Create_Path(Bintable.group)

504:     Handler <- ._Brick_Get_Something_(Group.path = Bintable.group.path,

517: #' A string specifying the path to the Brick store created with 

534: #' Bintable_path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 

537: #' out_dir <- file.path(tempdir(), "HiCBricks_chrominfo_test")

541: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable_path, 

670: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 

673: #' out_dir <- file.path(tempdir(), "add_ranges_test")

677: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 

709:     bplapply(Brick_paths, function(Brick_path){

710:         ._Brick_Add_Ranges_(Brick = Brick_path,

711:         Group.path = Create_Path(c(Reference.object$hdf.ranges.root,

739: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 

742: #' out_dir <- file.path(tempdir(), "list_matrices_test")

746: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 

766:             Path = Create_Path(

794: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 

797: #' out_dir <- file.path(tempdir(), "list_rangekeys_test")