geewhiz.h

/**************************************************************************
 * Copyright (c) 2006-2011 T. M. Murali                                   *
 *                                                                        *
 * This file is part of Biorithm.                                         *
 *                                                                        *
 * Biorithm 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 3 of the License, or      *
 * (at your option) any later version.                                    *
 *                                                                        *
 * Biorithm 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 Biorithm.  If not, see <http://www.gnu.org/licenses/>.      *
 *                                                                        *
 **************************************************************************/

#ifndef _GEEWHIZ_H
#define _GEEWHIZ_H

#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<map>
#include<sstream>
#include<algorithm>

#include "boost/lexical_cast.hpp"

//#include "global.h"
//#include "function.h"
#include "graph.h"

using namespace std;

namespace Graphwhiz
{

//poor information hiding for classes, but really these are structs in
//need of a constructor
class MyColor
{
public:
  unsigned int R, G, B;
  string RGB, RGBHTML;
  string blank;
  MyColor()
    {
      R = G = B = 0;
      // see MyColor::generate() to see how to initialise these colours.
      RGB="00,00,00";
      // should be hex.
      RGBHTML = "000000";
    }
  MyColor(unsigned int _R, unsigned int _G, unsigned int _B)
    {
      R = min(_R, (unsigned int) 255);
      G = min(_G, (unsigned int) 255);
      B = min(_B, (unsigned int) 255);
      _fillIn();
    }
  
  static MyColor generate(string id);
  
  string printHTML() const
    {
      if ("" == RGBHTML)
        cerr << "\tThere is no colour value." << endl;
      return blank+"\"#"+RGBHTML+"\"";
    }
  
  string printRGB() const
    {
      return(RGB);
    }

private:

  void _fillIn();

};

struct FunctionType
{
private:
  MyColor color;
  string url;

public:

  FunctionType()
      : color(), url("")
    {}

  FunctionType(MyColor c, string u = "")
      : color(c), url(u)
    {}
  
  FunctionType(string id, string url = "")
      : color(MyColor::generate(id)), url("")
    {}
  
  string getColorHTML() const
    {
      return color.printHTML();
    }
  string getColorRGB() const
    {
      return color.printRGB();
    }

  string getURL() const
    {
      return url;
    }
  
  void setColor(MyColor &c)
    {
      color = c;
    }
  
  void setURL(string u)
    {
      url = u;
    }
};


struct NodeInfo
{
public:
  NodeInfo()
      : name(""), label(""), type(""), functions(), url(""), color(), colors(), image(""), weight(0)
    {}
  
  // the string used to ID a node.
  string name;
  // the string used to label a node in the picture output by the visualisation programme.
  //
  // it is useful to differentiate between names and labels because we
  // often draw networks from more than 1 species. orthologous genes
  // can have the same name in > 1 species but we want to draw them as
  // separate nodes, while still using the same label for them in the
  // picture.
  string label;
  string type;
  vector< FunctionType > functions;
  string url;
  // this will colour the node.
  MyColor color;
  // this will be a rows of colours below the node, each row made up
  // on the colours in each sub-vector.
  vector< vector< MyColor > > colors;
  string image;
  // sometimes a node may have a weight that i want to draw.
  MyNT weight;

  // void addColour(MyColor &c)
  //   {
  //     colors.push_back(c);
  //   }
  
  void addFunction(FunctionType &f)
    {
      functions.push_back(f);
    }
  
};

class NodeType
{
public:
  string shape;
  string style;
  MyColor color;
  bool url,img;
  NodeType()
    {
      url=img=false;
      shape="rectangle";
    }

  string getDescriptionString(NodeInfo &n);

  string getHTMLString(NodeInfo & n);
  
};



// function object for comparing edge weights. 
// struct compareMyEdgeWeights : public binary_function< const myedge&, const myedge&, bool> 
// {
//   bool operator()(const myedge& __x, const myedge& __y) const
//     {
//       return(__x.weight < __y.weight);
//     }
// };


class EdgeType
{
public:
  MyColor color;
  string style;
  string direction;
  string head;
  string tail;
  string length;
  
  EdgeType()
    {
      style="solid";
      direction="none";
      head="normal";
      tail="none";
      length="1.0";
    }

