Systems and methods utilizing improved cell boundary definition in biological images

Abstract

A system and method for defining cell boundaries in a biological image using an improved file structure is disclosed. Cell boundaries are simulated using non-intersecting polygonal paths along the cell boundaries. Cartesian coordinates of a starting vertex of the polygon and polar coordinates of steps between vertices along the polygon path are stored in a data structure. Each step length is compressed in a single byte in a three-part bit mode. The final file containing the data structure defines the cell boundary in the biological image through compression storage, and data transmission and processing of spatial bioinformatics are improved.

Description

[0001] Cross - Reference to Related Applications This application claims the benefit of U.S. Provisional Application No. 63 / 434,361, filed on December 21, 2022, the entire content of which is incorporated herein by reference. Background Art

[0002] Spatial biology research combines whole-slide imaging at single-cell resolution to visualize and quantify the expression of biomarkers and to reveal how cells interact and organize within the context of an entire tissue. Conducting a widely applicable and comprehensive morphometric analysis of the complex bioinformatics in bioimaging data remains a challenging task. Summary of the Invention

[0003] Cells are the basic units of life, and studying individual cells in a cellular context such as cell cultures or biological tissues provides a powerful tool for various aspects of research. Medical and biological images are growing rapidly in terms of data scale and information content. For example, single-cell imagers utilize successive cycles of probe hybridization and imaging, promising to combine the advantages of single-cell RNA sequencing analysis with additional spatial resolution at the single-cell and even subcellular levels while retaining cell position information. Cell image data can be two-dimensional and / or three-dimensional. In addition, "omics" data in spatial bioinformatics (such as genomic data, proteomic data, metabolomic data, metagenomic data, phenomic data, and / or transcriptomic data) are associated with cell image data as metadata and / or overlays of the images.

[0004] Image segmentation software and methods have been used to define cell boundaries based on polygonal paths along cell boundaries in biological cell images. However, biological cell images may contain data of millions of cells. The storage, transmission, and display of cell image data may require huge resources, bandwidth, and time. Most importantly, rendering data on the client side is too slow and consumes too much computing resources. The GUI allows users to pan and zoom the image, and when performing this operation, it is necessary to render and re-render the cell boundaries.

[0005] A common method of describing a polygonal path is to use the Cartesian coordinates of the starting vertex and the differences in all dimensions of ordered adjacent vertex pairs, such as ΔX and ΔY. Therefore, at least 2 bytes are required to describe each step length of the polygonal path. Thus, there is a need to improve the file that defines cell boundaries, which contains a data structure that can describe each step length with less storage space.

[0006] Accordingly, on the one hand, the present invention discloses a computer-implemented method for generating a computer-implemented method for generating a defined biological image data file, which includes: a) retrieving, by a computer, the Cartesian coordinates of the vertices of non-intersecting polygons and following the polygonal path of the cell boundaries in the biological image, maintaining these vertices in the order from the starting vertex to the last vertex; b) storing, by a computer, the Cartesian coordinates of the starting vertex of the polygon in a data structure; c) calculating, by a computer, the distance between the starting vertex and the last vertex; d) selecting, by a computer, a matrix containing edge elements to represent different directions based on the distance; e) designating, by a computer, the Cartesian coordinates of the first vertex in the ordered adjacent vertex pair as the polar reference coordinates of the matrix; f) converting, by a computer, the Cartesian coordinates of the second vertex in the ordered adjacent vertex pair into the reference of the polar coordinates of the corresponding matrix; g) designating, by a computer in combination with the size of the matrix, the step size of the first vertex in the ordered adjacent vertex pair as the edge element of the second vertex; h) storing, by a computer, the step sizes of the vertices in the data structure in the order of the polygonal path; i) storing, by a computer through iteration of e)-h), the step sizes of all vertices in the data structure; and, j) generating, by a computer, a file defining the cell boundary from the data structure. In some embodiments, the vertices are maintained in an array. In some embodiments, the method further includes performing, by a computer, a quality assurance check on the Cartesian coordinates of the received non-intersecting polygon vertices, wherein the quality assurance check includes one or more of the following: checking whether the polygon contains at least 3 vertices; checking whether the polygonal path contains a closed loop; checking whether the polygonal path contains a predefined direction; and checking whether the vertex order along the polygonal path is a continuous order. In some embodiments, the step size includes a long step size. In some embodiments, the step size includes a short step size. In some embodiments, the matrix includes a 3X3, 4X4, 5X5, 6X6, 7X7, 8X8, 9X9, 10X10, 11X11, 12X12, 13X13, 14X14, 15X15, 16X16, 17X17, 18X18, 19X19, 20X20, 21X21, 22X22, 23X23, 24X24, 25X25, 26X26, 27X27, 28X28, 29X29, 30X30, 31X31, 32X32 or 33X33 matrix. In some embodiments, the data structure includes 1 bit, 2 bits, 3 bits, 4 bits, 5 bits, 6 bits, 7 bits or 8 bits for storing each step size. In some embodiments, the data structure includes 1 byte, 2 bytes, 3 bytes or 4 bytes for storing each step size. In some embodiments, the method in h) further includes storing a terminator for the last vertex of the polygon. In some embodiments, the method further includes receiving a biological image. In some embodiments, the biological image includes a 2D image.In some embodiments, the Cartesian coordinates are 2D coordinates. In some embodiments, the biological image includes a 3D image. In some embodiments, the Cartesian coordinates are 3D coordinates. In some embodiments, the distance includes the Euclidean distance. In some embodiments, the distance includes the difference in one-dimensional Cartesian coordinates. In some embodiments, the distance includes the maximum value of the Cartesian coordinate differences in all dimensions. In some embodiments, the distance includes the minimum value of the Cartesian coordinate differences in all dimensions. In some embodiments, the distance includes the arithmetic mean of the Cartesian coordinate differences in all dimensions. In some embodiments, the method further includes compressing, by a computer, the data of all vertices of the cell boundary in a data structure. In some embodiments, the computer includes a client computing device. In some embodiments, the method further includes rendering the cell boundary on a GUI. In some embodiments, the method further includes rendering 100K, 500K, 1M, 5M, or 10M cell boundaries. In some embodiments, the file includes the definition of 100K, 500K, 1M, 5M, or 10M cell boundaries.

[0007] On the other hand, the present invention discloses a computer-implemented system, which includes at least one processor and instructions executable by the at least one processor to provide an application program. The application program includes: a) a software module for retrieving the Cartesian coordinates of the vertices of non-intersecting polygons, following the polygonal path of the cell boundary in a biological image, and maintaining these vertices in the order from the starting vertex to the last vertex; b) a software module for storing the Cartesian coordinates of the starting vertex of the polygon in a data structure; c) a software module for calculating the distance between the starting vertex and the last vertex; d) a software module for selecting a matrix containing edge elements to represent different directions based on the distance; e) a software module for designating the Cartesian coordinates of the first vertex in an ordered adjacent vertex pair as the polar reference coordinates of the matrix; f) a software module for converting the Cartesian coordinates of the second vertex in the ordered adjacent vertex pair into the reference of the polar coordinates of the corresponding matrix; g) a software module for designating the step size of the first vertex in the ordered adjacent vertex pair as the edge element of the second vertex in combination with the matrix size; h) a software module for storing the step sizes of the vertices in the data structure in the order of the polygonal path; i) a software module for storing the step sizes of all vertices in the data structure by iterating e)-h); j) a software module for generating a file defining the cell boundary from the data structure. In some embodiments, the vertices are maintained in an array. In some embodiments, the application program further includes a software module for performing a quality assurance check on the received Cartesian coordinates of the vertices of non-intersecting polygons, wherein the quality assurance check includes one or more of the following: checking whether the polygon contains at least 3 vertices; checking whether the polygonal path contains a closed loop; checking whether the polygonal path contains a predefined direction; and checking whether the vertex order along the polygonal path is a continuous order. In some embodiments, the step sizes include long step sizes. In some embodiments, the step sizes include short step sizes. In some embodiments, the matrix includes a 3X3, 4X4, 5X5, 6X6, 7X7, 8X8, 9X9, 10X10, 11X11, 12X12, 13X13, 14X14, 15X15, 16X16, 17X17, 18X18, 19X19, 20X20, 21X21, 22X22, 23X23, 24X24, 25X25, 26X26, 27X27, 28X28, 29X29, 30X30, 31X31, 32X32 or 33X33 matrix. In some embodiments, the data structure includes 1 bit, 2 bits, 3 bits, 4 bits, 5 bits, 6 bits, 7 bits or 8 bits for storing each step size. In some embodiments, the data structure includes 1 byte, 2 bytes, 3 bytes or 4 bytes for storing each step size. In some embodiments, the software module in h) further includes a terminator for storing the last vertex of the polygon.In some embodiments, the application further includes a software module for receiving a biological image. In some embodiments, the biological image includes a 2D image. In some embodiments, the Cartesian coordinates are 2D coordinates. In some embodiments, the biological image includes a 3D image. In some embodiments, the Cartesian coordinates are 3D coordinates. In some embodiments, the distance includes the Euclidean distance. In some embodiments, the distance includes the difference of one-dimensional Cartesian coordinates. In some embodiments, the distance includes the maximum value of the Cartesian coordinate differences in all dimensions. In some embodiments, the distance includes the minimum value of the Cartesian coordinate differences in all dimensions. In some embodiments, the distance includes the arithmetic mean of the Cartesian coordinate differences in all dimensions. In some embodiments, the application further includes a software module for compressing the data of all vertices of the cell boundary in the data structure. In some embodiments, the system includes a client computing device. In some embodiments, the application further includes a software module for rendering the cell boundary on the GUI. In some embodiments, the software module further includes rendering the cell boundary of 100K, 500K, 1M, 5M, or 10M. In some embodiments, the file includes the definition of the cell boundary of 100K, 500K, 1M, 5M, or 10M.

[0008] In another aspect, the present invention discloses a non-transitory computer-readable storage medium encoded with instructions executable by one or more processors to cause the one or more processors to perform operations including: a) retrieving Cartesian coordinates of vertices of non-intersecting polygons; b) following a polygonal path of a cell boundary in a biological image and maintaining these vertices in order from a starting vertex to a last vertex; c) storing the Cartesian coordinates of the starting vertex of the polygon in a data structure; d) calculating the distance between the starting vertex and the last vertex; e) selecting a matrix containing edge elements to represent different directions based on the distance; f) designating the Cartesian coordinates of the first vertex in an ordered adjacent vertex pair as the polar reference coordinates of the matrix; g) converting the Cartesian coordinates of the second vertex in the ordered adjacent vertex pair into the reference of the polar coordinates of the corresponding matrix; h) designating the step size of the first vertex in the ordered adjacent vertex pair as the edge element of the second vertex in combination with the size of the matrix; i) storing the step sizes of the vertices in the data structure in the order of the polygonal path; j) storing the step sizes of all vertices in the data structure by iterating f)-i); and k) generating a file defining the cell boundary from the data structure. In some embodiments, the vertices are maintained in an array. In some embodiments, the operations further include performing a quality assurance check on the received Cartesian coordinates of the non-intersecting polygon vertices, wherein the quality assurance check includes one or more of the following: checking whether the polygon contains at least 3 vertices; checking whether the polygonal path contains a closed loop; checking whether the polygonal path contains a predefined direction; and checking whether the vertex order along the polygonal path is a consecutive order. In some embodiments, the step sizes include long step sizes. In some embodiments, the step sizes include short step sizes. In some embodiments, the matrix includes a 3X3, 4X4, 5X5, 6X6, 7X7, 8X8, 9X9, 10X10, 11X11, 12X12, 13X13, 14X14, 15X15, 16X16, 17X17, 18X18, 19X19, 20X20, 21X21, 22X22, 23X23, 24X24, 25X25, 26X26, 27X27, 28X28, 29X29, 30X30, 31X31, 32X32 or 33X33 matrix. In some embodiments, the data structure includes 1 bit, 2 bits, 3 bits, 4 bits, 5 bits, 6 bits, 7 bits or 8 bits for storing each step size. In some embodiments, the data structure includes 1 byte, 2 bytes, 3 bytes or 4 bytes for storing each step size. In some embodiments, the operation in i) further includes storing a terminator for the last vertex of the polygon. In some embodiments, the operations further include receiving a biological image. In some embodiments, the biological image includes a 2D image. In some embodiments, the Cartesian coordinates are 2D coordinates.In some embodiments, the biological image includes a 3D image. In some embodiments, the Cartesian coordinates are 3D coordinates. In some embodiments, the distance includes the Euclidean distance. In some embodiments, the distance includes the difference in one-dimensional Cartesian coordinates. In some embodiments, the distance includes the maximum value of the Cartesian coordinate differences in all dimensions. In some embodiments, the distance includes the minimum value of the Cartesian coordinate differences in all dimensions. In some embodiments, the distance includes the arithmetic mean of the Cartesian coordinate differences in all dimensions. In some embodiments, the operation further includes compressing the data of all vertices of the cell boundary in the data structure. In some embodiments, the non-transitory computer-readable storage medium further includes a client computing device. In some embodiments, the operation further includes rendering the cell boundary on the GUI. In some embodiments, the operation further includes rendering 100K, 500K, 1M, 5M, or 10M cell boundaries. In some embodiments, the file includes the definition of 100K, 500K, 1M, 5M, or 10M cell boundaries.

