colorize.hh

// Copyright (C) 2008, 2009 EPITA Research and Development Laboratory
// (LRDE)
//
// This file is part of Olena.
//
// Olena 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, version 2 of the License.
//
// Olena 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 Olena.  If not, see <http://www.gnu.org/licenses/>.
//
// As a special exception, you may use this file as part of a free
// software project without restriction.  Specifically, if other files
// instantiate templates or use macros or inline functions from this
// file, or you compile this file and link it with other files to produce
// an executable, this file does not by itself cause the resulting
// executable to be covered by the GNU General Public License.  This
// exception does not however invalidate any other reasons why the
// executable file might be covered by the GNU General Public License.

#ifndef MLN_LABELING_COLORIZE_HH
# define MLN_LABELING_COLORIZE_HH


# include <mln/core/concept/image.hh>
# include <mln/fun/i2v/array.hh>
# include <mln/value/rgb8.hh>
# include <mln/literal/black.hh>
# include <mln/data/transform.hh>
# include <mln/data/compute.hh>
# include <mln/accu/stat/max.hh>


namespace mln
{

  namespace labeling
  {

    // Forward declaration.
    namespace colorize_
    {
      extern unsigned min_value;
      extern unsigned max_value;
    }



    template <typename V, typename L>
    mln_ch_value(L, V)
    colorize(const V& value,
             const Image<L>& labeled_image,
             const mln_value(L)& nlabels);


    //
    template <typename V, typename L>
    mln_ch_value(L, V)
    colorize(const V& value,
             const Image<L>& labeled_image);


    //
    template <typename L>
    mln_ch_value(L, mln::value::rgb8)
    colorize(const Image<L>& input,
             const mln_value(L)& nlabels);


# ifndef MLN_INCLUDE_ONLY

    namespace colorize_
    {
      unsigned min_value = 20;
      unsigned max_value = 220;
    }


    namespace internal
    {

      unsigned random_number()
      {
        static unsigned last = 1;

        last = (323 * last + 6603) % 1025;

        return colorize_::min_value + last % colorize_::max_value;
      }


      // No random color generator is available for the value type V.
      template <typename V>
      V random_color(const V&);


      template <unsigned n>
      mln::value::rgb<n>
      random_color(const mln::value::rgb<n>&)
      {
        // Make sure the numbers are generated in the same order
        // whatever the compiler used.
        // For instance, ICC does not compute function arguments in
        // the same order as GCC does.
        unsigned
          red = random_number(),
          green = random_number(),
          blue = random_number();
        return mln::value::rgb<n>(red,
                                  green,
                                  blue);
      }

    }

    template <typename V, typename L>
    inline
    mln_ch_value(L, V)
    colorize(const V& value,
             const Image<L>& input,
             const mln_value(L)& nlabels)
    {
      trace::entering("labeling::colorize");
      mln_precondition(exact(input).is_valid());
      // FIXME: check that V is a color type.
      // FIXME: we want to be sure that this is a label.
      // mlc_is_a(mln_value(L), mln::value::Symbolic)::check();
      (void) value;

      unsigned label_count = static_cast<unsigned>(nlabels) + 1;
      static fun::i2v::array<V> f(0);
      int diff_size = f.size() - label_count;
      if (diff_size < 0)
      {
        srand(1);
        f.resize(label_count);
        unsigned i = f.size() + diff_size;
        // We want to treat comp 0 differently since it is the background.
        if (i == 0)
        {
          i = 1;
          f(0) = literal::black;
        }
        for (; i < f.size(); ++i)
          f(i) = internal::random_color(value);
      }
      mln_assertion(f.size() >= (label_count));
      mln_ch_value(L, V) output = data::transform(input, f);

      trace::exiting("labeling::colorize");
      return output;
    }

    template <typename V, typename L>
    inline
    mln_ch_value(L, V)
    colorize(const V& value,
             const Image<L>& input)
    {
      trace::entering("labeling::colorize");
      mln_precondition(exact(input).is_valid());

      accu::stat::max<mln_value(L)> accu;
      mln_value(L) nlabels = data::compute(accu, input);

      mln_ch_value(L,V) output = colorize(value, input, nlabels);

      trace::exiting("labeling::colorize");
      return output;
    }


    template <typename L>
    inline
    mln_ch_value(L, mln::value::rgb8)
    colorize(const Image<L>& input,
             const mln_value(L)& nlabels)
    {
      return colorize(mln::value::rgb8(), input, nlabels);
    }


# endif // ! MLN_INCLUDE_ONLY

  } // end of namespace mln::labeling

} // end of namespace mln


#endif // ! MLN_LABELING_COLORIZE_HH