Beatmup::Python Namespace Reference

Python binding utilities More...

Classes
class	Bitmap
	Wrapper of Android.Graphics.Bitmap object. More...
class	WritableChunkCollection
	Writable ChunkCollection implementation for Python. More...

Functions
template<typename T >
CustomPoint< T >	toPoint (const py::tuple &tuple)
template<typename T >
CustomRectangle< T >	toRectangle (const py::tuple &tuple)
template<typename T >
py::tuple	toTuple (const CustomPoint< T > &point)
template<typename T >
py::tuple	toTuple (const CustomRectangle< T > &rectangle)
template<typename T >
py::tuple	toTuple (const CustomMatrix2< T > &matrix)
py::tuple	toTuple (const color3f &color)
py::tuple	toTuple (const color4i &color)
pixfloat4	toPixfloat4 (const py::tuple &tuple)
color3f	toColor3f (const py::tuple &tuple)
color4f	toColor4f (const py::tuple &tuple)
color4i	toColor4i (const py::tuple &tuple)
py::object	getModelOutputDataByName (NNets::Model &model, const std::string &opName, int output)
py::object	getModelOutputDataByOp (NNets::Model &model, const NNets::AbstractOperation &operation, int output)

Detailed Description

Python binding utilities

Function Documentation

toPoint()

template<typename T >

CustomPoint<T> Beatmup::Python::toPoint ( const py::tuple &  tuple )

inline

Definition at line 34 of file binding_tools.hpp.

                                                            {
            if (tuple.size() != 2)
                throw std::invalid_argument("Expected a tuple of 2 elements");
            return CustomPoint<T>(tuple[0].cast<T>(), tuple[1].cast<T>());
        }

toRectangle()

template<typename T >

CustomRectangle<T> Beatmup::Python::toRectangle ( const py::tuple &  tuple )

inline

Definition at line 41 of file binding_tools.hpp.

                                                                    {
            if (tuple.size() != 4)
                throw std::invalid_argument("Expected a tuple of 4 elements");
            return CustomRectangle<T>(tuple[0].cast<T>(), tuple[1].cast<T>(), tuple[2].cast<T>(), tuple[3].cast<T>());
        }

toTuple() [1/5]

template<typename T >

py::tuple Beatmup::Python::toTuple ( const CustomPoint< T > &  point )

inline

Definition at line 49 of file binding_tools.hpp.

                                                            {
            return py::make_tuple(point.x, point.y);
        }

toTuple() [2/5]

template<typename T >

py::tuple Beatmup::Python::toTuple ( const CustomRectangle< T > &  rectangle )

inline

Definition at line 54 of file binding_tools.hpp.

                                                                    {
            return py::make_tuple(rectangle.a.x, rectangle.a.y, rectangle.b.x, rectangle.b.y);
        }

toTuple() [3/5]

template<typename T >

py::tuple Beatmup::Python::toTuple ( const CustomMatrix2< T > &  matrix )

inline

Definition at line 59 of file binding_tools.hpp.

                                                               {
            return py::make_tuple(
                py::make_tuple(matrix.getA11(), matrix.getA12()),
                py::make_tuple(matrix.getA21(), matrix.getA22())
            );
        }

toTuple() [4/5]

py::tuple Beatmup::Python::toTuple ( const color3f &  color )

inline

Definition at line 66 of file binding_tools.hpp.

                                                     {
            return py::make_tuple(color.r, color.g, color.b);
        }

toTuple() [5/5]

py::tuple Beatmup::Python::toTuple ( const color4i &  color )

inline

Definition at line 70 of file binding_tools.hpp.

                                                     {
            return py::make_tuple(color.r, color.g, color.b, color.a);
        }

toPixfloat4()

pixfloat4 Beatmup::Python::toPixfloat4 ( const py::tuple &  tuple )

inline

Definition at line 74 of file binding_tools.hpp.

                                                           {
            if (tuple.size() != 4)
                throw std::invalid_argument("Expected a tuple of 4 elements");
            return pixfloat4(tuple[0].cast<float>(), tuple[1].cast<float>(), tuple[2].cast<float>(), tuple[3].cast<float>());
        }

toColor3f()

color3f Beatmup::Python::toColor3f ( const py::tuple &  tuple )

inline

Definition at line 80 of file binding_tools.hpp.

                                                       {
            if (tuple.size() != 3)
                throw std::invalid_argument("Expected a tuple of 3 elements");
            return color3f{ tuple[0].cast<float>(), tuple[1].cast<float>(), tuple[2].cast<float>() };
        }

toColor4f()

color4f Beatmup::Python::toColor4f ( const py::tuple &  tuple )

inline

Definition at line 86 of file binding_tools.hpp.

                                                       {
            if (tuple.size() != 4)
                throw std::invalid_argument("Expected a tuple of 4 elements");
            return color4f{ tuple[0].cast<float>(), tuple[1].cast<float>(), tuple[2].cast<float>(), tuple[3].cast<float>() };
        }

toColor4i()

color4i Beatmup::Python::toColor4i ( const py::tuple &  tuple )

inline

Definition at line 92 of file binding_tools.hpp.

                                                       {
            if (tuple.size() != 4)
                throw std::invalid_argument("Expected a tuple of 4 elements");
            return color4i{ tuple[0].cast<uint8_t>(), tuple[1].cast<uint8_t>(), tuple[2].cast<uint8_t>(), tuple[3].cast<uint8_t>() };
        }

getModelOutputDataByName()

py::object Beatmup::Python::getModelOutputDataByName	(	NNets::Model &	model,
		const std::string &	opName,
		int	output
	)

Definition at line 40 of file binding_tools.cpp.

                                                                                                       {
    return getModelOutputDataByOp(model, model.getOperation(opName), output);
}

getModelOutputDataByOp()

py::object Beatmup::Python::getModelOutputDataByOp	(	NNets::Model &	model,
		const NNets::AbstractOperation &	operation,
		int	output
	)

Definition at line 22 of file binding_tools.cpp.

                                                                                                                     {
    size_t numSamples;
    auto data = model.getOutputData(numSamples, operation, output);
    auto size = operation.getOutputSize(output);
    if (!data)
        return py::none();
    if (size[0] == 1 && size[2] == 1)
        // column vector got, return flat
        return py::array_t<float>({ size[1] }, { sizeof(float) }, data);
    else
        return py::array_t<float>(
            { size[1], size[0], size[2] },      // "H, W, C"
            { size[0] * size[2] * sizeof(float), size[2] * sizeof(float), sizeof(float) },
            data
        );
}