--- a
+++ b/R/annotation.R
@@ -0,0 +1,738 @@
+####
+# Main Shiny App ####
+####
+
+#' annotateSpatialData
+#'
+#' A mini shiny app to for annotating spatial points
+#'
+#' @param object a VoltRon object
+#' @param label the name of the new metadata column (default: annotation) annotating spatial points by selected polygons
+#' @param assay assay name (exp: Assay1) or assay class (exp: Visium, Xenium), see \link{SampleMetadata}. 
+#' if NULL, the default assay will be used, see \link{vrMainAssay}.
+#' @param annotation_assay name of the annotation assay ()
+#' @param use.image.only if TRUE, use only the image
+#' @param shiny.options a list of shiny options (launch.browser, host, port etc.) passed \code{options} arguement of \link{shinyApp}. For more information, see \link{runApp}
+#' @param image_name the name/key of the image
+#' @param channel the name of the main channel
+#' @param ... additional parameters passed to \link{vrSpatialPlot}.
+#'
+#' @import shiny
+#' @importFrom shinyjs useShinyjs show hide
+#' @importFrom stats median
+#' @importFrom sp point.in.polygon
+#' @import ggplot2
+#'
+#' @export
+#' 
+#' @examples
+#' \dontrun{
+#' # Annotate based on images
+#' visium_data <- annotateSpatialData(visium_data, use.image.only = TRUE)
+#' 
+#' # Annotate based on spatial plot
+#' xenium_data <- annotateSpatialData(xenium_data, group.by = "clusters")
+#' }
+annotateSpatialData <- function(object, label = "annotation", assay = NULL, annotation_assay = "ROIAnnotation", use.image.only = FALSE, 
+                                shiny.options = list(launch.browser = getOption("shiny.launch.browser", interactive())), 
+                                image_name = NULL, channel = NULL, ...) {
+  
+  if(!inherits(object, "VoltRon"))
+    stop("Please provide a VoltRon object!")
+  
+  ## Importing images ####
+  
+  # get assay names, and always get a single assay
+  assay_names <- vrAssayNames(object, assay = assay)
+  if(length(assay_names) > 0)
+    assay <- assay_names[1]
+  
+  # get image name and channel
+  if(is.null(image_name)){
+    image_name <- vrMainSpatial(object[[assay]])
+  }
+  
+  # get image
+  img <- vrImages(object[[assay]], name = image_name, channel = channel, as.raster = TRUE)
+  if(!inherits(img, "Image_Array")){
+    if(!requireNamespace("ImageArray")){
+      message("Please install ImageArray package to speed up visualization")
+      img <- magick::image_read(img)
+    } else{
+      img <- ImageArray::createImageArray(img)
+    }
+  }
+  if(!use.image.only){
+    # get spatial plot
+    g_spatial <- vrSpatialPlot(object, assay = assay, spatial = image_name, channel = channel, scale.image = FALSE, ...)
+    g_spatial <- g_spatial$layers[[2]]
+  }
+  
+  # get image info
+  max.pixel.size <- 1200
+  imginfo <- getImageInfo(img)
+  
+  ## Get previous annotation ####
+  
+  # set label names
+  sample_metadata <- SampleMetadata(object)
+  metadata <- Metadata(object, assay = sample_metadata[assay, "Assay"])
+  coords <- vrCoordinates(object, assay = assay)
+  if(label %in% colnames(metadata)){
+    unique_names <- make.unique(c(colnames(metadata)[grepl(paste0("^", label), colnames(metadata))], label))
+    label <- unique_names[length(unique_names)]
+  }
+  
+  # get segmentations (if exists) from the same layer
+  if(!is.null(annotation_assay)){
+    layer_metadata <- sample_metadata[sample_metadata$Layer == sample_metadata[assay, "Layer"] & sample_metadata$Sample == sample_metadata[assay, "Sample"],]
+    if(annotation_assay %in% layer_metadata$Assay){
+      
+      # get segments
+      segments <- vrSegments(object, assay = annotation_assay)
+      segments <- lapply(segments, function(seg) seg[,colnames(seg)[colnames(seg) != "id"]])
+      segment_names <- gsub("_Assay[0-9]+$", "", names(segments)) 
+      
+      # remove the latest annotation
+      all_assay_names <- vrAssayNames(object, assay = "all")
+      object <- subsetVoltRon(object, assays = all_assay_names[!all_assay_names %in% rownames(layer_metadata)[layer_metadata$Assay == annotation_assay]])
+      
+    } else {
+      segments <- list()
+      segment_names <- c()
+    }
+  }
+  
+  ## UI and Server ####
+  
+  # Define UI for the application
+  ui <- fluidPage(
+    sidebarLayout(position = "left",
+                  
+                  sidebarPanel(
+                    
+                    # margin settings
+                    tags$style(make_css(list('.well', 'margin', '7%'))),
+                    
+                    # # specific settings for dealing with simultaneous click and brush events
+                    # # https://jokergoo.github.io/2021/02/20/differentiate-brush-and-click-event-in-shiny/
+                    tags$script(HTML("
+            $('#plot').mousedown(function(e) {
+                var parentOffset = $(this).offset();
+                var relX = e.pageX - parentOffset.left;
+                var relY = e.pageY - parentOffset.top;
+                Shiny.setInputValue('x1', relX);
+                Shiny.setInputValue('y1', relY);
+            }).mouseup(function(e) {
+                var parentOffset = $(this).offset();
+                var relX = e.pageX - parentOffset.left;
+                var relY = e.pageY - parentOffset.top;
+                Shiny.setInputValue('x2', relX);
+                Shiny.setInputValue('y2', relY);
+                Shiny.setInputValue('action', Math.random());
+            });
+          ")),
+                    
+                    # Interface
+                    fluidRow(
+                      column(12,h4("Spatial Annotation")),
+                      column(12,shiny::actionButton("reset_btn",     "Reset Points     ")),
+                      column(12,shiny::actionButton("rmvlast_btn",   "Remove Last Point")),
+                      column(12,shiny::actionButton("addregion_btn", "Add Region       ")),
+                    ),
+                    br(),
+                    
+                    fluidRow(
+                      column(6,shiny::selectInput("region_type", label = "Region Type", choices = c("Polygon", "Circle"), selected = "Polygon")),
+                      column(6,shiny::sliderInput("alpha", "Transparency", min = 0, max = 1, value = 0.2)),
+                    ),
+                    
+                    fluidRow(
+                      column(6,shiny::sliderInput("label_size", label = "Label Size", min = 1, max = 5, step = 0.5, value = 4)),
+                    ),
+                    
+                    # instructions
+                    h4("How to use"),
+                    p(style="font-size: 12px;", strong("Single-L-click"), " to select polygon or circle points"),
+                    p(style="font-size: 12px;", strong("Add Region"), " to set points as a new region"),
+                    p(style="font-size: 12px;", strong("Circles"), " require only 2 points"),
+                    p(style="font-size: 12px;", strong("Polygons"), " require at least 4 points"),
+                    br(),
+                    
+                    # Subsets
+                    fluidRow(
+                      column(12,h4("Selected Regions")),
+                      br(),
+                      column(12,shiny::actionButton("done", "Done")),
+                      br()  
+                    ),
+                    
+                    # Subsets
+                    fluidRow(
+                      br(),
+                      uiOutput("textbox_ui"),
+                      br()  
+                    ),
+                    
+                    width = 4
+                  ),
+                  mainPanel(
+                    shinyjs::useShinyjs(),
+                    plotOutput("image_plot",
+                               height = "1000px",
+                               click = "plot_click",
+                               dblclick = "plot_dblclick",
+                               brush = brushOpts(
+                                 id = "plot_brush", fill = "green",
+                                 resetOnNew = TRUE
+                               )),
+                    width = 8
+                  )
+    )
+  )
+  
+  # Define server logic required to create, add, and remove textboxes
+  server <- function(input, output, session) {
+    
+    # Reactive values ####
+    selected_corners_list <- reactiveVal(segments)
+    selected_corners <- reactiveVal(data.frame(x = numeric(0), y = numeric(0)))
+    ranges <- reactiveValues(x = c(0, imginfo$width), y = c(0, imginfo$height))
+    
+    # Zoom Event ####
+    manageImageBrush(img, ranges, max.pixel.size, input, output, session)
+    
+    # Corner Events ####
+    observeEvent(input$reset_btn, {
+      selected_corners(data.frame(x = numeric(0), y = numeric(0)))
+    })
+    observeEvent(input$rmvlast_btn, {
+      selected_corners(selected_corners()[-nrow(selected_corners()),])
+    })
+    manageSelectedCorners(selected_corners, img, ranges, max.pixel.size, input, output, session)
+
+    # Region Events ####
+    n <- length(segments)
+    textboxes <- reactiveVal(if (n > 0) seq_len(n) else numeric(0))
+    if (n > 0) {
+      segment_names <- as.list(segment_names)
+      names(segment_names) <- paste0("region", seq_len(n))
+      textbox_values <- do.call("reactiveValues", segment_names)
+    } else {
+      textbox_values <- reactiveValues()
+    }
+    
+    # Dynamically generate UI for textboxes and remove buttons
+    output$textbox_ui <- renderUI({
+      lapply(rev(textboxes()), function(i) {
+        column(12,
+               textInputwithButton(textinputId = paste0("region", i), label = paste0("Region ", i),
+                                   buttoninputId = paste0("remove", i), value = isolate(textbox_values[[paste0("region", i)]]), 
+                                   onclick = sprintf('Shiny.setInputValue("remove", %d)', i))
+               
+        )
+      })
+    })
+  
+    ### update Region text ####
+    
+    observe({
+      lapply(textboxes(), function(i) {
+        observeEvent(input[[paste0("region", i)]], {
+          textbox_values[[paste0("region", i)]] <- isolate(input[[paste0("region", i)]])
+        }, ignoreNULL = FALSE)
+      })
+    })
+    
+    ### remove a Region ####
+    
+    # Observe event to remove textbox when the button is clicked
+    observeEvent(input$remove, {
+      
+      # remove one point
+      selected_corners_list(selected_corners_list()[!(textboxes() == as.numeric(isolate(input$remove)))])
+      
+      # Update the reactive value to remove the textbox
+      textboxes(setdiff(textboxes(), as.numeric(isolate(input$remove))))
+      
+      # Remove the value from textbox_values
+      textbox_values[[paste0("region", as.numeric(input$remove))]] <- NULL
+      
+    }, ignoreInit = TRUE)
+    
+    ### add a Region ####
+    
+    # Observe event to add a new textbox
+    observeEvent(input$addregion_btn, {
+      
+      # Polygon selection
+      if(isolate(input$region_type == "Polygon")){
+        if(nrow(selected_corners()) > 3){
+          
+          # add to region list
+          selected_corners_list(c(selected_corners_list(), list(selected_corners())))
+          
+          # remove selected points
+          selected_corners(data.frame(x = numeric(0), y = numeric(0)))
+          
+          # add buttons
+          new_id <- if (length(textboxes()) == 0) 1 else max(textboxes()) + 1
+          textboxes(c(textboxes(), new_id))
+          textbox_values[[paste0("region", new_id)]] <- ""
+        } else {
+          showNotification("You must selected at least 4 points for each polygon!")
+        }
+      } 
+      
+      # Circle selection
+      if(isolate(input$region_type == "Circle")){
+        if(nrow(selected_corners()) == 2){
+          
+          # add to region list
+          circle <- makeCircleData(selected_corners())
+          selected_corners_list(c(selected_corners_list(), list(circle)))
+          
+          # remove selected points
+          selected_corners(data.frame(x = numeric(0), y = numeric(0)))
+          
+          # add buttons
+          new_id <- if (length(textboxes()) == 0) 1 else max(textboxes()) + 1
+          textboxes(c(textboxes(), new_id))
+          textbox_values[[paste0("region", new_id)]] <- ""
+        } else {
+          showNotification("You must selected only 2 points for each circle!")
+        }
+      }
+    })
+    # Image output ####
+    output$image_plot <- renderPlot({
+      
+      ## get image ####
+      zoom_info <- FromBoxToCrop(cbind(ranges$x, ranges$y), imageinfo = imginfo)
+      img <- cropImage(img, zoom_info)
+      g <- plotImage(img, max.pixel.size = max.pixel.size) + labs(title = "")
+      if(!use.image.only){
+        g_spatial_clone <- cloneLayer(g_spatial)
+        g <- g + transformSpatialLayer(g_spatial_clone, img, ranges, max.pixel.size)
+      }
+
+      # visualize currently selected corners ####
+      transformed_corners <- transformSelectedCorners(selected_corners(), img, ranges, max.pixel.size)
+      if(nrow(transformed_corners) > 0){
+        if(isolate(input$region_type == "Polygon")){
+          g <- g +
+            ggplot2::geom_polygon(aes(x = x, y = y), data = transformed_corners, alpha = input$alpha, color = "red")
+        } else {
+          circle <- makeCircleData(transformed_corners)
+          g <- g +
+            ggforce::geom_ellipse(aes(x0 = as.numeric(x), y0 = as.numeric(y), a = as.numeric(rx), b = as.numeric(ry), angle = 0), 
+                                  data = circle, alpha = input$alpha, color = "red", fill = "red")         
+        }
+        g <- g +
+          ggplot2::geom_point(aes(x = x, y = y), data = transformed_corners, color = "red", shape = 16) 
+      }
+      
+      # visualize already selected regions ####
+      transformed_corners_list <- lapply(selected_corners_list(), transformSelectedCorners, img, ranges, max.pixel.size)
+      if(length(transformed_corners_list) > 0){
+        for (i in seq_len(length(transformed_corners_list))){
+          cur_corners <- transformed_corners_list[[i]]
+          
+          # visualize regions
+          if(ncol(cur_corners) == 2){
+            g <- g +
+              ggplot2::geom_polygon(aes(x = x, y = y, group = "region"), data = cur_corners, alpha = input$alpha, color = "red") 
+          } else {
+            g <- g +
+              ggforce::geom_ellipse(aes(x0 = as.numeric(x), y0 = as.numeric(y), a = as.numeric(rx), b = as.numeric(ry), angle = 0), 
+                                    data = cur_corners, alpha = input$alpha, color = "red", fill = "red")
+          }
+          
+          # visualize labels
+          if(ncol(cur_corners) == 2){
+            cur_corners <- data.frame(x = mean(cur_corners[,1]), y = max(cur_corners[,2]), region = paste("Region ", isolate(textboxes()[i])))
+          } else {
+            cur_corners <- data.frame(x = cur_corners[,1], y = cur_corners[,2] + cur_corners[,3], region = paste("Region ", isolate(textboxes()[i])))
+          }
+          g <- g +
+            ggrepel::geom_label_repel(mapping = aes(x = x, y = y, label = region), data = cur_corners,
+                                      size = input$label_size, direction = "y", nudge_y = 6, box.padding = 0, label.padding = input$label_size*0.1, seed = 1, color = "red")
+          
+        }
+      }
+      
+      # return graph
+      g
+    })
+    
+    # Return values for the shiny app ####
+    observe({
+      if(length(selected_corners_list()) > 0){
+        shinyjs::show(id = "done")
+      } else {
+        shinyjs::hide(id = "done")
+      }
+    })
+    observeEvent(input$done, {
+      
+      # selected list
+      selected_polygon_list <- selected_corners_list()
+      
+      # collect labels
+      selected_label_list <- vapply(seq_len(length(selected_polygon_list)), function(i) input[[paste0("region",i)]], character(1))
+      
+      if(length(selected_corners_list()) == 0){
+        showNotification("You have not annotated the data yet!")
+      } else if(any(selected_label_list == "")) {
+        showNotification("Some regions have blank annotations (empty labels!)")
+      } else {
+        
+        ### annotate spatial points ####
+        if(inherits(metadata, "data.table")){
+          spatialpoints <- as.vector(metadata$id)
+        } else {
+          spatialpoints <- rownames(metadata)
+        }
+        
+        new_label <- rep("undefined", length(spatialpoints))
+        names(new_label) <- spatialpoints
+        result_list <- list()
+        for(i in seq_len(length(selected_polygon_list))){
+          cur_poly <- selected_polygon_list[[i]]
+          if(ncol(cur_poly) > 2){
+            in.list <- point.in.circle(coords[,1], coords[,2], cur_poly[,1], cur_poly[,2], cur_poly[,3])
+          } else {
+            in.list <- sp::point.in.polygon(coords[,1], coords[,2], cur_poly[,1], cur_poly[,2])
+          }
+          new_label[rownames(coords)[!!in.list]] <- selected_label_list[i]
+        }
+        
+        # place annotation to metadata
+        metadata[[label]] <- new_label
+        Metadata(object, assay = sample_metadata[assay, "Assay"]) <- metadata
+        
+        # add polygons to a new assay ####
+        segments <- list()
+        for(i in seq_len(length(selected_label_list))){
+          segments[[selected_label_list[i]]] <- data.frame(id = i, selected_polygon_list[[i]])
+        }
+        coords <- t(vapply(segments, function(seg){
+          apply(seg[,c("x", "y")], 2, mean)
+        }, numeric(2)))
+        new_assay <- formAssay(coords = coords, 
+                               segments = segments,
+                               type = "ROI",
+                               image = vrImages(object, assay = assay),
+                               main_image = vrMainImage(object[[assay]]),
+                               name = assay)
+        metadata <- data.frame(check.rows = FALSE, row.names = rownames(coords), selected_label_list)
+        colnames(metadata) <- label
+        object <- addAssayVoltRon(object,
+                                  assay = new_assay,
+                                  metadata = metadata,
+                                  assay_name = annotation_assay,
+                                  sample = sample_metadata[assay, "Sample"],
+                                  layer = sample_metadata[assay, "Layer"])
+        
+        # stop app and return
+        stopApp(object)
+      }
+    })
+  }
+  
+  # Run App ####
+  shiny.options <- configure_shiny_options(shiny.options)
+  shiny::runApp(
+    shiny::shinyApp(ui, server, options = list(host = shiny.options[["host"]], port = shiny.options[["port"]], launch.browser = shiny.options[["launch.browser"]]),
+                    onStart = function() {
+                      onStop(function() {
+                      })
+                    })
+  )
+}
+
+####
+# Annotation Utilities ####
+####
+
+manageImageBrush <- function(image, ranges, max.pixel.size, input, output, session){
+  imginfo <- getImageInfo(image)
+  observeEvent(input$plot_dblclick, {
+    brush <- isolate(input$plot_brush)
+    if (!is.null(brush)) {
+      
+      # get brush
+      brush_mat <- data.frame(x = c(brush$xmin, brush$xmax), 
+                              y = c(brush$ymin, brush$ymax))
+      
+      # if width is large, then correct the brush event for the downsize (scaling) effect
+      limits <- data.frame(x = ranges$x, y = ranges$y)
+      width <- limits[2,1]-limits[1,1]
+      height <- limits[2,2]-limits[1,2]
+      if(max(height,width) > max.pixel.size){
+        if(inherits(image, "Image_Array")){
+          n.series <- ImageArray::len(image)
+          cur_width <- width
+          cur_height <- height
+          for(ii in 2:n.series){
+            cur_width <- width/(2^(ii-1))
+            cur_height <- height/(2^(ii-1))
+            if(max(cur_height, cur_width) <= max.pixel.size){
+              break
+            }
+          }
+          brush_mat <- brush_mat*width/ceiling(cur_width)
+        } else {
+          brush_mat <- brush_mat*width/max.pixel.size
+        }
+      }
+      
+      # correct brush for the zoom effect
+      brush_mat[,1] <- brush_mat[,1] + limits[1,1]
+      brush_mat[,2] <- brush_mat[,2] + limits[1,2]
+      brush_mat[1,1] <- floor(brush_mat[1,1])
+      brush_mat[1,2] <- floor(brush_mat[1,2])
+      brush_mat[2,1] <- ceiling(brush_mat[2,1])
+      brush_mat[2,2] <- ceiling(brush_mat[2,2])
+
+      # update ranges
+      ranges$x <- brush_mat[,1]
+      ranges$y <- brush_mat[,2]
+      
+    } else {
+      ranges$x <- c(0, imginfo$width)
+      ranges$y <- c(0, imginfo$height)
+    }
+  })
+}
+
+manageSelectedCorners <- function(selected_corners, image, ranges, max.pixel.size, input, output, session){
+  observeEvent(input$plot_click, {
+    brush <- isolate(input$plot_brush)
+    if(is.null(brush)) {
+      
+      # if a circle, dont allow more than two points
+      if(isolate(input$region_type == "Circle")){
+        if(nrow(selected_corners()) == 2){
+          selected_corners(data.frame(x = numeric(0), y = numeric(0)))
+        }
+      }
+      
+      # get points
+      click <- input$plot_click
+      pts <- c(click$x, click$y)
+
+      # correct for zoom effect
+      limits <- data.frame(x = ranges$x, y = ranges$y)
+      width <- limits[2,1]-limits[1,1]
+      height <- limits[2,2]-limits[1,2]
+      if(max(height,width) > max.pixel.size){
+        if(inherits(image, c("Image_Array"))){
+          n.series <- ImageArray::len(image)
+          cur_width <- width
+          cur_height <- height
+          for(ii in 2:n.series){
+            cur_width <- width/(2^(ii-1))
+            cur_height <- height/(2^(ii-1))
+            if(max(cur_height, cur_width) <= max.pixel.size){
+              break
+            }
+          }
+          pts <- pts*width/ceiling(cur_width)
+        } else {
+          pts <- pts*width/max.pixel.size
+        }
+      }
+    
+      # correct for offset effect
+      pts[1] <- pts[1] + limits[1,1]
+      pts[2] <- pts[2] + limits[1,2]
+      
+      # Append new point to the data frame
+      new_point <- data.frame(x = pts[1], y = pts[2])
+      
+      # add new point
+      selected_corners(rbind(selected_corners(), new_point))
+    }
+  })
+}
+
+transformSelectedCorners <- function(selected_corners, image, ranges, max.pixel.size){
+  
+  # if empty, return
+  if(nrow(selected_corners) == 0){
+    return(selected_corners)
+  }
+  selected_corners <- as.matrix(selected_corners)
+  
+  # circle settings
+  circle <- FALSE
+  if(ncol(selected_corners) > 2)
+    circle <- TRUE
+  
+  # get circle radius 
+  if(circle){
+    selected_radius <- selected_corners[,3:4, drop = FALSE]
+    selected_corners <- selected_corners[,seq_len(2), drop = FALSE]
+  }
+  
+  # get image info
+  imginfo <- getImageInfo(image)
+  
+  # correct for offset effect
+  limits <- cbind(ranges$x, ranges$y)
+  selected_corners <- selected_corners - matrix(rep(limits[1,], nrow(selected_corners)), nrow = nrow(selected_corners), byrow = T)
+
+  # correct for zoom effect
+  width <- limits[2,1]-limits[1,1]
+  height <- limits[2,2]-limits[1,2]
+  if(max(height,width) > max.pixel.size){
+    if(inherits(image, "Image_Array")){
+      n.series <- ImageArray::len(image)
+      cur_width <- width
+      cur_height <- height
+      for(ii in 2:n.series){
+        cur_width <- width/(2^(ii-1))
+        cur_height <- height/(2^(ii-1))
+        if(max(cur_height, cur_width) <= max.pixel.size){
+          break
+        }
+      }
+      selected_corners <- selected_corners*ceiling(cur_width)/width
+      if(circle){
+        selected_radius <- selected_radius*ceiling(cur_width)/width
+      }
+    } else {
+      selected_corners <- selected_corners*max.pixel.size/width
+      if(circle){
+        selected_radius <- selected_radius*max.pixel.size/width
+      }
+    }
+  }
+  
+  # make data frame
+  if(circle){
+    selected_corners <- as.data.frame(cbind(selected_corners,selected_radius))
+    colnames(selected_corners) <- c("x", "y", "rx", "ry")
+  } else {
+    selected_corners <- as.data.frame(selected_corners)
+    colnames(selected_corners) <- c("x", "y") 
+  }
+  
+  # return
+  selected_corners
+}
+
+#' @importFrom stats na.omit
+transformSpatialLayer <- function(g_spatial, image, ranges, max.pixel.size){
+  
+  # correct for zoom
+  ind <- (g_spatial$data$x > ranges$x[1] & g_spatial$data$x < ranges$x[2]) & (g_spatial$data$y > ranges$y[1] & g_spatial$data$y < ranges$y[2])
+  g_spatial$data <- g_spatial$data[ind,]
+  
+  # is.na
+  g_spatial$data <- stats::na.omit(g_spatial$data)
+  
+  # correct for zoom effect
+  limits <- data.frame(x = ranges$x, y = ranges$y)
+  width <- limits[2,1]-limits[1,1]
+  height <- limits[2,2]-limits[1,2]
+  if(max(height,width) > max.pixel.size){
+    if(inherits(image, "Image_Array")){
+      n.series <- ImageArray::len(image)
+      cur_width <- width
+      cur_height <- height
+      for(ii in 2:n.series){
+        cur_width <- width/(2^(ii-1))
+        cur_height <- height/(2^(ii-1))
+        if(max(cur_height, cur_width) <= max.pixel.size){
+          break
+        }
+      }
+      g_spatial$data$x <- g_spatial$data$x*ceiling(cur_width)/width
+      g_spatial$data$y <- g_spatial$data$y*ceiling(cur_width)/width
+    } else {
+      g_spatial$data$x <- g_spatial$data$x*max.pixel.size/width
+      g_spatial$data$y <- g_spatial$data$y*max.pixel.size/width
+    }
+  }
+  
+  # correct for offset effect
+  # g_spatial$data$x <- g_spatial$data$x - min(g_spatial$data$x)
+  # g_spatial$data$y <- g_spatial$data$y - min(g_spatial$data$y)
+  g_spatial$data$x <- g_spatial$data$x - limits[1,1]
+  g_spatial$data$y <- g_spatial$data$y - limits[1,2]
+  
+  # return
+  g_spatial
+}
+
+####
+# Shiny Utilities ####
+####
+
+#' internal Text input with button
+#' 
+#' Reproduced since it is not exported in the Shiny namespace.
+#' 
+#' @importFrom shiny tags validateCssUnit
+#' 
+#' @keywords internal
+textInputwithButton <- function (textinputId, label, buttoninputId, value = "", width = NULL, placeholder = NULL, ...) 
+{
+  textvalue <- restoreInput(id = textinputId, default = value)
+  buttonvalue <- restoreInput(id = buttoninputId, default = NULL)
+  div(class = "form-group shiny-input-container", 
+      style =  css(width = shiny::validateCssUnit(width), display = "inline-block"),
+      shinyInputLabel(textinputId, label), 
+      shiny::tags$input(id = textinputId, 
+                        style = css(width = "80%", float = "left"),
+                        type = "text", class = "shiny-input-text form-control", 
+                        value = textvalue, placeholder = placeholder),
+      shiny::tags$button(id = buttoninputId, 
+                         style = css(width = "20%", float = "left"),
+                         type = "button", class = "btn btn-default action-button", 
+                         `data-val` = buttonvalue, disabled = NULL, list(shiny::icon("trash")), ...)
+  )
+}
+
+#' Shiny's internal \code{shinyInputLabel} function
+#' 
+#' Reproduced since it is not exported in the Shiny namespace.
+#' 
+#' @importFrom shiny tags
+#' 
+#' @keywords internal
+shinyInputLabel <- function(inputId, label=NULL) {
+  shiny::tags$label(label,
+                    class = "control-label",
+                    class = if (is.null(label)) "shiny-label-null",
+                    `for` = inputId
+  )
+}
+
+####
+# Auxiliary ####
+####
+
+#' makeCircleData
+#' 
+#' creates circle ROI from selected corners
+#' 
+#' @keywords internal
+makeCircleData <- function(selected_corners) {
+  radius <- sqrt((selected_corners[1,1] - selected_corners[2,1])^2 + (selected_corners[1,2] - selected_corners[2,2])^2)
+  data.frame(x = selected_corners[1,1], y = selected_corners[1,2], rx = radius, ry = radius)
+}
+
+#' point.in.circle
+#' 
+#' checks if points are in the defined circle ROI with a (x,y) center and radius
+#' 
+#' @keywords internal
+point.in.circle <- function(x,y,circle.x, circle.y, radius) {
+  x <- x - circle.x
+  y <- y - circle.y
+  distall <- sqrt((x - circle.x)^2 + (y - circle.y)^2)
+  return(distall < radius)
+}
\ No newline at end of file