omni::WarpGrid Class Reference

A warp grid is a 2D bezier grid with MxN points Default size 6x6 points. Selected points are also stored: More...

#include <WarpGrid.h>

Collaboration diagram for omni::WarpGrid:

Public Types
enum	Interpolation { Interpolation::BICUBIC, Interpolation::LINEAR }

Public Member Functions
	WarpGrid ()
	Default constructor. More...
void	reset ()
	Resets all points to form a regular grid. More...
void	resize (int _horz, int _vert)
	Resize grid with given horizontal and vertical resolution. More...
int	vertical () const
	Return vertical resolution. More...
int	horizontal () const
	Return horizontal resolution. More...
Interpolation	interpolation () const
	Return interpolation type (BICUBIC is default) More...
void	setInterpolation (Interpolation)
	Interpolation value. More...
bool	isReset () const
	Returns true if all warp points are in regular position. More...
bool	hasChanged () const
	Return true if warp grid has changed. More...
void	selectAll ()
	Select all points. More...
WarpPoint *	selectNearest (const QPointF &_p)
	Select nearest point, does not clear selection, returns pointer to. More...
void	selectNone ()
	Clear selection. More...
std::set< WarpPoint * >	getSelected ()
	Returns pointer set of selected points. More...
std::set< WarpPoint const * >	getSelected () const
	Returns pointer set of selected points (const version) More...
WarpPoint *	getPoint (int x, int y)
	Get point with x and y index. More...
WarpPoint const *	getPoint (int x, int y) const
	Get point with x and y index (const version) More...
QVector2D	getWarpPointPos (int x, int y) const
	Return position of warp point. More...
QVector2D	getWarpPointPos (int x, int y, float u, float v) const
	Return interpolated position of warp point x, y. More...
QVector2D	getTexCoord (int _x, int _y) const
	Return texture coordinate on x,y index. More...
std::vector< WarpPoint > const &	points () const
	Return const reference to warp points. More...

Private Types
typedef std::array< QVector2D, 4 >	array4_type

Private Member Functions
size_t	getNearest (const QPointF &_p) const
	Return index to nearest point. More...
QVector2D	cubicInterpolate (const array4_type &_points, float t) const
	Interpolate four points. More...

Private Attributes
int	horizontal_ = 4
int	vertical_ = 4
bool	hasChanged_ = true
Interpolation	interpolation_ = Interpolation::BICUBIC
std::vector< WarpPoint >	points_

