KOKKOS_INLINE_FUNCTION
void operator()(const int index) const
{
const int kk = index % x;
const int jj = index / x;
if(jj >= halo_depth && jj < y-1 && kk >= halo_depth && kk < x-1)
{
kx(index) = rx*(w(index-1)+w(index)) /
(2.0*w(index-1)*w(index));
ky(index) = ry*(w(index-x)+w(index)) /
(2.0*w(index-x)*w(index));
}
}
void sobel(const imagev3* input, imagev3* output) {
imagev3 kx(3, 3);
imagev3 buffer(input->getWidth(), input->getHeight());
kx.set(0, 0, -la::v3::E)
.set(0, 2, -la::v3::E)
.set(2, 0, la::v3::E)
.set(2, 2, la::v3::E)
.set(0, 1, -la::v3::E * 2)
.set(2, 1, la::v3::E * 2);
convolve(input, &buffer, &kx);
imagev3 ky(3, 3);
ky.set(0, 0, -la::v3::E)
.set(2, 0, -la::v3::E)
.set(0, 2, la::v3::E)
.set(2, 2, la::v3::E)
.set(1, 0, -la::v3::E * 2)
.set(1, 2, la::v3::E * 2);
convolve(input, output, &ky);
binop(&buffer, output, output, imageop::com);
}
void
TrackerNodePrivate::computeTransformParamsFromTracksEnd(double refTime,
double maxFittingError,
const QList<TransformData>& results)
{
QList<TransformData> validResults;
for (QList<TransformData>::const_iterator it = results.begin(); it != results.end(); ++it) {
if (it->valid) {
validResults.push_back(*it);
}
}
KnobIntPtr smoothKnob = smoothTransform.lock();
int smoothTJitter, smoothRJitter, smoothSJitter;
smoothTJitter = smoothKnob->getValue(DimIdx(0));
smoothRJitter = smoothKnob->getValue(DimIdx(1));
smoothSJitter = smoothKnob->getValue(DimIdx(2));
KnobDoublePtr translationKnob = translate.lock();
KnobDoublePtr scaleKnob = scale.lock();
KnobDoublePtr rotationKnob = rotate.lock();
KnobDoublePtr fittingErrorKnob = fittingError.lock();
KnobStringPtr fittingWarningKnob = fittingErrorWarning.lock();
int halfTJitter = smoothTJitter / 2;
int halfRJitter = smoothRJitter / 2;
int halfSJitter = smoothSJitter / 2;
translationKnob->blockValueChanges();
scaleKnob->blockValueChanges();
rotationKnob->blockValueChanges();
fittingErrorKnob->blockValueChanges();
std::list<KnobIPtr> animatedKnobsChanged;
animatedKnobsChanged.push_back(translationKnob);
animatedKnobsChanged.push_back(scaleKnob);
animatedKnobsChanged.push_back(rotationKnob);
animatedKnobsChanged.push_back(fittingErrorKnob);
Curve tmpTXCurve, tmpTYCurve, tmpRotateCurve, tmpScaleCurve, tmpFittingErrorCurve;
bool mustShowFittingWarn = false;
for (QList<TransformData>::const_iterator itResults = validResults.begin(); itResults != validResults.end(); ++itResults) {
const TransformData& dataAtTime = *itResults;
{
KeyFrame kf(dataAtTime.time, dataAtTime.rms);
if (dataAtTime.rms >= maxFittingError) {
mustShowFittingWarn = true;
}
tmpFittingErrorCurve.setOrAddKeyframe(kf);
}
if (!dataAtTime.hasRotationAndScale) {
// no rotation or scale: simply extract the translation
Point translation;
if (smoothTJitter > 1) {
TranslateData avgT;
averageDataFunctor<QList<TransformData>::const_iterator, void, TranslateData>(validResults.begin(), validResults.end(), itResults, halfTJitter, 0, &avgT, 0);
translation.x = avgT.p.x;
translation.y = avgT.p.y;
} else {
translation.x = dataAtTime.translation.x;
translation.y = dataAtTime.translation.y;
}
{
KeyFrame kx(dataAtTime.time, translation.x);
KeyFrame ky(dataAtTime.time, translation.y);
tmpTXCurve.setOrAddKeyframe(kx);
tmpTYCurve.setOrAddKeyframe(ky);
}
} else {
double rot = 0;
if (smoothRJitter > 1) {
RotateData avgR;
averageDataFunctor<QList<TransformData>::const_iterator, void, RotateData>(validResults.begin(), validResults.end(), itResults, halfRJitter, 0, &avgR, 0);
rot = avgR.r;
} else {
rot = dataAtTime.rotation;
}
{
KeyFrame k(dataAtTime.time, rot);
tmpRotateCurve.setOrAddKeyframe(k);
}
double scale;
if (smoothSJitter > 1) {
ScaleData avgR;
averageDataFunctor<QList<TransformData>::const_iterator, void, ScaleData>(validResults.begin(), validResults.end(), itResults, halfSJitter, 0, &avgR, 0);
scale = avgR.s;
} else {
scale = dataAtTime.scale;
}
{
KeyFrame k(dataAtTime.time, scale);
tmpScaleCurve.setOrAddKeyframe(k);
}
Point translation;
if (smoothTJitter > 1) {
TranslateData avgT;
averageDataFunctor<QList<TransformData>::const_iterator, void, TranslateData>(validResults.begin(), validResults.end(), itResults, halfTJitter, 0, &avgT, 0);
translation.x = avgT.p.x;
translation.y = avgT.p.y;
} else {
translation.x = dataAtTime.translation.x;
translation.y = dataAtTime.translation.y;
}
{
KeyFrame kx(dataAtTime.time, translation.x);
KeyFrame ky(dataAtTime.time, translation.y);
tmpTXCurve.setOrAddKeyframe(kx);
tmpTYCurve.setOrAddKeyframe(ky);
}
}
} // for all samples
fittingWarningKnob->setSecret(!mustShowFittingWarn);
fittingErrorKnob->cloneCurve(ViewIdx(0), DimIdx(0), tmpFittingErrorCurve, 0 /*offset*/, 0 /*range*/);
translationKnob->cloneCurve(ViewIdx(0), DimIdx(0), tmpTXCurve, 0 /*offset*/, 0 /*range*/);
translationKnob->cloneCurve(ViewIdx(0), DimIdx(1), tmpTYCurve, 0 /*offset*/, 0 /*range*/);
rotationKnob->cloneCurve(ViewIdx(0), DimIdx(0), tmpRotateCurve, 0 /*offset*/, 0 /*range*/);
scaleKnob->cloneCurve(ViewIdx(0), DimIdx(0), tmpScaleCurve, 0 /*offset*/, 0 /*range*/);
scaleKnob->cloneCurve(ViewIdx(0), DimIdx(1), tmpScaleCurve, 0 /*offset*/, 0 /*range*/);
for (std::list<KnobIPtr>::iterator it = animatedKnobsChanged.begin(); it != animatedKnobsChanged.end(); ++it) {
(*it)->unblockValueChanges();
(*it)->evaluateValueChange(DimSpec::all(), TimeValue(refTime), ViewSetSpec::all(), eValueChangedReasonUserEdited);
}
endSolve();
} // TrackerNodePrivate::computeTransformParamsFromTracksEnd
void
TrackerNodePrivate::computeCornerParamsFromTracksEnd(double refTime,
double maxFittingError,
const QList<CornerPinData>& results)
{
// Make sure we get only valid results
QList<CornerPinData> validResults;
for (QList<CornerPinData>::const_iterator it = results.begin(); it != results.end(); ++it) {
if (it->valid) {
validResults.push_back(*it);
}
}
// Get all knobs that we are going to write to and block any value changes on them
KnobIntPtr smoothCornerPinKnob = smoothCornerPin.lock();
int smoothJitter = smoothCornerPinKnob->getValue();
int halfJitter = smoothJitter / 2;
KnobDoublePtr fittingErrorKnob = fittingError.lock();
KnobDoublePtr fromPointsKnob[4];
KnobDoublePtr toPointsKnob[4];
KnobBoolPtr enabledPointsKnob[4];
KnobStringPtr fittingWarningKnob = fittingErrorWarning.lock();
for (int i = 0; i < 4; ++i) {
fromPointsKnob[i] = fromPoints[i].lock();
toPointsKnob[i] = toPoints[i].lock();
enabledPointsKnob[i] = enableToPoint[i].lock();
}
std::list<KnobIPtr> animatedKnobsChanged;
fittingErrorKnob->blockValueChanges();
animatedKnobsChanged.push_back(fittingErrorKnob);
for (int i = 0; i < 4; ++i) {
toPointsKnob[i]->blockValueChanges();
animatedKnobsChanged.push_back(toPointsKnob[i]);
}
// Get reference corner pin
CornerPinPoints refFrom;
for (int c = 0; c < 4; ++c) {
refFrom.pts[c].x = fromPointsKnob[c]->getValueAtTime(TimeValue(refTime));
refFrom.pts[c].y = fromPointsKnob[c]->getValueAtTime(TimeValue(refTime), DimIdx(1));
}
// Create temporary curves and clone the toPoint internal curves at once because setValueAtTime will be slow since it emits
// signals to create keyframes in keyframeSet
Curve tmpToPointsCurveX[4], tmpToPointsCurveY[4];
Curve tmpFittingErrorCurve;
bool mustShowFittingWarn = false;
for (QList<CornerPinData>::const_iterator itResults = validResults.begin(); itResults != validResults.end(); ++itResults) {
const CornerPinData& dataAtTime = *itResults;
// Add the error to the curve and check if we need to turn on the RMS warning
{
KeyFrame kf(dataAtTime.time, dataAtTime.rms);
if (dataAtTime.rms >= maxFittingError) {
mustShowFittingWarn = true;
}
tmpFittingErrorCurve.setOrAddKeyframe(kf);
}
if (smoothJitter <= 1) {
for (int c = 0; c < 4; ++c) {
Point toPoint;
toPoint = TrackerHelper::applyHomography(refFrom.pts[c], dataAtTime.h);
KeyFrame kx(dataAtTime.time, toPoint.x);
KeyFrame ky(dataAtTime.time, toPoint.y);
tmpToPointsCurveX[c].setOrAddKeyframe(kx);
tmpToPointsCurveY[c].setOrAddKeyframe(ky);
//toPoints[c]->setValuesAtTime(dataAtTime[i].time, toPoint.x, toPoint.y, ViewSpec::all(), eValueChangedReasonUserEdited);
}
} else {
// Average to points before and after if using jitter
CornerPinPoints avgTos;
averageDataFunctor<QList<CornerPinData>::const_iterator, CornerPinPoints, CornerPinPoints>(validResults.begin(), validResults.end(), itResults, halfJitter, &refFrom, &avgTos, 0);
for (int c = 0; c < 4; ++c) {
KeyFrame kx(dataAtTime.time, avgTos.pts[c].x);
KeyFrame ky(dataAtTime.time, avgTos.pts[c].y);
tmpToPointsCurveX[c].setOrAddKeyframe(kx);
tmpToPointsCurveY[c].setOrAddKeyframe(ky);
}
} // use jitter
} // for each result
// If user wants a post-smooth, apply it
if (smoothJitter > 1) {
int halfSmoothJitter = smoothJitter / 2;
KeyFrameSet xSet[4], ySet[4];
KeyFrameSet newXSet[4], newYSet[4];
for (int c = 0; c < 4; ++c) {
xSet[c] = tmpToPointsCurveX[c].getKeyFrames_mt_safe();
ySet[c] = tmpToPointsCurveY[c].getKeyFrames_mt_safe();
}
for (int c = 0; c < 4; ++c) {
for (KeyFrameSet::const_iterator it = xSet[c].begin(); it != xSet[c].end(); ++it) {
double avg;
averageDataFunctor<KeyFrameSet::const_iterator, void, double>(xSet[c].begin(), xSet[c].end(), it, halfSmoothJitter, 0, &avg, 0);
KeyFrame k(*it);
k.setValue(avg);
newXSet[c].insert(k);
}
for (KeyFrameSet::const_iterator it = ySet[c].begin(); it != ySet[c].end(); ++it) {
double avg;
averageDataFunctor<KeyFrameSet::const_iterator, void, double>(ySet[c].begin(), ySet[c].end(), it, halfSmoothJitter, 0, &avg, 0);
KeyFrame k(*it);
k.setValue(avg);
newYSet[c].insert(k);
}
}
for (int c = 0; c < 4; ++c) {
tmpToPointsCurveX[c].setKeyframes(newXSet[c], true);
tmpToPointsCurveY[c].setKeyframes(newYSet[c], true);
}
}
fittingWarningKnob->setSecret(!mustShowFittingWarn);
fittingErrorKnob->cloneCurve(ViewIdx(0), DimIdx(0), tmpFittingErrorCurve, 0 /*offset*/, 0 /*range*/);
for (int c = 0; c < 4; ++c) {
toPointsKnob[c]->cloneCurve(ViewIdx(0), DimIdx(0), tmpToPointsCurveX[c], 0 /*offset*/, 0 /*range*/);
toPointsKnob[c]->cloneCurve(ViewIdx(0), DimIdx(1), tmpToPointsCurveY[c], 0 /*offset*/, 0 /*range*/);
}
for (std::list<KnobIPtr>::iterator it = animatedKnobsChanged.begin(); it != animatedKnobsChanged.end(); ++it) {
(*it)->unblockValueChanges();
(*it)->evaluateValueChange(DimSpec::all(), TimeValue(refTime), ViewSetSpec::all(), eValueChangedReasonUserEdited);
}
endSolve();
} // TrackerNodePrivate::computeCornerParamsFromTracksEnd
void test_fire() {
BSArenaKey ky(10, legend);
BSArenaPuzzle pz(10, legend);
BSArena::result r;
int c(0);
time_t st;
st = time(&st);
int error(-1);
// std::ifstream file("logic-demo.log");
std::ofstream file("logic-demo.log");
// std::streambuf* cout_sbuf = std::cout.rdbuf(); // save original sbuf
std::cout.rdbuf(file.rdbuf());
while(error == -1) {
file.seekp(0);
file << "OK";
ky.load_legend(legend);
ky.auto_setup();
pz.load_legend(legend);
pz.clean();
++c;
long dt = time(NULL) - st;
std::cerr << "=======" <<
" (count=" << c << "; dt=" << dt << ") " <<
"==========" << std::endl;
for (int i(0); i<1000; ++i) {
file << "\n\n=======" << i <<
" (count=" << c << "; dt=" << dt << ") " <<
"==========\n\n" << std::endl;
BSPoint p = pz.find_fire();
file << "======FIRE TO " << p <<
" (count=" << c << "; dt=" << dt << ") " <<
std::endl;
r = ky.apply_fire(p);
file << "======RESULT " << r <<
" (count=" << c << "; dt=" << dt << ") " <<
std::endl;
switch(r) {
case BSArena::r_milk: // мимо
break;
case BSArena::r_already_fired: // сюда уже стреляли
error = r;
break;
case BSArena::r_wasted_effort: // мимо, но вам и так должно быть известно, что здесь ничего нет
error = r;
break;
case BSArena::r_continue_in_that_direction: // ранен, продолжайте добивать
break;
case BSArena::r_drowned: // утонул
break;
case BSArena::r_game_over: // добит последний, игра окончена
break;
default:
error = r;
break;
}
if (error != -1) break;
pz.apply_result(p, r);
if (r == BSArena::r_game_over) break;
}
if (r != BSArena::r_game_over) {
file << "\n====== 1000 (!!!) ======\n";
break;
}
if (error != -1) {
file << "\n====== error(r) = " << error << " (!!!) ======\n";
break;
}
file << "DONE.\n\n\n";
}
file << "DONE AND EXIT (NORMAL / ERROR FOUND).\n\n\n";
}
Ord CustomRightHandSide::ord(Ord x, Ord y) const
{
return - kx(x,y) * dudx(x,y) - ky(x,y) * dudy(x,y) - k(x,y) * (dudxx(x,y) + dudyy(x,y));
}
double CustomRightHandSide::value(double x, double y) const
{
return - kx(x,y) * dudx(x,y) - ky(x,y) * dudy(x,y) - k(x,y) * (dudxx(x,y) + dudyy(x,y));
}
// Per OpenVX
// Implements the Sobel Image Filter k.
// This k produces two output planes (one can be omitted) in the x and y plane.
// The Sobel Operators Gx,Gy are defined as:
//
// -1 0 1 -1 -2 -1
// Gx = -2 0 2 Gy = 0 0 0
// 1 0 1 1 2 1
//
// https://www.khronos.org/registry/vx/specs/1.0/html/da/d4b/group__group__vision__function__sobel3x3.html
//
std::pair<Halide::Func, Halide::Func> sobel_3x3(Halide::Func input, bool grayscale) {
Halide::Func kx("kx"), ky("ky");
Halide::Func gradient_x("gradient_x"), gradient_y("gradient_y");
Halide::RDom r(-1,3,-1,3);
Halide::Var x,y,c;
kx(x,y) = 0;
kx(-1,-1) = -1;
kx(0,-1) = 0;
kx(1,-1) = 1;
kx(-1, 0) = -2;
kx(0, 0) = 0;
kx(1, 0) = 2;
kx(-1, 1) = -1;
kx(0, 1) = 0;
kx(1, 1) = 1;
if (grayscale)
gradient_x(x,y) = sum(input(x+r.x, y+r.y) * kx(r.x, r.y));
else
gradient_x(x,y,c) = sum(input(x+r.x, y+r.y, c) * kx(r.x, r.y));
ky(x,y) = 0;
ky(-1,-1) = -1;
ky(0,-1) = -2;
ky(1,-1) = -1;
ky(-1, 0) = 0;
ky(0, 0) = 0;
ky(1, 0) = 0;
ky(-1, 1) = 1;
ky(0, 1) = 2;
ky(1, 1) = 1;
if (grayscale)
gradient_y(x,y) = sum(input(x+r.x, y+r.y) * ky(r.x, r.y));
else
gradient_y(x,y,c) = sum(input(x+r.x, y+r.y, c) * ky(r.x, r.y));
std::pair<Halide::Func, Halide::Func> ret = std::make_pair(gradient_x, gradient_y);
return ret;
}
void graphik()
{
int gd=0, gm;
initgraph(&gd,&gm,"c:\\lang\\bgi");
cleardevice();
uuu[0]=y0;
yyy[0]=y0;
yyy[1]=kkk;
line(kx(-0.1),ky(0),kx(1.5),ky(0));
line(kx(0),ky(-0.1),kx(0),ky(1.5));
outtextxy(kx(0.01),ky(-0.01),"0");
circle(kx(0),ky(1),1);
circle(kx(1),ky(0),1);
outtextxy(kx(-0.02),ky(1),"1");
outtextxy(kx(1.01),ky(-0.01),"1");
float i=0;
int j=1,ind=0;
setcolor(11);
circle(kx(0),ky(uuu[0]),2);
moveto(kx(0),ky(yyy[0]));
while(i<=1){
rongekutt(i,H,yyy);
i=i+H;
ind++;
lineto(kx(i),ky(yyy[0]));
if(ind==int(0.2/H)){
ind=0;
uuu[j]=yyy[0];
circle(kx(i),ky(uuu[j]),2);
j=j+1;
}
}
outtextxy(450,50,"- graphik");
getch();
znach();
prhod(ccc,ddd);
obrhod(ccc,ddd,mmm);
setcolor(13);
outtextxy(450,60,"- spline");
i=0;
moveto(kx(i),ky(spline(i)));
while(i<=1){
lineto(kx(i),ky(spline(i)));
i=i+H;
}
getch();
closegraph();
}
