cloud.h

Go to the documentation of this file.

#ifndef CLOUD_H_
#define CLOUD_H_

#include <QtGui/QColor>
#include <pcl/apps/point_cloud_editor/localTypes.h>
#include <pcl/apps/point_cloud_editor/statistics.h>

// XXX - handle shifting upon setting of a Cloud3D
// XXX - add functions for retrieving an unshifted Cloud3D
// XXX - add functions for retrieveing unshifted points by index
// XXX - mark access functions below as returning shifted values
class Cloud : public Statistics
{
  public:
    Cloud ();

    Cloud (const Cloud& copy);

    Cloud (const Cloud3D& cloud, bool register_stats=false);

    ~Cloud ();

    Cloud&
    operator= (const Cloud& cloud);

    Point3D&
    operator[] (unsigned int index);

    const Point3D&
    operator[] (unsigned int index) const;

    inline
    void
    getCenter (float &x, float &y, float &z) const
    {
      x = center_xyz_[X]; y = center_xyz_[Y]; z = center_xyz_[Z];
    }

    inline
    float
    getScalingFactor() const
    {
      return (display_scale_);
    }

    inline
    const float*
    getMatrix () const
    {
      return (cloud_matrix_);
    }

    void
    loadMatrix (const float* matrix);

    void
    multMatrix (const float* matrix);

    void
    setSelectionRotation (const float* matrix);

    void
    setSelectionTranslation (float dx, float dy, float dz);

    void
    setSelection (SelectionPtr selection_ptr);

    void
    setRGB (float r, float g, float b);

    void
    setHighlightColor (float r, float g, float b);

    void
    draw (bool disable_highlight = false) const;

    void
    drawWithTexture () const;

    void
    drawWithRGB () const;

    void
    drawWithPureColor () const;

    void
    drawWithHighlightColor () const;

    inline
    void
    setColorRampAxis(Axis a)
    {
      color_ramp_axis_ = a;
    }

    inline
    void
    setColorRamp(bool on_off)
    {
      use_color_ramp_ = on_off;
    }

    void
    append (const Point3D& point);
    
    void
    append (const Cloud& cloud);
    
    void
    remove (const Selection& selection);

    inline
    unsigned int
    size () const
    {
      return (cloud_.size());
    }

    void
    resize (unsigned int new_size);
    
    void
    clear ();

    void
    setPointSize (int size);

    void
    setHighlightPointSize (int size);

    Point3D
    getObjectSpacePoint (unsigned int index) const;

    Point3D
    getDisplaySpacePoint (unsigned int index) const;

    void
    getDisplaySpacePoints (std::vector<Point3D>& pts) const;

    const Cloud3D&
    getInternalCloud () const;

    void
    restore (const CopyBuffer& copy_buffer, const Selection& selection);

    std::string
    getStat () const;

    static const float DEFAULT_POINT_DISPLAY_SIZE_;
    static const float DEFAULT_POINT_HIGHLIGHT_SIZE_;
    static const float DEFAULT_POINT_DISPLAY_COLOR_RED_;
    static const float DEFAULT_POINT_DISPLAY_COLOR_GREEN_;
    static const float DEFAULT_POINT_DISPLAY_COLOR_BLUE_;
    static const float DEFAULT_POINT_HIGHLIGHT_COLOR_RED_;
    static const float DEFAULT_POINT_HIGHLIGHT_COLOR_GREEN_;
    static const float DEFAULT_POINT_HIGHLIGHT_COLOR_BLUE_;

  private:
    void
    updateCloudMembers ();

    void
    enableTexture () const;

    void
    disableTexture() const;

    Cloud3D cloud_;

    boost::weak_ptr<Selection> selection_wk_ptr_;

    bool use_color_ramp_;

    bool use_native_color_;

    Axis color_ramp_axis_;

    float display_scale_;

    float center_xyz_[XYZ_SIZE];

    float min_xyz_[XYZ_SIZE];

    float max_xyz_[XYZ_SIZE];

    float cloud_matrix_[MATRIX_SIZE];

    float select_matrix_[MATRIX_SIZE];

    IndexVector partitioned_indices_;

    float point_size_;

    float selected_point_size_;

    float color_[RGB];

    float highlight_color_[RGB];

    float select_translate_x_, select_translate_y_, select_translate_z_;
};
#endif // CLOUD_H_