From 0cedb627549b2cf13ca74aa27cb4878c9551f8e7 Mon Sep 17 00:00:00 2001
From: Aaron Holmes <aholmes@mednet.ucla.edu>
Date: Wed, 5 Mar 2025 16:36:30 -0800
Subject: [PATCH 01/14] Add methods for generating colors for clone IDs.

This is used here, for example.
https://github.com/uclahs-cds/project-CancerEvolutionVisualization-web/blob/aholmes-add-additional-cev-methods/R/create.clone.genome.distribution.plot.R#L7-L13
---
 R/utility.R | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/R/utility.R b/R/utility.R
index e780345..1218644 100644
--- a/R/utility.R
+++ b/R/utility.R
@@ -62,3 +62,70 @@ get.encoded.distance <- function(points) {
 
     return(encoded.distances);
     }
+
+#' Generate a named vector of colors for every clone ID specified.
+#'
+#' Assigns colors to clones, ensuring a minimum number of colors are used.
+#' Any colors specified in `clone.colours` are maintained in the order
+#' specified and are used as the first colors for the `clone.ids`.
+#'
+#' @param clone.colours A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.
+#' @param clone.ids A vector of clone identifiers.
+#' @param minimum.number.of.colours An integer specifying the minimum number of colors required.
+#'
+#' @return A named vector of colors assigned to each clone.
+get.clone.colours <- function(clone.colours, clone.ids, minimum.number.of.colours = 0) {
+    if (is.null(clone.colours) && minimum.number.of.colours == 0) {
+        return(NULL);
+        }
+
+    if (length(clone.colours) < minimum.number.of.colours) {
+        clone.colours <- c(
+            clone.colours,
+            sample(
+                colors(),
+                size = abs(minimum.number.of.colours - length(clone.colours))
+                )
+            );
+        }
+
+    if (!is.null(clone.colours)) {
+        unique.clone.ids <- unique(clone.ids);
+        sampled.colors <- sample(colors(), size = length(unique.clone.ids));
+        sampled.colors[seq_along(clone.colours)] <- clone.colours;
+        return(setNames(
+            sampled.colors[seq_along(unique.clone.ids)],
+            unique.clone.ids
+            ));
+        }
+
+    return(NULL);
+    }
+
+#' Generate a named vector of colors for every clone ID specified,
+#' ordered by the clone IDs in `clone.order`.
+#'
+#' Assigns colors to clones and ensures they follow a specified order.
+#' Any colors specified in `clone.colours` are maintained in the order
+#' specified and are used as the first colors for the `clone.ids`.
+#'
+#' @param clone.colours A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.
+#' @param clone.ids A vector of clone identifiers.
+#' @param clone.order An optional vector specifying the order of clones. If `NULL`, clone order is not gauranteed.
+#' @param minimum.number.of.colours An integer specifying the minimum number of colors required.
+#'
+#' @return A list containing:
+#' \describe{
+#'   \item{clone.colours}{A named vector of colors assigned to each clone.}
+#'   \item{clone.order}{The ordered clones.}
+#' }
+get.clone.colours.in.order <- function(clone.colours, clone.ids, clone.order = NULL, minimum.number.of.colours = 0) {
+    if (is.null(clone.order)) {
+        unique.clone.ids <- unique(clone.ids);
+        clone.order <- c(clone.order, unique.clone.ids[!unique.clone.ids %in% clone.order]);
+        }
+
+    clone.colours <- get.clone.colours(clone.colours, clone.order, minimum.number.of.colours);
+
+    return(list(clone.colours = clone.colours, clone.order = clone.order));
+    }

From 438447ae719e00b6e5378fdf2feddff75ae89815 Mon Sep 17 00:00:00 2001
From: Aaron Holmes <aholmes@mednet.ucla.edu>
Date: Thu, 6 Mar 2025 11:33:21 -0800
Subject: [PATCH 02/14] Correct errors in clone color methods. Add tests.

---
 DESCRIPTION                       |   1 +
 R/utility.R                       |  18 +++-
 man/get.clone.colours.Rd          |  29 ++++++
 man/get.clone.colours.in.order.Rd |  41 ++++++++
 tests/testthat/test-utility.R     | 159 ++++++++++++++++++++++++++++++
 5 files changed, 246 insertions(+), 2 deletions(-)
 create mode 100644 man/get.clone.colours.Rd
 create mode 100644 man/get.clone.colours.in.order.Rd

diff --git a/DESCRIPTION b/DESCRIPTION
index ab9d683..552bb03 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -28,3 +28,4 @@ Suggests:
 VignetteBuilder: knitr
 LazyLoad: yes
 LazyData: yes
+RoxygenNote: 7.3.1
diff --git a/R/utility.R b/R/utility.R
index 1218644..c0f4c70 100644
--- a/R/utility.R
+++ b/R/utility.R
@@ -69,6 +69,11 @@ get.encoded.distance <- function(points) {
 #' Any colors specified in `clone.colours` are maintained in the order
 #' specified and are used as the first colors for the `clone.ids`.
 #'
+#' if `clone.colours` is NULL or an empty vector, _and_
+#' `minimum.number.of.colours` is 0, `NULL` is returned
+#' so BPG's default color selection can be used without needing to
+#' check for `NULL`.
+#'
 #' @param clone.colours A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.
 #' @param clone.ids A vector of clone identifiers.
 #' @param minimum.number.of.colours An integer specifying the minimum number of colors required.
@@ -89,7 +94,7 @@ get.clone.colours <- function(clone.colours, clone.ids, minimum.number.of.colour
             );
         }
 
