DiscreteStateSpace.h
1 /*********************************************************************
2 * Software License Agreement (BSD License)
3 *
4 * Copyright (c) 2011, Rice University
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
17 * * Neither the name of the Rice University nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
33 *********************************************************************/
34 
35 /* Author: Elizabeth Fudge */
36 
37 #ifndef OMPL_BASE_SPACES_DISCRETE_STATE_SPACE_
38 #define OMPL_BASE_SPACES_DISCRETE_STATE_SPACE_
39 
40 #include "ompl/base/StateSpace.h"
41 
42 namespace ompl
43 {
44  namespace base
45  {
47  class DiscreteStateSampler : public StateSampler
48  {
49  public:
51  DiscreteStateSampler(const StateSpace *space) : StateSampler(space)
52  {
53  }
54 
55  void sampleUniform(State *state) override;
56  void sampleUniformNear(State *state, const State *near, double distance) override;
57  void sampleGaussian(State *state, const State *mean, double stdDev) override;
58  };
59 
67  class DiscreteStateSpace : public StateSpace
68  {
69  public:
71  class StateType : public State
72  {
73  public:
75  int value;
76  };
77 
80  DiscreteStateSpace(int lowerBound, int upperBound)
81  : lowerBound_(lowerBound), upperBound_(upperBound)
82  {
83  setName("Discrete" + getName());
85  }
86 
87  ~DiscreteStateSpace() override = default;
88 
89  bool isDiscrete() const override;
90 
91  unsigned int getDimension() const override;
92 
93  double getMaximumExtent() const override;
94 
95  double getMeasure() const override;
96 
97  void enforceBounds(State *state) const override;
98 
99  bool satisfiesBounds(const State *state) const override;
100 
101  unsigned int getSerializationLength() const override;
102 
103  void serialize(void *serialization, const State *state) const override;
104 
105  void deserialize(State *state, const void *serialization) const override;
106 
107  void copyState(State *destination, const State *source) const override;
108 
109  double distance(const State *state1, const State *state2) const override;
110 
111  bool equalStates(const State *state1, const State *state2) const override;
112 
113  void interpolate(const State *from, const State *to, double t, State *state) const override;
114 
115  StateSamplerPtr allocDefaultStateSampler() const override;
116 
117  State *allocState() const override;
118 
119  void freeState(State *state) const override;
120 
121  void printState(const State *state, std::ostream &out) const override;
122 
123  void printSettings(std::ostream &out) const override;
124 
125  void registerProjections() override;
126 
128  unsigned int getStateCount() const
129  {
130  return upperBound_ - lowerBound_ + 1;
131  }
132 
134  int getLowerBound() const
135  {
136  return lowerBound_;
137  }
138 
140  int getUpperBound() const
141  {
142  return upperBound_;
143  }
144 
147  void setBounds(int lowerBound, int upperBound)
148  {
149  lowerBound_ = lowerBound;
150  upperBound_ = upperBound;
151  }
152 
153  void setup() override;
154 
155  protected:
157  int lowerBound_;
158 
160  int upperBound_;
161  };
162  }
163 }
164 
165 #endif
double getMaximumExtent() const override
Get the maximum value a call to distance() can return (or an upper bound). For unbounded state spaces...
void enforceBounds(State *state) const override
Bring the state within the bounds of the state space. For unbounded spaces this function can be a no-...
State * allocState() const override
Allocate a state that can store a point in the described space.
int upperBound_
The highest integer state.
int lowerBound_
The lowest integer state.
void sampleUniformNear(State *state, const State *near, double distance) override
Sample a state near another, within a neighborhood controlled by a distance parameter.
Definition of an abstract state.
Definition: State.h:110
void printSettings(std::ostream &out) const override
Print the settings for this state space to a stream.
void deserialize(State *state, const void *serialization) const override
Read the binary representation of a state from serialization and write it to state.
double getMeasure() const override
Get a measure of the space (this can be thought of as a generalization of volume)
int value
The current state - an int in range [lowerBound, upperBound].
void copyState(State *destination, const State *source) const override
Copy a state to another. The memory of source and destination should NOT overlap.
void printState(const State *state, std::ostream &out) const override
Print a state to a stream.
int getLowerBound() const
Returns the lowest possible state.
ompl::base::State StateType
Define the type of state allocated by this space.
Definition: StateSpace.h:139
bool satisfiesBounds(const State *state) const override
Check if a state is inside the bounding box. For unbounded spaces this function can always return tru...
unsigned int getStateCount() const
Returns the number of states possible.
ompl::base::DiscreteStateSpace
int getUpperBound() const
Returns the highest possible state.
const std::string & getName() const
Get the name of the state space.
Definition: StateSpace.cpp:195
void registerProjections() override
Register the projections for this state space. Usually, this is at least the default projection....
DiscreteStateSampler(const StateSpace *space)
Constructor.
StateSamplerPtr allocDefaultStateSampler() const override
Allocate an instance of the default uniform state sampler for this space.
void setName(const std::string &name)
Set the name of the state space.
Definition: StateSpace.cpp:200
int type_
A type assigned for this state space.
Definition: StateSpace.h:592
void sampleUniform(State *state) override
Sample a state.
void setBounds(int lowerBound, int upperBound)
Set the bounds for the states in this space (the states will be in the set [lowerBound,...
bool equalStates(const State *state1, const State *state2) const override
Checks whether two states are equal.
void sampleGaussian(State *state, const State *mean, double stdDev) override
Sample a state using a Gaussian distribution with given mean and standard deviation (stdDev).
double distance(const State *state1, const State *state2) const override
Computes distance between two states. This function satisfies the properties of a metric if isMetricS...
void interpolate(const State *from, const State *to, double t, State *state) const override
Computes the state that lies at time t in [0, 1] on the segment that connects from state to to state....
unsigned int getDimension() const override
Get the dimension of the space (not the dimension of the surrounding ambient space)
void serialize(void *serialization, const State *state) const override
Write the binary representation of state to serialization.
A shared pointer wrapper for ompl::base::StateSampler.
void setup() override
Perform final setup steps. This function is automatically called by the SpaceInformation....
unsigned int getSerializationLength() const override
Get the number of chars in the serialization of a state in this space.
void freeState(State *state) const override
Free the memory of the allocated state.
bool isDiscrete() const override
Check if the set of states is discrete.
Main namespace. Contains everything in this library.
Definition: AppBase.h:20
DiscreteStateSpace(int lowerBound, int upperBound)
Construct a discrete space in wich states can take values in the set [lowerBound, upperBound].