pixelpos.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 "vtkTIFFReader.h"
#include "vtkJPEGReader.h"
#include "vtkPNGReader.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkPolyData.h"
#include "vtkPoints.h"
#include "vtkIntArray.h"
#include "vtkCellArray.h"
#include "vtkPolyDataMapper.h"
#include "vtkLookupTable.h"
#include "vtkActor.h"
#include "vtkFloatArray.h"
#include "vtkTexture.h"
#include "vtkImageResample.h"
#include "vtkImageClip.h"
#include "vtkCamera.h"
#include "vtkImageShiftScale.h"
 
#include <sstream>
#include <string>
#include <iostream>
#include <vector>
 
#include "SimpleOpt.h"
 
#include "a_subpixel_interactor.h"
enum { OPT_HELP, OPT_Xm, OPT_Ym, OPT_XM, OPT_YM, OPT_OUT, OPT_IN, OPT_QUIET};
 
CSimpleOpt::SOption g_rgOptions[] = {
        { OPT_Xm,  _T("-xm"),     SO_REQ_SEP },
        { OPT_Ym,  _T("-ym"),     SO_REQ_SEP },
        { OPT_XM,  _T("-xM"),     SO_REQ_SEP },
        { OPT_YM,  _T("-yM"),     SO_REQ_SEP },
        { OPT_OUT, _T("-nof"),           SO_NONE    },
        { OPT_OUT, _T("--no-output-file"),     SO_NONE    },
        { OPT_IN,  _T("-i"),     SO_REQ_SEP },
        { OPT_IN,  _T("--input"),     SO_REQ_SEP },
        { OPT_QUIET, _T("-q"),     SO_NONE    },
        { OPT_QUIET, _T("--quit"),     SO_NONE    },
        { OPT_HELP, _T("-?"),     SO_NONE    },
        { OPT_HELP, _T("-h"),     SO_NONE    },
        { OPT_HELP, _T("--help"), SO_NONE    },
        SO_END_OF_OPTIONS
};
 
//---------------------------------------------------------------------------
int error(int val)
{
#include "pixelpos.help"
        return val;
}
 
bool with_output = true;
bool small_window = false;
bool verbose = true;
int xm = 0;
int ym = 0;
int xM = 100000;
int yM = 100000;
std::string name;
std::string input_file("");
 
