Render.hpp

Go to the documentation of this file.

/*
# Copyright (c) 2014-2016, NVIDIA CORPORATION. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#  * Neither the name of NVIDIA CORPORATION nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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 THE COPYRIGHT OWNER OR
# CONTRIBUTORS 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.
*/

#ifndef NVXIO_RENDER_HPP
#define NVXIO_RENDER_HPP

#include <memory>
#include <string>

#include <VX/vx.h>
#include <NVXIO/Export.hpp>

#ifndef __ANDROID__
#include <NVXIO/Application.hpp>
#endif

namespace nvxio
{
class NVXIO_EXPORT Render
{
public:

    enum TargetType
    {
        UNKNOWN_RENDER, 
        WINDOW_RENDER, 
        VIDEO_RENDER, 
        IMAGE_RENDER 
    };

    struct TextBoxStyle
    {
        vx_uint8 color[4]; 
        vx_uint8 bgcolor[4]; 
        vx_coordinates2d_t origin; 
    };

    struct FeatureStyle
    {
        vx_uint8 color[4]; 
        float radius; 
    };

    struct LineStyle
    {
        vx_uint8 color[4]; 
        int thickness; 
    };

    struct MotionFieldStyle
    {
        vx_uint8 color[4]; 
    };


    struct DetectedObjectStyle
    {
        std::string label;
        vx_uint8 color[4];
        vx_uint8 thickness;
        vx_uint8 radius;
        bool isHalfTransparent;
    };

    struct CircleStyle
    {
        vx_uint8 color[4]; 
        int thickness; 
    };

#ifndef __ANDROID__

    enum MouseButtonEvent
    {
        LeftButtonDown, 
        LeftButtonUp, 
        MiddleButtonDown, 
        MiddleButtonUp, 
        RightButtonDown, 
        RightButtonUp, 
        MouseMove 
    };

    typedef void (*OnKeyboardEventCallback)(void* context, vx_char key, vx_uint32 x, vx_uint32 y);

    typedef void (*OnMouseEventCallback)(void* context, MouseButtonEvent event, vx_uint32 x, vx_uint32 y);

    virtual void setOnKeyboardEventCallback(OnKeyboardEventCallback callback, void* context) = 0;

    virtual void setOnMouseEventCallback(OnMouseEventCallback callback, void* context) = 0;
#endif

    virtual void putImage(vx_image image) = 0;

    virtual void putTextViewport(const std::string& text, const TextBoxStyle& style) = 0;

    virtual void putFeatures(vx_array location, const FeatureStyle& style) = 0;

    virtual void putFeatures(vx_array location, vx_array styles) = 0;

    virtual void putLines(vx_array lines, const LineStyle& style) = 0;

    virtual void putConvexPolygon(vx_array vertices, const LineStyle& style) = 0;

    virtual void putMotionField(vx_image field, const MotionFieldStyle& style) = 0;

    virtual void putObjectLocation(const vx_rectangle_t& location, const DetectedObjectStyle& style) = 0;

    virtual void putCircles(vx_array circles, const CircleStyle& style) = 0;

    virtual void putArrows(vx_array old_points, vx_array new_points,
                           const LineStyle& style) = 0;

#ifndef __ANDROID__

    virtual bool flush() = 0;

    virtual void close() = 0;
#endif

    TargetType getTargetType() const
    {
        return targetType;
    }

    std::string getRenderName() const
    {
        return renderName;
    }

    virtual vx_uint32 getViewportWidth() const = 0;

    virtual vx_uint32 getViewportHeight() const = 0;

    virtual ~Render()
    {}

protected:

    Render(TargetType type = Render::UNKNOWN_RENDER, std::string name = "Undefined"):
        targetType(type),
        renderName(name)
    {}

    const TargetType  targetType;
    const std::string renderName;
};

#ifdef __ANDROID__

NVXIO_EXPORT std::unique_ptr<Render> createRender(vx_context context, vx_uint32 width, vx_uint32 height, bool doScale = true);

#else

NVXIO_EXPORT std::unique_ptr<Render> createDefaultRender(vx_context context, const std::string& title, vx_uint32 width, vx_uint32 height,
                                                         vx_uint32 format = VX_DF_IMAGE_RGBX, bool doScale = true,
                                                         bool fullScreen = nvxio::Application::get().getFullScreenFlag());

NVXIO_EXPORT std::unique_ptr<Render> createVideoRender(vx_context context, const std::string& path, vx_uint32 width,
                                                       vx_uint32 height, vx_uint32 format = VX_DF_IMAGE_RGBX);

NVXIO_EXPORT std::unique_ptr<Render> createWindowRender(vx_context context, const std::string& title, vx_uint32 width, vx_uint32 height,
                                                        vx_uint32 format = VX_DF_IMAGE_RGBX, bool doScale = true,
                                                        bool fullscreen = nvxio::Application::get().getFullScreenFlag());

NVXIO_EXPORT std::unique_ptr<Render> createImageRender(vx_context context, const std::string& path, vx_uint32 width, vx_uint32 height,
                                                       vx_uint32 format = VX_DF_IMAGE_RGBX);

#endif

}
#endif // NVXIO_RENDER_HPP