P1
# This is an example bitmap of the harif alef
# by the way # mean comment line
5 11
0 0 0 0 0
0 0 1 1 0
0 0 1 0 0
0 1 1 1 0
0 0 0 0 0
0 0 1 0 0
0 0 1 0 0
0 0 1 0 0
0 0 1 0 0
0 0 1 0 0
0 0 0 0 0

P2
# ali.pgm
12 12
4
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 2 0 0 0 0 0
0 0 0 0 0 0 2 0 0 0 0 0
0 0 0 0 0 0 2 0 0 0 0 0
0 0 0 0 0 0 2 0 1 1 1 0
0 0 0 0 0 0 2 0 1 0 0 0
0 3 0 0 3 2 2 2 1 1 1 0
0 3 0 0 3 0 0 0 0 0 0 0
0 3 3 3 3 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 4 0 4 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0

P3
# colorboard.ppm
3 5
255

255 0 0         0 255 0         0 0 255
255 0 255       0 255 255       0 0 255
255 0 0         255 255 0       255 0 255
255 255 0       0 255 0         0 255 255
255 255 255     140 0 0         0 0 0

// -*- compile-command: "gcc -o red-gradient red-gradient.c && ./red-gradient"; -*-
#include <stdio.h>
#include <stdlib.h>

#define WIDTH  400
#define HEIGHT 200

int main(int argc, char **argv)
{
  FILE *fp = fopen("red-gradient.ppm", "w+b");
  fprintf(fp, "P6\n%d %d\n255\n", WIDTH, HEIGHT);

  float inc = (float) (256.0/WIDTH);

  float k = inc;
  for (float i = 0; i < HEIGHT; ++i)
    {
      for (int j = 0; j < WIDTH; ++j)
        {
          putc ((char) k, fp);
          putc (0, fp);
          putc (0, fp);
          k+=inc;
        }
      k = inc;
    }

  fclose (fp);
  return 0;
}

// -*- compile-command: "gcc -o red-white red-white.c && ./red-white"; -*-
#include <stdio.h>
#include <stdlib.h>

#define WIDTH 400
#define HEIGHT 200

int main(int argc, char **argv)
{
  FILE *fp = fopen("red-white.ppm", "w+b");
  fprintf(fp, "P6\n%d %d\n255\n", WIDTH, HEIGHT);

  unsigned char pixels[HEIGHT][WIDTH][3];
  float inc = (float) (256.0/WIDTH);
  float k = 255;

  for (int i = 0; i < HEIGHT; ++i)
    {
      for (int j = 0; j < WIDTH; ++j)
        {
          pixels[i][j][0] = 255;
          pixels[i][j][1] = (unsigned char) k;
          pixels[i][j][2] = (unsigned char) k;
          k-=inc;
        }
      k=255;
    }

  fwrite(pixels, HEIGHT*WIDTH*3, 1, fp);
  fclose (fp);
  return 0;
}

// -*- compile-command: "gcc -o ptr-eg ptr-eg.c && ./ptr-eg"; -*-
#include <stdio.h>
#include <stdlib.h>

#define WIDTH 400
#define HEIGHT 200

int main(int argc, char **argv)
{
  FILE *fp = fopen("ptr-eg.ppm", "w+b");
  fprintf(fp, "P6\n%d %d\n255\n", WIDTH, HEIGHT);

  unsigned char *pixels = malloc(sizeof(unsigned char) * WIDTH * HEIGHT * 3);
  float inc = (float) (256.0/WIDTH);
  float k = 255;
  int ten_percent_w = WIDTH*0.1;
  int ten_percent_h = HEIGHT*0.1;

  unsigned char *iter = pixels;
  for (int i = 0; i < HEIGHT; ++i)
    {
      for (int j = 0; j < WIDTH; ++j)
        {
          if (j % ten_percent_w == 0 && i % ten_percent_h == 0)
            {
              *iter++ = 255;
              *iter++ = 0;
              *iter++ = 0;
            }
          else if (i % ten_percent_h == 0)
            {
              *iter++ = 255;
              *iter++ = 0;
              *iter++ = 0;
            }
          else if (j % ten_percent_h == 0)
            {
              *iter++ = 255;
              *iter++ = 0;
              *iter++ = 0;
            }
          else
            {
              *iter++ = k;
              *iter++ = k/2 ;
              *iter++ = i+j << 2;
            }

          k-=inc;
        }
      k=255;
    }

  fwrite(pixels, HEIGHT*WIDTH*3, 1, fp);
  free (pixels);
  fclose (fp);
  return 0;
}

