repare 0.0.2__py3-none-any.whl → 0.1.0__py3-none-any.whl

repare/pedigree.py

@@ -4,6 +4,7 @@ from collections import defaultdict, deque
 
 import matplotlib.pyplot as plt
 import networkx as nx
+from matplotlib.colors import to_rgba
 
 
 class Pedigree:
@@ -12,12 +13,12 @@ class Pedigree:
     """
 
     def __init__(self) -> None:
-        self.num_placeholders = 0
+        self.num_placeholders: int = 0
         self.node_to_data: dict[str, dict[str, str | bool | float]] = dict()
-        self.node_to_father = defaultdict(str)
-        self.node_to_mother = defaultdict(str)
-        self.node_to_children = defaultdict(set)
-        self.node_to_siblings = defaultdict(set)
+        self.node_to_father: dict[str, str] = dict()
+        self.node_to_mother: dict[str, str] = dict()
+        self.node_to_children: dict[str, set[str]] = dict()
+        self.node_to_siblings: dict[str, set[str]] = dict()
 
     def __deepcopy__(self, memo: dict) -> "Pedigree":
         """
@@ -34,10 +35,10 @@ class Pedigree:
 
         new_pedigree.node_to_father = self.node_to_father.copy()
         new_pedigree.node_to_mother = self.node_to_mother.copy()
-        new_pedigree.node_to_children = defaultdict(set)
+        new_pedigree.node_to_children = dict()
         for k, v in self.node_to_children.items():
             new_pedigree.node_to_children[k] = v.copy()
-        new_pedigree.node_to_siblings = defaultdict(set)
+        new_pedigree.node_to_siblings = dict()
         for k, v in self.node_to_siblings.items():
             new_pedigree.node_to_siblings[k] = v.copy()
         return new_pedigree
@@ -46,23 +47,22 @@ class Pedigree:
         """
         Gets pedigree topological sort of the Pedigree. See https://doi.org/10.1089/cmb.2011.0254.
         """
-        leaf_nodes: list[str] = sorted([node for node in self.node_to_data if not self.node_to_children[node]])
+        leaf_nodes: list[str] = sorted([node for node in self.node_to_data if not self.get_children(node)])
         result: list[str] = []
 
-        # DFS
-        def visit(node: str) -> None:
+        def dfs(node: str) -> None:
             # No father == no mother
-            if not self.node_to_father[node]:
-                assert not self.node_to_mother[node]
+            if not self.get_father(node):
+                assert not self.get_mother(node)
                 result.append(node)
             else:
                 # Visit father first
-                visit(self.node_to_father[node])
-                visit(self.node_to_mother[node])
+                dfs(self.get_father(node))
+                dfs(self.get_mother(node))
                 result.append(node)
 
         for node in leaf_nodes:
-            visit(node)
+            dfs(node)
             # Break between each node's path
             result.append("")
 
@@ -72,15 +72,56 @@ class Pedigree:
             if node.isnumeric():
                 if node not in placeholder_to_idx:
                     placeholder_to_idx[node] = len(placeholder_to_idx)
-                mt_haplogroup = self.node_to_data[node]["mt_haplogroup"]
-                if self.node_to_data[node]["sex"] == "M":
-                    y_haplogroup = self.node_to_data[node]["y_haplogroup"]
+
+                node_data = self.get_data(node)
+                mt_haplogroup = node_data["mt_haplogroup"]
+                if node_data["sex"] == "M":
+                    y_haplogroup = node_data["y_haplogroup"]
                     # Unique identifier for placeholder
                     result[i] = f"M {placeholder_to_idx[node]} {mt_haplogroup} {y_haplogroup}"
                 else:
                     result[i] = f"F {placeholder_to_idx[node]} {mt_haplogroup}"
         return tuple(result)
 