-    if (!is.null(clone.colours)) {
+    if (!is.null(clone.colours) && !is.null(clone.ids)) {
         unique.clone.ids <- unique(clone.ids);
         sampled.colors <- sample(colors(), size = length(unique.clone.ids));
         sampled.colors[seq_along(clone.colours)] <- clone.colours;
@@ -109,6 +114,11 @@ get.clone.colours <- function(clone.colours, clone.ids, minimum.number.of.colour
 #' Any colors specified in `clone.colours` are maintained in the order
 #' specified and are used as the first colors for the `clone.ids`.
 #'
+#' if `clone.colours` is NULL or an empty vector, _and_
+#' `minimum.number.of.colours` is 0, `NULL` is returned
+#' so BPG's default color selection can be used without needing to
+#' check for `NULL`.
+#'
 #' @param clone.colours A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.
 #' @param clone.ids A vector of clone identifiers.
 #' @param clone.order An optional vector specifying the order of clones. If `NULL`, clone order is not gauranteed.
@@ -120,7 +130,11 @@ get.clone.colours <- function(clone.colours, clone.ids, minimum.number.of.colour
 #'   \item{clone.order}{The ordered clones.}
 #' }
 get.clone.colours.in.order <- function(clone.colours, clone.ids, clone.order = NULL, minimum.number.of.colours = 0) {
-    if (is.null(clone.order)) {
+    if (is.null(clone.colours) && is.null(clone.order)) {
+        clone.ids <- NULL;
+        }
+
+    if (is.null(clone.order) && !is.null(clone.ids)) {
         unique.clone.ids <- unique(clone.ids);
         clone.order <- c(clone.order, unique.clone.ids[!unique.clone.ids %in% clone.order]);
         }
diff --git a/man/get.clone.colours.Rd b/man/get.clone.colours.Rd
new file mode 100644
index 0000000..ab6e9c5
--- /dev/null
+++ b/man/get.clone.colours.Rd
@@ -0,0 +1,29 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/utility.R
+\name{get.clone.colours}
+\alias{get.clone.colours}
+\title{Generate a named vector of colors for every clone ID specified.}
+\usage{
+get.clone.colours(clone.colours, clone.ids, minimum.number.of.colours = 0)
+}
+\arguments{
+\item{clone.colours}{A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.}
+
+\item{clone.ids}{A vector of clone identifiers.}
+
+\item{minimum.number.of.colours}{An integer specifying the minimum number of colors required.}
+}
+\value{
+A named vector of colors assigned to each clone.
+}
+\description{
+Assigns colors to clones, ensuring a minimum number of colors are used.
+Any colors specified in `clone.colours` are maintained in the order
+specified and are used as the first colors for the `clone.ids`.
+}
+\details{
+if `clone.colours` is NULL or an empty vector, _and_
+`minimum.number.of.colours` is 0, `NULL` is returned
+so BPG's default color selection can be used without needing to
+check for `NULL`.
+}
diff --git a/man/get.clone.colours.in.order.Rd b/man/get.clone.colours.in.order.Rd
new file mode 100644
index 0000000..2d767c5
--- /dev/null
+++ b/man/get.clone.colours.in.order.Rd
@@ -0,0 +1,41 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/utility.R
+\name{get.clone.colours.in.order}
+\alias{get.clone.colours.in.order}
+\title{Generate a named vector of colors for every clone ID specified,
+ordered by the clone IDs in `clone.order`.}
+\usage{
+get.clone.colours.in.order(
+  clone.colours,
+  clone.ids,
+  clone.order = NULL,
+  minimum.number.of.colours = 0
+)
+}
+\arguments{
+\item{clone.colours}{A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.}
+
+\item{clone.ids}{A vector of clone identifiers.}
+
+\item{clone.order}{An optional vector specifying the order of clones. If `NULL`, clone order is not gauranteed.}
+
+\item{minimum.number.of.colours}{An integer specifying the minimum number of colors required.}
+}
+\value{
+A list containing:
+\describe{
+  \item{clone.colours}{A named vector of colors assigned to each clone.}
+  \item{clone.order}{The ordered clones.}
+}
+}
+\description{
+Assigns colors to clones and ensures they follow a specified order.
+Any colors specified in `clone.colours` are maintained in the order
+specified and are used as the first colors for the `clone.ids`.
+}
+\details{
+if `clone.colours` is NULL or an empty vector, _and_
+`minimum.number.of.colours` is 0, `NULL` is returned
+so BPG's default color selection can be used without needing to
+check for `NULL`.
+}
diff --git a/tests/testthat/test-utility.R b/tests/testthat/test-utility.R
index aeb18c7..5ad8898 100644
--- a/tests/testthat/test-utility.R
+++ b/tests/testthat/test-utility.R
@@ -76,3 +76,162 @@ test_that(
 
         expect_equal(order(result), expected.order);
     });
+
+test_that(
+    'get.clone.colours returns expected vectors', {
+        result <- get.clone.colours(NULL, NULL);
+        expect_null(result);
+        result <- get.clone.colours(NULL, c('ABC', 'DEF'));
+        expect_null(result);
+        result <- get.clone.colours(c('red','green'), NULL);
+        expect_null(result);
+        result <- get.clone.colours(c(), c());
+        expect_null(result);
+        result <- get.clone.colours(NULL, c());
+        expect_null(result);
+        result <- get.clone.colours(c(), NULL);
+        expect_null(result);
+        result <- get.clone.colours(c(), c('ABC', 'DEF'));
+        expect_null(result);
+        result <- get.clone.colours(c('red', 'green'), c());
+        expect_null(result);
+        result <- get.clone.colours(c('red','green'), c('ABC','DEF'));
+        expect_equal(result, c(ABC = 'red', DEF = 'green'));
+        result <- get.clone.colours(c('red'), c('ABC','DEF'));
+        expect_equal(names(result), c('ABC', 'DEF'));
+        expect_true(result['ABC'] == 'red');
+        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
+        result <- get.clone.colours(c(NULL,'red'), c('ABC','DEF'));
+        expect_equal(names(result), c('ABC', 'DEF'));
+        expect_true(result['ABC'] == 'red');
+        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
+        result <- get.clone.colours(c('red',NULL), c('ABC','DEF'));
+        expect_equal(names(result), c('ABC', 'DEF'));
+        expect_true(result['ABC'] == 'red');
+        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
+        result <- get.clone.colours(c('red','green'), c('ABC'));
+        expect_equal(result, c(ABC = 'red'));
+        result <- get.clone.colours(c('red','green'), c(NULL,'ABC'));
+        expect_equal(result, c(ABC = 'red'));
+        result <- get.clone.colours(c('red','green'), c('ABC',NULL));
+        expect_equal(result, c(ABC = 'red'));
+    });
+
+test_that(
+    'get.clone.colours returns expected vectors with minimum colours specified', {
+        result <- get.clone.colours(NULL, NULL, 3)
+        expect_null(result);
+        result <- get.clone.colours(c('red', 'green'), NULL, 3)
+        expect_null(result);
+        result <- get.clone.colours(c('red'), NULL, 3)
+        expect_null(result);
+        result <- get.clone.colours(c('red', 'green'), c('ABC','DEF'), 3)
+        expect_equal(result, c(ABC = 'red', DEF = 'green'));
+        result <- get.clone.colours(c('red'), c('ABC','DEF'), 3)
+        expect_equal(names(result), c('ABC', 'DEF'));
+        expect_true(result['ABC'] == 'red');
+        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
+        result <- get.clone.colours(c('red', 'green'), c('ABC'), 3)
+        expect_equal(result, c(ABC = 'red'));
+    });
+
+test_that(
+    'get.clone.colours.in.order returns expected vectors when order is not specified', {
+        # get.clone.colours.in.order has same result as get.clone.colours
+        # with the change that a named list is returned with two members
+        result <- get.clone.colours.in.order(NULL, NULL)
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
+        result <- get.clone.colours.in.order(NULL, c('ABC', 'DEF'))
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
+        result <- get.clone.colours.in.order(c('red','green'), NULL)
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
+        result <- get.clone.colours.in.order(c(), c())
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
+        result <- get.clone.colours.in.order(NULL, c())
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
+        result <- get.clone.colours.in.order(c(), NULL)
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
+        result <- get.clone.colours.in.order(c(), c('ABC', 'DEF'))
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
+        result <- get.clone.colours.in.order(c('red', 'green'), c())
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
+        result <- get.clone.colours.in.order(c('red','green'), c('ABC','DEF'))
+        expect_true(setequal(result,list(clone.colours = c(ABC = 'red',DEF = 'green'), clone.order = c('ABC','DEF'))))
+        result <- get.clone.colours.in.order(c('red'), c('ABC','DEF'))
+        expect_equal(names(result), c('clone.colours', 'clone.order'))
+        expect_equal(names(result$clone.colours), c('ABC', 'DEF'))
+        expect_true(result$clone.colours['ABC'] == 'red')
+        expect_true(!is.na(result$clone.colours['DEF']) && nzchar(result$clone.colours['DEF']))
+        expect_equal(result$clone.order, c('ABC','DEF'))
+
+        result <- get.clone.colours.in.order(c(NULL,'red'), c('ABC','DEF'))
+        expect_equal(names(result), c('clone.colours', 'clone.order'))
+        expect_equal(names(result$clone.colours), c('ABC','DEF'))
+        expect_true(result$clone.colours['ABC'] == 'red')
+        expect_true(!is.na(result$clone.colours['DEF']) && nzchar(result$clone.colours['DEF']))
+        expect_equal(result$clone.order, c('ABC','DEF'))
+
+        result <- get.clone.colours.in.order(c('red',NULL), c('ABC','DEF'))
+        expect_equal(names(result), c('clone.colours', 'clone.order'))
+        expect_equal(names(result$clone.colours), c('ABC','DEF'))
+        expect_true(result$clone.colours['ABC'] == 'red')
+        expect_true(!is.na(result$clone.colours['DEF']) && nzchar(result$clone.colours['DEF']))
+        expect_equal(result$clone.order, c('ABC','DEF'))
+
+        result <- get.clone.colours.in.order(c('red','green'), c('ABC'))
+        expect_true(setequal(result,list(clone.colours = c(ABC = 'red'), clone.order = c('ABC'))))
+        result <- get.clone.colours.in.order(c('red','green'), c(NULL,'ABC'))
+        expect_true(setequal(result,list(clone.colours = c(ABC = 'red'), clone.order = c('ABC'))))
+        result <- get.clone.colours.in.order(c('red','green'), c('ABC',NULL))
+        expect_true(setequal(result,list(clone.colours = c(ABC = 'red'), clone.order = c('ABC'))))
+    });
+
+test_that(
+    'get.clone.colours.in.order returns expected vectors when order is specified', {
+        # get.clone.colours.in.order with order specified
+        result <- get.clone.colours.in.order(NULL, NULL, c('DEF','ABC'))
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = c('DEF','ABC'))))
+        result <- get.clone.colours.in.order(NULL, c('ABC', 'DEF'), c('DEF','ABC'))
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = c('DEF','ABC'))))
+        result <- get.clone.colours.in.order(c('red','green'), NULL)
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
+        result <- get.clone.colours.in.order(c(), c(), c('DEF','ABC'))
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = c('DEF','ABC'))))
+        result <- get.clone.colours.in.order(NULL, c(), c('DEF','ABC'))
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = c('DEF','ABC'))))
+        result <- get.clone.colours.in.order(c(), NULL, c('DEF','ABC'))
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = c('DEF','ABC'))))
+        result <- get.clone.colours.in.order(c(), c('ABC', 'DEF'), c('DEF','ABC'))
+        expect_true(setequal(result, list(clone.colours = NULL, clone.order = c('DEF','ABC'))))
+        result <- get.clone.colours.in.order(c('red', 'green'), c(), c('DEF','ABC'))
+        expect_true(setequal(result, list(clone.colours = c(DEF = 'red',ABC = 'green'), clone.order = c('DEF','ABC'))))
+        result <- get.clone.colours.in.order(c('red','green'), c('ABC','DEF'), c('DEF','ABC'))
+        expect_true(setequal(result,list(clone.colours = c(DEF = 'red',ABC = 'green'), clone.order = c('DEF','ABC'))))
+        result <- get.clone.colours.in.order(c('red'), c('ABC','DEF'), c('DEF','ABC'))
+        expect_equal(names(result), c('clone.colours', 'clone.order'))
+        expect_equal(names(result$clone.colours), c('DEF', 'ABC'))
+        expect_true(result$clone.colours['DEF'] == 'red')
+        expect_true(!is.na(result$clone.colours['ABC']) && nzchar(result$clone.colours['ABC']))
+        expect_equal(result$clone.order, c('DEF','ABC'))
+
+        result <- get.clone.colours.in.order(c(NULL,'red'), c('ABC','DEF'), c('DEF','ABC'))
+        expect_equal(names(result), c('clone.colours', 'clone.order'))
+        expect_equal(names(result$clone.colours), c('DEF','ABC'))
+        expect_true(result$clone.colours['DEF'] == 'red')
+        expect_true(!is.na(result$clone.colours['ABC']) && nzchar(result$clone.colours['ABC']))
+        expect_equal(result$clone.order, c('DEF','ABC'))
+
+        result <- get.clone.colours.in.order(c('red',NULL), c('ABC','DEF'), c('DEF','ABC'))
+        expect_equal(names(result), c('clone.colours', 'clone.order'))
+        expect_equal(names(result$clone.colours), c('DEF','ABC'))
+        expect_true(result$clone.colours['DEF'] == 'red')
+        expect_true(!is.na(result$clone.colours['ABC']) && nzchar(result$clone.colours['ABC']))
+        expect_equal(result$clone.order, c('DEF','ABC'))
+
+        result <- get.clone.colours.in.order(c('red','green'), c('ABC'), c('DEF','ABC'))
+        expect_true(setequal(result,list(clone.colours = c(DEF = 'red',ABC = 'green'), clone.order = c('DEF','ABC'))))
+        result <- get.clone.colours.in.order(c('red','green'), c(NULL,'ABC'), c('DEF','ABC'))
+        expect_true(setequal(result,list(clone.colours = c(DEF = 'red',ABC = 'green'), clone.order = c('DEF','ABC'))))
+        result <- get.clone.colours.in.order(c('red','green'), c('ABC',NULL), c('DEF','ABC'))
+        expect_true(setequal(result,list(clone.colours = c(DEF = 'red',ABC = 'green'), clone.order = c('DEF','ABC'))))
+    });

