fix docs adding api

Author: BadPrograms

docs/api.md

@@ -1 +1 @@
-:::LineageTree
+::: lineagetree.measure

docs/glossary.md

@@ -1,64 +1,54 @@
 
 This tool may interest individuals with and without a background in computer science, so all users need to become familiar with the nomenclature used by LineageTree. To that end, this glossary defines the terms used throughout the project.
 
-- ### Trees
-
- A tree is a hierarchical acyclic graph that contains nodes and edges, lineageTree works with at most 2 successors for one node. To create a demo tree the user can call
+- ### Tree Graphs
+ A tree graph is a hierarchical acyclic graph that contains nodes and edges, **LineageTree is a tree graph** that has at most 2 successors for one node. To create a demo tree the user can call
 
 ```python
 from lineagetree import LineageTree
 lT = LineageTree(successors= {i:[i+1] for i in range(10)})
 ```
 
  ![Image for glossary](./images/glossary_image.png)
-> The differences between a biological lineage and a LineageTree lineage
+> The differences between a biological lineage and a LineageTree.
 
 - ### Nodes
-
- The smallest part of a tree, a point that may or may not connect to others. The set of all the nodes may be accessed by ```lT.nodes```
+ The **smallest part of a LineageTree**, a point that may or may not connect to others. The set of all the nodes may be accessed by ```lT.nodes```
 
 - ### Edges
-
- The lTect that connects 2 nodes, in the case of the tree its also directed (goes one way). The edges may be accessed throug ```lT.edges```
+ The object that **connects 2 nodes**, in the case of the tree its also directed (goes one way). The edges may be accessed through ```lT.edges```
 
 - ### Successors
-
- The successor of a node n is a node connected with an edge to the node n that exists one level (timepoint) lower than n. The immutable dictionary (MappingProxy) of all the successors may be accessed by ```lT.successor```
+ The successor of a **node n in timepoint t is the node n' in timepoint t+1** and is connected to the node n. The immutable dictionary (MappingProxy) of all the successors may be accessed by ```lT.successor```
 
 - ### Predecessors
-
- The predecessor of a node n is a node connected to the node that exists one time point higher than n. The immutable dictionary (MappingProxy) of all the predecessors may be accessed by ```lT.predecessor```
+ The predecessor of a **node n in timepoint t is the node n' in timepoint t-1** and is connected to the node n. The immutable dictionary (MappingProxy) of all the predecessors may be accessed by ```lT.predecessor```
 
 - ### Roots
-
- The root of a tree is a node that has no predecessors. In the case of lineageTree the root has an empty tuple as predecessor. LineageTree allows for many roots to exist in the same file. The set of roots may be accessed by using ```lT.roots```
+ The root of a tree is **a node that has no predecessors**. In the case of lineageTree the root has an empty tuple as predecessor. LineageTree allows for many roots to exist in the same file. The set of roots may be accessed by using ```lT.roots```
 
 - ### Leaves
-
- The leaf of a tree is a node that has no successors. In the case of lineageTree the leaf has an empty tuple as a successor. The set of leaves may be accessed through ```lT.leaves```
-
-- ### Divisions
-
- An event where one node has 2 successors instead of one. There is no direct way to access a division; however, the node that is before a division (or after) is always at the end or start of a chain (except for the cases that the chain contains a leaf or a root)
+ The leaf of a tree is **a node that has no successors**. In the case of lineageTree the leaf has an empty tuple as a successor. The set of leaves may be accessed through ```lT.leaves```
 
 - ### Chains
+ A **tree segment**, where **all nodes are between a division or root and a division or a leaf**. To access a chain that contains a specific node `n`, the user may use:``` lT.get_chain_of_node(n) ```
+ A continuous subset of a chain may be referred to as a subchain or a path, which is not a chain.
 
- A tree segment, where all nodes are between a division or root and a division or a leaf. To access a chain that contains a specific node `n`, the user may use:``` lT.get_chain_of_node(n) ```
-A continuous subset of a chain may be referred to as a subchain or a path, which is not a chain.
+- ### Divisions
+ An event where **one node has 2 successors** instead of one. There is no direct way to access a division; however, the node that is before a division (or after) is always at the end or start of a chain (except for the cases that the chain contains a leaf or a root)
 
 - ### Subtree
-
- Any segment of a tree that is also a tree. Using the function ```lT.get_sub_tree(node)``` will not provide a new lineageTree but a list of all the nodes contained inside the subtree.
+ Any segment of a tree that is also a tree. The function ```lT.get_sub_tree(node)``` will return a list of all the nodes contained inside the subtree.
 
 - ### Siblings
