tgStructure.h

Go to the documentation of this file.

/*
 * Copyright © 2012, United States Government, as represented by the
 * Administrator of the National Aeronautics and Space Administration.
 * All rights reserved.
 * 
 * The NASA Tensegrity Robotics Toolkit (NTRT) v1 platform is licensed
 * under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0.
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
*/

#ifndef TG_STRUCTURE_H
#define TG_STRUCTURE_H

// This library
#include "tgNodes.h"
#include "tgPairs.h"
// The NTRT Core Library
#include "core/tgTaggable.h"
// The C++ Standard Library
#include <string>
#include <vector>
#include <queue>

// Forward declarations
class btQuaternion;
class btVector3;
class tgNode;
class tgTags;

class tgStructure : public tgTaggable
{
public:
    
    tgStructure();

    tgStructure(const tgStructure& orig);

    tgStructure(const tgTags& tags);

    tgStructure(const std::string& space_separated_tags);

    virtual ~tgStructure();

    void addNode(double x, double y, double z, std::string tags = "");
    
    void addNode(tgNode& newNode);

    void addPair(int fromNodeIdx, int toNodeIdx, std::string tags = "");
    
    void addPair(const btVector3& from, const btVector3& to, std::string tags = "");

    /*
     * Removes the pair that's passed in as a parameter from the structure
     * (added to accommodate structures encoded in YAML)
     * @param[in] pair a reference to the pair to remove
     */
    void removePair(const tgPair& pair);

    void move(const btVector3& offset);
    
    void addRotation(const btVector3& fixedPoint,
             const btVector3& axis,
             double angle);

    void addRotation(const btVector3& fixedPoint,
             const btVector3& fromOrientation,
             const btVector3& toOrientation);

    void addRotation(const btVector3& fixedPoint,
             const btQuaternion& rotation);

    /*
     * Scales structure by a scale factor
     * @param[in] scaleFactor the scale factor by which to scale the structure
     */
    void scale(double scaleFactor);

    /*
     * Scales structure relative to a reference point
     * @param[in] referencePoint a btVector3 reference point to scale the structure from/to
     * @param[in] scaleFactor the scale factor by which to scale the structure
     */
    void scale(const btVector3& referencePoint, double scaleFactor);

    void addChild(tgStructure* child);    

    void addChild(const tgStructure& child);

    const tgNodes& getNodes() const
    {
        return m_nodes;
    }

    tgNode& findNode(const std::string& name);

    btVector3 getCentroid() const;

    const tgPairs& getPairs() const
    {
        return m_pairs;
    }

    tgPair& findPair(const btVector3& from, const btVector3& to);
                
    const std::vector<tgStructure*>& getChildren() const
    {
        return m_children;
    }

    tgStructure& findChild(const std::string& name);

private:

    tgNodes m_nodes;

    tgPairs m_pairs;

    // we own these
    std::vector<tgStructure*> m_children;
    
};

 /*
inline std::ostream&
operator<<(std::ostream& os, const tgStructure& structure) 
{
  os << "tgStructure with the following tgNodes and tgPairs: " << std::endl;
  os << structure.getNodes() << std::endl;
  os << structure.getPairs() << std::endl;
  os << "This tgStructure has the following children (also tgStructures): "
     << std::endl;

  // add each child structure's string output to the output stream
  std::vector<tgStructure*> children = structure.getChildren();
  for(std::size_t i= 0; i < children.size(); i++)
  {
    os << "Child " << i << ": " << std::endl;
    os << *(children[i]) << std::endl;
  }

  // If this tgStructure has no children, say so.
  if( children.size() == 0)
  {
    os << "(no children)" << std::endl;
  }

  return os;
}
*/



std::string asYamlElement(const tgStructure& structure, int indentLevel=0);

std::string asYamlItem(const tgStructure& structure, int indentLevel=0);

std::string asYamlItems(const std::vector<tgStructure*> structures, int indentLevel=0);

inline std::ostream&
operator<<(std::ostream& os, const tgStructure& structure) 
{
    //os << asYamlElement(os, structure) << std::endl;
    os << asYamlElement(structure) << std::endl;
    return os;
};

/*
std::string asYamlElement(const tgStructure& structure, int indentLevel=0)
{
    std::stringstream os;
    std::string indent = std::string(2 * (indentLevel), ' ');
    os << indent << "structure:" << std::endl;
    os << indent << "  tags: " << asYamlList(structure.getTags()) << std::endl;
    os << asYamlItems(structure.getNodes(), indentLevel + 1);
    os << asYamlItems(structure.getPairs(), indentLevel + 1);
    os << asYamlItems(structure.getChildren(), indentLevel + 1);
    return os.str();
};

inline std::string asYamlItem(const tgStructure& structure, int indentLevel=0)
{
    std::stringstream os;
    std::string indent = std::string(2 * (indentLevel), ' ');
    os << indent << "- tags: " << asYamlList(structure.getTags()) << std::endl;
    os << asYamlItems(structure.getNodes(), indentLevel + 1);
    os << asYamlItems(structure.getPairs(), indentLevel + 1);
    os << asYamlItems(structure.getChildren(), indentLevel + 1);
    return os.str();
};

inline std::string asYamlItems(const std::vector<tgStructure*> structures, int indentLevel)
{
    std::stringstream os;
    std::string indent = std::string(2 * (indentLevel), ' ');
    if (structures.size() == 0) {
        os << indent << "structures: []" << std::endl;
        return os.str();
    }

    os << indent << "structures:" << std::endl;
    for(size_t i = 0; i < structures.size(); i++)
    {
        os << asYamlItem(*structures[i], indentLevel+1);
    }
    return os.str();
};

*/
#endif