F:/KPlato/koffice/libs/pigment/KoColorSpace.h

Aller à la documentation de ce fichier.

/*
 *  Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
#ifndef KOCOLORSPACE_H
#define KOCOLORSPACE_H

#include <config.h>
#include <lcms.h>
#include <limits.h>

#include <QImage>
#include <QBitArray>
#include <QHash>

#include <Q3MemArray>
#include <q3valuevector.h>
#include <q3valuelist.h>

#include <KoCompositeOp.h>
#include <KoChannelInfo.h>
#include <KoID.h>


class KoColorProfile;
class KoColorSpaceRegistry;
class KisMathToolbox;
class KisFilter;

const quint8 OPACITY_TRANSPARENT = 0;
const quint8 OPACITY_OPAQUE = UCHAR_MAX;

class KoColorAdjustment
{
public:

    KoColorAdjustment() {};
    virtual ~KoColorAdjustment() {};
};


enum ColorSpaceIndependence {
    FULLY_INDEPENDENT,
    TO_LAB16,
    TO_RGBA8,
    TO_RGBA16
};
// TODO: constify all function of KisColorSpace
class PIGMENT_EXPORT KoColorSpace {

protected:
    KoColorSpace() {};

public:
    KoColorSpace(const QString &id, const QString &name, KoColorSpaceRegistry * parent);
    virtual ~KoColorSpace();

    virtual bool operator==(const KoColorSpace& rhs) const {
        return id() == rhs.id();
    }


public:

    //========== Channels =====================================================//

    virtual Q3ValueVector<KoChannelInfo *> channels() const
    {
        return m_channels;
    }

    virtual quint32 nChannels() const = 0;

    virtual quint32 nColorChannels() const = 0;

    virtual quint32 nSubstanceChannels() const { return 0; };

    virtual quint32 pixelSize() const = 0;

    virtual QString channelValueText(const quint8 *pixel, quint32 channelIndex) const = 0;

    virtual QString normalisedChannelValueText(const quint8 *pixel, quint32 channelIndex) const = 0;

    virtual quint8 scaleToU8(const quint8 * srcPixel, qint32 channelPos) const = 0;

    virtual quint16 scaleToU16(const quint8 * srcPixel, qint32 channelPos) const = 0;

    virtual void getSingleChannelPixel(quint8 *dstPixel, const quint8 *srcPixel, quint32 channelIndex) const = 0;

    //========== Identification ===============================================//

    virtual QString id() const {return m_id;};

    virtual QString name() const {return m_name;};

    virtual quint32 colorSpaceType() const = 0;

    virtual icColorSpaceSignature colorSpaceSignature() const = 0;

    virtual bool willDegrade(ColorSpaceIndependence independence) const = 0;

    //========== Capabilities =================================================//

    virtual KoCompositeOpList userVisiblecompositeOps() const;

    virtual const KoCompositeOp * compositeOp(const QString & id) const;

    virtual void addCompositeOp(const KoCompositeOp * op);
    
    virtual bool hasHighDynamicRange() const = 0;


    //========== Display profiles =============================================//

    virtual KoColorProfile * getProfile() const = 0;

//================= Conversion functions ==================================//


    virtual void fromQColor(const QColor& c, quint8 *dst, KoColorProfile * profile = 0) const = 0;

    virtual void fromQColor(const QColor& c, quint8 opacity, quint8 *dst, KoColorProfile * profile = 0) const = 0;

    virtual void toQColor(const quint8 *src, QColor *c, KoColorProfile * profile = 0) const = 0;

    virtual void toQColor(const quint8 *src, QColor *c, quint8 *opacity, KoColorProfile * profile = 0) const = 0;

    virtual QImage convertToQImage(const quint8 *data, qint32 width, qint32 height,
                                   KoColorProfile *  dstProfile, qint32 renderingIntent = INTENT_PERCEPTUAL,
                                   float exposure = 0.0f) const = 0;

    quint8 *allocPixelBuffer(quint32 numPixels) const;

    virtual void toLabA16(const quint8 * src, quint8 * dst, const quint32 nPixels) const = 0;

    virtual void fromLabA16(const quint8 * src, quint8 * dst, const quint32 nPixels) const = 0;

    virtual void toRgbA16(const quint8 * src, quint8 * dst, const quint32 nPixels) const =0;

    virtual void fromRgbA16(const quint8 * src, quint8 * dst, const quint32 nPixels) const =0;
    
    virtual bool convertPixelsTo(const quint8 * src,
                                 quint8 * dst, const KoColorSpace * dstColorSpace,
                                 quint32 numPixels,
                                 qint32 renderingIntent = INTENT_PERCEPTUAL) const = 0;

//============================== Manipulation functions ==========================//


//
// The manipulation functions have default implementations that _convert_ the pixel
// to a QColor and back. Reimplement these methods in your color strategy!
//

    virtual quint8 getAlpha(const quint8 * pixel) const = 0;

    virtual void setAlpha(quint8 * pixels, quint8 alpha, qint32 nPixels) const = 0;

    virtual void multiplyAlpha(quint8 * pixels, quint8 alpha, qint32 nPixels) const = 0;

    virtual void applyAlphaU8Mask(quint8 * pixels, const quint8 * alpha, qint32 nPixels) const = 0;

    virtual void applyInverseAlphaU8Mask(quint8 * pixels, const quint8 * alpha, qint32 nPixels) const = 0;

    virtual KoColorAdjustment *createBrightnessContrastAdjustment(quint16 *transferValues) const = 0;

    virtual KoColorAdjustment *createDesaturateAdjustment() const = 0;

    virtual KoColorAdjustment *createPerChannelAdjustment(quint16 **transferValues) const = 0;

    virtual void applyAdjustment(const quint8 *src, quint8 *dst, KoColorAdjustment *, qint32 nPixels) const = 0;

    virtual void invertColor(quint8 * src, qint32 nPixels) const = 0;

    // XXX: What with alpha channels? YYY: Add an overloaded function that takes alpha into account?
    virtual quint8 difference(const quint8* src1, const quint8* src2) const = 0;


    virtual void mixColors(const quint8 **colors, const quint8 *weights, quint32 nColors, quint8 *dst) const = 0;

    virtual void convolveColors(quint8** colors, qint32* kernelValues, KoChannelInfo::enumChannelFlags channelFlags, quint8 *dst, qint32 factor, qint32 offset, qint32 nPixels) const = 0;

    virtual void darken(const quint8 * src, quint8 * dst, qint32 shade, bool compensate, double compensation, qint32 nPixels) const = 0;

    virtual quint8 intensity8(const quint8 * src) const = 0;

    virtual KoID mathToolboxID() const =0;

    virtual void bitBlt(quint8 *dst,
                        qint32 dststride,
                        KoColorSpace * srcSpace,
                        const quint8 *src,
                        qint32 srcRowStride,
                        const quint8 *srcAlphaMask,
                        qint32 maskRowStride,
                        quint8 opacity,
                        qint32 rows,
                        qint32 cols,
                        const KoCompositeOp * op,
            const QBitArray & channelFlags) const;
    virtual void bitBlt(quint8 *dst,
                        qint32 dststride,
                        KoColorSpace * srcSpace,
                        const quint8 *src,
                        qint32 srcRowStride,
                        const quint8 *srcAlphaMask,
                        qint32 maskRowStride,
                        quint8 opacity,
                        qint32 rows,
                        qint32 cols,
            const KoCompositeOp * op) const;
    
    virtual void bitBlt(quint8 *dst,
                        qint32 dststride,
                        KoColorSpace * srcSpace,
                        const quint8 *src,
                        qint32 srcRowStride,
                        const quint8 *srcAlphaMask,
                        qint32 maskRowStride,
                        quint8 opacity,
                        qint32 rows,
                        qint32 cols,
                        const QString & op,
            const QBitArray & channelFlags) const;

    virtual void bitBlt(quint8 *dst,
                        qint32 dststride,
                        KoColorSpace * srcSpace,
                        const quint8 *src,
                        qint32 srcRowStride,
                        const quint8 *srcAlphaMask,
                        qint32 maskRowStride,
                        quint8 opacity,
                        qint32 rows,
                        qint32 cols,
            const QString& op) const;

    

    virtual Q3ValueList<KisFilter*> createBackgroundFilters() const
        { return Q3ValueList<KisFilter*>(); };

private:

    QString m_id;
    QString m_name;

protected:
    KoColorSpaceRegistry * m_parent;
    Q3ValueVector<KoChannelInfo *> m_channels;
    QHash<QString, KoCompositeOp *> m_compositeOps;
    mutable Q3MemArray<quint8> m_conversionCache; // XXX: This will be a bad problem when we have threading.

};

class KoColorSpaceFactory {
public:
        virtual ~KoColorSpaceFactory() {}
    virtual KoID id() const = 0;

    virtual quint32 colorSpaceType() = 0;

    virtual icColorSpaceSignature colorSpaceSignature() = 0;

    virtual KoColorSpace *createColorSpace(KoColorSpaceRegistry * parent, KoColorProfile *) = 0;

    virtual QString defaultProfile() = 0;

};

#endif // KOCOLORSPACE_H

---