From 1088f5bc0ace054985e41b8a2577030d869ff08d Mon Sep 17 00:00:00 2001
From: Aaron Holmes <aholmes@mednet.ucla.edu>
Date: Wed, 12 Mar 2025 15:52:37 -0700
Subject: [PATCH 03/14] Add tests for `get.colours(...)`

---
 tests/testthat/test-get.colours.R | 56 +++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 tests/testthat/test-get.colours.R

diff --git a/tests/testthat/test-get.colours.R b/tests/testthat/test-get.colours.R
new file mode 100644
index 0000000..a9e39bc
--- /dev/null
+++ b/tests/testthat/test-get.colours.R
@@ -0,0 +1,56 @@
+test_that('get.colours returns a color for each vector element', {
+  value.list <- c('ABC', 'DEF', 'DEF', 'GHI');
+  colors <- get.colours(value.list);
+  expect_equal(names(colors), c('ABC', 'DEF', 'DEF', 'GHI'));
+  expect_equal(length(colors), 4);
+  for (i in seq_along(colors)) {
+    color.value <- colors[i];
+    expect_true(!is.na(color.value) && nzchar(color.value));
+    }
+  });
+
+test_that('get.colours returns a color for each vector element when return.names is FALSE', {
+  value.list <- c('ABC', 'DEF', 'DEF', 'GHI');
+  colors <- get.colours(value.list, FALSE);
+  expect_equal(names(colors), c('ABC', 'DEF', 'DEF', 'GHI'));
+  expect_equal(length(colors), 4);
+  for (i in seq_along(colors)) {
+    color.value <- colors[i];
+    expect_true(!is.na(color.value) && nzchar(color.value));
+    }
+  });
+
+test_that('get.colours returns a color for unique vector elements when return.names is TRUE', {
+  value.list <- c('ABC', 'DEF', 'DEF', 'GHI');
+  colors <- get.colours(value.list, TRUE);
+  expect_equal(names(colors), c('ABC', 'DEF', 'GHI'));
+  expect_equal(length(colors), 3);
+  unique.colors <- unique(names(colors));
+  for (key in unique.colors) {
+    expect_true(!is.na(colors[key]) && nzchar(colors[key]));
+    }
+  });
+
+test_that('get.colours returns an empty color vector when value.list is empty', {
+  value.list <- c();
+  colors <- get.colours(value.list);
+  expect_true(identical(names(colors), character(0)));
+  expect_true(identical(colors, setNames(character(0), character(0))));
+  expect_equal(length(colors), 0);
+  });
+
+test_that('get.colours returns an empty color vector when value.list is empty and return.names is FALSE', {
+  value.list <- c();
+  colors <- get.colours(value.list, FALSE);
+  expect_true(identical(names(colors), character(0)));
+  expect_true(identical(colors, setNames(character(0), character(0))));
+  expect_equal(length(colors), 0);
+  });
+
+test_that('get.colours returns an empty color vector when value.list is empty and return.names is TRUE', {
+  value.list <- c();
+  colors <- get.colours(value.list, TRUE);
+  expect_true(identical(names(colors), character(0)));
+  expect_true(identical(colors, setNames(character(0), character(0))));
+  expect_equal(length(colors), 0);
+  });

From 35b1c9a8081479bfa5928d98e04fcb83ff5705a3 Mon Sep 17 00:00:00 2001
From: whelena <hwinata@mednet.ucla.edu>
Date: Fri, 14 Mar 2025 14:38:04 -0700
Subject: [PATCH 04/14] modified get.clone.colours.in.order to use get.colours

---
 R/utility.R | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/R/utility.R b/R/utility.R
index c0f4c70..304bf1c 100644
--- a/R/utility.R
+++ b/R/utility.R
@@ -135,11 +135,22 @@ get.clone.colours.in.order <- function(clone.colours, clone.ids, clone.order = N
         }
 
     if (is.null(clone.order) && !is.null(clone.ids)) {
-        unique.clone.ids <- unique(clone.ids);
-        clone.order <- c(clone.order, unique.clone.ids[!unique.clone.ids %in% clone.order]);
+        clone.order <- unique(clone.ids);
         }
 
-    clone.colours <- get.clone.colours(clone.colours, clone.order, minimum.number.of.colours);
+    if (is.null(clone.colours) || is.null(clone.order)) {
+        clone.colours <- NULL;
+    } else {
+        sampled.colours <- sample(colors(), size = length(clone.order));
+        sampled.colours[seq_along(clone.colours)] <- clone.colours;
+        clone.colours <- setNames(
+            sampled.colours[seq_along(clone.order)],
+            clone.order
+            );
+        }
 
-    return(list(clone.colours = clone.colours, clone.order = clone.order));
+    return(list(
+        clone.colours = clone.colours,
+        clone.order = clone.order
+        ));
     }

From 2e22ac3b3f8aa5a3bed08b6e3b0f5f8b7bf4715c Mon Sep 17 00:00:00 2001
From: whelena <hwinata@mednet.ucla.edu>
Date: Fri, 14 Mar 2025 14:39:05 -0700
Subject: [PATCH 05/14] remove unused arguments in get.clone.colours.in.order

---
 R/utility.R | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/R/utility.R b/R/utility.R
