attribute.py

#
# Copyright (c) 2017 Texas Instruments Incorporated
#
# All rights reserved not granted herein.
#
# Limited License.
#
# Texas Instruments Incorporated grants a world-wide, royalty-free, non-exclusive
# license under copyrights and patents it now or hereafter owns or controls to make,
# have made, use, import, offer to sell and sell ("Utilize") this software subject to the
# terms herein.  With respect to the foregoing patent license, such license is granted
# solely to the extent that any such patent is necessary to Utilize the software alone.
# The patent license shall not apply to any combinations which include this software,
# other than combinations with devices manufactured by or for TI ("TI Devices").
# No hardware patent is licensed hereunder.
#
# Redistributions must preserve existing copyright notices and reproduce this license
# (including the above copyright notice and the disclaimer and (if applicable) source
# code license limitations below) in the documentation and/or other materials provided
# with the distribution
#
# Redistribution and use in binary form, without modification, are permitted provided
# that the following conditions are met:
#
#       No reverse engineering, decompilation, or disassembly of this software is
# permitted with respect to any software provided in binary form.
#
#       any redistribution and use are licensed by TI for use only with TI Devices.
#
#       Nothing shall obligate TI to provide you with source code for the software
# licensed and provided to you in object code.
#
# If software source code is provided to you, modification and redistribution of the
# source code are permitted provided that the following conditions are met:
#
#       any redistribution and use of the source code, including any resulting derivative
# works, are licensed by TI for use only with TI Devices.
#
#       any redistribution and use of any object code compiled from the source code
# and any resulting derivative works, are licensed by TI for use only with TI Devices.
#
# Neither the name of Texas Instruments Incorporated nor the names of its suppliers
#
# may be used to endorse or promote products derived from this software without
# specific prior written permission.
#
# DISCLAIMER.
#
# THIS SOFTWARE IS PROVIDED BY TI AND TI'S LICENSORS "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 TI AND TI'S LICENSORS 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.
#
#

from enum import Enum
from . import *


class ImageAttribute(Enum) :
    
    WIDTH       = ('w', 'vx_uint32')
    
    HEIGHT      = ('h', 'vx_uint32')
    
    FORMAT      = ('fmt', 'vx_df_image')
    
    PLANES      = ('planes', 'vx_size')
    
    SPACE       = ('space', 'vx_enum')
    
    RANGE       = ('range', 'vx_enum')
    
    SIZE        = ('size', 'vx_size')
    
    MEMORY_TYPE = ('memory_type', 'vx_enum')

    def vx_enum_name(attr) :
        return "VX_IMAGE_" + attr.name

    def object_type() :
        return Type.IMAGE


class PyramidAttribute(Enum) :
    
    LEVELS      = ('levels', 'vx_size')
    
    SCALE       = ('scale', 'vx_float32')
    
    WIDTH       = ('w', 'vx_uint32')
    
    HEIGHT      = ('h', 'vx_uint32')
    
    FORMAT      = ('fmt', 'vx_df_image')

    def vx_enum_name(attr) :
        return "VX_PYRAMID_" + attr.name

    def object_type() :
        return Type.PYRAMID


class ArrayAttribute(Enum) :
    
    ITEMTYPE      = ('item_type', 'vx_enum')
    
    NUMITEMS      = ('num_items', 'vx_size')
    
    CAPACITY      = ('capacity', 'vx_size')
    
    ITEMSIZE      = ('item_size', 'vx_size')

    def vx_enum_name(attr) :
        return "VX_ARRAY_" + attr.name

    def object_type() :
        return Type.ARRAY


class ScalarAttribute(Enum) :
    
    TYPE      = ('scalar_type', 'vx_enum')

    def vx_enum_name(attr) :
        return "VX_SCALAR_" + attr.name

    def object_type() :
        return Type.SCALAR


class ConvolutionAttribute(Enum) :
    
    ROWS      = ('row', 'vx_size')
    
    COLUMNS   = ('col', 'vx_size')
    
    SCALE     = ('scale', 'vx_uint32')
    
    SIZE      = ('size', 'vx_size')

    def vx_enum_name(attr) :
        return "VX_CONVOLUTION_" + attr.name

    def object_type() :
        return Type.CONVOLUTION


class MatrixAttribute(Enum) :
    
    TYPE      = ('type', 'vx_enum')
    
    ROWS      = ('h', 'vx_size')
    
    COLUMNS   = ('w', 'vx_size')
    
    SIZE      = ('size', 'vx_size')
    
    ORIGIN    = ('origin', 'vx_coordinates2d_t')
    
    PATTERN   = ('pattern', 'vx_enum')

    def vx_enum_name(attr) :
        return "VX_MATRIX_" + attr.name

    def object_type() :
        return Type.MATRIX


class LutAttribute(Enum) :
    
    TYPE      = ('type', 'vx_enum')
    
    COUNT     = ('count', 'vx_size')
    
    SIZE      = ('size', 'vx_size')
    
    OFFSET    = ('offset', 'vx_uint32')

    def vx_enum_name(attr) :
        return "VX_LUT_" + attr.name

    def object_type() :
        return Type.LUT


