view_li.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 "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkInteractorStyleTrackballCamera.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkPolyData.h"
#include "vtkPoints.h"
#include "vtkProperty.h"
#include "vtkCellData.h"
#include "vtkCellArray.h"
#include "vtkDoubleArray.h"
#include "vtkElevationFilter.h"
#include "vtkPolyDataMapper.h"
#include "vtkPolyDataNormals.h"
#include "vtkLookupTable.h"
#include "vtkDataSetMapper.h"
#include "vtkActor.h"
#include "vtkLODActor.h"
#include "vtkAxes.h"
#include "vtkPointData.h"
 
#include "a_interactor.h"
#include "a_pmat.h"
 
#include <iostream>
#include <sstream>
 
#include "SimpleOpt.h"
 
enum { OPT_HELP, OPT_DIR, OPT_SMOOTH, OPT_TRI, OPT_PTSIZE, OPT_CAMERA, OPT_IMAGE, OPT_GREY, OPT_SCALAR, OPT_SCALARD, OPT_SCALARL, OPT_STEPS, OPT_MAG, OPT_TRA, OPT_AXES };
 
CSimpleOpt::SOption g_rgOptions[] = {
        { OPT_DIR, _T("-x"),     SO_NONE    },
        { OPT_DIR, _T("-y"),     SO_NONE    },
        { OPT_DIR, _T("-z"),     SO_NONE    },
        { OPT_DIR, _T("-0"),     SO_NONE    },
        { OPT_SMOOTH, _T("-s"),     SO_NONE    },
        { OPT_SMOOTH, _T("--smooth"),     SO_NONE    },
        { OPT_GREY,  _T("-g"),     SO_NONE    },
        { OPT_GREY,  _T("--greyscale"),     SO_NONE    },
        { OPT_STEPS,  _T("-b"),     SO_REQ_SEP },
        { OPT_STEPS,  _T("--bands"),     SO_REQ_SEP },
        { OPT_TRA,_T("-tr"),     SO_NONE    },
        { OPT_MAG,  _T("-m"),     SO_REQ_SEP },
        { OPT_MAG,  _T("--magnification"),     SO_REQ_SEP },
        { OPT_TRI,  _T("-t"),     SO_REQ_SEP },
        { OPT_TRI,  _T("--triangle"),     SO_REQ_SEP },
        { OPT_CAMERA,  _T("-c"),     SO_REQ_SEP },
        { OPT_CAMERA,  _T("--camera"),     SO_REQ_SEP },
        { OPT_IMAGE,  _T("-i"),     SO_REQ_SEP },
        { OPT_IMAGE,  _T("--image"),     SO_REQ_SEP },
        { OPT_SCALAR, _T("-sf"),     SO_REQ_SEP },
        { OPT_SCALAR, _T("--scalar-file"),     SO_REQ_SEP },
        { OPT_SCALARD, _T("-si"),     SO_NONE    },
        { OPT_SCALARD, _T("--scalar-invert"),     SO_NONE    },
        { OPT_SCALARL, _T("-sl"),     SO_NONE    },
        { OPT_SCALARL, _T("--scalar-lines"),     SO_NONE    },
        { OPT_PTSIZE,  _T("-p"),     SO_REQ_SEP },
        { OPT_AXES,_T("-a"),     SO_NONE    },  
        { OPT_AXES,_T("--axes"),     SO_NONE    },
        { OPT_HELP, _T("-?"),     SO_NONE    },
        { OPT_HELP, _T("-h"),     SO_NONE    },
        { OPT_HELP, _T("--help"), SO_NONE    },
        SO_END_OF_OPTIONS
};
 
vtkRenderer * ren;
bool smooth = false;
bool with_camera_file = false;
a_pmat pmat;
std::string image_file("");
int * bb;
bool is_textured = false;
bool is_transparent = false;
 
//---------------------------------------------------------------------------
int error(int val)
{
#include "view_li.help"
        return val;
}
 
#include "view_pt_li_common.cxx"
 
