headshot Home
PDF icon Papers & Posters
code icon Code
hammer icon Projects
notes icon Notes
other pics Other Photos
Handbook Humanoids Wiki
Handbook Pfunk Lab


Code

Project: jvfeatures

jvtypes.h      jvfeatures.h      chessSeg.cpp      jvtypes.cpp      jvtest.cpp      jvfeatures.cpp     

Project: Other

migrateMailbox.scpt.txt     

Project: Infinite HMM Tutorial

run.m      iHMM_tutorial.zip      HDP_HMM.m      README.txt      ConditionalProbabilityTable.m      HDP.m      HMMProblem.m      HMM.m     

Project: RRT

RRT.h      plot_output.py      RRT.tgz      rrt_test.cpp      RRT.cpp      BidirectionalRRT.cpp      AbstractRRT.cpp     

Project: Box2D_friction_mod

WheelConstraint.h      test_TopDownCar.py      b2FrictionJoint.h      python_friction_joint.patch      test_TopDownFrictionJoint.py      TestEntries.cpp      TopDownCar.h      b2FrictionJoint.cpp      box2d_friction_joint.patch     

Project: Dirichlet Process Mixture Tutorial

EM_GM.m      DP_Demo.m      DPMM.m      DP_Tutorial.zip      DirichletProcess.m      gaussian_EM.m     

Project: Arduino_Code

Arduino_Code.zip      convert_range2D.py      arduino-serial.c      oscilloscope.pde      motordriver.pde      helicopter_controller.pde      accelerometer_test.pde      ranger_plane_sweep.pde      clodbuster_controller.pde      pwm_manual.pde      ranger_test.pde      servo_test.pde     

Project: ArduCom

arducom.py      setup.py     

Project: support

geshi.php      Protector.php     

Project: Cogent

CodePane.php      NotesPane.php      PicsPane.php      Cogent.php      PubsTable.php     
Click here to download "resources/code/RRT/rrt_test.cpp"

resources/code/RRT/rrt_test.cpp

#include "RRT.h"
#include <iostream>
#include <vector>
#include <assert.h>

using namespace std;

/**
 * @file rrt_test.cpp
 * Demonstrates implementation of an RRT for a simple
 * 2D path planning problem in the presence of circular
 * obstacles.
 *
 *  @date Feb 27, 2012
 *  @author Jon Scholz
 */

class TestRRT : public RRT {
// class TestRRT : public BidirectionalRRT {
public:
        virtual ~TestRRT() {
                std::cout << "calling TestRRT destructor" << std::endl;
        }
        vector<config> obstCenters; /// Obstacle parameters
        vector<double> obstRadii; /// Radius (of hypersphere)
       
        void installObstacle(config pos, double radius) {
                obstCenters.push_back(pos);
                obstRadii.push_back(radius);
        }
       
        // simple collision model (hyperspheres)
        virtual bool checkCollisions(config &c) {
                assert(obstCenters.size() == obstRadii.size());
                for (int i = 0; i < obstCenters.size(); ++i) {
                        if ((c - obstCenters[i]).getCost() < obstRadii[i])
                                return true;   
                }
                return false;
        }
};

int main()
{
        // // Some rrt obj
        // TestRRT rrt;
        //
        // // Specify task configuration
        // config init(2);
        // init[0]=0.5;
        // init[1]=0.5;
        //
        // config goal(2);
        // goal[0]=3.5;
        // goal[1]=3.5;
        //
        // config minConf(2);
        // minConf[0] = 0;
        // minConf[1] = 0;
        //
        // config maxConf(2);
        // maxConf[0] = 4;
        // maxConf[1] = 4;
       
        // // Add some obstacles
        // config obst1(2);
        // obst1[0] = 1;
        // obst1[1] = 1;
        // rrt.installObstacle(obst1, 0.5);
        //
        // obst1[0] = 2;
        // obst1[1] = 2;
        // rrt.installObstacle(obst1, 0.7);
        //
        // obst1[0] = 3;
        // obst1[1] = 3;
        // rrt.installObstacle(obst1, 0.5);
        //
        // obst1[0] = 3;
        // obst1[1] = 1;
        // rrt.installObstacle(obst1, 0.65);
        //
        // obst1[0] = 1;
        // obst1[1] = 3;
        // rrt.installObstacle(obst1, 0.65);
       
        // Our RRT problem:
        // rrt.initialize(init, goal, minConf, maxConf);
        // cout << "initConfig = " << rrt.getStart() << endl;
        // cout << "goalConfig = " << rrt.getGoal() << endl;
        // cout << "minConfig = " << rrt.getMinConf() << endl;
        // cout << "maxConfig = " << rrt.getMaxConf() << endl;
        //      for (int i = 0; i < rrt.obstCenters.size(); ++i)
        //      cout << "obstacle " << i << ": {" << rrt.obstCenters[i] << "," << rrt.obstRadii[i] << "}" << endl;
       
        // Our RRT solution:
        // rrt.run(20, false);
        // rrt.printTree();
        // rrt.printPath();
        // cout << "Done." << endl;

        // double *v = new double[2];
        // double *y = v;
        // delete[] v;
        // delete[] y;
        // double *v;
        // delete[] v;
        config a(2);
        config b;
        b = config(a);
       
       
        return 0;
}
 

About me

Pic of me