iLab Neuromorphic Robotics Toolkit  0.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PixelOperatorsImpl.H File Reference

Author
Randolph Voorhies

License

//    // ////////////////////////////////////////////////////////////////////////
//    //              The iLab Neuromorphic Robotics Toolkit (NRT)             //
//    // Copyright 2010-2012 by the University of Southern California (USC)    //
//    //                          and the iLab at USC.                         //
//    //                                                                       //
//    //                iLab - University of Southern California               //
//    //                Hedco Neurociences Building, Room HNB-10               //
//    //                    Los Angeles, Ca 90089-2520 - USA                   //
//    //                                                                       //
//    //      See http://ilab.usc.edu for information about this project.      //
//    // ////////////////////////////////////////////////////////////////////////
//    // This file is part of The iLab Neuromorphic Robotics Toolkit.          //
//    //                                                                       //
//    // The iLab Neuromorphic Robotics Toolkit 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, either   //
//    // version 3 of the License, or (at your option) any later version.      //
//    //                                                                       //
//    // The iLab Neuromorphic Robotics Toolkit 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 The iLab Neuromorphic Robotics Toolkit.  If not, see       //
//    // <http://www.gnu.org/licenses/>.                                       //
//    // ////////////////////////////////////////////////////////////////////////
//    

Definition in file PixelOperatorsImpl.H.

Go to the source code of this file.

Functions

template<class T , class U >
std::enable_if< pixel_traits
< T >::has_extra_data
&&pixel_traits< U >
::has_extra_data >::type 
copy_extra_data (T const &from, U &to)
 
template<class T , class U >
std::enable_if<!(pixel_traits
< T >::has_extra_data
&&pixel_traits< U >
::has_extra_data)>::type 
copy_extra_data (T const &from, U &to)
 
template<template< typename > class OpType, class T1 , class T2 , class RetType >
std::enable_if<!pixel_traits
< RetType >::has_extra_data >
::type 
apply_extra_data_op (T1 const &lhs, T2 const &rhs, RetType &ret)
 
template<template< typename > class OpType, class T1 , class T2 , class RetType >
std::enable_if< pixel_traits
< RetType >::has_extra_data
&&pixel_traits< T1 >
::has_extra_data
&&pixel_traits< T2 >
::has_extra_data >::type 
apply_extra_data_op (T1 const &lhs, T2 const &rhs, RetType &ret)
 
template<template< typename > class OpType, class T1 , class T2 , class RetType >
std::enable_if< pixel_traits
< RetType >::has_extra_data
&&pixel_traits< T1 >
::has_extra_data
&&!pixel_traits< T2 >
::has_extra_data >::type 
apply_extra_data_op (T1 const &lhs, T2 const &rhs, RetType &ret)
 
template<template< typename > class OpType, class T1 , class T2 , class RetType >
std::enable_if< pixel_traits
< RetType >::has_extra_data
&&!pixel_traits< T1 >
::has_extra_data
&&pixel_traits< T2 >
::has_extra_data >::type 
apply_extra_data_op (T1 const &lhs, T2 const &rhs, RetType &ret)
 
