knit-graphs 0.0.1__py3-none-any.whl

knit_graphs/Course.py

@@ -0,0 +1,104 @@
+"""Course representation of a section of knitting with no parent loops."""
+from knit_graphs.Loop import Loop
+
+
+class Course:
+    """
+    Course object for organizing loops into knitting rows
+    """
+
+    def __init__(self):
+        self.loops_in_order: list[Loop] = []
+        self._loop_set: dict[Loop, Loop] = {}
+
+    def add_loop(self, loop: Loop, index: int | None = None):
+        """
+        Add the loop at the given index or to the end of the course
+        :param loop: loop to add
+        :param index: index to insert at or None if adding to end
+        """
+        for parent_loop in loop.parent_loops:
+            assert parent_loop not in self, f"{loop} has parent {parent_loop}, cannot be added to same course"
+        self._loop_set[loop] = loop
+        if index is None:
+            self.loops_in_order.append(loop)
+        else:
+            self.loops_in_order.insert(index, loop)
+
+    def has_increase(self) -> bool:
+        """
+        :return: True if course has at least one yarn over to start new wales.
+        """
+        for loop in self:
+            if not loop.has_parent_loops():  # Yarn over
+                return True
+        return False
+
+    def has_decrease(self) -> bool:
+        """
+        :return: True if course has at least one decrease, merging two wales
+        """
+        for loop in self:
+            if len(loop.parent_loops) > 1:
+                return True
+        return False
+
+    def has_terminal_loop(self, knit_graph) -> bool:
+        """\
+        :param knit_graph: Knit graph to get child loop data from
+        :return: True if this course contains a terminal loop with no child
+        """
+        for loop in self:
+            if knit_graph.get_child_loop(loop) is None:
+                return True
+        return False
+
+    def __getitem__(self, index: int | slice) -> Loop | list[Loop]:
+        return self.loops_in_order[index]
+
+    def index(self, loop: Loop) -> int:
+        """
+        Searches for index of given loop_id
+        :param loop: loop_id or loop to find
+        :return: index of the loop_id
+        """
+        return self.loops_in_order.index(loop)
+
+    def in_round_with(self, next_course) -> bool:
+        """
+        :param next_course: another course who should follow this course
+        :return: True if the next course starts at the beginning of this course
+        """
+        next_start = next_course[0]
+        i = 1
+        while not next_start.has_parent_loops():
+            next_start = next_course[i]
+            i += 1
+        return self[0] in next_start.parent_loops
+
+    def in_row_with(self, next_course) -> bool:
+        """
+        :param next_course: another course that should follow this course.
+        :return: True if the next course starts at the end of this course.
+        """
+        next_start = next_course[0]
+        i = 1
+        while not next_start.has_parent_loops():
+            next_start = next_course[i]
+            i += 1
+        return self[-1] in next_start.parent_loops
+
+    def __contains__(self, loop: Loop) -> bool:
+        return loop in self._loop_set
+
+    def __iter__(self):
+        return self.loops_in_order.__iter__()
+
+    def __len__(self):
+        return len(self.loops_in_order)
+
+    def __str__(self):
+        return str(self.loops_in_order)
+
+    def __repr__(self):
+        return str(self)

knit_graphs/Knit_Graph.py

