3dSDPViewer.cpp

 
#include <iostream>
 
#include "DGtal/base/Common.h"
#include "DGtal/helpers/StdDefs.h"
#include "DGtal/io/viewers/Viewer3D.h"
#include "DGtal/io/DrawWithDisplay3DModifier.h"
#include "DGtal/io/readers/TableReader.h"
#include "DGtal/io/readers/PointListReader.h"
#include "DGtal/io/readers/MeshReader.h"
#include "DGtal/topology/helpers/Surfaces.h"
#include "DGtal/topology/SurfelAdjacency.h"
#include "DGtal/shapes/Mesh.h"
#include "DGtal/io/Color.h"
#include "DGtal/io/colormaps/HueShadeColorMap.h"
#include "DGtal/io/readers/GenericReader.h"
#include "DGtal/io/DrawWithDisplay3DModifier.h"
 
#include "CLI11.hpp"
 
using namespace std;
using namespace DGtal;
using namespace Z3i;
 
typedef Viewer3D<Z3i::Space, Z3i::KSpace> Viewer;
 
// call back function to display voxel coordinates
int displayCoordsCallBack(void *viewer, int name, void *data)
{
  vector<Z3i::RealPoint> *vectVoxels = (vector<Z3i::RealPoint> *)data;
  std::stringstream ss;
  ss << "Selected voxel: (" << (*vectVoxels)[name][0] << ", ";
  ss << (*vectVoxels)[name][1] << ", ";
  ss << (*vectVoxels)[name][2] << ") ";
  ((Viewer *)viewer)->displayMessage(QString(ss.str().c_str()), 100000);
 
  return 0;
}
 
