diff --git a/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.cpp b/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.cpp
index 2018e53710..84280ce765 100644
--- a/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.cpp
+++ b/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.cpp
@@ -1,179 +1,144 @@
 /*
  *  Copyright (c) 2006 Cyrille Berger <cberger@cberger.net>
  *
  * This library 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 2.1 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 Lesser 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.
 */
 
 #include "LabColorSpace.h"
 
 #include <QDomElement>
 
 #include <klocalizedstring.h>
 
 #include "../compositeops/KoCompositeOps.h"
 #include <KoColorConversions.h>
 #include <kis_dom_utils.h>
 
 LabU16ColorSpace::LabU16ColorSpace(const QString &name, KoColorProfile *p)
     : LcmsColorSpace<KoLabU16Traits>(colorSpaceId(), name, TYPE_LABA_16, cmsSigLabData, p)
 {
     addChannel(new KoChannelInfo(i18n("Lightness"), 0 * sizeof(quint16), 0, KoChannelInfo::COLOR, KoChannelInfo::UINT16, sizeof(quint16), QColor(100, 100, 100)));
     addChannel(new KoChannelInfo(i18n("a*"),        1 * sizeof(quint16), 1, KoChannelInfo::COLOR, KoChannelInfo::UINT16, sizeof(quint16), QColor(150, 150, 150)));
     addChannel(new KoChannelInfo(i18n("b*"),        2 * sizeof(quint16), 2, KoChannelInfo::COLOR, KoChannelInfo::UINT16, sizeof(quint16), QColor(200, 200, 200)));
     addChannel(new KoChannelInfo(i18n("Alpha"),     3 * sizeof(quint16), 3, KoChannelInfo::ALPHA, KoChannelInfo::UINT16, sizeof(quint16)));
 
     init();
 
     addStandardCompositeOps<KoLabU16Traits>(this);
 }
 
 bool LabU16ColorSpace::willDegrade(ColorSpaceIndependence independence) const
 {
     if (independence == TO_RGBA8) {
         return true;
     } else {
         return false;
     }
 }
 
-QString LabU16ColorSpace::normalisedChannelValueText(const quint8 *pixel, quint32 channelIndex) const
-{
-    const KoLabU16Traits::channels_type *pix = reinterpret_cast<const  KoLabU16Traits::channels_type *>(pixel);
-    Q_ASSERT(channelIndex < channelCount());
-
-    // These convert from lcms encoded format to standard ranges.
-
-    switch (channelIndex) {
-    case 0:
-        return QString().setNum(100.0 * static_cast<float>(pix[0]) / KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::unitValueL);
-    case 1:
-    case 2:
-        if (pix[channelIndex] <= 0.5) {
-            return QString().setNum(100.0 *
-                                    qBound((qreal)KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB,
-                                           (qreal)(2.0 * static_cast<float>(pix[channelIndex]) * KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB),
-                                           (qreal)KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB));
-        } else {
-            return QString().setNum(
-                100.0 *
-                qBound((qreal)KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB,
-                       (qreal)(KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB +
-                               2.0 * (static_cast<float>(pix[channelIndex]) - 0.5) * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB)),
-                       (qreal)KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::unitValueAB));
-        }
-    case 3:
-        return QString().setNum(
-            100.0 * qBound((qreal)0,
-                           (qreal)(static_cast<float>(pix[channelIndex]) / KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::unitValue),
-                           (qreal)KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::unitValue));
-    default:
-        return QString("Error");
-    }
-}
-
 KoColorSpace *LabU16ColorSpace::clone() const
 {
     return new LabU16ColorSpace(name(), profile()->clone());
 }
 
 void LabU16ColorSpace::colorToXML(const quint8 *pixel, QDomDocument &doc, QDomElement &colorElt) const
 {
     const KoLabU16Traits::Pixel *p = reinterpret_cast<const KoLabU16Traits::Pixel *>(pixel);
     QDomElement labElt = doc.createElement("Lab");
 
     qreal a, b;
 
     if (p->a <= KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB) {
         a = (p->a - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB) /
             (2.0 * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB));
     } else {
         a = 0.5 +
             (p->a - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB) /
                 (2.0 * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB));
     }
 
     if (p->b <= KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB) {
         b = (p->b - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB) /
             (2.0 * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB));
     } else {
         b = 0.5 +
             (p->b - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB) /
                 (2.0 * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB));
     }
 
     labElt.setAttribute("L", KisDomUtils::toString(KoColorSpaceMaths<KoLabU16Traits::channels_type, qreal>::scaleToA(p->L)));
     labElt.setAttribute("a", KisDomUtils::toString(a));
     labElt.setAttribute("b", KisDomUtils::toString(b));
     labElt.setAttribute("space", profile()->name());
     colorElt.appendChild(labElt);
 }
 
 void LabU16ColorSpace::colorFromXML(quint8 *pixel, const QDomElement &elt) const
 {
     KoLabU16Traits::Pixel *p = reinterpret_cast<KoLabU16Traits::Pixel *>(pixel);
 
     double a = KisDomUtils::toDouble(elt.attribute("a"));
     double b = KisDomUtils::toDouble(elt.attribute("b"));
 
     p->L = KoColorSpaceMaths<qreal, KoLabU16Traits::channels_type>::scaleToA(KisDomUtils::toDouble(elt.attribute("L")));
 
     if (a <= 0.5) {
         p->a = KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB +
             2.0 * a * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB);
     } else {
         p->a = (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB +
                 2.0 * (a - 0.5) * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB));
     }
 
     if (b <= 0.5) {
         p->b = KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB +
             2.0 * b * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB);
     } else {
         p->b = (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB +
                 2.0 * (b - 0.5) * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB));
     }
 
     p->alpha = KoColorSpaceMathsTraits<quint16>::max;
 }
 void LabU16ColorSpace::toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const
 {
     LabToLCH(channelValues[0],channelValues[1],channelValues[2], luma, sat, hue);
 }
 
 QVector <double> LabU16ColorSpace::fromHSY(qreal *hue, qreal *sat, qreal *luma) const
 {
     QVector <double> channelValues(4);
     LCHToLab(*luma, *sat, *hue, &channelValues[0],&channelValues[1],&channelValues[2]);
     channelValues[3]=1.0;
     return channelValues;
 }
 
 void LabU16ColorSpace::toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const
 {
     *y =channelValues[0];
     *u=channelValues[1];
     *v=channelValues[2];
 }
 
 QVector <double> LabU16ColorSpace::fromYUV(qreal *y, qreal *u, qreal *v) const
 {
     QVector <double> channelValues(4);
     channelValues[0]=*y;
     channelValues[1]=*u;
     channelValues[2]=*v;
     channelValues[3]=1.0;
     return channelValues;
 }