//---------------------------------------------------------------------------
int main(int argc, char ** argv)
{
        std::string tri_file;
        bool with_scalars = false;
        int li_width = 3;
        int magnification = 1;
        bool is_greyscale = false;
        double number_steps = 256;
        double m_scalar = 1.e30;
        double M_scalar = -1.e30;
        bool invert_scalar = false;
        bool line_scalar = false;
        bool with_axes = false;
        std::string code("z");
        std::string scalar_file;        
        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_DIR)
                        {
                                std::string code0(args.OptionText());
                                code = code0.substr(1,1);
                        }
                        else if (args.OptionId() == OPT_SMOOTH)
                                smooth = true;
                        else if (args.OptionId() == OPT_TRA)
                                is_transparent = true;
                        else if (args.OptionId() == OPT_GREY)
                                is_greyscale = true;
                        else if (args.OptionId() == OPT_SCALARD)
                                invert_scalar = true;
                        else if (args.OptionId() == OPT_SCALARL)
                                line_scalar = true;
                        else if (args.OptionId() == OPT_SCALAR)
                        {
                                with_scalars = true;
                                code = "s";
                                scalar_file = args.OptionArg();
                        }       
                        else if (args.OptionId() == OPT_TRI)
                        {
                                tri_file = args.OptionArg();
                        }
                        else if (args.OptionId() == OPT_PTSIZE)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                int size;
                                in >> size;
                                if ((size > 0)&&(size < 100))
                                        li_width = size;
                        }
                        else if (args.OptionId() == OPT_STEPS)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                int size;
                                in >> size;
                                if ((size > 0)&&(size < 256))
                                        number_steps = size;
                        }
                        else if (args.OptionId() == OPT_MAG)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                int size;
                                in >> size;
                                if ((size > 1)&&(size < 100))
                                        magnification = size;
                        } else if (args.OptionId() == OPT_CAMERA)
                        {
                                std::ifstream in(args.OptionArg());
                                if (!in)
                                {
                                        std::cerr << "cannot open file: '" << args.OptionArg() << "'" << std::endl;
                                        return error(-3);
                                }
                                in >> pmat;
                                with_camera_file = true;
                        } else if (args.OptionId() == OPT_IMAGE)
                                image_file = args.OptionArg();
                        else if (args.OptionId() == OPT_AXES)
                                with_axes = 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
                }
        }
 
        bool flat = false;
        if ((with_camera_file)&&(image_file != "")) is_textured = true;
        vtkPoints * pts = vtkPoints::New();
        vtkDoubleArray * scalars;
        if (with_scalars)
        {
                std::ifstream in(scalar_file.c_str());
                if (!in)
                {
                        std::cerr << "Cannot open file '" << scalar_file << "'" << std::endl;
                        return error(-2);
                }
                scalars = vtkDoubleArray::New();
                scalars->SetNumberOfComponents(1);
                int nlis;
                in >> nlis;
                short nj=2;
                if (line_scalar)
                        nj=1;
                for (unsigned int i=0; i<nlis; i++)
                {
                        for (short j=0; j<nj; j++)
                        {
                                double val;
                                in >> val;
                                if (val<m_scalar)
                                        m_scalar = val;
                                if (val>M_scalar)
                                        M_scalar = val;
                                scalars->InsertNextValue(val);
                        }
                }
        }
        int nlis;
        std::cin >> nlis;
        for (unsigned int k = 0; k < nlis; k++)
        {
                for (short j=0; j<2; j++)
                {
                        double x,y,z;
                        std::cin >> x >> y >> z;
                        pts->InsertNextPoint(x,y,z);
                }
        }
        ren = vtkRenderer::New();
        vtkRenderWindow * renWin = vtkRenderWindow::New();
        renWin->AddRenderer(ren);
        renWin->SetStereoTypeToAnaglyph();
        ren->Delete();
        a_interactor * style = a_interactor::New();
        style->name("view_li");
        if (magnification != 1)
                style->magnification(magnification);
        vtkRenderWindowInteractor * iren =  vtkRenderWindowInteractor::New();
        iren->SetRenderWindow(renWin);
        renWin->Delete();
        iren->SetInteractorStyle(style);
        iren->LightFollowCameraOff();
        vtkCellArray * lines = vtkCellArray::New();
        for (unsigned int k = 0; k < nlis; k++)
        {
                vtkIdType co[] = {2*k,2*k+1};
                lines->InsertNextCell(2,co);
        }
        vtkPolyData * data = vtkPolyData::New();
        data->SetPoints(pts);
        pts->Delete();
        data->SetLines(lines);
        lines->Delete();
        if (with_scalars)
        {
                if (line_scalar)
                        data->GetCellData()->SetScalars(scalars);
                else
                        data->GetPointData()->SetScalars(scalars);
        }
        double bd[6];
        pts->GetBounds(bd);
 
        vtkElevationFilter * elevation = vtkElevationFilter::New();
        if (code == "0")
                flat = true;
        else if (code != "s")
        {
                elevation = vtkElevationFilter::New();
                elevation->SetInputData(data);
                data->Delete();
                elevation->SetScalarRange(0,20);
        }
        if (code == "x")
        {
                if (bd[0]==bd[1])
                        flat = true;
                else
                {
                        elevation->SetLowPoint(bd[0],0,0);
                        elevation->SetHighPoint(bd[1],0,0);
                }
        }
        else if (code == "y")
        {
                if (bd[2]==bd[3])
                        flat = true;
                else
                {
                        elevation->SetLowPoint(0,bd[2],0);
                        elevation->SetHighPoint(0,bd[3],0);
                }
        }
        else if (code == "z")
        {
                if (bd[4]==bd[5])
                        flat = true;
                else
                {
                        elevation->SetLowPoint(0,0,bd[4]);
                        elevation->SetHighPoint(0,0,bd[5]);
                }
        }
        vtkDataSetMapper * map = vtkDataSetMapper::New();
        map->SetResolveCoincidentTopologyToShiftZBuffer();
        if ((!flat)||(with_scalars))
        {
                vtkLookupTable * lut = vtkLookupTable::New();
                lut->SetNumberOfTableValues(number_steps);
                if (is_greyscale)
                {
                        lut->SetHueRange(0,0);
                        lut->SetSaturationRange(0,0);
                        if (invert_scalar)
                                lut->SetValueRange(1,0);
                        else
                                lut->SetValueRange(0,1);        
                } else
                {
                        if (invert_scalar)
                                lut->SetHueRange(0,0.6);
                        else
                                lut->SetHueRange(0.6,0);
                        lut->SetSaturationRange(1,1);
                        lut->SetValueRange(1,1);
                }
                map->SetLookupTable(lut);
                lut->Delete();
                if (with_scalars)
                {
                        map->SetScalarRange(m_scalar,M_scalar);
                        map->SetInputData(data);
                        data->Delete();
                }
                else
                {
                        map->SetInputConnection(elevation->GetOutputPort());
                        elevation->Delete();
                        map->SetScalarRange(0,20);
                }
        }
        else
        {
                map->SetInputData(data);
                data->Delete();
        }
        vtkActor * actor;
        if (nlis>20000)
        {
                actor = vtkLODActor::New();
                ((vtkLODActor *)(actor))->SetNumberOfCloudPoints(5000);//set more than default to give a nice impression
        }
        else
                actor = vtkActor::New();
        actor->SetMapper(map);
        map->Delete();
        actor->GetProperty()->SetLineWidth(li_width);
        actor->GetProperty()->SetInterpolationToFlat();
        ren->AddActor(actor);
        actor->Delete();
        if (tri_file != "")
                view_triangles(tri_file,flat);
        renWin->SetSize(640,480);
        renWin->SetWindowName("view_pt (central)");
        if (with_axes)
        {
                vtkAxes * axes = vtkAxes::New();
                axes->SetOrigin(0.,0.,0.);
                axes->SetScaleFactor(1.);
                vtkLookupTable * lut = vtkLookupTable::New();
                lut->SetHueRange(0,1);
                lut->SetSaturationRange(1,1);
                lut->SetValueRange(1,1);
                vtkPolyDataMapper * map = vtkPolyDataMapper::New();
                map->SetInputConnection(axes->GetOutputPort());
                axes->Delete();
                map->SetLookupTable(lut);
                lut->Delete();
                actor = vtkActor::New();
                actor->SetMapper(map);
                map->Delete();
                actor->GetProperty()->SetLineWidth(3);
                actor->GetProperty()->SetInterpolationToFlat();
                ren->AddActor(actor);
        }
        renWin->SetSize(renWin->GetScreenSize());
        renWin->Render();
        iren->Start();
        return 0;
}