+
+
+
+
+
+
+
+
+
+
+
+
+Measure the continuity and smooth of our clustering performance in the spatial domain using PAS and CHAOS
+ +DLFCP and psoriasis dataset
+PAS: Percentage of abnormal spots
+CHAOS: spatial chaos score
+ + + +library(tidyverse)package 㤼㸱tidyverse㤼㸲 was built under R version 4.1.3package 㤼㸱ggplot2㤼㸲 was built under R version 4.1.3package 㤼㸱tibble㤼㸲 was built under R version 4.1.3package 㤼㸱tidyr㤼㸲 was built under R version 4.1.3package 㤼㸱readr㤼㸲 was built under R version 4.1.3package 㤼㸱purrr㤼㸲 was built under R version 4.1.3package 㤼㸱dplyr㤼㸲 was built under R version 4.1.3package 㤼㸱stringr㤼㸲 was built under R version 4.1.3package 㤼㸱forcats㤼㸲 was built under R version 4.1.3package 㤼㸱lubridate㤼㸲 was built under R version 4.1.3-- Attaching core tidyverse packages ------------------- tidyverse 2.0.0 --
+v dplyr 1.1.2 v readr 2.1.4
+v forcats 1.0.0 v stringr 1.5.0
+v ggplot2 3.4.2 v tibble 3.2.1
+v lubridate 1.9.2 v tidyr 1.3.0
+v purrr 1.0.1 -- Conflicts ------------------------------------- tidyverse_conflicts() --
+x dplyr::filter() masks stats::filter()
+x dplyr::lag() masks stats::lag()
+i Use the conflicted package (<http://conflicted.r-lib.org/>) to force all conflicts to become errorsWarning messages:
+1: R graphics engine version 14 is not supported by this version of RStudio. The Plots tab will be disabled until a newer version of RStudio is installed.
+2: In do_once((if (is_R_CMD_check()) stop else warning)("The function xfun::isFALSE() will be deprecated in the future. Please ", :
+ The function xfun::isFALSE() will be deprecated in the future. Please consider using base::isFALSE(x) or identical(x, FALSE) instead.library(parallel)
+
+
+#mac
+fx_CHAOS = function(clusterlabel, location){
+ # require(parallel)
+ matched_location=location
+ NAs = which(is.na(clusterlabel))
+ if(length(NAs>0)){
+ clusterlabel=clusterlabel[-NAs]
+ matched_location = matched_location[-NAs,]
+ }
+ matched_location = scale(matched_location)
+ dist_val = rep(0,length(unique(clusterlabel)))
+ count = 0
+ for(k in unique(clusterlabel)){
+ count = count + 1
+ location_cluster = matched_location[which(clusterlabel == k),]
+ if(length(location_cluster)==2){next}
+ #require(parallel)
+ results = mclapply(1:dim(location_cluster)[1], fx_1NN, location_in=location_cluster,mc.cores = 5) #This is the MC part
+ dist_val[count] = sum(unlist(results))
+ }
+ dist_val = na.omit(dist_val)
+ return(sum(dist_val)/length(clusterlabel))
+
+}
+
+
+#windows
+fx_PAS = function(clusterlabel, location){
+ # require(parallel)
+
+ matched_location=location
+ NAs = which(is.na(clusterlabel))
+ if(length(NAs>0)){
+ clusterlabel=clusterlabel[-NAs]
+ matched_location = matched_location[-NAs,]
+ }
+
+ results = mclapply(1:dim(matched_location)[1], fx_kNN, location_in=matched_location,k=10,cluster_in=clusterlabel, mc.cores = 5)
+ return(sum(unlist(results))/length(clusterlabel))
+}
+
+
+#mac
+fx_PAS = function(clusterlabel, location) {
+
+ plan(multisession, workers = 3) # sets the plan to use 5 cores for parallel processing
+
+ matched_location = location
+ NAs = which(is.na(clusterlabel))
+ if (length(NAs) > 0) {
+ clusterlabel = clusterlabel[-NAs]
+ matched_location = matched_location[-NAs, ]
+ }
+
+ results = future_lapply(1:dim(matched_location)[1], fx_kNN,
+ location_in = matched_location,
+ k = 10,
+ cluster_in = clusterlabel)
+
+ return(sum(unlist(results)) / length(clusterlabel))
+}
+
+
+library(future)package 㤼㸱future㤼㸲 was built under R version 4.1.3library(future.apply)
+
+
+#windows
+fx_CHAOS = function(clusterlabel, location){
+ # Set future plan to use 3 cores
+ plan(multisession, workers = 3)
+
+ matched_location = location
+ NAs = which(is.na(clusterlabel))
+
+ if(length(NAs) > 0){
+ clusterlabel = clusterlabel[-NAs]
+ matched_location = matched_location[-NAs,]
+ }
+
+ matched_location = scale(matched_location)
+ dist_val = rep(0, length(unique(clusterlabel)))
+ count = 0
+
+ for(k in unique(clusterlabel)){
+ count = count + 1
+ location_cluster = matched_location[which(clusterlabel == k),]
+
+ if(nrow(location_cluster) <= 2){next}
+
+ # Use future_lapply for parallelization
+ results = future_lapply(1:nrow(location_cluster), fx_1NN, location_in = location_cluster)
+
+ dist_val[count] = sum(unlist(results))
+ }
+
+ dist_val = na.omit(dist_val)
+
+ return(sum(dist_val) / length(clusterlabel))
+}
+
+
+
+library(pdist)package 㤼㸱pdist㤼㸲 was built under R version 4.1.3fx_1NN = function(i,location_in){
+ # library(pdist)
+ line_i = rep(0,dim(location_in)[1])
+ line_i = pdist(location_in[i,],location_in[-i,])@dist
+ return(min(line_i))
+}
+
+
+fx_kNN = function(i,location_in,k,cluster_in){
+ #library(pdist)
+ line_i = rep(0,dim(location_in)[1])
+ line_i = pdist(location_in[i,],location_in[-i,])@dist
+ ind = order(line_i)[1:k]
+ cluster_use = cluster_in[-i]
+ if(sum(cluster_use[ind] != cluster_in[i])>(k/2)){
+ return(1)
+ }else{
+ return(0)
+ }
+
+}
+
+Clusters loading
+ + + +location = read_csv('C:\\Users\\Juan\\Desktop\\temp_data\\151673\\spatial\\tissue_positions_list.csv')New names:One or more parsing issues, call `problems()` on your data frame for
+details, e.g.:
+ dat <- vroom(...)
+ problems(dat)Rows: 4992 Columns: 7-- Column specification ---------------------------------------------------
+Delimiter: ","
+chr (1): ...1
+dbl (5): a, b, c, d, x
+lgl (1): y
+i Use `spec()` to retrieve the full column specification for this data.
+i Specify the column types or set `show_col_types = FALSE` to quiet this message.location2 = readRDS('C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\DLPFC_spatial_3639cells_2cols.rds')
+dim(location2)[1] 3639 2dim(location)[1] 4992 7rownames(location) = location$...1Setting row names on a tibble is deprecated.GT = read_csv('C:\\Users\\Juan\\Desktop\\temp_data\\151673\\cluster_labels_151673.csv')Rows: 3639 Columns: 22-- Column specification ---------------------------------------------------
+Delimiter: ","
+chr (2): key, ground_truth
+dbl (20): SpatialDE_PCA, SpatialDE_pool_PCA, HVG_PCA, pseudobulk_PCA, m...
+i Use `spec()` to retrieve the full column specification for this data.
+i Specify the column types or set `show_col_types = FALSE` to quiet this message.stcca_c = readRDS('C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\stCCA_DLPFC_benchmark_clusters.rds')
+pca = readRDS('C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\PCA_DLPFC_benchmark_clusters.rds')
+
+# Get common row names
+common_rows <- intersect(rownames(location), rownames(location2))
+
+# Filter location2
+location2_filtered <- location2[common_rows, ]
+
+# Optionally, also filter location
+location_filtered <- location[common_rows, ]
+
+location2$thruth = GT$ground_truthlocation2 %>% ggplot()+
+ geom_point(aes(x= imagecol ,y = imagerow ,color =thruth ))
# ground thruth
+fx_CHAOS(location2$thruth, location = location2[,c('imagecol','imagerow')])[1] 0.06046773#stcca
+# Iterate from 6 to 20, incrementing by 2 each time
+for (i in seq(6, 20, by=2)) {
+ # Generate the name of the source column in stcca_c
+ source_colname <- paste("stCCA CC dimension =", i)
+
+ # Generate the name of the new column to be created in location2
+ new_colname <- paste("stcca_", i, sep="")
+
+ # Assign the new column in location2 using values from stcca_c
+ location2[[new_colname]] <- stcca_c[[source_colname]]
+}
+
+#pca
+for (i in seq(6, 20, by=2)) {
+ # Generate the name of the source column in pca
+ source_colname <- paste0("PCA dimension=", i)
+
+ # Generate the name of the new column to be created in location2
+ new_colname <- paste("pca_", i, sep="")
+
+ # Assign the new column in location2 using values from pca
+ location2[[new_colname]] <- pca[[source_colname]]
+}
+
+#spaceflow
+for(i in seq(10, 30, by=5)) {
+ file_path <- paste0("C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\", i, "_res_0.3_domains.tsv")
+ # Read the TSV file into a data frame
+ spaceflow <- read.delim(file_path, header=TRUE, sep="\t")
+ # Add a new column to location2 using the label column from the read TSV
+ location2[[paste0("spaceflow", i)]] <- spaceflow$label
+}
+
+#stlearn
+
+for(i in seq(6, 20, by=2)) {
+ file_path <- paste0("C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\151673_", i, "comps_calc_cluster.csv")
+ # Read the CSV file into a data frame
+ comps_calc_cluster <- read.csv(file_path, header=TRUE)
+ # Add a new column to location2 using the label column from the read CSV
+ location2[[paste0("stLearn", i)]] <- comps_calc_cluster$X_pca_kmeans
+}
+
+
+CHAOS DLFPC
+ + + +cols_to_apply <- setdiff(names(location2), c('imagecol', 'imagerow'))
+
+results_dfchaos <- data.frame()
+
+results <- sapply(cols_to_apply, function(col) {
+ fx_CHAOS(location2[[col]], location = location2[, c('imagecol', 'imagerow')])
+})
+
+results_dfchaos <- as.data.frame(results)results_dfchaos$Combinations = rownames(results_dfchaos)
+results_dfchaos
+
+
+
+
+
+CHAOS stat
+The lower, the less the chaos
+ + + +ggplot(results_dfchaos, aes(x=Combinations, y=results)) +
+ geom_bar(stat="identity", position="dodge") +
+ theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
+ ggtitle("Output from fx_CHAOS") +
+ xlab("Variables") +
+ ylab("Values")
+
+PAS DLFPC
+ + + +cols_to_apply <- setdiff(names(location2), c('imagecol', 'imagerow'))
+
+results_dfpas <- data.frame()
+
+results <- sapply(cols_to_apply, function(col) {
+ fx_PAS(location2[[col]], location = location2[, c('imagecol', 'imagerow')])
+})
+
+results_dfpas <- as.data.frame(as.table(results))results_dfpas
+
+
+
+
+
+
+
+
+ggplot(results_dfpas, aes(x=Var1, y=Freq)) +
+ geom_bar(stat="identity", position="dodge") +
+ theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
+ ggtitle("Output from fx_PAS") +
+ xlab("Variables") +
+ ylab("Values")
results_dfchaos$dataset <- ifelse(grepl("^stcca_", results_dfchaos$Combinations), "stcca",
+ ifelse(grepl("^pca_", results_dfchaos$Combinations), "pca",
+ ifelse(grepl("^spaceflow", results_dfchaos$Combinations), "spaceflow",
+ ifelse(grepl("^stLearn", results_dfchaos$Combinations), "stLearn",
+ ifelse(grepl("^thruth", results_dfchaos$Combinations), "thruth", "Other")))))
+
+head(results_dfchaos)
+
+
+
+
+
+results_dfchaos_filtered <- results_dfchaos[results_dfchaos$dataset != "thruth", ]
+
+ggplot(results_dfchaos_filtered, aes(x = Combinations, y = results)) +
+ geom_bar(stat = "identity", position = "dodge") +
+ theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
+ ggtitle("Output from fx_CHAOS") +
+ xlab("Variables") +
+ ylab("Values") +
+ facet_wrap(~ dataset, scales = "free_x")
+
+results_dfpas$dataset <- ifelse(grepl("^stcca_", results_dfpas$Var1), "stcca",
+ ifelse(grepl("^pca_", results_dfpas$Var1), "pca",
+ ifelse(grepl("^spaceflow", results_dfpas$Var1), "spaceflow",
+ ifelse(grepl("^stLearn", results_dfpas$Var1), "stLearn",
+ ifelse(grepl("^thruth", results_dfpas$Var1), "thruth", "Other")))))
+
+# Filter out the 'thruth' rows
+results_dfpas_filtered <- results_dfpas[results_dfpas$dataset != "thruth", ]
+
+# Create a bar plot with ggplot2, with facet_wrap based on the 'dataset' column
+ggplot(results_dfpas_filtered, aes(x = Var1, y = Freq)) +
+ geom_bar(stat = "identity", position = "dodge") +
+ theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
+ ggtitle("Output from fx_PAS") +
+ xlab("Variables") +
+ ylab("Values") +
+ facet_wrap(~ dataset, scales = "free_x")
+
+
+CHAOS boxplot
+ + + +
+
+
+ p = ggplot(results_dfchaos_filtered, aes(x = reorder(dataset, -results, FUN = mean), y = results, fill = dataset)) +
+ geom_boxplot(outlier.shape = NA, width = 0.35) +
+ geom_jitter(width = 0.1) +
+ theme_bw() +
+ theme(
+ legend.position = "none",
+ axis.line = element_line(),
+ plot.background = element_blank(),
+ panel.grid.major = element_blank(),
+ panel.grid.minor = element_blank(),
+ panel.border = element_blank(),
+ axis.text.x = element_text(size = 15, face = "bold", colour = "black"),
+ axis.text.y = element_text(size = 14, colour = "black"),
+ axis.title.y = element_text(size = 15, face = "bold")
+ ) +
+ scale_fill_manual(values = c("cornsilk1", "cornsilk2", "cornsilk3", "cornsilk4")) +
+ # scale_x_discrete(name = "", expand = c(0.5, 0)) +
+ # scale_y_continuous(limits = c(0, 0.3), breaks = seq(0, 0.3, by = 0.1)) +
+ ylab("CHAOS Score") +
+ labs(title = "CHAOS DLFCP")+
+ xlab('')
+
+p
+
+PAS boxplot
+ + + +
# Save to a specific directory
+saveRDS(results_dfpas_filtered, "results_dfpas_filtered.rds")
+results_dfpas_filtered = readRDS("results_dfpas_filtered.rds")
+
+
+Psoriasis dataset
+ + + +coor_pp12 = readRDS('C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\Psoriasis_Coordinate_2023-07-14.RDS')
+
+cluster_pp12=readRDS('C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\stCCA_psoriasis_cluster_label_0.35best.rds')
+
+all_pp12 = cbind(coor_pp12,cluster_pp12)
+cols_to_apply <- setdiff(names(all_pp12), c('V5', 'V6'))
+
+results_dfpas <- data.frame()
+
+results <- sapply(cols_to_apply, function(col) {
+ fx_PAS(all_pp12[[col]], location = all_pp12[, c('V5', 'V6')])
+})
+
+results_dfpas <- as.data.frame(as.table(results))results_dfpas
+
+
+
+
+
+results_dfpas %>%
+ ggplot(aes(x = Var1, y = Freq)) +
+ geom_point() + ylab('PAS score') + xlab('Resolutions')
cols_to_apply <- setdiff(names(all_pp12), c('V5', 'V6'))
+
+results_dfpas <- data.frame()
+
+results <- sapply(cols_to_apply, function(col) {
+ fx_CHAOS(all_pp12[[col]], location = all_pp12[, c('V5', 'V6')])
+})
+
+results_dfpas <- as.data.frame(as.table(results))results_dfpas
+
+
+
+
+
+results_dfpas %>%
+ ggplot(aes(x = Var1, y = Freq)) +
+ geom_point() + ylab('CHAOS score') + xlab('Resolutions')
---
title: "Measure the continuity and smooth of our clustering performance in the spatial domain using PAS and CHAOS"
output: html_notebook
---

DLFCP and psoriasis dataset


PAS: Percentage of abnormal spots


CHAOS: spatial chaos score

```{r}
library(tidyverse)
library(parallel)


#mac 
fx_CHAOS = function(clusterlabel, location){
  # require(parallel)
  matched_location=location
  NAs = which(is.na(clusterlabel))
  if(length(NAs>0)){
    clusterlabel=clusterlabel[-NAs]
    matched_location = matched_location[-NAs,]
  }
  matched_location = scale(matched_location)
  dist_val = rep(0,length(unique(clusterlabel)))
  count = 0
  for(k in unique(clusterlabel)){
    count = count + 1
    location_cluster = matched_location[which(clusterlabel == k),]
    if(length(location_cluster)==2){next}
    #require(parallel)
    results = mclapply(1:dim(location_cluster)[1], fx_1NN, location_in=location_cluster,mc.cores = 5) #This is the MC part
    dist_val[count] = sum(unlist(results))
  }
  dist_val = na.omit(dist_val)
  return(sum(dist_val)/length(clusterlabel))

}


#windows
fx_PAS = function(clusterlabel, location){
  # require(parallel)

  matched_location=location
  NAs = which(is.na(clusterlabel))
  if(length(NAs>0)){
    clusterlabel=clusterlabel[-NAs]
    matched_location = matched_location[-NAs,]
  }

  results = mclapply(1:dim(matched_location)[1], fx_kNN, location_in=matched_location,k=10,cluster_in=clusterlabel, mc.cores = 5)
  return(sum(unlist(results))/length(clusterlabel))
}


#mac
fx_PAS = function(clusterlabel, location) {
  
  plan(multisession, workers = 3)  # sets the plan to use 5 cores for parallel processing
  
  matched_location = location
  NAs = which(is.na(clusterlabel))
  if (length(NAs) > 0) {
    clusterlabel = clusterlabel[-NAs]
    matched_location = matched_location[-NAs, ]
  }
  
  results = future_lapply(1:dim(matched_location)[1], fx_kNN, 
                          location_in = matched_location, 
                          k = 10, 
                          cluster_in = clusterlabel)
  
  return(sum(unlist(results)) / length(clusterlabel))
}


library(future)
library(future.apply)


#windows
fx_CHAOS = function(clusterlabel, location){
  # Set future plan to use 3 cores
  plan(multisession, workers = 3)
  
  matched_location = location
  NAs = which(is.na(clusterlabel))
  
  if(length(NAs) > 0){
    clusterlabel = clusterlabel[-NAs]
    matched_location = matched_location[-NAs,]
  }
  
  matched_location = scale(matched_location)
  dist_val = rep(0, length(unique(clusterlabel)))
  count = 0
  
  for(k in unique(clusterlabel)){
    count = count + 1
    location_cluster = matched_location[which(clusterlabel == k),]
    
    if(nrow(location_cluster) <= 2){next}
    
    # Use future_lapply for parallelization
    results = future_lapply(1:nrow(location_cluster), fx_1NN, location_in = location_cluster)
    
    dist_val[count] = sum(unlist(results))
  }
  
  dist_val = na.omit(dist_val)
  
  return(sum(dist_val) / length(clusterlabel))
}



library(pdist)

fx_1NN = function(i,location_in){
  # library(pdist)
  line_i = rep(0,dim(location_in)[1])
  line_i = pdist(location_in[i,],location_in[-i,])@dist
  return(min(line_i))
}


fx_kNN = function(i,location_in,k,cluster_in){
  #library(pdist)
  line_i = rep(0,dim(location_in)[1])
  line_i = pdist(location_in[i,],location_in[-i,])@dist
  ind = order(line_i)[1:k]
  cluster_use = cluster_in[-i]
  if(sum(cluster_use[ind] != cluster_in[i])>(k/2)){
    return(1)
  }else{
    return(0)
  }

}
```


## Clusters loading

```{r}
location = read_csv('C:\\Users\\Juan\\Desktop\\temp_data\\151673\\spatial\\tissue_positions_list.csv')
location2 = readRDS('C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\DLPFC_spatial_3639cells_2cols.rds')
dim(location2)
dim(location)

rownames(location) = location$...1

GT = read_csv('C:\\Users\\Juan\\Desktop\\temp_data\\151673\\cluster_labels_151673.csv')
stcca_c = readRDS('C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\stCCA_DLPFC_benchmark_clusters.rds')
pca = readRDS('C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\PCA_DLPFC_benchmark_clusters.rds')

# Get common row names
common_rows <- intersect(rownames(location), rownames(location2))

# Filter location2
location2_filtered <- location2[common_rows, ]

# Optionally, also filter location
location_filtered <- location[common_rows, ]

location2$thruth = GT$ground_truth
```


```{r}
location2 %>% ggplot()+
  geom_point(aes(x= imagecol ,y = imagerow ,color =thruth ))
```


```{r}
# ground thruth
fx_CHAOS(location2$thruth, location = location2[,c('imagecol','imagerow')])

```

```{r}
#stcca
# Iterate from 6 to 20, incrementing by 2 each time
for (i in seq(6, 20, by=2)) {
  # Generate the name of the source column in stcca_c
  source_colname <- paste("stCCA CC dimension =", i)
  
  # Generate the name of the new column to be created in location2
  new_colname <- paste("stcca_", i, sep="")
  
  # Assign the new column in location2 using values from stcca_c
  location2[[new_colname]] <- stcca_c[[source_colname]]
}

#pca
for (i in seq(6, 20, by=2)) {
  # Generate the name of the source column in pca
  source_colname <- paste0("PCA dimension=", i)
  
  # Generate the name of the new column to be created in location2
  new_colname <- paste("pca_", i, sep="")
  
  # Assign the new column in location2 using values from pca
  location2[[new_colname]] <- pca[[source_colname]]
}

#spaceflow
for(i in seq(10, 30, by=5)) {
  file_path <- paste0("C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\", i, "_res_0.3_domains.tsv")
  # Read the TSV file into a data frame
  spaceflow <- read.delim(file_path, header=TRUE, sep="\t")
  # Add a new column to location2 using the label column from the read TSV
  location2[[paste0("spaceflow", i)]] <- spaceflow$label
}

#stlearn

for(i in seq(6, 20, by=2)) {
  file_path <- paste0("C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\151673_", i, "comps_calc_cluster.csv")
  # Read the CSV file into a data frame
  comps_calc_cluster <- read.csv(file_path, header=TRUE)
  # Add a new column to location2 using the label column from the read CSV
  location2[[paste0("stLearn", i)]] <- comps_calc_cluster$X_pca_kmeans
}

```


## CHAOS DLFPC 

```{r}
cols_to_apply <- setdiff(names(location2), c('imagecol', 'imagerow'))

results_dfchaos <- data.frame()

results <- sapply(cols_to_apply, function(col) {
  fx_CHAOS(location2[[col]], location = location2[, c('imagecol', 'imagerow')])
})

results_dfchaos <- as.data.frame(results)
```

```{r}
results_dfchaos$Combinations = rownames(results_dfchaos)
results_dfchaos
```

CHAOS stat

The lower, the less the chaos

```{r}
ggplot(results_dfchaos, aes(x=Combinations, y=results)) +
  geom_bar(stat="identity", position="dodge") +
  theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
  ggtitle("Output from fx_CHAOS") +
  xlab("Variables") +
  ylab("Values")
```





## PAS DLFPC

```{r}
cols_to_apply <- setdiff(names(location2), c('imagecol', 'imagerow'))

results_dfpas <- data.frame()

results <- sapply(cols_to_apply, function(col) {
  fx_PAS(location2[[col]], location = location2[, c('imagecol', 'imagerow')])
})

results_dfpas <- as.data.frame(as.table(results))
```

```{r}
results_dfpas
```

```{r}
ggplot(results_dfpas, aes(x=Var1, y=Freq)) +
  geom_bar(stat="identity", position="dodge") +
  theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
  ggtitle("Output from fx_PAS") +
  xlab("Variables") +
  ylab("Values")
```





```{r}
results_dfchaos$dataset <- ifelse(grepl("^stcca_", results_dfchaos$Combinations), "stcca",
                           ifelse(grepl("^pca_", results_dfchaos$Combinations), "pca",
                           ifelse(grepl("^spaceflow", results_dfchaos$Combinations), "spaceflow",
                           ifelse(grepl("^stLearn", results_dfchaos$Combinations), "stLearn",
                           ifelse(grepl("^thruth", results_dfchaos$Combinations), "thruth", "Other")))))

head(results_dfchaos)

results_dfchaos_filtered <- results_dfchaos[results_dfchaos$dataset != "thruth", ]

ggplot(results_dfchaos_filtered, aes(x = Combinations, y = results)) +
  geom_bar(stat = "identity", position = "dodge") +
  theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
  ggtitle("Output from fx_CHAOS") +
  xlab("Variables") +
  ylab("Values") +
  facet_wrap(~ dataset, scales = "free_x")

```



```{r}

results_dfpas$dataset <- ifelse(grepl("^stcca_", results_dfpas$Var1), "stcca",
                                ifelse(grepl("^pca_", results_dfpas$Var1), "pca",
                                ifelse(grepl("^spaceflow", results_dfpas$Var1), "spaceflow",
                                ifelse(grepl("^stLearn", results_dfpas$Var1), "stLearn",
                                ifelse(grepl("^thruth", results_dfpas$Var1), "thruth", "Other")))))

# Filter out the 'thruth' rows
results_dfpas_filtered <- results_dfpas[results_dfpas$dataset != "thruth", ]

# Create a bar plot with ggplot2, with facet_wrap based on the 'dataset' column
ggplot(results_dfpas_filtered, aes(x = Var1, y = Freq)) + 
  geom_bar(stat = "identity", position = "dodge") +
  theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
  ggtitle("Output from fx_PAS") +
  xlab("Variables") +
  ylab("Values") +
  facet_wrap(~ dataset, scales = "free_x")

```

## CHAOS boxplot

```{r}



 p = ggplot(results_dfchaos_filtered, aes(x = reorder(dataset, -results, FUN = mean), y = results, fill = dataset)) +
  geom_boxplot(outlier.shape = NA, width = 0.35) +
  geom_jitter(width = 0.1) +
  theme_bw() +
  theme(
    legend.position = "none",
    axis.line = element_line(),
    plot.background = element_blank(),
    panel.grid.major = element_blank(),
    panel.grid.minor = element_blank(),
    panel.border = element_blank(),
    axis.text.x = element_text(size = 15, face = "bold", colour = "black"),
    axis.text.y = element_text(size = 14, colour = "black"),
    axis.title.y = element_text(size = 15, face = "bold")
  ) +
  scale_fill_manual(values = c("cornsilk1", "cornsilk2", "cornsilk3", "cornsilk4")) +
 # scale_x_discrete(name = "", expand = c(0.5, 0)) +
 # scale_y_continuous(limits = c(0, 0.3), breaks = seq(0, 0.3, by = 0.1)) + 
  ylab("CHAOS Score") +
  labs(title = "CHAOS DLFCP")+
  xlab('')

p
```



## PAS boxplot

```{r}

n_categories <- length(unique(results_dfpas_filtered$Var1))


cornsilk_shades <- colorRampPalette(c("cornsilk4", "cornsilk1"))(n_categories)


 p = ggplot(results_dfpas_filtered, aes(x = reorder(dataset, -Freq, FUN = mean), y = Freq, fill = dataset)) +
  geom_boxplot(outlier.shape = NA, width = 0.35) +
  geom_jitter(width = 0.1) +
  theme_bw() +
  theme(
    legend.position = "none",
    axis.line = element_line(),
    plot.background = element_blank(),
    panel.grid.major = element_blank(),
    panel.grid.minor = element_blank(),
    panel.border = element_blank(),
    axis.text.x = element_text(size = 15, face = "bold", colour = "black"),
    axis.text.y = element_text(size = 14, colour = "black"),
    axis.title.y = element_text(size = 15, face = "bold")
  ) +
  scale_fill_manual(values = c("cornsilk1", "cornsilk2", "cornsilk3", "cornsilk4")) +
  scale_x_discrete(name = "", expand = c(0.5, 0)) +
  scale_y_continuous(limits = c(0, 0.3), breaks = seq(0, 0.3, by = 0.1)) + 
  ylab("PAS Score") +
  labs(title = "PAS")

p
setwd('C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc')
ggsave("PAS_score_datasets_9-5-2023.pdf", plot = p, width = 11, height = 10)
```


```{r}
# Save to a specific directory
saveRDS(results_dfpas_filtered, "results_dfpas_filtered.rds")
results_dfpas_filtered = readRDS("results_dfpas_filtered.rds")
```


## Psoriasis dataset

```{r}
coor_pp12 = readRDS('C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\Psoriasis_Coordinate_2023-07-14.RDS')

cluster_pp12=readRDS('C:\\Users\\Juan\\Desktop\\all_clusters_dlfpc\\stCCA_psoriasis_cluster_label_0.35best.rds')

all_pp12 = cbind(coor_pp12,cluster_pp12)

```

```{r}
cols_to_apply <- setdiff(names(all_pp12), c('V5', 'V6'))

results_dfpas <- data.frame()

results <- sapply(cols_to_apply, function(col) {
  fx_PAS(all_pp12[[col]], location = all_pp12[, c('V5', 'V6')])
})

results_dfpas <- as.data.frame(as.table(results))
```


```{r}
results_dfpas

results_dfpas %>%
  ggplot(aes(x = Var1, y = Freq)) +
    geom_point() + ylab('PAS score') + xlab('Resolutions')
```

```{r}
cols_to_apply <- setdiff(names(all_pp12), c('V5', 'V6'))

results_dfpas <- data.frame()

results <- sapply(cols_to_apply, function(col) {
  fx_CHAOS(all_pp12[[col]], location = all_pp12[, c('V5', 'V6')])
})

results_dfpas <- as.data.frame(as.table(results))
```

```{r}
results_dfpas

results_dfpas %>%
  ggplot(aes(x = Var1, y = Freq)) +
    geom_point() + ylab('CHAOS score') + xlab('Resolutions')
```


```{r}
ggplot(results_dfpas, aes(x = Var1, y = Freq)) + 
  geom_bar(stat = "identity", position = "dodge") +
  theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
  ggtitle("Output from fx_PAS") +
  xlab("Variables") +
  ylab("Values") +
 # facet_wrap(~ dataset, scales = "free_x")
```


+
+
+
+