[0009] In various embodiments, image segmentation software based on machine learning (ML) algorithms can be applied to create cell boundaries from fluorescence images of protein assays. In certain embodiments, the protein assay may include a protein antibody that binds to a membrane protein. In some embodiments, the ML algorithms applied to image segmentation may include semantic segmentation, instance segmentation, generative networks for segmentation. In some embodiments, the image segmentation software may include ImagedJ, CellProfiller, Cellpose, Ilastik, and / or QuPath. BRIEF DESCRIPTION OF THE DRAWINGS

[0010] In conjunction with the accompanying drawings, the features and advantages of the present invention can be better understood by referring to the following detailed description of exemplary embodiments, wherein: Figure 1 Shows a non-limiting example of a computing device; in this case, the device has one or more processors, memory, a storage device, and a network interface; Figure 2 Shows a non-limiting example of a web / mobile application providing system; in this case, the system provides a browser-based and / or native mobile user interface; Figure 3 Shows a non-limiting example of a cloud-based web / mobile application providing system; in this case, the system includes elastic load balancing, auto-scaling web server and application server resources, and a synchronously replicated database; Figure 4A and 4BShows a non - limiting example of a matrix; in this case, the edge of the matrix holds a number that represents the polar coordinate reference created from the center to the edge of the peripheral position where the number is located; Figure 5 Shows a non - limiting example of a fast polygon self - intersection test for moving vertices; Figure 6A and 6B Shows a non - limiting example of fast polygon mask filling using line direction; and Figures 7A - 7E Shows a non - limiting example of the cell segmentation verification shown in Example 2.

[0011] Incorporation by reference All publications, patents, and patent applications mentioned in this specification are hereby incorporated by reference for the specific purposes indicated herein. Detailed description

[0012] In some embodiments, the present invention discloses a computer-implemented method for generating a computer file defining a biological image data, which includes: a) retrieving, by a computer, the Cartesian coordinates of the vertices of a non-intersecting polygon and following the polygonal path of the cell boundaries in the biological image, and maintaining these vertices in order from the starting vertex to the last vertex; b) storing, by a computer, the Cartesian coordinates of the starting vertex of the polygon in a data structure; c) calculating, by a computer, the distance between the starting vertex and the last vertex; d) selecting, by a computer, a matrix containing edge elements to represent different directions based on the distance; e) designating, by a computer, the Cartesian coordinates of the first vertex in an ordered adjacent vertex pair as the polar reference coordinates of the matrix; f) converting, by a computer, the Cartesian coordinates of the second vertex in the ordered adjacent vertex pair into the polar coordinates of the matrix; g) designating, by a computer in combination with the size of the matrix, the step of the first vertex in the ordered adjacent vertex pair as the edge element of the second vertex; h) storing, by a computer, the steps of the vertices in the data structure in the order of the polygonal path; i) storing, by a computer through iterating e)-h), the steps of all vertices in the data structure; and j) generating, by a computer, a file defining the cell boundary from the data structure. In some embodiments, the vertices are maintained in an array. In some embodiments, the method further includes performing, by a computer, a quality assurance check on the received Cartesian coordinates of the non-intersecting polygon vertices, wherein the quality assurance check includes one or more of the following: checking whether the polygon contains at least 3 vertices; checking whether the polygonal path contains a closed loop; checking whether the polygonal path contains a predefined direction; and checking whether the order of the vertices along the polygonal path is a continuous order. In some embodiments, the step includes a long step. In some embodiments, the step includes a short step. In some embodiments, the matrix includes a 3X3, 4X4, 5X5, 6X6, 7X7, 8X8, 9X9, 10X10, 11X11, 12X12, 13X13, 14X14, 15X15, 16X16, 17X17, 18X18, 19X19, 20X20, 21X21, 22X22, 23X23, 24X24, 25X25, 26X26, 27X27, 28X28, 29X29, 30X30, 31X31, 32X32 or 33X33 matrix. In some embodiments, the data structure includes 1 bit, 2 bits, 3 bits, 4 bits, 5 bits, 6 bits, 7 bits or 8 bits for storing each step. In some embodiments, the data structure includes 1 byte, 2 bytes, 3 bytes or 4 bytes for storing each step. In some embodiments, the method in h) further includes storing a terminator for the last vertex of the polygon. In some embodiments, the method further includes receiving a biological image. In some embodiments, the biological image includes a 2D image.In some embodiments, the Cartesian coordinates are 2D coordinates. In some embodiments, the biological image includes a 3D image. In some embodiments, the Cartesian coordinates are 3D coordinates. In some embodiments, the distance includes the Euclidean distance. In some embodiments, the distance includes the difference of one-dimensional Cartesian coordinates. In some embodiments, the distance includes the maximum value of the Cartesian coordinate differences of all dimensions. In some embodiments, the distance includes the minimum value of the Cartesian coordinate differences of all dimensions. In some embodiments, the distance includes the arithmetic mean of the Cartesian coordinate differences of all dimensions. In some embodiments, the method further includes compressing, by a computer, data of all vertices of a cell boundary in a data structure. In some embodiments, the computer includes a client computing device. In some embodiments, the method further includes rendering the cell boundary on a GUI. In some embodiments, the method further includes rendering 100K, 500K, 1M, 5M, or 10M cell boundaries. In some embodiments, the file includes definitions of 100K, 500K, 1M, 5M, or 10M cell boundaries.

[0013] In some embodiments, the present invention discloses a computer-implemented system that includes at least one processor and instructions executable by the at least one processor to provide an application program, the application program including: a) a software module for retrieving the Cartesian coordinates of the vertices of non-intersecting polygons and following the polygonal path of the cell boundary in a biological image, maintaining these vertices in order from the starting vertex to the last vertex; b) a software module for storing the Cartesian coordinates of the starting vertex of the polygon in a data structure; c) a software module for calculating the distance between the starting vertex and the last vertex; d) a software module for selecting a matrix containing edge elements to represent different directions based on the distance; e) a software module for designating the Cartesian coordinates of the first vertex in an ordered adjacent vertex pair as the polar reference coordinates of the matrix; f) a software module for converting the Cartesian coordinates of the second vertex in the ordered adjacent vertex pair into the polar coordinates of the matrix; g) a software module for, in combination with the matrix size, designating the step of the first vertex in the ordered adjacent vertex pair as the edge element of the second vertex; h) a software module for storing the step of the vertex in the data structure in the order of the polygonal path; i) a software module for storing the steps of all vertices in the data structure by iterating e)-h); j) a software module for generating a file defining the cell boundary from the data structure. In some embodiments, the vertices are maintained in an array. In some embodiments, the application program further includes a software module for performing a quality assurance check on the received Cartesian coordinates of the vertices of non-intersecting polygons, wherein the quality assurance check includes one or more of the following: checking whether the polygon contains at least 3 vertices; checking whether the polygonal path contains a closed loop; checking whether the polygonal path contains a predefined direction; and checking whether the vertex order along the polygonal path is a continuous order. In some embodiments, the step includes a long step. In some embodiments, the step includes a short step. In some embodiments, the matrix includes a 3X3, 4X4, 5X5, 6X6, 7X7, 8X8, 9X9, 10X10, 11X11, 12X12, 13X13, 14X14, 15X15, 16X16, 17X17, 18X18, 19X19, 20X20, 21X21, 22X22, 23X23, 24X24, 25X25, 26X26, 27X27, 28X28, 29X29, 30X30, 31X31, 32X32, or 33X33 matrix. In some embodiments, the data structure includes 1 bit, 2 bits, 3 bits, 4 bits, 5 bits, 6 bits, 7 bits, or 8 bits for storing each step. In some embodiments, the data structure includes 1 byte, 2 bytes, 3 bytes, or 4 bytes for storing each step. In some embodiments, the software module in h) further includes a terminator for storing the last vertex of the polygon.In some embodiments, the application further includes a software module for receiving a biological image. In some embodiments, the biological image includes a 2D image. In some embodiments, the Cartesian coordinates are 2D coordinates. In some embodiments, the biological image includes a 3D image. In some embodiments, the Cartesian coordinates are 3D coordinates. In some embodiments, the distance includes the Euclidean distance. In some embodiments, the distance includes the difference of one-dimensional Cartesian coordinates. In some embodiments, the distance includes the maximum value of the Cartesian coordinate differences in all dimensions. In some embodiments, the distance includes the minimum value of the Cartesian coordinate differences in all dimensions. In some embodiments, the distance includes the arithmetic mean of the Cartesian coordinate differences in all dimensions. In some embodiments, the application further includes a software module for compressing the data of all vertices of the cell boundary in the data structure. In some embodiments, the system further includes a client computing device. In some embodiments, the application further includes a software module for rendering the cell boundary on the GUI. In some embodiments, the software module further includes rendering the cell boundaries of 100K, 500K, 1M, 5M, or 10M. In some embodiments, the file includes the definition of the cell boundaries of 100K, 500K, 1M, 5M, or 10M.

