// OPTIMIZE mdarray_float convolve(const mdarray_float &src, const mdarray_float &kernel, int cx, int cy) { mdarray_float convolved(false, src.length(0), src.length(1)); #pragma omp parallel #pragma omp for for (int y = 0; y < src.length(1); y++) for (int x = 0; x < src.length(0); x++) { double s = 0.; for (int yy = 0; yy < kernel.length(1); yy++) for (int xx = 0; xx < kernel.length(0); xx++) { s += kernel(xx, yy) * src(x + xx - cx, y + yy - cy); } convolved(x, y) = s; } return convolved; }
double MyModel_Pixels::calculate_total_flux(double time) const { double speed = 1.0/timescale; double offset = x0 + speed*time; int j = (int)floor((offset - (x_min + 0.5*dx))/dx); return convolved(ni/2, j%nj); }
std::vector<float> WindowFunction::convolve( const std::vector<float>& input, const std::vector<float>& window ) const { unsigned int inputSize = input.size(); unsigned int padding = window.size() / 2; std::vector<float> convolved(inputSize, 0.0); // TODO: this implements zero padding for boundary effects, // write something mean-based later. for (unsigned int sample = 0; sample < inputSize; sample++) { float convolution = 0.0; for (unsigned int k = 0; k < window.size(); k++) { int frm = (signed)sample - (signed)padding + (signed)k; if (frm >= 0 && frm < (signed)inputSize) // don't run off either end convolution += input[frm] * window[k] / window.size(); } convolved[sample] = convolution; } return convolved; }
void MyModel_Pixels::calculate_obscurer_map() { // Obscurer image for(size_t j=0; j<nj; ++j) for(size_t i=0; i<ni; ++i) obscurer_map(i, j) = exp(-sd*n(i, j)); // FFT of obscurer_map arma::cx_mat A = arma::fft2(obscurer_map); // (FFT of obscurer map)*(FFT of star map) for(size_t j=0; j<nj; ++j) for(size_t i=0; i<ni; ++i) A(i, j) *= fft_of_star(i, j); // obscurer map convolved with star map A = arma::ifft2(A); for(size_t i=0; i<ni; ++i) for(size_t j=0; j<nj; ++j) convolved(i, j) = A(i, j).real(); }
int main(int argc, char *argv[]) { if (argc != 4) { cout << "Usage: " << argv[0] << " cpu|gpu out_func out_prefix" << endl; return 1; } ImageParam input(UInt(8), 3, "input"); Func clamped("clamped"); Func convolved("convolved"); Func sharpen("sharpen"); Var c("c"), x("x"), y("y"); // Algorithm clamped(x, y, c) = input( clamp(x, 0, input.width()-1), clamp(y, 0, input.height()-1), c) / 255.f; Image<int16_t> kernel(3, 3); kernel(0, 0) = -1; kernel(0, 1) = -1; kernel(0, 2) = -1; kernel(1, 0) = -1; kernel(1, 1) = 8; kernel(1, 2) = -1; kernel(2, 0) = -1; kernel(2, 1) = -1; kernel(2, 2) = -1; RDom r(kernel); convolved(x, y, c) += kernel(r.x, r.y) * clamped(x + r.x - 1, y + r.y - 1, c); sharpen(x, y, c) = u8( clamp(convolved(x, y, c)/8 + clamped(x, y, c), 0, 1) * 255 ); // Channel order input.set_stride(0, 4); input.set_extent(2, 4); sharpen.reorder_storage(c, x, y); sharpen.output_buffer().set_stride(0, 4); sharpen.output_buffer().set_extent(2, 4); // Schedules if (!strcmp(argv[1], "cpu")) { sharpen.parallel(y).vectorize(c, 4); } else if (!strcmp(argv[1], "gpu")) { sharpen.cuda_tile(x, y, 16, 4); } else { cout << "Invalid schedule type '" << argv[1] << "'" << endl; return 1; } compile(sharpen, input, argv[2], argv[3]); return 0; }
int main (int argc, char ** argv) { int viewport_source, viewport_convolved = 0; int direction = -1; int nb_threads = 0; char border_policy = 'Z'; double threshold = 0.001; pcl::filters::Convolution<pcl::PointXYZRGB, pcl::PointXYZRGB> convolution; Eigen::ArrayXf gaussian_kernel(5); gaussian_kernel << 1.f/16, 1.f/4, 3.f/8, 1.f/4, 1.f/16; pcl::console::print_info ("convolution kernel:"); for (int i = 0; i < gaussian_kernel.size (); ++i) pcl::console::print_info (" %f", gaussian_kernel[i]); pcl::console::print_info ("\n"); if (argc < 3) { usage (argv); return 1; } // check if user is requesting help std::string arg (argv[1]); if (arg == "--help" || arg == "-h") { usage (argv); return 1; } // user don't need help find convolving direction // convolve row if (pcl::console::find_switch (argc, argv, "-r")) direction = 0; else { // convolve column if (pcl::console::find_switch (argc, argv, "-c")) direction = 1; else // convolve both if (pcl::console::find_switch (argc, argv, "-s")) direction = 2; else { // wrong direction given print usage usage (argv); return 1; } } // number of threads if any if (pcl::console::parse_argument (argc, argv, "-t", nb_threads) != -1 ) { if (nb_threads <= 0) nb_threads = 1; } convolution.setNumberOfThreads (nb_threads); // borders policy if any if (pcl::console::parse_argument (argc, argv, "-p", border_policy) != -1 ) { switch (border_policy) { case 'Z' : convolution.setBordersPolicy (pcl::filters::Convolution<pcl::PointXYZRGB, pcl::PointXYZRGB>::BORDERS_POLICY_IGNORE); break; case 'M' : convolution.setBordersPolicy (pcl::filters::Convolution<pcl::PointXYZRGB, pcl::PointXYZRGB>::BORDERS_POLICY_MIRROR); break; case 'D' : convolution.setBordersPolicy (pcl::filters::Convolution<pcl::PointXYZRGB, pcl::PointXYZRGB>::BORDERS_POLICY_DUPLICATE); break; default : { usage (argv); return (1); } } } else convolution.setBordersPolicy (pcl::filters::Convolution<pcl::PointXYZRGB, pcl::PointXYZRGB>::BORDERS_POLICY_IGNORE); // distance threshold if any if (pcl::console::parse_argument (argc, argv, "-d", threshold) == -1 ) { threshold = 0.01; } convolution.setDistanceThreshold (static_cast<float> (threshold)); // all set // we have file name and convolving direction pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZRGB> ()); if (pcl::io::loadPCDFile (argv[1], *cloud) == -1) { pcl::console::print_error ("Couldn't read file %s \n", argv[1]); return (-1); } cloud->is_dense = false; convolution.setInputCloud (cloud); convolution.setKernel (gaussian_kernel); pcl::PointCloud<pcl::PointXYZRGB>::Ptr convolved (new pcl::PointCloud<pcl::PointXYZRGB> ()); double t0; pcl::console::print_info ("convolving %s along \n", argv[1]); std::ostringstream convolved_label; convolved_label << "convolved along "; switch (direction) { case 0: { convolved_label << "rows... "; t0 = pcl::getTime (); convolution.convolveRows (*convolved); break; } case 1: { convolved_label << "columns... "; t0 = pcl::getTime (); convolution.convolveCols (*convolved); break; } case 2: { convolved_label << "rows and columns... "; t0 = pcl::getTime (); convolution.convolve (*convolved); break; } } convolved_label << pcl::getTime () - t0 << "s"; // Display boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer (new pcl::visualization::PCLVisualizer ("Convolution")); // viewport stuff viewer->createViewPort (0, 0, 0.5, 1, viewport_source); viewer->createViewPort (0.5, 0, 1, 1, viewport_convolved); viewer->setBackgroundColor (0, 0, 0); // Source pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> color_handler_source (cloud); viewer->addPointCloud<pcl::PointXYZRGB> (cloud, color_handler_source, "source", viewport_source); viewer->addText ("source", 10, 10, "source_label", viewport_source); // Convolved pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> color_handler_convolved (convolved); viewer->addPointCloud<pcl::PointXYZRGB> (convolved, color_handler_convolved, "convolved", viewport_convolved); viewer->addText (convolved_label.str (), 10, 10, "convolved_label", viewport_convolved); viewer->spin (); pcl::PCDWriter writer; writer.write<pcl::PointXYZRGB> ("convolved.pcd", *convolved, false); }