+    def get_data(self, node: str) -> dict[str, str | bool | float]:
+        """
+        Returns the data for the given node.
+        """
+        assert node in self.node_to_data
+        return self.node_to_data[node]
+
+    def get_father(self, node: str) -> str:
+        """
+        Returns the father of the given node.
+        If the node has no father, returns "".
+        """
+        assert node in self.node_to_data
+        return self.node_to_father.get(node, "")
+
+    def get_mother(self, node: str) -> str:
+        """
+        Returns the mother of the given node.
+        If the node has no mother, returns "".
+        """
+        assert node in self.node_to_data
+        return self.node_to_mother.get(node, "")
+
+    def get_children(self, node: str) -> set[str]:
+        """
+        Returns the children of the given node.
+        If the node has no children, returns an empty set.
+        """
+        assert node in self.node_to_data
+        return self.node_to_children.get(node, set())
+
+    def get_siblings(self, node: str) -> set[str]:
+        """
+        Returns the siblings of the given node.
+        If the node has no siblings, returns an empty set.
+        """
+        assert node in self.node_to_data
+        return self.node_to_siblings.get(node, set())
+
     def add_node(
         self,
         node_id: str,
@@ -94,7 +135,7 @@ class Pedigree:
         """
         Add a node to the pedigree. If haplogroup is unknown, set argument to empty string ("").
         """
-        self.node_to_data[node_id]: dict[str, str | bool | float] = dict()
+        self.node_to_data[node_id] = dict()
         self.node_to_data[node_id]["sex"] = sex
         if y_haplogroup and sex == "F":
             raise ValueError("Only males can have y_haplogroup values.")
@@ -113,20 +154,33 @@ class Pedigree:
         assert node1 != node2
         assert node1 in self.node_to_data and node2 in self.node_to_data
 
-        if self.node_to_data[node1]["sex"] == "M":
+        # Remove child from original parent
+        if self.get_data(node1)["sex"] == "M":
+            if self.get_father(node2):
+                self.node_to_children[self.get_father(node2)].remove(node2)
             self.node_to_father[node2] = node1
         else:
+            if self.get_mother(node2):
+                self.node_to_children[self.get_mother(node2)].remove(node2)
             self.node_to_mother[node2] = node1
+
+        for sibling in self.get_siblings(node2):
+            self.node_to_siblings[sibling].remove(node2)
+        if node2 in self.node_to_siblings:
+            del self.node_to_siblings[node2]
+
+        if node1 not in self.node_to_children:
+            self.node_to_children[node1] = set()
         self.node_to_children[node1].add(node2)
 
         # Add any sibling relations that are created
-        node2_parents = [self.node_to_father[node2], self.node_to_mother[node2]]
+        node2_parents = [self.get_father(node2), self.get_mother(node2)]
         # Make sure Node 2 has 2 known parents
         if node2_parents[0] and node2_parents[1]:
-            for node1_child in self.node_to_children[node1]:
+            for node1_child in self.get_children(node1):
                 if (
                     node1_child != node2
-                    and [self.node_to_father[node1_child], self.node_to_mother[node1_child]] == node2_parents
+                    and [self.get_father(node1_child), self.get_mother(node1_child)] == node2_parents
                 ):
                     self.add_sibling_relation(node1_child, node2)
 
@@ -138,15 +192,19 @@ class Pedigree:
         assert node1 != node2
         assert node1 in self.node_to_data and node2 in self.node_to_data
 
+        if node1 not in self.node_to_siblings:
+            self.node_to_siblings[node1] = set()
+        if node2 not in self.node_to_siblings:
+            self.node_to_siblings[node2] = set()
         self.node_to_siblings[node1].add(node2)
         self.node_to_siblings[node2].add(node1)
 
         # Update siblings of siblings
-        for node1_sibling in self.node_to_siblings[node1]:
+        for node1_sibling in self.get_siblings(node1):
             if node1_sibling != node2:
                 self.node_to_siblings[node1_sibling].add(node2)
                 self.node_to_siblings[node2].add(node1_sibling)
-        for node2_sibling in self.node_to_siblings[node2]:
+        for node2_sibling in self.get_siblings(node2):
             if node1 != node2_sibling:
                 self.node_to_siblings[node1].add(node2_sibling)
                 self.node_to_siblings[node2_sibling].add(node1)
@@ -168,37 +226,46 @@ class Pedigree:
                 name_to_discard = node2 if name_to_keep == node1 else node1
 
                 # Update relations for relatives of the discarded node
-                name_to_discard_father = self.node_to_father[name_to_discard]
-                name_to_discard_mother = self.node_to_mother[name_to_discard]
+                name_to_discard_father = self.get_father(name_to_discard)
+                name_to_discard_mother = self.get_mother(name_to_discard)
                 if name_to_discard_father:
+                    assert self.get_children(name_to_discard_father)
                     self.node_to_children[name_to_discard_father].remove(name_to_discard)
                 if name_to_discard_mother:
+                    assert self.get_children(name_to_discard_mother)
                     self.node_to_children[name_to_discard_mother].remove(name_to_discard)
 
-                for child in self.node_to_children[name_to_discard]:
+                name_to_discard_children = set()
+                for child in self.get_children(name_to_discard):
                     # Merging a parent and child - we will see this when there is inbreeding
+                    # Note: can’t merge a parent and a child if the child has siblings,
+                    # because then the child becomes the parent of its siblings (this is
+                    # handled by check_invalid_parent_child_merge)
                     if name_to_keep == child:
-                        if self.node_to_data[name_to_keep]["sex"] == "M":
+                        if self.get_data(name_to_keep)["sex"] == "M":
                             del self.node_to_father[name_to_keep]
                         else:
                             del self.node_to_mother[name_to_keep]
                     else:
-                        # This also handles having the correct name of the merged parents from last loop iteration
-                        self.add_parent_relation(name_to_keep, child)
+                        name_to_discard_children.add(child)
+
+                for child in name_to_discard_children:
+                    # This step also handles having the correct name of the merged parents from last loop iteration
+                    self.add_parent_relation(name_to_keep, child)
 
                 # Remove all occurrences of name_to_discard in its sibling's sibling sets first
-                # so that self.add_sibling_relation() does not add it back in
-                for sibling in self.node_to_siblings[name_to_discard]:
+                # so that add_sibling_relation does not add it back in.
+                for sibling in self.get_siblings(name_to_discard):
                     self.node_to_siblings[sibling].remove(name_to_discard)
-                for sibling in self.node_to_siblings[name_to_discard]:
+                for sibling in self.get_siblings(name_to_discard):
                     if sibling != name_to_keep:
                         self.add_sibling_relation(sibling, name_to_keep)
 
                 # Recursively merge parent relations of Node 1 and Node 2
-                father1 = self.node_to_father[name_to_keep]
-                father2 = self.node_to_father[name_to_discard]
-                mother1 = self.node_to_mother[name_to_keep]
-                mother2 = self.node_to_mother[name_to_discard]
+                father1 = self.get_father(name_to_keep)
+                father2 = self.get_father(name_to_discard)
+                mother1 = self.get_mother(name_to_keep)
+                mother2 = self.get_mother(name_to_discard)
                 if father1 and father2:
                     pair_queue.append((father1, father2))
                 elif father2:
@@ -225,69 +292,163 @@ class Pedigree:
                     elif node2 == name_to_discard:
                         pair_queue[idx] = (node1, name_to_keep)
 
-                del self.node_to_data[name_to_discard]
-                del self.node_to_father[name_to_discard]
-                del self.node_to_mother[name_to_discard]
-                del self.node_to_children[name_to_discard]
-                del self.node_to_siblings[name_to_discard]
+                for data_dict in [
+                    self.node_to_data,
+                    self.node_to_father,
+                    self.node_to_mother,
+                    self.node_to_children,
+                    self.node_to_siblings,
+                ]:
+                    if name_to_discard in data_dict:
+                        del data_dict[name_to_discard]
 
-    def check_cycles_if_merged(self, node1: str, node2: str) -> bool:
+    def check_valid_merge(self, node1: str, node2: str) -> bool:
         """
-        Returns True if merging Node 1 and Node 2 (and their ancestors) would result in a cycle.
+        Returns True if merging Node 1 and Node 2 (and their ancestors) is a valid operation.
         """
+        assert node1 in self.node_to_data and node2 in self.node_to_data
         # Get sets of nodes that would be merged if Node 1 and Node 2 were merged (i.e. ancestors of Node 1 and Node 2)
         # Note that we get sets and not just pairs because of potential inbreeding,
         # for example if one node is both a parent and grandparent of another node
         merge_sets: list[set[str]] = []
-        merge_queue = deque([(node1, node2)])
+        merge_queue: deque[set[str]] = deque([set([node1, node2])])
+        included_nodes: set[str] = set()
+
         while merge_queue:
-            curr_node1, curr_node2 = merge_queue.popleft()
+            curr_nodes = merge_queue.popleft()
+            # If all nodes are the same, skip
+            if len(set(curr_nodes)) == 1:
+                continue
+
             # Update merge sets
-            if curr_node1 != curr_node2:
-                updated = False
-                for merge_set in merge_sets:
-                    if curr_node1 in merge_set or curr_node2 in merge_set:
-                        merge_set.update([curr_node1, curr_node2])
-                        updated = True
-                        break
-                if not updated:
-                    merge_sets.append({curr_node1, curr_node2})
-                # Add parents to the queue
-                curr_father1 = self.node_to_father[curr_node1]
-                curr_father2 = self.node_to_father[curr_node2]
-                curr_mother1 = self.node_to_mother[curr_node1]
-                curr_mother2 = self.node_to_mother[curr_node2]
-                if curr_father1 and curr_father2:
-                    merge_queue.append((curr_father1, curr_father2))
-                if curr_mother1 and curr_mother2:
-                    merge_queue.append((curr_mother1, curr_mother2))
+            updated = False
+            for merge_set in merge_sets:
+                if merge_set == curr_nodes:
+                    updated = True
+                    break
+
+                if any(node in merge_set for node in curr_nodes):
+                    merge_set.update(curr_nodes)
+                    # Include all merged nodes in the current set of nodes
+                    curr_nodes = merge_set
+                    updated = True
+                    break
+            if not updated:
+                merge_sets.append(set(curr_nodes))
+            included_nodes.update(curr_nodes)
+
+            # Add parents to the queue
+            curr_fathers = set([self.get_father(node) for node in curr_nodes if self.get_father(node)])
+            curr_mothers = set([self.get_mother(node) for node in curr_nodes if self.get_mother(node)])
+            if len(curr_fathers) > 1 and not curr_fathers.issubset(included_nodes):
+                merge_queue.append(curr_fathers)
+            if len(curr_mothers) > 1 and not curr_mothers.issubset(included_nodes):
+                merge_queue.append(curr_mothers)
+
+        if self.check_named_node_merge(merge_sets):
+            return False
+
+        if self.check_invalid_parent_child_merge(merge_sets):
+            return False
+
+        if self.check_invalid_sibling_child_merge(merge_sets):
+            return False
+
+        if self.check_cycle_merge(merge_sets):
+            return False
+        return True
+
+    def check_named_node_merge(self, merge_sets: list[set[str]]) -> bool:
+        """
+        Returns True if merging Node 1 and Node 2 (and their ancestors) would result in
+        at least one named node being lost.
+        """
+        for nodes_to_merge in merge_sets:
+            named_nodes = [node for node in nodes_to_merge if not node.isnumeric()]
+            if len(named_nodes) > 1:
+                return True
+        return False
+
+    def check_invalid_parent_child_merge(self, merge_sets: list[set[str]]) -> bool:
+        """
+        Returns True if merging Node 1 and Node 2 (and their ancestors) would result in an invalid parent-child merge.
+        We can't merge a parent and a child where the child has siblings, because then the child becomes the parent
+        of its siblings which makes the pedigree internally inconsistent. merge_sets is a list of node sets that would
+        be merged if Node 1 and Node 2 were merged.
+        """
+        for nodes_to_merge in merge_sets:
+            for curr_node1 in nodes_to_merge:
+                for curr_node2 in nodes_to_merge:
+                    if curr_node1 == curr_node2:
+                        continue
+
+                    # If Node 1 is a parent of Node 2, and Node 2 has siblings, don't merge
+                    if self.get_father(curr_node2) == curr_node1 or self.get_mother(curr_node2) == curr_node1:
+                        if self.get_siblings(curr_node2):
+                            return True
+                    # If Node 2 is a parent of Node 1, and Node 1 has siblings, don't merge
+                    if self.get_father(curr_node1) == curr_node2 or self.get_mother(curr_node1) == curr_node2:
+                        if self.get_siblings(curr_node1):
+                            return True
+        return False
+
+    def check_invalid_sibling_child_merge(self, merge_sets: list[set[str]]) -> bool:
+        """
+        Returns True if merging Node 1 and Node 2 (and their ancestors) would result in an invalid sibling-child merge.
+        We can't merge a sibling and a child of a common node, because then the common node becomes parent and sibling
+        of the merged node which makes the pedigree internally inconsistent. merge_sets is a list of node sets that
+        would be merged if Node 1 and Node 2 were merged.
+        """
+        for nodes_to_merge in merge_sets:
+            for curr_node1 in nodes_to_merge:
+                for curr_node2 in nodes_to_merge:
+                    if curr_node1 == curr_node2:
+                        continue
+
+                    # A third node is both a parent of Node 1 and a sibling of Node 2
+                    if self.get_father(curr_node1) in self.get_siblings(curr_node2) or self.get_mother(
+                        curr_node1
+                    ) in self.get_siblings(curr_node2):
+                        return True
+                    # A third node is both a parent of Node 2 and a sibling of Node 1
+                    if self.get_father(curr_node2) in self.get_siblings(curr_node1) or self.get_mother(
+                        curr_node2
+                    ) in self.get_siblings(curr_node1):
+                        return True
+        return False
+
+    def check_cycle_merge(self, merge_sets: list[set[str]]) -> bool:
+        """
+        Returns True if merging Node 1 and Node 2 (and their ancestors) would result in a cycle.
+        merge_sets is a list of node sets that would be merged if Node 1 and Node 2 were merged.
+        """
 
         # DFS cycle detection
-        def dfs(node):
-            merged_nodes: set[str] | None = None
+        def dfs(node) -> bool:
+            nodes_to_merge: set[str] | None = None
             for merge_set in merge_sets:
                 if node in merge_set:
-                    merged_nodes = merge_set
+                    nodes_to_merge = merge_set
                     break
 
-            if merged_nodes:
+            if nodes_to_merge:
                 if node in in_progress:
                     return True
                 if node in explored:
                     return False
-                in_progress.update(merged_nodes)
-                for child in [child for node in merged_nodes for child in self.node_to_children[node]]:
+                in_progress.update(nodes_to_merge)
+                for child in [child for node in nodes_to_merge for child in self.get_children(node)]:
                     if dfs(child):
                         return True
-                in_progress.difference_update(merged_nodes)
-                explored.update(merged_nodes)
+                in_progress.difference_update(nodes_to_merge)
+                explored.update(nodes_to_merge)
             else:
                 if node in in_progress:
                     return True
                 if node in explored:
                     return False
                 in_progress.add(node)
-                for child in self.node_to_children[node]:
+                for child in self.get_children(node):
                     if dfs(child):
                         return True
                 in_progress.remove(node)
@@ -310,8 +471,8 @@ class Pedigree:
         """
         assert node in self.node_to_data
 
-        father = self.node_to_father[node]
-        mother = self.node_to_mother[node]
+        father = self.get_father(node)
+        mother = self.get_mother(node)
 
         if not father:
             father_id = str(self.num_placeholders)
@@ -326,7 +487,7 @@ class Pedigree:
             )
 
             self.add_parent_relation(father_id, node)
-            for sibling in self.node_to_siblings[node]:
+            for sibling in self.get_siblings(node):
                 self.add_parent_relation(father_id, sibling)
             self.num_placeholders += 1
 
@@ -343,7 +504,7 @@ class Pedigree:
             )
 
             self.add_parent_relation(mother_id, node)
-            for sibling in self.node_to_siblings[node]:
+            for sibling in self.get_siblings(node):
                 self.add_parent_relation(mother_id, sibling)
             self.num_placeholders += 1
 
@@ -352,56 +513,96 @@ class Pedigree:
         Update haplogroups of placeholder nodes.
         """
         for node in self.node_to_data:
-            y_haplogroup: str = self.node_to_data[node]["y_haplogroup"]
+            y_haplogroup: str = self.get_data(node)["y_haplogroup"]
             y_lineage: deque[str] = deque(
-                [self.node_to_father[node]]
-                + [child for child in self.node_to_children[node] if self.node_to_data[child]["sex"] == "M"]
+                [self.get_father(node)]
+                + [child for child in self.get_children(node) if self.get_data(child)["sex"] == "M"]
             )
 
             while y_lineage:
                 curr_node = y_lineage.popleft()
                 if (
                     not curr_node
-                    or "*" not in self.node_to_data[curr_node]["y_haplogroup"]
-                    or self.node_to_data[curr_node]["y_haplogroup"].rstrip("*") == y_haplogroup.rstrip("*")
+                    or "*" not in self.get_data(curr_node)["y_haplogroup"]
+                    or self.get_data(curr_node)["y_haplogroup"].rstrip("*") == y_haplogroup.rstrip("*")
                 ):
                     continue
                 # Overwrite/extend Y haplogroup if it contains a "*" and is a strict subset of the "leaf" haplogroup
-                if y_haplogroup.startswith(self.node_to_data[curr_node]["y_haplogroup"].rstrip("*")):
+                if y_haplogroup.startswith(self.get_data(curr_node)["y_haplogroup"].rstrip("*")):
                     self.node_to_data[curr_node]["y_haplogroup"] = (
                         y_haplogroup if y_haplogroup[-1] == "*" else y_haplogroup + "*"
                     )
-                    y_lineage.append(self.node_to_father[curr_node])
-                    for curr_node_child in self.node_to_children[curr_node]:
+                    y_lineage.append(self.get_father(curr_node))
+                    for curr_node_child in self.get_children(curr_node):
                         # Only males have Y chromosome
-                        if self.node_to_data[curr_node_child]["sex"] == "M":
+                        if self.get_data(curr_node_child)["sex"] == "M":
                             y_lineage.append(curr_node_child)
 
-            mt_haplogroup: str = self.node_to_data[node]["mt_haplogroup"]
-            mt_lineage: deque[str] = deque([self.node_to_mother[node]])
+            mt_haplogroup: str = self.get_data(node)["mt_haplogroup"]
+            mt_lineage: deque[str] = deque([self.get_mother(node)])
             # Only females pass on mitochondrial DNA to children
-            if self.node_to_data[node]["sex"] == "F":
-                mt_lineage.extend(self.node_to_children[node])
+            if self.get_data(node)["sex"] == "F":
+                mt_lineage.extend(self.get_children(node))
 
             while mt_lineage:
                 curr_node = mt_lineage.popleft()
                 if (
                     not curr_node
-                    or "*" not in self.node_to_data[curr_node]["mt_haplogroup"]
-                    or self.node_to_data[curr_node]["mt_haplogroup"].rstrip("*") == mt_haplogroup.rstrip("*")
+                    or "*" not in self.get_data(curr_node)["mt_haplogroup"]
+                    or self.get_data(curr_node)["mt_haplogroup"].rstrip("*") == mt_haplogroup.rstrip("*")
                 ):
                     continue
                 # Overwrite/extend mitochondrial haplogroup if it contains a "*"
                 # and is a strict subset of the "leaf" haplogroup
-                if mt_haplogroup.startswith(self.node_to_data[curr_node]["mt_haplogroup"].rstrip("*")):
+                if mt_haplogroup.startswith(self.get_data(curr_node)["mt_haplogroup"].rstrip("*")):
                     self.node_to_data[curr_node]["mt_haplogroup"] = (
                         mt_haplogroup if mt_haplogroup[-1] == "*" else mt_haplogroup + "*"
                     )
-                    mt_lineage.append(self.node_to_mother[curr_node])
-                    if self.node_to_data[curr_node]["sex"] == "F":
-                        mt_lineage.extend(self.node_to_children[curr_node])
+                    mt_lineage.append(self.get_mother(curr_node))
+                    if self.get_data(curr_node)["sex"] == "F":
+                        mt_lineage.extend(self.get_children(curr_node))
 
-    def validate_members(self, members: set) -> bool:
+    def validate_structure(self) -> bool:
+        """
+        Validates pedigree structure and consistency of internal data.
+        """
+        for child, father in self.node_to_father.items():
+            if child not in self.node_to_children[father]:
+                return False
+            if child == father:
+                return False
+
+        for child, mother in self.node_to_mother.items():
+            if child not in self.node_to_children[mother]:
+                return False
+            if child == mother:
+                return False
+
+        for parent, children in self.node_to_children.items():
+            for child in children:
+                if self.get_data(parent)["sex"] == "M":
+                    if parent != self.node_to_father[child]:
+                        return False
+                else:
+                    if parent != self.node_to_mother[child]:
+                        return False
+                if parent == child:
+                    return False
+
+        for node, siblings in self.node_to_siblings.items():
+            for sibling in siblings:
+                if node not in self.node_to_siblings[sibling]:
+                    return False
+                if (
+                    self.node_to_father[node] != self.node_to_father[sibling]
+                    or self.node_to_mother[node] != self.node_to_mother[sibling]
+                ):
+                    return False
+                if node == sibling:
+                    return False
+        return True
+
+    def validate_members(self, members: set[str]) -> bool:
         """
         Validates this tree based on the member nodes it should contain.
         """
@@ -427,15 +628,11 @@ class Pedigree:
                 return haplogroup1.startswith(haplogroup2.rstrip("*"))
 
         for parent, child in self.get_parent_child_pairs():
-            if self.node_to_data[parent]["sex"] == "F":
-                if not haplogroups_agree(
-                    self.node_to_data[parent]["mt_haplogroup"], self.node_to_data[child]["mt_haplogroup"]
-                ):
+            if self.get_data(parent)["sex"] == "F":
+                if not haplogroups_agree(self.get_data(parent)["mt_haplogroup"], self.get_data(child)["mt_haplogroup"]):
                     return False
-            elif self.node_to_data[parent]["sex"] == "M" and self.node_to_data[child]["sex"] == "M":
-                if not haplogroups_agree(
-                    self.node_to_data[parent]["y_haplogroup"], self.node_to_data[child]["y_haplogroup"]
-                ):
+            elif self.get_data(parent)["sex"] == "M" and self.get_data(child)["sex"] == "M":
+                if not haplogroups_agree(self.get_data(parent)["y_haplogroup"], self.get_data(child)["y_haplogroup"]):
                     return False
         return True
 
@@ -444,7 +641,7 @@ class Pedigree:
         Validates that nodes that cannot have children do not have children.
         """
         for node in self.get_non_placeholder_nodes():
-            if len(self.node_to_children[node]) > 0 and not self.node_to_data[node]["can_have_children"]:
+            if len(self.get_children(node)) > 0 and not self.get_data(node)["can_have_children"]:
                 return False
         return True
 
@@ -454,9 +651,9 @@ class Pedigree:
         """
         related_pairs = self.get_related_pairs()
         for node in self.get_non_placeholder_nodes():
-            if not self.node_to_data[node]["can_be_inbred"]:
-                father = self.node_to_father[node]
-                mother = self.node_to_mother[node]
+            if not self.get_data(node)["can_be_inbred"]:
+                father = self.get_father(node)
+                mother = self.get_mother(node)
                 if (father, mother) in related_pairs or (mother, father) in related_pairs:
                     return False
         return True
@@ -465,11 +662,10 @@ class Pedigree:
         """
         Validates that nodes do not postdate their descendants.
         """
-        leaf_nodes: list[str] = [node for node in self.node_to_data if not self.node_to_children[node]]
+        leaf_nodes: list[str] = [node for node in self.node_to_data if not self.get_children(node)]
 
-        # DFS
-        def visit(node: str, curr_years_before_present: float) -> None:
-            years_before_present = self.node_to_data[node]["years_before_present"]
+        def dfs(node: str, curr_years_before_present: float) -> bool:
+            years_before_present = self.get_data(node)["years_before_present"]
             if not math.isnan(years_before_present):
                 # Node postdates its descendants
                 if years_before_present < curr_years_before_present:
@@ -477,16 +673,16 @@ class Pedigree:
                 else:
                     curr_years_before_present = years_before_present
 
-            if self.node_to_father[node]:
-                assert self.node_to_mother[node]
-                if not visit(self.node_to_father[node], curr_years_before_present):
+            if self.get_father(node):
+                assert self.get_mother(node)
+                if not dfs(self.get_father(node), curr_years_before_present):
                     return False
-                if not visit(self.node_to_mother[node], curr_years_before_present):
+                if not dfs(self.get_mother(node), curr_years_before_present):
                     return False
             return True
 
         for node in leaf_nodes:
-            if not visit(node, float("-inf")):
+            if not dfs(node, float("-inf")):
                 return False
         return True
 
@@ -508,7 +704,7 @@ class Pedigree:
         pair_to_constraints: defaultdict[tuple[str, str], list[tuple[str, ...]]],
         pair_to_relations_so_far: defaultdict[tuple[str, str], list[tuple[str, str, bool]]],
         check_half_siblings: bool,
-    ) -> tuple[int, list[tuple[str, str, str]]]:
+    ) -> tuple[int, list[tuple[str, str, str, str]]]:
         """
         Validates this tree based on the input relation data.
         If check_half_siblings is False, don't check for extraneous half-sibling relations
@@ -537,7 +733,9 @@ class Pedigree:
                         pair_to_constraints_seen_entries[(node1, node2)].add(idx)
                         break
 
-        def validate_relation(node1: str, node2: str, relation: str, strike_log: list[str, str, str, str]) -> None:
+        def validate_relation(
+            node1: str, node2: str, relation: str, strike_log: list[tuple[str, str, str, str]]
+        ) -> None:
             relation_to_degree = {
                 "parent-child": "1",
                 "child-parent": "1",
@@ -575,7 +773,7 @@ class Pedigree:
             remove_relation_from_input_data(node1, node2, relation)
             remove_relation_from_input_data(node2, node1, flipped_relations[relation])
 
-        strike_log: list[str, str, str, str] = []  # (node1, node2, +/- relation degree, constraints)
+        strike_log: list[tuple[str, str, str, str]] = []  # (node1, node2, +/- relation degree, constraints)
         # Check that relations in the pedigree are present in the input data
         for parent, child in self.get_parent_child_pairs(include_placeholders=False):
             validate_relation(parent, child, "parent-child", strike_log)
@@ -622,7 +820,7 @@ class Pedigree:
                 if not self.is_relation_in_pedigree(node1, node2, constraints.split(";")):
                     strike_log.append((node1, node2, f"-{degree}", constraints))
             else:
-                pedigree_shared_relations: defaultdict(int) = self.get_relations_between_nodes(
+                pedigree_shared_relations: defaultdict[str, int] = self.get_relations_between_nodes(
                     node1, node2, include_maternal_paternal=True
                 )
                 for degree, constraints, _ in degrees_constraints:
@@ -654,7 +852,7 @@ class Pedigree:
                 node_pair_strike_balances[(node2, node1)] -= 1
         return strike_count, strike_log
 
-    def count_third_degree_inconcistencies(
+    def count_third_degree_inconsistencies(
         self, pair_to_constraints: defaultdict[tuple[str, str], list[tuple[str, ...]]]
     ) -> int:
         """