[0014] In some embodiments, the present invention discloses a non - transitory computer - readable storage medium encoded with instructions executable by one or more processors to cause the one or more processors to perform operations including: a) retrieving Cartesian coordinates of vertices of non - intersecting polygons; b) following a polygonal path of a cell boundary in a biological image and maintaining these vertices in order from a starting vertex to a last vertex; c) storing the Cartesian coordinates of the starting vertex of the polygon in a data structure; d) calculating the distance between the starting vertex and the last vertex; e) selecting a matrix containing edge elements to represent different directions based on the distance; f) designating the Cartesian coordinates of the first vertex in an ordered adjacent vertex pair as the polar reference coordinates of the matrix; g) converting the Cartesian coordinates of the second vertex in the ordered adjacent vertex pair to polar coordinates of the matrix; h) combining the size of the matrix, designating the step of the first vertex in the ordered adjacent vertex pair as the edge element of the second vertex; i) storing the step of the vertex in the data structure in the order of the polygonal path; j) storing the steps of all vertices in the data structure by iterating f) - i); and k) generating a file defining the cell boundary from the data structure. In some embodiments, the vertices are maintained in an array. In some embodiments, the operations further include performing a quality - assurance check on the received Cartesian coordinates of the non - intersecting polygon vertices, where the quality - assurance check includes one or more of the following: checking whether the polygon contains at least 3 vertices; checking whether the polygonal path contains a closed loop; checking whether the polygonal path contains a predefined direction; and checking whether the vertex order along the polygonal path is a consecutive order. In some embodiments, the step includes a long step. In some embodiments, the step includes a short step. In some embodiments, the matrix includes a 3X3, 4X4, 5X5, 6X6, 7X7, 8X8, 9X9, 10X10, 11X11, 12X12, 13X13, 14X14, 15X15, 16X16, 17X17, 18X18, 19X19, 20X20, 21X21, 22X22, 23X23, 24X24, 25X25, 26X26, 27X27, 28X28, 29X29, 30X30, 31X31, 32X32, or 33X33 matrix. In some embodiments, the data structure includes 1 bit, 2 bits, 3 bits, 4 bits, 5 bits, 6 bits, 7 bits, or 8 bits for storing each step. In some embodiments, the data structure includes 1 byte, 2 bytes, 3 bytes, or 4 bytes for storing each step. In some embodiments, the operation in i) further includes storing a terminator for the last vertex of the polygon. In some embodiments, the operations further include receiving a biological image. In some embodiments, the biological image includes a 2D image. In some embodiments, the Cartesian coordinates are 2D coordinates.In some embodiments, the biological image includes a 3D image. In some embodiments, the Cartesian coordinates are 3D coordinates. In some embodiments, the distance includes the Euclidean distance. In some embodiments, the distance includes the difference of one-dimensional Cartesian coordinates. In some embodiments, the distance includes the maximum value of the Cartesian coordinate differences in all dimensions. In some embodiments, the distance includes the minimum value of the Cartesian coordinate differences in all dimensions. In some embodiments, the distance includes the arithmetic mean of the Cartesian coordinate differences in all dimensions. In some embodiments, the operation further includes compressing the data of all vertices of the cell boundary in the data structure. In some embodiments, the non-transitory computer-readable medium further includes a client computing device. In some embodiments, the operation further includes rendering the cell boundary on the GUI. In some embodiments, the operation further includes rendering 100K, 500K, 1M, 5M, or 10M cell boundaries. In some embodiments, the file includes the definition of 100K, 500K, 1M, 5M, or 10M cell boundaries.

[0015] Some Definitions Unless otherwise defined, all technical terms used in the present invention have the same meaning as commonly understood by those of ordinary skill in the art to which the present invention belongs.

[0016] As used in this specification and the appended claims, the singular forms "a", "an", and "the" include their plural referents unless the context clearly dictates otherwise. Any reference to "or" herein is intended to include "and / or" unless otherwise stated.

[0017] The "some embodiments", "other embodiments", or "specific embodiments" referred to throughout this specification refer to specific features, structures, or characteristics related to the description of that embodiment being included in at least one embodiment. Thus, the appearances of the phrases "in some embodiments", "in other embodiments", or "in specific embodiments" throughout this specification do not necessarily all refer to the same embodiment. Additionally, the specific features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

[0018] Computing System Reference Figure 1 , which shows a block diagram depicting an exemplary machine that includes a computer system 100 (e.g., a processing or computing system) within which a set of instructions can be executed to cause the device to perform or implement one or more aspects and / or methods of static code scheduling in the present invention. Figure 1 The components in are provided only as examples and do not limit the scope of use or functionality of any hardware, software, embedded logic components, or combinations of two or more such components for implementing a particular embodiment.

[0019] The computer system 100 may include one or more processors 101, a memory 103, and a storage device 108, which communicate with each other and with other components via a bus 140. The bus 140 may also connect a display 132, one or more input devices 133 (e.g., may include a keypad, a keyboard, a mouse, a stylus, etc.), one or more output devices 134, one or more additional storage devices 135, and various tangible storage media 136. All of these elements may be connected to the bus 140 directly or through one or more interfaces or adapters. For example, the various tangible storage media 136 may be connected to the bus 140 via a storage media interface 126. The computer system 100 may have any suitable physical form, including but not limited to one or more integrated circuits (ICs), a printed circuit board (PCB), a mobile handheld device (e.g., a mobile phone or a PDA), a laptop or notebook computer, a distributed computer system, a computing grid, or a server.

[0020] The computer system 100 includes one or more processors 101 (e.g., a central processing unit (CPU), a general-purpose graphics processing unit (GPGPU), or a quantum processing unit (QPU)) that perform functions. The processor 101 optionally includes a cache storage unit 102 for temporarily storing locally instructions, data, or computer addresses. The processor 101 is configured to assist in the execution of computer-readable instructions. Since the processor 101 executes non-transitory, processor-executable instructions embodied in one or more tangible computer-readable storage media (e.g., the memory 103, the storage device 108, the storage device 135, and / or the storage media 136), the computer system 100 may be Figure 1 providing functions for the components shown. The computer-readable medium may store software implementing a particular embodiment, and the processor 101 may execute the software. The memory 103 may read software from one or more other computer-readable media (e.g., the mass storage devices 135, 136) or from one or more other sources via a suitable interface, such as a network interface 120. The software may cause the processor 101 to execute one or more processes or one or more steps of one or more processes described or shown in the present invention. Executing such processes or steps may include defining data structures stored in the memory 103 and modifying the data structures according to the instructions of the software.

[0021] The memory 103 may include various components (e.g., machine-readable media), including but not limited to random access memory components (such as RAM 104) (e.g., static RAM (SRAM), dynamic RAM (DRAM), ferroelectric random access memory (FRAM), phase change random access memory (PRAM), etc.), read-only memory components (such as ROM 105), and any combination thereof. The ROM 105 can be used to unidirectionally transfer data and instructions to the processor 101, while the RAM 104 can be used to bidirectionally transfer data and instructions with the processor 101. The ROM 105 and the RAM 104 can include any suitable tangible computer-readable media described below. In one example, a basic input / output system 106 (BIOS) including basic routines that help transfer information between elements within the computer system 100 during startup, for example, can be stored in the memory 103.

[0022] The fixed memory 108 is optionally bidirectionally connected to the processor 101 through a storage control unit 107. The fixed memory 108 provides additional data storage capabilities and can also include any suitable tangible computer-readable media described herein. The memory 108 can be used to store an operating system 109, executable files 110, data 111, applications 112 (application programs), etc. The memory 108 can also include an optical disk drive, a solid-state memory device (e.g., based on a flash memory system), or any combination of the above. In an appropriate case, the information in the memory 108 can be incorporated into the memory 103 as virtual memory.

[0023] In one example, the storage device 135 can be detachably connected to the computer system 100 through a storage device interface 125 (e.g., through an external port connector (not shown)). Specifically, the storage device 135 and the associated machine-readable media can provide non-volatile and / or volatile storage of machine-readable instructions, data structures, program modules, and / or other data for the computer system 100. In one example, the software can be wholly or partially present in the machine-readable media of the storage device 135. In another example, the software can be wholly or partially present within the processor 101.

[0024] The bus 140 connects various subsystems. In this document, when referring to a bus, it may cover, where appropriate, one or more digital signal lines that perform a common function. The bus 140 can be any of a variety of bus structures, including but not limited to a memory bus, a memory controller, a peripheral bus, a local bus, and any combination thereof, and can employ any of a variety of bus architectures. By way of example and not limitation, such architectures include Industry Standard Architecture (ISA) bus, Enhanced ISA (EISA) bus, Micro Channel Architecture (MCA) bus, Video Electronics Standards Association Local Bus (VLB), Peripheral Component Interconnect (PCI) bus, PCI-Express (PCI-X) bus, Accelerated Graphics Port (AGP) bus, HyperTransport (HTX) bus, Serial Advanced Technology Attachment (SATA) bus, and any combination thereof.

[0025] The computer system 100 may also include an input device 133. In one example, a user of the computer system 100 can input commands and / or other information into the computer system 100 through the input device 133. Examples of the input device 133 include but are not limited to alphanumeric input devices (e.g., keyboards), pointing devices (e.g., mice or touchpads), touchpads, touchscreens, multi-touch screens, joysticks, styli, gamepads, audio input devices (e.g., microphones, voice response systems, etc.), optical scanners, video or still image capture devices (e.g., cameras), and any combination thereof. In some embodiments, the input device is a Kinect, a Leap Motion (motion sensor), etc. The input device 133 can be connected to the bus 140 through a variety of input interfaces 123 (e.g., the input interface 123), including but not limited to serial, parallel, game port, USB, FireWire interface (FIREWIRE), Thunderbolt interface (THUNDERBOLT), or any combination of the above interfaces.

[0026] In a particular embodiment, when the computer system 100 is connected to the network 130, the computer system 100 can communicate with other devices connected to the network 130, such as mobile devices and enterprise systems, distributed computing systems, cloud storage systems, cloud computing systems, etc. Communications to and from the computer system 100 can be transmitted through the network interface 120. For example, the network interface 120 can receive incoming communications (e.g., requests or responses from other devices) in the form of one or more data packets (e.g., Internet Protocol (IP) data packets) from the network 130, and the computer system 100 can store the incoming communications in the memory 103 for processing. Similarly, the computer system 100 can store outgoing communications (e.g., requests or responses to other devices) in the memory 103 in the form of one or more data packets and transmit them from the network interface 120 to the network 130. The processor 101 can access these communication data packets stored in the memory 103 for processing.

[0027] Examples of the network interface 120 include, but are not limited to, network interface cards, modems, and any combination thereof. Examples of the network 130 or network segment 130 include, but are not limited to, distributed computing systems, cloud computing systems, wide area networks (WANs) (e.g., the Internet, enterprise networks), local area networks (LANs) (e.g., networks associated with offices, buildings, campuses, or other relatively small geographical spaces), telephone networks, direct connections between two computing devices, peer-to-peer networks, and any combination thereof. The network, such as network 130, may employ wired and / or wireless communication modes. Generally, any network topology may be used.

[0028] Information and data can be displayed via the display 132. Examples of the display 132 include, but are not limited to, cathode ray tubes (CRTs), liquid crystal displays (LCDs), thin film transistor liquid crystal displays (TFT-LCDs), organic liquid crystal displays (OLEDs), such as passive matrix OLED (PMOLED) or active matrix OLED (AMOLED) displays, plasma displays, and any combination thereof. The display 132 can be connected to the processor 101, memory 103, fixed memory 108, and other devices, such as the input device 133, via the bus 140. The display 132 can be connected to the bus 140 through a video interface 122, and the data transmission between the display 132 and the bus 140 can be controlled by a graphics controller 121. In some embodiments, the display is a video projector. In some embodiments, the display is a head-mounted display (HMD), such as a VR head-mounted device. In other embodiments, suitable VR head-mounted devices include, but are not limited to, HTC Vive, Oculus Rift, Samsung Gear VR, Microsoft HoloLens, Razer OSVR, FOVE VR, Zeiss VR One, Avegant Glyph, Freefly VR head-mounted devices, and so on. In still other embodiments, the display is a combination of the devices disclosed herein.

[0029] In addition to the display 132, the computer system 100 may further include one or more other peripheral output devices 134, including, but not limited to, audio speakers, printers, storage devices, and any combination thereof. Such peripheral output devices can be connected to the bus 140 through an output interface 124. Examples of the output interface 124 include, but are not limited to, serial ports, parallel connections, USB ports, FireWire ports, Thunderbolt ports, and any combination thereof.

[0030] Optionally or alternatively, computer system 100 may provide functionality that is logically hardwired or otherwise embodied in circuitry that may act in place of or in conjunction with software to perform one or more of the processes or one or more steps of one or more of the processes described or illustrated herein. References to software in this invention may encompass logic, and references to logic may encompass software. Additionally, where appropriate, references to computer-readable media may encompass circuitry (such as an IC) storing software for execution, circuitry embodying logic for execution, or a combination of both. This invention encompasses any suitable combination of hardware, software, or both.

[0031] Those skilled in the art will appreciate that the various exemplary logical blocks, modules, circuits, and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware, computer software, or a combination of both. To clearly illustrate this interchangeability of hardware and software, various exemplary components, blocks, modules, circuits, and steps have been described above generally in terms of their functionality.

