void GLWidget::draw()
{
QPainter p(this); // used for text overlay
// save the GL state set for QPainter
p.beginNativePainting();
saveGLState();
// render the 'bubbles.svg' file into our pbuffer
QPainter pbuffer_painter(pbuffer);
svg_renderer->render(&pbuffer_painter);
pbuffer_painter.end();
glFlush();
// rendering directly to a texture is not supported on X11 and
// some Windows implementations, unfortunately
if (!hasDynamicTextureUpdate)
pbuffer->updateDynamicTexture(dynamicTexture);
makeCurrent();
// draw into the GL widget
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1, 1, -1, 1, 10, 100);
glTranslatef(0.0f, 0.0f, -15.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glViewport(0, 0, width(), height());
glBindTexture(GL_TEXTURE_2D, dynamicTexture);
glEnable(GL_TEXTURE_2D);
glEnable(GL_MULTISAMPLE);
glEnable(GL_CULL_FACE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// draw background
glPushMatrix();
glScalef(1.7f, 1.7f, 1.7f);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glCallList(tile_list);
glPopMatrix();
const int w = logo.width();
const int h = logo.height();
glRotatef(rot_x, 1.0f, 0.0f, 0.0f);
glRotatef(rot_y, 0.0f, 1.0f, 0.0f);
glRotatef(rot_z, 0.0f, 0.0f, 1.0f);
glScalef(scale/w, scale/w, scale/w);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
// draw the Qt icon
glTranslatef(-w+1, -h+1, 0.0f);
for (int y=h-1; y>=0; --y) {
uint *p = (uint*) logo.scanLine(y);
uint *end = p + w;
int x = 0;
while (p < end) {
glColor4ub(qRed(*p), qGreen(*p), qBlue(*p), uchar(qAlpha(*p)*.9));
glTranslatef(0.0f, 0.0f, wave[y*w+x]);
if (qAlpha(*p) > 128)
glCallList(tile_list);
glTranslatef(0.0f, 0.0f, -wave[y*w+x]);
glTranslatef(2.0f, 0.0f, 0.0f);
++x;
++p;
}
glTranslatef(-w*2.0f, 2.0f, 0.0f);
}
// restore the GL state that QPainter expects
restoreGLState();
p.endNativePainting();
// draw the overlayed text using QPainter
p.setPen(QColor(197, 197, 197, 157));
p.setBrush(QColor(197, 197, 197, 127));
p.drawRect(QRect(0, 0, width(), 50));
p.setPen(Qt::black);
p.setBrush(Qt::NoBrush);
const QString str1(tr("A simple OpenGL pbuffer example."));
const QString str2(tr("Use the mouse wheel to zoom, press buttons and move mouse to rotate, double-click to flip."));
QFontMetrics fm(p.font());
p.drawText(width()/2 - fm.width(str1)/2, 20, str1);
p.drawText(width()/2 - fm.width(str2)/2, 20 + fm.lineSpacing(), str2);
}
bool QgsHttpRequestHandler::greenCompare( QPair<QRgb, int> c1, QPair<QRgb, int> c2 )
{
return qGreen( c1.first ) < qGreen( c2.first );
}
void ImageOperations::featureScale( const OpGrayImage& img,
OpGrayImage& imgRet )
{
QImage qimg = img.getQtImage();
QImage qimgRet;
qimgRet.create(qimg.width()/2, qimg.height()/2, 32);
for( int y=0; y<qimg.height(); y+=2 )
{
for( int x=0; x<qimg.width(); x+=2 )
{
if( (int(x/2) < qimgRet.width()) && (int(y/2) < qimgRet.height()))
{
if( (qRed (qimg.pixel(x,y)) == 0) && // If pixel in
(qGreen(qimg.pixel(x,y)) == 0) && // image contains feature
(qBlue (qimg.pixel(x,y)) == 0))
{ // set in scaled
qimgRet.setPixel(int(x/2), int(y/2), qRgb(0,0,0));
}
else
{
if ((x < qimg.width()-1) && // Else, if pixel
((qRed (qimg.pixel(x+1,y)) == 0) && // to the right
(qGreen(qimg.pixel(x+1,y)) == 0) && // contains feature
(qBlue (qimg.pixel(x+1,y)) == 0)))
{ // set in scaled.
qimgRet.setPixel(int(x/2), int(y/2), qRgb(0,0,0));
}
else
{
if( (y < qimg.height()-1) && // Else if pixel
((qRed (qimg.pixel(x,y+1)) == 0) && // below contains
(qGreen(qimg.pixel(x,y+1)) == 0) && // feature, set
(qBlue (qimg.pixel(x,y+1)) == 0)))
{ // in scaled.
qimgRet.setPixel(int(x/2), int(y/2), qRgb(0,0,0));
}
else
{ // Else if pixel
if( ((x < qimg.width()-1) && // to the right
(y < qimg.height()-1)) && // and below
((qRed (qimg.pixel(x,y+1)) == 0) && // contains
(qGreen(qimg.pixel(x,y+1)) == 0) && // feature, set
(qBlue (qimg.pixel(x,y+1)) == 0)))
{ // it in scaled.
qimgRet.setPixel(int(x/2), int(y/2), qRgb(0,0,0));
}
else
{ // Else set
qimgRet.setPixel(int(x/2), int(y/2), // non-feature in
qRgb(255,255,255)); // scaled.
}
}
}
}
}
}
}
OpGrayImage tmp(qimgRet);
imgRet = tmp;
}
void RGBMatrix::updateMapChannels(const RGBMap& map, const FixtureGroup* grp)
{
quint32 mdAssigned = QLCChannel::invalid();
quint32 mdFxi = Fixture::invalidId();
uint fadeTime = 0;
if (overrideFadeInSpeed() == defaultSpeed())
fadeTime = fadeInSpeed();
else
fadeTime = overrideFadeInSpeed();
// Create/modify fade channels for ALL pixels in the color map.
for (int y = 0; y < map.size(); y++)
{
for (int x = 0; x < map[y].size(); x++)
{
QLCPoint pt(x, y);
GroupHead grpHead(grp->head(pt));
Fixture* fxi = doc()->fixture(grpHead.fxi);
if (fxi == NULL)
continue;
if (grpHead.fxi != mdFxi)
{
mdAssigned = QLCChannel::invalid();
mdFxi = grpHead.fxi;
}
QLCFixtureHead head = fxi->head(grpHead.head);
QVector <quint32> rgb = head.rgbChannels();
QVector <quint32> cmy = head.cmyChannels();
if (rgb.size() == 3)
{
// RGB color mixing
FadeChannel fc;
fc.setFixture(doc(), grpHead.fxi);
fc.setChannel(rgb.at(0));
fc.setTarget(qRed(map[y][x]));
insertStartValues(fc, fadeTime);
m_fader->add(fc);
fc.setChannel(rgb.at(1));
fc.setTarget(qGreen(map[y][x]));
insertStartValues(fc, fadeTime);
m_fader->add(fc);
fc.setChannel(rgb.at(2));
fc.setTarget(qBlue(map[y][x]));
insertStartValues(fc, fadeTime);
m_fader->add(fc);
}
else if (cmy.size() == 3)
{
// CMY color mixing
QColor col(map[y][x]);
FadeChannel fc;
fc.setFixture(doc(), grpHead.fxi);
fc.setChannel(cmy.at(0));
fc.setTarget(col.cyan());
insertStartValues(fc, fadeTime);
m_fader->add(fc);
fc.setChannel(cmy.at(1));
fc.setTarget(col.magenta());
insertStartValues(fc, fadeTime);
m_fader->add(fc);
fc.setChannel(cmy.at(2));
fc.setTarget(col.yellow());
insertStartValues(fc, fadeTime);
m_fader->add(fc);
}
if (head.masterIntensityChannel() != QLCChannel::invalid())
{
//qDebug() << "RGBMatrix: found dimmer at" << head.masterIntensityChannel();
// Simple intensity (dimmer) channel
QColor col(map[y][x]);
FadeChannel fc;
fc.setFixture(doc(), grpHead.fxi);
fc.setChannel(head.masterIntensityChannel());
if (col.value() == 0 && mdAssigned != head.masterIntensityChannel())
fc.setTarget(0);
else
{
fc.setTarget(255);
if (mdAssigned == QLCChannel::invalid())
mdAssigned = head.masterIntensityChannel();
}
insertStartValues(fc, fadeTime);
m_fader->add(fc);
}
}
}
}
static bool write_pbm_image(QIODevice *out, const QImage &sourceImage, const QByteArray &sourceFormat)
{
QByteArray str;
QImage image = sourceImage;
QByteArray format = sourceFormat;
format = format.left(3); // ignore RAW part
bool gray = format == "pgm";
if (format == "pbm") {
image = image.convertToFormat(QImage::Format_Mono);
} else if (image.depth() == 1) {
image = image.convertToFormat(QImage::Format_Indexed8);
} else {
switch (image.format()) {
case QImage::Format_RGB16:
case QImage::Format_RGB666:
case QImage::Format_RGB555:
case QImage::Format_RGB888:
case QImage::Format_RGB444:
image = image.convertToFormat(QImage::Format_RGB32);
break;
case QImage::Format_ARGB8565_Premultiplied:
case QImage::Format_ARGB6666_Premultiplied:
case QImage::Format_ARGB8555_Premultiplied:
case QImage::Format_ARGB4444_Premultiplied:
image = image.convertToFormat(QImage::Format_ARGB32);
break;
default:
break;
}
}
if (image.depth() == 1 && image.colorCount() == 2) {
if (qGray(image.color(0)) < qGray(image.color(1))) {
// 0=dark/black, 1=light/white - invert
image.detach();
for (int y=0; y<image.height(); y++) {
uchar *p = image.scanLine(y);
uchar *end = p + image.bytesPerLine();
while (p < end)
*p++ ^= 0xff;
}
}
}
uint w = image.width();
uint h = image.height();
str = "P\n";
str += QByteArray::number(w);
str += ' ';
str += QByteArray::number(h);
str += '\n';
switch (image.depth()) {
case 1: {
str.insert(1, '4');
if (out->write(str, str.length()) != str.length())
return false;
w = (w+7)/8;
for (uint y=0; y<h; y++) {
uchar* line = image.scanLine(y);
if (w != (uint)out->write((char*)line, w))
return false;
}
}
break;
case 8: {
str.insert(1, gray ? '5' : '6');
str.append("255\n");
if (out->write(str, str.length()) != str.length())
return false;
QVector<QRgb> color = image.colorTable();
uint bpl = w*(gray ? 1 : 3);
uchar *buf = new uchar[bpl];
for (uint y=0; y<h; y++) {
uchar *b = image.scanLine(y);
uchar *p = buf;
uchar *end = buf+bpl;
if (gray) {
while (p < end) {
uchar g = (uchar)qGray(color[*b++]);
*p++ = g;
}
} else {
while (p < end) {
QRgb rgb = color[*b++];
*p++ = qRed(rgb);
*p++ = qGreen(rgb);
*p++ = qBlue(rgb);
}
}
if (bpl != (uint)out->write((char*)buf, bpl))
return false;
}
delete [] buf;
}
break;
case 32: {
str.insert(1, gray ? '5' : '6');
str.append("255\n");
if (out->write(str, str.length()) != str.length())
return false;
uint bpl = w*(gray ? 1 : 3);
uchar *buf = new uchar[bpl];
for (uint y=0; y<h; y++) {
QRgb *b = (QRgb*)image.scanLine(y);
uchar *p = buf;
uchar *end = buf+bpl;
if (gray) {
while (p < end) {
uchar g = (uchar)qGray(*b++);
*p++ = g;
}
} else {
while (p < end) {
QRgb rgb = *b++;
*p++ = qRed(rgb);
*p++ = qGreen(rgb);
*p++ = qBlue(rgb);
}
}
if (bpl != (uint)out->write((char*)buf, bpl))
return false;
}
delete [] buf;
}
break;
default:
return false;
}
return true;
}
bool VoxelTree::readFromSquareARGB32Pixels(const char* filename) {
emit importProgress(0);
int minAlpha = INT_MAX;
QImage pngImage = QImage(filename);
for (int i = 0; i < pngImage.width(); ++i) {
for (int j = 0; j < pngImage.height(); ++j) {
minAlpha = std::min(qAlpha(pngImage.pixel(i, j)) , minAlpha);
}
}
int maxSize = std::max(pngImage.width(), pngImage.height());
int scale = 1;
while (maxSize > scale) {scale *= 2;}
float size = 1.0f / scale;
emit importSize(size * pngImage.width(), 1.0f, size * pngImage.height());
QRgb pixel;
int minNeighborhoodAlpha;
for (int i = 0; i < pngImage.width(); ++i) {
for (int j = 0; j < pngImage.height(); ++j) {
emit importProgress((100 * (i * pngImage.height() + j)) /
(pngImage.width() * pngImage.height()));
pixel = pngImage.pixel(i, j);
minNeighborhoodAlpha = qAlpha(pixel) - 1;
if (i != 0) {
minNeighborhoodAlpha = std::min(minNeighborhoodAlpha, qAlpha(pngImage.pixel(i - 1, j)));
}
if (j != 0) {
minNeighborhoodAlpha = std::min(minNeighborhoodAlpha, qAlpha(pngImage.pixel(i, j - 1)));
}
if (i < pngImage.width() - 1) {
minNeighborhoodAlpha = std::min(minNeighborhoodAlpha, qAlpha(pngImage.pixel(i + 1, j)));
}
if (j < pngImage.height() - 1) {
minNeighborhoodAlpha = std::min(minNeighborhoodAlpha, qAlpha(pngImage.pixel(i, j + 1)));
}
while (qAlpha(pixel) > minNeighborhoodAlpha) {
++minNeighborhoodAlpha;
createVoxel(i * size,
(minNeighborhoodAlpha - minAlpha) * size,
j * size,
size,
qRed(pixel),
qGreen(pixel),
qBlue(pixel),
true);
}
}
}
emit importProgress(100);
return true;
}
void renderWatermark(QImage & image, const QString & wmText, const QFont & wmFont, const unsigned int wmOpacity, double pA, double pB, double pC, double pD)
{
const double pi = 3.14159265358979323846;
double w = ((double)image.width() - pA);
double h = ((double)image.height() - pB);
double theta = (pi/-2.0) + atan(w / h);
double l = sqrt((w * w) + (h * h));
const double sintheta = sin(theta);
const double costheta = cos(theta);
double margin_width = pC;
double margin_height = pD;
int offset = (int)(l * 0.05);
int l2 = (int)(l * 0.9);
int x = (int)(sintheta * h) + offset;
int y = (int)(costheta * h);
QFont fnt = wmFont;
QFontMetrics fm = QFontMetrics(fnt);
QFontInfo fi(fnt);
QString family = fi.family();
QList<int> sizes = QFontDatabase().pointSizes(family);
qSort(sizes);
for(int i = sizes.size() - 1; i > 0; i--)
{
fnt.setPointSize(sizes[i]);
fm = QFontMetrics(fnt);
if(fm.boundingRect(wmText).width() < l2)
break;
}
int fh = fm.height();
y = y - (fh/2);
//NB QPixmap not safe outside of main thread, using QImage instead
QImage wm(image.width(), image.height(), QImage::Format_RGB32);
wm.fill(0xFFFFFFFF);
QPainter pPainter;
pPainter.begin(&wm);
pPainter.setFont(fnt);
pPainter.translate(margin_width, margin_height);
pPainter.rotate((theta/pi)*180);
pPainter.drawText(x, y, l2, fh, Qt::AlignCenter, wmText);
pPainter.end();
double opacity = wmOpacity / 255.0;
double opacity_inv = 1.0 - opacity;
QRgb s = 0;
QRgb d = 0;
for(y = 0; y < image.height(); y++) {
for(x = 0; x < image.width(); x++) {
s = wm.pixel(x, y);
if((s & 0x00ffffff) == 0x00ffffff) continue; // if it's white just skip it
d = image.pixel(x, y);
image.setPixel(x, y, qRgb( (int)((qRed(s) * opacity) + (qRed(d) * opacity_inv)),
(int)((qGreen(s) * opacity) + (qGreen(d) * opacity_inv)),
(int)((qBlue(s) * opacity) + (qBlue(d) * opacity_inv)) ));
}
}
}
QPixmap MIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)
{
QPixmap pm;
QString pmckey(d->pmcKey(size, mode, state));
if (QPixmapCache::find(pmckey, pm))
return pm;
if (d->addedPixmaps) {
pm = d->addedPixmaps->value(d->hashKey(mode, state));
if (!pm.isNull() && pm.size() == size)
return pm;
}
QSvgRenderer renderer;
d->loadDataForModeAndState(&renderer, mode, state);
if (!renderer.isValid())
return pm;
QSize actualSize = renderer.defaultSize();
if (!actualSize.isNull())
actualSize.scale(size, Qt::KeepAspectRatio);
QImage img(actualSize, QImage::Format_ARGB32);
img.fill(0x00000000);
QPainter p(&img);
renderer.render(&p);
p.end();
bool light = Ms::preferences.globalStyle == Ms::STYLE_LIGHT;
int ww = img.width();
if (state == QIcon::On) {
if (light) {
for (int y = 0; y < img.height(); ++y) {
QRgb *scanLine = (QRgb*)img.scanLine(y);
for (int x = 0; x < img.width(); ++x) {
QRgb pixel = *scanLine;
int alpha = qAlpha(pixel);
if (alpha < 0)
alpha = 0;
*scanLine = qRgba(qRed(255-pixel), qGreen(255-pixel), qBlue(255-pixel), alpha);
++scanLine;
}
}
}
else {
for (int y = 0; y < img.height(); ++y) {
quint32* p = (quint32*)img.scanLine(y);
for (int x = 0; x < ww; ++x) {
if (*p & 0xff000000) {
int d = 0xff - (*p & 0xff);
int dd = 50;
QColor color(QColor::fromRgba(*p));
int r = 70 - d + dd;
if (r < 0)
r = 0;
int g = 130 - d + dd;
if (g < 0)
g = 0;
int b = 180 - d + dd;
if (b < 0)
b = 0;
QColor nc = QColor(r, g, b, color.alpha());
*p = nc.rgba();
}
++p;
}
}
}
}
else {
// change alpha channel
int delta = 51;
if (mode == QIcon::Disabled)
delta = 178;
else if (state == QIcon::On)
delta = 0;
if (light) {
for (int y = 0; y < img.height(); ++y) {
QRgb *scanLine = (QRgb*)img.scanLine(y);
for (int x = 0; x < img.width(); ++x) {
QRgb pixel = *scanLine;
int alpha = qAlpha(pixel) - delta;
if (alpha < 0)
alpha = 0;
*scanLine = qRgba(qRed(255-pixel), qGreen(255-pixel), qBlue(255-pixel), alpha);
++scanLine;
}
}
}
else {
for (int y = 0; y < img.height(); ++y) {
QRgb *scanLine = (QRgb*)img.scanLine(y);
for (int x = 0; x < img.width(); ++x) {
QRgb pixel = *scanLine;
int alpha = qAlpha(pixel) - delta;
if (alpha < 0)
alpha = 0;
*scanLine = qRgba(qRed(pixel), qGreen(pixel), qBlue(pixel), alpha);
++scanLine;
}
}
}
}
pm = QPixmap::fromImage(img);
if (!pm.isNull())
QPixmapCache::insert(pmckey, pm);
return pm;
}
QgsRasterBlock * QgsBrightnessContrastFilter::block( int bandNo, QgsRectangle const & extent, int width, int height )
{
Q_UNUSED( bandNo );
QgsDebugMsg( QString( "width = %1 height = %2 extent = %3" ).arg( width ).arg( height ).arg( extent.toString() ) );
QgsRasterBlock *outputBlock = new QgsRasterBlock();
if ( !mInput )
{
return outputBlock;
}
// At this moment we know that we read rendered image
int bandNumber = 1;
QgsRasterBlock *inputBlock = mInput->block( bandNumber, extent, width, height );
if ( !inputBlock || inputBlock->isEmpty() )
{
QgsDebugMsg( "No raster data!" );
delete inputBlock;
return outputBlock;
}
if ( mBrightness == 0 && mContrast == 0 )
{
QgsDebugMsg( "No brightness changes." );
delete outputBlock;
return inputBlock;
}
if ( !outputBlock->reset( QGis::ARGB32_Premultiplied, width, height ) )
{
delete inputBlock;
return outputBlock;
}
// adjust image
QRgb myNoDataColor = qRgba( 0, 0, 0, 0 );
QRgb myColor;
int r, g, b, alpha;
double f = qPow(( mContrast + 100 ) / 100.0, 2 );
for ( qgssize i = 0; i < ( qgssize )width*height; i++ )
{
if ( inputBlock->color( i ) == myNoDataColor )
{
outputBlock->setColor( i, myNoDataColor );
continue;
}
myColor = inputBlock->color( i );
alpha = qAlpha( myColor );
r = adjustColorComponent( qRed( myColor ), alpha, mBrightness, f );
g = adjustColorComponent( qGreen( myColor ), alpha, mBrightness, f );
b = adjustColorComponent( qBlue( myColor ), alpha, mBrightness, f );
outputBlock->setColor( i, qRgba( r, g, b, alpha ) );
}
delete inputBlock;
return outputBlock;
}
void refresh_image( producer_qimage self, mlt_frame frame, mlt_image_format format, int width, int height )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = &self->parent;
// Get index and qimage
int image_idx = refresh_qimage( self, frame );
// optimization for subsequent iterations on single pictur
if ( image_idx != self->image_idx || width != self->current_width || height != self->current_height )
self->current_image = NULL;
// If we have a qimage and need a new scaled image
if ( self->qimage && ( !self->current_image || ( format != mlt_image_none && format != self->format ) ) )
{
QString interps = mlt_properties_get( properties, "rescale.interp" );
bool interp = ( interps != "nearest" ) && ( interps != "none" );
QImage *qimage = static_cast<QImage*>( self->qimage );
// Note - the original qimage is already safe and ready for destruction
if ( qimage->depth() == 1 )
{
QImage temp = qimage->convertToFormat( QImage::Format_RGB32 );
delete qimage;
qimage = new QImage( temp );
self->qimage = qimage;
}
QImage scaled = interp? qimage->scaled( QSize( width, height ) ) :
qimage->scaled( QSize(width, height), Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
int has_alpha = scaled.hasAlphaChannel();
// Store width and height
self->current_width = width;
self->current_height = height;
// Allocate/define image
int dst_stride = width * ( has_alpha ? 4 : 3 );
int image_size = dst_stride * ( height + 1 );
self->current_image = ( uint8_t * )mlt_pool_alloc( image_size );
self->current_alpha = NULL;
self->format = has_alpha ? mlt_image_rgb24a : mlt_image_rgb24;
// Copy the image
int y = self->current_height + 1;
uint8_t *dst = self->current_image;
while ( --y )
{
QRgb *src = (QRgb*) scaled.scanLine( self->current_height - y );
int x = self->current_width + 1;
while ( --x )
{
*dst++ = qRed(*src);
*dst++ = qGreen(*src);
*dst++ = qBlue(*src);
if ( has_alpha ) *dst++ = qAlpha(*src);
++src;
}
}
// Convert image to requested format
if ( format != mlt_image_none && format != self->format )
{
uint8_t *buffer = NULL;
// First, set the image so it can be converted when we get it
mlt_frame_replace_image( frame, self->current_image, self->format, width, height );
mlt_frame_set_image( frame, self->current_image, image_size, mlt_pool_release );
self->format = format;
// get_image will do the format conversion
mlt_frame_get_image( frame, &buffer, &format, &width, &height, 0 );
// cache copies of the image and alpha buffers
if ( buffer )
{
image_size = mlt_image_format_size( format, width, height, NULL );
self->current_image = (uint8_t*) mlt_pool_alloc( image_size );
memcpy( self->current_image, buffer, image_size );
}
if ( ( buffer = mlt_frame_get_alpha_mask( frame ) ) )
{
self->current_alpha = (uint8_t*) mlt_pool_alloc( width * height );
memcpy( self->current_alpha, buffer, width * height );
}
}
// Update the cache
mlt_cache_item_close( self->image_cache );
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "qimage.image", self->current_image, image_size, mlt_pool_release );
self->image_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.image" );
self->image_idx = image_idx;
mlt_cache_item_close( self->alpha_cache );
self->alpha_cache = NULL;
if ( self->current_alpha )
{
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "qimage.alpha", self->current_alpha, width * height, mlt_pool_release );
self->alpha_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.alpha" );
}
}
// Set width/height of frame
mlt_properties_set_int( properties, "width", self->current_width );
mlt_properties_set_int( properties, "height", self->current_height );
}
void CSettings::read()
{
QSettings settings(qApp->applicationDirPath() + "/settnig.ini", QSettings::IniFormat) ;
qDebug() << "readRootSetting\n" << settings.allKeys() ;
qDebug() << "file:" << qApp->applicationDirPath() + "/settnig.ini" ;
settings.beginGroup("Global");
#if defined(Q_OS_WIN32)
m_fileOpenDir = settings.value("cur_dir", QString(".\\")).toString() ;
#elif defined(Q_OS_MAC)
m_fileOpenDir = settings.value("cur_dir", QString("/Users/")).toString() ;
#elif defined(Q_OS_LINUX)
m_fileOpenDir = settings.value("cur_dir", QString("/home/")).toString() ;
#else
#error OSが定義されてないよ
#endif
m_fileSaveDir = settings.value("save_dir", m_fileOpenDir).toString() ;
m_pngSaveDir = settings.value("png_dir", m_fileOpenDir).toString() ;
m_jsonSaveDir = settings.value("json_dir", m_fileOpenDir).toString() ;
m_asmSaveDir = settings.value("asm_dir", m_fileOpenDir).toString() ;
QRgb col_anm = settings.value("anime_color", 0).toUInt() ;
QRgb col_img = settings.value("image_color", 0).toUInt() ;
m_animeBGColor = QColor(qRed(col_anm), qGreen(col_anm), qBlue(col_anm), qAlpha(col_anm)) ;
m_imageBGColor = QColor(qRed(col_img), qGreen(col_img), qBlue(col_img), qAlpha(col_img)) ;
m_bSaveImage = settings.value("save_image", false).toBool() ;
m_bFlat = settings.value("save_flat_json", false).toBool() ;
m_bLayerHierarchy = settings.value("layer_hierarchy", false).toBool() ;
m_frameStart = settings.value("frame_start", 0).toInt() ;
m_frameEnd = settings.value("frame_end", 30).toInt() ;
m_bBackup = settings.value("backup", false).toBool() ;
m_backupNum = settings.value("backup_num", 1).toInt() ;
settings.endGroup();
settings.beginGroup("MainWindow");
m_mainWindowGeometry = settings.value("geometry").toByteArray() ;
m_mainWindowState = settings.value("state").toByteArray() ;
settings.endGroup();
settings.beginGroup("AnimationWindow");
m_anmWindowGeometry = settings.value("geometry").toByteArray() ;
m_bUseBackImage = settings.value("use_back_image", false).toBool() ;
m_backImagePath = settings.value("back_image", "").toString() ;
m_bDrawFrame = settings.value("disp_frame", true).toBool() ;
m_bDrawCenter = settings.value("disp_center", false).toBool() ;
m_anmWindowTreeWidth = settings.value("tree_width", -1).toInt() ;
m_anmWindowTreeWidthIndex = settings.value("tree_width_idx", -1).toInt() ;
m_anmWindowScreenW = settings.value("scr_w", 0).toInt() ;
m_anmWindowScreenH = settings.value("scr_h", 0).toInt() ;
m_anmWindowW = settings.value("win_w", 2048).toInt() ;
m_anmWindowH = settings.value("win_h", 2048).toInt() ;
m_bUseDepthTest = settings.value("use_depth_test", true).toBool() ;
m_bUseZSort = settings.value("use_zsort", true).toBool() ;
m_bCheckGrid = settings.value("check_grid", true).toBool() ;
m_bCheckLinearFilter = settings.value("check_linear_filter", false).toBool() ;
settings.endGroup();
settings.beginGroup("ImageWindow");
m_imgWindowGeometry = settings.value("geometry").toByteArray() ;
settings.endGroup();
settings.beginGroup("LoupeWindow");
m_loupeWindowGeometry = settings.value("geometry").toByteArray() ;
settings.endGroup();
settings.beginGroup("CurveEditorWindow") ;
m_curveWindowGeometry = settings.value("geometry").toByteArray() ;
m_curveSplitterWidth = settings.value("splitter_width", -1).toInt() ;
m_curveSplitterWidthIndex = settings.value("splitter_width_idx", -1).toInt() ;
settings.endGroup() ;
settings.beginGroup("Shortcut");
m_scPosSelect = QKeySequence(settings.value("pos", "Z").toString()) ;
m_scRotSelect = QKeySequence(settings.value("rot", "X").toString()) ;
m_scCenterSelect = QKeySequence(settings.value("center", "C").toString()) ;
m_scScaleSelect = QKeySequence(settings.value("scale", "V").toString()) ;
m_scPathSelect = QKeySequence(settings.value("path", "B").toString()) ;
m_scCopyFrame = QKeySequence(settings.value("copy_frame", "Ctrl+C").toString()) ;
m_scPasteFrame = QKeySequence(settings.value("paste_frame", "Ctrl+V").toString()) ;
m_scPlayAnime = QKeySequence(settings.value("play_anime", "").toString()) ;
m_scStopAnime = QKeySequence(settings.value("stop_anime", "").toString()) ;
m_scJumpStartFrame = QKeySequence(settings.value("jump_start", "").toString()) ;
m_scJumpEndFrame = QKeySequence(settings.value("jump_end", "").toString()) ;
m_scAddFrameData = QKeySequence(settings.value("add_frame", "").toString()) ;
m_scDelFrameData = QKeySequence(settings.value("del_frame", "").toString()) ;
m_scDelItem = QKeySequence(settings.value("del_item", "").toString()) ;
m_scDispItem = QKeySequence(settings.value("disp_item", "").toString()) ;
m_scLockItem = QKeySequence(settings.value("lock_item", "").toString()) ;
m_scMoveAnimeWindow = QKeySequence(settings.value("move_anm_win", "").toString()) ;
m_scLockLoupe = QKeySequence(settings.value("lock_loupe", "").toString()) ;
m_scCopyAllFrame = QKeySequence(settings.value("copy_allframe", "").toString()) ;
m_scPasteAllFrame = QKeySequence(settings.value("paste_allframe", "").toString()) ;
m_scDeleteAllFrame = QKeySequence(settings.value("delete_allframe", "").toString()) ;
settings.endGroup();
}
QImage HistogramGenerator::calculateHistogram(const QSize ¶deSize, const QImage &image, const int &components,
HistogramGenerator::Rec rec, const bool &unscaled, const uint &accelFactor) const
{
if (paradeSize.height() <= 0 || paradeSize.width() <= 0 || image.width() <= 0 || image.height() <= 0) {
return QImage();
}
bool drawY = (components & HistogramGenerator::ComponentY) != 0;
bool drawR = (components & HistogramGenerator::ComponentR) != 0;
bool drawG = (components & HistogramGenerator::ComponentG) != 0;
bool drawB = (components & HistogramGenerator::ComponentB) != 0;
bool drawSum = (components & HistogramGenerator::ComponentSum) != 0;
int r[256], g[256], b[256], y[256], s[766];
// Initialize the values to zero
std::fill(r, r+256, 0);
std::fill(g, g+256, 0);
std::fill(b, b+256, 0);
std::fill(y, y+256, 0);
std::fill(s, s+766, 0);
const uint iw = image.bytesPerLine();
const uint ih = image.height();
const uint ww = paradeSize.width();
const uint wh = paradeSize.height();
const uint byteCount = iw*ih;
const uint stepsize = 4*accelFactor;
const uchar *bits = image.bits();
QRgb *col;
// Read the stats from the input image
for (uint i = 0; i < byteCount; i += stepsize) {
col = (QRgb *)bits;
r[qRed(*col)]++;
g[qGreen(*col)]++;
b[qBlue(*col)]++;
if (drawY) {
// Use if branch to avoid expensive multiplication if Y disabled
if (rec == HistogramGenerator::Rec_601) {
y[(int)floor(.299*qRed(*col) + .587*qGreen(*col) + .114*qBlue(*col))]++;
} else {
y[(int)floor(.2125*qRed(*col) + .7154*qGreen(*col) + .0721*qBlue(*col))]++;
}
}
if (drawSum) {
// Use an if branch here because the sum takes more operations than rgb
s[qRed(*col)]++;
s[qGreen(*col)]++;
s[qBlue(*col)]++;
}
bits += stepsize;
}
const int nParts = (drawY ? 1 : 0) + (drawR ? 1 : 0) + (drawG ? 1 : 0) + (drawB ? 1 : 0) + (drawSum ? 1 : 0);
if (nParts == 0) {
// Nothing to draw
return QImage();
}
const int d = 20; // Distance for text
const int partH = (wh-nParts*d)/nParts;
const float scaling = (float)partH/(byteCount >> 7);
const int dist = 40;
int wy = 0; // Drawing position
QImage histogram(paradeSize, QImage::Format_ARGB32);
QPainter davinci(&histogram);
davinci.setPen(QColor(220, 220, 220, 255));
histogram.fill(qRgba(0, 0, 0, 0));
if (drawY) {
drawComponentFull(&davinci, y, scaling, QRect(0, wy, ww, partH + dist), QColor(220, 220, 210, 255), dist, unscaled, 256);
wy += partH + d;
}
if (drawSum) {
drawComponentFull(&davinci, s, scaling/3, QRect(0, wy, ww, partH + dist), QColor(220, 220, 210, 255), dist, unscaled, 256);
wy += partH + d;
}
if (drawR) {
drawComponentFull(&davinci, r, scaling, QRect(0, wy, ww, partH + dist), QColor(255, 128, 0, 255), dist, unscaled, 256);
wy += partH + d;
}
if (drawG) {
drawComponentFull(&davinci, g, scaling, QRect(0, wy, ww, partH + dist), QColor(128, 255, 0, 255), dist, unscaled, 256);
wy += partH + d;
}
if (drawB) {
drawComponentFull(&davinci, b, scaling, QRect(0, wy, ww, partH + dist), QColor(0, 128, 255, 255), dist, unscaled, 256);
wy += partH + d;
}
return histogram;
}
static bool write_jpeg_image(const QImage &image, QIODevice *device, int sourceQuality)
{
bool success = false;
const QVector<QRgb> cmap = image.colorTable();
struct jpeg_compress_struct cinfo;
JSAMPROW row_pointer[1];
row_pointer[0] = 0;
struct my_jpeg_destination_mgr *iod_dest = new my_jpeg_destination_mgr(device);
struct my_error_mgr jerr;
cinfo.err = jpeg_std_error(&jerr);
jerr.error_exit = my_error_exit;
if (!setjmp(jerr.setjmp_buffer)) {
// WARNING:
// this if loop is inside a setjmp/longjmp branch
// do not create C++ temporaries here because the destructor may never be called
// if you allocate memory, make sure that you can free it (row_pointer[0])
jpeg_create_compress(&cinfo);
cinfo.dest = iod_dest;
cinfo.image_width = image.width();
cinfo.image_height = image.height();
bool gray=false;
switch (image.format()) {
case QImage::Format_Mono:
case QImage::Format_MonoLSB:
case QImage::Format_Indexed8:
gray = true;
for (int i = image.colorCount(); gray && i--;) {
gray = gray & (qRed(cmap[i]) == qGreen(cmap[i]) &&
qRed(cmap[i]) == qBlue(cmap[i]));
}
cinfo.input_components = gray ? 1 : 3;
cinfo.in_color_space = gray ? JCS_GRAYSCALE : JCS_RGB;
break;
default:
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
}
jpeg_set_defaults(&cinfo);
qreal diffInch = qAbs(image.dotsPerMeterX()*2.54/100. - qRound(image.dotsPerMeterX()*2.54/100.))
+ qAbs(image.dotsPerMeterY()*2.54/100. - qRound(image.dotsPerMeterY()*2.54/100.));
qreal diffCm = (qAbs(image.dotsPerMeterX()/100. - qRound(image.dotsPerMeterX()/100.))
+ qAbs(image.dotsPerMeterY()/100. - qRound(image.dotsPerMeterY()/100.)))*2.54;
if (diffInch < diffCm) {
cinfo.density_unit = 1; // dots/inch
cinfo.X_density = qRound(image.dotsPerMeterX()*2.54/100.);
cinfo.Y_density = qRound(image.dotsPerMeterY()*2.54/100.);
} else {
cinfo.density_unit = 2; // dots/cm
cinfo.X_density = (image.dotsPerMeterX()+50) / 100;
cinfo.Y_density = (image.dotsPerMeterY()+50) / 100;
}
int quality = sourceQuality >= 0 ? qMin(sourceQuality,100) : 75;
#if defined(Q_OS_UNIXWARE)
jpeg_set_quality(&cinfo, quality, B_TRUE /* limit to baseline-JPEG values */);
jpeg_start_compress(&cinfo, B_TRUE);
#else
jpeg_set_quality(&cinfo, quality, true /* limit to baseline-JPEG values */);
jpeg_start_compress(&cinfo, true);
#endif
row_pointer[0] = new uchar[cinfo.image_width*cinfo.input_components];
int w = cinfo.image_width;
while (cinfo.next_scanline < cinfo.image_height) {
uchar *row = row_pointer[0];
switch (image.format()) {
case QImage::Format_Mono:
case QImage::Format_MonoLSB:
if (gray) {
const uchar* data = image.constScanLine(cinfo.next_scanline);
if (image.format() == QImage::Format_MonoLSB) {
for (int i=0; i<w; i++) {
bool bit = !!(*(data + (i >> 3)) & (1 << (i & 7)));
row[i] = qRed(cmap[bit]);
}
} else {
for (int i=0; i<w; i++) {
bool bit = !!(*(data + (i >> 3)) & (1 << (7 -(i & 7))));
row[i] = qRed(cmap[bit]);
}
}
} else {
const uchar* data = image.constScanLine(cinfo.next_scanline);
if (image.format() == QImage::Format_MonoLSB) {
for (int i=0; i<w; i++) {
bool bit = !!(*(data + (i >> 3)) & (1 << (i & 7)));
*row++ = qRed(cmap[bit]);
*row++ = qGreen(cmap[bit]);
*row++ = qBlue(cmap[bit]);
}
} else {
for (int i=0; i<w; i++) {
bool bit = !!(*(data + (i >> 3)) & (1 << (7 -(i & 7))));
*row++ = qRed(cmap[bit]);
*row++ = qGreen(cmap[bit]);
*row++ = qBlue(cmap[bit]);
}
}
}
void RGBMatrix::updateMapChannels(const RGBMap& map, const FixtureGroup* grp)
{
uint fadeTime = (overrideFadeInSpeed() == defaultSpeed()) ? fadeInSpeed() : overrideFadeInSpeed();
// Create/modify fade channels for ALL pixels in the color map.
for (int y = 0; y < map.size(); y++)
{
for (int x = 0; x < map[y].size(); x++)
{
QLCPoint pt(x, y);
GroupHead grpHead(grp->head(pt));
Fixture* fxi = doc()->fixture(grpHead.fxi);
if (fxi == NULL)
continue;
QLCFixtureHead head = fxi->head(grpHead.head);
QVector <quint32> rgb = head.rgbChannels();
QVector <quint32> cmy = head.cmyChannels();
quint32 masterDim = fxi->masterIntensityChannel();
quint32 headDim = head.channelNumber(QLCChannel::Intensity, QLCChannel::MSB);
// Collect all dimmers that affect current head:
// They are the master dimmer (affects whole fixture)
// and per-head dimmer.
//
// If there are no RGB or CMY channels, the least important* dimmer channel
// is used to create grayscale image.
//
// The rest of the dimmer channels are set to full if dimmer control is
// enabled and target color is > 0 (see
// http://www.qlcplus.org/forum/viewtopic.php?f=29&t=11090)
//
// Note: If there is only one head, and only one dimmer channel,
// make it a master dimmer in fixture definition.
//
// *least important - per head dimmer if present,
// otherwise per fixture dimmer if present
QVector <quint32> dim;
if (masterDim != QLCChannel::invalid())
dim << masterDim;
if (headDim != QLCChannel::invalid())
dim << headDim;
uint col = map[y][x];
if (rgb.size() == 3)
{
// RGB color mixing
{
FadeChannel fc(doc(), grpHead.fxi, rgb.at(0));
fc.setTarget(qRed(col));
insertStartValues(fc, fadeTime);
m_fader->add(fc);
}
{
FadeChannel fc(doc(), grpHead.fxi, rgb.at(1));
fc.setTarget(qGreen(col));
insertStartValues(fc, fadeTime);
m_fader->add(fc);
}
{
FadeChannel fc(doc(), grpHead.fxi, rgb.at(2));
fc.setTarget(qBlue(col));
insertStartValues(fc, fadeTime);
m_fader->add(fc);
}
}
else if (cmy.size() == 3)
{
// CMY color mixing
QColor cmyCol(col);
{
FadeChannel fc(doc(), grpHead.fxi, cmy.at(0));
fc.setTarget(cmyCol.cyan());
insertStartValues(fc, fadeTime);
m_fader->add(fc);
}
{
FadeChannel fc(doc(), grpHead.fxi, cmy.at(1));
fc.setTarget(cmyCol.magenta());
insertStartValues(fc, fadeTime);
m_fader->add(fc);
}
{
FadeChannel fc(doc(), grpHead.fxi, cmy.at(2));
fc.setTarget(cmyCol.yellow());
insertStartValues(fc, fadeTime);
m_fader->add(fc);
}
}
else if (!dim.empty())
{
// Set dimmer to value of the color (e.g. for PARs)
FadeChannel fc(doc(), grpHead.fxi, dim.last());
// the weights are taken from
// https://en.wikipedia.org/wiki/YUV#SDTV_with_BT.601
fc.setTarget(0.299 * qRed(col) + 0.587 * qGreen(col) + 0.114 * qBlue(col));
insertStartValues(fc, fadeTime);
m_fader->add(fc);
dim.pop_back();
}
if (m_dimmerControl)
{
// Set the rest of the dimmer channels to full on
foreach(quint32 ch, dim)
{
FadeChannel fc(doc(), grpHead.fxi, ch);
fc.setTarget(col == 0 ? 0 : 255);
insertStartValues(fc, fadeTime);
m_fader->add(fc);
}
}
}
}
// Flood fill
// ----- http://lodev.org/cgtutor/floodfill.html
void BitmapImage::floodFill(BitmapImage* targetImage,
QRect cameraRect,
QPoint point,
QRgb newColor,
int tolerance)
{
// If the point we are supposed to fill is outside the image and camera bounds, do nothing
if(!cameraRect.united(targetImage->bounds()).contains(point))
{
return;
}
// Square tolerance for use with compareColor
tolerance = static_cast<int>(qPow(tolerance, 2));
QRgb oldColor = targetImage->pixel(point);
oldColor = qRgba(qRed(oldColor), qGreen(oldColor), qBlue(oldColor), qAlpha(oldColor));
// Preparations
QList<QPoint> queue; // queue all the pixels of the filled area (as they are found)
BitmapImage* replaceImage = nullptr;
QPoint tempPoint;
QRgb newPlacedColor = 0;
QScopedPointer< QHash<QRgb, bool> > cache(new QHash<QRgb, bool>());
int xTemp = 0;
bool spanLeft = false;
bool spanRight = false;
// Extend to size of Camera
targetImage->extend(cameraRect);
replaceImage = new BitmapImage(cameraRect, Qt::transparent);
queue.append(point);
// Preparations END
while (!queue.empty())
{
tempPoint = queue.takeFirst();
point.setX(tempPoint.x());
point.setY(tempPoint.y());
xTemp = point.x();
newPlacedColor = replaceImage->constScanLine(xTemp, point.y());
while (xTemp >= targetImage->mBounds.left() &&
compareColor(targetImage->constScanLine(xTemp, point.y()), oldColor, tolerance, cache.data())) xTemp--;
xTemp++;
spanLeft = spanRight = false;
while (xTemp <= targetImage->mBounds.right() &&
compareColor(targetImage->constScanLine(xTemp, point.y()), oldColor, tolerance, cache.data()) &&
newPlacedColor != newColor)
{
// Set pixel color
replaceImage->scanLine(xTemp, point.y(), newColor);
if (!spanLeft && (point.y() > targetImage->mBounds.top()) &&
compareColor(targetImage->constScanLine(xTemp, point.y() - 1), oldColor, tolerance, cache.data())) {
queue.append(QPoint(xTemp, point.y() - 1));
spanLeft = true;
}
else if (spanLeft && (point.y() > targetImage->mBounds.top()) &&
!compareColor(targetImage->constScanLine(xTemp, point.y() - 1), oldColor, tolerance, cache.data())) {
spanLeft = false;
}
if (!spanRight && point.y() < targetImage->mBounds.bottom() &&
compareColor(targetImage->constScanLine(xTemp, point.y() + 1), oldColor, tolerance, cache.data())) {
queue.append(QPoint(xTemp, point.y() + 1));
spanRight = true;
}
else if (spanRight && point.y() < targetImage->mBounds.bottom() &&
!compareColor(targetImage->constScanLine(xTemp, point.y() + 1), oldColor, tolerance, cache.data())) {
spanRight = false;
}
Q_ASSERT(queue.count() < (targetImage->mBounds.width() * targetImage->mBounds.height()));
xTemp++;
}
}
targetImage->paste(replaceImage);
targetImage->modification();
delete replaceImage;
}
QImage EdgeDetection::gradientMagnitudeImage(QImage *image)
{
QImage new_image(image->size(), QImage::Format_ARGB32_Premultiplied);
// QImage orient_image(image->size(), QImage::Format_ARGB32_Premultiplied);
QList<QPair<QPoint, QPair<int, int> > > x_y_struct;
x_y_struct.append( qMakePair(QPoint(-1,-1), QPair<int,int>(-1, 1) ));
x_y_struct.append( qMakePair(QPoint(-1,0), QPair<int,int>(-2, 0) ));
x_y_struct.append( qMakePair(QPoint(-1,1), QPair<int,int>(-1,-1) ));
x_y_struct.append( qMakePair(QPoint(0,-1), QPair<int,int>(0,2) ));
x_y_struct.append( qMakePair(QPoint(0,0), QPair<int,int>(0,0) ));
x_y_struct.append( qMakePair(QPoint(0,1), QPair<int,int>(0,-2) ));
x_y_struct.append( qMakePair(QPoint(1,-1), QPair<int,int>(1,1) ));
x_y_struct.append( qMakePair(QPoint(1,0), QPair<int,int>(2,0) ));
x_y_struct.append( qMakePair(QPoint(1,1), QPair<int,int>(1, -1) ));
// QList<QPair<QPoint, qreal> > orientations;
// qreal orien_min = 1000;
// qreal orien_max = 0;
// int threshold = QInputDialog::getInteger(0, "Threshold", "Threshold value:", -1, -1, 255);
for( int y=0; y < image->height(); y++ ) {
for( int x=0; x < image->width(); x++ ) {
QPoint point(x,y);
int x_sum = 0;
int x_rsum = 0;
int x_gsum = 0;
int x_bsum = 0;
int y_sum = 0;
int y_rsum = 0;
int y_gsum = 0;
int y_bsum = 0;
//Perform Convolution on X
for (int i=0; i < x_y_struct.size(); i++) {
QPoint offset = x_y_struct.at(i).first;
QPair<int,int> multiplier = x_y_struct.at(i).second;
//Only convolve real pixels
int pixel_x = offset.x() + x;
int pixel_y = offset.y() + y;
QRgb color;
if ( pixel_x < 0 ||
pixel_x >= image->width() ||
pixel_y < 0 ||
pixel_y >= image->height() ) {
color = qRgb(128, 128, 128);
} else {
color = image->pixel(QPoint(pixel_x, pixel_y));
}
int gray_val = qGray(color);
x_sum += gray_val * multiplier.first;
x_rsum += qRed(color) * multiplier.first;
x_gsum += qGreen(color) * multiplier.first;
x_bsum += qBlue(color) * multiplier.first;
y_sum += gray_val * multiplier.second;
y_rsum += qRed(color) * multiplier.second;
y_gsum += qGreen(color) * multiplier.second;
y_bsum += qBlue(color) * multiplier.second;
}
//Gradient
qreal gradient = qSqrt(qPow(x_sum / 8, 2) + qPow(y_sum / 8, 2));
qreal r_gradient = qSqrt(qPow(x_rsum / 8, 2) + qPow(y_rsum / 8, 2));
qreal g_gradient = qSqrt(qPow(x_gsum / 8, 2) + qPow(y_gsum / 8, 2));
qreal b_gradient = qSqrt(qPow(x_bsum / 8, 2) + qPow(y_bsum / 8, 2));
//Orientation
// qreal orientation = qAtan2(y_sum, x_sum);
// if ( orientation < orien_min )
// orien_min = orientation;
// if ( orientation > orien_max )
// orien_max = orientation;
// orientations.append(qMakePair(point, orientation));
//Threshold
// QRgb val;
// if ( threshold < 0 ) {
// val = qRgb(gradient, gradient, gradient);
// } else if ( gradient > threshold ) {
// val = qRgb(255,255,255);
// } else
// val = qRgb(0,0,0);
// new_image.setPixel(point, val);
new_image.setPixel(point, qRgb(r_gradient, g_gradient, b_gradient));
}
}
// for( int i=0; i < orientations.size(); i++ ) {
// QPair<QPoint, qreal> o_pair = orientations.at(i);
// qreal normal = Utility::rangeConvert(orien_max, orien_min, 255, 0, o_pair.second);
// orient_image.setPixel(o_pair.first, qRgb(normal, normal, normal));
// }
return new_image;
}
void MaskWidget::paintEvent(QPaintEvent* e)
{
if (!m_desktopPixmap.isNull())
{
m_curPos = QCursor::pos();
QPainter painter(this);
painter.drawPixmap(0, 0, m_desktopPixmap);
if (!m_bScreenShotDone)
{
if (!m_bDragging)
{
m_curRc.setRect(-9999, -9999, 19999, 19999);
for (std::vector<RECT>::iterator it = g_winRects.begin(); it != g_winRects.end(); ++it)
{
QRect rect;
rect.setRect(it->left, it->top, it->right - it->left, it->bottom - it->top);
if (rect.contains(QCursor::pos()) && m_curRc.contains(rect)/* && rect.height() > 5 && rect.width() > 5*/)
{
m_curRc = rect;
//break;
}
}
}
else
{
m_curRc = QRect(m_startPoint, QCursor::pos());
}
}
painter.save();
painter.setPen(Qt::NoPen);
painter.setBrush(QColor(0, 0, 0, 120));
QPolygon p1(QRect(0, 0, width(), height()));
QPolygon p2(m_curRc, true);
p1 = p1.subtracted(p2);
painter.drawPolygon(p1);
painter.restore();
painter.save();
QPen pen = painter.pen();
if (m_bScreenShotDone || m_bMousePressing)
{
pen.setWidth(2);
pen.setColor(QColor(6, 157, 213));
pen.setStyle(Qt::DashDotDotLine);
}
else
{
pen.setWidth(4);
pen.setColor(QColor(0, 255, 0));
pen.setStyle(Qt::SolidLine);
}
painter.setPen(pen);
painter.drawRect(m_curRc);
painter.restore();
painter.save();
QRect ori(m_curPos.x() - 15, m_curPos.y() - 11, 30, 22);
QPixmap magnifier(126, 122);
QPainter painter2(&magnifier);
painter2.save();
painter2.fillRect(0, 0, 126, 122, QBrush(QColor(51, 51, 51, 200)));
painter2.restore();
QPen p = painter2.pen();
p.setWidth(1);
p.setColor(QColor(51, 51, 51));
painter2.setPen(p);
painter2.drawRect(0, 0, 125, 93);
p.setWidth(2);
p.setColor(QColor(255, 255, 255));
painter2.setPen(p);
painter2.drawRect(2, 2, 122, 90);
painter2.drawPixmap(3, 3, m_desktopPixmap.copy(ori).scaled(120, 88));
p.setWidth(4);
p.setColor(QColor(0, 122, 179, 128));
painter2.setPen(p);
painter2.drawLine(5, 45, 121, 45);
painter2.drawLine(61, 5, 61, 89);
p.setWidth(1);
p.setColor(QColor(255, 255, 255));
painter2.setPen(p);
painter2.drawText(6, 105, QString("%1 x %2").arg(m_curRc.width()).arg(m_curRc.height()));
QImage image = m_desktopPixmap.toImage();
QRgb rgb = image.pixel(m_curPos.x()-1, m_curPos.y()-1);
painter2.drawText(6, 118, QString("rgb(%1,%2,%3").arg(qRed(rgb)).arg(qGreen(rgb)).arg(qBlue(rgb)));
QPoint showPoint(m_curPos.x() + 10, m_curPos.y() + 10);
if (m_curPos.y() + 130 > this->height())
showPoint.setY(m_curPos.y() - 130);
if (m_curPos.x() + 130 > this->width())
showPoint.setX(m_curPos.x() - 130);
painter.drawPixmap(showPoint, magnifier);
}
}
static void _soften(QString sourceFile, QString destFile)
{
QImage image(sourceFile);
if(image.isNull())
{
qDebug() << "load " << sourceFile << " failed! ";
return;
}
int width = image.width();
int height = image.height();
int r, g, b;
QRgb color;
int xLimit = width - 1;
int yLimit = height - 1;
for(int i = 1; i < xLimit; i++)
{
for(int j = 1; j < yLimit; j++)
{
r = 0;
g = 0;
b = 0;
for(int m = 0; m < 9; m++)
{
int s = 0;
int p = 0;
switch(m)
{
case 0:
s = i - 1;
p = j - 1;
break;
case 1:
s = i;
p = j - 1;
break;
case 2:
s = i + 1;
p = j - 1;
break;
case 3:
s = i + 1;
p = j;
break;
case 4:
s = i + 1;
p = j + 1;
break;
case 5:
s = i;
p = j + 1;
break;
case 6:
s = i - 1;
p = j + 1;
break;
case 7:
s = i - 1;
p = j;
break;
case 8:
s = i;
p = j;
}
color = image.pixel(s, p);
r += qRed(color);
g += qGreen(color);
b += qBlue(color);
}
r = (int) (r / 9.0);
g = (int) (g / 9.0);
b = (int) (b / 9.0);
r = qMin(255, qMax(0, r));
g = qMin(255, qMax(0, g));
b = qMin(255, qMax(0, b));
image.setPixel(i, j, qRgb(r, g, b));
}
}
image.save(destFile);
}
static QRgb weighpixel(QRgb rgb, int percentage)
{
return qRgb((qRed(rgb) * percentage) >> (FIXEDPOINT_FRACTIONBITS * 2),
(qGreen(rgb) * percentage) >> (FIXEDPOINT_FRACTIONBITS * 2),
(qBlue(rgb) * percentage) >> (FIXEDPOINT_FRACTIONBITS * 2));
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QDir src_dir("../gfx/");
QDir dst_dir("c:/temp/");
dst_dir.mkdir("gfx_2x/");
dst_dir.cd("gfx_2x/");
QRgb filter_rgb = qRgba(240, 0, 0, 255);
QRgb mask_rgb = qRgba(255, 0, 255, 255);
QRgb shadow_rgb = qRgba(127, 0, 127, 255);
QStringList list = src_dir.entryList();
foreach(const QString file, list) {
qDebug("found file: %s", file.toStdString().c_str());
QImage image(src_dir.filePath(file));
if( !image.isNull() ) {
if( image.width() % 2 != 0 ) {
throw "image width not multiple of 2";
}
if( image.height() % 2 != 0 ) {
throw "image height not multiple of 2";
}
int new_width = image.width() / 2;
int new_height = image.height() / 2;
QImage new_image(new_width, new_height, image.format());
new_image.fill(0);
for(int y=0;y<new_height;y++) {
for(int x=0;x<new_width;x++) {
QRgb rgb00 = image.pixel(2*x, 2*y);
QRgb rgb10 = image.pixel(2*x+1, 2*y);
QRgb rgb01 = image.pixel(2*x, 2*y);
QRgb rgb11 = image.pixel(2*x+1, 2*y+1);
if( rgb00 == filter_rgb || rgb10 == filter_rgb || rgb01 == filter_rgb || rgb11 == filter_rgb ) {
rgb00 = filter_rgb;
rgb10 = filter_rgb;
rgb01 = filter_rgb;
rgb11 = filter_rgb;
}
else if( rgb00 == mask_rgb || rgb10 == mask_rgb || rgb01 == mask_rgb || rgb11 == mask_rgb ) {
rgb00 = mask_rgb;
rgb10 = mask_rgb;
rgb01 = mask_rgb;
rgb11 = mask_rgb;
}
else if( rgb00 == shadow_rgb || rgb10 == shadow_rgb || rgb01 == shadow_rgb || rgb11 == shadow_rgb ) {
rgb00 = shadow_rgb;
rgb10 = shadow_rgb;
rgb01 = shadow_rgb;
rgb11 = shadow_rgb;
}
/*if( rgb00 == mask_rgb ) {
rgb00 = qRgba(0, 0, 0, 0);
}
if( rgb10 == mask_rgb ) {
rgb10 = qRgba(0, 0, 0, 0);
}
if( rgb01 == mask_rgb ) {
rgb01 = qRgba(0, 0, 0, 0);
}
if( rgb11 == mask_rgb ) {
rgb11 = qRgba(0, 0, 0, 0);
}
if( rgb00 == shadow_rgb ) {
rgb00 = qRgba(0, 0, 0, 0);
}
if( rgb10 == shadow_rgb ) {
rgb10 = qRgba(0, 0, 0, 0);
}
if( rgb01 == shadow_rgb ) {
rgb01 = qRgba(0, 0, 0, 0);
}
if( rgb11 == shadow_rgb ) {
rgb11 = qRgba(0, 0, 0, 0);
}*/
int irgb00[] = {qRed(rgb00), qGreen(rgb00), qBlue(rgb00), qAlpha(rgb00)};
int irgb10[] = {qRed(rgb10), qGreen(rgb10), qBlue(rgb10), qAlpha(rgb10)};
int irgb01[] = {qRed(rgb01), qGreen(rgb01), qBlue(rgb01), qAlpha(rgb01)};
int irgb11[] = {qRed(rgb11), qGreen(rgb11), qBlue(rgb11), qAlpha(rgb11)};
int irgb[] = {0, 0, 0, 0};
for(int i=0;i<4;i++) {
int result = (int)((irgb00[i] + irgb10[i] + irgb01[i] + irgb11[i]) / 4.0);
irgb[i] = result;
}
QRgb rgb = qRgba(irgb[0], irgb[1], irgb[2], irgb[3]);
new_image.setPixel(x, y, rgb);
}
}
QString save_filename = dst_dir.filePath(file);
qDebug(" save as %s", save_filename.toStdString().c_str());
if( !new_image.save(save_filename) ) {
throw "failed to save";
}
}
else {
qDebug(" failed to load");
}
}
bool closeRGB(const QRgb &r1, const QRgb &r2)
{
return std::abs(qRed(r1) - qRed(r2)) +
std::abs(qGreen(r1) - qGreen(r2)) +
std::abs(qBlue(r1) - qBlue(r2)) < ColorThreshold;
}
QgsRasterFileWriter::WriterError QgsRasterFileWriter::writeImageRaster( QgsRasterIterator* iter, int nCols, int nRows, const QgsRectangle& outputExtent,
const QgsCoordinateReferenceSystem& crs, QProgressDialog* progressDialog )
{
QgsDebugMsg( "Entered" );
if ( !iter )
{
return SourceProviderError;
}
const QgsRasterInterface* iface = iter->input();
QGis::DataType inputDataType = iface->dataType( 1 );
if ( !iface || ( inputDataType != QGis::ARGB32 &&
inputDataType != QGis::ARGB32_Premultiplied ) )
{
return SourceProviderError;
}
iter->setMaximumTileWidth( mMaxTileWidth );
iter->setMaximumTileHeight( mMaxTileHeight );
void* redData = qgsMalloc( mMaxTileWidth * mMaxTileHeight );
void* greenData = qgsMalloc( mMaxTileWidth * mMaxTileHeight );
void* blueData = qgsMalloc( mMaxTileWidth * mMaxTileHeight );
void* alphaData = qgsMalloc( mMaxTileWidth * mMaxTileHeight );
QgsRectangle mapRect;
int iterLeft = 0, iterTop = 0, iterCols = 0, iterRows = 0;
int fileIndex = 0;
//create destProvider for whole dataset here
QgsRasterDataProvider* destProvider = 0;
double pixelSize;
double geoTransform[6];
globalOutputParameters( outputExtent, nCols, nRows, geoTransform, pixelSize );
destProvider = initOutput( nCols, nRows, crs, geoTransform, 4, QGis::Byte );
iter->startRasterRead( 1, nCols, nRows, outputExtent );
int nParts = 0;
if ( progressDialog )
{
int nPartsX = nCols / iter->maximumTileWidth() + 1;
int nPartsY = nRows / iter->maximumTileHeight() + 1;
nParts = nPartsX * nPartsY;
progressDialog->setMaximum( nParts );
progressDialog->show();
progressDialog->setLabelText( QObject::tr( "Reading raster part %1 of %2" ).arg( fileIndex + 1 ).arg( nParts ) );
}
QgsRasterBlock *inputBlock = 0;
while ( iter->readNextRasterPart( 1, iterCols, iterRows, &inputBlock, iterLeft, iterTop ) )
{
if ( !inputBlock )
{
continue;
}
if ( progressDialog && fileIndex < ( nParts - 1 ) )
{
progressDialog->setValue( fileIndex + 1 );
progressDialog->setLabelText( QObject::tr( "Reading raster part %1 of %2" ).arg( fileIndex + 2 ).arg( nParts ) );
QCoreApplication::processEvents( QEventLoop::AllEvents, 1000 );
if ( progressDialog->wasCanceled() )
{
delete inputBlock;
break;
}
}
//fill into red/green/blue/alpha channels
qgssize nPixels = ( qgssize )iterCols * iterRows;
// TODO: should be char not int? we are then copying 1 byte
int red = 0;
int green = 0;
int blue = 0;
int alpha = 255;
for ( qgssize i = 0; i < nPixels; ++i )
{
QRgb c = inputBlock->color( i );
alpha = qAlpha( c );
red = qRed( c ); green = qGreen( c ); blue = qBlue( c );
if ( inputDataType == QGis::ARGB32_Premultiplied )
{
double a = alpha / 255.;
QgsDebugMsgLevel( QString( "red = %1 green = %2 blue = %3 alpha = %4 p = %5 a = %6" ).arg( red ).arg( green ).arg( blue ).arg( alpha ).arg(( int )c, 0, 16 ).arg( a ), 5 );
red /= a;
green /= a;
blue /= a;
}
memcpy(( char* )redData + i, &red, 1 );
memcpy(( char* )greenData + i, &green, 1 );
memcpy(( char* )blueData + i, &blue, 1 );
memcpy(( char* )alphaData + i, &alpha, 1 );
}
delete inputBlock;
//create output file
if ( mTiledMode )
{
//delete destProvider;
QgsRasterDataProvider* partDestProvider = createPartProvider( outputExtent,
nCols, iterCols, iterRows,
iterLeft, iterTop, mOutputUrl, fileIndex,
4, QGis::Byte, crs );
if ( partDestProvider )
{
//write data to output file
partDestProvider->write( redData, 1, iterCols, iterRows, 0, 0 );
partDestProvider->write( greenData, 2, iterCols, iterRows, 0, 0 );
partDestProvider->write( blueData, 3, iterCols, iterRows, 0, 0 );
partDestProvider->write( alphaData, 4, iterCols, iterRows, 0, 0 );
addToVRT( partFileName( fileIndex ), 1, iterCols, iterRows, iterLeft, iterTop );
addToVRT( partFileName( fileIndex ), 2, iterCols, iterRows, iterLeft, iterTop );
addToVRT( partFileName( fileIndex ), 3, iterCols, iterRows, iterLeft, iterTop );
addToVRT( partFileName( fileIndex ), 4, iterCols, iterRows, iterLeft, iterTop );
delete partDestProvider;
}
}
else if ( destProvider )
{
destProvider->write( redData, 1, iterCols, iterRows, iterLeft, iterTop );
destProvider->write( greenData, 2, iterCols, iterRows, iterLeft, iterTop );
destProvider->write( blueData, 3, iterCols, iterRows, iterLeft, iterTop );
destProvider->write( alphaData, 4, iterCols, iterRows, iterLeft, iterTop );
}
++fileIndex;
}
if ( destProvider )
delete destProvider;
qgsFree( redData ); qgsFree( greenData ); qgsFree( blueData ); qgsFree( alphaData );
if ( progressDialog )
{
progressDialog->setValue( progressDialog->maximum() );
}
if ( mTiledMode )
{
QString vrtFilePath( mOutputUrl + "/" + vrtFileName() );
writeVRT( vrtFilePath );
if ( mBuildPyramidsFlag == QgsRaster::PyramidsFlagYes )
{
buildPyramids( vrtFilePath );
}
}
else
{
if ( mBuildPyramidsFlag == QgsRaster::PyramidsFlagYes )
{
buildPyramids( mOutputUrl );
}
}
return NoError;
}
bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image, volatile int quality_in, const QString &description,
int off_x_in, int off_y_in)
{
QPoint offset = image.offset();
int off_x = off_x_in + offset.x();
int off_y = off_y_in + offset.y();
png_structp png_ptr;
png_infop info_ptr;
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,0,0,0);
if (!png_ptr) {
return false;
}
png_set_error_fn(png_ptr, 0, 0, qt_png_warning);
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr, 0);
return false;
}
if (setjmp(png_jmpbuf(png_ptr))) {
png_destroy_write_struct(&png_ptr, &info_ptr);
return false;
}
int quality = quality_in;
if (quality >= 0) {
if (quality > 9) {
qWarning("PNG: Quality %d out of range", quality);
quality = 9;
}
png_set_compression_level(png_ptr, quality);
}
png_set_write_fn(png_ptr, (void*)this, qpiw_write_fn, qpiw_flush_fn);
int color_type = 0;
if (image.colorCount()) {
if (image.isGrayscale())
color_type = PNG_COLOR_TYPE_GRAY;
else
color_type = PNG_COLOR_TYPE_PALETTE;
}
else if (image.format() == QImage::Format_Grayscale8)
color_type = PNG_COLOR_TYPE_GRAY;
else if (image.hasAlphaChannel())
color_type = PNG_COLOR_TYPE_RGB_ALPHA;
else
color_type = PNG_COLOR_TYPE_RGB;
png_set_IHDR(png_ptr, info_ptr, image.width(), image.height(),
image.depth() == 1 ? 1 : 8, // per channel
color_type, 0, 0, 0); // sets #channels
if (gamma != 0.0) {
png_set_gAMA(png_ptr, info_ptr, 1.0/gamma);
}
if (image.format() == QImage::Format_MonoLSB)
png_set_packswap(png_ptr);
if (color_type == PNG_COLOR_TYPE_PALETTE) {
// Paletted
int num_palette = qMin(256, image.colorCount());
png_color palette[256];
png_byte trans[256];
int num_trans = 0;
for (int i=0; i<num_palette; i++) {
QRgb rgba=image.color(i);
palette[i].red = qRed(rgba);
palette[i].green = qGreen(rgba);
palette[i].blue = qBlue(rgba);
trans[i] = qAlpha(rgba);
if (trans[i] < 255) {
num_trans = i+1;
}
}
png_set_PLTE(png_ptr, info_ptr, palette, num_palette);
if (num_trans) {
png_set_tRNS(png_ptr, info_ptr, trans, num_trans, 0);
}
}
// Swap ARGB to RGBA (normal PNG format) before saving on
// BigEndian machines
if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
png_set_swap_alpha(png_ptr);
}
// Qt==ARGB==Big(ARGB)==Little(BGRA). But RGB888 is RGB regardless
if (QSysInfo::ByteOrder == QSysInfo::LittleEndian
&& image.format() != QImage::Format_RGB888) {
png_set_bgr(png_ptr);
}
if (off_x || off_y) {
png_set_oFFs(png_ptr, info_ptr, off_x, off_y, PNG_OFFSET_PIXEL);
}
if (frames_written > 0)
png_set_sig_bytes(png_ptr, 8);
if (image.dotsPerMeterX() > 0 || image.dotsPerMeterY() > 0) {
png_set_pHYs(png_ptr, info_ptr,
image.dotsPerMeterX(), image.dotsPerMeterY(),
PNG_RESOLUTION_METER);
}
set_text(image, png_ptr, info_ptr, description);
png_write_info(png_ptr, info_ptr);
if (image.depth() != 1)
png_set_packing(png_ptr);
if (color_type == PNG_COLOR_TYPE_RGB && image.format() != QImage::Format_RGB888)
png_set_filler(png_ptr, 0,
QSysInfo::ByteOrder == QSysInfo::BigEndian ?
PNG_FILLER_BEFORE : PNG_FILLER_AFTER);
if (looping >= 0 && frames_written == 0) {
uchar data[13] = "NETSCAPE2.0";
// 0123456789aBC
data[0xB] = looping%0x100;
data[0xC] = looping/0x100;
png_write_chunk(png_ptr, const_cast<png_bytep>((const png_byte *)"gIFx"), data, 13);
}
if (ms_delay >= 0 || disposal!=Unspecified) {
uchar data[4];
data[0] = disposal;
data[1] = 0;
data[2] = (ms_delay/10)/0x100; // hundredths
data[3] = (ms_delay/10)%0x100;
png_write_chunk(png_ptr, const_cast<png_bytep>((const png_byte *)"gIFg"), data, 4);
}
int height = image.height();
int width = image.width();
switch (image.format()) {
case QImage::Format_Mono:
case QImage::Format_MonoLSB:
case QImage::Format_Indexed8:
case QImage::Format_Grayscale8:
case QImage::Format_RGB32:
case QImage::Format_ARGB32:
case QImage::Format_RGB888:
{
png_bytep* row_pointers = new png_bytep[height];
for (int y=0; y<height; y++)
row_pointers[y] = const_cast<png_bytep>(image.constScanLine(y));
png_write_image(png_ptr, row_pointers);
delete [] row_pointers;
}
break;
default:
{
QImage::Format fmt = image.hasAlphaChannel() ? QImage::Format_ARGB32 : QImage::Format_RGB32;
QImage row;
png_bytep row_pointers[1];
for (int y=0; y<height; y++) {
row = image.copy(0, y, width, 1).convertToFormat(fmt);
row_pointers[0] = const_cast<png_bytep>(row.constScanLine(0));
png_write_rows(png_ptr, row_pointers, 1);
}
}
break;
}
png_write_end(png_ptr, info_ptr);
frames_written++;
png_destroy_write_struct(&png_ptr, &info_ptr);
return true;
}
QRgb macGetRgba( QRgb initial, bool *ok, QWidget *parent, const char* )
{
Point p = { -1, -1 };
const uchar *pstr = p_str("Choose a color");
static const int sw = 420, sh = 300;
if(parent) {
parent = parent->topLevelWidget();
p.h = (parent->x() + (parent->width() / 2)) - (sw / 2);
p.v = (parent->y() + (parent->height() / 2)) - (sh / 2);
QRect r = QApplication::desktop()->screenGeometry(QApplication::desktop()->screenNumber(parent));
if(p.h + sw > r.right())
p.h -= (p.h + sw) - r.right() + 10;
if(p.v + sh > r.bottom())
p.v -= (p.v + sh) - r.bottom() + 10;
} else if(QWidget *w = qApp->mainWidget()) {
static int last_screen = -1;
int scr = QApplication::desktop()->screenNumber(w);
if(last_screen != scr) {
QRect r = QApplication::desktop()->screenGeometry(scr);
p.h = (r.x() + (r.width() / 2)) - (sw / 2);
p.v = (r.y() + (r.height() / 2)) - (sh / 2);
}
}
RGBColor rgb, rgbout;
rgb.red = qRed(initial) * 256;
rgb.blue = qBlue(initial) * 256;
rgb.green = qGreen(initial) * 256;
#if 1
Point place;
place.h = p.h == -1 ? 0 : p.h;
place.v = p.v == -1 ? 0 : p.v;
Boolean rval = FALSE;
{
QMacBlockingFunction block;
QWidget modal_widg(parent, __FILE__ "__modal_dlg",
Qt::WType_TopLevel | Qt::WStyle_Customize | Qt::WStyle_DialogBorder);
qt_enter_modal(&modal_widg);
rval = GetColor(place, pstr, &rgb, &rgbout);
qt_leave_modal(&modal_widg);
}
#else
ColorPickerInfo cpInfo;
// Set the input color to be an RGB color in system space.
cpInfo.theColor.color.rgb.red = rgb.red;
cpInfo.theColor.color.rgb.green = rgb.green;
cpInfo.theColor.color.rgb.blue = rgb.blue;
cpInfo.theColor.profile = 0L;
cpInfo.dstProfile = 0L;
cpInfo.flags = kColorPickerAppIsColorSyncAware | kColorPickerCanModifyPalette |
kColorPickerCanAnimatePalette;
// Place dialog
cpInfo.placeWhere = kCenterOnMainScreen;
if(p.h != -1 || p.v != -1) {
cpInfo.placeWhere = kAtSpecifiedOrigin;
cpInfo.dialogOrigin = p;
}
cpInfo.pickerType = 0L; // Use the default picker.
cpInfo.eventProc = 0L;
cpInfo.colorProc = 0L;
cpInfo.colorProcData = 0L;
memcpy(cpInfo.prompt, pstr, pstr[0]+1);
Boolean rval = FALSE;
{
QMacBlockingFunction block;
rval = (PickColor(&cpInfo) == noErr && cpInfo.newColorChosen);
}
if(rval) {
rval = TRUE;
if(!cpInfo.theColor.profile) {
rgbout.red = cpInfo.theColor.color.rgb.red;
rgbout.green = cpInfo.theColor.color.rgb.green;
rgbout.blue = cpInfo.theColor.color.rgb.blue;
} else {
qDebug("not sure how to handle..");
}
}
#endif
free((void *)pstr);
if(ok)
(*ok) = rval;
if(!rval)
return initial;
initial = qRgba(rgbout.red / 256, rgbout.green / 256,
rgbout.blue / 256, qAlpha(initial));
return initial;
}
bool QgsHttpRequestHandler::minMaxRange( const QgsColorBox& colorBox, int& redRange, int& greenRange, int& blueRange, int& alphaRange )
{
if ( colorBox.size() < 1 )
{
return false;
}
int rMin = INT_MAX;
int gMin = INT_MAX;
int bMin = INT_MAX;
int aMin = INT_MAX;
int rMax = INT_MIN;
int gMax = INT_MIN;
int bMax = INT_MIN;
int aMax = INT_MIN;
int currentRed = 0;
int currentGreen = 0;
int currentBlue = 0;
int currentAlpha = 0;
QgsColorBox::const_iterator colorBoxIt = colorBox.constBegin();
for ( ; colorBoxIt != colorBox.constEnd(); ++colorBoxIt )
{
currentRed = qRed( colorBoxIt->first );
if ( currentRed > rMax )
{
rMax = currentRed;
}
if ( currentRed < rMin )
{
rMin = currentRed;
}
currentGreen = qGreen( colorBoxIt->first );
if ( currentGreen > gMax )
{
gMax = currentGreen;
}
if ( currentGreen < gMin )
{
gMin = currentGreen;
}
currentBlue = qBlue( colorBoxIt->first );
if ( currentBlue > bMax )
{
bMax = currentBlue;
}
if ( currentBlue < bMin )
{
bMin = currentBlue;
}
currentAlpha = qAlpha( colorBoxIt->first );
if ( currentAlpha > aMax )
{
aMax = currentAlpha;
}
if ( currentAlpha < aMin )
{
aMin = currentAlpha;
}
}
redRange = rMax - rMin;
greenRange = gMax - gMin;
blueRange = bMax - bMin;
alphaRange = aMax - aMin;
return true;
}
QImage CompositeEffect::processImages(const QVector<QImage> &images, const KoFilterEffectRenderContext &context) const
{
int imageCount = images.count();
if (!imageCount)
return QImage();
QImage result = images[0];
if (images.count() != 2) {
return result;
}
if (m_operation == Arithmetic) {
const QRgb *src = (QRgb*)images[1].constBits();
QRgb *dst = (QRgb*)result.bits();
int w = result.width();
qreal sa, sr, sg, sb;
qreal da, dr, dg, db;
int pixel = 0;
// TODO: do we have to calculate with non-premuliplied colors here ???
QRect roi = context.filterRegion().toRect();
for (int row = roi.top(); row < roi.bottom(); ++row) {
for (int col = roi.left(); col < roi.right(); ++col) {
pixel = row * w + col;
const QRgb &s = src[pixel];
QRgb &d = dst[pixel];
sa = fromIntColor[qAlpha(s)];
sr = fromIntColor[qRed(s)];
sg = fromIntColor[qGreen(s)];
sb = fromIntColor[qBlue(s)];
da = fromIntColor[qAlpha(d)];
dr = fromIntColor[qRed(d)];
dg = fromIntColor[qGreen(d)];
db = fromIntColor[qBlue(d)];
da = m_k[0] * sa * da + m_k[1] * da + m_k[2] * sa + m_k[3];
dr = m_k[0] * sr * dr + m_k[1] * dr + m_k[2] * sr + m_k[3];
dg = m_k[0] * sg * dg + m_k[1] * dg + m_k[2] * sg + m_k[3];
db = m_k[0] * sb * db + m_k[1] * db + m_k[2] * sb + m_k[3];
da *= 255.0;
// set pre-multiplied color values on destination image
d = qRgba(static_cast<quint8>(qBound(qreal(0.0), dr * da, qreal(255.0))),
static_cast<quint8>(qBound(qreal(0.0), dg * da, qreal(255.0))),
static_cast<quint8>(qBound(qreal(0.0), db * da, qreal(255.0))),
static_cast<quint8>(qBound(qreal(0.0), da, qreal(255.0))));
}
}
} else {
QPainter painter(&result);
switch (m_operation) {
case CompositeOver:
painter.setCompositionMode(QPainter::CompositionMode_DestinationOver);
break;
case CompositeIn:
painter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
break;
case CompositeOut:
painter.setCompositionMode(QPainter::CompositionMode_DestinationOut);
break;
case CompositeAtop:
painter.setCompositionMode(QPainter::CompositionMode_DestinationAtop);
break;
case CompositeXor:
painter.setCompositionMode(QPainter::CompositionMode_Xor);
break;
default:
// no composition mode
break;
}
painter.drawImage(context.filterRegion(), images[1], context.filterRegion());
}
return result;
}
//===========================================================================//
// void ImageOperations::subsample(QImage image, QImage* ret, //
// bool resize = true) //
//===========================================================================//
// INPUTS: image: QImage to be sub-sampled by factor 2. //
// resize: flag to indicate whether the size of the image should //
// be decreased by factor 2 as part of sub-sampling or //
// pixel values duplicated to maintain the original size. //
// OUTPUTS: QImage: Sub-sampled image of either equal or half the original //
// size. //
// OPERATION: The average of a pixel and its right, lower and lower-right //
// neighbours is computed and used as value for the pixel(s) in //
// the sub-sampled image. //
//===========================================================================//
void ImageOperations::subsample( const QImage& qimg, QImage& qimgRet,
bool bResize)
{
int subs_w, subs_h;
if( bResize )
{ // Compute the
subs_w = int(qimg.width()/2); // size of the
subs_h = int(qimg.height()/2); // output image.
}
else
{
subs_w = qimg.width();
subs_h = qimg.height();
}
qimgRet.create(subs_w, subs_h, 32);
int col_r, col_g, col_b;
for (int y=0; y<qimg.height(); y+=2)
{ // Traverse image
for (int x=0; x<qimg.width(); x+=2)
{ // and compute
col_r = qRed(qimg.pixel(x,y)); // average of
col_g = qGreen(qimg.pixel(x,y)); // the pixel and
col_b = qBlue(qimg.pixel(x,y)); // its neighbours
int sum = 1; // to the right,
if (x < qimg.width()-1)
{ // the bottom as
col_r += qRed (qimg.pixel(x+1, y)); // well as the
col_g += qGreen(qimg.pixel(x+1,y)); // bottom-right.
col_b += qBlue (qimg.pixel(x+1,y)); // Consider image
sum++; // borders.
}
if (y < qimg.height()-1)
{
col_r += qRed (qimg.pixel(x,y+1));
col_g += qGreen(qimg.pixel(x,y+1));
col_b += qBlue (qimg.pixel(x,y+1));
sum++;
}
if ((x<qimg.width()-1) && (y<qimg.height()-1))
{
col_r += qRed (qimg.pixel(x+1, y+1));
col_g += qGreen(qimg.pixel(x+1, y+1));
col_b += qBlue (qimg.pixel(x+1, y+1));
sum++;
}
col_r /= sum;
col_g /= sum;
col_b /= sum;
if (bResize)
{ // Set the output
if ((int(x/2) < subs_w) && (int(y/2) < subs_h))
{ // image's pixels
qimgRet.setPixel(int(x/2), int(y/2), // to the computed
qRgb(col_r, col_g, col_b)); // values.
}
}
else
{ // In the case that
qimgRet.setPixel(x, y, qRgb(col_r, col_g, // the image is
col_b)); // not being re-
if (x < qimg.width()-1)
{ // sized, four
qimgRet.setPixel(x+1, y, qRgb(col_r, col_g, // pixels hold
col_b)); // the same value
} // (with the
if (y < qimg.height()-1)
{ // exception of
qimgRet.setPixel(x, y+1, qRgb(col_r, col_g, // the borders).
col_b));
}
if ((x<qimg.width()-1) && (y<qimg.height()-1))
{
qimgRet.setPixel(x+1, y+1, qRgb(col_r, col_g,
col_b));
}
}
}
}
}
void MeshRenderer :: renderToImage(cv::Mat4b& image, int flags)
{
ntk_assert(m_vertex_buffer_object.initialized,
"Renderer not initialized! Call setPose and setMesh.");
ntk::TimeCount tc_gl_current("make_current", 2);
m_pbuffer->makeCurrent();
tc_gl_current.stop();
ntk::TimeCount tc_gl_render("gl_render", 2);
if (flags & WIREFRAME)
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
VertexBufferObject& vbo = m_vertex_buffer_object;
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo.vertex_id);
if (vbo.has_texcoords)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, vbo.texture_id);
}
else
{
glDisable(GL_TEXTURE_2D);
}
if (vbo.has_texcoords)
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
if (vbo.has_color)
glEnableClientState(GL_COLOR_ARRAY);
else
glColor3f(1.0f,0.f,0.f);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, 0);
if (vbo.has_color)
glColorPointer(3, GL_UNSIGNED_BYTE, 0, ((char*) NULL) + vbo.color_offset);
if (vbo.has_texcoords)
glTexCoordPointer(2, GL_FLOAT, 0, ((char*) NULL) + vbo.texture_offset);
if (vbo.has_faces)
{
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, vbo.faces_id);
glNormal3f(0, 0, 1);
glDrawElements(GL_TRIANGLES, vbo.nb_faces*3, GL_UNSIGNED_INT, 0);
}
else
{
glDrawArrays(GL_POINTS,
0,
vbo.nb_vertices);
}
glDisableClientState(GL_VERTEX_ARRAY);
if (vbo.has_color)
glDisableClientState(GL_COLOR_ARRAY);
if (vbo.has_texcoords)
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// bind with 0, so, switch back to normal pointer operation
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
if (vbo.has_faces)
{
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
}
glFinish();
tc_gl_render.stop();
ntk::TimeCount tc_image("to_image", 2);
QImage qimage = m_pbuffer->toImage();
tc_image.stop();
ntk::TimeCount tc_depth_buffer("compute_depth_buffer", 2);
computeDepthBuffer();
tc_depth_buffer.stop();
ntk::TimeCount tc_convert("convert_to_cv", 2);
for (int r = 0; r < qimage.height(); ++r)
for (int c = 0; c < qimage.width(); ++c)
{
QRgb pixel = qimage.pixel(c,r);
Vec4b color (qBlue(pixel), qGreen(pixel), qRed(pixel), qAlpha(pixel));
m_color_buffer(r,c) = color;
float a = qAlpha(pixel)/255.f;
if (a > 0)
{
Vec4b old_color = image(r,c);
image(r,c) = Vec4b(old_color[0]*(1-a) + color[0]*a,
old_color[1]*(1-a) + color[1]*a,
old_color[2]*(1-a) + color[2]*a,
255);
}
}
tc_convert.stop();
}
void ImageOperations::colorCanny( const OpRGBImage& img,
OpGrayImage& imgRet,
float dThreshLow, float dThreshHigh,
float dSigma )
{
//printf("ImageOperations::colorCanny() ...\n");
QImage qimg = img.getQtImage();
int w = qimg.width();
int h = qimg.height();
//- create a YCC color-opponent image from the input image -//
OpGrayImage imgY ( w, h );
OpGrayImage imgC1( w, h );
OpGrayImage imgC2( w, h );
for (int y=0; y < h; y++)
{
for (int x=0; x < w; x++)
{
// img is the original QImage //
uint *p = (uint *) qimg.scanLine(y) + x;
//-- convert rgb to YCC --//
imgY(x,y) = (1.0/3.0)*(qRed(*p) + qGreen(*p) + qBlue(*p));
imgC1(x,y) = 2.0*(0.5*qRed(*p) - 0.5*qGreen(*p));
imgC2(x,y) = 2.0*(0.5*qRed(*p) + 0.5*qGreen(*p) - qBlue(*p));
}
}
//-- apply the filter --//
OpGrayImage imgDx( w, h );
OpGrayImage imgDy( w, h );
//-- fast gauss --//
OpGrayImage imgYDx( w, h );
OpGrayImage imgYDy( w, h );
imgY.opFastGaussDxDy( dSigma, imgYDx, imgYDy );
OpGrayImage imgC1Dx( w, h );
OpGrayImage imgC1Dy( w, h );
imgC1.opFastGaussDxDy( dSigma, imgC1Dx, imgC1Dy );
OpGrayImage imgC2Dx( w, h );
OpGrayImage imgC2Dy( w, h );
imgC2.opFastGaussDxDy( dSigma, imgC2Dx, imgC2Dy );
for (int y=0; y < h; y++)
{
for (int x=0; x < w; x++)
{
imgDx(x,y) = sqrt( imgYDx(x,y).value()*imgYDx(x,y).value() +
imgC1Dx(x,y).value()*imgC1Dx(x,y).value() +
imgC2Dx(x,y).value()*imgC2Dx(x,y).value() );
imgDy(x,y) = sqrt( imgYDy(x,y).value()*imgYDy(x,y).value() +
imgC1Dy(x,y).value()*imgC1Dy(x,y).value() +
imgC2Dy(x,y).value()*imgC2Dy(x,y).value() );
}
}
/*
//-- slow gauss --//
OpGrayImage imgYDx = imgY.opGaussDerivGx( m_dSigma );
OpGrayImage imgYDy = imgY.opGaussDerivGy( m_dSigma );
OpGrayImage imgC1Dx = imgC1.opGaussDerivGx( m_dSigma );
OpGrayImage imgC1Dy = imgC1.opGaussDerivGy( m_dSigma );
OpGrayImage imgC2Dx = imgC2.opGaussDerivGx( m_dSigma );
OpGrayImage imgC2Dy = imgC2.opGaussDerivGy( m_dSigma );
for (int y=0; y < m_img.height(); y++)
for (int x=0; x < m_img.width(); x++)
{
imgDx(x,y) = sqrt( imgYDx(x,y).value()*imgYDx(x,y).value() +
imgC1Dx(x,y).value()*imgC1Dx(x,y).value() +
imgC2Dx(x,y).value()*imgC2Dx(x,y).value() );
imgDy(x,y) = sqrt( imgYDy(x,y).value()*imgYDy(x,y).value() +
imgC1Dy(x,y).value()*imgC1Dy(x,y).value() +
imgC2Dy(x,y).value()*imgC2Dy(x,y).value() );
}
*/
//-- apply the Canny operator --//
OpGrayImage resultImg( w, h );
imgRet = resultImg;
imgRet = cannyEdgesDxDy( imgDx, imgDy, dThreshLow, dThreshHigh );
}
ccPointCloud* ccCalibratedImage::orthoRectifyAsCloud(CCLib::GenericIndexedCloud* keypoints3D, std::vector<KeyPoint>& keypointsImage) const
{
double a[3],b[3],c[3];
if (!computeOrthoRectificationParams(keypoints3D,keypointsImage,a,b,c))
return 0;
const double& a0 = a[0];
const double& a1 = a[1];
const double& a2 = a[2];
const double& b0 = b[0];
const double& b1 = b[1];
const double& b2 = b[2];
//const double& c0 = c[0];
const double& c1 = c[1];
const double& c2 = c[2];
PointCoordinateType defaultZ = 0;
ccPointCloud* proj = new ccPointCloud(getName()+QString(".ortho-rectified"));
if (!proj->reserve(m_width*m_height))
{
delete proj;
return 0;
}
if (!proj->reserveTheRGBTable())
{
delete proj;
return 0;
}
proj->showColors(true);
unsigned realCount = 0;
//ortho rectification
{
for (unsigned pi = 0; pi<m_width; ++pi)
{
double xi = static_cast<PointCoordinateType>(pi) - 0.5*static_cast<PointCoordinateType>(m_width);
for (unsigned pj = 0; pj<m_height; ++pj)
{
double yi = static_cast<PointCoordinateType>(pj) - 0.5*static_cast<PointCoordinateType>(m_height);
double qi = 1.0 + c1*xi + c2*yi;
CCVector3 P(static_cast<PointCoordinateType>((a0+a1*xi+a2*yi)/qi),
static_cast<PointCoordinateType>((b0+b1*xi+b2*yi)/qi),
defaultZ);
//and color?
QRgb rgb = m_image.pixel(pi,pj);
int r = qRed(rgb);
int g = qGreen(rgb);
int b = qBlue(rgb);
if (r+g+b > 0)
{
//add point
proj->addPoint(P);
//and color
colorType C[3] = { static_cast<colorType>(r),
static_cast<colorType>(g),
static_cast<colorType>(b) };
proj->addRGBColor(C);
++realCount;
}
}
}
}
if (realCount == 0)
{
delete proj;
proj = 0;
}
else
{
proj->resize(realCount);
}
return proj;
}
