lemongraph 0.0.1

data/ext/lemon-1.3.1/lemon/color.h

@@ -0,0 +1,204 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2009
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+#ifndef LEMON_COLOR_H
+#define LEMON_COLOR_H
+
+#include<vector>
+#include<lemon/math.h>
+#include<lemon/maps.h>
+
+
+///\ingroup misc
+///\file
+///\brief Tools to manage RGB colors.
+
+namespace lemon {
+
+
+  /// \addtogroup misc
+  /// @{
+
+  ///Data structure representing RGB colors.
+
+  ///Data structure representing RGB colors.
+  class Color
+  {
+    double _r,_g,_b;
+  public:
+    ///Default constructor
+    Color() {}
+    ///Constructor
+    Color(double r,double g,double b) :_r(r),_g(g),_b(b) {};
+    ///Set the red component
+    double & red() {return _r;}
+    ///Return the red component
+    const double & red() const {return _r;}
+    ///Set the green component
+    double & green() {return _g;}
+    ///Return the green component
+    const double & green() const {return _g;}
+    ///Set the blue component
+    double & blue() {return _b;}
+    ///Return the blue component
+    const double & blue() const {return _b;}
+    ///Set the color components
+    void set(double r,double g,double b) { _r=r;_g=g;_b=b; };
+  };
+
+  /// White color constant
+  extern const Color WHITE;
+  /// Black color constant
+  extern const Color BLACK;
+  /// Red color constant
+  extern const Color RED;
+  /// Green color constant
+  extern const Color GREEN;
+  /// Blue color constant
+  extern const Color BLUE;
+  /// Yellow color constant
+  extern const Color YELLOW;
+  /// Magenta color constant
+  extern const Color MAGENTA;
+  /// Cyan color constant
+  extern const Color CYAN;
+  /// Grey color constant
+  extern const Color GREY;
+  /// Dark red color constant
+  extern const Color DARK_RED;
+  /// Dark green color constant
+  extern const Color DARK_GREEN;
+  /// Drak blue color constant
+  extern const Color DARK_BLUE;
+  /// Dark yellow color constant
+  extern const Color DARK_YELLOW;
+  /// Dark magenta color constant
+  extern const Color DARK_MAGENTA;
+  /// Dark cyan color constant
+  extern const Color DARK_CYAN;
+
+  ///Map <tt>int</tt>s to different <tt>Color</tt>s
+
+  ///This map assigns one of the predefined \ref Color "Color"s to
+  ///each <tt>int</tt>. It is possible to change the colors as well as
+  ///their number. The integer range is cyclically mapped to the
+  ///provided set of colors.
+  ///
+  ///This is a true \ref concepts::ReferenceMap "reference map", so
+  ///you can also change the actual colors.
+
+  class Palette : public MapBase<int,Color>
+  {
+    std::vector<Color> colors;
+  public:
+    ///Constructor
+
+    ///Constructor.
+    ///\param have_white Indicates whether white is among the
+    ///provided initial colors (\c true) or not (\c false). If it is true,
+    ///white will be assigned to \c 0.
+    ///\param num The number of the allocated colors. If it is \c -1,
+    ///the default color configuration is set up (26 color plus optionaly the
+    ///white).  If \c num is less then 26/27 then the default color
+    ///list is cut. Otherwise the color list is filled repeatedly with
+    ///the default color list.  (The colors can be changed later on.)
+    Palette(bool have_white=false,int num=-1)
+    {
+      if (num==0) return;
+      do {
+        if(have_white) colors.push_back(Color(1,1,1));
+
+        colors.push_back(Color(0,0,0));
+        colors.push_back(Color(1,0,0));
+        colors.push_back(Color(0,1,0));
+        colors.push_back(Color(0,0,1));
+        colors.push_back(Color(1,1,0));
+        colors.push_back(Color(1,0,1));
+        colors.push_back(Color(0,1,1));
+
+        colors.push_back(Color(.5,0,0));
+        colors.push_back(Color(0,.5,0));
+        colors.push_back(Color(0,0,.5));
+        colors.push_back(Color(.5,.5,0));
+        colors.push_back(Color(.5,0,.5));
+        colors.push_back(Color(0,.5,.5));
+
+        colors.push_back(Color(.5,.5,.5));
+        colors.push_back(Color(1,.5,.5));
+        colors.push_back(Color(.5,1,.5));
+        colors.push_back(Color(.5,.5,1));
+        colors.push_back(Color(1,1,.5));
+        colors.push_back(Color(1,.5,1));
+        colors.push_back(Color(.5,1,1));
+
+        colors.push_back(Color(1,.5,0));
+        colors.push_back(Color(.5,1,0));
+        colors.push_back(Color(1,0,.5));
+        colors.push_back(Color(0,1,.5));
+        colors.push_back(Color(0,.5,1));
+        colors.push_back(Color(.5,0,1));
+      } while(int(colors.size())<num);
+      if(num>=0) colors.resize(num);
+    }
+    ///\e
+    Color &operator[](int i)
+    {
+      return colors[i%colors.size()];
+    }
+    ///\e
+    const Color &operator[](int i) const
+    {
+      return colors[i%colors.size()];
+    }
+    ///\e
+    void set(int i,const Color &c)
+    {
+      colors[i%colors.size()]=c;
+    }
+    ///Adds a new color to the end of the color list.
+    void add(const Color &c)
+    {
+      colors.push_back(c);
+    }
+
+    ///Sets the number of the existing colors.
+    void resize(int s) { colors.resize(s);}
+    ///Returns the number of the existing colors.
+    int size() const { return int(colors.size());}
+  };
+
+  ///Returns a visibly distinct \ref Color
+
+  ///Returns a \ref Color which is as different from the given parameter
+  ///as it is possible.
+  inline Color distantColor(const Color &c)
+  {
+    return Color(c.red()<.5?1:0,c.green()<.5?1:0,c.blue()<.5?1:0);
+  }
+  ///Returns black for light colors and white for the dark ones.
+
+  ///Returns black for light colors and white for the dark ones.
+  inline Color distantBW(const Color &c){
+    return (.2125*c.red()+.7154*c.green()+.0721*c.blue())<.5 ? WHITE : BLACK;
+  }
+
+  /// @}
+
+} //END OF NAMESPACE LEMON
+
+#endif // LEMON_COLOR_H

