/**
* Example of a test. To be completed.
*
*/
bool testSimpleBoard()
{
unsigned int nbok = 0;
unsigned int nb = 2;
trace.beginBlock ( "Testing class SimpleBoard" );
Board2D board;
board.setPenColorRGBi( 0, 0, 0);
board.drawRectangle( -1, 1, 2.0, 2.0 );
board.setPenColorRGBi( 0, 0, 255 );
board.fillCircle( 2, 2, 1 );
board.saveSVG( "simpleboard.svg" );
board.saveFIG( "simpleboard.fig" );
board.saveEPS( "simpleboard.eps" );
board.saveTikZ( "simpleboard.tikz" );
nbok++;
typedef PointVector<2,int> Point2D;
Point2D apoint, p2;
apoint[0] = 5;
p2[0] = 1;
apoint[1] = 8;
p2[1] = 1;
board.setPenColorRGBi( 255, 0, 255 );
board << apoint;
board.setPenColorRGBi( 255, 0, 0 );
Display2DFactory::draw(board, apoint, p2);
board.scale(10);
board.saveSVG( "pointsimpleboard.svg" );
board.saveFIG( "pointsimpleboard.fig" );
board.saveEPS( "pointsimpleboard.eps" );
board.saveTikZ( "pointsimpleboard.tikz" );
nbok++;
trace.endBlock();
return nbok == nb;
}
int main( int argc, char** argv )
{
trace.beginBlock ( "Example exampleBezierCurve" );
trace.info() << "Args:";
for ( int i = 0; i < argc; ++i )
trace.info() << " " << argv[ i ];
trace.info() << endl;
//control points
typedef PointVector<2,int> Point;
Point P(0,0), Q(4,4), R(8,0);
//display
Board2D board;
//with fill
board << SetMode(P.className(), "Grid") << P << Q << R;
board.drawQuadraticBezierCurve(P[0], P[1], Q[0], Q[1], R[0], R[1]);
board.saveSVG("BezierCurve.svg", Board2D::BoundingBox, 5000 );
board.saveEPS("BezierCurve.eps", Board2D::BoundingBox, 5000 );
board.saveTikZ("BezierCurve.tikz", Board2D::BoundingBox, 5000 );
board.saveFIG("BezierCurve.fig", Board2D::BoundingBox, 5000 );
#ifdef WITH_CAIRO
board.saveCairo("BezierCurve.pdf", Board2D::CairoPDF);
#endif
board.clear();
//without fill
board << SetMode(P.className(), "Grid") << P << Q << R;
board.setFillColor(Color::None);
board.drawQuadraticBezierCurve(P[0], P[1], Q[0], Q[1], R[0], R[1]);
board.saveSVG("BezierCurve2.svg", Board2D::BoundingBox, 5000 );
board.saveEPS("BezierCurve2.eps", Board2D::BoundingBox, 5000 );
board.saveTikZ("BezierCurve2.tikz", Board2D::BoundingBox, 5000 );
board.saveFIG("BezierCurve2.fig", Board2D::BoundingBox, 5000 );
#ifdef WITH_CAIRO
board.saveCairo("BezierCurve2.pdf", Board2D::CairoPDF);
#endif
trace.endBlock();
return 0;
}
int main()
{
typedef SpaceND<2> Space2;
typedef HyperRectDomain<Space2> TDomain;
typedef TDomain::Vector Vector;
//Default image selector = STLVector
typedef ImageSelector<TDomain, unsigned char>::Type Image;
// Creating FreemanChain from file
std::string freemanChainFilename = examplesPath + "samples/contourS.fc";
fstream fst;
fst.open (freemanChainFilename.c_str(), ios::in);
FreemanChain<Space::Integer> fc(fst);
fst.close();
// Importing image with MagickReader
MagickReader<Image> reader;
std::string filenameImage = examplesPath + "samples/contourS.gif";
Image img = reader.importImage( filenameImage );
Point ptInf = img.lowerBound();
Point ptSup = img.upperBound();
unsigned int width = abs(ptSup.at(0)-ptInf.at(0)+1);
unsigned int height = abs(ptSup.at(1)-ptInf.at(1)+1);
// Draw the freemanchain and the contour
Board2D dgBoard;
dgBoard.drawImage(filenameImage, 0,height-1, width, height );
dgBoard << fc;
dgBoard.saveEPS("freemanChainDisplay.eps");
dgBoard.saveSVG("freemanChainDisplay.svg");
dgBoard.saveFIG("freemanChainDisplay.fig");
return 0;
}
/**
* testDisplay
*
*/
bool testDisplay()
{
typedef FreemanChain<int> FreemanChain;
//typedef FreemanChain::Point Point;
//typedef FreemanChain::Vector Vector;
//typedef FreemanChain::ConstIterator Iterator;
//typedef std::vector<unsigned int> numVector;
Board2D aBoard;
aBoard.setUnit(Board::UCentimeter);
fstream fst;
fst.open ((testPath + "samples/contourS.fc").c_str() , ios::in);
FreemanChain fc(fst);
aBoard.setPenColor(Color::Red);
//aBoard << DrawPavingPixel();
aBoard << fc;
std::string filenameImage = testPath + "samples/contourS.png"; // ! only PNG with Cairo for the moment !
LibBoard::Image image( 0, 84, 185, 85, filenameImage, 20 );
image.shiftDepth(500);
LibBoard::Board & board = aBoard;
board << image;
aBoard.saveSVG( "testDisplayFC.svg", Board::BoundingBox, 5000 );
aBoard.saveEPS( "testDisplayFC.eps", Board::BoundingBox, 5000 );
aBoard.saveFIG( "testDisplayFC.fig", Board::BoundingBox, 5000 );
#ifdef WITH_CAIRO
aBoard.saveCairo("testDisplayFC-cairo.pdf", Board2D::CairoPDF, Board::BoundingBox, 5000);
aBoard.saveCairo("testDisplayFC-cairo.png", Board2D::CairoPNG, Board::BoundingBox, 5000);
aBoard.saveCairo("testDisplayFC-cairo.ps", Board2D::CairoPS, Board::BoundingBox, 5000);
aBoard.saveCairo("testDisplayFC-cairo.svg", Board2D::CairoSVG, Board::BoundingBox, 5000);
#endif
return true;
}
int main( int argc, char** argv )
{
// parse command line ----------------------------------------------
po::options_description general_opt("Allowed options are: ");
general_opt.add_options()
("help,h", "display this message")
("FreemanChain,f", po::value<std::string>(), "FreemanChain file name")
("SDP", po::value<std::string>(), "Import a contour as a Sequence of Discrete Points (SDP format)")
("SFP", po::value<std::string>(), "Import a contour as a Sequence of Floating Points (SFP format)")
("drawContourPoint", po::value<double>(), "<size> display contour points as disk of radius <size>")
("lineWidth", po::value<double>()->default_value(1.0), "Define the linewidth of the contour (SDP format)")
("withProcessing", po::value<std::string>(), "Processing (used only with --FreemanChain):\n\t DSS segmentation {DSS}\n\t Maximal segments {MS}\n\t Faithful Polygon {FP}\n\t Minimum Length Polygon {MLP}")
("outputEPS", po::value<std::string>(), " <filename> specify eps format (default format output.eps)")
("outputSVG", po::value<std::string>(), " <filename> specify svg format.")
("outputFIG", po::value<std::string>(), " <filename> specify fig format.")
#ifdef WITH_CAIRO
("outputPDF", po::value<std::string>(), "outputPDF <filename> specify pdf format. ")
("outputPNG", po::value<std::string>(), "outputPNG <filename> specify png format.")
("invertYaxis", " invertYaxis invert the Y axis for display contours (used only with --SDP)")
#endif
#ifdef WITH_MAGICK
("backgroundImage", po::value<std::string>(), "backgroundImage <filename> <alpha> : display image as background with transparency alpha (defaut 1) (transparency works only if cairo is available)")
("alphaBG", po::value<double>(), "alphaBG <value> 0-1.0 to display the background image in transparency (default 1.0)")
#endif
("scale", po::value<double>(), "scale <value> 1: normal; >1 : larger ; <1 lower resolutions )");
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, general_opt), vm);
po::notify(vm);
if(vm.count("help")||argc<=1 || (not(vm.count("FreemanChain")) && not(vm.count("SDP")) && not(vm.count("SFP"))&&
not(vm.count("backgroundImage")) ) )
{
trace.info()<< "Display discrete contours. " <<std::endl << "Basic usage: "<<std::endl
<< "\t displayContours [options] --FreemanChain <fileName> --imageName image.png "<<std::endl
<< general_opt << "\n";
return 0;
}
double lineWidth= vm["lineWidth"].as<double>();
double scale=1.0;
if(vm.count("scale")){
scale = vm["scale"].as<double>();
}
Board2D aBoard;
aBoard.setUnit (0.05*scale, LibBoard::Board::UCentimeter);
#ifdef WITH_MAGICK
double alpha=1.0;
if(vm.count("alphaBG")){
alpha = vm["alphaBG"].as<double>();
}
if(vm.count("backgroundImage")){
string imageName = vm["backgroundImage"].as<string>();
typedef ImageSelector<Z2i::Domain, unsigned char>::Type Image;
DGtal::MagickReader<Image> reader;
Image img = reader.importImage( imageName );
Z2i::Point ptInf = img.lowerBound();
Z2i::Point ptSup = img.upperBound();
unsigned int width = abs(ptSup.at(0)-ptInf.at(0)+1);
unsigned int height = abs(ptSup.at(1)-ptInf.at(1)+1);
aBoard.drawImage(imageName, 0-0.5,height-0.5, width, height, -1, alpha );
}
#endif
if(vm.count("FreemanChain")){
string fileName = vm["FreemanChain"].as<string>();
vector< FreemanChain<int> > vectFc = PointListReader< Z2i::Point>:: getFreemanChainsFromFile<int> (fileName);
//aBoard << SetMode( vectFc.at(0).styleName(), "InterGrid" );
aBoard << CustomStyle( vectFc.at(0).styleName(),
new CustomColors( Color::Red , Color::None ) );
for(unsigned int i=0; i<vectFc.size(); i++){
aBoard << vectFc.at(i) ;
if(vm.count("withProcessing")){
std::string processingName = vm["withProcessing"].as<std::string>();
vector<Z2i::Point> vPts(vectFc.at(i).size()+1);
copy ( vectFc.at(i).begin(), vectFc.at(i).end(), vPts.begin() );
bool isClosed;
if ( vPts.at(0) == vPts.at(vPts.size()-1) ) {
isClosed = true;
vPts.pop_back();
} else isClosed = false;
if (processingName == "DSS") {
typedef ArithmeticalDSS<vector<Z2i::Point>::iterator,int,4> DSS4;
typedef deprecated::GreedyDecomposition<DSS4> Decomposition4;
//Segmentation
DSS4 computer;
Decomposition4 theDecomposition( vPts.begin(),vPts.end(),computer,isClosed );
//for each segment
aBoard << SetMode( computer.styleName(), "BoundingBox" );
string styleName = computer.styleName() + "/BoundingBox";
for ( Decomposition4::SegmentIterator it = theDecomposition.begin();
it != theDecomposition.end(); ++it )
{
DSS4 segment(*it);
aBoard << CustomStyle( styleName,
new CustomPenColor( DGtal::Color::Gray ) );
aBoard << segment; // draw each segment
}
} else if (processingName == "MS") {
typedef ArithmeticalDSS<vector<Z2i::Point>::iterator,int,4> DSS4;
typedef deprecated::MaximalSegments<DSS4> Decomposition4;
//Segmentation
DSS4 computer;
Decomposition4 theDecomposition( vPts.begin(),vPts.end(),computer,isClosed );
//for each segment
aBoard << SetMode( computer.styleName(), "BoundingBox" );
string styleName = computer.styleName() + "/BoundingBox";
for ( Decomposition4::SegmentIterator it = theDecomposition.begin();
it != theDecomposition.end(); ++it )
{
DSS4 segment(*it);
aBoard << CustomStyle( styleName,
new CustomPenColor( DGtal::Color::Black ) );
aBoard << segment; // draw each segment
}
} else if (processingName == "FP") {
typedef FP<vector<Z2i::Point>::iterator,int,4> FP;
FP theFP( vPts.begin(),vPts.end(),isClosed );
aBoard << CustomStyle( theFP.styleName(),
new CustomPenColor( DGtal::Color::Black ) );
aBoard << theFP;
} else if (processingName == "MLP") {
typedef FP<vector<Z2i::Point>::iterator,int,4> FP;
FP theFP( vPts.begin(),vPts.end(),isClosed );
vector<FP::RealPoint> v( theFP.size() );
theFP.copyMLP( v.begin() );
//polyline to draw
vector<LibBoard::Point> polyline;
vector<FP::RealPoint>::const_iterator it = v.begin();
for ( ;it != v.end();++it) {
FP::RealPoint p = (*it);
polyline.push_back(LibBoard::Point(p[0],p[1]));
}
if (isClosed) {
FP::RealPoint p = (*v.begin());
polyline.push_back(LibBoard::Point(p[0],p[1]));
}
aBoard.setPenColor(DGtal::Color::Black);
aBoard.drawPolyline(polyline);
}
}
}
}
if(vm.count("SDP") || vm.count("SFP")){
bool drawPoints= vm.count("drawContourPoint");
bool invertYaxis = vm.count("invertYaxis");
double pointSize=1.0;
if(drawPoints){
pointSize = vm["drawContourPoint"].as<double>();
}
vector<LibBoard::Point> contourPt;
if(vm.count("SDP")){
string fileName = vm["SDP"].as<string>();
vector< Z2i::Point > contour =
PointListReader< Z2i::Point >::getPointsFromFile(fileName);
for(unsigned int j=0; j<contour.size(); j++){
LibBoard::Point pt((double)(contour.at(j)[0]),
(invertYaxis? (double)(-contour.at(j)[1]+contour.at(0)[1]):(double)(contour.at(j)[1])));
contourPt.push_back(pt);
if(drawPoints){
aBoard.fillCircle(pt.x, pt.y, pointSize);
}
}
}
if(vm.count("SFP")){
string fileName = vm["SFP"].as<string>();
vector< PointVector<2,double> > contour =
PointListReader< PointVector<2,double> >::getPointsFromFile(fileName);
for(unsigned int j=0; j<contour.size(); j++){
LibBoard::Point pt((double)(contour.at(j)[0]),
(invertYaxis? (double)(-contour.at(j)[1]+contour.at(0)[1]):(double)(contour.at(j)[1])));
contourPt.push_back(pt);
if(drawPoints){
aBoard.fillCircle(pt.x, pt.y, pointSize);
}
}
}
aBoard.setPenColor(Color::Red);
aBoard.setLineStyle (LibBoard::Shape::SolidStyle );
aBoard.setLineWidth (lineWidth);
aBoard.drawPolyline(contourPt);
}
if (vm.count("outputSVG")){
string outputFileName= vm["outputSVG"].as<string>();
aBoard.saveSVG(outputFileName.c_str());
} else
if (vm.count("outputFIG")){
string outputFileName= vm["outputFIG"].as<string>();
aBoard.saveFIG(outputFileName.c_str());
} else
if (vm.count("outputEPS")){
string outputFileName= vm["outputEPS"].as<string>();
aBoard.saveEPS(outputFileName.c_str());
}
#ifdef WITH_CAIRO
else
if (vm.count("outputEPS")){
string outputFileName= vm["outputEPS"].as<string>();
aBoard.saveCairo(outputFileName.c_str(),Board2D::CairoEPS );
} else
if (vm.count("outputPDF")){
string outputFileName= vm["outputPDF"].as<string>();
aBoard.saveCairo(outputFileName.c_str(),Board2D::CairoPDF );
} else
if (vm.count("outputPNG")){
string outputFileName= vm["outputPNG"].as<string>();
aBoard.saveCairo(outputFileName.c_str(),Board2D::CairoPNG );
}
#endif
else { //default output
string outputFileName= "output.eps";
aBoard.saveEPS(outputFileName.c_str());
}
}
int main( int /*argc*/, char** /*argv*/ )
{
trace.beginBlock ( "Example ctopo-fillContours" );
DGtal::KhalimskySpaceND< 2, int > K;
K.init(Z2i::Point(0, 10), Z2i::Point(20, 30), false);
// We choose a direct and indirect oriented contour.
//! [ctopoFillContoursInit]
FreemanChain<int> fc1 ("001001001001001111101111011222222223222222322233333330301033333003", 6, 14);
FreemanChain<int> fc2 ("1111000033332222", 6, 20);
//! [ctopoFillContoursInit]
Board2D aBoard;
Board2D aBoard2;
aBoard << K.lowerBound() << K.upperBound() ;
aBoard2 << K.lowerBound() << K.upperBound() ;
//From the FreemanChain we can get a vector of SCell wrapped in a SurfelSetPredicate with sign defined from the FreemanChain orientation:
//! [ctopoFillContoursGetSCells]
typedef KhalimskySpaceND<2, int>::SCell SCell;
std::set<DGtal::KhalimskySpaceND< 2, int >::SCell> boundarySCell;
FreemanChain<int>::getInterPixelLinels(K, fc1, boundarySCell, false);
//! [ctopoFillContoursGetSCells]
aBoard << CustomStyle((*boundarySCell.begin()).className(), new CustomColors(DGtal::Color::Red, DGtal::Color::Red) );
for( std::set<DGtal::KhalimskySpaceND< 2, int >::SCell>::const_iterator it= boundarySCell.begin();
it!= boundarySCell.end(); it++){
aBoard << *it;
}
// We can also add other freeman chains with indirect orientation to construct a hole in interior of the shape:
//! [ctopoFillContoursGetSCellsHole]
std::set<DGtal::KhalimskySpaceND< 2, int >::SCell> boundarySCellhole;
FreemanChain<int>::getInterPixelLinels(K, fc2, boundarySCellhole, false);
//! [ctopoFillContoursGetSCellsHole]
aBoard << CustomStyle((*boundarySCell.begin()).className(), new CustomColors(DGtal::Color::Blue, DGtal::Color::Blue) );
aBoard2 << CustomStyle((*boundarySCell.begin()).className(), new CustomColors(DGtal::Color::Blue, DGtal::Color::Blue) );
for( std::set<DGtal::KhalimskySpaceND< 2, int >::SCell>::const_iterator it= boundarySCellhole.begin(); it!= boundarySCellhole.end(); it++){
aBoard << *it;
aBoard2 << *it;
boundarySCell.insert(*it);
}
// Now we can compute the unsigned cell associated to interior pixels:
//! [ctopoFillContoursFillRegion]
typedef ImageContainerBySTLMap< Z2i::Domain, bool> BoolImage2D;
BoolImage2D::Domain imageDomain( Z2i::Point(0,10), Z2i::Point(20,30) );
BoolImage2D interiorCellImage( imageDomain );
Surfaces<DGtal::KhalimskySpaceND< 2, int > >::uFillInterior(K, functors::SurfelSetPredicate<std::set<SCell>,SCell>(boundarySCell),
interiorCellImage, 1, false);
//! [ctopoFillContoursFillRegion]
aBoard << CustomStyle(K.uSpel(Z2i::Point(0,0)).className(), new CustomColors(DGtal::Color::None, Color(200, 200, 200)) );
for(BoolImage2D::Domain::ConstIterator it = interiorCellImage.domain().begin();
it!=interiorCellImage.domain().end(); it++){
if(interiorCellImage(*it)){
aBoard << K.uSpel(*it);
}
}
// We can also compute the unsigned cell associated to interior and exterior pixels:
//! [ctopoFillContoursFillRegionHoles]
BoolImage2D interiorCellHoleImage( imageDomain );
BoolImage2D exteriorCellHoleImage( imageDomain );
Surfaces<DGtal::KhalimskySpaceND< 2, int > >::uFillInterior(K, functors::SurfelSetPredicate<std::set<SCell>, SCell>(boundarySCellhole),
interiorCellHoleImage, 1, true);
Surfaces<DGtal::KhalimskySpaceND< 2, int > >::uFillExterior(K, functors::SurfelSetPredicate<std::set<SCell>, SCell>(boundarySCellhole),
exteriorCellHoleImage, 1, false);
//! [ctopoFillContoursFillRegionHoles]
aBoard2 << CustomStyle(K.uSpel(Z2i::Point(0,0)).className(),
new CustomColors(DGtal::Color::None, Color(200, 200, 200)) );
for(BoolImage2D::Domain::ConstIterator it = interiorCellHoleImage.domain().begin();
it!=interiorCellHoleImage.domain().end(); it++){
if(interiorCellHoleImage(*it)){
aBoard2 << K.uSpel(*it);
}
}
aBoard2 << CustomStyle(K.uSpel(Z2i::Point(0,0)).className(),
new CustomColors(DGtal::Color::None, Color(100, 100, 100)) );
for(BoolImage2D::Domain::ConstIterator it = exteriorCellHoleImage.domain().begin();
it!=exteriorCellHoleImage.domain().end(); it++){
if(exteriorCellHoleImage(*it)){
aBoard2 << K.uSpel(*it);
}
}
aBoard.saveEPS("example_ctopo-fillContours.eps");
aBoard.saveFIG("example_ctopo-fillContours.fig");
aBoard2.saveEPS("example_ctopo-fillContours2.eps");
aBoard2.saveFIG("example_ctopo-fillContours2.fig");
trace.endBlock();
return 0;
}
int main( int argc, char** argv )
{
// parse command line ----------------------------------------------
po::options_description general_opt("Allowed options are: ");
general_opt.add_options()
("help,h", "display this message")
("input,i", po::value<std::string>(), "input FreemanChain file name")
("SDP", po::value<std::string>(), "Import a contour as a Sequence of Discrete Points (SDP format)")
("SFP", po::value<std::string>(), "Import a contour as a Sequence of Floating Points (SFP format)")
("drawContourPoint", po::value<double>(), "<size> display contour points as disk of radius <size>")
("fillContour", "fill the contours with default color (gray)")
("lineWidth", po::value<double>()->default_value(1.0), "Define the linewidth of the contour (SDP format)")
("drawPointOfIndex", po::value<int>(), "<index> Draw the contour point of index <index> (default 0) ")
("pointSize", po::value<double>()->default_value(2.0), "<size> Set the display point size of the point displayed by drawPointofIndex option (default 2.0) ")
("noXFIGHeader", " to exclude xfig header in the resulting output stream (no effect with option -outputFile).")
("withProcessing", po::value<std::string>(), "Processing (used only when the input is a Freeman chain (--input)):\n\t DSS segmentation {DSS}\n\t Maximal segments {MS}\n\t Faithful Polygon {FP}\n\t Minimum Length Polygon {MLP}")
("outputFile,o", po::value<std::string>(), " <filename> save output file automatically according the file format extension.")
("outputStreamEPS", " specify eps for output stream format.")
("outputStreamSVG", " specify svg for output stream format.")
("outputStreamFIG", " specify fig for output stream format.")
("invertYaxis", " invertYaxis invert the Y axis for display contours (used only with --SDP)")
("backgroundImage", po::value<std::string>(), "backgroundImage <filename> : display image as background ")
("alphaBG", po::value<double>(), "alphaBG <value> 0-1.0 to display the background image in transparency (default 1.0), (transparency works only if cairo is available)")
("scale", po::value<double>(), "scale <value> 1: normal; >1 : larger ; <1 lower resolutions )");
bool parseOK=true;
po::variables_map vm;
try {
po::store(po::parse_command_line(argc, argv, general_opt), vm);
} catch(const std::exception& ex) {
parseOK=false;
trace.info()<< "Error checking program options: "<< ex.what()<< std::endl;
}
po::notify(vm);
if(!parseOK||vm.count("help")||argc<=1 || (!(vm.count("input")) && !(vm.count("SDP")) && !(vm.count("SFP"))&&
!(vm.count("backgroundImage")) ) )
{
trace.info()<< "Display discrete contours. " <<std::endl << "Basic usage: "<<std::endl
<< "\t displayContours [options] --input <fileName> "<<std::endl
<< general_opt << "\n";
return 0;
}
double lineWidth= vm["lineWidth"].as<double>();
bool filled = vm.count("fillContour");
double scale=1.0;
if(vm.count("scale")) {
scale = vm["scale"].as<double>();
}
Board2D aBoard;
aBoard.setUnit (0.05*scale, LibBoard::Board::UCentimeter);
double alpha=1.0;
if(vm.count("alphaBG")) {
alpha = vm["alphaBG"].as<double>();
}
if(vm.count("backgroundImage")) {
std::string imageName = vm["backgroundImage"].as<std::string>();
typedef ImageSelector<Z2i::Domain, unsigned char>::Type Image;
Image img = DGtal::GenericReader<Image>::import( imageName );
Z2i::Point ptInf = img.domain().lowerBound();
Z2i::Point ptSup = img.domain().upperBound();
unsigned int width = abs(ptSup[0]-ptInf[0]+1);
unsigned int height = abs(ptSup[1]-ptInf[1]+1);
aBoard.drawImage(imageName, 0-0.5,height-0.5, width, height, -1, alpha );
}
if(vm.count("input")) {
std::string fileName = vm["input"].as<std::string>();
std::vector< FreemanChain<int> > vectFc = PointListReader< Z2i::Point>:: getFreemanChainsFromFile<int> (fileName);
aBoard << CustomStyle( vectFc.at(0).className(),
new CustomColors( Color::Red , filled? Color::Gray: Color::None ) );
aBoard.setLineWidth (lineWidth);
for(unsigned int i=0; i<vectFc.size(); i++) {
aBoard << vectFc.at(i) ;
if(vm.count("drawPointOfIndex")) {
int index = vm["drawPointOfIndex"].as<int>();
double size = vm["pointSize"].as<double>();
aBoard.setPenColor(Color::Blue);
aBoard.fillCircle((double)(vectFc.at(i).getPoint(index)[0]), (double)(vectFc.at(i).getPoint(index)[1]), size);
}
if(vm.count("withProcessing")) {
std::string processingName = vm["withProcessing"].as<std::string>();
std::vector<Z2i::Point> vPts(vectFc.at(i).size()+1);
copy ( vectFc.at(i).begin(), vectFc.at(i).end(), vPts.begin() );
bool isClosed;
if ( vPts.at(0) == vPts.at(vPts.size()-1) ) {
isClosed = true;
vPts.pop_back();
} else isClosed = false;
if (processingName == "DSS") {
typedef ArithmeticalDSSComputer<std::vector<Z2i::Point>::iterator,int,4> DSS4;
typedef GreedySegmentation<DSS4> Decomposition4;
DSS4 computer;
Decomposition4 theDecomposition( vPts.begin(),vPts.end(),computer );
//for each segment
std::string className;
for ( Decomposition4::SegmentComputerIterator it = theDecomposition.begin();
it != theDecomposition.end(); ++it )
{
DSS4::Primitive segment(it->primitive());
aBoard << SetMode( segment.className(), "BoundingBox" );
className = segment.className() + "/BoundingBox";
aBoard << CustomStyle( className,
new CustomPenColor( DGtal::Color::Gray ) );
aBoard << segment; // draw each segment
}
} else if (processingName == "MS") {
typedef ArithmeticalDSSComputer<std::vector<Z2i::Point>::iterator,int,4> DSS4;
typedef SaturatedSegmentation<DSS4> Decomposition4;
//Segmentation
DSS4 computer;
Decomposition4 theDecomposition( vPts.begin(),vPts.end(),computer );
//for each segment
std::string className;
for ( Decomposition4::SegmentComputerIterator it = theDecomposition.begin();
it != theDecomposition.end(); ++it )
{
DSS4::Primitive segment(it->primitive());
aBoard << SetMode( segment.className(), "BoundingBox" );
className = segment.className() + "/BoundingBox";
aBoard << CustomStyle( className,
new CustomPenColor( DGtal::Color::Gray ) );
aBoard << segment; // draw each segment
}
} else if (processingName == "FP") {
typedef FP<std::vector<Z2i::Point>::iterator,int,4> FP;
FP theFP( vPts.begin(),vPts.end() );
aBoard << CustomStyle( theFP.className(),
new CustomPenColor( DGtal::Color::Black ) );
aBoard << theFP;
} else if (processingName == "MLP") {
typedef FP<std::vector<Z2i::Point>::iterator,int,4> FP;
FP theFP( vPts.begin(),vPts.end() );
std::vector<FP::RealPoint> v( theFP.size() );
theFP.copyMLP( v.begin() );
//polyline to draw
std::vector<LibBoard::Point> polyline;
std::vector<FP::RealPoint>::const_iterator it = v.begin();
for ( ; it != v.end(); ++it) {
FP::RealPoint p = (*it);
polyline.push_back(LibBoard::Point(p[0],p[1]));
}
if (isClosed) {
FP::RealPoint p = (*v.begin());
polyline.push_back(LibBoard::Point(p[0],p[1]));
}
aBoard.setPenColor(DGtal::Color::Black);
aBoard.drawPolyline(polyline);
} else if (processingName == "MDCA") {
typedef KhalimskySpaceND<2,int> KSpace;
typedef GridCurve<KSpace> Curve;
Curve curve; //grid curve
curve.initFromPointsVector( vPts );
typedef Curve::IncidentPointsRange Range; //range
Range r = curve.getIncidentPointsRange(); //range
typedef Range::ConstCirculator ConstCirculator; //iterator
typedef StabbingCircleComputer<ConstCirculator> SegmentComputer; //segment computer
//typedef GeometricalDCA<ConstIterator> SegmentComputer; //segment computer
typedef SaturatedSegmentation<SegmentComputer> Segmentation;
//Segmentation theSegmentation( r.begin(), r.end(), SegmentComputer() );
Segmentation theSegmentation( r.c(), r.c(), SegmentComputer() );
theSegmentation.setMode("Last");
// board << curve;
Segmentation::SegmentComputerIterator it = theSegmentation.begin();
Segmentation::SegmentComputerIterator itEnd = theSegmentation.end();
Board2D otherBoard;
otherBoard.setPenColor(DGtal::Color::Black);
otherBoard << curve;
for ( ; it != itEnd; ++it ) {
aBoard << SetMode(SegmentComputer().className(), "") << (*it);
otherBoard << SetMode(SegmentComputer().className(), "") << (*it);
}
otherBoard.saveSVG("mdca.svg", Board2D::BoundingBox, 5000 );
}
}
}
}
if(vm.count("SDP") || vm.count("SFP")) {
bool drawPoints= vm.count("drawContourPoint");
bool invertYaxis = vm.count("invertYaxis");
double pointSize=1.0;
if(drawPoints) {
pointSize = vm["drawContourPoint"].as<double>();
}
std::vector<LibBoard::Point> contourPt;
if(vm.count("SDP")) {
std::string fileName = vm["SDP"].as<std::string>();
std::vector< Z2i::Point > contour =
PointListReader< Z2i::Point >::getPointsFromFile(fileName);
for(unsigned int j=0; j<contour.size(); j++) {
LibBoard::Point pt((double)(contour.at(j)[0]),
(invertYaxis? (double)(-contour.at(j)[1]+contour.at(0)[1]):(double)(contour.at(j)[1])));
contourPt.push_back(pt);
if(drawPoints) {
aBoard.fillCircle(pt.x, pt.y, pointSize);
}
}
}
if(vm.count("SFP")) {
std::string fileName = vm["SFP"].as<std::string>();
std::vector< PointVector<2,double> > contour =
PointListReader< PointVector<2,double> >::getPointsFromFile(fileName);
for(unsigned int j=0; j<contour.size(); j++) {
LibBoard::Point pt((double)(contour.at(j)[0]),
(invertYaxis? (double)(-contour.at(j)[1]+contour.at(0)[1]):(double)(contour.at(j)[1])));
contourPt.push_back(pt);
if(drawPoints) {
aBoard.fillCircle(pt.x, pt.y, pointSize);
}
}
}
aBoard.setPenColor(Color::Red);
aBoard.setFillColor(Color::Gray);
aBoard.setLineStyle (LibBoard::Shape::SolidStyle );
aBoard.setLineWidth (lineWidth);
if(!filled) {
aBoard.drawPolyline(contourPt);
} else {
aBoard.fillPolyline(contourPt);
}
if(vm.count("drawPointOfIndex")) {
int index = vm["drawPointOfIndex"].as<int>();
double size = vm["pointSize"].as<double>();
aBoard.fillCircle((double)(contourPt.at(index).x), (double)(contourPt.at(index).y), size);
}
}
if(vm.count("outputFile")) {
std::string outputFileName= vm["outputFile"].as<std::string>();
std::string extension = outputFileName.substr(outputFileName.find_last_of(".") + 1);
if(extension=="svg") {
aBoard.saveSVG(outputFileName.c_str());
}
#ifdef WITH_CAIRO
else if (extension=="eps") {
aBoard.saveCairo(outputFileName.c_str(),Board2D::CairoEPS );
} else if (extension=="pdf") {
aBoard.saveCairo(outputFileName.c_str(),Board2D::CairoPDF );
} else if (extension=="png") {
aBoard.saveCairo(outputFileName.c_str(),Board2D::CairoPNG );
}
#endif
else if(extension=="eps") {
aBoard.saveEPS(outputFileName.c_str());
} else if(extension=="fig") {
aBoard.saveFIG(outputFileName.c_str(),LibBoard::Board::BoundingBox, 10.0, !vm.count("noXFIGHeader") );
}
}
if (vm.count("outputStreamSVG")) {
aBoard.saveSVG(std::cout);
} else if (vm.count("outputStreamFIG")) {
aBoard.saveFIG(std::cout, LibBoard::Board::BoundingBox, 10.0, !vm.count("noXFIGHeader"));
} else if (vm.count("outputStreamEPS")) {
aBoard.saveEPS(std::cout);
}
}
int main( int argc, char** argv )
{
// Contour import
args.addOption("-fc", "-fc <freemanChain.fc> : FreemanChain file name", "freeman.fc" );
args.addOption("-sdp", "-sdp <contour.sdp> : Import a contour as a Sequence of Discrete Points (SDP format)", "contour.sdp" );
args.addOption("-sfp", "-sdp <contour.sdp> : Import a contour as a Sequence of Floating Points (SFP format)", "contour.sdp" );
// Display options
args.addOption("-drawContourPoint", "-drawContourPoint <size> (double): display contour points as disk of radius <size> (default 1.0) ", "1.0" );
args.addBooleanOption("-fillContour", "-fillContour fill the contours with default color");
args.addOption("-lineWidth", "-lineWidth <width> : define the linewidth <width> of the contour (default 1.0) (SDP format)", "1.0");
args.addOption("-outputEPS", "-outputEPS <filename> specify eps format (default format output.eps)", "output.eps");
args.addOption("-outputSVG", "-outputSVG <filename> specify svg format. (default name output.svg)", "output.svg");
args.addOption("-outputFIG", "-outputFIG <filename> specify svg format. (default name output.fig)", "output.fig");
#ifdef WITH_CAIRO
args.addOption("-outputPDF", "-outputPDF <filename> specify svg format. (default name output.pdf)", "output.pdf");
args.addOption("-outputPNG", "-outputPNG <filename> specify png format. (default name output.png)", "output.png");
args.addBooleanOption("-invertYaxis", "-invertYaxis: invert the Y axis for display contours (used only with --SDP) ");
#endif
#ifdef WITH_MAGICK
args.addOption("-backgroundImage", "-backgroundImage <filename> <alpha> : display image as background with transparency alpha (defaut 1) (transparency works only if cairo is available)", "imageBG.png", "1.0" );
#endif
args.addOption("-backgroundImageXFIG", "-backgroundImageXFIG <filename> <width> <height> : display image as background in XFIG format", "imageBG.png", "256","256" );
args.addOption("-scale", "-scale <value> 1: normal; >1 : larger ; <1 lower resolutions ) (default 1.0) ", "1.0");
bool parseOK= args.readArguments( argc, argv );
if(!parseOK || args.check("-h") || (! args.check("-fc") && ! args.check("-sdp") && ! args.check("-sfp"))){
trace.info()<<args.usage("displayContours", "Display discrete contours. \n Basic usage: \n \t displayContours [options] -fc <fileName> \n", "");
return 1;
}
double lineWidth = args.getOption("-lineWidth")->getFloatValue(0);
double scale = args.getOption("-scale")->getIntValue(0);
bool filled = args.check("-fillContour");
Board2D aBoard;
aBoard.setUnit (0.05*scale, LibBoard::Board::UCentimeter);
#ifdef WITH_MAGICK
double alpha=args.getOption("-alphaBG")->getFloatValue(0);
if(args.check("-backgroundImage")){
string imageName = args.check("-backgroundImage")->getValue(0);
typedef ImageSelector<Z2i::Domain, unsigned char>::Type Image;
DGtal::MagickReader<Image> reader;
Image img = reader.importImage( imageName );
Z2i::Point ptInf = img.domain().lowerBound();
Z2i::Point ptSup = img.domain().upperBound();
unsigned int width = abs(ptSup.at(0)-ptInf.at(0)+1);
unsigned int height = abs(ptSup.at(1)-ptInf.at(1)+1);
aBoard.drawImage(imageName, 0-0.5,height-0.5, width, height, -1, alpha );
}
#endif
if(args.check("-backgroundImageXFIG")){
string imageName = args.getOption("-backgroundImageXFIG")->getValue(0);
unsigned int width = args.getOption("-backgroundImageXFIG")->getIntValue(1);
unsigned int height = args.getOption("-backgroundImageXFIG")->getIntValue(2);
aBoard.drawImage(imageName, 0,height-1, width, height, -1, 1.0 );
}
if(args.check("-fc")){
string fileName = args.getOption("-fc")->getValue(0);
vector< FreemanChain<int> > vectFc = PointListReader< Z2i::Point>:: getFreemanChainsFromFile<int> (fileName);
//aBoard << SetMode( vectFc.at(0).className(), "InterGrid" );
aBoard << CustomStyle( vectFc.at(0).className(),
new CustomColors( Color::Red , (filled ? (Color::Black) : (Color::None)) ) );
for(unsigned int i=0; i<vectFc.size(); i++){
aBoard << vectFc.at(i) ;
}
}
if( args.check("-sdp") || args.check("-sfp")){
bool drawPoints= args.check("-drawContourPoint");
bool invertYaxis = args.check("-invertYaxis");
double pointSize = args.getOption("-drawContourPoint")->getFloatValue(0);
vector<LibBoard::Point> contourPt;
if(args.check("-sdp")){
string fileName = args.getOption("-sdp")->getValue(0);
vector< Z2i::Point > contour =
PointListReader< Z2i::Point >::getPointsFromFile(fileName);
for(unsigned int j=0; j<contour.size(); j++){
LibBoard::Point pt((double)(contour.at(j)[0]),
(invertYaxis? (double)(-contour.at(j)[1]+contour.at(0)[1]):(double)(contour.at(j)[1])));
contourPt.push_back(pt);
if(drawPoints){
aBoard.fillCircle(pt.x, pt.y, pointSize);
}
}
}
if(args.check("-sfp")){
string fileName = args.getOption("-sfp")->getValue(0);
vector< PointVector<2,double> > contour =
PointListReader< PointVector<2,double> >::getPointsFromFile(fileName);
for(unsigned int j=0; j<contour.size(); j++){
LibBoard::Point pt((double)(contour.at(j)[0]),
(invertYaxis? (double)(-contour.at(j)[1]+contour.at(0)[1]):(double)(contour.at(j)[1])));
contourPt.push_back(pt);
if(drawPoints){
aBoard.fillCircle(pt.x, pt.y, pointSize);
}
}
}
aBoard.setPenColor(Color::Red);
aBoard.setLineStyle (LibBoard::Shape::SolidStyle );
aBoard.setLineWidth (lineWidth);
if(!filled){
aBoard.drawPolyline(contourPt);
}else{
aBoard.fillPolyline(contourPt);
}
}
if (args.check("-outputSVG")){
string outputFileName= args.getOption("-outputSVG")->getValue(0);
aBoard.saveSVG(outputFileName.c_str());
} else
if (args.check("-outputFIG")){
string outputFileName= args.getOption("-outputFIG")->getValue(0);
aBoard.saveFIG(outputFileName.c_str());
} else
if (args.check("-outputEPS")){
string outputFileName= args.getOption("-outputEPS")->getValue(0);
aBoard.saveEPS(outputFileName.c_str());
}
#ifdef WITH_CAIRO
else
if (args.check("-outputEPS")){
string outputFileName= args.getOption("-outputSVG")->getValue(0);
aBoard.saveCairo(outputFileName.c_str(),Board2D::CairoEPS );
} else
if (args.check("-outputPDF")){
string outputFileName= args.getOption("-outputPDF")->getValue(0);
aBoard.saveCairo(outputFileName.c_str(),Board2D::CairoPDF );
} else
if (args.check("-outputPNG")){
string outputFileName= args.getOption("-outputPNG")getValue(0);
aBoard.saveCairo(outputFileName.c_str(),Board2D::CairoPNG );
}
#endif
else { //default output
string outputFileName= "output.eps";
aBoard.saveEPS(outputFileName.c_str());
}
}
int main(int argc, char** argv)
{
Point ptL(-1, -1);
Point ptU(3, 3);
Domain d (ptL, ptU);
Point pt0(0,0);
Point pt1(1,0);
Point pt2(0,1);
Point pt3(2,1);
Point pt4(1,2);
Point pt5(2,2);
DigitalSet aSet( d );
aSet.insert(pt0);
aSet.insert(pt1);
aSet.insert(pt2);
aSet.insert(pt3);
aSet.insert(pt4);
Board2D boardAdj;
boardAdj << d;
std::set<SCell> bdry;
Z2i::KSpace ks;
ks.init( ptL, ptU, true );
boardAdj << aSet;
// Extracting the surface boundary of the shape
Surfaces<Z2i::KSpace>::sMakeBoundary( bdry, ks, aSet, ks.lowerBound(), ks.upperBound() );
SurfelAdjacency<Z2i::KSpace::dimension> sAdjInt( true );
SurfelAdjacency<Z2i::KSpace::dimension> sAdjExt( false );
//Displaying the boundary bels
std::set<SCell>::iterator itBoundary;
int i=0;
Board2D boardDisplayAll;
boardDisplayAll<< d;
boardAdj.saveFIG("illustrationAdjSRC.fig");
for(itBoundary= bdry.begin(); itBoundary!= bdry.end(); itBoundary++){
boardDisplayAll << *itBoundary;
}
boardDisplayAll.saveFIG("illustrationAdjBdr.fig");
itBoundary = bdry.begin();
for (int i =0; i<10; i++) itBoundary++;
SCell surfel = *itBoundary;
// Defining surfel Neighborhood given an surfel Adjacency
SurfelNeighborhood<KSpace> sNeighInt;
sNeighInt.init( &ks, &sAdjInt, surfel );
SurfelNeighborhood<KSpace> sNeighExt;
sNeighExt.init( &ks, &sAdjExt, surfel );
SCell surfelFollowerInt;
SCell surfelFollowerExt;
sNeighInt.getAdjacentOnDigitalSet ( surfelFollowerInt, aSet, *(ks.sDirs(surfel)), true);
sNeighExt.getAdjacentOnDigitalSet ( surfelFollowerExt, aSet, *(ks.sDirs(surfel)), true);
boardAdj << CustomStyle( surfel.className() ,
new CustomColors( Color::Blue,
Color::Gray ));
boardAdj << surfel;
boardAdj << CustomStyle( surfel.className() ,
new CustomColors( Color::Red,
Color::Black ));
boardAdj << surfelFollowerInt;
boardAdj << CustomStyle( surfel.className() ,
new CustomColors( Color::Green,
Color::White ));
boardAdj << surfelFollowerExt;
boardAdj.saveFIG("illustrationAdjIntExt.fig");
// Extraction of contour
std::set<SCell> aContour1;
Surfaces<Z2i::KSpace>::trackBoundary( aContour1, ks,
sAdjExt,
aSet, surfel );
Board2D boardContour1;
boardContour1 << d;
std::set<SCell>::iterator iterOnContour;
for( iterOnContour= aContour1.begin(); iterOnContour != aContour1.end(); iterOnContour++){
if(*iterOnContour != surfel){
boardContour1 << CustomStyle( surfel.className() ,
new CustomColors( Color::Green,
Color::White ));
boardContour1<< *iterOnContour;
}else{
boardContour1 << CustomStyle( surfel.className() ,
new CustomColors( Color::Blue,
Color::Gray ));
boardContour1<< *iterOnContour;
}
}
boardContour1.saveFIG("illustrationAdjContour.fig");
// Extraction of contour
std::set<SCell> aContour2;
Surfaces<Z2i::KSpace>::trackBoundary( aContour2, ks,
sAdjInt,
aSet, surfel );
Board2D boardContour2;
boardContour2 << d;
std::set<SCell>::iterator iterOnContour2;
for( iterOnContour2= aContour2.begin(); iterOnContour2 != aContour2.end(); iterOnContour2++){
if(*iterOnContour2 != surfel){
boardContour2 << CustomStyle( surfel.className() ,
new CustomColors( Color::Red,
Color::White ));
boardContour2<< *iterOnContour2;
}else{
boardContour2 << CustomStyle( surfel.className() ,
new CustomColors( Color::Blue,
Color::Gray ));
boardContour2<< *iterOnContour2;
}
}
boardContour2.saveFIG("illustrationAdjContour2.fig");
return 0;
}