image_pyramid.hpp

Go to the documentation of this file.

//*LB*
// Copyright (c) 2010, University of Bonn, Institute for Computer Science VI
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//  * Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimer.
//  * 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.
//  * Neither the name of the University of Bonn 
//    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 HOLDER 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.
//*LE*

#ifndef __IMAGE_PYRAMID_HPP__
#define __IMAGE_PYRAMID_HPP__

#include <cuv/tensor_ops/tensor_ops.hpp>
#include <cuv/basics/cuda_array.hpp>

namespace cuv{

        template <class __matrix_type>
        class image_pyramid
        {
        public:
                typedef __matrix_type              matrix_type;            
                typedef typename matrix_type::value_type    value_type;    
                typedef typename matrix_type::memory_layout_type memory_layout; 
                typedef typename matrix_type::index_type    index_type;    

                image_pyramid( int img_h, int img_w, int depth, int dim );
                matrix_type* get(int depth, int channel);
                matrix_type* get_all_channels(int depth);
                inline int dim(){return m_dim;}                           
                inline unsigned int base_h(){return m_base_height;}       
                inline unsigned int base_w(){return m_base_width;}        
                inline unsigned int depth(){return m_matrices.size();}    

                template<class __arg_matrix_type>
                void build(const __arg_matrix_type& src, const unsigned int interleaved_channels){
                        typedef typename __arg_matrix_type::value_type   argval_type;
                        typedef typename __arg_matrix_type::memory_space_type argmemspace_type;
                        typedef typename __arg_matrix_type::index_type   argindex_type;
                        typedef cuda_array<argval_type,argmemspace_type,argindex_type> argca_type;

                        // create base image at level 0
                        if(    src.shape()[0] == m_base_height*m_dim // the image dimensions match the input --> just copy.
                                && src.shape()[1] == m_base_width
                        ){
                                //std::cout << "Copycase"<<std::endl;
                                        *m_matrices[0]=src;
                        }
                        else if(   interleaved_channels == 4
                                        && m_dim                == 3
                        ){
                                //std::cout << "Colorcase"<<std::endl;
                                        argca_type cpy(src,4);
                                        matrix_type& dst = *m_matrices[0];
                                        gaussian_pyramid_downsample(dst, cpy, interleaved_channels);
                        }
                        else if(src.shape()[0] > m_base_height*m_dim  // the image dimensions are too large: downsample to 1st level of pyramid
                                &&  src.shape()[1] > m_base_width
                        ){
                                //std::cout << "Multichannel case"<<std::endl;
                                for(int i=0;i<m_dim;i++){
                                        const __arg_matrix_type view(indices[index_range(0,src.shape()[0]/m_dim)][index_range(0,src.shape()[1])],(argval_type*)src.ptr());
                                        argca_type cpy(view);
                                        matrix_type* dstview = get(0,i);
                                        gaussian_pyramid_downsample(*dstview, cpy,1);
                                        delete dstview;
                                }
                        }else{
                                cuvAssert(false);
                        }

                        // fill upper levels
                        for(int i=1;i<m_matrices.size();i++){
                                for(int d=0;d<m_dim;d++){
                                        matrix_type* srcview = get(i-1,d);
                                        argca_type cpy(*srcview);
                                        matrix_type* dstview = get(i,  d);
                                        gaussian_pyramid_downsample(*dstview, cpy,1);
                                        delete dstview;
                                        delete srcview;
                                }
                        }

                }
        private:
                std::vector<matrix_type*> m_matrices;
                unsigned int m_dim;
                unsigned int m_base_width;
                unsigned int m_base_height;
        };
        
        template <class __matrix_type>
        typename image_pyramid<__matrix_type>::matrix_type*
        image_pyramid<__matrix_type>::get(int depth, int channel){
                cuvAssert(depth   < m_matrices.size());
                cuvAssert(channel < m_dim);
                matrix_type& mat = *m_matrices[depth];
                //std::cout << "asking for channel "<<channel<<" in matrix of size "<<mat.shape()[0]<<"x"<<mat.shape()[1]<<std::endl;
                unsigned int w = mat.shape()[1];
                unsigned int h = mat.shape()[0];
                return new matrix_type(indices[index_range(0,h/m_dim)][index_range(0,w)],mat.ptr()+channel*w*h/m_dim);
        }

        template <class __matrix_type>
        typename image_pyramid<__matrix_type>::matrix_type*
        image_pyramid<__matrix_type>::get_all_channels(int depth){
                cuvAssert(depth   < m_matrices.size());
                matrix_type& mat = *m_matrices[depth];
                return &mat;
        }

        template <class __matrix_type>
        image_pyramid<__matrix_type>::image_pyramid( int img_h, int img_w, int depth, int dim )
        :m_base_height(img_h)
        ,m_base_width(img_w)
        ,m_dim(dim)
        {
        for(unsigned int i=0;i<m_matrices.size();i++)
            delete m_matrices[i];
                m_matrices.clear();
                for(unsigned int i=0; i<depth;i++){
                        //std::cout << "Creating Pyramid Level: "<< img_h<<"*"<<m_dim<<"x"<<img_w<<std::endl;
                        m_matrices.push_back(new matrix_type(extents[img_h*m_dim][img_w]));
                        img_h=ceil(img_h/2.f);
                        img_w=ceil(img_w/2.f);
                }
        }

template<class T,class S, class I>
void gaussian_pyramid_downsample(
        tensor<T,S,row_major>& dst,
        const cuda_array<T,S,I>& src,
        const unsigned int interleaved_channels
);
template<class T,class S, class I>
void gaussian_pyramid_upsample(
        tensor<T,S,row_major>& dst,
        const cuda_array<T,S,I>& src
);

template<class TDest, class T,class S, class I>
void get_pixel_classes(
        tensor<TDest,S,row_major>& dst,
        const cuda_array<T,S,I>&           src,
        float scale_fact
);

template<class T,class S, class I>
void gaussian(
        tensor<T,S,row_major>& dst,
        const cuda_array<T,S,I>& src
);
 // end group image_ops

}
#endif /* __IMAGE_PYRAMID_HPP__ */