index 304bf1c..5d3d37a 100644
--- a/R/utility.R
+++ b/R/utility.R
@@ -122,14 +122,18 @@ get.clone.colours <- function(clone.colours, clone.ids, minimum.number.of.colour
 #' @param clone.colours A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.
 #' @param clone.ids A vector of clone identifiers.
 #' @param clone.order An optional vector specifying the order of clones. If `NULL`, clone order is not gauranteed.
-#' @param minimum.number.of.colours An integer specifying the minimum number of colors required.
 #'
 #' @return A list containing:
 #' \describe{
 #'   \item{clone.colours}{A named vector of colors assigned to each clone.}
 #'   \item{clone.order}{The ordered clones.}
 #' }
-get.clone.colours.in.order <- function(clone.colours, clone.ids, clone.order = NULL, minimum.number.of.colours = 0) {
+get.clone.colours.in.order <- function(
+    clone.colours,
+    clone.ids,
+    clone.order = NULL
+    ) {
+
     if (is.null(clone.colours) && is.null(clone.order)) {
         clone.ids <- NULL;
         }

From 87dfe100d1064f06dc3e9a459ec2f89b94edf5d3 Mon Sep 17 00:00:00 2001
From: whelena <hwinata@mednet.ucla.edu>
Date: Fri, 14 Mar 2025 14:39:16 -0700
Subject: [PATCH 06/14] update documentation

---
 man/get.clone.colours.in.order.Rd | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/man/get.clone.colours.in.order.Rd b/man/get.clone.colours.in.order.Rd
index 2d767c5..8c0d017 100644
--- a/man/get.clone.colours.in.order.Rd
+++ b/man/get.clone.colours.in.order.Rd
@@ -5,12 +5,7 @@
 \title{Generate a named vector of colors for every clone ID specified,
 ordered by the clone IDs in `clone.order`.}
 \usage{
-get.clone.colours.in.order(
-  clone.colours,
-  clone.ids,
-  clone.order = NULL,
-  minimum.number.of.colours = 0
-)
+get.clone.colours.in.order(clone.colours, clone.ids, clone.order = NULL)
 }
 \arguments{
 \item{clone.colours}{A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.}
@@ -18,8 +13,6 @@ get.clone.colours.in.order(
 \item{clone.ids}{A vector of clone identifiers.}
 
 \item{clone.order}{An optional vector specifying the order of clones. If `NULL`, clone order is not gauranteed.}
-
-\item{minimum.number.of.colours}{An integer specifying the minimum number of colors required.}
 }
 \value{
 A list containing:

From 79c6446e8a3cd51f62eb2dfd6eb87b01f246e857 Mon Sep 17 00:00:00 2001
From: Aaron Holmes <aholmes@mednet.ucla.edu>
Date: Mon, 17 Mar 2025 09:29:43 -0700
Subject: [PATCH 07/14] Simplify "get.clone.colours" methods.

---
 R/utility.R | 18 ++----------------
 1 file changed, 2 insertions(+), 16 deletions(-)

diff --git a/R/utility.R b/R/utility.R
index 5d3d37a..78370b9 100644
--- a/R/utility.R
+++ b/R/utility.R
@@ -80,23 +80,9 @@ get.encoded.distance <- function(points) {
 #'
 #' @return A named vector of colors assigned to each clone.
 get.clone.colours <- function(clone.colours, clone.ids, minimum.number.of.colours = 0) {
-    if (is.null(clone.colours) && minimum.number.of.colours == 0) {
-        return(NULL);
-        }
-
-    if (length(clone.colours) < minimum.number.of.colours) {
-        clone.colours <- c(
-            clone.colours,
-            sample(
-                colors(),
-                size = abs(minimum.number.of.colours - length(clone.colours))
-                )
-            );
-        }
-
     if (!is.null(clone.colours) && !is.null(clone.ids)) {
         unique.clone.ids <- unique(clone.ids);
-        sampled.colors <- sample(colors(), size = length(unique.clone.ids));
+        sampled.colors <- get.colours(unique.clone.ids);
         sampled.colors[seq_along(clone.colours)] <- clone.colours;
         return(setNames(
             sampled.colors[seq_along(unique.clone.ids)],
@@ -145,7 +131,7 @@ get.clone.colours.in.order <- function(
     if (is.null(clone.colours) || is.null(clone.order)) {
         clone.colours <- NULL;
     } else {
-        sampled.colours <- sample(colors(), size = length(clone.order));
+        sampled.colours <- get.colours(clone.ids);
         sampled.colours[seq_along(clone.colours)] <- clone.colours;
         clone.colours <- setNames(
             sampled.colours[seq_along(clone.order)],

From c754b9a4fa8f867009916e1dfba495829608dbd4 Mon Sep 17 00:00:00 2001
From: whelena <hwinata@mednet.ucla.edu>
Date: Mon, 17 Mar 2025 11:03:35 -0700
Subject: [PATCH 08/14] add back get.colours

---
 R/utility.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/R/utility.R b/R/utility.R
index 5d3d37a..0f0e0c6 100644
--- a/R/utility.R
+++ b/R/utility.R
@@ -145,7 +145,7 @@ get.clone.colours.in.order <- function(
     if (is.null(clone.colours) || is.null(clone.order)) {
         clone.colours <- NULL;
     } else {
-        sampled.colours <- sample(colors(), size = length(clone.order));
+        sampled.colours <- get.colours(clone.order);
         sampled.colours[seq_along(clone.colours)] <- clone.colours;
         clone.colours <- setNames(
             sampled.colours[seq_along(clone.order)],

From 578ddbb2a2936f856bfc68fb940fa08868c10578 Mon Sep 17 00:00:00 2001
From: Aaron Holmes <aholmes@mednet.ucla.edu>
Date: Mon, 17 Mar 2025 11:29:39 -0700
Subject: [PATCH 09/14] Merge `get.clone.colours` with `get.colours` and update
 associated code.

---
 R/get.colours.R                   |  62 ++++++++++-
 R/utility.R                       |  84 +--------------
 man/get.clone.colours.Rd          |  29 -----
 man/get.clone.colours.in.order.Rd |  34 ------
 tests/testthat/test-get.colours.R | 169 ++++++++++++++++++++++++++++++
 tests/testthat/test-utility.R     | 159 ----------------------------
 6 files changed, 229 insertions(+), 308 deletions(-)
 delete mode 100644 man/get.clone.colours.Rd
 delete mode 100644 man/get.clone.colours.in.order.Rd

diff --git a/R/get.colours.R b/R/get.colours.R
index 007d3ff..0c14245 100644
--- a/R/get.colours.R
+++ b/R/get.colours.R
@@ -1,15 +1,24 @@
 get.colours <- function(
     value.list,
-    return.names = FALSE
+    return.names = FALSE,
+    predetermined.colours = NULL
     ) {
     colours <- grDevices::colors()[grep('(white|gr(a|e)y)', grDevices::colors(), invert = T)];
-    n <- length(unique(value.list));
+    unique.values <- unique(value.list);
+    n <- length(unique.values);
 
     col.list <- sample(colours, n);
+
+    if (!is.null(predetermined.colours) && !is.null(value.list)) {
+        col.list[seq_along(predetermined.colours)] <- predetermined.colours;
+        }
+
     if (is.null(levels(value.list))) {
-        value.list <- factor(value.list, levels = unique(value.list))
+        value.list <- factor(value.list, levels = unique.values);
         }
+
     names(col.list) <- levels(value.list);
+
     if (return.names) {
         return(col.list);
     } else {
@@ -17,6 +26,53 @@ get.colours <- function(
         }
     }
 
+#' Generate a named vector of colors for every value specified,
+#' ordered by the value in `value.order`.
+#'
+#' Assigns colors to values and ensures they follow a specified order.
+#' Any colors specified in `predetermined.colours` are maintained in the order
+#' specified and are used as the first colors for the `value.list`.
+#'
+#' @param predetermined.colours A vector of colors assigned to values. If `NULL`, colors will be generated automatically.
+#' @param value.list A vector of values.
+#' @param value.order An optional vector specifying the order of values. If `NULL`, value order is not gauranteed.
+#'
+#' @return A list containing:
+#' \describe{
+#'   \item{colours}{A named vector of colors assigned to each value.}
+#'   \item{value.order}{The ordered values.}
+#' }
+get.colours.in.order <- function(
+    predetermined.colours,
+    value.list,
+    value.order = NULL
+    ) {
+
+    if (is.null(predetermined.colours) && is.null(value.order)) {
+        value.list <- NULL;
+        }
+
+    if (is.null(value.order) && !is.null(value.list)) {
+        value.order <- unique(value.list);
+        }
+
+    if (is.null(predetermined.colours) || is.null(value.order)) {
+        predetermined.colours <- NULL;
+    } else {
+        sampled.colours <- get.colours(value.list);
+        sampled.colours[seq_along(predetermined.colours)] <- predetermined.colours;
+        predetermined.colours <- setNames(
+            sampled.colours[seq_along(value.order)],
+            value.order
+            );
+        }
+
+    return(list(
+        colours = predetermined.colours,
+        value.order = value.order
+        ));
+    }
+
 get.colour.luminance <- function(colour) {
     # Formulas and values documented in:
     # https://www.w3.org/WAI/GL/wiki/Relative_luminance
diff --git a/R/utility.R b/R/utility.R
index 78370b9..ed8b799 100644
--- a/R/utility.R
+++ b/R/utility.R
@@ -61,86 +61,4 @@ get.encoded.distance <- function(points) {
     encoded.distances <- ifelse(dot.products >= 0, distances.along.line, -distances.along.line);
 
     return(encoded.distances);
-    }
-
-#' Generate a named vector of colors for every clone ID specified.
-#'
-#' Assigns colors to clones, ensuring a minimum number of colors are used.
-#' Any colors specified in `clone.colours` are maintained in the order
-#' specified and are used as the first colors for the `clone.ids`.
-#'
-#' if `clone.colours` is NULL or an empty vector, _and_
-#' `minimum.number.of.colours` is 0, `NULL` is returned
-#' so BPG's default color selection can be used without needing to
-#' check for `NULL`.
-#'
-#' @param clone.colours A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.
-#' @param clone.ids A vector of clone identifiers.
-#' @param minimum.number.of.colours An integer specifying the minimum number of colors required.
-#'
-#' @return A named vector of colors assigned to each clone.
-get.clone.colours <- function(clone.colours, clone.ids, minimum.number.of.colours = 0) {
-    if (!is.null(clone.colours) && !is.null(clone.ids)) {
-        unique.clone.ids <- unique(clone.ids);
-        sampled.colors <- get.colours(unique.clone.ids);
-        sampled.colors[seq_along(clone.colours)] <- clone.colours;
-        return(setNames(
-            sampled.colors[seq_along(unique.clone.ids)],
-            unique.clone.ids
-            ));
-        }
-
-    return(NULL);
-    }
-
-#' Generate a named vector of colors for every clone ID specified,
-#' ordered by the clone IDs in `clone.order`.
-#'
-#' Assigns colors to clones and ensures they follow a specified order.
-#' Any colors specified in `clone.colours` are maintained in the order
-#' specified and are used as the first colors for the `clone.ids`.
-#'
-#' if `clone.colours` is NULL or an empty vector, _and_
-#' `minimum.number.of.colours` is 0, `NULL` is returned
-#' so BPG's default color selection can be used without needing to
-#' check for `NULL`.
-#'
-#' @param clone.colours A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.
-#' @param clone.ids A vector of clone identifiers.
-#' @param clone.order An optional vector specifying the order of clones. If `NULL`, clone order is not gauranteed.
-#'
-#' @return A list containing:
-#' \describe{
-#'   \item{clone.colours}{A named vector of colors assigned to each clone.}
-#'   \item{clone.order}{The ordered clones.}
-#' }
-get.clone.colours.in.order <- function(
-    clone.colours,
-    clone.ids,
-    clone.order = NULL
-    ) {
-
-    if (is.null(clone.colours) && is.null(clone.order)) {
-        clone.ids <- NULL;
-        }
-
-    if (is.null(clone.order) && !is.null(clone.ids)) {
-        clone.order <- unique(clone.ids);
-        }
-
-    if (is.null(clone.colours) || is.null(clone.order)) {
-        clone.colours <- NULL;
-    } else {
-        sampled.colours <- get.colours(clone.ids);
-        sampled.colours[seq_along(clone.colours)] <- clone.colours;
-        clone.colours <- setNames(
-            sampled.colours[seq_along(clone.order)],
-            clone.order
-            );
-        }
-
-    return(list(
-        clone.colours = clone.colours,
-        clone.order = clone.order
-        ));
-    }
+    }
\ No newline at end of file
diff --git a/man/get.clone.colours.Rd b/man/get.clone.colours.Rd
deleted file mode 100644
index ab6e9c5..0000000
--- a/man/get.clone.colours.Rd
+++ /dev/null
@@ -1,29 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/utility.R
-\name{get.clone.colours}
-\alias{get.clone.colours}
-\title{Generate a named vector of colors for every clone ID specified.}
-\usage{
-get.clone.colours(clone.colours, clone.ids, minimum.number.of.colours = 0)
-}
-\arguments{
-\item{clone.colours}{A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.}
-
-\item{clone.ids}{A vector of clone identifiers.}
-
-\item{minimum.number.of.colours}{An integer specifying the minimum number of colors required.}
-}
-\value{
-A named vector of colors assigned to each clone.
-}
-\description{
-Assigns colors to clones, ensuring a minimum number of colors are used.
-Any colors specified in `clone.colours` are maintained in the order
-specified and are used as the first colors for the `clone.ids`.
-}
-\details{
-if `clone.colours` is NULL or an empty vector, _and_
-`minimum.number.of.colours` is 0, `NULL` is returned
-so BPG's default color selection can be used without needing to
-check for `NULL`.
-}
diff --git a/man/get.clone.colours.in.order.Rd b/man/get.clone.colours.in.order.Rd
deleted file mode 100644
index 8c0d017..0000000
--- a/man/get.clone.colours.in.order.Rd
+++ /dev/null
@@ -1,34 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/utility.R
-\name{get.clone.colours.in.order}
-\alias{get.clone.colours.in.order}
-\title{Generate a named vector of colors for every clone ID specified,
-ordered by the clone IDs in `clone.order`.}
-\usage{
-get.clone.colours.in.order(clone.colours, clone.ids, clone.order = NULL)
-}
-\arguments{
-\item{clone.colours}{A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.}
-
-\item{clone.ids}{A vector of clone identifiers.}
-
-\item{clone.order}{An optional vector specifying the order of clones. If `NULL`, clone order is not gauranteed.}
-}
-\value{
-A list containing:
-\describe{
-  \item{clone.colours}{A named vector of colors assigned to each clone.}
-  \item{clone.order}{The ordered clones.}
-}
-}
-\description{
-Assigns colors to clones and ensures they follow a specified order.
-Any colors specified in `clone.colours` are maintained in the order
-specified and are used as the first colors for the `clone.ids`.
-}
-\details{
-if `clone.colours` is NULL or an empty vector, _and_
-`minimum.number.of.colours` is 0, `NULL` is returned
-so BPG's default color selection can be used without needing to
-check for `NULL`.
-}
diff --git a/tests/testthat/test-get.colours.R b/tests/testthat/test-get.colours.R
index a9e39bc..b584013 100644
--- a/tests/testthat/test-get.colours.R
+++ b/tests/testthat/test-get.colours.R
@@ -1,3 +1,9 @@
+expect.character.vector <- function (result) {
+    expect_true(identical(names(result), character(0)));
+    expect_true(identical(result, setNames(character(0), character(0))));
+    expect_equal(length(result), 0);
+    }
+
 test_that('get.colours returns a color for each vector element', {
   value.list <- c('ABC', 'DEF', 'DEF', 'GHI');
   colors <- get.colours(value.list);
@@ -54,3 +60,166 @@ test_that('get.colours returns an empty color vector when value.list is empty an
   expect_true(identical(colors, setNames(character(0), character(0))));
   expect_equal(length(colors), 0);
   });
+
+test_that(
+    'get.colours returns expected vectors', {
+        result <- get.colours(NULL, predetermined.colours = NULL);
+        expect.character.vector(result);
+        result <- get.colours(c('ABC', 'DEF'), predetermined.colours = NULL);
+        expect_equal(names(result), c('ABC', 'DEF'));
+        expect_true(!is.na(result['ABC']) && nzchar(result['ABC']));
+        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
+        result <- get.colours(NULL, predetermined.colours = c('red','green'));
+        expect.character.vector(result);
+        result <- get.colours(c(), predetermined.colours = c());
+        expect.character.vector(result);
+        result <- get.colours(NULL, predetermined.colours = c());
+        expect.character.vector(result);
+        result <- get.colours(c(), predetermined.colours = NULL);
+        expect.character.vector(result);
+        result <- get.colours(c("ABC", "DEF"), predetermined.colours = c())
+        expect_equal(names(result), c('ABC', 'DEF'));
+        expect_true(!is.na(result['ABC']) && nzchar(result['ABC']));
+        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
+        result <- get.colours(c(), predetermined.colours = c('red', 'green'));
+        expect.character.vector(result);
+        result <- get.colours(c('ABC','DEF'), predetermined.colours = c('red','green'));
+        expect_equal(result, c(ABC = 'red', DEF = 'green'));
+        result <- get.colours(c('ABC','DEF'), predetermined.colours = c('red'));
+        expect_equal(names(result), c('ABC', 'DEF'));
+        expect_true(result['ABC'] == 'red');
+        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
+        result <- get.colours(c('ABC','DEF'), predetermined.colours = c(NULL,'red'));
+        expect_equal(names(result), c('ABC', 'DEF'));
+        expect_true(result['ABC'] == 'red');
+        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
+        result <- get.colours(c('ABC','DEF'), predetermined.colours = c('red',NULL));
+        expect_equal(names(result), c('ABC', 'DEF'));
+        expect_true(result['ABC'] == 'red');
+        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
+        result <- get.colours(c('ABC'), predetermined.colours = c('red','green'));
+        expect_equal(result, c(ABC = 'red'));
+        result <- get.colours(c(NULL,'ABC'), predetermined.colours = c('red','green'));
+        expect_equal(result, c(ABC = 'red'));
+        result <- get.colours(c('ABC',NULL), predetermined.colours = c('red','green'));
+        expect_equal(result, c(ABC = 'red'));
+    });
+
+test_that(
+    'get.colours returns expected vectors with minimum colours specified', {
+        result <- get.colours(NULL, predetermined.colours = NULL)
+        expect.character.vector(result);
+        result <- get.colours(NULL, predetermined.colours = c('red', 'green'))
+        expect.character.vector(result);
+        result <- get.colours(NULL, predetermined.colours = c('red'))
+        expect.character.vector(result);
+        result <- get.colours(c('ABC','DEF'), predetermined.colours = c('red', 'green'))
+        expect_equal(result, c(ABC = 'red', DEF = 'green'));
+        result <- get.colours(c('ABC','DEF'), predetermined.colours = c('red'))
+        expect_equal(names(result), c('ABC', 'DEF'));
+        expect_true(result['ABC'] == 'red');
+        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
+        result <- get.colours(c('ABC'), predetermined.colours = c('red', 'green'))
+        expect_equal(result, c(ABC = 'red'));
+    });
+
+test_that(
+    'get.colours.in.order returns expected vectors when order is not specified', {
+        # get.colours.in.order has same result as get.colours
+        # with the change that a named list is returned with two members
+        result <- get.colours.in.order(NULL, NULL)
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
+        result <- get.colours.in.order(NULL, c('ABC', 'DEF'))
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
+        result <- get.colours.in.order(c('red','green'), NULL)
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
+        result <- get.colours.in.order(c(), c())
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
+        result <- get.colours.in.order(NULL, c())
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
+        result <- get.colours.in.order(c(), NULL)
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
+        result <- get.colours.in.order(c(), c('ABC', 'DEF'))
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
+        result <- get.colours.in.order(c('red', 'green'), c())
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
+        result <- get.colours.in.order(c('red','green'), c('ABC','DEF'))
+        expect_true(setequal(result,list(predetermined.colours = c(ABC = 'red',DEF = 'green'), value.order = c('ABC','DEF'))))
+        result <- get.colours.in.order(c('red'), c('ABC','DEF'))
+        expect_equal(names(result), c('colours', 'value.order'))
+        expect_equal(names(result$colours), c('ABC', 'DEF'))
+        expect_true(result$colours['ABC'] == 'red')
+        expect_true(!is.na(result$colours['DEF']) && nzchar(result$colours['DEF']))
+        expect_equal(result$value.order, c('ABC','DEF'))
+
+        result <- get.colours.in.order(c(NULL,'red'), c('ABC','DEF'))
+        expect_equal(names(result), c('colours', 'value.order'))
+        expect_equal(names(result$colours), c('ABC','DEF'))
+        expect_true(result$colours['ABC'] == 'red')
+        expect_true(!is.na(result$colours['DEF']) && nzchar(result$colours['DEF']))
+        expect_equal(result$value.order, c('ABC','DEF'))
+
+        result <- get.colours.in.order(c('red',NULL), c('ABC','DEF'))
+        expect_equal(names(result), c('colours', 'value.order'))
+        expect_equal(names(result$colours), c('ABC','DEF'))
+        expect_true(result$colours['ABC'] == 'red')
+        expect_true(!is.na(result$colours['DEF']) && nzchar(result$colours['DEF']))
+        expect_equal(result$value.order, c('ABC','DEF'))
+
+        result <- get.colours.in.order(c('red','green'), c('ABC'))
+        expect_true(setequal(result,list(predetermined.colours = c(ABC = 'red'), value.order = c('ABC'))))
+        result <- get.colours.in.order(c('red','green'), c(NULL,'ABC'))
+        expect_true(setequal(result,list(predetermined.colours = c(ABC = 'red'), value.order = c('ABC'))))
+        result <- get.colours.in.order(c('red','green'), c('ABC',NULL))
+        expect_true(setequal(result,list(predetermined.colours = c(ABC = 'red'), value.order = c('ABC'))))
+    });
+
+test_that(
+    'get.colours.in.order returns expected vectors when order is specified', {
+        # get.colours.in.order with order specified
+        result <- get.colours.in.order(NULL, NULL, c('DEF','ABC'))
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
+        result <- get.colours.in.order(NULL, c('ABC', 'DEF'), c('DEF','ABC'))
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
+        result <- get.colours.in.order(c('red','green'), NULL)
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
+        result <- get.colours.in.order(c(), c(), c('DEF','ABC'))
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
+        result <- get.colours.in.order(NULL, c(), c('DEF','ABC'))
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
+        result <- get.colours.in.order(c(), NULL, c('DEF','ABC'))
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
+        result <- get.colours.in.order(c(), c('ABC', 'DEF'), c('DEF','ABC'))
+        expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
+        result <- get.colours.in.order(c('red', 'green'), c(), c('DEF','ABC'))
+        expect_true(setequal(result, list(predetermined.colours = c(DEF = 'red',ABC = 'green'), value.order = c('DEF','ABC'))))
+        result <- get.colours.in.order(c('red','green'), c('ABC','DEF'), c('DEF','ABC'))
+        expect_true(setequal(result,list(predetermined.colours = c(DEF = 'red',ABC = 'green'), value.order = c('DEF','ABC'))))
+        result <- get.colours.in.order(c('red'), c('ABC','DEF'), c('DEF','ABC'))
+        expect_equal(names(result), c('colours', 'value.order'))
+        expect_equal(names(result$colours), c('DEF', 'ABC'))
+        expect_true(result$colours['DEF'] == 'red')
+        expect_true(!is.na(result$colours['ABC']) && nzchar(result$colours['ABC']))
+        expect_equal(result$value.order, c('DEF','ABC'))
+
+        result <- get.colours.in.order(c(NULL,'red'), c('ABC','DEF'), c('DEF','ABC'))
+        expect_equal(names(result), c('colours', 'value.order'))
+        expect_equal(names(result$colours), c('DEF','ABC'))
+        expect_true(result$colours['DEF'] == 'red')
+        expect_true(!is.na(result$colours['ABC']) && nzchar(result$colours['ABC']))
+        expect_equal(result$value.order, c('DEF','ABC'))
+
+        result <- get.colours.in.order(c('red',NULL), c('ABC','DEF'), c('DEF','ABC'))
+        expect_equal(names(result), c('colours', 'value.order'))
+        expect_equal(names(result$colours), c('DEF','ABC'))
+        expect_true(result$colours['DEF'] == 'red')
+        expect_true(!is.na(result$colours['ABC']) && nzchar(result$colours['ABC']))
+        expect_equal(result$value.order, c('DEF','ABC'))
+
+        result <- get.colours.in.order(c('red','green'), c('ABC'), c('DEF','ABC'))
+        expect_true(setequal(result,list(predetermined.colours = c(DEF = 'red',ABC = 'green'), value.order = c('DEF','ABC'))))
+        result <- get.colours.in.order(c('red','green'), c(NULL,'ABC'), c('DEF','ABC'))
+        expect_true(setequal(result,list(predetermined.colours = c(DEF = 'red',ABC = 'green'), value.order = c('DEF','ABC'))))
+        result <- get.colours.in.order(c('red','green'), c('ABC',NULL), c('DEF','ABC'))
+        expect_true(setequal(result,list(predetermined.colours = c(DEF = 'red',ABC = 'green'), value.order = c('DEF','ABC'))))
+    });
\ No newline at end of file
diff --git a/tests/testthat/test-utility.R b/tests/testthat/test-utility.R
index 5ad8898..aeb18c7 100644
--- a/tests/testthat/test-utility.R
+++ b/tests/testthat/test-utility.R
@@ -76,162 +76,3 @@ test_that(
 
         expect_equal(order(result), expected.order);
     });
-
-test_that(
-    'get.clone.colours returns expected vectors', {
-        result <- get.clone.colours(NULL, NULL);
-        expect_null(result);
-        result <- get.clone.colours(NULL, c('ABC', 'DEF'));
-        expect_null(result);
-        result <- get.clone.colours(c('red','green'), NULL);
-        expect_null(result);
-        result <- get.clone.colours(c(), c());
-        expect_null(result);
-        result <- get.clone.colours(NULL, c());
-        expect_null(result);
-        result <- get.clone.colours(c(), NULL);
-        expect_null(result);
-        result <- get.clone.colours(c(), c('ABC', 'DEF'));
-        expect_null(result);
-        result <- get.clone.colours(c('red', 'green'), c());
-        expect_null(result);
-        result <- get.clone.colours(c('red','green'), c('ABC','DEF'));
-        expect_equal(result, c(ABC = 'red', DEF = 'green'));
-        result <- get.clone.colours(c('red'), c('ABC','DEF'));
-        expect_equal(names(result), c('ABC', 'DEF'));
-        expect_true(result['ABC'] == 'red');
-        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
-        result <- get.clone.colours(c(NULL,'red'), c('ABC','DEF'));
-        expect_equal(names(result), c('ABC', 'DEF'));
-        expect_true(result['ABC'] == 'red');
-        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
-        result <- get.clone.colours(c('red',NULL), c('ABC','DEF'));
-        expect_equal(names(result), c('ABC', 'DEF'));
-        expect_true(result['ABC'] == 'red');
-        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
-        result <- get.clone.colours(c('red','green'), c('ABC'));
-        expect_equal(result, c(ABC = 'red'));
-        result <- get.clone.colours(c('red','green'), c(NULL,'ABC'));
-        expect_equal(result, c(ABC = 'red'));
-        result <- get.clone.colours(c('red','green'), c('ABC',NULL));
-        expect_equal(result, c(ABC = 'red'));
-    });
-
-test_that(
-    'get.clone.colours returns expected vectors with minimum colours specified', {
-        result <- get.clone.colours(NULL, NULL, 3)
-        expect_null(result);
-        result <- get.clone.colours(c('red', 'green'), NULL, 3)
-        expect_null(result);
-        result <- get.clone.colours(c('red'), NULL, 3)
-        expect_null(result);
-        result <- get.clone.colours(c('red', 'green'), c('ABC','DEF'), 3)
-        expect_equal(result, c(ABC = 'red', DEF = 'green'));
-        result <- get.clone.colours(c('red'), c('ABC','DEF'), 3)
-        expect_equal(names(result), c('ABC', 'DEF'));
-        expect_true(result['ABC'] == 'red');
-        expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
-        result <- get.clone.colours(c('red', 'green'), c('ABC'), 3)
-        expect_equal(result, c(ABC = 'red'));
-    });
-
-test_that(
-    'get.clone.colours.in.order returns expected vectors when order is not specified', {
-        # get.clone.colours.in.order has same result as get.clone.colours
-        # with the change that a named list is returned with two members
-        result <- get.clone.colours.in.order(NULL, NULL)
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
-        result <- get.clone.colours.in.order(NULL, c('ABC', 'DEF'))
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
-        result <- get.clone.colours.in.order(c('red','green'), NULL)
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
-        result <- get.clone.colours.in.order(c(), c())
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
-        result <- get.clone.colours.in.order(NULL, c())
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
-        result <- get.clone.colours.in.order(c(), NULL)
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
-        result <- get.clone.colours.in.order(c(), c('ABC', 'DEF'))
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
-        result <- get.clone.colours.in.order(c('red', 'green'), c())
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
-        result <- get.clone.colours.in.order(c('red','green'), c('ABC','DEF'))
-        expect_true(setequal(result,list(clone.colours = c(ABC = 'red',DEF = 'green'), clone.order = c('ABC','DEF'))))
-        result <- get.clone.colours.in.order(c('red'), c('ABC','DEF'))
-        expect_equal(names(result), c('clone.colours', 'clone.order'))
-        expect_equal(names(result$clone.colours), c('ABC', 'DEF'))
-        expect_true(result$clone.colours['ABC'] == 'red')
-        expect_true(!is.na(result$clone.colours['DEF']) && nzchar(result$clone.colours['DEF']))
-        expect_equal(result$clone.order, c('ABC','DEF'))
-
-        result <- get.clone.colours.in.order(c(NULL,'red'), c('ABC','DEF'))
-        expect_equal(names(result), c('clone.colours', 'clone.order'))
-        expect_equal(names(result$clone.colours), c('ABC','DEF'))
-        expect_true(result$clone.colours['ABC'] == 'red')
-        expect_true(!is.na(result$clone.colours['DEF']) && nzchar(result$clone.colours['DEF']))
-        expect_equal(result$clone.order, c('ABC','DEF'))
-
-        result <- get.clone.colours.in.order(c('red',NULL), c('ABC','DEF'))
-        expect_equal(names(result), c('clone.colours', 'clone.order'))
-        expect_equal(names(result$clone.colours), c('ABC','DEF'))
-        expect_true(result$clone.colours['ABC'] == 'red')
-        expect_true(!is.na(result$clone.colours['DEF']) && nzchar(result$clone.colours['DEF']))
-        expect_equal(result$clone.order, c('ABC','DEF'))
-
-        result <- get.clone.colours.in.order(c('red','green'), c('ABC'))
-        expect_true(setequal(result,list(clone.colours = c(ABC = 'red'), clone.order = c('ABC'))))
-        result <- get.clone.colours.in.order(c('red','green'), c(NULL,'ABC'))
-        expect_true(setequal(result,list(clone.colours = c(ABC = 'red'), clone.order = c('ABC'))))
-        result <- get.clone.colours.in.order(c('red','green'), c('ABC',NULL))
-        expect_true(setequal(result,list(clone.colours = c(ABC = 'red'), clone.order = c('ABC'))))
-    });
-
-test_that(
-    'get.clone.colours.in.order returns expected vectors when order is specified', {
-        # get.clone.colours.in.order with order specified
-        result <- get.clone.colours.in.order(NULL, NULL, c('DEF','ABC'))
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = c('DEF','ABC'))))
-        result <- get.clone.colours.in.order(NULL, c('ABC', 'DEF'), c('DEF','ABC'))
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = c('DEF','ABC'))))
-        result <- get.clone.colours.in.order(c('red','green'), NULL)
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = NULL)))
-        result <- get.clone.colours.in.order(c(), c(), c('DEF','ABC'))
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = c('DEF','ABC'))))
-        result <- get.clone.colours.in.order(NULL, c(), c('DEF','ABC'))
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = c('DEF','ABC'))))
-        result <- get.clone.colours.in.order(c(), NULL, c('DEF','ABC'))
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = c('DEF','ABC'))))
-        result <- get.clone.colours.in.order(c(), c('ABC', 'DEF'), c('DEF','ABC'))
-        expect_true(setequal(result, list(clone.colours = NULL, clone.order = c('DEF','ABC'))))
-        result <- get.clone.colours.in.order(c('red', 'green'), c(), c('DEF','ABC'))
-        expect_true(setequal(result, list(clone.colours = c(DEF = 'red',ABC = 'green'), clone.order = c('DEF','ABC'))))
-        result <- get.clone.colours.in.order(c('red','green'), c('ABC','DEF'), c('DEF','ABC'))
-        expect_true(setequal(result,list(clone.colours = c(DEF = 'red',ABC = 'green'), clone.order = c('DEF','ABC'))))
-        result <- get.clone.colours.in.order(c('red'), c('ABC','DEF'), c('DEF','ABC'))
-        expect_equal(names(result), c('clone.colours', 'clone.order'))
-        expect_equal(names(result$clone.colours), c('DEF', 'ABC'))
-        expect_true(result$clone.colours['DEF'] == 'red')
-        expect_true(!is.na(result$clone.colours['ABC']) && nzchar(result$clone.colours['ABC']))
-        expect_equal(result$clone.order, c('DEF','ABC'))
-
-        result <- get.clone.colours.in.order(c(NULL,'red'), c('ABC','DEF'), c('DEF','ABC'))
-        expect_equal(names(result), c('clone.colours', 'clone.order'))
-        expect_equal(names(result$clone.colours), c('DEF','ABC'))
-        expect_true(result$clone.colours['DEF'] == 'red')
-        expect_true(!is.na(result$clone.colours['ABC']) && nzchar(result$clone.colours['ABC']))
-        expect_equal(result$clone.order, c('DEF','ABC'))
-
-        result <- get.clone.colours.in.order(c('red',NULL), c('ABC','DEF'), c('DEF','ABC'))
-        expect_equal(names(result), c('clone.colours', 'clone.order'))
-        expect_equal(names(result$clone.colours), c('DEF','ABC'))
-        expect_true(result$clone.colours['DEF'] == 'red')
-        expect_true(!is.na(result$clone.colours['ABC']) && nzchar(result$clone.colours['ABC']))
-        expect_equal(result$clone.order, c('DEF','ABC'))
-
-        result <- get.clone.colours.in.order(c('red','green'), c('ABC'), c('DEF','ABC'))
-        expect_true(setequal(result,list(clone.colours = c(DEF = 'red',ABC = 'green'), clone.order = c('DEF','ABC'))))
-        result <- get.clone.colours.in.order(c('red','green'), c(NULL,'ABC'), c('DEF','ABC'))
-        expect_true(setequal(result,list(clone.colours = c(DEF = 'red',ABC = 'green'), clone.order = c('DEF','ABC'))))
-        result <- get.clone.colours.in.order(c('red','green'), c('ABC',NULL), c('DEF','ABC'))
-        expect_true(setequal(result,list(clone.colours = c(DEF = 'red',ABC = 'green'), clone.order = c('DEF','ABC'))))
-    });

