phoenix_transpose_impl.h File Reference

#include <algorithm>
#include "phoenix_transpose.h"

Include dependency graph for phoenix_transpose_impl.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
template<typename T, typename U>
void	phoenix_transpose_block (T *__restrict__ ptabOutput, const U *__restrict__ ptabInput, size_t nbRowOut, size_t nbColOut, size_t nbBlockRowOut, size_t nbBlockColOut, size_t outputPadding)
	Transpose and convert the table of U into a table of T.
template<typename T, typename U>
void	phoenix_transpose_block_copy (T *__restrict__ ptabOutput, const U *__restrict__ ptabInput, size_t nbRowOut, size_t nbColOut, size_t nbBlockRowOut, size_t nbBlockColOut, size_t outputPadding, bool isTransposed)
	Convert the table of U into a table of T.
template<typename T, typename U>
void	phoenix_transpose_copy (T *__restrict__ ptabOutput, const U *__restrict__ ptabInput, size_t nbRowOut, size_t nbColOut, size_t outputPadding, bool isTransposed)
	Convert the table of U into a table of T.

Function Documentation

phoenix_transpose_block()

template<typename T, typename U>

void phoenix_transpose_block	(	T *__restrict__	ptabOutput,
		const U *__restrict__	ptabInput,
		size_t	nbRowOut,
		size_t	nbColOut,
		size_t	nbBlockRowOut,
		size_t	nbBlockColOut,
		size_t	outputPadding )

Transpose and convert the table of U into a table of T.

Parameters

[out]	ptabOutput	: output table
	ptabInput	: table of input
	nbRowOut	: number of rows of the output table
	nbColOut	: number of columns of the output table
	nbBlockRowOut	: block size on slice
	nbBlockColOut	: block size on pixel
	outputPadding	: padding of the output matrix

Definition at line 53 of file phoenix_transpose_impl.h.

{
        T* tabOutput = phoenix_assume_aligned(ptabOutput);
        const U* tabInput = phoenix_assume_aligned(ptabInput);
//      T* tabOutput = ptabOutput;
//      const U* tabInput = ptabInput;
//      std::cerr << "phoenix_transpose_block : nbRowOut = " << nbRowOut << ", nbColOut = " << nbColOut << ", nbBlockRowOut = " << nbBlockRowOut << ", nbBlockColOut = " << nbBlockColOut << std::endl;
        size_t outputRowSize(nbColOut + outputPadding);
        for(size_t i(0lu); i < nbColOut; i += nbBlockColOut){
                for(size_t j(0lu); j < nbRowOut; j += nbBlockRowOut){
                        // transpose the block beginning at [i,j]
                        for(size_t k(i); k < std::min(i + nbBlockColOut, nbColOut); ++k){
                                for(size_t l(j); l < std::min(j + nbBlockRowOut, nbRowOut); ++l){
//                                      std::cerr << "phoenix_transpose_block : (i = "<<i<<", j = "<<j<<") tabOutput["<<k<<" + "<<l<<"*"<<outputRowSize<<"] = tabInput["<<l<<" + "<<k<<"*"<<nbRowOut<<"]" << std::endl;
                                        tabOutput[l*outputRowSize + k] = tabInput[k*nbRowOut + l];
                                }
                        }
                }
        }
}

References phoenix_assume_aligned().

Referenced by phoenix_transpose_block_copy().

Here is the call graph for this function:

Here is the caller graph for this function:

phoenix_transpose_block_copy()

template<typename T, typename U>

void phoenix_transpose_block_copy	(	T *__restrict__	ptabOutput,
		const U *__restrict__	ptabInput,
		size_t	nbRowOut,
		size_t	nbColOut,
		size_t	nbBlockRowOut,
		size_t	nbBlockColOut,
		size_t	outputPadding,
		bool	isTransposed )

Convert the table of U into a table of T.

Parameters

[out]	ptabOutput	: output table
	ptabInput	: table of input
	nbRowOut	: number of rows of the output table
	nbColOut	: number of columns of the output table
	nbBlockRowOut	: block size on slice
	nbBlockColOut	: block size on pixel
	outputPadding	: padding of the output matrix
	isTransposed	: true if the input matrix of short has to be has to be transposed, false if not

Definition at line 86 of file phoenix_transpose_impl.h.

{
        if(!isTransposed){
                T* tabOutput = phoenix_assume_aligned(ptabOutput);
                const U* tabInput = phoenix_assume_aligned(ptabInput);
                size_t outputRowSize(nbColOut + outputPadding);
                for(size_t i(0lu); i < nbColOut; i += nbBlockColOut){
                        for(size_t j(0lu); j < nbRowOut; j += nbBlockRowOut){
                                // transpose the block beginning at [i,j]
                                for(size_t k(i); k < std::min(i + nbBlockColOut, nbColOut); ++k){
                                        for(size_t l(j); l < std::min(j + nbBlockRowOut, nbRowOut); ++l){
                                                tabOutput[l*outputRowSize + k] = tabInput[l*nbRowOut + k];
                                        }
                                }
                        }
                }
        }else{          //The bad slices rejection from real data have to be done here !!!!!
                phoenix_transpose_block(ptabOutput, ptabInput,
                        nbRowOut, nbColOut, nbBlockRowOut, nbBlockColOut, outputPadding);
        }
}

References phoenix_assume_aligned(), and phoenix_transpose_block().

Here is the call graph for this function:

phoenix_transpose_copy()

template<typename T, typename U>

void phoenix_transpose_copy	(	T *__restrict__	ptabOutput,
		const U *__restrict__	ptabInput,
		size_t	nbRowOut,
		size_t	nbColOut,
		size_t	outputPadding,
		bool	isTransposed )

Convert the table of U into a table of T.

Parameters

[out]	ptabOutput	: output table
	ptabInput	: table of input
	nbRowOut	: number of rows of the output table
	nbColOut	: number of columns of the output table
	outputPadding	: padding of the output matrix
	isTransposed	: true if the input matrix of short has to be has to be transposed, false if not

Definition at line 22 of file phoenix_transpose_impl.h.

{
        T* tabOutput = phoenix_assume_aligned(ptabOutput);
        const U* tabInput = phoenix_assume_aligned(ptabInput);
        size_t outputRowSize(nbColOut + outputPadding);
        if(!isTransposed){
                for(size_t i(0lu); i < nbRowOut; ++i){
                        for(size_t j(0lu); j < nbColOut; ++j){
                                tabOutput[i*outputRowSize + j] = tabInput[i*nbColOut + j];
                        }
                }
        }else{          //The bad slices rejection from real data have to be done here !!!!!
                for(size_t j(0lu); j < nbColOut; ++j){
                        for(size_t i(0lu); i < nbRowOut; ++i){
                                tabOutput[i*outputRowSize + j] = tabInput[i + j*nbRowOut];
                        }
                }
        }
}

References phoenix_assume_aligned().

Here is the call graph for this function: