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 t_libraryEditor::paintEvent(QPaintEvent *event) { QPainter painter(this); QBrush polyBrush; polyBrush.setColor(g_color); QPen dotPen; uint8_t minThickness = 4; painter.setRenderHint(QPainter::Antialiasing, true); painter.scale(scale, scale); painter.translate(offsetx,offsety); painter.setBackgroundMode(Qt::OpaqueMode); painter.setBackground(QBrush(QColor(255,255,255))); painter.fillRect(-2000,-2000,4000,4000,QColor(255,255,255)); dotPen.setStyle(Qt::DashLine); dotPen.setColor(QColor(200,200,200)); dotPen.setWidth(0); painter.setPen(dotPen); for(int16_t x = -2000; x != 2000; x += 50) { painter.drawLine(x,-2000,x,2000); painter.drawLine(-2000,x,2000,x); } if(haveComp) { for(uint16_t t = 0; t != currentComponent->items.size(); ++t) { if(currentComponent->items.at(t)->thickness < minThickness) currentComponent->items.at(t)->thickness = minThickness; if(currentComponent->items.at(t)->type == 'P') { t_PolylineObject *ob = static_cast<t_PolylineObject*>(currentComponent->items.at(t)); paintPolygon(painter, *ob); } else if(currentComponent->items.at(t)->type == 'C') { t_CircleObject *ob = static_cast<t_CircleObject*>(currentComponent->items.at(t)); paintCircle(painter, *ob); } else if(currentComponent->items.at(t)->type == 'X') { t_PinObject *ob = static_cast<t_PinObject*>(currentComponent->items.at(t)); paintPin(painter, *ob); } else if(currentComponent->items.at(t)->type == 'S') { t_RectangleObject *ob = static_cast<t_RectangleObject*>(currentComponent->items.at(t)); paintRectangle(painter, *ob); } else if(currentComponent->items.at(t)->type == 'A') { t_ArcObject *ob = static_cast<t_ArcObject*>(currentComponent->items.at(t)); paintArc(painter, *ob); } } for(uint8_t t = 0; t != currentComponent->fields.size(); ++t) { t_component_field tF = currentComponent->fields.at(t); if(tF.flags & (1 << VISIBLE)) { paintText(painter, tF); } } } /* if(incompleteStage) { dotPen.setWidth(5); dotPen.setStyle(Qt::SolidLine); dotPen.setColor(QColor(200,100,100)); painter.setPen(dotPen); painter.drawLine(incompleteLine); } else if(pinPlacement) { dotPen.setWidth(1); dotPen.setColor(QColor(100,200,100)); painter.setPen(dotPen); painter.drawEllipse(incompleteLine.p2(), 10, 10); } */ dotPen.setColor(QColor(100,100,100)); dotPen.setWidth(1); painter.setPen(dotPen); painter.drawLine(0,-10,0,10); painter.drawLine(-10,0,10,0); event->accept(); }
int run(const char *serverAddress, const int serverPort, char headless) { int i, sockfd, show = ~0; int frames = 0; int returnValue = EXIT_SUCCESS; CvCapture *capture; CvMemStorage *storage; IplImage *grabbedImage; IplImage *imgThreshold; CvSeq *seq; CvFont font; SendQueue *queue; char strbuf[255]; struct timeval oldTime, time, diff; float lastKnownFPS = 0; sockfd = initNetwork(serverAddress, serverPort); if (sockfd == -1) { fprintf(stderr, "ERROR: initNetwork returned -1\n"); return EXIT_FAILURE; } queue = initSendQueue(); capture = cvCaptureFromCAM(CV_CAP_ANY); if (capture == NULL) { fprintf( stderr, "ERROR: capture is NULL \n" ); getchar(); return EXIT_FAILURE; } // Create a window in which the captured images will be presented cvNamedWindow("mywindow", CV_WINDOW_AUTOSIZE); storage = cvCreateMemStorage(0); // void cvInitFont(font, font_face, hscale, vscale, shear=0, thickness=1, line_type=8 ) cvInitFont(&font, CV_FONT_HERSHEY_PLAIN, 1, 1, 0, 1, 8); gettimeofday(&oldTime, NULL); // Show the image captured from the camera in the window and repeat while (1) { cvClearMemStorage(storage); grabbedImage = cvQueryFrame(capture); if (grabbedImage == NULL) { fprintf( stderr, "ERROR: frame is null...\n" ); getchar(); returnValue = EXIT_FAILURE; break; } //Create detection image imgThreshold = cvCreateImage(cvGetSize(grabbedImage), 8, 1); cvInRangeS(grabbedImage, min, max, imgThreshold); //Flip images to act as a mirror. //TODO remove when camera faces screen if (show) { cvFlip(grabbedImage, grabbedImage, 1); cvFlip(imgThreshold, imgThreshold, 1); } //Find all dots in the image. This is where any calibration of dot detection is done, if needed, though it //should be fine as it is right now. /* * image, circleStorage, method, double dp, double minDist, double param1, double param2, int minRadius, int maxRadius */ seq = cvHoughCircles(imgThreshold, storage, CV_HOUGH_GRADIENT, 2, 20, 20, 2, 0, 10); for (i = 0; i < seq->total; i++){ // Get point float *p = (float*)cvGetSeqElem(seq, i); //Draw current circle to the original image if (show) paintCircle(p, grabbedImage); //Buffer current circle to be sent to the server addPointToSendQueue(p, queue); } //Print some statistics to the image if (show) { snprintf(strbuf, sizeof(strbuf), "Dots: %i", seq->total); cvPutText(grabbedImage, strbuf, cvPoint(10, 20), &font, cvScalar(WHITE)); snprintf(strbuf, sizeof(strbuf), "FPS: %.1f", lastKnownFPS); cvPutText(grabbedImage, strbuf, cvPoint(10, 200), &font, cvScalar(WHITE)); } //Show images //TODO Comment these out will probably improve performance quite a bit if (show) { cvShowImage("mywindow", imgThreshold); cvShowImage("mywindow", grabbedImage); } gettimeofday(&time, NULL); timeval_subtract(&diff, &time, &oldTime); // printf("Frames = %i\n", diff.tv_sec); if (diff.tv_sec >= 2) { lastKnownFPS = (float)frames / diff.tv_sec; oldTime = time; frames = 0; } //Add one to the frame rate counter frames++; //Send to dots detected this frame to the server sendQueue(sockfd, queue); clearSendQueue(queue); // //If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version), //remove higher bits using AND operator i = (cvWaitKey(10) & 0xff); if (i == 'v') show = ~show; if (i == 27) break; } // Release the capture device housekeeping cvReleaseCapture( &capture ); cvDestroyWindow( "mywindow" ); destroySendQueue(queue); close(sockfd); return returnValue; }
void SprayBrush::paint(KisPaintDeviceSP dev, const KisPaintInformation& info, const KoColor &color) { qreal x = info.pos().x(); qreal y = info.pos().y(); // initializing painter KisPainter drawer(dev); drawer.setPaintColor(color); // jitter radius int tmpRadius = m_radius; if (m_jitterSize){ m_radius = m_radius * drand48(); } // jitter movement if (m_jitterMovement){ x = x + (( 2 * m_radius * drand48() ) - m_radius) * m_amount; y = y + (( 2 * m_radius * drand48() ) - m_radius) * m_amount; } KisRandomAccessor accessor = dev->createRandomAccessor( qRound(x), qRound(y) ); m_pixelSize = dev->colorSpace()->pixelSize(); m_inkColor = color; m_counter++; // coverage: adaptively select how many objects are sprayed per paint if (m_useDensity){ m_particlesCount = (m_coverage * (M_PI * m_radius * m_radius) ); } // Metaballs are rendered little differently if (m_shape == 2 && m_object == 0){ paintMetaballs(dev, info, color); } qreal nx, ny; int ix, iy; qreal angle; qreal lengthX; qreal lengthY; for (int i = 0; i < m_particlesCount; i++){ // generate random angle angle = drand48() * M_PI * 2; // different X and Y length?? lengthY = lengthX = drand48(); // I hope we live the era where sin and cos is not slow for spray nx = (sin(angle) * m_radius * lengthX); ny = (cos(angle) * m_radius * lengthY); // transform nx *= m_scale; ny *= m_scale; // it is some shape (circle, ellipse, rectangle) if (m_object == 0) { // steps for single step in circle and ellipse int steps = 36; qreal random = drand48(); drawer.setFillColor(m_inkColor); drawer.setBackgroundColor(m_inkColor); drawer.setPaintColor(m_inkColor); // it is ellipse if (m_shape == 0){ // qreal ellipseA = m_width / 2.0; qreal ellipseB = m_height / 2.0; if (m_width == m_height) { if (m_jitterShapeSize){ paintCircle(drawer, nx + x, ny + y, int((random * ellipseA) + 1.5) , steps); } else{ paintCircle(drawer, nx + x, ny + y, qRound(ellipseA) , steps); } } else { if (m_jitterShapeSize){ paintEllipse(drawer, nx + x, ny + y,int((random * ellipseA) + 1.5) ,int((random * ellipseB) + 1.5), angle , steps); } else{ paintEllipse(drawer, nx + x, ny + y, qRound(ellipseA), qRound(ellipseB), angle , steps); } } } else if (m_shape == 1) { if (m_jitterShapeSize){ paintRectangle(drawer, nx + x, ny + y,int((random * m_width) + 1.5) ,int((random * m_height) + 1.5), angle , steps); } else{ paintRectangle(drawer, nx + x, ny + y, qRound(m_width), qRound(m_height), angle , steps); } } // it is pixel particle }else if (m_object == 1){ paintParticle(accessor,m_inkColor,nx + x, ny + y); } // it is pixel else if (m_object == 2) { ix = qRound(nx + x); iy = qRound(ny + y); accessor.moveTo(ix, iy); memcpy(accessor.rawData(), m_inkColor.data(), m_pixelSize); } } // hidden code for outline detection //m_inkColor.setOpacity(128); //paintOutline(dev,m_inkColor,x, y, m_radius * 2); // recover from jittering of color m_radius = tmpRadius; }