╱─────────╲
       ╱           ╲
      ╱             ╲
     │               │
     │      ●        │
     │               │
      ╲             ╱
       ╲           ╱
        ╲─────────╱

import numpy as np

# 立方体的 8 个顶点
vertices = np.array([
    [-1, -1, -1],  # 0: 左下后
    [ 1, -1, -1],  # 1: 右下后
    [ 1, -1,  1],  # 2: 右下前
    [-1, -1,  1],  # 3: 左下前
    [-1,  1, -1],  # 4: 左上后
    [ 1,  1, -1],  # 5: 右上后
    [ 1,  1,  1],  # 6: 右上前
    [-1,  1,  1],  # 7: 左上前
])

# 立方体的 12 条边
edges = [
    (0, 1), (1, 2), (2, 3), (3, 0),  # 底面
    (4, 5), (5, 6), (6, 7), (7, 4),  # 顶面
    (0, 4), (1, 5), (2, 6), (3, 7),  # 竖直边
]

x' = x·cos(θ) - y·sin(θ)
y' = x·sin(θ) + y·cos(θ)
z' = z

def rotation_matrix(angle_x, angle_y, angle_z):
    """
    生成绕 X、Y、Z 轴旋转的组合旋转矩阵
    
    旋转顺序：Z → Y → X（先绕 Z 转，再绕 Y 转，最后绕 X 转）
    注意：矩阵乘法从右向左应用，所以写法是 Rx · Ry · Rz
    """
    # 预计算 sin 和 cos
    cx, sx = np.cos(angle_x), np.sin(angle_x)
    cy, sy = np.cos(angle_y), np.sin(angle_y)
    cz, sz = np.cos(angle_z), np.sin(angle_z)
    
    # 绕各轴旋转矩阵
    Rx = np.array([[1, 0, 0], [0, cx, -sx], [0, sx, cx]])
    Ry = np.array([[cy, 0, sy], [0, 1, 0], [-sy, 0, cy]])
    Rz = np.array([[cz, -sz, 0], [sz, cz, 0], [0, 0, 1]])
    
    # 组合旋转：R = Rx · Ry · Rz
    return Rx @ Ry @ Rz

def project(point, distance=5, z_offset=3):
    """
    将 3D 点投影到 2D 平面
    
    参数:
        point: 3D 坐标 [x, y, z]
        distance: 焦距，越大越接近正交投影
        z_offset: Z 轴偏移，将物体推向远处
    """
    x, y, z = point
    
    # 防止除零
    denominator = max(z + z_offset, 0.001)
    
    # 透视投影公式
    x_2d = x * distance / denominator
    y_2d = y * distance / denominator
    
    return (x_2d, y_2d)

def draw_line(canvas, x0, y0, x1, y1, char='●'):
    """
    Bresenham 直线算法
    
    原理：在离散网格上，选择最接近理想直线的像素点
    """
    dx = abs(x1 - x0)
    dy = abs(y1 - y0)
    sx = 1 if x0 < x1 else -1
    sy = 1 if y0 < y1 else -1
    err = dx - dy
    
    while True:
        set_pixel(canvas, x0, y0, char)
        if x0 == x1 and y0 == y1:
            break
        e2 = 2 * err
        if e2 > -dy:
            err -= dy
            x0 += sx
        if e2 < dx:
            err += dx
            y0 += sy

def get_char_by_depth(z, z_min=-2, z_max=2):
    """根据深度选择字符"""
    normalized = (z - z_min) / (z_max - z_min)
    normalized = max(0, min(1, normalized))
    
    chars = ['·', '░', '▒', '▓', '█', '●']
    index = int(normalized * (len(chars) - 1))
    return chars[index]

#!/usr/bin/env python3
"""
ASCII 艺术 3D 旋转立方体
完整实现，可直接运行
"""

import numpy as np
import time
import os

