TPixel32 TGenericColorFunction::operator()(const TPixel32 &color) const
{
return TPixel32(tcrop(m_m[0] * color.r + m_c[0], 0.0, 255.0),
tcrop(m_m[1] * color.g + m_c[1], 0.0, 255.0),
tcrop(m_m[2] * color.b + m_c[2], 0.0, 255.0),
tcrop(m_m[3] * color.m + m_c[3], 0.0, 255.0));
}
SquareBuilder(int cellLx, int cellLy, double radius, int wrap)
: MaskCellBuilder<PIXEL, GRAY>(cellLx, cellLy, radius, wrap) {
// Build the mask corresponding to a square of passed radius
GRAY *pix, *pixRev, *line, *lineEnd, *lineRev;
this->m_mask = TRasterPT<GRAY>(cellLx, cellLy);
// For each pixel in the lower-left quadrant, fill in the corresponding mask
// value.
// The other ones are filled by mirroring.
int i, j;
double lxHalf = 0.5 * cellLx, lyHalf = 0.5 * cellLy;
int lxHalfI = tceil(lxHalf), lyHalfI = tceil(lyHalf);
double val, addValX = radius - lxHalf + 1, addValY = radius - lyHalf + 1;
for (i = 0; i < lyHalfI; ++i) {
line = this->m_mask->pixels(i),
lineRev = this->m_mask->pixels(cellLy - i - 1);
lineEnd = line + cellLx;
for (j = 0, pix = line, pixRev = lineEnd - 1; j < lxHalfI;
++j, ++pix, --pixRev) {
val = tcrop(addValX + i, 0.0, 1.0) * tcrop(addValY + j, 0.0, 1.0);
*pix = *pixRev = val * GRAY::maxChannelValue;
}
memcpy(lineRev, line, cellLx * sizeof(GRAY));
}
}
void ImageViewer::dragCompare(const QPoint &dp) {
if (m_compareSettings.m_dragCompareX)
m_compareSettings.m_compareX += ((double)dp.x()) / width();
else if (m_compareSettings.m_dragCompareY)
m_compareSettings.m_compareY -= ((double)dp.y()) / height();
m_compareSettings.m_compareX = tcrop(m_compareSettings.m_compareX, 0.0, 1.0);
m_compareSettings.m_compareY = tcrop(m_compareSettings.m_compareY, 0.0, 1.0);
update();
}
void TScanParam::update(const TScanParam &model) {
m_supported = model.m_supported;
m_min = model.m_min;
m_max = model.m_max;
m_def = model.m_def;
m_step = model.m_step;
m_value = tcrop(m_value, m_min, m_max);
}
double OnionSkinMask::getOnionSkinFade(int rowsDistance) {
if (rowsDistance == 0) return 0.9;
double fade =
MINFADE +
abs(rowsDistance) *
getIncrement(Preferences::instance()->getOnionPaperThickness());
return tcrop(fade, MINFADE, MAXFADE);
}
void TPalette::movePage(Page *page, int dstPageIndex) {
assert(page);
assert(page->m_palette == this);
dstPageIndex = tcrop(dstPageIndex, 0, getPageCount() - 1);
if (dstPageIndex == page->getIndex()) return;
m_pages.erase(m_pages.begin() + page->getIndex());
m_pages.insert(m_pages.begin() + dstPageIndex, page);
for (int i = 0; i < getPageCount(); i++) m_pages[i]->m_index = i;
assert(page->getIndex() == dstPageIndex);
}
void PlaneViewer::setViewZoom(double x, double y, double zoom) {
zoom = tcrop(zoom, m_zoomRange[0], m_zoomRange[1]);
double delta = zoom / m_aff.a11;
m_aff.a13 = x + delta * (m_aff.a13 - x);
m_aff.a23 = y + delta * (m_aff.a23 - y);
m_aff.a11 = m_aff.a22 = zoom;
update();
#ifdef PRINT_AFF
qDebug("zoom = %.4f; pos = %.4f, %.4f", m_aff.a11, m_aff.a13, m_aff.a23);
#endif
}
void blend(TToonzImageP ti, TRasterPT<PIXEL> rasOut,
const std::vector<BlendParam> ¶ms) {
assert(ti->getRaster()->getSize() == rasOut->getSize());
// Extract the interesting raster. It should be the savebox of passed cmap,
// plus - if
// some param has the 0 index as blending color - the intensity of that blend
// param.
unsigned int i, j;
TRect saveBox(ti->getSavebox());
int enlargement = 0;
for (i = 0; i < params.size(); ++i)
for (j = 0; j < params[i].colorsIndexes.size(); ++j)
if (params[i].colorsIndexes[j] == 0)
enlargement = std::max(enlargement, tceil(params[i].intensity));
saveBox = saveBox.enlarge(enlargement);
TRasterCM32P cmIn(ti->getRaster()->extract(saveBox));
TRasterPT<PIXEL> rasOutExtract = rasOut->extract(saveBox);
// Ensure that cmIn and rasOut have the same size
unsigned int lx = cmIn->getLx(), ly = cmIn->getLy();
// Build the pure colors infos
SelectionRaster selectionRaster(cmIn);
// Now, build a little group of BlurPatterns - and for each, one for passed
// param.
// A small number of patterns per param is needed to make the pattern look not
// ever the same.
const int blurPatternsPerParam = 10;
std::vector<BlurPatternContainer> blurGroup(params.size());
for (i = 0; i < params.size(); ++i) {
BlurPatternContainer &blurContainer = blurGroup[i];
blurContainer.reserve(blurPatternsPerParam);
for (j = 0; j < blurPatternsPerParam; ++j)
blurContainer.push_back(BlurPattern(
params[i].intensity, params[i].smoothness, params[i].stopAtCountour));
}
// Build the palette
TPalette *palette = ti->getPalette();
std::vector<TPixel32> paletteColors;
paletteColors.resize(palette->getStyleCount());
for (i = 0; i < paletteColors.size(); ++i)
paletteColors[i] = premultiply(palette->getStyle(i)->getAverageColor());
// Build the 4 auxiliary rasters for the blending procedure: they are ink /
// paint versus input / output in the blend.
// The output raster is reused to spare some memory - it should be, say, the
// inkLayer's second at the end of the overall
// blending procedure. It could be the first, without the necessity of
// clearing it before blending the layers, but things
// get more complicated when PIXEL is TPixel64...
RGBMRasterPair inkLayer, paintLayer;
TRaster32P rasOut32P_1(lx, ly, lx, (TPixel32 *)rasOut->getRawData(), false);
inkLayer.first = (params.size() % 2) ? rasOut32P_1 : TRaster32P(lx, ly);
inkLayer.second = (params.size() % 2) ? TRaster32P(lx, ly) : rasOut32P_1;
if (PIXEL::maxChannelValue >= TPixel64::maxChannelValue) {
TRaster32P rasOut32P_2(lx, ly, lx,
((TPixel32 *)rasOut->getRawData()) + lx * ly, false);
paintLayer.first = (params.size() % 2) ? rasOut32P_2 : TRaster32P(lx, ly);
paintLayer.second = (params.size() % 2) ? TRaster32P(lx, ly) : rasOut32P_2;
} else {
paintLayer.first = TRaster32P(lx, ly);
paintLayer.second = TRaster32P(lx, ly);
}
inkLayer.first->clear();
inkLayer.second->clear();
paintLayer.first->clear();
paintLayer.second->clear();
// Now, we have to perform the blur of each of the cm's pixels.
cmIn->lock();
rasOut->lock();
inkLayer.first->lock();
inkLayer.second->lock();
paintLayer.first->lock();
paintLayer.second->lock();
// Convert the initial cmIn to fullcolor ink - paint layers
buildLayers(cmIn, paletteColors, inkLayer.first, paintLayer.first);
// Perform the blend on separated ink - paint layers
for (i = 0; i < params.size(); ++i) {
if (params[i].colorsIndexes.size() == 0) continue;
selectionRaster.updateSelection(cmIn, params[i]);
doBlend(cmIn, inkLayer, paintLayer, selectionRaster, blurGroup[i]);
tswap(inkLayer.first, inkLayer.second);
tswap(paintLayer.first, paintLayer.second);
}
// Release the unnecessary rasters
inkLayer.second->unlock();
paintLayer.second->unlock();
inkLayer.second = TRaster32P();
paintLayer.second = TRaster32P();
// Clear rasOut - since it was reused to spare space...
rasOut->clear();
// Add the ink & paint layers on the output raster
double PIXELmaxChannelValue = PIXEL::maxChannelValue;
double toPIXELFactor =
PIXELmaxChannelValue / (double)TPixel32::maxChannelValue;
double inkFactor, paintFactor;
TPoint pos;
PIXEL *outPix, *outBegin = (PIXEL *)rasOutExtract->getRawData();
TPixelCM32 *cmPix, *cmBegin = (TPixelCM32 *)cmIn->getRawData();
int wrap = rasOutExtract->getWrap();
TPixel32 *inkPix = (TPixel32 *)inkLayer.first->getRawData();
TPixel32 *paintPix = (TPixel32 *)paintLayer.first->getRawData();
for (i = 0; i < ly; ++i) {
outPix = outBegin + wrap * i;
cmPix = cmBegin + wrap * i;
for (j = 0; j < lx; ++j, ++outPix, ++cmPix, ++inkPix, ++paintPix) {
getFactors(cmPix->getTone(), inkFactor, paintFactor);
outPix->r = tcrop(
toPIXELFactor * (inkFactor * inkPix->r + paintFactor * paintPix->r),
0.0, PIXELmaxChannelValue);
outPix->g = tcrop(
toPIXELFactor * (inkFactor * inkPix->g + paintFactor * paintPix->g),
0.0, PIXELmaxChannelValue);
outPix->b = tcrop(
toPIXELFactor * (inkFactor * inkPix->b + paintFactor * paintPix->b),
0.0, PIXELmaxChannelValue);
outPix->m = tcrop(
toPIXELFactor * (inkFactor * inkPix->m + paintFactor * paintPix->m),
0.0, PIXELmaxChannelValue);
}
}
inkLayer.first->unlock();
paintLayer.first->unlock();
cmIn->unlock();
rasOut->unlock();
// Destroy the auxiliary bitmaps
selectionRaster.destroy();
}
void TColorValue::setHsv(int h, int s, int v)
{
int i;
double p, q, t, f;
double hue, sat, value;
hue = h;
sat = 0.01 * s;
value = 0.01 * v;
assert(0 <= hue && hue <= 360);
assert(0 <= sat && sat <= 1);
assert(0 <= value && value <= 1);
if (sat == 0) {
m_r = m_g = m_b = value;
} else {
if (hue == 360)
hue = 0;
hue = hue / 60;
i = (int)hue;
f = hue - i;
p = tcrop(value * (1 - sat), 0., 1.);
q = tcrop(value * (1 - (sat * f)), 0., 1.);
t = tcrop(value * (1 - (sat * (1 - f))), 0., 1.);
switch (i) {
case 0:
m_r = value;
m_g = t;
m_b = p;
break;
case 1:
m_r = q;
m_g = value;
m_b = p;
break;
case 2:
m_r = p;
m_g = value;
m_b = t;
break;
case 3:
m_r = p;
m_g = q;
m_b = value;
break;
case 4:
m_r = t;
m_g = p;
m_b = value;
break;
case 5:
m_r = value;
m_g = p;
m_b = q;
break;
}
}
}
void TSceneProperties::setFieldGuideSize(int size)
{
assert(1 <= size && size <= 100);
m_fieldGuideSize = tcrop(size, 1, 100);
}
void TSceneProperties::setTlvSubsampling(int s)
{
assert(1 <= s && s <= 100);
m_tlvSubsampling = tcrop(s, 1, 100);
}
void TSceneProperties::setFullcolorSubsampling(int s)
{
assert(1 <= s && s <= 100);
m_fullcolorSubsampling = tcrop(s, 1, 100);
}
