int main(int argc, char* argv[]) { std::string image_dir; if(argc!=2) { std::cout << "Usage :" << std::endl << " " << argv[0] << " <directory>" << std::endl << "ex : " << argv[0] << " /usr/share/mirage-images" << std::endl; return 1; } image_dir = argv[1]; try { ImageRGB24 source,result; ImageInt filter; mirage::Init(); // Here, we play with border effects. // We load an image from filename. mirage::img::JPEG::read(source,image_dir+"/spiderman.jpg"); std::cout << "Generating spiderman.jpg" << std::endl; mirage::img::JPEG::write(source,"spiderman.jpg",75); // We create a bigger image result.resize(source._dimension*2.5); // We create a filter filter.resize(source._dimension/2); filter = 0; // All values are 0. *(filter.begin()) = 1; // upper left is 1. // Let us try the default out frame policy. source.setPolicy(new mirage::ZeroOutFramePolicy<ImageRGB24>()); // This will generates an error message (and is inefficient), // since optimized convolution needs source and result images // having the same size. OptimizedConvolution(source,filter,result); // This will generates an error message (and is inefficient), // since optimized convolution (involved by the template) needs // source and result images having the same size. mirage::colorspace::Convolution<ImageRGB24,ImageInt,ImageRGB24>::RGB::Process(source,filter,result); // And last, the good one for this border-effect example Convolution(source,filter,result); std::cout << "Generating spiderman-zero.jpg" << std::endl; mirage::img::JPEG::write(result,"spiderman-zero.jpg",75); // Let us try other out frame policies. source.setPolicy(new mirage::ClosePointOutFramePolicy<ImageRGB24>()); Convolution(source,filter,result); std::cout << "Generating spiderman-close-point.jpg" << std::endl; mirage::img::JPEG::write(result,"spiderman-close-point.jpg",75); source.setPolicy(new mirage::PeriodicOutFramePolicy<ImageRGB24>()); Convolution(source,filter,result); std::cout << "Generating spiderman-periodic.jpg" << std::endl; mirage::img::JPEG::write(result,"spiderman-periodic.jpg",75); source.setPolicy(new mirage::SymetricOutFramePolicy<ImageRGB24>()); Convolution(source,filter,result); std::cout << "Generating spiderman-symetric.jpg" << std::endl; mirage::img::JPEG::write(result,"spiderman-symetric.jpg",75); // Now, we know how to filter images. Let us try to apply // ready-to-use mirage filters. mirage::img::JPEG::read(source,image_dir+"/shrek.jpg"); std::cout << "Generating shrek.jpg" << std::endl; mirage::img::JPEG::write(source,"shrek.jpg",75); // We can get the vertical sobel filter in an ImageInt data. ImageInt sobel_vert; ImageInt::iterator sobel_vert_iter, sobel_vert_iter_end; int w,sobel_vert_width; mirage::img::Filter<int>::Sobel::Vertical(sobel_vert); sobel_vert_width = sobel_vert._dimension[0]; std::cout << "Sobel vertical filter :" << std::endl; for(sobel_vert_iter=sobel_vert.begin(),sobel_vert_iter_end=sobel_vert.end(); sobel_vert_iter != sobel_vert_iter_end; std::cout << std::endl) for(w=0; w<sobel_vert_width; ++sobel_vert_iter,++w) std::cout << std::setw(3) << *sobel_vert_iter << ' '; // Nevertheless, we can set up the sobel filtering with a set of // predifine functions, that allocates the sobel filter obtenied // here internally. These are available for RGB and Gray, on 2D // frames. mirage::SubFrame<ImageRGB24> subimage(source,mirage::img::Coordinate(0,0),source._dimension/2); ImageRGBDouble sobel_result; // Template parameters are static-flag, source type, destination // type. No buffering would have has some strange // effects since source image would have changed during the // filtering process. // // The first parameter, the static flag, is set to 1 since we want // to use static data for intermediate computations (this avoids // many reallocations). Be carful with that, is is not thread // safe. In a multi-thread context, set this flag to 0. sobel_result.resize(subimage._dimension); mirage::img::Filtering<1, mirage::SubFrame<ImageRGB24>, ImageRGBDouble>::RGB::Sobel::Horizontal(subimage,sobel_result); // sobel_result has values in [-255*4,255*4], so we rescale them // and convert in RGB24. mirage::algo::UnaryOp<ImageRGBDouble,mirage::SubFrame<ImageRGB24>,SobelRGBDoubleToRGB24Op>(sobel_result,subimage); // It is to be notices here that filtering the sub-image deals // with its border... but the outframe policy is involved only for // the border of the sub-image corresponding to actual borders of // parent image. So for right and bottom border, out of bound // during filtering consist in picking existing pixels in the // parent image. // Now, let us use the full sobel filter on another subpart of the // image. Note that passing 1 for buffer mode (last template // parameter) is required, since source and destination are the // same. subimage.resize(source._dimension/3,source._dimension/2); sobel_result.resize(subimage._dimension); mirage::img::Filtering<1, mirage::SubFrame<ImageRGB24>, mirage::SubFrame<ImageRGB24>, 1>::RGB::Sobel::Norm(subimage,subimage); std::cout << "Generating shrek-sobel.ppm" << std::endl; mirage::img::PPM::write(source,"shrek-sobel.ppm"); // Actually, sobel filtering extracts lines from grayscaled images. ImageGray8 gray_result; // As source is altered, we reload it from file. mirage::img::JPEG::read(source,image_dir+"/shrek.jpg"); gray_result.resize(source._dimension); // There is an unary operator pre-define for color to gray transforms. mirage::algo::UnaryOp<ImageRGB24,ImageGray8, mirage::colorspace::RGBToGray<ImageRGB24::value_type,ImageGray8::value_type> >(source,gray_result); std::cout << "Generating shrek-gray.jpg" << std::endl; mirage::img::JPEG::write(gray_result,"shrek-gray.jpg",10); // Low compression quality for fun... mirage::img::Filtering<1, ImageGray8, ImageGray8, 1>::Gray::Sobel::Norm(gray_result,gray_result); std::cout << "Generating shrek-gray-sobel.ppm" << std::endl; mirage::img::PPM::write(gray_result,"shrek-gray-sobel.ppm"); } catch(mirage::Exception::Any& e) { std::cerr << "Error : " << e.what() << std::endl; } catch(...) { std::cerr << "Unknown error" << std::endl; } return 0; }
int main(int argc, char** argv) { if(argc != 4) { cout << argc << endl; cout << "to use this program you have to enter this command line ./main path/of/the/picture connexity threshold " << endl; cout << "Threshold should be in 0-255" << endl; cout << "connexity should be 4connexity or 8connexity or chamfer5711" << endl; } else { int threshold = atoi(argv[2]); if(threshold <= 255 && threshold >= 0 && ( (strcmp(argv[3],"4connexity") == 0 ) || (strcmp(argv[3],"8connexity") == 0 ) || strcmp(argv[3],"chamfer5711") == 0) ) { vector<point2dWeighting> myWeightingVector; if(strcmp(argv[3],"4connexity") == 0 ) { make4Connexity(myWeightingVector); } else if(strcmp(argv[3],"8connexity") == 0) { make8Connexity(myWeightingVector); } else { makeSimpleChamfrein(myWeightingVector); } // mask creation SymmetricMask<point2dWeighting> myMask; SymmetricMaskGenerator<point2dWeighting> generateur; myMask = generateur.generateMask(myWeightingVector); // CMETRIC and distance Transform instanciation CChamferMetric<int,point2d> myMetric(myMask); ChamferDistanceTransform<int,point2d> myDistance(myMetric); Image image = DGtal::PNMReader<Image>::importPGM(argv[1], true); /** distance transformation **/ ImageInt output = myDistance.applyAlgorithm(image,threshold,true); /** output colorisation **/ DGtal::Board2D aBoard; ImageInt::Value maxDT = (*std::max_element(output.begin(), output.end())); typedef DGtal::HueShadeColorMap<ImageInt::Value,2> HueTwice; aBoard.clear(); Display2DFactory::drawImage<HueTwice>(aBoard, output, (ImageInt::Value)0, (ImageInt::Value)maxDT); aBoard.saveEPS(outputNameFile); /** distance transformation numeric output **/ /* typename Image::Domain::ConstIterator dit= image.domain().begin(); for(;dit != image.domain().end();++dit) { cout << (*dit) << " : " << (int)output(*dit) << endl; }*/ } } return 0; }