data/ext/lemon-1.3.1/lemon/concept_check.h

@@ -0,0 +1,77 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2013
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+// The contents of this file was inspired by the concept checking
+// utility of the BOOST library (http://www.boost.org).
+
+///\file
+///\brief Basic utilities for concept checking.
+///
+
+#ifndef LEMON_CONCEPT_CHECK_H
+#define LEMON_CONCEPT_CHECK_H
+
+namespace lemon {
+
+  /*
+    "inline" is used for ignore_unused_variable_warning()
+    and function_requires() to make sure there is no
+    overtarget with g++.
+  */
+
+  template <class T> inline void ignore_unused_variable_warning(const T&) { }
+  template <class T1, class T2>
+  inline void ignore_unused_variable_warning(const T1&, const T2&) { }
+  template <class T1, class T2, class T3>
+  inline void ignore_unused_variable_warning(const T1&, const T2&,
+                                             const T3&) { }
+  template <class T1, class T2, class T3, class T4>
+  inline void ignore_unused_variable_warning(const T1&, const T2&,
+                                             const T3&, const T4&) { }
+  template <class T1, class T2, class T3, class T4, class T5>
+  inline void ignore_unused_variable_warning(const T1&, const T2&,
+                                             const T3&, const T4&,
+                                             const T5&) { }
+  template <class T1, class T2, class T3, class T4, class T5, class T6>
+  inline void ignore_unused_variable_warning(const T1&, const T2&,
+                                             const T3&, const T4&,
+                                             const T5&, const T6&) { }
+
+  ///\e
+  template <class Concept>
+  inline void function_requires()
+  {
+#if !defined(NDEBUG)
+    void (Concept::*x)() = & Concept::constraints;
+    ::lemon::ignore_unused_variable_warning(x);
+#endif
+  }
+
+  ///\e
+  template <typename Concept, typename Type>
+  inline void checkConcept() {
+#if !defined(NDEBUG)
+    typedef typename Concept::template Constraints<Type> ConceptCheck;
+    void (ConceptCheck::*x)() = & ConceptCheck::constraints;
+    ::lemon::ignore_unused_variable_warning(x);
+#endif
+  }
+
+} // namespace lemon
+
+#endif // LEMON_CONCEPT_CHECK_H