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();
}
