//--------------------------------------------------------------
void ofApp::draw(){
if (selectedColor.size()==0) {
colorPicker();
}
//---------POLYGONS---------------------
if (selectedColor.size()>0) {
polygons();
for (int i = 0; i < curveVertices.size(); i++){
}
///////////maximilian///////
/* You can use any of the data from audio received and audiorequested to draw stuff here.
Importantly, most people just use the input and output arrays defined above.
Clever people don't do this. This bit of code shows that by default, each signal is going to flip
between -1 and 1. You need to account for this somehow. Get the absolute value for example.
*/
// ofSetColor(255, 255, 255,255);
// ofRect(600, 300, sample*150, sample*150); /* audio sigs go between -1 and 1. See?*/
// ofCircle(200, 300, wave*150);
}
//---------COLOR PICKER---------------------
// pickerFbo.draw(ofGetWidth()-ofGetWidth()/6,ofGetHeight() - ofGetHeight()/6);
if (colorPickerRect.inside(mouseX, mouseY)) {
colorPicker();
ableClick=false;
}else{
ableClick=true;
}
}
void HairyBrush::colorifyBristles(KisPaintDeviceSP source, QPointF point)
{
KoColor bristleColor(m_dab->colorSpace());
KisCrossDeviceColorPickerInt colorPicker(source, bristleColor);
Bristle *b = 0;
int size = m_bristles.size();
for (int i = 0; i < size; i++) {
b = m_bristles[i];
int x = qRound(b->x() + point.x());
int y = qRound(b->y() + point.y());
colorPicker.pickOldColor(x, y, bristleColor.data());
b->setColor(bristleColor);
}
}
void UBDrawingFillPropertiesPalette::onBtnSelectFillSecondColor()
{
QColorDialog colorPicker(this);
colorPicker.setOption(QColorDialog::ShowAlphaChannel);
#ifdef Q_WS_MAC
colorPicker.setOption(QColorDialog::DontUseNativeDialog);
#endif
if ( colorPicker.exec() )
{
QColor selectedColor = colorPicker.selectedColor();
if (selectedColor.alpha() == 0)
selectedColor = Qt::transparent;
UBApplication::boardController->shapeFactory().setFillingSecondColor(selectedColor);
mBtnColor2Picker->setColor(selectedColor); // udpate Color icon in palette.
}
}
void UBDrawingFillPropertiesPalette::onBtnSelectFillFirstColor()
{
QColorDialog colorPicker(this);
colorPicker.setOption(QColorDialog::ShowAlphaChannel);
#ifdef Q_WS_MAC
colorPicker.setOption(QColorDialog::DontUseNativeDialog);
#endif
if ( colorPicker.exec() )
{
QColor selectedColor = colorPicker.selectedColor();
if (selectedColor.alpha() == 0)
selectedColor = Qt::transparent;
UBApplication::boardController->shapeFactory().setFillingFirstColor(selectedColor);
mBtnColorPicker->setColor(selectedColor); // udpate Color icon in palette.
if (UBApplication::boardController->shapeFactory().fillType() == UBShapeFactory::Transparent)
{
UBApplication::mainWindow->actionColorStyleFull->setChecked(true);
onBtnColorFull();
}
}
}
KisSpacingInformation KisColorSmudgeOp::paintAt(const KisPaintInformation& info)
{
KisBrushSP brush = m_brush;
// Simple error catching
if (!painter()->device() || !brush || !brush->canPaintFor(info))
return 1.0;
// get the scaling factor calculated by the size option
qreal scale = m_sizeOption.apply(info);
qreal rotation = m_rotationOption.apply(info);
if (checkSizeTooSmall(scale)) return KisSpacingInformation();
setCurrentScale(scale);
setCurrentRotation(rotation);
QPointF scatteredPos =
m_scatterOption.apply(info,
brush->maskWidth(scale, rotation, 0, 0, info),
brush->maskHeight(scale, rotation, 0, 0, info));
QPointF hotSpot = brush->hotSpot(scale, scale, rotation, info);
/**
* Update the brush mask.
*
* Upon leaving the function:
* o m_maskDab stores the new mask
* o m_maskBounds stroes the extents of the mask paint device
* o m_dstDabRect stores the destination rect where the mask is going
* to be written to
*/
updateMask(info, scale, rotation, scatteredPos);
QPointF newCenterPos = QRectF(m_dstDabRect).center();
QRect srcDabRect = m_dstDabRect.translated((m_lastPaintPos - newCenterPos).toPoint());
/**
* Save the center of the current dab to know where to read the
* data during the next pass. We do not save scatteredPos here,
* because it may slightly differ from the real center of the
* brush (due to some rounding effects), which will result in
* really weird quality.
*/
m_lastPaintPos = QRectF(m_dstDabRect).center();
KisSpacingInformation spacingInfo =
effectiveSpacing(m_dstDabRect.width(), m_dstDabRect.height(),
m_spacingOption, info);
if (m_firstRun) {
m_firstRun = false;
return spacingInfo;
}
// save the old opacity value and composite mode
quint8 oldOpacity = painter()->opacity();
QString oldModeId = painter()->compositeOp()->id();
qreal fpOpacity = (qreal(oldOpacity) / 255.0) * m_opacityOption.getOpacityf(info);
KoColor color = painter()->paintColor();
if (m_image && m_overlayModeOption.isChecked()) {
m_image->blockUpdates();
m_backgroundPainter->bitBlt(QPoint(), m_image->projection(), srcDabRect);
m_image->unblockUpdates();
}
else {
// IMPORTANT: clear the temporary painting device to color black with zero opacity
// it will only clear the extents of the brush
m_tempDev->clear(QRect(QPoint(), m_dstDabRect.size()));
}
if (m_smudgeRateOption.getMode() == KisSmudgeOption::SMEARING_MODE) {
// cut out the area from the canvas under the brush
// and blit it to the temporary painting device
if(m_smudgeRadiusOption.isChecked())
{
m_smudgeRadiusOption.apply(*m_smudgePainter,info,m_brush->width(),m_dstDabRect.center().x(),m_dstDabRect.center().y(),painter()->device());
color = m_smudgePainter->paintColor();
}
m_smudgePainter->bitBlt(QPoint(), painter()->device(), srcDabRect);
}
else {
QPoint pt = (srcDabRect.topLeft() + hotSpot).toPoint();
// get the pixel on the canvas that lies beneath the hot spot
// of the dab and fill the temporary paint device with that color
KoColor color = painter()->paintColor();
if(m_smudgeRadiusOption.isChecked())
{
m_smudgeRadiusOption.apply(*m_smudgePainter,info,m_brush->width(),pt.x(),pt.y(),painter()->device());
KoColor color2 = m_smudgePainter->paintColor();
m_smudgePainter->fill(0, 0, m_dstDabRect.width(), m_dstDabRect.height(),color2);
}
else
{
KisCrossDeviceColorPickerInt colorPicker(painter()->device(), color);
colorPicker.pickColor(pt.x(), pt.y(), color.data());
m_smudgePainter->fill(0, 0, m_dstDabRect.width(), m_dstDabRect.height(), color);
}
}
// if the user selected the color smudge option
// we will mix some color into the temporary painting device (m_tempDev)
if (m_colorRateOption.isChecked()) {
// this will apply the opacy (selected by the user) to copyPainter
// (but fit the rate inbetween the range 0.0 to (1.0-SmudgeRate))
qreal maxColorRate = qMax<qreal>(1.0 - m_smudgeRateOption.getRate(), 0.2);
m_colorRateOption.apply(*m_colorRatePainter, info, 0.0, maxColorRate, fpOpacity);
// paint a rectangle with the current color (foreground color)
// or a gradient color (if enabled)
// into the temporary painting device and use the user selected
// composite mode
KoColor color = painter()->paintColor();
m_gradientOption.apply(color, m_gradient, info);
m_colorRatePainter->fill(0, 0, m_dstDabRect.width(), m_dstDabRect.height(), color);
}
// if color is disabled (only smudge) and "overlay mode is enabled
// then first blit the region under the brush from the image projection
// to the painting device to prevent a rapid build up of alpha value
// if the color to be smudged is semi transparent
if (m_image && m_overlayModeOption.isChecked() && !m_colorRateOption.isChecked()) {
painter()->setCompositeOp(COMPOSITE_COPY);
painter()->setOpacity(OPACITY_OPAQUE_U8);
m_image->blockUpdates();
painter()->bitBlt(m_dstDabRect.topLeft(), m_image->projection(), m_dstDabRect);
m_image->unblockUpdates();
}
// set opacity calculated by the rate option
m_smudgeRateOption.apply(*painter(), info, 0.0, 1.0, fpOpacity);
// then blit the temporary painting device on the canvas at the current brush position
// the alpha mask (maskDab) will be used here to only blit the pixels that are in the area (shape) of the brush
painter()->setCompositeOp(COMPOSITE_COPY);
painter()->bitBltWithFixedSelection(m_dstDabRect.x(), m_dstDabRect.y(), m_tempDev, m_maskDab, m_dstDabRect.width(), m_dstDabRect.height());
painter()->renderMirrorMaskSafe(m_dstDabRect, m_tempDev, 0, 0, m_maskDab,
!m_dabCache->needSeparateOriginal());
// restore orginal opacy and composite mode values
painter()->setOpacity(oldOpacity);
painter()->setCompositeOp(oldModeId);
return spacingInfo;
}
void SprayBrush::paint(KisPaintDeviceSP dab, KisPaintDeviceSP source,
const KisPaintInformation& info, qreal rotation, qreal scale,
const KoColor &color, const KoColor &bgColor)
{
// initializing painter
if (!m_painter) {
m_painter = new KisPainter(dab);
m_painter->setFillStyle(KisPainter::FillStyleForegroundColor);
m_painter->setMaskImageSize(m_shapeProperties->width, m_shapeProperties->height);
m_dabPixelSize = dab->colorSpace()->pixelSize();
if (m_colorProperties->useRandomHSV) {
m_transfo = dab->colorSpace()->createColorTransformation("hsv_adjustment", QHash<QString, QVariant>());
}
m_brushQImage = m_shapeProperties->image;
if (!m_brushQImage.isNull()) {
m_brushQImage = m_brushQImage.scaled(m_shapeProperties->width, m_shapeProperties->height);
}
m_imageDevice = new KisPaintDevice(dab->colorSpace());
}
qreal x = info.pos().x();
qreal y = info.pos().y();
KisRandomAccessorSP accessor = dab->createRandomAccessorNG(qRound(x), qRound(y));
Q_ASSERT(color.colorSpace()->pixelSize() == dab->pixelSize());
m_inkColor = color;
KisCrossDeviceColorPicker colorPicker(source, m_inkColor);
// apply size sensor
m_radius = m_properties->radius * scale;
// jitter movement
if (m_properties->jitterMovement) {
x = x + ((2 * m_radius * drand48()) - m_radius) * m_properties->amount;
y = y + ((2 * m_radius * drand48()) - m_radius) * m_properties->amount;
}
// this is wrong for every shape except pixel and anti-aliased pixel
if (m_properties->useDensity) {
m_particlesCount = (m_properties->coverage * (M_PI * m_radius * m_radius));
}
else {
m_particlesCount = m_properties->particleCount;
}
QHash<QString, QVariant> params;
qreal nx, ny;
int ix, iy;
qreal angle;
qreal length;
qreal rotationZ = 0.0;
qreal particleScale = 1.0;
bool shouldColor = true;
if (m_colorProperties->fillBackground) {
m_painter->setPaintColor(bgColor);
paintCircle(m_painter, x, y, m_radius);
}
QTransform m;
m.reset();
m.rotateRadians(-rotation + deg2rad(m_properties->brushRotation));
m.scale(m_properties->scale, m_properties->scale);
for (quint32 i = 0; i < m_particlesCount; i++) {
// generate random angle
angle = drand48() * M_PI * 2;
// generate random length
if (m_properties->gaussian) {
length = qBound<qreal>(0.0, m_rand->nextGaussian(0.0, 0.50) , 1.0);
}
else {
length = drand48();
}
if (m_shapeDynamicsProperties->enabled) {
// rotation
rotationZ = rotationAngle();
if (m_shapeDynamicsProperties->followCursor) {
rotationZ = linearInterpolation(rotationZ, angle, m_shapeDynamicsProperties->followCursorWeigth);
}
if (m_shapeDynamicsProperties->followDrawingAngle) {
rotationZ = linearInterpolation(rotationZ, info.drawingAngle(), m_shapeDynamicsProperties->followDrawingAngleWeight);
}
// random size - scale
if (m_shapeDynamicsProperties->randomSize) {
particleScale = drand48();
}
}
// generate polar coordinate
nx = (m_radius * cos(angle) * length);
ny = (m_radius * sin(angle) * length);
// compute the height of the ellipse
ny *= m_properties->aspect;
// transform
m.map(nx, ny, &nx, &ny);
// color transformation
if (shouldColor) {
if (m_colorProperties->sampleInputColor) {
colorPicker.pickOldColor(nx + x, ny + y, m_inkColor.data());
}
// mix the color with background color
if (m_colorProperties->mixBgColor) {
KoMixColorsOp * mixOp = dab->colorSpace()->mixColorsOp();
const quint8 *colors[2];
colors[0] = m_inkColor.data();
colors[1] = bgColor.data();
qint16 colorWeights[2];
int MAX_16BIT = 255;
qreal blend = info.pressure();
colorWeights[0] = static_cast<quint16>(blend * MAX_16BIT);
colorWeights[1] = static_cast<quint16>((1.0 - blend) * MAX_16BIT);
mixOp->mixColors(colors, colorWeights, 2, m_inkColor.data());
}
if (m_colorProperties->useRandomHSV && m_transfo) {
params["h"] = (m_colorProperties->hue / 180.0) * drand48();
params["s"] = (m_colorProperties->saturation / 100.0) * drand48();
params["v"] = (m_colorProperties->value / 100.0) * drand48();
m_transfo->setParameters(params);
m_transfo->transform(m_inkColor.data(), m_inkColor.data() , 1);
}
if (m_colorProperties->useRandomOpacity) {
quint8 alpha = qRound(drand48() * OPACITY_OPAQUE_U8);
m_inkColor.setOpacity(alpha);
m_painter->setOpacity(alpha);
}
if (!m_colorProperties->colorPerParticle) {
shouldColor = false;
}
m_painter->setPaintColor(m_inkColor);
}
qreal jitteredWidth = qMax(qreal(1.0), m_shapeProperties->width * particleScale);
qreal jitteredHeight = qMax(qreal(1.0), m_shapeProperties->height * particleScale);
if (m_shapeProperties->enabled){
switch (m_shapeProperties->shape){
// ellipse
case 0:
{
if (m_shapeProperties->width == m_shapeProperties->height){
paintCircle(m_painter, nx + x, ny + y, qRound(jitteredWidth * 0.5));
}
else {
paintEllipse(m_painter, nx + x, ny + y, qRound(jitteredWidth * 0.5) , qRound(jitteredHeight * 0.5), rotationZ);
}
break;
}
// rectangle
case 1:
{
paintRectangle(m_painter, nx + x, ny + y, qRound(jitteredWidth) , qRound(jitteredHeight), rotationZ);
break;
}
// wu-particle
case 2: {
paintParticle(accessor, m_inkColor, nx + x, ny + y);
break;
}
// pixel
case 3: {
ix = qRound(nx + x);
iy = qRound(ny + y);
accessor->moveTo(ix, iy);
memcpy(accessor->rawData(), m_inkColor.data(), m_dabPixelSize);
break;
}
case 4: {
if (!m_brushQImage.isNull()) {
QTransform m;
m.rotate(rad2deg(rotationZ));
if (m_shapeDynamicsProperties->randomSize) {
m.scale(particleScale, particleScale);
}
m_transformed = m_brushQImage.transformed(m, Qt::SmoothTransformation);
m_imageDevice->convertFromQImage(m_transformed, 0);
KisRandomAccessorSP ac = m_imageDevice->createRandomAccessorNG(0, 0);
QRect rc = m_transformed.rect();
if (m_colorProperties->useRandomHSV && m_transfo) {
for (int y = rc.y(); y < rc.y() + rc.height(); y++) {
for (int x = rc.x(); x < rc.x() + rc.width(); x++) {
ac->moveTo(x, y);
m_transfo->transform(ac->rawData(), ac->rawData() , 1);
}
}
}
ix = qRound(nx + x - rc.width() * 0.5);
iy = qRound(ny + y - rc.height() * 0.5);
m_painter->bitBlt(QPoint(ix, iy), m_imageDevice, rc);
m_imageDevice->clear();
break;
}
}
}
// Auto-brush
}
else {
QPointF hotSpot = m_brush->hotSpot(particleScale, particleScale, -rotationZ, info);
QPointF pos(nx + x, ny + y);
QPointF pt = pos - hotSpot;
qint32 ix;
qreal xFraction;
qint32 iy;
qreal yFraction;
KisPaintOp::splitCoordinate(pt.x(), &ix, &xFraction);
KisPaintOp::splitCoordinate(pt.y(), &iy, &yFraction);
//KisFixedPaintDeviceSP dab;
if (m_brush->brushType() == IMAGE ||
m_brush->brushType() == PIPE_IMAGE) {
m_fixedDab = m_brush->paintDevice(m_fixedDab->colorSpace(), particleScale, -rotationZ, info, xFraction, yFraction);
if (m_colorProperties->useRandomHSV && m_transfo) {
quint8 * dabPointer = m_fixedDab->data();
int pixelCount = m_fixedDab->bounds().width() * m_fixedDab->bounds().height();
m_transfo->transform(dabPointer, dabPointer, pixelCount);
}
}
else {
m_brush->mask(m_fixedDab, m_inkColor, particleScale, particleScale, -rotationZ, info, xFraction, yFraction);
}
m_painter->bltFixed(QPoint(ix, iy), m_fixedDab, m_fixedDab->bounds());
}
}
// recover from jittering of color,
// m_inkColor.opacity is recovered with every paint
}
void KisSmudgeRadiusOption::apply(KisPainter& painter, const KisPaintInformation& info, qreal scale, qreal posx, qreal posy,KisPaintDeviceSP dev) const
{
double sliderValue = computeValue(info);
int smudgeRadius = ((sliderValue * scale)*0.5)/100.0;//scale is diameter?
KoColor color = painter.paintColor();
if (smudgeRadius == 1) {
dev->pixel(posx, posy, &color);
painter.setPaintColor(color);
} else {
const KoColorSpace* cs = dev->colorSpace();
int pixelSize = cs->pixelSize();
quint8* data = new quint8[pixelSize];
static quint8** pixels = new quint8*[2];
qint16* weights = new qint16[2];
pixels[1] = new quint8[pixelSize];
pixels[0] = new quint8[pixelSize];
int loop_increment = 1;
if(smudgeRadius >= 8)
{
loop_increment = (2*smudgeRadius)/16;
}
int i = 0;
int k = 0;
int j = 0;
KisRandomConstAccessorSP accessor = dev->createRandomConstAccessorNG(0, 0);
KisCrossDeviceColorPickerInt colorPicker(painter.device(), color);
colorPicker.pickColor(posx, posy, color.data());
for (int y = 0; y <= smudgeRadius; y = y + loop_increment) {
for (int x = 0; x <= smudgeRadius; x = x + loop_increment) {
for(j = 0;j < 2;j++)
{
if(j == 1)
{
y = y*(-1);
}
for(k = 0;k < 2;k++)
{
if(k == 1)
{
x = x*(-1);
}
accessor->moveTo(posx + x, posy + y);
memcpy(pixels[1], accessor->rawDataConst(), pixelSize);
if(i == 0)
{
memcpy(pixels[0],accessor->rawDataConst(),pixelSize);
}
if (x == 0 && y == 0) {
// Because the sum of the weights must be 255,
// we cheat a bit, and weigh the center pixel differently in order
// to sum to 255 in total
// It's -(counts -1), because we'll add the center one implicitly
// through that calculation
weights[1] = (255 - ((i + 1) * (255 /(i+2) )) );
} else {
weights[1] = 255 /(i+2);
}
i++;
if (i>smudgeRadius){i=0;}
weights[0] = 255 - weights[1];
const quint8** cpixels = const_cast<const quint8**>(pixels);
cs->mixColorsOp()->mixColors(cpixels, weights,2, data);
memcpy(pixels[0],data,pixelSize);
}
x = x*(-1);
}
y = y*(-1);
}
}
KoColor color = KoColor(pixels[0],cs);
painter.setPaintColor(color);
for (int l = 0; l < 2; l++){
delete[] pixels[l];
}
// delete[] pixels;
delete[] data;
}
}
