kis_colorspace.h

/*
 *  Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
#ifndef KIS_COLORSPACE_H_
#define KIS_COLORSPACE_H_
 
#include <config.h>
#include LCMS_HEADER
 
#include <tqvaluevector.h>
#include <tqvaluelist.h>
 
#include "kis_composite_op.h"
#include "kis_channelinfo.h"
 
class DCOPObject;
 
class KisProfile;
class KisColorSpaceFactoryRegistry;
class KisMathToolbox;
class KisFilter;
 
class KisColorAdjustment
{
public:
 
    KisColorAdjustment() {};
    virtual ~KisColorAdjustment() {};
};
 
 
enum ColorSpaceIndependence {
    FULLY_INDEPENDENT,
    TO_LAB16,
    TO_RGBA8,
    TO_RGBA16
};
 
class KisColorSpace {
 
 
public:
 
    KisColorSpace();
    virtual ~KisColorSpace();
 
    virtual DCOPObject * dcopObject();
 
    virtual bool operator==(const KisColorSpace& rhs) const {
        return id().id() == rhs.id().id();
    }
 
    
public:
 
    //========== Channels =====================================================//
 
    virtual TQValueVector<KisChannelInfo *> channels() const = 0;
 
    virtual TQ_UINT32 nChannels() const = 0;
 
    virtual TQ_UINT32 nColorChannels() const = 0;
 
    virtual TQ_UINT32 nSubstanceChannels() const { return 0; };
 
    virtual TQ_UINT32 pixelSize() const = 0;
 
    virtual TQString channelValueText(const TQ_UINT8 *pixel, TQ_UINT32 channelIndex) const = 0;
 
    virtual TQString normalisedChannelValueText(const TQ_UINT8 *pixel, TQ_UINT32 channelIndex) const = 0;
 
    virtual TQ_UINT8 scaleToU8(const TQ_UINT8 * srcPixel, TQ_INT32 channelPos) = 0;
 
     virtual TQ_UINT16 scaleToU16(const TQ_UINT8 * srcPixel, TQ_INT32 channelPos) = 0;
 
     virtual void getSingleChannelPixel(TQ_UINT8 *dstPixel, const TQ_UINT8 *srcPixel, TQ_UINT32 channelIndex) = 0;
 
    //========== Identification ===============================================//
 
    virtual KisID id() const = 0;
 
    virtual TQ_UINT32 colorSpaceType() = 0;
 
    virtual icColorSpaceSignature colorSpaceSignature() = 0;
 
    virtual bool willDegrade(ColorSpaceIndependence independence) = 0;
    
    //========== Capabilities =================================================//
 
    virtual KisCompositeOpList userVisiblecompositeOps() const = 0;
 
    virtual bool hasHighDynamicRange() const = 0;
 
 
    //========== Display profiles =============================================//
 
    virtual KisProfile * getProfile() const = 0;
 
//================= Conversion functions ==================================//
 
 
    virtual void fromTQColor(const TQColor& c, TQ_UINT8 *dst, KisProfile * profile = 0) = 0;
 
    virtual void fromTQColor(const TQColor& c, TQ_UINT8 opacity, TQ_UINT8 *dst, KisProfile * profile = 0) = 0;
 
 
    virtual void toTQColor(const TQ_UINT8 *src, TQColor *c, KisProfile * profile = 0) = 0;
 
    virtual void toTQColor(const TQ_UINT8 *src, TQColor *c, TQ_UINT8 *opacity, KisProfile * profile = 0) = 0;
 
    virtual TQImage convertToTQImage(const TQ_UINT8 *data, TQ_INT32 width, TQ_INT32 height,
                                   KisProfile *  dstProfile, TQ_INT32 renderingIntent = INTENT_PERCEPTUAL,
                                   float exposure = 0.0f) = 0;
 
 
    virtual void toLabA16(const TQ_UINT8 * src, TQ_UINT8 * dst, const TQ_UINT32 nPixels) const = 0;
 
    virtual void fromLabA16(const TQ_UINT8 * src, TQ_UINT8 * dst, const TQ_UINT32 nPixels) const = 0;
 
    virtual bool convertPixelsTo(const TQ_UINT8 * src,
                                 TQ_UINT8 * dst, KisColorSpace * dstColorSpace,
                                 TQ_UINT32 numPixels,
                                 TQ_INT32 renderingIntent = INTENT_PERCEPTUAL) = 0;
 
//============================== Manipulation functions ==========================//
 
 
//
// The manipulation functions have default implementations that _convert_ the pixel
// to a TQColor and back. Reimplement these methods in your color strategy!
//
 
    virtual TQ_UINT8 getAlpha(const TQ_UINT8 * pixel) const = 0;
 
    virtual void setAlpha(TQ_UINT8 * pixels, TQ_UINT8 alpha, TQ_INT32 nPixels) const = 0;
 
    virtual void multiplyAlpha(TQ_UINT8 * pixels, TQ_UINT8 alpha, TQ_INT32 nPixels) = 0;
 
    virtual void applyAlphaU8Mask(TQ_UINT8 * pixels, TQ_UINT8 * alpha, TQ_INT32 nPixels) = 0;
 
    virtual void applyInverseAlphaU8Mask(TQ_UINT8 * pixels, TQ_UINT8 * alpha, TQ_INT32 nPixels) = 0;
 
    virtual KisColorAdjustment *createBrightnessContrastAdjustment(TQ_UINT16 *transferValues) = 0;
 
    virtual KisColorAdjustment *createDesaturateAdjustment() = 0;
 
    virtual KisColorAdjustment *createPerChannelAdjustment(TQ_UINT16 **transferValues) = 0;
 
    virtual void applyAdjustment(const TQ_UINT8 *src, TQ_UINT8 *dst, KisColorAdjustment *, TQ_INT32 nPixels) = 0;
 
    virtual void invertColor(TQ_UINT8 * src, TQ_INT32 nPixels) = 0;
 
    // XXX: What with alpha channels? YYY: Add an overloaded function that takes alpha into account?
    virtual TQ_UINT8 difference(const TQ_UINT8* src1, const TQ_UINT8* src2) = 0;
 
 
    virtual void mixColors(const TQ_UINT8 **colors, const TQ_UINT8 *weights, TQ_UINT32 nColors, TQ_UINT8 *dst) const = 0;
 
    virtual void convolveColors(TQ_UINT8** colors, TQ_INT32* kernelValues, KisChannelInfo::enumChannelFlags channelFlags, TQ_UINT8 *dst, TQ_INT32 factor, TQ_INT32 offset, TQ_INT32 nPixels) const = 0;
 
    virtual void darken(const TQ_UINT8 * src, TQ_UINT8 * dst, TQ_INT32 shade, bool compensate, double compensation, TQ_INT32 nPixels) const = 0;
 
    virtual TQ_UINT8 intensity8(const TQ_UINT8 * src) const = 0;
    
    virtual KisID mathToolboxID() const =0;
    
    virtual void bitBlt(TQ_UINT8 *dst,
                TQ_INT32 dststride,
                KisColorSpace * srcSpace,
                const TQ_UINT8 *src,
                TQ_INT32 srcRowStride,
                const TQ_UINT8 *srcAlphaMask,
                TQ_INT32 maskRowStride,
                TQ_UINT8 opacity,
                TQ_INT32 rows,
                TQ_INT32 cols,
                const KisCompositeOp& op) = 0;
 
    virtual TQValueList<KisFilter*> createBackgroundFilters()
        { return TQValueList<KisFilter*>(); };
 
private:
 
    DCOPObject * m_dcop;
 
};
 
class KisColorSpaceFactory {
public:
    virtual KisID id() const = 0;
 
    virtual TQ_UINT32 colorSpaceType() = 0;
 
    virtual icColorSpaceSignature colorSpaceSignature() = 0;
 
    virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *) = 0;
 
    virtual TQString defaultProfile() = 0;
 
};
 
#endif // KIS_COLORSPACE_H_