BurgerGFX – simple 2D graphics

sample code and output
sample code and output

Several times I find myself wanting to visualize something in 2D, but can’t bother to fire up OpenGL or other cumbersome API.

So I wrote a simple program which I called BurgerGFX, with 2 core functionalities: draw point and draw line. I find this to be quite enough for simple applications such as viewing a graph.

Setting up the drawing canvas, which I call burger, is simple: call create(width, height), which returns a pointer to the burger. Then simply call the draws, prints and cleans as needed.

Here’s the code for your enjoyment.

/*
    File: burgergfx.c

    Copyright (c) 2014 Leonardo Brito <lbrito@gmail.com>

    This software is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with this program; if not, write the Free Software Foundation, Inc., 51
    Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#include
#include
#include

typedef struct
{
      int w,h;
      char* burger_matrix;
} burger;

/**
 *  @brief Create a new w x h burger
 *
 *  @param [in] w width
 *  @param [in] h height
 *  @return pointer to burger
 */
burger* create(int w, int h)
{
      burger* bgfx = malloc(sizeof(burger));
      bgfx->w = w;
      bgfx->h = h;
      bgfx->burger_matrix = malloc(sizeof(char)*w*h);
      int i=0;
      for (;i<w*h;i++) bgfx->burger_matrix[i] = '.';
      return bgfx;
}

/**
 *  @brief Get the appropriate cell from a normalized x coordinate
 *
 *  @param [in] b burger
 *  @param [in] x normalized coordinate
 *  @return cell index
 */
int get_norm_x(burger* b, double x)
{
      return (int) round(b->w*x);
}

/**
 *  @brief Get the appropriate cell from a normalized y coordinate
 *
 *  @param [in] b burger
 *  @param [in] y normalized coordinate
 *  @return cell index
 */
int get_norm_y(burger* b, double y)
{
      return (int) round(b->h*y);
}

/**
 *  @brief Fill the burger with whitespace
 *
 *  @param [in] b

 */
void clean_burger(burger* b)
{
      int i=0;
      for (;iw*b->h;i++) b->burger_matrix[i] = ' ';
}

/**
 *  @brief Put char in cell
 *
 *  @param [in] b  burger
 *  @param [in] dx normalized x position
 *  @param [in] dy normalized y position
 *  @param [in] c  char to be put
 */
void put_burger(burger* b, double dx, double dy, char c)
{
      int x = get_norm_x(b, dx);
      int y = get_norm_y(b, dy);
      b->burger_matrix[y+(x*b->w)] = c;
}

/**
 *  @brief Put char in cell
 *
 *  @param [in] b burger
 *  @param [in] x cell index
 *  @param [in] y cell index
 *  @param [in] c char to be put
 */
void put_burger_int(burger* b, int x, int y, char c)
{
      b->burger_matrix[y+(x*b->w)] = c;
}

/**
 *  @brief Print the current burger
 *
 *  @param [in] bgfx
 */
void print_burger(burger* bgfx)
{

      int i = 0, j = 0;
      printf("\n");
      for (;i<(bgfx->w/2)-2;i++) printf("  ");
      printf("Burger\n");
      for (i=0;ih;i++)
      {
            for (j=0;jw;j++)
            {
                  printf("%c ",bgfx->burger_matrix[i+(j*bgfx->w)]);
            }
            printf("\n");
      }
}

/**
 *  @brief Draw line from point 1 to point 2 on burger
 *
 *  @param [in] bgfx
 *  @param [in] dx1  point 1 normalized x coord
 *  @param [in] dy1  point 1 normalized y coord
 *  @param [in] dx2  point 2 normalized x coord
 *  @param [in] dy2  point 2 normalized y coord
 */
void put_line(burger* bgfx, double dx1, double dy1, double dx2, double dy2)
{
      int x1 = get_norm_x(bgfx, dx1);
      int y1 = get_norm_y(bgfx, dy1);
      int x2 = get_norm_x(bgfx, dx2);
      int y2 = get_norm_y(bgfx, dy2);

      int i = 0;

      float a = (float)(y2-y1)/(float)(x2-x1);

      if (x1<x2)
      {
            for (i=x1; i            {
                  int x = i - x1;
                  int y = (int) (a*x) + y1;
                  put_burger_int(bgfx, i, y, '.');
            }
      }
      else
      {
            for (i=x2; i<x1; i++)
            {
                  int x = i - x2;
                  int y = (int) (a*x) + (y1                  put_burger_int(bgfx, i, y, '.');
            }
      }
}
Advertisements

2 thoughts on “BurgerGFX – simple 2D graphics

  1. Hi

    Congratulations for putting together these pages.

    There seem to be some problems with the “” characters in some lines in the code
    e.g. lines 21,22,23, 82, 125, 127, 168 (this last line seem to be corrupted)

    and in line 153
    I think there would be an exception if x1 == x2

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s