int main(int argc, char *argv[] ) { ros::init(argc, argv, "histogram_segmentation"); //initialize with a default name ros::NodeHandle nh("~"); //use node name as sufix of the namespace nh.param<int>("threshold", threshold, 254); nh.param<int>("dilate_iterations", dilate_iterations, 9); nh.param<int>("dilate_size", dilate_size, 7); nh.param<int>("erode_iterations", erode_iterations, 0); nh.param<int>("erode_size", erode_size, 3); if(argc < 2) { ROS_ERROR("Histogram segmentation needs a template to search for. Please provide it as a command line argument."); return -1; } std::string template_path(argv[1]); ROS_INFO("%s", template_path.c_str()); cv::Mat raw_template = cv::imread(template_path); target_hist = pal_vision_util::calcHSVHist(raw_template); cv::normalize(target_hist, target_hist, 0, 255, cv::NORM_MINMAX, -1, cv::Mat()); image_transport::ImageTransport it(nh); image_transport::Subscriber rect_sub = it.subscribe("/image", 1, &imageCb); image_pub = it.advertise("image_masked", 1); mask_pub = it.advertise("mask", 1); debug_pub = it.advertise("debug",1); dynamic_reconfigure::Server<pal_vision_segmentation::HistogramSegmentConfig> server; dynamic_reconfigure::Server<pal_vision_segmentation::HistogramSegmentConfig>::CallbackType f; f = boost::bind(&reconf_callback, _1, _2); server.setCallback(f); ros::spin(); }
int main(int argc, char **argv) { /**********************************/ /* Program options */ /**********************************/ // Need to specify elevation grid // Need to specify channel std::string map_file; std::string template_file; std::string output_file_depth; std::string output_file_proportion; bool ignore_na = false; bool do_max = false; bool majority = false; // namespace prog_opt = boost::program_options; namespace fs = boost::filesystem; namespace raster_util = blink::raster; prog_opt::options_description desc("Allowed options"); desc.add_options() ("help,h", "produce help message") ("map,m", prog_opt::value<std::string>(&map_file), "path of the gdal capatible raster for aggregating") ("template,t", prog_opt::value<std::string>(&template_file), "path of the gdal capatible raster which works as a template (output raster will have same extent and cell size as template)") ("depth-out,d", prog_opt::value<std::string>(&output_file_depth)->default_value("aggregated-depth.tif"), "path where the output gtif raster of depth is saved") ("proportion-out,p", prog_opt::value<std::string>(&output_file_proportion)->default_value("aggregated-proportion.tif"), "path where the output gtif raster of proportion flooded is saved") ("maximum,x", "use maximum statistic, rather than average") ("majority,a", "only assign value if majority of cells are not noValue") ("ignore-na,i", "ignore pixels with nodata when taking statistic"); prog_opt::variables_map vm; prog_opt::store(prog_opt::parse_command_line(argc, argv, desc), vm); prog_opt::notify(vm); if (vm.count("help")) { std::cout << desc << "\n"; return 1; } if (vm.count("maximum")) { do_max = true; } if (vm.count("ignore-na")) { ignore_na = true; } if (vm.count("majority")) { majority = true; } fs::path map_path(map_file); fs::path template_path(template_file); fs::path output_path_depth(output_file_depth); fs::path output_path_proportion(output_file_proportion); // Check file exists if (!fs::exists(map_path)) { std::stringstream ss; ss << map_path << " does not exist"; throw std::runtime_error(ss.str()); return (EXIT_FAILURE); } if (!fs::exists(template_path)) { std::stringstream ss; ss << template_path << " does not exist"; throw std::runtime_error(ss.str()); return (EXIT_FAILURE); } /**********************************/ /* Read in maps */ /**********************************/ std::cout << "\n\n*************************************\n"; std::cout << "* Read in maps *\n"; std::cout << "*************************************" << std::endl; auto template_m = raster_util::open_gdal_raster<double>(template_path, GA_ReadOnly); auto map = raster_util::open_gdal_raster<double>(map_path, GA_ReadOnly); /********************************************/ /* Assign memory for output map */ /********************************************/ std::cout << "\n\n**************************************\n"; std::cout << "* Assign memory for output maps *\n"; std::cout << "**************************************" << std::endl; auto output_map_depth = raster_util::create_gdal_raster_from_model<double>(output_path_depth, template_m); auto output_map_proportion = raster_util::create_gdal_raster_from_model<double>(output_path_proportion, template_m); aggregateMaps(map, template_m, output_map_depth, output_map_proportion, ignore_na, do_max, majority); return (EXIT_SUCCESS); }
void FolderShaper::MoveCopyTemplate (entry_ref * a_template_ref, bool a_move) { BEntry template_entry; template_entry.SetTo (a_template_ref, true); // traverse, if link (future proof) template_entry.GetRef (a_template_ref); BString template_name = a_template_ref->name; // name of dropped template BPath template_path (& template_entry); BString template_path_string = template_path.Path(); // path of dropped template NameSafe(& template_path_string); BPath templates_folder_path (m_tmpl_dir, NULL); // path of template folder BString templates_folder_string = templates_folder_path.Path(); //NameSafe(& templates_folder_string); // not yet, we want the new name in first // create a new name that is unique in the Template folder BString new_target_name = a_template_ref->name; int32 counter = 2; m_tmpl_dir->Rewind(); while(m_tmpl_dir->Contains(new_target_name.String())) { new_target_name = a_template_ref->name; new_target_name.Append(" "); new_target_name << counter; counter ++; } BString target_template_path_string = templates_folder_string; target_template_path_string. Append("/"); target_template_path_string. Append(new_target_name); NameSafe(& target_template_path_string); // DEBUG PRINT(("template_name: %s\n", template_name.String())); PRINT(("new_target_name: %s\n", new_target_name.String())); PRINT(("template_path_string: %s\n", template_path_string.String())); PRINT(("templates_folder_string: %s\n", templates_folder_string.String())); PRINT(("target_template_path_string: %s\n", target_template_path_string.String())); if (a_move) // Move { // find a temp name that's in neither of the source/target folders BString unique_name = a_template_ref->name; BDirectory source_dir(templates_folder_string.String()); counter = 2; while( source_dir.Contains(unique_name.String()) || m_tmpl_dir->Contains(unique_name.String()) ) { unique_name = a_template_ref->name; unique_name.Append(" "); unique_name << counter; counter ++; } PRINT(("unique_name: %s\n", unique_name.String())); template_entry.Rename(unique_name.String()); template_entry.MoveTo(m_tmpl_dir); } else // Copy { BString command = "copyattr -d -r "; command.Append(template_path_string); command.Append(" "); command.Append(target_template_path_string); system(command.String()); } }
banner_t * banner_new_from_file(const char *filename, int *num_options, cups_option_t **options) { FILE *f; char *line = NULL; size_t len = 0; int linenr = 0; banner_t *banner = NULL; if (!strcmp(filename, "-")) f = stdin; else if (!(f = fopen(filename, "r"))) { perror("Error opening banner file"); goto out; } if (getline(&line, &len, f) == -1 || strncmp(line, "#PDF-BANNER", 11) != 0) goto out; banner = calloc(1, sizeof *banner); while (getline(&line, &len, f) != -1) { char *key, *value; linenr++; if (!parse_line(line, &key, &value)) continue; if (!value) { fprintf(stderr, "error: line %d is missing a value\n", linenr); continue; } if (!strcasecmp(key, "template")) banner->template_file = template_path(value); else if (!strcasecmp(key, "header")) banner->header = strdup(value); else if (!strcasecmp(key, "footer")) banner->header = strdup(value); else if (!strcasecmp(key, "font")) { *num_options = cupsAddOption("banner-font", strdup(value), *num_options, options); } else if (!strcasecmp(key, "font-size")) { *num_options = cupsAddOption("banner-font-size", strdup(value), *num_options, options); } else if (!strcasecmp(key, "show")) banner->infos = parse_show(value); else if (!strcasecmp(key, "image") || !strcasecmp(key, "notice")) fprintf(stderr, "note:%d: bannertopdf does not support '%s'\n", linenr, key); else fprintf(stderr, "error:%d: unknown keyword '%s'\n", linenr, key); } /* load default template if none was specified */ if (!banner->template_file) banner->template_file = template_path ("default.pdf"); out: free(line); if (f) fclose(f); return banner; }
status_t FolderShaper::ShapeRef (entry_ref * a_ref, const char * a_template, bool a_do_open) { PRINT(("ShapeRef(%s, %s)\n", a_ref->name, a_template)); status_t status; // store original_name BEntry original_entry (a_ref, true); original_entry. GetRef (a_ref); BString original_name = a_ref->name; BPath original_path (& original_entry); BString original_path_string = original_path.Path(); NameSafe(& original_path_string); BPath original_parent_path; original_path.GetParent(& original_parent_path); BDirectory parent_dir(original_parent_path.Path()); // temp name BString new_name = a_ref->name; new_name.Prepend("New "); int32 counter = 2; while(parent_dir.Contains(new_name.String())) { new_name = a_ref->name; new_name.Append(" (temporary "); new_name << counter; new_name.Append(")"); counter ++; } PRINT(("original_name: %s\n", original_name.String())); PRINT(("new_name: %s\n", new_name.String())); PRINT(("original_path: %s\n", original_path.Path())); PRINT(("original_path_string: %s\n", original_path_string.String())); PRINT(("original_parent_path: %s\n", original_parent_path.Path())); BPath template_path (m_tmpl_dir, a_template); BEntry tmp_entry; // traverse link to template if ((status = tmp_entry.SetTo(template_path.Path(), true)) != B_OK) { // message return status; } template_path.SetTo(& tmp_entry); BString template_path_string = template_path.Path(); NameSafe(& template_path_string); PRINT(("template_path_string: %s\n", template_path_string.String())); BPath new_path (original_parent_path.Path(), new_name.String()); BString new_path_string = new_path.Path(); NameSafe(& new_path_string); PRINT(("new_path_string: %s\n", new_path_string.String())); BString command; if(m_do_keep_position) { // copy X/Y position attribute from Original Folder command = "copyattr -n _trk/pinfo_le "; command.Append(original_path_string); command.Append(" "); command.Append(template_path_string); PRINT(("copy X/Y position: \n%s\n", command.String())); system(command.String()); } else { BNode template_node(& tmp_entry); template_node.RemoveAttr("_trk/pinfo_le"); } // copy template -> "New name" (temp) command = "copyattr -d -r "; command.Append(template_path_string); command.Append(" "); command.Append(new_path_string); PRINT(("copy template -> temp: \n%s\n", command.String())); system(command.String()); // New folder exists? BDirectory new_directory; if((status = new_directory.SetTo(new_path.Path())) != B_OK) { ErrorMessage("new_directory.SetTo() ", status); // ... probably want a BAlert return status; } BDirectory original_dir; if((status = original_dir.SetTo(original_path.Path())) != B_OK) { ErrorMessage("original_dir.SetTo() ", status); // ... probably want a BAlert return status; } // Move stuff from original folder to new folder BEntry original_content_entry; while(original_dir.GetNextEntry(&original_content_entry) == B_OK) { if ((status = original_content_entry .MoveTo(& new_directory, NULL, ! m_do_clobber)) != B_OK && (status != B_FILE_EXISTS || (! m_do_clobber) == true)) { ErrorMessage("original_content_entry.MoveTo() ", status); return status; // ... definitely needs a fat BAlert } } // Move original folder to Trash // alt. // Delete bool was_open = false; if (m_do_move) { // Is Folder Open ? was_open = IsFolderOpen(a_ref); // Close Original Folder status = MoveRefToTrash(a_ref); // This calls Tracker to move the ref. // If the folder is open, Tracker will close it. for (int j = 0; j < 250; j++) { PRINT(("loop: %d\n", j)); if (original_entry.Exists() == false) break; snooze(20000); // give Tracker some Time to Move // .... consider using node-monitoring instead to // catch when Tracker has moved the folder to Trash } } else { status = original_entry.Remove(); if (status != B_OK) { ErrorMessage("original_content_entry.MoveTo() ", status); // BAlert.. Could not remove original folder // return status; } } // Rename New Folder -> Original Name BEntry new_entry(new_path.Path()); status = new_entry.Rename(original_name.String()); if (status != B_OK) ErrorMessage("new_entry.Rename() ", status); entry_ref new_ref; status = new_entry.GetRef(& new_ref); if (status != B_OK) ErrorMessage("new_entry.GetRef() ", status); // Open New Folder if (was_open) PRINT(("was_open == true\n")); if (! was_open) PRINT(("was_open == false\n")); if (((m_do_open == FS_IF_ORIGINAL_OPEN) && was_open) || m_do_open == FS_ALWAYS_OPEN) { // open folder command = original_path_string; command.Prepend("/boot/system/Tracker "); command.Append(" &"); system(command.String()); // wait for new folder to open WaitForOpeningFolder(& new_ref); // Clean Up All if (m_do_clean_up) CleanUpWindow(& new_ref); } return B_OK; }