@@ -727,92 +925,88 @@ class Pedigree:
 
         for relation in relations_list:
             if relation == "parent-child":
-                if node2 in self.node_to_children[node1]:
+                if node2 in self.get_children(node1):
                     return True
             if relation == "child-parent":
-                if node1 in self.node_to_children[node2]:
+                if node1 in self.get_children(node2):
                     return True
             if relation == "siblings":
-                if node2 in self.node_to_siblings[node1]:
-                    assert node1 in self.node_to_siblings[node2]
+                if node2 in self.get_siblings(node1):
+                    assert node1 in self.get_siblings(node2)
                     return True
 
             if relation == "aunt/uncle-nephew/niece":
-                for sibling in self.node_to_siblings[node1]:
-                    if node2 in self.node_to_children[sibling]:
+                for sibling in self.get_siblings(node1):
+                    if node2 in self.get_children(sibling):
                         return True
             if relation == "nephew/niece-aunt/uncle":
-                for sibling in self.node_to_siblings[node2]:
-                    if node1 in self.node_to_children[sibling]:
+                for sibling in self.get_siblings(node2):
+                    if node1 in self.get_children(sibling):
                         return True
             if relation == "grandparent-grandchild":
-                for child in self.node_to_children[node1]:
-                    if node2 in self.node_to_children[child]:
+                for child in self.get_children(node1):
+                    if node2 in self.get_children(child):
                         return True
             if relation == "grandchild-grandparent":