[0032] The various exemplary logical blocks, modules, and circuits described in connection with the embodiments disclosed herein may be implemented or performed using a general-purpose processor, a digital signal processor (DSP), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA) or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or any combination thereof designed to perform the functions described herein. A general-purpose processor may be a microprocessor, but, alternatively, the processor may be any conventional processor, controller, microcontroller, or state machine. The processor may also be implemented as a combination of computing devices, e.g., a combination of a DSP and a microprocessor, multiple microprocessors, one or more microprocessors in conjunction with a DSP core, or any other such configuration.

[0033] The steps of a method or algorithm described in connection with the embodiments disclosed herein may be embodied directly in hardware, in a software module executed by one or more processors, or in a combination of both. A software module may reside in RAM memory, flash memory, ROM memory, EPROM memory, EEPROM memory, registers, a hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art. The exemplary storage medium is coupled to the processor such that the processor can read information from, and write information to, the storage medium. In the alternative, the storage medium may be integral to the processor. The processor and the storage medium may reside in an ASIC. The ASIC may reside in a user terminal. Alternatively, the processor and the storage medium may reside as discrete components in a user terminal.

[0034] According to the description herein, suitable computing devices include, but are not limited to, server computers, desktop computers, laptop computers, notebook computers, subnotebook computers, netbook computers, network tablet computers, set-top box computers, media streaming devices, handheld computers, Internet appliances, mobile smartphones, tablet computers, and personal digital assistants.

[0035] In some embodiments, the computing device includes an operating system configured to execute executable instructions. For example, the operating system is software that includes programs and data, manages the hardware of the device, and provides services for the execution of application programs. Those skilled in the art should understand that suitable server operating systems include, but are not limited to, FreeBSD, OpenBSD, NetBSD ® , Linux, Apple ® Mac OS X Server ® , Oracle ® Solaris ® , Windows Serve r® and Novell ® NetWare ® . Those skilled in the art will also recognize that suitable personal computer operating systems include, but are not limited to, Microsoft ® Windows ® , Apple ® Mac OS X ® , UNIX ® and UNIX-like operating systems (such as GNU / Linux ® ). In some embodiments, the operating system is provided by cloud computing. Those skilled in the art should also understand that suitable mobile smartphone operating systems include, but are not limited to, Nokia ® Symbian ® OS, Apple ® iOS ® , Research In Motion ® BlackBerryOS ® , Google ® Android ® , Microsoft ® Windows Phone ® OS, Microsoft ® Windows Mobile ® OS, Linux ® and Palm ® WebOS ® .

[0036] non-transitory computer-readable storage medium In some embodiments, the platforms, systems, media, and methods disclosed in the present invention include one or more non-transitory computer-readable storage media having programs of instructions programmed thereon that are executable by an operating system of an optionally networked computing device. In further embodiments, the computer-readable storage medium is a tangible component of the computing device. In still further embodiments, the computer-readable storage medium is optionally removable from the computing device. In some embodiments, the computer-readable storage medium includes, but is not limited to, CD-ROMs, DVDs, flash devices, solid state memories, disk drives, tape drives, optical disc drives, distributed computing systems including cloud computing systems and services, and the like. In certain cases, the programs and instructions are permanently, substantially permanently, semi-permanently, or non-transitorily encoded on the medium.

[0037] computer program In some embodiments, the platforms, systems, media, and methods disclosed in the present invention include at least one computer program or its use. A computer program includes a series of instructions executable by one or more processors of a CPU of a computing device for performing a particular task. The computer-readable instructions can be implemented as program modules, such as functions, objects, application programming interfaces (APIs), computational data structures, etc. for performing a particular task or implementing a particular abstract data type. Those skilled in the art will appreciate, in light of the disclosure of the present invention, that computer programs can be written in various versions of various languages.

[0038]

[0038] The functionality of the computer-readable instructions can be combined or distributed as needed in various environments. In some embodiments, a computer program includes a sequence of instructions. In some embodiments, a computer program includes multiple sequences of instructions. In some embodiments, a computer program is provided from a single location. In other embodiments, a computer program is provided from multiple locations. In various embodiments, a computer program includes one or more software modules. In various embodiments, a computer program includes, in whole or in part, one or more web applications, one or more mobile applications, one or more stand-alone applications, one or more web browser plugins, extensions, add-ons, or accessories, or combinations thereof.

[0039] Web application In some embodiments, a computer program includes a web application. Those skilled in the art will understand, in light of the disclosure of the present invention, that in various embodiments, a web application utilizes one or more software frameworks and one or more database systems. In some embodiments, a web application is based on, for example, Microsoft ®Created with a software framework such as.NET or Ruby on Rails (RoR). In some embodiments, the Web application utilizes one or more database systems, including but not limited to relational, non-relational, object-oriented, associative, XML, and document-oriented database systems. In other embodiments, suitable relational database systems include but are not limited to Microsoft ® SQL Server, mySQL™, and Oracle®. Those skilled in the art should also understand that in various embodiments, the Web application is written in one or more versions of one or more languages. The Web application can be written in one or more markup languages, presentation definition languages, client-side scripting languages, server-side coding languages, database query languages, or combinations thereof. In some embodiments, the Web application is written to some extent in a markup language such as Hypertext Markup Language (HTML), Extensible Hypertext Markup Language (XHTML), or Extensible Markup Language (XML). In some embodiments, the Web application is written to some extent in a presentation definition language such as Cascading Style Sheets (CSS). In some embodiments, the Web application is written to some extent in a client-side scripting language such as Asynchronous JavaScript and XML (AJAX), Flash ® ActionScript, JavaScript, or Silverlight ® to write. In some embodiments, the Web application is written to some extent in a server-side coding language such as Active Server Pages (ASP), ColdFusion ® , Perl, Java™, Java Server Pages (JSP), Hypertext Preprocessor (PHP), Python™, Ruby, Tcl, Smalltalk, WebDNA ® or Groovy. In some embodiments, the Web application is written to some extent in a database query language such as Structured Query Language (SQL). In some embodiments, the Web application integrates enterprise server products such as IBM ® Lotus Domino ® . In some embodiments, the Web application includes a media player element. In various further embodiments, the media player element utilizes one or more of a variety of suitable multimedia technologies, including but not limited to Adobe ® Flash ® , HTML 5, Apple ® QuickTime ® , Microsoft ®Silverlight ® 、Java™ and Unity ® 。

[0040] Reference Figure 2 ,In a particular embodiment, the application providing system includes one or more databases 200 accessed by a relational database management system (RDBMS) 210. Suitable RDBMSs include Firebird, MySQL, PostgreSQL, SQLite, Oracle Database, Microsoft SQL Server, IBM DB2, IBM Informix, SAP Sybase, Teradata, etc. In this embodiment, the application providing system further includes one or more application servers 220 (such as Java servers,.NET servers, PHP servers, etc.) and one or more web servers 230 (such as Apache, IIS, GWS, etc.). The web server optionally exposes one or more web services through an application programming interface (API) 240. Through a network, such as the Internet, the system provides a browser-based and / or mobile native user interface.

[0041] Reference Figure 3 Alternatively, in a particular embodiment, the application providing system has a distributed cloud-based architecture 300 and includes elastic load balancing, auto-scaling web server resources 310 and application server resources 320, and synchronously replicated databases 330.

[0042] Mobile Application In some embodiments, the computer program includes a mobile application provided to a mobile computing device. In some embodiments, the mobile application is pre-installed on the mobile computing device when the mobile computing device is manufactured. In other embodiments, the mobile application is provided to the mobile computing device through the computer network described in the present invention.

[0043] In view of the content disclosed in the present invention, those skilled in the art can use known hardware, programming languages, and development environments to create mobile applications through techniques well known in the art. Those skilled in the art should understand that mobile applications can be written in a variety of programming languages. Suitable programming languages include, but are not limited to, C, C++, C#, Objective-C, Java™, JavaScript, Pascal, Object Pascal, Python™, Ruby, VB.NET, WML, and XHTML / HTML with or without CSS, or combinations thereof.

[0044] A suitable mobile application development environment can be obtained from multiple sources. Commercially available development environments include, but are not limited to, AirplaySDK, alcheMo, Appcelerator ® , Celsius, Bedrock, Flash Lite,.NET Compact Framework, Rhomobile, and WorkLight mobile platforms. Other free development environments include, but are not limited to, Lazarus, MobiFlex, MoSync, and PhoneGap. In addition, mobile device manufacturers release software development kits, including, but not limited to, iPhone and iPad (iOS) SDKs, Android™ SDKs, BlackBerry ® SDKs, BREW SDKs, Palm ® OS SDKs, Symbian SDKs, webOS SDKs, and Windows ® Mobile SDKs.

[0045] Standalone applications In some embodiments, a computer program includes a standalone application that runs as an independent computer process rather than as an add-on to an existing process, such as not being a plugin. It is clear to those skilled in the art that standalone applications generally require compilation. A compiler is a computer program that converts source code written in a programming language into binary target code, such as assembly language or machine code. Suitable programming languages for compilation include, but are not limited to, C, C++, Objective-C, COBOL, Delphi, Eiffel, Java™, Lisp, Python™, Visual Basic, and VB.NET, or combinations thereof. Compilation is typically performed, at least in part, to create an executable program. In some embodiments, a computer program includes one or more executable compiled applications.

[0046] Web browser plugins In some embodiments, a computer program includes a Web browser plugin (e.g., an extension, etc.). In the computing field, a plugin is one or more software components that add specific functionality to a large software application. The developer of the software application supports plugins to enable third-party developers to create capabilities to extend the application, so as to easily add new functions and reduce the size of the application. If the application supports plugins, the plugins can customize the functionality of the software application. For example, Web browsers often use plugins to play videos, generate interactions, scan for viruses, and display specific file types. Those skilled in the art are familiar with a variety of Web browser plugins, including Adobe ® Flash® Player, Microsoft ® Silverlight ® and Apple ® QuickTime ® 。In some embodiments, the toolbar includes one or more web browser extensions, add-ons, or plug-ins. In some embodiments, the toolbar includes one or more explorer bars, toolbars, or desktop bars.

[0047] In view of the disclosure of the present invention, those skilled in the art will recognize that there are a variety of plug-in frameworks available that are capable of supporting the development of plug-ins in a variety of programming languages, including but not limited to C++, Delphi, Java™, PHP, Python™, and VB.NET, or combinations thereof.

[0048] A web browser (also known as a network browser) is a software application designed to be used with a networked computing device for retrieving, presenting, and browsing information resources on the World Wide Web. Suitable web browsers include but are not limited to Microsoft ® Internet Explorer ® 、Mozilla ® Firefox ® 、Google ® Chrome, Apple ® Safari ® 、OperaSoftware ® Opera ® and KDE Konqueror. In some embodiments, the web browser is a mobile web browser. A mobile web browser (also known as a micro browser, mini browser, and wireless browser) is designed for mobile computing devices, which include but are not limited to handheld computers, tablet computers, netbook computers, small notebook computers, smartphones, music players, personal digital assistants (PDAs), and handheld video game systems. Suitable mobile web browsers include but are not limited to: Google ® Android ® Browser, RIM BlackBerry ® Browser, Apple ® Safari ® 、Palm ® Blazer, Palm ® WebOS ® Browser, Mozilla ® Firefox ®Mobile, Microsoft ® Internet Explorer ® Mobile, Amazon ® Kindle ® Basic Web, Nokia ® Browser, Opera Software ® Opera ® Mobile and Sony ® PSP™ Browser.

