You can subscribe to this list here.
2010 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}
(1) 
_{Sep}

_{Oct}

_{Nov}

_{Dec}


2011 
_{Jan}
(4) 
_{Feb}
(6) 
_{Mar}
(16) 
_{Apr}
(9) 
_{May}
(6) 
_{Jun}
(2) 
_{Jul}

_{Aug}
(14) 
_{Sep}
(10) 
_{Oct}
(12) 
_{Nov}
(15) 
_{Dec}
(3) 
2012 
_{Jan}
(15) 
_{Feb}
(9) 
_{Mar}
(10) 
_{Apr}
(19) 
_{May}
(20) 
_{Jun}
(14) 
_{Jul}
(1) 
_{Aug}
(2) 
_{Sep}

_{Oct}
(3) 
_{Nov}
(1) 
_{Dec}
(2) 
2013 
_{Jan}
(13) 
_{Feb}
(8) 
_{Mar}
(11) 
_{Apr}
(20) 
_{May}
(11) 
_{Jun}
(11) 
_{Jul}
(12) 
_{Aug}
(3) 
_{Sep}

_{Oct}
(7) 
_{Nov}
(9) 
_{Dec}
(1) 
2014 
_{Jan}
(1) 
_{Feb}
(4) 
_{Mar}
(13) 
_{Apr}
(5) 
_{May}
(10) 
_{Jun}
(27) 
_{Jul}
(17) 
_{Aug}

_{Sep}
(8) 
_{Oct}
(12) 
_{Nov}
(19) 
_{Dec}
(31) 
2015 
_{Jan}
(21) 
_{Feb}
(11) 
_{Mar}
(15) 
_{Apr}
(1) 
_{May}
(15) 
_{Jun}
(11) 
_{Jul}
(23) 
_{Aug}
(6) 
_{Sep}
(28) 
_{Oct}
(17) 
_{Nov}
(18) 
_{Dec}
(1) 
2016 
_{Jan}
(14) 
_{Feb}
(42) 
_{Mar}
(20) 
_{Apr}
(10) 
_{May}
(11) 
_{Jun}
(3) 
_{Jul}
(9) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 

1

2
(1) 
3
(3) 
4
(1) 
5

6

7

8

9

10

11

12

13

14

15

16

17

18
(2) 
19

20

21
(6) 
22

23

24
(2) 
25

26

27
(3) 
28

29
(1) 
30






From: daniel chan <danielstar01@gm...>  20120429 02:01:31

Thanks a lot Ryan. Daniel On Fri, Apr 27, 2012 at 1:28 PM, Ryan Luna <rluna@...> wrote: > Hello Daniel, > > It looks like you are defining your allocMyValidStateSampler method inside > of a class (MPPlanner), and then attempting to reference this function > using setValidStateSamplerAllocator(). To reference a class function, I > recommend using boost::bind. Your call to setValidStateSamplerAllocator > should look something like this: > > setValidStateSamplerAllocator(boost::bind(&MPPlanner::allocMyValidStateSampler, > this, _1)) > > where 'this' should be a pointer to an instance of MPPlanner. > > There is a brief tutorial of Boost.Function and Boost.Bind in the OMPL > documentation as well: http://ompl.kavrakilab.org/boost.html > > Let me know if this helps. > > Ryan > > On Fri, Apr 27, 2012 at 3:01 PM, daniel chan <danielstar01@...>wrote: > >> Hi, >> >> I am trying to set my own valid state sampler as described in >> http://ompl.kavrakilab.org/availableSamplers.html. But I am getting the >> following error..... >> >> This is how I set/define: >> >> ompl::base::ValidStateSamplerPtr >> MPPlanner::allocMyValidStateSampler(const ompl::base::SpaceInformation *si) >> { >> return ompl::base::ValidStateSamplerPtr(new >> MPValidStateSampler(si)); >> } >> >> >> simple_setup.getSpaceInformation()>setValidStateSamplerAllocator(allocMyValidStateSampler); >> >> In a separate header file I defined MPValidStateSampler. >> >> ERROR I am getting: >> >> error: no matching function for call to >> ‘ompl::base::SpaceInformation::setValidStateSamplerAllocator(<unresolved >> overloaded function type>)’ >> /opt/ros/electric/stacks/arm_navigation/ompl/installation/include/ompl/base/SpaceInformation.h:262: >> note: candidates are: void >> ompl::base::SpaceInformation::setValidStateSamplerAllocator(const >> ompl::base::ValidStateSamplerAllocator&) >> >> Am I missing something? I exactly followed this link >> http://ompl.kavrakilab.org/availableSamplers.html. I even tried with >> existing >> >> new ob::ObstacleBasedValidStateSampler <http://ompl.kavrakilab.org/classompl_1_1base_1_1ObstacleBasedValidStateSampler.html>(si) >> >> >> >> instead of my custom defined valid state sampler >> new MPValidStateSampler(si) >> >> Please help me where I am doing wrong. >> >> Thanks a lot. >> Daniel >> >> >> >>  >> Live Security Virtual Conference >> Exclusive live event will cover all the ways today's security and >> threat landscape has changed and how IT managers can respond. Discussions >> will include endpoint security, mobile security and the latest in malware >> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/ >> _______________________________________________ >> omplusers mailing list >> omplusers@... >> https://lists.sourceforge.net/lists/listinfo/omplusers >> >> > 
From: Ryan Luna <rluna@ri...>  20120427 20:29:01

