/opt/ros/diamondback/stacks/graspit_simulator/graspit/graspit_source/src/DBase/DBPlanner/db_manager.h

Go to the documentation of this file.

//######################################################################
//
// GraspIt!
// Copyright (C) 2002-2009  Columbia University in the City of New York.
// All rights reserved.
//
// GraspIt! is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GraspIt! is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with GraspIt!.  If not, see <http://www.gnu.org/licenses/>.
//
// Author(s):  Hao Dang and Matei T. Ciocarlie
//
// $Id: db_manager.h,v 1.20 2010/08/11 02:45:37 cmatei Exp $
//
//######################################################################

#ifndef DB_PLANNER_DB_MANAGER_H
#define DB_PLANNER_DB_MANAGER_H

#include <string>
#include <vector>
#include <utility>
#include "model.h"
#include "task.h"
#include "grasp.h"
using std::pair;
using std::string;
using std::vector;

class GraspAllocator;
class ModelAllocator;

namespace db_planner {

class FilterList{
public:
        enum FilterType{NONE, HAS_HUMAN_GRASPS, HAS_HUMAN_REFINED_GRASPS, OLD_STYLE_IV};
        static string GetWhereClause(FilterType filter) {
                if (filter == HAS_HUMAN_GRASPS) {
                        return "WHERE model_name IN (SELECT DISTINCT scaled_model_name "
                                   "FROM grasp JOIN scaled_model USING(scaled_model_id) "
                                   "WHERE grasp_source_id = 2)";
                } else if (filter == HAS_HUMAN_REFINED_GRASPS) {
                        return "WHERE model_name IN (SELECT DISTINCT scaled_model_name "
                                   "FROM grasp JOIN scaled_model USING(scaled_model_id) "
                                   "WHERE grasp_source_id = 3)";
                } else if (filter == OLD_STYLE_IV) {
                        return "WHERE model_name LIKE 'matei%'";
                } else {
                        return "";
                }
        }
};


class DatabaseManager {
 protected:


  ModelAllocator *model_allocator_;

  GraspAllocator *grasp_allocator_;

 public:

  virtual void SetGraspAllocator(GraspAllocator* allocator) = 0;

  virtual void SetModelAllocator(ModelAllocator* allocator) = 0;

  virtual bool isConnected() const = 0;

  virtual bool GetAlignment(const Model& source,
                            const Model& dest, 
                            const string& alignment_method_name, 
                            float alignment[16]) const = 0;

  virtual bool SaveAlignment(const Model& source,
                             const Model& dest, 
                             const string& alignment_method_name, 
                             const float alignment[16]) const = 0;

  virtual bool GetNeighbors(const Model& model, 
                            const string& distance_function_name, 
                            const int num_neighbors,
                            vector<pair<Model*, double> >* neighbors) 
                            const = 0;
  virtual bool SaveNeighbors(const Model& model, 
                             const string& distance_function_name, 
                             const vector<pair<Model*, double> >& neighbors) 
                             const = 0;
  virtual bool GetGrasps(const Model& model, 
                         const string& hand_name, 
                         vector<Grasp*>* grasp_list) const = 0;

  virtual bool AcquireNextTask(TaskRecord *rec) = 0;
  virtual bool SetTaskStatus(int task_id, const string &status) = 0;
  virtual bool GetPlanningTaskRecord(int task_id, PlanningTaskRecord *rec) = 0;
  virtual bool GetOptimizationTaskRecord(int /*task_id*/, OptimizationTaskRecord* /*rec*/) {return false;}
  virtual bool SaveOptimizationResults(const OptimizationTaskRecord& /*rec*/,
                                       const std::vector<double>& /*parameters*/,
                                       const std::vector<double>& /*results*/) {return false;}

  virtual bool SaveGrasp(const Grasp*) const = 0;
  virtual bool SaveGrasps(const vector<Grasp*> graspList) const{
    for(size_t i = 0; i < graspList.size(); ++i){
      if (!SaveGrasp(graspList[i])) {
        return false;
      }
    }
    return true;
  }
  virtual bool DeleteGrasp(Grasp* grasp) const = 0;

  virtual bool SetGraspClusterRep(Grasp *grasp, bool rep) const = 0;

  virtual bool InsertGraspPair(const Grasp *grasp1, const Grasp *grasp2) const = 0;
  virtual bool SetGraspTableClearance(Grasp *grasp, double clearance) const = 0;
  virtual bool ModelList(vector<Model*>* model_list, 
                         FilterList::FilterType filter = FilterList::NONE) const = 0;
  virtual bool ScaledModel(Model* &model, int scaled_model_id) const = 0;
  virtual bool GraspTypeList(vector<string>* type_list) const = 0;
  virtual bool DistanceFunctionList(
      vector<string>* distance_function_list) const = 0;
  virtual bool AlignmentMethodList(
      vector<string>* alignment_method_list) const = 0;
  virtual bool LoadModelGeometry(Model*) const = 0;
};

}
#endif  // DB_PLANNER_DB_MANAGER

---

graspit
Author(s):
autogenerated on Wed Jan 25 10:58:52 2012