omni::visual::Tuning Class Reference

Tuning visualizer. More...

#include <Tuning.h>

Collaboration diagram for omni::visual::Tuning:

Public Member Functions
	Tuning (omni::proj::Tuning &)
	~Tuning ()
omni::proj::Tuning const &	tuning () const
void	update ()
	Update shaders, warp grid and blend texture. More...
void	updateBlendTexture ()
	Updates blend texture after it has changed by blend brush. More...
void	updateWarpGrid ()
	Update warp grid mesh. More...
void	setBlendTextureUpdateRect (QRect const &)
	Set portion of blend mask which is to be updated. More...
void	drawTestCard (int _id, bool _grayscale=false)
	Draw Test card image for screen setup. More...
void	drawWarpGrid () const
	Draws warp grid with lines and handles. More...
void	drawWarpPatch () const
	Draw warp grip without lines and handles. More...
void	drawOutput (float _inputOpacity=0.0, QColor const &_color=Qt::white, float _blendMaskOpacity=1.0, bool _grayscale=true) const
	Draws Blendmask with warp grid and brush stroke layer. More...
void	drawCursor (QPointF const &_pos)
	Draw cursor for blend brush. More...
bool	initialized () const
void	updateWarpBuffer (visual::Session const *_vizSession)
	Update warp buffer which contains image of projector perspective. More...
void	generateCalibrationData ()
void	drawCalibratedInput (bool _flipped=false)

Private Member Functions
QRectF	tuningRect () const
	Calculates rectangle of this tuning. More...
QVector4D	channelCorrectionAsVec (Channel) const
	Return QVector4D of channel correction parameters. More...

Private Attributes
omni::proj::Tuning &	tuning_
ContextBoundPtr< visual::WarpGrid >	warpGrid_
ContextBoundPtr< QOpenGLTexture >	blendTex_
ContextBoundPtr< Framebuffer32F >	calibrationFramebuffer_
proj::Calibration	calibration_
ContextBoundPtr < QOpenGLFramebufferObject >	warpGridBuffer_
	Frame buffer which holds a texture with current view image. More...
ContextBoundPtr < QOpenGLFramebufferObject >	testCardFrameBuffer_
QRect	blendTextureUpdateRect_

Static Private Attributes
static ContextBoundPtr < QOpenGLShaderProgram >	calibrationShader_
static ContextBoundPtr < QOpenGLShaderProgram >	testCardShader_
static ContextBoundPtr < QOpenGLShaderProgram >	blendShader_
static ContextBoundPtr < QOpenGLShaderProgram >	blendBrushShader_
static ContextBoundPtr < QOpenGLShaderProgram >	blendBrushCursorShader_

Detailed Description

Tuning visualizer.

Constructor & Destructor Documentation

omni::visual::Tuning::Tuning

(

omni::proj::Tuning &

_tuning

)

                                          :
      tuning_(_tuning)
    {}

omni::visual::Tuning::~Tuning

(

)

{}

Member Function Documentation

QVector4D omni::visual::Tuning::channelCorrectionAsVec ( Channel  _channel ) const

private

Return QVector4D of channel correction parameters.

                                                                   {
      QVector4D _vec(0.0, 0.0, 0.0, 0.0);
      auto     *_channelCorrection = calibration_.colorCorrection().correction(
        _channel);

      if (!_channelCorrection) return _vec;

      _vec.setX(_channelCorrection->gamma());
      _vec.setY(_channelCorrection->brightness());
      _vec.setZ(_channelCorrection->contrast());
      _vec.setW(_channelCorrection->multiplier());
      return _vec;
    }

void omni::visual::Tuning::drawCalibratedInput

