im2li.cxx

Go to the documentation of this file.

/*
         Copyright 2008-2019 Pierre SMARS (smars@yuntech.edu.tw)
         This program is free software: you can redistribute it and/or modify
         it under the terms of the GNU General Public License as published by
         the Free Software Foundation, either version 2 of the License, or
         (at your option) any later version.
 
         This program is distributed in the hope that it will be useful,
         but WITHOUT ANY WARRANTY; without even the implied warranty of
         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
         GNU General Public License for more details.
 
         You should have received a copy of the GNU General Public License
         along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#include <iostream>
#include <sstream>
#include <vil/vil_load.h>
#include <vil/vil_convert.h>
#include <vil/vil_image_view.h>
#include <vil1/vil1_vil.h>
#include <vil1/vil1_memory_image_of.h>
#include <osl/osl_canny_ox_params.h>
#include <osl/osl_canny_ox.h>
#include "vtkKochanekSpline.h"
 
#include "SimpleOpt.h"
 
enum { OPT_HELP, OPT_SIGMA, OPT_SPLINE, OPT_VERBOSE };
 
CSimpleOpt::SOption g_rgOptions[] = {
        { OPT_SIGMA, _T("-s"),     SO_REQ_SEP   },
        { OPT_SIGMA, _T("--sigma"),     SO_REQ_SEP   },
        { OPT_SPLINE, _T("-r"),     SO_REQ_SEP   },
        { OPT_SPLINE, _T("--regularize"),     SO_REQ_SEP   },
        { OPT_VERBOSE, _T("-v"),     SO_NONE    },
        { OPT_VERBOSE, _T("--verbose"),     SO_NONE    },
        { OPT_HELP, _T("-?"),     SO_NONE    },
        { OPT_HELP, _T("-h"),     SO_NONE    },
        { OPT_HELP, _T("--help"), SO_NONE    },
        SO_END_OF_OPTIONS
};
//---------------------------------------------------------------------------
class a_line
{
        public:
                a_line(double * x0, double * x);
                friend   std::ostream&    operator<< (std::ostream& o, const a_line& l);
        protected:
                double   x0_[2];
                double   x_[2];
};
//---------------------------------------------------------------------------
a_line::a_line(double * x0, double * x)
{
        for (int i=0; i<2; i++)
        {
                x0_[i] = x0[i];
                x_[i] = x[i];
        }
}
//---------------------------------------------------------------------------
std::ostream& operator<< (std::ostream& o, const a_line& l)
{
        o << l.x0_[0] << " " << l.x0_[1] << " 0 " << l.x_[0] << " " << l.x_[1] << " 0" << std::endl;
        return o;
}
//---------------------------------------------------------------------------
int error(int val)
{
#include "im2li.help"
        return val;
}
//---------------------------------------------------------------------------
double round(double val)
{
        return (int)(val*10+.5)/10.;
}
//---------------------------------------------------------------------------
int main(int argc, char **argv)
{
        bool with_spline = false;
        double step = 10.;
        double tension = 0;
        double bias = 0;
        double continuity = 0;
        bool verbose = false;
        osl_canny_ox_params params;
        CSimpleOpt args(argc, argv, g_rgOptions);
        while (args.Next())
        {
                if (args.LastError() == SO_SUCCESS)
                {
                        if (args.OptionId() == OPT_HELP)
                                return error(0);
                        else if (args.OptionId() == OPT_VERBOSE)
                                verbose=true;
                        else if (args.OptionId() == OPT_SIGMA)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                in >> params.sigma;
                        }
                        else if (args.OptionId() == OPT_SPLINE)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                in >> step;
                                if ((step <= 0.)||(step>1000.))
                                        return error(-3);
                                with_spline = true;
                        }
                        else
                                return error(-1);
                        // handle option, using OptionId(), OptionText() and OptionArg()
                } else {
                        std::cerr << "Invalid argument: " << args.OptionText() << std::endl;
                        return error(args.LastError());
                        // handle error, one of: SO_OPT_INVALID, SO_OPT_MULTIPLE,
                        // SO_ARG_INVALID, SO_ARG_INVALID_TYPE, SO_ARG_MISSING
                }
        }
        if (args.FileCount() != 1) return error(-2);
        std::string in_file = args.File(0);
        params.verbose=verbose;
        vil_image_view<vxl_byte> img;
        img = vil_convert_stretch_range (vxl_byte(), vil_convert_to_component_order(
                                vil_convert_to_n_planes(1, vil_convert_cast(vxl_byte(), vil_load(in_file.c_str())))));
        if (!img)
                return 1;
        if (verbose)
                std::cerr << in_file << " : " << img << std::endl;
        vil1_memory_image_of<vxl_byte> image = vil1_from_vil_image_view(img);
        if (verbose)
                std::cerr << "operates on : " << image << std::endl;
        std::list<a_line> lines;
        std::list<osl_edge*> edges;
        //segment the image
        osl_canny_ox filter(params);
        filter.detect_edges(image, &edges);
        //double dist = 0;
        for(std::list<osl_edge*>::iterator i=edges.begin(); i != edges.end(); ++i)
        {
                //length of the polyline
                double dist = 0.;
                vtkKochanekSpline * s[2];
                if (with_spline)
                {
                        for (int j = 0; j < 2; j++)
                        {
                                s[j] = vtkKochanekSpline::New();
                                s[j]->SetDefaultTension(tension);
                                s[j]->SetDefaultBias(bias);
                                s[j]->SetDefaultContinuity(continuity);
                        }
                }
                double x0[2], x[2];
                //origin of polyline
                x0[0] = (*i)->GetX(0);
                x0[1] = (*i)->GetY(0);
                if (with_spline)
                        for (int j = 0; j < 2; j++) s[j]->AddPoint(0,x0[j]);
                //add control point to the spline
                for (int j=1; j<(*i)->size(); j++)
                {
                        //point on polyline
                        x[0] = (*i)->GetX(j);
                        x[1] = (*i)->GetY(j);
                        if (with_spline)
                        {
                                //calculate length of polyline
                                dist += sqrt((x[0]-x0[0])*(x[0]-x0[0])+(x[1]-x0[1])*(x[1]-x0[1]));
                                //add control point to the spline
                                for (int k = 0; k < 2; k++) s[k]->AddPoint(dist,x[k]);
                        }
                        else
                                lines.push_back(a_line(x0,x));
                        //record line for later output
                        for (int k = 0; k < 2; k++) x0[k]=x[k];
                }
                if (with_spline)
                {
                        //number of points on interpolated polyline
                        double n_pt = (int)dist/step;
                        if (n_pt != 0)
                        {
                                double t = 0.;
                                //evaluate the spline
                                for (int j=0; j<2; j++)
                                        x0[j] = s[j]->Evaluate(0.);
                                for (int j=1; j<n_pt; j++)
                                {
                                        t+= step;
                                        //evaluate the spline
                                        for (int k=0; k<2; k++)
                                                x[k] = s[k]->Evaluate(t);
                                        a_line test(x0,x0);
                                        //record line for later output
                                        lines.push_back(a_line(x0,x));
                                        for (int k=0; k<2; k++)
                                                x0[k] = x[k];
                                }
                        }
                        for (int j = 0; j < 2; j++) s[j]->Delete();
                } 
        }
        //output all the lines
        std::cout << lines.size() << std::endl;
        for(std::list<a_line>::iterator li=lines.begin(); li != lines.end(); ++li)
                std::cout << (*li); 
        return 0;
}