# ===================================================== # 芯片数据分析模块 (Microarray Data Analysis) # ===================================================== # 功能： # 1. 解析 GEO Series Matrix 文件 # 2. 解析 SOFT 平台注释文件 # 3. 探针注释 (探针ID → 基因符号) # 4. limma 差异分析 # 5. 与现有下游模块集成 (KEGG/GO/GSEA/TF/通路活性) # ===================================================== # ===================================================== # 1. GEO Series Matrix 文件解析 # ===================================================== #' 解析 GEO Series Matrix 文件 #' #' @param file_path Series Matrix 文件路径 #' @return list 包含表达矩阵和元数据 parse_geo_series_matrix <- function(file_path) { cat("📂 开始解析 GEO Series Matrix 文件...\n") tryCatch({ # 读取所有行 lines <- readLines(file_path, warn = FALSE) # 查找数据起始标记 start_idx <- which(lines == "!series_matrix_table_begin") if (length(start_idx) == 0) { return(list( success = FALSE, error = "未找到 !series_matrix_table_begin 标记，这不是有效的 GEO Series Matrix 文件" )) } start_idx <- start_idx[1] + 1 # 跳过标记行本身 # 查找数据结束标记（可选） end_idx <- which(lines == "!series_matrix_table_end") if (length(end_idx) > 0) { end_idx <- end_idx[1] - 1 } else { # 如果没有结束标记，读取到文件末尾 end_idx <- length(lines) } cat(sprintf("✅ 找到数据区域: 第 %d - %d 行\n", start_idx, end_idx)) # 提取矩阵数据 matrix_lines <- lines[start_idx:end_idx] # 读取为数据框 text_connection <- textConnection(matrix_lines) expr_matrix <- read.table( text_connection, header = TRUE, row.names = 1, sep = "\t", quote = "\"", # 允许引号 comment.char = "", stringsAsFactors = FALSE, check.names = FALSE ) close(text_connection) # 去除列名中的引号 colnames(expr_matrix) <- gsub('"', '', colnames(expr_matrix)) rownames(expr_matrix) <- gsub('"', '', rownames(expr_matrix)) cat(sprintf("✅ 清理引号后样本名示例: %s\n", paste(head(colnames(expr_matrix), 3), collapse = ", "))) cat(sprintf("✅ 清理引号后探针ID示例: %s\n", paste(head(rownames(expr_matrix), 3), collapse = ", "))) # 提取元数据（用于样本分组提示） metadata <- extract_geo_metadata(lines[1:(start_idx-2)]) cat(sprintf("✅ 解析完成: %d 探针 × %d 样本\n", nrow(expr_matrix), ncol(expr_matrix))) return(list( success = TRUE, matrix = expr_matrix, metadata = metadata, n_probes = nrow(expr_matrix), n_samples = ncol(expr_matrix), sample_names = colnames(expr_matrix) )) }, error = function(e) { return(list( success = FALSE, error = paste("解析文件时出错:", e$message) )) }) } #' 提取 GEO 元数据 #' #' @param metadata_lines 元数据行 #' @return list 包含样本描述等信息 extract_geo_metadata <- function(metadata_lines) { result <- list( has_metadata = FALSE, sample_descriptions = NULL, sample_titles = NULL ) # 查找样本描述行 desc_line <- grep("^!Sample_description", metadata_lines, value = TRUE) if (length(desc_line) > 0) { # 提取描述信息 descriptions <- gsub("^!Sample_description\t", "", desc_line) descriptions <- gsub('"', '', descriptions) # 分割成向量 descriptions <- strsplit(descriptions[1], "\t")[[1]] result$sample_descriptions <- descriptions result$has_metadata <- TRUE } # 查找样本标题行 title_line <- grep("^!Sample_title", metadata_lines, value = TRUE) if (length(title_line) > 0) { # 提取标题信息 titles <- gsub("^!Sample_title\t", "", title_line) titles <- gsub('"', '', titles) # 分割成向量 titles <- strsplit(titles[1], "\t")[[1]] result$sample_titles <- titles result$has_metadata <- TRUE } return(result) } # ===================================================== # 2. SOFT 平台文件解析 # ===================================================== #' 解析 SOFT 平台注释文件 #' #' @param file_path SOFT 文件路径 #' @param separator 字段分隔符（正则表达式，默认为Tab） #' @return list 包含原始表格和探针-基因映射 parse_platform_annotation <- function(file_path, separator = "\t") { cat("📋 开始解析 SOFT 平台文件...\n") cat(sprintf("📋 使用分隔符: %s\n", separator)) tryCatch({ lines <- readLines(file_path, warn = FALSE) # 查找平台表起始标记 start_idx <- which(lines == "!platform_table_begin") if (length(start_idx) == 0) { return(list( success = FALSE, error = "未找到 !platform_table_begin 标记" )) } start_idx <- start_idx[1] + 1 # 读取到文件末尾或下一个 ^ 标记 remaining_lines <- lines[start_idx:length(lines)] next_section <- which(grepl("^\\^", remaining_lines)) if (length(next_section) > 0) { end_idx <- start_idx + next_section[1] - 2 } else { end_idx <- length(lines) } table_lines <- lines[start_idx:end_idx] # 读取表头（使用用户指定的分隔符） header <- strsplit(table_lines[1], separator)[[1]] # 读取数据（使用用户指定的分隔符） text_conn <- textConnection(table_lines) raw_table <- read.table( text_conn, header = TRUE, sep = separator, quote = "", stringsAsFactors = FALSE, fill = TRUE, check.names = FALSE ) close(text_conn) cat(sprintf("📋 平台注释文件解析: %d 列 × %d 行\n", ncol(raw_table), nrow(raw_table))) cat("📋 列名:", paste(colnames(raw_table), collapse = ", "), "\n") # 🔍 显示各列的示例数据，帮助用户选择 cat("📋 各列示例数据:\n") for (col in colnames(raw_table)) { sample_vals <- head(raw_table[[col]][!is.na(raw_table[[col]]) & raw_table[[col]] != ""], 3) cat(sprintf(" %s: %s\n", col, paste(sample_vals, collapse = ", "))) } # ❌ 不再自动检测基因符号列，由用户手动选择 cat("⚠️ 请用户手动选择基因符号列\n") # 返回原始表格，不进行自动检测和映射 return(list( success = TRUE, raw_table = raw_table, mapping = NULL, # 不提供自动映射 gene_symbol_col = NULL, # 不提供自动检测的列名 needs_manual_selection = TRUE, # 标记需要手动选择 message = "请手动选择ID列和基因列" )) }, error = function(e) { return(list( success = FALSE, error = paste("解析 SOFT 文件时出错:", e$message) )) }) } #' 智能检测基因符号列（改进版 - 基于内容分析） #' #' @param table 平台注释数据框 #' @return 字符列名或 NULL detect_gene_symbol_column <- function(table) { cat("🔍 开始智能检测基因符号列...\n") # 常见的基因符号列名（优先级高） high_priority_names <- c( "GENE_SYMBOL", "Gene.Symbol", "Gene_Symbol", "gene_symbol", "SYMBOL", "Symbol", "Gene Symbol" ) # 方法1: 优先级列名匹配 for (name in high_priority_names) { if (name %in% colnames(table)) { # 验证：检查该列是否真的包含基因符号格式 col_data <- table[[name]] col_data <- col_data[!is.na(col_data) & col_data != ""] n_check <- min(50, length(col_data)) if (n_check >= 10) { # 检查是否包含典型基因符号格式 # 基因符号：字母开头，可能包含数字和连字符，长度2-20 pattern <- "^[A-Z][A-Z0-9\\-]{1,15}$" match_ratio <- sum(grepl(pattern, col_data[1:n_check])) / n_check if (match_ratio > 0.5) { # 超过50%匹配 cat(sprintf("✅ 智能检测到基因列(高优先级): %s (匹配率: %.1f%%)\n", name, match_ratio*100)) return(name) } } } } # 方法2: 列名部分匹配 for (name in high_priority_names) { matching_cols <- colnames(table)[sapply(colnames(table), function(col) { grepl(name, col, ignore.case = TRUE) })] if (length(matching_cols) > 0) { # 验证内容 for (col_name in matching_cols) { col_data <- table[[col_name]] col_data <- col_data[!is.na(col_data) & col_data != ""] n_check <- min(50, length(col_data)) if (n_check >= 10) { pattern <- "^[A-Z][A-Z0-9\\-]{1,15}$" match_ratio <- sum(grepl(pattern, col_data[1:n_check])) / n_check if (match_ratio > 0.5) { cat(sprintf("✅ 智能检测到基因列(模糊匹配): %s (匹配率: %.1f%%)\n", col_name, match_ratio*100)) return(col_name) } } } } } # 方法3: 检查所有列的内容特征 best_col <- NULL best_match_ratio <- 0 for (col_name in colnames(table)) { # 跳过明显不是基因的列 if (col_name %in% c("ID", "SPOT_ID", "CONTROL_TYPE", "REFSEQ", "GB_ACC", "UNIGENE_ID", "ENSEMBL_ID", "TIGR_ID", "ACCESSION_STRING", "CHROMOSOMAL_LOCATION", "CYTOBAND", "DESCRIPTION", "GO_ID", "SEQUENCE")) { next } col_data <- table[[col_name]] col_data <- col_data[!is.na(col_data) & col_data != ""] n_check <- min(100, length(col_data)) if (n_check < 10) next # 检查基因符号特征 # 典型基因符号：TP53, EGFR, BRCA1, MYC, IL-6, TNF-alpha patterns <- c( "^[A-Z][A-Z0-9]{1,10}$", # 简单基因符号：TP53, EGFR "^[A-Z][A-Z0-9]{1,5}-[0-9]+$", # 带数字的：BRCA1-001 "^[A-Z]{2,6}-[A-Z0-9]{1,3}$" # 带连字符的：IL-6, TNF-a ) match_count <- sum(sapply(patterns, function(p) { sum(grepl(p, col_data[1:n_check])) })) match_ratio <- match_count / n_check if (match_ratio > best_match_ratio && match_ratio > 0.3) { best_match_ratio <- match_ratio best_col <- col_name } } if (!is.null(best_col)) { cat(sprintf("✅ 智能检测到基因列(内容分析): %s (匹配率: %.1f%%)\n", best_col, best_match_ratio*100)) return(best_col) } cat("⚠️ 无法自动检测基因符号列，需要用户手动选择\n") return(NULL) } #' 执行探针注释（合并表达矩阵和基因映射） #' #' @param expr_matrix 探针表达矩阵 #' @param probe_gene_map 探针-基因映射数据框 #' @return 基因表达矩阵 annotate_probe_matrix <- function(expr_matrix, probe_gene_map) { cat("🔄 开始探针注释...\n") # 找到共同的探针 common_probes <- intersect(rownames(expr_matrix), probe_gene_map$probe_id) if (length(common_probes) == 0) { stop("❌ 探针ID不匹配，请检查平台注释文件是否正确") } cat(sprintf("📊 共同探针数: %d (表达矩阵: %d, 注释文件: %d)\n", length(common_probes), nrow(expr_matrix), nrow(probe_gene_map))) # 提取共同探针的表达数据 expr_subset <- expr_matrix[common_probes, , drop = FALSE] # 添加探针ID列以便合并 expr_subset <- data.frame(probe_id = rownames(expr_subset), expr_subset, stringsAsFactors = FALSE) # 合并基因符号 merged <- merge(expr_subset, probe_gene_map, by = "probe_id") # 移除探针ID列 probe_id_col <- which(names(merged) == "probe_id") if (length(probe_id_col) > 0) { merged <- merged[, -probe_id_col] } # 按基因分组，对表达值取平均值 # 如果一个基因对应多个探针，取平均值 library(dplyr) expr_annotated <- merged %>% group_by(gene_symbol) %>% summarise(across(everything(), mean, na.rm = TRUE)) %>% column_to_rownames("gene_symbol") # 转换为矩阵 expr_annotated <- as.matrix(expr_annotated) cat(sprintf("✅ 探针注释完成: %d 探针 → %d 基因\n", length(common_probes), nrow(expr_annotated))) # 检查是否有基因被重复注释 n_probes_per_gene <- table(merged$gene_symbol) n_multi_probe_genes <- sum(n_probes_per_gene > 1) if (n_multi_probe_genes > 0) { cat(sprintf("📊 其中 %d 个基因有多个探针(已取平均)\n", n_multi_probe_genes)) } return(expr_annotated) } # ===================================================== # 3. limma 差异分析 # ===================================================== #' 使用 limma 进行芯片数据差异分析 #' #' @param expr_matrix 基因表达矩阵 #' @param ctrl_samples 对照组样本名 #' @param trt_samples 处理组样本名 #' @param pvalue_threshold P值阈值 #' @param logfc_threshold log2FC阈值 #' @param pval_type P值类型："adj.P.Val" 或 "P.Value" #' @return 差异分析结果 run_limma_analysis <- function(expr_matrix, ctrl_samples, trt_samples, pvalue_threshold = 0.05, logfc_threshold = 1, pval_type = "adj.P.Val") { cat("🧬 开始 limma 差异分析...\n") # 检查样本 if (length(ctrl_samples) == 0 || length(trt_samples) == 0) { stop("❌ 对照组和处理组样本数不能为0") } # 重新排序矩阵（按照 Control -> Treatment） sample_order <- c(ctrl_samples, trt_samples) # 检查样本是否存在 missing_samples <- setdiff(sample_order, colnames(expr_matrix)) if (length(missing_samples) > 0) { stop(sprintf("❌ 以下样本不存在于表达矩阵中: %s", paste(missing_samples, collapse = ", "))) } expr_ordered <- expr_matrix[, sample_order, drop = FALSE] # 🆕 检查并移除非数值列（如ProbeID和Gene） # limma需要纯数值表达矩阵 if ("ProbeID" %in% colnames(expr_ordered)) { cat("📋 移除ProbeID列（非数值）\n") expr_ordered <- expr_ordered[, colnames(expr_ordered) != "ProbeID", drop = FALSE] } if ("Gene" %in% colnames(expr_ordered)) { cat("📋 移除Gene列（非数值）\n") expr_ordered <- expr_ordered[, colnames(expr_ordered) != "Gene", drop = FALSE] } # 确保所有列都是数值 expr_ordered <- as.matrix(expr_ordered) storage.mode(expr_ordered) <- "numeric" cat(sprintf("📊 最终分析矩阵: %d 基因 × %d 样本\n", nrow(expr_ordered), ncol(expr_ordered))) # 创建分组因子 group <- factor(c(rep("Control", length(ctrl_samples)), rep("Treatment", length(trt_samples)))) cat(sprintf("📊 样本分组: Control=%d, Treatment=%d\n", length(ctrl_samples), length(trt_samples))) # 加载 limma library(limma) # 设计矩阵 design <- model.matrix(~0 + group) colnames(design) <- levels(group) cat("📊 设计矩阵:\n") print(design) # 线性模型拟合 fit <- lmFit(expr_ordered, design) # 设置对比 contrast.matrix <- makeContrasts(Treatment-Control, levels=design) cat("📊 对比矩阵:\n") print(contrast.matrix) fit2 <- contrasts.fit(fit, contrast.matrix) fit2 <- eBayes(fit2) # 提取结果 results <- topTable(fit2, number = Inf, adjust.method = "BH", sort.by = "P") # 🔧 修复：正确设置ID和SYMBOL列 # rownames(results) 是基因符号（如"FAM174B", "TP53"） # expr_matrix现在包含EntrezID列（如果有），用于ID列 results$SYMBOL <- rownames(results) # SYMBOL = 基因符号（行名） # ID列使用EntrezID（如果存在），否则使用基因符号 if ("EntrezID" %in% colnames(expr_matrix)) { # expr_matrix的行名对应results的行名 results$ID <- expr_matrix[rownames(results), "EntrezID"] # ID = Entrez Gene ID cat("✅ ID列使用Entrez Gene ID，SYMBOL列使用基因符号\n") } else { results$ID <- rownames(results) # 没有EntrezID时，ID也用基因符号 cat("✅ ID列和SYMBOL列都使用基因符号（无EntrezID）\n") } # 计算统计信息 - 根据用户选择的P值类型 n_total <- nrow(results) # 🔧 使用用户选择的P值类型 pval_col <- if (pval_type == "adj.P.Val") "adj.P.Val" else "P.Value" pval_values <- results[[pval_col]] n_significant <- sum(pval_values < pvalue_threshold, na.rm = TRUE) n_up <- sum(results$logFC > logfc_threshold & pval_values < pvalue_threshold, na.rm = TRUE) n_down <- sum(results$logFC < -logfc_threshold & pval_values < pvalue_threshold, na.rm = TRUE) cat(sprintf("✅ limma 分析完成: %d 个基因\n", n_total)) cat(sprintf(" 使用P值类型: %s\n", pval_type)) cat(sprintf(" 显著差异基因 (%s < %.3f): %d (%.1f%%)\n", pval_type, pvalue_threshold, n_significant, n_significant/n_total*100)) cat(sprintf(" 上调基因 (log2FC > %.2f): %d\n", logfc_threshold, n_up)) cat(sprintf(" 下调基因 (log2FC < %.2f): %d\n", logfc_threshold, n_down)) return(list( results = results, n_total = n_total, n_significant = n_significant, n_up = n_up, n_down = n_down, design = design, fit = fit2 )) } # ===================================================== # 4. 探针表达量聚合 # ===================================================== #' 聚合探针表达量到基因水平 #' #' @param probe_matrix 探针表达矩阵（行为探针，列为样本） #' @param probe_mapping 探针-基因映射数据框（从 parse_soft_platform 返回） #' @return 基因表达矩阵（行为基因，列为样本） aggregate_probe_expression <- function(probe_matrix, probe_mapping) { cat("🔄 开始聚合探针表达量...\n") # 提取映射关系 probe_ids <- probe_mapping$probe_id gene_symbols <- probe_mapping$gene_symbol # 创建映射向量（探针ID -> 基因符号） names(gene_symbols) <- probe_ids # 过滤掉未映射的探针 common_probes <- intersect(rownames(probe_matrix), probe_ids) if (length(common_probes) == 0) { cat("⚠️ 未找到匹配的探针ID\n") return(NULL) } cat(sprintf("✅ 匹配探针: %d / %d\n", length(common_probes), nrow(probe_matrix))) # 子集表达矩阵和映射 expr_subset <- probe_matrix[common_probes, , drop = FALSE] gene_symbols_subset <- gene_symbols[common_probes] # 移除NA和空字符串 valid_mask <- !is.na(gene_symbols_subset) & gene_symbols_subset != "" expr_subset <- expr_subset[valid_mask, , drop = FALSE] gene_symbols_subset <- gene_symbols_subset[valid_mask] # 聚合方法：对于每个基因，选择表达量最高的探针 cat("📊 聚合策略: 选择最高表达探针\n") # 获取唯一基因 unique_genes <- unique(gene_symbols_subset) cat(sprintf("📊 唯一基因数: %d\n", length(unique_genes))) # 为每个基因选择表达量最高的探针 gene_expr_list <- lapply(unique_genes, function(gene) { # 找到该基因的所有探针 gene_probes <- which(gene_symbols_subset == gene) if (length(gene_probes) == 1) { # 只有一个探针，直接使用 return(expr_subset[gene_probes, , drop = FALSE]) } else { # 多个探针，选择平均表达量最高的 avg_expr <- rowMeans(expr_subset[gene_probes, , drop = FALSE]) best_probe <- gene_probes[which.max(avg_expr)] return(expr_subset[best_probe, , drop = FALSE]) } }) # 合并为基因表达矩阵 gene_expr_matrix <- do.call(rbind, gene_expr_list) rownames(gene_expr_matrix) <- unique_genes cat(sprintf("✅ 聚合完成: %d 个基因\n", nrow(gene_expr_matrix))) return(gene_expr_matrix) } # ===================================================== # 5. 智能样本分组系统（通用版本） # ===================================================== #' 从 Series Matrix 元数据中自动检测分组 #' #' @param sample_names 样本名向量 #' @param sample_descriptions 样本描述向量（可选） #' @param sample_titles 样本标题向量（可选） #' @return list 包含分组建议和分组方法 detect_chip_groups_auto <- function(sample_names, sample_descriptions = NULL, sample_titles = NULL) { cat("🔍 开始自动检测分组模式...\n") cat(sprintf("📊 总样本数: %d\n", length(sample_names))) # 定义常见的分组模式 group_patterns <- list( # 模式1: 时间序列 (before/after, baseline/followup) list( name = "时间序列", ctrl_keywords = c("before", "baseline", "time0", "initial", "visit1"), trt_keywords = c("after", "post", "follow", "final", "visit2", "visit3") ), # 模式2: 处理对照 (control/treated) list( name = "处理对照", ctrl_keywords = c("control", "ctrl", "untreated", "vehicle", "placebo"), trt_keywords = c("treatment", "treated", "drug", "compound", "stimulated") ), # 模式3: 疾病对照 (normal/disease) list( name = "疾病对照", ctrl_keywords = c("normal", "healthy", "control", "wild"), trt_keywords = c("disease", "patient", "cancer", "tumor", "sick") ), # 模式4: 基因型 (wildtype/mutant) list( name = "基因型", ctrl_keywords = c("wild", "wt", "wildtype", "normal", "control"), trt_keywords = c("mutant", "mut", "knockout", "ko", "transgenic", "tg") ), # 模式5: 剂量反应 (control/dose) list( name = "剂量反应", ctrl_keywords = c("dose0", "dose_0", "control", "vehicle", "untreated"), trt_keywords = c("dose", "treatment", "low", "medium", "high") ), # 模式6: 激活/抑制 list( name = "激活抑制", ctrl_keywords = c("inactive", "unstimulated", "resting", "control"), trt_keywords = c("active", "stimulated", "induced", "activated") ) ) # 方法1: 从 sample_descriptions 检测 if (!is.null(sample_descriptions) && length(sample_descriptions) > 0) { cat("📋 尝试从 Sample_description 检测分组...\n") for (pattern in group_patterns) { ctrl_match <- sapply(sample_descriptions, function(d) { any(sapply(pattern$ctrl_keywords, function(kw) { grepl(kw, d, ignore.case = TRUE) })) }) trt_match <- sapply(sample_descriptions, function(d) { any(sapply(pattern$trt_keywords, function(kw) { grepl(kw, d, ignore.case = TRUE) })) }) # 检查是否找到匹配 if (sum(ctrl_match) > 0 && sum(trt_match) > 0) { ctrl_idx <- which(ctrl_match) trt_idx <- which(trt_match) cat(sprintf("✅ 检测到 '%s' 分组模式 (from description)\n", pattern$name)) cat(sprintf(" 对照组: %d 个样本 (%s)\n", length(ctrl_idx), paste(sample_names[ctrl_idx], collapse = ", "))) cat(sprintf(" 处理组: %d 个样本 (%s)\n", length(trt_idx), paste(sample_names[trt_idx], collapse = ", "))) return(list( pattern_name = pattern$name, method = "auto_description", ctrl_samples = sample_names[ctrl_idx], trt_samples = sample_names[trt_idx], ctrl_indices = ctrl_idx, trt_indices = trt_idx, confidence = "high", source = "description" )) } } } # 方法2: 从 sample_titles 检测 if (!is.null(sample_titles) && length(sample_titles) > 0) { cat("📋 尝试从 Sample_title 检测分组...\n") for (pattern in group_patterns) { ctrl_match <- sapply(sample_titles, function(t) { any(sapply(pattern$ctrl_keywords, function(kw) { grepl(kw, t, ignore.case = TRUE) })) }) trt_match <- sapply(sample_titles, function(t) { any(sapply(pattern$trt_keywords, function(kw) { grepl(kw, t, ignore.case = TRUE) })) }) if (sum(ctrl_match) > 0 && sum(trt_match) > 0) { ctrl_idx <- which(ctrl_match) trt_idx <- which(trt_match) cat(sprintf("✅ 检测到 '%s' 分组模式 (from title)\n", pattern$name)) cat(sprintf(" 对照组: %d 个样本\n", length(ctrl_idx))) cat(sprintf(" 处理组: %d 个样本\n", length(trt_idx))) return(list( pattern_name = pattern$name, method = "auto_title", ctrl_samples = sample_names[ctrl_idx], trt_samples = sample_names[trt_idx], ctrl_indices = ctrl_idx, trt_indices = trt_idx, confidence = "medium", source = "title" )) } } } # 方法3: 从样本名本身检测 cat("📋 尝试从样本名检测分组...\n") # 简化样本名（移除GSM前缀） simplified_names <- gsub("^GSM\\d+_", "", sample_names) for (pattern in group_patterns) { ctrl_match <- sapply(simplified_names, function(n) { any(sapply(pattern$ctrl_keywords, function(kw) { grepl(kw, n, ignore.case = TRUE) })) }) trt_match <- sapply(simplified_names, function(n) { any(sapply(pattern$trt_keywords, function(kw) { grepl(kw, n, ignore.case = TRUE) })) }) if (sum(ctrl_match) > 0 && sum(trt_match) > 0) { ctrl_idx <- which(ctrl_match) trt_idx <- which(trt_match) cat(sprintf("✅ 检测到 '%s' 分组模式 (from name)\n", pattern$name)) cat(sprintf(" 对照组: %d 个样本\n", length(ctrl_idx))) cat(sprintf(" 处理组: %d 个样本\n", length(trt_idx))) return(list( pattern_name = pattern$name, method = "auto_name", ctrl_samples = sample_names[ctrl_idx], trt_samples = sample_names[trt_idx], ctrl_indices = ctrl_idx, trt_indices = trt_idx, confidence = "medium", source = "name" )) } } # 所有方法都失败 cat("⚠️ 未能自动检测到分组模式，请手动设置\n") return(list( pattern_name = NULL, method = "manual", ctrl_samples = NULL, trt_samples = NULL, ctrl_indices = NULL, trt_indices = NULL, confidence = NULL, source = NULL )) } #' 检测配对关系 #' #' @param sample_names 样本名 #' @param metadata 元数据 #' @return list 配对关系或NULL detect_pairing <- function(sample_names, metadata) { # 尝试从样本名中提取配对信息 # 例如: Patient1_before, Patient1_after # 提取共同的配对标识符 # 方法：移除已知的对照组/处理组关键词后，看剩余部分是否匹配 # 简化样本名 simplified <- gsub("^GSM\\d+_", "", sample_names) # 定义配对关键词 pairing_keywords <- list( before = "after", baseline = "follow", control = "treated", time0 = "time1", visit1 = "visit2", pre = "post" ) # 尝试检测配对模式 for (kw1 in names(pairing_keywords)) { kw2 <- pairing_keywords[[kw1]] # 检查是否有样本包含这些关键词 has_kw1 <- grepl(kw1, simplified, ignore.case = TRUE) has_kw2 <- grepl(kw2, simplified, ignore.case = TRUE) if (sum(has_kw1) > 0 && sum(has_kw2) > 0) { # 提取配对标识符 ids_kw1 <- gsub(kw1, "", simplified[has_kw1], ignore.case = TRUE) ids_kw2 <- gsub(kw2, "", simplified[has_kw2], ignore.case = TRUE) # 找到共同的ID common_ids <- intersect(ids_kw1, ids_kw2) if (length(common_ids) > 0) { cat(sprintf("💡 检测到配对设计: %d 对样本\n", length(common_ids))) return(list( is_paired = TRUE, n_pairs = length(common_ids), pairing_pattern = sprintf("%s/%s", kw1, kw2) )) } } } return(list(is_paired = FALSE)) } # ===================================================== # 5. 转换为标准格式（与现有模块兼容） # ===================================================== #' 将芯片差异分析结果转换为标准格式 #' #' @param limma_results limma 分析结果 #' @param expr_matrix 表达矩阵 #' @param ctrl_samples 对照组样本 #' @param trt_samples 处理组样本 #' @return 标准格式的差异分析结果 format_chip_results_for_pipeline <- function(limma_results, expr_matrix, ctrl_samples, trt_samples) { # 🔧 修复：正确使用ID（EntrezID）和SYMBOL（基因符号）列 limma_res <- limma_results$results deg_df <- data.frame( ID = limma_res$ID, # Entrez Gene ID（如果有的话） SYMBOL = limma_res$SYMBOL, # 基因符号 log2FoldChange = limma_res$logFC, # log2倍数变化 pvalue = limma_res$P.Value, # 原始p值 padj = limma_res$adj.P.Val, # BH校正p值 baseMean = limma_res$AveExpr, # 平均表达 t = limma_res$t, # t统计量（用于TF活性分析） row.names = NULL, stringsAsFactors = FALSE ) # ENTREZID列与ID列相同（都是Entrez Gene ID） deg_df$ENTREZID <- deg_df$ID return(list( deg_df = deg_df, background_genes = rownames(expr_matrix), # 背景基因（用于富集分析） expr_matrix = expr_matrix, # 完整表达矩阵（用于 AUCell/GSVA） ctrl_samples = ctrl_samples, trt_samples = trt_samples, method = "limma", n_significant = limma_results$n_significant, n_up = limma_results$n_up, n_down = limma_results$n_down )) } # ===================================================== # 6. Shiny Server 函数 # ===================================================== #' 芯片数据分析模块 UI 生成函数 #' #' @return UI 元素 chip_analysis_ui <- function() { tagList( fluidRow( column(12, div( class = "info-box", style = "background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 25px; border-radius: 15px; margin-bottom: 25px;", h4("🧬 芯片数据分析模块", style = "margin-top: 0; color: white;"), p("支持 GEO Series Matrix 格式的芯片数据差异分析，自动探针注释，无缝集成下游富集分析。", style = "color: rgba(255,255,255,0.9); margin-bottom: 0;") ) ) ), # 🎨 使用可折叠面板组织所有步骤 tags$div( id = "chip_analysis_accordion", # ===== 面板1: 数据上传 ===== tags$div( class = "panel panel-default", tags$div( class = "panel-heading", style = "cursor: pointer; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 15px;", `data-toggle` = "collapse", `data-target` = "#panel_upload", tags$h4( class = "panel-title", style = "margin: 0;", tags$span(icon("upload"), " 📁 步骤1: 数据上传与预览") ) ), tags$div( id = "panel_upload", class = "panel-collapse collapse in", # in = 默认展开 wellPanel( # 文件上传 fluidRow( column(6, h5("📄 上传数据文件", style = "color: #007AFF;"), fileInput("chip_series_matrix", "GEO Series Matrix 文件", accept = c(".txt", ".matrix.txt", "text/plain"), placeholder = "选择文件..."), helpText("GEO 数据库下载的 Series Matrix 文件（通常包含样本表达矩阵）") ), column(6, fileInput("chip_soft_platform", "SOFT 平台注释文件 (可选)", accept = c(".txt", ".soft", "annot.txt", "text/plain"), placeholder = "选择文件..."), helpText("用于探针注释的 GPL 平台文件。如不上传，系统将尝试自动注释。") ) ), tags$hr(style = "border-color: #dee2e6;"), # 数据预览 h5("📊 数据文件预览", style="color: #007AFF;"), fluidRow( column(6, h6("Series Matrix 文件（前5行）", style="color: #666;"), DTOutput("chip_series_matrix_preview") ), column(6, h6("SOFT 文件（前10行）", style="color: #666;"), DTOutput("chip_soft_raw_preview") ) ) ), tags$div( class = "panel-body", style = "padding: 15px;" ) ) ), # ===== 面板2: 探针注释配置 ===== tags$div( class = "panel panel-default", tags$div( class = "panel-heading", style = "cursor: pointer; background: linear-gradient(135deg, #9C27B0 0%, #7B1FA2 100%); color: white; padding: 15px;", `data-toggle` = "collapse", `data-target` = "#panel_annotation", tags$h4( class = "panel-title", style = "margin: 0;", tags$span(icon("cogs"), " 🧬 步骤2: 探针注释与数据合并") ) ), tags$div( id = "panel_annotation", class = "panel-collapse collapse", # 默认折叠 wellPanel( # SOFT文件列名清单 uiOutput("chip_soft_columns_list_ui"), tags$hr(style = "border-color: #dee2e6;"), # 探针注释配置 h5("📋 探针注释配置", style = "color: #9C27B0;"), uiOutput("chip_soft_column_selection_panel"), tags$hr(style = "border-color: #dee2e6;"), # 合并操作按钮 fluidRow( column(6, actionButton("chip_preview_merge", "👁️ 预览合并结果", class = "btn-info", style = "width: 100%;") ), column(6, actionButton("chip_apply_merge", "✅ 应用配置并生成最终矩阵", class = "btn-success", style = "width: 100%;") ) ), # 合并预览 conditionalPanel( condition = "input.chip_preview_merge", wellPanel( style = "background: #e8f5e9; border: 2px solid #4caf50;", h5("👁️ 合并结果预览（前5行）", style = "color: #2e7d32;"), DTOutput("chip_merge_preview_table") ) ), # 最终矩阵显示 conditionalPanel( condition = "input.chip_apply_merge", wellPanel( style = "background: linear-gradient(135deg, #e8f5e9 0%, #c8e6c9 100%); border: 2px solid #4caf50;", h5("✅ 最终表达矩阵", style = "color: #2e7d32; font-size: 18px; font-weight: bold;"), uiOutput("chip_final_matrix_ui"), br(), helpText("💡 此矩阵可直接用于后续的差异分析。已将探针ID和基因符号合并到表达数据中。", style = "color: #2e7d33;") ) ) ) ), # ===== 面板3: 数据预处理与探针去重 ===== tags$div( class = "panel panel-default", tags$div( class = "panel-heading", style = "cursor: pointer; background: linear-gradient(135deg, #ff9800 0%, #f57c00 100%); color: white; padding: 15px;", `data-toggle` = "collapse", `data-target` = "#panel_preprocess", tags$h4( class = "panel-title", style = "margin: 0;", tags$span(icon("sliders-h"), " 🔧 步骤3: 数据预处理与探针去重") ) ), tags$div( id = "panel_preprocess", class = "panel-collapse collapse in", # 默认展开 wellPanel( # 预处理 h5("📊 数据预处理（log2转换 + 标准化）", style = "color: #ff9800; font-weight: bold;"), fluidRow( column(6, checkboxInput("chip_auto_log2", "自动判断并执行log2转换", value = TRUE), checkboxInput("chip_normalize_data", "执行limma标准化（normalizeBetweenArrays）", value = TRUE) ), column(6, actionButton("chip_preprocess_data", "⚙️ 执行预处理", class = "btn-warning", style = "width: 100%;") ) ), # 预处理结果 conditionalPanel( condition = "input.chip_preprocess_data", uiOutput("chip_preprocess_result_ui") ), tags$hr(style = "border-color: #ffc107;"), # 批次矫正 h5("🎛️ 批次效应矫正（可选）", style = "color: #E91E63; font-weight: bold;"), fluidRow( column(6, selectInput("chip_batch_method", "批次矫正方法", choices = c("无" = "none", "ComBat (sva)" = "combat", "ComBat (limma)" = "limma", "SVA" = "sva"), selected = "none") ), column(6, actionButton("chip_apply_batch_correct", "🎛️ 执行批次矫正", class = "btn-danger", style = "width: 100%;") ) ), # 批次矫正结果 conditionalPanel( condition = "input.chip_apply_batch_correct", uiOutput("chip_batch_correct_result_ui") ), tags$hr(style = "border-color: #ffc107;"), # 探针去重 h5("✂️ 探针去重（保留表达量最高的探针）", style = "color: #ff9800; font-weight: bold;"), helpText("当一个基因对应多个探针时，保留表达量最高的探针。这将生成基因级别的表达矩阵。"), fluidRow( column(6, h6("去重前统计：", style = "color: #666;"), uiOutput("chip_before_dedupe_stats") ), column(6, h6("去重后统计：", style = "color: #666;"), uiOutput("chip_after_dedupe_stats") ) ), actionButton("chip_dedupe_probes", "✂️ 执行探针去重", class = "btn-warning btn-lg", style = "width: 100%;"), # 去重结果 conditionalPanel( condition = "input.chip_dedupe_probes", wellPanel( h6("✅ 去重完成", style = "color: #28a745;"), uiOutput("chip_dedupe_result_ui") ) ), tags$hr(style = "border-color: #ffc107;"), # 生成标准格式数据 h5("💾 生成标准格式数据", style = "color: #ff9800; font-weight: bold;"), helpText("将处理后的表达矩阵转换成标准格式，可直接用于后续的差异分析、KEGG、GO等模块。"), fluidRow( column(12, div( style = "background: #d4edda; padding: 15px; border-radius: 8px; border: 1px solid #c3e6cb;", h6("💡 即可对接现有分析模块：", style = "color: #155724;"), tags$ul(style="margin: 10px 0; padding-left: 20px;", tags$li("差异分析（使用现有的差异分析模块）"), tags$li("KEGG富集分析（使用现有的KEGG模块）"), tags$li("GO富集分析（使用现有的GO模块）"), tags$li("GSEA分析（使用现有的GSEA模块）") ) ) ) ), actionButton("chip_generate_standard_data", "🚀 生成标准格式数据", class = "btn-success btn-lg", style = "width: 100%; font-size: 16px;") ) ) ), # ===== 面板4: 差异分析 ===== tags$div( class = "panel panel-default", tags$div( class = "panel-heading", style = "cursor: pointer; background: linear-gradient(135deg, #34C759 0%, #2e7d32 100%); color: white; padding: 15px;", `data-toggle` = "collapse", `data-target` = "#panel_diff_analysis", tags$h4( class = "panel-title", style = "margin: 0;", tags$span(icon("chart-bar"), " 🧬 步骤4: 差异分析") ) ), tags$div( id = "panel_diff_analysis", class = "panel-collapse collapse", # 默认折叠 style = "padding: 15px;", wellPanel( # 样本分组 uiOutput("chip_grouping_ui"), tags$hr(style = "border-color: #34C759;"), # 差异分析参数 h5("🔬 差异分析参数", style = "color: #34C759; font-weight: bold;"), fluidRow( column(4, sliderInput("chip_logfc_threshold", "log2FoldChange 阈值:", min = 0, max = 5, value = 1, step = 0.1) ), column(4, selectInput("chip_pval_type", "显著性指标:", choices = c("校正P值 (adj.P.Val)" = "adj.P.Val", "原始P值 (P.Value)" = "P.Value"), selected = "adj.P.Val") ), column(4, sliderInput("chip_pvalue_threshold", "P值 阈值:", min = 0.001, max = 0.1, value = 0.05, step = 0.001) ) ), fluidRow( column(12, checkboxInput("chip_paired_analysis", "配对样本分析（如果适用）", value = FALSE) ) ), tags$hr(style = "border-color: #34C759;"), actionButton("run_chip_analysis", "🚀 运行差异分析", class = "btn-primary btn-lg", style = "width: 100%; margin-top: 15px;") ) ) ) ), # ===== 面板5: 分析结果 ===== tags$div( class = "panel panel-default", tags$div( class = "panel-heading", style = "cursor: pointer; background: linear-gradient(135deg, #007AFF 0%, #0051D5 100%); color: white; padding: 15px;", `data-toggle` = "collapse", `data-target` = "#panel_results", tags$h4( class = "panel-title", style = "margin: 0;", tags$span(icon("table"), " 📊 步骤5: 分析结果") ) ), tags$div( id = "panel_results", class = "panel-collapse collapse", # 默认折叠 style = "padding: 15px;", wellPanel( # 结果统计和表格（chip_results_ui 已包含表格） uiOutput("chip_results_ui"), tags$hr(style = "border-color: #007AFF;"), # 下载按钮 fluidRow( column(12, downloadButton("download_chip_results", "📥 下载结果", class = "btn-success") ) ) ) ) ) ) ) } #' 芯片数据分析模块 Server 函数 #' #' @param input Shiny input #' @param output Shiny output #' @param session Shiny session #' @param deg_results 差异分析结果容器（用于更新） chip_analysis_server <- function(input, output, session, deg_results) { cat("✅ 芯片分析模块已启动\n") # 渲染 UI output$chip_analysis_ui_output <- renderUI({ chip_analysis_ui() }) # 存储芯片数据 chip_data <- reactiveValues( series_matrix = NULL, soft_platform = NULL, probe_mapping = NULL, expr_matrix = NULL, metadata = NULL, group_info = NULL, manual_ctrl_samples = NULL, manual_trt_samples = NULL ) # 解析对照组样本 observeEvent(input$chip_parse_ctrl, { req(input$chip_paste_ctrl) req(chip_data$series_matrix) pasted_text <- input$chip_paste_ctrl # 显示进度 showNotification("正在解析对照组样本...", type = "message") # 解析样本列表 samples <- parse_sample_list(pasted_text, chip_data$series_matrix) if (is.null(samples) || length(samples) == 0) { showNotification("解析失败：未找到有效样本", type = "error") return(NULL) } # 保存对照组 chip_data$manual_ctrl_samples <- samples showNotification( sprintf("✅ 成功解析对照组: %d 个样本", length(samples)), type = "message" ) }) # 解析处理组样本 observeEvent(input$chip_parse_trt, { req(input$chip_paste_trt) req(chip_data$series_matrix) pasted_text <- input$chip_paste_trt # 显示进度 showNotification("正在解析处理组样本...", type = "message") # 解析样本列表 samples <- parse_sample_list(pasted_text, chip_data$series_matrix) if (is.null(samples) || length(samples) == 0) { showNotification("解析失败：未找到有效样本", type = "error") return(NULL) } # 保存处理组 chip_data$manual_trt_samples <- samples showNotification( sprintf("✅ 成功解析处理组: %d 个样本", length(samples)), type = "message" ) }) # 清除分组设置 observeEvent(input$chip_clear_groups, { chip_data$manual_ctrl_samples <- NULL chip_data$manual_trt_samples <- NULL showNotification("已清除分组设置", type = "message") }) # 解析 Series Matrix 文件 observeEvent(input$chip_series_matrix, { req(input$chip_series_matrix) file_path <- input$chip_series_matrix$datapath # 显示进度 showNotification("正在解析 GEO Series Matrix 文件...", type = "message") # 解析文件 result <- parse_geo_series_matrix(file_path) if (!result$success) { showNotification(result$error, type = "error") return(NULL) } # 保存数据 chip_data$series_matrix <- result$matrix chip_data$metadata <- result$metadata chip_data$expr_matrix <- result$matrix showNotification( sprintf("✅ 成功解析: %d 探针 × %d 样本", result$n_probes, result$n_samples), type = "message" ) # 尝试自动检测分组 if (!is.null(result$metadata)) { group_info <- detect_chip_groups_auto( sample_names = result$sample_names, sample_descriptions = result$metadata$sample_descriptions, sample_titles = result$metadata$sample_titles ) chip_data$group_info <- group_info } }, ignoreNULL = TRUE) # Series Matrix 文件预览 output$chip_series_matrix_preview <- renderDT({ req(chip_data$series_matrix) # 提取前5行 preview_matrix <- head(chip_data$series_matrix, 5) # 转换为数据框（保留行名） preview_df <- as.data.frame(preview_matrix) datatable( preview_df, options = list( dom = 't', paging = FALSE, scrollX = TRUE, columnDefs = list(list( className = 'dt-center', targets = "_all" )) ), rownames = TRUE, # 显示行名（探针ID） filter = 'none' ) %>% formatStyle(columns = 1:min(5, ncol(preview_df)), fontSize = '85%') }) # SOFT 文件预览UI output$chip_soft_preview_ui <- renderUI({ # 只要有文件上传记录就显示预览 if (!is.null(input$chip_soft_platform)) { cat(sprintf("🔍 渲染SOFT预览UI (文件已上传)\n")) if (!is.null(chip_data$soft_platform)) { cat(sprintf(" 数据可用: %d rows x %d cols\n", nrow(chip_data$soft_platform), ncol(chip_data$soft_platform))) } else { cat(" ⚠️ 数据尚未加载到chip_data\n") } tagList( h5("📄 SOFT 平台注释文件（前10行）", style = "color: #FF9800;"), helpText("这是SOFT注释文件的真实数据。可以看到ID列和多个可能的基因列。"), DTOutput("chip_soft_raw_preview") ) } else { cat("⚠️ SOFT文件未上传\n") div( class = "alert alert-info", h5("📄 请先上传SOFT平台注释文件"), p("上传后将在此处显示文件预览。") ) } }) # 🆕 SOFT文件列名列表展示 output$chip_soft_columns_list_ui <- renderUI({ req(chip_data$soft_platform) soft_cols <- colnames(chip_data$soft_platform) tagList( h6("📌 所有列名（共", span(style = "color: #FF9500;", length(soft_cols)), "列）:", style = "color: #333;"), # 以表格形式展示所有列名 div( style = "background: #fff3e0; padding: 15px; border-radius: 8px; border-left: 4px solid #FF9800;", # 每行显示3列 div(style = "display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px;", lapply(seq_along(soft_cols), function(i) { col_name <- soft_cols[i] div( style = "background: white; padding: 8px; border-radius: 4px; border: 1px solid #FFB74D;", tags$span(style = "color: #E65100; font-weight: bold; font-family: monospace;", sprintf("%d. %s", i, col_name)) ) }) ) ), br(), # 重要提示 div( style = "background: #e3f2fd; padding: 12px; border-radius: 5px; border-left: 4px solid #2196F3;", h6("💡 如何选择基因列？", style = "color: #1976D2; margin-top: 0;"), tags$ul(style = "padding-left: 20px; margin: 5px 0;", tags$li("查看下方的列内容示例，了解每列包含什么数据"), tags$li("基因符号列通常包含：TP53, EGFR, BRCA1, MYC 等基因名称"), tags$li("ID列通常包含：数字或探针标识符（如 1553601_at）"), tags$li("点击下方的'查看列内容'按钮查看每列的前5行数据") ) ) ) }) # 🆕 显示各列内容示例 output$chip_soft_column_examples_ui <- renderUI({ req(chip_data$soft_platform) soft_cols <- colnames(chip_data$soft_platform) # 为每一列生成示例展示 tagList( h6("📊 各列内容示例（前3行）", style = "color: #333;"), div(style = "max-height: 400px; overflow-y: auto;"), lapply(soft_cols, function(col_name) { # 获取该列的前3个非空值 col_data <- chip_data$soft_platform[[col_name]] col_data <- col_data[!is.na(col_data) & col_data != ""] examples <- head(col_data, 3) wellPanel( style = "padding: 10px; margin-bottom: 10px;", h7(style = "color: #FF9800; font-weight: bold; margin-bottom: 5px;", sprintf("🔹 %s", col_name)), div( style = "background: #f5f5f5; padding: 8px; border-radius: 4px; font-family: monospace; font-size: 11px;", for (i in seq_along(examples)) { tags$div( sprintf(" %d. %s", i, as.character(examples[i])), style = i < length(examples) ? "margin-bottom: 5px;" : "" ) } ) ) }) ) }) # 解析 SOFT 平台文件 observeEvent(input$chip_soft_platform, { req(input$chip_soft_platform) file_path <- input$chip_soft_platform$datapath showNotification("正在解析 SOFT 平台注释文件...", type = "message") result <- parse_platform_annotation(file_path, "\t") # 使用Tab作为分隔符 if (!result$success) { showNotification(result$error, type = "error") return(NULL) } chip_data$soft_platform <- result$raw_table chip_data$probe_mapping <- NULL # 不使用自动映射 chip_data$gene_symbol_col <- NULL # 不使用自动检测的列名 cat(sprintf("💾 SOFT数据已保存: %d rows x %d cols\n", nrow(chip_data$soft_platform), ncol(chip_data$soft_platform))) cat("⚠️ 请用户手动选择ID列和基因列\n") showNotification( "✅ SOFT文件已加载，请在下方手动选择ID列和基因列", type = "message" ) }, ignoreNULL = TRUE) # 重新解析SOFT文件（修改分隔符后） observeEvent(input$chip_reparse_soft, { req(input$chip_soft_platform) file_path <- input$chip_soft_platform$datapath # 获取分隔符，默认为Tab separator <- if (is.null(input$chip_soft_separator) || input$chip_soft_separator == "") { "\t" } else { input$chip_soft_separator } showNotification("正在重新解析 SOFT 平台注释文件...", type = "message") result <- parse_platform_annotation(file_path, separator) if (!result$success) { showNotification(result$error, type = "error") return(NULL) } chip_data$soft_platform <- result$raw_table chip_data$probe_mapping <- NULL # 不使用自动映射 chip_data$gene_symbol_col <- NULL # 不使用自动检测的列名 showNotification( "✅ 重新解析完成，请手动选择ID列和基因列", type = "message" ) }) # 数据概览 output$chip_data_summary <- renderDT({ req(chip_data$series_matrix) matrix <- chip_data$series_matrix # 创建摘要表 summary_df <- data.frame( 项目 = c("探针数", "样本数", "样本名称"), 值 = c( nrow(matrix), ncol(matrix), paste(colnames(matrix), collapse = ", ") ) ) # 添加分组信息 if (!is.null(chip_data$group_info) && !is.null(chip_data$group_info$pattern_name)) { summary_df <- rbind(summary_df, data.frame( 项目 = c("检测到分组模式", "对照组样本", "处理组样本"), 值 = c( chip_data$group_info$pattern_name, paste(chip_data$group_info$ctrl_samples, collapse = ", "), paste(chip_data$group_info$trt_samples, collapse = ", ") ) )) } datatable(summary_df, options = list(dom = 't', paging = FALSE), rownames = FALSE) }) # 注释状态显示 output$chip_annotation_status <- renderUI({ req(chip_data$series_matrix) # 检查是否加载了SOFT文件 soft_loaded <- !is.null(chip_data$soft_platform) if (soft_loaded) { # 已加载SOFT文件但尚未配置映射 div( class = "alert alert-info", h5("✅ SOFT文件已加载，等待配置", style = "color: #17a2b8;"), p(sprintf("总探针数: %d", nrow(chip_data$series_matrix))), p(sprintf("SOFT平台数据: %d 行 x %d 列", nrow(chip_data$soft_platform), ncol(chip_data$soft_platform))), p("💡 请在下方选择ID列和基因列以建立探针映射。", style = "color: #007bff; font-weight: bold;"), if (!is.null(chip_data$probe_mapping)) { p(sprintf("成功映射: %d (%.1f%%)", nrow(chip_data$probe_mapping), nrow(chip_data$probe_mapping) / nrow(chip_data$series_matrix) * 100)) } ) } else { # 未加载SOFT文件 div( class = "alert alert-warning", h5("⚠️ 未加载探针注释文件", style = "color: #ffc107;"), p("将直接使用探针ID作为基因符号进行分析。"), p("强烈建议上传 SOFT 平台注释文件以获得准确的结果。") ) } }) # 🆕 SOFT文件列选择面板（使用renderUI而不是conditionalPanel） output$chip_soft_column_selection_panel <- renderUI({ # 检查SOFT文件是否加载 if (is.null(chip_data$soft_platform)) { return(NULL) } # 只打印一次日志，避免刷屏 if (is.null(chip_data$panel_initialized)) { cat(sprintf("✅ 初始化SOFT列选择面板: %d 行 x %d 列\n", nrow(chip_data$soft_platform), ncol(chip_data$soft_platform))) chip_data$panel_initialized <- TRUE } # 使用isolate防止input变化触发重新渲染 soft_cols <- isolate(colnames(chip_data$soft_platform)) # 获取当前选择值（使用isolate避免建立依赖） current_id <- isolate({ if (!is.null(input$chip_soft_id_col) && input$chip_soft_id_col != "") { input$chip_soft_id_col } else { "" } }) current_gene <- isolate({ if (!is.null(input$chip_soft_gene_col) && input$chip_soft_gene_col != "") { input$chip_soft_gene_col } else { "" } }) wellPanel( style = "background: linear-gradient(135deg, #fff7e6 0%, #ffe6b3 100%); border: 2px solid #FF9800;", h4("📋 SOFT文件列选择", style = "color: #FF9800; margin-top: 0;"), helpText("💡 您可以预先浏览和选择SOFT文件的列，即使还未上传Series Matrix文件。"), br(), fluidRow( column(4, h5("选择ID列", style = "color: #9C27B0; font-weight: bold;"), selectInput("chip_soft_id_col", "选择ID列（必须与Series Matrix的探针ID匹配）", choices = c("", soft_cols), selected = current_id), helpText("选择SOFT文件中包含探针ID的列（通常为'ID'列）") ), column(4, h5("选择基因列", style = "color: #9C27B0; font-weight: bold;"), selectInput("chip_soft_gene_col", "选择基因列（包含基因符号的列）", choices = c("", soft_cols), selected = current_gene), helpText("选择包含基因符号的列（如GENE_SYMBOL, SYMBOL）") ), column(4, h5("选择EntrezID列（可选）", style = "color: #FF5722; font-weight: bold;"), selectInput("chip_soft_entrez_col", "选择Entrez Gene ID列", choices = c("", "自动检测", soft_cols), selected = ""), helpText("选择包含Entrez Gene ID的列（如GENE, ENTREZID）", style = "font-size: 11px; color: #FF5722;") ) ), # 状态提示单独的uiOutput，避免循环 uiOutput("chip_selection_status") ) }) # 🆕 状态提示单独渲染（避免导致父级重新渲染） output$chip_selection_status <- renderUI({ # 使用isolate避免触发父级renderUI id_col <- isolate(input$chip_soft_id_col) gene_col <- isolate(input$chip_soft_gene_col) entrez_col <- isolate(input$chip_soft_entrez_col) # 🔍 自动检测可能的EntrezID列 possible_entrez_hint <- "" if (!is.null(chip_data$soft_platform)) { soft_cols <- colnames(chip_data$soft_platform) # 检查是否有常见的EntrezID列名 entrez_candidates <- c("ENTREZ_GENE_ID", "ENTREZID", "EntrezID", "GeneID", "GENE_ID", "ENTREZ_GENE", "GENE") found_cols <- intersect(entrez_candidates, soft_cols) if (length(found_cols) > 0) { possible_entrez_hint <- p(sprintf("💡 检测到可能的EntrezID列: %s", paste(found_cols, collapse = ", ")), collapse = " ") } } if (is.null(id_col) || id_col == "" || is.null(gene_col) || gene_col == "") { div( style = "background: #fff3cd; padding: 10px; border-radius: 5px; margin-top: 15px;", h6("⚠️ 未完成选择", style = "color: #856404;"), p("请选择ID列和基因列，然后上传Series Matrix文件并点击应用按钮。", style = "font-size: 12px;"), if (possible_entrez_hint != "") { p(possible_entrez_hint, style = "font-size: 11px; color: #FF5722; font-weight: bold;") } ) } else { status_color <- "d4edda" status_text <- "✅ 已选择列" status_text_color <- "155724" # 检查是否选择了EntrezID列 if (is.null(entrez_col) || entrez_col == "") { if (possible_entrez_hint != "") { status_color <- "fff3cd" status_text <- "⚠️ 建议选择EntrezID列" status_text_color <- "856404" } } div( style = sprintf("background: %s; padding: 10px; border-radius: 5px; margin-top: 15px;", status_color), h6(status_text, style = sprintf("color: %s;", status_text_color)), p(sprintf("ID列: %s | 基因列: %s", id_col, gene_col), style = "font-size: 12px; font-weight: bold;"), if (!is.null(entrez_col) && entrez_col != "" && entrez_col != "自动检测") { p(sprintf("EntrezID列: %s", entrez_col), style = "font-size: 12px; color: #FF5722; font-weight: bold;") }, p("💡 请上传Series Matrix文件，然后点击'✅ 应用配置并生成最终矩阵'按钮。", style = "font-size: 12px;"), if (possible_entrez_hint != "" && (is.null(entrez_col) || entrez_col == "")) { p(possible_entrez_hint, style = "font-size: 11px; color: #FF5722; font-weight: bold; margin-top: 5px;" ) } ) } }) # 🆕 监听列选择（只在日志中记录，不触发UI更新） observe({ # 只有两个列都选择了才处理 req(input$chip_soft_id_col) req(input$chip_soft_gene_col) req(input$chip_soft_id_col != "") req(input$chip_soft_gene_col != "") # 保存选择到chip_data chip_data$selected_id_col <- input$chip_soft_id_col chip_data$selected_gene_col <- input$chip_soft_gene_col # 使用isolate避免触发UI重新渲染 isolate({ cat(sprintf("📋 用户已选择: ID列=%s, 基因列=%s\n", input$chip_soft_id_col, input$chip_soft_gene_col)) }) }) # 🆕 合并工作流面板renderUI（替代conditionalPanel） output$chip_merge_workflow_panel <- renderUI({ # 检查两个文件是否都已上传 has_series <- !is.null(chip_data$series_matrix) has_soft <- !is.null(chip_data$soft_platform) if (!has_series || !has_soft) { return(NULL) } # 检查是否已选择列 has_id_col <- !is.null(input$chip_soft_id_col) && input$chip_soft_id_col != "" has_gene_col <- !is.null(input$chip_soft_gene_col) && input$chip_soft_gene_col != "" wellPanel( style = "background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%); border: 2px solid #667eea;", h4("🔗 探针注释与数据合并工作流", style = "color: #667eea; margin-top: 0;"), # 工作流说明 div( style = "background: rgba(255,255,255,0.8); padding: 15px; border-radius: 8px; margin-bottom: 20px;", h5("📋 重要提示", style = "color: #dc3545;"), helpText("您已在上方黄色面板选择了列，现在可以应用配置生成最终矩阵！"), if (has_id_col && has_gene_col) { tags$div(style = "background: #d4edda; padding: 10px; border-radius: 5px; border-left: 4px solid #28a745;", tags$strong("✅ 当前配置："), tags$ul(style = "margin: 10px 0;", tags$li(sprintf("ID列: %s", input$chip_soft_id_col)), tags$li(sprintf("基因列: %s", input$chip_soft_gene_col)) ) ) } else { tags$div(style = "background: #fff3cd; padding: 10px; border-radius: 5px; border-left: 4px solid #ffc107;", tags$strong("⚠️ 请先在上方黄色面板选择列！") ) } ), # 应用按钮 if (has_id_col && has_gene_col) { tagList( hr(style = "border-color: #667eea;"), h5("步骤5: 应用配置并生成最终矩阵", style = "color: #9C27B0; font-weight: bold;"), fluidRow( column(12, actionButton("chip_apply_merge", "✅ 应用配置并生成最终矩阵", class = "btn-success btn-lg btn-block", style = "font-size: 16px; padding: 15px;"), helpText("点击后将应用所有配置，生成带基因符号的表达矩阵。", style = "text-align: center;") ) ) ) } ) }) # SOFT文件列选择UI output$chip_soft_columns_ui <- renderUI({ req(chip_data$soft_platform) soft_cols <- colnames(chip_data$soft_platform) tagList( h5("🔍 SOFT文件列信息", style = "color: #9C27B0;"), p(sprintf("检测到 %d 列，请确认基因符号列：", ncol(chip_data$soft_platform))), fluidRow( column(8, selectInput("chip_gene_symbol_col", "选择基因符号列:", choices = soft_cols, selected = chip_data$gene_symbol_col) ), column(4, br(), actionButton("chip_update_gene_col", "🔄 更新列选择", class = "btn-primary", style = "width: 100%;") ) ), helpText("💡 提示：系统已自动检测，如不正确可手动选择。", class = "text-info") ) }) # 更新基因符号列 observeEvent(input$chip_update_gene_col, { req(chip_data$soft_platform) req(input$chip_gene_symbol_col) selected_col <- input$chip_gene_symbol_col # 重新提取映射 probe_col <- chip_data$soft_platform[, 1] # 假设第一列是探针ID gene_col <- chip_data$soft_platform[, selected_col] # 移除NA和空 valid_mask <- !is.na(gene_col) & gene_col != "" probe_col <- probe_col[valid_mask] gene_col <- gene_col[valid_mask] # 创建映射 mapping <- data.frame( probe_id = as.character(probe_col), gene_symbol = as.character(gene_col), stringsAsFactors = FALSE ) chip_data$probe_mapping <- mapping chip_data$gene_symbol_col <- selected_col showNotification( sprintf("✅ 已更新基因列为: %s (%d 个映射)", selected_col, nrow(mapping)), type = "message" ) }) # SOFT文件原始数据预览 output$chip_soft_raw_preview <- renderDT({ req(chip_data$soft_platform) # 显示前10行，但限制显示的列数 preview_df <- head(chip_data$soft_platform, 10) # 🔧 截断过长的文本以避免渲染问题 truncate_text <- function(text, max_len = 100) { if (is.character(text) || is.factor(text)) { text <- as.character(text) text <- ifelse(nchar(text) > max_len, paste0(substr(text, 1, max_len), "..."), text) } return(text) } # 对所有列应用截断 for (col in colnames(preview_df)) { preview_df[[col]] <- truncate_text(preview_df[[col]], max_len = 100) } # 限制显示的列数（最多显示15列，避免表格过宽） if (ncol(preview_df) > 15) { preview_df <- preview_df[, 1:15] cat(sprintf("⚠️ SOFT文件有%d列，仅显示前15列\n", ncol(chip_data$soft_platform))) } datatable( preview_df, options = list( dom = 't', paging = FALSE, scrollX = TRUE, scrollY = "400px", columnDefs = list(list( className = 'dt-center', targets = "_all" )) ), rownames = FALSE, filter = 'none', escape = FALSE # 允许HTML渲染（用于显示省略号） ) %>% formatStyle(columns = 1:ncol(preview_df), fontSize = '85%', maxWidth = '200px', overflow = 'hidden', textOverflow = 'ellipsis') }) # 探针-基因映射预览 output$chip_probe_mapping_preview <- renderDT({ req(chip_data$probe_mapping) # 显示前10行 preview_df <- head(chip_data$probe_mapping, 10) datatable( preview_df, options = list(dom = 't', paging = FALSE), rownames = FALSE, colnames = c("探针ID", "基因符号") ) %>% formatStyle(columns = c("探针ID", "基因符号"), fontSize = '90%') }) # ============================================ # 🆕 探针注释与合并工作流 - 服务端逻辑 # ============================================ # 步骤2: 渲染SOFT文件ID列选择器 output$chip_soft_id_column_ui <- renderUI({ req(chip_data$soft_platform) soft_cols <- colnames(chip_data$soft_platform) tagList( selectInput("chip_soft_id_col", "选择ID列（必须与Series Matrix的探针ID匹配）", choices = c("", soft_cols), # 添加空选项 selected = ""), helpText("💡 提示：根据上方SOFT文件预览，选择包含探针ID的列（通常为'ID'列）", style = "color: #ff9800;") ) }) # 步骤3: 渲染SOFT文件基因列选择器 output$chip_soft_gene_column_ui <- renderUI({ req(chip_data$soft_platform) soft_cols <- colnames(chip_data$soft_platform) tagList( selectInput("chip_soft_gene_col", "选择基因列（包含基因符号的列）", choices = c("", soft_cols), # ✅ 添加空选项 selected = ""), # ✅ 默认不选中，强制用户手动选择 helpText("⚠️ 请根据上方SOFT文件预览和右侧数据示例，手动选择包含基因符号的列（如 GENE_SYMBOL）。", style = "color: #ff9800; font-weight: bold;") ) }) # 步骤4: 显示选中基因列的实际示例数据 output$chip_gene_column_examples_ui <- renderUI({ req(chip_data$soft_platform) req(input$chip_soft_gene_col) gene_col <- input$chip_soft_gene_col examples <- head(chip_data$soft_platform[[gene_col]], 5) tagList( h6("📋 实际数据示例（前5行）:", style = "color: #667eea;"), div( style = "background: #f8f9fa; padding: 10px; border-radius: 5px; font-family: monospace; font-size: 11px;", for (i in seq_along(examples)) { tags$div( sprintf("%d. %s", i, as.character(examples[i])) ) } ) ) }) # 步骤4: 正则表达式测试 output$chip_regex_test_result_ui <- renderUI({ req(input$chip_test_regex) # 获取测试数据 example_text <- if (!is.null(input$chip_gene_extract_example) && input$chip_gene_extract_example != "") { input$chip_gene_extract_example } else { # 使用实际数据示例 req(input$chip_soft_gene_col) examples <- head(chip_data$soft_platform[[input$chip_soft_gene_col]], 3) paste(examples, collapse = "\n") } regex_pattern <- input$chip_gene_regex %||% "[A-Z][A-Z0-9]+" # 测试提取 tryCatch({ matches <- gregexpr(regex_pattern, example_text, perl = TRUE) extracted <- regmatches(example_text, matches) # 提取所有匹配项 all_matches <- unique(unlist(extracted)) all_matches <- all_matches[all_matches != ""] if (length(all_matches) == 0) { div( class = "alert alert-warning", h6("⚠️ 未找到匹配"), p("当前正则表达式无法从示例文本中提取基因符号。"), p(sprintf("正则表达式: %s", regex_pattern)) ) } else { tagList( div( class = "alert alert-success", h6("✅ 提取成功", style = "color: #28a745;"), p(sprintf("找到 %d 个匹配:", length(all_matches))), div( style = "background: #f8f9fa; padding: 10px; border-radius: 5px; margin-top: 10px;", tags$ul(style = "margin: 0; padding-left: 20px;", tagList(lapply(all_matches, function(m) { tags$li(style = "margin: 5px 0; font-family: monospace; color: #667eea;", sprintf("%s", m)) })) ) ) ), div( style = "margin-top: 10px;", h6("📊 提取统计:", style = "color: #667eea;"), tags$table( class = "table table-striped", tags$tbody( tags$tr( tags$td("原始文本长度"), tags$td(nchar(example_text)) ), tags$tr( tags$td("提取数量"), tags$td(length(all_matches)) ), tags$tr( tags$td("平均长度"), tags$td(round(mean(nchar(all_matches)), 1)) ) ) ) ) ) } }, error = function(e) { div( class = "alert alert-danger", h6("❌ 正则表达式错误"), p(e$message) ) }) }) # 正则预设按钮逻辑 observeEvent(input$chip_regex_preset1, { updateTextInput(session, "chip_gene_regex", value = "[A-Z]+") }) observeEvent(input$chip_regex_preset2, { updateTextInput(session, "chip_gene_regex", value = "[A-Z][A-Z0-9]+") }) observeEvent(input$chip_regex_preset3, { updateTextInput(session, "chip_gene_regex", value("\\(([^)]+)\\)")) }) # 步骤5: 预览合并结果 observeEvent(input$chip_preview_merge, { req(chip_data$series_matrix) req(chip_data$soft_platform) req(input$chip_soft_id_col) req(input$chip_soft_gene_col) # 转换Series Matrix行名为列 series_df <- as.data.frame(chip_data$series_matrix) if (input$chip_convert_rownames %||% TRUE) { series_df <- data.frame(ProbeID = rownames(series_df), series_df, row.names = NULL) } # 准备SOFT数据 soft_df <- chip_data$soft_platform[, c(input$chip_soft_id_col, input$chip_soft_gene_col)] colnames(soft_df) <- c("ID", "GeneSymbol") # 合并数据 - 简化版预览 merged_df <- merge(series_df, soft_df, by.x = "ProbeID", by.y = "ID", all.x = TRUE) # 重新排序列：ProbeID | GeneSymbol | 样本列 sample_cols <- colnames(merged_df)[!colnames(merged_df) %in% c("ProbeID", "GeneSymbol", "ID")] merged_df <- merged_df[, c("ProbeID", "GeneSymbol", sample_cols)] # 保存预览结果 chip_data$merged_preview <- head(merged_df, 5) showNotification("✅ 合并预览已生成", type = "message") }) # 显示合并预览表格 output$chip_merge_preview_table <- renderDT({ req(chip_data$merged_preview) datatable( chip_data$merged_preview, options = list( dom = 't', paging = FALSE, scrollX = TRUE ), rownames = FALSE, filter = 'none' ) %>% formatStyle(columns = c("ProbeID", "Gene"), fontSize = '90%') }) # 步骤5: 应用合并配置 observeEvent(input$chip_apply_merge, { req(chip_data$series_matrix) req(chip_data$soft_platform) req(input$chip_soft_id_col) req(input$chip_soft_gene_col) showNotification("🔄 正在应用配置并生成最终矩阵...", type = "message") # 转换Series Matrix行名为列 series_df <- as.data.frame(chip_data$series_matrix) if (input$chip_convert_rownames %||% TRUE) { series_df <- data.frame(ProbeID = rownames(series_df), series_df, row.names = NULL) } cat(sprintf("🔍 Series探针ID示例: %s\n", paste(head(series_df$ProbeID, 3), collapse = ", "))) # 🔍 智能检测SOFT文件中的探针ID列 user_id_col <- input$chip_soft_id_col user_id_sample <- head(chip_data$soft_platform[[user_id_col]][!is.na(chip_data$soft_platform[[user_id_col]])], 10) cat(sprintf("🔍 用户选择的ID列 '%s' 示例: %s\n", user_id_col, paste(head(user_id_sample, 3), collapse = ", "))) # 检查用户选择的ID列是否真的包含探针ID # 支持多种探针ID格式： # 1. Affymetrix: 12345_at, 1234567_x_at, 1234567_at # 2. Agilent: A_23_P100001, CN_123456 # 3. Illumina: ILMN_123456 is_probe_format <- any(grepl(".*_.*_at$|.*_at$|at$", user_id_sample)) || # Affymetrix any(grepl("^[A-Z]+_\\d+_", user_id_sample)) || # Agilent/Illumina前缀 any(grepl("^CN_", user_id_sample)) # 其他常见格式 # 准备SOFT数据 if (is_probe_format) { cat("✅ 用户选择的ID列包含探针格式\n") soft_df <- chip_data$soft_platform[, c(user_id_col, input$chip_soft_gene_col)] colnames(soft_df) <- c("ID", "Gene_Raw") } else { cat("⚠️ 用户选择的ID列不包含探针格式，尝试使用SOFT行名\n") # 尝试使用SOFT文件的行名作为探针ID if (!is.null(rownames(chip_data$soft_platform))) { # 检查行名是否匹配探针ID rowname_sample <- head(rownames(chip_data$soft_platform), 10) cat(sprintf("🔍 SOFT行名示例: %s\n", paste(rowname_sample, collapse = ", "))) # 创建临时数据框使用行名 soft_df <- data.frame( ID = rownames(chip_data$soft_platform), Gene_Raw = chip_data$soft_platform[[input$chip_soft_gene_col]], stringsAsFactors = FALSE ) } else { cat("❌ SOFT文件没有行名，无法自动检测\n") showNotification("⚠️ 请选择包含探针ID的列（如ID、SPOT_ID等）", type = "warning", duration = 10) return() } } # 🆕 智能判断是否需要正则提取 # 检查基因列的内容，如果已经是纯符号格式，不需要提取 gene_sample <- head(soft_df$Gene_Raw[!is.na(soft_df$Gene_Raw) & soft_df$Gene_Raw != ""], 10) cat(sprintf("🔍 用户选择的基因列 '%s' 示例: %s\n", input$chip_soft_gene_col, paste(head(gene_sample, 3), collapse = ", "))) # 判断是否是纯数字ID is_numeric_id <- all(grepl("^[0-9]+$", gene_sample)) if (is_numeric_id) { cat("⚠️ 用户选择的基因列包含数字ID而非基因符号！\n") cat("💡 建议：请选择包含基因符号的列（如GENE_SYMBOL）\n") # 尝试自动查找真正的基因符号列 soft_cols <- colnames(chip_data$soft_platform) cat(sprintf("🔍 SOFT文件所有列名: %s\n", paste(soft_cols, collapse = ", "))) possible_symbol_cols <- c("GENE_SYMBOL", "SYMBOL", "GENE_NAME", "NAME", "DESCRIPTION") for (col in possible_symbol_cols) { if (col %in% soft_cols && col != input$chip_soft_gene_col) { test_data <- head(chip_data$soft_platform[[col]][!is.na(chip_data$soft_platform[[col]])], 10) cat(sprintf("🔍 检查列 '%s': 示例=%s\n", col, paste(head(test_data, 3), collapse = ", "))) if (!all(grepl("^[0-9]+$", test_data))) { cat(sprintf("✅ 自动检测到基因符号列: %s\n", col)) cat(sprintf(" 示例: %s\n", paste(head(test_data, 3), collapse = ", "))) # 🔧 修复：创建新的soft_df，直接包含正确的列 soft_df <- chip_data$soft_platform[, c(user_id_col, col)] colnames(soft_df) <- c("ID", "Gene_Raw") cat("✅ 已重新创建soft_df，使用正确的基因符号列\n") cat(sprintf("✅ 验证：soft_df的Gene_Raw列示例: %s\n", paste(head(soft_df$Gene_Raw[!is.na(soft_df$Gene_Raw)], 3), collapse = ", "))) break } } } } # 重新检查Gene_Raw gene_sample <- head(soft_df$Gene_Raw[!is.na(soft_df$Gene_Raw) & soft_df$Gene_Raw != ""], 10) # 判断是否已经是纯基因符号（不包含额外文本） # 典型基因符号：TP53, EGFR, BRCA1, MYC (大写字母+数字，无空格，无逗号) is_pure_symbol <- all(grepl("^[A-Z][A-Z0-9]{1,15}$", gene_sample)) if (is_pure_symbol) { cat("✅ 基因列已是纯符号格式，直接使用，无需正则提取\n") cat(sprintf(" 示例: %s\n", paste(head(gene_sample, 3), collapse = ", "))) # 直接使用原列作为基因符号 soft_df$GeneSymbol <- soft_df$Gene_Raw cat(sprintf("✅ GeneSymbol列已创建，示例: %s\n", paste(head(soft_df$GeneSymbol[!is.na(soft_df$GeneSymbol)], 3), collapse = ", "))) } else { cat("📋 基因列包含额外文本，应用正则提取\n") cat(sprintf(" 原始示例: %s\n", paste(head(gene_sample, 2), collapse = ", "))) # 应用正则提取 regex_pattern <- input$chip_gene_regex %||% "[A-Z][A-Z0-9]+" soft_df$GeneSymbol <- sapply(soft_df$Gene_Raw, function(x) { matches <- regmatches(x, gregexpr(regex_pattern, as.character(x), perl = TRUE)) if (length(matches[[1]]) > 0) { matches[[1]][1] # 取第一个匹配 } else { NA } }) extracted_sample <- head(soft_df$GeneSymbol[!is.na(soft_df$GeneSymbol)], 5) cat(sprintf(" 提取示例: %s\n", paste(extracted_sample, collapse = ", "))) } # 🔧 尝试获取Entrez Gene ID（支持用户指定或自动检测） # 🔧 通用函数：清理EntrezID（移除非数字字符） clean_entrez_id <- function(entrez_str) { if (is.na(entrez_str) || is.null(entrez_str) || entrez_str == "") { return(NA) } # 转换为字符 entrez_str <- as.character(entrez_str) # 移除所有非数字字符（保留数字0-9） cleaned <- gsub("[^0-9]", "", entrez_str) # 如果清理后为空，返回NA if (cleaned == "" || is.na(cleaned)) { return(NA) } return(cleaned) } # 方法1: 用户手动指定EntrezID列 if (!is.null(input$chip_soft_entrez_col) && input$chip_soft_entrez_col != "" && input$chip_soft_entrez_col != "自动检测") { user_entrez_col <- input$chip_soft_entrez_col if (user_entrez_col %in% colnames(chip_data$soft_platform)) { raw_entrez_ids <- as.character(chip_data$soft_platform[[user_entrez_col]][match(soft_df$ID, chip_data$soft_platform[[input$chip_soft_id_col]])]) # 🔧 清理EntrezID（移除非数字字符） entrez_gene_ids <- sapply(raw_entrez_ids, clean_entrez_id) soft_df$EntrezID <- entrez_gene_ids # 统计清理情况 na_count <- sum(is.na(entrez_gene_ids)) valid_count <- sum(!is.na(entrez_gene_ids)) entrez_sample <- head(entrez_gene_ids[!is.na(entrez_gene_ids)], 3) cat(sprintf("✅ 用户指定的EntrezID列 '%s' 已添加\n", user_entrez_col)) cat(sprintf(" 有效ID数: %d, NA数: %d\n", valid_count, na_count)) cat(sprintf(" 示例: %s\n", paste(entrez_sample, collapse = ", "))) if (na_count > 0) { cat(sprintf(" ⚠️ %d个ID被清理为NA（包含非数字字符）\n", na_count)) } } } # 方法2: 自动检测EntrezID列（如果用户选择"自动检测"） else if (!is.null(input$chip_soft_entrez_col) && input$chip_soft_entrez_col == "自动检测") { # 常见的EntrezID列名（按优先级排序） possible_entrez_cols <- c("ENTREZ_GENE_ID", "ENTREZID", "EntrezID", "GeneID", "GENE_ID", "ENTREZ_GENE", "GENE", "Entrez Gene ID", "Entrez", "ENTREZ") found_entrez_col <- NULL for (col in possible_entrez_cols) { if (col %in% colnames(chip_data$soft_platform)) { # 检查该列是否包含数字ID（清理后） test_values <- head(chip_data$soft_platform[[col]], 100) test_values <- test_values[!is.na(test_values) & test_values != ""] # 🔧 清理测试值（移除非数字字符） cleaned_test <- sapply(test_values, clean_entrez_id) cleaned_test <- cleaned_test[!is.na(cleaned_test)] # 检查是否大部分可以清理为纯数字（EntrezID特征） if (length(cleaned_test) > 0) { is_numeric_id <- sum(grepl("^[0-9]+$", cleaned_test)) / length(cleaned_test) > 0.8 if (is_numeric_id) { found_entrez_col <- col cat(sprintf("✅ 自动检测到EntrezID列: '%s'\n", col)) break } } } } if (!is.null(found_entrez_col)) { raw_entrez_ids <- as.character(chip_data$soft_platform[[found_entrez_col]][match(soft_df$ID, chip_data$soft_platform[[input$chip_soft_id_col]])]) # 🔧 清理EntrezID（移除非数字字符） entrez_gene_ids <- sapply(raw_entrez_ids, clean_entrez_id) soft_df$EntrezID <- entrez_gene_ids # 统计清理情况 na_count <- sum(is.na(entrez_gene_ids)) valid_count <- sum(!is.na(entrez_gene_ids)) entrez_sample <- head(entrez_gene_ids[!is.na(entrez_gene_ids)], 3) cat(sprintf("✅ 自动检测的EntrezID列已添加\n", found_entrez_col)) cat(sprintf(" 有效ID数: %d, NA数: %d\n", valid_count, na_count)) cat(sprintf(" 示例: %s\n", paste(entrez_sample, collapse = ", "))) if (na_count > 0) { cat(sprintf(" ⚠️ %d个ID被清理为NA（包含非数字字符）\n", na_count)) } } else { cat("⚠️ 自动检测未找到EntrezID列\n") } } # 方法3: 旧逻辑（仅检查GENE列）- 也添加清理 else if ("GENE" %in% colnames(chip_data$soft_platform)) { raw_entrez_ids <- as.character(chip_data$soft_platform$GENE[match(soft_df$ID, chip_data$soft_platform[[input$chip_soft_id_col]])]) # 🔧 清理EntrezID entrez_gene_ids <- sapply(raw_entrez_ids, clean_entrez_id) soft_df$EntrezID <- entrez_gene_ids # 统计清理情况 na_count <- sum(is.na(entrez_gene_ids)) valid_count <- sum(!is.na(entrez_gene_ids)) entrez_sample <- head(entrez_gene_ids[!is.na(entrez_gene_ids)], 3) cat(sprintf("✅ Entrez Gene ID列（GENE）已添加\n")) cat(sprintf(" 有效ID数: %d, NA数: %d\n", valid_count, na_count)) cat(sprintf(" 示例: %s\n", paste(entrez_sample, collapse = ", "))) if (na_count > 0) { cat(sprintf(" ⚠️ %d个ID被清理为NA（包含非数字字符）\n", na_count)) } } # 🔧 不再创建Gene列！直接使用GeneSymbol用于去重，EntrezID用于差异分析 cat("✅ 使用GeneSymbol列进行探针去重\n") cat("✅ 使用EntrezID列作为差异分析结果的ID\n") # 合并数据 - 保留所有列 merged_df <- merge(series_df, soft_df, by.x = "ProbeID", by.y = "ID", all.x = TRUE) # 🔧 智能识别样本列（必须是数值型，排除ID列和基因列） # 规则：样本列 = 数值型列 + 不在排除列表中 exclude_cols <- c("ProbeID", "GeneSymbol", "EntrezID", "Gene_Raw", "ID") # 识别数值型列（样本列） sample_cols <- character(0) for (col in colnames(merged_df)) { if (!(col %in% exclude_cols)) { # 检查是否为数值型 if (is.numeric(merged_df[[col]])) { sample_cols <- c(sample_cols, col) } } } cat(sprintf("🔍 识别到 %d 个样本列: %s\n", length(sample_cols), paste(head(sample_cols, 5), collapse = ", "))) # 重新排序列：ProbeID | GeneSymbol | EntrezID | 样本列 if ("EntrezID" %in% colnames(merged_df)) { # 重新排列列顺序 merged_df <- merged_df[, c("ProbeID", "GeneSymbol", "EntrezID", sample_cols)] # 🔧 强制确保EntrezID是字符型 merged_df$EntrezID <- as.character(merged_df$EntrezID) cat("✅ EntrezID列已强制转换为字符型\n") } else { # 如果没有EntrezID，只保留GeneSymbol merged_df <- merged_df[, c("ProbeID", "GeneSymbol", sample_cols)] cat("⚠️ 未找到EntrezID列\n") } # 🔍 诊断：显示合并后的列结构 cat(sprintf("🔍 合并后矩阵结构: %d 行 × %d 列\n", nrow(merged_df), ncol(merged_df))) cat(sprintf("🔍 列名: %s\n", paste(colnames(merged_df), collapse = ", "))) cat(sprintf("🔍 前3列: %s\n", paste(head(colnames(merged_df), 3), collapse = ", "))) cat(sprintf("🔍 后3列: %s\n", paste(tail(colnames(merged_df), 3), collapse = ", "))) # 显示各列的类型 cat("🔍 列类型:\n") for (i in 1:min(5, ncol(merged_df))) { cat(sprintf(" %s: %s\n", colnames(merged_df)[i], class(merged_df[[i]]))) } # 确认EntrezID列的位置和类型 if ("EntrezID" %in% colnames(merged_df)) { entrez_col_idx <- which(colnames(merged_df) == "EntrezID") cat(sprintf("🔍 EntrezID列位置: 第%d列，类型: %s\n", entrez_col_idx, class(merged_df$EntrezID))) cat(sprintf("🔍 EntrezID示例: %s\n", paste(head(merged_df$EntrezID[!is.na(merged_df$EntrezID)], 3), collapse = ", "))) } # 保存最终合并的矩阵 chip_data$merged_matrix <- merged_df # 🆕 检查数据列内容 gene_symbol_sample <- head(merged_df$GeneSymbol[!is.na(merged_df$GeneSymbol)], 5) cat(sprintf("✅ GeneSymbol列包含基因符号（示例: %s）\n", paste(gene_symbol_sample, 3), collapse = ", ")) if ("EntrezID" %in% colnames(merged_df)) { entrez_sample <- head(merged_df$EntrezID[!is.na(merged_df$EntrezID)], 5) cat(sprintf("✅ EntrezID列包含Entrez Gene ID（示例: %s）\n", paste(entrez_sample, collapse = ", "))) } # 统计信息 n_total <- nrow(merged_df) n_annotated <- sum(!is.na(merged_df$GeneSymbol)) annotation_rate <- n_annotated / n_total * 100 # 🔍 诊断信息：检查GeneSymbol列匹配情况 na_count <- sum(is.na(merged_df$GeneSymbol) | merged_df$GeneSymbol == "") cat(sprintf("🔍 诊断: %d个探针的GeneSymbol为NA或空 (%.1f%%)\n", na_count, na_count/n_total*100)) # 检查ID匹配情况 series_probes <- series_df$ProbeID soft_ids <- soft_df$ID matched_probes <- sum(series_probes %in% soft_ids) cat(sprintf("🔍 ID匹配: %d / %d 个Series探针在SOFT文件中找到 (%.1f%%)\n", matched_probes, length(series_probes), matched_probes/length(series_probes)*100)) # 如果匹配率太低，显示警告 if (matched_probes / length(series_probes) < 0.5) { cat("⚠️ 警告：ID匹配率低于50%，请检查ID列选择是否正确！\n") cat(sprintf(" Series探针示例: %s\n", paste(head(series_probes, 3), collapse = ", "))) cat(sprintf(" SOFT ID示例: %s\n", paste(head(soft_ids, 3), collapse = ", "))) } cat(sprintf("✅ 合并完成: %d 个探针, %d 个已注释 (%.1f%%)\n", n_total, n_annotated, annotation_rate)) showNotification( sprintf("✅ 合并完成！%d / %d 个探针已注释 (%.1f%%)", n_annotated, n_total, annotation_rate), type = "message", duration = 10 ) }) # 显示最终合并矩阵的预览（在应用合并后） output$chip_final_matrix_ui <- renderUI({ req(chip_data$merged_matrix) tagList( h5("📊 最终表达矩阵（前5行）", style = "color: #28a745;"), DTOutput("chip_final_matrix_table") ) }) output$chip_final_matrix_table <- renderDT({ req(chip_data$merged_matrix) # 显示前5行和前10列（避免表格过宽） preview_df <- head(chip_data$merged_matrix, 5) if (ncol(preview_df) > 12) { preview_df <- preview_df[, 1:12] # ProbeID + Gene + 前10个样本 } # 检查是否有ProbeID和Gene列 has_probe_id <- "ProbeID" %in% colnames(preview_df) has_gene <- "Gene" %in% colnames(preview_df) # 创建datatable dt <- datatable( preview_df, options = list( dom = 't', paging = FALSE, scrollX = TRUE, columnDefs = list(list( className = 'dt-center', targets = "_all" )) ), rownames = FALSE, filter = 'none' ) # 只对存在的列应用样式 if (has_probe_id && has_gene) { dt <- dt %>% formatStyle(columns = c("ProbeID", "Gene"), backgroundColor = '#e8f4f8', fontWeight = 'bold') } dt }) # ============================================ # 🆕 数据预处理与探针去重 - Server逻辑 # ============================================ # 去重前统计显示 output$chip_before_dedupe_stats <- renderUI({ req(chip_data$merged_matrix) # 统计探针数量 n_probes <- nrow(chip_data$merged_matrix) # 识别数值列（样本数据） numeric_cols <- sapply(chip_data$merged_matrix, function(x) is.numeric(x)) n_samples <- sum(numeric_cols) # 统计探针-基因映射情况 n_with_gene <- sum(!is.na(chip_data$merged_matrix$GeneSymbol)) # 计算一个基因对应多个探针的情况 gene_counts <- table(chip_data$merged_matrix$GeneSymbol) gene_counts <- gene_counts[names(gene_counts) != ""] # 移除空基因名 n_multi_probes <- sum(gene_counts > 1) div( style = "font-size: 12px;", tags$ul(style = "padding-left: 15px; margin: 5px 0;", tags$li(sprintf("总探针数: %d", n_probes)), tags$li(sprintf("样本数: %d", n_samples)), tags$li(sprintf("有基因注释的探针: %d (%.1f%%)", n_with_gene, n_with_gene/n_probes*100)), tags$li(sprintf("一因多探针的基因数: %d", n_multi_probes)) ) ) }) # 步骤1: 数据预处理 observeEvent(input$chip_preprocess_data, { req(chip_data$merged_matrix) showNotification("🔄 正在进行数据预处理...", type = "message") tryCatch({ # 🔧 修复：智能提取表达数据（只保留数值列） merged_df <- chip_data$merged_matrix # 识别数值列 numeric_cols <- sapply(merged_df, function(x) is.numeric(x)) # 排除ProbeID和Gene列（它们在前两列） # 但要确保只使用数值列进行计算 expr_cols <- which(numeric_cols) # 提取表达数据 expr_matrix <- as.matrix(merged_df[, expr_cols, drop = FALSE]) # 🔧 修复：使用ProbeID作为行名，而不是Gene（这样才能在去重时正确匹配） if ("ProbeID" %in% colnames(merged_df)) { rownames(expr_matrix) <- merged_df$ProbeID cat("✅ 表达矩阵行名使用ProbeID\n") } else if ("Gene" %in% colnames(merged_df)) { rownames(expr_matrix) <- merged_df$Gene cat("⚠️ 警告：使用Gene作为行名（ProbeID列不存在）\n") } else { rownames(expr_matrix) <- rownames(merged_df) } cat(sprintf("✅ 提取表达数据: %d 探针 × %d 样本\n", nrow(expr_matrix), ncol(expr_matrix))) # 保存原始数据用于对比 chip_data$expr_before_preprocess <- expr_matrix # 1. 自动log2转换判断 if (input$chip_auto_log2 %||% TRUE) { ex <- expr_matrix qx <- as.numeric(quantile(ex, c(0., 0.25, 0.5, 0.75, 0.99, 1.0), na.rm = TRUE)) LogC <- (qx[5] > 100) || (qx[6] - qx[1] > 50 && qx[2] > 0) || (qx[2] > 0 && qx[2] < 1 && qx[4] > 1 && qx[4] < 2) if (LogC) { ex[which(ex <= 0)] <- NaN expr_matrix <- log2(ex) chip_data$log2_performed <- TRUE cat("✅ log2转换已完成\n") } else { chip_data$log2_performed <- FALSE cat("ℹ️ 不需要log2转换\n") } } # 2. limma标准化 if (input$chip_normalize_data %||% TRUE) { library(limma) expr_matrix <- normalizeBetweenArrays(expr_matrix) chip_data$normalize_performed <- TRUE cat("✅ limma标准化已完成\n") } # 保存处理后的数据 chip_data$expr_preprocessed <- expr_matrix # 生成结果报告 chip_data$preprocess_report <- list( log2_performed = chip_data$log2_performed, normalize_performed = chip_data$normalize_performed, n_probes = nrow(expr_matrix), n_samples = ncol(expr_matrix), data_range = range(expr_matrix, na.rm = TRUE) ) # 🆕 生成箱线图对比（矫正前后） tryCatch({ library(ggplot2) library(reshape2) # 矫正前的数据 - 计算每个样本的统计值用于箱线图 expr_before <- chip_data$expr_before_preprocess # 转置矩阵：行为样本，列为探针 df_before <- as.data.frame(t(expr_before)) df_before$Sample <- rownames(df_before) # 将数据从宽格式转换为长格式（使用reshape2的melt） df_before_long <- melt(df_before, id.vars = "Sample", variable.name = "Probe", value.name = "Expression") df_before_long$Stage <- "Before" # 矫正后的数据 df_after <- as.data.frame(t(expr_matrix)) df_after$Sample <- rownames(df_after) df_after_long <- melt(df_after, id.vars = "Sample", variable.name = "Probe", value.name = "Expression") df_after_long$Stage <- "After" # 合并数据 df_combined <- rbind(df_before_long, df_after_long) # 绘制箱线图 p <- ggplot(df_combined, aes(x = Sample, y = Expression, fill = Stage)) + geom_boxplot() + theme_bw() + theme( axis.text.x = element_text(angle = 90, hjust = 1, vjust = 0.5, size = 8), legend.position = "top", plot.title = element_text(hjust = 0.5) ) + labs( title = "数据预处理前后对比", x = "样本", y = "表达值", fill = "阶段" ) + scale_fill_manual(values = c("Before" = "#E69F00", "After" = "#009E73")) chip_data$preprocess_boxplot <- p cat("✅ 箱线图已生成\n") }, error = function(e) { cat(sprintf("⚠️ 箱线图生成失败: %s\n", e$message)) }) showNotification("✅ 数据预处理完成！", type = "message", duration = 5) }, error = function(e) { showNotification(sprintf("❌ 预处理失败: %s", e$message), type = "error") }) }) # 预处理结果显示 output$chip_preprocess_result_ui <- renderUI({ req(chip_data$preprocess_report) req(chip_data$expr_preprocessed) report <- chip_data$preprocess_report expr_matrix <- chip_data$expr_preprocessed # 计算额外统计信息 expr_mean <- mean(expr_matrix, na.rm = TRUE) expr_median <- median(expr_matrix, na.rm = TRUE) expr_sd <- sd(expr_matrix, na.rm = TRUE) tagList( h5("✅ 预处理完成", style = "color: #28a745; font-weight: bold;"), br(), # 基本统计信息 wellPanel( style = "background: #f8f9fa; border: 1px solid #dee2e6;", h6("📊 基本统计", style = "color: #495057; margin-top: 0;"), tags$table( class = "table table-sm table-striped", style = "margin-bottom: 0;", tags$thead( tags$tr( tags$th("项目", style = "width: 50%;"), tags$th("值") ) ), tags$tbody( tags$tr( tags$td("log2转换"), tags$td({ if (report$log2_performed) tags$span("✅ 是", class = "badge badge-success") else tags$span("❌ 否", class = "badge badge-secondary") }) ), tags$tr( tags$td("limma标准化 (quantile)"), tags$td({ if (report$normalize_performed) tags$span("✅ 是", class = "badge badge-success") else tags$span("❌ 否", class = "badge badge-secondary") }) ), tags$tr( tags$td(tags$strong("探针数")), tags$td(sprintf("%d", report$n_probes)) ), tags$tr( tags$td(tags$strong("样本数")), tags$td(sprintf("%d", report$n_samples)) ), tags$tr( tags$td("数据范围"), tags$td(sprintf("%.3f ~ %.3f", report$data_range[1], report$data_range[2])) ), tags$tr( tags$td("平均值"), tags$td(sprintf("%.3f", expr_mean)) ), tags$tr( tags$td("中位数"), tags$td(sprintf("%.3f", expr_median)) ), tags$tr( tags$td("标准差"), tags$td(sprintf("%.3f", expr_sd)) ) ) ) ), br(), # 箱线图对比 wellPanel( style = "background: white; border: 1px solid #dee2e6;", h6("📊 箱线图对比（矫正前后）", style = "color: #ff9800; margin-top: 0;"), plotOutput("chip_preprocess_boxplot", height = "500px") ) ) }) # 🆕 渲染箱线图 output$chip_preprocess_boxplot <- renderPlot({ req(chip_data$preprocess_boxplot) chip_data$preprocess_boxplot }) # ============================================ # 🆕 批次矫正 - Server逻辑 # ============================================ # 自动检测批次 observeEvent(input$chip_detect_batch, { req(chip_data$expr_preprocessed) req(input$chip_batch_pattern) pattern <- input$chip_batch_pattern sample_names <- colnames(chip_data$expr_preprocessed) # 从样本名中提取批次信息 batches <- sapply(sample_names, function(x) { match <- regmatches(x, regexpr(paste0(pattern, "\\w+"), x, ignore.case = TRUE)) if (length(match) > 0) { return(match) } else { return("Unknown") } }) # 保存批次信息 chip_data$batch_info <- batches chip_data$batch_method <- input$chip_batch_method %||% "limma" # 统计批次分布 batch_table <- table(batches) cat(sprintf("✅ 检测到 %d 个批次:\n", length(batch_table))) for (i in seq_along(batch_table)) { cat(sprintf(" - %s: %d 个样本\n", names(batch_table)[i], batch_table[i])) } showNotification( sprintf("✅ 检测到 %d 个批次", length(batch_table)), type = "message" ) }) # 解析手动指定的批次 observeEvent(input$chip_batch_manual, { req(input$chip_batch_manual) tryCatch({ lines <- strsplit(input$chip_batch_manual, "\n")[[1]] lines <- lines[lines != "" & !grepl("^\\s*$", lines)] batch_mapping <- list() for (line in lines) { parts <- strsplit(line, "\t")[[1]] if (length(parts) >= 2) { batch_mapping[[trimws(parts[1])]] <- trimws(parts[2]) } } chip_data$batch_manual_mapping <- batch_mapping sample_names <- colnames(chip_data$expr_preprocessed) batches <- sapply(sample_names, function(x) { if (x %in% names(batch_mapping)) { return(batch_mapping[[x]]) } else { return("Unknown") } }) chip_data$batch_info <- batches batch_table <- table(batches) cat(sprintf("✅ 手动指定批次: %d 个批次\n", length(batch_table))) showNotification( sprintf("✅ 手动指定批次: %d 个批次", length(batch_table)), type = "message" ) }, error = function(e) { showNotification(sprintf("❌ 解析批次信息失败: %s", e$message), type = "error") }) }) # 显示批次信息 output$chip_batch_info_ui <- renderUI({ req(chip_data$batch_info) batches <- chip_data$batch_info batch_table <- table(batches) tagList( tags$table( class = "table table-striped", tags$thead( tags$tr( tags$th("批次"), tags$th("样本数") ) ), tags$tbody( lapply(seq_along(batch_table), function(i) { tags$tr( tags$td(names(batch_table)[i]), tags$td(batch_table[i]) ) }) ) ) ) }) # 执行批次矫正 observeEvent(input$chip_apply_batch_correct, { req(chip_data$expr_preprocessed) req(chip_data$batch_info) showNotification("🔧 正在进行批次矫正...", type = "message") tryCatch({ expr_matrix <- chip_data$expr_preprocessed batches <- chip_data$batch_info method <- input$chip_batch_method %||% "limma" cat(sprintf("📊 批次矫正方法: %s\n", method)) if (method == "limma") { # 使用 limma::removeBatchEffect library(limma) batch_factor <- factor(batches) design <- model.matrix(~1, data = data.frame(batch = batch_factor)) expr_corrected <- removeBatchEffect(expr_matrix, batch = batch_factor) cat("✅ limma::removeBatchEffect 批次矫正完成\n") } else if (method == "combat") { # 使用 sva::ComBat library(sva) batch_factor <- factor(batches) expr_corrected <- ComBat( dat = expr_matrix, batch = batch_factor, mod = NULL, par.prior = TRUE, prior.plots = FALSE ) cat("✅ sva::ComBat 批次矫正完成\n") } # 保存矫正后的数据 chip_data$expr_batch_corrected <- expr_corrected chip_data$batch_correct_method <- method # 计算矫正前后的差异 mean_diff <- mean(abs(expr_matrix - expr_corrected), na.rm = TRUE) # 生成报告 chip_data$batch_correct_report <- list( method = method, n_batches = length(unique(batches)), batch_distribution = table(batches), mean_change = mean_diff, n_probes = nrow(expr_corrected), n_samples = ncol(expr_corrected) ) showNotification( sprintf("✅ 批次矫正完成！方法: %s", method), type = "message", duration = 10 ) }, error = function(e) { showNotification( sprintf("❌ 批次矫正失败: %s", e$message), type = "error", duration = 10 ) cat(sprintf("❌ 批次矫正错误: %s\n", e$message)) }) }) # 显示批次矫正结果 output$chip_batch_correct_result_ui <- renderUI({ req(chip_data$batch_correct_report) report <- chip_data$batch_correct_report method_name <- if (report$method == "limma") { "limma::removeBatchEffect" } else { "sva::ComBat" } tagList( h6("✅ 批次矫正完成", style = "color: #E91E63;"), tags$table( class = "table table-striped", tags$thead( tags$tr( tags$th("项目"), tags$th("值") ) ), tags$tbody( tags$tr( tags$td("矫正方法"), tags$td(method_name) ), tags$tr( tags$td("批次数"), tags$td(report$n_batches) ), tags$tr( tags$td("探针/基因数"), tags$td(report$n_probes) ), tags$tr( tags$td("样本数"), tags$td(report$n_samples) ), tags$tr( tags$td("平均变化幅度"), tags$td(sprintf("%.4f", report$mean_change)) ) ) ), br(), helpText("💡 提示：批次矫正后的数据已保存，将用于后续的探针去重和差异分析。") ) }) # 步骤2: 探针去重 observeEvent(input$chip_dedupe_probes, { req(chip_data$expr_preprocessed) showNotification("✂️ 正在进行探针去重...", type = "message") tryCatch({ library(dplyr) library(tibble) # ✅ 优先使用批次矫正后的数据 if (!is.null(chip_data$expr_batch_corrected)) { expr_matrix <- chip_data$expr_batch_corrected cat("✅ 使用批次矫正后的数据进行探针去重\n") } else { expr_matrix <- chip_data$expr_preprocessed cat("✅ 使用预处理后的数据进行探针去重\n") } # 转换为数据框并添加探针ID和基因信息 expr_df <- as.data.frame(expr_matrix) expr_df <- expr_df %>% rownames_to_column("ProbeID") # 🔧 检查merged_matrix中的可用列 available_cols <- colnames(chip_data$merged_matrix) cat(sprintf("📋 merged_matrix可用列: %s\n", paste(available_cols, collapse = ", "))) # 动态选择要合并的列（只选择存在的列） merge_cols <- c("ProbeID") if ("GeneSymbol" %in% available_cols) { merge_cols <- c(merge_cols, "GeneSymbol") } if ("EntrezID" %in% available_cols) { merge_cols <- c(merge_cols, "EntrezID") } cat(sprintf("📋 将合并列: %s\n", paste(merge_cols, collapse = ", "))) # 执行合并 expr_df <- expr_df %>% inner_join(chip_data$merged_matrix[, merge_cols, drop = FALSE], by = "ProbeID") # 🔧 清理合并后的EntrezID列（移除非数字字符） if ("EntrezID" %in% colnames(expr_df)) { clean_entrez_id <- function(entrez_str) { if (is.na(entrez_str) || is.null(entrez_str) || entrez_str == "") { return(NA) } entrez_str <- as.character(entrez_str) # 移除所有非数字字符（///, //, -, 等） cleaned <- gsub("[^0-9]", "", entrez_str) if (cleaned == "" || is.na(cleaned)) { return(NA) } return(cleaned) } # 统计清理前的情况 na_before <- sum(is.na(expr_df$EntrezID)) # 应用清理 expr_df$EntrezID <- sapply(expr_df$EntrezID, clean_entrez_id) # 统计清理后的情况 na_after <- sum(is.na(expr_df$EntrezID)) cat(sprintf("🔧 EntrezID清理: NA前=%d, NA后=%d, 新增NA=%d\n", na_before, na_after, na_after - na_before)) if (na_after > na_before) { cat(sprintf("⚠️ %d个EntrezID包含非数字字符，已清理为NA\n", na_after - na_before)) } } # 🔍 诊断：检查合并后的GeneSymbol列 cat(sprintf("🔍 去重前: %d 行，GeneSymbol NA=%d, 空字符串=%d\n", nrow(expr_df), sum(is.na(expr_df$GeneSymbol)), sum(expr_df$GeneSymbol == ""))) # 移除没有基因符号的探针 expr_df <- expr_df[!is.na(expr_df$GeneSymbol) & expr_df$GeneSymbol != "", ] cat(sprintf("🔍 移除NA后: %d 行剩余\n", nrow(expr_df))) # 如果移除后没有数据，警告并跳过去重 if (nrow(expr_df) == 0) { cat("⚠️ 警告：移除NA基因后没有数据！请检查合并步骤的GeneSymbol列\n") showNotification("❌ 去重失败：所有基因都是NA，请检查ID列和基因列是否匹配", type = "error", duration = 10) return() } # 探针去重：保留表达量最高的探针 # 使用GeneSymbol去重，但保留EntrezID列供差异分析使用 # 最终expr_deduped包含：行名=GeneSymbol, 列=EntrezID + 样本数据 if ("EntrezID" %in% colnames(expr_df)) { expr_df <- expr_df %>% select(-ProbeID) %>% # 去掉探针ID列 select(GeneSymbol, EntrezID, everything()) %>% # 基因符号和ID放前面 mutate(rowMean = rowMeans(.[, -(1:2)])) %>% # 计算平均表达量（排除前两列） arrange(desc(rowMean)) %>% # 按表达量降序排列 distinct(GeneSymbol, .keep_all = TRUE) %>% # 按基因符号去重 select(-rowMean) %>% # 删除辅助列（保留EntrezID列！） column_to_rownames("GeneSymbol") # GeneSymbol作为行名，EntrezID保留为列 cat("✅ 去重使用GeneSymbol，行名=GeneSymbol，EntrezID保留为列供差异分析使用\n") } else { # 没有EntrezID，使用GeneSymbol expr_df <- expr_df %>% select(-ProbeID) %>% # 去掉探针ID列 select(GeneSymbol, everything()) %>% # 基因符号放第一 mutate(rowMean = rowMeans(.[, -1])) %>% # 计算平均表达量 arrange(desc(rowMean)) %>% # 按表达量降序排列 distinct(GeneSymbol, .keep_all = TRUE) %>% # 去重 select(-rowMean) %>% # 删除辅助列 column_to_rownames("GeneSymbol") # 基因符号变回行名 cat("✅ 去重使用GeneSymbol，最终结果使用GeneSymbol作为行名\n") } # 保存去重后的数据 chip_data$expr_deduped <- expr_df # 统计信息 n_before <- nrow(chip_data$expr_preprocessed) n_after <- nrow(expr_df) reduction_rate <- (n_before - n_after) / n_before * 100 chip_data$dedupe_report <- list( n_probes_before = n_before, n_genes_after = n_after, n_removed = n_before - n_after, reduction_rate = reduction_rate, n_samples = ncol(expr_df) ) cat(sprintf("✅ 探针去重完成: %d 探针 → %d 基因 (%.1f%% 减少)\n", n_before, n_after, reduction_rate)) showNotification( sprintf("✅ 去重完成！%d 探针 → %d 基因", n_before, n_after), type = "message", duration = 5 ) }, error = function(e) { showNotification(sprintf("❌ 去重失败: %s", e$message), type = "error") }) }) # 去重后统计显示 output$chip_after_dedupe_stats <- renderUI({ req(chip_data$dedupe_report) report <- chip_data$dedupe_report div( style = "font-size: 12px; color: #28a745;", tags$ul(style = "padding-left: 15px; margin: 5px 0;", tags$li(sprintf("基因数: %d", report$n_genes_after)), tags$li(sprintf("样本数: %d", report$n_samples)), tags$li(sprintf("减少探针数: %d (%.1f%%)", report$n_removed, report$reduction_rate)) ) ) }) # 去重结果显示 output$chip_dedupe_result_ui <- renderUI({ req(chip_data$dedupe_report) report <- chip_data$dedupe_report tagList( tags$table( class = "table table-striped", tags$thead( tags$tr( tags$th("项目"), tags$th("值") ) ), tags$tbody( tags$tr( tags$td("去重前探针数"), tags$td(report$n_probes_before) ), tags$tr( tags$td("去重后基因数"), tags$td(report$n_genes_after) ), tags$tr( tags$td("减少的探针数"), tags$td(report$n_removed) ), tags$tr( tags$td("减少比例"), tags$td(sprintf("%.1f%%", report$reduction_rate)) ), tags$tr( tags$td("样本数"), tags$td(report$n_samples) ) ) ), br(), h6("📊 去重后表达矩阵预览（前5行 × 前10列）：", style = "color: #666;"), # 显示去重后的矩阵预览 DTOutput("chip_deduped_matrix_preview") ) }) # 去重后矩阵预览表格 output$chip_deduped_matrix_preview <- renderDT({ req(chip_data$expr_deduped) preview_df <- head(chip_data$expr_deduped, 5) if (ncol(preview_df) > 10) { preview_df <- preview_df[, 1:10] } datatable( as.data.frame(preview_df), options = list( dom = 't', paging = FALSE, scrollX = TRUE ), rownames = TRUE, filter = 'none' ) %>% formatStyle(columns = 1:ncol(preview_df), fontSize = '85%') }) # 步骤3: 生成标准格式数据 observeEvent(input$chip_generate_standard_data, { req(chip_data$expr_deduped) showNotification("🚀 正在生成标准格式数据...", type = "message") tryCatch({ # 保存为标准格式（可直接用于现有分析模块） chip_data$standard_expression <- chip_data$expr_deduped # 保存样本名称 chip_data$sample_names <- colnames(chip_data$expr_deduped) # 保存基因名称 chip_data$gene_names <- rownames(chip_data$expr_deduped) # 标记数据已准备好 chip_data$ready_for_analysis <- TRUE cat(sprintf("✅ 标准格式数据已生成: %d 基因 × %d 样本\n", nrow(chip_data$standard_expression), ncol(chip_data$standard_expression))) showNotification( sprintf("✅ 标准格式数据已生成！%d 基因 × %d 样本", nrow(chip_data$standard_expression), ncol(chip_data$standard_expression)), type = "message", duration = 10 ) }, error = function(e) { showNotification(sprintf("❌ 生成失败: %s", e$message), type = "error") }) }) # 标准数据摘要显示 output$chip_standard_data_summary <- renderUI({ req(chip_data$standard_expression) tagList( h6("📊 数据摘要", style = "color: #155724;"), tags$table( class = "table table-striped", tags$thead( tags$tr( tags$th("项目"), tags$th("值") ) ), tags$tbody( tags$tr( tags$td("基因数"), tags$td(nrow(chip_data$standard_expression)) ), tags$tr( tags$td("样本数"), tags$td(ncol(chip_data$standard_expression)) ), tags$tr( tags$td("样本名称"), tags$td(paste(head(chip_data$sample_names, 5), collapse = ", ")) ) ) ), br(), h6("✅ 现在可以进行以下分析：", style = "color: #155724;"), tags$ul(style = "padding-left: 20px;", tags$li("切换到“差异分析”模块进行limma分析"), tags$li("使用样本分组功能设置对照组和处理组"), tags$li("进行KEGG和GO富集分析"), tags$li("生成火山图和其他可视化") ) ) }) # ============================================ # 原有的分组逻辑继续 # ============================================ # 动态生成分组 UI output$chip_grouping_ui <- renderUI({ req(chip_data$series_matrix) sample_names <- colnames(chip_data$series_matrix) # 如果自动检测到分组 if (!is.null(chip_data$group_info) && !is.null(chip_data$group_info$pattern_name)) { tagList( div( class = "alert alert-info", h5("✅ 自动检测到分组模式"), p(sprintf("模式: %s", chip_data$group_info$pattern_name)), p(sprintf("对照组: %s", paste(chip_data$group_info$ctrl_samples, collapse = ", "))), p(sprintf("处理组: %s", paste(chip_data$group_info$trt_samples, collapse = ", "))), checkboxInput("chip_use_auto_groups", "使用自动检测的分组", value = TRUE) ), conditionalPanel( condition = "!input.chip_use_auto_groups", h5("手动选择分组:"), helpText("💡 提示：可以点击输入框后，直接粘贴样本名称（用逗号或空格分隔）"), fluidRow( column(6, selectizeInput("chip_ctrl_samples", "对照组样本:", choices = sample_names, multiple = TRUE, options = list(create = TRUE)) ), column(6, selectizeInput("chip_trt_samples", "处理组样本:", choices = sample_names, multiple = TRUE, options = list(create = TRUE)) ) ) ) ) } else { # 手动分组 tagList( div( class = "alert alert-warning", h5("⚠️ 未能自动检测分组模式"), p("请使用上方的快速粘贴功能，或手动指定对照组和处理组样本。") ), helpText("💡 提示：可以点击输入框后，直接粘贴样本名称（用逗号或空格分隔）"), fluidRow( column(6, selectizeInput("chip_ctrl_samples", "对照组样本:", choices = sample_names, multiple = TRUE, options = list(create = TRUE)) ), column(6, selectizeInput("chip_trt_samples", "处理组样本:", choices = sample_names, multiple = TRUE, options = list(create = TRUE)) ) ) ) } }) # 显示当前分组状态 output$chip_current_groups_ui <- renderUI({ req(chip_data$series_matrix) # 检查是否有手动设置的分组 has_manual <- !is.null(chip_data$manual_ctrl_samples) && !is.null(chip_data$manual_trt_samples) # 检查是否有自动检测的分组 has_auto <- !is.null(chip_data$group_info) && !is.null(chip_data$group_info$pattern_name) if (has_manual) { div( class = "alert alert-success", h5("✅ 当前分组（手动设置）"), p(sprintf("对照组 (%d个): %s", length(chip_data$manual_ctrl_samples), paste(chip_data$manual_ctrl_samples, collapse = ", "))), p(sprintf("处理组 (%d个): %s", length(chip_data$manual_trt_samples), paste(chip_data$manual_trt_samples, collapse = ", "))) ) } else if (has_auto) { div( class = "alert alert-info", h5("🤖 当前分组（自动检测）"), p(sprintf("模式: %s", chip_data$group_info$pattern_name)), p(sprintf("对照组 (%d个): %s", length(chip_data$group_info$ctrl_samples), paste(chip_data$group_info$ctrl_samples, collapse = ", "))), p(sprintf("处理组 (%d个): %s", length(chip_data$group_info$trt_samples), paste(chip_data$group_info$trt_samples, collapse = ", "))) ) } else { div( class = "alert alert-warning", h5("⚠️ 尚未设置分组"), p("请使用上方的快速粘贴功能设置分组，或使用手动选择。") ) } }) # 手动分组UI（折叠状态） output$chip_manual_grouping_ui <- renderUI({ req(chip_data$series_matrix) sample_names <- colnames(chip_data$series_matrix) tagList( h5("📝 手动选择样本（备选方案）", style = "color: #6E6E73;"), helpText("如果快速粘贴不方便，可以在这里手动选择样本："), fluidRow( column(6, selectInput("chip_ctrl_samples_manual", "对照组样本:", choices = sample_names, multiple = TRUE) ), column(6, selectInput("chip_trt_samples_manual", "处理组样本:", choices = sample_names, multiple = TRUE) ) ), actionButton("chip_apply_manual_groups", "✅ 应用手动选择的分组", class = "btn-success", style = "width: 100%; margin-top: 10px;") ) }) # 应用手动选择的分组 observeEvent(input$chip_apply_manual_groups, { req(input$chip_ctrl_samples_manual) req(input$chip_trt_samples_manual) if (length(input$chip_ctrl_samples_manual) == 0 || length(input$chip_trt_samples_manual) == 0) { showNotification("请至少为每组选择一个样本！", type = "warning") return(NULL) } chip_data$manual_ctrl_samples <- input$chip_ctrl_samples_manual chip_data$manual_trt_samples <- input$chip_trt_samples_manual showNotification( sprintf("✅ 已应用手动分组: %d 对照 + %d 处理", length(input$chip_ctrl_samples_manual), length(input$chip_trt_samples_manual)), type = "message" ) }) # 运行差异分析 observeEvent(input$run_chip_analysis, { req(chip_data$series_matrix) # 获取分组信息（优先级：手动粘贴 > 自动检测 > 下拉选择） if (!is.null(chip_data$manual_ctrl_samples) && !is.null(chip_data$manual_trt_samples)) { # 使用手动粘贴的分组 ctrl_samples <- chip_data$manual_ctrl_samples trt_samples <- chip_data$manual_trt_samples cat("✅ 使用手动粘贴的分组\n") } else if (!is.null(input$chip_use_auto_groups) && input$chip_use_auto_groups && !is.null(chip_data$group_info) && !is.null(chip_data$group_info$pattern_name)) { # 使用自动检测的分组 ctrl_samples <- chip_data$group_info$ctrl_samples trt_samples <- chip_data$group_info$trt_samples cat("✅ 使用自动检测的分组\n") } else { # 使用下拉选择的分组 ctrl_samples <- input$chip_ctrl_samples trt_samples <- input$chip_trt_samples cat("✅ 使用下拉选择的分组\n") } # 验证分组 if (is.null(ctrl_samples) || length(ctrl_samples) == 0 || is.null(trt_samples) || length(trt_samples) == 0) { showNotification("请先设置对照组和处理组样本！", type = "error") return(NULL) } # 显示进度 showNotification("正在运行差异分析...", type = "message") # ✅ 优先使用经过完整预处理流程的数据 if (!is.null(chip_data$standard_expression) && chip_data$ready_for_analysis) { # 使用标准格式数据（已探针注释、预处理、去重） expr_matrix <- chip_data$standard_expression cat("✅ 使用标准格式数据（已探针注释和去重）\n") cat(sprintf(" 表达矩阵: %d 基因 × %d 样本\n", nrow(expr_matrix), ncol(expr_matrix))) } else if (!is.null(chip_data$expr_deduped)) { # 使用去重后的数据 expr_matrix <- chip_data$expr_deduped cat("✅ 使用去重后的表达数据\n") } else if (!is.null(chip_data$merged_matrix)) { # 使用合并后的数据（探针已注释，但未去重） # 需要去掉ProbeID和Gene列 merged_df <- chip_data$merged_matrix # 识别数值列（样本数据） numeric_cols <- sapply(merged_df, function(x) is.numeric(x)) expr_matrix <- as.matrix(merged_df[, numeric_cols, drop = FALSE]) # 使用ProbeID作为行名（因为可能还需要探针级别的信息） if ("ProbeID" %in% colnames(merged_df)) { rownames(expr_matrix) <- merged_df$ProbeID } else { rownames(expr_matrix) <- merged_df$Gene } cat("✅ 使用合并后的数据（探针已注释）\n") } else { # 最后的备选方案：使用原始Series Matrix probe_mapping <- chip_data$probe_mapping if (is.null(probe_mapping)) { # 如果没有加载注释文件，使用探针ID作为基因符号 expr_matrix <- chip_data$series_matrix cat("⚠️ 未加载注释文件，使用探针ID作为基因符号\n") } else { # 使用注释映射（旧的自动检测方法） expr_matrix <- aggregate_probe_expression( chip_data$series_matrix, probe_mapping ) if (is.null(expr_matrix)) { showNotification("探针注释失败！", type = "error") return(NULL) } } } # 运行 limma 分析 limma_res <- run_limma_analysis( expr_matrix = expr_matrix, ctrl_samples = ctrl_samples, trt_samples = trt_samples, logfc_threshold = input$chip_logfc_threshold, pvalue_threshold = input$chip_pvalue_threshold, pval_type = input$chip_pval_type # 🔧 传入用户选择的P值类型 ) if (is.null(limma_res)) { showNotification("差异分析失败！", type = "error") return(NULL) } # 转换为标准格式 formatted_results <- format_chip_results_for_pipeline( limma_res, expr_matrix, ctrl_samples, trt_samples ) # 保存结果到 reactiveValues chip_data$limma_results <- limma_res chip_data$formatted_results <- formatted_results showNotification( sprintf("✅ 分析完成: %d 个显著差异基因", limma_res$n_significant), type = "message" ) }) # 显示结果 output$chip_results_ui <- renderUI({ req(chip_data$limma_results) limma_res <- chip_data$limma_results tagList( # 统计摘要 fluidRow( column(3, wellPanel( style = "background: #f8f9fa; border: 2px solid #dee2e6; text-align: center; padding: 20px;", h3(limma_res$n_total, style = "color: #495057; margin: 10px 0;"), h6("总基因数", style = "color: #6c757d; margin: 0;") ) ), column(3, wellPanel( style = "background: #e7f3ff; border: 2px solid #007bff; text-align: center; padding: 20px;", h3(limma_res$n_significant, style = "color: #007bff; margin: 10px 0;"), icon("star", style = "color: #007bff; font-size: 24px;"), h6("显著差异", style = "color: #007bff; margin: 5px 0 0 0;") ) ), column(3, wellPanel( style = "background: #d4edda; border: 2px solid #28a745; text-align: center; padding: 20px;", h3(limma_res$n_up, style = "color: #28a745; margin: 10px 0;"), icon("arrow-up", style = "color: #28a745; font-size: 24px;"), h6("上调", style = "color: #28a745; margin: 5px 0 0 0;") ) ), column(3, wellPanel( style = "background: #f8d7da; border: 2px solid #dc3545; text-align: center; padding: 20px;", h3(limma_res$n_down, style = "color: #dc3545; margin: 10px 0;"), icon("arrow-down", style = "color: #dc3545; font-size: 24px;"), h6("下调", style = "color: #dc3545; margin: 5px 0 0 0;") ) ) ), hr(), # 结果表格 h4("差异分析结果"), DTOutput("chip_results_table"), br(), # 下载按钮 downloadButton("download_chip_results", "📥 下载结果", class = "btn-success") ) }) # 结果表格 output$chip_results_table <- renderDT({ req(chip_data$limma_results) results <- chip_data$limma_results$results # 🔧 添加显著性标记 - 根据用户选择的P值类型 pval_col <- if (input$chip_pval_type == "adj.P.Val") "adj.P.Val" else "P.Value" results$Significant <- ifelse( results[[pval_col]] < input$chip_pvalue_threshold & abs(results$logFC) >= input$chip_logfc_threshold, "Yes", "No" ) # 🔧 修复：重新排列列顺序，确保ID和SYMBOL列在前 # 期望顺序：ID, SYMBOL, logFC, AveExpr, t, P.Value, adj.P.Val, B, Significant results_ordered <- results[, c("ID", "SYMBOL", "logFC", "AveExpr", "t", "P.Value", "adj.P.Val", "B", "Significant")] # 🔍 诊断：检查ID列的内容 id_sample <- head(results_ordered$ID, 5) cat(sprintf("📊 差异分析结果ID列示例: %s\n", paste(id_sample, collapse = ", "))) cat(sprintf("📊 ID列类型: %s\n", class(results_ordered$ID)[1])) # 检查ID列是否为基因符号（包含字母）还是EntrezID（纯数字） is_entrez_id <- all(grepl("^[0-9]+$", results_ordered$ID[!is.na(results_ordered$ID)])) if (!is_entrez_id) { cat("⚠️ 警告: ID列包含基因符号而非Entrez Gene ID！\n") cat("💡 这可能是因为SOFT文件中缺少EntrezID列\n") } datatable( results_ordered, options = list( pageLength = 25, scrollX = TRUE, order = list(list(6, 'asc')) # 按P.Value排序（第6列） ), filter = 'top', rownames = FALSE ) %>% formatRound(columns = c('logFC', 'AveExpr', 't', 'P.Value', 'adj.P.Val'), digits = 4) %>% formatStyle( columns = c('ID', 'SYMBOL'), backgroundColor = '#e8f4f8', fontWeight = 'bold' ) %>% formatStyle( 'Significant', color = styleEqual(c('Yes', 'No'), c('green', 'grey')), fontWeight = 'bold' ) }) # 下载结果 output$download_chip_results <- downloadHandler( filename = function() { sprintf("chip_analysis_results_%s.csv", Sys.Date()) }, content = function(file) { req(chip_data$limma_results) results <- chip_data$limma_results$results write.csv(results, file, row.names = FALSE) } ) } # ===================================================== # 模块结束 # ===================================================== # ===================================================== # 7. 辅助函数：解析粘贴的样本列表 # ===================================================== #' 解析粘贴的样本列表（每行一个样本名） #' #' @param pasted_text 粘贴的文本内容 #' @param expr_matrix 表达矩阵（用于验证样本名） #' @return vector 样本名向量 parse_sample_list <- function(pasted_text, expr_matrix) { cat("🔍 开始解析样本列表...\n") # 分割成行 lines <- strsplit(pasted_text, "\n")[[1]] lines <- trimws(lines) # 移除首尾空白 lines <- lines[lines != ""] # 移除空行 if (length(lines) == 0) { cat("⚠️ 粘贴内容为空\n") return(NULL) } cat(sprintf("📊 读取到 %d 行\n", length(lines))) # 获取表达矩阵的样本名 matrix_samples <- colnames(expr_matrix) # 匹配样本名 valid_samples <- intersect(lines, matrix_samples) if (length(valid_samples) == 0) { cat("⚠️ 未找到匹配的样本\n") cat(sprintf(" 粘贴的样本: %s\n", paste(head(lines, 3), collapse = ", "))) cat(sprintf(" 可用样本: %s\n", paste(head(matrix_samples, 3), collapse = ", "))) return(NULL) } cat(sprintf("✅ 匹配成功: %d / %d 个样本\n", length(valid_samples), length(lines))) # 检查是否有未匹配的样本 unmatched <- setdiff(lines, matrix_samples) if (length(unmatched) > 0) { cat(sprintf("⚠️ %d 个样本未匹配: %s\n", length(unmatched), paste(head(unmatched, 3), collapse = ", "))) } return(valid_samples) } #' 解析用户粘贴的分组信息（旧版本，保留备用） #' #' @param pasted_text 粘贴的文本内容 #' @param group_col_name 分组列名（可选） #' @param expr_matrix 表达矩阵（用于验证样本名） #' @return list 包含 ctrl_samples 和 trt_samples parse_pasted_groups <- function(pasted_text, group_col_name, expr_matrix) { cat("🔍 开始解析粘贴的分组信息...\n") # 分割成行 lines <- strsplit(pasted_text, "\n")[[1]] lines <- lines[lines != ""] # 移除空行 if (length(lines) == 0) { return(list(success = FALSE, error = "粘贴内容为空")) } # 方法1: 如果指定了分组列名，按列名解析 if (!is.null(group_col_name) && group_col_name != "") { cat(sprintf("📋 使用分组列名: %s\n", group_col_name)) # 尝试读取为表格 tryCatch({ # 读取文本 text_conn <- textConnection(lines) df <- read.table(text_conn, header = TRUE, sep = "\t", stringsAsFactors = FALSE, check.names = FALSE, quote = "\"", comment.char = "") close(text_conn) # 检查是否存在分组列 if (!group_col_name %in% colnames(df)) { return(list(success = FALSE, error = sprintf("未找到分组列 '%s'，可用列: %s", group_col_name, paste(colnames(df), collapse = ", ")))) } # 提取分组信息 groups <- df[[group_col_name]] # 获取唯一分组 unique_groups <- unique(groups) if (length(unique_groups) < 2) { return(list(success = FALSE, error = "分组列中只有一个组，需要至少2个组")) } # 如果超过2个组，取前2个 if (length(unique_groups) > 2) { cat(sprintf("⚠️ 检测到 %d 个组，将使用前两个: %s\n", length(unique_groups), paste(unique_groups[1:2], collapse = ", "))) unique_groups <- unique_groups[1:2] } # 根据分组列提取样本 ctrl_name <- unique_groups[1] trt_name <- unique_groups[2] ctrl_samples <- colnames(df)[groups == ctrl_name] trt_samples <- colnames(df)[groups == trt_name] # 移除分组列本身 ctrl_samples <- ctrl_samples[ctrl_samples != group_col_name] trt_samples <- trt_samples[trt_samples != group_col_name] cat(sprintf("✅ 解析成功: %d 对照 (%s) + %d 处理 (%s)\n", length(ctrl_samples), ctrl_name, length(trt_samples), trt_name)) return(list( success = TRUE, ctrl_samples = ctrl_samples, trt_samples = trt_samples )) }, error = function(e) { return(list(success = FALSE, error = paste("解析表格失败:", e$message))) }) } # 方法2: 没有指定列名，自动检测 cat("🤖 自动检测分组模式...\n") # 尝试检测第一行是否为列名 first_line <- lines[1] tryCatch({ # 读取为表格 text_conn <- textConnection(lines) df <- read.table(text_conn, header = TRUE, sep = "\t", stringsAsFactors = FALSE, check.names = FALSE, quote = "\"", comment.char = "") close(text_conn) # 获取所有样本名（列名，排除第一列ID列） all_samples <- colnames(df)[-1] # 排除ID列 # 获取表达矩阵的样本名 matrix_samples <- colnames(expr_matrix) # 找到交集 common_samples <- intersect(all_samples, matrix_samples) if (length(common_samples) < 2) { return(list(success = FALSE, error = sprintf("在粘贴内容中只找到 %d 个有效样本，需要至少2个", length(common_samples)))) } cat(sprintf("📊 找到 %d 个有效样本\n", length(common_samples))) # 尝试从列名中自动分组 # 使用现有的自动检测函数 sample_names <- common_samples # 如果有多余的列，尝试从第二列开始检测分组模式 if (ncol(df) > 2) { # 检查第二列是否有分组信息 potential_groups <- df[[2]] if (length(unique(potential_groups)) == 2) { unique_g <- unique(potential_groups) ctrl_samples <- sample_names[potential_groups == unique_g[1]] trt_samples <- sample_names[potential_groups == unique_g[2]] cat(sprintf("✅ 自动检测分组: %d 对照 + %d 处理\n", length(ctrl_samples), length(trt_samples))) return(list( success = TRUE, ctrl_samples = ctrl_samples, trt_samples = trt_samples )) } } # 如果无法自动检测，返回所有样本让用户手动选择 cat("⚠️ 无法自动检测分组，返回所有样本供手动选择\n") # 默认：前一半作为对照，后一半作为处理 n_samples <- length(sample_names) mid_point <- ceiling(n_samples / 2) ctrl_samples <- sample_names[1:mid_point] trt_samples <- sample_names[(mid_point+1):n_samples] cat(sprintf("⚠️ 默认分组: 前 %d 个为对照，后 %d 个为处理\n", length(ctrl_samples), length(trt_samples))) return(list( success = TRUE, ctrl_samples = ctrl_samples, trt_samples = trt_samples, warning = "无法自动检测分组模式，已按位置默认分组，请手动调整" )) }, error = function(e) { return(list(success = FALSE, error = paste("解析失败:", e$message))) }) }