Source code for g3d.defs.g3dentity

"""G3DEntity class definition"""
from typing import Any

import os

if os.environ.get('__USE_CUDA', '0') == '1':
    import cupy as np
else:
    import numpy as np

from g3d.defs import G3DWorld
from g3d.defs import FunctionByPass




class G3DEntity:
    """base class for any G3D entity/container"""

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        """initialize G3DEntity placeholder"""
        self._tag = ""
        self._set_default()
        self.set(*args, **kwargs)

    @property
    def tag(self) -> str:
        """tag (string) used for identification"""
        return self._tag

    @tag.setter
    def tag(self, val: str) -> None:
        self._tag = val

    def _set_default(self) -> None:
        self._tag = 'g3d_entity'



    def set(self, *args: Any, **kwargs: Any) -> None:
        """
        sets entity parameters according to specifications
        input: args, kwargs
        example: set(args, kwargs)
        """
        if len(args) != 0:
            self._set_from_args(*args, **kwargs)
        if len(kwargs) != 0:
            g3d_world = G3DWorld()
            for key, value in kwargs.items():
                if g3d_world.display.verbose:
                    if type(value) is list:
                        print('%s == list of length %s' % (key, str(len(value))))
                    elif type(value) is np.ndarray:
                        print('%s == array of size %s' % (key, str(value.shape)))
                    else:
                        print('%s == %s' % (key, str(value)))
                if not self.set_from_key_value(key, value):
                    print('warning! parameter %s is not defined' % key)


    @staticmethod
    def _get_function_evaluate_status(**kwargs: Any) -> Any:
        bps = FunctionByPass.EVALUATE
        if len(kwargs) != 0:
            for key, value in kwargs.items():
                if key == 'bps':
                    bps = value
        return bps

    def _set_from_args(self, *args: Any, **kwargs: Any) -> np.ndarray:
        bps = self._get_function_evaluate_status(**kwargs)
        args_stat = np.ones(len(args))
        if bps is FunctionByPass.EVALUATE:
            for i in range(len(args)):
                arg = args[i]
                if type(arg) is str:
                    self._tag = arg
                    args_stat[i] = 0
        return args_stat



    def set_from_key_value(self, key: str, value: Any) -> bool:
        """
        sets entity parameters from specified key => value data
        input: key, value
        valid keys for G3DCode base class:
        'tag'
        example: set_from_key_value(key, value)
        """
        if key == 'tag':
            self._tag = value
            return True
        return False




    def copy(self, e: 'G3DEntity'):
        """
        copies data from specified entity
        input: entity
        example: copy(e)
        """
        self._tag = e.tag


    @staticmethod
    def _list_is_populated(defs: list) -> bool:
        if type(defs) is not list:
            return False
        if len(defs) == 0:
            return False
        return True

    def _list_is_all_ints(self, defs: list) -> bool:
        if not self._list_is_populated(defs):
            return False
        for n in defs:
            if type(n) is not int:
                return False
        return True

    def _list_is_all_floats(self, defs: list) -> bool:
        if not self._list_is_populated(defs):
            return False
        for n in defs:
            if type(n) is not float and type(n) is not np.float64:
                return False
        return True



    def print(self) -> None:
        """
        prints entity data
        """
        print(' tag: %s' % self._tag)