definiciones de clase de muestreo regulares y prueba

Este algoritmo es un algoritmo de muestreo uniforme, heredado de la clase Sampler.

declaración de la clase:

#pragma vez 
#ifndef __REGULAR_HEADER__ 
#define __REGULAR_HEADER__ 

# include "sampler.h" 

clase regular: Sampler pública { 
público: 
	Regular (); 
	~ Regular (); 
	(Samps enteros const) regular; 
	(Samps const enteros, conjuntos enteros const) regular; 
	Regular (const & registro regular); 
	Regular operador & = (const Regular & registro); 
	Sampler * clone () const virtual; 
	generate_samples virtual void (); 
}; 
#terminara si　　

implementación de la clase:

# include "pch.h" 
# include "regular.h" 

regular :: Regular (): Sampler () { 
	generate_samples (); 
} 

Regular Regular :: ~ () {} 

(Samps enteros const) Regular :: Regular: Sampler (Samps) { 
	generate_samples (); 
} 

Regular :: (Samps enteros const, conjuntos enteros const) Regular: Sampler (Samps, conjuntos) { 
	generate_samples (); 
} 

Regular :: Regular (const Regular & registro): Sampler (reg) { 
	generate_samples (); 
} 

Regular y regular operador :: = (const & registro regular) { 
	si (esto == & registro) 
		de retorno * esto; 
	Sampler :: operator = (reg); 
	* volver esto; 
} 

Sampler * Regular :: clone () const { 
	Return new Regular (* this); 
}

void regulares :: generate_samples () { 
	número entero n = (número entero) std :: sqrt ((LHaga) nsamples); 
	para (número entero p = 0; p <nsets; p ++) { 
		for (número entero i = 0; i <n; i ++) 
			para (número entero j = 0; j <n; j ++) { 
				Point2 sp ((j + 0,5) / n, (i + 0.5) / n); //均匀采样
				samples.push_back (sp); 
			} 
	} 
}

 

algoritmo de prueba de muestreo:

clase Sampler y se añade a la cantidad de muestras categoría ViewPlane, función creciente (parte si no se indica específicamente, la modificación no se repetirá)

void set_samples (const número entero n );

vacío set_sampler (Sampler * const sp );

ViewPlane declaración determinada clase es la siguiente:

#pragma vez 
#ifndef __VIEWPLANE_HEADER__ 
#define __VIEWPLANE_HEADER__ 

# include "../../Types.h" 

clase Sampler; 

clase ViewPlane { 
público: 
	ViewPlane (); 
	ViewPlane (const ViewPlane y vp); 
	set_hres void (const hr número entero); 
	set_vres void (const vr número entero); 
	set_pixelsize void (const ps LHaga); 
	set_gamma void (const ga LHaga); 
	set_samples void (const número entero n); //新增
	void set_sampler (Sampler * const sp); //新增
	HRES entero; 
	vres entero; 
	nsamples enteros; //新增
	LHaga s; 
	g LHaga; 
	Sampler sampler *; //新增
}; 

#terminara si　

Tenga que modificar las miembros de la clase:

#include "pch.h" 
#include "viewplane.h" 
#include "../samplers/jittered.h" 


ViewPlane :: ViewPlane (): HRES (200), vres (100), S (0,02), g ( 1), nsamples (16), sampler (nullptr) {} 

ViewPlane :: ViewPlane (const ViewPlane y vp) 
	: HREs (vp.hres), VRES (vp.vres), s (vp.s), g (vp.g ), nsamples (vp.nsamples), Sampler (vp.sampler) {} 

... 

void ViewPlane :: set_samples (const número entero n) {//和书上不同,剔除特殊性,增加兼容性
	nsamples = n; 
	sampler-> clear (); 
	sampler-> set_num_samples (nsamples); 
	sampler-> setup_shuffled_indices (); 
	sampler-> generate_samples (); 
} 

Void ViewPlane :: set_sampler (Sampler * const sp) { 
	si (muestreador = nullptr!) {  
		Muestreador de eliminación;
		Muestreador = nullptr;
	nsamples = sp-> get_num_samples (); 
	sampler = sp; 
}

　　

clase mundial sólo modifican la estructura y render partes:

void mundo :: build () { 
	vp.set_hres (200); 
	vp.set_vres (100); 
	vp.set_sampler (nueva Regular ()); //所有采样修改都在这里测试
	tracer_ptr = new multiesferas (this); 
	Geometrics * obj = new Esfera (0, 0,5); 
	obj-> set_color (RGBColor (1, 0, 0)); 
	add_object (obj); 
	obj = new Esfera (Point3 (0, -100,5, 0), 100); 
	obj-> set_color (RGBColor (0, 0, 1)); 
	add_object (obj); 
}

A menos que hacer de otro modo parte de la declaración, después de la parte modificada no se repetirá.

vacío Mundial :: render () { 
	Ray ray; 
	x LHaga, y; 
	open_window (vp.hres, vp.vres); 
	Point3 sp; 
	ray.o = Point3 (0, 0, 1); 
	para (entero r = vp.vres - 1; r> = 0; r -) // genera de-esquina izquierda a derecha-esquina 
		para (número entero c = 0; c <vp.hres; c ++) { 
			el color RGBColor; 
			para (número entero p = 0; p <vp.nsamples; p ++) {//增加样本
				sp = vp.sampler-> sample_unit_square (); 
				x = vp.s * (c - 0,5 * vp.hres + sp.x); 
				y = vp.s * (r - 0,5 * vp.vres + sp.y); 
				ray.d = Point3 (x, y, -1); 
				color + = tracer_ptr-> trace_ray (ray); 
			} 
			De color / = vp.nsamples; 
			display_pixel (r, c, color); 
		} 
}

　　

Después de la modificación, operando procedimientos, resultados de la prueba son como sigue (después de la amplificación y se encontró una gran cantidad de esquinas redondeadas, entonces probar otro algoritmo de muestreo):