From 4d2ef1a667a7dcafd0148a1f46bb65db8bad36d9 Mon Sep 17 00:00:00 2001 From: Your Name Date: Sat, 13 Dec 2025 00:33:58 +0000 Subject: [PATCH] gpt answer with sloped lines --- draw_12_rects_and_send.py | 185 ++++++++++++++++++++++++++++++++-------------- 1 file changed, 130 insertions(+), 55 deletions(-) diff --git a/draw_12_rects_and_send.py b/draw_12_rects_and_send.py index 330d872..f8e324e 100644 --- a/draw_12_rects_and_send.py +++ b/draw_12_rects_and_send.py @@ -1,108 +1,182 @@ #!/usr/bin/env python3 """ -draw_12_rects_thick_outline.py +draw_12_slanted_top_bottom.py -800 × 600 ARGB framebuffer. -12 tall rectangles (aspect 1 : 12) placed side‑by‑side with a gap. -Only the rectangle outline is drawn, the border thickness can be changed -with the constant LINE_THICKNESS (default = 3 pixels). - -The complete framebuffer is streamed to a TCP server listening on -localhost:12345 (payload is prefixed with a 4‑byte big‑endian length). +* 800 × 600 ARGB framebuffer (A,R,G,B each 1 byte) +* 12 rectangles, aspect 1 : 12, 5 px gap, 100 px empty margin at top & bottom +* each rectangle has an individual tilt angle (degrees) stored in + ROT_ANGLES_DEG[12] +* the top and bottom edges are *slanted* while the left‑ and right‑hand + edges remain perfectly vertical +* outline colour = opaque white, thickness = LINE_THICKNESS (default = 3 px) +* the raw buffer (with a 4‑byte length prefix) is streamed to a TCP server + listening on localhost:12345 """ +import math import socket import sys # ---------------------------------------------------------------------- -# Frame‑buffer configuration +# 1️⃣ Frame‑buffer configuration # ---------------------------------------------------------------------- FB_WIDTH = 800 # horizontal pixels FB_HEIGHT = 600 # vertical pixels BPP = 4 # bytes per pixel (A,R,G,B) # ---------------------------------------------------------------------- -# Geometry of the 12 rectangles +# 2️⃣ Margins & rectangle geometry (before slant) # ---------------------------------------------------------------------- -RECT_HEIGHT = 400 # fill the whole image vertically -RECT_WIDTH = RECT_HEIGHT // 12 # 600 / 12 = 50 px (maintains 1:12) +MARGIN_TOP = 100 # empty band at the very top +MARGIN_BOTTOM = 300 # empty band at the very bottom -SPACING = 10 # pixels between two neighbours +RECT_HEIGHT = FB_HEIGHT - MARGIN_TOP - MARGIN_BOTTOM # usable height = 400 px +RECT_WIDTH = RECT_HEIGHT // 12 # ≈ 33 px (aspect 1 : 12) + +SPACING = 10 # gap between rectangles TOTAL_RECT_W = 12 * RECT_WIDTH + 11 * SPACING -X0_START = (FB_WIDTH - TOTAL_RECT_W) // 2 # centre the whole strip +X0_START = (FB_WIDTH - TOTAL_RECT_W) // 2 # centre the whole strip # ---------------------------------------------------------------------- -# Outline thickness (change this to whatever you need) +# 3️⃣ Outline thickness (you may change it) # ---------------------------------------------------------------------- -LINE_THICKNESS = 4 # >=1 ; thicker than 1 pixel +LINE_THICKNESS = 5 # ≥ 1 pixel # ---------------------------------------------------------------------- -# Helper – write a pixel into the bytearray (no bounds check for speed) +# 4️⃣ Per‑rectangle tilt angles (degrees) +# ---------------------------------------------------------------------- +# You can generate these programmatically, read them from a file, etc. +ROT_ANGLES_DEG = [ + 90, 5, 10, 15, 20, 25, + 30, 35, 40, 45, 50, 85 +] +assert len(ROT_ANGLES_DEG) == 12, "Exactly 12 angles are required." + +# ---------------------------------------------------------------------- +# Helper – write a single pixel (bounds‑checked) # ---------------------------------------------------------------------- def set_pixel(buf: bytearray, x: int, y: int, color: tuple) -> None: """Write an ARGB pixel at (x, y). `color` = (A,R,G,B).""" - offset = (y * FB_WIDTH + x) * BPP - buf[offset:offset + 4] = bytes(color) # A,R,G,B order + if 0 <= x < FB_WIDTH and 0 <= y < FB_HEIGHT: + off = (y * FB_WIDTH + x) * BPP + buf[off:off + 4] = bytes(color) # A,R,G,B order # ---------------------------------------------------------------------- -# Fill a rectangular region (used for thick edges) +# Helper – draw a thick line (Bresenham + square brush) # ---------------------------------------------------------------------- -def fill_rect(buf: bytearray, x0: int, y0: int, w: int, h: int, color: tuple) -> None: - """Write a solid w × h block of `color` starting at (x0, y0).""" - # Clip to the frame buffer – safety net for very thick lines at the border - x0 = max(0, x0) - y0 = max(0, y0) - w = min(w, FB_WIDTH - x0) - h = min(h, FB_HEIGHT - y0) +def draw_thick_line(buf: bytearray, + x0: int, y0: int, + x1: int, y1: int, + color: tuple, + thickness: int) -> None: + """Draw a line from (x0,y0) to (x1,y1) using a square brush of `thickness`.""" + 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 # error term - row_bytes = w * BPP - pixel_bytes = bytes(color) + while True: + # paint a filled square centred on the current pixel + for ty in range(-thickness // 2, thickness // 2 + 1): + for tx in range(-thickness // 2, thickness // 2 + 1): + set_pixel(buf, x0 + tx, y0 + ty, color) - for y in range(y0, y0 + h): - off = (y * FB_WIDTH + x0) * BPP - buf[off:off + row_bytes] = pixel_bytes * w + if x0 == x1 and y0 == y1: + break + e2 = 2 * err + if e2 >= dy: + err += dy + x0 += sx + if e2 <= dx: + err += dx + y0 += sy # ---------------------------------------------------------------------- -# Build the framebuffer +# 5️⃣ Build the framebuffer (background + white slanted‑top/bottom rectangles) # ---------------------------------------------------------------------- def build_framebuffer() -> bytearray: - """Create an ARGB buffer, fill it black and draw the thick‑outline rectangles.""" - # 1️⃣ background = opaque black (A,R,G,B) + """Create the ARGB buffer and draw the 12 rectangles with slanted top/bottom.""" + # ----- background: opaque black ----- fb = bytearray(FB_WIDTH * FB_HEIGHT * BPP) - bg_color = (255, 0, 0, 0) # opaque black - fb[:] = bg_color * (FB_WIDTH * FB_HEIGHT) + bg = (255, 0, 0, 0) # A,R,G,B = opaque black + fb[:] = bg * (FB_WIDTH * FB_HEIGHT) + + WHITE = (255, 255, 255, 255) # colour of the outlines + + half_w = RECT_WIDTH // 2 # half the (un‑slanted) width + + y_top = MARGIN_TOP + y_bottom = FB_HEIGHT - MARGIN_BOTTOM - 1 # inclusive bottom row - # 2️⃣ draw each rectangle outline for idx in range(12): - # ── colour palette (feel free to change) ─────────────────────── - rect_color = (255, 255, 255, 255) # opaque + # -------------------------------------------------------------- + # 1️⃣ Un‑slanted left edge of the rectangle (including spacing) + # -------------------------------------------------------------- + orig_x0 = X0_START + idx * (RECT_WIDTH + SPACING) - # left‑most X coordinate of the *inner* rectangle (the border belongs to it) - x0 = X0_START + idx * (RECT_WIDTH + SPACING) - y0 = 100 - w = RECT_WIDTH - h = RECT_HEIGHT + # -------------------------------------------------------------- + # 2️⃣ Centre X coordinate (kept fixed while slanting) + # -------------------------------------------------------------- + cx = orig_x0 + half_w - # ── thick edges ────────────────────────────────────────────────── + # -------------------------------------------------------------- + # 3️⃣ Angle for this rectangle + # -------------------------------------------------------------- + angle_rad = math.radians(ROT_ANGLES_DEG[idx]) + sin_a = math.sin(angle_rad) + + # -------------------------------------------------------------- + # 4️⃣ Vertical offset applied to the *ends* of the top/bottom lines + # (the spec says: sin(angle) * RECT_WITH / 2) + # -------------------------------------------------------------- + offset = sin_a * half_w # because RECT_WITH/2 == half_w + + # -------------------------------------------------------------- + # 5️⃣ Coordinates of the four line end‑points + # -------------------------------------------------------------- # top edge - fill_rect(fb, x0, y0, w, LINE_THICKNESS, rect_color) + x0_top = cx - half_w + y0_top = int(round(y_top + offset)) + + x1_top = cx + half_w + y1_top = int(round(y_top - offset)) # bottom edge - fill_rect(fb, x0, y0 + h - LINE_THICKNESS, w, LINE_THICKNESS, rect_color) + x0_bot = cx - half_w + y0_bot = int(round(y_bottom - offset)) - # left edge - fill_rect(fb, x0, y0, LINE_THICKNESS, h, rect_color) + x1_bot = cx + half_w + y1_bot = int(round(y_bottom + offset)) - # right edge - fill_rect(fb, x0 + w - LINE_THICKNESS, y0, LINE_THICKNESS, h, rect_color) + # -------------------------------------------------------------- + # 6️⃣ Draw the four sides + # -------------------------------------------------------------- + # top (slanted) + draw_thick_line(fb, x0_top, y0_top, x1_top, y1_top, + WHITE, LINE_THICKNESS) + + # bottom (slanted) + draw_thick_line(fb, x0_bot, y0_bot, x1_bot, y1_bot, + WHITE, LINE_THICKNESS) + + # left vertical side – from the *top‑left* endpoint down to the + # *bottom‑left* endpoint + draw_thick_line(fb, x0_top, y0_top, x0_bot, y0_bot, + WHITE, LINE_THICKNESS) + + # right vertical side – from the *top‑right* endpoint down to the + # *bottom‑right* endpoint + draw_thick_line(fb, x1_top, y1_top, x1_bot, y1_bot, + WHITE, LINE_THICKNESS) return fb # ---------------------------------------------------------------------- -# Send the buffer to the TCP server +# 6️⃣ Send the framebuffer to the TCP server (localhost:12345) # ---------------------------------------------------------------------- def send_framebuffer(buf: bytearray, host: str = "127.0.0.1", @@ -110,7 +184,7 @@ def send_framebuffer(buf: bytearray, """Open a TCP socket, connect, and stream the whole framebuffer.""" try: with socket.create_connection((host, port), timeout=5) as sock: - # optional length prefix (many protocols expect it) + # optional 4‑byte length prefix – many simple protocols expect it length_prefix = len(buf).to_bytes(4, byteorder="big") sock.sendall(length_prefix + buf) print(f"✔ Sent {len(buf)} bytes to {host}:{port}") @@ -119,7 +193,7 @@ def send_framebuffer(buf: bytearray, # ---------------------------------------------------------------------- -# Main entry point +# 7️⃣ Main entry point # ---------------------------------------------------------------------- def main() -> None: fb = build_framebuffer() @@ -128,3 +202,4 @@ def main() -> None: if __name__ == "__main__": main() +