knit-graphs 0.0.6__py3-none-any.whl → 0.0.7__py3-none-any.whl

{knit_graphs-0.0.6.dist-info → knit_graphs-0.0.7.dist-info}/METADATA

@@ -1,23 +1,29 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: knit-graphs
-Version: 0.0.6
+Version: 0.0.7
 Summary: A graph representation of knitted structures where each loop is a node and edges represent yarn and stitch relationships.
-Project-URL: Documentation, https://github.com/mhofmann-Khoury/knit_graph#readme
-Project-URL: Issues, https://github.com/mhofmann-Khoury/knit_graph/issues
-Project-URL: Source, https://github.com/mhofmann-Khoury/knit_graph
-Author-email: Megan Hofmann <m.hofmann@northeastern.edu>
-License-File: LICENSE
-Keywords: ACT Lab,Northeastern,fabrication,knit,machine knit,textile
-Classifier: Development Status :: 2 - Pre-Alpha
+Home-page: https://mhofmann-Khoury.github.io/knit-graphs/
+License: MIT
+Keywords: ACT Lab,Northeastern University,knit,machine knit,fabrication,textile
+Author: Megan Hofmann
+Author-email: m.hofmann@northeastern.edu
+Maintainer: Megan Hofmann
+Maintainer-email: m.hofmann@northeastern.edu
+Requires-Python: >=3.11,<3.14
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
-Classifier: Programming Language :: Python
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.11
-Requires-Dist: networkx~=3.2.1
-Requires-Dist: plotly~=5.22.0
+Requires-Dist: networkx (>=3.5)
+Requires-Dist: plotly (>=6.3.0)
+Project-URL: Documentation, https://mhofmann-Khoury.github.io/knit-graphs/
+Project-URL: Repository, https://github.com/mhofmann-Khoury/knit-graphs
 Description-Content-Type: text/markdown
 
 # knit_graphs
@@ -27,9 +33,9 @@ Description-Content-Type: text/markdown
 
 -----
 ## Description
-The knit-graphs packaged provides a data structure for representing knitted structures formed of loops of yarn (nodes) connected by various edge structures. Loops are connected by: floats (yarn-edges) in a yarn graph structure, stitch edges (loops pulled through loops), and crossed over each other in a wale-braid structure. 
+The knit-graphs packaged provides a data structure for representing knitted structures formed of loops of yarn (nodes) connected by various edge structures. Loops are connected by: floats (yarn-edges) in a yarn graph structure, stitch edges (loops pulled through loops), and crossed over each other in a wale-braid structure.
 