Friends
bool	operator== (WarpGrid const &, WarpGrid const &)
	Test for equality (is equal if all warp points are equal. More...

Detailed Description

A warp grid is a 2D bezier grid with MxN points Default size 6x6 points. Selected points are also stored:

Member Typedef Documentation

typedef std::array<QVector2D, 4> omni::WarpGrid::array4_type

private

Member Enumeration Documentation

enum omni::WarpGrid::Interpolation

strong

Enumerator
BICUBIC
LINEAR

                               {
        BICUBIC,
        LINEAR
      };

Constructor & Destructor Documentation

omni::WarpGrid::WarpGrid

(

)

Default constructor.

                       :
        horizontal_(4),
        vertical_(4)
    {
        reset();
    }

Member Function Documentation

QVector2D omni::WarpGrid::cubicInterpolate ( const array4_type &  _points, float  t  ) const

private

Interpolate four points.

    {
        return knots[1] + 0.5f * t * (knots[2] - knots[0] +
                                      t * (2.0f * knots[0] - 5.0f * knots[1] +
                                           4.0f * knots[2] - knots[3] +
                                           t * (3.0f * (knots[1] - knots[2]) +
                                                knots[3] - knots[0])));
    }

size_t omni::WarpGrid::getNearest ( const QPointF &  _p ) const

private

Return index to nearest point.

    {
        float  _nearestDist = std::numeric_limits<float>::max();
        size_t _nearestIdx  = -1;

        for (size_t i = 0; i < points_.size(); ++i)
        {
            auto& _point = points_[i];
            auto  _dist  = QVector2D(_p - _point.pos()).lengthSquared();

            if (_dist < _nearestDist)
            {
                _nearestIdx  = i;
                _nearestDist = _dist;
            }
        }
        return _nearestIdx;
    }

WarpPoint * omni::WarpGrid::getPoint	(	int	x,
		int	y
	)

Get point with x and y index.

    {
        if ((x < 0) || (y < 0)) return nullptr;

        if ((x >= horizontal_) || (y >= vertical_)) return nullptr;
        hasChanged_ = true;

        return &points_[y * horizontal_ + x];
    }

WarpPoint const * omni::WarpGrid::getPoint	(	int	x,
		int	y
	)		const

Get point with x and y index (const version)

    {
        if ((x < 0) || (y < 0)) return nullptr;

        if ((x >= horizontal_) || (y >= vertical_)) return nullptr;

        return &points_[y * horizontal_ + x];
    }

std::set< WarpPoint * > omni::WarpGrid::getSelected

(

)

Returns pointer set of selected points.

    {
        std::set<WarpPoint *> _selection;

        hasChanged_ = true;

        for (auto& _point : points_)
            if (_point.selected()) _selection.insert(&_point);
        return _selection;
    }

std::set< WarpPoint const * > omni::WarpGrid::getSelected

(

)

const

Returns pointer set of selected points (const version)

    {
        std::set<WarpPoint const *> _selection;

        for (auto& _point : points_)
            if (_point.selected()) _selection.insert(&_point);
        return _selection;
    }

QVector2D omni::WarpGrid::getTexCoord	(	int	_x,
		int	_y
	)		const

Return texture coordinate on x,y index.

    {
        return QVector2D(float(_x) / (horizontal() - 1),
                         float(_y) / (vertical() - 1));
    }

QVector2D omni::WarpGrid::getWarpPointPos	(	int	x,
		int	y
	)		const

Return position of warp point.

    {
        int maxX = horizontal() - 1;
        int maxY = vertical() - 1;

        // here's the magic: extrapolate points beyond the edges
        if (x < 0) {
            return QVector2D(
                2.0f * getWarpPointPos(0, y) - getWarpPointPos(0 - x, y));
        }

        if (y < 0) {
            return QVector2D(
                2.0f * getWarpPointPos(x, 0) - getWarpPointPos(x, 0 - y));
        }

        if (x > maxX) {
            return QVector2D(2.0f * getWarpPointPos(maxX, y) - getWarpPointPos(
                                 2 * maxX - x,
                                 y));
        }

        if (y > maxY) {
            return QVector2D(
                2.0f * getWarpPointPos(x, maxY)
                - getWarpPointPos(x, 2 * maxY - y));
        }


        return QVector2D(getPoint(x, y)->pos());
    }

QVector2D omni::WarpGrid::getWarpPointPos	(	int	x,
		int	y,
		float	u,
		float	v
	)		const

Return interpolated position of warp point x, y.

                                                                            {
        switch (interpolation_) {
        default:

        // perform linear interpolation
        case Interpolation::LINEAR:
        {
            auto _p00 = getWarpPointPos(x + 0, y + 0);
            auto _p10 = getWarpPointPos(x + 1, y + 0);
            auto _p01 = getWarpPointPos(x + 0, y + 1);
            auto _p11 = getWarpPointPos(x + 1, y + 1);
            QVector2D p1((1.0f - u) * _p00 + u * _p10);
            QVector2D p2((1.0f - u) * _p01 + u * _p11);
            return QVector2D((1.0f - v) * p1 + v * p2);
        }
        // perform bicubic interpolation
        case Interpolation::BICUBIC:
        {
            array4_type _rows, _cols;
            for (int i = -1; i < 3; ++i) {
                for (int j = -1; j < 3; ++j) {
                    _cols[j + 1] = getWarpPointPos(x + i, y + j);
                }
                _rows[i + 1] = cubicInterpolate(_cols, v);
            }
            return cubicInterpolate(_rows, u);
        }
        }
        return QVector2D(0.0, 0.0);
    }

bool omni::WarpGrid::hasChanged

(

)

const

Return true if warp grid has changed.

                                    {
        return hasChanged_;
    }

int omni::WarpGrid::horizontal

(

)

const

Return horizontal resolution.

    {
        return horizontal_;
    }

WarpGrid::Interpolation omni::WarpGrid::interpolation

(

)

const

Return interpolation type (BICUBIC is default)

                                                        {
        return interpolation_;
    }

bool omni::WarpGrid::isReset

(

)

const

Returns true if all warp points are in regular position.

    {
        for (size_t y = 0; y < vertical(); ++y)
            for (size_t x = 0; x < horizontal(); ++x)
            {
                if (QVector2D(getPoint(x,
                                       y)->pos()) !=
                    (getTexCoord(x, y) - QVector2D(0.5, 0.5))) return false;
            }

        return true;
    }

std::vector< WarpPoint > const & omni::WarpGrid::points

(

)

const

Return const reference to warp points.

    {
        return points_;
    }

void omni::WarpGrid::reset

(

)

Resets all points to form a regular grid.

    {
        points_.clear();
        points_.reserve(vertical() * horizontal());

        for (size_t y = 0; y < vertical(); ++y)
            for (size_t x = 0; x < horizontal();
                 ++x) points_.emplace_back((getTexCoord(x, y) - QVector2D(0.5,
                                                                          0.5)).toPointF());
        hasChanged_ = true;
    }

void omni::WarpGrid::resize	(	int	_horz,
		int	_vert
	)

Resize grid with given horizontal and vertical resolution.

    {
        if ((_horz < 2) || (_vert < 2) ||
            ((_horz == horizontal_) && (_vert == vertical_))) return;

        horizontal_ = _horz;
        vertical_   = _vert;
        reset();
    }

void omni::WarpGrid::selectAll

(

)

Select all points.

    {
        for (auto& _point : points_) _point.setSelected(true);
    }

WarpPoint * omni::WarpGrid::selectNearest

(

const QPointF &

_p

)

Select nearest point, does not clear selection, returns pointer to.

    {
        size_t _nearestIdx = getNearest(_p);
        auto   _nearest    =
            (_nearestIdx == -1) ? nullptr : &points_[_nearestIdx];
        hasChanged_ = true;

        return _nearest;
    }

void omni::WarpGrid::selectNone

(

)

Clear selection.

    {
        for (auto& _point : points_) _point.setSelected(false);
    }

void omni::WarpGrid::setInterpolation

(

Interpolation

_interpolation

)

Interpolation value.

                                                                {
        interpolation_ = _interpolation;
        hasChanged_ = true;
    }

int omni::WarpGrid::vertical

(

)

const

Return vertical resolution.

    {
        return vertical_;
    }

Friends And Related Function Documentation

bool operator== ( WarpGrid const &  _lhs, WarpGrid const &  _rhs  )

friend

Test for equality (is equal if all warp points are equal.

    {
        return
            OMNI_TEST_MEMBER_EQUAL(horizontal_) &&
            OMNI_TEST_MEMBER_EQUAL(vertical_) &&
            OMNI_TEST_MEMBER_EQUAL(points_);
    }

Field Documentation

bool omni::WarpGrid::hasChanged_ = true

private

int omni::WarpGrid::horizontal_ = 4

private

Interpolation omni::WarpGrid::interpolation_ = Interpolation::BICUBIC

private

std::vector<WarpPoint> omni::WarpGrid::points_

private

int omni::WarpGrid::vertical_ = 4

private

---

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

• include/omni/WarpGrid.h
• src/lib/WarpGrid.cpp