Hello Daniel, It looks like you are defining your allocMyValidStateSampler method inside of a class (MPPlanner), and then attempting to reference this function using setValidStateSamplerAllocator(). To reference a class function, I recommend using boost::bind. Your call to setValidStateSamplerAllocator should look something like this: setValidStateSamplerAllocator(boost::bind(&MPPlanner::allocMyValidStateSampler, this, _1)) where 'this' should be a pointer to an instance of MPPlanner. There is a brief tutorial of Boost.Function and Boost.Bind in the OMPL documentation as well: http://ompl.kavrakilab.org/boost.html Let me know if this helps. Ryan On Fri, Apr 27, 2012 at 3:01 PM, daniel chan <danielstar01@...> wrote: > Hi, > > I am trying to set my own valid state sampler as described in > http://ompl.kavrakilab.org/availableSamplers.html. But I am getting the > following error..... > > This is how I set/define: > > ompl::base::ValidStateSamplerPtr MPPlanner::allocMyValidStateSampler(const > ompl::base::SpaceInformation *si) > { > return ompl::base::ValidStateSamplerPtr(new > MPValidStateSampler(si)); > } > > > simple_setup.getSpaceInformation()>setValidStateSamplerAllocator(allocMyValidStateSampler); > > In a separate header file I defined MPValidStateSampler. > > ERROR I am getting: > > error: no matching function for call to > ‘ompl::base::SpaceInformation::setValidStateSamplerAllocator(<unresolved > overloaded function type>)’ > /opt/ros/electric/stacks/arm_navigation/ompl/installation/include/ompl/base/SpaceInformation.h:262: > note: candidates are: void > ompl::base::SpaceInformation::setValidStateSamplerAllocator(const > ompl::base::ValidStateSamplerAllocator&) > > Am I missing something? I exactly followed this link > http://ompl.kavrakilab.org/availableSamplers.html. I even tried with > existing > > new ob::ObstacleBasedValidStateSampler <http://ompl.kavrakilab.org/classompl_1_1base_1_1ObstacleBasedValidStateSampler.html>(si) > > > instead of my custom defined valid state sampler > new MPValidStateSampler(si) > > Please help me where I am doing wrong. > > Thanks a lot. > Daniel > > > >  > Live Security Virtual Conference > Exclusive live event will cover all the ways today's security and > threat landscape has changed and how IT managers can respond. Discussions > will include endpoint security, mobile security and the latest in malware > threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/ > _______________________________________________ > omplusers mailing list > omplusers@... > https://lists.sourceforge.net/lists/listinfo/omplusers > > 
From: daniel chan <danielstar01@gm...>  20120427 20:01:16

Hi, I am trying to set my own valid state sampler as described in http://ompl.kavrakilab.org/availableSamplers.html. But I am getting the following error..... This is how I set/define: ompl::base::ValidStateSamplerPtr MPPlanner::allocMyValidStateSampler(const ompl::base::SpaceInformation *si) { return ompl::base::ValidStateSamplerPtr(new MPValidStateSampler(si)); } simple_setup.getSpaceInformation()>setValidStateSamplerAllocator(allocMyValidStateSampler); In a separate header file I defined MPValidStateSampler. ERROR I am getting: error: no matching function for call to ‘ompl::base::SpaceInformation::setValidStateSamplerAllocator(<unresolved overloaded function type>)’ /opt/ros/electric/stacks/arm_navigation/ompl/installation/include/ompl/base/SpaceInformation.h:262: note: candidates are: void ompl::base::SpaceInformation::setValidStateSamplerAllocator(const ompl::base::ValidStateSamplerAllocator&) Am I missing something? I exactly followed this link http://ompl.kavrakilab.org/availableSamplers.html. I even tried with existing new ob::ObstacleBasedValidStateSampler <http://ompl.kavrakilab.org/classompl_1_1base_1_1ObstacleBasedValidStateSampler.html>(si) instead of my custom defined valid state sampler new MPValidStateSampler(si) Please help me where I am doing wrong. Thanks a lot. Daniel 
From: daniel chan <danielstar01@gm...>  20120427 19:51:04