// -*- compile-command: "gcc -o ascii-parse ascii-parse.c && ./ascii-parse"; -*-
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct 
{
  char *magic, *width, *height, *depth;
} header;                       /* Image metadata, the section before data */

int main(int argc, char **argv)
{
  header file_header;

  FILE *fp = fopen("colorboard.ppm", "r");
  fseek(fp, 0, SEEK_END);
  unsigned int lastpos = ftell(fp);
  fseek(fp, 0, SEEK_SET);

  int numberscount = 0;         /* How many number in file without spaces and comments */
  int wordc = 0;                /* How many char the word takes */
 loop:
  while (ftell(fp) != lastpos)
    {
      char c = fgetc(fp);
      if (c == '#') while (c != '\n') c = fgetc(fp);      
      if (c == '\n' || c == '   ' || c == ' ')
        {
          if (wordc > 0)
            {
              numberscount++;
              wordc = 0;
            }
          goto loop;
        }
      else wordc++;
    }
  unsigned char pixels[numberscount-4]; // data without magic number, height, width and depth
  unsigned int positions[numberscount];
  int sizes[numberscount];

  fseek(fp, 0, SEEK_SET);
  int iter = 0;
  wordc = 0;
  loop2:
  while (ftell(fp) != lastpos)
    {
      char c = fgetc(fp);
      if (c == '#') while (c != '\n') c = fgetc(fp);      
      if (c == '\n' || c == '   ' || c == ' ')
        {
          if (wordc > 0)
            {
              positions[iter] = ftell(fp);
              sizes[iter] = wordc;
              iter++;
              wordc = 0;
            }
          goto loop2;
        }
      else wordc++;
    }

  int pixiter = 0;              /* Pixel iterator */
  for (int i = 0; i < numberscount; ++i)
    {
      fseek(fp, positions[i]-sizes[i]-1, SEEK_SET);
      char str[sizes[i]];
      for (int t = 0; t < sizes[i]; ++t) str[t] = fgetc(fp);
      if (i == 0) file_header.magic = strdup(str);
      else if (i == 1) file_header.width = strdup(str);
      else if (i == 2) file_header.height = strdup(str);
      else if (i == 3) file_header.depth = strdup(str);
      else
        {
          pixels[pixiter] = (unsigned char) atoi(str);
          pixiter++;
        }
    }
  // setting the last number manually because it is somewhat problematic
  fseek(fp, numberscount-sizes[numberscount-1], SEEK_SET);
  char last[1];
  for (int f = 0; f < sizes[numberscount-1]; ++f) last[f] = fgetc(fp);
  pixels[numberscount-4] = atoi(last);

  fclose(fp);

  FILE *fp2 = fopen("binary-colorboard.ppm", "w+b");
  fprintf(fp2, "P6\n%s %s\n%s\n", file_header.width,
          file_header.height, file_header.depth);
  fwrite(pixels, numberscount-3, 1, fp);
  fclose(fp);

  return 0;
}

// -*- compile-command: "gcc -g -o flip flip.c -lm && ./flip dog.ppm  && eog flip-dog.ppm"; -*-
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <string.h>

int main(int argc, char **argv)
{
  if (argc < 2)
    {
      printf("Usage: %s file.ppm\n", argv[0]);
      exit (0);
    }

  unsigned int w, h, d;
  FILE *fp = fopen(argv[1], "rb");
  char *line = NULL; // initializing it to NULL is very important for memory safty
  size_t len;
  getline (&line, &len, fp);
  if (strcmp ("P6\n", line) != 0)
    {
      printf("This is not valid P6 ppm file\n");
      fclose (fp);
      exit (1);
    }
  getline (&line, &len, fp);
  while (strstr(line, "#") != NULL) getline (&line, &len, fp);

  sscanf (line, "%u %u", &w, &h);
  getline (&line, &len, fp);
  sscanf (line, "%u", &d);
  unsigned char *data = malloc (w*h*3);
  fread (data, w*h*3, 1, fp);
  fclose (fp);

  unsigned char newdata[w*h*3];
  char outstr[strlen (argv[1])+ strlen ("flip-")+1];
  snprintf (outstr, strlen (argv[1])+ strlen ("flip-")+1, "flip-%s", argv[1]);
  FILE *fpout = fopen(outstr, "wb");
  fprintf(fpout, "P6\n%u %u\n255\n", w, h);

  int ik = w*h*3;
  for(int cy = 0; cy < w*h*3; cy+=3)
    {
      newdata[cy+2] = data[--ik];
      newdata[cy+1] = data[--ik];
      newdata[cy] = data[--ik];
    }

  fwrite (newdata, sizeof newdata, 1, fpout);
  fclose (fpout);
  return 0;
}

