int Image::getMax()
{
// Alternatively create max from histogram
//IntIntMap::iterator iter = this->getHistogram()->end();
//iter--;
//return (*iter).first;
if (mBaseImageData->GetNumberOfScalarComponents() == 3)
{
if (mMaxRGBIntensity != -1)
{
return mMaxRGBIntensity;
}
QDateTime before = QDateTime::currentDateTime();
double max = 0.0;
switch (mBaseImageData->GetScalarType())
{
case VTK_UNSIGNED_CHAR:
max = getRGBMax<unsigned char>(mBaseImageData);
break;
case VTK_UNSIGNED_SHORT:
max = getRGBMax<unsigned short>(mBaseImageData);
break;
default:
CX_LOG_ERROR() << "Unhandled RGB data type in image " << this->getUid();
break;
}
mMaxRGBIntensity = max;
return (int)mMaxRGBIntensity;
}
else
{
// return (int) this->getTransferFunctions3D()->getScalarMax();
return mBaseImageData->GetScalarRange()[1];
}
}
void ShaderCallback::addUniformfArray(vtkShaderProgram *program, std::string name, float value)
{
//Note: Set uniform will fail if the uniform is not present OR active (used inside the program).
report_gl_error();
//CX_LOG_DEBUG() << "Adding uniform called: " << name << " with value " << value;
if(!program->SetUniform1fv(name.c_str(), 1, &value))
{
CX_LOG_ERROR() << "Could not set uniform named " << name;
}
report_gl_error();
}
QPoint LayoutWidgetUsingViewWidgets::getPosition(ViewPtr view)
{
ViewWidget* widget = this->WidgetFromView(view);
if (!widget)
{
CX_LOG_ERROR() << "Did not find view in layout " << view->getUid();
return QPoint(0,0);
}
QPoint p = widget->mapToGlobal(QPoint(0,0));
p = this->mapFromGlobal(p);
return p;
}
void ShaderCallback::bindFSOutputVariable(vtkShaderProgram *program)
{
GLint color_frag_out_index = glGetFragDataLocation(program->GetHandle(), FS_Out_Vec4_Color.c_str());
if(color_frag_out_index != -1)
{
glBindFragDataLocation(program->GetHandle(), color_frag_out_index, FS_Out_Vec4_Color.c_str()); //setting output of fragment shader
//CX_LOG_DEBUG() << "Binding fragmentshader output to " << FS_Out_Vec4_Color << " at index "<< color_frag_out_index;
}
else
{
CX_LOG_ERROR() << "Could not find glGetFragDataLocation for " << FS_Out_Vec4_Color;
}
}
QString DataLocations::getDocPath()
{
if(!isRunFromBuildFolder())
{
QString path = QString("%1/%2").arg(qApp->applicationDirPath()).arg(CX_DOC_ROOT_RELATIVE_INSTALLED);
// QString path = getBundlePath() + "/" + CX_DOC_ROOT_RELATIVE_INSTALLED; // look for installed location
if (QDir(path).exists())
return QDir(path).canonicalPath();
else
{
CX_LOG_ERROR() << QString("Cannot find doc path: ") << path;
return "";
}
}
if (QDir(CX_DOC_ROOT).exists()) // look for folder in source code
return QDir(CX_DOC_ROOT).canonicalPath();
else
{
CX_LOG_ERROR() << QString("Cannot find doc path: ") << CX_DOC_ROOT;
return "";
}
}
ShaderCallback::ShaderItemPtr ShaderCallback::getShaderItem(QString image_uid) const
{
ShaderItemPtr item;
for(int i=0; i<mShaderItems.size(); ++i)
{
item = mShaderItems.at(i);
if(item->mTextureUid == image_uid)
{
return item;
}
}
CX_LOG_ERROR() << "COULD NOT FIND THE SHADERITEM";
return item;
}
/**
* @brief ShaderCallback::addArrayToAttributeArray
* In the vertex shader there is an in array of vec3 which will contain texture coordinates per uploaded texture. This function populates this array.
* @param program The shader program to work with.
* @param buffer The buffer containing the texture coordinates.
* @param name The name of the array variable in the vertex shader which will point to the texture coordinates.
* @param vector_index The place in the
*/
void ShaderCallback::addArrayToAttributeArray(vtkShaderProgram *program, vtkOpenGLBufferObjectPtr buffer, std::string name, int vector_index)
{
//--------
//This is information about how the texture coordinates are uploaded.
int offset = 0;
int vec_size = 3;
size_t stride = sizeof(float)*vec_size; //is this correct? was *3;
int elementType = GL_FLOAT; //VTK_FLOAT
bool normalize = false;
//CX_LOG_DEBUG() << "Adding attribute called: " << name << " to vector_index: " << vector_index;
//--------
const GLchar *namePtr = static_cast<const GLchar *>(name.c_str());
GLint start_of_vector_index = glGetAttribLocation(program->GetHandle(), namePtr);
report_gl_error();
if(start_of_vector_index != -1)
{
GLint position_in_vector_index = start_of_vector_index + vector_index;
buffer->Bind();
glEnableVertexAttribArray(position_in_vector_index);
glVertexAttribPointer(position_in_vector_index,
vec_size,
elementType,
normalize,
static_cast<GLsizei>(stride),
((char *)NULL + (offset))
);
report_gl_error();
}
else
{
CX_LOG_ERROR() << "Error setting attribute " << name << " with vector_index " << vector_index;
}
}
virtual void updateTexture()
{
if (mMTime == mTexture->GetMTime())
{
return;
}
mMTime = mTexture->GetMTime();
//vtkgl::ActiveTexture(getGLTextureForVolume(textureUnitIndex)); //TODO is this OK?
GLenum size,internalType;
boost::uint32_t dimx = mTexture ->GetDimensions( )[0];
boost::uint32_t dimy = mTexture ->GetDimensions( )[1];
boost::uint32_t dimz = mTexture ->GetDimensions( )[2];
mMemorySize = dimx * dimy * dimz;
glEnable( GL_TEXTURE_3D );
glBindTexture(GL_TEXTURE_3D, textureId);
report_gl_error();
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP );
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP );
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP );
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
switch (mTexture->GetScalarType())
{
case VTK_UNSIGNED_CHAR:
{
size = GL_UNSIGNED_BYTE;
internalType = GL_LUMINANCE;
}
break; //8UI_EXT; break;
case VTK_UNSIGNED_SHORT:
{
size = GL_UNSIGNED_SHORT;
internalType = GL_LUMINANCE16;
mMemorySize *= 2;
}
break; //16UI_EXT; break;
default:
size = 0;
internalType = 0;
std::cout << "Bit size not supported!" << std::endl;
QString dataType(mTexture->GetScalarTypeAsString());
CX_LOG_ERROR() << QString("Attempt to update 3D GL texture from type %1 failed. Only unsigned types supported").arg(dataType);
break;
}
if (mTexture->GetNumberOfScalarComponents()==1)
{
void* data = mTexture->GetPointData()->GetScalars()->GetVoidPointer(0);
glTexImage3D(GL_TEXTURE_3D, 0, internalType, dimx, dimy, dimz, 0, GL_LUMINANCE, size, data);
}
else if (mTexture->GetNumberOfScalarComponents()==3)
{
internalType = GL_RGB;
void* data = mTexture->GetPointData()->GetScalars()->GetVoidPointer(0);
glTexImage3D(GL_TEXTURE_3D, 0, internalType, dimx, dimy, dimz, 0, GL_RGB, size, data);
mMemorySize *= 3;
}
else
{
std::cout << "unsupported number of image components" << std::endl;
}
glDisable(GL_TEXTURE_3D);
report_gl_error();
}
QAction* MainWindowActions::getAction(QString uid)
{
if (!mActions.count(uid))
CX_LOG_ERROR() << QString("Could not find action %1 in MainWindowActions object").arg(uid);
return mActions[uid];
}
