NECropKernel Class Reference

Interface for the kernel to perform tensor cropping. More...

#include <NECropKernel.h>

Collaboration diagram for NECropKernel:

Public Types
using	InBoundsCropFunction = void(const ITensor *, const ITensor *, float *, Coordinates, int32_t, int32_t, int32_t, bool, bool)
	Function to use for in bounds crop for the particular tensor types passed to configure() More...

Public Member Functions
const char *	name () const override
	Name of the kernel. More...
	NECropKernel ()
	Default constructor. More...
	NECropKernel (const NECropKernel &)=delete
	Prevent instances of this class from being copied (As this class contains pointers) More...
NECropKernel &	operator= (const NECropKernel &)=delete
	Prevent instances of this class from being copied (As this class contains pointers) More...
	NECropKernel (NECropKernel &&)=default
	Allow instances of this class to be moved. More...
NECropKernel &	operator= (NECropKernel &&)=default
	Allow instances of this class to be moved. More...
	~NECropKernel ()=default
	Default destructor. More...
void	configure (const ITensor *input, const ITensor *crop_boxes, const ITensor *box_ind, ITensor *output, uint32_t crop_box_ind=0, float extrapolation_value=0)
	Configure kernel. More...
void	configure_output_shape ()
	Configure output tensor's shape as this can only be determined at runtime. More...
void	run (const Window &window, const ThreadInfo &info) override
	Execute the kernel on the passed window. More...
Public Member Functions inherited from ICPPKernel
virtual	~ICPPKernel ()=default
	Default destructor. More...
virtual void	run_nd (const Window &window, const ThreadInfo &info, const Window &thread_locator)
	legacy compatibility layer for implemantions which do not support thread_locator In these cases we simply narrow the interface down the legacy version More...
virtual void	run_op (ITensorPack &tensors, const Window &window, const ThreadInfo &info)
	Execute the kernel on the passed window. More...
virtual size_t	get_mws (const CPUInfo &platform, size_t thread_count) const
	Return minimum workload size of the relevant kernel. More...
Public Member Functions inherited from IKernel
	IKernel ()
	Constructor. More...
virtual	~IKernel ()=default
	Destructor. More...
virtual bool	is_parallelisable () const
	Indicates whether or not the kernel is parallelisable. More...
virtual BorderSize	border_size () const
	The size of the border for that kernel. More...
const Window &	window () const
	The maximum window the kernel can be executed on. More...
bool	is_window_configured () const
	Function to check if the embedded window of this kernel has been configured. More...

Static Public Member Functions
static Status	validate (const ITensorInfo *input, const ITensorInfo *crop_boxes, const ITensorInfo *box_ind, const ITensorInfo *output, uint32_t crop_box_ind=0, float extrapolation_value=0)
	Static function to check if given info will lead to a valid configuration of CLStridedSliceKernel. More...

Additional Inherited Members
Static Public Attributes inherited from ICPPKernel
static constexpr size_t	default_mws = 1

Detailed Description

Interface for the kernel to perform tensor cropping.

Definition at line 37 of file NECropKernel.h.

Member Typedef Documentation

InBoundsCropFunction

using InBoundsCropFunction = void(const ITensor *, const ITensor *, float *, Coordinates, int32_t, int32_t, int32_t, bool, bool)

Function to use for in bounds crop for the particular tensor types passed to configure()

Definition at line 94 of file NECropKernel.h.

Constructor & Destructor Documentation

NECropKernel() [1/3]

NECropKernel

(

)

Default constructor.

Definition at line 192 of file NECropKernel.cpp.

    : _input(nullptr), _crop_boxes(nullptr), _box_ind(nullptr), _output(nullptr), _start(), _end(), _crop_box_ind(0), _extrapolation_value(0), _rows_out_of_bounds(), _cols_out_of_bounds()
{
}

NECropKernel() [2/3]

NECropKernel ( const NECropKernel &  )

delete

Prevent instances of this class from being copied (As this class contains pointers)

NECropKernel() [3/3]

NECropKernel ( NECropKernel &&  )

default

Allow instances of this class to be moved.

~NECropKernel()

~NECropKernel ( )

default

Default destructor.