From 3c9d0802a98e814b6367107c77bf4af880e48490 Mon Sep 17 00:00:00 2001
From: Aaron Holmes <aholmes@mednet.ucla.edu>
Date: Mon, 17 Mar 2025 11:32:12 -0700
Subject: [PATCH 10/14] Fix lintr errors.

---
 R/utility.R                       | 2 +-
 tests/testthat/test-get.colours.R | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/R/utility.R b/R/utility.R
index ed8b799..e780345 100644
--- a/R/utility.R
+++ b/R/utility.R
@@ -61,4 +61,4 @@ get.encoded.distance <- function(points) {
     encoded.distances <- ifelse(dot.products >= 0, distances.along.line, -distances.along.line);
 
     return(encoded.distances);
-    }
\ No newline at end of file
+    }
diff --git a/tests/testthat/test-get.colours.R b/tests/testthat/test-get.colours.R
index b584013..94e1005 100644
--- a/tests/testthat/test-get.colours.R
+++ b/tests/testthat/test-get.colours.R
@@ -1,4 +1,4 @@
-expect.character.vector <- function (result) {
+expect.character.vector <- function(result) {
     expect_true(identical(names(result), character(0)));
     expect_true(identical(result, setNames(character(0), character(0))));
     expect_equal(length(result), 0);
@@ -77,7 +77,7 @@ test_that(
         expect.character.vector(result);
         result <- get.colours(c(), predetermined.colours = NULL);
         expect.character.vector(result);
-        result <- get.colours(c("ABC", "DEF"), predetermined.colours = c())
+        result <- get.colours(c('ABC', 'DEF'), predetermined.colours = c())
         expect_equal(names(result), c('ABC', 'DEF'));
         expect_true(!is.na(result['ABC']) && nzchar(result['ABC']));
         expect_true(!is.na(result['DEF']) && nzchar(result['DEF']));
@@ -222,4 +222,4 @@ test_that(
         expect_true(setequal(result,list(predetermined.colours = c(DEF = 'red',ABC = 'green'), value.order = c('DEF','ABC'))))
         result <- get.colours.in.order(c('red','green'), c('ABC',NULL), c('DEF','ABC'))
         expect_true(setequal(result,list(predetermined.colours = c(DEF = 'red',ABC = 'green'), value.order = c('DEF','ABC'))))
-    });
\ No newline at end of file
+    });