(

bool

_flipped = false

)

                                                  {
      if (!calibrationShader_) return;

      auto *_currentInput = tuning().session().inputs().current();
      if (!_currentInput) return;

      if (!calibrationFramebuffer_) {
        generateCalibrationData();
      }

      withCurrentContext([&](QOpenGLFunctions& _) {
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        QMatrix4x4 _m;
        if (_flipped) {
          _m.ortho(0.5, -0.5, 0.5, -0.5, -1.0, 1.0);
        } else {
          _m.ortho(-0.5, 0.5, -0.5, 0.5, -1.0, 1.0);

        }
        glMultMatrixf(_m.constData());

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        useShader(*calibrationShader_, [&](UniformHandler& _h) {
          _h.texUniform("image", _currentInput->textureId(),
                        GL_TEXTURE_RECTANGLE);
          _h.texUniform("uv_map", calibrationFramebuffer_->texture());
          _h.uniform("image_size",
                     QVector2D(_currentInput->width(),
                               _currentInput->height()));
          _h.uniform("cc_red_vec",
                     channelCorrectionAsVec(
                       Channel::RED));
          _h.uniform("cc_green_vec",
                     channelCorrectionAsVec(Channel::
                                            GREEN));
          _h.uniform("cc_blue_vec",
                     channelCorrectionAsVec(
                       Channel::BLUE));
          _h.uniform("cc_all_vec",
                     channelCorrectionAsVec(
                       Channel::ALL));

          Rectangle::draw(-0.5, 0.5, 0.5, -0.5);
        });
      });
    }

void omni::visual::Tuning::drawCursor

(

QPointF const &

_pos

)

Draw cursor for blend brush.

    {
      auto _rect = tuningRect();

      withCurrentContext([&](QOpenGLFunctions& _)
      {
        _.glEnable(GL_BLEND);

        useShader(*blendBrushCursorShader_, [&](UniformHandler& _h) {
          float _rX = tuning_.blendMask().brushSize() * 0.5 / tuning_.width();
          float _rY = _rX * (_rect.height() / _rect.width());
          _h.uniform("width", GLfloat(0.002 / _rX));
          _h.uniform("soft", GLfloat(0.0005 / _rX));
          Rectangle::draw(_pos.x() - _rX, _pos.x() + _rX, _pos.y() + _rY,
                          _pos.y() - _rY);
        });
      });
    }

void omni::visual::Tuning::drawOutput	(	float	_inputOpacity = 0.0,
		QColor const &	_color = Qt::white,
		float	_blendMaskOpacity = 1.0,
		bool	_grayscale = true
	)		const

Draws Blendmask with warp grid and brush stroke layer.

    {
      if (!blendShader_) return;

      withCurrentContext([&](QOpenGLFunctions& _) {
        _.glEnable(GL_DEPTH_TEST);
        _.glEnable(GL_BLEND);
        _.glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

        if (!warpGridBuffer_) return;

        GLuint _inputTexId = warpGridBuffer_->texture();

        auto& _mask = tuning().blendMask();

        useShader(*blendShader_, [&](UniformHandler& _h) {
          _h.uniform("top", _mask.topWidth());
          _h.uniform("right", _mask.rightWidth());
          _h.uniform("bottom", _mask.bottomWidth());
          _h.uniform("left", _mask.leftWidth());
          _h.uniform("edge_gamma",    _mask.gamma());
          _h.texUniform("input_tex",     _inputTexId);
          _h.uniform("input_opacity", _inputOpacity);
          _h.uniform("color",         _color.redF(),
                     _color.greenF(),
                     _color.blueF());
          _h.uniform("gray_output",   _grayscale);

          auto& _cC = tuning().colorCorrection();

          if (_cC.isUsed()) {
            _h.uniform("cc_gamma", QVector4D(
                         _cC.red().gamma(),
                         _cC.green().gamma(),
                         _cC.blue().gamma(),
                         _cC.all().gamma()));
            _h.uniform("cc_brightness", QVector4D(
                         _cC.red().brightness(),
                         _cC.green().brightness(),
                         _cC.blue().brightness(),
                         _cC.all().brightness()));
            _h.uniform("cc_contrast", QVector4D(
                         _cC.red().contrast(),
                         _cC.green().contrast(),
                         _cC.blue().contrast(),
                         _cC.all().contrast()));
            _h.uniform("cc_multiplier", QVector4D(
                         _cC.red().multiplier(),
                         _cC.green().multiplier(),
                         _cC.blue().multiplier(),
                         _cC.all().multiplier()));
          } else {
            QVector4D _null(0.0, 0.0, 0.0, 0.0);
            _h.uniform("cc_multiplier", _null);
            _h.uniform("cc_contrast",   _null);
            _h.uniform("cc_brightness", _null);
            _h.uniform("cc_gamma",      _null);
          }

          _h.uniform("mask",
                     GLfloat(_blendMaskOpacity));
          warpGrid_->draw();
        });

        if (_blendMaskOpacity > 0.0) {
          glColor4f(0.0, 0.0, 0.0, 1.0);
          float _b = 4.0;


          // Draw masks for borders
          glBegin(GL_QUADS);
          {
            glVertex2f(-0.5,      -0.5 - _b);
            glVertex2f(0.5 - _b,  -0.5);
            glVertex2f(0.5 - _b,  0.5);
            glVertex2f(-0.5,      0.5 + _b);
            glVertex2f(-0.5 + _b, -0.5 - _b);
            glVertex2f(0.5,       -0.5);
            glVertex2f(0.5,       0.5);
            glVertex2f(-0.5 + _b, 0.5 + _b);
            glVertex2f(-0.5 + _b, 0.5 + _b);
            glVertex2f(0.5 - _b,  0.5 + _b);
            glVertex2f(0.5 - _b,  0.5);
            glVertex2f(-0.5 + _b, 0.5);
            glVertex2f(-0.5 + _b, -0.5);
            glVertex2f(0.5 - _b,  -0.5);
            glVertex2f(0.5 - _b,  -0.5 - _b);
            glVertex2f(-0.5 + _b, -0.5 - _b);
          }
          glEnd();

          useShader(*blendBrushShader_, [&](UniformHandler& _h) {
            _h.texUniform("blend_tex", *blendTex_);
            Rectangle::drawFlipped();
          });
        }
      });
    }

