blob.hh

Go to the documentation of this file.

/*
 * blob.hh
 * Mac Mason <mmason@willowgarage.com>
 *
 * We need a (C++) object for tracking the variety of things we, well, track.
 *
 * The Blob object also keeps track of several static function that do useful
 * things to blobs, like merging arrays of them.
 */

#pragma once

#include <vector>
#include <boost/utility.hpp>  // for boost::noncopyable
#include "pcl16/point_types.h"
#include "pcl16/point_cloud.h"
#include <cstddef>

namespace semanticmodel
{

class Blob : public boost::noncopyable
{
  private:
    // Keep our typing sane.
    typedef pcl16::PointXYZRGB Point;
    typedef pcl16::PointCloud<Point> PointCloud;

  public:
    // The raw cloud of the object.
    PointCloud::Ptr cloud;
    // The convex hull of the (flattened) data, at z == 0.0.
    PointCloud::Ptr hull;
    //  Unique id of this blob
    unsigned int id;

    // Given a cluster (generated by our filter), fill everything in.
    Blob(const PointCloud::ConstPtr& cluster);

    // No need for a destructor; viva shared_ptr!

    // Does this Blob overlap that blob? Our algorithm is to accept any
    // overlap between the (flattened) convex hulls.
    bool overlaps(const Blob& rhs) const;

    // Bring the contents of rhs into this Blob. 
    void mergeFrom(const Blob& rhs);

    // Compute the (average) color of the object. Given values in the range
    // [0.0, 1.0] (for ease of use with visualization_msgs).
    void RGB(float& r, float& g, float& b) const;

    // Compute the size of the bounding box of the Blob. Note that the
    // returned box will be axis-aligned, which is not (necessarily) what you
    // meant. Deal with it.
    void size(double& x, double& y, double& z) const;

    // Return a copy, with all the z-values set to the appropriate value.
    // Since shared_ptrs are cheap to copy, let's return one.
    static PointCloud::Ptr flatten(PointCloud::Ptr& in, double z = 0.0);

    // Given a set of objects (the current set), and a new object, do the
    // overlap checking to include this object in the set, merging as
    // necessary. ("Smart" merging, with recursive checks). objects is
    // expected to hold zero or more blobs, none of which overlap. blob is
    // expected to be a new object to merge in. This function takes ownership
    // of the passed-in pointer; DO NOT DELETE IT YOURSELF. The objects vector
    // will be modified by this function; whoever owned that vector beforehand
    // still does.
    //
    // See also MergeBlobWithSetHelper, below.
    static void MergeBlobWithSet(std::vector<Blob*>& objects, Blob* blob);

  private:

    // This is the one-pass helper for MergeBlobWithSet. This version takes in
    // a single vector; the object-to-be-potentially-merged is the last
    // element. If it returns true, a merge happened, and the newly-merged
    // object is the last element; if it returns false, no edits are made to
    // objects.
    static bool MergeBlobWithSetHelper(std::vector<Blob*>& objects);

    static unsigned int next_id;

    // A helper for the constructor; fill in hull from a cloud. This is
    // smart about self-hull-assignment; see the usage in mergeFrom.
    void hullerize(const PointCloud::ConstPtr& cloud);

    // An overlaps() helper; a direct port from plane_data_assocation.py.
    bool oneSidedIntersect(const PointCloud::ConstPtr& p1,
                           const PointCloud::ConstPtr& p2) const;

    // See previous comment.
    void projectOntoNormal(const PointCloud::ConstPtr& poly, 
                           const Point& q1, const Point& q2,
                           double& inf, double& sup) const;
};

}