template<class _t, class _rt, class _it> _t rect<_t, _rt, _it>::width() {
adjust_to_concept();
return x1() - x0() + 1;
}
vector<double> CNelderMead::NelderMeadFunction(double (*f)(vector<double>, RMSEinputs rmsein), NMsettings nmset, vector<vector<double> > x)
{
int NumIters = 0;
int i,j;
double MaxIters = nmset.MaxIters;
double tolerance = nmset.tolerance;
int N = nmset.N;
RMSEinputs rmsein = nmset.RMSEinp;
double S = rmsein.S;
double T = rmsein.T;
double r = rmsein.r;
// Value of the function at the vertices
vector<vector<double> > F(N+1, vector<double>(2));
// Step 0. Ordering and Best and Worst points
// Order according to the functional values, compute the best and worst points
step0:
NumIters += 1;
for (j=0; j<=N; j++){
vector<double> z(N, 0.0); // Create vector to contain
for (i=0; i<=N-1; i++)
z[i] = x[i][j];
F[j][0] = f(z,rmsein); // Function values
F[j][1] = j; // Original index positions
}
sort(F.begin(), F.end());
// New vertices order first N best initial vectors and
// last (N+1)st vertice is the worst vector
// y is the matrix of vertices, ordered so that the worst vertice is last
vector<vector<double> > y(N, vector<double>(N+1));
for (j=0; j<=N; j++)
for (i=0; i<=N-1; i++)
y[i][j] = x[i][F[j][1]];
// First best vector y(1) and function value f1
vector<double> x1(N, 0.0); for (i=0; i<=N-1; i++) x1[i] = y[i][0];
double f1 = f(x1,rmsein);
// Last best vector y(N) and function value fn
vector<double> xn(N, 0.0); for (i=0; i<=N-1; i++) xn[i] = y[i][N-1];
double fn = f(xn,rmsein);
// Worst vector y(N+1) and function value fn1
vector<double> xn1(N, 0.0); for (i=0; i<=N-1; i++) xn1[i] = y[i][N];
double fn1 = f(xn1,rmsein);
// z is the first N vectors from y, excludes the worst y(N+1)
vector<vector<double> > z(N, vector<double>(N));
for (j=0; j<=N-1; j++)
for (i=0; i<=N-1; i++)
z[i][j] = y[i][j];
// Mean of best N values and function value fm
vector<double> xm(N, 0.0); xm = CNelderMead::VMean(z,N);
double fm = f(xm,rmsein);
// Reflection point xr and function fr
vector<double> xr(N, 0.0); xr = CNelderMead::VSub(VAdd(xm, xm), xn1);
double fr = f(xr,rmsein);
// Expansion point xe and function fe
vector<double> xe(N, 0.0); xe = CNelderMead::VSub(VAdd(xr, xr), xm);
double fe = f(xe,rmsein);
// Outside contraction point and function foc
vector<double> xoc(N, 0.0); xoc = CNelderMead::VAdd(CNelderMead::VMult(xr, 0.5), VMult(xm, 0.5));
double foc = f(xoc,rmsein);
// Inside contraction point and function foc
vector<double> xic(N, 0.0); xic = CNelderMead::VAdd(CNelderMead::VMult(xm, 0.5), CNelderMead::VMult(xn1, 0.5));
double fic = f(xic,rmsein);
while ((NumIters <= MaxIters) && (abs(f1-fn1) >= tolerance))
{
// Step 1. Reflection Rule
if ((f1<=fr) && (fr<fn)) {
for (j=0; j<=N-1; j++)
for (i=0; i<=N-1; i++)
x[i][j] = y[i][j];
for (i=0; i<=N-1; i++)
x[i][N] = xr[i];
goto step0;
}
// Step 2. Expansion Rule
if (fr<f1) {
for (j=0; j<=N-1; j++) {
for (i=0; i<=N-1; i++) x[i][j] = y[i][j]; }
if (fe<fr)
for (i=0; i<=N-1; i++) x[i][N] = xe[i];
else
for (i=0; i<=N-1; i++) x[i][N] = xr[i];
goto step0;
}
// Step 3. Outside contraction Rule
if ((fn<=fr) && (fr<fn1) && (foc<=fr)) {
for (j=0; j<=N-1; j++) {
for (i=0; i<=N-1; i++) x[i][j] = y[i][j]; }
for (i=0; i<=N-1; i++) x[i][N] = xoc[i];
goto step0;
}
// Step 4. Inside contraction Rule
if ((fr>=fn1) && (fic<fn1)) {
for (j=0; j<=N-1; j++) {
for (i=0; i<=N-1; i++) x[i][j] = y[i][j]; }
for (i=0; i<=N-1; i++) x[i][N] = xic[i];
goto step0;
}
// Step 5. Shrink Step
for (i=0; i<=N-1; i++)
x[i][0] = y[i][0];
for (i=0; i<=N-1; i++) {
for (j=1; j<=N; j++)
x[i][j] = 0.5*(y[i][j] + x[i][0]);
}
goto step0;
}
// Output component
// Return N parameter values, value of objective function, and number of iterations
vector<double> out(N+2);
for (i=0; i<=N-1; i++)
out[i] = x1[i];
out[N] = f1;
out[N+1] = NumIters;
return out;
}
// Private methods
// determine the slave/master pair in contact, and setup Vectors (N,T1,T2)
int ZeroLengthInterface2D::contactDetect(int s, int m1, int m2, int stage)
{
//+--------------+-----------------+----------------+----------------+---------------+
// NOTES: some methods to get displacements from nodes
//+--------------+-----------------+----------------+----------------+---------------+
// getDisp() : get commit(k-1) disp, will be commit(k) after commit
// getTrialDisp(): get Trial(k) disp
// getIncrDisp(): get Trial(k)-Commit(k-1), will be 0 after commit
// getIncrDeltaDisp(): get Trial(k)-Trial(k-1), will be 0 after commit
//+--------------+-----------------+----------------+----------------+--------------
////////////////////////////// for transient gap ///////////////////////////////////
// DEFINE:
// gap = (U_master-U_slave) / dot(ContactNormal),
// defines overlapped normal distance, always keep positive (+) when contacted
///*
// get current position and after trial displacement for (slave, master1, master2) nodes
int i;
const Vector &xs = nodePointers[s]->getCrds();
const Vector &uxs = nodePointers[s]->getTrialDisp();
const Vector &x1 = nodePointers[m1]->getCrds();
const Vector &ux1= nodePointers[m1]->getTrialDisp();
const Vector &x2 = nodePointers[m2]->getCrds();
const Vector &ux2= nodePointers[m2]->getTrialDisp();
Vector trial_slave(2), trial_master1(2), trial_master2(2);
for (i = 0; i < 2; i++) {
trial_slave(i) = xs(i) + uxs(i);
trial_master1(i) = x1(i) + ux1(i);
trial_master2(i) = x2(i) + ux2(i);
//opserr << "trial_slave: " << trial_slave(i) << "\n";
//opserr << "trial_master1: " << trial_master1(i) << "\n";
//opserr << "trial_master2: " << trial_master2(i) << "\n";
}
// calculate normal gap for contact
Vector diff(2);
Vector ContactTangent(2);
for (i = 0; i < 2; i++) {
diff(i) = trial_master2(i) - trial_master1(i);
//opserr << "diff: " << diff(i) << "\n";
}
double L = diff.Norm();
// tangent vector
for (i = 0; i < 2; i++) ContactTangent(i) = (1/L) * (trial_master2(i) - trial_master1(i));
// normal vector
ContactNormal(0) = - ContactTangent(1);
ContactNormal(1) = ContactTangent(0);
normal_gap(s) = 0;
double alpha = 0;
double alpha_bar = 0;
for (i = 0; i < 2; i++) {
alpha += (1/L) * (trial_slave(i) - trial_master1(i)) * ContactTangent(i);
normal_gap(s) += (trial_slave(i) - trial_master1(i)) * ContactNormal(i);
diff(i) = x2(i) - x1(i);
}
double gapgap = normal_gap(s);
double L_bar = diff.Norm();
for (i = 0; i < 2; i++) alpha_bar += (1/L_bar) * (xs(i) - x1(i)) * ContactTangent(i);
shear_gap(s) = (alpha - alpha_bar) * L_bar;
/*
/////////////////////////////// for transient gap ///////////////////////////////
// we have another way to define the gap, can replace previous code block if want
////////////////////////////// for dynamic gap //////////////////////////////////
const Vector // get current trial incremental position
&U_slave = nodePointers[0]->getCrds() + nodePointers[0]->getIncrDisp();
const Vector
&U_master= nodePointers[1]->getCrds() + nodePointers[1]->getIncrDisp();
gap=0;
int i;
for (i=0; i<2; i++){
gap += (U_master(i)-U_slave(i))* ContactNormal(i);
}
gap+=gap_n;
///////////////// for dynamic gap //////////////////////
*/
// stage = 0 means searching slave nodes against master segments
// stage = 1 means searching master nodes against slave segments
if ((stage == 0 && normal_gap(s) >= 0 && alpha > 0 && alpha < 1) ||
(stage == 1 && normal_gap(s) >= 0 && alpha >= 0 && alpha <= 1)) { // in contact
N(0) = ContactNormal(0);
N(1) = ContactNormal(1);
N(2) = -(1 - alpha) * N(0);
N(3) = -(1 - alpha) * N(1);
N(4) = -(alpha) * N(0);
N(5) = -(alpha) * N(1);
T(0) = ContactTangent(0);
T(1) = ContactTangent(1);
T(2) = -(1-alpha) * T(0);
T(3) = -(1-alpha) * T(1);
T(4) = -(alpha) * T(0);
T(5) = -(alpha) * T(1);
return 1;
} else {
return 0; // Not in contact
}
}
long LatticeSolve(vec_ZZ& x, const mat_ZZ& A, const vec_ZZ& y, long reduce)
{
long n = A.NumRows();
long m = A.NumCols();
if (y.length() != m)
Error("LatticeSolve: dimension mismatch");
if (reduce < 0 || reduce > 2)
Error("LatticeSolve: bad reduce parameter");
if (IsZero(y)) {
x.SetLength(n);
clear(x);
return 1;
}
mat_ZZ A1, U1;
ZZ det2;
long im_rank, ker_rank;
A1 = A;
im_rank = image(det2, A1, U1);
ker_rank = n - im_rank;
mat_ZZ A2, U2;
long new_rank;
long i;
A2.SetDims(im_rank + 1, m);
for (i = 1; i <= im_rank; i++)
A2(i) = A1(ker_rank + i);
A2(im_rank + 1) = y;
new_rank = image(det2, A2, U2);
if (new_rank != im_rank ||
(U2(1)(im_rank+1) != 1 && U2(1)(im_rank+1) != -1))
return 0;
vec_ZZ x1;
x1.SetLength(im_rank);
for (i = 1; i <= im_rank; i++)
x1(i) = U2(1)(i);
if (U2(1)(im_rank+1) == 1)
negate(x1, x1);
vec_ZZ x2, tmp;
x2.SetLength(n);
clear(x2);
tmp.SetLength(n);
for (i = 1; i <= im_rank; i++) {
mul(tmp, U1(ker_rank+i), x1(i));
add(x2, x2, tmp);
}
if (reduce == 0) {
x = x2;
return 1;
}
else if (reduce == 1) {
U1.SetDims(ker_rank+1, n);
U1(ker_rank+1) = x2;
image(det2, U1);
x = U1(ker_rank + 1);
return 1;
}
else if (reduce == 2) {
U1.SetDims(ker_rank, n);
LLL(det2, U1);
U1.SetDims(ker_rank+1, n);
U1(ker_rank+1) = x2;
image(det2, U1);
x = U1(ker_rank + 1);
return 1;
}
return 0;
}
void benchmark_sort(
const vex::Context &ctx, vex::profiler<> &prof
)
{
const size_t N = 16 * 1024 * 1024;
const size_t M = 16;
typedef typename std::conditional<
std::is_same<float, real>::value, cl_uint, cl_ulong
>::type key_type;
std::default_random_engine rng( std::rand() );
std::uniform_int_distribution<key_type> rnd;
std::vector<key_type> x0(N);
std::vector<key_type> x1(N);
std::generate(x0.begin(), x0.end(), [&]() { return rnd(rng); });
vex::vector<key_type> X0(ctx, x0);
vex::vector<key_type> X1(ctx, N);
X1 = X0;
vex::sort(X1);
double tot_time = 0;
for(size_t i = 0; i < M; i++) {
X1 = X0;
ctx.finish();
prof.tic_cpu("VexCL");
vex::sort(X1);
ctx.finish();
tot_time += prof.toc("VexCL");
}
std::cout
<< "Sort (" << vex::type_name<key_type>() << ")\n"
<< " VexCL: " << N * M / tot_time << " keys/sec\n";
#ifdef HAVE_BOOST_COMPUTE
X1 = X0;
vex::compute::sort(X1);
tot_time = 0;
for(size_t i = 0; i < M; i++) {
X1 = X0;
ctx.finish();
prof.tic_cpu("Boost.Compute");
vex::compute::sort(X1);
ctx.finish();
tot_time += prof.toc("Boost.Compute");
}
std::cout
<< " Boost.Compute: " << N * M / tot_time << " keys/sec\n";
#endif
#ifdef HAVE_CLOGS
X1 = X0;
vex::clogs::sort(X1);
tot_time = 0;
for(size_t i = 0; i < M; i++) {
X1 = X0;
ctx.finish();
prof.tic_cpu("CLOGS");
vex::clogs::sort(X1);
ctx.finish();
tot_time += prof.toc("CLOGS");
}
std::cout
<< " CLOGS: " << N * M / tot_time << " keys/sec\n";
#endif
if (options.bm_cpu) {
tot_time = 0;
for(size_t i = 0; i < M; i++) {
std::copy(x0.begin(), x0.end(), x1.begin());
prof.tic_cpu("STL");
std::sort(x1.begin(), x1.end());
tot_time += prof.toc("STL");
}
std::cout << " STL: " << N * M / tot_time << " keys/sec\n";
}
std::cout << std::endl;
}
static void tst_isolate_roots() {
enable_trace("isolate_roots");
unsynch_mpq_manager qm;
polynomial::manager pm(qm);
algebraic_numbers::manager am(qm);
polynomial_ref x0(pm);
polynomial_ref x1(pm);
polynomial_ref x2(pm);
polynomial_ref x3(pm);
x0 = pm.mk_polynomial(pm.mk_var());
x1 = pm.mk_polynomial(pm.mk_var());
x2 = pm.mk_polynomial(pm.mk_var());
x3 = pm.mk_polynomial(pm.mk_var());
polynomial_ref p(pm);
p = x3*x1 + 1;
scoped_anum v0(am), v1(am), v2(am);
tst_isolate_roots(p, am, 0, v0, 1, v1, 2, v2);
am.set(v1, 1);
tst_isolate_roots(p, am, 0, v0, 1, v1, 2, v2);
am.set(v1, 2);
am.root(v1, 2, v1);
tst_isolate_roots(p, am, 0, v0, 1, v1, 2, v2);
p = (x1 + x2)*x3 + 1;
am.set(v2, v1);
tst_isolate_roots(p, am, 0, v0, 1, v1, 2, v2);
p = (x1 + x2)*x3 + x1*x2 + 2;
tst_isolate_roots(p, am, 0, v0, 1, v1, 2, v2);
p = (x1 + x2)*(x3^3) + x1*x2 + 2;
tst_isolate_roots(p, am, 0, v0, 1, v1, 2, v2);
p = (x1 + x2)*(x3^2) - x1*x2 - 2;
tst_isolate_roots(p, am, 0, v0, 1, v1, 2, v2);
p = x0*(x1 + x2)*(x3^2) - x0*x1*x2 - 2;
tst_isolate_roots(p, am, 0, v0, 1, v1, 2, v2);
p = (x1 - x2)*x3 + x1*x2 - 2;
tst_isolate_roots(p, am, 0, v0, 1, v1, 2, v2);
p = (x1 - x2)*(x3^3) + x1*x2 - 2;
tst_isolate_roots(p, am, 0, v0, 1, v1, 2, v2);
p = (x3 - x0)*(x3 - x0 - x1);
am.set(v0, 2);
am.root(v0, 2, v0); // x2 -> sqrt(2)
am.set(v1, 3);
am.root(v1, 2, v1); // x1 -> sqrt(3)
am.reset(v2);
tst_isolate_roots(p, am, 0, v0, 1, v1, 2, v2);
p = (x3 - x0)*((x3 - x0 - x1)^2);
tst_isolate_roots(p, am, 0, v0, 1, v1, 2, v2);
p = (x3 - x0)*(x3 - 2)*((x3 - 1)^2)*(x3 - x1);
tst_isolate_roots(p, am, 0, v0, 1, v1, 2, v2);
}
int main(int argc, char *argv[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
Platform &platform = Tpetra::DefaultPlatform::getDefaultPlatform();
Teuchos::RCP<const Teuchos::Comm<int> > comm = platform.getComm();
int iprint = argc - 1;
Teuchos::oblackholestream bhs; // outputs nothing
std::ostream& outStream = (iprint > 0) ? std::cout : bhs;
int errorFlag = 0;
RealT errtol = ROL::ROL_THRESHOLD<RealT>();
try {
// Dimension of the optimization vector
int dim = 10;
Teuchos::RCP<Map> map = Teuchos::rcp( new Map(dim,0,comm) );
// Create Tpetra::MultiVectors (single vectors)
MVP x_rcp = Teuchos::rcp( new MV(map,1,true) );
MVP y_rcp = Teuchos::rcp( new MV(map,1,true) );
VP W_rcp = Teuchos::rcp( new V(map,true) );
// Random elements
//x_rcp->randomize();
//y_rcp->randomize();
x_rcp->putScalar(1.0);
y_rcp->putScalar(1.0);
// Set all values to 2
W_rcp->putScalar(2.0);
// Create ROL vectors
ROL::PrimalScaledTpetraMultiVector<RealT,LO,GO,Node> x(x_rcp,W_rcp);
ROL::DualScaledTpetraMultiVector<RealT,LO,GO,Node> y(y_rcp,W_rcp);
// const ROL::Vector<RealT> &g = x.dual();
// const ROL::Vector<RealT> &h = x.dual();
// RealT hnorm = h.norm();
// RealT gnorm = g.norm();
RealT xy = x.dot(y.dual());
RealT yx = y.dot(x.dual());
outStream << "\nAbsolute error between x.dot(y.dual()) and y.dot(x.dual()): "
<< std::abs(xy-yx) << "\n";
outStream << "x.dot(y.dual()): " << xy << "\n";
outStream << "y.dot(x.dual()): " << yx << "\n";
if ( std::abs(xy-yx) > errtol ) {
outStream << "---> POSSIBLE ERROR ABOVE!\n";
errorFlag++;
}
RealT xx = std::sqrt(x.dot(x)), xnorm = x.norm();
RealT yy = std::sqrt(y.dot(y)), ynorm = y.norm();
outStream << "\nAbsolute error between sqrt(x.dot(x)) and x.norm(): "
<< std::abs(xx-xnorm) << "\n";
outStream << "sqrt(x.dot(x)): " << xx << "\n";
outStream << "x.norm(): " << xnorm << "\n";
if ( std::abs(xx-xnorm) > errtol ) {
outStream << "---> POSSIBLE ERROR ABOVE!\n";
errorFlag++;
}
outStream << "\nAbsolute error between sqrt(y.dot(y)) and y.norm(): "
<< std::abs(yy-ynorm) << "\n";
outStream << "sqrt(y.dot(y)): " << yy << "\n";
outStream << "y.norm(): " << ynorm << "\n";
if ( std::abs(yy-ynorm) > errtol ) {
outStream << "---> POSSIBLE ERROR ABOVE!\n";
errorFlag++;
}
// clone z from x, deep copy x into z, norm of z
Teuchos::RCP<ROL::Vector<RealT> > z = x.clone();
z->set(x);
RealT znorm = z->norm();
outStream << "\nNorm of ROL::Vector z (clone of x): " << znorm << "\n";
if ( std::abs(xnorm - znorm) > errtol ) {
outStream << "---> POSSIBLE ERROR ABOVE!\n";
errorFlag++;
}
Teuchos::RCP<ROL::Vector<RealT> > w = y.clone();
w = y.clone();
w->set(y);
RealT wnorm = w->norm();
outStream << "\nNorm of ROL::Vector w (clone of y): " << wnorm << "\n";
if ( std::abs(ynorm - wnorm) > errtol ) {
outStream << "---> POSSIBLE ERROR ABOVE!\n";
errorFlag++;
}
// Standard tests.
// Create Tpetra::MultiVectors (single vectors)
MVP x1_rcp = Teuchos::rcp( new MV(map,1,true) );
MVP y1_rcp = Teuchos::rcp( new MV(map,1,true) );
MVP z1_rcp = Teuchos::rcp( new MV(map,1,true) );
ROL::PrimalScaledTpetraMultiVector<RealT,LO,GO,Node> x1(x1_rcp,W_rcp);
ROL::PrimalScaledTpetraMultiVector<RealT,LO,GO,Node> y1(y1_rcp,W_rcp);
ROL::PrimalScaledTpetraMultiVector<RealT,LO,GO,Node> z1(z1_rcp,W_rcp);
x1_rcp->randomize();
y1_rcp->randomize();
z1_rcp->randomize();
std::vector<RealT> consistency = x1.checkVector(y1, z1, true, outStream);
ROL::StdVector<RealT> checkvec(Teuchos::rcp(&consistency, false));
if (checkvec.norm() > std::sqrt(errtol)) {
errorFlag++;
}
}
catch (std::logic_error err) {
outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
main(){
X x1("1234");
X x2(x1+1);
}
double yangle() const {
double x=x1()-x0;
double y=y1()-y0;
double o=x<0?1:-1;
return vangle(0,1,x,y)*o+M_PI;
}
Path SVGLineElement::toPathData() const
{
return Path::createLine(FloatPoint(x1().value(this), y1().value(this)),
FloatPoint(x2().value(this), y2().value(this)));
}
bool SVGLineElement::hasRelativeValues() const
{
return (x1().isRelative() || y1().isRelative() ||
x2().isRelative() || y2().isRelative());
}
inline void
TrsvUN( UnitOrNonUnit diag, const DistMatrix<F>& U, DistMatrix<F>& x )
{
#ifndef RELEASE
CallStackEntry entry("internal::TrsvUN");
if( U.Grid() != x.Grid() )
LogicError("{U,x} must be distributed over the same grid");
if( U.Height() != U.Width() )
LogicError("U must be square");
if( x.Width() != 1 && x.Height() != 1 )
LogicError("x must be a vector");
const Int xLength = ( x.Width() == 1 ? x.Height() : x.Width() );
if( U.Width() != xLength )
LogicError("Nonconformal TrsvUN");
#endif
const Grid& g = U.Grid();
if( x.Width() == 1 )
{
// Matrix views
DistMatrix<F> U01(g),
U11(g);
DistMatrix<F>
xT(g), x0(g),
xB(g), x1(g),
x2(g);
// Temporary distributions
DistMatrix<F,STAR,STAR> U11_STAR_STAR(g);
DistMatrix<F,STAR,STAR> x1_STAR_STAR(g);
DistMatrix<F,MR, STAR> x1_MR_STAR(g);
DistMatrix<F,MC, STAR> z_MC_STAR(g);
// Views of z[MC,* ], which will store updates to x
DistMatrix<F,MC,STAR> z0_MC_STAR(g),
z1_MC_STAR(g);
z_MC_STAR.AlignWith( U );
Zeros( z_MC_STAR, x.Height(), 1 );
// Start the algorithm
PartitionUp
( x, xT,
xB, 0 );
while( xT.Height() > 0 )
{
RepartitionUp
( xT, x0,
x1,
/**/ /**/
xB, x2 );
const Int n0 = x0.Height();
const Int n1 = x1.Height();
LockedView( U01, U, 0, n0, n0, n1 );
LockedView( U11, U, n0, n0, n1, n1 );
View( z0_MC_STAR, z_MC_STAR, 0, 0, n0, 1 );
View( z1_MC_STAR, z_MC_STAR, n0, 0, n1, 1 );
x1_MR_STAR.AlignWith( U01 );
//----------------------------------------------------------------//
if( x2.Height() != 0 )
x1.SumScatterUpdate( F(1), z1_MC_STAR );
x1_STAR_STAR = x1;
U11_STAR_STAR = U11;
Trsv
( UPPER, NORMAL, diag,
U11_STAR_STAR.LockedMatrix(),
x1_STAR_STAR.Matrix() );
x1 = x1_STAR_STAR;
x1_MR_STAR = x1_STAR_STAR;
LocalGemv( NORMAL, F(-1), U01, x1_MR_STAR, F(1), z0_MC_STAR );
//----------------------------------------------------------------//
SlidePartitionUp
( xT, x0,
/**/ /**/
x1,
xB, x2 );
}
}
else
{
// Matrix views
DistMatrix<F> U01(g),
U11(g);
DistMatrix<F>
xL(g), xR(g),
x0(g), x1(g), x2(g);
// Temporary distributions
DistMatrix<F,STAR,STAR> U11_STAR_STAR(g);
DistMatrix<F,STAR,STAR> x1_STAR_STAR(g);
DistMatrix<F,STAR,MR > x1_STAR_MR(g);
DistMatrix<F,MC, MR > z1(g);
DistMatrix<F,MR, MC > z1_MR_MC(g);
DistMatrix<F,STAR,MC > z_STAR_MC(g);
// Views of z[* ,MC]
DistMatrix<F,STAR,MC> z0_STAR_MC(g), z1_STAR_MC(g);
z_STAR_MC.AlignWith( U );
Zeros( z_STAR_MC, 1, x.Width() );
// Start the algorithm
PartitionLeft( x, xL, xR, 0 );
while( xL.Width() > 0 )
{
RepartitionLeft
( xL, /**/ xR,
x0, x1, /**/ x2 );
const Int n0 = x0.Width();
const Int n1 = x1.Width();
LockedView( U01, U, 0, n0, n0, n1 );
LockedView( U11, U, n0, n0, n1, n1 );
View( z0_STAR_MC, z_STAR_MC, 0, 0, 1, n0 );
View( z1_STAR_MC, z_STAR_MC, 0, n0, 1, n1 );
x1_STAR_MR.AlignWith( U01 );
z1.AlignWith( x1 );
//----------------------------------------------------------------//
if( x2.Width() != 0 )
{
z1_MR_MC.SumScatterFrom( z1_STAR_MC );
z1 = z1_MR_MC;
Axpy( F(1), z1, x1 );
}
x1_STAR_STAR = x1;
U11_STAR_STAR = U11;
Trsv
( UPPER, NORMAL, diag,
U11_STAR_STAR.LockedMatrix(),
x1_STAR_STAR.Matrix() );
x1 = x1_STAR_STAR;
x1_STAR_MR = x1_STAR_STAR;
LocalGemv( NORMAL, F(-1), U01, x1_STAR_MR, F(1), z0_STAR_MC );
//----------------------------------------------------------------//
SlidePartitionLeft
( xL, /**/ xR,
x0, /**/ x1, x2 );
}
}
}
Eigen::MatrixXd RmullwlskCCsort2( const Eigen::Map<Eigen::VectorXd> & bw, const std::string kernel_type, const Eigen::Map<Eigen::MatrixXd> & tPairs, const Eigen::Map<Eigen::MatrixXd> & cxxn, const Eigen::Map<Eigen::VectorXd> & win, const Eigen::Map<Eigen::VectorXd> & xgrid, const Eigen::Map<Eigen::VectorXd> & ygrid, const bool & bwCheck){
// Assumes the first row of tPairs is sorted in increasing order.
// tPairs : xin (in MATLAB code)
// cxxn : yin (in MATLAB code)
// xgrid: out1 (in MATLAB code)
// ygrid: out2 (in MATLAB code)
// bwCheck : boolean/ cause the function to simply run the bandwidth check.
const double invSqrt2pi= 1./(sqrt(2.*M_PI));
// Map the kernel name so we can use switches
std::map<std::string,int> possibleKernels;
possibleKernels["epan"] = 1; possibleKernels["rect"] = 2;
possibleKernels["gauss"] = 3; possibleKernels["gausvar"] = 4;
possibleKernels["quar"] = 5;
// The following test is here for completeness, we mightwant to move it up a
// level (in the wrapper) in the future.
// If the kernel_type key exists set KernelName appropriately
int KernelName = 0;
if ( possibleKernels.count( kernel_type ) != 0){
KernelName = possibleKernels.find( kernel_type )->second; //Set kernel choice
} else {
// otherwise use "epan"as the kernel_type
//Rcpp::Rcout << "Kernel_type argument was not set correctly; Epanechnikov kernel used." << std::endl;
Rcpp::warning("Kernel_type argument was not set correctly; Epanechnikov kernel used.");
KernelName = possibleKernels.find( "epan" )->second;;
}
// Check that we do not have zero weights // Should do a try-catch here
// Again this might be best moved a level-up.
if ( !(win.all()) ){ //
Rcpp::Rcout << "Cases with zero-valued windows are not yet implemented" << std::endl;
return (tPairs);
}
// ProfilerStart("sort.log");
// Start the actual smoother here
const unsigned int xgridN = xgrid.size();
const unsigned int ygridN = ygrid.size();
const unsigned int n = tPairs.cols();
// For sorted x1
Eigen::VectorXd x1(tPairs.row(0).transpose());
const double* tDat = x1.data();
Eigen::MatrixXd mu(xgrid.size(), ygrid.size());
mu.setZero();
for (unsigned int i = 0; i != xgridN; ++i) {
const double xl = xgrid(i) - bw(0) - 1e-6,
xu = xgrid(i) + bw(0) + 1e-6;
unsigned int indl = std::lower_bound(tDat, tDat + n, xl) - tDat,
indu = std::upper_bound(tDat, tDat + n, xu) - tDat;
// sort the y index
std::vector<valIndPair> yval(indu - indl);
for (unsigned int k = 0; k < yval.size(); ++k){
yval[k] = std::make_pair(tPairs(1, k + indl), k + indl);
}
std::sort<std::vector<valIndPair>::iterator>(yval.begin(), yval.end(), compPair);
std::vector<valIndPair>::iterator ylIt = yval.begin(),
yuIt = yval.begin();
for (unsigned int j = 0; j != ygridN; ++j) {
const double yl = ygrid(j) - bw(1) - 1e-6,
yu = ygrid(j) + bw(1) + 1e-6;
//locating local window (LOL) (bad joke)
std::vector <unsigned int> indx;
//if the kernel is not Gaussian
if ( KernelName != 3) {
// Search the lower and upper bounds increasingly.
ylIt = std::lower_bound(ylIt, yval.end(), valIndPair(yl, 0), compPair);
yuIt = std::upper_bound(yuIt, yval.end(), valIndPair(yu, 0), compPair);
// The following works nice for the Gaussian
// but for very small samples it complains
//} else {
// ylIt = yval.begin();
// yuIt = yval.end();
//}
for (std::vector<valIndPair>::iterator y = ylIt; y != yuIt; ++y){
indx.push_back(y->second);
}
} else { //When we finally get c++11 we will use std::iota
for( unsigned int y = 0; y != n; ++y){
indx.push_back(y);
}
}
// for (unsigned int y = 0; y != indx.size(); ++y){
// Rcpp::Rcout << "indx.at(y): " << indx.at(y)<< ", ";
// }
unsigned int indxSize = indx.size();
Eigen::VectorXd lw(indxSize);
Eigen::VectorXd ly(indxSize);
Eigen::MatrixXd lx(2,indxSize);
for (unsigned int u = 0; u !=indxSize; ++u){
lx.col(u) = tPairs.col(indx[u]);
lw(u) = win(indx[u]);
ly(u) = cxxn(indx[u]);
}
// check enough points are in the local window
unsigned int meter=1;
for (unsigned int u =0; u< indxSize; ++u) {
for (unsigned int t = u + 1; t < indxSize; ++t) {
if ( (lx(0,u) != lx(0,t) ) || (lx(1,u) != lx(1,t) ) ) {
meter++;
}
}
if (meter >= 3) {
break;
}
}
//computing weight matrix
if (meter >= 3 && !bwCheck) {
Eigen::VectorXd temp(indxSize);
Eigen::MatrixXd llx(2, indxSize );
llx.row(0) = (lx.row(0).array() - xgrid(i))/bw(0);
llx.row(1) = (lx.row(1).array() - ygrid(j))/bw(1);
//define the kernel used
switch (KernelName){
case 1: // Epan
temp= ((1-llx.row(0).array().pow(2))*(1- llx.row(1).array().pow(2))).array() *
((9./16)*lw).transpose().array();
break;
case 2 : // Rect
temp=(lw.array())*.25 ;
break;
case 3 : // Gauss
temp = ((-.5*(llx.row(1).array().pow(2))).exp()) * invSqrt2pi *
((-.5*(llx.row(0).array().pow(2))).exp()) * invSqrt2pi *
(lw.transpose().array());
break;
case 4 : // GausVar
temp = (lw.transpose().array()) *
((-0.5 * llx.row(0).array().pow(2)).array().exp() * invSqrt2pi).array() *
((-0.5 * llx.row(1).array().pow(2)).array().exp() * invSqrt2pi).array() *
(1.25 - (0.25 * (llx.row(0).array().pow(2))).array()) *
(1.50 - (0.50 * (llx.row(1).array().pow(2))).array());
break;
case 5 : // Quar
temp = (lw.transpose().array()) *
((1.-llx.row(0).array().pow(2)).array().pow(2)).array() *
((1.-llx.row(1).array().pow(2)).array().pow(2)).array() * (225./256.);
break;
}
// make the design matrix
Eigen::MatrixXd X(indxSize ,3);
X.setOnes();
X.col(1) = lx.row(0).array() - xgrid(i);
X.col(2) = lx.row(1).array() - ygrid(j);
Eigen::LDLT<Eigen::MatrixXd> ldlt_XTWX(X.transpose() * temp.asDiagonal() *X);
// The solver should stop if the value is NaN. See the HOLE example in gcvlwls2dV2.
Eigen::VectorXd beta = ldlt_XTWX.solve(X.transpose() * temp.asDiagonal() * ly);
mu(i,j)=beta(0);
}
// else if(meter < 3){
// // Rcpp::Rcout <<"The meter value is:" << meter << std::endl;
// if (bwCheck) {
// Eigen::MatrixXd checker(1,1);
// checker(0,0) = 0.;
// return(checker);
// } else {
// Rcpp::stop("No enough points in local window, please increase bandwidth.");
// }
// }
}
}
if (bwCheck){
Eigen::MatrixXd checker(1,1);
checker(0,0) = 1.;
return(checker);
}
// ProfilerStop();
return ( mu );
}
template<class _t, class _rt, class _it> _t rect<_t, _rt, _it>::center_x() {
adjust_to_concept();
return (x0() + x1()) / 2;
}
void MathPlot::setupSincScatterDemo(QCustomPlot *customPlot)
{
customPlot->legend->setVisible(true);
customPlot->legend->setFont(QFont("Helvetica",9));
// set locale to english, so we get english decimal separator:
customPlot->setLocale(QLocale(QLocale::English, QLocale::UnitedKingdom));
// add confidence band graphs:
customPlot->addGraph();
QPen pen;
pen.setStyle(Qt::DotLine);
pen.setWidth(1);
pen.setColor(QColor(180,180,180));
customPlot->graph(0)->setName("Confidence Band 68%");
customPlot->graph(0)->setPen(pen);
customPlot->graph(0)->setBrush(QBrush(QColor(255,50,30,20)));
customPlot->addGraph();
customPlot->legend->removeItem(customPlot->legend->itemCount()-1); // don't show two confidence band graphs in legend
customPlot->graph(1)->setPen(pen);
customPlot->graph(0)->setChannelFillGraph(customPlot->graph(1));
// add theory curve graph:
customPlot->addGraph();
pen.setStyle(Qt::DashLine);
pen.setWidth(2);
pen.setColor(Qt::red);
customPlot->graph(2)->setPen(pen);
customPlot->graph(2)->setName("Theory Curve");
// add data point graph:
customPlot->addGraph();
customPlot->graph(3)->setPen(QPen(Qt::blue));
customPlot->graph(3)->setLineStyle(QCPGraph::lsNone);
customPlot->graph(3)->setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssCross, 4));
customPlot->graph(3)->setErrorType(QCPGraph::etValue);
customPlot->graph(3)->setErrorPen(QPen(QColor(180,180,180)));
customPlot->graph(3)->setName("Measurement");
// generate ideal sinc curve data and some randomly perturbed data for scatter plot:
QVector<double> x0(250), y0(250);
QVector<double> yConfUpper(250), yConfLower(250);
for (int i=0; i<250; ++i)
{
x0[i] = (i/249.0-0.5)*30+0.01; // by adding a small offset we make sure not do divide by zero in next code line
y0[i] = sin(x0[i])/x0[i]; // sinc function
yConfUpper[i] = y0[i]+0.15;
yConfLower[i] = y0[i]-0.15;
x0[i] *= 1000;
}
QVector<double> x1(50), y1(50), y1err(50);
for (int i=0; i<50; ++i)
{
// generate a gaussian distributed random number:
double tmp1 = rand()/(double)RAND_MAX;
double tmp2 = rand()/(double)RAND_MAX;
double r = sqrt(-2*log(tmp1))*cos(2*M_PI*tmp2); // box-muller transform for gaussian distribution
// set y1 to value of y0 plus a random gaussian pertubation:
x1[i] = (i/50.0-0.5)*30+0.25;
y1[i] = sin(x1[i])/x1[i]+r*0.15;
x1[i] *= 1000;
y1err[i] = 0.15;
}
// pass data to graphs and let QCustomPlot determine the axes ranges so the whole thing is visible:
customPlot->graph(0)->setData(x0, yConfUpper);
customPlot->graph(1)->setData(x0, yConfLower);
customPlot->graph(2)->setData(x0, y0);
customPlot->graph(3)->setDataValueError(x1, y1, y1err);
customPlot->graph(2)->rescaleAxes();
customPlot->graph(3)->rescaleAxes(true);
// setup look of bottom tick labels:
customPlot->xAxis->setTickLabelRotation(30);
customPlot->xAxis->setAutoTickCount(9);
customPlot->xAxis->setNumberFormat("ebc");
customPlot->xAxis->setNumberPrecision(1);
customPlot->xAxis->moveRange(-10);
// make top right axes clones of bottom left axes. Looks prettier:
customPlot->axisRect()->setupFullAxesBox();
}
void ApplyNonMaximumSuppresion(std::vector< LkTracker* >& in_out_source, float in_nms_threshold)
{
if (in_out_source.empty())
return;
unsigned int size = in_out_source.size();
std::vector<float> area(size);
std::vector<float> scores(size);
std::vector<int> x1(size);
std::vector<int> y1(size);
std::vector<int> x2(size);
std::vector<int> y2(size);
std::vector<unsigned int> indices(size);
std::vector<bool> is_suppresed(size);
for(unsigned int i = 0; i< in_out_source.size(); i++)
{
ObjectDetection tmp = in_out_source[i]->GetTrackedObject();
area[i] = tmp.rect.width * tmp.rect.height;
if (area[i]>0)
is_suppresed[i] = false;
else
{
is_suppresed[i] = true;
in_out_source[i]->NullifyLifespan();
}
indices[i] = i;
scores[i] = tmp.score;
x1[i] = tmp.rect.x;
y1[i] = tmp.rect.y;
x2[i] = tmp.rect.width + tmp.rect.x;
y2[i] = tmp.rect.height + tmp.rect.y;
}
Sort(area, indices);//returns indices ordered based on scores
for(unsigned int i=0; i< size; i++)
{
for(unsigned int j= i+1; j< size; j++)
{
if(is_suppresed[indices[i]] || is_suppresed[indices[j]])
continue;
int x1_max = std::max(x1[indices[i]], x1[indices[j]]);
int x2_min = std::min(x2[indices[i]], x2[indices[j]]);
int y1_max = std::max(y1[indices[i]], y1[indices[j]]);
int y2_min = std::min(y2[indices[i]], y2[indices[j]]);
int overlap_width = x2_min - x1_max + 1;
int overlap_height = y2_min - y1_max + 1;
if(overlap_width > 0 && overlap_height>0)
{
float overlap_part = (overlap_width*overlap_height)/area[indices[j]];
if(overlap_part > in_nms_threshold)
{
is_suppresed[indices[j]] = true;
in_out_source[indices[j]]->NullifyLifespan();
if (in_out_source[indices[j]]->GetFrameCount() > in_out_source[indices[i]]->GetFrameCount())
{
in_out_source[indices[i]]->object_id = in_out_source[indices[j]]->object_id;
}
}
}
}
}
return ;
}
void MathPlot::setupMultiAxisDemo(QCustomPlot *customPlot)
{
customPlot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
customPlot->setLocale(QLocale(QLocale::English, QLocale::UnitedKingdom)); // period as decimal separator and comma as thousand separator
customPlot->legend->setVisible(true);
QFont legendFont = font(); // start out with MainWindow's font..
legendFont.setPointSize(9); // and make a bit smaller for legend
customPlot->legend->setFont(legendFont);
customPlot->legend->setBrush(QBrush(QColor(255,255,255,230)));
// by default, the legend is in the inset layout of the main axis rect. So this is how we access it to change legend placement:
customPlot->axisRect()->insetLayout()->setInsetAlignment(0, Qt::AlignBottom|Qt::AlignRight);
// setup for graph 0: key axis left, value axis bottom
// will contain left maxwell-like function
customPlot->addGraph(customPlot->yAxis, customPlot->xAxis);
customPlot->graph(0)->setPen(QPen(QColor(255, 100, 0)));
customPlot->graph(0)->setBrush(QBrush(QPixmap("://skin/images/balboa.jpg"))); // fill with texture of specified image
customPlot->graph(0)->setLineStyle(QCPGraph::lsLine);
customPlot->graph(0)->setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssDisc, 5));
customPlot->graph(0)->setName("Left maxwell function");
// setup for graph 1: key axis bottom, value axis left (those are the default axes)
// will contain bottom maxwell-like function
customPlot->addGraph();
customPlot->graph(1)->setPen(QPen(Qt::red));
customPlot->graph(1)->setBrush(QBrush(QPixmap("://skin/images/balboa.jpg"))); // same fill as we used for graph 0
customPlot->graph(1)->setLineStyle(QCPGraph::lsStepCenter);
customPlot->graph(1)->setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssCircle, Qt::red, Qt::white, 7));
customPlot->graph(1)->setErrorType(QCPGraph::etValue);
customPlot->graph(1)->setName("Bottom maxwell function");
// setup for graph 2: key axis top, value axis right
// will contain high frequency sine with low frequency beating:
customPlot->addGraph(customPlot->xAxis2, customPlot->yAxis2);
customPlot->graph(2)->setPen(QPen(Qt::blue));
customPlot->graph(2)->setName("High frequency sine");
// setup for graph 3: same axes as graph 2
// will contain low frequency beating envelope of graph 2
customPlot->addGraph(customPlot->xAxis2, customPlot->yAxis2);
QPen blueDotPen;
blueDotPen.setColor(QColor(30, 40, 255, 150));
blueDotPen.setStyle(Qt::DotLine);
blueDotPen.setWidthF(4);
customPlot->graph(3)->setPen(blueDotPen);
customPlot->graph(3)->setName("Sine envelope");
// setup for graph 4: key axis right, value axis top
// will contain parabolically distributed data points with some random perturbance
customPlot->addGraph(customPlot->yAxis2, customPlot->xAxis2);
customPlot->graph(4)->setPen(QColor(50, 50, 50, 255));
customPlot->graph(4)->setLineStyle(QCPGraph::lsNone);
customPlot->graph(4)->setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssCircle, 4));
customPlot->graph(4)->setName("Some random data around\na quadratic function");
// generate data, just playing with numbers, not much to learn here:
QVector<double> x0(25), y0(25);
QVector<double> x1(15), y1(15), y1err(15);
QVector<double> x2(250), y2(250);
QVector<double> x3(250), y3(250);
QVector<double> x4(250), y4(250);
for (int i=0; i<25; ++i) // data for graph 0
{
x0[i] = 3*i/25.0;
y0[i] = exp(-x0[i]*x0[i]*0.8)*(x0[i]*x0[i]+x0[i]);
}
for (int i=0; i<15; ++i) // data for graph 1
{
x1[i] = 3*i/15.0;;
y1[i] = exp(-x1[i]*x1[i])*(x1[i]*x1[i])*2.6;
y1err[i] = y1[i]*0.25;
}
for (int i=0; i<250; ++i) // data for graphs 2, 3 and 4
{
x2[i] = i/250.0*3*M_PI;
x3[i] = x2[i];
x4[i] = i/250.0*100-50;
y2[i] = sin(x2[i]*12)*cos(x2[i])*10;
y3[i] = cos(x3[i])*10;
y4[i] = 0.01*x4[i]*x4[i] + 1.5*(rand()/(double)RAND_MAX-0.5) + 1.5*M_PI;
}
// pass data points to graphs:
customPlot->graph(0)->setData(x0, y0);
customPlot->graph(1)->setDataValueError(x1, y1, y1err);
customPlot->graph(2)->setData(x2, y2);
customPlot->graph(3)->setData(x3, y3);
customPlot->graph(4)->setData(x4, y4);
// activate top and right axes, which are invisible by default:
customPlot->xAxis2->setVisible(true);
customPlot->yAxis2->setVisible(true);
// set ranges appropriate to show data:
customPlot->xAxis->setRange(0, 2.7);
customPlot->yAxis->setRange(0, 2.6);
customPlot->xAxis2->setRange(0, 3.0*M_PI);
customPlot->yAxis2->setRange(-70, 35);
// set pi ticks on top axis:
QVector<double> piTicks;
QVector<QString> piLabels;
piTicks << 0 << 0.5*M_PI << M_PI << 1.5*M_PI << 2*M_PI << 2.5*M_PI << 3*M_PI;
piLabels << "0" << QString::fromUtf8("½π") << QString::fromUtf8("π") << QString::fromUtf8("1½π") << QString::fromUtf8("2π") << QString::fromUtf8("2½π") << QString::fromUtf8("3π");
customPlot->xAxis2->setAutoTicks(false);
customPlot->xAxis2->setAutoTickLabels(false);
customPlot->xAxis2->setTickVector(piTicks);
customPlot->xAxis2->setTickVectorLabels(piLabels);
// add title layout element:
customPlot->plotLayout()->insertRow(0);
customPlot->plotLayout()->addElement(0, 0, new QCPPlotTitle(customPlot, "Way too many graphs in one plot"));
// set labels:
customPlot->xAxis->setLabel("Bottom axis with outward ticks");
customPlot->yAxis->setLabel("Left axis label");
customPlot->xAxis2->setLabel("Top axis label");
customPlot->yAxis2->setLabel("Right axis label");
// make ticks on bottom axis go outward:
customPlot->xAxis->setTickLength(0, 5);
customPlot->xAxis->setSubTickLength(0, 3);
// make ticks on right axis go inward and outward:
customPlot->yAxis2->setTickLength(3, 3);
customPlot->yAxis2->setSubTickLength(1, 1);
}
void IncNavierStokes::v_InitObject()
{
AdvectionSystem::v_InitObject();
int i,j;
int numfields = m_fields.num_elements();
std::string velids[] = {"u","v","w"};
// Set up Velocity field to point to the first m_expdim of m_fields;
m_velocity = Array<OneD,int>(m_spacedim);
for(i = 0; i < m_spacedim; ++i)
{
for(j = 0; j < numfields; ++j)
{
std::string var = m_boundaryConditions->GetVariable(j);
if(boost::iequals(velids[i], var))
{
m_velocity[i] = j;
break;
}
ASSERTL0(j != numfields, "Failed to find field: " + var);
}
}
// Set up equation type enum using kEquationTypeStr
for(i = 0; i < (int) eEquationTypeSize; ++i)
{
bool match;
m_session->MatchSolverInfo("EQTYPE",kEquationTypeStr[i],match,false);
if(match)
{
m_equationType = (EquationType)i;
break;
}
}
ASSERTL0(i != eEquationTypeSize,"EQTYPE not found in SOLVERINFO section");
// This probably should to into specific implementations
// Equation specific Setups
switch(m_equationType)
{
case eSteadyStokes:
case eSteadyOseen:
case eSteadyNavierStokes:
case eSteadyLinearisedNS:
break;
case eUnsteadyNavierStokes:
case eUnsteadyStokes:
{
m_session->LoadParameter("IO_InfoSteps", m_infosteps, 0);
m_session->LoadParameter("IO_CFLSteps", m_cflsteps, 0);
m_session->LoadParameter("SteadyStateSteps", m_steadyStateSteps, 0);
m_session->LoadParameter("SteadyStateTol", m_steadyStateTol, 1e-6);
// check to see if any user defined boundary condition is
// indeed implemented
for(int n = 0; n < m_fields[0]->GetBndConditions().num_elements(); ++n)
{
std::string type =m_fields[0]->GetBndConditions()[n]->GetUserDefined();
if(!type.empty())
// Time Dependent Boundary Condition (if no user
// defined then this is empty)
ASSERTL0 (boost::iequals(type,"Wall_Forces") ||
boost::iequals(type,"TimeDependent") ||
boost::iequals(type,"MovingBody") ||
boost::iequals(type,"Radiation") ||
boost::iequals(type,"I") ||
boost::iequals(type,"HOutflow"),
"Unknown USERDEFINEDTYPE boundary condition");
}
}
break;
case eNoEquationType:
default:
ASSERTL0(false,"Unknown or undefined equation type");
}
m_session->LoadParameter("Kinvis", m_kinvis);
// Default advection type per solver
std::string vConvectiveType;
switch(m_equationType)
{
case eUnsteadyStokes:
vConvectiveType = "NoAdvection";
break;
case eUnsteadyNavierStokes:
case eSteadyNavierStokes:
vConvectiveType = "Convective";
break;
case eUnsteadyLinearisedNS:
vConvectiveType = "Linearised";
break;
default:
break;
}
// Check if advection type overridden
if (m_session->DefinesTag("AdvectiveType") && m_equationType != eUnsteadyStokes)
{
vConvectiveType = m_session->GetTag("AdvectiveType");
}
// Initialise advection
m_advObject = SolverUtils::GetAdvectionFactory().CreateInstance(vConvectiveType, vConvectiveType);
m_advObject->InitObject( m_session, m_fields);
// Forcing terms
m_forcing = SolverUtils::Forcing::Load(m_session, m_fields,
v_GetForceDimension());
// check to see if any Robin boundary conditions and if so set
// up m_field to boundary condition maps;
m_fieldsBCToElmtID = Array<OneD, Array<OneD, int> >(numfields);
m_fieldsBCToTraceID = Array<OneD, Array<OneD, int> >(numfields);
m_fieldsRadiationFactor = Array<OneD, Array<OneD, NekDouble> > (numfields);
for (i = 0; i < m_fields.num_elements(); ++i)
{
bool Set = false;
Array<OneD, const SpatialDomains::BoundaryConditionShPtr > BndConds;
Array<OneD, MultiRegions::ExpListSharedPtr> BndExp;
int radpts = 0;
BndConds = m_fields[i]->GetBndConditions();
BndExp = m_fields[i]->GetBndCondExpansions();
for(int n = 0; n < BndConds.num_elements(); ++n)
{
if(boost::iequals(BndConds[n]->GetUserDefined(),"Radiation"))
{
ASSERTL0(BndConds[n]->GetBoundaryConditionType() == SpatialDomains::eRobin,
"Radiation boundary condition must be of type Robin <R>");
if(Set == false)
{
m_fields[i]->GetBoundaryToElmtMap(m_fieldsBCToElmtID[i],m_fieldsBCToTraceID[i]);
Set = true;
}
radpts += BndExp[n]->GetTotPoints();
}
}
m_fieldsRadiationFactor[i] = Array<OneD, NekDouble>(radpts);
radpts = 0; // reset to use as a counter
for(int n = 0; n < BndConds.num_elements(); ++n)
{
if(boost::iequals(BndConds[n]->GetUserDefined(),"Radiation"))
{
int npoints = BndExp[n]->GetNpoints();
Array<OneD, NekDouble> x0(npoints,0.0);
Array<OneD, NekDouble> x1(npoints,0.0);
Array<OneD, NekDouble> x2(npoints,0.0);
Array<OneD, NekDouble> tmpArray;
BndExp[n]->GetCoords(x0,x1,x2);
LibUtilities::Equation coeff =
boost::static_pointer_cast<
SpatialDomains::RobinBoundaryCondition
>(BndConds[n])->m_robinPrimitiveCoeff;
coeff.Evaluate(x0,x1,x2,m_time,
tmpArray = m_fieldsRadiationFactor[i]+ radpts);
//Vmath::Neg(npoints,tmpArray = m_fieldsRadiationFactor[i]+ radpts,1);
radpts += npoints;
}
}
}
// Set up Field Meta Data for output files
m_fieldMetaDataMap["Kinvis"] = boost::lexical_cast<std::string>(m_kinvis);
m_fieldMetaDataMap["TimeStep"] = boost::lexical_cast<std::string>(m_timestep);
}
void AdminWindow::addCustomPlot(QCustomPlot *customPlot)
{
// generate some data:
QVector<double> x1(101), y1(101); // initialize with entries 0..100
for (int i=0; i<101; ++i)
{
x1[i] = i/50.0 - 1; // x goes from -1 to 1
y1[i] = x1[i]*x1[i]; // let's plot a quadratic function
}
// // create graph and assign data to it:
// customPlot->addGraph();
// customPlot->graph(0)->setData(x, y);
// // give the axes some labels:
// customPlot->xAxis->setLabel("x");
// customPlot->yAxis->setLabel("y");
// // set axes ranges, so we see all data:
// customPlot->xAxis->setRange(-1, 1);
// customPlot->yAxis->setRange(0, 1);
QCPGraph *graph1 = customPlot->addGraph();
graph1->setData(x1, y1);
graph1->setPen(Qt::NoPen);
graph1->setBrush(QColor(70, 165, 255, 150));
customPlot->addLayer("abovemain", customPlot->layer("main"), QCustomPlot::limAbove);
customPlot->addLayer("belowmain", customPlot->layer("main"), QCustomPlot::limBelow);
graph1->setLayer("abovemain");
customPlot->xAxis->grid()->setLayer("belowmain");
customPlot->yAxis->grid()->setLayer("belowmain");
// set some pens, brushes and backgrounds:
customPlot->xAxis->setBasePen(QPen(Qt::white, 1));
customPlot->yAxis->setBasePen(QPen(Qt::white, 1));
customPlot->xAxis->setTickPen(QPen(Qt::white, 1));
customPlot->yAxis->setTickPen(QPen(Qt::white, 1));
customPlot->xAxis->setSubTickPen(QPen(Qt::white, 1));
customPlot->yAxis->setSubTickPen(QPen(Qt::white, 1));
customPlot->xAxis->setTickLabelColor(Qt::white);
customPlot->yAxis->setTickLabelColor(Qt::white);
customPlot->xAxis->grid()->setPen(QPen(QColor(140, 140, 140), 1, Qt::DotLine));
customPlot->yAxis->grid()->setPen(QPen(QColor(140, 140, 140), 1, Qt::DotLine));
customPlot->xAxis->grid()->setSubGridPen(QPen(QColor(80, 80, 80), 1, Qt::DotLine));
customPlot->yAxis->grid()->setSubGridPen(QPen(QColor(80, 80, 80), 1, Qt::DotLine));
customPlot->xAxis->grid()->setSubGridVisible(true);
customPlot->yAxis->grid()->setSubGridVisible(true);
customPlot->xAxis->grid()->setZeroLinePen(Qt::NoPen);
customPlot->yAxis->grid()->setZeroLinePen(Qt::NoPen);
customPlot->xAxis->setUpperEnding(QCPLineEnding::esSpikeArrow);
customPlot->yAxis->setUpperEnding(QCPLineEnding::esSpikeArrow);
QLinearGradient plotGradient;
plotGradient.setStart(0, 0);
plotGradient.setFinalStop(0, 350);
plotGradient.setColorAt(0, QColor(80, 80, 80));
plotGradient.setColorAt(1, QColor(50, 50, 50));
customPlot->setBackground(plotGradient);
QLinearGradient axisRectGradient;
axisRectGradient.setStart(0, 0);
axisRectGradient.setFinalStop(0, 350);
axisRectGradient.setColorAt(0, QColor(80, 80, 80));
axisRectGradient.setColorAt(1, QColor(30, 30, 30));
customPlot->axisRect()->setBackground(axisRectGradient);
customPlot->rescaleAxes();
customPlot->yAxis->setRange(0, 2);
}
void EXPORT_API ProjectTetrasShapeMatchingJB(btVector3* initialPositions, btVector3* predPositions, float* invMasses, bool* posLocks, int* tetsPerVertex, Tetrahedron* tetras, btVector3* restCMs, float* invRestMat, int tetrasCount, float Ks_prime)
{
for (int i = 0; i < tetrasCount; i++)
{
Tetrahedron tetra = tetras[i];
if (tetra.restVolume == 0.0f)
continue;
Eigen::Vector3f x1_0(initialPositions[tetra.idA].x(), initialPositions[tetra.idA].y(), initialPositions[tetra.idA].z());
Eigen::Vector3f x2_0(initialPositions[tetra.idB].x(), initialPositions[tetra.idB].y(), initialPositions[tetra.idB].z());
Eigen::Vector3f x3_0(initialPositions[tetra.idC].x(), initialPositions[tetra.idC].y(), initialPositions[tetra.idC].z());
Eigen::Vector3f x4_0(initialPositions[tetra.idD].x(), initialPositions[tetra.idD].y(), initialPositions[tetra.idD].z());
Eigen::Vector3f x1(predPositions[tetra.idA].x(), predPositions[tetra.idA].y(), predPositions[tetra.idA].z());
Eigen::Vector3f x2(predPositions[tetra.idB].x(), predPositions[tetra.idB].y(), predPositions[tetra.idB].z());
Eigen::Vector3f x3(predPositions[tetra.idC].x(), predPositions[tetra.idC].y(), predPositions[tetra.idC].z());
Eigen::Vector3f x4(predPositions[tetra.idD].x(), predPositions[tetra.idD].y(), predPositions[tetra.idD].z());
float w1 = posLocks[tetra.idA] ? 0.0f : invMasses[tetra.idA];
float w2 = posLocks[tetra.idB] ? 0.0f : invMasses[tetra.idB];
float w3 = posLocks[tetra.idC] ? 0.0f : invMasses[tetra.idC];
float w4 = posLocks[tetra.idD] ? 0.0f : invMasses[tetra.idD];
Eigen::Vector3f restCM(restCMs[i].x(), restCMs[i].y(), restCMs[i].z());
Eigen::Matrix3f A;
A(0, 0) = invRestMat[16 * i + 0]; A(0, 1) = invRestMat[16 * i + 1]; A(0, 2) = invRestMat[16 * i + 2];
A(1, 0) = invRestMat[16 * i + 4]; A(1, 1) = invRestMat[16 * i + 5]; A(1, 2) = invRestMat[16 * i + 6];
A(2, 0) = invRestMat[16 * i + 8]; A(2, 1) = invRestMat[16 * i + 9]; A(2, 2) = invRestMat[16 * i + 10];
//
//public float m00; 0
//public float m01; 1
//public float m02; 2
//public float m03; 3
//public float m10; 4
//public float m11; 5
//public float m12; 6
//public float m13; 7
//public float m20; 8
//public float m21; 9
//public float m22; 10
//public float m23; 11
//public float m30; 12
//public float m31; 13
//public float m32; 14
//public float m33; 15
//
//A(0, 0) = invRestMat[16 * i + 0]; A(0, 1) = invRestMat[16 * i + 4]; A(0, 2) = invRestMat[16 * i + 8];
//A(1, 0) = invRestMat[16 * i + 1]; A(1, 1) = invRestMat[16 * i + 5]; A(1, 2) = invRestMat[16 * i + 9];
//A(2, 0) = invRestMat[16 * i + 2]; A(2, 1) = invRestMat[16 * i + 6]; A(2, 2) = invRestMat[16 * i + 10];
//public float m00; 0
//public float m10; 1
//public float m20; 2
//public float m30; 3
//public float m01; 4
//public float m11; 5
//public float m21; 6
//public float m31; 7
//public float m02; 8
//public float m12; 9
//public float m22; 10
//public float m32; 11
//public float m03; 12
//public float m13; 13
//public float m23; 14
//public float m33; 15
Eigen::Vector3f x[4] = { x1, x2, x3, x4 };
Eigen::Vector3f x0[4] = { x1_0, x2_0, x3_0, x4_0 };
float w[4] = { w1, w2, w3, w4 };
Eigen::Vector3f corr[4];
bool res = PBD::PositionBasedDynamics::solveShapeMatchingConstraint(
x0, x, w, 4,
restCM,
A,
Ks_prime,
false,
corr);
btVector3 dP1 = btVector3(corr[0].x(), corr[0].y(), corr[0].z());
btVector3 dP2 = btVector3(corr[1].x(), corr[1].y(), corr[1].z());
btVector3 dP3 = btVector3(corr[2].x(), corr[2].y(), corr[2].z());
btVector3 dP4 = btVector3(corr[3].x(), corr[3].y(), corr[3].z());
// Important: Divide position correction by the number of clusters which contain the vertex.
//corr1 = (1.0f / vTets[v1].m_numTets) * corr[0];
//corr2 = (1.0f / vTets[v2].m_numTets) * corr[1];
//corr3 = (1.0f / vTets[v3].m_numTets) * corr[2];
//corr4 = (1.0f / vTets[v4].m_numTets) * corr[3];
if (w1 != 0.0f)
predPositions[tetra.idA] += dP1 * (1.0f / (btScalar)tetsPerVertex[tetra.idA]);
if (w2 != 0.0f)
predPositions[tetra.idB] += dP2 * (1.0f / (btScalar)tetsPerVertex[tetra.idB]);
if (w3 != 0.0f)
predPositions[tetra.idC] += dP3 * (1.0f / (btScalar)tetsPerVertex[tetra.idC]);
if (w4 != 0.0f)
predPositions[tetra.idD] += dP4 * (1.0f / (btScalar)tetsPerVertex[tetra.idD]);
}
}
Flux_Pts Rectang_Object::lmr_all_pts(INT dir) const
{
Elise_Rect r = box();
ASSERT_USER((r._dim == 1),"dim != 1 for lmr_all_pts(INT dir)");
return line_map_rect(dir,x0(),x1());
}
int main(int argc,char* argv[]) {
if (argc < 4) {
printf("./match_g2o pose_stamped.txt key.match map_point.txt\n");
return 1;
}
srand(time(NULL));
Rcl << 1,0,0,0,0,1,0,-1,0;
Tcl << 0,0.06,0;
//read pose file
FILE* pose_stamped = fopen(argv[1],"r");
if (!pose_stamped)
return 1;
char buffer[2048];
std::vector<Mat3> rotations;
std::vector<Eigen::Vector3d> translations;
while (fgets(buffer,2048,pose_stamped)) {
double t,x,y,z,qx,qy,qz,qw;
if (sscanf(buffer,"%lf %lf %lf %lf %lf %lf %lf %lf",&t,&x,&y,&z,&qw,&qx,&qy,&qz)==8) {
double r[9];
quaternionToRotation(qx,qy,qz,qw,r);
Mat3 Rwl;
memcpy(Rwl.data(),r,9*sizeof(double));
Eigen::Vector3d Twl(x,y,z);
rotations.push_back(Rcl * Rwl.transpose());
translations.push_back(- Rcl * Rwl.transpose() * Twl + Tcl);
} else {
printf("Error parsing: %s\n",buffer);
}
}
fclose(pose_stamped);
struct timespec start,end;
clock_gettime(CLOCK_MONOTONIC,&start);
int count_points = 0;
double RMSE = 0;
FILE* key_match = fopen(argv[2],"r");
FILE* map_point = fopen(argv[3],"w");
if (!(key_match && map_point))
return 1;
while (fgets(buffer,2048,key_match)) {
#if DEBUG_SINGLE
printf("key.match: %s",buffer);
#endif
int id;
char* tok = strtok(buffer," ");
std::vector<double> uc,vc;
std::vector<int> index;
while (tok) {
id = atoi(tok);
index.push_back(id);
tok = strtok(NULL," \n");
double u = atof(tok);
tok = strtok(NULL," \n");
double v = atof(tok);
tok = strtok(NULL," \n");
uc.push_back(u - cx);
vc.push_back(cy - v);
}
//optimize
Eigen::Vector3d bestEstimate, x1, x2;
double leastError = -1;
for (unsigned int i=0;i<index.size()-1;i++) {
for (unsigned int j=i+1;j<index.size();j++) {
double u1 = uc[i], v1 = vc[i];
double u2 = uc[j], v2 = vc[j];
Mat3 R1 = rotations[index[i]], R2 = rotations[index[j]];
Eigen::Vector3d T1 = translations[index[i]], T2 = translations[index[j]];
Mat3 Rcc = R2 * R1.transpose();
Eigen::Vector3d Tcc = T1 - R1 * R2.transpose() * T2;
Eigen::Vector3d r1 = Rcc.row(0), r2 = Rcc.row(1), r3 = Rcc.row(2);
Eigen::Vector3d uv(-u1/fx,-v1/fy,1);
Eigen::Vector3d mult_u = r1 + u2/fx * r3;
Eigen::Vector3d mult_v = r2 + v2/fy * r3;
double z_est[2] = {mult_u.dot(Tcc) / mult_u.dot(uv),
mult_v.dot(Tcc) / mult_v.dot(uv) } ;
for (int k=0;k<1;k++) {
x1 << -u1*z_est[k]/fx, -v1*z_est[k]/fy, z_est[k];
x2 = Rcc * (x1 - Tcc);
if (x1(2) >= 0 || x2(2) >= 0)
break;
double u_est = -fx * x2(0) / x2(2);
double v_est = -fy * x2(1) / x2(2);
double error = (u_est-u2) * (u_est-u2) + (v_est-v2) * (v_est-v2);
if (leastError < 0 || error < leastError) {
leastError = error;
bestEstimate = R1.transpose() * (x1 - T1);
}
}
}
}
//record result
RMSE += leastError;
#if DEBUG_SINGLE
printf("reprojection: ");
char* c = buffer;
c += sprintf(c,"transformation:\n");
for (unsigned int i=0;i<index.size();i++) {
id = index[i];
Eigen::Vector3d xc = rotations[id] * bestEstimate + translations[id];
double u = - fx * xc(0) / xc(2);
double v = - fy * xc(1) / xc(2);
printf("%d %f %f ",id,u+cx,cy-v);
c += sprintf(c,"%4.2f %4.2f %4.2f\n%4.2f %4.2f %4.2f\n%4.2f %4.2f %4.2f\n",
rotations[id](0,0),rotations[id](0,1),rotations[id](0,2),
rotations[id](1,0),rotations[id](1,1),rotations[id](1,2),
rotations[id](2,0),rotations[id](2,1),rotations[id](2,2));
c += sprintf(c,"[%4.2f %4.2f %4.2f]\n",translations[id](0),translations[id](1),translations[id](2));
}
printf("\n%s",buffer);
printf("estimate: %f %f %f %lu %f\n",bestEstimate(0),bestEstimate(1),bestEstimate(2),index.size(),leastError);
#endif
fprintf(map_point,"%f %f %f %lu %f\n",bestEstimate(0),bestEstimate(1),bestEstimate(2),index.size(),leastError);
count_points++;
}
clock_gettime(CLOCK_MONOTONIC,&end);
double dt = end.tv_sec - start.tv_sec + 0.000000001 * (end.tv_nsec - start.tv_nsec);
RMSE = sqrt(RMSE / count_points);
printf("Optimized %d map points (%fs, RMSE = %f)\n",count_points, dt, RMSE);
fclose(key_match);
fclose(map_point);
return 0;
}
void vpTemplateTrackerMIInverseCompositional::trackNoPyr(const vpImage<unsigned char> &I)
{
if(!CompoInitialised)
std::cout<<"Compositionnal tracking no initialised\nUse InitCompInverse(vpImage<unsigned char> &I) function"<<std::endl;
dW=0;
if(blur)
vpImageFilter::filter(I, BI,fgG,taillef);
int Nbpoint=0;
lambda=lambdaDep;
double MI=0,MIprec=-1000;
vpColVector p_avant_estimation;p_avant_estimation=p;
MI_preEstimation=-getCost(I,p);
NMI_preEstimation=-getNormalizedCost(I,p);
// std::cout << "MI avant: " << MI_preEstimation << std::endl;
// std::cout << "NMI avant: " << NMI_preEstimation << std::endl;
initPosEvalRMS(p);
vpColVector dpinv(nbParam);
double alpha=2.;
unsigned int iteration=0;
//unsigned int bspline_ = (unsigned int) bspline;
//unsigned int totParam = (bspline_ * bspline_)*(1+nbParam+nbParam*nbParam);
vpMatrix Hnorm(nbParam,nbParam);
do
{
Nbpoint=0;
MIprec=MI;
MI=0;
zeroProbabilities();
Warp->computeCoeff(p);
{
for(int point=0;point<(int)templateSize;point++)
{
vpColVector x1(2),x2(2);
double i2,j2;
double IW;
int cr,ct;
double er,et;
x1[0]=(double)ptTemplate[point].x;
x1[1]=(double)ptTemplate[point].y;
Warp->computeDenom(x1,p); // A modif pour parallelisation mais ne pose pas de pb avec warp utilises dans DECSA
Warp->warpX(x1,x2,p);
j2=x2[0];
i2=x2[1];
if((i2>=0)&&(j2>=0)&&(i2<I.getHeight()-1)&&(j2<I.getWidth()-1))
{
//if(m_ptCurrentMask == NULL ||(m_ptCurrentMask->getWidth() == I.getWidth() && m_ptCurrentMask->getHeight() == I.getHeight() && (*m_ptCurrentMask)[(unsigned int)i2][(unsigned int)j2] > 128))
{
Nbpoint++;
if(!blur)
IW=(double)I.getValue(i2,j2);
else
IW=BI.getValue(i2,j2);
ct=ptTemplateSupp[point].ct;
et=ptTemplateSupp[point].et;
double tmp = IW*(((double)Nc)-1.f)/255.f;
cr=(int)tmp;
er=tmp-(double)cr;
if( (ApproxHessian==HESSIAN_NONSECOND||hessianComputation==vpTemplateTrackerMI::USE_HESSIEN_DESIRE) && (ptTemplateSelect[point] || !useTemplateSelect) )
{
vpTemplateTrackerMIBSpline::PutTotPVBsplineNoSecond(Prt, dPrt, cr, er, ct, et, Ncb, ptTemplate[point].dW, nbParam, bspline);
}
else if (ptTemplateSelect[point] || !useTemplateSelect)
{
if(bspline==3){
vpTemplateTrackerMIBSpline::PutTotPVBspline3(Prt, dPrt, d2Prt, cr, er, ct, et, Ncb, ptTemplate[point].dW, nbParam);
}
else{
vpTemplateTrackerMIBSpline::PutTotPVBspline4(Prt, dPrt, d2Prt, cr, er, ct, et, Ncb, ptTemplate[point].dW, nbParam);
}
}
else{
vpTemplateTrackerMIBSpline::PutTotPVBsplinePrt(Prt, cr, er, ct, et, Ncb,nbParam, bspline);
}
}
}
}
}
if(Nbpoint==0)
{
diverge=true;
MI=0;
deletePosEvalRMS();
throw(vpTrackingException(vpTrackingException::notEnoughPointError, "No points in the template"));
}
else
{
// computeProba(Nbpoint);
unsigned int indd, indd2;
indd = indd2 = 0;
unsigned int Ncb_ = (unsigned int)Ncb;
for(unsigned int i=0;i<Ncb_*Ncb_;i++){
Prt[i]=Prt[i]/Nbpoint;
for(unsigned int j=0;j<nbParam;j++){
dPrt[indd]=dPrt[indd]/Nbpoint;
indd++;
for(unsigned int k=0;k<nbParam;k++){
d2Prt[indd2]=d2Prt[indd2]/Nbpoint;
indd2++;
}
}
}
computeMI(MI);
if(hessianComputation!=vpTemplateTrackerMI::USE_HESSIEN_DESIRE){
computeHessienNormalized(Hnorm);
computeHessien(H);
}
computeGradient();
vpMatrix::computeHLM(H,lambda,HLM);
try
{
switch(hessianComputation)
{
case vpTemplateTrackerMI::USE_HESSIEN_DESIRE:
dp=gain*HLMdesireInverse*G;
break;
case vpTemplateTrackerMI::USE_HESSIEN_BEST_COND:
if(HLM.cond()>HLMdesire.cond())
dp=gain*HLMdesireInverse*G;
else
dp=gain*0.2*HLM.inverseByLU()*G;
break;
default:
dp=gain*0.2*HLM.inverseByLU()*G;
break;
}
}
catch(vpException &e)
{
//std::cerr<<"probleme inversion"<<std::endl;
throw(e);
}
}
switch(minimizationMethod)
{
case vpTemplateTrackerMIInverseCompositional::USE_LMA:
{
vpColVector dp_test_LMA(nbParam);
vpColVector dpinv_test_LMA(nbParam);
vpColVector p_test_LMA(nbParam);
if(ApproxHessian==HESSIAN_NONSECOND)
dp_test_LMA=-100000.1*dp;
else
dp_test_LMA=1.*dp;
Warp->getParamInverse(dp_test_LMA,dpinv_test_LMA);
Warp->pRondp(p,dpinv_test_LMA,p_test_LMA);
MI=-getCost(I,p);
double MI_LMA=-getCost(I,p_test_LMA);
if(MI_LMA>MI)
{
dp=dp_test_LMA;
lambda=(lambda/10.<1e-6)?lambda/10.:1e-6;
}
else
{
dp=0;
lambda=(lambda*10.<1e6)?1e6:lambda*10.;
}
}
break;
case vpTemplateTrackerMIInverseCompositional::USE_GRADIENT:
dp=-gain*0.3*G*20;
break;
case vpTemplateTrackerMIInverseCompositional::USE_QUASINEWTON:
{
double s_scal_y;
if(iterationGlobale!=0)
{
vpColVector s_quasi=p-p_prec;
vpColVector y_quasi=G-G_prec;
s_scal_y=s_quasi.t()*y_quasi;
//std::cout<<"mise a jour K"<<std::endl;
/*if(s_scal_y!=0)//BFGS
KQuasiNewton=KQuasiNewton+0.01*(-(s_quasi*y_quasi.t()*KQuasiNewton+KQuasiNewton*y_quasi*s_quasi.t())/s_scal_y+(1.+y_quasi.t()*(KQuasiNewton*y_quasi)/s_scal_y)*s_quasi*s_quasi.t()/s_scal_y);*/
//if(s_scal_y!=0)//DFP
if(std::fabs(s_scal_y) > std::numeric_limits<double>::epsilon())//DFP
{
KQuasiNewton=KQuasiNewton+0.0001*(s_quasi*s_quasi.t()/s_scal_y-KQuasiNewton*y_quasi*y_quasi.t()*KQuasiNewton/(y_quasi.t()*KQuasiNewton*y_quasi));
//std::cout<<"mise a jour K"<<std::endl;
}
}
dp=gain*KQuasiNewton*G;
//std::cout<<KQuasiNewton<<std::endl<<std::endl;
p_prec=p;
G_prec=G;
//p-=1.01*dp;
}
break;
default:
{
if(useBrent)
{
alpha=2.;
computeOptimalBrentGain(I,p,-MI,dp,alpha);
dp=alpha*dp;
}
if(ApproxHessian==HESSIAN_NONSECOND)
dp=-1.*dp;
break;
}
}
Warp->getParamInverse(dp,dpinv);
Warp->pRondp(p,dpinv,p);
iteration++;
iterationGlobale++;
computeEvalRMS(p);
// std::cout << p.t() << std::endl;
}
while( (!diverge) && (std::fabs(MI-MIprec) > std::fabs(MI)*std::numeric_limits<double>::epsilon()) &&(iteration< iterationMax)&&(evolRMS>threshold_RMS) );
//while( (!diverge) && (MI!=MIprec) &&(iteration< iterationMax)&&(evolRMS>threshold_RMS) );
nbIteration=iteration;
if(diverge)
{
if(computeCovariance){
covarianceMatrix = vpMatrix(Warp->getNbParam(),Warp->getNbParam());
covarianceMatrix = -1;
MI_postEstimation = -1;
NMI_postEstimation = -1;
}
deletePosEvalRMS();
// throw(vpTrackingException(vpTrackingException::badValue, "Tracking failed")) ;
}
else
{
MI_postEstimation=-getCost(I,p);
NMI_postEstimation=-getNormalizedCost(I,p);
// std::cout << "MI apres: " << MI_postEstimation << std::endl;
// std::cout << "NMI apres: " << NMI_postEstimation << std::endl;
if(MI_preEstimation>MI_postEstimation)
{
p=p_avant_estimation;
MI_postEstimation = MI_preEstimation;
NMI_postEstimation = NMI_preEstimation;
covarianceMatrix = vpMatrix(Warp->getNbParam(),Warp->getNbParam());
covarianceMatrix = -1;
}
deletePosEvalRMS();
if(computeCovariance){
try{
covarianceMatrix = (-H).inverseByLU();
// covarianceMatrix = (-Hnorm).inverseByLU();
}
catch(...){
covarianceMatrix = vpMatrix(Warp->getNbParam(),Warp->getNbParam());
covarianceMatrix = -1;
MI_postEstimation = -1;
NMI_postEstimation = -1;
deletePosEvalRMS();
}
}
}
}
void Ellipse_n::perform(){
QVector<double> x(100*a*2+1), y(100*a*2+1); // initialize with entries 0..100
double w = -a;
int count = 0;
for (int i=0; w<a; ++i)
{
x[i] = w; // let's plot a quadratic function
y[i] = b*sqrt((1) - ((x[i]*x[i]) / (a*a)));
count++;
w+=0.01;
}
if (x[x.size()-1] != a){
x[x.size()-1] = a;
y[x.size()-1] = b*sqrt((1) - ((x[x.size()-1]*x[x.size()-1]) / (a*a)));
}
QVector<double> x1(100*a*2+1), y1(100*a*2+1); // initialize with entries 0..100
w = -a;
for (int i=0; w<a; ++i)
{
x1[i] = w; // let's plot a quadratic function
y1[i] = (-b)*sqrt((1) - ((x[i]*x[i]) / (a*a)));
w+=0.01;
}
if (x1[x1.size()-1] != a){
x1[x1.size()-1] = a;
y1[x1.size()-1] = (-b)*sqrt((1) - ((x[x1.size()-1]*x[x1.size()-1]) / (a*a)));
}
xg = x;
yg = y;
xg1 = x1;
yg1 = y1;
for (int i = 0; i<100*a*2 + 1; i ++){
xg[i] = xg[i] + Xc;
yg[i] = (yg[i] + Yc);
xg1[i] = xg1[i] + Xc;
yg1[i] = yg1[i] + Yc;
}
}
void benchmark_scan(
const vex::Context &ctx, vex::profiler<> &prof
)
{
const size_t N = 16 * 1024 * 1024;
const size_t M = 16;
typedef typename std::conditional<
std::is_same<float, real>::value, cl_uint, cl_ulong
>::type key_type;
std::default_random_engine rng( std::rand() );
std::uniform_int_distribution<key_type> rnd;
std::vector<key_type> x0(N);
std::vector<key_type> x1(N);
std::generate(x0.begin(), x0.end(), [&]() { return rnd(rng); });
vex::vector<key_type> X0(ctx, x0);
vex::vector<key_type> X1(ctx, N);
vex::exclusive_scan(X0, X1);
ctx.finish();
prof.tic_cpu("VexCL");
for(size_t i = 0; i < M; i++)
vex::exclusive_scan(X0, X1);
ctx.finish();
double tot_time = prof.toc("VexCL");
std::cout
<< "Scan (" << vex::type_name<key_type>() << ")\n"
<< " VexCL: " << N * M / tot_time << " keys/sec\n";
#ifdef HAVE_BOOST_COMPUTE
vex::compute::exclusive_scan(X0, X1);
ctx.finish();
prof.tic_cpu("Boost.Compute");
for(size_t i = 0; i < M; i++)
vex::compute::exclusive_scan(X0, X1);
ctx.finish();
tot_time = prof.toc("Boost.Compute");
std::cout
<< " Boost.Compute: " << N * M / tot_time << " keys/sec\n";
#endif
#ifdef HAVE_CLOGS
vex::clogs::exclusive_scan(X0, X1);
ctx.finish();
prof.tic_cpu("CLOGS");
for(size_t i = 0; i < M; i++)
vex::clogs::exclusive_scan(X0, X1);
ctx.finish();
tot_time = prof.toc("CLOGS");
std::cout
<< " CLOGS: " << N * M / tot_time << " keys/sec\n";
#endif
if (options.bm_cpu) {
prof.tic_cpu("CPU");
for(size_t i = 0; i < M; i++) {
key_type sum = key_type();
for(size_t j = 0; j < N; ++j) {
key_type next = sum + x0[j];
x1[j] = sum;
sum = next;
}
}
tot_time = prof.toc("CPU");
std::cout << " CPU: " << N * M / tot_time << " keys/sec\n";
}
std::cout << std::endl;
}
int checkResults( bool trans,
Epetra_LinearProblemRedistor * redistor,
Epetra_LinearProblem * A,
Epetra_LinearProblem * R,
bool verbose) {
int m = A->GetRHS()->MyLength();
int n = A->GetLHS()->MyLength();
assert( m == n ) ;
Epetra_MultiVector *x = A->GetLHS() ;
Epetra_MultiVector x1( *x ) ;
// Epetra_MultiVector Difference( x1 ) ;
Epetra_MultiVector *b = A->GetRHS();
Epetra_RowMatrix *matrixA = A->GetMatrix();
assert( matrixA != 0 ) ;
int iam = matrixA->Comm().MyPID();
// Epetra_Time timer(A->Comm());
// double start = timer.ElapsedTime();
matrixA->Multiply(trans, *b, x1) ; // x = Ab
int M,N,nz;
int *ptr, *ind;
double *val, *rhs, *lhs;
int Nrhs, ldrhs, ldlhs;
redistor->ExtractHbData( M, N, nz, ptr, ind,
val, Nrhs, rhs, ldrhs,
lhs, ldlhs);
assert( M == N ) ;
if ( verbose ) {
cout << " iam = " << iam
<< " m = " << m << " n = " << n << " M = " << M << endl ;
cout << " iam = " << iam << " ptr = " << ptr[0] << " " << ptr[1] << " " << ptr[2] << " " << ptr[3] << " " << ptr[4] << " " << ptr[5] << endl ;
cout << " iam = " << iam << " ind = " << ind[0] << " " << ind[1] << " " << ind[2] << " " << ind[3] << " " << ind[4] << " " << ind[5] << endl ;
cout << " iam = " << iam << " val = " << val[0] << " " << val[1] << " " << val[2] << " " << val[3] << " " << val[4] << " " << val[5] << endl ;
}
// Create a serial map in case we end up needing it
// If it is created inside the else block below it would have to
// be with a call to new().
int NumMyElements_ = 0 ;
if (matrixA->Comm().MyPID()==0) NumMyElements_ = n;
Epetra_Map SerialMap( n, NumMyElements_, 0, matrixA->Comm() );
// These are unnecessary and useless
// Epetra_Vector serial_A_rhs( SerialMap ) ;
// Epetra_Vector serial_A_lhs( SerialMap ) ;
// Epetra_Export exporter( matrixA->BlockRowMap(), SerialMap) ;
//
// In each process, we will compute Rb putting the answer into LHS
//
for ( int k = 0 ; k < Nrhs; k ++ ) {
for ( int i = 0 ; i < M ; i ++ ) {
lhs[ i + k * ldlhs ] = 0.0;
}
for ( int i = 0 ; i < M ; i++ ) {
for ( int l = ptr[i]; l < ptr[i+1]; l++ ) {
int j = ind[l] ;
if ( verbose && N < 40 ) {
cout << " i = " << i << " j = " << j ;
cout << " l = " << l << " val[l] = " << val[l] ;
cout << " rhs = " << rhs[ j + k * ldrhs ] << endl ;
}
lhs[ i + k * ldrhs ] += val[l] * rhs[ j + k * ldrhs ] ;
}
}
if ( verbose && N < 40 ) {
cout << " lhs = " ;
for ( int j = 0 ; j < N ; j++ ) cout << " " << lhs[j] ;
cout << endl ;
cout << " rhs = " ;
for ( int j = 0 ; j < N ; j++ ) cout << " " << rhs[j] ;
cout << endl ;
}
const Epetra_Comm &comm = matrixA->Comm() ;
#ifdef HAVE_COMM_ASSERT_EQUAL
//
// Here we double check to make sure that lhs and rhs are
// replicated.
//
for ( int j = 0 ; j < N ; j++ ) {
assert( Comm_assert_equal( &comm, lhs[ j + k * ldrhs ] ) ) ;
assert( Comm_assert_equal( &comm, rhs[ j + k * ldrhs ] ) ) ;
}
#endif
}
//
// Now we have to redistribue them back
//
redistor->UpdateOriginalLHS( A->GetLHS() ) ;
//
// Now we want to compare x and x1 which have been computed as follows:
// x = Rb
// x1 = Ab
//
double Norm_x1, Norm_diff ;
EPETRA_CHK_ERR( x1.Norm2( &Norm_x1 ) ) ;
// cout << " x1 = " << x1 << endl ;
// cout << " *x = " << *x << endl ;
x1.Update( -1.0, *x, 1.0 ) ;
EPETRA_CHK_ERR( x1.Norm2( &Norm_diff ) ) ;
// cout << " diff, i.e. updated x1 = " << x1 << endl ;
int ierr = 0;
if ( verbose ) {
cout << " Norm_diff = " << Norm_diff << endl ;
cout << " Norm_x1 = " << Norm_x1 << endl ;
}
if ( Norm_diff / Norm_x1 > n * error_tolerance ) ierr++ ;
if (ierr!=0 && verbose) cerr << "Status: Test failed" << endl;
else if (verbose) cerr << "Status: Test passed" << endl;
return(ierr);
}
void bi::DOPRI5IntegratorSSE<B,S,T1>::update(const T1 t1, const T1 t2,
State<B,ON_HOST>& s) {
/* pre-condition */
BI_ASSERT(t1 < t2);
typedef host_vector_reference<sse_real> vector_reference_type;
typedef Pa<ON_HOST,B,host,host,sse_host,sse_host> PX;
typedef DOPRI5VisitorHost<B,S,S,real,PX,sse_real> Visitor;
static const int N = block_size<S>::value;
const int P = s.size();
#pragma omp parallel
{
sse_real buf[10*N];
vector_reference_type x0(buf, N);
vector_reference_type x1(buf + N, N);
vector_reference_type x2(buf + 2*N, N);
vector_reference_type x3(buf + 3*N, N);
vector_reference_type x4(buf + 4*N, N);
vector_reference_type x5(buf + 5*N, N);
vector_reference_type x6(buf + 6*N, N);
vector_reference_type err(buf + 7*N, N);
vector_reference_type k1(buf + 8*N, N);
vector_reference_type k7(buf + 9*N, N);
sse_real e, e2;
real t, h, logfacold, logfac11, fac, e2max;
int n, id, p;
bool k1in;
PX pax;
#pragma omp for
for (p = 0; p < P; p += BI_SSE_SIZE) {
t = t1;
h = h_h0;
logfacold = bi::log(BI_REAL(1.0e-4));
k1in = false;
n = 0;
sse_host_load<B,S>(s, p, x0);
/* integrate */
while (t < t2 && n < h_nsteps) {
if (BI_REAL(0.1)*bi::abs(h) <= bi::abs(t)*h_uround) {
// step size too small
}
if (t + BI_REAL(1.01)*h - t2 > BI_REAL(0.0)) {
h = t2 - t;
if (h <= BI_REAL(0.0)) {
t = t2;
break;
}
}
/* stages */
Visitor::stage1(t, h, s, p, pax, x0.buf(), x1.buf(), x2.buf(), x3.buf(), x4.buf(), x5.buf(), x6.buf(), k1.buf(), err.buf(), k1in);
k1in = true; // can reuse from previous iteration in future
sse_host_store<B,S>(s, p, x1);
Visitor::stage2(t, h, s, p, pax, x0.buf(), x2.buf(), x3.buf(), x4.buf(), x5.buf(), x6.buf(), err.buf());
sse_host_store<B,S>(s, p, x2);
Visitor::stage3(t, h, s, p, pax, x0.buf(), x3.buf(), x4.buf(), x5.buf(), x6.buf(), err.buf());
sse_host_store<B,S>(s, p, x3);
Visitor::stage4(t, h, s, p, pax, x0.buf(), x4.buf(), x5.buf(), x6.buf(), err.buf());
sse_host_store<B,S>(s, p, x4);
Visitor::stage5(t, h, s, p, pax, x0.buf(), x5.buf(), x6.buf(), err.buf());
sse_host_store<B,S>(s, p, x5);
Visitor::stage6(t, h, s, p, pax, x0.buf(), x6.buf(), err.buf());
/* compute error */
Visitor::stageErr(t, h, s, p, pax, x0.buf(), x6.buf(), k7.buf(), err.buf());
/* determine largest error among trajectories */
e2 = BI_REAL(0.0);
for (id = 0; id < N; ++id) {
e = err[id]*h/(bi::max(bi::abs(x0(id)), bi::abs(x6(id)))*h_rtoler + h_atoler);
e2 += e*e;
}
#ifdef ENABLE_SINGLE
e2max = bi::max(bi::max(e2.unpacked.a, e2.unpacked.b), bi::max(e2.unpacked.c, e2.unpacked.d));
#else
e2max = bi::max(e2.unpacked.a, e2.unpacked.b);
#endif
e2max /= N;
if (e2max <= BI_REAL(1.0)) {
/* accept */
t += h;
x0.swap(x6);
k1.swap(k7);
}
sse_host_store<B,S>(s, p, x0);
/* compute next step size */
if (t < t2) {
logfac11 = h_expo*bi::log(e2max);
if (e2max > BI_REAL(1.0)) {
/* step was rejected */
h *= bi::max(h_facl, bi::exp(h_logsafe - logfac11));
} else {
/* step was accepted */
fac = bi::exp(h_beta*logfacold + h_logsafe - logfac11); // Lund-stabilization
fac = bi::min(h_facr, bi::max(h_facl, fac)); // bound
h *= fac;
logfacold = BI_REAL(0.5)*bi::log(bi::max(e2max, BI_REAL(1.0e-8)));
}
}
++n;
}
}
}
}
void bi::DOPRI5IntegratorHost<B,S,T1>::update(const T1 t1, const T1 t2,
State<B,ON_HOST>& s) {
/* pre-condition */
BI_ASSERT(t1 < t2);
typedef typename temp_host_vector<real>::type vector_type;
typedef Pa<ON_HOST,B,host,host,host,host> PX;
typedef DOPRI5VisitorHost<B,S,S,real,PX,real> Visitor;
static const int N = block_size<S>::value;
const int P = s.size();
#pragma omp parallel
{
vector_type x0(N), x1(N), x2(N), x3(N), x4(N), x5(N), x6(N), err(N), k1(
N), k7(N);
real t, h, e, e2, logfacold, logfac11, fac;
int n, id, p;
bool k1in;
PX pax;
#pragma omp for
for (p = 0; p < P; ++p) {
t = t1;
h = h_h0;
logfacold = bi::log(BI_REAL(1.0e-4));
k1in = false;
n = 0;
host_load<B,S>(s, p, x0);
/* integrate */
while (t < t2 && n < h_nsteps) {
if (BI_REAL(0.1)*bi::abs(h) <= bi::abs(t)*h_uround) {
// step size too small
}
if (t + BI_REAL(1.01)*h - t2 > BI_REAL(0.0)) {
h = t2 - t;
if (h <= BI_REAL(0.0)) {
t = t2;
break;
}
}
/* stages */
Visitor::stage1(t, h, s, p, pax, x0.buf(), x1.buf(), x2.buf(), x3.buf(), x4.buf(), x5.buf(), x6.buf(), k1.buf(), err.buf(), k1in);
k1in = true; // can reuse from previous iteration in future
host_store<B,S>(s, p, x1);
Visitor::stage2(t, h, s, p, pax, x0.buf(), x2.buf(), x3.buf(), x4.buf(), x5.buf(), x6.buf(), err.buf());
host_store<B,S>(s, p, x2);
Visitor::stage3(t, h, s, p, pax, x0.buf(), x3.buf(), x4.buf(), x5.buf(), x6.buf(), err.buf());
host_store<B,S>(s, p, x3);
Visitor::stage4(t, h, s, p, pax, x0.buf(), x4.buf(), x5.buf(), x6.buf(), err.buf());
host_store<B,S>(s, p, x4);
Visitor::stage5(t, h, s, p, pax, x0.buf(), x5.buf(), x6.buf(), err.buf());
host_store<B,S>(s, p, x5);
Visitor::stage6(t, h, s, p, pax, x0.buf(), x6.buf(), err.buf());
/* compute error */
Visitor::stageErr(t, h, s, p, pax, x0.buf(), x6.buf(), k7.buf(), err.buf());
e2 = 0.0;
for (id = 0; id < N; ++id) {
e = err(id)*h/(h_atoler + h_rtoler*bi::max(bi::abs(x0(id)), bi::abs(x6(id))));
e2 += e*e;
}
e2 /= N;
/* accept/reject */
if (e2 <= BI_REAL(1.0)) {
/* accept */
t += h;
x0.swap(x6);
k1.swap(k7);
}
host_store<B,S>(s, p, x0);
/* compute next step size */
if (t < t2) {
logfac11 = h_expo*bi::log(e2);
if (e2 > BI_REAL(1.0)) {
/* step was rejected */
h *= bi::max(h_facl, bi::exp(h_logsafe - logfac11));
} else {
/* step was accepted */
fac = bi::exp(h_beta*logfacold + h_logsafe - logfac11); // Lund-stabilization
fac = bi::min(h_facr, bi::max(h_facl, fac));// bound
h *= fac;
logfacold = BI_REAL(0.5)*bi::log(bi::max(e2, BI_REAL(1.0e-8)));
}
}
++n;
}
}
}
}
// ----------------------------------------------------------------------------
// Handles the action [id].
// Returns true if the action was handled, false otherwise
// ----------------------------------------------------------------------------
bool GfxEntryPanel::handleEntryPanelAction(std::string_view id)
{
// We're only interested in "pgfx_" actions
if (!StrUtil::startsWith(id, "pgfx_"))
return false;
// For pgfx_brush actions, the string after pgfx is a brush name
if (StrUtil::startsWith(id, "pgfx_brush"))
{
gfx_canvas_->setBrush(SBrush::get(std::string{ id }));
button_brush_->setIcon(StrUtil::afterFirst(id, '_'));
}
// Editing - drag mode
else if (id == "pgfx_drag")
{
editing_ = false;
gfx_canvas_->setEditingMode(GfxCanvas::EditMode::None);
}
// Editing - draw mode
else if (id == "pgfx_draw")
{
editing_ = true;
gfx_canvas_->setEditingMode(GfxCanvas::EditMode::Paint);
gfx_canvas_->setPaintColour(cb_colour_->colour());
}
// Editing - erase mode
else if (id == "pgfx_erase")
{
editing_ = true;
gfx_canvas_->setEditingMode(GfxCanvas::EditMode::Erase);
}
// Editing - translate mode
else if (id == "pgfx_magic")
{
editing_ = true;
gfx_canvas_->setEditingMode(GfxCanvas::EditMode::Translate);
}
// Editing - set translation
else if (id == "pgfx_settrans")
{
// Create translation editor dialog
TranslationEditorDialog ted(
theMainWindow, *theMainWindow->paletteChooser()->selectedPalette(), " Colour Remap", image());
// Create translation to edit
ted.openTranslation(edit_translation_);
// Show the dialog
if (ted.ShowModal() == wxID_OK)
{
// Set the translation
edit_translation_.copy(ted.getTranslation());
gfx_canvas_->setTranslation(&edit_translation_);
}
}
// Editing - set brush
else if (id == "pgfx_setbrush")
{
auto p = button_brush_->GetScreenPosition() -= GetScreenPosition();
p.y += button_brush_->GetMaxHeight();
PopupMenu(menu_brushes_, p);
}
// Mirror
else if (id == "pgfx_mirror")
{
// Mirror X
image()->mirror(false);
// Update UI
gfx_canvas_->updateImageTexture();
gfx_canvas_->Refresh();
// Update variables
image_data_modified_ = true;
setModified();
}
// Flip
else if (id == "pgfx_flip")
{
// Mirror Y
image()->mirror(true);
// Update UI
gfx_canvas_->updateImageTexture();
gfx_canvas_->Refresh();
// Update variables
image_data_modified_ = true;
setModified();
}
// Rotate
else if (id == "pgfx_rotate")
{
// Prompt for rotation angle
wxString angles[] = { "90", "180", "270" };
int choice = wxGetSingleChoiceIndex("Select rotation angle", "Rotate", 3, angles, 0);
// Rotate image
switch (choice)
{
case 0: image()->rotate(90); break;
case 1: image()->rotate(180); break;
case 2: image()->rotate(270); break;
default: break;
}
// Update UI
gfx_canvas_->updateImageTexture();
gfx_canvas_->Refresh();
// Update variables
image_data_modified_ = true;
setModified();
}
// Translate
else if (id == "pgfx_remap")
{
// Create translation editor dialog
auto pal = MainEditor::currentPalette();
TranslationEditorDialog ted(theMainWindow, *pal, " Colour Remap", &gfx_canvas_->image());
// Create translation to edit
ted.openTranslation(prev_translation_);
// Show the dialog
if (ted.ShowModal() == wxID_OK)
{
// Apply translation to image
image()->applyTranslation(&ted.getTranslation(), pal);
// Update UI
gfx_canvas_->updateImageTexture();
gfx_canvas_->Refresh();
// Update variables
image_data_modified_ = true;
gfx_canvas_->updateImageTexture();
setModified();
prev_translation_.copy(ted.getTranslation());
}
}
// Colourise
else if (id == "pgfx_colourise")
{
auto pal = MainEditor::currentPalette();
GfxColouriseDialog gcd(theMainWindow, entry_, *pal);
gcd.setColour(last_colour);
// Show colourise dialog
if (gcd.ShowModal() == wxID_OK)
{
// Colourise image
image()->colourise(gcd.colour(), pal);
// Update UI
gfx_canvas_->updateImageTexture();
gfx_canvas_->Refresh();
// Update variables
image_data_modified_ = true;
Refresh();
setModified();
}
last_colour = gcd.colour().toString(ColRGBA::StringFormat::RGB);
}
// Tint
else if (id == "pgfx_tint")
{
auto pal = MainEditor::currentPalette();
GfxTintDialog gtd(theMainWindow, entry_, *pal);
gtd.setValues(last_tint_colour, last_tint_amount);
// Show tint dialog
if (gtd.ShowModal() == wxID_OK)
{
// Tint image
image()->tint(gtd.colour(), gtd.amount(), pal);
// Update UI
gfx_canvas_->updateImageTexture();
gfx_canvas_->Refresh();
// Update variables
image_data_modified_ = true;
Refresh();
setModified();
}
last_tint_colour = gtd.colour().toString(ColRGBA::StringFormat::RGB);
last_tint_amount = (int)(gtd.amount() * 100.0);
}
// Crop
else if (id == "pgfx_crop")
{
auto image = this->image();
auto pal = MainEditor::currentPalette();
GfxCropDialog gcd(theMainWindow, image, pal);
// Show crop dialog
if (gcd.ShowModal() == wxID_OK)
{
// Prompt to adjust offsets
auto crop = gcd.cropRect();
if (crop.tl.x > 0 || crop.tl.y > 0)
{
if (wxMessageBox(
"Do you want to adjust the offsets? This will keep the graphic in the same relative "
"position it was before cropping.",
"Adjust Offsets?",
wxYES_NO)
== wxYES)
{
image->setXOffset(image->offset().x - crop.tl.x);
image->setYOffset(image->offset().y - crop.tl.y);
}
}
// Crop image
image->crop(crop.x1(), crop.y1(), crop.x2(), crop.y2());
// Update UI
gfx_canvas_->updateImageTexture();
gfx_canvas_->Refresh();
// Update variables
image_data_modified_ = true;
Refresh();
setModified();
}
}
// alPh/tRNS
else if (id == "pgfx_alph" || id == "pgfx_trns")
{
setModified();
Refresh();
}
// Optimize PNG
else if (id == "pgfx_pngopt")
{
// This is a special case. If we set the entry as modified, SLADE will prompt
// to save it, rewriting the entry and cancelling the optimization done...
if (EntryOperations::optimizePNG(entry_))
setModified(false);
else
wxMessageBox(
"Warning: Couldn't optimize this image, check console log for info",
"Warning",
wxOK | wxCENTRE | wxICON_WARNING);
Refresh();
}
// Extract all
else if (id == "pgfx_extract")
{
extractAll();
}
// Convert
else if (id == "pgfx_convert")
{
GfxConvDialog gcd(theMainWindow);
gcd.CenterOnParent();
gcd.openEntry(entry_);
gcd.ShowModal();
if (gcd.itemModified(0))
{
// Get image and conversion info
auto image = gcd.itemImage(0);
auto format = gcd.itemFormat(0);
// Write converted image back to entry
format->saveImage(*image, entry_data_, gcd.itemPalette(0));
// This makes the "save" button (and the setModified stuff) redundant and confusing!
// The alternative is to save to entry effectively (uncomment the importMemChunk line)
// but remove the setModified and image_data_modified lines, and add a call to refresh
// to get the PNG tRNS status back in sync.
// entry->importMemChunk(entry_data);
image_data_modified_ = true;
setModified();
// Fix tRNS status if we converted to paletted PNG
int MENU_GFXEP_PNGOPT = SAction::fromId("pgfx_pngopt")->wxId();
int MENU_GFXEP_ALPH = SAction::fromId("pgfx_alph")->wxId();
int MENU_GFXEP_TRNS = SAction::fromId("pgfx_trns")->wxId();
int MENU_ARCHGFX_EXPORTPNG = SAction::fromId("arch_gfx_exportpng")->wxId();
if (format->name() == "PNG")
{
ArchiveEntry temp;
temp.importMemChunk(entry_data_);
temp.setType(EntryType::fromId("png"));
menu_custom_->Enable(MENU_GFXEP_ALPH, true);
menu_custom_->Enable(MENU_GFXEP_TRNS, true);
menu_custom_->Check(MENU_GFXEP_TRNS, EntryOperations::gettRNSChunk(&temp));
menu_custom_->Enable(MENU_ARCHGFX_EXPORTPNG, false);
menu_custom_->Enable(MENU_GFXEP_PNGOPT, true);
toolbar_->enableGroup("PNG", true);
}
else
{
menu_custom_->Enable(MENU_GFXEP_ALPH, false);
menu_custom_->Enable(MENU_GFXEP_TRNS, false);
menu_custom_->Enable(MENU_ARCHGFX_EXPORTPNG, true);
menu_custom_->Enable(MENU_GFXEP_PNGOPT, false);
toolbar_->enableGroup("PNG", false);
}
// Refresh
this->image()->open(entry_data_, 0, format->id());
gfx_canvas_->Refresh();
}
}
// Unknown action
else
return false;
// Action handled
return true;
}
template<class _t, class _rt, class _it> _t rect<_t, _rt, _it>::center_x() const {
return (x0() + x1()) / 2;
}