cellmaps-utils 0.10.0__py3-none-any.whl

cellmaps_utils/hcx_utils.py

@@ -0,0 +1,198 @@
+import json
+import os
+
+import ndex2
+from ndex2.cx2 import CX2Network, RawCX2NetworkFactory
+
+from cellmaps_utils.exceptions import CellMapsError
+
+
+def get_host_and_uuid_from_network_url(network_url):
+    """
+    Extracts the host and UUID from a given NDEx network URL.
+
+    :param network_url: The URL of the NDEx network.
+    :type network_url: str
+    :return: A tuple containing the host and the UUID of the network.
+    :rtype: tuple
+    """
+    if network_url is None:
+        return None, None
+    parts = network_url.replace('https://', '').replace('http:/', '').split('/')
+    host, uuid = parts[0], parts[-1]
+    return host, uuid
+
+
+def get_interactome(host, uuid, username, password, parent_edgelist):
+    """
+    Retrieves the interactome either from NDEx or from a local edge list.
+
+    :param host: The NDEx server host.
+    :type host: str
+    :param uuid: The UUID of the interactome network in NDEx.
+    :type uuid: str
+    :param username: The NDEx username for authentication.
+    :type username: str
+    :param password: The NDEx password for authentication.
+    :type password: str
+    :param parent_edgelist: Path to a file containing the interactome edge list.
+    :type parent_edgelist: str
+    :return: A CX2Network object representing the interactome.
+    :rtype: CX2Network
+    """
+    interactome = CX2Network()
+    if parent_edgelist is not None:
+        with open(parent_edgelist, 'r') as f:
+            for line in f:
+                parts = line.split()
+                id_source_node = interactome.lookup_node_id_by_name(parts[0])
+                source_node = id_source_node if id_source_node is not None else interactome.add_node(
+                    attributes={'name': parts[0]})
+                id_target_node = interactome.lookup_node_id_by_name(parts[1])
+                target_node = id_target_node if id_target_node is not None else interactome.add_node(
+                    attributes={'name': parts[1]})
+                interactome.add_edge(source=source_node, target=target_node)
+    elif host is not None and uuid is not None:
+        client = ndex2.client.Ndex2(host=host, username=username, password=password)
+        factory = RawCX2NetworkFactory()
+        client_resp = client.get_network_as_cx2_stream(uuid)
+        interactome = factory.get_cx2network(json.loads(client_resp.content))
+    return interactome
+
+
+def get_root_nodes(hierarchy):
+    """
+    Identifies the root nodes in a hierarchical network.
+
+    In CDAPS the root node has only source edges to children
+    so this function counts up number of target edges for each node
+    and the one with 0 is the root
+
+    :return: root node ids
+    :rtype: set
+    """
+    all_nodes = set()
+    for node_id, node_obj in hierarchy.get_nodes().items():
+        all_nodes.add(node_id)
+
+    nodes_with_targets = set()
+    for edge_id, edge_obj in hierarchy.get_edges().items():
+        nodes_with_targets.add(edge_obj['t'])
+    return all_nodes.difference(nodes_with_targets)
+
+
+def add_isroot_node_attribute(hierarchy, root_nodes):
+    """
+    Using the **root_nodes** set or list, add
+    ``HCX::isRoot`` to
+    every node setting value to ``True``
+    if node id is in **root_nodes**
+    otherwise set the value to ``False``
+    """
+    attr_name = 'HCX::isRoot'
+    for node_id, node_obj in hierarchy.get_nodes().items():
+        if node_id in root_nodes:
+            hierarchy.add_node_attribute(node_id, attr_name, True)
+        else:
+            hierarchy.add_node_attribute(node_id, attr_name, False)
+
+
+def add_hcx_network_annotations(hierarchy, interactome=None, output_dir='.',
+                                interactome_name='hierarchy_parent.cx2', host='www.ndexbio.org', uuid=None):
+    """
+    Adds HCX network annotations to the hierarchy.
+
+    :param hierarchy: The hierarchical network in CX2 format.
+    :type hierarchy: CX2Network
+    :param interactome: The interactome network.
+    :type interactome: CX2Network, optional
+    :param output_dir: Directory where the interactome file will be saved.
+    :type output_dir: str, optional
+    :param interactome_name: Name of the interactome file.
+    :type interactome_name: str, optional
+    :param host: NDEx host for interactome retrieval.
+    :type host: str, optional
+    :param uuid: UUID of the interactome in NDEx.
+    :type uuid: str, optional
+    :return: The updated hierarchy network with annotations.
+    :rtype: CX2Network
+    """
+    if not isinstance(hierarchy, CX2Network):
+        raise CellMapsError("Hierarchy must be an instance of CX2Network.")
+    if uuid is None and interactome is None:
+        raise CellMapsError("UUID of interactome or interactome (instance of CX2Network) must be specified!")
+
+    hierarchy.add_network_attribute('ndexSchema', 'hierarchy_v0.1',
+                                    datatype='string')
+    hierarchy.add_network_attribute('HCX::modelFileCount', '2',
+                                    datatype='integer')
+
+    if host and uuid:
+        hierarchy.add_network_attribute('HCX::interactionNetworkHost', host)
+        hierarchy.add_network_attribute('HCX::interactionNetworkUUID', uuid)
+    else:
+        interactome_path = os.path.join(output_dir, interactome_name)
+        interactome.write_as_raw_cx2(interactome_path)
+        hierarchy.add_network_attribute('HCX::interactionNetworkName', interactome_name,
+                                        datatype='string')
+    return hierarchy
+
+
+def add_hcx_members_annotation(hierarchy, interactome, gene_column='CD_MemberList'):
+    """
+    Adds the 'HCX::members' attribute to nodes in the hierarchy based on the interactome.
+
+    :param hierarchy: The hierarchical network in CX2 format.
+    :type hierarchy: CX2Network
+    :param interactome: The interactome network.
+    :type interactome: CX2Network
+    :param gene_column: Column name containing gene members.
+    :type gene_column: str, optional
+    """
+    for node_id, node_obj in hierarchy.get_nodes().items():
+        memberlist = hierarchy.get_node(node_id).get('v', {}).get(gene_column, '').split(' ')
+        membersids = []
+        for member in memberlist:
+            id_interactome = interactome.lookup_node_id_by_name(member)
+            if id_interactome is not None:
+                membersids.append(id_interactome)
+        hierarchy.add_node_attribute(node_id, 'HCX::members', membersids, datatype='list_of_integer')
+
+
+def convert_hierarchical_network_to_hcx(hierarchy, interactome_url, ndex_username=None, ndex_password=None,
+                                        gene_column='CD_MemberList'):
+    """
+    Converts a hierarchical network into HCX format by adding necessary annotations and interactome details.
+
+    :param hierarchy: The hierarchical network in CX2 format or a path to the CX2 file.
+    :type hierarchy: CX2Network or str
+    :param interactome_url: URL of the interactome network in NDEx.
+    :type interactome_url: str
+    :param ndex_username: NDEx username for authentication.
+    :type ndex_username: str, optional
+    :param ndex_password: NDEx password for authentication.
+    :type ndex_password: str, optional
+    :param gene_column: Column name containing gene members.
+    :type gene_column: str, optional
+    :return: The updated hierarchy network in CX2 format with HCX annotations.
+    :rtype: CX2Network
+    """
+    factory = RawCX2NetworkFactory()
+    if isinstance(hierarchy, str):
+        hierarchy = factory.get_cx2network(hierarchy)
+
+    # Get the host and uuid of the interactome
+    host, uuid = get_host_and_uuid_from_network_url(interactome_url)
+    hierarchy = add_hcx_network_annotations(hierarchy, host=host, uuid=uuid)
+
+    # Create CX2Network object from interactome from NDEx
+    client = ndex2.client.Ndex2(host=host, username=ndex_username, password=ndex_password)
+    client_resp = client.get_network_as_cx2_stream(uuid)
+    interactome = factory.get_cx2network(json.loads(client_resp.content))
+
+    # Add HCX::members attribute to node attributes
+    add_hcx_members_annotation(hierarchy, interactome, gene_column)
+
+    # Add isRoot attribute to node attributes
+    add_isroot_node_attribute(hierarchy, get_root_nodes(hierarchy))
+    return hierarchy

