t_vector3d calcul_normal(t_obj *object, t_vector3d *inter) { t_vector3d n; t_vector3d tmp; double angle; if (object->type == SPHERE) n = sub_vector(object->origin, *inter); if (object->type == PLAN) n = object->origin; if (object->type == CYLINDRE) { n = sub_vector(object->origin, *inter); n.z = 0; rotation(&n, object->angle); } if (object->type == CONE) { n = sub_vector(object->origin, *inter); n.z = 0; rotation(&n, object->angle); } n = normalize(n); return (n); }
// ----------------------------------------------------------------- // dest <-- M^(-1) src int mat_invert_uml(field_offset src, field_offset dest, field_offset temp, Real mass) { register int i; register site *s; int cgn; Real norm = 1.0 / (2.0 * mass); if (src == temp) { printf("MAT_INVERT_UML: src = temp\n"); exit(0); } // "Precondition" both even and odd sites // temp <-- M^dag src dslash(src, F_OFFSET(ttt), EVENANDODD); scalar_mult_add_latvec(F_OFFSET(ttt), src, -2.0 * mass, temp, EVENANDODD); scalar_mult_latvec(temp, -1.0, temp, EVENANDODD); // dest_e <-- (M^dag M)^-1 temp_e (even sites only) cgn = ks_congrad(temp, dest, mass, EVEN); // Reconstruct odd site solution // dest_o <-- 1/2m (Dslash_oe * dest_e + src_o) dslash(dest, F_OFFSET(ttt), ODD); FORODDSITES(i, s) { sub_vector((vector *)F_PT(s, src), &(s->ttt), (vector *)F_PT(s, dest)); scalar_mult_vector((vector *)F_PT(s, dest), norm, (vector *)F_PT(s, dest)); }
void get_reflected_ray(t_ray* ray, t_object* obj, t_ray* new_ray) { new_ray->distance = 20000; mult_vector(&ray->dest, &new_ray->origin, ray->distance); add_vector(&new_ray->origin, &ray->origin, &new_ray->origin); get_normal(obj, &new_ray->origin, &new_ray->dest); mult_vector(&new_ray->dest, &new_ray->dest, dot_vector(&ray->dest, &new_ray->dest)); mult_vector(&new_ray->dest, &new_ray->dest, 2); sub_vector(&ray->dest, &new_ray->dest, &new_ray->dest); }
float compute_diehdral_angle(const own_vector_t *a1, const own_vector_t *a2,const own_vector_t *a3, const own_vector_t *a4){ /* Computes the dihedral angle */ own_vector_t *P1, *P2, *M, *r1, *r2, *r3; double mod_P1, mod_P2; double W; P1 = Malloc(own_vector_t,1); P2 = Malloc(own_vector_t,1); M = Malloc(own_vector_t,1); r1 = Malloc(own_vector_t,1); r2 = Malloc(own_vector_t,1); r3 = Malloc(own_vector_t,1); //Computing distances sub_vector(r1,a1,a2); sub_vector(r2,a2,a3); sub_vector(r3,a3,a4); cross_product(P1,r1,r2); cross_product(P2,r2,r3); mod_P1 = mod_vector(P1); mod_P2 = mod_vector(P2); W = acos(scalar_prod(P1,P2)/(mod_P1*mod_P2)); //Check if is necessary change the signal of W cross_product(M,P1,P2); if (scalar_prod(M,r2) < 0){ W = W *(-1); } //Deallocating variables free(P1); free(P2); free(M); free(r1); free(r2); free(r3); return W; }
void ConvolutionalLayer::back_propagate(std::vector<double> *d, std::vector<std::vector<double>> *w) { int convoluted_size = (convoluted_dim * convoluted_dim) / 4; for (int i=0; i<features.size(); i++) { int index = i*convoluted_size; std::vector<std::vector<double>> sub_vector(w->begin()+index, w->begin()+index+convoluted_size); features[i]->correct(d, &sub_vector); } if (layer_index + 1 != Network::layers.size()) Network::layers[layer_index + 1]->back_propagate(d, w); }
void init_refraction(t_ray** rays, t_vector* normal, t_object* obj, t_vector* tmp) { (*rays[1]).distance = 20000; mult_vector(&(*rays[0]).dest, &(*rays[1]).origin, (*rays[0]).distance); add_vector(&(*rays[1]).origin, &(*rays[0]).origin, &(*rays[1]).origin); get_normal(obj, &(*rays[1]).origin, normal, rays[0]); sub_vector(NULL, &(*rays[0]).dest, tmp); if ((*rays[0]).in_obj == 0) { if (obj->obj_type != E_PLANE) (*rays[1]).in_obj = 1; else (*rays[1]).in_obj = 0; (*rays[1]).refract = obj->material.refract; } else { sub_vector(NULL, normal, normal); (*rays[1]).in_obj = 0; (*rays[1]).refract = 1.0; } }
void color_cylinder(t_ray* ray, t_vector* inter, t_object* obj, t_color* clr) { t_vector normal; double angle; t_vector light; get_normal(obj, inter, &normal, ray); sub_vector(NULL, &ray->dest, &light); angle = dot_vector(&normal, &light); if (angle < 0.0) angle = 0.0; clr->r = obj->material.diffuse.r * AMBIANT_RED * angle; clr->g = obj->material.diffuse.g * AMBIANT_GREEN * angle; clr->b = obj->material.diffuse.b * AMBIANT_BLUE * angle; }
void get_refracted_ray(t_ray* ray, t_object* obj, t_ray* new_ray) { t_vector tmp; t_vector normal; double d[3]; t_ray* rays[2]; rays[0] = ray; rays[1] = new_ray; init_refraction(rays, &normal, obj, &tmp); d[0] = dot_vector(&tmp, &normal); d[1] = ray->refract / new_ray->refract; d[2] = asin(d[1] * sin(acos(d[0]))); mult_vector(&normal, &new_ray->dest, cos(d[2]) + d[1] * d[0]); mult_vector(&ray->dest, &tmp, d[1]); sub_vector(&tmp, &new_ray->dest, &new_ray->dest); normalize(&new_ray->dest); }
/** void pool(WSGraph gd, vector a, vector b, int rr, int cc) 3D的な円柱の描画.中身はccで塗りつぶされる. @param gd 操作対象となるグラフィックデータ構造体. @param a 円柱の一方の底面の円の中心の座標ベクトル. @param b 円柱のもう一方の底面の円の中心の座標ベクトル. @param rr 円柱の半径. @param cc 線と塗りつぶしの濃度. */ void pool(WSGraph gd, vector a, vector b, int rr, int cc) { int i, ll, cz; vector ox, oz, ev; WSGraph vp, px; ox = sub_vector(b, a); ll = (int)(ox.n + 0.5); vp = px = make_WSGraph(2*rr+3, 2*rr+3, ll); if (vp.gp==NULL) return; for (i=0; i<vp.zs; i++) { cz = i*vp.xs*vp.ys; px.gp = &(vp.gp[cz]); circle(px, rr+1, rr+1, rr, cc, ON); } oz = set_vector((float)((vp.xs-1)/2.), (float)((vp.ys-1)/2.), 0.); ev = unit_vector(ox); local2world(gd, vp, a, oz, ev, NULL, NULL); free(vp.gp); return; }