repo
stringlengths 1
152
⌀ | file
stringlengths 15
205
| code
stringlengths 0
41.6M
| file_length
int64 0
41.6M
| avg_line_length
float64 0
1.81M
| max_line_length
int64 0
12.7M
| extension_type
stringclasses 90
values |
|---|---|---|---|---|---|---|
octomap | octomap-master/octomap/include/octomap/OcTreeIterator.hxx | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMAP_OCTREEITERATOR_HXX_
#define OCTOMAP_OCTREEITERATOR_HXX_
/**
* Base class for OcTree iterators. So far, all iterator's are
* const with respect to the tree. This file is included within
* OcTreeBaseImpl.h, you should probably not include this directly.
*/
class iterator_base : public std::iterator<std::forward_iterator_tag, NodeType>{
public:
struct StackElement;
/// Default ctor, only used for the end-iterator
iterator_base() : tree(NULL), maxDepth(0){}
/**
* Constructor of the iterator. Initializes the iterator with the default
* constructor (= end() iterator) if tree is empty or NULL.
*
* @param ptree OcTreeBaseImpl on which the iterator is used on
* @param depth Maximum depth to traverse the tree. 0 (default): unlimited
*/
iterator_base(OcTreeBaseImpl<NodeType,INTERFACE> const* ptree, uint8_t depth=0)
: tree((ptree && ptree->root) ? ptree : NULL), maxDepth(depth)
{
if (ptree && maxDepth == 0)
maxDepth = ptree->getTreeDepth();
if (tree && tree->root){ // tree is not empty
StackElement s;
s.node = tree->root;
s.depth = 0;
s.key[0] = s.key[1] = s.key[2] = tree->tree_max_val;
stack.push(s);
} else{ // construct the same as "end"
tree = NULL;
this->maxDepth = 0;
}
}
/// Copy constructor of the iterator
iterator_base(const iterator_base& other)
: tree(other.tree), maxDepth(other.maxDepth), stack(other.stack) {}
/// Comparison between iterators. First compares the tree, then stack size and top element of stack.
bool operator==(const iterator_base& other) const {
return (tree ==other.tree && stack.size() == other.stack.size()
&& (stack.size()==0 || (stack.size() > 0 && (stack.top().node == other.stack.top().node
&& stack.top().depth == other.stack.top().depth
&& stack.top().key == other.stack.top().key ))));
}
/// Comparison between iterators. First compares the tree, then stack size and top element of stack.
bool operator!=(const iterator_base& other) const {
return (tree !=other.tree || stack.size() != other.stack.size()
|| (stack.size() > 0 && ((stack.top().node != other.stack.top().node
|| stack.top().depth != other.stack.top().depth
|| stack.top().key != other.stack.top().key ))));
}
iterator_base& operator=(const iterator_base& other){
tree = other.tree;
maxDepth = other.maxDepth;
stack = other.stack;
return *this;
};
/// Ptr operator will return the current node in the octree which the
/// iterator is referring to
NodeType const* operator->() const { return stack.top().node;}
/// Ptr operator will return the current node in the octree which the
/// iterator is referring to
NodeType* operator->() { return stack.top().node;}
/// Return the current node in the octree which the
/// iterator is referring to
const NodeType& operator*() const { return *(stack.top().node);}
/// Return the current node in the octree which the
/// iterator is referring to
NodeType& operator*() { return *(stack.top().node);}
/// return the center coordinate of the current node
point3d getCoordinate() const {
return tree->keyToCoord(stack.top().key, stack.top().depth);
}
/// @return single coordinate of the current node
double getX() const{
return tree->keyToCoord(stack.top().key[0], stack.top().depth);
}
/// @return single coordinate of the current node
double getY() const{
return tree->keyToCoord(stack.top().key[1], stack.top().depth);
}
/// @return single coordinate of the current node
double getZ() const{
return tree->keyToCoord(stack.top().key[2], stack.top().depth);
}
/// @return the side of the volume occupied by the current node
double getSize() const {return tree->getNodeSize(stack.top().depth); }
/// return depth of the current node
unsigned getDepth() const {return unsigned(stack.top().depth); }
/// @return the OcTreeKey of the current node
const OcTreeKey& getKey() const {return stack.top().key;}
/// @return the OcTreeKey of the current node, for nodes with depth != maxDepth
OcTreeKey getIndexKey() const {
return computeIndexKey(tree->getTreeDepth() - stack.top().depth, stack.top().key);
}
/// Element on the internal recursion stack of the iterator
struct StackElement{
NodeType* node;
OcTreeKey key;
uint8_t depth;
};
protected:
OcTreeBaseImpl<NodeType,INTERFACE> const* tree; ///< Octree this iterator is working on
uint8_t maxDepth; ///< Maximum depth for depth-limited queries
/// Internal recursion stack. Apparently a stack of vector works fastest here.
std::stack<StackElement,std::vector<StackElement> > stack;
/// One step of depth-first tree traversal.
/// How this is used depends on the actual iterator.
void singleIncrement(){
StackElement top = stack.top();
stack.pop();
if (top.depth == maxDepth)
return;
StackElement s;
s.depth = top.depth +1;
key_type center_offset_key = tree->tree_max_val >> s.depth;
// push on stack in reverse order
for (int i=7; i>=0; --i) {
if (tree->nodeChildExists(top.node,i)) {
computeChildKey(i, center_offset_key, top.key, s.key);
s.node = tree->getNodeChild(top.node, i);
//OCTOMAP_DEBUG_STR("Current depth: " << int(top.depth) << " new: "<< int(s.depth) << " child#" << i <<" ptr: "<<s.node);
stack.push(s);
assert(s.depth <= maxDepth);
}
}
}
};
/**
* Iterator over the complete tree (inner nodes and leafs).
* See below for example usage.
* Note that the non-trivial call to tree->end_tree() should be done only once
* for efficiency!
*
* @code
* for(OcTreeTYPE::tree_iterator it = tree->begin_tree(),
* end=tree->end_tree(); it!= end; ++it)
* {
* //manipulate node, e.g.:
* std::cout << "Node center: " << it.getCoordinate() << std::endl;
* std::cout << "Node size: " << it.getSize() << std::endl;
* std::cout << "Node value: " << it->getValue() << std::endl;
* }
* @endcode
*/
class tree_iterator : public iterator_base {
public:
tree_iterator() : iterator_base(){}
/**
* Constructor of the iterator.
*
* @param ptree OcTreeBaseImpl on which the iterator is used on
* @param depth Maximum depth to traverse the tree. 0 (default): unlimited
*/
tree_iterator(OcTreeBaseImpl<NodeType,INTERFACE> const* ptree, uint8_t depth=0) : iterator_base(ptree, depth) {};
/// postfix increment operator of iterator (it++)
tree_iterator operator++(int){
tree_iterator result = *this;
++(*this);
return result;
}
/// Prefix increment operator to advance the iterator
tree_iterator& operator++(){
if (!this->stack.empty()){
this->singleIncrement();
}
if (this->stack.empty()){
this->tree = NULL;
}
return *this;
}
/// @return whether the current node is a leaf, i.e. has no children or is at max level
bool isLeaf() const{
return (!this->tree->nodeHasChildren(this->stack.top().node) || this->stack.top().depth == this->maxDepth);
}
};
/**
* Iterator to iterate over all leafs of the tree.
* Inner nodes are skipped. See below for example usage.
* Note that the non-trivial call to tree->end_leafs() should be done only once
* for efficiency!
*
* @code
* for(OcTreeTYPE::leaf_iterator it = tree->begin_leafs(),
* end=tree->end_leafs(); it!= end; ++it)
* {
* //manipulate node, e.g.:
* std::cout << "Node center: " << it.getCoordinate() << std::endl;
* std::cout << "Node size: " << it.getSize() << std::endl;
* std::cout << "Node value: " << it->getValue() << std::endl;
* }
* @endcode
*
*/
class leaf_iterator : public iterator_base {
public:
leaf_iterator() : iterator_base(){}
/**
* Constructor of the iterator.
*
* @param ptree OcTreeBaseImpl on which the iterator is used on
* @param depth Maximum depth to traverse the tree. 0 (default): unlimited
*/
leaf_iterator(OcTreeBaseImpl<NodeType, INTERFACE> const* ptree, uint8_t depth=0) : iterator_base(ptree, depth) {
// tree could be empty (= no stack)
if (this->stack.size() > 0){
// skip forward to next valid leaf node:
// add root another time (one will be removed) and ++
this->stack.push(this->stack.top());
operator ++();
}
}
leaf_iterator(const leaf_iterator& other) : iterator_base(other) {};
/// postfix increment operator of iterator (it++)
leaf_iterator operator++(int){
leaf_iterator result = *this;
++(*this);
return result;
}
/// prefix increment operator of iterator (++it)
leaf_iterator& operator++(){
if (this->stack.empty()){
this->tree = NULL; // TODO check?
} else {
this->stack.pop();
// skip forward to next leaf
while(!this->stack.empty()
&& this->stack.top().depth < this->maxDepth
&& this->tree->nodeHasChildren(this->stack.top().node))
{
this->singleIncrement();
}
// done: either stack is empty (== end iterator) or a next leaf node is reached!
if (this->stack.empty())
this->tree = NULL;
}
return *this;
}
};
/**
* Bounding-box leaf iterator. This iterator will traverse all leaf nodes
* within a given bounding box (axis-aligned). See below for example usage.
* Note that the non-trivial call to tree->end_leafs_bbx() should be done only once
* for efficiency!
*
* @code
* for(OcTreeTYPE::leaf_bbx_iterator it = tree->begin_leafs_bbx(min,max),
* end=tree->end_leafs_bbx(); it!= end; ++it)
* {
* //manipulate node, e.g.:
* std::cout << "Node center: " << it.getCoordinate() << std::endl;
* std::cout << "Node size: " << it.getSize() << std::endl;
* std::cout << "Node value: " << it->getValue() << std::endl;
* }
* @endcode
*/
class leaf_bbx_iterator : public iterator_base {
public:
leaf_bbx_iterator() : iterator_base() {};
/**
* Constructor of the iterator. The bounding box corners min and max are
* converted into an OcTreeKey first.
*
* @note Due to rounding and discretization
* effects, nodes may be traversed that have float coordinates appearing
* outside of the (float) bounding box. However, the node's complete volume
* will include the bounding box coordinate. For a more exact control, use
* the constructor with OcTreeKeys instead.
*
* @param ptree OcTreeBaseImpl on which the iterator is used on
* @param min Minimum point3d of the axis-aligned boundingbox
* @param max Maximum point3d of the axis-aligned boundingbox
* @param depth Maximum depth to traverse the tree. 0 (default): unlimited
*/
leaf_bbx_iterator(OcTreeBaseImpl<NodeType,INTERFACE> const* ptree, const point3d& min, const point3d& max, uint8_t depth=0)
: iterator_base(ptree, depth)
{
if (this->stack.size() > 0){
assert(ptree);
if (!this->tree->coordToKeyChecked(min, minKey) || !this->tree->coordToKeyChecked(max, maxKey)){
// coordinates invalid, set to end iterator
this->tree = NULL;
this->maxDepth = 0;
} else{ // else: keys are generated and stored
// advance from root to next valid leaf in bbx:
this->stack.push(this->stack.top());
this->operator ++();
}
}
}
/**
* Constructor of the iterator. This version uses the exact keys as axis-aligned
* bounding box (including min and max).
*
* @param ptree OcTreeBaseImpl on which the iterator is used on
* @param min Minimum OcTreeKey to be included in the axis-aligned boundingbox
* @param max Maximum OcTreeKey to be included in the axis-aligned boundingbox
* @param depth Maximum depth to traverse the tree. 0 (default): unlimited
*/
leaf_bbx_iterator(OcTreeBaseImpl<NodeType,INTERFACE> const* ptree, const OcTreeKey& min, const OcTreeKey& max, uint8_t depth=0)
: iterator_base(ptree, depth), minKey(min), maxKey(max)
{
// tree could be empty (= no stack)
if (this->stack.size() > 0){
// advance from root to next valid leaf in bbx:
this->stack.push(this->stack.top());
this->operator ++();
}
}
leaf_bbx_iterator(const leaf_bbx_iterator& other) : iterator_base(other) {
minKey = other.minKey;
maxKey = other.maxKey;
}
/// postfix increment operator of iterator (it++)
leaf_bbx_iterator operator++(int){
leaf_bbx_iterator result = *this;
++(*this);
return result;
}
/// prefix increment operator of iterator (++it)
leaf_bbx_iterator& operator++(){
if (this->stack.empty()){
this->tree = NULL; // TODO check?
} else {
this->stack.pop();
// skip forward to next leaf
while(!this->stack.empty()
&& this->stack.top().depth < this->maxDepth
&& this->tree->nodeHasChildren(this->stack.top().node))
{
this->singleIncrement();
}
// done: either stack is empty (== end iterator) or a next leaf node is reached!
if (this->stack.empty())
this->tree = NULL;
}
return *this;
};
protected:
void singleIncrement(){
typename iterator_base::StackElement top = this->stack.top();
this->stack.pop();
typename iterator_base::StackElement s;
s.depth = top.depth +1;
key_type center_offset_key = this->tree->tree_max_val >> s.depth;
// push on stack in reverse order
for (int i=7; i>=0; --i) {
if (this->tree->nodeChildExists(top.node, i)) {
computeChildKey(i, center_offset_key, top.key, s.key);
// overlap of query bbx and child bbx?
if ((minKey[0] <= (s.key[0] + center_offset_key)) && (maxKey[0] >= (s.key[0] - center_offset_key))
&& (minKey[1] <= (s.key[1] + center_offset_key)) && (maxKey[1] >= (s.key[1] - center_offset_key))
&& (minKey[2] <= (s.key[2] + center_offset_key)) && (maxKey[2] >= (s.key[2] - center_offset_key)))
{
s.node = this->tree->getNodeChild(top.node, i);
this->stack.push(s);
assert(s.depth <= this->maxDepth);
}
}
}
}
OcTreeKey minKey;
OcTreeKey maxKey;
};
#endif /* OCTREEITERATOR_HXX_ */
| 17,543 | 36.810345 | 133 | hxx |
octomap | octomap-master/octomap/include/octomap/OcTreeKey.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMAP_OCTREE_KEY_H
#define OCTOMAP_OCTREE_KEY_H
/* According to c++ standard including this header has no practical effect
* but it can be used to determine the c++ standard library implementation.
*/
#include <ciso646>
#include <assert.h>
/* Libc++ does not implement the TR1 namespace, all c++11 related functionality
* is instead implemented in the std namespace.
*/
#if defined(__GNUC__) && ! defined(_LIBCPP_VERSION)
#include <tr1/unordered_set>
#include <tr1/unordered_map>
namespace octomap {
namespace unordered_ns = std::tr1;
}
#else
#include <unordered_set>
#include <unordered_map>
namespace octomap {
namespace unordered_ns = std;
}
#endif
namespace octomap {
typedef uint16_t key_type;
/**
* OcTreeKey is a container class for internal key addressing. The keys count the
* number of cells (voxels) from the origin as discrete address of a voxel.
* @see OcTreeBaseImpl::coordToKey() and OcTreeBaseImpl::keyToCoord() for conversions.
*/
class OcTreeKey {
public:
OcTreeKey () {}
OcTreeKey (key_type a, key_type b, key_type c){
k[0] = a;
k[1] = b;
k[2] = c;
}
OcTreeKey(const OcTreeKey& other){
k[0] = other.k[0];
k[1] = other.k[1];
k[2] = other.k[2];
}
bool operator== (const OcTreeKey &other) const {
return ((k[0] == other[0]) && (k[1] == other[1]) && (k[2] == other[2]));
}
bool operator!= (const OcTreeKey& other) const {
return( (k[0] != other[0]) || (k[1] != other[1]) || (k[2] != other[2]) );
}
OcTreeKey& operator=(const OcTreeKey& other){
k[0] = other.k[0]; k[1] = other.k[1]; k[2] = other.k[2];
return *this;
}
const key_type& operator[] (unsigned int i) const {
return k[i];
}
key_type& operator[] (unsigned int i) {
return k[i];
}
key_type k[3];
/// Provides a hash function on Keys
struct KeyHash{
size_t operator()(const OcTreeKey& key) const{
// a simple hashing function
// explicit casts to size_t to operate on the complete range
// constanst will be promoted according to C++ standard
return static_cast<size_t>(key.k[0])
+ 1447*static_cast<size_t>(key.k[1])
+ 345637*static_cast<size_t>(key.k[2]);
}
};
};
/**
* Data structure to efficiently compute the nodes to update from a scan
* insertion using a hash set.
* @note you need to use boost::unordered_set instead if your compiler does not
* yet support tr1!
*/
typedef unordered_ns::unordered_set<OcTreeKey, OcTreeKey::KeyHash> KeySet;
/**
* Data structrure to efficiently track changed nodes as a combination of
* OcTreeKeys and a bool flag (to denote newly created nodes)
*
*/
typedef unordered_ns::unordered_map<OcTreeKey, bool, OcTreeKey::KeyHash> KeyBoolMap;
class KeyRay {
public:
KeyRay () {
ray.resize(maxSize);
reset();
}
KeyRay(const KeyRay& other){
ray = other.ray;
size_t dSize = other.end() - other.begin();
end_of_ray = ray.begin() + dSize;
}
void reset() {
end_of_ray = begin();
}
void addKey(const OcTreeKey& k) {
assert(end_of_ray != ray.end());
*end_of_ray = k;
++end_of_ray;
}
size_t size() const { return end_of_ray - ray.begin(); }
size_t sizeMax() const { return maxSize; }
typedef std::vector<OcTreeKey>::iterator iterator;
typedef std::vector<OcTreeKey>::const_iterator const_iterator;
typedef std::vector<OcTreeKey>::reverse_iterator reverse_iterator;
iterator begin() { return ray.begin(); }
iterator end() { return end_of_ray; }
const_iterator begin() const { return ray.begin(); }
const_iterator end() const { return end_of_ray; }
reverse_iterator rbegin() { return (reverse_iterator) end_of_ray; }
reverse_iterator rend() { return ray.rend(); }
private:
std::vector<OcTreeKey> ray;
std::vector<OcTreeKey>::iterator end_of_ray;
const static size_t maxSize = 100000;
};
/**
* Computes the key of a child node while traversing the octree, given
* child index and current key
*
* @param[in] pos index of child node (0..7)
* @param[in] center_offset_key constant offset of octree keys
* @param[in] parent_key current (parent) key
* @param[out] child_key computed child key
*/
inline void computeChildKey (unsigned int pos, key_type center_offset_key,
const OcTreeKey& parent_key, OcTreeKey& child_key) {
// x-axis
if (pos & 1) child_key[0] = parent_key[0] + center_offset_key;
else child_key[0] = parent_key[0] - center_offset_key - (center_offset_key ? 0 : 1);
// y-axis
if (pos & 2) child_key[1] = parent_key[1] + center_offset_key;
else child_key[1] = parent_key[1] - center_offset_key - (center_offset_key ? 0 : 1);
// z-axis
if (pos & 4) child_key[2] = parent_key[2] + center_offset_key;
else child_key[2] = parent_key[2] - center_offset_key - (center_offset_key ? 0 : 1);
}
/// generate child index (between 0 and 7) from key at given tree depth
inline uint8_t computeChildIdx(const OcTreeKey& key, int depth){
uint8_t pos = 0;
if (key.k[0] & (1 << depth))
pos += 1;
if (key.k[1] & (1 << depth))
pos += 2;
if (key.k[2] & (1 << depth))
pos += 4;
return pos;
}
/**
* Generates a unique key for all keys on a certain level of the tree
*
* @param level from the bottom (= tree_depth - depth of key)
* @param key input indexing key (at lowest resolution / level)
* @return key corresponding to the input key at the given level
*/
inline OcTreeKey computeIndexKey(key_type level, const OcTreeKey& key) {
if (level == 0)
return key;
else {
key_type mask = 65535 << level;
OcTreeKey result = key;
result[0] &= mask;
result[1] &= mask;
result[2] &= mask;
return result;
}
}
} // namespace
#endif
| 7,910 | 31.422131 | 96 | h |
octomap | octomap-master/octomap/include/octomap/OcTreeNode.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMAP_OCTREE_NODE_H
#define OCTOMAP_OCTREE_NODE_H
#include "octomap_types.h"
#include "octomap_utils.h"
#include "OcTreeDataNode.h"
#include <limits>
namespace octomap {
/**
* Nodes to be used in OcTree. They represent 3d occupancy grid cells.
* "value" stores their log-odds occupancy.
*
* Note: If you derive a class (directly or indirectly) from OcTreeNode or
* OcTreeDataNode, you have to implement (at least) the following functions:
* createChild(), getChild(), getChild() const, expandNode() to avoid slicing
* errors and memory-related bugs.
* See ColorOcTreeNode in ColorOcTree.h for an example.
*
*/
class OcTreeNode : public OcTreeDataNode<float> {
public:
OcTreeNode();
~OcTreeNode();
// -- node occupancy ----------------------------
/// \return occupancy probability of node
inline double getOccupancy() const { return probability(value); }
/// \return log odds representation of occupancy probability of node
inline float getLogOdds() const{ return value; }
/// sets log odds occupancy of node
inline void setLogOdds(float l) { value = l; }
/**
* @return mean of all children's occupancy probabilities, in log odds
*/
double getMeanChildLogOdds() const;
/**
* @return maximum of children's occupancy probabilities, in log odds
*/
float getMaxChildLogOdds() const;
/// update this node's occupancy according to its children's maximum occupancy
inline void updateOccupancyChildren() {
this->setLogOdds(this->getMaxChildLogOdds()); // conservative
}
/// adds p to the node's logOdds value (with no boundary / threshold checking!)
void addValue(const float& p);
protected:
// "value" stores log odds occupancy probability
};
} // end namespace
#endif
| 3,621 | 35.959184 | 83 | h |
octomap | octomap-master/octomap/include/octomap/OcTreeStamped.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMAP_OCTREE_STAMPED_H
#define OCTOMAP_OCTREE_STAMPED_H
#include <octomap/OcTreeNode.h>
#include <octomap/OccupancyOcTreeBase.h>
#include <ctime>
namespace octomap {
// node definition
class OcTreeNodeStamped : public OcTreeNode {
public:
OcTreeNodeStamped() : OcTreeNode(), timestamp(0) {}
OcTreeNodeStamped(const OcTreeNodeStamped& rhs) : OcTreeNode(rhs), timestamp(rhs.timestamp) {}
bool operator==(const OcTreeNodeStamped& rhs) const{
return (rhs.value == value && rhs.timestamp == timestamp);
}
void copyData(const OcTreeNodeStamped& from){
OcTreeNode::copyData(from);
timestamp = from.getTimestamp();
}
// timestamp
inline unsigned int getTimestamp() const { return timestamp; }
inline void updateTimestamp() { timestamp = (unsigned int) time(NULL);}
inline void setTimestamp(unsigned int t) {timestamp = t; }
// update occupancy and timesteps of inner nodes
inline void updateOccupancyChildren() {
this->setLogOdds(this->getMaxChildLogOdds()); // conservative
updateTimestamp();
}
protected:
unsigned int timestamp;
};
// tree definition
class OcTreeStamped : public OccupancyOcTreeBase <OcTreeNodeStamped> {
public:
/// Default constructor, sets resolution of leafs
OcTreeStamped(double resolution);
/// virtual constructor: creates a new object of same type
/// (Covariant return type requires an up-to-date compiler)
OcTreeStamped* create() const {return new OcTreeStamped(resolution); }
std::string getTreeType() const {return "OcTreeStamped";}
//! \return timestamp of last update
unsigned int getLastUpdateTime();
void degradeOutdatedNodes(unsigned int time_thres);
virtual void updateNodeLogOdds(OcTreeNodeStamped* node, const float& update) const;
void integrateMissNoTime(OcTreeNodeStamped* node) const;
protected:
/**
* Static member object which ensures that this OcTree's prototype
* ends up in the classIDMapping only once. You need this as a
* static member in any derived octree class in order to read .ot
* files through the AbstractOcTree factory. You should also call
* ensureLinking() once from the constructor.
*/
class StaticMemberInitializer{
public:
StaticMemberInitializer() {
OcTreeStamped* tree = new OcTreeStamped(0.1);
tree->clearKeyRays();
AbstractOcTree::registerTreeType(tree);
}
/**
* Dummy function to ensure that MSVC does not drop the
* StaticMemberInitializer, causing this tree failing to register.
* Needs to be called from the constructor of this octree.
*/
void ensureLinking() {};
};
/// to ensure static initialization (only once)
static StaticMemberInitializer ocTreeStampedMemberInit;
};
} // end namespace
#endif
| 4,655 | 35.093023 | 98 | h |
octomap | octomap-master/octomap/include/octomap/OccupancyOcTreeBase.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMAP_OCCUPANCY_OCTREE_BASE_H
#define OCTOMAP_OCCUPANCY_OCTREE_BASE_H
#include <list>
#include <stdlib.h>
#include <vector>
#include "octomap_types.h"
#include "octomap_utils.h"
#include "OcTreeBaseImpl.h"
#include "AbstractOccupancyOcTree.h"
namespace octomap {
/**
* Base implementation for Occupancy Octrees (e.g. for mapping).
* AbstractOccupancyOcTree serves as a common
* base interface for all these classes.
* Each class used as NODE type needs to be derived from
* OccupancyOcTreeNode.
*
* This tree implementation has a maximum depth of 16.
* At a resolution of 1 cm, values have to be < +/- 327.68 meters (2^15)
*
* This limitation enables the use of an efficient key generation
* method which uses the binary representation of the data.
*
* \note The tree does not save individual points.
*
* \tparam NODE Node class to be used in tree (usually derived from
* OcTreeDataNode)
*/
template <class NODE>
class OccupancyOcTreeBase : public OcTreeBaseImpl<NODE,AbstractOccupancyOcTree> {
public:
/// Default constructor, sets resolution of leafs
OccupancyOcTreeBase(double resolution);
virtual ~OccupancyOcTreeBase();
/// Copy constructor
OccupancyOcTreeBase(const OccupancyOcTreeBase<NODE>& rhs);
/**
* Integrate a Pointcloud (in global reference frame), parallelized with OpenMP.
* Special care is taken that each voxel
* in the map is updated only once, and occupied nodes have a preference over free ones.
* This avoids holes in the floor from mutual deletion and is more efficient than the plain
* ray insertion in insertPointCloudRays().
*
* @note replaces insertScan()
*
* @param scan Pointcloud (measurement endpoints), in global reference frame
* @param sensor_origin measurement origin in global reference frame
* @param maxrange maximum range for how long individual beams are inserted (default -1: complete beam)
* @param lazy_eval whether update of inner nodes is omitted after the update (default: false).
* This speeds up the insertion, but you need to call updateInnerOccupancy() when done.
* @param discretize whether the scan is discretized first into octree key cells (default: false).
* This reduces the number of raycasts using computeDiscreteUpdate(), resulting in a potential speedup.*
*/
virtual void insertPointCloud(const Pointcloud& scan, const octomap::point3d& sensor_origin,
double maxrange=-1., bool lazy_eval = false, bool discretize = false);
/**
* Integrate a 3d scan (transform scan before tree update), parallelized with OpenMP.
* Special care is taken that each voxel
* in the map is updated only once, and occupied nodes have a preference over free ones.
* This avoids holes in the floor from mutual deletion and is more efficient than the plain
* ray insertion in insertPointCloudRays().
*
* @note replaces insertScan()
*
* @param scan Pointcloud (measurement endpoints) relative to frame origin
* @param sensor_origin origin of sensor relative to frame origin
* @param frame_origin origin of reference frame, determines transform to be applied to cloud and sensor origin
* @param maxrange maximum range for how long individual beams are inserted (default -1: complete beam)
* @param lazy_eval whether update of inner nodes is omitted after the update (default: false).
* This speeds up the insertion, but you need to call updateInnerOccupancy() when done.
* @param discretize whether the scan is discretized first into octree key cells (default: false).
* This reduces the number of raycasts using computeDiscreteUpdate(), resulting in a potential speedup.*
*/
virtual void insertPointCloud(const Pointcloud& scan, const point3d& sensor_origin, const pose6d& frame_origin,
double maxrange=-1., bool lazy_eval = false, bool discretize = false);
/**
* Insert a 3d scan (given as a ScanNode) into the tree, parallelized with OpenMP.
*
* @note replaces insertScan
*
* @param scan ScanNode contains Pointcloud data and frame/sensor origin
* @param maxrange maximum range for how long individual beams are inserted (default -1: complete beam)
* @param lazy_eval whether the tree is left 'dirty' after the update (default: false).
* This speeds up the insertion by not updating inner nodes, but you need to call updateInnerOccupancy() when done.
* @param discretize whether the scan is discretized first into octree key cells (default: false).
* This reduces the number of raycasts using computeDiscreteUpdate(), resulting in a potential speedup.
*/
virtual void insertPointCloud(const ScanNode& scan, double maxrange=-1., bool lazy_eval = false, bool discretize = false);
/**
* Integrate a Pointcloud (in global reference frame), parallelized with OpenMP.
* This function simply inserts all rays of the point clouds as batch operation.
* Discretization effects can lead to the deletion of occupied space, it is
* usually recommended to use insertPointCloud() instead.
*
* @param scan Pointcloud (measurement endpoints), in global reference frame
* @param sensor_origin measurement origin in global reference frame
* @param maxrange maximum range for how long individual beams are inserted (default -1: complete beam)
* @param lazy_eval whether update of inner nodes is omitted after the update (default: false).
* This speeds up the insertion, but you need to call updateInnerOccupancy() when done.
*/
virtual void insertPointCloudRays(const Pointcloud& scan, const point3d& sensor_origin, double maxrange = -1., bool lazy_eval = false);
/**
* Set log_odds value of voxel to log_odds_value. This only works if key is at the lowest
* octree level
*
* @param key OcTreeKey of the NODE that is to be updated
* @param log_odds_value value to be set as the log_odds value of the node
* @param lazy_eval whether update of inner nodes is omitted after the update (default: false).
* This speeds up the insertion, but you need to call updateInnerOccupancy() when done.
* @return pointer to the updated NODE
*/
virtual NODE* setNodeValue(const OcTreeKey& key, float log_odds_value, bool lazy_eval = false);
/**
* Set log_odds value of voxel to log_odds_value.
* Looks up the OcTreeKey corresponding to the coordinate and then calls setNodeValue() with it.
*
* @param value 3d coordinate of the NODE that is to be updated
* @param log_odds_value value to be set as the log_odds value of the node
* @param lazy_eval whether update of inner nodes is omitted after the update (default: false).
* This speeds up the insertion, but you need to call updateInnerOccupancy() when done.
* @return pointer to the updated NODE
*/
virtual NODE* setNodeValue(const point3d& value, float log_odds_value, bool lazy_eval = false);
/**
* Set log_odds value of voxel to log_odds_value.
* Looks up the OcTreeKey corresponding to the coordinate and then calls setNodeValue() with it.
*
* @param x
* @param y
* @param z
* @param log_odds_value value to be set as the log_odds value of the node
* @param lazy_eval whether update of inner nodes is omitted after the update (default: false).
* This speeds up the insertion, but you need to call updateInnerOccupancy() when done.
* @return pointer to the updated NODE
*/
virtual NODE* setNodeValue(double x, double y, double z, float log_odds_value, bool lazy_eval = false);
/**
* Manipulate log_odds value of a voxel by changing it by log_odds_update (relative).
* This only works if key is at the lowest octree level
*
* @param key OcTreeKey of the NODE that is to be updated
* @param log_odds_update value to be added (+) to log_odds value of node
* @param lazy_eval whether update of inner nodes is omitted after the update (default: false).
* This speeds up the insertion, but you need to call updateInnerOccupancy() when done.
* @return pointer to the updated NODE
*/
virtual NODE* updateNode(const OcTreeKey& key, float log_odds_update, bool lazy_eval = false);
/**
* Manipulate log_odds value of a voxel by changing it by log_odds_update (relative).
* Looks up the OcTreeKey corresponding to the coordinate and then calls updateNode() with it.
*
* @param value 3d coordinate of the NODE that is to be updated
* @param log_odds_update value to be added (+) to log_odds value of node
* @param lazy_eval whether update of inner nodes is omitted after the update (default: false).
* This speeds up the insertion, but you need to call updateInnerOccupancy() when done.
* @return pointer to the updated NODE
*/
virtual NODE* updateNode(const point3d& value, float log_odds_update, bool lazy_eval = false);
/**
* Manipulate log_odds value of a voxel by changing it by log_odds_update (relative).
* Looks up the OcTreeKey corresponding to the coordinate and then calls updateNode() with it.
*
* @param x
* @param y
* @param z
* @param log_odds_update value to be added (+) to log_odds value of node
* @param lazy_eval whether update of inner nodes is omitted after the update (default: false).
* This speeds up the insertion, but you need to call updateInnerOccupancy() when done.
* @return pointer to the updated NODE
*/
virtual NODE* updateNode(double x, double y, double z, float log_odds_update, bool lazy_eval = false);
/**
* Integrate occupancy measurement.
*
* @param key OcTreeKey of the NODE that is to be updated
* @param occupied true if the node was measured occupied, else false
* @param lazy_eval whether update of inner nodes is omitted after the update (default: false).
* This speeds up the insertion, but you need to call updateInnerOccupancy() when done.
* @return pointer to the updated NODE
*/
virtual NODE* updateNode(const OcTreeKey& key, bool occupied, bool lazy_eval = false);
/**
* Integrate occupancy measurement.
* Looks up the OcTreeKey corresponding to the coordinate and then calls udpateNode() with it.
*
* @param value 3d coordinate of the NODE that is to be updated
* @param occupied true if the node was measured occupied, else false
* @param lazy_eval whether update of inner nodes is omitted after the update (default: false).
* This speeds up the insertion, but you need to call updateInnerOccupancy() when done.
* @return pointer to the updated NODE
*/
virtual NODE* updateNode(const point3d& value, bool occupied, bool lazy_eval = false);
/**
* Integrate occupancy measurement.
* Looks up the OcTreeKey corresponding to the coordinate and then calls udpateNode() with it.
*
* @param x
* @param y
* @param z
* @param occupied true if the node was measured occupied, else false
* @param lazy_eval whether update of inner nodes is omitted after the update (default: false).
* This speeds up the insertion, but you need to call updateInnerOccupancy() when done.
* @return pointer to the updated NODE
*/
virtual NODE* updateNode(double x, double y, double z, bool occupied, bool lazy_eval = false);
/**
* Creates the maximum likelihood map by calling toMaxLikelihood on all
* tree nodes, setting their occupancy to the corresponding occupancy thresholds.
* This enables a very efficient compression if you call prune() afterwards.
*/
virtual void toMaxLikelihood();
/**
* Insert one ray between origin and end into the tree.
* integrateMissOnRay() is called for the ray, the end point is updated as occupied.
* It is usually more efficient to insert complete pointcloudsm with insertPointCloud() or
* insertPointCloudRays().
*
* @param origin origin of sensor in global coordinates
* @param end endpoint of measurement in global coordinates
* @param maxrange maximum range after which the raycast should be aborted
* @param lazy_eval whether update of inner nodes is omitted after the update (default: false).
* This speeds up the insertion, but you need to call updateInnerOccupancy() when done.
* @return success of operation
*/
virtual bool insertRay(const point3d& origin, const point3d& end, double maxrange=-1.0, bool lazy_eval = false);
/**
* Performs raycasting in 3d, similar to computeRay(). Can be called in parallel e.g. with OpenMP
* for a speedup.
*
* A ray is cast from 'origin' with a given direction, the first non-free
* cell is returned in 'end' (as center coordinate). This could also be the
* origin node if it is occupied or unknown. castRay() returns true if an occupied node
* was hit by the raycast. If the raycast returns false you can search() the node at 'end' and
* see whether it's unknown space.
*
*
* @param[in] origin starting coordinate of ray
* @param[in] direction A vector pointing in the direction of the raycast (NOT a point in space). Does not need to be normalized.
* @param[out] end returns the center of the last cell on the ray. If the function returns true, it is occupied.
* @param[in] ignoreUnknownCells whether unknown cells are ignored (= treated as free). If false (default), the raycast aborts when an unknown cell is hit and returns false.
* @param[in] maxRange Maximum range after which the raycast is aborted (<= 0: no limit, default)
* @return true if an occupied cell was hit, false if the maximum range or octree bounds are reached, or if an unknown node was hit.
*/
virtual bool castRay(const point3d& origin, const point3d& direction, point3d& end,
bool ignoreUnknownCells=false, double maxRange=-1.0) const;
/**
* Retrieves the entry point of a ray into a voxel. This is the closest intersection point of the ray
* originating from origin and a plane of the axis aligned cube.
*
* @param[in] origin Starting point of ray
* @param[in] direction A vector pointing in the direction of the raycast. Does not need to be normalized.
* @param[in] center The center of the voxel where the ray terminated. This is the output of castRay.
* @param[out] intersection The entry point of the ray into the voxel, on the voxel surface.
* @param[in] delta A small increment to avoid ambiguity of beeing exactly on a voxel surface. A positive value will get the point out of the hit voxel, while a negative valuewill get it inside.
* @return Whether or not an intesection point has been found. Either, the ray never cross the voxel or the ray is exactly parallel to the only surface it intersect.
*/
virtual bool getRayIntersection(const point3d& origin, const point3d& direction, const point3d& center,
point3d& intersection, double delta=0.0) const;
/**
* Performs a step of the marching cubes surface reconstruction algorithm
* to retrieve the normal of the triangles that fall in the cube
* formed by the voxels located at the vertex of a given voxel.
*
* @param[in] point voxel for which retrieve the normals
* @param[out] normals normals of the triangles
* @param[in] unknownStatus consider unknown cells as free (false) or occupied (default, true).
* @return True if the input voxel is known in the occupancy grid, and false if it is unknown.
*/
bool getNormals(const point3d& point, std::vector<point3d>& normals, bool unknownStatus=true) const;
//-- set BBX limit (limits tree updates to this bounding box)
/// use or ignore BBX limit (default: ignore)
void useBBXLimit(bool enable) { use_bbx_limit = enable; }
bool bbxSet() const { return use_bbx_limit; }
/// sets the minimum for a query bounding box to use
void setBBXMin (const point3d& min);
/// sets the maximum for a query bounding box to use
void setBBXMax (const point3d& max);
/// @return the currently set minimum for bounding box queries, if set
point3d getBBXMin () const { return bbx_min; }
/// @return the currently set maximum for bounding box queries, if set
point3d getBBXMax () const { return bbx_max; }
point3d getBBXBounds () const;
point3d getBBXCenter () const;
/// @return true if point is in the currently set bounding box
bool inBBX(const point3d& p) const;
/// @return true if key is in the currently set bounding box
bool inBBX(const OcTreeKey& key) const;
//-- change detection on occupancy:
/// track or ignore changes while inserting scans (default: ignore)
void enableChangeDetection(bool enable) { use_change_detection = enable; }
bool isChangeDetectionEnabled() const { return use_change_detection; }
/// Reset the set of changed keys. Call this after you obtained all changed nodes.
void resetChangeDetection() { changed_keys.clear(); }
/**
* Iterator to traverse all keys of changed nodes.
* you need to enableChangeDetection() first. Here, an OcTreeKey always
* refers to a node at the lowest tree level (its size is the minimum tree resolution)
*/
KeyBoolMap::const_iterator changedKeysBegin() const {return changed_keys.begin();}
/// Iterator to traverse all keys of changed nodes.
KeyBoolMap::const_iterator changedKeysEnd() const {return changed_keys.end();}
/// Number of changes since last reset.
size_t numChangesDetected() const { return changed_keys.size(); }
/**
* Helper for insertPointCloud(). Computes all octree nodes affected by the point cloud
* integration at once. Here, occupied nodes have a preference over free
* ones.
*
* @param scan point cloud measurement to be integrated
* @param origin origin of the sensor for ray casting
* @param free_cells keys of nodes to be cleared
* @param occupied_cells keys of nodes to be marked occupied
* @param maxrange maximum range for raycasting (-1: unlimited)
*/
void computeUpdate(const Pointcloud& scan, const octomap::point3d& origin,
KeySet& free_cells,
KeySet& occupied_cells,
double maxrange);
/**
* Helper for insertPointCloud(). Computes all octree nodes affected by the point cloud
* integration at once. Here, occupied nodes have a preference over free
* ones. This function first discretizes the scan with the octree grid, which results
* in fewer raycasts (=speedup) but a slightly different result than computeUpdate().
*
* @param scan point cloud measurement to be integrated
* @param origin origin of the sensor for ray casting
* @param free_cells keys of nodes to be cleared
* @param occupied_cells keys of nodes to be marked occupied
* @param maxrange maximum range for raycasting (-1: unlimited)
*/
void computeDiscreteUpdate(const Pointcloud& scan, const octomap::point3d& origin,
KeySet& free_cells,
KeySet& occupied_cells,
double maxrange);
// -- I/O -----------------------------------------
/**
* Reads only the data (=complete tree structure) from the input stream.
* The tree needs to be constructed with the proper header information
* beforehand, see readBinary().
*/
std::istream& readBinaryData(std::istream &s);
/**
* Read node from binary stream (max-likelihood value), recursively
* continue with all children.
*
* This will set the log_odds_occupancy value of
* all leaves to either free or occupied.
*/
std::istream& readBinaryNode(std::istream &s, NODE* node);
/**
* Write node to binary stream (max-likelihood value),
* recursively continue with all children.
*
* This will discard the log_odds_occupancy value, writing
* all leaves as either free or occupied.
*
* @param s
* @param node OcTreeNode to write out, will recurse to all children
* @return
*/
std::ostream& writeBinaryNode(std::ostream &s, const NODE* node) const;
/**
* Writes the data of the tree (without header) to the stream, recursively
* calling writeBinaryNode (starting with root)
*/
std::ostream& writeBinaryData(std::ostream &s) const;
/**
* Updates the occupancy of all inner nodes to reflect their children's occupancy.
* If you performed batch-updates with lazy evaluation enabled, you must call this
* before any queries to ensure correct multi-resolution behavior.
**/
void updateInnerOccupancy();
/// integrate a "hit" measurement according to the tree's sensor model
virtual void integrateHit(NODE* occupancyNode) const;
/// integrate a "miss" measurement according to the tree's sensor model
virtual void integrateMiss(NODE* occupancyNode) const;
/// update logodds value of node by adding to the current value.
virtual void updateNodeLogOdds(NODE* occupancyNode, const float& update) const;
/// converts the node to the maximum likelihood value according to the tree's parameter for "occupancy"
virtual void nodeToMaxLikelihood(NODE* occupancyNode) const;
/// converts the node to the maximum likelihood value according to the tree's parameter for "occupancy"
virtual void nodeToMaxLikelihood(NODE& occupancyNode) const;
protected:
/// Constructor to enable derived classes to change tree constants.
/// This usually requires a re-implementation of some core tree-traversal functions as well!
OccupancyOcTreeBase(double resolution, unsigned int tree_depth, unsigned int tree_max_val);
/**
* Traces a ray from origin to end and updates all voxels on the
* way as free. The volume containing "end" is not updated.
*/
inline bool integrateMissOnRay(const point3d& origin, const point3d& end, bool lazy_eval = false);
// recursive calls ----------------------------
NODE* updateNodeRecurs(NODE* node, bool node_just_created, const OcTreeKey& key,
unsigned int depth, const float& log_odds_update, bool lazy_eval = false);
NODE* setNodeValueRecurs(NODE* node, bool node_just_created, const OcTreeKey& key,
unsigned int depth, const float& log_odds_value, bool lazy_eval = false);
void updateInnerOccupancyRecurs(NODE* node, unsigned int depth);
void toMaxLikelihoodRecurs(NODE* node, unsigned int depth, unsigned int max_depth);
protected:
bool use_bbx_limit; ///< use bounding box for queries (needs to be set)?
point3d bbx_min;
point3d bbx_max;
OcTreeKey bbx_min_key;
OcTreeKey bbx_max_key;
bool use_change_detection;
/// Set of leaf keys (lowest level) which changed since last resetChangeDetection
KeyBoolMap changed_keys;
};
} // namespace
#include "octomap/OccupancyOcTreeBase.hxx"
#endif
| 25,146 | 48.404715 | 198 | h |
octomap | octomap-master/octomap/include/octomap/OccupancyOcTreeBase.hxx | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <bitset>
#include <algorithm>
#include <octomap/MCTables.h>
namespace octomap {
template <class NODE>
OccupancyOcTreeBase<NODE>::OccupancyOcTreeBase(double in_resolution)
: OcTreeBaseImpl<NODE,AbstractOccupancyOcTree>(in_resolution), use_bbx_limit(false), use_change_detection(false)
{
}
template <class NODE>
OccupancyOcTreeBase<NODE>::OccupancyOcTreeBase(double in_resolution, unsigned int in_tree_depth, unsigned int in_tree_max_val)
: OcTreeBaseImpl<NODE,AbstractOccupancyOcTree>(in_resolution, in_tree_depth, in_tree_max_val), use_bbx_limit(false), use_change_detection(false)
{
}
template <class NODE>
OccupancyOcTreeBase<NODE>::~OccupancyOcTreeBase(){
}
template <class NODE>
OccupancyOcTreeBase<NODE>::OccupancyOcTreeBase(const OccupancyOcTreeBase<NODE>& rhs) :
OcTreeBaseImpl<NODE,AbstractOccupancyOcTree>(rhs), use_bbx_limit(rhs.use_bbx_limit),
bbx_min(rhs.bbx_min), bbx_max(rhs.bbx_max),
bbx_min_key(rhs.bbx_min_key), bbx_max_key(rhs.bbx_max_key),
use_change_detection(rhs.use_change_detection), changed_keys(rhs.changed_keys)
{
this->clamping_thres_min = rhs.clamping_thres_min;
this->clamping_thres_max = rhs.clamping_thres_max;
this->prob_hit_log = rhs.prob_hit_log;
this->prob_miss_log = rhs.prob_miss_log;
this->occ_prob_thres_log = rhs.occ_prob_thres_log;
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::insertPointCloud(const ScanNode& scan, double maxrange, bool lazy_eval, bool discretize) {
// performs transformation to data and sensor origin first
Pointcloud& cloud = *(scan.scan);
pose6d frame_origin = scan.pose;
point3d sensor_origin = frame_origin.inv().transform(scan.pose.trans());
insertPointCloud(cloud, sensor_origin, frame_origin, maxrange, lazy_eval, discretize);
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::insertPointCloud(const Pointcloud& scan, const octomap::point3d& sensor_origin,
double maxrange, bool lazy_eval, bool discretize) {
KeySet free_cells, occupied_cells;
if (discretize)
computeDiscreteUpdate(scan, sensor_origin, free_cells, occupied_cells, maxrange);
else
computeUpdate(scan, sensor_origin, free_cells, occupied_cells, maxrange);
// insert data into tree -----------------------
for (KeySet::iterator it = free_cells.begin(); it != free_cells.end(); ++it) {
updateNode(*it, false, lazy_eval);
}
for (KeySet::iterator it = occupied_cells.begin(); it != occupied_cells.end(); ++it) {
updateNode(*it, true, lazy_eval);
}
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::insertPointCloud(const Pointcloud& pc, const point3d& sensor_origin, const pose6d& frame_origin,
double maxrange, bool lazy_eval, bool discretize) {
// performs transformation to data and sensor origin first
Pointcloud transformed_scan (pc);
transformed_scan.transform(frame_origin);
point3d transformed_sensor_origin = frame_origin.transform(sensor_origin);
insertPointCloud(transformed_scan, transformed_sensor_origin, maxrange, lazy_eval, discretize);
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::insertPointCloudRays(const Pointcloud& pc, const point3d& origin, double /* maxrange */, bool lazy_eval) {
if (pc.size() < 1)
return;
#ifdef _OPENMP
omp_set_num_threads(this->keyrays.size());
#pragma omp parallel for
#endif
for (int i = 0; i < (int)pc.size(); ++i) {
const point3d& p = pc[i];
unsigned threadIdx = 0;
#ifdef _OPENMP
threadIdx = omp_get_thread_num();
#endif
KeyRay* keyray = &(this->keyrays.at(threadIdx));
if (this->computeRayKeys(origin, p, *keyray)){
#ifdef _OPENMP
#pragma omp critical
#endif
{
for(KeyRay::iterator it=keyray->begin(); it != keyray->end(); it++) {
updateNode(*it, false, lazy_eval); // insert freespace measurement
}
updateNode(p, true, lazy_eval); // update endpoint to be occupied
}
}
}
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::computeDiscreteUpdate(const Pointcloud& scan, const octomap::point3d& origin,
KeySet& free_cells, KeySet& occupied_cells,
double maxrange)
{
Pointcloud discretePC;
discretePC.reserve(scan.size());
KeySet endpoints;
for (int i = 0; i < (int)scan.size(); ++i) {
OcTreeKey k = this->coordToKey(scan[i]);
std::pair<KeySet::iterator,bool> ret = endpoints.insert(k);
if (ret.second){ // insertion took place => k was not in set
discretePC.push_back(this->keyToCoord(k));
}
}
computeUpdate(discretePC, origin, free_cells, occupied_cells, maxrange);
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::computeUpdate(const Pointcloud& scan, const octomap::point3d& origin,
KeySet& free_cells, KeySet& occupied_cells,
double maxrange)
{
#ifdef _OPENMP
omp_set_num_threads(this->keyrays.size());
#pragma omp parallel for schedule(guided)
#endif
for (int i = 0; i < (int)scan.size(); ++i) {
const point3d& p = scan[i];
unsigned threadIdx = 0;
#ifdef _OPENMP
threadIdx = omp_get_thread_num();
#endif
KeyRay* keyray = &(this->keyrays.at(threadIdx));
if (!use_bbx_limit) { // no BBX specified
if ((maxrange < 0.0) || ((p - origin).norm() <= maxrange) ) { // is not maxrange meas.
// free cells
if (this->computeRayKeys(origin, p, *keyray)){
#ifdef _OPENMP
#pragma omp critical (free_insert)
#endif
{
free_cells.insert(keyray->begin(), keyray->end());
}
}
// occupied endpoint
OcTreeKey key;
if (this->coordToKeyChecked(p, key)){
#ifdef _OPENMP
#pragma omp critical (occupied_insert)
#endif
{
occupied_cells.insert(key);
}
}
} else { // user set a maxrange and length is above
point3d direction = (p - origin).normalized ();
point3d new_end = origin + direction * (float) maxrange;
if (this->computeRayKeys(origin, new_end, *keyray)){
#ifdef _OPENMP
#pragma omp critical (free_insert)
#endif
{
free_cells.insert(keyray->begin(), keyray->end());
}
}
} // end if maxrange
} else { // BBX was set
// endpoint in bbx and not maxrange?
if ( inBBX(p) && ((maxrange < 0.0) || ((p - origin).norm () <= maxrange) ) ) {
// occupied endpoint
OcTreeKey key;
if (this->coordToKeyChecked(p, key)){
#ifdef _OPENMP
#pragma omp critical (occupied_insert)
#endif
{
occupied_cells.insert(key);
}
}
} // end if in BBX and not maxrange
// truncate the end point to the max range if the max range is exceeded
point3d new_end = p;
if ((maxrange >= 0.0) && ((p - origin).norm() > maxrange)) {
const point3d direction = (p - origin).normalized();
new_end = origin + direction * (float) maxrange;
}
// update freespace, break as soon as bbx limit is reached
if (this->computeRayKeys(origin, new_end, *keyray)){
for(KeyRay::iterator it=keyray->begin(); it != keyray->end(); it++) {
if (inBBX(*it)) {
#ifdef _OPENMP
#pragma omp critical (free_insert)
#endif
{
free_cells.insert(*it);
}
}
else break;
}
} // end if compute ray
} // end bbx case
} // end for all points, end of parallel OMP loop
// prefer occupied cells over free ones (and make sets disjunct)
for(KeySet::iterator it = free_cells.begin(), end=free_cells.end(); it!= end; ){
if (occupied_cells.find(*it) != occupied_cells.end()){
it = free_cells.erase(it);
} else {
++it;
}
}
}
template <class NODE>
NODE* OccupancyOcTreeBase<NODE>::setNodeValue(const OcTreeKey& key, float log_odds_value, bool lazy_eval) {
// clamp log odds within range:
log_odds_value = std::min(std::max(log_odds_value, this->clamping_thres_min), this->clamping_thres_max);
bool createdRoot = false;
if (this->root == NULL){
this->root = new NODE();
this->tree_size++;
createdRoot = true;
}
return setNodeValueRecurs(this->root, createdRoot, key, 0, log_odds_value, lazy_eval);
}
template <class NODE>
NODE* OccupancyOcTreeBase<NODE>::setNodeValue(const point3d& value, float log_odds_value, bool lazy_eval) {
OcTreeKey key;
if (!this->coordToKeyChecked(value, key))
return NULL;
return setNodeValue(key, log_odds_value, lazy_eval);
}
template <class NODE>
NODE* OccupancyOcTreeBase<NODE>::setNodeValue(double x, double y, double z, float log_odds_value, bool lazy_eval) {
OcTreeKey key;
if (!this->coordToKeyChecked(x, y, z, key))
return NULL;
return setNodeValue(key, log_odds_value, lazy_eval);
}
template <class NODE>
NODE* OccupancyOcTreeBase<NODE>::updateNode(const OcTreeKey& key, float log_odds_update, bool lazy_eval) {
// early abort (no change will happen).
// may cause an overhead in some configuration, but more often helps
NODE* leaf = this->search(key);
// no change: node already at threshold
if (leaf
&& ((log_odds_update >= 0 && leaf->getLogOdds() >= this->clamping_thres_max)
|| ( log_odds_update <= 0 && leaf->getLogOdds() <= this->clamping_thres_min)))
{
return leaf;
}
bool createdRoot = false;
if (this->root == NULL){
this->root = new NODE();
this->tree_size++;
createdRoot = true;
}
return updateNodeRecurs(this->root, createdRoot, key, 0, log_odds_update, lazy_eval);
}
template <class NODE>
NODE* OccupancyOcTreeBase<NODE>::updateNode(const point3d& value, float log_odds_update, bool lazy_eval) {
OcTreeKey key;
if (!this->coordToKeyChecked(value, key))
return NULL;
return updateNode(key, log_odds_update, lazy_eval);
}
template <class NODE>
NODE* OccupancyOcTreeBase<NODE>::updateNode(double x, double y, double z, float log_odds_update, bool lazy_eval) {
OcTreeKey key;
if (!this->coordToKeyChecked(x, y, z, key))
return NULL;
return updateNode(key, log_odds_update, lazy_eval);
}
template <class NODE>
NODE* OccupancyOcTreeBase<NODE>::updateNode(const OcTreeKey& key, bool occupied, bool lazy_eval) {
float logOdds = this->prob_miss_log;
if (occupied)
logOdds = this->prob_hit_log;
return updateNode(key, logOdds, lazy_eval);
}
template <class NODE>
NODE* OccupancyOcTreeBase<NODE>::updateNode(const point3d& value, bool occupied, bool lazy_eval) {
OcTreeKey key;
if (!this->coordToKeyChecked(value, key))
return NULL;
return updateNode(key, occupied, lazy_eval);
}
template <class NODE>
NODE* OccupancyOcTreeBase<NODE>::updateNode(double x, double y, double z, bool occupied, bool lazy_eval) {
OcTreeKey key;
if (!this->coordToKeyChecked(x, y, z, key))
return NULL;
return updateNode(key, occupied, lazy_eval);
}
template <class NODE>
NODE* OccupancyOcTreeBase<NODE>::updateNodeRecurs(NODE* node, bool node_just_created, const OcTreeKey& key,
unsigned int depth, const float& log_odds_update, bool lazy_eval) {
bool created_node = false;
assert(node);
// follow down to last level
if (depth < this->tree_depth) {
unsigned int pos = computeChildIdx(key, this->tree_depth -1 - depth);
if (!this->nodeChildExists(node, pos)) {
// child does not exist, but maybe it's a pruned node?
if (!this->nodeHasChildren(node) && !node_just_created ) {
// current node does not have children AND it is not a new node
// -> expand pruned node
this->expandNode(node);
}
else {
// not a pruned node, create requested child
this->createNodeChild(node, pos);
created_node = true;
}
}
if (lazy_eval)
return updateNodeRecurs(this->getNodeChild(node, pos), created_node, key, depth+1, log_odds_update, lazy_eval);
else {
NODE* retval = updateNodeRecurs(this->getNodeChild(node, pos), created_node, key, depth+1, log_odds_update, lazy_eval);
// prune node if possible, otherwise set own probability
// note: combining both did not lead to a speedup!
if (this->pruneNode(node)){
// return pointer to current parent (pruned), the just updated node no longer exists
retval = node;
} else{
node->updateOccupancyChildren();
}
return retval;
}
}
// at last level, update node, end of recursion
else {
if (use_change_detection) {
bool occBefore = this->isNodeOccupied(node);
updateNodeLogOdds(node, log_odds_update);
if (node_just_created){ // new node
changed_keys.insert(std::pair<OcTreeKey,bool>(key, true));
} else if (occBefore != this->isNodeOccupied(node)) { // occupancy changed, track it
KeyBoolMap::iterator it = changed_keys.find(key);
if (it == changed_keys.end())
changed_keys.insert(std::pair<OcTreeKey,bool>(key, false));
else if (it->second == false)
changed_keys.erase(it);
}
} else {
updateNodeLogOdds(node, log_odds_update);
}
return node;
}
}
// TODO: mostly copy of updateNodeRecurs => merge code or general tree modifier / traversal
template <class NODE>
NODE* OccupancyOcTreeBase<NODE>::setNodeValueRecurs(NODE* node, bool node_just_created, const OcTreeKey& key,
unsigned int depth, const float& log_odds_value, bool lazy_eval) {
bool created_node = false;
assert(node);
// follow down to last level
if (depth < this->tree_depth) {
unsigned int pos = computeChildIdx(key, this->tree_depth -1 - depth);
if (!this->nodeChildExists(node, pos)) {
// child does not exist, but maybe it's a pruned node?
if (!this->nodeHasChildren(node) && !node_just_created ) {
// current node does not have children AND it is not a new node
// -> expand pruned node
this->expandNode(node);
}
else {
// not a pruned node, create requested child
this->createNodeChild(node, pos);
created_node = true;
}
}
if (lazy_eval)
return setNodeValueRecurs(this->getNodeChild(node, pos), created_node, key, depth+1, log_odds_value, lazy_eval);
else {
NODE* retval = setNodeValueRecurs(this->getNodeChild(node, pos), created_node, key, depth+1, log_odds_value, lazy_eval);
// prune node if possible, otherwise set own probability
// note: combining both did not lead to a speedup!
if (this->pruneNode(node)){
// return pointer to current parent (pruned), the just updated node no longer exists
retval = node;
} else{
node->updateOccupancyChildren();
}
return retval;
}
}
// at last level, update node, end of recursion
else {
if (use_change_detection) {
bool occBefore = this->isNodeOccupied(node);
node->setLogOdds(log_odds_value);
if (node_just_created){ // new node
changed_keys.insert(std::pair<OcTreeKey,bool>(key, true));
} else if (occBefore != this->isNodeOccupied(node)) { // occupancy changed, track it
KeyBoolMap::iterator it = changed_keys.find(key);
if (it == changed_keys.end())
changed_keys.insert(std::pair<OcTreeKey,bool>(key, false));
else if (it->second == false)
changed_keys.erase(it);
}
} else {
node->setLogOdds(log_odds_value);
}
return node;
}
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::updateInnerOccupancy(){
if (this->root)
this->updateInnerOccupancyRecurs(this->root, 0);
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::updateInnerOccupancyRecurs(NODE* node, unsigned int depth){
assert(node);
// only recurse and update for inner nodes:
if (this->nodeHasChildren(node)){
// return early for last level:
if (depth < this->tree_depth){
for (unsigned int i=0; i<8; i++) {
if (this->nodeChildExists(node, i)) {
updateInnerOccupancyRecurs(this->getNodeChild(node, i), depth+1);
}
}
}
node->updateOccupancyChildren();
}
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::toMaxLikelihood() {
if (this->root == NULL)
return;
// convert bottom up
for (unsigned int depth=this->tree_depth; depth>0; depth--) {
toMaxLikelihoodRecurs(this->root, 0, depth);
}
// convert root
nodeToMaxLikelihood(this->root);
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::toMaxLikelihoodRecurs(NODE* node, unsigned int depth,
unsigned int max_depth) {
assert(node);
if (depth < max_depth) {
for (unsigned int i=0; i<8; i++) {
if (this->nodeChildExists(node, i)) {
toMaxLikelihoodRecurs(this->getNodeChild(node, i), depth+1, max_depth);
}
}
}
else { // max level reached
nodeToMaxLikelihood(node);
}
}
template <class NODE>
bool OccupancyOcTreeBase<NODE>::getNormals(const point3d& point, std::vector<point3d>& normals,
bool unknownStatus) const {
normals.clear();
OcTreeKey init_key;
if ( !OcTreeBaseImpl<NODE,AbstractOccupancyOcTree>::coordToKeyChecked(point, init_key) ) {
OCTOMAP_WARNING_STR("Voxel out of bounds");
return false;
}
// OCTOMAP_WARNING("Normal for %f, %f, %f\n", point.x(), point.y(), point.z());
int vertex_values[8];
OcTreeKey current_key;
NODE* current_node;
// There is 8 neighbouring sets
// The current cube can be at any of the 8 vertex
int x_index[4][4] = {{1, 1, 0, 0}, {1, 1, 0, 0}, {0, 0 -1, -1}, {0, 0 -1, -1}};
int y_index[4][4] = {{1, 0, 0, 1}, {0, -1, -1, 0}, {0, -1, -1, 0}, {1, 0, 0, 1}};
int z_index[2][2] = {{0, 1}, {-1, 0}};
// Iterate over the 8 neighboring sets
for(int m = 0; m < 2; ++m){
for(int l = 0; l < 4; ++l){
int k = 0;
// Iterate over the cubes
for(int j = 0; j < 2; ++j){
for(int i = 0; i < 4; ++i){
current_key[0] = init_key[0] + x_index[l][i];
current_key[1] = init_key[1] + y_index[l][i];
current_key[2] = init_key[2] + z_index[m][j];
current_node = this->search(current_key);
if(current_node){
vertex_values[k] = this->isNodeOccupied(current_node);
// point3d coord = this->keyToCoord(current_key);
// OCTOMAP_WARNING_STR("vertex " << k << " at " << coord << "; value " << vertex_values[k]);
}else{
// Occupancy of unknown cells
vertex_values[k] = unknownStatus;
}
++k;
}
}
int cube_index = 0;
if (vertex_values[0]) cube_index |= 1;
if (vertex_values[1]) cube_index |= 2;
if (vertex_values[2]) cube_index |= 4;
if (vertex_values[3]) cube_index |= 8;
if (vertex_values[4]) cube_index |= 16;
if (vertex_values[5]) cube_index |= 32;
if (vertex_values[6]) cube_index |= 64;
if (vertex_values[7]) cube_index |= 128;
// OCTOMAP_WARNING_STR("cubde_index: " << cube_index);
// All vertices are occupied or free resulting in no normal
if (edgeTable[cube_index] == 0)
return true;
// No interpolation is done yet, we use vertexList in <MCTables.h>.
for(int i = 0; triTable[cube_index][i] != -1; i += 3){
point3d p1 = vertexList[triTable[cube_index][i ]];
point3d p2 = vertexList[triTable[cube_index][i+1]];
point3d p3 = vertexList[triTable[cube_index][i+2]];
point3d v1 = p2 - p1;
point3d v2 = p3 - p1;
// OCTOMAP_WARNING("Vertex p1 %f, %f, %f\n", p1.x(), p1.y(), p1.z());
// OCTOMAP_WARNING("Vertex p2 %f, %f, %f\n", p2.x(), p2.y(), p2.z());
// OCTOMAP_WARNING("Vertex p3 %f, %f, %f\n", p3.x(), p3.y(), p3.z());
// Right hand side cross product to retrieve the normal in the good
// direction (pointing to the free nodes).
normals.push_back(v1.cross(v2).normalize());
}
}
}
return true;
}
template <class NODE>
bool OccupancyOcTreeBase<NODE>::castRay(const point3d& origin, const point3d& directionP, point3d& end,
bool ignoreUnknown, double maxRange) const {
/// ---------- see OcTreeBase::computeRayKeys -----------
// Initialization phase -------------------------------------------------------
OcTreeKey current_key;
if ( !OcTreeBaseImpl<NODE,AbstractOccupancyOcTree>::coordToKeyChecked(origin, current_key) ) {
OCTOMAP_WARNING_STR("Coordinates out of bounds during ray casting");
return false;
}
NODE* startingNode = this->search(current_key);
if (startingNode){
if (this->isNodeOccupied(startingNode)){
// Occupied node found at origin
// (need to convert from key, since origin does not need to be a voxel center)
end = this->keyToCoord(current_key);
return true;
}
} else if(!ignoreUnknown){
end = this->keyToCoord(current_key);
return false;
}
point3d direction = directionP.normalized();
bool max_range_set = (maxRange > 0.0);
int step[3];
double tMax[3];
double tDelta[3];
for(unsigned int i=0; i < 3; ++i) {
// compute step direction
if (direction(i) > 0.0) step[i] = 1;
else if (direction(i) < 0.0) step[i] = -1;
else step[i] = 0;
// compute tMax, tDelta
if (step[i] != 0) {
// corner point of voxel (in direction of ray)
double voxelBorder = this->keyToCoord(current_key[i]);
voxelBorder += double(step[i] * this->resolution * 0.5);
tMax[i] = ( voxelBorder - origin(i) ) / direction(i);
tDelta[i] = this->resolution / fabs( direction(i) );
}
else {
tMax[i] = std::numeric_limits<double>::max();
tDelta[i] = std::numeric_limits<double>::max();
}
}
if (step[0] == 0 && step[1] == 0 && step[2] == 0){
OCTOMAP_ERROR("Raycasting in direction (0,0,0) is not possible!");
return false;
}
// for speedup:
double maxrange_sq = maxRange *maxRange;
// Incremental phase ---------------------------------------------------------
bool done = false;
while (!done) {
unsigned int dim;
// find minimum tMax:
if (tMax[0] < tMax[1]){
if (tMax[0] < tMax[2]) dim = 0;
else dim = 2;
}
else {
if (tMax[1] < tMax[2]) dim = 1;
else dim = 2;
}
// check for overflow:
if ((step[dim] < 0 && current_key[dim] == 0)
|| (step[dim] > 0 && current_key[dim] == 2* this->tree_max_val-1))
{
OCTOMAP_WARNING("Coordinate hit bounds in dim %d, aborting raycast\n", dim);
// return border point nevertheless:
end = this->keyToCoord(current_key);
return false;
}
// advance in direction "dim"
current_key[dim] += step[dim];
tMax[dim] += tDelta[dim];
// generate world coords from key
end = this->keyToCoord(current_key);
// check for maxrange:
if (max_range_set){
double dist_from_origin_sq(0.0);
for (unsigned int j = 0; j < 3; j++) {
dist_from_origin_sq += ((end(j) - origin(j)) * (end(j) - origin(j)));
}
if (dist_from_origin_sq > maxrange_sq)
return false;
}
NODE* currentNode = this->search(current_key);
if (currentNode){
if (this->isNodeOccupied(currentNode)) {
done = true;
break;
}
// otherwise: node is free and valid, raycasting continues
} else if (!ignoreUnknown){ // no node found, this usually means we are in "unknown" areas
return false;
}
} // end while
return true;
}
template <class NODE>
bool OccupancyOcTreeBase<NODE>::getRayIntersection (const point3d& origin, const point3d& direction, const point3d& center,
point3d& intersection, double delta/*=0.0*/) const {
// We only need three normals for the six planes
octomap::point3d normalX(1, 0, 0);
octomap::point3d normalY(0, 1, 0);
octomap::point3d normalZ(0, 0, 1);
// One point on each plane, let them be the center for simplicity
octomap::point3d pointXNeg(center(0) - float(this->resolution / 2.0), center(1), center(2));
octomap::point3d pointXPos(center(0) + float(this->resolution / 2.0), center(1), center(2));
octomap::point3d pointYNeg(center(0), center(1) - float(this->resolution / 2.0), center(2));
octomap::point3d pointYPos(center(0), center(1) + float(this->resolution / 2.0), center(2));
octomap::point3d pointZNeg(center(0), center(1), center(2) - float(this->resolution / 2.0));
octomap::point3d pointZPos(center(0), center(1), center(2) + float(this->resolution / 2.0));
double lineDotNormal = 0.0;
double d = 0.0;
double outD = std::numeric_limits<double>::max();
octomap::point3d intersect;
bool found = false;
// Find the intersection (if any) with each place
// Line dot normal will be zero if they are parallel, in which case no intersection can be the entry one
// if there is an intersection does it occur in the bounded plane of the voxel
// if yes keep only the closest (smallest distance to sensor origin).
if((lineDotNormal = normalX.dot(direction)) != 0.0){ // Ensure lineDotNormal is non-zero (assign and test)
d = (pointXNeg - origin).dot(normalX) / lineDotNormal;
intersect = direction * float(d) + origin;
if(!(intersect(1) < (pointYNeg(1) - 1e-6) || intersect(1) > (pointYPos(1) + 1e-6) ||
intersect(2) < (pointZNeg(2) - 1e-6) || intersect(2) > (pointZPos(2) + 1e-6))){
outD = std::min(outD, d);
found = true;
}
d = (pointXPos - origin).dot(normalX) / lineDotNormal;
intersect = direction * float(d) + origin;
if(!(intersect(1) < (pointYNeg(1) - 1e-6) || intersect(1) > (pointYPos(1) + 1e-6) ||
intersect(2) < (pointZNeg(2) - 1e-6) || intersect(2) > (pointZPos(2) + 1e-6))){
outD = std::min(outD, d);
found = true;
}
}
if((lineDotNormal = normalY.dot(direction)) != 0.0){ // Ensure lineDotNormal is non-zero (assign and test)
d = (pointYNeg - origin).dot(normalY) / lineDotNormal;
intersect = direction * float(d) + origin;
if(!(intersect(0) < (pointXNeg(0) - 1e-6) || intersect(0) > (pointXPos(0) + 1e-6) ||
intersect(2) < (pointZNeg(2) - 1e-6) || intersect(2) > (pointZPos(2) + 1e-6))){
outD = std::min(outD, d);
found = true;
}
d = (pointYPos - origin).dot(normalY) / lineDotNormal;
intersect = direction * float(d) + origin;
if(!(intersect(0) < (pointXNeg(0) - 1e-6) || intersect(0) > (pointXPos(0) + 1e-6) ||
intersect(2) < (pointZNeg(2) - 1e-6) || intersect(2) > (pointZPos(2) + 1e-6))){
outD = std::min(outD, d);
found = true;
}
}
if((lineDotNormal = normalZ.dot(direction)) != 0.0){ // Ensure lineDotNormal is non-zero (assign and test)
d = (pointZNeg - origin).dot(normalZ) / lineDotNormal;
intersect = direction * float(d) + origin;
if(!(intersect(0) < (pointXNeg(0) - 1e-6) || intersect(0) > (pointXPos(0) + 1e-6) ||
intersect(1) < (pointYNeg(1) - 1e-6) || intersect(1) > (pointYPos(1) + 1e-6))){
outD = std::min(outD, d);
found = true;
}
d = (pointZPos - origin).dot(normalZ) / lineDotNormal;
intersect = direction * float(d) + origin;
if(!(intersect(0) < (pointXNeg(0) - 1e-6) || intersect(0) > (pointXPos(0) + 1e-6) ||
intersect(1) < (pointYNeg(1) - 1e-6) || intersect(1) > (pointYPos(1) + 1e-6))){
outD = std::min(outD, d);
found = true;
}
}
// Substract (add) a fraction to ensure no ambiguity on the starting voxel
// Don't start on a boundary.
if(found)
intersection = direction * float(outD + delta) + origin;
return found;
}
template <class NODE> inline bool
OccupancyOcTreeBase<NODE>::integrateMissOnRay(const point3d& origin, const point3d& end, bool lazy_eval) {
if (!this->computeRayKeys(origin, end, this->keyrays.at(0))) {
return false;
}
for(KeyRay::iterator it=this->keyrays[0].begin(); it != this->keyrays[0].end(); it++) {
updateNode(*it, false, lazy_eval); // insert freespace measurement
}
return true;
}
template <class NODE> bool
OccupancyOcTreeBase<NODE>::insertRay(const point3d& origin, const point3d& end, double maxrange, bool lazy_eval)
{
// cut ray at maxrange
if ((maxrange > 0) && ((end - origin).norm () > maxrange))
{
point3d direction = (end - origin).normalized ();
point3d new_end = origin + direction * (float) maxrange;
return integrateMissOnRay(origin, new_end,lazy_eval);
}
// insert complete ray
else
{
if (!integrateMissOnRay(origin, end,lazy_eval))
return false;
updateNode(end, true, lazy_eval); // insert hit cell
return true;
}
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::setBBXMin (const point3d& min) {
bbx_min = min;
if (!this->coordToKeyChecked(bbx_min, bbx_min_key)) {
OCTOMAP_ERROR("ERROR while generating bbx min key.\n");
}
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::setBBXMax (const point3d& max) {
bbx_max = max;
if (!this->coordToKeyChecked(bbx_max, bbx_max_key)) {
OCTOMAP_ERROR("ERROR while generating bbx max key.\n");
}
}
template <class NODE>
bool OccupancyOcTreeBase<NODE>::inBBX(const point3d& p) const {
return ((p.x() >= bbx_min.x()) && (p.y() >= bbx_min.y()) && (p.z() >= bbx_min.z()) &&
(p.x() <= bbx_max.x()) && (p.y() <= bbx_max.y()) && (p.z() <= bbx_max.z()) );
}
template <class NODE>
bool OccupancyOcTreeBase<NODE>::inBBX(const OcTreeKey& key) const {
return ((key[0] >= bbx_min_key[0]) && (key[1] >= bbx_min_key[1]) && (key[2] >= bbx_min_key[2]) &&
(key[0] <= bbx_max_key[0]) && (key[1] <= bbx_max_key[1]) && (key[2] <= bbx_max_key[2]) );
}
template <class NODE>
point3d OccupancyOcTreeBase<NODE>::getBBXBounds () const {
octomap::point3d obj_bounds = (bbx_max - bbx_min);
obj_bounds /= 2.;
return obj_bounds;
}
template <class NODE>
point3d OccupancyOcTreeBase<NODE>::getBBXCenter () const {
octomap::point3d obj_bounds = (bbx_max - bbx_min);
obj_bounds /= 2.;
return bbx_min + obj_bounds;
}
// -- I/O -----------------------------------------
template <class NODE>
std::istream& OccupancyOcTreeBase<NODE>::readBinaryData(std::istream &s){
// tree needs to be newly created or cleared externally
if (this->root) {
OCTOMAP_ERROR_STR("Trying to read into an existing tree.");
return s;
}
this->root = new NODE();
this->readBinaryNode(s, this->root);
this->size_changed = true;
this->tree_size = OcTreeBaseImpl<NODE,AbstractOccupancyOcTree>::calcNumNodes(); // compute number of nodes
return s;
}
template <class NODE>
std::ostream& OccupancyOcTreeBase<NODE>::writeBinaryData(std::ostream &s) const{
OCTOMAP_DEBUG("Writing %zu nodes to output stream...", this->size());
if (this->root)
this->writeBinaryNode(s, this->root);
return s;
}
template <class NODE>
std::istream& OccupancyOcTreeBase<NODE>::readBinaryNode(std::istream &s, NODE* node){
assert(node);
char child1to4_char;
char child5to8_char;
s.read((char*)&child1to4_char, sizeof(char));
s.read((char*)&child5to8_char, sizeof(char));
std::bitset<8> child1to4 ((unsigned long long) child1to4_char);
std::bitset<8> child5to8 ((unsigned long long) child5to8_char);
// std::cout << "read: "
// << child1to4.to_string<char,std::char_traits<char>,std::allocator<char> >() << " "
// << child5to8.to_string<char,std::char_traits<char>,std::allocator<char> >() << std::endl;
// inner nodes default to occupied
node->setLogOdds(this->clamping_thres_max);
for (unsigned int i=0; i<4; i++) {
if ((child1to4[i*2] == 1) && (child1to4[i*2+1] == 0)) {
// child is free leaf
this->createNodeChild(node, i);
this->getNodeChild(node, i)->setLogOdds(this->clamping_thres_min);
}
else if ((child1to4[i*2] == 0) && (child1to4[i*2+1] == 1)) {
// child is occupied leaf
this->createNodeChild(node, i);
this->getNodeChild(node, i)->setLogOdds(this->clamping_thres_max);
}
else if ((child1to4[i*2] == 1) && (child1to4[i*2+1] == 1)) {
// child has children
this->createNodeChild(node, i);
this->getNodeChild(node, i)->setLogOdds(-200.); // child is unkown, we leave it uninitialized
}
}
for (unsigned int i=0; i<4; i++) {
if ((child5to8[i*2] == 1) && (child5to8[i*2+1] == 0)) {
// child is free leaf
this->createNodeChild(node, i+4);
this->getNodeChild(node, i+4)->setLogOdds(this->clamping_thres_min);
}
else if ((child5to8[i*2] == 0) && (child5to8[i*2+1] == 1)) {
// child is occupied leaf
this->createNodeChild(node, i+4);
this->getNodeChild(node, i+4)->setLogOdds(this->clamping_thres_max);
}
else if ((child5to8[i*2] == 1) && (child5to8[i*2+1] == 1)) {
// child has children
this->createNodeChild(node, i+4);
this->getNodeChild(node, i+4)->setLogOdds(-200.); // set occupancy when all children have been read
}
// child is unkown, we leave it uninitialized
}
// read children's children and set the label
for (unsigned int i=0; i<8; i++) {
if (this->nodeChildExists(node, i)) {
NODE* child = this->getNodeChild(node, i);
if (fabs(child->getLogOdds() + 200.)<1e-3) {
readBinaryNode(s, child);
child->setLogOdds(child->getMaxChildLogOdds());
}
} // end if child exists
} // end for children
return s;
}
template <class NODE>
std::ostream& OccupancyOcTreeBase<NODE>::writeBinaryNode(std::ostream &s, const NODE* node) const{
assert(node);
// 2 bits for each children, 8 children per node -> 16 bits
std::bitset<8> child1to4;
std::bitset<8> child5to8;
// 10 : child is free node
// 01 : child is occupied node
// 00 : child is unkown node
// 11 : child has children
// speedup: only set bits to 1, rest is init with 0 anyway,
// can be one logic expression per bit
for (unsigned int i=0; i<4; i++) {
if (this->nodeChildExists(node, i)) {
const NODE* child = this->getNodeChild(node, i);
if (this->nodeHasChildren(child)) { child1to4[i*2] = 1; child1to4[i*2+1] = 1; }
else if (this->isNodeOccupied(child)) { child1to4[i*2] = 0; child1to4[i*2+1] = 1; }
else { child1to4[i*2] = 1; child1to4[i*2+1] = 0; }
}
else {
child1to4[i*2] = 0; child1to4[i*2+1] = 0;
}
}
for (unsigned int i=0; i<4; i++) {
if (this->nodeChildExists(node, i+4)) {
const NODE* child = this->getNodeChild(node, i+4);
if (this->nodeHasChildren(child)) { child5to8[i*2] = 1; child5to8[i*2+1] = 1; }
else if (this->isNodeOccupied(child)) { child5to8[i*2] = 0; child5to8[i*2+1] = 1; }
else { child5to8[i*2] = 1; child5to8[i*2+1] = 0; }
}
else {
child5to8[i*2] = 0; child5to8[i*2+1] = 0;
}
}
// std::cout << "wrote: "
// << child1to4.to_string<char,std::char_traits<char>,std::allocator<char> >() << " "
// << child5to8.to_string<char,std::char_traits<char>,std::allocator<char> >() << std::endl;
char child1to4_char = (char) child1to4.to_ulong();
char child5to8_char = (char) child5to8.to_ulong();
s.write((char*)&child1to4_char, sizeof(char));
s.write((char*)&child5to8_char, sizeof(char));
// write children's children
for (unsigned int i=0; i<8; i++) {
if (this->nodeChildExists(node, i)) {
const NODE* child = this->getNodeChild(node, i);
if (this->nodeHasChildren(child)) {
writeBinaryNode(s, child);
}
}
}
return s;
}
//-- Occupancy queries on nodes:
template <class NODE>
void OccupancyOcTreeBase<NODE>::updateNodeLogOdds(NODE* occupancyNode, const float& update) const {
occupancyNode->addValue(update);
if (occupancyNode->getLogOdds() < this->clamping_thres_min) {
occupancyNode->setLogOdds(this->clamping_thres_min);
return;
}
if (occupancyNode->getLogOdds() > this->clamping_thres_max) {
occupancyNode->setLogOdds(this->clamping_thres_max);
}
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::integrateHit(NODE* occupancyNode) const {
updateNodeLogOdds(occupancyNode, this->prob_hit_log);
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::integrateMiss(NODE* occupancyNode) const {
updateNodeLogOdds(occupancyNode, this->prob_miss_log);
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::nodeToMaxLikelihood(NODE* occupancyNode) const{
if (this->isNodeOccupied(occupancyNode))
occupancyNode->setLogOdds(this->clamping_thres_max);
else
occupancyNode->setLogOdds(this->clamping_thres_min);
}
template <class NODE>
void OccupancyOcTreeBase<NODE>::nodeToMaxLikelihood(NODE& occupancyNode) const{
if (this->isNodeOccupied(occupancyNode))
occupancyNode.setLogOdds(this->clamping_thres_max);
else
occupancyNode.setLogOdds(this->clamping_thres_min);
}
} // namespace
| 40,621 | 34.790308 | 148 | hxx |
octomap | octomap-master/octomap/include/octomap/Pointcloud.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMAP_POINTCLOUD_H
#define OCTOMAP_POINTCLOUD_H
#include <vector>
#include <list>
#include <octomap/octomap_types.h>
namespace octomap {
/**
* A collection of 3D coordinates (point3d), which are regarded as endpoints of a
* 3D laser scan.
*/
class Pointcloud {
public:
Pointcloud();
~Pointcloud();
Pointcloud(const Pointcloud& other);
Pointcloud(Pointcloud* other);
size_t size() const { return points.size(); }
void clear();
inline void reserve(size_t size) {points.reserve(size); }
inline void push_back(float x, float y, float z) {
points.push_back(point3d(x,y,z));
}
inline void push_back(const point3d& p) {
points.push_back(p);
}
inline void push_back(point3d* p) {
points.push_back(*p);
}
/// Add points from other Pointcloud
void push_back(const Pointcloud& other);
/// Export the Pointcloud to a VRML file
void writeVrml(std::string filename);
/// Apply transform to each point
void transform(pose6d transform);
/// Rotate each point in pointcloud
void rotate(double roll, double pitch, double yaw);
/// Apply transform to each point, undo previous transforms
void transformAbsolute(pose6d transform);
/// Calculate bounding box of Pointcloud
void calcBBX(point3d& lowerBound, point3d& upperBound) const;
/// Crop Pointcloud to given bounding box
void crop(point3d lowerBound, point3d upperBound);
// removes any points closer than [thres] to (0,0,0)
void minDist(double thres);
void subSampleRandom(unsigned int num_samples, Pointcloud& sample_cloud);
// iterators ------------------
typedef point3d_collection::iterator iterator;
typedef point3d_collection::const_iterator const_iterator;
iterator begin() { return points.begin(); }
iterator end() { return points.end(); }
const_iterator begin() const { return points.begin(); }
const_iterator end() const { return points.end(); }
point3d back() { return points.back(); }
/// Returns a copy of the ith point in point cloud.
/// Use operator[] for direct access to point reference.
point3d getPoint(unsigned int i) const; // may return NULL
inline const point3d& operator[] (size_t i) const { return points[i]; }
inline point3d& operator[] (size_t i) { return points[i]; }
// I/O methods
std::istream& readBinary(std::istream &s);
std::istream& read(std::istream &s);
std::ostream& writeBinary(std::ostream &s) const;
protected:
pose6d current_inv_transform;
point3d_collection points;
};
}
#endif
| 4,430 | 33.889764 | 83 | h |
octomap | octomap-master/octomap/include/octomap/ScanGraph.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMAP_SCANGRAPH_H
#define OCTOMAP_SCANGRAPH_H
#include <string>
#include <math.h>
#include "Pointcloud.h"
#include "octomap_types.h"
namespace octomap {
class ScanGraph;
/**
* A 3D scan as Pointcloud, performed from a Pose6D.
*/
class ScanNode {
public:
ScanNode (Pointcloud* _scan, pose6d _pose, unsigned int _id)
: scan(_scan), pose(_pose), id(_id) {}
ScanNode ()
: scan(NULL) {}
~ScanNode();
bool operator == (const ScanNode& other) {
return (id == other.id);
}
std::ostream& writeBinary(std::ostream &s) const;
std::istream& readBinary(std::istream &s);
std::ostream& writePoseASCII(std::ostream &s) const;
std::istream& readPoseASCII(std::istream &s);
Pointcloud* scan;
pose6d pose; ///< 6D pose from which the scan was performed
unsigned int id;
};
/**
* A connection between two \ref ScanNode "ScanNodes"
*/
class ScanEdge {
public:
ScanEdge(ScanNode* _first, ScanNode* _second, pose6d _constraint)
: first(_first), second(_second), constraint(_constraint), weight(1.0) { }
ScanEdge() {}
bool operator == (const ScanEdge& other) {
return ( (*first == *(other.first) ) && ( *second == *(other.second) ) );
}
std::ostream& writeBinary(std::ostream &s) const;
// a graph has to be given to recover ScanNode pointers
std::istream& readBinary(std::istream &s, ScanGraph& graph);
std::ostream& writeASCII(std::ostream &s) const;
std::istream& readASCII(std::istream &s, ScanGraph& graph);
ScanNode* first;
ScanNode* second;
pose6d constraint;
double weight;
};
/**
* A ScanGraph is a collection of ScanNodes, connected by ScanEdges.
* Each ScanNode contains a 3D scan performed from a pose.
*
*/
class ScanGraph {
public:
ScanGraph() {};
~ScanGraph();
/// Clears all nodes and edges, and will delete the corresponding objects
void clear();
/**
* Creates a new ScanNode in the graph from a Pointcloud.
*
* @param scan Pointer to a pointcloud to be added to the ScanGraph.
* ScanGraph will delete the object when it's no longer needed, don't delete it yourself.
* @param pose 6D pose of the origin of the Pointcloud
* @return Pointer to the new node
*/
ScanNode* addNode(Pointcloud* scan, pose6d pose);
/**
* Creates an edge between two ScanNodes.
* ScanGraph will delete the object when it's no longer needed, don't delete it yourself.
*
* @param first ScanNode
* @param second ScanNode
* @param constraint 6D transform between the two nodes
* @return
*/
ScanEdge* addEdge(ScanNode* first, ScanNode* second, pose6d constraint);
ScanEdge* addEdge(unsigned int first_id, unsigned int second_id);
/// will return NULL if node was not found
ScanNode* getNodeByID(unsigned int id);
/// \return true when an edge between first_id and second_id exists
bool edgeExists(unsigned int first_id, unsigned int second_id);
/// Connect previously added ScanNode to the one before that
void connectPrevious();
std::vector<unsigned int> getNeighborIDs(unsigned int id);
std::vector<ScanEdge*> getOutEdges(ScanNode* node);
// warning: constraints are reversed
std::vector<ScanEdge*> getInEdges(ScanNode* node);
void exportDot(std::string filename);
/// Transform every scan according to its pose
void transformScans();
/// Cut graph (all containing Pointclouds) to given BBX in global coords
void crop(point3d lowerBound, point3d upperBound);
/// Cut Pointclouds to given BBX in local coords
void cropEachScan(point3d lowerBound, point3d upperBound);
typedef std::vector<ScanNode*>::iterator iterator;
typedef std::vector<ScanNode*>::const_iterator const_iterator;
iterator begin() { return nodes.begin(); }
iterator end() { return nodes.end(); }
const_iterator begin() const { return nodes.begin(); }
const_iterator end() const { return nodes.end(); }
size_t size() const { return nodes.size(); }
size_t getNumPoints(unsigned int max_id = -1) const;
typedef std::vector<ScanEdge*>::iterator edge_iterator;
typedef std::vector<ScanEdge*>::const_iterator const_edge_iterator;
edge_iterator edges_begin() { return edges.begin(); }
edge_iterator edges_end() { return edges.end(); }
const_edge_iterator edges_begin() const { return edges.begin(); }
const_edge_iterator edges_end() const { return edges.end(); }
std::ostream& writeBinary(std::ostream &s) const;
std::istream& readBinary(std::ifstream &s);
bool writeBinary(const std::string& filename) const;
bool readBinary(const std::string& filename);
std::ostream& writeEdgesASCII(std::ostream &s) const;
std::istream& readEdgesASCII(std::istream &s);
std::ostream& writeNodePosesASCII(std::ostream &s) const;
std::istream& readNodePosesASCII(std::istream &s);
/**
* Reads in a ScanGraph from a "plain" ASCII file of the form
* NODE x y z R P Y
* x y z
* x y z
* x y z
* NODE x y z R P Y
* x y z
*
* Lines starting with the NODE keyword contain the 6D pose of a scan node,
* all 3D point following until the next NODE keyword (or end of file) are
* inserted into that scan node as pointcloud in its local coordinate frame
*
* @param s input stream to read from
* @return read stream
*/
std::istream& readPlainASCII(std::istream& s);
void readPlainASCII(const std::string& filename);
protected:
std::vector<ScanNode*> nodes;
std::vector<ScanEdge*> edges;
};
}
#endif
| 7,500 | 31.331897 | 100 | h |
octomap | octomap-master/octomap/include/octomap/octomap.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include "octomap_types.h"
#include "Pointcloud.h"
#include "ScanGraph.h"
#include "OcTree.h"
| 1,875 | 47.102564 | 78 | h |
octomap | octomap-master/octomap/include/octomap/octomap_deprecated.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMAP_DEPRECATED_H
#define OCTOMAP_DEPRECATED_H
// define multi-platform deprecation mechanism
#ifndef OCTOMAP_DEPRECATED
#ifdef __GNUC__
#define OCTOMAP_DEPRECATED(func) func __attribute__ ((deprecated))
#elif defined(_MSC_VER)
#define OCTOMAP_DEPRECATED(func) __declspec(deprecated) func
#else
#pragma message("WARNING: You need to implement OCTOMAP_DEPRECATED for this compiler")
#define OCTOMAP_DEPRECATED(func) func
#endif
#endif
#endif
| 2,258 | 44.18 | 90 | h |
octomap | octomap-master/octomap/include/octomap/octomap_timing.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMAP_TIMING_H_
#define OCTOMAP_TIMING_H_
#ifdef _MSC_VER
// MS compilers
#include <sys/timeb.h>
#include <sys/types.h>
#include <winsock.h>
void gettimeofday(struct timeval* t, void* timezone) {
struct _timeb timebuffer;
_ftime64_s( &timebuffer );
t->tv_sec= (long) timebuffer.time;
t->tv_usec=1000*timebuffer.millitm;
}
#else
// GCC and minGW
#include <sys/time.h>
#endif
#endif
| 2,205 | 39.109091 | 78 | h |
octomap | octomap-master/octomap/include/octomap/octomap_types.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMAP_TYPES_H
#define OCTOMAP_TYPES_H
#include <stdio.h>
#include <vector>
#include <list>
#include <inttypes.h>
#include <octomap/math/Vector3.h>
#include <octomap/math/Pose6D.h>
#include <octomap/octomap_deprecated.h>
namespace octomap {
///Use Vector3 (float precision) as a point3d in octomap
typedef octomath::Vector3 point3d;
/// Use our Pose6D (float precision) as pose6d in octomap
typedef octomath::Pose6D pose6d;
typedef std::vector<octomath::Vector3> point3d_collection;
typedef std::list<octomath::Vector3> point3d_list;
/// A voxel defined by its center point3d and its side length
typedef std::pair<point3d, double> OcTreeVolume;
}
// no debug output if not in debug mode:
#ifdef NDEBUG
#ifndef OCTOMAP_NODEBUGOUT
#define OCTOMAP_NODEBUGOUT
#endif
#endif
#ifdef OCTOMAP_NODEBUGOUT
#define OCTOMAP_DEBUG(...) (void)0
#define OCTOMAP_DEBUG_STR(...) (void)0
#else
#define OCTOMAP_DEBUG(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define OCTOMAP_DEBUG_STR(args) std::cerr << args << std::endl
#endif
#define OCTOMAP_WARNING(...) fprintf(stderr, "WARNING: "), fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define OCTOMAP_WARNING_STR(args) std::cerr << "WARNING: " << args << std::endl
#define OCTOMAP_ERROR(...) fprintf(stderr, "ERROR: "), fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define OCTOMAP_ERROR_STR(args) std::cerr << "ERROR: " << args << std::endl
#endif
| 3,315 | 39.439024 | 110 | h |
octomap | octomap-master/octomap/include/octomap/octomap_utils.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMAP_UTILS_H_
#define OCTOMAP_UTILS_H_
#include <math.h>
namespace octomap{
/// compute log-odds from probability:
inline float logodds(double probability){
return (float) log(probability/(1-probability));
}
/// compute probability from logodds:
inline double probability(double logodds){
return 1. - ( 1. / (1. + exp(logodds)));
}
}
#endif /* OCTOMAP_UTILS_H_ */
| 2,183 | 38 | 78 | h |
octomap | octomap-master/octomap/include/octomap/math/Pose6D.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMATH_POSE6D_H
#define OCTOMATH_POSE6D_H
#include "Vector3.h"
#include "Quaternion.h"
namespace octomath {
/*!
* \brief This class represents a tree-dimensional pose of an object
*
* The tree-dimensional pose is represented by a three-dimensional
* translation vector representing the position of the object and
* a Quaternion representing the attitude of the object
*/
class Pose6D {
public:
Pose6D();
~Pose6D();
/*!
* \brief Constructor
*
* Constructs a pose from given translation and rotation.
*/
Pose6D(const Vector3& trans, const Quaternion& rot);
/*!
* \brief Constructor
*
* Constructs a pose from a translation represented by
* its x, y, z-values and a rotation represented by its
* Tait-Bryan angles roll, pitch, and yaw
*/
Pose6D(float x, float y, float z, double roll, double pitch, double yaw);
Pose6D(const Pose6D& other);
Pose6D& operator= (const Pose6D& other);
bool operator==(const Pose6D& other) const;
bool operator!=(const Pose6D& other) const;
/*!
* \brief Translational component
*
* @return the translational component of this pose
*/
inline Vector3& trans() { return translation; }
/*!
* \brief Rotational component
*
* @return the rotational component of this pose
*/
inline Quaternion& rot() { return rotation; }
/*!
* \brief Translational component
*
* @return the translational component of this pose
*/
const Vector3& trans() const { return translation; }
/*!
* \brief Rotational component
* @return the rotational component of this pose
*/
const Quaternion& rot() const { return rotation; }
inline float& x() { return translation(0); }
inline float& y() { return translation(1); }
inline float& z() { return translation(2); }
inline const float& x() const { return translation(0); }
inline const float& y() const { return translation(1); }
inline const float& z() const { return translation(2); }
inline double roll() const {return (rotation.toEuler())(0); }
inline double pitch() const {return (rotation.toEuler())(1); }
inline double yaw() const {return (rotation.toEuler())(2); }
/*!
* \brief Transformation of a vector
*
* Transforms the vector v by the transformation which is
* specified by this.
* @return the vector which is translated by the translation of
* this and afterwards rotated by the rotation of this.
*/
Vector3 transform (const Vector3 &v) const;
/*!
* \brief Inversion
*
* Inverts the coordinate transformation represented by this pose
* @return a copy of this pose inverted
*/
Pose6D inv() const;
/*!
* \brief Inversion
*
* Inverts the coordinate transformation represented by this pose
* @return a reference to this pose
*/
Pose6D& inv_IP();
/*!
* \brief Concatenation
*
* Concatenates the coordinate transformations represented
* by this and p.
* @return this * p (applies first this, then p)
*/
Pose6D operator* (const Pose6D &p) const;
/*!
* \brief In place concatenation
*
* Concatenates p to this Pose6D.
* @return this which results from first moving by this and
* afterwards by p
*/
const Pose6D& operator*= (const Pose6D &p);
/*!
* \brief Translational distance
*
* @return the translational (euclidian) distance to p
*/
double distance(const Pose6D &other) const;
/*!
* \brief Translational length
*
* @return the translational (euclidian) length of the translation
* vector of this Pose6D
*/
double transLength() const;
/*!
* \brief Output operator
*
* Output to stream in a format which can be parsed using read().
*/
std::ostream& write(std::ostream &s) const;
/*!
* \brief Input operator
*
* Parsing from stream which was written by write().
*/
std::istream& read(std::istream &s);
/*!
* \brief Binary output operator
*
* Output to stream in a binary format which can be parsed using readBinary().
*/
std::ostream& writeBinary(std::ostream &s) const;
/*!
* \brief Binary input operator
*
* Parsing from binary stream which was written by writeBinary().
*/
std::istream& readBinary(std::istream &s);
protected:
Vector3 translation;
Quaternion rotation;
};
//! user friendly output in format (x y z, u x y z) which is (translation, rotation)
std::ostream& operator<<(std::ostream& s, const Pose6D& p);
}
#endif
| 6,525 | 30.52657 | 86 | h |
octomap | octomap-master/octomap/include/octomap/math/Quaternion.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMATH_QUATERNION_H
#define OCTOMATH_QUATERNION_H
#include "Vector3.h"
#include <iostream>
#include <vector>
namespace octomath {
/*!
* \brief This class represents a Quaternion.
*
* The Unit Quaternion is one possible representation of the
* attitude of an object in tree-dimensional space.
*
* This Quaternion class is implemented according to Diebel,
* James. Representing Attitude: Euler Angle, Unit Quaternions, and
* Rotation Vectors. Stanford University. 2006. - Technical Report.
*/
class Quaternion {
public:
/*!
* \brief Default constructor
*
* Constructs the (1,0,0,0) Unit Quaternion
* representing the identity rotation.
*/
inline Quaternion() { u() = 1; x() = 0; y() = 0; z() = 0; }
/*!
* \brief Copy constructor
*/
Quaternion(const Quaternion& other);
/*!
* \brief Constructor
*
* Constructs a Quaternion from four single
* values
*/
Quaternion(float u, float x, float y, float z);
/*!
* \brief Constructor
*
* @param other a vector containing euler angles
*/
Quaternion(const Vector3& other);
/*!
* \brief Constructor from Euler angles
*
* Constructs a Unit Quaternion from Euler angles / Tait Bryan
* angles (in radians) according to the 1-2-3 convention.
* @param roll phi/roll angle (rotation about x-axis)
* @param pitch theta/pitch angle (rotation about y-axis)
* @param yaw psi/yaw angle (rotation about z-axis)
*/
Quaternion(double roll, double pitch, double yaw);
//! Constructs a Unit Quaternion from a rotation angle and axis.
Quaternion(const Vector3& axis, double angle);
/*!
* \brief Conversion to Euler angles
*
* Converts the attitude represented by this to
* Euler angles (roll, pitch, yaw).
*/
Vector3 toEuler() const;
void toRotMatrix(std::vector <double>& rot_matrix_3_3) const;
inline const float& operator() (unsigned int i) const { return data[i]; }
inline float& operator() (unsigned int i) { return data[i]; }
float norm () const;
Quaternion normalized () const;
Quaternion& normalize ();
void operator/= (float x);
Quaternion& operator= (const Quaternion& other);
bool operator== (const Quaternion& other) const;
/*!
* \brief Quaternion multiplication
*
* Standard Quaternion multiplication which is not
* commutative.
* @return this * other
*/
Quaternion operator* (const Quaternion& other) const;
/*!
* \brief Quaternion multiplication with extended vector
*
* @return q * (0, v)
*/
Quaternion operator* (const Vector3 &v) const;
/*!
* \brief Quaternion multiplication with extended vector
*
* @return (0, v) * q
*/
friend Quaternion operator* (const Vector3 &v, const Quaternion &q);
/*!
* \brief Inversion
*
* @return A copy of this Quaterion inverted
*/
inline Quaternion inv() const { return Quaternion(u(), -x(), -y(), -z()); }
/*!
* \brief Inversion
*
* Inverts this Quaternion
* @return a reference to this Quaternion
*/
Quaternion& inv_IP();
/*!
* \brief Rotate a vector
*
* Rotates a vector to the body fixed coordinate
* system according to the attitude represented by
* this Quaternion.
* @param v a vector represented in world coordinates
* @return v represented in body-fixed coordinates
*/
Vector3 rotate(const Vector3 &v) const;
inline float& u() { return data[0]; }
inline float& x() { return data[1]; }
inline float& y() { return data[2]; }
inline float& z() { return data[3]; }
inline const float& u() const { return data[0]; }
inline const float& x() const { return data[1]; }
inline const float& y() const { return data[2]; }
inline const float& z() const { return data[3]; }
std::istream& read(std::istream &s);
std::ostream& write(std::ostream &s) const;
std::istream& readBinary(std::istream &s);
std::ostream& writeBinary(std::ostream &s) const;
protected:
float data[4];
};
//! user friendly output in format (u x y z)
std::ostream& operator<<(std::ostream& s, const Quaternion& q);
}
#endif
| 6,132 | 29.063725 | 80 | h |
octomap | octomap-master/octomap/include/octomap/math/Utils.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMATH_UTILS_H
#define OCTOMATH_UTILS_H
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
#ifndef M_PI_2
#define M_PI_2 1.570796326794896619
#endif
#ifndef DEG2RAD
#define DEG2RAD(x) ((x) * 0.01745329251994329575)
#endif
#ifndef RAD2DEG
#define RAD2DEG(x) ((x) * 57.29577951308232087721)
#endif
#endif
| 2,106 | 35.964912 | 78 | h |
octomap | octomap-master/octomap/include/octomap/math/Vector3.h | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#ifndef OCTOMATH_VECTOR3_H
#define OCTOMATH_VECTOR3_H
#include <iostream>
#include <math.h>
namespace octomath {
/*!
* \brief This class represents a three-dimensional vector
*
* The three-dimensional vector can be used to represent a
* translation in three-dimensional space or to represent the
* attitude of an object using Euler angle.
*/
class Vector3 {
public:
/*!
* \brief Default constructor
*/
Vector3 () { data[0] = data[1] = data[2] = 0.0; }
/*!
* \brief Copy constructor
*
* @param other a vector of dimension 3
*/
Vector3 (const Vector3& other) {
data[0] = other(0);
data[1] = other(1);
data[2] = other(2);
}
/*!
* \brief Constructor
*
* Constructs a three-dimensional vector from
* three single values x, y, z or roll, pitch, yaw
*/
Vector3 (float x, float y, float z) {
data[0] = x;
data[1] = y;
data[2] = z;
}
/* inline Eigen3::Vector3f getVector3f() const { return Eigen3::Vector3f(data[0], data[1], data[2]) ; } */
/* inline Eigen3::Vector4f& getVector4f() { return data; } */
/* inline Eigen3::Vector4f getVector4f() const { return data; } */
/*!
* \brief Assignment operator
*
* @param other a vector of dimension 3
*/
inline Vector3& operator= (const Vector3& other) {
data[0] = other(0);
data[1] = other(1);
data[2] = other(2);
return *this;
}
/*!
* \brief Three-dimensional vector (cross) product
*
* Calculates the tree-dimensional cross product, which
* represents the vector orthogonal to the plane defined
* by this and other.
* @return this x other
*/
inline Vector3 cross (const Vector3& other) const
{
//return (data.start<3> ().cross (other.data.start<3> ()));
// \note should this be renamed?
return Vector3(y()*other.z() - z()*other.y(),
z()*other.x() - x()*other.z(),
x()*other.y() - y()*other.x());
}
/// dot product
inline double dot (const Vector3& other) const
{
return x()*other.x() + y()*other.y() + z()*other.z();
}
inline const float& operator() (unsigned int i) const
{
return data[i];
}
inline float& operator() (unsigned int i)
{
return data[i];
}
inline float& x()
{
return operator()(0);
}
inline float& y()
{
return operator()(1);
}
inline float& z()
{
return operator()(2);
}
inline const float& x() const
{
return operator()(0);
}
inline const float& y() const
{
return operator()(1);
}
inline const float& z() const
{
return operator()(2);
}
inline float& roll()
{
return operator()(0);
}
inline float& pitch()
{
return operator()(1);
}
inline float& yaw()
{
return operator()(2);
}
inline const float& roll() const
{
return operator()(0);
}
inline const float& pitch() const
{
return operator()(1);
}
inline const float& yaw() const
{
return operator()(2);
}
inline Vector3 operator- () const
{
Vector3 result;
result(0) = -data[0];
result(1) = -data[1];
result(2) = -data[2];
return result;
}
inline Vector3 operator+ (const Vector3 &other) const
{
Vector3 result(*this);
result(0) += other(0);
result(1) += other(1);
result(2) += other(2);
return result;
}
inline Vector3 operator* (float x) const {
Vector3 result(*this);
result(0) *= x;
result(1) *= x;
result(2) *= x;
return result;
}
inline Vector3 operator- (const Vector3 &other) const
{
Vector3 result(*this);
result(0) -= other(0);
result(1) -= other(1);
result(2) -= other(2);
return result;
}
inline void operator+= (const Vector3 &other)
{
data[0] += other(0);
data[1] += other(1);
data[2] += other(2);
}
inline void operator-= (const Vector3& other) {
data[0] -= other(0);
data[1] -= other(1);
data[2] -= other(2);
}
inline void operator/= (float x) {
data[0] /= x;
data[1] /= x;
data[2] /= x;
}
inline void operator*= (float x) {
data[0] *= x;
data[1] *= x;
data[2] *= x;
}
inline bool operator== (const Vector3 &other) const {
for (unsigned int i=0; i<3; i++) {
if (operator()(i) != other(i))
return false;
}
return true;
}
/// @return length of the vector ("L2 norm")
inline double norm () const {
return sqrt(norm_sq());
}
/// @return squared length ("L2 norm") of the vector
inline double norm_sq() const {
return (x()*x() + y()*y() + z()*z());
}
/// normalizes this vector, so that it has norm=1.0
inline Vector3& normalize () {
double len = norm();
if (len > 0)
*this /= (float) len;
return *this;
}
/// @return normalized vector, this one remains unchanged
inline Vector3 normalized () const {
Vector3 result(*this);
result.normalize ();
return result;
}
inline double angleTo(const Vector3& other) const {
double dot_prod = this->dot(other);
double len1 = this->norm();
double len2 = other.norm();
return acos(dot_prod / (len1*len2));
}
inline double distance (const Vector3& other) const {
double dist_x = x() - other.x();
double dist_y = y() - other.y();
double dist_z = z() - other.z();
return sqrt(dist_x*dist_x + dist_y*dist_y + dist_z*dist_z);
}
inline double distanceXY (const Vector3& other) const {
double dist_x = x() - other.x();
double dist_y = y() - other.y();
return sqrt(dist_x*dist_x + dist_y*dist_y);
}
Vector3& rotate_IP (double roll, double pitch, double yaw);
// void read (unsigned char * src, unsigned int size);
std::istream& read(std::istream &s);
std::ostream& write(std::ostream &s) const;
std::istream& readBinary(std::istream &s);
std::ostream& writeBinary(std::ostream &s) const;
protected:
float data[3];
};
//! user friendly output in format (x y z)
std::ostream& operator<<(std::ostream& out, octomath::Vector3 const& v);
}
#endif
| 8,332 | 24.48318 | 110 | h |
octomap | octomap-master/octomap/src/AbstractOcTree.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <octomap/AbstractOcTree.h>
#include <octomap/OcTree.h>
#include <octomap/CountingOcTree.h>
namespace octomap {
AbstractOcTree::AbstractOcTree(){
}
bool AbstractOcTree::write(const std::string& filename) const{
std::ofstream file(filename.c_str(), std::ios_base::out | std::ios_base::binary);
if (!file.is_open()){
OCTOMAP_ERROR_STR("Filestream to "<< filename << " not open, nothing written.");
return false;
} else {
// TODO: check is_good of finished stream, return
write(file);
file.close();
}
return true;
}
bool AbstractOcTree::write(std::ostream &s) const{
s << fileHeader <<"\n# (feel free to add / change comments, but leave the first line as it is!)\n#\n";
s << "id " << getTreeType() << std::endl;
s << "size "<< size() << std::endl;
s << "res " << getResolution() << std::endl;
s << "data" << std::endl;
// write the actual data:
writeData(s);
// TODO: ret.val, checks stream?
return true;
}
AbstractOcTree* AbstractOcTree::read(const std::string& filename){
std::ifstream file(filename.c_str(), std::ios_base::in |std::ios_base::binary);
if (!file.is_open()){
OCTOMAP_ERROR_STR("Filestream to "<< filename << " not open, nothing read.");
return NULL;
} else {
// TODO: check is_good of finished stream, warn?
return read(file);
}
}
AbstractOcTree* AbstractOcTree::read(std::istream &s){
// check if first line valid:
std::string line;
std::getline(s, line);
if (line.compare(0,fileHeader.length(), fileHeader) !=0){
OCTOMAP_ERROR_STR("First line of OcTree file header does not start with \""<< fileHeader);
return NULL;
}
std::string id;
unsigned size;
double res;
if (!AbstractOcTree::readHeader(s, id, size, res))
return NULL;
// otherwise: values are valid, stream is now at binary data!
OCTOMAP_DEBUG_STR("Reading octree type "<< id);
AbstractOcTree* tree = createTree(id, res);
if (tree){
if (size > 0)
tree->readData(s);
OCTOMAP_DEBUG_STR("Done ("<< tree->size() << " nodes)");
}
return tree;
}
bool AbstractOcTree::readHeader(std::istream& s, std::string& id, unsigned& size, double& res){
id = "";
size = 0;
res = 0.0;
std::string token;
bool headerRead = false;
while(s.good() && !headerRead) {
s >> token;
if (token == "data"){
headerRead = true;
// skip forward until end of line:
char c;
do {
c = s.get();
} while(s.good() && (c != '\n'));
}
else if (token.compare(0,1,"#") == 0){
// comment line, skip forward until end of line:
char c;
do {
c = s.get();
} while(s.good() && (c != '\n'));
}
else if (token == "id")
s >> id;
else if (token == "res")
s >> res;
else if (token == "size")
s >> size;
else{
OCTOMAP_WARNING_STR("Unknown keyword in OcTree header, skipping: "<<token);
char c;
do {
c = s.get();
} while(s.good() && (c != '\n'));
}
}
if (!headerRead) {
OCTOMAP_ERROR_STR("Error reading OcTree header");
return false;
}
if (id == "") {
OCTOMAP_ERROR_STR("Error reading OcTree header, ID not set");
return false;
}
if (res <= 0.0) {
OCTOMAP_ERROR_STR("Error reading OcTree header, res <= 0.0");
return false;
}
// fix deprecated id value:
if (id == "1"){
OCTOMAP_WARNING("You are using a deprecated id \"%s\", changing to \"OcTree\" (you should update your file header)\n", id.c_str());
id = "OcTree";
}
return true;
}
AbstractOcTree* AbstractOcTree::createTree(const std::string class_name, double res){
std::map<std::string, AbstractOcTree*>::iterator it = classIDMapping().find(class_name);
if (it == classIDMapping().end()){
OCTOMAP_ERROR("Could not create octree of type %s, not in store in classIDMapping\n", class_name.c_str());
return NULL;
} else {
AbstractOcTree* tree = it->second->create();
tree->setResolution(res);
return tree;
}
}
std::map<std::string, AbstractOcTree*>& AbstractOcTree::classIDMapping(){
// we will "leak" the memory of the map and all trees until program exits,
// but this ensures all static objects are there as long as needed
// http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.15
static std::map<std::string, AbstractOcTree*>* map = new std::map<std::string, AbstractOcTree*>();
return *map;
}
void AbstractOcTree::registerTreeType(AbstractOcTree* tree){
classIDMapping()[tree->getTreeType()] = tree;
}
const std::string AbstractOcTree::fileHeader = "# Octomap OcTree file";
}
| 6,655 | 30.396226 | 137 | cpp |
octomap | octomap-master/octomap/src/AbstractOccupancyOcTree.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <octomap/AbstractOccupancyOcTree.h>
#include <octomap/octomap_types.h>
namespace octomap {
AbstractOccupancyOcTree::AbstractOccupancyOcTree(){
// some sane default values:
setOccupancyThres(0.5); // = 0.0 in logodds
setProbHit(0.7); // = 0.85 in logodds
setProbMiss(0.4); // = -0.4 in logodds
setClampingThresMin(0.1192); // = -2 in log odds
setClampingThresMax(0.971); // = 3.5 in log odds
}
bool AbstractOccupancyOcTree::writeBinary(const std::string& filename){
std::ofstream binary_outfile( filename.c_str(), std::ios_base::binary);
if (!binary_outfile.is_open()){
OCTOMAP_ERROR_STR("Filestream to "<< filename << " not open, nothing written.");
return false;
}
return writeBinary(binary_outfile);
}
bool AbstractOccupancyOcTree::writeBinaryConst(const std::string& filename) const{
std::ofstream binary_outfile( filename.c_str(), std::ios_base::binary);
if (!binary_outfile.is_open()){
OCTOMAP_ERROR_STR("Filestream to "<< filename << " not open, nothing written.");
return false;
}
writeBinaryConst(binary_outfile);
binary_outfile.close();
return true;
}
bool AbstractOccupancyOcTree::writeBinary(std::ostream &s){
// convert to max likelihood first, this makes efficient pruning on binary data possible
this->toMaxLikelihood();
this->prune();
return writeBinaryConst(s);
}
bool AbstractOccupancyOcTree::writeBinaryConst(std::ostream &s) const{
// write new header first:
s << binaryFileHeader <<"\n# (feel free to add / change comments, but leave the first line as it is!)\n#\n";
s << "id " << this->getTreeType() << std::endl;
s << "size "<< this->size() << std::endl;
s << "res " << this->getResolution() << std::endl;
s << "data" << std::endl;
writeBinaryData(s);
if (s.good()){
OCTOMAP_DEBUG(" done.\n");
return true;
} else {
OCTOMAP_WARNING_STR("Output stream not \"good\" after writing tree");
return false;
}
}
bool AbstractOccupancyOcTree::readBinaryLegacyHeader(std::istream &s, unsigned int& size, double& res) {
if (!s.good()){
OCTOMAP_WARNING_STR("Input filestream not \"good\" in OcTree::readBinary");
}
int tree_type = -1;
s.read((char*)&tree_type, sizeof(tree_type));
if (tree_type == 3){
this->clear();
s.read((char*)&res, sizeof(res));
if (res <= 0.0){
OCTOMAP_ERROR("Invalid tree resolution: %f", res);
return false;
}
s.read((char*)&size, sizeof(size));
return true;
}
else {
OCTOMAP_ERROR_STR("Binary file does not contain an OcTree!");
return false;
}
}
bool AbstractOccupancyOcTree::readBinary(const std::string& filename){
std::ifstream binary_infile( filename.c_str(), std::ios_base::binary);
if (!binary_infile.is_open()){
OCTOMAP_ERROR_STR("Filestream to "<< filename << " not open, nothing read.");
return false;
}
return readBinary(binary_infile);
}
bool AbstractOccupancyOcTree::readBinary(std::istream &s) {
if (!s.good()){
OCTOMAP_WARNING_STR("Input filestream not \"good\" in OcTree::readBinary");
}
// check if first line valid:
std::string line;
std::istream::pos_type streampos = s.tellg();
std::getline(s, line);
unsigned size;
double res;
if (line.compare(0,AbstractOccupancyOcTree::binaryFileHeader.length(), AbstractOccupancyOcTree::binaryFileHeader) ==0){
std::string id;
if (!AbstractOcTree::readHeader(s, id, size, res))
return false;
OCTOMAP_DEBUG_STR("Reading binary octree type "<< id);
} else{ // try to read old binary format:
s.clear(); // clear eofbit of istream
s.seekg(streampos);
if (readBinaryLegacyHeader(s, size, res)){
OCTOMAP_WARNING_STR("You are using an outdated binary tree file format.");
OCTOMAP_WARNING_STR("Please convert your .bt files with convert_octree.");
}
else {
OCTOMAP_ERROR_STR("First line of OcTree file header does not start with \""<< AbstractOccupancyOcTree::binaryFileHeader<<"\"");
return false;
}
}
// otherwise: values are valid, stream is now at binary data!
this->clear();
this->setResolution(res);
if (size > 0)
this->readBinaryData(s);
if (size != this->size()){
OCTOMAP_ERROR("Tree size mismatch: # read nodes (%zu) != # expected nodes (%d)\n",this->size(), size);
return false;
}
return true;
}
const std::string AbstractOccupancyOcTree::binaryFileHeader = "# Octomap OcTree binary file";
}
| 6,509 | 34.769231 | 135 | cpp |
octomap | octomap-master/octomap/src/ColorOcTree.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <octomap/ColorOcTree.h>
namespace octomap {
// node implementation --------------------------------------
std::ostream& ColorOcTreeNode::writeData(std::ostream &s) const {
s.write((const char*) &value, sizeof(value)); // occupancy
s.write((const char*) &color, sizeof(Color)); // color
return s;
}
std::istream& ColorOcTreeNode::readData(std::istream &s) {
s.read((char*) &value, sizeof(value)); // occupancy
s.read((char*) &color, sizeof(Color)); // color
return s;
}
ColorOcTreeNode::Color ColorOcTreeNode::getAverageChildColor() const {
int mr = 0;
int mg = 0;
int mb = 0;
int c = 0;
if (children != NULL){
for (int i=0; i<8; i++) {
ColorOcTreeNode* child = static_cast<ColorOcTreeNode*>(children[i]);
if (child != NULL && child->isColorSet()) {
mr += child->getColor().r;
mg += child->getColor().g;
mb += child->getColor().b;
++c;
}
}
}
if (c > 0) {
mr /= c;
mg /= c;
mb /= c;
return Color((uint8_t) mr, (uint8_t) mg, (uint8_t) mb);
}
else { // no child had a color other than white
return Color(255, 255, 255);
}
}
void ColorOcTreeNode::updateColorChildren() {
color = getAverageChildColor();
}
// tree implementation --------------------------------------
ColorOcTree::ColorOcTree(double in_resolution)
: OccupancyOcTreeBase<ColorOcTreeNode>(in_resolution) {
colorOcTreeMemberInit.ensureLinking();
}
ColorOcTreeNode* ColorOcTree::setNodeColor(const OcTreeKey& key,
uint8_t r,
uint8_t g,
uint8_t b) {
ColorOcTreeNode* n = search (key);
if (n != 0) {
n->setColor(r, g, b);
}
return n;
}
bool ColorOcTree::pruneNode(ColorOcTreeNode* node) {
if (!isNodeCollapsible(node))
return false;
// set value to children's values (all assumed equal)
node->copyData(*(getNodeChild(node, 0)));
if (node->isColorSet()) // TODO check
node->setColor(node->getAverageChildColor());
// delete children
for (unsigned int i=0;i<8;i++) {
deleteNodeChild(node, i);
}
delete[] node->children;
node->children = NULL;
return true;
}
bool ColorOcTree::isNodeCollapsible(const ColorOcTreeNode* node) const{
// all children must exist, must not have children of
// their own and have the same occupancy probability
if (!nodeChildExists(node, 0))
return false;
const ColorOcTreeNode* firstChild = getNodeChild(node, 0);
if (nodeHasChildren(firstChild))
return false;
for (unsigned int i = 1; i<8; i++) {
// compare nodes only using their occupancy, ignoring color for pruning
if (!nodeChildExists(node, i) || nodeHasChildren(getNodeChild(node, i)) || !(getNodeChild(node, i)->getValue() == firstChild->getValue()))
return false;
}
return true;
}
ColorOcTreeNode* ColorOcTree::averageNodeColor(const OcTreeKey& key,
uint8_t r,
uint8_t g,
uint8_t b) {
ColorOcTreeNode* n = search(key);
if (n != 0) {
if (n->isColorSet()) {
ColorOcTreeNode::Color prev_color = n->getColor();
n->setColor((prev_color.r + r)/2, (prev_color.g + g)/2, (prev_color.b + b)/2);
}
else {
n->setColor(r, g, b);
}
}
return n;
}
ColorOcTreeNode* ColorOcTree::integrateNodeColor(const OcTreeKey& key,
uint8_t r,
uint8_t g,
uint8_t b) {
ColorOcTreeNode* n = search (key);
if (n != 0) {
if (n->isColorSet()) {
ColorOcTreeNode::Color prev_color = n->getColor();
double node_prob = n->getOccupancy();
uint8_t new_r = (uint8_t) ((double) prev_color.r * node_prob
+ (double) r * (0.99-node_prob));
uint8_t new_g = (uint8_t) ((double) prev_color.g * node_prob
+ (double) g * (0.99-node_prob));
uint8_t new_b = (uint8_t) ((double) prev_color.b * node_prob
+ (double) b * (0.99-node_prob));
n->setColor(new_r, new_g, new_b);
}
else {
n->setColor(r, g, b);
}
}
return n;
}
void ColorOcTree::updateInnerOccupancy() {
this->updateInnerOccupancyRecurs(this->root, 0);
}
void ColorOcTree::updateInnerOccupancyRecurs(ColorOcTreeNode* node, unsigned int depth) {
// only recurse and update for inner nodes:
if (nodeHasChildren(node)){
// return early for last level:
if (depth < this->tree_depth){
for (unsigned int i=0; i<8; i++) {
if (nodeChildExists(node, i)) {
updateInnerOccupancyRecurs(getNodeChild(node, i), depth+1);
}
}
}
node->updateOccupancyChildren();
node->updateColorChildren();
}
}
void ColorOcTree::writeColorHistogram(std::string filename) {
#ifdef _MSC_VER
fprintf(stderr, "The color histogram uses gnuplot, this is not supported under windows.\n");
#else
// build RGB histogram
std::vector<int> histogram_r (256,0);
std::vector<int> histogram_g (256,0);
std::vector<int> histogram_b (256,0);
for(ColorOcTree::tree_iterator it = this->begin_tree(),
end=this->end_tree(); it!= end; ++it) {
if (!it.isLeaf() || !this->isNodeOccupied(*it)) continue;
ColorOcTreeNode::Color& c = it->getColor();
++histogram_r[c.r];
++histogram_g[c.g];
++histogram_b[c.b];
}
// plot data
FILE *gui = popen("gnuplot ", "w");
fprintf(gui, "set term postscript eps enhanced color\n");
fprintf(gui, "set output \"%s\"\n", filename.c_str());
fprintf(gui, "plot [-1:256] ");
fprintf(gui,"'-' w filledcurve lt 1 lc 1 tit \"r\",");
fprintf(gui, "'-' w filledcurve lt 1 lc 2 tit \"g\",");
fprintf(gui, "'-' w filledcurve lt 1 lc 3 tit \"b\",");
fprintf(gui, "'-' w l lt 1 lc 1 tit \"\",");
fprintf(gui, "'-' w l lt 1 lc 2 tit \"\",");
fprintf(gui, "'-' w l lt 1 lc 3 tit \"\"\n");
for (int i=0; i<256; ++i) fprintf(gui,"%d %d\n", i, histogram_r[i]);
fprintf(gui,"0 0\n"); fprintf(gui, "e\n");
for (int i=0; i<256; ++i) fprintf(gui,"%d %d\n", i, histogram_g[i]);
fprintf(gui,"0 0\n"); fprintf(gui, "e\n");
for (int i=0; i<256; ++i) fprintf(gui,"%d %d\n", i, histogram_b[i]);
fprintf(gui,"0 0\n"); fprintf(gui, "e\n");
for (int i=0; i<256; ++i) fprintf(gui,"%d %d\n", i, histogram_r[i]);
fprintf(gui, "e\n");
for (int i=0; i<256; ++i) fprintf(gui,"%d %d\n", i, histogram_g[i]);
fprintf(gui, "e\n");
for (int i=0; i<256; ++i) fprintf(gui,"%d %d\n", i, histogram_b[i]);
fprintf(gui, "e\n");
fflush(gui);
#endif
}
std::ostream& operator<<(std::ostream& out, ColorOcTreeNode::Color const& c) {
return out << '(' << (unsigned int)c.r << ' ' << (unsigned int)c.g << ' ' << (unsigned int)c.b << ')';
}
ColorOcTree::StaticMemberInitializer ColorOcTree::colorOcTreeMemberInit;
} // end namespace
| 9,212 | 34.298851 | 144 | cpp |
octomap | octomap-master/octomap/src/CountingOcTree.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <cassert>
#include <octomap/CountingOcTree.h>
namespace octomap {
/// implementation of CountingOcTreeNode ----------------------------------
CountingOcTreeNode::CountingOcTreeNode()
: OcTreeDataNode<unsigned int>(0)
{
}
CountingOcTreeNode::~CountingOcTreeNode() {
}
/// implementation of CountingOcTree --------------------------------------
CountingOcTree::CountingOcTree(double in_resolution)
: OcTreeBase<CountingOcTreeNode>(in_resolution) {
countingOcTreeMemberInit.ensureLinking();
}
CountingOcTreeNode* CountingOcTree::updateNode(const point3d& value) {
OcTreeKey key;
if (!coordToKeyChecked(value, key)) return NULL;
return updateNode(key);
}
// Note: do not inline this method, will decrease speed (KMW)
CountingOcTreeNode* CountingOcTree::updateNode(const OcTreeKey& k) {
if (root == NULL) {
root = new CountingOcTreeNode();
tree_size++;
}
CountingOcTreeNode* curNode (root);
curNode->increaseCount();
// follow or construct nodes down to last level...
for (int i=(tree_depth-1); i>=0; i--) {
unsigned int pos = computeChildIdx(k, i);
// requested node does not exist
if (!nodeChildExists(curNode, pos)) {
createNodeChild(curNode, pos);
}
// descent tree
curNode = getNodeChild(curNode, pos);
curNode->increaseCount(); // modify traversed nodes
}
return curNode;
}
void CountingOcTree::getCentersMinHits(point3d_list& node_centers, unsigned int min_hits) const {
OcTreeKey root_key;
root_key[0] = root_key[1] = root_key[2] = this->tree_max_val;
getCentersMinHitsRecurs(node_centers, min_hits, this->tree_depth, this->root, 0, root_key);
}
void CountingOcTree::getCentersMinHitsRecurs( point3d_list& node_centers,
unsigned int& min_hits,
unsigned int max_depth,
CountingOcTreeNode* node, unsigned int depth,
const OcTreeKey& parent_key) const {
if (depth < max_depth && nodeHasChildren(node)) {
key_type center_offset_key = this->tree_max_val >> (depth + 1);
OcTreeKey search_key;
for (unsigned int i=0; i<8; ++i) {
if (nodeChildExists(node,i)) {
computeChildKey(i, center_offset_key, parent_key, search_key);
getCentersMinHitsRecurs(node_centers, min_hits, max_depth, getNodeChild(node,i), depth+1, search_key);
}
}
}
else { // max level reached
if (node->getCount() >= min_hits) {
node_centers.push_back(this->keyToCoord(parent_key, depth));
}
}
}
CountingOcTree::StaticMemberInitializer CountingOcTree::countingOcTreeMemberInit;
} // namespace
| 4,635 | 33.857143 | 112 | cpp |
octomap | octomap-master/octomap/src/OcTree.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <octomap/OcTree.h>
namespace octomap {
OcTree::OcTree(double in_resolution)
: OccupancyOcTreeBase<OcTreeNode>(in_resolution) {
ocTreeMemberInit.ensureLinking();
}
OcTree::OcTree(std::string _filename)
: OccupancyOcTreeBase<OcTreeNode> (0.1) { // resolution will be set according to tree file
readBinary(_filename);
}
OcTree::StaticMemberInitializer OcTree::ocTreeMemberInit;
} // namespace
| 2,209 | 39.181818 | 95 | cpp |
octomap | octomap-master/octomap/src/OcTreeNode.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <bitset>
#include <cassert>
#include <math.h>
#include <fstream>
#include <stdlib.h>
#include <inttypes.h>
#include <octomap/OcTreeNode.h>
namespace octomap {
OcTreeNode::OcTreeNode()
: OcTreeDataNode<float>(0.0)
{
}
OcTreeNode::~OcTreeNode(){
}
// ============================================================
// = occupancy probability ==================================
// ============================================================
double OcTreeNode::getMeanChildLogOdds() const{
double mean = 0;
uint8_t c = 0;
if (children !=NULL){
for (unsigned int i=0; i<8; i++) {
if (children[i] != NULL) {
mean += static_cast<OcTreeNode*>(children[i])->getOccupancy(); // TODO check if works generally
++c;
}
}
}
if (c > 0)
mean /= (double) c;
return log(mean/(1-mean));
}
float OcTreeNode::getMaxChildLogOdds() const{
float max = -std::numeric_limits<float>::max();
if (children !=NULL){
for (unsigned int i=0; i<8; i++) {
if (children[i] != NULL) {
float l = static_cast<OcTreeNode*>(children[i])->getLogOdds(); // TODO check if works generally
if (l > max)
max = l;
}
}
}
return max;
}
void OcTreeNode::addValue(const float& logOdds) {
value += logOdds;
}
} // end namespace
| 3,180 | 31.459184 | 105 | cpp |
octomap | octomap-master/octomap/src/OcTreeStamped.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include "octomap/OcTreeStamped.h"
namespace octomap {
OcTreeStamped::OcTreeStamped(double in_resolution)
: OccupancyOcTreeBase<OcTreeNodeStamped>(in_resolution) {
ocTreeStampedMemberInit.ensureLinking();
}
unsigned int OcTreeStamped::getLastUpdateTime() {
// this value is updated whenever inner nodes are
// updated using updateOccupancyChildren()
return root->getTimestamp();
}
void OcTreeStamped::degradeOutdatedNodes(unsigned int time_thres) {
unsigned int query_time = (unsigned int) time(NULL);
for(leaf_iterator it = this->begin_leafs(), end=this->end_leafs();
it!= end; ++it) {
if ( this->isNodeOccupied(*it)
&& ((query_time - it->getTimestamp()) > time_thres) ) {
integrateMissNoTime(&*it);
}
}
}
void OcTreeStamped::updateNodeLogOdds(OcTreeNodeStamped* node, const float& update) const {
OccupancyOcTreeBase<OcTreeNodeStamped>::updateNodeLogOdds(node, update);
node->updateTimestamp();
}
void OcTreeStamped::integrateMissNoTime(OcTreeNodeStamped* node) const{
OccupancyOcTreeBase<OcTreeNodeStamped>::updateNodeLogOdds(node, prob_miss_log);
}
OcTreeStamped::StaticMemberInitializer OcTreeStamped::ocTreeStampedMemberInit;
} // end namespace
| 3,044 | 40.712329 | 93 | cpp |
octomap | octomap-master/octomap/src/Pointcloud.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
/* According to c++ standard including this header has no practical effect
* but it can be used to determine the c++ standard library implementation.
*/
#include <ciso646>
#if defined(_MSC_VER) || defined(_LIBCPP_VERSION)
#include <algorithm>
#if __cplusplus > 199711L
#include <random>
#endif
#else
#include <ext/algorithm>
#endif
#include <fstream>
#include <math.h>
#include <assert.h>
#include <limits>
#include <octomap/Pointcloud.h>
namespace octomap {
Pointcloud::Pointcloud() {
}
Pointcloud::~Pointcloud() {
this->clear();
}
void Pointcloud::clear() {
// delete the points
if (points.size()) {
points.clear();
}
}
Pointcloud::Pointcloud(const Pointcloud& other) {
for (Pointcloud::const_iterator it = other.begin(); it != other.end(); it++) {
points.push_back(point3d(*it));
}
}
Pointcloud::Pointcloud(Pointcloud* other) {
for (Pointcloud::const_iterator it = other->begin(); it != other->end(); it++) {
points.push_back(point3d(*it));
}
}
void Pointcloud::push_back(const Pointcloud& other) {
for (Pointcloud::const_iterator it = other.begin(); it != other.end(); it++) {
points.push_back(point3d(*it));
}
}
point3d Pointcloud::getPoint(unsigned int i) const{
if (i < points.size())
return points[i];
else {
OCTOMAP_WARNING("Pointcloud::getPoint index out of range!\n");
return points.back();
}
}
void Pointcloud::transform(octomath::Pose6D transform) {
for (unsigned int i=0; i<points.size(); i++) {
points[i] = transform.transform(points[i]);
}
// FIXME: not correct for multiple transforms
current_inv_transform = transform.inv();
}
void Pointcloud::transformAbsolute(pose6d transform) {
// undo previous transform, then apply current transform
pose6d transf = current_inv_transform * transform;
for (unsigned int i=0; i<points.size(); i++) {
points[i] = transf.transform(points[i]);
}
current_inv_transform = transform.inv();
}
void Pointcloud::rotate(double roll, double pitch, double yaw) {
for (unsigned int i=0; i<points.size(); i++) {
points[i].rotate_IP(roll, pitch, yaw);
}
}
void Pointcloud::calcBBX(point3d& lowerBound, point3d& upperBound) const {
float min_x, min_y, min_z;
float max_x, max_y, max_z;
min_x = min_y = min_z = 1e6;
max_x = max_y = max_z = -1e6;
float x,y,z;
for (Pointcloud::const_iterator it=begin(); it!=end(); it++) {
x = (*it)(0);
y = (*it)(1);
z = (*it)(2);
if (x < min_x) min_x = x;
if (y < min_y) min_y = y;
if (z < min_z) min_z = z;
if (x > max_x) max_x = x;
if (y > max_y) max_y = y;
if (z > max_z) max_z = z;
}
lowerBound(0) = min_x; lowerBound(1) = min_y; lowerBound(2) = min_z;
upperBound(0) = max_x; upperBound(1) = max_y; upperBound(2) = max_z;
}
void Pointcloud::crop(point3d lowerBound, point3d upperBound) {
Pointcloud result;
float min_x, min_y, min_z;
float max_x, max_y, max_z;
float x,y,z;
min_x = lowerBound(0); min_y = lowerBound(1); min_z = lowerBound(2);
max_x = upperBound(0); max_y = upperBound(1); max_z = upperBound(2);
for (Pointcloud::const_iterator it=begin(); it!=end(); it++) {
x = (*it)(0);
y = (*it)(1);
z = (*it)(2);
if ( (x >= min_x) &&
(y >= min_y) &&
(z >= min_z) &&
(x <= max_x) &&
(y <= max_y) &&
(z <= max_z) ) {
result.push_back (x,y,z);
}
} // end for points
this->clear();
this->push_back(result);
}
void Pointcloud::minDist(double thres) {
Pointcloud result;
float x,y,z;
for (Pointcloud::const_iterator it=begin(); it!=end(); it++) {
x = (*it)(0);
y = (*it)(1);
z = (*it)(2);
double dist = sqrt(x*x+y*y+z*z);
if ( dist > thres ) result.push_back (x,y,z);
} // end for points
this->clear();
this->push_back(result);
}
void Pointcloud::subSampleRandom(unsigned int num_samples, Pointcloud& sample_cloud) {
point3d_collection samples;
// visual studio does not support random_sample_n and neither does libc++
#if defined(_MSC_VER) || defined(_LIBCPP_VERSION)
samples.reserve(this->size());
samples.insert(samples.end(), this->begin(), this->end());
#if __cplusplus > 199711L
std::random_device r;
std::mt19937 urbg(r());
std::shuffle(samples.begin(), samples.end(), urbg);
#else
std::random_shuffle(samples.begin(), samples.end());
#endif
samples.resize(num_samples);
#else
random_sample_n(begin(), end(), std::back_insert_iterator<point3d_collection>(samples), num_samples);
for (unsigned int i=0; i<samples.size(); i++) {
sample_cloud.push_back(samples[i]);
}
#endif
}
void Pointcloud::writeVrml(std::string filename){
std::ofstream outfile (filename.c_str());
outfile << "#VRML V2.0 utf8" << std::endl;
outfile << "Transform {" << std::endl;
outfile << "translation 0 0 0" << std::endl;
outfile << "rotation 0 0 0 0" << std::endl;
outfile << " children [" << std::endl;
outfile << " Shape{" << std::endl;
outfile << " geometry PointSet {" << std::endl;
outfile << " coord Coordinate {" << std::endl;
outfile << " point [" << std::endl;
OCTOMAP_DEBUG_STR("PointCloud::writeVrml writing "
<< points.size() << " points to "
<< filename.c_str() << ".");
for (unsigned int i = 0; i < (points.size()); i++){
outfile << "\t\t" << (points[i])(0)
<< " " << (points[i])(1)
<< " " << (points[i])(2)
<< "\n";
}
outfile << " ]" << std::endl;
outfile << " }" << std::endl;
outfile << " color Color{" << std::endl;
outfile << " color [" << std::endl;
for (unsigned int i = 0; i < points.size(); i++){
outfile << "\t\t 1.0 1.0 1.0 \n";
}
outfile << " ]" << std::endl;
outfile << " }" << std::endl;
outfile << " }" << std::endl;
outfile << " }" << std::endl;
outfile << " ]" << std::endl;
outfile << "}" << std::endl;
}
std::istream& Pointcloud::read(std::istream &s){
while (!s.eof()){
point3d p;
for (unsigned int i=0; i<3; i++){
s >> p(i);
}
if (!s.fail()){
this->push_back(p);
} else {
break;
}
}
return s;
}
std::istream& Pointcloud::readBinary(std::istream &s) {
uint32_t pc_size = 0;
s.read((char*)&pc_size, sizeof(pc_size));
OCTOMAP_DEBUG("Reading %d points from binary file...", pc_size);
if (pc_size > 0) {
this->points.reserve(pc_size);
point3d p;
for (uint32_t i=0; i<pc_size; i++) {
p.readBinary(s);
if (!s.fail()) {
this->push_back(p);
}
else {
OCTOMAP_ERROR("Pointcloud::readBinary: ERROR.\n" );
break;
}
}
}
assert(pc_size == this->size());
OCTOMAP_DEBUG("done.\n");
return s;
}
std::ostream& Pointcloud::writeBinary(std::ostream &s) const {
// check if written unsigned int can hold size
size_t orig_size = this->size();
if (orig_size > std::numeric_limits<uint32_t>::max()){
OCTOMAP_ERROR("Pointcloud::writeBinary ERROR: Point cloud too large to be written");
return s;
}
uint32_t pc_size = static_cast<uint32_t>(this->size());
OCTOMAP_DEBUG("Writing %u points to binary file...", pc_size);
s.write((char*)&pc_size, sizeof(pc_size));
for (Pointcloud::const_iterator it = this->begin(); it != this->end(); it++) {
it->writeBinary(s);
}
OCTOMAP_DEBUG("done.\n");
return s;
}
} // end namespace
| 9,606 | 26.765896 | 105 | cpp |
octomap | octomap-master/octomap/src/ScanGraph.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <iomanip>
#include <fstream>
#include <sstream>
#include <stdlib.h>
#include <octomap/math/Pose6D.h>
#include <octomap/ScanGraph.h>
namespace octomap {
ScanNode::~ScanNode(){
if (scan != NULL){
delete scan;
scan = NULL;
}
}
std::ostream& ScanNode::writeBinary(std::ostream &s) const {
// file structure: pointcloud | pose | id
scan->writeBinary(s);
pose.writeBinary(s);
uint32_t uintId = static_cast<uint32_t>(id);
s.write((char*)&uintId, sizeof(uintId));
return s;
}
std::istream& ScanNode::readBinary(std::istream &s) {
this->scan = new Pointcloud();
this->scan->readBinary(s);
this->pose.readBinary(s);
uint32_t uintId;
s.read((char*)&uintId, sizeof(uintId));
this->id = uintId;
return s;
}
std::ostream& ScanNode::writePoseASCII(std::ostream &s) const {
s << " " << this->id; // export pose for human editor
s << " ";
this->pose.trans().write(s);
s << " ";
this->pose.rot().toEuler().write(s);
s << std::endl;
return s;
}
std::istream& ScanNode::readPoseASCII(std::istream &s) {
unsigned int read_id;
s >> read_id;
if (read_id != this->id)
OCTOMAP_ERROR("ERROR while reading ScanNode pose from ASCII. id %d does not match real id %d.\n", read_id, this->id);
this->pose.trans().read(s);
// read rotation from euler angles
point3d rot;
rot.read(s);
this->pose.rot() = octomath::Quaternion(rot);
return s;
}
std::ostream& ScanEdge::writeBinary(std::ostream &s) const {
// file structure: first_id | second_id | constraint | weight
s.write((char*)&first->id, sizeof(first->id));
s.write((char*)&second->id, sizeof(second->id));
constraint.writeBinary(s);
s.write((char*)&weight, sizeof(weight));
return s;
}
std::istream& ScanEdge::readBinary(std::istream &s, ScanGraph& graph) {
unsigned int first_id, second_id;
s.read((char*)&first_id, sizeof(first_id));
s.read((char*)&second_id, sizeof(second_id));
this->first = graph.getNodeByID(first_id);
if (this->first == NULL) OCTOMAP_ERROR("ERROR while reading ScanEdge. first node not found.\n");
this->second = graph.getNodeByID(second_id);
if (this->second == NULL) OCTOMAP_ERROR("ERROR while reading ScanEdge. second node not found.\n");
this->constraint.readBinary(s);
s.read((char*)&weight, sizeof(weight));
return s;
}
std::ostream& ScanEdge::writeASCII(std::ostream &s) const {
// file structure: first_id | second_id | constraint | weight
s << " " << first->id << " " << second->id;
s << " ";
constraint.write(s);
s << " " << weight;
s << std::endl;
return s;
}
std::istream& ScanEdge::readASCII(std::istream &s, ScanGraph& graph) {
unsigned int first_id, second_id;
s >> first_id;
s >> second_id;
this->first = graph.getNodeByID(first_id);
if (this->first == NULL) OCTOMAP_ERROR("ERROR while reading ScanEdge. first node %d not found.\n", first_id);
this->second = graph.getNodeByID(second_id);
if (this->second == NULL) OCTOMAP_ERROR("ERROR while reading ScanEdge. second node %d not found.\n", second_id);
this->constraint.read(s);
s >> weight;
return s;
}
ScanGraph::~ScanGraph() {
this->clear();
}
void ScanGraph::clear() {
for (unsigned int i=0; i<nodes.size(); i++) {
delete nodes[i];
}
nodes.clear();
for (unsigned int i=0; i<edges.size(); i++) {
delete edges[i];
}
edges.clear();
}
ScanNode* ScanGraph::addNode(Pointcloud* scan, pose6d pose) {
if (scan != 0) {
nodes.push_back(new ScanNode(scan, pose, (unsigned int) nodes.size()));
return nodes.back();
}
else {
OCTOMAP_ERROR("scan is invalid.\n");
return NULL;
}
}
ScanEdge* ScanGraph::addEdge(ScanNode* first, ScanNode* second, pose6d constraint) {
if ((first != 0) && (second != 0)) {
edges.push_back(new ScanEdge(first, second, constraint));
// OCTOMAP_DEBUG("ScanGraph::AddEdge %d --> %d\n", first->id, second->id);
return edges.back();
}
else {
OCTOMAP_ERROR("addEdge:: one or both nodes invalid.\n");
return NULL;
}
}
ScanEdge* ScanGraph::addEdge(unsigned int first_id, unsigned int second_id) {
if ( this->edgeExists(first_id, second_id)) {
OCTOMAP_ERROR("addEdge:: Edge exists!\n");
return NULL;
}
ScanNode* first = getNodeByID(first_id);
ScanNode* second = getNodeByID(second_id);
if ((first != 0) && (second != 0)) {
pose6d constr = first->pose.inv() * second->pose;
return this->addEdge(first, second, constr);
}
else {
OCTOMAP_ERROR("addEdge:: one or both scans invalid.\n");
return NULL;
}
}
void ScanGraph::connectPrevious() {
if (nodes.size() >= 2) {
ScanNode* first = nodes[nodes.size()-2];
ScanNode* second = nodes[nodes.size()-1];
pose6d c = (first->pose).inv() * second->pose;
this->addEdge(first, second, c);
}
}
void ScanGraph::exportDot(std::string filename) {
std::ofstream outfile (filename.c_str());
outfile << "graph ScanGraph" << std::endl;
outfile << "{" << std::endl;
for (unsigned int i=0; i<edges.size(); i++) {
outfile << (edges[i]->first)->id
<< " -- "
<< (edges[i]->second)->id
<< " [label="
<< std::fixed << std::setprecision(2) << edges[i]->constraint.transLength()
<< "]" << std::endl;
}
outfile << "}" << std::endl;
outfile.close();
}
ScanNode* ScanGraph::getNodeByID(unsigned int id) {
for (unsigned int i = 0; i < nodes.size(); i++) {
if (nodes[i]->id == id) return nodes[i];
}
return NULL;
}
bool ScanGraph::edgeExists(unsigned int first_id, unsigned int second_id) {
for (unsigned int i=0; i<edges.size(); i++) {
if (
(((edges[i]->first)->id == first_id) && ((edges[i]->second)->id == second_id))
||
(((edges[i]->first)->id == second_id) && ((edges[i]->second)->id == first_id))) {
return true;
}
}
return false;
}
std::vector<unsigned int> ScanGraph::getNeighborIDs(unsigned int id) {
std::vector<unsigned int> res;
ScanNode* node = getNodeByID(id);
if (node) {
// check all nodes
for (unsigned int i = 0; i < nodes.size(); i++) {
if (node->id == nodes[i]->id) continue;
if (edgeExists(id, nodes[i]->id)) {
res.push_back(nodes[i]->id);
}
}
}
return res;
}
std::vector<ScanEdge*> ScanGraph::getOutEdges(ScanNode* node) {
std::vector<ScanEdge*> res;
if (node) {
for (std::vector<ScanEdge*>::iterator it = edges.begin(); it != edges.end(); it++) {
if ((*it)->first == node) {
res.push_back(*it);
}
}
}
return res;
}
std::vector<ScanEdge*> ScanGraph::getInEdges(ScanNode* node) {
std::vector<ScanEdge*> res;
if (node) {
for (std::vector<ScanEdge*>::iterator it = edges.begin(); it != edges.end(); it++) {
if ((*it)->second == node) {
res.push_back(*it);
}
}
}
return res;
}
void ScanGraph::transformScans() {
for(ScanGraph::iterator it=this->begin(); it != this->end(); it++) {
((*it)->scan)->transformAbsolute((*it)->pose);
}
}
bool ScanGraph::writeBinary(const std::string& filename) const {
std::ofstream binary_outfile( filename.c_str(), std::ios_base::binary);
if (!binary_outfile.is_open()){
OCTOMAP_ERROR_STR("Filestream to "<< filename << " not open, nothing written.");
return false;
}
writeBinary(binary_outfile);
binary_outfile.close();
return true;
}
std::ostream& ScanGraph::writeBinary(std::ostream &s) const {
// file structure: n | node_1 | ... | node_n | m | edge_1 | ... | edge_m
// write nodes ---------------------------------
// note: size is always an unsigned int!
unsigned int graph_size = (unsigned int) this->size();
if (graph_size) OCTOMAP_DEBUG("writing %u nodes to binary file...\n", graph_size);
s.write((char*)&graph_size, sizeof(graph_size));
for (ScanGraph::const_iterator it = this->begin(); it != this->end(); it++) {
(*it)->writeBinary(s);
}
if (graph_size) OCTOMAP_DEBUG("done.\n");
// write edges ---------------------------------
unsigned int num_edges = (unsigned int) this->edges.size();
if (num_edges) OCTOMAP_DEBUG("writing %u edges to binary file...\n", num_edges);
s.write((char*)&num_edges, sizeof(num_edges));
for (ScanGraph::const_edge_iterator it = this->edges_begin(); it != this->edges_end(); it++) {
(*it)->writeBinary(s);
}
if (num_edges) OCTOMAP_DEBUG(" done.\n");
return s;
}
bool ScanGraph::readBinary(const std::string& filename) {
std::ifstream binary_infile(filename.c_str(), std::ios_base::binary);
if (!binary_infile.is_open()){
OCTOMAP_ERROR_STR("Filestream to "<< filename << " not open, nothing read.");
return false;
}
readBinary(binary_infile);
binary_infile.close();
return true;
}
std::istream& ScanGraph::readBinary(std::ifstream &s) {
if (!s.is_open()){
OCTOMAP_ERROR_STR("Could not read from input filestream in ScanGraph::readBinary");
return s;
} else if (!s.good()){
OCTOMAP_WARNING_STR("Input filestream not \"good\" in ScanGraph::readBinary");
}
this->clear();
// read nodes ---------------------------------
unsigned int graph_size = 0;
s.read((char*)&graph_size, sizeof(graph_size));
if (graph_size) OCTOMAP_DEBUG("reading %d nodes from binary file...\n", graph_size);
if (graph_size > 0) {
this->nodes.reserve(graph_size);
for (unsigned int i=0; i<graph_size; i++) {
ScanNode* node = new ScanNode();
node->readBinary(s);
if (!s.fail()) {
this->nodes.push_back(node);
}
else {
OCTOMAP_ERROR("ScanGraph::readBinary: ERROR.\n" );
break;
}
}
}
if (graph_size) OCTOMAP_DEBUG("done.\n");
// read edges ---------------------------------
unsigned int num_edges = 0;
s.read((char*)&num_edges, sizeof(num_edges));
if (num_edges) OCTOMAP_DEBUG("reading %d edges from binary file...\n", num_edges);
if (num_edges > 0) {
this->edges.reserve(num_edges);
for (unsigned int i=0; i<num_edges; i++) {
ScanEdge* edge = new ScanEdge();
edge->readBinary(s, *this);
if (!s.fail()) {
this->edges.push_back(edge);
}
else {
OCTOMAP_ERROR("ScanGraph::readBinary: ERROR.\n" );
break;
}
}
}
if (num_edges) OCTOMAP_DEBUG("done.\n");
return s;
}
void ScanGraph::readPlainASCII(const std::string& filename){
std::ifstream infile(filename.c_str());
if (!infile.is_open()){
OCTOMAP_ERROR_STR("Filestream to "<< filename << " not open, nothing read.");
return;
}
readPlainASCII(infile);
infile.close();
}
std::istream& ScanGraph::readPlainASCII(std::istream& s){
std::string currentLine;
ScanNode* currentNode = NULL;
while (true){
getline(s, currentLine);
if (s.good() && !s.eof()){
std::stringstream ss;
ss << currentLine;
// skip empty and comment lines:
if (currentLine.size() == 0
|| (currentLine.compare(0,1, "#") == 0)
|| (currentLine.compare(0,1, " ") == 0)){
continue;
} else if(currentLine.compare(0,4,"NODE")==0){
if (currentNode){
this->nodes.push_back(currentNode);
this->connectPrevious();
OCTOMAP_DEBUG_STR("ScanNode "<< currentNode->pose << " done, size: "<< currentNode->scan->size());
}
currentNode = new ScanNode();
currentNode->scan = new Pointcloud();
float x, y, z, roll, pitch, yaw;
std::string tmp;
ss >> tmp >> x >> y >> z >> roll >> pitch >> yaw;
pose6d pose(x, y, z, roll, pitch, yaw);
//std::cout << "Pose "<< pose << " found.\n";
currentNode->pose = pose;
} else{
if (currentNode == NULL){
// TODO: allow "simple" pc files by setting initial Scan Pose to (0,0,0)
OCTOMAP_ERROR_STR("Error parsing log file, no Scan to add point to!");
break;
}
float x, y, z;
ss >> x >> y >> z;
//std::cout << "Point "<< x << "," <<y <<"," <<z << " found.\n";
currentNode->scan->push_back(x,y,z);
}
} else{
if (currentNode){
this->nodes.push_back(currentNode);
this->connectPrevious();
OCTOMAP_DEBUG_STR("Final ScanNode "<< currentNode->pose << " done, size: "<< currentNode->scan->size());
}
break;
}
}
return s;
}
std::ostream& ScanGraph::writeEdgesASCII(std::ostream &s) const {
// file structure: n | edge_1 | ... | edge_n
OCTOMAP_DEBUG_STR("Writing " << this->edges.size() << " edges to ASCII file...");
s << " " << this->edges.size();
s << std::endl;
for (ScanGraph::const_edge_iterator it = this->edges_begin(); it != this->edges_end(); it++) {
(*it)->writeASCII(s);
}
s << std::endl;
OCTOMAP_DEBUG_STR("Done.");
return s;
}
std::istream& ScanGraph::readEdgesASCII(std::istream &s) {
unsigned int num_edges = 0;
s >> num_edges;
OCTOMAP_DEBUG("Reading %d edges from ASCII file...\n", num_edges);
if (num_edges > 0) {
for (unsigned int i=0; i<this->edges.size(); i++) delete edges[i];
this->edges.clear();
this->edges.reserve(num_edges);
for (unsigned int i=0; i<num_edges; i++) {
ScanEdge* edge = new ScanEdge();
edge->readASCII(s, *this);
if (!s.fail()) {
this->edges.push_back(edge);
}
else {
OCTOMAP_ERROR("ScanGraph::readBinary: ERROR.\n" );
break;
}
}
}
OCTOMAP_DEBUG("done.\n");
return s;
}
std::ostream& ScanGraph::writeNodePosesASCII(std::ostream &s) const {
OCTOMAP_DEBUG("Writing %lu node poses to ASCII file...\n", (unsigned long) this->size());
for (ScanGraph::const_iterator it = this->begin(); it != this->end(); it++) {
(*it)->writePoseASCII(s);
}
s << std::endl;
OCTOMAP_DEBUG("done.\n");
return s;
}
std::istream& ScanGraph::readNodePosesASCII(std::istream &s) {
for (ScanGraph::const_iterator it = this->begin(); it != this->end(); it++) {
(*it)->readPoseASCII(s);
}
for (ScanGraph::edge_iterator it = this->edges_begin(); it != this->edges_end(); it++) {
ScanNode* first = (*it)->first;
ScanNode* second = (*it)->second;
(*it)->constraint = (first->pose).inv() * second->pose;
}
// constraints and nodes are inconsistent, rewire graph
// for (unsigned int i=0; i<this->edges.size(); i++) delete edges[i];
// this->edges.clear();
// ScanGraph::iterator first_it = this->begin();
// ScanGraph::iterator second_it = first_it+1;
// for ( ; second_it != this->end(); first_it++, second_it++) {
// ScanNode* first = (*first_it);
// ScanNode* second = (*second_it);
// octomath::Pose6D c = (first->pose).inv() * second->pose;
// this->addEdge(first, second, c);
// }
return s;
}
void ScanGraph::cropEachScan(point3d lowerBound, point3d upperBound) {
for (ScanGraph::iterator it = this->begin(); it != this->end(); it++) {
((*it)->scan)->crop(lowerBound, upperBound);
}
}
void ScanGraph::crop(point3d lowerBound, point3d upperBound) {
// for all node in graph...
for (ScanGraph::iterator it = this->begin(); it != this->end(); it++) {
pose6d scan_pose = (*it)->pose;
Pointcloud* pc = new Pointcloud((*it)->scan);
pc->transformAbsolute(scan_pose);
pc->crop(lowerBound, upperBound);
pc->transform(scan_pose.inv());
delete (*it)->scan;
(*it)->scan = pc;
}
}
size_t ScanGraph::getNumPoints(unsigned int max_id) const {
size_t retval = 0;
for (ScanGraph::const_iterator it = this->begin(); it != this->end(); it++) {
retval += (*it)->scan->size();
if ((max_id > 0) && ((*it)->id == max_id)) break;
}
return retval;
}
} // end namespace
| 18,219 | 28.105431 | 123 | cpp |
octomap | octomap-master/octomap/src/binvox2bt.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
/*!
* @file binvox2bt.cpp
* Read files generated by Patrick Min's 3D mesh voxelizer
* ("binvox", available at: http://www.cs.princeton.edu/~min/binvox/)
* and convert the voxel meshes to a single bonsai tree file.
* This file is based on code from http://www.cs.princeton.edu/~min/binvox/read_binvox.cc
*
* @author S. Osswald, University of Freiburg, Copyright (C) 2010.
* License: New BSD License
*/
#ifndef M_PI_2
#define M_PI_2 1.5707963267948966192E0
#endif
#include <string>
#include <fstream>
#include <iostream>
#include <octomap/octomap.h>
#include <cstdlib>
#include <cstring>
using namespace std;
using namespace octomap;
namespace octomap {
typedef unsigned char byte;
}
int main(int argc, char **argv)
{
int version; // binvox file format version (should be 1)
size_t depth, height, width; // dimensions of the voxel grid
size_t size; // number of grid cells (height * width * depth)
float tx, ty, tz; // Translation
float scale; // Scaling factor
bool mark_free = false; // Mark free cells (false = cells remain "unknown")
bool rotate = false; // Fix orientation of webots-exported files
bool show_help = false;
string output_filename;
double minX = 0.0;
double minY = 0.0;
double minZ = 0.0;
double maxX = 0.0;
double maxY = 0.0;
double maxZ = 0.0;
bool applyBBX = false;
bool applyOffset = false;
octomap::point3d offset(0.0, 0.0, 0.0);
OcTree *tree = 0;
if(argc == 1) show_help = true;
for(int i = 1; i < argc && !show_help; i++) {
if(strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-help") == 0 ||
strcmp(argv[i], "--usage") == 0 || strcmp(argv[i], "-usage") == 0 ||
strcmp(argv[i], "-h") == 0
)
show_help = true;
}
if(show_help) {
cout << "Usage: "<<argv[0]<<" [OPTIONS] <binvox filenames>" << endl;
cout << "\tOPTIONS:" << endl;
cout << "\t -o <file> Output filename (default: first input filename + .bt)\n";
cout << "\t --mark-free Mark not occupied cells as 'free' (default: unknown)\n";
cout << "\t --rotate Rotate left by 90 deg. to fix the coordinate system when exported from Webots\n";
cout << "\t --bb <minx> <miny> <minz> <maxx> <maxy> <maxz>: force bounding box for OcTree\n";
cout << "\t --offset <x> <y> <z>: add an offset to the final coordinates\n";
cout << "If more than one binvox file is given, the models are composed to a single bonsai tree->\n";
cout << "All options apply to the subsequent input files.\n\n";
exit(0);
}
for(int i = 1; i < argc; i++) {
// Parse command line arguments
if(strcmp(argv[i], "--mark-free") == 0) {
mark_free = true;
continue;
} else if(strcmp(argv[i], "--no-mark-free") == 0) {
mark_free = false;
continue;
}else if(strcmp(argv[i], "--rotate") == 0) {
rotate = true;
continue;
} else if(strcmp(argv[i], "-o") == 0 && i < argc - 1) {
i++;
output_filename = argv[i];
continue;
} else if (strcmp(argv[i], "--bb") == 0 && i < argc - 7) {
i++;
minX = atof(argv[i]);
i++;
minY = atof(argv[i]);
i++;
minZ = atof(argv[i]);
i++;
maxX = atof(argv[i]);
i++;
maxY = atof(argv[i]);
i++;
maxZ = atof(argv[i]);
applyBBX = true;
continue;
} else if (strcmp(argv[i], "--offset") == 0 && i < argc - 4) {
i++;
offset(0) = (float) atof(argv[i]);
i++;
offset(1) = (float) atof(argv[i]);
i++;
offset(2) = (float) atof(argv[i]);
applyOffset = true;
continue;
}
// Open input file
ifstream *input = new ifstream(argv[i], ios::in | ios::binary);
if(!input->good()) {
cerr << "Error: Could not open input file " << argv[i] << "!" << endl;
exit(1);
} else {
cout << "Reading binvox file " << argv[i] << "." << endl;
if(output_filename.empty()) {
output_filename = string(argv[i]).append(".bt");
}
}
// read header
string line;
*input >> line; // #binvox
if (line.compare("#binvox") != 0) {
cout << "Error: first line reads [" << line << "] instead of [#binvox]" << endl;
delete input;
return 0;
}
*input >> version;
cout << "reading binvox version " << version << endl;
depth = 0;
int done = 0;
while(input->good() && !done) {
*input >> line;
if (line.compare("data") == 0) done = 1;
else if (line.compare("dim") == 0) {
*input >> depth >> height >> width;
}
else if (line.compare("translate") == 0) {
*input >> tx >> ty >> tz;
}
else if (line.compare("scale") == 0) {
*input >> scale;
}
else {
cout << " unrecognized keyword [" << line << "], skipping" << endl;
char c;
do { // skip until end of line
c = input->get();
} while(input->good() && (c != '\n'));
}
}
if (!done) {
cout << " error reading header" << endl;
return 0;
}
if (depth == 0) {
cout << " missing dimensions in header" << endl;
return 0;
}
size = width * height * depth;
int maxSide = std::max(std::max(width, height), depth);
double res = double(scale)/double(maxSide);
if(!tree) {
cout << "Generating octree with leaf size " << res << endl << endl;
tree = new OcTree(res);
}
if (applyBBX){
cout << "Bounding box for Octree: [" << minX << ","<< minY << "," << minZ << " - "
<< maxX << ","<< maxY << "," << maxZ << "]\n";
}
if (applyOffset){
std::cout << "Offset on final map: "<< offset << std::endl;
}
cout << "Read data: ";
cout.flush();
// read voxel data
octomap::byte value;
octomap::byte count;
size_t index = 0;
size_t end_index = 0;
size_t nr_voxels = 0;
size_t nr_voxels_out = 0;
input->unsetf(ios::skipws); // need to read every byte now (!)
*input >> value; // read the linefeed char
while((end_index < size) && input->good()) {
*input >> value >> count;
if (input->good()) {
end_index = index + count;
if (end_index > size) return 0;
for(size_t j=index; j < end_index; j++) {
// Output progress dots
if(j % (size / 20) == 0) {
cout << ".";
cout.flush();
}
// voxel index --> voxel coordinates
size_t y = j % width;
size_t z = (j / width) % height;
size_t x = j / (width * height);
// voxel coordinates --> world coordinates
point3d endpoint((float) ((double) x*res + tx + 0.000001),
(float) ((double) y*res + ty + 0.000001),
(float) ((double) z*res + tz + 0.000001));
if(rotate) {
endpoint.rotate_IP(M_PI_2, 0.0, 0.0);
}
if (applyOffset)
endpoint += offset;
if (!applyBBX || (endpoint(0) <= maxX && endpoint(0) >= minX
&& endpoint(1) <= maxY && endpoint(1) >= minY
&& endpoint(2) <= maxZ && endpoint(2) >= minZ)){
// mark cell in octree as free or occupied
if(mark_free || value == 1) {
tree->updateNode(endpoint, value == 1, true);
}
} else{
nr_voxels_out ++;
}
}
if (value) nr_voxels += count;
index = end_index;
} // if file still ok
} // while
cout << endl << endl;
input->close();
cout << " read " << nr_voxels << " voxels, skipped "<<nr_voxels_out << " (out of bounding box)\n\n";
}
// prune octree
cout << "Pruning octree" << endl << endl;
tree->updateInnerOccupancy();
tree->prune();
// write octree to file
if(output_filename.empty()) {
cerr << "Error: No input files found." << endl << endl;
exit(1);
}
cout << "Writing octree to " << output_filename << endl << endl;
tree->writeBinary(output_filename.c_str());
cout << "done" << endl << endl;
return 0;
}
| 11,019 | 34.207668 | 118 | cpp |
octomap | octomap-master/octomap/src/bt2vrml.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <octomap/octomap.h>
#include <fstream>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <list>
using namespace std;
using namespace octomap;
void printUsage(char* self){
std::cerr << "\nUSAGE: " << self << " input.bt\n\n";
std::cerr << "This tool will convert the occupied voxels of a binary OctoMap \n"
"file input.bt to a VRML2.0 file input.bt.wrl.\n\n";
std::cerr << "WARNING: The output files will be quite large!\n\n";
exit(0);
}
int main(int argc, char** argv) {
// default values:
string vrmlFilename = "";
string btFilename = "";
if (argc != 2 || (argc > 1 && strcmp(argv[1], "-h") == 0)){
printUsage(argv[0]);
}
btFilename = std::string(argv[1]);
vrmlFilename = btFilename + ".wrl";
cout << "\nReading OcTree file\n===========================\n";
// TODO: check if file exists and if OcTree read correctly?
OcTree* tree = new OcTree(btFilename);
cout << "\nWriting occupied volumes to VRML\n===========================\n";
std::ofstream outfile (vrmlFilename.c_str());
outfile << "#VRML V2.0 utf8\n#\n";
outfile << "# created from OctoMap file "<<btFilename<< " with bt2vrml\n";
size_t count(0);
for(OcTree::leaf_iterator it = tree->begin(), end=tree->end(); it!= end; ++it) {
if(tree->isNodeOccupied(*it)){
count++;
double size = it.getSize();
outfile << "Transform { translation "
<< it.getX() << " " << it.getY() << " " << it.getZ()
<< " \n children ["
<< " Shape { geometry Box { size "
<< size << " " << size << " " << size << "} } ]\n"
<< "}\n";
}
}
delete tree;
outfile.close();
std::cout << "Finished writing "<< count << " voxels to " << vrmlFilename << std::endl;
return 0;
}
| 3,561 | 33.582524 | 89 | cpp |
octomap | octomap-master/octomap/src/compare_octrees.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <octomap/octomap.h>
#include <fstream>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <list>
#include <cmath>
#ifdef _MSC_VER // fix missing isnan for VC++
#define isnan(x) _isnan(x)
#endif
// on MacOS, isnan is in std (also C++11)
using namespace std;
using namespace octomap;
void printUsage(char* self){
std::cerr << "\nUSAGE: " << self << " tree1.ot tree2.ot\n\n";
std::cerr << "Compare two octrees for accuracy / compression.\n\n";
exit(0);
}
int main(int argc, char** argv) {
if (argc != 3 || (argc > 1 && strcmp(argv[1], "-h") == 0)){
printUsage(argv[0]);
}
std::string filename1 = std::string(argv[1]);
std::string filename2 = std::string(argv[2]);
cout << "\nReading octree files...\n";
OcTree* tree1 = dynamic_cast<OcTree*>(OcTree::read(filename1));
OcTree* tree2 = dynamic_cast<OcTree*>(OcTree::read(filename2));
if (fabs(tree1->getResolution()-tree2->getResolution()) > 1e-6){
OCTOMAP_ERROR("Error: Tree resolutions don't match!");
exit(-1);
}
cout << "Expanding octrees... \n";
// expand both to full resolution:
tree1->expand();
tree2->expand();
if (tree1->getNumLeafNodes() != tree2->getNumLeafNodes()){
OCTOMAP_ERROR_STR("Octrees have different size: " << tree1->getNumLeafNodes() << "!=" <<tree2->getNumLeafNodes() << endl);
exit(-1);
}
cout << "Expanded num. leafs: " << tree1->getNumLeafNodes() << endl;
// check bbx:
double x1, x2, y1, y2, z1, z2;
tree1->getMetricSize(x1, y1, z1);
tree2->getMetricSize(x2, y2, z2);
if ((fabs(x1-x2) > 1e-6)
|| (fabs(y1-y2) > 1e-6)
|| (fabs(z1-z2) > 1e-6))
{
OCTOMAP_WARNING("Trees span over different volumes, results may be wrong\n");
exit(1);
}
double kld_sum = 0.0;
cout << "Comparing trees... \n";
for (OcTree::leaf_iterator it = tree1->begin_leafs(),
end = tree1->end_leafs(); it != end; ++it)
{
OcTreeNode* n = tree2->search(it.getKey());
if (!n){
OCTOMAP_ERROR("Could not find coordinate of 1st octree in 2nd octree\n");
} else{
// check occupancy prob:
double p1 = it->getOccupancy();
double p2 = n->getOccupancy();
if (p1 < 0.0 || p1 > 1.0)
OCTOMAP_ERROR("p1 wrong: %f", p1);
if (p2 < 0.0 || p2 > 1.0)
OCTOMAP_ERROR("p2 wrong: %f", p2);
// if (p1 > 0.1 || p2 > 0.1)
if (p1 > 0.001 && p2 < 0.001)
OCTOMAP_WARNING("p2 near 0, p1 > 0 => inf?");
if (p1 < 0.999 && p2 > 0.999)
OCTOMAP_WARNING("p2 near 1, p1 < 1 => inf?");
double kld = 0;
if (p1 < 0.0001)
kld =log((1-p1)/(1-p2))*(1-p1);
else if (p1 > 0.9999)
kld =log(p1/p2)*p1;
else
kld +=log(p1/p2)*p1 + log((1-p1)/(1-p2))*(1-p1);
#if __cplusplus >= 201103L
if (std::isnan(kld)){
#else
if (isnan(kld)){
#endif
OCTOMAP_ERROR("KLD is nan! KLD(%f,%f)=%f; sum = %f", p1, p2, kld, kld_sum);
exit(-1);
}
kld_sum+=kld;
//if (p1 <)
// if (fabs(p1-p2) > 1e-6)
// cout << "diff: " << p1-p2 << endl;
}
}
cout << "KLD: " << kld_sum << endl;
delete tree1;
delete tree2;
return 0;
}
| 4,955 | 29.404908 | 128 | cpp |
octomap | octomap-master/octomap/src/convert_octree.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <octomap/AbstractOcTree.h>
#include <octomap/OcTree.h>
#include <octomap/ColorOcTree.h>
#include <fstream>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <list>
using namespace std;
using namespace octomap;
void printUsage(char* self){
std::cerr << "\nUSAGE: " << self << " input.(ot|bt|cot) [output.ot]\n\n";
std::cerr << "This tool converts between OctoMap octree file formats, \n"
"e.g. to convert old legacy files to the new .ot format or to convert \n"
"between .bt and .ot files. The default output format is .ot.\n\n";
exit(0);
}
int main(int argc, char** argv) {
string inputFilename = "";
string outputFilename = "";
if (argc < 2 || argc > 3 || (argc > 1 && strcmp(argv[1], "-h") == 0)){
printUsage(argv[0]);
}
inputFilename = std::string(argv[1]);
if (argc == 3)
outputFilename = std::string(argv[2]);
else{
outputFilename = inputFilename + ".ot";
}
cout << "\nReading OcTree file\n===========================\n";
std::ifstream file(inputFilename.c_str(), std::ios_base::in |std::ios_base::binary);
if (!file.is_open()){
OCTOMAP_ERROR_STR("Filestream to "<< inputFilename << " not open, nothing read.");
exit(-1);
}
std::istream::pos_type streampos = file.tellg();
AbstractOcTree* tree;
// reading binary:
if (inputFilename.length() > 3 && (inputFilename.compare(inputFilename.length()-3, 3, ".bt") == 0)){
OcTree* binaryTree = new OcTree(0.1);
if (binaryTree->readBinary(file) && binaryTree->size() > 1)
tree = binaryTree;
else {
OCTOMAP_ERROR_STR("Could not detect binary OcTree format in file.");
exit(-1);
}
} else {
tree = AbstractOcTree::read(file);
if (!tree){
OCTOMAP_WARNING_STR("Could not detect OcTree in file, trying legacy formats.");
// TODO: check if .cot extension, try old format only then
// reset and try old ColorOcTree format:
file.clear(); // clear eofbit of istream
file.seekg(streampos);
ColorOcTree* colorTree = new ColorOcTree(0.1);
colorTree->readData(file);
if (colorTree->size() > 1 && file.good()){
OCTOMAP_WARNING_STR("Detected Binary ColorOcTree to convert. \nPlease check and update the new file header (resolution will likely be wrong).");
tree = colorTree;
} else{
delete colorTree;
std::cerr << "Error reading from file " << inputFilename << std::endl;
exit(-1);
}
}
}
// close filestream
file.close();
if (outputFilename.length() > 3 && (outputFilename.compare(outputFilename.length()-3, 3, ".bt") == 0)){
std::cerr << "Writing binary (BonsaiTree) file" << std::endl;
AbstractOccupancyOcTree* octree = dynamic_cast<AbstractOccupancyOcTree*>(tree);
if (octree){
if (!octree->writeBinary(outputFilename)){
std::cerr << "Error writing to " << outputFilename << std::endl;
exit(-2);
}
} else {
std::cerr << "Error: Writing to .bt is not supported for this tree type: " << tree->getTreeType() << std::endl;
exit(-2);
}
} else{
std::cerr << "Writing general OcTree file" << std::endl;
if (!tree->write(outputFilename)){
std::cerr << "Error writing to " << outputFilename << std::endl;
exit(-2);
}
}
std::cout << "Finished writing to " << outputFilename << std::endl;
return 0;
}
| 5,176 | 33.744966 | 152 | cpp |
octomap | octomap-master/octomap/src/edit_octree.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <string>
#include <fstream>
#include <iostream>
#include <octomap/octomap.h>
#include <cstdlib>
#include <cstring>
using namespace std;
using namespace octomap;
int main(int argc, char **argv)
{
//bool rotate = false; // Fix orientation of webots-exported files
bool show_help = false;
string outputFilename("");
string inputFilename("");
// double minX = 0.0;
// double minY = 0.0;
// double minZ = 0.0;
// double maxX = 0.0;
// double maxY = 0.0;
// double maxZ = 0.0;
// bool applyBBX = false;
// bool applyOffset = false;
octomap::point3d offset(0.0, 0.0, 0.0);
double scale = 1.0;
double res = -1.0;
if(argc == 1) show_help = true;
for(int i = 1; i < argc && !show_help; i++) {
if(strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-help") == 0 ||
strcmp(argv[i], "--usage") == 0 || strcmp(argv[i], "-usage") == 0 ||
strcmp(argv[i], "-h") == 0
)
show_help = true;
}
if(show_help) {
cout << "Usage: "<<argv[0]<<" [OPTIONS] <filename.bt>" << endl;
cout << "\tOPTIONS:" << endl;
cout << "\t -o <file> Output filename (default: first input filename + .bt)" << endl;
// cout << "\t --mark-free Mark not occupied cells as 'free' (default: unknown)" << endl;
// cout << "\t --rotate Rotate left by 90 deg. to fix the coordinate system when exported from Webots" << endl;
cout << "\t --offset <x> <y> <z>: add an offset to the octree coordinates (translation)\n";
// cout << "\t --bb <minx> <miny> <minz> <maxx> <maxy> <maxz>: force bounding box for OcTree" << endl;
cout << "\t --res <resolution>: set ressolution of OcTree to new value\n";
cout << "\t --scale <scale>: scale octree resolution by a value\n";
exit(0);
}
for(int i = 1; i < argc; i++) {
// Parse command line arguments
if(strcmp(argv[i], "--rotate") == 0) {
OCTOMAP_WARNING_STR(argv[i] << " not yet implemented!\n");
//rotate = true;
continue;
} else if(strcmp(argv[i], "-o") == 0 && i < argc - 1) {
i++;
outputFilename = argv[i];
continue;
} else if (strcmp(argv[i], "--bb") == 0 && i < argc - 7) {
OCTOMAP_WARNING_STR(argv[i] << " not yet implemented!\n");
i++;
//minX = atof(argv[i]);
i++;
//minY = atof(argv[i]);
i++;
//minZ = atof(argv[i]);
i++;
//maxX = atof(argv[i]);
i++;
//maxY = atof(argv[i]);
i++;
//maxZ = atof(argv[i]);
//applyBBX = true;
continue;
} else if (strcmp(argv[i], "--res") == 0 && i < argc - 1) {
i++;
res = atof(argv[i]);
continue;
} else if (strcmp(argv[i], "--scale") == 0 && i < argc - 1) {
i++;
scale = atof(argv[i]);
continue;
} else if (strcmp(argv[i], "--offset") == 0 && i < argc - 4) {
OCTOMAP_WARNING_STR(argv[i] << " not yet implemented!\n");
i++;
offset(0) = (float) atof(argv[i]);
i++;
offset(1) = (float) atof(argv[i]);
i++;
offset(2) = (float) atof(argv[i]);
//applyOffset = true;
continue;
} else if (i == argc-1){
inputFilename = string(argv[i]);
}
}
if (outputFilename == ""){
outputFilename = inputFilename + ".edit.bt";
}
OcTree* tree = new OcTree(0.1);
if (!tree->readBinary(inputFilename)){
OCTOMAP_ERROR("Could not open file, exiting.\n");
exit(1);
}
// apply scale / resolution setting:
if (scale != 1.0){
res = tree->getResolution() * scale;
}
if (res > 0.0){
std::cout << "Setting new tree resolution: " << res << std::endl;
tree->setResolution(res);
}
// TODO: implement rest (move, bounding box, rotation...)
// size = width * height * depth;
// double res = double(scale)/double(depth);
//
// if(!tree) {
// cout << "Generate labeled octree with leaf size " << res << endl << endl;
// tree = new OcTree(res);
// }
//
// if (applyBBX){
// cout << "Bounding box for Octree: [" << minX << ","<< minY << "," << minZ << " - "
// << maxX << ","<< maxY << "," << maxZ << "]\n";
//
// }
// if (applyOffset){
// std::cout << "Offset on final map: "<< offset << std::endl;
//
// }
//
//
// if(rotate) {
// endpoint.rotate_IP(M_PI_2, 0.0, 0.0);
// }
// if (applyOffset)
// endpoint += offset;
//
// if (!applyBBX || (endpoint(0) <= maxX && endpoint(0) >= minX
// && endpoint(1) <= maxY && endpoint(1) >= minY
// && endpoint(2) <= maxZ && endpoint(2) >= minZ)){
//
// // mark cell in octree as free or occupied
// if(mark_free || value == 1) {
// tree->updateNode(endpoint, value == 1);
// }
// } else{
// nr_voxels_out ++;
// }
// }
//
// // prune octree
// cout << "Prune octree" << endl << endl;
// tree->prune();
// write octree to file
cout << "Writing octree to " << outputFilename << endl;
if (!tree->writeBinary(outputFilename)){
OCTOMAP_ERROR("Error writing tree to %s\n", outputFilename.c_str());
exit(1);
}
cout << "done" << endl << endl;
delete tree;
return 0;
}
| 7,310 | 31.493333 | 126 | cpp |
octomap | octomap-master/octomap/src/eval_octree_accuracy.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>
#include <octomap/octomap.h>
#include <octomap/octomap_timing.h>
using namespace std;
using namespace octomap;
void printUsage(char* self){
std::cerr << "USAGE: " << self << " <InputFile.graph>\n";
std::cerr << "This tool is part of OctoMap and evaluates the statistical accuracy\n"
"of an octree map from scan graph data (point clouds with poses).\n";
std::cerr << "OPTIONS:\n"
" -res <resolution> (default: 0.1 m)\n"
" -m <maxrange> (optional) \n"
" -n <max scan no.> (optional) \n"
"\n";
exit(0);
}
int main(int argc, char** argv) {
// default values:
double res = 0.1;
if (argc < 2)
printUsage(argv[0]);
string graphFilename = std::string(argv[1]);
double maxrange = -1;
int max_scan_no = -1;
int skip_scan_eval = 5;
int arg = 1;
while (++arg < argc) {
if (! strcmp(argv[arg], "-i"))
graphFilename = std::string(argv[++arg]);
else if (! strcmp(argv[arg], "-res"))
res = atof(argv[++arg]);
else if (! strcmp(argv[arg], "-m"))
maxrange = atof(argv[++arg]);
else if (! strcmp(argv[arg], "-n"))
max_scan_no = atoi(argv[++arg]);
else {
printUsage(argv[0]);
}
}
cout << "\nReading Graph file\n===========================\n";
ScanGraph* graph = new ScanGraph();
if (!graph->readBinary(graphFilename))
exit(2);
size_t num_points_in_graph = 0;
if (max_scan_no > 0) {
num_points_in_graph = graph->getNumPoints(max_scan_no-1);
cout << "\n Data points in graph up to scan " << max_scan_no << ": " << num_points_in_graph << endl;
}
else {
num_points_in_graph = graph->getNumPoints();
cout << "\n Data points in graph: " << num_points_in_graph << endl;
}
cout << "\nCreating tree\n===========================\n";
OcTree* tree = new OcTree(res);
size_t numScans = graph->size();
unsigned int currentScan = 1;
for (ScanGraph::iterator scan_it = graph->begin(); scan_it != graph->end(); scan_it++) {
if (currentScan % skip_scan_eval != 0){
if (max_scan_no > 0) cout << "("<<currentScan << "/" << max_scan_no << ") " << flush;
else cout << "("<<currentScan << "/" << numScans << ") " << flush;
tree->insertPointCloud(**scan_it, maxrange);
} else
cout << "(SKIP) " << flush;
if ((max_scan_no > 0) && (currentScan == (unsigned int) max_scan_no))
break;
currentScan++;
}
tree->expand();
cout << "\nEvaluating scans\n===========================\n";
currentScan = 1;
size_t num_points = 0;
size_t num_voxels_correct = 0;
size_t num_voxels_wrong = 0;
size_t num_voxels_unknown = 0;
for (ScanGraph::iterator scan_it = graph->begin(); scan_it != graph->end(); scan_it++) {
if (currentScan % skip_scan_eval == 0){
if (max_scan_no > 0) cout << "("<<currentScan << "/" << max_scan_no << ") " << flush;
else cout << "("<<currentScan << "/" << numScans << ") " << flush;
pose6d frame_origin = (*scan_it)->pose;
point3d sensor_origin = frame_origin.inv().transform((*scan_it)->pose.trans());
// transform pointcloud:
Pointcloud scan (*(*scan_it)->scan);
scan.transform(frame_origin);
point3d origin = frame_origin.transform(sensor_origin);
KeySet free_cells, occupied_cells;
tree->computeUpdate(scan, origin, free_cells, occupied_cells, maxrange);
num_points += scan.size();
// count free cells
for (KeySet::iterator it = free_cells.begin(); it != free_cells.end(); ++it) {
OcTreeNode* n = tree->search(*it);
if (n){
if (tree->isNodeOccupied(n))
num_voxels_wrong++;
else
num_voxels_correct++;
} else
num_voxels_unknown++;
} // count occupied cells
for (KeySet::iterator it = occupied_cells.begin(); it != occupied_cells.end(); ++it) {
OcTreeNode* n = tree->search(*it);
if (n){
if (tree->isNodeOccupied(n))
num_voxels_correct++;
else
num_voxels_wrong++;
} else
num_voxels_unknown++;
}
}
if ((max_scan_no > 0) && (currentScan == (unsigned int) max_scan_no))
break;
currentScan++;
}
cout << "\nFinished evaluating " << num_points <<"/"<< num_points_in_graph << " points.\n"
<<"Voxels correct: "<<num_voxels_correct<<" #wrong: " <<num_voxels_wrong << " #unknown: " <<num_voxels_unknown
<<". % correct: "<< num_voxels_correct/double(num_voxels_correct+num_voxels_wrong)<<"\n\n";
delete graph;
delete tree;
return 0;
}
| 6,439 | 31.690355 | 116 | cpp |
octomap | octomap-master/octomap/src/graph2tree.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>
#include <octomap/octomap.h>
#include <octomap/octomap_timing.h>
using namespace std;
using namespace octomap;
void printUsage(char* self){
std::cerr << "USAGE: " << self << " [options]\n\n";
std::cerr << "This tool is part of OctoMap and inserts the data of a scan graph\n"
"file (point clouds with poses) into an octree.\n"
"The output is a compact maximum-likelihood binary octree file \n"
"(.bt, bonsai tree) and general octree files (.ot) with the full\n"
"information.\n\n";
std::cerr << "OPTIONS:\n -i <InputFile.graph> (required)\n"
" -o <OutputFile.bt> (required) \n"
" -res <resolution> (optional, default: 0.1 m)\n"
" -m <maxrange> (optional) \n"
" -n <max scan no.> (optional) \n"
" -log (enable a detailed log file with statistics) \n"
" -g (nodes are already in global coordinates and no transformation is required) \n"
" -compressML (enable maximum-likelihood compression (lossy) after every scan)\n"
" -simple (simple scan insertion ray by ray instead of optimized) \n"
" -discretize (approximate raycasting on discretized coordinates, speeds up insertion) \n"
" -clamping <p_min> <p_max> (override default sensor model clamping probabilities between 0..1)\n"
" -sensor <p_miss> <p_hit> (override default sensor model hit and miss probabilities between 0..1)"
"\n";
exit(0);
}
void calcThresholdedNodes(const OcTree* tree,
unsigned int& num_thresholded,
unsigned int& num_other)
{
num_thresholded = 0;
num_other = 0;
for(OcTree::tree_iterator it = tree->begin_tree(), end=tree->end_tree(); it!= end; ++it){
if (tree->isNodeAtThreshold(*it))
num_thresholded++;
else
num_other++;
}
}
void outputStatistics(const OcTree* tree){
unsigned int numThresholded, numOther;
calcThresholdedNodes(tree, numThresholded, numOther);
size_t memUsage = tree->memoryUsage();
unsigned long long memFullGrid = tree->memoryFullGrid();
size_t numLeafNodes = tree->getNumLeafNodes();
cout << "Tree size: " << tree->size() <<" nodes (" << numLeafNodes<< " leafs). " <<numThresholded <<" nodes thresholded, "<< numOther << " other\n";
cout << "Memory: " << memUsage << " byte (" << memUsage/(1024.*1024.) << " MB)" << endl;
cout << "Full grid: "<< memFullGrid << " byte (" << memFullGrid/(1024.*1024.) << " MB)" << endl;
double x, y, z;
tree->getMetricSize(x, y, z);
cout << "Size: " << x << " x " << y << " x " << z << " m^3\n";
cout << endl;
}
int main(int argc, char** argv) {
// default values:
double res = 0.1;
string graphFilename = "";
string treeFilename = "";
double maxrange = -1;
int max_scan_no = -1;
bool detailedLog = false;
bool simpleUpdate = false;
bool discretize = false;
bool dontTransformNodes = false;
unsigned char compression = 1;
// get default sensor model values:
OcTree emptyTree(0.1);
double clampingMin = emptyTree.getClampingThresMin();
double clampingMax = emptyTree.getClampingThresMax();
double probMiss = emptyTree.getProbMiss();
double probHit = emptyTree.getProbHit();
timeval start;
timeval stop;
int arg = 0;
while (++arg < argc) {
if (! strcmp(argv[arg], "-i"))
graphFilename = std::string(argv[++arg]);
else if (!strcmp(argv[arg], "-o"))
treeFilename = std::string(argv[++arg]);
else if (! strcmp(argv[arg], "-res") && argc-arg < 2)
printUsage(argv[0]);
else if (! strcmp(argv[arg], "-res"))
res = atof(argv[++arg]);
else if (! strcmp(argv[arg], "-log"))
detailedLog = true;
else if (! strcmp(argv[arg], "-g"))
dontTransformNodes = true;
else if (! strcmp(argv[arg], "-simple"))
simpleUpdate = true;
else if (! strcmp(argv[arg], "-discretize"))
discretize = true;
else if (! strcmp(argv[arg], "-compress"))
OCTOMAP_WARNING("Argument -compress no longer has an effect, incremental pruning is done during each insertion.\n");
else if (! strcmp(argv[arg], "-compressML"))
compression = 2;
else if (! strcmp(argv[arg], "-m"))
maxrange = atof(argv[++arg]);
else if (! strcmp(argv[arg], "-n"))
max_scan_no = atoi(argv[++arg]);
else if (! strcmp(argv[arg], "-clamping") && (argc-arg < 3))
printUsage(argv[0]);
else if (! strcmp(argv[arg], "-clamping")){
clampingMin = atof(argv[++arg]);
clampingMax = atof(argv[++arg]);
}
else if (! strcmp(argv[arg], "-sensor") && (argc-arg < 3))
printUsage(argv[0]);
else if (! strcmp(argv[arg], "-sensor")){
probMiss = atof(argv[++arg]);
probHit = atof(argv[++arg]);
}
else {
printUsage(argv[0]);
}
}
if (graphFilename == "" || treeFilename == "")
printUsage(argv[0]);
// verify input:
if (res <= 0.0){
OCTOMAP_ERROR("Resolution must be positive");
exit(1);
}
if (clampingMin >= clampingMax || clampingMin < 0.0 || clampingMax > 1.0){
OCTOMAP_ERROR("Error in clamping values: 0.0 <= [%f] < [%f] <= 1.0\n", clampingMin, clampingMax);
exit(1);
}
if (probMiss >= probHit || probMiss < 0.0 || probHit > 1.0){
OCTOMAP_ERROR("Error in sensor model (hit/miss prob.): 0.0 <= [%f] < [%f] <= 1.0\n", probMiss, probHit);
exit(1);
}
std::string treeFilenameOT = treeFilename + ".ot";
std::string treeFilenameMLOT = treeFilename + "_ml.ot";
cout << "\nReading Graph file\n===========================\n";
ScanGraph* graph = new ScanGraph();
if (!graph->readBinary(graphFilename))
exit(2);
size_t num_points_in_graph = 0;
if (max_scan_no > 0) {
num_points_in_graph = graph->getNumPoints(max_scan_no-1);
cout << "\n Data points in graph up to scan " << max_scan_no << ": " << num_points_in_graph << endl;
}
else {
num_points_in_graph = graph->getNumPoints();
cout << "\n Data points in graph: " << num_points_in_graph << endl;
}
// transform pointclouds first, so we can directly operate on them later
if (!dontTransformNodes) {
for (ScanGraph::iterator scan_it = graph->begin(); scan_it != graph->end(); scan_it++) {
pose6d frame_origin = (*scan_it)->pose;
point3d sensor_origin = frame_origin.inv().transform((*scan_it)->pose.trans());
(*scan_it)->scan->transform(frame_origin);
point3d transformed_sensor_origin = frame_origin.transform(sensor_origin);
(*scan_it)->pose = pose6d(transformed_sensor_origin, octomath::Quaternion());
}
}
std::ofstream logfile;
if (detailedLog){
logfile.open((treeFilename+".log").c_str());
logfile << "# Memory of processing " << graphFilename << " over time\n";
logfile << "# Resolution: "<< res <<"; compression: " << int(compression) << "; scan endpoints: "<< num_points_in_graph << std::endl;
logfile << "# [scan number] [bytes octree] [bytes full 3D grid]\n";
}
cout << "\nCreating tree\n===========================\n";
OcTree* tree = new OcTree(res);
tree->setClampingThresMin(clampingMin);
tree->setClampingThresMax(clampingMax);
tree->setProbHit(probHit);
tree->setProbMiss(probMiss);
gettimeofday(&start, NULL); // start timer
size_t numScans = graph->size();
size_t currentScan = 1;
for (ScanGraph::iterator scan_it = graph->begin(); scan_it != graph->end(); scan_it++) {
if (max_scan_no > 0) cout << "("<<currentScan << "/" << max_scan_no << ") " << flush;
else cout << "("<<currentScan << "/" << numScans << ") " << flush;
if (simpleUpdate)
tree->insertPointCloudRays((*scan_it)->scan, (*scan_it)->pose.trans(), maxrange);
else
tree->insertPointCloud((*scan_it)->scan, (*scan_it)->pose.trans(), maxrange, false, discretize);
if (compression == 2){
tree->toMaxLikelihood();
tree->prune();
}
if (detailedLog)
logfile << currentScan << " " << tree->memoryUsage() << " " << tree->memoryFullGrid() << "\n";
if ((max_scan_no > 0) && (currentScan == (unsigned int) max_scan_no))
break;
currentScan++;
}
gettimeofday(&stop, NULL); // stop timer
double time_to_insert = (stop.tv_sec - start.tv_sec) + 1.0e-6 *(stop.tv_usec - start.tv_usec);
// get rid of graph in mem before doing anything fancy with tree (=> memory)
delete graph;
if (logfile.is_open())
logfile.close();
cout << "\nDone building tree.\n\n";
cout << "time to insert scans: " << time_to_insert << " sec" << endl;
cout << "time to insert 100.000 points took: " << time_to_insert/ ((double) num_points_in_graph / 100000) << " sec (avg)" << endl << endl;
std::cout << "Pruned tree (lossless compression)\n" << "===========================\n";
outputStatistics(tree);
tree->write(treeFilenameOT);
std::cout << "Pruned max-likelihood tree (lossy compression)\n" << "===========================\n";
tree->toMaxLikelihood();
tree->prune();
outputStatistics(tree);
cout << "\nWriting tree files\n===========================\n";
tree->write(treeFilenameMLOT);
std::cout << "Full Octree (pruned) written to "<< treeFilenameOT << std::endl;
std::cout << "Full Octree (max.likelihood, pruned) written to "<< treeFilenameMLOT << std::endl;
tree->writeBinary(treeFilename);
std::cout << "Bonsai tree written to "<< treeFilename << std::endl;
cout << endl;
delete tree;
return 0;
}
| 11,292 | 35.546926 | 150 | cpp |
octomap | octomap-master/octomap/src/intersection_example.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <vector>
#include <string>
#include <octomap/octomap.h>
#include <octomap/OcTree.h>
using namespace std;
using namespace octomap;
int main(int /*argc*/, char** /*argv*/) {
cout << "generating example map" << endl;
OcTree tree (0.1); // create empty tree with resolution 0.1
// insert some measurements of free cells
for (float x = -2; x <= 0; x += 0.02f) {
for (float y = -2; y <= 0; y += 0.02f) {
for (float z = -2; z <= 0; z += 0.02f) {
point3d endpoint(x, y, z);
tree.updateNode(endpoint, false); // integrate 'free' measurement
}
}
}
// insert some measurements of occupied cells (twice as much)
for (float x = -1; x <= 0; x += 0.01f) {
for (float y = -1; y <= 0; y += 0.01f) {
for (float z = -1; z <= 0; z += 0.01f) {
point3d endpoint(x, y, z);
tree.updateNode(endpoint, true); // integrate 'occupied' measurement
}
}
}
point3d origin(-1.5, -1.5, -0.5);
point3d direction;
point3d ray_end;
for(float z = 0; z <= 0.25; z += 0.125){
direction = point3d(1, 1, z);
cout << endl;
cout << "casting ray from " << origin << " in the " << direction << " direction"<< endl;
bool success = tree.castRay(origin, direction, ray_end);
if(success){
cout << "ray hit cell with center " << ray_end << endl;
point3d intersection;
success = tree.getRayIntersection(origin, direction, ray_end, intersection);
if(success)
cout << "entrance point is " << intersection << endl;
}
}
return 0;
}
| 3,346 | 34.989247 | 93 | cpp |
octomap | octomap-master/octomap/src/log2graph.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <octomap/octomap.h>
#include <string.h>
#include <stdlib.h>
using namespace std;
using namespace octomap;
void printUsage(char* self){
std::cerr << "\nUSAGE: " << self << " InputFile.log OutputFile.graph\n\n";
std::cerr << "This tool converts a plain text log file into a binary scangraph file" << std::endl;
std::cerr << "which can be used in Octomap.\n\n";
std::cerr << "The log file needs to be in the format of:\n"
<< "NODE x y z roll pitch yaw\n"
<< "x y z\nx y z\n...\n"
<< "NODE x y z roll pitch yaw\n"
<< "x y z\n...\n\n"
<< "Lines starting with '#' or empty lines are ignored.\n\n";
exit(0);
}
int main(int argc, char** argv) {
// default values:
string logFilename = "";
string graphFilename = "";
if (argc != 3){
printUsage(argv[0]);
} else{
logFilename = std::string(argv[1]);
graphFilename = std::string(argv[2]);
}
cout << "\nReading Log file\n===========================\n";
ScanGraph* graph = new ScanGraph();
graph->readPlainASCII(logFilename);
cout << "\nWriting binary graph file\n===========================\n";
graph->writeBinary(graphFilename);
return 0;
}
| 2,957 | 36.443038 | 100 | cpp |
octomap | octomap-master/octomap/src/normals_example.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <vector>
#include <string>
#include <octomap/octomap.h>
#include <octomap/OcTree.h>
using namespace std;
using namespace octomap;
void print_query_info(point3d query, OcTreeNode* node) {
if (node != NULL) {
cout << "occupancy probability at " << query << ":\t " << node->getOccupancy() << endl;
}
else
cout << "occupancy probability at " << query << ":\t is unknown" << endl;
}
int main(int /*argc*/, char** /*argv*/) {
cout << endl;
cout << "generating example map" << endl;
OcTree tree (0.1); // create empty tree with resolution 0.1
// insert some measurements of occupied cells
for (int x=-20; x<20; x++) {
for (int y=-20; y<20; y++) {
for (int z=-20; z<20; z++) {
point3d endpoint ((float) x*0.05f, (float) y*0.05f, (float) z*0.05f);
tree.updateNode(endpoint, true); // integrate 'occupied' measurement
}
}
}
// insert some measurements of free cells
for (int x=-30; x<30; x++) {
for (int y=-30; y<30; y++) {
for (int z=-30; z<30; z++) {
point3d endpoint ((float) x*0.02f-1.0f, (float) y*0.02f-1.0f, (float) z*0.02f-1.0f);
tree.updateNode(endpoint, false); // integrate 'free' measurement
}
}
}
cout << endl;
cout << "performing some queries around the desired voxel:" << endl;
point3d query;
OcTreeNode* result = NULL;
for(float z = -0.6f; z < -0.21f; z += 0.1f){
for(float y = -0.6f; y < -0.21f; y += 0.1f){
for(float x = -0.6f; x < -0.21f; x += 0.1f){
query = point3d(x, y, z);
result = tree.search(query);
print_query_info(query, result);
}
}
}
query = point3d(-0.5f, -0.4f, -0.4f);
result = tree.search(query);
vector<point3d> normals;
if (tree.getNormals(query, normals)){
cout << endl;
string s_norm = (normals.size() > 1) ? " normals " : " normal ";
cout << "MC algorithm gives " << normals.size() << s_norm << "in voxel at " << query << endl;
for(unsigned i = 0; i < normals.size(); ++i)
cout << "\t" << normals[i].x() << "; " << normals[i].y() << "; " << normals[i].z() << endl;
} else{
cout << "query point unknown (no normals)\n";
}
}
| 3,971 | 34.150442 | 97 | cpp |
octomap | octomap-master/octomap/src/octree2pointcloud.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>
#include <octomap/octomap.h>
#include <octomap/octomap_timing.h>
using namespace std;
using namespace octomap;
void printUsage(char* self){
cerr << "USAGE: " << self << " <InputFile.bt> <OutputFile.pcd>\n";
cerr << "This tool creates a point cloud of the occupied cells\n";
exit(0);
}
int main(int argc, char** argv) {
if (argc != 3)
printUsage(argv[0]);
string inputFilename = argv[1];
string outputFilename = argv[2];
OcTree* tree = new OcTree(0.1);
if (!tree->readBinary(inputFilename)){
OCTOMAP_ERROR("Could not open file, exiting.\n");
exit(1);
}
unsigned int maxDepth = tree->getTreeDepth();
cout << "tree depth is " << maxDepth << endl;
// expand collapsed occupied nodes until all occupied leaves are at maximum depth
vector<OcTreeNode*> collapsed_occ_nodes;
do {
collapsed_occ_nodes.clear();
for (OcTree::iterator it = tree->begin(); it != tree->end(); ++it)
{
if(tree->isNodeOccupied(*it) && it.getDepth() < maxDepth)
{
collapsed_occ_nodes.push_back(&(*it));
}
}
for (vector<OcTreeNode*>::iterator it = collapsed_occ_nodes.begin(); it != collapsed_occ_nodes.end(); ++it)
{
tree->expandNode(*it);
}
cout << "expanded " << collapsed_occ_nodes.size() << " nodes" << endl;
} while(collapsed_occ_nodes.size() > 0);
vector<point3d> pcl;
for (OcTree::iterator it = tree->begin(); it != tree->end(); ++it)
{
if(tree->isNodeOccupied(*it))
{
pcl.push_back(it.getCoordinate());
}
}
delete tree;
ofstream f(outputFilename.c_str(), ofstream::out);
f << "# .PCD v0.7" << endl
<< "VERSION 0.7" << endl
<< "FIELDS x y z" << endl
<< "SIZE 4 4 4" << endl
<< "TYPE F F F" << endl
<< "COUNT 1 1 1" << endl
<< "WIDTH " << pcl.size() << endl
<< "HEIGHT 1" << endl
<< "VIEWPOINT 0 0 0 0 0 0 1" << endl
<< "POINTS " << pcl.size() << endl
<< "DATA ascii" << endl;
for (size_t i = 0; i < pcl.size(); i++)
f << pcl[i].x() << " " << pcl[i].y() << " " << pcl[i].z() << endl;
f.close();
return 0;
}
| 3,945 | 33.313043 | 111 | cpp |
octomap | octomap-master/octomap/src/offset_graph.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include "octomap.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
using namespace std;
using namespace octomap;
using namespace octomath;
int main(int argc, char** argv) {
if (argc != 4) {
printf("usage: in.graph offset out.graph\n");
exit(0);
}
ScanGraph* graph = new ScanGraph();
graph->readBinary(argv[1]);
double offset = atof(argv[2]);
Pose6D trans(0,0,-offset,0,0,0);
for (ScanGraph::iterator scan_it = graph->begin(); scan_it != graph->end(); scan_it++) {
(*scan_it)->scan->transform(trans);
(*scan_it)->pose *= trans.inv();
}
graph->writeBinary(argv[3]);
return 0;
}
| 2,413 | 36.138462 | 90 | cpp |
octomap | octomap-master/octomap/src/simple_example.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <octomap/octomap.h>
#include <octomap/OcTree.h>
using namespace std;
using namespace octomap;
void print_query_info(point3d query, OcTreeNode* node) {
if (node != NULL) {
cout << "occupancy probability at " << query << ":\t " << node->getOccupancy() << endl;
}
else
cout << "occupancy probability at " << query << ":\t is unknown" << endl;
}
int main(int /*argc*/, char** /*argv*/) {
cout << endl;
cout << "generating example map" << endl;
OcTree tree (0.1); // create empty tree with resolution 0.1
// insert some measurements of occupied cells
for (int x=-20; x<20; x++) {
for (int y=-20; y<20; y++) {
for (int z=-20; z<20; z++) {
point3d endpoint ((float) x*0.05f, (float) y*0.05f, (float) z*0.05f);
tree.updateNode(endpoint, true); // integrate 'occupied' measurement
}
}
}
// insert some measurements of free cells
for (int x=-30; x<30; x++) {
for (int y=-30; y<30; y++) {
for (int z=-30; z<30; z++) {
point3d endpoint ((float) x*0.02f-1.0f, (float) y*0.02f-1.0f, (float) z*0.02f-1.0f);
tree.updateNode(endpoint, false); // integrate 'free' measurement
}
}
}
cout << endl;
cout << "performing some queries:" << endl;
point3d query (0., 0., 0.);
OcTreeNode* result = tree.search (query);
print_query_info(query, result);
query = point3d(-1.,-1.,-1.);
result = tree.search (query);
print_query_info(query, result);
query = point3d(1.,1.,1.);
result = tree.search (query);
print_query_info(query, result);
cout << endl;
tree.writeBinary("simple_tree.bt");
cout << "wrote example file simple_tree.bt" << endl << endl;
cout << "now you can use octovis to visualize: octovis simple_tree.bt" << endl;
cout << "Hint: hit 'F'-key in viewer to see the freespace" << endl << endl;
}
| 3,633 | 34.627451 | 92 | cpp |
octomap | octomap-master/octomap/src/math/Pose6D.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <octomap/math/Pose6D.h>
#include <math.h>
namespace octomath {
Pose6D::Pose6D() {
}
Pose6D::Pose6D(const Vector3 &trans, const Quaternion &rot) :
translation(trans),
rotation(rot)
{ }
Pose6D::Pose6D(float x, float y, float z, double roll, double pitch, double yaw) :
translation(x, y, z),
rotation(roll, pitch, yaw)
{ }
Pose6D::~Pose6D() {
}
Pose6D::Pose6D(const Pose6D& other) :
translation(other.trans()),
rotation(other.rot())
{ }
Pose6D& Pose6D::operator= (const Pose6D& other) {
translation = other.trans();
rotation = other.rot();
return *this;
}
Pose6D Pose6D::inv() const {
Pose6D result(*this);
result.rot() = rot().inv().normalized();
result.trans() = result.rot().rotate(-trans());
return result;
}
Pose6D& Pose6D::inv_IP() {
rot() = rot().inv().normalized();
trans() = rot().rotate(-trans());
return *this;
}
Vector3 Pose6D::transform (const Vector3 &v) const {
Vector3 res = this->rot().rotate(v);
res = res + this->trans();
return res;
}
Pose6D Pose6D::operator* (const Pose6D& other) const {
Quaternion rot_new = rotation * other.rot();
Vector3 trans_new = rotation.rotate(other.trans()) + trans();
return Pose6D(trans_new, rot_new.normalized());
}
const Pose6D& Pose6D::operator*= (const Pose6D& other) {
trans() += rotation.rotate(other.trans());
rot() = rot() * other.rot();
return *this;
}
double Pose6D::distance (const Pose6D &other) const {
double dist_x = x() - other.x();
double dist_y = y() - other.y();
double dist_z = z() - other.z();
return sqrt(dist_x*dist_x + dist_y*dist_y + dist_z*dist_z);
}
double Pose6D::transLength() const {
return sqrt(x()*x() + y()*y() + z()*z());
}
bool Pose6D::operator==(const Pose6D& other) const {
return translation == other.translation
&& rotation == other.rotation;
}
bool Pose6D::operator!=(const Pose6D& other) const {
return !(*this == other);
}
std::istream& Pose6D::read(std::istream &s) {
translation.read(s);
rotation.read(s);
return s;
}
std::ostream& Pose6D::write(std::ostream &s) const {
translation.write(s);
s << " ";
rotation.write(s);
return s;
}
std::istream& Pose6D::readBinary(std::istream &s) {
translation.readBinary(s);
rotation.readBinary(s);
return s;
}
std::ostream& Pose6D::writeBinary(std::ostream &s) const {
translation.writeBinary(s);
rotation.writeBinary(s);
return s;
}
std::ostream& operator<<(std::ostream& s, const Pose6D& p) {
s << "(" << p.x() << " " << p.y() << " " << p.z()
<< ", " << p.rot().u() << " " << p.rot().x() << " " << p.rot().y() << " " << p.rot().z() << ")";
return s;
}
}
| 4,594 | 27.899371 | 102 | cpp |
octomap | octomap-master/octomap/src/math/Quaternion.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <octomap/math/Vector3.h>
#include <octomap/math/Quaternion.h>
#include <octomap/math/Utils.h>
#include <cassert>
#include <math.h>
#include <algorithm>
// used from Vector: norm2, unit, *
namespace octomath {
Quaternion::Quaternion(const Quaternion &other) {
data[0] = other(0);
data[1] = other(1);
data[2] = other(2);
data[3] = other(3);
}
Quaternion::Quaternion(float uu, float xx, float yy, float zz) {
u() = uu;
x() = xx;
y() = yy;
z() = zz;
}
Quaternion::Quaternion(const Vector3 &other) {
operator=(Quaternion(other.roll(), other.pitch(), other.yaw()));
}
Quaternion::Quaternion(double roll, double pitch, double yaw) {
double sroll = sin(roll);
double spitch = sin(pitch);
double syaw = sin(yaw);
double croll = cos(roll);
double cpitch = cos(pitch);
double cyaw = cos(yaw);
double m[3][3] = { //create rotational Matrix
{cyaw*cpitch, cyaw*spitch*sroll - syaw*croll, cyaw*spitch*croll + syaw*sroll},
{syaw*cpitch, syaw*spitch*sroll + cyaw*croll, syaw*spitch*croll - cyaw*sroll},
{ -spitch, cpitch*sroll, cpitch*croll}
};
float _u = (float) (sqrt(std::max(0., 1 + m[0][0] + m[1][1] + m[2][2]))/2.0);
float _x = (float) (sqrt(std::max(0., 1 + m[0][0] - m[1][1] - m[2][2]))/2.0);
float _y = (float) (sqrt(std::max(0., 1 - m[0][0] + m[1][1] - m[2][2]))/2.0);
float _z = (float) (sqrt(std::max(0., 1 - m[0][0] - m[1][1] + m[2][2]))/2.0);
u() = _u;
x() = (m[2][1] - m[1][2])>=0?fabs(_x):-fabs(_x);
y() = (m[0][2] - m[2][0])>=0?fabs(_y):-fabs(_y);
z() = (m[1][0] - m[0][1])>=0?fabs(_z):-fabs(_z);
}
Quaternion::Quaternion(const Vector3& axis, double angle) {
double sa = sin(angle/2);
double ca = cos(angle/2);
x() = (float) (axis.x()*sa);
y() = (float) (axis.y()*sa);
z() = (float) (axis.z()*sa);
u() = (float) ca;
}
float Quaternion::norm () const {
double n = 0;
for (unsigned int i=0; i<4; i++) {
n += operator()(i) * operator()(i);
}
return (float) sqrt(n);
}
void Quaternion::operator/= (float x)
{
for (unsigned int i=0; i<4; ++i)
operator()(i) /= x;
}
bool Quaternion::operator== (const Quaternion& other) const
{
for (unsigned int i=0; i<4; i++)
{
if (operator()(i) != other(i))
return false;
}
return true;
}
Vector3 Quaternion::toEuler() const {
// create rotational matrix
double n = norm ();
double s = n > 0?2./(n*n):0.;
double xs = x()*s;
double ys = y()*s;
double zs = z()*s;
double ux = u()*xs;
double uy = u()*ys;
double uz = u()*zs;
double xx = x()*xs;
double xy = x()*ys;
double xz = x()*zs;
double yy = y()*ys;
double yz = y()*zs;
double zz = z()*zs;
double m[3][3];
m[0][0] = 1.0 - (yy + zz);
m[1][1] = 1.0 - (xx + zz);
m[2][2] = 1.0 - (xx + yy);
m[1][0] = xy + uz;
m[0][1] = xy - uz;
m[2][0] = xz - uy;
m[0][2] = xz + uy;
m[2][1] = yz + ux;
m[1][2] = yz - ux;
float roll = (float) atan2(m[2][1], m[2][2]);
float pitch = (float) atan2(-m[2][0], sqrt(m[2][1]*m[2][1] + m[2][2]*m[2][2]));
float yaw = (float) atan2(m[1][0], m[0][0]);
return Vector3(roll, pitch, yaw);
}
void Quaternion::toRotMatrix(std::vector <double>& rot_matrix_3_3) const {
// create rotational matrix
double n = norm ();
double s = n > 0?2./(n*n):0.;
double xs = x()*s;
double ys = y()*s;
double zs = z()*s;
double ux = u()*xs;
double uy = u()*ys;
double uz = u()*zs;
double xx = x()*xs;
double xy = x()*ys;
double xz = x()*zs;
double yy = y()*ys;
double yz = y()*zs;
double zz = z()*zs;
double m[3][3];
m[0][0] = 1.0 - (yy + zz);
m[1][1] = 1.0 - (xx + zz);
m[2][2] = 1.0 - (xx + yy);
m[1][0] = xy + uz;
m[0][1] = xy - uz;
m[2][0] = xz - uy;
m[0][2] = xz + uy;
m[2][1] = yz + ux;
m[1][2] = yz - ux;
rot_matrix_3_3.clear();
rot_matrix_3_3.resize(9,0.);
for (unsigned int i=0; i<3; i++) {
rot_matrix_3_3[i*3] = m[i][0];
rot_matrix_3_3[i*3+1] = m[i][1];
rot_matrix_3_3[i*3+2] = m[i][2];
}
}
Quaternion& Quaternion::operator= (const Quaternion& other) {
u() = other.u();
x() = other.x();
y() = other.y();
z() = other.z();
return *this;
}
Quaternion Quaternion::operator* (const Quaternion& other) const {
return Quaternion(u()*other.u() - x()*other.x() - y()*other.y() - z()*other.z(),
y()*other.z() - other.y()*z() + u()*other.x() + other.u()*x(),
z()*other.x() - other.z()*x() + u()*other.y() + other.u()*y(),
x()*other.y() - other.x()*y() + u()*other.z() + other.u()*z());
}
Quaternion Quaternion::operator* (const Vector3& v) const {
return *this * Quaternion(0, v(0), v(1), v(2));
}
Quaternion operator* (const Vector3& v, const Quaternion& q) {
return Quaternion(0, v(0), v(1), v(2)) * q;
}
Quaternion& Quaternion::normalize (){
double len = norm ();
if (len > 0)
*this /= (float) len;
return *this;
}
Quaternion Quaternion::normalized () const {
Quaternion result(*this);
result.normalize ();
return result;
}
Quaternion& Quaternion::inv_IP() {
x() = -x();
y() = -y();
z() = -z();
return *this;
}
Vector3 Quaternion::rotate(const Vector3& v) const {
Quaternion q = *this * v * this->inv();
return Vector3(q.x(), q.y(), q.z());
}
std::istream& Quaternion::read(std::istream &s) {
int temp;
s >> temp; // should be 4
for (unsigned int i=0; i<4; i++)
s >> operator()(i);
return s;
}
std::ostream& Quaternion::write(std::ostream &s) const {
s << 4;
for (unsigned int i=0; i<4; i++)
s << " " << operator()(i);
return s;
}
std::istream& Quaternion::readBinary(std::istream &s) {
int temp;
s.read((char*)&temp, sizeof(temp));
double val = 0;
for (unsigned int i=0; i<4; i++) {
s.read((char*)&val, sizeof(val));
operator()(i) = (float) val;
}
return s;
}
std::ostream& Quaternion::writeBinary(std::ostream &s) const {
int temp = 4;
s.write((char*)&temp, sizeof(temp));
double val = 0;
for (unsigned int i=0; i<4; i++) {
val = operator()(i);
s.write((char*)&val, sizeof(val));
}
return s;
}
std::ostream& operator<<(std::ostream& s, const Quaternion& q) {
s << "(" << q.u() << " " << q.x() << " " << q.y() << " " << q.z() << ")";
return s;
}
}
| 8,412 | 26.13871 | 84 | cpp |
octomap | octomap-master/octomap/src/math/Vector3.cpp | /*
* OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees
* https://octomap.github.io/
*
* Copyright (c) 2009-2013, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved.
* License: New BSD
*
* 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 University of Freiburg 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.
*/
#include <octomap/math/Vector3.h>
#include <cassert>
#include <math.h>
#include <string.h>
namespace octomath {
Vector3& Vector3::rotate_IP (double roll, double pitch, double yaw) {
double x, y, z;
// pitch (around y)
x = (*this)(0); z = (*this)(2);
(*this)(0) = (float) (z * sin(pitch) + x * cos(pitch));
(*this)(2) = (float) (z * cos(pitch) - x * sin(pitch));
// yaw (around z)
x = (*this)(0); y = (*this)(1);
(*this)(0) = (float) (x * cos(yaw) - y * sin(yaw));
(*this)(1) = (float) (x * sin(yaw) + y * cos(yaw));
// roll (around x)
y = (*this)(1); z = (*this)(2);
(*this)(1) = (float) (y * cos(roll) - z * sin(roll));
(*this)(2) = (float) (y * sin(roll) + z * cos(roll));
return *this;
}
// void Vector3::read(unsigned char * src, unsigned int size){
// memcpy(&data[0],src, sizeof(double));
// memcpy(&data[1],src, sizeof(double));
// memcpy(&data[2],src, sizeof(double));
// }
std::istream& Vector3::read(std::istream &s) {
int temp;
s >> temp; // should be 3
for (unsigned int i=0; i<3; i++)
s >> operator()(i);
return s;
}
std::ostream& Vector3::write(std::ostream &s) const {
s << 3;
for (unsigned int i=0; i<3; i++)
s << " " << operator()(i);
return s;
}
std::istream& Vector3::readBinary(std::istream &s) {
int temp;
s.read((char*)&temp, sizeof(temp));
double val = 0;
for (unsigned int i=0; i<3; i++) {
s.read((char*)&val, sizeof(val));
operator()(i) = (float) val;
}
return s;
}
std::ostream& Vector3::writeBinary(std::ostream &s) const {
int temp = 3;
s.write((char*)&temp, sizeof(temp));
double val = 0;
for (unsigned int i=0; i<3; i++) {
val = operator()(i);
s.write((char*)&val, sizeof(val));
}
return s;
}
std::ostream& operator<<(std::ostream& out, octomath::Vector3 const& v) {
return out << '(' << v.x() << ' ' << v.y() << ' ' << v.z() << ')';
}
}
| 3,780 | 31.316239 | 78 | cpp |
octomap | octomap-master/octomap/src/testing/color_tree_histogram.cpp | #include <octomap/octomap.h>
#include <octomap/ColorOcTree.h>
using namespace std;
using namespace octomap;
int main(int /*argc*/, char** argv) {
std::string filename(argv[1]);
std::ifstream infile(filename.c_str(), std::ios_base::in |std::ios_base::binary);
if (!infile.is_open()) {
cout << "file "<< filename << " could not be opened for reading.\n";
return -1;
}
ColorOcTree tree (0.1);
tree.readData(infile);
infile.close();
cout << "color tree read from "<< filename <<"\n";
tree.writeColorHistogram("histogram.eps");
return 0;
}
| 572 | 20.222222 | 83 | cpp |
octomap | octomap-master/octomap/src/testing/test_bbx.cpp |
#include <octomap/octomap.h>
#include "testing.h"
using namespace octomap;
int main(int /*argc*/, char** /*argv*/) {
const float resolution = 0.2f;
OcTree tree(resolution);
// Set up the bounding box.
const float bbx_limit = 10.1f;
point3d bbx_min(-bbx_limit, -bbx_limit, -bbx_limit);
point3d bbx_max(bbx_limit, bbx_limit, bbx_limit);
tree.setBBXMin(bbx_min);
tree.setBBXMax(bbx_max);
tree.useBBXLimit(true);
// Set up the point cloud. Offset the origin by half resolution to use the
// center of a voxel.
Pointcloud cloud;
const point3d origin(resolution / 2.f, 5.f + resolution / 2.f, resolution / 2.f);
const float maxrange = 8.f;
// The first point is inside the bounding box and max range.
const point3d point0 = origin + point3d(5.f, 0.f, 0.f);
cloud.push_back(point0);
// The second point is outside the bounding box but within max range.
const point3d point1 = origin + point3d(0.f, 7.f, 0.f);
cloud.push_back(point1);
// The third point is inside the bounding box but outside max range.
const point3d point2 = origin + point3d(0.f, 0.f, 9.f);
cloud.push_back(point2);
tree.insertPointCloud(cloud, origin, maxrange);
// Check the point cloud insertion using ray casting.
tree.setOccupancyThres(0.5f);
point3d end_point;
// Searching in the x-direction from the origin finds the first point.
bool ray_cast_ret = tree.castRay(origin, point3d(1.f, 0.f, 0.f), end_point);
EXPECT_TRUE(ray_cast_ret);
const float eps = 1e-3;
EXPECT_NEAR(end_point.x(), point0.x(), eps);
EXPECT_NEAR(end_point.y(), point0.y(), eps);
EXPECT_NEAR(end_point.z(), point0.z(), eps);
// Searching in the y-direction from the origin terminates just outside the
// bounding box.
ray_cast_ret = tree.castRay(origin, point3d(0.f, 1.f, 0.f), end_point);
EXPECT_FALSE(ray_cast_ret);
EXPECT_NEAR(end_point.x(), point1.x(), eps);
EXPECT_NEAR(end_point.y(), bbx_limit + resolution, eps);
EXPECT_NEAR(end_point.z(), point1.z(), eps);
// Searching in the z-direction from the origin terminates at the max range.
ray_cast_ret = tree.castRay(origin, point3d(0.f, 0.f, 1.f), end_point);
EXPECT_FALSE(ray_cast_ret);
EXPECT_NEAR(end_point.x(), point2.x(), eps);
EXPECT_NEAR(end_point.y(), point2.y(), eps);
EXPECT_NEAR(end_point.z(), origin.z() + maxrange, eps);
return 0;
}
| 2,342 | 36.190476 | 83 | cpp |
octomap | octomap-master/octomap/src/testing/test_changedkeys.cpp |
#include <stdio.h>
#include <octomap/octomap.h>
#include <octomap/math/Utils.h>
using namespace std;
using namespace octomap;
void printChanges(OcTree& tree){
unsigned int changedOccupied = 0;
unsigned int changedFree = 0;
unsigned int actualOccupied = 0;
unsigned int actualFree = 0;
unsigned int missingChanged = 0;
tree.expand();
// iterate through the changed nodes
KeyBoolMap::const_iterator it;
for (it=tree.changedKeysBegin(); it!=tree.changedKeysEnd(); it++) {
OcTreeNode* node = tree.search(it->first);
if (node != NULL) {
if (tree.isNodeOccupied(node)) {
changedOccupied += 1;
}
else {
changedFree += 1;
}
} else {
missingChanged +=1;
}
}
// iterate through the entire tree
for(OcTree::tree_iterator it=tree.begin_tree(),
end=tree.end_tree(); it!= end; ++it) {
if (it.isLeaf()) {
if (tree.isNodeOccupied(*it)) {
actualOccupied += 1;
}
else {
actualFree += 1;
}
}
}
cout << "change detection: " << changedOccupied << " occ; " << changedFree << " free; "<< missingChanged << " missing" << endl;
cout << "actual: " << actualOccupied << " occ; " << actualFree << " free; " << endl;
tree.prune();
}
int main(int /*argc*/, char** /*argv*/) {
//##############################################################
OcTree tree (0.05);
tree.enableChangeDetection(true);
point3d origin (0.01f, 0.01f, 0.02f);
point3d point_on_surface (4.01f,0.01f,0.01f);
tree.insertRay(origin, point_on_surface);
printChanges(tree);
tree.updateNode(point3d(2.01f, 0.01f, 0.01f), 2.0f);
printChanges(tree);
tree.updateNode(point3d(2.01f, 0.01f, 0.01f), -2.0f);
printChanges(tree);
cout << "generating spherical scan at " << origin << " ..." << endl;
for (int i=-100; i<101; i++) {
Pointcloud cloud;
for (int j=-100; j<101; j++) {
point3d rotated = point_on_surface;
rotated.rotate_IP(0, DEG2RAD(i*0.5), DEG2RAD(j*0.5));
cloud.push_back(rotated);
}
// insert in global coordinates:
tree.insertPointCloud(cloud, origin, -1);
}
printChanges(tree);
cout << "done." << endl;
return 0;
}
| 2,205 | 22.221053 | 129 | cpp |
octomap | octomap-master/octomap/src/testing/test_color_tree.cpp | #include <octomap/octomap.h>
#include <octomap/ColorOcTree.h>
#include "testing.h"
using namespace std;
using namespace octomap;
void print_query_info(point3d query, ColorOcTreeNode* node) {
if (node != NULL) {
cout << "occupancy probability at " << query << ":\t " << node->getOccupancy() << endl;
cout << "color of node is: " << node->getColor()
<< endl;
}
else
cout << "occupancy probability at " << query << ":\t is unknown" << endl;
}
int main(int /*argc*/, char** /*argv*/) {
double res = 0.05; // create empty tree with resolution 0.05 (different from default 0.1 for test)
ColorOcTree tree (res);
// insert some measurements of occupied cells
for (int x=-20; x<20; x++) {
for (int y=-20; y<20; y++) {
for (int z=-20; z<20; z++) {
point3d endpoint ((float) x*0.05f+0.01f, (float) y*0.05f+0.01f, (float) z*0.05f+0.01f);
ColorOcTreeNode* n = tree.updateNode(endpoint, true);
n->setColor(z*5+100,x*5+100,y*5+100);
}
}
}
// insert some measurements of free cells
for (int x=-30; x<30; x++) {
for (int y=-30; y<30; y++) {
for (int z=-30; z<30; z++) {
point3d endpoint ((float) x*0.02f+2.0f, (float) y*0.02f+2.0f, (float) z*0.02f+2.0f);
ColorOcTreeNode* n = tree.updateNode(endpoint, false);
n->setColor(255,255,0); // set color to yellow
}
}
}
// set inner node colors
tree.updateInnerOccupancy();
// should already be pruned
EXPECT_EQ(tree.size(), tree.calcNumNodes());
const size_t initialSize = tree.size();
EXPECT_EQ(initialSize, 1034);
tree.prune();
EXPECT_EQ(tree.size(), tree.calcNumNodes());
EXPECT_EQ(initialSize, tree.size());
cout << endl;
std::cout << "\nWriting to / from file\n===============================\n";
std::string filename ("simple_color_tree.ot");
std::cout << "Writing color tree to " << filename << std::endl;
// write color tree
EXPECT_TRUE(tree.write(filename));
// read tree file
cout << "Reading color tree from "<< filename <<"\n";
AbstractOcTree* read_tree = AbstractOcTree::read(filename);
EXPECT_TRUE(read_tree);
EXPECT_EQ(read_tree->getTreeType().compare(tree.getTreeType()), 0);
EXPECT_FLOAT_EQ(read_tree->getResolution(), tree.getResolution());
EXPECT_EQ(read_tree->size(), tree.size());
ColorOcTree* read_color_tree = dynamic_cast<ColorOcTree*>(read_tree);
EXPECT_TRUE(read_color_tree);
EXPECT_TRUE(tree == *read_color_tree);
{
cout << "Performing some queries:" << endl;
// TODO: some more meaningful tests
point3d query (0., 0., 0.);
ColorOcTreeNode* result = tree.search (query);
ColorOcTreeNode* result2 = read_color_tree->search (query);
std::cout << "READ: ";
print_query_info(query, result);
std::cout << "WRITE: ";
print_query_info(query, result2);
EXPECT_TRUE(result);
EXPECT_TRUE(result2);
EXPECT_EQ(result->getColor(), result2->getColor());
EXPECT_EQ(result->getLogOdds(), result2->getLogOdds());
query = point3d(-1.,-1.,-1.);
result = tree.search (query);
result2 = read_color_tree->search (query);
print_query_info(query, result);
std::cout << "READ: ";
print_query_info(query, result);
std::cout << "WRITE: ";
print_query_info(query, result2);
EXPECT_TRUE(result);
EXPECT_TRUE(result2);
EXPECT_EQ(result->getColor(), result2->getColor());
EXPECT_EQ(result->getLogOdds(), result2->getLogOdds());
query = point3d(1.,1.,1.);
result = tree.search (query);
result2 = read_color_tree->search (query);
print_query_info(query, result);
std::cout << "READ: ";
print_query_info(query, result);
std::cout << "WRITE: ";
print_query_info(query, result2);
EXPECT_FALSE(result);
EXPECT_FALSE(result2);
}
delete read_tree;
read_tree = NULL;
{
std::cout << "\nPruning / expansion\n===============================\n";
EXPECT_EQ(initialSize, tree.size());
EXPECT_EQ(initialSize, tree.calcNumNodes());
std::cout << "Initial size: " << tree.size() << std::endl;
// tree should already be pruned during insertion:
tree.prune();
EXPECT_EQ(initialSize, tree.size());
EXPECT_EQ(initialSize, tree.calcNumNodes());
tree.expand();
std::cout << "Size after expansion: " << tree.size() << std::endl;
EXPECT_EQ(tree.size(), tree.calcNumNodes());
// prune again, should be same as initial size
tree.prune();
EXPECT_EQ(initialSize, tree.size());
EXPECT_EQ(initialSize, tree.calcNumNodes());
}
// delete / create some nodes
{
std::cout << "\nCreating / deleting nodes\n===============================\n";
size_t initialSize = tree.size();
EXPECT_EQ(initialSize, tree.calcNumNodes());
std::cout << "Initial size: " << initialSize << std::endl;
point3d newCoord(-2.0, -2.0, -2.0);
ColorOcTreeNode* newNode = tree.updateNode(newCoord, true);
newNode->setColor(255,0,0);
EXPECT_TRUE(newNode != NULL);
const size_t insertedSize = tree.size();
std::cout << "Size after one insertion: " << insertedSize << std::endl;
EXPECT_EQ(insertedSize, initialSize+6);
EXPECT_EQ(insertedSize, tree.calcNumNodes());
// find parent of newly inserted node:
ColorOcTreeNode* parentNode = tree.search(newCoord, tree.getTreeDepth() -1);
EXPECT_TRUE(parentNode);
EXPECT_TRUE(tree.nodeHasChildren(parentNode));
// only one child exists:
EXPECT_TRUE(tree.nodeChildExists(parentNode, 0));
for (size_t i = 1; i < 8; ++i){
EXPECT_FALSE(tree.nodeChildExists(parentNode, i));
}
tree.deleteNodeChild(parentNode, 0);
EXPECT_EQ(tree.size(), tree.calcNumNodes());
EXPECT_EQ(tree.size(), insertedSize - 1);
tree.prune();
EXPECT_EQ(tree.size(), tree.calcNumNodes());
EXPECT_EQ(tree.size(), insertedSize - 1);
tree.expandNode(parentNode);
EXPECT_EQ(tree.size(), tree.calcNumNodes());
EXPECT_EQ(tree.size(), insertedSize + 7);
EXPECT_TRUE(tree.pruneNode(parentNode));
EXPECT_EQ(tree.size(), tree.calcNumNodes());
EXPECT_EQ(tree.size(), insertedSize - 1);
EXPECT_TRUE(tree.write("simple_color_tree_ed.ot"));
}
return 0;
}
| 6,275 | 31.184615 | 101 | cpp |
octomap | octomap-master/octomap/src/testing/test_io.cpp | #include <stdio.h>
#include <string>
#include <octomap/OcTree.h>
#include <octomap/ColorOcTree.h>
#include <octomap/OcTreeStamped.h>
#include <octomap/math/Utils.h>
#include "testing.h"
using namespace std;
using namespace octomap;
using namespace octomath;
int main(int argc, char** argv) {
if (argc != 2){
std::cerr << "Error: you need to specify a testfile (.bt) as argument to read" << std::endl;
return 1; // exit 1 means failure
}
std::cout << "Testing empty OcTree...\n";
//empty tree
{
OcTree emptyTree(0.999);
EXPECT_EQ(emptyTree.size(), 0);
EXPECT_TRUE(emptyTree.writeBinary("empty.bt"));
EXPECT_TRUE(emptyTree.write("empty.ot"));
OcTree emptyReadTree(0.2);
EXPECT_TRUE(emptyReadTree.readBinary("empty.bt"));
EXPECT_EQ(emptyReadTree.size(), 0);
EXPECT_TRUE(emptyTree == emptyReadTree);
AbstractOcTree* readTreeAbstract = AbstractOcTree::read("empty.ot");
EXPECT_TRUE(readTreeAbstract);
OcTree* readTreeOt = dynamic_cast<OcTree*>(readTreeAbstract);
EXPECT_TRUE(readTreeOt);
EXPECT_EQ(readTreeOt->size(), 0);
EXPECT_TRUE(emptyTree == *readTreeOt);
delete readTreeOt;
}
std::cout << "Testing reference OcTree from file ...\n";
string filename = string(argv[1]);
{
string filenameOt = "test_io_file.ot";
string filenameBtOut = "test_io_file.bt";
string filenameBtCopyOut = "test_io_file_copy.bt";
// read reference tree from input file
OcTree tree (0.1);
EXPECT_TRUE (tree.readBinary(filename));
std::cout << " Copy Constructor / assignment / ==\n";
// test copy constructor / assignment:
OcTree* treeCopy = new OcTree(tree);
EXPECT_TRUE(tree == *treeCopy);
EXPECT_TRUE(treeCopy->writeBinary(filenameBtCopyOut));
// change a tree property, trees must be different afterwards
treeCopy->setResolution(tree.getResolution()*2.0);
EXPECT_FALSE(tree == *treeCopy);
treeCopy->setResolution(tree.getResolution());
EXPECT_TRUE(tree == *treeCopy);
// flip one value, trees must be different afterwards:
point3d pt(0.5, 0.5, 0.5);
OcTreeNode* node = treeCopy->search(pt);
if (node && treeCopy->isNodeOccupied(node))
treeCopy->updateNode(pt, false);
else
treeCopy->updateNode(pt, true);
EXPECT_FALSE(tree == *treeCopy);
delete treeCopy;
std::cout << " Swap\n";
// test swap:
OcTree emptyT(tree.getResolution());
OcTree emptySw(emptyT);
OcTree otherSw(tree);
emptySw.swapContent(otherSw);
EXPECT_FALSE(emptyT == emptySw);
EXPECT_TRUE(emptySw == tree);
EXPECT_TRUE(otherSw == emptyT);
// write again to bt, read & compare
EXPECT_TRUE(tree.writeBinary(filenameBtOut));
OcTree readTreeBt(0.1);
EXPECT_TRUE(readTreeBt.readBinary(filenameBtOut));
EXPECT_TRUE(tree == readTreeBt);
std::cout <<" Write to .ot / read through AbstractOcTree\n";
// now write to .ot, read & compare
EXPECT_TRUE(tree.write(filenameOt));
AbstractOcTree* readTreeAbstract = AbstractOcTree::read(filenameOt);
EXPECT_TRUE(readTreeAbstract);
OcTree* readTreeOt = dynamic_cast<OcTree*>(readTreeAbstract);
EXPECT_TRUE(readTreeOt);
EXPECT_TRUE(tree == *readTreeOt);
// sanity test for "==": flip one node, compare again
point3d coord(0.1f, 0.1f, 0.1f);
node = readTreeOt->search(coord);
if (node && readTreeOt->isNodeOccupied(node))
readTreeOt->updateNode(coord, false);
else
readTreeOt->updateNode(coord, true);
EXPECT_FALSE(tree == *readTreeOt);
delete readTreeOt;
}
// Test for tree headers and IO factory registry (color)
{
std::cout << "Testing ColorOcTree...\n";
double res = 0.02;
std::string filenameColor = "test_io_color_file.ot";
ColorOcTree colorTree(res);
EXPECT_EQ(colorTree.getTreeType(), "ColorOcTree");
ColorOcTreeNode* colorNode = colorTree.updateNode(point3d(0.0, 0.0, 0.0), true);
ColorOcTreeNode::Color color_red(255, 0, 0);
colorNode->setColor(color_red);
colorTree.setNodeColor(0.0, 0.0, 0.0, 255, 0, 0);
colorTree.updateNode(point3d(0.1f, 0.1f, 0.1f), true);
colorTree.setNodeColor(0.1f, 0.1f, 0.1f, 0, 0, 255);
EXPECT_TRUE(colorTree.write(filenameColor));
AbstractOcTree* readTreeAbstract = AbstractOcTree::read(filenameColor);
EXPECT_TRUE(readTreeAbstract);
EXPECT_EQ(colorTree.getTreeType(), readTreeAbstract->getTreeType());
ColorOcTree* readColorTree = dynamic_cast<ColorOcTree*>(readTreeAbstract);
EXPECT_TRUE(readColorTree);
EXPECT_TRUE(colorTree == *readColorTree);
colorNode = colorTree.search(0.0, 0.0, 0.0);
EXPECT_TRUE(colorNode);
EXPECT_EQ(colorNode->getColor(), color_red);
delete readColorTree;
}
// Test for tree headers and IO factory registry (stamped)
{
std::cout << "Testing OcTreeStamped...\n";
double res = 0.05;
std::string filenameStamped = "test_io_stamped_file.ot";
OcTreeStamped stampedTree(res);
EXPECT_EQ(stampedTree.getTreeType(), "OcTreeStamped");
// TODO: add / modify some stamped nodes
//ColorOcTreeNode* colorNode = colorTree.updateNode(point3d(0.0, 0.0, 0.0), true);
//ColorOcTreeNode::Color color_red(255, 0, 0);
//colorNode->setColor(color_red);
//colorTree.setNodeColor(0.0, 0.0, 0.0, 255, 0, 0);
//colorTree.updateNode(point3d(0.1f, 0.1f, 0.1f), true);
//colorTree.setNodeColor(0.1f, 0.1f, 0.1f, 0, 0, 255);
EXPECT_TRUE(stampedTree.write(filenameStamped));
AbstractOcTree* readTreeAbstract = AbstractOcTree::read(filenameStamped);
EXPECT_TRUE(readTreeAbstract);
EXPECT_EQ(stampedTree.getTreeType(), readTreeAbstract->getTreeType());
OcTreeStamped* readStampedTree = dynamic_cast<OcTreeStamped*>(readTreeAbstract);
EXPECT_TRUE(readStampedTree);
EXPECT_TRUE(stampedTree == *readStampedTree);
//colorNode = colorTree.search(0.0, 0.0, 0.0);
//EXPECT_TRUE(colorNode);
//EXPECT_EQ(colorNode->getColor(), color_red);
delete readStampedTree;
}
std::cerr << "Test successful.\n";
return 0;
}
| 6,091 | 32.289617 | 96 | cpp |
octomap | octomap-master/octomap/src/testing/test_iterators.cpp |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <octomap/octomap_timing.h>
#include <octomap/octomap.h>
#include <octomap/math/Utils.h>
#include "testing.h"
using namespace std;
using namespace octomap;
void printUsage(char* self){
std::cerr << "\nUSAGE: " << self << " inputfile.bt [max_depth] (optional)\n\n";
exit(1);
}
void computeChildCenter (const unsigned int& pos,
const float& center_offset,
const point3d& parent_center,
point3d& child_center) {
// x-axis
if (pos & 1) child_center(0) = parent_center(0) + center_offset;
else child_center(0) = parent_center(0) - center_offset;
// y-axis
if (pos & 2) child_center(1) = parent_center(1) + center_offset;
else child_center(1) = parent_center(1) - center_offset;
// z-axis
if (pos & 4) child_center(2) = parent_center(2) + center_offset;
else child_center(2) = parent_center(2) - center_offset;
}
/// mimics old deprecated behavior to compare against
void getLeafNodesRecurs(std::list<OcTreeVolume>& voxels,
unsigned int max_depth,
OcTreeNode* node, unsigned int depth,
const point3d& parent_center, const point3d& tree_center,
OcTree* tree, bool occupied)
{
if ((depth <= max_depth) && (node != NULL) ) {
if (tree->nodeHasChildren(node) && (depth != max_depth)) {
float center_offset = float(tree_center(0) / pow( 2., (double) depth+1));
point3d search_center;
for (unsigned int i=0; i<8; i++) {
if (tree->nodeChildExists(node, i)) {
computeChildCenter(i, center_offset, parent_center, search_center);
getLeafNodesRecurs(voxels, max_depth, tree->getNodeChild(node, i), depth+1, search_center, tree_center, tree, occupied);
}
}
}
else {
if (tree->isNodeOccupied(node) == occupied){
double voxelSize = tree->getResolution() * pow(2., double(16 - depth));
voxels.push_back(std::make_pair(parent_center - tree_center, voxelSize));
}
}
}
}
/// mimics old deprecated behavior to compare against
void getVoxelsRecurs(std::list<OcTreeVolume>& voxels,
unsigned int max_depth,
OcTreeNode* node, unsigned int depth,
const point3d& parent_center, const point3d& tree_center,
OcTree* tree){
if ((depth <= max_depth) && (node != NULL) ) {
if (tree->nodeHasChildren(node) && (depth != max_depth)) {
double center_offset = tree_center(0) / pow(2., (double) depth + 1);
point3d search_center;
for (unsigned int i = 0; i < 8; i++) {
if (tree->nodeChildExists(node, i)) {
computeChildCenter(i, (float) center_offset, parent_center, search_center);
getVoxelsRecurs(voxels, max_depth, tree->getNodeChild(node, i), depth + 1, search_center, tree_center, tree);
}
} // depth
}
double voxelSize = tree->getResolution() * pow(2., double(16 - depth));
voxels.push_back(std::make_pair(parent_center - tree_center, voxelSize));
}
}
/// compare two lists of octree nodes on equality
void compareResults(const std::list<OcTreeVolume>& list_iterator, const std::list<OcTreeVolume>& list_depr){
EXPECT_EQ(list_iterator.size(), list_depr.size());
list<OcTreeVolume>::const_iterator list_it = list_iterator.begin();
list<OcTreeVolume>::const_iterator list_depr_it = list_depr.begin();
for (; list_it != list_iterator.end(); ++list_it, ++list_depr_it){
EXPECT_NEAR(list_it->first.x(), list_depr_it->first.x(), 0.005);
EXPECT_NEAR(list_it->first.y(), list_depr_it->first.y(), 0.005);
EXPECT_NEAR(list_it->first.z(), list_depr_it->first.z(), 0.005);
}
std::cout << "Resulting lists (size "<< list_iterator.size() << ") identical\n";
}
// for unique comparing, need to sort the lists:
bool OcTreeVolumeSortPredicate(const OcTreeVolume& lhs, const OcTreeVolume& rhs)
{
return ( lhs.second < rhs.second
|| (lhs.second == rhs.second &&
lhs.first.x() < rhs.first.x()
&& lhs.first.y() < rhs.first.y()
&& lhs.first.z() < rhs.first.z()));
}
double timediff(const timeval& start, const timeval& stop){
return (stop.tv_sec - start.tv_sec) + 1.0e-6 *(stop.tv_usec - start.tv_usec);
}
void boundingBoxTest(OcTree* tree){
//tree->expand();
// test complete tree (should be equal to no bbx)
OcTreeKey bbxMinKey, bbxMaxKey;
double temp_x,temp_y,temp_z;
tree->getMetricMin(temp_x,temp_y,temp_z);
octomap::point3d bbxMin = octomap::point3d(float(temp_x), float(temp_y), float(temp_z));
tree->getMetricMax(temp_x,temp_y,temp_z);
octomap::point3d bbxMax = octomap::point3d(float(temp_x), float(temp_y), float(temp_z));
EXPECT_TRUE(tree->coordToKeyChecked(bbxMin, bbxMinKey));
EXPECT_TRUE(tree->coordToKeyChecked(bbxMax, bbxMaxKey));
OcTree::leaf_bbx_iterator it_bbx = tree->begin_leafs_bbx(bbxMinKey,bbxMaxKey);
EXPECT_TRUE(it_bbx == tree->begin_leafs_bbx(bbxMinKey,bbxMaxKey));
OcTree::leaf_bbx_iterator end_bbx = tree->end_leafs_bbx();
EXPECT_TRUE(end_bbx == tree->end_leafs_bbx());
OcTree::leaf_iterator it = tree->begin_leafs();
EXPECT_TRUE(it == tree->begin_leafs());
OcTree::leaf_iterator end = tree->end_leafs();
EXPECT_TRUE(end == tree->end_leafs());
for( ; it!= end && it_bbx != end_bbx; ++it, ++it_bbx){
EXPECT_TRUE(it == it_bbx);
}
EXPECT_TRUE(it == end && it_bbx == end_bbx);
// now test an actual bounding box:
tree->expand(); // (currently only works properly for expanded tree (no multires)
bbxMin = point3d(-1, -1, - 1);
bbxMax = point3d(3, 2, 1);
EXPECT_TRUE(tree->coordToKeyChecked(bbxMin, bbxMinKey));
EXPECT_TRUE(tree->coordToKeyChecked(bbxMax, bbxMaxKey));
typedef unordered_ns::unordered_map<OcTreeKey, double, OcTreeKey::KeyHash> KeyVolumeMap;
KeyVolumeMap bbxVoxels;
size_t count = 0;
for(OcTree::leaf_bbx_iterator it = tree->begin_leafs_bbx(bbxMinKey,bbxMaxKey), end=tree->end_leafs_bbx();
it!= end; ++it)
{
count++;
OcTreeKey currentKey = it.getKey();
// leaf is actually a leaf:
EXPECT_FALSE(tree->nodeHasChildren(&(*it)));
// leaf exists in tree:
OcTreeNode* node = tree->search(currentKey);
EXPECT_TRUE(node);
EXPECT_EQ(node, &(*it));
// all leafs are actually in the bbx:
for (unsigned i = 0; i < 3; ++i){
// if (!(currentKey[i] >= bbxMinKey[i] && currentKey[i] <= bbxMaxKey[i])){
// std::cout << "Key failed: " << i << " " << currentKey[i] << " "<< bbxMinKey[i] << " "<< bbxMaxKey[i]
// << "size: "<< it.getSize()<< std::endl;
// }
EXPECT_TRUE(currentKey[i] >= bbxMinKey[i] && currentKey[i] <= bbxMaxKey[i]);
}
bbxVoxels.insert(std::pair<OcTreeKey,double>(currentKey, it.getSize()));
}
EXPECT_EQ(bbxVoxels.size(), count);
std::cout << "Bounding box traversed ("<< count << " leaf nodes)\n\n";
// compare with manual BBX check on all leafs:
for(OcTree::leaf_iterator it = tree->begin(), end=tree->end(); it!= end; ++it) {
OcTreeKey key = it.getKey();
if ( key[0] >= bbxMinKey[0] && key[0] <= bbxMaxKey[0]
&& key[1] >= bbxMinKey[1] && key[1] <= bbxMaxKey[1]
&& key[2] >= bbxMinKey[2] && key[2] <= bbxMaxKey[2])
{
KeyVolumeMap::iterator bbxIt = bbxVoxels.find(key);
EXPECT_FALSE(bbxIt == bbxVoxels.end());
EXPECT_TRUE(key == bbxIt->first);
EXPECT_EQ(it.getSize(), bbxIt->second);
}
}
}
int main(int argc, char** argv) {
//##############################################################
string btFilename = "";
unsigned char maxDepth = 16;
// test timing:
timeval start;
timeval stop;
const unsigned char tree_depth(16);
const unsigned int tree_max_val(32768);
double time_it, time_depr;
if (argc <= 1|| argc >3 || strcmp(argv[1], "-h") == 0){
printUsage(argv[0]);
}
btFilename = std::string(argv[1]);
if (argc > 2){
maxDepth = (unsigned char)atoi(argv[2]);
}
maxDepth = std::min((unsigned char)16,maxDepth);
if (maxDepth== 0)
maxDepth = tree_depth;
// iterate over empty tree:
OcTree emptyTree(0.2);
EXPECT_EQ(emptyTree.size(), 0);
EXPECT_EQ(emptyTree.calcNumNodes(), 0);
size_t iteratedNodes = 0;
OcTree::tree_iterator t_it = emptyTree.begin_tree(maxDepth);
OcTree::tree_iterator t_end = emptyTree.end_tree();
EXPECT_TRUE (t_it == t_end);
for( ; t_it != t_end; ++t_it){
iteratedNodes++;
}
EXPECT_EQ(iteratedNodes, 0);
for(OcTree::leaf_iterator l_it = emptyTree.begin_leafs(maxDepth), l_end=emptyTree.end_leafs(); l_it!= l_end; ++l_it){
iteratedNodes++;
}
EXPECT_EQ(iteratedNodes, 0);
octomap::point3d ptMinBBX(-0.1, -0.1, -0.1);
octomap::point3d ptMaxBBX(0.1, 0.1, 0.1);
for(OcTree::leaf_bbx_iterator l_it = emptyTree.begin_leafs_bbx(ptMinBBX, ptMaxBBX, maxDepth), l_end=emptyTree.end_leafs_bbx(); l_it!= l_end; ++l_it){
iteratedNodes++;
}
EXPECT_EQ(iteratedNodes, 0);
octomap::OcTreeKey minBBX(10, 10, 16);
octomap::OcTreeKey maxBBX(10, 10, 18);
for(OcTree::leaf_bbx_iterator l_it = emptyTree.begin_leafs_bbx(minBBX, maxBBX, maxDepth), l_end=emptyTree.end_leafs_bbx(); l_it!= l_end; ++l_it){
iteratedNodes++;
}
EXPECT_EQ(iteratedNodes, 0);
cout << "\nReading OcTree file\n===========================\n";
OcTree* tree = new OcTree(btFilename);
if (tree->size()<= 1){
std::cout << "Error reading file, exiting!\n";
return 1;
}
size_t count;
std::list<OcTreeVolume> list_depr;
std::list<OcTreeVolume> list_iterator;
/**
* get number of nodes:
*/
gettimeofday(&start, NULL); // start timer
size_t num_leafs_recurs = tree->getNumLeafNodes();
gettimeofday(&stop, NULL); // stop timer
time_depr = timediff(start, stop);
gettimeofday(&start, NULL); // start timer
size_t num_leafs_it = 0;
for(OcTree::leaf_iterator it = tree->begin(), end=tree->end(); it!= end; ++it) {
num_leafs_it++;
}
gettimeofday(&stop, NULL); // stop timer
time_it = timediff(start, stop);
std::cout << "Number of leafs: " << num_leafs_it << " / " << num_leafs_recurs << ", times: "
<<time_it << " / " << time_depr << "\n========================\n\n";
/**
* get all occupied leafs
*/
point3d tree_center;
tree_center(0) = tree_center(1) = tree_center(2)
= (float) (((double) tree_max_val) * tree->getResolution());
gettimeofday(&start, NULL); // start timer
getLeafNodesRecurs(list_depr,maxDepth,tree->getRoot(), 0, tree_center, tree_center, tree, true);
gettimeofday(&stop, NULL); // stop timer
time_depr = timediff(start, stop);
gettimeofday(&start, NULL); // start timer
for(OcTree::iterator it = tree->begin(maxDepth), end=tree->end(); it!= end; ++it){
if(tree->isNodeOccupied(*it))
{
//count ++;
list_iterator.push_back(OcTreeVolume(it.getCoordinate(), it.getSize()));
}
}
gettimeofday(&stop, NULL); // stop timer
time_it = timediff(start, stop);
std::cout << "Occupied lists traversed, times: "
<<time_it << " / " << time_depr << "\n";
compareResults(list_iterator, list_depr);
std::cout << "========================\n\n";
/**
* get all free leafs
*/
list_iterator.clear();
list_depr.clear();
gettimeofday(&start, NULL); // start timer
for(OcTree::leaf_iterator it = tree->begin(maxDepth), end=tree->end(); it!= end; ++it) {
if(!tree->isNodeOccupied(*it))
list_iterator.push_back(OcTreeVolume(it.getCoordinate(), it.getSize()));
}
gettimeofday(&stop, NULL); // stop timer
time_it = timediff(start, stop);
gettimeofday(&start, NULL); // start timer
getLeafNodesRecurs(list_depr,maxDepth,tree->getRoot(), 0, tree_center, tree_center, tree, false);
gettimeofday(&stop, NULL); // stop timer
time_depr = timediff(start, stop);
std::cout << "Free lists traversed, times: "
<<time_it << " / " << time_depr << "\n";
compareResults(list_iterator, list_depr);
std::cout << "========================\n\n";
/**
* get all volumes
*/
list_iterator.clear();
list_depr.clear();
gettimeofday(&start, NULL); // start timer
getVoxelsRecurs(list_depr,maxDepth,tree->getRoot(), 0, tree_center, tree_center, tree);
gettimeofday(&stop, NULL); // stop timer
time_depr = timediff(start, stop);
gettimeofday(&start, NULL); // start timers
for(OcTree::tree_iterator it = tree->begin_tree(maxDepth), end=tree->end_tree();
it!= end; ++it){
//count ++;
//std::cout << it.getDepth() << " " << " "<<it.getCoordinate()<< std::endl;
list_iterator.push_back(OcTreeVolume(it.getCoordinate(), it.getSize()));
}
gettimeofday(&stop, NULL); // stop timer
time_it = timediff(start, stop);
list_iterator.sort(OcTreeVolumeSortPredicate);
list_depr.sort(OcTreeVolumeSortPredicate);
std::cout << "All inner lists traversed, times: "
<<time_it << " / " << time_depr << "\n";
compareResults(list_iterator, list_depr);
std::cout << "========================\n\n";
// traverse all leaf nodes, timing:
gettimeofday(&start, NULL); // start timers
count = 0;
for(OcTree::iterator it = tree->begin(maxDepth), end=tree->end();
it!= end; ++it){
// do something:
// std::cout << it.getDepth() << " " << " "<<it.getCoordinate()<< std::endl;
count++;
}
gettimeofday(&stop, NULL); // stop timer
time_it = timediff(start, stop);
std::cout << "Time to traverse all leafs at max depth " <<(unsigned int)maxDepth <<" ("<<count<<" nodes): "<< time_it << " s\n\n";
/**
* bounding box tests
*/
boundingBoxTest(tree);
boundingBoxTest(&emptyTree);
// test tree with one node:
OcTree simpleTree(0.01);
simpleTree.updateNode(point3d(10, 10, 10), 5.0f);
for(OcTree::leaf_iterator it = simpleTree.begin_leafs(maxDepth), end=simpleTree.end_leafs(); it!= end; ++it) {
std::cout << it.getDepth() << " " << " "<<it.getCoordinate()<< std::endl;
}
std::cout << "Tests successful\n";
return 0;
}
| 14,038 | 31.273563 | 151 | cpp |
octomap | octomap-master/octomap/src/testing/test_mapcollection.cpp |
#include <stdio.h>
#include <octomap/MapCollection.h>
#include <octomap/math/Utils.h>
#include "testing.h"
using namespace std;
using namespace octomap;
using namespace octomath;
OcTree* generateSphereTree(point3d origin, float radius){
OcTree* tree = new OcTree(0.05);
point3d point_on_surface = origin;
point_on_surface.x() += radius;
for (int i=0; i<360; i++) {
for (int j=0; j<360; j++) {
if (!tree->insertRay(origin, origin+point_on_surface)) {
cout << "ERROR while inserting ray from " << origin << " to " << point_on_surface << endl;
}
point_on_surface.rotate_IP (0,0,DEG2RAD(1.));
}
point_on_surface.rotate_IP (0,DEG2RAD(1.),0);
}
return tree;
}
int main(int /*argc*/, char** argv) {
// //Generate a MapCollection
// MapCollection<MapNode<OcTree> > coll;
// OcTree* tree1 = generateSphereTree(point3d(0.01f,0.01f,0.01f), 2.0f);
// MapNode<OcTree>* mn1 = new MapNode<OcTree>(tree1, pose6d(0.0,0.0,0.0,0.0,0.0,0.0));
// mn1->setId("nodeone");
// coll.addNode(mn1);
// OcTree* tree2 = generateSphereTree(point3d(0.01f,0.01f,0.01f), 3.5f);
// MapNode<OcTree>* mn2 = new MapNode<OcTree>(tree2, pose6d(3.0,7.0,10.0,0.0,0.0,0.0));
// mn2->setId("nodetwo");
// coll.addNode(mn2);
// //Write the MapCollection
// coll.write("tempcollection.txt");
// //Read it back in
// MapCollection<MapNode<OcTree> > coll_read("tempcollection.txt");
//TODO do some ray operations
//TODO do some isOccupied operations
//TODO do some comparisons between original and re-read MaCollection
//Read MapCollection from command line
std::string filename(argv[1]);
MapCollection<MapNode<OcTree> > collection(filename);
EXPECT_TRUE(collection.size() > 0);
//Write it to file
collection.write("writeout.txt");
//Write pointcloud to file
// collection.writePointcloud("test.vrml");
//TODO delete temporary files?
//tempcollection.txt
//nodeone.bt
//nodetwo.bt
//writeout.txt
//test.vrml
std::vector<point3d> query;
query.push_back(point3d(0,0,0));
query.push_back(point3d(2,0,0));
query.push_back(point3d(2,0,2));
query.push_back(point3d(1.99f,0.0f,0.0f));
query.push_back(point3d(0,0,3));
query.push_back(point3d(3,7,13.5));
query.push_back(point3d(0,-1,-1));
for (std::vector<point3d>::iterator it = query.begin(); it != query.end(); ++it) {
point3d& q = *it;
if (collection.isOccupied(q))
printf("q (%0.2f, %0.2f, %0.2f) is occupied\n", q.x(), q.y(), q.z());
else
printf("q (%0.2f, %0.2f, %0.2f) is NOT occupied\n", q.x(), q.y(), q.z());
printf("in fact, it has an occupancy probability of %0.2f\n", collection.getOccupancy(q));
}
point3d ray_origin (0,0,10);
point3d ray_direction (0,0,-10);
point3d ray_end (100,100,100);
if (collection.castRay(ray_origin, ray_direction, ray_end,true)) {
printf("ray from %.2f,%.2f,%.2f in dir %.2f,%.2f,%.2f hit obstacle at %.2f,%.2f,%.2f\n",
ray_origin.x(), ray_origin.y(), ray_origin.z(),
ray_direction.x(), ray_direction.y(), ray_direction.z(),
ray_end.x(), ray_end.y(), ray_end.z());
}
else {
printf("ray from %.2f,%.2f,%.2f in dir %.2f,%.2f,%.2f FAIL\n",
ray_origin.x(), ray_origin.y(), ray_origin.z(),
ray_direction.x(), ray_direction.y(), ray_direction.z());
}
printf("\n\n");
ray_origin = point3d(0,0,-10);
ray_direction = point3d(0,0,10);
if (collection.castRay(ray_origin, ray_direction, ray_end,true)) {
printf("ray from %.2f,%.2f,%.2f in dir %.2f,%.2f,%.2f hit obstacle at %.2f,%.2f,%.2f\n",
ray_origin.x(), ray_origin.y(), ray_origin.z(),
ray_direction.x(), ray_direction.y(), ray_direction.z(),
ray_end.x(), ray_end.y(), ray_end.z());
}
else {
printf("ray from %.2f,%.2f,%.2f in dir %.2f,%.2f,%.2f FAIL\n",
ray_origin.x(), ray_origin.y(), ray_origin.z(),
ray_direction.x(), ray_direction.y(), ray_direction.z());
}
printf("\n\n");
//....
ray_origin = point3d(0,-1.5,-3);
ray_direction = point3d(0,0,1);
if (collection.castRay(ray_origin, ray_direction, ray_end,true, 5)) {
printf("ray from %.2f,%.2f,%.2f in dir %.2f,%.2f,%.2f hit obstacle at %.2f,%.2f,%.2f\n",
ray_origin.x(), ray_origin.y(), ray_origin.z(),
ray_direction.x(), ray_direction.y(), ray_direction.z(),
ray_end.x(), ray_end.y(), ray_end.z());
}
else {
printf("ray from %.2f,%.2f,%.2f in dir %.2f,%.2f,%.2f FAIL\n",
ray_origin.x(), ray_origin.y(), ray_origin.z(),
ray_direction.x(), ray_direction.y(), ray_direction.z());
}
return 0;
}
| 4,629 | 31.605634 | 94 | cpp |
octomap | octomap-master/octomap/src/testing/test_pruning.cpp |
#include <octomap/octomap.h>
#include "testing.h"
using namespace std;
using namespace octomap;
using namespace octomath;
int main(int /*argc*/, char** /*argv*/) {
float res = 0.01f;
OcTree tree(res);
EXPECT_EQ(tree.size(), 0);
tree.prune();
EXPECT_EQ(tree.size(), 0);
point3d singlePt(-0.05f, -0.02f, 1.0f);
OcTreeKey singleKey;
tree.coordToKeyChecked(singlePt, singleKey);
OcTreeNode* singleNode = tree.updateNode(singleKey, true);
EXPECT_TRUE(singleNode);
EXPECT_EQ(singleNode, tree.search(singlePt));
OcTreeKey key;
// check all neighbors, none should exist:
for (key[2] = singleKey[2] - 1; key[2] <= singleKey[2] + 1; ++key[2]){
for (key[1] = singleKey[1] - 1; key[1] <= singleKey[1] + 1; ++key[1]){
for (key[0] = singleKey[0] - 1; key[0] <= singleKey[0] + 1; ++key[0]){
if (key != singleKey){
OcTreeNode* node = tree.search(key);
EXPECT_FALSE(node);
} else {
OcTreeNode* node = tree.search(key);
EXPECT_TRUE(node);
EXPECT_EQ(singleNode, node);
}
}
}
}
// pruning should do nothing:
tree.prune();
for (key[2] = singleKey[2] - 1; key[2] <= singleKey[2] + 1; ++key[2]){
for (key[1] = singleKey[1] - 1; key[1] <= singleKey[1] + 1; ++key[1]){
for (key[0] = singleKey[0] - 1; key[0] <= singleKey[0] + 1; ++key[0]){
if (key != singleKey){
OcTreeNode* node = tree.search(key);
EXPECT_FALSE(node);
} else {
OcTreeNode* node = tree.search(key);
EXPECT_TRUE(node);
EXPECT_EQ(singleNode, node);
}
}
}
}
// node + 1 branch of depth 16
EXPECT_EQ(tree.calcNumNodes(), tree.size());
EXPECT_EQ(tree.size(), 17);
// create diagonal neighbor in same parent node
OcTreeKey singleKey2 = singleKey;
singleKey2[0] +=1;
singleKey2[1] +=1;
singleKey2[2] +=1;
OcTreeNode* singleNode2 = tree.updateNode(singleKey2, true);
EXPECT_TRUE(singleNode2);
for (key[2] = singleKey[2] - 1; key[2] <= singleKey[2] + 1; ++key[2]){
for (key[1] = singleKey[1] - 1; key[1] <= singleKey[1] + 1; ++key[1]){
for (key[0] = singleKey[0] - 1; key[0] <= singleKey[0] + 1; ++key[0]){
if (key == singleKey){
OcTreeNode* node = tree.search(key);
EXPECT_TRUE(node);
EXPECT_EQ(singleNode, node);
} else if (key == singleKey2){
OcTreeNode* node = tree.search(key);
EXPECT_TRUE(node);
EXPECT_EQ(singleNode2, node);
} else{
OcTreeNode* node = tree.search(key);
EXPECT_FALSE(node);
}
}
}
}
EXPECT_EQ(tree.calcNumNodes(), tree.size());
EXPECT_EQ(tree.size(), 18); // one more leaf at lowest level
// pruning should do nothing:
tree.prune();
for (key[2] = singleKey[2] - 1; key[2] <= singleKey[2] + 1; ++key[2]){
for (key[1] = singleKey[1] - 1; key[1] <= singleKey[1] + 1; ++key[1]){
for (key[0] = singleKey[0] - 1; key[0] <= singleKey[0] + 1; ++key[0]){
if (key == singleKey){
OcTreeNode* node = tree.search(key);
EXPECT_TRUE(node);
EXPECT_EQ(singleNode, node);
} else if (key == singleKey2){
OcTreeNode* node = tree.search(key);
EXPECT_TRUE(node);
EXPECT_EQ(singleNode2, node);
} else{
OcTreeNode* node = tree.search(key);
EXPECT_FALSE(node);
}
}
}
}
EXPECT_EQ(tree.calcNumNodes(), tree.size());
EXPECT_EQ(tree.size(), 18);
//tree.write("pruning_test_out0.ot");
// fill the complete octant, should auto-prune
tree.updateNode(OcTreeKey(singleKey[0]+1, singleKey[1]+0, singleKey[2]+0), true);
tree.updateNode(OcTreeKey(singleKey[0]+1, singleKey[1]+1, singleKey[2]+0), true);
tree.updateNode(OcTreeKey(singleKey[0]+0, singleKey[1]+1, singleKey[2]+0), true);
tree.updateNode(OcTreeKey(singleKey[0]+0, singleKey[1]+0, singleKey[2]+1), true);
tree.updateNode(OcTreeKey(singleKey[0]+1, singleKey[1]+0, singleKey[2]+1), true);
EXPECT_EQ(tree.size(), 23);
// last node should trigger auto-pruning:
OcTreeNode* prunedNode = tree.updateNode(OcTreeKey(singleKey[0]+0, singleKey[1]+1, singleKey[2]+1), true);
EXPECT_EQ(tree.size(), 16);
// all queries should now end up at same parent node:
OcTreeNode* parentNode = tree.search(singleKey);
OcTreeNode* parentNode2 = tree.search(singleKey2);
EXPECT_EQ(parentNode, parentNode2);
// test pointer returned by updateNode (pruned)
EXPECT_EQ(prunedNode, parentNode);
//tree.write("pruning_test_out1.ot");
// now test larger volume pruning:
for (float x=0.005f; x <= 0.32f; x+=res){
for (float y=0.005f; y <= 0.32f; y+=res){
for (float z=0.005f; z <= 0.32f; z+=res){
OcTreeNode* node = tree.updateNode(point3d(x,y,z), true);
EXPECT_TRUE(node);
EXPECT_TRUE(tree.isNodeOccupied(node));
}
}
}
EXPECT_EQ(tree.calcNumNodes(), tree.size());
EXPECT_EQ(27, tree.size());
// TODO: replace with test for lazy eval?
tree.prune();
EXPECT_EQ(tree.calcNumNodes(), tree.size());
EXPECT_EQ(27, tree.size());
tree.expand();
EXPECT_EQ(tree.calcNumNodes(), tree.size());
EXPECT_EQ(37483, tree.size());
tree.prune();
EXPECT_EQ(27, tree.size());
// test expansion:
for (float x=0.005f; x <= 0.32f; x+=res){
for (float y=0.005f; y <= 0.32f; y+=res){
for (float z=0.005f; z <= 0.32f; z+=res){
OcTreeNode* node = tree.search(point3d(x,y,z));
EXPECT_TRUE(node);
EXPECT_TRUE(tree.isNodeOccupied(node));
}
}
}
tree.coordToKeyChecked(point3d(0.1f, 0.1f, 0.1f), singleKey);
EXPECT_TRUE(tree.updateNode(singleKey, true));
for (float x=0.005f; x <= 0.32f; x+=res){
for (float y=0.005f; y <= 0.32f; y+=res){
for (float z=0.005f; z <= 0.32f; z+=res){
OcTreeNode* node = tree.search(point3d(x,y,z));
EXPECT_TRUE(node);
EXPECT_TRUE(tree.isNodeOccupied(node));
}
}
}
EXPECT_EQ(tree.calcNumNodes(), tree.size());
EXPECT_EQ(67, tree.size());
// test deletion / pruning of single nodes
{
std::cout << "\nCreating / deleting nodes\n===============================\n";
size_t initialSize = tree.size();
EXPECT_EQ(initialSize, tree.calcNumNodes());
EXPECT_EQ(initialSize, 67);
point3d newCoord(-2.0, -2.0, -2.0);
OcTreeNode* newNode = tree.updateNode(newCoord, true);
EXPECT_TRUE(newNode != NULL);
size_t insertedSize = tree.size();
std::cout << "Size after one insertion: " << insertedSize << std::endl;
EXPECT_EQ(insertedSize, tree.calcNumNodes());
EXPECT_EQ(insertedSize, 83);
// find parent of newly inserted node:
OcTreeNode* parentNode = tree.search(newCoord, tree.getTreeDepth() -1);
EXPECT_TRUE(parentNode);
EXPECT_TRUE(tree.nodeHasChildren(parentNode));
// only one child exists:
for (size_t i = 0; i < 7; ++i){
EXPECT_FALSE(tree.nodeChildExists(parentNode, i));
}
EXPECT_TRUE(tree.nodeChildExists(parentNode, 7));
// create another new node manually:
OcTreeNode* newNodeCreated = tree.createNodeChild(parentNode, 0);
EXPECT_TRUE(newNodeCreated != NULL);
EXPECT_TRUE(tree.nodeChildExists(parentNode, 0));
const float value = 0.123f;
newNodeCreated->setValue(value);
tree.write("pruning_test_edited.ot");
EXPECT_EQ(tree.size(), tree.calcNumNodes());
EXPECT_EQ(tree.size(), insertedSize+1);
tree.prune();
EXPECT_EQ(tree.calcNumNodes(), insertedSize+1);
tree.deleteNodeChild(parentNode, 0);
tree.deleteNodeChild(parentNode, 7);
EXPECT_EQ(tree.size(), tree.calcNumNodes());
EXPECT_EQ(tree.size(), insertedSize-1);
tree.prune();
EXPECT_EQ(tree.size(), tree.calcNumNodes());
EXPECT_EQ(tree.size(), insertedSize-1);
tree.expandNode(parentNode);
EXPECT_EQ(tree.size(), tree.calcNumNodes());
EXPECT_EQ(tree.size(), insertedSize+7);
EXPECT_TRUE(tree.pruneNode(parentNode));
EXPECT_EQ(tree.size(), tree.calcNumNodes());
EXPECT_EQ(tree.size(), insertedSize-1);
}
tree.write("pruning_test_out.ot");
{
std::cout << "\nClearing tree / recursive delete\n===============================\n";
OcTree emptyTree(0.1234);
EXPECT_EQ(emptyTree.size(), 0);
emptyTree.clear();
EXPECT_EQ(emptyTree.size(), emptyTree.calcNumNodes());
EXPECT_EQ(emptyTree.size(), 0);
tree.clear();
EXPECT_EQ(tree.size(), 0);
EXPECT_EQ(tree.size(), tree.calcNumNodes());
tree.prune();
EXPECT_EQ(tree.size(), 0);
}
tree.write("pruning_test_out.ot");
std::cerr << "Test successful.\n";
return 0;
}
| 9,201 | 33.724528 | 110 | cpp |
octomap | octomap-master/octomap/src/testing/test_raycasting.cpp |
#include <stdio.h>
#include <octomap/octomap.h>
#include <octomap/math/Utils.h>
#include "testing.h"
using namespace std;
using namespace octomap;
using namespace octomath;
int main(int /*argc*/, char** /*argv*/) {
OcTree tree (0.05);
// point3d origin (10.01, 10.01, 10.02);
point3d origin (0.01f, 0.01f, 0.02f);
point3d point_on_surface (2.01f, 0.01f, 0.01f);
cout << "Generating sphere at " << origin << " ..." << endl;
unsigned sphere_beams = 500;
double angle = 2.0*M_PI/double(sphere_beams);
Pointcloud p;
for (unsigned i=0; i<sphere_beams; i++) {
for (unsigned j=0; j<sphere_beams; j++) {
p.push_back(origin+point_on_surface);
point_on_surface.rotate_IP (0,0,angle);
}
point_on_surface.rotate_IP (0,angle,0);
}
tree.insertPointCloud(p, origin);
cout << "Writing to sphere.bt..." << endl;
EXPECT_TRUE(tree.writeBinary("sphere.bt"));
// -----------------------------------------------
cout << "Casting rays in sphere ..." << endl;
OcTree sampled_surface (0.05);
point3d direction = point3d (1.0,0.0,0.0);
point3d obstacle(0,0,0);
unsigned int hit (0);
unsigned int miss (0);
unsigned int unknown (0);
double mean_dist(0);
for (unsigned i=0; i<sphere_beams; i++) {
for (unsigned j=0; j<sphere_beams; j++) {
if (!tree.castRay(origin, direction, obstacle, false, 3.)) {
// hit unknown
if (!tree.search(obstacle))
unknown++;
else
miss++;
}
else {
hit++;
mean_dist += (obstacle - origin).norm();
sampled_surface.updateNode(obstacle, true);
}
direction.rotate_IP (0,0,angle);
}
direction.rotate_IP (0,angle,0);
}
cout << "Writing sampled_surface.bt" << endl;
EXPECT_TRUE(sampled_surface.writeBinary("sampled_surface.bt"));
mean_dist /= (double) hit;
std::cout << " hits / misses / unknown: " << hit << " / " << miss << " / " << unknown << std::endl;
std::cout << " mean obstacle dist: " << mean_dist << std::endl;
EXPECT_NEAR(mean_dist, 2., 0.05);
EXPECT_EQ(hit, (sphere_beams*sphere_beams));
EXPECT_EQ(miss, 0);
EXPECT_EQ(unknown, 0);
// -----------------------------------------------
cout << "generating single rays..." << endl;
OcTree single_beams(0.03333);
int num_beams = 17;
float beamLength = 10.0f;
point3d single_origin (1.0f, 0.45f, 0.45f);
point3d single_origin_top (1.0f, 0.45f, 1.0);
point3d single_endpoint(beamLength, 0.0f, 0.0f);
for (int i=0; i<num_beams; i++) {
for (int j=0; j<num_beams; j++) {
if (!single_beams.insertRay(single_origin, single_origin+single_endpoint)) {
cout << "ERROR while inserting ray from " << single_origin << " to " << single_endpoint << endl;
}
single_endpoint.rotate_IP (0,0,DEG2RAD(360.0/num_beams));
}
single_endpoint.rotate_IP (0,DEG2RAD(360.0/num_beams),0);
}
cout << "done." << endl;
cout << "writing to beams.bt..." << endl;
EXPECT_TRUE(single_beams.writeBinary("beams.bt"));
////// more tests from unit_tests.cpp:
double res = 0.1;
double res_2 = res/2.0;
OcTree cubeTree(res);
// fill a cube with "free", end is "occupied":
for (float x=-0.95f; x <= 1.0f; x+=float(res)){
for (float y=-0.95f; y <= 1.0f; y+= float(res)){
for (float z=-0.95f; z <= 1.0f; z+= float(res)){
if (x < 0.9){
EXPECT_TRUE(cubeTree.updateNode(point3d(x,y,z), false));
} else{
EXPECT_TRUE(cubeTree.updateNode(point3d(x,y,z), true));
}
}
}
}
// fill some "floor":
EXPECT_TRUE(cubeTree.updateNode(res_2,res_2,-res_2, true));
EXPECT_TRUE(cubeTree.updateNode(3*res_2,res_2,-res_2, true));
EXPECT_TRUE(cubeTree.updateNode(-res_2,res_2,-res_2, true));
EXPECT_TRUE(cubeTree.updateNode(-3*res_2,res_2,-res_2, true));
cubeTree.writeBinary("raycasting_cube.bt");
origin = point3d(0.0f, 0.0f, 0.0f);
point3d end;
// hit the corner:
direction = point3d(0.95f, 0.95f, 0.95f);
EXPECT_TRUE(cubeTree.castRay(origin, direction, end, false));
EXPECT_TRUE(cubeTree.isNodeOccupied(cubeTree.search(end)));
std::cout << "Hit occupied voxel: " << end << std::endl;
direction = point3d(1.0, 0.0, 0.0);
EXPECT_TRUE(cubeTree.castRay(origin, direction, end, false));
EXPECT_TRUE(cubeTree.isNodeOccupied(cubeTree.search(end)));
std::cout << "Hit occupied voxel: " << end << std::endl;
EXPECT_NEAR(1.0, (origin - end).norm(), res_2);
// hit bottom:
origin = point3d(float(res_2), float(res_2), 0.5f);
direction = point3d(0.0, 0.0, -1.0f);
EXPECT_TRUE(cubeTree.castRay(origin, direction, end, false));
EXPECT_TRUE(cubeTree.isNodeOccupied(cubeTree.search(end)));
std::cout << "Hit voxel: " << end << std::endl;
EXPECT_FLOAT_EQ(origin(0), end(0));
EXPECT_FLOAT_EQ(origin(1), end(1));
EXPECT_FLOAT_EQ(-res_2, end(2));
// hit boundary of unknown:
origin = point3d(0.0f, 0.0f, 0.0f);
direction = point3d(0.0f, 1.0f, 0.0f);
EXPECT_FALSE(cubeTree.castRay(origin, direction, end, false));
EXPECT_FALSE(cubeTree.search(end));
std::cout << "Boundary unknown hit: " << end << std::endl;
// hit boundary of octree:
EXPECT_FALSE(cubeTree.castRay(origin, direction, end, true));
EXPECT_FALSE(cubeTree.search(end));
EXPECT_FLOAT_EQ(end.x(), res_2);
EXPECT_FLOAT_EQ(end.y(), float(32768*res-res_2));
EXPECT_FLOAT_EQ(end.z(), res_2);
direction = point3d(-1.0f, 0.0f, 0.0f);
EXPECT_FALSE(cubeTree.castRay(origin, direction, end, true));
EXPECT_FALSE(cubeTree.search(end));
EXPECT_FLOAT_EQ(end.x(), float(-32767*res-res_2));
EXPECT_FLOAT_EQ(end.y(), res_2);
EXPECT_FLOAT_EQ(end.z(), res_2);
// test maxrange:
EXPECT_FALSE(cubeTree.castRay(origin, direction, end, true, 0.9));
std::cout << "Max range endpoint: " << end << std::endl;
OcTreeNode* endPt = cubeTree.search(end);
EXPECT_TRUE(endPt);
EXPECT_FALSE(cubeTree.isNodeOccupied(endPt));
double dist = (origin - end).norm();
EXPECT_NEAR(0.9, dist, res);
std::cout << "Test successful\n";
return 0;
}
| 6,039 | 29.816327 | 102 | cpp |
octomap | octomap-master/octomap/src/testing/test_scans.cpp |
#include <stdio.h>
#include <octomap/octomap.h>
#include <octomap/math/Utils.h>
#include "testing.h"
using namespace std;
using namespace octomap;
void printUsage(char* self){
std::cerr << "\nUSAGE: " << self << " spherical_scan.graph (reference file to compare, required)\n\n";
exit(1);
}
void comparePose(const pose6d& first, const pose6d& sec){
EXPECT_FLOAT_EQ(first.x(), sec.x());
EXPECT_FLOAT_EQ(first.y(), sec.y());
EXPECT_FLOAT_EQ(first.z(), sec.z());
EXPECT_FLOAT_EQ(first.roll(), sec.roll());
EXPECT_FLOAT_EQ(first.pitch(), sec.pitch());
EXPECT_FLOAT_EQ(first.yaw(), sec.yaw());
}
void comparePoint(const point3d& first, const point3d& sec){
EXPECT_FLOAT_EQ(first.x(), sec.x());
EXPECT_FLOAT_EQ(first.y(), sec.y());
EXPECT_FLOAT_EQ(first.z(), sec.z());
}
int main(int argc, char** argv) {
if (argc != 2){
printUsage(argv[0]);
}
std::string filename = std::string(argv[1]);
ScanGraph referenceGraph;
EXPECT_TRUE(referenceGraph.readBinary(filename));
// TODO: read in reference graph file
//##############################################################
point3d point_on_surface (4.01f, 0.01f, 0.01f);
Pointcloud* cloud = new Pointcloud();
for (int i=-50; i<51; i++) {
for (int j=-50; j<51; j++) {
point3d rotated = point_on_surface;
rotated.rotate_IP(0, DEG2RAD(i*0.5), DEG2RAD(j*0.5));
cloud->push_back(rotated);
}
}
pose6d origin(1.0, 0, -0.5, 0, 0, 0);
ScanGraph graph;
graph.addNode(cloud, origin); // graph assumes ownership of cloud!
{
std::cout << "Comparing ScanGraph with reference file at " << filename << std::endl;
EXPECT_TRUE(graph.size() == referenceGraph.size());
ScanNode* scanNode = *graph.begin();
ScanNode* refScanNode = *referenceGraph.begin();
EXPECT_EQ(scanNode->id, refScanNode->id);
comparePose(scanNode->pose, refScanNode->pose);
EXPECT_EQ(scanNode->scan->size(), refScanNode->scan->size());
for (size_t i = 0; i < scanNode->scan->size(); ++i){
comparePoint((*scanNode->scan)[i], (*refScanNode->scan)[i]);
}
}
// test reading and writing to file - to verify, are the values really exactly equal or just close?
{
std::cout << "Testing ScanGraph I/O" << std::endl;
EXPECT_TRUE(graph.writeBinary("spherical_scan_out.graph"));
ScanGraph reReadGraph;
EXPECT_TRUE(reReadGraph.readBinary("spherical_scan_out.graph"));
EXPECT_TRUE(graph.size() == reReadGraph.size());
EXPECT_EQ(reReadGraph.size(), 1);
ScanNode* scanNode = *graph.begin();
ScanNode* readScanNode = *reReadGraph.begin();
EXPECT_EQ(scanNode->id, readScanNode->id);
EXPECT_EQ(scanNode->pose, readScanNode->pose);
EXPECT_EQ(scanNode->scan->size(), readScanNode->scan->size());
for (size_t i = 0; i < scanNode->scan->size(); ++i){
EXPECT_EQ((*scanNode->scan)[i], (*readScanNode->scan)[i]);
}
}
// insert into OcTree
{
OcTree tree (0.05);
// insert in global coordinates:
tree.insertPointCloud(*cloud, origin.trans());
tree.writeBinary("spherical_scan.bt");
}
cout << "Test done." << endl;
exit(0);
}
| 3,219 | 26.058824 | 105 | cpp |
octomap | octomap-master/octomap/src/testing/testing.h | #include <math.h>
#include <stdlib.h>
// this is mimicing gtest expressions
#define EXPECT_TRUE(args) { \
if (!(args)) { fprintf(stderr, "test failed (EXPECT_TRUE) in %s, line %d\n", __FILE__, __LINE__); \
exit(1); \
} }
#define EXPECT_FALSE(args) { \
if (args) { fprintf(stderr, "test failed (EXPECT_FALSE) in %s, line %d\n", __FILE__, __LINE__); \
exit(1); \
} }
#define EXPECT_EQ(a,b) { \
if (!((a) == (b))) { std::cerr << "test failed: " <<a<<"!="<<b<< " in " \
<< __FILE__ << ", line " <<__LINE__ << std::endl; \
exit(1); \
} }
#define EXPECT_FLOAT_EQ(a,b) { \
if (!(fabs((a) - (b)) <= 1e-5)) { fprintf(stderr, "test failed: %f != %f in %s, line %d\n", a, b, __FILE__, __LINE__); \
exit(1); \
} }
#define EXPECT_NEAR(a,b,prec) { \
if (!(fabs((a) - (b)) <= prec)) { fprintf(stderr, "test failed: |%f - %f| > %f in %s, line %d\n", a, b, prec, __FILE__, __LINE__); \
exit(1); \
} }
| 1,480 | 45.28125 | 136 | h |
octomap | octomap-master/octomap/src/testing/unit_tests.cpp | #include <stdio.h>
#include <string>
#ifdef _WIN32
#include <Windows.h> // to define Sleep()
#else
#include <unistd.h> // POSIX sleep()
#endif
#include <octomap/octomap.h>
#include <octomap/OcTreeStamped.h>
#include <octomap/math/Utils.h>
#include "testing.h"
using namespace std;
using namespace octomap;
using namespace octomath;
int main(int argc, char** argv) {
if (argc != 2){
std::cerr << "Error: you need to specify a test as argument" << std::endl;
return 1; // exit 1 means failure
}
std::string test_name (argv[1]);
// ------------------------------------------------------------
if (test_name == "MathVector") {
// test constructors
Vector3* twos = new Vector3();
Vector3* ones = new Vector3(1,1,1);
for (int i=0;i<3;i++) {
(*twos)(i) = 2;
}
// test basic operations
Vector3 subtraction = *twos - *ones;
Vector3 addition = *twos + *ones;
Vector3 multiplication = *twos * 2.;
for (int i=0;i<3;i++) {
EXPECT_FLOAT_EQ (subtraction(i), 1.);
EXPECT_FLOAT_EQ (addition(i), 3.);
EXPECT_FLOAT_EQ (multiplication(i), 4.);
}
// copy constructor
Vector3 rotation = *ones;
// rotation
rotation.rotate_IP (M_PI, 1., 0.1);
EXPECT_FLOAT_EQ (rotation.x(), 1.2750367);
EXPECT_FLOAT_EQ (rotation.y(), (-1.1329513));
EXPECT_FLOAT_EQ (rotation.z(), 0.30116868);
// ------------------------------------------------------------
} else if (test_name == "MathPose") {
// constructors
Pose6D a (1.0f, 0.1f, 0.1f, 0.0f, 0.1f, (float) M_PI/4. );
Pose6D b;
Vector3 trans(1.0f, 0.1f, 0.1f);
Quaternion rot(0.0f, 0.1f, (float) M_PI/4.);
Pose6D c(trans, rot);
// comparator
EXPECT_TRUE ( a == c);
// toEuler
EXPECT_FLOAT_EQ (c.yaw() , M_PI/4.);
// transform
Vector3 t = c.transform (trans);
EXPECT_FLOAT_EQ (t.x() , 1.6399229);
EXPECT_FLOAT_EQ (t.y() , 0.8813442);
EXPECT_FLOAT_EQ (t.z() , 0.099667005);
// inverse transform
Pose6D c_inv = c.inv();
Vector3 t2 = c_inv.transform (t);
EXPECT_FLOAT_EQ (t2.x() , trans.x());
EXPECT_FLOAT_EQ (t2.y() , trans.y());
EXPECT_FLOAT_EQ (t2.z() , trans.z());
// ------------------------------------------------------------
} else if (test_name == "InsertRay") {
double p = 0.5;
EXPECT_FLOAT_EQ(p, probability(logodds(p)));
p = 0.1;
EXPECT_FLOAT_EQ(p, probability(logodds(p)));
p = 0.99;
EXPECT_FLOAT_EQ(p, probability(logodds(p)));
float l = 0;
EXPECT_FLOAT_EQ(l, logodds(probability(l)));
l = -4;
EXPECT_FLOAT_EQ(l, logodds(probability(l)));
l = 2;
EXPECT_FLOAT_EQ(l, logodds(probability(l)));
OcTree tree (0.05);
tree.setProbHit(0.7);
tree.setProbMiss(0.4);
point3d origin (0.01f, 0.01f, 0.02f);
point3d point_on_surface (2.01f,0.01f,0.01f);
for (int i=0; i<360; i++) {
for (int j=0; j<360; j++) {
EXPECT_TRUE (tree.insertRay(origin, origin+point_on_surface));
point_on_surface.rotate_IP (0,0,DEG2RAD(1.));
}
point_on_surface.rotate_IP (0,DEG2RAD(1.),0);
}
EXPECT_TRUE (tree.writeBinary("sphere_rays.bt"));
EXPECT_EQ ((int) tree.size(), 50615);
// ------------------------------------------------------------
// ray casting is now in "test_raycasting.cpp"
// ------------------------------------------------------------
// insert scan test
// insert graph node test
// write graph test
} else if (test_name == "InsertScan") {
Pointcloud* measurement = new Pointcloud();
point3d origin (0.01f, 0.01f, 0.02f);
point3d point_on_surface (2.01f, 0.01f, 0.01f);
for (int i=0; i<360; i++) {
for (int j=0; j<360; j++) {
point3d p = origin+point_on_surface;
measurement->push_back(p);
point_on_surface.rotate_IP (0,0,DEG2RAD(1.));
}
point_on_surface.rotate_IP (0,DEG2RAD(1.),0);
}
OcTree tree (0.05);
tree.insertPointCloud(*measurement, origin);
EXPECT_EQ (tree.size(), 53959);
ScanGraph* graph = new ScanGraph();
Pose6D node_pose (origin.x(), origin.y(), origin.z(),0.0f,0.0f,0.0f);
graph->addNode(measurement, node_pose);
EXPECT_TRUE (graph->writeBinary("test.graph"));
delete graph;
// ------------------------------------------------------------
// graph read file test
} else if (test_name == "ReadGraph") {
// not really meaningful, see better test in "test_scans.cpp"
ScanGraph graph;
EXPECT_TRUE (graph.readBinary("test.graph"));
// ------------------------------------------------------------
} else if (test_name == "StampedTree") {
OcTreeStamped stamped_tree (0.05);
// fill tree
for (int x=-20; x<20; x++)
for (int y=-20; y<20; y++)
for (int z=-20; z<20; z++) {
point3d p ((float) x*0.05f+0.01f, (float) y*0.05f+0.01f, (float) z*0.05f+0.01f);
stamped_tree.updateNode(p, true); // integrate 'occupied' measurement
}
// test if update times set
point3d query (0.1f, 0.1f, 0.1f);
OcTreeNodeStamped* result = stamped_tree.search (query);
EXPECT_TRUE (result);
unsigned int tree_time = stamped_tree.getLastUpdateTime();
unsigned int node_time = result->getTimestamp();
std::cout << "After 1st update (cube): Tree time " <<tree_time << "; node(0.1, 0.1, 0.1) time " << result->getTimestamp() << std::endl;
EXPECT_TRUE (tree_time > 0);
#ifdef _WIN32
Sleep(1000);
#else
sleep(1);
#endif
stamped_tree.integrateMissNoTime(result); // reduce occupancy, no time update
std::cout << "After 2nd update (single miss): Tree time " <<tree_time << "; node(0.1, 0.1, 0.1) time " << node_time << std::endl;
EXPECT_EQ (node_time, result->getTimestamp()); // node time updated?
point3d query2 = point3d (0.1f, 0.1f, 0.3f);
stamped_tree.updateNode(query2, true); // integrate 'occupied' measurement
OcTreeNodeStamped* result2 = stamped_tree.search (query2);
EXPECT_TRUE (result2);
result = stamped_tree.search (query);
EXPECT_TRUE (result);
std::cout << "After 3rd update (single hit at (0.1, 0.1, 0.3): Tree time " << stamped_tree.getLastUpdateTime() << "; node(0.1, 0.1, 0.1) time " << result->getTimestamp()
<< "; node(0.1, 0.1, 0.3) time " << result2->getTimestamp() << std::endl;
EXPECT_TRUE (result->getTimestamp() < result2->getTimestamp()); // result2 has been updated
EXPECT_EQ(result2->getTimestamp(), stamped_tree.getLastUpdateTime());
// ------------------------------------------------------------
} else if (test_name == "OcTreeKey") {
OcTree tree (0.05);
point3d p(0.0,0.0,0.0);
OcTreeKey key;
tree.coordToKeyChecked(p, key);
point3d p_inv = tree.keyToCoord(key);
EXPECT_FLOAT_EQ (0.025, p_inv.x());
EXPECT_FLOAT_EQ (0.025, p_inv.y());
EXPECT_FLOAT_EQ (0.025, p_inv.z());
// ------------------------------------------------------------
} else {
std::cerr << "Invalid test name specified: " << test_name << std::endl;
return 1;
}
std::cerr << "Test successful.\n";
return 0;
}
| 7,147 | 32.558685 | 173 | cpp |
octomap | octomap-master/octovis/include/octovis/CameraFollowMode.h | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#ifndef CAMERAFOLLOWMODE_H_
#define CAMERAFOLLOWMODE_H_
#include "SceneObject.h"
#include <QObject>
class CameraFollowMode : public QObject {
Q_OBJECT
public:
CameraFollowMode(octomap::ScanGraph *graph = NULL);
virtual ~CameraFollowMode();
void setScanGraph(octomap::ScanGraph *graph);
public slots:
void jumpToFrame(unsigned int frame);
void cameraPathStopped(int id);
void cameraPathFrameChanged(int id, int current_camera_frame);
void play();
void pause();
void clearCameraPath();
void saveToCameraPath();
void addToCameraPath();
void removeFromCameraPath();
void followCameraPath();
void followRobotPath();
signals:
void changeCamPose(const octomath::Pose6D& pose);
void interpolateCamPose(const octomath::Pose6D& old_pose, const octomath::Pose6D& new_pose, double u);
void stopped();
void frameChanged(unsigned int frame);
void deleteCameraPath(int id);
void removeFromCameraPath(int id, int frame);
void updateCameraPath(int id, int frame);
void appendToCameraPath(int id, const octomath::Pose6D& pose);
void appendCurrentToCameraPath(int id);
void addCurrentToCameraPath(int id, int frame);
void playCameraPath(int id, int start_frame);
void stopCameraPath(int id);
void jumpToCamFrame(int id, int frame);
void changeNumberOfFrames(unsigned count);
void scanGraphAvailable(bool available);
protected:
octomap::ScanGraph *m_scan_graph;
unsigned int m_current_scan;
unsigned int m_current_cam_frame;
unsigned int m_number_cam_frames;
unsigned int m_start_frame;
bool m_followRobotTrajectory;
};
#endif /* CAMERAFOLLOWMODE_H_ */
| 2,602 | 31.5375 | 104 | h |
octomap | octomap-master/octovis/include/octovis/ColorOcTreeDrawer.h | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#ifndef OCTOVIS_COLOR_OCTREEDRAWER_H_
#define OCTOVIS_COLOR_OCTREEDRAWER_H_
#include <octovis/OcTreeDrawer.h>
#include <octomap/ColorOcTree.h>
namespace octomap {
class ColorOcTreeDrawer : public OcTreeDrawer {
public:
ColorOcTreeDrawer();
virtual ~ColorOcTreeDrawer();
virtual void setOcTree(const AbstractOcTree& tree_pnt, const pose6d& origin, int map_id_);
protected:
};
} // end namespace
#endif
| 1,428 | 28.163265 | 94 | h |
octomap | octomap-master/octovis/include/octovis/OcTreeDrawer.h | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#ifndef OCTREEDRAWER_H_
#define OCTREEDRAWER_H_
#include "SceneObject.h"
namespace octomap {
class OcTreeDrawer: public octomap::SceneObject {
public:
OcTreeDrawer();
virtual ~OcTreeDrawer();
void clear();
void draw() const;
// initialization of drawer -------------------------
/// sets a new OcTree that should be drawn by this drawer
void setOcTree(const AbstractOcTree& octree){
octomap::pose6d o; // initialized to (0,0,0) , (0,0,0,1) by default
setOcTree(octree, o, 0);
}
/// sets a new OcTree that should be drawn by this drawer
/// origin specifies a global transformation that should be applied
virtual void setOcTree(const AbstractOcTree& octree, const octomap::pose6d& origin, int map_id_);
// modification of existing drawer ------------------
/// sets a new selection of the current OcTree to be drawn
void setOcTreeSelection(const std::list<octomap::OcTreeVolume>& selectedPoints);
/// clear the visualization of the OcTree selection
void clearOcTreeSelection();
/// sets alpha level for occupied cells
void setAlphaOccupied(double alpha);
void setAlternativeDrawing(bool flag){m_alternativeDrawing = flag;}
void enableOcTree(bool enabled = true);
void enableOcTreeCells(bool enabled = true) { m_update = true; m_drawOccupied = enabled; };
void enableFreespace(bool enabled = true) { m_update = true; m_drawFree = enabled; };
void enableSelection(bool enabled = true) { m_update = true; m_drawSelection = enabled; };
void setMax_tree_depth(unsigned int max_tree_depth) { m_update = true; m_max_tree_depth = max_tree_depth;};
// set new origin (move object)
void setOrigin(octomap::pose6d t);
void enableAxes(bool enabled = true) { m_update = true; m_displayAxes = enabled; };
protected:
//void clearOcTree();
void clearOcTreeStructure();
void drawOctreeGrid() const;
void drawOccupiedVoxels() const;
void drawFreeVoxels() const;
void drawSelection() const;
void drawCubes(GLfloat** cubeArray, unsigned int cubeArraySize,
GLfloat* cubeColorArray = NULL) const;
void drawAxes() const;
//! Initializes the OpenGL visualization for a list of OcTreeVolumes
//! The array is cleared first, if needed
/// rotates cubes to correct reference frame
void generateCubes(const std::list<octomap::OcTreeVolume>& voxels,
GLfloat*** glArray, unsigned int& glArraySize,
octomath::Pose6D& origin,
GLfloat** glColorArray = NULL);
//! clear OpenGL visualization
void clearCubes(GLfloat*** glArray, unsigned int& glArraySize,
GLfloat** glColorArray = NULL);
//! setup OpenGL arrays
void initGLArrays(const unsigned int& num_cubes, unsigned int& glArraySize,
GLfloat*** glArray, GLfloat** glColorArray);
//! setup cube template
void initCubeTemplate(const octomath::Pose6D& origin,
std::vector<octomath::Vector3>& cube_template);
//! add one cube to arrays
unsigned int generateCube(const octomap::OcTreeVolume& v,
const std::vector<octomath::Vector3>& cube_template,
const unsigned int& current_array_idx,
GLfloat*** glArray);
unsigned int setCubeColorHeightmap(const octomap::OcTreeVolume& v,
const unsigned int& current_array_idx,
GLfloat** glColorArray);
unsigned int setCubeColorRGBA(const unsigned char& r, const unsigned char& g,
const unsigned char& b, const unsigned char& a,
const unsigned int& current_array_idx,
GLfloat** glColorArray);
void initOctreeGridVis();
//! OpenGL representation of Octree cells (cubes)
GLfloat** m_occupiedThresArray;
unsigned int m_occupiedThresSize;
GLfloat** m_freeThresArray;
unsigned int m_freeThresSize;
GLfloat** m_occupiedArray;
unsigned int m_occupiedSize;
GLfloat** m_freeArray;
unsigned int m_freeSize;
GLfloat** m_selectionArray;
unsigned int m_selectionSize;
//! Color array for occupied cells (height)
GLfloat* m_occupiedThresColorArray;
GLfloat* m_occupiedColorArray;
//! OpenGL representation of Octree (grid structure)
// TODO: put in its own drawer object!
GLfloat* octree_grid_vertex_array;
unsigned int octree_grid_vertex_size;
std::list<octomap::OcTreeVolume> m_grid_voxels;
bool m_drawOccupied;
bool m_drawOcTreeGrid;
bool m_drawFree;
bool m_drawSelection;
bool m_octree_grid_vis_initialized;
bool m_displayAxes;
bool m_alternativeDrawing;
mutable bool m_update;
unsigned int m_max_tree_depth;
double m_alphaOccupied;
octomap::pose6d origin;
octomap::pose6d initial_origin;
int map_id;
};
}
#endif /* OCTREEDRAWER_H_ */
| 6,070 | 36.018293 | 111 | h |
octomap | octomap-master/octovis/include/octovis/OcTreeRecord.h | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#ifndef OCTOVIS_OC_TREE_RECORD
#define OCTOVIS_OC_TREE_RECORD
#include <octovis/OcTreeDrawer.h>
namespace octomap {
class OcTreeRecord {
public:
AbstractOcTree* octree;
OcTreeDrawer* octree_drawer;
unsigned int id;
pose6d origin;
};
} // namespace
#endif
| 1,289 | 29 | 77 | h |
octomap | octomap-master/octovis/include/octovis/PointcloudDrawer.h | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#ifndef POINTCLOUDDRAWER_H_
#define POINTCLOUDDRAWER_H_
#include "SceneObject.h"
namespace octomap {
/**
* Drawer which visualizes Pointclouds
*/
class PointcloudDrawer: public ScanGraphDrawer {
public:
PointcloudDrawer();
PointcloudDrawer(const ScanGraph& graph);
virtual ~PointcloudDrawer();
virtual void draw() const;
virtual void clear();
virtual void setScanGraph(const ScanGraph& graph);
protected:
GLfloat* m_pointsArray;
unsigned m_numberPoints;
};
}
#endif /* POINTCLOUDDRAWER_H_ */
| 1,537 | 27.481481 | 77 | h |
octomap | octomap-master/octovis/include/octovis/SceneObject.h | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#ifndef SCENEOBJECT_H_
#define SCENEOBJECT_H_
// fix Windows includes
#include <qglobal.h>
#if defined(Q_WS_WIN) || defined(Q_OS_WIN)
#include <QtCore/qt_windows.h>
#endif
#if defined(Q_WS_MAC) || defined(Q_OS_MAC)
#include <OpenGL/glu.h>
#else
#include <GL/glu.h>
#endif
#include <octomap/octomap.h>
namespace octomap {
/**
* Abstract base class for objects to be drawn in the ViewerWidget.
*
*/
class SceneObject {
public:
enum ColorMode {
CM_FLAT,
CM_PRINTOUT,
CM_COLOR_HEIGHT,
CM_GRAY_HEIGHT,
CM_SEMANTIC
};
public:
SceneObject();
virtual ~SceneObject(){};
/**
* Actual draw function which will be called to visualize the object
*/
virtual void draw() const = 0;
/**
* Clears the object's representation (will be called when it gets invalid)
*/
virtual void clear(){};
public:
//! the color mode has to be set before calling OcTreDrawer::setMap()
//! because the cubes are generated in OcTreDrawer::setMap() using the color information
inline void setColorMode(ColorMode mode) { m_colorMode = mode; }
inline void enablePrintoutMode(bool enabled = true) { if (enabled) m_colorMode = CM_PRINTOUT; else m_colorMode = CM_FLAT; }
inline void enableHeightColorMode(bool enabled = true) { if (enabled) m_colorMode = CM_COLOR_HEIGHT; else m_colorMode = CM_FLAT; }
inline void enableSemanticColoring(bool enabled = true) { if (enabled) m_colorMode = CM_SEMANTIC; else m_colorMode = CM_FLAT; }
protected:
/// writes rgb values which correspond to a rel. height in the map.
/// (glArrayPos needs to have at least size 3!)
void heightMapColor(double h, GLfloat* glArrayPos) const;
void heightMapGray(double h, GLfloat* glArrayPos) const;
double m_zMin;
double m_zMax;
ColorMode m_colorMode;
};
/**
* Abstract base class for all objects visualizing ScanGraphs.
*/
class ScanGraphDrawer : public SceneObject {
public:
ScanGraphDrawer(): SceneObject(){};
virtual ~ScanGraphDrawer(){};
/**
* Notifies drawer of a new or changed ScanGraph, so that the internal
* representation can be rebuilt. Needs to be overloaded by each specific
* drawer.
*
* @param graph ScanGraph to be visualized
*/
virtual void setScanGraph(const octomap::ScanGraph& graph) = 0;
};
}
#endif /* SCENEOBJECT_H_ */
| 3,389 | 28.736842 | 134 | h |
octomap | octomap-master/octovis/include/octovis/SelectionBox.h | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#ifndef SELECTIONBOX_H_
#define SELECTIONBOX_H_
#include <qglviewer.h>
namespace octomap {
class SelectionBox{
public:
SelectionBox();
virtual ~SelectionBox();
void draw(bool withNames = false);
const qglviewer::ManipulatedFrame* frame (unsigned short i) const { return m_frames.at(i); }
qglviewer::ManipulatedFrame* frame (unsigned short i) { return m_frames.at(i); }
void getBBXMin(float& x, float& y, float& z) const;
void getBBXMax(float& x, float& y, float& z) const;
int getGrabbedFrame() const;
protected:
void drawAxis(float length = 0.2f) const;
bool m_visible;
std::vector<qglviewer::ManipulatedFrame*> m_frames;
unsigned short m_selectedFrame;
qglviewer::Vec m_minPt;
qglviewer::Vec m_maxPt;
float m_arrowLength;
};
}
#endif
| 1,806 | 27.68254 | 96 | h |
octomap | octomap-master/octovis/include/octovis/TrajectoryDrawer.h | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#ifndef TRAJECTORYDRAWER_H_
#define TRAJECTORYDRAWER_H_
#include "SceneObject.h"
#include <vector>
namespace octomap {
class TrajectoryDrawer : public ScanGraphDrawer{
public:
TrajectoryDrawer();
TrajectoryDrawer(const ScanGraph& graph);
virtual ~TrajectoryDrawer();
virtual void draw() const;
virtual void clear();
virtual void setScanGraph(const octomap::ScanGraph& graph);
protected:
GLfloat* m_trajectoryVertexArray;
GLfloat* m_trajectoryColorArray;
unsigned int m_trajectorySize; //!< number of nodes in the ScanGraph
};
}
#endif /* TRAJECTORYDRAWER_H_ */
| 1,600 | 30.392157 | 77 | h |
octomap | octomap-master/octovis/include/octovis/ViewerGui.h | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#ifndef VIEWERGUI_H
#define VIEWERGUI_H
#include <qglobal.h>
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
#include <QtWidgets>
#else // QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
#include <QtGui>
#endif // QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
#include <QFileDialog>
#include <QMessageBox>
#include <QDockWidget>
#include <string>
#include <cmath>
#include "TrajectoryDrawer.h"
#include "PointcloudDrawer.h"
#include "OcTreeDrawer.h"
#include "CameraFollowMode.h"
#include "ViewerWidget.h"
#include "ViewerSettings.h"
#include "ViewerSettingsPanel.h"
#include "ViewerSettingsPanelCamera.h"
#include "ui_ViewerGui.h"
#include <octomap/AbstractOcTree.h>
#include <octomap/OcTreeBase.h>
#include <octovis/OcTreeRecord.h>
namespace octomap {
class ViewerGui : public QMainWindow {
Q_OBJECT
public:
ViewerGui(const std::string& filename="", QWidget *parent = 0, unsigned int initTreeDepth = 16);
~ViewerGui();
static const unsigned int LASERTYPE_URG = 0;
static const unsigned int LASERTYPE_SICK = 1;
// use this drawer id if loading files or none is specified in msg
static const unsigned int DEFAULT_OCTREE_ID = 0;
public slots:
void changeTreeDepth(int depth);
void addNextScans(unsigned scans);
void gotoFirstScan();
bool isShown();
private slots:
// auto-connected Slots (by name))
void on_actionExit_triggered();
void on_actionOpen_file_triggered();
void on_actionOpen_graph_incremental_triggered();
void on_actionSave_file_triggered();
void on_actionExport_view_triggered();
void on_actionExport_sequence_triggered(bool checked);
void on_actionClear_selection_triggered();
void on_actionFill_selection_triggered();
void on_actionClear_unknown_in_selection_triggered();
void on_actionFill_unknown_in_selection_triggered();
void on_actionClear_nodes_in_selection_triggered();
void on_actionFill_nodes_in_selection_triggered();
void on_actionDelete_nodes_in_selection_triggered();
void on_actionDelete_nodes_outside_of_selection_triggered();
void on_actionHelp_triggered();
void on_actionSettings_triggered();
void on_actionPrune_tree_triggered();
void on_actionExpand_tree_triggered();
void on_actionConvert_ml_tree_triggered();
void on_actionReload_Octree_triggered();
void on_actionPrintout_mode_toggled(bool checked);
void on_actionSelection_box_toggled(bool checked);
void on_actionHeight_map_toggled(bool checked);
void on_actionSemanticColoring_toggled(bool checked);
void on_actionStore_camera_triggered();
void on_actionRestore_camera_triggered();
void on_actionPointcloud_toggled(bool checked);
void on_actionTrajectory_toggled(bool checked);
void on_actionOctree_cells_toggled(bool enabled);
void on_actionOctree_structure_toggled(bool enabled);
void on_actionFree_toggled(bool enabled);
void on_actionSelected_toggled(bool enabled);
void on_actionAxes_toggled(bool checked);
void on_actionHideBackground_toggled(bool checked);
void on_actionAlternateRendering_toggled(bool checked);
void on_actionClear_triggered();
void voxelSelected(const QMouseEvent* e);
void on_action_bg_black_triggered();
void on_action_bg_white_triggered();
void on_action_bg_gray_triggered();
void on_savecampose_triggered();
void on_loadcampose_triggered();
// use it for testcases etc.
void on_actionTest_triggered();
signals:
void updateStatusBar(QString message, int duration);
void changeNumberOfScans(unsigned scans);
void changeCurrentScan(unsigned scans);
void changeResolution(double resolution);
void changeCamPosition(double x, double y, double z, double lookX, double lookY, double lookZ);
private:
/**
* (Re-)load the data file stored in m_fileName.
* Depending on the extension, the respective load function is used.
*/
void openFile();
/**
* Reads in a .dat file which consists of single points in ASCII,
* one point per line, values separated by white spaces
*/
void openPointcloud();
/**
* Opens a .graph file and generates a ScanGraph from it. Afterwards,
* loadGraph() is called.
*/
void openGraph(bool completeGraph = true);
/**
* Finishes loading a ScanGraph, either from .log or .graph.
*/
void loadGraph(bool completeGraph = true);
/**
* Adds a scan from the graph to the OcTree
*/
void addNextScan();
/**
* Opens a .pc PointCloud
*/
void openPC();
/// open "regular" file containing an octree
void openOcTree();
/// open binary format OcTree
void openTree();
// EXPERIMENTAL
// open a map collection (.hot-file)
void openMapCollection();
void setOcTreeUISwitches();
/*!
* (Re-)generates OcTree from the internally stored ScanGraph
*/
void generateOctree();
void showOcTree();
void showInfo(QString string, bool newline=false);
void addOctree(AbstractOcTree* tree, int id, pose6d origin);
void addOctree(AbstractOcTree* tree, int id);
bool getOctreeRecord(int id, OcTreeRecord*& otr);
void saveCameraPosition(const char* filename) const;
void loadCameraPosition(const char* filename);
void updateNodesInBBX(const point3d& min, const point3d& max, bool occupied);
void setNodesInBBX(const point3d& min, const point3d& max, bool occupied);
void setNonNodesInBBX(const point3d& min, const point3d& max, bool occupied);
std::map<int, OcTreeRecord> m_octrees;
ScanGraph* m_scanGraph;
ScanGraph::iterator m_nextScanToAdd;
Ui::ViewerGuiClass ui;
ViewerWidget* m_glwidget;
TrajectoryDrawer* m_trajectoryDrawer;
PointcloudDrawer* m_pointcloudDrawer;
CameraFollowMode* m_cameraFollowMode;
double m_octreeResolution;
double m_laserMaxRange;
double m_occupancyThresh; // FIXME: This is not really used at the moment...
unsigned int m_max_tree_depth;
unsigned int m_laserType; // SICK or Hokuyo /URG
bool m_cameraStored;
QLabel* m_nodeSelected;
QLabel* m_mapSizeStatus;
QLabel* m_mapMemoryStatus;
/// Filename of last loaded file, in case it is necessary to reload it
std::string m_filename;
};
} // namespace
#endif // VIEWERGUI_H
| 7,314 | 30.943231 | 100 | h |
octomap | octomap-master/octovis/include/octovis/ViewerSettings.h | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#ifndef VIEWERSETTINGS_H
#define VIEWERSETTINGS_H
#include <QtGlobal>
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
#include <QtWidgets/QDialog>
#else // QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
#include <QtGui/QDialog>
#endif // QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
#include "ui_ViewerSettings.h"
class ViewerSettings : public QDialog
{
Q_OBJECT
public:
ViewerSettings(QWidget *parent = 0);
~ViewerSettings();
double getResolution(){return ui.resolution->value(); };
void setResolution(double resolution){ui.resolution->setValue(resolution);};
unsigned int getLaserType(){return ui.laserType->currentIndex(); };
void setLaserType(int type){ui.laserType->setCurrentIndex(type); };
double getMaxRange(){return ui.maxRange->value(); };
void setMaxRange(double range){ui.maxRange->setValue(range); };
private:
Ui::ViewerSettingsClass ui;
};
#endif // VIEWERSETTINGS_H
| 1,900 | 33.563636 | 80 | h |
octomap | octomap-master/octovis/include/octovis/ViewerSettingsPanel.h | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#ifndef VIEWERSETTINGSPANEL_H
#define VIEWERSETTINGSPANEL_H
#include <math.h>
#include <QWidget>
#include "ui_ViewerSettingsPanel.h"
#define _TREE_MAX_DEPTH 16
class ViewerSettingsPanel : public QWidget
{
Q_OBJECT
public:
ViewerSettingsPanel(QWidget *parent = 0);
~ViewerSettingsPanel();
public slots:
void setNumberOfScans(unsigned scans);
void setCurrentScan(unsigned scan);
void setResolution(double resolution);
void setTreeDepth(int depth);
private slots:
void on_firstScanButton_clicked();
void on_lastScanButton_clicked();
void on_nextScanButton_clicked();
void on_fastFwdScanButton_clicked();
signals:
void treeDepthChanged(int depth);
void addNextScans(unsigned scans);
void gotoFirstScan();
private:
void scanProgressChanged();
void leafSizeChanged();
Ui::ViewerSettingsPanelClass ui;
unsigned m_currentScan;
unsigned m_numberScans;
unsigned m_treeDepth;
double m_resolution;
};
#endif // VIEWERSETTINGSPANEL_H
| 1,998 | 27.15493 | 77 | h |
octomap | octomap-master/octovis/include/octovis/ViewerSettingsPanelCamera.h | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#ifndef VIEWERSETTINGSPANELFLYMODE_H
#define VIEWERSETTINGSPANELFLYMODE_H
#include <qglobal.h>
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
#include <QtWidgets/QWidget>
#else
#include <QtGui/QWidget>
#endif
#include "ui_ViewerSettingsPanelCamera.h"
class ViewerSettingsPanelCamera : public QWidget
{
Q_OBJECT
public:
ViewerSettingsPanelCamera(QWidget *parent = 0);
~ViewerSettingsPanelCamera();
QSize sizeHint() const;
public slots:
void setNumberOfFrames(unsigned frames);
void setCurrentFrame(unsigned frame);
void setRobotTrajectoryAvailable(bool available);
void setStopped();
private slots:
void on_firstScanButton_clicked();
void on_lastScanButton_clicked();
void on_nextScanButton_clicked();
void on_previousScanButton_clicked();
void on_playScanButton_clicked();
void on_scanProgressSlider_sliderMoved(int value);
void on_followCameraPathButton_clicked();
void on_followTrajectoryButton_clicked();
void on_cameraPathAdd_clicked();
void on_cameraPathRemove_clicked();
void on_cameraPathSave_clicked();
void on_cameraPathClear_clicked();
void positionEditDone(double);
signals:
void changeCamPosition(double x, double y, double z, double lookX, double lookY, double lookZ);
void jumpToFrame(unsigned int frame);
void play();
void pause();
void clearCameraPath();
void saveToCameraPath();
void removeFromCameraPath();
void addToCameraPath();
void followCameraPath();
void followRobotPath();
private:
void dataChanged();
void gotoFrame(unsigned int frame);
bool followRobotTrajectory();
Ui::ViewerSettingsPanelCameraClass ui;
unsigned int m_currentFrame;
unsigned int m_numberFrames;
bool m_robotTrajectoryAvailable;
};
#endif // VIEWERSETTINGSPANELFLYMODE_H
| 2,782 | 29.922222 | 96 | h |
octomap | octomap-master/octovis/include/octovis/ViewerWidget.h | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#ifndef VIEWERWIDGET_H_
#define VIEWERWIDGET_H_
#include "SceneObject.h"
#include "SelectionBox.h"
#include <octomap/octomap.h>
#include <qglviewer.h>
namespace octomap{
class ViewerWidget : public QGLViewer {
Q_OBJECT
public:
ViewerWidget(QWidget* parent = NULL);
void clearAll();
/**
* Adds an object to the scene that can be drawn
*
* @param obj SceneObject to be added
*/
void addSceneObject(SceneObject* obj);
/**
* Removes a SceneObject from the list of drawable objects if
* it has been added previously. Does nothing otherwise.
*
* @param obj SceneObject to be removed
*/
void removeSceneObject(SceneObject* obj);
public slots:
void enablePrintoutMode (bool enabled = true);
void enableHeightColorMode (bool enabled = true);
void enableSemanticColoring (bool enabled = true);
void enableSelectionBox (bool enabled = true);
void setCamPosition(double x, double y, double z, double lookX, double lookY, double lookZ);
void setCamPose(const octomath::Pose6D& pose);
virtual void setSceneBoundingBox(const qglviewer::Vec& min, const qglviewer::Vec& max);
void deleteCameraPath(int id);
void appendToCameraPath(int id, const octomath::Pose6D& pose);
void appendCurrentToCameraPath(int id);
void addCurrentToCameraPath(int id, int frame);
void removeFromCameraPath(int id, int frame);
void updateCameraPath(int id, int frame);
void jumpToCamFrame(int id, int frame);
void playCameraPath(int id, int start_frame);
void stopCameraPath(int id);
const SelectionBox& selectionBox() const { return m_selectionBox;}
/**
* Resets the 3D viewpoint to the initial value
*/
void resetView();
private slots:
void cameraPathFinished();
void cameraPathInterpolated();
signals:
void cameraPathStopped(int id);
void cameraPathFrameChanged(int id, int current_camera_frame);
void select(const QMouseEvent* e);
protected:
virtual void draw();
virtual void drawWithNames();
virtual void init();
/**
* Overloaded from QGLViewer. Draws own axis and grid in scale, then calls QGLViewer::postDraw().
*/
virtual void postDraw();
virtual void postSelection(const QPoint&);
virtual QString helpString() const;
qglviewer::Quaternion poseToQGLQuaternion(const octomath::Pose6D& pose);
std::vector<SceneObject*> m_sceneObjects;
SelectionBox m_selectionBox;
bool m_printoutMode;
bool m_heightColorMode;
bool m_semantic_coloring;
bool m_drawAxis; // actual state of axis (original overwritten)
bool m_drawGrid; // actual state of grid (original overwritten)
bool m_drawSelectionBox;
double m_zMin;
double m_zMax;
int m_current_camera_path;
int m_current_camera_frame;
};
}
#endif /* VIEWERWIDGET_H_ */
| 3,732 | 28.626984 | 99 | h |
octomap | octomap-master/octovis/src/CameraFollowMode.cpp | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#include <octovis/CameraFollowMode.h>
#include <iostream>
#define CAMERA_PATH_ID 13
#define ROBOT_TRAJECTORY_ID 14
CameraFollowMode::CameraFollowMode(octomap::ScanGraph *graph)
: QObject(), m_scan_graph(graph), m_current_scan(1), m_current_cam_frame(1), m_number_cam_frames(0),
m_followRobotTrajectory(false) {
}
CameraFollowMode::~CameraFollowMode() {
}
void CameraFollowMode::jumpToFrame(unsigned int frame) {
if(m_followRobotTrajectory) {
if(frame <= m_scan_graph->size()) {
m_current_scan = frame;
octomath::Pose6D pose = m_scan_graph->getNodeByID(frame-1)->pose;
emit changeCamPose(pose);
}
} else {
m_current_cam_frame = frame;
emit jumpToCamFrame(CAMERA_PATH_ID, m_current_cam_frame-1);
}
}
void CameraFollowMode::play() {
if(m_followRobotTrajectory) {
emit deleteCameraPath(ROBOT_TRAJECTORY_ID);
//emit appendCurrentToCameraPath(ROBOT_TRAJECTORY_ID);
m_start_frame = m_current_scan;
for(unsigned int i = m_start_frame; i <= m_scan_graph->size(); i++) {
octomap::ScanNode* scanNode = m_scan_graph->getNodeByID(i-1);
if (scanNode)
emit appendToCameraPath(ROBOT_TRAJECTORY_ID, scanNode->pose);
else{
std::cerr << "Error in " << __FILE__ << ":" << __LINE__ <<" : invalid node ID "<< i-1 << std::endl;
}
}
emit playCameraPath(ROBOT_TRAJECTORY_ID, 0);
} else {
m_start_frame = m_current_cam_frame;
emit playCameraPath(CAMERA_PATH_ID, m_start_frame-1);
}
}
void CameraFollowMode::pause() {
emit stopCameraPath(CAMERA_PATH_ID);
emit stopCameraPath(ROBOT_TRAJECTORY_ID);
}
void CameraFollowMode::setScanGraph(octomap::ScanGraph *graph) {
m_scan_graph = graph;
emit scanGraphAvailable(true);
}
void CameraFollowMode::cameraPathStopped(int id) {
if(id == CAMERA_PATH_ID || id == ROBOT_TRAJECTORY_ID) {
emit stopped();
}
}
void CameraFollowMode::cameraPathFrameChanged(int id, int current_camera_frame) {
if(m_followRobotTrajectory) {
m_current_scan = m_start_frame + current_camera_frame;
emit frameChanged(m_current_scan);
} else {
m_current_cam_frame = m_start_frame + current_camera_frame;
emit frameChanged(m_current_cam_frame);
}
}
void CameraFollowMode::clearCameraPath() {
emit deleteCameraPath(CAMERA_PATH_ID);
m_current_cam_frame = 1;
m_number_cam_frames = 0;
emit frameChanged(m_current_cam_frame);
emit changeNumberOfFrames(m_number_cam_frames);
}
void CameraFollowMode::saveToCameraPath() {
emit updateCameraPath(CAMERA_PATH_ID, m_current_cam_frame-1);
}
void CameraFollowMode::addToCameraPath() {
emit addCurrentToCameraPath(CAMERA_PATH_ID, m_current_cam_frame-1);
m_number_cam_frames++;
if(m_number_cam_frames == 1) m_current_cam_frame = 1;
else m_current_cam_frame++;
emit frameChanged(m_current_cam_frame);
emit changeNumberOfFrames(m_number_cam_frames);
}
void CameraFollowMode::removeFromCameraPath() {
if(m_number_cam_frames>0) {
emit removeFromCameraPath(CAMERA_PATH_ID, m_current_cam_frame-1);
m_number_cam_frames--;
emit changeNumberOfFrames(m_number_cam_frames);
}
}
void CameraFollowMode::followCameraPath() {
m_followRobotTrajectory = false;
emit frameChanged(m_current_cam_frame);
emit changeNumberOfFrames(m_number_cam_frames);
}
void CameraFollowMode::followRobotPath() {
if(m_scan_graph) {
m_followRobotTrajectory = true;
emit frameChanged(m_current_scan);
emit changeNumberOfFrames(m_scan_graph->size());
}
}
| 4,462 | 30.429577 | 107 | cpp |
octomap | octomap-master/octovis/src/ColorOcTreeDrawer.cpp | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#include <octovis/ColorOcTreeDrawer.h>
namespace octomap {
ColorOcTreeDrawer::ColorOcTreeDrawer()
: OcTreeDrawer() {
}
ColorOcTreeDrawer::~ColorOcTreeDrawer() {
}
void ColorOcTreeDrawer::setOcTree(const AbstractOcTree& tree_pnt,
const octomap::pose6d& origin_,
int map_id_) {
const ColorOcTree& tree = ((const ColorOcTree&) tree_pnt);
this->map_id = map_id_;
// save origin used during cube generation
this->initial_origin = octomap::pose6d(octomap::point3d(0,0,0), origin_.rot());
// origin is in global coords
this->origin = origin_;
// maximum size to prevent crashes on large maps: (should be checked in a better way than a constant)
bool showAll = (tree.size() < 5 * 1e6);
bool uses_origin = ( (origin_.rot().x() != 0.) && (origin_.rot().y() != 0.)
&& (origin_.rot().z() != 0.) && (origin_.rot().u() != 1.) );
// walk the tree one to find the number of nodes in each category
// (this is used to set up the OpenGL arrays)
// TODO: this step may be left out, if we maintained the GLArrays in std::vectors instead...
unsigned int cnt_occupied(0), cnt_occupied_thres(0), cnt_free(0), cnt_free_thres(0);
for(ColorOcTree::tree_iterator it = tree.begin_tree(this->m_max_tree_depth),
end=tree.end_tree(); it!= end; ++it) {
if (it.isLeaf()) {
if (tree.isNodeOccupied(*it)){ // occupied voxels
if (tree.isNodeAtThreshold(*it)) ++cnt_occupied_thres;
else ++cnt_occupied;
}
else if (showAll) { // freespace voxels
if (tree.isNodeAtThreshold(*it)) ++cnt_free_thres;
else ++cnt_free;
}
}
}
// setup GL arrays for cube quads and cube colors
initGLArrays(cnt_occupied , m_occupiedSize , &m_occupiedArray , &m_occupiedColorArray);
initGLArrays(cnt_occupied_thres, m_occupiedThresSize, &m_occupiedThresArray, &m_occupiedThresColorArray);
initGLArrays(cnt_free , m_freeSize , &m_freeArray, NULL);
initGLArrays(cnt_free_thres , m_freeThresSize , &m_freeThresArray, NULL);
std::vector<octomath::Vector3> cube_template;
initCubeTemplate(origin, cube_template);
unsigned int idx_occupied(0), idx_occupied_thres(0), idx_free(0), idx_free_thres(0);
unsigned int color_idx_occupied(0), color_idx_occupied_thres(0);
m_grid_voxels.clear();
OcTreeVolume voxel; // current voxel, possibly transformed
for(ColorOcTree::tree_iterator it = tree.begin_tree(this->m_max_tree_depth),
end=tree.end_tree(); it!= end; ++it) {
if (it.isLeaf()) { // voxels for leaf nodes
if (uses_origin)
voxel = OcTreeVolume(origin.rot().rotate(it.getCoordinate()), it.getSize());
else
voxel = OcTreeVolume(it.getCoordinate(), it.getSize());
if (tree.isNodeOccupied(*it)){ // occupied voxels
if (tree.isNodeAtThreshold(*it)) {
idx_occupied_thres = generateCube(voxel, cube_template, idx_occupied_thres, &m_occupiedThresArray);
color_idx_occupied_thres = setCubeColorRGBA(it->getColor().r, it->getColor().g, it->getColor().b,
(unsigned char) (it->getOccupancy() * 255.),
color_idx_occupied_thres, &m_occupiedThresColorArray);
}
else {
idx_occupied = generateCube(voxel, cube_template, idx_occupied, &m_occupiedArray);
color_idx_occupied = setCubeColorRGBA(it->getColor().r, it->getColor().g, it->getColor().b,
(unsigned char)(it->getOccupancy() * 255.),
color_idx_occupied, &m_occupiedColorArray);
}
}
else if (showAll) { // freespace voxels
if (tree.isNodeAtThreshold(*it)) {
idx_free_thres = generateCube(voxel, cube_template, idx_free_thres, &m_freeThresArray);
}
else {
idx_free = generateCube(voxel, cube_template, idx_free, &m_freeArray);
}
}
// grid structure voxel
if (showAll) m_grid_voxels.push_back(voxel);
}
else { // inner node voxels (for grid structure only)
if (showAll) {
if (uses_origin)
voxel = OcTreeVolume(origin.rot().rotate(it.getCoordinate()), it.getSize());
else
voxel = OcTreeVolume(it.getCoordinate(), it.getSize());
m_grid_voxels.push_back(voxel);
}
}
} // end for all voxels
m_octree_grid_vis_initialized = false;
if(m_drawOcTreeGrid)
initOctreeGridVis();
}
} // end namespace
| 5,902 | 41.467626 | 111 | cpp |
octomap | octomap-master/octovis/src/OcTreeDrawer.cpp | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#include <octovis/OcTreeDrawer.h>
#include <qglviewer.h>
#define OTD_RAD2DEG 57.2957795
namespace octomap {
OcTreeDrawer::OcTreeDrawer() : SceneObject(),
m_occupiedThresSize(0), m_freeThresSize(0),
m_occupiedSize(0), m_freeSize(0), m_selectionSize(0),
octree_grid_vertex_size(0), m_alphaOccupied(0.8), map_id(0)
{
m_octree_grid_vis_initialized = false;
m_drawOccupied = true;
m_drawOcTreeGrid = false;
m_drawFree = false;
m_drawSelection = true;
m_displayAxes = false;
m_update = true;
m_alternativeDrawing = false;
m_occupiedArray = NULL;
m_freeArray = NULL;
m_occupiedThresArray = NULL;
m_freeThresArray = NULL;
m_occupiedColorArray = NULL;
m_occupiedThresColorArray = NULL;
m_selectionArray = NULL;
// origin and movement
initial_origin = octomap::pose6d(0,0,0,0,0,0);
origin = initial_origin;
}
OcTreeDrawer::~OcTreeDrawer() {
clear();
}
void OcTreeDrawer::draw() const {
static int gl_list_index = -1;
if(m_alternativeDrawing && gl_list_index < 0){
gl_list_index = glGenLists(1);
m_update = true;
}
if(!m_alternativeDrawing && gl_list_index != -1){//Free video card memory
//std::cerr << "Freeing VRAM\n";
glDeleteLists(gl_list_index,1);
gl_list_index = -1;
}
if(m_update || !m_alternativeDrawing)
{
if(m_alternativeDrawing) {
std::cout << "Preparing batch rendering, please wait ...\n";
glNewList(gl_list_index, GL_COMPILE_AND_EXECUTE);
}
// push current status
glPushMatrix();
// octomap::pose6d relative_transform = origin * initial_origin.inv();
octomap::pose6d relative_transform = origin;// * initial_origin;
// apply relative transform
const octomath::Quaternion& q = relative_transform.rot();
glTranslatef(relative_transform.x(), relative_transform.y(), relative_transform.z());
// convert quaternion to angle/axis notation
float scale = sqrt(q.x() * q.x() + q.y() * q.y() + q.z() * q.z());
if (scale) {
float axis_x = q.x() / scale;
float axis_y = q.y() / scale;
float axis_z = q.z() / scale;
float angle = acos(q.u()) * 2.0f * OTD_RAD2DEG; // opengl expects DEG
glRotatef(angle, axis_x, axis_y, axis_z);
}
glEnableClientState(GL_VERTEX_ARRAY);
if (m_drawSelection) // Drawing voxels in descending alpha-channel magnitude avoids (most) artifacts
drawSelection();
if (m_drawOccupied)
drawOccupiedVoxels();
if (m_drawFree)
drawFreeVoxels();
if (m_drawOcTreeGrid)
drawOctreeGrid();
if (m_displayAxes) {
drawAxes();
}
glDisableClientState(GL_VERTEX_ARRAY);
// reset previous status
glPopMatrix();
if(m_alternativeDrawing) {
glEndList();
std::cout << "Finished preparation of batch rendering.\n";
}
m_update = false;
}
else
{
glCallList(gl_list_index);
}
}
void OcTreeDrawer::setAlphaOccupied(double alpha){
m_update = true;
m_alphaOccupied = alpha;
}
void OcTreeDrawer::setOcTree(const AbstractOcTree& in_tree, const pose6d& in_origin, int map_id_) {
const OcTree& octree = (const OcTree&) in_tree;
this->map_id = map_id_;
// save origin used during cube generation
this->initial_origin = octomap::pose6d(octomap::point3d(0,0,0), in_origin.rot());
// origin is in global coords
this->origin = in_origin;
// maximum size to prevent crashes on large maps: (should be checked in a better way than a constant)
bool showAll = (octree.size() < 5 * 1e6);
bool uses_origin = ( (origin.rot().x() != 0.) && (origin.rot().y() != 0.)
&& (origin.rot().z() != 0.) && (origin.rot().u() != 1.) );
// walk the tree one to find the number of nodes in each category
// (this is used to set up the OpenGL arrays)
// TODO: this step may be left out, if we maintained the GLArrays in std::vectors instead...
unsigned int cnt_occupied(0), cnt_occupied_thres(0), cnt_free(0), cnt_free_thres(0);
for(OcTree::tree_iterator it = octree.begin_tree(this->m_max_tree_depth),
end=octree.end_tree(); it!= end; ++it) {
if (it.isLeaf()) {
if (octree.isNodeOccupied(*it)){ // occupied voxels
if (octree.isNodeAtThreshold(*it)) ++cnt_occupied_thres;
else ++cnt_occupied;
}
else if (showAll) { // freespace voxels
if (octree.isNodeAtThreshold(*it)) ++cnt_free_thres;
else ++cnt_free;
}
}
}
// setup GL arrays for cube quads and cube colors
initGLArrays(cnt_occupied , m_occupiedSize , &m_occupiedArray , &m_occupiedColorArray);
initGLArrays(cnt_occupied_thres, m_occupiedThresSize, &m_occupiedThresArray, &m_occupiedThresColorArray);
initGLArrays(cnt_free , m_freeSize , &m_freeArray, NULL);
initGLArrays(cnt_free_thres , m_freeThresSize , &m_freeThresArray, NULL);
double minX, minY, minZ, maxX, maxY, maxZ;
octree.getMetricMin(minX, minY, minZ);
octree.getMetricMax(maxX, maxY, maxZ);
// set min/max Z for color height map
m_zMin = minZ;
m_zMax = maxZ;
std::vector<octomath::Vector3> cube_template;
initCubeTemplate(origin, cube_template);
unsigned int idx_occupied(0), idx_occupied_thres(0), idx_free(0), idx_free_thres(0);
unsigned int color_idx_occupied(0), color_idx_occupied_thres(0);
m_grid_voxels.clear();
OcTreeVolume voxel; // current voxel, possibly transformed
for(OcTree::tree_iterator it = octree.begin_tree(this->m_max_tree_depth),
end=octree.end_tree(); it!= end; ++it) {
if (it.isLeaf()) { // voxels for leaf nodes
if (uses_origin)
voxel = OcTreeVolume(origin.rot().rotate(it.getCoordinate()), it.getSize());
else
voxel = OcTreeVolume(it.getCoordinate(), it.getSize());
if (octree.isNodeOccupied(*it)){ // occupied voxels
if (octree.isNodeAtThreshold(*it)) {
idx_occupied_thres = generateCube(voxel, cube_template, idx_occupied_thres, &m_occupiedThresArray);
color_idx_occupied_thres = setCubeColorHeightmap(voxel, color_idx_occupied_thres, &m_occupiedThresColorArray);
}
else {
idx_occupied = generateCube(voxel, cube_template, idx_occupied, &m_occupiedArray);
color_idx_occupied = setCubeColorHeightmap(voxel, color_idx_occupied, &m_occupiedColorArray);
}
}
else if (showAll) { // freespace voxels
if (octree.isNodeAtThreshold(*it)) {
idx_free_thres = generateCube(voxel, cube_template, idx_free_thres, &m_freeThresArray);
}
else {
idx_free = generateCube(voxel, cube_template, idx_free, &m_freeArray);
}
}
}
else { // inner node voxels (for grid structure only)
if (showAll) {
if (uses_origin)
voxel = OcTreeVolume(origin.rot().rotate(it.getCoordinate()), it.getSize());
else
voxel = OcTreeVolume(it.getCoordinate(), it.getSize());
m_grid_voxels.push_back(voxel);
}
}
} // end for all voxels
m_octree_grid_vis_initialized = false;
if(m_drawOcTreeGrid)
initOctreeGridVis();
}
void OcTreeDrawer::setOcTreeSelection(const std::list<octomap::OcTreeVolume>& selectedVoxels){
m_update = true;
// init selectedVoxels GLarray
initGLArrays(selectedVoxels.size(), m_selectionSize, &m_selectionArray, NULL);
generateCubes(selectedVoxels, &m_selectionArray, m_selectionSize, this->origin);
}
void OcTreeDrawer::clearOcTreeSelection(){
m_update = true;
clearCubes(&m_selectionArray, m_selectionSize);
}
void OcTreeDrawer::initGLArrays(const unsigned int& num_cubes,
unsigned int& glArraySize,
GLfloat*** glArray, GLfloat** glColorArray) {
clearCubes(glArray, glArraySize, glColorArray);
// store size of GL arrays for drawing
glArraySize = num_cubes * 4 * 3;
// allocate cube arrays, 6 quads per cube
*glArray = new GLfloat* [6];
for (unsigned i = 0; i<6; ++i){
(*glArray)[i] = new GLfloat[glArraySize];
}
// setup quad color array, if given
if (glColorArray != NULL)
*glColorArray = new GLfloat[glArraySize * 4 *4];
}
void OcTreeDrawer::initCubeTemplate(const octomath::Pose6D& origin,
std::vector<octomath::Vector3>& cube_template) {
cube_template.clear();
cube_template.reserve(24);
cube_template.push_back(octomath::Vector3( 1, 1,-1));
cube_template.push_back(octomath::Vector3( 1,-1,-1));
cube_template.push_back(octomath::Vector3( 1, 1,-1));
cube_template.push_back(octomath::Vector3(-1, 1,-1));
cube_template.push_back(octomath::Vector3( 1, 1,-1));
cube_template.push_back(octomath::Vector3( 1, 1, 1));
cube_template.push_back(octomath::Vector3(-1, 1,-1));
cube_template.push_back(octomath::Vector3(-1,-1,-1));
cube_template.push_back(octomath::Vector3( 1, 1, 1));
cube_template.push_back(octomath::Vector3(-1, 1, 1));
cube_template.push_back(octomath::Vector3( 1,-1,-1));
cube_template.push_back(octomath::Vector3( 1,-1, 1));
cube_template.push_back(octomath::Vector3(-1, 1, 1));
cube_template.push_back(octomath::Vector3(-1,-1, 1));
cube_template.push_back(octomath::Vector3( 1,-1, 1));
cube_template.push_back(octomath::Vector3(-1,-1, 1));
cube_template.push_back(octomath::Vector3(-1,-1,-1));
cube_template.push_back(octomath::Vector3(-1,-1, 1));
cube_template.push_back(octomath::Vector3( 1, 1, 1));
cube_template.push_back(octomath::Vector3( 1,-1, 1));
cube_template.push_back(octomath::Vector3( 1,-1,-1));
cube_template.push_back(octomath::Vector3(-1,-1,-1));
cube_template.push_back(octomath::Vector3(-1, 1,-1));
cube_template.push_back(octomath::Vector3(-1, 1, 1));
}
unsigned int OcTreeDrawer::generateCube(const octomap::OcTreeVolume& v,
const std::vector<octomath::Vector3>& cube_template,
const unsigned int& current_array_idx,
GLfloat*** glArray) {
// epsilon to be substracted from cube size so that neighboring planes don't overlap
// seems to introduce strange artifacts nevertheless...
double eps = 1e-5;
octomath::Vector3 p;
double half_cube_size = GLfloat(v.second /2.0 -eps);
unsigned int i = current_array_idx;
// Cube surfaces are in gl_array in order: back, front, top, down, left, right.
// Arrays are filled in parallel (increasing i for all at once)
// One color array for all surfaces is filled when requested
p = v.first + cube_template[0] * half_cube_size;
(*glArray)[0][i] = p.x();
(*glArray)[0][i+1] = p.y();
(*glArray)[0][i+2] = p.z();
p = v.first + cube_template[1] * half_cube_size;
(*glArray)[1][i] = p.x();
(*glArray)[1][i+1] = p.y();
(*glArray)[1][i+2] = p.z();
p = v.first + cube_template[2] * half_cube_size;
(*glArray)[2][i] = p.x();
(*glArray)[2][i+1] = p.y();
(*glArray)[2][i+2] = p.z();
p = v.first + cube_template[3] * half_cube_size;
(*glArray)[3][i] = p.x();
(*glArray)[3][i+1] = p.y();
(*glArray)[3][i+2] = p.z();
p = v.first + cube_template[4] * half_cube_size;
(*glArray)[4][i] = p.x();
(*glArray)[4][i+1] = p.y();
(*glArray)[4][i+2] = p.z();
p = v.first + cube_template[5] * half_cube_size;
(*glArray)[5][i] = p.x();
(*glArray)[5][i+1] = p.y();
(*glArray)[5][i+2] = p.z();
i+= 3; //-------------------
p = v.first + cube_template[6] * half_cube_size;
(*glArray)[0][i] = p.x();
(*glArray)[0][i+1] = p.y();
(*glArray)[0][i+2] = p.z();
p = v.first + cube_template[7] * half_cube_size;
(*glArray)[1][i] = p.x();
(*glArray)[1][i+1] = p.y();
(*glArray)[1][i+2] = p.z();
p = v.first + cube_template[8] * half_cube_size;
(*glArray)[2][i] = p.x();
(*glArray)[2][i+1] = p.y();
(*glArray)[2][i+2] = p.z();
p = v.first + cube_template[9] * half_cube_size;
(*glArray)[3][i] = p.x();
(*glArray)[3][i+1] = p.y();
(*glArray)[3][i+2] = p.z();
p = v.first + cube_template[10] * half_cube_size;
(*glArray)[4][i] = p.x();
(*glArray)[4][i+1] = p.y();
(*glArray)[4][i+2] = p.z();
p = v.first + cube_template[11] * half_cube_size;
(*glArray)[5][i] = p.x();
(*glArray)[5][i+1] = p.y();
(*glArray)[5][i+2] = p.z();
i+= 3; //-------------------
p = v.first + cube_template[12] * half_cube_size;
(*glArray)[0][i] = p.x();
(*glArray)[0][i+1] = p.y();
(*glArray)[0][i+2] = p.z();
p = v.first + cube_template[13] * half_cube_size;
(*glArray)[1][i] = p.x();
(*glArray)[1][i+1] = p.y();
(*glArray)[1][i+2] = p.z();
p = v.first + cube_template[14] * half_cube_size;
(*glArray)[2][i] = p.x();
(*glArray)[2][i+1] = p.y();
(*glArray)[2][i+2] = p.z();
p = v.first + cube_template[15] * half_cube_size;
(*glArray)[3][i] = p.x();
(*glArray)[3][i+1] = p.y();
(*glArray)[3][i+2] = p.z();
p = v.first + cube_template[16] * half_cube_size;
(*glArray)[4][i] = p.x();
(*glArray)[4][i+1] = p.y();
(*glArray)[4][i+2] = p.z();
p = v.first + cube_template[17] * half_cube_size;
(*glArray)[5][i] = p.x();
(*glArray)[5][i+1] = p.y();
(*glArray)[5][i+2] = p.z();
i+= 3; //-------------------
p = v.first + cube_template[18] * half_cube_size;
(*glArray)[0][i] = p.x();
(*glArray)[0][i+1] = p.y();
(*glArray)[0][i+2] = p.z();
p = v.first + cube_template[19] * half_cube_size;
(*glArray)[1][i] = p.x();
(*glArray)[1][i+1] = p.y();
(*glArray)[1][i+2] = p.z();
p = v.first + cube_template[20] * half_cube_size;
(*glArray)[2][i] = p.x();
(*glArray)[2][i+1] = p.y();
(*glArray)[2][i+2] = p.z();
p = v.first + cube_template[21] * half_cube_size;
(*glArray)[3][i] = p.x();
(*glArray)[3][i+1] = p.y();
(*glArray)[3][i+2] = p.z();
p = v.first + cube_template[22] * half_cube_size;
(*glArray)[4][i] = p.x();
(*glArray)[4][i+1] = p.y();
(*glArray)[4][i+2] = p.z();
p = v.first + cube_template[23] * half_cube_size;
(*glArray)[5][i] = p.x();
(*glArray)[5][i+1] = p.y();
(*glArray)[5][i+2] = p.z();
i += 3; //-------------------
return i; // updated array idx
}
unsigned int OcTreeDrawer::setCubeColorHeightmap(const octomap::OcTreeVolume& v,
const unsigned int& current_array_idx,
GLfloat** glColorArray) {
if (glColorArray == NULL) return current_array_idx;
unsigned int colorIdx = current_array_idx;
// color for all 4 vertices (same height)
for (int k = 0; k < 4; ++k) {
if (m_colorMode == CM_GRAY_HEIGHT)
SceneObject::heightMapGray(v.first.z(), *glColorArray + colorIdx); // sets r,g,b
else
SceneObject::heightMapColor(v.first.z(), *glColorArray + colorIdx); // sets r,g,b
// set Alpha value:
(*glColorArray)[colorIdx + 3] = m_alphaOccupied;
colorIdx += 4;
}
return colorIdx;
}
unsigned int OcTreeDrawer::setCubeColorRGBA(const unsigned char& r,
const unsigned char& g,
const unsigned char& b,
const unsigned char& a,
const unsigned int& current_array_idx,
GLfloat** glColorArray) {
if (glColorArray == NULL) return current_array_idx;
unsigned int colorIdx = current_array_idx;
// set color for next 4 vertices (=one quad)
for (int k = 0; k < 4; ++k) {
(*glColorArray)[colorIdx ] = (double) r/255.;
(*glColorArray)[colorIdx + 1] = (double) g/255.;
(*glColorArray)[colorIdx + 2] = (double) b/255.;
(*glColorArray)[colorIdx + 3] = (double) a/255.;
colorIdx += 4;
}
return colorIdx;
}
void OcTreeDrawer::clearCubes(GLfloat*** glArray,
unsigned int& glArraySize,
GLfloat** glColorArray) {
if (glArraySize != 0) {
for (unsigned i = 0; i < 6; ++i) {
delete[] (*glArray)[i];
}
delete[] *glArray;
*glArray = NULL;
glArraySize = 0;
}
if (glColorArray != NULL && *glColorArray != NULL) {
delete[] *glColorArray;
*glColorArray = NULL;
}
}
// still used for "selection" nodes
void OcTreeDrawer::generateCubes(const std::list<octomap::OcTreeVolume>& voxels,
GLfloat*** glArray, unsigned int& glArraySize,
octomath::Pose6D& origin,
GLfloat** glColorArray) {
unsigned int i = 0;
unsigned int colorIdx = 0;
std::vector<octomath::Vector3> cube_template;
initCubeTemplate(origin, cube_template);
for (std::list<octomap::OcTreeVolume>::const_iterator it=voxels.begin();
it != voxels.end(); it++) {
i = generateCube(*it, cube_template, i, glArray);
}
if (glColorArray != NULL) {
for (std::list<octomap::OcTreeVolume>::const_iterator it=voxels.begin();
it != voxels.end(); it++) {
colorIdx = setCubeColorHeightmap(*it, colorIdx, glColorArray);
}
}
}
void OcTreeDrawer::initOctreeGridVis() {
if (m_octree_grid_vis_initialized) return;
clearOcTreeStructure();
// allocate arrays for octree grid visualization
octree_grid_vertex_size = m_grid_voxels.size() * 12 * 2 * 3;
octree_grid_vertex_array = new GLfloat[octree_grid_vertex_size];
// generate the cubes, 12 lines each
std::list<octomap::OcTreeVolume>::iterator it_rec;
unsigned int i = 0;
double x,y,z;
for (it_rec=m_grid_voxels.begin(); it_rec != m_grid_voxels.end(); it_rec++) {
x = it_rec->first.x();
y = it_rec->first.y();
z = it_rec->first.z();
double half_voxel_size = it_rec->second / 2.0;
// ----
octree_grid_vertex_array[i] = x + half_voxel_size;
octree_grid_vertex_array[i+1] = y + half_voxel_size;
octree_grid_vertex_array[i+2] = z - half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x - half_voxel_size;
octree_grid_vertex_array[i+1] = y + half_voxel_size;
octree_grid_vertex_array[i+2] = z - half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x - half_voxel_size;
octree_grid_vertex_array[i+1] = y + half_voxel_size;
octree_grid_vertex_array[i+2] = z - half_voxel_size;
i += 3;
octree_grid_vertex_array[i] = x - half_voxel_size;
octree_grid_vertex_array[i+1] = y + half_voxel_size;
octree_grid_vertex_array[i+2] = z + half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x - half_voxel_size;
octree_grid_vertex_array[i+1] = y + half_voxel_size;
octree_grid_vertex_array[i+2] = z + half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x + half_voxel_size;
octree_grid_vertex_array[i+1] = y + half_voxel_size;
octree_grid_vertex_array[i+2] = z + half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x + half_voxel_size;
octree_grid_vertex_array[i+1] = y + half_voxel_size;
octree_grid_vertex_array[i+2] = z + half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x + half_voxel_size;
octree_grid_vertex_array[i+1] = y + half_voxel_size;
octree_grid_vertex_array[i+2] = z - half_voxel_size;
i+= 3;
// ----
octree_grid_vertex_array[i] = x + half_voxel_size;
octree_grid_vertex_array[i+1] = y - half_voxel_size;
octree_grid_vertex_array[i+2] = z + half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x - half_voxel_size;
octree_grid_vertex_array[i+1] = y - half_voxel_size;
octree_grid_vertex_array[i+2] = z + half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x - half_voxel_size;
octree_grid_vertex_array[i+1] = y - half_voxel_size;
octree_grid_vertex_array[i+2] = z + half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x - half_voxel_size;
octree_grid_vertex_array[i+1] = y - half_voxel_size;
octree_grid_vertex_array[i+2] = z - half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x - half_voxel_size;
octree_grid_vertex_array[i+1] = y - half_voxel_size;
octree_grid_vertex_array[i+2] = z - half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x + half_voxel_size;
octree_grid_vertex_array[i+1] = y - half_voxel_size;
octree_grid_vertex_array[i+2] = z - half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x + half_voxel_size;
octree_grid_vertex_array[i+1] = y - half_voxel_size;
octree_grid_vertex_array[i+2] = z - half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x + half_voxel_size;
octree_grid_vertex_array[i+1] = y - half_voxel_size;
octree_grid_vertex_array[i+2] = z + half_voxel_size;
i+= 3;
// ----
octree_grid_vertex_array[i] = x + half_voxel_size;
octree_grid_vertex_array[i+1] = y + half_voxel_size;
octree_grid_vertex_array[i+2] = z - half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x + half_voxel_size;
octree_grid_vertex_array[i+1] = y - half_voxel_size;
octree_grid_vertex_array[i+2] = z - half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x - half_voxel_size;
octree_grid_vertex_array[i+1] = y + half_voxel_size;
octree_grid_vertex_array[i+2] = z - half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x - half_voxel_size;
octree_grid_vertex_array[i+1] = y - half_voxel_size;
octree_grid_vertex_array[i+2] = z - half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x - half_voxel_size;
octree_grid_vertex_array[i+1] = y + half_voxel_size;
octree_grid_vertex_array[i+2] = z + half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x - half_voxel_size;
octree_grid_vertex_array[i+1] = y - half_voxel_size;
octree_grid_vertex_array[i+2] = z + half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x + half_voxel_size;
octree_grid_vertex_array[i+1] = y + half_voxel_size;
octree_grid_vertex_array[i+2] = z + half_voxel_size;
i+= 3;
octree_grid_vertex_array[i] = x + half_voxel_size;
octree_grid_vertex_array[i+1] = y - half_voxel_size;
octree_grid_vertex_array[i+2] = z + half_voxel_size;
i+= 3;
// ----
}
m_octree_grid_vis_initialized = true;
}
void OcTreeDrawer::clearOcTreeStructure(){
if (octree_grid_vertex_size != 0) {
delete[] octree_grid_vertex_array;
octree_grid_vertex_size = 0;
}
m_octree_grid_vis_initialized = false;
}
void OcTreeDrawer::clear() {
//clearOcTree();
clearCubes(&m_occupiedArray, m_occupiedSize, &m_occupiedColorArray);
clearCubes(&m_occupiedThresArray, m_occupiedThresSize, &m_occupiedThresColorArray);
clearCubes(&m_freeArray, m_freeSize);
clearCubes(&m_freeThresArray, m_freeThresSize);
clearCubes(&m_selectionArray, m_selectionSize);
clearOcTreeStructure();
}
void OcTreeDrawer::drawOccupiedVoxels() const {
if (m_colorMode == CM_SEMANTIC) {
// hardcoded mapping id -> colors
if (this->map_id == 0) { // background
glColor3f(0.784f, 0.66f, 0); // gold
}
else if (this->map_id == 1) { // table
glColor3f(0.68f, 0., 0.62f); // purple
}
else { // object
glColor3f(0., 0.784f, 0.725f); // cyan
}
drawCubes(m_occupiedThresArray, m_occupiedThresSize, m_occupiedThresColorArray);
}
else {
// colors for printout mode:
if (m_colorMode == CM_PRINTOUT) {
if (!m_drawFree) { // gray on white background
glColor3f(0.6f, 0.6f, 0.6f);
}
else {
glColor3f(0.1f, 0.1f, 0.1f);
}
}
// draw binary occupied cells
if (m_occupiedThresSize != 0) {
if (m_colorMode != CM_PRINTOUT) glColor4f(0.0f, 0.0f, 1.0f, m_alphaOccupied);
drawCubes(m_occupiedThresArray, m_occupiedThresSize, m_occupiedThresColorArray);
}
// draw delta occupied cells
if (m_occupiedSize != 0) {
if (m_colorMode != CM_PRINTOUT) glColor4f(0.2f, 0.7f, 1.0f, m_alphaOccupied);
drawCubes(m_occupiedArray, m_occupiedSize, m_occupiedColorArray);
}
}
}
void OcTreeDrawer::drawFreeVoxels() const {
if (m_colorMode == CM_PRINTOUT) {
if (!m_drawOccupied) { // gray on white background
glColor3f(0.5f, 0.5f, 0.5f);
}
else {
glColor3f(0.9f, 0.9f, 0.9f);
}
}
// draw binary freespace cells
if (m_freeThresSize != 0) {
if (m_colorMode != CM_PRINTOUT) glColor4f(0.0f, 1.0f, 0.0f, 0.3f);
drawCubes(m_freeThresArray, m_freeThresSize);
}
// draw delta freespace cells
if (m_freeSize != 0) {
if (m_colorMode != CM_PRINTOUT) glColor4f(0.5f, 1.0f, 0.1f, 0.3f);
drawCubes(m_freeArray, m_freeSize);
}
}
void OcTreeDrawer::drawSelection() const {
if (m_selectionSize != 0) {
glColor4f(1.0, 0.0, 0.0, 1.0);
drawCubes(m_selectionArray, m_selectionSize);
}
}
void OcTreeDrawer::drawCubes(GLfloat** cubeArray, unsigned int cubeArraySize,
GLfloat* cubeColorArray) const {
if (cubeArraySize == 0 || cubeArray == NULL){
std::cerr << "Warning: GLfloat array to draw cubes appears to be empty, nothing drawn.\n";
return;
}
// save current color
GLfloat* curcol = new GLfloat[4];
glGetFloatv(GL_CURRENT_COLOR, curcol);
// enable color pointer when heightColorMode is enabled:
if ((m_colorMode == CM_COLOR_HEIGHT || m_colorMode == CM_GRAY_HEIGHT) && (cubeColorArray != NULL)){
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4, GL_FLOAT, 0, cubeColorArray);
}
// top surfaces:
glNormal3f(0.0f, 1.0f, 0.0f);
glVertexPointer(3, GL_FLOAT, 0, cubeArray[0]);
glDrawArrays(GL_QUADS, 0, cubeArraySize / 3);
// bottom surfaces:
glNormal3f(0.0f, -1.0f, 0.0f);
glVertexPointer(3, GL_FLOAT, 0, cubeArray[1]);
glDrawArrays(GL_QUADS, 0, cubeArraySize / 3);
// right surfaces:
glNormal3f(1.0f, 0.0f, 0.0f);
glVertexPointer(3, GL_FLOAT, 0, cubeArray[2]);
glDrawArrays(GL_QUADS, 0, cubeArraySize / 3);
// left surfaces:
glNormal3f(-1.0f, 0.0f, 0.0f);
glVertexPointer(3, GL_FLOAT, 0, cubeArray[3]);
glDrawArrays(GL_QUADS, 0, cubeArraySize / 3);
// back surfaces:
glNormal3f(0.0f, 0.0f, -1.0f);
glVertexPointer(3, GL_FLOAT, 0, cubeArray[4]);
glDrawArrays(GL_QUADS, 0, cubeArraySize / 3);
// front surfaces:
glNormal3f(0.0f, 0.0f, 1.0f);
glVertexPointer(3, GL_FLOAT, 0, cubeArray[5]);
glDrawArrays(GL_QUADS, 0, cubeArraySize / 3);
if ((m_colorMode == CM_COLOR_HEIGHT || m_colorMode == CM_GRAY_HEIGHT)
&& (cubeColorArray != NULL)){
glDisableClientState(GL_COLOR_ARRAY);
}
// draw bounding linies of cubes in printout:
if (m_colorMode == CM_PRINTOUT){
glDisable(GL_LIGHTING);
glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
glEnable (GL_LINE_SMOOTH);
glPolygonMode (GL_FRONT_AND_BACK, GL_LINE); // Draw Polygons only as Wireframes
glLineWidth(2.0f);
glColor3f(0.0f, 0.0f, 0.0f);
glCullFace(GL_FRONT_AND_BACK); // Don't draw any Polygons faces
//glDepthFunc (GL_LEQUAL);
// top meshes:
glNormal3f(0.0f, 1.0f, 0.0f);
glVertexPointer(3, GL_FLOAT, 0, cubeArray[0]);
glDrawArrays(GL_QUADS, 0, cubeArraySize / 3);
// bottom meshes:
glNormal3f(0.0f, -1.0f, 0.0f);
glVertexPointer(3, GL_FLOAT, 0, cubeArray[1]);
glDrawArrays(GL_QUADS, 0, cubeArraySize / 3);
// right meshes:
glNormal3f(1.0f, 0.0f, 0.0f);
glVertexPointer(3, GL_FLOAT, 0, cubeArray[2]);
glDrawArrays(GL_QUADS, 0, cubeArraySize / 3);
// left meshes:
glNormal3f(-1.0f, 0.0f, 0.0f);
glVertexPointer(3, GL_FLOAT, 0, cubeArray[3]);
glDrawArrays(GL_QUADS, 0, cubeArraySize / 3);
// restore defaults:
glCullFace(GL_BACK);
//glDepthFunc(GL_LESS);
glDisable(GL_LINE_SMOOTH);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_LIGHTING);
}
// reset color
glColor4fv(curcol);
delete[] curcol;
}
void OcTreeDrawer::drawOctreeGrid() const {
if (!m_octree_grid_vis_initialized) return;
if (octree_grid_vertex_size == 0) return;
glDisable(GL_LIGHTING);
glEnable(GL_LINE_SMOOTH);
glLineWidth(1.);
glVertexPointer(3, GL_FLOAT, 0, octree_grid_vertex_array);
glColor3f(0.0, 0.0, 0.0);
glDrawArrays(GL_LINES, 0, octree_grid_vertex_size / 3);
glDisable(GL_LINE_SMOOTH);
glEnable(GL_LIGHTING);
}
void OcTreeDrawer::enableOcTree(bool enabled) {
m_update = true;
m_drawOcTreeGrid = enabled;
if(m_drawOcTreeGrid && !m_octree_grid_vis_initialized) {
initOctreeGridVis();
}
}
void OcTreeDrawer::setOrigin(octomap::pose6d t){
origin = t;
std::cout << "OcTreeDrawer: setting new global origin: " << t << std::endl;
octomap::pose6d relative_transform = origin * initial_origin.inv();
std::cout << "origin : " << origin << std::endl;
std::cout << "inv init orig : " << initial_origin.inv() << std::endl;
std::cout << "relative trans: " << relative_transform << std::endl;
}
void OcTreeDrawer::drawAxes() const {
octomap::pose6d relative_transform = origin * initial_origin.inv();
glPushMatrix();
float length = 0.15f;
GLboolean lighting, colorMaterial;
glGetBooleanv(GL_LIGHTING, &lighting);
glGetBooleanv(GL_COLOR_MATERIAL, &colorMaterial);
glDisable(GL_COLOR_MATERIAL);
double angle= 2 * acos(initial_origin.rot().u());
double scale = sqrt (initial_origin.rot().x()*initial_origin.rot().x()
+ initial_origin.rot().y()*initial_origin.rot().y()
+ initial_origin.rot().z()*initial_origin.rot().z());
double ax= initial_origin.rot().x() / scale;
double ay= initial_origin.rot().y() / scale;
double az= initial_origin.rot().z() / scale;
if (angle > 0) glRotatef(OTD_RAD2DEG*angle, ax, ay, az);
float color[4];
color[0] = 0.7f; color[1] = 0.7f; color[2] = 1.0f; color[3] = 1.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
QGLViewer::drawArrow(length, 0.01*length);
color[0] = 1.0f; color[1] = 0.7f; color[2] = 0.7f; color[3] = 1.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glPushMatrix();
glRotatef(90.0, 0.0, 1.0, 0.0);
QGLViewer::drawArrow(length, 0.01*length);
glPopMatrix();
color[0] = 0.7f; color[1] = 1.0f; color[2] = 0.7f; color[3] = 1.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glPushMatrix();
glRotatef(-90.0, 1.0, 0.0, 0.0);
QGLViewer::drawArrow(length, 0.01*length);
glPopMatrix();
glTranslatef(relative_transform.trans().x(), relative_transform.trans().y(), relative_transform.trans().z());
if (colorMaterial)
glEnable(GL_COLOR_MATERIAL);
if (!lighting)
glDisable(GL_LIGHTING);
glPopMatrix();
}
} // namespace
| 33,062 | 34.589882 | 122 | cpp |
octomap | octomap-master/octovis/src/PointcloudDrawer.cpp | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#include <octovis/PointcloudDrawer.h>
namespace octomap {
PointcloudDrawer::PointcloudDrawer()
: ScanGraphDrawer(), m_pointsArray(NULL), m_numberPoints(0)
{
}
PointcloudDrawer::PointcloudDrawer(const ScanGraph& graph)
: ScanGraphDrawer(), m_pointsArray(NULL), m_numberPoints(0)
{
this->setScanGraph(graph);
}
PointcloudDrawer::~PointcloudDrawer() {
clear();
}
void PointcloudDrawer::setScanGraph(const ScanGraph& graph){
clear();
// count points first:
for (octomap::ScanGraph::const_iterator it = graph.begin(); it != graph.end(); it++) {
m_numberPoints += (*it)->scan->size();
}
m_pointsArray = new GLfloat[3*m_numberPoints];
unsigned i = 0;
for (octomap::ScanGraph::const_iterator graph_it = graph.begin(); graph_it != graph.end(); graph_it++) {
octomap::Pointcloud* scan = new Pointcloud((*graph_it)->scan);
scan->transformAbsolute((*graph_it)->pose);
for (Pointcloud::iterator pc_it = scan->begin(); pc_it != scan->end(); ++pc_it){
m_pointsArray[3*i] = pc_it->x();
m_pointsArray[3*i +1] = pc_it->y();
m_pointsArray[3*i +2] = pc_it->z();
i++;
}
delete scan;
}
}
void PointcloudDrawer::clear(){
if (m_numberPoints != 0) {
delete[] m_pointsArray;
m_numberPoints = 0;
}
}
void PointcloudDrawer::draw() const{
if (m_numberPoints == 0)
return;
glEnable(GL_POINT_SMOOTH);
glEnableClientState(GL_VERTEX_ARRAY);
// TODO: find a solution for printout-mode (=> separate drawer?)
// if (m_printoutMode){
// if (!m_drawFree) {
// glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
// }
// glColor4f(0.0, 0.0, 0.0, 1.);
// } else{
// glColor4f(1.0, 0.0, 0.0, 1.);
// }
glPointSize(1.0);
glColor4f(1.0, 0.0, 0.0, 1.);
glVertexPointer(3, GL_FLOAT, 0, m_pointsArray);
glDrawArrays(GL_POINTS, 0, m_numberPoints);
glDisableClientState(GL_VERTEX_ARRAY);
}
}
| 2,980 | 27.122642 | 108 | cpp |
octomap | octomap-master/octovis/src/SceneObject.cpp | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#define NOMINMAX
#include <octovis/SceneObject.h>
#ifndef RAD2DEG
#define RAD2DEG(x) ((x) * 57.29577951308232087721)
#endif
namespace octomap {
SceneObject::SceneObject() :
m_zMin(0.0), m_zMax(1.0), m_colorMode(CM_FLAT) {
}
void SceneObject::heightMapColor(double h, GLfloat* glArrayPos) const {
if (m_zMin >= m_zMax)
h = 0.5;
else{
h = (1.0 - std::min(std::max((h-m_zMin)/ (m_zMax - m_zMin), 0.0), 1.0)) *0.8;
}
// blend over HSV-values (more colors)
double r, g, b;
double s = 1.0;
double v = 1.0;
h -= floor(h);
h *= 6;
int i;
double m, n, f;
i = floor(h);
f = h - i;
if (!(i & 1))
f = 1 - f; // if i is even
m = v * (1 - s);
n = v * (1 - s * f);
switch (i) {
case 6:
case 0:
r = v; g = n; b = m;
break;
case 1:
r = n; g = v; b = m;
break;
case 2:
r = m; g = v; b = n;
break;
case 3:
r = m; g = n; b = v;
break;
case 4:
r = n; g = m; b = v;
break;
case 5:
r = v; g = m; b = n;
break;
default:
r = 1; g = 0.5; b = 0.5;
break;
}
glArrayPos[0] = r;
glArrayPos[1] = g;
glArrayPos[2] = b;
}
void SceneObject::heightMapGray(double h, GLfloat* glArrayPos) const {
if (m_zMin >= m_zMax)
h = 0.5;
else{
h = std::min(std::max((h-m_zMin)/ (m_zMax - m_zMin), 0.0), 1.0) * 0.4 + 0.3; // h \in [0.3, 0.7]
}
glArrayPos[0] = h;
glArrayPos[1] = h;
glArrayPos[2] = h;
}
}
| 2,531 | 22.886792 | 102 | cpp |
octomap | octomap-master/octovis/src/SelectionBox.cpp | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
// workaround for Windows
#define NOMINMAX
#include <octovis/SelectionBox.h>
#include <manipulatedFrame.h>
namespace octomap{
SelectionBox::SelectionBox()
: m_visible(false),
m_minPt(0,0,0), m_maxPt(1,1,1),
m_arrowLength(0.2)
{
for (unsigned i=0; i< 3; ++i){
m_frames.push_back(new qglviewer::ManipulatedFrame());
}
for (unsigned i=0; i< 3; ++i){
m_frames.push_back(new qglviewer::ManipulatedFrame());
}
qglviewer::WorldConstraint* XAxis = new qglviewer::WorldConstraint();
XAxis->setTranslationConstraint(qglviewer::AxisPlaneConstraint::AXIS, qglviewer::Vec(1.0,0.0,0.0));
XAxis->setRotationConstraint (qglviewer::AxisPlaneConstraint::FORBIDDEN, qglviewer::Vec(0.0,0.0,0.0));
qglviewer::WorldConstraint* YAxis = new qglviewer::WorldConstraint();
YAxis->setTranslationConstraint(qglviewer::AxisPlaneConstraint::AXIS, qglviewer::Vec(0.0,1.0,0.0));
YAxis->setRotationConstraint (qglviewer::AxisPlaneConstraint::FORBIDDEN, qglviewer::Vec(0.0,0.0,0.0));
qglviewer::WorldConstraint* ZAxis = new qglviewer::WorldConstraint();
ZAxis->setTranslationConstraint(qglviewer::AxisPlaneConstraint::AXIS, qglviewer::Vec(0.0,0.0,1.0));
ZAxis->setRotationConstraint (qglviewer::AxisPlaneConstraint::FORBIDDEN, qglviewer::Vec(0.0,0.0,0.0));
frame(0)->setConstraint(XAxis);
frame(1)->setConstraint(YAxis);
frame(2)->setConstraint(ZAxis);
frame(3)->setConstraint(XAxis);
frame(4)->setConstraint(YAxis);
frame(5)->setConstraint(ZAxis);
}
SelectionBox::~SelectionBox(){
delete m_frames[0];
delete m_frames[1];
}
void SelectionBox::draw(bool withNames){
// set min/max new from grabbed frame:
for (unsigned i = 0; i < m_frames.size(); ++i){
if (frame(i)->grabsMouse()){
qglviewer::Vec f = frame(i)->position();
unsigned oi = i+3;
float corr = m_arrowLength/2.0;
if (i >= 3){
oi = i-3;
corr *= -1;
}
qglviewer::Vec fo = frame(oi)->position();
unsigned ci = i%3;
m_minPt[ci] = std::min(f[ci] - corr, fo[ci] + corr);
m_maxPt[ci] = std::max(f[ci] - corr, fo[ci] + corr);
}
}
// draw box:
glEnable(GL_LINE_SMOOTH);
glLineWidth(2.);
glDisable(GL_LIGHTING);
glColor3f(0.9,0.0, 0.0);
glBegin(GL_LINE_LOOP); // Start drawing a line primitive
glVertex3f(m_minPt.x, m_minPt.y, m_minPt.z);
glVertex3f(m_maxPt.x, m_minPt.y, m_minPt.z);
glVertex3f(m_maxPt.x, m_maxPt.y, m_minPt.z);
glVertex3f(m_minPt.x, m_maxPt.y, m_minPt.z);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex3f(m_minPt.x, m_minPt.y, m_maxPt.z);
glVertex3f(m_maxPt.x, m_minPt.y, m_maxPt.z);
glVertex3f(m_maxPt.x, m_maxPt.y, m_maxPt.z);
glVertex3f(m_minPt.x, m_maxPt.y, m_maxPt.z);
// glVertex3f(-1.0f, -1.0f, 0.0f); // The bottom left corner
// glVertex3f(-1.0f, 1.0f, 0.0f); // The top left corner
// glVertex3f(1.0f, 1.0f, 0.0f); // The top right corner
// glVertex3f(1.0f, -1.0f, 0.0f); // The bottom right corner
glEnd();
glBegin(GL_LINES);
glVertex3f(m_minPt.x, m_minPt.y, m_minPt.z);
glVertex3f(m_minPt.x, m_minPt.y, m_maxPt.z);
glVertex3f(m_maxPt.x, m_minPt.y, m_minPt.z);
glVertex3f(m_maxPt.x, m_minPt.y, m_maxPt.z);
glVertex3f(m_maxPt.x, m_maxPt.y, m_minPt.z);
glVertex3f(m_maxPt.x, m_maxPt.y, m_maxPt.z);
glVertex3f(m_minPt.x, m_maxPt.y, m_minPt.z);
glVertex3f(m_minPt.x, m_maxPt.y, m_maxPt.z);
glEnd();
glDisable(GL_LINE_SMOOTH);
glEnable(GL_LIGHTING);
// correct all arrow frames:
for (unsigned i = 0; i < m_frames.size(); ++i){
qglviewer::Vec pt = m_minPt;
float corr = m_arrowLength/2;
if (i/3 == 1){
pt = m_maxPt;
corr *= -1;
}
pt[i%3] += corr;
frame(i)->setTranslation(pt);
}
// draw spheres in their frames:
// GLUquadricObj* quadric=gluNewQuadric();
// gluQuadricNormals(quadric, GLU_SMOOTH);
// glColor4f(1.0, 0.0, 0.0, 1.0);
GLboolean lighting, colorMaterial;
glGetBooleanv(GL_LIGHTING, &lighting);
glGetBooleanv(GL_COLOR_MATERIAL, &colorMaterial);
glDisable(GL_COLOR_MATERIAL);
for (unsigned i = 0; i < m_frames.size(); ++i){
glPushMatrix();
glMultMatrixd(m_frames[i]->matrix());
if (withNames)
glPushName(i);
float length = m_arrowLength;
if (frame(i)->grabsMouse())
length *= 2;
const float radius = length/20;
float color[4];
if (i%3 == 0){ // x
color[0] = 1.0f; color[1] = 0.7f; color[2] = 0.7f; color[3] = 1.0f;
glPushMatrix();
glRotatef(90.0, 0.0, 1.0, 0.0);
} else if (i%3 == 1){ // y
color[0] = 0.7f; color[1] = 1.0f; color[2] = 0.7f; color[3] = 1.0f;
glPushMatrix();
glRotatef(-90.0, 1.0, 0.0, 0.0);
} else { // z
glPushMatrix();
color[0] = 0.7f; color[1] = 0.7f; color[2] = 1.0f; color[3] = 1.0f;
}
glTranslatef(0.0, 0.0, -length/2.0);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
QGLViewer::drawArrow(length, radius);
glPopMatrix();
if (withNames)
glPopName();
glPopMatrix();
}
if (colorMaterial)
glEnable(GL_COLOR_MATERIAL);
if (!lighting)
glDisable(GL_LIGHTING);
//gluDeleteQuadric(quadric);
}
void SelectionBox::getBBXMin(float& x, float& y, float& z) const {
x = m_minPt.x;
y = m_minPt.y;
z = m_minPt.z;
}
void SelectionBox::getBBXMax(float& x, float& y, float& z) const {
x = m_maxPt.x;
y = m_maxPt.y;
z = m_maxPt.z;
}
int SelectionBox::getGrabbedFrame() const {
int frameid = -1;
for (unsigned i = 0; i < m_frames.size(); ++i){
if (frame(i)->grabsMouse()){
frameid = i;
break;
}
}
return frameid;
}
void SelectionBox::drawAxis(float length) const
{
const float radius = length/20;
GLboolean lighting, colorMaterial;
glGetBooleanv(GL_LIGHTING, &lighting);
glGetBooleanv(GL_COLOR_MATERIAL, &colorMaterial);
glDisable(GL_COLOR_MATERIAL);
float color[4];
color[0] = 0.7f; color[1] = 0.7f; color[2] = 1.0f; color[3] = 1.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
QGLViewer::drawArrow(length, radius);
color[0] = 1.0f; color[1] = 0.7f; color[2] = 0.7f; color[3] = 1.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glPushMatrix();
glRotatef(90.0, 0.0, 1.0, 0.0);
QGLViewer::drawArrow(length, radius);
glPopMatrix();
color[0] = 0.7f; color[1] = 1.0f; color[2] = 0.7f; color[3] = 1.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glPushMatrix();
glRotatef(-90.0, 1.0, 0.0, 0.0);
QGLViewer::drawArrow(length, radius);
glPopMatrix();
if (colorMaterial)
glEnable(GL_COLOR_MATERIAL);
if (!lighting)
glDisable(GL_LIGHTING);
}
}
| 7,660 | 26.458781 | 106 | cpp |
octomap | octomap-master/octovis/src/TrajectoryDrawer.cpp | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#include <octovis/TrajectoryDrawer.h>
namespace octomap {
TrajectoryDrawer::TrajectoryDrawer()
: ScanGraphDrawer(), m_trajectoryVertexArray(NULL), m_trajectoryColorArray(NULL), m_trajectorySize(0)
{
}
TrajectoryDrawer::TrajectoryDrawer(const octomap::ScanGraph& graph)
: ScanGraphDrawer(), m_trajectoryVertexArray(NULL), m_trajectoryColorArray(NULL), m_trajectorySize(0)
{
this->setScanGraph(graph);
}
TrajectoryDrawer::~TrajectoryDrawer() {
clear();
}
void TrajectoryDrawer::draw() const{
if (m_trajectorySize == 0)
return;
// draw lines:
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glLineWidth(3.0f);
glVertexPointer(3, GL_FLOAT, 0, m_trajectoryVertexArray);
glColorPointer(4, GL_FLOAT, 0, m_trajectoryColorArray);
glDrawArrays(GL_LINE_STRIP, 0, m_trajectorySize);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
// draw nodes:
GLUquadricObj* quadric=gluNewQuadric();
gluQuadricNormals(quadric, GLU_SMOOTH);
for (uint i = 0; i < m_trajectorySize; ++i){
glPushMatrix();
glTranslatef(m_trajectoryVertexArray[3*i], m_trajectoryVertexArray[3*i +1], m_trajectoryVertexArray[3*i +2]);
glColor4f(m_trajectoryColorArray[4*i],m_trajectoryColorArray[4*i+1],m_trajectoryColorArray[4*i+2],m_trajectoryColorArray[4*i+3]);
gluSphere(quadric, 0.05, 32, 32);
glPopMatrix();
}
gluDeleteQuadric(quadric);
}
void TrajectoryDrawer::clear(){
if (m_trajectorySize != 0) {
delete[] m_trajectoryVertexArray;
delete[] m_trajectoryColorArray;
m_trajectorySize = 0;
}
}
void TrajectoryDrawer::setScanGraph(const octomap::ScanGraph& graph){
clear();
m_trajectorySize = graph.size();
m_trajectoryVertexArray = new GLfloat[m_trajectorySize * 3];
m_trajectoryColorArray = new GLfloat[m_trajectorySize * 4];
uint i = 0;
for (octomap::ScanGraph::const_iterator it = graph.begin(); it != graph.end(); it++) {
m_trajectoryVertexArray[i] = (*it)->pose.trans().x();
m_trajectoryVertexArray[i+1] = (*it)->pose.trans().y();
m_trajectoryVertexArray[i+2] = (*it)->pose.trans().z();
i+=3;
}
for (unsigned int j=0; j < m_trajectorySize*4; j+=4) {
m_trajectoryColorArray[j] = 0.; // r
m_trajectoryColorArray[j+1] = 0.; // g
m_trajectoryColorArray[j+2] = 1.; // b
m_trajectoryColorArray[j+3] = 1.; // alpha
}
}
}
| 3,490 | 31.027523 | 135 | cpp |
octomap | octomap-master/octovis/src/ViewerGui.cpp | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#include <iostream>
#include <fstream>
//#include <octomap/octomap_timing.h>
#include <octovis/ViewerGui.h>
#include <octovis/ColorOcTreeDrawer.h>
#include <octomap/MapCollection.h>
//Dummy object definition to ensure VS2012 does not drop the StaticMemberInitializer, causing this tree failing to register.
octomap::ColorOcTree colortreeTmp(0);
#define _MAXRANGE_URG 5.1
#define _MAXRANGE_SICK 50.0
namespace octomap{
ViewerGui::ViewerGui(const std::string& filename, QWidget *parent, unsigned int initDepth)
: QMainWindow(parent), m_scanGraph(NULL),
m_trajectoryDrawer(NULL), m_pointcloudDrawer(NULL),
m_cameraFollowMode(NULL),
m_octreeResolution(0.1), m_laserMaxRange(-1.), m_occupancyThresh(0.5),
m_max_tree_depth(initDepth > 0 && initDepth <= 16 ? initDepth : 16),
m_laserType(LASERTYPE_SICK),
m_cameraStored(false),
m_filename("")
{
ui.setupUi(this);
m_glwidget = new ViewerWidget(this);
this->setCentralWidget(m_glwidget);
// Settings panel at the right side
ViewerSettingsPanel* settingsPanel = new ViewerSettingsPanel(this);
settingsPanel->setTreeDepth(initDepth);
QDockWidget* settingsDock = new QDockWidget("Octree / Scan graph settings", this);
settingsDock->setWidget(settingsPanel);
this->addDockWidget(Qt::RightDockWidgetArea, settingsDock);
ui.menuShow->addAction(settingsDock->toggleViewAction());
// Camera settings panel at the right side
ViewerSettingsPanelCamera* settingsCameraPanel = new ViewerSettingsPanelCamera(this);
QDockWidget *settingsCameraDock = new QDockWidget("Camera settings", this);
settingsCameraDock->setWidget(settingsCameraPanel);
this->addDockWidget(Qt::RightDockWidgetArea, settingsCameraDock);
this->tabifyDockWidget(settingsDock, settingsCameraDock);
settingsDock->raise();
ui.menuShow->addAction(settingsCameraDock->toggleViewAction());
// status bar
m_nodeSelected = new QLabel("Selected node coordinates", this);
m_mapSizeStatus = new QLabel("Map size", this);
m_mapMemoryStatus = new QLabel("Memory consumption", this);
m_nodeSelected->setFrameStyle(QFrame::Panel | QFrame::Sunken);
m_mapSizeStatus->setFrameStyle(QFrame::Panel | QFrame::Sunken);
m_mapMemoryStatus->setFrameStyle(QFrame::Panel | QFrame::Sunken);
statusBar()->addPermanentWidget(m_nodeSelected);
statusBar()->addPermanentWidget(m_mapSizeStatus);
statusBar()->addPermanentWidget(m_mapMemoryStatus);
m_cameraFollowMode = new CameraFollowMode();
connect(this, SIGNAL(updateStatusBar(QString, int)), statusBar(), SLOT(showMessage(QString, int)));
connect(settingsPanel, SIGNAL(treeDepthChanged(int)), this, SLOT(changeTreeDepth(int)));
connect(settingsPanel, SIGNAL(addNextScans(unsigned)), this, SLOT(addNextScans(unsigned)));
connect(settingsPanel, SIGNAL(gotoFirstScan()), this, SLOT(gotoFirstScan()));
connect(settingsCameraPanel, SIGNAL(jumpToFrame(unsigned)), m_cameraFollowMode, SLOT(jumpToFrame(unsigned)));
connect(settingsCameraPanel, SIGNAL(play()), m_cameraFollowMode, SLOT(play()));
connect(settingsCameraPanel, SIGNAL(pause()), m_cameraFollowMode, SLOT(pause()));
connect(settingsCameraPanel, SIGNAL(clearCameraPath()), m_cameraFollowMode, SLOT(clearCameraPath()));
connect(settingsCameraPanel, SIGNAL(saveToCameraPath()), m_cameraFollowMode, SLOT(saveToCameraPath()));
connect(settingsCameraPanel, SIGNAL(removeFromCameraPath()), m_cameraFollowMode, SLOT(removeFromCameraPath()));
connect(settingsCameraPanel, SIGNAL(addToCameraPath()), m_cameraFollowMode, SLOT(addToCameraPath()));
connect(settingsCameraPanel, SIGNAL(followCameraPath()), m_cameraFollowMode, SLOT(followCameraPath()));
connect(settingsCameraPanel, SIGNAL(followRobotPath()), m_cameraFollowMode, SLOT(followRobotPath()));
connect(m_cameraFollowMode, SIGNAL(changeNumberOfFrames(unsigned)), settingsCameraPanel, SLOT(setNumberOfFrames(unsigned)));
connect(m_cameraFollowMode, SIGNAL(frameChanged(unsigned)), settingsCameraPanel, SLOT(setCurrentFrame(unsigned)));
connect(m_cameraFollowMode, SIGNAL(stopped()), settingsCameraPanel, SLOT(setStopped()));
connect(m_cameraFollowMode, SIGNAL(scanGraphAvailable(bool)), settingsCameraPanel, SLOT(setRobotTrajectoryAvailable(bool)));
connect(m_cameraFollowMode, SIGNAL(deleteCameraPath(int)), m_glwidget, SLOT(deleteCameraPath(int)));
connect(m_cameraFollowMode, SIGNAL(removeFromCameraPath(int,int)), m_glwidget, SLOT(removeFromCameraPath(int,int)));
connect(m_cameraFollowMode, SIGNAL(appendToCameraPath(int, const octomath::Pose6D&)), m_glwidget, SLOT(appendToCameraPath(int, const octomath::Pose6D&)));
connect(m_cameraFollowMode, SIGNAL(appendCurrentToCameraPath(int)), m_glwidget, SLOT(appendCurrentToCameraPath(int)));
connect(m_cameraFollowMode, SIGNAL(addCurrentToCameraPath(int,int)), m_glwidget, SLOT(addCurrentToCameraPath(int,int)));
connect(m_cameraFollowMode, SIGNAL(updateCameraPath(int,int)), m_glwidget, SLOT(updateCameraPath(int,int)));
connect(m_cameraFollowMode, SIGNAL(playCameraPath(int,int)), m_glwidget, SLOT(playCameraPath(int,int)));
connect(m_cameraFollowMode, SIGNAL(stopCameraPath(int)), m_glwidget, SLOT(stopCameraPath(int)));
connect(m_cameraFollowMode, SIGNAL(jumpToCamFrame(int, int)), m_glwidget, SLOT(jumpToCamFrame(int, int)));
connect(m_glwidget, SIGNAL(cameraPathStopped(int)), m_cameraFollowMode, SLOT(cameraPathStopped(int)));
connect(m_glwidget, SIGNAL(cameraPathFrameChanged(int, int)), m_cameraFollowMode, SLOT(cameraPathFrameChanged(int, int)));
connect(this, SIGNAL(changeNumberOfScans(unsigned)), settingsPanel, SLOT(setNumberOfScans(unsigned)));
connect(this, SIGNAL(changeCurrentScan(unsigned)), settingsPanel, SLOT(setCurrentScan(unsigned)));
connect(this, SIGNAL(changeResolution(double)), settingsPanel, SLOT(setResolution(double)));
connect(settingsCameraPanel, SIGNAL(changeCamPosition(double, double, double, double, double, double)),
m_glwidget, SLOT(setCamPosition(double, double, double, double, double, double)));
connect(m_cameraFollowMode, SIGNAL(changeCamPose(const octomath::Pose6D&)),
m_glwidget, SLOT(setCamPose(const octomath::Pose6D&)));
connect(ui.actionReset_view, SIGNAL(triggered()), m_glwidget, SLOT(resetView()));
connect(m_glwidget, SIGNAL(select(const QMouseEvent*)), this, SLOT(voxelSelected(const QMouseEvent*)));
if (filename != ""){
m_filename = filename;
openFile();
}
}
ViewerGui::~ViewerGui() {
if (m_trajectoryDrawer){
m_glwidget->removeSceneObject(m_trajectoryDrawer);
delete m_trajectoryDrawer;
m_trajectoryDrawer = NULL;
}
if (m_pointcloudDrawer){
m_glwidget->removeSceneObject(m_pointcloudDrawer);
delete m_pointcloudDrawer;
m_pointcloudDrawer = NULL;
}
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin(); it != m_octrees.end(); ++it) {
m_glwidget->removeSceneObject(it->second.octree_drawer);
delete (it->second.octree_drawer);
delete (it->second.octree);
}
m_octrees.clear();
if(m_cameraFollowMode) {
delete m_cameraFollowMode;
m_cameraFollowMode = NULL;
}
}
bool ViewerGui::isShown() {
return m_glwidget->isVisible();
}
void ViewerGui::showInfo(QString string, bool newline) {
std::cerr << string.toLocal8Bit().data();
if (newline) std::cerr << std::endl;
else std::cerr << std::flush;
int duration = 0;
if (newline)
duration = 3000;
emit updateStatusBar(string, duration);
}
bool ViewerGui::getOctreeRecord(int id, OcTreeRecord*& otr) {
std::map<int, OcTreeRecord>::iterator it = m_octrees.find(id);
if( it != m_octrees.end() ) {
otr = &(it->second);
return true;
}
else {
return false;
}
}
void ViewerGui::addOctree(octomap::AbstractOcTree* tree, int id, octomap::pose6d origin) {
// is id in use?
OcTreeRecord* r;
bool foundRecord = getOctreeRecord(id, r);
if (foundRecord && r->octree->getTreeType().compare(tree->getTreeType()) !=0){
// delete old drawer, create new
delete r->octree_drawer;
if (dynamic_cast<OcTree*>(tree)) {
r->octree_drawer = new OcTreeDrawer();
// fprintf(stderr, "adding new OcTreeDrawer for node %d\n", id);
}
else if (dynamic_cast<ColorOcTree*>(tree)) {
r->octree_drawer = new ColorOcTreeDrawer();
} else{
OCTOMAP_ERROR("Could not create drawer for tree type %s\n", tree->getTreeType().c_str());
}
delete r->octree;
r->octree = tree;
r->origin = origin;
} else if (foundRecord && r->octree->getTreeType().compare(tree->getTreeType()) ==0) {
// only swap out tree
delete r->octree;
r->octree = tree;
r->origin = origin;
} else {
// add new record
OcTreeRecord otr;
otr.id = id;
if (dynamic_cast<OcTree*>(tree)) {
otr.octree_drawer = new OcTreeDrawer();
// fprintf(stderr, "adding new OcTreeDrawer for node %d\n", id);
}
else if (dynamic_cast<ColorOcTree*>(tree)) {
otr.octree_drawer = new ColorOcTreeDrawer();
} else{
OCTOMAP_ERROR("Could not create drawer for tree type %s\n", tree->getTreeType().c_str());
}
otr.octree = tree;
otr.origin = origin;
m_octrees[id] = otr;
m_glwidget->addSceneObject(otr.octree_drawer);
}
}
void ViewerGui::addOctree(octomap::AbstractOcTree* tree, int id) {
octomap::pose6d o; // initialized to (0,0,0) , (0,0,0,1) by default
addOctree(tree, id, o);
}
void ViewerGui::showOcTree() {
// update viewer stat
double minX, minY, minZ, maxX, maxY, maxZ;
minX = minY = minZ = -10; // min bbx for drawing
maxX = maxY = maxZ = 10; // max bbx for drawing
double sizeX, sizeY, sizeZ;
sizeX = sizeY = sizeZ = 0.;
size_t memoryUsage = 0;
size_t num_nodes = 0;
size_t memorySingleNode = 0;
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin(); it != m_octrees.end(); ++it) {
// get map bbx
double lminX, lminY, lminZ, lmaxX, lmaxY, lmaxZ;
it->second.octree->getMetricMin(lminX, lminY, lminZ);
it->second.octree->getMetricMax(lmaxX, lmaxY, lmaxZ);
// transform to world coords using map origin
octomap::point3d pmin(lminX, lminY, lminZ);
octomap::point3d pmax(lmaxX, lmaxY, lmaxZ);
pmin = it->second.origin.transform(pmin);
pmax = it->second.origin.transform(pmax);
lminX = pmin.x(); lminY = pmin.y(); lminZ = pmin.z();
lmaxX = pmax.x(); lmaxY = pmax.y(); lmaxZ = pmax.z();
// update global bbx
if (lminX < minX) minX = lminX;
if (lminY < minY) minY = lminY;
if (lminZ < minZ) minZ = lminZ;
if (lmaxX > maxX) maxX = lmaxX;
if (lmaxY > maxY) maxY = lmaxY;
if (lmaxZ > maxZ) maxZ = lmaxZ;
double lsizeX, lsizeY, lsizeZ;
// update map stats
it->second.octree->getMetricSize(lsizeX, lsizeY, lsizeZ);
if (lsizeX > sizeX) sizeX = lsizeX;
if (lsizeY > sizeY) sizeY = lsizeY;
if (lsizeZ > sizeZ) sizeZ = lsizeZ;
memoryUsage += it->second.octree->memoryUsage();
num_nodes += it->second.octree->size();
memorySingleNode = std::max(memorySingleNode, it->second.octree->memoryUsageNode());
}
m_glwidget->setSceneBoundingBox(qglviewer::Vec(minX, minY, minZ), qglviewer::Vec(maxX, maxY, maxZ));
//if (m_octrees.size()) {
QString size = QString("%L1 x %L2 x %L3 m^3; %L4 nodes").arg(sizeX).arg(sizeY).arg(sizeZ).arg(unsigned(num_nodes));
QString memory = QString("Single node: %L1 B; ").arg(memorySingleNode)
+ QString ("Octree: %L1 B (%L2 MB)").arg(memoryUsage).arg((double) memoryUsage/(1024.*1024.), 0, 'f', 3);
m_mapMemoryStatus->setText(memory);
m_mapSizeStatus->setText(size);
//}
m_glwidget->update();
// generate cubes -> display
// timeval start;
// timeval stop;
// gettimeofday(&start, NULL); // start timer
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin(); it != m_octrees.end(); ++it) {
it->second.octree_drawer->setMax_tree_depth(m_max_tree_depth);
it->second.octree_drawer->setOcTree(*it->second.octree, it->second.origin, it->second.id);
}
// gettimeofday(&stop, NULL); // stop timer
// double time_to_generate = (stop.tv_sec - start.tv_sec) + 1.0e-6 *(stop.tv_usec - start.tv_usec);
// fprintf(stderr, "setOcTree took %f sec\n", time_to_generate);
m_glwidget->update();
}
void ViewerGui::generateOctree() {
if (m_scanGraph) {
QApplication::setOverrideCursor(Qt::WaitCursor);
showInfo("Generating OcTree... ");
std::cerr << std::endl;
//if (m_ocTree) delete m_ocTree;
OcTree* tree = new octomap::OcTree(m_octreeResolution);
octomap::ScanGraph::iterator it;
unsigned numScans = m_scanGraph->size();
unsigned currentScan = 1;
for (it = m_scanGraph->begin(); it != m_nextScanToAdd; it++) {
tree->insertPointCloud(**it, m_laserMaxRange);
fprintf(stderr, "generateOctree:: inserting scan node with %d points, origin: %.2f ,%.2f , %.2f.\n",
(unsigned int) (*it)->scan->size(), (*it)->pose.x(), (*it)->pose.y(), (*it)->pose.z() );
std::cout << " S ("<<currentScan<<"/"<<numScans<<") " << std::flush;
currentScan++;
}
this->addOctree(tree, DEFAULT_OCTREE_ID);
this->showOcTree();
showInfo("Done.", true);
QApplication::restoreOverrideCursor();
}
else {
std::cerr << "generateOctree called but no ScanGraph present!\n";
}
}
// == incremental graph generation =======================
void ViewerGui::gotoFirstScan(){
if (m_scanGraph){
showInfo("Inserting first scan node into tree... ", true);
QApplication::setOverrideCursor(Qt::WaitCursor);
m_nextScanToAdd = m_scanGraph->begin();
// if (m_ocTree) delete m_ocTree;
// m_ocTree = new octomap::OcTree(m_octreeResolution);
OcTree* tree = new octomap::OcTree(m_octreeResolution);
this->addOctree(tree, DEFAULT_OCTREE_ID);
addNextScan();
QApplication::restoreOverrideCursor();
showOcTree();
}
}
void ViewerGui::addNextScan(){
if (m_scanGraph){
showInfo("Inserting next scan node into tree... ", true);
QApplication::setOverrideCursor(Qt::WaitCursor);
if (m_nextScanToAdd != m_scanGraph->end()){
OcTreeRecord* r;
if (!getOctreeRecord(DEFAULT_OCTREE_ID, r)) {
fprintf(stderr, "ERROR: OctreeRecord for id %d not found!\n", DEFAULT_OCTREE_ID);
return;
}
// not used with ColorOcTrees, omitting casts
((OcTree*) r->octree)->insertPointCloud(**m_nextScanToAdd, m_laserMaxRange);
m_nextScanToAdd++;
}
QApplication::restoreOverrideCursor();
showOcTree();
}
}
void ViewerGui::addNextScans(unsigned scans){
for (unsigned i = 0; i < scans; ++i){
addNextScan();
}
}
// == file I/O ===========================================
void ViewerGui::openFile(){
if (!m_filename.empty()){
m_glwidget->clearAll();
QString temp = QString(m_filename.c_str());
QFileInfo fileinfo(temp);
this->setWindowTitle(fileinfo.fileName());
if (fileinfo.suffix() == "graph"){
openGraph();
}else if (fileinfo.suffix() == "bt"){
openTree();
}
else if (fileinfo.suffix() == "ot")
{
openOcTree();
}
else if (fileinfo.suffix() == "hot"){
openMapCollection();
}
else if (fileinfo.suffix() == "dat"){
openPointcloud();
}
else {
QMessageBox::warning(this, "Unknown file", "Cannot open file, unknown extension: "+fileinfo.suffix(), QMessageBox::Ok);
}
}
}
void ViewerGui::openGraph(bool completeGraph){
QApplication::setOverrideCursor(Qt::WaitCursor);
showInfo("Loading scan graph from file " + QString(m_filename.c_str()) );
if (m_scanGraph) delete m_scanGraph;
m_scanGraph = new octomap::ScanGraph();
m_scanGraph->readBinary(m_filename);
loadGraph(completeGraph);
}
void ViewerGui::openPointcloud(){
QApplication::setOverrideCursor(Qt::WaitCursor);
showInfo("Loading ASCII pointcloud from file "+QString(m_filename.c_str()) + "...");
if (m_scanGraph) delete m_scanGraph;
m_scanGraph = new octomap::ScanGraph();
// read pointcloud from file
std::ifstream s(m_filename.c_str());
Pointcloud* pc = new Pointcloud();
if (!s) {
std::cout <<"ERROR: could not read " << m_filename << std::endl;
return;
}
pc->read(s);
pose6d laser_pose(0,0,0,0,0,0);
m_scanGraph->addNode(pc, laser_pose);
loadGraph(true);
showInfo("Done.", true);
}
void ViewerGui::setOcTreeUISwitches() {
ui.actionPointcloud->setChecked(false);
ui.actionPointcloud->setEnabled(false);
ui.actionOctree_cells->setChecked(true);
ui.actionOctree_cells->setEnabled(true);
ui.actionFree->setChecked(false);
ui.actionFree->setEnabled(true);
ui.actionOctree_structure->setEnabled(true);
ui.actionOctree_structure->setChecked(false);
ui.actionTrajectory->setEnabled(false);
ui.actionConvert_ml_tree->setEnabled(true);
ui.actionReload_Octree->setEnabled(true);
ui.actionSettings->setEnabled(false);
ui.actionSelected->setChecked(true);
ui.actionSelected->setEnabled(true);
}
void ViewerGui::openTree(){
OcTree* tree = new octomap::OcTree(m_filename);
this->addOctree(tree, DEFAULT_OCTREE_ID);
m_octreeResolution = tree->getResolution();
emit changeResolution(m_octreeResolution);
setOcTreeUISwitches();
showOcTree();
m_glwidget->resetView();
}
void ViewerGui::openOcTree(){
AbstractOcTree* tree = AbstractOcTree::read(m_filename);
if (tree){
this->addOctree(tree, DEFAULT_OCTREE_ID);
m_octreeResolution = tree->getResolution();
emit changeResolution(m_octreeResolution);
setOcTreeUISwitches();
showOcTree();
m_glwidget->resetView();
if (tree->getTreeType() == "ColorOcTree"){
// map color and height map share the same color array and QAction
ui.actionHeight_map->setText ("Map color"); // rename QAction in Menu
this->on_actionHeight_map_toggled(true); // enable color view
ui.actionHeight_map->setChecked(true);
}
}
else {
QMessageBox::warning(this, "File error", "Cannot open OcTree file", QMessageBox::Ok);
}
}
// EXPERIMENTAL
void ViewerGui::openMapCollection() {
OCTOMAP_DEBUG("Opening hierarchy from %s...\n", m_filename.c_str());
std::ifstream infile(m_filename.c_str(), std::ios_base::in |std::ios_base::binary);
if (!infile.is_open()) {
QMessageBox::warning(this, "File error", "Cannot open OcTree file", QMessageBox::Ok);
return;
}
infile.close();
MapCollection<MapNode<OcTree> > collection(m_filename);
int i=0;
for (MapCollection<MapNode<OcTree> >::iterator it = collection.begin();
it != collection.end(); ++it) {
OCTOMAP_DEBUG("Adding hierarchy node %s\n", (*it)->getId().c_str());
OcTree* tree = (*it)->getMap();
if (!tree)
OCTOMAP_ERROR("Error while reading node %s\n", (*it)->getId().c_str());
else {
OCTOMAP_DEBUG("Read tree with %zu tree nodes\n", tree->size());
}
pose6d origin = (*it)->getOrigin();
this->addOctree(tree, i, origin);
++i;
}
setOcTreeUISwitches();
showOcTree();
m_glwidget->resetView();
OCTOMAP_DEBUG("done\n");
}
void ViewerGui::loadGraph(bool completeGraph) {
ui.actionSettings->setEnabled(true);
ui.actionPointcloud->setEnabled(true);
ui.actionPointcloud->setChecked(false);
ui.actionTrajectory->setEnabled(true);
ui.actionOctree_cells->setEnabled(true);
ui.actionOctree_cells->setChecked(true);
ui.actionOctree_structure->setEnabled(true);
ui.actionOctree_structure->setChecked(false);
ui.actionFree->setChecked(false);
ui.actionFree->setEnabled(true);
ui.actionReload_Octree->setEnabled(true);
ui.actionConvert_ml_tree->setEnabled(true);
unsigned graphSize = m_scanGraph->size();
unsigned currentScan;
if (completeGraph){
fprintf(stderr, "loadGraph:: generating octree from complete graph.\n" );
m_nextScanToAdd = m_scanGraph->end();
generateOctree();
currentScan = graphSize;
}
else{
m_nextScanToAdd = m_scanGraph->begin();
//if (m_ocTree) delete m_ocTree;
//m_ocTree = new octomap::OcTree(m_octreeResolution);
OcTree* tree = new octomap::OcTree(m_octreeResolution);
this->addOctree(tree, DEFAULT_OCTREE_ID);
addNextScan();
currentScan = 1;
}
m_glwidget->resetView();
QApplication::restoreOverrideCursor();
emit changeNumberOfScans(graphSize);
emit changeCurrentScan(currentScan);
showInfo("Done (" +QString::number(currentScan)+ " of "+ QString::number(graphSize)+" nodes)", true);
if (!m_trajectoryDrawer){
m_trajectoryDrawer = new TrajectoryDrawer();
}
m_trajectoryDrawer->setScanGraph(*m_scanGraph);
if (!m_pointcloudDrawer){
m_pointcloudDrawer = new PointcloudDrawer();
}
m_pointcloudDrawer->setScanGraph(*m_scanGraph);
m_cameraFollowMode->setScanGraph(m_scanGraph);
if (ui.actionTrajectory->isChecked())
m_glwidget->addSceneObject(m_trajectoryDrawer);
if (ui.actionPointcloud->isChecked())
m_glwidget->addSceneObject(m_pointcloudDrawer);
}
void ViewerGui::changeTreeDepth(int depth){
// range check:
if (depth < 1 || depth > 16)
return;
m_max_tree_depth = unsigned(depth);
if (m_octrees.size() > 0)
showOcTree();
}
void ViewerGui::on_actionExit_triggered(){
this->close();
}
void ViewerGui::on_actionHelp_triggered(){
m_glwidget->help();
}
void ViewerGui::on_actionSettings_triggered(){
ViewerSettings dialog(this);
dialog.setResolution(m_octreeResolution);
dialog.setLaserType(m_laserType);
dialog.setMaxRange(m_laserMaxRange);
if (dialog.exec()){
double oldResolution = m_octreeResolution;
double oldLaserMaxRange = m_laserMaxRange;
double oldType = m_laserType;
m_octreeResolution = dialog.getResolution();
m_laserType = dialog.getLaserType();
m_laserMaxRange = dialog.getMaxRange();
// apply new settings
bool resolutionChanged = (std::abs(oldResolution - m_octreeResolution) > 1e-5);
bool maxRangeChanged = (std::abs(oldLaserMaxRange - m_laserMaxRange) > 1e-5);
if (resolutionChanged)
emit changeResolution(m_octreeResolution);
if (oldType != m_laserType){ // parameters changed, reload file:
openFile();
} else if (resolutionChanged || maxRangeChanged){
generateOctree();
}
}
}
void ViewerGui::on_actionOpen_file_triggered(){
QString filename = QFileDialog::getOpenFileName(this,
tr("Open data file"), "",
"All supported files (*.graph *.bt *.ot *.dat);;OcTree file (*.ot);;Bonsai tree file (*.bt);;Binary scan graph (*.graph);;Pointcloud (*.dat);;All files (*)");
if (!filename.isEmpty()){
#ifdef _WIN32
m_filename = std::string(filename.toLocal8Bit().data());
#else
m_filename = filename.toStdString();
#endif
openFile();
}
}
void ViewerGui::on_actionOpen_graph_incremental_triggered(){
QString filename = QFileDialog::getOpenFileName(this,
tr("Open graph file incrementally (at start)"), "",
"Binary scan graph (*.graph)");
if (!filename.isEmpty()){
m_glwidget->clearAll();
#ifdef _WIN32
m_filename = std::string(filename.toLocal8Bit().data());
#else
m_filename = filename.toStdString();
#endif
openGraph(false);
}
}
void ViewerGui::on_actionSave_file_triggered(){
OcTreeRecord* r;
if (!getOctreeRecord(DEFAULT_OCTREE_ID, r)) {
fprintf(stderr, "ERROR: OctreeRecord for id %d not found!\n", DEFAULT_OCTREE_ID);
QMessageBox::warning(this, tr("3D Mapping Viewer"),
"Error: No OcTree present.",
QMessageBox::Ok);
return;
}
QString filename = QFileDialog::getSaveFileName(this, tr("Save octree file"),
"", tr("Full OcTree (*.ot);;Bonsai Tree file (*.bt);;"));
if (filename != ""){
QApplication::setOverrideCursor(Qt::WaitCursor);
showInfo("Writing file... ", false);
QFileInfo fileinfo(filename);
std::string std_filename;
#ifdef _WIN32
std_filename = filename.toLocal8Bit().data();
#else
std_filename = filename.toStdString();
#endif
AbstractOcTree* t = r->octree;
if (fileinfo.suffix() == "bt") {
AbstractOccupancyOcTree* ot = dynamic_cast<AbstractOccupancyOcTree*> (t);
if (ot)
ot->writeBinaryConst(std_filename);
else{
QMessageBox::warning(this, "Unknown tree type",
"Could not convert to occupancy tree for writing .bt file",
QMessageBox::Ok);
}
}
else if (fileinfo.suffix() == "ot"){
r->octree->write(std_filename);
}
else {
QMessageBox::warning(this, "Unknown file",
"Cannot write file, unknown extension: "+fileinfo.suffix(),
QMessageBox::Ok);
}
QApplication::restoreOverrideCursor();
showInfo("Done.", true);
}
}
void ViewerGui::on_actionClear_nodes_in_selection_triggered(){
point3d min, max;
m_glwidget->selectionBox().getBBXMin(min.x(), min.y(), min.z());
m_glwidget->selectionBox().getBBXMax(max.x(), max.y(), max.z());
updateNodesInBBX(min, max, false);
}
void ViewerGui::on_actionClear_selection_triggered(){
point3d min, max;
m_glwidget->selectionBox().getBBXMin(min.x(), min.y(), min.z());
m_glwidget->selectionBox().getBBXMax(max.x(), max.y(), max.z());
setNodesInBBX(min, max, false);
}
void ViewerGui::on_actionClear_unknown_in_selection_triggered()
{
point3d min, max;
m_glwidget->selectionBox().getBBXMin(min.x(), min.y(), min.z());
m_glwidget->selectionBox().getBBXMax(max.x(), max.y(), max.z());
setNonNodesInBBX(min, max, false);
}
void ViewerGui::on_actionFill_unknown_in_selection_triggered()
{
point3d min, max;
m_glwidget->selectionBox().getBBXMin(min.x(), min.y(), min.z());
m_glwidget->selectionBox().getBBXMax(max.x(), max.y(), max.z());
setNonNodesInBBX(min, max, true);
}
void ViewerGui::on_actionFill_selection_triggered(){
point3d min, max;
m_glwidget->selectionBox().getBBXMin(min.x(), min.y(), min.z());
m_glwidget->selectionBox().getBBXMax(max.x(), max.y(), max.z());
setNodesInBBX(min, max, true);
}
void ViewerGui::on_actionFill_nodes_in_selection_triggered(){
point3d min, max;
m_glwidget->selectionBox().getBBXMin(min.x(), min.y(), min.z());
m_glwidget->selectionBox().getBBXMax(max.x(), max.y(), max.z());
updateNodesInBBX(min, max, true);
}
void ViewerGui::on_actionDelete_nodes_in_selection_triggered(){
point3d min, max;
m_glwidget->selectionBox().getBBXMin(min.x(), min.y(), min.z());
m_glwidget->selectionBox().getBBXMax(max.x(), max.y(), max.z());
for (std::map<int, OcTreeRecord>::iterator t_it = m_octrees.begin(); t_it != m_octrees.end(); ++t_it) {
OcTree* octree = dynamic_cast<OcTree*>(t_it->second.octree);
if (octree){
for(OcTree::leaf_bbx_iterator it = octree->begin_leafs_bbx(min,max),
end=octree->end_leafs_bbx(); it!= end; ++it){
octree->deleteNode(it.getKey(), it.getDepth());
}
} else{
QMessageBox::warning(this, "Not implemented", "Functionality not yet implemented for this octree type",
QMessageBox::Ok);
}
}
showOcTree();
}
void ViewerGui::on_actionDelete_nodes_outside_of_selection_triggered(){
point3d min, max;
m_glwidget->selectionBox().getBBXMin(min.x(), min.y(), min.z());
m_glwidget->selectionBox().getBBXMax(max.x(), max.y(), max.z());
for (std::map<int, OcTreeRecord>::iterator t_it = m_octrees.begin(); t_it != m_octrees.end(); ++t_it) {
OcTree* octree = dynamic_cast<OcTree*>(t_it->second.octree);
if (octree){
octomap::OcTreeKey minKey, maxKey;
if (!octree->coordToKeyChecked(min, minKey) || !octree->coordToKeyChecked(max, maxKey)){
return;
}
for(OcTree::leaf_iterator it = octree->begin_leafs(),
end=octree->end_leafs(); it!= end; ++it){
// check if outside of bbx:
OcTreeKey k = it.getKey();
if (k[0] < minKey[0] || k[1] < minKey[1] || k[2] < minKey[2]
|| k[0] > maxKey[0] || k[1] > maxKey[1] || k[2] > maxKey[2])
{
octree->deleteNode(k, it.getDepth());
}
}
} else
QMessageBox::warning(this, "Not implemented", "Functionality not yet implemented for this octree type",
QMessageBox::Ok);
}
showOcTree();
}
void ViewerGui::updateNodesInBBX(const point3d& min, const point3d& max, bool occupied){
for (std::map<int, OcTreeRecord>::iterator t_it = m_octrees.begin(); t_it != m_octrees.end(); ++t_it) {
OcTree* octree = dynamic_cast<OcTree*>(t_it->second.octree);
if (octree){
float logodds;
if (occupied)
logodds = octree->getClampingThresMaxLog();
else
logodds = octree->getClampingThresMinLog();
for(OcTree::leaf_bbx_iterator it = octree->begin_leafs_bbx(min,max),
end=octree->end_leafs_bbx(); it!= end; ++it)
{
// directly set values of leafs:
it->setLogOdds(logodds);
}
// update inner nodes to make tree consistent:
octree->updateInnerOccupancy();
} else
QMessageBox::warning(this, "Not implemented", "Functionality not yet implemented for this octree type",
QMessageBox::Ok);
}
showOcTree();
}
void ViewerGui::setNodesInBBX(const point3d& min, const point3d& max, bool occupied){
for (std::map<int, OcTreeRecord>::iterator t_it = m_octrees.begin(); t_it != m_octrees.end(); ++t_it) {
OcTree* octree = dynamic_cast<OcTree*>(t_it->second.octree);
if (octree){
float logodds = octree->getClampingThresMaxLog() - octree->getClampingThresMinLog();
if (!occupied)
logodds *= -1;
OcTreeKey minKey(0,0,0);
OcTreeKey maxKey(0,0,0);
octree->coordToKeyChecked(min, minKey);
octree->coordToKeyChecked(max, maxKey);
OcTreeKey k;
for (k[0] = minKey[0]; k[0] < maxKey[0]; ++k[0]){
for (k[1] = minKey[1]; k[1] < maxKey[1]; ++k[1]){
for (k[2] = minKey[2]; k[2] < maxKey[2]; ++k[2]){
octree->updateNode(k, logodds);
}
}
}
}
}
showOcTree();
}
void ViewerGui::setNonNodesInBBX(const point3d& min, const point3d& max, bool occupied) {
for (std::map<int, OcTreeRecord>::iterator t_it = m_octrees.begin(); t_it != m_octrees.end(); ++t_it) {
OcTree* octree = dynamic_cast<OcTree*>(t_it->second.octree);
if (octree){
float logodds = octree->getClampingThresMaxLog() - octree->getClampingThresMinLog();
if (!occupied)
logodds *= -1;
OcTreeKey minKey(0,0,0);
OcTreeKey maxKey(0,0,0);
octree->coordToKeyChecked(min, minKey);
octree->coordToKeyChecked(max, maxKey);
OcTreeKey k;
for (k[0] = minKey[0]; k[0] < maxKey[0]; ++k[0]){
for (k[1] = minKey[1]; k[1] < maxKey[1]; ++k[1]){
for (k[2] = minKey[2]; k[2] < maxKey[2]; ++k[2]){
OcTreeNode* n = octree->search(k);
if(!n)
octree->updateNode(k, logodds);
}
}
}
}
}
showOcTree();
}
void ViewerGui::on_actionExport_view_triggered(){
m_glwidget->openSnapshotFormatDialog();
m_glwidget->saveSnapshot(false);
}
void ViewerGui::on_actionExport_sequence_triggered(bool checked){
if(checked) {
if(m_glwidget->openSnapshotFormatDialog()) {
m_glwidget->saveSnapshot(false);
m_glwidget->setSnapshotCounter(0);
connect(m_glwidget, SIGNAL(drawFinished(bool)), m_glwidget, SLOT(saveSnapshot(bool)));
} else {
ui.actionExport_sequence->setChecked(false);
}
} else {
disconnect(m_glwidget, SIGNAL(drawFinished(bool)), m_glwidget, SLOT(saveSnapshot(bool)));
}
}
void ViewerGui::on_actionPrintout_mode_toggled(bool checked){
if (checked) {
ui.actionHeight_map->setChecked(false);
ui.actionSemanticColoring->setChecked(false);
}
m_glwidget->enablePrintoutMode(checked);
}
void ViewerGui::on_actionSelection_box_toggled(bool checked){
ui.menuDelete_nodes->setEnabled(checked);
ui.menuFill_selection->setEnabled(checked);
ui.menuChange_nodes_in_selection->setEnabled(checked);
m_glwidget->enableSelectionBox(checked);
m_glwidget->update();
}
void ViewerGui::on_actionHeight_map_toggled(bool checked){
if (checked) {
ui.actionPrintout_mode->setChecked(false);
ui.actionSemanticColoring->setChecked(false);
}
m_glwidget->enableHeightColorMode(checked);
}
void ViewerGui::on_actionSemanticColoring_toggled(bool checked) {
if (checked) {
ui.actionHeight_map->setChecked(false);
ui.actionPrintout_mode->setChecked(false);
}
m_glwidget->enableSemanticColoring(checked);
}
void ViewerGui::on_actionStore_camera_triggered(){
m_glwidget->camera()->deletePath(0);
m_glwidget->camera()->addKeyFrameToPath(0);
m_cameraStored = true;
ui.actionRestore_camera->setEnabled(true);
}
void ViewerGui::on_actionRestore_camera_triggered(){
if (m_cameraStored){
m_glwidget->camera()->playPath(0);
}
}
void ViewerGui::on_actionPointcloud_toggled(bool checked){
if (m_pointcloudDrawer){
if (checked)
m_glwidget->addSceneObject(m_pointcloudDrawer);
else
m_glwidget->removeSceneObject(m_pointcloudDrawer);
}
}
void ViewerGui::on_actionTrajectory_toggled(bool checked){
if (m_trajectoryDrawer){
if (checked)
m_glwidget->addSceneObject(m_trajectoryDrawer);
else
m_glwidget->removeSceneObject(m_trajectoryDrawer);
}
}
void ViewerGui::on_actionAxes_toggled(bool checked){
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin();
it != m_octrees.end(); ++it) {
it->second.octree_drawer->enableAxes(checked);
}
m_glwidget->update();
}
void ViewerGui::on_actionHideBackground_toggled(bool checked) {
OcTreeRecord* r;
if (getOctreeRecord(DEFAULT_OCTREE_ID, r)) {
if (checked) m_glwidget->removeSceneObject(r->octree_drawer);
else m_glwidget->addSceneObject(r->octree_drawer);
m_glwidget->update();
}
}
void ViewerGui::on_actionAlternateRendering_toggled(bool checked) {
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin(); it != m_octrees.end(); ++it) {
//std::cout << "Setting Octree " << it->first << " to " << (checked ? "alternate" : "regular") << " rendering.";
it->second.octree_drawer->setAlternativeDrawing(checked);
}
}
void ViewerGui::on_actionClear_triggered() {
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin();
it != m_octrees.end(); ++it) {
m_glwidget->removeSceneObject(it->second.octree_drawer);
delete (it->second.octree_drawer);
delete (it->second.octree);
}
m_octrees.clear();
showOcTree();
}
void ViewerGui::voxelSelected(const QMouseEvent* e){
QPoint pixel_coord = e->pos();
qglviewer::Vec origin;
qglviewer::Vec direction;
m_glwidget->camera()->convertClickToLine(pixel_coord, origin, direction);
const point3d origin3d{(float)origin.x,(float)origin.y,(float)origin.z};
const point3d direction3d{(float)direction.x,(float)direction.y,(float)direction.z};
point3d end3d; // voxel coords hit by ray
QString message = QString("--, --, -- m");
std::list<octomap::OcTreeVolume> selection;
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin(); it != m_octrees.end(); ++it)
{
AbstractOcTree* tree = it->second.octree;
bool ray_hit = false;
if (OcTree* occupancytree = dynamic_cast<OcTree*>(tree))
{
ray_hit = occupancytree->castRay(origin3d, direction3d, end3d, true); // ? append ray distance arg to avoid raycast to inf warnings
}
else if (ColorOcTree* occupancytree = dynamic_cast<ColorOcTree*>(tree))
{
ray_hit = occupancytree->castRay(origin3d, direction3d, end3d, true);
}
else
{
OCTOMAP_ERROR("Could not select nodes of this tree type %s\n", tree->getTreeType().c_str());
continue;
}
if (ray_hit)
{
message = QString("%L1, %L2, %L3 m").arg(end3d.x()).arg(end3d.y()).arg(end3d.z());
OcTreeVolume voxel = OcTreeVolume(end3d, tree->getResolution());
selection.push_back(voxel);
it->second.octree_drawer->setOcTreeSelection(selection);
}
else it->second.octree_drawer->clearOcTreeSelection();
}
m_nodeSelected->setText(message);
m_glwidget->update();
}
void ViewerGui::on_actionTest_triggered(){
}
void ViewerGui::on_actionReload_Octree_triggered(){
if (m_scanGraph) {
generateOctree();
} else {
openFile();
}
}
void ViewerGui::on_actionConvert_ml_tree_triggered(){
QApplication::setOverrideCursor(Qt::WaitCursor);
if (m_octrees.size()) {
showInfo("Converting OcTree to maximum Likelihood map... ");
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin();
it != m_octrees.end(); ++it) {
AbstractOcTree* t = it->second.octree;
if (dynamic_cast<OcTree*>(t)) {
((OcTree*) t)->toMaxLikelihood();
}
else if (dynamic_cast<OcTree*>(t)) {
((ColorOcTree*) t)->toMaxLikelihood();
}
}
showInfo("Done.", true);
showOcTree();
QApplication::restoreOverrideCursor();
}
}
void ViewerGui::on_actionPrune_tree_triggered(){
QApplication::setOverrideCursor(Qt::WaitCursor);
if (m_octrees.size()) {
showInfo("Pruning OcTree... ");
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin();
it != m_octrees.end(); ++it) {
it->second.octree->prune();
}
showOcTree();
showInfo("Done.", true);
}
QApplication::restoreOverrideCursor();
}
void ViewerGui::on_actionExpand_tree_triggered(){
QApplication::setOverrideCursor(Qt::WaitCursor);
// if (m_ocTree) {
if (m_octrees.size()) {
showInfo("Expanding OcTree... ");
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin();
it != m_octrees.end(); ++it) {
it->second.octree->expand();
}
showOcTree();
showInfo("Done.", true);
}
QApplication::restoreOverrideCursor();
}
void ViewerGui::on_actionOctree_cells_toggled(bool enabled) {
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin();
it != m_octrees.end(); ++it) {
it->second.octree_drawer->enableOcTreeCells(enabled);
}
m_glwidget->update();
}
void ViewerGui::on_actionOctree_structure_toggled(bool enabled) {
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin();
it != m_octrees.end(); ++it) {
it->second.octree_drawer->enableOcTree(enabled);
}
m_glwidget->update();
}
void ViewerGui::on_actionFree_toggled(bool enabled) {
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin();
it != m_octrees.end(); ++it) {
it->second.octree_drawer->enableFreespace(enabled);
}
m_glwidget->update();
}
void ViewerGui::on_actionSelected_toggled(bool enabled) {
for (std::map<int, OcTreeRecord>::iterator it = m_octrees.begin();
it != m_octrees.end(); ++it) {
if(it->second.octree_drawer)
it->second.octree_drawer->enableSelection(enabled);
}
}
void ViewerGui::on_action_bg_black_triggered() {
m_glwidget->setBackgroundColor( QColor(0,0,0) );
}
void ViewerGui::on_action_bg_white_triggered() {
m_glwidget->setBackgroundColor( QColor(255,255,255) );
}
void ViewerGui::on_action_bg_gray_triggered() {
m_glwidget->setBackgroundColor( QColor(117,117,117) );
}
void ViewerGui::on_savecampose_triggered() {
QString filename = QFileDialog::getSaveFileName(this, "Save Viewer State", "camera.xml", "Camera/State file (*.xml)");
if (!filename.isEmpty()) {
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
saveCameraPosition(filename.toLatin1().constData());
#else // QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
saveCameraPosition(filename.toAscii().constData());
#endif // QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
}
}
void ViewerGui::on_loadcampose_triggered() {
QString filename = QFileDialog::getOpenFileName(this, "Load Viewer State", "camera.xml", "Camera/State file (*.xml)");
if (!filename.isEmpty()) {
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
loadCameraPosition(filename.toLatin1().constData());
#else // QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
loadCameraPosition(filename.toAscii().constData());
#endif // QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
}
}
void ViewerGui::saveCameraPosition(const char* filename) const {
// HACK get non-const pointer to myself
ViewerWidget* aux = const_cast<ViewerWidget*>( m_glwidget);
aux->setStateFileName(QString(filename));
aux->saveStateToFile();
aux->setStateFileName(QString::null);
}
void ViewerGui::loadCameraPosition(const char* filename) {
m_glwidget->setStateFileName(QString(filename));
m_glwidget->restoreStateFromFile();
m_glwidget->setStateFileName(QString::null);
}
}
| 41,932 | 31.888627 | 208 | cpp |
octomap | octomap-master/octovis/src/ViewerSettings.cpp | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#include <octovis/ViewerSettings.h>
ViewerSettings::ViewerSettings(QWidget *parent)
: QDialog(parent)
{
ui.setupUi(this);
}
ViewerSettings::~ViewerSettings()
{
}
| 1,159 | 30.351351 | 77 | cpp |
octomap | octomap-master/octovis/src/ViewerSettingsPanel.cpp | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#include <octovis/ViewerSettingsPanel.h>
ViewerSettingsPanel::ViewerSettingsPanel(QWidget *parent)
: QWidget(parent), m_currentScan(0), m_numberScans(0), m_treeDepth(_TREE_MAX_DEPTH), m_resolution(0.1)
{
ui.setupUi(this);
connect(ui.treeDepth, SIGNAL(valueChanged(int)), this, SLOT(setTreeDepth(int)));
scanProgressChanged();
leafSizeChanged();
}
ViewerSettingsPanel::~ViewerSettingsPanel()
{
}
void ViewerSettingsPanel::on_nextScanButton_clicked(){
if (m_currentScan < m_numberScans){
m_currentScan++;
scanProgressChanged();
emit addNextScans(1);
}
}
void ViewerSettingsPanel::on_fastFwdScanButton_clicked(){
unsigned increase = int(m_numberScans)-int(m_currentScan);
if (increase > 5) increase = 5;
m_currentScan += increase;
scanProgressChanged();
emit addNextScans(increase);
}
void ViewerSettingsPanel::on_lastScanButton_clicked(){
unsigned increase = int(m_numberScans)-int(m_currentScan);
m_currentScan += increase;
scanProgressChanged();
emit addNextScans(increase);
}
void ViewerSettingsPanel::on_firstScanButton_clicked(){
m_currentScan = 1;
scanProgressChanged();
emit gotoFirstScan();
}
void ViewerSettingsPanel::scanProgressChanged(){
if (int(m_numberScans) > 1)
ui.scanProgressBar->setMaximum(int(m_numberScans));
else
ui.scanProgressBar->setMaximum(1);
if (m_currentScan == m_numberScans){
ui.nextScanButton->setEnabled(false);
ui.fastFwdScanButton->setEnabled(false);
ui.lastScanButton->setEnabled(false);
} else{
ui.nextScanButton->setEnabled(true);
ui.fastFwdScanButton->setEnabled(true);
ui.lastScanButton->setEnabled(true);
}
if (m_currentScan < 2){
ui.firstScanButton->setEnabled(false);
} else{
ui.firstScanButton->setEnabled(true);
}
ui.scanProgressBar->setValue(m_currentScan);
// queue a redraw:
ui.scanProgressBar->update();
}
void ViewerSettingsPanel::setNumberOfScans(unsigned scans){
m_numberScans = scans;
scanProgressChanged();
}
void ViewerSettingsPanel::setCurrentScan(unsigned scan){
m_currentScan = scan;
scanProgressChanged();
}
void ViewerSettingsPanel::setResolution(double resolution){
m_resolution = resolution;
leafSizeChanged();
}
void ViewerSettingsPanel::setTreeDepth(int depth){
emit treeDepthChanged(depth);
m_treeDepth = depth;
ui.treeDepth->setValue(depth);
ui.treeDepthSlider->setValue(depth);
leafSizeChanged();
}
void ViewerSettingsPanel::leafSizeChanged(){
double leafSize = m_resolution * pow(2.0, (int) (_TREE_MAX_DEPTH-m_treeDepth));
ui.leafSize->setText(QString::number(leafSize)+" m");
}
| 3,589 | 27.492063 | 106 | cpp |
octomap | octomap-master/octovis/src/ViewerSettingsPanelCamera.cpp | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#include <octovis/ViewerSettingsPanelCamera.h>
#include <iostream>
ViewerSettingsPanelCamera::ViewerSettingsPanelCamera(QWidget *parent)
: QWidget(parent), m_currentFrame(1), m_numberFrames(0), m_robotTrajectoryAvailable(false)
{
ui.setupUi(this);
connect(ui.posX, SIGNAL(valueChanged(double)), this, SLOT(positionEditDone(double)));
connect(ui.posY, SIGNAL(valueChanged(double)), this, SLOT(positionEditDone(double)));
connect(ui.posZ, SIGNAL(valueChanged(double)), this, SLOT(positionEditDone(double)));
connect(ui.lookX, SIGNAL(valueChanged(double)), this, SLOT(positionEditDone(double)));
connect(ui.lookY, SIGNAL(valueChanged(double)), this, SLOT(positionEditDone(double)));
connect(ui.lookZ, SIGNAL(valueChanged(double)), this, SLOT(positionEditDone(double)));
ui.followTrajectoryButton->setEnabled(m_robotTrajectoryAvailable);
dataChanged();
}
ViewerSettingsPanelCamera::~ViewerSettingsPanelCamera()
{
}
QSize ViewerSettingsPanelCamera::sizeHint() const {
return QSize(250, 180);
}
void ViewerSettingsPanelCamera::positionEditDone(double){
emit changeCamPosition(ui.posX->value(), ui.posY->value(), ui.posZ->value(), ui.lookX->value(), ui.lookY->value(), ui.lookZ->value());
}
void ViewerSettingsPanelCamera::setNumberOfFrames(unsigned frames){
m_numberFrames = frames;
dataChanged();
}
void ViewerSettingsPanelCamera::setCurrentFrame(unsigned frame){
m_currentFrame = frame;
dataChanged();
}
void ViewerSettingsPanelCamera::setRobotTrajectoryAvailable(bool available) {
m_robotTrajectoryAvailable = available;
if(!available) ui.followTrajectoryButton->setChecked(false);
ui.followTrajectoryButton->setEnabled(available);
}
void ViewerSettingsPanelCamera::gotoFrame(unsigned int frame) {
if(frame > 0 && frame <= m_numberFrames) {
m_currentFrame = frame;
emit jumpToFrame(m_currentFrame);
dataChanged();
}
}
void ViewerSettingsPanelCamera::on_nextScanButton_clicked(){
gotoFrame(m_currentFrame + 1);
}
void ViewerSettingsPanelCamera::on_previousScanButton_clicked(){
gotoFrame(m_currentFrame - 1);
}
void ViewerSettingsPanelCamera::on_firstScanButton_clicked(){
gotoFrame(1);
}
void ViewerSettingsPanelCamera::on_lastScanButton_clicked(){
gotoFrame(m_numberFrames);
}
void ViewerSettingsPanelCamera::on_followCameraPathButton_clicked(){
emit followCameraPath();
}
void ViewerSettingsPanelCamera::on_followTrajectoryButton_clicked(){
emit followRobotPath();
}
void ViewerSettingsPanelCamera::on_cameraPathAdd_clicked(){
emit addToCameraPath();
}
void ViewerSettingsPanelCamera::on_cameraPathRemove_clicked(){
emit removeFromCameraPath();
}
void ViewerSettingsPanelCamera::on_cameraPathClear_clicked(){
emit clearCameraPath();
}
void ViewerSettingsPanelCamera::on_cameraPathSave_clicked(){
emit saveToCameraPath();
}
void ViewerSettingsPanelCamera::on_playScanButton_clicked(){
if(ui.playScanButton->isChecked()) {
ui.scanProgressSlider->setEnabled(false);
ui.followGroupBox->setEnabled(false);
emit play();
} else {
ui.scanProgressSlider->setEnabled(true);
ui.followGroupBox->setEnabled(true);
emit pause();
}
dataChanged();
}
void ViewerSettingsPanelCamera::on_scanProgressSlider_sliderMoved(int value) {
gotoFrame(value);
}
void ViewerSettingsPanelCamera::setStopped(){
ui.followGroupBox->setEnabled(true);
ui.scanProgressSlider->setEnabled(true);
ui.playScanButton->setChecked(false);
dataChanged();
}
void ViewerSettingsPanelCamera::dataChanged(){
unsigned int max = std::max(0,int(m_numberFrames));
unsigned int cur = std::min(max, m_currentFrame);
ui.scanProgressSlider->setMaximum(max);
ui.scanProgressSlider->setMinimum(1);
if(ui.playScanButton->isChecked()) {
ui.firstScanButton->setEnabled(false);
ui.nextScanButton->setEnabled(false);
ui.previousScanButton->setEnabled(false);
ui.lastScanButton->setEnabled(false);
} else {
if (m_currentFrame >= max){
ui.nextScanButton->setEnabled(false);
ui.playScanButton->setEnabled(false);
ui.lastScanButton->setEnabled(false);
} else {
ui.nextScanButton->setEnabled(true);
ui.playScanButton->setEnabled(true);
ui.lastScanButton->setEnabled(true);
}
if (m_currentFrame < 2){
ui.firstScanButton->setEnabled(cur > 0);
ui.previousScanButton->setEnabled(false);
} else{
ui.firstScanButton->setEnabled(true);
ui.previousScanButton->setEnabled(true);
}
if (max > 1) {
ui.playScanButton->setEnabled(true);
} else {
ui.playScanButton->setEnabled(false);
}
}
if(followRobotTrajectory() || ui.playScanButton->isChecked()) {
ui.cameraPathAdd->setEnabled(false);
ui.cameraPathRemove->setEnabled(false);
ui.cameraPathSave->setEnabled(false);
ui.cameraPathClear->setEnabled(false);
} else {
ui.cameraPathAdd->setEnabled(true);
ui.cameraPathRemove->setEnabled(m_numberFrames > 0);
ui.cameraPathSave->setEnabled(m_numberFrames > 0);
ui.cameraPathClear->setEnabled(m_numberFrames > 0);
}
if(max > 0 && !ui.playScanButton->isChecked()) {
ui.scanProgressSlider->setEnabled(true);
} else {
ui.scanProgressSlider->setEnabled(false);
}
ui.scanProgressSlider->setValue(cur);
ui.scanProgressLabel->setText(QString("%1/%2").arg(cur).arg(max));
// queue a redraw:
ui.scanProgressSlider->update();
}
bool ViewerSettingsPanelCamera::followRobotTrajectory(){
return ui.followTrajectoryButton->isChecked();
}
| 6,474 | 29.257009 | 136 | cpp |
octomap | octomap-master/octovis/src/ViewerWidget.cpp | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#include <octovis/ViewerWidget.h>
#include <manipulatedCameraFrame.h>
#ifndef M_PI_2
#define M_PI_2 1.5707963267948966192E0
#endif
using namespace std;
namespace octomap {
ViewerWidget::ViewerWidget(QWidget* parent) :
QGLViewer(parent), m_zMin(0.0),m_zMax(1.0) {
m_printoutMode = false;
m_heightColorMode = false;
m_semantic_coloring = false;
m_drawSelectionBox = false;
}
void ViewerWidget::init() {
// setHandlerKeyboardModifiers(QGLViewer::CAMERA, Qt::AltModifier);
// setHandlerKeyboardModifiers(QGLViewer::FRAME, Qt::NoModifier);
// setHandlerKeyboardModifiers(QGLViewer::CAMERA, Qt::ControlModifier);
setMouseTracking(true);
// Restore previous viewer state.
restoreStateFromFile();
// Make camera the default manipulated frame.
setManipulatedFrame( camera()->frame() );
// invert mousewheel (more like Blender)
camera()->frame()->setWheelSensitivity(-1.0);
// Light initialization:
glEnable(GL_LIGHT0);
float pos[4] = {-1.0, 1.0, 1.0, 0.0};
// Directional light
glLightfv(GL_LIGHT0, GL_POSITION, pos);
// background color defaults to white
this->setBackgroundColor( QColor(255,255,255) );
}
void ViewerWidget::resetView(){
this->camera()->setOrientation((float) -M_PI_2, (float) M_PI_2);
this->showEntireScene();
update();
}
QString ViewerWidget::helpString() const{
QString help = "<h2>Octomap 3D viewer</h2>";
help +="The Octomap library implements a 3D occupancy grid mapping approach. "
"It provides data structures and mapping algorithms. The map is implemented "
"using an octree. 3D maps can be viewed an built using this 3D viewer."
"<br/><br/>"
"Octomap is available at https://octomap.github.io, and is actively "
"maintained by Kai M. Wurm and Armin Hornung. This 3D viewer is based on "
"libQGLViewer, available at http://www.libqglviewer.com/."
"<br/><br/>"
"Please refer to the \"Keyboard\" and \"Mouse\" tabs for instructions on "
"how to use the viewer.";
return help;
}
void ViewerWidget::enableHeightColorMode (bool enabled) {
m_heightColorMode = enabled;
for(std::vector<SceneObject*>::iterator it = m_sceneObjects.begin(); it != m_sceneObjects.end(); it++) {
(*it)->enableHeightColorMode(enabled);
}
update();
}
void ViewerWidget::enablePrintoutMode(bool enabled) {
m_printoutMode = enabled;
for(std::vector<SceneObject*>::iterator it = m_sceneObjects.begin(); it != m_sceneObjects.end(); it++) {
(*it)->enablePrintoutMode(enabled);
}
update();
}
void ViewerWidget::enableSemanticColoring (bool enabled) {
m_semantic_coloring = enabled;
for(std::vector<SceneObject*>::iterator it = m_sceneObjects.begin(); it != m_sceneObjects.end(); it++) {
(*it)->enableSemanticColoring(enabled);
}
update();
}
void ViewerWidget::enableSelectionBox(bool enabled) {
m_drawSelectionBox = enabled;
update();
}
qglviewer::Quaternion ViewerWidget::poseToQGLQuaternion(const octomath::Pose6D& pose) {
// copying octomap::Quaternion parameters to qglviewer::Quaternion does not work (reason unknown)
// octomath::Quaternion quaternion = pose.rot().normalized();
// return qglviewer::Quaternion(quaternion.x(), quaternion.y(), quaternion.z(), quaternion.u());
// Compute viewing direction and use code from libqglviewer's "look at" function
octomath::Vector3 dir = pose.rot().rotate(octomath::Vector3(1.,0.,0.));
qglviewer::Vec direction(dir.x(), dir.y(), dir.z());
//qglviewer::Vec xAxis = direction ^ camera()->upVector();
// useing 0, 0, 1 as upvector instead:
qglviewer::Vec xAxis = direction ^ qglviewer::Vec(0.0, 0.0, 1.0);
qglviewer::Quaternion q;
q.setFromRotatedBasis(xAxis, xAxis^direction, -direction);
return q;
}
void ViewerWidget::setCamPosition(double x, double y, double z, double lookX, double lookY, double lookZ){
this->camera()->setOrientation(-M_PI/2., M_PI/2.);
camera()->setPosition(qglviewer::Vec(x, y, z));
camera()->lookAt(qglviewer::Vec(lookX, lookY, lookZ));
camera()->setUpVector(qglviewer::Vec(0.0, 0.0, 1.0));
update();
}
void ViewerWidget::setCamPose(const octomath::Pose6D& pose){
octomath::Pose6D ahead = pose * octomath::Pose6D(octomath::Vector3(1,0,0), octomath::Quaternion());
setCamPosition(pose.x(), pose.y(), pose.z(), ahead.x(), ahead.y(), ahead.z());
}
void ViewerWidget::jumpToCamFrame(int id, int frame) {
qglviewer::KeyFrameInterpolator *kfi = camera()->keyFrameInterpolator(id);
if(kfi && frame >= 0 && frame < kfi->numberOfKeyFrames()) {
camera()->setPosition(kfi->keyFrame(frame).position());
camera()->setOrientation(kfi->keyFrame(frame).orientation());
} else {
std::cerr << "Error: Could not jump to frame " << frame << " of " << kfi->numberOfKeyFrames() << std::endl;
}
update();
}
void ViewerWidget::deleteCameraPath(int id) {
if(camera()->keyFrameInterpolator(id)) {
disconnect(camera()->keyFrameInterpolator(id), SIGNAL(interpolated()), this, SLOT(update()));
disconnect(camera()->keyFrameInterpolator(id), SIGNAL(interpolated()), this, SLOT(cameraPathInterpolated()));
disconnect(camera()->keyFrameInterpolator(id), SIGNAL(endReached()), this, SLOT(cameraPathFinished()));
camera()->deletePath(id);
}
}
void ViewerWidget::appendToCameraPath(int id, const octomath::Pose6D& pose) {
qglviewer::Vec position(pose.trans().x(), pose.trans().y(), pose.trans().z());
qglviewer::Quaternion quaternion = poseToQGLQuaternion(pose);
qglviewer::Frame frame(position, quaternion);
if(!camera()->keyFrameInterpolator(id)) {
camera()->setKeyFrameInterpolator(id, new qglviewer::KeyFrameInterpolator(camera()->frame()));
}
camera()->keyFrameInterpolator(id)->addKeyFrame(frame);
}
void ViewerWidget::removeFromCameraPath(int id, int frame) {
qglviewer::KeyFrameInterpolator *old_kfi = camera()->keyFrameInterpolator(id);
if(old_kfi) {
qglviewer::KeyFrameInterpolator *new_kfi = new qglviewer::KeyFrameInterpolator(camera()->frame());
for(int i = 0; i < old_kfi->numberOfKeyFrames(); i++) {
if(i != frame) {
new_kfi->addKeyFrame(old_kfi->keyFrame(i));
}
}
deleteCameraPath(id);
camera()->setKeyFrameInterpolator(id, new_kfi);
}
}
void ViewerWidget::updateCameraPath(int id, int frame) {
qglviewer::KeyFrameInterpolator *old_kfi = camera()->keyFrameInterpolator(id);
if(old_kfi) {
qglviewer::KeyFrameInterpolator *new_kfi = new qglviewer::KeyFrameInterpolator(camera()->frame());
for(int i = 0; i < old_kfi->numberOfKeyFrames(); i++) {
if(i != frame) {
new_kfi->addKeyFrame(old_kfi->keyFrame(i));
} else {
new_kfi->addKeyFrame(*(camera()->frame()));
}
}
deleteCameraPath(id);
camera()->setKeyFrameInterpolator(id, new_kfi);
}
}
void ViewerWidget::appendCurrentToCameraPath(int id) {
int frame = 0;
if(camera()->keyFrameInterpolator(id)) frame = camera()->keyFrameInterpolator(id)->numberOfKeyFrames();
addCurrentToCameraPath(id, frame);
}
void ViewerWidget::addCurrentToCameraPath(int id, int frame) {
qglviewer::KeyFrameInterpolator *old_kfi = camera()->keyFrameInterpolator(id);
if(!old_kfi || frame >= old_kfi->numberOfKeyFrames()) {
camera()->addKeyFrameToPath(id);
} else {
qglviewer::KeyFrameInterpolator *new_kfi = new qglviewer::KeyFrameInterpolator(camera()->frame());
for(int i = 0; i < old_kfi->numberOfKeyFrames(); i++) {
new_kfi->addKeyFrame(old_kfi->keyFrame(i));
if(i == frame) {
new_kfi->addKeyFrame(camera()->frame());
}
}
deleteCameraPath(id);
camera()->setKeyFrameInterpolator(id, new_kfi);
}
}
void ViewerWidget::playCameraPath(int id, int start_frame) {
qglviewer::KeyFrameInterpolator *kfi = camera()->keyFrameInterpolator(id);
if(kfi && !kfi->interpolationIsStarted() && start_frame >= 0 && start_frame < kfi->numberOfKeyFrames()) {
m_current_camera_path = id;
m_current_camera_frame = start_frame;
kfi->setInterpolationTime(kfi->keyFrameTime(start_frame));
std::cout << "Playing path of length " << kfi->numberOfKeyFrames() << ", start time " << kfi->keyFrameTime(start_frame) << std::endl;
connect(kfi, SIGNAL(interpolated()), this, SLOT(update()));
connect(kfi, SIGNAL(interpolated()), this, SLOT(cameraPathInterpolated()));
connect(kfi, SIGNAL(endReached()), this, SLOT(cameraPathFinished()));
kfi->startInterpolation();
}
}
void ViewerWidget::stopCameraPath(int id) {
if(camera()->keyFrameInterpolator(id) && camera()->keyFrameInterpolator(id)->interpolationIsStarted()) {
disconnect(camera()->keyFrameInterpolator(id), SIGNAL(interpolated()), this, SLOT(update()));
disconnect(camera()->keyFrameInterpolator(id), SIGNAL(interpolated()), this, SLOT(cameraPathInterpolated()));
disconnect(camera()->keyFrameInterpolator(id), SIGNAL(endReached()), this, SLOT(cameraPathFinished()));
camera()->keyFrameInterpolator(id)->stopInterpolation();
}
}
void ViewerWidget::cameraPathFinished() {
if(camera()->keyFrameInterpolator(m_current_camera_path)) {
disconnect(camera()->keyFrameInterpolator(m_current_camera_path), SIGNAL(interpolated()), this, SLOT(update()));
disconnect(camera()->keyFrameInterpolator(m_current_camera_path), SIGNAL(interpolated()), this, SLOT(cameraPathInterpolated()));
disconnect(camera()->keyFrameInterpolator(m_current_camera_path), SIGNAL(endReached()), this, SLOT(cameraPathFinished()));
emit cameraPathStopped(m_current_camera_path);
}
}
void ViewerWidget::cameraPathInterpolated() {
qglviewer::KeyFrameInterpolator *kfi = camera()->keyFrameInterpolator(m_current_camera_path);
if(kfi) {
int current_frame = m_current_camera_frame;
for(int i = m_current_camera_frame + 1; i < kfi->numberOfKeyFrames(); i++) {
if(kfi->keyFrameTime(current_frame) <= kfi->interpolationTime()) current_frame = i;
else break;
}
if(current_frame != m_current_camera_frame) {
m_current_camera_frame = current_frame;
emit cameraPathFrameChanged(m_current_camera_path, m_current_camera_frame);
}
}
}
void ViewerWidget::setSceneBoundingBox(const qglviewer::Vec& min, const qglviewer::Vec& max){
m_zMin = min[2];
m_zMax = max[2];
QGLViewer::setSceneBoundingBox(min, max);
}
void ViewerWidget::addSceneObject(SceneObject* obj){
assert (obj);
m_sceneObjects.push_back(obj);
update();
}
void ViewerWidget::removeSceneObject(SceneObject* obj){
assert(obj);
for(std::vector<SceneObject*>::iterator it = m_sceneObjects.begin();
it != m_sceneObjects.end();){
if (*it == obj)
it = m_sceneObjects.erase(it);
else
++it;
}
update();
}
void ViewerWidget::clearAll(){
// clear drawable objects:
for(std::vector<SceneObject*>::iterator it = m_sceneObjects.begin(); it != m_sceneObjects.end(); it++){
(*it)->clear();
}
}
void ViewerWidget::draw(){
// debugging: draw light in scene
//drawLight(GL_LIGHT0);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_LIGHTING);
if (m_printoutMode){
glCullFace(GL_BACK);
}
// draw drawable objects:
for(std::vector<SceneObject*>::iterator it = m_sceneObjects.begin();
it != m_sceneObjects.end(); ++it){
(*it)->draw();
}
if (m_drawSelectionBox){
m_selectionBox.draw();
if (m_selectionBox.getGrabbedFrame() >= 0){
setMouseBinding(Qt::LeftButton, FRAME, TRANSLATE);
} else {
setMouseBinding(Qt::LeftButton, FRAME, ROTATE);
}
}
}
void ViewerWidget::drawWithNames(){
if (m_drawSelectionBox)
m_selectionBox.draw(true);
}
void ViewerWidget::postDraw(){
// Reset model view matrix to world coordinates origin
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
camera()->loadModelViewMatrix();
// TODO restore model loadProjectionMatrixStereo
// Save OpenGL state
glPushAttrib(GL_ALL_ATTRIB_BITS);
glDisable(GL_COLOR_MATERIAL);
if (gridIsDrawn()){
glLineWidth(1.0);
drawGrid(5.0, 10);
}
if (axisIsDrawn()){
glLineWidth(2.0);
drawAxis(1.0);
}
// Restore GL state
glPopAttrib();
glPopMatrix();
m_drawAxis = axisIsDrawn();
m_drawGrid = gridIsDrawn();
setAxisIsDrawn(false);
setGridIsDrawn(false);
QGLViewer::postDraw();
setAxisIsDrawn(m_drawAxis);
setGridIsDrawn(m_drawGrid);
}
void ViewerWidget::postSelection(const QPoint&)
{
}
} // namespace
| 13,350 | 32.461153 | 137 | cpp |
octomap | octomap-master/octovis/src/main.cpp | /*
* This file is part of OctoMap - An Efficient Probabilistic 3D Mapping
* Framework Based on Octrees
* http://octomap.github.io
*
* Copyright (c) 2009-2014, K.M. Wurm and A. Hornung, University of Freiburg
* All rights reserved. License for the viewer octovis: GNU GPL v2
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
*
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see http://www.gnu.org/licenses/.
*/
#include <QtGui>
#include <QApplication>
#include <octovis/ViewerGui.h>
#include <stdlib.h> //strtol
int main(int argc, char *argv[]) {
std::string filename = "";
int depth = 0;
if (argc == 1) {
std::cout << "Usage: " << argv[0] << " [mapfile] [tree depth cutoff]\n";
std::cout << "Where the optional [tree depth cutoff] is an integer from 1 to 16\n";
}
if (argc >= 2) { filename = std::string(argv[1]); }
if (argc >= 3) { depth = std::strtol(argv[2], NULL, 10); }//zero on parse error
QApplication app(argc, argv);
octomap::ViewerGui gui(filename, NULL, depth);
gui.show();
return app.exec();
}
| 1,621 | 33.510638 | 88 | cpp |
octomap | octomap-master/octovis/src/extern/QGLViewer/camera.cpp | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#include "domUtils.h"
#include "camera.h"
#include "qglviewer.h"
#include "manipulatedCameraFrame.h"
using namespace std;
using namespace qglviewer;
/*! Default constructor.
sceneCenter() is set to (0,0,0) and sceneRadius() is set to 1.0. type() is Camera::PERSPECTIVE,
with a \c M_PI/4 fieldOfView().
See IODistance(), physicalDistanceToScreen(), physicalScreenWidth() and focusDistance()
documentations for default stereo parameter values. */
Camera::Camera()
: frame_(NULL), fieldOfView_(M_PI/4.0), modelViewMatrixIsUpToDate_(false), projectionMatrixIsUpToDate_(false)
{
// #CONNECTION# Camera copy constructor
interpolationKfi_ = new KeyFrameInterpolator;
// Requires the interpolationKfi_
setFrame(new ManipulatedCameraFrame());
// #CONNECTION# All these default values identical in initFromDOMElement.
// Requires fieldOfView() to define focusDistance()
setSceneRadius(1.0);
// Initial value (only scaled after this)
orthoCoef_ = tan(fieldOfView()/2.0);
// Also defines the pivotPoint(), which changes orthoCoef_. Requires a frame().
setSceneCenter(Vec(0.0, 0.0, 0.0));
// Requires fieldOfView() when called with ORTHOGRAPHIC. Attention to projectionMatrix_ below.
setType(PERSPECTIVE);
// #CONNECTION# initFromDOMElement default values
setZNearCoefficient(0.005);
setZClippingCoefficient(sqrt(3.0));
// Dummy values
setScreenWidthAndHeight(600, 400);
// Stereo parameters
setIODistance(0.062);
setPhysicalScreenWidth(0.5);
// focusDistance is set from setFieldOfView()
// #CONNECTION# Camera copy constructor
for (unsigned short j=0; j<16; ++j)
{
modelViewMatrix_[j] = ((j%5 == 0) ? 1.0 : 0.0);
// #CONNECTION# computeProjectionMatrix() is lazy and assumes 0.0 almost everywhere.
projectionMatrix_[j] = 0.0;
}
computeProjectionMatrix();
}
/*! Virtual destructor.
The frame() is deleted, but the different keyFrameInterpolator() are \e not deleted (in case they
are shared). */
Camera::~Camera()
{
delete frame_;
delete interpolationKfi_;
}
/*! Copy constructor. Performs a deep copy using operator=(). */
Camera::Camera(const Camera& camera)
: QObject(), frame_(NULL)
{
// #CONNECTION# Camera constructor
interpolationKfi_ = new KeyFrameInterpolator;
// Requires the interpolationKfi_
setFrame(new ManipulatedCameraFrame(*camera.frame()));
for (unsigned short j=0; j<16; ++j)
{
modelViewMatrix_[j] = ((j%5 == 0) ? 1.0 : 0.0);
// #CONNECTION# computeProjectionMatrix() is lazy and assumes 0.0 almost everywhere.
projectionMatrix_[j] = 0.0;
}
(*this)=camera;
}
/*! Equal operator.
All the parameters of \p camera are copied. The frame() pointer is not modified, but its
Frame::position() and Frame::orientation() are set to those of \p camera.
\attention The Camera screenWidth() and screenHeight() are set to those of \p camera. If your
Camera is associated with a QGLViewer, you should update these value after the call to this method:
\code
*(camera()) = otherCamera;
camera()->setScreenWidthAndHeight(width(), height());
\endcode
The same applies to sceneCenter() and sceneRadius(), if needed. */
Camera& Camera::operator=(const Camera& camera)
{
setScreenWidthAndHeight(camera.screenWidth(), camera.screenHeight());
setFieldOfView(camera.fieldOfView());
setSceneRadius(camera.sceneRadius());
setSceneCenter(camera.sceneCenter());
setZNearCoefficient(camera.zNearCoefficient());
setZClippingCoefficient(camera.zClippingCoefficient());
setType(camera.type());
// Stereo parameters
setIODistance(camera.IODistance());
setFocusDistance(camera.focusDistance());
setPhysicalScreenWidth(camera.physicalScreenWidth());
orthoCoef_ = camera.orthoCoef_;
projectionMatrixIsUpToDate_ = false;
// frame_ and interpolationKfi_ pointers are not shared.
frame_->setReferenceFrame(NULL);
frame_->setPosition(camera.position());
frame_->setOrientation(camera.orientation());
interpolationKfi_->resetInterpolation();
kfi_ = camera.kfi_;
computeProjectionMatrix();
computeModelViewMatrix();
return *this;
}
/*! Sets Camera screenWidth() and screenHeight() (expressed in pixels).
You should not call this method when the Camera is associated with a QGLViewer, since the
latter automatically updates these values when it is resized (hence overwritting your values).
Non-positive dimension are silently replaced by a 1 pixel value to ensure frustrum coherence.
If your Camera is used without a QGLViewer (offscreen rendering, shadow maps), use setAspectRatio()
instead to define the projection matrix. */
void Camera::setScreenWidthAndHeight(int width, int height)
{
// Prevent negative and zero dimensions that would cause divisions by zero.
screenWidth_ = width > 0 ? width : 1;
screenHeight_ = height > 0 ? height : 1;
projectionMatrixIsUpToDate_ = false;
}
/*! Returns the near clipping plane distance used by the Camera projection matrix.
The clipping planes' positions depend on the sceneRadius() and sceneCenter() rather than being fixed
small-enough and large-enough values. A good scene dimension approximation will hence result in an
optimal precision of the z-buffer.
The near clipping plane is positioned at a distance equal to zClippingCoefficient() * sceneRadius()
in front of the sceneCenter():
\code
zNear = distanceToSceneCenter() - zClippingCoefficient()*sceneRadius();
\endcode
In order to prevent negative or too small zNear() values (which would degrade the z precision),
zNearCoefficient() is used when the Camera is inside the sceneRadius() sphere:
\code
const qreal zMin = zNearCoefficient() * zClippingCoefficient() * sceneRadius();
if (zNear < zMin)
zNear = zMin;
// With an ORTHOGRAPHIC type, the value is simply clamped to 0.0
\endcode
See also the zFar(), zClippingCoefficient() and zNearCoefficient() documentations.
If you need a completely different zNear computation, overload the zNear() and zFar() methods in a
new class that publicly inherits from Camera and use QGLViewer::setCamera():
\code
class myCamera :: public qglviewer::Camera
{
virtual qreal Camera::zNear() const { return 0.001; };
virtual qreal Camera::zFar() const { return 100.0; };
}
\endcode
See the <a href="../examples/standardCamera.html">standardCamera example</a> for an application.
\attention The value is always positive although the clipping plane is positioned at a negative z
value in the Camera coordinate system. This follows the \c gluPerspective standard. */
qreal Camera::zNear() const
{
const qreal zNearScene = zClippingCoefficient() * sceneRadius();
qreal z = distanceToSceneCenter() - zNearScene;
// Prevents negative or null zNear values.
const qreal zMin = zNearCoefficient() * zNearScene;
if (z < zMin)
switch (type())
{
case Camera::PERSPECTIVE : z = zMin; break;
case Camera::ORTHOGRAPHIC : z = 0.0; break;
}
return z;
}
/*! Returns the far clipping plane distance used by the Camera projection matrix.
The far clipping plane is positioned at a distance equal to zClippingCoefficient() * sceneRadius()
behind the sceneCenter():
\code
zFar = distanceToSceneCenter() + zClippingCoefficient()*sceneRadius();
\endcode
See the zNear() documentation for details. */
qreal Camera::zFar() const
{
return distanceToSceneCenter() + zClippingCoefficient() * sceneRadius();
}
/*! Sets the vertical fieldOfView() of the Camera (in radians).
Note that focusDistance() is set to sceneRadius() / tan(fieldOfView()/2) by this method. */
void Camera::setFieldOfView(qreal fov) {
fieldOfView_ = fov;
setFocusDistance(sceneRadius() / tan(fov/2.0));
projectionMatrixIsUpToDate_ = false;
}
/*! Defines the Camera type().
Changing the camera Type alters the viewport and the objects' sizes can be changed.
This method garantees that the two frustum match in a plane normal to viewDirection(), passing through the pivotPoint().
Prefix the type with \c Camera if needed, as in:
\code
camera()->setType(Camera::ORTHOGRAPHIC);
// or even qglviewer::Camera::ORTHOGRAPHIC if you do not use namespace
\endcode */
void Camera::setType(Type type)
{
// make ORTHOGRAPHIC frustum fit PERSPECTIVE (at least in plane normal to viewDirection(), passing
// through RAP). Done only when CHANGING type since orthoCoef_ may have been changed with a
// setPivotPoint() in the meantime.
if ( (type == Camera::ORTHOGRAPHIC) && (type_ == Camera::PERSPECTIVE) )
orthoCoef_ = tan(fieldOfView()/2.0);
type_ = type;
projectionMatrixIsUpToDate_ = false;
}
/*! Sets the Camera frame().
If you want to move the Camera, use setPosition() and setOrientation() or one of the Camera
positioning methods (lookAt(), fitSphere(), showEntireScene()...) instead.
If you want to save the Camera position(), there's no need to call this method either. Use
addKeyFrameToPath() and playPath() instead.
This method is actually mainly useful if you derive the ManipulatedCameraFrame class and want to
use an instance of your new class to move the Camera.
A \c NULL \p mcf pointer will silently be ignored. The calling method is responsible for
deleting the previous frame() pointer if needed in order to prevent memory leaks. */
void Camera::setFrame(ManipulatedCameraFrame* const mcf)
{
if (!mcf)
return;
if (frame_) {
disconnect(frame_, SIGNAL(modified()), this, SLOT(onFrameModified()));
}
frame_ = mcf;
interpolationKfi_->setFrame(frame());
connect(frame_, SIGNAL(modified()), this, SLOT(onFrameModified()));
onFrameModified();
}
/*! Returns the distance from the Camera center to sceneCenter(), projected along the Camera Z axis.
Used by zNear() and zFar() to optimize the Z range. */
qreal Camera::distanceToSceneCenter() const
{
return fabs((frame()->coordinatesOf(sceneCenter())).z);
}
/*! Returns the \p halfWidth and \p halfHeight of the Camera orthographic frustum.
These values are only valid and used when the Camera is of type() Camera::ORTHOGRAPHIC. They are
expressed in OpenGL units and are used by loadProjectionMatrix() to define the projection matrix
using:
\code
glOrtho( -halfWidth, halfWidth, -halfHeight, halfHeight, zNear(), zFar() )
\endcode
These values are proportional to the Camera (z projected) distance to the pivotPoint().
When zooming on the object, the Camera is translated forward \e and its frustum is narrowed, making
the object appear bigger on screen, as intuitively expected.
Overload this method to change this behavior if desired, as is done in the
<a href="../examples/standardCamera.html">standardCamera example</a>. */
void Camera::getOrthoWidthHeight(GLdouble& halfWidth, GLdouble& halfHeight) const
{
const qreal dist = orthoCoef_ * fabs(cameraCoordinatesOf(pivotPoint()).z);
//#CONNECTION# fitScreenRegion
halfWidth = dist * ((aspectRatio() < 1.0) ? 1.0 : aspectRatio());
halfHeight = dist * ((aspectRatio() < 1.0) ? 1.0/aspectRatio() : 1.0);
}
/*! Computes the projection matrix associated with the Camera.
If type() is Camera::PERSPECTIVE, defines a \c GL_PROJECTION matrix similar to what would \c
gluPerspective() do using the fieldOfView(), window aspectRatio(), zNear() and zFar() parameters.
If type() is Camera::ORTHOGRAPHIC, the projection matrix is as what \c glOrtho() would do.
Frustum's width and height are set using getOrthoWidthHeight().
Both types use zNear() and zFar() to place clipping planes. These values are determined from
sceneRadius() and sceneCenter() so that they best fit the scene size.
Use getProjectionMatrix() to retrieve this matrix. Overload loadProjectionMatrix() if you want your
Camera to use an exotic projection matrix.
\note You must call this method if your Camera is not associated with a QGLViewer and is used for
offscreen computations (using (un)projectedCoordinatesOf() for instance). loadProjectionMatrix()
does it otherwise. */
void Camera::computeProjectionMatrix() const
{
if (projectionMatrixIsUpToDate_) return;
const qreal ZNear = zNear();
const qreal ZFar = zFar();
switch (type())
{
case Camera::PERSPECTIVE:
{
// #CONNECTION# all non null coefficients were set to 0.0 in constructor.
const qreal f = 1.0/tan(fieldOfView()/2.0);
projectionMatrix_[0] = f/aspectRatio();
projectionMatrix_[5] = f;
projectionMatrix_[10] = (ZNear + ZFar) / (ZNear - ZFar);
projectionMatrix_[11] = -1.0;
projectionMatrix_[14] = 2.0 * ZNear * ZFar / (ZNear - ZFar);
projectionMatrix_[15] = 0.0;
// same as gluPerspective( 180.0*fieldOfView()/M_PI, aspectRatio(), zNear(), zFar() );
break;
}
case Camera::ORTHOGRAPHIC:
{
GLdouble w, h;
getOrthoWidthHeight(w,h);
projectionMatrix_[0] = 1.0/w;
projectionMatrix_[5] = 1.0/h;
projectionMatrix_[10] = -2.0/(ZFar - ZNear);
projectionMatrix_[11] = 0.0;
projectionMatrix_[14] = -(ZFar + ZNear)/(ZFar - ZNear);
projectionMatrix_[15] = 1.0;
// same as glOrtho( -w, w, -h, h, zNear(), zFar() );
break;
}
}
projectionMatrixIsUpToDate_ = true;
}
/*! Computes the modelView matrix associated with the Camera's position() and orientation().
This matrix converts from the world coordinates system to the Camera coordinates system, so that
coordinates can then be projected on screen using the projection matrix (see computeProjectionMatrix()).
Use getModelViewMatrix() to retrieve this matrix.
\note You must call this method if your Camera is not associated with a QGLViewer and is used for
offscreen computations (using (un)projectedCoordinatesOf() for instance). loadModelViewMatrix()
does it otherwise. */
void Camera::computeModelViewMatrix() const
{
if (modelViewMatrixIsUpToDate_) return;
const Quaternion q = frame()->orientation();
const qreal q00 = 2.0 * q[0] * q[0];
const qreal q11 = 2.0 * q[1] * q[1];
const qreal q22 = 2.0 * q[2] * q[2];
const qreal q01 = 2.0 * q[0] * q[1];
const qreal q02 = 2.0 * q[0] * q[2];
const qreal q03 = 2.0 * q[0] * q[3];
const qreal q12 = 2.0 * q[1] * q[2];
const qreal q13 = 2.0 * q[1] * q[3];
const qreal q23 = 2.0 * q[2] * q[3];
modelViewMatrix_[0] = 1.0 - q11 - q22;
modelViewMatrix_[1] = q01 - q23;
modelViewMatrix_[2] = q02 + q13;
modelViewMatrix_[3] = 0.0;
modelViewMatrix_[4] = q01 + q23;
modelViewMatrix_[5] = 1.0 - q22 - q00;
modelViewMatrix_[6] = q12 - q03;
modelViewMatrix_[7] = 0.0;
modelViewMatrix_[8] = q02 - q13;
modelViewMatrix_[9] = q12 + q03;
modelViewMatrix_[10] = 1.0 - q11 - q00;
modelViewMatrix_[11] = 0.0;
const Vec t = q.inverseRotate(frame()->position());
modelViewMatrix_[12] = -t.x;
modelViewMatrix_[13] = -t.y;
modelViewMatrix_[14] = -t.z;
modelViewMatrix_[15] = 1.0;
modelViewMatrixIsUpToDate_ = true;
}
/*! Loads the OpenGL \c GL_PROJECTION matrix with the Camera projection matrix.
The Camera projection matrix is computed using computeProjectionMatrix().
When \p reset is \c true (default), the method clears the previous projection matrix by calling \c
glLoadIdentity before setting the matrix. Setting \p reset to \c false is useful for \c GL_SELECT
mode, to combine the pushed matrix with a picking matrix. See QGLViewer::beginSelection() for details.
This method is used by QGLViewer::preDraw() (called before user's QGLViewer::draw() method) to
set the \c GL_PROJECTION matrix according to the viewer's QGLViewer::camera() settings.
Use getProjectionMatrix() to retrieve this matrix. Overload this method if you want your Camera to
use an exotic projection matrix. See also loadModelViewMatrix().
\attention \c glMatrixMode is set to \c GL_PROJECTION.
\attention If you use several OpenGL contexts and bypass the Qt main refresh loop, you should call
QGLWidget::makeCurrent() before this method in order to activate the right OpenGL context. */
void Camera::loadProjectionMatrix(bool reset) const
{
// WARNING: makeCurrent must be called by every calling method
glMatrixMode(GL_PROJECTION);
if (reset)
glLoadIdentity();
computeProjectionMatrix();
glMultMatrixd(projectionMatrix_);
}
/*! Loads the OpenGL \c GL_MODELVIEW matrix with the modelView matrix corresponding to the Camera.
Calls computeModelViewMatrix() to compute the Camera's modelView matrix.
This method is used by QGLViewer::preDraw() (called before user's QGLViewer::draw() method) to
set the \c GL_MODELVIEW matrix according to the viewer's QGLViewer::camera() position() and
orientation().
As a result, the vertices used in QGLViewer::draw() can be defined in the so called world
coordinate system. They are multiplied by this matrix to get converted to the Camera coordinate
system, before getting projected using the \c GL_PROJECTION matrix (see loadProjectionMatrix()).
When \p reset is \c true (default), the method loads (overwrites) the \c GL_MODELVIEW matrix. Setting
\p reset to \c false simply calls \c glMultMatrixd (might be useful for some applications).
Overload this method or simply call glLoadMatrixd() at the beginning of QGLViewer::draw() if you
want your Camera to use an exotic modelView matrix. See also loadProjectionMatrix().
getModelViewMatrix() returns the 4x4 modelView matrix.
\attention glMatrixMode is set to \c GL_MODELVIEW
\attention If you use several OpenGL contexts and bypass the Qt main refresh loop, you should call
QGLWidget::makeCurrent() before this method in order to activate the right OpenGL context. */
void Camera::loadModelViewMatrix(bool reset) const
{
// WARNING: makeCurrent must be called by every calling method
glMatrixMode(GL_MODELVIEW);
computeModelViewMatrix();
if (reset)
glLoadMatrixd(modelViewMatrix_);
else
glMultMatrixd(modelViewMatrix_);
}
/*! Same as loadProjectionMatrix() but for a stereo setup.
Only the Camera::PERSPECTIVE type() is supported for stereo mode. See
QGLViewer::setStereoDisplay().
Uses focusDistance(), IODistance(), and physicalScreenWidth() to compute cameras
offset and asymmetric frustums.
When \p leftBuffer is \c true, computes the projection matrix associated to the left eye (right eye
otherwise). See also loadModelViewMatrixStereo().
See the <a href="../examples/stereoViewer.html">stereoViewer</a> and the <a
href="../examples/contribs.html#anaglyph">anaglyph</a> examples for an illustration.
To retrieve this matrix, use a code like:
\code
glMatrixMode(GL_PROJECTION);
glPushMatrix();
loadProjectionMatrixStereo(left_or_right);
glGetDoublev(GL_PROJECTION_MATRIX, m);
glPopMatrix();
\endcode
Note that getProjectionMatrix() always returns the mono-vision matrix.
\attention glMatrixMode is set to \c GL_PROJECTION. */
void Camera::loadProjectionMatrixStereo(bool leftBuffer) const
{
qreal left, right, bottom, top;
qreal screenHalfWidth, halfWidth, side, shift, delta;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
switch (type())
{
case Camera::PERSPECTIVE:
// compute half width of screen,
// corresponding to zero parallax plane to deduce decay of cameras
screenHalfWidth = focusDistance() * tan(horizontalFieldOfView() / 2.0);
shift = screenHalfWidth * IODistance() / physicalScreenWidth();
// should be * current y / y total
// to take into account that the window doesn't cover the entire screen
// compute half width of "view" at znear and the delta corresponding to
// the shifted camera to deduce what to set for asymmetric frustums
halfWidth = zNear() * tan(horizontalFieldOfView() / 2.0);
delta = shift * zNear() / focusDistance();
side = leftBuffer ? -1.0 : 1.0;
left = -halfWidth + side * delta;
right = halfWidth + side * delta;
top = halfWidth / aspectRatio();
bottom = -top;
glFrustum(left, right, bottom, top, zNear(), zFar() );
break;
case Camera::ORTHOGRAPHIC:
qWarning("Camera::setProjectionMatrixStereo: Stereo not available with Ortho mode");
break;
}
}
/*! Same as loadModelViewMatrix() but for a stereo setup.
Only the Camera::PERSPECTIVE type() is supported for stereo mode. See
QGLViewer::setStereoDisplay().
The modelView matrix is almost identical to the mono-vision one. It is simply translated along its
horizontal axis by a value that depends on stereo parameters (see focusDistance(),
IODistance(), and physicalScreenWidth()).
When \p leftBuffer is \c true, computes the modelView matrix associated to the left eye (right eye
otherwise).
loadProjectionMatrixStereo() explains how to retrieve to resulting matrix.
See the <a href="../examples/stereoViewer.html">stereoViewer</a> and the <a
href="../examples/contribs.html#anaglyph">anaglyph</a> examples for an illustration.
\attention glMatrixMode is set to \c GL_MODELVIEW. */
void Camera::loadModelViewMatrixStereo(bool leftBuffer) const
{
// WARNING: makeCurrent must be called by every calling method
glMatrixMode(GL_MODELVIEW);
qreal halfWidth = focusDistance() * tan(horizontalFieldOfView() / 2.0);
qreal shift = halfWidth * IODistance() / physicalScreenWidth(); // * current window width / full screen width
computeModelViewMatrix();
if (leftBuffer)
modelViewMatrix_[12] -= shift;
else
modelViewMatrix_[12] += shift;
glLoadMatrixd(modelViewMatrix_);
}
/*! Fills \p m with the Camera projection matrix values.
Based on computeProjectionMatrix() to make sure the Camera projection matrix is up to date.
This matrix only reflects the Camera's internal parameters and it may differ from the \c
GL_PROJECTION matrix retrieved using \c glGetDoublev(GL_PROJECTION_MATRIX, m). It actually
represents the state of the \c GL_PROJECTION after QGLViewer::preDraw(), at the beginning of
QGLViewer::draw(). If you modified the \c GL_PROJECTION matrix (for instance using
QGLViewer::startScreenCoordinatesSystem()), the two results differ.
The result is an OpenGL 4x4 matrix, which is given in \e column-major order (see \c glMultMatrix
man page for details).
See also getModelViewMatrix() and setFromProjectionMatrix(). */
void Camera::getProjectionMatrix(GLdouble m[16]) const
{
computeProjectionMatrix();
for (unsigned short i=0; i<16; ++i)
m[i] = projectionMatrix_[i];
}
/*! Overloaded getProjectionMatrix(GLdouble m[16]) method using a \c GLfloat array instead. */
void Camera::getProjectionMatrix(GLfloat m[16]) const
{
static GLdouble mat[16];
getProjectionMatrix(mat);
for (unsigned short i=0; i<16; ++i)
m[i] = float(mat[i]);
}
/*! Fills \p m with the Camera modelView matrix values.
First calls computeModelViewMatrix() to define the Camera modelView matrix.
Note that this matrix may \e not be the one you would get from a \c
glGetDoublev(GL_MODELVIEW_MATRIX, m). It actually represents the state of the \c
GL_MODELVIEW after QGLViewer::preDraw(), at the \e beginning of QGLViewer::draw(). It converts from
the world to the Camera coordinate system. As soon as you modify the \c GL_MODELVIEW in your
QGLViewer::draw() method (using glTranslate, glRotate... or similar methods), the two matrices differ.
The result is an OpenGL 4x4 matrix, which is given in \e column-major order (see \c glMultMatrix
man page for details).
See also getProjectionMatrix() and setFromModelViewMatrix(). */
void Camera::getModelViewMatrix(GLdouble m[16]) const
{
// May not be needed, but easier like this.
// Prevents from retrieving matrix in stereo mode -> overwrites shifted value.
computeModelViewMatrix();
for (unsigned short i=0; i<16; ++i)
m[i] = modelViewMatrix_[i];
}
/*! Overloaded getModelViewMatrix(GLdouble m[16]) method using a \c GLfloat array instead. */
void Camera::getModelViewMatrix(GLfloat m[16]) const
{
static GLdouble mat[16];
getModelViewMatrix(mat);
for (unsigned short i=0; i<16; ++i)
m[i] = float(mat[i]);
}
/*! Fills \p m with the product of the ModelView and Projection matrices.
Calls getModelViewMatrix() and getProjectionMatrix() and then fills \p m with the product of these two matrices. */
void Camera::getModelViewProjectionMatrix(GLdouble m[16]) const
{
GLdouble mv[16];
GLdouble proj[16];
getModelViewMatrix(mv);
getProjectionMatrix(proj);
for (unsigned short i=0; i<4; ++i)
{
for (unsigned short j=0; j<4; ++j)
{
qreal sum = 0.0;
for (unsigned short k=0; k<4; ++k)
sum += proj[i+4*k]*mv[k+4*j];
m[i+4*j] = sum;
}
}
}
/*! Overloaded getModelViewProjectionMatrix(GLdouble m[16]) method using a \c GLfloat array instead. */
void Camera::getModelViewProjectionMatrix(GLfloat m[16]) const
{
static GLdouble mat[16];
getModelViewProjectionMatrix(mat);
for (unsigned short i=0; i<16; ++i)
m[i] = float(mat[i]);
}
/*! Sets the sceneRadius() value. Negative values are ignored.
\attention This methods also sets focusDistance() to sceneRadius() / tan(fieldOfView()/2) and
flySpeed() to 1% of sceneRadius(). */
void Camera::setSceneRadius(qreal radius)
{
if (radius <= 0.0)
{
qWarning("Scene radius must be positive - Ignoring value");
return;
}
sceneRadius_ = radius;
projectionMatrixIsUpToDate_ = false;
setFocusDistance(sceneRadius() / tan(fieldOfView()/2.0));
frame()->setFlySpeed(0.01*sceneRadius());
}
/*! Similar to setSceneRadius() and setSceneCenter(), but the scene limits are defined by a (world
axis aligned) bounding box. */
void Camera::setSceneBoundingBox(const Vec& min, const Vec& max)
{
setSceneCenter((min+max)/2.0);
setSceneRadius(0.5*(max-min).norm());
}
/*! Sets the sceneCenter().
\attention This method also sets the pivotPoint() to sceneCenter(). */
void Camera::setSceneCenter(const Vec& center)
{
sceneCenter_ = center;
setPivotPoint(sceneCenter());
projectionMatrixIsUpToDate_ = false;
}
/*! setSceneCenter() to the result of pointUnderPixel(\p pixel).
Returns \c true if a pointUnderPixel() was found and sceneCenter() was actually changed.
See also setPivotPointFromPixel(). See the pointUnderPixel() documentation. */
bool Camera::setSceneCenterFromPixel(const QPoint& pixel)
{
bool found;
Vec point = pointUnderPixel(pixel, found);
if (found)
setSceneCenter(point);
return found;
}
#ifndef DOXYGEN
void Camera::setRevolveAroundPoint(const Vec& point) {
qWarning("setRevolveAroundPoint() is deprecated, use setPivotPoint() instead");
setPivotPoint(point);
}
bool Camera::setRevolveAroundPointFromPixel(const QPoint& pixel) {
qWarning("setRevolveAroundPointFromPixel() is deprecated, use setPivotPointFromPixel() instead");
return setPivotPointFromPixel(pixel);
}
Vec Camera::revolveAroundPoint() const {
qWarning("revolveAroundPoint() is deprecated, use pivotPoint() instead");
return pivotPoint();
}
#endif
/*! Changes the pivotPoint() to \p point (defined in the world coordinate system). */
void Camera::setPivotPoint(const Vec& point)
{
const qreal prevDist = fabs(cameraCoordinatesOf(pivotPoint()).z);
// If frame's RAP is set directly, projectionMatrixIsUpToDate_ should also be
// set to false to ensure proper recomputation of the ORTHO projection matrix.
frame()->setPivotPoint(point);
// orthoCoef_ is used to compensate for changes of the pivotPoint, so that the image does
// not change when the pivotPoint is changed in ORTHOGRAPHIC mode.
const qreal newDist = fabs(cameraCoordinatesOf(pivotPoint()).z);
// Prevents division by zero when rap is set to camera position
if ((prevDist > 1E-9) && (newDist > 1E-9))
orthoCoef_ *= prevDist / newDist;
projectionMatrixIsUpToDate_ = false;
}
/*! The pivotPoint() is set to the point located under \p pixel on screen.
Returns \c true if a pointUnderPixel() was found. If no point was found under \p pixel, the
pivotPoint() is left unchanged.
\p pixel is expressed in Qt format (origin in the upper left corner of the window). See
pointUnderPixel().
See also setSceneCenterFromPixel(). */
bool Camera::setPivotPointFromPixel(const QPoint& pixel)
{
bool found;
Vec point = pointUnderPixel(pixel, found);
if (found)
setPivotPoint(point);
return found;
}
/*! Returns the ratio between pixel and OpenGL units at \p position.
A line of \c n * pixelGLRatio() OpenGL units, located at \p position in the world coordinates
system, will be projected with a length of \c n pixels on screen.
Use this method to scale objects so that they have a constant pixel size on screen. The following
code will draw a 20 pixel line, starting at sceneCenter() and always directed along the screen
vertical direction:
\code
glBegin(GL_LINES);
glVertex3fv(sceneCenter());
glVertex3fv(sceneCenter() + 20 * pixelGLRatio(sceneCenter()) * camera()->upVector());
glEnd();
\endcode */
qreal Camera::pixelGLRatio(const Vec& position) const
{
switch (type())
{
case Camera::PERSPECTIVE :
return 2.0 * fabs((frame()->coordinatesOf(position)).z) * tan(fieldOfView()/2.0) / screenHeight();
case Camera::ORTHOGRAPHIC :
{
GLdouble w, h;
getOrthoWidthHeight(w,h);
return 2.0 * h / screenHeight();
}
}
// Bad compilers complain
return 1.0;
}
/*! Changes the Camera fieldOfView() so that the entire scene (defined by QGLViewer::sceneCenter()
and QGLViewer::sceneRadius()) is visible from the Camera position().
The position() and orientation() of the Camera are not modified and you first have to orientate the
Camera in order to actually see the scene (see lookAt(), showEntireScene() or fitSphere()).
This method is especially useful for \e shadow \e maps computation. Use the Camera positioning
tools (setPosition(), lookAt()) to position a Camera at the light position. Then use this method to
define the fieldOfView() so that the shadow map resolution is optimally used:
\code
// The light camera needs size hints in order to optimize its fieldOfView
lightCamera->setSceneRadius(sceneRadius());
lightCamera->setSceneCenter(sceneCenter());
// Place the light camera.
lightCamera->setPosition(lightFrame->position());
lightCamera->lookAt(sceneCenter());
lightCamera->setFOVToFitScene();
\endcode
See the (soon available) shadowMap contribution example for a practical implementation.
\attention The fieldOfView() is clamped to M_PI/2.0. This happens when the Camera is at a distance
lower than sqrt(2.0) * sceneRadius() from the sceneCenter(). It optimizes the shadow map
resolution, although it may miss some parts of the scene. */
void Camera::setFOVToFitScene()
{
if (distanceToSceneCenter() > sqrt(2.0)*sceneRadius())
setFieldOfView(2.0 * asin(sceneRadius() / distanceToSceneCenter()));
else
setFieldOfView(M_PI / 2.0);
}
/*! Makes the Camera smoothly zoom on the pointUnderPixel() \p pixel.
Nothing happens if no pointUnderPixel() is found. Otherwise a KeyFrameInterpolator is created that
animates the Camera on a one second path that brings the Camera closer to the point under \p pixel.
See also interpolateToFitScene(). */
void Camera::interpolateToZoomOnPixel(const QPoint& pixel)
{
const qreal coef = 0.1;
bool found;
Vec target = pointUnderPixel(pixel, found);
if (!found)
return;
if (interpolationKfi_->interpolationIsStarted())
interpolationKfi_->stopInterpolation();
interpolationKfi_->deletePath();
interpolationKfi_->addKeyFrame(*(frame()));
interpolationKfi_->addKeyFrame(Frame(0.3*frame()->position() + 0.7*target, frame()->orientation()), 0.4);
// Small hack: attach a temporary frame to take advantage of lookAt without modifying frame
static ManipulatedCameraFrame* tempFrame = new ManipulatedCameraFrame();
ManipulatedCameraFrame* const originalFrame = frame();
tempFrame->setPosition(coef*frame()->position() + (1.0-coef)*target);
tempFrame->setOrientation(frame()->orientation());
setFrame(tempFrame);
lookAt(target);
setFrame(originalFrame);
interpolationKfi_->addKeyFrame(*(tempFrame), 1.0);
interpolationKfi_->startInterpolation();
}
/*! Interpolates the Camera on a one second KeyFrameInterpolator path so that the entire scene fits
the screen at the end.
The scene is defined by its sceneCenter() and its sceneRadius(). See showEntireScene().
The orientation() of the Camera is not modified. See also interpolateToZoomOnPixel(). */
void Camera::interpolateToFitScene()
{
if (interpolationKfi_->interpolationIsStarted())
interpolationKfi_->stopInterpolation();
interpolationKfi_->deletePath();
interpolationKfi_->addKeyFrame(*(frame()));
// Small hack: attach a temporary frame to take advantage of lookAt without modifying frame
static ManipulatedCameraFrame* tempFrame = new ManipulatedCameraFrame();
ManipulatedCameraFrame* const originalFrame = frame();
tempFrame->setPosition(frame()->position());
tempFrame->setOrientation(frame()->orientation());
setFrame(tempFrame);
showEntireScene();
setFrame(originalFrame);
interpolationKfi_->addKeyFrame(*(tempFrame));
interpolationKfi_->startInterpolation();
}
/*! Smoothly interpolates the Camera on a KeyFrameInterpolator path so that it goes to \p fr.
\p fr is expressed in world coordinates. \p duration tunes the interpolation speed (default is
1 second).
See also interpolateToFitScene() and interpolateToZoomOnPixel(). */
void Camera::interpolateTo(const Frame& fr, qreal duration)
{
if (interpolationKfi_->interpolationIsStarted())
interpolationKfi_->stopInterpolation();
interpolationKfi_->deletePath();
interpolationKfi_->addKeyFrame(*(frame()));
interpolationKfi_->addKeyFrame(fr, duration);
interpolationKfi_->startInterpolation();
}
/*! Returns the coordinates of the 3D point located at pixel (x,y) on screen.
Calls a \c glReadPixel to get the pixel depth and applies an unprojectedCoordinatesOf() to the
result. \p found indicates whether a point was found or not (i.e. background pixel, result's depth
is zFar() in that case).
\p x and \p y are expressed in pixel units with an origin in the upper left corner. Use
screenHeight() - y to convert to OpenGL standard.
\attention This method assumes that a GL context is available, and that its content was drawn using
the Camera (i.e. using its projection and modelview matrices). This method hence cannot be used for
offscreen Camera computations. Use cameraCoordinatesOf() and worldCoordinatesOf() to perform
similar operations in that case.
\note The precision of the z-Buffer highly depends on how the zNear() and zFar() values are fitted
to your scene. Loose boundaries will result in imprecision along the viewing direction. */
Vec Camera::pointUnderPixel(const QPoint& pixel, bool& found) const
{
float depth;
// Qt uses upper corner for its origin while GL uses the lower corner.
glReadPixels(pixel.x(), screenHeight()-1-pixel.y(), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth);
found = depth < 1.0;
Vec point(pixel.x(), pixel.y(), depth);
point = unprojectedCoordinatesOf(point);
return point;
}
/*! Moves the Camera so that the entire scene is visible.
Simply calls fitSphere() on a sphere defined by sceneCenter() and sceneRadius().
You will typically use this method in QGLViewer::init() after you defined a new sceneRadius(). */
void Camera::showEntireScene()
{
fitSphere(sceneCenter(), sceneRadius());
}
/*! Moves the Camera so that its sceneCenter() is projected on the center of the window. The
orientation() and fieldOfView() are unchanged.
Simply projects the current position on a line passing through sceneCenter(). See also
showEntireScene().*/
void Camera::centerScene()
{
frame()->projectOnLine(sceneCenter(), viewDirection());
}
/*! Sets the Camera orientation(), so that it looks at point \p target (defined in the world
coordinate system).
The Camera position() is not modified. Simply setViewDirection().
See also setUpVector(), setOrientation(), showEntireScene(), fitSphere() and fitBoundingBox(). */
void Camera::lookAt(const Vec& target)
{
setViewDirection(target - position());
}
/*! Moves the Camera so that the sphere defined by (\p center, \p radius) is visible and fits in the frustum.
The Camera is simply translated to center the sphere in the screen and make it fit the frustum. Its
orientation() and its fieldOfView() are unchanged.
You should therefore orientate the Camera before you call this method. See lookAt(),
setOrientation() and setUpVector(). */
void Camera::fitSphere(const Vec& center, qreal radius)
{
qreal distance = 0.0;
switch (type())
{
case Camera::PERSPECTIVE :
{
const qreal yview = radius / sin(fieldOfView() / 2.0);
const qreal xview = radius / sin(horizontalFieldOfView() / 2.0);
distance = qMax(xview, yview);
break;
}
case Camera::ORTHOGRAPHIC :
{
distance = ((center-pivotPoint()) * viewDirection()) + (radius / orthoCoef_);
break;
}
}
Vec newPos(center - distance * viewDirection());
frame()->setPositionWithConstraint(newPos);
}
/*! Moves the Camera so that the (world axis aligned) bounding box (\p min, \p max) is entirely
visible, using fitSphere(). */
void Camera::fitBoundingBox(const Vec& min, const Vec& max)
{
qreal diameter = qMax(fabs(max[1]-min[1]), fabs(max[0]-min[0]));
diameter = qMax(fabs(max[2]-min[2]), diameter);
fitSphere(0.5*(min+max), 0.5*diameter);
}
/*! Moves the Camera so that the rectangular screen region defined by \p rectangle (pixel units,
with origin in the upper left corner) fits the screen.
The Camera is translated (its orientation() is unchanged) so that \p rectangle is entirely
visible. Since the pixel coordinates only define a \e frustum in 3D, it's the intersection of this
frustum with a plane (orthogonal to the viewDirection() and passing through the sceneCenter())
that is used to define the 3D rectangle that is eventually fitted. */
void Camera::fitScreenRegion(const QRect& rectangle)
{
const Vec vd = viewDirection();
const qreal distToPlane = distanceToSceneCenter();
const QPoint center = rectangle.center();
Vec orig, dir;
convertClickToLine( center, orig, dir );
Vec newCenter = orig + distToPlane / (dir*vd) * dir;
convertClickToLine( QPoint(rectangle.x(), center.y()), orig, dir );
const Vec pointX = orig + distToPlane / (dir*vd) * dir;
convertClickToLine( QPoint(center.x(), rectangle.y()), orig, dir );
const Vec pointY = orig + distToPlane / (dir*vd) * dir;
qreal distance = 0.0;
switch (type())
{
case Camera::PERSPECTIVE :
{
const qreal distX = (pointX-newCenter).norm() / sin(horizontalFieldOfView()/2.0);
const qreal distY = (pointY-newCenter).norm() / sin(fieldOfView()/2.0);
distance = qMax(distX, distY);
break;
}
case Camera::ORTHOGRAPHIC :
{
const qreal dist = ((newCenter-pivotPoint()) * vd);
//#CONNECTION# getOrthoWidthHeight
const qreal distX = (pointX-newCenter).norm() / orthoCoef_ / ((aspectRatio() < 1.0) ? 1.0 : aspectRatio());
const qreal distY = (pointY-newCenter).norm() / orthoCoef_ / ((aspectRatio() < 1.0) ? 1.0/aspectRatio() : 1.0);
distance = dist + qMax(distX, distY);
break;
}
}
Vec newPos(newCenter - distance * vd);
frame()->setPositionWithConstraint(newPos);
}
/*! Rotates the Camera so that its upVector() becomes \p up (defined in the world coordinate
system).
The Camera is rotated around an axis orthogonal to \p up and to the current upVector() direction.
Use this method in order to define the Camera horizontal plane.
When \p noMove is set to \c false, the orientation modification is compensated by a translation, so
that the pivotPoint() stays projected at the same position on screen. This is especially
useful when the Camera is used as an observer of the scene (default mouse binding).
When \p noMove is \c true (default), the Camera position() is left unchanged, which is an intuitive
behavior when the Camera is in a walkthrough fly mode (see the QGLViewer::MOVE_FORWARD and
QGLViewer::MOVE_BACKWARD QGLViewer::MouseAction).
The frame()'s ManipulatedCameraFrame::sceneUpVector() is set accordingly.
See also setViewDirection(), lookAt() and setOrientation(). */
void Camera::setUpVector(const Vec& up, bool noMove)
{
Quaternion q(Vec(0.0, 1.0, 0.0), frame()->transformOf(up));
if (!noMove)
frame()->setPosition(pivotPoint() - (frame()->orientation()*q).rotate(frame()->coordinatesOf(pivotPoint())));
frame()->rotate(q);
// Useful in fly mode to keep the horizontal direction.
frame()->updateSceneUpVector();
}
/*! Sets the orientation() of the Camera using polar coordinates.
\p theta rotates the Camera around its Y axis, and \e then \p phi rotates it around its X axis.
The polar coordinates are defined in the world coordinates system: \p theta = \p phi = 0 means
that the Camera is directed towards the world Z axis. Both angles are expressed in radians.
See also setUpVector(). The position() of the Camera is unchanged, you may want to call showEntireScene()
after this method to move the Camera.
This method can be useful to create Quicktime VR panoramic sequences, see the
QGLViewer::saveSnapshot() documentation for details. */
void Camera::setOrientation(qreal theta, qreal phi)
{
Vec axis(0.0, 1.0, 0.0);
const Quaternion rot1(axis, theta);
axis = Vec(-cos(theta), 0.0, sin(theta));
const Quaternion rot2(axis, phi);
setOrientation(rot1 * rot2);
}
/*! Sets the Camera orientation(), defined in the world coordinate system. */
void Camera::setOrientation(const Quaternion& q)
{
frame()->setOrientation(q);
frame()->updateSceneUpVector();
}
/*! Rotates the Camera so that its viewDirection() is \p direction (defined in the world coordinate
system).
The Camera position() is not modified. The Camera is rotated so that the horizon (defined by its
upVector()) is preserved. See also lookAt() and setUpVector(). */
void Camera::setViewDirection(const Vec& direction)
{
if (direction.squaredNorm() < 1E-10)
return;
Vec xAxis = direction ^ upVector();
if (xAxis.squaredNorm() < 1E-10)
{
// target is aligned with upVector, this means a rotation around X axis
// X axis is then unchanged, let's keep it !
xAxis = frame()->inverseTransformOf(Vec(1.0, 0.0, 0.0));
}
Quaternion q;
q.setFromRotatedBasis(xAxis, xAxis^direction, -direction);
frame()->setOrientationWithConstraint(q);
}
// Compute a 3 by 3 determinant.
static qreal det(qreal m00,qreal m01,qreal m02,
qreal m10,qreal m11,qreal m12,
qreal m20,qreal m21,qreal m22)
{
return m00*m11*m22 + m01*m12*m20 + m02*m10*m21 - m20*m11*m02 - m10*m01*m22 - m00*m21*m12;
}
// Computes the index of element [i][j] in a \c qreal matrix[3][4].
static inline unsigned int ind(unsigned int i, unsigned int j)
{
return (i*4+j);
}
/*! Returns the Camera position (the eye), defined in the world coordinate system.
Use setPosition() to set the Camera position. Other convenient methods are showEntireScene() or
fitSphere(). Actually returns \c frame()->position().
This position corresponds to the projection center of a Camera::PERSPECTIVE Camera. It is not
located in the image plane, which is at a zNear() distance ahead. */
Vec Camera::position() const { return frame()->position(); }
/*! Returns the normalized up vector of the Camera, defined in the world coordinate system.
Set using setUpVector() or setOrientation(). It is orthogonal to viewDirection() and to
rightVector().
It corresponds to the Y axis of the associated frame() (actually returns
frame()->inverseTransformOf(Vec(0.0, 1.0, 0.0)) ). */
Vec Camera::upVector() const
{
return frame()->inverseTransformOf(Vec(0.0, 1.0, 0.0));
}
/*! Returns the normalized view direction of the Camera, defined in the world coordinate system.
Change this value using setViewDirection(), lookAt() or setOrientation(). It is orthogonal to
upVector() and to rightVector().
This corresponds to the negative Z axis of the frame() ( frame()->inverseTransformOf(Vec(0.0,
0.0, -1.0)) ). */
Vec Camera::viewDirection() const { return frame()->inverseTransformOf(Vec(0.0, 0.0, -1.0)); }
/*! Returns the normalized right vector of the Camera, defined in the world coordinate system.
This vector lies in the Camera horizontal plane, directed along the X axis (orthogonal to
upVector() and to viewDirection()). Set using setUpVector(), lookAt() or setOrientation().
Simply returns frame()->inverseTransformOf(Vec(1.0, 0.0, 0.0)). */
Vec Camera::rightVector() const
{
return frame()->inverseTransformOf(Vec(1.0, 0.0, 0.0));
}
/*! Returns the Camera orientation, defined in the world coordinate system.
Actually returns \c frame()->orientation(). Use setOrientation(), setUpVector() or lookAt() to
set the Camera orientation. */
Quaternion Camera::orientation() const { return frame()->orientation(); }
/*! Sets the Camera position() (the eye), defined in the world coordinate system. */
void Camera::setPosition(const Vec& pos) { frame()->setPosition(pos); }
/*! Returns the Camera frame coordinates of a point \p src defined in world coordinates.
worldCoordinatesOf() performs the inverse transformation.
Note that the point coordinates are simply converted in a different coordinate system. They are
not projected on screen. Use projectedCoordinatesOf() for that. */
Vec Camera::cameraCoordinatesOf(const Vec& src) const { return frame()->coordinatesOf(src); }
/*! Returns the world coordinates of the point whose position \p src is defined in the Camera
coordinate system.
cameraCoordinatesOf() performs the inverse transformation. */
Vec Camera::worldCoordinatesOf(const Vec& src) const { return frame()->inverseCoordinatesOf(src); }
/*! Returns the fly speed of the Camera.
Simply returns frame()->flySpeed(). See the ManipulatedCameraFrame::flySpeed() documentation.
This value is only meaningful when the MouseAction bindings is QGLViewer::MOVE_FORWARD or
QGLViewer::MOVE_BACKWARD.
Set to 1% of the sceneRadius() by setSceneRadius(). See also setFlySpeed(). */
qreal Camera::flySpeed() const { return frame()->flySpeed(); }
/*! Sets the Camera flySpeed().
\attention This value is modified by setSceneRadius(). */
void Camera::setFlySpeed(qreal speed) { frame()->setFlySpeed(speed); }
/*! The point the Camera pivots around with the QGLViewer::ROTATE mouse binding. Defined in world coordinate system.
Default value is the sceneCenter().
\attention setSceneCenter() changes this value. */
Vec Camera::pivotPoint() const { return frame()->pivotPoint(); }
/*! Sets the Camera's position() and orientation() from an OpenGL ModelView matrix.
This enables a Camera initialisation from an other OpenGL application. \p modelView is a 16 GLdouble
vector representing a valid OpenGL ModelView matrix, such as one can get using:
\code
GLdouble mvm[16];
glGetDoublev(GL_MODELVIEW_MATRIX, mvm);
myCamera->setFromModelViewMatrix(mvm);
\endcode
After this method has been called, getModelViewMatrix() returns a matrix equivalent to \p
modelView.
Only the orientation() and position() of the Camera are modified.
\note If you defined your matrix as \c GLdouble \c mvm[4][4], pass \c &(mvm[0][0]) as a
parameter. */
void Camera::setFromModelViewMatrix(const GLdouble* const modelViewMatrix)
{
// Get upper left (rotation) matrix
qreal upperLeft[3][3];
for (int i=0; i<3; ++i)
for (int j=0; j<3; ++j)
upperLeft[i][j] = modelViewMatrix[i*4+j];
// Transform upperLeft into the associated Quaternion
Quaternion q;
q.setFromRotationMatrix(upperLeft);
setOrientation(q);
setPosition(-q.rotate(Vec(modelViewMatrix[12], modelViewMatrix[13], modelViewMatrix[14])));
}
/*! Defines the Camera position(), orientation() and fieldOfView() from a projection matrix.
\p matrix has to be given in the format used by vision algorithm. It has 3 lines and 4 columns. It
transforms a point from the world homogeneous coordinate system (4 coordinates: \c sx, \c sy, \c sz
and \c s) into a point in the screen homogeneous coordinate system (3 coordinates: \c sx, \c sy,
and \c s, where \c x and \c y are the pixel coordinates on the screen).
Its three lines correspond to the homogeneous coordinates of the normals to the planes x=0, y=0 and
z=0, defined in the Camera coordinate system.
The elements of the matrix are ordered in line major order: you can call \c
setFromProjectionMatrix(&(matrix[0][0])) if you defined your matrix as a \c qreal \c matrix[3][4].
\attention Passing the result of getProjectionMatrix() or getModelViewMatrix() to this method is
not possible (purposefully incompatible matrix dimensions). \p matrix is more likely to be the
product of these two matrices, without the last line.
Use setFromModelViewMatrix() to set position() and orientation() from a \c GL_MODELVIEW matrix.
fieldOfView() can also be retrieved from a \e perspective \c GL_PROJECTION matrix using 2.0 *
atan(1.0/projectionMatrix[5]).
This code was written by Sylvain Paris. */
void Camera::setFromProjectionMatrix(const qreal matrix[12])
{
// The 3 lines of the matrix are the normals to the planes x=0, y=0, z=0
// in the camera CS. As we normalize them, we do not need the 4th coordinate.
Vec line_0(matrix[ind(0,0)],matrix[ind(0,1)],matrix[ind(0,2)]);
Vec line_1(matrix[ind(1,0)],matrix[ind(1,1)],matrix[ind(1,2)]);
Vec line_2(matrix[ind(2,0)],matrix[ind(2,1)],matrix[ind(2,2)]);
line_0.normalize();
line_1.normalize();
line_2.normalize();
// The camera position is at (0,0,0) in the camera CS so it is the
// intersection of the 3 planes. It can be seen as the kernel
// of the 3x4 projection matrix. We calculate it through 4 dimensional
// vectorial product. We go directly into 3D that is to say we directly
// divide the first 3 coordinates by the 4th one.
// We derive the 4 dimensional vectorial product formula from the
// computation of a 4x4 determinant that is developped according to
// its 4th column. This implies some 3x3 determinants.
const Vec cam_pos = Vec(det(matrix[ind(0,1)],matrix[ind(0,2)],matrix[ind(0,3)],
matrix[ind(1,1)],matrix[ind(1,2)],matrix[ind(1,3)],
matrix[ind(2,1)],matrix[ind(2,2)],matrix[ind(2,3)]),
-det(matrix[ind(0,0)],matrix[ind(0,2)],matrix[ind(0,3)],
matrix[ind(1,0)],matrix[ind(1,2)],matrix[ind(1,3)],
matrix[ind(2,0)],matrix[ind(2,2)],matrix[ind(2,3)]),
det(matrix[ind(0,0)],matrix[ind(0,1)],matrix[ind(0,3)],
matrix[ind(1,0)],matrix[ind(1,1)],matrix[ind(1,3)],
matrix[ind(2,0)],matrix[ind(2,1)],matrix[ind(2,3)])) /
(-det(matrix[ind(0,0)],matrix[ind(0,1)],matrix[ind(0,2)],
matrix[ind(1,0)],matrix[ind(1,1)],matrix[ind(1,2)],
matrix[ind(2,0)],matrix[ind(2,1)],matrix[ind(2,2)]));
// We compute the rotation matrix column by column.
// GL Z axis is front facing.
Vec column_2 = -line_2;
// X-axis is almost like line_0 but should be orthogonal to the Z axis.
Vec column_0 = ((column_2^line_0)^column_2);
column_0.normalize();
// Y-axis is almost like line_1 but should be orthogonal to the Z axis.
// Moreover line_1 is downward oriented as the screen CS.
Vec column_1 = -((column_2^line_1)^column_2);
column_1.normalize();
qreal rot[3][3];
rot[0][0] = column_0[0];
rot[1][0] = column_0[1];
rot[2][0] = column_0[2];
rot[0][1] = column_1[0];
rot[1][1] = column_1[1];
rot[2][1] = column_1[2];
rot[0][2] = column_2[0];
rot[1][2] = column_2[1];
rot[2][2] = column_2[2];
// We compute the field of view
// line_1^column_0 -> vector of intersection line between
// y_screen=0 and x_camera=0 plane.
// column_2*(...) -> cos of the angle between Z vector et y_screen=0 plane
// * 2 -> field of view = 2 * half angle
// We need some intermediate values.
Vec dummy = line_1^column_0;
dummy.normalize();
qreal fov = acos(column_2*dummy) * 2.0;
// We set the camera.
Quaternion q;
q.setFromRotationMatrix(rot);
setOrientation(q);
setPosition(cam_pos);
setFieldOfView(fov);
}
/*
// persp : projectionMatrix_[0] = f/aspectRatio();
void Camera::setFromProjectionMatrix(const GLdouble* projectionMatrix)
{
QString message;
if ((fabs(projectionMatrix[1]) > 1E-3) ||
(fabs(projectionMatrix[2]) > 1E-3) ||
(fabs(projectionMatrix[3]) > 1E-3) ||
(fabs(projectionMatrix[4]) > 1E-3) ||
(fabs(projectionMatrix[6]) > 1E-3) ||
(fabs(projectionMatrix[7]) > 1E-3) ||
(fabs(projectionMatrix[8]) > 1E-3) ||
(fabs(projectionMatrix[9]) > 1E-3))
message = "Non null coefficient in projection matrix - Aborting";
else
if ((fabs(projectionMatrix[11]+1.0) < 1E-5) && (fabs(projectionMatrix[15]) < 1E-5))
{
if (projectionMatrix[5] < 1E-4)
message="Negative field of view in Camera::setFromProjectionMatrix";
else
setType(Camera::PERSPECTIVE);
}
else
if ((fabs(projectionMatrix[11]) < 1E-5) && (fabs(projectionMatrix[15]-1.0) < 1E-5))
setType(Camera::ORTHOGRAPHIC);
else
message = "Unable to determine camera type in setFromProjectionMatrix - Aborting";
if (!message.isEmpty())
{
qWarning(message);
return;
}
switch (type())
{
case Camera::PERSPECTIVE:
{
setFieldOfView(2.0 * atan(1.0/projectionMatrix[5]));
const qreal far = projectionMatrix[14] / (2.0 * (1.0 + projectionMatrix[10]));
const qreal near = (projectionMatrix[10]+1.0) / (projectionMatrix[10]-1.0) * far;
setSceneRadius((far-near)/2.0);
setSceneCenter(position() + (near + sceneRadius())*viewDirection());
break;
}
case Camera::ORTHOGRAPHIC:
{
GLdouble w, h;
getOrthoWidthHeight(w,h);
projectionMatrix_[0] = 1.0/w;
projectionMatrix_[5] = 1.0/h;
projectionMatrix_[10] = -2.0/(ZFar - ZNear);
projectionMatrix_[11] = 0.0;
projectionMatrix_[14] = -(ZFar + ZNear)/(ZFar - ZNear);
projectionMatrix_[15] = 1.0;
// same as glOrtho( -w, w, -h, h, zNear(), zFar() );
break;
}
}
}
*/
///////////////////////// Camera to world transform ///////////////////////
/*! Same as cameraCoordinatesOf(), but with \c qreal[3] parameters (\p src and \p res may be identical pointers). */
void Camera::getCameraCoordinatesOf(const qreal src[3], qreal res[3]) const
{
Vec r = cameraCoordinatesOf(Vec(src));
for (int i=0; i<3; ++i)
res[i] = r[i];
}
/*! Same as worldCoordinatesOf(), but with \c qreal[3] parameters (\p src and \p res may be identical pointers). */
void Camera::getWorldCoordinatesOf(const qreal src[3], qreal res[3]) const
{
Vec r = worldCoordinatesOf(Vec(src));
for (int i=0; i<3; ++i)
res[i] = r[i];
}
/*! Fills \p viewport with the Camera OpenGL viewport.
This method is mainly used in conjunction with \c gluProject, which requires such a viewport.
Returned values are (0, screenHeight(), screenWidth(), - screenHeight()), so that the origin is
located in the \e upper left corner of the window (Qt style coordinate system). */
void Camera::getViewport(GLint viewport[4]) const
{
viewport[0] = 0;
viewport[1] = screenHeight();
viewport[2] = screenWidth();
viewport[3] = -screenHeight();
}
/*! Returns the screen projected coordinates of a point \p src defined in the \p frame coordinate
system.
When \p frame in \c NULL (default), \p src is expressed in the world coordinate system.
The x and y coordinates of the returned Vec are expressed in pixel, (0,0) being the \e upper left
corner of the window. The z coordinate ranges between 0.0 (near plane) and 1.0 (excluded, far
plane). See the \c gluProject man page for details.
unprojectedCoordinatesOf() performs the inverse transformation.
See the <a href="../examples/screenCoordSystem.html">screenCoordSystem example</a>.
This method only uses the intrinsic Camera parameters (see getModelViewMatrix(),
getProjectionMatrix() and getViewport()) and is completely independent of the OpenGL \c
GL_MODELVIEW, \c GL_PROJECTION and viewport matrices. You can hence define a virtual Camera and use
this method to compute projections out of a classical rendering context.
\attention However, if your Camera is not attached to a QGLViewer (used for offscreen computations
for instance), make sure the Camera matrices are updated before calling this method. Call
computeModelViewMatrix() and computeProjectionMatrix() to do so.
If you call this method several times with no change in the matrices, consider precomputing the
projection times modelview matrix to save computation time if required (\c P x \c M in the \c
gluProject man page).
Here is the code corresponding to what this method does (kindly submitted by Robert W. Kuhn) :
\code
Vec project(Vec point)
{
GLint Viewport[4];
GLdouble Projection[16], Modelview[16];
GLdouble matrix[16];
// Precomputation begin
glGetIntegerv(GL_VIEWPORT , Viewport);
glGetDoublev (GL_MODELVIEW_MATRIX , Modelview);
glGetDoublev (GL_PROJECTION_MATRIX, Projection);
for (unsigned short m=0; m<4; ++m)
{
for (unsigned short l=0; l<4; ++l)
{
qreal sum = 0.0;
for (unsigned short k=0; k<4; ++k)
sum += Projection[l+4*k]*Modelview[k+4*m];
matrix[l+4*m] = sum;
}
}
// Precomputation end
GLdouble v[4], vs[4];
v[0]=point[0]; v[1]=point[1]; v[2]=point[2]; v[3]=1.0;
vs[0]=matrix[0 ]*v[0] + matrix[4 ]*v[1] + matrix[8 ]*v[2] + matrix[12 ]*v[3];
vs[1]=matrix[1 ]*v[0] + matrix[5 ]*v[1] + matrix[9 ]*v[2] + matrix[13 ]*v[3];
vs[2]=matrix[2 ]*v[0] + matrix[6 ]*v[1] + matrix[10]*v[2] + matrix[14 ]*v[3];
vs[3]=matrix[3 ]*v[0] + matrix[7 ]*v[1] + matrix[11]*v[2] + matrix[15 ]*v[3];
vs[0] /= vs[3];
vs[1] /= vs[3];
vs[2] /= vs[3];
vs[0] = vs[0] * 0.5 + 0.5;
vs[1] = vs[1] * 0.5 + 0.5;
vs[2] = vs[2] * 0.5 + 0.5;
vs[0] = vs[0] * Viewport[2] + Viewport[0];
vs[1] = vs[1] * Viewport[3] + Viewport[1];
return Vec(vs[0], Viewport[3]-vs[1], vs[2]);
}
\endcode
*/
Vec Camera::projectedCoordinatesOf(const Vec& src, const Frame* frame) const
{
GLdouble x,y,z;
static GLint viewport[4];
getViewport(viewport);
if (frame)
{
const Vec tmp = frame->inverseCoordinatesOf(src);
gluProject(tmp.x,tmp.y,tmp.z, modelViewMatrix_, projectionMatrix_, viewport, &x,&y,&z);
}
else
gluProject(src.x,src.y,src.z, modelViewMatrix_, projectionMatrix_, viewport, &x,&y,&z);
return Vec(x,y,z);
}
/*! Returns the world unprojected coordinates of a point \p src defined in the screen coordinate
system.
The \p src.x and \p src.y input values are expressed in pixels, (0,0) being the \e upper left corner
of the window. \p src.z is a depth value ranging in [0..1[ (respectively corresponding to the near
and far planes). Note that src.z is \e not a linear interpolation between zNear and zFar.
/code
src.z = zFar() / (zFar() - zNear()) * (1.0 - zNear() / z);
/endcode
Where z is the distance from the point you project to the camera, along the viewDirection().
See the \c gluUnProject man page for details.
The result is expressed in the \p frame coordinate system. When \p frame is \c NULL (default), the
result is expressed in the world coordinates system. The possible \p frame Frame::referenceFrame()
are taken into account.
projectedCoordinatesOf() performs the inverse transformation.
This method only uses the intrinsic Camera parameters (see getModelViewMatrix(),
getProjectionMatrix() and getViewport()) and is completely independent of the OpenGL \c
GL_MODELVIEW, \c GL_PROJECTION and viewport matrices. You can hence define a virtual Camera and use
this method to compute un-projections out of a classical rendering context.
\attention However, if your Camera is not attached to a QGLViewer (used for offscreen computations
for instance), make sure the Camera matrices are updated before calling this method (use
computeModelViewMatrix(), computeProjectionMatrix()). See also setScreenWidthAndHeight().
This method is not computationally optimized. If you call it several times with no change in the
matrices, you should buffer the entire inverse projection matrix (modelview, projection and then
viewport) to speed-up the queries. See the \c gluUnProject man page for details. */
Vec Camera::unprojectedCoordinatesOf(const Vec& src, const Frame* frame) const
{
GLdouble x,y,z;
static GLint viewport[4];
getViewport(viewport);
gluUnProject(src.x,src.y,src.z, modelViewMatrix_, projectionMatrix_, viewport, &x,&y,&z);
if (frame)
return frame->coordinatesOf(Vec(x,y,z));
else
return Vec(x,y,z);
}
/*! Same as projectedCoordinatesOf(), but with \c qreal parameters (\p src and \p res can be identical pointers). */
void Camera::getProjectedCoordinatesOf(const qreal src[3], qreal res[3], const Frame* frame) const
{
Vec r = projectedCoordinatesOf(Vec(src), frame);
for (int i=0; i<3; ++i)
res[i] = r[i];
}
/*! Same as unprojectedCoordinatesOf(), but with \c qreal parameters (\p src and \p res can be identical pointers). */
void Camera::getUnprojectedCoordinatesOf(const qreal src[3], qreal res[3], const Frame* frame) const
{
Vec r = unprojectedCoordinatesOf(Vec(src), frame);
for (int i=0; i<3; ++i)
res[i] = r[i];
}
///////////////////////////////////// KFI /////////////////////////////////////////
/*! Returns the KeyFrameInterpolator that defines the Camera path number \p i.
If path \p i is not defined for this index, the method returns a \c NULL pointer. */
KeyFrameInterpolator* Camera::keyFrameInterpolator(unsigned int i) const
{
if (kfi_.contains(i))
return kfi_[i];
else
return NULL;
}
/*! Sets the KeyFrameInterpolator that defines the Camera path of index \p i.
The previous keyFrameInterpolator() is lost and should be deleted by the calling method if
needed.
The KeyFrameInterpolator::interpolated() signal of \p kfi probably needs to be connected to the
Camera's associated QGLViewer::update() slot, so that when the Camera position is interpolated
using \p kfi, every interpolation step updates the display:
\code
myViewer.camera()->deletePath(3);
myViewer.camera()->setKeyFrameInterpolator(3, myKeyFrameInterpolator);
connect(myKeyFrameInterpolator, SIGNAL(interpolated()), myViewer, SLOT(update());
\endcode
\note These connections are done automatically when a Camera is attached to a QGLViewer, or when a
new KeyFrameInterpolator is defined using the QGLViewer::addKeyFrameKeyboardModifiers() and
QGLViewer::pathKey() (default is Alt+F[1-12]). See the <a href="../keyboard.html">keyboard page</a>
for details. */
void Camera::setKeyFrameInterpolator(unsigned int i, KeyFrameInterpolator* const kfi)
{
if (kfi)
kfi_[i] = kfi;
else
kfi_.remove(i);
}
/*! Adds the current Camera position() and orientation() as a keyFrame to the path number \p i.
This method can also be used if you simply want to save a Camera point of view (a path made of a
single keyFrame). Use playPath() to make the Camera play the keyFrame path (resp. restore
the point of view). Use deletePath() to clear the path.
The default keyboard shortcut for this method is Alt+F[1-12]. Set QGLViewer::pathKey() and
QGLViewer::addKeyFrameKeyboardModifiers().
If you use directly this method and the keyFrameInterpolator(i) does not exist, a new one is
created. Its KeyFrameInterpolator::interpolated() signal should then be connected to the
QGLViewer::update() slot (see setKeyFrameInterpolator()). */
void Camera::addKeyFrameToPath(unsigned int i)
{
if (!kfi_.contains(i))
setKeyFrameInterpolator(i, new KeyFrameInterpolator(frame()));
kfi_[i]->addKeyFrame(*(frame()));
}
/*! Makes the Camera follow the path of keyFrameInterpolator() number \p i.
If the interpolation is started, it stops it instead.
This method silently ignores undefined (empty) paths (see keyFrameInterpolator()).
The default keyboard shortcut for this method is F[1-12]. Set QGLViewer::pathKey() and
QGLViewer::playPathKeyboardModifiers(). */
void Camera::playPath(unsigned int i)
{
if (kfi_.contains(i)) {
if (kfi_[i]->interpolationIsStarted())
kfi_[i]->stopInterpolation();
else
kfi_[i]->startInterpolation();
}
}
/*! Resets the path of the keyFrameInterpolator() number \p i.
If this path is \e not being played (see playPath() and
KeyFrameInterpolator::interpolationIsStarted()), resets it to its starting position (see
KeyFrameInterpolator::resetInterpolation()). If the path is played, simply stops interpolation. */
void Camera::resetPath(unsigned int i)
{
if (kfi_.contains(i)) {
if ((kfi_[i]->interpolationIsStarted()))
kfi_[i]->stopInterpolation();
else
{
kfi_[i]->resetInterpolation();
kfi_[i]->interpolateAtTime(kfi_[i]->interpolationTime());
}
}
}
/*! Deletes the keyFrameInterpolator() of index \p i.
Disconnect the keyFrameInterpolator() KeyFrameInterpolator::interpolated() signal before deleting the
keyFrameInterpolator() if needed:
\code
disconnect(camera()->keyFrameInterpolator(i), SIGNAL(interpolated()), this, SLOT(update()));
camera()->deletePath(i);
\endcode */
void Camera::deletePath(unsigned int i)
{
if (kfi_.contains(i))
{
kfi_[i]->stopInterpolation();
delete kfi_[i];
kfi_.remove(i);
}
}
/*! Draws all the Camera paths defined by the keyFrameInterpolator().
Simply calls KeyFrameInterpolator::drawPath() for all the defined paths. The path color is the
current \c glColor().
\attention The OpenGL state is modified by this method: see KeyFrameInterpolator::drawPath(). */
void Camera::drawAllPaths()
{
for (QMap<unsigned int, KeyFrameInterpolator*>::ConstIterator it = kfi_.begin(), end=kfi_.end(); it != end; ++it)
(it.value())->drawPath(3, 5, sceneRadius());
}
////////////////////////////////////////////////////////////////////////////////
/*! Returns an XML \c QDomElement that represents the Camera.
\p name is the name of the QDomElement tag. \p doc is the \c QDomDocument factory used to create
QDomElement.
Concatenates the Camera parameters, the ManipulatedCameraFrame::domElement() and the paths'
KeyFrameInterpolator::domElement().
Use initFromDOMElement() to restore the Camera state from the resulting \c QDomElement.
If you want to save the Camera state in a file, use:
\code
QDomDocument document("myCamera");
doc.appendChild( myCamera->domElement("Camera", document) );
QFile f("myCamera.xml");
if (f.open(IO_WriteOnly))
{
QTextStream out(&f);
document.save(out, 2);
}
\endcode
Note that the QGLViewer::camera() is automatically saved by QGLViewer::saveStateToFile() when a
QGLViewer is closed. Use QGLViewer::restoreStateFromFile() to restore it back. */
QDomElement Camera::domElement(const QString& name, QDomDocument& document) const
{
QDomElement de = document.createElement(name);
QDomElement paramNode = document.createElement("Parameters");
paramNode.setAttribute("fieldOfView", QString::number(fieldOfView()));
paramNode.setAttribute("zNearCoefficient", QString::number(zNearCoefficient()));
paramNode.setAttribute("zClippingCoefficient", QString::number(zClippingCoefficient()));
paramNode.setAttribute("orthoCoef", QString::number(orthoCoef_));
paramNode.setAttribute("sceneRadius", QString::number(sceneRadius()));
paramNode.appendChild(sceneCenter().domElement("SceneCenter", document));
switch (type())
{
case Camera::PERSPECTIVE : paramNode.setAttribute("Type", "PERSPECTIVE"); break;
case Camera::ORTHOGRAPHIC : paramNode.setAttribute("Type", "ORTHOGRAPHIC"); break;
}
de.appendChild(paramNode);
QDomElement stereoNode = document.createElement("Stereo");
stereoNode.setAttribute("IODist", QString::number(IODistance()));
stereoNode.setAttribute("focusDistance", QString::number(focusDistance()));
stereoNode.setAttribute("physScreenWidth", QString::number(physicalScreenWidth()));
de.appendChild(stereoNode);
de.appendChild(frame()->domElement("ManipulatedCameraFrame", document));
// KeyFrame paths
for (QMap<unsigned int, KeyFrameInterpolator*>::ConstIterator it = kfi_.begin(), end=kfi_.end(); it != end; ++it)
{
QDomElement kfNode = (it.value())->domElement("KeyFrameInterpolator", document);
kfNode.setAttribute("index", QString::number(it.key()));
de.appendChild(kfNode);
}
return de;
}
/*! Restores the Camera state from a \c QDomElement created by domElement().
Use the following code to retrieve a Camera state from a file created using domElement():
\code
// Load DOM from file
QDomDocument document;
QFile f("myCamera.xml");
if (f.open(IO_ReadOnly))
{
document.setContent(&f);
f.close();
}
// Parse the DOM tree
QDomElement main = document.documentElement();
myCamera->initFromDOMElement(main);
\endcode
The frame() pointer is not modified by this method. The frame() state is however modified.
\attention The original keyFrameInterpolator() are deleted and should be copied first if they are shared. */
void Camera::initFromDOMElement(const QDomElement& element)
{
QDomElement child=element.firstChild().toElement();
QMutableMapIterator<unsigned int, KeyFrameInterpolator*> it(kfi_);
while (it.hasNext()) {
it.next();
deletePath(it.key());
}
while (!child.isNull())
{
if (child.tagName() == "Parameters")
{
// #CONNECTION# Default values set in constructor
setFieldOfView(DomUtils::qrealFromDom(child, "fieldOfView", M_PI/4.0));
setZNearCoefficient(DomUtils::qrealFromDom(child, "zNearCoefficient", 0.005));
setZClippingCoefficient(DomUtils::qrealFromDom(child, "zClippingCoefficient", sqrt(3.0)));
orthoCoef_ = DomUtils::qrealFromDom(child, "orthoCoef", tan(fieldOfView()/2.0));
setSceneRadius(DomUtils::qrealFromDom(child, "sceneRadius", sceneRadius()));
setType(PERSPECTIVE);
QString type = child.attribute("Type", "PERSPECTIVE");
if (type == "PERSPECTIVE") setType(Camera::PERSPECTIVE);
if (type == "ORTHOGRAPHIC") setType(Camera::ORTHOGRAPHIC);
QDomElement child2=child.firstChild().toElement();
while (!child2.isNull())
{
/* Although the scene does not change when a camera is loaded, restore the saved center and radius values.
Mainly useful when a the viewer is restored on startup, with possible additional cameras. */
if (child2.tagName() == "SceneCenter")
setSceneCenter(Vec(child2));
child2 = child2.nextSibling().toElement();
}
}
if (child.tagName() == "ManipulatedCameraFrame")
frame()->initFromDOMElement(child);
if (child.tagName() == "Stereo")
{
setIODistance(DomUtils::qrealFromDom(child, "IODist", 0.062));
setFocusDistance(DomUtils::qrealFromDom(child, "focusDistance", focusDistance()));
setPhysicalScreenWidth(DomUtils::qrealFromDom(child, "physScreenWidth", 0.5));
}
if (child.tagName() == "KeyFrameInterpolator")
{
unsigned int index = DomUtils::uintFromDom(child, "index", 0);
setKeyFrameInterpolator(index, new KeyFrameInterpolator(frame()));
if (keyFrameInterpolator(index))
keyFrameInterpolator(index)->initFromDOMElement(child);
}
child = child.nextSibling().toElement();
}
}
/*! Gives the coefficients of a 3D half-line passing through the Camera eye and pixel (x,y).
The origin of the half line (eye position) is stored in \p orig, while \p dir contains the properly
oriented and normalized direction of the half line.
\p x and \p y are expressed in Qt format (origin in the upper left corner). Use screenHeight() - y
to convert to OpenGL units.
This method is useful for analytical intersection in a selection method.
See the <a href="../examples/select.html">select example</a> for an illustration. */
void Camera::convertClickToLine(const QPoint& pixel, Vec& orig, Vec& dir) const
{
switch (type())
{
case Camera::PERSPECTIVE:
orig = position();
dir = Vec( ((2.0 * pixel.x() / screenWidth()) - 1.0) * tan(fieldOfView()/2.0) * aspectRatio(),
((2.0 * (screenHeight()-pixel.y()) / screenHeight()) - 1.0) * tan(fieldOfView()/2.0),
-1.0 );
dir = worldCoordinatesOf(dir) - orig;
dir.normalize();
break;
case Camera::ORTHOGRAPHIC:
{
GLdouble w,h;
getOrthoWidthHeight(w,h);
orig = Vec((2.0 * pixel.x() / screenWidth() - 1.0)*w, -(2.0 * pixel.y() / screenHeight() - 1.0)*h, 0.0);
orig = worldCoordinatesOf(orig);
dir = viewDirection();
break;
}
}
}
#ifndef DOXYGEN
/*! This method has been deprecated in libQGLViewer version 2.2.0 */
void Camera::drawCamera(qreal, qreal, qreal)
{
qWarning("drawCamera is deprecated. Use Camera::draw() instead.");
}
#endif
/*! Draws a representation of the Camera in the 3D world.
The near and far planes are drawn as quads, the frustum is drawn using lines and the camera up
vector is represented by an arrow to disambiguate the drawing. See the
<a href="../examples/standardCamera.html">standardCamera example</a> for an illustration.
Note that the current \c glColor and \c glPolygonMode are used to draw the near and far planes. See
the <a href="../examples/frustumCulling.html">frustumCulling example</a> for an example of
semi-transparent plane drawing. Similarly, the current \c glLineWidth and \c glColor is used to draw
the frustum outline.
When \p drawFarPlane is \c false, only the near plane is drawn. \p scale can be used to scale the
drawing: a value of 1.0 (default) will draw the Camera's frustum at its actual size.
This method assumes that the \c glMatrixMode is \c GL_MODELVIEW and that the current ModelView
matrix corresponds to the world coordinate system (as it is at the beginning of QGLViewer::draw()).
The Camera is then correctly positioned and orientated.
\note The drawing of a QGLViewer's own QGLViewer::camera() should not be visible, but may create
artefacts due to numerical imprecisions. */
void Camera::draw(bool drawFarPlane, qreal scale) const
{
glPushMatrix();
glMultMatrixd(frame()->worldMatrix());
// 0 is the upper left coordinates of the near corner, 1 for the far one
Vec points[2];
points[0].z = scale * zNear();
points[1].z = scale * zFar();
switch (type())
{
case Camera::PERSPECTIVE:
{
points[0].y = points[0].z * tan(fieldOfView()/2.0);
points[0].x = points[0].y * aspectRatio();
const qreal ratio = points[1].z / points[0].z;
points[1].y = ratio * points[0].y;
points[1].x = ratio * points[0].x;
break;
}
case Camera::ORTHOGRAPHIC:
{
GLdouble hw, hh;
getOrthoWidthHeight(hw, hh);
points[0].x = points[1].x = scale * qreal(hw);
points[0].y = points[1].y = scale * qreal(hh);
break;
}
}
const int farIndex = drawFarPlane?1:0;
// Near and (optionally) far plane(s)
glBegin(GL_QUADS);
for (int i=farIndex; i>=0; --i)
{
glNormal3d(0.0f, 0.0f, (i==0)?1.0f:-1.0f);
glVertex3d( points[i].x, points[i].y, -points[i].z);
glVertex3d(-points[i].x, points[i].y, -points[i].z);
glVertex3d(-points[i].x, -points[i].y, -points[i].z);
glVertex3d( points[i].x, -points[i].y, -points[i].z);
}
glEnd();
// Up arrow
const qreal arrowHeight = 1.5 * points[0].y;
const qreal baseHeight = 1.2 * points[0].y;
const qreal arrowHalfWidth = 0.5 * points[0].x;
const qreal baseHalfWidth = 0.3 * points[0].x;
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// Base
glBegin(GL_QUADS);
glVertex3d(-baseHalfWidth, points[0].y, -points[0].z);
glVertex3d( baseHalfWidth, points[0].y, -points[0].z);
glVertex3d( baseHalfWidth, baseHeight, -points[0].z);
glVertex3d(-baseHalfWidth, baseHeight, -points[0].z);
glEnd();
// Arrow
glBegin(GL_TRIANGLES);
glVertex3d( 0.0, arrowHeight, -points[0].z);
glVertex3d(-arrowHalfWidth, baseHeight, -points[0].z);
glVertex3d( arrowHalfWidth, baseHeight, -points[0].z);
glEnd();
// Frustum lines
switch (type())
{
case Camera::PERSPECTIVE :
glBegin(GL_LINES);
glVertex3d(0.0, 0.0, 0.0);
glVertex3d( points[farIndex].x, points[farIndex].y, -points[farIndex].z);
glVertex3d(0.0, 0.0, 0.0);
glVertex3d(-points[farIndex].x, points[farIndex].y, -points[farIndex].z);
glVertex3d(0.0, 0.0, 0.0);
glVertex3d(-points[farIndex].x, -points[farIndex].y, -points[farIndex].z);
glVertex3d(0.0, 0.0, 0.0);
glVertex3d( points[farIndex].x, -points[farIndex].y, -points[farIndex].z);
glEnd();
break;
case Camera::ORTHOGRAPHIC :
if (drawFarPlane)
{
glBegin(GL_LINES);
glVertex3d( points[0].x, points[0].y, -points[0].z);
glVertex3d( points[1].x, points[1].y, -points[1].z);
glVertex3d(-points[0].x, points[0].y, -points[0].z);
glVertex3d(-points[1].x, points[1].y, -points[1].z);
glVertex3d(-points[0].x, -points[0].y, -points[0].z);
glVertex3d(-points[1].x, -points[1].y, -points[1].z);
glVertex3d( points[0].x, -points[0].y, -points[0].z);
glVertex3d( points[1].x, -points[1].y, -points[1].z);
glEnd();
}
}
glPopMatrix();
}
/*! Returns the 6 plane equations of the Camera frustum.
The six 4-component vectors of \p coef respectively correspond to the left, right, near, far, top
and bottom Camera frustum planes. Each vector holds a plane equation of the form:
\code
a*x + b*y + c*z + d = 0
\endcode
where \c a, \c b, \c c and \c d are the 4 components of each vector, in that order.
See the <a href="../examples/frustumCulling.html">frustumCulling example</a> for an application.
This format is compatible with the \c glClipPlane() function. One camera frustum plane can hence be
applied in an other viewer to visualize the culling results:
\code
// Retrieve plane equations
GLdouble coef[6][4];
mainViewer->camera()->getFrustumPlanesCoefficients(coef);
// These two additional clipping planes (which must have been enabled)
// will reproduce the mainViewer's near and far clipping.
glClipPlane(GL_CLIP_PLANE0, coef[2]);
glClipPlane(GL_CLIP_PLANE1, coef[3]);
\endcode */
void Camera::getFrustumPlanesCoefficients(GLdouble coef[6][4]) const
{
// Computed once and for all
const Vec pos = position();
const Vec viewDir = viewDirection();
const Vec up = upVector();
const Vec right = rightVector();
const qreal posViewDir = pos * viewDir;
static Vec normal[6];
static GLdouble dist[6];
switch (type())
{
case Camera::PERSPECTIVE :
{
const qreal hhfov = horizontalFieldOfView() / 2.0;
const qreal chhfov = cos(hhfov);
const qreal shhfov = sin(hhfov);
normal[0] = - shhfov * viewDir;
normal[1] = normal[0] + chhfov * right;
normal[0] = normal[0] - chhfov * right;
normal[2] = -viewDir;
normal[3] = viewDir;
const qreal hfov = fieldOfView() / 2.0;
const qreal chfov = cos(hfov);
const qreal shfov = sin(hfov);
normal[4] = - shfov * viewDir;
normal[5] = normal[4] - chfov * up;
normal[4] = normal[4] + chfov * up;
for (int i=0; i<2; ++i)
dist[i] = pos * normal[i];
for (int j=4; j<6; ++j)
dist[j] = pos * normal[j];
// Natural equations are:
// dist[0,1,4,5] = pos * normal[0,1,4,5];
// dist[2] = (pos + zNear() * viewDir) * normal[2];
// dist[3] = (pos + zFar() * viewDir) * normal[3];
// 2 times less computations using expanded/merged equations. Dir vectors are normalized.
const qreal posRightCosHH = chhfov * pos * right;
dist[0] = -shhfov * posViewDir;
dist[1] = dist[0] + posRightCosHH;
dist[0] = dist[0] - posRightCosHH;
const qreal posUpCosH = chfov * pos * up;
dist[4] = - shfov * posViewDir;
dist[5] = dist[4] - posUpCosH;
dist[4] = dist[4] + posUpCosH;
break;
}
case Camera::ORTHOGRAPHIC :
normal[0] = -right;
normal[1] = right;
normal[4] = up;
normal[5] = -up;
GLdouble hw, hh;
getOrthoWidthHeight(hw, hh);
dist[0] = (pos - hw * right) * normal[0];
dist[1] = (pos + hw * right) * normal[1];
dist[4] = (pos + hh * up) * normal[4];
dist[5] = (pos - hh * up) * normal[5];
break;
}
// Front and far planes are identical for both camera types.
normal[2] = -viewDir;
normal[3] = viewDir;
dist[2] = -posViewDir - zNear();
dist[3] = posViewDir + zFar();
for (int i=0; i<6; ++i)
{
coef[i][0] = GLdouble(normal[i].x);
coef[i][1] = GLdouble(normal[i].y);
coef[i][2] = GLdouble(normal[i].z);
coef[i][3] = dist[i];
}
}
void Camera::onFrameModified() {
projectionMatrixIsUpToDate_ = false;
modelViewMatrixIsUpToDate_ = false;
}
| 79,872 | 35.141629 | 120 | cpp |
octomap | octomap-master/octovis/src/extern/QGLViewer/camera.h | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#ifndef QGLVIEWER_CAMERA_H
#define QGLVIEWER_CAMERA_H
#include "keyFrameInterpolator.h"
class QGLViewer;
namespace qglviewer {
class ManipulatedCameraFrame;
/*! \brief A perspective or orthographic camera.
\class Camera camera.h QGLViewer/camera.h
A Camera defines some intrinsic parameters (fieldOfView(), position(), viewDirection(),
upVector()...) and useful positioning tools that ease its placement (showEntireScene(),
fitSphere(), lookAt()...). It exports its associated OpenGL projection and modelview matrices and
can interactively be modified using the mouse.
<h3>Mouse manipulation</h3>
The position() and orientation() of the Camera are defined by a ManipulatedCameraFrame (retrieved
using frame()). These methods are just convenient wrappers to the equivalent Frame methods. This
also means that the Camera frame() can be attached to a Frame::referenceFrame() which enables
complex Camera setups.
Different displacements can be performed using the mouse. The list of possible actions is defined
by the QGLViewer::MouseAction enum. Use QGLViewer::setMouseBinding() to attach a specific action
to an arbitrary mouse button-state key binding. These actions are detailed in the <a
href="../mouse.html">mouse page</a>.
The default button binding are: QGLViewer::ROTATE (left), QGLViewer::ZOOM (middle) and
QGLViewer::TRANSLATE (right). With this configuration, the Camera \e observes a scene and rotates
around its pivotPoint(). You can switch between this mode and a fly mode using the
QGLViewer::CAMERA_MODE (see QGLViewer::toggleCameraMode()) keyboard shortcut (default is 'Space').
<h3>Other functionalities</h3>
The type() of the Camera can be Camera::ORTHOGRAPHIC or Camera::PERSPECTIVE (see Type()).
fieldOfView() is meaningless with Camera::ORTHOGRAPHIC.
The near and far planes of the Camera are fitted to the scene and determined from
QGLViewer::sceneRadius(), QGLViewer::sceneCenter() and zClippingCoefficient() by the zNear() and
zFar() methods. Reasonable values on the scene extends hence have to be provided to the QGLViewer
in order for the Camera to correctly display the scene. High level positioning methods also use
this information (showEntireScene(), centerScene()...).
A Camera holds KeyFrameInterpolator that can be used to save Camera positions and paths. You can
interactively addKeyFrameToPath() to a given path using the default \c Alt+F[1-12] shortcuts. Use
playPath() to make the Camera follow the path (default shortcut is F[1-12]). See the <a
href="../keyboard.html">keyboard page</a> for details on key customization.
Use cameraCoordinatesOf() and worldCoordinatesOf() to convert to and from the Camera frame()
coordinate system. projectedCoordinatesOf() and unprojectedCoordinatesOf() will convert from
screen to 3D coordinates. convertClickToLine() is very useful for analytical object selection.
Stereo display is possible on machines with quad buffer capabilities (with Camera::PERSPECTIVE
type() only). Test the <a href="../examples/stereoViewer.html">stereoViewer example</a> to check.
A Camera can also be used outside of a QGLViewer or even without OpenGL for its coordinate system
conversion capabilities. Note however that some of them explicitly rely on the presence of a
Z-buffer. \nosubgrouping */
class QGLVIEWER_EXPORT Camera : public QObject
{
#ifndef DOXYGEN
friend class ::QGLViewer;
#endif
Q_OBJECT
public:
Camera();
virtual ~Camera();
Camera(const Camera& camera);
Camera& operator=(const Camera& camera);
/*! Enumerates the two possible types of Camera.
See type() and setType(). This type mainly defines different Camera projection matrix (see
loadProjectionMatrix()). Many other methods (pointUnderPixel(), convertClickToLine(),
projectedCoordinatesOf(), pixelGLRatio()...) are affected by this Type. */
enum Type { PERSPECTIVE, ORTHOGRAPHIC };
/*! @name Position and orientation */
//@{
public:
Vec position() const;
Vec upVector() const;
Vec viewDirection() const;
Vec rightVector() const;
Quaternion orientation() const;
void setFromModelViewMatrix(const GLdouble* const modelViewMatrix);
void setFromProjectionMatrix(const qreal matrix[12]);
public Q_SLOTS:
void setPosition(const Vec& pos);
void setOrientation(const Quaternion& q);
void setOrientation(qreal theta, qreal phi);
void setUpVector(const Vec& up, bool noMove=true);
void setViewDirection(const Vec& direction);
//@}
/*! @name Positioning tools */
//@{
public Q_SLOTS:
void lookAt(const Vec& target);
void showEntireScene();
void fitSphere(const Vec& center, qreal radius);
void fitBoundingBox(const Vec& min, const Vec& max);
void fitScreenRegion(const QRect& rectangle);
void centerScene();
void interpolateToZoomOnPixel(const QPoint& pixel);
void interpolateToFitScene();
void interpolateTo(const Frame& fr, qreal duration);
//@}
/*! @name Frustum */
//@{
public:
/*! Returns the Camera::Type of the Camera.
Set by setType(). Mainly used by loadProjectionMatrix().
A Camera::PERSPECTIVE Camera uses a classical projection mainly defined by its fieldOfView().
With a Camera::ORTHOGRAPHIC type(), the fieldOfView() is meaningless and the width and height of
the Camera frustum are inferred from the distance to the pivotPoint() using
getOrthoWidthHeight().
Both types use zNear() and zFar() (to define their clipping planes) and aspectRatio() (for
frustum shape). */
Type type() const { return type_; }
/*! Returns the vertical field of view of the Camera (in radians).
Value is set using setFieldOfView(). Default value is pi/4 radians. This value is meaningless if
the Camera type() is Camera::ORTHOGRAPHIC.
The field of view corresponds the one used in \c gluPerspective (see manual). It sets the Y
(vertical) aperture of the Camera. The X (horizontal) angle is inferred from the window aspect
ratio (see aspectRatio() and horizontalFieldOfView()).
Use setFOVToFitScene() to adapt the fieldOfView() to a given scene. */
qreal fieldOfView() const { return fieldOfView_; }
/*! Returns the horizontal field of view of the Camera (in radians).
Value is set using setHorizontalFieldOfView() or setFieldOfView(). These values
are always linked by:
\code
horizontalFieldOfView() = 2.0 * atan ( tan(fieldOfView()/2.0) * aspectRatio() ).
\endcode */
qreal horizontalFieldOfView() const { return 2.0 * atan ( tan(fieldOfView()/2.0) * aspectRatio() ); }
/*! Returns the Camera aspect ratio defined by screenWidth() / screenHeight().
When the Camera is attached to a QGLViewer, these values and hence the aspectRatio() are
automatically fitted to the viewer's window aspect ratio using setScreenWidthAndHeight(). */
qreal aspectRatio() const { return screenWidth_ / static_cast<qreal>(screenHeight_); }
/*! Returns the width (in pixels) of the Camera screen.
Set using setScreenWidthAndHeight(). This value is automatically fitted to the QGLViewer's
window dimensions when the Camera is attached to a QGLViewer. See also QGLWidget::width() */
int screenWidth() const { return screenWidth_; }
/*! Returns the height (in pixels) of the Camera screen.
Set using setScreenWidthAndHeight(). This value is automatically fitted to the QGLViewer's
window dimensions when the Camera is attached to a QGLViewer. See also QGLWidget::height() */
int screenHeight() const { return screenHeight_; }
void getViewport(GLint viewport[4]) const;
qreal pixelGLRatio(const Vec& position) const;
/*! Returns the coefficient which is used to set zNear() when the Camera is inside the sphere
defined by sceneCenter() and zClippingCoefficient() * sceneRadius().
In that case, the zNear() value is set to zNearCoefficient() * zClippingCoefficient() *
sceneRadius(). See the zNear() documentation for details.
Default value is 0.005, which is appropriate for most applications. In case you need a high
dynamic ZBuffer precision, you can increase this value (~0.1). A lower value will prevent
clipping of very close objects at the expense of a worst Z precision.
Only meaningful when Camera type is Camera::PERSPECTIVE. */
qreal zNearCoefficient() const { return zNearCoef_; }
/*! Returns the coefficient used to position the near and far clipping planes.
The near (resp. far) clipping plane is positioned at a distance equal to zClippingCoefficient() *
sceneRadius() in front of (resp. behind) the sceneCenter(). This garantees an optimal use of
the z-buffer range and minimizes aliasing. See the zNear() and zFar() documentations.
Default value is square root of 3.0 (so that a cube of size sceneRadius() is not clipped).
However, since the sceneRadius() is used for other purposes (see showEntireScene(), flySpeed(),
...) and you may want to change this value to define more precisely the location of the clipping
planes. See also zNearCoefficient().
For a total control on clipping planes' positions, an other option is to overload the zNear()
and zFar() methods. See the <a href="../examples/standardCamera.html">standardCamera example</a>.
\attention When QGLViewer::cameraPathAreEdited(), this value is set to 5.0 so that the Camera
paths are not clipped. The previous zClippingCoefficient() value is restored back when you leave
this mode. */
qreal zClippingCoefficient() const { return zClippingCoef_; }
virtual qreal zNear() const;
virtual qreal zFar() const;
virtual void getOrthoWidthHeight(GLdouble& halfWidth, GLdouble& halfHeight) const;
void getFrustumPlanesCoefficients(GLdouble coef[6][4]) const;
public Q_SLOTS:
void setType(Type type);
void setFieldOfView(qreal fov);
/*! Sets the horizontalFieldOfView() of the Camera (in radians).
horizontalFieldOfView() and fieldOfView() are linked by the aspectRatio(). This method actually
calls setFieldOfView(( 2.0 * atan (tan(hfov / 2.0) / aspectRatio()) )) so that a call to
horizontalFieldOfView() returns the expected value. */
void setHorizontalFieldOfView(qreal hfov) { setFieldOfView( 2.0 * atan (tan(hfov / 2.0) / aspectRatio()) ); }
void setFOVToFitScene();
/*! Defines the Camera aspectRatio().
This value is actually inferred from the screenWidth() / screenHeight() ratio. You should use
setScreenWidthAndHeight() instead.
This method might however be convenient when the Camera is not associated with a QGLViewer. It
actually sets the screenHeight() to 100 and the screenWidth() accordingly. See also
setFOVToFitScene().
\note If you absolutely need an aspectRatio() that does not correspond to your viewer's window
dimensions, overload loadProjectionMatrix() or multiply the created GL_PROJECTION matrix by a
scaled diagonal matrix in your QGLViewer::draw() method. */
void setAspectRatio(qreal aspect) { setScreenWidthAndHeight(int(100.0*aspect), 100); }
void setScreenWidthAndHeight(int width, int height);
/*! Sets the zNearCoefficient() value. */
void setZNearCoefficient(qreal coef) { zNearCoef_ = coef; projectionMatrixIsUpToDate_ = false; }
/*! Sets the zClippingCoefficient() value. */
void setZClippingCoefficient(qreal coef) { zClippingCoef_ = coef; projectionMatrixIsUpToDate_ = false; }
//@}
/*! @name Scene radius and center */
//@{
public:
/*! Returns the radius of the scene observed by the Camera.
You need to provide such an approximation of the scene dimensions so that the Camera can adapt
its zNear() and zFar() values. See the sceneCenter() documentation.
See also setSceneBoundingBox().
Note that QGLViewer::sceneRadius() (resp. QGLViewer::setSceneRadius()) simply call this method
(resp. setSceneRadius()) on its associated QGLViewer::camera(). */
qreal sceneRadius() const { return sceneRadius_; }
/*! Returns the position of the scene center, defined in the world coordinate system.
The scene observed by the Camera should be roughly centered on this position, and included in a
sceneRadius() sphere. This approximate description of the scene permits a zNear() and zFar()
clipping planes definition, and allows convenient positioning methods such as showEntireScene().
Default value is (0,0,0) (world origin). Use setSceneCenter() to change it. See also
setSceneBoundingBox().
Note that QGLViewer::sceneCenter() (resp. QGLViewer::setSceneCenter()) simply calls this method
(resp. setSceneCenter()) on its associated QGLViewer::camera(). */
Vec sceneCenter() const { return sceneCenter_; }
qreal distanceToSceneCenter() const;
public Q_SLOTS:
void setSceneRadius(qreal radius);
void setSceneCenter(const Vec& center);
bool setSceneCenterFromPixel(const QPoint& pixel);
void setSceneBoundingBox(const Vec& min, const Vec& max);
//@}
/*! @name Pivot Point */
//@{
public Q_SLOTS:
void setPivotPoint(const Vec& point);
bool setPivotPointFromPixel(const QPoint& pixel);
public:
Vec pivotPoint() const;
#ifndef DOXYGEN
public Q_SLOTS:
void setRevolveAroundPoint(const Vec& point);
bool setRevolveAroundPointFromPixel(const QPoint& pixel);
public:
Vec revolveAroundPoint() const;
#endif
//@}
/*! @name Associated frame */
//@{
public:
/*! Returns the ManipulatedCameraFrame attached to the Camera.
This ManipulatedCameraFrame defines its position() and orientation() and can translate mouse
events into Camera displacement. Set using setFrame(). */
ManipulatedCameraFrame* frame() const { return frame_; }
public Q_SLOTS:
void setFrame(ManipulatedCameraFrame* const mcf);
//@}
/*! @name KeyFramed paths */
//@{
public:
KeyFrameInterpolator* keyFrameInterpolator(unsigned int i) const;
public Q_SLOTS:
void setKeyFrameInterpolator(unsigned int i, KeyFrameInterpolator* const kfi);
virtual void addKeyFrameToPath(unsigned int i);
virtual void playPath(unsigned int i);
virtual void deletePath(unsigned int i);
virtual void resetPath(unsigned int i);
virtual void drawAllPaths();
//@}
/*! @name OpenGL matrices */
//@{
public:
virtual void loadProjectionMatrix(bool reset=true) const;
virtual void loadModelViewMatrix(bool reset=true) const;
void computeProjectionMatrix() const;
void computeModelViewMatrix() const;
virtual void loadProjectionMatrixStereo(bool leftBuffer=true) const;
virtual void loadModelViewMatrixStereo(bool leftBuffer=true) const;
void getProjectionMatrix(GLfloat m[16]) const;
void getProjectionMatrix(GLdouble m[16]) const;
void getModelViewMatrix(GLfloat m[16]) const;
void getModelViewMatrix(GLdouble m[16]) const;
void getModelViewProjectionMatrix(GLfloat m[16]) const;
void getModelViewProjectionMatrix(GLdouble m[16]) const;
//@}
/*! @name Drawing */
//@{
#ifndef DOXYGEN
static void drawCamera(qreal scale=1.0, qreal aspectRatio=1.33, qreal fieldOfView=qreal(M_PI)/4.0);
#endif
virtual void draw(bool drawFarPlane=true, qreal scale=1.0) const;
//@}
/*! @name World to Camera coordinate systems conversions */
//@{
public:
Vec cameraCoordinatesOf(const Vec& src) const;
Vec worldCoordinatesOf(const Vec& src) const;
void getCameraCoordinatesOf(const qreal src[3], qreal res[3]) const;
void getWorldCoordinatesOf(const qreal src[3], qreal res[3]) const;
//@}
/*! @name 2D screen to 3D world coordinate systems conversions */
//@{
public:
Vec projectedCoordinatesOf(const Vec& src, const Frame* frame=NULL) const;
Vec unprojectedCoordinatesOf(const Vec& src, const Frame* frame=NULL) const;
void getProjectedCoordinatesOf(const qreal src[3], qreal res[3], const Frame* frame=NULL) const;
void getUnprojectedCoordinatesOf(const qreal src[3], qreal res[3], const Frame* frame=NULL) const;
void convertClickToLine(const QPoint& pixel, Vec& orig, Vec& dir) const;
Vec pointUnderPixel(const QPoint& pixel, bool& found) const;
//@}
/*! @name Fly speed */
//@{
public:
qreal flySpeed() const;
public Q_SLOTS:
void setFlySpeed(qreal speed);
//@}
/*! @name Stereo parameters */
//@{
public:
/*! Returns the user's inter-ocular distance (in meters). Default value is 0.062m, which fits most people.
loadProjectionMatrixStereo() uses this value to define the Camera offset and frustum. See
setIODistance(). */
qreal IODistance() const { return IODistance_; }
/*! Returns the physical distance between the user's eyes and the screen (in meters).
physicalDistanceToScreen() and focusDistance() represent the same distance. The former is
expressed in physical real world units, while the latter is expressed in OpenGL virtual world
units.
This is a helper function. It simply returns physicalScreenWidth() / 2.0 / tan(horizontalFieldOfView() / 2.0); */
qreal physicalDistanceToScreen() const { return physicalScreenWidth() / 2.0 / tan(horizontalFieldOfView() / 2.0); }
/*! Returns the physical screen width, in meters. Default value is 0.5m (average monitor width).
Used for stereo display only (see loadModelViewMatrixStereo() and loadProjectionMatrixStereo()).
Set using setPhysicalScreenWidth(). */
qreal physicalScreenWidth() const { return physicalScreenWidth_; }
/*! Returns the focus distance used by stereo display, expressed in OpenGL units.
This is the distance in the virtual world between the Camera and the plane where the horizontal
stereo parallax is null (the stereo left and right cameras' lines of sigth cross at this distance).
This distance is the virtual world equivalent of the real-world physicalDistanceToScreen().
\attention This value is modified by QGLViewer::setSceneRadius(), setSceneRadius() and
setFieldOfView(). When one of these values is modified, focusDistance() is set to sceneRadius()
/ tan(fieldOfView()/2), which provides good results. */
qreal focusDistance() const { return focusDistance_; }
public Q_SLOTS:
/*! Sets the IODistance(). */
void setIODistance(qreal distance) { IODistance_ = distance; }
#ifndef DOXYGEN
/*! This method is deprecated. Use setPhysicalScreenWidth() instead. */
void setPhysicalDistanceToScreen(qreal distance) { Q_UNUSED(distance); qWarning("setPhysicalDistanceToScreen is deprecated, use setPhysicalScreenWidth instead"); }
#endif
/*! Sets the physical screen (monitor or projected wall) width (in meters). */
void setPhysicalScreenWidth(qreal width) { physicalScreenWidth_ = width; }
/*! Sets the focusDistance(), in OpenGL scene units. */
void setFocusDistance(qreal distance) { focusDistance_ = distance; }
//@}
/*! @name XML representation */
//@{
public:
virtual QDomElement domElement(const QString& name, QDomDocument& document) const;
public Q_SLOTS:
virtual void initFromDOMElement(const QDomElement& element);
//@}
private Q_SLOTS:
void onFrameModified();
private:
// F r a m e
ManipulatedCameraFrame* frame_;
// C a m e r a p a r a m e t e r s
int screenWidth_, screenHeight_; // size of the window, in pixels
qreal fieldOfView_; // in radians
Vec sceneCenter_;
qreal sceneRadius_; // OpenGL units
qreal zNearCoef_;
qreal zClippingCoef_;
qreal orthoCoef_;
Type type_; // PERSPECTIVE or ORTHOGRAPHIC
mutable GLdouble modelViewMatrix_[16]; // Buffered model view matrix.
mutable bool modelViewMatrixIsUpToDate_;
mutable GLdouble projectionMatrix_[16]; // Buffered projection matrix.
mutable bool projectionMatrixIsUpToDate_;
// S t e r e o p a r a m e t e r s
qreal IODistance_; // inter-ocular distance, in meters
qreal focusDistance_; // in scene units
qreal physicalScreenWidth_; // in meters
// P o i n t s o f V i e w s a n d K e y F r a m e s
QMap<unsigned int, KeyFrameInterpolator*> kfi_;
KeyFrameInterpolator* interpolationKfi_;
};
} // namespace qglviewer
#endif // QGLVIEWER_CAMERA_H
| 20,450 | 38.865497 | 164 | h |
octomap | octomap-master/octovis/src/extern/QGLViewer/config.h | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
///////////////////////////////////////////////////////////////////
// libQGLViewer configuration file //
// Modify these settings according to your local configuration //
///////////////////////////////////////////////////////////////////
#ifndef QGLVIEWER_CONFIG_H
#define QGLVIEWER_CONFIG_H
#define QGLVIEWER_VERSION 0x020603
// Needed for Qt < 4 (?)
#ifndef QT_CLEAN_NAMESPACE
# define QT_CLEAN_NAMESPACE
#endif
// Get QT_VERSION and other Qt flags
#include <qglobal.h>
#if QT_VERSION < 0x040000
Error : libQGLViewer requires a minimum Qt version of 4.0
#endif
// Win 32 DLL export macros
#ifdef Q_OS_WIN32
# ifndef M_PI
# define M_PI 3.14159265358979323846
# endif
# ifndef QGLVIEWER_STATIC
# ifdef CREATE_QGLVIEWER_DLL
# if QT_VERSION >= 0x040500
# define QGLVIEWER_EXPORT Q_DECL_EXPORT
# else
# define QGLVIEWER_EXPORT __declspec(dllexport)
# endif
# else
# if QT_VERSION >= 0x040500
# define QGLVIEWER_EXPORT Q_DECL_IMPORT
# else
# define QGLVIEWER_EXPORT __declspec(dllimport)
# endif
# endif
# endif
# ifndef __MINGW32__
# pragma warning( disable : 4251 ) // DLL interface, needed with Visual 6
# pragma warning( disable : 4786 ) // identifier truncated to 255 in browser information (Visual 6).
# endif
#endif // Q_OS_WIN32
// For other architectures, this macro is empty
#ifndef QGLVIEWER_EXPORT
# define QGLVIEWER_EXPORT
#endif
// OpenGL includes - Included here and hence shared by all the files that need OpenGL headers.
# include <QGLWidget>
// GLU was removed from Qt in version 4.8
#ifdef Q_OS_MAC
# include <OpenGL/glu.h>
#else
# include <GL/glu.h>
#endif
// Container classes interfaces changed a lot in Qt.
// Compatibility patches are all grouped here.
#include <QList>
#include <QVector>
// For deprecated methods
// #define __WHERE__ "In file "<<__FILE__<<", line "<<__LINE__<<": "
// #define orientationAxisAngle(x,y,z,a) { std::cout << __WHERE__ << "getOrientationAxisAngle()." << std::endl; exit(0); }
// Patch for gcc version <= 2.95. Seems to no longer be needed with recent Qt versions.
// Uncomment these lines if you have error message dealing with operator << on QStrings
// #if defined(__GNUC__) && defined(__GNUC_MINOR__) && (__GNUC__ < 3) && (__GNUC_MINOR__ < 96)
// # include <iostream>
// # include <qstring.h>
// std::ostream& operator<<(std::ostream& out, const QString& str)
// { out << str.latin1(); return out; }
// #endif
#endif // QGLVIEWER_CONFIG_H
| 3,466 | 32.019048 | 122 | h |
octomap | octomap-master/octovis/src/extern/QGLViewer/constraint.cpp | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#include "constraint.h"
#include "frame.h"
#include "camera.h"
#include "manipulatedCameraFrame.h"
using namespace qglviewer;
using namespace std;
////////////////////////////////////////////////////////////////////////////////
// Constraint //
////////////////////////////////////////////////////////////////////////////////
/*! Default constructor.
translationConstraintType() and rotationConstraintType() are set to AxisPlaneConstraint::FREE.
translationConstraintDirection() and rotationConstraintDirection() are set to (0,0,0). */
AxisPlaneConstraint::AxisPlaneConstraint()
: translationConstraintType_(FREE), rotationConstraintType_(FREE)
{
// Do not use set since setRotationConstraintType needs a read.
}
/*! Simply calls setTranslationConstraintType() and setTranslationConstraintDirection(). */
void AxisPlaneConstraint::setTranslationConstraint(Type type, const Vec& direction)
{
setTranslationConstraintType(type);
setTranslationConstraintDirection(direction);
}
/*! Defines the translationConstraintDirection(). The coordinate system where \p direction is expressed depends on your class implementation. */
void AxisPlaneConstraint::setTranslationConstraintDirection(const Vec& direction)
{
if ((translationConstraintType()!=AxisPlaneConstraint::FREE) && (translationConstraintType()!=AxisPlaneConstraint::FORBIDDEN))
{
const qreal norm = direction.norm();
if (norm < 1E-8)
{
qWarning("AxisPlaneConstraint::setTranslationConstraintDir: null vector for translation constraint");
translationConstraintType_ = AxisPlaneConstraint::FREE;
}
else
translationConstraintDir_ = direction/norm;
}
}
/*! Simply calls setRotationConstraintType() and setRotationConstraintDirection(). */
void AxisPlaneConstraint::setRotationConstraint(Type type, const Vec& direction)
{
setRotationConstraintType(type);
setRotationConstraintDirection(direction);
}
/*! Defines the rotationConstraintDirection(). The coordinate system where \p direction is expressed depends on your class implementation. */
void AxisPlaneConstraint::setRotationConstraintDirection(const Vec& direction)
{
if ((rotationConstraintType()!=AxisPlaneConstraint::FREE) && (rotationConstraintType()!=AxisPlaneConstraint::FORBIDDEN))
{
const qreal norm = direction.norm();
if (norm < 1E-8)
{
qWarning("AxisPlaneConstraint::setRotationConstraintDir: null vector for rotation constraint");
rotationConstraintType_ = AxisPlaneConstraint::FREE;
}
else
rotationConstraintDir_ = direction/norm;
}
}
/*! Set the Type() of the rotationConstraintType(). Default is AxisPlaneConstraint::FREE.
Depending on this value, the Frame will freely rotate (AxisPlaneConstraint::FREE), will only be able
to rotate around an axis (AxisPlaneConstraint::AXIS), or will not able to rotate at all
(AxisPlaneConstraint::FORBIDDEN).
Use Frame::setOrientation() to define the orientation of the constrained Frame before it gets
constrained.
\attention An AxisPlaneConstraint::PLANE Type() is not meaningful for rotational constraints and
will be ignored. */
void AxisPlaneConstraint::setRotationConstraintType(Type type)
{
if (rotationConstraintType() == AxisPlaneConstraint::PLANE)
{
qWarning("AxisPlaneConstraint::setRotationConstraintType: the PLANE type cannot be used for a rotation constraints");
return;
}
rotationConstraintType_ = type;
}
////////////////////////////////////////////////////////////////////////////////
// LocalConstraint //
////////////////////////////////////////////////////////////////////////////////
/*! Depending on translationConstraintType(), constrain \p translation to be along an axis or
limited to a plane defined in the Frame local coordinate system by
translationConstraintDirection(). */
void LocalConstraint::constrainTranslation(Vec& translation, Frame* const frame)
{
Vec proj;
switch (translationConstraintType())
{
case AxisPlaneConstraint::FREE:
break;
case AxisPlaneConstraint::PLANE:
proj = frame->rotation().rotate(translationConstraintDirection());
translation.projectOnPlane(proj);
break;
case AxisPlaneConstraint::AXIS:
proj = frame->rotation().rotate(translationConstraintDirection());
translation.projectOnAxis(proj);
break;
case AxisPlaneConstraint::FORBIDDEN:
translation = Vec(0.0, 0.0, 0.0);
break;
}
}
/*! When rotationConstraintType() is AxisPlaneConstraint::AXIS, constrain \p rotation to be a rotation
around an axis whose direction is defined in the Frame local coordinate system by
rotationConstraintDirection(). */
void LocalConstraint::constrainRotation(Quaternion& rotation, Frame* const)
{
switch (rotationConstraintType())
{
case AxisPlaneConstraint::FREE:
break;
case AxisPlaneConstraint::PLANE:
break;
case AxisPlaneConstraint::AXIS:
{
Vec axis = rotationConstraintDirection();
Vec quat = Vec(rotation[0], rotation[1], rotation[2]);
quat.projectOnAxis(axis);
rotation = Quaternion(quat, 2.0*acos(rotation[3]));
}
break;
case AxisPlaneConstraint::FORBIDDEN:
rotation = Quaternion(); // identity
break;
}
}
////////////////////////////////////////////////////////////////////////////////
// WorldConstraint //
////////////////////////////////////////////////////////////////////////////////
/*! Depending on translationConstraintType(), constrain \p translation to be along an axis or
limited to a plane defined in the world coordinate system by
translationConstraintDirection(). */
void WorldConstraint::constrainTranslation(Vec& translation, Frame* const frame)
{
Vec proj;
switch (translationConstraintType())
{
case AxisPlaneConstraint::FREE:
break;
case AxisPlaneConstraint::PLANE:
if (frame->referenceFrame())
{
proj = frame->referenceFrame()->transformOf(translationConstraintDirection());
translation.projectOnPlane(proj);
}
else
translation.projectOnPlane(translationConstraintDirection());
break;
case AxisPlaneConstraint::AXIS:
if (frame->referenceFrame())
{
proj = frame->referenceFrame()->transformOf(translationConstraintDirection());
translation.projectOnAxis(proj);
}
else
translation.projectOnAxis(translationConstraintDirection());
break;
case AxisPlaneConstraint::FORBIDDEN:
translation = Vec(0.0, 0.0, 0.0);
break;
}
}
/*! When rotationConstraintType() is AxisPlaneConstraint::AXIS, constrain \p rotation to be a rotation
around an axis whose direction is defined in the world coordinate system by
rotationConstraintDirection(). */
void WorldConstraint::constrainRotation(Quaternion& rotation, Frame* const frame)
{
switch (rotationConstraintType())
{
case AxisPlaneConstraint::FREE:
break;
case AxisPlaneConstraint::PLANE:
break;
case AxisPlaneConstraint::AXIS:
{
Vec quat(rotation[0], rotation[1], rotation[2]);
Vec axis = frame->transformOf(rotationConstraintDirection());
quat.projectOnAxis(axis);
rotation = Quaternion(quat, 2.0*acos(rotation[3]));
break;
}
case AxisPlaneConstraint::FORBIDDEN:
rotation = Quaternion(); // identity
break;
}
}
////////////////////////////////////////////////////////////////////////////////
// CameraConstraint //
////////////////////////////////////////////////////////////////////////////////
/*! Creates a CameraConstraint, whose constrained directions are defined in the \p camera coordinate
system. */
CameraConstraint::CameraConstraint(const Camera* const camera)
: AxisPlaneConstraint(), camera_(camera)
{}
/*! Depending on translationConstraintType(), constrain \p translation to be along an axis or
limited to a plane defined in the camera() coordinate system by
translationConstraintDirection(). */
void CameraConstraint::constrainTranslation(Vec& translation, Frame* const frame)
{
Vec proj;
switch (translationConstraintType())
{
case AxisPlaneConstraint::FREE:
break;
case AxisPlaneConstraint::PLANE:
proj = camera()->frame()->inverseTransformOf(translationConstraintDirection());
if (frame->referenceFrame())
proj = frame->referenceFrame()->transformOf(proj);
translation.projectOnPlane(proj);
break;
case AxisPlaneConstraint::AXIS:
proj = camera()->frame()->inverseTransformOf(translationConstraintDirection());
if (frame->referenceFrame())
proj = frame->referenceFrame()->transformOf(proj);
translation.projectOnAxis(proj);
break;
case AxisPlaneConstraint::FORBIDDEN:
translation = Vec(0.0, 0.0, 0.0);
break;
}
}
/*! When rotationConstraintType() is AxisPlaneConstraint::AXIS, constrain \p rotation to be a rotation
around an axis whose direction is defined in the camera() coordinate system by
rotationConstraintDirection(). */
void CameraConstraint::constrainRotation(Quaternion& rotation, Frame* const frame)
{
switch (rotationConstraintType())
{
case AxisPlaneConstraint::FREE:
break;
case AxisPlaneConstraint::PLANE:
break;
case AxisPlaneConstraint::AXIS:
{
Vec axis = frame->transformOf(camera()->frame()->inverseTransformOf(rotationConstraintDirection()));
Vec quat = Vec(rotation[0], rotation[1], rotation[2]);
quat.projectOnAxis(axis);
rotation = Quaternion(quat, 2.0*acos(rotation[3]));
}
break;
case AxisPlaneConstraint::FORBIDDEN:
rotation = Quaternion(); // identity
break;
}
}
| 10,385 | 34.568493 | 144 | cpp |
octomap | octomap-master/octovis/src/extern/QGLViewer/constraint.h | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#ifndef QGLVIEWER_CONSTRAINT_H
#define QGLVIEWER_CONSTRAINT_H
#include "vec.h"
#include "quaternion.h"
namespace qglviewer {
class Frame;
class Camera;
/*! \brief An interface class for Frame constraints.
\class Constraint constraint.h QGLViewer/constraint.h
This class defines the interface for the Constraints that can be applied to a Frame to limit its
motion. Use Frame::setConstraint() to associate a Constraint to a Frame (default is a \c NULL
Frame::constraint()).
<h3>How does it work ?</h3>
The Constraint acts as a filter on the translation and rotation Frame increments.
constrainTranslation() and constrainRotation() should be overloaded to specify the constraint
behavior: the desired displacement is given as a parameter that can optionally be modified.
Here is how the Frame::translate() and Frame::rotate() methods use the Constraint:
\code
Frame::translate(Vec& T)
{
if (constraint())
constraint()->constrainTranslation(T, this);
t += T;
}
Frame::rotate(Quaternion& Q)
{
if (constraint())
constraint()->constrainRotation(Q, this);
q *= Q;
}
\endcode
The default behavior of constrainTranslation() and constrainRotation() is empty (meaning no
filtering).
The Frame which uses the Constraint is passed as a parameter to the constrainTranslation() and
constrainRotation() methods, so that they can have access to its current state (mainly
Frame::position() and Frame::orientation()). It is not \c const for versatility reasons, but
directly modifying it should be avoided.
\attention Frame::setTranslation(), Frame::setRotation() and similar methods will actually indeed
set the frame position and orientation, without taking the constraint into account. Use the \e
WithConstraint versions of these methods to enforce the Constraint.
<h3>Implemented Constraints</h3>
Classical axial and plane Constraints are provided for convenience: see the LocalConstraint,
WorldConstraint and CameraConstraint classes' documentations.
Try the <a href="../examples/constrainedFrame.html">constrainedFrame</a> and <a
href="../examples/constrainedCamera.html">constrainedCamera</a> examples for an illustration.
<h3>Creating new Constraints</h3>
The implementation of a new Constraint class simply consists in overloading the filtering methods:
\code
// This Constraint enforces that the Frame cannot have a negative z world coordinate.
class myConstraint : public Constraint
{
public:
virtual void constrainTranslation(Vec& t, Frame * const fr)
{
// Express t in the world coordinate system.
const Vec tWorld = fr->inverseTransformOf(t);
if (fr->position().z + tWorld.z < 0.0) // check the new fr z coordinate
t.z = fr->transformOf(-fr->position().z); // t.z is clamped so that next z position is 0.0
}
};
\endcode
Note that the translation (resp. rotation) parameter passed to constrainTranslation() (resp.
constrainRotation()) is expressed in the \e local Frame coordinate system. Here, we use the
Frame::transformOf() and Frame::inverseTransformOf() method to convert it to and from the world
coordinate system.
Combined constraints can easily be achieved by creating a new class that applies the different
constraint filters:
\code
myConstraint::constrainTranslation(Vec& v, Frame* const fr)
{
constraint1->constrainTranslation(v, fr);
constraint2->constrainTranslation(v, fr);
// and so on, with possible branches, tests, loops...
}
\endcode
*/
class QGLVIEWER_EXPORT Constraint
{
public:
/*! Virtual destructor. Empty. */
virtual ~Constraint() {}
/*! Filters the translation applied to the \p frame. This default implementation is empty (no
filtering).
Overload this method in your own Constraint class to define a new translation constraint. \p
frame is the Frame to which is applied the translation. It is not defined \c const, but you
should refrain from directly changing its value in the constraint. Use its Frame::position() and
update the \p translation accordingly instead.
\p translation is expressed in local frame coordinate system. Use Frame::inverseTransformOf() to
express it in the world coordinate system if needed. */
virtual void constrainTranslation(Vec& translation, Frame* const frame) { Q_UNUSED(translation); Q_UNUSED(frame); }
/*! Filters the rotation applied to the \p frame. This default implementation is empty (no
filtering).
Overload this method in your own Constraint class to define a new rotation constraint. See
constrainTranslation() for details.
Use Frame::inverseTransformOf() on the \p rotation Quaternion::axis() to express \p rotation in
the world coordinate system if needed. */
virtual void constrainRotation(Quaternion& rotation, Frame* const frame) { Q_UNUSED(rotation); Q_UNUSED(frame); }
};
/*!
\brief An abstract class for Frame Constraints defined by an axis or a plane.
\class AxisPlaneConstraint constraint.h QGLViewer/constraint.h
AxisPlaneConstraint is an interface for (translation and/or rotation) Constraint that are defined
by a direction. translationConstraintType() and rotationConstraintType() define how this
direction should be interpreted: as an axis (AxisPlaneConstraint::AXIS) or as a plane normal
(AxisPlaneConstraint::PLANE). See the Type() documentation for details.
The three implementations of this class: LocalConstraint, WorldConstraint and CameraConstraint
differ by the coordinate system in which this direction is expressed.
Different implementations of this class are illustrated in the
<a href="../examples/constrainedCamera.html">contrainedCamera</a> and
<a href="../examples/constrainedFrame.html">constrainedFrame</a> examples.
\attention When applied, the rotational Constraint may not intuitively follow the mouse
displacement. A solution would be to directly measure the rotation angle in screen coordinates,
but that would imply to know the QGLViewer::camera(), so that we can compute the projected
coordinates of the rotation center (as is done with the QGLViewer::SCREEN_ROTATE binding).
However, adding an extra pointer to the QGLViewer::camera() in all the AxisPlaneConstraint
derived classes (which the user would have to update in a multi-viewer application) was judged as
an overkill. */
class QGLVIEWER_EXPORT AxisPlaneConstraint : public Constraint
{
public:
AxisPlaneConstraint();
/*! Virtual destructor. Empty. */
virtual ~AxisPlaneConstraint() {}
/*! Type lists the different types of translation and rotation constraints that are available.
It specifies the meaning of the constraint direction (see translationConstraintDirection() and
rotationConstraintDirection()): as an axis direction (AxisPlaneConstraint::AXIS) or a plane
normal (AxisPlaneConstraint::PLANE). AxisPlaneConstraint::FREE means no constraint while
AxisPlaneConstraint::FORBIDDEN completely forbids the translation and/or the rotation.
See translationConstraintType() and rotationConstraintType().
\attention The AxisPlaneConstraint::PLANE Type is not valid for rotational constraint.
New derived classes can use their own extended enum for specific constraints:
\code
class MyAxisPlaneConstraint : public AxisPlaneConstraint
{
public:
enum MyType { FREE, AXIS, PLANE, FORBIDDEN, CUSTOM };
virtual void constrainTranslation(Vec &translation, Frame *const frame)
{
// translationConstraintType() is simply an int. CUSTOM Type is handled seamlessly.
switch (translationConstraintType())
{
case MyAxisPlaneConstraint::FREE: ... break;
case MyAxisPlaneConstraint::CUSTOM: ... break;
}
};
MyAxisPlaneConstraint* c = new MyAxisPlaneConstraint();
// Note the Type conversion
c->setTranslationConstraintType(AxisPlaneConstraint::Type(MyAxisPlaneConstraint::CUSTOM));
};
\endcode */
enum Type { FREE, AXIS, PLANE, FORBIDDEN };
/*! @name Translation constraint */
//@{
/*! Overloading of Constraint::constrainTranslation(). Empty */
virtual void constrainTranslation(Vec& translation, Frame* const frame) { Q_UNUSED(translation); Q_UNUSED(frame); };
void setTranslationConstraint(Type type, const Vec& direction);
/*! Sets the Type() of the translationConstraintType(). Default is AxisPlaneConstraint::FREE. */
void setTranslationConstraintType(Type type) { translationConstraintType_ = type; };
void setTranslationConstraintDirection(const Vec& direction);
/*! Returns the translation constraint Type().
Depending on this value, the Frame will freely translate (AxisPlaneConstraint::FREE), will only
be able to translate along an axis direction (AxisPlaneConstraint::AXIS), will be forced to stay
into a plane (AxisPlaneConstraint::PLANE) or will not able to translate at all
(AxisPlaneConstraint::FORBIDDEN).
Use Frame::setPosition() to define the position of the constrained Frame before it gets
constrained. */
Type translationConstraintType() const { return translationConstraintType_; };
/*! Returns the direction used by the translation constraint.
It represents the axis direction (AxisPlaneConstraint::AXIS) or the plane normal
(AxisPlaneConstraint::PLANE) depending on the translationConstraintType(). It is undefined for
AxisPlaneConstraint::FREE or AxisPlaneConstraint::FORBIDDEN.
The AxisPlaneConstraint derived classes express this direction in different coordinate system
(camera for CameraConstraint, local for LocalConstraint, and world for WorldConstraint). This
value can be modified with setTranslationConstraintDirection(). */
Vec translationConstraintDirection() const { return translationConstraintDir_; };
//@}
/*! @name Rotation constraint */
//@{
/*! Overloading of Constraint::constrainRotation(). Empty. */
virtual void constrainRotation(Quaternion& rotation, Frame* const frame) { Q_UNUSED(rotation); Q_UNUSED(frame); };
void setRotationConstraint(Type type, const Vec& direction);
void setRotationConstraintType(Type type);
void setRotationConstraintDirection(const Vec& direction);
/*! Returns the rotation constraint Type(). */
Type rotationConstraintType() const { return rotationConstraintType_; };
/*! Returns the axis direction used by the rotation constraint.
This direction is defined only when rotationConstraintType() is AxisPlaneConstraint::AXIS.
The AxisPlaneConstraint derived classes express this direction in different coordinate system
(camera for CameraConstraint, local for LocalConstraint, and world for WorldConstraint). This
value can be modified with setRotationConstraintDirection(). */
Vec rotationConstraintDirection() const { return rotationConstraintDir_; };
//@}
private:
// int and not Type to allow for overloading and new types definition.
Type translationConstraintType_;
Type rotationConstraintType_;
Vec translationConstraintDir_;
Vec rotationConstraintDir_;
};
/*! \brief An AxisPlaneConstraint defined in the Frame local coordinate system.
\class LocalConstraint constraint.h QGLViewer/constraint.h
The translationConstraintDirection() and rotationConstraintDirection() are expressed in the Frame
local coordinate system (see Frame::referenceFrame()).
See the <a href="../examples/constrainedFrame.html">constrainedFrame</a> example for an illustration. */
class QGLVIEWER_EXPORT LocalConstraint : public AxisPlaneConstraint
{
public:
/*! Virtual destructor. Empty. */
virtual ~LocalConstraint() {};
virtual void constrainTranslation(Vec& translation, Frame* const frame);
virtual void constrainRotation (Quaternion& rotation, Frame* const frame);
};
/*! \brief An AxisPlaneConstraint defined in the world coordinate system.
\class WorldConstraint constraint.h QGLViewer/constraint.h
The translationConstraintDirection() and rotationConstraintDirection() are expressed in world
coordinate system.
See the <a href="../examples/constrainedFrame.html">constrainedFrame</a> and <a
href="../examples/multiView.html">multiView</a> examples for an illustration. */
class QGLVIEWER_EXPORT WorldConstraint : public AxisPlaneConstraint
{
public:
/*! Virtual destructor. Empty. */
virtual ~WorldConstraint() {};
virtual void constrainTranslation(Vec& translation, Frame* const frame);
virtual void constrainRotation (Quaternion& rotation, Frame* const frame);
};
/*! \brief An AxisPlaneConstraint defined in the camera coordinate system.
\class CameraConstraint constraint.h QGLViewer/constraint.h
The translationConstraintDirection() and rotationConstraintDirection() are expressed in the
associated camera() coordinate system.
See the <a href="../examples/constrainedFrame.html">constrainedFrame</a> and <a
href="../examples/constrainedCamera.html">constrainedCamera</a> examples for an illustration. */
class QGLVIEWER_EXPORT CameraConstraint : public AxisPlaneConstraint
{
public:
explicit CameraConstraint(const Camera* const camera);
/*! Virtual destructor. Empty. */
virtual ~CameraConstraint() {};
virtual void constrainTranslation(Vec& translation, Frame* const frame);
virtual void constrainRotation (Quaternion& rotation, Frame* const frame);
/*! Returns the associated Camera. Set using the CameraConstraint constructor. */
const Camera* camera() const { return camera_; };
private:
const Camera* const camera_;
};
} // namespace qglviewer
#endif // QGLVIEWER_CONSTRAINT_H
| 14,304 | 41.19764 | 117 | h |
octomap | octomap-master/octovis/src/extern/QGLViewer/domUtils.h | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#include "config.h"
#include <QDomElement>
#include <QString>
#include <QStringList>
#include <QColor>
#include <math.h>
#ifndef DOXYGEN
// QDomElement loading with syntax checking.
class DomUtils
{
private:
static void warning(const QString& message)
{
qWarning("%s", message.toLatin1().constData());
}
public:
static qreal qrealFromDom(const QDomElement& e, const QString& attribute, qreal defValue)
{
qreal value = defValue;
if (e.hasAttribute(attribute)) {
const QString s = e.attribute(attribute);
bool ok;
value = s.toDouble(&ok);
if (!ok) {
warning(QString("'%1' is not a valid qreal syntax for attribute \"%2\" in initialization of \"%3\". Setting value to %4.")
.arg(s).arg(attribute).arg(e.tagName()).arg(QString::number(defValue)));
value = defValue;
}
} else {
warning(QString("\"%1\" attribute missing in initialization of \"%2\". Setting value to %3.")
.arg(attribute).arg(e.tagName()).arg(QString::number(value)));
}
#if defined(isnan)
// The "isnan" method may not be available on all platforms.
// Find its equivalent or simply remove these two lines
if (isnan(value))
warning(QString("Warning, attribute \"%1\" initialized to Not a Number in \"%2\"")
.arg(attribute).arg(e.tagName()));
#endif
return value;
}
static int intFromDom(const QDomElement& e, const QString& attribute, int defValue)
{
int value = defValue;
if (e.hasAttribute(attribute))
{
const QString s = e.attribute(attribute);
bool ok;
value = s.toInt(&ok);
if (!ok) {
warning(QString("'%1' is not a valid integer syntax for attribute \"%2\" in initialization of \"%3\". Setting value to %4.")
.arg(s).arg(attribute).arg(e.tagName()).arg(QString::number(defValue)));
value = defValue;
}
} else {
warning(QString("\"%1\" attribute missing in initialization of \"%2\". Setting value to %3.")
.arg(attribute).arg(e.tagName()).arg(QString::number(value)));
}
return value;
}
static unsigned int uintFromDom(const QDomElement& e, const QString& attribute, unsigned int defValue)
{
unsigned int value = defValue;
if (e.hasAttribute(attribute))
{
const QString s = e.attribute(attribute);
bool ok;
value = s.toUInt(&ok);
if (!ok) {
warning(QString("'%1' is not a valid unsigned integer syntax for attribute \"%2\" in initialization of \"%3\". Setting value to %4.")
.arg(s).arg(attribute).arg(e.tagName()).arg(QString::number(defValue)));
value = defValue;
}
} else {
warning(QString("\"%1\" attribute missing in initialization of \"%2\". Setting value to %3.")
.arg(attribute).arg(e.tagName()).arg(QString::number(value)));
}
return value;
}
static bool boolFromDom(const QDomElement& e, const QString& attribute, bool defValue)
{
bool value = defValue;
if (e.hasAttribute(attribute))
{
const QString s = e.attribute(attribute);
if (s.toLower() == QString("true"))
value = true;
else if (s.toLower() == QString("false"))
value = false;
else
{
warning(QString("'%1' is not a valid boolean syntax for attribute \"%2\" in initialization of \"%3\". Setting value to %4.")
.arg(s).arg(attribute).arg(e.tagName()).arg(defValue?"true":"false"));
}
} else {
warning(QString("\"%1\" attribute missing in initialization of \"%2\". Setting value to %3.")
.arg(attribute).arg(e.tagName()).arg(value?"true":"false"));
}
return value;
}
static void setBoolAttribute(QDomElement& element, const QString& attribute, bool value) {
element.setAttribute(attribute, (value ? "true" : "false"));
}
static QDomElement QColorDomElement(const QColor& color, const QString& name, QDomDocument& doc)
{
QDomElement de = doc.createElement(name);
de.setAttribute("red", QString::number(color.red()));
de.setAttribute("green", QString::number(color.green()));
de.setAttribute("blue", QString::number(color.blue()));
return de;
}
static QColor QColorFromDom(const QDomElement& e)
{
int color[3];
QStringList attribute;
attribute << "red" << "green" << "blue";
for (int i=0; i<attribute.count(); ++i)
color[i] = DomUtils::intFromDom(e, attribute[i], 0);
return QColor(color[0], color[1], color[2]);
}
};
#endif // DOXYGEN
| 5,216 | 31.203704 | 137 | h |
octomap | octomap-master/octovis/src/extern/QGLViewer/frame.cpp | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#include "domUtils.h"
#include "frame.h"
#include <math.h>
using namespace qglviewer;
using namespace std;
/*! Creates a default Frame.
Its position() is (0,0,0) and it has an identity orientation() Quaternion. The referenceFrame()
and the constraint() are \c NULL. */
Frame::Frame()
: constraint_(NULL), referenceFrame_(NULL)
{}
/*! Creates a Frame with a position() and an orientation().
See the Vec and Quaternion documentations for convenient constructors and methods.
The Frame is defined in the world coordinate system (its referenceFrame() is \c NULL). It
has a \c NULL associated constraint(). */
Frame::Frame(const Vec& position, const Quaternion& orientation)
: t_(position), q_(orientation), constraint_(NULL), referenceFrame_(NULL)
{}
/*! Equal operator.
The referenceFrame() and constraint() pointers are copied.
\attention Signal and slot connections are not copied. */
Frame& Frame::operator=(const Frame& frame)
{
// Automatic compiler generated version would not emit the modified() signals as is done in
// setTranslationAndRotation.
setTranslationAndRotation(frame.translation(), frame.rotation());
setConstraint(frame.constraint());
setReferenceFrame(frame.referenceFrame());
return *this;
}
/*! Copy constructor.
The translation() and rotation() as well as constraint() and referenceFrame() pointers are
copied. */
Frame::Frame(const Frame& frame)
: QObject()
{
(*this) = frame;
}
/////////////////////////////// MATRICES //////////////////////////////////////
/*! Returns the 4x4 OpenGL transformation matrix represented by the Frame.
This method should be used in conjunction with \c glMultMatrixd() to modify the OpenGL modelview
matrix from a Frame hierarchy. With this Frame hierarchy:
\code
Frame* body = new Frame();
Frame* leftArm = new Frame();
Frame* rightArm = new Frame();
leftArm->setReferenceFrame(body);
rightArm->setReferenceFrame(body);
\endcode
The associated OpenGL drawing code should look like:
\code
void Viewer::draw()
{
glPushMatrix();
glMultMatrixd(body->matrix());
drawBody();
glPushMatrix();
glMultMatrixd(leftArm->matrix());
drawArm();
glPopMatrix();
glPushMatrix();
glMultMatrixd(rightArm->matrix());
drawArm();
glPopMatrix();
glPopMatrix();
}
\endcode
Note the use of nested \c glPushMatrix() and \c glPopMatrix() blocks to represent the frame hierarchy: \c
leftArm and \c rightArm are both correctly drawn with respect to the \c body coordinate system.
This matrix only represents the local Frame transformation (i.e. with respect to the
referenceFrame()). Use worldMatrix() to get the full Frame transformation matrix (i.e. from the
world to the Frame coordinate system). These two match when the referenceFrame() is \c NULL.
The result is only valid until the next call to matrix(), getMatrix(), worldMatrix() or
getWorldMatrix(). Use it immediately (as above) or use getMatrix() instead.
\attention The OpenGL format of the result is the transpose of the actual mathematical European
representation (translation is on the last \e line instead of the last \e column).
\note The scaling factor of the 4x4 matrix is 1.0. */
const GLdouble* Frame::matrix() const
{
static GLdouble m[4][4];
getMatrix(m);
return (const GLdouble*)(m);
}
/*! \c GLdouble[4][4] version of matrix(). See also getWorldMatrix() and matrix(). */
void Frame::getMatrix(GLdouble m[4][4]) const
{
q_.getMatrix(m);
m[3][0] = t_[0];
m[3][1] = t_[1];
m[3][2] = t_[2];
}
/*! \c GLdouble[16] version of matrix(). See also getWorldMatrix() and matrix(). */
void Frame::getMatrix(GLdouble m[16]) const
{
q_.getMatrix(m);
m[12] = t_[0];
m[13] = t_[1];
m[14] = t_[2];
}
/*! Returns a Frame representing the inverse of the Frame space transformation.
The rotation() of the new Frame is the Quaternion::inverse() of the original rotation.
Its translation() is the negated inverse rotated image of the original translation.
If a Frame is considered as a space rigid transformation (translation and rotation), the inverse()
Frame performs the inverse transformation.
Only the local Frame transformation (i.e. defined with respect to the referenceFrame()) is inverted.
Use worldInverse() for a global inverse.
The resulting Frame has the same referenceFrame() as the Frame and a \c NULL constraint().
\note The scaling factor of the 4x4 matrix is 1.0. */
Frame Frame::inverse() const
{
Frame fr(-(q_.inverseRotate(t_)), q_.inverse());
fr.setReferenceFrame(referenceFrame());
return fr;
}
/*! Returns the 4x4 OpenGL transformation matrix represented by the Frame.
This method should be used in conjunction with \c glMultMatrixd() to modify
the OpenGL modelview matrix from a Frame:
\code
// The modelview here corresponds to the world coordinate system.
Frame fr(pos, Quaternion(from, to));
glPushMatrix();
glMultMatrixd(fr.worldMatrix());
// draw object in the fr coordinate system.
glPopMatrix();
\endcode
This matrix represents the global Frame transformation: the entire referenceFrame() hierarchy is
taken into account to define the Frame transformation from the world coordinate system. Use
matrix() to get the local Frame transformation matrix (i.e. defined with respect to the
referenceFrame()). These two match when the referenceFrame() is \c NULL.
The OpenGL format of the result is the transpose of the actual mathematical European
representation (translation is on the last \e line instead of the last \e column).
\attention The result is only valid until the next call to matrix(), getMatrix(), worldMatrix() or
getWorldMatrix(). Use it immediately (as above) or use getWorldMatrix() instead.
\note The scaling factor of the 4x4 matrix is 1.0. */
const GLdouble* Frame::worldMatrix() const
{
// This test is done for efficiency reasons (creates lots of temp objects otherwise).
if (referenceFrame())
{
static Frame fr;
fr.setTranslation(position());
fr.setRotation(orientation());
return fr.matrix();
}
else
return matrix();
}
/*! qreal[4][4] parameter version of worldMatrix(). See also getMatrix() and matrix(). */
void Frame::getWorldMatrix(GLdouble m[4][4]) const
{
const GLdouble* mat = worldMatrix();
for (int i=0; i<4; ++i)
for (int j=0; j<4; ++j)
m[i][j] = mat[i*4+j];
}
/*! qreal[16] parameter version of worldMatrix(). See also getMatrix() and matrix(). */
void Frame::getWorldMatrix(GLdouble m[16]) const
{
const GLdouble* mat = worldMatrix();
for (int i=0; i<16; ++i)
m[i] = mat[i];
}
/*! This is an overloaded method provided for convenience. Same as setFromMatrix(). */
void Frame::setFromMatrix(const GLdouble m[4][4])
{
if (fabs(m[3][3]) < 1E-8)
{
qWarning("Frame::setFromMatrix: Null homogeneous coefficient");
return;
}
qreal rot[3][3];
for (int i=0; i<3; ++i)
{
t_[i] = m[3][i] / m[3][3];
for (int j=0; j<3; ++j)
// Beware of the transposition (OpenGL to European math)
rot[i][j] = m[j][i] / m[3][3];
}
q_.setFromRotationMatrix(rot);
Q_EMIT modified();
}
/*! Sets the Frame from an OpenGL matrix representation (rotation in the upper left 3x3 matrix and
translation on the last line).
Hence, if a code fragment looks like:
\code
GLdouble m[16]={...};
glMultMatrixd(m);
\endcode
It is equivalent to write:
\code
Frame fr;
fr.setFromMatrix(m);
glMultMatrixd(fr.matrix());
\endcode
Using this conversion, you can benefit from the powerful Frame transformation methods to translate
points and vectors to and from the Frame coordinate system to any other Frame coordinate system
(including the world coordinate system). See coordinatesOf() and transformOf().
Emits the modified() signal. See also matrix(), getMatrix() and
Quaternion::setFromRotationMatrix().
\attention A Frame does not contain a scale factor. The possible scaling in \p m will not be
converted into the Frame by this method. */
void Frame::setFromMatrix(const GLdouble m[16])
{
GLdouble mat[4][4];
for (int i=0; i<4; ++i)
for (int j=0; j<4; ++j)
mat[i][j] = m[i*4+j];
setFromMatrix(mat);
}
//////////////////// SET AND GET LOCAL TRANSLATION AND ROTATION ///////////////////////////////
/*! Same as setTranslation(), but with \p qreal parameters. */
void Frame::setTranslation(qreal x, qreal y, qreal z)
{
setTranslation(Vec(x, y, z));
}
/*! Fill \c x, \c y and \c z with the translation() of the Frame. */
void Frame::getTranslation(qreal& x, qreal& y, qreal& z) const
{
const Vec t = translation();
x = t[0];
y = t[1];
z = t[2];
}
/*! Same as setRotation() but with \c qreal Quaternion parameters. */
void Frame::setRotation(qreal q0, qreal q1, qreal q2, qreal q3)
{
setRotation(Quaternion(q0, q1, q2, q3));
}
/*! The \p q are set to the rotation() of the Frame.
See Quaternion::Quaternion(qreal, qreal, qreal, qreal) for details on \c q. */
void Frame::getRotation(qreal& q0, qreal& q1, qreal& q2, qreal& q3) const
{
const Quaternion q = rotation();
q0 = q[0];
q1 = q[1];
q2 = q[2];
q3 = q[3];
}
////////////////////////////////////////////////////////////////////////////////
/*! Translates the Frame of \p t (defined in the Frame coordinate system).
The translation actually applied to the Frame may differ from \p t since it can be filtered by the
constraint(). Use translate(Vec&) or setTranslationWithConstraint() to retrieve the filtered
translation value. Use setTranslation() to directly translate the Frame without taking the
constraint() into account.
See also rotate(const Quaternion&). Emits the modified() signal. */
void Frame::translate(const Vec& t)
{
Vec tbis = t;
translate(tbis);
}
/*! Same as translate(const Vec&) but \p t may be modified to satisfy the translation constraint().
Its new value corresponds to the translation that has actually been applied to the Frame. */
void Frame::translate(Vec& t)
{
if (constraint())
constraint()->constrainTranslation(t, this);
t_ += t;
Q_EMIT modified();
}
/*! Same as translate(const Vec&) but with \c qreal parameters. */
void Frame::translate(qreal x, qreal y, qreal z)
{
Vec t(x,y,z);
translate(t);
}
/*! Same as translate(Vec&) but with \c qreal parameters. */
void Frame::translate(qreal& x, qreal& y, qreal& z)
{
Vec t(x,y,z);
translate(t);
x = t[0];
y = t[1];
z = t[2];
}
/*! Rotates the Frame by \p q (defined in the Frame coordinate system): R = R*q.
The rotation actually applied to the Frame may differ from \p q since it can be filtered by the
constraint(). Use rotate(Quaternion&) or setRotationWithConstraint() to retrieve the filtered
rotation value. Use setRotation() to directly rotate the Frame without taking the constraint()
into account.
See also translate(const Vec&). Emits the modified() signal. */
void Frame::rotate(const Quaternion& q)
{
Quaternion qbis = q;
rotate(qbis);
}
/*! Same as rotate(const Quaternion&) but \p q may be modified to satisfy the rotation constraint().
Its new value corresponds to the rotation that has actually been applied to the Frame. */
void Frame::rotate(Quaternion& q)
{
if (constraint())
constraint()->constrainRotation(q, this);
q_ *= q;
q_.normalize(); // Prevents numerical drift
Q_EMIT modified();
}
/*! Same as rotate(Quaternion&) but with \c qreal Quaternion parameters. */
void Frame::rotate(qreal& q0, qreal& q1, qreal& q2, qreal& q3)
{
Quaternion q(q0,q1,q2,q3);
rotate(q);
q0 = q[0];
q1 = q[1];
q2 = q[2];
q3 = q[3];
}
/*! Same as rotate(const Quaternion&) but with \c qreal Quaternion parameters. */
void Frame::rotate(qreal q0, qreal q1, qreal q2, qreal q3)
{
Quaternion q(q0,q1,q2,q3);
rotate(q);
}
/*! Makes the Frame rotate() by \p rotation around \p point.
\p point is defined in the world coordinate system, while the \p rotation axis is defined in the
Frame coordinate system.
If the Frame has a constraint(), \p rotation is first constrained using
Constraint::constrainRotation(). The translation which results from the filtered rotation around
\p point is then computed and filtered using Constraint::constrainTranslation(). The new \p
rotation value corresponds to the rotation that has actually been applied to the Frame.
Emits the modified() signal. */
void Frame::rotateAroundPoint(Quaternion& rotation, const Vec& point)
{
if (constraint())
constraint()->constrainRotation(rotation, this);
q_ *= rotation;
q_.normalize(); // Prevents numerical drift
Vec trans = point + Quaternion(inverseTransformOf(rotation.axis()), rotation.angle()).rotate(position()-point) - t_;
if (constraint())
constraint()->constrainTranslation(trans, this);
t_ += trans;
Q_EMIT modified();
}
/*! Same as rotateAroundPoint(), but with a \c const \p rotation Quaternion. Note that the actual
rotation may differ since it can be filtered by the constraint(). */
void Frame::rotateAroundPoint(const Quaternion& rotation, const Vec& point)
{
Quaternion rot = rotation;
rotateAroundPoint(rot, point);
}
//////////////////// SET AND GET WORLD POSITION AND ORIENTATION ///////////////////////////////
/*! Sets the position() of the Frame, defined in the world coordinate system. Emits the modified()
signal.
Use setTranslation() to define the \e local frame translation (with respect to the
referenceFrame()). The potential constraint() of the Frame is not taken into account, use
setPositionWithConstraint() instead. */
void Frame::setPosition(const Vec& position)
{
if (referenceFrame())
setTranslation(referenceFrame()->coordinatesOf(position));
else
setTranslation(position);
}
/*! Same as setPosition(), but with \c qreal parameters. */
void Frame::setPosition(qreal x, qreal y, qreal z)
{
setPosition(Vec(x, y, z));
}
/*! Same as successive calls to setPosition() and then setOrientation().
Only one modified() signal is emitted, which is convenient if this signal is connected to a
QGLViewer::update() slot. See also setTranslationAndRotation() and
setPositionAndOrientationWithConstraint(). */
void Frame::setPositionAndOrientation(const Vec& position, const Quaternion& orientation)
{
if (referenceFrame())
{
t_ = referenceFrame()->coordinatesOf(position);
q_ = referenceFrame()->orientation().inverse() * orientation;
}
else
{
t_ = position;
q_ = orientation;
}
Q_EMIT modified();
}
/*! Same as successive calls to setTranslation() and then setRotation().
Only one modified() signal is emitted, which is convenient if this signal is connected to a
QGLViewer::update() slot. See also setPositionAndOrientation() and
setTranslationAndRotationWithConstraint(). */
void Frame::setTranslationAndRotation(const Vec& translation, const Quaternion& rotation)
{
t_ = translation;
q_ = rotation;
Q_EMIT modified();
}
/*! \p x, \p y and \p z are set to the position() of the Frame. */
void Frame::getPosition(qreal& x, qreal& y, qreal& z) const
{
Vec p = position();
x = p.x;
y = p.y;
z = p.z;
}
/*! Sets the orientation() of the Frame, defined in the world coordinate system. Emits the modified() signal.
Use setRotation() to define the \e local frame rotation (with respect to the referenceFrame()). The
potential constraint() of the Frame is not taken into account, use setOrientationWithConstraint()
instead. */
void Frame::setOrientation(const Quaternion& orientation)
{
if (referenceFrame())
setRotation(referenceFrame()->orientation().inverse() * orientation);
else
setRotation(orientation);
}
/*! Same as setOrientation(), but with \c qreal parameters. */
void Frame::setOrientation(qreal q0, qreal q1, qreal q2, qreal q3)
{
setOrientation(Quaternion(q0, q1, q2, q3));
}
/*! Get the current orientation of the frame (same as orientation()).
Parameters are the orientation Quaternion values.
See also setOrientation(). */
/*! The \p q are set to the orientation() of the Frame.
See Quaternion::Quaternion(qreal, qreal, qreal, qreal) for details on \c q. */
void Frame::getOrientation(qreal& q0, qreal& q1, qreal& q2, qreal& q3) const
{
Quaternion o = orientation();
q0 = o[0];
q1 = o[1];
q2 = o[2];
q3 = o[3];
}
/*! Returns the position of the Frame, defined in the world coordinate system. See also
orientation(), setPosition() and translation(). */
Vec Frame::position() const {
if (referenceFrame_)
return inverseCoordinatesOf(Vec(0.0,0.0,0.0));
else
return t_;
}
/*! Returns the orientation of the Frame, defined in the world coordinate system. See also
position(), setOrientation() and rotation(). */
Quaternion Frame::orientation() const
{
Quaternion res = rotation();
const Frame* fr = referenceFrame();
while (fr != NULL)
{
res = fr->rotation() * res;
fr = fr->referenceFrame();
}
return res;
}
////////////////////// C o n s t r a i n t V e r s i o n s //////////////////////////
/*! Same as setTranslation(), but \p translation is modified so that the potential constraint() of the
Frame is satisfied.
Emits the modified() signal. See also setRotationWithConstraint() and setPositionWithConstraint(). */
void Frame::setTranslationWithConstraint(Vec& translation)
{
Vec deltaT = translation - this->translation();
if (constraint())
constraint()->constrainTranslation(deltaT, this);
setTranslation(this->translation() + deltaT);
translation = this->translation();
}
/*! Same as setRotation(), but \p rotation is modified so that the potential constraint() of the
Frame is satisfied.
Emits the modified() signal. See also setTranslationWithConstraint() and setOrientationWithConstraint(). */
void Frame::setRotationWithConstraint(Quaternion& rotation)
{
Quaternion deltaQ = this->rotation().inverse() * rotation;
if (constraint())
constraint()->constrainRotation(deltaQ, this);
// Prevent numerical drift
deltaQ.normalize();
setRotation(this->rotation() * deltaQ);
q_.normalize();
rotation = this->rotation();
}
/*! Same as setTranslationAndRotation(), but \p translation and \p orientation are modified to
satisfy the constraint(). Emits the modified() signal. */
void Frame::setTranslationAndRotationWithConstraint(Vec& translation, Quaternion& rotation)
{
Vec deltaT = translation - this->translation();
Quaternion deltaQ = this->rotation().inverse() * rotation;
if (constraint())
{
constraint()->constrainTranslation(deltaT, this);
constraint()->constrainRotation(deltaQ, this);
}
// Prevent numerical drift
deltaQ.normalize();
t_ += deltaT;
q_ *= deltaQ;
q_.normalize();
translation = this->translation();
rotation = this->rotation();
Q_EMIT modified();
}
/*! Same as setPosition(), but \p position is modified so that the potential constraint() of the
Frame is satisfied. See also setOrientationWithConstraint() and setTranslationWithConstraint(). */
void Frame::setPositionWithConstraint(Vec& position)
{
if (referenceFrame())
position = referenceFrame()->coordinatesOf(position);
setTranslationWithConstraint(position);
}
/*! Same as setOrientation(), but \p orientation is modified so that the potential constraint() of the Frame
is satisfied. See also setPositionWithConstraint() and setRotationWithConstraint(). */
void Frame::setOrientationWithConstraint(Quaternion& orientation)
{
if (referenceFrame())
orientation = referenceFrame()->orientation().inverse() * orientation;
setRotationWithConstraint(orientation);
}
/*! Same as setPositionAndOrientation() but \p position and \p orientation are modified to satisfy
the constraint. Emits the modified() signal. */
void Frame::setPositionAndOrientationWithConstraint(Vec& position, Quaternion& orientation)
{
if (referenceFrame())
{
position = referenceFrame()->coordinatesOf(position);
orientation = referenceFrame()->orientation().inverse() * orientation;
}
setTranslationAndRotationWithConstraint(position, orientation);
}
///////////////////////////// REFERENCE FRAMES ///////////////////////////////////////
/*! Sets the referenceFrame() of the Frame.
The Frame translation() and rotation() are then defined in the referenceFrame() coordinate system.
Use position() and orientation() to express these in the world coordinate system.
Emits the modified() signal if \p refFrame differs from the current referenceFrame().
Using this method, you can create a hierarchy of Frames. This hierarchy needs to be a tree, which
root is the world coordinate system (i.e. a \c NULL referenceFrame()). A warning is printed and no
action is performed if setting \p refFrame as the referenceFrame() would create a loop in the Frame
hierarchy (see settingAsReferenceFrameWillCreateALoop()). */
void Frame::setReferenceFrame(const Frame* const refFrame)
{
if (settingAsReferenceFrameWillCreateALoop(refFrame))
qWarning("Frame::setReferenceFrame would create a loop in Frame hierarchy");
else
{
bool identical = (referenceFrame_ == refFrame);
referenceFrame_ = refFrame;
if (!identical)
Q_EMIT modified();
}
}
/*! Returns \c true if setting \p frame as the Frame's referenceFrame() would create a loop in the
Frame hierarchy. */
bool Frame::settingAsReferenceFrameWillCreateALoop(const Frame* const frame)
{
const Frame* f = frame;
while (f != NULL)
{
if (f == this)
return true;
f = f->referenceFrame();
}
return false;
}
///////////////////////// FRAME TRANSFORMATIONS OF 3D POINTS //////////////////////////////
/*! Returns the Frame coordinates of a point \p src defined in the world coordinate system (converts
from world to Frame).
inverseCoordinatesOf() performs the inverse convertion. transformOf() converts 3D vectors instead
of 3D coordinates.
See the <a href="../examples/frameTransform.html">frameTransform example</a> for an
illustration. */
Vec Frame::coordinatesOf(const Vec& src) const
{
if (referenceFrame())
return localCoordinatesOf(referenceFrame()->coordinatesOf(src));
else
return localCoordinatesOf(src);
}
/*! Returns the world coordinates of the point whose position in the Frame coordinate system is \p
src (converts from Frame to world).
coordinatesOf() performs the inverse convertion. Use inverseTransformOf() to transform 3D vectors
instead of 3D coordinates. */
Vec Frame::inverseCoordinatesOf(const Vec& src) const
{
const Frame* fr = this;
Vec res = src;
while (fr != NULL)
{
res = fr->localInverseCoordinatesOf(res);
fr = fr->referenceFrame();
}
return res;
}
/*! Returns the Frame coordinates of a point \p src defined in the referenceFrame() coordinate
system (converts from referenceFrame() to Frame).
localInverseCoordinatesOf() performs the inverse convertion. See also localTransformOf(). */
Vec Frame::localCoordinatesOf(const Vec& src) const
{
return rotation().inverseRotate(src - translation());
}
/*! Returns the referenceFrame() coordinates of a point \p src defined in the Frame coordinate
system (converts from Frame to referenceFrame()).
localCoordinatesOf() performs the inverse convertion. See also localInverseTransformOf(). */
Vec Frame::localInverseCoordinatesOf(const Vec& src) const
{
return rotation().rotate(src) + translation();
}
/*! Returns the Frame coordinates of the point whose position in the \p from coordinate system is \p
src (converts from \p from to Frame).
coordinatesOfIn() performs the inverse transformation. */
Vec Frame::coordinatesOfFrom(const Vec& src, const Frame* const from) const
{
if (this == from)
return src;
else
if (referenceFrame())
return localCoordinatesOf(referenceFrame()->coordinatesOfFrom(src, from));
else
return localCoordinatesOf(from->inverseCoordinatesOf(src));
}
/*! Returns the \p in coordinates of the point whose position in the Frame coordinate system is \p
src (converts from Frame to \p in).
coordinatesOfFrom() performs the inverse transformation. */
Vec Frame::coordinatesOfIn(const Vec& src, const Frame* const in) const
{
const Frame* fr = this;
Vec res = src;
while ((fr != NULL) && (fr != in))
{
res = fr->localInverseCoordinatesOf(res);
fr = fr->referenceFrame();
}
if (fr != in)
// in was not found in the branch of this, res is now expressed in the world
// coordinate system. Simply convert to in coordinate system.
res = in->coordinatesOf(res);
return res;
}
////// qreal[3] versions
/*! Same as coordinatesOf(), but with \c qreal parameters. */
void Frame::getCoordinatesOf(const qreal src[3], qreal res[3]) const
{
const Vec r = coordinatesOf(Vec(src));
for (int i=0; i<3 ; ++i)
res[i] = r[i];
}
/*! Same as inverseCoordinatesOf(), but with \c qreal parameters. */
void Frame::getInverseCoordinatesOf(const qreal src[3], qreal res[3]) const
{
const Vec r = inverseCoordinatesOf(Vec(src));
for (int i=0; i<3 ; ++i)
res[i] = r[i];
}
/*! Same as localCoordinatesOf(), but with \c qreal parameters. */
void Frame::getLocalCoordinatesOf(const qreal src[3], qreal res[3]) const
{
const Vec r = localCoordinatesOf(Vec(src));
for (int i=0; i<3 ; ++i)
res[i] = r[i];
}
/*! Same as localInverseCoordinatesOf(), but with \c qreal parameters. */
void Frame::getLocalInverseCoordinatesOf(const qreal src[3], qreal res[3]) const
{
const Vec r = localInverseCoordinatesOf(Vec(src));
for (int i=0; i<3 ; ++i)
res[i] = r[i];
}
/*! Same as coordinatesOfIn(), but with \c qreal parameters. */
void Frame::getCoordinatesOfIn(const qreal src[3], qreal res[3], const Frame* const in) const
{
const Vec r = coordinatesOfIn(Vec(src), in);
for (int i=0; i<3 ; ++i)
res[i] = r[i];
}
/*! Same as coordinatesOfFrom(), but with \c qreal parameters. */
void Frame::getCoordinatesOfFrom(const qreal src[3], qreal res[3], const Frame* const from) const
{
const Vec r = coordinatesOfFrom(Vec(src), from);
for (int i=0; i<3 ; ++i)
res[i] = r[i];
}
///////////////////////// FRAME TRANSFORMATIONS OF VECTORS //////////////////////////////
/*! Returns the Frame transform of a vector \p src defined in the world coordinate system (converts
vectors from world to Frame).
inverseTransformOf() performs the inverse transformation. coordinatesOf() converts 3D coordinates
instead of 3D vectors (here only the rotational part of the transformation is taken into account).
See the <a href="../examples/frameTransform.html">frameTransform example</a> for an
illustration. */
Vec Frame::transformOf(const Vec& src) const
{
if (referenceFrame())
return localTransformOf(referenceFrame()->transformOf(src));
else
return localTransformOf(src);
}
/*! Returns the world transform of the vector whose coordinates in the Frame coordinate
system is \p src (converts vectors from Frame to world).
transformOf() performs the inverse transformation. Use inverseCoordinatesOf() to transform 3D
coordinates instead of 3D vectors. */
Vec Frame::inverseTransformOf(const Vec& src) const
{
const Frame* fr = this;
Vec res = src;
while (fr != NULL)
{
res = fr->localInverseTransformOf(res);
fr = fr->referenceFrame();
}
return res;
}
/*! Returns the Frame transform of a vector \p src defined in the referenceFrame() coordinate system
(converts vectors from referenceFrame() to Frame).
localInverseTransformOf() performs the inverse transformation. See also localCoordinatesOf(). */
Vec Frame::localTransformOf(const Vec& src) const
{
return rotation().inverseRotate(src);
}
/*! Returns the referenceFrame() transform of a vector \p src defined in the Frame coordinate
system (converts vectors from Frame to referenceFrame()).
localTransformOf() performs the inverse transformation. See also localInverseCoordinatesOf(). */
Vec Frame::localInverseTransformOf(const Vec& src) const
{
return rotation().rotate(src);
}
/*! Returns the Frame transform of the vector whose coordinates in the \p from coordinate system is \p
src (converts vectors from \p from to Frame).
transformOfIn() performs the inverse transformation. */
Vec Frame::transformOfFrom(const Vec& src, const Frame* const from) const
{
if (this == from)
return src;
else
if (referenceFrame())
return localTransformOf(referenceFrame()->transformOfFrom(src, from));
else
return localTransformOf(from->inverseTransformOf(src));
}
/*! Returns the \p in transform of the vector whose coordinates in the Frame coordinate system is \p
src (converts vectors from Frame to \p in).
transformOfFrom() performs the inverse transformation. */
Vec Frame::transformOfIn(const Vec& src, const Frame* const in) const
{
const Frame* fr = this;
Vec res = src;
while ((fr != NULL) && (fr != in))
{
res = fr->localInverseTransformOf(res);
fr = fr->referenceFrame();
}
if (fr != in)
// in was not found in the branch of this, res is now expressed in the world
// coordinate system. Simply convert to in coordinate system.
res = in->transformOf(res);
return res;
}
///////////////// qreal[3] versions //////////////////////
/*! Same as transformOf(), but with \c qreal parameters. */
void Frame::getTransformOf(const qreal src[3], qreal res[3]) const
{
Vec r = transformOf(Vec(src));
for (int i=0; i<3 ; ++i)
res[i] = r[i];
}
/*! Same as inverseTransformOf(), but with \c qreal parameters. */
void Frame::getInverseTransformOf(const qreal src[3], qreal res[3]) const
{
Vec r = inverseTransformOf(Vec(src));
for (int i=0; i<3 ; ++i)
res[i] = r[i];
}
/*! Same as localTransformOf(), but with \c qreal parameters. */
void Frame::getLocalTransformOf(const qreal src[3], qreal res[3]) const
{
Vec r = localTransformOf(Vec(src));
for (int i=0; i<3 ; ++i)
res[i] = r[i];
}
/*! Same as localInverseTransformOf(), but with \c qreal parameters. */
void Frame::getLocalInverseTransformOf(const qreal src[3], qreal res[3]) const
{
Vec r = localInverseTransformOf(Vec(src));
for (int i=0; i<3 ; ++i)
res[i] = r[i];
}
/*! Same as transformOfIn(), but with \c qreal parameters. */
void Frame::getTransformOfIn(const qreal src[3], qreal res[3], const Frame* const in) const
{
Vec r = transformOfIn(Vec(src), in);
for (int i=0; i<3 ; ++i)
res[i] = r[i];
}
/*! Same as transformOfFrom(), but with \c qreal parameters. */
void Frame::getTransformOfFrom(const qreal src[3], qreal res[3], const Frame* const from) const
{
Vec r = transformOfFrom(Vec(src), from);
for (int i=0; i<3 ; ++i)
res[i] = r[i];
}
//////////////////////////// STATE //////////////////////////////
/*! Returns an XML \c QDomElement that represents the Frame.
\p name is the name of the QDomElement tag. \p doc is the \c QDomDocument factory used to create
QDomElement.
The resulting QDomElement looks like:
\code
<name>
<position x=".." y=".." z=".." />
<orientation q0=".." q1=".." q2=".." q3=".." />
</name>
\endcode
Use initFromDOMElement() to restore the Frame state from the resulting \c QDomElement.
See Vec::domElement() for a complete example. See also Quaternion::domElement(),
Camera::domElement()...
\attention The constraint() and referenceFrame() are not saved in the QDomElement. */
QDomElement Frame::domElement(const QString& name, QDomDocument& document) const
{
// TODO: use translation and rotation instead when referenceFrame is coded...
QDomElement e = document.createElement(name);
e.appendChild(position().domElement("position", document));
e.appendChild(orientation().domElement("orientation", document));
return e;
}
/*! Restores the Frame state from a \c QDomElement created by domElement().
See domElement() for the \c QDomElement syntax. See the Vec::initFromDOMElement() and
Quaternion::initFromDOMElement() documentations for details on default values if an argument is
missing.
\attention The constraint() and referenceFrame() are not restored by this method and are left
unchanged. */
void Frame::initFromDOMElement(const QDomElement& element)
{
// TODO: use translation and rotation instead when referenceFrame is coded...
// Reset default values. Attention: destroys constraint.
// *this = Frame();
// This instead ? Better : what is not set is not changed.
// setPositionAndOrientation(Vec(), Quaternion());
QDomElement child=element.firstChild().toElement();
while (!child.isNull())
{
if (child.tagName() == "position")
setPosition(Vec(child));
if (child.tagName() == "orientation")
setOrientation(Quaternion(child).normalized());
child = child.nextSibling().toElement();
}
}
///////////////////////////////// ALIGN /////////////////////////////////
/*! Aligns the Frame with \p frame, so that two of their axis are parallel.
If one of the X, Y and Z axis of the Frame is almost parallel to any of the X, Y, or Z axis of \p
frame, the Frame is rotated so that these two axis actually become parallel.
If, after this first rotation, two other axis are also almost parallel, a second alignment is
performed. The two frames then have identical orientations, up to 90 degrees rotations.
\p threshold measures how close two axis must be to be considered parallel. It is compared with the
absolute values of the dot product of the normalized axis. As a result, useful range is sqrt(2)/2
(systematic alignment) to 1 (no alignment).
When \p move is set to \c true, the Frame position() is also affected by the alignment. The new
Frame's position() is such that the \p frame position (computed with coordinatesOf(), in the Frame
coordinates system) does not change.
\p frame may be \c NULL and then represents the world coordinate system (same convention than for
the referenceFrame()).
The rotation (and translation when \p move is \c true) applied to the Frame are filtered by the
possible constraint(). */
void Frame::alignWithFrame(const Frame* const frame, bool move, qreal threshold)
{
Vec directions[2][3];
for (unsigned short d=0; d<3; ++d)
{
Vec dir((d==0)? 1.0 : 0.0, (d==1)? 1.0 : 0.0, (d==2)? 1.0 : 0.0);
if (frame)
directions[0][d] = frame->inverseTransformOf(dir);
else
directions[0][d] = dir;
directions[1][d] = inverseTransformOf(dir);
}
qreal maxProj = 0.0;
qreal proj;
unsigned short index[2];
index[0] = index[1] = 0;
for (unsigned short i=0; i<3; ++i)
for (unsigned short j=0; j<3; ++j)
if ( (proj=fabs(directions[0][i]*directions[1][j])) >= maxProj )
{
index[0] = i;
index[1] = j;
maxProj = proj;
}
Frame old;
old=*this;
qreal coef = directions[0][index[0]] * directions[1][index[1]];
if (fabs(coef) >= threshold)
{
const Vec axis = cross(directions[0][index[0]], directions[1][index[1]]);
qreal angle = asin(axis.norm());
if (coef >= 0.0)
angle = -angle;
rotate(rotation().inverse() * Quaternion(axis, angle) * orientation());
// Try to align an other axis direction
unsigned short d = (index[1]+1) % 3;
Vec dir((d==0)? 1.0 : 0.0, (d==1)? 1.0 : 0.0, (d==2)? 1.0 : 0.0);
dir = inverseTransformOf(dir);
qreal max = 0.0;
for (unsigned short i=0; i<3; ++i)
{
qreal proj = fabs(directions[0][i]*dir);
if (proj > max)
{
index[0] = i;
max = proj;
}
}
if (max >= threshold)
{
const Vec axis = cross(directions[0][index[0]], dir);
qreal angle = asin(axis.norm());
if (directions[0][index[0]] * dir >= 0.0)
angle = -angle;
rotate(rotation().inverse() * Quaternion(axis, angle) * orientation());
}
}
if (move)
{
Vec center;
if (frame)
center = frame->position();
translate(center - orientation().rotate(old.coordinatesOf(center)) - translation());
}
}
/*! Translates the Frame so that its position() lies on the line defined by \p origin and \p
direction (defined in the world coordinate system).
Simply uses an orthogonal projection. \p direction does not need to be normalized. */
void Frame::projectOnLine(const Vec& origin, const Vec& direction)
{
// If you are trying to find a bug here, because of memory problems, you waste your time.
// This is a bug in the gcc 3.3 compiler. Compile the library in debug mode and test.
// Uncommenting this line also seems to solve the problem. Horrible.
// cout << "position = " << position() << endl;
// If you found a problem or are using a different compiler, please let me know.
const Vec shift = origin - position();
Vec proj = shift;
proj.projectOnAxis(direction);
translate(shift-proj);
}
| 36,875 | 31.206114 | 117 | cpp |
octomap | octomap-master/octovis/src/extern/QGLViewer/frame.h | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#ifndef QGLVIEWER_FRAME_H
#define QGLVIEWER_FRAME_H
#include <QObject>
#include <QString>
#include "constraint.h"
// #include "GL/gl.h" is now included in config.h for ease of configuration
namespace qglviewer {
/*! \brief The Frame class represents a coordinate system, defined by a position and an
orientation. \class Frame frame.h QGLViewer/frame.h
A Frame is a 3D coordinate system, represented by a position() and an orientation(). The order of
these transformations is important: the Frame is first translated \e and \e then rotated around
the new translated origin.
A Frame is useful to define the position and orientation of a 3D rigid object, using its matrix()
method, as shown below:
\code
// Builds a Frame at position (0.5,0,0) and oriented such that its Y axis is along the (1,1,1)
// direction. One could also have used setPosition() and setOrientation().
Frame fr(Vec(0.5,0,0), Quaternion(Vec(0,1,0), Vec(1,1,1)));
glPushMatrix();
glMultMatrixd(fr.matrix());
// Draw your object here, in the local fr coordinate system.
glPopMatrix();
\endcode
Many functions are provided to transform a 3D point from one coordinate system (Frame) to an
other: see coordinatesOf(), inverseCoordinatesOf(), coordinatesOfIn(), coordinatesOfFrom()...
You may also want to transform a 3D vector (such as a normal), which corresponds to applying only
the rotational part of the frame transformation: see transformOf() and inverseTransformOf(). See
the <a href="../examples/frameTransform.html">frameTransform example</a> for an illustration.
The translation() and the rotation() that are encapsulated in a Frame can also be used to
represent a \e rigid \e transformation of space. Such a transformation can also be interpreted as
a change of coordinate system, and the coordinate system conversion functions actually allow you
to use a Frame as a rigid transformation. Use inverseCoordinatesOf() (resp. coordinatesOf()) to
apply the transformation (resp. its inverse). Note the inversion.
<h3>Hierarchy of Frames</h3>
The position and the orientation of a Frame are actually defined with respect to a
referenceFrame(). The default referenceFrame() is the world coordinate system (represented by a \c
NULL referenceFrame()). If you setReferenceFrame() to a different Frame, you must then
differentiate:
\arg the \e local translation() and rotation(), defined with respect to the referenceFrame(),
\arg the \e global position() and orientation(), always defined with respect to the world
coordinate system.
A Frame is actually defined by its translation() with respect to its referenceFrame(), and then by
a rotation() of the coordinate system around the new translated origin.
This terminology for \e local (translation() and rotation()) and \e global (position() and
orientation()) definitions is used in all the methods' names and should be sufficient to prevent
ambiguities. These notions are obviously identical when the referenceFrame() is \c NULL, i.e. when
the Frame is defined in the world coordinate system (the one you are in at the beginning of the
QGLViewer::draw() method, see the <a href="../introduction.html">introduction page</a>).
Frames can hence easily be organized in a tree hierarchy, which root is the world coordinate
system. A loop in the hierarchy would result in an inconsistent (multiple) Frame definition.
settingAsReferenceFrameWillCreateALoop() checks this and prevents setReferenceFrame() from
creating such a loop.
This frame hierarchy is used in methods like coordinatesOfIn(), coordinatesOfFrom()... which allow
coordinates (or vector) conversions from a Frame to any other one (including the world coordinate
system).
However, one must note that this hierarchical representation is internal to the Frame classes.
When the Frames represent OpenGL coordinates system, one should map this hierarchical
representation to the OpenGL GL_MODELVIEW matrix stack. See the matrix() documentation for
details.
<h3>Constraints</h3>
An interesting feature of Frames is that their displacements can be constrained. When a Constraint
is attached to a Frame, it filters the input of translate() and rotate(), and only the resulting
filtered motion is applied to the Frame. The default constraint() is \c NULL resulting in no
filtering. Use setConstraint() to attach a Constraint to a frame.
Constraints are especially usefull for the ManipulatedFrame instances, in order to forbid some
mouse motions. See the <a href="../examples/constrainedFrame.html">constrainedFrame</a>, <a
href="../examples/constrainedCamera.html">constrainedCamera</a> and <a
href="../examples/luxo.html">luxo</a> examples for an illustration.
Classical constraints are provided for convenience (see LocalConstraint, WorldConstraint and
CameraConstraint) and new constraints can very easily be implemented.
<h3>Derived classes</h3>
The ManipulatedFrame class inherits Frame and implements a mouse motion convertion, so that a
Frame (and hence an object) can be manipulated in the scene with the mouse.
\nosubgrouping */
class QGLVIEWER_EXPORT Frame : public QObject
{
Q_OBJECT
public:
Frame();
/*! Virtual destructor. Empty. */
virtual ~Frame() {}
Frame(const Frame& frame);
Frame& operator=(const Frame& frame);
Q_SIGNALS:
/*! This signal is emitted whenever the position() or the orientation() of the Frame is modified.
Connect this signal to any object that must be notified:
\code
QObject::connect(myFrame, SIGNAL(modified()), myObject, SLOT(update()));
\endcode
Use the QGLViewer::QGLViewerPool() to connect the signal to all the viewers.
\note If your Frame is part of a Frame hierarchy (see referenceFrame()), a modification of one
of the parents of this Frame will \e not emit this signal. Use code like this to change this
behavior (you can do this recursively for all the referenceFrame() until the \c NULL world root
frame is encountered):
\code
// Emits the Frame modified() signal when its referenceFrame() is modified().
connect(myFrame->referenceFrame(), SIGNAL(modified()), myFrame, SIGNAL(modified()));
\endcode
\attention Connecting this signal to a QGLWidget::update() slot (or a method that calls it)
will prevent you from modifying the Frame \e inside your QGLViewer::draw() method as it would
result in an infinite loop. However, QGLViewer::draw() should not modify the scene.
\note Note that this signal might be emitted even if the Frame is not actually modified, for
instance after a translate(Vec(0,0,0)) or a setPosition(position()). */
void modified();
/*! This signal is emitted when the Frame is interpolated by a KeyFrameInterpolator.
See the KeyFrameInterpolator documentation for details.
If a KeyFrameInterpolator is used to successively interpolate several Frames in your scene,
connect the KeyFrameInterpolator::interpolated() signal instead (identical, but independent of
the interpolated Frame). */
void interpolated();
public:
/*! @name World coordinates position and orientation */
//@{
Frame(const Vec& position, const Quaternion& orientation);
void setPosition(const Vec& position);
void setPosition(qreal x, qreal y, qreal z);
void setPositionWithConstraint(Vec& position);
void setOrientation(const Quaternion& orientation);
void setOrientation(qreal q0, qreal q1, qreal q2, qreal q3);
void setOrientationWithConstraint(Quaternion& orientation);
void setPositionAndOrientation(const Vec& position, const Quaternion& orientation);
void setPositionAndOrientationWithConstraint(Vec& position, Quaternion& orientation);
Vec position() const;
Quaternion orientation() const;
void getPosition(qreal& x, qreal& y, qreal& z) const;
void getOrientation(qreal& q0, qreal& q1, qreal& q2, qreal& q3) const;
//@}
public:
/*! @name Local translation and rotation w/r reference Frame */
//@{
/*! Sets the translation() of the frame, locally defined with respect to the referenceFrame().
Emits the modified() signal.
Use setPosition() to define the world coordinates position(). Use
setTranslationWithConstraint() to take into account the potential constraint() of the Frame. */
void setTranslation(const Vec& translation) { t_ = translation; Q_EMIT modified(); }
void setTranslation(qreal x, qreal y, qreal z);
void setTranslationWithConstraint(Vec& translation);
/*! Set the current rotation Quaternion. See rotation() and the different Quaternion
constructors. Emits the modified() signal. See also setTranslation() and
setRotationWithConstraint(). */
/*! Sets the rotation() of the Frame, locally defined with respect to the referenceFrame().
Emits the modified() signal.
Use setOrientation() to define the world coordinates orientation(). The potential
constraint() of the Frame is not taken into account, use setRotationWithConstraint()
instead. */
void setRotation(const Quaternion& rotation) { q_ = rotation; Q_EMIT modified(); }
void setRotation(qreal q0, qreal q1, qreal q2, qreal q3);
void setRotationWithConstraint(Quaternion& rotation);
void setTranslationAndRotation(const Vec& translation, const Quaternion& rotation);
void setTranslationAndRotationWithConstraint(Vec& translation, Quaternion& rotation);
/*! Returns the Frame translation, defined with respect to the referenceFrame().
Use position() to get the result in the world coordinates. These two values are identical
when the referenceFrame() is \c NULL (default).
See also setTranslation() and setTranslationWithConstraint(). */
Vec translation() const { return t_; }
/*! Returns the Frame rotation, defined with respect to the referenceFrame().
Use orientation() to get the result in the world coordinates. These two values are identical
when the referenceFrame() is \c NULL (default).
See also setRotation() and setRotationWithConstraint(). */
/*! Returns the current Quaternion orientation. See setRotation(). */
Quaternion rotation() const { return q_; }
void getTranslation(qreal& x, qreal& y, qreal& z) const;
void getRotation(qreal& q0, qreal& q1, qreal& q2, qreal& q3) const;
//@}
public:
/*! @name Frame hierarchy */
//@{
/*! Returns the reference Frame, in which coordinates system the Frame is defined.
The translation() and rotation() of the Frame are defined with respect to the referenceFrame()
coordinate system. A \c NULL referenceFrame() (default value) means that the Frame is defined in
the world coordinate system.
Use position() and orientation() to recursively convert values along the referenceFrame() chain
and to get values expressed in the world coordinate system. The values match when the
referenceFrame() is \c NULL.
Use setReferenceFrame() to set this value and create a Frame hierarchy. Convenient functions
allow you to convert 3D coordinates from one Frame to an other: see coordinatesOf(),
localCoordinatesOf(), coordinatesOfIn() and their inverse functions.
Vectors can also be converted using transformOf(), transformOfIn, localTransformOf() and their
inverse functions. */
const Frame* referenceFrame() const { return referenceFrame_; }
void setReferenceFrame(const Frame* const refFrame);
bool settingAsReferenceFrameWillCreateALoop(const Frame* const frame);
//@}
/*! @name Frame modification */
//@{
void translate(Vec& t);
void translate(const Vec& t);
// Some compilers complain about "overloading cannot distinguish from previous declaration"
// Simply comment out the following method and its associated implementation
void translate(qreal x, qreal y, qreal z);
void translate(qreal& x, qreal& y, qreal& z);
void rotate(Quaternion& q);
void rotate(const Quaternion& q);
// Some compilers complain about "overloading cannot distinguish from previous declaration"
// Simply comment out the following method and its associated implementation
void rotate(qreal q0, qreal q1, qreal q2, qreal q3);
void rotate(qreal& q0, qreal& q1, qreal& q2, qreal& q3);
void rotateAroundPoint(Quaternion& rotation, const Vec& point);
void rotateAroundPoint(const Quaternion& rotation, const Vec& point);
void alignWithFrame(const Frame* const frame, bool move=false, qreal threshold=0.0);
void projectOnLine(const Vec& origin, const Vec& direction);
//@}
/*! @name Coordinate system transformation of 3D coordinates */
//@{
Vec coordinatesOf(const Vec& src) const;
Vec inverseCoordinatesOf(const Vec& src) const;
Vec localCoordinatesOf(const Vec& src) const;
Vec localInverseCoordinatesOf(const Vec& src) const;
Vec coordinatesOfIn(const Vec& src, const Frame* const in) const;
Vec coordinatesOfFrom(const Vec& src, const Frame* const from) const;
void getCoordinatesOf(const qreal src[3], qreal res[3]) const;
void getInverseCoordinatesOf(const qreal src[3], qreal res[3]) const;
void getLocalCoordinatesOf(const qreal src[3], qreal res[3]) const;
void getLocalInverseCoordinatesOf(const qreal src[3], qreal res[3]) const;
void getCoordinatesOfIn(const qreal src[3], qreal res[3], const Frame* const in) const;
void getCoordinatesOfFrom(const qreal src[3], qreal res[3], const Frame* const from) const;
//@}
/*! @name Coordinate system transformation of vectors */
// A frame is as a new coordinate system, defined with respect to a reference frame (the world
// coordinate system by default, see the "Composition of frame" section).
// The transformOf() (resp. inverseTransformOf()) functions transform a 3D vector from (resp.
// to) the world coordinates system. This section defines the 3D vector transformation
// functions. See the Coordinate system transformation of 3D points above for the transformation
// of 3D points. The difference between the two sets of functions is simple: for vectors, only
// the rotational part of the transformations is taken into account, while translation is also
// considered for 3D points.
// The length of the resulting transformed vector is identical to the one of the source vector
// for all the described functions.
// When local is prepended to the names of the functions, the functions simply transform from
// (and to) the reference frame.
// When In (resp. From) is appended to the names, the functions transform from (resp. To) the
// frame that is given as an argument. The frame does not need to be in the same branch or the
// hierarchical tree, and can be \c NULL (the world coordinates system).
// Combining any of these functions with its inverse (in any order) leads to the identity.
//@{
Vec transformOf(const Vec& src) const;
Vec inverseTransformOf(const Vec& src) const;
Vec localTransformOf(const Vec& src) const;
Vec localInverseTransformOf(const Vec& src) const;
Vec transformOfIn(const Vec& src, const Frame* const in) const;
Vec transformOfFrom(const Vec& src, const Frame* const from) const;
void getTransformOf(const qreal src[3], qreal res[3]) const;
void getInverseTransformOf(const qreal src[3], qreal res[3]) const;
void getLocalTransformOf(const qreal src[3], qreal res[3]) const;
void getLocalInverseTransformOf(const qreal src[3], qreal res[3]) const;
void getTransformOfIn(const qreal src[3], qreal res[3], const Frame* const in) const;
void getTransformOfFrom(const qreal src[3], qreal res[3], const Frame* const from) const;
//@}
/*! @name Constraint on the displacement */
//@{
/*! Returns the current constraint applied to the Frame.
A \c NULL value (default) means that no Constraint is used to filter Frame translation and
rotation. See the Constraint class documentation for details.
You may have to use a \c dynamic_cast to convert the result to a Constraint derived class. */
Constraint* constraint() const { return constraint_; }
/*! Sets the constraint() attached to the Frame.
A \c NULL value means no constraint. The previous constraint() should be deleted by the calling
method if needed. */
void setConstraint(Constraint* const constraint) { constraint_ = constraint; }
//@}
/*! @name Associated matrices */
//@{
public:
const GLdouble* matrix() const;
void getMatrix(GLdouble m[4][4]) const;
void getMatrix(GLdouble m[16]) const;
const GLdouble* worldMatrix() const;
void getWorldMatrix(GLdouble m[4][4]) const;
void getWorldMatrix(GLdouble m[16]) const;
void setFromMatrix(const GLdouble m[4][4]);
void setFromMatrix(const GLdouble m[16]);
//@}
/*! @name Inversion of the transformation */
//@{
Frame inverse() const;
/*! Returns the inverse() of the Frame world transformation.
The orientation() of the new Frame is the Quaternion::inverse() of the original orientation.
Its position() is the negated and inverse rotated image of the original position.
The result Frame has a \c NULL referenceFrame() and a \c NULL constraint().
Use inverse() for a local (i.e. with respect to referenceFrame()) transformation inverse. */
Frame worldInverse() const { return Frame(-(orientation().inverseRotate(position())), orientation().inverse()); }
//@}
/*! @name XML representation */
//@{
public:
virtual QDomElement domElement(const QString& name, QDomDocument& document) const;
public Q_SLOTS:
virtual void initFromDOMElement(const QDomElement& element);
//@}
private:
// P o s i t i o n a n d o r i e n t a t i o n
Vec t_;
Quaternion q_;
// C o n s t r a i n t s
Constraint* constraint_;
// F r a m e c o m p o s i t i o n
const Frame* referenceFrame_;
};
} // namespace qglviewer
#endif // QGLVIEWER_FRAME_H
| 18,425 | 43.293269 | 114 | h |
octomap | octomap-master/octovis/src/extern/QGLViewer/keyFrameInterpolator.cpp | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#include "domUtils.h"
#include "qglviewer.h" // for QGLViewer::drawAxis and Camera::drawCamera
using namespace qglviewer;
using namespace std;
/*! Creates a KeyFrameInterpolator, with \p frame as associated frame().
The frame() can be set or changed using setFrame().
interpolationTime(), interpolationSpeed() and interpolationPeriod() are set to their default
values. */
KeyFrameInterpolator::KeyFrameInterpolator(Frame* frame)
: frame_(NULL), period_(40), interpolationTime_(0.0), interpolationSpeed_(1.0), interpolationStarted_(false),
closedPath_(false), loopInterpolation_(false), pathIsValid_(false), valuesAreValid_(true), currentFrameValid_(false)
// #CONNECTION# Values cut pasted initFromDOMElement()
{
setFrame(frame);
for (int i=0; i<4; ++i)
currentFrame_[i] = new QMutableListIterator<KeyFrame*>(keyFrame_);
connect(&timer_, SIGNAL(timeout()), SLOT(update()));
}
/*! Virtual destructor. Clears the keyFrame path. */
KeyFrameInterpolator::~KeyFrameInterpolator()
{
deletePath();
for (int i=0; i<4; ++i)
delete currentFrame_[i];
}
/*! Sets the frame() associated to the KeyFrameInterpolator. */
void KeyFrameInterpolator::setFrame(Frame* const frame)
{
if (this->frame())
disconnect(this, SIGNAL( interpolated() ), this->frame(), SIGNAL( interpolated() ));
frame_ = frame;
if (this->frame())
connect(this, SIGNAL( interpolated() ), this->frame(), SIGNAL( interpolated() ));
}
/*! Updates frame() state according to current interpolationTime(). Then adds
interpolationPeriod()*interpolationSpeed() to interpolationTime().
This internal method is called by a timer when interpolationIsStarted(). It can be used for
debugging purpose. stopInterpolation() is called when interpolationTime() reaches firstTime() or
lastTime(), unless loopInterpolation() is \c true. */
void KeyFrameInterpolator::update()
{
interpolateAtTime(interpolationTime());
interpolationTime_ += interpolationSpeed() * interpolationPeriod() / 1000.0;
if (interpolationTime() > keyFrame_.last()->time())
{
if (loopInterpolation())
setInterpolationTime(keyFrame_.first()->time() + interpolationTime_ - keyFrame_.last()->time());
else
{
// Make sure last KeyFrame is reached and displayed
interpolateAtTime(keyFrame_.last()->time());
stopInterpolation();
}
Q_EMIT endReached();
}
else
if (interpolationTime() < keyFrame_.first()->time())
{
if (loopInterpolation())
setInterpolationTime(keyFrame_.last()->time() - keyFrame_.first()->time() + interpolationTime_);
else
{
// Make sure first KeyFrame is reached and displayed
interpolateAtTime(keyFrame_.first()->time());
stopInterpolation();
}
Q_EMIT endReached();
}
}
/*! Starts the interpolation process.
A timer is started with an interpolationPeriod() period that updates the frame()'s position and
orientation. interpolationIsStarted() will return \c true until stopInterpolation() or
toggleInterpolation() is called.
If \p period is positive, it is set as the new interpolationPeriod(). The previous
interpolationPeriod() is used otherwise (default).
If interpolationTime() is larger than lastTime(), interpolationTime() is reset to firstTime()
before interpolation starts (and inversely for negative interpolationSpeed()).
Use setInterpolationTime() before calling this method to change the starting interpolationTime().
See the <a href="../examples/keyFrames.html">keyFrames example</a> for an illustration.
You may also be interested in QGLViewer::animate() and QGLViewer::startAnimation().
\attention The keyFrames must be defined (see addKeyFrame()) \e before you startInterpolation(),
or else the interpolation will naturally immediately stop. */
void KeyFrameInterpolator::startInterpolation(int period)
{
if (period >= 0)
setInterpolationPeriod(period);
if (!keyFrame_.isEmpty())
{
if ((interpolationSpeed() > 0.0) && (interpolationTime() >= keyFrame_.last()->time()))
setInterpolationTime(keyFrame_.first()->time());
if ((interpolationSpeed() < 0.0) && (interpolationTime() <= keyFrame_.first()->time()))
setInterpolationTime(keyFrame_.last()->time());
timer_.start(interpolationPeriod());
interpolationStarted_ = true;
update();
}
}
/*! Stops an interpolation started with startInterpolation(). See interpolationIsStarted() and toggleInterpolation(). */
void KeyFrameInterpolator::stopInterpolation()
{
timer_.stop();
interpolationStarted_ = false;
}
/*! Stops the interpolation and resets interpolationTime() to the firstTime().
If desired, call interpolateAtTime() after this method to actually move the frame() to
firstTime(). */
void KeyFrameInterpolator::resetInterpolation()
{
stopInterpolation();
setInterpolationTime(firstTime());
}
/*! Appends a new keyFrame to the path, with its associated \p time (in seconds).
The keyFrame is given as a pointer to a Frame, which will be connected to the
KeyFrameInterpolator: when \p frame is modified, the KeyFrameInterpolator path is updated
accordingly. This allows for dynamic paths, where keyFrame can be edited, even during the
interpolation. See the <a href="../examples/keyFrames.html">keyFrames example</a> for an
illustration.
\c NULL \p frame pointers are silently ignored. The keyFrameTime() has to be monotonously
increasing over keyFrames.
Use addKeyFrame(const Frame&, qreal) to add keyFrame by values. */
void KeyFrameInterpolator::addKeyFrame(const Frame* const frame, qreal time)
{
if (!frame)
return;
if (keyFrame_.isEmpty())
interpolationTime_ = time;
if ( (!keyFrame_.isEmpty()) && (keyFrame_.last()->time() > time) )
qWarning("Error in KeyFrameInterpolator::addKeyFrame: time is not monotone");
else
keyFrame_.append(new KeyFrame(frame, time));
connect(frame, SIGNAL(modified()), SLOT(invalidateValues()));
valuesAreValid_ = false;
pathIsValid_ = false;
currentFrameValid_ = false;
resetInterpolation();
}
/*! Appends a new keyFrame to the path, with its associated \p time (in seconds).
The path will use the current \p frame state. If you want the path to change when \p frame is
modified, you need to pass a \e pointer to the Frame instead (see addKeyFrame(const Frame*,
qreal)).
The keyFrameTime() have to be monotonously increasing over keyFrames. */
void KeyFrameInterpolator::addKeyFrame(const Frame& frame, qreal time)
{
if (keyFrame_.isEmpty())
interpolationTime_ = time;
if ( (!keyFrame_.isEmpty()) && (keyFrame_.last()->time() > time) )
qWarning("Error in KeyFrameInterpolator::addKeyFrame: time is not monotone");
else
keyFrame_.append(new KeyFrame(frame, time));
valuesAreValid_ = false;
pathIsValid_ = false;
currentFrameValid_ = false;
resetInterpolation();
}
/*! Appends a new keyFrame to the path.
Same as addKeyFrame(const Frame* frame, qreal), except that the keyFrameTime() is set to the
previous keyFrameTime() plus one second (or 0.0 if there is no previous keyFrame). */
void KeyFrameInterpolator::addKeyFrame(const Frame* const frame)
{
qreal time;
if (keyFrame_.isEmpty())
time = 0.0;
else
time = lastTime() + 1.0;
addKeyFrame(frame, time);
}
/*! Appends a new keyFrame to the path.
Same as addKeyFrame(const Frame& frame, qreal), except that the keyFrameTime() is automatically set
to previous keyFrameTime() plus one second (or 0.0 if there is no previous keyFrame). */
void KeyFrameInterpolator::addKeyFrame(const Frame& frame)
{
qreal time;
if (keyFrame_.isEmpty())
time = 0.0;
else
time = keyFrame_.last()->time() + 1.0;
addKeyFrame(frame, time);
}
/*! Removes all keyFrames from the path. The numberOfKeyFrames() is set to 0. */
void KeyFrameInterpolator::deletePath()
{
stopInterpolation();
qDeleteAll(keyFrame_);
keyFrame_.clear();
pathIsValid_ = false;
valuesAreValid_ = false;
currentFrameValid_ = false;
}
static void drawCamera(qreal scale)
{
glDisable(GL_LIGHTING);
const qreal halfHeight = scale * 0.07;
const qreal halfWidth = halfHeight * 1.3;
const qreal dist = halfHeight / tan(qreal(M_PI)/8.0);
const qreal arrowHeight = 1.5 * halfHeight;
const qreal baseHeight = 1.2 * halfHeight;
const qreal arrowHalfWidth = 0.5 * halfWidth;
const qreal baseHalfWidth = 0.3 * halfWidth;
// Frustum outline
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glBegin(GL_LINE_STRIP);
glVertex3d(-halfWidth, halfHeight,-dist);
glVertex3d(-halfWidth,-halfHeight,-dist);
glVertex3d( 0.0, 0.0, 0.0);
glVertex3d( halfWidth,-halfHeight,-dist);
glVertex3d(-halfWidth,-halfHeight,-dist);
glEnd();
glBegin(GL_LINE_STRIP);
glVertex3d( halfWidth,-halfHeight,-dist);
glVertex3d( halfWidth, halfHeight,-dist);
glVertex3d( 0.0, 0.0, 0.0);
glVertex3d(-halfWidth, halfHeight,-dist);
glVertex3d( halfWidth, halfHeight,-dist);
glEnd();
// Up arrow
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// Base
glBegin(GL_QUADS);
glVertex3d(-baseHalfWidth, halfHeight,-dist);
glVertex3d( baseHalfWidth, halfHeight,-dist);
glVertex3d( baseHalfWidth, baseHeight,-dist);
glVertex3d(-baseHalfWidth, baseHeight,-dist);
glEnd();
// Arrow
glBegin(GL_TRIANGLES);
glVertex3d( 0.0, arrowHeight,-dist);
glVertex3d(-arrowHalfWidth, baseHeight, -dist);
glVertex3d( arrowHalfWidth, baseHeight, -dist);
glEnd();
}
/*! Draws the path used to interpolate the frame().
\p mask controls what is drawn: if (mask & 1) (default), the position path is drawn. If (mask &
2), a camera representation is regularly drawn and if (mask & 4), an oriented axis is regularly
drawn. Examples:
\code
drawPath(); // Simply draws the interpolation path
drawPath(3); // Draws path and cameras
drawPath(5); // Draws path and axis
\endcode
In the case where camera or axis is drawn, \p nbFrames controls the number of objects (axis or
camera) drawn between two successive keyFrames. When \p nbFrames=1, only the path KeyFrames are
drawn. \p nbFrames=2 also draws the intermediate orientation, etc. The maximum value is 30. \p
nbFrames should divide 30 so that an object is drawn for each KeyFrame. Default value is 6.
\p scale (default=1.0) controls the scaling of the camera and axis drawing. A value of
QGLViewer::sceneRadius() should give good results.
See the <a href="../examples/keyFrames.html">keyFrames example</a> for an illustration.
The color of the path is the current \c glColor().
\attention The OpenGL state is modified by this method: GL_LIGHTING is disabled and line width set
to 2. Use this code to preserve your current OpenGL state:
\code
glPushAttrib(GL_ALL_ATTRIB_BITS);
drawPathModifyGLState(mask, nbFrames, scale);
glPopAttrib();
\endcode */
void KeyFrameInterpolator::drawPath(int mask, int nbFrames, qreal scale)
{
const int nbSteps = 30;
if (!pathIsValid_)
{
path_.clear();
if (keyFrame_.isEmpty())
return;
if (!valuesAreValid_)
updateModifiedFrameValues();
if (keyFrame_.first() == keyFrame_.last())
path_.push_back(Frame(keyFrame_.first()->position(), keyFrame_.first()->orientation()));
else
{
static Frame fr;
KeyFrame* kf_[4];
kf_[0] = keyFrame_.first();
kf_[1] = kf_[0];
int index = 1;
kf_[2] = (index < keyFrame_.size()) ? keyFrame_.at(index) : NULL;
index++;
kf_[3] = (index < keyFrame_.size()) ? keyFrame_.at(index) : NULL;
while (kf_[2])
{
Vec diff = kf_[2]->position() - kf_[1]->position();
Vec v1 = 3.0 * diff - 2.0 * kf_[1]->tgP() - kf_[2]->tgP();
Vec v2 = -2.0 * diff + kf_[1]->tgP() + kf_[2]->tgP();
// cout << kf_[0]->time() << " , " << kf_[1]->time() << " , " << kf_[2]->time() << " , " << kf_[3]->time() << endl;
for (int step=0; step<nbSteps; ++step)
{
qreal alpha = step / static_cast<qreal>(nbSteps);
fr.setPosition(kf_[1]->position() + alpha * (kf_[1]->tgP() + alpha * (v1+alpha*v2)));
fr.setOrientation(Quaternion::squad(kf_[1]->orientation(), kf_[1]->tgQ(), kf_[2]->tgQ(), kf_[2]->orientation(), alpha));
path_.push_back(fr);
}
// Shift
kf_[0] = kf_[1];
kf_[1] = kf_[2];
kf_[2] = kf_[3];
index++;
kf_[3] = (index < keyFrame_.size()) ? keyFrame_.at(index) : NULL;
}
// Add last KeyFrame
path_.push_back(Frame(kf_[1]->position(), kf_[1]->orientation()));
}
pathIsValid_ = true;
}
if (mask)
{
glDisable(GL_LIGHTING);
glLineWidth(2);
if (mask & 1)
{
glBegin(GL_LINE_STRIP);
Q_FOREACH (Frame fr, path_)
glVertex3fv(fr.position());
glEnd();
}
if (mask & 6)
{
int count = 0;
if (nbFrames > nbSteps)
nbFrames = nbSteps;
qreal goal = 0.0;
Q_FOREACH (Frame fr, path_)
if ((count++) >= goal)
{
goal += nbSteps / static_cast<qreal>(nbFrames);
glPushMatrix();
glMultMatrixd(fr.matrix());
if (mask & 2) drawCamera(scale);
if (mask & 4) QGLViewer::drawAxis(scale/10.0);
glPopMatrix();
}
}
}
}
void KeyFrameInterpolator::updateModifiedFrameValues()
{
Quaternion prevQ = keyFrame_.first()->orientation();
KeyFrame* kf;
for (int i=0; i<keyFrame_.size(); ++i)
{
kf = keyFrame_.at(i);
if (kf->frame())
kf->updateValuesFromPointer();
kf->flipOrientationIfNeeded(prevQ);
prevQ = kf->orientation();
}
KeyFrame* prev = keyFrame_.first();
kf = keyFrame_.first();
int index = 1;
while (kf)
{
KeyFrame* next = (index < keyFrame_.size()) ? keyFrame_.at(index) : NULL;
index++;
if (next)
kf->computeTangent(prev, next);
else
kf->computeTangent(prev, kf);
prev = kf;
kf = next;
}
valuesAreValid_ = true;
}
/*! Returns the Frame associated with the keyFrame at index \p index.
See also keyFrameTime(). \p index has to be in the range 0..numberOfKeyFrames()-1.
\note If this keyFrame was defined using a pointer to a Frame (see addKeyFrame(const Frame*
const)), the \e current pointed Frame state is returned. */
Frame KeyFrameInterpolator::keyFrame(int index) const
{
const KeyFrame* const kf = keyFrame_.at(index);
return Frame(kf->position(), kf->orientation());
}
/*! Returns the time corresponding to the \p index keyFrame.
See also keyFrame(). \p index has to be in the range 0..numberOfKeyFrames()-1. */
qreal KeyFrameInterpolator::keyFrameTime(int index) const
{
return keyFrame_.at(index)->time();
}
/*! Returns the duration of the KeyFrameInterpolator path, expressed in seconds.
Simply corresponds to lastTime() - firstTime(). Returns 0.0 if the path has less than 2 keyFrames.
See also keyFrameTime(). */
qreal KeyFrameInterpolator::duration() const
{
return lastTime() - firstTime();
}
/*! Returns the time corresponding to the first keyFrame, expressed in seconds.
Returns 0.0 if the path is empty. See also lastTime(), duration() and keyFrameTime(). */
qreal KeyFrameInterpolator::firstTime() const
{
if (keyFrame_.isEmpty())
return 0.0;
else
return keyFrame_.first()->time();
}
/*! Returns the time corresponding to the last keyFrame, expressed in seconds.
Returns 0.0 if the path is empty. See also firstTime(), duration() and keyFrameTime(). */
qreal KeyFrameInterpolator::lastTime() const
{
if (keyFrame_.isEmpty())
return 0.0;
else
return keyFrame_.last()->time();
}
void KeyFrameInterpolator::updateCurrentKeyFrameForTime(qreal time)
{
// Assertion: times are sorted in monotone order.
// Assertion: keyFrame_ is not empty
// TODO: Special case for loops when closed path is implemented !!
if (!currentFrameValid_)
// Recompute everything from scrach
currentFrame_[1]->toFront();
while (currentFrame_[1]->peekNext()->time() > time)
{
currentFrameValid_ = false;
if (!currentFrame_[1]->hasPrevious())
break;
currentFrame_[1]->previous();
}
if (!currentFrameValid_)
*currentFrame_[2] = *currentFrame_[1];
while (currentFrame_[2]->peekNext()->time() < time)
{
currentFrameValid_ = false;
if (!currentFrame_[2]->hasNext())
break;
currentFrame_[2]->next();
}
if (!currentFrameValid_)
{
*currentFrame_[1] = *currentFrame_[2];
if ((currentFrame_[1]->hasPrevious()) && (time < currentFrame_[2]->peekNext()->time()))
currentFrame_[1]->previous();
*currentFrame_[0] = *currentFrame_[1];
if (currentFrame_[0]->hasPrevious())
currentFrame_[0]->previous();
*currentFrame_[3] = *currentFrame_[2];
if (currentFrame_[3]->hasNext())
currentFrame_[3]->next();
currentFrameValid_ = true;
splineCacheIsValid_ = false;
}
// cout << "Time = " << time << " : " << currentFrame_[0]->peekNext()->time() << " , " <<
// currentFrame_[1]->peekNext()->time() << " , " << currentFrame_[2]->peekNext()->time() << " , " << currentFrame_[3]->peekNext()->time() << endl;
}
void KeyFrameInterpolator::updateSplineCache()
{
Vec delta = currentFrame_[2]->peekNext()->position() - currentFrame_[1]->peekNext()->position();
v1 = 3.0 * delta - 2.0 * currentFrame_[1]->peekNext()->tgP() - currentFrame_[2]->peekNext()->tgP();
v2 = -2.0 * delta + currentFrame_[1]->peekNext()->tgP() + currentFrame_[2]->peekNext()->tgP();
splineCacheIsValid_ = true;
}
/*! Interpolate frame() at time \p time (expressed in seconds). interpolationTime() is set to \p
time and frame() is set accordingly.
If you simply want to change interpolationTime() but not the frame() state, use
setInterpolationTime() instead.
Emits the interpolated() signal and makes the frame() emit the Frame::interpolated() signal. */
void KeyFrameInterpolator::interpolateAtTime(qreal time)
{
setInterpolationTime(time);
if ((keyFrame_.isEmpty()) || (!frame()))
return;
if (!valuesAreValid_)
updateModifiedFrameValues();
updateCurrentKeyFrameForTime(time);
if (!splineCacheIsValid_)
updateSplineCache();
qreal alpha;
qreal dt = currentFrame_[2]->peekNext()->time() - currentFrame_[1]->peekNext()->time();
if (dt == 0.0)
alpha = 0.0;
else
alpha = (time - currentFrame_[1]->peekNext()->time()) / dt;
// Linear interpolation - debug
// Vec pos = alpha*(currentFrame_[2]->peekNext()->position()) + (1.0-alpha)*(currentFrame_[1]->peekNext()->position());
Vec pos = currentFrame_[1]->peekNext()->position() + alpha * (currentFrame_[1]->peekNext()->tgP() + alpha * (v1+alpha*v2));
Quaternion q = Quaternion::squad(currentFrame_[1]->peekNext()->orientation(), currentFrame_[1]->peekNext()->tgQ(),
currentFrame_[2]->peekNext()->tgQ(), currentFrame_[2]->peekNext()->orientation(), alpha);
frame()->setPositionAndOrientationWithConstraint(pos, q);
Q_EMIT interpolated();
}
/*! Returns an XML \c QDomElement that represents the KeyFrameInterpolator.
The resulting QDomElement holds the KeyFrameInterpolator parameters as well as the path keyFrames
(if the keyFrame is defined by a pointer to a Frame, use its current value).
\p name is the name of the QDomElement tag. \p doc is the \c QDomDocument factory used to create
QDomElement.
Use initFromDOMElement() to restore the ManipulatedFrame state from the resulting QDomElement.
See Vec::domElement() for a complete example. See also Quaternion::domElement(),
Camera::domElement()...
Note that the Camera::keyFrameInterpolator() are automatically saved by QGLViewer::saveStateToFile()
when a QGLViewer is closed. */
QDomElement KeyFrameInterpolator::domElement(const QString& name, QDomDocument& document) const
{
QDomElement de = document.createElement(name);
int count = 0;
Q_FOREACH (KeyFrame* kf, keyFrame_)
{
Frame fr(kf->position(), kf->orientation());
QDomElement kfNode = fr.domElement("KeyFrame", document);
kfNode.setAttribute("index", QString::number(count));
kfNode.setAttribute("time", QString::number(kf->time()));
de.appendChild(kfNode);
++count;
}
de.setAttribute("nbKF", QString::number(keyFrame_.count()));
de.setAttribute("time", QString::number(interpolationTime()));
de.setAttribute("speed", QString::number(interpolationSpeed()));
de.setAttribute("period", QString::number(interpolationPeriod()));
DomUtils::setBoolAttribute(de, "closedPath", closedPath());
DomUtils::setBoolAttribute(de, "loop", loopInterpolation());
return de;
}
/*! Restores the KeyFrameInterpolator state from a \c QDomElement created by domElement().
Note that the frame() pointer is not included in the domElement(): you need to setFrame() after
this method to attach a Frame to the KeyFrameInterpolator.
See Vec::initFromDOMElement() for a complete code example.
See also Camera::initFromDOMElement() and Frame::initFromDOMElement(). */
void KeyFrameInterpolator::initFromDOMElement(const QDomElement& element)
{
qDeleteAll(keyFrame_);
keyFrame_.clear();
QDomElement child=element.firstChild().toElement();
while (!child.isNull())
{
if (child.tagName() == "KeyFrame")
{
Frame fr;
fr.initFromDOMElement(child);
qreal time = DomUtils::qrealFromDom(child, "time", 0.0);
addKeyFrame(fr, time);
}
child = child.nextSibling().toElement();
}
// #CONNECTION# Values cut pasted from constructor
setInterpolationTime(DomUtils::qrealFromDom(element, "time", 0.0));
setInterpolationSpeed(DomUtils::qrealFromDom(element, "speed", 1.0));
setInterpolationPeriod(DomUtils::intFromDom(element, "period", 40));
setClosedPath(DomUtils::boolFromDom(element, "closedPath", false));
setLoopInterpolation(DomUtils::boolFromDom(element, "loop", false));
// setFrame(NULL);
pathIsValid_ = false;
valuesAreValid_ = false;
currentFrameValid_ = false;
stopInterpolation();
}
#ifndef DOXYGEN
//////////// KeyFrame private class implementation /////////
KeyFrameInterpolator::KeyFrame::KeyFrame(const Frame& fr, qreal t)
: time_(t), frame_(NULL)
{
p_ = fr.position();
q_ = fr.orientation();
}
KeyFrameInterpolator::KeyFrame::KeyFrame(const Frame* fr, qreal t)
: time_(t), frame_(fr)
{
updateValuesFromPointer();
}
void KeyFrameInterpolator::KeyFrame::updateValuesFromPointer()
{
p_ = frame()->position();
q_ = frame()->orientation();
}
void KeyFrameInterpolator::KeyFrame::computeTangent(const KeyFrame* const prev, const KeyFrame* const next)
{
tgP_ = 0.5 * (next->position() - prev->position());
tgQ_ = Quaternion::squadTangent(prev->orientation(), q_, next->orientation());
}
void KeyFrameInterpolator::KeyFrame::flipOrientationIfNeeded(const Quaternion& prev)
{
if (Quaternion::dot(prev, q_) < 0.0)
q_.negate();
}
#endif //DOXYGEN
| 23,068 | 31.264336 | 148 | cpp |
octomap | octomap-master/octovis/src/extern/QGLViewer/keyFrameInterpolator.h | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#ifndef QGLVIEWER_KEY_FRAME_INTERPOLATOR_H
#define QGLVIEWER_KEY_FRAME_INTERPOLATOR_H
#include <QObject>
#include <QTimer>
#include "quaternion.h"
// Not actually needed, but some bad compilers (Microsoft VS6) complain.
#include "frame.h"
// If you compiler complains about incomplete type, uncomment the next line
// #include "frame.h"
// and comment "class Frame;" 3 lines below
namespace qglviewer {
class Camera;
class Frame;
/*! \brief A keyFrame Catmull-Rom Frame interpolator.
\class KeyFrameInterpolator keyFrameInterpolator.h QGLViewer/keyFrameInterpolator.h
A KeyFrameInterpolator holds keyFrames (that define a path) and a pointer to a Frame of your
application (which will be interpolated). When the user startInterpolation(), the
KeyFrameInterpolator regularly updates the frame() position and orientation along the path.
Here is a typical utilization example (see also the <a href="../examples/keyFrames.html">keyFrames
example</a>):
\code
init()
{
// The KeyFrameInterpolator kfi is given the Frame that it will drive over time.
kfi = new KeyFrameInterpolator( new Frame() );
kfi->addKeyFrame( Frame( Vec(1,0,0), Quaternion() ) );
kfi->addKeyFrame( new Frame( Vec(2,1,0), Quaternion() ) );
// ...and so on for all the keyFrames.
// Ask for a display update after each update of the KeyFrameInterpolator
connect(kfi, SIGNAL(interpolated()), SLOT(update()));
kfi->startInterpolation();
}
draw()
{
glPushMatrix();
glMultMatrixd( kfi->frame()->matrix() );
// Draw your object here. Its position and orientation are interpolated.
glPopMatrix();
}
\endcode
The keyFrames are defined by a Frame and a time, expressed in seconds. The Frame can be provided
as a const reference or as a pointer to a Frame (see the addKeyFrame() methods). In the latter
case, the path will automatically be updated when the Frame is modified (using the
Frame::modified() signal).
The time has to be monotonously increasing over keyFrames. When interpolationSpeed() equals 1.0
(default value), these times correspond to actual user's seconds during interpolation (provided
that your main loop is fast enough). The interpolation is then real-time: the keyFrames will be
reached at their keyFrameTime().
<h3>Interpolation details</h3>
When the user startInterpolation(), a timer is started which will update the frame()'s position
and orientation every interpolationPeriod() milliseconds. This update increases the
interpolationTime() by interpolationPeriod() * interpolationSpeed() milliseconds.
Note that this mechanism ensures that the number of interpolation steps is constant and equal to
the total path duration() divided by the interpolationPeriod() * interpolationSpeed(). This is
especially useful for benchmarking or movie creation (constant number of snapshots).
During the interpolation, the KeyFrameInterpolator emits an interpolated() signal, which will
usually be connected to the QGLViewer::update() slot. The interpolation is stopped when
interpolationTime() is greater than the lastTime() (unless loopInterpolation() is \c true) and the
endReached() signal is then emitted.
Note that a Camera has Camera::keyFrameInterpolator(), that can be used to drive the Camera along a
path, or to restore a saved position (a path made of a single keyFrame). Press Alt+Fx to define a
new keyFrame for path x. Pressing Fx plays/pauses path interpolation. See QGLViewer::pathKey() and
the <a href="../keyboard.html">keyboard page</a> for details.
\attention If a Constraint is attached to the frame() (see Frame::constraint()), it should be
deactivated before interpolationIsStarted(), otherwise the interpolated motion (computed as if
there was no constraint) will probably be erroneous.
<h3>Retrieving interpolated values</h3>
This code defines a KeyFrameInterpolator, and displays the positions that will be followed by the
frame() along the path:
\code
KeyFrameInterpolator kfi( new Frame() );
// calls to kfi.addKeyFrame() to define the path.
const qreal deltaTime = 0.04; // output a position every deltaTime seconds
for (qreal time=kfi.firstTime(); time<=kfi.lastTime(); time += deltaTime)
{
kfi.interpolateAtTime(time);
cout << "t=" << time << "\tpos=" << kfi.frame()->position() << endl;
}
\endcode
You may want to temporally disconnect the \c kfi interpolated() signal from the
QGLViewer::update() slot before calling this code. \nosubgrouping */
class QGLVIEWER_EXPORT KeyFrameInterpolator : public QObject
{
// todo closedPath, insertKeyFrames, deleteKeyFrame, replaceKeyFrame
Q_OBJECT
public:
KeyFrameInterpolator(Frame* fr=NULL);
virtual ~KeyFrameInterpolator();
Q_SIGNALS:
/*! This signal is emitted whenever the frame() state is interpolated.
The emission of this signal triggers the synchronous emission of the frame()
Frame::interpolated() signal, which may also be useful.
This signal should especially be connected to your QGLViewer::update() slot, so that the display
is updated after every update of the KeyFrameInterpolator frame():
\code
connect(myKeyFrameInterpolator, SIGNAL(interpolated()), SLOT(update()));
\endcode
Use the QGLViewer::QGLViewerPool() to connect the signal to all the viewers.
Note that the QGLViewer::camera() Camera::keyFrameInterpolator() created using QGLViewer::pathKey()
have their interpolated() signals automatically connected to the QGLViewer::update() slot. */
void interpolated();
/*! This signal is emitted when the interpolation reaches the first (when interpolationSpeed()
is negative) or the last keyFrame.
When loopInterpolation() is \c true, interpolationTime() is reset and the interpolation
continues. It otherwise stops. */
void endReached();
/*! @name Path creation */
//@{
public Q_SLOTS:
void addKeyFrame(const Frame& frame);
void addKeyFrame(const Frame& frame, qreal time);
void addKeyFrame(const Frame* const frame);
void addKeyFrame(const Frame* const frame, qreal time);
void deletePath();
//@}
/*! @name Associated Frame */
//@{
public:
/*! Returns the associated Frame and that is interpolated by the KeyFrameInterpolator.
When interpolationIsStarted(), this Frame's position and orientation will regularly be updated
by a timer, so that they follow the KeyFrameInterpolator path.
Set using setFrame() or with the KeyFrameInterpolator constructor. */
Frame* frame() const { return frame_; }
public Q_SLOTS:
void setFrame(Frame* const frame);
//@}
/*! @name Path parameters */
//@{
public:
Frame keyFrame(int index) const;
qreal keyFrameTime(int index) const;
/*! Returns the number of keyFrames used by the interpolation. Use addKeyFrame() to add new keyFrames. */
int numberOfKeyFrames() const { return keyFrame_.count(); }
qreal duration() const;
qreal firstTime() const;
qreal lastTime() const;
//@}
/*! @name Interpolation parameters */
//@{
public:
/*! Returns the current interpolation time (in seconds) along the KeyFrameInterpolator path.
This time is regularly updated when interpolationIsStarted(). Can be set directly with
setInterpolationTime() or interpolateAtTime(). */
qreal interpolationTime() const { return interpolationTime_; }
/*! Returns the current interpolation speed.
Default value is 1.0, which means keyFrameTime() will be matched during the interpolation
(provided that your main loop is fast enough).
A negative value will result in a reverse interpolation of the keyFrames. See also
interpolationPeriod(). */
qreal interpolationSpeed() const { return interpolationSpeed_; }
/*! Returns the current interpolation period, expressed in milliseconds.
The update of the frame() state will be done by a timer at this period when
interpolationIsStarted().
This period (multiplied by interpolationSpeed()) is added to the interpolationTime() at each
update, and the frame() state is modified accordingly (see interpolateAtTime()). Default value
is 40 milliseconds. */
int interpolationPeriod() const { return period_; }
/*! Returns \c true when the interpolation is played in an infinite loop.
When \c false (default), the interpolation stops when interpolationTime() reaches firstTime()
(with negative interpolationSpeed()) or lastTime().
interpolationTime() is otherwise reset to firstTime() (+ interpolationTime() - lastTime()) (and
inversely for negative interpolationSpeed()) and interpolation continues.
In both cases, the endReached() signal is emitted. */
bool loopInterpolation() const { return loopInterpolation_; }
#ifndef DOXYGEN
/*! Whether or not (default) the path defined by the keyFrames is a closed loop. When \c true,
the last and the first KeyFrame are linked by a new spline segment.
Use setLoopInterpolation() to create a continuous animation over the entire path.
\attention The closed path feature is not yet implemented. */
bool closedPath() const { return closedPath_; }
#endif
public Q_SLOTS:
/*! Sets the interpolationTime().
\attention The frame() state is not affected by this method. Use this function to define the
starting time of a future interpolation (see startInterpolation()). Use interpolateAtTime() to
actually interpolate at a given time. */
void setInterpolationTime(qreal time) { interpolationTime_ = time; }
/*! Sets the interpolationSpeed(). Negative or null values are allowed. */
void setInterpolationSpeed(qreal speed) { interpolationSpeed_ = speed; }
/*! Sets the interpolationPeriod(). */
void setInterpolationPeriod(int period) { period_ = period; }
/*! Sets the loopInterpolation() value. */
void setLoopInterpolation(bool loop=true) { loopInterpolation_ = loop; }
#ifndef DOXYGEN
/*! Sets the closedPath() value. \attention The closed path feature is not yet implemented. */
void setClosedPath(bool closed=true) { closedPath_ = closed; }
#endif
//@}
/*! @name Interpolation */
//@{
public:
/*! Returns \c true when the interpolation is being performed. Use startInterpolation(),
stopInterpolation() or toggleInterpolation() to modify this state. */
bool interpolationIsStarted() const { return interpolationStarted_; }
public Q_SLOTS:
void startInterpolation(int period = -1);
void stopInterpolation();
void resetInterpolation();
/*! Calls startInterpolation() or stopInterpolation(), depending on interpolationIsStarted(). */
void toggleInterpolation() { if (interpolationIsStarted()) stopInterpolation(); else startInterpolation(); }
virtual void interpolateAtTime(qreal time);
//@}
/*! @name Path drawing */
//@{
public:
virtual void drawPath(int mask=1, int nbFrames=6, qreal scale=1.0);
//@}
/*! @name XML representation */
//@{
public:
virtual QDomElement domElement(const QString& name, QDomDocument& document) const;
virtual void initFromDOMElement(const QDomElement& element);
//@}
private Q_SLOTS:
virtual void update();
virtual void invalidateValues() { valuesAreValid_ = false; pathIsValid_ = false; splineCacheIsValid_ = false; }
private:
// Copy constructor and opertor= are declared private and undefined
// Prevents everyone from trying to use them
// KeyFrameInterpolator(const KeyFrameInterpolator& kfi);
// KeyFrameInterpolator& operator=(const KeyFrameInterpolator& kfi);
void updateCurrentKeyFrameForTime(qreal time);
void updateModifiedFrameValues();
void updateSplineCache();
#ifndef DOXYGEN
// Internal private KeyFrame representation
class KeyFrame
{
public:
KeyFrame(const Frame& fr, qreal t);
KeyFrame(const Frame* fr, qreal t);
Vec position() const { return p_; }
Quaternion orientation() const { return q_; }
Vec tgP() const { return tgP_; }
Quaternion tgQ() const { return tgQ_; }
qreal time() const { return time_; }
const Frame* frame() const { return frame_; }
void updateValuesFromPointer();
void flipOrientationIfNeeded(const Quaternion& prev);
void computeTangent(const KeyFrame* const prev, const KeyFrame* const next);
private:
Vec p_, tgP_;
Quaternion q_, tgQ_;
qreal time_;
const Frame* const frame_;
};
#endif
// K e y F r a m e s
mutable QList<KeyFrame*> keyFrame_;
QMutableListIterator<KeyFrame*>* currentFrame_[4];
QList<Frame> path_;
// A s s o c i a t e d f r a m e
Frame* frame_;
// R h y t h m
QTimer timer_;
int period_;
qreal interpolationTime_;
qreal interpolationSpeed_;
bool interpolationStarted_;
// M i s c
bool closedPath_;
bool loopInterpolation_;
// C a c h e d v a l u e s a n d f l a g s
bool pathIsValid_;
bool valuesAreValid_;
bool currentFrameValid_;
bool splineCacheIsValid_;
Vec v1, v2;
};
} // namespace qglviewer
#endif // QGLVIEWER_KEY_FRAME_INTERPOLATOR_H
| 13,603 | 37 | 112 | h |
octomap | octomap-master/octovis/src/extern/QGLViewer/manipulatedCameraFrame.cpp | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#include "domUtils.h"
#include "manipulatedCameraFrame.h"
#include "qglviewer.h"
#include <QMouseEvent>
using namespace qglviewer;
using namespace std;
/*! Default constructor.
flySpeed() is set to 0.0 and sceneUpVector() is (0,1,0). The pivotPoint() is set to (0,0,0).
\attention Created object is removeFromMouseGrabberPool(). */
ManipulatedCameraFrame::ManipulatedCameraFrame()
: driveSpeed_(0.0), sceneUpVector_(0.0, 1.0, 0.0), rotatesAroundUpVector_(false), zoomsOnPivotPoint_(false)
{
setFlySpeed(0.0);
removeFromMouseGrabberPool();
connect(&flyTimer_, SIGNAL(timeout()), SLOT(flyUpdate()));
}
/*! Equal operator. Calls ManipulatedFrame::operator=() and then copy attributes. */
ManipulatedCameraFrame& ManipulatedCameraFrame::operator=(const ManipulatedCameraFrame& mcf)
{
ManipulatedFrame::operator=(mcf);
setFlySpeed(mcf.flySpeed());
setSceneUpVector(mcf.sceneUpVector());
setRotatesAroundUpVector(mcf.rotatesAroundUpVector_);
setZoomsOnPivotPoint(mcf.zoomsOnPivotPoint_);
return *this;
}
/*! Copy constructor. Performs a deep copy of all members using operator=(). */
ManipulatedCameraFrame::ManipulatedCameraFrame(const ManipulatedCameraFrame& mcf)
: ManipulatedFrame(mcf)
{
removeFromMouseGrabberPool();
connect(&flyTimer_, SIGNAL(timeout()), SLOT(flyUpdate()));
(*this)=(mcf);
}
////////////////////////////////////////////////////////////////////////////////
/*! Overloading of ManipulatedFrame::spin().
Rotates the ManipulatedCameraFrame around its pivotPoint() instead of its origin. */
void ManipulatedCameraFrame::spin()
{
rotateAroundPoint(spinningQuaternion(), pivotPoint());
}
#ifndef DOXYGEN
/*! Called for continuous frame motion in fly mode (see QGLViewer::MOVE_FORWARD). Emits
manipulated(). */
void ManipulatedCameraFrame::flyUpdate()
{
static Vec flyDisp(0.0, 0.0, 0.0);
switch (action_)
{
case QGLViewer::MOVE_FORWARD:
flyDisp.z = -flySpeed();
translate(localInverseTransformOf(flyDisp));
break;
case QGLViewer::MOVE_BACKWARD:
flyDisp.z = flySpeed();
translate(localInverseTransformOf(flyDisp));
break;
case QGLViewer::DRIVE:
flyDisp.z = flySpeed() * driveSpeed_;
translate(localInverseTransformOf(flyDisp));
break;
default:
break;
}
// Needs to be out of the switch since ZOOM/fastDraw()/wheelEvent use this callback to trigger a final draw().
// #CONNECTION# wheelEvent.
Q_EMIT manipulated();
}
Vec ManipulatedCameraFrame::flyUpVector() const {
qWarning("flyUpVector() is deprecated. Use sceneUpVector() instead.");
return sceneUpVector();
}
void ManipulatedCameraFrame::setFlyUpVector(const Vec& up) {
qWarning("setFlyUpVector() is deprecated. Use setSceneUpVector() instead.");
setSceneUpVector(up);
}
#endif
/*! This method will be called by the Camera when its orientation is changed, so that the
sceneUpVector (private) is changed accordingly. You should not need to call this method. */
void ManipulatedCameraFrame::updateSceneUpVector()
{
sceneUpVector_ = inverseTransformOf(Vec(0.0, 1.0, 0.0));
}
////////////////////////////////////////////////////////////////////////////////
// S t a t e s a v i n g a n d r e s t o r i n g //
////////////////////////////////////////////////////////////////////////////////
/*! Returns an XML \c QDomElement that represents the ManipulatedCameraFrame.
Adds to the ManipulatedFrame::domElement() the ManipulatedCameraFrame specific informations in a \c
ManipulatedCameraParameters child QDomElement.
\p name is the name of the QDomElement tag. \p doc is the \c QDomDocument factory used to create
QDomElement.
Use initFromDOMElement() to restore the ManipulatedCameraFrame state from the resulting
\c QDomElement.
See Vec::domElement() for a complete example. See also Quaternion::domElement(),
Frame::domElement(), Camera::domElement()... */
QDomElement ManipulatedCameraFrame::domElement(const QString& name, QDomDocument& document) const
{
QDomElement e = ManipulatedFrame::domElement(name, document);
QDomElement mcp = document.createElement("ManipulatedCameraParameters");
mcp.setAttribute("flySpeed", QString::number(flySpeed()));
DomUtils::setBoolAttribute(mcp, "rotatesAroundUpVector", rotatesAroundUpVector());
DomUtils::setBoolAttribute(mcp, "zoomsOnPivotPoint", zoomsOnPivotPoint());
mcp.appendChild(sceneUpVector().domElement("sceneUpVector", document));
e.appendChild(mcp);
return e;
}
/*! Restores the ManipulatedCameraFrame state from a \c QDomElement created by domElement().
First calls ManipulatedFrame::initFromDOMElement() and then initializes ManipulatedCameraFrame
specific parameters. */
void ManipulatedCameraFrame::initFromDOMElement(const QDomElement& element)
{
// No need to initialize, since default sceneUpVector and flySpeed are not meaningful.
// It's better to keep current ones. And it would destroy constraint() and referenceFrame().
// *this = ManipulatedCameraFrame();
ManipulatedFrame::initFromDOMElement(element);
QDomElement child=element.firstChild().toElement();
while (!child.isNull())
{
if (child.tagName() == "ManipulatedCameraParameters")
{
setFlySpeed(DomUtils::qrealFromDom(child, "flySpeed", flySpeed()));
setRotatesAroundUpVector(DomUtils::boolFromDom(child, "rotatesAroundUpVector", false));
setZoomsOnPivotPoint(DomUtils::boolFromDom(child, "zoomsOnPivotPoint", false));
QDomElement schild=child.firstChild().toElement();
while (!schild.isNull())
{
if (schild.tagName() == "sceneUpVector")
setSceneUpVector(Vec(schild));
schild = schild.nextSibling().toElement();
}
}
child = child.nextSibling().toElement();
}
}
////////////////////////////////////////////////////////////////////////////////
// M o u s e h a n d l i n g //
////////////////////////////////////////////////////////////////////////////////
#ifndef DOXYGEN
/*! Protected internal method used to handle mouse events. */
void ManipulatedCameraFrame::startAction(int ma, bool withConstraint)
{
ManipulatedFrame::startAction(ma, withConstraint);
switch (action_)
{
case QGLViewer::MOVE_FORWARD:
case QGLViewer::MOVE_BACKWARD:
case QGLViewer::DRIVE:
flyTimer_.setSingleShot(false);
flyTimer_.start(10);
break;
case QGLViewer::ROTATE:
constrainedRotationIsReversed_ = transformOf(sceneUpVector_).y < 0.0;
break;
default:
break;
}
}
void ManipulatedCameraFrame::zoom(qreal delta, const Camera * const camera) {
const qreal sceneRadius = camera->sceneRadius();
if (zoomsOnPivotPoint_) {
Vec direction = position() - camera->pivotPoint();
if (direction.norm() > 0.02 * sceneRadius || delta > 0.0)
translate(delta * direction);
} else {
const qreal coef = qMax(fabs((camera->frame()->coordinatesOf(camera->pivotPoint())).z), 0.2 * sceneRadius);
Vec trans(0.0, 0.0, -coef * delta);
translate(inverseTransformOf(trans));
}
}
#endif
/*! Overloading of ManipulatedFrame::mouseMoveEvent().
Motion depends on mouse binding (see <a href="../mouse.html">mouse page</a> for details). The
resulting displacements are basically inverted from those of a ManipulatedFrame. */
void ManipulatedCameraFrame::mouseMoveEvent(QMouseEvent* const event, Camera* const camera)
{
// #CONNECTION# QGLViewer::mouseMoveEvent does the update().
switch (action_)
{
case QGLViewer::TRANSLATE:
{
const QPoint delta = prevPos_ - event->pos();
Vec trans(delta.x(), -delta.y(), 0.0);
// Scale to fit the screen mouse displacement
switch (camera->type())
{
case Camera::PERSPECTIVE :
trans *= 2.0 * tan(camera->fieldOfView()/2.0) *
fabs((camera->frame()->coordinatesOf(pivotPoint())).z) / camera->screenHeight();
break;
case Camera::ORTHOGRAPHIC :
{
GLdouble w,h;
camera->getOrthoWidthHeight(w, h);
trans[0] *= 2.0 * w / camera->screenWidth();
trans[1] *= 2.0 * h / camera->screenHeight();
break;
}
}
translate(inverseTransformOf(translationSensitivity()*trans));
break;
}
case QGLViewer::MOVE_FORWARD:
{
Quaternion rot = pitchYawQuaternion(event->x(), event->y(), camera);
rotate(rot);
//#CONNECTION# wheelEvent MOVE_FORWARD case
// actual translation is made in flyUpdate().
//translate(inverseTransformOf(Vec(0.0, 0.0, -flySpeed())));
break;
}
case QGLViewer::MOVE_BACKWARD:
{
Quaternion rot = pitchYawQuaternion(event->x(), event->y(), camera);
rotate(rot);
// actual translation is made in flyUpdate().
//translate(inverseTransformOf(Vec(0.0, 0.0, flySpeed())));
break;
}
case QGLViewer::DRIVE:
{
Quaternion rot = turnQuaternion(event->x(), camera);
rotate(rot);
// actual translation is made in flyUpdate().
driveSpeed_ = 0.01 * (event->y() - pressPos_.y());
break;
}
case QGLViewer::ZOOM:
{
zoom(deltaWithPrevPos(event, camera), camera);
break;
}
case QGLViewer::LOOK_AROUND:
{
Quaternion rot = pitchYawQuaternion(event->x(), event->y(), camera);
rotate(rot);
break;
}
case QGLViewer::ROTATE:
{
Quaternion rot;
if (rotatesAroundUpVector_) {
// Multiply by 2.0 to get on average about the same speed as with the deformed ball
qreal dx = 2.0 * rotationSensitivity() * (prevPos_.x() - event->x()) / camera->screenWidth();
qreal dy = 2.0 * rotationSensitivity() * (prevPos_.y() - event->y()) / camera->screenHeight();
if (constrainedRotationIsReversed_) dx = -dx;
Vec verticalAxis = transformOf(sceneUpVector_);
rot = Quaternion(verticalAxis, dx) * Quaternion(Vec(1.0, 0.0, 0.0), dy);
} else {
Vec trans = camera->projectedCoordinatesOf(pivotPoint());
rot = deformedBallQuaternion(event->x(), event->y(), trans[0], trans[1], camera);
}
//#CONNECTION# These two methods should go together (spinning detection and activation)
computeMouseSpeed(event);
setSpinningQuaternion(rot);
spin();
break;
}
case QGLViewer::SCREEN_ROTATE:
{
Vec trans = camera->projectedCoordinatesOf(pivotPoint());
const qreal angle = atan2(event->y() - trans[1], event->x() - trans[0]) - atan2(prevPos_.y()-trans[1], prevPos_.x()-trans[0]);
Quaternion rot(Vec(0.0, 0.0, 1.0), angle);
//#CONNECTION# These two methods should go together (spinning detection and activation)
computeMouseSpeed(event);
setSpinningQuaternion(rot);
spin();
updateSceneUpVector();
break;
}
case QGLViewer::ROLL:
{
const qreal angle = M_PI * (event->x() - prevPos_.x()) / camera->screenWidth();
Quaternion rot(Vec(0.0, 0.0, 1.0), angle);
rotate(rot);
setSpinningQuaternion(rot);
updateSceneUpVector();
break;
}
case QGLViewer::SCREEN_TRANSLATE:
{
Vec trans;
int dir = mouseOriginalDirection(event);
if (dir == 1)
trans.setValue(prevPos_.x() - event->x(), 0.0, 0.0);
else if (dir == -1)
trans.setValue(0.0, event->y() - prevPos_.y(), 0.0);
switch (camera->type())
{
case Camera::PERSPECTIVE :
trans *= 2.0 * tan(camera->fieldOfView()/2.0) *
fabs((camera->frame()->coordinatesOf(pivotPoint())).z) / camera->screenHeight();
break;
case Camera::ORTHOGRAPHIC :
{
GLdouble w,h;
camera->getOrthoWidthHeight(w, h);
trans[0] *= 2.0 * w / camera->screenWidth();
trans[1] *= 2.0 * h / camera->screenHeight();
break;
}
}
translate(inverseTransformOf(translationSensitivity()*trans));
break;
}
case QGLViewer::ZOOM_ON_REGION:
case QGLViewer::NO_MOUSE_ACTION:
break;
}
if (action_ != QGLViewer::NO_MOUSE_ACTION)
{
prevPos_ = event->pos();
if (action_ != QGLViewer::ZOOM_ON_REGION)
// ZOOM_ON_REGION should not emit manipulated().
// prevPos_ is used to draw rectangle feedback.
Q_EMIT manipulated();
}
}
/*! This is an overload of ManipulatedFrame::mouseReleaseEvent(). The QGLViewer::MouseAction is
terminated. */
void ManipulatedCameraFrame::mouseReleaseEvent(QMouseEvent* const event, Camera* const camera)
{
if ((action_ == QGLViewer::MOVE_FORWARD) || (action_ == QGLViewer::MOVE_BACKWARD) || (action_ == QGLViewer::DRIVE))
flyTimer_.stop();
if (action_ == QGLViewer::ZOOM_ON_REGION)
camera->fitScreenRegion(QRect(pressPos_, event->pos()));
ManipulatedFrame::mouseReleaseEvent(event, camera);
}
/*! This is an overload of ManipulatedFrame::wheelEvent().
The wheel behavior depends on the wheel binded action. Current possible actions are QGLViewer::ZOOM,
QGLViewer::MOVE_FORWARD, QGLViewer::MOVE_BACKWARD. QGLViewer::ZOOM speed depends on
wheelSensitivity() while QGLViewer::MOVE_FORWARD and QGLViewer::MOVE_BACKWARD depend on flySpeed().
See QGLViewer::setWheelBinding() to customize the binding. */
void ManipulatedCameraFrame::wheelEvent(QWheelEvent* const event, Camera* const camera)
{
//#CONNECTION# QGLViewer::setWheelBinding, ManipulatedFrame::wheelEvent.
switch (action_)
{
case QGLViewer::ZOOM:
{
zoom(wheelDelta(event), camera);
Q_EMIT manipulated();
break;
}
case QGLViewer::MOVE_FORWARD:
case QGLViewer::MOVE_BACKWARD:
//#CONNECTION# mouseMoveEvent() MOVE_FORWARD case
translate(inverseTransformOf(Vec(0.0, 0.0, 0.2*flySpeed()*event->delta())));
Q_EMIT manipulated();
break;
default:
break;
}
// #CONNECTION# startAction should always be called before
if (previousConstraint_)
setConstraint(previousConstraint_);
// The wheel triggers a fastDraw. A final update() is needed after the last wheel event to
// polish the rendering using draw(). Since the last wheel event does not say its name, we use
// the flyTimer_ to trigger flyUpdate(), which emits manipulated. Two wheel events
// separated by more than this delay milliseconds will trigger a draw().
const int finalDrawAfterWheelEventDelay = 400;
// Starts (or prolungates) the timer.
flyTimer_.setSingleShot(true);
flyTimer_.start(finalDrawAfterWheelEventDelay);
// This could also be done *before* manipulated is emitted, so that isManipulated() returns false.
// But then fastDraw would not be used with wheel.
// Detecting the last wheel event and forcing a final draw() is done using the timer_.
action_ = QGLViewer::NO_MOUSE_ACTION;
}
////////////////////////////////////////////////////////////////////////////////
/*! Returns a Quaternion that is a rotation around current camera Y, proportionnal to the horizontal mouse position. */
Quaternion ManipulatedCameraFrame::turnQuaternion(int x, const Camera* const camera)
{
return Quaternion(Vec(0.0, 1.0, 0.0), rotationSensitivity()*(prevPos_.x()-x)/camera->screenWidth());
}
/*! Returns a Quaternion that is the composition of two rotations, inferred from the
mouse pitch (X axis) and yaw (sceneUpVector() axis). */
Quaternion ManipulatedCameraFrame::pitchYawQuaternion(int x, int y, const Camera* const camera)
{
const Quaternion rotX(Vec(1.0, 0.0, 0.0), rotationSensitivity()*(prevPos_.y()-y)/camera->screenHeight());
const Quaternion rotY(transformOf(sceneUpVector()), rotationSensitivity()*(prevPos_.x()-x)/camera->screenWidth());
return rotY * rotX;
}
| 15,965 | 32.970213 | 129 | cpp |
octomap | octomap-master/octovis/src/extern/QGLViewer/manipulatedCameraFrame.h | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#ifndef QGLVIEWER_MANIPULATED_CAMERA_FRAME_H
#define QGLVIEWER_MANIPULATED_CAMERA_FRAME_H
#include "manipulatedFrame.h"
namespace qglviewer {
/*! \brief The ManipulatedCameraFrame class represents a ManipulatedFrame with Camera specific mouse bindings.
\class ManipulatedCameraFrame manipulatedCameraFrame.h QGLViewer/manipulatedCameraFrame.h
A ManipulatedCameraFrame is a specialization of a ManipulatedFrame, designed to be set as the
Camera::frame(). Mouse motions are basically interpreted in a negated way: when the mouse goes to
the right, the ManipulatedFrame translation goes to the right, while the ManipulatedCameraFrame
has to go to the \e left, so that the \e scene seems to move to the right.
A ManipulatedCameraFrame rotates around its pivotPoint(), which corresponds to the
associated Camera::pivotPoint().
A ManipulatedCameraFrame can also "fly" in the scene. It basically moves forward, and turns
according to the mouse motion. See flySpeed(), sceneUpVector() and the QGLViewer::MOVE_FORWARD and
QGLViewer::MOVE_BACKWARD QGLViewer::MouseAction.
See the <a href="../mouse.html">mouse page</a> for a description of the possible actions that can
be performed using the mouse and their bindings.
\nosubgrouping */
class QGLVIEWER_EXPORT ManipulatedCameraFrame : public ManipulatedFrame
{
#ifndef DOXYGEN
friend class Camera;
friend class ::QGLViewer;
#endif
Q_OBJECT
public:
ManipulatedCameraFrame();
/*! Virtual destructor. Empty. */
virtual ~ManipulatedCameraFrame() {}
ManipulatedCameraFrame(const ManipulatedCameraFrame& mcf);
ManipulatedCameraFrame& operator=(const ManipulatedCameraFrame& mcf);
/*! @name Pivot point */
//@{
public:
/*! Returns the point the ManipulatedCameraFrame pivot point, around which the camera rotates.
It is defined in the world coordinate system. Default value is (0,0,0).
When the ManipulatedCameraFrame is associated to a Camera, Camera::pivotPoint() also
returns this value. This point can interactively be changed using the mouse (see
Camera::setPivotPointFromPixel() and QGLViewer::RAP_FROM_PIXEL and QGLViewer::RAP_IS_CENTER
in the <a href="../mouse.html">mouse page</a>). */
Vec pivotPoint() const { return pivotPoint_; }
/*! Sets the pivotPoint(), defined in the world coordinate system. */
void setPivotPoint(const Vec& point) { pivotPoint_ = point; }
#ifndef DOXYGEN
Vec revolveAroundPoint() const { qWarning("revolveAroundPoint() is deprecated, use pivotPoint() instead"); return pivotPoint(); }
void setRevolveArountPoint(const Vec& point) { qWarning("setRevolveAroundPoint() is deprecated, use setPivotPoint() instead"); setPivotPoint(point); }
#endif
//@}
/*! @name Camera manipulation */
//@{
public:
/*! Returns \c true when the frame's rotation is constrained around the sceneUpVector(),
and \c false otherwise, when the rotation is completely free (default).
In free mode, the associated camera can be arbitrarily rotated in the scene, along its
three axis, thus possibly leading to any arbitrary orientation.
When you setRotatesAroundUpVector() to \c true, the sceneUpVector() defines a
'vertical' direction around which the camera rotates. The camera can rotate left
or right, around this axis. It can also be moved up or down to show the 'top' and
'bottom' views of the scene. As a result, the sceneUpVector() will always appear vertical
in the scene, and the horizon is preserved and stays projected along the camera's
horizontal axis.
Note that setting this value to \c true when the sceneUpVector() is not already
vertically projected will break these invariants. It will also limit the possible movement
of the camera, possibly up to a lock when the sceneUpVector() is projected horizontally.
Use Camera::setUpVector() to define the sceneUpVector() and align the camera before calling
this method to ensure this does not happen. */
bool rotatesAroundUpVector() const { return rotatesAroundUpVector_; }
/*! Sets the value of rotatesAroundUpVector().
Default value is false (free rotation). */
void setRotatesAroundUpVector(bool constrained) { rotatesAroundUpVector_ = constrained; }
/*! Returns whether or not the QGLViewer::ZOOM action zooms on the pivot point.
When set to \c false (default), a zoom action will move the camera along its Camera::viewDirection(),
i.e. back and forth along a direction perpendicular to the projection screen.
setZoomsOnPivotPoint() to \c true will move the camera along an axis defined by the
Camera::pivotPoint() and its current position instead. As a result, the projected position of the
pivot point on screen will stay the same during a zoom. */
bool zoomsOnPivotPoint() const { return zoomsOnPivotPoint_; }
/*! Sets the value of zoomsOnPivotPoint().
Default value is false. */
void setZoomsOnPivotPoint(bool enabled) { zoomsOnPivotPoint_ = enabled; }
private:
#ifndef DOXYGEN
void zoom(qreal delta, const Camera * const camera);
#endif
//@}
/*! @name Fly parameters */
//@{
public Q_SLOTS:
/*! Sets the flySpeed(), defined in OpenGL units.
Default value is 0.0, but it is modified according to the QGLViewer::sceneRadius() when the
ManipulatedCameraFrame is set as the Camera::frame(). */
void setFlySpeed(qreal speed) { flySpeed_ = speed; }
/*! Sets the sceneUpVector(), defined in the world coordinate system.
Default value is (0,1,0), but it is updated by the Camera when this object is set as its Camera::frame().
Using Camera::setUpVector() instead is probably a better solution. */
void setSceneUpVector(const Vec& up) { sceneUpVector_ = up; }
public:
/*! Returns the fly speed, expressed in OpenGL units.
It corresponds to the incremental displacement that is periodically applied to the
ManipulatedCameraFrame position when a QGLViewer::MOVE_FORWARD or QGLViewer::MOVE_BACKWARD
QGLViewer::MouseAction is proceeded.
\attention When the ManipulatedCameraFrame is set as the Camera::frame(), this value is set
according to the QGLViewer::sceneRadius() by QGLViewer::setSceneRadius(). */
qreal flySpeed() const { return flySpeed_; }
/*! Returns the up vector of the scene, expressed in the world coordinate system.
In 'fly mode' (corresponding to the QGLViewer::MOVE_FORWARD and QGLViewer::MOVE_BACKWARD
QGLViewer::MouseAction bindings), horizontal displacements of the mouse rotate
the ManipulatedCameraFrame around this vector. Vertical displacements rotate always around the
Camera \c X axis.
This value is also used when setRotationIsConstrained() is set to \c true to define the up vector
(and incidentally the 'horizon' plane) around which the camera will rotate.
Default value is (0,1,0), but it is updated by the Camera when this object is set as its Camera::frame().
Camera::setOrientation() and Camera::setUpVector()) direclty modify this value and should be used
instead. */
Vec sceneUpVector() const { return sceneUpVector_; }
#ifndef DOXYGEN
Vec flyUpVector() const;
void setFlyUpVector(const Vec& up);
#endif
//@}
/*! @name Mouse event handlers */
//@{
protected:
virtual void mouseReleaseEvent(QMouseEvent* const event, Camera* const camera);
virtual void mouseMoveEvent (QMouseEvent* const event, Camera* const camera);
virtual void wheelEvent (QWheelEvent* const event, Camera* const camera);
//@}
/*! @name Spinning */
//@{
protected Q_SLOTS:
virtual void spin();
//@}
/*! @name XML representation */
//@{
public:
virtual QDomElement domElement(const QString& name, QDomDocument& document) const;
public Q_SLOTS:
virtual void initFromDOMElement(const QDomElement& element);
//@}
#ifndef DOXYGEN
protected:
virtual void startAction(int ma, bool withConstraint=true); // int is really a QGLViewer::MouseAction
#endif
private Q_SLOTS:
virtual void flyUpdate();
private:
void updateSceneUpVector();
Quaternion turnQuaternion(int x, const Camera* const camera);
Quaternion pitchYawQuaternion(int x, int y, const Camera* const camera);
private:
// Fly mode data
qreal flySpeed_;
qreal driveSpeed_;
Vec sceneUpVector_;
QTimer flyTimer_;
bool rotatesAroundUpVector_;
// Inverse the direction of an horizontal mouse motion. Depends on the projected
// screen orientation of the vertical axis when the mouse button is pressed.
bool constrainedRotationIsReversed_;
bool zoomsOnPivotPoint_;
Vec pivotPoint_;
};
} // namespace qglviewer
#endif // QGLVIEWER_MANIPULATED_CAMERA_FRAME_H
| 9,398 | 39.166667 | 151 | h |
octomap | octomap-master/octovis/src/extern/QGLViewer/manipulatedFrame.cpp | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#include "domUtils.h"
#include "manipulatedFrame.h"
#include "manipulatedCameraFrame.h"
#include "qglviewer.h"
#include "camera.h"
#include <cstdlib>
#include <QMouseEvent>
using namespace qglviewer;
using namespace std;
/*! Default constructor.
The translation is set to (0,0,0), with an identity rotation (0,0,0,1) (see Frame constructor
for details).
The different sensitivities are set to their default values (see rotationSensitivity(),
translationSensitivity(), spinningSensitivity() and wheelSensitivity()). */
ManipulatedFrame::ManipulatedFrame()
: action_(QGLViewer::NO_MOUSE_ACTION), keepsGrabbingMouse_(false)
{
// #CONNECTION# initFromDOMElement and accessor docs
setRotationSensitivity(1.0);
setTranslationSensitivity(1.0);
setSpinningSensitivity(0.3);
setWheelSensitivity(1.0);
setZoomSensitivity(1.0);
isSpinning_ = false;
previousConstraint_ = NULL;
connect(&spinningTimer_, SIGNAL(timeout()), SLOT(spinUpdate()));
}
/*! Equal operator. Calls Frame::operator=() and then copy attributes. */
ManipulatedFrame& ManipulatedFrame::operator=(const ManipulatedFrame& mf)
{
Frame::operator=(mf);
setRotationSensitivity(mf.rotationSensitivity());
setTranslationSensitivity(mf.translationSensitivity());
setSpinningSensitivity(mf.spinningSensitivity());
setWheelSensitivity(mf.wheelSensitivity());
setZoomSensitivity(mf.zoomSensitivity());
mouseSpeed_ = 0.0;
dirIsFixed_ = false;
keepsGrabbingMouse_ = false;
action_ = QGLViewer::NO_MOUSE_ACTION;
return *this;
}
/*! Copy constructor. Performs a deep copy of all attributes using operator=(). */
ManipulatedFrame::ManipulatedFrame(const ManipulatedFrame& mf)
: Frame(mf), MouseGrabber()
{
(*this)=mf;
}
////////////////////////////////////////////////////////////////////////////////
/*! Implementation of the MouseGrabber main method.
The ManipulatedFrame grabsMouse() when the mouse is within a 10 pixels region around its
Camera::projectedCoordinatesOf() position().
See the <a href="../examples/mouseGrabber.html">mouseGrabber example</a> for an illustration. */
void ManipulatedFrame::checkIfGrabsMouse(int x, int y, const Camera* const camera)
{
const int thresold = 10;
const Vec proj = camera->projectedCoordinatesOf(position());
setGrabsMouse(keepsGrabbingMouse_ || ((fabs(x-proj.x) < thresold) && (fabs(y-proj.y) < thresold)));
}
////////////////////////////////////////////////////////////////////////////////
// S t a t e s a v i n g a n d r e s t o r i n g //
////////////////////////////////////////////////////////////////////////////////
/*! Returns an XML \c QDomElement that represents the ManipulatedFrame.
Adds to the Frame::domElement() the ManipulatedFrame specific informations in a \c
ManipulatedParameters child QDomElement.
\p name is the name of the QDomElement tag. \p doc is the \c QDomDocument factory used to create
QDomElement.
Use initFromDOMElement() to restore the ManipulatedFrame state from the resulting \c QDomElement.
See Vec::domElement() for a complete example. See also Quaternion::domElement(),
Camera::domElement()... */
QDomElement ManipulatedFrame::domElement(const QString& name, QDomDocument& document) const
{
QDomElement e = Frame::domElement(name, document);
QDomElement mp = document.createElement("ManipulatedParameters");
mp.setAttribute("rotSens", QString::number(rotationSensitivity()));
mp.setAttribute("transSens", QString::number(translationSensitivity()));
mp.setAttribute("spinSens", QString::number(spinningSensitivity()));
mp.setAttribute("wheelSens", QString::number(wheelSensitivity()));
mp.setAttribute("zoomSens", QString::number(zoomSensitivity()));
e.appendChild(mp);
return e;
}
/*! Restores the ManipulatedFrame state from a \c QDomElement created by domElement().
Fields that are not described in \p element are set to their default values (see
ManipulatedFrame()).
First calls Frame::initFromDOMElement() and then initializes ManipulatedFrame specific parameters.
Note that constraint() and referenceFrame() are not restored and are left unchanged.
See Vec::initFromDOMElement() for a complete code example. */
void ManipulatedFrame::initFromDOMElement(const QDomElement& element)
{
// Not called since it would set constraint() and referenceFrame() to NULL.
// *this = ManipulatedFrame();
Frame::initFromDOMElement(element);
stopSpinning();
QDomElement child=element.firstChild().toElement();
while (!child.isNull())
{
if (child.tagName() == "ManipulatedParameters")
{
// #CONNECTION# constructor default values and accessor docs
setRotationSensitivity (DomUtils::qrealFromDom(child, "rotSens", 1.0));
setTranslationSensitivity(DomUtils::qrealFromDom(child, "transSens", 1.0));
setSpinningSensitivity (DomUtils::qrealFromDom(child, "spinSens", 0.3));
setWheelSensitivity (DomUtils::qrealFromDom(child, "wheelSens", 1.0));
setZoomSensitivity (DomUtils::qrealFromDom(child, "zoomSens", 1.0));
}
child = child.nextSibling().toElement();
}
}
////////////////////////////////////////////////////////////////////////////////
// M o u s e h a n d l i n g //
////////////////////////////////////////////////////////////////////////////////
/*! Returns \c true when the ManipulatedFrame is being manipulated with the mouse.
Can be used to change the display of the manipulated object during manipulation.
When Camera::frame() of the QGLViewer::camera() isManipulated(), QGLViewer::fastDraw() is used in
place of QGLViewer::draw() for scene rendering. A simplified drawing will then allow for
interactive camera displacements. */
bool ManipulatedFrame::isManipulated() const
{
return action_ != QGLViewer::NO_MOUSE_ACTION;
}
/*! Starts the spinning of the ManipulatedFrame.
This method starts a timer that will call spin() every \p updateInterval milliseconds. The
ManipulatedFrame isSpinning() until you call stopSpinning(). */
void ManipulatedFrame::startSpinning(int updateInterval)
{
isSpinning_ = true;
spinningTimer_.start(updateInterval);
}
/*! Rotates the ManipulatedFrame by its spinningQuaternion(). Called by a timer when the
ManipulatedFrame isSpinning(). */
void ManipulatedFrame::spin()
{
rotate(spinningQuaternion());
}
/* spin() and spinUpdate() differ since spin can be used by itself (for instance by
QGLViewer::SCREEN_ROTATE) without a spun emission. Much nicer to use the spinningQuaternion() and
hence spin() for these incremental updates. Nothing special to be done for continuous spinning
with this design. */
void ManipulatedFrame::spinUpdate()
{
spin();
Q_EMIT spun();
}
#ifndef DOXYGEN
/*! Protected internal method used to handle mouse events. */
void ManipulatedFrame::startAction(int ma, bool withConstraint)
{
action_ = (QGLViewer::MouseAction)(ma);
// #CONNECTION# manipulatedFrame::wheelEvent, manipulatedCameraFrame::wheelEvent and mouseReleaseEvent()
// restore previous constraint
if (withConstraint)
previousConstraint_ = NULL;
else
{
previousConstraint_ = constraint();
setConstraint(NULL);
}
switch (action_)
{
case QGLViewer::ROTATE:
case QGLViewer::SCREEN_ROTATE:
mouseSpeed_ = 0.0;
stopSpinning();
break;
case QGLViewer::SCREEN_TRANSLATE:
dirIsFixed_ = false;
break;
default:
break;
}
}
/*! Updates mouse speed, measured in pixels/milliseconds. Should be called by any method which wants to
use mouse speed. Currently used to trigger spinning in mouseReleaseEvent(). */
void ManipulatedFrame::computeMouseSpeed(const QMouseEvent* const e)
{
const QPoint delta = (e->pos() - prevPos_);
const qreal dist = sqrt(qreal(delta.x()*delta.x() + delta.y()*delta.y()));
delay_ = last_move_time.restart();
if (delay_ == 0)
// Less than a millisecond: assume delay = 1ms
mouseSpeed_ = dist;
else
mouseSpeed_ = dist/delay_;
}
/*! Return 1 if mouse motion was started horizontally and -1 if it was more vertical. Returns 0 if
this could not be determined yet (perfect diagonal motion, rare). */
int ManipulatedFrame::mouseOriginalDirection(const QMouseEvent* const e)
{
static bool horiz = true; // Two simultaneous manipulatedFrame require two mice !
if (!dirIsFixed_)
{
const QPoint delta = e->pos() - pressPos_;
dirIsFixed_ = abs(delta.x()) != abs(delta.y());
horiz = abs(delta.x()) > abs(delta.y());
}
if (dirIsFixed_)
if (horiz)
return 1;
else
return -1;
else
return 0;
}
qreal ManipulatedFrame::deltaWithPrevPos(QMouseEvent* const event, Camera* const camera) const {
qreal dx = qreal(event->x() - prevPos_.x()) / camera->screenWidth();
qreal dy = qreal(event->y() - prevPos_.y()) / camera->screenHeight();
qreal value = fabs(dx) > fabs(dy) ? dx : dy;
return value * zoomSensitivity();
}
qreal ManipulatedFrame::wheelDelta(const QWheelEvent* event) const {
static const qreal WHEEL_SENSITIVITY_COEF = 8E-4;
return event->delta() * wheelSensitivity() * WHEEL_SENSITIVITY_COEF;
}
void ManipulatedFrame::zoom(qreal delta, const Camera * const camera) {
Vec trans(0.0, 0.0, (camera->position() - position()).norm() * delta);
trans = camera->frame()->orientation().rotate(trans);
if (referenceFrame())
trans = referenceFrame()->transformOf(trans);
translate(trans);
}
#endif // DOXYGEN
/*! Initiates the ManipulatedFrame mouse manipulation.
Overloading of MouseGrabber::mousePressEvent(). See also mouseMoveEvent() and mouseReleaseEvent().
The mouse behavior depends on which button is pressed. See the <a href="../mouse.html">QGLViewer
mouse page</a> for details. */
void ManipulatedFrame::mousePressEvent(QMouseEvent* const event, Camera* const camera)
{
Q_UNUSED(camera);
if (grabsMouse())
keepsGrabbingMouse_ = true;
// #CONNECTION setMouseBinding
// action_ should no longer possibly be NO_MOUSE_ACTION since this value is not inserted in mouseBinding_
//if (action_ == QGLViewer::NO_MOUSE_ACTION)
//event->ignore();
prevPos_ = pressPos_ = event->pos();
}
/*! Modifies the ManipulatedFrame according to the mouse motion.
Actual behavior depends on mouse bindings. See the QGLViewer::MouseAction enum and the <a
href="../mouse.html">QGLViewer mouse page</a> for details.
The \p camera is used to fit the mouse motion with the display parameters (see
Camera::screenWidth(), Camera::screenHeight(), Camera::fieldOfView()).
Emits the manipulated() signal. */
void ManipulatedFrame::mouseMoveEvent(QMouseEvent* const event, Camera* const camera)
{
switch (action_)
{
case QGLViewer::TRANSLATE:
{
const QPoint delta = event->pos() - prevPos_;
Vec trans(delta.x(), -delta.y(), 0.0);
// Scale to fit the screen mouse displacement
switch (camera->type())
{
case Camera::PERSPECTIVE :
trans *= 2.0 * tan(camera->fieldOfView()/2.0) * fabs((camera->frame()->coordinatesOf(position())).z) / camera->screenHeight();
break;
case Camera::ORTHOGRAPHIC :
{
GLdouble w,h;
camera->getOrthoWidthHeight(w, h);
trans[0] *= 2.0 * w / camera->screenWidth();
trans[1] *= 2.0 * h / camera->screenHeight();
break;
}
}
// Transform to world coordinate system.
trans = camera->frame()->orientation().rotate(translationSensitivity()*trans);
// And then down to frame
if (referenceFrame()) trans = referenceFrame()->transformOf(trans);
translate(trans);
break;
}
case QGLViewer::ZOOM:
{
zoom(deltaWithPrevPos(event, camera), camera);
break;
}
case QGLViewer::SCREEN_ROTATE:
{
Vec trans = camera->projectedCoordinatesOf(position());
const qreal prev_angle = atan2(prevPos_.y()-trans[1], prevPos_.x()-trans[0]);
const qreal angle = atan2(event->y()-trans[1], event->x()-trans[0]);
const Vec axis = transformOf(camera->frame()->inverseTransformOf(Vec(0.0, 0.0, -1.0)));
Quaternion rot(axis, angle-prev_angle);
//#CONNECTION# These two methods should go together (spinning detection and activation)
computeMouseSpeed(event);
setSpinningQuaternion(rot);
spin();
break;
}
case QGLViewer::SCREEN_TRANSLATE:
{
Vec trans;
int dir = mouseOriginalDirection(event);
if (dir == 1)
trans.setValue(event->x() - prevPos_.x(), 0.0, 0.0);
else if (dir == -1)
trans.setValue(0.0, prevPos_.y() - event->y(), 0.0);
switch (camera->type())
{
case Camera::PERSPECTIVE :
trans *= 2.0 * tan(camera->fieldOfView()/2.0) * fabs((camera->frame()->coordinatesOf(position())).z) / camera->screenHeight();
break;
case Camera::ORTHOGRAPHIC :
{
GLdouble w,h;
camera->getOrthoWidthHeight(w, h);
trans[0] *= 2.0 * w / camera->screenWidth();
trans[1] *= 2.0 * h / camera->screenHeight();
break;
}
}
// Transform to world coordinate system.
trans = camera->frame()->orientation().rotate(translationSensitivity()*trans);
// And then down to frame
if (referenceFrame())
trans = referenceFrame()->transformOf(trans);
translate(trans);
break;
}
case QGLViewer::ROTATE:
{
Vec trans = camera->projectedCoordinatesOf(position());
Quaternion rot = deformedBallQuaternion(event->x(), event->y(), trans[0], trans[1], camera);
trans = Vec(-rot[0], -rot[1], -rot[2]);
trans = camera->frame()->orientation().rotate(trans);
trans = transformOf(trans);
rot[0] = trans[0];
rot[1] = trans[1];
rot[2] = trans[2];
//#CONNECTION# These two methods should go together (spinning detection and activation)
computeMouseSpeed(event);
setSpinningQuaternion(rot);
spin();
break;
}
case QGLViewer::MOVE_FORWARD:
case QGLViewer::MOVE_BACKWARD:
case QGLViewer::LOOK_AROUND:
case QGLViewer::ROLL:
case QGLViewer::DRIVE:
case QGLViewer::ZOOM_ON_REGION:
// These MouseAction values make no sense for a manipulatedFrame
break;
case QGLViewer::NO_MOUSE_ACTION:
// Possible when the ManipulatedFrame is a MouseGrabber. This method is then called without startAction
// because of mouseTracking.
break;
}
if (action_ != QGLViewer::NO_MOUSE_ACTION)
{
prevPos_ = event->pos();
Q_EMIT manipulated();
}
}
/*! Stops the ManipulatedFrame mouse manipulation.
Overloading of MouseGrabber::mouseReleaseEvent().
If the action was a QGLViewer::ROTATE QGLViewer::MouseAction, a continuous spinning is possible if
the speed of the mouse cursor is larger than spinningSensitivity() when the button is released.
Press the rotate button again to stop spinning. See startSpinning() and isSpinning(). */
void ManipulatedFrame::mouseReleaseEvent(QMouseEvent* const event, Camera* const camera)
{
Q_UNUSED(event);
Q_UNUSED(camera);
keepsGrabbingMouse_ = false;
if (previousConstraint_)
setConstraint(previousConstraint_);
if (((action_ == QGLViewer::ROTATE) || (action_ == QGLViewer::SCREEN_ROTATE)) && (mouseSpeed_ >= spinningSensitivity()))
startSpinning(delay_);
action_ = QGLViewer::NO_MOUSE_ACTION;
}
/*! Overloading of MouseGrabber::mouseDoubleClickEvent().
Left button double click aligns the ManipulatedFrame with the \p camera axis (see alignWithFrame()
and QGLViewer::ALIGN_FRAME). Right button projects the ManipulatedFrame on the \p camera view
direction. */
void ManipulatedFrame::mouseDoubleClickEvent(QMouseEvent* const event, Camera* const camera)
{
if (event->modifiers() == Qt::NoModifier)
switch (event->button())
{
case Qt::LeftButton: alignWithFrame(camera->frame()); break;
case Qt::RightButton: projectOnLine(camera->position(), camera->viewDirection()); break;
default: break;
}
}
/*! Overloading of MouseGrabber::wheelEvent().
Using the wheel is equivalent to a QGLViewer::ZOOM QGLViewer::MouseAction. See
QGLViewer::setWheelBinding(), setWheelSensitivity(). */
void ManipulatedFrame::wheelEvent(QWheelEvent* const event, Camera* const camera)
{
//#CONNECTION# QGLViewer::setWheelBinding
if (action_ == QGLViewer::ZOOM)
{
zoom(wheelDelta(event), camera);
Q_EMIT manipulated();
}
// #CONNECTION# startAction should always be called before
if (previousConstraint_)
setConstraint(previousConstraint_);
action_ = QGLViewer::NO_MOUSE_ACTION;
}
////////////////////////////////////////////////////////////////////////////////
/*! Returns "pseudo-distance" from (x,y) to ball of radius size.
\arg for a point inside the ball, it is proportional to the euclidean distance to the ball
\arg for a point outside the ball, it is proportional to the inverse of this distance (tends to
zero) on the ball, the function is continuous. */
static qreal projectOnBall(qreal x, qreal y)
{
// If you change the size value, change angle computation in deformedBallQuaternion().
const qreal size = 1.0;
const qreal size2 = size*size;
const qreal size_limit = size2*0.5;
const qreal d = x*x + y*y;
return d < size_limit ? sqrt(size2 - d) : size_limit/sqrt(d);
}
#ifndef DOXYGEN
/*! Returns a quaternion computed according to the mouse motion. Mouse positions are projected on a
deformed ball, centered on (\p cx,\p cy). */
Quaternion ManipulatedFrame::deformedBallQuaternion(int x, int y, qreal cx, qreal cy, const Camera* const camera)
{
// Points on the deformed ball
qreal px = rotationSensitivity() * (prevPos_.x() - cx) / camera->screenWidth();
qreal py = rotationSensitivity() * (cy - prevPos_.y()) / camera->screenHeight();
qreal dx = rotationSensitivity() * (x - cx) / camera->screenWidth();
qreal dy = rotationSensitivity() * (cy - y) / camera->screenHeight();
const Vec p1(px, py, projectOnBall(px, py));
const Vec p2(dx, dy, projectOnBall(dx, dy));
// Approximation of rotation angle
// Should be divided by the projectOnBall size, but it is 1.0
const Vec axis = cross(p2,p1);
const qreal angle = 5.0 * asin(sqrt(axis.squaredNorm() / p1.squaredNorm() / p2.squaredNorm()));
return Quaternion(axis, angle);
}
#endif // DOXYGEN
| 18,749 | 33.029038 | 131 | cpp |
octomap | octomap-master/octovis/src/extern/QGLViewer/manipulatedFrame.h | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#ifndef QGLVIEWER_MANIPULATED_FRAME_H
#define QGLVIEWER_MANIPULATED_FRAME_H
#include "frame.h"
#include "mouseGrabber.h"
#include "qglviewer.h"
#include <QString>
#include <QTimer>
#include <QDateTime>
namespace qglviewer {
/*! \brief A ManipulatedFrame is a Frame that can be rotated and translated using the mouse.
\class ManipulatedFrame manipulatedFrame.h QGLViewer/manipulatedFrame.h
It converts the mouse motion into a translation and an orientation updates. A ManipulatedFrame is
used to move an object in the scene. Combined with object selection, its MouseGrabber properties
and a dynamic update of the scene, the ManipulatedFrame introduces a great reactivity in your
applications.
A ManipulatedFrame is attached to a QGLViewer using QGLViewer::setManipulatedFrame():
\code
init() { setManipulatedFrame( new ManipulatedFrame() ); }
draw()
{
glPushMatrix();
glMultMatrixd(manipulatedFrame()->matrix());
// draw the manipulated object here
glPopMatrix();
}
\endcode
See the <a href="../examples/manipulatedFrame.html">manipulatedFrame example</a> for a complete
application.
Mouse events are normally sent to the QGLViewer::camera(). You have to press the QGLViewer::FRAME
state key (default is \c Control) to move the QGLViewer::manipulatedFrame() instead. See the <a
href="../mouse.html">mouse page</a> for a description of mouse button bindings.
<h3>Inherited functionalities</h3>
A ManipulatedFrame is an overloaded instance of a Frame. The powerful coordinate system
transformation functions (Frame::coordinatesOf(), Frame::transformOf(), ...) can hence be applied
to a ManipulatedFrame.
A ManipulatedFrame is also a MouseGrabber. If the mouse cursor gets within a distance of 10 pixels
from the projected position of the ManipulatedFrame, the ManipulatedFrame becomes the new
QGLViewer::mouseGrabber(). It can then be manipulated directly, without any specific state key,
object selection or GUI intervention. This is very convenient to directly move some objects in the
scene (typically a light). See the <a href="../examples/mouseGrabber.html">mouseGrabber
example</a> as an illustration. Note that QWidget::setMouseTracking() needs to be enabled in order
to use this feature (see the MouseGrabber documentation).
<h3>Advanced functionalities</h3>
A QGLViewer can handle at most one ManipulatedFrame at a time. If you want to move several objects
in the scene, you simply have to keep a list of the different ManipulatedFrames, and to activate
the right one (using QGLViewer::setManipulatedFrame()) when needed. This can for instance be done
according to an object selection: see the <a href="../examples/luxo.html">luxo example</a> for an
illustration.
When the ManipulatedFrame is being manipulated using the mouse (mouse pressed and not yet
released), isManipulated() returns \c true. This might be used to trigger a specific action or
display (as is done with QGLViewer::fastDraw()).
The ManipulatedFrame also emits a manipulated() signal each time its state is modified by the
mouse. This signal is automatically connected to the QGLViewer::update() slot when the
ManipulatedFrame is attached to a viewer using QGLViewer::setManipulatedFrame().
You can make the ManipulatedFrame spin() if you release the rotation mouse button while moving the
mouse fast enough (see spinningSensitivity()). See also translationSensitivity() and
rotationSensitivity() for sensitivity tuning. \nosubgrouping */
class QGLVIEWER_EXPORT ManipulatedFrame : public Frame, public MouseGrabber
{
#ifndef DOXYGEN
friend class Camera;
friend class ::QGLViewer;
#endif
Q_OBJECT
public:
ManipulatedFrame();
/*! Virtual destructor. Empty. */
virtual ~ManipulatedFrame() {}
ManipulatedFrame(const ManipulatedFrame& mf);
ManipulatedFrame& operator=(const ManipulatedFrame& mf);
Q_SIGNALS:
/*! This signal is emitted when ever the ManipulatedFrame is manipulated (i.e. rotated or
translated) using the mouse. Connect this signal to any object that should be notified.
Note that this signal is automatically connected to the QGLViewer::update() slot, when the
ManipulatedFrame is attached to a viewer using QGLViewer::setManipulatedFrame(), which is
probably all you need.
Use the QGLViewer::QGLViewerPool() if you need to connect this signal to all the viewers.
See also the spun(), modified(), interpolated() and KeyFrameInterpolator::interpolated()
signals' documentations. */
void manipulated();
/*! This signal is emitted when the ManipulatedFrame isSpinning().
Note that for the QGLViewer::manipulatedFrame(), this signal is automatically connected to the
QGLViewer::update() slot.
Connect this signal to any object that should be notified. Use the QGLViewer::QGLViewerPool() if
you need to connect this signal to all the viewers.
See also the manipulated(), modified(), interpolated() and KeyFrameInterpolator::interpolated()
signals' documentations. */
void spun();
/*! @name Manipulation sensitivity */
//@{
public Q_SLOTS:
/*! Defines the rotationSensitivity(). */
void setRotationSensitivity(qreal sensitivity) { rotationSensitivity_ = sensitivity; }
/*! Defines the translationSensitivity(). */
void setTranslationSensitivity(qreal sensitivity) { translationSensitivity_ = sensitivity; }
/*! Defines the spinningSensitivity(), in pixels per milliseconds. */
void setSpinningSensitivity(qreal sensitivity) { spinningSensitivity_ = sensitivity; }
/*! Defines the wheelSensitivity(). */
void setWheelSensitivity(qreal sensitivity) { wheelSensitivity_ = sensitivity; }
/*! Defines the zoomSensitivity(). */
void setZoomSensitivity(qreal sensitivity) { zoomSensitivity_ = sensitivity; }
public:
/*! Returns the influence of a mouse displacement on the ManipulatedFrame rotation.
Default value is 1.0. With an identical mouse displacement, a higher value will generate a
larger rotation (and inversely for lower values). A 0.0 value will forbid ManipulatedFrame mouse
rotation (see also constraint()).
See also setRotationSensitivity(), translationSensitivity(), spinningSensitivity() and
wheelSensitivity(). */
qreal rotationSensitivity() const { return rotationSensitivity_; }
/*! Returns the influence of a mouse displacement on the ManipulatedFrame translation.
Default value is 1.0. You should not have to modify this value, since with 1.0 the
ManipulatedFrame precisely stays under the mouse cursor.
With an identical mouse displacement, a higher value will generate a larger translation (and
inversely for lower values). A 0.0 value will forbid ManipulatedFrame mouse translation (see
also constraint()).
\note When the ManipulatedFrame is used to move a \e Camera (see the ManipulatedCameraFrame
class documentation), after zooming on a small region of your scene, the camera may translate
too fast. For a camera, it is the Camera::pivotPoint() that exactly matches the mouse
displacement. Hence, instead of changing the translationSensitivity(), solve the problem by
(temporarily) setting the Camera::pivotPoint() to a point on the zoomed region (see the
QGLViewer::RAP_FROM_PIXEL mouse binding in the <a href="../mouse.html">mouse page</a>).
See also setTranslationSensitivity(), rotationSensitivity(), spinningSensitivity() and
wheelSensitivity(). */
qreal translationSensitivity() const { return translationSensitivity_; }
/*! Returns the minimum mouse speed required (at button release) to make the ManipulatedFrame
spin().
See spin(), spinningQuaternion() and startSpinning() for details.
Mouse speed is expressed in pixels per milliseconds. Default value is 0.3 (300 pixels per
second). Use setSpinningSensitivity() to tune this value. A higher value will make spinning more
difficult (a value of 100.0 forbids spinning in practice).
See also setSpinningSensitivity(), translationSensitivity(), rotationSensitivity() and
wheelSensitivity(). */
qreal spinningSensitivity() const { return spinningSensitivity_; }
/*! Returns the zoom sensitivity.
Default value is 1.0. A higher value will make the zoom faster.
Use a negative value to invert the zoom in and out directions.
See also setZoomSensitivity(), translationSensitivity(), rotationSensitivity() wheelSensitivity()
and spinningSensitivity(). */
qreal zoomSensitivity() const { return zoomSensitivity_; }
/*! Returns the mouse wheel sensitivity.
Default value is 1.0. A higher value will make the wheel action more efficient (usually meaning
a faster zoom). Use a negative value to invert the zoom in and out directions.
See also setWheelSensitivity(), translationSensitivity(), rotationSensitivity() zoomSensitivity()
and spinningSensitivity(). */
qreal wheelSensitivity() const { return wheelSensitivity_; }
//@}
/*! @name Spinning */
//@{
public:
/*! Returns \c true when the ManipulatedFrame is spinning.
During spinning, spin() rotates the ManipulatedFrame by its spinningQuaternion() at a frequency
defined when the ManipulatedFrame startSpinning().
Use startSpinning() and stopSpinning() to change this state. Default value is \c false. */
bool isSpinning() const { return isSpinning_; }
/*! Returns the incremental rotation that is applied by spin() to the ManipulatedFrame
orientation when it isSpinning().
Default value is a null rotation (identity Quaternion). Use setSpinningQuaternion() to change
this value.
The spinningQuaternion() axis is defined in the ManipulatedFrame coordinate system. You can use
Frame::transformOfFrom() to convert this axis from an other Frame coordinate system. */
Quaternion spinningQuaternion() const { return spinningQuaternion_; }
public Q_SLOTS:
/*! Defines the spinningQuaternion(). Its axis is defined in the ManipulatedFrame coordinate
system. */
void setSpinningQuaternion(const Quaternion& spinningQuaternion) { spinningQuaternion_ = spinningQuaternion; }
virtual void startSpinning(int updateInterval);
/*! Stops the spinning motion started using startSpinning(). isSpinning() will return \c false
after this call. */
virtual void stopSpinning() { spinningTimer_.stop(); isSpinning_ = false; }
protected Q_SLOTS:
virtual void spin();
private Q_SLOTS:
void spinUpdate();
//@}
/*! @name Mouse event handlers */
//@{
protected:
virtual void mousePressEvent (QMouseEvent* const event, Camera* const camera);
virtual void mouseMoveEvent (QMouseEvent* const event, Camera* const camera);
virtual void mouseReleaseEvent (QMouseEvent* const event, Camera* const camera);
virtual void mouseDoubleClickEvent(QMouseEvent* const event, Camera* const camera);
virtual void wheelEvent (QWheelEvent* const event, Camera* const camera);
//@}
public:
/*! @name Current state */
//@{
bool isManipulated() const;
/*! Returns the \c MouseAction currently applied to this ManipulatedFrame.
Will return QGLViewer::NO_MOUSE_ACTION unless a mouse button is being pressed
and has been bound to this QGLViewer::MouseHandler.
The binding between mouse buttons and key modifiers and MouseAction is set using
QGLViewer::setMouseBinding(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton buttons, MouseHandler handler, MouseAction action, bool withConstraint).
*/
QGLViewer::MouseAction currentMouseAction() const { return action_; }
//@}
/*! @name MouseGrabber implementation */
//@{
public:
virtual void checkIfGrabsMouse(int x, int y, const Camera* const camera);
//@}
/*! @name XML representation */
//@{
public:
virtual QDomElement domElement(const QString& name, QDomDocument& document) const;
public Q_SLOTS:
virtual void initFromDOMElement(const QDomElement& element);
//@}
#ifndef DOXYGEN
protected:
Quaternion deformedBallQuaternion(int x, int y, qreal cx, qreal cy, const Camera* const camera);
QGLViewer::MouseAction action_;
Constraint* previousConstraint_; // When manipulation is without Contraint.
virtual void startAction(int ma, bool withConstraint=true); // int is really a QGLViewer::MouseAction
void computeMouseSpeed(const QMouseEvent* const e);
int mouseOriginalDirection(const QMouseEvent* const e);
/*! Returns a screen scaled delta from event's position to prevPos_, along the
X or Y direction, whichever has the largest magnitude. */
qreal deltaWithPrevPos(QMouseEvent* const event, Camera* const camera) const;
/*! Returns a normalized wheel delta, proportionnal to wheelSensitivity(). */
qreal wheelDelta(const QWheelEvent* event) const;
// Previous mouse position (used for incremental updates) and mouse press position.
QPoint prevPos_, pressPos_;
private:
void zoom(qreal delta, const Camera * const camera);
#endif // DOXYGEN
private:
// Sensitivity
qreal rotationSensitivity_;
qreal translationSensitivity_;
qreal spinningSensitivity_;
qreal wheelSensitivity_;
qreal zoomSensitivity_;
// Mouse speed and spinning
QTime last_move_time;
qreal mouseSpeed_;
int delay_;
bool isSpinning_;
QTimer spinningTimer_;
Quaternion spinningQuaternion_;
// Whether the SCREEN_TRANS direction (horizontal or vertical) is fixed or not.
bool dirIsFixed_;
// MouseGrabber
bool keepsGrabbingMouse_;
};
} // namespace qglviewer
#endif // QGLVIEWER_MANIPULATED_FRAME_H
| 14,207 | 41.285714 | 163 | h |
octomap | octomap-master/octovis/src/extern/QGLViewer/mouseGrabber.cpp | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#include "mouseGrabber.h"
using namespace qglviewer;
// Static private variable
QList<MouseGrabber*> MouseGrabber::MouseGrabberPool_;
/*! Default constructor.
Adds the created MouseGrabber in the MouseGrabberPool(). grabsMouse() is set to \c false. */
MouseGrabber::MouseGrabber()
: grabsMouse_(false)
{
addInMouseGrabberPool();
}
/*! Adds the MouseGrabber in the MouseGrabberPool().
All created MouseGrabber are automatically added in the MouseGrabberPool() by the constructor.
Trying to add a MouseGrabber that already isInMouseGrabberPool() has no effect.
Use removeFromMouseGrabberPool() to remove the MouseGrabber from the list, so that it is no longer
tested with checkIfGrabsMouse() by the QGLViewer, and hence can no longer grab mouse focus. Use
isInMouseGrabberPool() to know the current state of the MouseGrabber. */
void MouseGrabber::addInMouseGrabberPool()
{
if (!isInMouseGrabberPool())
MouseGrabber::MouseGrabberPool_.append(this);
}
/*! Removes the MouseGrabber from the MouseGrabberPool().
See addInMouseGrabberPool() for details. Removing a MouseGrabber that is not in MouseGrabberPool()
has no effect. */
void MouseGrabber::removeFromMouseGrabberPool()
{
if (isInMouseGrabberPool())
MouseGrabber::MouseGrabberPool_.removeAll(const_cast<MouseGrabber*>(this));
}
/*! Clears the MouseGrabberPool().
Use this method only if it is faster to clear the MouseGrabberPool() and then to add back a few
MouseGrabbers than to remove each one independently. Use QGLViewer::setMouseTracking(false) instead
if you want to disable mouse grabbing.
When \p autoDelete is \c true, the MouseGrabbers of the MouseGrabberPool() are actually deleted
(use this only if you're sure of what you do). */
void MouseGrabber::clearMouseGrabberPool(bool autoDelete)
{
if (autoDelete)
qDeleteAll(MouseGrabber::MouseGrabberPool_);
MouseGrabber::MouseGrabberPool_.clear();
}
| 2,856 | 36.103896 | 100 | cpp |
octomap | octomap-master/octovis/src/extern/QGLViewer/mouseGrabber.h | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#ifndef QGLVIEWER_MOUSE_GRABBER_H
#define QGLVIEWER_MOUSE_GRABBER_H
#include "config.h"
#include <QEvent>
class QGLViewer;
namespace qglviewer {
class Camera;
/*! \brief Abstract class for objects that grab mouse focus in a QGLViewer.
\class MouseGrabber mouseGrabber.h QGLViewer/mouseGrabber.h
MouseGrabber are objects which react to the mouse cursor, usually when it hovers over them. This
abstract class only provides an interface for all these objects: their actual behavior has to be
defined in a derived class.
<h3>How does it work ?</h3>
All the created MouseGrabber are grouped in a MouseGrabberPool(). The QGLViewers parse this pool,
calling all the MouseGrabbers' checkIfGrabsMouse() methods that setGrabsMouse() if desired.
When a MouseGrabber grabsMouse(), it becomes the QGLViewer::mouseGrabber(). All the mouse events
(mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent(), mouseDoubleClickEvent() and
wheelEvent()) are then transmitted to the QGLViewer::mouseGrabber() instead of being normally
processed. This continues while grabsMouse() (updated using checkIfGrabsMouse()) returns \c true.
If you want to (temporarily) disable a specific MouseGrabbers, you can remove it from this pool
using removeFromMouseGrabberPool(). You can also disable a MouseGrabber in a specific QGLViewer
using QGLViewer::setMouseGrabberIsEnabled().
<h3>Implementation details</h3>
In order to make MouseGrabber react to mouse events, mouse tracking has to be activated in the
QGLViewer which wants to use MouseGrabbers:
\code
init() { setMouseTracking(true); }
\endcode
Call \c QGLWidget::hasMouseTracking() to get the current state of this flag.
The \p camera parameter of the different mouse event methods is a pointer to the
QGLViewer::camera() of the QGLViewer that uses the MouseGrabber. It can be used to compute 2D to
3D coordinates conversion using Camera::projectedCoordinatesOf() and
Camera::unprojectedCoordinatesOf().
Very complex behaviors can be implemented using this framework: auto-selected objects (no need to
press a key to use them), automatic drop-down menus, 3D GUI, spinners using the wheelEvent(), and
whatever your imagination creates. See the <a href="../examples/mouseGrabber.html">mouseGrabber
example</a> for an illustration.
Note that ManipulatedFrame are MouseGrabber: see the <a href="../examples/keyFrames.html">keyFrame
example</a> for an illustration. Every created ManipulatedFrame is hence present in the
MouseGrabberPool() (note however that ManipulatedCameraFrame are not inserted).
<h3>Example</h3>
Here is for instance a draft version of a MovableObject class. Instances of these class can freely
be moved on screen using the mouse, as movable post-it-like notes:
\code
class MovableObject : public MouseGrabber
{
public:
MovableObject() : pos(0,0), moved(false) {}
void checkIfGrabsMouse(int x, int y, const qglviewer::Camera* const)
{
// MovableObject is active in a region of 5 pixels around its pos.
// May depend on the actual shape of the object. Customize as desired.
// Once clicked (moved = true), it keeps grabbing mouse until button is released.
setGrabsMouse( moved || ((pos-QPoint(x,y)).manhattanLength() < 5) );
}
void mousePressEvent( QMouseEvent* const e, Camera* const) { prevPos = e->pos(); moved = true; }
void mouseMoveEvent(QMouseEvent* const e, const Camera* const)
{
if (moved)
{
// Add position delta to current pos
pos += e->pos() - prevPos;
prevPos = e->pos();
}
}
void mouseReleaseEvent(QMouseEvent* const, Camera* const) { moved = false; }
void draw()
{
// The object is drawn centered on its pos, with different possible aspects:
if (grabsMouse())
if (moved)
// Object being moved, maybe a transparent display
else
// Object ready to be moved, maybe a highlighted visual feedback
else
// Normal display
}
private:
QPoint pos, prevPos;
bool moved;
};
\endcode
Note that the different event callback methods are called only once the MouseGrabber grabsMouse().
\nosubgrouping */
class QGLVIEWER_EXPORT MouseGrabber
{
#ifndef DOXYGEN
friend class ::QGLViewer;
#endif
public:
MouseGrabber();
/*! Virtual destructor. Removes the MouseGrabber from the MouseGrabberPool(). */
virtual ~MouseGrabber() { MouseGrabber::MouseGrabberPool_.removeAll(this); }
/*! @name Mouse grabbing detection */
//@{
public:
/*! Pure virtual method, called by the QGLViewers before they test if the MouseGrabber
grabsMouse(). Should setGrabsMouse() according to the mouse position.
This is the core method of the MouseGrabber. It has to be overloaded in your derived class.
Its goal is to update the grabsMouse() flag according to the mouse and MouseGrabber current
positions, using setGrabsMouse().
grabsMouse() is usually set to \c true when the mouse cursor is close enough to the MouseGrabber
position. It should also be set to \c false when the mouse cursor leaves this region in order to
release the mouse focus.
\p x and \p y are the mouse cursor coordinates (Qt coordinate system: (0,0) corresponds to the upper
left corner).
A typical implementation will look like:
\code
// (posX,posY) is the position of the MouseGrabber on screen.
// Here, distance to mouse must be less than 10 pixels to activate the MouseGrabber.
setGrabsMouse( sqrt((x-posX)*(x-posX) + (y-posY)*(y-posY)) < 10);
\endcode
If the MouseGrabber position is defined in 3D, use the \p camera parameter, corresponding to
the calling QGLViewer Camera. Project on screen and then compare the projected coordinates:
\code
Vec proj = camera->projectedCoordinatesOf(myMouseGrabber->frame()->position());
setGrabsMouse((fabs(x-proj.x) < 5) && (fabs(y-proj.y) < 2)); // Rectangular region
\endcode
See examples in the <a href="#_details">detailed description</a> section and in the <a
href="../examples/mouseGrabber.html">mouseGrabber example</a>. */
virtual void checkIfGrabsMouse(int x, int y, const Camera* const camera) = 0;
/*! Returns \c true when the MouseGrabber grabs the QGLViewer's mouse events.
This flag is set with setGrabsMouse() by the checkIfGrabsMouse() method. */
bool grabsMouse() const { return grabsMouse_; }
protected:
/*! Sets the grabsMouse() flag. Normally used by checkIfGrabsMouse(). */
void setGrabsMouse(bool grabs) { grabsMouse_ = grabs; }
//@}
/*! @name MouseGrabber pool */
//@{
public:
/*! Returns a list containing pointers to all the active MouseGrabbers.
Used by the QGLViewer to parse all the MouseGrabbers and to check if any of them grabsMouse()
using checkIfGrabsMouse().
You should not have to directly use this list. Use removeFromMouseGrabberPool() and
addInMouseGrabberPool() to modify this list.
\attention This method returns a \c QPtrList<MouseGrabber> with Qt 3 and a \c QList<MouseGrabber> with Qt 2. */
static const QList<MouseGrabber*>& MouseGrabberPool() { return MouseGrabber::MouseGrabberPool_; }
/*! Returns \c true if the MouseGrabber is currently in the MouseGrabberPool() list.
Default value is \c true. When set to \c false using removeFromMouseGrabberPool(), the
QGLViewers no longer checkIfGrabsMouse() on this MouseGrabber. Use addInMouseGrabberPool() to
insert it back. */
bool isInMouseGrabberPool() const { return MouseGrabber::MouseGrabberPool_.contains(const_cast<MouseGrabber*>(this)); }
void addInMouseGrabberPool();
void removeFromMouseGrabberPool();
void clearMouseGrabberPool(bool autoDelete=false);
//@}
/*! @name Mouse event handlers */
//@{
protected:
/*! Callback method called when the MouseGrabber grabsMouse() and a mouse button is pressed.
The MouseGrabber will typically start an action or change its state when a mouse button is
pressed. mouseMoveEvent() (called at each mouse displacement) will then update the MouseGrabber
accordingly and mouseReleaseEvent() (called when the mouse button is released) will terminate
this action.
Use the \p event QMouseEvent::state() and QMouseEvent::button() to test the keyboard
and button state and possibly change the MouseGrabber behavior accordingly.
See the <a href="#_details">detailed description section</a> and the <a
href="../examples/mouseGrabber.html">mouseGrabber example</a> for examples.
See the \c QGLWidget::mousePressEvent() and the \c QMouseEvent documentations for details. */
virtual void mousePressEvent(QMouseEvent* const event, Camera* const camera) { Q_UNUSED(event); Q_UNUSED(camera); }
/*! Callback method called when the MouseGrabber grabsMouse() and a mouse button is double clicked.
See the \c QGLWidget::mouseDoubleClickEvent() and the \c QMouseEvent documentations for details. */
virtual void mouseDoubleClickEvent(QMouseEvent* const event, Camera* const camera) { Q_UNUSED(event); Q_UNUSED(camera); }
/*! Mouse release event callback method. See mousePressEvent(). */
virtual void mouseReleaseEvent(QMouseEvent* const event, Camera* const camera) { Q_UNUSED(event); Q_UNUSED(camera); }
/*! Callback method called when the MouseGrabber grabsMouse() and the mouse is moved while a
button is pressed.
This method will typically update the state of the MouseGrabber from the mouse displacement. See
the mousePressEvent() documentation for details. */
virtual void mouseMoveEvent(QMouseEvent* const event, Camera* const camera) { Q_UNUSED(event); Q_UNUSED(camera); }
/*! Callback method called when the MouseGrabber grabsMouse() and the mouse wheel is used.
See the \c QGLWidget::wheelEvent() and the \c QWheelEvent documentations for details. */
virtual void wheelEvent(QWheelEvent* const event, Camera* const camera) { Q_UNUSED(event); Q_UNUSED(camera); }
//@}
private:
// Copy constructor and opertor= are declared private and undefined
// Prevents everyone from trying to use them
MouseGrabber(const MouseGrabber&);
MouseGrabber& operator=(const MouseGrabber&);
bool grabsMouse_;
// Q G L V i e w e r p o o l
static QList<MouseGrabber*> MouseGrabberPool_;
};
} // namespace qglviewer
#endif // QGLVIEWER_MOUSE_GRABBER_H
| 11,050 | 40.701887 | 122 | h |
octomap | octomap-master/octovis/src/extern/QGLViewer/qglviewer.cpp | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#include "domUtils.h"
#include "qglviewer.h"
#include "camera.h"
#include "keyFrameInterpolator.h"
#include "manipulatedCameraFrame.h"
# include <QtAlgorithms>
# include <QTextEdit>
# include <QApplication>
# include <QFileInfo>
# include <QDateTime>
# include <QMessageBox>
# include <QPushButton>
# include <QTabWidget>
# include <QTextStream>
# include <QMouseEvent>
# include <QTimer>
# include <QImage>
# include <QDir>
# include <QUrl>
using namespace std;
using namespace qglviewer;
// Static private variable
QList<QGLViewer*> QGLViewer::QGLViewerPool_;
/*! \mainpage
libQGLViewer is a free C++ library based on Qt that enables the quick creation of OpenGL 3D viewers.
It features a powerful camera trackball and simple applications simply require an implementation of
the <code>draw()</code> method. This makes it a tool of choice for OpenGL beginners and
assignments. It provides screenshot saving, mouse manipulated frames, stereo display, interpolated
keyFrames, object selection, and much more. It is fully
customizable and easy to extend to create complex applications, with a possible Qt GUI.
libQGLViewer is <i>not</i> a 3D viewer that can be used directly to view 3D scenes in various
formats. It is more likely to be the starting point for the coding of such a viewer.
libQGLViewer is based on the Qt toolkit and hence compiles on any architecture (Unix-Linux, Mac,
Windows, ...). Full reference documentation and many examples are provided.
See the project main page for details on the project and installation steps. */
void QGLViewer::defaultConstructor()
{
// Test OpenGL context
// if (glGetString(GL_VERSION) == 0)
// qWarning("Unable to get OpenGL version, context may not be available - Check your configuration");
int poolIndex = QGLViewer::QGLViewerPool_.indexOf(NULL);
setFocusPolicy(Qt::StrongFocus);
if (poolIndex >= 0)
QGLViewer::QGLViewerPool_.replace(poolIndex, this);
else
QGLViewer::QGLViewerPool_.append(this);
camera_ = new Camera();
setCamera(camera());
setDefaultShortcuts();
setDefaultMouseBindings();
setSnapshotFileName(tr("snapshot", "Default snapshot file name"));
initializeSnapshotFormats();
setSnapshotCounter(0);
setSnapshotQuality(95);
fpsTime_.start();
fpsCounter_ = 0;
f_p_s_ = 0.0;
fpsString_ = tr("%1Hz", "Frames per seconds, in Hertz").arg("?");
visualHint_ = 0;
previousPathId_ = 0;
// prevPos_ is not initialized since pos() is not meaningful here.
// It will be set when setFullScreen(false) is called after setFullScreen(true)
// #CONNECTION# default values in initFromDOMElement()
manipulatedFrame_ = NULL;
manipulatedFrameIsACamera_ = false;
mouseGrabberIsAManipulatedFrame_ = false;
mouseGrabberIsAManipulatedCameraFrame_ = false;
displayMessage_ = false;
connect(&messageTimer_, SIGNAL(timeout()), SLOT(hideMessage()));
messageTimer_.setSingleShot(true);
helpWidget_ = NULL;
setMouseGrabber(NULL);
setSceneRadius(1.0);
showEntireScene();
setStateFileName(".qglviewer.xml");
// #CONNECTION# default values in initFromDOMElement()
setAxisIsDrawn(false);
setGridIsDrawn(false);
setFPSIsDisplayed(false);
setCameraIsEdited(false);
setTextIsEnabled(true);
setStereoDisplay(false);
// Make sure move() is not called, which would call initializeGL()
fullScreen_ = false;
setFullScreen(false);
animationTimerId_ = 0;
stopAnimation();
setAnimationPeriod(40); // 25Hz
selectBuffer_ = NULL;
setSelectBufferSize(4*1000);
setSelectRegionWidth(3);
setSelectRegionHeight(3);
setSelectedName(-1);
bufferTextureId_ = 0;
bufferTextureMaxU_ = 0.0;
bufferTextureMaxV_ = 0.0;
bufferTextureWidth_ = 0;
bufferTextureHeight_ = 0;
previousBufferTextureFormat_ = 0;
previousBufferTextureInternalFormat_ = 0;
currentlyPressedKey_ = Qt::Key(0);
setAttribute(Qt::WA_NoSystemBackground);
tileRegion_ = NULL;
}
#if !defined QT3_SUPPORT
/*! Constructor. See \c QGLWidget documentation for details.
All viewer parameters (display flags, scene parameters, associated objects...) are set to their default values. See
the associated documentation.
If the \p shareWidget parameter points to a valid \c QGLWidget, the QGLViewer will share the OpenGL
context with \p shareWidget (see isSharing()). */
QGLViewer::QGLViewer(QWidget* parent, const QGLWidget* shareWidget, Qt::WindowFlags flags)
: QGLWidget(parent, shareWidget, flags)
{ defaultConstructor(); }
/*! Same as QGLViewer(), but a \c QGLContext can be provided so that viewers share GL contexts, even
with \c QGLContext sub-classes (use \p shareWidget otherwise). */
QGLViewer::QGLViewer(QGLContext *context, QWidget* parent, const QGLWidget* shareWidget, Qt::WindowFlags flags)
: QGLWidget(context, parent, shareWidget, flags)
{ defaultConstructor(); }
/*! Same as QGLViewer(), but a specific \c QGLFormat can be provided.
This is for instance needed to ask for a stencil buffer or for stereo display (as is illustrated in
the <a href="../examples/stereoViewer.html">stereoViewer example</a>). */
QGLViewer::QGLViewer(const QGLFormat& format, QWidget* parent, const QGLWidget* shareWidget, Qt::WindowFlags flags)
: QGLWidget(format, parent, shareWidget, flags)
{ defaultConstructor(); }
#endif // QT3_SUPPORT
/*! Virtual destructor.
The viewer is replaced by \c NULL in the QGLViewerPool() (in order to preserve other viewer's indexes) and allocated
memory is released. The camera() is deleted and should be copied before if it is shared by an other viewer. */
QGLViewer::~QGLViewer()
{
// See closeEvent comment. Destructor is called (and not closeEvent) only when the widget is embedded.
// Hence we saveToFile here. It is however a bad idea if virtual domElement() has been overloaded !
// if (parent())
// saveStateToFileForAllViewers();
QGLViewer::QGLViewerPool_.replace(QGLViewer::QGLViewerPool_.indexOf(this), NULL);
delete camera();
delete[] selectBuffer_;
if (helpWidget())
{
// Needed for Qt 4 which has no main widget.
helpWidget()->close();
delete helpWidget_;
}
}
static QString QGLViewerVersionString()
{
return QString::number((QGLVIEWER_VERSION & 0xff0000) >> 16) + "." +
QString::number((QGLVIEWER_VERSION & 0x00ff00) >> 8) + "." +
QString::number(QGLVIEWER_VERSION & 0x0000ff);
}
static Qt::KeyboardModifiers keyboardModifiersFromState(unsigned int state) {
// Convertion of keyboard modifiers and mouse buttons as an int is no longer supported : emulate
return Qt::KeyboardModifiers(int(state & 0xFF000000));
}
static Qt::MouseButton mouseButtonFromState(unsigned int state) {
// Convertion of keyboard modifiers and mouse buttons as an int is no longer supported : emulate
return Qt::MouseButton(state & 0xFFFF);
}
/*! Initializes the QGLViewer OpenGL context and then calls user-defined init().
This method is automatically called once, before the first call to paintGL().
Overload init() instead of this method to modify viewer specific OpenGL state or to create display
lists.
To make beginners' life easier and to simplify the examples, this method slightly modifies the
standard OpenGL state:
\code
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
glEnable(GL_COLOR_MATERIAL);
\endcode
If you port an existing application to QGLViewer and your display changes, you probably want to
disable these flags in init() to get back to a standard OpenGL state. */
void QGLViewer::initializeGL()
{
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
glEnable(GL_COLOR_MATERIAL);
// Default colors
setForegroundColor(QColor(180, 180, 180));
setBackgroundColor(QColor(51, 51, 51));
// Clear the buffer where we're going to draw
if (format().stereo())
{
glDrawBuffer(GL_BACK_RIGHT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDrawBuffer(GL_BACK_LEFT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
else
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Calls user defined method. Default emits a signal.
init();
// Give time to glInit to finish and then call setFullScreen().
if (isFullScreen())
QTimer::singleShot( 100, this, SLOT(delayedFullScreen()) );
}
/*! Main paint method, inherited from \c QGLWidget.
Calls the following methods, in that order:
\arg preDraw() (or preDrawStereo() if viewer displaysInStereo()) : places the camera in the world coordinate system.
\arg draw() (or fastDraw() when the camera is manipulated) : main drawing method. Should be overloaded.
\arg postDraw() : display of visual hints (world axis, FPS...) */
void QGLViewer::paintGL()
{
if (displaysInStereo())
{
for (int view=1; view>=0; --view)
{
// Clears screen, set model view matrix with shifted matrix for ith buffer
preDrawStereo(view);
// Used defined method. Default is empty
if (camera()->frame()->isManipulated())
fastDraw();
else
draw();
postDraw();
}
}
else
{
// Clears screen, set model view matrix...
preDraw();
// Used defined method. Default calls draw()
if (camera()->frame()->isManipulated())
fastDraw();
else
draw();
// Add visual hints: axis, camera, grid...
postDraw();
}
Q_EMIT drawFinished(true);
}
/*! Sets OpenGL state before draw().
Default behavior clears screen and sets the projection and modelView matrices:
\code
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
camera()->loadProjectionMatrix();
camera()->loadModelViewMatrix();
\endcode
Emits the drawNeeded() signal once this is done (see the <a href="../examples/callback.html">callback example</a>). */
void QGLViewer::preDraw()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// GL_PROJECTION matrix
camera()->loadProjectionMatrix();
// GL_MODELVIEW matrix
camera()->loadModelViewMatrix();
Q_EMIT drawNeeded();
}
/*! Called after draw() to draw viewer visual hints.
Default implementation displays axis, grid, FPS... when the respective flags are sets.
See the <a href="../examples/multiSelect.html">multiSelect</a> and <a
href="../examples/contribs.html#thumbnail">thumbnail</a> examples for an overloading illustration.
The GLContext (color, LIGHTING, BLEND...) is \e not modified by this method, so that in
draw(), the user can rely on the OpenGL context he defined. Respect this convention (by pushing/popping the
different attributes) if you overload this method. */
void QGLViewer::postDraw()
{
// Reset model view matrix to world coordinates origin
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
camera()->loadModelViewMatrix();
// TODO restore model loadProjectionMatrixStereo
// Save OpenGL state
glPushAttrib(GL_ALL_ATTRIB_BITS);
// Set neutral GL state
glDisable(GL_TEXTURE_1D);
glDisable(GL_TEXTURE_2D);
#ifdef GL_TEXTURE_3D // OpenGL 1.2 Only...
glDisable(GL_TEXTURE_3D);
#endif
glDisable(GL_TEXTURE_GEN_Q);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
#ifdef GL_RESCALE_NORMAL // OpenGL 1.2 Only...
glEnable(GL_RESCALE_NORMAL);
#endif
glDisable(GL_COLOR_MATERIAL);
qglColor(foregroundColor());
if (cameraIsEdited())
camera()->drawAllPaths();
// Pivot point, line when camera rolls, zoom region
drawVisualHints();
if (gridIsDrawn()) { glLineWidth(1.0); drawGrid(camera()->sceneRadius()); }
if (axisIsDrawn()) { glLineWidth(2.0); drawAxis(camera()->sceneRadius()); }
// FPS computation
const unsigned int maxCounter = 20;
if (++fpsCounter_ == maxCounter)
{
f_p_s_ = 1000.0 * maxCounter / fpsTime_.restart();
fpsString_ = tr("%1Hz", "Frames per seconds, in Hertz").arg(f_p_s_, 0, 'f', ((f_p_s_ < 10.0)?1:0));
fpsCounter_ = 0;
}
// Restore foregroundColor
float color[4];
color[0] = foregroundColor().red() / 255.0f;
color[1] = foregroundColor().green() / 255.0f;
color[2] = foregroundColor().blue() / 255.0f;
color[3] = 1.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
if (FPSIsDisplayed()) displayFPS();
if (displayMessage_) drawText(10, height()-10, message_);
// Restore GL state
glPopAttrib();
glPopMatrix();
}
/*! Called before draw() (instead of preDraw()) when viewer displaysInStereo().
Same as preDraw() except that the glDrawBuffer() is set to \c GL_BACK_LEFT or \c GL_BACK_RIGHT
depending on \p leftBuffer, and it uses qglviewer::Camera::loadProjectionMatrixStereo() and
qglviewer::Camera::loadModelViewMatrixStereo() instead. */
void QGLViewer::preDrawStereo(bool leftBuffer)
{
// Set buffer to draw in
// Seems that SGI and Crystal Eyes are not synchronized correctly !
// That's why we don't draw in the appropriate buffer...
if (!leftBuffer)
glDrawBuffer(GL_BACK_LEFT);
else
glDrawBuffer(GL_BACK_RIGHT);
// Clear the buffer where we're going to draw
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// GL_PROJECTION matrix
camera()->loadProjectionMatrixStereo(leftBuffer);
// GL_MODELVIEW matrix
camera()->loadModelViewMatrixStereo(leftBuffer);
Q_EMIT drawNeeded();
}
/*! Draws a simplified version of the scene to guarantee interactive camera displacements.
This method is called instead of draw() when the qglviewer::Camera::frame() is
qglviewer::ManipulatedCameraFrame::isManipulated(). Default implementation simply calls draw().
Overload this method if your scene is too complex to allow for interactive camera manipulation. See
the <a href="../examples/fastDraw.html">fastDraw example</a> for an illustration. */
void QGLViewer::fastDraw()
{
draw();
}
/*! Starts (\p edit = \c true, default) or stops (\p edit=\c false) the edition of the camera().
Current implementation is limited to paths display. Get current state using cameraIsEdited().
\attention This method sets the qglviewer::Camera::zClippingCoefficient() to 5.0 when \p edit is \c
true, so that the Camera paths (see qglviewer::Camera::keyFrameInterpolator()) are not clipped. It
restores the previous value when \p edit is \c false. */
void QGLViewer::setCameraIsEdited(bool edit)
{
cameraIsEdited_ = edit;
if (edit)
{
previousCameraZClippingCoefficient_ = camera()->zClippingCoefficient();
// #CONNECTION# 5.0 also used in domElement() and in initFromDOMElement().
camera()->setZClippingCoefficient(5.0);
}
else
camera()->setZClippingCoefficient(previousCameraZClippingCoefficient_);
Q_EMIT cameraIsEditedChanged(edit);
update();
}
// Key bindings. 0 means not defined
void QGLViewer::setDefaultShortcuts()
{
// D e f a u l t a c c e l e r a t o r s
setShortcut(DRAW_AXIS, Qt::Key_A);
setShortcut(DRAW_GRID, Qt::Key_G);
setShortcut(DISPLAY_FPS, Qt::Key_F);
setShortcut(ENABLE_TEXT, Qt::SHIFT+Qt::Key_Question);
setShortcut(EXIT_VIEWER, Qt::Key_Escape);
setShortcut(SAVE_SCREENSHOT, Qt::CTRL+Qt::Key_S);
setShortcut(CAMERA_MODE, Qt::Key_Space);
setShortcut(FULL_SCREEN, Qt::ALT+Qt::Key_Return);
setShortcut(STEREO, Qt::Key_S);
setShortcut(ANIMATION, Qt::Key_Return);
setShortcut(HELP, Qt::Key_H);
setShortcut(EDIT_CAMERA, Qt::Key_C);
setShortcut(MOVE_CAMERA_LEFT, Qt::Key_Left);
setShortcut(MOVE_CAMERA_RIGHT,Qt::Key_Right);
setShortcut(MOVE_CAMERA_UP, Qt::Key_Up);
setShortcut(MOVE_CAMERA_DOWN, Qt::Key_Down);
setShortcut(INCREASE_FLYSPEED, Qt::Key_Plus);
setShortcut(DECREASE_FLYSPEED, Qt::Key_Minus);
setShortcut(SNAPSHOT_TO_CLIPBOARD, Qt::CTRL+Qt::Key_C);
keyboardActionDescription_[DISPLAY_FPS] = tr("Toggles the display of the FPS", "DISPLAY_FPS action description");
keyboardActionDescription_[SAVE_SCREENSHOT] = tr("Saves a screenshot", "SAVE_SCREENSHOT action description");
keyboardActionDescription_[FULL_SCREEN] = tr("Toggles full screen display", "FULL_SCREEN action description");
keyboardActionDescription_[DRAW_AXIS] = tr("Toggles the display of the world axis", "DRAW_AXIS action description");
keyboardActionDescription_[DRAW_GRID] = tr("Toggles the display of the XY grid", "DRAW_GRID action description");
keyboardActionDescription_[CAMERA_MODE] = tr("Changes camera mode (observe or fly)", "CAMERA_MODE action description");
keyboardActionDescription_[STEREO] = tr("Toggles stereo display", "STEREO action description");
keyboardActionDescription_[HELP] = tr("Opens this help window", "HELP action description");
keyboardActionDescription_[ANIMATION] = tr("Starts/stops the animation", "ANIMATION action description");
keyboardActionDescription_[EDIT_CAMERA] = tr("Toggles camera paths display", "EDIT_CAMERA action description"); // TODO change
keyboardActionDescription_[ENABLE_TEXT] = tr("Toggles the display of the text", "ENABLE_TEXT action description");
keyboardActionDescription_[EXIT_VIEWER] = tr("Exits program", "EXIT_VIEWER action description");
keyboardActionDescription_[MOVE_CAMERA_LEFT] = tr("Moves camera left", "MOVE_CAMERA_LEFT action description");
keyboardActionDescription_[MOVE_CAMERA_RIGHT] = tr("Moves camera right", "MOVE_CAMERA_RIGHT action description");
keyboardActionDescription_[MOVE_CAMERA_UP] = tr("Moves camera up", "MOVE_CAMERA_UP action description");
keyboardActionDescription_[MOVE_CAMERA_DOWN] = tr("Moves camera down", "MOVE_CAMERA_DOWN action description");
keyboardActionDescription_[INCREASE_FLYSPEED] = tr("Increases fly speed", "INCREASE_FLYSPEED action description");
keyboardActionDescription_[DECREASE_FLYSPEED] = tr("Decreases fly speed", "DECREASE_FLYSPEED action description");
keyboardActionDescription_[SNAPSHOT_TO_CLIPBOARD] = tr("Copies a snapshot to clipboard", "SNAPSHOT_TO_CLIPBOARD action description");
// K e y f r a m e s s h o r t c u t k e y s
setPathKey(Qt::Key_F1, 1);
setPathKey(Qt::Key_F2, 2);
setPathKey(Qt::Key_F3, 3);
setPathKey(Qt::Key_F4, 4);
setPathKey(Qt::Key_F5, 5);
setPathKey(Qt::Key_F6, 6);
setPathKey(Qt::Key_F7, 7);
setPathKey(Qt::Key_F8, 8);
setPathKey(Qt::Key_F9, 9);
setPathKey(Qt::Key_F10, 10);
setPathKey(Qt::Key_F11, 11);
setPathKey(Qt::Key_F12, 12);
setAddKeyFrameKeyboardModifiers(Qt::AltModifier);
setPlayPathKeyboardModifiers(Qt::NoModifier);
}
// M o u s e b e h a v i o r
void QGLViewer::setDefaultMouseBindings()
{
const Qt::KeyboardModifiers cameraKeyboardModifiers = Qt::NoModifier;
const Qt::KeyboardModifiers frameKeyboardModifiers = Qt::ControlModifier;
//#CONNECTION# toggleCameraMode()
for (int handler=0; handler<2; ++handler)
{
MouseHandler mh = (MouseHandler)(handler);
Qt::KeyboardModifiers modifiers = (mh == FRAME) ? frameKeyboardModifiers : cameraKeyboardModifiers;
setMouseBinding(modifiers, Qt::LeftButton, mh, ROTATE);
setMouseBinding(modifiers, Qt::MidButton, mh, ZOOM);
setMouseBinding(modifiers, Qt::RightButton, mh, TRANSLATE);
setMouseBinding(Qt::Key_R, modifiers, Qt::LeftButton, mh, SCREEN_ROTATE);
setWheelBinding(modifiers, mh, ZOOM);
}
// Z o o m o n r e g i o n
setMouseBinding(Qt::ShiftModifier, Qt::MidButton, CAMERA, ZOOM_ON_REGION);
// S e l e c t
setMouseBinding(Qt::ShiftModifier, Qt::LeftButton, SELECT);
setMouseBinding(Qt::ShiftModifier, Qt::RightButton, RAP_FROM_PIXEL);
// D o u b l e c l i c k
setMouseBinding(Qt::NoModifier, Qt::LeftButton, ALIGN_CAMERA, true);
setMouseBinding(Qt::NoModifier, Qt::MidButton, SHOW_ENTIRE_SCENE, true);
setMouseBinding(Qt::NoModifier, Qt::RightButton, CENTER_SCENE, true);
setMouseBinding(frameKeyboardModifiers, Qt::LeftButton, ALIGN_FRAME, true);
// middle double click makes no sense for manipulated frame
setMouseBinding(frameKeyboardModifiers, Qt::RightButton, CENTER_FRAME, true);
// A c t i o n s w i t h k e y m o d i f i e r s
setMouseBinding(Qt::Key_Z, Qt::NoModifier, Qt::LeftButton, ZOOM_ON_PIXEL);
setMouseBinding(Qt::Key_Z, Qt::NoModifier, Qt::RightButton, ZOOM_TO_FIT);
#ifdef Q_OS_MAC
// Specific Mac bindings for touchpads. Two fingers emulate a wheelEvent which zooms.
// There is no right button available : make Option key + left emulate the right button.
// A Control+Left indeed emulates a right click (OS X system configuration), but it does
// no seem to support dragging.
// Done at the end to override previous settings.
const Qt::KeyboardModifiers macKeyboardModifiers = Qt::AltModifier;
setMouseBinding(macKeyboardModifiers, Qt::LeftButton, CAMERA, TRANSLATE);
setMouseBinding(macKeyboardModifiers, Qt::LeftButton, CENTER_SCENE, true);
setMouseBinding(frameKeyboardModifiers | macKeyboardModifiers, Qt::LeftButton, CENTER_FRAME, true);
setMouseBinding(frameKeyboardModifiers | macKeyboardModifiers, Qt::LeftButton, FRAME, TRANSLATE);
#endif
}
/*! Associates a new qglviewer::Camera to the viewer.
You should only use this method when you derive a new class from qglviewer::Camera and want to use
one of its instances instead of the original class.
It you simply want to save and restore Camera positions, use qglviewer::Camera::addKeyFrameToPath()
and qglviewer::Camera::playPath() instead.
This method silently ignores \c NULL \p camera pointers. The calling method is responsible for deleting
the previous camera pointer in order to prevent memory leaks if needed.
The sceneRadius() and sceneCenter() of \p camera are set to the \e current QGLViewer values.
All the \p camera qglviewer::Camera::keyFrameInterpolator()
qglviewer::KeyFrameInterpolator::interpolated() signals are connected to the viewer update() slot.
The connections with the previous viewer's camera are removed. */
void QGLViewer::setCamera(Camera* const camera)
{
if (!camera)
return;
camera->setSceneRadius(sceneRadius());
camera->setSceneCenter(sceneCenter());
camera->setScreenWidthAndHeight(width(), height());
// Disconnect current camera from this viewer.
disconnect(this->camera()->frame(), SIGNAL(manipulated()), this, SLOT(update()));
disconnect(this->camera()->frame(), SIGNAL(spun()), this, SLOT(update()));
// Connect camera frame to this viewer.
connect(camera->frame(), SIGNAL(manipulated()), SLOT(update()));
connect(camera->frame(), SIGNAL(spun()), SLOT(update()));
connectAllCameraKFIInterpolatedSignals(false);
camera_ = camera;
connectAllCameraKFIInterpolatedSignals();
previousCameraZClippingCoefficient_ = this->camera()->zClippingCoefficient();
}
void QGLViewer::connectAllCameraKFIInterpolatedSignals(bool connection)
{
for (QMap<unsigned int, KeyFrameInterpolator*>::ConstIterator it = camera()->kfi_.begin(), end=camera()->kfi_.end(); it != end; ++it)
{
if (connection)
connect(camera()->keyFrameInterpolator(it.key()), SIGNAL(interpolated()), SLOT(update()));
else
disconnect(camera()->keyFrameInterpolator(it.key()), SIGNAL(interpolated()), this, SLOT(update()));
}
if (connection)
connect(camera()->interpolationKfi_, SIGNAL(interpolated()), SLOT(update()));
else
disconnect(camera()->interpolationKfi_, SIGNAL(interpolated()), this, SLOT(update()));
}
/*! Draws a representation of \p light.
Called in draw(), this method is useful to debug or display your light setup. Light drawing depends
on the type of light (point, spot, directional).
The method retrieves the light setup using \c glGetLightfv. Position and define your lights before
calling this method.
Light is drawn using its diffuse color. Disabled lights are not displayed.
Drawing size is proportional to sceneRadius(). Use \p scale to rescale it.
See the <a href="../examples/drawLight.html">drawLight example</a> for an illustration.
\attention You need to enable \c GL_COLOR_MATERIAL before calling this method. \c glColor is set to
the light diffuse color. */
void QGLViewer::drawLight(GLenum light, qreal scale) const
{
static GLUquadric* quadric = gluNewQuadric();
const qreal length = sceneRadius() / 5.0 * scale;
GLboolean lightIsOn;
glGetBooleanv(light, &lightIsOn);
if (lightIsOn)
{
// All light values are given in eye coordinates
glPushMatrix();
glLoadIdentity();
float color[4];
glGetLightfv(light, GL_DIFFUSE, color);
glColor4fv(color);
float pos[4];
glGetLightfv(light, GL_POSITION, pos);
if (pos[3] != 0.0)
{
glTranslatef(pos[0]/pos[3], pos[1]/pos[3], pos[2]/pos[3]);
GLfloat cutOff;
glGetLightfv(light, GL_SPOT_CUTOFF, &cutOff);
if (cutOff != 180.0)
{
GLfloat dir[4];
glGetLightfv(light, GL_SPOT_DIRECTION, dir);
glMultMatrixd(Quaternion(Vec(0,0,1), Vec(dir)).matrix());
QGLViewer::drawArrow(length);
gluCylinder(quadric, 0.0, 0.7 * length * sin(cutOff * M_PI / 180.0), 0.7 * length * cos(cutOff * M_PI / 180.0), 12, 1);
}
else
gluSphere(quadric, 0.2*length, 10, 10);
}
else
{
// Directional light.
Vec dir(pos[0], pos[1], pos[2]);
dir.normalize();
Frame fr=Frame(camera()->cameraCoordinatesOf(4.0 * length * camera()->frame()->inverseTransformOf(dir)),
Quaternion(Vec(0,0,-1), dir));
glMultMatrixd(fr.matrix());
drawArrow(length);
}
glPopMatrix();
}
}
/*! Draws \p text at position \p x, \p y (expressed in screen coordinates pixels, origin in the
upper left corner of the widget).
The default QApplication::font() is used to render the text when no \p fnt is specified. Use
QApplication::setFont() to define this default font.
You should disable \c GL_LIGHTING and \c GL_DEPTH_TEST before this method so that colors are properly rendered.
This method can be used in conjunction with the qglviewer::Camera::projectedCoordinatesOf()
method to display a text attached to an object. In your draw() method use:
\code
qglviewer::Vec screenPos = camera()->projectedCoordinatesOf(myFrame.position());
drawText((int)screenPos[0], (int)screenPos[1], "My Object");
\endcode
See the <a href="../examples/screenCoordSystem.html">screenCoordSystem example</a> for an illustration.
Text is displayed only when textIsEnabled() (default). This mechanism allows the user to
conveniently remove all the displayed text with a single keyboard shortcut.
See also displayMessage() to drawText() for only a short amount of time.
Use QGLWidget::renderText(x,y,z, text) instead if you want to draw a text located
at a specific 3D position instead of 2D screen coordinates (fixed size text, facing the camera).
The \c GL_MODELVIEW and \c GL_PROJECTION matrices are not modified by this method.
\attention This method uses display lists to render the characters, with an index that starts at
2000 by default (see the QGLWidget::renderText() documentation). If you use more than 2000 Display
Lists, they may overlap with these. Directly use QGLWidget::renderText() in that case, with a
higher \c listBase parameter (or overload <code>fontDisplayListBase</code>).*/
void QGLViewer::drawText(int x, int y, const QString& text, const QFont& fnt)
{
if (!textIsEnabled())
return;
if (tileRegion_ != NULL) {
renderText(int((x-tileRegion_->xMin) * width() / (tileRegion_->xMax - tileRegion_->xMin)),
int((y-tileRegion_->yMin) * height() / (tileRegion_->yMax - tileRegion_->yMin)), text, scaledFont(fnt));
} else
renderText(x, y, text, fnt);
}
/*! Briefly displays a message in the lower left corner of the widget. Convenient to provide
feedback to the user.
\p message is displayed during \p delay milliseconds (default is 2 seconds) using drawText().
This method should not be called in draw(). If you want to display a text in each draw(), use
drawText() instead.
If this method is called when a message is already displayed, the new message replaces the old one.
Use setTextIsEnabled() (default shortcut is '?') to enable or disable text (and hence messages)
display. */
void QGLViewer::displayMessage(const QString& message, int delay)
{
message_ = message;
displayMessage_ = true;
// Was set to single shot in defaultConstructor.
messageTimer_.start(delay);
if (textIsEnabled())
update();
}
void QGLViewer::hideMessage()
{
displayMessage_ = false;
if (textIsEnabled())
update();
}
/*! Displays the averaged currentFPS() frame rate in the upper left corner of the widget.
update() should be called in a loop in order to have a meaningful value (this is the case when
you continuously move the camera using the mouse or when animationIsStarted()).
setAnimationPeriod(0) to make this loop as fast as possible in order to reach and measure the
maximum available frame rate.
When FPSIsDisplayed() is \c true (default is \c false), this method is called by postDraw() to
display the currentFPS(). Use QApplication::setFont() to define the font (see drawText()). */
void QGLViewer::displayFPS()
{
drawText(10, int(1.5*((QApplication::font().pixelSize()>0)?QApplication::font().pixelSize():QApplication::font().pointSize())), fpsString_);
}
/*! Modify the projection matrix so that drawing can be done directly with 2D screen coordinates.
Once called, the \p x and \p y coordinates passed to \c glVertex are expressed in pixels screen
coordinates. The origin (0,0) is in the upper left corner of the widget by default. This follows
the Qt standards, so that you can directly use the \c pos() provided by for instance \c
QMouseEvent. Set \p upward to \c true to place the origin in the \e lower left corner, thus
following the OpenGL and mathematical standards. It is always possible to switch between the two
representations using \c newY = height() - \c y.
You need to call stopScreenCoordinatesSystem() at the end of the drawing block to restore the
previous camera matrix.
In practice, this method should be used in draw(). It sets an appropriate orthographic projection
matrix and then sets \c glMatrixMode to \c GL_MODELVIEW.
See the <a href="../examples/screenCoordSystem.html">screenCoordSystem</a>, <a
href="../examples/multiSelect.html">multiSelect</a> and <a
href="../examples/contribs.html#backgroundImage">backgroundImage</a> examples for an illustration.
You may want to disable \c GL_LIGHTING, to enable \c GL_LINE_SMOOTH or \c GL_BLEND to draw when
this method is used.
If you want to link 2D drawings to 3D objects, use qglviewer::Camera::projectedCoordinatesOf() to
compute the 2D projection on screen of a 3D point (see the <a
href="../examples/screenCoordSystem.html">screenCoordSystem</a> example). See also drawText().
In this mode, you should use z values that are in the [0.0, 1.0[ range (0.0 corresponding to the
near clipping plane and 1.0 being just beyond the far clipping plane). This interval matches the
values that can be read from the z-buffer. Note that if you use the convenient \c glVertex2i() to
provide coordinates, the implicit 0.0 z coordinate will make your drawings appear \e on \e top of
the rest of the scene. */
void QGLViewer::startScreenCoordinatesSystem(bool upward) const
{
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
if (tileRegion_ != NULL)
if (upward)
glOrtho(tileRegion_->xMin, tileRegion_->xMax, tileRegion_->yMin, tileRegion_->yMax, 0.0, -1.0);
else
glOrtho(tileRegion_->xMin, tileRegion_->xMax, tileRegion_->yMax, tileRegion_->yMin, 0.0, -1.0);
else
if (upward)
glOrtho(0, width(), 0, height(), 0.0, -1.0);
else
glOrtho(0, width(), height(), 0, 0.0, -1.0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
}
/*! Stops the pixel coordinate drawing block started by startScreenCoordinatesSystem().
The \c GL_MODELVIEW and \c GL_PROJECTION matrices modified in
startScreenCoordinatesSystem() are restored. \c glMatrixMode is set to \c GL_MODELVIEW. */
void QGLViewer::stopScreenCoordinatesSystem() const
{
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
/*! Overloading of the \c QObject method.
If animationIsStarted(), calls animate() and draw(). */
void QGLViewer::timerEvent(QTimerEvent *)
{
if (animationIsStarted())
{
animate();
update();
}
}
/*! Starts the animation loop. See animationIsStarted(). */
void QGLViewer::startAnimation()
{
animationTimerId_ = startTimer(animationPeriod());
animationStarted_ = true;
}
/*! Stops animation. See animationIsStarted(). */
void QGLViewer::stopAnimation()
{
animationStarted_ = false;
if (animationTimerId_ != 0)
killTimer(animationTimerId_);
}
/*! Overloading of the \c QWidget method.
Saves the viewer state using saveStateToFile() and then calls QGLWidget::closeEvent(). */
void QGLViewer::closeEvent(QCloseEvent *e)
{
// When the user clicks on the window close (x) button:
// - If the viewer is a top level window, closeEvent is called and then saves to file.
// - Otherwise, nothing happen s:(
// When the user press the EXIT_VIEWER keyboard shortcut:
// - If the viewer is a top level window, saveStateToFile() is also called
// - Otherwise, closeEvent is NOT called and keyPressEvent does the job.
/* After tests:
E : Embedded widget
N : Widget created with new
C : closeEvent called
D : destructor called
E N C D
y y
y n y
n y y
n n y y
closeEvent is called iif the widget is NOT embedded.
Destructor is called iif the widget is created on the stack
or if widget (resp. parent if embedded) is created with WDestructiveClose flag.
closeEvent always before destructor.
Close using qApp->closeAllWindows or (x) is identical.
*/
// #CONNECTION# Also done for EXIT_VIEWER in keyPressEvent().
saveStateToFile();
QGLWidget::closeEvent(e);
}
/*! Simple wrapper method: calls \c select(event->pos()).
Emits \c pointSelected(e) which is useful only if you rely on the Qt signal-slot mechanism and you
did not overload QGLViewer. If you choose to derive your own viewer class, simply overload
select() (or probably simply drawWithNames(), see the <a href="../examples/select.html">select
example</a>) to implement your selection mechanism.
This method is called when you use the QGLViewer::SELECT mouse binding(s) (default is Shift + left
button). Use setMouseBinding() to change this. */
void QGLViewer::select(const QMouseEvent* event)
{
// For those who don't derive but rather rely on the signal-slot mechanism.
Q_EMIT pointSelected(event);
select(event->pos());
}
/*! This method performs a selection in the scene from pixel coordinates.
It is called when the user clicks on the QGLViewer::SELECT QGLViewer::ClickAction binded button(s)
(default is Shift + LeftButton).
This template method successively calls four other methods:
\code
beginSelection(point);
drawWithNames();
endSelection(point);
postSelection(point);
\endcode
The default implementation of these methods is as follows (see the methods' documentation for
more details):
\arg beginSelection() sets the \c GL_SELECT mode with the appropriate picking matrices. A
rectangular frustum (of size defined by selectRegionWidth() and selectRegionHeight()) centered on
\p point is created.
\arg drawWithNames() is empty and should be overloaded. It draws each selectable object of the
scene, enclosed by calls to \c glPushName() / \c glPopName() to tag the object with an integer id.
\arg endSelection() then restores \c GL_RENDER mode and analyzes the selectBuffer() to set in
selectedName() the id of the object that was drawn in the region. If several object are in the
region, the closest one in the depth buffer is chosen. If no object has been drawn under cursor,
selectedName() is set to -1.
\arg postSelection() is empty and can be overloaded for possible signal/display/interface update.
See the \c glSelectBuffer() man page for details on this \c GL_SELECT mechanism.
This default implementation is quite limited: only the closer object is selected, and only one
level of names can be pushed. However, this reveals sufficient in many cases and you usually only
have to overload drawWithNames() to implement a simple object selection process. See the <a
href="../examples/select.html">select example</a> for an illustration.
If you need a more complex selection process (such as a point, edge or triangle selection, which
is easier with a 2 or 3 levels selectBuffer() heap, and which requires a finer depth sorting to
privilege point over edge and edges over triangles), overload the endSelection() method. Use
setSelectRegionWidth(), setSelectRegionHeight() and setSelectBufferSize() to tune the select
buffer configuration. See the <a href="../examples/multiSelect.html">multiSelect example</a> for
an illustration.
\p point is the center pixel (origin in the upper left corner) of the selection region. Use
qglviewer::Camera::convertClickToLine() to transform these coordinates in a 3D ray if you want to
perform an analytical intersection.
\attention \c GL_SELECT mode seems to report wrong results when used in conjunction with backface
culling. If you encounter problems try to \c glDisable(GL_CULL_FACE). */
void QGLViewer::select(const QPoint& point)
{
beginSelection(point);
drawWithNames();
endSelection(point);
postSelection(point);
}
/*! This method should prepare the selection. It is called by select() before drawWithNames().
The default implementation uses the \c GL_SELECT mode to perform a selection. It uses
selectBuffer() and selectBufferSize() to define a \c glSelectBuffer(). The \c GL_PROJECTION is then
set using \c gluPickMatrix(), with a window selection size defined by selectRegionWidth() and
selectRegionHeight(). Finally, the \c GL_MODELVIEW matrix is set to the world coordinate system
using qglviewer::Camera::loadModelViewMatrix(). See the gluPickMatrix() documentation for details.
You should not need to redefine this method (if you use the \c GL_SELECT mode to perform your
selection), since this code is fairly classical and can be tuned. You are more likely to overload
endSelection() if you want to use a more complex select buffer structure. */
void QGLViewer::beginSelection(const QPoint& point)
{
// Make OpenGL context current (may be needed with several viewers ?)
makeCurrent();
// Prepare the selection mode
glSelectBuffer(selectBufferSize(), selectBuffer());
glRenderMode(GL_SELECT);
glInitNames();
// Loads the matrices
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
static GLint viewport[4];
camera()->getViewport(viewport);
gluPickMatrix(point.x(), point.y(), selectRegionWidth(), selectRegionHeight(), viewport);
// loadProjectionMatrix() first resets the GL_PROJECTION matrix with a glLoadIdentity().
// The false parameter prevents this and hence multiplies the matrices.
camera()->loadProjectionMatrix(false);
// Reset the original (world coordinates) modelview matrix
camera()->loadModelViewMatrix();
}
/*! This method is called by select() after scene elements were drawn by drawWithNames(). It should
analyze the selection result to determine which object is actually selected.
The default implementation relies on \c GL_SELECT mode (see beginSelection()). It assumes that
names were pushed and popped in drawWithNames(), and analyzes the selectBuffer() to find the name
that corresponds to the closer (z min) object. It then setSelectedName() to this value, or to -1 if
the selectBuffer() is empty (no object drawn in selection region). Use selectedName() (probably in
the postSelection() method) to retrieve this value and update your data structure accordingly.
This default implementation, although sufficient for many cases is however limited and you may have
to overload this method. This will be the case if drawWithNames() uses several push levels in the
name heap. A more precise depth selection, for instance privileging points over edges and
triangles to avoid z precision problems, will also require an overloading. A typical implementation
will look like:
\code
glFlush();
// Get the number of objects that were seen through the pick matrix frustum.
// Resets GL_RENDER mode.
GLint nbHits = glRenderMode(GL_RENDER);
if (nbHits <= 0)
setSelectedName(-1);
else
{
// Interpret results: each object created values in the selectBuffer().
// See the glSelectBuffer() man page for details on the buffer structure.
// The following code depends on your selectBuffer() structure.
for (int i=0; i<nbHits; ++i)
if ((selectBuffer())[i*4+1] < zMin)
setSelectedName((selectBuffer())[i*4+3])
}
\endcode
See the <a href="../examples/multiSelect.html">multiSelect example</a> for
a multi-object selection implementation of this method. */
void QGLViewer::endSelection(const QPoint& point)
{
Q_UNUSED(point);
// Flush GL buffers
glFlush();
// Get the number of objects that were seen through the pick matrix frustum. Reset GL_RENDER mode.
GLint nbHits = glRenderMode(GL_RENDER);
if (nbHits <= 0)
setSelectedName(-1);
else
{
// Interpret results: each object created 4 values in the selectBuffer().
// selectBuffer[4*i+1] is the object minimum depth value, while selectBuffer[4*i+3] is the id pushed on the stack.
// Of all the objects that were projected in the pick region, we select the closest one (zMin comparison).
// This code needs to be modified if you use several stack levels. See glSelectBuffer() man page.
GLuint zMin = (selectBuffer())[1];
setSelectedName(int((selectBuffer())[3]));
for (int i=1; i<nbHits; ++i)
if ((selectBuffer())[4*i+1] < zMin)
{
zMin = (selectBuffer())[4*i+1];
setSelectedName(int((selectBuffer())[4*i+3]));
}
}
}
/*! Sets the selectBufferSize().
The previous selectBuffer() is deleted and a new one is created. */
void QGLViewer::setSelectBufferSize(int size)
{
if (selectBuffer_)
delete[] selectBuffer_;
selectBufferSize_ = size;
selectBuffer_ = new GLuint[selectBufferSize()];
}
static QString mouseButtonsString(Qt::MouseButtons b)
{
QString result("");
bool addAmpersand = false;
if (b & Qt::LeftButton) { result += QGLViewer::tr("Left", "left mouse button"); addAmpersand=true; }
if (b & Qt::MidButton) { if (addAmpersand) result += " & "; result += QGLViewer::tr("Middle", "middle mouse button"); addAmpersand=true; }
if (b & Qt::RightButton) { if (addAmpersand) result += " & "; result += QGLViewer::tr("Right", "right mouse button"); }
return result;
}
void QGLViewer::performClickAction(ClickAction ca, const QMouseEvent* const e)
{
// Note: action that need it should call update().
switch (ca)
{
// # CONNECTION setMouseBinding prevents adding NO_CLICK_ACTION in clickBinding_
// This case should hence not be possible. Prevents unused case warning.
case NO_CLICK_ACTION :
break;
case ZOOM_ON_PIXEL :
camera()->interpolateToZoomOnPixel(e->pos());
break;
case ZOOM_TO_FIT :
camera()->interpolateToFitScene();
break;
case SELECT :
select(e);
update();
break;
case RAP_FROM_PIXEL :
if (! camera()->setPivotPointFromPixel(e->pos()))
camera()->setPivotPoint(sceneCenter());
setVisualHintsMask(1);
update();
break;
case RAP_IS_CENTER :
camera()->setPivotPoint(sceneCenter());
setVisualHintsMask(1);
update();
break;
case CENTER_FRAME :
if (manipulatedFrame())
manipulatedFrame()->projectOnLine(camera()->position(), camera()->viewDirection());
break;
case CENTER_SCENE :
camera()->centerScene();
break;
case SHOW_ENTIRE_SCENE :
camera()->showEntireScene();
break;
case ALIGN_FRAME :
if (manipulatedFrame())
manipulatedFrame()->alignWithFrame(camera()->frame());
break;
case ALIGN_CAMERA :
Frame * frame = new Frame();
frame->setTranslation(camera()->pivotPoint());
camera()->frame()->alignWithFrame(frame, true);
delete frame;
break;
}
}
/*! Overloading of the \c QWidget method.
When the user clicks on the mouse:
\arg if a mouseGrabber() is defined, qglviewer::MouseGrabber::mousePressEvent() is called,
\arg otherwise, the camera() or the manipulatedFrame() interprets the mouse displacements,
depending on mouse bindings.
Mouse bindings customization can be achieved using setMouseBinding() and setWheelBinding(). See the
<a href="../mouse.html">mouse page</a> for a complete description of mouse bindings.
See the mouseMoveEvent() documentation for an example of more complex mouse behavior customization
using overloading.
\note When the mouseGrabber() is a manipulatedFrame(), the modifier keys are not taken into
account. This allows for a direct manipulation of the manipulatedFrame() when the mouse hovers,
which is probably what is expected. */
void QGLViewer::mousePressEvent(QMouseEvent* e)
{
//#CONNECTION# mouseDoubleClickEvent has the same structure
//#CONNECTION# mouseString() concatenates bindings description in inverse order.
ClickBindingPrivate cbp(e->modifiers(), e->button(), false, (Qt::MouseButtons)(e->buttons() & ~(e->button())), currentlyPressedKey_);
if (clickBinding_.contains(cbp)) {
performClickAction(clickBinding_[cbp], e);
} else
if (mouseGrabber())
{
if (mouseGrabberIsAManipulatedFrame_)
{
for (QMap<MouseBindingPrivate, MouseActionPrivate>::ConstIterator it=mouseBinding_.begin(), end=mouseBinding_.end(); it!=end; ++it)
if ((it.value().handler == FRAME) && (it.key().button == e->button()))
{
ManipulatedFrame* mf = dynamic_cast<ManipulatedFrame*>(mouseGrabber());
if (mouseGrabberIsAManipulatedCameraFrame_)
{
mf->ManipulatedFrame::startAction(it.value().action, it.value().withConstraint);
mf->ManipulatedFrame::mousePressEvent(e, camera());
}
else
{
mf->startAction(it.value().action, it.value().withConstraint);
mf->mousePressEvent(e, camera());
}
break;
}
}
else
mouseGrabber()->mousePressEvent(e, camera());
update();
}
else
{
//#CONNECTION# wheelEvent has the same structure
const MouseBindingPrivate mbp(e->modifiers(), e->button(), currentlyPressedKey_);
if (mouseBinding_.contains(mbp))
{
MouseActionPrivate map = mouseBinding_[mbp];
switch (map.handler)
{
case CAMERA :
camera()->frame()->startAction(map.action, map.withConstraint);
camera()->frame()->mousePressEvent(e, camera());
break;
case FRAME :
if (manipulatedFrame())
{
if (manipulatedFrameIsACamera_)
{
manipulatedFrame()->ManipulatedFrame::startAction(map.action, map.withConstraint);
manipulatedFrame()->ManipulatedFrame::mousePressEvent(e, camera());
}
else
{
manipulatedFrame()->startAction(map.action, map.withConstraint);
manipulatedFrame()->mousePressEvent(e, camera());
}
}
break;
}
if (map.action == SCREEN_ROTATE)
// Display visual hint line
update();
}
else
e->ignore();
}
}
/*! Overloading of the \c QWidget method.
Mouse move event is sent to the mouseGrabber() (if any) or to the camera() or the
manipulatedFrame(), depending on mouse bindings (see setMouseBinding()).
If you want to define your own mouse behavior, do something like this:
\code
void Viewer::mousePressEvent(QMouseEvent* e)
{
if ((e->button() == myButton) && (e->modifiers() == myModifiers))
myMouseBehavior = true;
else
QGLViewer::mousePressEvent(e);
}
void Viewer::mouseMoveEvent(QMouseEvent *e)
{
if (myMouseBehavior)
// Use e->x() and e->y() as you want...
else
QGLViewer::mouseMoveEvent(e);
}
void Viewer::mouseReleaseEvent(QMouseEvent* e)
{
if (myMouseBehavior)
myMouseBehavior = false;
else
QGLViewer::mouseReleaseEvent(e);
}
\endcode */
void QGLViewer::mouseMoveEvent(QMouseEvent* e)
{
if (mouseGrabber())
{
mouseGrabber()->checkIfGrabsMouse(e->x(), e->y(), camera());
if (mouseGrabber()->grabsMouse())
if (mouseGrabberIsAManipulatedCameraFrame_)
(dynamic_cast<ManipulatedFrame*>(mouseGrabber()))->ManipulatedFrame::mouseMoveEvent(e, camera());
else
mouseGrabber()->mouseMoveEvent(e, camera());
else
setMouseGrabber(NULL);
update();
}
if (!mouseGrabber())
{
//#CONNECTION# mouseReleaseEvent has the same structure
if (camera()->frame()->isManipulated())
{
camera()->frame()->mouseMoveEvent(e, camera());
// #CONNECTION# manipulatedCameraFrame::mouseMoveEvent specific if at the beginning
if (camera()->frame()->action_ == ZOOM_ON_REGION)
update();
}
else // !
if ((manipulatedFrame()) && (manipulatedFrame()->isManipulated()))
if (manipulatedFrameIsACamera_)
manipulatedFrame()->ManipulatedFrame::mouseMoveEvent(e, camera());
else
manipulatedFrame()->mouseMoveEvent(e, camera());
else
if (hasMouseTracking())
{
Q_FOREACH (MouseGrabber* mg, MouseGrabber::MouseGrabberPool())
{
mg->checkIfGrabsMouse(e->x(), e->y(), camera());
if (mg->grabsMouse())
{
setMouseGrabber(mg);
// Check that MouseGrabber is not disabled
if (mouseGrabber() == mg)
{
update();
break;
}
}
}
}
}
}
/*! Overloading of the \c QWidget method.
Calls the mouseGrabber(), camera() or manipulatedFrame \c mouseReleaseEvent method.
See the mouseMoveEvent() documentation for an example of mouse behavior customization. */
void QGLViewer::mouseReleaseEvent(QMouseEvent* e)
{
if (mouseGrabber())
{
if (mouseGrabberIsAManipulatedCameraFrame_)
(dynamic_cast<ManipulatedFrame*>(mouseGrabber()))->ManipulatedFrame::mouseReleaseEvent(e, camera());
else
mouseGrabber()->mouseReleaseEvent(e, camera());
mouseGrabber()->checkIfGrabsMouse(e->x(), e->y(), camera());
if (!(mouseGrabber()->grabsMouse()))
setMouseGrabber(NULL);
// update();
}
else
//#CONNECTION# mouseMoveEvent has the same structure
if (camera()->frame()->isManipulated())
{
camera()->frame()->mouseReleaseEvent(e, camera());
}
else
if ((manipulatedFrame()) && (manipulatedFrame()->isManipulated()))
{
if (manipulatedFrameIsACamera_)
manipulatedFrame()->ManipulatedFrame::mouseReleaseEvent(e, camera());
else
manipulatedFrame()->mouseReleaseEvent(e, camera());
}
else
e->ignore();
// Not absolutely needed (see above commented code for the optimal version), but may reveal
// useful for specific applications.
update();
}
/*! Overloading of the \c QWidget method.
If defined, the wheel event is sent to the mouseGrabber(). It is otherwise sent according to wheel
bindings (see setWheelBinding()). */
void QGLViewer::wheelEvent(QWheelEvent* e)
{
if (mouseGrabber())
{
if (mouseGrabberIsAManipulatedFrame_)
{
for (QMap<WheelBindingPrivate, MouseActionPrivate>::ConstIterator it=wheelBinding_.begin(), end=wheelBinding_.end(); it!=end; ++it)
if (it.value().handler == FRAME)
{
ManipulatedFrame* mf = dynamic_cast<ManipulatedFrame*>(mouseGrabber());
if (mouseGrabberIsAManipulatedCameraFrame_)
{
mf->ManipulatedFrame::startAction(it.value().action, it.value().withConstraint);
mf->ManipulatedFrame::wheelEvent(e, camera());
}
else
{
mf->startAction(it.value().action, it.value().withConstraint);
mf->wheelEvent(e, camera());
}
break;
}
}
else
mouseGrabber()->wheelEvent(e, camera());
update();
}
else
{
//#CONNECTION# mousePressEvent has the same structure
WheelBindingPrivate wbp(e->modifiers(), currentlyPressedKey_);
if (wheelBinding_.contains(wbp))
{
MouseActionPrivate map = wheelBinding_[wbp];
switch (map.handler)
{
case CAMERA :
camera()->frame()->startAction(map.action, map.withConstraint);
camera()->frame()->wheelEvent(e, camera());
break;
case FRAME :
if (manipulatedFrame()) {
if (manipulatedFrameIsACamera_)
{
manipulatedFrame()->ManipulatedFrame::startAction(map.action, map.withConstraint);
manipulatedFrame()->ManipulatedFrame::wheelEvent(e, camera());
}
else
{
manipulatedFrame()->startAction(map.action, map.withConstraint);
manipulatedFrame()->wheelEvent(e, camera());
}
}
break;
}
}
else
e->ignore();
}
}
/*! Overloading of the \c QWidget method.
The behavior of the mouse double click depends on the mouse binding. See setMouseBinding() and the
<a href="../mouse.html">mouse page</a>. */
void QGLViewer::mouseDoubleClickEvent(QMouseEvent* e)
{
//#CONNECTION# mousePressEvent has the same structure
ClickBindingPrivate cbp(e->modifiers(), e->button(), true, (Qt::MouseButtons)(e->buttons() & ~(e->button())), currentlyPressedKey_);
if (clickBinding_.contains(cbp))
performClickAction(clickBinding_[cbp], e);
else
if (mouseGrabber())
mouseGrabber()->mouseDoubleClickEvent(e, camera());
else
e->ignore();
}
/*! Sets the state of displaysInStereo(). See also toggleStereoDisplay().
First checks that the display is able to handle stereovision using QGLWidget::format(). Opens a
warning message box in case of failure. Emits the stereoChanged() signal otherwise. */
void QGLViewer::setStereoDisplay(bool stereo)
{
if (format().stereo())
{
stereo_ = stereo;
if (!displaysInStereo())
{
glDrawBuffer(GL_BACK_LEFT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDrawBuffer(GL_BACK_RIGHT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
Q_EMIT stereoChanged(stereo_);
update();
}
else
if (stereo)
QMessageBox::warning(this, tr("Stereo not supported", "Message box window title"), tr("Stereo is not supported on this display."));
else
stereo_ = false;
}
/*! Sets the isFullScreen() state.
If the QGLViewer is embedded in an other QWidget (see QWidget::topLevelWidget()), this widget is
displayed in full screen instead. */
void QGLViewer::setFullScreen(bool fullScreen)
{
if (fullScreen_ == fullScreen) return;
fullScreen_ = fullScreen;
QWidget* tlw = topLevelWidget();
if (isFullScreen())
{
prevPos_ = topLevelWidget()->pos();
tlw->showFullScreen();
tlw->move(0,0);
}
else
{
tlw->showNormal();
tlw->move(prevPos_);
}
}
/*! Directly defines the mouseGrabber().
You should not call this method directly as it bypasses the
qglviewer::MouseGrabber::checkIfGrabsMouse() test performed by mouseMoveEvent().
If the MouseGrabber is disabled (see mouseGrabberIsEnabled()), this method silently does nothing. */
void QGLViewer::setMouseGrabber(MouseGrabber* mouseGrabber)
{
if (!mouseGrabberIsEnabled(mouseGrabber))
return;
mouseGrabber_ = mouseGrabber;
mouseGrabberIsAManipulatedFrame_ = (dynamic_cast<ManipulatedFrame*>(mouseGrabber) != NULL);
mouseGrabberIsAManipulatedCameraFrame_ = ((dynamic_cast<ManipulatedCameraFrame*>(mouseGrabber) != NULL) &&
(mouseGrabber != camera()->frame()));
Q_EMIT mouseGrabberChanged(mouseGrabber);
}
/*! Sets the mouseGrabberIsEnabled() state. */
void QGLViewer::setMouseGrabberIsEnabled(const qglviewer::MouseGrabber* const mouseGrabber, bool enabled)
{
if (enabled)
disabledMouseGrabbers_.remove(reinterpret_cast<size_t>(mouseGrabber));
else
disabledMouseGrabbers_[reinterpret_cast<size_t>(mouseGrabber)];
}
QString QGLViewer::mouseActionString(QGLViewer::MouseAction ma)
{
switch (ma)
{
case QGLViewer::NO_MOUSE_ACTION : return QString::null;
case QGLViewer::ROTATE : return QGLViewer::tr("Rotates", "ROTATE mouse action");
case QGLViewer::ZOOM : return QGLViewer::tr("Zooms", "ZOOM mouse action");
case QGLViewer::TRANSLATE : return QGLViewer::tr("Translates", "TRANSLATE mouse action");
case QGLViewer::MOVE_FORWARD : return QGLViewer::tr("Moves forward", "MOVE_FORWARD mouse action");
case QGLViewer::LOOK_AROUND : return QGLViewer::tr("Looks around", "LOOK_AROUND mouse action");
case QGLViewer::MOVE_BACKWARD : return QGLViewer::tr("Moves backward", "MOVE_BACKWARD mouse action");
case QGLViewer::SCREEN_ROTATE : return QGLViewer::tr("Rotates in screen plane", "SCREEN_ROTATE mouse action");
case QGLViewer::ROLL : return QGLViewer::tr("Rolls", "ROLL mouse action");
case QGLViewer::DRIVE : return QGLViewer::tr("Drives", "DRIVE mouse action");
case QGLViewer::SCREEN_TRANSLATE : return QGLViewer::tr("Horizontally/Vertically translates", "SCREEN_TRANSLATE mouse action");
case QGLViewer::ZOOM_ON_REGION : return QGLViewer::tr("Zooms on region for", "ZOOM_ON_REGION mouse action");
}
return QString::null;
}
QString QGLViewer::clickActionString(QGLViewer::ClickAction ca)
{
switch (ca)
{
case QGLViewer::NO_CLICK_ACTION : return QString::null;
case QGLViewer::ZOOM_ON_PIXEL : return QGLViewer::tr("Zooms on pixel", "ZOOM_ON_PIXEL click action");
case QGLViewer::ZOOM_TO_FIT : return QGLViewer::tr("Zooms to fit scene", "ZOOM_TO_FIT click action");
case QGLViewer::SELECT : return QGLViewer::tr("Selects", "SELECT click action");
case QGLViewer::RAP_FROM_PIXEL : return QGLViewer::tr("Sets pivot point", "RAP_FROM_PIXEL click action");
case QGLViewer::RAP_IS_CENTER : return QGLViewer::tr("Resets pivot point", "RAP_IS_CENTER click action");
case QGLViewer::CENTER_FRAME : return QGLViewer::tr("Centers manipulated frame", "CENTER_FRAME click action");
case QGLViewer::CENTER_SCENE : return QGLViewer::tr("Centers scene", "CENTER_SCENE click action");
case QGLViewer::SHOW_ENTIRE_SCENE : return QGLViewer::tr("Shows entire scene", "SHOW_ENTIRE_SCENE click action");
case QGLViewer::ALIGN_FRAME : return QGLViewer::tr("Aligns manipulated frame", "ALIGN_FRAME click action");
case QGLViewer::ALIGN_CAMERA : return QGLViewer::tr("Aligns camera", "ALIGN_CAMERA click action");
}
return QString::null;
}
static QString keyString(unsigned int key)
{
# if QT_VERSION >= 0x040100
return QKeySequence(int(key)).toString(QKeySequence::NativeText);
# else
return QString(QKeySequence(key));
# endif
}
QString QGLViewer::formatClickActionPrivate(ClickBindingPrivate cbp)
{
bool buttonsBefore = cbp.buttonsBefore != Qt::NoButton;
QString keyModifierString = keyString(cbp.modifiers + cbp.key);
if (!keyModifierString.isEmpty()) {
#ifdef Q_OS_MAC
// modifiers never has a '+' sign. Add one space to clearly separate modifiers (and possible key) from button
keyModifierString += " ";
#else
// modifiers might be of the form : 'S' or 'Ctrl+S' or 'Ctrl+'. For consistency, add an other '+' if needed, no spaces
if (!keyModifierString.endsWith('+'))
keyModifierString += "+";
#endif
}
return tr("%1%2%3%4%5%6", "Modifier / button or wheel / double click / with / button / pressed")
.arg(keyModifierString)
.arg(mouseButtonsString(cbp.button)+(cbp.button == Qt::NoButton ? tr("Wheel", "Mouse wheel") : ""))
.arg(cbp.doubleClick ? tr(" double click", "Suffix after mouse button") : "")
.arg(buttonsBefore ? tr(" with ", "As in : Left button with Ctrl pressed") : "")
.arg(buttonsBefore ? mouseButtonsString(cbp.buttonsBefore) : "")
.arg(buttonsBefore ? tr(" pressed", "As in : Left button with Ctrl pressed") : "");
}
bool QGLViewer::isValidShortcutKey(int key) {
return (key >= Qt::Key_Any && key < Qt::Key_Escape) || (key >= Qt::Key_F1 && key <= Qt::Key_F35);
}
#ifndef DOXYGEN
/*! This method is deprecated since version 2.5.0
Use setMouseBindingDescription(Qt::KeyboardModifiers, Qt::MouseButtons, QString, bool, Qt::MouseButtons) instead.
*/
void QGLViewer::setMouseBindingDescription(unsigned int state, QString description, bool doubleClick, Qt::MouseButtons buttonsBefore) {
qWarning("setMouseBindingDescription(int state,...) is deprecated. Use the modifier/button equivalent");
setMouseBindingDescription(keyboardModifiersFromState(state),
mouseButtonFromState(state),
description,
doubleClick,
buttonsBefore);
}
#endif
/*! Defines a custom mouse binding description, displayed in the help() window's Mouse tab.
Same as calling setMouseBindingDescription(Qt::Key, Qt::KeyboardModifiers, Qt::MouseButton, QString, bool, Qt::MouseButtons),
with a key value of Qt::Key(0) (i.e. binding description when no regular key needs to be pressed). */
void QGLViewer::setMouseBindingDescription(Qt::KeyboardModifiers modifiers, Qt::MouseButton button, QString description, bool doubleClick, Qt::MouseButtons buttonsBefore)
{
setMouseBindingDescription(Qt::Key(0), modifiers, button, description, doubleClick, buttonsBefore);
}
/*! Defines a custom mouse binding description, displayed in the help() window's Mouse tab.
\p modifiers is a combination of Qt::KeyboardModifiers (\c Qt::ControlModifier, \c Qt::AltModifier, \c
Qt::ShiftModifier, \c Qt::MetaModifier). Possibly combined using the \c "|" operator.
\p button is one of the Qt::MouseButtons (\c Qt::LeftButton, \c Qt::MidButton,
\c Qt::RightButton...).
\p doubleClick indicates whether or not the user has to double click this button to perform the
described action. \p buttonsBefore lists the buttons that need to be pressed before the double click.
Set an empty \p description to \e remove a mouse binding description.
\code
// The R key combined with the Left mouse button rotates the camera in the screen plane.
setMouseBindingDescription(Qt::Key_R, Qt::NoModifier, Qt::LeftButton, "Rotates camera in screen plane");
// A left button double click toggles full screen
setMouseBindingDescription(Qt::NoModifier, Qt::LeftButton, "Toggles full screen mode", true);
// Removes the description of Ctrl+Right button
setMouseBindingDescription(Qt::ControlModifier, Qt::RightButton, "");
\endcode
Overload mouseMoveEvent() and friends to implement your custom mouse behavior (see the
mouseMoveEvent() documentation for an example). See the <a
href="../examples/keyboardAndMouse.html">keyboardAndMouse example</a> for an illustration.
Use setMouseBinding() and setWheelBinding() to change the standard mouse action bindings. */
void QGLViewer::setMouseBindingDescription(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button, QString description, bool doubleClick, Qt::MouseButtons buttonsBefore)
{
ClickBindingPrivate cbp(modifiers, button, doubleClick, buttonsBefore, key);
if (description.isEmpty())
mouseDescription_.remove(cbp);
else
mouseDescription_[cbp] = description;
}
static QString tableLine(const QString& left, const QString& right)
{
static bool even = false;
const QString tdtd("</b></td><td>");
const QString tdtr("</td></tr>\n");
QString res("<tr bgcolor=\"");
if (even)
res += "#eeeeff\">";
else
res += "#ffffff\">";
res += "<td><b>" + left + tdtd + right + tdtr;
even = !even;
return res;
}
/*! Returns a QString that describes the application mouse bindings, displayed in the help() window
\c Mouse tab.
Result is a table that describes custom application mouse binding descriptions defined using
setMouseBindingDescription() as well as standard mouse bindings (defined using setMouseBinding()
and setWheelBinding()). See the <a href="../mouse.html">mouse page</a> for details on mouse
bindings.
See also helpString() and keyboardString(). */
QString QGLViewer::mouseString() const
{
QString text("<center><table border=\"1\" cellspacing=\"0\" cellpadding=\"4\">\n");
const QString trtd("<tr><td>");
const QString tdtr("</td></tr>\n");
const QString tdtd("</td><td>");
text += QString("<tr bgcolor=\"#aaaacc\"><th align=\"center\">%1</th><th align=\"center\">%2</th></tr>\n").
arg(tr("Button(s)", "Buttons column header in help window mouse tab")).arg(tr("Description", "Description column header in help window mouse tab"));
QMap<ClickBindingPrivate, QString> mouseBinding;
// User-defined mouse bindings come first.
for (QMap<ClickBindingPrivate, QString>::ConstIterator itm=mouseDescription_.begin(), endm=mouseDescription_.end(); itm!=endm; ++itm)
mouseBinding[itm.key()] = itm.value();
for (QMap<ClickBindingPrivate, QString>::ConstIterator it=mouseBinding.begin(), end=mouseBinding.end(); it != end; ++it)
{
// Should not be needed (see setMouseBindingDescription())
if (it.value().isNull())
continue;
text += tableLine(formatClickActionPrivate(it.key()), it.value());
}
// Optional separator line
if (!mouseBinding.isEmpty())
{
mouseBinding.clear();
text += QString("<tr bgcolor=\"#aaaacc\"><td colspan=2>%1</td></tr>\n").arg(tr("Standard mouse bindings", "In help window mouse tab"));
}
// Then concatenates the descriptions of wheelBinding_, mouseBinding_ and clickBinding_.
// The order is significant and corresponds to the priorities set in mousePressEvent() (reverse priority order, last one overwrites previous)
// #CONNECTION# mousePressEvent() order
for (QMap<MouseBindingPrivate, MouseActionPrivate>::ConstIterator itmb=mouseBinding_.begin(), endmb=mouseBinding_.end();
itmb != endmb; ++itmb)
{
ClickBindingPrivate cbp(itmb.key().modifiers, itmb.key().button, false, Qt::NoButton, itmb.key().key);
QString text = mouseActionString(itmb.value().action);
if (!text.isNull())
{
switch (itmb.value().handler)
{
case CAMERA: text += " " + tr("camera", "Suffix after action"); break;
case FRAME: text += " " + tr("manipulated frame", "Suffix after action"); break;
}
if (!(itmb.value().withConstraint))
text += "*";
}
mouseBinding[cbp] = text;
}
for (QMap<WheelBindingPrivate, MouseActionPrivate>::ConstIterator itw=wheelBinding_.begin(), endw=wheelBinding_.end(); itw != endw; ++itw)
{
ClickBindingPrivate cbp(itw.key().modifiers, Qt::NoButton, false, Qt::NoButton, itw.key().key);
QString text = mouseActionString(itw.value().action);
if (!text.isNull())
{
switch (itw.value().handler)
{
case CAMERA: text += " " + tr("camera", "Suffix after action"); break;
case FRAME: text += " " + tr("manipulated frame", "Suffix after action"); break;
}
if (!(itw.value().withConstraint))
text += "*";
}
mouseBinding[cbp] = text;
}
for (QMap<ClickBindingPrivate, ClickAction>::ConstIterator itcb=clickBinding_.begin(), endcb=clickBinding_.end(); itcb!=endcb; ++itcb)
mouseBinding[itcb.key()] = clickActionString(itcb.value());
for (QMap<ClickBindingPrivate, QString>::ConstIterator it2=mouseBinding.begin(), end2=mouseBinding.end(); it2 != end2; ++it2)
{
if (it2.value().isNull())
continue;
text += tableLine(formatClickActionPrivate(it2.key()), it2.value());
}
text += "</table></center>";
return text;
}
/*! Defines a custom keyboard shortcut description, that will be displayed in the help() window \c
Keyboard tab.
The \p key definition is given as an \c int using Qt enumerated values. Set an empty \p description
to remove a shortcut description:
\code
setKeyDescription(Qt::Key_W, "Toggles wireframe display");
setKeyDescription(Qt::CTRL+Qt::Key_L, "Loads a new scene");
// Removes a description
setKeyDescription(Qt::CTRL+Qt::Key_C, "");
\endcode
See the <a href="../examples/keyboardAndMouse.html">keyboardAndMouse example</a> for illustration
and the <a href="../keyboard.html">keyboard page</a> for details. */
void QGLViewer::setKeyDescription(unsigned int key, QString description)
{
if (description.isEmpty())
keyDescription_.remove(key);
else
keyDescription_[key] = description;
}
QString QGLViewer::cameraPathKeysString() const
{
if (pathIndex_.isEmpty())
return QString::null;
QVector<Qt::Key> keys;
keys.reserve(pathIndex_.count());
for (QMap<Qt::Key, unsigned int>::ConstIterator i = pathIndex_.begin(), endi=pathIndex_.end(); i != endi; ++i)
keys.push_back(i.key());
qSort(keys);
QVector<Qt::Key>::const_iterator it = keys.begin(), end = keys.end();
QString res = keyString(*it);
const int maxDisplayedKeys = 6;
int nbDisplayedKeys = 0;
Qt::Key previousKey = (*it);
int state = 0;
++it;
while ((it != end) && (nbDisplayedKeys < maxDisplayedKeys-1))
{
switch (state)
{
case 0 :
if ((*it) == previousKey + 1)
state++;
else
{
res += ", " + keyString(*it);
nbDisplayedKeys++;
}
break;
case 1 :
if ((*it) == previousKey + 1)
state++;
else
{
res += ", " + keyString(previousKey);
res += ", " + keyString(*it);
nbDisplayedKeys += 2;
state = 0;
}
break;
default :
if ((*it) != previousKey + 1)
{
res += ".." + keyString(previousKey);
res += ", " + keyString(*it);
nbDisplayedKeys += 2;
state = 0;
}
break;
}
previousKey = *it;
++it;
}
if (state == 1)
res += ", " + keyString(previousKey);
if (state == 2)
res += ".." + keyString(previousKey);
if (it != end)
res += "...";
return res;
}
/*! Returns a QString that describes the application keyboard shortcut bindings, and that will be
displayed in the help() window \c Keyboard tab.
Default value is a table that describes the custom shortcuts defined using setKeyDescription() as
well as the \e standard QGLViewer::KeyboardAction shortcuts (defined using setShortcut()). See the
<a href="../keyboard.html">keyboard page</a> for details on key customization.
See also helpString() and mouseString(). */
QString QGLViewer::keyboardString() const
{
QString text("<center><table border=\"1\" cellspacing=\"0\" cellpadding=\"4\">\n");
text += QString("<tr bgcolor=\"#aaaacc\"><th align=\"center\">%1</th><th align=\"center\">%2</th></tr>\n").
arg(QGLViewer::tr("Key(s)", "Keys column header in help window mouse tab")).arg(QGLViewer::tr("Description", "Description column header in help window mouse tab"));
QMap<unsigned int, QString> keyDescription;
// 1 - User defined key descriptions
for (QMap<unsigned int, QString>::ConstIterator kd=keyDescription_.begin(), kdend=keyDescription_.end(); kd!=kdend; ++kd)
keyDescription[kd.key()] = kd.value();
// Add to text in sorted order
for (QMap<unsigned int, QString>::ConstIterator kb=keyDescription.begin(), endb=keyDescription.end(); kb!=endb; ++kb)
text += tableLine(keyString(kb.key()), kb.value());
// 2 - Optional separator line
if (!keyDescription.isEmpty())
{
keyDescription.clear();
text += QString("<tr bgcolor=\"#aaaacc\"><td colspan=2>%1</td></tr>\n").arg(QGLViewer::tr("Standard viewer keys", "In help window keys tab"));
}
// 3 - KeyboardAction bindings description
for (QMap<KeyboardAction, unsigned int>::ConstIterator it=keyboardBinding_.begin(), end=keyboardBinding_.end(); it != end; ++it)
if ((it.value() != 0) && ((!cameraIsInRotateMode()) || ((it.key() != INCREASE_FLYSPEED) && (it.key() != DECREASE_FLYSPEED))))
keyDescription[it.value()] = keyboardActionDescription_[it.key()];
// Add to text in sorted order
for (QMap<unsigned int, QString>::ConstIterator kb2=keyDescription.begin(), endb2=keyDescription.end(); kb2!=endb2; ++kb2)
text += tableLine(keyString(kb2.key()), kb2.value());
// 4 - Camera paths keys description
const QString cpks = cameraPathKeysString();
if (!cpks.isNull())
{
text += "<tr bgcolor=\"#ccccff\"><td colspan=2>\n";
text += QGLViewer::tr("Camera paths are controlled using the %1 keys (noted <i>Fx</i> below):", "Help window key tab camera keys").arg(cpks) + "</td></tr>\n";
text += tableLine(keyString(playPathKeyboardModifiers()) + "<i>" + QGLViewer::tr("Fx", "Generic function key (F1..F12)") + "</i>",
QGLViewer::tr("Plays path (or resets saved position)"));
text += tableLine(keyString(addKeyFrameKeyboardModifiers()) + "<i>" + QGLViewer::tr("Fx", "Generic function key (F1..F12)") + "</i>",
QGLViewer::tr("Adds a key frame to path (or defines a position)"));
text += tableLine(keyString(addKeyFrameKeyboardModifiers()) + "<i>" + QGLViewer::tr("Fx", "Generic function key (F1..F12)") + "</i>+<i>" + QGLViewer::tr("Fx", "Generic function key (F1..F12)") + "</i>",
QGLViewer::tr("Deletes path (or saved position)"));
}
text += "</table></center>";
return text;
}
/*! Displays the help window "About" tab. See help() for details. */
void QGLViewer::aboutQGLViewer() {
help();
helpWidget()->setCurrentIndex(3);
}
/*! Opens a modal help window that includes four tabs, respectively filled with helpString(),
keyboardString(), mouseString() and about libQGLViewer.
Rich html-like text can be used (see the QStyleSheet documentation). This method is called when the
user presses the QGLViewer::HELP key (default is 'H').
You can use helpWidget() to access to the help widget (to add/remove tabs, change layout...).
The helpRequired() signal is emitted. */
void QGLViewer::help()
{
Q_EMIT helpRequired();
bool resize = false;
int width=600;
int height=400;
static QString label[] = {tr("&Help", "Help window tab title"), tr("&Keyboard", "Help window tab title"), tr("&Mouse", "Help window tab title"), tr("&About", "Help window about title")};
if (!helpWidget())
{
// Qt4 requires a NULL parent...
helpWidget_ = new QTabWidget(NULL);
helpWidget()->setWindowTitle(tr("Help", "Help window title"));
resize = true;
for (int i=0; i<4; ++i)
{
QTextEdit* tab = new QTextEdit(NULL);
tab->setReadOnly(true);
helpWidget()->insertTab(i, tab, label[i]);
if (i==3) {
# include "qglviewer-icon.xpm"
QPixmap pixmap(qglviewer_icon);
tab->document()->addResource(QTextDocument::ImageResource,
QUrl("mydata://qglviewer-icon.xpm"), QVariant(pixmap));
}
}
}
for (int i=0; i<4; ++i)
{
QString text;
switch (i)
{
case 0 : text = helpString(); break;
case 1 : text = keyboardString(); break;
case 2 : text = mouseString(); break;
case 3 : text = QString("<center><br><img src=\"mydata://qglviewer-icon.xpm\">") + tr(
"<h1>libQGLViewer</h1>"
"<h3>Version %1</h3><br>"
"A versatile 3D viewer based on OpenGL and Qt<br>"
"Copyright 2002-%2 Gilles Debunne<br>"
"<code>%3</code>").arg(QGLViewerVersionString()).arg("2014").arg("http://www.libqglviewer.com") +
QString("</center>");
break;
default : break;
}
QTextEdit* textEdit = (QTextEdit*)(helpWidget()->widget(i));
textEdit->setHtml(text);
textEdit->setText(text);
if (resize && (textEdit->height() > height))
height = textEdit->height();
}
if (resize)
helpWidget()->resize(width, height+40); // 40 pixels is ~ tabs' height
helpWidget()->show();
helpWidget()->raise();
}
/*! Overloading of the \c QWidget method.
Default keyboard shortcuts are defined using setShortcut(). Overload this method to implement a
specific keyboard binding. Call the original method if you do not catch the event to preserve the
viewer default key bindings:
\code
void Viewer::keyPressEvent(QKeyEvent *e)
{
// Defines the Alt+R shortcut.
if ((e->key() == Qt::Key_R) && (e->modifiers() == Qt::AltModifier))
{
myResetFunction();
update(); // Refresh display
}
else
QGLViewer::keyPressEvent(e);
}
// With Qt 2 or 3, you would retrieve modifiers keys using :
// const Qt::ButtonState modifiers = (Qt::ButtonState)(e->state() & Qt::KeyButtonMask);
\endcode
When you define a new keyboard shortcut, use setKeyDescription() to provide a short description
which is displayed in the help() window Keyboard tab. See the <a
href="../examples/keyboardAndMouse.html">keyboardAndMouse</a> example for an illustration.
See also QGLWidget::keyReleaseEvent(). */
void QGLViewer::keyPressEvent(QKeyEvent *e)
{
if (e->key() == 0)
{
e->ignore();
return;
}
const Qt::Key key = Qt::Key(e->key());
const Qt::KeyboardModifiers modifiers = e->modifiers();
QMap<KeyboardAction, unsigned int>::ConstIterator it=keyboardBinding_.begin(), end=keyboardBinding_.end();
const unsigned int target = key | modifiers;
while ((it != end) && (it.value() != target))
++it;
if (it != end)
handleKeyboardAction(it.key());
else
if (pathIndex_.contains(Qt::Key(key)))
{
// Camera paths
unsigned int index = pathIndex_[Qt::Key(key)];
// not safe, but try to double press on two viewers at the same time !
static QTime doublePress;
if (modifiers == playPathKeyboardModifiers())
{
int elapsed = doublePress.restart();
if ((elapsed < 250) && (index==previousPathId_))
camera()->resetPath(index);
else
{
// Stop previous interpolation before starting a new one.
if (index != previousPathId_)
{
KeyFrameInterpolator* previous = camera()->keyFrameInterpolator(previousPathId_);
if ((previous) && (previous->interpolationIsStarted()))
previous->resetInterpolation();
}
camera()->playPath(index);
}
previousPathId_ = index;
}
else if (modifiers == addKeyFrameKeyboardModifiers())
{
int elapsed = doublePress.restart();
if ((elapsed < 250) && (index==previousPathId_))
{
if (camera()->keyFrameInterpolator(index))
{
disconnect(camera()->keyFrameInterpolator(index), SIGNAL(interpolated()), this, SLOT(update()));
if (camera()->keyFrameInterpolator(index)->numberOfKeyFrames() > 1)
displayMessage(tr("Path %1 deleted", "Feedback message").arg(index));
else
displayMessage(tr("Position %1 deleted", "Feedback message").arg(index));
camera()->deletePath(index);
}
}
else
{
bool nullBefore = (camera()->keyFrameInterpolator(index) == NULL);
camera()->addKeyFrameToPath(index);
if (nullBefore)
connect(camera()->keyFrameInterpolator(index), SIGNAL(interpolated()), SLOT(update()));
int nbKF = camera()->keyFrameInterpolator(index)->numberOfKeyFrames();
if (nbKF > 1)
displayMessage(tr("Path %1, position %2 added", "Feedback message").arg(index).arg(nbKF));
else
displayMessage(tr("Position %1 saved", "Feedback message").arg(index));
}
previousPathId_ = index;
}
update();
} else {
if (isValidShortcutKey(key)) currentlyPressedKey_ = key;
e->ignore();
}
}
void QGLViewer::keyReleaseEvent(QKeyEvent * e) {
if (isValidShortcutKey(e->key())) currentlyPressedKey_ = Qt::Key(0);
}
void QGLViewer::handleKeyboardAction(KeyboardAction id)
{
switch (id)
{
case DRAW_AXIS : toggleAxisIsDrawn(); break;
case DRAW_GRID : toggleGridIsDrawn(); break;
case DISPLAY_FPS : toggleFPSIsDisplayed(); break;
case ENABLE_TEXT : toggleTextIsEnabled(); break;
case EXIT_VIEWER : saveStateToFileForAllViewers(); qApp->closeAllWindows(); break;
case SAVE_SCREENSHOT : saveSnapshot(false, false); break;
case FULL_SCREEN : toggleFullScreen(); break;
case STEREO : toggleStereoDisplay(); break;
case ANIMATION : toggleAnimation(); break;
case HELP : help(); break;
case EDIT_CAMERA : toggleCameraIsEdited(); break;
case SNAPSHOT_TO_CLIPBOARD : snapshotToClipboard(); break;
case CAMERA_MODE :
toggleCameraMode();
displayMessage(cameraIsInRotateMode()?tr("Camera in observer mode", "Feedback message"):tr("Camera in fly mode", "Feedback message"));
break;
case MOVE_CAMERA_LEFT :
camera()->frame()->translate(camera()->frame()->inverseTransformOf(Vec(-10.0*camera()->flySpeed(), 0.0, 0.0)));
update();
break;
case MOVE_CAMERA_RIGHT :
camera()->frame()->translate(camera()->frame()->inverseTransformOf(Vec( 10.0*camera()->flySpeed(), 0.0, 0.0)));
update();
break;
case MOVE_CAMERA_UP :
camera()->frame()->translate(camera()->frame()->inverseTransformOf(Vec(0.0, 10.0*camera()->flySpeed(), 0.0)));
update();
break;
case MOVE_CAMERA_DOWN :
camera()->frame()->translate(camera()->frame()->inverseTransformOf(Vec(0.0, -10.0*camera()->flySpeed(), 0.0)));
update();
break;
case INCREASE_FLYSPEED : camera()->setFlySpeed(camera()->flySpeed() * 1.5); break;
case DECREASE_FLYSPEED : camera()->setFlySpeed(camera()->flySpeed() / 1.5); break;
}
}
/*! Callback method used when the widget size is modified.
If you overload this method, first call the inherited method. Also called when the widget is
created, before its first display. */
void QGLViewer::resizeGL(int width, int height)
{
QGLWidget::resizeGL(width, height);
glViewport( 0, 0, GLint(width), GLint(height) );
camera()->setScreenWidthAndHeight(this->width(), this->height());
}
//////////////////////////////////////////////////////////////////////////
// K e y b o a r d s h o r t c u t s //
//////////////////////////////////////////////////////////////////////////
/*! Defines the shortcut() that triggers a given QGLViewer::KeyboardAction.
Here are some examples:
\code
// Press 'Q' to exit application
setShortcut(EXIT_VIEWER, Qt::Key_Q);
// Alt+M toggles camera mode
setShortcut(CAMERA_MODE, Qt::ALT + Qt::Key_M);
// The DISPLAY_FPS action is disabled
setShortcut(DISPLAY_FPS, 0);
\endcode
Only one shortcut can be assigned to a given QGLViewer::KeyboardAction (new bindings replace
previous ones). If several KeyboardAction are binded to the same shortcut, only one of them is
active. */
void QGLViewer::setShortcut(KeyboardAction action, unsigned int key)
{
keyboardBinding_[action] = key;
}
/*! Returns the keyboard shortcut associated to a given QGLViewer::KeyboardAction.
Result is an \c unsigned \c int defined using Qt enumerated values, as in \c Qt::Key_Q or
\c Qt::CTRL + Qt::Key_X. Use Qt::MODIFIER_MASK to separate the key from the state keys. Returns \c 0 if
the KeyboardAction is disabled (not binded). Set using setShortcut().
If you want to define keyboard shortcuts for custom actions (say, open a scene file), overload
keyPressEvent() and then setKeyDescription().
These shortcuts and their descriptions are automatically included in the help() window \c Keyboard
tab.
See the <a href="../keyboard.html">keyboard page</a> for details and default values and the <a
href="../examples/keyboardAndMouse.html">keyboardAndMouse</a> example for a practical
illustration. */
unsigned int QGLViewer::shortcut(KeyboardAction action) const
{
if (keyboardBinding_.contains(action))
return keyboardBinding_[action];
else
return 0;
}
#ifndef DOXYGEN
void QGLViewer::setKeyboardAccelerator(KeyboardAction action, unsigned int key)
{
qWarning("setKeyboardAccelerator is deprecated. Use setShortcut instead.");
setShortcut(action, key);
}
unsigned int QGLViewer::keyboardAccelerator(KeyboardAction action) const
{
qWarning("keyboardAccelerator is deprecated. Use shortcut instead.");
return shortcut(action);
}
#endif
/////// Key Frames associated keys ///////
/*! Returns the keyboard key associated to camera Key Frame path \p index.
Default values are F1..F12 for indexes 1..12.
addKeyFrameKeyboardModifiers() (resp. playPathKeyboardModifiers()) define the state key(s) that
must be pressed with this key to add a KeyFrame to (resp. to play) the associated Key Frame path.
If you quickly press twice the pathKey(), the path is reset (resp. deleted).
Use camera()->keyFrameInterpolator( \p index ) to retrieve the KeyFrameInterpolator that defines
the path.
If several keys are binded to a given \p index (see setPathKey()), one of them is returned.
Returns \c 0 if no key is associated with this index.
See also the <a href="../keyboard.html">keyboard page</a>. */
Qt::Key QGLViewer::pathKey(unsigned int index) const
{
for (QMap<Qt::Key, unsigned int>::ConstIterator it = pathIndex_.begin(), end=pathIndex_.end(); it != end; ++it)
if (it.value() == index)
return it.key();
return Qt::Key(0);
}
/*! Sets the pathKey() associated with the camera Key Frame path \p index.
Several keys can be binded to the same \p index. Use a negated \p key value to delete the binding
(the \p index value is then ignored):
\code
// Press 'space' to play/pause/add/delete camera path of index 0.
setPathKey(Qt::Key_Space, 0);
// Remove this binding
setPathKey(-Qt::Key_Space);
\endcode */
void QGLViewer::setPathKey(int key, unsigned int index)
{
Qt::Key k = Qt::Key(abs(key));
if (key < 0)
pathIndex_.remove(k);
else
pathIndex_[k] = index;
}
/*! Sets the playPathKeyboardModifiers() value. */
void QGLViewer::setPlayPathKeyboardModifiers(Qt::KeyboardModifiers modifiers)
{
playPathKeyboardModifiers_ = modifiers;
}
/*! Sets the addKeyFrameKeyboardModifiers() value. */
void QGLViewer::setAddKeyFrameKeyboardModifiers(Qt::KeyboardModifiers modifiers)
{
addKeyFrameKeyboardModifiers_ = modifiers;
}
/*! Returns the keyboard modifiers that must be pressed with a pathKey() to add the current camera
position to a KeyFrame path.
It can be \c Qt::NoModifier, \c Qt::ControlModifier, \c Qt::ShiftModifier, \c Qt::AltModifier, \c
Qt::MetaModifier or a combination of these (using the bitwise '|' operator).
Default value is Qt::AltModifier. Defined using setAddKeyFrameKeyboardModifiers().
See also playPathKeyboardModifiers(). */
Qt::KeyboardModifiers QGLViewer::addKeyFrameKeyboardModifiers() const
{
return addKeyFrameKeyboardModifiers_;
}
/*! Returns the keyboard modifiers that must be pressed with a pathKey() to play a camera KeyFrame path.
It can be \c Qt::NoModifier, \c Qt::ControlModifier, \c Qt::ShiftModifier, \c Qt::AltModifier, \c
Qt::MetaModifier or a combination of these (using the bitwise '|' operator).
Default value is Qt::NoModifier. Defined using setPlayPathKeyboardModifiers().
See also addKeyFrameKeyboardModifiers(). */
Qt::KeyboardModifiers QGLViewer::playPathKeyboardModifiers() const
{
return playPathKeyboardModifiers_;
}
#ifndef DOXYGEN
// Deprecated methods
Qt::KeyboardModifiers QGLViewer::addKeyFrameStateKey() const
{
qWarning("addKeyFrameStateKey has been renamed addKeyFrameKeyboardModifiers");
return addKeyFrameKeyboardModifiers(); }
Qt::KeyboardModifiers QGLViewer::playPathStateKey() const
{
qWarning("playPathStateKey has been renamed playPathKeyboardModifiers");
return playPathKeyboardModifiers();
}
void QGLViewer::setAddKeyFrameStateKey(unsigned int buttonState)
{
qWarning("setAddKeyFrameStateKey has been renamed setAddKeyFrameKeyboardModifiers");
setAddKeyFrameKeyboardModifiers(keyboardModifiersFromState(buttonState));
}
void QGLViewer::setPlayPathStateKey(unsigned int buttonState)
{
qWarning("setPlayPathStateKey has been renamed setPlayPathKeyboardModifiers");
setPlayPathKeyboardModifiers(keyboardModifiersFromState(buttonState));
}
Qt::Key QGLViewer::keyFrameKey(unsigned int index) const
{
qWarning("keyFrameKey has been renamed pathKey.");
return pathKey(index);
}
Qt::KeyboardModifiers QGLViewer::playKeyFramePathStateKey() const
{
qWarning("playKeyFramePathStateKey has been renamed playPathKeyboardModifiers.");
return playPathKeyboardModifiers();
}
void QGLViewer::setKeyFrameKey(unsigned int index, int key)
{
qWarning("setKeyFrameKey is deprecated, use setPathKey instead, with swapped parameters.");
setPathKey(key, index);
}
void QGLViewer::setPlayKeyFramePathStateKey(unsigned int buttonState)
{
qWarning("setPlayKeyFramePathStateKey has been renamed setPlayPathKeyboardModifiers.");
setPlayPathKeyboardModifiers(keyboardModifiersFromState(buttonState));
}
#endif
////////////////////////////////////////////////////////////////////////////////
// M o u s e b e h a v i o r s t a t e k e y s //
////////////////////////////////////////////////////////////////////////////////
#ifndef DOXYGEN
/*! This method has been deprecated since version 2.5.0
Associates keyboard modifiers to MouseHandler \p handler.
The \p modifiers parameter is \c Qt::AltModifier, \c Qt::ShiftModifier, \c Qt::ControlModifier, \c
Qt::MetaModifier or a combination of these using the '|' bitwise operator.
\e All the \p handler's associated bindings will then need the specified \p modifiers key(s) to be
activated.
With this code,
\code
setHandlerKeyboardModifiers(QGLViewer::CAMERA, Qt::AltModifier);
setHandlerKeyboardModifiers(QGLViewer::FRAME, Qt::NoModifier);
\endcode
you will have to press the \c Alt key while pressing mouse buttons in order to move the camera(),
while no key will be needed to move the manipulatedFrame().
This method has a very basic implementation: every action binded to \p handler has its keyboard
modifier replaced by \p modifiers. If \p handler had some actions binded to different modifiers,
these settings will be lost. You should hence consider using setMouseBinding() for finer tuning.
The default binding associates \c Qt::ControlModifier to all the QGLViewer::FRAME actions and \c
Qt::NoModifier to all QGLViewer::CAMERA actions. See <a href="../mouse.html">mouse page</a> for
details.
\attention This method calls setMouseBinding(), which ensures that only one action is binded to a
given modifiers. If you want to \e swap the QGLViewer::CAMERA and QGLViewer::FRAME keyboard
modifiers, you have to use a temporary dummy modifier (as if you were swapping two variables) or
else the first call will overwrite the previous settings:
\code
// Associate FRAME with Alt (temporary value)
setHandlerKeyboardModifiers(QGLViewer::FRAME, Qt::AltModifier);
// Control is associated with CAMERA
setHandlerKeyboardModifiers(QGLViewer::CAMERA, Qt::ControlModifier);
// And finally, FRAME can be associated with NoModifier
setHandlerKeyboardModifiers(QGLViewer::FRAME, Qt::NoModifier);
\endcode */
void QGLViewer::setHandlerKeyboardModifiers(MouseHandler handler, Qt::KeyboardModifiers modifiers)
{
qWarning("setHandlerKeyboardModifiers is deprecated, call setMouseBinding() instead");
QMap<MouseBindingPrivate, MouseActionPrivate> newMouseBinding;
QMap<WheelBindingPrivate, MouseActionPrivate> newWheelBinding;
QMap<ClickBindingPrivate, ClickAction> newClickBinding_;
QMap<MouseBindingPrivate, MouseActionPrivate>::Iterator mit;
QMap<WheelBindingPrivate, MouseActionPrivate>::Iterator wit;
// First copy unchanged bindings.
for (mit = mouseBinding_.begin(); mit != mouseBinding_.end(); ++mit)
if ((mit.value().handler != handler) || (mit.value().action == ZOOM_ON_REGION))
newMouseBinding[mit.key()] = mit.value();
for (wit = wheelBinding_.begin(); wit != wheelBinding_.end(); ++wit)
if (wit.value().handler != handler)
newWheelBinding[wit.key()] = wit.value();
// Then, add modified bindings, that can overwrite the previous ones.
for (mit = mouseBinding_.begin(); mit != mouseBinding_.end(); ++mit)
if ((mit.value().handler == handler) && (mit.value().action != ZOOM_ON_REGION))
{
MouseBindingPrivate mbp(modifiers, mit.key().button, mit.key().key);
newMouseBinding[mbp] = mit.value();
}
for (wit = wheelBinding_.begin(); wit != wheelBinding_.end(); ++wit)
if (wit.value().handler == handler)
{
WheelBindingPrivate wbp(modifiers, wit.key().key);
newWheelBinding[wbp] = wit.value();
}
// Same for button bindings
for (QMap<ClickBindingPrivate, ClickAction>::ConstIterator cb=clickBinding_.begin(), end=clickBinding_.end(); cb != end; ++cb)
if (((handler==CAMERA) && ((cb.value() == CENTER_SCENE) || (cb.value() == ALIGN_CAMERA))) ||
((handler==FRAME) && ((cb.value() == CENTER_FRAME) || (cb.value() == ALIGN_FRAME))))
{
ClickBindingPrivate cbp(modifiers, cb.key().button, cb.key().doubleClick, cb.key().buttonsBefore, cb.key().key);
newClickBinding_[cbp] = cb.value();
}
else
newClickBinding_[cb.key()] = cb.value();
mouseBinding_ = newMouseBinding;
wheelBinding_ = newWheelBinding;
clickBinding_ = newClickBinding_;
}
void QGLViewer::setHandlerStateKey(MouseHandler handler, unsigned int buttonState)
{
qWarning("setHandlerStateKey has been renamed setHandlerKeyboardModifiers");
setHandlerKeyboardModifiers(handler, keyboardModifiersFromState(buttonState));
}
void QGLViewer::setMouseStateKey(MouseHandler handler, unsigned int buttonState)
{
qWarning("setMouseStateKey has been renamed setHandlerKeyboardModifiers.");
setHandlerKeyboardModifiers(handler, keyboardModifiersFromState(buttonState));
}
/*! This method is deprecated since version 2.5.0
Use setMouseBinding(Qt::KeyboardModifiers, Qt::MouseButtons, MouseHandler, MouseAction, bool) instead.
*/
void QGLViewer::setMouseBinding(unsigned int state, MouseHandler handler, MouseAction action, bool withConstraint)
{
qWarning("setMouseBinding(int state, MouseHandler...) is deprecated. Use the modifier/button equivalent");
setMouseBinding(keyboardModifiersFromState(state),
mouseButtonFromState(state),
handler,
action,
withConstraint);
}
#endif
/*! Defines a MouseAction binding.
Same as calling setMouseBinding(Qt::Key, Qt::KeyboardModifiers, Qt::MouseButton, MouseHandler, MouseAction, bool),
with a key value of Qt::Key(0) (i.e. no regular extra key needs to be pressed to perform this action). */
void QGLViewer::setMouseBinding(Qt::KeyboardModifiers modifiers, Qt::MouseButton button, MouseHandler handler, MouseAction action, bool withConstraint) {
setMouseBinding(Qt::Key(0), modifiers, button, handler, action, withConstraint);
}
/*! Associates a MouseAction to any mouse \p button, while keyboard \p modifiers and \p key are pressed.
The receiver of the mouse events is a MouseHandler (QGLViewer::CAMERA or QGLViewer::FRAME).
The parameters should read: when the mouse \p button is pressed, while the keyboard \p modifiers and \p key are down,
activate \p action on \p handler. Use Qt::NoModifier to indicate that no modifier
key is needed, and a \p key value of 0 if no regular key has to be pressed
(or simply use setMouseBinding(Qt::KeyboardModifiers, Qt::MouseButton, MouseHandler, MouseAction, bool)).
Use the '|' operator to combine modifiers:
\code
// The R key combined with the Left mouse button rotates the camera in the screen plane.
setMouseBinding(Qt::Key_R, Qt::NoModifier, Qt::LeftButton, CAMERA, SCREEN_ROTATE);
// Alt + Shift and Left button rotates the manipulatedFrame().
setMouseBinding(Qt::AltModifier | Qt::ShiftModifier, Qt::LeftButton, FRAME, ROTATE);
\endcode
If \p withConstraint is \c true (default), the possible
qglviewer::Frame::constraint() of the associated Frame will be enforced during motion.
The list of all possible MouseAction, some binding examples and default bindings are provided in
the <a href="../mouse.html">mouse page</a>.
See the <a href="../examples/keyboardAndMouse.html">keyboardAndMouse</a> example for an illustration.
If no mouse button is specified, the binding is ignored. If an action was previously
associated with this keyboard and button combination, it is silently overwritten (call mouseAction()
before to check).
To remove a specific mouse binding, use \p NO_MOUSE_ACTION as the \p action.
See also setMouseBinding(Qt::KeyboardModifiers, Qt::MouseButtons, ClickAction, bool, int), setWheelBinding() and clearMouseBindings(). */
void QGLViewer::setMouseBinding(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button, MouseHandler handler, MouseAction action, bool withConstraint)
{
if ((handler == FRAME) && ((action == MOVE_FORWARD) || (action == MOVE_BACKWARD) ||
(action == ROLL) || (action == LOOK_AROUND) ||
(action == ZOOM_ON_REGION))) {
qWarning("Cannot bind %s to FRAME", mouseActionString(action).toLatin1().constData());
return;
}
if (button == Qt::NoButton) {
qWarning("No mouse button specified in setMouseBinding");
return;
}
MouseActionPrivate map;
map.handler = handler;
map.action = action;
map.withConstraint = withConstraint;
MouseBindingPrivate mbp(modifiers, button, key);
if (action == NO_MOUSE_ACTION)
mouseBinding_.remove(mbp);
else
mouseBinding_.insert(mbp, map);
ClickBindingPrivate cbp(modifiers, button, false, Qt::NoButton, key);
clickBinding_.remove(cbp);
}
#ifndef DOXYGEN
/*! This method is deprecated since version 2.5.0
Use setMouseBinding(Qt::KeyboardModifiers, Qt::MouseButtons, MouseHandler, MouseAction, bool) instead.
*/
void QGLViewer::setMouseBinding(unsigned int state, ClickAction action, bool doubleClick, Qt::MouseButtons buttonsBefore) {
qWarning("setMouseBinding(int state, ClickAction...) is deprecated. Use the modifier/button equivalent");
setMouseBinding(keyboardModifiersFromState(state),
mouseButtonFromState(state),
action,
doubleClick,
buttonsBefore);
}
#endif
/*! Defines a ClickAction binding.
Same as calling setMouseBinding(Qt::Key, Qt::KeyboardModifiers, Qt::MouseButton, ClickAction, bool, Qt::MouseButtons),
with a key value of Qt::Key(0) (i.e. no regular key needs to be pressed to activate this action). */
void QGLViewer::setMouseBinding(Qt::KeyboardModifiers modifiers, Qt::MouseButton button, ClickAction action, bool doubleClick, Qt::MouseButtons buttonsBefore)
{
setMouseBinding(Qt::Key(0), modifiers, button, action, doubleClick, buttonsBefore);
}
/*! Associates a ClickAction to a button and keyboard key and modifier(s) combination.
The parameters should read: when \p button is pressed, while the \p modifiers and \p key keys are down,
and possibly as a \p doubleClick, then perform \p action. Use Qt::NoModifier to indicate that no modifier
key is needed, and a \p key value of 0 if no regular key has to be pressed (or simply use
setMouseBinding(Qt::KeyboardModifiers, Qt::MouseButton, ClickAction, bool, Qt::MouseButtons)).
If \p buttonsBefore is specified (valid only when \p doubleClick is \c true), then this (or these) other mouse
button(s) has (have) to be pressed \e before the double click occurs in order to execute \p action.
The list of all possible ClickAction, some binding examples and default bindings are listed in the
<a href="../mouse.html">mouse page</a>. See also the setMouseBinding() documentation.
See the <a href="../examples/keyboardAndMouse.html">keyboardAndMouse example</a> for an
illustration.
The binding is ignored if Qt::NoButton is specified as \p buttons.
See also setMouseBinding(Qt::KeyboardModifiers, Qt::MouseButtons, MouseHandler, MouseAction, bool), setWheelBinding() and clearMouseBindings().
*/
void QGLViewer::setMouseBinding(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button, ClickAction action, bool doubleClick, Qt::MouseButtons buttonsBefore)
{
if ((buttonsBefore != Qt::NoButton) && !doubleClick) {
qWarning("Buttons before is only meaningful when doubleClick is true in setMouseBinding().");
return;
}
if (button == Qt::NoButton) {
qWarning("No mouse button specified in setMouseBinding");
return;
}
ClickBindingPrivate cbp(modifiers, button, doubleClick, buttonsBefore, key);
// #CONNECTION performClickAction comment on NO_CLICK_ACTION
if (action == NO_CLICK_ACTION)
clickBinding_.remove(cbp);
else
clickBinding_.insert(cbp, action);
if ((!doubleClick) && (buttonsBefore == Qt::NoButton)) {
MouseBindingPrivate mbp(modifiers, button, key);
mouseBinding_.remove(mbp);
}
}
/*! Defines a mouse wheel binding.
Same as calling setWheelBinding(Qt::Key, Qt::KeyboardModifiers, MouseHandler, MouseAction, bool),
with a key value of Qt::Key(0) (i.e. no regular key needs to be pressed to activate this action). */
void QGLViewer::setWheelBinding(Qt::KeyboardModifiers modifiers, MouseHandler handler, MouseAction action, bool withConstraint) {
setWheelBinding(Qt::Key(0), modifiers, handler, action, withConstraint);
}
/*! Associates a MouseAction and a MouseHandler to a mouse wheel event.
This method is very similar to setMouseBinding(), but specific to the wheel.
In the current implementation only QGLViewer::ZOOM can be associated with QGLViewer::FRAME, while
QGLViewer::CAMERA can receive QGLViewer::ZOOM and QGLViewer::MOVE_FORWARD.
The difference between QGLViewer::ZOOM and QGLViewer::MOVE_FORWARD is that QGLViewer::ZOOM speed
depends on the distance to the object, while QGLViewer::MOVE_FORWARD moves at a constant speed
defined by qglviewer::Camera::flySpeed(). */
void QGLViewer::setWheelBinding(Qt::Key key, Qt::KeyboardModifiers modifiers, MouseHandler handler, MouseAction action, bool withConstraint)
{
//#CONNECTION# ManipulatedFrame::wheelEvent and ManipulatedCameraFrame::wheelEvent switches
if ((action != ZOOM) && (action != MOVE_FORWARD) && (action != MOVE_BACKWARD) && (action != NO_MOUSE_ACTION)) {
qWarning("Cannot bind %s to wheel", mouseActionString(action).toLatin1().constData());
return;
}
if ((handler == FRAME) && (action != ZOOM) && (action != NO_MOUSE_ACTION)) {
qWarning("Cannot bind %s to FRAME wheel", mouseActionString(action).toLatin1().constData());
return;
}
MouseActionPrivate map;
map.handler = handler;
map.action = action;
map.withConstraint = withConstraint;
WheelBindingPrivate wbp(modifiers, key);
if (action == NO_MOUSE_ACTION)
wheelBinding_.remove(wbp);
else
wheelBinding_[wbp] = map;
}
/*! Clears all the default mouse bindings.
After this call, you will have to use setMouseBinding() and setWheelBinding() to restore the mouse bindings you are interested in.
*/
void QGLViewer::clearMouseBindings() {
mouseBinding_.clear();
clickBinding_.clear();
wheelBinding_.clear();
}
/*! Clears all the default keyboard shortcuts.
After this call, you will have to use setShortcut() to define your own keyboard shortcuts.
*/
void QGLViewer::clearShortcuts() {
keyboardBinding_.clear();
pathIndex_.clear();
}
/*! This method is deprecated since version 2.5.0
Use mouseAction(Qt::Key, Qt::KeyboardModifiers, Qt::MouseButtons) instead.
*/
QGLViewer::MouseAction QGLViewer::mouseAction(unsigned int state) const {
qWarning("mouseAction(int state,...) is deprecated. Use the modifier/button equivalent");
return mouseAction(Qt::Key(0), keyboardModifiersFromState(state), mouseButtonFromState(state));
}
/*! Returns the MouseAction the will be triggered when the mouse \p button is pressed,
while the keyboard \p modifiers and \p key are pressed.
Returns QGLViewer::NO_MOUSE_ACTION if no action is associated with this combination. Use 0 for \p key
to indicate that no regular key needs to be pressed.
For instance, to know which motion corresponds to Alt+LeftButton, do:
\code
QGLViewer::MouseAction ma = mouseAction(0, Qt::AltModifier, Qt::LeftButton);
if (ma != QGLViewer::NO_MOUSE_ACTION) ...
\endcode
Use mouseHandler() to know which object (QGLViewer::CAMERA or QGLViewer::FRAME) will execute this
action. */
QGLViewer::MouseAction QGLViewer::mouseAction(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button) const
{
MouseBindingPrivate mbp(modifiers, button, key);
if (mouseBinding_.contains(mbp))
return mouseBinding_[mbp].action;
else
return NO_MOUSE_ACTION;
}
/*! This method is deprecated since version 2.5.0
Use mouseHanler(Qt::Key, Qt::KeyboardModifiers, Qt::MouseButtons) instead.
*/
int QGLViewer::mouseHandler(unsigned int state) const {
qWarning("mouseHandler(int state,...) is deprecated. Use the modifier/button equivalent");
return mouseHandler(Qt::Key(0), keyboardModifiersFromState(state), mouseButtonFromState(state));
}
/*! Returns the MouseHandler which will be activated when the mouse \p button is pressed, while the \p modifiers and \p key are pressed.
If no action is associated with this combination, returns \c -1. Use 0 for \p key and Qt::NoModifier for \p modifiers
to represent the lack of a key press.
For instance, to know which handler receives the Alt+LeftButton, do:
\code
int mh = mouseHandler(0, Qt::AltModifier, Qt::LeftButton);
if (mh == QGLViewer::CAMERA) ...
\endcode
Use mouseAction() to know which action (see the MouseAction enum) will be performed on this handler. */
int QGLViewer::mouseHandler(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button) const
{
MouseBindingPrivate mbp(modifiers, button, key);
if (mouseBinding_.contains(mbp))
return mouseBinding_[mbp].handler;
else
return -1;
}
#ifndef DOXYGEN
/*! This method is deprecated since version 2.5.0
Use mouseButtons() and keyboardModifiers() instead.
*/
int QGLViewer::mouseButtonState(MouseHandler handler, MouseAction action, bool withConstraint) const {
qWarning("mouseButtonState() is deprecated. Use mouseButtons() and keyboardModifiers() instead");
for (QMap<MouseBindingPrivate, MouseActionPrivate>::ConstIterator it=mouseBinding_.begin(), end=mouseBinding_.end(); it != end; ++it)
if ( (it.value().handler == handler) && (it.value().action == action) && (it.value().withConstraint == withConstraint) )
return (int) it.key().modifiers | (int) it.key().button;
return Qt::NoButton;
}
#endif
/*! Returns the keyboard state that triggers \p action on \p handler \p withConstraint using the mouse wheel.
If such a binding exists, results are stored in the \p key and \p modifiers
parameters. If the MouseAction \p action is not bound, \p key is set to the illegal -1 value.
If several keyboard states trigger the MouseAction, one of them is returned.
See also setMouseBinding(), getClickActionBinding() and getMouseActionBinding(). */
void QGLViewer::getWheelActionBinding(MouseHandler handler, MouseAction action, bool withConstraint,
Qt::Key& key, Qt::KeyboardModifiers& modifiers) const
{
for (QMap<WheelBindingPrivate, MouseActionPrivate>::ConstIterator it=wheelBinding_.begin(), end=wheelBinding_.end(); it != end; ++it)
if ( (it.value().handler == handler) && (it.value().action == action) && (it.value().withConstraint == withConstraint) ) {
key = it.key().key;
modifiers = it.key().modifiers;
return;
}
key = Qt::Key(-1);
modifiers = Qt::NoModifier;
}
/*! Returns the mouse and keyboard state that triggers \p action on \p handler \p withConstraint.
If such a binding exists, results are stored in the \p key, \p modifiers and \p button
parameters. If the MouseAction \p action is not bound, \p button is set to \c Qt::NoButton.
If several mouse and keyboard states trigger the MouseAction, one of them is returned.
See also setMouseBinding(), getClickActionBinding() and getWheelActionBinding(). */
void QGLViewer::getMouseActionBinding(MouseHandler handler, MouseAction action, bool withConstraint,
Qt::Key& key, Qt::KeyboardModifiers& modifiers, Qt::MouseButton& button) const
{
for (QMap<MouseBindingPrivate, MouseActionPrivate>::ConstIterator it=mouseBinding_.begin(), end=mouseBinding_.end(); it != end; ++it) {
if ( (it.value().handler == handler) && (it.value().action == action) && (it.value().withConstraint == withConstraint) ) {
key = it.key().key;
modifiers = it.key().modifiers;
button = it.key().button;
return;
}
}
key = Qt::Key(0);
modifiers = Qt::NoModifier;
button = Qt::NoButton;
}
/*! Returns the MouseAction (if any) that is performed when using the wheel, when the \p modifiers and \p key keyboard keys are pressed.
Returns NO_MOUSE_ACTION if no such binding has been defined using setWheelBinding().
Same as mouseAction(), but for the wheel action. See also wheelHandler().
*/
QGLViewer::MouseAction QGLViewer::wheelAction(Qt::Key key, Qt::KeyboardModifiers modifiers) const
{
WheelBindingPrivate wbp(modifiers, key);
if (wheelBinding_.contains(wbp))
return wheelBinding_[wbp].action;
else
return NO_MOUSE_ACTION;
}
/*! Returns the MouseHandler (if any) that receives wheel events when the \p modifiers and \p key keyboard keys are pressed.
Returns -1 if no no such binding has been defined using setWheelBinding(). See also wheelAction().
*/
int QGLViewer::wheelHandler(Qt::Key key, Qt::KeyboardModifiers modifiers) const
{
WheelBindingPrivate wbp(modifiers, key);
if (wheelBinding_.contains(wbp))
return wheelBinding_[wbp].handler;
else
return -1;
}
/*! Same as mouseAction(), but for the ClickAction set using setMouseBinding().
Returns NO_CLICK_ACTION if no click action is associated with this keyboard and mouse buttons combination. */
QGLViewer::ClickAction QGLViewer::clickAction(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button,
bool doubleClick, Qt::MouseButtons buttonsBefore) const {
ClickBindingPrivate cbp(modifiers, button, doubleClick, buttonsBefore, key);
if (clickBinding_.contains(cbp))
return clickBinding_[cbp];
else
return NO_CLICK_ACTION;
}
#ifndef DOXYGEN
/*! This method is deprecated since version 2.5.0
Use wheelAction(Qt::Key key, Qt::KeyboardModifiers modifiers) instead. */
QGLViewer::MouseAction QGLViewer::wheelAction(Qt::KeyboardModifiers modifiers) const {
qWarning("wheelAction() is deprecated. Use the new wheelAction() method with a key parameter instead");
return wheelAction(Qt::Key(0), modifiers);
}
/*! This method is deprecated since version 2.5.0
Use wheelHandler(Qt::Key key, Qt::KeyboardModifiers modifiers) instead. */
int QGLViewer::wheelHandler(Qt::KeyboardModifiers modifiers) const {
qWarning("wheelHandler() is deprecated. Use the new wheelHandler() method with a key parameter instead");
return wheelHandler(Qt::Key(0), modifiers);
}
/*! This method is deprecated since version 2.5.0
Use wheelAction() and wheelHandler() instead. */
unsigned int QGLViewer::wheelButtonState(MouseHandler handler, MouseAction action, bool withConstraint) const
{
qWarning("wheelButtonState() is deprecated. Use the wheelAction() and wheelHandler() instead");
for (QMap<WheelBindingPrivate, MouseActionPrivate>::ConstIterator it=wheelBinding_.begin(), end=wheelBinding_.end(); it!=end; ++it)
if ( (it.value().handler == handler) && (it.value().action == action) && (it.value().withConstraint == withConstraint) )
return it.key().key + it.key().modifiers;
return -1;
}
/*! This method is deprecated since version 2.5.0
Use clickAction(Qt::KeyboardModifiers, Qt::MouseButtons, bool, Qt::MouseButtons) instead.
*/
QGLViewer::ClickAction QGLViewer::clickAction(unsigned int state, bool doubleClick, Qt::MouseButtons buttonsBefore) const {
qWarning("clickAction(int state,...) is deprecated. Use the modifier/button equivalent");
return clickAction(Qt::Key(0),
keyboardModifiersFromState(state),
mouseButtonFromState(state),
doubleClick,
buttonsBefore);
}
/*! This method is deprecated since version 2.5.0
Use getClickActionState(ClickAction, Qt::Key, Qt::KeyboardModifiers, Qt::MouseButton, bool, Qt::MouseButtons) instead.
*/
void QGLViewer::getClickButtonState(ClickAction action, unsigned int& state, bool& doubleClick, Qt::MouseButtons& buttonsBefore) const {
qWarning("getClickButtonState(int state,...) is deprecated. Use the modifier/button equivalent");
Qt::KeyboardModifiers modifiers;
Qt::MouseButton button;
Qt::Key key;
getClickActionBinding(action, key, modifiers, button, doubleClick, buttonsBefore);
state = (unsigned int) modifiers | (unsigned int) button | (unsigned int) key;
}
#endif
/*! Returns the mouse and keyboard state that triggers \p action.
If such a binding exists, results are stored in the \p key, \p modifiers, \p button, \p doubleClick and \p buttonsBefore
parameters. If the ClickAction \p action is not bound, \p button is set to \c Qt::NoButton.
If several mouse buttons trigger in the ClickAction, one of them is returned.
See also setMouseBinding(), getMouseActionBinding() and getWheelActionBinding(). */
void QGLViewer::getClickActionBinding(ClickAction action, Qt::Key& key, Qt::KeyboardModifiers& modifiers, Qt::MouseButton &button, bool& doubleClick, Qt::MouseButtons& buttonsBefore) const
{
for (QMap<ClickBindingPrivate, ClickAction>::ConstIterator it=clickBinding_.begin(), end=clickBinding_.end(); it != end; ++it)
if (it.value() == action) {
modifiers = it.key().modifiers;
button = it.key().button;
doubleClick = it.key().doubleClick;
buttonsBefore = it.key().buttonsBefore;
key = it.key().key;
return;
}
modifiers = Qt::NoModifier;
button = Qt::NoButton;
doubleClick = false;
buttonsBefore = Qt::NoButton;
key = Qt::Key(0);
}
/*! This function should be used in conjunction with toggleCameraMode(). It returns \c true when at
least one mouse button is binded to the \c ROTATE mouseAction. This is crude way of determining
which "mode" the camera is in. */
bool QGLViewer::cameraIsInRotateMode() const
{
//#CONNECTION# used in toggleCameraMode() and keyboardString()
Qt::Key key;
Qt::KeyboardModifiers modifiers;
Qt::MouseButton button;
getMouseActionBinding(CAMERA, ROTATE, true /*constraint*/, key, modifiers, button);
return button != Qt::NoButton;
}
/*! Swaps between two predefined camera mouse bindings.
The first mode makes the camera observe the scene while revolving around the
qglviewer::Camera::pivotPoint(). The second mode is designed for walkthrough applications
and simulates a flying camera.
Practically, the three mouse buttons are respectively binded to:
\arg In rotate mode: QGLViewer::ROTATE, QGLViewer::ZOOM, QGLViewer::TRANSLATE.
\arg In fly mode: QGLViewer::MOVE_FORWARD, QGLViewer::LOOK_AROUND, QGLViewer::MOVE_BACKWARD.
The current mode is determined by checking if a mouse button is binded to QGLViewer::ROTATE for
the QGLViewer::CAMERA. The state key that was previously used to move the camera is preserved. */
void QGLViewer::toggleCameraMode()
{
Qt::Key key;
Qt::KeyboardModifiers modifiers;
Qt::MouseButton button;
getMouseActionBinding(CAMERA, ROTATE, true /*constraint*/, key, modifiers, button);
bool rotateMode = button != Qt::NoButton;
if (!rotateMode) {
getMouseActionBinding(CAMERA, MOVE_FORWARD, true /*constraint*/, key, modifiers, button);
}
//#CONNECTION# setDefaultMouseBindings()
if (rotateMode)
{
camera()->frame()->updateSceneUpVector();
camera()->frame()->stopSpinning();
setMouseBinding(modifiers, Qt::LeftButton, CAMERA, MOVE_FORWARD);
setMouseBinding(modifiers, Qt::MidButton, CAMERA, LOOK_AROUND);
setMouseBinding(modifiers, Qt::RightButton, CAMERA, MOVE_BACKWARD);
setMouseBinding(Qt::Key_R, modifiers, Qt::LeftButton, CAMERA, ROLL);
setMouseBinding(Qt::NoModifier, Qt::LeftButton, NO_CLICK_ACTION, true);
setMouseBinding(Qt::NoModifier, Qt::MidButton, NO_CLICK_ACTION, true);
setMouseBinding(Qt::NoModifier, Qt::RightButton, NO_CLICK_ACTION, true);
setWheelBinding(modifiers, CAMERA, MOVE_FORWARD);
}
else
{
// Should stop flyTimer. But unlikely and not easy.
setMouseBinding(modifiers, Qt::LeftButton, CAMERA, ROTATE);
setMouseBinding(modifiers, Qt::MidButton, CAMERA, ZOOM);
setMouseBinding(modifiers, Qt::RightButton, CAMERA, TRANSLATE);
setMouseBinding(Qt::Key_R, modifiers, Qt::LeftButton, CAMERA, SCREEN_ROTATE);
setMouseBinding(Qt::NoModifier, Qt::LeftButton, ALIGN_CAMERA, true);
setMouseBinding(Qt::NoModifier, Qt::MidButton, SHOW_ENTIRE_SCENE, true);
setMouseBinding(Qt::NoModifier, Qt::RightButton, CENTER_SCENE, true);
setWheelBinding(modifiers, CAMERA, ZOOM);
}
}
////////////////////////////////////////////////////////////////////////////////
// M a n i p u l a t e d f r a m e s //
////////////////////////////////////////////////////////////////////////////////
/*! Sets the viewer's manipulatedFrame().
Several objects can be manipulated simultaneously, as is done the <a
href="../examples/multiSelect.html">multiSelect example</a>.
Defining the \e own viewer's camera()->frame() as the manipulatedFrame() is possible and will result
in a classical camera manipulation. See the <a href="../examples/luxo.html">luxo example</a> for an
illustration.
Note that a qglviewer::ManipulatedCameraFrame can be set as the manipulatedFrame(): it is possible
to manipulate the camera of a first viewer in a second viewer. */
void QGLViewer::setManipulatedFrame(ManipulatedFrame* frame)
{
if (manipulatedFrame())
{
manipulatedFrame()->stopSpinning();
if (manipulatedFrame() != camera()->frame())
{
disconnect(manipulatedFrame(), SIGNAL(manipulated()), this, SLOT(update()));
disconnect(manipulatedFrame(), SIGNAL(spun()), this, SLOT(update()));
}
}
manipulatedFrame_ = frame;
manipulatedFrameIsACamera_ = ((manipulatedFrame() != camera()->frame()) &&
(dynamic_cast<ManipulatedCameraFrame*>(manipulatedFrame()) != NULL));
if (manipulatedFrame())
{
// Prevent multiple connections, that would result in useless display updates
if (manipulatedFrame() != camera()->frame())
{
connect(manipulatedFrame(), SIGNAL(manipulated()), SLOT(update()));
connect(manipulatedFrame(), SIGNAL(spun()), SLOT(update()));
}
}
}
#ifndef DOXYGEN
////////////////////////////////////////////////////////////////////////////////
// V i s u a l H i n t s //
////////////////////////////////////////////////////////////////////////////////
/*! Draws viewer related visual hints.
Displays the new qglviewer::Camera::pivotPoint() when it is changed. See the <a
href="../mouse.html">mouse page</a> for details. Also draws a line between
qglviewer::Camera::pivotPoint() and mouse cursor when the camera is rotated around the
camera Z axis.
See also setVisualHintsMask() and resetVisualHints(). The hint color is foregroundColor().
\note These methods may become more interesting one day. The current design is too limited and
should be improved when other visual hints must be drawn.
Limitation : One needs to have access to visualHint_ to overload this method.
Removed from the documentation for this reason. */
void QGLViewer::drawVisualHints()
{
// Pivot point cross
if (visualHint_ & 1)
{
const qreal size = 15.0;
Vec proj = camera()->projectedCoordinatesOf(camera()->pivotPoint());
startScreenCoordinatesSystem();
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glLineWidth(3.0);
glBegin(GL_LINES);
glVertex2d(proj.x - size, proj.y);
glVertex2d(proj.x + size, proj.y);
glVertex2d(proj.x, proj.y - size);
glVertex2d(proj.x, proj.y + size);
glEnd();
glEnable(GL_DEPTH_TEST);
stopScreenCoordinatesSystem();
}
// if (visualHint_ & 2)
// drawText(80, 10, "Play");
// Screen rotate line
ManipulatedFrame* mf = NULL;
Vec pnt;
if (camera()->frame()->action_ == SCREEN_ROTATE)
{
mf = camera()->frame();
pnt = camera()->pivotPoint();
}
if (manipulatedFrame() && (manipulatedFrame()->action_ == SCREEN_ROTATE))
{
mf = manipulatedFrame();
// Maybe useful if the mf is a manipCameraFrame...
// pnt = manipulatedFrame()->pivotPoint();
pnt = manipulatedFrame()->position();
}
if (mf)
{
pnt = camera()->projectedCoordinatesOf(pnt);
startScreenCoordinatesSystem();
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glLineWidth(3.0);
glBegin(GL_LINES);
glVertex2d(pnt.x, pnt.y);
glVertex2i(mf->prevPos_.x(), mf->prevPos_.y());
glEnd();
glEnable(GL_DEPTH_TEST);
stopScreenCoordinatesSystem();
}
// Zoom on region: draw a rectangle
if (camera()->frame()->action_ == ZOOM_ON_REGION)
{
startScreenCoordinatesSystem();
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glLineWidth(2.0);
glBegin(GL_LINE_LOOP);
glVertex2i(camera()->frame()->pressPos_.x(), camera()->frame()->pressPos_.y());
glVertex2i(camera()->frame()->prevPos_.x(), camera()->frame()->pressPos_.y());
glVertex2i(camera()->frame()->prevPos_.x(), camera()->frame()->prevPos_.y());
glVertex2i(camera()->frame()->pressPos_.x(), camera()->frame()->prevPos_.y());
glEnd();
glEnable(GL_DEPTH_TEST);
stopScreenCoordinatesSystem();
}
}
/*! Defines the mask that will be used to drawVisualHints(). The only available mask is currently 1,
corresponding to the display of the qglviewer::Camera::pivotPoint(). resetVisualHints() is
automatically called after \p delay milliseconds (default is 2 seconds). */
void QGLViewer::setVisualHintsMask(int mask, int delay)
{
visualHint_ = visualHint_ | mask;
QTimer::singleShot(delay, this, SLOT(resetVisualHints()));
}
/*! Reset the mask used by drawVisualHints(). Called by setVisualHintsMask() after 2 seconds to reset the display. */
void QGLViewer::resetVisualHints()
{
visualHint_ = 0;
}
#endif
////////////////////////////////////////////////////////////////////////////////
// A x i s a n d G r i d d i s p l a y l i s t s //
////////////////////////////////////////////////////////////////////////////////
/*! Draws a 3D arrow along the positive Z axis.
\p length, \p radius and \p nbSubdivisions define its geometry. If \p radius is negative
(default), it is set to 0.05 * \p length.
Use drawArrow(const Vec& from, const Vec& to, qreal radius, int nbSubdivisions) or change the \c
ModelView matrix to place the arrow in 3D.
Uses current color and does not modify the OpenGL state. */
void QGLViewer::drawArrow(qreal length, qreal radius, int nbSubdivisions)
{
static GLUquadric* quadric = gluNewQuadric();
if (radius < 0.0)
radius = 0.05 * length;
const qreal head = 2.5*(radius / length) + 0.1;
const qreal coneRadiusCoef = 4.0 - 5.0 * head;
gluCylinder(quadric, radius, radius, length * (1.0 - head/coneRadiusCoef), nbSubdivisions, 1);
glTranslated(0.0, 0.0, length * (1.0 - head));
gluCylinder(quadric, coneRadiusCoef * radius, 0.0, head * length, nbSubdivisions, 1);
glTranslated(0.0, 0.0, -length * (1.0 - head));
}
/*! Draws a 3D arrow between the 3D point \p from and the 3D point \p to, both defined in the
current ModelView coordinates system.
See drawArrow(qreal length, qreal radius, int nbSubdivisions) for details. */
void QGLViewer::drawArrow(const Vec& from, const Vec& to, qreal radius, int nbSubdivisions)
{
glPushMatrix();
glTranslated(from[0], from[1], from[2]);
const Vec dir = to-from;
glMultMatrixd(Quaternion(Vec(0,0,1), dir).matrix());
QGLViewer::drawArrow(dir.norm(), radius, nbSubdivisions);
glPopMatrix();
}
/*! Draws an XYZ axis, with a given size (default is 1.0).
The axis position and orientation matches the current modelView matrix state: three arrows (red,
green and blue) of length \p length are drawn along the positive X, Y and Z directions.
Use the following code to display the current position and orientation of a qglviewer::Frame:
\code
glPushMatrix();
glMultMatrixd(frame.matrix());
QGLViewer::drawAxis(sceneRadius() / 5.0); // Or any scale
glPopMatrix();
\endcode
The current color and line width are used to draw the X, Y and Z characters at the extremities of
the three arrows. The OpenGL state is not modified by this method.
axisIsDrawn() uses this method to draw a representation of the world coordinate system. See also
QGLViewer::drawArrow() and QGLViewer::drawGrid(). */
void QGLViewer::drawAxis(qreal length)
{
const qreal charWidth = length / 40.0;
const qreal charHeight = length / 30.0;
const qreal charShift = 1.04 * length;
GLboolean lighting, colorMaterial;
glGetBooleanv(GL_LIGHTING, &lighting);
glGetBooleanv(GL_COLOR_MATERIAL, &colorMaterial);
glDisable(GL_LIGHTING);
glBegin(GL_LINES);
// The X
glVertex3d(charShift, charWidth, -charHeight);
glVertex3d(charShift, -charWidth, charHeight);
glVertex3d(charShift, -charWidth, -charHeight);
glVertex3d(charShift, charWidth, charHeight);
// The Y
glVertex3d( charWidth, charShift, charHeight);
glVertex3d(0.0, charShift, 0.0);
glVertex3d(-charWidth, charShift, charHeight);
glVertex3d(0.0, charShift, 0.0);
glVertex3d(0.0, charShift, 0.0);
glVertex3d(0.0, charShift, -charHeight);
// The Z
glVertex3d(-charWidth, charHeight, charShift);
glVertex3d( charWidth, charHeight, charShift);
glVertex3d( charWidth, charHeight, charShift);
glVertex3d(-charWidth, -charHeight, charShift);
glVertex3d(-charWidth, -charHeight, charShift);
glVertex3d( charWidth, -charHeight, charShift);
glEnd();
glEnable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
float color[4];
color[0] = 0.7f; color[1] = 0.7f; color[2] = 1.0f; color[3] = 1.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
QGLViewer::drawArrow(length, 0.01*length);
color[0] = 1.0f; color[1] = 0.7f; color[2] = 0.7f; color[3] = 1.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glPushMatrix();
glRotatef(90.0f, 0.0f, 1.0f, 0.0f);
QGLViewer::drawArrow(length, 0.01*length);
glPopMatrix();
color[0] = 0.7f; color[1] = 1.0f; color[2] = 0.7f; color[3] = 1.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glPushMatrix();
glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);
QGLViewer::drawArrow(length, 0.01*length);
glPopMatrix();
if (colorMaterial)
glEnable(GL_COLOR_MATERIAL);
if (!lighting)
glDisable(GL_LIGHTING);
}
/*! Draws a grid in the XY plane, centered on (0,0,0) (defined in the current coordinate system).
\p size (OpenGL units) and \p nbSubdivisions define its geometry. Set the \c GL_MODELVIEW matrix to
place and orientate the grid in 3D space (see the drawAxis() documentation).
The OpenGL state is not modified by this method. */
void QGLViewer::drawGrid(qreal size, int nbSubdivisions)
{
GLboolean lighting;
glGetBooleanv(GL_LIGHTING, &lighting);
glDisable(GL_LIGHTING);
glBegin(GL_LINES);
for (int i=0; i<=nbSubdivisions; ++i)
{
const qreal pos = size*(2.0*i/nbSubdivisions-1.0);
glVertex2d(pos, -size);
glVertex2d(pos, +size);
glVertex2d(-size, pos);
glVertex2d( size, pos);
}
glEnd();
if (lighting)
glEnable(GL_LIGHTING);
}
////////////////////////////////////////////////////////////////////////////////
// S t a t i c m e t h o d s : Q G L V i e w e r P o o l //
////////////////////////////////////////////////////////////////////////////////
/*! saveStateToFile() is called on all the QGLViewers using the QGLViewerPool(). */
void QGLViewer::saveStateToFileForAllViewers()
{
Q_FOREACH (QGLViewer* viewer, QGLViewer::QGLViewerPool())
{
if (viewer)
viewer->saveStateToFile();
}
}
//////////////////////////////////////////////////////////////////////////
// S a v e s t a t e b e t w e e n s e s s i o n s //
//////////////////////////////////////////////////////////////////////////
/*! Returns the state file name. Default value is \c .qglviewer.xml.
This is the name of the XML file where saveStateToFile() saves the viewer state (camera state,
widget geometry, display flags... see domElement()) on exit. Use restoreStateFromFile() to restore
this state later (usually in your init() method).
Setting this value to \c QString::null will disable the automatic state file saving that normally
occurs on exit.
If more than one viewer are created by the application, this function will return a numbered file
name (as in ".qglviewer1.xml", ".qglviewer2.xml"... using QGLViewer::QGLViewerIndex()) for extra
viewers. Each viewer will then read back its own information in restoreStateFromFile(), provided
that the viewers are created in the same order, which is usually the case. */
QString QGLViewer::stateFileName() const
{
QString name = stateFileName_;
if (!name.isEmpty() && QGLViewer::QGLViewerIndex(this) > 0)
{
QFileInfo fi(name);
if (fi.suffix().isEmpty())
name += QString::number(QGLViewer::QGLViewerIndex(this));
else
name = fi.absolutePath() + '/' + fi.completeBaseName() + QString::number(QGLViewer::QGLViewerIndex(this)) + "." + fi.suffix();
}
return name;
}
/*! Saves in stateFileName() an XML representation of the QGLViewer state, obtained from
domElement().
Use restoreStateFromFile() to restore this viewer state.
This method is automatically called when a viewer is closed (using Escape or using the window's
upper right \c x close button). setStateFileName() to \c QString::null to prevent this. */
void QGLViewer::saveStateToFile()
{
QString name = stateFileName();
if (name.isEmpty())
return;
QFileInfo fileInfo(name);
if (fileInfo.isDir())
{
QMessageBox::warning(this, tr("Save to file error", "Message box window title"), tr("State file name (%1) references a directory instead of a file.").arg(name));
return;
}
const QString dirName = fileInfo.absolutePath();
if (!QFileInfo(dirName).exists())
{
QDir dir;
if (!(dir.mkdir(dirName)))
{
QMessageBox::warning(this, tr("Save to file error", "Message box window title"), tr("Unable to create directory %1").arg(dirName));
return;
}
}
// Write the DOM tree to file
QFile f(name);
if (f.open(QIODevice::WriteOnly))
{
QTextStream out(&f);
QDomDocument doc("QGLVIEWER");
doc.appendChild(domElement("QGLViewer", doc));
doc.save(out, 2);
f.flush();
f.close();
}
else
QMessageBox::warning(this, tr("Save to file error", "Message box window title"), tr("Unable to save to file %1").arg(name) + ":\n" + f.errorString());
}
/*! Restores the QGLViewer state from the stateFileName() file using initFromDOMElement().
States are saved using saveStateToFile(), which is automatically called on viewer exit.
Returns \c true when the restoration is successful. Possible problems are an non existing or
unreadable stateFileName() file, an empty stateFileName() or an XML syntax error.
A manipulatedFrame() should be defined \e before calling this method, so that its state can be
restored. Initialization code put \e after this function will override saved values:
\code
void Viewer::init()
{
// Default initialization goes here (including the declaration of a possible manipulatedFrame).
if (!restoreStateFromFile())
showEntireScene(); // Previous state cannot be restored: fit camera to scene.
// Specific initialization that overrides file savings goes here.
}
\endcode */
bool QGLViewer::restoreStateFromFile()
{
QString name = stateFileName();
if (name.isEmpty())
return false;
QFileInfo fileInfo(name);
if (!fileInfo.isFile())
// No warning since it would be displayed at first start.
return false;
if (!fileInfo.isReadable())
{
QMessageBox::warning(this, tr("Problem in state restoration", "Message box window title"), tr("File %1 is not readable.").arg(name));
return false;
}
// Read the DOM tree form file
QFile f(name);
if (f.open(QIODevice::ReadOnly))
{
QDomDocument doc;
doc.setContent(&f);
f.close();
QDomElement main = doc.documentElement();
initFromDOMElement(main);
}
else
{
QMessageBox::warning(this, tr("Open file error", "Message box window title"), tr("Unable to open file %1").arg(name) + ":\n" + f.errorString());
return false;
}
return true;
}
/*! Returns an XML \c QDomElement that represents the QGLViewer.
Used by saveStateToFile(). restoreStateFromFile() uses initFromDOMElement() to restore the
QGLViewer state from the resulting \c QDomElement.
\p name is the name of the QDomElement tag. \p doc is the \c QDomDocument factory used to create
QDomElement.
The created QDomElement contains state values (axisIsDrawn(), FPSIsDisplayed(), isFullScreen()...),
viewer geometry, as well as camera() (see qglviewer::Camera::domElement()) and manipulatedFrame()
(if defined, see qglviewer::ManipulatedFrame::domElement()) states.
Overload this method to add your own attributes to the state file:
\code
QDomElement Viewer::domElement(const QString& name, QDomDocument& document) const
{
// Creates a custom node for a light
QDomElement de = document.createElement("Light");
de.setAttribute("state", (lightIsOn()?"on":"off"));
// Note the include of the ManipulatedFrame domElement method.
de.appendChild(lightManipulatedFrame()->domElement("LightFrame", document));
// Get default state domElement and append custom node
QDomElement res = QGLViewer::domElement(name, document);
res.appendChild(de);
return res;
}
\endcode
See initFromDOMElement() for the associated restoration code.
\attention For the manipulatedFrame(), qglviewer::Frame::constraint() and
qglviewer::Frame::referenceFrame() are not saved. See qglviewer::Frame::domElement(). */
QDomElement QGLViewer::domElement(const QString& name, QDomDocument& document) const
{
QDomElement de = document.createElement(name);
de.setAttribute("version", QGLViewerVersionString());
QDomElement stateNode = document.createElement("State");
// hasMouseTracking() is not saved
stateNode.appendChild(DomUtils::QColorDomElement(foregroundColor(), "foregroundColor", document));
stateNode.appendChild(DomUtils::QColorDomElement(backgroundColor(), "backgroundColor", document));
DomUtils::setBoolAttribute(stateNode, "stereo", displaysInStereo());
// Revolve or fly camera mode is not saved
de.appendChild(stateNode);
QDomElement displayNode = document.createElement("Display");
DomUtils::setBoolAttribute(displayNode, "axisIsDrawn", axisIsDrawn());
DomUtils::setBoolAttribute(displayNode, "gridIsDrawn", gridIsDrawn());
DomUtils::setBoolAttribute(displayNode, "FPSIsDisplayed", FPSIsDisplayed());
DomUtils::setBoolAttribute(displayNode, "cameraIsEdited", cameraIsEdited());
// textIsEnabled() is not saved
de.appendChild(displayNode);
QDomElement geometryNode = document.createElement("Geometry");
DomUtils::setBoolAttribute(geometryNode, "fullScreen", isFullScreen());
if (isFullScreen())
{
geometryNode.setAttribute("prevPosX", QString::number(prevPos_.x()));
geometryNode.setAttribute("prevPosY", QString::number(prevPos_.y()));
}
else
{
QWidget* tlw = topLevelWidget();
geometryNode.setAttribute("width", QString::number(tlw->width()));
geometryNode.setAttribute("height", QString::number(tlw->height()));
geometryNode.setAttribute("posX", QString::number(tlw->pos().x()));
geometryNode.setAttribute("posY", QString::number(tlw->pos().y()));
}
de.appendChild(geometryNode);
// Restore original Camera zClippingCoefficient before saving.
if (cameraIsEdited())
camera()->setZClippingCoefficient(previousCameraZClippingCoefficient_);
de.appendChild(camera()->domElement("Camera", document));
if (cameraIsEdited())
// #CONNECTION# 5.0 from setCameraIsEdited()
camera()->setZClippingCoefficient(5.0);
if (manipulatedFrame())
de.appendChild(manipulatedFrame()->domElement("ManipulatedFrame", document));
return de;
}
/*! Restores the QGLViewer state from a \c QDomElement created by domElement().
Used by restoreStateFromFile() to restore the QGLViewer state from a file.
Overload this method to retrieve custom attributes from the QGLViewer state file. This code
corresponds to the one given in the domElement() documentation:
\code
void Viewer::initFromDOMElement(const QDomElement& element)
{
// Restore standard state
QGLViewer::initFromDOMElement(element);
QDomElement child=element.firstChild().toElement();
while (!child.isNull())
{
if (child.tagName() == "Light")
{
if (child.hasAttribute("state"))
setLightOn(child.attribute("state").lower() == "on");
// Assumes there is only one child. Otherwise you need to parse child's children recursively.
QDomElement lf = child.firstChild().toElement();
if (!lf.isNull() && lf.tagName() == "LightFrame")
lightManipulatedFrame()->initFromDomElement(lf);
}
child = child.nextSibling().toElement();
}
}
\endcode
See also qglviewer::Camera::initFromDOMElement(), qglviewer::ManipulatedFrame::initFromDOMElement().
\note The manipulatedFrame() \e pointer is not modified by this method. If defined, its state is
simply set from the \p element values. */
void QGLViewer::initFromDOMElement(const QDomElement& element)
{
const QString version = element.attribute("version");
// if (version != QGLViewerVersionString())
if (version[0] != '2')
// Patches for previous versions should go here when the state file syntax is modified.
qWarning("State file created using QGLViewer version %s may not be correctly read.", version.toLatin1().constData());
QDomElement child=element.firstChild().toElement();
bool tmpCameraIsEdited = cameraIsEdited();
while (!child.isNull())
{
if (child.tagName() == "State")
{
// #CONNECTION# default values from defaultConstructor()
// setMouseTracking(DomUtils::boolFromDom(child, "mouseTracking", false));
setStereoDisplay(DomUtils::boolFromDom(child, "stereo", false));
//if ((child.attribute("cameraMode", "revolve") == "fly") && (cameraIsInRevolveMode()))
// toggleCameraMode();
QDomElement ch=child.firstChild().toElement();
while (!ch.isNull())
{
if (ch.tagName() == "foregroundColor")
setForegroundColor(DomUtils::QColorFromDom(ch));
if (ch.tagName() == "backgroundColor")
setBackgroundColor(DomUtils::QColorFromDom(ch));
ch = ch.nextSibling().toElement();
}
}
if (child.tagName() == "Display")
{
// #CONNECTION# default values from defaultConstructor()
setAxisIsDrawn(DomUtils::boolFromDom(child, "axisIsDrawn", false));
setGridIsDrawn(DomUtils::boolFromDom(child, "gridIsDrawn", false));
setFPSIsDisplayed(DomUtils::boolFromDom(child, "FPSIsDisplayed", false));
// See comment below.
tmpCameraIsEdited = DomUtils::boolFromDom(child, "cameraIsEdited", false);
// setTextIsEnabled(DomUtils::boolFromDom(child, "textIsEnabled", true));
}
if (child.tagName() == "Geometry")
{
setFullScreen(DomUtils::boolFromDom(child, "fullScreen", false));
if (isFullScreen())
{
prevPos_.setX(DomUtils::intFromDom(child, "prevPosX", 0));
prevPos_.setY(DomUtils::intFromDom(child, "prevPosY", 0));
}
else
{
int width = DomUtils::intFromDom(child, "width", 600);
int height = DomUtils::intFromDom(child, "height", 400);
topLevelWidget()->resize(width, height);
camera()->setScreenWidthAndHeight(this->width(), this->height());
QPoint pos;
pos.setX(DomUtils::intFromDom(child, "posX", 0));
pos.setY(DomUtils::intFromDom(child, "posY", 0));
topLevelWidget()->move(pos);
}
}
if (child.tagName() == "Camera")
{
connectAllCameraKFIInterpolatedSignals(false);
camera()->initFromDOMElement(child);
connectAllCameraKFIInterpolatedSignals();
}
if ((child.tagName() == "ManipulatedFrame") && (manipulatedFrame()))
manipulatedFrame()->initFromDOMElement(child);
child = child.nextSibling().toElement();
}
// The Camera always stores its "real" zClippingCoef in domElement(). If it is edited,
// its "real" coef must be saved and the coef set to 5.0, as is done in setCameraIsEdited().
// BUT : Camera and Display are read in an arbitrary order. We must initialize Camera's
// "real" coef BEFORE calling setCameraIsEdited. Hence this temp cameraIsEdited and delayed call
cameraIsEdited_ = tmpCameraIsEdited;
if (cameraIsEdited_)
{
previousCameraZClippingCoefficient_ = camera()->zClippingCoefficient();
// #CONNECTION# 5.0 from setCameraIsEdited.
camera()->setZClippingCoefficient(5.0);
}
}
#ifndef DOXYGEN
/*! This method is deprecated since version 1.3.9-5. Use saveStateToFile() and setStateFileName()
instead. */
void QGLViewer::saveToFile(const QString& fileName)
{
if (!fileName.isEmpty())
setStateFileName(fileName);
qWarning("saveToFile() is deprecated, use saveStateToFile() instead.");
saveStateToFile();
}
/*! This function is deprecated since version 1.3.9-5. Use restoreStateFromFile() and
setStateFileName() instead. */
bool QGLViewer::restoreFromFile(const QString& fileName)
{
if (!fileName.isEmpty())
setStateFileName(fileName);
qWarning("restoreFromFile() is deprecated, use restoreStateFromFile() instead.");
return restoreStateFromFile();
}
#endif
/*! Makes a copy of the current buffer into a texture.
Creates a texture (when needed) and uses glCopyTexSubImage2D() to directly copy the buffer in it.
Use \p internalFormat and \p format to define the texture format and hence which and how components
of the buffer are copied into the texture. See the glTexImage2D() documentation for details.
When \p format is c GL_NONE (default), its value is set to \p internalFormat, which fits most
cases. Typical \p internalFormat (and \p format) values are \c GL_DEPTH_COMPONENT and \c GL_RGBA.
Use \c GL_LUMINANCE as the \p internalFormat and \c GL_RED, \c GL_GREEN or \c GL_BLUE as \p format
to capture a single color component as a luminance (grey scaled) value. Note that \c GL_STENCIL is
not supported as a format.
The texture has dimensions which are powers of two. It is as small as possible while always being
larger or equal to the current size of the widget. The buffer image hence does not entirely fill
the texture: it is stuck to the lower left corner (corresponding to the (0,0) texture coordinates).
Use bufferTextureMaxU() and bufferTextureMaxV() to get the upper right corner maximum u and v
texture coordinates. Use bufferTextureId() to retrieve the id of the created texture.
Here is how to display a grey-level image of the z-buffer:
\code
copyBufferToTexture(GL_DEPTH_COMPONENT);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glEnable(GL_TEXTURE_2D);
startScreenCoordinatesSystem(true);
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0); glVertex2i(0, 0);
glTexCoord2f(bufferTextureMaxU(), 0.0); glVertex2i(width(), 0);
glTexCoord2f(bufferTextureMaxU(), bufferTextureMaxV()); glVertex2i(width(), height());
glTexCoord2f(0.0, bufferTextureMaxV()); glVertex2i(0, height());
glEnd();
stopScreenCoordinatesSystem();
glDisable(GL_TEXTURE_2D);
\endcode
Use glReadBuffer() to select which buffer is copied into the texture. See also \c
glPixelTransfer(), \c glPixelZoom() and \c glCopyPixel() for pixel color transformations during
copy.
Call makeCurrent() before this method to make the OpenGL context active if needed.
\note The \c GL_DEPTH_COMPONENT format may not be supported by all hardware. It may sometimes be
emulated in software, resulting in poor performances.
\note The bufferTextureId() texture is binded at the end of this method. */
void QGLViewer::copyBufferToTexture(GLint internalFormat, GLenum format)
{
int h = 16;
int w = 16;
// Todo compare performance with qt code.
while (w < width())
w <<= 1;
while (h < height())
h <<= 1;
bool init = false;
if ((w != bufferTextureWidth_) || (h != bufferTextureHeight_))
{
bufferTextureWidth_ = w;
bufferTextureHeight_ = h;
bufferTextureMaxU_ = width() / qreal(bufferTextureWidth_);
bufferTextureMaxV_ = height() / qreal(bufferTextureHeight_);
init = true;
}
if (bufferTextureId() == 0)
{
glGenTextures(1, &bufferTextureId_);
glBindTexture(GL_TEXTURE_2D, bufferTextureId_);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
init = true;
}
else
glBindTexture(GL_TEXTURE_2D, bufferTextureId_);
if ((format != previousBufferTextureFormat_) ||
(internalFormat != previousBufferTextureInternalFormat_))
{
previousBufferTextureFormat_ = format;
previousBufferTextureInternalFormat_ = internalFormat;
init = true;
}
if (init)
{
if (format == GL_NONE)
format = GLenum(internalFormat);
glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, bufferTextureWidth_, bufferTextureHeight_, 0, format, GL_UNSIGNED_BYTE, NULL);
}
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width(), height());
}
/*! Returns the texture id of the texture created by copyBufferToTexture().
Use glBindTexture() to use this texture. Note that this is already done by copyBufferToTexture().
Returns \c 0 is copyBufferToTexture() was never called or if the texure was deleted using
glDeleteTextures() since then. */
GLuint QGLViewer::bufferTextureId() const
{
if (glIsTexture(bufferTextureId_))
return bufferTextureId_;
else
return 0;
}
| 142,290 | 35.977911 | 204 | cpp |
octomap | octomap-master/octovis/src/extern/QGLViewer/qglviewer.h | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#ifndef QGLVIEWER_QGLVIEWER_H
#define QGLVIEWER_QGLVIEWER_H
#include "camera.h"
#include <QMap>
#include <QClipboard>
#include <QTime>
class QTabWidget;
namespace qglviewer {
class MouseGrabber;
class ManipulatedFrame;
class ManipulatedCameraFrame;
}
/*! \brief A versatile 3D OpenGL viewer based on QGLWidget.
\class QGLViewer qglviewer.h QGLViewer/qglviewer.h
It features many classical viewer functionalities, such as a camera trackball, manipulated objects,
snapshot saving and much <a href="../features.html">more</a>. Its main goal is to ease the development
of new 3D applications.
New users should read the <a href="../introduction.html">introduction page</a> to get familiar with
important notions such as sceneRadius(), sceneCenter() and the world coordinate system. Try the
numerous simple <a href="../examples/index.html">examples</a> to discover the possibilities and
understand how it works.
<h3>Usage</h3>
To use a QGLViewer, derive you viewer class from the QGLViewer and overload its draw() virtual
method. See the <a href="../examples/simpleViewer.html">simpleViewer example</a> for an illustration.
An other option is to connect your drawing methods to the signals emitted by the QGLViewer (Qt's
callback mechanism). See the <a href="../examples/callback.html">callback example</a> for a
complete implementation.
\nosubgrouping */
class QGLVIEWER_EXPORT QGLViewer : public QGLWidget
{
Q_OBJECT
public:
// Complete implementation is provided so that the constructor is defined with QT3_SUPPORT when .h is included.
// (Would not be available otherwise since lib is compiled without QT3_SUPPORT).
#ifdef QT3_SUPPORT
explicit QGLViewer(QWidget* parent=NULL, const char* name=0, const QGLWidget* shareWidget=0, Qt::WindowFlags flags=0)
: QGLWidget(parent, name, shareWidget, flags)
{ defaultConstructor(); }
explicit QGLViewer(const QGLFormat& format, QWidget* parent=0, const char* name=0, const QGLWidget* shareWidget=0,Qt::WindowFlags flags=0)
: QGLWidget(format, parent, name, shareWidget, flags)
{ defaultConstructor(); }
QGLViewer(QGLContext* context, QWidget* parent, const char* name=0, const QGLWidget* shareWidget=0, Qt::WindowFlags flags=0)
: QGLWidget(context, parent, name, shareWidget, flags) {
defaultConstructor(); }
#else
explicit QGLViewer(QWidget* parent=0, const QGLWidget* shareWidget=0, Qt::WindowFlags flags=0);
explicit QGLViewer(QGLContext *context, QWidget* parent=0, const QGLWidget* shareWidget=0, Qt::WindowFlags flags=0);
explicit QGLViewer(const QGLFormat& format, QWidget* parent=0, const QGLWidget* shareWidget=0, Qt::WindowFlags flags=0);
#endif
virtual ~QGLViewer();
/*! @name Display of visual hints */
//@{
public:
/*! Returns \c true if the world axis is drawn by the viewer.
Set by setAxisIsDrawn() or toggleAxisIsDrawn(). Default value is \c false. */
bool axisIsDrawn() const { return axisIsDrawn_; }
/*! Returns \c true if a XY grid is drawn by the viewer.
Set by setGridIsDrawn() or toggleGridIsDrawn(). Default value is \c false. */
bool gridIsDrawn() const { return gridIsDrawn_; }
/*! Returns \c true if the viewer displays the current frame rate (Frames Per Second).
Use QApplication::setFont() to define the display font (see drawText()).
Set by setFPSIsDisplayed() or toggleFPSIsDisplayed(). Use currentFPS() to get the current FPS.
Default value is \c false. */
bool FPSIsDisplayed() const { return FPSIsDisplayed_; }
/*! Returns \c true if text display (see drawText()) is enabled.
Set by setTextIsEnabled() or toggleTextIsEnabled(). This feature conveniently removes all the
possibly displayed text, cleaning display. Default value is \c true. */
bool textIsEnabled() const { return textIsEnabled_; }
/*! Returns \c true if the camera() is being edited in the viewer.
Set by setCameraIsEdited() or toggleCameraIsEdited(). Default value is \p false.
The current implementation is limited: the defined camera() paths (see
qglviewer::Camera::keyFrameInterpolator()) are simply displayed using
qglviewer::Camera::drawAllPaths(). Actual camera and path edition will be implemented in the
future. */
bool cameraIsEdited() const { return cameraIsEdited_; }
public Q_SLOTS:
/*! Sets the state of axisIsDrawn(). Emits the axisIsDrawnChanged() signal. See also toggleAxisIsDrawn(). */
void setAxisIsDrawn(bool draw=true) { axisIsDrawn_ = draw; Q_EMIT axisIsDrawnChanged(draw); update(); }
/*! Sets the state of gridIsDrawn(). Emits the gridIsDrawnChanged() signal. See also toggleGridIsDrawn(). */
void setGridIsDrawn(bool draw=true) { gridIsDrawn_ = draw; Q_EMIT gridIsDrawnChanged(draw); update(); }
/*! Sets the state of FPSIsDisplayed(). Emits the FPSIsDisplayedChanged() signal. See also toggleFPSIsDisplayed(). */
void setFPSIsDisplayed(bool display=true) { FPSIsDisplayed_ = display; Q_EMIT FPSIsDisplayedChanged(display); update(); }
/*! Sets the state of textIsEnabled(). Emits the textIsEnabledChanged() signal. See also toggleTextIsEnabled(). */
void setTextIsEnabled(bool enable=true) { textIsEnabled_ = enable; Q_EMIT textIsEnabledChanged(enable); update(); }
void setCameraIsEdited(bool edit=true);
/*! Toggles the state of axisIsDrawn(). See also setAxisIsDrawn(). */
void toggleAxisIsDrawn() { setAxisIsDrawn(!axisIsDrawn()); }
/*! Toggles the state of gridIsDrawn(). See also setGridIsDrawn(). */
void toggleGridIsDrawn() { setGridIsDrawn(!gridIsDrawn()); }
/*! Toggles the state of FPSIsDisplayed(). See also setFPSIsDisplayed(). */
void toggleFPSIsDisplayed() { setFPSIsDisplayed(!FPSIsDisplayed()); }
/*! Toggles the state of textIsEnabled(). See also setTextIsEnabled(). */
void toggleTextIsEnabled() { setTextIsEnabled(!textIsEnabled()); }
/*! Toggles the state of cameraIsEdited(). See also setCameraIsEdited(). */
void toggleCameraIsEdited() { setCameraIsEdited(!cameraIsEdited()); }
//@}
/*! @name Viewer's colors */
//@{
public:
/*! Returns the background color of the viewer.
This method is provided for convenience since the background color is an OpenGL state variable
set with \c glClearColor(). However, this internal representation has the advantage that it is
saved (resp. restored) with saveStateToFile() (resp. restoreStateFromFile()).
Use setBackgroundColor() to define and activate a background color.
\attention Each QColor component is an integer ranging from 0 to 255. This differs from the qreal
values used by \c glClearColor() which are in the 0.0-1.0 range. Default value is (51, 51, 51)
(dark gray). You may have to change foregroundColor() accordingly.
\attention This method does not return the current OpenGL clear color as \c glGet() does. Instead,
it returns the QGLViewer internal variable. If you directly use \c glClearColor() or \c
qglClearColor() instead of setBackgroundColor(), the two results will differ. */
QColor backgroundColor() const { return backgroundColor_; }
/*! Returns the foreground color used by the viewer.
This color is used when FPSIsDisplayed(), gridIsDrawn(), to display the camera paths when the
cameraIsEdited().
\attention Each QColor component is an integer in the range 0-255. This differs from the qreal
values used by \c glColor3f() which are in the range 0-1. Default value is (180, 180, 180) (light
gray).
Use \c qglColor(foregroundColor()) to set the current OpenGL color to the foregroundColor().
See also backgroundColor(). */
QColor foregroundColor() const { return foregroundColor_; }
public Q_SLOTS:
/*! Sets the backgroundColor() of the viewer and calls \c qglClearColor(). See also
setForegroundColor(). */
void setBackgroundColor(const QColor& color) { backgroundColor_=color; qglClearColor(color); }
/*! Sets the foregroundColor() of the viewer, used to draw visual hints. See also setBackgroundColor(). */
void setForegroundColor(const QColor& color) { foregroundColor_ = color; }
//@}
/*! @name Scene dimensions */
//@{
public:
/*! Returns the scene radius.
The entire displayed scene should be included in a sphere of radius sceneRadius(), centered on
sceneCenter().
This approximate value is used by the camera() to set qglviewer::Camera::zNear() and
qglviewer::Camera::zFar(). It is also used to showEntireScene() or to scale the world axis
display..
Default value is 1.0. This method is equivalent to camera()->sceneRadius(). See
setSceneRadius(). */
qreal sceneRadius() const { return camera()->sceneRadius(); }
/*! Returns the scene center, defined in world coordinates.
See sceneRadius() for details.
Default value is (0,0,0). Simply a wrapper for camera()->sceneCenter(). Set using
setSceneCenter().
Do not mismatch this value (that only depends on the scene) with the qglviewer::Camera::pivotPoint(). */
qglviewer::Vec sceneCenter() const { return camera()->sceneCenter(); }
public Q_SLOTS:
/*! Sets the sceneRadius().
The camera() qglviewer::Camera::flySpeed() is set to 1% of this value by this method. Simple
wrapper around camera()->setSceneRadius(). */
virtual void setSceneRadius(qreal radius) { camera()->setSceneRadius(radius); }
/*! Sets the sceneCenter(), defined in world coordinates.
\attention The qglviewer::Camera::pivotPoint() is set to the sceneCenter() value by this
method. */
virtual void setSceneCenter(const qglviewer::Vec& center) { camera()->setSceneCenter(center); }
/*! Convenient way to call setSceneCenter() and setSceneRadius() from a (world axis aligned) bounding box of the scene.
This is equivalent to:
\code
setSceneCenter((min+max) / 2.0);
setSceneRadius((max-min).norm() / 2.0);
\endcode */
void setSceneBoundingBox(const qglviewer::Vec& min, const qglviewer::Vec& max) { camera()->setSceneBoundingBox(min,max); }
/*! Moves the camera so that the entire scene is visible.
Simple wrapper around qglviewer::Camera::showEntireScene(). */
void showEntireScene() { camera()->showEntireScene(); update(); }
//@}
/*! @name Associated objects */
//@{
public:
/*! Returns the associated qglviewer::Camera, never \c NULL. */
qglviewer::Camera* camera() const { return camera_; }
/*! Returns the viewer's qglviewer::ManipulatedFrame.
This qglviewer::ManipulatedFrame can be moved with the mouse when the associated mouse bindings
are used (default is when pressing the \c Control key with any mouse button). Use
setMouseBinding() to define new bindings.
See the <a href="../examples/manipulatedFrame.html">manipulatedFrame example</a> for a complete
implementation.
Default value is \c NULL, meaning that no qglviewer::ManipulatedFrame is set. */
qglviewer::ManipulatedFrame* manipulatedFrame() const { return manipulatedFrame_; }
public Q_SLOTS:
void setCamera(qglviewer::Camera* const camera);
void setManipulatedFrame(qglviewer::ManipulatedFrame* frame);
//@}
/*! @name Mouse grabbers */
//@{
public:
/*! Returns the current qglviewer::MouseGrabber, or \c NULL if no qglviewer::MouseGrabber
currently grabs mouse events.
When qglviewer::MouseGrabber::grabsMouse(), the different mouse events are sent to the
mouseGrabber() instead of their usual targets (camera() or manipulatedFrame()).
See the qglviewer::MouseGrabber documentation for details on MouseGrabber's mode of operation.
In order to use MouseGrabbers, you need to enable mouse tracking (so that mouseMoveEvent() is
called even when no mouse button is pressed). Add this line in init() or in your viewer
constructor:
\code
setMouseTracking(true);
\endcode
Note that mouse tracking is disabled by default. Use QWidget::hasMouseTracking() to
retrieve current state. */
qglviewer::MouseGrabber* mouseGrabber() const { return mouseGrabber_; }
void setMouseGrabberIsEnabled(const qglviewer::MouseGrabber* const mouseGrabber, bool enabled=true);
/*! Returns \c true if \p mouseGrabber is enabled.
Default value is \c true for all MouseGrabbers. When set to \c false using
setMouseGrabberIsEnabled(), the specified \p mouseGrabber will never become the mouseGrabber() of
this QGLViewer. This is useful when you use several viewers: some MouseGrabbers may only have a
meaning for some specific viewers and should not be selectable in others.
You can also use qglviewer::MouseGrabber::removeFromMouseGrabberPool() to completely disable a
MouseGrabber in all the QGLViewers. */
bool mouseGrabberIsEnabled(const qglviewer::MouseGrabber* const mouseGrabber) { return !disabledMouseGrabbers_.contains(reinterpret_cast<size_t>(mouseGrabber)); }
public Q_SLOTS:
void setMouseGrabber(qglviewer::MouseGrabber* mouseGrabber);
//@}
/*! @name State of the viewer */
//@{
public:
/*! Returns the aspect ratio of the viewer's widget (width() / height()). */
qreal aspectRatio() const { return width() / static_cast<qreal>(height()); }
/*! Returns the current averaged viewer frame rate.
This value is computed and averaged over 20 successive frames. It only changes every 20 draw()
(previously computed value is otherwise returned).
This method is useful for true real-time applications that may adapt their computational load
accordingly in order to maintain a given frequency.
This value is meaningful only when draw() is regularly called, either using a \c QTimer, when
animationIsStarted() or when the camera is manipulated with the mouse. */
qreal currentFPS() { return f_p_s_; }
/*! Returns \c true if the viewer is in fullScreen mode.
Default value is \c false. Set by setFullScreen() or toggleFullScreen().
Note that if the QGLViewer is embedded in an other QWidget, it returns \c true when the top level
widget is in full screen mode. */
bool isFullScreen() const { return fullScreen_; }
/*! Returns \c true if the viewer displays in stereo.
The QGLViewer object must be created with a stereo format to handle stereovision:
\code
QGLFormat format;
format.setStereoDisplay( TRUE );
QGLViewer viewer(format);
\endcode
The hardware needs to support stereo display. Try the <a
href="../examples/stereoViewer.html">stereoViewer example</a> to check.
Set by setStereoDisplay() or toggleStereoDisplay(). Default value is \c false.
Stereo is performed using the Parallel axis asymmetric frustum perspective projection method.
See Camera::loadProjectionMatrixStereo() and Camera::loadModelViewMatrixStereo().
The stereo parameters are defined by the camera(). See qglviewer::Camera::setIODistance(),
qglviewer::Camera::setPhysicalScreenWidth() and
qglviewer::Camera::setFocusDistance(). */
bool displaysInStereo() const { return stereo_; }
/*! Returns the recommended size for the QGLViewer. Default value is 600x400 pixels. */
virtual QSize sizeHint() const { return QSize(600, 400); }
public Q_SLOTS:
void setFullScreen(bool fullScreen=true);
void setStereoDisplay(bool stereo=true);
/*! Toggles the state of isFullScreen(). See also setFullScreen(). */
void toggleFullScreen() { setFullScreen(!isFullScreen()); }
/*! Toggles the state of displaysInStereo(). See setStereoDisplay(). */
void toggleStereoDisplay() { setStereoDisplay(!stereo_); }
void toggleCameraMode();
private:
bool cameraIsInRotateMode() const;
//@}
/*! @name Display methods */
//@{
public:
static void drawArrow(qreal length=1.0, qreal radius=-1.0, int nbSubdivisions=12);
static void drawArrow(const qglviewer::Vec& from, const qglviewer::Vec& to, qreal radius=-1.0, int nbSubdivisions=12);
static void drawAxis(qreal length=1.0);
static void drawGrid(qreal size=1.0, int nbSubdivisions=10);
virtual void startScreenCoordinatesSystem(bool upward=false) const;
virtual void stopScreenCoordinatesSystem() const;
void drawText(int x, int y, const QString& text, const QFont& fnt=QFont());
void displayMessage(const QString& message, int delay=2000);
// void draw3DText(const qglviewer::Vec& pos, const qglviewer::Vec& normal, const QString& string, GLfloat height=0.1);
protected:
virtual void drawLight(GLenum light, qreal scale = 1.0) const;
private:
void displayFPS();
/*! Vectorial rendering callback method. */
void drawVectorial() { paintGL(); }
#ifndef DOXYGEN
friend void drawVectorial(void* param);
#endif
//@}
#ifdef DOXYGEN
/*! @name Useful inherited methods */
//@{
public:
/*! Returns viewer's widget width (in pixels). See QGLWidget documentation. */
int width() const;
/*! Returns viewer's widget height (in pixels). See QGLWidget documentation. */
int height() const;
/*! Updates the display. Do not call draw() directly, use this method instead. See QGLWidget documentation. */
virtual void updateGL();
/*! Converts \p image into the unnamed format expected by OpenGL methods such as glTexImage2D().
See QGLWidget documentation. */
static QImage convertToGLFormat(const QImage & image);
/*! Calls \c glColor3. See QGLWidget::qglColor(). */
void qglColor(const QColor& color) const;
/*! Calls \c glClearColor. See QGLWidget documentation. */
void qglClearColor(const QColor& color) const;
/*! Returns \c true if the widget has a valid GL rendering context. See QGLWidget
documentation. */
bool isValid() const;
/*! Returns \c true if display list sharing with another QGLWidget was requested in the
constructor. See QGLWidget documentation. */
bool isSharing() const;
/*! Makes this widget's rendering context the current OpenGL rendering context. Useful with
several viewers. See QGLWidget documentation. */
virtual void makeCurrent();
/*! Returns \c true if mouseMoveEvent() is called even when no mouse button is pressed.
You need to setMouseTracking() to \c true in order to use MouseGrabber (see mouseGrabber()). See
details in the QWidget documentation. */
bool hasMouseTracking () const;
public Q_SLOTS:
/*! Resizes the widget to size \p width by \p height pixels. See also width() and height(). */
virtual void resize(int width, int height);
/*! Sets the hasMouseTracking() value. */
virtual void setMouseTracking(bool enable);
protected:
/*! Returns \c true when buffers are automatically swapped (default). See details in the QGLWidget
documentation. */
bool autoBufferSwap() const;
protected Q_SLOTS:
/*! Sets the autoBufferSwap() value. */
void setAutoBufferSwap(bool on);
//@}
#endif
/*! @name Snapshots */
//@{
public:
/*! Returns the snapshot file name used by saveSnapshot().
This value is used in \p automatic mode (see saveSnapshot()). A dialog is otherwise popped-up to
set it.
You can also directly provide a file name using saveSnapshot(const QString&, bool).
If the file name is relative, the current working directory at the moment of the method call is
used. Set using setSnapshotFileName(). */
const QString& snapshotFileName() const { return snapshotFileName_; }
#ifndef DOXYGEN
const QString& snapshotFilename() const;
#endif
/*! Returns the snapshot file format used by saveSnapshot().
This value is used when saveSnapshot() is passed the \p automatic flag. It is defined using a
saveAs pop-up dialog otherwise.
The available formats are those handled by Qt. Classical values are \c "JPEG", \c "PNG",
\c "PPM", \c "BMP". Use the following code to get the actual list:
\code
QList<QByteArray> formatList = QImageReader::supportedImageFormats();
// or with Qt version 2 or 3:
QStringList formatList = QImage::outputFormatList();
\endcode
If the library was compiled with the vectorial rendering option (default), three additional
vectorial formats are available: \c "EPS", \c "PS" and \c "XFIG". \c "SVG" and \c "PDF" formats
should soon be available. The <a href="http://artis.imag.fr/Software/VRender">VRender library</a>
was created by Cyril Soler.
Note that the VRender library has some limitations: vertex shader effects are not reproduced and
\c PASS_THROUGH tokens are not handled so one can not change point and line size in the middle of
a drawing.
Default value is the first supported among "JPEG, PNG, EPS, PS, PPM, BMP", in that order.
This value is set using setSnapshotFormat() or with openSnapshotFormatDialog().
\attention No verification is performed on the provided format validity. The next call to
saveSnapshot() may fail if the format string is not supported. */
const QString& snapshotFormat() const { return snapshotFormat_; }
/*! Returns the value of the counter used to name snapshots in saveSnapshot() when \p automatic is
\c true.
Set using setSnapshotCounter(). Default value is 0, and it is incremented after each \p automatic
snapshot. See saveSnapshot() for details. */
int snapshotCounter() const { return snapshotCounter_; }
/*! Defines the image quality of the snapshots produced with saveSnapshot().
Values must be in the range -1..100. Use 0 for lowest quality and 100 for highest quality (and
larger files). -1 means use Qt default quality. Default value is 95.
Set using setSnapshotQuality(). See also the QImage::save() documentation.
\note This value has no impact on the images produced in vectorial format. */
int snapshotQuality() { return snapshotQuality_; }
// Qt 2.3 does not support qreal default value parameters in slots.
// Remove "Q_SLOTS" from the following line to compile with Qt 2.3
public Q_SLOTS:
void saveSnapshot(bool automatic=true, bool overwrite=false);
public Q_SLOTS:
void saveSnapshot(const QString& fileName, bool overwrite=false);
void setSnapshotFileName(const QString& name);
/*! Sets the snapshotFormat(). */
void setSnapshotFormat(const QString& format) { snapshotFormat_ = format; }
/*! Sets the snapshotCounter(). */
void setSnapshotCounter(int counter) { snapshotCounter_ = counter; }
/*! Sets the snapshotQuality(). */
void setSnapshotQuality(int quality) { snapshotQuality_ = quality; }
bool openSnapshotFormatDialog();
void snapshotToClipboard();
private:
bool saveImageSnapshot(const QString& fileName);
#ifndef DOXYGEN
/* This class is used internally for screenshot that require tiling (image size size different
from window size). Only in that case, is the private tileRegion_ pointer non null.
It then contains the current tiled region, which is used by startScreenCoordinatesSystem
to adapt the coordinate system. Not using it would result in a tiled drawing of the parts
that use startScreenCoordinatesSystem. Also used by scaledFont for same purposes. */
class TileRegion { public : qreal xMin, yMin, xMax, yMax, textScale; };
#endif
public:
/*! Return a possibly scaled version of \p font, used for snapshot rendering.
From a user's point of view, this method simply returns \p font and can be used transparently.
However when internally rendering a screen snapshot using saveSnapshot(), it returns a scaled version
of the font, so that the size of the rendered text on the snapshot is identical to what is displayed on screen,
even if the snapshot uses image tiling to create an image of dimensions different from those of the
current window. This scaled version will only be used when saveSnapshot() calls your draw() method
to generate the snapshot.
All your calls to QGLWidget::renderText() function hence should use this method.
\code
renderText(x, y, z, "My Text", scaledFont(QFont()));
\endcode
will guarantee that this text will be properly displayed on arbitrary sized snapshots.
Note that this method is not needed if you use drawText() which already calls it internally. */
QFont scaledFont(const QFont& font) const {
if (tileRegion_ == NULL)
return font;
else {
QFont f(font);
if (f.pixelSize() == -1)
f.setPointSizeF(f.pointSizeF() * tileRegion_->textScale);
else
f.setPixelSize(int(f.pixelSize() * tileRegion_->textScale));
return f;
}
}
//@}
/*! @name Buffer to texture */
//@{
public:
GLuint bufferTextureId() const;
/*! Returns the texture coordinate corresponding to the u extremum of the bufferTexture.
The bufferTexture is created by copyBufferToTexture(). The texture size has powers of two
dimensions and the buffer image hence only fills a part of it. This value corresponds to the u
coordinate of the extremum right side of the buffer image.
Use (0,0) to (bufferTextureMaxU(), bufferTextureMaxV()) texture coordinates to map the entire
texture on a quad. */
qreal bufferTextureMaxU() const { return bufferTextureMaxU_; }
/*! Same as bufferTextureMaxU(), but for the v texture coordinate. */
qreal bufferTextureMaxV() const { return bufferTextureMaxV_; }
public Q_SLOTS:
void copyBufferToTexture(GLint internalFormat, GLenum format=GL_NONE);
//@}
/*! @name Animation */
//@{
public:
/*! Return \c true when the animation loop is started.
During animation, an infinite loop calls animate() and draw() and then waits for animationPeriod()
milliseconds before calling animate() and draw() again. And again.
Use startAnimation(), stopAnimation() or toggleAnimation() to change this value.
See the <a href="../examples/animation.html">animation example</a> for illustration. */
bool animationIsStarted() const { return animationStarted_; }
/*! The animation loop period, in milliseconds.
When animationIsStarted(), this is delay waited after draw() to call animate() and draw() again.
Default value is 40 milliseconds (25 Hz).
This value will define the currentFPS() when animationIsStarted() (provided that your animate()
and draw() methods are fast enough).
If you want to know the maximum possible frame rate of your machine on a given scene,
setAnimationPeriod() to \c 0, and startAnimation() (keyboard shortcut is \c Enter). The display
will then be updated as often as possible, and the frame rate will be meaningful.
\note This value is taken into account only the next time you call startAnimation(). If
animationIsStarted(), you should stopAnimation() first. */
int animationPeriod() const { return animationPeriod_; }
public Q_SLOTS:
/*! Sets the animationPeriod(), in milliseconds. */
void setAnimationPeriod(int period) { animationPeriod_ = period; }
virtual void startAnimation();
virtual void stopAnimation();
/*! Scene animation method.
When animationIsStarted(), this method is in charge of the scene update before each draw().
Overload it to define how your scene evolves over time. The time should either be regularly
incremented in this method (frame-rate independent animation) or computed from actual time (for
instance using QTime::elapsed()) for real-time animations.
Note that KeyFrameInterpolator (which regularly updates a Frame) does not use this method
to animate a Frame, but rather rely on a QTimer signal-slot mechanism.
See the <a href="../examples/animation.html">animation example</a> for an illustration. */
virtual void animate() { Q_EMIT animateNeeded(); }
/*! Calls startAnimation() or stopAnimation(), depending on animationIsStarted(). */
void toggleAnimation() { if (animationIsStarted()) stopAnimation(); else startAnimation(); }
//@}
public:
Q_SIGNALS:
/*! Signal emitted by the default init() method.
Connect this signal to the methods that need to be called to initialize your viewer or overload init(). */
void viewerInitialized();
/*! Signal emitted by the default draw() method.
Connect this signal to your main drawing method or overload draw(). See the <a
href="../examples/callback.html">callback example</a> for an illustration. */
void drawNeeded();
/*! Signal emitted at the end of the QGLViewer::paintGL() method, when frame is drawn.
Can be used to notify an image grabbing process that the image is ready. A typical example is to
connect this signal to the saveSnapshot() method, so that a (numbered) snapshot is generated after
each new display, in order to create a movie:
\code
connect(viewer, SIGNAL(drawFinished(bool)), SLOT(saveSnapshot(bool)));
\endcode
The \p automatic bool variable is always \c true and has been added so that the signal can be
connected to saveSnapshot() with an \c automatic value set to \c true. */
void drawFinished(bool automatic);
/*! Signal emitted by the default animate() method.
Connect this signal to your scene animation method or overload animate(). */
void animateNeeded();
/*! Signal emitted by the default QGLViewer::help() method.
Connect this signal to your own help method or overload help(). */
void helpRequired();
/*! This signal is emitted whenever axisIsDrawn() changes value. */
void axisIsDrawnChanged(bool drawn);
/*! This signal is emitted whenever gridIsDrawn() changes value. */
void gridIsDrawnChanged(bool drawn);
/*! This signal is emitted whenever FPSIsDisplayed() changes value. */
void FPSIsDisplayedChanged(bool displayed);
/*! This signal is emitted whenever textIsEnabled() changes value. */
void textIsEnabledChanged(bool enabled);
/*! This signal is emitted whenever cameraIsEdited() changes value.. */
void cameraIsEditedChanged(bool edited);
/*! This signal is emitted whenever displaysInStereo() changes value. */
void stereoChanged(bool on);
/*! Signal emitted by select().
Connect this signal to your selection method or overload select(), or more probably simply
drawWithNames(). */
void pointSelected(const QMouseEvent* e);
/*! Signal emitted by setMouseGrabber() when the mouseGrabber() is changed.
\p mouseGrabber is a pointer to the new MouseGrabber. Note that this signal is emitted with a \c
NULL parameter each time a MouseGrabber stops grabbing mouse. */
void mouseGrabberChanged(qglviewer::MouseGrabber* mouseGrabber);
/*! @name Help window */
//@{
public:
/*! Returns the QString displayed in the help() window main tab.
Overload this method to define your own help string, which should shortly describe your
application and explain how it works. Rich-text (HTML) tags can be used (see QStyleSheet()
documentation for available tags):
\code
QString myViewer::helpString() const
{
QString text("<h2>M y V i e w e r</h2>");
text += "Displays a <b>Scene</b> using OpenGL. Move the camera using the mouse.";
return text;
}
\endcode
See also mouseString() and keyboardString(). */
virtual QString helpString() const { return tr("No help available."); }
virtual QString mouseString() const;
virtual QString keyboardString() const;
#ifndef DOXYGEN
/*! This method is deprecated, use mouseString() instead. */
virtual QString mouseBindingsString () const { return mouseString(); }
/*! This method is deprecated, use keyboardString() instead. */
virtual QString shortcutBindingsString () const { return keyboardString(); }
#endif
public Q_SLOTS:
virtual void help();
virtual void aboutQGLViewer();
protected:
/*! Returns a pointer to the help widget.
Use this only if you want to directly modify the help widget. Otherwise use helpString(),
setKeyDescription() and setMouseBindingDescription() to customize the text displayed in the help
window tabs. */
QTabWidget* helpWidget() { return helpWidget_; }
//@}
/*! @name Drawing methods */
//@{
protected:
virtual void resizeGL(int width, int height);
virtual void initializeGL();
/*! Initializes the viewer OpenGL context.
This method is called before the first drawing and should be overloaded to initialize some of the
OpenGL flags. The default implementation is empty. See initializeGL().
Typical usage include camera() initialization (showEntireScene()), previous viewer state
restoration (restoreStateFromFile()), OpenGL state modification and display list creation.
Note that initializeGL() modifies the standard OpenGL context. These values can be restored back
in this method.
\attention You should not call updateGL() (or any method that calls it) in this method, as it will
result in an infinite loop. The different QGLViewer set methods (setAxisIsDrawn(),
setFPSIsDisplayed()...) are protected against this problem and can safely be called.
\note All the OpenGL specific initializations must be done in this method: the OpenGL context is
not yet available in your viewer constructor. */
virtual void init() { Q_EMIT viewerInitialized(); }
virtual void paintGL();
virtual void preDraw();
virtual void preDrawStereo(bool leftBuffer=true);
/*! The core method of the viewer, that draws the scene.
If you build a class that inherits from QGLViewer, this is the method you want to overload. See
the <a href="../examples/simpleViewer.html">simpleViewer example</a> for an illustration.
The camera modelView matrix set in preDraw() converts from the world to the camera coordinate
systems. Vertices given in draw() can then be considered as being given in the world coordinate
system. The camera is moved in this world using the mouse. This representation is much more
intuitive than the default camera-centric OpenGL standard.
\attention The \c GL_PROJECTION matrix should not be modified by this method, to correctly display
visual hints (axis, grid, FPS...) in postDraw(). Use push/pop or call
camera()->loadProjectionMatrix() at the end of draw() if you need to change the projection matrix
(unlikely). On the other hand, the \c GL_MODELVIEW matrix can be modified and left in a arbitrary
state. */
virtual void draw() {}
virtual void fastDraw();
virtual void postDraw();
//@}
/*! @name Mouse, keyboard and event handlers */
//@{
protected:
virtual void mousePressEvent(QMouseEvent *);
virtual void mouseMoveEvent(QMouseEvent *);
virtual void mouseReleaseEvent(QMouseEvent *);
virtual void mouseDoubleClickEvent(QMouseEvent *);
virtual void wheelEvent(QWheelEvent *);
virtual void keyPressEvent(QKeyEvent *);
virtual void keyReleaseEvent(QKeyEvent *);
virtual void timerEvent(QTimerEvent *);
virtual void closeEvent(QCloseEvent *);
//@}
/*! @name Object selection */
//@{
public:
/*! Returns the name (an integer value) of the entity that was last selected by select(). This
value is set by endSelection(). See the select() documentation for details.
As a convention, this method returns -1 if the selectBuffer() was empty, meaning that no object
was selected.
Return value is -1 before the first call to select(). This value is modified using setSelectedName(). */
int selectedName() const { return selectedObjectId_; }
/*! Returns the selectBuffer() size.
See the select() documentation for details. Use setSelectBufferSize() to change this value.
Default value is 4000 (i.e. 1000 objects in selection region, since each object pushes 4 values).
This size should be over estimated to prevent a buffer overflow when many objects are drawn under
the mouse cursor. */
int selectBufferSize() const { return selectBufferSize_; }
/*! Returns the width (in pixels) of a selection frustum, centered on the mouse cursor, that is
used to select objects.
The height of the selection frustum is defined by selectRegionHeight().
The objects that will be drawn in this region by drawWithNames() will be recorded in the
selectBuffer(). endSelection() then analyzes this buffer and setSelectedName() to the name of the
closest object. See the gluPickMatrix() documentation for details.
The default value is 3, which is adapted to standard applications. A smaller value results in a
more precise selection but the user has to be careful for small feature selection.
See the <a href="../examples/multiSelect.html">multiSelect example</a> for an illustration. */
int selectRegionWidth() const { return selectRegionWidth_; }
/*! See the selectRegionWidth() documentation. Default value is 3 pixels. */
int selectRegionHeight() const { return selectRegionHeight_; }
/*! Returns a pointer to an array of \c GLuint.
This buffer is used by the \c GL_SELECT mode in select() to perform object selection. The buffer
size can be modified using setSelectBufferSize(). If you overload endSelection(), you will analyze
the content of this buffer. See the \c glSelectBuffer() man page for details. */
GLuint* selectBuffer() { return selectBuffer_; }
public Q_SLOTS:
virtual void select(const QMouseEvent* event);
virtual void select(const QPoint& point);
void setSelectBufferSize(int size);
/*! Sets the selectRegionWidth(). */
void setSelectRegionWidth(int width) { selectRegionWidth_ = width; }
/*! Sets the selectRegionHeight(). */
void setSelectRegionHeight(int height) { selectRegionHeight_ = height; }
/*! Set the selectedName() value.
Used in endSelection() during a selection. You should only call this method if you overload the
endSelection() method. */
void setSelectedName(int id) { selectedObjectId_=id; }
protected:
virtual void beginSelection(const QPoint& point);
/*! This method is called by select() and should draw selectable entities.
Default implementation is empty. Overload and draw the different elements of your scene you want
to be able to select. The default select() implementation relies on the \c GL_SELECT, and requires
that each selectable element is drawn within a \c glPushName() - \c glPopName() block. A typical
usage would be (see the <a href="../examples/select.html">select example</a>):
\code
void Viewer::drawWithNames() {
for (int i=0; i<nbObjects; ++i) {
glPushName(i);
object(i)->draw();
glPopName();
}
}
\endcode
The resulting selected name is computed by endSelection(), which setSelectedName() to the integer
id pushed by this method (a value of -1 means no selection). Use selectedName() to update your
selection, probably in the postSelection() method.
\attention If your selected objects are points, do not use \c glBegin(GL_POINTS); and \c glVertex3fv()
in the above \c draw() method (not compatible with raster mode): use \c glRasterPos3fv() instead. */
virtual void drawWithNames() {}
virtual void endSelection(const QPoint& point);
/*! This method is called at the end of the select() procedure. It should finalize the selection
process and update the data structure/interface/computation/display... according to the newly
selected entity.
The default implementation is empty. Overload this method if needed, and use selectedName() to
retrieve the selected entity name (returns -1 if no object was selected). See the <a
href="../examples/select.html">select example</a> for an illustration. */
virtual void postSelection(const QPoint& point) { Q_UNUSED(point); }
//@}
/*! @name Keyboard customization */
//@{
public:
/*! Defines the different actions that can be associated with a keyboard shortcut using
setShortcut().
See the <a href="../keyboard.html">keyboard page</a> for details. */
enum KeyboardAction { DRAW_AXIS, DRAW_GRID, DISPLAY_FPS, ENABLE_TEXT, EXIT_VIEWER,
SAVE_SCREENSHOT, CAMERA_MODE, FULL_SCREEN, STEREO, ANIMATION, HELP, EDIT_CAMERA,
MOVE_CAMERA_LEFT, MOVE_CAMERA_RIGHT, MOVE_CAMERA_UP, MOVE_CAMERA_DOWN,
INCREASE_FLYSPEED, DECREASE_FLYSPEED, SNAPSHOT_TO_CLIPBOARD };
unsigned int shortcut(KeyboardAction action) const;
#ifndef DOXYGEN
// QGLViewer 1.x
unsigned int keyboardAccelerator(KeyboardAction action) const;
Qt::Key keyFrameKey(unsigned int index) const;
Qt::KeyboardModifiers playKeyFramePathStateKey() const;
// QGLViewer 2.0 without Qt4 support
Qt::KeyboardModifiers addKeyFrameStateKey() const;
Qt::KeyboardModifiers playPathStateKey() const;
#endif
Qt::Key pathKey(unsigned int index) const;
Qt::KeyboardModifiers addKeyFrameKeyboardModifiers() const;
Qt::KeyboardModifiers playPathKeyboardModifiers() const;
public Q_SLOTS:
void setShortcut(KeyboardAction action, unsigned int key);
#ifndef DOXYGEN
void setKeyboardAccelerator(KeyboardAction action, unsigned int key);
#endif
void setKeyDescription(unsigned int key, QString description);
void clearShortcuts();
// Key Frames shortcut keys
#ifndef DOXYGEN
// QGLViewer 1.x compatibility methods
virtual void setKeyFrameKey(unsigned int index, int key);
virtual void setPlayKeyFramePathStateKey(unsigned int buttonState);
// QGLViewer 2.0 without Qt4 support
virtual void setPlayPathStateKey(unsigned int buttonState);
virtual void setAddKeyFrameStateKey(unsigned int buttonState);
#endif
virtual void setPathKey(int key, unsigned int index = 0);
virtual void setPlayPathKeyboardModifiers(Qt::KeyboardModifiers modifiers);
virtual void setAddKeyFrameKeyboardModifiers(Qt::KeyboardModifiers modifiers);
//@}
public:
/*! @name Mouse customization */
//@{
/*! Defines the different mouse handlers: camera() or manipulatedFrame().
Used by setMouseBinding(), setMouseBinding(Qt::KeyboardModifiers modifiers, Qt::MouseButtons, ClickAction, bool, int)
and setWheelBinding() to define which handler receives the mouse events. */
enum MouseHandler { CAMERA, FRAME };
/*! Defines the possible actions that can be binded to a mouse click using
setMouseBinding(Qt::KeyboardModifiers, Qt::MouseButtons, ClickAction, bool, int).
See the <a href="../mouse.html">mouse page</a> for details. */
enum ClickAction { NO_CLICK_ACTION, ZOOM_ON_PIXEL, ZOOM_TO_FIT, SELECT, RAP_FROM_PIXEL, RAP_IS_CENTER,
CENTER_FRAME, CENTER_SCENE, SHOW_ENTIRE_SCENE, ALIGN_FRAME, ALIGN_CAMERA };
/*! Defines the possible actions that can be binded to a mouse action (a click, followed by a
mouse displacement).
These actions may be binded to the camera() or to the manipulatedFrame() (see QGLViewer::MouseHandler) using
setMouseBinding(). */
enum MouseAction { NO_MOUSE_ACTION,
ROTATE, ZOOM, TRANSLATE,
MOVE_FORWARD, LOOK_AROUND, MOVE_BACKWARD,
SCREEN_ROTATE, ROLL, DRIVE,
SCREEN_TRANSLATE, ZOOM_ON_REGION };
#ifndef DOXYGEN
MouseAction mouseAction(unsigned int state) const;
int mouseHandler(unsigned int state) const;
int mouseButtonState(MouseHandler handler, MouseAction action, bool withConstraint=true) const;
ClickAction clickAction(unsigned int state, bool doubleClick, Qt::MouseButtons buttonsBefore) const;
void getClickButtonState(ClickAction action, unsigned int & state, bool& doubleClick, Qt::MouseButtons& buttonsBefore) const;
unsigned int wheelButtonState(MouseHandler handler, MouseAction action, bool withConstraint=true) const;
#endif
MouseAction mouseAction(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button) const;
int mouseHandler(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button) const;
void getMouseActionBinding(MouseHandler handler, MouseAction action, bool withConstraint,
Qt::Key& key, Qt::KeyboardModifiers& modifiers, Qt::MouseButton& button) const;
ClickAction clickAction(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button,
bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton) const;
void getClickActionBinding(ClickAction action, Qt::Key& key, Qt::KeyboardModifiers& modifiers,
Qt::MouseButton& button, bool& doubleClick, Qt::MouseButtons& buttonsBefore) const;
MouseAction wheelAction(Qt::Key key, Qt::KeyboardModifiers modifiers) const;
int wheelHandler(Qt::Key key, Qt::KeyboardModifiers modifiers) const;
void getWheelActionBinding(MouseHandler handler, MouseAction action, bool withConstraint,
Qt::Key& key, Qt::KeyboardModifiers& modifiers) const;
public Q_SLOTS:
#ifndef DOXYGEN
void setMouseBinding(unsigned int state, MouseHandler handler, MouseAction action, bool withConstraint=true);
void setMouseBinding(unsigned int state, ClickAction action, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);
void setMouseBindingDescription(unsigned int state, QString description, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);
#endif
void setMouseBinding(Qt::KeyboardModifiers modifiers, Qt::MouseButton buttons, MouseHandler handler, MouseAction action, bool withConstraint=true);
void setMouseBinding(Qt::KeyboardModifiers modifiers, Qt::MouseButton button, ClickAction action, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);
void setWheelBinding(Qt::KeyboardModifiers modifiers, MouseHandler handler, MouseAction action, bool withConstraint=true);
void setMouseBindingDescription(Qt::KeyboardModifiers modifiers, Qt::MouseButton button, QString description, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);
void setMouseBinding(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton buttons, MouseHandler handler, MouseAction action, bool withConstraint=true);
void setMouseBinding(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button, ClickAction action, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);
void setWheelBinding(Qt::Key key, Qt::KeyboardModifiers modifiers, MouseHandler handler, MouseAction action, bool withConstraint=true);
void setMouseBindingDescription(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton button, QString description, bool doubleClick=false, Qt::MouseButtons buttonsBefore=Qt::NoButton);
void clearMouseBindings();
#ifndef DOXYGEN
MouseAction wheelAction(Qt::KeyboardModifiers modifiers) const;
int wheelHandler(Qt::KeyboardModifiers modifiers) const;
void setHandlerKeyboardModifiers(MouseHandler handler, Qt::KeyboardModifiers modifiers);
void setHandlerStateKey(MouseHandler handler, unsigned int buttonState);
void setMouseStateKey(MouseHandler handler, unsigned int buttonState);
#endif
private:
static QString mouseActionString(QGLViewer::MouseAction ma);
static QString clickActionString(QGLViewer::ClickAction ca);
//@}
/*! @name State persistence */
//@{
public:
QString stateFileName() const;
virtual QDomElement domElement(const QString& name, QDomDocument& document) const;
public Q_SLOTS:
virtual void initFromDOMElement(const QDomElement& element);
virtual void saveStateToFile(); // cannot be const because of QMessageBox
virtual bool restoreStateFromFile();
/*! Defines the stateFileName() used by saveStateToFile() and restoreStateFromFile().
The file name can have an optional prefix directory (no prefix meaning current directory). If the
directory does not exist, it will be created by saveStateToFile().
\code
// Name depends on the displayed 3D model. Saved in current directory.
setStateFileName(3DModelName() + ".xml");
// Files are stored in a dedicated directory under user's home directory.
setStateFileName(QDir::homeDirPath + "/.config/myApp.xml");
\endcode */
void setStateFileName(const QString& name) { stateFileName_ = name; }
#ifndef DOXYGEN
void saveToFile(const QString& fileName=QString::null);
bool restoreFromFile(const QString& fileName=QString::null);
#endif
private:
static void saveStateToFileForAllViewers();
//@}
/*! @name QGLViewer pool */
//@{
public:
/*! Returns a \c QList that contains pointers to all the created QGLViewers.
Note that this list may contain \c NULL pointers if the associated viewer has been deleted.
Can be useful to apply a method or to connect a signal to all the viewers:
\code
foreach (QGLViewer* viewer, QGLViewer::QGLViewerPool())
connect(myObject, SIGNAL(IHaveChangedSignal()), viewer, SLOT(update()));
\endcode
\attention With Qt version 3, this method returns a \c QPtrList instead. Use a \c QPtrListIterator
to iterate on the list instead.*/
static const QList<QGLViewer*>& QGLViewerPool() { return QGLViewer::QGLViewerPool_; }
/*! Returns the index of the QGLViewer \p viewer in the QGLViewerPool(). This index in unique and
can be used to identify the different created QGLViewers (see stateFileName() for an application
example).
When a QGLViewer is deleted, the QGLViewers' indexes are preserved and NULL is set for that index.
When a QGLViewer is created, it is placed in the first available position in that list.
Returns -1 if the QGLViewer could not be found (which should not be possible). */
static int QGLViewerIndex(const QGLViewer* const viewer) { return QGLViewer::QGLViewerPool_.indexOf(const_cast<QGLViewer*>(viewer)); }
//@}
#ifndef DOXYGEN
/*! @name Visual hints */
//@{
public:
virtual void setVisualHintsMask(int mask, int delay = 2000);
virtual void drawVisualHints();
public Q_SLOTS:
virtual void resetVisualHints();
//@}
#endif
private Q_SLOTS:
// Patch for a Qt bug with fullScreen on startup
void delayedFullScreen() { move(prevPos_); setFullScreen(); }
void hideMessage();
private:
// Copy constructor and operator= are declared private and undefined
// Prevents everyone from trying to use them
QGLViewer(const QGLViewer& v);
QGLViewer& operator=(const QGLViewer& v);
// Set parameters to their default values. Called by the constructors.
void defaultConstructor();
void handleKeyboardAction(KeyboardAction id);
// C a m e r a
qglviewer::Camera* camera_;
bool cameraIsEdited_;
qreal previousCameraZClippingCoefficient_;
unsigned int previousPathId_; // double key press recognition
void connectAllCameraKFIInterpolatedSignals(bool connection=true);
// C o l o r s
QColor backgroundColor_, foregroundColor_;
// D i s p l a y f l a g s
bool axisIsDrawn_; // world axis
bool gridIsDrawn_; // world XY grid
bool FPSIsDisplayed_; // Frame Per Seconds
bool textIsEnabled_; // drawText() actually draws text or not
bool stereo_; // stereo display
bool fullScreen_; // full screen mode
QPoint prevPos_; // Previous window position, used for full screen mode
// A n i m a t i o n
bool animationStarted_; // animation mode started
int animationPeriod_; // period in msecs
int animationTimerId_;
// F P S d i s p l a y
QTime fpsTime_;
unsigned int fpsCounter_;
QString fpsString_;
qreal f_p_s_;
// M e s s a g e s
QString message_;
bool displayMessage_;
QTimer messageTimer_;
// M a n i p u l a t e d f r a m e
qglviewer::ManipulatedFrame* manipulatedFrame_;
bool manipulatedFrameIsACamera_;
// M o u s e G r a b b e r
qglviewer::MouseGrabber* mouseGrabber_;
bool mouseGrabberIsAManipulatedFrame_;
bool mouseGrabberIsAManipulatedCameraFrame_;
QMap<size_t, bool> disabledMouseGrabbers_;
// S e l e c t i o n
int selectRegionWidth_, selectRegionHeight_;
int selectBufferSize_;
GLuint* selectBuffer_;
int selectedObjectId_;
// V i s u a l h i n t s
int visualHint_;
// S h o r t c u t k e y s
void setDefaultShortcuts();
QString cameraPathKeysString() const;
QMap<KeyboardAction, QString> keyboardActionDescription_;
QMap<KeyboardAction, unsigned int> keyboardBinding_;
QMap<unsigned int, QString> keyDescription_;
// K e y F r a m e s s h o r t c u t s
QMap<Qt::Key, unsigned int> pathIndex_;
Qt::KeyboardModifiers addKeyFrameKeyboardModifiers_, playPathKeyboardModifiers_;
// B u f f e r T e x t u r e
GLuint bufferTextureId_;
qreal bufferTextureMaxU_, bufferTextureMaxV_;
int bufferTextureWidth_, bufferTextureHeight_;
unsigned int previousBufferTextureFormat_;
int previousBufferTextureInternalFormat_;
#ifndef DOXYGEN
// M o u s e a c t i o n s
struct MouseActionPrivate {
MouseHandler handler;
MouseAction action;
bool withConstraint;
};
// M o u s e b i n d i n g s
struct MouseBindingPrivate {
const Qt::KeyboardModifiers modifiers;
const Qt::MouseButton button;
const Qt::Key key;
MouseBindingPrivate(Qt::KeyboardModifiers m, Qt::MouseButton b, Qt::Key k)
: modifiers(m), button(b), key(k) {}
// This sort order is used in mouseString() to display sorted mouse bindings
bool operator<(const MouseBindingPrivate& mbp) const
{
if (key != mbp.key)
return key < mbp.key;
if (modifiers != mbp.modifiers)
return modifiers < mbp.modifiers;
return button < mbp.button;
}
};
// W h e e l b i n d i n g s
struct WheelBindingPrivate {
const Qt::KeyboardModifiers modifiers;
const Qt::Key key;
WheelBindingPrivate(Qt::KeyboardModifiers m, Qt::Key k)
: modifiers(m), key(k) {}
// This sort order is used in mouseString() to display sorted wheel bindings
bool operator<(const WheelBindingPrivate& wbp) const
{
if (key != wbp.key)
return key < wbp.key;
return modifiers < wbp.modifiers;
}
};
// C l i c k b i n d i n g s
struct ClickBindingPrivate {
const Qt::KeyboardModifiers modifiers;
const Qt::MouseButton button;
const bool doubleClick;
const Qt::MouseButtons buttonsBefore; // only defined when doubleClick is true
const Qt::Key key;
ClickBindingPrivate(Qt::KeyboardModifiers m, Qt::MouseButton b, bool dc, Qt::MouseButtons bb, Qt::Key k)
: modifiers(m), button(b), doubleClick(dc), buttonsBefore(bb), key(k) {}
// This sort order is used in mouseString() to display sorted mouse bindings
bool operator<(const ClickBindingPrivate& cbp) const
{
if (key != cbp.key)
return key < cbp.key;
if (buttonsBefore != cbp.buttonsBefore)
return buttonsBefore < cbp.buttonsBefore;
if (modifiers != cbp.modifiers)
return modifiers < cbp.modifiers;
if (button != cbp.button)
return button < cbp.button;
return doubleClick != cbp.doubleClick;
}
};
#endif
static QString formatClickActionPrivate(ClickBindingPrivate cbp);
static bool isValidShortcutKey(int key);
QMap<ClickBindingPrivate, QString> mouseDescription_;
void setDefaultMouseBindings();
void performClickAction(ClickAction ca, const QMouseEvent* const e);
QMap<MouseBindingPrivate, MouseActionPrivate> mouseBinding_;
QMap<WheelBindingPrivate, MouseActionPrivate> wheelBinding_;
QMap<ClickBindingPrivate, ClickAction> clickBinding_;
Qt::Key currentlyPressedKey_;
// S n a p s h o t s
void initializeSnapshotFormats();
QImage frameBufferSnapshot();
QString snapshotFileName_, snapshotFormat_;
int snapshotCounter_, snapshotQuality_;
TileRegion* tileRegion_;
// Q G L V i e w e r p o o l
static QList<QGLViewer*> QGLViewerPool_;
// S t a t e F i l e
QString stateFileName_;
// H e l p w i n d o w
QTabWidget* helpWidget_;
};
#endif // QGLVIEWER_QGLVIEWER_H
| 54,377 | 40.861432 | 193 | h |
octomap | octomap-master/octovis/src/extern/QGLViewer/quaternion.cpp | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#include "domUtils.h"
#include "quaternion.h"
#include <stdlib.h> // RAND_MAX
// All the methods are declared inline in Quaternion.h
using namespace qglviewer;
using namespace std;
/*! Constructs a Quaternion that will rotate from the \p from direction to the \p to direction.
Note that this rotation is not uniquely defined. The selected axis is usually orthogonal to \p from
and \p to, minimizing the rotation angle. This method is robust and can handle small or almost identical vectors. */
Quaternion::Quaternion(const Vec& from, const Vec& to)
{
const qreal epsilon = 1E-10;
const qreal fromSqNorm = from.squaredNorm();
const qreal toSqNorm = to.squaredNorm();
// Identity Quaternion when one vector is null
if ((fromSqNorm < epsilon) || (toSqNorm < epsilon))
{
q[0]=q[1]=q[2]=0.0;
q[3]=1.0;
}
else
{
Vec axis = cross(from, to);
const qreal axisSqNorm = axis.squaredNorm();
// Aligned vectors, pick any axis, not aligned with from or to
if (axisSqNorm < epsilon)
axis = from.orthogonalVec();
qreal angle = asin(sqrt(axisSqNorm / (fromSqNorm * toSqNorm)));
if (from*to < 0.0)
angle = M_PI-angle;
setAxisAngle(axis, angle);
}
}
/*! Returns the image of \p v by the Quaternion inverse() rotation.
rotate() performs an inverse transformation. Same as inverse().rotate(v). */
Vec Quaternion::inverseRotate(const Vec& v) const
{
return inverse().rotate(v);
}
/*! Returns the image of \p v by the Quaternion rotation.
See also inverseRotate() and operator*(const Quaternion&, const Vec&). */
Vec Quaternion::rotate(const Vec& v) const
{
const qreal q00 = 2.0 * q[0] * q[0];
const qreal q11 = 2.0 * q[1] * q[1];
const qreal q22 = 2.0 * q[2] * q[2];
const qreal q01 = 2.0 * q[0] * q[1];
const qreal q02 = 2.0 * q[0] * q[2];
const qreal q03 = 2.0 * q[0] * q[3];
const qreal q12 = 2.0 * q[1] * q[2];
const qreal q13 = 2.0 * q[1] * q[3];
const qreal q23 = 2.0 * q[2] * q[3];
return Vec((1.0 - q11 - q22)*v[0] + ( q01 - q23)*v[1] + ( q02 + q13)*v[2],
( q01 + q23)*v[0] + (1.0 - q22 - q00)*v[1] + ( q12 - q03)*v[2],
( q02 - q13)*v[0] + ( q12 + q03)*v[1] + (1.0 - q11 - q00)*v[2] );
}
/*! Set the Quaternion from a (supposedly correct) 3x3 rotation matrix.
The matrix is expressed in European format: its three \e columns are the images by the rotation of
the three vectors of an orthogonal basis. Note that OpenGL uses a symmetric representation for its
matrices.
setFromRotatedBasis() sets a Quaternion from the three axis of a rotated frame. It actually fills
the three columns of a matrix with these rotated basis vectors and calls this method. */
void Quaternion::setFromRotationMatrix(const qreal m[3][3])
{
// Compute one plus the trace of the matrix
const qreal onePlusTrace = 1.0 + m[0][0] + m[1][1] + m[2][2];
if (onePlusTrace > 1E-5)
{
// Direct computation
const qreal s = sqrt(onePlusTrace) * 2.0;
q[0] = (m[2][1] - m[1][2]) / s;
q[1] = (m[0][2] - m[2][0]) / s;
q[2] = (m[1][0] - m[0][1]) / s;
q[3] = 0.25 * s;
}
else
{
// Computation depends on major diagonal term
if ((m[0][0] > m[1][1])&(m[0][0] > m[2][2]))
{
const qreal s = sqrt(1.0 + m[0][0] - m[1][1] - m[2][2]) * 2.0;
q[0] = 0.25 * s;
q[1] = (m[0][1] + m[1][0]) / s;
q[2] = (m[0][2] + m[2][0]) / s;
q[3] = (m[1][2] - m[2][1]) / s;
}
else
if (m[1][1] > m[2][2])
{
const qreal s = sqrt(1.0 + m[1][1] - m[0][0] - m[2][2]) * 2.0;
q[0] = (m[0][1] + m[1][0]) / s;
q[1] = 0.25 * s;
q[2] = (m[1][2] + m[2][1]) / s;
q[3] = (m[0][2] - m[2][0]) / s;
}
else
{
const qreal s = sqrt(1.0 + m[2][2] - m[0][0] - m[1][1]) * 2.0;
q[0] = (m[0][2] + m[2][0]) / s;
q[1] = (m[1][2] + m[2][1]) / s;
q[2] = 0.25 * s;
q[3] = (m[0][1] - m[1][0]) / s;
}
}
normalize();
}
#ifndef DOXYGEN
void Quaternion::setFromRotationMatrix(const float m[3][3])
{
qWarning("setFromRotationMatrix now expects a double[3][3] parameter");
qreal mat[3][3];
for (int i=0; i<3; ++i)
for (int j=0; j<3; ++j)
mat[i][j] = qreal(m[i][j]);
setFromRotationMatrix(mat);
}
void Quaternion::setFromRotatedBase(const Vec& X, const Vec& Y, const Vec& Z)
{
qWarning("setFromRotatedBase is deprecated, use setFromRotatedBasis instead");
setFromRotatedBasis(X,Y,Z);
}
#endif
/*! Sets the Quaternion from the three rotated vectors of an orthogonal basis.
The three vectors do not have to be normalized but must be orthogonal and direct (X^Y=k*Z, with k>0).
\code
Quaternion q;
q.setFromRotatedBasis(X, Y, Z);
// Now q.rotate(Vec(1,0,0)) == X and q.inverseRotate(X) == Vec(1,0,0)
// Same goes for Y and Z with Vec(0,1,0) and Vec(0,0,1).
\endcode
See also setFromRotationMatrix() and Quaternion(const Vec&, const Vec&). */
void Quaternion::setFromRotatedBasis(const Vec& X, const Vec& Y, const Vec& Z)
{
qreal m[3][3];
qreal normX = X.norm();
qreal normY = Y.norm();
qreal normZ = Z.norm();
for (int i=0; i<3; ++i)
{
m[i][0] = X[i] / normX;
m[i][1] = Y[i] / normY;
m[i][2] = Z[i] / normZ;
}
setFromRotationMatrix(m);
}
/*! Returns the axis vector and the angle (in radians) of the rotation represented by the Quaternion.
See the axis() and angle() documentations. */
void Quaternion::getAxisAngle(Vec& axis, qreal& angle) const
{
angle = 2.0 * acos(q[3]);
axis = Vec(q[0], q[1], q[2]);
const qreal sinus = axis.norm();
if (sinus > 1E-8)
axis /= sinus;
if (angle > M_PI)
{
angle = 2.0 * qreal(M_PI) - angle;
axis = -axis;
}
}
/*! Returns the normalized axis direction of the rotation represented by the Quaternion.
It is null for an identity Quaternion. See also angle() and getAxisAngle(). */
Vec Quaternion::axis() const
{
Vec res = Vec(q[0], q[1], q[2]);
const qreal sinus = res.norm();
if (sinus > 1E-8)
res /= sinus;
return (acos(q[3]) <= M_PI/2.0) ? res : -res;
}
/*! Returns the angle (in radians) of the rotation represented by the Quaternion.
This value is always in the range [0-pi]. Larger rotational angles are obtained by inverting the
axis() direction.
See also axis() and getAxisAngle(). */
qreal Quaternion::angle() const
{
const qreal angle = 2.0 * acos(q[3]);
return (angle <= M_PI) ? angle : 2.0*M_PI - angle;
}
/*! Returns an XML \c QDomElement that represents the Quaternion.
\p name is the name of the QDomElement tag. \p doc is the \c QDomDocument factory used to create
QDomElement.
When output to a file, the resulting QDomElement will look like:
\code
<name q0=".." q1=".." q2=".." q3=".." />
\endcode
Use initFromDOMElement() to restore the Quaternion state from the resulting \c QDomElement. See
also the Quaternion(const QDomElement&) constructor.
See the Vec::domElement() documentation for a complete QDomDocument creation and saving example.
See also Frame::domElement(), Camera::domElement(), KeyFrameInterpolator::domElement()... */
QDomElement Quaternion::domElement(const QString& name, QDomDocument& document) const
{
QDomElement de = document.createElement(name);
de.setAttribute("q0", QString::number(q[0]));
de.setAttribute("q1", QString::number(q[1]));
de.setAttribute("q2", QString::number(q[2]));
de.setAttribute("q3", QString::number(q[3]));
return de;
}
/*! Restores the Quaternion state from a \c QDomElement created by domElement().
The \c QDomElement should contain the \c q0, \c q1 , \c q2 and \c q3 attributes. If one of these
attributes is missing or is not a number, a warning is displayed and these fields are respectively
set to 0.0, 0.0, 0.0 and 1.0 (identity Quaternion).
See also the Quaternion(const QDomElement&) constructor. */
void Quaternion::initFromDOMElement(const QDomElement& element)
{
Quaternion q(element);
*this = q;
}
/*! Constructs a Quaternion from a \c QDomElement representing an XML code of the form
\code< anyTagName q0=".." q1=".." q2=".." q3=".." />\endcode
If one of these attributes is missing or is not a number, a warning is displayed and the associated
value is respectively set to 0, 0, 0 and 1 (identity Quaternion).
See also domElement() and initFromDOMElement(). */
Quaternion::Quaternion(const QDomElement& element)
{
QStringList attribute;
attribute << "q0" << "q1" << "q2" << "q3";
for (int i=0; i<attribute.size(); ++i)
q[i] = DomUtils::qrealFromDom(element, attribute[i], ((i<3)?0.0:1.0));
}
/*! Returns the Quaternion associated 4x4 OpenGL rotation matrix.
Use \c glMultMatrixd(q.matrix()) to apply the rotation represented by Quaternion \c q to the
current OpenGL matrix.
See also getMatrix(), getRotationMatrix() and inverseMatrix().
\attention The result is only valid until the next call to matrix(). Use it immediately (as shown
above) or consider using getMatrix() instead.
\attention The matrix is given in OpenGL format (row-major order) and is the transpose of the
actual mathematical European representation. Consider using getRotationMatrix() instead. */
const GLdouble* Quaternion::matrix() const
{
static GLdouble m[4][4];
getMatrix(m);
return (const GLdouble*)(m);
}
/*! Fills \p m with the OpenGL representation of the Quaternion rotation.
Use matrix() if you do not need to store this matrix and simply want to alter the current OpenGL
matrix. See also getInverseMatrix() and Frame::getMatrix(). */
void Quaternion::getMatrix(GLdouble m[4][4]) const
{
const qreal q00 = 2.0 * q[0] * q[0];
const qreal q11 = 2.0 * q[1] * q[1];
const qreal q22 = 2.0 * q[2] * q[2];
const qreal q01 = 2.0 * q[0] * q[1];
const qreal q02 = 2.0 * q[0] * q[2];
const qreal q03 = 2.0 * q[0] * q[3];
const qreal q12 = 2.0 * q[1] * q[2];
const qreal q13 = 2.0 * q[1] * q[3];
const qreal q23 = 2.0 * q[2] * q[3];
m[0][0] = 1.0 - q11 - q22;
m[1][0] = q01 - q23;
m[2][0] = q02 + q13;
m[0][1] = q01 + q23;
m[1][1] = 1.0 - q22 - q00;
m[2][1] = q12 - q03;
m[0][2] = q02 - q13;
m[1][2] = q12 + q03;
m[2][2] = 1.0 - q11 - q00;
m[0][3] = 0.0;
m[1][3] = 0.0;
m[2][3] = 0.0;
m[3][0] = 0.0;
m[3][1] = 0.0;
m[3][2] = 0.0;
m[3][3] = 1.0;
}
/*! Same as getMatrix(), but with a \c GLdouble[16] parameter. See also getInverseMatrix() and Frame::getMatrix(). */
void Quaternion::getMatrix(GLdouble m[16]) const
{
static GLdouble mat[4][4];
getMatrix(mat);
int count = 0;
for (int i=0; i<4; ++i)
for (int j=0; j<4; ++j)
m[count++] = mat[i][j];
}
/*! Fills \p m with the 3x3 rotation matrix associated with the Quaternion.
See also getInverseRotationMatrix().
\attention \p m uses the European mathematical representation of the rotation matrix. Use matrix()
and getMatrix() to retrieve the OpenGL transposed version. */
void Quaternion::getRotationMatrix(qreal m[3][3]) const
{
static GLdouble mat[4][4];
getMatrix(mat);
for (int i=0; i<3; ++i)
for (int j=0; j<3; ++j)
// Beware of transposition
m[i][j] = qreal(mat[j][i]);
}
/*! Returns the associated 4x4 OpenGL \e inverse rotation matrix. This is simply the matrix() of the
inverse().
\attention The result is only valid until the next call to inverseMatrix(). Use it immediately (as
in \c glMultMatrixd(q.inverseMatrix())) or use getInverseMatrix() instead.
\attention The matrix is given in OpenGL format (row-major order) and is the transpose of the
actual mathematical European representation. Consider using getInverseRotationMatrix() instead. */
const GLdouble* Quaternion::inverseMatrix() const
{
static GLdouble m[4][4];
getInverseMatrix(m);
return (const GLdouble*)(m);
}
/*! Fills \p m with the OpenGL matrix corresponding to the inverse() rotation.
Use inverseMatrix() if you do not need to store this matrix and simply want to alter the current
OpenGL matrix. See also getMatrix(). */
void Quaternion::getInverseMatrix(GLdouble m[4][4]) const
{
inverse().getMatrix(m);
}
/*! Same as getInverseMatrix(), but with a \c GLdouble[16] parameter. See also getMatrix(). */
void Quaternion::getInverseMatrix(GLdouble m[16]) const
{
inverse().getMatrix(m);
}
/*! \p m is set to the 3x3 \e inverse rotation matrix associated with the Quaternion.
\attention This is the classical mathematical rotation matrix. The OpenGL format uses its
transposed version. See inverseMatrix() and getInverseMatrix(). */
void Quaternion::getInverseRotationMatrix(qreal m[3][3]) const
{
static GLdouble mat[4][4];
getInverseMatrix(mat);
for (int i=0; i<3; ++i)
for (int j=0; j<3; ++j)
// Beware of transposition
m[i][j] = qreal(mat[j][i]);
}
/*! Returns the slerp interpolation of Quaternions \p a and \p b, at time \p t.
\p t should range in [0,1]. Result is \p a when \p t=0 and \p b when \p t=1.
When \p allowFlip is \c true (default) the slerp interpolation will always use the "shortest path"
between the Quaternions' orientations, by "flipping" the source Quaternion if needed (see
negate()). */
Quaternion Quaternion::slerp(const Quaternion& a, const Quaternion& b, qreal t, bool allowFlip)
{
qreal cosAngle = Quaternion::dot(a, b);
qreal c1, c2;
// Linear interpolation for close orientations
if ((1.0 - fabs(cosAngle)) < 0.01)
{
c1 = 1.0 - t;
c2 = t;
}
else
{
// Spherical interpolation
qreal angle = acos(fabs(cosAngle));
qreal sinAngle = sin(angle);
c1 = sin(angle * (1.0 - t)) / sinAngle;
c2 = sin(angle * t) / sinAngle;
}
// Use the shortest path
if (allowFlip && (cosAngle < 0.0))
c1 = -c1;
return Quaternion(c1*a[0] + c2*b[0], c1*a[1] + c2*b[1], c1*a[2] + c2*b[2], c1*a[3] + c2*b[3]);
}
/*! Returns the slerp interpolation of the two Quaternions \p a and \p b, at time \p t, using
tangents \p tgA and \p tgB.
The resulting Quaternion is "between" \p a and \p b (result is \p a when \p t=0 and \p b for \p
t=1).
Use squadTangent() to define the Quaternion tangents \p tgA and \p tgB. */
Quaternion Quaternion::squad(const Quaternion& a, const Quaternion& tgA, const Quaternion& tgB, const Quaternion& b, qreal t)
{
Quaternion ab = Quaternion::slerp(a, b, t);
Quaternion tg = Quaternion::slerp(tgA, tgB, t, false);
return Quaternion::slerp(ab, tg, 2.0*t*(1.0-t), false);
}
/*! Returns the logarithm of the Quaternion. See also exp(). */
Quaternion Quaternion::log()
{
qreal len = sqrt(q[0]*q[0] + q[1]*q[1] + q[2]*q[2]);
if (len < 1E-6)
return Quaternion(q[0], q[1], q[2], 0.0);
else
{
qreal coef = acos(q[3]) / len;
return Quaternion(q[0]*coef, q[1]*coef, q[2]*coef, 0.0);
}
}
/*! Returns the exponential of the Quaternion. See also log(). */
Quaternion Quaternion::exp()
{
qreal theta = sqrt(q[0]*q[0] + q[1]*q[1] + q[2]*q[2]);
if (theta < 1E-6)
return Quaternion(q[0], q[1], q[2], cos(theta));
else
{
qreal coef = sin(theta) / theta;
return Quaternion(q[0]*coef, q[1]*coef, q[2]*coef, cos(theta));
}
}
/*! Returns log(a. inverse() * b). Useful for squadTangent(). */
Quaternion Quaternion::lnDif(const Quaternion& a, const Quaternion& b)
{
Quaternion dif = a.inverse()*b;
dif.normalize();
return dif.log();
}
/*! Returns a tangent Quaternion for \p center, defined by \p before and \p after Quaternions.
Useful for smooth spline interpolation of Quaternion with squad() and slerp(). */
Quaternion Quaternion::squadTangent(const Quaternion& before, const Quaternion& center, const Quaternion& after)
{
Quaternion l1 = Quaternion::lnDif(center,before);
Quaternion l2 = Quaternion::lnDif(center,after);
Quaternion e;
for (int i=0; i<4; ++i)
e.q[i] = -0.25 * (l1.q[i] + l2.q[i]);
e = center*(e.exp());
// if (Quaternion::dot(e,b) < 0.0)
// e.negate();
return e;
}
ostream& operator<<(ostream& o, const Quaternion& Q)
{
return o << Q[0] << '\t' << Q[1] << '\t' << Q[2] << '\t' << Q[3];
}
/*! Returns a random unit Quaternion.
You can create a randomly directed unit vector using:
\code
Vec randomDir = Quaternion::randomQuaternion() * Vec(1.0, 0.0, 0.0); // or any other Vec
\endcode
\note This function uses rand() to create pseudo-random numbers and the random number generator can
be initialized using srand().*/
Quaternion Quaternion::randomQuaternion()
{
// The rand() function is not very portable and may not be available on your system.
// Add the appropriate include or replace by an other random function in case of problem.
qreal seed = rand()/(qreal)RAND_MAX;
qreal r1 = sqrt(1.0 - seed);
qreal r2 = sqrt(seed);
qreal t1 = 2.0 * M_PI * (rand()/(qreal)RAND_MAX);
qreal t2 = 2.0 * M_PI * (rand()/(qreal)RAND_MAX);
return Quaternion(sin(t1)*r1, cos(t1)*r1, sin(t2)*r2, cos(t2)*r2);
}
| 17,379 | 30.428571 | 125 | cpp |
octomap | octomap-master/octovis/src/extern/QGLViewer/quaternion.h | /****************************************************************************
Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.
This file is part of the QGLViewer library version 2.6.3.
http://www.libqglviewer.com - [email protected]
This file may be used under the terms of the GNU General Public License
versions 2.0 or 3.0 as published by the Free Software Foundation and
appearing in the LICENSE file included in the packaging of this file.
In addition, as a special exception, Gilles Debunne gives you certain
additional rights, described in the file GPL_EXCEPTION in this package.
libQGLViewer uses dual licensing. Commercial/proprietary software must
purchase a libQGLViewer Commercial License.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*****************************************************************************/
#ifndef QGLVIEWER_QUATERNION_H
#define QGLVIEWER_QUATERNION_H
#include "vec.h"
#include <math.h>
#include <iostream>
namespace qglviewer {
/*! \brief The Quaternion class represents 3D rotations and orientations.
\class Quaternion quaternion.h QGLViewer/quaternion.h
The Quaternion is an appropriate (although not very intuitive) representation for 3D rotations and
orientations. Many tools are provided to ease the definition of a Quaternion: see constructors,
setAxisAngle(), setFromRotationMatrix(), setFromRotatedBasis().
You can apply the rotation represented by the Quaternion to 3D points using rotate() and
inverseRotate(). See also the Frame class that represents a coordinate system and provides other
conversion functions like Frame::coordinatesOf() and Frame::transformOf().
You can apply the Quaternion \c q rotation to the OpenGL matrices using:
\code
glMultMatrixd(q.matrix());
// equvalent to glRotate(q.angle()*180.0/M_PI, q.axis().x, q.axis().y, q.axis().z);
\endcode
Quaternion is part of the \c qglviewer namespace, specify \c qglviewer::Quaternion or use the qglviewer
namespace: \code using namespace qglviewer; \endcode
<h3>Internal representation</h3>
The internal representation of a Quaternion corresponding to a rotation around axis \c axis, with an angle
\c alpha is made of four qreals (i.e. doubles) q[i]:
\code
{q[0],q[1],q[2]} = sin(alpha/2) * {axis[0],axis[1],axis[2]}
q[3] = cos(alpha/2)
\endcode
Note that certain implementations place the cosine term in first position (instead of last here).
The Quaternion is always normalized, so that its inverse() is actually its conjugate.
See also the Vec and Frame classes' documentations.
\nosubgrouping */
class QGLVIEWER_EXPORT Quaternion
{
public:
/*! @name Defining a Quaternion */
//@{
/*! Default constructor, builds an identity rotation. */
Quaternion()
{ q[0]=q[1]=q[2]=0.0; q[3]=1.0; }
/*! Constructor from rotation axis (non null) and angle (in radians). See also setAxisAngle(). */
Quaternion(const Vec& axis, qreal angle)
{
setAxisAngle(axis, angle);
}
Quaternion(const Vec& from, const Vec& to);
/*! Constructor from the four values of a Quaternion. First three values are axis*sin(angle/2) and
last one is cos(angle/2).
\attention The identity Quaternion is Quaternion(0,0,0,1) and \e not Quaternion(0,0,0,0) (which is
not unitary). The default Quaternion() creates such identity Quaternion. */
Quaternion(qreal q0, qreal q1, qreal q2, qreal q3)
{ q[0]=q0; q[1]=q1; q[2]=q2; q[3]=q3; }
/*! Copy constructor. */
Quaternion(const Quaternion& Q)
{ for (int i=0; i<4; ++i) q[i] = Q.q[i]; }
/*! Equal operator. */
Quaternion& operator=(const Quaternion& Q)
{
for (int i=0; i<4; ++i)
q[i] = Q.q[i];
return (*this);
}
/*! Sets the Quaternion as a rotation of axis \p axis and angle \p angle (in radians).
\p axis does not need to be normalized. A null \p axis will result in an identity Quaternion. */
void setAxisAngle(const Vec& axis, qreal angle)
{
const qreal norm = axis.norm();
if (norm < 1E-8)
{
// Null rotation
q[0] = 0.0; q[1] = 0.0; q[2] = 0.0; q[3] = 1.0;
}
else
{
const qreal sin_half_angle = sin(angle / 2.0);
q[0] = sin_half_angle*axis[0]/norm;
q[1] = sin_half_angle*axis[1]/norm;
q[2] = sin_half_angle*axis[2]/norm;
q[3] = cos(angle / 2.0);
}
}
/*! Sets the Quaternion value. See the Quaternion(qreal, qreal, qreal, qreal) constructor documentation. */
void setValue(qreal q0, qreal q1, qreal q2, qreal q3)
{ q[0]=q0; q[1]=q1; q[2]=q2; q[3]=q3; }
#ifndef DOXYGEN
void setFromRotationMatrix(const float m[3][3]);
void setFromRotatedBase(const Vec& X, const Vec& Y, const Vec& Z);
#endif
void setFromRotationMatrix(const qreal m[3][3]);
void setFromRotatedBasis(const Vec& X, const Vec& Y, const Vec& Z);
//@}
/*! @name Accessing values */
//@{
Vec axis() const;
qreal angle() const;
void getAxisAngle(Vec& axis, qreal& angle) const;
/*! Bracket operator, with a constant return value. \p i must range in [0..3]. See the Quaternion(qreal, qreal, qreal, qreal) documentation. */
qreal operator[](int i) const { return q[i]; }
/*! Bracket operator returning an l-value. \p i must range in [0..3]. See the Quaternion(qreal, qreal, qreal, qreal) documentation. */
qreal& operator[](int i) { return q[i]; }
//@}
/*! @name Rotation computations */
//@{
/*! Returns the composition of the \p a and \p b rotations.
The order is important. When applied to a Vec \c v (see operator*(const Quaternion&, const Vec&)
and rotate()) the resulting Quaternion acts as if \p b was applied first and then \p a was
applied. This is obvious since the image \c v' of \p v by the composited rotation satisfies: \code
v'= (a*b) * v = a * (b*v) \endcode
Note that a*b usually differs from b*a.
\attention For efficiency reasons, the resulting Quaternion is not normalized. Use normalize() in
case of numerical drift with small rotation composition. */
friend Quaternion operator*(const Quaternion& a, const Quaternion& b)
{
return Quaternion(a.q[3]*b.q[0] + b.q[3]*a.q[0] + a.q[1]*b.q[2] - a.q[2]*b.q[1],
a.q[3]*b.q[1] + b.q[3]*a.q[1] + a.q[2]*b.q[0] - a.q[0]*b.q[2],
a.q[3]*b.q[2] + b.q[3]*a.q[2] + a.q[0]*b.q[1] - a.q[1]*b.q[0],
a.q[3]*b.q[3] - b.q[0]*a.q[0] - a.q[1]*b.q[1] - a.q[2]*b.q[2]);
}
/*! Quaternion rotation is composed with \p q.
See operator*(), since this is equivalent to \c this = \c this * \p q.
\note For efficiency reasons, the resulting Quaternion is not normalized.
You may normalize() it after each application in case of numerical drift. */
Quaternion& operator*=(const Quaternion &quat)
{
*this = (*this)*quat;
return *this;
}
/*! Returns the image of \p v by the rotation \p q.
Same as q.rotate(v). See rotate() and inverseRotate(). */
friend Vec operator*(const Quaternion& quat, const Vec& v)
{
return quat.rotate(v);
}
Vec rotate(const Vec& v) const;
Vec inverseRotate(const Vec& v) const;
//@}
/*! @name Inversion */
//@{
/*! Returns the inverse Quaternion (inverse rotation).
Result has a negated axis() direction and the same angle(). A composition (see operator*()) of a
Quaternion and its inverse() results in an identity function.
Use invert() to actually modify the Quaternion. */
Quaternion inverse() const { return Quaternion(-q[0], -q[1], -q[2], q[3]); }
/*! Inverses the Quaternion (same rotation angle(), but negated axis()).
See also inverse(). */
void invert() { q[0] = -q[0]; q[1] = -q[1]; q[2] = -q[2]; }
/*! Negates all the coefficients of the Quaternion.
This results in an other representation of the \e same rotation (opposite rotation angle, but with
a negated axis direction: the two cancel out). However, note that the results of axis() and
angle() are unchanged after a call to this method since angle() always returns a value in [0,pi].
This method is mainly useful for Quaternion interpolation, so that the spherical
interpolation takes the shortest path on the unit sphere. See slerp() for details. */
void negate() { invert(); q[3] = -q[3]; }
/*! Normalizes the Quaternion coefficients.
This method should not need to be called since we only deal with unit Quaternions. This is however
useful to prevent numerical drifts, especially with small rotational increments. See also
normalized(). */
qreal normalize()
{
const qreal norm = sqrt(q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
for (int i=0; i<4; ++i)
q[i] /= norm;
return norm;
}
/*! Returns a normalized version of the Quaternion.
See also normalize(). */
Quaternion normalized() const
{
qreal Q[4];
const qreal norm = sqrt(q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
for (int i=0; i<4; ++i)
Q[i] = q[i] / norm;
return Quaternion(Q[0], Q[1], Q[2], Q[3]);
}
//@}
/*! @name Associated matrix */
//@{
const GLdouble* matrix() const;
void getMatrix(GLdouble m[4][4]) const;
void getMatrix(GLdouble m[16]) const;
void getRotationMatrix(qreal m[3][3]) const;
const GLdouble* inverseMatrix() const;
void getInverseMatrix(GLdouble m[4][4]) const;
void getInverseMatrix(GLdouble m[16]) const;
void getInverseRotationMatrix(qreal m[3][3]) const;
//@}
/*! @name Slerp interpolation */
//@{
static Quaternion slerp(const Quaternion& a, const Quaternion& b, qreal t, bool allowFlip=true);
static Quaternion squad(const Quaternion& a, const Quaternion& tgA, const Quaternion& tgB, const Quaternion& b, qreal t);
/*! Returns the "dot" product of \p a and \p b: a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]. */
static qreal dot(const Quaternion& a, const Quaternion& b) { return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]; }
Quaternion log();
Quaternion exp();
static Quaternion lnDif(const Quaternion& a, const Quaternion& b);
static Quaternion squadTangent(const Quaternion& before, const Quaternion& center, const Quaternion& after);
//@}
/*! @name Random Quaternion */
//@{
static Quaternion randomQuaternion();
//@}
/*! @name XML representation */
//@{
explicit Quaternion(const QDomElement& element);
QDomElement domElement(const QString& name, QDomDocument& document) const;
void initFromDOMElement(const QDomElement& element);
//@}
#ifdef DOXYGEN
/*! @name Output stream */
//@{
/*! Output stream operator. Enables debugging code like:
\code
Quaternion rot(...);
cout << "Rotation=" << rot << endl;
\endcode */
std::ostream& operator<<(std::ostream& o, const qglviewer::Vec&);
//@}
#endif
private:
/*! The internal data representation is private, use operator[] to access values. */
qreal q[4];
};
} // namespace
std::ostream& operator<<(std::ostream& o, const qglviewer::Quaternion&);
#endif // QGLVIEWER_QUATERNION_H
| 10,761 | 33.49359 | 144 | h |