-                for child in self.node_to_children[node2]:
-                    if node1 in self.node_to_children[child]:
+                for child in self.get_children(node2):
+                    if node1 in self.get_children(child):
                         return True
             if relation == "half-siblings":
-                if self.node_to_father[node2]:
-                    if (
-                        node1 in self.node_to_children[self.node_to_father[node2]]
-                        and self.node_to_mother[node1] != self.node_to_mother[node2]
+                if self.get_father(node2):
+                    if node1 in self.get_children(self.get_father(node2)) and self.get_mother(node1) != self.get_mother(
+                        node2
                     ):
                         return True
-                if self.node_to_mother[node2]:
-                    if (
-                        node1 in self.node_to_children[self.node_to_mother[node2]]
-                        and self.node_to_father[node1] != self.node_to_father[node2]
+                if self.get_mother(node2):
+                    if node1 in self.get_children(self.get_mother(node2)) and self.get_father(node1) != self.get_father(
+                        node2
                     ):
                         return True
 
             if relation == "maternal aunt/uncle-nephew/niece":
-                for sibling in self.node_to_siblings[node1]:
-                    if self.node_to_data[sibling]["sex"] == "F" and node2 in self.node_to_children[sibling]:
+                for sibling in self.get_siblings(node1):
+                    if self.get_data(sibling)["sex"] == "F" and node2 in self.get_children(sibling):
                         return True
             if relation == "paternal aunt/uncle-nephew/niece":
-                for sibling in self.node_to_siblings[node1]:
-                    if self.node_to_data[sibling]["sex"] == "M" and node2 in self.node_to_children[sibling]:
+                for sibling in self.get_siblings(node1):
+                    if self.get_data(sibling)["sex"] == "M" and node2 in self.get_children(sibling):
                         return True
             if relation == "maternal nephew/niece-aunt/uncle":
-                for sibling in self.node_to_siblings[node2]:
-                    if self.node_to_data[sibling]["sex"] == "F" and node1 in self.node_to_children[sibling]:
+                for sibling in self.get_siblings(node2):
+                    if self.get_data(sibling)["sex"] == "F" and node1 in self.get_children(sibling):
                         return True
             if relation == "paternal nephew/niece-aunt/uncle":
-                for sibling in self.node_to_siblings[node2]:
-                    if self.node_to_data[sibling]["sex"] == "M" and node1 in self.node_to_children[sibling]:
+                for sibling in self.get_siblings(node2):
+                    if self.get_data(sibling)["sex"] == "M" and node1 in self.get_children(sibling):
                         return True
 
             if relation == "maternal grandparent-grandchild":
-                for child in self.node_to_children[node1]:
-                    if self.node_to_data[child]["sex"] == "F" and node2 in self.node_to_children[child]:
+                for child in self.get_children(node1):
+                    if self.get_data(child)["sex"] == "F" and node2 in self.get_children(child):
                         return True
             if relation == "paternal grandparent-grandchild":
-                for child in self.node_to_children[node1]:
-                    if self.node_to_data[child]["sex"] == "M" and node2 in self.node_to_children[child]:
+                for child in self.get_children(node1):
+                    if self.get_data(child)["sex"] == "M" and node2 in self.get_children(child):
                         return True
             if relation == "maternal grandchild-grandparent":
-                for child in self.node_to_children[node2]:
-                    if self.node_to_data[child]["sex"] == "F" and node1 in self.node_to_children[child]:
+                for child in self.get_children(node2):
+                    if self.get_data(child)["sex"] == "F" and node1 in self.get_children(child):
                         return True
             if relation == "paternal grandchild-grandparent":
-                for child in self.node_to_children[node2]:
-                    if self.node_to_data[child]["sex"] == "M" and node1 in self.node_to_children[child]:
+                for child in self.get_children(node2):
+                    if self.get_data(child)["sex"] == "M" and node1 in self.get_children(child):
                         return True
 
             if relation == "paternal half-siblings":
-                if self.node_to_father[node2]:
-                    if (
-                        node1 in self.node_to_children[self.node_to_father[node2]]
-                        and self.node_to_mother[node1] != self.node_to_mother[node2]
+                if self.get_father(node2):
+                    if node1 in self.get_children(self.get_father(node2)) and self.get_mother(node1) != self.get_mother(
+                        node2
                     ):
                         return True
             if relation == "maternal half-siblings":
-                if self.node_to_mother[node2]:
-                    if (
-                        node1 in self.node_to_children[self.node_to_mother[node2]]
-                        and self.node_to_father[node1] != self.node_to_father[node2]
+                if self.get_mother(node2):
+                    if node1 in self.get_children(self.get_mother(node2)) and self.get_father(node1) != self.get_father(
+                        node2
                     ):
                         return True
         return False
@@ -823,7 +1017,7 @@ class Pedigree:
         """
         Returns a dictionary of the *1st- and 2nd-degree* relations between node1 and node2.
         """
-        relations = defaultdict(int)
+        relations: defaultdict[str, int] = defaultdict(int)
         if self.is_relation_in_pedigree(node1, node2, ["parent-child"]):
             relations["parent-child"] += 1
         if self.is_relation_in_pedigree(node1, node2, ["child-parent"]):
@@ -896,7 +1090,7 @@ class Pedigree:
         """
         parent_child_pairs: list[tuple[str, str]] = []
         for parent in self.node_to_children:
-            for child in self.node_to_children[parent]:
+            for child in self.get_children(parent):
                 if include_placeholders or (not parent.isnumeric() and not child.isnumeric()):
                     parent_child_pairs.append((parent, child))
         return parent_child_pairs
@@ -908,7 +1102,7 @@ class Pedigree:
         """
         sibling_pairs: list[tuple[str, str]] = []
         for sibling1 in self.node_to_siblings:
-            for sibling2 in self.node_to_siblings[sibling1]:
+            for sibling2 in self.get_siblings(sibling1):
                 if include_placeholders or (not sibling1.isnumeric() and not sibling2.isnumeric()):
                     # Don't add symmetric duplicates
                     if (sibling2, sibling1) not in sibling_pairs:
@@ -925,8 +1119,8 @@ class Pedigree:
         """
         aunt_uncle_nephew_niece_pairs: list[tuple[str, str]] = []
         for parent, child in self.get_parent_child_pairs():
-            for parent_sibling in self.node_to_siblings[parent]:
-                if not shared_relative_sex or self.node_to_data[parent]["sex"] == shared_relative_sex:
+            for parent_sibling in self.get_siblings(parent):
+                if not shared_relative_sex or self.get_data(parent)["sex"] == shared_relative_sex:
                     if include_placeholders or (not parent_sibling.isnumeric() and not child.isnumeric()):
                         aunt_uncle_nephew_niece_pairs.append((parent_sibling, child))
         return aunt_uncle_nephew_niece_pairs
@@ -940,8 +1134,8 @@ class Pedigree:
         """
         grandparent_grandchild_pairs: list[tuple[str, str]] = []
         for parent, child in self.get_parent_child_pairs():
-            for child_child in self.node_to_children[child]:
-                if not shared_relative_sex or self.node_to_data[child]["sex"] == shared_relative_sex:
+            for child_child in self.get_children(child):
+                if not shared_relative_sex or self.get_data(child)["sex"] == shared_relative_sex:
                     if include_placeholders or (not parent.isnumeric() and not child_child.isnumeric()):
                         grandparent_grandchild_pairs.append((parent, child_child))
         return grandparent_grandchild_pairs
@@ -954,9 +1148,9 @@ class Pedigree:
         """
         half_sibling_pairs: list[tuple[str, str]] = []
         for parent, child in self.get_parent_child_pairs():
-            for other_child in self.node_to_children[parent]:
-                if child != other_child and other_child not in self.node_to_siblings[child]:
-                    if not shared_relative_sex or self.node_to_data[parent]["sex"] == shared_relative_sex:
+            for other_child in self.get_children(parent):
+                if child != other_child and other_child not in self.get_siblings(child):
+                    if not shared_relative_sex or self.get_data(parent)["sex"] == shared_relative_sex:
                         if include_placeholders or (not child.isnumeric() and not other_child.isnumeric()):
                             # Don't add symmetric duplicates
                             if (other_child, child) not in half_sibling_pairs:
@@ -969,12 +1163,12 @@ class Pedigree:
         """
         half_aunt_uncle_nephew_niece_pairs: list[tuple[str, str]] = []
         for half_sibling1, half_sibling2 in self.get_half_sibling_pairs():
-            for half_sibling1_child in self.node_to_children[half_sibling1]:
+            for half_sibling1_child in self.get_children(half_sibling1):
                 if half_sibling1_child != half_sibling2:
                     if include_placeholders or (not half_sibling2.isnumeric() and not half_sibling1_child.isnumeric()):
                         half_aunt_uncle_nephew_niece_pairs.append((half_sibling2, half_sibling1_child))
 
-            for half_sibling2_child in self.node_to_children[half_sibling2]:
+            for half_sibling2_child in self.get_children(half_sibling2):
                 if half_sibling2_child != half_sibling1:
                     if include_placeholders or (not half_sibling1.isnumeric() and not half_sibling2_child.isnumeric()):
                         half_aunt_uncle_nephew_niece_pairs.append((half_sibling1, half_sibling2_child))
@@ -986,7 +1180,7 @@ class Pedigree:
         """
         greatgrandparent_greatgrandchild_pairs: list[tuple[str, str]] = []
         for grandparent, grandchild in self.get_grandparent_grandchild_pairs():
-            for grandchild_child in self.node_to_children[grandchild]:
+            for grandchild_child in self.get_children(grandchild):
                 if include_placeholders or (not grandparent.isnumeric() and not grandchild_child.isnumeric()):
                     greatgrandparent_greatgrandchild_pairs.append((grandparent, grandchild_child))
         return greatgrandparent_greatgrandchild_pairs
@@ -999,7 +1193,7 @@ class Pedigree:
         """
         grandaunt_granduncle_grandnephew_grandniece_pairs: list[tuple[str, str]] = []
         for aunt_uncle, nephew_niece in self.get_aunt_uncle_nephew_niece_pairs():
-            for nephew_niece_child in self.node_to_children[nephew_niece]:
+            for nephew_niece_child in self.get_children(nephew_niece):
                 if include_placeholders or (not aunt_uncle.isnumeric() and not nephew_niece_child.isnumeric()):
                     grandaunt_granduncle_grandnephew_grandniece_pairs.append((aunt_uncle, nephew_niece_child))
         return grandaunt_granduncle_grandnephew_grandniece_pairs
@@ -1010,7 +1204,7 @@ class Pedigree:
         """
         cousin_pairs: list[tuple[str, str]] = []
         for aunt_uncle, child in self.get_aunt_uncle_nephew_niece_pairs():
-            for aunt_uncle_child in self.node_to_children[aunt_uncle]:
+            for aunt_uncle_child in self.get_children(aunt_uncle):
                 if include_placeholders or (not child.isnumeric() and not aunt_uncle_child.isnumeric()):
                     # Don't add symmetric duplicates
                     if aunt_uncle_child != child and (aunt_uncle_child, child) not in cousin_pairs:
@@ -1041,30 +1235,22 @@ class Pedigree:
         """
         return set([node for node in self.node_to_data if not node.isnumeric()])
 
-    def clean_up_relations(self) -> None:
+    def clean_data(self) -> None:
         """
         Remove any empty entries in the relation dictionaries.
         Also remove unnecessary placeholder nodes to standardize topological sort output.
         """
-        for relation_dict in [self.node_to_father, self.node_to_mother, self.node_to_children, self.node_to_siblings]:
-            keys_to_remove = set()
-            for k, v in relation_dict.items():
-                if not v:
-                    keys_to_remove.add(k)
-            for key_to_remove in keys_to_remove:
-                del relation_dict[key_to_remove]
-
         placeholder_nodes_to_remove: set[str] = set()
         for node in self.node_to_data:
-            mother = self.node_to_mother[node]
-            father = self.node_to_father[node]
+            mother = self.get_mother(node)
+            father = self.get_father(node)
             if mother.isnumeric() and father.isnumeric():
-                if len(self.node_to_children[mother]) == 1 and len(self.node_to_children[father]) == 1:
+                if len(self.get_children(mother)) == 1 and len(self.get_children(father)) == 1:
                     if (
-                        not self.node_to_mother[mother]
-                        and not self.node_to_father[mother]
-                        and not self.node_to_mother[father]
-                        and not self.node_to_father[father]
+                        not self.get_mother(mother)
+                        and not self.get_father(mother)
+                        and not self.get_mother(father)
+                        and not self.get_father(father)
                     ):
                         placeholder_nodes_to_remove.add(mother)
                         placeholder_nodes_to_remove.add(father)
@@ -1080,16 +1266,36 @@ class Pedigree:
                 if node in data_dict:
                     del data_dict[node]
 
-            for node in self.node_to_data:
-                assert node not in self.node_to_siblings[node] and node not in self.node_to_children[node]
-                if self.node_to_father[node] in placeholder_nodes_to_remove:
-                    del self.node_to_father[node]
-                if self.node_to_mother[node] in placeholder_nodes_to_remove:
-                    del self.node_to_mother[node]
+        for node in self.node_to_data:
+            assert node not in self.get_siblings(node) and node not in self.get_children(node)
+            if self.get_father(node) in placeholder_nodes_to_remove:
+                del self.node_to_father[node]
+            if self.get_mother(node) in placeholder_nodes_to_remove:
+                del self.node_to_mother[node]
 
-    def plot(self, path: str) -> None:
+        for relation_dict in [self.node_to_father, self.node_to_mother, self.node_to_children, self.node_to_siblings]:
+            keys_to_remove = set()
+            for k, v in relation_dict.items():
+                if not v:
+                    keys_to_remove.add(k)
+            for key_to_remove in keys_to_remove:
+                del relation_dict[key_to_remove]
+
+    def plot(
+        self,
+        path: str,
+        mt_haplogroup_to_color: dict[str, str] | dict[str, tuple[float, float, float, float]] | None = None,
+        nodes_to_remove: list[str] | None = None,
+        edges_to_remove: list[tuple[str, str]] | None = None,
+        dotted_edges_to_add: list[tuple[str, str]] | None = None,
+    ) -> None:
         """
-        Plot the pedigree to the given path.
+        Plot the pedigree to the given path. Optionally takes a custom mapping of mt_haplogroups to colors.
+        Also optionally takes arguments to plot uncertain relations.
+        nodes_to_remove is a list of nodes to remove from the plot.
+        edges_to_remove is a list of parent-child edges to remove from the plot.
+        dotted_edges_to_add is a list of node pairs to plot as dotted lines.
+        These arguments can be used in conjunction to replace uncertain relations with dotted lines.
         """
         if not importlib.util.find_spec("pygraphviz"):
             raise ImportError("Plotting pedigree requires PyGraphviz (https://pygraphviz.github.io/).")
@@ -1099,54 +1305,76 @@ class Pedigree:
         for node in self.node_to_data:
             if node not in tree.nodes:
                 tree.add_node(node)
-        male_named_nodes = [
-            node for node in self.node_to_data if self.node_to_data[node]["sex"] == "M" and not node.isnumeric()
-        ]
-        male_placeholder_nodes = [
-            node for node in self.node_to_data if self.node_to_data[node]["sex"] == "M" and node.isnumeric()
-        ]
-        female_named_nodes = [
-            node for node in self.node_to_data if self.node_to_data[node]["sex"] == "F" and not node.isnumeric()
+
+        # Replace relations with dotted edges
+        if nodes_to_remove:
+            tree.remove_nodes_from(nodes_to_remove)
+        if edges_to_remove:
+            tree.remove_edges_from(edges_to_remove)
+        if dotted_edges_to_add:
+            tree.add_edges_from(dotted_edges_to_add, style="dotted")
+        parent_child_edges = [
+            (u, v) for u, v, style in tree.edges.data("style", default="parent_child") if style == "parent_child"
         ]
+        dotted_edges = [(u, v) for u, v, style in tree.edges.data("style", default="parent_child") if style == "dotted"]
+
+        male_named_nodes = [node for node in tree.nodes if self.get_data(node)["sex"] == "M" and not node.isnumeric()]
+        male_placeholder_nodes = [node for node in tree.nodes if self.get_data(node)["sex"] == "M" and node.isnumeric()]
+        female_named_nodes = [node for node in tree.nodes if self.get_data(node)["sex"] == "F" and not node.isnumeric()]
         female_placeholder_nodes = [
-            node for node in self.node_to_data if self.node_to_data[node]["sex"] == "F" and node.isnumeric()
+            node for node in tree.nodes if self.get_data(node)["sex"] == "F" and node.isnumeric()
         ]
 
-        non_placeholder_labels = dict()
+        node_labels = dict()
         for node in tree.nodes:
-            mt_haplogroup = self.node_to_data[node]["mt_haplogroup"][:3]
-            y_haplogroup = self.node_to_data[node]["y_haplogroup"][:3]
+            mt_haplogroup = self.get_data(node)["mt_haplogroup"].replace("*", "")[:3]
+            y_haplogroup = self.get_data(node)["y_haplogroup"].replace("*", "")[:3]
             if node.isnumeric():
                 if y_haplogroup:
-                    non_placeholder_labels[node] = f"{mt_haplogroup}\n{y_haplogroup}"
+                    node_labels[node] = f"MT: {mt_haplogroup}\nY: {y_haplogroup}"
                 else:
-                    non_placeholder_labels[node] = f"{mt_haplogroup}"
+                    node_labels[node] = f"MT: {mt_haplogroup}"
             else:
                 if y_haplogroup:
-                    non_placeholder_labels[node] = f"{node}\n{mt_haplogroup}\n{y_haplogroup}"
+                    node_labels[node] = f"{node}\nMT: {mt_haplogroup}\nY: {y_haplogroup}"
                 else:
-                    non_placeholder_labels[node] = f"{node}\n{mt_haplogroup}"
+                    node_labels[node] = f"{node}\nMT: {mt_haplogroup}"
 
         # Create colormap for MT haplogroups
-        cmap = plt.get_cmap("tab20")
-        mt_haplogroups = sorted(
-            set([self.node_to_data[node]["mt_haplogroup"] for node in self.node_to_data if not node.isnumeric()])
-        )
-        mt_haplogroup_to_color = {
-            haplogroup: cmap(i / len(mt_haplogroups)) for i, haplogroup in enumerate(mt_haplogroups)
-        }
+        if not mt_haplogroup_to_color:
+            cmap = plt.get_cmap("tab20")
+            mt_haplogroups = sorted(
+                set(
+                    [
+                        self.get_data(node)["mt_haplogroup"].replace("*", "")
+                        for node in self.node_to_data
+                        if not node.isnumeric()
+                    ]
+                )
+            )
+            mt_haplogroup_to_color = {
+                haplogroup: cmap(i / len(mt_haplogroups)) for i, haplogroup in enumerate(mt_haplogroups)
+            }
+
+        # Specify alpha here instead of in nx.draw_networkx_nodes so node borders stay opaque
+        face_alpha = 0.5
         male_named_node_colors = [
-            mt_haplogroup_to_color[self.node_to_data[node]["mt_haplogroup"]] for node in male_named_nodes
+            to_rgba(mt_haplogroup_to_color[self.get_data(node)["mt_haplogroup"].replace("*", "")], face_alpha)
+            for node in male_named_nodes
         ]
         female_named_node_colors = [
-            mt_haplogroup_to_color[self.node_to_data[node]["mt_haplogroup"]] for node in female_named_nodes
+            to_rgba(mt_haplogroup_to_color[self.get_data(node)["mt_haplogroup"].replace("*", "")], face_alpha)
+            for node in female_named_nodes
         ]
+        male_placeholder_node_colors = [to_rgba("#e5e5e5", face_alpha) for node in male_placeholder_nodes]
+        female_placeholder_node_colors = [to_rgba("#e5e5e5", face_alpha) for node in female_placeholder_nodes]
 
         plt.figure(figsize=(12, 4.8), dpi=1200)
         # Scale sizes based on pedigree node count
-        node_size = min(1000, 10000 / len(tree.nodes))
+        node_size = min(1000, 9000 / len(tree.nodes))
         # Matplotlib doesn't allow font size less than 1
-        font_size = max(min(4.5, 150 / len(tree.nodes)), 1)
+        font_size = max(math.sqrt(node_size) / 5, 1)
+        line_width = math.sqrt(node_size) / 100
 
         pos = nx.nx_agraph.graphviz_layout(tree, prog="dot")
         nx.draw_networkx_nodes(
@@ -1157,7 +1385,7 @@ class Pedigree:
             node_size=node_size,
             node_color=male_named_node_colors,
             edgecolors="black",
-            linewidths=0.2,
+            linewidths=line_width,
         )
         nx.draw_networkx_nodes(
             tree,
@@ -1167,7 +1395,7 @@ class Pedigree:
             node_size=node_size,
             node_color=female_named_node_colors,
             edgecolors="black",
-            linewidths=0.2,
+            linewidths=line_width,
         )
         nx.draw_networkx_nodes(
             tree,
@@ -1175,9 +1403,9 @@ class Pedigree:
             nodelist=male_placeholder_nodes,
             node_shape="s",
             node_size=node_size,
-            node_color="#e5e5e5",
+            node_color=male_placeholder_node_colors,
             edgecolors="black",
-            linewidths=0.2,
+            linewidths=line_width,
         )
         nx.draw_networkx_nodes(
             tree,
@@ -1185,12 +1413,33 @@ class Pedigree:
             nodelist=female_placeholder_nodes,
             node_shape="o",
             node_size=node_size,
-            node_color="#e5e5e5",
+            node_color=female_placeholder_node_colors,
             edgecolors="black",
-            linewidths=0.2,
+            linewidths=line_width,
+        )
+        nx.draw_networkx_labels(tree, pos=pos, labels=node_labels, font_size=font_size)
+        nx.draw_networkx_edges(
+            tree,
+            edgelist=parent_child_edges,
+            pos=pos,
+            node_shape="s",
+            node_size=node_size,
+            width=line_width,
+            arrowsize=line_width * 30,
+            edge_color="black",
+        )
+        # Setting arrows=False causes edges to overlap their associated nodes for some reason
+        nx.draw_networkx_edges(
+            tree,
+            edgelist=dotted_edges,
+            pos=pos,
+            node_shape="s",
+            node_size=node_size,
+            width=line_width * 1.5,
+            arrowstyle="-",
+            style=(0, (3, 3)),
+            edge_color="blue",
         )
-        nx.draw_networkx_labels(tree, pos=pos, labels=non_placeholder_labels, font_size=font_size)
-        nx.draw_networkx_edges(tree, pos=pos, node_shape="s", node_size=node_size, width=0.2, arrowsize=font_size * 1.2)
 
         plt.axis("off")
         plt.savefig(path, bbox_inches="tight")