void omni::visual::Tuning::drawTestCard	(	int	_id,
		bool	_grayscale = false
	)

Draw Test card image for screen setup.

    {
      if (!testCardFrameBuffer_) return;

      withCurrentContext([&](QOpenGLFunctions& _) {
        _.glEnable(GL_TEXTURE_2D);
  _.glDisable(GL_LIGHTING);
        glColor4f(1.0,1.0,1.0,1.0);
        _.glBindTexture(GL_TEXTURE_2D,testCardFrameBuffer_->texture());
        Rectangle::draw();
        _.glBindTexture(GL_TEXTURE_2D,0);
        _.glDisable(GL_TEXTURE_2D);
      });
    }

void omni::visual::Tuning::drawWarpGrid

(

)

const

Draws warp grid with lines and handles.

Parameters

_rect

Screen Rectangle of input

    {
      if (!warpGrid_) return;
      warpGrid_->drawLines();
      warpGrid_->drawHandles(tuning_.color(), tuningRect());
    }

void omni::visual::Tuning::drawWarpPatch

(

)

const

Draw warp grip without lines and handles.

    {
      warpGrid_->draw();
    }

void omni::visual::Tuning::generateCalibrationData

(

)

                                         {
      calibration_.setRenderSize(QSize(tuning_.width(),
                                       tuning_.height()));
      calibration_.render(tuning_,calibrationFramebuffer_);
    }

bool omni::visual::Tuning::initialized

(

)

const

    {
      return !!blendTex_ && !!blendShader_ && !!testCardShader_;
    }

void omni::visual::Tuning::setBlendTextureUpdateRect

(

QRect const &

_rect

)

Set portion of blend mask which is to be updated.

    {
      int _radius = tuning_.blendMask().brushSize() / 2 + 1;

      blendTextureUpdateRect_ = _rect.normalized().adjusted(-_radius,
                                                            -_radius,
                                                            _radius,
                                                            _radius)
                                & QRect(0, 0,
                                        tuning_.width(), tuning_.height());
    }

omni::proj::Tuning const & omni::visual::Tuning::tuning

(

)

const

    {
      return tuning_;
    }

QRectF omni::visual::Tuning::tuningRect ( ) const

private

Calculates rectangle of this tuning.

    {
      float _projAspect = float(tuning_.width()) / tuning_.height();
      float _left       = -0.5, _right = 0.5, _bottom = -0.5, _top = 0.5;

      if (_projAspect > 1.0)
      {
        _top    *= _projAspect;
        _bottom *=  _projAspect;
      }
      else
      {
        _left  /= _projAspect;
        _right /= _projAspect;
      }
      return QRectF(QPointF(_left, _top), QPointF(_right, _bottom));
    }

