typename Kernel::Model MaxConsensus ( const Kernel &kernel, const Scorer &scorer, std::vector<uint32_t> *best_inliers = nullptr, uint32_t max_iteration = 1024 ) { const uint32_t min_samples = Kernel::MINIMUM_SAMPLES; const uint32_t total_samples = kernel.NumSamples(); size_t best_num_inliers = 0; typename Kernel::Model best_model; // Test if we have sufficient points to for the kernel. if (total_samples < min_samples) { if (best_inliers) { best_inliers->resize(0); } return best_model; } // In this robust estimator, the scorer always works on all the data points // at once. So precompute the list ahead of time. std::vector<uint32_t> all_samples(total_samples); std::iota(all_samples.begin(), all_samples.end(), 0); // Random number generator configuration std::mt19937 random_generator(std::mt19937::default_seed); std::vector<uint32_t> sample; for (uint32_t iteration = 0; iteration < max_iteration; ++iteration) { UniformSample(min_samples, random_generator, &all_samples, &sample); std::vector<typename Kernel::Model> models; kernel.Fit(sample, &models); // Compute costs for each fit. for (const auto& model_it : models) { std::vector<uint32_t> inliers; scorer.Score(kernel, model_it, all_samples, &inliers); if (best_num_inliers < inliers.size()) { best_num_inliers = inliers.size(); best_model = model_it; if (best_inliers) { best_inliers->swap(inliers); } } } } return best_model; }
typename Kernel::Model RANSAC( const Kernel &kernel, const Scorer &scorer, std::vector<size_t> *best_inliers = nullptr , size_t *best_score = nullptr , // Found number of inliers double outliers_probability = 1e-2) { assert(outliers_probability < 1.0); assert(outliers_probability > 0.0); size_t iteration = 0; const size_t min_samples = Kernel::MINIMUM_SAMPLES; const size_t total_samples = kernel.NumSamples(); size_t max_iterations = 100; const size_t really_max_iterations = 4096; size_t best_num_inliers = 0; double best_inlier_ratio = 0.0; typename Kernel::Model best_model; // Test if we have sufficient points for the kernel. if (total_samples < min_samples) { if (best_inliers) { best_inliers->resize(0); } return best_model; } // In this robust estimator, the scorer always works on all the data points // at once. So precompute the list ahead of time [0,..,total_samples]. std::vector<size_t> all_samples(total_samples); std::iota(all_samples.begin(), all_samples.end(), 0); std::vector<size_t> sample; for (iteration = 0; iteration < max_iterations && iteration < really_max_iterations; ++iteration) { UniformSample(min_samples, &all_samples, &sample); std::vector<typename Kernel::Model> models; kernel.Fit(sample, &models); // Compute the inlier list for each fit. for (size_t i = 0; i < models.size(); ++i) { std::vector<size_t> inliers; scorer.Score(kernel, models[i], all_samples, &inliers); if (best_num_inliers < inliers.size()) { best_num_inliers = inliers.size(); best_inlier_ratio = inliers.size() / double(total_samples); best_model = models[i]; if (best_inliers) { best_inliers->swap(inliers); } } if (best_inlier_ratio) { max_iterations = IterationsRequired(min_samples, outliers_probability, best_inlier_ratio); } } } if (best_score) *best_score = best_num_inliers; return best_model; }
bool OpenEXRInput::read_native_deep_tiles (int xbegin, int xend, int ybegin, int yend, int zbegin, int zend, int chbegin, int chend, DeepData &deepdata) { if (m_deep_tiled_input_part == NULL) { error ("called OpenEXRInput::read_native_deep_tiles without an open file"); return false; } try { const PartInfo &part (m_parts[m_subimage]); size_t width = (xend - xbegin); size_t npixels = width * (yend - ybegin) * (zend - zbegin); chend = clamp (chend, chbegin+1, m_spec.nchannels); int nchans = chend - chbegin; // Set up the count and pointers arrays and the Imf framebuffer std::vector<TypeDesc> channeltypes; m_spec.get_channelformats (channeltypes); deepdata.init (npixels, nchans, array_view<const TypeDesc>(&channeltypes[chbegin], chend-chbegin), spec().channelnames); std::vector<unsigned int> all_samples (npixels); std::vector<void*> pointerbuf (npixels * nchans); Imf::DeepFrameBuffer frameBuffer; Imf::Slice countslice (Imf::UINT, (char *)(&all_samples[0] - xbegin - ybegin*width), sizeof(unsigned int), sizeof(unsigned int) * width); frameBuffer.insertSampleCountSlice (countslice); for (int c = chbegin; c < chend; ++c) { Imf::DeepSlice slice (part.pixeltype[c], (char *)(&pointerbuf[0]+(c-chbegin) - xbegin*nchans - ybegin*width*nchans), sizeof(void*) * nchans, // xstride of pointer array sizeof(void*) * nchans*width, // ystride of pointer array deepdata.samplesize()); // stride of data sample frameBuffer.insert (m_spec.channelnames[c].c_str(), slice); } m_deep_tiled_input_part->setFrameBuffer (frameBuffer); int xtiles = round_to_multiple (xend-xbegin, m_spec.tile_width) / m_spec.tile_width; int ytiles = round_to_multiple (yend-ybegin, m_spec.tile_height) / m_spec.tile_height; int firstxtile = (xbegin - m_spec.x) / m_spec.tile_width; int firstytile = (ybegin - m_spec.y) / m_spec.tile_height; // Get the sample counts for each pixel and compute the total // number of samples and resize the data area appropriately. m_deep_tiled_input_part->readPixelSampleCounts ( firstxtile, firstxtile+xtiles-1, firstytile, firstytile+ytiles-1); deepdata.set_all_samples (all_samples); deepdata.get_pointers (pointerbuf); // Read the pixels m_deep_tiled_input_part->readTiles ( firstxtile, firstxtile+xtiles-1, firstytile, firstytile+ytiles-1, m_miplevel, m_miplevel); } catch (const std::exception &e) { error ("Failed OpenEXR read: %s", e.what()); return false; } catch (...) { // catch-all for edge cases or compiler bugs error ("Failed OpenEXR read: unknown exception"); return false; } return true; }
bool OpenEXRInput::read_native_deep_scanlines (int ybegin, int yend, int z, int chbegin, int chend, DeepData &deepdata) { if (m_deep_scanline_input_part == NULL) { error ("called OpenEXRInput::read_native_deep_scanlines without an open file"); return false; } #ifdef USE_OPENEXR_VERSION2 try { const PartInfo &part (m_parts[m_subimage]); size_t npixels = (yend - ybegin) * m_spec.width; chend = clamp (chend, chbegin+1, m_spec.nchannels); int nchans = chend - chbegin; // Set up the count and pointers arrays and the Imf framebuffer std::vector<TypeDesc> channeltypes; m_spec.get_channelformats (channeltypes); deepdata.init (npixels, nchans, array_view<const TypeDesc>(&channeltypes[chbegin], chend-chbegin), spec().channelnames); std::vector<unsigned int> all_samples (npixels); std::vector<void*> pointerbuf (npixels*nchans); Imf::DeepFrameBuffer frameBuffer; Imf::Slice countslice (Imf::UINT, (char *)(&all_samples[0] - m_spec.x - ybegin*m_spec.width), sizeof(unsigned int), sizeof(unsigned int) * m_spec.width); frameBuffer.insertSampleCountSlice (countslice); for (int c = chbegin; c < chend; ++c) { Imf::DeepSlice slice (part.pixeltype[c], (char *)(&pointerbuf[0]+(c-chbegin) - m_spec.x * nchans - ybegin*m_spec.width*nchans), sizeof(void*) * nchans, // xstride of pointer array sizeof(void*) * nchans*m_spec.width, // ystride of pointer array deepdata.samplesize()); // stride of data sample frameBuffer.insert (m_spec.channelnames[c].c_str(), slice); } m_deep_scanline_input_part->setFrameBuffer (frameBuffer); // Get the sample counts for each pixel and compute the total // number of samples and resize the data area appropriately. m_deep_scanline_input_part->readPixelSampleCounts (ybegin, yend-1); deepdata.set_all_samples (all_samples); deepdata.get_pointers (pointerbuf); // Read the pixels m_deep_scanline_input_part->readPixels (ybegin, yend-1); // deepdata.import_chansamp (pointerbuf); } catch (const std::exception &e) { error ("Failed OpenEXR read: %s", e.what()); return false; } catch (...) { // catch-all for edge cases or compiler bugs error ("Failed OpenEXR read: unknown exception"); return false; } return true; #else return false; #endif }