fenix
/
PDF4QT
mirror of https://github.com/JakubMelka/PDF4QT.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
PDF4QT/Pdf4QtLib/sources/pdfcolorspaces.h

744 lines
34 KiB
C++
Raw Blame History

// Copyright (C) 2019-2020 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
// (at your option) 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/>.
#ifndef PDFCOLORSPACES_H
#define PDFCOLORSPACES_H
#include "pdfflatarray.h"
#include "pdffunction.h"
#include <QColor>
#include <QImage>
#include <QSharedPointer>
#include <set>
namespace pdf
{
class PDFCMS;
class PDFArray;
class PDFObject;
class PDFStream;
class PDFPattern;
class PDFDocument;
class PDFDictionary;
class PDFAbstractColorSpace;
class PDFPatternColorSpace;
class PDFRenderErrorReporter;
using PDFColorComponent = float;
using PDFColor = PDFFlatArray<PDFColorComponent, 4>;
using PDFColorSpacePointer = QSharedPointer<PDFAbstractColorSpace>;
static constexpr const int COLOR_SPACE_MAX_LEVEL_OF_RECURSION = 12;
static constexpr const char* COLOR_SPACE_DICTIONARY = "ColorSpace";
static constexpr const char* COLOR_SPACE_NAME_DEVICE_GRAY = "DeviceGray";
static constexpr const char* COLOR_SPACE_NAME_DEVICE_RGB = "DeviceRGB";
static constexpr const char* COLOR_SPACE_NAME_DEVICE_CMYK = "DeviceCMYK";
static constexpr const char* COLOR_SPACE_NAME_ABBREVIATION_DEVICE_GRAY = "G";
static constexpr const char* COLOR_SPACE_NAME_ABBREVIATION_DEVICE_RGB = "RGB";
static constexpr const char* COLOR_SPACE_NAME_ABBREVIATION_DEVICE_CMYK = "CMYK";
static constexpr const char* COLOR_SPACE_NAME_ABBREVIATION_CAL_CMYK = "CalCMYK";
static constexpr const char* COLOR_SPACE_NAME_DEFAULT_GRAY = "DefaultGray";
static constexpr const char* COLOR_SPACE_NAME_DEFAULT_RGB = "DefaultRGB";
static constexpr const char* COLOR_SPACE_NAME_DEFAULT_CMYK = "DefaultCMYK";
static constexpr const char* COLOR_SPACE_NAME_CAL_GRAY = "CalGray";
static constexpr const char* COLOR_SPACE_NAME_CAL_RGB = "CalRGB";
static constexpr const char* COLOR_SPACE_NAME_LAB = "Lab";
static constexpr const char* COLOR_SPACE_NAME_ICCBASED = "ICCBased";
static constexpr const char* COLOR_SPACE_NAME_INDEXED = "Indexed";
static constexpr const char* COLOR_SPACE_NAME_SEPARATION = "Separation";
static constexpr const char* COLOR_SPACE_NAME_DEVICE_N = "DeviceN";
static constexpr const char* COLOR_SPACE_NAME_PATTERN = "Pattern";
static constexpr const char* CAL_WHITE_POINT = "WhitePoint";
static constexpr const char* CAL_BLACK_POINT = "BlackPoint";
static constexpr const char* CAL_GAMMA = "Gamma";
static constexpr const char* CAL_MATRIX = "Matrix";
static constexpr const char* CAL_RANGE = "Range";
static constexpr const char* ICCBASED_ALTERNATE = "Alternate";
static constexpr const char* ICCBASED_N = "N";
static constexpr const char* ICCBASED_RANGE = "Range";
enum class BlackPointCompensationMode
{
Default,
ON,
OFF
};
/// Image raw data - containing data for image. Image data are row-ordered, and by components.
/// So the row can be for 3-components RGB like 'RGBRGBRGB...RGB', where size of row in bytes is 3 * width of image.
class PDFImageData
{
public:
enum class MaskingType
{
None,
ColorKeyMasking, ///< Masking by color key
ImageMask, ///< Masking by 1-bit image (see "ImageMask" entry in image's dictionary), current color from the graphic state is used to paint an image
SoftMask, ///< Image is masked by soft mask
};
explicit PDFImageData() :
m_components(0),
m_bitsPerComponent(0),
m_width(0),
m_height(0),
m_stride(0),
m_maskingType(MaskingType::None)
{
}
explicit inline PDFImageData(unsigned int components,
unsigned int bitsPerComponent,
unsigned int width,
unsigned int height,
unsigned int stride,
MaskingType maskingType,
QByteArray data,
std::vector<PDFInteger>&& colorKeyMask,
std::vector<PDFReal>&& decode,
std::vector<PDFReal>&& matte) :
m_components(components),
m_bitsPerComponent(bitsPerComponent),
m_width(width),
m_height(height),
m_stride(stride),
m_maskingType(maskingType),
m_data(qMove(data)),
m_colorKeyMask(qMove(colorKeyMask)),
m_decode(qMove(decode)),
m_matte(qMove(matte))
{
}
unsigned int getComponents() const { return m_components; }
unsigned int getBitsPerComponent() const { return m_bitsPerComponent; }
unsigned int getWidth() const { return m_width; }
unsigned int getHeight() const { return m_height; }
unsigned int getStride() const { return m_stride; }
MaskingType getMaskingType() const { return m_maskingType; }
const QByteArray& getData() const { return m_data; }
const std::vector<PDFInteger>& getColorKeyMask() const { return m_colorKeyMask; }
const std::vector<PDFReal>& getDecode() const { return m_decode; }
const std::vector<PDFReal>& getMatte() const { return m_matte; }
void setMaskingType(MaskingType maskingType) { m_maskingType = maskingType; }
void setDecode(std::vector<PDFReal> decode) { m_decode = qMove(decode); }
/// Returns number of color channels
unsigned int getColorChannels() const { return m_components; }
bool isValid() const { return m_width && m_height && m_components && m_bitsPerComponent; }
const unsigned char* getRow(unsigned int rowIndex) const;
private:
unsigned int m_components;
unsigned int m_bitsPerComponent;
unsigned int m_width;
unsigned int m_height;
unsigned int m_stride;
MaskingType m_maskingType;
QByteArray m_data;
/// Mask entry of the image. If it is empty, no color key masking is induced.
/// If it is not empty, then it should contain 2 x number of color components,
/// consisting of [ min_0, max_0, min_1, max_1, ... , min_n, max_n ].
std::vector<PDFInteger> m_colorKeyMask;
/// Decode array. If it is empty, then no decoding is performed. If it is nonempty,
/// then contains n pairs of numbers, where n is number of color components. If ImageMask
/// in the image dictionary is true, then decode array should be [0 1] or [1 0].
std::vector<PDFReal> m_decode;
/// Matte color (color, agains which is image preblended, when using soft masking
/// image (defined for soft masks).
std::vector<PDFReal> m_matte;
};
using PDFColor3 = std::array<PDFColorComponent, 3>;
/// Matrix for color component multiplication (for example, conversion between some color spaces)
template<size_t Rows, size_t Cols>
class PDFColorComponentMatrix
{
public:
explicit constexpr inline PDFColorComponentMatrix() : m_values() { }
template<typename... Components>
explicit constexpr inline PDFColorComponentMatrix(Components... components) : m_values({ static_cast<PDFColorComponent>(components)... }) { }
std::array<PDFColorComponent, Rows> operator*(const std::array<PDFColorComponent, Cols>& color) const
{
std::array<PDFColorComponent, Rows> result = { };
for (size_t row = 0; row < Rows; ++row)
{
for (size_t column = 0; column < Cols; ++column)
{
result[row] += m_values[row * Cols + column] * color[column];
}
}
return result;
}
inline typename std::array<PDFColorComponent, Rows * Cols>::iterator begin() { return m_values.begin(); }
inline typename std::array<PDFColorComponent, Rows * Cols>::iterator end() { return m_values.end(); }
private:
std::array<PDFColorComponent, Rows * Cols> m_values;
};
using PDFColorComponentMatrix_3x3 = PDFColorComponentMatrix<3, 3>;
/// Represents PDF's color space (abstract class). Contains functions for parsing
/// color spaces.
class PDFAbstractColorSpace
{
public:
explicit PDFAbstractColorSpace() = default;
virtual ~PDFAbstractColorSpace() = default;
/// Returns default color for the color space
virtual QColor getDefaultColor(const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter) const = 0;
/// Returns transformed color for given input color. Color is transformed using color
/// management system (cms), if color management system fails, and returns invalid color,
/// then generic solution for color transformation is used (which is often not valid).
/// Caller can also specify rendering intent and error reporter, where color management
/// system can write errors during color transformation.
/// \param color Input color
/// \param cms Color management system
/// \param intent Rendering intent
/// \param reporter Error reporter
/// \param isRange01 Is range [0, 1], or native color component range (for Lab spaces)?
virtual QColor getColor(const PDFColor& color, const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter, bool isRange01) const = 0;
/// Returns color component count
virtual size_t getColorComponentCount() const = 0;
/// Transforms image data to result image.
/// \param imageData Image data
/// \param softMask Soft mask (for alpha channel)
/// \param cms Color management system
/// \param intent Rendering intent
/// \param reporter Error reporter
virtual QImage getImage(const PDFImageData& imageData,
const PDFImageData& softMask,
const PDFCMS* cms,
RenderingIntent intent,
PDFRenderErrorReporter* reporter) const;
/// Fills RGB buffer using colors from \p colors. Colors are transformed
/// by this color space (or color management system is used). Buffer
/// must be big enough to contain all 8-bit RGB data.
/// \param Colors Input color buffer
/// \param intent Rendering intent
/// \param outputBuffer 8-bit RGB output buffer
/// \param cms Color management system
/// \param reporter Render error reporter
virtual void fillRGBBuffer(const std::vector<float>& colors,
unsigned char* outputBuffer,
RenderingIntent intent,
const PDFCMS* cms,
PDFRenderErrorReporter* reporter) const;
/// If this class is pattern space, returns this, otherwise returns nullptr.
virtual const PDFPatternColorSpace* asPatternColorSpace() const { return nullptr; }
/// Checks, if number of color components is OK, and if yes, converts them to the QColor value.
/// If they are not OK, exception is thrown. \sa getColor
/// \param color Input color
/// \param cms Color management system
/// \param intent Rendering intent
/// \param reporter Error reporter
QColor getCheckedColor(const PDFColor& color, const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter) const;
/// Creates alpha mask from soft image data. Exception is thrown, if something fails.
/// \param softMask Soft mask
static QImage createAlphaMask(const PDFImageData& softMask);
/// Parses the desired color space. If desired color space is not found, then exception is thrown.
/// If everything is OK, then shared pointer to the new color space is returned.
/// \param colorSpaceDictionary Dictionary containing color spaces of the page
/// \param document Document (for loading objects)
/// \param colorSpace Identification of color space (either name or array), must be a direct object
static PDFColorSpacePointer createColorSpace(const PDFDictionary* colorSpaceDictionary,
const PDFDocument* document,
const PDFObject& colorSpace);
/// Creates device color space by name. Color space can be created by this function only, if
/// it is simple - one of the basic device color spaces (gray, RGB or CMYK).
/// \param colorSpaceDictionary Dictionary containing color spaces of the page
/// \param document Document (for loading objects)
/// \param name Name of the color space
static PDFColorSpacePointer createDeviceColorSpaceByName(const PDFDictionary* colorSpaceDictionary,
const PDFDocument* document,
const QByteArray& name);
/// Converts a vector of real numbers to the PDFColor
static PDFColor convertToColor(const std::vector<PDFReal>& components);
/// Returns true, if two colors are equal (considering the tolerance). So, if one
/// of the color components differs more than \p tolerance from the another, then
/// false is returned. If colors have different number of components, false is returned.
/// \param color1 First color
/// \param color2 Second color
/// \param tolerance Color tolerance
static bool isColorEqual(const PDFColor& color1, const PDFColor& color2, PDFReal tolerance);
/// Mix colors according the given ratio.
/// \param color1 First color
/// \param color2 Second color
/// \param ratio Mixing ratio
static PDFColor mixColors(const PDFColor& color1, const PDFColor& color2, PDFReal ratio);
protected:
/// Clips the color component to range [0, 1]
static constexpr PDFColorComponent clip01(PDFColorComponent component) { return qBound<PDFColorComponent>(0.0, component, 1.0); }
/// Clips the color to range [0 1] in all components
static constexpr PDFColor3 clip01(const PDFColor3& color)
{
PDFColor3 result = color;
for (PDFColorComponent& component : result)
{
component = clip01(component);
}
return result;
}
/// Parses the desired color space. If desired color space is not found, then exception is thrown.
/// If everything is OK, then shared pointer to the new color space is returned.
/// \param colorSpaceDictionary Dictionary containing color spaces of the page
/// \param document Document (for loading objects)
/// \param colorSpace Identification of color space (either name or array), must be a direct object
/// \param recursion Recursion guard
/// \param usedNames Names, which were already parsed
static PDFColorSpacePointer createColorSpaceImpl(const PDFDictionary* colorSpaceDictionary,
const PDFDocument* document,
const PDFObject& colorSpace,
int recursion,
std::set<QByteArray>& usedNames);
/// Creates device color space by name. Color space can be created by this function only, if
/// it is simple - one of the basic device color spaces (gray, RGB or CMYK).
/// \param colorSpaceDictionary Dictionary containing color spaces of the page
/// \param document Document (for loading objects)
/// \param name Name of the color space
/// \param usedNames Names, which were already parsed
static PDFColorSpacePointer createDeviceColorSpaceByNameImpl(const PDFDictionary* colorSpaceDictionary,
const PDFDocument* document,
const QByteArray& name,
int recursion,
std::set<QByteArray>& usedNames);
/// Converts XYZ value to the standard RGB value (linear). No gamma correction is applied.
/// Default transformation matrix is applied.
/// \param xyzColor Color in XYZ space
static PDFColor3 convertXYZtoRGB(const PDFColor3& xyzColor);
/// Multiplies color by factor
/// \param color Color to be multiplied
/// \param factor Multiplication factor
static constexpr PDFColor3 colorMultiplyByFactor(const PDFColor3& color, PDFColorComponent factor)
{
PDFColor3 result = color;
for (PDFColorComponent& component : result)
{
component *= factor;
}
return result;
}
/// Multiplies color by factors (stored in components of the color)
/// \param color Color to be multiplied
/// \param factor Multiplication factors
static constexpr PDFColor3 colorMultiplyByFactors(const PDFColor3& color, const PDFColor3& factors)
{
PDFColor3 result = { };
for (size_t i = 0; i < color.size(); ++i)
{
result[i] = color[i] * factors[i];
}
return result;
}
/// Powers color by factors (stored in components of the color)
/// \param color Color to be multiplied
/// \param factor Power factors
static constexpr PDFColor3 colorPowerByFactors(const PDFColor3& color, const PDFColor3& factors)
{
PDFColor3 result = { };
for (size_t i = 0; i < color.size(); ++i)
{
result[i] = std::powf(color[i], factors[i]);
}
return result;
}
/// Converts RGB values of range [0.0, 1.0] to standard QColor
/// \param color Color to be converted
static inline QColor fromRGB01(const PDFColor3& color)
{
PDFColorComponent r = clip01(color[0]);
PDFColorComponent g = clip01(color[1]);
PDFColorComponent b = clip01(color[2]);
QColor result(QColor::Rgb);
result.setRgbF(r, g, b, 1.0);
return result;
}
};
class PDFDeviceGrayColorSpace : public PDFAbstractColorSpace
{
public:
explicit PDFDeviceGrayColorSpace() = default;
virtual ~PDFDeviceGrayColorSpace() = default;
virtual QColor getDefaultColor(const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter) const override;
virtual QColor getColor(const PDFColor& color, const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter, bool isRange01) const override;
virtual size_t getColorComponentCount() const override;
virtual void fillRGBBuffer(const std::vector<float>& colors,unsigned char* outputBuffer, RenderingIntent intent, const PDFCMS* cms, PDFRenderErrorReporter* reporter) const override;
};
class PDFDeviceRGBColorSpace : public PDFAbstractColorSpace
{
public:
explicit PDFDeviceRGBColorSpace() = default;
virtual ~PDFDeviceRGBColorSpace() = default;
virtual QColor getDefaultColor(const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter) const override;
virtual QColor getColor(const PDFColor& color, const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter, bool isRange01) const override;
virtual size_t getColorComponentCount() const override;
virtual void fillRGBBuffer(const std::vector<float>& colors,unsigned char* outputBuffer, RenderingIntent intent, const PDFCMS* cms, PDFRenderErrorReporter* reporter) const override;
};
class PDFDeviceCMYKColorSpace : public PDFAbstractColorSpace
{
public:
explicit PDFDeviceCMYKColorSpace() = default;
virtual ~PDFDeviceCMYKColorSpace() = default;
virtual QColor getDefaultColor(const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter) const override;
virtual QColor getColor(const PDFColor& color, const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter, bool isRange01) const override;
virtual size_t getColorComponentCount() const override;
virtual void fillRGBBuffer(const std::vector<float>& colors,unsigned char* outputBuffer, RenderingIntent intent, const PDFCMS* cms, PDFRenderErrorReporter* reporter) const override;
};
class PDFXYZColorSpace : public PDFAbstractColorSpace
{
public:
virtual QColor getDefaultColor(const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter) const override;
protected:
explicit PDFXYZColorSpace(PDFColor3 whitePoint);
virtual ~PDFXYZColorSpace() = default;
PDFColor3 m_whitePoint;
/// What are these coefficients? We want to map white point from XYZ space to white point
/// of RGB space. These coefficients are reciprocal values to the point converted from XYZ white
/// point. So, if we call getColor(m_whitePoint), then we should get vector (1.0, 1.0, 1.0)
/// after multiplication by these coefficients.
PDFColor3 m_correctionCoefficients;
};
class PDFCalGrayColorSpace : public PDFXYZColorSpace
{
public:
explicit PDFCalGrayColorSpace(PDFColor3 whitePoint, PDFColor3 blackPoint, PDFColorComponent gamma);
virtual ~PDFCalGrayColorSpace() = default;
virtual QColor getColor(const PDFColor& color, const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter, bool isRange01) const override;
virtual size_t getColorComponentCount() const override;
virtual void fillRGBBuffer(const std::vector<float>& colors,unsigned char* outputBuffer, RenderingIntent intent, const PDFCMS* cms, PDFRenderErrorReporter* reporter) const override;
/// Creates CalGray color space from provided values.
/// \param document Document
/// \param dictionary Dictionary
static PDFColorSpacePointer createCalGrayColorSpace(const PDFDocument* document, const PDFDictionary* dictionary);
private:
PDFColor3 m_blackPoint;
PDFColorComponent m_gamma;
};
class PDFCalRGBColorSpace : public PDFXYZColorSpace
{
public:
explicit PDFCalRGBColorSpace(PDFColor3 whitePoint, PDFColor3 blackPoint, PDFColor3 gamma, PDFColorComponentMatrix_3x3 matrix);
virtual ~PDFCalRGBColorSpace() = default;
virtual QColor getColor(const PDFColor& color, const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter, bool isRange01) const override;
virtual size_t getColorComponentCount() const override;
virtual void fillRGBBuffer(const std::vector<float>& colors,unsigned char* outputBuffer, RenderingIntent intent, const PDFCMS* cms, PDFRenderErrorReporter* reporter) const override;
/// Creates CalRGB color space from provided values.
/// \param document Document
/// \param dictionary Dictionary
static PDFColorSpacePointer createCalRGBColorSpace(const PDFDocument* document, const PDFDictionary* dictionary);
private:
PDFColor3 m_blackPoint;
PDFColor3 m_gamma;
PDFColorComponentMatrix_3x3 m_matrix;
};
class PDFLabColorSpace : public PDFXYZColorSpace
{
public:
explicit PDFLabColorSpace(PDFColor3 whitePoint, PDFColor3 blackPoint, PDFColorComponent aMin, PDFColorComponent aMax, PDFColorComponent bMin, PDFColorComponent bMax);
virtual ~PDFLabColorSpace() = default;
virtual QColor getColor(const PDFColor& color, const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter, bool isRange01) const override;
virtual size_t getColorComponentCount() const override;
virtual void fillRGBBuffer(const std::vector<float>& colors,unsigned char* outputBuffer, RenderingIntent intent, const PDFCMS* cms, PDFRenderErrorReporter* reporter) const override;
/// Creates Lab color space from provided values.
/// \param document Document
/// \param dictionary Dictionary
static PDFColorSpacePointer createLabColorSpace(const PDFDocument* document, const PDFDictionary* dictionary);
private:
PDFColor3 m_blackPoint;
PDFColorComponent m_aMin;
PDFColorComponent m_aMax;
PDFColorComponent m_bMin;
PDFColorComponent m_bMax;
};
class PDFICCBasedColorSpace : public PDFAbstractColorSpace
{
public:
static constexpr const size_t MAX_COLOR_COMPONENTS = 4;
using Ranges = std::array<PDFColorComponent, MAX_COLOR_COMPONENTS * 2>;
explicit PDFICCBasedColorSpace(PDFColorSpacePointer alternateColorSpace, Ranges range, QByteArray iccProfileData, PDFObjectReference metadata);
virtual ~PDFICCBasedColorSpace() = default;
virtual QColor getDefaultColor(const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter) const override;
virtual QColor getColor(const PDFColor& color, const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter, bool isRange01) const override;
virtual size_t getColorComponentCount() const override;
virtual void fillRGBBuffer(const std::vector<float>& colors, unsigned char* outputBuffer, RenderingIntent intent, const PDFCMS* cms, PDFRenderErrorReporter* reporter) const override;
PDFObjectReference getMetadata() const { return m_metadata; }
/// Creates ICC based color space from provided values.
/// \param colorSpaceDictionary Color space dictionary
/// \param document Document
/// \param stream Stream with ICC profile
/// \param recursion Recursion guard
/// \param usedNames Names, which were already parsed
static PDFColorSpacePointer createICCBasedColorSpace(const PDFDictionary* colorSpaceDictionary,
const PDFDocument* document,
const PDFStream* stream,
int recursion,
std::set<QByteArray>& usedNames);
private:
PDFColorSpacePointer m_alternateColorSpace;
Ranges m_range;
QByteArray m_iccProfileData;
QByteArray m_iccProfileDataChecksum;
PDFObjectReference m_metadata;
};
class PDFIndexedColorSpace : public PDFAbstractColorSpace
{
public:
explicit PDFIndexedColorSpace(PDFColorSpacePointer baseColorSpace, QByteArray&& colors, int maxValue);
virtual ~PDFIndexedColorSpace() = default;
virtual QColor getDefaultColor(const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter) const override;
virtual QColor getColor(const PDFColor& color, const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter, bool isRange01) const override;
virtual size_t getColorComponentCount() const override;
virtual QImage getImage(const PDFImageData& imageData,
const PDFImageData& softMask,
const PDFCMS* cms,
RenderingIntent intent,
PDFRenderErrorReporter* reporter) const override;
/// Creates indexed color space from provided values.
/// \param colorSpaceDictionary Color space dictionary
/// \param document Document
/// \param array Array with indexed color space definition
/// \param recursion Recursion guard
/// \param usedNames Names, which were already parsed
static PDFColorSpacePointer createIndexedColorSpace(const PDFDictionary* colorSpaceDictionary,
const PDFDocument* document,
const PDFArray* array,
int recursion,
std::set<QByteArray>& usedNames);
private:
static constexpr const int MIN_VALUE = 0;
static constexpr const int MAX_VALUE = 255;
PDFColorSpacePointer m_baseColorSpace;
QByteArray m_colors;
int m_maxValue;
};
class PDFSeparationColorSpace : public PDFAbstractColorSpace
{
public:
explicit PDFSeparationColorSpace(QByteArray&& colorName, PDFColorSpacePointer alternateColorSpace, PDFFunctionPtr tintTransform);
virtual ~PDFSeparationColorSpace() = default;
virtual QColor getDefaultColor(const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter) const override;
virtual QColor getColor(const PDFColor& color, const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter, bool isRange01) const override;
virtual size_t getColorComponentCount() const override;
bool isNone() const { return m_isNone; }
bool isAll() const { return m_isAll; }
/// Creates separation color space from provided values.
/// \param colorSpaceDictionary Color space dictionary
/// \param document Document
/// \param array Array with separation color space definition
/// \param recursion Recursion guard
/// \param usedNames Names, which were already parsed
static PDFColorSpacePointer createSeparationColorSpace(const PDFDictionary* colorSpaceDictionary,
const PDFDocument* document,
const PDFArray* array,
int recursion,
std::set<QByteArray>& usedNames);
private:
QByteArray m_colorName;
PDFColorSpacePointer m_alternateColorSpace;
PDFFunctionPtr m_tintTransform;
bool m_isNone;
bool m_isAll;
};
class PDFDeviceNColorSpace : public PDFAbstractColorSpace
{
public:
enum class Type
{
DeviceN,
NChannel
};
struct ColorantInfo
{
QByteArray name;
PDFColorSpacePointer separationColorSpace;
PDFReal solidity = 0.0;
PDFFunctionPtr dotGain;
};
using Colorants = std::vector<ColorantInfo>;
explicit PDFDeviceNColorSpace(Type type,
Colorants&& colorants,
PDFColorSpacePointer alternateColorSpace,
PDFColorSpacePointer processColorSpace,
PDFFunctionPtr tintTransform,
std::vector<QByteArray>&& colorantsPrintingOrder,
std::vector<QByteArray> processColorSpaceComponents);
virtual ~PDFDeviceNColorSpace() = default;
virtual QColor getDefaultColor(const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter) const override;
virtual QColor getColor(const PDFColor& color, const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter, bool isRange01) const override;
virtual size_t getColorComponentCount() const override;
/// Returns type of DeviceN color space
Type getType() const { return m_type; }
const Colorants& getColorants() const { return m_colorants; }
const PDFColorSpacePointer& getAlternateColorSpace() const { return m_alternateColorSpace; }
const PDFColorSpacePointer& getProcessColorSpace() const { return m_processColorSpace; }
const PDFFunctionPtr& getTintTransform() const { return m_tintTransform; }
const std::vector<QByteArray>& getPrintingOrder() const { return m_colorantsPrintingOrder; }
const std::vector<QByteArray>& getProcessColorSpaceComponents() const { return m_processColorSpaceComponents; }
bool isNone() const { return m_isNone; }
/// Creates DeviceN color space from provided values.
/// \param colorSpaceDictionary Color space dictionary
/// \param document Document
/// \param array Array with DeviceN color space definition
/// \param recursion Recursion guard
/// \param usedNames Names, which were already parsed
static PDFColorSpacePointer createDeviceNColorSpace(const PDFDictionary* colorSpaceDictionary,
const PDFDocument* document,
const PDFArray* array,
int recursion,
std::set<QByteArray>& usedNames);
private:
Type m_type;
Colorants m_colorants;
PDFColorSpacePointer m_alternateColorSpace;
PDFColorSpacePointer m_processColorSpace;
PDFFunctionPtr m_tintTransform;
std::vector<QByteArray> m_colorantsPrintingOrder;
std::vector<QByteArray> m_processColorSpaceComponents;
bool m_isNone;
};
class PDFPatternColorSpace : public PDFAbstractColorSpace
{
public:
explicit PDFPatternColorSpace(std::shared_ptr<PDFPattern>&& pattern, PDFColorSpacePointer&& uncoloredPatternColorSpace, PDFColor uncoloredPatternColor) :
m_pattern(qMove(pattern)),
m_uncoloredPatternColorSpace(qMove(uncoloredPatternColorSpace)),
m_uncoloredPatternColor(qMove(uncoloredPatternColor))
{
}
virtual ~PDFPatternColorSpace() override = default;
virtual QColor getDefaultColor(const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter) const override;
virtual QColor getColor(const PDFColor& color, const PDFCMS* cms, RenderingIntent intent, PDFRenderErrorReporter* reporter, bool isRange01) const override;
virtual size_t getColorComponentCount() const override;
virtual const PDFPatternColorSpace* asPatternColorSpace() const override { return this; }
const PDFPattern* getPattern() const { return m_pattern.get(); }
PDFColorSpacePointer getUncoloredPatternColorSpace() const { return m_uncoloredPatternColorSpace; }
PDFColor getUncoloredPatternColor() const { return m_uncoloredPatternColor; }
private:
std::shared_ptr<PDFPattern> m_pattern;
PDFColorSpacePointer m_uncoloredPatternColorSpace;
PDFColor m_uncoloredPatternColor;
};
} // namespace pdf
#endif // PDFCOLORSPACES_H
Reference in New Issue View Git Blame Copy Permalink