polyfix 0.1.0__tar.gz

polyfix-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.3
+Name: polyfix
+Version: 0.1.0
+Summary: Module for creating EnergyPlus ready floor plans from geometry containing holes.
+Author: Juliet Nwagwu Ume-Ezeoke
+Author-email: Juliet Nwagwu Ume-Ezeoke <jnwagwu@stanford.edu>
+Requires-Dist: bpython>=0.25
+Requires-Dist: cyclopts>=4.4.3
+Requires-Dist: expression>=5.6.0
+Requires-Dist: geom>=0.3.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: matplotlib>=3.10.6
+Requires-Dist: networkx>=3.5
+Requires-Dist: numpy>=2.3.3
+Requires-Dist: pipe>=2.2
+Requires-Dist: pre-commit>=4.5.1
+Requires-Dist: ptpython>=3.0.31
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pyprojroot>=0.3.0
+Requires-Dist: pytest>=8.4.2
+Requires-Dist: pytest-cov>=7.0.0
+Requires-Dist: shapely>=2.1.2
+Requires-Dist: snakemake>=9.14.5
+Requires-Dist: tomli-w>=1.2.0
+Requires-Dist: types-networkx>=3.5.0.20251106
+Requires-Dist: utils4plans
+Requires-Dist: whenever>=0.9.3
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# polyfix
+
+### Geometry conventions
+
+- Polygonal domains can be specified using coordinate in either a clockwise or counterclockwise direction.
+- After the coordinates are normalized, they will have a clockwise direction, starting from the bottom left. This comes from Shapely's defaults for normalizing

polyfix-0.1.0/README.md

@@ -0,0 +1,6 @@
+# polyfix
+
+### Geometry conventions
+
+- Polygonal domains can be specified using coordinate in either a clockwise or counterclockwise direction.
+- After the coordinates are normalized, they will have a clockwise direction, starting from the bottom left. This comes from Shapely's defaults for normalizing

polyfix-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "polyfix"
+version = "0.1.0"
+description = "Module for creating EnergyPlus ready floor plans from geometry containing holes."
+readme = "README.md"
+authors = [
+  { name = "Juliet Nwagwu Ume-Ezeoke", email = "jnwagwu@stanford.edu" },
+]
+requires-python = ">=3.13"
+dependencies = [
+  "bpython>=0.25",
+  "cyclopts>=4.4.3",
+  "expression>=5.6.0",
+  "geom>=0.3.0",
+  "loguru>=0.7.3",
+  "matplotlib>=3.10.6",
+  "networkx>=3.5",
+  "numpy>=2.3.3",
+  "pipe>=2.2",
+  "pre-commit>=4.5.1",
+  "ptpython>=3.0.31",
+  "pydantic>=2.12.5",
+  "pyprojroot>=0.3.0",
+  "pytest>=8.4.2",
+  "pytest-cov>=7.0.0",
+  "shapely>=2.1.2",
+  "snakemake>=9.14.5",
+  "tomli-w>=1.2.0",
+  "types-networkx>=3.5.0.20251106",
+  "utils4plans",
+  "whenever>=0.9.3",
+]
+
+[project.scripts]
+polyfix = "polyfix.cli.main:main"
+
+[build-system]
+requires = ["uv_build>=0.8.3,<0.9.0"]
+build-backend = "uv_build"
+
+# [tool.uv.sources]
+# utils4plans = { path = "../utils4plans" }

polyfix-0.1.0/src/polyfix/__init__.py

@@ -0,0 +1 @@
+from rich.pretty import pretty_repr

polyfix-0.1.0/src/polyfix/bends/bends.py