class DistributionAttribute(Enum) :
    
    DIMENSIONS  = ('dims', 'vx_size')
    
    OFFSET      = ('offset', 'vx_int32')
    
    RANGE       = ('range', 'vx_uint32')
    
    BINS        = ('bins', 'vx_size')
    
    WINDOW      = ('win', 'vx_uint32')
    
    SIZE        = ('size', 'vx_size')

    def vx_enum_name(attr) :
        return "VX_DISTRIBUTION_" + attr.name

    def object_type() :
        return Type.DISTRIBUTION


class ThresholdAttribute(Enum) :
    
    TYPE             = ('threshold_type', 'vx_enum')
    
    THRESHOLD_VALUE  = ('value', 'vx_int32')
    
    THRESHOLD_LOWER  = ('lower', 'vx_int32')
    
    THRESHOLD_UPPER  = ('upper', 'vx_int32')
    
    TRUE_VALUE       = ('true_value', 'vx_int32')
    
    FALSE_VALUE      = ('false_value', 'vx_int32')
    
    DATA_TYPE        = ('threshold_data_type', 'vx_enum')

    def vx_enum_name(attr) :
        return "VX_THRESHOLD_" + attr.name

    def object_type() :
        return Type.THRESHOLD


class RemapAttribute(Enum) :
    
    SOURCE_WIDTH         = ('src_w', 'vx_uint32')
    
    SOURCE_HEIGHT        = ('src_h', 'vx_uint32')
    
    DESTINATION_WIDTH    = ('dst_w', 'vx_uint32')
    
    DESTINATION_HEIGHT   = ('dst_h', 'vx_uint32')

    def vx_enum_name(attr) :
        return "VX_REMAP_" + attr.name

    def object_type() :
        return Type.REMAP


class ObjectArrayAttribute(Enum) :
    
    ITEMTYPE      = ('type', 'vx_enum')
    
    NUMITEMS      = ('num_items', 'vx_size')

    def vx_enum_name(attr) :
        return "VX_OBJECT_ARRAY_" + attr.name

    def object_type() :
        return Type.OBJECT_ARRAY


class UserDataObjectAttribute(Enum) :
    
    NAME        = ('name', 'vx_char')
    
    SIZE        = ('size', 'vx_size')

    def vx_enum_name(attr) :
        return "VX_USER_DATA_OBJECT_" + attr.name

    def object_type() :
        return Type.USER_DATA_OBJECT


class RawImageAttribute(Enum) :
    
    WIDTH              = ('w', 'vx_uint32')
    
    HEIGHT             = ('h', 'vx_uint32')
    
    MUM_EXPOSURES      = ('num_exposures', 'vx_uint32')
    
    LINE_INTERLEAVED   = ('line_interleaved', 'vx_bool')
    
    FORMAT             = ('format', 'tivx_raw_image_format_t')
    
    META_HEIGHT_BEFORE = ('meta_height_before', 'vx_uint32')
    
    META_HEIGHT_AFTER  = ('meta_height_after', 'vx_uint32')

    def vx_enum_name(attr) :
        return "TIVX_RAW_IMAGE_" + attr.name

    def object_type() :
        return Type.RAW_IMAGE


class TensorAttribute(Enum) :
    
    NUMBER_OF_DIMS         = ('number_of_dims', 'vx_size')
    
    DIMS                   = ('dims', 'vx_size')
    
    DATA_TYPE              = ('data_type', 'vx_enum')
    
    FIXED_POINT_POSITION   = ('fixed_point_position', 'vx_int8')
    
    SCALING_DIVISOR        = ('scaling_divisor', 'vx_int8')
    
    SCALING_DIVISOR_FIXED_POINT_POSITION   = ('scaling_divisor_fixed_point_position', 'vx_int8')

    def vx_enum_name(attr) :
        return "VX_TENSOR_" + attr.name

    def object_type() :
        return Type.TENSOR


class Attribute :
    Image = ImageAttribute
    Pyramid = PyramidAttribute
    Array = ArrayAttribute
    Scalar = ScalarAttribute
    Convolution = ConvolutionAttribute
    Matrix = MatrixAttribute
    Lut = LutAttribute
    Distribution = DistributionAttribute
    Threshold = ThresholdAttribute
    Remap = RemapAttribute
    ObjectArray = ObjectArrayAttribute
    UserDataObject = UserDataObjectAttribute
    RawImage = RawImageAttribute
    Tensor = TensorAttribute

    def from_type(type) :
        if type == Type.IMAGE :
            return Attribute.Image
        if type == Type.PYRAMID :
            return Attribute.Pyramid
        if type == Type.ARRAY :
            return Attribute.Array
        if type == Type.SCALAR :
            return Attribute.Scalar
        if type == Type.CONVOLUTION :
            return Attribute.Convolution
        if type == Type.MATRIX :
            return Attribute.Matrix
        if type == Type.LUT :
            return Attribute.Lut
        if type == Type.DISTRIBUTION :
            return Attribute.Distribution
        if type == Type.THRESHOLD :
            return Attribute.Threshold
        if type == Type.REMAP :
            return Attribute.Remap
        if type == Type.OBJECT_ARRAY :
            return Attribute.ObjectArray
        if type == Type.USER_DATA_OBJECT :
            return Attribute.UserDataObject
        if type == Type.RAW_IMAGE :
            return Attribute.RawImage
        if type == Type.TENSOR :
            return Attribute.Tensor
        return "INVALID"