void omni::visual::Tuning::update

(

)

Update shaders, warp grid and blend texture.

    {
      using omni::util::fileToStr;

      primaryContextSwitch([&](QOpenGLFunctions& _) {
        initShader(testCardShader_, "testcard");
        initShader(blendShader_, "blend");
        initShader(blendBrushShader_, "blendbrush");
        initShader(blendBrushCursorShader_, "blendBrushCursor");
        initShader(calibrationShader_, "calibration");

        if (!testCardFrameBuffer_ ||
          testCardFrameBuffer_->width() != tuning_.width() ||
          testCardFrameBuffer_->height() != tuning_.height()) {
          QOpenGLFramebufferObjectFormat _format;
          _format.setMipmap(true);
          _format.setSamples(0);
          _format.setAttachment(QOpenGLFramebufferObject::NoAttachment);
          testCardFrameBuffer_.reset(new QOpenGLFramebufferObject(
            tuning_.width(),
            tuning_.height(),
            _format));
        }
      });

      updateWarpGrid();
      updateBlendTexture();

      draw_on_framebuffer(testCardFrameBuffer_.get(),[&](QOpenGLFunctions& _) {
        QMatrix4x4 _m;
        _m.ortho(-0.5,0.5,0.5,-0.5,-1.0,1.0);
        glMultMatrixf(_m.constData());
      }, [&](QOpenGLFunctions& _) {
  glColor4f(1.0,1.0,1.0,1.0);
  _.glDisable(GL_LIGHTING);
        auto _color    = tuning_.color();
        GLfloat _red   = _color.redF();
        GLfloat _green = _color.greenF();
        GLfloat _blue  = _color.blueF();
        testCardShader_->bind();
        testCardShader_->setUniformValue("resolution",
                                       GLfloat(tuning_.width()),
                                       GLfloat(tuning_.height()));
        testCardShader_->setUniformValue("test_color",   _red,
                                       _green,
                                       _blue);
        testCardShader_->setUniformValue("projector_id", GLint(tuning_.id() + 1));
        testCardShader_->setUniformValue("gray_output",  false);
        Rectangle::draw();
        testCardShader_->release();
      });
    }

void omni::visual::Tuning::updateBlendTexture

(

)

Updates blend texture after it has changed by blend brush.

Transform tuning sized rect to stroke buffer sized rect

Optimization for uploading only a portion of the blend

    {
        const int _resolution = BlendMask::resolution();
        auto _fullRect = QRect(0, 0, _resolution, _resolution);

        if (!blendTex_)
        {
          primaryContextSwitch([&](QOpenGLFunctions& _) {

          // Reset blend texture
          blendTextureUpdateRect_ = _fullRect;

          if (!blendTex_.reset(new QOpenGLTexture(tuning_.blendMask().
                                             strokeBuffer().toQImage()))) {
                                               return;
                                             }
          blendTex_->bind();
          _.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
                            GL_CLAMP_TO_EDGE);
          _.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
                            GL_CLAMP_TO_EDGE);
          _.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
                            GL_LINEAR);
          _.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                            GL_LINEAR);
          blendTex_->release();
          });
        }


      withCurrentContext([&](QOpenGLFunctions& _)
      {
        auto& _blendMask = tuning().blendMask();
        auto _ptr = _blendMask.strokeBufferData();

        /// Transform tuning sized rect to stroke buffer sized rect
        auto _transformRect = [&](QRect const& _rect) -> QRect {
                                auto _res = BlendMask::resolution();
                                return QRect(
                                  _res * _rect.x() / tuning_.width(),
                                  _res * _rect.y() / tuning_.height(),
                                  _res * _rect.width() / tuning_.width(),
                                  _res * _rect.height() / tuning_.height());
                              };

        /// Optimization for uploading only a portion of the blend
        // buffer to texture
        if (blendTextureUpdateRect_ != _fullRect)
        {
          auto _r = _transformRect(blendTextureUpdateRect_) & _fullRect;
          auto _data = _blendMask.strokeBuffer().cropRect(_r);
          _ptr = (void *)(_data.data().data());
          _.glBindTexture(GL_TEXTURE_2D, blendTex_->textureId());
          _.glPixelStorei(GL_UNPACK_ALIGNMENT,   1);
          _.glPixelStorei(GL_UNPACK_ROW_LENGTH,  0);
          _.glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
          _.glPixelStorei(GL_UNPACK_SKIP_ROWS,   0);
          _.glTexSubImage2D(GL_TEXTURE_2D, 0, _r.x(), _r.y(),
                            _r.width(), _r.height(), GL_RED,
                            GL_UNSIGNED_BYTE, _ptr);
          _.glBindTexture(GL_TEXTURE_2D, 0);
          blendTextureUpdateRect_ = _fullRect;
        } else
        {
          auto _r = _fullRect;
          _.glBindTexture(GL_TEXTURE_2D, blendTex_->textureId());
          _.glTexSubImage2D(GL_TEXTURE_2D, 0, _r.x(), _r.y(),
                            _r.width(), _r.height(), GL_RED,
                            GL_UNSIGNED_BYTE, _ptr);
          _.glBindTexture(GL_TEXTURE_2D, 0);
        }
      });
    }