From fa8e4df809eb2369ef9a07c1bc959b8ce14f1a5f Mon Sep 17 00:00:00 2001
From: whelena <hwinata@mednet.ucla.edu>
Date: Mon, 17 Mar 2025 11:43:33 -0700
Subject: [PATCH 11/14] rename documentation

---
 man/get.clone.colours.in.order.Rd | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/man/get.clone.colours.in.order.Rd b/man/get.clone.colours.in.order.Rd
index 8c0d017..228429f 100644
--- a/man/get.clone.colours.in.order.Rd
+++ b/man/get.clone.colours.in.order.Rd
@@ -1,11 +1,11 @@
 % Generated by roxygen2: do not edit by hand
 % Please edit documentation in R/utility.R
-\name{get.clone.colours.in.order}
-\alias{get.clone.colours.in.order}
+\name{get.colours.in.order}
+\alias{get.colours.in.order}
 \title{Generate a named vector of colors for every clone ID specified,
 ordered by the clone IDs in `clone.order`.}
 \usage{
-get.clone.colours.in.order(clone.colours, clone.ids, clone.order = NULL)
+get.colours.in.order(clone.colours, clone.ids, clone.order = NULL)
 }
 \arguments{
 \item{clone.colours}{A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.}

From d6c2d336ed35817c0212f4fde148d112d1cbabde Mon Sep 17 00:00:00 2001
From: Aaron Holmes <aholmes@mednet.ucla.edu>
Date: Mon, 17 Mar 2025 11:52:39 -0700
Subject: [PATCH 12/14] Change order of parameters in colour functions to be
 consistent.

---
 R/get.colours.R                   |  6 ++--
 tests/testthat/test-get.colours.R | 60 +++++++++++++++----------------
 2 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/R/get.colours.R b/R/get.colours.R
index 0c14245..ec2a873 100644
--- a/R/get.colours.R
+++ b/R/get.colours.R
@@ -33,9 +33,9 @@ get.colours <- function(
 #' Any colors specified in `predetermined.colours` are maintained in the order
 #' specified and are used as the first colors for the `value.list`.
 #'
-#' @param predetermined.colours A vector of colors assigned to values. If `NULL`, colors will be generated automatically.
 #' @param value.list A vector of values.
 #' @param value.order An optional vector specifying the order of values. If `NULL`, value order is not gauranteed.
+#' @param predetermined.colours A vector of colors assigned to values. If `NULL`, colors will be generated automatically.
 #'
 #' @return A list containing:
 #' \describe{
@@ -43,9 +43,9 @@ get.colours <- function(
 #'   \item{value.order}{The ordered values.}
 #' }
 get.colours.in.order <- function(
-    predetermined.colours,
     value.list,
-    value.order = NULL
+    value.order = NULL,
+    predetermined.colours = NULL
     ) {
 
     if (is.null(predetermined.colours) && is.null(value.order)) {
diff --git a/tests/testthat/test-get.colours.R b/tests/testthat/test-get.colours.R
index 94e1005..8e121bd 100644
--- a/tests/testthat/test-get.colours.R
+++ b/tests/testthat/test-get.colours.R
@@ -127,99 +127,99 @@ test_that(
     'get.colours.in.order returns expected vectors when order is not specified', {
         # get.colours.in.order has same result as get.colours
         # with the change that a named list is returned with two members
-        result <- get.colours.in.order(NULL, NULL)
+        result <- get.colours.in.order(NULL, predetermined.colours = NULL)
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
-        result <- get.colours.in.order(NULL, c('ABC', 'DEF'))
+        result <- get.colours.in.order(c('ABC', 'DEF'), predetermined.colours = NULL)
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
-        result <- get.colours.in.order(c('red','green'), NULL)
+        result <- get.colours.in.order(NULL, predetermined.colours = c('red','green'))
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
-        result <- get.colours.in.order(c(), c())
+        result <- get.colours.in.order(c(), predetermined.colours = c())
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
-        result <- get.colours.in.order(NULL, c())
+        result <- get.colours.in.order(c(), predetermined.colours = NULL)
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
-        result <- get.colours.in.order(c(), NULL)
+        result <- get.colours.in.order(NULL, predetermined.colours = c())
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
-        result <- get.colours.in.order(c(), c('ABC', 'DEF'))
+        result <- get.colours.in.order(c('ABC', 'DEF'), predetermined.colours = c())
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
-        result <- get.colours.in.order(c('red', 'green'), c())
+        result <- get.colours.in.order(c(), predetermined.colours = c('red', 'green'))
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
-        result <- get.colours.in.order(c('red','green'), c('ABC','DEF'))
+        result <- get.colours.in.order(c('ABC','DEF'), predetermined.colours = c('red','green'))
         expect_true(setequal(result,list(predetermined.colours = c(ABC = 'red',DEF = 'green'), value.order = c('ABC','DEF'))))
-        result <- get.colours.in.order(c('red'), c('ABC','DEF'))
+        result <- get.colours.in.order(c('ABC','DEF'), predetermined.colours = c('red'))
         expect_equal(names(result), c('colours', 'value.order'))
         expect_equal(names(result$colours), c('ABC', 'DEF'))
         expect_true(result$colours['ABC'] == 'red')
         expect_true(!is.na(result$colours['DEF']) && nzchar(result$colours['DEF']))
         expect_equal(result$value.order, c('ABC','DEF'))
 
-        result <- get.colours.in.order(c(NULL,'red'), c('ABC','DEF'))
+        result <- get.colours.in.order(c('ABC','DEF'), predetermined.colours = c(NULL,'red'))
         expect_equal(names(result), c('colours', 'value.order'))
         expect_equal(names(result$colours), c('ABC','DEF'))
         expect_true(result$colours['ABC'] == 'red')
         expect_true(!is.na(result$colours['DEF']) && nzchar(result$colours['DEF']))
         expect_equal(result$value.order, c('ABC','DEF'))
 
-        result <- get.colours.in.order(c('red',NULL), c('ABC','DEF'))
+        result <- get.colours.in.order(c('ABC','DEF'), predetermined.colours = c('red',NULL))
         expect_equal(names(result), c('colours', 'value.order'))
         expect_equal(names(result$colours), c('ABC','DEF'))
         expect_true(result$colours['ABC'] == 'red')
         expect_true(!is.na(result$colours['DEF']) && nzchar(result$colours['DEF']))
         expect_equal(result$value.order, c('ABC','DEF'))
 
-        result <- get.colours.in.order(c('red','green'), c('ABC'))
+        result <- get.colours.in.order(c('ABC'), predetermined.colours = c('red','green'))
         expect_true(setequal(result,list(predetermined.colours = c(ABC = 'red'), value.order = c('ABC'))))
-        result <- get.colours.in.order(c('red','green'), c(NULL,'ABC'))
+        result <- get.colours.in.order(c(NULL,'ABC'), predetermined.colours = c('red','green'))
         expect_true(setequal(result,list(predetermined.colours = c(ABC = 'red'), value.order = c('ABC'))))
-        result <- get.colours.in.order(c('red','green'), c('ABC',NULL))
+        result <- get.colours.in.order(c('ABC',NULL), predetermined.colours = c('red','green'))
         expect_true(setequal(result,list(predetermined.colours = c(ABC = 'red'), value.order = c('ABC'))))
     });
 
 test_that(
     'get.colours.in.order returns expected vectors when order is specified', {
         # get.colours.in.order with order specified
-        result <- get.colours.in.order(NULL, NULL, c('DEF','ABC'))
+        result <- get.colours.in.order(NULL, c('DEF','ABC'), NULL)
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
-        result <- get.colours.in.order(NULL, c('ABC', 'DEF'), c('DEF','ABC'))
+        result <- get.colours.in.order(c('ABC', 'DEF'), c('DEF','ABC'), NULL)
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
-        result <- get.colours.in.order(c('red','green'), NULL)
+        result <- get.colours.in.order(NULL, predetermined.colours = c('red','green'))
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
-        result <- get.colours.in.order(c(), c(), c('DEF','ABC'))
+        result <- get.colours.in.order(c(), c("DEF", "ABC"), c())
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
-        result <- get.colours.in.order(NULL, c(), c('DEF','ABC'))
+        result <- get.colours.in.order(c(), c('DEF','ABC'), NULL)
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
-        result <- get.colours.in.order(c(), NULL, c('DEF','ABC'))
+        result <- get.colours.in.order(NULL, c("DEF", "ABC"), c())
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
-        result <- get.colours.in.order(c(), c('ABC', 'DEF'), c('DEF','ABC'))
+        result <- get.colours.in.order(c("ABC", "DEF"), c("DEF", "ABC"), c())
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
-        result <- get.colours.in.order(c('red', 'green'), c(), c('DEF','ABC'))
+        result <- get.colours.in.order(c(), c('DEF','ABC'), c('red', 'green'))
         expect_true(setequal(result, list(predetermined.colours = c(DEF = 'red',ABC = 'green'), value.order = c('DEF','ABC'))))
-        result <- get.colours.in.order(c('red','green'), c('ABC','DEF'), c('DEF','ABC'))
+        result <- get.colours.in.order(c('ABC','DEF'), c('DEF','ABC'), c('red','green'))
         expect_true(setequal(result,list(predetermined.colours = c(DEF = 'red',ABC = 'green'), value.order = c('DEF','ABC'))))
-        result <- get.colours.in.order(c('red'), c('ABC','DEF'), c('DEF','ABC'))
+        result <- get.colours.in.order(c('ABC','DEF'), c('DEF','ABC'), c('red'))
         expect_equal(names(result), c('colours', 'value.order'))
         expect_equal(names(result$colours), c('DEF', 'ABC'))
         expect_true(result$colours['DEF'] == 'red')
         expect_true(!is.na(result$colours['ABC']) && nzchar(result$colours['ABC']))
         expect_equal(result$value.order, c('DEF','ABC'))
 
-        result <- get.colours.in.order(c(NULL,'red'), c('ABC','DEF'), c('DEF','ABC'))
+        result <- get.colours.in.order(c('ABC','DEF'), c('DEF','ABC'), c(NULL,'red'))
         expect_equal(names(result), c('colours', 'value.order'))
         expect_equal(names(result$colours), c('DEF','ABC'))
         expect_true(result$colours['DEF'] == 'red')
         expect_true(!is.na(result$colours['ABC']) && nzchar(result$colours['ABC']))
         expect_equal(result$value.order, c('DEF','ABC'))
 
-        result <- get.colours.in.order(c('red',NULL), c('ABC','DEF'), c('DEF','ABC'))
+        result <- get.colours.in.order(c('ABC','DEF'), c('DEF','ABC'), c('red',NULL))
         expect_equal(names(result), c('colours', 'value.order'))
         expect_equal(names(result$colours), c('DEF','ABC'))
         expect_true(result$colours['DEF'] == 'red')
         expect_true(!is.na(result$colours['ABC']) && nzchar(result$colours['ABC']))
         expect_equal(result$value.order, c('DEF','ABC'))
 
-        result <- get.colours.in.order(c('red','green'), c('ABC'), c('DEF','ABC'))
+        result <- get.colours.in.order(c('ABC'), c('DEF','ABC'), c('red','green'))
         expect_true(setequal(result,list(predetermined.colours = c(DEF = 'red',ABC = 'green'), value.order = c('DEF','ABC'))))
-        result <- get.colours.in.order(c('red','green'), c(NULL,'ABC'), c('DEF','ABC'))
+        result <- get.colours.in.order(c(NULL,'ABC'), c('DEF','ABC'), c('red','green'))
         expect_true(setequal(result,list(predetermined.colours = c(DEF = 'red',ABC = 'green'), value.order = c('DEF','ABC'))))
-        result <- get.colours.in.order(c('red','green'), c('ABC',NULL), c('DEF','ABC'))
+        result <- get.colours.in.order(c('ABC',NULL), c('DEF','ABC'), c('red','green'))
         expect_true(setequal(result,list(predetermined.colours = c(DEF = 'red',ABC = 'green'), value.order = c('DEF','ABC'))))
     });

From 4a02cf4754d7ce9f4a9fd6dee08ee04473502135 Mon Sep 17 00:00:00 2001
From: Aaron Holmes <aholmes@mednet.ucla.edu>
Date: Mon, 17 Mar 2025 11:53:37 -0700
Subject: [PATCH 13/14] Remove man page.

---
 man/get.clone.colours.in.order.Rd | 34 -------------------------------
 1 file changed, 34 deletions(-)
 delete mode 100644 man/get.clone.colours.in.order.Rd

diff --git a/man/get.clone.colours.in.order.Rd b/man/get.clone.colours.in.order.Rd
deleted file mode 100644
index 228429f..0000000
--- a/man/get.clone.colours.in.order.Rd
+++ /dev/null
@@ -1,34 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/utility.R
-\name{get.colours.in.order}
-\alias{get.colours.in.order}
-\title{Generate a named vector of colors for every clone ID specified,
-ordered by the clone IDs in `clone.order`.}
-\usage{
-get.colours.in.order(clone.colours, clone.ids, clone.order = NULL)
-}
-\arguments{
-\item{clone.colours}{A vector of colors assigned to clones. If `NULL`, colors will be generated automatically.}
-
-\item{clone.ids}{A vector of clone identifiers.}
-
-\item{clone.order}{An optional vector specifying the order of clones. If `NULL`, clone order is not gauranteed.}
-}
-\value{
-A list containing:
-\describe{
-  \item{clone.colours}{A named vector of colors assigned to each clone.}
-  \item{clone.order}{The ordered clones.}
-}
-}
-\description{
-Assigns colors to clones and ensures they follow a specified order.
-Any colors specified in `clone.colours` are maintained in the order
-specified and are used as the first colors for the `clone.ids`.
-}
-\details{
-if `clone.colours` is NULL or an empty vector, _and_
-`minimum.number.of.colours` is 0, `NULL` is returned
-so BPG's default color selection can be used without needing to
-check for `NULL`.
-}

From eb0c4421a0774c91ec239a1afaa6b99a6a338736 Mon Sep 17 00:00:00 2001
From: Aaron Holmes <aholmes@mednet.ucla.edu>
Date: Mon, 17 Mar 2025 11:55:37 -0700
Subject: [PATCH 14/14] lintr fixes.

---
 tests/testthat/test-get.colours.R | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/testthat/test-get.colours.R b/tests/testthat/test-get.colours.R
index 8e121bd..237aae7 100644
--- a/tests/testthat/test-get.colours.R
+++ b/tests/testthat/test-get.colours.R
@@ -183,13 +183,13 @@ test_that(
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
         result <- get.colours.in.order(NULL, predetermined.colours = c('red','green'))
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = NULL)))
-        result <- get.colours.in.order(c(), c("DEF", "ABC"), c())
+        result <- get.colours.in.order(c(), c('DEF', 'ABC'), c())
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
         result <- get.colours.in.order(c(), c('DEF','ABC'), NULL)
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
-        result <- get.colours.in.order(NULL, c("DEF", "ABC"), c())
+        result <- get.colours.in.order(NULL, c('DEF', 'ABC'), c())
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
-        result <- get.colours.in.order(c("ABC", "DEF"), c("DEF", "ABC"), c())
+        result <- get.colours.in.order(c('ABC', 'DEF'), c('DEF', 'ABC'), c())
         expect_true(setequal(result, list(predetermined.colours = NULL, value.order = c('DEF','ABC'))))
         result <- get.colours.in.order(c(), c('DEF','ABC'), c('red', 'green'))
         expect_true(setequal(result, list(predetermined.colours = c(DEF = 'red',ABC = 'green'), value.order = c('DEF','ABC'))))