mirror of
https://github.com/JakubMelka/PDF4QT.git
synced 2025-06-05 21:59:17 +02:00
4042 lines
161 KiB
C++
4042 lines
161 KiB
C++
// Copyright (C) 2020-2022 Jakub Melka
|
|
//
|
|
// This file is part of PDF4QT.
|
|
//
|
|
// PDF4QT is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// with the written consent of the copyright owner, any later version.
|
|
//
|
|
// PDF4QT is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with PDF4QT. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
#include "pdftransparencyrenderer.h"
|
|
#include "pdfdocument.h"
|
|
#include "pdfcms.h"
|
|
#include "pdfexecutionpolicy.h"
|
|
#include "pdfimage.h"
|
|
#include "pdfpattern.h"
|
|
#include "pdfdbgheap.h"
|
|
|
|
#include <iterator>
|
|
|
|
namespace pdf
|
|
{
|
|
|
|
PDFFloatBitmap::PDFFloatBitmap() :
|
|
m_width(0),
|
|
m_height(0),
|
|
m_pixelSize(0)
|
|
{
|
|
|
|
}
|
|
|
|
PDFFloatBitmap::PDFFloatBitmap(size_t width, size_t height, PDFPixelFormat format) :
|
|
m_format(format),
|
|
m_width(width),
|
|
m_height(height),
|
|
m_pixelSize(format.getChannelCount())
|
|
{
|
|
Q_ASSERT(format.isValid());
|
|
|
|
m_data.resize(format.calculateBitmapDataLength(width, height), static_cast<PDFColorComponent>(0.0f));
|
|
|
|
if (m_format.hasActiveColorMask())
|
|
{
|
|
m_activeColorMask.resize(width * height, 0);
|
|
}
|
|
}
|
|
|
|
PDFColorBuffer PDFFloatBitmap::getPixel(size_t x, size_t y)
|
|
{
|
|
Q_ASSERT(x < m_width);
|
|
Q_ASSERT(y < m_height);
|
|
|
|
const size_t index = getPixelIndex(x, y);
|
|
return PDFColorBuffer(m_data.data() + index, m_pixelSize);
|
|
}
|
|
|
|
PDFConstColorBuffer PDFFloatBitmap::getPixel(size_t x, size_t y) const
|
|
{
|
|
Q_ASSERT(x < m_width);
|
|
Q_ASSERT(y < m_height);
|
|
|
|
const size_t index = getPixelIndex(x, y);
|
|
return PDFConstColorBuffer(m_data.data() + index, m_pixelSize);
|
|
}
|
|
|
|
PDFColorBuffer PDFFloatBitmap::getPixels()
|
|
{
|
|
return PDFColorBuffer(m_data.data(), m_data.size());
|
|
}
|
|
|
|
PDFColorComponent PDFFloatBitmap::getPixelInkCoverage(size_t x, size_t y) const
|
|
{
|
|
PDFConstColorBuffer buffer = getPixel(x, y);
|
|
|
|
const uint8_t colorChannelIndexStart = m_format.getColorChannelIndexStart();
|
|
const uint8_t colorChannelIndexEnd = m_format.getColorChannelIndexEnd();
|
|
|
|
PDFColorComponent inkCoverage = 0.0;
|
|
for (uint8_t i = colorChannelIndexStart; i < colorChannelIndexEnd; ++i)
|
|
{
|
|
inkCoverage += buffer[i];
|
|
}
|
|
|
|
return inkCoverage;
|
|
}
|
|
|
|
PDFFloatBitmap PDFFloatBitmap::getInkCoverageBitmap() const
|
|
{
|
|
PDFFloatBitmap result(getWidth(), getHeight(), PDFPixelFormat::createFormat(1, 0, false, true, false));
|
|
|
|
for (size_t y = 0; y < getHeight(); ++y)
|
|
{
|
|
for (size_t x = 0; x < getWidth(); ++x)
|
|
{
|
|
PDFColorComponent coverage = getPixelInkCoverage(x, y);
|
|
PDFColorBuffer targetProcessColorBuffer = result.getPixel(x, y);
|
|
targetProcessColorBuffer[0] = coverage;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
const PDFColorComponent* PDFFloatBitmap::begin() const
|
|
{
|
|
return m_data.data();
|
|
}
|
|
|
|
const PDFColorComponent* PDFFloatBitmap::end() const
|
|
{
|
|
return m_data.data() + m_data.size();
|
|
}
|
|
|
|
PDFColorComponent* PDFFloatBitmap::begin()
|
|
{
|
|
return m_data.data();
|
|
}
|
|
|
|
PDFColorComponent* PDFFloatBitmap::end()
|
|
{
|
|
return m_data.data() + m_data.size();
|
|
}
|
|
|
|
void PDFFloatBitmap::makeTransparent()
|
|
{
|
|
if (m_format.hasShapeChannel())
|
|
{
|
|
fillChannel(m_format.getShapeChannelIndex(), 0.0f);
|
|
}
|
|
|
|
if (m_format.hasOpacityChannel())
|
|
{
|
|
fillChannel(m_format.getOpacityChannelIndex(), 0.0f);
|
|
}
|
|
}
|
|
|
|
void PDFFloatBitmap::makeOpaque()
|
|
{
|
|
if (m_format.hasShapeChannel())
|
|
{
|
|
fillChannel(m_format.getShapeChannelIndex(), 1.0f);
|
|
}
|
|
|
|
if (m_format.hasOpacityChannel())
|
|
{
|
|
fillChannel(m_format.getOpacityChannelIndex(), 1.0f);
|
|
}
|
|
}
|
|
|
|
void PDFFloatBitmap::makeColorBlack()
|
|
{
|
|
fillProcessColorChannels(m_format.hasProcessColorsSubtractive() ? 1.0 : 0.0);
|
|
}
|
|
|
|
void PDFFloatBitmap::makeColorWhite()
|
|
{
|
|
fillProcessColorChannels(m_format.hasProcessColorsSubtractive() ? 0.0 : 1.0);
|
|
}
|
|
|
|
size_t PDFFloatBitmap::getPixelIndex(size_t x, size_t y) const
|
|
{
|
|
return (y * m_width + x) * m_pixelSize;
|
|
}
|
|
|
|
uint32_t PDFFloatBitmap::getPixelActiveColorMask(size_t x, size_t y) const
|
|
{
|
|
Q_ASSERT(hasActiveColorMask());
|
|
return m_activeColorMask[y * m_width + x];
|
|
}
|
|
|
|
void PDFFloatBitmap::markPixelActiveColorMask(size_t x, size_t y, uint32_t activeColorMask)
|
|
{
|
|
Q_ASSERT(hasActiveColorMask());
|
|
m_activeColorMask[y * m_width + x] |= activeColorMask;
|
|
}
|
|
|
|
void PDFFloatBitmap::setPixelActiveColorMask(size_t x, size_t y, uint32_t activeColorMask)
|
|
{
|
|
Q_ASSERT(hasActiveColorMask());
|
|
m_activeColorMask[y * m_width + x] = activeColorMask;
|
|
}
|
|
|
|
void PDFFloatBitmap::setAllColorActive()
|
|
{
|
|
std::fill(m_activeColorMask.begin(), m_activeColorMask.end(), PDFPixelFormat::getAllColorsMask());
|
|
}
|
|
|
|
void PDFFloatBitmap::setAllColorInactive()
|
|
{
|
|
std::fill(m_activeColorMask.begin(), m_activeColorMask.end(), 0);
|
|
}
|
|
|
|
void PDFFloatBitmap::setColorActivity(uint32_t mask)
|
|
{
|
|
std::fill(m_activeColorMask.begin(), m_activeColorMask.end(), mask);
|
|
}
|
|
|
|
QImage PDFFloatBitmap::getChannelImage(uint8_t channelIndex) const
|
|
{
|
|
if (channelIndex >= getPixelSize())
|
|
{
|
|
return QImage();
|
|
}
|
|
|
|
QImage image(int(getWidth()), int(getHeight()), QImage::Format_Grayscale8);
|
|
|
|
for (int y = 0; y < image.height(); ++y)
|
|
{
|
|
uchar* line = image.scanLine(y);
|
|
for (int x = 0; x < image.width(); ++x)
|
|
{
|
|
PDFConstColorBuffer buffer = getPixel(x, y);
|
|
line[x] = qRound(buffer[channelIndex] * 255);
|
|
}
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
PDFFloatBitmap PDFFloatBitmap::extractProcessColors() const
|
|
{
|
|
PDFPixelFormat format = PDFPixelFormat::createFormat(m_format.getProcessColorChannelCount(), 0, false, m_format.hasProcessColorsSubtractive(), false);
|
|
PDFFloatBitmap result(getWidth(), getHeight(), format);
|
|
|
|
for (size_t x = 0; x < getWidth(); ++x)
|
|
{
|
|
for (size_t y = 0; y < getHeight(); ++y)
|
|
{
|
|
PDFConstColorBuffer sourceProcessColorBuffer = getPixel(x, y);
|
|
PDFColorBuffer targetProcessColorBuffer = result.getPixel(x, y);
|
|
|
|
Q_ASSERT(sourceProcessColorBuffer.size() >= targetProcessColorBuffer.size());
|
|
std::copy(sourceProcessColorBuffer.cbegin(), std::next(sourceProcessColorBuffer.cbegin(), targetProcessColorBuffer.size()), targetProcessColorBuffer.begin());
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
PDFFloatBitmap PDFFloatBitmap::extractSpotChannel(uint8_t channel) const
|
|
{
|
|
PDFPixelFormat format = PDFPixelFormat::createFormat(0, 1, false, m_format.hasProcessColorsSubtractive(), false);
|
|
PDFFloatBitmap result(getWidth(), getHeight(), format);
|
|
|
|
Q_ASSERT(m_format.hasSpotColors());
|
|
Q_ASSERT(m_format.getSpotColorChannelIndexStart() <= channel);
|
|
Q_ASSERT(m_format.getSpotColorChannelIndexEnd() > channel);
|
|
|
|
for (size_t x = 0; x < getWidth(); ++x)
|
|
{
|
|
for (size_t y = 0; y < getHeight(); ++y)
|
|
{
|
|
PDFConstColorBuffer sourceProcessColorBuffer = getPixel(x, y);
|
|
PDFColorBuffer targetProcessColorBuffer = result.getPixel(x, y);
|
|
|
|
targetProcessColorBuffer[0] = sourceProcessColorBuffer[channel];
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
PDFFloatBitmap PDFFloatBitmap::extractOpacityChannel() const
|
|
{
|
|
PDFFloatBitmap result(getWidth(), getHeight(), PDFPixelFormat::createOpacityMask());
|
|
|
|
if (m_format.hasOpacityChannel())
|
|
{
|
|
const uint8_t opacityChannel = m_format.getOpacityChannelIndex();
|
|
for (size_t x = 0; x < getWidth(); ++x)
|
|
{
|
|
for (size_t y = 0; y < getHeight(); ++y)
|
|
{
|
|
PDFConstColorBuffer sourceProcessColorBuffer = getPixel(x, y);
|
|
PDFColorBuffer targetProcessColorBuffer = result.getPixel(x, y);
|
|
|
|
targetProcessColorBuffer[0] = sourceProcessColorBuffer[opacityChannel];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result.makeOpaque();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
PDFFloatBitmap PDFFloatBitmap::extractLuminosityChannel() const
|
|
{
|
|
PDFFloatBitmap result(getWidth(), getHeight(), PDFPixelFormat::createOpacityMask());
|
|
|
|
const uint8_t sourceChannelIndex = m_format.getProcessColorChannelIndexStart();
|
|
switch (m_format.getProcessColorChannelCount())
|
|
{
|
|
case 1:
|
|
{
|
|
for (size_t x = 0; x < getWidth(); ++x)
|
|
{
|
|
for (size_t y = 0; y < getHeight(); ++y)
|
|
{
|
|
PDFConstColorBuffer sourceProcessColorBuffer = getPixel(x, y);
|
|
PDFColorBuffer targetProcessColorBuffer = result.getPixel(x, y);
|
|
|
|
targetProcessColorBuffer[0] = PDFBlendFunction::getLuminosity(PDFGray(sourceProcessColorBuffer[sourceChannelIndex]));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
for (size_t x = 0; x < getWidth(); ++x)
|
|
{
|
|
for (size_t y = 0; y < getHeight(); ++y)
|
|
{
|
|
PDFConstColorBuffer sourceProcessColorBuffer = getPixel(x, y);
|
|
PDFColorBuffer targetProcessColorBuffer = result.getPixel(x, y);
|
|
|
|
PDFColorComponent r = sourceProcessColorBuffer[sourceChannelIndex + 0];
|
|
PDFColorComponent g = sourceProcessColorBuffer[sourceChannelIndex + 1];
|
|
PDFColorComponent b = sourceProcessColorBuffer[sourceChannelIndex + 2];
|
|
targetProcessColorBuffer[0] = PDFBlendFunction::getLuminosity(PDFRGB{ r, g, b });
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 4:
|
|
{
|
|
for (size_t x = 0; x < getWidth(); ++x)
|
|
{
|
|
for (size_t y = 0; y < getHeight(); ++y)
|
|
{
|
|
PDFConstColorBuffer sourceProcessColorBuffer = getPixel(x, y);
|
|
PDFColorBuffer targetProcessColorBuffer = result.getPixel(x, y);
|
|
|
|
PDFColorComponent _c = sourceProcessColorBuffer[sourceChannelIndex + 0];
|
|
PDFColorComponent _m = sourceProcessColorBuffer[sourceChannelIndex + 1];
|
|
PDFColorComponent _y = sourceProcessColorBuffer[sourceChannelIndex + 2];
|
|
PDFColorComponent _k = sourceProcessColorBuffer[sourceChannelIndex + 3];
|
|
targetProcessColorBuffer[0] = PDFBlendFunction::getLuminosity(PDFCMYK{ _c, _m, _y, _k });
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
result.makeOpaque();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (m_format.hasOpacityChannel())
|
|
{
|
|
const uint8_t opacityChannel = m_format.getOpacityChannelIndex();
|
|
for (size_t x = 0; x < getWidth(); ++x)
|
|
{
|
|
for (size_t y = 0; y < getHeight(); ++y)
|
|
{
|
|
PDFConstColorBuffer sourceProcessColorBuffer = getPixel(x, y);
|
|
PDFColorBuffer targetProcessColorBuffer = result.getPixel(x, y);
|
|
|
|
targetProcessColorBuffer[0] = sourceProcessColorBuffer[opacityChannel];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result.makeOpaque();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void PDFFloatBitmap::copyChannel(const PDFFloatBitmap& sourceBitmap, uint8_t channelFrom, uint8_t channelTo)
|
|
{
|
|
Q_ASSERT(getWidth() == sourceBitmap.getWidth());
|
|
Q_ASSERT(getHeight() == sourceBitmap.getHeight());
|
|
|
|
for (size_t x = 0; x < getWidth(); ++x)
|
|
{
|
|
for (size_t y = 0; y < getHeight(); ++y)
|
|
{
|
|
PDFConstColorBuffer sourceProcessColorBuffer = sourceBitmap.getPixel(x, y);
|
|
PDFColorBuffer targetProcessColorBuffer = getPixel(x, y);
|
|
|
|
targetProcessColorBuffer[channelTo] = sourceProcessColorBuffer[channelFrom];
|
|
}
|
|
}
|
|
}
|
|
|
|
PDFFloatBitmap PDFFloatBitmap::resize(size_t width, size_t height, Qt::TransformationMode mode) const
|
|
{
|
|
if (width == 0 || height == 0)
|
|
{
|
|
return PDFFloatBitmap();
|
|
}
|
|
|
|
PDFFloatBitmap bitmap(width, height, getPixelFormat());
|
|
|
|
const qreal pixelRatioH = qreal(getWidth()) / qreal(width);
|
|
const qreal pixelRatioV = qreal(getHeight()) / qreal(height);
|
|
|
|
switch (mode)
|
|
{
|
|
case Qt::FastTransformation:
|
|
{
|
|
for (size_t yDest = 0; yDest < height; ++yDest)
|
|
{
|
|
for (size_t xDest = 0; xDest < width; ++xDest)
|
|
{
|
|
size_t xSrc = qFloor(pixelRatioH * xDest);
|
|
size_t ySrc = qFloor(pixelRatioV * yDest);
|
|
|
|
PDFConstColorBuffer srcBuffer = getPixel(xSrc, ySrc);
|
|
PDFColorBuffer destBuffer = bitmap.getPixel(xDest, yDest);
|
|
|
|
Q_ASSERT(srcBuffer.size() == destBuffer.size());
|
|
|
|
// Just copy the color
|
|
std::copy(srcBuffer.cbegin(), srcBuffer.cend(), destBuffer.begin());
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case Qt::SmoothTransformation:
|
|
{
|
|
const size_t pixelCount = getPixelSize();
|
|
std::vector<PDFColorComponent> buffer(pixelCount, 0.0f);
|
|
|
|
for (size_t yDest = 0; yDest < height; ++yDest)
|
|
{
|
|
for (size_t xDest = 0; xDest < width; ++xDest)
|
|
{
|
|
const qreal xOrdinateStart = pixelRatioH * xDest;
|
|
const qreal xOrdinateEnd = xOrdinateStart + pixelRatioH;
|
|
const qreal yOrdinateStart = pixelRatioV * yDest;
|
|
const qreal yOrdinateEnd = yOrdinateStart + pixelRatioV;
|
|
|
|
size_t xSrcStart = qFloor(xOrdinateStart);
|
|
size_t xSrcEnd = qMin<qreal>(qCeil(xOrdinateEnd), getWidth());
|
|
size_t ySrcStart = qFloor(yOrdinateStart);
|
|
size_t ySrcEnd = qMin<qreal>(qCeil(yOrdinateEnd), getHeight());
|
|
|
|
std::fill(buffer.begin(), buffer.end(), 0.0f);
|
|
|
|
qreal sumPortion = 0.0;
|
|
|
|
for (size_t i = xSrcStart; i < xSrcEnd; ++i)
|
|
{
|
|
const qreal xSubpixelStart = qMax(qreal(i), xOrdinateStart);
|
|
const qreal xSubpixelEnd = qMin(qreal(i + 1), xOrdinateEnd);
|
|
const qreal xPortion = xSubpixelEnd - xSubpixelStart;
|
|
|
|
for (size_t j = ySrcStart; j < ySrcEnd; ++j)
|
|
{
|
|
const qreal ySubpixelStart = qMax(qreal(j), yOrdinateStart);
|
|
const qreal ySubpixelEnd = qMin(qreal(j + 1), yOrdinateEnd);
|
|
const qreal yPortion = ySubpixelEnd - ySubpixelStart;
|
|
const qreal pixelPortion = xPortion * yPortion;
|
|
|
|
PDFConstColorBuffer srcBuffer = getPixel(i, j);
|
|
|
|
for (size_t k = 0; k < pixelCount; ++k)
|
|
{
|
|
buffer[k] += srcBuffer[k] * pixelPortion;
|
|
}
|
|
|
|
sumPortion += pixelPortion;
|
|
}
|
|
}
|
|
|
|
// Compute weighed sum of pixels
|
|
const qreal coefficient = qFuzzyIsNull(sumPortion) ? 0.0 : 1.0 / sumPortion;
|
|
for (size_t k = 0; k < pixelCount; ++k)
|
|
{
|
|
buffer[k] *= coefficient;
|
|
}
|
|
|
|
PDFColorBuffer destBuffer = bitmap.getPixel(xDest, yDest);
|
|
Q_ASSERT(buffer.size() == destBuffer.size());
|
|
std::copy(buffer.cbegin(), buffer.cend(), destBuffer.begin());
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
Q_ASSERT(false);
|
|
break;
|
|
}
|
|
|
|
return bitmap;
|
|
}
|
|
|
|
void PDFFloatBitmap::blend(const PDFFloatBitmap& source,
|
|
PDFFloatBitmap& target,
|
|
const PDFFloatBitmap& backdrop,
|
|
const PDFFloatBitmap& initialBackdrop,
|
|
const PDFFloatBitmap& blendSoftMask,
|
|
bool alphaIsShape,
|
|
PDFColorComponent constantAlpha,
|
|
BlendMode mode,
|
|
bool knockoutGroup,
|
|
OverprintMode overprintMode,
|
|
QRect blendRegion)
|
|
{
|
|
Q_ASSERT(source.getWidth() == target.getWidth());
|
|
Q_ASSERT(source.getHeight() == target.getHeight());
|
|
Q_ASSERT(source.getPixelFormat() == target.getPixelFormat());
|
|
Q_ASSERT(source.getWidth() == blendSoftMask.getWidth());
|
|
Q_ASSERT(source.getHeight() == blendSoftMask.getHeight());
|
|
Q_ASSERT(blendSoftMask.getPixelFormat() == PDFPixelFormat::createOpacityMask());
|
|
|
|
Q_ASSERT(blendRegion.left() >= 0);
|
|
Q_ASSERT(blendRegion.top() >= 0);
|
|
Q_ASSERT(blendRegion.right() < source.getWidth());
|
|
Q_ASSERT(blendRegion.bottom() < source.getHeight());
|
|
|
|
const PDFPixelFormat pixelFormat = source.getPixelFormat();
|
|
const uint8_t shapeChannel = pixelFormat.getShapeChannelIndex();
|
|
const uint8_t opacityChannel = pixelFormat.getOpacityChannelIndex();
|
|
const uint8_t colorChannelStart = pixelFormat.getColorChannelIndexStart();
|
|
const uint8_t colorChannelEnd = pixelFormat.getColorChannelIndexEnd();
|
|
const uint8_t processColorChannelStart = pixelFormat.getProcessColorChannelIndexStart();
|
|
const uint8_t processColorChannelEnd = pixelFormat.getProcessColorChannelIndexEnd();
|
|
const uint8_t spotColorChannelStart = pixelFormat.getSpotColorChannelIndexStart();
|
|
const uint8_t spotColorChannelEnd = pixelFormat.getSpotColorChannelIndexEnd();
|
|
std::vector<PDFColorComponent> B_i(source.getPixelSize(), 0.0f);
|
|
std::vector<BlendMode> channelBlendModes(source.getPixelSize(), mode);
|
|
|
|
// For blending spot colors, only white preserving blend modes are possible.
|
|
// If this is not the case, revert spot color blend mode to normal blending.
|
|
// See 11.7.4.2 of PDF 2.0 specification.
|
|
if (pixelFormat.hasSpotColors() && !PDFBlendModeInfo::isWhitePreserving(mode))
|
|
{
|
|
auto itBegin = std::next(channelBlendModes.begin(), spotColorChannelStart);
|
|
auto itEnd = std::next(channelBlendModes.begin(), spotColorChannelEnd);
|
|
std::fill(itBegin, itEnd, BlendMode::Normal);
|
|
}
|
|
|
|
// Handle overprint mode for normal blend mode. We do not support
|
|
// oveprinting for other blend modes, than normal.
|
|
|
|
auto getBlendModeForPixel = [&source, &channelBlendModes, pixelFormat, overprintMode, mode](size_t x, size_t y, uint8_t channel)
|
|
{
|
|
switch (overprintMode)
|
|
{
|
|
case OverprintMode::NoOveprint:
|
|
break;
|
|
|
|
case OverprintMode::Overprint_Mode_0:
|
|
{
|
|
// Select source color, if channel is active,
|
|
// otherwise select backdrop color.
|
|
|
|
const uint32_t activeColorChannels = source.hasActiveColorMask() ? source.getPixelActiveColorMask(x, y) : PDFPixelFormat::getAllColorsMask();
|
|
uint32_t flag = (static_cast<uint32_t>(1)) << channel;
|
|
if (channelBlendModes[channel] == BlendMode::Normal && !(activeColorChannels & flag))
|
|
{
|
|
// Color channel is inactive
|
|
return BlendMode::Overprint_SelectBackdrop;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case OverprintMode::Overprint_Mode_1:
|
|
{
|
|
// For process colors, select source color, if it is nonzero,
|
|
// otherwise select backdrop. If process color channel is inactive,
|
|
// select backdrop.
|
|
|
|
const uint32_t activeColorChannels = source.hasActiveColorMask() ? source.getPixelActiveColorMask(x, y) : PDFPixelFormat::getAllColorsMask();
|
|
|
|
if (pixelFormat.hasProcessColors() && mode == BlendMode::Normal &&
|
|
channel >= pixelFormat.getProcessColorChannelIndexStart() && channel < pixelFormat.getProcessColorChannelIndexEnd())
|
|
{
|
|
uint32_t flag = (static_cast<uint32_t>(1)) << channel;
|
|
if (!(activeColorChannels & flag))
|
|
{
|
|
// Color channel is inactive
|
|
return BlendMode::Overprint_SelectBackdrop;
|
|
}
|
|
else
|
|
{
|
|
// Color channel is active, but select source color only, if it is nonzero
|
|
return pixelFormat.hasProcessColorsSubtractive() ? BlendMode::Overprint_SelectNonOneSourceOrBackdrop
|
|
: BlendMode::Overprint_SelectNonZeroSourceOrBackdrop;
|
|
}
|
|
}
|
|
|
|
if (pixelFormat.hasSpotColors() && channel >= pixelFormat.getSpotColorChannelIndexStart() && channel < pixelFormat.getSpotColorChannelIndexEnd())
|
|
{
|
|
// For spot colors, select backdrop, if channel is inactive,
|
|
// otherwise select source color.
|
|
|
|
uint32_t flag = (static_cast<uint32_t>(1)) << channel;
|
|
if (channelBlendModes[channel] == BlendMode::Normal && !(activeColorChannels & flag))
|
|
{
|
|
// Color channel is inactive
|
|
return BlendMode::Overprint_SelectBackdrop;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
Q_ASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return channelBlendModes[channel];
|
|
};
|
|
|
|
for (int x = blendRegion.left(); x <= blendRegion.right(); ++x)
|
|
{
|
|
for (int y = blendRegion.top(); y <= blendRegion.bottom(); ++y)
|
|
{
|
|
PDFConstColorBuffer sourceColor = source.getPixel(x, y);
|
|
PDFColorBuffer targetColor = target.getPixel(x, y);
|
|
PDFConstColorBuffer backdropColor = backdrop.getPixel(x, y);
|
|
PDFConstColorBuffer initialBackdropColor = initialBackdrop.getPixel(x, y);
|
|
PDFConstColorBuffer alphaColorBuffer = blendSoftMask.getPixel(x, y);
|
|
|
|
const PDFColorComponent softMaskValue = alphaColorBuffer[0];
|
|
const PDFColorComponent f_j_i = sourceColor[shapeChannel];
|
|
const PDFColorComponent f_m_i = alphaIsShape ? softMaskValue : 1.0f;
|
|
const PDFColorComponent f_k_i = alphaIsShape ? constantAlpha : 1.0f;
|
|
const PDFColorComponent q_m_i = !alphaIsShape ? softMaskValue : 1.0f;
|
|
const PDFColorComponent q_k_i = !alphaIsShape ? constantAlpha : 1.0f;
|
|
const PDFColorComponent f_s_i = f_j_i * f_m_i * f_k_i;
|
|
const PDFColorComponent alpha_j_i = sourceColor[opacityChannel];
|
|
const PDFColorComponent alpha_s_i = alpha_j_i * (f_m_i * q_m_i) * (f_k_i * q_k_i);
|
|
|
|
// Old alpha (alpha_g_i_1) is stored in target (immediate) buffer
|
|
const PDFColorComponent alpha_g_i_1 = targetColor[opacityChannel];
|
|
|
|
// alpha_g_0 == 0.0f according to the specification, otherwise select alpha_g_i_1 from target color
|
|
const PDFColorComponent alpha_g_b = knockoutGroup ? 0.0f : alpha_g_i_1;
|
|
|
|
// alpha_0 is taken from initial backdrop color buffer
|
|
const PDFColorComponent alpha_0 = initialBackdropColor[opacityChannel];
|
|
|
|
// f_g_i_1 is stored in target (immediate) buffer
|
|
const PDFColorComponent f_g_i_1 = targetColor[shapeChannel];
|
|
|
|
// Formulas taken from
|
|
const PDFColorComponent f_g_i = PDFBlendFunction::blend_Union(f_g_i_1, f_s_i);
|
|
const PDFColorComponent alpha_g_i = (1.0f - f_s_i) * alpha_g_i_1 + (f_s_i - alpha_s_i) * alpha_g_b + alpha_s_i;
|
|
const PDFColorComponent alpha_i_1 = PDFBlendFunction::blend_Union(alpha_0, alpha_g_i_1);
|
|
const PDFColorComponent alpha_i = PDFBlendFunction::blend_Union(alpha_0, alpha_g_i);
|
|
|
|
// alpha_b is either alpha_0 (for knockout group) or alpha_i_1
|
|
const PDFColorComponent alpha_b = knockoutGroup ? alpha_0 : alpha_i_1;
|
|
|
|
if (qFuzzyIsNull(alpha_g_i))
|
|
{
|
|
// If alpha_i is zero, then color is undefined, just fill shape/opacity
|
|
targetColor[shapeChannel] = f_g_i;
|
|
targetColor[opacityChannel] = alpha_g_i;
|
|
continue;
|
|
}
|
|
|
|
if (target.hasActiveColorMask())
|
|
{
|
|
const uint32_t activeColorChannels = source.hasActiveColorMask() ? source.getPixelActiveColorMask(x, y) : PDFPixelFormat::getAllColorsMask();
|
|
target.markPixelActiveColorMask(x, y, activeColorChannels);
|
|
}
|
|
|
|
std::fill(B_i.begin(), B_i.end(), 0.0f);
|
|
|
|
// Calculate blended pixel
|
|
if (PDFBlendModeInfo::isSeparable(mode))
|
|
{
|
|
// Separable blend mode - process each color separately
|
|
const bool isProcessColorSubtractive = pixelFormat.hasProcessColorsSubtractive();
|
|
const bool isSpotColorSubtractive = pixelFormat.hasSpotColorsSubtractive();
|
|
|
|
if (pixelFormat.hasProcessColors())
|
|
{
|
|
if (!isProcessColorSubtractive)
|
|
{
|
|
for (uint8_t i = processColorChannelStart; i < processColorChannelEnd; ++i)
|
|
{
|
|
const BlendMode pixelBlendMode = getBlendModeForPixel(x, y, i);
|
|
B_i[i] = PDFBlendFunction::blend(pixelBlendMode, backdropColor[i], sourceColor[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint8_t i = processColorChannelStart; i < processColorChannelEnd; ++i)
|
|
{
|
|
const BlendMode pixelBlendMode = getBlendModeForPixel(x, y, i);
|
|
B_i[i] = 1.0f - PDFBlendFunction::blend(pixelBlendMode, 1.0f - backdropColor[i], 1.0f - sourceColor[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pixelFormat.hasSpotColors())
|
|
{
|
|
|
|
if (!isSpotColorSubtractive)
|
|
{
|
|
for (uint8_t i = spotColorChannelStart; i < spotColorChannelEnd; ++i)
|
|
{
|
|
const BlendMode pixelBlendMode = getBlendModeForPixel(x, y, i);
|
|
B_i[i] = PDFBlendFunction::blend(pixelBlendMode, backdropColor[i], sourceColor[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint8_t i = spotColorChannelStart; i < spotColorChannelEnd; ++i)
|
|
{
|
|
const BlendMode pixelBlendMode = getBlendModeForPixel(x, y, i);
|
|
B_i[i] = 1.0f - PDFBlendFunction::blend(pixelBlendMode, 1.0f - backdropColor[i], 1.0f - sourceColor[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Nonseparable blend mode - process colors together
|
|
if (pixelFormat.hasProcessColors())
|
|
{
|
|
switch (pixelFormat.getProcessColorChannelCount())
|
|
{
|
|
case 1:
|
|
{
|
|
// Gray
|
|
const PDFGray Cb = backdropColor[processColorChannelStart];
|
|
const PDFGray Cs = sourceColor[processColorChannelStart];
|
|
const PDFGray blended = PDFBlendFunction::blend_Nonseparable(mode, Cb, Cs);
|
|
B_i[pixelFormat.getProcessColorChannelIndexStart()] = blended;
|
|
break;
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
// RGB
|
|
const PDFRGB Cb = { backdropColor[processColorChannelStart + 0],
|
|
backdropColor[processColorChannelStart + 1],
|
|
backdropColor[processColorChannelStart + 2] };
|
|
const PDFRGB Cs = { sourceColor[processColorChannelStart + 0],
|
|
sourceColor[processColorChannelStart + 1],
|
|
sourceColor[processColorChannelStart + 2] };
|
|
const PDFRGB blended = PDFBlendFunction::blend_Nonseparable(mode, Cb, Cs);
|
|
B_i[processColorChannelStart + 0] = blended[0];
|
|
B_i[processColorChannelStart + 1] = blended[1];
|
|
B_i[processColorChannelStart + 2] = blended[2];
|
|
break;
|
|
}
|
|
|
|
case 4:
|
|
{
|
|
// CMYK
|
|
const PDFCMYK Cb = { backdropColor[processColorChannelStart + 0],
|
|
backdropColor[processColorChannelStart + 1],
|
|
backdropColor[processColorChannelStart + 2],
|
|
backdropColor[processColorChannelStart + 3] };
|
|
const PDFCMYK Cs = { sourceColor[processColorChannelStart + 0],
|
|
sourceColor[processColorChannelStart + 1],
|
|
sourceColor[processColorChannelStart + 2],
|
|
sourceColor[processColorChannelStart + 3] };
|
|
const PDFCMYK blended = PDFBlendFunction::blend_Nonseparable(mode, Cb, Cs);
|
|
B_i[processColorChannelStart + 0] = blended[0];
|
|
B_i[processColorChannelStart + 1] = blended[1];
|
|
B_i[processColorChannelStart + 2] = blended[2];
|
|
B_i[processColorChannelStart + 3] = blended[3];
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
// This is a serious error. Blended buffer remains unchanged (zero)
|
|
Q_ASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pixelFormat.hasSpotColors())
|
|
{
|
|
const bool isSpotColorSubtractive = pixelFormat.hasSpotColorsSubtractive();
|
|
if (!isSpotColorSubtractive)
|
|
{
|
|
for (uint8_t i = spotColorChannelStart; i < spotColorChannelEnd; ++i)
|
|
{
|
|
const BlendMode pixelBlendMode = getBlendModeForPixel(x, y, i);
|
|
B_i[i] = PDFBlendFunction::blend(pixelBlendMode, backdropColor[i], sourceColor[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint8_t i = spotColorChannelStart; i < spotColorChannelEnd; ++i)
|
|
{
|
|
const BlendMode pixelBlendMode = getBlendModeForPixel(x, y, i);
|
|
B_i[i] = 1.0f - PDFBlendFunction::blend(pixelBlendMode, 1.0f - backdropColor[i], 1.0f - sourceColor[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (uint8_t i = colorChannelStart; i < colorChannelEnd; ++i)
|
|
{
|
|
const PDFColorComponent C_s_i = sourceColor[i];
|
|
const PDFColorComponent C_b = backdropColor[i];
|
|
const PDFColorComponent C_i_1 = targetColor[i];
|
|
|
|
PDFColorComponent C_t = (f_s_i - alpha_s_i) * alpha_b * C_b + alpha_s_i * ((1.0f - alpha_b) * C_s_i + alpha_b * B_i[i]);
|
|
PDFColorComponent C_i = ((1.0f - f_s_i) * alpha_i_1 * C_i_1 + C_t) / alpha_i;
|
|
|
|
targetColor[i] = C_i;
|
|
}
|
|
|
|
targetColor[shapeChannel] = f_g_i;
|
|
targetColor[opacityChannel] = alpha_g_i;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PDFFloatBitmap::blendConvertedSpots(const PDFFloatBitmap& convertedSpotColors)
|
|
{
|
|
Q_ASSERT(convertedSpotColors.getPixelFormat().getProcessColorChannelCount() == m_format.getProcessColorChannelCount());
|
|
|
|
const uint8_t processColorChannelStart = m_format.getProcessColorChannelIndexStart();
|
|
const uint8_t processColorChannelEnd = m_format.getProcessColorChannelIndexEnd();
|
|
|
|
const PDFColorComponent* sourcePixel = convertedSpotColors.begin();
|
|
for (PDFColorComponent* targetPixel = begin(); targetPixel != end(); targetPixel += m_pixelSize, sourcePixel+= convertedSpotColors.getPixelSize())
|
|
{
|
|
for (uint8_t i = processColorChannelStart; i < processColorChannelEnd; ++i)
|
|
{
|
|
if (m_format.hasProcessColorsSubtractive())
|
|
{
|
|
targetPixel[i] = PDFBlendFunction::blend_Union(targetPixel[i], sourcePixel[i]);
|
|
}
|
|
else
|
|
{
|
|
targetPixel[i] = targetPixel[i] * sourcePixel[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void PDFFloatBitmap::fillProcessColorChannels(PDFColorComponent value)
|
|
{
|
|
if (!m_format.hasProcessColors())
|
|
{
|
|
// No process colors
|
|
return;
|
|
}
|
|
|
|
const uint8_t channelStart = m_format.getProcessColorChannelIndexStart();
|
|
const uint8_t channelEnd = m_format.getProcessColorChannelIndexEnd();
|
|
|
|
for (PDFColorComponent* pixel = begin(); pixel != end(); pixel += m_pixelSize)
|
|
{
|
|
std::fill(pixel + channelStart, pixel + channelEnd, value);
|
|
}
|
|
}
|
|
|
|
void PDFFloatBitmap::fillChannel(size_t channel, PDFColorComponent value)
|
|
{
|
|
// Do we have just one channel?
|
|
if (m_format.getChannelCount() == 1)
|
|
{
|
|
Q_ASSERT(channel == 0);
|
|
std::fill(m_data.begin(), m_data.end(), value);
|
|
return;
|
|
}
|
|
|
|
for (PDFColorComponent* pixel = begin(); pixel != end(); pixel += m_pixelSize)
|
|
{
|
|
pixel[channel] = value;
|
|
}
|
|
}
|
|
|
|
PDFFloatBitmap PDFFloatBitmap::createOpaqueSoftMask(size_t width, size_t height)
|
|
{
|
|
PDFFloatBitmap result(width, height, PDFPixelFormat::createOpacityMask());
|
|
result.makeOpaque();
|
|
return result;
|
|
}
|
|
|
|
PDFFloatBitmapWithColorSpace::PDFFloatBitmapWithColorSpace()
|
|
{
|
|
|
|
}
|
|
|
|
PDFFloatBitmapWithColorSpace::PDFFloatBitmapWithColorSpace(size_t width, size_t height, PDFPixelFormat format) :
|
|
PDFFloatBitmap(width, height, format)
|
|
{
|
|
|
|
}
|
|
|
|
PDFFloatBitmapWithColorSpace::PDFFloatBitmapWithColorSpace(size_t width, size_t height, PDFPixelFormat format, PDFColorSpacePointer blendColorSpace) :
|
|
PDFFloatBitmap(width, height, format),
|
|
m_colorSpace(blendColorSpace)
|
|
{
|
|
|
|
}
|
|
|
|
PDFColorSpacePointer PDFFloatBitmapWithColorSpace::getColorSpace() const
|
|
{
|
|
return m_colorSpace;
|
|
}
|
|
|
|
void PDFFloatBitmapWithColorSpace::setColorSpace(const PDFColorSpacePointer& colorSpace)
|
|
{
|
|
m_colorSpace = colorSpace;
|
|
}
|
|
|
|
void PDFFloatBitmapWithColorSpace::convertToColorSpace(const PDFCMS* cms,
|
|
RenderingIntent intent,
|
|
const PDFColorSpacePointer& targetColorSpace,
|
|
PDFRenderErrorReporter* reporter)
|
|
{
|
|
Q_ASSERT(m_colorSpace);
|
|
if (m_colorSpace->equals(targetColorSpace.get()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
const uint8_t targetDeviceColors = static_cast<uint8_t>(targetColorSpace->getColorComponentCount());
|
|
PDFPixelFormat newFormat = getPixelFormat();
|
|
newFormat.setProcessColors(targetDeviceColors);
|
|
newFormat.setProcessColorsSubtractive(targetDeviceColors == 4);
|
|
|
|
PDFFloatBitmap sourceProcessColors = extractProcessColors();
|
|
PDFFloatBitmap targetProcessColors(sourceProcessColors.getWidth(), sourceProcessColors.getHeight(), PDFPixelFormat::createFormat(targetDeviceColors, 0, false, newFormat.hasProcessColorsSubtractive(), newFormat.hasActiveColorMask()));
|
|
|
|
if (!PDFAbstractColorSpace::transform(m_colorSpace.data(), targetColorSpace.data(), cms, intent, sourceProcessColors.getPixels(), targetProcessColors.getPixels(), reporter))
|
|
{
|
|
reporter->reportRenderError(RenderErrorType::Error, PDFTranslationContext::tr("Transformation between blending color space failed."));
|
|
}
|
|
|
|
PDFFloatBitmapWithColorSpace temporary(getWidth(), getHeight(), newFormat, targetColorSpace);
|
|
for (size_t x = 0; x < getWidth(); ++x)
|
|
{
|
|
for (size_t y = 0; y < getHeight(); ++y)
|
|
{
|
|
PDFColorBuffer sourceProcessColorBuffer = targetProcessColors.getPixel(x, y);
|
|
PDFColorBuffer sourceSpotColorAndOpacityBuffer = getPixel(x, y);
|
|
PDFColorBuffer targetBuffer = temporary.getPixel(x, y);
|
|
|
|
Q_ASSERT(sourceProcessColorBuffer.size() <= targetBuffer.size());
|
|
|
|
// Copy process colors
|
|
PDFColorComponent* targetIt = targetBuffer.begin();
|
|
targetIt = std::copy(sourceProcessColorBuffer.cbegin(), sourceProcessColorBuffer.cend(), targetIt);
|
|
|
|
Q_ASSERT(std::distance(targetIt, targetBuffer.end()) == temporary.getPixelFormat().getSpotColorChannelCount() + temporary.getPixelFormat().getAuxiliaryChannelCount());
|
|
|
|
const PDFColorComponent* sourceIt = std::next(sourceSpotColorAndOpacityBuffer.cbegin(), getPixelFormat().getProcessColorChannelCount());
|
|
targetIt = std::copy(sourceIt, sourceSpotColorAndOpacityBuffer.cend(), targetIt);
|
|
|
|
Q_ASSERT(targetIt == targetBuffer.cend());
|
|
}
|
|
}
|
|
|
|
// Simplification - set all color channels active
|
|
temporary.setAllColorActive();
|
|
*this = qMove(temporary);
|
|
}
|
|
|
|
PDFTransparencyRenderer::PDFTransparencyRenderer(const PDFPage* page,
|
|
const PDFDocument* document,
|
|
const PDFFontCache* fontCache,
|
|
const PDFCMS* cms,
|
|
const PDFOptionalContentActivity* optionalContentActivity,
|
|
const PDFInkMapper* inkMapper,
|
|
PDFTransparencyRendererSettings settings,
|
|
QTransform pagePointToDevicePointMatrix) :
|
|
BaseClass(page, document, fontCache, cms, optionalContentActivity, pagePointToDevicePointMatrix, PDFMeshQualitySettings()),
|
|
m_inkMapper(inkMapper),
|
|
m_active(false),
|
|
m_settings(settings)
|
|
{
|
|
m_deviceColorSpace.reset(new PDFDeviceRGBColorSpace());
|
|
m_processColorSpace.reset(new PDFDeviceCMYKColorSpace());
|
|
}
|
|
|
|
void PDFTransparencyRenderer::setDeviceColorSpace(PDFColorSpacePointer colorSpace)
|
|
{
|
|
if (!colorSpace || colorSpace->isBlendColorSpace())
|
|
{
|
|
// Set device color space only, when it is a blend color space
|
|
m_deviceColorSpace = colorSpace;
|
|
}
|
|
}
|
|
|
|
void PDFTransparencyRenderer::setProcessColorSpace(PDFColorSpacePointer colorSpace)
|
|
{
|
|
if (!colorSpace || colorSpace->isBlendColorSpace())
|
|
{
|
|
// Set process color space only, when it is a blend color space
|
|
m_processColorSpace = colorSpace;
|
|
}
|
|
}
|
|
|
|
void PDFTransparencyRenderer::beginPaint(QSize pixelSize)
|
|
{
|
|
Q_ASSERT(!m_active);
|
|
m_active = true;
|
|
|
|
Q_ASSERT(pixelSize.isValid());
|
|
Q_ASSERT(m_deviceColorSpace);
|
|
Q_ASSERT(m_processColorSpace);
|
|
|
|
m_originalProcessBitmap = PDFFloatBitmapWithColorSpace();
|
|
m_transparencyGroupDataStack.clear();
|
|
m_painterStateStack.push(PDFTransparencyPainterState());
|
|
|
|
// Initialize initial opaque soft mask
|
|
PDFFloatBitmap initialSoftMaskBitmap;
|
|
createOpaqueSoftMask(initialSoftMaskBitmap, pixelSize.width(), pixelSize.height());
|
|
m_painterStateStack.top().softMask = PDFTransparencySoftMask(true, qMove(initialSoftMaskBitmap));
|
|
|
|
PDFPixelFormat pixelFormat = PDFPixelFormat::createFormat(uint8_t(m_deviceColorSpace->getColorComponentCount()),
|
|
uint8_t(m_inkMapper->getActiveSpotColorCount()),
|
|
true, m_deviceColorSpace->getColorComponentCount() == 4,
|
|
true);
|
|
|
|
PDFFloatBitmapWithColorSpace paper = PDFFloatBitmapWithColorSpace(pixelSize.width(), pixelSize.height(), pixelFormat, m_deviceColorSpace);
|
|
paper.makeColorWhite();
|
|
|
|
PDFTransparencyGroupPainterData deviceGroup;
|
|
deviceGroup.alphaIsShape = getGraphicState()->getAlphaIsShape();
|
|
deviceGroup.alphaStroke = getGraphicState()->getAlphaStroking();
|
|
deviceGroup.alphaFill = getGraphicState()->getAlphaFilling();
|
|
deviceGroup.blendMode = getGraphicState()->getBlendMode();
|
|
deviceGroup.blackPointCompensationMode = getGraphicState()->getBlackPointCompensationMode();
|
|
deviceGroup.renderingIntent = RenderingIntent::RelativeColorimetric;
|
|
deviceGroup.initialBackdrop = qMove(paper);
|
|
deviceGroup.immediateBackdrop = deviceGroup.initialBackdrop;
|
|
deviceGroup.blendColorSpace = m_deviceColorSpace;
|
|
|
|
m_transparencyGroupDataStack.emplace_back(qMove(deviceGroup));
|
|
|
|
// Create page transparency group
|
|
PDFObject pageTransparencyGroupObject = getPage()->getTransparencyGroup(&getDocument()->getStorage());
|
|
PDFTransparencyGroup transparencyGroup = parseTransparencyGroup(pageTransparencyGroupObject);
|
|
transparencyGroup.isolated = true;
|
|
|
|
if (!transparencyGroup.colorSpacePointer)
|
|
{
|
|
transparencyGroup.colorSpacePointer = m_processColorSpace;
|
|
}
|
|
|
|
m_pageTransparencyGroupGuard.reset(new PDFTransparencyGroupGuard(this, qMove(transparencyGroup)));
|
|
m_transparencyGroupDataStack.back().filterColorsUsingMask = (m_settings.flags.testFlag(PDFTransparencyRendererSettings::ActiveColorMask) &&
|
|
m_settings.activeColorMask != PDFPixelFormat::getAllColorsMask());
|
|
m_transparencyGroupDataStack.back().activeColorMask = m_settings.activeColorMask;
|
|
m_transparencyGroupDataStack.back().transformSpotsToDevice = m_settings.flags.testFlag(PDFTransparencyRendererSettings::SeparationSimulation);
|
|
m_transparencyGroupDataStack.back().saveOriginalImage = m_settings.flags.testFlag(PDFTransparencyRendererSettings::SaveOriginalProcessImage);
|
|
}
|
|
|
|
const PDFFloatBitmap& PDFTransparencyRenderer::endPaint()
|
|
{
|
|
Q_ASSERT(m_active);
|
|
m_textTransparencyGroupGuard.reset(); // Just safeguard - ET operator may not be present
|
|
m_pageTransparencyGroupGuard.reset();
|
|
m_active = false;
|
|
m_painterStateStack.pop();
|
|
|
|
return *getImmediateBackdrop();
|
|
}
|
|
|
|
QImage PDFTransparencyRenderer::toImageImpl(const PDFFloatBitmapWithColorSpace& floatImage, bool use16Bit) const
|
|
{
|
|
QImage image;
|
|
|
|
Q_ASSERT(floatImage.getPixelFormat().getProcessColorChannelCount() == 3);
|
|
|
|
if (use16Bit)
|
|
{
|
|
image = QImage(int(floatImage.getWidth()), int(floatImage.getHeight()), QImage::Format_RGBA64);
|
|
|
|
const PDFPixelFormat pixelFormat = floatImage.getPixelFormat();
|
|
const int height = image.height();
|
|
const int width = image.width();
|
|
const float scale = std::numeric_limits<quint16>::max();
|
|
const uint8_t channelStart = pixelFormat.getProcessColorChannelIndexStart();
|
|
const uint8_t channelEnd = pixelFormat.getProcessColorChannelIndexEnd();
|
|
const uint8_t opacityChannel = pixelFormat.getOpacityChannelIndex();
|
|
|
|
for (int y = 0; y < height; ++y)
|
|
{
|
|
quint16* pixels = reinterpret_cast<quint16*>(image.bits() + y * image.bytesPerLine());
|
|
|
|
for (int x = 0; x < width; ++x)
|
|
{
|
|
PDFConstColorBuffer colorBuffer = floatImage.getPixel(x, y);
|
|
|
|
for (uint8_t channel = channelStart; channel < channelEnd; ++channel)
|
|
{
|
|
*pixels++ = quint16(colorBuffer[channel] * scale);
|
|
}
|
|
|
|
*pixels++ = quint16(colorBuffer[opacityChannel] * scale);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
image = QImage(int(floatImage.getWidth()), int(floatImage.getHeight()), QImage::Format_RGBA8888);
|
|
|
|
const PDFPixelFormat pixelFormat = floatImage.getPixelFormat();
|
|
const int height = image.height();
|
|
const int width = image.width();
|
|
const float scale = std::numeric_limits<quint8>::max();
|
|
const uint8_t channelStart = pixelFormat.getProcessColorChannelIndexStart();
|
|
const uint8_t channelEnd = pixelFormat.getProcessColorChannelIndexEnd();
|
|
const uint8_t opacityChannel = pixelFormat.getOpacityChannelIndex();
|
|
|
|
for (int y = 0; y < height; ++y)
|
|
{
|
|
quint8* pixels = reinterpret_cast<quint8*>(image.bits() + y * image.bytesPerLine());
|
|
|
|
for (int x = 0; x < width; ++x)
|
|
{
|
|
PDFConstColorBuffer colorBuffer = floatImage.getPixel(x, y);
|
|
|
|
for (uint8_t channel = channelStart; channel < channelEnd; ++channel)
|
|
{
|
|
*pixels++ = quint8(colorBuffer[channel] * scale);
|
|
}
|
|
|
|
*pixels++ = quint8(colorBuffer[opacityChannel] * scale);
|
|
}
|
|
}
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
QImage PDFTransparencyRenderer::toImage(bool use16Bit, bool usePaper, const PDFRGB& paperColor) const
|
|
{
|
|
QImage image;
|
|
|
|
if (m_transparencyGroupDataStack.size() == 1 && // We have finished the painting
|
|
getImmediateBackdrop()->getPixelFormat().getProcessColorChannelCount() == 3) // We have exactly three process colors (RGB)
|
|
{
|
|
const PDFFloatBitmapWithColorSpace& floatImage = *getImmediateBackdrop();
|
|
Q_ASSERT(floatImage.getPixelFormat().hasOpacityChannel());
|
|
|
|
if (!usePaper)
|
|
{
|
|
return toImageImpl(floatImage, use16Bit);
|
|
}
|
|
|
|
PDFFloatBitmapWithColorSpace paperImage(floatImage.getWidth(), floatImage.getHeight(), floatImage.getPixelFormat(), floatImage.getColorSpace());
|
|
createPaperBitmap(paperImage, paperColor);
|
|
|
|
PDFFloatBitmap imageSoftMask;
|
|
createOpaqueSoftMask(imageSoftMask, paperImage.getWidth(), paperImage.getHeight());
|
|
|
|
QRect blendRegion(0, 0, int(floatImage.getWidth()), int(floatImage.getHeight()));
|
|
PDFFloatBitmapWithColorSpace::blend(floatImage, paperImage, paperImage, paperImage, imageSoftMask, false, 1.0f, BlendMode::Normal, false, PDFFloatBitmap::OverprintMode::NoOveprint, blendRegion);
|
|
|
|
return toImageImpl(paperImage, use16Bit);
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
void PDFTransparencyRenderer::clearColor(const PDFColor& color)
|
|
{
|
|
PDFFloatBitmapWithColorSpace* backdrop = getImmediateBackdrop();
|
|
const PDFPixelFormat pixelFormat = backdrop->getPixelFormat();
|
|
|
|
const uint8_t processColorChannelStart = pixelFormat.getProcessColorChannelIndexStart();
|
|
const uint8_t processColorChannelEnd = pixelFormat.getProcessColorChannelIndexEnd();
|
|
|
|
for (uint8_t i = processColorChannelStart; i < processColorChannelEnd; ++i)
|
|
{
|
|
if (i >= color.size())
|
|
{
|
|
reportRenderError(RenderErrorType::Error, PDFTranslationContext::tr("Invalid clear color - process color %1 was not found in clear color.").arg(i));
|
|
return;
|
|
}
|
|
|
|
backdrop->fillChannel(i, color[i]);
|
|
}
|
|
|
|
if (color.size() > pixelFormat.getProcessColorChannelCount())
|
|
{
|
|
reportRenderError(RenderErrorType::Error, PDFTranslationContext::tr("More colors in clear color (%1) than process color channel count (%2).").arg(color.size()).arg(pixelFormat.getProcessColorChannelCount()));
|
|
}
|
|
}
|
|
|
|
bool PDFTransparencyRenderer::isContentKindSuppressed(ContentKind kind) const
|
|
{
|
|
switch (kind)
|
|
{
|
|
case ContentKind::Shapes:
|
|
if (!m_settings.flags.testFlag(PDFTransparencyRendererSettings::DisplayVectorGraphics))
|
|
{
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
case ContentKind::Text:
|
|
if (!m_settings.flags.testFlag(PDFTransparencyRendererSettings::DisplayText))
|
|
{
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
case ContentKind::Images:
|
|
if (!m_settings.flags.testFlag(PDFTransparencyRendererSettings::DisplayImages))
|
|
{
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
case ContentKind::Shading:
|
|
if (!m_settings.flags.testFlag(PDFTransparencyRendererSettings::DisplayShadings))
|
|
{
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
case ContentKind::Tiling:
|
|
if (!m_settings.flags.testFlag(PDFTransparencyRendererSettings::DisplayTilingPatterns))
|
|
{
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
Q_ASSERT(false);
|
|
break;
|
|
}
|
|
|
|
return BaseClass::isContentKindSuppressed(kind);
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performPixelSampling(const PDFReal shape,
|
|
const PDFReal opacity,
|
|
const uint8_t shapeChannel,
|
|
const uint8_t opacityChannel,
|
|
const uint8_t colorChannelStart,
|
|
const uint8_t colorChannelEnd,
|
|
int x,
|
|
int y,
|
|
const PDFMappedColor& fillColor,
|
|
const PDFPainterPathSampler& clipSampler,
|
|
const PDFPainterPathSampler& pathSampler)
|
|
{
|
|
const PDFColorComponent clipValue = clipSampler.sample(QPoint(x, y));
|
|
const PDFColorComponent objectShapeValue = pathSampler.sample(QPoint(x, y));
|
|
const PDFColorComponent shapeValue = objectShapeValue * clipValue * shape;
|
|
|
|
if (shapeValue > 0.0f)
|
|
{
|
|
// We consider old object shape - we use Union function to
|
|
// set shape channel value.
|
|
|
|
PDFColorBuffer pixel = m_drawBuffer.getPixel(x, y);
|
|
pixel[shapeChannel] = PDFBlendFunction::blend_Union(shapeValue, pixel[shapeChannel]);
|
|
pixel[opacityChannel] = pixel[shapeChannel] * opacity;
|
|
|
|
// Copy color
|
|
for (uint8_t colorChannelIndex = colorChannelStart; colorChannelIndex < colorChannelEnd; ++colorChannelIndex)
|
|
{
|
|
pixel[colorChannelIndex] = fillColor.mappedColor[colorChannelIndex];
|
|
}
|
|
|
|
m_drawBuffer.markPixelActiveColorMask(x, y, fillColor.activeChannels);
|
|
}
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performFillFragmentFromTexture(const PDFReal shape,
|
|
const PDFReal opacity,
|
|
const uint8_t shapeChannel,
|
|
const uint8_t opacityChannel,
|
|
const uint8_t colorChannelStart,
|
|
const uint8_t colorChannelEnd,
|
|
int x,
|
|
int y,
|
|
const QTransform& worldToTextureMatrix,
|
|
const PDFFloatBitmap& texture,
|
|
const PDFPainterPathSampler& clipSampler)
|
|
{
|
|
// Get pixel buffer from texture
|
|
QPointF sourcePoint(x, y);
|
|
QPointF texturePoint = sourcePoint * worldToTextureMatrix;
|
|
|
|
if (texturePoint.x() < 0.0 ||
|
|
texturePoint.x() >= texture.getWidth() ||
|
|
texturePoint.y() < 0.0 ||
|
|
texturePoint.y() >= texture.getHeight())
|
|
{
|
|
// Fragment is outside of the texture
|
|
return;
|
|
}
|
|
|
|
const size_t texelCoordinateX = qFloor(texturePoint.x());
|
|
const size_t texelCoordinateY = qFloor(texturePoint.y());
|
|
|
|
PDFConstColorBuffer texel = texture.getPixel(texelCoordinateX, texelCoordinateY);
|
|
|
|
const PDFColorComponent clipValue = clipSampler.sample(QPoint(x, y));
|
|
const PDFColorComponent objectShapeValue = texel[shapeChannel];
|
|
const PDFColorComponent objectOpacityValue = texel[opacityChannel];
|
|
const PDFColorComponent shapeValue = objectShapeValue * clipValue * shape;
|
|
const PDFColorComponent opacityValue = objectOpacityValue * clipValue * shape * opacity;
|
|
|
|
if (shapeValue > 0.0f)
|
|
{
|
|
// We consider old object shape - we use Union function to
|
|
// set shape channel value.
|
|
|
|
PDFColorBuffer pixel = m_drawBuffer.getPixel(x, y);
|
|
pixel[shapeChannel] = PDFBlendFunction::blend_Union(shapeValue, pixel[shapeChannel]);
|
|
pixel[opacityChannel] = opacityValue;
|
|
|
|
// Copy color
|
|
for (uint8_t colorChannelIndex = colorChannelStart; colorChannelIndex < colorChannelEnd; ++colorChannelIndex)
|
|
{
|
|
pixel[colorChannelIndex] = texel[colorChannelIndex];
|
|
}
|
|
|
|
m_drawBuffer.markPixelActiveColorMask(x, y, texture.getPixelActiveColorMask(texelCoordinateX, texelCoordinateY));
|
|
}
|
|
}
|
|
|
|
void PDFTransparencyRenderer::collapseSpotColorsToDeviceColors(PDFFloatBitmapWithColorSpace& bitmap)
|
|
{
|
|
PDFPixelFormat pixelFormat = bitmap.getPixelFormat();
|
|
|
|
if (!pixelFormat.hasSpotColors())
|
|
{
|
|
return;
|
|
}
|
|
|
|
const uint8_t spotColorIndexStart = pixelFormat.getSpotColorChannelIndexStart();
|
|
const uint8_t spotColorIndexEnd = pixelFormat.getSpotColorChannelIndexEnd();
|
|
|
|
for (uint8_t i = spotColorIndexStart; i < spotColorIndexEnd; ++i)
|
|
{
|
|
// Collapse spot color
|
|
const PDFInkMapper::ColorInfo* spotColor = m_inkMapper->getActiveSpotColor(i - spotColorIndexStart);
|
|
Q_ASSERT(spotColor);
|
|
|
|
switch (spotColor->colorSpace->getColorSpace())
|
|
{
|
|
case PDFAbstractColorSpace::ColorSpace::Separation:
|
|
{
|
|
PDFFloatBitmap spotColorBitmap = bitmap.extractSpotChannel(i);
|
|
PDFFloatBitmap processColorBitmap(spotColorBitmap.getWidth(), spotColorBitmap.getHeight(), PDFPixelFormat::createFormat(pixelFormat.getProcessColorChannelCount(), 0, false, pixelFormat.hasProcessColorsSubtractive(), false));
|
|
if (!PDFAbstractColorSpace::transform(spotColor->colorSpace.data(), bitmap.getColorSpace().data(), getCMS(), getGraphicState()->getRenderingIntent(), spotColorBitmap.getPixels(), processColorBitmap.getPixels(), this))
|
|
{
|
|
reportRenderError(RenderErrorType::Error, PDFTranslationContext::tr("Transformation of spot color to blend color space failed."));
|
|
}
|
|
|
|
bitmap.blendConvertedSpots(processColorBitmap);
|
|
break;
|
|
}
|
|
|
|
case PDFAbstractColorSpace::ColorSpace::DeviceN:
|
|
{
|
|
PDFFloatBitmap deviceNBitmap(bitmap.getWidth(), bitmap.getHeight(), PDFPixelFormat::createFormat(uint8_t(spotColor->colorSpace->getColorComponentCount()), 0, false, true, false));
|
|
PDFFloatBitmap processColorBitmap(bitmap.getWidth(), bitmap.getHeight(), PDFPixelFormat::createFormat(pixelFormat.getProcessColorChannelCount(), 0, false, pixelFormat.hasProcessColorsSubtractive(), false));
|
|
|
|
deviceNBitmap.copyChannel(bitmap, i, spotColor->colorSpaceIndex);
|
|
|
|
if (!PDFAbstractColorSpace::transform(spotColor->colorSpace.data(), bitmap.getColorSpace().data(), getCMS(), getGraphicState()->getRenderingIntent(), deviceNBitmap.getPixels(), processColorBitmap.getPixels(), this))
|
|
{
|
|
reportRenderError(RenderErrorType::Error, PDFTranslationContext::tr("Transformation of spot color to blend color space failed."));
|
|
}
|
|
|
|
bitmap.blendConvertedSpots(processColorBitmap);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
reportRenderError(RenderErrorType::Error, PDFTranslationContext::tr("Transformation of spot color to blend color space failed."));
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
PDFFloatBitmapWithColorSpace PDFTransparencyRenderer::getImage(const PDFImage& sourceImage)
|
|
{
|
|
PDFFloatBitmapWithColorSpace bitmap;
|
|
|
|
const PDFImageData& imageData = sourceImage.getImageData();
|
|
|
|
if (imageData.isValid())
|
|
{
|
|
const bool isImageMask = imageData.getMaskingType() == PDFImageData::MaskingType::ImageMask;
|
|
if (sourceImage.getColorSpace() && !isImageMask)
|
|
{
|
|
bitmap = getColoredImage(sourceImage);
|
|
}
|
|
else if (isImageMask)
|
|
{
|
|
if (imageData.getBitsPerComponent() != 1)
|
|
{
|
|
throw PDFRendererException(RenderErrorType::Error, PDFTranslationContext::tr("Invalid number bits of image mask (should be 1 bit instead of %1 bits).").arg(imageData.getBitsPerComponent()));
|
|
}
|
|
|
|
if (imageData.getWidth() == 0 || imageData.getHeight() == 0)
|
|
{
|
|
throw PDFRendererException(RenderErrorType::Error, PDFTranslationContext::tr("Invalid size of image (%1x%2)").arg(imageData.getWidth()).arg(imageData.getHeight()));
|
|
}
|
|
|
|
bitmap = PDFFloatBitmapWithColorSpace(imageData.getWidth(), imageData.getHeight(), m_drawBuffer.getPixelFormat(), getBlendColorSpace());
|
|
const bool flip01 = !imageData.getDecode().empty() && qFuzzyCompare(imageData.getDecode().front(), 1.0);
|
|
PDFBitReader reader(&imageData.getData(), imageData.getBitsPerComponent());
|
|
|
|
PDFPixelFormat pixelFormat = bitmap.getPixelFormat();
|
|
const PDFMappedColor& fillColor = getMappedFillColor();
|
|
Q_ASSERT(fillColor.mappedColor.size() == pixelFormat.getColorChannelCount());
|
|
|
|
for (size_t i = pixelFormat.getColorChannelIndexStart(); i < pixelFormat.getColorChannelIndexEnd(); ++i)
|
|
{
|
|
bitmap.fillChannel(i, fillColor.mappedColor[i]);
|
|
}
|
|
|
|
Q_ASSERT(pixelFormat.hasShapeChannel());
|
|
Q_ASSERT(pixelFormat.hasOpacityChannel());
|
|
|
|
const uint8_t shapeChannelIndex = pixelFormat.getShapeChannelIndex();
|
|
const uint8_t opacityChannelIndex = pixelFormat.getOpacityChannelIndex();
|
|
|
|
const bool alphaIsShape = getGraphicState()->getAlphaIsShape();
|
|
|
|
for (unsigned int i = 0, rowCount = imageData.getHeight(); i < rowCount; ++i)
|
|
{
|
|
reader.seek(i * imageData.getStride());
|
|
|
|
for (unsigned int j = 0, colCount = imageData.getWidth(); j < colCount; ++j)
|
|
{
|
|
PDFColorBuffer buffer = bitmap.getPixel(j, i);
|
|
|
|
const bool transparent = flip01 != static_cast<bool>(reader.read());
|
|
|
|
if (alphaIsShape)
|
|
{
|
|
const PDFColorComponent shapeValue = transparent ? 0.0f : 1.0f;
|
|
const PDFColorComponent opacityValue = shapeValue;
|
|
buffer[shapeChannelIndex] = shapeValue;
|
|
buffer[opacityChannelIndex] = opacityValue;
|
|
}
|
|
else
|
|
{
|
|
const PDFColorComponent shapeValue = 1.0f;
|
|
const PDFColorComponent opacityValue = transparent ? 0.0f : 1.0f;
|
|
buffer[shapeChannelIndex] = shapeValue;
|
|
buffer[opacityChannelIndex] = opacityValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
bitmap.setColorActivity(fillColor.activeChannels);
|
|
}
|
|
}
|
|
|
|
return bitmap;
|
|
}
|
|
|
|
PDFFloatBitmapWithColorSpace PDFTransparencyRenderer::convertImageToBlendSpace(const PDFFloatBitmapWithColorSpace& image)
|
|
{
|
|
PDFFloatBitmapWithColorSpace convertedImage(image.getWidth(), image.getHeight(), m_drawBuffer.getPixelFormat(), getBlendColorSpace());
|
|
auto imageColorSpace = image.getColorSpace();
|
|
Q_ASSERT(imageColorSpace);
|
|
const PDFFloatBitmapWithColorSpace* sourceImage = ℑ
|
|
PDFFloatBitmapWithColorSpace temporaryImage;
|
|
|
|
PDFInkMapping inkMapping = m_inkMapper->createMapping(imageColorSpace.data(), getBlendColorSpace().data(), m_drawBuffer.getPixelFormat());
|
|
if (!inkMapping.isValid())
|
|
{
|
|
temporaryImage = image;
|
|
temporaryImage.convertToColorSpace(getCMS(), getGraphicState()->getRenderingIntent(), getBlendColorSpace(), this);
|
|
inkMapping = m_inkMapper->createMapping(getBlendColorSpace().data(), getBlendColorSpace().data(), m_drawBuffer.getPixelFormat());
|
|
sourceImage = &temporaryImage;
|
|
}
|
|
|
|
Q_ASSERT(inkMapping.isValid());
|
|
|
|
const uint8_t sourceBufferShapeChannelIndex = sourceImage->getPixelFormat().getShapeChannelIndex();
|
|
const uint8_t sourceBufferOpacityChannelIndex = sourceImage->getPixelFormat().getOpacityChannelIndex();
|
|
const uint8_t targetBufferShapeChannelIndex = convertedImage.getPixelFormat().getShapeChannelIndex();
|
|
const uint8_t targetBufferOpacityChannelIndex = convertedImage.getPixelFormat().getOpacityChannelIndex();
|
|
|
|
for (size_t y = 0; y < sourceImage->getHeight(); ++y)
|
|
{
|
|
for (size_t x = 0; x < sourceImage->getWidth(); ++x)
|
|
{
|
|
PDFConstColorBuffer sourceBuffer = sourceImage->getPixel(x, y);
|
|
PDFColorBuffer targetBuffer = convertedImage.getPixel(x, y);
|
|
|
|
for (const PDFInkMapping::Mapping& ink : inkMapping.mapping)
|
|
{
|
|
switch (ink.type)
|
|
{
|
|
case pdf::PDFInkMapping::Pass:
|
|
targetBuffer[ink.target] = sourceBuffer[ink.source];
|
|
break;
|
|
|
|
default:
|
|
Q_ASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
targetBuffer[targetBufferShapeChannelIndex] = sourceBuffer[sourceBufferShapeChannelIndex];
|
|
targetBuffer[targetBufferOpacityChannelIndex] = sourceBuffer[sourceBufferOpacityChannelIndex];
|
|
}
|
|
}
|
|
|
|
convertedImage.setColorActivity(inkMapping.activeChannels);
|
|
return convertedImage;
|
|
}
|
|
|
|
PDFFloatBitmapWithColorSpace PDFTransparencyRenderer::getColoredImage(const PDFImage& sourceImage)
|
|
{
|
|
PDFFloatBitmapWithColorSpace result;
|
|
|
|
const PDFImageData& imageData = sourceImage.getImageData();
|
|
const PDFImageData& imageSoftMask = sourceImage.getSoftMaskData();
|
|
|
|
PDFColorSpacePointer imageColorSpace = sourceImage.getColorSpace();
|
|
size_t colorComponentCount = imageColorSpace->getColorComponentCount();
|
|
bool isCMYK = colorComponentCount == 4;
|
|
const bool useSmoothImageTransformation = m_settings.flags.testFlag(PDFTransparencyRendererSettings::SmoothImageTransformation) && sourceImage.isInterpolated();
|
|
|
|
if (!imageColorSpace)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Invalid image color space."));
|
|
}
|
|
|
|
auto setColorSpaceAndMakeOpaque = [&](auto imageColorSpace)
|
|
{
|
|
result.setColorSpace(imageColorSpace);
|
|
result.makeOpaque();
|
|
};
|
|
|
|
Q_ASSERT(imageData.isValid());
|
|
if (imageColorSpace->getColorSpace() == PDFAbstractColorSpace::ColorSpace::Indexed)
|
|
{
|
|
const PDFIndexedColorSpace* indexedColorSpace = dynamic_cast<const PDFIndexedColorSpace*>(imageColorSpace.data());
|
|
imageColorSpace = indexedColorSpace->getBaseColorSpace();
|
|
|
|
if (!imageColorSpace)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Invalid base color space of indexed color space."));
|
|
}
|
|
|
|
unsigned int componentCount = imageData.getComponents();
|
|
PDFBitReader reader(&imageData.getData(), imageData.getBitsPerComponent());
|
|
|
|
if (componentCount != colorComponentCount)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Invalid colors for indexed color space. Color space has %1 colors. Provided color count is %4.").arg(colorComponentCount).arg(componentCount));
|
|
}
|
|
|
|
const unsigned int imageWidth = imageData.getWidth();
|
|
const unsigned int imageHeight = imageData.getHeight();
|
|
Q_ASSERT(componentCount == 1);
|
|
|
|
std::vector<PDFColorComponent> colorIndices;
|
|
colorIndices.reserve(imageData.getWidth() * imageData.getHeight());
|
|
|
|
for (unsigned int i = 0; i < imageHeight; ++i)
|
|
{
|
|
reader.seek(i * imageData.getStride());
|
|
|
|
for (unsigned int j = 0; j < imageWidth; ++j)
|
|
{
|
|
PDFBitReader::Value index = reader.read();
|
|
colorIndices.push_back(index);
|
|
}
|
|
}
|
|
|
|
PDFColorBuffer indicesBuffer(colorIndices.data(), colorIndices.size());
|
|
std::vector<PDFColorComponent> transformedColors = indexedColorSpace->transformColorsToBaseColorSpace(indicesBuffer);
|
|
colorComponentCount = imageColorSpace->getColorComponentCount();
|
|
isCMYK = colorComponentCount == 4;
|
|
|
|
if (transformedColors.size() != colorComponentCount * imageWidth * imageHeight)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Conversion of indexed image to base color space failed."));
|
|
}
|
|
|
|
result = PDFFloatBitmapWithColorSpace(imageWidth, imageHeight, PDFPixelFormat::createFormat(uint8_t(colorComponentCount), 0, true, isCMYK, false));
|
|
setColorSpaceAndMakeOpaque(imageColorSpace);
|
|
|
|
for (unsigned int i = 0; i < imageHeight; ++i)
|
|
{
|
|
for (unsigned int j = 0; j < imageWidth; ++j)
|
|
{
|
|
PDFColorBuffer buffer = result.getPixel(j, i);
|
|
|
|
size_t pixelIndex = (i * imageWidth + j) * colorComponentCount;
|
|
for (size_t k = 0; k < colorComponentCount; ++k)
|
|
{
|
|
Q_ASSERT(pixelIndex + k < transformedColors.size());
|
|
buffer[k] = transformedColors[pixelIndex + k];
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (imageData.getMaskingType())
|
|
{
|
|
case PDFImageData::MaskingType::None:
|
|
break;
|
|
|
|
case PDFImageData::MaskingType::SoftMask:
|
|
{
|
|
PDFFloatBitmap alphaMask = getAlphaMaskFromSoftMask(imageSoftMask);
|
|
if (alphaMask.getWidth() != result.getWidth() || alphaMask.getHeight() != result.getHeight())
|
|
{
|
|
// Scale the alpha mask, if it is masked
|
|
alphaMask = alphaMask.resize(result.getWidth(), result.getHeight(), useSmoothImageTransformation ? Qt::SmoothTransformation : Qt::FastTransformation);
|
|
}
|
|
Q_ASSERT(alphaMask.getPixelFormat().getChannelCount() == 2);
|
|
Q_ASSERT(alphaMask.getPixelFormat().hasOpacityChannel());
|
|
Q_ASSERT(alphaMask.getPixelFormat().hasShapeChannel());
|
|
|
|
Q_ASSERT(result.getPixelFormat().hasShapeChannel());
|
|
Q_ASSERT(result.getPixelFormat().hasOpacityChannel());
|
|
|
|
const uint8_t sourceShapeChannelIndex = alphaMask.getPixelFormat().getShapeChannelIndex();
|
|
const uint8_t sourceOpacityChannelIndex = alphaMask.getPixelFormat().getOpacityChannelIndex();
|
|
const uint8_t targetShapeChannelIndex = result.getPixelFormat().getShapeChannelIndex();
|
|
const uint8_t targetOpacityChannelIndex = result.getPixelFormat().getOpacityChannelIndex();
|
|
|
|
for (size_t i = 0; i < imageHeight; ++i)
|
|
{
|
|
for (unsigned int j = 0; j < imageWidth; ++j)
|
|
{
|
|
PDFColorBuffer targetBuffer = result.getPixel(j, i);
|
|
PDFColorBuffer alphaBuffer = alphaMask.getPixel(j, i);
|
|
|
|
targetBuffer[targetShapeChannelIndex] = alphaBuffer[sourceShapeChannelIndex];
|
|
targetBuffer[targetOpacityChannelIndex] = alphaBuffer[sourceOpacityChannelIndex];
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw PDFRendererException(RenderErrorType::NotImplemented, PDFTranslationContext::tr("Image masking not implemented!"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (imageData.getMaskingType())
|
|
{
|
|
case PDFImageData::MaskingType::None:
|
|
{
|
|
result = PDFFloatBitmapWithColorSpace(imageData.getWidth(), imageData.getHeight(), PDFPixelFormat::createFormat(uint8_t(colorComponentCount), 0, true, isCMYK, false));
|
|
setColorSpaceAndMakeOpaque(imageColorSpace);
|
|
|
|
unsigned int componentCount = imageData.getComponents();
|
|
if (componentCount != colorComponentCount)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Invalid colors for color space. Color space has %1 colors. Provided color count is %4.").arg(colorComponentCount).arg(componentCount));
|
|
}
|
|
|
|
const std::vector<PDFReal>& decode = imageData.getDecode();
|
|
if (!decode.empty() && decode.size() != componentCount * 2)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Invalid size of the decode array. Expected %1, actual %2.").arg(componentCount * 2).arg(decode.size()));
|
|
}
|
|
|
|
const unsigned int imageWidth = imageData.getWidth();
|
|
const unsigned int imageHeight = imageData.getHeight();
|
|
|
|
PDFBitReader reader(&imageData.getData(), imageData.getBitsPerComponent());
|
|
const PDFColorComponent max = reader.max();
|
|
const PDFColorComponent coefficient = 1.0 / max;
|
|
|
|
for (size_t i = 0; i < imageHeight; ++i)
|
|
{
|
|
reader.seek(i * imageData.getStride());
|
|
|
|
for (size_t j = 0; j < imageWidth; ++j)
|
|
{
|
|
PDFColorBuffer buffer = result.getPixel(j, i);
|
|
|
|
for (size_t k = 0; k < componentCount; ++k)
|
|
{
|
|
PDFReal value = reader.read();
|
|
|
|
// Interpolate value, if it is not empty
|
|
if (!decode.empty())
|
|
{
|
|
buffer[k] = interpolateColors(value, 0.0, max, decode[2 * k], decode[2 * k + 1]);
|
|
}
|
|
else
|
|
{
|
|
buffer[k] = value * coefficient;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case PDFImageData::MaskingType::SoftMask:
|
|
{
|
|
result = PDFFloatBitmapWithColorSpace(imageData.getWidth(), imageData.getHeight(), PDFPixelFormat::createFormat(uint8_t(colorComponentCount), 0, true, isCMYK, false));
|
|
result.setColorSpace(imageColorSpace);
|
|
|
|
const bool hasMatte = !imageSoftMask.getMatte().empty();
|
|
std::vector<PDFReal> matte = imageSoftMask.getMatte();
|
|
|
|
if (hasMatte && matte.size() != colorComponentCount)
|
|
{
|
|
reportRenderError(RenderErrorType::Warning, PDFTranslationContext::tr("Invalid matte color."));
|
|
}
|
|
|
|
matte.resize(colorComponentCount, 0.0f);
|
|
|
|
unsigned int componentCount = imageData.getComponents();
|
|
if (componentCount != colorComponentCount)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Invalid colors for color space. Color space has %1 colors. Provided color count is %4.").arg(colorComponentCount).arg(componentCount));
|
|
}
|
|
|
|
const std::vector<PDFReal>& decode = imageData.getDecode();
|
|
if (!decode.empty() && decode.size() != componentCount * 2)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Invalid size of the decode array. Expected %1, actual %2.").arg(componentCount * 2).arg(decode.size()));
|
|
}
|
|
|
|
const unsigned int imageWidth = imageData.getWidth();
|
|
const unsigned int imageHeight = imageData.getHeight();
|
|
|
|
PDFFloatBitmap alphaMask = getAlphaMaskFromSoftMask(imageSoftMask);
|
|
if (alphaMask.getWidth() != result.getWidth() || alphaMask.getHeight() != result.getHeight())
|
|
{
|
|
// Scale the alpha mask, if it is masked
|
|
alphaMask = alphaMask.resize(result.getWidth(), result.getHeight(), useSmoothImageTransformation ? Qt::SmoothTransformation : Qt::FastTransformation);
|
|
}
|
|
Q_ASSERT(alphaMask.getPixelFormat().getChannelCount() == 2);
|
|
Q_ASSERT(alphaMask.getPixelFormat().hasOpacityChannel());
|
|
Q_ASSERT(alphaMask.getPixelFormat().hasShapeChannel());
|
|
|
|
PDFBitReader reader(&imageData.getData(), imageData.getBitsPerComponent());
|
|
const PDFColorComponent max = reader.max();
|
|
const PDFColorComponent coefficient = 1.0 / max;
|
|
|
|
Q_ASSERT(result.getPixelFormat().hasShapeChannel());
|
|
Q_ASSERT(result.getPixelFormat().hasOpacityChannel());
|
|
|
|
const uint8_t sourceShapeChannelIndex = alphaMask.getPixelFormat().getShapeChannelIndex();
|
|
const uint8_t sourceOpacityChannelIndex = alphaMask.getPixelFormat().getOpacityChannelIndex();
|
|
const uint8_t targetShapeChannelIndex = result.getPixelFormat().getShapeChannelIndex();
|
|
const uint8_t targetOpacityChannelIndex = result.getPixelFormat().getOpacityChannelIndex();
|
|
|
|
for (size_t i = 0; i < imageHeight; ++i)
|
|
{
|
|
reader.seek(i * imageData.getStride());
|
|
|
|
for (unsigned int j = 0; j < imageWidth; ++j)
|
|
{
|
|
PDFColorBuffer targetBuffer = result.getPixel(j, i);
|
|
PDFColorBuffer alphaBuffer = alphaMask.getPixel(j, i);
|
|
|
|
for (unsigned int k = 0; k < componentCount; ++k)
|
|
{
|
|
PDFReal value = reader.read();
|
|
|
|
// Interpolate value, if it is not empty
|
|
if (!decode.empty())
|
|
{
|
|
targetBuffer[k] = interpolateColors(value, 0.0, max, decode[2 * k], decode[2 * k + 1]);
|
|
}
|
|
else
|
|
{
|
|
targetBuffer[k] = value * coefficient;
|
|
}
|
|
}
|
|
|
|
targetBuffer[targetShapeChannelIndex] = alphaBuffer[sourceShapeChannelIndex];
|
|
targetBuffer[targetOpacityChannelIndex] = alphaBuffer[sourceOpacityChannelIndex];
|
|
const PDFColorComponent alpha = targetBuffer[targetOpacityChannelIndex];
|
|
|
|
// Un-premultiply with matte color, according to chapter 11.6.5.2 in PDF
|
|
// 2.0 specification, we use inversion of following formula:
|
|
//
|
|
// c' = m + alpha * (c - m)
|
|
//
|
|
// So, inversion is:
|
|
//
|
|
// c = m + (c' - m) / alpha
|
|
//
|
|
if (hasMatte && !qFuzzyIsNull(alpha))
|
|
{
|
|
for (unsigned int k = 0; k < componentCount; ++k)
|
|
{
|
|
const PDFColorComponent m = matte[k];
|
|
targetBuffer[k] = qBound(0.0f, m + (targetBuffer[k] - m) / alpha, 1.0f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case PDFImageData::MaskingType::ColorKeyMasking:
|
|
{
|
|
result = PDFFloatBitmapWithColorSpace(imageData.getWidth(), imageData.getHeight(), PDFPixelFormat::createFormat(uint8_t(colorComponentCount), 0, true, isCMYK, false));
|
|
setColorSpaceAndMakeOpaque(imageColorSpace);
|
|
|
|
unsigned int componentCount = imageData.getComponents();
|
|
if (componentCount != colorComponentCount)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Invalid colors for color space. Color space has %1 colors. Provided color count is %4.").arg(colorComponentCount).arg(componentCount));
|
|
}
|
|
|
|
Q_ASSERT(componentCount > 0);
|
|
const std::vector<PDFInteger>& colorKeyMask = imageData.getColorKeyMask();
|
|
if (colorKeyMask.size() / 2 != componentCount)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Invalid number of color components in color key mask. Expected %1, provided %2.").arg(2 * componentCount).arg(colorKeyMask.size()));
|
|
}
|
|
|
|
const std::vector<PDFReal>& decode = imageData.getDecode();
|
|
if (!decode.empty() && decode.size() != componentCount * 2)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Invalid size of the decoded array. Expected %1, actual %2.").arg(componentCount * 2).arg(decode.size()));
|
|
}
|
|
|
|
PDFBitReader reader(&imageData.getData(), imageData.getBitsPerComponent());
|
|
|
|
PDFColor color;
|
|
color.resize(componentCount);
|
|
|
|
const PDFColorComponent max = reader.max();
|
|
const PDFColorComponent coefficient = 1.0 / max;
|
|
const bool alphaIsShape = getGraphicState()->getAlphaIsShape();
|
|
|
|
const uint8_t targetShapeChannelIndex = result.getPixelFormat().getShapeChannelIndex();
|
|
const uint8_t targetOpacityChannelIndex = result.getPixelFormat().getOpacityChannelIndex();
|
|
|
|
for (unsigned int i = 0, rowCount = imageData.getHeight(); i < rowCount; ++i)
|
|
{
|
|
reader.seek(i * imageData.getStride());
|
|
|
|
for (unsigned int j = 0; j < imageData.getWidth(); ++j)
|
|
{
|
|
// Number of masked-out colors
|
|
unsigned int maskedColors = 0;
|
|
|
|
PDFColorBuffer targetBuffer = result.getPixel(j, i);
|
|
|
|
for (unsigned int k = 0; k < componentCount; ++k)
|
|
{
|
|
PDFBitReader::Value value = reader.read();
|
|
|
|
// Interpolate value, if decode is not empty
|
|
if (!decode.empty())
|
|
{
|
|
targetBuffer[k] = interpolateColors(value, 0.0, max, decode[2 * k], decode[2 * k + 1]);
|
|
}
|
|
else
|
|
{
|
|
targetBuffer[k] = value * coefficient;
|
|
}
|
|
|
|
Q_ASSERT(2 * k + 1 < colorKeyMask.size());
|
|
if (static_cast<std::decay<decltype(colorKeyMask)>::type::value_type>(value) >= colorKeyMask[2 * k] &&
|
|
static_cast<std::decay<decltype(colorKeyMask)>::type::value_type>(value) <= colorKeyMask[2 * k + 1])
|
|
{
|
|
++maskedColors;
|
|
}
|
|
}
|
|
|
|
const PDFColorComponent alpha = (maskedColors == componentCount) ? 0.0f : 1.0f;
|
|
const PDFColorComponent shape = alphaIsShape ? alpha : 1.0f;
|
|
|
|
targetBuffer[targetShapeChannelIndex] = shape;
|
|
targetBuffer[targetOpacityChannelIndex] = alpha;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
throw PDFRendererException(RenderErrorType::NotImplemented, PDFTranslationContext::tr("Image masking not implemented!"));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Jakub Melka: We are mapping into draw buffer, so we must use draw buffer pixel format
|
|
return convertImageToBlendSpace(result);
|
|
}
|
|
|
|
PDFFloatBitmap PDFTransparencyRenderer::getAlphaMaskFromSoftMask(const PDFImageData& imageSoftMask)
|
|
{
|
|
if (imageSoftMask.getMaskingType() != PDFImageData::MaskingType::None)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Soft mask can't have masking."));
|
|
}
|
|
|
|
if (imageSoftMask.getWidth() < 1 || imageSoftMask.getHeight() < 1)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Invalid size of soft mask."));
|
|
}
|
|
|
|
PDFFloatBitmap result(imageSoftMask.getWidth(), imageSoftMask.getHeight(), PDFPixelFormat::createFormat(0, 0, true, false, false));
|
|
|
|
unsigned int componentCount = imageSoftMask.getComponents();
|
|
if (componentCount != 1)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Soft mask should have only 1 color component (alpha) instead of %1.").arg(componentCount));
|
|
}
|
|
|
|
const std::vector<PDFReal>& decode = imageSoftMask.getDecode();
|
|
if (!decode.empty() && decode.size() != componentCount * 2)
|
|
{
|
|
throw PDFException(PDFTranslationContext::tr("Invalid size of the decode array. Expected %1, actual %2.").arg(componentCount * 2).arg(decode.size()));
|
|
}
|
|
|
|
PDFBitReader reader(&imageSoftMask.getData(), imageSoftMask.getBitsPerComponent());
|
|
|
|
PDFColor color;
|
|
color.resize(componentCount);
|
|
|
|
const PDFColorComponent max = reader.max();
|
|
const PDFColorComponent coefficient = 1.0 / max;
|
|
const uint8_t targetShapeChannelIndex = result.getPixelFormat().getShapeChannelIndex();
|
|
const uint8_t targetOpacityChannelIndex = result.getPixelFormat().getOpacityChannelIndex();
|
|
const bool alphaIsShape = getGraphicState()->getAlphaIsShape();
|
|
|
|
for (unsigned int i = 0, rowCount = imageSoftMask.getHeight(); i < rowCount; ++i)
|
|
{
|
|
reader.seek(i * imageSoftMask.getStride());
|
|
|
|
for (unsigned int j = 0, colCount = imageSoftMask.getWidth(); j < colCount; ++j)
|
|
{
|
|
PDFColorComponent alpha = 0.0;
|
|
PDFReal value = reader.read();
|
|
|
|
// Interpolate value, if it is not empty
|
|
if (!decode.empty())
|
|
{
|
|
alpha = interpolate(value, 0.0, max, decode[0], decode[1]);
|
|
}
|
|
else
|
|
{
|
|
alpha = value * coefficient;
|
|
}
|
|
|
|
alpha = qBound(0.0f, alpha, 1.0f);
|
|
const PDFColorComponent shape = alphaIsShape ? alpha : 1.0f;
|
|
|
|
PDFColorBuffer targetBuffer = result.getPixel(j, i);
|
|
targetBuffer[targetShapeChannelIndex] = shape;
|
|
targetBuffer[targetOpacityChannelIndex] = alpha;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void PDFTransparencyRenderer::processSoftMask(const PDFDictionary* softMask)
|
|
{
|
|
if (m_painterStateStack.empty())
|
|
{
|
|
// Jakub Melka: This occurs only in initialization phase.
|
|
// Just quit, opaque soft mask is initialized when beginPaint is called.
|
|
return;
|
|
}
|
|
|
|
if (!softMask)
|
|
{
|
|
// Make soft mask opaque
|
|
getPainterState()->softMask.makeOpaque();
|
|
}
|
|
else
|
|
{
|
|
PDFSoftMaskDefinition softMaskDefinition = PDFSoftMaskDefinition::parse(softMask, this);
|
|
|
|
if (!softMaskDefinition.getFormStream())
|
|
{
|
|
reportRenderError(RenderErrorType::Error, PDFTranslationContext::tr("Invalind soft mask."));
|
|
getPainterState()->softMask.makeOpaque();
|
|
return;
|
|
}
|
|
|
|
// Jakub Melka: Define blend color space
|
|
PDFColorSpacePointer blendColorSpace = softMaskDefinition.getTransparencyGroup().colorSpacePointer;
|
|
if (!blendColorSpace)
|
|
{
|
|
blendColorSpace.reset(new PDFDeviceRGBColorSpace());
|
|
}
|
|
if (!blendColorSpace->isBlendColorSpace())
|
|
{
|
|
reportRenderError(RenderErrorType::Error, PDFTranslationContext::tr("Invalid blend color space of soft mask definition."));
|
|
getPainterState()->softMask.makeOpaque();
|
|
return;
|
|
}
|
|
|
|
PDFInkMapper inkMapper(nullptr, getDocument());
|
|
PDFTransparencyRenderer softMaskRenderer(getPage(), getDocument(), getFontCache(), getCMS(), getOptionalContentActivity(), &inkMapper, m_settings, getPagePointToDevicePointMatrix());
|
|
softMaskRenderer.initializeProcessor();
|
|
|
|
PDFPageContentProcessorState graphicState = *getGraphicState();
|
|
graphicState.setSoftMask(nullptr);
|
|
|
|
softMaskRenderer.setDeviceColorSpace(blendColorSpace);
|
|
softMaskRenderer.setProcessColorSpace(blendColorSpace);
|
|
|
|
softMaskRenderer.beginPaint(QSize(int(m_drawBuffer.getWidth()), int(m_drawBuffer.getHeight())));
|
|
softMaskRenderer.clearColor(softMaskDefinition.getBackdropColor());
|
|
softMaskRenderer.setGraphicsState(graphicState);
|
|
softMaskRenderer.processForm(softMaskDefinition.getFormStream());
|
|
const PDFFloatBitmap& renderedSoftMask = softMaskRenderer.endPaint();
|
|
PDFFloatBitmap createdSoftMask;
|
|
|
|
switch (softMaskDefinition.getType())
|
|
{
|
|
case pdf::PDFPageContentProcessor::PDFSoftMaskDefinition::Type::Alpha:
|
|
createdSoftMask = renderedSoftMask.extractOpacityChannel();
|
|
break;
|
|
|
|
case pdf::PDFPageContentProcessor::PDFSoftMaskDefinition::Type::Luminosity:
|
|
createdSoftMask = renderedSoftMask.extractLuminosityChannel();
|
|
break;
|
|
|
|
default:
|
|
case pdf::PDFPageContentProcessor::PDFSoftMaskDefinition::Type::Invalid:
|
|
reportRenderError(RenderErrorType::Error, PDFTranslationContext::tr("Invalid soft mask type."));
|
|
createdSoftMask = renderedSoftMask.extractOpacityChannel();
|
|
break;
|
|
}
|
|
|
|
if (const PDFFunction* function = softMaskDefinition.getTransferFunction())
|
|
{
|
|
const size_t width = createdSoftMask.getWidth();
|
|
const size_t height = createdSoftMask.getHeight();
|
|
|
|
for (size_t y = 0; y < height; ++y)
|
|
{
|
|
for (size_t x = 0; x < width; ++x)
|
|
{
|
|
PDFColorBuffer pixel = createdSoftMask.getPixel(x, y);
|
|
PDFReal sourceValue = pixel[0];
|
|
PDFReal targetValue = sourceValue;
|
|
|
|
PDFFunction::FunctionResult result = function->apply(&sourceValue, &sourceValue + 1, &targetValue, &targetValue + 1);
|
|
|
|
if (!result)
|
|
{
|
|
reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Evaulation of soft mask transfer function failed."));
|
|
}
|
|
|
|
pixel[0] = targetValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
getPainterState()->softMask = PDFTransparencySoftMask(false, qMove(createdSoftMask));
|
|
}
|
|
}
|
|
|
|
void PDFTransparencyRenderer::createOpaqueBitmap(PDFFloatBitmap& bitmap)
|
|
{
|
|
bitmap.makeOpaque();
|
|
}
|
|
|
|
void PDFTransparencyRenderer::createPaperBitmap(PDFFloatBitmap& bitmap, const PDFRGB& paperColor)
|
|
{
|
|
bitmap.makeOpaque();
|
|
bitmap.fillChannel(0, paperColor[0]);
|
|
bitmap.fillChannel(1, paperColor[1]);
|
|
bitmap.fillChannel(2, paperColor[2]);
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performPathPainting(const QPainterPath& path, bool stroke, bool fill, bool text, Qt::FillRule fillRule)
|
|
{
|
|
Q_UNUSED(text);
|
|
Q_UNUSED(fillRule);
|
|
|
|
QTransform worldMatrix = getCurrentWorldMatrix();
|
|
|
|
const PDFReal shapeStroking = getShapeStroking();
|
|
const PDFReal opacityStroking = getOpacityStroking();
|
|
const PDFReal shapeFilling = getShapeFilling();
|
|
const PDFReal opacityFilling = getOpacityFilling();
|
|
|
|
PDFPixelFormat format = m_drawBuffer.getPixelFormat();
|
|
Q_ASSERT(format.hasShapeChannel());
|
|
Q_ASSERT(format.hasOpacityChannel());
|
|
|
|
const uint8_t shapeChannel = format.getShapeChannelIndex();
|
|
const uint8_t opacityChannel = format.getOpacityChannelIndex();
|
|
const uint8_t colorChannelStart = format.getColorChannelIndexStart();
|
|
const uint8_t colorChannelEnd = format.getColorChannelIndexEnd();
|
|
|
|
if (fill)
|
|
{
|
|
QPainterPath worldPath = worldMatrix.map(path);
|
|
QRect fillRect = getActualFillRect(worldPath.controlPointRect());
|
|
|
|
// Fill rect may be, or may not be valid. It depends on the painter path
|
|
// and world matrix. Path can be translated outside of the paint area.
|
|
if (fillRect.isValid())
|
|
{
|
|
PDFPainterPathSampler clipSampler(m_painterStateStack.top().clipPath, m_settings.samplesCount, 1.0f, fillRect, m_settings.flags.testFlag(PDFTransparencyRendererSettings::PrecisePathSampler));
|
|
PDFPainterPathSampler pathSampler(worldPath, m_settings.samplesCount, 0.0f, fillRect, m_settings.flags.testFlag(PDFTransparencyRendererSettings::PrecisePathSampler));
|
|
const PDFMappedColor& fillColor = getMappedFillColor();
|
|
|
|
if (isMultithreadedPathSamplingUsed(fillRect))
|
|
{
|
|
if (fillRect.width() > fillRect.height())
|
|
{
|
|
// Columns
|
|
PDFIntegerRange<int> range(fillRect.left(), fillRect.right() + 1);
|
|
auto processEntry = [&, this](int x)
|
|
{
|
|
for (int y = fillRect.top(); y <= fillRect.bottom(); ++y)
|
|
{
|
|
performPixelSampling(shapeFilling, opacityFilling, shapeChannel, opacityChannel, colorChannelStart, colorChannelEnd, x, y, fillColor, clipSampler, pathSampler);
|
|
}
|
|
};
|
|
PDFExecutionPolicy::execute(PDFExecutionPolicy::Scope::Content, range.begin(), range.end(), processEntry);
|
|
}
|
|
else
|
|
{
|
|
// Rows
|
|
PDFIntegerRange<int> range(fillRect.top(), fillRect.bottom() + 1);
|
|
auto processEntry = [&, this](int y)
|
|
{
|
|
for (int x = fillRect.left(); x <= fillRect.right(); ++x)
|
|
{
|
|
performPixelSampling(shapeFilling, opacityFilling, shapeChannel, opacityChannel, colorChannelStart, colorChannelEnd, x, y, fillColor, clipSampler, pathSampler);
|
|
}
|
|
};
|
|
PDFExecutionPolicy::execute(PDFExecutionPolicy::Scope::Content, range.begin(), range.end(), processEntry);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int x = fillRect.left(); x <= fillRect.right(); ++x)
|
|
{
|
|
for (int y = fillRect.top(); y <= fillRect.bottom(); ++y)
|
|
{
|
|
performPixelSampling(shapeFilling, opacityFilling, shapeChannel, opacityChannel, colorChannelStart, colorChannelEnd, x, y, fillColor, clipSampler, pathSampler);
|
|
}
|
|
}
|
|
}
|
|
|
|
m_drawBuffer.modify(fillRect, true, false);
|
|
}
|
|
}
|
|
|
|
if (stroke)
|
|
{
|
|
// We must stroke the path.
|
|
QPainterPathStroker stroker;
|
|
stroker.setCapStyle(getGraphicState()->getLineCapStyle());
|
|
stroker.setWidth(getGraphicState()->getLineWidth());
|
|
stroker.setMiterLimit(getGraphicState()->getMitterLimit());
|
|
stroker.setJoinStyle(getGraphicState()->getLineJoinStyle());
|
|
|
|
const PDFLineDashPattern& lineDashPattern = getGraphicState()->getLineDashPattern();
|
|
if (!lineDashPattern.isSolid())
|
|
{
|
|
stroker.setDashPattern(lineDashPattern.createForQPen(getGraphicState()->getLineWidth()));
|
|
stroker.setDashOffset(lineDashPattern.getDashOffset());
|
|
}
|
|
QPainterPath strokedPath = stroker.createStroke(path);
|
|
|
|
QPainterPath worldPath = worldMatrix.map(strokedPath);
|
|
QRect strokeRect = getActualFillRect(worldPath.controlPointRect());
|
|
|
|
// Fill rect may be, or may not be valid. It depends on the painter path
|
|
// and world matrix. Path can be translated outside of the paint area.
|
|
if (strokeRect.isValid())
|
|
{
|
|
PDFPainterPathSampler clipSampler(m_painterStateStack.top().clipPath, m_settings.samplesCount, 1.0f, strokeRect, m_settings.flags.testFlag(PDFTransparencyRendererSettings::PrecisePathSampler));
|
|
PDFPainterPathSampler pathSampler(worldPath, m_settings.samplesCount, 0.0f, strokeRect, m_settings.flags.testFlag(PDFTransparencyRendererSettings::PrecisePathSampler));
|
|
const PDFMappedColor& strokeColor = getMappedStrokeColor();
|
|
|
|
if (isMultithreadedPathSamplingUsed(strokeRect))
|
|
{
|
|
if (strokeRect.width() > strokeRect.height())
|
|
{
|
|
// Columns
|
|
PDFIntegerRange<int> range(strokeRect.left(), strokeRect.right() + 1);
|
|
auto processEntry = [&, this](int x)
|
|
{
|
|
for (int y = strokeRect.top(); y <= strokeRect.bottom(); ++y)
|
|
{
|
|
performPixelSampling(shapeStroking, opacityStroking, shapeChannel, opacityChannel, colorChannelStart, colorChannelEnd, x, y, strokeColor, clipSampler, pathSampler);
|
|
}
|
|
};
|
|
PDFExecutionPolicy::execute(PDFExecutionPolicy::Scope::Content, range.begin(), range.end(), processEntry);
|
|
}
|
|
else
|
|
{
|
|
// Rows
|
|
PDFIntegerRange<int> range(strokeRect.top(), strokeRect.bottom() + 1);
|
|
auto processEntry = [&, this](int y)
|
|
{
|
|
for (int x = strokeRect.left(); x <= strokeRect.right(); ++x)
|
|
{
|
|
performPixelSampling(shapeStroking, opacityStroking, shapeChannel, opacityChannel, colorChannelStart, colorChannelEnd, x, y, strokeColor, clipSampler, pathSampler);
|
|
}
|
|
};
|
|
PDFExecutionPolicy::execute(PDFExecutionPolicy::Scope::Content, range.begin(), range.end(), processEntry);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int x = strokeRect.left(); x <= strokeRect.right(); ++x)
|
|
{
|
|
for (int y = strokeRect.top(); y <= strokeRect.bottom(); ++y)
|
|
{
|
|
performPixelSampling(shapeStroking, opacityStroking, shapeChannel, opacityChannel, colorChannelStart, colorChannelEnd, x, y, strokeColor, clipSampler, pathSampler);
|
|
}
|
|
}
|
|
}
|
|
|
|
m_drawBuffer.modify(strokeRect, false, true);
|
|
}
|
|
}
|
|
|
|
flushDrawBuffer();
|
|
}
|
|
|
|
bool PDFTransparencyRenderer::performPathPaintingUsingShading(const QPainterPath& path, bool stroke, bool fill, const PDFShadingPattern* shadingPattern)
|
|
{
|
|
if (path.isEmpty())
|
|
{
|
|
// Path is empty
|
|
return true;
|
|
}
|
|
|
|
// Exactly one of stroke/fill must be true and other must be false
|
|
Q_ASSERT(stroke != fill);
|
|
|
|
QTransform worldMatrix = getCurrentWorldMatrix();
|
|
QPainterPath worldPath = worldMatrix.map(path);
|
|
QRect fillRect = getActualFillRect(worldPath.controlPointRect());
|
|
|
|
if (fillRect.isEmpty())
|
|
{
|
|
// Jakub Melka: nothing to draw, rectangle is empty
|
|
return true;
|
|
}
|
|
|
|
std::unique_ptr<PDFShadingSampler> sampler(shadingPattern->createSampler(getPatternBaseMatrix()));
|
|
if (!sampler)
|
|
{
|
|
// Can't create sampler - this is error
|
|
reportRenderError(RenderErrorType::Error, PDFTranslationContext::tr("Cannot create shading sampler."));
|
|
return true;
|
|
}
|
|
|
|
// Now, we have a sampler, so we create a texture, which we will later use
|
|
// as color source.
|
|
const PDFAbstractColorSpace* colorSpace = shadingPattern->getColorSpace();
|
|
const size_t shadingColorComponentCount = colorSpace->getColorComponentCount();
|
|
PDFFloatBitmapWithColorSpace texture(fillRect.width() + 1, fillRect.height() + 1, PDFPixelFormat::createFormat(uint8_t(shadingColorComponentCount), 0, true, shadingColorComponentCount == 4, false), shadingPattern->getColorSpacePtr());
|
|
QPointF offset = fillRect.topLeft();
|
|
|
|
PDFPixelFormat texturePixelFormat = texture.getPixelFormat();
|
|
uint8_t textureShapeChannel = texturePixelFormat.getShapeChannelIndex();
|
|
uint8_t textureOpacityChannel = texturePixelFormat.getOpacityChannelIndex();
|
|
|
|
if (fillRect.width() > fillRect.height())
|
|
{
|
|
// Columns
|
|
PDFIntegerRange<int> range(fillRect.left(), fillRect.right() + 1);
|
|
auto processEntry = [&, this](int x)
|
|
{
|
|
for (int y = fillRect.top(); y <= fillRect.bottom(); ++y)
|
|
{
|
|
const int texelCoordinateX = x - fillRect.left();
|
|
const int texelCoordinateY = y - fillRect.top();
|
|
|
|
PDFColorBuffer buffer = texture.getPixel(texelCoordinateX, texelCoordinateY);
|
|
bool isSampled = sampler->sample(QPointF(x, y) + offset, buffer.resized(shadingColorComponentCount), m_settings.shadingAlgorithmLimit);
|
|
const PDFColorComponent textureSampleShape = isSampled ? 1.0f : 0.0f;
|
|
buffer[textureShapeChannel] = textureSampleShape;
|
|
buffer[textureOpacityChannel] = textureSampleShape;
|
|
}
|
|
};
|
|
PDFExecutionPolicy::execute(PDFExecutionPolicy::Scope::Content, range.begin(), range.end(), processEntry);
|
|
}
|
|
else
|
|
{
|
|
// Rows
|
|
PDFIntegerRange<int> range(fillRect.top(), fillRect.bottom() + 1);
|
|
auto processEntry = [&, this](int y)
|
|
{
|
|
for (int x = fillRect.left(); x <= fillRect.right(); ++x)
|
|
{
|
|
const int texelCoordinateX = x - fillRect.left();
|
|
const int texelCoordinateY = y - fillRect.top();
|
|
|
|
PDFColorBuffer buffer = texture.getPixel(texelCoordinateX, texelCoordinateY);
|
|
bool isSampled = sampler->sample(QPointF(x, y) + offset, buffer.resized(shadingColorComponentCount), m_settings.shadingAlgorithmLimit);
|
|
const PDFColorComponent textureSampleShape = isSampled ? 1.0f : 0.0f;
|
|
buffer[textureShapeChannel] = textureSampleShape;
|
|
buffer[textureOpacityChannel] = textureSampleShape;
|
|
}
|
|
};
|
|
PDFExecutionPolicy::execute(PDFExecutionPolicy::Scope::Content, range.begin(), range.end(), processEntry);
|
|
}
|
|
|
|
// Convert image to a blend color space
|
|
texture = convertImageToBlendSpace(texture);
|
|
texturePixelFormat = texture.getPixelFormat();
|
|
textureShapeChannel = texturePixelFormat.getShapeChannelIndex();
|
|
textureOpacityChannel = texturePixelFormat.getOpacityChannelIndex();
|
|
|
|
PDFPainterPathSampler clipSampler(m_painterStateStack.top().clipPath, m_settings.samplesCount, 1.0f, fillRect, m_settings.flags.testFlag(PDFTransparencyRendererSettings::PrecisePathSampler));
|
|
PDFPainterPathSampler pathSampler(worldPath, m_settings.samplesCount, 0.0f, fillRect, m_settings.flags.testFlag(PDFTransparencyRendererSettings::PrecisePathSampler));
|
|
|
|
const PDFReal constantShape = stroke ? getShapeStroking() : getShapeFilling();
|
|
const PDFReal constantOpacity = stroke ? getOpacityStroking() : getOpacityFilling();
|
|
|
|
Q_ASSERT(m_drawBuffer.getPixelFormat() == texture.getPixelFormat());
|
|
|
|
const PDFPixelFormat drawBufferPixelFormat = m_drawBuffer.getPixelFormat();
|
|
const uint8_t drawBufferShapeChannel = drawBufferPixelFormat.getShapeChannelIndex();
|
|
const uint8_t drawBufferOpacityChannel = drawBufferPixelFormat.getOpacityChannelIndex();
|
|
const uint32_t colorChannelStart = drawBufferPixelFormat.getColorChannelIndexStart();
|
|
const uint32_t colorChannelEnd = drawBufferPixelFormat.getColorChannelIndexEnd();
|
|
|
|
for (int x = fillRect.left(); x <= fillRect.right(); ++x)
|
|
{
|
|
for (int y = fillRect.top(); y <= fillRect.bottom(); ++y)
|
|
{
|
|
const int texelCoordinateX = x - fillRect.left();
|
|
const int texelCoordinateY = y - fillRect.top();
|
|
PDFColorBuffer texel = texture.getPixel(texelCoordinateX, texelCoordinateY);
|
|
|
|
const PDFColorComponent textureShape = texel[drawBufferShapeChannel];
|
|
const PDFColorComponent textureOpacity = texel[drawBufferOpacityChannel];
|
|
const PDFColorComponent clipValue = clipSampler.sample(QPoint(x, y));
|
|
const PDFColorComponent objectShapeValue = pathSampler.sample(QPoint(x, y));
|
|
const PDFColorComponent shapeValue = objectShapeValue * clipValue * constantShape * textureShape;
|
|
const PDFColorComponent opacityValue = shapeValue * constantOpacity * textureOpacity;
|
|
|
|
if (shapeValue > 0.0f)
|
|
{
|
|
// We consider old object shape - we use Union function to
|
|
// set shape channel value.
|
|
|
|
PDFColorBuffer pixel = m_drawBuffer.getPixel(x, y);
|
|
pixel[drawBufferShapeChannel] = PDFBlendFunction::blend_Union(shapeValue, pixel[drawBufferShapeChannel]);
|
|
pixel[drawBufferOpacityChannel] = opacityValue;
|
|
|
|
// Copy color
|
|
for (uint8_t colorChannelIndex = colorChannelStart; colorChannelIndex < colorChannelEnd; ++colorChannelIndex)
|
|
{
|
|
pixel[colorChannelIndex] = texel[colorChannelIndex];
|
|
}
|
|
|
|
m_drawBuffer.markPixelActiveColorMask(x, y, texture.getPixelActiveColorMask(texelCoordinateX, texelCoordinateY));
|
|
}
|
|
}
|
|
}
|
|
|
|
m_drawBuffer.modify(fillRect, fill, stroke);
|
|
return true;
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performFinishPathPainting()
|
|
{
|
|
flushDrawBuffer();
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performClipping(const QPainterPath& path, Qt::FillRule fillRule)
|
|
{
|
|
Q_UNUSED(fillRule);
|
|
|
|
PDFTransparencyPainterState* painterState = getPainterState();
|
|
|
|
if (!painterState->clipPath.isEmpty())
|
|
{
|
|
painterState->clipPath = painterState->clipPath.intersected(getCurrentWorldMatrix().map(path));
|
|
}
|
|
else
|
|
{
|
|
painterState->clipPath = getCurrentWorldMatrix().map(path);
|
|
}
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performUpdateGraphicsState(const PDFPageContentProcessorState& state)
|
|
{
|
|
PDFPageContentProcessorState::StateFlags stateFlags = state.getStateFlags();
|
|
|
|
const bool colorTransformAffected = stateFlags.testFlag(PDFPageContentProcessorState::StateRenderingIntent) ||
|
|
stateFlags.testFlag(PDFPageContentProcessorState::StateBlackPointCompensation);
|
|
|
|
if (colorTransformAffected ||
|
|
stateFlags.testFlag(PDFPageContentProcessorState::StateStrokeColor) ||
|
|
stateFlags.testFlag(PDFPageContentProcessorState::StateStrokeColorSpace))
|
|
{
|
|
m_mappedStrokeColor.dirty();
|
|
}
|
|
|
|
if (colorTransformAffected ||
|
|
stateFlags.testFlag(PDFPageContentProcessorState::StateFillColor) ||
|
|
stateFlags.testFlag(PDFPageContentProcessorState::StateFillColorSpace))
|
|
{
|
|
m_mappedFillColor.dirty();
|
|
}
|
|
|
|
BaseClass::performUpdateGraphicsState(state);
|
|
|
|
if (stateFlags.testFlag(PDFPageContentProcessorState::StateSoftMask))
|
|
{
|
|
processSoftMask(state.getSoftMask());
|
|
}
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performSaveGraphicState(ProcessOrder order)
|
|
{
|
|
if (order == ProcessOrder::AfterOperation)
|
|
{
|
|
m_painterStateStack.push(m_painterStateStack.top());
|
|
}
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performRestoreGraphicState(ProcessOrder order)
|
|
{
|
|
if (order == ProcessOrder::BeforeOperation)
|
|
{
|
|
m_painterStateStack.pop();
|
|
}
|
|
if (order == ProcessOrder::AfterOperation)
|
|
{
|
|
invalidateCachedItems();
|
|
}
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performBeginTransparencyGroup(ProcessOrder order, const PDFTransparencyGroup& transparencyGroup)
|
|
{
|
|
if (order == ProcessOrder::BeforeOperation)
|
|
{
|
|
PDFTransparencyGroupPainterData data;
|
|
data.group = transparencyGroup;
|
|
data.alphaIsShape = getGraphicState()->getAlphaIsShape();
|
|
data.alphaFill = getGraphicState()->getAlphaFilling();
|
|
data.alphaStroke = getGraphicState()->getAlphaStroking();
|
|
data.blendMode = getGraphicState()->getBlendMode();
|
|
data.blackPointCompensationMode = getGraphicState()->getBlackPointCompensationMode();
|
|
data.renderingIntent = getGraphicState()->getRenderingIntent();
|
|
data.blendColorSpace = transparencyGroup.colorSpacePointer;
|
|
|
|
if (!data.blendColorSpace)
|
|
{
|
|
data.blendColorSpace = getBlendColorSpace();
|
|
}
|
|
|
|
// Create initial backdrop, according to 11.4.8 of PDF 2.0 specification.
|
|
// If group is knockout, use initial backdrop.
|
|
data.initialBackdrop = *getBackdrop();
|
|
|
|
if (isTransparencyGroupIsolated())
|
|
{
|
|
// Make initial backdrop transparent
|
|
data.makeInitialBackdropTransparent();
|
|
}
|
|
else if (!isTransparencyGroupKnockout())
|
|
{
|
|
// We have stored alpha_g_i in immediate buffer. We must mix it with alpha_0 to get alpha_i
|
|
const PDFFloatBitmapWithColorSpace* initialBackdrop = getInitialBackdrop();
|
|
const uint8_t opacityChannelIndex = initialBackdrop->getPixelFormat().getOpacityChannelIndex();
|
|
const size_t width = data.initialBackdrop.getWidth();
|
|
const size_t height = data.initialBackdrop.getHeight();
|
|
|
|
for (size_t x = 0; x < width; ++x)
|
|
{
|
|
for (size_t y = 0; y < height; ++y)
|
|
{
|
|
PDFConstColorBuffer oldPixel = initialBackdrop->getPixel(x, y);
|
|
PDFColorBuffer newPixel = data.initialBackdrop.getPixel(x, y);
|
|
newPixel[opacityChannelIndex] = PDFBlendFunction::blend_Union(oldPixel[opacityChannelIndex], newPixel[opacityChannelIndex]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Prepare soft mask
|
|
data.softMask = getPainterState()->softMask;
|
|
|
|
data.initialBackdrop.convertToColorSpace(getCMS(), data.renderingIntent, data.blendColorSpace, this);
|
|
data.immediateBackdrop = data.initialBackdrop;
|
|
|
|
// Jakub Melka: According to 11.4.8 of PDF 2.0 specification, we must
|
|
// initialize f_g_0 and alpha_g_0 to zero. We store f_g_0 and alpha_g_0
|
|
// in the immediate backdrop, so we will make it transparent.
|
|
data.makeImmediateBackdropTransparent();
|
|
|
|
// Create draw buffer
|
|
m_drawBuffer = PDFDrawBuffer(data.immediateBackdrop.getWidth(), data.immediateBackdrop.getHeight(), data.immediateBackdrop.getPixelFormat());
|
|
|
|
m_transparencyGroupDataStack.emplace_back(qMove(data));
|
|
invalidateCachedItems();
|
|
}
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performEndTransparencyGroup(ProcessOrder order, const PDFTransparencyGroup& transparencyGroup)
|
|
{
|
|
Q_UNUSED(transparencyGroup);
|
|
|
|
if (order == ProcessOrder::AfterOperation)
|
|
{
|
|
// "Unblend" the initial backdrop from immediate backdrop, according to 11.4.8
|
|
removeInitialBackdrop();
|
|
|
|
PDFTransparencyGroupPainterData sourceData = qMove(m_transparencyGroupDataStack.back());
|
|
m_transparencyGroupDataStack.pop_back();
|
|
|
|
// Filter inactive colors - clear all colors in immediate mask,
|
|
// which are set to inactive.
|
|
if (sourceData.filterColorsUsingMask)
|
|
{
|
|
const PDFPixelFormat pixelFormat = sourceData.immediateBackdrop.getPixelFormat();
|
|
const uint32_t colorChannelStart = pixelFormat.getColorChannelIndexStart();
|
|
const uint32_t colorChannelEnd = pixelFormat.getColorChannelIndexEnd();
|
|
const uint32_t processColorChannelEnd = pixelFormat.getProcessColorChannelIndexEnd();
|
|
|
|
for (uint32_t colorChannelIndex = colorChannelStart; colorChannelIndex < colorChannelEnd; ++colorChannelIndex)
|
|
{
|
|
const uint32_t flag = 1 << colorChannelIndex;
|
|
if (!(sourceData.activeColorMask & flag))
|
|
{
|
|
const bool isProcessColor = colorChannelIndex < processColorChannelEnd;
|
|
const bool isSubtractive = isProcessColor ? pixelFormat.hasProcessColorsSubtractive() : pixelFormat.hasSpotColorsSubtractive();
|
|
|
|
sourceData.immediateBackdrop.fillChannel(colorChannelIndex, isSubtractive ? 0.0f : 1.0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (sourceData.saveOriginalImage)
|
|
{
|
|
m_originalProcessBitmap = sourceData.immediateBackdrop;
|
|
}
|
|
|
|
// Collapse spot colors
|
|
if (sourceData.transformSpotsToDevice)
|
|
{
|
|
collapseSpotColorsToDeviceColors(sourceData.immediateBackdrop);
|
|
}
|
|
|
|
PDFTransparencyGroupPainterData& targetData = m_transparencyGroupDataStack.back();
|
|
sourceData.immediateBackdrop.convertToColorSpace(getCMS(), targetData.renderingIntent, targetData.blendColorSpace, this);
|
|
|
|
PDFOverprintMode overprintMode = getGraphicState()->getOverprintMode();
|
|
const bool useOverprint = overprintMode.overprintFilling || overprintMode.overprintStroking;
|
|
|
|
PDFFloatBitmap::OverprintMode selectedOverprintMode = PDFFloatBitmap::OverprintMode::NoOveprint;
|
|
if (useOverprint)
|
|
{
|
|
selectedOverprintMode = overprintMode.overprintMode == 0 ? PDFFloatBitmap::OverprintMode::Overprint_Mode_0
|
|
: PDFFloatBitmap::OverprintMode::Overprint_Mode_1;
|
|
}
|
|
|
|
PDFFloatBitmap::blend(sourceData.immediateBackdrop, targetData.immediateBackdrop, *getBackdrop(), *getInitialBackdrop(), *sourceData.softMask.getSoftMask(),
|
|
sourceData.alphaIsShape, sourceData.alphaFill, sourceData.blendMode, sourceData.group.knockout, selectedOverprintMode, getPaintRect());
|
|
|
|
// Create draw buffer
|
|
PDFFloatBitmapWithColorSpace* backdrop = getImmediateBackdrop();
|
|
m_drawBuffer = PDFDrawBuffer(backdrop->getWidth(), backdrop->getHeight(), backdrop->getPixelFormat());
|
|
|
|
invalidateCachedItems();
|
|
}
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performTextBegin(ProcessOrder order)
|
|
{
|
|
if (order == ProcessOrder::AfterOperation && getGraphicState()->getTextKnockout())
|
|
{
|
|
// In a case of text knockout, use text transparency group of type knockout
|
|
PDFTransparencyGroup transparencyGroup;
|
|
transparencyGroup.knockout = true;
|
|
m_textTransparencyGroupGuard.reset(new PDFTransparencyGroupGuard(this, qMove(transparencyGroup)));
|
|
}
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performTextEnd(ProcessOrder order)
|
|
{
|
|
if (order == ProcessOrder::BeforeOperation)
|
|
{
|
|
m_textTransparencyGroupGuard.reset();
|
|
}
|
|
}
|
|
|
|
bool PDFTransparencyRenderer::performOriginalImagePainting(const PDFImage& image)
|
|
{
|
|
PDFFloatBitmap texture = getImage(image);
|
|
|
|
if (m_settings.flags.testFlag(PDFTransparencyRendererSettings::SmoothImageTransformation) && image.isInterpolated())
|
|
{
|
|
// Test, if we can use smooth images. We can use them under following conditions:
|
|
// 1) Transformed rectangle is not skewed or deformed (so vectors (0, 1) and (1, 0) are orthogonal)
|
|
// 2) We are shrinking the image
|
|
// 3) Aspect ratio of the image is the same
|
|
|
|
QTransform matrix = getCurrentWorldMatrix();
|
|
QLineF mappedWidthVector = matrix.map(QLineF(0, 0, texture.getWidth(), 0));
|
|
QLineF mappedHeightVector = matrix.map(QLineF(0, 0, 0, texture.getHeight()));
|
|
qreal angle = mappedWidthVector.angleTo(mappedHeightVector);
|
|
if (qFuzzyCompare(angle, 90.0))
|
|
{
|
|
// Image is not skewed, so we if we are shrinking the image
|
|
const qreal originalWidth = texture.getWidth();
|
|
const qreal originalHeight = texture.getHeight();
|
|
const qreal originalRatio = originalWidth / originalHeight;
|
|
const qreal transformedWidth = mappedWidthVector.length();
|
|
const qreal transformedHeight = mappedHeightVector.length();
|
|
const qreal transformedRatio = transformedWidth / transformedHeight;
|
|
|
|
if (qFuzzyCompare(originalRatio, transformedRatio) && originalWidth > transformedWidth && originalHeight > transformedHeight)
|
|
{
|
|
uint32_t activeColorMask = texture.getPixelActiveColorMask(0, 0);
|
|
texture = texture.resize(qCeil(transformedWidth), qCeil(transformedHeight), Qt::SmoothTransformation);
|
|
texture.setColorActivity(activeColorMask);
|
|
}
|
|
}
|
|
}
|
|
|
|
QTransform imageTransform(1.0 / qreal(texture.getWidth()), 0, 0, 1.0 / qreal(texture.getHeight()), 0, 0);
|
|
QTransform worldMatrix = imageTransform * getCurrentWorldMatrix();
|
|
|
|
// Because Qt uses opposite axis direction than PDF, then we must transform the y-axis
|
|
// to the opposite (so the image is then unchanged)
|
|
worldMatrix.translate(0.0, texture.getHeight());
|
|
worldMatrix.scale(1, -1);
|
|
|
|
QPolygonF imagePolygon;
|
|
imagePolygon << QPointF(0.0, 0.0);
|
|
imagePolygon << QPointF(0.0, texture.getHeight());
|
|
imagePolygon << QPointF(texture.getWidth(), texture.getHeight());
|
|
imagePolygon << QPointF(texture.getWidth(), 0.0);
|
|
|
|
QTransform worldToTextureMatrix = worldMatrix.inverted();
|
|
QRectF boundingRectangle = worldMatrix.map(imagePolygon).boundingRect();
|
|
QRect fillRect = getActualFillRect(boundingRectangle);
|
|
|
|
const PDFReal shape = getShapeFilling();
|
|
const PDFReal opacity = getOpacityFilling();
|
|
|
|
PDFPixelFormat format = m_drawBuffer.getPixelFormat();
|
|
Q_ASSERT(format.hasShapeChannel());
|
|
Q_ASSERT(format.hasOpacityChannel());
|
|
Q_ASSERT(format == texture.getPixelFormat());
|
|
|
|
const uint8_t shapeChannel = format.getShapeChannelIndex();
|
|
const uint8_t opacityChannel = format.getOpacityChannelIndex();
|
|
const uint8_t colorChannelStart = format.getColorChannelIndexStart();
|
|
const uint8_t colorChannelEnd = format.getColorChannelIndexEnd();
|
|
|
|
// Fill rect may be, or may not be valid. It depends on the painter path
|
|
// and world matrix. Path can be translated outside of the paint area.
|
|
if (fillRect.isValid())
|
|
{
|
|
PDFPainterPathSampler clipSampler(m_painterStateStack.top().clipPath, m_settings.samplesCount, 1.0f, fillRect, m_settings.flags.testFlag(PDFTransparencyRendererSettings::PrecisePathSampler));
|
|
|
|
if (isMultithreadedPathSamplingUsed(fillRect))
|
|
{
|
|
if (fillRect.width() > fillRect.height())
|
|
{
|
|
// Columns
|
|
PDFIntegerRange<int> range(fillRect.left(), fillRect.right() + 1);
|
|
auto processEntry = [&, this](int x)
|
|
{
|
|
for (int y = fillRect.top(); y <= fillRect.bottom(); ++y)
|
|
{
|
|
performFillFragmentFromTexture(shape, opacity, shapeChannel, opacityChannel, colorChannelStart, colorChannelEnd, x, y, worldToTextureMatrix, texture, clipSampler);
|
|
}
|
|
};
|
|
PDFExecutionPolicy::execute(PDFExecutionPolicy::Scope::Content, range.begin(), range.end(), processEntry);
|
|
}
|
|
else
|
|
{
|
|
// Rows
|
|
PDFIntegerRange<int> range(fillRect.top(), fillRect.bottom() + 1);
|
|
auto processEntry = [&, this](int y)
|
|
{
|
|
for (int x = fillRect.left(); x <= fillRect.right(); ++x)
|
|
{
|
|
performFillFragmentFromTexture(shape, opacity, shapeChannel, opacityChannel, colorChannelStart, colorChannelEnd, x, y, worldToTextureMatrix, texture, clipSampler);
|
|
}
|
|
};
|
|
PDFExecutionPolicy::execute(PDFExecutionPolicy::Scope::Content, range.begin(), range.end(), processEntry);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int x = fillRect.left(); x <= fillRect.right(); ++x)
|
|
{
|
|
for (int y = fillRect.top(); y <= fillRect.bottom(); ++y)
|
|
{
|
|
performFillFragmentFromTexture(shape, opacity, shapeChannel, opacityChannel, colorChannelStart, colorChannelEnd, x, y, worldToTextureMatrix, texture, clipSampler);
|
|
}
|
|
}
|
|
}
|
|
|
|
m_drawBuffer.modify(fillRect, true, false);
|
|
flushDrawBuffer();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performImagePainting(const QImage& image)
|
|
{
|
|
Q_UNUSED(image);
|
|
|
|
reportRenderErrorOnce(RenderErrorType::NotImplemented, PDFTranslationContext::tr("Image painting not implemented."));
|
|
}
|
|
|
|
void PDFTransparencyRenderer::performMeshPainting(const PDFMesh& mesh)
|
|
{
|
|
Q_UNUSED(mesh);
|
|
|
|
reportRenderErrorOnce(RenderErrorType::NotImplemented, PDFTranslationContext::tr("Mesh painting not implemented."));
|
|
}
|
|
|
|
PDFReal PDFTransparencyRenderer::getShapeStroking() const
|
|
{
|
|
return getGraphicState()->getAlphaIsShape() ? getGraphicState()->getAlphaStroking() : 1.0;
|
|
}
|
|
|
|
PDFReal PDFTransparencyRenderer::getOpacityStroking() const
|
|
{
|
|
return !getGraphicState()->getAlphaIsShape() ? getGraphicState()->getAlphaStroking() : 1.0;
|
|
}
|
|
|
|
PDFReal PDFTransparencyRenderer::getShapeFilling() const
|
|
{
|
|
return getGraphicState()->getAlphaIsShape() ? getGraphicState()->getAlphaFilling() : 1.0;
|
|
}
|
|
|
|
PDFReal PDFTransparencyRenderer::getOpacityFilling() const
|
|
{
|
|
return !getGraphicState()->getAlphaIsShape() ? getGraphicState()->getAlphaFilling() : 1.0;
|
|
}
|
|
|
|
void PDFTransparencyRenderer::invalidateCachedItems()
|
|
{
|
|
m_mappedStrokeColor.dirty();
|
|
m_mappedFillColor.dirty();
|
|
}
|
|
|
|
void PDFTransparencyRenderer::removeInitialBackdrop()
|
|
{
|
|
PDFFloatBitmapWithColorSpace* immediateBackdrop = getImmediateBackdrop();
|
|
PDFFloatBitmapWithColorSpace* initialBackdrop = getInitialBackdrop();
|
|
PDFPixelFormat pixelFormat = immediateBackdrop->getPixelFormat();
|
|
|
|
const uint8_t alphaChannelIndex = pixelFormat.getOpacityChannelIndex();
|
|
const uint8_t colorChannelIndexStart = pixelFormat.getColorChannelIndexStart();
|
|
const uint8_t colorChannelIndexEnd= pixelFormat.getColorChannelIndexEnd();
|
|
|
|
Q_ASSERT(alphaChannelIndex != PDFPixelFormat::INVALID_CHANNEL_INDEX);
|
|
Q_ASSERT(colorChannelIndexStart != PDFPixelFormat::INVALID_CHANNEL_INDEX);
|
|
Q_ASSERT(colorChannelIndexEnd != PDFPixelFormat::INVALID_CHANNEL_INDEX);
|
|
|
|
for (size_t x = 0; x < immediateBackdrop->getWidth(); ++x)
|
|
{
|
|
for (size_t y = 0; y < immediateBackdrop->getHeight(); ++y)
|
|
{
|
|
PDFColorBuffer initialBackdropColorBuffer = initialBackdrop->getPixel(x, y);
|
|
PDFColorBuffer immediateBackdropColorBuffer = immediateBackdrop->getPixel(x, y);
|
|
|
|
const PDFColorComponent alpha_0 = initialBackdropColorBuffer[alphaChannelIndex];
|
|
const PDFColorComponent alpha_g_n = immediateBackdropColorBuffer[alphaChannelIndex];
|
|
|
|
if (!qFuzzyIsNull(alpha_g_n))
|
|
{
|
|
for (uint8_t i = colorChannelIndexStart; i < colorChannelIndexEnd; ++i)
|
|
{
|
|
const PDFColorComponent C_0 = initialBackdropColorBuffer[i];
|
|
const PDFColorComponent C_n = immediateBackdropColorBuffer[i];
|
|
const PDFColorComponent C = C_n + (C_n - C_0) * alpha_0 * (1.0f / alpha_g_n - 1.0f);
|
|
const PDFColorComponent C_clipped = qBound(0.0f, C, 1.0f);
|
|
immediateBackdropColorBuffer[i] = C_clipped;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
PDFFloatBitmapWithColorSpace* PDFTransparencyRenderer::getInitialBackdrop()
|
|
{
|
|
return &m_transparencyGroupDataStack.back().initialBackdrop;
|
|
}
|
|
|
|
PDFFloatBitmapWithColorSpace* PDFTransparencyRenderer::getImmediateBackdrop()
|
|
{
|
|
return &m_transparencyGroupDataStack.back().immediateBackdrop;
|
|
}
|
|
|
|
PDFFloatBitmapWithColorSpace* PDFTransparencyRenderer::getBackdrop()
|
|
{
|
|
if (isTransparencyGroupKnockout())
|
|
{
|
|
return getInitialBackdrop();
|
|
}
|
|
else
|
|
{
|
|
return getImmediateBackdrop();
|
|
}
|
|
}
|
|
|
|
const PDFFloatBitmapWithColorSpace* PDFTransparencyRenderer::getInitialBackdrop() const
|
|
{
|
|
return &m_transparencyGroupDataStack.back().initialBackdrop;
|
|
}
|
|
|
|
const PDFFloatBitmapWithColorSpace* PDFTransparencyRenderer::getImmediateBackdrop() const
|
|
{
|
|
return &m_transparencyGroupDataStack.back().immediateBackdrop;
|
|
}
|
|
|
|
const PDFFloatBitmapWithColorSpace* PDFTransparencyRenderer::getBackdrop() const
|
|
{
|
|
if (isTransparencyGroupKnockout())
|
|
{
|
|
return getInitialBackdrop();
|
|
}
|
|
else
|
|
{
|
|
return getImmediateBackdrop();
|
|
}
|
|
}
|
|
|
|
const PDFColorSpacePointer& PDFTransparencyRenderer::getBlendColorSpace() const
|
|
{
|
|
return m_transparencyGroupDataStack.back().blendColorSpace;
|
|
}
|
|
|
|
bool PDFTransparencyRenderer::isTransparencyGroupIsolated() const
|
|
{
|
|
return m_transparencyGroupDataStack.back().group.isolated;
|
|
}
|
|
|
|
bool PDFTransparencyRenderer::isTransparencyGroupKnockout() const
|
|
{
|
|
return m_transparencyGroupDataStack.back().group.knockout;
|
|
}
|
|
|
|
const PDFTransparencyRenderer::PDFMappedColor& PDFTransparencyRenderer::getMappedStrokeColor()
|
|
{
|
|
return m_mappedStrokeColor.get(this, &PDFTransparencyRenderer::getMappedStrokeColorImpl);
|
|
}
|
|
|
|
const PDFTransparencyRenderer::PDFMappedColor& PDFTransparencyRenderer::getMappedFillColor()
|
|
{
|
|
return m_mappedFillColor.get(this, &PDFTransparencyRenderer::getMappedFillColorImpl);
|
|
}
|
|
|
|
void PDFTransparencyRenderer::fillMappedColorUsingMapping(const PDFPixelFormat pixelFormat,
|
|
PDFMappedColor& result,
|
|
const PDFInkMapping& inkMapping,
|
|
const PDFColor& sourceColor)
|
|
{
|
|
result.mappedColor.resize(pixelFormat.getColorChannelCount());
|
|
|
|
// Zero the color
|
|
for (size_t i = 0; i < pixelFormat.getColorChannelCount(); ++i)
|
|
{
|
|
result.mappedColor[i] = 0.0f;
|
|
}
|
|
|
|
for (const PDFInkMapping::Mapping& ink : inkMapping.mapping)
|
|
{
|
|
// Sanity check of source color
|
|
if (ink.source >= sourceColor.size())
|
|
{
|
|
reportRenderError(RenderErrorType::Error, PDFTranslationContext::tr("Invalid source ink index %1.").arg(ink.source));
|
|
continue;
|
|
}
|
|
|
|
// Sanity check of target color
|
|
if (ink.target >= result.mappedColor.size())
|
|
{
|
|
reportRenderError(RenderErrorType::Error, PDFTranslationContext::tr("Invalid target ink index %1.").arg(ink.target));
|
|
continue;
|
|
}
|
|
|
|
switch (ink.type)
|
|
{
|
|
case pdf::PDFInkMapping::Pass:
|
|
result.mappedColor[ink.target] = sourceColor[ink.source];
|
|
break;
|
|
|
|
default:
|
|
Q_ASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
result.activeChannels = inkMapping.activeChannels;
|
|
}
|
|
|
|
PDFTransparencyRenderer::PDFMappedColor PDFTransparencyRenderer::createMappedColor(const PDFColor& sourceColor, const PDFAbstractColorSpace* sourceColorSpace)
|
|
{
|
|
PDFMappedColor result;
|
|
|
|
const PDFAbstractColorSpace* targetColorSpace = getBlendColorSpace().data();
|
|
const PDFPixelFormat pixelFormat = getImmediateBackdrop()->getPixelFormat();
|
|
|
|
Q_ASSERT(targetColorSpace->equals(getImmediateBackdrop()->getColorSpace().data()));
|
|
|
|
PDFInkMapping inkMapping = m_inkMapper->createMapping(sourceColorSpace, targetColorSpace, pixelFormat);
|
|
if (inkMapping.isValid())
|
|
{
|
|
fillMappedColorUsingMapping(pixelFormat, result, inkMapping, sourceColor);
|
|
}
|
|
else
|
|
{
|
|
// Jakub Melka: We must convert color form source color space to target color space
|
|
std::vector<PDFColorComponent> sourceColorVector(sourceColor.size(), 0.0f);
|
|
for (size_t i = 0; i < sourceColorVector.size(); ++i)
|
|
{
|
|
sourceColorVector[i] = sourceColor[i];
|
|
}
|
|
PDFColorBuffer sourceColorBuffer(sourceColorVector.data(), sourceColorVector.size());
|
|
|
|
std::vector<PDFColorComponent> targetColorVector(pixelFormat.getProcessColorChannelCount(), 0.0f);
|
|
PDFColorBuffer targetColorBuffer(targetColorVector.data(), targetColorVector.size());
|
|
|
|
if (!PDFAbstractColorSpace::transform(sourceColorSpace, targetColorSpace, getCMS(), getGraphicState()->getRenderingIntent(), sourceColorBuffer, targetColorBuffer, this))
|
|
{
|
|
reportRenderError(RenderErrorType::Error, PDFTranslationContext::tr("Transformation from source color space to target blending color space failed."));
|
|
}
|
|
|
|
PDFColor adjustedSourceColor;
|
|
adjustedSourceColor.resize(targetColorBuffer.size());
|
|
|
|
for (size_t i = 0; i < targetColorBuffer.size(); ++i)
|
|
{
|
|
adjustedSourceColor[i] = targetColorBuffer[i];
|
|
}
|
|
|
|
inkMapping = m_inkMapper->createMapping(targetColorSpace, targetColorSpace, pixelFormat);
|
|
|
|
Q_ASSERT(inkMapping.isValid());
|
|
fillMappedColorUsingMapping(pixelFormat, result, inkMapping, adjustedSourceColor);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
PDFTransparencyRenderer::PDFMappedColor PDFTransparencyRenderer::getMappedStrokeColorImpl()
|
|
{
|
|
const PDFAbstractColorSpace* sourceColorSpace = getGraphicState()->getStrokeColorSpace();
|
|
const PDFColor& sourceColor = getGraphicState()->getStrokeColorOriginal();
|
|
|
|
return createMappedColor(sourceColor, sourceColorSpace);
|
|
}
|
|
|
|
PDFTransparencyRenderer::PDFMappedColor PDFTransparencyRenderer::getMappedFillColorImpl()
|
|
{
|
|
const PDFAbstractColorSpace* sourceColorSpace = getGraphicState()->getFillColorSpace();
|
|
const PDFColor& sourceColor = getGraphicState()->getFillColorOriginal();
|
|
|
|
return createMappedColor(sourceColor, sourceColorSpace);
|
|
}
|
|
|
|
QRect PDFTransparencyRenderer::getPaintRect() const
|
|
{
|
|
return QRect(0, 0, int(getBackdrop()->getWidth()), int(getBackdrop()->getHeight()));
|
|
}
|
|
|
|
QRect PDFTransparencyRenderer::getActualFillRect(const QRectF& fillRect) const
|
|
{
|
|
int xLeft = qFloor(fillRect.left()) - 1;
|
|
int xRight = qCeil(fillRect.right()) + 1;
|
|
int yTop = qFloor(fillRect.top()) - 1;
|
|
int yBottom = qCeil(fillRect.bottom()) + 1;
|
|
|
|
QRect drawRect(xLeft, yTop, xRight - xLeft, yBottom - yTop);
|
|
return getPaintRect().intersected(drawRect);
|
|
}
|
|
|
|
void PDFTransparencyRenderer::flushDrawBuffer()
|
|
{
|
|
if (m_drawBuffer.isModified())
|
|
{
|
|
PDFOverprintMode overprintMode = getGraphicState()->getOverprintMode();
|
|
const bool useOverprint = (overprintMode.overprintFilling && m_drawBuffer.isContainsFilling()) ||
|
|
(overprintMode.overprintStroking && m_drawBuffer.isContainsStroking());
|
|
|
|
PDFFloatBitmap::OverprintMode selectedOverprintMode = PDFFloatBitmap::OverprintMode::NoOveprint;
|
|
if (useOverprint)
|
|
{
|
|
selectedOverprintMode = overprintMode.overprintMode == 0 ? PDFFloatBitmap::OverprintMode::Overprint_Mode_0
|
|
: PDFFloatBitmap::OverprintMode::Overprint_Mode_1;
|
|
}
|
|
|
|
PDFFloatBitmap::blend(m_drawBuffer, *getImmediateBackdrop(), *getBackdrop(), *getInitialBackdrop(), *getPainterState()->softMask.getSoftMask(),
|
|
getGraphicState()->getAlphaIsShape(), 1.0f, getGraphicState()->getBlendMode(), isTransparencyGroupKnockout(),
|
|
selectedOverprintMode, m_drawBuffer.getModifiedRect());
|
|
|
|
|
|
m_drawBuffer.clear();
|
|
}
|
|
}
|
|
|
|
bool PDFTransparencyRenderer::isMultithreadedPathSamplingUsed(QRect fillRect) const
|
|
{
|
|
if (!m_settings.flags.testFlag(PDFTransparencyRendererSettings::MultithreadedPathSampler))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return fillRect.width() * fillRect.height() > m_settings.multithreadingPathSampleThreshold && fillRect.width() > 1;
|
|
}
|
|
|
|
PDFInkMapper::PDFInkMapper(const PDFCMSManager* manager, const PDFDocument* document) :
|
|
m_cmsManager(manager),
|
|
m_document(document)
|
|
{
|
|
// Initialize device separations
|
|
std::vector<ColorInfo> graySeparations = getSeparations(1, false);
|
|
std::vector<ColorInfo> rgbSeparations = getSeparations(3, false);
|
|
std::vector<ColorInfo> cmykSeparations = getSeparations(4, false);
|
|
|
|
m_deviceColors.insert(m_deviceColors.end(), std::make_move_iterator(graySeparations.begin()), std::make_move_iterator(graySeparations.end()));
|
|
m_deviceColors.insert(m_deviceColors.end(), std::make_move_iterator(rgbSeparations.begin()), std::make_move_iterator(rgbSeparations.end()));
|
|
m_deviceColors.insert(m_deviceColors.end(), std::make_move_iterator(cmykSeparations.begin()), std::make_move_iterator(cmykSeparations.end()));
|
|
}
|
|
|
|
std::vector<PDFInkMapper::ColorInfo> PDFInkMapper::getSeparations(uint32_t processColorCount, bool withSpots) const
|
|
{
|
|
std::vector<ColorInfo> result;
|
|
result.reserve(getActiveSpotColorCount() + processColorCount);
|
|
|
|
PDFRenderErrorReporterDummy renderErrorReporter;
|
|
PDFCMSPointer cms = m_cmsManager ? m_cmsManager->getCurrentCMS() : nullptr;
|
|
|
|
switch (processColorCount)
|
|
{
|
|
case 1:
|
|
{
|
|
PDFDeviceGrayColorSpace grayColorSpace;
|
|
|
|
ColorInfo gray;
|
|
gray.name = "Gray";
|
|
gray.textName = PDFTranslationContext::tr("Gray");
|
|
gray.canBeActive = true;
|
|
gray.active = true;
|
|
gray.isSpot = false;
|
|
gray.spotColorIndex = 0;
|
|
gray.colorSpaceType = PDFAbstractColorSpace::ColorSpace::DeviceGray;
|
|
gray.color = cms ? grayColorSpace.getColor(PDFColor(1.0f), cms.get(), RenderingIntent::Perceptual, &renderErrorReporter, true) : QColor();
|
|
result.emplace_back(qMove(gray));
|
|
break;
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
PDFDeviceRGBColorSpace rgbColorSpace;
|
|
|
|
ColorInfo red;
|
|
red.name = "Red";
|
|
red.textName = PDFTranslationContext::tr("Red");
|
|
red.canBeActive = true;
|
|
red.active = true;
|
|
red.isSpot = false;
|
|
red.spotColorIndex = 0;
|
|
red.colorSpaceType = PDFAbstractColorSpace::ColorSpace::DeviceRGB;
|
|
red.color = cms ? rgbColorSpace.getColor(PDFColor(1.0f, 0.0f, 0.0f), cms.get(), RenderingIntent::Perceptual, &renderErrorReporter, true) : QColor();
|
|
result.emplace_back(qMove(red));
|
|
|
|
ColorInfo green;
|
|
green.name = "Green";
|
|
green.textName = PDFTranslationContext::tr("Green");
|
|
green.canBeActive = true;
|
|
green.active = true;
|
|
green.isSpot = false;
|
|
green.spotColorIndex = 1;
|
|
green.colorSpaceType = PDFAbstractColorSpace::ColorSpace::DeviceRGB;
|
|
green.color = cms ? rgbColorSpace.getColor(PDFColor(0.0f, 1.0f, 0.0f), cms.get(), RenderingIntent::Perceptual, &renderErrorReporter, true) : QColor();
|
|
result.emplace_back(qMove(green));
|
|
|
|
ColorInfo blue;
|
|
blue.name = "Blue";
|
|
blue.textName = PDFTranslationContext::tr("Blue");
|
|
blue.canBeActive = true;
|
|
blue.active = true;
|
|
blue.isSpot = false;
|
|
blue.spotColorIndex = 2;
|
|
blue.colorSpaceType = PDFAbstractColorSpace::ColorSpace::DeviceRGB;
|
|
blue.color = cms ? rgbColorSpace.getColor(PDFColor(0.0f, 0.0f, 1.0f), cms.get(), RenderingIntent::Perceptual, &renderErrorReporter, true) : QColor();
|
|
result.emplace_back(qMove(blue));
|
|
break;
|
|
}
|
|
|
|
case 4:
|
|
{
|
|
PDFDeviceCMYKColorSpace cmykColorSpace;
|
|
|
|
ColorInfo cyan;
|
|
cyan.name = "Cyan";
|
|
cyan.textName = PDFTranslationContext::tr("Cyan");
|
|
cyan.canBeActive = true;
|
|
cyan.active = true;
|
|
cyan.isSpot = false;
|
|
cyan.spotColorIndex = 0;
|
|
cyan.colorSpaceType = PDFAbstractColorSpace::ColorSpace::DeviceCMYK;
|
|
cyan.color = cms ? cmykColorSpace.getColor(PDFColor(1.0f, 0.0f, 0.0f, 0.0f), cms.get(), RenderingIntent::Perceptual, &renderErrorReporter, true) : QColor();
|
|
result.emplace_back(qMove(cyan));
|
|
|
|
ColorInfo magenta;
|
|
magenta.name = "Magenta";
|
|
magenta.textName = PDFTranslationContext::tr("Magenta");
|
|
magenta.canBeActive = true;
|
|
magenta.active = true;
|
|
magenta.isSpot = false;
|
|
magenta.spotColorIndex = 1;
|
|
magenta.colorSpaceType = PDFAbstractColorSpace::ColorSpace::DeviceCMYK;
|
|
magenta.color = cms ? cmykColorSpace.getColor(PDFColor(0.0f, 1.0f, 0.0f, 0.0f), cms.get(), RenderingIntent::Perceptual, &renderErrorReporter, true) : QColor();
|
|
result.emplace_back(qMove(magenta));
|
|
|
|
ColorInfo yellow;
|
|
yellow.name = "Yellow";
|
|
yellow.textName = PDFTranslationContext::tr("Yellow");
|
|
yellow.canBeActive = true;
|
|
yellow.active = true;
|
|
yellow.isSpot = false;
|
|
yellow.spotColorIndex = 2;
|
|
yellow.colorSpaceType = PDFAbstractColorSpace::ColorSpace::DeviceCMYK;
|
|
yellow.color = cms ? cmykColorSpace.getColor(PDFColor(0.0f, 0.0f, 1.0f, 0.0f), cms.get(), RenderingIntent::Perceptual, &renderErrorReporter, true) : QColor();
|
|
result.emplace_back(qMove(yellow));
|
|
|
|
ColorInfo black;
|
|
black.name = "Black";
|
|
black.textName = PDFTranslationContext::tr("Black");
|
|
black.canBeActive = true;
|
|
black.active = true;
|
|
black.isSpot = false;
|
|
black.spotColorIndex = 3;
|
|
black.colorSpaceType = PDFAbstractColorSpace::ColorSpace::DeviceCMYK;
|
|
black.color = cms ? cmykColorSpace.getColor(PDFColor(0.0f, 0.0f, 0.0f, 1.0f), cms.get(), RenderingIntent::Perceptual, &renderErrorReporter, true) : QColor();
|
|
result.emplace_back(qMove(black));
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
for (uint32_t i = 0; i < processColorCount; ++i)
|
|
{
|
|
ColorInfo generic;
|
|
generic.textName = PDFTranslationContext::tr("Process Generic%1").arg(i + 1);
|
|
generic.name = generic.textName.toLatin1();
|
|
generic.canBeActive = true;
|
|
generic.active = true;
|
|
generic.isSpot = false;
|
|
generic.spotColorIndex = i;
|
|
result.emplace_back(qMove(generic));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (withSpots)
|
|
{
|
|
for (const auto& spotColor : m_spotColors)
|
|
{
|
|
if (!spotColor.active)
|
|
{
|
|
// Skip inactive spot colors
|
|
continue;
|
|
}
|
|
|
|
result.emplace_back(spotColor);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void PDFInkMapper::createSpotColors(bool activate)
|
|
{
|
|
m_spotColors.clear();
|
|
m_activeSpotColors = 0;
|
|
|
|
PDFRenderErrorReporterDummy renderErrorReporter;
|
|
PDFCMSPointer cms = m_cmsManager ? m_cmsManager->getCurrentCMS() : nullptr;
|
|
|
|
const PDFCatalog* catalog = m_document->getCatalog();
|
|
const size_t pageCount = catalog->getPageCount();
|
|
for (size_t i = 0; i < pageCount; ++i)
|
|
{
|
|
const PDFPage* page = catalog->getPage(i);
|
|
PDFObject resources = m_document->getObject(page->getResources());
|
|
|
|
if (resources.isDictionary() && resources.getDictionary()->hasKey("ColorSpace"))
|
|
{
|
|
const PDFDictionary* colorSpaceDictionary = m_document->getDictionaryFromObject(resources.getDictionary()->get("ColorSpace"));
|
|
if (colorSpaceDictionary)
|
|
{
|
|
std::size_t colorSpaces = colorSpaceDictionary->getCount();
|
|
for (size_t csIndex = 0; csIndex < colorSpaces; ++ csIndex)
|
|
{
|
|
PDFColorSpacePointer colorSpacePointer;
|
|
try
|
|
{
|
|
colorSpacePointer = PDFAbstractColorSpace::createColorSpace(colorSpaceDictionary, m_document, m_document->getObject(colorSpaceDictionary->getValue(csIndex)));
|
|
}
|
|
catch (const PDFException&)
|
|
{
|
|
// Ignore invalid color spaces
|
|
continue;
|
|
}
|
|
|
|
if (!colorSpacePointer)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
switch (colorSpacePointer->getColorSpace())
|
|
{
|
|
case PDFAbstractColorSpace::ColorSpace::Separation:
|
|
{
|
|
const PDFSeparationColorSpace* separationColorSpace = dynamic_cast<const PDFSeparationColorSpace*>(colorSpacePointer.data());
|
|
|
|
if (!separationColorSpace->isNone() && !separationColorSpace->isAll() && !separationColorSpace->getColorName().isEmpty())
|
|
{
|
|
// Try to add spot color
|
|
const QByteArray& colorName = separationColorSpace->getColorName();
|
|
if (!containsSpotColor(colorName) && !containsProcessColor(colorName))
|
|
{
|
|
ColorInfo info;
|
|
info.name = colorName;
|
|
info.textName = PDFEncoding::convertTextString(info.name);
|
|
info.colorSpace = colorSpacePointer;
|
|
info.spotColorIndex = uint32_t(m_spotColors.size());
|
|
info.color = cms ? separationColorSpace->getColor(pdf::PDFColor(1.0f), cms.get(), pdf::RenderingIntent::Perceptual, &renderErrorReporter, true) : nullptr;
|
|
m_spotColors.emplace_back(qMove(info));
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case PDFAbstractColorSpace::ColorSpace::DeviceN:
|
|
{
|
|
const PDFDeviceNColorSpace* deviceNColorSpace = dynamic_cast<const PDFDeviceNColorSpace*>(colorSpacePointer.data());
|
|
|
|
if (!deviceNColorSpace->isNone())
|
|
{
|
|
const PDFDeviceNColorSpace::Colorants& colorants = deviceNColorSpace->getColorants();
|
|
for (size_t ii = 0; ii < colorants.size(); ++ii)
|
|
{
|
|
const PDFDeviceNColorSpace::ColorantInfo& colorantInfo = colorants[ii];
|
|
if (!containsSpotColor(colorantInfo.name) && !containsProcessColor(colorantInfo.name))
|
|
{
|
|
PDFColor color;
|
|
color.resize(deviceNColorSpace->getColorComponentCount());
|
|
color[ii] = 1.0f;
|
|
|
|
ColorInfo info;
|
|
info.name = colorantInfo.name;
|
|
info.textName = PDFEncoding::convertTextString(info.name);
|
|
info.colorSpaceIndex = uint32_t(ii);
|
|
info.colorSpace = colorSpacePointer;
|
|
info.spotColorIndex = uint32_t(m_spotColors.size());
|
|
info.color = cms ? deviceNColorSpace->getColor(color, cms.get(), pdf::RenderingIntent::Perceptual, &renderErrorReporter, true) : nullptr;
|
|
m_spotColors.emplace_back(qMove(info));
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t minIndex = qMin<uint32_t>(uint32_t(m_spotColors.size()), MAX_SPOT_COLOR_COMPONENTS);
|
|
for (size_t i = 0; i < minIndex; ++i)
|
|
{
|
|
m_spotColors[i].canBeActive = true;
|
|
}
|
|
|
|
setSpotColorsActive(activate);
|
|
}
|
|
|
|
bool PDFInkMapper::containsSpotColor(const QByteArray& colorName) const
|
|
{
|
|
return getSpotColor(colorName) != nullptr;
|
|
}
|
|
|
|
bool PDFInkMapper::containsProcessColor(const QByteArray& colorName) const
|
|
{
|
|
return getProcessColor(colorName) != nullptr;
|
|
}
|
|
|
|
const PDFInkMapper::ColorInfo* PDFInkMapper::getSpotColor(const QByteArray& colorName) const
|
|
{
|
|
auto it = std::find_if(m_spotColors.cbegin(), m_spotColors.cend(), [&colorName](const auto& info) { return info.name == colorName; });
|
|
if (it != m_spotColors.cend())
|
|
{
|
|
return &*it;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
const PDFInkMapper::ColorInfo* PDFInkMapper::getProcessColor(const QByteArray& colorName) const
|
|
{
|
|
auto it = std::find_if(m_deviceColors.cbegin(), m_deviceColors.cend(), [&colorName](const auto& info) { return info.name == colorName; });
|
|
if (it != m_deviceColors.cend())
|
|
{
|
|
return &*it;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
const PDFInkMapper::ColorInfo* PDFInkMapper::getActiveProcessColor(const QByteArray& colorName, PDFAbstractColorSpace::ColorSpace colorSpace) const
|
|
{
|
|
auto it = std::find_if(m_deviceColors.cbegin(), m_deviceColors.cend(), [&colorName, colorSpace](const auto& info) { return info.name == colorName && info.active && info.colorSpaceType == colorSpace; });
|
|
if (it != m_deviceColors.cend())
|
|
{
|
|
return &*it;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
const PDFInkMapper::ColorInfo* PDFInkMapper::getActiveSpotColor(size_t index) const
|
|
{
|
|
for (const ColorInfo& info : m_spotColors)
|
|
{
|
|
if (info.active)
|
|
{
|
|
if (index == 0)
|
|
{
|
|
return &info;
|
|
}
|
|
|
|
--index;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void PDFInkMapper::setSpotColorsActive(bool active)
|
|
{
|
|
m_activeSpotColors = 0;
|
|
|
|
if (active)
|
|
{
|
|
for (auto& spotColor : m_spotColors)
|
|
{
|
|
if (spotColor.canBeActive)
|
|
{
|
|
spotColor.active = true;
|
|
++m_activeSpotColors;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (auto& spotColor : m_spotColors)
|
|
{
|
|
spotColor.active = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
PDFInkMapping PDFInkMapper::createMapping(const PDFAbstractColorSpace* sourceColorSpace,
|
|
const PDFAbstractColorSpace* targetColorSpace,
|
|
PDFPixelFormat targetPixelFormat) const
|
|
{
|
|
PDFInkMapping mapping;
|
|
|
|
const PDFAbstractColorSpace::ColorSpace colorSpaceType = targetColorSpace->getColorSpace();
|
|
Q_ASSERT(targetColorSpace->getColorComponentCount() == targetPixelFormat.getProcessColorChannelCount());
|
|
|
|
if (sourceColorSpace->equals(targetColorSpace))
|
|
{
|
|
Q_ASSERT(sourceColorSpace->getColorComponentCount() == targetColorSpace->getColorComponentCount());
|
|
|
|
uint8_t colorCount = uint8_t(targetColorSpace->getColorComponentCount());
|
|
mapping.mapping.reserve(colorCount);
|
|
|
|
for (uint8_t i = 0; i < colorCount; ++i)
|
|
{
|
|
mapping.map(i, i);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (sourceColorSpace->getColorSpace())
|
|
{
|
|
case PDFAbstractColorSpace::ColorSpace::Separation:
|
|
{
|
|
const PDFSeparationColorSpace* separationColorSpace = dynamic_cast<const PDFSeparationColorSpace*>(sourceColorSpace);
|
|
|
|
if (separationColorSpace->isAll())
|
|
{
|
|
// Map this color to all device colors
|
|
uint32_t colorCount = static_cast<uint32_t>(targetColorSpace->getColorComponentCount());
|
|
mapping.mapping.reserve(colorCount);
|
|
|
|
for (size_t i = 0; i < colorCount; ++i)
|
|
{
|
|
mapping.map(0, uint8_t(i));
|
|
}
|
|
}
|
|
else if (!separationColorSpace->isNone() && !separationColorSpace->getColorName().isEmpty())
|
|
{
|
|
const QByteArray& colorName = separationColorSpace->getColorName();
|
|
|
|
// First try to map it as process color, if we do not succeed, then map it as spot color
|
|
const ColorInfo* processColor = getActiveProcessColor(colorName, colorSpaceType);
|
|
if (processColor)
|
|
{
|
|
if (targetPixelFormat.hasProcessColors() && processColor->spotColorIndex < targetPixelFormat.getProcessColorChannelCount())
|
|
{
|
|
mapping.map(0, uint8_t(targetPixelFormat.getProcessColorChannelIndexStart() + processColor->spotColorIndex));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const ColorInfo* spotColor = getSpotColor(colorName);
|
|
if (spotColor && spotColor->active && targetPixelFormat.hasSpotColors() && spotColor->spotColorIndex < targetPixelFormat.getSpotColorChannelCount())
|
|
{
|
|
mapping.map(0, uint8_t(targetPixelFormat.getSpotColorChannelIndexStart() + spotColor->spotColorIndex));
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case PDFAbstractColorSpace::ColorSpace::DeviceN:
|
|
{
|
|
const PDFDeviceNColorSpace* deviceNColorSpace = dynamic_cast<const PDFDeviceNColorSpace*>(sourceColorSpace);
|
|
|
|
if (!deviceNColorSpace->isNone())
|
|
{
|
|
const PDFDeviceNColorSpace::Colorants& colorants = deviceNColorSpace->getColorants();
|
|
for (size_t i = 0; i < colorants.size(); ++i)
|
|
{
|
|
const PDFDeviceNColorSpace::ColorantInfo& colorantInfo = colorants[i];
|
|
|
|
// First try to map it as process color, if we do not succeed, then map it as spot color
|
|
const ColorInfo* processColor = getActiveProcessColor(colorantInfo.name, colorSpaceType);
|
|
if (processColor)
|
|
{
|
|
if (targetPixelFormat.hasProcessColors() && processColor->spotColorIndex < targetPixelFormat.getProcessColorChannelCount())
|
|
{
|
|
mapping.map(uint8_t(i), uint8_t(targetPixelFormat.getProcessColorChannelIndexStart() + processColor->spotColorIndex));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const ColorInfo* info = getSpotColor(colorantInfo.name);
|
|
|
|
if (info && info->active && targetPixelFormat.hasSpotColors() && info->spotColorIndex < targetPixelFormat.getSpotColorChannelCount())
|
|
{
|
|
mapping.map(uint8_t(i), uint8_t(targetColorSpace->getColorComponentCount() + info->spotColorIndex));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return mapping;
|
|
}
|
|
|
|
PDFPainterPathSampler::PDFPainterPathSampler(QPainterPath path, int samplesCount, PDFColorComponent defaultShape, QRect fillRect, bool precise) :
|
|
m_defaultShape(defaultShape),
|
|
m_samplesCount(qMax(samplesCount, 1)),
|
|
m_path(qMove(path)),
|
|
m_fillRect(fillRect),
|
|
m_precise(precise)
|
|
{
|
|
if (!precise)
|
|
{
|
|
m_fillPolygon = m_path.toFillPolygon();
|
|
prepareScanLines();
|
|
}
|
|
}
|
|
|
|
PDFColorComponent PDFPainterPathSampler::sample(QPoint point) const
|
|
{
|
|
if (m_path.isEmpty() || !m_fillRect.contains(point))
|
|
{
|
|
return m_defaultShape;
|
|
}
|
|
|
|
if (!m_scanLineInfo.empty())
|
|
{
|
|
return sampleByScanLine(point);
|
|
}
|
|
|
|
const qreal coordX1 = point.x();
|
|
const qreal coordX2 = coordX1 + 1.0;
|
|
const qreal coordY1 = point.y();
|
|
const qreal coordY2 = coordY1 + 1.0;
|
|
|
|
const qreal centerX = (coordX1 + coordX2) * 0.5;
|
|
const qreal centerY = (coordY1 + coordY2) * 0.5;
|
|
|
|
const QPointF topLeft(coordX1, coordY1);
|
|
const QPointF topRight(coordX2, coordY1);
|
|
const QPointF bottomLeft(coordX1, coordY2);
|
|
const QPointF bottomRight(coordX2, coordY2);
|
|
|
|
if (m_samplesCount <= 1)
|
|
{
|
|
// Jakub Melka: Just one sample
|
|
if (m_precise)
|
|
{
|
|
return m_path.contains(QPointF(centerX, centerY)) ? 1.0f : 0.0f;
|
|
}
|
|
else
|
|
{
|
|
return m_fillPolygon.contains(QPointF(centerX, centerY)) ? 1.0f : 0.0f;
|
|
}
|
|
}
|
|
|
|
int cornerHits = 0;
|
|
Qt::FillRule fillRule = m_path.fillRule();
|
|
|
|
if (m_precise)
|
|
{
|
|
cornerHits += m_path.contains(topLeft) ? 1 : 0;
|
|
cornerHits += m_path.contains(topRight) ? 1 : 0;
|
|
cornerHits += m_path.contains(bottomLeft) ? 1 : 0;
|
|
cornerHits += m_path.contains(bottomRight) ? 1 : 0;
|
|
}
|
|
else
|
|
{
|
|
cornerHits += m_fillPolygon.containsPoint(topLeft, fillRule) ? 1 : 0;
|
|
cornerHits += m_fillPolygon.containsPoint(topRight, fillRule) ? 1 : 0;
|
|
cornerHits += m_fillPolygon.containsPoint(bottomLeft, fillRule) ? 1 : 0;
|
|
cornerHits += m_fillPolygon.containsPoint(bottomRight, fillRule) ? 1 : 0;
|
|
}
|
|
|
|
if (cornerHits == 4)
|
|
{
|
|
// Completely inside
|
|
return 1.0;
|
|
}
|
|
|
|
if (cornerHits == 0)
|
|
{
|
|
// Completely outside
|
|
return 0.0;
|
|
}
|
|
|
|
// Otherwise we must use regular sample grid
|
|
const qreal offset = 1.0f / PDFColorComponent(m_samplesCount + 1);
|
|
PDFColorComponent sampleValue = 0.0f;
|
|
const PDFColorComponent sampleGain = 1.0f / PDFColorComponent(m_samplesCount * m_samplesCount);
|
|
for (int ix = 0; ix < m_samplesCount; ++ix)
|
|
{
|
|
const qreal x = offset * (ix + 1) + coordX1;
|
|
|
|
for (int iy = 0; iy < m_samplesCount; ++iy)
|
|
{
|
|
const qreal y = offset * (iy + 1) + coordY1;
|
|
|
|
if (m_precise)
|
|
{
|
|
if (m_path.contains(QPointF(x, y)))
|
|
{
|
|
sampleValue += sampleGain;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_fillPolygon.containsPoint(QPointF(x, y), fillRule))
|
|
{
|
|
sampleValue += sampleGain;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return sampleValue;
|
|
}
|
|
|
|
PDFColorComponent PDFPainterPathSampler::sampleByScanLine(QPoint point) const
|
|
{
|
|
int scanLinePosition = point.y() - m_fillRect.y();
|
|
|
|
size_t scanLineCountPerPixel = getScanLineCountPerPixel();
|
|
size_t scanLineTopRow = scanLinePosition * scanLineCountPerPixel;
|
|
size_t scanLineBottomRow = scanLineTopRow + scanLineCountPerPixel - 1;
|
|
size_t scanLineGridRowTop = scanLineTopRow + 1;
|
|
|
|
Qt::FillRule fillRule = m_path.fillRule();
|
|
|
|
auto performSampling = [&](size_t scanLineIndex, PDFReal firstOrdinate, int sampleCount, PDFReal step, PDFReal gain)
|
|
{
|
|
ScanLineInfo info = m_scanLineInfo[scanLineIndex];
|
|
auto it = std::next(m_scanLineSamples.cbegin(), info.indexStart);
|
|
|
|
PDFReal ordinate = firstOrdinate;
|
|
PDFColorComponent value = 0.0;
|
|
auto ordinateIt = it;
|
|
for (int i = 0; i < sampleCount; ++i)
|
|
{
|
|
while (std::next(ordinateIt)->x < ordinate)
|
|
{
|
|
++ordinateIt;
|
|
}
|
|
|
|
int windingNumber = ordinateIt->windingNumber;
|
|
|
|
const bool inside = (fillRule == Qt::WindingFill) ? windingNumber != 0 : windingNumber % 2 != 0;
|
|
if (inside)
|
|
{
|
|
value += gain;
|
|
}
|
|
|
|
ordinate += step;
|
|
}
|
|
|
|
return value;
|
|
};
|
|
|
|
const qreal coordX1 = point.x();
|
|
const PDFReal cornerValue = performSampling(scanLineTopRow, coordX1, 2, 1.0, 1.0) + performSampling(scanLineBottomRow, coordX1, 2, 1.0, 1.0);
|
|
|
|
if (qFuzzyIsNull(4.0 - cornerValue))
|
|
{
|
|
// Whole inside
|
|
return 1.0;
|
|
}
|
|
|
|
if (qFuzzyIsNull(cornerValue))
|
|
{
|
|
// Whole outside
|
|
return 0.0;
|
|
}
|
|
|
|
const qreal offset = 1.0f / PDFColorComponent(m_samplesCount + 1);
|
|
PDFColorComponent sampleValue = 0.0f;
|
|
const PDFColorComponent sampleGain = 1.0f / PDFColorComponent(m_samplesCount * m_samplesCount);
|
|
|
|
for (size_t i = 0; i < m_samplesCount; ++i)
|
|
{
|
|
sampleValue += performSampling(scanLineGridRowTop++, coordX1 + offset, m_samplesCount, offset, sampleGain);
|
|
}
|
|
|
|
return sampleValue;
|
|
}
|
|
|
|
size_t PDFPainterPathSampler::getScanLineCountPerPixel() const
|
|
{
|
|
return m_samplesCount + 2;
|
|
}
|
|
|
|
void PDFPainterPathSampler::prepareScanLines()
|
|
{
|
|
if (m_fillPolygon.isEmpty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int yOffset = m_fillRect.top(); yOffset <= m_fillRect.bottom(); ++yOffset)
|
|
{
|
|
const qreal coordY1 = yOffset;
|
|
const qreal coordY2 = coordY1 + 1.0;
|
|
|
|
// Top pixel line
|
|
if (m_scanLineInfo.empty())
|
|
{
|
|
m_scanLineInfo.emplace_back(createScanLine(coordY1));
|
|
}
|
|
else
|
|
{
|
|
m_scanLineInfo.emplace_back(m_scanLineInfo.back());
|
|
}
|
|
|
|
// Sample grid
|
|
const qreal offset = 1.0f / PDFColorComponent(m_samplesCount + 1);
|
|
for (int iy = 0; iy < m_samplesCount; ++iy)
|
|
{
|
|
const qreal y = offset * (iy + 1) + coordY1;
|
|
m_scanLineInfo.emplace_back(createScanLine(y));
|
|
}
|
|
|
|
// Bottom pixel line
|
|
m_scanLineInfo.emplace_back(createScanLine(coordY2));
|
|
}
|
|
}
|
|
|
|
PDFPainterPathSampler::ScanLineInfo PDFPainterPathSampler::createScanLine(qreal y)
|
|
{
|
|
ScanLineInfo result;
|
|
result.indexStart = m_scanLineSamples.size();
|
|
|
|
// Add start item
|
|
m_scanLineSamples.emplace_back(-std::numeric_limits<PDFReal>::infinity(), 0);
|
|
|
|
// Traverse polygon, add sample for each polygon line, we must
|
|
// also implicitly close last edge (if polygon is not closed)
|
|
for (int i = 1; i < m_fillPolygon.size(); ++i)
|
|
{
|
|
createScanLineSample(m_fillPolygon[i - 1], m_fillPolygon[i], y);
|
|
}
|
|
|
|
if (m_fillPolygon.front() != m_fillPolygon.back())
|
|
{
|
|
createScanLineSample(m_fillPolygon.back(), m_fillPolygon.front(), y);
|
|
}
|
|
|
|
// Add end item
|
|
m_scanLineSamples.emplace_back(+std::numeric_limits<PDFReal>::infinity(), 0);
|
|
|
|
result.indexEnd = m_scanLineSamples.size();
|
|
|
|
auto it = std::next(m_scanLineSamples.begin(), result.indexStart);
|
|
auto itEnd = std::next(m_scanLineSamples.begin(), result.indexEnd);
|
|
|
|
// Jakub Melka: now, sort the line samples and compute properly the winding number
|
|
std::sort(it, itEnd);
|
|
|
|
int currentWindingNumber = 0;
|
|
for (; it != itEnd; ++it)
|
|
{
|
|
currentWindingNumber += it->windingNumber;
|
|
it->windingNumber = currentWindingNumber;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void PDFPainterPathSampler::createScanLineSample(const QPointF& p1, const QPointF& p2, qreal y)
|
|
{
|
|
PDFReal y1 = p1.y();
|
|
PDFReal y2 = p2.y();
|
|
|
|
if (qFuzzyIsNull(y2 - y1))
|
|
{
|
|
// Ignore horizontal lines
|
|
return;
|
|
}
|
|
|
|
PDFReal x1 = p1.x();
|
|
PDFReal x2 = p2.x();
|
|
|
|
int windingNumber = 1;
|
|
if (y2 < y1)
|
|
{
|
|
std::swap(y1, y2);
|
|
std::swap(x1, x2);
|
|
windingNumber = -1;
|
|
}
|
|
|
|
// Do we have intercept?
|
|
if (y1 <= y && y < y2)
|
|
{
|
|
const PDFReal x = interpolate(y, y1, y2, x1, x2);
|
|
m_scanLineSamples.emplace_back(x, windingNumber);
|
|
}
|
|
}
|
|
|
|
void PDFDrawBuffer::clear()
|
|
{
|
|
if (!m_modifiedRect.isValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int x = m_modifiedRect.left(); x <= m_modifiedRect.right(); ++x)
|
|
{
|
|
for (int y = m_modifiedRect.top(); y <= m_modifiedRect.bottom(); ++y)
|
|
{
|
|
PDFColorBuffer buffer = getPixel(x, y);
|
|
std::fill(buffer.begin(), buffer.end(), 0.0f);
|
|
setPixelActiveColorMask(x, y, 0);
|
|
}
|
|
}
|
|
|
|
m_containsFilling = false;
|
|
m_containsStroking = false;
|
|
m_modifiedRect = QRect();
|
|
}
|
|
|
|
void PDFDrawBuffer::modify(QRect rect, bool containsFilling, bool containsStroking)
|
|
{
|
|
m_modifiedRect = m_modifiedRect.united(rect);
|
|
m_containsFilling |= containsFilling;
|
|
m_containsStroking |= containsStroking;
|
|
}
|
|
|
|
void PDFTransparencyRenderer::PDFTransparencyGroupPainterData::makeInitialBackdropTransparent()
|
|
{
|
|
initialBackdrop.makeTransparent();
|
|
}
|
|
|
|
void PDFTransparencyRenderer::PDFTransparencyGroupPainterData::makeImmediateBackdropTransparent()
|
|
{
|
|
immediateBackdrop.makeTransparent();
|
|
immediateBackdrop.setAllColorInactive();
|
|
}
|
|
|
|
void PDFTransparencyRenderer::PDFTransparencySoftMask::makeOpaque()
|
|
{
|
|
if (!isOpaque())
|
|
{
|
|
m_data->isOpaque = true;
|
|
m_data->softMask.makeOpaque();
|
|
}
|
|
}
|
|
|
|
PDFInkCoverageCalculator::PDFInkCoverageCalculator(const PDFDocument* document,
|
|
const PDFFontCache* fontCache,
|
|
const PDFCMSManager* cmsManager,
|
|
const PDFOptionalContentActivity* optionalContentActivity,
|
|
const PDFInkMapper* inkMapper,
|
|
PDFProgress* progress,
|
|
PDFTransparencyRendererSettings settings) :
|
|
m_document(document),
|
|
m_fontCache(fontCache),
|
|
m_cmsManager(cmsManager),
|
|
m_optionalContentActivity(optionalContentActivity),
|
|
m_inkMapper(inkMapper),
|
|
m_progress(progress),
|
|
m_settings(settings)
|
|
{
|
|
Q_ASSERT(m_document);
|
|
Q_ASSERT(m_fontCache);
|
|
Q_ASSERT(m_cmsManager);
|
|
Q_ASSERT(m_optionalContentActivity);
|
|
Q_ASSERT(m_inkMapper);
|
|
}
|
|
|
|
void PDFInkCoverageCalculator::perform(QSize size, const std::vector<PDFInteger>& pages)
|
|
{
|
|
if (pages.empty())
|
|
{
|
|
// Nothing to do
|
|
return;
|
|
}
|
|
|
|
if (m_progress)
|
|
{
|
|
m_progress->start(pages.size(), ProgressStartupInfo());
|
|
}
|
|
|
|
auto calculatePageCoverage = [this, size](PDFInteger pageIndex)
|
|
{
|
|
if (pageIndex >= PDFInteger(m_document->getCatalog()->getPageCount()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
const PDFPage* page = m_document->getCatalog()->getPage(pageIndex);
|
|
if (!page)
|
|
{
|
|
return;
|
|
}
|
|
|
|
QRectF pageRect = page->getRotatedMediaBox();
|
|
QSizeF pageSize = pageRect.size();
|
|
pageSize.scale(size.width(), size.height(), Qt::KeepAspectRatio);
|
|
QSize imageSize = pageSize.toSize();
|
|
|
|
if (!imageSize.isValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
pdf::PDFTransparencyRendererSettings settings;
|
|
settings.flags.setFlag(PDFTransparencyRendererSettings::SaveOriginalProcessImage, true);
|
|
|
|
// Jakub Melka: debug is very slow, use multithreading
|
|
#ifdef QT_DEBUG
|
|
settings.flags.setFlag(PDFTransparencyRendererSettings::MultithreadedPathSampler, true);
|
|
#endif
|
|
|
|
settings.flags.setFlag(PDFTransparencyRendererSettings::ActiveColorMask, false);
|
|
settings.flags.setFlag(PDFTransparencyRendererSettings::SeparationSimulation, true);
|
|
settings.activeColorMask = PDFPixelFormat::getAllColorsMask();
|
|
|
|
QTransform pagePointToDevicePoint = pdf::PDFRenderer::createPagePointToDevicePointMatrix(page, QRect(QPoint(0, 0), imageSize));
|
|
pdf::PDFCMSPointer cms = m_cmsManager->getCurrentCMS();
|
|
pdf::PDFTransparencyRenderer renderer(page, m_document, m_fontCache, cms.data(), m_optionalContentActivity,
|
|
m_inkMapper, settings, pagePointToDevicePoint);
|
|
|
|
renderer.beginPaint(imageSize);
|
|
renderer.processContents();
|
|
renderer.endPaint();
|
|
|
|
PDFFloatBitmapWithColorSpace originalProcessImage = renderer.getOriginalProcessBitmap();
|
|
QSizeF pageSizeMM = page->getRotatedMediaBoxMM().size();
|
|
|
|
pdf::PDFPixelFormat pixelFormat = originalProcessImage.getPixelFormat();
|
|
pdf::PDFColorComponent totalArea = pageSizeMM.width() * pageSizeMM.height();
|
|
pdf::PDFColorComponent pixelArea = totalArea / pdf::PDFColorComponent(originalProcessImage.getWidth() * originalProcessImage.getHeight());
|
|
|
|
std::vector<PDFColorComponent> pageCoverage;
|
|
const uint8_t colorChannelCount = pixelFormat.getColorChannelCount();
|
|
pageCoverage.resize(colorChannelCount, 0.0f);
|
|
|
|
for (size_t y = 0; y < originalProcessImage.getHeight(); ++y)
|
|
{
|
|
for (size_t x = 0; x < originalProcessImage.getWidth(); ++x)
|
|
{
|
|
const pdf::PDFColorBuffer buffer = originalProcessImage.getPixel(x, y);
|
|
const pdf::PDFColorComponent alpha = pixelFormat.hasOpacityChannel() ? buffer[pixelFormat.getOpacityChannelIndex()] : 1.0f;
|
|
|
|
for (uint8_t i = 0; i < colorChannelCount; ++i)
|
|
{
|
|
pageCoverage[i] += buffer[i] * alpha;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::vector<PDFColorComponent> pageRatioCoverage = pageCoverage;
|
|
for (uint8_t i = 0; i < colorChannelCount; ++i)
|
|
{
|
|
pageCoverage[i] *= pixelArea;
|
|
pageRatioCoverage[i] *= pixelArea / totalArea;
|
|
}
|
|
|
|
std::vector<PDFInkMapper::ColorInfo> separations = m_inkMapper->getSeparations(pixelFormat.getProcessColorChannelCount());
|
|
Q_ASSERT(pixelFormat.getColorChannelCount() == separations.size());
|
|
|
|
std::vector<InkCoverageChannelInfo> results;
|
|
results.reserve(separations.size());
|
|
|
|
for (size_t i = 0; i < separations.size(); ++i)
|
|
{
|
|
const PDFInkMapper::ColorInfo& colorInfo = separations[i];
|
|
|
|
InkCoverageChannelInfo info;
|
|
info.color = colorInfo.color;
|
|
info.name = colorInfo.name;
|
|
info.textName = colorInfo.textName;
|
|
info.isSpot = colorInfo.isSpot;
|
|
info.coveredArea = pageCoverage[i];
|
|
info.ratio = pageRatioCoverage[i];
|
|
results.emplace_back(qMove(info));
|
|
}
|
|
|
|
if (m_progress)
|
|
{
|
|
m_progress->step();
|
|
}
|
|
|
|
QMutexLocker lock(&m_mutex);
|
|
m_inkCoverageResults[pageIndex] = qMove(results);
|
|
};
|
|
|
|
PDFExecutionPolicy::execute(PDFExecutionPolicy::Scope::Page, pages.begin(), pages.end(), calculatePageCoverage);
|
|
|
|
if (m_progress)
|
|
{
|
|
m_progress->finish();
|
|
}
|
|
}
|
|
|
|
void PDFInkCoverageCalculator::clear()
|
|
{
|
|
QMutexLocker lock(&m_mutex);
|
|
m_inkCoverageResults.clear();
|
|
}
|
|
|
|
const std::vector<PDFInkCoverageCalculator::InkCoverageChannelInfo>* PDFInkCoverageCalculator::getInkCoverage(PDFInteger pageIndex) const
|
|
{
|
|
auto it = m_inkCoverageResults.find(pageIndex);
|
|
if (it != m_inkCoverageResults.end())
|
|
{
|
|
return &it->second;
|
|
}
|
|
|
|
static const std::vector<PDFInkCoverageCalculator::InkCoverageChannelInfo> dummy;
|
|
return &dummy;
|
|
}
|
|
|
|
const PDFInkCoverageCalculator::InkCoverageChannelInfo* PDFInkCoverageCalculator::findCoverageInfoByName(const std::vector<PDFInkCoverageCalculator::InkCoverageChannelInfo>& infos,
|
|
const QByteArray& name)
|
|
{
|
|
auto it = std::find_if(infos.cbegin(), infos.cend(), [&name](const auto& info) { return info.name == name; });
|
|
if (it != infos.cend())
|
|
{
|
|
return &*it;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
PDFInkCoverageCalculator::InkCoverageChannelInfo* PDFInkCoverageCalculator::findCoverageInfoByName(std::vector<PDFInkCoverageCalculator::InkCoverageChannelInfo>& infos, const QByteArray& name)
|
|
{
|
|
auto it = std::find_if(infos.begin(), infos.end(), [&name](const auto& info) { return info.name == name; });
|
|
if (it != infos.cend())
|
|
{
|
|
return &*it;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
} // namespace pdf
|