//---------------------------------------------------------------------------
int error_tests(int argc, char ** argv)
{
        CSimpleOpt args(argc, argv, g_rgOptions);
        while (args.Next())
        {
                if (args.LastError() == SO_SUCCESS)
                {
                        if (args.OptionId() == OPT_HELP)
                                return error(-1);
                        else if (args.OptionId() == OPT_OUT)
                                with_output = false;
                        else if (args.OptionId() == OPT_QUIET)
                                verbose = false;
                        else if (args.OptionId() == OPT_Xm)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                in >> xm;
                        } else if (args.OptionId() == OPT_Ym)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                in >> ym;
                        } else if (args.OptionId() == OPT_XM)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                in >> xM;
                        } else if (args.OptionId() == OPT_YM)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                in >> yM;
                        } else if (args.OptionId() == OPT_IN)
                        {
                                input_file = args.OptionArg();
                        } else
                                return error(-2);
                        // 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(-3);
        name = args.File(0);
        return 0;
}
//---------------------------------------------------------------------------
int * window(int xm, int ym, int xM, int yM, int * dim)
{
        auto val = new int[6];
        val[0] = 0; val[1] = dim[0]-1;
        val[2] = 0; val[3] = dim[1]-1;
        val[4] = 0; val[5] = 0;
        if ((xm>0)&&(xm<dim[0]-1))
        {
                val[0] = xm;
                small_window = true;
        }
        if ((xM>xm)&&(xM<dim[0]-1))
        {
                val[1] = xM;
                small_window = true;
        }
        if ((ym>0)&&(ym<dim[1]-1))
        {
                val[2] = ym;
                small_window = true;
        }
        if ((yM>ym)&&(yM<dim[1]-1))
        {
                val[3] = yM;
                small_window = true;
        }
        return val;
}
//--------------Stroustroup, p.591
//comparisons without case
int cmp_nocase(const std::string& s, const std::string& s2)
{
        std::string::const_iterator p = s.begin();
        std::string::const_iterator p2 = s2.begin();
        while (p != s.end() && p2 != s2.end())
        {
                if (toupper(*p) != toupper(*p2))
                        return (toupper(*p) < toupper(*p2)) ? -1 : 1;
                ++p;
                ++p2;
        }
        return (s2.size() == s.size()) ? 0 : (s.size() < s2.size()) ? -1 : 1; //size is unsigned
}
//---------------------------------------------------------------------------
int main(int argc, char ** argv)
{
        int val = error_tests(argc, argv);
        if (val != 0) return val;
        std::string ext = name.substr(name.find_last_of('.')+1,name.size());
        vtkImageReader2 * reader;
        if ((cmp_nocase(ext,"tif")==0)||(cmp_nocase(ext,"tiff")==0))
                reader = (vtkImageReader2 *)vtkTIFFReader::New();
        else if ((cmp_nocase(ext,"jpg")==0)||(cmp_nocase(ext,"jpeg")==0))
                reader = (vtkImageReader2 *)vtkJPEGReader::New();
        else if ((cmp_nocase(ext,"png")==0)||(cmp_nocase(ext,"png")==0))
                reader = (vtkImageReader2 *)vtkPNGReader::New();
        else return error(-3);
        reader->SetFileName(name.c_str());
        reader->Update();
        int * dim = reader->GetOutput()->GetDimensions();
 
        if (verbose)
        {
                std::cerr << "Dimensions: " << dim[0] << " " << dim [1] << " [";
                std::cerr << reader->GetNumberOfScalarComponents() << " x ";
        }
        int dtype = reader->GetDataScalarType();
        if (verbose)
        {
                if (dtype == VTK_UNSIGNED_CHAR)
                        std::cerr << "unsigned char (8bits)";
                else if (dtype == VTK_UNSIGNED_SHORT)
                        std::cerr << "unsigned short (16bits)";
                else
                        std::cerr << "type (" << reader->GetDataScalarType() << ")";
                //implement other types if needed
                std::cerr << "]" << std::endl;
        }
 
        vtkRenderer *ren = vtkRenderer::New();
        vtkRenderWindow *renWin = vtkRenderWindow::New();
        renWin->AddRenderer(ren);
        ren->Delete();
 
        pixelpos_points coord(ren);
        if (!verbose)
                coord.quiet();
 
        int * dim2 = window(xm,ym,xM,yM,dim);
        vtkImageClip * clip = vtkImageClip::New();
        clip->SetInputConnection(reader->GetOutputPort());
        clip->SetOutputWholeExtent(dim2);
        double scale;
        if (reader->GetDataScalarType()==5)
                scale = 1./256.;
        else
                scale = 1.;
        vtkImageShiftScale * cast = vtkImageShiftScale::New();
        cast->SetInputConnection(clip->GetOutputPort());
        clip->Delete();
        cast->SetShift(0.);
        cast->SetScale(scale);
        cast->ClampOverflowOn();
        cast->SetOutputScalarTypeToUnsignedChar();
        vtkTexture * texture = vtkTexture::New();
        texture->SetInputConnection(cast->GetOutputPort());
        cast->Delete();
        texture->InterpolateOff();
        vtkFloatArray * tcoords = vtkFloatArray::New();
        tcoords->SetNumberOfComponents(2);
        tcoords->SetNumberOfTuples(4);
        float p[] = {0.,0.};
        tcoords->SetTuple(0,p);
        p[0] = 1.;
        tcoords->SetTuple(1,p);
        p[1] = 1.;
        tcoords->SetTuple(2,p);
        p[0] = 0.;
        tcoords->SetTuple(3,p);
        a_subpixel_interactor * style = a_subpixel_interactor::New();
        style->SetImage(reader);
        style->setpos(&coord);
        style->setscale(cast,scale);
        vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
        iren->SetRenderWindow(renWin);
        iren->SetInteractorStyle(style);
        style->Delete();
 
        float x[4][3]={{static_cast<float>(dim2[0]),static_cast<float>(dim2[2]),0.f}, 
                {static_cast<float>(dim2[1]),static_cast<float>(dim2[2]),0.f},
                {static_cast<float>(dim2[1]),static_cast<float>(dim2[3]),0.f},
                {static_cast<float>(dim2[0]),static_cast<float>(dim2[3]),0.f}};
        vtkIdType pts[1][4]={{0,1,2,3}};
 
        vtkPoints * points = vtkPoints::New();
        for (int i=0; i<4; i++) points->InsertPoint(i,x[i]);
        vtkCellArray * polys = vtkCellArray::New();
        polys->InsertNextCell(4,pts[0]);
        vtkPolyData * plane = vtkPolyData::New();
        plane->SetPoints(points);
        points->Delete();
        plane->SetPolys(polys);
        plane->GetPointData()->SetTCoords(tcoords);
        vtkPolyDataMapper * map = vtkPolyDataMapper::New();
        map->SetInputData(plane);
        plane->Delete();
        vtkActor * actor = vtkActor::New();
        actor->SetMapper(map);
        actor->DragableOff();
        map->Delete();
        actor->SetTexture(texture);
        texture->Delete();
        ren->AddActor(actor);
        actor->Delete();
 
        style->set(points,clip,dim[0],dim[1]);
 
        if (small_window)
        {
                vtkImageResample * resample = vtkImageResample::New();
                resample->SetInputConnection(reader->GetOutputPort());
                resample->SetAxisMagnificationFactor(0,.1);
                resample->SetAxisMagnificationFactor(1,.1);
                vtkTexture * texture2 = vtkTexture::New();
                texture2->SetInputConnection(resample->GetOutputPort());
                resample->Delete();
                float x2[4][3]={{0.f,0.f,0.f}, 
                        {static_cast<float>(dim[0]),0.f,-.5f}, 
                        {static_cast<float>(dim[0]),static_cast<float>(dim[1]),-.5f}, 
                        {0.f,static_cast<float>(dim[1]),-.5f}};
                vtkPoints * points2 = vtkPoints::New();
                for (int i=0; i<4; i++) points2->InsertPoint(i,x2[i]);
                vtkIntArray * scalars = vtkIntArray::New();
                scalars->SetNumberOfComponents(1);
                scalars->SetNumberOfTuples(4);
                for (int i=0; i<4; i++) scalars->SetTuple1(i,8);
 
                vtkPolyData * plane2 = vtkPolyData::New();
                plane2->SetPoints(points2);
                points2->Delete();
                plane2->SetPolys(polys);
                plane2->GetPointData()->SetScalars(scalars);
                scalars->Delete();
                plane2->GetPointData()->SetTCoords(tcoords);
                vtkLookupTable * lut = vtkLookupTable::New();
                lut->SetHueRange(0.6,0);
                lut->SetSaturationRange(.2,.2);
                lut->SetValueRange(1,1);
                vtkPolyDataMapper * map2 = vtkPolyDataMapper::New();
                map2->SetInputData(plane2);
                plane2->Delete();
                map2->SetScalarRange(0,10);
                map2->SetLookupTable(lut);
                lut->Delete();
                vtkActor *actor2 = vtkActor::New();
                actor2->SetMapper(map2);
                actor2->DragableOff();
                map2->Delete();
                actor2->SetTexture(texture2);
                texture2->Delete();
                ren->AddActor(actor2);
                actor2->Delete();
        }
        else
        {
                vtkActor * actor2 = vtkActor::New();
                ren->AddActor(actor2);
        }
 
        reader->Delete();
        tcoords->Delete();
        polys->Delete();
 
        vtkCamera * cam = ren->GetActiveCamera();
        cam->SetFocalPoint(dim[0]/2,dim[1]/2,0);
        cam->SetPosition(dim[0]/2,dim[1]/2,1);
        cam->ParallelProjectionOn();
        cam->SetParallelScale(dim[1]/2);
        ren->ResetCameraClippingRange();
        if (dim[1]<dim[0])
                renWin->SetSize(800,int(800*(double(dim[1])/double(dim[0]))));
        else
                renWin->SetSize(int(800*(double(dim[0])/double(dim[1]))),800);
 
        renWin->Render();
 
        if (input_file != "")
        {
                std::ifstream in(input_file.c_str());
                in >> coord;
                in.close();
        }
 
        renWin->SetWindowName(const_cast<char *>((std::string("PixelPos : ")+name).c_str()));
        iren->Start();
        renWin->Delete();
        iren->Delete();
 
        //      delete[] dim;
        //      delete[] dim2;
        if (with_output)
        {
                if (verbose)
                {
                        if (coord.size()==0)
                        {
                                std::cerr << std::endl << "no point extracted" << std::endl;
                                return 0;
                        }
                        if (coord.size()==1)
                                std::cerr << std::endl << "one point extracted" << std::endl;
                        else
                                std::cerr << std::endl << coord.size() << " points extracted" << std::endl;
                        std::cerr << std::endl;
                }
                std::cout << coord;
        }
 
        return 0;
}