[0049] Software Module In some embodiments, the platforms, systems, media, and methods disclosed in the present invention include software, server, and / or database modules, or utilize these modules. Given the disclosure of the present invention, software modules can be created using techniques known to those skilled in the art and using machines, software, and languages known in the art. The software modules disclosed in the present invention can be implemented in a variety of ways. In different embodiments, a software module includes a file, a piece of code, a programming object, a programming structure, a distributed computing resource, a cloud computing resource, or a combination thereof. In various other embodiments, a software module includes multiple files, multiple pieces of code, multiple programming objects, multiple programming structures, multiple distributed computing resources, multiple cloud computing resources, or a combination thereof. In various embodiments, one or more software modules include, but are not limited to, web applications, mobile applications, standalone applications, and distributed or cloud computing applications. In some embodiments, a software module is located in a computer program or application. In other embodiments, a software module is located in multiple computer programs or applications. In some embodiments, a software module is hosted on one machine. In other embodiments, a software module is hosted on multiple machines. In further embodiments, a software module is hosted on a distributed computing platform (such as a cloud computing platform). In some embodiments, a software module is hosted on one or more machines at the same location. In other embodiments, a software module is hosted on one or more machines at multiple locations.

[0050] Database In some embodiments, the platforms, systems, media, and methods disclosed by the present invention include one or more databases or their use. Given the disclosure of the present invention, those skilled in the art will understand that many databases are suitable for storing and retrieving user information, research information, slide information, field of view (FoV) information, flow cell information, image information (including cell boundaries), genomic information, transcriptomic information, and proteomic information. In various embodiments, suitable databases include, but are not limited to, relational databases, non-relational databases, object-oriented databases, object databases, entity-relationship model databases, associative databases, XML databases, document-oriented databases, and graph databases. Other non-limiting examples include SQL, PostgreSQL, MySQL, Oracle, DB2, Sybase, and MongoDB. In some embodiments, the database is Internet-based. In further embodiments, the database is Web-based. In still further embodiments, the database is cloud computing-based. In certain embodiments, the database is a distributed database. In other embodiments, the database is based on one or more local computer storage devices.

[0051] Data retrieval In some embodiments, the methods, systems, and media disclosed in the present invention receive data from laboratory instruments. In some embodiments, the data is received directly from one or more laboratory instruments. In other embodiments, the data is received indirectly from one or more laboratory instruments. In some embodiments, the methods, systems, and media disclosed in the present invention receive data from a database. In some embodiments, the data is received directly from the database. In other embodiments, the data is received indirectly from the database. Many types of data are applicable. In the field of spatial biology, useful data includes, but is not limited to, biological image data, such as microscopic images (e.g., micrographs) of formalin-fixed paraffin-embedded (FFPE) and / or fresh-frozen (FF) cell and / or tissue samples. In some embodiments, the biological image data includes cell image data. In some embodiments, the image data includes two-dimensional data. In some embodiments, the image data includes three-dimensional image data. In some embodiments, data from RNA assays and protein assays on a single slide is split into two data sets. In some embodiments, data from RNA assays and protein assays on a single slide is combined. Additionally, in the field of spatial biology, useful data also includes, but is not limited to, "omics" data, such as genomic data, proteomic data, metabolomic data, metagenomic data, phenomic data, and / or transcriptomic data. In some embodiments, the omics data is associated with the image data. For example, in various embodiments, the omics data can be generated from the same tissue, the same sample, or the same type of cell as the image data. In other embodiments, the omics data is related to the image data in two-dimensional and / or three-dimensional space. In various embodiments, the omics data is associated with the image data as metadata and / or an image overlay.

[0052] In some embodiments, the methods, systems, and media disclosed in the present invention can receive data through an instrument interface and save it in its original file format. In some embodiments, the platforms, systems, media, and methods disclosed in the present invention can receive data through an instrument interface and add it to a data set.

[0053] Non-intersecting polygons In some embodiments, the methods, systems, and media disclosed by the present invention may include receiving cell image data. In some embodiments, the cell image data includes cell boundary data. In some embodiments, the cell boundary data includes the Cartesian coordinates of the vertices of non-intersecting polygons along a polygonal path around the cell boundary. In some embodiments, the Cartesian coordinates include two-dimensional coordinates. In some embodiments, the Cartesian coordinates include 3D coordinates. In some embodiments, the Cartesian coordinates of the vertices may be recorded in an ordered data structure, namely an array. In some embodiments, the order includes the order from the starting vertex to the last vertex along the polygonal path around the cell boundary. In some embodiments, the cell image data includes data from system user input. In some embodiments, the cell image data includes data from an algorithm. In some embodiments, the cell image data includes a combination of data from system user input and data from an algorithm.

[0054] In some embodiments, the methods, systems, and media disclosed by the present invention may include performing a quality assurance check. In some embodiments, the quality assurance check may include checking the Cartesian coordinates of the vertices of the received non-intersecting polygons. In some embodiments, the quality assurance check includes one or more of the following: a) checking whether the polygon contains at least 3 vertices; b) checking whether the polygonal path contains a closed loop; c) checking whether the polygonal path contains a defined direction; and d) checking whether the vertex order along the polygonal path is in sequence.

[0055] In various embodiments, the methods, systems, and media disclosed by the present invention further include a client computing device. In various embodiments, the methods, systems, and media disclosed by the present invention further include rendering the cell boundary on a GUI. In various embodiments, the GUI allows the user to move the vertices of the polygon along the cell boundary. In various embodiments, the GUI allows the user to redisplay the cell boundary after moving the vertices of the polygon along the cell boundary.

[0056] In some embodiments, the methods, systems, and media disclosed by the present invention may further include a fast polygon self-intersection test for moving vertices. A common method for testing polygon segment self-intersection is to compare each segment in the polygon with all other segments. The complexity of the common method is O(N 2),(where N is the number of line segments in the polygon. In some embodiments, the fast polygon self-intersection test may include identifying moving vertices. In some embodiments, the fast polygon self-intersection test may further include comparing two line segments connected to a moving vertex with all other line segments. In some embodiments, the complexity of the fast polygon self-intersection test may be O(N), where N is the number of line segments of the polygon. In some embodiments, the speed increase can provide a higher frame rate for the user interface. In some embodiments, the speed increase can provide a higher control fluency for the user interface. In some embodiments, the speed improvement enables the user to modify the shape of a complex polygon in real time.)

[0057] As Figure 5 shown, in the hexagon ABCDEF, vertex A is moving. Based on the directions of the pre-computed AB and AF vectors, line intersection tests are performed on the BC, CD, DE, and EF line segments. The conventional method requires testing each of these six line segments against the other five line segments, for a total of 30 calculations. The fast polygon self-intersection test takes into account that only the two line segments AB and AF will be affected by the movement of vertex A, so only AB and AF are tested for intersection. In this example, the remaining 4 line segments do not need to be recalculated. The fast polygon self-intersection test also takes into account that adjacent line segments (e.g., line segments sharing a common vertex) do not need to be tested for intersection. This makes the total number of tests in the example only 6 calculations, instead of 30 calculations in the conventional method.)

[0058] In some embodiments, the methods, systems, and media disclosed by the present invention may further include a fast polygon mask filling method that utilizes line directions. The conventional method for filling a polygon is to use a digital differential analyzer (DDA) or Bresenham's line drawing algorithm to draw the line segments of the polygon as pixels; then use a scan filling algorithm to find the intersections of edge pairs along each horizontal row, which requires some additional calculations, such as division operations. Then use a scan filling algorithm to sort the edge pairs and fill the pixels between each pair of edge pairs. The complexity of the line drawing part of the conventional method is O(N), and the complexity of the scan filling algorithm is O(N log(N)). In some embodiments, the fast polygon mask filling method may include retaining context information of the direction of each line when drawing the pixels of the line segments. In some embodiments, the fast polygon mask filling method further includes recording conditional values for pixels with external edges. In some embodiments, the conditional values include left, right, or shared. In some embodiments, the fast polygon mask filling method includes direct filling without sorting the edge pairs. In some embodiments, the complexity of the line drawing of the fast polygon mask filling method is O(N). In some embodiments, the complexity of the polygon filling of the fast polygon mask filling method is O(N).)

[0059] AsFigure 6B As shown, the interior region of a polygon with white edges is filled by applying a fast polygon mask filling method. Counting counterclockwise from the top, the polygon vertices are located at (12, 0), (0, 19), (13, 36), (24, 27), (14, 21), (27, 5) respectively. The pixels of the polygon are as Figure 6A shown. Each interior pixel is assigned a point. For each edge pixel, one of the following three values is assigned: "O" represents a shared edge pixel, "<" represents a left edge pixel, and ">" represents a right edge pixel.

[0060] matrix In some embodiments, the methods, systems, and media disclosed herein may further include calculating the distance between the starting vertex and the last vertex. In some embodiments, the distance includes the Euclidean distance. In some embodiments, the distance includes the difference in one-dimensional Cartesian coordinates, i.e., Δx, Δy, or Δz. In some embodiments, the distance includes the maximum of the Cartesian coordinate differences in all dimensions, i.e., the maximum of Δx and Δy, or the maximum of Δx, Δy, and Δz. In some embodiments, the distance includes the minimum of the Cartesian coordinate differences in all dimensions, i.e., the minimum of Δx and Δy, or the minimum of Δx, Δy, and Δz. In some embodiments, the distance includes the arithmetic mean of the Cartesian coordinate differences in all dimensions, i.e., the mean of Δx and Δy, or the mean of Δx and Δz, or the mean of Δy and Δz, or the mean of Δx, Δy, and Δz.

[0061] In some embodiments, the methods, systems, and media disclosed by the present invention may further include selecting a matrix containing edge elements to represent different directions based on the distance. In some embodiments, the matrix includes a 3X3, 4X4, 5X5, 6X6, 7X7, 8X8, 9X9, 10x10, 11X11, 12X12, 13X13, 14X14, 15X15, 16X16, 17X17, 18X18, 19X19, 20X20, 21X21, 22X22, 23X23, 24X24, 25X25, 26X26, 27X27, 28X28, 29X29, 30X30, 31X31, 32X32, or 33X33 matrix.

[0062] Figure 4AShows a non-limiting example of a 9X9 matrix. The polar coordinate reference point of the matrix is marked with an X at the center. At the edge of the matrix, the numbers 0 to 31 are arranged in a clockwise direction, starting with 0 on the right side. These 32 numbers represent different directions between adjacent vertex pairs. The distance from the polar coordinate reference point (X) to the edge is 4 (pixels) in all directions. Similarly, in a 17X17 matrix, the distance from the polar coordinate reference point to the edge is 8 (pixels) in all directions. There are 64 numbers (0 - 63) representing different directions on the edge of the 17X17 matrix. The polar coordinates in this matrix (e.g., a distance of 4 or 8, and the numbers representing different directions) can be used to define the step size between ordered adjacent vertex pairs along a polygonal path on the cell boundary. In some embodiments, the distance along the polygonal path on the cell boundary is fixed. In some embodiments, the step size includes short steps. In some embodiments, the step size includes long steps.

[0063] In some embodiments, the short step includes a distance of about 1 pixel, about 2 pixels, about 3 pixels, about 4 pixels, about 5 pixels, about 6 pixels, about 7 pixels, or about 8 pixels. In some embodiments, the short step includes a distance of about 1 pixel to about 8 pixels, about 1 pixel to about 7 pixels, about 1 pixel to about 6 pixels, about 1 pixel to about 5 pixels, about 1 pixel to about 4 pixels, about 1 pixel to about 3 pixels, about 1 pixel to about 2 pixels, about 2 pixels to about 8 pixels, about 2 pixels to about 7 pixels, about 2 pixels to about 6 pixels, about 2 pixels to about 5 pixels, about 2 pixels to about 4 pixels, about 2 pixels to about 3 pixels, about 3 pixels to about 8 pixels, about 3 pixels to about 7 pixels, about 3 pixels to about 6 pixels, about 3 pixels to about 5 pixels, about 3 pixels to about 4 pixels, about 4 pixels to about 8 pixels, about 4 pixels to about 7 pixels, about 4 pixels to about 6 pixels, about 4 pixels to about 5 pixels, about 5 pixels to about 8 pixels, about 5 pixels to about 7 pixels, about 5 pixels to about 6 pixels, about 6 pixels to about 8 pixels, about 6 pixels to about 7 pixels, or about 7 pixels to about 8 pixels. In some embodiments, the short step includes a distance of at least about 1 pixel, at least about 2 pixels, at least about 3 pixels, at least about 4 pixels, at least about 5 pixels, at least about 6 pixels, at least about 7 pixels, or at least about 8 pixels. In some embodiments, the short step includes a distance of at most about 1 pixel, at most about 2 pixels, at most about 3 pixels, at most about 4 pixels, at most about 5 pixels, at most about 6 pixels, at most about 7 pixels, or at most about 8 pixels.

