Skip to content

Instantly share code, notes, and snippets.

@BachiLi BachiLi/smallgdpt.cpp
Last active Sep 3, 2019

Embed
What would you like to do?
// smallgdpt: a simple implementation of gradient domain path tracing
// https://mediatech.aalto.fi/publications/graphics/GPT/
// adapted from smallpt by Kevin Beason http://www.kevinbeason.com/smallpt/
// and a screened poisson solver by Pravin Bhat http://grail.cs.washington.edu/projects/screenedPoissonEq/
// to build, type: g++ -o smallgdpt -fopenmp -O3 smallgdpt.cpp -L/usr/local/lib -lm -lfftw3
// you will need fftw3 http://www.fftw.org/ to compile
// usage: ./smallgdpt [number of samples per pixel]
#include <fftw3.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
const int MAX_DEPTH = 32;
struct Vec {
double x, y, z; // position, also color (r,g,b)
Vec(double x_=0, double y_=0, double z_=0){ x=x_; y=y_; z=z_; }
Vec operator+(const Vec &b) const { return Vec(x+b.x,y+b.y,z+b.z); }
Vec operator-(const Vec &b) const { return Vec(x-b.x,y-b.y,z-b.z); }
Vec operator-() const {return Vec(-x,-y,-z);}
Vec operator*(double b) const { return Vec(x*b,y*b,z*b); }
Vec mult(const Vec &b) const { return Vec(x*b.x,y*b.y,z*b.z); }
Vec& norm(){ return *this = *this * (1/sqrt(x*x+y*y+z*z)); }
double dot(const Vec &b) const { return x*b.x+y*b.y+z*b.z; } // cross:
Vec operator%(Vec&b){return Vec(y*b.z-z*b.y,z*b.x-x*b.z,x*b.y-y*b.x);}
double max() const {return x>y && x>z ? x : y > z ? y : z;}
};
struct Ray { Vec o, d; Ray(Vec o_, Vec d_) : o(o_), d(d_) {} };
enum Refl_t { DIFF, SPEC, REFR }; // material types
struct Sphere {
double rad; // radius
Vec p, e, c; // position, emission, color
Refl_t refl; // reflection type (DIFFuse, SPECular, REFRactive)
Sphere(double rad_, Vec p_, Vec e_, Vec c_, Refl_t refl_):
rad(rad_), p(p_), e(e_), c(c_), refl(refl_) {}
double intersect(const Ray &r) const { // returns distance, 0 if nohit
Vec op = p-r.o; // Solve t^2*d.d + 2*t*(o-p).d + (o-p).(o-p)-R^2 = 0
double t, eps=1e-4, b=op.dot(r.d), det=b*b-op.dot(op)+rad*rad;
if (det<0) return 0; else det=sqrt(det);
return (t=b-det)>eps ? t : ((t=b+det)>eps ? t : 0);
}
};
int width = 1024; int height = 768;
Ray cam(Vec(50,50,295.6), Vec(0,-0.042612,-1).norm()); // cam pos, dir
Vec cx=Vec(width*.5135/height), cy=(cx%cam.d).norm()*.5135;
Sphere spheres[] = {//Scene: radius, position, emission, color, material
Sphere(1e5, Vec( 1e5+1,40.8,81.6), Vec(),Vec(.75,.25,.25),DIFF),//Left
Sphere(1e5, Vec(-1e5+99,40.8,81.6),Vec(),Vec(.25,.25,.75),DIFF),//Rght
Sphere(1e5, Vec(50,40.8, 1e5), Vec(),Vec(.75,.75,.75),DIFF),//Back
Sphere(1e5, Vec(50, 1e5, 81.6), Vec(),Vec(.75,.75,.75),DIFF),//Botm
Sphere(1e5, Vec(50,-1e5+81.6,81.6),Vec(),Vec(.75,.75,.75),DIFF),//Top
Sphere(16.5,Vec(27,16.5,47), Vec(),Vec(1.0,1.0,1.0)*.999, SPEC),//Mirr
Sphere(16.5,Vec(73,16.5,78), Vec(),Vec(1.0,1.0,1.0)*.999, REFR),//Glas
Sphere(600, Vec(50,681.6-.27,81.6),Vec(12,12,12), Vec(), DIFF) //Lite
};
struct PathVert {
Vec p; Vec n; int id;
};
struct Path {
PathVert verts[MAX_DEPTH];
double rnds[2*MAX_DEPTH];
int vertCount;
int x, y;
};
inline bool intersect(const Ray &r, double &t, int &id){
double n=sizeof(spheres)/sizeof(Sphere), d, inf=t=1e20;
for(int i=int(n);i--;) if((d=spheres[i].intersect(r))&&d<t){t=d;id=i;}
return t<inf;
}
Vec reflect(const Vec &d, const Vec &n) {
return d - n * 2.0 * n.dot(d);
}
Ray sampleBSDF(const Ray &ray, const Sphere &obj, const PathVert &vert, double u0, double u1) {
if (obj.refl == DIFF) {
double r1=2*M_PI*u0, r2=u1, r2s=sqrt(r2);
Vec nl=vert.n.dot(ray.d)<0?vert.n:vert.n*-1; // flip normal if needed
Vec w=nl, u=((fabs(w.x)>.1?Vec(0,1):Vec(1))%w).norm(), v=w%u;
Vec d = (u*cos(r1)*r2s + v*sin(r1)*r2s + w*sqrt(1-r2)).norm();
return Ray(vert.p, d);
} else if (obj.refl == SPEC) {
return Ray(vert.p, reflect(ray.d, vert.n));
} else { //REFR
Ray reflRay(vert.p, reflect(ray.d, vert.n));
bool into = vert.n.dot(ray.d)<0;
Vec nl = into?vert.n:vert.n*-1;
double nc=1, nt=1.5, nnt=into?nc/nt:nt/nc, ddn=ray.d.dot(nl), cos2t;
if ((cos2t = 1-nnt*nnt*(1-ddn*ddn)) < 0) { // total internal reflection
return reflRay;
}
Vec tdir = (ray.d*nnt - vert.n*((into?1:-1)*(ddn*nnt+sqrt(cos2t)))).norm();
double a=nt-nc, b=nt+nc, R0=a*a/(b*b), c = 1-(into?-ddn:tdir.dot(vert.n));
double Re=R0+(1-R0)*c*c*c*c*c, P=.25+.5*Re; // schlick
if (u0 < P) {
return reflRay;
} else {
return Ray(vert.p, tdir);
}
}
return Ray(Vec(), Vec());
}
double BSDFProb(const Refl_t &refl, const Vec &wi, const Vec &n, const Vec &wo) {
if (refl == DIFF) {
double cosTheta = fabs(wo.dot(n));
return (cosTheta/M_PI);
} else if (refl == SPEC) {
return 1.0;
} else { //REFR
bool refl = wi.dot(n) * wo.dot(n) > 0.0;
bool into = n.dot(wi) > 0;
Vec nl = into ? n : n*-1; // flip normal if needed
Vec d = -wi;
double nc=1, nt=1.5, nnt=into?nc/nt:nt/nc, ddn=d.dot(nl), cos2t;
double P = refl ? 1.0 : 0.0;
if ((cos2t = 1-nnt*nnt*(1-ddn*ddn)) > 0) {
Vec tdir = (d*nnt - n*((into?1:-1)*(ddn*nnt+sqrt(cos2t)))).norm();
double a=nt-nc, b=nt+nc, R0=a*a/(b*b), c = 1-(into?-ddn:tdir.dot(n));
double Re=R0+(1-R0)*c*c*c*c*c;
P = .25+.5*Re; if (!refl) P = 1.0 - P;
}
return P;
}
return 0.0;
}
// generate a light path from scratch
bool generatePath(int x, int y, unsigned short *rng, Path &path) {
path.x = x; path.y = y;
path.rnds[0] = erand48(rng); path.rnds[1] = erand48(rng);
Vec d = cx*( (path.rnds[0] + x)/width - .5) +
cy*( (path.rnds[1] + y)/height - .5) + cam.d;
// Camera rays are pushed forward to start in interior
Ray ray(cam.o+d*140, d.norm());
path.vertCount = 0;
for (int depth = 1; depth <= MAX_DEPTH; depth++) {
double t; int id = -1;
if (!intersect(ray, t, id)) return false;
const Sphere &obj = spheres[id];
PathVert vert;
vert.p = ray.o + ray.d*t; vert.n = (vert.p - obj.p).norm(); vert.id = id;
path.verts[depth-1] = vert; path.vertCount++;
double p = obj.c.max();
if (p <= 0.0) return true; // assume refl=0 -> light source
if (depth == MAX_DEPTH) return false;
path.rnds[2*depth] = erand48(rng); path.rnds[2*depth+1] = erand48(rng);
ray = sampleBSDF(ray, obj, vert, path.rnds[2*depth], path.rnds[2*depth+1]);
}
return false;
}
// "shift" a light path to a specific pixel
bool shiftPath(int x, int y, const Path &basePath, Path &offsetPath, double &jacobian) {
offsetPath.x = x; offsetPath.y = y;
Vec baseWi = -(cx*( (basePath.rnds[0] + basePath.x)/width - .5) +
cy*( (basePath.rnds[1] + basePath.y)/height - .5) + cam.d).norm();
Vec d = cx*( (basePath.rnds[0] + x)/width - .5) +
cy*( (basePath.rnds[1] + y)/height - .5) + cam.d;
Ray ray(cam.o+d*140, d.norm());
Vec wi = -ray.d;
offsetPath.vertCount = basePath.vertCount;
memcpy(offsetPath.verts, basePath.verts, sizeof(PathVert) * basePath.vertCount);
jacobian = 1.0;
for (int vertId = 0; vertId < basePath.vertCount; vertId++) {
int depth = vertId + 1;
double t; int id = -1;
if (!intersect(ray, t, id)) return false;
const Sphere &obj = spheres[id];
const Sphere &baseObj = spheres[basePath.verts[vertId].id];
if (obj.refl != baseObj.refl) return false;
PathVert vert;
vert.p = ray.o + ray.d*t; vert.n = (vert.p - obj.p).norm(); vert.id = id;
offsetPath.verts[vertId] = vert;
if (vertId == basePath.vertCount - 1) break;
if (obj.refl == DIFF && spheres[basePath.verts[vertId + 1].id].refl == DIFF) {
// connect back to base path, jacobian = ratio of geometry term
if (!intersect(Ray(vert.p, (basePath.verts[depth].p - vert.p).norm()), t, id) ||
id != basePath.verts[vertId + 1].id) return false;
Vec baseP0 = basePath.verts[depth - 1].p;
Vec p1 = basePath.verts[depth].p;
Vec baseN0 = basePath.verts[depth - 1].n;
Vec n1 = basePath.verts[depth].n;
Vec baseDir = p1 - baseP0;
double baseDist2 = baseDir.dot(baseDir);
baseDir = baseDir * (1.0 / sqrt(baseDist2));
double baseGeom = fabs(baseDir.dot(n1)) * fabs(baseDir.dot(baseN0)) / baseDist2;
Vec shiftDir = p1 - vert.p;
double shiftDist2 = shiftDir.dot(shiftDir);
shiftDir = shiftDir * (1.0 / sqrt(shiftDist2));
double shiftGeom = fabs(shiftDir.dot(n1)) * fabs(shiftDir.dot(vert.n)) / shiftDist2;
jacobian *= (shiftGeom / baseGeom);
return true;
}
// copy the random numbers used to sample BRDF, jacobian = ratio of inverse PDF
// this should be simpler than the half-vector based shift described in the paper
ray = sampleBSDF(ray, obj, vert, basePath.rnds[2*depth], basePath.rnds[2*depth+1]);
Vec baseWo = (basePath.verts[vertId + 1].p - basePath.verts[vertId].p).norm();
double basePDF = BSDFProb(baseObj.refl, baseWi, basePath.verts[vertId].n, baseWo);
double shiftPDF = BSDFProb(obj.refl, wi, vert.n, ray.d);
if (shiftPDF <= 0.0) return false;
jacobian *= (basePDF / shiftPDF);
baseWi = -baseWo; wi = -ray.d;
}
const Sphere &obj = spheres[offsetPath.verts[offsetPath.vertCount-1].id];
double p = obj.c.max();
return p <= 0.0; // assume refl=0 -> light source
}
// path contribution in solid angle domain
Vec pathContrib(const Path &path) {
Vec throughput(1,1,1);
Vec wi = -(cx*( (path.rnds[0] + path.x)/width - .5) +
cy*( (path.rnds[1] + path.y)/height - .5) + cam.d).norm();
for (int vert = 0; vert < path.vertCount - 1; vert++) {
const PathVert &currVert = path.verts[vert];
const PathVert &nextVert = path.verts[vert + 1];
Vec wo = (nextVert.p - currVert.p).norm();
double cosTheta = fabs(wo.dot(currVert.n));
const Sphere &obj = spheres[path.verts[vert].id];
if (cosTheta <= 1e-6) return Vec();
if (obj.refl == DIFF) {
throughput = throughput.mult(obj.c*(cosTheta/M_PI));
} else if (obj.refl == SPEC) {
throughput = throughput.mult(obj.c);
} else { //REFR
bool refl = wi.dot(currVert.n) * wo.dot(currVert.n) > 0.0;
bool into = currVert.n.dot(wi) > 0;
Vec d = -wi;
Vec nl = into ? currVert.n : currVert.n*-1; // flip normal if needed
double nc=1, nt=1.5, nnt=into?nc/nt:nt/nc, ddn=d.dot(nl), cos2t;
double fresnel = refl ? 1.0 : 0.0;
if ((cos2t = 1-nnt*nnt*(1-ddn*ddn)) > 0) {
Vec tdir = (d*nnt - currVert.n*((into?1:-1)*(ddn*nnt+sqrt(cos2t)))).norm();
double a=nt-nc, b=nt+nc, R0=a*a/(b*b), c = 1-(into?-ddn:tdir.dot(currVert.n));
double Re=R0+(1-R0)*c*c*c*c*c,Tr=1-Re;
fresnel = refl ? Re : Tr;
}
throughput = throughput.mult(obj.c * fresnel);
}
wi = -wo;
}
const Sphere &obj = spheres[path.verts[path.vertCount-1].id];
return throughput.mult(obj.e);
}
// path probability in solid angle domain
double pathProb(const Path &path) {
Vec wi = -(cx*( (path.rnds[0] + path.x)/width - .5) +
cy*( (path.rnds[1] + path.y)/height - .5) + cam.d).norm();
double prob = 1.0;
for (int vert = 0; vert < path.vertCount - 1; vert++) {
const PathVert &currVert = path.verts[vert];
const PathVert &nextVert = path.verts[vert + 1];
Vec wo = (nextVert.p - currVert.p).norm();
double cosTheta = fabs(wo.dot(currVert.n));
const Sphere &obj = spheres[path.verts[vert].id];
if (cosTheta <= 1e-6) return 0.0;
prob *= BSDFProb(obj.refl, wi, currVert.n, wo);
if (prob <= 0.0) return 0.0;
wi = -wo;
}
return prob;
}
// screened Poisson solver from http://grail.cs.washington.edu/projects/screenedPoissonEq/
void fourierSolve(int width, int height,
const double* imgData, const double* imgGradX,
const double* imgGradY, double dataCost,
double* imgOut) {
int nodeCount = width * height;
double* fftBuff = (double*) fftw_malloc(sizeof(*fftBuff) * nodeCount);
//compute two 1D lookup tables for computing the DCT of a 2D Laplacian on the fly
double* ftLapY = (double*) fftw_malloc(sizeof(*ftLapY) * height);
double* ftLapX = (double*) fftw_malloc(sizeof(*ftLapX) * width);
for(int x = 0; x < width; x++) {
ftLapX[x] = 2.0 * cos(M_PI * x / (width - 1));
}
for(int y = 0; y < height; y++) {
ftLapY[y] = -4.0 + (2.0 * cos(M_PI * y / (height - 1)));
}
//Create a DCT-I plan for, which is its own inverse.
fftw_plan fftPlan;
fftPlan = fftw_plan_r2r_2d(height, width,
fftBuff, fftBuff,
FFTW_REDFT00, FFTW_REDFT00, FFTW_ESTIMATE); //use FFTW_PATIENT when plan can be reused
for(int iChannel = 0; iChannel < 3; iChannel++) {
int nodeAddr = 0;
int pixelAddr = iChannel;
int rightPixelAddr = 3 + iChannel;
int topPixelAddr = (width * 3) + iChannel;
double dcSum = 0.0;
// compute h_hat from u, gx, gy (see equation 48 in Bhat's paper), as well as the DC term of u's DCT.
for(int y = 0; y < height; y++)
for(int x = 0; x < width; x++,
nodeAddr++, pixelAddr += 3, rightPixelAddr += 3, topPixelAddr += 3) {
// Compute DC term of u's DCT without computing the whole DCT.
double dcMult = 1.0;
if((x > 0) && (x < width - 1))
dcMult *= 2.0;
if((y > 0) && (y < height - 1))
dcMult *= 2.0;
dcSum += dcMult * imgData[pixelAddr];
fftBuff[nodeAddr] = dataCost * imgData[pixelAddr];
// Subtract g^x_x and g^y_y, with boundary factor of -2.0 to account for boundary reflections implicit in the DCT
if((x > 0) && (x < width - 1))
fftBuff[nodeAddr] -= (imgGradX[rightPixelAddr] - imgGradX[pixelAddr]);
else
fftBuff[nodeAddr] -= (-2.0 * imgGradX[pixelAddr]);
if((y > 0) && (y < height - 1))
fftBuff[nodeAddr] -= (imgGradY[topPixelAddr] - imgGradY[pixelAddr]);
else
fftBuff[nodeAddr] -= (-2.0 * imgGradY[pixelAddr]);
}
//transform h_hat to H_hat by taking the DCT of h_hat
fftw_execute(fftPlan);
//compute F_hat using H_hat (see equation 29 in Bhat's paper)
nodeAddr = 0;
for(int y = 0; y < height; y++)
for(int x = 0; x < width; x++, nodeAddr++) {
float ftLapResponse = ftLapY[y] + ftLapX[x];
fftBuff[nodeAddr] /= (dataCost - ftLapResponse);
}
/* Set the DC term of the solution to the value computed above (i.e., the DC term of imgData).
* set dcSum to the desired average when dataCost=0
*/
fftBuff[0] = dcSum;
//transform F_hat to f_hat by taking the inverse DCT of F_hat
fftw_execute(fftPlan);
double fftDenom = 4.0 * (width - 1) * (height - 1);
pixelAddr = iChannel;
for(int iNode = 0; iNode < nodeCount; iNode++, pixelAddr += 3) {
imgOut[pixelAddr] = fftBuff[iNode] / fftDenom;
}
}
fftw_free(fftBuff);
fftw_free(ftLapX);
fftw_free(ftLapY);
fftw_destroy_plan(fftPlan);
}
int main(int argc, char *argv[]){
int samps = argc==2 ? atoi(argv[1]) : 4; // # samples
Vec *c=new Vec[width * height];
Vec *cx0=new Vec[width * height];
Vec *cy0=new Vec[width * height];
Vec *cx1=new Vec[width * height];
Vec *cy1=new Vec[width * height];
#pragma omp parallel for schedule(dynamic, 1) // OpenMP
for (int y=0; y<height; y++){ // Loop over image rows
fprintf(stderr,"\rRendering (%d spp) %5.2f%%",samps,100.*y/(height-1));
for (unsigned short x=0, rng[3]={0,0,y*y*y}; x<width; x++) { // Loop cols
Vec r, rdx0, rdy0, rdx1, rdy1;
for (int s=0; s<samps; s++){
Path path, oPath; double jacobian;
if(generatePath(x, y, rng, path)) {
Vec contrib = pathContrib(path);
double prob = pathProb(path);
if (prob > 0.0) {
Vec contribX0, contribY0;
Vec contribX1, contribY1;
double wX0 = 1, wY0 = 1;
double wX1 = 1, wY1 = 1;
r = r + (contrib * (1.0 / prob)) * (1.0 / (double)samps);
if(shiftPath(x-1, y, path, oPath, jacobian)) {
contribX0 = pathContrib(oPath) * jacobian;
double pX0 = pathProb(oPath) * jacobian;
wX0 = prob / (prob + pX0);
}
if(shiftPath(x, y+1, path, oPath, jacobian)) {
contribY0 = pathContrib(oPath) * jacobian;
double pY0 = pathProb(oPath) * jacobian;
wY0 = prob / (prob + pY0);
}
if(shiftPath(x+1, y, path, oPath, jacobian)) {
contribX1 = pathContrib(oPath) * jacobian;
double pX1 = pathProb(oPath) * jacobian;
wX1 = prob / (prob + pX1);
}
if(shiftPath(x, y-1, path, oPath, jacobian)) {
contribY1 = pathContrib(oPath) * jacobian;
double pY1 = pathProb(oPath) * jacobian;
wY1 = prob / (prob + pY1);
}
rdx0 = rdx0 + (contrib - contribX0) * (wX0 / (prob * (double)samps));
rdy0 = rdy0 + (contrib - contribY0) * (wY0 / (prob * (double)samps));
rdx1 = rdx1 + (contribX1 - contrib) * (wX1 / (prob * (double)samps));
rdy1 = rdy1 + (contribY1 - contrib) * (wY1 / (prob * (double)samps));
}
}
}
int i = (height - y - 1) * width + x;
c[i] = c[i] + r;
cx0[i] = cx0[i] + rdx0; cy0[i] = cy0[i] + rdy0;
cx1[i] = cx1[i] + rdx1; cy1[i] = cy1[i] + rdy1;
}
}
Vec *cx=new Vec[width * height], *cy = new Vec[width * height];
for (int y=0; y<height; y++)
for (int x=0; x<width; x++) {
int i = y * width + x;
if (x == 0) cx[i] = cx0[i];
else cx[i] = cx0[i] + cx1[i-1];
if (y == 0) cy[i] = cy0[i];
else cy[i] = cy0[i] + cy1[i-width];
}
Vec *out=new Vec[width * height];
fourierSolve(width, height, (double*)c, (double*)cx, (double*)cy, 0.04, (double*)out);
int npixel = 3 * width * height;
float *fc = new float[npixel], *fout = new float[npixel];
float *fcx = new float[npixel], *fcy = new float[npixel];
for(int i = 0; i < width * height; i++) { //pfm requires single precision
fc[3*i] = c[i].x; fc[3*i+1] = c[i].y; fc[3*i+2] = c[i].z;
fout[3*i] = out[i].x; fout[3*i+1] = out[i].y; fout[3*i+2] = out[i].z;
fcx[3*i] = fabs(cx[i].x); fcx[3*i+1] = fabs(cx[i].y); fcx[3*i+2] = fabs(cx[i].z);
fcy[3*i] = fabs(cy[i].x); fcy[3*i+1] = fabs(cy[i].y); fcy[3*i+2] = fabs(cy[i].z);
}
FILE *f = fopen("image.pfm", "w"); // Write image to PFM files.
fprintf(f, "PF\n%d %d\n%d\n", width, height, -1);
fwrite(fc, sizeof(float), npixel, f); fclose(f);
f = fopen("image_dx.pfm", "w");
fprintf(f, "PF\n%d %d\n%d\n", width, height, -1);
fwrite(fcx, sizeof(float), npixel, f); fclose(f);
f = fopen("image_dy.pfm", "w");
fprintf(f, "PF\n%d %d\n%d\n", width, height, -1);
fwrite(fcy, sizeof(float), npixel, f); fclose(f);
f = fopen("image_poisson.pfm", "w");
fprintf(f, "PF\n%d %d\n%d\n", width, height, -1);
fwrite(fout, sizeof(float), npixel, f); fclose(f);
return 0;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.