diff --git a/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.h b/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.h
index 7882875fe8..7785273a93 100644
--- a/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.h
+++ b/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.h
@@ -1,115 +1,113 @@
 /*
  *  Copyright (c) 2006 Cyrille Berger <cberger@cberger.net>
  *
  * This library 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 2.1 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 Lesser 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 LabU16ColorSpace_H_
 #define LabU16ColorSpace_H_
 
 #include "LcmsColorSpace.h"
 #include "KoColorModelStandardIds.h"
 
 #define TYPE_LABA_16 (COLORSPACE_SH(PT_Lab) | CHANNELS_SH(3) | BYTES_SH(2) | EXTRA_SH(1))
 
 struct KoLabF32Traits;
 
 class LabU16ColorSpace : public LcmsColorSpace<KoLabU16Traits>
 {
 public:
 
     LabU16ColorSpace(const QString &name, KoColorProfile *p);
 
     bool willDegrade(ColorSpaceIndependence independence) const override;
 
-    QString normalisedChannelValueText(const quint8 *pixel, quint32 channelIndex) const override;
-
     static QString colorSpaceId()
     {
         return QString("LABA");
     }
 
     KoID colorModelId() const override
     {
         return LABAColorModelID;
     }
 
     KoID colorDepthId() const override
     {
         return Integer16BitsColorDepthID;
     }
 
     virtual KoColorSpace *clone() const;
 
     void colorToXML(const quint8 *pixel, QDomDocument &doc, QDomElement &colorElt) const override;
 
     void colorFromXML(quint8* pixel, const QDomElement& elt) const override;
     void toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const override;
     QVector <double> fromHSY(qreal *hue, qreal *sat, qreal *luma) const override;
     void toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const override;
     QVector <double> fromYUV(qreal *y, qreal *u, qreal *v) const override;
 };
 
 class LabU16ColorSpaceFactory : public LcmsColorSpaceFactory
 {
 public:
     LabU16ColorSpaceFactory()
         : LcmsColorSpaceFactory(TYPE_LABA_16, cmsSigLabData)
     {
     }
 
     bool userVisible() const override
     {
         return true;
     }
 
     QString id() const override
     {
         return LabU16ColorSpace::colorSpaceId();
     }
 
     QString name() const override
     {
         return QString("%1 (%2)").arg(LABAColorModelID.name()).arg(Integer16BitsColorDepthID.name());
     }
 
     KoID colorModelId() const override
     {
         return LABAColorModelID;
     }
 
     KoID colorDepthId() const override
     {
         return Integer16BitsColorDepthID;
     }
 
     int referenceDepth() const override
     {
         return 16;
     }
 
     KoColorSpace *createColorSpace(const KoColorProfile *p) const override
     {
         return new LabU16ColorSpace(name(), p->clone());
     }
 
     QString defaultProfile() const override
     {
         return "Lab identity built-in";
     }
 };
 
 #endif
diff --git a/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.cpp b/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.cpp
index 8b4852cf35..ae21504f96 100644
--- a/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.cpp
+++ b/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.cpp
@@ -1,175 +1,139 @@
 /*
  *  Copyright (c) 2006 Cyrille Berger <cberger@cberger.net>
  *
  * This library 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 2.1 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 Lesser 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.
 */
 
 #include "LabU8ColorSpace.h"
 
 #include <QDomElement>
 
 #include <klocalizedstring.h>
 
 #include "../compositeops/KoCompositeOps.h"
 #include <KoColorConversions.h>
 #include <kis_dom_utils.h>
 
 LabU8ColorSpace::LabU8ColorSpace(const QString &name, KoColorProfile *p) :
     LcmsColorSpace<KoLabU8Traits>(colorSpaceId(), name, TYPE_LABA_8, cmsSigLabData, p)
 {
     addChannel(new KoChannelInfo(i18n("Lightness"), 0 * sizeof(quint8), 0, KoChannelInfo::COLOR, KoChannelInfo::UINT8, sizeof(quint8), QColor(100, 100, 100)));
     addChannel(new KoChannelInfo(i18n("a*"),        1 * sizeof(quint8), 1, KoChannelInfo::COLOR, KoChannelInfo::UINT8, sizeof(quint8), QColor(150, 150, 150)));
     addChannel(new KoChannelInfo(i18n("b*"),        2 * sizeof(quint8), 2, KoChannelInfo::COLOR, KoChannelInfo::UINT8, sizeof(quint8), QColor(200, 200, 200)));
     addChannel(new KoChannelInfo(i18n("Alpha"),     3 * sizeof(quint8), 3, KoChannelInfo::ALPHA, KoChannelInfo::UINT8, sizeof(quint8)));
     init();
     addStandardCompositeOps<KoLabU8Traits>(this);
 }
 
 bool LabU8ColorSpace::willDegrade(ColorSpaceIndependence /*independence*/) const
 {
     return false;
 }
 