@@ -0,0 +1,187 @@
+"""The graph structure used to represent knitted objects"""
+import networkx
+
+from knit_graphs.Course import Course
+from knit_graphs.Loop import Loop
+from knit_graphs.Pull_Direction import Pull_Direction
+from knit_graphs.Yarn import Yarn
+from knit_graphs.artin_wale_braids.Crossing_Direction import Crossing_Direction
+from knit_graphs.artin_wale_braids.Loop_Braid_Graph import Loop_Braid_Graph
+from knit_graphs.artin_wale_braids.Wale import Wale
+from knit_graphs.artin_wale_braids.Wale_Group import Wale_Group
+
+
+class Knit_Graph:
+    """
+    A representation of knitted structures as connections between loops on yarns
+    """
+
+    def __init__(self):
+        self.stitch_graph: networkx.DiGraph = networkx.DiGraph()
+        self.braid_graph: Loop_Braid_Graph = Loop_Braid_Graph()
+        self._last_loop: None | Loop = None
+        self.yarns: dict[Yarn, Yarn] = {}
+
+    @property
+    def last_loop(self) -> None | Loop:
+        """
+        :return: Last loop added to graph
+        """
+        return self._last_loop
+
+    @property
+    def has_loop(self) -> bool:
+        """
+        :return: True if graph has loops
+        """
+        return self._last_loop is not None
+
+    def add_crossing(self, left_loop: Loop, right_loop: Loop, crossing_direction: Crossing_Direction):
+        """
+        Adds edge between loops with attribute of the crossing direction.
+        :param left_loop: Loop on the left side of the crossing.
+        :param right_loop: Loop on the right side of the crossing.
+        :param crossing_direction: The crossing direction is (over, under, none) between loops.
+        """
+        self.braid_graph.add_crossing(left_loop, right_loop, crossing_direction)
+
+    def add_loop(self, loop: Loop):
+        """
+        Adds a loop to the graph
+        :param loop: the loop to be added in as a node in the graph
+        """
+        self.stitch_graph.add_node(loop)
+        if loop.yarn not in self.yarns:
+            self.add_yarn(loop.yarn)
+        if self._last_loop is None or loop > self._last_loop:
+            self._last_loop = loop
+
+    def add_yarn(self, yarn: Yarn):
+        """
+        Adds a yarn to the graph. Assumes that loops do not need to be added
+        :param yarn: the yarn to be added to the graph structure
+        """
+        self.yarns[yarn] = yarn
+
+    def connect_loops(self, parent_loop: Loop, child_loop: Loop,
+                      pull_direction: Pull_Direction = Pull_Direction.BtF,
+                      stack_position: int | None = None):
+        """
+        Creates a stitch-edge by connecting a parent and child loop
+        :param parent_loop: the id of the parent loop to connect to this child
+        :param child_loop:  the id of the child loop to connect to the parent
+        :param pull_direction: the direction the child is pulled through the parent
+        :param stack_position: The position to insert the parent into, by default add on top of the stack
+        """
+        if parent_loop not in self:
+            raise KeyError(f"parent loop {parent_loop} not in Knit Graph")
+        if child_loop not in self:
+            raise KeyError(f"child loop {parent_loop} not in Knit Graph")
+        self.stitch_graph.add_edge(parent_loop, child_loop, pull_direction=pull_direction)
+        child_loop.add_parent_loop(parent_loop, stack_position)
+
+    def get_wale_starting_with_loop(self, first_loop: Loop) -> Wale:
+        """
+        :param first_loop:
+        :return: A wale starting from given loop in knit graph.
+        """
+        wale = Wale(first_loop)
+        cur_loop = first_loop
+        while len(self.stitch_graph.successors(cur_loop)) == 1:
+            cur_loop = [*self.stitch_graph.successors(cur_loop)][0]
+            wale.add_loop_to_end(cur_loop, self.stitch_graph.edges[wale.last_loop, cur_loop]['pull_direction'])
+        return wale
+
+    def get_wales_ending_with_loop(self, last_loop: Loop) -> list[Wale]:
+        """
+        :param last_loop: last loop of joined set of wales
+        :return: the set of wales that end at this loop, only multiple wales if this is a child of a decrease.
+        """
+        wales = []
+        for top_stitch_parent in self.stitch_graph.predecessors(last_loop):
+            wale = Wale(last_loop)
+            wale.add_loop_to_beginning(top_stitch_parent, self.stitch_graph.edges[top_stitch_parent, last_loop]['pull_direction'])
+            cur_loop = top_stitch_parent
+            while len(cur_loop.parent_loops) == 1:  # stop at split for decrease or start of wale
+                cur_loop = [*self.stitch_graph.predecessors(cur_loop)][0]
+                wale.add_loop_to_beginning(cur_loop, self.stitch_graph.edges[cur_loop, wale.first_loop]['pull_direction'])
+            wales.append(wale)
+        return wales
+
+    def get_courses(self) -> list[Course]:
+        """
+        :return: A dictionary of loop_ids to the course they are on,
+        a dictionary or course ids to the loops on that course in the order of creation.
+        The first set of loops in the graph is on course 0.
+        A course change occurs when a loop has a parent loop in the last course.
+        """
+        courses = []
+        course = Course()
+        for loop in sorted([*self.stitch_graph.nodes]):
+            for parent in self.stitch_graph.predecessors(loop):
+                if parent in course:  # start a new course
+                    courses.append(course)
+                    course = Course()
+                    break
+            course.add_loop(loop)
+        courses.append(course)
+        return courses
+
+    def get_wale_groups(self) -> dict[Loop, Wale_Group]:
+        """
+        :return: Dictionary of terminal loops to the wale group they terminate
+        """
+        wale_groups = {}
+        for loop in self.stitch_graph.nodes:
+            if self.is_terminal_loop(loop):
+                wale_groups.update({loop: Wale_Group(wale, self) for wale in self.get_wales_ending_with_loop(loop)})
+        return wale_groups
+
+    def __contains__(self, item: Loop):
+        """
+        Returns true if the item is in the graph
+        :param item: the loop being checked for in the graph
+        :return: true if the loop_id of item or the loop is in the graph
+        """
+        return self.stitch_graph.has_node(item)
+
+    def get_stitch_edge(self, parent: Loop, child: Loop, stitch_property: str | None = None):
+        """
+        Shortcut to get stitch-edge data from loops or ids
+        :param stitch_property: property of edge to return
+        :param parent: parent loop or id of parent loop
+        :param child: child loop or id of child loop
+        :return: the edge data for this stitch edge
+        """
+        if self.stitch_graph.has_edge(parent, child):
+            edge = self.stitch_graph.get_edge_data(parent, child)
+            if stitch_property is not None:
+                return edge[stitch_property]
+            else:
+                return edge
+        else:
+            return None
+
+    def get_child_loop(self, loop: Loop) -> Loop | None:
+        """
+        :param loop: loop_id to look for child from.
+        :return: child loop_id or None if no child loop
+        """
+        successors = [*self.stitch_graph.successors(loop)]
+        if len(successors) == 0:
+            return None
+        return successors[0]
+
+    def has_child_loop(self, loop: Loop) -> bool:
+        """
+        :param loop:
+        :return: True if loop has a child loop
+        """
+        return self.get_child_loop(loop) is not None
+
+    def is_terminal_loop(self, loop: Loop) -> bool:
+        """
+        :param loop:
+        :return: True if loop has no child
+        """
+        return not self.has_child_loop(loop)

