Question

当我在下面的代码中向double tmin=0.0, double tmax=0.0的构造函数中添加一些额外的形式参数Ray时，我总是会得到一个带有白色上边框的错误图像。这些形式参数目前对代码没有任何作用（即未使用）。那么如何获得不同的图像呢？

系统规格：

操作系统：Windows 8.1
编译：MSVC 2015

Code：

#include "stdafx.h"
#include <math.h>
#include <stdlib.h>
#include <stdio.h>

#include <random>
std::default_random_engine generator(606418532);
std::uniform_real_distribution<double> distribution = std::uniform_real_distribution<double>(0.0, 1.0);
double erand48(unsigned short *x) {
    return distribution(generator);
}
#define M_PI 3.14159265358979323846

struct Vector3 {
    double x, y, z;
    Vector3(double x_ = 0, double y_ = 0, double z_ = 0) { x = x_; y = y_; z = z_; }
    Vector3 operator+(const Vector3 &b) const { return Vector3(x + b.x, y + b.y, z + b.z); }
    Vector3 operator-(const Vector3 &b) const { return Vector3(x - b.x, y - b.y, z - b.z); }
    Vector3 operator*(double b) const { return Vector3(x*b, y*b, z*b); }
    Vector3 mult(const Vector3 &b) const { return Vector3(x*b.x, y*b.y, z*b.z); }
    Vector3& norm() { return *this = *this * (1 / sqrt(x*x + y*y + z*z)); }
    double Dot(const Vector3 &b) const { return x*b.x + y*b.y + z*b.z; } // cross:
    Vector3 operator%(Vector3&b) { return Vector3(y*b.z - z*b.y, z*b.x - x*b.z, x*b.y - y*b.x); }
};

//struct Ray { Vector3 o, d; Ray(const Vector3 &o_, const Vector3 &d_, double tmin=0.0, double tmax=0.0) : o(o_), d(d_) {} };
struct Ray { Vector3 o, d; Ray(const Vector3 &o_, const Vector3 &d_) : o(o_), d(d_) {} };

enum Reflection_t { DIFFUSE, SPECULAR, REFRACTIVE };
struct Sphere {
    double rad;       // radius
    Vector3 p, e, f;      // position, emission, color
    Reflection_t reflection_t;      // reflection type (DIFFuse, SPECular, REFRactive)
    Sphere(double rad_, Vector3 p_, Vector3 e_, Vector3 f_, Reflection_t reflection_t) :
        rad(rad_), p(p_), e(e_), f(f_), reflection_t(reflection_t) {}
    double intersect(const Ray &r) const {
        Vector3 op = p - r.o;
        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);
    }
};