template<class P1 , class P2 >
std::enable_if
< pixel_helper::are_comparable
< P1, P2 >::value, P1 >::type & 
operator+= (P1 &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_multi_channel
&&pixel_traits< P2 >
::is_single_channel, P1 >
::type & 
operator+= (P1 &lhs, P2 const &rhs)
 
template<class P1 , typename T2 >
std::enable_if<!pixel_traits
< P1 >::has_extra_data
&&pixel_helper::is_pixel< P1 >
::value &&std::is_arithmetic
< T2 >::value, P1 >::type & 
operator+= (P1 &lhs, T2 const rhs)
 
template<class P1 , typename T2 >
std::enable_if< pixel_traits
< P1 >::has_extra_data
&&std::is_arithmetic< T2 >
::value, P1 >::type & 
operator+= (P1 &lhs, T2 const rhs)
 
template<class P1 , class P2 >
std::enable_if
< pixel_helper::are_comparable
< P1, P2 >::value, typename
pixel_helper::are_comparable
< P1, P2 >::type >::type 
operator+ (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_multi_channel
&&pixel_traits< P2 >
::is_single_channel, typename
P1::template rebind< typename
promote< typename P1::PODType,
typename P2::PODType >::type >
::type >::type 
operator+ (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_single_channel
&&pixel_traits< P2 >
::is_multi_channel, typename
P2::template rebind< typename
promote< typename P1::PODType,
typename P2::PODType >::type >
::type >::type 
operator+ (P1 const &lhs, P2 const &rhs)
 
template<class P1 , typename T2 >
std::enable_if<!pixel_traits
< P1 >::has_extra_data
&&pixel_helper::is_pixel< P1 >
::value &&std::is_arithmetic
< T2 >::value, typename
P1::template rebind< typename
nrt::promote< typename
P1::PODType, T2 >::type >
::type >::type 
operator+ (P1 const &lhs, T2 const rhs)
 
template<class P1 , typename T2 >
std::enable_if< pixel_traits
< P1 >::has_extra_data
&&pixel_helper::is_pixel< P1 >
::value &&std::is_arithmetic
< T2 >::value, typename
P1::template rebind< typename
nrt::promote< typename
P1::PODType, T2 >::type >
::type >::type 
operator+ (P1 const &lhs, T2 const rhs)
 
template<class P2 , typename T1 >
std::enable_if<!pixel_traits
< P2 >::has_extra_data
&&pixel_helper::is_pixel< P2 >
::value &&std::is_arithmetic
< T1 >::value, typename
P2::template rebind< typename
promote< T1, typename
P2::PODType >::type >::type >
::type 
operator+ (T1 const lhs, P2 const &rhs)
 
template<class P2 , typename T1 >
std::enable_if< pixel_traits
< P2 >::has_extra_data
&&pixel_helper::is_pixel< P2 >
::value &&std::is_arithmetic
< T1 >::value, typename
P2::template rebind< typename
promote< T1, typename
P2::PODType >::type >::type >
::type 
operator+ (T1 const lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if
< pixel_helper::are_comparable
< P1, P2 >::value, P1 >::type & 
operator-= (P1 &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_multi_channel
&&pixel_traits< P2 >
::is_single_channel, P1 >
::type & 
operator-= (P1 &lhs, P2 const &rhs)
 
template<class P1 , typename T2 >
std::enable_if<!pixel_traits
< P1 >::has_extra_data
&&pixel_helper::is_pixel< P1 >
::value &&std::is_arithmetic
< T2 >::value, P1 >::type & 
operator-= (P1 &lhs, T2 const rhs)
 
template<class P1 , typename T2 >
std::enable_if< pixel_traits
< P1 >::has_extra_data
&&std::is_arithmetic< T2 >
::value, P1 >::type & 
operator-= (P1 &lhs, T2 const rhs)
 
template<class P1 , class P2 >
std::enable_if
< pixel_helper::are_comparable
< P1, P2 >::value, typename
pixel_helper::are_comparable
< P1, P2 >::type >::type 
operator- (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_multi_channel
&&pixel_traits< P2 >
::is_single_channel, typename
P1::template rebind< typename
promote< typename P1::PODType,
typename P2::PODType >::type >
::type >::type 
operator- (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_single_channel
&&pixel_traits< P2 >
::is_multi_channel, typename
P2::template rebind< typename
promote< typename P1::PODType,
typename P2::PODType >::type >
::type >::type 
operator- (P1 const &lhs, P2 const &rhs)
 
template<class P1 , typename T2 >
std::enable_if<!pixel_traits
< P1 >::has_extra_data
&&pixel_helper::is_pixel< P1 >
::value &&std::is_arithmetic
< T2 >::value, typename
P1::template rebind< typename
nrt::promote< typename
P1::PODType, T2 >::type >
::type >::type 
operator- (P1 const &lhs, T2 const rhs)
 
template<class P1 , typename T2 >
std::enable_if< pixel_traits
< P1 >::has_extra_data
&&pixel_helper::is_pixel< P1 >
::value &&std::is_arithmetic
< T2 >::value, typename
P1::template rebind< typename
nrt::promote< typename
P1::PODType, T2 >::type >
::type >::type 
operator- (P1 const &lhs, T2 const rhs)
 
template<class P2 , typename T1 >
std::enable_if<!pixel_traits
< P2 >::has_extra_data
&&pixel_helper::is_pixel< P2 >
::value &&std::is_arithmetic
< T1 >::value, typename
P2::template rebind< typename
promote< T1, typename
P2::PODType >::type >::type >
::type 
operator- (T1 const lhs, P2 const &rhs)
 
template<class P2 , typename T1 >
std::enable_if< pixel_traits
< P2 >::has_extra_data
&&pixel_helper::is_pixel< P2 >
::value &&std::is_arithmetic
< T1 >::value, typename
P2::template rebind< typename
promote< T1, typename
P2::PODType >::type >::type >
::type 
operator- (T1 const lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if
< pixel_helper::are_comparable
< P1, P2 >::value, P1 >::type & 
operator*= (P1 &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_multi_channel
&&pixel_traits< P2 >
::is_single_channel, P1 >
::type & 
operator*= (P1 &lhs, P2 const &rhs)
 
template<class P1 , typename T2 >
std::enable_if<!pixel_traits
< P1 >::has_extra_data
&&pixel_helper::is_pixel< P1 >
::value &&std::is_arithmetic
< T2 >::value, P1 >::type & 
operator*= (P1 &lhs, T2 const rhs)
 
template<class P1 , typename T2 >
std::enable_if< pixel_traits
< P1 >::has_extra_data
&&std::is_arithmetic< T2 >
::value, P1 >::type & 
operator*= (P1 &lhs, T2 const rhs)
 
template<class P1 , class P2 >
std::enable_if
< pixel_helper::are_comparable
< P1, P2 >::value, typename
pixel_helper::are_comparable
< P1, P2 >::type >::type 
operator* (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_multi_channel
&&pixel_traits< P2 >
::is_single_channel, typename
P1::template rebind< typename
promote< typename P1::PODType,
typename P2::PODType >::type >
::type >::type 
operator* (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_single_channel
&&pixel_traits< P2 >
::is_multi_channel, typename
P2::template rebind< typename
promote< typename P1::PODType,
typename P2::PODType >::type >
::type >::type 
operator* (P1 const &lhs, P2 const &rhs)
 
template<class P1 , typename T2 >
std::enable_if<!pixel_traits
< P1 >::has_extra_data
&&pixel_helper::is_pixel< P1 >
::value &&std::is_arithmetic
< T2 >::value, typename
P1::template rebind< typename
nrt::promote< typename
P1::PODType, T2 >::type >
::type >::type 
operator* (P1 const &lhs, T2 const rhs)
 
template<class P1 , typename T2 >
std::enable_if< pixel_traits
< P1 >::has_extra_data
&&pixel_helper::is_pixel< P1 >
::value &&std::is_arithmetic
< T2 >::value, typename
P1::template rebind< typename
nrt::promote< typename
P1::PODType, T2 >::type >
::type >::type 
operator* (P1 const &lhs, T2 const rhs)
 
template<class P2 , typename T1 >
std::enable_if<!pixel_traits
< P2 >::has_extra_data
&&pixel_helper::is_pixel< P2 >
::value &&std::is_arithmetic
< T1 >::value, typename
P2::template rebind< typename
promote< T1, typename
P2::PODType >::type >::type >
::type 
operator* (T1 const lhs, P2 const &rhs)
 
template<class P2 , typename T1 >
std::enable_if< pixel_traits
< P2 >::has_extra_data
&&pixel_helper::is_pixel< P2 >
::value &&std::is_arithmetic
< T1 >::value, typename
P2::template rebind< typename
promote< T1, typename
P2::PODType >::type >::type >
::type 
operator* (T1 const lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if
< pixel_helper::are_comparable
< P1, P2 >::value, P1 >::type & 
operator/= (P1 &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_multi_channel
&&pixel_traits< P2 >
::is_single_channel, P1 >
::type & 
operator/= (P1 &lhs, P2 const &rhs)
 
template<class P1 , typename T2 >
std::enable_if<!pixel_traits
< P1 >::has_extra_data
&&pixel_helper::is_pixel< P1 >
::value &&std::is_arithmetic
< T2 >::value, P1 >::type & 
operator/= (P1 &lhs, T2 const rhs)
 
template<class P1 , typename T2 >
std::enable_if< pixel_traits
< P1 >::has_extra_data
&&std::is_arithmetic< T2 >
::value, P1 >::type & 
operator/= (P1 &lhs, T2 const rhs)
 
template<class P1 , class P2 >
std::enable_if
< pixel_helper::are_comparable
< P1, P2 >::value, typename
pixel_helper::are_comparable
< P1, P2 >::type >::type 
operator/ (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_multi_channel
&&pixel_traits< P2 >
::is_single_channel, typename
P1::template rebind< typename
promote< typename P1::PODType,
typename P2::PODType >::type >
::type >::type 
operator/ (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_single_channel
&&pixel_traits< P2 >
::is_multi_channel, typename
P2::template rebind< typename
promote< typename P1::PODType,
typename P2::PODType >::type >
::type >::type 
operator/ (P1 const &lhs, P2 const &rhs)
 
template<class P1 , typename T2 >
std::enable_if<!pixel_traits
< P1 >::has_extra_data
&&pixel_helper::is_pixel< P1 >
::value &&std::is_arithmetic
< T2 >::value, typename
P1::template rebind< typename
nrt::promote< typename
P1::PODType, T2 >::type >
::type >::type 
operator/ (P1 const &lhs, T2 const rhs)
 
template<class P1 , typename T2 >
std::enable_if< pixel_traits
< P1 >::has_extra_data
&&pixel_helper::is_pixel< P1 >
::value &&std::is_arithmetic
< T2 >::value, typename
P1::template rebind< typename
nrt::promote< typename
P1::PODType, T2 >::type >
::type >::type 
operator/ (P1 const &lhs, T2 const rhs)
 
template<class P2 , typename T1 >
std::enable_if<!pixel_traits
< P2 >::has_extra_data
&&pixel_helper::is_pixel< P2 >
::value &&std::is_arithmetic
< T1 >::value, typename
P2::template rebind< typename
promote< T1, typename
P2::PODType >::type >::type >
::type 
operator/ (T1 const lhs, P2 const &rhs)
 
template<class P2 , typename T1 >
std::enable_if< pixel_traits
< P2 >::has_extra_data
&&pixel_helper::is_pixel< P2 >
::value &&std::is_arithmetic
< T1 >::value, typename
P2::template rebind< typename
promote< T1, typename
P2::PODType >::type >::type >
::type 
operator/ (T1 const lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_single_channel
&&pixel_traits< P2 >
::is_single_channel, bool >
::type 
operator== (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_single_channel
&&pixel_traits< P2 >
::is_single_channel, bool >
::type 
operator!= (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_single_channel
&&pixel_traits< P2 >
::is_single_channel, bool >
::type 
operator< (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_single_channel
&&pixel_traits< P2 >
::is_single_channel, bool >
::type 
operator<= (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_single_channel
&&pixel_traits< P2 >
::is_single_channel, bool >
::type 
operator> (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P1 >::is_single_channel
&&pixel_traits< P2 >
::is_single_channel, bool >
::type 
operator>= (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P2 >::is_multi_channel
&&(pixel_traits< P1 >
::num_channels==pixel_traits
< P2 >::num_channels), bool >
::type 
operator== (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P2 >::is_multi_channel
&&(pixel_traits< P1 >
::num_channels==pixel_traits
< P2 >::num_channels), bool >
::type 
operator!= (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P2 >::is_multi_channel
&&(pixel_traits< P1 >
::num_channels==pixel_traits
< P2 >::num_channels), bool >
::type 
operator< (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P2 >::is_multi_channel
&&(pixel_traits< P1 >
::num_channels==pixel_traits
< P2 >::num_channels), bool >
::type 
operator<= (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P2 >::is_multi_channel
&&(pixel_traits< P1 >
::num_channels==pixel_traits
< P2 >::num_channels), bool >
::type 
operator> (P1 const &lhs, P2 const &rhs)
 
template<class P1 , class P2 >
std::enable_if< pixel_traits
< P2 >::is_multi_channel
&&(pixel_traits< P1 >
::num_channels==pixel_traits
< P2 >::num_channels), bool >
::type 
operator>= (P1 const &lhs, P2 const &rhs)