ImLine ObjectClusterer::FitLine2D(const vecPairOfPixels& connPixels)
{
const int itv = smax(connPixels.size()/20, 1);
ImRect range(connPixels[0].first.x,connPixels[0].first.x,connPixels[0].first.y,connPixels[0].first.y);
int szcnt=0;
for(size_t i=0; i<connPixels.size(); i+=itv)
{
range.ExpandRange(connPixels[i].first);
range.ExpandRange(connPixels[i].second);
szcnt++;
}
assert(smax(range.xh - range.xl, range.yh - range.yl) > 1);
Eigen::MatrixXf A(szcnt, 2);
Eigen::VectorXf s(2);
Eigen::VectorXf b(szcnt);
ImLine line;
if(range.xh - range.xl > range.yh - range.yl)
{
int cnt=0;
for(size_t i=0; i<connPixels.size(); i+=itv)
{
A(cnt,0) = (connPixels[i].first.x + connPixels[i].second.x)/2.f;
A(cnt,1) = 1.f;
b(cnt) = (connPixels[i].first.y + connPixels[i].second.y)/2.f;
cnt++;
}
// y = s(0)*x + s(1) => -s(0)*x + y = s(1)
s = A.colPivHouseholderQr().solve(b);
line.a = -s(0);
line.b = 1.f;
line.c = s(1);
// line.endPixels[0] = (cl_int2){range.xl, (int)(s(0)*range.xl + s(1))};
// line.endPixels[1] = (cl_int2){range.xh, (int)(s(0)*range.xh + s(1))};
line.endPixels[0] = (cl_int2){range.xl, line.GetY(range.xl)};
line.endPixels[1] = (cl_int2){range.xh, line.GetY(range.xh)};
}
else
{
int cnt=0;
for(size_t i=0; i<connPixels.size(); i+=itv)
{
A(cnt,0) = (connPixels[i].first.y + connPixels[i].second.y)/2.f;
A(cnt,1) = 1.f;
b(cnt) = (connPixels[i].first.x + connPixels[i].second.x)/2.f;
cnt++;
}
// x = s(0)*y + s(1) => x + -s(0)*y = s(1)
s = A.colPivHouseholderQr().solve(b);
line.a = 1.f;
line.b = -s(0);
line.c = s(1);
// line.endPixels[0] = (cl_int2){(int)(s(0)*range.yl + s(1)), range.yl};
// line.endPixels[1] = (cl_int2){(int)(s(0)*range.yh + s(1)), range.yh};
line.endPixels[0] = (cl_int2){line.GetX(range.yl), range.yl};
line.endPixels[1] = (cl_int2){line.GetX(range.yh), range.yh};
}
return line;
}
//------------------------------------------------------------------------------
void FunMax::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc)
{
if (a_iArgc < 1)
throw ParserError(ErrorContext(ecTOO_FEW_PARAMS, GetExprPos(), GetIdent()));
float_type smax(-1e30), sval(0);
for (int i=0; i<a_iArgc; ++i)
{
switch(a_pArg[i]->GetType())
{
case 'f': sval = a_pArg[i]->GetFloat(); break;
case 'i': sval = a_pArg[i]->GetFloat(); break;
case 'n': break; // ignore not in list entries (missing parameter)
case 'c':
default:
{
ErrorContext err;
err.Errc = ecTYPE_CONFLICT_FUN;
err.Arg = i+1;
err.Type1 = a_pArg[i]->GetType();
err.Type2 = 'f';
throw ParserError(err);
}
}
smax = max(smax, sval);
}
*ret = smax;
}
cl_int2 ObjectClusterer::SearchValidPixelOnLine(const ImLine& border, const cl_int2& centerPixel, const int firstID, const int secondID)
{
int majorAxis=0, minorAxis=1;
if(border.IsXAxisMajor()==false)
{
majorAxis=1;
minorAxis=0;
}
cl_int2 linePixel = centerPixel;
int pxidx, move=1;
int rangeMin = smin(border.endPixels[0].s[majorAxis], border.endPixels[1].s[majorAxis]);
int rangeMax = smax(border.endPixels[0].s[majorAxis], border.endPixels[1].s[majorAxis]);
cl_float4 coef = (cl_float4){border.a, border.b, border.c, 0.f};
while(linePixel.s[majorAxis] >= rangeMin && linePixel.s[majorAxis] <= rangeMax)
{
linePixel.s[majorAxis] = centerPixel.s[majorAxis]-move;
linePixel.s[minorAxis] = (int)(-coef.s[majorAxis]/coef.s[minorAxis]*linePixel.s[majorAxis] + coef.s[2]/coef.s[minorAxis]);
pxidx = PIXIDX(linePixel);
if(nullityMap[pxidx] < NullID::PointNull && (objectMap[pxidx]==firstID || objectMap[pxidx]==secondID))
return linePixel;
linePixel.s[majorAxis] = centerPixel.s[majorAxis]+move;
linePixel.s[minorAxis] = (int)(-coef.s[majorAxis]/coef.s[minorAxis]*linePixel.s[majorAxis] + coef.s[2]/coef.s[minorAxis]);
pxidx = PIXIDX(linePixel);
if(nullityMap[pxidx] < NullID::PointNull && (objectMap[pxidx]==firstID || objectMap[pxidx]==secondID))
return linePixel;
move++;
}
throw 1;
return centerPixel;
}
int test_macros(void)
{
ASSERT_EQ(bits(256), 32);
ASSERT_EQ(bytes(32), 256);
ASSERT_EQ(smin(1, 2), 1);
ASSERT_EQ(smax(1, 2), 2);
return 1;
}
bool ObjectClusterer::DetermineConvexity(const Segment& firstPlane, const Segment& secondPlane)
{
float relativeHeight;
if(firstPlane.numpt > secondPlane.numpt*3)
relativeHeight = HeightFromPlane(secondPlane, firstPlane);
else if(secondPlane.numpt > firstPlane.numpt*3)
relativeHeight = HeightFromPlane(firstPlane, secondPlane);
else
{
float relativeHeight1to2 = HeightFromPlane(secondPlane, firstPlane);
float relativeHeight2to1 = HeightFromPlane(firstPlane, secondPlane);
relativeHeight = smax(relativeHeight1to2, relativeHeight2to1);
}
const float convexityHeight = smax(DEPTH(firstPlane.center)*DEPTH(secondPlane.center)*0.015f, 0.007f);
#ifdef DEBUG_ObjectClusterBase
heights.back().first = relativeHeight;
heights.back().second = convexityHeight;
#endif
return (relativeHeight > convexityHeight);
}
int find(int *num,int l,int r)
{
int *maxi,*maxj,maxl,maxr,maxm;
if (l==r)
return num[l];
maxi=(int *)malloc(sizeof(int));
maxj=(int *)malloc(sizeof(int));
maxl=find(num,l,(l+r)/2);
maxr=find(num,(l+r)/2+1,r);
maxm=smax(num,l,r,maxi,maxj);
return max(max(maxl,maxr),maxm);
}
/// Set the first saturation to either its min or max value in
/// the indicated cells. The second saturation value s2 is set
/// to (1.0 - s1) for each cell. Any further saturation values
/// are unchanged.
void setFirstSat(const std::vector<int>& cells,
const Opm::BlackoilPropertiesInterface& props,
ExtremalSat es)
{
const int n = cells.size();
std::vector<double> smin(num_phases_*n);
std::vector<double> smax(num_phases_*n);
props.satRange(n, &cells[0], &smin[0], &smax[0]);
const double* svals = (es == MinSat) ? &smin[0] : &smax[0];
for (int ci = 0; ci < n; ++ci) {
const int cell = cells[ci];
sat_[num_phases_*cell] = svals[num_phases_*ci];
sat_[num_phases_*cell + 1] = 1.0 - sat_[num_phases_*cell];
}
}
void IntervalFilter::add(uint16 from, uint16 to)
{
if (from > MAX_ID)
{
from = MAX_ID;
}
if (to > MAX_ID)
{
to = MAX_ID;
}
//assert order
if (from > to)
{
sswap(from, to);
}
//adjust lower bound
fFrom = smin(fFrom, from);
//adjust upper bound
fTo = smax(fTo, to);
}
// This file should be identical to DogSolveRK_Unst, with the exception that all
// output printing statements are silenced.
//
// Advance the solution qold to qnew over time interval tstart to tend.
//
// All local information is allocated within this function. The only part
// that gets shared are time values passed through dogStateUnst2. This class
// should be modified to accept the state variable, q and aux in place of only
// containing time information as is currently the case. (-DS)
double DogSolveRK_Unst_Quiet(
const dTensor2* vel_vec,
const mesh& Mesh, const edge_data_Unst& EdgeData,
dTensor3& aux, dTensor3& qold, dTensor3& qnew,
const double tstart, const double tend, DogStateUnst2& dogStateUnst2)
{
const int mx = qnew.getsize(1);
const int meqn = qnew.getsize(2);
const int kmax = qnew.getsize(3);
const int maux = aux.getsize(2);
const double* cflv = dogParams.get_cflv();
const int nv = dogParams.get_nv();
RKinfo rk;
SetRKinfo(dogParams.get_time_order(),rk);
// define local variables
int n_step = 0;
double t = tstart;
double dt = dogStateUnst2.get_initial_dt();
const double CFL_max = cflv[1];
const double CFL_target = cflv[2];
double cfl = 0.0;
double dtmin = dt;
double dtmax = dt;
const int NumElems = Mesh.get_NumElems(); // Number of total elements in mesh
const int NumNodes = Mesh.get_NumNodes(); // Number of nodes in mesh
const int NumEdges = Mesh.get_NumEdges(); // Number of edges in mesh
dTensor3 qstar(NumElems,meqn,kmax);
dTensor3 q1(NumElems,meqn,kmax);
dTensor3 q2(NumElems,meqn,kmax);
dTensor3 auxstar(NumElems,maux,kmax);
dTensor3 Lstar(NumElems,meqn,kmax);
dTensor3 Lold(NumElems,meqn,kmax);
dTensor3 auxold(NumElems,maux,kmax);
dTensor1 smax(NumEdges);
void L2Project_Unst(
const dTensor2* vel_vec,
const int istart, const int iend,
const int QuadOrder, const int BasisOrder_qin, const int BasisOrder_auxin, const
int BasisOrder_fout, const mesh& Mesh, const dTensor3* qin, const dTensor3*
auxin, dTensor3* fout, void (*Func)(const dTensor2* vel_vec, const
dTensor2&,const dTensor2&, const dTensor2&,dTensor2&));
// JUNK here:
void AuxFuncWrapper(
const dTensor2* vel_vec,
const dTensor2& xpts,
const dTensor2& NOT_USED_1,
const dTensor2& NOT_USED_2,
dTensor2& auxvals);
const int space_order = dogParams.get_space_order();
if( maux > 0 )
{
printf("WARNING: maux = %d should be zero for Vlasov routines.", maux);
printf(" Modify parameters.ini to remove this warning\n" );
L2Project_Unst(vel_vec,1,NumElems,
space_order,space_order,space_order,space_order,
Mesh,&qnew,&aux,&aux,&AuxFuncWrapper);
}
// Set initialize qstar and auxstar values
qstar.copyfrom(qold);
auxstar.copyfrom(aux);
// Runge-Kutta time stepping
while (t<tend)
{
// initialize time step
int m_accept = 0;
n_step = n_step + 1;
// check if max number of time steps exceeded
if( n_step > nv )
{
eprintf(" Error in DogSolveRK_Unst.cpp: "
" Exceeded allowed # of time steps \n"
" n_step = %d\n"
" nv = %d\n\n",
n_step, nv);
}
// copy qnew into qold
qold.copyfrom(qnew);
auxold.copyfrom(aux);
// keep trying until we get a dt that does not violate CFL condition
while (m_accept==0)
{
// set current time
double told = t;
if (told+dt > tend)
{ dt = tend - told; }
t = told + dt;
// TODO - this needs to be performed at the 'local' level
dogStateUnst2.set_time ( told );
dogStateUnst2.set_dt ( dt );
// Set initial maximum wave speed to zero
smax.setall(0.);
// Take a full time step of size dt
switch ( dogParams.get_time_order() )
{
case 1: // First order in time (1-stage)
// -----------------------------------------------
// Stage #1 (the only one in this case)
rk.mstage = 1;
BeforeStep_Unst(dt,Mesh,aux,qnew);
ConstructL_Unst(told, vel_vec,Mesh,EdgeData,aux,qnew,Lstar,smax);
UpdateSoln_Unst(rk.alpha1->get(rk.mstage),rk.alpha2->get(rk.mstage),
rk.beta->get(rk.mstage),dt,Mesh,aux, qnew, Lstar, qnew);
AfterStep_Unst(dt,Mesh,aux,qnew);
// -----------------------------------------------
break;
case 2: // Second order in time (2-stages)
// -----------------------------------------------
// Stage #1
rk.mstage = 1;
dogStateUnst2.set_time(told);
BeforeStep_Unst(dt,Mesh,aux,qnew);
ConstructL_Unst(told,vel_vec,Mesh,EdgeData,aux,qnew,Lstar,smax);
UpdateSoln_Unst(
rk.alpha1->get(rk.mstage),rk.alpha2->get(rk.mstage),
rk.beta->get(rk.mstage), dt, Mesh, aux, qnew, Lstar, qstar);
AfterStep_Unst(dt, Mesh, auxstar, qstar);
// ------------------------------------------------
// Stage #2
rk.mstage = 2;
dogStateUnst2.set_time(told+dt);
BeforeStep_Unst(dt, Mesh, auxstar, qstar);
ConstructL_Unst(told+1.0*dt, vel_vec, Mesh, EdgeData, aux, qstar, Lstar, smax);
UpdateSoln_Unst(rk.alpha1->get(rk.mstage), rk.alpha2->get(rk.mstage),
rk.beta->get(rk.mstage), dt, Mesh, auxstar, qstar, Lstar, qnew);
AfterStep_Unst(dt, Mesh, aux, qnew);
// ------------------------------------------------
break;
case 3: // Third order in time (3-stages)
// qnew = alpha1 * qstar + alpha2 * qnew + beta * dt * L( qstar )
// alpha1 = 1.0
// alpha2 = 0.0
// beta = 1.0
// ------------------------------------------------
// Stage #1
rk.mstage = 1;
dogStateUnst2.set_time(told);
BeforeStep_Unst(dt,Mesh,aux,qnew);
ConstructL_Unst(told, vel_vec,Mesh,EdgeData,aux,qnew,Lstar,smax);
Lold.copyfrom(Lstar);
UpdateSoln_Unst(rk.alpha1->get(rk.mstage),rk.alpha2->get(rk.mstage),
rk.beta->get(rk.mstage),dt,Mesh,aux,qnew,Lstar,qstar);
AfterStep_Unst(dt,Mesh,aux,qstar);
// -------------------------------------------------
// alpha1 = 0.75
// alpha2 = 0.25
// beta = 0.25
// Stage #2
rk.mstage = 2;
dogStateUnst2.set_time(told+0.5*dt);
BeforeStep_Unst(dt,Mesh,aux,qstar);
ConstructL_Unst(told+dt, vel_vec,Mesh,EdgeData,aux,qstar,Lstar,smax);
UpdateSoln_Unst(rk.alpha1->get(rk.mstage),rk.alpha2->get(rk.mstage),
rk.beta->get(rk.mstage),dt,Mesh,aux,qnew,Lstar,qstar);
AfterStep_Unst(dt,Mesh,aux,qstar);
// --------------------------------------------------
// alpha1 = 2/3
// alpha2 = 1/3
// beta = 2/3
// Stage #3
rk.mstage = 3;
dogStateUnst2.set_time(told+dt);
BeforeStep_Unst(dt,Mesh,auxstar,qstar);
ConstructL_Unst(told+0.5*dt,vel_vec,Mesh,EdgeData,auxstar,qstar,Lstar,smax);
UpdateSoln_Unst(rk.alpha1->get(rk.mstage),rk.alpha2->get(rk.mstage),
rk.beta->get(rk.mstage),dt,Mesh,aux,qstar,Lstar,qnew);
AfterStep_Unst(dt,Mesh,aux,qnew);
// --------------------------------------------------
break;
default: unsupported_value_error(dogParams.get_time_order());
}
// compute cfl number
cfl = GetCFL_Unst(dt,Mesh,aux,smax);
// output time step information
// if (dogParams.get_verbosity()>0)
// {
// printf(" In DogSolveRK_Quiet: DogSolve2D ... Step %5d"
// " CFL =%6.3f"
// " dt =%11.3e"
// " t =%11.3e\n",
// n_step, cfl, dt, t);
// }
// choose new time step
if (cfl>0.0)
{
dt = Min(dogParams.get_max_dt(), dt*CFL_target/cfl);
dtmin = Min(dt,dtmin);
dtmax = Max(dt,dtmax);
}
else
{
dt = dogParams.get_max_dt();
}
// see whether to accept or reject this step
if (cfl<=CFL_max)
// accept
{
m_accept = 1;
dogStateUnst2.set_time(t);
// do any extra work
// AfterFullTimeStep_Unst(dogStateUnst2.get_dt(),Mesh,
// auxold,qold,Lold,aux,qnew);
}
else
//reject
{
t = told;
dogStateUnst2.set_time(told);
// if( dogParams.get_verbosity() > 0 )
// {
// printf("DogSolve2D rejecting step..."
// "CFL number too large\n");
// }
// copy qold into qnew
qnew.copyfrom(qold);
aux.copyfrom(auxold);
// after reject function
// AfterReject_Unst(Mesh,dt,aux,qnew);
}
}
}
// printf(" Finished! t = %2.3e and nsteps = %d\n", t, n_step );
// set initial time step for next call to DogSolveRK
dogStateUnst2.set_initial_dt(dt);
void DeleteRKInfo(RKinfo& rk);
DeleteRKInfo(rk);
return cfl;
}
namespace gce
{
struct arg1_t
{
std::string hi_;
int i_;
};
struct arg2_t
{
std::vector<int> v_;
int i_;
};
}
GCE_PACK(gce::arg1_t, (hi_&smax(100))(i_&sfix));
GCE_PACK(gce::arg2_t, (v_&smax(5))(i_));
namespace gce
{
static std::size_t const lv1_thr_num = 5;
static std::size_t const lv2_thr_num = 5;
class message_ut
{
public:
static void run()
{
std::cout << "message_ut begin." << std::endl;
for (std::size_t i=0; i<100; ++i)
{
test_common();
