void MapGradient::compute_tangent_and_binormal(
MapVertexProperty<vec3>& tangent,
MapVertexProperty<vec3>& binormal
) {
vec2 du(1,0) ; vec2 dv(0,1) ;
FOR_EACH_VERTEX(Map, map_, it) {
tangent[it] = compute_gradient(it, du) ;
binormal[it] = compute_gradient(it, dv) ;
}
void gradient_check()
{
std::vector<int> const Labels{0, 1, 2, 0};
auto const UniqueLabels = get_unique_labels(Labels);
auto const NumClass = UniqueLabels.size();
EigenMat const Train = EigenMat::Random(10, 2);
weight_ = EigenMat::Random(NumClass, Train.rows());
grad_ = EigenMat::Zero(NumClass, Train.rows());
int const TrainCols = static_cast<int>(Train.cols());
EigenMat const GroundTruth = get_ground_truth(NumClass, TrainCols,
UniqueLabels,
Labels);
gradient_checking gc;
auto func = [&](EigenMat &theta)->double
{
return compute_cost(Train, theta, GroundTruth);
};
EigenMat const WeightBuffer = weight_;
EigenMat const Gradient =
gc.compute_gradient(weight_, func);
compute_cost(Train, WeightBuffer, GroundTruth);
compute_gradient(Train, WeightBuffer, GroundTruth);
std::cout<<std::boolalpha<<"gradient checking pass : "******"\n";//*/
}
void create_normal_map(t_env *e, t_obj *obj)
{
int x;
int y;
double *grad;
y = -1;
grad = NULL;
obj->mat.texture.bump =
(t_rgb**)malloc(sizeof(t_rgb*) * obj->mat.texture.h);
obj->mat.texture.bump == NULL ? error(e, E_MALLOC, NULL, 1) : 0;
while (++y < obj->mat.texture.h)
{
x = -1;
obj->mat.texture.bump[y] =
(t_rgb*)malloc(sizeof(t_rgb) * obj->mat.texture.w);
obj->mat.texture.bump[y] == NULL ? error(e, E_MALLOC, NULL, 1) : 0;
while (++x < obj->mat.texture.w)
{
grad = get_gradient(obj->mat.texture.img, y, x, obj->mat.texture);
grad == NULL ? error(e, E_MALLOC, NULL, 1) : 0;
obj->mat.texture.bump[y][x] = compute_gradient(grad, obj);
ft_memdel((void**)&grad);
}
}
}
static gboolean
newton_improve (GnmNlsolve *nl, gnm_float *xs, gnm_float *y, gnm_float ymax)
{
GnmSolver *sol = nl->parent;
const int n = nl->vars->len;
gnm_float *g, **H, *d;
gboolean ok;
g = compute_gradient (nl, xs);
H = compute_hessian (nl, xs, g);
d = g_new (gnm_float, n);
ok = (gnm_linear_solve (H, g, n, d) == 0);
if (ok) {
int i;
gnm_float y2, *xs2 = g_new (gnm_float, n);
gnm_float f, best_f = -1;
ok = FALSE;
for (f = 1; f > 1e-4; f /= 2) {
int i;
for (i = 0; i < n; i++)
xs2[i] = xs[i] - f * d[i];
set_vector (nl, xs2);
y2 = get_value (nl);
if (nl->debug) {
print_vector ("xs2", xs2, n);
g_printerr ("Obj value %.15" GNM_FORMAT_g "\n",
y2);
}
if (y2 < ymax && gnm_solver_check_constraints (sol)) {
best_f = f;
ymax = y2;
break;
}
}
if (best_f > 0) {
for (i = 0; i < n; i++)
xs[i] = xs[i] - best_f * d[i];
*y = ymax;
ok = TRUE;
}
g_free (xs2);
} else {
if (nl->debug)
g_printerr ("Failed to solve Newton step.\n");
}
g_free (d);
g_free (g);
free_matrix (H, n);
return ok;
}
vec3 MapGradient::compute_gradient(Map::Vertex* v, const vec2& w) {
vec3 result(0,0,0) ;
Map::Halfedge* h = v->halfedge() ;
int count = 0 ;
do {
result = result + compute_gradient(h->prev(), h, h->next(), w) ;
h = h->next() ;
count++ ;
} while(h != v->halfedge()) ;
return real(1.0 / double(count)) * result ;
}
void gradient_descent(double X[][MAX_FEATURE_DIMENSION], int y[],
double theta[], int feature_number, int sample_number,
double alpha, int iterate_number, double J[]){
for (int i = 0; i < iterate_number; i++){
double temp[MAX_FEATURE_DIMENSION] = {0};
for (int j = 0; j <= feature_number; j++){
temp[j] = theta[j] - alpha * compute_gradient(X, y, theta, feature_number, j, sample_number);
}
for (int j = 0; j <= feature_number; j++){
theta[j] = temp[j];
}
J[i] = compute_cost(X, y, theta, feature_number, sample_number);
}
}
void MapGradient::compute_gradient(
Map::Halfedge* h1,
Map::Halfedge* h2,
Map::Halfedge* h3,
double* TU,
double* TV
) {
compute_gradient(
h1->vertex()->point(),
h2->vertex()->point(),
h3->vertex()->point(),
*halfedge_tex_vertex_[h1],
*halfedge_tex_vertex_[h2],
*halfedge_tex_vertex_[h3],
TU, TV
) ;
}
void softmax<T>::train(const Eigen::Ref<const EigenMat> &train,
const std::vector<int> &labels)
{
#ifdef OCV_TEST_SOFTMAX
gradient_check();
#endif
auto const UniqueLabels = get_unique_labels(labels);
auto const NumClass = UniqueLabels.size();
weight_ = EigenMat::Random(NumClass, train.rows());
grad_ = EigenMat::Zero(NumClass, train.rows());
auto const TrainCols = static_cast<int>(train.cols());
EigenMat const GroundTruth = get_ground_truth(static_cast<int>(NumClass),
TrainCols,
UniqueLabels,
labels);
std::random_device rd;
std::default_random_engine re(rd());
int const Batch = (get_batch_size(TrainCols));
int const RandomSize = TrainCols != Batch ?
TrainCols - Batch - 1 : 0;
std::uniform_int_distribution<int>
uni_int(0, RandomSize);
for(size_t i = 0; i != params_.max_iter_; ++i){
auto const Cols = uni_int(re);
auto const &TrainBlock =
train.block(0, Cols, train.rows(), Batch);
auto const >Block =
GroundTruth.block(0, Cols, NumClass, Batch);
auto const Cost = compute_cost(TrainBlock, weight_, GTBlock);
if(std::abs(params_.cost_ - Cost) < params_.epsillon_ ||
Cost < 0){
break;
}
params_.cost_ = Cost;
compute_gradient(TrainBlock, weight_, GTBlock);
weight_.array() -= grad_.array() * params_.lrate_;//*/
}
}
vec3 MapGradient::compute_gradient(
Map::Halfedge* h1,
Map::Halfedge* h2,
Map::Halfedge* h3,
const vec2& W
) {
double TU[3] ;
double TV[3] ;
compute_gradient(h1,h2,h3,TU,TV) ;
const vec3& p1 = h1->vertex()->point() ;
const vec3& p2 = h2->vertex()->point() ;
const vec3& p3 = h3->vertex()->point() ;
vec3 grad_u(
real(TU[0] * p1.x + TU[1] * p2.x + TU[2] * p3.x),
real(TU[0] * p1.y + TU[1] * p2.y + TU[2] * p3.y),
real(TU[0] * p1.z + TU[1] * p2.z + TU[2] * p3.z)
) ;
vec3 grad_v(
real(TV[0] * p1.x + TV[1] * p2.x + TV[2] * p3.x),
real(TV[0] * p1.y + TV[1] * p2.y + TV[2] * p3.y),
real(TV[0] * p1.z + TV[1] * p2.z + TV[2] * p3.z)
) ;
return W.x * grad_u + W.y * grad_v ;
}
void GeodesicInHeat::compute_distance(const Vertex& start_vertex)
{
int n = mesh.n_vertices();
int start_idx = start_vertex.idx();
VecN delta(n);
delta.setZero();
delta(start_idx) =1.0f;
//The laplacian, gradient divergence matrix only need to compute once.
if (!initialized)
initialization();
float timestep = avglength*avglength*factor;
VecN uNeumann = compute_heat(delta,Laplacian, AreaMatrix,timestep);
VecN uDirichlet = compute_heat(delta, LaplacianDirichlet, AreaMatrix, timestep);
VecN u =0.5*uNeumann+0.5*uDirichlet;
//Method::the three boundary function will active one, if all false, display the average.
if (Neumann)
u = uNeumann;
if (Dirichlet)
u = uDirichlet;
MatMxN X = compute_gradient(Grad_x, Grad_y, Grad_z, u);
VecN div_X = compute_divergence(Div_x, Div_y, Div_z, X);
Eigen::SimplicialCholesky<Sparse, Eigen::RowMajor> Solver;
Solver.compute(Laplacian);
VecN phi = Solver.solve(div_X);
//shift phi and find out the Max G, Min G and the Max geodesic distance span along edge.
for (auto const& vertex : mesh.vertices())
{
float d1 = phi[vertex.idx()];
HeatDisplay[vertex] = d1;
float d2 = 0.0;
for (auto const& vj : mesh.vertices(vertex))
{
float d = std::abs(phi[vertex.idx()] - phi[vj.idx()]);
if (d > d2)
d2 = d;
}
if (d1 > MaxGeodesic)
MaxGeodesic = d1;
if (d2 > MaxEdgeSpan)
MaxEdgeSpan = d2;
if (d1 < MinGeodesic)
MinGeodesic = d1;
}
for (auto const& vertex : mesh.vertices())
{
HeatDisplay[vertex] = HeatDisplay[vertex] - MinGeodesic;
HeatDistance[vertex] = HeatDisplay[vertex];
}
MaxGeodesic -= MinGeodesic;
MinGeodesic = 0;
if (Neumann) {
mLogger() << "Heat: Neumann Boudary Condition, M=" << factor;
return;
}
if (Dirichlet) {
mLogger() << "Heat: Dirichlet Boudary Condition, M=" << factor;
return;
}
mLogger() << "Heat: Average Boudary Condition, M=" << factor;
}
void
detect_edges(Image *img, float sigma, float threshold, \
unsigned char *edge_pix, PList *edge_pts)
{
int x, y;
int w = img->w;
int h = img->h;
// convert image to grayscale
float **gray = array_create(w, h);
convert_grayscale(img, gray);
// blur grayscale image
float **gray2 = array_create(w, h);
gaussian_blur(gray, gray2, w, h, sigma);
// compute gradient of blurred image
float **g_mag = array_create(w, h);
float **g_ang = array_create(w, h);
compute_gradient(gray2, w, h, g_mag, g_ang);
// mark edge pixels
#define PIX(y,x) edge_pix[(y)*w+(x)]
#pragma omp parallel
{
#pragma omp for private(x) nowait
for (y = 0; y < h; y++)
for (x = 0; x < w; x++)
{
PIX(y,x) = is_edge(g_mag,g_ang,threshold,x,y,w,h) ? 255 : 0;
}
// connect horizontal edges
#pragma omp for private(x) nowait
for (y = 0; y < h ; y++)
for (x = 1; x < w-1; x++)
{
if (!PIX(y,x) && PIX(y,x+1) && PIX(y,x-1))
PIX(y,x) = 255;
}
// connect vertical edges
#pragma omp for private(y) nowait
for (x = 0; x < w ; x++)
for (y = 1; y < h-1; y++)
{
if (!PIX(y,x) && PIX(y+1,x) && PIX(y-1,x))
PIX(y,x) = 255;
}
#pragma omp for private(x)
// connect diagonal edges
for (y = 1; y < h-1; y++)
for (x = 1; x < w-1; x++)
{
if (!PIX(y,x) && PIX(y-1,x-1) && PIX(y+1,x+1))
PIX(y,x) = 255;
if (!PIX(y,x) && PIX(y-1,x+1) && PIX(y+1,x-1))
PIX(y,x) = 255;
}
}
// add edge points to list
if (edge_pts)
{
for (y = 0; y < h; y++)
for (x = 0; x < w; x++)
{
if (PIX(y,x)) PList_push(edge_pts, x, y);
}
}
// cleanup
array_free(g_mag, h);
array_free(g_ang, h);
array_free(gray2, h);
array_free(gray, h);
}
static void compute_hessian(struct state *state, double *hess)
{
size_t n_frags, n_coord;
double *xyzabc, *grad_f, *grad_b;
bool central = cfg_get_bool(state->cfg, "hess_central");
check_fail(efp_get_frag_count(state->efp, &n_frags));
n_coord = 6 * n_frags;
xyzabc = xmalloc(n_coord * sizeof(double));
grad_f = xmalloc(n_coord * sizeof(double));
grad_b = xmalloc(n_coord * sizeof(double));
check_fail(efp_get_coordinates(state->efp, xyzabc));
if (!central) {
memcpy(grad_b, state->grad, n_frags * 6 * sizeof(double));
for (size_t i = 0; i < n_frags; i++) {
const double *euler = xyzabc + 6 * i + 3;
double *gradptr = grad_b + 6 * i + 3;
efp_torque_to_derivative(euler, gradptr, gradptr);
}
}
for (size_t i = 0; i < n_coord; i++) {
double save = xyzabc[i];
double step = i % 6 < 3 ? cfg_get_double(state->cfg, "num_step_dist") :
cfg_get_double(state->cfg, "num_step_angle");
show_progress(i + 1, n_coord, "FORWARD");
xyzabc[i] = save + step;
compute_gradient(state, n_frags, xyzabc, grad_f);
if (central) {
show_progress(i + 1, n_coord, "BACKWARD");
xyzabc[i] = save - step;
compute_gradient(state, n_frags, xyzabc, grad_b);
}
double delta = central ? 2.0 * step : step;
for (size_t j = 0; j < n_coord; j++)
hess[i * n_coord + j] = (grad_f[j] - grad_b[j]) / delta;
xyzabc[i] = save;
}
/* restore original coordinates */
check_fail(efp_set_coordinates(state->efp, EFP_COORD_TYPE_XYZABC, xyzabc));
/* reduce error by computing the average of H(i,j) and H(j,i) */
for (size_t i = 0; i < n_coord; i++) {
for (size_t j = i + 1; j < n_coord; j++) {
double sum = hess[i * n_coord + j] + hess[j * n_coord + i];
hess[i * n_coord + j] = 0.5 * sum;
hess[j * n_coord + i] = hess[i * n_coord + j];
}
}
free(xyzabc);
free(grad_f);
free(grad_b);
msg("\n\n");
}
SGMatrix<float64_t> CKLInference::get_posterior_covariance()
{
compute_gradient();
return SGMatrix<float64_t>(m_Sigma);
}
SGVector<float64_t> CKLInference::get_posterior_mean()
{
compute_gradient();
return SGVector<float64_t>(m_mu);
}
