Example #1
0
  /* \brief Visual update. Create visualizations and add them to the viewer
   *
   */
  void update()
  {
    //remove existing shapes from visualizer
    clearView();

    //prevent the display of too many cubes
    bool displayCubeLegend = displayCubes && static_cast<int> (displayCloud->points.size ()) <= MAX_DISPLAYED_CUBES;

    showLegend(displayCubeLegend);

    if (displayCubeLegend)
    {
      //show octree as cubes
      showCubes(sqrt(octree.getVoxelSquaredSideLen(displayedDepth)));
      if (showPointsWithCubes)
      {
        //add original cloud in visualizer
        pcl::visualization::PointCloudColorHandlerGenericField<pcl::PointXYZ> color_handler(cloud, "z");
        viz.addPointCloud(cloud, color_handler, "cloud");
      }
    }
    else
    {
      //add current cloud in visualizer
      pcl::visualization::PointCloudColorHandlerGenericField<pcl::PointXYZ> color_handler(displayCloud,"z");
      viz.addPointCloud(displayCloud, color_handler, "cloud");
    }
  }
Example #2
0
/**
 * Main (what else?)
 */
int main()
{

	init();

	while(1)
	{
		color_handler();
	}
}
Example #3
0
void
pcl::modeler::CloudMesh::getColorScalarsFromField(vtkSmartPointer<vtkDataArray> &scalars, const std::string& field) const
{
  if (field == "rgb" || field == "rgba")
  {
    pcl::visualization::PointCloudColorHandlerRGBField<PointT> color_handler(cloud_);
    color_handler.getColor(scalars);
    return;
  }

  if (field == "random")
  {
    pcl::visualization::PointCloudColorHandlerRandom<PointT> color_handler(cloud_);
    color_handler.getColor(scalars);
    return;
  }

  pcl::visualization::PointCloudColorHandlerGenericField<PointT> color_handler(cloud_, field);
  color_handler.getColor(scalars);

  return;
}
Example #4
0
template <typename PointT> void
FrameCloudView<PointT>::show ()
{
    if (cloud_ && cld_mutex_.try_lock())
    {
        pcl::visualization::PointCloudColorHandlerRGBField<PointT> color_handler (cloud_);

        if (!visualizer_.updatePointCloud<PointT> (cloud_, color_handler, cloud_id_))
        {
            visualizer_.addPointCloud<PointT> (cloud_, color_handler, cloud_id_);
            visualizer_.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, cloud_id_);
        }
        cld_mutex_.unlock();
    }
}
Example #5
0
    template <typename PointT> bool 
    PCLVisualizer::addPointCloud (
      const typename pcl::PointCloud<PointT>::ConstPtr &cloud, 
      const PointCloudGeometryHandler<PointT> &geometry_handler,
      const std::string &id, int viewport)
    {
      // Check to see if this ID entry already exists (has it been already added to the visualizer?)
      CloudActorMap::iterator am_it = cloud_actor_map_->find (id);

      if (am_it != cloud_actor_map_->end ())
      {
        PCL_WARN ("[addPointCloud] A PointCloud with id <%s> already exists! Please choose a different id and retry.\n", id.c_str ());
        return (false);
      }
  
      //PointCloudColorHandlerRandom<PointT> color_handler (cloud);
      PointCloudColorHandlerCustom<PointT> color_handler (cloud, 255, 255, 255);
      return (fromHandlersToScreen (geometry_handler, color_handler, id, viewport));
    }
Example #6
0
    template <typename PointT> bool 
    PCLVisualizer::addPointCloud (
      const typename pcl::PointCloud<PointT>::ConstPtr &cloud, 
      const GeometryHandlerConstPtr &geometry_handler,
      const std::string &id, int viewport)
    {
      // Check to see if this ID entry already exists (has it been already added to the visualizer?)
      CloudActorMap::iterator am_it = cloud_actor_map_->find (id);

      if (am_it != cloud_actor_map_->end ())
      {
        // Here we're just pushing the handlers onto the queue. If needed, something fancier could
        // be done such as checking if a specific handler already exists, etc.
        am_it->second.geometry_handlers.push_back (geometry_handler);
        return (true);
      }

      //PointCloudColorHandlerRandom<PointT> color_handler (cloud);
      PointCloudColorHandlerCustom<PointT> color_handler (cloud, 255, 255, 255);
      return (fromHandlersToScreen (geometry_handler, color_handler, id, viewport));
    }
    void
    viz_cb (pcl::visualization::PCLVisualizer& viz)
    {
      boost::mutex::scoped_lock lock (mtx_);
      if (!keypoints_ && !cloud_)
      {
        boost::this_thread::sleep(boost::posix_time::seconds(1));
        return;
      }

      FPS_CALC ("visualization");
      viz.removePointCloud ("raw");
      pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGBA> color_handler (cloud_);
      viz.addPointCloud<pcl::PointXYZRGBA> (cloud_, color_handler, "raw");

      if (!viz.updatePointCloud<pcl::PointXYZ> (keypoints_, "keypoints"))
      {
        viz.addPointCloud<pcl::PointXYZ> (keypoints_, "keypoints");
        viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 5.0, "keypoints");
        viz.resetCameraViewpoint ("keypoints");
      }
    }