-QString LabU8ColorSpace::normalisedChannelValueText(const quint8 *pixel, quint32 channelIndex) const
-{
-    const KoLabU8Traits::channels_type *pix = reinterpret_cast<const  KoLabU8Traits::channels_type *>(pixel);
-    Q_ASSERT(channelIndex < channelCount());
-
-    // These convert from lcms encoded format to standard ranges.
-
-    switch (channelIndex) {
-    case 0:
-        return QString().setNum(100.0 * static_cast<float>(pix[0]) / KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::unitValueL);
-    case 1:
-    case 2:
-        if (pix[channelIndex] <= 0.5) {
-            return QString().setNum(100.0 *
-                                    qBound((qreal)KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB,
-                                           (qreal)(2.0 * static_cast<float>(pix[channelIndex]) * KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB),
-                                           (qreal)KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB));
-        } else {
-            return QString().setNum(
-                100.0 *
-                qBound((qreal)KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB,
-                       (qreal)(KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB +
-                               2.0 * (static_cast<float>(pix[channelIndex]) - 0.5) * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB)),
-                       (qreal)KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::unitValueAB));
-        }
-    case 3:
-        return QString().setNum(
-            100.0 * qBound((qreal)0,
-                           (qreal)(static_cast<float>(pix[channelIndex]) / KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::unitValue),
-                           (qreal)KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::unitValue));
-    default:
-        return QString("Error");
-    }
-
-}
-
 KoColorSpace *LabU8ColorSpace::clone() const
 {
     return new LabU8ColorSpace(name(), profile()->clone());
 }
 
 void LabU8ColorSpace::colorToXML(const quint8 *pixel, QDomDocument &doc, QDomElement &colorElt) const
 {
     const KoLabU8Traits::Pixel *p = reinterpret_cast<const KoLabU8Traits::Pixel *>(pixel);
     QDomElement labElt = doc.createElement("Lab");
 
     double a, b;
 
     if (p->a <= KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB) {
         a = (p->a - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB) /
             (2.0 * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB));
     } else {
         a = 0.5 +
             (p->a - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB) /
                 (2.0 * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB));
     }
 
     if (p->b <= KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB) {
         b = (p->b - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB) /
             (2.0 * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB));
     } else {
         b = 0.5 +
             (p->b - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB) /
                 (2.0 * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB));
     }
 
     labElt.setAttribute("L", KisDomUtils::toString(KoColorSpaceMaths<KoLabU8Traits::channels_type, qreal>::scaleToA(p->L)));
     labElt.setAttribute("a", KisDomUtils::toString(a));
     labElt.setAttribute("b", KisDomUtils::toString(b));
     labElt.setAttribute("space", profile()->name());
     colorElt.appendChild(labElt);
 }
 
 void LabU8ColorSpace::colorFromXML(quint8 *pixel, const QDomElement &elt) const
 {
     KoLabU8Traits::Pixel *p = reinterpret_cast<KoLabU8Traits::Pixel *>(pixel);
 
     double a = KisDomUtils::toDouble(elt.attribute("a"));
     double b = KisDomUtils::toDouble(elt.attribute("b"));
 
     p->L = KoColorSpaceMaths<qreal, KoLabU8Traits::channels_type>::scaleToA(KisDomUtils::toDouble(elt.attribute("L")));
 
     if (a <= 0.5) {
         p->a =
             KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB + 2.0 * a * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB);
     } else {
         p->a = (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB +
                 2.0 * (a - 0.5) * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB));
     }
 
     if (b <= 0.5) {
         p->b =
             KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB + 2.0 * b * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB);
     } else {
         p->b = (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB +
                 2.0 * (b - 0.5) * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB));
     }
 
     p->alpha = KoColorSpaceMathsTraits<quint8>::max;
 }
 
 void LabU8ColorSpace::toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const
 {
     LabToLCH(channelValues[0],channelValues[1],channelValues[2], luma, sat, hue);
 }
 
 QVector <double> LabU8ColorSpace::fromHSY(qreal *hue, qreal *sat, qreal *luma) const
 {
     QVector <double> channelValues(4);
     LCHToLab(*luma, *sat, *hue, &channelValues[0],&channelValues[1],&channelValues[2]);
     channelValues[3]=1.0;
     return channelValues;
 }
 
 void LabU8ColorSpace::toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const
 {
     *y =channelValues[0];
     *u=channelValues[1];
     *v=channelValues[2];
 }
 
 QVector <double> LabU8ColorSpace::fromYUV(qreal *y, qreal *u, qreal *v) const
 {
     QVector <double> channelValues(4);
     channelValues[0]=*y;
     channelValues[1]=*u;
     channelValues[2]=*v;
     channelValues[3]=1.0;
     return channelValues;
 }