[0064] In some embodiments, the long step includes a distance of about 4 pixels, about 5 pixels, about 6 pixels, about 7 pixels, about 8 pixels, about 9 pixels, about 10 pixels, about 11 pixels, about 12 pixels, about 14 pixels, or about 16 pixels. In some embodiments, the long step includes a distance of from about 4 pixels to about 16 pixels, from about 4 pixels to about 14 pixels, from about 4 pixels to about 12 pixels, from about 4 pixels to about 11 pixels, from about 4 pixels to about 10 pixels, from about 4 pixels to about 9 pixels, from about 4 pixels to about 8 pixels, from about 4 pixels to about 7 pixels, from about 4 pixels to about 6 pixels, from about 4 pixels to about 5 pixels, from about 5 pixels to about 16 pixels, from about 5 pixels to about 14 pixels, from about 5 pixels to about 12 pixels, from about 5 pixels to about 11 pixels, from about 5 pixels to about 10 pixels, from about 5 pixels to about 9 pixels, from about 5 pixels to about 8 pixels, from about 5 pixels to about 7 pixels, from about 5 pixels to about 6 pixels, from about 6 pixels to about 16 pixels, from about 6 pixels to about 14 pixels, from about 6 pixels to about 12 pixels, from about 6 pixels to about 11 pixels, from about 6 pixels to about 10 pixels, from about 6 pixels to about 9 pixels, from about 6 pixels to about 8 pixels, from about 6 pixels to about 7 pixels, from about 7 pixels to about 16 pixels, from about 7 pixels to about 14 pixels, from about 7 pixels to about 12 pixels, from about 7 pixels to about 11 pixels, from about 7 pixels to about 10 pixels, from about 7 pixels to about 9 pixels, from about 7 pixels to about 8 pixels, from about 8 pixels to about 16 pixels, from about 8 pixels to about 14 pixels, from about 8 pixels to about 12 pixels, from about 8 pixels to about 11 pixels, from about 8 pixels to about 10 pixels, from about 8 pixels to about 9 pixels, from about 9 pixels to about 16 pixels, from about 9 pixels to about 14 pixels, from about 9 pixels to about 12 pixels, from about 9 pixels to about 11 pixels, from about 9 pixels to about 10 pixels, from about 10 pixels to about 16 pixels, from about 10 pixels to about 14 pixels, from about 10 pixels to about 12 pixels, from about 10 pixels to about 11 pixels, from about 11 pixels to about 16 pixels, from about 11 pixels to about 14 pixels, from about 11 pixels to about 12 pixels, from about 12 pixels to about 16 pixels, from about 12 pixels to about 14 pixels, or from about 14 pixels to about 16 pixels. In some embodiments, the long step includes a distance of at least about 4 pixels, at least about 5 pixels, at least about 6 pixels, at least about 7 pixels, at least about 8 pixels, at least about 9 pixels, at least about 10 pixels, at least about 11 pixels, at least about 12 pixels, at least about 14 pixels, or at least about 16 pixels. In some embodiments, the long step includes a distance of at most about 4 pixels, at most about 5 pixels, at most about 6 pixels, at most about 7 pixels, at most about 8 pixels, at most about 9 pixels, at most about 10 pixels, at most about 11 pixels, at most about 12 pixels, at most about 14 pixels, or at most about 16 pixels.

[0065] Figure 4BShows a non - restrictive example of the cell boundary represented by a pentagon ABCDE in a Cartesian coordinate system. A is the starting vertex and E is the last vertex. The distance between all vertices is 4 (pixels). This is determined by the distance between the starting vertex and the last vertex (in this case A and E). To calculate the step from A to B, the Cartesian coordinates of the first vertex A in the ordered pair of adjacent vertices (AB) are assigned to the polar reference coordinates of the matrix. For example, vertex A is placed at the "X" at the center of the matrix in Figure 4A After coordinate transformation, the second vertex B in the ordered pair of adjacent vertices will be located at the edge position of the matrix represented by the number "2". Therefore, the direction of the step from A to B can be represented by "2". Along this path, the step from B to C can be calculated by following the same polar coordinate transformation: vertex B is moved to the "X" at the center of the matrix in Figure 4A and then vertex C is located at the edge position represented by the number "10". Therefore, the direction of the BC step is 10. Following the same transformation method, the step from C to D is 16 and the step from D to E will be 22.

[0066] Data structure In some embodiments, the methods, systems, and media disclosed by the present invention may further include storing the Cartesian coordinates of the starting vertex in a data structure. In some embodiments, the methods, systems, and media disclosed by the present invention may further include storing each step length of the polygonal path along the cell boundary in the data structure. In some embodiments, the data structure includes 1 bit, 2 bits, 3 bits, 4 bits, 5 bits, 6 bits, 7 bits, 8 bits, 9 bits, 10 bits, 11 bits, 12 bits, 13 bits, 14 bits, 15 bits, or 16 bits for storing each step length. In some embodiments, the data structure includes at least 1 bit, at least 2 bits, at least 3 bits, at least 4 bits, at least 5 bits, at least 6 bits, at least 7 bits, at least 8 bits, at least 9 bits, at least 10 bits, at least 11 bits, at least 12 bits, at least 13 bits, at least 14 bits, at least 15 bits, or at least 16 bits for storing each step length. In some embodiments, the data structure includes from about 1 bit to about 16 bits, from about 1 bit to about 15 bits, from about 1 bit to about 14 bits, from about 1 bit to about 13 bits, from about 1 bit to about 12 bits, from about 1 bit to about 11 bits, from about 1 bit to about 10 bits, from about 1 bit to about 9 bits, from about 1 bit to about 8 bits, from about 1 bit to about 7 bits, from about 1 bit to about 6 bits, from about 1 bit to about 5 bits, from about 1 bit to about 4 bits, from about 1 bit to about 3 bits, from about 1 bit to about 2 bits, from about 2 bits to about 16 bits, from about 2 bits to about 15 bits, from about 2 bits to about 14 bits, from about 2 bits to about 13 bits, from about 2 bits to about 12 bits, from about 2 bits to about 11 bits, from about 2 bits to about 10 bits, from about 2 bits to about 9 bits, from about 2 bits to about 8 bits, from about 2 bits to about 7 bits, from about 2 bits to about 6 bits, from about 2 bits to about 5 bits, from about 2 bits to about 4 bits, from about 2 bits to about 3 bits, from about 3 bits to about 16 bits, from about 3 bits to about 15 bits, from about 3 bits to about 14 bits, from about 3 bits to about 13 bits, from about 3 bits to about 12 bits, from about 3 bits to about 11 bits, from about 3 bits to about 10 bits, from about 3 bits to about 9 bits, from about 3 bits to about 8 bits, from about 3 bits to about 7 bits, from about 3 bits to about 6 bits, from about 3 bits to about 5 bits, from about 3 bits to about 4 bits, from about 4 bits to about 16 bits, from about 4 bits to about 15 bits, from about 4 bits to about 14 bits, from about 4 bits to about 13 bits, from about 4 bits to about 12 bits, from about 4 bits to about 11 bits, from about 4 bits to about 10 bits, from about 4 bits to about 9 bits, from about 4 bits to about 8 bits, from about 4 bits to about 7 bits, from about 4 bits to about 6 bits, from about 4 bits to about 5 bits, from about 5 bits to about 16 bits, from about 5 bits to about 15 bits, from about 5 bits to about 14 bits, from about 5 bits to about 13 bits, from about 5 bits to about 12 bits, from about 5 bits to about 11 bits, from about 5 bits to about 10 bits, from about 5 bits to about 9 bits, from about 5 bits to about 8 bits, from about 5 bits to about 7 bits, from about 5 bits to about 6 bits, from about 6 bits to about 16 bits,from about 6 bits to about 15 bits, from about 6 bits to about 14 bits, from about 6 bits to about 13 bits, from about 6 bits to about 12 bits, from about 6 bits to about 11 bits, from about 6 bits to about 10 bits, from about 6 bits to about 9 bits, from about 6 bits to about 8 bits, from about 6 bits to about 7 bits, from about 7 bits to about 16 bits, from about 7 bits to about 15 bits, from about 7 bits to about 14 bits, from about 7 bits to about 13 bits, from about 7 bits to about 12 bits, from about 7 bits to about 11 bits, from about 7 bits to about 10 bits, from about 7 bits to about 9 bits, from about 7 bits to about 8 bits, from about 8 bits to about 16 bits, from about 8 bits to about 15 bits, from about 8 bits to about 14 bits, from about 8 bits to about 13 bits, from about 8 bits to about 12 bits, from about 8 bits to about 11 bits, from about 8 bits to about 10 bits, from about 8 bits to about 9 bits, from about 9 bits to about 16 bits, from about 9 bits to about 15 bits, from about 9 bits to about 14 bits, from about 9 bits to about 13 bits, from about 9 bits to about 12 bits, from about 9 bits to about 11 bits, from about 9 bits to about 10 bits, from about 10 bits to about 16 bits, from about 10 bits to about 15 bits, from about 10 bits to about 14 bits, from about 10 bits to about 13 bits, from about 10 bits to about 12 bits, from about 10 bits to about 11 bits, from about 11 bits to about 16 bits, from about 11 bits to about 15 bits, from about 11 bits to about 14 bits, from about 11 bits to about 13 bits, from about 11 bits to about 12 bits, from about 12 bits to about 16 bits, from about 12 bits to about 15 bits, from about 12 bits to about 14 bits, from about 12 bits to about 13 bits, from about 13 bits to about 16 bits, from about 13 bits to about 15 bits, from about 13 bits to about 14 bits, from about 14 bits to about 16 bits, from about 14 bits to about 15 bits, or from about 15 bits to about 16 bits, for storing each step size.,

[0067] In some embodiments, the data structure includes 1 byte, 2 bytes, 3 bytes, or 4 bytes for storing each step size. In some embodiments, the data structure includes from about 1 byte to about 4 bytes, from about 1 byte to about 3 bytes, from about 1 byte to about 2 bytes, from about 2 bytes to about 4 bytes, from about 2 bytes to about 3 bytes, or from about 3 bytes to about 4 bytes for storing each step size. In some embodiments, the data structure includes at most 1 byte, at most 2 bytes, at most 3 bytes, or at most 4 bytes for storing each step size. In some embodiments, the data structure includes at least 1 byte, at least 2 bytes, at least 3 bytes, or at least 4 bytes for storing each step size.

[0068] A common way to describe a polygonal path is to use the Cartesian coordinates of the starting vertex and the differences in all dimensions for ordered pairs of adjacent vertices, such as ΔX and ΔY, such that at least 2 full bytes are required to describe each step along the polygonal path. In various embodiments, the methods, systems, and media disclosed herein include a data structure that includes packing 3 parts of the data bits into a single byte to represent short or long steps based on polar coordinates. After storing the Cartesian coordinates of the starting vertex in the data structure, the polar coordinates of each step along the polygonal path are stored sequentially in 1 byte. The first part of the byte is used to store the direction of the step. As Figure 4A shown, as a non-limiting example, when a 9X9 matrix with a direction on the edge is selected for a short step, the direction of each step can be represented by a number between 0 and 31, requiring at most 5 bits. Similarly, when a 17X17 matrix is selected for a long step, as a non-limiting example, the direction of each step can be represented by a number between 0 and 63, requiring at most 6 bits. The second part of the byte is used to indicate a long step or a short step. The long or short step indicator can be stored as the 7th bit in the data structure. The third part of the byte is designated as a path terminator. When storing the step of the last vertex, the terminator can be stored as the 8th bit of the last step in the data structure. The result is that each step only requires 1 byte containing three parts to record. All steps of the polygonal path will be stored in such 1 byte in the order of the Cartesian coordinates of the starting vertex. The last bit of the last byte (step) will contain the terminator. In various embodiments, the methods, systems, and media disclosed herein also include compressing the data in the structure.

