void ThisClass::ProcessCPU(int y, int x, int r, ChannelMask channels, Row& row) {
Channel rgb_chan[3];
rgb_chan[0] = Chan_Red;
rgb_chan[1] = Chan_Green;
rgb_chan[2] = Chan_Blue;
// Must call get before initializing any pointers
row.get(input0(), y, x, r, channels);
// Copy all other channels through unchanged
ChannelSet copy_mask = channels - Mask_RGB - k_spill_matte_channel_;
row.pre_copy(row, copy_mask);
row.copy(row, copy_mask, x, r);
Row m_row(x, r);
if (input(iMatte) != nullptr) { m_row.get(*input(iMatte), y, x, r, Mask_Alpha); }
float rgb[3] = {0, 0, 0};
afx::ReadOnlyPixel in_px(3);
afx::Pixel out_px(3);
for (int i = 0; i < 3; i++) {
in_px.SetPtr(row[rgb_chan[i]] + x, i);// Set const in pointers RGB
out_px.SetPtr(row.writable(rgb_chan[i]) + x, i); // Set out pointers RGB
}
const float* m_ptr = nullptr;
if (input(iMatte) != nullptr) { m_ptr = m_row[Chan_Alpha] + x; }
for (int x0 = x; x0 < r; ++x0) { // Loop through pixels in row
float suppression_matte = 0.0f;
float m = 1.0f;
if (input(iMatte) != nullptr) { m = *m_ptr; }
for (int i = 0; i < 3; i++) { rgb[i] = in_px.GetVal(i); }
hue_shifter_.Rotate(rgb); //Shift hue so mean hue is 1/3 on hue scale
float suppression = k_amount_ * m * afx::SpillSupression(rgb, k_algorithm_); //Calculate suppression
rgb[1] -= suppression;
hue_shifter_inv_.Rotate(rgb);
for (int i = 0; i < 3; i++) { rgb[i] = fmaxf(rgb[i], 0.0f); }
suppression_matte = clamp(suppression / ref_suppression_, 0.0f, 1.0f);
for (int i = 0; i < 3; i++) {
out_px[i] = rgb[i];
}
foreach (z, k_spill_matte_channel_) { *(row.writable(z) + x0) = suppression_matte; }
in_px++;
out_px++;
if (input(iMatte) != nullptr) { m_ptr++; }
}
}
void LpSub::constraint2row(
ArrayBuffer<Constraint*> &cons,
ArrayBuffer<Row*> &rows)
{
int conNnz; //!< number of nonzero elements in constraint
Row rowBuf(master_, sub_->nVar()); //!< dummy to generate row
Row *row; //!< pointer to the new row
const int nCons = cons.size();
for (int c = 0; c < nCons; c++) {
conNnz = cons[c]->genRow(sub_->actVar(), rowBuf);
row = new Row(master_, conNnz);
row->copy(rowBuf);
rows.push(row);
rowBuf.clear();
}
}
void engine(int y, int xx, int r, ChannelMask channels, Row& out)
{
unsigned int imageSize =
static_cast<unsigned int> (info().format().width()
* info().format().height());
// fill up the output image from the buffer
if (m_buffer.size() == imageSize)
{
float *rOut = out.writable(Chan_Red) + xx;
float *gOut = out.writable(Chan_Green) + xx;
float *bOut = out.writable(Chan_Blue) + xx;
float *aOut = out.writable(Chan_Alpha) + xx;
const float *END = rOut + (r - xx);
unsigned int xxx = static_cast<unsigned int> (xx);
unsigned int yyy = static_cast<unsigned int> (y);
while (rOut < END)
{
*rOut = m_buffer.get(xxx, yyy).r;
*gOut = m_buffer.get(xxx, yyy).g;
*bOut = m_buffer.get(xxx, yyy).b;
*aOut = m_buffer.get(xxx, yyy).a;
++rOut;
++gOut;
++bOut;
++aOut;
++xxx;
}
}
else
{
Row input(xx, r);
input0().get(y, xx, r, Mask_All, input);
out.copy(input, Mask_All, xx, r);
}
}
// Called on each scanline
void NukeCtlIop::pixel_engine(const Row& in, int y, int x, int r, ChannelMask channels, Row& out) {
if (transform != NULL)
{
try {
transform->execute(in, x, r, out);
}
catch (const BaseExc& e) {
error("Could not execute CTL argument transform: %s", e.what());
}
catch (const exception& e) {
error("Could not execute CTL argument transform: %s", e.what());
}
catch (...) // Something wicked this way comes
{
error("Could not execute CTL argument transform");
}
}
else
{
out.copy(in, channels, x, r);
}
}