void KIGPDialog::writeConfig()
{
KConfigGroup group = m_config->group("Look");
group.writeEntry("ImagesPerRow", getImagesPerRow());
group.writeEntry("ImageName", printImageName());
group.writeEntry("ImageSize", printImageSize());
group.writeEntry("ImageProperty", printImageProperty());
group.writeEntry("FontName", getFontName());
group.writeEntry("FontSize", getFontSize());
group.writeEntry("ForegroundColor", getForegroundColor().name() );
group.writeEntry("BackgroundColor", getBackgroundColor().name());
group =m_config->group("Directory");
group.writeEntry("RecurseSubDirectories", recurseSubDirectories());
group.writeEntry("RecursionLevel", recursionLevel());
group.writeEntry("CopyOriginalFiles", copyOriginalFiles());
group.writeEntry("UseCommentFile", useCommentFile());
group = m_config->group("Thumbnails");
group.writeEntry("ThumbnailSize", getThumbnailSize());
group.writeEntry("ColorDepth", getColorDepth());
group.writeEntry("ColorDepthSet", colorDepthSet());
group.writeEntry("ImageFormat", getImageFormat());
group.sync();
}
void LLPanelSnapshotLocal::onFormatComboCommit(LLUICtrl* ctrl)
{
mLocalFormat = getImageFormat();
// <FS:Ansariel> FIRE-7090: Snapshot format for disk changes when selecting snapshot to inventory or email
gSavedSettings.setS32("FSSnapshotLocalFormat", getChild<LLComboBox>("local_format_combo")->getCurrentIndex());
// will call updateControls()
LLFloaterSnapshot::getInstance()->notify(LLSD().with("image-format-change", true));
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void WriteImages::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setImagePrefix( reader->readString("ImagePrefix", getImagePrefix()) );
setFilePrefix( reader->readValue("FilePrefix", getFilePrefix()) );
setOutputPath( reader->readString("OutputPath", getOutputPath()) );
setColorsArrayPath( reader->readDataArrayPath("ColorsArrayPath", getColorsArrayPath()) );
setImageFormat( reader->readValue("ImageFormat", getImageFormat()) );
setPlane(reader->readValue("Plane", getPlane()));
reader->closeFilterGroup();
}
VideoSourceImages::VideoSourceImages(VDInputFileImages *parent)
: mpParent(parent)
, mCachedHandleFrame(-1)
{
mSampleFirst = 0;
mpTargetFormatHeader.resize(sizeof(BITMAPINFOHEADER));
allocFormat(sizeof(BITMAPINFOHEADER));
invalidateFrameBuffer();
// This has to be 1 so that read() doesn't kick away the request.
mSampleLast = mpParent->GetFrameCount();
getFrame(0);
// Fill out streamInfo
extern const VDFraction& VDPreferencesGetImageSequenceFrameRate();
const VDFraction& fr = VDPreferencesGetImageSequenceFrameRate();
streamInfo.fccType = VDAVIStreamInfo::kTypeVideo;
streamInfo.fccHandler = NULL;
streamInfo.dwFlags = 0;
streamInfo.dwCaps = 0;
streamInfo.wPriority = 0;
streamInfo.wLanguage = 0;
streamInfo.dwScale = fr.getLo();
streamInfo.dwRate = fr.getHi();
streamInfo.dwStart = 0;
streamInfo.dwLength = VDClampToUint32(mSampleLast);
streamInfo.dwInitialFrames = 0;
streamInfo.dwSuggestedBufferSize = 0;
streamInfo.dwQuality = (DWORD)-1;
streamInfo.dwSampleSize = 0;
streamInfo.rcFrameLeft = 0;
streamInfo.rcFrameTop = 0;
streamInfo.rcFrameRight = (uint16)getImageFormat()->biWidth;
streamInfo.rcFrameBottom = (uint16)getImageFormat()->biHeight;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void WritePoleFigure::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setGoodVoxelsArrayPath(reader->readDataArrayPath("GoodVoxelsArrayPath", getGoodVoxelsArrayPath() ) );
setCrystalStructuresArrayPath(reader->readDataArrayPath("CrystalStructuresArrayPath", getCrystalStructuresArrayPath() ) );
setCellPhasesArrayPath(reader->readDataArrayPath("CellPhasesArrayPath", getCellPhasesArrayPath() ) );
setCellEulerAnglesArrayPath(reader->readDataArrayPath("CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath() ) );
setImagePrefix( reader->readString("ImagePrefix", getImagePrefix()));
setOutputPath( reader->readString("OutputPath", getOutputPath()));
setImageFormat( reader->readValue("ImageFormat", getImageFormat()));
setImageLayout( reader->readValue("ImageLayout", getImageLayout()));
setImageSize( reader->readValue("ImageSize", getImageSize()));
setLambertSize( reader->readValue("LambertSize", getLambertSize()));
reader->closeFilterGroup();
}
// virtual
void LLPanelSnapshot::onOpen(const LLSD& key)
{
S32 old_format = gSavedSettings.getS32("SnapshotFormat");
S32 new_format = (S32) getImageFormat();
gSavedSettings.setS32("SnapshotFormat", new_format);
setCtrlsEnabled(true);
// Switching panels will likely change image format.
// Not updating preview right away may lead to errors,
// e.g. attempt to send a large BMP image by email.
if (old_format != new_format)
{
LLFloaterSnapshot::getInstance()->notify(LLSD().with("image-format-change", true));
}
updateCustomResControls();
}
/**
* Get the image stored in the specified field.
*
* @param rowId The ID of the record to fetch data from
* @param colIndex The position index of the field to fetch data from
* @return The requested image
*/
QImage View::getImage(int rowId, int colIndex)
{
QString colName = columns[colIndex];
QString format = getImageFormat(rowId, colIndex);
return ImageUtils::load(db, rowId, colName, format);
}
/*
* Update Texture - requires valid OpenGL Context
*/
void TextureUpdate::updateTexture(const Measurement::ImageMeasurement& image) {
#ifdef HAVE_OPENCV
// access OCL Manager and initialize if needed
Vision::OpenCLManager& oclManager = Vision::OpenCLManager::singleton();
if (!image) {
// LOG4CPP_WARN ??
return;
}
// if OpenCL is enabled and image is on GPU, then use OCL codepath
bool image_isOnGPU = oclManager.isInitialized() & image->isOnGPU();
if ( m_bTextureInitialized )
{
// check if received image fits into the allocated texture
// find out texture format
int umatConvertCode = -1;
GLenum glFormat = GL_LUMINANCE;
GLenum glDatatype = GL_UNSIGNED_BYTE;
int numOfChannels = 1;
Image::ImageFormatProperties fmtSrc, fmtDst;
image->getFormatProperties(fmtSrc);
image->getFormatProperties(fmtDst);
getImageFormat(fmtSrc, fmtDst, image_isOnGPU, umatConvertCode, glFormat, glDatatype);
if (image_isOnGPU) {
#ifdef HAVE_OPENCL
glBindTexture( GL_TEXTURE_2D, m_texture );
// @todo this probably causes unwanted delay - .. except when executed on gpu ...
if (umatConvertCode != -1) {
cv::cvtColor(image->uMat(), m_convertedImage, umatConvertCode );
} else {
m_convertedImage = image->uMat();
}
cv::ocl::finish();
glFinish();
cl_command_queue commandQueue = oclManager.getCommandQueue();
cl_int err;
clFinish(commandQueue);
err = clEnqueueAcquireGLObjects(commandQueue, 1, &(m_clImage), 0, NULL, NULL);
if(err != CL_SUCCESS)
{
LOG4CPP_ERROR( logger, "error at clEnqueueAcquireGLObjects:" << getOpenCLErrorString(err) );
}
cl_mem clBuffer = (cl_mem) m_convertedImage.handle(cv::ACCESS_READ);
cl_command_queue cv_ocl_queue = (cl_command_queue)cv::ocl::Queue::getDefault().ptr();
size_t offset = 0;
size_t dst_origin[3] = {0, 0, 0};
size_t region[3] = {static_cast<size_t>(m_convertedImage.cols), static_cast<size_t>(m_convertedImage.rows), 1};
err = clEnqueueCopyBufferToImage(cv_ocl_queue, clBuffer, m_clImage, offset, dst_origin, region, 0, NULL, NULL);
if (err != CL_SUCCESS)
{
LOG4CPP_ERROR( logger, "error at clEnqueueCopyBufferToImage:" << getOpenCLErrorString(err) );
}
err = clEnqueueReleaseGLObjects(commandQueue, 1, &m_clImage, 0, NULL, NULL);
if(err != CL_SUCCESS)
{
LOG4CPP_ERROR( logger, "error at clEnqueueReleaseGLObjects:" << getOpenCLErrorString(err) );
}
cv::ocl::finish();
#else // HAVE_OPENCL
LOG4CPP_ERROR( logger, "Image isOnGPU but OpenCL is disabled!!");
#endif // HAVE_OPENCL
} else {
// load image from CPU buffer into texture
glBindTexture( GL_TEXTURE_2D, m_texture );
glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, image->width(), image->height(),
glFormat, glDatatype, image->Mat().data );
}
}
#endif // HAVE_OPENCV
}
void TextureUpdate::initializeTexture(const Measurement::ImageMeasurement& image, const GLuint tex_id) {
#ifdef HAVE_OPENCV
if (!image) {
return;
}
if ( !m_bTextureInitialized )
{
// access OCL Manager and initialize if needed
Vision::OpenCLManager& oclManager = Vision::OpenCLManager::singleton();
// if OpenCL is enabled and image is on GPU, then use OCL codepath
bool image_isOnGPU = oclManager.isEnabled() & image->isOnGPU();
// find out texture format
int umatConvertCode = -1;
GLenum glFormat = GL_LUMINANCE;
GLenum glDatatype = GL_UNSIGNED_BYTE;
int numOfChannels = 1;
Image::ImageFormatProperties fmtSrc, fmtDst;
image->getFormatProperties(fmtSrc);
image->getFormatProperties(fmtDst);
getImageFormat(fmtSrc, fmtDst, image_isOnGPU, umatConvertCode, glFormat, glDatatype);
// generate power-of-two sizes
m_pow2Width = 1;
while ( m_pow2Width < (unsigned)image->width() )
m_pow2Width <<= 1;
m_pow2Height = 1;
while ( m_pow2Height < (unsigned)image->height() )
m_pow2Height <<= 1;
m_texture = tex_id;
glBindTexture( GL_TEXTURE_2D, m_texture );
// define texture parameters
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL );
// load empty texture image (defines texture size)
glTexImage2D( GL_TEXTURE_2D, 0, fmtDst.channels, m_pow2Width, m_pow2Height, 0, glFormat, glDatatype, 0 );
LOG4CPP_DEBUG( logger, "glTexImage2D( width=" << m_pow2Width << ", height=" << m_pow2Height << " ): " << glGetError() );
LOG4CPP_INFO( logger, "initalized texture ( " << glFormat << " ) OnGPU: " << image_isOnGPU);
if (oclManager.isInitialized()) {
#ifdef HAVE_OPENCL
//Get an image Object from the OpenGL texture
cl_int err;
// windows specific or opencl version specific ??
#ifdef WIN32
m_clImage = clCreateFromGLTexture2D( oclManager.getContext(), CL_MEM_WRITE_ONLY, GL_TEXTURE_2D, 0, m_texture, &err);
#else
m_clImage = clCreateFromGLTexture( oclManager.getContext(), CL_MEM_WRITE_ONLY, GL_TEXTURE_2D, 0, m_texture, &err);
#endif
if (err != CL_SUCCESS)
{
LOG4CPP_ERROR( logger, "error at clCreateFromGLTexture2D:" << getOpenCLErrorString(err) );
}
#endif
}
m_bTextureInitialized = true;
}
#endif // HAVE_OPENCV
}
std::string MapSection::getImageFormatSuffix() const {
if (getImageFormat() == ImageFormat::PNG)
return "png";
return "jpg";
}
const void *VideoSourceImages::streamGetFrame(const void *inputBuffer, uint32 data_len, bool is_preroll, VDPosition frame_num, VDPosition target_sample) {
// We may get a zero-byte frame if we already have the image.
if (!data_len)
return getFrameBuffer();
int w, h;
bool bHasAlpha;
bool bIsPNG = false;
bool bIsJPG = false;
bool bIsBMP = false;
bool bIsIFF = false;
bool bIsTGA = false;
bIsPNG = VDDecodePNGHeader(inputBuffer, data_len, w, h, bHasAlpha);
if (!bIsPNG) {
bIsJPG = VDIsJPEGHeader(inputBuffer, data_len);
if (!bIsJPG) {
bIsBMP = DecodeBMPHeader(inputBuffer, data_len, w, h, bHasAlpha);
if (!bIsBMP) {
bIsIFF = VDIsMayaIFFHeader(inputBuffer, data_len);
if (!bIsIFF)
bIsTGA = DecodeTGAHeader(inputBuffer, data_len, w, h, bHasAlpha);
}
}
}
if (!bIsBMP && !bIsTGA && !bIsJPG && !bIsPNG && !bIsIFF)
throw MyError("Image file must be in PNG, Windows BMP, truecolor TARGA format, MayaIFF, or sequential JPEG format.");
if (bIsJPG) {
if (!mpJPEGDecoder)
mpJPEGDecoder = VDCreateJPEGDecoder();
mpJPEGDecoder->Begin(inputBuffer, data_len);
mpJPEGDecoder->DecodeHeader(w, h);
}
VDPixmap pxIFF;
if (bIsIFF) {
if (!mpIFFDecoder)
mpIFFDecoder = VDCreateImageDecoderIFF();
pxIFF = mpIFFDecoder->Decode(inputBuffer, data_len);
w = pxIFF.w;
h = pxIFF.h;
}
// Check image header.
VDAVIBitmapInfoHeader *pFormat = getImageFormat();
if (getFrameBuffer()) {
if (w != pFormat->biWidth || h != pFormat->biHeight) {
vdfastvector<wchar_t> errBuf;
throw MyError("Image \"%ls\" (%dx%d) doesn't match the image dimensions of the first image (%dx%d)."
, mpParent->ComputeFilename(errBuf, frame_num), w, h, pFormat->biWidth, pFormat->biHeight);
}
} else {
if (!AllocFrameBuffer(w * h * 4))
throw MyMemoryError();
pFormat->biSize = sizeof(BITMAPINFOHEADER);
pFormat->biWidth = w;
pFormat->biHeight = h;
pFormat->biPlanes = 1;
pFormat->biCompression = 0xFFFFFFFFUL;
pFormat->biBitCount = 0;
pFormat->biSizeImage = 0;
pFormat->biXPelsPerMeter = 0;
pFormat->biYPelsPerMeter = 0;
pFormat->biClrUsed = 0;
pFormat->biClrImportant = 0;
// special case for initial read in constructor
return NULL;
}
if (bIsJPG) {
int format;
switch(mvbFrameBuffer.depth) {
case 16: format = IVDJPEGDecoder::kFormatXRGB1555; break;
case 24: format = IVDJPEGDecoder::kFormatRGB888; break;
case 32: format = IVDJPEGDecoder::kFormatXRGB8888; break;
}
mpJPEGDecoder->DecodeImage((char *)mvbFrameBuffer.data + mvbFrameBuffer.pitch * (mvbFrameBuffer.h - 1), -mvbFrameBuffer.pitch, format);
mpJPEGDecoder->End();
}
if (bIsIFF)
VDPixmapBlt(getTargetFormat(), pxIFF);
if (bIsBMP)
DecodeBMP(inputBuffer, data_len, mvbFrameBuffer);
if (bIsTGA)
DecodeTGA(inputBuffer, data_len, mvbFrameBuffer);
if (bIsPNG) {
if (!mpPNGDecoder)
mpPNGDecoder = VDCreateImageDecoderPNG();
PNGDecodeError err = mpPNGDecoder->Decode(inputBuffer, data_len);
if (err) {
if (err == kPNGDecodeOutOfMemory)
throw MyMemoryError();
vdfastvector<wchar_t> errBuf;
throw MyError("Error decoding \"%ls\": %ls\n", mpParent->ComputeFilename(errBuf, frame_num), VDLoadString(0, kVDST_PNGDecodeErrors, err));
}
VDPixmapBlt(VDAsPixmap(mvbFrameBuffer), mpPNGDecoder->GetFrameBuffer());
}
mCachedFrame = frame_num;
return mpFrameBuffer;
}
