KisPaintDeviceSP KisShearVisitor::yShear(KisPaintDeviceSP src, qreal shearY, KoUpdater *progress) { int start = progress->progress(); KisPaintDeviceSP dst = KisPaintDeviceSP(new KisPaintDevice(src->colorSpace())); KoMixColorsOp * mixOp = src->colorSpace()->mixColorsOp(); dst->setX(src->x()); dst->setY(src->y()); QRect r = src->exactBounds(); qreal displacement; qint32 displacementInt; qreal weight; for (qint32 x = r.left(); x <= r.right(); x++) { //calculate displacement displacement = x * shearY; displacementInt = (qint32)(floor(displacement)); weight = displacement - displacementInt; qint16 pixelWeights[2]; pixelWeights[0] = static_cast<quint8>(weight * 255 + 0.5); pixelWeights[1] = 255 - pixelWeights[0]; KisVLineConstIteratorPixel srcIt = src->createVLineIterator(x, r.y(), r.height() + 1); KisVLineIteratorPixel leftSrcIt = src->createVLineIterator(x, r.y() - 1, r.height() + 1); KisVLineIteratorPixel dstIt = dst->createVLineIterator(x, r.y() + displacementInt, r.height() + 1); while (!srcIt.isDone()) { const quint8 *pixelPtrs[2]; pixelPtrs[0] = leftSrcIt.rawData(); pixelPtrs[1] = srcIt.rawData(); mixOp->mixColors(pixelPtrs, pixelWeights, 2, dstIt.rawData()); ++srcIt; ++leftSrcIt; ++dstIt; } progress->setProgress(start + x); } return dst; }
lInterestPoints HarrisPointDetector::computeInterestPoints(KisPaintDeviceSP device, const QRect& rect) // lHarrisPoints computeHarrisPoints(KisPaintDeviceSP device, QRect rect) { dbgPlugins << "Compute Harris points on the rect :" << rect; Q_ASSERT(device->colorSpace()->id() == "GRAYA"); lInterestPoints points; // Compute the derivatives KisEightFloatColorSpace* floatCs = new KisEightFloatColorSpace(); KisPaintDeviceSP infoDevice = new KisPaintDevice(floatCs, "infoDevice"); float g_var = DERIVATION_SIGMA * DERIVATION_SIGMA ; float sqrt2pi = sqrt(2 * M_PI); float beta0 = 1 / (sqrt2pi * DERIVATION_SIGMA); float beta1 = beta0 * exp(-1 / (2 * g_var)); float beta2 = beta0 * exp(-4 / (2 * g_var)); float alpha1 = beta1 / g_var; float alpha2 = 2 * beta2 / g_var; { KisHLineConstIteratorPixel hitDevice = device->createHLineConstIterator(rect.left(), rect.top() + 2, rect.width() - 4); KisHLineIteratorPixel hitinfoDevice = infoDevice-> createHLineIterator(rect.left() + 2, 2, rect.width()); quint8 pixelvalue[5]; dbgPlugins << " Compute the derivatives"; dbgPlugins << " horizontal derivatives"; /* Horizontal computation of derivatives */ for (int y = rect.top() + 2; y < rect.bottom() - 2; y++) { pixelvalue[LEFTLEFT] = *hitDevice.rawData(); ++hitDevice; pixelvalue[LEFT] = *hitDevice.rawData(); ++hitDevice; pixelvalue[CENTER] = *hitDevice.rawData(); ++hitDevice; pixelvalue[RIGHT] = *hitDevice.rawData(); ++hitDevice; while (!hitDevice.isDone()) { pixelvalue[RIGHTRIGHT] = *hitDevice.rawData(); float* infoValues = reinterpret_cast<float*>(hitinfoDevice.rawData()); infoValues[INFO_HDIFF] = alpha1 * (pixelvalue[LEFT] - pixelvalue[RIGHT]) + alpha2 * (pixelvalue[LEFTLEFT] - pixelvalue[RIGHTRIGHT]); infoValues[INFO_HADD] = beta0 * (pixelvalue[CENTER]) + beta1 * (pixelvalue[LEFT] + pixelvalue[RIGHT]) + beta2 * (pixelvalue[LEFTLEFT] + pixelvalue[RIGHTRIGHT]); infoValues[INFO_INTENSITY] = pixelvalue[CENTER]; // dbgPlugins << hitDevice.x() <<"" << hitDevice.y() <<"" << infoValues[INFO_HDIFF] <<"" << infoValues[INFO_HADD] <<"" << (int)pixelvalue[CENTER] <<"" << infoValues[INFO_INTENSITY]; memmove(pixelvalue, pixelvalue + 1, 4*sizeof(quint8)); ++hitDevice; ++hitinfoDevice; } hitDevice.nextRow(); hitinfoDevice.nextRow(); } } KisTransaction a("", infoDevice); { KisVLineConstIteratorPixel vitinfoDeviceRead = infoDevice-> createVLineConstIterator(rect.left() + 4, rect.top(), rect.height()); KisVLineIteratorPixel vitinfoDevice = infoDevice-> createVLineIterator(rect.left() + 4, rect.top() + 2, rect.height() - 2); float hdiffValue[5]; float haddValue[5]; dbgPlugins << " vertical derivatives"; /* Vertical computation of derivatives */ for (int x = rect.left() + 4; x < rect.right() - 4; x++) { const float* infoValue = reinterpret_cast<const float*>(vitinfoDeviceRead.oldRawData()); hdiffValue[TOPTOP] = infoValue[INFO_HDIFF]; haddValue[TOPTOP] = infoValue[INFO_HADD]; ++vitinfoDeviceRead; infoValue = reinterpret_cast<const float*>(vitinfoDeviceRead.oldRawData()); hdiffValue[TOP] = infoValue[INFO_HDIFF]; haddValue[TOP] = infoValue[INFO_HADD]; ++vitinfoDeviceRead; infoValue = reinterpret_cast<const float*>(vitinfoDeviceRead.oldRawData()); hdiffValue[CENTER] = infoValue[INFO_HDIFF]; haddValue[CENTER] = infoValue[INFO_HADD]; ++vitinfoDeviceRead; infoValue = reinterpret_cast<const float*>(vitinfoDeviceRead.oldRawData()); hdiffValue[RIGHT] = infoValue[INFO_HDIFF]; haddValue[RIGHT] = infoValue[INFO_HADD]; ++vitinfoDeviceRead; while (!vitinfoDevice.isDone()) { infoValue = reinterpret_cast<const float*>(vitinfoDeviceRead.oldRawData()); hdiffValue[RIGHTRIGHT] = infoValue[INFO_HDIFF]; haddValue[RIGHTRIGHT] = infoValue[INFO_HADD]; float c_grdy = beta0 * hdiffValue[ CENTER ] + beta1 * (hdiffValue[ TOP ] + hdiffValue[ BOTTOM ]) + beta2 * (hdiffValue[ TOPTOP ] + hdiffValue[ BOTTOMBOTTOM ]); float c_grdx = alpha1 * (haddValue[ TOP ] - haddValue[ BOTTOM ]) + alpha2 * (haddValue[ TOPTOP ] - haddValue[ BOTTOMBOTTOM ]); float* infoValueDst = reinterpret_cast<float*>(vitinfoDevice.rawData()); infoValueDst[ INFO_XX ] = c_grdx * c_grdx; infoValueDst[ INFO_YY ] = c_grdy * c_grdy; infoValueDst[ INFO_X ] = c_grdx; infoValueDst[ INFO_Y ] = c_grdy; infoValueDst[ INFO_XY ] = c_grdx * c_grdy; memmove(hdiffValue, hdiffValue + 1, 4 * sizeof(float)); memmove(haddValue , haddValue + 1 , 4 * sizeof(float)); ++vitinfoDeviceRead; ++vitinfoDevice; } vitinfoDeviceRead.nextCol(); vitinfoDevice.nextCol(); } } // Apply a blur // Apply a blur KisTransaction("", infoDevice); #if 1 { KisHLineConstIteratorPixel hitDevice = infoDevice->createHLineConstIterator(rect.left(), rect.top() + 2, rect.width() - 4); KisHLineIteratorPixel hitinfoDevice = infoDevice-> createHLineIterator(rect.left() + 2, rect.top() + 2, rect.width() - 4); float pixelvalue[6][6]; dbgPlugins << " Compute the blur"; dbgPlugins << " horizontal blur"; /* Horizontal computation of derivatives */ for (int y = rect.top() + 2; y < rect.bottom() - 2; y++) { memcpy(pixelvalue[LEFTLEFT], hitDevice.rawData(), 6*sizeof(float)); ++hitDevice; memcpy(pixelvalue[LEFT], hitDevice.rawData(), 6*sizeof(float)); ++hitDevice; memcpy(pixelvalue[CENTER], hitDevice.rawData(), 6*sizeof(float)); ++hitDevice; memcpy(pixelvalue[RIGHT], hitDevice.rawData(), 6*sizeof(float)); ++hitDevice; while (!hitDevice.isDone()) { memcpy(pixelvalue[RIGHTRIGHT], hitDevice.rawData(), 6*sizeof(float)); float* infoValues = reinterpret_cast<float*>(hitinfoDevice.rawData()); for (int i = 0; i < 5; i++) { infoValues[i] = beta0 * pixelvalue[CENTER][i] + beta1 * (pixelvalue[LEFT][i] + pixelvalue[RIGHT][i]) + beta2 * (pixelvalue[LEFTLEFT][i] + pixelvalue[RIGHTRIGHT][i]); // infoValues[i] =2 * pixelvalue[CENTER][i] + ( pixelvalue[LEFT][i] + pixelvalue[RIGHT][i] ); } // memmove(pixelvalue, pixelvalue + 1, 4*sizeof(float[6])); for (int i = 0; i < 5; i++) { memcpy(pixelvalue[i], pixelvalue[i+1], 6*sizeof(float)); } ++hitDevice; ++hitinfoDevice; } hitDevice.nextRow(); hitinfoDevice.nextRow(); } } KisTransaction b("", infoDevice); { KisVLineConstIteratorPixel vitinfoDeviceRead = infoDevice-> createVLineConstIterator(rect.left() + 4, rect.top(), rect.height()); KisVLineIteratorPixel vitinfoDevice = infoDevice-> createVLineIterator(rect.left() + 4, rect.top() + 2, rect.height() - 4); float infoValue[6][6]; dbgPlugins << " vertical blur"; /* Vertical computation of derivatives */ for (int x = rect.left() + 4; x < rect.right() - 4; x++) { memcpy(infoValue[TOPTOP], vitinfoDeviceRead.oldRawData(), 6*sizeof(float)); ++vitinfoDeviceRead; memcpy(infoValue[TOP], vitinfoDeviceRead.oldRawData(), 6*sizeof(float)); ++vitinfoDeviceRead; memcpy(infoValue[CENTER], vitinfoDeviceRead.oldRawData(), 6*sizeof(float)); ++vitinfoDeviceRead; memcpy(infoValue[BOTTOM], vitinfoDeviceRead.oldRawData(), 6*sizeof(float)); ++vitinfoDeviceRead; while (!vitinfoDevice.isDone()) { memcpy(infoValue[BOTTOMBOTTOM], vitinfoDeviceRead.oldRawData(), 6*sizeof(float)); float* dst = reinterpret_cast<float*>(vitinfoDevice.rawData()); for (int i = 0; i < 5; i++) { dst[i] = beta0 * infoValue[CENTER][i] + beta1 * (infoValue[BOTTOM][i] + infoValue[TOP][i]) + beta2 * (infoValue[TOPTOP][i] + infoValue[BOTTOMBOTTOM][i]); // dst[i] = (2*infoValue[CENTER][i] + ( infoValue[BOTTOM][i] + infoValue[TOP][i] )) / 16; } // memmove(infoValue, infoValue + 1, 4*sizeof(float[6])); for (int i = 0; i < 5; i++) { memcpy(infoValue[i], infoValue[i+1], 6*sizeof(float)); } ++vitinfoDeviceRead; ++vitinfoDevice; } vitinfoDeviceRead.nextCol(); vitinfoDevice.nextCol(); } } #endif #if 0 KisTransaction("", infoDevice); dbgPlugins << " Blur"; { // Compute the blur mask KisAutobrushShape* kas = new KisAutobrushCircleShape(5, 5, 2, 2); QImage mask; kas->createBrush(&mask); KisKernelSP kernel = KisKernel::fromQImage(mask); // Apply the convolution to xxDevice KisConvolutionPainter infoDevicePainter(infoDevice); infoDevicePainter.beginTransaction("bouuh"); infoDevicePainter.applyMatrix(kernel, 2, 2, rect.width() - 4, rect.height() - 4, BORDER_REPEAT); delete kas; } #endif dbgPlugins << " compute curvatures"; // Compute the curvatures { KisRectIteratorPixel vitinfoDeviceRect = infoDevice->createRectIterator(2, 0, rect.width() - 2, rect.height() - 2); for (;!vitinfoDeviceRect.isDone(); ++vitinfoDeviceRect) { float* infoValue = reinterpret_cast<float*>(vitinfoDeviceRect.rawData()); float det = infoValue[INFO_XX] * infoValue[INFO_YY] - infoValue[INFO_XY] * infoValue[INFO_XY]; float trace = infoValue[INFO_XX] + infoValue[INFO_YY]; float temp = sqrt(trace * trace - 4 * det); infoValue[ INFO_HIGH ] = 0.5 * (trace + temp); infoValue[ INFO_LOW ] = 0.5 * (trace - temp); if (infoValue[ INFO_HIGH ] < infoValue[ INFO_LOW ]) { float a = infoValue[ INFO_HIGH ]; infoValue[ INFO_HIGH ] = infoValue[ INFO_LOW ]; infoValue[ INFO_LOW ] = a; } // dbgPlugins << vitinfoDeviceRect.x() <<"" << vitinfoDeviceRect.y() <<"" << infoValue[INFO_XX] <<"" << infoValue[INFO_YY] <<"" << infoValue[INFO_XY] <<"" << infoValue[INFO_HIGH] <<"" << infoValue[INFO_LOW] <<"" << trace <<"" << temp <<"" << det; } } HarrisPoints zones(5, 5, rect.width(), rect.height(), FEATURES_QUANTITY); // Detect Harris Points { int margin = 8; KisHLineIterator hitinfoDevice = infoDevice-> createHLineIterator(margin, margin, rect.width() - 2 * margin); for (int y = margin + rect.top(); y < rect.bottom() - margin; y++) { for (int x = margin + rect.left(); x < rect.right() - margin; x++, ++hitinfoDevice) { float* infoValue = reinterpret_cast<float*>(hitinfoDevice.rawData()); float low = infoValue[ INFO_LOW ]; // dbgPlugins << low; if (low > THRESHOLD_LAMBDA) { KisRectIteratorPixel vitinfoDeviceRect = infoDevice->createRectIterator(x - 1, y - 1, 3, 3); bool greater = true; for (;!vitinfoDeviceRect.isDone(); ++vitinfoDeviceRect) { if (reinterpret_cast<float*>(vitinfoDeviceRect.rawData())[ INFO_LOW ] > low) { greater = false; break; } } if (greater) { // dbgPlugins <<"new point"; HarrisPoint* hp = new HarrisPoint(x, y, infoValue[INFO_INTENSITY], infoValue[INFO_HIGH], infoValue[INFO_LOW], device); #if 0 points.push_back(hp); #endif #if 0 if (points.empty()) { points.push_back(hp); } else { if (points.size() >= FEATURES_QUANTITY && hp->low() > static_cast<HarrisPoint*>(points.back())->low()) { // remove last element, the totalNumber stay equal to FEATURES_QUANTITY points.pop_back(); } if (points.size() != FEATURES_QUANTITY) { lInterestPoints::iterator it; if (hp->low() < static_cast<HarrisPoint*>(points.back())->low()) { points.push_back(hp); } else { // insert the new corner at his right place bool inserted = false; for (it = points.begin(); it != points.end(); it++) { if (hp->low() >= static_cast<HarrisPoint*>(*it)->low()) { // dbgPlugins <<"insert point"; points.insert(it, hp); inserted = true; break; } } if (!inserted) delete hp; } } else { // hp wasn't added to the list, remove it delete hp; } } #endif #if 1 zones.instertPoint(hp); #endif } } } hitinfoDevice.nextRow(); } } points = zones.points(); dbgPlugins << "Harris detector has found :" << points.size() << " harris points"; delete floatCs; return points; }