knit_graphs/Loop.py

@@ -0,0 +1,155 @@
+"""Module containing the Loop Class"""
+
+
+class Loop:
+    """
+    A class to represent a single loop structure for modeling a single loop in a knitting pattern.
+
+    Attributes:
+    -----------
+    _loop_id : int
+        a unique identifier for the loop
+    yarn : Yarn
+        the Yarn variable that creates and holds this loop
+    parent_loops : list
+        the list of parent loops
+    front_floats : dict
+        a dictionary of loops in front of the float
+    back_floats : dict
+        a dictionary of loops behind the float
+
+    Methods:
+    -----------
+    add_loop_in_front_of_float(u, v)
+        Set this loop to be in front of the float between u and v
+    add_loop_behind_float(u, v)
+        Set this loop to be behind the float between u and v
+    is_in_front_of_float(u, v)
+        Check if the float between u and v is in front of this loop
+    is_behind_float(u, v)
+        Check if the float between u and v is behind this loop
+    prior_loop_on_yarn()
+        Return the prior loop on yarn or None if first loop on yarn
+    next_loop_on_yarn()
+        Return the next loop on yarn or None if last loop on yarn
+    has_parent_loops()
+        Check if loop has stitch-edge parents
+    add_parent_loop(parent, stack_position)
+        Add the parent Loop onto the stack of parent_loops
+    """
+
+    def __init__(self, loop_id: int, yarn):
+        """
+        Constructs the Loop object.
+
+        Parameters:
+        -----------
+        loop_id : int
+            a unique identifier for the loop, must be non-negative
+        yarn : Yarn
+            the Yarn variable that creates and holds this loop
+        """
+        assert loop_id >= 0, f"{loop_id}: Loop_id must be non-negative"
+        self._loop_id: int = loop_id
+        self.yarn = yarn
+        self.parent_loops: list[Loop] = []
+        self.front_floats: dict[Loop, set[Loop]] = {}
+        self.back_floats: dict[Loop, set[Loop]] = {}
+
+    def add_loop_in_front_of_float(self, u, v):
+        """
+        Set this loop to be in front of the float between u and v
+        :param u: First loop in float
+        :param v: Second loop in float
+        """
+        if u not in self.back_floats:
+            self.back_floats[u] = set()
+        if v not in self.back_floats:
+            self.back_floats[v] = set()
+        self.back_floats[u].add(v)
+        self.back_floats[v].add(u)
+
+    def add_loop_behind_float(self, u, v):
+        """
+        Set this loop to be behind the float between u and v
+        :param u: First loop in float
+        :param v: Second loop in float
+        """
+        if u not in self.front_floats:
+            self.front_floats[u] = set()
+        if v not in self.front_floats:
+            self.front_floats[v] = set()
+        self.front_floats[u].add(v)
+        self.front_floats[v].add(u)
+
+    def is_in_front_of_float(self, u, v) -> bool:
+        """
+        :param u: First loop in float.
+        :param v: Second loop in float.
+        :return: True if the float between u and v is in front of this loop.
+        """
+        return u in self.back_floats and v in self.back_floats and v in self.back_floats[u]
+
+    def is_behind_float(self, u, v) -> bool:
+        """
+        :param u: First loop in float.
+        :param v: Second loop in float.
+        :return: True if the float between u and v is behind this loop.
+        """
+        return u in self.front_floats and v in self.front_floats and v in self.front_floats[u]
+
+    def prior_loop_on_yarn(self):
+        """
+        :return: Prior loop on yarn or None if first loop on yarn
+        """
+        return self.yarn.prior_loop(self)
+
+    def next_loop_on_yarn(self):
+        """
+        :return: Next loop on yarn or Non if last loop on yarn
+        """
+        return self.yarn.next_loop(self)
+
+    def has_parent_loops(self) -> bool:
+        """
+        :return: True if loop has stitch-edge parents
+        """
+        return len(self.parent_loops) > 0
+
+    def add_parent_loop(self, parent, stack_position: int | None = None):
+        """
+        Adds the parent Loop onto the stack of parent_loops
+        :param parent: the Loop to be added onto the stack
+        :param stack_position: The position to insert the parent into, by default add on top of the stack
+        """
+        if stack_position is not None:
+            self.parent_loops.insert(stack_position, parent)
+        else:
+            self.parent_loops.append(parent)
+
+    @property
+    def loop_id(self) -> int:
+        """
+        :return: the id of the loop
+        """
+        return self._loop_id
+
+    def __hash__(self):
+        return self.loop_id
+
+    def __eq__(self, other):
+        return isinstance(other, Loop) and self.loop_id == other.loop_id and self.yarn == other.yarn
+
+    def __lt__(self, other):
+        assert isinstance(other, Loop)
+        return self.loop_id < other.loop_id
+
+    def __gt__(self, other):
+        assert isinstance(other, Loop)
+        return self.loop_id > other.loop_id
+
+    def __str__(self):
+        return f"{self.loop_id} on yarn {self.yarn}"
+
+    def __repr__(self):
+        return str(self.loop_id)

knit_graphs/Pull_Direction.py

@@ -0,0 +1,23 @@
+"""Enumerator used to define the two pull-direction of a loop through other loops"""
+from enum import Enum
+
+
+class Pull_Direction(Enum):
+    """An enumerator of the two pull-directions of a loop."""
+    BtF = "Knit"
+    FtB = "Purl"
+
+    def opposite(self):
+        """
+        :return: returns the opposite pull direction of self
+        """
+        if self is Pull_Direction.BtF:
+            return Pull_Direction.FtB
+        else:
+            return Pull_Direction.BtF
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value