@@ -0,0 +1,130 @@
+from loguru import logger
+from utils4plans.lists import chain_flatten
+from polyfix.geometry.modify.validate import InvalidPolygonError, validate_polygon
+from polyfix.bends.graph import (
+    create_surface_graph_for_domain,
+    find_small_node_groups,
+    get_nodes_data,
+    get_successor_node,
+    handle_components,
+    update_small_nbs,
+)
+from polyfix.geometry.ortho import FancyOrthoDomain
+from polyfix.bends.interfaces import (
+    BendHolder,
+    KappaOne,
+    KappaTwo,
+    PiOne,
+    PiThree,
+    PiTwo,
+)
+import networkx as nx
+
+from polyfix.geometry.surfaces import Surface
+
+
+def check_is_pi_two(G: nx.DiGraph, node: str):
+    data = get_nodes_data(G, node)
+    if data.is_small and data.is_nb2_small and not data.is_nb_small:
+        return True
+
+
+def identify_pi_twos(domain: FancyOrthoDomain, G_: nx.DiGraph):
+
+    def make(node: str):
+        n1 = get_successor_node(G, node)
+        n2 = get_successor_node(G, n1)
+
+        s1 = get_nodes_data(G, node).surface
+        s2 = get_nodes_data(G, n2).surface
+        assert s1 and s2
+        return PiTwo.from_surfaces(domain, G, s1, s2)
+
+    G = update_small_nbs(G_)
+
+    bends = [make(node) for node in G.nodes if check_is_pi_two(G, node)]
+
+    # only want those where are passing bend checks
+    passing_bends = [i for i in bends if i.are_vectors_correct]
+    return passing_bends
+
+
+def is_part_of_pi_twos(bends: list[PiTwo], surface: Surface):
+    pi2surfs = chain_flatten([[i.s1, i.s2] for i in bends])
+    if surface in pi2surfs:
+        return True
+
+
+def assign_bends(domain: FancyOrthoDomain, domain_name: int | str = ""):
+
+    bh = BendHolder()
+    try:
+        validate_polygon(domain.polygon, domain.name)
+    except InvalidPolygonError as e:
+        logger.error(
+            f"Could not validate polygon, and could not assign bends for domain<{domain_name}> ----- {e.message()}"
+        )
+        return bh
+
+    G = create_surface_graph_for_domain(domain)
+    bh.pi2s.extend(identify_pi_twos(domain, G))
+    # TODO find 2pi groups
+    components = find_small_node_groups(G)
+    logger.trace(f"components = {components}")
+
+    # TODO:pi2s
+
+    info = (domain, G)
+
+    # large_groups = []
+    # uncategorized = []H
+
+    for comp_ in components:
+        comp = list(comp_)  # TODO: can simplify this.
+        size = len(comp)
+        if size > 3:
+            bh.large.append(comp)
+        elif size == 3:
+            res = handle_components(G, comp)
+            # logger.debug(
+            #     f"after have handled components: {[i.name_w_domain for i in res]}"
+            # )
+            bend = PiThree.from_surfaces(*info, *res)
+            if bend.are_vectors_correct:
+                bh.pi3s.append(bend)
+            else:
+                bh.large.append(comp)
+            # todo: check if vectors are correct, if not goes to same treatment as large..
+            #
+        elif size == 2:
+            res = handle_components(G, comp)
+            res = KappaTwo.from_surfaces(*info, *res)
+            bh.kappa2s.append(res)
+        elif size == 1:
+            res = handle_components(G, comp)[0]
+            if is_part_of_pi_twos(bh.pi2s, res):
+                continue
+
+            bend = KappaOne.from_surfaces(*info, res)
+            if bend.are_vectors_correct:
+                bh.kappas.append(bend)
+                continue
+
+            bend = PiOne.from_surfaces(*info, res)
+            if bend.are_vectors_correct:
+                bh.pis.append(bend)
+                continue
+
+            bh.not_found.append(comp)
+
+        # bh larges and bad pi3s become kappa2s
+        for comp in bh.large:
+            res = handle_components(G, comp)
+            s1, s2, *_ = res
+            bend = KappaTwo.from_surfaces(*info, s1, s2)
+            bh.kappa2s.append(bend)
+
+    return bh
+
+
+# TODO: consider making the checks of the bend vectos external.. ?

polyfix-0.1.0/src/polyfix/bends/errors.py

