cvrTypeInfo.h

Go to the documentation of this file.

/*
 * Copyright (C) 1998-2004
 * 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   cvrTypeInfo.h
 *         Definition of some template functions that give information
 *         about its template type.
 * \author Pablo Alvarado
 * \date   16.05.2001
 *
 * $Id: cvrTypeInfo.h,v 1.6 2007/10/14 20:25:38 alvarado Exp $
 */

#ifndef _CVR_TYPE_INFO_H_
#define _CVR_TYPE_INFO_H_

#include "cvrTypes.h"
#include "cvrClassName.h"
#include <limits>
#include <typeinfo>

// Visual define these as macros
#undef min
#undef max

namespace cvr {

  /**
   * This class allows to ask some information required in the
   * CVR-Libfor some types.
   * Note that the members are static, and you do not need any
   * instance of the class to get the type information.
   *
   * For more information about a type you can also use the
   * std::numeric_limits type of the Standard Template Library.
   *
   * Example:
   * \code
   * if (typeInfo<dreal>::isFloatingPointType()) {
   *   cout << "dreal is a floating point type" << endl;
   * } else {
   *   cout << "this is a really weird case!" << endl;
   * }
   * \endcode
   */
  template<class T>
  class typeInfo {
  public:
    /**
     * Alias for contained type.
     *
     * For usual C++ types (int, float, etc.), this is exactly as T, but
     * for compound type (complex<T>, point<T>, etc.) this corresponds to the
     * type of the components
     */
    typedef T value_type;

    /**
     * Type suggested for accumulation of current type elements
     * (for example int for ubyte).
     */
    typedef T accumulation_type;

    /**
     * Type suggested to accumulate the square of values of the current
     * type
     */
    typedef T square_accumulation_type;

    /**
     * Suggest a norm for the given type.
     * Usually 255 is used for ubyte, 127 for byte, 65535 for all other
     * integer types and 1.0 for the floating point types.
     */
    static T suggestedNorm() throw() {return 65535;}

    /**
     * Return true if the type T is a floating point type.
     */
    static bool isFloatingPointType() throw() {return false;}

    /**
     * Return a const char* with the name of the type
     */
    static const char* name() throw() {return "";}

    /**
     * The difference of this minimum with the std::numeric_limits<T>::min() is
     * that here the minimum value is returned for floating point types and
     * fixed point types.  The STL method returns for floating point values
     * the minimal representable value above zero.  For max() you can use
     * the standard version
     */
    static T min() throw() {return std::numeric_limits<T>::min();}

  private:
    /**
     * Disable creation of instances of this class.
     */
    typeInfo() {};
  };

  // ------------------------
  // template specializations
  // ------------------------

  template<>
  class typeInfo<ubyte> {
  public:
    typedef ubyte value_type;
    typedef int32 accumulation_type;
    typedef int32 square_accumulation_type;
    static ubyte suggestedNorm() throw() {return 255;}
    static bool isFloatingPointType() throw() {return false;}
    static const char* name() throw() {return "cvr::ubyte";};
    static ubyte min() throw() {return std::numeric_limits<ubyte>::min();}
  private:
    typeInfo() {};
  };

  template<>
  class typeInfo<byte> {
  public:
    typedef byte value_type;
    typedef int32 accumulation_type;
    typedef int32 square_accumulation_type;
    static byte suggestedNorm() throw() {return 127;}
    static bool isFloatingPointType() throw() {return false;}
    static const char* name() throw() {return "cvr::byte";}
    static byte min() throw() {return std::numeric_limits<byte>::min();}
  private:
    typeInfo() {};
  };

  template<>
  class typeInfo<int16> {
  public:
    typedef int16 value_type;
    typedef int32 accumulation_type;
    typedef dreal square_accumulation_type;
    static int16 suggestedNorm() throw() {return 255;}
    static bool isFloatingPointType() throw() {return false;}
    static const char* name() throw() {return "cvr::int16";}
    static short int min() throw() {
      return std::numeric_limits<int16>::min();
    }
  private:
    typeInfo() {};
  };

  template<>
  class typeInfo<uint16> {
  public:
    typedef uint16 value_type;
    typedef int32 accumulation_type;
    typedef dreal square_accumulation_type;
    static uint16 suggestedNorm() throw() {return 255;}
    static bool isFloatingPointType() throw() {return false;}
    static const char* name() throw() {return "cvr::uint16";}
    static uint16 min() throw() {
      return std::numeric_limits<uint16>::min();
    }
  private:
    typeInfo() {};
  };

  template<>
  class typeInfo<int32> {
  public:
    typedef int32 value_type;
    typedef int32 accumulation_type;
    typedef dreal square_accumulation_type;
    static int32 suggestedNorm() throw() {return 65535;}
    static bool isFloatingPointType() throw() {return false;}
    static const char* name() throw() {return "cvr::int32";}
    static int32 min() throw() {return std::numeric_limits<int32>::min();}
  private:
    typeInfo() {};
  };

  template<>
  class typeInfo<uint32> {
  public:
    typedef uint32 value_type;
    typedef int32 accumulation_type;
    typedef dreal square_accumulation_type;
    static uint32 suggestedNorm() throw() {return 65535;}
    static bool isFloatingPointType() throw() {return false;}
    static const char* name() throw() {return "cvr::uint32";}
    static uint32 min() throw() {
      return std::numeric_limits<uint32>::min();
    }
  private:
    typeInfo() {};
  };

  template<>
  class typeInfo<sreal> {
  public:
    typedef sreal value_type;
    typedef sreal accumulation_type;
    typedef dreal square_accumulation_type;
    static sreal suggestedNorm() throw() {return static_cast<sreal>(1);}
    static bool isFloatingPointType() throw() {return true;}
    static const char* name() throw() {return "cvr::sreal";};
    static float min() throw() {return -std::numeric_limits<sreal>::max();}
  private:
    typeInfo() {};
  };

  template<>
  class typeInfo<dreal> {
  public:
    typedef dreal value_type;
    typedef dreal accumulation_type;
    typedef dreal square_accumulation_type;
    static dreal suggestedNorm() throw() {return static_cast<dreal>(1);}
    static bool isFloatingPointType() throw() {return true;}
    static const char* name() throw() {return "cvr::dreal";};
    static dreal min() throw() {return -std::numeric_limits<dreal>::max();}
  private:
    typeInfo() {};
  };

  /**
   * This tricky specialization lets the typeInfo of any template class with a
   * single template parameter make use of the typeInfo of its template
   * parameter.
   */
  template<typename T, template <class> class U>
  class typeInfo< U<T> > {
  public:
    typedef typename typeInfo<T>::value_type value_type;
    typedef U< typename typeInfo<T>::accumulation_type > accumulation_type;
    typedef U< typename typeInfo<T>::square_accumulation_type >
    square_accumulation_type;

    // Let us hope that this trick way works in all cases:
    static U<T> suggestedNorm() throw() {
      return U<T>(typeInfo<T>::suggestedNorm());
    }

    // no container is a pure floating point type!
    static bool isFloatingPointType() throw() {return false;}

    //
    static const char* name() throw() {
      static const std::string theName =
        className::demangle(typeid(U<T>()).name());
      return theName.c_str();
    }

    // this class has no minimum, as it does not make much sense here.
  private:
    typeInfo() {};
  };
}

#endif