Member Function Documentation

configure()

void configure	(	const ITensor *	input,
		const ITensor *	crop_boxes,
		const ITensor *	box_ind,
		ITensor *	output,
		uint32_t	crop_box_ind = 0,
		float	extrapolation_value = 0
	)

Configure kernel.

Note

Supported tensor rank: up to 4

Padding not supported.

Parameters

[in]	input	Source tensor. Data type supported: U8/U16/S16/U32/S32/F16/F32. Data layouts supported: NHWC.
[in]	crop_boxes	Tensor containing all possible boxes used to crop the image, each represented by 4 normalized values. Data type supported: F32
[in]	box_ind	One dimensional tensor mapping the crop_box_ind to the index of the 3D image in input. Data type supported: F32
[out]	output	Destination tensor. Data type supported: F32
[in]	crop_box_ind	Index of the crop box to be used from crop_boxes. Default is 0.
[in]	extrapolation_value	Value to be used for values outside of the image. Default is 0.

Definition at line 197 of file NECropKernel.cpp.

{
    ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
    ARM_COMPUTE_ERROR_THROW_ON(validate(input->info(), crop_boxes->info(), box_ind->info(), output->info(), crop_box_ind, extrapolation_value));
 
    _input               = input;
    _crop_boxes          = crop_boxes;
    _box_ind             = box_ind;
    _output              = output;
    _crop_box_ind        = crop_box_ind;
    _extrapolation_value = extrapolation_value;
}

References ARM_COMPUTE_ERROR_ON_NULLPTR, ARM_COMPUTE_ERROR_THROW_ON, ITensor::info(), arm_compute::test::validation::input, and NECropKernel::validate().

configure_output_shape()

void configure_output_shape

(

)

Configure output tensor's shape as this can only be determined at runtime.

Definition at line 234 of file NECropKernel.cpp.

{
    // _crop_box_ind is used to index _crop_boxes and retrieve the appropriate crop box.
    // The crop box is specified by normalized coordinates [y0, x0, y1, x1].
    const float x0 = *reinterpret_cast<const float *>(_crop_boxes->ptr_to_element(Coordinates(1, _crop_box_ind)));
    const float y0 = *reinterpret_cast<const float *>(_crop_boxes->ptr_to_element(Coordinates(0, _crop_box_ind)));
    const float x1 = *reinterpret_cast<const float *>(_crop_boxes->ptr_to_element(Coordinates(3, _crop_box_ind)));
    const float y1 = *reinterpret_cast<const float *>(_crop_boxes->ptr_to_element(Coordinates(2, _crop_box_ind)));
    // The normalized coordiantes are scaled to retrieve the floating point image coordinates which are rounded to integers.
    _start = Coordinates(std::floor(x0 * (_input->info()->tensor_shape()[1] - 1) + 0.5f),
                         std::floor(y0 * (_input->info()->tensor_shape()[2] - 1) + 0.5f));
    _end = Coordinates(std::floor(x1 * (_input->info()->tensor_shape()[1] - 1) + 0.5f),
                       std::floor(y1 * (_input->info()->tensor_shape()[2] - 1) + 0.5f));
    const TensorShape out_shape(_input->info()->tensor_shape()[0], abs(_end[0] - _start[0]) + 1, abs(_end[1] - _start[1]) + 1);
    _output->info()->set_tensor_shape(out_shape);
 
    bool is_width_flipped  = _end[0] < _start[0];
    bool is_height_flipped = _end[1] < _start[1];
    if(is_height_flipped)
    {
        _rows_out_of_bounds[0] = _start[1] >= static_cast<int32_t>(_input->info()->dimension(2)) ? std::min(static_cast<uint32_t>(_start[1] - _input->info()->dimension(2) + 1),
                                                                                                            static_cast<uint32_t>(_output->info()->dimension(2))) :
                                 0;
        _rows_out_of_bounds[1] = _end[1] < 0 ? std::min(static_cast<uint32_t>(-_end[1]),
                                                        static_cast<uint32_t>(_output->info()->dimension(2))) :
                                 0;
    }
    else
    {
        _rows_out_of_bounds[0] = _start[1] < 0 ? std::min(static_cast<uint32_t>(-_start[1]),
                                                          static_cast<uint32_t>(_output->info()->dimension(2))) :
                                 0;
        _rows_out_of_bounds[1] = _end[1] >= static_cast<int32_t>(_input->info()->dimension(2)) ? std::min(static_cast<uint32_t>(_end[1] - _input->info()->dimension(2) + 1),
                                                                                                          static_cast<uint32_t>(_output->info()->dimension(2))) :
                                 0;
    }
    if(is_width_flipped)
    {
        _cols_out_of_bounds[0] = _start[0] >= static_cast<int32_t>(_input->info()->dimension(1)) ? std::min(static_cast<uint32_t>(_start[0] - _input->info()->dimension(1) + 1),
                                                                                                            static_cast<uint32_t>(_output->info()->dimension(1))) :
                                 0;
        _cols_out_of_bounds[1] = _end[0] < 0 ? std::min(static_cast<uint32_t>(-_end[0]),
                                                        static_cast<uint32_t>(_output->info()->dimension(1))) :
                                 0;
    }
    else
    {
        _cols_out_of_bounds[0] = _start[0] < 0 ? std::min(static_cast<uint32_t>(-_start[0]),
                                                          static_cast<uint32_t>(_output->info()->dimension(1))) :
                                 0;
        _cols_out_of_bounds[1] = _end[0] >= static_cast<int32_t>(_input->info()->dimension(1)) ? std::min(static_cast<uint32_t>(_end[0] - _input->info()->dimension(1) + 1),
                                                                                                          static_cast<uint32_t>(_output->info()->dimension(1))) :
                                 0;
    }
 
    INEKernel::configure(calculate_max_window(*_output->info()));
}

