//==============================================================================
void VoxelGridShape::updateOccupancy(
const Eigen::Vector3d& point, bool occupied)
{
mOctree->updateNode(toPoint3d(point), occupied);
incrementVersion();
}
//==============================================================================
void VoxelGridShape::updateOccupancy(
const Eigen::Vector3d& from, const Eigen::Vector3d& to)
{
mOctree->insertRay(toPoint3d(from), toPoint3d(to));
incrementVersion();
}
void MetaFile::mknod( const std::string& path ) //, mode_t type, mode_t mode )
{
// insert the entry if the file is in fact new
m_sql << "INSERT OR IGNORE INTO entries ("
"path, "
"subscribed "
") VALUES ("
<< "'" << path << "', "
<< 0 <<
")";
// update subscription to the file
m_sql << "UPDATE entries SET subscribed=1 WHERE path='"
<< path << "'";
// set the initial version of the file
m_sql << "INSERT OR IGNORE INTO version ("
"path, "
"client, "
"version "
") VALUES ("
<< "'" << path << "', "
<< 0 << ", "
<< 0 <<
")";
incrementVersion();
}
//==============================================================================
void CapsuleShape::setHeight(double height)
{
assert(0.0 < height);
mHeight = height;
mIsBoundingBoxDirty = true;
mIsVolumeDirty = true;
incrementVersion();
}
//==============================================================================
void CylinderShape::setHeight(double _height)
{
assert(0.0 < _height);
mHeight = _height;
mIsBoundingBoxDirty = true;
mIsVolumeDirty = true;
incrementVersion();
}
//==============================================================================
void CapsuleShape::setRadius(double radius)
{
assert(0.0 < radius);
mRadius = radius;
mIsBoundingBoxDirty = true;
mIsVolumeDirty = true;
incrementVersion();
}
//==============================================================================
void CylinderShape::setRadius(double _radius)
{
assert(0.0 < _radius);
mRadius = _radius;
mIsBoundingBoxDirty = true;
mIsVolumeDirty = true;
incrementVersion();
}
//==============================================================================
void VoxelGridShape::updateOccupancy(
const octomap::Pointcloud& pointCloud,
const Eigen::Vector3d& sensorOrigin,
const Eigen::Isometry3d& relativeTo)
{
mOctree->insertPointCloud(
pointCloud, toPoint3d(sensorOrigin), toPose6d(relativeTo));
incrementVersion();
}
//==============================================================================
void VoxelGridShape::updateOccupancy(
const octomap::Pointcloud& pointCloud,
const Eigen::Vector3d& sensorOrigin,
const Frame* relativeTo)
{
if (relativeTo == Frame::World())
{
mOctree->insertPointCloud(pointCloud, toPoint3d(sensorOrigin));
incrementVersion();
}
else
{
updateOccupancy(pointCloud, sensorOrigin, relativeTo->getWorldTransform());
}
}
//==============================================================================
void VoxelGridShape::setOctree(fcl_shared_ptr<octomap::OcTree> octree)
{
if (!octree)
{
dtwarn
<< "[VoxelGridShape] Attempting to assign null octree. Ignoring this "
<< "query.\n";
return;
}
if (octree == mOctree)
return;
mOctree = std::move(octree);
mIsBoundingBoxDirty = true;
mIsVolumeDirty = true;
incrementVersion();
}
//==============================================================================
void PlaneShape::setOffset(double _offset)
{
mOffset = _offset;
incrementVersion();
}
//==============================================================================
void PlaneShape::setNormal(const Eigen::Vector3d& _normal)
{
mNormal = _normal.normalized();
incrementVersion();
}
//==============================================================================
void ArrowShape::configureArrow(const Eigen::Vector3d& _tail,
const Eigen::Vector3d& _head,
const Properties& _properties)
{
mTail = _tail;
mHead = _head;
mProperties = _properties;
mProperties.mHeadLengthScale =
std::max(0.0, std::min(1.0, mProperties.mHeadLengthScale));
mProperties.mMinHeadLength = std::max(0.0, mProperties.mMinHeadLength);
mProperties.mMaxHeadLength = std::max(0.0, mProperties.mMaxHeadLength);
mProperties.mHeadRadiusScale = std::max(1.0, mProperties.mHeadRadiusScale);
double length = (mTail-mHead).norm();
double minHeadLength =
std::min(mProperties.mMinHeadLength,
mProperties.mDoubleArrow? length/2.0 : length);
double maxHeadLength =
std::min(mProperties.mMaxHeadLength,
mProperties.mDoubleArrow? length/2.0 : length);
double headLength = mProperties.mHeadLengthScale*length;
headLength = std::min(maxHeadLength, std::max(minHeadLength, headLength));
// construct the tail
if(mProperties.mDoubleArrow)
{
constructArrowTip(mMesh->mMeshes[0], headLength, 0, mProperties);
}
else
{
constructArrowTip(mMesh->mMeshes[0], 0, 0, mProperties);
}
// construct the main body
if(mProperties.mDoubleArrow)
{
constructArrowBody(mMesh->mMeshes[1], headLength, length-headLength,
mProperties);
}
else
{
constructArrowBody(mMesh->mMeshes[1], 0, length-headLength, mProperties);
}
// construct the head
constructArrowTip(mMesh->mMeshes[2], length-headLength, length, mProperties);
Eigen::Isometry3d tf(Eigen::Isometry3d::Identity());
tf.translation() = mTail;
Eigen::Vector3d v = mHead - mTail;
Eigen::Vector3d z = Eigen::Vector3d::UnitZ();
if(v.norm() > 0)
{
v.normalize();
Eigen::Vector3d axis = z.cross(v);
if(axis.norm() > 0)
axis.normalize();
else
axis = Eigen::Vector3d::UnitY(); // Any vector in the X/Y plane can be used
tf.rotate(Eigen::AngleAxisd(acos(z.dot(v)), axis));
}
aiNode* node = mMesh->mRootNode;
for(std::size_t i=0; i<4; ++i)
for(std::size_t j=0; j<4; ++j)
node->mTransformation[i][j] = tf(i,j);
mIsBoundingBoxDirty = true;
mIsVolumeDirty = true;
incrementVersion();
}
void Mesh::setTexCoords(const std::vector<glm::vec2>& texCoords) {
_texCoords = texCoords;
incrementVersion();
}
void Mesh::setNormals(const std::vector<glm::vec3>& normals)
{
_normals = normals;
_hasNormals = true;
incrementVersion();
}
void Mesh::setVertices(const std::vector<glm::vec3>& vertices) {
_vertices = vertices;
calculateNormals();
calculateBoundingBox();
incrementVersion();
}
void Rt::Value::Uuid::generate() {
uuid_generate(value);
incrementVersion();
notify(this);
}
void MetaFile::unlink( const std::string& path )
{
m_sql << "DELETE FROM entries WHERE path='" << path << "'";
m_sql << "DELETE FROM version WHERE path='" << path << "'";
incrementVersion();
}
void MetaFile::incrementVersion()
{
incrementVersion( m_subpath );
}
void CompositeScene::addScene(SceneRef scene) {
_scenes.push_back(scene);
calculateBoundingBox();
incrementVersion();
}
void CompositeScene::clear() {
_scenes.clear();
incrementVersion();
}
void Mesh::setIndices(const std::vector<unsigned int>& indices) {
_indices = indices;
incrementVersion();
}
void Mesh::setTexture(TextureRef texture) {
_texture = texture;
incrementVersion();
}
void Rt::Value::Uuid::set(Rt::uuid value) {
uuid_copy(this->value, value);
incrementVersion();
notify(this);
}
