/**
* Compute only curve from selection data (averages,histograms buffer and selection buffer)
* @param clipSrc source of the plugin
* @param time current time
* @param renderScale current renderScale
*/
void OverlayData::computeCurveFromSelectionData( OFX::Clip* clipSrc, const OfxTime time, const OfxPointD& renderScale)
{
_isComputing = true;
resetCurvesFromSelectionData();
if( ! clipSrc->isConnected() )
{
_isComputing = false;
return;
}
boost::scoped_ptr<OFX::Image> src( clipSrc->fetchImage(_currentTime, clipSrc->getCanonicalRod(_currentTime)) ); //scoped pointer of current source clip
// Compatibility tests
if( !src.get() ) // source isn't accessible
{
_isComputing = false;
std::cout << "src is not accessible" << std::endl;
return;
}
if( src->getRowBytes() == 0 )//if source is wrong
{
BOOST_THROW_EXCEPTION( exception::WrongRowBytes() );
}
OfxRectI srcPixelRod = clipSrc->getPixelRod( _currentTime, renderScale ); //get current RoD
if( (clipSrc->getPixelDepth() != OFX::eBitDepthFloat) ||
(!clipSrc->getPixelComponents()) )
{
BOOST_THROW_EXCEPTION( exception::Unsupported() << exception::user() + "Can't compute histogram data with the actual input clip format." );
return;
}
if( srcPixelRod != src->getBounds() )
{
// the host does bad things !
// remove overlay... but do not crash.
TUTTLE_COUT_WARNING( "Image RoD and image bounds are not the same (rod=" << srcPixelRod << " , bounds:" << src->getBounds() << ")." );
return;
}
// Compute if source is OK
SView srcView = tuttle::plugin::getView<SView>( src.get(), srcPixelRod ); // get current view from source clip
OfxPointI imgSize;
imgSize.x = srcView.width();
imgSize.y = srcView.height();
if( isImageSizeModified( imgSize ) )
{
clearAll( imgSize );
}
//Compute histogram buffer
Pixel_compute_histograms funct( _imgBool,_curveFromSelection, true); //functor declaration
terry::algorithm::transform_pixels( srcView, funct ); //(USED functor reference)
this->correctHistogramBufferData(_curveFromSelection); //correct Histogram data to make up for discretization (average)
}
/*
* Copy RGB channels of the clip source into a buffer
*/
int CloudPointData::generateAllPointsVBOData(SView srcView)
{
//compute buffer size
int size = (int)(srcView.height()*srcView.width()); //return size : full image here
//copy full image into buffer
Pixel_copy funct( _imgCopy ); //functor declaration
//treatment
terry::algorithm::transform_pixels( srcView, funct ); //transform pixel did with functor reference
return size;
}
/*
* Copy discretization RGB channels of the clip source into a buffer
*/
int CloudPointData::generateDiscretizedVBOData(SView srcView, const int& discretizationStep )
{
//compute buffer size
int size = (int)(srcView.height()*srcView.width()); //return size : full image here
//Create and use functor to get discretize data (functor with template)
Pixel_copy_discretization<SPixel> funct(_imgCopy,discretizationStep); //functor declaration
terry::algorithm::transform_pixels( srcView, funct); //with functor reference
funct.convertSetDataToVectorData(); //copy functor data to _imgCopy data
size = _imgCopy.size(); //change size
return size;
}
/**
* Update selection areas buffer to selection histograms overlay
* @param args needed to have current time
*/
void OverlayData::computeHistogramBufferData( HistogramBufferData& data, SView& srcView, const OfxTime time, const bool isSelection)
{
data._step = _vNbStep; //prepare HistogramBuffer structure
BOOST_ASSERT( _imgBool.shape()[0] == _size.y );
BOOST_ASSERT( _imgBool.shape()[1] == _size.x );
BOOST_ASSERT( srcView.width() == _size.x );
BOOST_ASSERT( srcView.height() == _size.y );
Pixel_compute_histograms funct( _imgBool, data, isSelection ); //functor declaration
terry::algorithm::transform_pixels( srcView, funct ); //(USED functor reference)
//boost::gil::for_each_pixel(srcView, funct); (NOT USED)
this->correctHistogramBufferData(data); //correct Histogram data to make up for discretization (average)
}
pixel_locator_gradientLocalMaxima_t( const SView& src )
: _loc_ref(src.xy_at(0,0))
, LT(_loc_ref.cache_location(-1,-1))
, CT(_loc_ref.cache_location( 0,-1))
, RT(_loc_ref.cache_location( 1,-1))
, LC(_loc_ref.cache_location(-1, 0))
, RC(_loc_ref.cache_location( 1, 0))
, LB(_loc_ref.cache_location(-1, 1))
, CB(_loc_ref.cache_location( 0, 1))
, RB(_loc_ref.cache_location( 1, 1))
{
using namespace terry::numeric;
pixel_assigns_min( _black );
}
pixel_locator_thinning_t(const SView& src, const bool* lut)
: _lut(lut)
, _loc_ref(src.xy_at(0, 0))
, LT(_loc_ref.cache_location(-1, -1))
, CT(_loc_ref.cache_location(0, -1))
, RT(_loc_ref.cache_location(1, -1))
, LC(_loc_ref.cache_location(-1, 0))
, RC(_loc_ref.cache_location(1, 0))
, LB(_loc_ref.cache_location(-1, 1))
, CB(_loc_ref.cache_location(0, 1))
, RB(_loc_ref.cache_location(1, 1))
{
using namespace terry::numeric;
pixel_assigns_max(_sWhite);
pixel_assigns_min(_dBlack);
pixel_assigns_max(_dWhite);
}
ExecStatus
ElementUnion<SView,RView>::propagate(Space& home, const ModEventDelta&) {
Region r(home);
int n = iv.size();
bool loopVar;
do {
loopVar = false;
// Cache the upper bound iterator, as we have to
// modify the upper bound while iterating
LubRanges<RView> x1ub(x1);
Iter::Ranges::Cache<LubRanges<RView> > x1ubc(r,x1ub);
Iter::Ranges::ToValues<Iter::Ranges::Cache<LubRanges<RView> > >
vx1ub(x1ubc);
GlbRanges<RView> x1lb(x1);
Iter::Ranges::Cache<GlbRanges<RView> > x1lbc(r,x1lb);
Iter::Ranges::ToValues<Iter::Ranges::Cache<GlbRanges<RView> > >
vx1(x1lbc);
// In the first iteration, compute in before[i] the union
// of all the upper bounds of the x_i. At the same time,
// exclude inconsistent x_i from x1 and remove them from
// the list, cancel their dependencies.
GLBndSet sofarBefore(home);
LUBndSet selectedInter(home, IntSet (Limits::min,
Limits::max));
GLBndSet* before =
static_cast<GLBndSet*>(r.ralloc(sizeof(GLBndSet)*n));
int j = 0;
int i = 0;
unsigned int maxCard = 0;
unsigned int minCard = Limits::card;
while ( vx1ub() ) {
// Remove vars at indices not in the upper bound
if (iv[i].idx < vx1ub.val()) {
iv[i].view.cancel(home,*this, PC_SET_ANY);
++i;
continue;
}
assert(iv[i].idx == vx1ub.val());
iv[j] = iv[i];
SView candidate = iv[j].view;
int candidateInd = iv[j].idx;
// inter = glb(candidate) & complement(lub(x0))
GlbRanges<SView> candlb(candidate);
LubRanges<SView> x0ub(x0);
Iter::Ranges::Diff<GlbRanges<SView>,
LubRanges<SView> > diff(candlb, x0ub);
bool selectSingleInconsistent = false;
if (x1.cardMax() <= 1) {
GlbRanges<SView> x0lb(x0);
LubRanges<SView> candub(candidate);
Iter::Ranges::Diff<GlbRanges<SView>,
LubRanges<SView> > diff2(x0lb, candub);
selectSingleInconsistent = diff2() || candidate.cardMax() < x0.cardMin();
}
// exclude inconsistent x_i
// an x_i is inconsistent if
// * at most one x_i can be selected and there are
// elements in x_0 that can't be in x_i
// (selectSingleInconsistent)
// * its min cardinality is greater than maxCard of x0
// * inter is not empty (there are elements in x_i
// that can't be in x_0)
if (selectSingleInconsistent ||
candidate.cardMin() > x0.cardMax() ||
diff()) {
ModEvent me = (x1.exclude(home,candidateInd));
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
iv[j].view.cancel(home,*this, PC_SET_ANY);
++i;
++vx1ub;
continue;
} else {
// if x_i is consistent, check whether we know
// that its index is in x1
if (vx1() && vx1.val()==candidateInd) {
// x0 >= candidate, candidate <= x0
GlbRanges<SView> candlb(candidate);
ModEvent me = x0.includeI(home,candlb);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
LubRanges<SView> x0ub(x0);
me = candidate.intersectI(home,x0ub);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
++vx1;
}
new (&before[j]) GLBndSet(home);
before[j].update(home,sofarBefore);
LubRanges<SView> cub(candidate);
sofarBefore.includeI(home,cub);
GlbRanges<SView> clb(candidate);
selectedInter.intersectI(home,clb);
maxCard = std::max(maxCard, candidate.cardMax());
minCard = std::min(minCard, candidate.cardMin());
}
++vx1ub;
++i; ++j;
}
// cancel the variables with index greater than
// max of lub(x1)
for (int k=i; k<n; k++) {
iv[k].view.cancel(home,*this, PC_SET_ANY);
}
n = j;
iv.size(n);
if (x1.cardMax()==0) {
// Selector is empty, hence the result must be empty
{
GECODE_ME_CHECK(x0.cardMax(home,0));
}
for (int i=n; i--;)
before[i].dispose(home);
return home.ES_SUBSUMED(*this);
}
if (x1.cardMin() > 0) {
// Selector is not empty, hence the intersection of the
// possibly selected lower bounds is contained in x0
BndSetRanges si(selectedInter);
ModEvent me = x0.includeI(home, si);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
me = x0.cardMin(home, minCard);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
}
selectedInter.dispose(home);
if (x1.cardMax() <= 1) {
ModEvent me = x0.cardMax(home, maxCard);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
}
{
// x0 <= sofarBefore
BndSetRanges sfB(sofarBefore);
ModEvent me = x0.intersectI(home,sfB);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
}
sofarBefore.dispose(home);
GLBndSet sofarAfter(home);
// In the second iteration, this time backwards, compute
// sofarAfter as the union of all lub(x_j) with j>i
for (int i=n; i--;) {
// TODO: check for size of universe here?
// if (sofarAfter.size() == 0) break;
// extra = inter(before[i], sofarAfter) - lub(x0)
BndSetRanges b(before[i]);
BndSetRanges s(sofarAfter);
GlbRanges<SView> x0lb(x0);
Iter::Ranges::Union<BndSetRanges, BndSetRanges> inter(b,s);
Iter::Ranges::Diff<GlbRanges<SView>,
Iter::Ranges::Union<BndSetRanges,BndSetRanges> > diff(x0lb, inter);
if (diff()) {
ModEvent me = (x1.include(home,iv[i].idx));
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
// candidate != extra
me = iv[i].view.includeI(home,diff);
loopVar |= me_modified(me);
GECODE_ME_CHECK(me);
}
LubRanges<SView> iviub(iv[i].view);
sofarAfter.includeI(home,iviub);
before[i].dispose(home);
}
sofarAfter.dispose(home);
} while (loopVar);
// Test whether we determined x1 without determining x0
if (x1.assigned() && !x0.assigned()) {
int ubsize = static_cast<int>(x1.lubSize());
if (ubsize > 2) {
assert(ubsize==n);
ViewArray<SView> is(home,ubsize);
for (int i=n; i--;)
is[i]=iv[i].view;
GECODE_REWRITE(*this,(RelOp::UnionN<SView, SView>
::post(home(*this),is,x0)));
} else if (ubsize == 2) {
assert(n==2);
SView a = iv[0].view;
SView b = iv[1].view;
GECODE_REWRITE(*this,(RelOp::Union<SView, SView, SView>
::post(home(*this),a,b,x0)));
} else if (ubsize == 1) {
assert(n==1);
GECODE_REWRITE(*this,(Rel::Eq<SView,SView>::post(home(*this),x0,iv[0].view)));
} else {
GECODE_ME_CHECK(x0.cardMax(home, 0));
return home.ES_SUBSUMED(*this);
}
}
bool allAssigned = true;
for (int i=iv.size(); i--;) {
if (!iv[i].view.assigned()) {
allAssigned = false;
break;
}
}
if (x0.assigned() && x1.assigned() && allAssigned) {
return home.ES_SUBSUMED(*this);
}
return ES_FIX;
}
/**
* Compute full data (averages,histograms buffer and selection buffer)
* @param clipSrc source of the plugin
* @param time current time
* @param renderScale current renderScale
*/
void OverlayData::computeFullData( OFX::Clip* clipSrc, const OfxTime time, const OfxPointD& renderScale, const bool selectionOnly )
{
_isComputing = true;
resetHistogramData();
resetHistogramSelectionData();
if( ! clipSrc->isConnected() )
{
_isComputing = false;
return;
}
//TUTTLE_TCOUT_INFOS;
//TUTTLE_TCOUT_VAR( "computeHistogramBufferData - fetchImage " << time );
boost::scoped_ptr<OFX::Image> src( clipSrc->fetchImage(time, clipSrc->getCanonicalRod(time)) ); //scoped pointer of current source clip
//TUTTLE_TCOUT_INFOS;
//TUTTLE_TCOUT_VAR( clipSrc->getPixelRod(time, renderScale) );
//TUTTLE_TCOUT_VAR( clipSrc->getCanonicalRod(time, renderScale) );
// Compatibility tests
if( !src.get() ) // source isn't accessible
{
_isComputing = false;
std::cout << "src is not accessible" << std::endl;
return;
}
// TUTTLE_TCOUT_VAR( src->getBounds() );
// TUTTLE_TCOUT_VAR( src->getRegionOfDefinition() );
if( src->getRowBytes() == 0 )//if source is wrong
{
BOOST_THROW_EXCEPTION( exception::WrongRowBytes() );
}
OfxRectI srcPixelRod = clipSrc->getPixelRod( time, renderScale ); //get current RoD
if( (clipSrc->getPixelDepth() != OFX::eBitDepthFloat) ||
(!clipSrc->getPixelComponents()) )
{
BOOST_THROW_EXCEPTION( exception::Unsupported() << exception::user() + "Can't compute histogram data with the actual input clip format." );
return;
}
// TUTTLE_TCOUT_INFOS;
// BOOST_ASSERT( srcPixelRod == src->getBounds() );
if( srcPixelRod != src->getBounds() )
{
// the host does bad things !
// remove overlay... but do not crash.
TUTTLE_COUT_WARNING( "Image RoD and image bounds are not the same (rod=" << srcPixelRod << " , bounds:" << src->getBounds() << ")." );
return;
}
// BOOST_ASSERT( srcPixelRod.x1 == src->getBounds().x1 );
// BOOST_ASSERT( srcPixelRod.y1 == src->getBounds().y1 );
// BOOST_ASSERT( srcPixelRod.x2 == src->getBounds().x2 );
// BOOST_ASSERT( srcPixelRod.y2 == src->getBounds().y2 );
// Compute if source is OK
SView srcView = tuttle::plugin::getView<SView>( src.get(), srcPixelRod ); // get current view from source clip
OfxPointI imgSize;
imgSize.x = srcView.width();
imgSize.y = srcView.height();
// TUTTLE_TCOUT_INFOS;
if( isImageSizeModified( imgSize ) )
{
//TUTTLE_TCOUT_INFOS;
clearAll( imgSize );
}
//TUTTLE_TCOUT_INFOS;
//Compute histogram buffer
this->computeHistogramBufferData( _data, srcView, time);
//TUTTLE_TCOUT_INFOS;
//Compute selection histogram buffer
this->computeHistogramBufferData( _selectionData, srcView, time, true );
//TUTTLE_TCOUT_INFOS;
//Compute averages
this->computeAverages();
_isComputing = false;
_currentTime = time;
//TUTTLE_TCOUT_INFOS;
}