stretch.hh

// Copyright (C) 2007, 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_DATA_STRETCH_HH
# define MLN_DATA_STRETCH_HH


# include <mln/estim/min_max.hh>
# include <mln/value/int_u.hh>
# include <mln/fun/v2v/linear.hh>
# include <mln/data/transform.hh>


# include <mln/value/internal/encoding.hh>
# include <iomanip>
namespace mln
{

  namespace data
  {

    template <typename V, typename I>
    mln_ch_value(I, V)
    stretch(const V& v, const Image<I>& input);


# ifndef MLN_INCLUDE_ONLY

    namespace impl
    {

      //
      template <typename V, typename I>
      inline
      mln_ch_value(I, V)
      stretch(const V& v, const Image<I>& input)
      {
        trace::entering("data::impl::stretch");

        (void) v;
        mlc_converts_to(float, V)::check();

        mln_ch_value(I, V) output;

        mln_value(I) min_, max_;
        estim::min_max(input, min_, max_);
        if (max_ != min_)
          {
            //FIXME: we would like to use float instead of double but we
            //can't for precision reasons. See ticket #179.
            double
              min = double(min_),
              max = double(max_),
              epsilon = mln_epsilon(float),
              M = mln_max(V) + 0.5f - epsilon,
              m = 0.0f - 0.5f + epsilon,
              a = (M - m) / (max - min),
              b = (m * max - M * min) / (max - min);
            fun::v2v::linear_sat<mln_value(I), double, V> f(a, b);
            output = data::transform(input, f);
          }
        else
          {
            initialize(output, input);
            trace::warning("output has no significative data!");
          }

        trace::exiting("data::impl::stretch");
        return output;
      }

    } // end of namespace mln::data::impl



    // Facade

    template <typename V, typename I>
    inline
    mln_ch_value(I, V)
    stretch(const V& v, const Image<I>& input)
    {
      trace::entering("data::stretch");

      (void) v;
      mln_precondition(exact(input).is_valid());

      mln_ch_value(I, V) output = impl::stretch(V(), input);

      trace::exiting("data::stretch");
      return output;
    }

# endif // ! MLN_INCLUDE_ONLY

  } // end of namespace mln::data

} // end of namespace mln


#endif // ! MLN_DATA_STRETCH_HH