void IndexColorPalette::insertShades(KoColor koclrA, KoColor koclrB, int shades)
{
koclrA.convertTo(KoColorSpaceRegistry::instance()->lab16());
koclrB.convertTo(KoColorSpaceRegistry::instance()->lab16());
LabColor clrA = *(reinterpret_cast<LabColor*>(koclrA.data()));
LabColor clrB = *(reinterpret_cast<LabColor*>(koclrB.data()));
insertShades(clrA, clrB, shades);
}
void IndexColorPalette::insertColor(QColor qclr)
{
KoColor koclr;
koclr.fromQColor(qclr);
koclr.convertTo(KoColorSpaceRegistry::instance()->lab16());
LabColor clr = *(reinterpret_cast<LabColor*>(koclr.data()));
insertColor(clr);
}
void KoStopGradient::setStops(QList< KoGradientStop > stops)
{
m_stops.clear();
KoColor color;
Q_FOREACH (const KoGradientStop & stop, stops) {
color = stop.second;
color.convertTo(colorSpace());
m_stops.append(KoGradientStop(stop.first, color));
}
QColor KisVisualColorSelectorShape::getColorFromConverter(KoColor c){
QColor col;
KoColor color = c;
if (m_d->displayRenderer) {
color.convertTo(m_d->displayRenderer->getPaintingColorSpace());
col = m_d->displayRenderer->toQColor(c);
} else {
col = c.toQColor();
}
return col;
}
void KisVisualColorSelectorShape::setColorFromSibling(KoColor c)
{
//qDebug() << this << "setColorFromSibling";
if (c.colorSpace() != m_d->colorSpace) {
c.convertTo(m_d->colorSpace);
}
m_d->currentColor = c;
Q_EMIT sigNewColor(c);
m_d->imagesNeedUpdate = true;
update();
}
void KisVisualColorSelectorShape::setColor(KoColor c)
{
//qDebug() << this << "KisVisualColorSelectorShape::setColor";
if (c.colorSpace() != m_d->colorSpace) {
c.convertTo(m_d->colorSpace);
}
m_d->currentColor = c;
updateCursor();
m_d->imagesNeedUpdate = true;
update();
}
void KisBrushOp::paintAt(const KisPaintInformation& info)
{
if (!painter()->device()) return;
KisBrushSP brush = m_brush;
Q_ASSERT(brush);
if (!brush) return;
KisPaintInformation adjustedInfo = settings->m_optionsWidget->m_sizeOption->apply(info);
if (!brush->canPaintFor(adjustedInfo))
return;
KisPaintDeviceSP device = painter()->device();
double pScale = KisPaintOp::scaleForPressure(adjustedInfo.pressure()); // TODO: why is there scale and pScale that seems to contains the same things ?
QPointF hotSpot = brush->hotSpot(pScale, pScale);
QPointF pt = info.pos() - hotSpot;
// Split the coordinates into integer plus fractional parts. The integer
// is where the dab will be positioned and the fractional part determines
// the sub-pixel positioning.
qint32 x;
double xFraction;
qint32 y;
double yFraction;
splitCoordinate(pt.x(), &x, &xFraction);
splitCoordinate(pt.y(), &y, &yFraction);
quint8 origOpacity = settings->m_optionsWidget->m_opacityOption->apply(painter(), info.pressure());
KoColor origColor = settings->m_optionsWidget->m_darkenOption->apply(painter(), info.pressure());
double scale = KisPaintOp::scaleForPressure(adjustedInfo.pressure());
KisFixedPaintDeviceSP dab = cachedDab(device->colorSpace());
if (brush->brushType() == IMAGE || brush->brushType() == PIPE_IMAGE) {
dab = brush->image(device->colorSpace(), scale, 0.0, adjustedInfo, xFraction, yFraction);
} else {
KoColor color = painter()->paintColor();
color.convertTo(dab->colorSpace());
brush->mask(dab, color, scale, scale, 0.0, info, xFraction, yFraction);
}
painter()->bltFixed(QPoint(x, y), dab, dab->bounds());
painter()->setOpacity(origOpacity);
painter()->setPaintColor(origColor);
}
bool pick(KisPaintDeviceSP dev, const QPoint& pos, KoColor *color)
{
KIS_ASSERT(dev);
KoColor pickedColor;
dev->pixel(pos.x(), pos.y(), &pickedColor);
pickedColor.convertTo(dev->compositionSourceColorSpace());
bool validColorPicked =
pickedColor.opacityU8() != OPACITY_TRANSPARENT_U8;
if (validColorPicked) {
pickedColor.setOpacity(OPACITY_OPAQUE_U8);
*color = pickedColor;
}
return validColorPicked;
}
void KisShadeSelectorLine::paintEvent(QPaintEvent *)
{
if (m_cachedColorSpace != m_parentProxy->colorSpace()) {
m_realPixelCache = new KisPaintDevice(m_parentProxy->colorSpace());
m_cachedColorSpace = m_parentProxy->colorSpace();
}
else {
m_realPixelCache->clear();
}
int patchCount;
int patchSpacing;
if(m_gradient) {
patchCount = width();
patchSpacing = 0;
}
else {
patchCount = m_patchCount;
patchSpacing = 3;
}
qreal patchWidth = (width()-patchSpacing*patchCount)/qreal(patchCount);
qreal hueStep=m_hueDelta/qreal(patchCount);
qreal saturationStep=m_saturationDelta/qreal(patchCount);
qreal valueStep=m_valueDelta/qreal(patchCount);
qreal baseHue;
qreal baseSaturation;
qreal baseValue;
m_parentProxy->converter()->
getHsvF(m_realColor, &baseHue, &baseSaturation, &baseValue);
int z=0;
for(int i=-patchCount/2; i<=patchCount/2; i++) {
if(i==0 && patchCount%2==0) continue;
qreal hue = baseHue + (i * hueStep) + m_hueShift;
while (hue < 0.0) hue += 1.0;
while (hue > 1.0) hue -= 1.0;
qreal saturation = qBound<qreal>(0., baseSaturation + (i * saturationStep) + m_saturationShift, 1.);
qreal value = qBound<qreal>(0., baseValue + (i * valueStep) + m_valueShift, 1.);
QRect patchRect(z * (patchWidth + patchSpacing), 0, patchWidth, m_lineHeight);
KoColor patchColor = m_parentProxy->converter()->fromHsvF(hue, saturation, value);
patchColor.convertTo(m_realPixelCache->colorSpace());
m_realPixelCache->fill(patchRect, patchColor);
z++;
}
QPainter wpainter(this);
QImage renderedImage = m_parentProxy->converter()->toQImage(m_realPixelCache);
wpainter.drawImage(0, 0, renderedImage);
if(m_displayHelpText) {
QString helpText(i18n("delta h=%1 s=%2 v=%3 shift h=%4 s=%5 v=%6",
m_hueDelta,
m_saturationDelta,
m_valueDelta,
m_hueShift,
m_saturationShift,
m_valueShift));
wpainter.setPen(QColor(255,255,255));
wpainter.drawText(rect(), helpText);
}
}
QPointF KisVisualColorSelectorShape::convertKoColorToShapeCoordinate(KoColor c)
{
////qDebug() << this << ">>>>>>>>> convertKoColorToShapeCoordinate()";
if (c.colorSpace() != m_d->colorSpace) {
c.convertTo(m_d->colorSpace);
}
QVector <float> channelValues (m_d->currentColor.colorSpace()->channelCount());
channelValues.fill(1.0);
m_d->colorSpace->normalisedChannelsValue(c.data(), channelValues);
QVector <float> channelValuesDisplay = channelValues;
QVector <qreal> maxvalue(c.colorSpace()->channelCount());
maxvalue.fill(1.0);
if (m_d->displayRenderer
&& (m_d->colorSpace->colorDepthId() == Float16BitsColorDepthID
|| m_d->colorSpace->colorDepthId() == Float32BitsColorDepthID
|| m_d->colorSpace->colorDepthId() == Float64BitsColorDepthID)
&& m_d->colorSpace->colorModelId() != LABAColorModelID
&& m_d->colorSpace->colorModelId() != CMYKAColorModelID) {
for (int ch = 0; ch<maxvalue.size(); ch++) {
KoChannelInfo *channel = m_d->colorSpace->channels()[ch];
maxvalue[ch] = m_d->displayRenderer->maxVisibleFloatValue(channel);
channelValues[ch] = channelValues[ch]/(maxvalue[ch]);
channelValuesDisplay[KoChannelInfo::displayPositionToChannelIndex(ch, m_d->colorSpace->channels())] = channelValues[ch];
}
} else {
for (int i =0; i<channelValues.size();i++) {
channelValuesDisplay[KoChannelInfo::displayPositionToChannelIndex(i, m_d->colorSpace->channels())] = qBound((float)0.0,channelValues[i], (float)1.0);
}
}
QPointF coordinates(0.0,0.0);
qreal huedivider = 1.0;
qreal huedivider2 = 1.0;
if (m_d->channel1==0) {
huedivider = 360.0;
}
if (m_d->channel2==0) {
huedivider2 = 360.0;
}
if (m_d->model != ColorModel::Channel && c.colorSpace()->colorModelId().id() == "RGBA") {
if (c.colorSpace()->colorModelId().id() == "RGBA") {
if (m_d->model == ColorModel::HSV){
QVector <float> inbetween(3);
RGBToHSV(channelValuesDisplay[0],channelValuesDisplay[1], channelValuesDisplay[2], &inbetween[0], &inbetween[1], &inbetween[2]);
inbetween = convertvectorqrealTofloat(getHSX(convertvectorfloatToqreal(inbetween)));
coordinates.setX(inbetween[m_d->channel1]/huedivider);
if (m_d->dimension == Dimensions::twodimensional) {
coordinates.setY(inbetween[m_d->channel2]/huedivider2);
}
} else if (m_d->model == ColorModel::HSL) {
QVector <float> inbetween(3);
RGBToHSL(channelValuesDisplay[0],channelValuesDisplay[1], channelValuesDisplay[2], &inbetween[0], &inbetween[1], &inbetween[2]);
inbetween = convertvectorqrealTofloat(getHSX(convertvectorfloatToqreal(inbetween)));
coordinates.setX(inbetween[m_d->channel1]/huedivider);
if (m_d->dimension == Dimensions::twodimensional) {
coordinates.setY(inbetween[m_d->channel2]/huedivider2);
}
} else if (m_d->model == ColorModel::HSI) {
QVector <qreal> chan2 = convertvectorfloatToqreal(channelValuesDisplay);
QVector <qreal> inbetween(3);
RGBToHSI(channelValuesDisplay[0],channelValuesDisplay[1], channelValuesDisplay[2], &inbetween[0], &inbetween[1], &inbetween[2]);
inbetween = getHSX(inbetween);
coordinates.setX(inbetween[m_d->channel1]);
if (m_d->dimension == Dimensions::twodimensional) {
coordinates.setY(inbetween[m_d->channel2]);
}
} else if (m_d->model == ColorModel::HSY) {
QVector <qreal> luma = m_d->colorSpace->lumaCoefficients();
QVector <qreal> chan2 = convertvectorfloatToqreal(channelValuesDisplay);
QVector <qreal> inbetween(3);
RGBToHSY(channelValuesDisplay[0],channelValuesDisplay[1], channelValuesDisplay[2], &inbetween[0], &inbetween[1], &inbetween[2], luma[0], luma[1], luma[2]);
inbetween = getHSX(inbetween);
coordinates.setX(inbetween[m_d->channel1]);
if (m_d->dimension == Dimensions::twodimensional) {
coordinates.setY(inbetween[m_d->channel2]);
}
}
}
} else {
coordinates.setX(qBound((float)0.0, channelValuesDisplay[m_d->channel1], (float)1.0));
if (m_d->dimension == Dimensions::twodimensional) {
coordinates.setY(qBound((float)0.0, channelValuesDisplay[m_d->channel2], (float)1.0));
}
}
return coordinates;
}
inline
KisFixedPaintDeviceSP KisDabCache::fetchDabCommon(const KoColorSpace *cs,
const KisColorSource *colorSource,
const KoColor& color,
double scaleX, double scaleY,
double angle,
const KisPaintInformation& info,
double subPixelX, double subPixelY,
qreal softnessFactor)
{
if (!m_d->dab || !(*m_d->dab->colorSpace() == *cs)) {
m_d->dab = new KisFixedPaintDevice(cs);
} else {
KisFixedPaintDeviceSP cachedDab =
tryFetchFromCache(colorSource, color, scaleX, scaleY, angle,
info, subPixelX, subPixelY, softnessFactor);
if (cachedDab) return cachedDab;
}
if (m_d->brush->brushType() == IMAGE || m_d->brush->brushType() == PIPE_IMAGE) {
m_d->dab = m_d->brush->paintDevice(cs, scaleX, angle, info,
subPixelX, subPixelY);
}
else {
if (!colorSource) {
KoColor paintColor = color;
paintColor.convertTo(cs);
*m_d->cachedDabParameters = getDabParameters(paintColor,
scaleX, scaleY,
angle, info,
subPixelX, subPixelY,
softnessFactor);
m_d->brush->mask(m_d->dab, paintColor, scaleX, scaleY, angle,
info, subPixelX, subPixelY, softnessFactor);
} else if (colorSource->isUniformColor()) {
KoColor paintColor = colorSource->uniformColor();
paintColor.convertTo(cs);
*m_d->cachedDabParameters = getDabParameters(paintColor,
scaleX, scaleY,
angle, info,
subPixelX, subPixelY,
softnessFactor);
m_d->brush->mask(m_d->dab, paintColor, scaleX, scaleY, angle,
info, subPixelX, subPixelY, softnessFactor);
} else {
if (!m_d->colorSourceDevice || !(*cs == *m_d->colorSourceDevice->colorSpace())) {
m_d->colorSourceDevice = new KisPaintDevice(cs);
} else {
m_d->colorSourceDevice->clear();
}
QRect maskRect(0, 0, m_d->brush->maskWidth(scaleX, angle, info), m_d->brush->maskHeight(scaleY, angle, info));
colorSource->colorize(m_d->colorSourceDevice, maskRect, info.pos().toPoint());
delete m_d->colorSourceDevice->convertTo(cs);
m_d->brush->mask(m_d->dab, m_d->colorSourceDevice, scaleX, scaleY, angle,
info, subPixelX, subPixelY, softnessFactor);
}
}
if (needSeparateOriginal()) {
if (!m_d->dabOriginal || !(*cs == *m_d->dabOriginal->colorSpace())) {
m_d->dabOriginal = new KisFixedPaintDevice(cs);
}
*m_d->dabOriginal = *m_d->dab;
}
postProcessDab(m_d->dab, info);
return m_d->dab;
}
void KoUniColorChooser::updateValues()
{
KoColor tmpColor;
m_HIn->blockSignals(true);
m_SIn->blockSignals(true);
m_VIn->blockSignals(true);
m_RIn->blockSignals(true);
m_GIn->blockSignals(true);
m_BIn->blockSignals(true);
if (cmykColorSpace()) {
m_CIn->blockSignals(true);
m_MIn->blockSignals(true);
m_YIn->blockSignals(true);
m_KIn->blockSignals(true);
}
m_LIn->blockSignals(true);
m_aIn->blockSignals(true);
m_bIn->blockSignals(true);
/*
KoOldColor color = m_fgColor;
int h = color.H();
int s = color.S();
int v = color.V();
m_HIn->setValue(h);
m_SIn->setValue(s);
m_VIn->setValue(v);
*/
tmpColor = m_currentColor;
tmpColor.convertTo(rgbColorSpace());
m_RIn->setValue(tmpColor.data()[2]);
m_GIn->setValue(tmpColor.data()[1]);
m_BIn->setValue(tmpColor.data()[0]);
if(m_showOpacitySlider)
{
m_opacitySlider->blockSignals(true);
m_opacityIn->blockSignals(true);
KoColor minColor = tmpColor;
tmpColor.colorSpace()->setOpacity(minColor.data(), OPACITY_TRANSPARENT_U8, 1);
KoColor maxColor = tmpColor;
tmpColor.colorSpace()->setOpacity(maxColor.data(), OPACITY_OPAQUE_U8, 1);
m_opacitySlider->setColors(minColor, maxColor);
m_opacitySlider->setValue(tmpColor.opacityF() * 100 );
m_opacityIn->setValue(tmpColor.opacityF() * 100 );
m_opacityIn->blockSignals(false);
m_opacitySlider->blockSignals(false);
}
tmpColor = m_currentColor;
tmpColor.convertTo(labColorSpace());
m_LIn->setValue(((quint16 *)tmpColor.data())[0]/(256*256/100));
m_aIn->setValue(((quint16 *)tmpColor.data())[1]/256);
m_bIn->setValue(((quint16 *)tmpColor.data())[2]/256);
if ( cmykColorSpace() ) {
tmpColor = m_currentColor;
tmpColor.convertTo(cmykColorSpace());
m_CIn->setValue((tmpColor.data()[0]*100)/255);
m_MIn->setValue((tmpColor.data()[1]*100/255));
m_YIn->setValue((tmpColor.data()[2]*100)/255);
m_KIn->setValue((tmpColor.data()[3]*100)/255);
}
m_HIn->blockSignals(false);
m_SIn->blockSignals(false);
m_VIn->blockSignals(false);
m_RIn->blockSignals(false);
m_GIn->blockSignals(false);
m_BIn->blockSignals(false);
if (cmykColorSpace()) {
m_CIn->blockSignals(false);
m_MIn->blockSignals(false);
m_YIn->blockSignals(false);
m_KIn->blockSignals(false);
}
m_LIn->blockSignals(false);
m_aIn->blockSignals(false);
m_bIn->blockSignals(false);
}