class ASCIICube:
    """ASCII 艺术 3D 旋转立方体"""
    
    def __init__(self, width=70, height=35):
        self.width = width
        self.height = height
        
        # 立方体顶点（边长 2，中心在原点）
        self.vertices = np.array([
            [-1, -1, -1], [1, -1, -1], [1, -1, 1], [-1, -1, 1],
            [-1, 1, -1], [1, 1, -1], [1, 1, 1], [-1, 1, 1],
        ], dtype=float)
        
        # 12 条边
        self.edges = [
            (0,1), (1,2), (2,3), (3,0),  # 底面
            (4,5), (5,6), (6,7), (7,4),  # 顶面
            (0,4), (1,5), (2,6), (3,7),  # 竖直
        ]
        
        # 旋转角度
        self.ax = self.ay = self.az = 0
        self.speed = (0.02, 0.04, 0.01)
        
        # 投影参数
        self.distance = 4
        self.z_offset = 3
        self.scale = 10
    
    def rotation_matrix(self, ax, ay, az):
        """生成组合旋转矩阵"""
        cx, sx = np.cos(ax), np.sin(ax)
        cy, sy = np.cos(ay), np.sin(ay)
        cz, sz = np.cos(az), np.sin(az)
        
        Rx = np.array([[1, 0, 0], [0, cx, -sx], [0, sx, cx]])
        Ry = np.array([[cy, 0, sy], [0, 1, 0], [-sy, 0, cy]])
        Rz = np.array([[cz, -sz, 0], [sz, cz, 0], [0, 0, 1]])
        
        return Rx @ Ry @ Rz
    
    def project(self, point):
        """3D 点透视投影到 2D"""
        x, y, z = point
        denom = max(z + self.z_offset, 0.001)
        return (x * self.distance / denom, 
                y * self.distance / denom, 
                z)
    
    def to_screen(self, x, y):
        """投影坐标转屏幕坐标"""
        sx = int(self.width / 2 + x * self.scale)
        sy = int(self.height / 2 - y * self.scale)
        return (sx, sy)
    
    def get_char(self, z):
        """根据深度选择字符"""
        z_norm = (z + 2) / 4
        z_norm = max(0, min(1, z_norm))
        chars = ['·', '░', '▒', '▓', '█', '●']
        return chars[int(z_norm * 5)]
    
    def draw_line(self, canvas, x0, y0, x1, y1, char):
        """Bresenham 直线算法"""
        dx, dy = abs(x1-x0), abs(y1-y0)
        sx = 1 if x0 < x1 else -1
        sy = 1 if y0 < y1 else -1
        err = dx - dy
        
        while True:
            if 0 <= x0 < self.width and 0 <= y0 < self.height:
                canvas[y0][x0] = char
            if x0 == x1 and y0 == y1:
                break
            e2 = 2 * err
            if e2 > -dy:
                err -= dy
                x0 += sx
            if e2 < dx:
                err += dx
                y0 += sy
    
    def render(self):
        """渲染当前帧"""
        # 旋转
        R = self.rotation_matrix(self.ax, self.ay, self.az)
        rotated = [R @ v for v in self.vertices]
        
        # 投影
        projected = [self.project(v) for v in rotated]
        
        # 画布
        canvas = [[' '] * self.width for _ in range(self.height)]
        
        # 按深度排序边（远的先画）
        edge_depths = [(projected[i][2] + projected[j][2]) / 2 
                       for i, j in self.edges]
        sorted_edges = sorted(zip(edge_depths, self.edges))
        
        # 绘制边
        for z, (i, j) in sorted_edges:
            p1, p2 = projected[i], projected[j]
            x1, y1 = self.to_screen(p1[0], p1[1])
            x2, y2 = self.to_screen(p2[0], p2[1])
            char = self.get_char(z)
            self.draw_line(canvas, x1, y1, x2, y2, char)
        
        # 绘制顶点
        for p in projected:
            x, y = self.to_screen(p[0], p[1])
            if 0 <= x < self.width and 0 <= y < self.height:
                canvas[y][x] = '●'
        
        return '\n'.join(''.join(row) for row in canvas)
    
    def update(self):
        """更新旋转角度"""
        self.ax += self.speed[0]
        self.ay += self.speed[1]
        self.az += self.speed[2]
    
    def run(self, fps=30):
        """运行动画"""
        try:
            while True:
                os.system('cls' if os.name == 'nt' else 'clear')
                print(self.render())
                print("\n[按 Ctrl+C 退出]")
                self.update()
                time.sleep(1.0 / fps)
        except KeyboardInterrupt:
            print("\n再见！👋")

if __name__ == '__main__':
    cube = ASCIICube(width=70, height=30)
    cube.run(fps=30)