References arm_compute::calculate_max_window(), ITensorInfo::dimension(), ITensor::info(), ITensor::ptr_to_element(), ITensorInfo::set_tensor_shape(), and ITensorInfo::tensor_shape().

name()

const char* name ( ) const

inlineoverridevirtual

Name of the kernel.

Returns

Kernel name

Implements ICPPKernel.

Definition at line 40 of file NECropKernel.h.

    {
        return "NECropKernel";
    }

operator=() [1/2]

NECropKernel& operator= ( const NECropKernel &  )

delete

Prevent instances of this class from being copied (As this class contains pointers)

operator=() [2/2]

NECropKernel& operator= ( NECropKernel &&  )

default

Allow instances of this class to be moved.

run()

void run ( const Window &  window, const ThreadInfo &  info  )

overridevirtual

Execute the kernel on the passed window.

Warning

If is_parallelisable() returns false then the passed window must be equal to window()

Note

The window has to be a region within the window returned by the window() method

The width of the window has to be a multiple of num_elems_processed_per_iteration().

Parameters

[in]	window	Region on which to execute the kernel. (Must be a region of the window returned by window())
[in]	info	Info about executing thread and CPU.

Reimplemented from ICPPKernel.

Definition at line 292 of file NECropKernel.cpp.

{
    ARM_COMPUTE_UNUSED(window, info);
    ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
    ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(INEKernel::window(), window);
 
    ARM_COMPUTE_ERROR_ON(_input->info()->has_padding());
    ARM_COMPUTE_ERROR_ON(_output->info()->has_padding());
 
    const auto *uk = get_implementation(CropSelectorData{ _input->info()->data_type() });
 
    uint32_t    batch_index = *(reinterpret_cast<int32_t *>(_box_ind->ptr_to_element(Coordinates(_crop_box_ind))));
    Coordinates input_offset(0, _end[0] < _start[0] ? _start[0] - _cols_out_of_bounds[0] : _start[0] + _cols_out_of_bounds[0],
                             _end[1] < _start[1] ? _start[1] - _rows_out_of_bounds[0] : _start[1] + _rows_out_of_bounds[0], batch_index);
    execute_window(_input, _output, input_offset, _extrapolation_value, _rows_out_of_bounds, _cols_out_of_bounds, uk->ukernel, _end[1] < _start[1],
                   _cols_out_of_bounds[0] + _cols_out_of_bounds[1] < _output->info()->dimension(1), _cols_out_of_bounds[0] > 0, _cols_out_of_bounds[1] > 0,
                   _start[0] <= _end[0], _end[0] < _start[0]);
}