cellmaps_utils/hidefconverter.py

@@ -0,0 +1,245 @@
+import json
+import logging
+import os
+
+import ndex2
+from ndex2.cx2 import RawCX2NetworkFactory, CX2Network
+import ndex2.constants as constants
+import cellmaps_utils.constants as cellmaps_constants
+from cellmaps_utils import hcx_utils
+from cellmaps_utils.exceptions import CellMapsError
+
+logger = logging.getLogger(__name__)
+
+
+class HierarchyToHiDeFConverter:
+    """
+    A class to convert a hierarchy network (in CX2 format) to a HiDeF format.
+    """
+    HIDEF_OUT_PREFIX = 'hidef_output_gene_names'
+
+    def __init__(self, output_dir, input_dir=None, hierarchy=None):
+        """
+        Constructor
+
+        :param input_dir: The directory containing the hierarchy file.
+        :type input_dir: str
+        :param output_dir: The directory where the output files will be stored.
+        :type output_dir: str
+        """
+        self.output_dir = output_dir
+        if hierarchy is None:
+            if input_dir is None:
+                raise CellMapsError("Either hierarch_path or input_dir should be specified!")
+            self.hierarchy_path = os.path.join(input_dir,
+                                               cellmaps_constants.HIERARCHY_NETWORK_PREFIX +
+                                               cellmaps_constants.CX2_SUFFIX)
+        else:
+            self.hierarchy_path = hierarchy
+        try:
+            factory = RawCX2NetworkFactory()
+            self.hierarchy = factory.get_cx2network(self.hierarchy_path)
+        except Exception as e:
+            logger.error(f"Failed to load hierarchy: {e}")
+            raise CellMapsError(f"Failed to load hierarchy: {e}")
+
+    def generate_hidef_files(self, nodes_filename=HIDEF_OUT_PREFIX + '.nodes',
+                             edges_filename=HIDEF_OUT_PREFIX + '.edges'):
+        """
+        Generates HiDeF files .nodes and .edges from the hierarchy network.
+        """
+        try:
+            nodes = self.hierarchy.get_nodes()
+            edges = self.hierarchy.get_edges()
+            formatted_nodes = self._format_aspect(nodes, self._format_node)
+            formatted_edges = self._format_aspect(edges, self._format_edge)
+            nodes_path = self._write_to_file(nodes_filename, formatted_nodes)
+            edges_path = self._write_to_file(edges_filename, formatted_edges)
+            return nodes_path, edges_path
+        except Exception as e:
+            logger.error(f"Error during HiDeF generation: {e}")
+            raise CellMapsError(f"Error during HiDeF generation: {e}")
+
+    @staticmethod
+    def _format_aspect(aspect, format_function):
+        """
+        Formats aspect list (nodes or edges) using a specified format function.
+
+        :param aspect: A list of aspect IDs (nodes or edges).
+        :type aspect: dict
+        :param format_function: A function to format a single entity.
+        :type format_function: function
+        :return: A list of formatted nodes or edges.
+        :rtype: list
+        """
+        return [format_function(aspect_id) for aspect_id in aspect]
+
+    def _format_node(self, node_id):
+        """
+        Formats a node for HiDeF output.
+
+        :param node_id: The ID of the node to be formatted.
+        :type node_id: int
+        :return: A formatted string representing the node.
+        :rtype: str
+        """
+        node = self.hierarchy.get_node(node_id)
+        node_attr = node[constants.ASPECT_VALUES]
+        formatted_node = (node_attr.get(constants.NODE_NAME_EXPANDED, node_id), node_attr.get('CD_MemberList_Size', 0),
+                          node_attr.get('CD_MemberList', ''), node_attr.get('HiDeF_persistence', 0))
+        return "\t".join(map(str, formatted_node))
+
+    def _format_edge(self, edge_id):
+        """
+        Formats an edge for HiDeF output.
+
+        :param edge_id: The ID of the edge to be formatted.
+        :type edge_id: int
+        :return: A formatted string representing the edge.
+        :rtype: str
+        """
+        edge = self.hierarchy.get_edge(edge_id)
+        source_node = self._find_node_name_by_id(edge[constants.EDGE_SOURCE])
+        target_node = self._find_node_name_by_id(edge[constants.EDGE_TARGET])
+        return f"{source_node}\t{target_node}\tdefault"
+
+    def _find_node_name_by_id(self, node_id):
+        """
+        Finds the name of a node given its ID.
+
+        :param node_id: The ID of the node.
+        :type node_id: int
+        :return: The name of the node.
+        :rtype: str
+        """
+        node = self.hierarchy.get_node(node_id)
+        return node[constants.ASPECT_VALUES].get(constants.NODE_NAME_EXPANDED, node_id)
+
+    def _write_to_file(self, filename, lines):
+        """
+        Writes output to a file.
+
+        :param filename: The name of the file to write to.
+        :type filename: str
+        :param lines: A list of strings to be written to the file.
+        :type lines: list
+        """
+        file_path = os.path.join(self.output_dir, filename)
+        with open(file_path, 'w') as file:
+            file.write('\n'.join(lines))
+        return file_path
+
+
+class HiDeFToHierarchyConverter:
+    """
+    A class to convert a edge list and node list in HiDeF format to hierarchy in HCX.
+
+    .. versionadded:: 0.5.0
+           The class was added to enable conversion from HiDeF-formatted edge and node files to hierarchy in HCX.
+    """
+
+    def __init__(self, output_dir, nodes_file_path, edges_file_path, parent_edgelist_path=None, parent_ndex_url=None,
+                 host='ndexbio.org', parent_uuid=None, ndex_user=None, ndex_password=None):
+        """
+        Initializes the converter with file paths and optional parent network details.
+
+        Parent network can be specified one of the following:
+        - edge list file
+        - link to interactome in NDEx
+        - uuid of NDEx network along with the host where the network is hosted.
+        If the network is private, username and password need to be specified.
+
+        :param output_dir: Directory where the output files will be stored.
+        :type output_dir: str
+        :param nodes_file_path: File path for the nodes file.
+        :type nodes_file_path: str
+        :param edges_file_path: File path for the edges file.
+        :type edges_file_path: str
+        :param parent_edgelist_path: Path to the edge list of the interactome (optional).
+        :type parent_edgelist_path: str, optional
+        :param parent_ndex_url: URL of parent interactome in NDEx (optional).
+        :type parent_ndex_url: str, optional
+        :param parent_uuid: UUID of the network in NDEx.
+        :type parent_uuid: str, optional
+        :param host: NDEx host.
+        :type host: str, optional
+        :param ndex_user: NDEx username (optional).
+        :type ndex_user: str, optional
+        :param ndex_password: NDEx password (optional).
+        :type ndex_password: str, optional
+        """
+        self.output_dir = output_dir
+        self.nodes_file_path = nodes_file_path
+        self.edges_file_path = edges_file_path
+        if parent_ndex_url is None and parent_edgelist_path is None:
+            raise CellMapsError("Specifying either url of parent interactome in NDEx, or edge list of the interactome"
+                                " is required!")
+        if parent_edgelist_path is not None and (parent_ndex_url is not None or parent_uuid is not None):
+            raise CellMapsError("You need to specify parent network as edge list in file, or as network in NDEx, "
+                                "not both!")
+        self.parent_edgelist = parent_edgelist_path
+        self.parent_url = parent_ndex_url
+        self.host = host
+        self.uuid = parent_uuid
+        self.username = ndex_user
+        self.password = ndex_password
+
+    def generate_hierarchy_hcx_file(self, hierarchy_filename='hierarchy.cx2',
+                                    interactome_filename='hierarchy_parent.cx2'):
+        """
+        Generates the HiDeF hierarchy file in CX2 format. If the object is initialized with parent network's edge list,
+        the interactome in CX2 format will be generated in output directory as well. If the object is initialized with
+        uuid of parent network, only hierarchy will be generated.
+
+        :param hierarchy_filename: The name of the file to write the hierarchy.
+        :type hierarchy_filename: str
+        :param interactome_filename: The name of the file to write the interactome (parent network of the hierarchy).
+        :type interactome_filename: str
+        """
+        hierarchy_path = os.path.join(self.output_dir, hierarchy_filename)
+        if self.parent_url is not None:
+            self.host, self.uuid = hcx_utils.get_host_and_uuid_from_network_url(self.parent_url)
+        interactome = hcx_utils.get_interactome(self.host, self.uuid, self.username, self.password,
+                                                self.parent_edgelist)
+        hierarchy = hcx_utils.add_hcx_network_annotations(self._get_hierarchy(interactome), interactome,
+                                                          self.output_dir, interactome_filename, self.host, self.uuid)
+        hierarchy.write_as_raw_cx2(hierarchy_path)
+
+    def _get_hierarchy(self, interactome):
+        """
+        Constructs the hierarchy based on the HiDeF edge list and node list and uses interactome to add HCX information.
+
+        :param interactome: The interactome network.
+        :type interactome: CX2Network
+        :return: A CX2Network object representing the hierarchy.
+        :rtype: CX2Network
+        """
+        hierarchy = CX2Network()
+
+        with open(self.nodes_file_path, 'r') as f:
+            for line in f:
+                name, size, genes, persistence = line.strip().split('\t')
+                hcx_members = []
+                for gene in genes.split():
+                    hcx_members.append(interactome.lookup_node_id_by_name(gene))
+                node_attributes = {
+                    constants.NODE_NAME_EXPANDED: name,
+                    'CD_MemberList_Size': size,
+                    'CD_MemberList': genes,
+                    'HCX::members': hcx_members,
+                    'HiDeF_persistence': persistence
+                }
+                hierarchy.add_node(attributes=node_attributes)
+
+        with open(self.edges_file_path, 'r') as f:
+            for line in f:
+                source, target, _ = line.strip().split('\t')
+                source_id = hierarchy.lookup_node_id_by_name(source)
+                target_id = hierarchy.lookup_node_id_by_name(target)
+                if source_id is not None and target_id is not None:
+                    hierarchy.add_edge(source=source_id, target=target_id)
+
+        root_nodes = hcx_utils.get_root_nodes(hierarchy)
+        hcx_utils.add_isroot_node_attribute(hierarchy, root_nodes=root_nodes)
+
+        return hierarchy