@@ -0,0 +1,61 @@
+from polyfix.geometry.ortho import FancyOrthoDomain
+
+from polyfix.bends.interfaces import Bend, BendHolder
+from polyfix.geometry.surfaces import Surface
+from typing import Literal
+
+from loguru import logger
+
+FAIL_TYPES = Literal[
+    "Invalid Move",
+    "Problem Finding Bends",
+    "Failed to Clean Domain Correctly",
+    "Invalid Incoming Domain",
+    "Exceeded number of iterations",
+]
+
+
+class DomainCleanFailure(Exception):
+    def __init__(
+        self,
+        domain: FancyOrthoDomain,
+        fail_type: FAIL_TYPES,
+        details: str,
+        surfaces: list[Surface] = [],
+        bends: BendHolder | None = None,
+        current_bend: Bend | None = None,
+    ):
+        self.domain = domain
+        self.fail_type = fail_type
+        self.details = details
+        self.surfaces = surfaces
+        self.bends = bends
+        self.current_bend = current_bend
+
+    def __rich_repr__(self):
+        yield "domain", self.domain.name
+        yield "fail_type", self.fail_type
+        yield "details", self.details
+
+    def show_message(self, layout_id: str):
+        logger.warning(f"[red bold]{self.fail_type} for {layout_id}-{self.domain.name}")
+        logger.warning(f"{self.details}")
+
+        if self.bends:
+            logger.warning(self.bends.summary_str)
+
+        if self.current_bend:
+            logger.warning(f"Current bend is {str(self.current_bend)}")
+            logger.warning(self.current_bend.study_vectors())
+
+
+class DomainCleanIterationFailure(Exception):
+    def __init__(
+        self, domain_name: str, fail_type: FAIL_TYPES, current_bend: Bend | None = None
+    ):
+        self.domain = domain_name
+        self.fail_type = fail_type
+        self.current_bend = current_bend
+
+    def message(self):
+        logger.warning(f"[red bold]{self.fail_type} for {self.domain}")

polyfix-0.1.0/src/polyfix/bends/graph.py

