chartflow 0.1.4__tar.gz → 0.1.5__tar.gz

{chartflow-0.1.4 → chartflow-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartflow
-Version: 0.1.4
+Version: 0.1.5
 Summary: Self-use. with fsm. node. chart. edit. Used for fsm and run, structure graph. use pyqt to show and interact
 Author-email: 2229066748@qq.com
 Maintainer: Eagle'sBaby

{chartflow-0.1.4 → chartflow-0.1.5}/chartflow/flow/chart.py

@@ -958,7 +958,8 @@ class Chart(IChart):
         shape_map = {
             "ellipse": NodeShape.ELLIPSE,
             "rectangle": NodeShape.RECTANGLE,
-            "diamond": NodeShape.DIAMOND
+            "diamond": NodeShape.DIAMOND,
+            "hexagon": NodeShape.HEXAGON
         }
 
         # Create node mapping

{chartflow-0.1.4 → chartflow-0.1.5}/chartflow/node/_node_base.py

@@ -398,7 +398,10 @@ class _NodeCore(QGraphicsEllipseItem):
 
         - 名称需容纳在内部区域(INNER_RATIO 以内); 有 hit 时额外预留
           (dot 深度 + 间距 + hit 文本宽度), 避免 hit 与名称重叠。
-        - 矩形且有端口时: 宽度由名称(+hit)决定, 高度由最多端口的一侧决定(可长宽不等)。
+        - 矩形且有端口时: 宽度由名称(+hit)决定, 高度由最多端口的一侧决定
+          (可长宽不等, 但宽不短于高——顶/底边不短于左右边)。
+        - 六边形: 平顶/平底边长(=rw)须不短于斜边长 hypot(rw/2, rh),
+          即 rw >= rh * 2/√3, 按此加宽(名称短时正方形不满足该约束)。
         - 其余(椭圆/菱形/无端口矩形): 保持方形。
         """
         tw, th = self._nameTextSize()
@@ -411,6 +414,8 @@ class _NodeCore(QGraphicsEllipseItem):
             port_extent = self._portInwardExtent()
             rw = max(rw_name, name_half + port_extent + NAME_INNER_PAD, self._min_radius)
             rh = max(rh_name, self._halfHeightForPorts(rw), self._min_radius)
+            # 矩形: 顶/底边(宽)不短于左右边(高); 名称短/端口多导致超高时加宽
+            rw = max(rw, rh)
             return rw, rh
 
         # 方形
@@ -421,6 +426,10 @@ class _NodeCore(QGraphicsEllipseItem):
                 R = max(R, self._circlePortRadius())
             else:
                 R = max(R, self._halfHeightForPorts(R))
+        if self._shape == NodeShape.HEXAGON:
+            # 六边形: 顶/底边 >= 斜边 -> rw >= rh * 2/√3; 加宽而非压扁,
+            # 以保留端口/名称的纵向空间
+            return R * 2.0 / math.sqrt(3.0), R
         return R, R
 
     def _setSize(self, rw: float, rh: float) -> None:
@@ -429,6 +438,12 @@ class _NodeCore(QGraphicsEllipseItem):
             # 圆形节点固定为标准圆(宽高相等), 保证端口沿弧线布局正确
             side = max(rw, rh)
             rw = rh = side
+        elif self._shape == NodeShape.HEXAGON:
+            # 六边形: 顶/底边 >= 斜边 -> rw >= rh * 2/√3(兜底, 含自定义半径路径)
+            rw = max(rw, rh * 2.0 / math.sqrt(3.0))
+        elif self._shape == NodeShape.RECTANGLE:
+            # 矩形: 顶/底边(宽)不短于左右边(高)(兜底)
+            rw = max(rw, rh)
         self._rw = rw
         self._rh = rh
         self._radius = rw  # 兼容椭圆/菱形及旧代码
@@ -475,6 +490,7 @@ class _NodeCore(QGraphicsEllipseItem):
           - ELLIPSE: 圆(半径 + 外环)
           - RECTANGLE: 圆角矩形(外扩外环)
           - DIAMOND: 菱形(四顶点外扩外环)
+          - HEXAGON: 六边形(六顶点外扩外环)
         """
         rect = self.rect()
         m = self._hitShapeMargin()
@@ -488,7 +504,7 @@ class _NodeCore(QGraphicsEllipseItem):
             # 圆角半径与 paint() 一致(基于原始 rect, 否则圆角位置错位)
             corner = min(rect.width(), rect.height()) * 0.2
             path.addRoundedRect(outer, corner, corner)
-        else:  # DIAMOND
+        elif self._shape == NodeShape.DIAMOND:
             c = rect.center()
             hw = rect.width() / 2.0 + m
             hh = rect.height() / 2.0 + m
@@ -497,6 +513,17 @@ class _NodeCore(QGraphicsEllipseItem):
             path.lineTo(c.x(), c.y() + hh)
             path.lineTo(c.x() - hw, c.y())
             path.closeSubpath()
+        else:  # HEXAGON
+            c = rect.center()
+            hw = rect.width() / 2.0 + m
+            hh = rect.height() / 2.0 + m
+            path.moveTo(c.x() - hw / 2.0, c.y() - hh)
+            path.lineTo(c.x() + hw / 2.0, c.y() - hh)
+            path.lineTo(c.x() + hw, c.y())
+            path.lineTo(c.x() + hw / 2.0, c.y() + hh)
+            path.lineTo(c.x() - hw / 2.0, c.y() + hh)
+            path.lineTo(c.x() - hw, c.y())
+            path.closeSubpath()
         return path
 
     def _centerText(self) -> None:

{chartflow-0.1.4 → chartflow-0.1.5}/chartflow/node/_node_interface.py

@@ -78,6 +78,7 @@ class INodeItem(Protocol):
         - ``ELLIPSE`` 椭圆/圆形(强制为宽高相等的标准圆)
         - ``RECTANGLE`` 圆角矩形
         - ``DIAMOND`` 菱形
+        - ``HEXAGON`` 六边形(平顶/平底, 左右尖角)
 
         赋值后若未设置自定义半径, 会按新形状重算尺寸; 切换到圆形时
         端口会从轴向排布切换为沿侧弧径向排布。
@@ -396,7 +397,8 @@ class INodeItem(Protocol):
         """计算从节点中心指向 ``target_pos`` 方向、落在节点外轮廓上的交点。
 
         依据当前 :attr:`nodeShape` 采用不同算法: 圆形用三角函数、
-        圆角矩形先求外接矩形交点再修正圆角、菱形用 L1 范数缩放。
+        圆角矩形先求外接矩形交点再修正圆角、菱形用 L1 范数缩放、
+        六边形取平顶边与斜边两组约束的较小射线交点。
 
         Args:
             target_pos: 目标位置(场景坐标)。

{chartflow-0.1.4 → chartflow-0.1.5}/chartflow/node/_node_ports.py

@@ -213,21 +213,22 @@ class _NodePortMixin:
     # 端口布局
     # ------------------------------------------------------------------ #
     def _layoutPorts(self) -> None:
-        """分布端口: 圆形沿侧弧径向; 菱形沿左/右斜边贴合排布; 矩形沿边缘轴向。"""
+        """分布端口: 圆形沿侧弧径向; 菱形/六边形沿左/右斜边贴合排布; 矩形沿边缘轴向。"""
         is_circle = self._shape == NodeShape.ELLIPSE
-        is_diamond = self._shape == NodeShape.DIAMOND
+        # 菱形与六边形(左右均为两条斜边)共用斜边贴合布局
+        is_slant = self._shape in (NodeShape.DIAMOND, NodeShape.HEXAGON)
         for side in ("left", "right"):
             for it in self._port_items[side]:
-                # 互斥的排布模式: _radial(圆形) / _diamond(菱形) / 皆 False(矩形)
+                # 互斥的排布模式: _radial(圆形) / _diamond(斜边) / 皆 False(矩形)
                 if it._radial != is_circle:
                     it._radial = is_circle
                     it.update()
-                if it._diamond != is_diamond:
-                    it._diamond = is_diamond
+                if it._diamond != is_slant:
+                    it._diamond = is_slant
                     it.update()
         if is_circle:
             self._layoutPortsOnCircle()
-        elif is_diamond:
+        elif is_slant:
             self._layoutPortsOnDiamond()
         else:
             self._layoutPortsAxisAligned()
@@ -277,16 +278,29 @@ class _NodePortMixin:
                 it.setPos(QPointF(x, y))
                 it.update()
 
+    def _slantInsetX(self) -> float:
+        """斜边上端点(顶/底侧)相对中心 x 的内缩量。
+
+        菱形: 0(斜边直达中线上的顶/底尖角);
+        六边形: half_w / 2(斜边从侧尖角连到平顶/平底边的端点)。
+        """
+        if self._shape == NodeShape.HEXAGON:
+            return self.rect().width() / 4.0
+        return 0.0
+
     def _layoutPortsOnDiamond(self) -> None:
-        """菱形: 端口沿左/右两条斜边贴合排布, dot 旋转使底边贴合斜边、
+        """菱形/六边形: 端口沿左/右两条斜边贴合排布, dot 旋转使底边贴合斜边、
         apex 沿斜边内法线(指向节点内部), 出射方向沿斜边外法线。
 
         每侧(right/left)对应两条斜边(上、下), 总弧长 2L(L=单条斜边长)。
         端口沿弧长以 PORT_MIN_GAP 紧凑排布, 整组围绕侧顶点(右顶点/左顶点,
         即赤道)居中。**所有四个顶点(top/side/bottom 及对侧顶点)附近都预留
-        顶点间隙**, 故端口自然落在斜边中段, 不压在任何菱角上。
+        顶点间隙**, 故端口自然落在斜边中段, 不压在任何尖角上。
+
+        斜边端点由 _slantInsetX() 参数化: 菱形斜边连到中线的顶/底尖角,
+        六边形斜边连到平顶/平底边的端点(x=±hw/2), 布局算法完全一致。
 
-        注意: 菱形斜边的内法线是**该斜边的常量法线**(垂直于斜边), 而非"指向
+        注意: 斜边的内法线是**该斜边的常量法线**(垂直于斜边), 而非"指向
         圆心"的方向 —— 二者仅在斜边中点重合。dot 底边须平行于斜边, 故
         _orient_angle 必须取斜边内法线方向(使旋转后底边贴合斜边)。
         """
@@ -296,20 +310,22 @@ class _NodePortMixin:
         hh = rect.height() / 2.0
         if hw <= 0 or hh <= 0:
             return
-        L = math.hypot(hw, hh)  # 单条斜边长
-        # 斜边内法线(指向节点内部, 垂直于斜边)。菱形四条斜边, 内法线方向固定。
-        #   右上(TR: top->right) 斜边方向 (hw, hh), 内法线 (-hh, hw)
-        #   右下(RB: right->bottom) 方向 (-hw, hh), 内法线 (-hh, -hw)
-        #   左下(BL: bottom->left) 方向 (-hw, -hh), 内法线 (hh, -hw)
-        #   左上(LT: left->top) 方向 (hw, -hh), 内法线 (hh, hw)
+        kx = self._slantInsetX()
+        sw = hw - kx  # 斜边的水平跨度(菱形=hw, 六边形=hw/2)
+        L = math.hypot(sw, hh)  # 单条斜边长
+        # 斜边内法线(指向节点内部, 垂直于斜边)。四条斜边, 内法线方向固定。
+        #   右上(TR: top->right) 斜边方向 (sw, hh), 内法线 (-hh, sw)
+        #   右下(RB: right->bottom) 方向 (-sw, hh), 内法线 (-hh, -sw)
+        #   左下(BL: bottom->left) 方向 (-sw, -hh), 内法线 (hh, -sw)
+        #   左上(LT: left->top) 方向 (sw, -hh), 内法线 (hh, sw)
         def inward_normal(ix, iy):
             nl = math.hypot(ix, iy)
             return (ix / nl, iy / nl) if nl > 1e-6 else (0.0, 0.0)
 
-        NORM_TR = inward_normal(-hh, hw)   # 右上斜边内法线
-        NORM_RB = inward_normal(-hh, -hw)  # 右下斜边内法线
-        NORM_BL = inward_normal(hh, -hw)   # 左下斜边内法线
-        NORM_LT = inward_normal(hh, hw)    # 左上斜边内法线
+        NORM_TR = inward_normal(-hh, sw)   # 右上斜边内法线
+        NORM_RB = inward_normal(-hh, -sw)  # 右下斜边内法线
+        NORM_BL = inward_normal(hh, -sw)   # 左下斜边内法线
+        NORM_LT = inward_normal(hh, sw)    # 左上斜边内法线
 
         # 四个顶点处的弧长预留(像素, 沿弧长方向): 避免端口压在任何菱角上。
         # top/bottom 顶点处一条斜边交汇, side 顶点处两条斜边交汇, 均需避让。
@@ -366,30 +382,31 @@ class _NodePortMixin:
                 s_values.append(L + vertex_gap + off_c)        # 下半中段内
             for it, s in zip(items, s_values):
                 # s ∈ [0, 2L]; 上半斜边 s∈[0,L](top→侧顶点), 下半 s∈[L,2L](侧顶点→bottom)
+                # 斜边端点: 侧尖角(±hw,0) <-> 顶/底端点(±kx,∓hh); kx=0 即菱形
                 if side == "right":
                     if s <= L:
-                        # 上半(TR): top(0,-hh) -> right(+hw,0), t=s/L
+                        # 上半(TR): (kx,-hh) -> right(+hw,0), t=s/L
                         t = max(0.0, min(1.0, s / L))
-                        px = cx + hw * t
+                        px = cx + kx + sw * t
                         py = cy + (-hh) + hh * t
                         nx, ny = NORM_TR
                     else:
-                        # 下半(RB): right(+hw,0) -> bottom(0,+hh), t=(s-L)/L
+                        # 下半(RB): right(+hw,0) -> (kx,+hh), t=(s-L)/L
                         t = max(0.0, min(1.0, (s - L) / L))
-                        px = cx + hw + (-hw) * t
+                        px = cx + hw - sw * t
                         py = cy + hh * t
                         nx, ny = NORM_RB
                 else:  # left
                     if s <= L:
-                        # 上半(LT): top(0,-hh) -> left(-hw,0), t=s/L
+                        # 上半(LT): (-kx,-hh) -> left(-hw,0), t=s/L
                         t = max(0.0, min(1.0, s / L))
-                        px = cx + (-hw) * t
+                        px = cx - kx - sw * t
                         py = cy + (-hh) + hh * t
                         nx, ny = NORM_LT
                     else:
-                        # 下半(BL): left(-hw,0) -> bottom(0,+hh), t=(s-L)/L
+                        # 下半(BL): left(-hw,0) -> (-kx,+hh), t=(s-L)/L
                         t = max(0.0, min(1.0, (s - L) / L))
-                        px = cx + (-hw) + hw * t
+                        px = cx - hw + sw * t
                         py = cy + hh * t
                         nx, ny = NORM_BL
                 it._orient_angle = math.degrees(math.atan2(ny, nx))
@@ -397,15 +414,15 @@ class _NodePortMixin:
                 it.update()
 
     def _diamondSideBias(self) -> float:
-        """菱形每条斜边上端口组的"逻辑中点"参数(0=远端顶点, 1=侧顶点)。
+        """菱形/六边形每条斜边上端口组的"逻辑中点"参数(0=远端顶点, 1=侧顶点)。
 
         取 0.7: 端口组偏向侧顶点(左右两角), 体现"左右两侧"的视觉聚类,
-        同时仍处于斜边中段(避开顶点预留区), 不会压在任何菱角上。
+        同时仍处于斜边中段(避开顶点预留区), 不会压在任何尖角上。
         """
         return 0.7
 
     def _diamondVertexGap(self) -> float:
-        """菱形每个顶点处沿弧长预留的间隙(像素)。
+        """菱形/六边形每个顶点处沿弧长预留的间隙(像素)。
 
         四个顶点(top/底/左/右)处斜边交汇, 法线方向不连续, 端口压在顶点上
         视觉突兀。预留固定像素间隙使端口落在斜边中段。取 10px: 对常见尺寸
@@ -422,6 +439,8 @@ class _NodePortMixin:
             return corner + 4.0
         if self._shape == NodeShape.DIAMOND:
             return half_h * 0.30
+        if self._shape == NodeShape.HEXAGON:
+            return half_h * 0.25
         # ELLIPSE
         return half_h * 0.22