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;
}