diff --git a/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.h b/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.h
index 52008d23dc..5a7e98b1f6 100644
--- a/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.h
+++ b/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.h
@@ -1,107 +1,106 @@
 /*
  *  Copyright (c) 2006 Cyrille Berger <cberger@cberger.net>
  *
  * This library 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 2.1 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 Lesser 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 LabU8ColorSpace_H_
 #define LabU8ColorSpace_H_
 
 #include "LcmsColorSpace.h"
 #include "KoColorModelStandardIds.h"
 
 #define TYPE_LABA_8 (COLORSPACE_SH(PT_Lab) | CHANNELS_SH(3) | BYTES_SH(1) | EXTRA_SH(1))
 
 struct KoLabU8Traits;
 
 class LabU8ColorSpace : public LcmsColorSpace<KoLabU8Traits>
 {
 public:
     LabU8ColorSpace(const QString &name, KoColorProfile *p);
     bool willDegrade(ColorSpaceIndependence independence) const override;
-    QString normalisedChannelValueText(const quint8 *pixel, quint32 channelIndex) const override;
 
     static QString colorSpaceId()
     {
         return QString("LABAU8");
     }
 
     KoID colorModelId() const override
     {
         return LABAColorModelID;
     }
 
     KoID colorDepthId() const override
     {
         return Integer8BitsColorDepthID;
     }
 
     virtual KoColorSpace* clone() const;
     void colorToXML(const quint8* pixel, QDomDocument& doc, QDomElement& colorElt) const override;
     void colorFromXML(quint8* pixel, const QDomElement& elt) const override;
     void toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const override;
     QVector <double> fromHSY(qreal *hue, qreal *sat, qreal *luma) const override;
     void toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const override;
     QVector <double> fromYUV(qreal *y, qreal *u, qreal *v) const override;
 };
 
 class LabU8ColorSpaceFactory : public LcmsColorSpaceFactory
 {
 public:
     LabU8ColorSpaceFactory() : LcmsColorSpaceFactory(TYPE_LABA_8, cmsSigLabData) {}
 
     bool userVisible() const override
     {
         return true;
     }
 
     QString id() const override
     {
         return LabU8ColorSpace::colorSpaceId();
     }
 
     QString name() const override
     {
         return QString("%1 (%2)").arg(LABAColorModelID.name()).arg(Integer8BitsColorDepthID.name());
     }
 
     KoID colorModelId() const override
     {
         return LABAColorModelID;
     }
 
     KoID colorDepthId() const override
     {
         return Integer8BitsColorDepthID;
     }
 
     int referenceDepth() const override
     {
         return 8;
     }
 
     KoColorSpace *createColorSpace(const KoColorProfile *p) const override
     {
         return new LabU8ColorSpace(name(), p->clone());
     }
 
     QString defaultProfile() const override
     {
         return "Lab identity built-in";
     }
 };
 
 #endif