Search code examples
c++craytracing

How to use stbi_write_png to write image pixel data to a png file

So I have been following the Ray tracing in a weekend and initially was writing all the pixel data to a ppm file and was just experimenting with writing to different image file formats. I was able to write to a bmp file with some help on the internet and currently I am trying to write the pixel data to a png. I have been trying to use stbi_write_png function but the resultant image created is totally different from what was require

I am detailing the code down below for the bmp part and the png and the resulting image as well for both implementations.

This is the code for the bmp write

#include<iostream>
#include<stdint.h>
#include<fstream>
#include<random>
#include "hitableList.h"
#include "sphere.h"
#include "camera.h"
#include "material.h"
#include <float.h> //for float_MAX
#include "main.h" //contains our typedef declarations, #defines and struct declarations.
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;

typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;
typedef float f32;

#define STBI_MSC_SECURE_CRT
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"


#define CHANNEL_NUM 3

internal u32 GetTotalPixelSize(image_32 Image)//take image_32 Image
{
    u32 Result = Image.Width*Image.Height * sizeof(u32);
    return(Result);
}

//Function defintion to allocate image size
internal image_32 AllocateImage(u32 width, u32 height)
{
    image_32 Image = {};//create the image object and initialize it.
    Image.Height = height;
    Image.Width = width;
    u32 OutputPixelSize = GetTotalPixelSize(Image);//old version of the code does this line->sizeof(u32)*image.Width*image.Height;
    Image.Pixels = (u32*)malloc(OutputPixelSize);//main source of the initial nullpointer at main *Out.
    return(Image);
}

internal void WriteImage(image_32 Image, const char* OutputFileName)
{
    u32 OutputPixelSize = GetTotalPixelSize(Image);
    bitmap_header Header = {};

    Header.FileType = 0x4D42;
    Header.FileSize = sizeof(Header) + OutputPixelSize;//Need to set it later
                                                       //Header.Reserved1;//These are reserved and set by the header itself
                                                       //Header.Reserved2;//These are reserved and set by the header itself
    Header.BitmapOffset = sizeof(Header);
    Header.Size = sizeof(Header) - 14;//also need to set the size of the pixels. Since the header is 50 bytes check wikipedia.
    Header.Width = Image.Width;
    Header.Height = Image.Height;
    Header.Planes = 1;
    Header.BitsPerPixel = 32;
    Header.Compression = 0;
    Header.SizeOfBitmap = OutputPixelSize;//writing bottom part first. Very Important.
    Header.HorzResolution = 0;
    Header.VertResolution = 0;
    Header.ColorsUsed = 0;
    Header.ColorsImportant = 0;
FILE *OutFile = fopen(OutputFileName, "wb");

    if (OutFile)
    {
        fwrite(&Header, sizeof(Header), 1, OutFile);//we write it into the header
        fwrite(Image.Pixels, OutputPixelSize, 1, OutFile);
        fclose(OutFile);
    }

    else
    {
        fprintf(stderr, "[Error]Unable to write output file %s. \n", OutputFileName);
    }
}

vec3 color(const ray& r, hitable *world, int depth)
{
    hit_record rec;
    if(world->hit(r, 0.001, FLT_MAX, rec)){
        ray scattered;
        vec3 attenuation;
        if(depth <50 && rec.mat_ptr->scatter(r,rec,attenuation,scattered)){
            return attenuation*color(scattered, world, depth+1);
        }
        else{
            return vec3(0,0,0);
        }
    }
    else{
        vec3 unit_direction = unit_vector(r.direction());
        float t = 0.5*(unit_direction.y() + 1.0);
        return (1.0-t)*vec3(1.0, 1.0, 1.0) + t*vec3(0.5, 0.7, 1.0);
    }
}