Thanks Ioan, Daniel On Tue, Apr 24, 2012 at 3:32 PM, Ioan Sucan <isucan@...> wrote: > Hello Daniel, > > Answers follow inline. > > On Tue, Apr 24, 2012 at 1:06 PM, daniel chan <danielstar01@...>wrote: > >> Hi Ioan, >> >> I am setting my statespaces and corresponding bounds like this: >> >> ompl::base::StateSpacePtr se2(new ompl::base::SE2StateSpace()); >> ompl::base::StateSpacePtr arm(new ompl::base::RealVectorStateSpace(7)); >> ompl::base::StateSpacePtr full =se2 + arm; >> >> ompl::base::RealVectorBounds se2bounds(2); >> ompl::base::RealVectorBounds armbounds(7); >> >> se2>as<ompl::base::SE2StateSpace>()>setBounds(se2bounds); >> arm>as<ompl::base::RealVectorStateSpace>()>setBounds(armbounds); >> >> ompl::geometric::SimpleSetup simple_setup(full); >> simple_setup.setStateValidityChecker(boost::bind(&ASPlanner::isMyStateValid, >> this, _1)); >> simple_setup.setPlanner(new >> ompl::geometric::ASPlanner(simple_setup.getSpaceInformation())); >> >> Ques1: Can you please tell how can I access these 10 subspaces of a >> state inside this function ASPlanner::isMyStateValid(const >> ompl::base::State *state) >> >> I know how to do if it was only SE2StateSpace (as shown below) but I am >> little confused for my "full" statespace. >> >> bool BRM::isMyStateValid(const ompl::base::State *state) >> { >> //if it was SE2StateSpace only then >> xvalue = >> ompl_state>as<ompl::base::SE2StateSpace::StateType>()>getX(); >> yvalue = >> ompl_state>as<ompl::base::SE2StateSpace::StateType>()>getY(); >> thetavalue = >> ompl_state>as<ompl::base::SE2StateSpace::StateType>()>getYaw(); >> >> //I want to know how to access for my statespace i.e. "full" as >> defined above >> ......... >> ......... >> } >> >> I guess the answer lies in what the + operator does for spaces: it > creates a CompondStateSpace and adds all subspaces with weight 1. So, a > state from the full state space will then be accessed (for read or write) > like so: > > > state>as<ompl::base::CompoundState>()>as<ompl::base::SE2StateSpace>(0)>getX().... > and for the real component: > > state>as<ompl::base::CompoundState>()>as<ompl::base::SE2StateSpace>(1)>getX().... > > The indexing starts at 0, and is in the order in which the elements were > added. You had se2 + arm, so se2 is at index 0, arm is at index 1. > > > > >> Ques2: How to set the values to my "full" statespace. Say inside my >> "ompl::geometric::ASPlanner" planner, I am sampling separately for "se2" >> and setting my own values for "arm". Then how can I input/set these to >> predefined 10D statespace "ompl::base::State *state" >> >> like: >> validsampler_>sample(se2state); >> armstate (set my own values here for 7D state space) >> >> Ques2(again): Now "ompl::base::State *state" , I want to set this state >> (which is "full" and compound statespace) equivalent to "se2state >> +armstate" >> >> The answer to the first question covers this case too. > > Ioan > > >> Thanks, >> Daniel >> >> >>  >> Live Security Virtual Conference >> Exclusive live event will cover all the ways today's security and >> threat landscape has changed and how IT managers can respond. Discussions >> will include endpoint security, mobile security and the latest in malware >> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/ >> _______________________________________________ >> omplusers mailing list >> omplusers@... >> https://lists.sourceforge.net/lists/listinfo/omplusers >> >> > 
From: Ioan Sucan <isucan@gm...>  20120424 22:32:22

Hello Daniel, Answers follow inline. On Tue, Apr 24, 2012 at 1:06 PM, daniel chan <danielstar01@...> wrote: > Hi Ioan, > > I am setting my statespaces and corresponding bounds like this: > > ompl::base::StateSpacePtr se2(new ompl::base::SE2StateSpace()); > ompl::base::StateSpacePtr arm(new ompl::base::RealVectorStateSpace(7)); > ompl::base::StateSpacePtr full =se2 + arm; > > ompl::base::RealVectorBounds se2bounds(2); > ompl::base::RealVectorBounds armbounds(7); > > se2>as<ompl::base::SE2StateSpace>()>setBounds(se2bounds); > arm>as<ompl::base::RealVectorStateSpace>()>setBounds(armbounds); > > ompl::geometric::SimpleSetup simple_setup(full); > simple_setup.setStateValidityChecker(boost::bind(&ASPlanner::isMyStateValid, > this, _1)); > simple_setup.setPlanner(new > ompl::geometric::ASPlanner(simple_setup.getSpaceInformation())); > > Ques1: Can you please tell how can I access these 10 subspaces of a state > inside this function ASPlanner::isMyStateValid(const ompl::base::State > *state) > > I know how to do if it was only SE2StateSpace (as shown below) but I am > little confused for my "full" statespace. > > bool BRM::isMyStateValid(const ompl::base::State *state) > { > //if it was SE2StateSpace only then > xvalue = > ompl_state>as<ompl::base::SE2StateSpace::StateType>()>getX(); > yvalue = > ompl_state>as<ompl::base::SE2StateSpace::StateType>()>getY(); > thetavalue = > ompl_state>as<ompl::base::SE2StateSpace::StateType>()>getYaw(); > > //I want to know how to access for my statespace i.e. "full" as > defined above > ......... > ......... > } > > I guess the answer lies in what the + operator does for spaces: it creates a CompondStateSpace and adds all subspaces with weight 1. So, a state from the full state space will then be accessed (for read or write) like so: state>as<ompl::base::CompoundState>()>as<ompl::base::SE2StateSpace>(0)>getX().... and for the real component: state>as<ompl::base::CompoundState>()>as<ompl::base::SE2StateSpace>(1)>getX().... The indexing starts at 0, and is in the order in which the elements were added. You had se2 + arm, so se2 is at index 0, arm is at index 1. > Ques2: How to set the values to my "full" statespace. Say inside my > "ompl::geometric::ASPlanner" planner, I am sampling separately for "se2" > and setting my own values for "arm". Then how can I input/set these to > predefined 10D statespace "ompl::base::State *state" > > like: > validsampler_>sample(se2state); > armstate (set my own values here for 7D state space) > > Ques2(again): Now "ompl::base::State *state" , I want to set this state > (which is "full" and compound statespace) equivalent to "se2state > +armstate" > > The answer to the first question covers this case too. Ioan > Thanks, > Daniel > > >  > Live Security Virtual Conference > Exclusive live event will cover all the ways today's security and > threat landscape has changed and how IT managers can respond. Discussions > will include endpoint security, mobile security and the latest in malware > threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/ > _______________________________________________ > omplusers mailing list > omplusers@... > https://lists.sourceforge.net/lists/listinfo/omplusers > > 
From: daniel chan <danielstar01@gm...>  20120424 20:06:23

Hi Ioan, I am setting my statespaces and corresponding bounds like this: ompl::base::StateSpacePtr se2(new ompl::base::SE2StateSpace()); ompl::base::StateSpacePtr arm(new ompl::base::RealVectorStateSpace(7)); ompl::base::StateSpacePtr full =se2 + arm; ompl::base::RealVectorBounds se2bounds(2); ompl::base::RealVectorBounds armbounds(7); se2>as<ompl::base::SE2StateSpace>()>setBounds(se2bounds); arm>as<ompl::base::RealVectorStateSpace>()>setBounds(armbounds); ompl::geometric::SimpleSetup simple_setup(full); simple_setup.setStateValidityChecker(boost::bind(&ASPlanner::isMyStateValid, this, _1)); simple_setup.setPlanner(new ompl::geometric::ASPlanner(simple_setup.getSpaceInformation())); Ques1: Can you please tell how can I access these 10 subspaces of a state inside this function ASPlanner::isMyStateValid(const ompl::base::State *state) I know how to do if it was only SE2StateSpace (as shown below) but I am little confused for my "full" statespace. bool BRM::isMyStateValid(const ompl::base::State *state) { //if it was SE2StateSpace only then xvalue = ompl_state>as<ompl::base::SE2StateSpace::StateType>()>getX(); yvalue = ompl_state>as<ompl::base::SE2StateSpace::StateType>()>getY(); thetavalue = ompl_state>as<ompl::base::SE2StateSpace::StateType>()>getYaw(); //I want to know how to access for my statespace i.e. "full" as defined above ......... ......... } Ques2: How to set the values to my "full" statespace. Say inside my "ompl::geometric::ASPlanner" planner, I am sampling separately for "se2" and setting my own values for "arm". Then how can I input/set these to predefined 10D statespace "ompl::base::State *state" like: validsampler_>sample(se2state); armstate (set my own values here for 7D state space) Ques2(again): Now "ompl::base::State *state" , I want to set this state (which is "full" and compound statespace) equivalent to "se2state +armstate" Thanks, Daniel 
From: Ioan Sucan <isucan@gm...>  20120421 10:10:18

Hello Daniel, You can get the latest version of OMPL by cloning the mercurial repository: http://ompl.kavrakilab.org/core/download.html Ioan On Sat, Apr 21, 2012 at 12:38 PM, daniel chan <danielstar01@...>wrote: > Hi Ioan, > > I downloaded recent ompl version but prm code seems older (not by ryan). > Can you please send me corresponding prm files (source/header) or any link > pointing to source and header files? That would be a great help!! > > Thank you, > Daniel > > On Sat, Apr 21, 2012 at 2:10 AM, Ioan Sucan <isucan@...> wrote: > >> Hello Daniel, >> >> To keep things simple when using planners in an abstract way, we ask the >> user to only call the solve() function for a planner to solve a problem. >> For PRM itself, there are growRoadmap functions which allow you to grow a >> roadmap a priory. Hoever, calling those functions is optional because solve >> for PRM works as follows: >> >>  add input states to the roadmap >>  while input states are not connected, grow the roadmap. >>  when they are connected, stop growing the roadmap and return the >> solution. >> >> Just recently Ryan Luna added an improvement to the PRM code that allows >> it to run more efficiently, and I think allows for a cleaner >> implementation: the check for the roadmap being able to connect an input >> state to a goal state is done in a separate thread. Lines 399  402 in >> PRM.cpp (rev 1852) are responsible for growing the roadmap, from the solve >> function, while the checkForSolution() function runs in a separate thread. >> >> So the answer is that solve() improves the roadmap as needed, if it can't >> solve the problem when called. And this happens of course if the initial >> roadmap is empty. >> >> For the second part of your question, PlannerInputStates is a helper >> class that allows implementations of planners to be simpler. Namely, >> PlannerInputStates makes it trivial to retrieve only valid input states >> (start or goal), wait for goal samplers if they're produced in a separate >> thread (GoalLazySamples), things like this. One is not required to use this >> class, but without it, things tend to get complicated if you want to >> support all goal types. >> If you see parts in the documentation that are not clear, please let me >> know and I will improve it. >> >> Ioan >> >> >> On Sat, Apr 21, 2012 at 11:58 AM, daniel chan <danielstar01@...>wrote: >> >>> Hello Ioan, >>> >>> I was looking into the PRM.cpp file and could not figure out where you >>> have written the routine for constructing the roadmap before calling >>> "solve" function (where you are adding start and goal states and doing >>> additional construction and expansion steps if solution is not found). Can >>> you please tell where in the PRM.cpp file you are building the roadmap >>> before calling solve function? >>> >>> What are valid input states (PlannerInputStates)? Are these refering to >>> start and goal states? Say if we have set only one start and one goal >>> states then pis>next() should provide only those start and goal state? >>> It seems to me there is no randombounce walk for the start and goal >>> states, if it is not possible to connect (start/goal) to roadmap using >>> nearest neighbor concept? >>> >>> Daniel >>> >>> >>> >>>  >>> For Developers, A Lot Can Happen In A Second. >>> Boundary is the first to Know...and Tell You. >>> Monitor Your Applications in UltraFine Resolution. Try it FREE! >>> http://p.sf.net/sfu/Boundaryd2dvs2 >>> _______________________________________________ >>> omplusers mailing list >>> omplusers@... >>> https://lists.sourceforge.net/lists/listinfo/omplusers >>> >>> >> > > >  > For Developers, A Lot Can Happen In A Second. > Boundary is the first to Know...and Tell You. > Monitor Your Applications in UltraFine Resolution. Try it FREE! > http://p.sf.net/sfu/Boundaryd2dvs2 > _______________________________________________ > omplusers mailing list > omplusers@... > https://lists.sourceforge.net/lists/listinfo/omplusers > > 
From: daniel chan <danielstar01@gm...>  20120421 09:38:14

Hi Ioan, I downloaded recent ompl version but prm code seems older (not by ryan). Can you please send me corresponding prm files (source/header) or any link pointing to source and header files? That would be a great help!! Thank you, Daniel On Sat, Apr 21, 2012 at 2:10 AM, Ioan Sucan <isucan@...> wrote: > Hello Daniel, > > To keep things simple when using planners in an abstract way, we ask the > user to only call the solve() function for a planner to solve a problem. > For PRM itself, there are growRoadmap functions which allow you to grow a > roadmap a priory. Hoever, calling those functions is optional because solve > for PRM works as follows: > >  add input states to the roadmap >  while input states are not connected, grow the roadmap. >  when they are connected, stop growing the roadmap and return the > solution. > > Just recently Ryan Luna added an improvement to the PRM code that allows > it to run more efficiently, and I think allows for a cleaner > implementation: the check for the roadmap being able to connect an input > state to a goal state is done in a separate thread. Lines 399  402 in > PRM.cpp (rev 1852) are responsible for growing the roadmap, from the solve > function, while the checkForSolution() function runs in a separate thread. > > So the answer is that solve() improves the roadmap as needed, if it can't > solve the problem when called. And this happens of course if the initial > roadmap is empty. > > For the second part of your question, PlannerInputStates is a helper class > that allows implementations of planners to be simpler. Namely, > PlannerInputStates makes it trivial to retrieve only valid input states > (start or goal), wait for goal samplers if they're produced in a separate > thread (GoalLazySamples), things like this. One is not required to use this > class, but without it, things tend to get complicated if you want to > support all goal types. > If you see parts in the documentation that are not clear, please let me > know and I will improve it. > > Ioan > > > On Sat, Apr 21, 2012 at 11:58 AM, daniel chan <danielstar01@...>wrote: > >> Hello Ioan, >> >> I was looking into the PRM.cpp file and could not figure out where you >> have written the routine for constructing the roadmap before calling >> "solve" function (where you are adding start and goal states and doing >> additional construction and expansion steps if solution is not found). Can >> you please tell where in the PRM.cpp file you are building the roadmap >> before calling solve function? >> >> What are valid input states (PlannerInputStates)? Are these refering to >> start and goal states? Say if we have set only one start and one goal >> states then pis>next() should provide only those start and goal state? >> It seems to me there is no randombounce walk for the start and goal >> states, if it is not possible to connect (start/goal) to roadmap using >> nearest neighbor concept? >> >> Daniel >> >> >> >>  >> For Developers, A Lot Can Happen In A Second. >> Boundary is the first to Know...and Tell You. >> Monitor Your Applications in UltraFine Resolution. Try it FREE! >> http://p.sf.net/sfu/Boundaryd2dvs2 >> _______________________________________________ >> omplusers mailing list >> omplusers@... >> https://lists.sourceforge.net/lists/listinfo/omplusers >> >> > 
From: Ioan Sucan <isucan@gm...>  20120421 09:10:47

Hello Daniel, To keep things simple when using planners in an abstract way, we ask the user to only call the solve() function for a planner to solve a problem. For PRM itself, there are growRoadmap functions which allow you to grow a roadmap a priory. Hoever, calling those functions is optional because solve for PRM works as follows:  add input states to the roadmap  while input states are not connected, grow the roadmap.  when they are connected, stop growing the roadmap and return the solution. Just recently Ryan Luna added an improvement to the PRM code that allows it to run more efficiently, and I think allows for a cleaner implementation: the check for the roadmap being able to connect an input state to a goal state is done in a separate thread. Lines 399  402 in PRM.cpp (rev 1852) are responsible for growing the roadmap, from the solve function, while the checkForSolution() function runs in a separate thread. So the answer is that solve() improves the roadmap as needed, if it can't solve the problem when called. And this happens of course if the initial roadmap is empty. For the second part of your question, PlannerInputStates is a helper class that allows implementations of planners to be simpler. Namely, PlannerInputStates makes it trivial to retrieve only valid input states (start or goal), wait for goal samplers if they're produced in a separate thread (GoalLazySamples), things like this. One is not required to use this class, but without it, things tend to get complicated if you want to support all goal types. If you see parts in the documentation that are not clear, please let me know and I will improve it. Ioan On Sat, Apr 21, 2012 at 11:58 AM, daniel chan <danielstar01@...>wrote: > Hello Ioan, > > I was looking into the PRM.cpp file and could not figure out where you > have written the routine for constructing the roadmap before calling > "solve" function (where you are adding start and goal states and doing > additional construction and expansion steps if solution is not found). Can > you please tell where in the PRM.cpp file you are building the roadmap > before calling solve function? > > What are valid input states (PlannerInputStates)? Are these refering to > start and goal states? Say if we have set only one start and one goal > states then pis>next() should provide only those start and goal state? > It seems to me there is no randombounce walk for the start and goal > states, if it is not possible to connect (start/goal) to roadmap using > nearest neighbor concept? > > Daniel > > > >  > For Developers, A Lot Can Happen In A Second. > Boundary is the first to Know...and Tell You. > Monitor Your Applications in UltraFine Resolution. Try it FREE! > http://p.sf.net/sfu/Boundaryd2dvs2 > _______________________________________________ > omplusers mailing list > omplusers@... > https://lists.sourceforge.net/lists/listinfo/omplusers > > 
From: daniel chan <danielstar01@gm...>  20120421 08:58:48

Hello Ioan, I was looking into the PRM.cpp file and could not figure out where you have written the routine for constructing the roadmap before calling "solve" function (where you are adding start and goal states and doing additional construction and expansion steps if solution is not found). Can you please tell where in the PRM.cpp file you are building the roadmap before calling solve function? What are valid input states (PlannerInputStates)? Are these refering to start and goal states? Say if we have set only one start and one goal states then pis>next() should provide only those start and goal state? It seems to me there is no randombounce walk for the start and goal states, if it is not possible to connect (start/goal) to roadmap using nearest neighbor concept? Daniel 
From: Ioan Sucan <isucan@gm...>  20120421 08:56:40

Hello Daniel, There are multiple types of samplers in OMPL. For states, you have two types of samplers: 1. Spacelevel sampling, which inherits from StateSampler. These are basic functions that always succeed at producing samples. All planners and other types of samplers depend on these samplers. Obtaining such a sampler can be done with the StateSamplerPtr ss = StateSpace::allocStateSampler(); ss>sampleUniform(...); http://ompl.kavrakilab.org/core/classompl_1_1base_1_1StateSampler.html If you previously call StateSpace::setStateSamplerAllocator(), you will get your sampler when further calls to allocStateSampler() are made. Just for completeness, it is possible to also bypass the setting made by setStateSamplerAllocator() if one calls allocDefaultStateSampler(), but this is normally not needed (possibly in your own replacement sampler only) 2. Valid state samplers. These are implementations of various sampling distributions. Producing samples may not always be successful, but returned samplers are always valid. Implementations are bridge test, obstaclebased sampling, etc. Not all planners use valid state samplers. Allocating and setting samplers in this case is done as indicated in your code sample. For your work, I think you need to follow option 1. Let me know if you have any further questions! Best regards, Ioan On Sat, Apr 21, 2012 at 11:42 AM, daniel chan <danielstar01@...>wrote: > Hello Ioan, > Should I set it to space or SpaceInformation? > like: > si>setValidStateSamplerAllocator(boost::bind(&allocMyValidStateSampler, > _1)); > > OR both way should work? > If I set it to SpaceInformation then I can allocate sampler and state as > given below, I don't know how to do these steps if I set it to StateSpace > instead of SpaceInformation: > ompl::base::ValidStateSamplerPtr sampler_ = > si_>allocMyValidStateSampler(); > ompl::base::State *state = si_>sllocState(); > sampler_>sample(state); > > Thanks, > Daniel > > >  > For Developers, A Lot Can Happen In A Second. > Boundary is the first to Know...and Tell You. > Monitor Your Applications in UltraFine Resolution. Try it FREE! > http://p.sf.net/sfu/Boundaryd2dvs2 > _______________________________________________ > omplusers mailing list > omplusers@... > https://lists.sourceforge.net/lists/listinfo/omplusers > > 
From: daniel chan <danielstar01@gm...>  20120421 08:42:50

Hello Ioan, Should I set it to space or SpaceInformation? like: si>setValidStateSamplerAllocator(boost::bind(&allocMyValidStateSampler, _1)); OR both way should work? If I set it to SpaceInformation then I can allocate sampler and state as given below, I don't know how to do these steps if I set it to StateSpace instead of SpaceInformation: ompl::base::ValidStateSamplerPtr sampler_ = si_>allocMyValidStateSampler(); ompl::base::State *state = si_>sllocState(); sampler_>sample(state); Thanks, Daniel 
From: Ioan Sucan <isucan@gm...>  20120418 19:22:05

On Wed, Apr 18, 2012 at 10:00 PM, daniel chan <danielstar01@...>wrote: > Hello, > > I want to define 10D state space (3Dx,y,theta for the base and 7D for the > arm), and set my statevaliditychecker function. > Can I define 10D state space but restrict the random sampling (a valid > sample in 3D) for 3D only (x,y, theta). Other 7D I can set in my new > planner under ompl domain. How to do it? Can I do it by this way? > Yes, you can do that fairly easily. You probably want something like SE2StateSpace for the base and RealVectorStateSpace(7) for the arm. Then, you construct a CompoundStateSpace for the two spaces mentioned above. Something like this should work: StateSpacePtr se2(new SE2StateSpace()); StateSpacePtr arm(new RealVectorStateSpace(7)); StateSpacePtr full = se2 + arm; Then you set your StateValidityChecker to whatever you please. To sample only in 3D, all you have to so is define a sampler yourself, inheriting from StateSampler ( http://ompl.kavrakilab.org/classompl_1_1base_1_1StateSampler.html) That sampler can do whatever you would like it to do. class MyOwnDefinedSampler : public StateSampler { public: .... }; Then you set that sampler to the space you created: StateSamplerPtr myAlloc(const StateSpace *space) { return StateSamplerPtr(new MyOwnDefinedSampler(space)); } full>setStateSamplerAllocator(&myAlloc); Ioan > > Thanks in advance. > Daniel > > >  > Better than sec? Nothing is better than sec when it comes to > monitoring Big Data applications. Try Boundary onesecond > resolution app monitoring today. Free. > http://p.sf.net/sfu/Boundarydev2dev > _______________________________________________ > omplusers mailing list > omplusers@... > https://lists.sourceforge.net/lists/listinfo/omplusers > > 
From: daniel chan <danielstar01@gm...>  20120418 19:00:23

Hello, I want to define 10D state space (3Dx,y,theta for the base and 7D for the arm), and set my statevaliditychecker function. Can I define 10D state space but restrict the random sampling (a valid sample in 3D) for 3D only (x,y, theta). Other 7D I can set in my new planner under ompl domain. How to do it? Can I do it by this way? Thanks in advance. Daniel 
From: Mark Moll <mmoll@ri...>  20120404 21:34:32

On Apr 2, 2012, at 6:28 PM, Adam Hartshorne wrote: > I am looking to sample unit quaternions from a gaussian distribution given a known mean quaternion Q and std of StdDev. > > Now I have come across the sampleGaussian function in the SO3StateSampler class, but the description doesn't make a whole lot of sense to me. It seems a bit garbled. Thus, I am a little unclear if this function it is doing exactly what I want or not. I pushed a fix to Gaussian sampling of unit quaternions to the public repository; see http://ompl.hg.sourceforge.net/hgweb/ompl/ompl/rev/6e2c50e2fe5c. I used the “wrapping” of tangent space approach as described by Johnson in his thesis. In our implementation we don’t allow arbitrary covariance matrices, but only ones of the form sigma^2 * I. This simplifies things a bit. I also don’t care about the tails of the distribution wrapping around. Instead, I check whether the standard deviation is “large” and, if so, just sample uniformly.  Mark Moll 
From: Mark Moll <mmoll@ri...>  20120403 19:39:44

[Forwarded with Adam Hartshorne’s permission.] Begin forwarded message: > From: Adam Hartshorne <adam.hartshorne@...> > Subject: Re: [omplusers] Sampling a Unit Quaternion from a Gaussian Distribution Question > Date: April 3, 2012 2:35:29 PM CDT > To: Mark Moll <mmoll@...> > > Hi, > > I have colour coded my reply to try and make it easier to read. > > It seems that Johnson PhD passed a lot of people by. I have come across several people "reinventing the wheel" to sample and combine quaternions, who seem unaware of the work in question. > > I think I will implement that and replace the existing implementation > > I will be more than happy to test it out when it is complete. > > The description in Court & Arnoud doesn’t look quite right; sigma^2 is undefined. Perhaps they assume sigma_1 = sigma_2 = sigma_3 = sigma? > > I forgot to mention, when I came to implement it a few years ago, I noticed the same thing :)...Good job I managed to speak to them about it. Here are the relevant bits from our exchange a few years ago. > > a rotation in space can be seen as a rotation of a given angle > around a given axis. Schematically, sigma_1, sigma_2 and sigma_3 > can be seen as the variances around the 3 coordinates of the axis, > while sigma can be seen as the variance of the angular value. > So by nature it is different from the 3 previous sigma. > > It's a user defined parameter in the experiments we conducted > in the AMDO paper, but it can also be efficiently learned from motion > capture data for instance. Actually, the covariance matrix was also > manually defined. > > > The sigma parameter is also related to the QuTem distribution in some sense. Though, I'm not sure > about how it is related the covariance matrix. I'll investigate and try to > give you a more convincing answer :) > > > Do dual quaternions offer any significant advantages? > > They offer a simple way to describe arbitrary geometric relations and provide a mathematical background > that allows combining transformations by simple multiplication of the corresponding dual quaternions. > In a comparison to other representations, Funda and Paul (1990) showed that dual quaternions are the most computationally efficient and compact representation. They have better properties (constant > speed, shortest path and coordinate invariance) and are without singularity. > > I can send you some links of their use in recent academic work, which probably include better descriptions of why one would want to use this representation over say a combination of a Quaternion + Vector. > > Adam  Mark Moll 
From: Mark Moll <mmoll@ri...>  20120403 19:38:47

Hi Adam, Thanks for the references! Sampling in the tangent space the way QuTEM does looks interesting. I think I will implement that and replace the existing implementation (which I believe is very similar, but not exactly the same). The description in Court & Arnoud doesn’t look quite right; sigma^2 is undefined. Perhaps they assume sigma_1 = sigma_2 = sigma_3 = sigma? I briefly scanned the other paper about dual quaternions. This seems to be another representation of SE(3). We currently represent SE(3) by quaternions and real 3vectors. This seems reasonably efficient, both in terms of computation and storage, for the types of operations that state spaces need to support in OMPL. Do dual quaternions offer any significant advantages? On Apr 3, 2012, at 4:05 AM, Adam Hartshorne wrote: > Hi, > > A QuTem distribution is described in > > Exploiting Quaternions to Support Expressive Interactive Character Motion (2003) by Michael Patrick Johnson (Phd Thesis) > http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.9.5467 > > A description of a possible use and clear implementation details of a sampler is given in (Appendix A), > > Sequential Monte Carlo Inverse Kinematics (2008) by Nicolas Court & Elise Arnaud > > http://hal.inria.fr/docs/00/24/84/15/PDF/RR6426.pdf > > > I was also wondering if you have considered extending your library to include dual quaternions? > > MPG  A Framework for Reasoning on 6 DOF Pose Uncertainty (2011) by Wendelin Feiten & Muriel Lang > > http://vault.willowgarage.com/wgdata1/vol1/muu11/WSF1206.pdf > > This paper details an interesting method by which one can use a convex combination of Projected Gaussians > in lieu of multivariate Gaussian distributions to represent the probability density function (pdf) of a 6D pose > consisting of a 3D translation component and an orientation. > > Adam > > > On Tue, Apr 3, 2012 at 4:20 AM, Mark Moll <mmoll@...> wrote: > Adam, > > The sampleGaussian function does indeed what you would expect. The documentation is not so much about *what* the function does (as this is specified by the abstract base class), but more about *how* this is implemented (since it is not entirely trivial). We didn’t use any particular paper, but if there’s a good reference please let us know. The paper by James Kuffner from ICRA 2004 only describes uniform sampling from SO(3), not Gaussian sampling, as far as I know. I am not familiar with the QuTem paper by Johnson.Can you me the complete reference? > > > On Apr 2, 2012, at 6:28 PM, Adam Hartshorne wrote: > >> Hi, >> >> I am looking to sample unit quaternions from a gaussian distribution given a known mean quaternion Q and std of StdDev. >> >> Now I have come across the sampleGaussian function in the SO3StateSampler class, but the description doesn't make a whole lot of sense to me. It seems a bit garbled. Thus, I am a little unclear if this function it is doing exactly what I want or not. >> >> >> sampleGaussian (State *state, const State *mean, const double stdDev) >> >> To sample sample a unit quaternion from a Gaussian, distribution we first compute a rotation q about a uniformly random unit vector by an angle sampled from a Gaussian with mean equal to 0 and standard deviation equal to 2*stdDev, and with a correction to account for the larger volume of states at increasing distance. (Quaternion distance is equal to half the angle in axisangle representation.) The resulting state is then the quaternion product of near and q. >> >> >> And if it is doing as I hope, what algorithm is being used to generate the samples? QuTem by Johnson? Kuffner, ICRA‘04.? >> >> Any help much appreciated. >> >> >> Adam >> > >  > Mark Moll > > > >  Mark Moll 
From: Mark Moll <mmoll@ri...>  20120403 03:20:25

Adam, The sampleGaussian function does indeed what you would expect. The documentation is not so much about *what* the function does (as this is specified by the abstract base class), but more about *how* this is implemented (since it is not entirely trivial). We didn’t use any particular paper, but if there’s a good reference please let us know. The paper by James Kuffner from ICRA 2004 only describes uniform sampling from SO(3), not Gaussian sampling, as far as I know. I am not familiar with the QuTem paper by Johnson.Can you me the complete reference? On Apr 2, 2012, at 6:28 PM, Adam Hartshorne wrote: > Hi, > > I am looking to sample unit quaternions from a gaussian distribution given a known mean quaternion Q and std of StdDev. > > Now I have come across the sampleGaussian function in the SO3StateSampler class, but the description doesn't make a whole lot of sense to me. It seems a bit garbled. Thus, I am a little unclear if this function it is doing exactly what I want or not. > > > sampleGaussian (State *state, const State *mean, const double stdDev) > > To sample sample a unit quaternion from a Gaussian, distribution we first compute a rotation q about a uniformly random unit vector by an angle sampled from a Gaussian with mean equal to 0 and standard deviation equal to 2*stdDev, and with a correction to account for the larger volume of states at increasing distance. (Quaternion distance is equal to half the angle in axisangle representation.) The resulting state is then the quaternion product of near and q. > > > And if it is doing as I hope, what algorithm is being used to generate the samples? QuTem by Johnson? Kuffner, ICRA‘04.? > > Any help much appreciated. > > > Adam >  Mark Moll 
From: Adam Hartshorne <adam.hartshorne@gm...>  20120402 23:28:13

Hi, I am looking to sample unit quaternions from a gaussian distribution given a known mean quaternion Q and std of StdDev. Now I have come across the sampleGaussian function in the SO3StateSampler class, but the description doesn't make a whole lot of sense to me. It seems a bit garbled. Thus, I am a little unclear if this function it is doing exactly what I want or not. sampleGaussian<http://ompl.kavrakilab.org/core/classompl_1_1base_1_1SO3StateSampler.html#ad73f1f60597f294443fdd2f4af7dc9fe>; > (State <http://ompl.kavrakilab.org/core/classompl_1_1base_1_1State.html>; *state, > const State<http://ompl.kavrakilab.org/core/classompl_1_1base_1_1State.html>; *mean, > const double stdDev) > To sample sample a unit quaternion from a Gaussian, distribution we first > compute a rotation q about a uniformly random unit vector by an angle > sampled from a Gaussian with mean equal to 0 and standard deviation equal > to 2*stdDev, and with a correction to account for the larger volume of > states at increasing distance. (Quaternion distance is equal to half the > angle in axisangle representation.) The resulting state is then the > quaternion product of near and q. And if it is doing as I hope, what algorithm is being used to generate the samples? QuTem by Johnson? Kuffner, ICRA‘04.? Any help much appreciated. Adam 