definición de clase Sampler

Esta es la clase base para todas las muestras, los beneficios de esta definición es que podemos probar cada algoritmo de muestreo, respectivamente.

definición de clase:

Una vez #pragma 
#ifndef __SAMPLER_HEADER__ 
#define __SAMPLER_HEADER__ 

# include "../utilities/geometry.h" 

clase Sampler { 
público: 
	Sampler (); 
	Virtual Sampler ~ (); 
	Sampler (const Entero Samps); 
	Sampler (const Entero Samps, const conjuntos enteros); 
	Sampler (const Sampler & S); 
	virtual Sampler * clone () const = 0; 
	generate_samples virtual void () = 0; // función virtual pura en este contexto, el libro no lo hace, lo hacemos tan fácilmente después de ajustar dinámicamente el número de muestras 
      sample_unit_square Point3 virtual (); 
	setup_shuffled_indices void (); 
	set_num_sets void (const conjuntos entero); 
	get_num_sets entero () const; 
	set_num_samples void (const Entero Samps); 
	get_num_samples entero () const;
	Claro void (); 
	Sampler operador & = (const Sampler & S); 
protegidas: 
	nsamples entero; 
	nsets entero; 
	std :: vector <Point3> las muestras; // utilizado aquí Point3, compatible con todos muestreo algoritmo 
	std :: vector <entero> shuffled_indices ; 
	Entero CUENTA; 
	Entero Salto; 
}; 
#endif

　　

implementación de la clase:

# include "pch.h" 
# include "sampler.h" 

Sampler :: Sampler (): nsamples (16), nsets (36), recuento (0), Salto (0) { 
	setup_shuffled_indices (); 
} 

Sampler Sampler :: ~ () {} 

Sampler :: Sampler (Samps const integer): nsamples (Samps), nsets (36), count (0), salto (0) { 
	setup_shuffled_indices (); 
} 

Sampler :: Sampler (Samps enteros const, conjuntos enteros const) 
	: nsamples (Samps), nsets (juegos), count (0), salto (0) { 
	setup_shuffled_indices (); 
} 

Sampler :: Sampler (const Sampler y s) 
	: nsamples (s.nsamples), nsets (s.nsets), count (s.count), salto (s.jump), 
	muestras (s.samples), shuffled_indices (s. shuffled_indices) {} 

Point3 Sampler :: sample_unit_square () {
	Si (recuento% nsamples == 0) 
Número entero Sampler :: get_num_sets () const {
		salto = (random_integer ()% nsets) * nsamples; 
	de retorno (muestras [JUMP + shuffled_indices [JUMP + count ++% nsamples]]); 
} 

Void Sampler :: setup_shuffled_indices () { 
	shuffled_indices.reserve (nsamples * nsets); 
	std :: vector <entero> índices; 
	para (entero i = 0; i <nsamples; i ++) 
		indices.push_back (i); 
	para (entero i = 0; i <nsets; i ++) { 
		random_shuffle (indices.begin (), indices.end ()); 
		shuffled_indices.insert (shuffled_indices.end (), indices.begin (), indices.end ()); 
	} 
} 

Void Sampler :: set_num_sets (conjuntos enteros const) { 
	nsets = conjuntos; 
} 

	Nsets regresar; 
}

void Sampler :: set_num_samples (Samps enteros const) { 
	nsamples = Samps; 
} 

Número entero Sampler :: get_num_samples () const { 
	nsamples de retorno; 
} 

Void Sampler :: clear () { 
	shuffled_indices.resize (0); 
	samples.resize (0); 
	count = salto = 0; 
} 

Sampler Sampler y operador :: = (const Sampler y s) { 
	si (este y s ==) 
		de retorno * esto; 
	nsamples = s.nsamples; 
	nsets = s.nsets; 
	count = s.count; 
	saltar = s.jump; 
	muestras = s.samples; 
	shuffled_indices = s.shuffled_indices; 
	* volver esto; 
}