[0069] In various embodiments, the file includes a data structure defining the cell boundary. In some embodiments, the file includes reducing the storage size of the cell boundary by about 10%, about 20%, about 30%, about 40%, about 50%, about 60%, about 70%, about 80%, or about 90%. In some embodiments, the file includes reducing the storage size of the cell boundary by at least about 10%, at least about 20%, at least about 30%, at least about 40%, at least about 50%, at least about 60%, at least about 70%, at least about 80%, or at least about 90%. In some embodiments, the file includes reducing the storage size of the cell boundary by about 10% to about 90%, about 10% to about 80%, about 10% to about 70%, about 10% to about 60%, about 10% to about 50%, about 10% to about 40%, about 10% to about 30%, about 10% to about 20%, about 20% to about 90%, about 20% to about 80%, about 20% to about 70%, about 20% to about 60%, about 20% to about 50%, about 20% to about 40%, about 20% to about 30%, about 30% to about 90%, about 30% to about 80%, about 30% to about 70%, about 30% to about 60%, 30% to about 50%, about 30% to about 40%, about 40% to about 90%, about 40% to about 80%, about 40% to about 70%, about 40% to about 60%, about 40% to about 50%, about 50% to about 90%, about 50% to about 80%, about 50% to about 70%, about 50% to about 60%, about 60% to about 90%, about 60% to about 80%, about 60% to about 70%, about 70% to about 90%, about 70% to about 80%, or about 80% to about 90%.

[0070] In various embodiments, the file contains a data structure defining cell boundaries. In some embodiments, the file includes definitions of approximately 1, approximately 10, approximately 100, approximately 1000, approximately 10K, approximately 100K, approximately 200K, approximately 500K, approximately 1M, approximately 5M, approximately 10M, or approximately 100M cell boundaries. In some embodiments, the file includes at least approximately 1, at least approximately 10, at least approximately 100, at least approximately 1000, at least approximately 10K, at least approximately 100K, at least approximately 200K, at least approximately 500K, at least approximately 1M, at least approximately 5M, at least approximately 10M, or at least approximately 100M cell boundary definitions. In some embodiments, the file contains from approximately 1 to approximately 10, from approximately 1 to approximately 100, from approximately 1 to approximately 1000, from approximately 1 to approximately 10K, from approximately 1 to approximately 100K, from approximately 1 to approximately 200K, from approximately 1 to approximately 500K, from approximately 1 to approximately 1M, from approximately 1 to approximately 5M, from approximately 1 to approximately 10M, from approximately 1 to approximately 100M, from approximately 10 to approximately 100, from approximately 10 to approximately 1000, from approximately 10 to approximately 10K, from approximately 10 to approximately 100K, from approximately 10 to approximately 200K, from approximately 10 to approximately 500K, from approximately 10 to approximately 1M, from approximately 10 to approximately 5M, from approximately 10 to approximately 10M, from approximately 10 to approximately 100M, from approximately 100 to approximately 1000, from approximately 100 to approximately 10K, from approximately 100 to approximately 100K, from approximately 100 to approximately 200K, from approximately 100 to approximately 500K, from approximately 100 to approximately 1M, from approximately 100 to approximately 5M, from approximately 100 to approximately 10M, from approximately 100 to approximately 100M, from approximately 1000 to approximately 10K, from approximately 1000 to approximately 100K, from approximately 1000 to approximately 200K, from approximately 1000 to approximately 500K, from approximately 1000 to approximately 1M, from approximately 1000 to approximately 5M, from approximately 1000 to approximately 10M, from approximately 1000 to approximately 100M, from approximately 10K to approximately 100K, from approximately 10K to approximately 200K, from approximately 10K to approximately 500K, from approximately 10K to approximately 1M, from approximately 10K to approximately 5M, from approximately 10K to approximately 10M, from approximately 10K to approximately 100M, from approximately 100K to approximately 200K, from approximately 100K to approximately 500K, from approximately 100K to approximately 1M, from approximately 100K to approximately 5M, from approximately 100K to approximately 10M, from approximately 100K to approximately 100M, from approximately 200K to approximately 500K, from approximately 200K to approximately 1M, from approximately 200K to approximately 5M, from approximately 200K to approximately 10M, from approximately 200K to approximately 100M, from approximately 500K to approximately 1M, from approximately 500K to approximately 5M, from approximately 500K to approximately 10M, from approximately 500K to approximately 100M, from approximately 1M to approximately 5M, from approximately 1M to approximately 10M, from approximately 1M to approximately 100M, from approximately 5M to approximately 10M, from approximately 5M to approximately 100M, or from approximately 10M to approximately 100M cell boundaries.

[0071] GUI In various embodiments, the methods, systems, and media disclosed by the present invention further include client computing devices. In various embodiments, the methods, systems, and media disclosed by the present invention further include the ability to render cell boundaries on a GUI. In some embodiments, it further includes rendering on the GUI approximately 1, approximately 10, approximately 100, approximately 1000, approximately 10000, approximately 100000, approximately 2000000, approximately 500K, approximately 1M, approximately 5M, approximately 10M, or approximately 100M cell boundaries. In some embodiments, it further includes rendering on the GUI at least approximately 1, at least approximately 10, at least approximately 100, at least approximately 1000, at least approximately 10K, at least approximately 100K, at least approximately 200K, at least approximately 500K, at least approximately 1M, at least approximately 5M, at least approximately 10M, or at least approximately 100M cell boundaries. In some embodiments, it further includes rendering on the GUI from approximately 1 to approximately 10, from approximately 1 to approximately 100, from approximately 1 to approximately 1000, from approximately 1 to approximately 10K, from approximately 1 to approximately 100K, from approximately 1 to approximately 200K, from approximately 1 to approximately 500K, from approximately 1 to approximately 1M, from approximately 1 to approximately 5M, from approximately 1 to approximately 10M, from approximately 1 to approximately 100M, from approximately 10 to approximately 100, from approximately 10 to approximately 1000, from approximately 10 to approximately 10K, from approximately 10 to approximately 100K, from approximately 10 to approximately 200K, from approximately 10 to approximately 500K, from approximately 10 to approximately 1M, from approximately 10 to approximately 5M, from approximately 10 to approximately 10M, from approximately 10 to approximately 100M, from approximately 100 to approximately 1000, from approximately 100 to approximately 10K, from approximately 100 to approximately 100K, from approximately 100 to approximately 200K, from approximately 100 to approximately 500K, from approximately 100 to approximately 1M, from approximately 100 to approximately 5M, from approximately 100 to approximately 10M, from approximately 100 to approximately 100M, from approximately 1000 to approximately 10K, from approximately 1000 to approximately 100K, from approximately 1000 to approximately 200K, from approximately 1000 to approximately 500K, from approximately 1000 to approximately 1M, from approximately 1000 to approximately 5M, from approximately 1000 to approximately 10M, from approximately 1000 to approximately 100M, from approximately 10K to approximately 100K, from approximately 10K to approximately 200K, from approximately 10K to approximately 500K, from approximately 10K to approximately 1M, from approximately 10K to approximately 5M, from approximately 10K to approximately 10M, from approximately 10K to approximately 100M, from approximately 100K to approximately 200K, from approximately 100K to approximately 500K, from approximately 100K to approximately 1M, from approximately 100K to approximately 5M, from approximately 100K to approximately 10M, from approximately 100K to approximately 100M, from approximately 200K to approximately 500K, from approximately 200K to approximately 1M, from approximately 200K to approximately 5M, from approximately 200K to approximately 10M, from approximately 200K to approximately 100M, from approximately 500K to approximately 1M, from approximately 500K to approximately 5M, from approximately 500K to approximately 10M, from approximately 500K to approximately 100M, from approximately 1M to approximately 5M, from approximately 1M to approximately 10M, from approximately 1M to approximately 100M, from approximately 5M to approximately 10M, from approximately 5M to approximately 100M, or from approximately 10M to approximately 100M cell boundaries.

[0072] Embodiment The following illustrative embodiments are used to illustrate the implementation manners of the software application, system, and method of the present invention, and do not mean to limit them in any way.

[0073] Embodiment 1 - Verification of Fast Polygon Self-Intersection Test for Moving Vertices Compared with the conventional brute-force algorithm, the performance of the fast polygon self-intersection test algorithm grows geometrically with the increase in the number of vertices. The fast polygon self-intersection test for moving vertices written in JavaScript was compared with the traditional brute-force algorithm on a web browser (Microsoft Edge). For a polygon with 50 vertices, the fast polygon self-intersection test is 100 times faster than the traditional algorithm. For a polygon with 100 vertices, it is 1,000 times faster.

[0074] Embodiment 2 - Verification of Cell Segmentation Images 1000-plex RNA analysis was performed on human tonsil sections on the CosMx™ Spatial Omics Single-Cell Imaging Platform. As Figure 7A shown, it shows a non-limiting example of a biological cell image after cell segmentation. The fields of view (FOVs) are evenly distributed on the tonsil to observe the expression in the germinal center and compare it with adjacent regions. The samples were stained with DAPI (where the cell nuclei appear blue) and CD298 / B2M (where the cell membranes appear yellow). As Figure 7A shown, after cell segmentation using the methods, systems, and media disclosed in the present invention, the cell boundaries are clearly shown around each cell nucleus; in contrast, Figure 7B shows an image before cell segmentation at the same FOV. Figure 7C shows an enlarged view with the same FOV. Figure 7D shows an enlarged image of cell segmentation with only cell nucleus staining; while Figure 7E shows an enlarged image of cell segmentation with both cell nucleus and cell membrane staining.

[0075] Although the preferred embodiments of the present invention have been shown and described herein, it will be apparent to those skilled in the art that these embodiments are provided by way of example only. Various changes, modifications, and substitutions can be envisioned by those skilled in the art without departing from the subject matter of the present invention. It should be understood that various alternatives to the embodiments described herein can be employed in practicing the subject matter of the present invention.

Claims

1. A computer-implemented method for generating a file defining biological image data, comprising: a) Retrieving, by a computer, the Cartesian coordinates of the vertices of non-intersecting polygons and following the polygonal path of the cell boundaries in a biological image, maintaining these vertices in order from a starting vertex to a last vertex; b) Storing, by a computer, the Cartesian coordinates of the starting vertex of the polygon in a data structure; c) Calculating, by a computer, the distance between the starting vertex and the last vertex; d) Selecting, by a computer, a matrix containing edge elements to represent different directions based on the distance; e) Designating, by a computer, the Cartesian coordinates of the first vertex in an ordered adjacent vertex pair as the polar reference coordinates of the matrix; f) Converting, by a computer, the Cartesian coordinates of the second vertex in the ordered adjacent vertex pair to the polar reference coordinates of the corresponding matrix; g) Designating, by a computer, the step size of the first vertex in the ordered adjacent vertex pair as the edge element of the second vertex in combination with the size of the matrix; h) Storing, by a computer, the step sizes of the vertices in the data structure in the order of the polygonal path; i) Storing, by a computer, the step sizes of all vertices in the data structure by iterating through e)-h); and, j) Generating, by a computer, a file defining the cell boundary from the data structure.

2. The method according to claim 1, characterized in that: The vertices are maintained in an array.

