void FEMorphology::platformApplyGeneric(PaintingData* paintingData, int yStart, int yEnd)
{
ByteArray* srcPixelArray = paintingData->srcPixelArray;
ByteArray* dstPixelArray = paintingData->dstPixelArray;
const int width = paintingData->width;
const int height = paintingData->height;
const int effectWidth = width * 4;
const int radiusX = paintingData->radiusX;
const int radiusY = paintingData->radiusY;
Vector<unsigned char> extrema;
for (int y = yStart; y < yEnd; ++y) {
int extremaStartY = max(0, y - radiusY);
int extremaEndY = min(height - 1, y + radiusY);
for (unsigned int clrChannel = 0; clrChannel < 4; ++clrChannel) {
extrema.clear();
// Compute extremas for each columns
for (int x = 0; x <= radiusX; ++x) {
unsigned char columnExtrema = srcPixelArray->get(extremaStartY * effectWidth + 4 * x + clrChannel);
for (int eY = extremaStartY + 1; eY < extremaEndY; ++eY) {
unsigned char pixel = srcPixelArray->get(eY * effectWidth + 4 * x + clrChannel);
if ((m_type == FEMORPHOLOGY_OPERATOR_ERODE && pixel <= columnExtrema)
|| (m_type == FEMORPHOLOGY_OPERATOR_DILATE && pixel >= columnExtrema)) {
columnExtrema = pixel;
}
}
extrema.append(columnExtrema);
}
// Kernel is filled, get extrema of next column
for (int x = 0; x < width; ++x) {
const int endX = min(x + radiusX, width - 1);
unsigned char columnExtrema = srcPixelArray->get(extremaStartY * effectWidth + endX * 4 + clrChannel);
for (int i = extremaStartY + 1; i <= extremaEndY; ++i) {
unsigned char pixel = srcPixelArray->get(i * effectWidth + endX * 4 + clrChannel);
if ((m_type == FEMORPHOLOGY_OPERATOR_ERODE && pixel <= columnExtrema)
|| (m_type == FEMORPHOLOGY_OPERATOR_DILATE && pixel >= columnExtrema))
columnExtrema = pixel;
}
if (x - radiusX >= 0)
extrema.remove(0);
if (x + radiusX <= width)
extrema.append(columnExtrema);
unsigned char entireExtrema = extrema[0];
for (unsigned kernelIndex = 1; kernelIndex < extrema.size(); ++kernelIndex) {
if ((m_type == FEMORPHOLOGY_OPERATOR_ERODE && extrema[kernelIndex] <= entireExtrema)
|| (m_type == FEMORPHOLOGY_OPERATOR_DILATE && extrema[kernelIndex] >= entireExtrema))
entireExtrema = extrema[kernelIndex];
}
dstPixelArray->set(y * effectWidth + 4 * x + clrChannel, entireExtrema);
}
}
}
}
void RenderSVGResourceMasker::drawContentIntoMaskImage(MaskerData* maskerData, const SVGMaskElement* maskElement, RenderObject* object)
{
GraphicsContext* maskImageContext = maskerData->maskImage->context();
ASSERT(maskImageContext);
// Eventually adjust the mask image context according to the target objectBoundingBox.
AffineTransform maskContentTransformation;
if (maskElement->maskContentUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
FloatRect objectBoundingBox = object->objectBoundingBox();
maskContentTransformation.translate(objectBoundingBox.x(), objectBoundingBox.y());
maskContentTransformation.scaleNonUniform(objectBoundingBox.width(), objectBoundingBox.height());
maskImageContext->concatCTM(maskContentTransformation);
}
// Draw the content into the ImageBuffer.
for (Node* node = maskElement->firstChild(); node; node = node->nextSibling()) {
RenderObject* renderer = node->renderer();
if (!node->isSVGElement() || !static_cast<SVGElement*>(node)->isStyled() || !renderer)
continue;
RenderStyle* style = renderer->style();
if (!style || style->display() == NONE || style->visibility() != VISIBLE)
continue;
SVGImageBufferTools::renderSubtreeToImageBuffer(maskerData->maskImage.get(), renderer, maskContentTransformation);
}
maskImageContext->restore();
#if !PLATFORM(CG)
maskerData->maskImage->transformColorSpace(ColorSpaceDeviceRGB, ColorSpaceLinearRGB);
#endif
// Create the luminance mask.
IntRect maskImageRect(IntPoint(), maskerData->maskImage->size());
RefPtr<ImageData> imageData = maskerData->maskImage->getUnmultipliedImageData(maskImageRect);
ByteArray* srcPixelArray = imageData->data()->data();
unsigned pixelArrayLength = srcPixelArray->length();
for (unsigned pixelOffset = 0; pixelOffset < pixelArrayLength; pixelOffset += 4) {
unsigned char a = srcPixelArray->get(pixelOffset + 3);
if (!a)
continue;
unsigned char r = srcPixelArray->get(pixelOffset);
unsigned char g = srcPixelArray->get(pixelOffset + 1);
unsigned char b = srcPixelArray->get(pixelOffset + 2);
double luma = (r * 0.2125 + g * 0.7154 + b * 0.0721) * ((double)a / 255.0);
srcPixelArray->set(pixelOffset + 3, luma);
}
maskerData->maskImage->putUnmultipliedImageData(imageData.get(), maskImageRect, IntPoint());
}
void FEComponentTransfer::platformApplySoftware()
{
FilterEffect* in = inputEffect(0);
ByteArray* pixelArray = createUnmultipliedImageResult();
if (!pixelArray)
return;
unsigned char rValues[256], gValues[256], bValues[256], aValues[256];
for (unsigned i = 0; i < 256; ++i)
rValues[i] = gValues[i] = bValues[i] = aValues[i] = i;
unsigned char* tables[] = { rValues, gValues, bValues, aValues };
ComponentTransferFunction transferFunction[] = {m_redFunc, m_greenFunc, m_blueFunc, m_alphaFunc};
TransferType callEffect[] = {identity, identity, table, discrete, linear, gamma};
for (unsigned channel = 0; channel < 4; channel++) {
ASSERT(static_cast<size_t>(transferFunction[channel].type) < WTF_ARRAY_LENGTH(callEffect));
(*callEffect[transferFunction[channel].type])(tables[channel], transferFunction[channel]);
}
IntRect drawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
in->copyUnmultipliedImage(pixelArray, drawingRect);
unsigned pixelArrayLength = pixelArray->length();
for (unsigned pixelOffset = 0; pixelOffset < pixelArrayLength; pixelOffset += 4) {
for (unsigned channel = 0; channel < 4; ++channel) {
unsigned char c = pixelArray->get(pixelOffset + channel);
pixelArray->set(pixelOffset + channel, tables[channel][c]);
}
}
}
void FEComponentTransfer::apply()
{
FilterEffect* in = inputEffect(0);
in->apply();
if (!in->resultImage())
return;
if (!effectContext())
return;
unsigned char rValues[256], gValues[256], bValues[256], aValues[256];
for (unsigned i = 0; i < 256; ++i)
rValues[i] = gValues[i] = bValues[i] = aValues[i] = i;
unsigned char* tables[] = { rValues, gValues, bValues, aValues };
ComponentTransferFunction transferFunction[] = {m_redFunc, m_greenFunc, m_blueFunc, m_alphaFunc};
TransferType callEffect[] = {identity, identity, table, discrete, linear, gamma};
for (unsigned channel = 0; channel < 4; channel++)
(*callEffect[transferFunction[channel].type])(tables[channel], transferFunction[channel]);
IntRect drawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
RefPtr<ImageData> imageData = in->resultImage()->getUnmultipliedImageData(drawingRect);
ByteArray* pixelArray = imageData->data()->data();
unsigned pixelArrayLength = pixelArray->length();
for (unsigned pixelOffset = 0; pixelOffset < pixelArrayLength; pixelOffset += 4) {
for (unsigned channel = 0; channel < 4; ++channel) {
unsigned char c = pixelArray->get(pixelOffset + channel);
pixelArray->set(pixelOffset + channel, tables[channel][c]);
}
}
resultImage()->putUnmultipliedImageData(imageData.get(), IntRect(IntPoint(), resultImage()->size()), IntPoint());
}
int32_t StringUtils::toUTF8(const wchar_t* unicode, int32_t length, ByteArray utf8)
{
if (length == 0)
return 0;
UTF8Encoder utf8Encoder(unicode, unicode + length);
int32_t encodeLength = utf8Encoder.encode(utf8.get(), utf8.size());
return encodeLength == Reader::READER_EOF ? 0 : encodeLength;
}
virtual bool incrementToken()
{
if (input->incrementToken())
{
String payloadData = L"pos: " + StringUtils::toString(pos);
ByteArray data = ByteArray::newInstance(payloadData.length() * sizeof(wchar_t));
std::wcsncpy((wchar_t*)data.get(), payloadData.c_str(), payloadData.length());
payloadAttr->setPayload(newLucene<Payload>(data));
int32_t posIncr = i % 2 == 1 ? 1 : 0;
posIncrAttr->setPositionIncrement(posIncr);
pos += posIncr;
++i;
return true;
}
else
return false;
}
void Buffer::enqueue( const ByteArray &s ) throw( KGD::Exception::Generic )
{
this->enqueue( s.get(), s.size() );
}
/// Builds an index with payloads in the given Directory and performs different
/// tests to verify the payload encoding
static void encodingTest(const DirectoryPtr& dir) {
PayloadAnalyzerPtr analyzer = newLucene<PayloadAnalyzer>();
IndexWriterPtr writer = newLucene<IndexWriter>(dir, analyzer, true, IndexWriter::MaxFieldLengthLIMITED);
// should be in sync with value in TermInfosWriter
int32_t skipInterval = 16;
int32_t numTerms = 5;
String fieldName = L"f1";
int32_t numDocs = skipInterval + 1;
// create content for the test documents with just a few terms
Collection<TermPtr> terms = generateTerms(fieldName, numTerms);
StringStream sb;
for (Collection<TermPtr>::iterator term = terms.begin(); term != terms.end(); ++term) {
sb << (*term)->text() << L" ";
}
String content = sb.str();
int32_t payloadDataLength = numTerms * numDocs * 2 + numTerms * numDocs * (numDocs - 1) / 2;
ByteArray payloadData = generateRandomData(payloadDataLength);
DocumentPtr d = newLucene<Document>();
d->add(newLucene<Field>(fieldName, content, Field::STORE_NO, Field::INDEX_ANALYZED));
// add the same document multiple times to have the same payload lengths for all
// occurrences within two consecutive skip intervals
int32_t offset = 0;
for (int32_t i = 0; i < 2 * numDocs; ++i) {
analyzer->setPayloadData(fieldName, payloadData, offset, 1);
offset += numTerms;
writer->addDocument(d);
}
// make sure we create more than one segment to test merging
writer->commit();
for (int32_t i = 0; i < numDocs; ++i) {
analyzer->setPayloadData(fieldName, payloadData, offset, i);
offset += i * numTerms;
writer->addDocument(d);
}
writer->optimize();
// flush
writer->close();
// Verify the index
IndexReaderPtr reader = IndexReader::open(dir, true);
ByteArray verifyPayloadData(ByteArray::newInstance(payloadDataLength));
offset = 0;
Collection<TermPositionsPtr> tps = Collection<TermPositionsPtr>::newInstance(numTerms);
for (int32_t i = 0; i < numTerms; ++i) {
tps[i] = reader->termPositions(terms[i]);
}
while (tps[0]->next()) {
for (int32_t i = 1; i < numTerms; ++i) {
tps[i]->next();
}
int32_t freq = tps[0]->freq();
for (int32_t i = 0; i < freq; ++i) {
for (int32_t j = 0; j < numTerms; ++j) {
tps[j]->nextPosition();
tps[j]->getPayload(verifyPayloadData, offset);
offset += tps[j]->getPayloadLength();
}
}
}
for (int32_t i = 0; i < numTerms; ++i) {
tps[i]->close();
}
EXPECT_TRUE(payloadData.equals(verifyPayloadData));
// test lazy skipping
TermPositionsPtr tp = reader->termPositions(terms[0]);
tp->next();
tp->nextPosition();
// now we don't read this payload
tp->nextPosition();
EXPECT_EQ(1, tp->getPayloadLength());
ByteArray payload = tp->getPayload(ByteArray(), 0);
EXPECT_EQ(payload[0], payloadData[numTerms]);
tp->nextPosition();
// we don't read this payload and skip to a different document
tp->skipTo(5);
tp->nextPosition();
EXPECT_EQ(1, tp->getPayloadLength());
payload = tp->getPayload(ByteArray(), 0);
EXPECT_EQ(payload[0], payloadData[5 * numTerms]);
// Test different lengths at skip points
tp->seek(terms[1]);
tp->next();
tp->nextPosition();
EXPECT_EQ(1, tp->getPayloadLength());
tp->skipTo(skipInterval - 1);
tp->nextPosition();
EXPECT_EQ(1, tp->getPayloadLength());
tp->skipTo(2 * skipInterval - 1);
tp->nextPosition();
EXPECT_EQ(1, tp->getPayloadLength());
tp->skipTo(3 * skipInterval - 1);
tp->nextPosition();
EXPECT_EQ(3 * skipInterval - 2 * numDocs - 1, tp->getPayloadLength());
// Test multiple call of getPayload()
tp->getPayload(ByteArray(), 0);
// it is forbidden to call getPayload() more than once without calling nextPosition()
try {
tp->getPayload(ByteArray(), 0);
} catch (IOException& e) {
EXPECT_TRUE(check_exception(LuceneException::IO)(e));
}
reader->close();
// test long payload
analyzer = newLucene<PayloadAnalyzer>();
writer = newLucene<IndexWriter>(dir, analyzer, true, IndexWriter::MaxFieldLengthLIMITED);
String singleTerm = L"lucene";
d = newLucene<Document>();
d->add(newLucene<Field>(fieldName, singleTerm, Field::STORE_NO, Field::INDEX_ANALYZED));
// add a payload whose length is greater than the buffer size of BufferedIndexOutput
payloadData = generateRandomData(2000);
analyzer->setPayloadData(fieldName, payloadData, 100, 1500);
writer->addDocument(d);
writer->optimize();
// flush
writer->close();
reader = IndexReader::open(dir, true);
tp = reader->termPositions(newLucene<Term>(fieldName, singleTerm));
tp->next();
tp->nextPosition();
verifyPayloadData.resize(tp->getPayloadLength());
tp->getPayload(verifyPayloadData, 0);
ByteArray portion(ByteArray::newInstance(1500));
MiscUtils::arrayCopy(payloadData.get(), 100, portion.get(), 0, 1500);
EXPECT_TRUE(portion.equals(verifyPayloadData));
reader->close();
}
static void generateRandomData(ByteArray data) {
std::generate(data.get(), data.get() + data.size(), rand);
}
