// Compare images:
QBitArray OKFilter::imageToVect(const QString &inputImage)
{
// Check src file:
QFileInfo fi(inputImage);
// Check files:
if (!fi.exists())
return QBitArray();
QImage img(inputImage);
if (img.isNull())
return QBitArray();
QBitArray result;
result.resize(img.width()*img.height());
int c = 0;
for (int j=0; j<img.height(); j++)
for (int i=0; i<img.width(); i++)
{
QRgb color = img.pixel(i, j);
int alpha = qAlpha(color);
result[c++] = (alpha>0);
}
return result;
}
void KeyWidget::map(const KeyMap& newMap){
keyMap = newMap;
selection = QBitArray(keyMap.count());
newSelection = QBitArray(keyMap.count());
animation = QBitArray(keyMap.count());
setFixedSize((keyMap.width() + KEY_SIZE) * 2.3, (keyMap.height() + KEY_SIZE) * 2.3);
update();
}
BuddyMonitor::BuddyMonitor(const QSharedPointer<BuddyPolicy> &bp, int min_anon) :
m_bp(bp),
m_used_nyms(m_bp->GetCount(), false),
m_min_anon(min_anon)
{
Q_ASSERT(m_bp);
for(int idx = 0; idx < m_bp->GetCount(); idx++) {
m_member_set.append(QBitArray(m_bp->GetCount(), true));
m_nym_set.append(QBitArray(m_bp->GetCount(), true));
}
}
void ChanMappingController::saveSettings()
{
QSettings settings(SETTINGS_DOMAIN, SETTINGS_APP);
settings.beginGroup("ChanMappingController2");
for (int i = 0; i < (int)DAQ::N_Modes; ++i) {
settings.setValue(QString("terseString_%1").arg(i), mapping[i].toTerseString(QBitArray(mapping[i].size(),true)));
settings.setValue(QString("terseString2_%1").arg(i), mapping2[i].toTerseString(QBitArray(mapping2[i].size(),true)));
}
settings.setValue("lastCMDlgDir", lastDir);
}
void KisConvolutionFilter::process(KisConstProcessingInformation srcInfo,
KisProcessingInformation dstInfo,
const QSize& size,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater
) const
{
Q_UNUSED(config);
const KisPaintDeviceSP src = srcInfo.paintDevice();
KisPaintDeviceSP dst = dstInfo.paintDevice();
QPoint dstTopLeft = dstInfo.topLeft();
QPoint srcTopLeft = srcInfo.topLeft();
Q_ASSERT(src != 0);
Q_ASSERT(dst != 0);
KisConvolutionPainter painter(dst, dstInfo.selection());
QBitArray channelFlags;
if (config) {
channelFlags = config->channelFlags();
}
if (channelFlags.isEmpty() || !config) {
channelFlags = QBitArray(src->colorSpace()->channelCount(), true);
}
// disable alpha channel
channelFlags.clearBit(1);
painter.setChannelFlags(channelFlags);
painter.setProgress(progressUpdater);
painter.applyMatrix(m_matrix, src, srcTopLeft, dstTopLeft, size, BORDER_REPEAT);
}
void LayerStack::resize(int top, int right, int bottom, int left)
{
int newtop = -top;
int newleft = -left;
int newright = _width + right;
int newbottom = _height + bottom;
if(newtop >= newbottom || newleft >= newright) {
qWarning() << "Invalid resize: borders reversed";
return;
}
_width = newright - newleft;
_height = newbottom - newtop;
_xtiles = Tile::roundTiles(_width);
_ytiles = Tile::roundTiles(_height);
_cache = QPixmap(_width, _height);
_dirtytiles = QBitArray(_xtiles*_ytiles, true);
foreach(Layer *l, _layers)
l->resize(top, right, bottom, left);
if(left || top) {
// Update annotation positions
QPoint offset(left, top);
foreach(Annotation *a, _annotations) {
a->setRect(a->rect().translated(offset));
emit annotationChanged(a->id());
}
void LayerStack::resize(int top, int right, int bottom, int left)
{
const QSize oldsize(_width, _height);
int newtop = -top;
int newleft = -left;
int newright = _width + right;
int newbottom = _height + bottom;
if(newtop >= newbottom || newleft >= newright) {
qWarning() << "Invalid resize: borders reversed";
return;
}
_width = newright - newleft;
_height = newbottom - newtop;
_xtiles = Tile::roundTiles(_width);
_ytiles = Tile::roundTiles(_height);
_dirtytiles = QBitArray(_xtiles*_ytiles, true);
for(Layer *l : m_layers)
l->resize(top, right, bottom, left);
if(left || top) {
// Update annotation positions
QPoint offset(left, top);
Q_FOREACH(const Annotation &a, m_annotations->getAnnotations()) {
m_annotations->reshapeAnnotation(a.id, a.rect.translated(offset));
}
}
FlagArray::FlagArray(DFInstance *df, VIRTADDR base_addr)
{
m_df = df;
//get the array from the pointer
VIRTADDR flags_addr = m_df->read_addr(base_addr);
//size of the byte array
quint32 size_in_bytes = m_df->read_addr(base_addr + 0x4);
m_flags = QBitArray(size_in_bytes * 8);
if(size_in_bytes > 1000){
LOGW << "aborting reading flags, size too large" << size_in_bytes;
return;
}
BYTE b;
int position;
for(uint i = 0; i < size_in_bytes; i++){
position = 7;
b = m_df->read_byte(flags_addr);
if(b > 0){
for(int t=128; t>0; t = t/2){
if(b & t)
m_flags.setBit(i*8 + position, true);
position--;
}
}
flags_addr += 0x1;
}
}
uint32_t OsmAnd::RoutingProfile::registerTagValueAttribute( const QString& tag, const QString& value )
{
auto key = tag + "$" + value;
auto itId = _universalRules.find(key);
if(itId != _universalRules.end())
return *itId;
auto id = _universalRules.size();
_universalRulesKeysById.push_back(key);
_universalRules.insert(key, id);
auto itTagRuleMask = _tagRuleMask.find(tag);
if(itTagRuleMask == _tagRuleMask.end())
itTagRuleMask = _tagRuleMask.insert(tag, QBitArray());
if(itTagRuleMask->size() <= id)
{
assert(id < std::numeric_limits<int>::max());
itTagRuleMask->resize(id + 1);
}
itTagRuleMask->setBit(id);
return id;
}
void KisConvolutionFilter::process(KisPaintDeviceSP device,
const QRect& applyRect,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater) const
{
Q_UNUSED(config);
QPoint srcTopLeft = applyRect.topLeft();
Q_ASSERT(device != 0);
KisConvolutionPainter painter(device);
QBitArray channelFlags;
if (config) {
channelFlags = config->channelFlags();
}
if (channelFlags.isEmpty() || !config) {
channelFlags = QBitArray(device->colorSpace()->channelCount(), true);
}
painter.setChannelFlags(channelFlags);
painter.setProgress(progressUpdater);
painter.applyMatrix(m_matrix, device, srcTopLeft, srcTopLeft, applyRect.size(), BORDER_REPEAT);
}
void LayerStackObserver::canvasResized(int xoffset, int yoffset, const QSize &oldsize)
{
Q_ASSERT(m_layerstack);
m_dirtytiles = QBitArray(m_layerstack->m_xtiles * m_layerstack->m_ytiles, true);
m_dirtyrect = QRect(QPoint(), m_layerstack->size());
resized(xoffset, yoffset, oldsize);
}
void applyGaussian(KisPixelSelectionSP selection,
const QRect &applyRect,
qreal radius)
{
KisGaussianKernel::applyGaussian(selection, applyRect,
radius, radius,
QBitArray(), 0);
}
void KeyWidget::map(const KeyMap& newMap){
keyMap = newMap;
selection = QBitArray(keyMap.count());
newSelection = QBitArray(keyMap.count());
animation = QBitArray(keyMap.count());
int width, height;
if(keyMap.isMouse()){
width = (keyMap.width() + KEY_SIZE) * 2.6;
height = (keyMap.height() + KEY_SIZE) * 2.6;
} else {
width = (keyMap.width() + KEY_SIZE) * 2.3;
height = (keyMap.height() + KEY_SIZE) * 2.3;
}
if(width < 500)
width = 500;
setFixedSize(width, height);
update();
}
Domain::Domain(block *parentBlock)
{
this->parentPosBlock = parentBlock;
mySettings = Settings::instance();
myExamples = Examples::instance();
for(unsigned int i = 0; i < myExamples->getAllExamples()->size(); ++i)
{
termOccurences4Examples.push_back(QBitArray());
domainMap.push_back(QMultiHash<int, int>());
}
}
/**
* If not already initialized, this is called automatically when the
* first layer is added.
* @param size the size of the layers (each layer must be this big)
*/
void LayerStack::init(const QSize& size)
{
Q_ASSERT(!size.isEmpty());
_width = size.width();
_height = size.height();
_xtiles = _width / Tile::SIZE + ((_width % Tile::SIZE)>0);
_ytiles = _height / Tile::SIZE + ((_height % Tile::SIZE)>0);
_cache = QPixmap(size);
_dirtytiles = QBitArray(_xtiles*_ytiles, true);
emit resized();
}
foreach(PainterInfo *info, m_painterInfos) {
KisPainter *painter = info->painter;
painter->begin(targetDevice, !hasIndirectPainting ? selection : 0);
m_resources->setupPainter(painter);
if(hasIndirectPainting) {
painter->setCompositeOp(targetDevice->colorSpace()->compositeOp(indirectPaintingCompositeOp));
painter->setOpacity(OPACITY_OPAQUE_U8);
painter->setChannelFlags(QBitArray());
}
}
void KisBlurFilter::processImpl(KisPaintDeviceSP device,
const QRect& rect,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater
) const
{
QPoint srcTopLeft = rect.topLeft();
Q_ASSERT(device != 0);
if (!config) config = new KisFilterConfiguration(id().id(), 1);
QVariant value;
int shape = (config->getProperty("shape", value)) ? value.toInt() : 0;
uint halfWidth = (config->getProperty("halfWidth", value)) ? value.toUInt() : 5;
uint width = 2 * halfWidth + 1;
uint halfHeight = (config->getProperty("halfHeight", value)) ? value.toUInt() : 5;
uint height = 2 * halfHeight + 1;
int rotate = (config->getProperty("rotate", value)) ? value.toInt() : 0;
int strength = 100 - (config->getProperty("strength", value) ? value.toUInt() : 0);
int hFade = (halfWidth * strength) / 100;
int vFade = (halfHeight * strength) / 100;
KisMaskGenerator* kas;
dbgKrita << width << "" << height << "" << hFade << "" << vFade;
switch (shape) {
case 1:
kas = new KisRectangleMaskGenerator(width, width / height , hFade, vFade, 2);
break;
case 0:
default:
kas = new KisCircleMaskGenerator(width, width / height, hFade, vFade, 2);
break;
}
QBitArray channelFlags;
if (config) {
channelFlags = config->channelFlags();
}
if (channelFlags.isEmpty() || !config) {
channelFlags = QBitArray(device->colorSpace()->channelCount(), true);
}
KisConvolutionKernelSP kernel = KisConvolutionKernel::fromMaskGenerator(kas, rotate * M_PI / 180.0);
delete kas;
KisConvolutionPainter painter(device);
painter.setChannelFlags(channelFlags);
painter.setProgress(progressUpdater);
painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}
void KisLsOverlayFilter::applyOverlay(KisPaintDeviceSP srcDevice,
KisMultipleProjection *dst,
const QRect &applyRect,
const psd_layer_effects_overlay_base *config,
KisLayerStyleFilterEnvironment *env) const
{
if (applyRect.isEmpty()) return;
KisPaintDeviceSP tempDevice = new KisPaintDevice(srcDevice->colorSpace());
{
// Create overlay device
KisPaintDeviceSP fillDevice = new KisPaintDevice(srcDevice->colorSpace());
KisLsUtils::fillOverlayDevice(fillDevice, applyRect, config, env);
KisPainter gc(tempDevice);
gc.setCompositeOp(COMPOSITE_OVER);
gc.bitBlt(applyRect.topLeft(), srcDevice, applyRect);
QBitArray channelFlags = srcDevice->colorSpace()->channelFlags(true, false);
gc.setChannelFlags(channelFlags);
gc.bitBlt(applyRect.topLeft(), fillDevice, applyRect);
gc.end();
}
{
// Paint over destination
const QString compositeOp = config->blendMode();
const quint8 opacityU8 = 255.0 / 100.0 * config->opacity();
KisPaintDeviceSP dstDevice = dst->getProjection(KisMultipleProjection::defaultProjectionId(), compositeOp, srcDevice);
KisPainter gc(dstDevice);
gc.setCompositeOp(COMPOSITE_OVER);
env->setupFinalPainter(&gc, opacityU8, QBitArray());
gc.bitBlt(applyRect.topLeft(), tempDevice, applyRect);
gc.end();
}
}
void KisImagePyramid::setChannelFlags(const QBitArray &channelFlags)
{
m_channelFlags = channelFlags;
int selectedChannels = 0;
const KoColorSpace *projectionCs = m_originalImage->projection()->colorSpace();
QList<KoChannelInfo*> channelInfo = projectionCs->channels();
if (channelInfo.size() != m_channelFlags.size()) {
m_channelFlags = QBitArray();
}
for (int i = 0; i < m_channelFlags.size(); ++i) {
if (m_channelFlags.testBit(i) && channelInfo[i]->channelType() == KoChannelInfo::COLOR) {
selectedChannels++;
m_selectedChannelIndex = i;
}
}
m_allChannelsSelected = (selectedChannels == m_channelFlags.size());
m_onlyOneChannelSelected = (selectedChannels == 1);
}
QList<HighlightSettingsEntry> HighlightSettings::loadSettings(QString group) {
QMutexLocker locker(&m_mutex);
QList<HighlightSettingsEntry> settingsList = QList<HighlightSettingsEntry>();
int size = settings->beginReadArray(group);
for (int i = 0; i < size; i++) {
settings->setArrayIndex(i);
settingsList.append(HighlightSettingsEntry((const int&)i,
(const QString&)settings->value("value", "").toString(),
(const QString&)settings->value("group", "").toString(),
(const QColor&)settings->value("color", QColor()).value<QColor>(),
(const bool&)settings->value("alert", false).toBool(),
(const QString&)settings->value("alertValue", "").toString(),
(const bool&)settings->value("timer", false).toBool(),
(const int&)settings->value("timerValue", 0).toInt(),
(const QString&)settings->value("timerAction", "").toString(),
(const QBitArray&)settings->value("options", QBitArray(3)).value<QBitArray>()));
}
settings->endArray();
return settingsList;
}
void Resume(int idx)
{
m_resumed = true;
_state->slots_open = QBitArray(GetGroup().Count(), false);
_state->slots_open[idx] = true;
_state->blogdrop_clients[idx]->GetParameters()->SetNElements(5);
if(IsServer()) {
_server_state->blogdrop_servers[idx]->GetParameters()->SetNElements(5);
}
if(idx == _state->my_idx) {
_state->blogdrop_author->GetParameters()->SetNElements(5);
}
if(IsServer()) {
ServerTestInteractive();
} else {
SubmitClientCiphertext();
}
}
QBitArray KisChannelFlagsWidget::channelFlags() const
{
bool allTrue = true;
QBitArray ba(m_channelChecks.size());
for (int i = 0; i < m_channelChecks.size(); ++i) {
bool flag = m_channelChecks.at(i)->isChecked();
if (!flag) allTrue = false;
ba.setBit(i, flag);
dbgUI << " channel " << i << " is " << flag << ", allTrue = " << allTrue << ", so ba.testBit("<<i<<")" << " is " << ba.testBit(i);
}
if (allTrue)
return QBitArray();
else {
QBitArray result = m_colorSpace->setChannelFlagsToPixelOrder(ba);
for (int i = 0; i < result.size(); ++i) {
dbgUI << "On conversion to the pixel order, flag " << i << " is " << result.testBit(i);
}
return result;
}
}
/**
* Inicjalizuje mapę wartości domyślnych.
*/
void SimpleBirdSettings::initDefaults()
{
defaults["firstRun"] = true;
defaults["general/defaultDirectory"] = QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
defaults["general/verbosity"] = 1;
defaults["sound/frameLength"] = 20;
defaults["sound/frameOverlap"] = 0.66;
defaults["sound/windowType"] = "Rectangular";
defaults["sound/windowTypeIndex"] = 0; // rectangular
defaults["sound/preemphasis"] = 0.9375;
defaults["sound/paramsPerFrame"] = 10;
defaults["sound/enabledFilters"] = QBitArray(Aquila::MELFILTERS, true);
defaults["dtw/distanceType"] = 0; // euclidean
defaults["dtw/normalizationType"] = 1; // diagonal
defaults["dtw/passType"] = 0; // neighbors
defaults["recognizing/minPatternSize"] = 0.6; // 60%
defaults["recognizing/maxPatternSize"] = 1.4; // 140%
defaults["charts/addOverlay"] = true;
defaults["charts/defaultImageFormat"] = ".png";
defaults["charts/drawDtwAccumulated"] = false;
defaults["appearance/useStylesheet"] = true;
defaults["appearance/stylesheet"] = "default";
defaults["appearance/waveformColor"] = QColor(Qt::red);
}
void tst_QBitArray::invertOnNull() const
{
QBitArray a;
QCOMPARE(a = ~a, QBitArray());
}
void KisMotionBlurFilter::process(KisPaintDeviceSP device,
const QRect& rect,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater
) const
{
QPoint srcTopLeft = rect.topLeft();
Q_ASSERT(device != 0);
if (!config) config = new KisFilterConfiguration(id().id(), 1);
QVariant value;
config->getProperty("blurAngle", value);
uint blurAngle = value.toUInt();
config->getProperty("blurLength", value);
uint blurLength = value.toUInt();
if (blurLength == 0)
return;
QBitArray channelFlags;
if (config) {
channelFlags = config->channelFlags();
}
if (channelFlags.isEmpty() || !config) {
channelFlags = QBitArray(device->colorSpace()->channelCount(), true);
}
// convert angle to radians
qreal angleRadians = blurAngle / 360.0 * 2 * M_PI;
// construct image
qreal halfWidth = blurLength / 2.0 * cos(angleRadians);
qreal halfHeight = blurLength / 2.0 * sin(angleRadians);
int kernelWidth = ceil(fabs(halfWidth)) * 2;
int kernelHeight = ceil(fabs(halfHeight)) * 2;
// check for zero dimensions (vertical/horizontal motion vectors)
kernelWidth = (kernelWidth == 0) ? 1 : kernelWidth;
kernelHeight = (kernelHeight == 0) ? 1 : kernelHeight;
QImage kernelRepresentation(kernelWidth, kernelHeight, QImage::Format_RGB32);
kernelRepresentation.fill(0);
QPainter imagePainter(&kernelRepresentation);
imagePainter.setRenderHint(QPainter::Antialiasing);
imagePainter.setPen(QPen(QColor::fromRgb(255, 255, 255), 1.0));
imagePainter.drawLine(QPointF(kernelWidth / 2 - halfWidth, kernelHeight / 2 + halfHeight),
QPointF(kernelWidth / 2 + halfWidth, kernelHeight / 2 - halfHeight));
// construct kernel from image
Matrix<qreal, Dynamic, Dynamic> motionBlurKernel(kernelHeight, kernelWidth);
for (int j = 0; j < kernelHeight; ++j) {
for (int i = 0; i < kernelWidth; ++i) {
motionBlurKernel(j, i) = qRed(kernelRepresentation.pixel(i, j));
}
}
// apply convolution
KisConvolutionPainter painter(device);
painter.setChannelFlags(channelFlags);
painter.setProgress(progressUpdater);
KisConvolutionKernelSP kernel = KisConvolutionKernel::fromMatrix(motionBlurKernel, 0, motionBlurKernel.sum());
painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}
void TestEngine::init()
{
QString dsn("TestEngine");
// QVariant::Invalid
// QVariant::BitArray
setData(dsn, "QBitArray", QVariant(QBitArray(97, false)));
// QVariant::Bitmap
setData(dsn, "QBitmap", QVariant(QBitmap(12, 57)));
// QVariant::Bool
setData(dsn, "bool", QVariant((bool)true));
// QVariant::Brush
setData(dsn, "QBrush", QVariant(QBrush(Qt::SolidPattern)));
// QVariant::ByteArray
QByteArray byteArray;
for (int i=0; i<256; ++i) {
byteArray.append(i);
}
setData(dsn, "QByteArray1", QVariant(byteArray));
setData(dsn, "QByteArray2", QVariant(QByteArray("KDE4")));
// QVariant::Char
setData(dsn, "QChar", QVariant(QChar(0x4B)));
// QVariant::Color
setData(dsn, "QColor", QVariant(QColor("#031337")));
// QVariant::Cursor
setData(dsn, "QCursor", QVariant(QCursor(Qt::ArrowCursor)));
// QVariant::Date
setData(dsn, "QDate", QVariant(QDate(2008, 1, 11)));
// QVariant::DateTime
setData(dsn, "QDateTime", QVariant(QDateTime(QDate(2008, 1, 11), QTime(12, 34, 56))));
// QVariant::Double
setData(dsn, "double", QVariant((double)12.34));
// QVariant::Font
setData(dsn, "QFont", QVariant(QFont()));
// QVariant::Icon
setData(dsn, "QIcon", QVariant(QIcon(QPixmap(12, 34))));
// QVariant::Image
setData(dsn, "QImage", QVariant(QImage(56, 78, QImage::Format_Mono)));
// QVariant::Int
setData(dsn, "int", QVariant((int)-4321));
// QVariant::KeySequence (???)
// QVariant::Line
setData(dsn, "QLine", QVariant(QLine(12, 34, 56, 78)));
// QVariant::LineF
setData(dsn, "QLineF", QVariant(QLineF(1.2, 3.4, 5.6, 7.8)));
// QVariant::List
QList<QVariant> list;
list << QString("KDE4") << QBrush() << QPen();
setData(dsn, "QList", QVariant(list));
// QVariant::Locale
setData(dsn, "QLocale", QVariant(QLocale("fr_FR")));
// QVariant::LongLong
setData(dsn, "qlonglong", QVariant((qlonglong)-4321));
// QVariant::Map
QMap<QString, QVariant> map;
for (int i=0; i<123; ++i) {
QString key = QString("key%1").arg(i);
QString val = QString("value%1").arg(i);
map[key] = val;
}
setData(dsn, "QMap", QVariant(map));
// QVariant::Matrix
setData(dsn, "QMatrix", QVariant(QMatrix()));
// QVariant::Transform
setData(dsn, "QTransform", QVariant(QTransform()));
// QVariant::Palette
setData(dsn, "QPalette", QVariant(QPalette()));
// QVariant::Pen
setData(dsn, "QPen", QVariant(QPen(Qt::SolidLine)));
// QVariant::Pixmap
setData(dsn, "QPixmap", QVariant(QPixmap(12, 34)));
// QVariant::Point
setData(dsn, "QPoint", QVariant(QPoint(12, 34)));
// QVariant::PointArray (obsoloted in Qt4, see QPolygon)
// QVariant::PointF
setData(dsn, "QPointF", QVariant(QPointF(12.34, 56.78)));
// QVariant::Polygon
setData(dsn, "QPolygon", QVariant(QPolygon(42)));
// QVariant::Rect
setData(dsn, "QRect", QVariant(QRect(12, 34, 56, 78)));
// QVariant::RectF
setData(dsn, "QRectF", QVariant(QRectF(1.2, 3.4, 5.6, 7.8)));
// QVariant::RegExp
setData(dsn, "QRegExp", QVariant(QRegExp("^KDE4$")));
// QVariant::Region
setData(dsn, "QRegion", QVariant(QRegion(10, 20, 30, 40)));
// QVariant::Size
setData(dsn, "QSize", QVariant(QSize(12, 34)));
// QVariant::SizeF
setData(dsn, "QSizeF", QVariant(QSizeF(12.34, 56.78)));
// QVariant::SizePolicy
setData(dsn, "QSizePolicy", QVariant(QSizePolicy()));
// QVariant::String
setData(dsn, "QString", QVariant(QString("KDE4 ROCKS!")));
// QVariant::StringList
QStringList stringList;
stringList << "K" << "D" << "E" << "4";
setData(dsn, "QStringList", QVariant(stringList));
// QVariant::TextFormat
setData(dsn, "QTextFormat", QVariant(QTextFormat()));
// QVariant::TextLength
setData(dsn, "QTextLength", QVariant(QTextLength()));
// QVariant::Time
setData(dsn, "QTime", QVariant(QTime(12, 34, 56)));
// QVariant::UInt
setData(dsn, "uint", QVariant((uint)4321));
// QVariant::ULongLong
setData(dsn, "qulonglong", QVariant((qulonglong)4321));
// QVariant::Url
setData(dsn, "QUrl", QVariant(QUrl("http://*****:*****@example.com:80/test.php?param1=foo¶m2=bar")));
// QVariant::UserType
MyUserType userType;
QVariant v;
v.setValue(userType);
setData(dsn, "UserType", v);
}; // init()
FlagArray::FlagArray(){
m_df = 0;
m_flags = QBitArray(0);
}
void KisImagePyramid::retrieveImageData(const QRect &rect)
{
// XXX: use QThreadStorage to cache the two patches (512x512) of pixels. Note
// that when we do that, we need to reset that cache when the projection's
// colorspace changes.
const KoColorSpace *projectionCs = m_originalImage->projection()->colorSpace();
KisPaintDeviceSP originalProjection = m_originalImage->projection();
quint32 numPixels = rect.width() * rect.height();
QScopedArrayPointer<quint8> originalBytes(
new quint8[originalProjection->colorSpace()->pixelSize() * numPixels]);
originalProjection->readBytes(originalBytes.data(), rect);
if (m_displayFilter &&
m_useOcio &&
projectionCs->colorModelId() == RGBAColorModelID) {
#ifdef HAVE_OCIO
const KoColorProfile *destinationProfile =
m_displayFilter->useInternalColorManagement() ?
m_monitorProfile : projectionCs->profile();
const KoColorSpace *floatCs =
KoColorSpaceRegistry::instance()->colorSpace(
RGBAColorModelID.id(),
Float32BitsColorDepthID.id(),
destinationProfile);
const KoColorSpace *modifiedMonitorCs =
KoColorSpaceRegistry::instance()->colorSpace(
RGBAColorModelID.id(),
Integer8BitsColorDepthID.id(),
destinationProfile);
if (projectionCs->colorDepthId() == Float32BitsColorDepthID) {
m_displayFilter->filter(originalBytes.data(), numPixels);
} else {
QScopedArrayPointer<quint8> dst(new quint8[floatCs->pixelSize() * numPixels]);
projectionCs->convertPixelsTo(originalBytes.data(), dst.data(), floatCs, numPixels, KoColorConversionTransformation::InternalRenderingIntent, KoColorConversionTransformation::InternalConversionFlags);
m_displayFilter->filter(dst.data(), numPixels);
originalBytes.swap(dst);
}
{
QScopedArrayPointer<quint8> dst(new quint8[modifiedMonitorCs->pixelSize() * numPixels]);
floatCs->convertPixelsTo(originalBytes.data(), dst.data(), modifiedMonitorCs, numPixels, KoColorConversionTransformation::InternalRenderingIntent, KoColorConversionTransformation::InternalConversionFlags);
originalBytes.swap(dst);
}
#endif
}
else {
QList<KoChannelInfo*> channelInfo = projectionCs->channels();
if (!m_channelFlags.size() == channelInfo.size()) {
setChannelFlags(QBitArray());
}
if (!m_channelFlags.isEmpty() && !m_allChannelsSelected) {
QScopedArrayPointer<quint8> dst(new quint8[projectionCs->pixelSize() * numPixels]);
int channelSize = channelInfo[m_selectedChannelIndex]->size();
int pixelSize = projectionCs->pixelSize();
KisConfig cfg;
if (m_onlyOneChannelSelected && !cfg.showSingleChannelAsColor()) {
int selectedChannelPos = channelInfo[m_selectedChannelIndex]->pos();
for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
for (uint channelIndex = 0; channelIndex < projectionCs->channelCount(); ++channelIndex) {
if (channelInfo[channelIndex]->channelType() == KoChannelInfo::COLOR) {
memcpy(dst.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
originalBytes.data() + (pixelIndex * pixelSize) + selectedChannelPos,
channelSize);
}
else if (channelInfo[channelIndex]->channelType() == KoChannelInfo::ALPHA) {
memcpy(dst.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
originalBytes.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
channelSize);
}
}
}
}
else {
for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
for (uint channelIndex = 0; channelIndex < projectionCs->channelCount(); ++channelIndex) {
if (m_channelFlags.testBit(channelIndex)) {
memcpy(dst.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
originalBytes.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
channelSize);
}
else {
memset(dst.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize), 0, channelSize);
}
}
}
}
originalBytes.swap(dst);
}
QScopedArrayPointer<quint8> dst(new quint8[m_monitorColorSpace->pixelSize() * numPixels]);
projectionCs->convertPixelsTo(originalBytes.data(), dst.data(), m_monitorColorSpace, numPixels, m_renderingIntent, m_conversionFlags);
originalBytes.swap(dst);
}
m_pyramid[ORIGINAL_INDEX]->writeBytes(originalBytes.data(), rect);
}
/*! \internal
If \a confirm is true, all edit operations (inserts, updates and
deletes) will be confirmed by the user. If \a confirm is false (the
default), all edits are posted to the database immediately.
*/
void Q3DataManager::setConfirmEdits(bool confirm)
{
d->confEdits = QBitArray(d->confEdits.size(), confirm);
}
void KisGaussianBlurFilter::process(KisPaintDeviceSP device,
const QRect& rect,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater
) const
{
QPoint srcTopLeft = rect.topLeft();
Q_ASSERT(device != 0);
if (!config) config = new KisFilterConfiguration(id().id(), 1);
QVariant value;
config->getProperty("horizRadius", value);
uint horizontalRadius = value.toUInt();
config->getProperty("vertRadius", value);
uint verticalRadius = value.toUInt();
QBitArray channelFlags;
if (config) {
channelFlags = config->channelFlags();
}
if (channelFlags.isEmpty() || !config) {
channelFlags = QBitArray(device->colorSpace()->channelCount(), true);
}
// compute horizontal kernel
uint horizKernelSize = horizontalRadius * 2 + 1;
Matrix<qreal, Dynamic, Dynamic> horizGaussian(1, horizKernelSize);
qreal horizSigma = horizontalRadius;
const qreal horizMultiplicand = 1 / (2 * M_PI * horizSigma * horizSigma);
const qreal horizExponentMultiplicand = 1 / (2 * horizSigma * horizSigma);
for (uint x = 0; x < horizKernelSize; x++)
{
uint xDistance = qAbs((int)horizontalRadius - (int)x);
horizGaussian(0, x) = horizMultiplicand * exp( -(qreal)((xDistance * xDistance) + (horizontalRadius * horizontalRadius)) * horizExponentMultiplicand );
}
// compute vertical kernel
uint verticalKernelSize = verticalRadius * 2 + 1;
Matrix<qreal, Dynamic, Dynamic> verticalGaussian(verticalKernelSize, 1);
qreal verticalSigma = verticalRadius;
const qreal verticalMultiplicand = 1 / (2 * M_PI * verticalSigma * verticalSigma);
const qreal verticalExponentMultiplicand = 1 / (2 * verticalSigma * verticalSigma);
for (uint y = 0; y < verticalKernelSize; y++)
{
uint yDistance = qAbs((int)verticalRadius - (int)y);
verticalGaussian(y, 0) = verticalMultiplicand * exp( -(qreal)((yDistance * yDistance) + (verticalRadius * verticalRadius)) * verticalExponentMultiplicand );
}
if ( (horizontalRadius > 0) && (verticalRadius > 0) )
{
KisPaintDeviceSP interm = new KisPaintDevice(device->colorSpace());
KisConvolutionKernelSP kernelHoriz = KisConvolutionKernel::fromMatrix(horizGaussian, 0, horizGaussian.sum());
KisConvolutionKernelSP kernelVertical = KisConvolutionKernel::fromMatrix(verticalGaussian, 0, verticalGaussian.sum());
KisConvolutionPainter horizPainter(interm);
horizPainter.setChannelFlags(channelFlags);
horizPainter.setProgress(progressUpdater);
horizPainter.applyMatrix(kernelHoriz, device,
srcTopLeft - QPoint(0, verticalRadius),
srcTopLeft - QPoint(0, verticalRadius),
rect.size() + QSize(0, 2 * verticalRadius), BORDER_REPEAT);
KisConvolutionPainter verticalPainter(device);
verticalPainter.setChannelFlags(channelFlags);
verticalPainter.setProgress(progressUpdater);
verticalPainter.applyMatrix(kernelVertical, interm, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}
else
{
if (horizontalRadius > 0)
{
KisConvolutionPainter painter(device);
painter.setChannelFlags(channelFlags);
painter.setProgress(progressUpdater);
KisConvolutionKernelSP kernelHoriz = KisConvolutionKernel::fromMatrix(horizGaussian, 0, horizGaussian.sum());
painter.applyMatrix(kernelHoriz, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}
if (verticalRadius > 0)
{
KisConvolutionPainter painter(device);
painter.setChannelFlags(channelFlags);
painter.setProgress(progressUpdater);
KisConvolutionKernelSP kernelVertical = KisConvolutionKernel::fromMatrix(verticalGaussian, 0, verticalGaussian.sum());
painter.applyMatrix(kernelVertical, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}
}
}