Example #8
0
guint32
gnc_table_get_color (Table *table, VirtualLocation virt_loc,
                                 gboolean *hatching)
{
    TableGetCellColorHandler color_handler;
    const char *handler_name;

    if (hatching)
        *hatching = FALSE;

    if (!table || !table->model)
        return COLOR_UNDEFINED;

    handler_name = gnc_table_get_cell_name (table, virt_loc);

    color_handler = gnc_table_model_get_cell_color_handler (table->model,
                                                            handler_name);

    if (!color_handler)
        return COLOR_UNDEFINED;

    return color_handler (virt_loc, hatching,
                          table->model->handler_user_data);
}
Example #9
0
  void Run()
  {
    int win_w = 800;
    int win_h = 600;

    o3d3xx::FrameGrabber::Ptr fg =
      std::make_shared<o3d3xx::FrameGrabber>(this->cam_);

    o3d3xx::ImageBuffer::Ptr buff =
      std::make_shared<o3d3xx::ImageBuffer>();

    //
    // Setup for point cloud
    //
    std::shared_ptr<pcl::visualization::PCLVisualizer> pclvis_ =
      std::make_shared<pcl::visualization::PCLVisualizer>(this->description_);
    pclvis_->setBackgroundColor(0, 0, 0);
    pclvis_->setSize(win_w, win_h);
    pclvis_->setCameraPosition(-3.0, // x-position
                               0,    // y-position
                               0,    // z-position
                               0,    // x-axis "up" (0 = false)
                               0,    // y-axis "up" (0 = false)
                               1);   // z-axis "up" (1 = true)

    // use "A" and "a" to toggle axes indicators
    pclvis_->registerKeyboardCallback(
     [&](const pcl::visualization::KeyboardEvent& ev)
      {
        if (ev.getKeySym() == "A" && ev.keyDown())
          {
            pclvis_->addCoordinateSystem();
          }
        else if (ev.getKeySym() == "a" && ev.keyDown())
          {
            pclvis_->removeCoordinateSystem();
          }
      });


    //
    // Setup for amplitude, depth, and confidence images
    //

    // used for all 2d images
    cv::namedWindow(this->description_, cv::WINDOW_NORMAL|cv::WINDOW_OPENGL);
    cv::resizeWindow(this->description_, win_w, win_h);
    int retval;
    double min, max;
    cv::Rect roi;

    // depth
    cv::Mat display_img;
    cv::Mat depth_colormap_img;

    // confidence
    cv::Mat conf_img;
    cv::Mat conf_colormap_img;

    // amplitude
    cv::Mat amp_colormap_img;
    cv::Mat raw_amp_colormap_img;

    bool is_first = true;
    while (! pclvis_->wasStopped())
      {
        pclvis_->spinOnce(100);
        if (! fg->WaitForFrame(buff.get(), 500))
          {
            continue;
          }

        //------------
        // Point cloud
        //------------
        pcl::visualization::PointCloudColorHandlerGenericField<o3d3xx::PointT>
          color_handler(buff->Cloud(), "intensity");

        if (is_first)
          {
            is_first = false;
            pclvis_->addPointCloud(buff->Cloud(), color_handler, "cloud");
          }
        else
          {
            pclvis_->updatePointCloud(buff->Cloud(), color_handler, "cloud");
          }

        //------------
        // 2D images
        //------------

        // depth image
        cv::minMaxIdx(buff->DepthImage(), &min, &max);
        cv::convertScaleAbs(buff->DepthImage(),
                            depth_colormap_img, 255 / max);
        cv::applyColorMap(depth_colormap_img, depth_colormap_img,
                          cv::COLORMAP_JET);

        // confidence image: show as binary image of good pixel vs. bad pixel.
        conf_img = buff->ConfidenceImage();
        conf_colormap_img = cv::Mat::ones(conf_img.rows,
                                          conf_img.cols,
                                          CV_8UC1);
        cv::bitwise_and(conf_img, conf_colormap_img,
                        conf_colormap_img);
        cv::convertScaleAbs(conf_colormap_img,
                            conf_colormap_img, 255);
        cv::applyColorMap(conf_colormap_img, conf_colormap_img,
                          cv::COLORMAP_SUMMER);

        // amplitude
        cv::minMaxIdx(buff->AmplitudeImage(), &min, &max);
        cv::convertScaleAbs(buff->AmplitudeImage(),
                            amp_colormap_img, 255 / max);
        cv::applyColorMap(amp_colormap_img, amp_colormap_img,
                          cv::COLORMAP_BONE);

        cv::minMaxIdx(buff->RawAmplitudeImage(), &min, &max);
        cv::convertScaleAbs(buff->RawAmplitudeImage(),
                            raw_amp_colormap_img, 255 / max);
        cv::applyColorMap(raw_amp_colormap_img, raw_amp_colormap_img,
                          cv::COLORMAP_BONE);

        // stich 2d images together and display
        display_img.create(depth_colormap_img.rows*2,
                           depth_colormap_img.cols*2,
                           depth_colormap_img.type());

        roi = cv::Rect(0, 0,
                       depth_colormap_img.cols,
                       depth_colormap_img.rows);
        depth_colormap_img.copyTo(display_img(roi));

        roi = cv::Rect(depth_colormap_img.cols, 0,
                       conf_colormap_img.cols,
                       conf_colormap_img.rows);
        conf_colormap_img.copyTo(display_img(roi));

        roi = cv::Rect(0, depth_colormap_img.rows,
                       amp_colormap_img.cols,
                       amp_colormap_img.rows);
        amp_colormap_img.copyTo(display_img(roi));

        roi = cv::Rect(depth_colormap_img.cols,
                       depth_colormap_img.rows,
                       raw_amp_colormap_img.cols,
                       raw_amp_colormap_img.rows);
        raw_amp_colormap_img.copyTo(display_img(roi));

        cv::imshow(this->description_, display_img);

        // `ESC', `q', or `Q' to exit
        retval = cv::waitKey(33);
        if ((retval == 27) || (retval == 113) || (retval == 81))
          {
            break;
          }
      } // end: while (...)
  }