3. The method according to claim 1, wherein: It further includes a computer performing a quality assurance check on the Cartesian coordinates of the received non-intersecting polygon vertices, wherein the quality assurance check includes one or more of the following: a) Checking whether the polygon contains at least 3 vertices; b) Checking whether the polygonal path forms a closed loop; c) Checking whether the polygonal path contains a predefined direction; and d) Checking whether the vertex order along the polygonal path is in a continuous order.

4. The method according to claim 1, wherein: The step sizes include long step sizes.

5. The method according to claim 1, characterized in that: The step sizes include short step sizes.

6. The method according to claim 1, characterized in that: The matrix includes a 3X3, 4X4, 5X5, 6X6, 7X7, 8X8, 9X9, 10X10, 11X11, 12X12, 13X13, 14X14, 15X15, 16X16, 17X17, 18X18, 19X19, 20X20, 21X21, 22X22, 23X23, 24X24, 25X25, 26X26, 27X27, 28X28, 29X29, 30X30, 31X31, 32X32 or 33X33 matrix.

7. The method according to claim 1, characterized in that: The data structure includes 1 bit, 2 bits, 3 bits, 4 bits, 5 bits, 6 bits, 7 bits or 8 bits for storing each step size.

8. The method according to claim 1, wherein: The data structure includes 1 byte, 2 bytes, 3 bytes or 4 bytes for storing each step size.

9. The method according to claim 1, characterized in that: h) It further includes storing a terminator for the last vertex of the polygon.

10. The method according to claim 1, wherein: It further includes receiving a biological image.

11. The method according to claim 1, characterized in that: The biological image includes a 2D image.

12. The method according to claim 11, wherein: The Cartesian coordinates are 2D coordinates.

13. The method according to claim 1, characterized in that: The biological image includes a 3D image.

14. The method according to claim 13, characterized in that: The Cartesian coordinates are 3D coordinates.

15. The method according to claim 1, characterized in that: The distance includes Euclidean distance.

16. The method according to claim 1, wherein: The distance includes the difference of one-dimensional Cartesian coordinates.

17. The method according to claim 1, characterized in that: The distance includes the maximum value of the Cartesian coordinate differences in all dimensions.

18. The method according to claim 1, characterized in that: The distance includes the minimum value of the Cartesian coordinate differences in all dimensions.

19. The method according to claim 1, wherein: The distance includes the arithmetic mean of the Cartesian coordinate differences in all dimensions.

20. The method according to claim 1, wherein: It also includes data for compressing all vertices of the cell boundary in the data structure by a computer.

21. The method according to claim 1, wherein: The computer includes a client computing device.

22. The method according to claim 1, wherein: It also includes rendering the cell boundary on the GUI.

23. The method according to claim 22, wherein: It also includes rendering at least 100K, 500K, 1M, 5M, or 10M cell boundaries.

24. The method according to claim 1, wherein: The file includes the definition of at least 100K, 500K, 1M, 5M, or 10M cell boundaries.

25. A computer-implemented system, comprising at least one processor and instructions executable by the at least one processor to provide an application including the following: a) A software module that retrieves the Cartesian coordinates of the vertices of non-intersecting polygons, follows the polygonal path of the cell boundary in a biological image, and maintains these vertices in order from the starting vertex to the last vertex; b) A software module that stores the Cartesian coordinates of the starting vertex of the polygon in a data structure; c) A software module that calculates the distance between the starting vertex and the last vertex; d) A software module that selects a matrix containing edge elements to represent different directions based on the distance; e) A software module that designates the Cartesian coordinates of the first vertex in an ordered adjacent vertex pair as the polar reference coordinates of the matrix; f) A software module that converts the Cartesian coordinates of the second vertex in the ordered adjacent vertex pair into a reference of the polar coordinates of the corresponding matrix; g) A software module that designates the step size of the first vertex in the ordered adjacent vertex pair as the edge element of the second vertex in combination with the matrix size; h) A software module that stores the step sizes of the vertices in order of the polygonal path in the data structure; i) A software module that stores the step sizes of all vertices in the data structure by iterating through e)-h); and j) A software module that generates a file defining the cell boundary from the data structure.

26. The system according to claim 25, wherein: The vertices are maintained in an array.

27. The system according to claim 25, characterized in that: The application also includes a software module that performs a quality assurance check on the received Cartesian coordinates of the non-intersecting polygon vertices, where the quality assurance check includes one or more of the following: a) Checking whether the polygon contains at least 3 vertices; b) Checking whether the polygonal path forms a closed loop; c) Checking whether the polygonal path contains a predefined direction; and d) Checking whether the order of the vertices along the polygonal path is in a continuous order.

28. The system according to claim 25, wherein: The step sizes include long step sizes.

29. The system according to claim 25, wherein: The step sizes include short step sizes.

30. The system according to claim 25, wherein: The matrix includes a 3X3, 4X4, 5X5, 6X6, 7X7, 8X8, 9X9, 10X10, 11X11, 12X12, 13X13, 14X14, 15X15, 16X16, 17X17, 18X18, 19X19, 20X20, 21X21, 22X22, 23X23, 24X24, 25X25, 26X26, 27X27, 28X28, 29X29, 30X30, 31X31, 32X32 or 33X33 matrix.

31. The system according to claim 25, wherein: The data structure includes 1 bit, 2 bits, 3 bits, 4 bits, 5 bits, 6 bits, 7 bits or 8 bits for storing each step size.

32. The system according to claim 25, wherein: The data structure includes 1 byte, 2 bytes, 3 bytes or 4 bytes for storing each step size.

33. The system according to claim 25, wherein: h) The software module further includes a terminator for storing the last vertex of the polygon.

34. The system according to claim 25, wherein: The application further includes a software module for receiving a biological image.

35. The system according to claim 25, wherein: The biological image includes a 2D image.

36. The system according to claim 35, characterized in that: The Cartesian coordinates are 2D coordinates.

37. The system according to claim 25, wherein: The biological image includes a 3D image.

38. The system according to claim 37, wherein: The Cartesian coordinates are 3D coordinates.

39. The system according to claim 25, characterized in that: The distance includes the Euclidean distance.

40. The system according to claim 25, wherein: The distance includes the difference of one-dimensional Cartesian coordinates.

41. The system according to claim 25, wherein: The distance includes the maximum value of the differences of Cartesian coordinates in all dimensions.

42. The system according to claim 25, wherein: The distance includes the minimum value of the differences of Cartesian coordinates in all dimensions.

43. The system according to claim 25, wherein: The distance includes the arithmetic mean of the differences of Cartesian coordinates in all dimensions.

44. The system according to claim 25, wherein: The application further includes a software module for compressing the data of all vertices of the cell boundary in the data structure.

45. The system according to claim 25, wherein: A client computing device is further included.

46. The system according to claim 25, wherein: The application further includes a software module for rendering the cell boundary on the GUI.

47. The system according to claim 46, characterized in that: The software module for rendering the cell boundary on the GUI renders at least 100K, 500K, 1M, 5M or 10M cell boundaries.

48. The system according to claim 25, wherein: The file includes the definition of at least 100K, 500K, 1M, 5M or 10M cell boundaries.

49. A non-transitory computer-readable storage medium encoded with instructions executable by one or more processors to cause the one or more processors to perform the following operations, the operations including: a) Retrieving the Cartesian coordinates of the vertices of non-intersecting polygons; b) Following the polygonal path of the cell boundary in the biological image and maintaining these vertices in the order from the starting vertex to the last vertex; c) Storing the Cartesian coordinates of the starting vertex of the polygon in the data structure; d) Calculating the distance between the starting vertex and the last vertex; e) Selecting a matrix containing edge elements to represent different directions based on the distance; f) Designating the Cartesian coordinates of the first vertex in the ordered adjacent vertex pair as the polar reference coordinates of the matrix; g) Converting the Cartesian coordinates of the second vertex in the ordered adjacent vertex pair into the reference of the polar coordinates of the corresponding matrix; h) Combining the size of the matrix and designating the step size of the first vertex in the ordered adjacent vertex pair as the edge element of the second vertex; i) Storing the step size of the vertex in the data structure in the order of the polygonal path; j) Storing the step sizes of all vertices in the data structure by iterating through f)-i); and, k) Generate a file defining the cell boundary from the said data structure.

50. The non-transitory computer-readable storage medium according to claim 49, wherein: The vertices are maintained in an array.

51. The non-transitory computer-readable storage medium according to claim 49, wherein: The operation further includes a software module for performing quality assurance checks on the Cartesian coordinates of the received non-intersecting polygon vertices, wherein the quality assurance checks include one or more of the following: a) Check whether the polygon contains at least 3 vertices; b) Check whether the polygon path forms a closed loop; c) Check whether the polygon path contains a defined direction; and d) Check whether the vertex order along the polygon path is in a consecutive order.

52. The non-transitory computer-readable storage medium according to claim 49, wherein: The step sizes include long step sizes.

53. The non-transitory computer-readable storage medium according to claim 49, wherein: The step sizes include short step sizes.

54. The non-transitory computer-readable storage medium according to claim 49, wherein: The matrices include 3X3, 4X4, 5X5, 6X6, 7X7, 8X8, 9X9, 10X10, 11X11, 12X12, 13X13, 14X14, 15X15, 16X16, 17X17, 18X18, 19X19, 20X20, 21X21, 22X22, 23X23, 24X24, 25X25, 26X26, 27X27, 28X28, 29X29, 30X30, 31X31, 32X32 or 33X33 matrices.

55. The non-transitory computer-readable storage medium according to claim 49, wherein: The data structure includes 1 bit, 2 bits, 3 bits, 4 bits, 5 bits, 6 bits, 7 bits or 8 bits for storing each step size.

56. The non-transitory computer-readable storage medium according to claim 49, wherein: The data structure includes 1 byte, 2 bytes, 3 bytes or 4 bytes for storing each step size.

57. The non-transitory computer-readable storage medium according to claim 49, wherein: i) The operation further includes storing a terminator for the last vertex of the polygon.

58. The non-transitory computer-readable storage medium according to claim 49, wherein: The operation further includes receiving a biological image.

59. The non-transitory computer-readable storage medium according to claim 49, wherein: The biological image includes a 2D image.

60. The non-transitory computer-readable storage medium according to claim 59, wherein: The Cartesian coordinates are 2D coordinates.

61. The non-transitory computer-readable storage medium according to claim 49, wherein: The biological image includes a 3D image.

62. The non-transitory computer-readable storage medium according to claim 61, wherein: The Cartesian coordinates are 3D coordinates.

63. The non-transitory computer-readable storage medium according to claim 49, wherein: The distances include Euclidean distances.

64. The non-transitory computer-readable storage medium according to claim 49, wherein: The distances include the differences of one-dimensional Cartesian coordinates.

65. The non-transitory computer-readable storage medium according to claim 49, wherein: The distances include the maximum value of the differences of Cartesian coordinates in all dimensions.

66. The non-transitory computer-readable storage medium according to claim 49, wherein: The distances include the minimum value of the differences of Cartesian coordinates in all dimensions.

67. The non-transitory computer-readable storage medium according to claim 49, wherein: The distances include the arithmetic mean of the differences of Cartesian coordinates in all dimensions.

68. The non-transitory computer-readable storage medium according to claim 49, wherein: The operation further includes compressing the data of all vertices of the cell boundary in the data structure.

69. The non-transitory computer-readable storage medium according to claim 49, wherein: A client computing device is further included.

70. The non-transitory computer-readable storage medium according to claim 49, wherein: The operation further includes rendering the cell boundary on the GUI.

71. The non-transitory computer-readable storage medium according to claim 70, wherein: The operation further includes rendering at least 100K, 500K, 1M, 5M or 10M cell boundaries.

72. The non-transitory computer-readable storage medium according to claim 49, wherein: The file includes the definitions of at least 100K, 500K, 1M, 5M or 10M cell boundaries.

Images