/*
* Copyright (c) 2010 Ixonos Plc.
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - Initial contribution
*
* Contributors:
* Ixonos Plc
*
* Description:
*
*/
//----IMAAMI----
//*************************************************************************
//CDCIETD.cpp
//Version 2.00
//
//Contains:
// CDCIETD
// Display specific color contrast enhancement,
// Image Enhancement for Transflective Displays version 2,
// IETD 2.
//
//History:
// 23.10.2003 version 2.00 created using existing IMAAMI IETD
//*************************************************************************
// Include Files
#include <e32std.h> // The basic definitions
#include <fbs.h> // For FBS bitmap
#include "DCIetd.h" // The DCIetd class
// MEMBER FUNCTIONS
//=============================================================================
/*
-----------------------------------------------------------------------------
CDCIetd
Constructor
Default constructor, initializes member variables to initial values
Return Values: none
-----------------------------------------------------------------------------
*/
CDCIetd::CDCIetd()
{
// Set default values for parameters (from init file)
iParameters.aWhitePixels = WhitePixels;
iParameters.aBlackPixels = BlackPixels;
iParameters.aStretchLimit = StretchLimit;
iParameters.aSaturationGain = SaturationGain;
iParameters.aBitLimit = BitLimit;
iParameters.aWBC = WBC;
iParameters.aDBC = DBC;
}
/*
-----------------------------------------------------------------------------
CDCIetd
NewLC
Factory function to instantiate the class.
This function leaves the class pointer to the cleanup stack
May leave with KErrNoMemory if no memory available
Return Values: CDCIetd* self: pointer to the class instance
-----------------------------------------------------------------------------
*/
CDCIetd* CDCIetd::NewLC()
{
CDCIetd* self = new (ELeave) CDCIetd();
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
/*
-----------------------------------------------------------------------------
CDCIetd
NewL
Factory function to instantiate the class.
May leave with KErrNoMemory if no memory available
Return Values: CDCIetd* self: pointer to the class instance
-----------------------------------------------------------------------------
*/
CDCIetd* CDCIetd::NewL()
{
CDCIetd* self = CDCIetd::NewLC();
CleanupStack::Pop();
return self;
}
/*
-----------------------------------------------------------------------------
CDCIetd
ConstructL
Second phase constructor. Does nothing at the moment
Return Values: none
-----------------------------------------------------------------------------
*/
void CDCIetd::ConstructL()
{
// This function is intentionally left blank.
}
/*
-----------------------------------------------------------------------------
CDCIetd
Destructor
Return Values: none
-----------------------------------------------------------------------------
*/
CDCIetd::~CDCIetd()
{
// This function is intentionally left blank.
}
/*
-----------------------------------------------------------------------------
CDCIetd
Analyze
Analyze image referenced by aBPtr
Return Values: none
-----------------------------------------------------------------------------
*/
// Analyze image referenced by aBPtr
void CDCIetd::Analyze(CFbsBitmap& aBPtr)
{
//EColor16M image is needed
if (aBPtr.DisplayMode() != EColor16M) return;
//Do analysis
GatherHistograms(aBPtr);
MakeMappings();
}
/*
-----------------------------------------------------------------------------
CDCIetd
ProcessL
Process image referenced by aImage (modify aImage).
May leave with KErrNoMemory if no memory available
Return Values: none
-----------------------------------------------------------------------------
*/
void CDCIetd::ProcessL (CFbsBitmap& aImage) // image reference
{
TUint r, g, b; // Color components
TUint lum; // Brightness estimate
TInt dr, dg, db; // Differences to brightness
TUint8* dataPtr; // Pointer to data
//EColor16M image is needed
if (aImage.DisplayMode() != EColor16M) return;
//Line Buffer and pointer to the data
TUint imageWidth = aImage.SizeInPixels().iWidth;
TUint scanLineLengthInBytes = aImage.ScanLineLength(imageWidth, aImage.DisplayMode());
//Allocate buffer for scanline
iScanLineBuffer = HBufC8::NewMaxL(scanLineLengthInBytes);
//Pointer to scanline
TPtr8 linePtr = iScanLineBuffer->Des();
//Step through image pixels and do stretching
//and saturation increase
//---------------------------------------------
//Read all lines
for (TInt lineNo=0; lineNo<aImage.SizeInPixels().iHeight; ++lineNo)
{
//Get line
aImage.GetScanLine(linePtr, TPoint(0, lineNo), imageWidth, aImage.DisplayMode());
//CHECK! CONST_CAST not used in every algorithm which way is better?
dataPtr = CONST_CAST(TUint8*, linePtr.Ptr());
//Step through pixels in line
for (TUint x=0; x < imageWidth; ++x)
{
// Map color componets according to mapping LUTs
b = iMap[2][*dataPtr++];
g = iMap[1][*dataPtr++];
r = iMap[0][*dataPtr++];
//Compute brightness estimate
//lum=0.299r+0.587g+0.114b; //true Y
//lum=(32768+19595*r+38470*g+7471*b)>>16; //Y
//lum = (r+g+b)/3; //Simple approximation
lum=(r+(g<<1)+b)>>2; //More effective simple approximation
//Compute componentwise differences to luminance
dr = r-lum;
dg = g-lum;
db = b-lum;
//Increase differences => saturation increases.
//Use gain parameter for adjusting the strength of the effect.
b += iParameters.aSaturationGain*db/32;
g += iParameters.aSaturationGain*dg/32;
r += iParameters.aSaturationGain*dr/32;
//Save data to same image & same pixels
dataPtr -= 3;
//Limit to available dynamic range [0,255].
*dataPtr++ = Limit255(b);
*dataPtr++ = Limit255(g);
*dataPtr++ = Limit255(r);
}
//Save line
aImage.SetScanLine(linePtr, lineNo);
}
//Free memory
delete(iScanLineBuffer);
iScanLineBuffer = 0;
}
/*
-----------------------------------------------------------------------------
CDCIetd
GatherHistograms
Gather histograms and make cumulative histogram.
Return Values: none
-----------------------------------------------------------------------------
*/
void CDCIetd::GatherHistograms (const CFbsBitmap& aImage) // Pointer to the image bitmap
{
const TUint8* dataPtr; //Pointer to data
TInt lineNo; //Line number
TUint x; //Pixel index
TUint color; //Color index
TUint count; // Number of colors in each component
//Compute image width & allocate scan line memory
TUint imageWidth = aImage.SizeInPixels().iWidth;
TUint histScanLineLengthInBytes = aImage.ScanLineLength(imageWidth, aImage.DisplayMode());
iScanLineBuffer = HBufC8::NewMaxL(histScanLineLengthInBytes);
//Pointer to line
TPtr8 linePtr = iScanLineBuffer->Des();
//Clear histograms
Mem::FillZ(iHistogram, sizeof(iHistogram));
// Read all lines and gather histograms
for (lineNo=0; lineNo<aImage.SizeInPixels().iHeight; lineNo++)
{
//Get line
aImage.GetScanLine(linePtr, TPoint(0, lineNo), imageWidth, aImage.DisplayMode());
dataPtr = linePtr.Ptr();
//Step through pixels
for (x=imageWidth; x != 0; --x)
{
++iHistogram[2][*dataPtr++]; // Increase Blue bin value
++iHistogram[1][*dataPtr++]; // Increase Green bin value
++iHistogram[0][*dataPtr++]; // Increase Red bin value
}
}
//Make cumulative histograms & count colors in each histogram
for (color=0; color<3; ++color)
{
// Count used colors
count=0;
for (x=0; x<256; ++x)
{
if (iHistogram[color][x]>0) count++;
}
// Compute increased stretch limit if a color component has less colors than iBitLimit.
// Otherwise use predetermined stretch limit.
if (count<iParameters.aBitLimit)
iReducedStretchLimit[color] = (TUint8)(iParameters.aStretchLimit*count/iParameters.aBitLimit+255-255*count/iParameters.aBitLimit);
else
iReducedStretchLimit[color] = iParameters.aStretchLimit;
//Make cumulative histogram
for (x=1; x<256; ++x)
iHistogram[color][x] += iHistogram[color][x-1];
}
//Free memory
delete(iScanLineBuffer);
iScanLineBuffer = 0;
}
/*
-----------------------------------------------------------------------------
CDCIetd
MakeMappings
Make mapping function look-up table (LUT).
Return Values: none
-----------------------------------------------------------------------------
*/
void CDCIetd::MakeMappings()
{
TInt MinBins[3];// Smallest existing values in histogram
TInt MaxBins[3];// Largest existing values in histogram
TUint minBin; // Minimum of smallest existing values
TUint maxBin; // Maximum of largest existing values
TUint x; // Index
// Stretching limit variables
TUint minShift;
TUint maxShift;
TUint totalShift;
TUint color; //Color index
//Step through colors
for (color=0; color<3; ++color)
{
// Find smallest existing values in histograms, discard darkest pixels
// according to blackpixels parameter
x = 0; // Start from fist bin
MinBins[color] = iParameters.aBlackPixels * iHistogram[color][255]/1000; // Compute value to be found
while (x < 255 && (TUint)iHistogram[color][x] < MinBins[color])
++x; // Find from histogram
MinBins[color] = x; // Save bin index = start of stretching part of LUT
// Find largest existing values in histograms, discard brightest pixels
// according to whitepixels parameter
x = 255; // Start from last bin
//Compute value to be found
MaxBins[color] = iHistogram[color][255] - iParameters.aWhitePixels * iHistogram[color][255]/1000;
while (x > 0 && (TUint)iHistogram[color][x] > MaxBins[color])
--x; // Find from histogram
MaxBins[color] = x; // Save bin index = end of stretching part of LUT
}
//Find minimum of all colors
minBin=255;
for (color=0; color<3; color++)
{
if (minBin>MinBins[color]) minBin=MinBins[color];
}
//Find maximum of all colors
maxBin=0;
for (color=0; color<3; color++)
{
if (maxBin<MaxBins[color]) maxBin=MaxBins[color];
}
//Adjust white and dark balance within limits given in parameters (maximum correction).
//0 means that largest(or smallest) of all values is used => no WBC(or DBC).
for (color=0; color<3; color++)
{
if(maxBin-MaxBins[color]>iParameters.aWBC) MaxBins[color]=maxBin-iParameters.aWBC;
if((MinBins[color]-minBin) > iParameters.aDBC) MinBins[color]=minBin+iParameters.aDBC;
}
//Step through color components
for (color=0; color<3; color++)
{
// If histogram has only one nonzero bin maxBin can be less than minBin.
// In that case change maxBin value to minBin.
if(MaxBins[color]<MinBins[color]) MaxBins[color]=MinBins[color];
// Limit stretching to narrovest histogram that can be stretched
if (MaxBins[color]-MinBins[color] < iReducedStretchLimit[color])
{
// Compute limiting shifts to measured values.
// Compute shifts for dark and bright end in relation
// to coresponding available space in dynamic range.
totalShift = iReducedStretchLimit[color]-(MaxBins[color]-MinBins[color]);
maxShift = totalShift*(255-MaxBins[color])/(255-(MaxBins[color]-MinBins[color]));
minShift = totalShift*MinBins[color]/(255-(MaxBins[color]-MinBins[color]));
// Shift measured values, so that stretching is limited
MinBins[color] -= minShift;
MaxBins[color] += maxShift;
// Check that dynamic range is not exceeded
// (Should happen only with faulty parameter values)
if (MinBins[color]<0)
MinBins[color]=0;
if (MaxBins[color]>255)
MaxBins[color]=255;
}
// Set 0 mapping part of the LUT
for (x=0; x<=MinBins[color]; ++x)
iMap[color][x] = 0;
// Set 255 mapping part of the LUT
for (x=MaxBins[color]; x<=255; ++x)
iMap[color][x] = 255;
// Compute linear stretching part of the LUT
for (x=MinBins[color]+1; x<MaxBins[color]; x++)
iMap[color][x] = (TUint8)(255*(x-MinBins[color])/(MaxBins[color]-MinBins[color]));
}
}
/*
-----------------------------------------------------------------------------
CDCIetd
SetParams
Set processing parameters
Return Values: none
-----------------------------------------------------------------------------
*/
void CDCIetd::SetParams(DCIetdParameters* params)
{
iParameters = *params;
}
/*
-----------------------------------------------------------------------------
CDCIetd
GetParams
Get current processing parameters
Return Values: none
-----------------------------------------------------------------------------
*/
void CDCIetd::GetParams(DCIetdParameters* params)
{
*params = iParameters;
}
//----IMAAMI----