  string print(double width=1);
};


class Geewhiz
{
private:
  MyGraph _graph;

  // should the output file cluster nodes of the same type into
  // subgraphs? _isDirected must also be true for dot to be used and
  // for the subgraphs to show up.
  bool _clusterNodes;
  
  bool _isDirected;

  // should I print edge labels.
  bool _printEdgeLabels;
  
  string _undirectedLayoutProgramme;
  string _directedLayoutProgramme;
  
  
  map< string, EdgeType > _edgeTypeDefinitions;
  
  map< string, FunctionType > _functionTypeDefinitions;
  
  map< string, NodeInfo > _nodeInfo;
  

  map< string, NodeType > _nodeTypeDefinitions;

public:
  Geewhiz()
      : _graph(), _clusterNodes(false), _isDirected(false), _printEdgeLabels(false),
        _undirectedLayoutProgramme("neato"), _directedLayoutProgramme("dot"),
        _edgeTypeDefinitions(),
        _functionTypeDefinitions(), _nodeInfo(), _nodeTypeDefinitions()
    {}

  void addFunctionTypeDefinition(string functionId, MyColor colour, string url = "")
    {
      addFunctionTypeDefinition(functionId, FunctionType(colour, url));
    }

  void addFunctionTypeDefinition(string id, const FunctionType &ftype)
    {
      _functionTypeDefinitions[id] = ftype;
    }
  
  
  
  void addNodeInfo(const NodeInfo &info)
    {
      static set< string > unknownNodeInfos;
      _nodeInfo[info.name] = info;
      if ((_nodeTypeDefinitions.end() == _nodeTypeDefinitions.find(info.type)) &&
          (unknownNodeInfos.end() != unknownNodeInfos.find(info.type)))
        // this is the first time i am seeing an known node info.
        {
          cerr << "Geewhiz::addNodeInfo(): unknown node type " << info.type
               << " for node " << info.name
               << ". Suppressing messages for other nodes with this type." << endl;
          unknownNodeInfos.insert(info.type);
        }
      
    }

  void setClusterNodes()
    {
      _clusterNodes = true;
    }

  bool getClusterNodes() const
    {
      return(_clusterNodes);
    }

  void setIsDirected()
    {
      _isDirected = true;
    }

  bool getIsDirected() const
    {
      return(_isDirected);
    }


  void getFunctionTypeDefinition(string id, FunctionType &type) const
    {
      map< string, FunctionType >::const_iterator ftdItr = _functionTypeDefinitions.find(id);
      if (_functionTypeDefinitions.end() != ftdItr)
        type = ftdItr->second;
      else
        {
          cerr << "\tNo function type definition exists for function \""
               << id << "\"" << endl;
          type = FunctionType("000000", "");
        }
    }
  
  bool getPrintEdgeLabels() const
    {
      return(_printEdgeLabels);
    }

  void setPrintEdgeLabels()
    {
      _printEdgeLabels = true;
    }
  
  void unsetPrintEdgeLabels()
    {
      _printEdgeLabels = false;
    }
  
  void setUndirectedLayoutProgramme(string prog) 
    {
      _undirectedLayoutProgramme = prog;
    }
  string getUndirectedLayoutProgramme()  const
    {
      return(_undirectedLayoutProgramme);
    }
  
  void setDirectedLayoutProgramme(string prog) 
    {
      _directedLayoutProgramme = prog;
    }
  string getDirectedLayoutProgramme()  const
    {
      return(_directedLayoutProgramme);
    }
  
  void layout(string outfile, const set< string > &formats, ostream &logStream, bool runGraphviz = true);
  
  void printDot(string outfile);
  
  void readEdges(string file)
    {
      _graph.read(file);
    }

  void readEdgeTypeDefinitions(string file);

  void readNodeInfo(string file);  
//     {
//       _graph.readNodeTypes(file);
//     }
  
  void readNodeTypeDefinitions(string file);


  void readParameters(string filename);



  void setGraph(const MyGraph &graph)
    {
      _graph = graph;
    }
  
};

}; // end of namespace Geewhiz.

#endif // _GEEWHIZ_H