-
- Two nodes that have the same predecessor. Often used for chains where the first node of each chain has the same predecessor as the other one.
+ **Two nodes that have the same predecessor**. Often used for chains where the first node of each chain has the same predecessor as the other one.
 
 - ### Time
-
  The time point at which the nodes exist. This property concerns time points and is not real time.
  The immutable dictionary (MappingProxy) containing the time information for all the nodes may be accessed through ```lT.times```.
 
 - ### Time resolution
-
  How long one time point lasts, relevant only for comparisons across lineages. This attribute can be a property or inspected by ```lT.time_resolution```.
+
+#### API reference
+

docs/images/glossary_image.png

@@ -1,19 +1,24 @@
 # Welcome to LineageTree Documentation
 
-LineageTree is a Python framework specialized in cell tracking data. It supports importing standard or custom formats and comprehensive processing and comparison analysis capabilities.
+LineageTree is a Python framework specialized in analyzing cell tracking data. It supports standard or custom tracking data formats and allows comprehensive processing and pairwise distance calculation.
 
 ## Why should I use LineageTree?
 
 <p style="text-align: justify;">
 
-How does a cluster of cells become organized? Do cells move and divide randomly until an organism starts to exist? People from multiple fields have worked tirelessly to answer such questions, resulting in better microscopy techniques to image embryos developing in real time and software that allows users to track nuclei or particles inside the organisms. Many scientists have developed algorithms analyzing the positions of all these particles, however, there is a lack of software that takes time and division patterns into account. LineageTree offers out-of-the-box algorithms to compare lineage data to extract results on the similarity of lineages. It also offers a strong enough backbone for the user to build their algorithms to analyze time and spatial data. One type of lineage data analysis is lineage comparison, which can provide useful information on how variable the development of an organism is, or extract information on fate gain or loss, or check for symmetric lineages in one organism. A napari plugin called [ReLAX](http://127.0.0.1:8000/). accompanies this framework, where the user can explore a digital clone of the embryo on both spatial and image data (4D 3D+time), label different lineages, and perform systematic comparison analysis on imported lineages.
-Using LineageTree the user can:
+How does a cluster of cells become organized? Do cells move and divide randomly until an organism starts to exist? People from multiple fields have worked tirelessly to answer such questions, resulting in better microscopy techniques to image embryos developing in real time and software that allows users to track nuclei or particles inside the organisms. Many scientists have developed algorithms analyzing the positions of all these particles, however, there is a lack of software that takes time and division patterns into account. LineageTree offers out-of-the-box algorithms to compare lineage data to extract results on the similarity of lineages. It also offers a strong enough backbone for the user to build their algorithms to analyze time and spatial data.
 </p>
+<!-- <p style="text-align: justify;"> -->
+
+One type of lineage data analysis is lineage comparison, which can provide useful information on how variable the development of an organism is, or extract information on fate gain or loss, or check for symmetric lineages in one organism. A napari plugin called [ReLAX](https://guignardlab.github.io/napari-relax/). accompanies this framework, where the user can explore a digital clone of the embryo on both spatial and temporal data, label different lineages, and perform systematic comparison analysis on imported lineages.
+<!-- </p> -->
+
+Using LineageTree the user can:
 
-- Import any tracking format (link to loaders)
-- Perform analysis on the data ( link to tree_styles) (maybe talk a bit about the spatial algorithms)?
-- Perform unordered tree edit distance analysis using different heuristics (tree_Styles)
-- Visualize lineages imported (plot_node, plot_lineages)
+- [Import any tracking format](./loaders.md)
+- Perform spatial analysis on the data
+- Perform [unordered tree edit distance analysis](./uted.md) using different heuristics 
+- [Visualize lineages](./viz.md) imported
 
 ## Quick Installation
 

docs/images/image39151.png

@@ -1,5 +1,5 @@
 
-# Loaders
+### Premade Loaders
 
 Multiple well known formats are ready for import out of the box:
 
@@ -25,7 +25,7 @@ Other attributes that can be used to initiate a lineageTree file apart from the
 
 - **kwargs: Any other dictionary provided during imaging can be loaded into lineageTree. The format is {unique_id: value}
 
-### Example of loading and template with **kwargs
+### Custom Loaders
 
 ```python
 
@@ -82,4 +82,6 @@ def template_load(path, name=None):
    )
 ```
 
-:::LineageTree.loaders
+### API reference for existing loaders
+
+#### ::: lineagetree._io

docs/index.md

@@ -124,14 +124,52 @@ This section is focused on showcasing the advantages and disadvantages of the tr
 
 ![synthetic_trees](./images/synthetic_trees.png)
 
-## Tree distance Graphs
+<!-- ### API reference
+
+#### :::lineagetree.measure.unordered_tree_edit_distance
+#### :::lineagetree.measure.unordered_tree_edit_distances_at_time_t
+#### :::lineagetree.measure.clear_comparisons -->
+## API reference for uted
+
+### ::: lineagetree.measure
+    options:
+      filters:
+        - "^unordered_tree_edit_distance$"
+        - "^unordered_tree_edit_distances_at_time_t$"
+        - "^clear_comparisons$"
+
+
+## Using the Matching Component of UTED
+
+UTED calculates distances between two tree graphs by matching their nodes. Extracting the matched nodes provides important information, particularly for labeled datasets. For example, when calculating the distance between two embryos, we can identify which clone or sublineage in one embryo corresponds to a clone or sublineage in the other. To support this, UTED includes functions specifically designed to find the matching between two lineages.
+
+#### API
+
+#### ::: lineagetree.measure
+    options:
+      filters:
+        - "^labelled_mappings$"
+
+
+
+### Tree distance Graphs
 
 <p style="text-align: justify;">
 
-The distance value is a very useful metric to check the similarity of two lineages, however its just a distance, it does not give you further information. A user should not only know how similar a tree is to another, but also which sublineages/subtrees are similar and which are not! Fortunately, we realized that we can extract important information during an important step of the algorithm, the matched pairs created during the mapping process and plot them into a new graph, called the tree distance graph. To produce these graphs, we color each chain that has been mapped with the value of the subtree spawned by these chains, showing a metric that can be interpreted as the quality of mapping. Such graphs can show two very significant things:
+The distance value is a useful metric for quantifying the similarity between two lineages, but it does not provide detailed information about which sublineages are similar or different. To address this, UTED generates tree distance graphs by leveraging the matched pairs produced during the mapping process.
+
+In these graphs, each matched chain is colored according to the value of its subtree, providing a visual representation of mapping quality. Tree distance graphs reveal two important aspects:
+
+- Variance: The color spectrum highlights the distances of mapped chains. Colors representing good mappings indicate low variance during development.
+
+- Gain or Loss of Function: Unmapped regions indicate lineages that exist in one tree but not the other. This may reflect biological differences, such as the emergence or loss of a lineage, or it may point to data quality issues.
 </p>
-- Variance: Such graphs will use a spectrum of colors to show the distances that are mapped and how well their mapping is, so colors that correspond to the good mapping indicate small variance during development.
+![add_an_example](./images/image39151.png)
+
 
-- Gain or loss of function, the unmapped regions can be interpreted as regions, where no region of one tree corresponds to the one with unmapped (of course this may also happen due to a bad dataset), which means that there is a lineage that does not exist in the other, a new lineage, the organism gained or lost a function!
+#### API
 
-![add_an_example](tree_distance_graph.png)
+#### ::: lineagetree.measure
+    options:
+      filters:
+        - "^plot_tree_distance_graphs$"

docs/loaders.md

@@ -7,3 +7,7 @@ Usually, tracked lineages contain hundreds of thousands of nodes, thus calculati
 ![viz](./images/2_trees.png)
 
 This way, the whole lineage can be plotted efficiently, even if the second graph is more representative of the truth.
+
+### API Reference
+
+#### ::: lineagetree.plot

docs/uted.md

@@ -18,13 +18,21 @@ theme:
   - navigation.path
   - navigation.expand
   - content.code.annotate
+markdown_extensions:
+  - toc:
+      permalink: true
+  - tables
+  - pymdownx.superfences   
 plugins:
 - mkdocstrings:
     handlers:
       python:
+        setup_commands:
+            - import os, sys
+            - sys.path.append(os.path.abspath("._io"))
         options:
-          show_submodules: true
           docstring_style: numpy
+          
 nav:
   - Home: index.md
   - Getting started:

docs/viz.md

@@ -14,6 +14,7 @@
     read_from_txt_for_celegans_CAO,
     LOADERS,
 )
+
 from .lineage_tree_manager import LineageTreeManager
 
 __all__ = (
@@ -31,4 +32,4 @@
     "read_from_txt_for_celegans",
     "read_from_txt_for_celegans_CAO",
     "LOADERS",
-)
+)