kindred/create
1
1
Fork 0
Code Issues 30 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

App: code cleanup of Color models

Browse Source
This commit is contained in:
wmayer
2022-01-29 11:58:05 +01:00
parent 9f1a62da29
commit 90d9f58de0
4 changed files with 310 additions and 384 deletions
Download Patch File Download Diff File Expand all files Collapse all files

351
src/App/ColorModel.cpp
View File

@@ -31,124 +31,83 @@
using namespace App;
ColorModel::ColorModel (unsigned short usCt)
: _usColors(usCt), _pclColors(0)
{
if (usCt > 0)
_pclColors = new Color[usCt];
}
ColorModel::ColorModel (const ColorModel &rclM)
: _pclColors(0)
{
*this = rclM;
}
ColorModel::~ColorModel ()
{
delete [] _pclColors;
}
ColorModel& ColorModel::operator = (const ColorModel &rclM)
{
// first check if both objects are identical
if (this == &rclM)
return *this;
delete [] _pclColors;
_pclColors = 0;
_usColors = rclM._usColors;
if (_usColors == 0)
return *this;
_pclColors = new Color[rclM._usColors];
for (int i = 0; i < rclM._usColors; i++)
_pclColors[i] = rclM._pclColors[i];
return *this;
}
ColorField::ColorField (void)
: _clModel(ColorModelTria())
ColorField::ColorField ()
: colorModel(ColorModelTria())
{
set(ColorModelTria(), -1.0f, 1.0f, 13);
}
ColorField::ColorField (const ColorModel &rclModel, float fMin, float fMax, unsigned short usCt)
: _clModel(ColorModelTria())
ColorField::ColorField (const ColorModel &rclModel, float fMin, float fMax, std::size_t usCt)
: colorModel(ColorModelTria())
{
set(rclModel, fMin, fMax, usCt);
}
ColorField::~ColorField ()
{
}
ColorField::ColorField (const ColorField &rclCF)
: _clModel(rclCF._clModel),
_fMin(rclCF._fMin),
_fMax(rclCF._fMax),
_fAscent(rclCF._fAscent),
_fConstant(rclCF._fConstant),
_usCtColors(rclCF._usCtColors),
_aclField(rclCF._aclField)
: colorModel(rclCF.colorModel),
fMin(rclCF.fMin),
fMax(rclCF.fMax),
fAscent(rclCF.fAscent),
fConstant(rclCF.fConstant),
ctColors(rclCF.ctColors),
colorField(rclCF.colorField)
{
}
ColorField& ColorField::operator = (const ColorField &rclCF)
{
_aclField = rclCF._aclField;
colorField = rclCF.colorField;
return *this;
}
void ColorField::set (const ColorModel &rclModel, float fMin, float fMax, unsigned short usCt)
void ColorField::set (const ColorModel &rclModel, float fMin, float fMax, std::size_t usCt)
{
_clModel = rclModel;
_fMin = std::min<float>(fMin, fMax);
_fMax = std::max<float>(_fMin + CCR_EPS, fMax);
_usCtColors = std::max<unsigned short>(usCt, _clModel._usColors);
colorModel = rclModel;
this->fMin = std::min<float>(fMin, fMax);
this->fMax = std::max<float>(this->fMin + CCR_EPS, fMax);
ctColors = std::max<std::size_t>(usCt, colorModel.getCountColors());
rebuild();
}
void ColorField::setColorModel (const ColorModel &rclModel)
{
_clModel = rclModel;
colorModel = rclModel;
rebuild();
}
void ColorField::rebuild (void)
void ColorField::rebuild ()
{
unsigned short usInd1, usInd2, usStep, i;
std::size_t usInd1, usInd2, usStep, i;
_aclField.resize(_usCtColors);
colorField.resize(ctColors);
usStep = std::min<unsigned short>(_usCtColors / (_clModel._usColors-1), _usCtColors-1);
usStep = std::min<std::size_t>(ctColors / (colorModel.getCountColors() - 1), ctColors - 1);
usInd1 = 0;
usInd2 = usStep;
for (i = 0; i < (_clModel._usColors - 1); i++) {
interpolate(_clModel._pclColors[i], usInd1, _clModel._pclColors[i+1], usInd2);
for (i = 0; i < (colorModel.getCountColors() - 1); i++) {
interpolate(colorModel.colors[i], usInd1, colorModel.colors[i+1], usInd2);
usInd1 = usInd2;
if ((i + 1) == (_clModel._usColors - 2))
usInd2 = _usCtColors - 1;
if ((i + 1) == (colorModel.getCountColors() - 2))
usInd2 = ctColors - 1;
else
usInd2 += usStep;
}
_fAscent = float(_usCtColors) / (_fMax - _fMin);
_fConstant = -_fAscent * _fMin;
fAscent = float(ctColors) / (fMax - fMin);
fConstant = -fAscent * fMin;
}
// fuellt das Array von Farbe 1, Index 1 bis Farbe 2, Index 2
void ColorField::interpolate (Color clCol1, unsigned short usInd1, Color clCol2, unsigned short usInd2)
void ColorField::interpolate (Color clCol1, std::size_t usInd1, Color clCol2, std::size_t usInd2)
{
unsigned short i;
std::size_t i;
float ucR, ucG, ucB;
float fR, fG, fB, fStep = 1.0f, fLen = float(usInd2 - usInd1);
_aclField[usInd1] = clCol1;
_aclField[usInd2] = clCol2;
colorField[usInd1] = clCol1;
colorField[usInd2] = clCol2;
fR = (float(clCol2.r) - float(clCol1.r)) / fLen;
fG = (float(clCol2.g) - float(clCol1.g)) / fLen;
@@ -158,115 +117,83 @@ void ColorField::interpolate (Color clCol1, unsigned short usInd1, Color clCol2,
ucR = clCol1.r + fR * fStep;
ucG = clCol1.g + fG * fStep;
ucB = clCol1.b + fB * fStep;
_aclField[i] = Color(ucR, ucG, ucB);
colorField[i] = Color(ucR, ucG, ucB);
fStep += 1.0f;
}
}
ColorGradient::ColorGradient (void)
: _tColorModel(TRIA),
_tStyle(ZERO_BASED),
_bOutsideGrayed(false),
_clTotal(ColorModelTria()),
_clTop(ColorModelTriaTop()),
_clBottom(ColorModelTriaBottom())
ColorGradient::ColorGradient ()
: tColorModel(TRIA),
tStyle(ZERO_BASED),
outsideGrayed(false),
totalModel(ColorModelTria()),
topModel(ColorModelTriaTop()),
bottomModel(ColorModelTriaBottom())
{
setColorModel();
set(-1.0f, 1.0f, 13, ZERO_BASED, false);
}
ColorGradient::ColorGradient (float fMin, float fMax, unsigned short usCtColors, TStyle tS, bool bOG)
: _tColorModel(TRIA),
_tStyle(tS),
_bOutsideGrayed(false),
_clTotal(ColorModelTria()),
_clTop(ColorModelTriaTop()),
_clBottom(ColorModelTriaBottom())
ColorGradient::ColorGradient (float fMin, float fMax, std::size_t usCtColors, TStyle tS, bool bOG)
: tColorModel(TRIA),
tStyle(tS),
outsideGrayed(false),
totalModel(ColorModelTria()),
topModel(ColorModelTriaTop()),
bottomModel(ColorModelTriaBottom())
{
setColorModel();
set(fMin, fMax, usCtColors, tS, bOG);
}
ColorGradient::ColorGradient (const ColorGradient &rclCR)
: _clColFld1(rclCR._clColFld1),
_clColFld2(rclCR._clColFld2),
_tColorModel(rclCR._tColorModel),
_tStyle(rclCR._tStyle),
_fMin(rclCR._fMin),
_fMax(rclCR._fMax),
_usCtColors(rclCR._usCtColors),
_bOutsideGrayed(rclCR._bOutsideGrayed),
_clTotal(rclCR._clTotal),
_clTop(rclCR._clTop),
_clBottom(rclCR._clBottom)
{
}
ColorGradient& ColorGradient::operator = (const ColorGradient &rclCR)
{
_tColorModel = rclCR._tColorModel;
_clTotal = rclCR._clTotal;
_clTop = rclCR._clTop;
_clBottom = rclCR._clBottom;
_bOutsideGrayed = rclCR._bOutsideGrayed;
_clColFld1 = rclCR._clColFld1;
_clColFld2 = rclCR._clColFld2;
_tStyle = rclCR._tStyle;
_fMin = rclCR._fMin;
_fMax = rclCR._fMax;
_usCtColors = rclCR._usCtColors;
return *this;
}
void ColorGradient::set (float fMin, float fMax, unsigned short usCt, TStyle tS, bool bOG)
void ColorGradient::set (float fMin, float fMax, std::size_t usCt, TStyle tS, bool bOG)
{
_fMin = std::min<float>(fMin, fMax);
_fMax = std::max<float>(_fMin + CCR_EPS, fMax);
_usCtColors = std::max<unsigned short>(usCt, getMinColors());
_tStyle = tS;
_bOutsideGrayed = bOG;
ctColors = std::max<std::size_t>(usCt, getMinColors());
tStyle = tS;
outsideGrayed = bOG;
rebuild();
}
void ColorGradient::rebuild (void)
void ColorGradient::rebuild ()
{
switch (_tStyle)
switch (tStyle)
{
case FLOW:
{
_clColFld1.set(_clTotal, _fMin, _fMax, _usCtColors);
colorField1.set(totalModel, _fMin, _fMax, ctColors);
break;
}
case ZERO_BASED:
{
if ((_fMin < 0.0f) && (_fMax > 0.0f))
{
_clColFld1.set(_clBottom, _fMin, 0.0f, _usCtColors / 2);
_clColFld2.set(_clTop, 0.0f, _fMax, _usCtColors / 2);
colorField1.set(bottomModel, _fMin, 0.0f, ctColors / 2);
colorField2.set(topModel, 0.0f, _fMax, ctColors / 2);
}
else if (_fMin >= 0.0f)
_clColFld1.set(_clTop, 0.0f, _fMax, _usCtColors);
colorField1.set(topModel, 0.0f, _fMax, ctColors);
else
_clColFld1.set(_clBottom, _fMin, 0.0f, _usCtColors);
colorField1.set(bottomModel, _fMin, 0.0f, ctColors);
break;
}
}
}
unsigned short ColorGradient::getMinColors (void) const
std::size_t ColorGradient::getMinColors () const
{
switch (_tStyle)
switch (tStyle)
{
case FLOW:
return _clColFld1.getMinColors();
return colorField1.getMinColors();
case ZERO_BASED:
{
if ((_fMin < 0.0f) && (_fMax > 0.0f))
return _clColFld1.getMinColors() + _clColFld2.getMinColors();
return colorField1.getMinColors() + colorField2.getMinColors();
else
return _clColFld1.getMinColors();
return colorField1.getMinColors();
}
}
return 2;
@@ -274,75 +201,75 @@ unsigned short ColorGradient::getMinColors (void) const
void ColorGradient::setColorModel (TColorModel tModel)
{
_tColorModel = tModel;
tColorModel = tModel;
setColorModel();
rebuild();
}
void ColorGradient::setColorModel (void)
void ColorGradient::setColorModel ()
{
switch (_tColorModel)
switch (tColorModel)
{
case TRIA:
{
_clTotal = ColorModelTria();
_clTop = ColorModelTriaTop();
_clBottom = ColorModelTriaBottom();
totalModel = ColorModelTria();
topModel = ColorModelTriaTop();
bottomModel = ColorModelTriaBottom();
break;
}
case INVERSE_TRIA:
{
_clTotal = ColorModelInverseTria();
_clTop = ColorModelInverseTriaTop();
_clBottom = ColorModelInverseTriaBottom();
totalModel = ColorModelInverseTria();
topModel = ColorModelInverseTriaTop();
bottomModel = ColorModelInverseTriaBottom();
break;
}
case GRAY:
{
_clTotal = ColorModelGray();
_clTop = ColorModelGrayTop();
_clBottom = ColorModelGrayBottom();
totalModel = ColorModelGray();
topModel = ColorModelGrayTop();
bottomModel = ColorModelGrayBottom();
break;
}
case INVERSE_GRAY:
{
_clTotal = ColorModelInverseGray();
_clTop = ColorModelInverseGrayTop();
_clBottom = ColorModelInverseGrayBottom();
totalModel = ColorModelInverseGray();
topModel = ColorModelInverseGrayTop();
bottomModel = ColorModelInverseGrayBottom();
break;
}
}
switch (_tStyle)
switch (tStyle)
{
case FLOW:
{
_clColFld1.setColorModel(_clTotal);
_clColFld2.setColorModel(_clBottom);
colorField1.setColorModel(totalModel);
colorField2.setColorModel(bottomModel);
break;
}
case ZERO_BASED:
{
_clColFld1.setColorModel(_clTop);
_clColFld2.setColorModel(_clBottom);
colorField1.setColorModel(topModel);
colorField2.setColorModel(bottomModel);
break;
}
}
}
ColorLegend::ColorLegend (void)
: _bOutsideGrayed(false)
ColorLegend::ColorLegend ()
: outsideGrayed(false)
{
// default green, red
_aclColorFields.emplace_back(0, 1, 0);
_aclColorFields.emplace_back(1, 0, 0);
colorFields.emplace_back(0, 1, 0);
colorFields.emplace_back(1, 0, 0);
_aclNames.push_back("Min");
_aclNames.push_back("Max");
names.push_back("Min");
names.push_back("Max");
_aclValues.push_back(-1.0f);
_aclValues.push_back(0.0f);
_aclValues.push_back(1.0f);
values.push_back(-1.0f);
values.push_back(0.0f);
values.push_back(1.0f);
}
ColorLegend::ColorLegend (const ColorLegend &rclCL)
@@ -352,38 +279,38 @@ ColorLegend::ColorLegend (const ColorLegend &rclCL)
ColorLegend& ColorLegend::operator = (const ColorLegend &rclCL)
{
_aclColorFields = rclCL._aclColorFields;
_aclNames = rclCL._aclNames;
_aclValues = rclCL._aclValues;
_bOutsideGrayed = rclCL._bOutsideGrayed;
colorFields = rclCL.colorFields;
names = rclCL.names;
values = rclCL.values;
outsideGrayed = rclCL.outsideGrayed;
return *this;
}
bool ColorLegend::operator == (const ColorLegend &rclCL) const
{
return (_aclColorFields.size() == rclCL._aclColorFields.size()) &&
(_aclNames.size() == rclCL._aclNames.size()) &&
(_aclValues.size() == rclCL._aclValues.size()) &&
std::equal(_aclColorFields.begin(), _aclColorFields.end(), rclCL._aclColorFields.begin()) &&
std::equal(_aclNames.begin(), _aclNames.end(), rclCL._aclNames.begin()) &&
std::equal(_aclValues.begin(), _aclValues.end(), rclCL._aclValues.begin()) &&
_bOutsideGrayed == rclCL._bOutsideGrayed;
return (colorFields.size() == rclCL.colorFields.size()) &&
(names.size() == rclCL.names.size()) &&
(values.size() == rclCL.values.size()) &&
std::equal(colorFields.begin(), colorFields.end(), rclCL.colorFields.begin()) &&
std::equal(names.begin(), names.end(), rclCL.names.begin()) &&
std::equal(values.begin(), values.end(), rclCL.values.begin()) &&
outsideGrayed == rclCL.outsideGrayed;
}
float ColorLegend::getValue (unsigned long ulPos) const
{
if (ulPos < _aclValues.size())
return _aclValues[ulPos];
if (ulPos < values.size())
return values[ulPos];
else
return 0.0f;
}
bool ColorLegend::setValue (unsigned long ulPos, float fVal)
{
if (ulPos < _aclValues.size())
if (ulPos < values.size())
{
_aclValues[ulPos] = fVal;
values[ulPos] = fVal;
return true;
}
else
@@ -392,8 +319,8 @@ bool ColorLegend::setValue (unsigned long ulPos, float fVal)
Color ColorLegend::getColor (unsigned long ulPos) const
{
if (ulPos < _aclColorFields.size())
return _aclColorFields[ulPos];
if (ulPos < colorFields.size())
return colorFields[ulPos];
else
return Color();
}
@@ -407,49 +334,49 @@ uint32_t ColorLegend::getPackedColor (unsigned long ulPos) const
std::string ColorLegend::getText (unsigned long ulPos) const
{
if (ulPos < _aclNames.size())
return _aclNames[ulPos];
if (ulPos < names.size())
return names[ulPos];
else
return "";
}
bool ColorLegend::addMin (const std::string &rclName)
{
_aclNames.push_front(rclName);
_aclValues.push_front(*_aclValues.begin() - 1.0f);
names.push_front(rclName);
values.push_front(*values.begin() - 1.0f);
Color clNewRGB;
clNewRGB.r = ((float)rand() / (float)RAND_MAX);
clNewRGB.g = ((float)rand() / (float)RAND_MAX);
clNewRGB.b = ((float)rand() / (float)RAND_MAX);
_aclColorFields.push_front(clNewRGB);
colorFields.push_front(clNewRGB);
return true;
}
bool ColorLegend::addMax (const std::string &rclName)
{
_aclNames.push_back(rclName);
_aclValues.push_back(*(_aclValues.end()-1) + 1.0f);
names.push_back(rclName);
values.push_back(*(values.end()-1) + 1.0f);
Color clNewRGB;
clNewRGB.r = ((float)rand() / (float)RAND_MAX);
clNewRGB.g = ((float)rand() / (float)RAND_MAX);
clNewRGB.b = ((float)rand() / (float)RAND_MAX);
_aclColorFields.push_back(clNewRGB);
colorFields.push_back(clNewRGB);
return true;
}
bool ColorLegend::remove (unsigned long ulPos)
{
if (ulPos < _aclColorFields.size())
if (ulPos < colorFields.size())
{
_aclColorFields.erase(_aclColorFields.begin() + ulPos);
_aclNames.erase(_aclNames.begin() + ulPos);
_aclValues.erase(_aclValues.begin() + ulPos);
colorFields.erase(colorFields.begin() + ulPos);
names.erase(names.begin() + ulPos);
values.erase(values.begin() + ulPos);
return true;
}
@@ -457,40 +384,40 @@ bool ColorLegend::remove (unsigned long ulPos)
return false;
}
void ColorLegend::removeFirst (void)
void ColorLegend::removeFirst ()
{
if (_aclColorFields.size() > 0)
if (colorFields.size() > 0)
{
_aclColorFields.erase(_aclColorFields.begin());
_aclNames.erase(_aclNames.begin());
_aclValues.erase(_aclValues.begin());
colorFields.erase(colorFields.begin());
names.erase(names.begin());
values.erase(values.begin());
}
}
void ColorLegend::removeLast (void)
void ColorLegend::removeLast ()
{
if (_aclColorFields.size() > 0)
if (colorFields.size() > 0)
{
_aclColorFields.erase(_aclColorFields.end()-1);
_aclNames.erase(_aclNames.end()-1);
_aclValues.erase(_aclValues.end()-1);
colorFields.erase(colorFields.end()-1);
names.erase(names.end()-1);
values.erase(values.end()-1);
}
}
void ColorLegend::resize (unsigned long ulCt)
{
if ((ulCt < 2) || (ulCt == _aclColorFields.size()))
if ((ulCt < 2) || (ulCt == colorFields.size()))
return;
if (ulCt > _aclColorFields.size())
if (ulCt > colorFields.size())
{
int k = ulCt - _aclColorFields.size();
int k = ulCt - colorFields.size();
for (int i = 0; i < k; i++)
addMin("new");
}
else
{
int k = _aclColorFields.size() - ulCt;
int k = colorFields.size() - ulCt;
for (int i = 0; i < k; i++)
removeLast();
}
@@ -498,9 +425,9 @@ void ColorLegend::resize (unsigned long ulCt)
bool ColorLegend::setColor (unsigned long ulPos, float ucRed, float ucGreen, float ucBlue)
{
if (ulPos < _aclNames.size())
if (ulPos < names.size())
{
_aclColorFields[ulPos] = Color(ucRed, ucGreen, ucBlue);
colorFields[ulPos] = Color(ucRed, ucGreen, ucBlue);
return true;
}
else
@@ -518,9 +445,9 @@ bool ColorLegend::setColor (unsigned long ulPos, unsigned long ulColor)
bool ColorLegend::setText (unsigned long ulPos, const std::string &rclName)
{
if (ulPos < _aclNames.size())
if (ulPos < names.size())
{
_aclNames[ulPos] = rclName;
names[ulPos] = rclName;
return true;
}
else