int main(int Extent)
{
int Error = 0;
gli::texture2d Texture(gli::FORMAT_R8_UNORM_PACK8, gli::texture2d::extent_type(Extent));
Texture.clear(gli::u8(255));
gli::sampler2d<float> Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_NEAREST, gli::FILTER_LINEAR);
std::clock_t TimeBegin = std::clock();
for(gli::texture2d::size_type LevelIndex = 0, LevelCount = Texture.levels(); LevelIndex < LevelCount; ++LevelIndex)
{
gli::texture2d::extent_type const Extent = Texture.extent(LevelIndex);
for(gli::size_t y = 0; y < Extent.y; ++y)
for(gli::size_t x = 0; x < Extent.x; ++x)
{
gli::vec4 const& Texel = Sampler.texture_lod(glm::vec2(x, y) / glm::vec2(Extent), static_cast<float>(LevelIndex));
Error += gli::all(gli::epsilonEqual(Texel, gli::vec4(1, 0, 0, 1), 0.001f)) ? 0 : 1;
}
}
std::clock_t TimeEnd = std::clock();
printf("2D texture lod linear performance test: %d\n", TimeEnd - TimeBegin);
return Error;
}
int test()
{
int Error = 0;
{
gli::texture_cube_array Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture_cube_array::extent_type(1), 1, 1);
Texture.clear(gli::u8vec4(0, 0, 0, 255));
Texture.store(gli::texture_cube_array::extent_type(0), 0, 0, 0, gli::u8vec4(255, 0, 0, 255));
Texture.store(gli::texture_cube_array::extent_type(0), 0, 1, 0, gli::u8vec4(255, 127, 0, 255));
Texture.store(gli::texture_cube_array::extent_type(0), 0, 2, 0, gli::u8vec4(255, 255, 0, 255));
Texture.store(gli::texture_cube_array::extent_type(0), 0, 3, 0, gli::u8vec4( 0, 255, 0, 255));
Texture.store(gli::texture_cube_array::extent_type(0), 0, 4, 0, gli::u8vec4( 0, 0, 255, 255));
Texture.store(gli::texture_cube_array::extent_type(0), 0, 5, 0, gli::u8vec4(255, 0, 255, 255));
gli::fsamplerCubeArray Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_LINEAR, gli::FILTER_LINEAR, gli::vec4(1.0f));
gli::vec4 SampleA = Sampler.texture_lod(gli::fsamplerCubeArray::normalized_type(0.25f), 0, 1, 0.0f);
Error += gli::all(gli::epsilonEqual(SampleA, gli::vec4(1.0f, 0.5f, 0.0f, 1.0f), 0.01f)) ? 0 : 1;
gli::vec4 SampleB = Sampler.texture_lod(gli::fsamplerCubeArray::normalized_type(0.8f), 0, 1, 0.0f);
Error += gli::all(gli::epsilonEqual(SampleB, gli::vec4(1.0f, 0.5f, 0.0f, 1.0f), 0.01f)) ? 0 : 1;
gli::vec4 SampleC = Sampler.texture_lod(gli::fsamplerCubeArray::normalized_type(0.20f, 0.8f), 0, 1, 0.0f);
Error += gli::all(gli::epsilonEqual(SampleC, gli::vec4(1.0f, 0.5f, 0.0f, 1.0f), 0.01f)) ? 0 : 1;
}
return Error;
}
TEST(SamplerTest, ReturnCorrectSample) {
Sampler sampler = Sampler(2,2);
Sample *sample;
// 1. (0.5,0.5)
EXPECT_EQ(sampler.getSample(sample), true);
EXPECT_EQ(sample->x, 0.5);
EXPECT_EQ(sample->y, 0.5);
// 2. (1.5, 0.5)
EXPECT_EQ(sampler.getSample(sample), true);
EXPECT_EQ(sample->x, 1.5);
EXPECT_EQ(sample->y, 0.5);
// 3. (0.5, 1.5)
EXPECT_EQ(sampler.getSample(sample), true);
EXPECT_EQ(sample->x, 0.5);
EXPECT_EQ(sample->y, 1.5);
// 4. (1.5, 1.5)
EXPECT_EQ(sampler.getSample(sample), true);
EXPECT_EQ(sample->x, 1.5);
EXPECT_EQ(sample->y, 1.5);
// 5. false
EXPECT_EQ(sampler.getSample(sample), false);
}
int test()
{
int Error = 0;
{
gli::texture2D Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2D::texelcoord_type(4), 1);
Texture.clear(gli::u8vec4(0, 0, 0, 255));
Texture.store(gli::dim2_t(0, 0), 0, gli::u8vec4(255, 127, 0, 255));
Texture.store(gli::dim2_t(1, 0), 0, gli::u8vec4(255, 127, 0, 255));
Texture.store(gli::dim2_t(0, 1), 0, gli::u8vec4(255, 127, 0, 255));
Texture.store(gli::dim2_t(1, 1), 0, gli::u8vec4(255, 127, 0, 255));
Texture.store(gli::dim2_t(2, 2), 0, gli::u8vec4( 0, 127, 255, 255));
Texture.store(gli::dim2_t(3, 2), 0, gli::u8vec4( 0, 127, 255, 255));
Texture.store(gli::dim2_t(2, 3), 0, gli::u8vec4( 0, 127, 255, 255));
Texture.store(gli::dim2_t(3, 3), 0, gli::u8vec4( 0, 127, 255, 255));
gli::sampler2D<float> Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_LINEAR, gli::FILTER_LINEAR, gli::vec4(1.0f, 0.5f, 0.0f, 1.0f));
gli::vec4 SampleA = Sampler.texture_lod(gli::fsampler2D::samplecoord_type(0.25f), 0.0f);
Error += gli::all(gli::epsilonEqual(SampleA, gli::vec4(1.0f, 0.5f, 0.0f, 1.0f), 0.01f)) ? 0 : 1;
gli::vec4 SampleB = Sampler.texture_lod(gli::fsampler2D::samplecoord_type(0.8f), 0.0f);
Error += gli::all(gli::epsilonEqual(SampleB, gli::vec4(0.0f, 0.5f, 1.0f, 1.0f), 0.01f)) ? 0 : 1;
gli::vec4 SampleC = Sampler.texture_lod(gli::fsampler2D::samplecoord_type(0.20f, 0.8f), 0.0f);
Error += gli::all(gli::epsilonEqual(SampleC, gli::vec4(0.0f, 0.0f, 0.0f, 1.0f), 0.01f)) ? 0 : 1;
}
return Error;
}
void
SDLTextureRenderer::start_draw()
{
if (!m_texture)
{
const int w = m_size.width / m_downscale;
const int h = m_size.height / m_downscale;
SDL_Texture* sdl_texture = SDL_CreateTexture(m_renderer,
SDL_PIXELFORMAT_RGB888,
SDL_TEXTUREACCESS_TARGET,
w, h);
if (!sdl_texture)
{
std::stringstream msg;
msg << "Couldn't create lightmap texture: " << SDL_GetError();
throw std::runtime_error(msg.str());
}
m_texture = TexturePtr(new SDLTexture(sdl_texture, w, h, Sampler()));
}
SDL_SetRenderTarget(m_renderer, get_sdl_texture());
SDL_RenderSetScale(m_renderer,
1.0f / static_cast<float>(m_downscale),
1.0f / static_cast<float>(m_downscale));
}
int main(int Extent)
{
int Error = 0;
gli::texture2d Texture(gli::FORMAT_R8_UNORM_PACK8, gli::texture2d::extent_type(Extent));
Texture.clear(gli::u8(255));
gli::sampler2d<float> Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE);
std::clock_t TimeBegin = std::clock();
for(gli::texture2d::size_type LevelIndex = 0, LevelCount = Texture.levels(); LevelIndex < LevelCount; ++LevelIndex)
{
gli::texture2d::extent_type const Extent = Texture.extent(LevelIndex);
for(gli::size_t y = 0; y < Extent.y; ++y)
for(gli::size_t x = 0; x < Extent.x; ++x)
{
gli::vec4 const& Texel = Sampler.texel_fetch(gli::texture2d::extent_type(x, y), LevelIndex);
Error += gli::all(gli::epsilonEqual(Texel, gli::vec4(1, 0, 0, 1), 0.001f)) ? 0 : 1;
assert(!Error);
}
}
std::clock_t TimeEnd = std::clock();
printf("2D texture fetch performance test: %d\n", TimeEnd - TimeBegin);
return Error;
}
int main( int argc, char** argv )
{
if( argc != 3 )
{
printf( "%s", "Usage arguments: -play somefile.wav\n" );
return 1;
}
DEBUG( "InitDummy" );
jack_set_error_function( error );
WavReader WavFile;
WavFile.open( argv[2] );
WavFile.read( );
WavFile.close( );
WavReader * WavFilePtr = &WavFile;
SamplerClass Sampler( WavFilePtr );
SamplerClass * SamplerPtr = &Sampler;
SoundEngineClass * PolySampler = SamplerPtr;
Sampler.setSampleIterator( SamplerPtr->getSoundFile()->begin() /*- 1000000*/ );
PolySampler->OpenClient( client, "Wav Sampler" );
PolySampler->setProcessCallback( SamplerPtr->Process, SamplerPtr );
PolySampler->setSampleRateCallback( SamplerPtr->SampleRate, SamplerPtr );
PolySampler->setLeftChannelOutputPort( "DAW_LEFT_CHANNEL" );
PolySampler->setRightChannelOutputPort( "DAW_RIGHT_CHANNEL" );
PolySampler->ActivateClient( );
PolySampler->ConnectPorts( );
INFO( "Bits per sample " << *WavFile.getBitsPerSample( ) );
STATUS( "Now Playing - " << argv[2] );
INFO( "WavFile Sample Rate is: " << *WavFile.getSampleRate() );
while( !SamplerPtr->isAtEnd() )
{
sleep( 1 );
}
return 0;
}
const Sampler& MeshRendererTransparentPS::sampler(const std::string& name) const
{
if(name == std::string("tex_sampler")) return tex_sampler;
if(name == std::string("shadow_sampler")) return shadow_sampler;
ASSERT(false, "Tried to look for non-existing resource");
return Sampler();
}
int test()
{
int Error = 0;
{
gli::texture1d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture1d::extent_type(4), 1);
gli::fsampler1D Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_LINEAR, gli::FILTER_LINEAR);
}
{
gli::texture1d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture1d::extent_type(4), 1);
gli::dsampler1D Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_LINEAR, gli::FILTER_LINEAR);
}
{
gli::texture1d Texture(gli::FORMAT_RGBA8_UINT_PACK8, gli::texture1d::extent_type(4), 1);
gli::isampler1D Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_NEAREST, gli::FILTER_NEAREST);
}
return Error;
}
int test()
{
int Error = 0;
{
gli::texture2d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2d::extent_type(4), 1);
gli::sampler2d<float> Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_LINEAR, gli::FILTER_LINEAR);
}
{
gli::texture2d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2d::extent_type(4), 1);
gli::sampler2d<double> Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_LINEAR, gli::FILTER_LINEAR);
}
{
gli::texture2d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2d::extent_type(4), 1);
gli::sampler2d<int> Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_NEAREST, gli::FILTER_NEAREST);
}
return Error;
}
void Film::renderScene(Camera &c, float stepSize) {
Sampler sampler = Sampler(c);
Sample s;
while (sampler.hasNext()) {
sampler.next();
if (sampler.getSample().x < 300 && sampler.getSample().y > 100) {
commitSample(Sample());
continue;
}
s = sampler.getPixelRGBA(stepSize);
commitSample(s);
}
}
const Sampler& SSAOPS::sampler(const std::string& name) const
{
if(name == std::string("ssaoSampler")) return ssaoSampler;
if(name == std::string("depthSampler")) return depthSampler;
if(name == std::string("defaultSampler")) return defaultSampler;
ASSERT(false, "Tried to look for non-existing resource");
return Sampler();
}
int test()
{
int Error = 0;
{
gli::texture3D Texture(gli::FORMAT_RGBA8_UNORM, gli::texture3D::texelcoord_type(4), 1);
gli::sampler3D<float> Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_LINEAR, gli::FILTER_LINEAR);
}
{
gli::texture3D Texture(gli::FORMAT_RGBA8_UNORM, gli::texture3D::texelcoord_type(4), 1);
gli::sampler3D<double> Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_LINEAR, gli::FILTER_LINEAR);
}
# if ENABLE_INTEGER_TESTS
{
gli::texture3D Texture(gli::FORMAT_RGBA8_UINT, gli::texture3D::texelcoord_type(4), 1);
gli::sampler3D<int> Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_LINEAR, gli::FILTER_LINEAR);
}
# endif//ENABLE_INTEGER_TESTS
return Error;
}
int test()
{
int Error = 0;
glm::vec4 const Orange(1.0f, 0.5f, 0.0f, 1.0f);
gli::texture2D Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2D::texelcoord_type(32), 1);
gli::fsampler2D Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_LINEAR, gli::FILTER_LINEAR);
Sampler.clear(Orange);
glm::u8vec4 const Texel = Texture.load<glm::u8vec4>(gli::dim2_t(7), 0);
Error += Texel == glm::u8vec4(255, 127, 0, 255) ? 0 : 1;
return Error;
}
void resample_subimage(const SrcMetaView& src, const DstMetaView& dst,
double src_min_x, double src_min_y,
double src_max_x, double src_max_y,
double angle, const Sampler& sampler=Sampler()) {
double src_width = std::max<double>(src_max_x - src_min_x - 1,1);
double src_height = std::max<double>(src_max_y - src_min_y - 1,1);
double dst_width = std::max<double>(dst.width()-1,1);
double dst_height = std::max<double>(dst.height()-1,1);
matrix3x2<double> mat =
matrix3x2<double>::get_translate(-dst_width/2.0, -dst_height/2.0) *
matrix3x2<double>::get_scale(src_width / dst_width, src_height / dst_height)*
matrix3x2<double>::get_rotate(-angle)*
matrix3x2<double>::get_translate(src_min_x + src_width/2.0, src_min_y + src_height/2.0);
resample_pixels(src,dst,mat,sampler);
}
int test()
{
int Error = 0;
glm::f32vec4 const Orange(1.0f, 0.5f, 0.0f, 1.0f);
gli::texture2D Texture(gli::FORMAT_RGBA32_SFLOAT_PACK32, gli::texture2D::texelcoord_type(4), 1);
gli::fsampler2D Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_LINEAR, gli::FILTER_LINEAR);
Sampler.clear(Orange);
gli::f32vec4 const Texel0 = Texture.load<gli::f32vec4>(gli::dim2_t(0), 0);
gli::f32vec4 const Texel1 = Texture.load<gli::f32vec4>(gli::dim2_t(2), 0);
Error += glm::all(glm::epsilonEqual(Texel0, Orange, 0.01f)) ? 0 : 1;
Error += glm::all(glm::epsilonEqual(Texel1, Orange, 0.01f)) ? 0 : 1;
return Error;
}
int test()
{
int Error = 0;
{
gli::texture3D Texture(gli::FORMAT_RGBA8_UNORM, gli::texture3D::texelcoord_type(2), 1);
Texture.clear(gli::u8vec4(255, 127, 0, 255));
gli::fsampler3D Sampler(Texture, gli::WRAP_CLAMP_TO_EDGE, gli::FILTER_LINEAR, gli::FILTER_LINEAR);
gli::vec4 SampleA = Sampler.texture_lod(gli::fsampler3D::samplecoord_type(0.25f), 0.0f);
Error += gli::all(gli::epsilonEqual(SampleA, gli::vec4(1.0f, 0.5f, 0.0f, 1.0f), 0.01f)) ? 0 : 1;
gli::vec4 SampleB = Sampler.texture_lod(gli::fsampler3D::samplecoord_type(0.75f), 0.0f);
Error += gli::all(gli::epsilonEqual(SampleB, gli::vec4(1.0f, 0.5f, 0.0f, 1.0f), 0.01f)) ? 0 : 1;
}
return Error;
}
int test()
{
int Error(0);
glm::vec4 const Orange(1.0f, 0.5f, 0.0f, 1.0f);
glm::vec4 const Blue(0.0f, 0.5f, 1.0f, 1.0f);
gli::texture2d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2d::extent_type(32), 1);
Texture.clear(glm::packUnorm4x8(Orange));
gli::fsampler2D Sampler(Texture, gli::WRAP_REPEAT, gli::FILTER_LINEAR, gli::FILTER_LINEAR, Blue);
{
std::array<gli::fsampler2D::normalized_type, 16> SampleCoord{
{
gli::fsampler2D::normalized_type( 0.5f, 0.5f),
gli::fsampler2D::normalized_type( 0.1f, 0.1f),
gli::fsampler2D::normalized_type( 0.5f, 0.1f),
gli::fsampler2D::normalized_type( 0.1f, 0.5f),
gli::fsampler2D::normalized_type( 0.5f, 0.9f),
gli::fsampler2D::normalized_type( 0.9f, 0.9f),
gli::fsampler2D::normalized_type( 0.9f, 0.5f),
gli::fsampler2D::normalized_type( 0.1f, 0.9f),
gli::fsampler2D::normalized_type( 0.5f,-0.5f),
gli::fsampler2D::normalized_type(-0.5f,-0.5f),
gli::fsampler2D::normalized_type(-0.5f, 0.5f),
gli::fsampler2D::normalized_type( 1.5f, 0.5f),
gli::fsampler2D::normalized_type( 1.5f, 1.5f),
gli::fsampler2D::normalized_type( 0.5f, 1.5f),
gli::fsampler2D::normalized_type( 1.5f,-0.5f),
gli::fsampler2D::normalized_type(-0.5f, 1.5f)
}};
for(std::size_t i = 0, n = SampleCoord.size(); i < n; ++i)
{
gli::vec4 const Texel = Sampler.texture_lod(SampleCoord[i], 0.0f);
Error += glm::all(glm::epsilonEqual(Texel, Orange, 0.01f)) ? 0 : 1;
}
}
return Error;
}
// rareEvents() function callable from R via Rcpp -- which is essentially
// the same as main() from SMCTC's examples/rare-events/main.cc
extern "C" SEXP rareEvents(SEXP numberS, SEXP iteratesS, SEXP thresholdS, SEXP scheduleS) {
long lNumber = Rcpp::as<long>(numberS); // Number of particles
lIterates = Rcpp::as<long>(iteratesS); // Number of iterations
dThreshold = Rcpp::as<double>(thresholdS); // Rare event threshold
dSchedule = Rcpp::as<double>(scheduleS); // Annealing schedule constant
try{
///An array of move function pointers
void (*pfMoves[])(long, smc::particle<mChain<double> > &,smc::rng*) = {fMove1, fMove2};
smc::moveset<mChain<double> > Moveset(fInitialiseMC, fSelect, sizeof(pfMoves) / sizeof(pfMoves[0]), pfMoves, fMCMC);
smc::sampler<mChain<double> > Sampler(lNumber, SMC_HISTORY_RAM);
Sampler.SetResampleParams(SMC_RESAMPLE_STRATIFIED,0.5);
Sampler.SetMoveSet(Moveset);
Sampler.Initialise();
Sampler.IterateUntil(lIterates);
///Estimate the normalising constant of the terminal distribution
double zEstimate = Sampler.IntegratePathSampling(pIntegrandPS, pWidthPS, NULL) - log(2.0);
///Estimate the weighting factor for the terminal distribution
double wEstimate = Sampler.Integrate(pIntegrandFS, NULL);
// cout << zEstimate << " " << log(wEstimate) << " " << zEstimate + log(wEstimate) << endl;
Rcpp::NumericVector res = Rcpp::NumericVector::create(Rcpp::Named("zEstimate") = zEstimate,
Rcpp::Named("log(wEstimate)") = log(wEstimate),
Rcpp::Named("sum") = zEstimate + log(wEstimate));
return res;
}
catch(smc::exception e) {
Rcpp::Rcout << e; // not cerr, as R doesn't like to mix with i/o
//exit(e.lCode); // we're just called from R so we should not exit
}
return R_NilValue; // to provide a return
}
// [ref] ${SMCTC_HOME}/examples/rare-events/main.cc
void rare_events_example()
{
// Number of Particles
const long lNumber = 1000;
// An array of move function pointers
void (*pfMoves[])(long, smc::particle<mChain<double> > &, smc::rng *) = { simfunctions::fMove1, simfunctions::fMove2 };
smc::moveset<mChain<double> > Moveset(simfunctions::fInitialise, simfunctions::fSelect, sizeof(pfMoves) / sizeof(pfMoves[0]), pfMoves, simfunctions::fMCMC);
smc::sampler<mChain<double> > Sampler(lNumber, SMC_HISTORY_RAM);
Sampler.SetResampleParams(SMC_RESAMPLE_STRATIFIED, 0.5);
Sampler.SetMoveSet(Moveset);
Sampler.Initialise();
Sampler.IterateUntil(simfunctions::lIterates);
// Estimate the normalising constant of the terminal distribution
const double zEstimate = Sampler.IntegratePathSampling(simfunctions::pIntegrandPS, simfunctions::pWidthPS, NULL) - std::log(2.0);
// Estimate the weighting factor for the terminal distribution
const double wEstimate = Sampler.Integrate(simfunctions::pIntegrandFS, NULL);
std::cout << zEstimate << " " << std::log(wEstimate) << " " << zEstimate + std::log(wEstimate) << endl;
}
const Sampler& DebugViewerVS::sampler(const std::string& name) const
{
ASSERT(false, "Tried to look for non-existing resource");
return Sampler();
}
const Sampler& ClearTexture2duCS::sampler(const std::string& name) const
{
ASSERT(false, "Tried to look for non-existing resource");
return Sampler();
}
void resample_pixels(const any_image_view<SrcTypes>& src, const any_image_view<DstTypes>& dst, const MapFn& dst_to_src, Sampler sampler=Sampler()) {
apply_operation(src,dst,detail::resample_pixels_fn<Sampler,MapFn>(dst_to_src,sampler));
}
void resample_pixels(const V1& src, const any_image_view<Types2>& dst, const MapFn& dst_to_src, Sampler sampler=Sampler()) {
apply_operation(dst,bind(detail::resample_pixels_fn<Sampler,MapFn>(dst_to_src,sampler), src, _1));
}
void resample_pixels(const SrcView& src_view, const DstView& dst_view, const MapFn& dst_to_src, Sampler sampler=Sampler()) {
typename DstView::point_t dst_dims=dst_view.dimensions();
typename DstView::point_t dst_p;
//typename mapping_traits<MapFn>::result_type src_p;
for (dst_p.y=0; dst_p.y<dst_dims.y; ++dst_p.y) {
typename DstView::x_iterator xit = dst_view.row_begin(dst_p.y);
for (dst_p.x=0; dst_p.x<dst_dims.x; ++dst_p.x) {
sample(sampler, src_view, transform(dst_to_src, dst_p), xit[dst_p.x]);
}
}
}
void resize_view(const SrcMetaView& src, const DstMetaView& dst, const Sampler& sampler=Sampler()) {
resample_subimage(src,dst,0,0,src.width(),src.height(),0,sampler);
}
// Models MappingFunctionConcept
void resample_pixels_progress( const SrcView& src_view, const DstView& dst_view, const MapFn& dst_to_src, const OfxRectI& procWindow, tuttle::plugin::IProgress* p, Sampler sampler = Sampler() )
{
typename DstView::point_t dst_p;
typename DstView::value_type black;
color_convert( boost::gil::rgba32f_pixel_t( 0.0, 0.0, 0.0, 0.0 ), black );
for( dst_p.y = procWindow.y1; dst_p.y < procWindow.y2; ++dst_p.y )
{
typename DstView::x_iterator xit = dst_view.row_begin( dst_p.y );
for( dst_p.x = procWindow.x1; dst_p.x < procWindow.x2; ++dst_p.x )
{
if( !boost::gil::sample( sampler, src_view, transform( dst_to_src, dst_p ), xit[dst_p.x] ) )
{
xit[dst_p.x] = black; // if it is outside of the source image
}
}
if( p->progressForward() )
return;
}
}
double Spectral_CompareSignals(signal_t *signal1_in, signal_t *signal2_in, int windowing)
{
signal_t *sig1 = NULL, *sig2 = NULL;
signal_t *sig1_sampled = NULL, *sig2_sampled = NULL;
spectral_time_t samplingRate = 0;
int x1, x2, x3;
double y1, y2, y3;
double similarity;
char *dbg_cross_both = NULL;
char *dbg_autocross1 = NULL;
char *dbg_autocross2 = NULL;
#if defined DEBUG_MODE
dbg_cross_both = "cross_sig1_sig2.txt";
dbg_autocross1 = "autocross_sig1.txt";
dbg_autocross1 = "autocross_sig2.txt";
#endif
if ((signal1_in == NULL) || (signal2_in == NULL)) return 0;
/* XXX Input signals are copied because shifting and windowing modifies them (deleted at exit) */
sig1 = Spectral_CloneSignal( signal1_in );
sig2 = Spectral_CloneSignal( signal2_in );
Spectral_ShiftSignal( sig1 );
Spectral_ShiftSignal( sig2 );
if (windowing != WINDOWING_NONE)
{
applyWindowing( sig1, windowing );
applyWindowing( sig2, windowing );
}
#if defined DEBUG_MODE
Spectral_DumpSignal(sig1, "comp_sig1_shift.txt");
Spectral_DumpSignal(sig2, "comp_sig2_shift.txt");
#endif
samplingRate = _SPECTRAL_MAX(
Spectral_GetSignalSamplingRate(sig1, 1000),
Spectral_GetSignalSamplingRate(sig2, 1000));
//sig1_sampled = Sampler(sig1, (spectral_time_t)5000000);
//sig2_sampled = Sampler(sig2, (spectral_time_t)5000000);
sig1_sampled = Sampler(sig1, (spectral_time_t)samplingRate, NULL);
sig2_sampled = Sampler(sig2, (spectral_time_t)samplingRate, NULL);
Crosscorrelation(sig1_sampled, sig1_sampled, dbg_autocross1, &x1, &y1);
Crosscorrelation(sig2_sampled, sig2_sampled, dbg_autocross2, &x2, &y2);
Crosscorrelation(sig1_sampled, sig2_sampled, dbg_cross_both, &x3, &y3);
/* x's -- points where sig1 is more similar to sig2
* y's -- value of the crosscorrelation
*/
similarity = sqrt(pow(y3,2)/(y1 * y2));
Spectral_FreeSignal(sig1_sampled);
Spectral_FreeSignal(sig2_sampled);
Spectral_FreeSignal(sig1);
Spectral_FreeSignal(sig2);
return similarity;
}
Sampler sample() const { return Sampler(values, samples, cmp, num_samples); }
Settings PhotonMapper(int sampleCount)
{
return Settings(Integrator("photonmapper", sampleCount > 32, sampleCount < 1),
Sampler("ldsampler", sampleCount));
}
