Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-5-sonnet-20241022· AnthropicHugging Face LMArena Human Preference 140K

give me code in c# that draws 100 by 50 rectangle in .bmp from vector polygon presented…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-sonnet-4-20250514-thinking-32k’s answer.
  1. User

    give me code in c# that draws 100 by 50 rectangle in .bmp from vector polygon presented by corresponding points

  2. Claude Assistant

    Here's C# code that creates a BMP file with a rectangle defined by vector points:

    using System;
    using System.Collections.Generic;
    using System.IO;
    
    public class BmpGenerator
    {
        public class Point
        {
            public int X { get; set; }
            public int Y { get; set; }
    
            public Point(int x, int y)
            {
                X = x;
                Y = y;
            }
        }
    
        public static void Main()
        {
            int width = 500;
            int height = 500;
    
            // Define rectangle points (100x50)
            List<Point> polygonPoints = new List<Point>
            {
                new Point(200, 200),           // Top-left
                new Point(300, 200),           // Top-right
                new Point(300, 250),           // Bottom-right
                new Point(200, 250)            // Bottom-left
            };
    
            // Create a byte array for the pixel data (24-bit BMP)
            byte[] pixelData = new byte[width * height * 3];
    
            // Fill the background with white
            for (int i = 0; i < pixelData.Length; i += 3)
            {
                pixelData[i] = 255;     // Blue
                pixelData[i + 1] = 255; // Green
                pixelData[i + 2] = 255; // Red
            }
    
            // Draw the rectangle
            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    if (IsPointInPolygon(new Point(x, y), polygonPoints))
                    {
                        int index = (y * width + x) * 3;
                        pixelData[index] = 0;     // Blue
                        pixelData[index + 1] = 0; // Green
                        pixelData[index + 2] = 0; // Red
                    }
                }
            }
    
            // Calculate padding and create BMP file
            int rowSize = width * 3;
            int padding = (4 - (rowSize % 4)) % 4;
            int newRowSize = rowSize + padding;
            int imageSize = newRowSize * height;
    
            // Create padded pixel data with reversed rows
            byte[] paddedPixelData = new byte[imageSize];
            for (int y = 0; y < height; y++)
            {
                int sourceRow = y;
                int destRow = height - 1 - y;
                int startIndex = sourceRow * width * 3;
                int paddedStartIndex = destRow * newRowSize;
                Array.Copy(pixelData, startIndex, paddedPixelData, paddedStartIndex, rowSize);
    
                // Add padding bytes
                for (int p = 0; p < padding; p++)
                {
                    paddedPixelData[paddedStartIndex + rowSize + p] = 0;
                }
            }
    
            // Write BMP file
            int fileSize = 54 + imageSize;
            using (BinaryWriter writer = new BinaryWriter(File.Open("rectangle.bmp", FileMode.Create)))
            {
                // File Header
                writer.Write((byte)'B');
                writer.Write((byte)'M');
                writer.Write(fileSize);
                writer.Write((int)0);
                writer.Write(54);
    
                // DIB Header
                writer.Write(40);
                writer.Write(width);
                writer.Write(height);
                writer.Write((short)1);
                writer.Write((short)24);
                writer.Write(0);
                writer.Write(imageSize);
                writer.Write(2835);
                writer.Write(2835);
                writer.Write(0);
                writer.Write(0);
    
                // Pixel Data
                writer.Write(paddedPixelData);
            }
        }
    
        // Point in polygon test using ray casting algorithm
        private static bool IsPointInPolygon(Point testPoint, List<Point> polygon)
        {
            bool result = false;
            int j = polygon.Count - 1;
    
            for (int i = 0; i < polygon.Count; i++)
            {
                if (polygon[i].Y < testPoint.Y && polygon[j].Y >= testPoint.Y || 
                    polygon[j].Y < testPoint.Y && polygon[i].Y >= testPoint.Y)
                {
                    if (polygon[i].X + (testPoint.Y - polygon[i].Y) / 
                        (polygon[j].Y - polygon[i].Y) * 
                        (polygon[j].X - polygon[i].X) < testPoint.X)
                    {
                        result = !result;
                    }
                }
                j = i;
            }
    
            return result;
        }
    }
    

    This code:

    1. Defines a Point class to represent vector points
    2. Creates a 500x500 pixel BMP image
    3. Defines a rectangle as a polygon using four points (100 pixels wide by 50 pixels tall)
    4. Uses a ray casting algorithm to determine which pixels are inside the polygon
    5. Fills those pixels in black, leaving the background white
    6. Handles all the BMP file format requirements including padding and row ordering
    7. Saves the result as "rectangle.bmp"

    You can modify the polygon points to change the position or size of the rectangle. The IsPointInPolygon method will work with any convex or concave polygon, not just rectangles, so you could add more points to create more complex shapes.

    To create different shapes, just modify the polygonPoints list with different coordinates. For example, to create a triangle, you would use three points instead of four.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.