@@ -0,0 +1,195 @@
+from copy import deepcopy
+from dataclasses import dataclass
+from utils4plans.lists import get_unique_one
+from utils4plans.sets import set_difference
+
+
+from loguru import logger
+from rich.pretty import pretty_repr
+from polyfix.geometry.surfaces import Surface
+from polyfix.geometry.ortho import FancyOrthoDomain
+from typing import Iterable, TypeVar
+import networkx as nx
+from utils4plans.lists import pairwise
+from polyfix.bends.utils import make_repr_obj
+
+T = TypeVar("T")
+
+
+@dataclass
+class DomainGraph:
+    graph: nx.DiGraph
+
+
+@dataclass
+class NodeData:
+    is_small: bool = False
+    surface: Surface | None = None
+    is_nb_small: bool = False
+    is_nb2_small: bool = False
+
+    @property
+    def repr_dict(self):
+        def fx():
+            yield "surface_name", self.surface.name_w_domain if self.surface else ""
+            yield "is_small", self.is_small
+            yield "is_nb_small", self.is_nb_small
+            yield "is_nb2_small", self.is_nb2_small
+
+        return make_repr_obj(fx)
+
+    # def __repr__(self):
+    #     def fx():
+    #         yield "is_small", self.is_small
+    #         yield "surface_name", self.surface.name if self.surface else ""
+    #
+    #     return make_repr_obj(fx, self)
+
+
+@dataclass(frozen=True)
+class SurfaceNode:
+    data: NodeData
+
+
+def get_nodes_data(G: nx.DiGraph, node: str):
+    data = G.nodes[node].get("data")
+    assert isinstance(data, NodeData)
+    d: NodeData = data
+    return d
+
+
+def get_predecesor(G: nx.DiGraph, node: object):
+    res = list(G.predecessors(node))[0]
+    return get_surface(G, res)
+
+
+def get_successor(G: nx.DiGraph, node: object):
+    res = list(G.successors(node))[0]
+    return get_surface(G, res)
+
+
+def get_successor_node(G: nx.DiGraph, node: object):
+    res = list(G.successors(node))
+    assert len(res) == 1, f"Expected one successor, but got {res}"
+    # should assert num of succesors = 1
+    return res[0]
+
+
+def create_cycle_graph(nodes_: Iterable[T]):
+    nodes = list(nodes_)
+    node_cycle = nodes + [nodes[0]]
+
+    # G: nx.DiGraph[SurfaceNode] = nx.DiGraph()
+    G = nx.DiGraph()
+    for i, j in pairwise(node_cycle):
+        G.add_edge(i, j)
+
+    return G
+
+
+def create_surface_graph_for_domain(domain: FancyOrthoDomain):
+
+    surf_names = [i.name_w_domain for i in domain.surfaces]
+    G = create_cycle_graph(surf_names)
+    node_data = {
+        name: {"data": NodeData(is_small=surf.is_small, surface=surf)}
+        for name, surf in zip(surf_names, domain.surfaces)
+    }
+    nx.set_node_attributes(G, node_data)
+    return G
+
+
+def update_small_nbs(G_: nx.DiGraph):
+    def check_nb_is_small(G: nx.DiGraph, nb: str):
+        data = get_nodes_data(G, nb)
+        return data.is_small
+
+    def update(G: nx.DiGraph, node: str):
+        data = get_nodes_data(G, node)
+        n1 = get_successor_node(G, node)
+        data.is_nb_small = check_nb_is_small(G, n1)
+
+        n2 = get_successor_node(G, n1)
+        data.is_nb2_small = check_nb_is_small(G, n2)
+
+    G = deepcopy(G_)
+    for node in G.nodes:
+        update(G, node)
+
+    return G
+
+
+def find_small_node_groups(G: nx.DiGraph):
+    nodes = [n for n, d in G.nodes(data=True) if d["data"].is_small]
+    sg = G.subgraph(nodes)
+    components = nx.connected_components(sg.to_undirected())
+
+    return list(components)
+
+
+def find_ends_of_a_directed_graph(G: nx.DiGraph):
+    root = get_unique_one(G.nodes, lambda x: len(list(G.predecessors(x))) == 0)
+    end = get_unique_one(G.nodes, lambda x: len(list(G.successors(x))) == 0)
+    return root, end
+
+
+def order_nodes_based_on_graph(G: nx.DiGraph, nodes_: Iterable[T]):
+    nodes = list(nodes_)
+    nodes_to_remove = set_difference(G.nodes, nodes)
+    sg = deepcopy(G)
+    sg.remove_nodes_from(nodes_to_remove)
+
+    logger.trace(sg.nodes)
+    if len(nodes) > 2:
+        root, end = find_ends_of_a_directed_graph(sg)
+        paths = list(nx.shortest_simple_paths(sg, root, end))
+        logger.trace(paths)
+        assert len(paths) == 1
+        return paths[0]
+
+    logger.trace(G.edge_subgraph(sg.edges).edges)
+    assert sg.order() == 2
+    assert len(sg.edges) == 1
+    e = list(sg.edges)[0]
+    return [e[0], e[1]]
+    # TODO: some stronger conditions on this.. this is assuming that everuthing is connected..
+    return list(sg.edges)
+
+
+def find_small_node_surfaces(G: nx.DiGraph, nodes: Iterable[str]) -> list[Surface]:
+    def find(node: str):
+        res = G.nodes[node].get("data")
+        assert isinstance(res, NodeData)
+        s = res.surface
+        assert s
+        return s
+
+    return [find(n) for n in nodes]
+
+
+def handle_components(G: nx.DiGraph, nodes_: Iterable[str]):
+    nodes = list(nodes_)
+    if len(nodes) >= 2:
+        ordered_nodes = order_nodes_based_on_graph(G, nodes)
+        logger.trace(pretty_repr({"orig_nodes": nodes, "ordered": ordered_nodes}))
+    else:
+        ordered_nodes = nodes
+    return find_small_node_surfaces(G, ordered_nodes)
+
+
+def get_surface(G: nx.Graph, node: str):
+    data = G.nodes[node].get("data")
+    assert isinstance(data, NodeData)
+    s = data.surface
+    assert s
+    return s
+
+
+def repr_graph(G: nx.DiGraph):
+    fd = {}
+    for node, d in G.nodes(data=True):
+        # TODO: can clean up with get method..
+        data = d["data"]
+        assert isinstance(data, NodeData)
+        fd[node] = data.repr_dict
+    return pretty_repr(fd, expand_all=True)