cellmaps_utils/hierdiff.py

@@ -0,0 +1,142 @@
+import logging
+
+import numpy as np
+import pandas as pd
+from ndex2.cx2 import RawCX2NetworkFactory, CX2Network
+
+logger = logging.getLogger(__name__)
+
+
+class HierarchyDiff:
+    """
+    A class to compare two hierarchies in CX2 (HCX)
+    """
+
+    def __init__(self):
+        """
+        Constructor
+        """
+        pass
+
+    @staticmethod
+    def _calculate_jaccard(setA, setB):
+        """
+        Calculate the Jaccard similarity between two sets.
+
+        The Jaccard similarity is defined as |A ∩ B| / |A ∪ B|.
+
+        :param setA: First set.
+        :type setA: set
+        :param setB: Second set.
+        :type setB: set
+        :return: The Jaccard similarity index.
+        :rtype: float
+        """
+        overlap = len(setA.intersection(setB))
+        union = len(setA.union(setB))
+        return overlap / union if union > 0 else 0
+
+    def _hierarchy_overlap(self, ref_hierarchy, alt_hierarchy):
+        """
+        Computes a  Jaccard similarity between nodes in two CX2Network hierarchies.
+        For each node in the alternative hierarchy, it calculates the Jaccard index with each node in
+        the reference hierarchy.
+
+        :param ref_hierarchy: The reference hierarchy to compare against.
+        :type ref_hierarchy: ndex2.cx2.CX2Network
+        :param alt_hierarchy: The alternative hierarchy being compared.
+        :type alt_hierarchy: ndex2.cx2.CX2Network
+        :return: A DataFrame of pass/fail (1/0) based on Jaccard similarity.
+        :rtype: pandas.DataFrame
+        """
+        ref_nodes = ref_hierarchy.get_nodes()
+        nodes = alt_hierarchy.get_nodes()
+
+        # Prepare a DataFrame to hold JI values
+        ji_df = pd.DataFrame(index=list(nodes.keys()), columns=list(ref_nodes.keys()), dtype=float)
+
+        for node_id, node_obj in nodes.items():
+            ont_comp_genes = set(node_obj.get('v', {}).get('CD_MemberList', '').split())
+            for ref_node_id, ref_node_obj in ref_nodes.items():
+                comp_genes = set(ref_node_obj.get('v', {}).get('CD_MemberList', '').split())
+                ji_df.at[node_id, ref_node_id] = self._calculate_jaccard(ont_comp_genes, comp_genes) \
+                    if ont_comp_genes and comp_genes else 0
+
+        return ji_df
+
+    def compute_hierarchy_robustness(self, ref_hierarchy, alt_hierarchies, ji_thre=0.4):
+        """
+        Computes a robustness score for each node in a reference hierarchy based on its structural overlap
+        across multiple alternative hierarchies. The overlap is measured using the Jaccard Index (JI),
+        and a threshold that determines if a node is considered to have sufficient overlap in a given
+        alternative hierarchy (values above the threshold are set to 1, while values below are set to 0).
+        The higher the overlap across the alternative hierarchies, the higher the robustness score.
+
+        robustness = (# hierarchies where JI > ji_thre) / (total number of alternative hierarchies)
+
+        :param ref_hierarchy: The reference hierarchy whose nodes' robustness is computed.
+        :type ref_hierarchy: ndex2.cx2.CX2Network or dict (raw CX2)
+        :param alt_hierarchies: A list of alternative hierarchies to compare against.
+        :type alt_hierarchies: list[ndex2.cx2.CX2Network or dict]
+        :param ji_thre: The Jaccard threshold used to determine overlap.
+        :type ji_thre: float
+        :return: The reference hierarchy with an added 'robustness' attribute for each node.
+        :rtype: ndex2.cx2.CX2Network
+        """
+        factory = RawCX2NetworkFactory()
+        ref_hier = ref_hierarchy if isinstance(ref_hierarchy, CX2Network) else factory.get_cx2network(ref_hierarchy)
+        alt_hiers = []
+        for hier in alt_hierarchies:
+            alt_hiers.append(hier if isinstance(hier, CX2Network) else factory.get_cx2network(hier))
+        r_hier = pd.DataFrame(index=list(ref_hier.get_nodes().keys()))
+        r_hier['robustness'] = [0] * len(r_hier)
+        for hierarchy in alt_hiers:
+            ji_df = self._hierarchy_overlap(ref_hier, hierarchy)
+            # Make a "pass/fail" matrix: 0 if JI <= threshold, 1 otherwise
+            pass_fail_df = (ji_df > ji_thre).astype(int)
+            maxs = pass_fail_df.max(axis=0)
+            r_hier.loc[pass_fail_df.columns, 'robustness'] += np.array(maxs).astype(int)
+        r_hier['robustness'] /= len(alt_hiers)
+        for node_id, robustness in r_hier['robustness'].to_dict().items():
+            ref_hier.add_node_attribute(node_id, 'robustness', robustness)
+
+        return ref_hier
+
+    def compare_hierarchies(self, hierarchy_a=None, hierarchy_b=None):
+        """
+        Compare two hierarchies in CX2 format by calculating Jaccard overlaps and
+        assigning a 'robustness' (overlap) score to each node in the first hierarchy.
+
+        :param hierarchy_a: The first (reference) hierarchy to compare.
+        :type hierarchy_a: ndex2.cx2.CX2Network
+        :param hierarchy_b: The second (alternative) hierarchy to compare against.
+        :type hierarchy_b: ndex2.cx2.CX2Network
+        :return: The first hierarchy with an added 'robustness' node attribute.
+        :rtype: ndex2.cx2.CX2Network
+        """
+        ji_df = self._hierarchy_overlap(hierarchy_a, hierarchy_b)
+        maxs = ji_df.max(axis=0)
+        node_overlap_scores = maxs.to_dict()
+
+        # Add nodes annotate nodes in hierarchy_a robustness scores
+        for node_id, data in hierarchy_a.get_nodes().items():
+            score = node_overlap_scores.get(node_id, 0)
+            hierarchy_a.add_node_attribute(node_id, 'robustness', score)
+
+        return hierarchy_a
+
+    def compare_hierarchies_from_files(self, hierarchy_a_path=None, hierarchy_b_path=None):
+        """
+        Compare two hierarchies from files then calculating overlap-based scores.
+
+        :param hierarchy_a_path: Path to the first (reference) hierarchy file.
+        :type hierarchy_a_path: str
+        :param hierarchy_b_path: Path to the second (alternative) hierarchy file.
+        :type hierarchy_b_path: str
+        :return: The first hierarchy (from hierarchy_a_path) with added robustness scores.
+        :rtype: ndex2.cx2.CX2Network
+        """
+        factory = RawCX2NetworkFactory()
+        hierarchy_a = factory.get_cx2network(hierarchy_a_path)
+        hierarchy_b = factory.get_cx2network(hierarchy_b_path)
+        return self.compare_hierarchies(hierarchy_a, hierarchy_b)