$ gcc -g -o flip flip.c -lm && ./flip dog.ppm  && eog flip-dog.ppm

// -*- compile-command: "gcc -g -o invert invert.c -lm && ./invert dog.ppm  && eog invert-dog.ppm"; -*-
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <string.h>

int main(int argc, char **argv)
{
  if (argc < 2)
    {
      printf("Usage: %s file.ppm\n", argv[0]);
      exit (0);
    }

  unsigned int w, h, d;
  FILE *fp = fopen(argv[1], "rb");
  char *line = NULL; // initializing it to NULL is very important for memory safty
  size_t len;
  getline (&line, &len, fp);
  if (strcmp ("P6\n", line) != 0)
    {
      printf("This is not valid P6 ppm file\n");
      fclose (fp);
      exit (1);
    }
  getline (&line, &len, fp);
  while (strstr(line, "#") != NULL)
    {
      getline (&line, &len, fp);
    }
  sscanf (line, "%u %u", &w, &h);
  getline (&line, &len, fp);
  sscanf (line, "%u", &d);
  unsigned char *data = malloc (w*h*3);
  fread (data, w*h*3, 1, fp);
  fclose (fp);

  unsigned char newdata[w*h*3];
  char outstr[strlen (argv[1])+ strlen ("invert-")+1];
  snprintf (outstr, strlen (argv[1])+ strlen ("invert-")+1, "invert-%s", argv[1]);
  FILE *fpout = fopen(outstr, "wb");
  fprintf(fpout, "P6\n%u %u\n255\n", w, h);

  for(int cy = 0; cy < w*h*3; ++cy)
    {
      newdata[cy] = 255 - data[cy];
    }

  fwrite (newdata, sizeof newdata, 1, fpout);
  fclose (fpout);
  return 0;
}

// -*- compile-command: "gcc -o write-tga write-tga.c && ./write-tga && eog file.tga"; -*-
#include <stdio.h>
#include <string.h>

enum
{
 width = 550,
 height = 400
};
/* to see the format spec see wikipedia */
/* https://en.wikipedia.org/wiki/Truevision_TGA */
/* this format is little-endian so no need to convert in normal x86 pc */
int main (void)
{
  FILE *fp = fopen("file.tga", "w+b");
  static unsigned char pixels[width * height * 3];
  static unsigned char tga[18+14];      /* HEADER static so all values initialized to zero */
  unsigned char *p;
  size_t x, y;

  /* all commented lines are unncessory because they are already initialized to zero */
  tga[0] = 14; // ID length: the length of comment section after header
  /* tga[1] = 0; */ // color map type: no color map (not indexed)
  tga[2] = 2; // Image type: uncompressed true-color image
  // color map specification
  /* tga[3] = 0; */ // First entry index (2 bytes): index of first
  /* tga[4] = 0; */ // color map entry that is included in the file
                    // it is zero because we didn't have colormap
  /* tga[5] = 0; */ // Color map length (2 bytes): number of entries
  /* tga[6] = 0; */ // of the color map that are included in the file
  /* tga[7] = 0; */ // Color map entry size (1 byte): number of bits per pixel

  tga[8] = 0; // X-origin (2 bytes): absolute coordinate of
  tga[9] = 0; // lower-left corner for displays where origin is
              // at the lower left  
  /* tga[10] = 0; */ // Y-origin (2 bytes): as for X-origin
  /* tga[11] = 0; */
  tga[12] = 255 & width;        /* width are stored in 2 bytes so this trick is needed */
  tga[13] = 255 & (width >> 8);
  tga[14] = 255 & height;       /* height are stored in 2 bytes so this trick is needed */
  tga[15] = 255 & (height >> 8);
  tga[16] = 24; // R 8 byte + G 8 byte + B 8 byte = 24 (without alpha)
  tga[17] = 32; // Image Descriptor see doc
  // comment section with word
  // happy, hacking
  tga[18] = 'h';
  tga[19] = 'a';
  tga[20] = 'p';
  tga[21] = 'p';
  tga[22] = 'y';
  tga[23] = ',';
  tga[24] = ' ';
  tga[25] = 'h';
  tga[26] = 'a';
  tga[27] = 'c';
  tga[28] = 'k';
  tga[29] = 'i';
  tga[30] = 'n';
  tga[31] = 'g';

  p = pixels; // p the iterator
  for (y = 0; y < height; y++)
    {
      for (x = 0; x < width; x++)
        {
          *p++ = 255 * ((float) y / height);
          *p++ = 255 * ((float) x / width);
          *p++ = 255 * ((float) y / height);
        }
    }
  fwrite (tga, sizeof (tga), 1, fp);
  fwrite (pixels, sizeof (pixels), 1, fp);
  fclose (fp);
  return 0;
}

