cvrHueLUT.h

Go to the documentation of this file.

/*
 * Copyright (C) 1998-2005
 * Lehrstuhl fuer Technische Informatik, RWTH-Aachen, Germany
 *
 *
 * This file is part of the Computer Vision and Robotics Library (CVR-Lib)
 *
 * The CVR-Lib is free software; you can redistribute it and/or
 * modify it under the terms of the BSD License.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the authors nor the names of its contributors may be
 *    used to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */



/**
 * \file   cvrHueLUT.h
 *         Contains the hue lookup table.
 * \author Pablo Alvarado
 * \author Peter Doerfler
 * \date   28.04.2005
 *
 * $Id: cvrHueLUT.h,v 1.3 2007/12/26 04:49:23 alvarado Exp $
 */

#ifndef _CVR_HUE_LUT_H_
#define _CVR_HUE_LUT_H_

#include "cvrObject.h"
#include "cvrMath.h"
#include "cvrAssert.h"

namespace cvr {
  /**
   * Following class provides a mono-state object that contains a 0.5MB Look-up
   * Table to accelerate the computation of hues.
   *
   * The hue is defined in terms of the RGB components and rgb chromaticities
   * as
   * \f[
   *   \begin{aligned}
   *      H &= \arccos\left(\frac{\frac{1}{2}\left[(R-G) + (R-B)\right]}
   *                       {\sqrt{(R-G)^2+(R-B)(G-B))}}\right) \\
   *        &= \arccos\left(\frac{\frac{1}{2}\left[(r-g) + (r-b)\right]}
   *                       {\sqrt{(r-g)^2+(r-b)(g-b))}}\right) \\
   *        &= \arccos\left[\frac{3r-1}
                                 {2\sqrt{3r^2+3g^2+3rg-3r-3g+1}}\right]
   *   \end{aligned}
   * \f]
   *
   * where for the last equation it was used the fact that \f$ r=1-g-b \f$.
   *
   * \b Note: This class normalizes the hue to be in the range [0,1]
   * which is more practical for the CVR-Lib than the typical 0..360
   * degrees definition.
   *
   * The LUT uses the fact that r+g+b=255 and thus only takes r and g as
   * inputs, where r,g, and b are the chromaticity values obtained by
   * normalization as r=R/(R+G+B), g=G/(R+G+B). These values need to be
   * multiplied by 511, which is the last index the LUT takes. Note that
   * r+g<512, and r,g >= 0
   *
   * As a mono-state class, only one instance of the LUT array will be created.
   *
   * @ingroup gColor
   */
  class hueLUT : public object {
  public:
    /**
     * Construct the class
     * Here, the LUT will be build just once (if not already done).
     * The first time you construct this class, it will take about 0.15 seconds
     * to build the LUT.
     */
    hueLUT();

    /**
     * return the hue for (r,g). r,g >=0 and r+g<512
     *
     * @param r red component
     * @param g green component
     * @return hue between 0 and 1
     */
    inline float operator() (const int r,const int g) const;

    /**
     * Returns the name of this class
     */
    virtual const std::string& name() const;

    /**
     * Returns a pointer to a clone of the parameters.
     */
    virtual hueLUT* clone() const;

    /**
     * Returns a pointer to a clone of the parameters.
     */
    virtual hueLUT* newInstance() const;

  protected:
    /**
     * Construct a hue LUT. It assumes that r,g>=0 and r+g<512.  The
     * 0.5MB memory required should not be a problem in modern PCs
     * anymore!.
     */
    static void constructHueLUT();

    /**
     * Type required to create the LUT as a const structure
     */
    typedef const float* cfloatptr_;

    /**
     * The hueLUT with floats.
     */
    static const cfloatptr_* hueLUT_;
  };

  inline float hueLUT::operator() (const int r,const int g) const {

#ifdef _CVR_DEBUG
    _lti_debug4("r=" << r << " g=" << g << "\n");
#endif

    // check in debug modus that range is ok
    assert((r>=0) && (g>=0) && ((r+g)<512));

    // just return the value
    return hueLUT_[r][g];
  }


}

#endif