void omni::visual::Tuning::updateWarpBuffer

(

visual::Session const *

_vizSession

)

Update warp buffer which contains image of projector perspective.

    {
        primaryContextSwitch([&](QOpenGLFunctions& _) {
        // If tuning size has changed, reset warpGrid framebuffer
        if (warpGridBuffer_)
        {
          if ((warpGridBuffer_->width() != tuning().width()) ||
              (warpGridBuffer_->height() !=
               tuning().height())) warpGridBuffer_.reset();
        }

        // If warp grid framebuffer is empty, make a new one
        if (!warpGridBuffer_)
        {
          if (!warpGridBuffer_.reset(new QOpenGLFramebufferObject(
                                       tuning().width(),
                                       tuning().height()))) return;

          warpGridBuffer_->setAttachment(QOpenGLFramebufferObject::Depth);
        }
      });

        // Draw projector's perspective on framebuffer texture
        draw_on_framebuffer(warpGridBuffer_.get(),
                            [&](QOpenGLFunctions& _) // Projection
                                                     // Operation
        {
          glMultMatrixf(tuning().projector().projectionMatrix().constData());
        },
                            [&](QOpenGLFunctions& _) // Model View
                                                     // Operation
        {
          _.glClear(
          GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
          _.glEnable(GL_DEPTH_TEST);
          _vizSession->drawCanvas();
          _vizSession->drawCanvasWireframe();
        });
    }

void omni::visual::Tuning::updateWarpGrid

(

)

Update warp grid mesh.

                                {
      if (!warpGrid_) {
        if (!warpGrid_.reset(new visual::WarpGrid(tuning_.warpGrid()))) return;
      }

      warpGrid_->update();
    }

Field Documentation

ContextBoundPtr< QOpenGLShaderProgram > omni::visual::Tuning::blendBrushCursorShader_

staticprivate

ContextBoundPtr< QOpenGLShaderProgram > omni::visual::Tuning::blendBrushShader_

staticprivate

ContextBoundPtr< QOpenGLShaderProgram > omni::visual::Tuning::blendShader_

staticprivate

ContextBoundPtr<QOpenGLTexture> omni::visual::Tuning::blendTex_

private

QRect omni::visual::Tuning::blendTextureUpdateRect_

private

proj::Calibration omni::visual::Tuning::calibration_

private

ContextBoundPtr<Framebuffer32F> omni::visual::Tuning::calibrationFramebuffer_

private

ContextBoundPtr< QOpenGLShaderProgram > omni::visual::Tuning::calibrationShader_

staticprivate

ContextBoundPtr<QOpenGLFramebufferObject> omni::visual::Tuning::testCardFrameBuffer_

private

ContextBoundPtr< QOpenGLShaderProgram > omni::visual::Tuning::testCardShader_

staticprivate

omni::proj::Tuning& omni::visual::Tuning::tuning_

private

ContextBoundPtr<visual::WarpGrid> omni::visual::Tuning::warpGrid_

private

ContextBoundPtr<QOpenGLFramebufferObject> omni::visual::Tuning::warpGridBuffer_

private

Frame buffer which holds a texture with current view image.

---

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

• include/omni/visual/Tuning.h
• src/lib/visual/Tuning.cpp