cellmaps_utils/ifimage_readme.txt

@@ -0,0 +1,31 @@
+This data set has been generated in the Emma Lundberg lab (https://ell-core.stanford.edu/)
+as part of the CM4AI Research Program (https://cm4ai.org/).
+
+This data set displays the spatial localization of proteins in the cell line MDA-MB-468.
+MDA-MB-468 cells were seeded into 96-well glass bottom plates
+and treated either with the chemotherapeutic drug Paclitaxel or with the chemotherapeutic
+drug Vorinostat (SAHA) or not treated. For drug treatment, higher cell numbers were
+seeded than for the cells that were not treated to reach a sufficient amount of
+remaining cells at the end of the experiment (treatment with Paclitaxel or Vorinostat
+disturbs cell growth). After fixation of the cells with PFA, for each protein, the
+subcellular distribution of the protein was investigated by immunofluorescence-based
+staining (ICC-IF) and confocal microscopy. Each well was stained with
+DAPI (to label nuclei, "blue" channel),
+a Calreticulin antibody (to label the endoplasmic reticulum, "yellow" channel),
+a Tubulin antibody (to label Microtubuli, "red" channel), and an antibody against a
+protein of interest (a different antibody / protein for each well, "green" channel).
+In the green channel, for each well, each one of the proteins was stained with an antibody
+from the proteinatlas.org project.
+
+The .tsv file describes each image in the data set. Each row represents one image.
+The columns describe the staining from which the image was taken:
+"Antibody ID" describes the antibody ID for the antibody applied to stain the protein
+visible in the "green" channel. The antibody ID can be looked up at proteinatlas.org
+to find out more information about the antibody.
+"ENSEMBL ID" indicates the ENSEMBL ID(s) of the gene(s) of the proteins visualized
+in the "green" channel.
+
+Treatment refers to how the cells that are depicted in the image were treated
+(with Paclitaxel, Vorinostat, or untreated)
+"Well" refers to the well coordinate on the 96-well plate
+"Region" is a unique identifier for the position in the well, where the cells were acquired.