-Knit graphs provide a powerful tool for representing knitted structures for digital fabrication systems such as knitting machine programming languages and design tools. 
+Knit graphs provide a powerful tool for representing knitted structures for digital fabrication systems such as knitting machine programming languages and design tools.
 
 Additional details about this knit-graph construction are available in the ACM publication:
 ["KnitPicking Texture: Programming and Modifying Complex Knitted Textures for Machine and Hand Knitting"](https://doi.org/10.1145/3332165.3347886)
@@ -54,25 +60,27 @@ pip install knit-graphs
 ## Usage
 
 ### Knit Graph Generators
-The [knit-graph-generators subpackage](https://github.com/mhofmann-Khoury/knit_graph/tree/main/src/knit_graphs/knit_graph_generators) provides a library of basic knit graphs to generate such as casting on loops of a knitted structure, creating Jersey (aka Stockinette) tubes and swatches, and other basic textures. 
+The [knit-graph-generators subpackage](https://github.com/mhofmann-Khoury/knit_graph/tree/main/src/knit_graphs/knit_graph_generators) provides a library of basic knit graphs to generate such as casting on loops of a knitted structure, creating Jersey (aka Stockinette) tubes and swatches, and other basic textures.
 For example, to generate a swatch of knit-purl ribbing use the following:
+
 ```python
-from knit_graphs.knit_graph_generators.basic_knit_graph_generators import kp_rib_swatch
+from knit_graphs.basic_knit_graph_generators import kp_rib_swatch
+
 width = 10
 height = 10
 kp_rib_swatch = kp_rib_swatch(width, height)
 ```
 Additional examples of knitgraph generator usage can be found in the [Knit_Graph test module](https://github.com/mhofmann-Khoury/knit_graph/blob/main/tests/test_Knit_Graph.py).
 
-Knitgraphs can be created without generators. We encourage users to review the generators as simple examples on creating a knit graph programmatically. 
+Knitgraphs can be created without generators. We encourage users to review the generators as simple examples on creating a knit graph programmatically.
 
 ### Visualizing Knit Graphs
-We provide simple support for visualizing knit graphs. This is primarily used to debugging simple knit graph programs. 
+We provide simple support for visualizing knit graphs. This is primarily used to debugging simple knit graph programs.
 
 For example, we can visualize a swatch of seed stitch (checkered knit and purl stitches) with the following code.
 
 ```python
-from knit_graphs.knit_graph_generators.basic_knit_graph_generators import seed_swatch
+from knit_graphs.basic_knit_graph_generators import seed_swatch
 from knit_graphs.knit_graph_visualizer.Stitch_Visualizer import visualize_stitches
 
 width = 4
@@ -80,16 +88,17 @@ height = 4
 swatch = seed_swatch(width, height)
 visualize_stitches(swatch)
 ```
-The visualizer shows knit stitches (loops pulled from the back of the fabric to the front) as blue edges and purl stitches (loops pulled from the front to back) (aka back-knits) as red edges. Loop nodes are circles labeled with their time-ordered index and colored to match their yarn (defaults to dark green). The yarn edges (aka floats) connecting them are made of thin edges the same color as the loop nodes. 
+The visualizer shows knit stitches (loops pulled from the back of the fabric to the front) as blue edges and purl stitches (loops pulled from the front to back) (aka back-knits) as red edges. Loop nodes are circles labeled with their time-ordered index and colored to match their yarn (defaults to dark green). The yarn edges (aka floats) connecting them are made of thin edges the same color as the loop nodes.
 
 Additional examples of using the visualizer are available in the [Stitch Visualizer Tests Module](https://github.com/mhofmann-Khoury/knit_graph/blob/main/tests/test_Stitch_Visualizer.py)
 
 ## Credits
-The design of this data scructure was completed by the authors of 
+The design of this data scructure was completed by the authors of
 ["KnitPicking Texture: Programming and Modifying Complex Knitted Textures for Machine and Hand Knitting"](https://doi.org/10.1145/3332165.3347886).
 
 The inclusion of the Artin-Braide wale crossing construction was inspired by ["An Artin Braid Group Representation of Knitting Machine State with Applications to Validation and Optimization of Fabrication Plans"](https://doi.org/10.1109/ICRA48506.2021.9562113) by Jenny Lin and James McCann.
 
 ## License
 
-`knit-graphs` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
+`knit-graphs` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
+

knit_graphs-0.0.7.dist-info/RECORD

@@ -0,0 +1,29 @@
+LICENSE,sha256=Oazk3oiRu5ZN7b-EdYNYh0vu-I3Av2uIPQ-9L_cZ6Oo,1070
+README.md,sha256=Hrs3kN8A7hxyel-WhEkzZYY89456vAh3KWbupcOAHsI,3963
+docs/Makefile,sha256=4zv3TVkTACm6JBaKgTES3ZI9cETXgM6ULbZkXZP1as8,638
+docs/make.bat,sha256=0qjrzODegavKd7LLwmr9ADhaYftiTnBgqOVAL9kApyo,769
+docs/source/api/knit_graphs.artin_wale_braids.rst,sha256=_KUBZld6fAS5OP0k4gd5yKamNGXEqH12XjakmWeJIII,1549
+docs/source/api/knit_graphs.rst,sha256=zdmnXipviweW0ZGQsQCZtfOOc_6Fj0yWdg_TwOMafLI,1398
+docs/source/conf.py,sha256=TZK8Rz0JNgQs2J_cUhVX5_4tmMBvRdGtILJsnAnAFWo,13350
+docs/source/index.rst,sha256=D4KmCX1_d2-WrPgxSeggHHsc9-TeQwSUGYOkehRQWrw,1462
+docs/source/installation.rst,sha256=GyNRk_oXKVgOZ4KFLAgkXLwjHYzDYsx8gcokLRrS0ZI,1247
+knit_graphs/Course.py,sha256=oT-YghPdAg7A51GI_StdfF8oxYGWGkoad72woEkRKeY,5818
+knit_graphs/Knit_Graph.py,sha256=KgcWQPzZJ-Iif7g3zWq6hBy4fdJXkJXnFxGOSMYOn-g,10795
+knit_graphs/Knit_Graph_Visualizer.py,sha256=bbWl9iPQR93MtpWMPji4RTFR3Rgon0vzBlS11e2R8Zg,37925
+knit_graphs/Loop.py,sha256=zp1ZiVRFSCPL2CnXNxgwNPv7WrcuqFRe3S_ZATxEBAo,5781
+knit_graphs/Pull_Direction.py,sha256=8xRLN-j7V1mExgmt3YjcJcTDa5rLedA2bF4wI8gd-DE,2334
+knit_graphs/Yarn.py,sha256=wNOmj15dnSA56Qw2D5ksgbmQqug-u5kPPxKGuitQ_qI,15901
+knit_graphs/__init__.py,sha256=qzZAOxTqjgLkhoGnKNZwOkuYbKEyzfWKkKpKkV6lVfk,111
+knit_graphs/_base_classes.py,sha256=ZEv_jkUglHzkfg-0TD6oonBq7QQmA4G7jrC_A6OubpY,6401
+knit_graphs/artin_wale_braids/Crossing_Direction.py,sha256=71ckmEFfL0s25NJb8lfYwH2zku0uM1C5X9gGM7PYC5A,2820
+knit_graphs/artin_wale_braids/Loop_Braid_Graph.py,sha256=2tsE16IzcvgsIKij1JNHWah6hLOgrpXCcjb6eocbfFs,4575
+knit_graphs/artin_wale_braids/Wale.py,sha256=PK8IQDnTFXk5924QZYiGCqfckS62laG9_XhK7xH2zAo,7171
+knit_graphs/artin_wale_braids/Wale_Braid.py,sha256=Ws0QmU7s63nrBKe69acDza-r-LozDyyaKVDNxQMy10Y,2662
+knit_graphs/artin_wale_braids/Wale_Braid_Word.py,sha256=4YBlVMUZkqp85r46ETQSbFVS_WrT4PsWthHmFv5Ny9M,4587
+knit_graphs/artin_wale_braids/Wale_Group.py,sha256=HTl01PHzFhInhFJuB30OScWx7pIejmo3-HwHN4RB4V4,6868
+knit_graphs/artin_wale_braids/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+knit_graphs/basic_knit_graph_generators.py,sha256=_8CbtZ4M5NRp0mXXNdCNDPtIaCKEzmpAJQVNlmV5l8c,13893
+knit_graphs-0.0.7.dist-info/LICENSE,sha256=Oazk3oiRu5ZN7b-EdYNYh0vu-I3Av2uIPQ-9L_cZ6Oo,1070
+knit_graphs-0.0.7.dist-info/METADATA,sha256=YuT2TGLdupJYXAKbbC-pXi-z0fKbOelNz31STuy7tks,5188
+knit_graphs-0.0.7.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+knit_graphs-0.0.7.dist-info/RECORD,,

{knit_graphs-0.0.6.dist-info → knit_graphs-0.0.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.24.2
+Generator: poetry-core 1.8.1
 Root-Is-Purelib: true
 Tag: py3-none-any

knit_graphs/__about__.py

@@ -1,4 +0,0 @@
-# SPDX-FileCopyrightText: 2024-present m.hofmann <m.hofmann@northeastern.edu>
-#
-# SPDX-License-Identifier: MIT
-__version__ = "0.0.6"

knit_graphs/knit_graph_visualizer/Stitch_Visualizer.py

@@ -1,427 +0,0 @@
-import networkx
-import plotly.graph_objects as go
-
-from knit_graphs.Course import Course
-from knit_graphs.Knit_Graph import Knit_Graph
-from knit_graphs.Loop import Loop
-from knit_graphs.Pull_Direction import Pull_Direction
-from knit_graphs.artin_wale_braids.Crossing_Direction import Crossing_Direction
-
-
-def get_base_row_course_positions(course: Course, start_on_left: bool, loop_space: float = 1.0) -> tuple[dict[Loop, float], float, float]:
-    """
-    :param course: course assumed to be base of knit graph for visualization
-    :param start_on_left: If True, loops will start on left side of plot
-    :param loop_space: spacing between loops
-    :return: dictionary of loops in course keyed to x position. The minimum loop position. The maximum loop position.
-    """
-    loops = course
-    if not start_on_left:
-        loops = reversed(course)
-    positions = {l: x * loop_space for x, l in enumerate(loops)}
-    return positions, min(positions.values()), max(positions.values())
-
-
-def get_base_round_course_positions(course: Course, start_on_left: bool,
-                                    loop_space: float = 1.0, back_shift: float = 0.5) -> tuple[dict[Loop, float], dict[Loop, float], float, float]:
-    """
-    :param back_shift: Shift in x position for back bed loop s that can't be placed by float inference.
-    :param course: Course assumed to be base of knit graph for visualization.
-    :param start_on_left: If True, loops will start on the left side of plot.
-    :param loop_space: Spacing between loops.
-    :return: Dictionary of loops in front of the course keyed to x position.
-     Dictionary of loops in the back of the course keyed to x position.
-      Min loop position. Max loop position
-    """
-    split_index = int(len(course) / 2)
-    front_loops = course[:split_index]
-    back_loops = course[split_index:]
-    if start_on_left:
-        back_loops = reversed(back_loops)
-    else:
-        front_loops = reversed(back_loops)
-    front_positions = {l: x * loop_space for x, l in enumerate(front_loops)}
-    back_positions = {l: x * loop_space + back_shift for x, l in enumerate(back_loops)}
-    for back_loop in back_loops:
-        float_positions = [front_positions[fl] for fl in back_loop.front_floats if fl in front_positions]
-        if len(float_positions) > 0:
-            back_positions[back_loop] = sum(float_positions) / len(float_positions)
-    min_front = min(front_positions.values())
-    max_front = max(front_positions.values())
-    min_back = min(back_positions.values())
-    max_back = max(back_positions.values())
-    return front_positions, back_positions, min(min_front, min_back), max(max_front, max_back)
-
-
-def get_loop_x_by_parent_average(data_graph: networkx.DiGraph, loop: Loop) -> float | None:
-    """
-    :param data_graph: Collection of loop nodes to assigned locations.
-    :param loop: Loop to derive location for.
-    :return: X position derived from parent_loop locations for loop.
-    """
-
-    def _parent_weight(stack_position):
-        return len(loop.parent_loops) - stack_position
-
-    parent_positions = {data_graph.nodes[p]['x'] * _parent_weight(sp): _parent_weight(sp)
-                        for sp, p in enumerate(loop.parent_loops)
-                        if p in data_graph.nodes}
-    if len(parent_positions) == 0:
-        return None
-    return sum(parent_positions.keys()) / sum(parent_positions.values())
-
-
-def get_loop_x_by_yarn_neighbor_average(data_graph: networkx.DiGraph, loop: Loop, prior_space=1, next_space=-1) -> float | None:
-    """
-    :param data_graph: Collection of loop nodes to assigned locations.
-    :param loop: Loop to place.
-    :param prior_space: Spacing from this loop to prior on yarn.
-    :param next_space: Spacing from this loop to next on yarn.
-    :return: None if no neighbors are placed or assign x position by neighbors on yarn.
-    """
-    x_neighbors = []
-    prior_loop = loop.prior_loop_on_yarn()
-    next_loop = loop.next_loop_on_yarn()
-    if prior_loop is not None and prior_loop in data_graph.nodes:
-        x_neighbors.append(data_graph.nodes[prior_loop]['x'] + prior_space)
-    if next_loop is not None and next_loop in data_graph.nodes:
-        x_neighbors.append(data_graph.nodes[next_loop]['x'] + next_space)
-    return sum(x_neighbors) / len(x_neighbors)
-
-
-def re_balance_course(data_graph: networkx.DiGraph, course: Course, target_width: float | None,
-                      left_side: float = 0, right_side: float | None = None) -> dict[Loop, float]:
-    """
-    :param target_width: Width to retarget to. Defaults to definition from right side value.
-    :param data_graph:  Collection of loop nodes to assign locations.
-    :param course: The course to re-balance.
-    :param left_side: The minimum left position of the course.
-    :param right_side: The maximum right position of the course. Defaults to right most loop position.
-    :return: Dictionary of loops to rebalanced positions.
-    Maintains original float proportions of each loop but assigns positions between left and right side values.
-    """
-    min_x, min_loop = min_x_in_course(course, data_graph)
-    max_x, max_loop = max_x_in_course(course, data_graph)
-    course_width = max_x - min_x
-    if target_width is None:
-        if right_side is None:
-            right_side = max_x
-        target_width = right_side - left_side
-
-    def _target_float_size(u, v) -> float:
-        current_size = abs(data_graph.nodes[u]['x'] - data_graph.nodes[v]['x'])
-        return (current_size * target_width) / course_width
-
-    return {l: _target_float_size(min_loop, l) + left_side for l in course}
-
-
-def max_x_in_course(course, data_graph) -> tuple[float, Loop]:
-    """
-    :param course:
-    :param data_graph:
-    :return: right most x position in course, loop with right most x position
-    """
-    return max([(data_graph.nodes[l]['x'], l) for l in course], key=lambda tup: tup[0])
-
-
-def min_x_in_course(course, data_graph) -> tuple[float, Loop]:
-    """
-    :param course:
-    :param data_graph:
-    :return: left most x position in course, loop with left most x position
-    """
-    return min([(data_graph.nodes[l]['x'], l) for l in course], key=lambda tup: tup[0])
-
-
-def get_loop_y_by_neighbor_floats(data_graph: networkx.DiGraph, loop: Loop, float_buffer: float = 0.25) -> float | None:
-    """
-    :param data_graph: Collection of loop nodes to assign locations.
-    :param loop: Loop to assign y location by neighboring floats.
-    :param float_buffer: Spacing between loop and its neighboring floats.
-    :return: Y position of loop or None if loop has no neighboring floats.
-    """
-    positions = [data_graph.nodes[fl]['y'] + float_buffer for fl in loop.front_floats if fl in data_graph.nodes]
-    positions.extend([data_graph.nodes[bl]['y'] - float_buffer for bl in loop.back_floats if bl in data_graph.nodes])
-    if len(positions) == 0:
-        return None
-    return sum(positions) / len(positions)
-
-
-def shift_purls(knit_graph: Knit_Graph, data_graph: networkx.DiGraph, purl_shift: float = 0.25):
-    shifted = set()
-    for u, v in knit_graph.stitch_graph.edges:
-        if v not in shifted:
-            pull_direction = knit_graph.stitch_graph[u][v]['pull_direction']
-            if pull_direction is Pull_Direction.FtB:
-                data_graph.nodes[v]['x'] += purl_shift
-                shifted.add(v)
-                if len(u.parent_loops) == 0:  # purl coming from yarn over
-                    data_graph.nodes[u]['x'] += purl_shift
-                    shifted.add(u)
-
-
-def visualize_stitches(knit_graph: Knit_Graph,
-                       first_course_index: int = 0, top_course_index: int | None = None,
-                       start_on_left: bool = True,
-                       re_balance_to_course_width=False,
-                       re_balance_to_base_width=False,
-                       left_zero_align=True,
-                       graph_title: str = "knit_graph"):
-    data_graph = position_loops(first_course_index, knit_graph, left_zero_align, re_balance_to_base_width, re_balance_to_course_width, start_on_left, top_course_index)
-
-    yarn_loop_traces = collect_yarn_loop_traces(data_graph, knit_graph)
-
-    yarn_float_traces = collect_yarn_float_traces(data_graph, knit_graph)
-
-    def _new_edge_data():
-        return {'x': [], 'y': [], 'edge': [], 'is_start': []}
-
-    def _add_edge_data(edge_data: dict[str, list], u_loop: Loop, v_loop: Loop):
-        data_graph.add_edge(u_loop, v_loop, pull_direction=pull_direction)
-        edge_data['x'].append(data_graph.nodes[u_loop]['x'])
-        edge_data['y'].append(data_graph.nodes[u_loop]['y'])
-        edge_data['edge'].append((u_loop, v_loop))
-        edge_data['is_start'].append(True)
-        edge_data['x'].append(data_graph.nodes[v_loop]['x'])
-        edge_data['y'].append(data_graph.nodes[v_loop]['y'])
-        edge_data['edge'].append((u_loop, v_loop))
-        edge_data['is_start'].append(False)
-        edge_data['x'].append(None)
-        edge_data['y'].append(None)
-
-    top_knit_data = _new_edge_data()
-    bot_knit_data = _new_edge_data()
-    top_purl_data = _new_edge_data()
-    bot_purl_data = _new_edge_data()
-    no_cross_knit_data = _new_edge_data()
-    no_cross_purl_data = _new_edge_data()
-
-    for left_loop, right_loop in knit_graph.braid_graph.loop_crossing_graph.edges:
-        crossing_direction = knit_graph.braid_graph.get_crossing(left_loop, right_loop)
-        for left_parent in left_loop.parent_loops:
-            pull_direction: Pull_Direction = knit_graph.stitch_graph[left_parent][left_loop]['pull_direction']
-            data_graph.add_edge(left_parent, left_loop, pull_direction=pull_direction)
-            if pull_direction is Pull_Direction.BtF:  # knit
-                if crossing_direction is Crossing_Direction.Over_Right:
-                    data = top_knit_data
-                elif crossing_direction is Crossing_Direction.Under_Right:
-                    data = bot_knit_data
-                else:
-                    data = no_cross_knit_data
-            else:
-                if crossing_direction is Crossing_Direction.Over_Right:
-                    data = top_purl_data
-                elif crossing_direction is Crossing_Direction.Under_Right:
-                    data = bot_purl_data
-                else:
-                    data = no_cross_knit_data
-            _add_edge_data(data, left_parent, left_loop)
-        for right_parent in right_loop.parent_loops:
-            pull_direction: Pull_Direction = knit_graph.stitch_graph[right_parent][right_loop]['pull_direction']
-            data_graph.add_edge(right_parent, right_loop, pull_direction=pull_direction)
-            if pull_direction is Pull_Direction.BtF:  # knit
-                if crossing_direction is Crossing_Direction.Under_Right:
-                    data = top_knit_data
-                elif crossing_direction is Crossing_Direction.Over_Right:
-                    data = bot_knit_data
-                else:
-                    data = no_cross_knit_data
-            else:
-                if crossing_direction is Crossing_Direction.Under_Right:
-                    data = top_purl_data
-                elif crossing_direction is Crossing_Direction.Over_Right:
-                    data = bot_purl_data
-                else:
-                    data = no_cross_purl_data
-            _add_edge_data(data, right_parent, right_loop)
-
-    for u, v in knit_graph.stitch_graph.edges:
-        if not data_graph.has_edge(u, v):
-            pull_direction: Pull_Direction = knit_graph.stitch_graph[u][v]['pull_direction']
-            if pull_direction is Pull_Direction.BtF:  # knit
-                _add_edge_data(no_cross_knit_data, u, v)
-            else:
-                _add_edge_data(no_cross_purl_data, u, v)
-
-    no_cross_knit_trace = go.Scatter(name="Knit Stitches (No Crossing)",
-                                     x=no_cross_knit_data['x'], y=no_cross_knit_data['y'],
-                                     line=dict(width=4, color='blue', dash='solid'),
-                                     opacity=0.8,
-                                     mode='lines')
-    top_knit_trace = go.Scatter(name="Knit Stitches (Crossing Over)",
-                                x=top_knit_data['x'], y=top_knit_data['y'],
-                                line=dict(width=5, color='blue', dash='solid'),
-                                opacity=1,
-                                mode='lines')
-    bot_knit_trace = go.Scatter(name="Knit Stitches (Crossing Under)",
-                                x=bot_knit_data['x'], y=bot_knit_data['y'],
-                                line=dict(width=3, color='blue', dash='dash'),
-                                opacity=.5,
-                                mode='lines')
-    no_cross_purl_trace = go.Scatter(name="Purl Stitches",
-                                     x=no_cross_purl_data['x'], y=no_cross_purl_data['y'],
-                                     line=dict(width=4, color='red', dash='solid'),
-                                     opacity=0.8,
-                                     mode='lines')
-    top_purl_trace = go.Scatter(name="Purl Stitches (Crossing Over)",
-                                x=top_purl_data['x'], y=top_knit_data['y'],
-                                line=dict(width=5, color='red', dash='solid'),
-                                opacity=1,
-                                mode='lines')
-    bot_purl_trace = go.Scatter(name="Purl Stitches (Crossing Under)",
-                                x=bot_purl_data['x'], y=bot_purl_data['y'],
-                                line=dict(width=3, color='red', dash='dash'),
-                                opacity=.5,
-                                mode='lines')
-
-    go_layout = go.Layout(title=graph_title,
-                          showlegend=True,
-                          hovermode='closest',
-                          margin=dict(b=20, l=5, r=5, t=40)
-                          )
-    figure_data = [top_knit_trace, top_purl_trace,
-                   no_cross_knit_trace, no_cross_purl_trace,
-                   bot_knit_trace, bot_purl_trace]
-    figure_data.extend(yarn_float_traces)
-    figure_data.extend(yarn_loop_traces)
-    fig = go.Figure(data=figure_data,
-                    layout=go_layout
-                    )
-    fig.show()
-
-
-def position_loops(first_course_index, knit_graph, left_zero_align, re_balance_to_base_width, re_balance_to_course_width,
-                   start_on_left, top_course_index):
-    data_graph = networkx.DiGraph()
-    courses = knit_graph.get_courses()
-    loops_to_course = {}
-    if top_course_index is not None:
-        courses = courses[:top_course_index]
-    base_course = courses[first_course_index]
-    for loop in base_course:
-        loops_to_course[loop] = base_course
-    if len(courses) > first_course_index + 1 and base_course.in_round_with(courses[first_course_index + 1]):
-        front_positions, back_positions, min_x, max_x = get_base_round_course_positions(base_course, start_on_left)
-        for loop, x in front_positions.items():
-            data_graph.add_node(loop, x=x, y=0)
-        for loop, x in back_positions.items():
-            # y = get_loop_y_by_neighbor_floats(data_graph, loop)
-            # if y is None:
-            #     y = .25
-            data_graph.add_node(loop, x=x, y=0)
-    else:
-        positions, min_x, max_x = get_base_row_course_positions(base_course, start_on_left)
-        for loop, x in positions.items():
-            data_graph.add_node(loop, x=x, y=0)
-    base_width = max_x - min_x
-    y = 1
-    for course in courses[first_course_index + 1:]:
-        need_x_placement = {}
-        for x, loop in enumerate(course):
-            loops_to_course[loop] = course
-            parent_average_x = get_loop_x_by_parent_average(data_graph, loop)
-            if parent_average_x is None:
-                need_x_placement[loop] = x
-            else:
-                x = parent_average_x
-            # float_placed_y = get_loop_y_by_neighbor_floats(data_graph, loop)
-            # if float_placed_y is not None:
-            #     y = float_placed_y
-            data_graph.add_node(loop, x=x, y=y)
-        for loop in need_x_placement.keys():
-            neighbor_based_x = get_loop_x_by_yarn_neighbor_average(data_graph, loop)
-            if neighbor_based_x is not None:
-                data_graph.nodes[loop]['x'] = neighbor_based_x
-        # swap x positions based on cable crossings
-        for left_loop in course:
-            for right_loop in knit_graph.braid_graph.left_crossing_loops(left_loop):
-                crossing_direction = knit_graph.braid_graph.get_crossing(left_loop, right_loop)
-                if crossing_direction is not Crossing_Direction.No_Cross:
-                    left_x = data_graph.nodes[left_loop]['x']
-                    data_graph.nodes[left_loop]['x'] = data_graph.nodes[right_loop]['x']
-                    data_graph.nodes[right_loop]['x'] = left_x
-        new_positions = {}
-        left_side = 0
-        if not left_zero_align:
-            left_side, left_loop = min_x_in_course(course, data_graph)
-        if re_balance_to_course_width:
-            new_positions = re_balance_course(data_graph, course, len(course) - 1, left_side)
-        elif re_balance_to_base_width:
-            new_positions = re_balance_course(data_graph, course, base_width, left_side)
-        for l, x in new_positions.items():
-            data_graph.nodes[l]['x'] = x
-        y += 1
-    adjust_y_positions_by_float_alignment(data_graph, knit_graph, loops_to_course)
-    shift_purls(knit_graph, data_graph)
-    return data_graph
-
-
-def adjust_y_positions_by_float_alignment(data_graph, knit_graph, loops_to_course, float_increment: float = 0.25):
-    for yarn in knit_graph.yarns:
-        for u, v, front_loops in yarn.loops_in_front_of_floats():
-            for fl in front_loops:
-                fl_course = loops_to_course[fl]
-                if u in fl_course and v in fl_course:  # same course, adjust float position
-                    data_graph.nodes[fl]['y'] -= float_increment
-        for u, v, back_loops in yarn.loops_behind_floats():
-            for bl in back_loops:
-                bl_course = loops_to_course[bl]
-                if u in bl_course and v in bl_course:  # same course, adjust float position
-                    data_graph.nodes[bl]['y'] += float_increment
-
-
-def collect_yarn_float_traces(data_graph, knit_graph):
-    """
-    :param data_graph: Collection of loop nodes to assign locations.
-    :param knit_graph: The knit graph to derive loop data from.
-    :return: The traces of the yarns-loop nodes for the graph
-    """
-    yarns_to_float_data = {}
-    for y in knit_graph.yarns.values():
-        float_data = {'x': [], 'y': []}
-        for u, v in y.loop_graph.edges:
-            float_data['x'].append(data_graph.nodes[u]['x'])
-            float_data['y'].append(data_graph.nodes[u]['y'])
-            float_data['x'].append(data_graph.nodes[v]['x'])
-            float_data['y'].append(data_graph.nodes[v]['y'])
-        yarns_to_float_data[y] = float_data
-    for y in knit_graph.yarns.values():
-        float_data = {'x': [], 'y': []}
-        for u in y.loop_graph.nodes:
-            float_data['x'].append(data_graph.nodes[u]['x'])
-            float_data['y'].append(data_graph.nodes[u]['y'])
-        yarns_to_float_data[y] = float_data
-    yarn_float_traces = [go.Scatter(name=y.yarn_id,
-                                    x=fd['x'], y=fd['y'],
-                                    line=dict(width=1,
-                                              color=y.properties.color,
-                                              shape='spline',
-                                              smoothing=1.3),
-                                    mode='lines')
-                         for y, fd in yarns_to_float_data.items()]
-    return yarn_float_traces
-
-
-def collect_yarn_loop_traces(data_graph, knit_graph):
-    """
-    :param data_graph: Collection of loop nodes to assign locations.
-    :param knit_graph: The knit graph to derive loop data from.
-    :return: The traces of the yarns-float edges for the graph
-    """
-    yarns_to_loop_data = {y: {'x': [data_graph.nodes[l]['x'] for l in y],
-                              'y': [data_graph.nodes[l]['y'] for l in y],
-                              'loop_id': [l.loop_id for l in y]
-                              }
-                          for y in knit_graph.yarns
-                          }
-    yarn_loop_traces = [go.Scatter(name=f"Loops on {y.yarn_id}", x=yd['x'], y=yd['y'], text=yd['loop_id'],
-                                   textposition='middle center',
-                                   mode='markers+text',
-                                   marker=dict(
-                                       reversescale=True,
-                                       color=y.properties.color,
-                                       size=30,
-                                       line_width=2, ))
-                        for y, yd in yarns_to_loop_data.items()
-                        ]
-    return yarn_loop_traces

knit_graphs-0.0.6.dist-info/RECORD

@@ -1,22 +0,0 @@
-knit_graphs/Course.py,sha256=gEIl9EXXCx3NfEQclhK_7WGVOK_rxF5hB0jqGeAyH_w,3437
-knit_graphs/Knit_Graph.py,sha256=arRNaxUaV3uwgNJ_UKxS7zViHl46y5QErPM_vTA_q8Y,7753
-knit_graphs/Loop.py,sha256=S2YGS8f_CtbFzy-OJsY6_JzGaHiiVMXrROO6P-wByTo,5236
-knit_graphs/Pull_Direction.py,sha256=G2JLbUT8x-ZfLNX3yjslv61FaoZiODUOPyYeDqj3pqQ,596
-knit_graphs/Yarn.py,sha256=9FOEBnWbtI8VJ-b1-NL0e8bsXuT0Jg0HG90jWEflUxw,9230
-knit_graphs/__about__.py,sha256=f6QbNB-h7iIziTm9pqa987kBoY_CelBN7KwRBZHwZck,137
-knit_graphs/__init__.py,sha256=bPQ_U3Sf5VvF36ywW6v79_J51b7DdZPvXuaHAtlbmg4,114
-knit_graphs/artin_wale_braids/Crossing_Direction.py,sha256=YVYfv11V-mB9WmQzNuOjbEQQI-b07gl9KF31vwujb1g,430
-knit_graphs/artin_wale_braids/Loop_Braid_Graph.py,sha256=z9_VyQA5U9y-XjyaZ67kSmOr0Bg_N1932ghV3YzNrP0,2742
-knit_graphs/artin_wale_braids/Wale.py,sha256=ldXVbb8cAe5QSoZNRxmdyrncnMYp6S0NnRpdJU6QQM4,3597
-knit_graphs/artin_wale_braids/Wale_Braid.py,sha256=9xCE0i0FoHN9J4CA_PZOoVIeLDHhIY3vC7LyK8OVkfk,1348
-knit_graphs/artin_wale_braids/Wale_Braid_Word.py,sha256=K17E-oRRsKYDrSWqwP1WMqR2MnK8nTNoSqaD73gtX6Y,1844
-knit_graphs/artin_wale_braids/Wale_Group.py,sha256=e5YTNiHditg4sSq-1lMAdmeIwIEHX4JKEiEx5X4nwZg,3718
-knit_graphs/artin_wale_braids/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-knit_graphs/knit_graph_generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-knit_graphs/knit_graph_generators/basic_knit_graph_generators.py,sha256=eRmoqIhjymKERJhjnwuQll3psAf9HHwnHWDkTcZX6Uk,11330
-knit_graphs/knit_graph_visualizer/Stitch_Visualizer.py,sha256=l90bdaucCDzSmua7iILoNmpVQuQsuMKHq5r0DkakoL0,21411
-knit_graphs/knit_graph_visualizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-knit_graphs-0.0.6.dist-info/METADATA,sha256=Mn0jZgvr2WWltpSizNu3mJS-7SPTehGQ6vlXM3I9UNY,5039
-knit_graphs-0.0.6.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
-knit_graphs-0.0.6.dist-info/licenses/LICENSE,sha256=M4U6L5axKj_93OoQXCm4RUIsUwHqEVzf7hsOVmyFPp0,1091
-knit_graphs-0.0.6.dist-info/RECORD,,