Sphere spheres[] = {
    Sphere(1e5, Vector3(1e5 + 1,40.8,81.6), Vector3(),Vector3(.75,.25,.25),DIFFUSE),//Left
    Sphere(1e5, Vector3(-1e5 + 99,40.8,81.6),Vector3(),Vector3(.25,.25,.75),DIFFUSE),//Rght
    Sphere(1e5, Vector3(50,40.8, 1e5),     Vector3(),Vector3(.75,.75,.75),DIFFUSE),//Back
    Sphere(1e5, Vector3(50,40.8,-1e5 + 170), Vector3(),Vector3(),           DIFFUSE),//Frnt
    Sphere(1e5, Vector3(50, 1e5, 81.6),    Vector3(),Vector3(.75,.75,.75),DIFFUSE),//Botm
    Sphere(1e5, Vector3(50,-1e5 + 81.6,81.6),Vector3(),Vector3(.75,.75,.75),DIFFUSE),//Top
    Sphere(16.5,Vector3(27,16.5,47),       Vector3(),Vector3(1,1,1)*.999, SPECULAR),//Mirr
    Sphere(16.5,Vector3(73,16.5,78),       Vector3(),Vector3(1,1,1)*.999, REFRACTIVE),//Glas
    Sphere(600, Vector3(50,681.6 - .27,81.6),Vector3(12,12,12),  Vector3(), DIFFUSE) //Lite
};
inline double clamp(double x) { return x<0 ? 0 : x>1 ? 1 : x; }
inline int toInt(double x) { return int(pow(clamp(x), 1 / 2.2) * 255 + .5); }
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;
}
Vector3 radiance(const Ray &r_, int depth_, unsigned short *Xi) {
    double t;                               // distance to intersection
    int id = 0;                               // id of intersected object
    Ray r = r_;
    int depth = depth_;
    Vector3 cl(0, 0, 0);   // accumulated color
    Vector3 cf(1, 1, 1);  // accumulated reflectance
    while (1) {
        if (!intersect(r, t, id)) return cl; // if miss, return black
        const Sphere &obj = spheres[id];        // the hit object
        Vector3 x = r.o + r.d*t, n = (x - obj.p).norm(), nl = n.Dot(r.d)<0 ? n : n*-1, f = obj.f;
        double p = f.x>f.y && f.x>f.z ? f.x : f.y>f.z ? f.y : f.z; // max refl
        cl = cl + cf.mult(obj.e);
        if (++depth>5) if (erand48(Xi)<p) f = f*(1 / p); else return cl; //R.R.
        cf = cf.mult(f);
        if (obj.reflection_t == DIFFUSE) {                  // Ideal DIFFUSE reflection
            double r1 = 2 * M_PI*erand48(Xi), r2 = erand48(Xi), r2s = sqrt(r2);
            Vector3 w = nl, u = ((fabs(w.x)>.1 ? Vector3(0, 1) : Vector3(1)) % w).norm(), v = w%u;
            Vector3 d = (u*cos(r1)*r2s + v*sin(r1)*r2s + w*sqrt(1 - r2)).norm();
            r = Ray(x, d);
            continue;
        }
        else if (obj.reflection_t == SPECULAR) {
            r = Ray(x, r.d - n * 2 * n.Dot(r.d));
            continue;
        }
        Ray reflRay(x, r.d - n * 2 * n.Dot(r.d));
        bool into = n.Dot(nl)>0;
        double nc = 1, nt = 1.5, nnt = into ? nc / nt : nt / nc, ddn = r.d.Dot(nl), cos2t;
        if ((cos2t = 1 - nnt*nnt*(1 - ddn*ddn))<0) {
            r = reflRay;
            continue;
        }
        Vector3 tdir = (r.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, Tr = 1 - Re, P = .25 + .5*Re, RP = Re / P, TP = Tr / (1 - P);
        if (erand48(Xi)<P) {
            cf = cf*RP;
            r = reflRay;
        }
        else {
            cf = cf*TP;
            r = Ray(x, tdir);
        }
        continue;
    }
}
int main(int argc, char *argv[]) {
    int w = 512, h = 384, samps = argc == 2 ? atoi(argv[1]) / 4 : 1; // # samples
    Ray cam(Vector3(50, 52, 295.6), Vector3(0, -0.042612, -1).norm()); // cam pos, dir
    Vector3 cx = Vector3(w*.5135 / h), cy = (cx%cam.d).norm()*.5135, r, *c = new Vector3[w*h];
#pragma omp parallel for schedule(dynamic, 1) private(r)       // OpenMP
    for (int y = 0; y<h; y++) {                       // Loop over image rows
        fprintf(stderr, "\rRendering (%d spp) %5.2f%%", samps * 4, 100.*y / (h - 1));
        for (unsigned short x = 0, Xi[3] = { 0,0,y*y*y }; x<w; x++)   // Loop cols
            for (int sy = 0, i = (h - y - 1)*w + x; sy<2; sy++)     // 2x2 subpixel rows
                for (int sx = 0; sx<2; sx++, r = Vector3()) {        // 2x2 subpixel cols
                    for (int s = 0; s<samps; s++) {
                        double r1 = 2 * erand48(Xi), dx = r1<1 ? sqrt(r1) - 1 : 1 - sqrt(2 - r1);
                        double r2 = 2 * erand48(Xi), dy = r2<1 ? sqrt(r2) - 1 : 1 - sqrt(2 - r2);
                        Vector3 d = cx*(((sx + .5 + dx) / 2 + x) / w - .5) +
                            cy*(((sy + .5 + dy) / 2 + y) / h - .5) + cam.d;
                        r = r + radiance(Ray(cam.o + d * 140, d.norm()), 0, Xi)*(1. / samps);
                    } // Camera rays are pushed ^^^^^ forward to start in interior
                    c[i] = c[i] + Vector3(clamp(r.x), clamp(r.y), clamp(r.z))*.25;
                }
    }
    FILE *fp;
    fopen_s(&fp, "image.ppm", "w");         // Write image to PPM file.
    fprintf(fp, "P3\n%d %d\n%d\n", w, h, 255);
    for (int i = 0; i<w*h; i++)
        fprintf(fp, "%d %d %d ", toInt(c[i].x), toInt(c[i].y), toInt(c[i].z));
}

首先 Ray 结构：

struct Ray { Vector3 o, d; Ray(const Vector3 &o_, const Vector3 &d_) : o(o_), d(d_) {} };

结果：

第二次 Ray 结构：

struct Ray { Vector3 o, d; Ray(const Vector3 &o_, const Vector3 &d_, double tmin=0.0, double tmax=0.0) : o(o_), d(d_) {} };

结果：

最后一张图像有一个明显的白色顶部边框，在第一张图片中不存在。

修改：

我用过

size_t n = sizeof(spheres) / sizeof(Sphere);

现在我获得了相同的图像，但我还检查了原始int(n)是否可能与9不同，这种情况从未如此。

好的，这是来自Debug构建，它与Release构建不同。

Answer 1

听起来像是内存错误，快速查看代码我对此行持怀疑态度：

for (int i = int(n); i--;) if ((d = spheres[i].intersect(r)) && d<t)

~~我怀疑访问sphere[i]是不合格的，也许你应该尝试sphere[i-1]。~~你也可以尝试用编译器编译代码，为编译添加额外的代码/清理/检查内存地址。

将未使用的形式参数添加到C ++方法会导致不同的行为

1 个答案: