mirror of
https://github.com/OPM/ResInsight.git
synced 2025-01-21 22:13:25 -06:00
719 lines
26 KiB
C++
719 lines
26 KiB
C++
//##################################################################################################
|
|
//
|
|
// Custom Visualization Core library
|
|
// Copyright (C) 2018- Ceetron Solutions AS
|
|
//
|
|
// This library may be used under the terms of either the GNU General Public License or
|
|
// the GNU Lesser General Public License as follows:
|
|
//
|
|
// GNU General Public License Usage
|
|
// This library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
// FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// See the GNU General Public License at <<http://www.gnu.org/licenses/gpl.html>>
|
|
// for more details.
|
|
//
|
|
// GNU Lesser General Public License Usage
|
|
// This library is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation; either version 2.1 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
// FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// See the GNU Lesser General Public License at <<http://www.gnu.org/licenses/lgpl-2.1.html>>
|
|
// for more details.
|
|
//
|
|
//##################################################################################################
|
|
|
|
#include "cafOverlayScalarMapperLegend.h"
|
|
#include "cvfBase.h"
|
|
#include "cvfBufferObjectManaged.h"
|
|
#include "cvfCamera.h"
|
|
#include "cvfFont.h"
|
|
#include "cvfGeometryBuilderDrawableGeo.h"
|
|
#include "cvfGeometryUtils.h"
|
|
#include "cvfGlyph.h"
|
|
#include "cvfMatrixState.h"
|
|
#include "cvfOpenGL.h"
|
|
#include "cvfOpenGLResourceManager.h"
|
|
#include "cvfRenderStateDepth.h"
|
|
#include "cvfRenderStateLine.h"
|
|
#include "cvfShaderProgram.h"
|
|
#include "cvfShaderProgramGenerator.h"
|
|
#include "cvfShaderSourceProvider.h"
|
|
#include "cvfShaderSourceRepository.h"
|
|
#include "cvfTextDrawer.h"
|
|
#include "cvfUniform.h"
|
|
#include "cvfViewport.h"
|
|
|
|
#include "cafInternalLegendRenderTools.h"
|
|
|
|
#ifndef CVF_OPENGL_ES
|
|
#include "cvfRenderState_FF.h"
|
|
#endif
|
|
|
|
#include "cvfRenderStateBlending.h"
|
|
#include "cvfScalarMapper.h"
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cmath>
|
|
|
|
namespace caf
|
|
{
|
|
using namespace cvf;
|
|
|
|
//==================================================================================================
|
|
///
|
|
/// \class cvf::OverlayColorLegend
|
|
/// \ingroup Render
|
|
///
|
|
///
|
|
///
|
|
//==================================================================================================
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Constructor
|
|
//--------------------------------------------------------------------------------------------------
|
|
OverlayScalarMapperLegend::OverlayScalarMapperLegend( Font* font )
|
|
: TitledOverlayFrame( font, 200, 200 )
|
|
, m_tickNumberPrecision( 4 )
|
|
, m_numberFormat( AUTO )
|
|
, m_Layout( Vec2ui( 200u, 200u ) )
|
|
{
|
|
CVF_ASSERT( font );
|
|
CVF_ASSERT( !font->isEmpty() );
|
|
|
|
m_tickValues.reserve( 3 );
|
|
m_tickValues.add( 0.0 );
|
|
m_tickValues.add( 0.5 );
|
|
m_tickValues.add( 1.0 );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
OverlayScalarMapperLegend::~OverlayScalarMapperLegend()
|
|
{
|
|
// Empty destructor to avoid errors with undefined types when cvf::ref's destructor gets called
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void OverlayScalarMapperLegend::setScalarMapper( const ScalarMapper* scalarMapper )
|
|
{
|
|
m_scalarMapper = scalarMapper;
|
|
|
|
if ( m_scalarMapper.notNull() )
|
|
{
|
|
std::vector<double> levelValues;
|
|
m_scalarMapper->majorTickValues( &levelValues );
|
|
|
|
m_tickValues.assign( levelValues );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Hardware rendering using shader programs
|
|
//--------------------------------------------------------------------------------------------------
|
|
void OverlayScalarMapperLegend::render( OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size )
|
|
{
|
|
renderGeneric( oglContext, position, size, false );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Software rendering using software
|
|
//--------------------------------------------------------------------------------------------------
|
|
void OverlayScalarMapperLegend::renderSoftware( OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size )
|
|
{
|
|
renderGeneric( oglContext, position, size, true );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool OverlayScalarMapperLegend::pick( int oglXCoord, int oglYCoord, const Vec2i& position, const Vec2ui& size )
|
|
{
|
|
Recti oglRect( position, size.x(), size.y() );
|
|
|
|
OverlayColorLegendLayoutInfo layoutInViewPortCoords( Vec2ui( oglRect.width(), oglRect.height() ) );
|
|
layoutInfo( &layoutInViewPortCoords );
|
|
|
|
Vec2i legendBarOrigin = oglRect.min();
|
|
legendBarOrigin.x() += static_cast<uint>( layoutInViewPortCoords.colorBarRect.min().x() );
|
|
legendBarOrigin.y() += static_cast<uint>( layoutInViewPortCoords.colorBarRect.min().y() );
|
|
|
|
Recti legendBarRect = Recti( legendBarOrigin,
|
|
static_cast<uint>( layoutInViewPortCoords.colorBarRect.width() ),
|
|
static_cast<uint>( layoutInViewPortCoords.colorBarRect.height() ) );
|
|
|
|
if ( ( oglXCoord > legendBarRect.min().x() ) && ( oglXCoord < legendBarRect.max().x() ) &&
|
|
( oglYCoord > legendBarRect.min().y() ) && ( oglYCoord < legendBarRect.max().y() ) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Set up camera/viewport and render
|
|
//--------------------------------------------------------------------------------------------------
|
|
void OverlayScalarMapperLegend::renderGeneric( OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software )
|
|
{
|
|
if ( size.x() <= 0 || size.y() <= 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
Camera camera;
|
|
camera.setViewport( position.x(), position.y(), size.x(), size.y() );
|
|
camera.setProjectionAsPixelExact2D();
|
|
camera.setViewMatrix( Mat4d::IDENTITY );
|
|
camera.applyOpenGL();
|
|
camera.viewport()->applyOpenGL( oglContext, Viewport::CLEAR_DEPTH );
|
|
|
|
m_Layout = OverlayColorLegendLayoutInfo( size );
|
|
layoutInfo( &m_Layout );
|
|
m_textDrawer = new TextDrawer( this->font() );
|
|
|
|
// Set up text drawer
|
|
float maxLegendRightPos = 0;
|
|
setupTextDrawer( m_textDrawer.p(), &m_Layout );
|
|
|
|
Vec2f backgroundSize( size );
|
|
|
|
// Do the actual rendering
|
|
if ( software )
|
|
{
|
|
if ( this->backgroundEnabled() )
|
|
{
|
|
InternalLegendRenderTools::renderBackgroundImmediateMode( oglContext,
|
|
backgroundSize,
|
|
this->backgroundColor(),
|
|
this->backgroundFrameColor() );
|
|
}
|
|
renderLegendImmediateMode( oglContext, &m_Layout );
|
|
m_textDrawer->renderSoftware( oglContext, camera );
|
|
}
|
|
else
|
|
{
|
|
const MatrixState matrixState( camera );
|
|
if ( this->backgroundEnabled() )
|
|
{
|
|
InternalLegendRenderTools::renderBackgroundUsingShaders( oglContext,
|
|
matrixState,
|
|
backgroundSize,
|
|
this->backgroundColor(),
|
|
this->backgroundFrameColor() );
|
|
}
|
|
renderLegendUsingShaders( oglContext, &m_Layout, matrixState );
|
|
m_textDrawer->render( oglContext, camera );
|
|
}
|
|
|
|
CVF_CHECK_OGL( oglContext );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void OverlayScalarMapperLegend::setupTextDrawer( TextDrawer* textDrawer, const OverlayColorLegendLayoutInfo* layout )
|
|
{
|
|
CVF_ASSERT( layout );
|
|
|
|
textDrawer->setVerticalAlignment( TextDrawer::CENTER );
|
|
textDrawer->setTextColor( this->textColor() );
|
|
|
|
m_visibleTickLabels.clear();
|
|
|
|
const float textX = layout->tickEndX + layout->tickTextLeadSpace;
|
|
|
|
const float overlapTolerance = 1.2f * layout->charHeight;
|
|
float lastVisibleTextY = 0.0;
|
|
|
|
size_t numTicks = m_tickValues.size();
|
|
size_t it;
|
|
for ( it = 0; it < numTicks; it++ )
|
|
{
|
|
float textY = static_cast<float>( layout->colorBarRect.min().y() + layout->tickYPixelPos->get( it ) );
|
|
|
|
// Always draw first and last tick label. For all others, skip drawing if text ends up
|
|
// on top of the previous label.
|
|
if ( it != 0 && it != ( numTicks - 1 ) )
|
|
{
|
|
if ( cvf::Math::abs( textY - lastVisibleTextY ) < overlapTolerance )
|
|
{
|
|
m_visibleTickLabels.push_back( false );
|
|
continue;
|
|
}
|
|
// Make sure it does not overlap the last tick as well
|
|
|
|
float lastTickY = static_cast<float>( layout->colorBarRect.max().y() );
|
|
|
|
if ( cvf::Math::abs( textY - lastTickY ) < overlapTolerance )
|
|
{
|
|
m_visibleTickLabels.push_back( false );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
double tickValue = m_tickValues[it];
|
|
String valueString;
|
|
switch ( m_numberFormat )
|
|
{
|
|
case FIXED:
|
|
valueString = String::number( tickValue, 'f', m_tickNumberPrecision );
|
|
break;
|
|
case SCIENTIFIC:
|
|
valueString = String::number( tickValue, 'e', m_tickNumberPrecision );
|
|
break;
|
|
default:
|
|
valueString = String::number( tickValue );
|
|
break;
|
|
}
|
|
|
|
Vec2f pos( textX, textY );
|
|
textDrawer->addText( valueString, pos );
|
|
|
|
lastVisibleTextY = textY;
|
|
m_visibleTickLabels.push_back( true );
|
|
}
|
|
|
|
float titleY = static_cast<float>( layout->overallLegendSize.y() ) - layout->margins.y() - layout->charHeight / 2.0f;
|
|
for ( it = 0; it < this->titleStrings().size(); it++ )
|
|
{
|
|
Vec2f pos( layout->margins.x(), titleY );
|
|
textDrawer->addText( this->titleStrings()[it], pos );
|
|
|
|
titleY -= layout->lineSpacing;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Draw the legend using shader programs
|
|
//--------------------------------------------------------------------------------------------------
|
|
void OverlayScalarMapperLegend::renderLegendUsingShaders( OpenGLContext* oglContext,
|
|
OverlayColorLegendLayoutInfo* layout,
|
|
const MatrixState& matrixState )
|
|
{
|
|
CVF_CALLSITE_OPENGL( oglContext );
|
|
|
|
CVF_TIGHT_ASSERT( layout );
|
|
CVF_TIGHT_ASSERT( layout->overallLegendSize.x() > 0 );
|
|
CVF_TIGHT_ASSERT( layout->overallLegendSize.y() > 0 );
|
|
|
|
RenderStateDepth depth( false );
|
|
depth.applyOpenGL( oglContext );
|
|
RenderStateLine line( static_cast<float>( this->lineWidth() ) );
|
|
line.applyOpenGL( oglContext );
|
|
|
|
// All vertices. Initialized here to set Z to zero once and for all.
|
|
static float vertexArray[] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
|
|
|
|
// Per vector convenience pointers
|
|
float* v0 = &vertexArray[0];
|
|
float* v1 = &vertexArray[3];
|
|
float* v2 = &vertexArray[6];
|
|
float* v3 = &vertexArray[9];
|
|
float* v4 = &vertexArray[12];
|
|
|
|
// Constant coordinates
|
|
v0[0] = v3[0] = layout->tickStartX;
|
|
v1[0] = v4[0] = layout->tickMidX;
|
|
|
|
// Connects
|
|
static const ushort trianglesConnects[] = { 0, 1, 4, 0, 4, 3 };
|
|
|
|
ref<ShaderProgram> shaderProgram = oglContext->resourceManager()->getLinkedUnlitColorShaderProgram( oglContext );
|
|
CVF_TIGHT_ASSERT( shaderProgram.notNull() );
|
|
|
|
if ( shaderProgram->useProgram( oglContext ) )
|
|
{
|
|
shaderProgram->clearUniformApplyTracking();
|
|
shaderProgram->applyFixedUniforms( oglContext, matrixState );
|
|
}
|
|
|
|
glBindBuffer( GL_ARRAY_BUFFER, 0 );
|
|
glEnableVertexAttribArray( ShaderProgram::VERTEX );
|
|
glVertexAttribPointer( ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray );
|
|
|
|
// Render color bar as one colored quad per pixel
|
|
|
|
int legendHeightPixelCount = static_cast<int>( layout->tickYPixelPos->get( m_tickValues.size() - 1 ) -
|
|
layout->tickYPixelPos->get( 0 ) + 0.01 );
|
|
if ( m_scalarMapper.notNull() )
|
|
{
|
|
int iPx;
|
|
for ( iPx = 0; iPx < legendHeightPixelCount; iPx++ )
|
|
{
|
|
const Color3ub& clr =
|
|
m_scalarMapper->mapToColor( m_scalarMapper->domainValue( ( iPx + 0.5 ) / legendHeightPixelCount ) );
|
|
float y0 = static_cast<float>( layout->colorBarRect.min().y() + iPx );
|
|
float y1 = static_cast<float>( layout->colorBarRect.min().y() + iPx + 1 );
|
|
|
|
// Dynamic coordinates for rectangle
|
|
v0[1] = v1[1] = y0;
|
|
v3[1] = v4[1] = y1;
|
|
|
|
// Draw filled rectangle elements
|
|
{
|
|
UniformFloat uniformColor( "u_color", Color4f( Color3f( clr ) ) );
|
|
shaderProgram->applyUniform( oglContext, uniformColor );
|
|
|
|
#ifdef CVF_OPENGL_ES
|
|
glDrawElements( GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, trianglesConnects );
|
|
#else
|
|
glDrawRangeElements( GL_TRIANGLES, 0, 4, 6, GL_UNSIGNED_SHORT, trianglesConnects );
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
// Render frame
|
|
|
|
// Dynamic coordinates for tickmarks-lines
|
|
bool isRenderingFrame = true;
|
|
if ( isRenderingFrame )
|
|
{
|
|
v0[0] = v2[0] = layout->colorBarRect.min().x() - 0.5f;
|
|
v1[0] = v3[0] = layout->colorBarRect.max().x() - 0.5f;
|
|
v0[1] = v1[1] = layout->colorBarRect.min().y() - 0.5f;
|
|
v2[1] = v3[1] = layout->colorBarRect.max().y() - 0.5f;
|
|
static const ushort frameConnects[] = { 0, 1, 1, 3, 3, 2, 2, 0 };
|
|
|
|
UniformFloat uniformColor( "u_color", Color4f( this->lineColor() ) );
|
|
shaderProgram->applyUniform( oglContext, uniformColor );
|
|
|
|
#ifdef CVF_OPENGL_ES
|
|
glDrawElements( GL_LINES, 8, GL_UNSIGNED_SHORT, frameConnects );
|
|
#else
|
|
glDrawRangeElements( GL_LINES, 0, 3, 8, GL_UNSIGNED_SHORT, frameConnects );
|
|
#endif
|
|
}
|
|
|
|
// Render tickmarks
|
|
bool isRenderingTicks = true;
|
|
|
|
if ( isRenderingTicks )
|
|
{
|
|
// Constant coordinates
|
|
v0[0] = layout->tickStartX;
|
|
v1[0] = layout->tickMidX - 0.5f * ( layout->tickEndX - layout->tickMidX ) - 0.5f;
|
|
v2[0] = layout->tickMidX;
|
|
v3[0] = layout->tickEndX - 0.5f * ( layout->tickEndX - layout->tickMidX ) - 0.5f;
|
|
v4[0] = layout->tickEndX;
|
|
|
|
static const ushort tickLinesWithLabel[] = { 0, 4 };
|
|
static const ushort tickLinesWoLabel[] = { 2, 3 };
|
|
|
|
size_t ic;
|
|
for ( ic = 0; ic < m_tickValues.size(); ic++ )
|
|
{
|
|
float y0 = static_cast<float>( layout->colorBarRect.min().y() + layout->tickYPixelPos->get( ic ) - 0.5f );
|
|
|
|
// Dynamic coordinates for tickmarks-lines
|
|
v0[1] = v1[1] = v2[1] = v3[1] = v4[1] = y0;
|
|
|
|
UniformFloat uniformColor( "u_color", Color4f( this->lineColor() ) );
|
|
shaderProgram->applyUniform( oglContext, uniformColor );
|
|
const ushort* linesConnects;
|
|
|
|
if ( m_visibleTickLabels[ic] )
|
|
{
|
|
linesConnects = tickLinesWithLabel;
|
|
}
|
|
else
|
|
{
|
|
linesConnects = tickLinesWoLabel;
|
|
}
|
|
|
|
#ifdef CVF_OPENGL_ES
|
|
glDrawElements( GL_LINES, 2, GL_UNSIGNED_SHORT, linesConnects );
|
|
#else
|
|
glDrawRangeElements( GL_LINES, 0, 4, 2, GL_UNSIGNED_SHORT, linesConnects );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
glDisableVertexAttribArray( ShaderProgram::VERTEX );
|
|
|
|
CVF_TIGHT_ASSERT( shaderProgram.notNull() );
|
|
shaderProgram->useNoProgram( oglContext );
|
|
|
|
// Reset render states
|
|
RenderStateDepth resetDepth;
|
|
resetDepth.applyOpenGL( oglContext );
|
|
|
|
RenderStateLine resetLine;
|
|
resetLine.applyOpenGL( oglContext );
|
|
|
|
CVF_CHECK_OGL( oglContext );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Draw the legend using immediate mode OpenGL
|
|
//--------------------------------------------------------------------------------------------------
|
|
void OverlayScalarMapperLegend::renderLegendImmediateMode( OpenGLContext* oglContext, OverlayColorLegendLayoutInfo* layout )
|
|
{
|
|
#ifdef CVF_OPENGL_ES
|
|
CVF_UNUSED( layout );
|
|
CVF_FAIL_MSG( "Not supported on OpenGL ES" );
|
|
#else
|
|
CVF_TIGHT_ASSERT( layout );
|
|
CVF_TIGHT_ASSERT( layout->overallLegendSize.x() > 0 );
|
|
CVF_TIGHT_ASSERT( layout->overallLegendSize.y() > 0 );
|
|
|
|
RenderStateDepth depth( false );
|
|
depth.applyOpenGL( oglContext );
|
|
|
|
RenderStateLighting_FF lighting( false );
|
|
lighting.applyOpenGL( oglContext );
|
|
|
|
// All vertices. Initialized here to set Z to zero once and for all.
|
|
static float vertexArray[] = {
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
};
|
|
|
|
// Per vector convenience pointers
|
|
float* v0 = &vertexArray[0];
|
|
float* v1 = &vertexArray[3];
|
|
float* v2 = &vertexArray[6];
|
|
float* v3 = &vertexArray[9];
|
|
float* v4 = &vertexArray[12];
|
|
|
|
// Constant coordinates
|
|
v0[0] = v3[0] = layout->tickStartX;
|
|
v1[0] = v4[0] = layout->tickMidX;
|
|
|
|
// Render color bar as one colored quad per pixel
|
|
|
|
int legendHeightPixelCount = static_cast<int>( layout->tickYPixelPos->get( m_tickValues.size() - 1 ) -
|
|
layout->tickYPixelPos->get( 0 ) + 0.01 );
|
|
if ( m_scalarMapper.notNull() )
|
|
{
|
|
int iPx;
|
|
for ( iPx = 0; iPx < legendHeightPixelCount; iPx++ )
|
|
{
|
|
const Color3ub& clr =
|
|
m_scalarMapper->mapToColor( m_scalarMapper->domainValue( ( iPx + 0.5 ) / legendHeightPixelCount ) );
|
|
float y0 = static_cast<float>( layout->colorBarRect.min().y() + iPx );
|
|
float y1 = static_cast<float>( layout->colorBarRect.min().y() + iPx + 1 );
|
|
|
|
// Dynamic coordinates for rectangle
|
|
v0[1] = v1[1] = y0;
|
|
v3[1] = v4[1] = y1;
|
|
|
|
// Draw filled rectangle elements
|
|
glColor3ubv( clr.ptr() );
|
|
glBegin( GL_TRIANGLE_FAN );
|
|
glVertex3fv( v0 );
|
|
glVertex3fv( v1 );
|
|
glVertex3fv( v4 );
|
|
glVertex3fv( v3 );
|
|
glEnd();
|
|
}
|
|
}
|
|
|
|
// Render frame
|
|
|
|
// Dynamic coordinates for tickmarks-lines
|
|
bool isRenderingFrame = true;
|
|
if ( isRenderingFrame )
|
|
{
|
|
v0[0] = v2[0] = layout->colorBarRect.min().x() - 0.5f;
|
|
v1[0] = v3[0] = layout->colorBarRect.max().x() - 0.5f;
|
|
v0[1] = v1[1] = layout->colorBarRect.min().y() - 0.5f;
|
|
v2[1] = v3[1] = layout->colorBarRect.max().y() - 0.5f;
|
|
|
|
glColor3fv( this->textColor().ptr() );
|
|
glBegin( GL_LINES );
|
|
glVertex3fv( v0 );
|
|
glVertex3fv( v1 );
|
|
glVertex3fv( v1 );
|
|
glVertex3fv( v3 );
|
|
glVertex3fv( v3 );
|
|
glVertex3fv( v2 );
|
|
glVertex3fv( v2 );
|
|
glVertex3fv( v0 );
|
|
glEnd();
|
|
}
|
|
|
|
// Render tickmarks
|
|
bool isRenderingTicks = true;
|
|
|
|
if ( isRenderingTicks )
|
|
{
|
|
// Constant coordinates
|
|
v0[0] = layout->tickStartX;
|
|
v1[0] = layout->tickMidX - 0.5f * ( layout->tickEndX - layout->tickMidX ) - 0.5f;
|
|
v2[0] = layout->tickMidX;
|
|
v3[0] = layout->tickEndX - 0.5f * ( layout->tickEndX - layout->tickMidX ) - 0.5f;
|
|
v4[0] = layout->tickEndX;
|
|
|
|
size_t ic;
|
|
for ( ic = 0; ic < m_tickValues.size(); ic++ )
|
|
{
|
|
float y0 = static_cast<float>( layout->colorBarRect.min().y() + layout->tickYPixelPos->get( ic ) - 0.5f );
|
|
|
|
// Dynamic coordinates for tickmarks-lines
|
|
v0[1] = v1[1] = v2[1] = v3[1] = v4[1] = y0;
|
|
|
|
glColor3fv( this->textColor().ptr() );
|
|
glBegin( GL_LINES );
|
|
if ( m_visibleTickLabels[ic] )
|
|
{
|
|
glVertex3fv( v0 );
|
|
glVertex3fv( v4 );
|
|
}
|
|
else
|
|
{
|
|
glVertex3fv( v2 );
|
|
glVertex3fv( v3 );
|
|
}
|
|
glEnd();
|
|
}
|
|
}
|
|
|
|
// Reset render states
|
|
RenderStateLighting_FF resetLighting;
|
|
resetLighting.applyOpenGL( oglContext );
|
|
RenderStateDepth resetDepth;
|
|
resetDepth.applyOpenGL( oglContext );
|
|
|
|
CVF_CHECK_OGL( oglContext );
|
|
#endif // CVF_OPENGL_ES
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Get layout information
|
|
//--------------------------------------------------------------------------------------------------
|
|
void OverlayScalarMapperLegend::layoutInfo( OverlayColorLegendLayoutInfo* layout )
|
|
{
|
|
CVF_TIGHT_ASSERT( layout );
|
|
|
|
ref<Glyph> glyph = this->font()->getGlyph( L'A' );
|
|
layout->charHeight = static_cast<float>( glyph->height() );
|
|
layout->lineSpacing = layout->charHeight * 1.5f;
|
|
layout->margins = Vec2f( 8.0f, 8.0f );
|
|
layout->tickTextLeadSpace = 5.0f;
|
|
|
|
float colorBarWidth = 25.0f;
|
|
float colorBarHeight = static_cast<float>( layout->overallLegendSize.y() ) - 2 * layout->margins.y() -
|
|
static_cast<float>( this->titleStrings().size() ) * layout->lineSpacing - layout->lineSpacing;
|
|
layout->colorBarRect =
|
|
Rectf( layout->margins.x(), layout->margins.y() + layout->charHeight / 2.0f, colorBarWidth, colorBarHeight );
|
|
|
|
layout->tickStartX = layout->margins.x();
|
|
layout->tickMidX = layout->margins.x() + layout->colorBarRect.width();
|
|
layout->tickEndX = layout->tickMidX + 5;
|
|
|
|
// Build array containing the pixel positions of all the ticks
|
|
size_t numTicks = m_tickValues.size();
|
|
layout->tickYPixelPos = new DoubleArray( numTicks );
|
|
|
|
size_t i;
|
|
for ( i = 0; i < numTicks; i++ )
|
|
{
|
|
double t;
|
|
if ( m_scalarMapper.isNull() )
|
|
t = 0;
|
|
else
|
|
t = m_scalarMapper->normalizedValue( m_tickValues[i] );
|
|
t = Math::clamp( t, 0.0, 1.1 );
|
|
if ( i != numTicks - 1 )
|
|
{
|
|
layout->tickYPixelPos->set( i, t * layout->colorBarRect.height() );
|
|
}
|
|
else
|
|
{
|
|
layout->tickYPixelPos->set( i, layout->colorBarRect.height() ); // Make sure we get a value at the top even
|
|
// if the scalarmapper range is zero
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void OverlayScalarMapperLegend::setTickPrecision( int precision )
|
|
{
|
|
m_tickNumberPrecision = precision;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void OverlayScalarMapperLegend::setTickFormat( NumberFormat format )
|
|
{
|
|
m_numberFormat = format;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::Vec2ui OverlayScalarMapperLegend::preferredSize()
|
|
{
|
|
OverlayColorLegendLayoutInfo layout( { 200, 200 } ); // Use default size
|
|
layoutInfo( &layout );
|
|
|
|
float preferredYSize = 2 * layout.margins.y() + layout.lineSpacing * this->titleStrings().size() +
|
|
1.5f * layout.lineSpacing * m_tickValues.size();
|
|
|
|
unsigned int maxTickTextWidth = 0;
|
|
for ( double tickValue : m_tickValues )
|
|
{
|
|
String valueString;
|
|
switch ( m_numberFormat )
|
|
{
|
|
case FIXED:
|
|
valueString = String::number( tickValue, 'f', m_tickNumberPrecision );
|
|
break;
|
|
case SCIENTIFIC:
|
|
valueString = String::number( tickValue, 'e', m_tickNumberPrecision );
|
|
break;
|
|
default:
|
|
valueString = String::number( tickValue );
|
|
break;
|
|
}
|
|
unsigned int textWidth = this->font()->textExtent( valueString ).x();
|
|
maxTickTextWidth = maxTickTextWidth < textWidth ? textWidth : maxTickTextWidth;
|
|
}
|
|
|
|
float preferredXSize = layout.tickEndX + layout.margins.x() + layout.tickTextLeadSpace + maxTickTextWidth;
|
|
|
|
for ( const cvf::String& titleLine : titleStrings() )
|
|
{
|
|
float titleWidth = this->font()->textExtent( titleLine ).x() + 2 * layout.margins.x();
|
|
preferredXSize = preferredXSize < titleWidth ? titleWidth : preferredXSize;
|
|
}
|
|
|
|
preferredXSize = std::min( preferredXSize, 400.0f );
|
|
|
|
return { (unsigned int)( std::ceil( preferredXSize ) ), (unsigned int)( std::ceil( preferredYSize ) ) };
|
|
}
|
|
|
|
} // namespace caf
|