ejung/waveform-draw
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

convert to c program

Browse Source
This commit is contained in:
Your Name
2025-12-13 01:33:41 +00:00
parent db764bbac0
commit 44efb66411
1 changed files with 232 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

232
draw_12_tilted_rects.c Normal file
View File

@@ -0,0 +1,232 @@
/*=====================================================================
draw_12_tilted_rects.c
---------------------------------------------------------------
Creates an 800×600 ARGB frame‑buffer, draws 12 white rectangles
whose top and bottom edges are slanted (as in the Python example
you supplied) and streams the buffer to a TCP server on
localhost:12345.
Compile (Linux / macOS):
gcc -Wall -O2 draw_12_tilted_rects.c -lm -o draw_12_tilted_rects
Run:
./draw_12_tilted_rects
-------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <math.h>
#include <errno.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define FB_W 800 /* framebuffer width */
#define FB_H 600 /* framebuffer height */
#define BPP 4 /* bytes per pixel (A,R,G,B) */
#define FRAMEBUF_SIZE (FB_W * FB_H * BPP)
#define MARGIN_TOP 100
#define MARGIN_BOTTOM 150
#define SPACING 10 /* space between rectangles */
#define LINE_THICKNESS 4 /* thickness of outline (pixels) */
#define NUM_RECTS 12
/*---------------------------------------------------------------*/
/* 1. Per‑rectangle tilt angles (in degrees). Edit as you wish. */
static int16_t rotAnglesDeg[NUM_RECTS] = {
0, 5, 10, 15, 20, 25,
30, 35, 40, 45, 50, 55
};
/*---------------------------------------------------------------*/
/* 2. ARGB colour helpers */
static const uint32_t COL_BLACK = 0xFF000000; /* opaque black */
static const uint32_t COL_WHITE = 0xFFFFFFFF; /* opaque white */
/*---------------------------------------------------------------*/
/* 3. Simple pixel write (bounds‑checked) */
static inline void set_pixel(uint8_t *fb, int x, int y, uint32_t col)
{
if (x < 0 || x >= FB_W || y < 0 || y >= FB_H)
return; /* ignore out‑of‑bounds writes */
uint32_t *dst = (uint32_t *)(fb + (y * FB_W + x) * BPP);
*dst = col;
}
/*---------------------------------------------------------------*/
/* 4. Thick line – Bresenham + square brush */
static void draw_thick_line(uint8_t *fb,
int x0, int y0,
int x1, int y1,
uint32_t col,
int thickness)
{
int dx = abs(x1 - x0);
int dy = -abs(y1 - y0);
int sx = (x0 < x1) ? 1 : -1;
int sy = (y0 < y1) ? 1 : -1;
int err = dx + dy; /* error term */
while (1) {
/* paint a square centred on the current pixel */
for (int ty = -thickness/2; ty <= thickness/2; ++ty) {
for (int tx = -thickness/2; tx <= thickness/2; ++tx) {
set_pixel(fb, x0 + tx, y0 + ty, col);
}
}
if (x0 == x1 && y0 == y1) break;
int e2 = 2 * err;
if (e2 >= dy) { err += dy; x0 += sx; }
if (e2 <= dx) { err += dx; y0 += sy; }
}
}
/*---------------------------------------------------------------*/
/* 5. Build the whole framebuffer */
static void build_framebuffer(uint8_t *fb)
{
/* 5.1 background = opaque black */
for (size_t i = 0; i < FRAMEBUF_SIZE; ++i) fb[i] = 0;
uint32_t *pix = (uint32_t *)fb;
for (size_t i = 0; i < FB_W * FB_H; ++i) pix[i] = COL_BLACK;
/* 5.2 geometry that does NOT depend on the angle */
const int usable_h = FB_H - MARGIN_TOP - MARGIN_BOTTOM; /* 400 */
const int rect_h = usable_h; /* 400 */
const int rect_w = rect_h / 8; /* ≈33 */
const int half_w = rect_w / 2;
const int total_rect_w = NUM_RECTS * rect_w + (NUM_RECTS - 1) * SPACING;
const int x0_start = (FB_W - total_rect_w) / 2; /* centre strip */
const int y_top = MARGIN_TOP;
const int y_bottom = FB_H - MARGIN_BOTTOM - 1; /* inclusive */
/* 5.3 draw each rectangle */
for (int i = 0; i < NUM_RECTS; ++i) {
/* ---- centre X (kept fixed while tilting) ---- */
int orig_x0 = x0_start + i * (rect_w + SPACING);
int cx = orig_x0 + half_w; /* centre X coordinate */
/* ---- angle in radians, sin and cos ---- */
double angle_rad = rotAnglesDeg[i] * M_PI / 180.0;
double sin_a = sin(angle_rad);
double cos_a = cos(angle_rad);
/* ---- vertical offset applied to the end‑points of the top/bottom lines ---- */
double offset = sin_a * half_w; /* sin(angle) * (RECT_W/2) */
/* ---- X offsets for the slanted top/bottom edges ---- */
double x_offset = cos_a * half_w; /* cos(angle) * (RECT_W/2) */
/* ---- compute the four end‑points (rounded to nearest integer) ---- */
int x0_top = (int)round(cx - x_offset);
int y0_top = (int)round(y_top + offset);
int x1_top = (int)round(cx + x_offset);
int y1_top = (int)round(y_top - offset);
int x0_bot = (int)round(cx - x_offset);
int y0_bot = (int)round(y_bottom - offset);
int x1_bot = (int)round(cx + x_offset);
int y1_bot = (int)round(y_bottom + offset);
/* ---- draw the four sides (thick) ---- */
draw_thick_line(fb, x0_top, y0_top, x1_top, y1_top,
COL_WHITE, LINE_THICKNESS); /* top */
draw_thick_line(fb, x0_bot, y0_bot, x1_bot, y1_bot,
COL_WHITE, LINE_THICKNESS); /* bottom*/
/* vertical sides – use the X coordinates of the *top* points;
the Y‑coordinates are taken from the corresponding top/bottom
endpoint, therefore they are automatically different when the
angle ≠ 0 or 180. */
draw_thick_line(fb, x0_top, y0_top, x0_bot, y0_bot,
COL_WHITE, LINE_THICKNESS); /* left */
draw_thick_line(fb, x1_top, y1_top, x1_bot, y1_bot,
COL_WHITE, LINE_THICKNESS); /* right */
}
}
/*---------------------------------------------------------------*/
/* 6. Send the framebuffer over TCP (length‑prefixed) */
static int send_framebuffer(const uint8_t *fb, size_t len,
const char *host, uint16_t port)
{
struct sockaddr_in srv;
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
perror("socket");
return -1;
}
memset(&srv, 0, sizeof(srv));
srv.sin_family = AF_INET;
srv.sin_port = htons(port);
if (inet_pton(AF_INET, host, &srv.sin_addr) <= 0) {
perror("inet_pton");
close(sock);
return -1;
}
if (connect(sock, (struct sockaddr *)&srv, sizeof(srv)) < 0) {
perror("connect");
close(sock);
return -1;
}
/* ---- optional 4‑byte length prefix (big‑endian) ---- */
uint32_t be_len = htonl((uint32_t)len);
if (write(sock, &be_len, sizeof(be_len)) != sizeof(be_len)) {
perror("write length prefix");
close(sock);
return -1;
}
/* ---- send the raw buffer ---- */
size_t sent = 0;
while (sent < len) {
ssize_t n = write(sock, fb + sent, len - sent);
if (n <= 0) {
perror("write framebuffer");
close(sock);
return -1;
}
sent += n;
}
close(sock);
return 0;
}
/*---------------------------------------------------------------*/
int main(void)
{
uint8_t *framebuf = malloc(FRAMEBUF_SIZE);
if (!framebuf) {
fprintf(stderr, "Failed to allocate framebuffer (%zu bytes)\n",
(size_t)FRAMEBUF_SIZE);
return EXIT_FAILURE;
}
while(1){
for(uint8_t i=0; i<sizeof(rotAnglesDeg)/sizeof(rotAnglesDeg[0]); i++)
rotAnglesDeg[i]=(rotAnglesDeg[i]+3)%180;
build_framebuffer(framebuf);
if (send_framebuffer(framebuf, FRAMEBUF_SIZE, "127.0.0.1", 12345) != 0) {
fprintf(stderr, "Failed to send framebuffer\n");
free(framebuf);
return EXIT_FAILURE;
}
usleep(100000);
}
printf("Framebuffer (%zu bytes) sent successfully.\n", (size_t)FRAMEBUF_SIZE);
free(framebuf);
return EXIT_SUCCESS;
}