plane_set_estimator.py

Go to the documentation of this file.

#!/usr/bin/env python
# Software License Agreement (BSD License)
#
# Copyright (c) 2009, Willow Garage, Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions in binary form must reproduce the above
#    copyright notice, this list of conditions and the following
#    disclaimer in the documentation and/or other materials provided
#    with the distribution.
#  * Neither the name of the Willow Garage nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.

# Author: Bhaskara Marthi
#
# Maintain set of planes

import roslib; roslib.load_manifest('semanticmodel')
import rospy
import semanticmodel.plane_data_association as pd
import threading
from semanticmodel import msg
from semanticmodel import srv
import visualization_msgs.msg as vm
import time
import math
import logging
import sys
#import mongo_ros as mr


LOG = logging.getLogger('world_model.planes')



class PlaneSetEstimator:
    "Holds the ros independent logic for the plane set estimator"
    
    def __init__(self, max_disp):
        "Initialize estimator"
        self.max_disp = max_disp
        self.planes = {}             
        LOG.info('Initialized estimator')
        

    def process_plane(self, bp):
        "Combine with an existing plane or add a new one"
        int_planes = [id for id, existing_plane in self.planes.items()
                      if pd.intersect(bp, existing_plane, self.max_disp)]
        LOG.debug("Intersecting planes are {0}".format(int_planes))
        if int_planes:
            self.planes = pd.merge_planes(self.planes, bp, self.max_disp)
        else:
            LOG.debug("Adding new plane {0}".format(len(self.planes)))
            self.planes[len(self.planes)] = bp
        LOG.debug("Done processing plane")
        

    def get_containing_plane(self, bp):
        int_planes = [pl for id, pl in self.planes.items()
                      if pd.intersect(bp, pl, self.max_disp)]
        LOG.debug("Intersecting planes are {0}".format(int_planes))
        combined_plane = bp
        for p in int_planes:
            combined_plane = pd.combine(combined_plane, p)
            LOG.debug("Combined plane is now {0}".format(combined_plane))
        return combined_plane                    



class Node:
    "Ros wrapper for the plane state estimator"
    
    def __init__(self):
        "Set up ros comms and initialize actual estimator"
        self.lock = threading.Lock()
        self.pe = PlaneSetEstimator(rospy.get_param("~max_plane_displacement", 0.1))
        with self.lock:
            self.sub = rospy.Subscriber('plane', msg.Plane, self.process_plane)
            self.pub = rospy.Publisher('planes', msg.Planes)
            self.vis_pub = rospy.Publisher('visualization_marker', vm.Marker)
            self.srv = rospy.Service('get_containing_plane', srv.PlaneExchange,
                                     self.get_containing_plane)
        LOG.info('Initialized node')

    def process_plane(self, p):
        LOG.debug("Processing plane")
        bp = pd.BoundedPlane(m)
        with self.lock:
            self.pe.process_plane(bp)

    def get_containing_plane(self, req):
        bp = pd.BoundedPlane(req.in_plane)
        LOG.debug("Getting containing plane for {0}".format(bp))
        with self.lock:
            return pd.to_plane_msg(self.pe.get_containing_plane(bp))

    def spin(self):
        "Publish current estimate at fixed rate"
        r = rospy.Rate(0.3)
        while not rospy.is_shutdown():
            time.sleep(2.0) # Temporary due to rosbag issues
            # r.sleep()
            with self.lock:
                planes = self.pe.planes
                self.pub.publish(map(pd.to_plane_msg, planes.values()))
                if len(planes)>0:
                    self.vis_pub.publish(pd.to_marker(planes.values(), rospy.Time.now()))



def main():
    rospy.init_node('plane_set_estimator')
    node = Node()
    node.spin()

if __name__ == "__main__":
    main()