References ARM_COMPUTE_ERROR_ON, ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW, ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL, ARM_COMPUTE_UNUSED, arm_compute::test::validation::data_type, ITensorInfo::dimension(), ITensorInfo::has_padding(), ITensor::info(), arm_compute::test::validation::info, ITensor::ptr_to_element(), and IKernel::window().

validate()

Status validate ( const ITensorInfo *  input, const ITensorInfo *  crop_boxes, const ITensorInfo *  box_ind, const ITensorInfo *  output, uint32_t  crop_box_ind = 0, float  extrapolation_value = 0  )

static

Static function to check if given info will lead to a valid configuration of CLStridedSliceKernel.

Note

Supported tensor rank: up to 4

Padding not supported.

Parameters

[in]	input	Source tensor info. Data type supported: U8/U16/S16/U32/S32/F16/F32. Data layouts supported: NHWC.
[in]	crop_boxes	Tensor info for tensor containing all possible boxes used to crop the image. Data type supported: F32
[in]	box_ind	Tensor info for the one dimensional tensor mapping the crop_box_ind to the index of the 3D image in input. Data type supported: F32
[in]	output	Destination tensor. Data type supported: F32
[in]	crop_box_ind	Index of the crop box to be used from crop_boxes. Default is 0.
[in]	extrapolation_value	Value to be used for values outside of the image. Default is 0.

Definition at line 210 of file NECropKernel.cpp.

{
    ARM_COMPUTE_UNUSED(extrapolation_value);
    const auto *uk = get_implementation(CropSelectorData{ input->data_type() });
    ARM_COMPUTE_RETURN_ERROR_ON(uk == nullptr || uk->ukernel == nullptr);
 
    ARM_COMPUTE_RETURN_ERROR_ON_CPU_F16_UNSUPPORTED(input);
    ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::U8, DataType::U16, DataType::S16, DataType::F16, DataType::U32, DataType::S32, DataType::F32);
    ARM_COMPUTE_RETURN_ERROR_ON_DATA_LAYOUT_NOT_IN(input, DataLayout::NHWC);
    ARM_COMPUTE_RETURN_ERROR_ON(input->tensor_shape().num_dimensions() > 4);
    ARM_COMPUTE_RETURN_ERROR_ON(crop_boxes->tensor_shape()[0] != 4);
    ARM_COMPUTE_RETURN_ERROR_ON(crop_boxes->tensor_shape()[1] != box_ind->tensor_shape()[0]);
    ARM_COMPUTE_RETURN_ERROR_ON(crop_boxes->tensor_shape()[1] <= crop_box_ind);
    ARM_COMPUTE_RETURN_ERROR_ON(box_ind->tensor_shape()[0] <= crop_box_ind);
    if(output->total_size() > 0)
    {
        ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_NOT_IN(output, DataType::F32);
        ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_LAYOUT(input, output);
        ARM_COMPUTE_RETURN_ERROR_ON(output->num_dimensions() != 3);
        ARM_COMPUTE_RETURN_ERROR_ON(output->has_padding());
    }
    return Status{};
}

References ARM_COMPUTE_RETURN_ERROR_ON, ARM_COMPUTE_RETURN_ERROR_ON_CPU_F16_UNSUPPORTED, ARM_COMPUTE_RETURN_ERROR_ON_DATA_LAYOUT_NOT_IN, ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN, ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_NOT_IN, ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_LAYOUT, ARM_COMPUTE_UNUSED, arm_compute::F16, arm_compute::F32, ITensorInfo::has_padding(), arm_compute::test::validation::input, arm_compute::NHWC, ITensorInfo::num_dimensions(), arm_compute::S16, arm_compute::S32, ITensorInfo::tensor_shape(), ITensorInfo::total_size(), arm_compute::U16, arm_compute::U32, and arm_compute::U8.

Referenced by NECropKernel::configure(), and NECropResize::validate().

---

The documentation for this class was generated from the following files:

• src/core/NEON/kernels/NECropKernel.h
• src/core/NEON/kernels/NECropKernel.cpp