// -*- compile-command: "gcc -g -o write-bmp-file write-bmp-file.c && ./write-bmp-file && eog written-file.bmp"; -*-
#include <stdio.h>

/* in bmp there are to headers : header (14 byte) and Dib header (22 byte) */
/* Color are not RGB but BGR */
/* Coordinates starts from bottem left */
#define WIDTH 400
#define HEIGHT 200
#define DEPTH 3
#define CDEPTH 24

int main(int argc, char **argv)
{
  FILE *fp = fopen("written-file.bmp", "w+b");

  //calculate padding
  int pad = 0, wcpy = WIDTH*DEPTH;
  while ((wcpy % 4) != 0) { wcpy++; pad++; }
  printf("pad = %u\n", pad);

  int rdata = (WIDTH*HEIGHT*DEPTH)+(HEIGHT*pad);
  printf("raw data = %u\n", rdata);
  int fsize = rdata+(14+40);
  printf("full file size = %u\n", fsize);

  fprintf(fp, "BM");
  // file size (4 byte to store the number that indicate file size)
  int i = fsize; // header size + Dib header size + raw data size (which include padding)
  fwrite (&i, 4, 1, fp);

  // optional application bit set to zero (2 byte)
  fputc(0, fp); fputc(0, fp);

  // another optional application bit set to zero (2 byte)
  fputc(0, fp); fputc(0, fp);

  // (4 byte) where pixel data start (offset) for us we have no  
  i = 54; // metadata other than header so 54 right after 53 (Dib header)
  fwrite (&i, 4, 1, fp);

  // Dib header //
  // 1: sizeof header (4 byte)
  i = 40;
  fwrite (&i, 4, 1, fp);

  // 2: image width (4 byte)
  i = WIDTH;
  fwrite (&i, 4, 1, fp);

  // 3: image height (4 byte)
  i = HEIGHT;
  fwrite (&i, 4, 1, fp);

  // 4: color plane must be 1 (according to wikipedia) (2 byte)
  short k = 1;
  fwrite (&k, 2, 1, fp);

  // 5: color depth  (2 byte)
  k = CDEPTH; // it is 24 because 8bit Blue + 8bit Green + 8bit Red
  fwrite (&k, 2, 1, fp);

  // 6: compression method (4 byte) (no compression 0)
  i = 0;
  fwrite (&i, 4, 1, fp);

  // 7: raw data size (4 byte)
  i = rdata;
  fwrite (&i, 4, 1, fp);

  // 8: horizontal resolution (4 byte)
  i = WIDTH;
  fwrite (&i, 4, 1, fp);

  // 9: vertical resolution (4 byte)
  i = HEIGHT;
  fwrite (&i, 4, 1, fp);

  // 10: number of colors in palette (4 byte)
  i = 0; // 0 for default 2^n
  fwrite (&i, 4, 1, fp);

  // 11: important colors (4 byte)
  i = 0; // ignored 0 (this what generally used)
  fwrite (&i, 4, 1, fp);

  float increment = (float) (256.0/WIDTH);
  float pkkk = 0;
  // after each row there must be padding bytes
  // to make each row multiple of 4 (if it is not )
  for (int i = 0; i < WIDTH; ++i)
    {
      // one row generated from each i iteration
      for (int jk = 0; jk < HEIGHT; ++jk)
        {
          fputc((unsigned char) pkkk, fp);      /* B */
          fputc(0, fp); /* G */
          fputc(0, fp); /* R */
        }
      for (int tk = 0; tk < pad; ++tk) fputc(0, fp); // Padding
      pkkk += increment;
    }

  fclose(fp);
  return 0;
}