uint8_t r, uint8_t g, uint8_t b) {

if (x < 0 || y < 0 || x >= img.w || y >= img.h) return;

size_t i = ((size_t)y * img.w + x) * 3;

img.rgb[i + 0] = r;

img.rgb[i + 1] = g;

img.rgb[i + 2] = b;

uint8_t r, uint8_t g, uint8_t b) {

if (x1 > x2) std::swap(x1, x2);

for (int x = x1; x <= x2; ++x) set_px(img, x, y, r, g, b);

uint8_t r, uint8_t g, uint8_t b) {

if (y1 > y2) std::swap(y1, y2);

for (int y = y1; y <= y2; ++y) set_px(img, x, y, r, g, b);

uint8_t r, uint8_t g, uint8_t b) {

if (x1 > x2) std::swap(x1, x2);

if (y1 > y2) std::swap(y1, y2);

for (int y = y1; y <= y2; ++y) {

for (int x = x1; x <= x2; ++x) {

set_px(img, x, y, r, g, b);

}

}

uint8_t r, uint8_t g, uint8_t b, int scale) {

unsigned uc = (unsigned char)ch;

if (uc >= 128) uc = (unsigned)'?';

if (scale <= 0) scale = 1;

const uint8_t* glyph = font8x8_basic[uc];

for (int row = 0; row < 8; ++row) {

uint8_t bits = glyph[row];

for (int col = 0; col < 8; ++col) {

if (bits & (1u << col)) {

int px = x + col * scale;

int py = y + row * scale;

for (int sy = 0; sy < scale; ++sy) {

for (int sx = 0; sx < scale; ++sx) {

set_px(img, px + sx, py + sy, r, g, b);

}

}

}

}

}

uint8_t r, uint8_t g, uint8_t b, int scale) {

if (!text) return;

if (scale <= 0) scale = 1;

int cx = x;

for (const char* p = text; *p; ++p) {

draw_char(img, cx, y, *p, r, g, b, scale);

cx += 8 * scale;

}

if (!text) return 0;

if (scale <= 0) scale = 1;

return (int)std::strlen(text) * 8 * scale;

uint8_t& r, uint8_t& g, uint8_t& b) {

static const uint8_t palette[20][3] = {

{230, 25, 75}, // red

{ 60, 180, 75}, // green

{255, 225, 25}, // yellow

{ 0, 130, 200}, // blue

{245, 130, 48}, // orange

{145, 30, 180}, // purple

{ 70, 240, 240}, // cyan

{240, 50, 230}, // magenta

{210, 245, 60}, // lime

{250, 190, 212}, // pink

{ 0, 128, 128}, // teal

{220, 190, 255}, // lavender

{170, 110, 40}, // brown

{255, 250, 200}, // beige

{128, 0, 0}, // maroon

{170, 255, 195}, // mint

{128, 128, 0}, // olive

{255, 215, 180}, // apricot

{ 0, 0, 128}, // navy

{128, 128, 128}, // gray

};

unsigned idx = (unsigned)(std::hash<std::string>{}(label) % 20u);

r = palette[idx][0];

g = palette[idx][1];

b = palette[idx][2];

if (img.w <= 0 || img.h <= 0) return;

if (thickness <= 0) thickness = 3;

uint8_t r, g, b;

label_color(box.label, r, g, b);

int x1 = (int)std::lround(box.x1);

int y1 = (int)std::lround(box.y1);

int x2 = (int)std::lround(box.x2);

int y2 = (int)std::lround(box.y2);

if (x2 < x1) std::swap(x1, x2);

if (y2 < y1) std::swap(y1, y2);

x1 = clampi(x1, 0, img.w - 1);

y1 = clampi(y1, 0, img.h - 1);

x2 = clampi(x2, 0, img.w - 1);

y2 = clampi(y2, 0, img.h - 1);

/* Stroke thickness: honor the caller value as a lower bound but always draw

int stroke = thickness < 3 ? 3 : thickness;

int max_stroke = std::min((x2 - x1) / 2, (y2 - y1) / 2);

if (max_stroke < 1) max_stroke = 1;

if (stroke > max_stroke) stroke = max_stroke;

for (int t = 0; t < stroke; ++t) {

draw_hline(img, x1, x2, y1 + t, r, g, b);

draw_hline(img, x1, x2, y2 - t, r, g, b);

draw_vline(img, x1 + t, y1, y2, r, g, b);

draw_vline(img, x2 - t, y1, y2, r, g, b);

}

/* Label: the free-text description string (no class id, no score). */

const char* name = box.label.empty() ? "?" : box.label.c_str();

/* Pick a font scale that's readable on both small and large images. */

int scale = 1;

if (img.w >= 640) scale = 2;

if (img.w >= 1280) scale = 3;

int padding = 3 * scale;

int label_w = text_width(name, scale);

int label_h = 8 * scale;

int bg_w = label_w + 2 * padding;

int bg_h = label_h + 2 * padding;

/* Prefer placing the label background above the box. If that would clip the

int bx1 = x1;

int by1 = y1 - bg_h;

if (by1 < 0) by1 = y1 + stroke;

int bx2 = bx1 + bg_w - 1;

if (bx2 >= img.w) bx2 = img.w - 1;

int by2 = by1 + bg_h - 1;

if (by2 >= img.h) by2 = img.h - 1;

fill_rect(img, bx1, by1, bx2, by2, r, g, b);

/* Choose text color (white or black) by perceived background brightness. */

int luma = (299 * r + 587 * g + 114 * b) / 1000;

uint8_t tr = 255, tg = 255, tb = 255;

if (luma > 160) { tr = tg = tb = 0; }

draw_text(img, bx1 + padding, by1 + padding, name, tr, tg, tb, scale);

Image out = img; // deep copy of pixel buffer

for (const auto& box : boxes) {

draw_box(out, box, /*thickness*/ 3);

}

return out;