int main()
{    
    printf("Raycasting......");
    /*
    int nx=1280;
    int ny =720;
    */
    u32 ns = 10;
    u32 width = 1280;
    u32 height = 720;
hitable *list[5];
    list[0] = new sphere(vec3(0,0,-1), 0.5, new lambertian(vec3(0.8, 0.3, 0.3)));
    list[1] = new sphere(vec3(0,-100.5,-1), 100, new lambertian(vec3(0.8, 0.8, 0.0)));
    list[2] = new sphere(vec3(1,0,-1), 0.5, new metal(vec3(0.8, 0.6, 0.2), 0.3));
    list[3] = new sphere(vec3(-1,0,-1), 0.5, new dielectric(1.5));
    list[4] = new sphere(vec3(-1,0,-1), -0.45, new dielectric(1.5));
    hitable *world = new hitable_list(list,4);
    camera cam;
    //u32 *Out = Image.Pixels;
    u8* pixels = new u8[width * height * CHANNEL_NUM];

    u32 index =0;
    for(u32 y=0 ; y<height; y++)
    {
        for(u32 x=0; x<width; x++)
        {
            vec3 col(0, 0, 0);

            for(u32 s=0; s < ns; s++)
            {
                float u = float(x+drand48())/float(width);
                float v = float(y+drand48())/float(height);
                ray r = cam.get_ray(u, v);
                vec3 p = r.point_at_parameter(2.0);
                col = col + color(r, world, 0); //col returns a vec3
            }
            col/=float(ns);//average sampling per pixel


           vec3 BMPColor = vec3(255*col); //getting bmp color values from raytraced image.
           u32 BMPvalue = BGRPack4x8(BMPColor); //packing the bmp color into an integer to write to the bitmap image.

           *Out++ = BMPvalue;


           if((y%64) ==0)
        {
            printf("\rRaycasting row %d%%....",100*y / height);
            fflush(stdout);
        }
}

         WriteImage(Image, "..\\data\\Hollow_Glass_Sphere.bmp");//getting the raytraced image plane on test.bmp.

         printf("\nDone.....\n");

return 0;
    }

#include<iostream>
#include<stdint.h>
#include<fstream>
#include<random>
#include "hitableList.h"
#include "sphere.h"
#include "camera.h"
#include "material.h"
#include <float.h> //for float_MAX
#include "main.h" //contains our typedef declarations, #defines and struct declarations.
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;

typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;
typedef float f32;

#define STBI_MSC_SECURE_CRT
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"


#define CHANNEL_NUM 3

vec3 color(const ray& r, hitable *world, int depth)
{
    hit_record rec;
    if(world->hit(r, 0.001, FLT_MAX, rec)){
        ray scattered;
        vec3 attenuation;
        if(depth <50 && rec.mat_ptr->scatter(r,rec,attenuation,scattered)){
            return attenuation*color(scattered, world, depth+1);
        }
        else{
            return vec3(0,0,0);
        }
    }
    else{
        vec3 unit_direction = unit_vector(r.direction());
        float t = 0.5*(unit_direction.y() + 1.0);
        return (1.0-t)*vec3(1.0, 1.0, 1.0) + t*vec3(0.5, 0.7, 1.0);
    }
}

int main()
{    
    printf("Raycasting......");
    /*
    int nx=1280;
    int ny =720;
    */
    u32 ns = 10;
    u32 width = 1280;
    u32 height = 720;

    hitable *list[5];
    list[0] = new sphere(vec3(0,0,-1), 0.5, new lambertian(vec3(0.8, 0.3, 0.3)));
    list[1] = new sphere(vec3(0,-100.5,-1), 100, new lambertian(vec3(0.8, 0.8, 0.0)));
    list[2] = new sphere(vec3(1,0,-1), 0.5, new metal(vec3(0.8, 0.6, 0.2), 0.3));
    list[3] = new sphere(vec3(-1,0,-1), 0.5, new dielectric(1.5));
    list[4] = new sphere(vec3(-1,0,-1), -0.45, new dielectric(1.5));
    hitable *world = new hitable_list(list,4);
    camera cam;
    //u32 *Out = Image.Pixels;
    u8* pixels = new u8[width * height * CHANNEL_NUM];

    u32 index =0;
    for(u32 y=0 ; y<height; y++)
    {
        for(u32 x=0; x<width; x++)
        {
            vec3 col(0, 0, 0);

            for(u32 s=0; s < ns; s++)
            {
                float u = float(x+drand48())/float(width);
                float v = float(y+drand48())/float(height);
                ray r = cam.get_ray(u, v);
                vec3 p = r.point_at_parameter(2.0);
                col = col + color(r, world, 0); //col returns a vec3
            }
            col/=float(ns);//average sampling per pixel

            col = vec3( sqrt(col[0]), sqrt(col[1]), sqrt(col[2]));
            int ir = int(255.99*col[0]);
            int ig = int(255.99*col[1]);
            int ib = int(255.99*col[2]);

            pixels[++index] = ir;
            pixels[++index] = ig;
            pixels[++index] = ib;


            if((y%64) ==0)
        {
            printf("\rRaycasting row %d%%....",100*y / height);
            fflush(stdout);
        }
    }

    stbi_write_png("testpng_4.png", width, height, CHANNEL_NUM, pixels, width*CHANNEL_NUM);

    printf("\nDone.....\n");

    return 0;
}

This is the BMP image that corresponds to the bmp write code and based off of what I read and implemented in Ray tracing in a weekend book, this is the correct desired image

enter image description here

This is the PNG image that corresponds to the png write code and it seems like the image is flipped in colors and orientation. I have tried and failed in debugging what could be the issue in this image. The only thought that comes to mind is if it is a endianness issue. I would be really happy if anyone could help me solve this problem on the png write and if it is an endianness issue, how could I go about solving it.

enter image description here

Solution

  • Here is your output, when converted from RGB to BRG:

    enter image description here 1. The image should be flipped in the y-axis. Instead of looping as:

    for(u32 y=0; y < height; y++)

    it should be something like:

    for (u32 y = height - 1; y >= 0; y--)

    1. The ir, ig, and ib values are type of int; however, the pixel buffer and the input of stbi_write_png function requires unsigned char, u8 in your case. Multiplying them by 255.9 might yield values well above 255, and you may consider clamping them between [0, 255] before casting them to unsigned char. You may consult a similar discussion here: stb image write issue

    2. Although changing the pixel ordering from RGB to BRG will do the trick, you may also want to consider why the image looks brighter overall. This is most probably because of the sqrt operation over the col values, which will return higher values than the original col values, since cols are fractional numbers. In multisampling, dividing the sum with the number of samples should suffice. In case these do not work, I would check if the stbi_write_png is still writing an alpha channel, or your viewer treats one of the channels as an alpha channel, which is the least likely.

    This is the output when the RGB channels are changed to BRG, the image is flipped vertically, and every col is squared, which looks correct: enter image description here