int main(int argc, char **argv)
{
  // parse command line using CLI ----------------------------------------------
  CLI::App app;
  std::string inputFileName;
  std::vector<unsigned int> vectIndexSDP{0, 1, 2};
  Color lineColor(100, 100, 250);
  Color pointColor(250, 250, 250);
  std::vector<int> vectColorPt;
  std::vector<int> vectColorLine;
  std::string meshName;
  std::string typePrimitive{"voxel"};
  std::string vectorsFileName;
  std::vector<double> vectSphereRadius;
  std::vector<unsigned int> vectColMesh;
  std::vector<unsigned int> vectIndexColorImport{3, 4, 5};
  bool importColorLabels{false};
  bool noPointDisplay{false};
  bool drawLines{false};
  bool sphereRadiusFromInput{true};
  bool importColors{false};
  bool interactiveDisplayVoxCoords{false};
  float sx{1.0};
  float sy{1.0};
  float sz{1.0};
  unsigned int sphereResolution{30};
  double sphereRadius{0.2};
  double lineSize{0.2};
  double filterValue{100.0};
  double constantNorm{0.0};
  double percentageFilterVect{100.0};
  unsigned int customAlphaMesh;
 
  unsigned int colorLabelIndex = 3;
 
  app.description("Display sequence of 3d discrete points by using QGLviewer.");
  app.add_option("-i,--input,1", inputFileName, "input file: sdp (sequence of discrete points).")
      ->required()
      ->check(CLI::ExistingFile);
  app.add_option("--SDPindex", vectIndexSDP, "specify the sdp index (by default 0,1,2).")
      ->expected(3);
  app.add_option("--pointColor,-c", vectColorPt, "set the color of  points: r g b a.")
      ->expected(4);
  app.add_option("--lineColor,-l", vectColorLine, "set the color of line: r g b a.")
      ->expected(4);
  app.add_option("--addMesh,-m", meshName, "append a mesh (off/obj) to the point set visualization.");
  app.add_option("--customAlphaMesh", customAlphaMesh, "set the alpha components of the colors of the mesh faces (can be applied for each mesh).");
  auto optMesh = app.add_option("--customColorMesh", vectColMesh, "set the R, G, B, A components of the colors of the mesh faces (mesh added with option --addMesh).")
                     ->expected(4);
  auto importColOpt = app.add_flag("--importColors", importColors, "import point colors from the input file (R G B colors should be by default at index 3, 4, 5).");
  app.add_option("--setColorsIndex", vectIndexColorImport, "customize the index of the imported colors in the source file (used by --importColor). By default the initial indexes are 3, 4, 5.")
      ->expected(3)
      ->needs(importColOpt);
 
  app.add_flag("--importColorLabels", importColorLabels, "import color labels from the input file (label index  should be by default at index 3).");
  app.add_option("--setColorLabelIndex", colorLabelIndex, "customize the index of the imported color labels in the source file (used by -importColorLabels).", true);
  app.add_option("--filter,-f", filterValue, "filter input file in order to display only the [arg] percent of the input 3D points (uniformly selected).", true);
  app.add_flag("--noPointDisplay", noPointDisplay, "usefull for instance to only display the lines between points.");
  app.add_flag("--drawLines", drawLines, "draw the line between discrete points.");
  app.add_option("--scaleX,-x", sx, "set the scale value in the X direction", true);
  app.add_option("--scaleY,-y", sy, "set the scale value in the Y direction", true);
  app.add_option("--scaleZ,-z", sy, "set the scale value in the Z direction", true);
  app.add_option("--sphereResolution", sphereResolution, "defines the sphere resolution (used when the primitive is set to the sphere).", true);
  app.add_option("-s,--sphereRadius", sphereRadius, "defines the sphere radius (used when the primitive is set to the sphere).", true);
  app.add_flag("--sphereRadiusFromInput", sphereRadiusFromInput, "takes, as sphere radius, the 4th field of the sdp input file.");
  app.add_option("--lineSize", lineSize, "defines the line size (used when the --drawLines or --drawVectors option is selected).", true);
  app.add_option("--primitive,-p", typePrimitive, "set the primitive to display the set of points.", true)
      ->check(CLI::IsMember({"voxel", "glPoints", "sphere"}));
  app.add_option("--drawVectors,-v", vectorsFileName, "SDP vector file: draw a set of vectors from the given file (each vector are determined by two consecutive point given, each point represented by its coordinates on a single line.");
 
  app.add_option("--unitVector,-u", constantNorm, "specifies that the SDP vector file format (of --drawVectors option) should be interpreted as unit vectors (each vector position is be defined from the input point (with input order) with a constant norm defined by [arg]).", true);
 
  app.add_option("--filterVectors", percentageFilterVect, "filters vector input file in order to display only the [arg] percent of the input vectors (uniformly selected, to be used with option --drawVectors else no effect). ", true);
  app.add_flag("--interactiveDisplayVoxCoords", interactiveDisplayVoxCoords, " by using this option the coordinates can be displayed after selection (shift+left click on voxel).");
 
  app.get_formatter()->column_width(40);
  CLI11_PARSE(app, argc, argv);
  // END parse command line using CLI ----------------------------------------------
 
  if (vectColorLine.size() == 4)
  {
    lineColor.setRGBi(vectColorLine[0], vectColorLine[1], vectColorLine[2], vectColorLine[3]);
  }
  if (vectColorPt.size() == 4)
  {
    pointColor.setRGBi(vectColorPt[0], vectColorPt[1], vectColorPt[2], vectColorPt[3]);
  }
 
  QApplication application(argc, argv);
 
  bool useUnitVector = constantNorm != 0.0;
 
  typedef Viewer3D<Z3i::Space, Z3i::KSpace> Viewer;
  Z3i::KSpace K;
  Viewer viewer(K);
  viewer.setWindowTitle("3dSPD Viewer");
  viewer.show();
  viewer.setGLScale(sx, sy, sz);
  viewer.myGLLineMinWidth = lineSize;
  viewer << CustomColors3D(pointColor, pointColor);
 
  // Get vector of colors if imported.
  std::vector<Color> vectColors;
  if (importColors)
  {
    std::vector<unsigned int> r = TableReader<unsigned int>::getColumnElementsFromFile(inputFileName, vectIndexColorImport[0]);
    std::vector<unsigned int> g = TableReader<unsigned int>::getColumnElementsFromFile(inputFileName, vectIndexColorImport[1]);
    std::vector<unsigned int> b = TableReader<unsigned int>::getColumnElementsFromFile(inputFileName, vectIndexColorImport[2]);
    for (unsigned int i = 0; i < r.size(); i++)
    {
      vectColors.push_back(Color(r[i], g[i], b[i]));
    }
  }
 
  // Get vector of colors if imported.
  std::vector<int> vectColorLabels;
  unsigned int maxLabel = 1;
  if (importColorLabels)
  {
    vectColorLabels = TableReader<int>::getColumnElementsFromFile(inputFileName, colorLabelIndex);
    maxLabel = *(std::max_element(vectColorLabels.begin(), vectColorLabels.end()));
  }
  HueShadeColorMap<unsigned int> aColorMap(0, maxLabel);
 
  if (sphereRadiusFromInput)
  {
    vectSphereRadius = TableReader<double>::getColumnElementsFromFile(inputFileName, 3);
  }
 
  vector<Z3i::RealPoint> vectVoxels;
  vectVoxels = PointListReader<Z3i::RealPoint>::getPointsFromFile(inputFileName, vectIndexSDP);
 
  int name = 0;
  if (!noPointDisplay)
  {
    if (typePrimitive == "glPoints")
    {
      viewer.setUseGLPointForBalls(true);
    }
 
    int step = max(1, (int)(100 / filterValue));
    for (unsigned int i = 0; i < vectVoxels.size(); i = i + step)
    {
      if (importColors)
      {
        Color col = vectColors[i];
        viewer.setFillColor(col);
      }
      else if (importColorLabels)
      {
        unsigned int index = vectColorLabels[i];
        Color col = aColorMap(index);
        viewer.setFillColor(col);
      }
 
      if (typePrimitive == "voxel")
      {
        if (interactiveDisplayVoxCoords)
        {
          viewer << SetName3D(name++);
        }
        viewer << Z3i::Point((int)vectVoxels.at(i)[0],
                             (int)vectVoxels.at(i)[1],
                             (int)vectVoxels.at(i)[2]);
      }
      else
      {
        viewer.addBall(vectVoxels.at(i), sphereRadius, sphereResolution);
      }
    }
 
    viewer << CustomColors3D(lineColor, lineColor);
    if (drawLines)
    {
      for (unsigned int i = 1; i < vectVoxels.size(); i++)
      {
        viewer.addLine(vectVoxels.at(i - 1), vectVoxels.at(i), lineSize);
      }
    }
 
    if (vectorsFileName != "")
    {
      std::vector<Z3i::RealPoint> vectorsPt = PointListReader<Z3i::RealPoint>::getPointsFromFile(vectorsFileName);
      if (vectorsPt.size() % 2 == 1)
      {
        trace.info() << "Warning the two set of points doesn't contains the same number of points, some vectors will be skipped." << std::endl;
      }
 
      double percentage = percentageFilterVect;
      int step = max(1, (int)(100 / percentage));
 
      if (useUnitVector)
      {
        for (unsigned int i = 0; i < std::min(vectVoxels.size(), vectorsPt.size()); i = i + 2 * step)
        {
          viewer.addLine(vectVoxels.at(i), vectVoxels.at(i) + vectorsPt.at(i) * constantNorm, lineSize);
        }
      }
      else
      {
        for (unsigned int i = 0; i < vectorsPt.size() - 1; i = i + 2 * step)
        {
          viewer.addLine(vectorsPt.at(i), vectorsPt.at(i + 1), lineSize);
        }
      }
    }
    if (meshName != "")
    {
      bool customColorMesh = vectColMesh.size() == 4;
      if (customColorMesh)
      {
        viewer.setFillColor(DGtal::Color(vectColMesh[0], vectColMesh[1], vectColMesh[2], vectColMesh[3]));
      }
      Mesh<Z3i::RealPoint> mesh(!customColorMesh);
      mesh << meshName;
      if (customAlphaMesh)
      {
        for (unsigned int j = 0; j < mesh.nbFaces(); j++)
        {
          auto c = mesh.getFaceColor(j);
          mesh.setFaceColor(j, Color(c.red(), c.green(), c.blue(), customAlphaMesh));
        }
        viewer << mesh;
      }
      if (interactiveDisplayVoxCoords)
      {
        viewer << SetSelectCallback3D(displayCoordsCallBack, &vectVoxels, 0, vectVoxels.size() - 1);
      }
 
      viewer << Viewer3D<>::updateDisplay;
      return application.exec();
    }
  }
}