//---------------------------------------------------------
void CFlow_Parallel::BRM_GetDiago(int Dir, int x, int y, int ix[3], int iy[3], double nnei[6], int nexp[6])
{
int i;
double Slope, Aspect;
Get_Gradient( x , y , Slope, Aspect);
nexp[0] = (int)(M_RAD_TO_DEG * Aspect);
nnei[0] = M_RAD_TO_DEG * Slope;
Get_Gradient(ix[0], iy[0], Slope, Aspect);
nexp[1] = (int)(M_RAD_TO_DEG * Aspect);
nnei[1] = M_RAD_TO_DEG * Slope;
Get_Gradient(ix[2], iy[2], Slope, Aspect);
nexp[2] = (int)(M_RAD_TO_DEG * Aspect);
nnei[2] = M_RAD_TO_DEG * Slope;
Get_Gradient(ix[1], iy[1], Slope, Aspect);
nexp[3] = (int)(M_RAD_TO_DEG * Aspect);
nnei[3] = M_RAD_TO_DEG * Slope;
for(i=1; i<4; i++)
if(nexp[i]<0)
nexp[i] = nexp[0];
for(i=0; i<4; i++)
{
nexp[i] += BRM_idreh[Dir];
if(nexp[i]>360)
nexp[i] -= 360;
}
}
//---------------------------------------------------------
void CFlow::Init_Cell(int x, int y)
{
double Weight, Slope, Aspect;
Weight = pWeight ? pWeight->asDouble(x, y) : 1.0;
if( pCatch )
{
pCatch ->Add_Value(x, y, Weight);
}
if( pCatch_Height )
{
pCatch_Height ->Add_Value(x, y, Weight * pDTM->asDouble(x,y));
}
if( pCatch_Slope )
{
Get_Gradient(x, y, Slope, Aspect);
pCatch_Slope ->Add_Value(x, y, Weight * Slope);
}
if( pCatch_Aspect && pCatch_AspectY )
{
Get_Gradient(x, y, Slope, Aspect);
pCatch_Aspect ->Add_Value(x, y, Weight * sin(Aspect));
pCatch_AspectY ->Add_Value(x, y, Weight * cos(Aspect));
}
}
//---------------------------------------------------------
void CFlow_Parallel::BRM_GetOrtho(int Dir, int x, int y, int ix[3], int iy[3], double nnei[6], int nexp[6])
{
int jx, jy, i,
i0 = (Dir + 2) % 8,
i4 = (Dir + 6) % 8;
double Slope, Aspect;
for(i=0; i<3; i++)
{
jx = ix[i];
jy = iy[i];
Get_Gradient(jx, jy, Slope, Aspect);
nnei[i] = M_RAD_TO_DEG * Slope;
nexp[i] = (int)(M_RAD_TO_DEG * Aspect);
}
jx = Get_xTo(i0,x);
jy = Get_yTo(i0,y);
Get_Gradient(jx, jy, Slope, Aspect);
nnei[3] = M_RAD_TO_DEG * Slope;
nexp[3] = (int)(M_RAD_TO_DEG * Aspect);
jx = Get_xTo(i4,x);
jy = Get_yTo(i4,y);
Get_Gradient(jx, jy, Slope, Aspect);
nnei[5] = M_RAD_TO_DEG * Slope;
nexp[5] = (int)(M_RAD_TO_DEG * Aspect);
Get_Gradient(x, y, Slope, Aspect);
nnei[4] = M_RAD_TO_DEG * Slope;
nexp[4] = (int)(M_RAD_TO_DEG * Aspect); //[jy][jx]) ????!!!!...;
for(i=0; i<6; i++)
if(nexp[i]<0)
nexp[i] = nexp[4];
for(i=0; i<6; i++)
{
nexp[i] += BRM_idreh[Dir];
if(nexp[i]>360)
nexp[i] -= 360;
}
}
//---------------------------------------------------------
int CFlow_Parallel::BRM_InitRZ(int x, int y, int ix[3], int iy[3])
{
int i, j, Dir;
double Slope, Aspect;
Get_Gradient(x, y, Slope, Aspect);
Aspect *= M_RAD_TO_DEG;
if( Aspect < 0 )
{
return( -1 );
}
//---Kategorisierte-Exposition-------------------------
Dir = 0;
while( Aspect > BRM_kgexp[Dir] && Dir < 8 )
Dir++;
Dir %=8;
//---Finde-Die-3-ZielRasterZellen----------------------
for(i=0; i<3; i++) // zxy[]: 0=Recht, 1=Mitte, 2=Links
{
j = (Dir + 7 + i) % 8;
ix[2-i] = Get_xTo(j,x);
iy[2-i] = Get_yTo(j,y);
}
return(Dir);
}
//---------------------------------------------------------
void CFlow_RecursiveUp::Set_DInf(int x, int y)
{
int Direction;
double Slope, Aspect;
Get_Gradient(x, y, Slope, Aspect);
Aspect *= M_RAD_TO_DEG;
if( Aspect >= 0 )
{
Direction = (int)(Aspect / 45.0);
Aspect = fmod(Aspect,45) / 45.0;
Flow[y][x][(Direction ) % 8] = 1 - Aspect;
Flow[y][x][(Direction + 1) % 8] = Aspect;
}
}
//---------------------------------------------------------
void CFlow_RecursiveUp::Set_Rho8(int x, int y)
{
int Direction;
double Slope, Aspect;
Get_Gradient(x, y, Slope, Aspect);
Aspect *= M_RAD_TO_DEG;
if( Aspect >= 0 )
{
Direction = (int)(Aspect / 45.0);
if( fmod(Aspect,45) / 45.0 > rand() / (double)RAND_MAX )
Direction++;
Direction %= 8;
Flow[y][x][Direction] = 1.0;
}
}
MCLR_SM::model MCLR_SM::Get_Training_Model()
{
// Set the z matrix
z.set_size(no_of_classes,x.cols());// Used in gradient computation
z.fill(0);
// Create the z matrix
for(int i=0;i<x.cols();++i)
{
vnl_vector<double> temp_vector = z.get_column(i);
temp_vector.put(y.get(i)-1,1);
z.set_column(i,temp_vector);
}
vnl_vector<double> diff_g_3_it(3,0);//difference in g vals for last 3 iterations
vnl_vector<double> g_4_it(4,0); // g vals for the last three
//std::cout<<x.cols()<<std::endl;
//std::cout<<test_data.rows()<<std::endl;
//std::cout<< x.get_n_columns(0,2)<< std::endl;
for(int i =0;i<1e10;++i)
{
//Get the gradient
Get_Gradient(Add_Bias(x));
//Get the hessian
Get_Hessian(Add_Bias(x));
//ameliorate hessian conditions
Ameliorate_Hessian_Conditions();
//Get the direction
// vnl_vector<double> dir = mclr->Newton_Direction(mclr->hessian,mclr->Column_Order_Matrix(mclr->gradient_w));
// mclr->direction = mclr->Reshape_Vector(dir,mclr->no_of_features+1,mclr->no_of_classes);
direction = Reshape_Vector(Newton_Direction(hessian,Column_Order_Matrix(gradient_w)),no_of_features+1,no_of_classes);
double step = logit_stepsize();
if(step == -1)
step = 1e-9;
m.w = m.w + step * direction;
g_4_it(i%4) = g;
if(i>1)
diff_g_3_it(i%3) = g_4_it(i%4) - g_4_it((i-1)%4);
if (i>3 && (diff_g_3_it.one_norm()/3)/(g_4_it.one_norm()/4) < stop_cond(0))
break;
}
m.FIM = hessian*-1;
m.CRB = vnl_matrix_inverse<double>(hessian);
// quirk of vnl ...
m.CRB = m.CRB*-1;
//std::cout<<vnl_trace(m.CRB)<<std::endl;
// FILE * fpin1 = FDeclare2("C:\\Users\\rkpadman\\Documents\\MATLAB\\crb.txt", "", 'w');
//for(int abc =0;abc<hessian.rows();++abc)
//{
// vnl_vector<double> temp = hessian.get_row(abc);
// for(int abcd =0;abcd<hessian.cols();++abcd)
// {
// fprintf(fpin1, "%lf ", temp[abcd]);
// }
// fprintf(fpin1, "\n");
//}
//fclose(fpin1);
top_features.clear();
top_features = Get_Top_Features();
return m;
}
int edge_detection(struct Cell_head elaboration_reg, struct bound_box Overlap_Box,
double *parBilin, double obsX, double obsY,
double *partial, double alpha, double residual,
double gradHigh, double gradLow)
{
/* 1 = PRE_TERRAIN */
/* 2 = PRE_EDGE */
/* 3 = PRE_UNKNOWN */
int c1, c2;
double g[9][2], gradient[2], gradPto, dirPto;
extern double stepE, stepN;
static struct Cell_head Elaboration;
g[0][0] = partial[0];
g[0][1] = partial[1];
gradPto = g[0][0] * g[0][0] + g[0][1] * g[0][1];
dirPto = atan(g[0][1] / g[0][0]) + M_PI / 2; /* radiants */
Elaboration = elaboration_reg;
if ((gradPto > gradHigh) && (residual > 0))
return PRE_EDGE; /* Strong condition for 'edge' points */
else if ((gradPto > gradLow) && (residual > 0)) { /* Soft condition for 'edge' points */
if (Vect_point_in_box(obsX, obsY, 0.0, &Overlap_Box)) {
Get_Gradient(Elaboration, obsX + stepE * cos(dirPto),
obsY + stepN * sin(dirPto), parBilin, gradient);
g[2][0] = gradient[0];
g[2][1] = gradient[1];
Get_Gradient(Elaboration, obsX + stepE * cos(dirPto + M_PI),
obsY + stepN * sin(dirPto + M_PI), parBilin, gradient);
g[7][0] = gradient[0];
g[7][1] = gradient[1];
if ((fabs(atan(g[2][1] / g[2][0]) + M_PI / 2 - dirPto) < alpha) &&
(fabs(atan(g[7][1] / g[7][0]) + M_PI / 2 - dirPto) < alpha)) {
Get_Gradient(Elaboration,
obsX + stepE * cos(dirPto + M_PI / 4),
obsY + stepN * sin(dirPto + M_PI / 4),
parBilin, gradient);
g[1][0] = gradient[0];
g[1][1] = gradient[1];
Get_Gradient(Elaboration,
obsX + stepE * cos(dirPto - M_PI / 4),
obsY + stepN * sin(dirPto - M_PI / 4),
parBilin, gradient);
g[3][0] = gradient[0];
g[3][1] = gradient[1];
Get_Gradient(Elaboration,
obsX + stepE * cos(dirPto + M_PI / 2),
obsY + stepN * sin(dirPto + M_PI / 2),
parBilin, gradient);
g[4][0] = gradient[0];
g[4][1] = gradient[1];
Get_Gradient(Elaboration,
obsX + stepE * cos(dirPto - M_PI / 2),
obsY + stepN * sin(dirPto - M_PI / 2),
parBilin, gradient);
g[5][0] = gradient[0];
g[5][1] = gradient[1];
Get_Gradient(Elaboration,
obsX + stepE * cos(dirPto + M_PI * 3 / 4),
obsY + stepN * sin(dirPto + M_PI * 3 / 4),
parBilin, gradient);
g[6][0] = gradient[0];
g[6][1] = gradient[1];
Get_Gradient(Elaboration,
obsX + stepE * cos(dirPto - M_PI * 3 / 4),
obsY + stepN * sin(dirPto - M_PI * 3 / 4),
parBilin, gradient);
g[8][0] = gradient[0];
g[8][1] = gradient[1];
c2 = 0;
for (c1 = 0; c1 < 9; c1++)
if (g[c1][0] * g[c1][0] + g[c1][1] * g[c1][1] >
gradHigh)
c2++;
if (c2 > 2)
return PRE_EDGE;
else
return PRE_TERRAIN;
}
else
return PRE_TERRAIN;
}
else
return PRE_UNKNOWN;
} /* END ELSE IF */
else
return PRE_TERRAIN;
}
void classification(struct Map_info *Out, struct Cell_head Elaboration,
struct bound_box General, struct bound_box Overlap, double **obs,
double *parBilin, double *parBicub, double mean,
double alpha, double gradHigh, double gradLow,
double overlap, int *line_num, int num_points,
dbDriver * driver, char *tabint_name, char *tab_name)
{
int i, edge;
double interpolation, weight, residual, eta, csi, gradient[2];
extern int nsplx, nsply, line_out_counter;
extern double stepN, stepE;
struct line_pnts *point;
struct line_cats *categories;
point = Vect_new_line_struct();
categories = Vect_new_cats_struct();
db_begin_transaction(driver);
for (i = 0; i < num_points; i++) { /* Sparse points */
G_percent(i, num_points, 2);
Vect_reset_line(point);
Vect_reset_cats(categories);
if (Vect_point_in_box(obs[i][0], obs[i][1], mean, &General)) {
interpolation =
dataInterpolateBicubic(obs[i][0], obs[i][1], stepE, stepN,
nsplx, nsply, Elaboration.west,
Elaboration.south, parBicub);
interpolation += mean;
Vect_copy_xyz_to_pnts(point, &obs[i][0], &obs[i][1], &obs[i][2], 1);
Get_Gradient(Elaboration, obs[i][0], obs[i][1], parBilin, gradient);
*point->z += mean;
/*Vect_cat_set (categories, F_INTERPOLATION, line_out_counter); */
if (Vect_point_in_box(obs[i][0], obs[i][1], interpolation, &Overlap)) { /*(5) */
residual = *point->z - interpolation;
edge =
edge_detection(Elaboration, Overlap, parBilin, *point->x,
*point->y, gradient, alpha, residual,
gradHigh, gradLow);
Vect_cat_set(categories, F_EDGE_DETECTION_CLASS, edge);
Vect_cat_set(categories, F_INTERPOLATION, line_out_counter);
Vect_write_line(Out, GV_POINT, point, categories);
Insert_Interpolation(interpolation, line_out_counter, driver,
tabint_name);
line_out_counter++;
}
else {
if ((*point->x > Overlap.E) && (*point->x < General.E)) {
if ((*point->y > Overlap.N) && (*point->y < General.N)) { /*(3) */
csi = (General.E - *point->x) / overlap;
eta = (General.N - *point->y) / overlap;
weight = csi * eta;
gradient[0] *= weight;
gradient[1] *= weight;
interpolation *= weight;
if (Select(&gradient[0], &gradient[1],
&interpolation, line_num[i], driver,
tab_name) != DB_OK)
G_fatal_error(_("Impossible to read from aux table"));
if (UpDate(gradient[0], gradient[1],
interpolation, line_num[i], driver,
tab_name) != DB_OK)
G_fatal_error(_("Impossible to update aux table"));
}
else if ((*point->y < Overlap.S) && (*point->y > General.S)) { /*(1) */
csi = (General.E - *point->x) / overlap;
eta = (*point->y - General.S) / overlap;
weight = csi * eta;
gradient[0] *= weight;
gradient[1] *= weight;
interpolation *= weight;
if (Insert(gradient[0], gradient[1], interpolation,
line_num[i], driver, tab_name) != DB_OK)
G_fatal_error(_("Impossible to write to aux table"));
}
else if ((*point->y <= Overlap.N) && (*point->y >= Overlap.S)) { /*(1) */
weight = (General.E - *point->x) / overlap;
gradient[0] *= weight;
gradient[1] *= weight;
interpolation *= weight;
if (Insert(gradient[0], gradient[1], interpolation,
line_num[i], driver, tab_name) != DB_OK)
G_fatal_error(_("Impossible to write to aux table"));
}
}
else if ((*point->x < Overlap.W) && (*point->x > General.W)) {
if ((*point->y > Overlap.N) && (*point->y < General.N)) { /*(4) */
csi = (*point->x - General.W) / overlap;
eta = (General.N - *point->y) / overlap;
weight = eta * csi;
gradient[0] *= weight;
gradient[1] *= weight;
interpolation *= weight;
if (Select(&gradient[0], &gradient[1],
&interpolation, line_num[i], driver,
tab_name) != DB_OK)
G_fatal_error(_("Impossible to read from aux table"));
residual = *point->z - interpolation;
edge =
edge_detection(Elaboration, Overlap, parBilin,
*point->x, *point->y, gradient,
alpha, residual, gradHigh,
gradLow);
Vect_cat_set(categories, F_EDGE_DETECTION_CLASS,
edge);
Vect_cat_set(categories, F_INTERPOLATION,
line_out_counter);
Vect_write_line(Out, GV_POINT, point, categories);
Insert_Interpolation(interpolation, line_out_counter,
driver, tabint_name);
line_out_counter++;
}
else if ((*point->y < Overlap.S) && (*point->y > General.S)) { /*(2) */
csi = (*point->x - General.W) / overlap;
eta = (*point->y - General.S) / overlap;
weight = csi * eta;
gradient[0] *= weight;
gradient[1] *= weight;
interpolation *= weight;
if (Select(&gradient[0], &gradient[1],
&interpolation, line_num[i], driver,
tab_name) != DB_OK)
G_fatal_error(_("Impossible to read from aux table"));
if (UpDate(gradient[0], gradient[1],
interpolation, line_num[i], driver,
tab_name) != DB_OK)
G_fatal_error(_("Impossible to update aux table"));
}
else if ((*point->y <= Overlap.N) && (*point->y >= Overlap.S)) { /*(2) */
weight = (*point->x - General.W) / overlap;
gradient[0] *= weight;
gradient[1] *= weight;
interpolation *= weight;
if (Select(&gradient[0], &gradient[1],
&interpolation, line_num[i], driver,
tab_name) != DB_OK)
G_fatal_error(_("Impossible to read from aux table"));
residual = *point->z - interpolation;
edge =
edge_detection(Elaboration, Overlap, parBilin,
*point->x, *point->y, gradient,
alpha, residual, gradHigh,
gradLow);
Vect_cat_set(categories, F_EDGE_DETECTION_CLASS,
edge);
Vect_cat_set(categories, F_INTERPOLATION,
line_out_counter);
Vect_write_line(Out, GV_POINT, point, categories);
Insert_Interpolation(interpolation, line_out_counter,
driver, tabint_name);
line_out_counter++;
}
}
else if ((*point->x <= Overlap.E) && (*point->x >= Overlap.W)) {
if ((*point->y > Overlap.N) && (*point->y < General.N)) { /*(3) */
weight = (General.N - *point->y) / overlap;
gradient[0] *= weight;
gradient[1] *= weight;
interpolation *= weight;
if (Select(&gradient[0], &gradient[1],
&interpolation, line_num[i], driver,
tab_name) != DB_OK)
G_fatal_error(_("Impossible to read from aux table"));
residual = *point->z - interpolation;
edge =
edge_detection(Elaboration, Overlap, parBilin,
*point->x, *point->y, gradient,
alpha, residual, gradHigh,
gradLow);
Vect_cat_set(categories, F_EDGE_DETECTION_CLASS,
edge);
Vect_cat_set(categories, F_INTERPOLATION,
line_out_counter);
Vect_write_line(Out, GV_POINT, point, categories);
Insert_Interpolation(interpolation, line_out_counter,
driver, tabint_name);
line_out_counter++;
}
else if ((*point->y < Overlap.S) && (*point->y > General.S)) { /*(1) */
weight = (*point->y - General.S) / overlap;
gradient[0] *= weight;
gradient[1] *= weight;
interpolation *= weight;
if (Insert(gradient[0], gradient[1], interpolation,
line_num[i], driver, tab_name) != DB_OK)
G_fatal_error(_("Impossible to write to aux table"));
} /*else (1) */
} /*else */
}
} /*end if obs */
} /*end for */
G_percent(num_points, num_points, 2); /* finish it */
db_commit_transaction(driver);
Vect_destroy_line_struct(point);
Vect_destroy_cats_struct(categories);
}
