/*! \brief Get intersection
*
* This function calculates if the ray origination from the given position intersects the vertex.
* If the vertex is intersected the position of the intersection is returned.
* The algorithm used for the calculation is the Möller-Trumbore algorithm.
* \param origin Position from where the ray originates.
* \param direction The direction in which the ray travels.
*/
hitResult intersect(const vektor & origin, const vektor & direction) const {
vektor e1, e2;
vektor P, Q, T;
double det, inv_det, u, v;
double t;
e1 = p2 - p1;
e2 = p3 - p1;
P = direction.get_cross_product(e2);
det = e1.get_dot_product(P);
if( det > -EPSILON && det < EPSILON) {
return hitResult(false, vektor());
}
inv_det = 1.0/det;
T = origin - p1;
u = T.get_dot_product(P) * inv_det;
if(u < 0.0 || u > 1.0) {
return hitResult(false, vektor());
}
Q = T.get_cross_product(e1);
v = direction.get_dot_product(Q)*inv_det;
if(v < 0.0 || u + v > 1.0) {
return hitResult(false, vektor());
}
t = e2.get_dot_product(Q) * inv_det;
if(t > EPSILON) {
return hitResult(true, origin + t*direction);
}
return hitResult(false, origin + t*direction);
}
Greenfb::Greenfb(Grid2D& g, double a, double b) : greenf(2*g.get_NX()+2*g.get_NY()-8)
{
int i, j, v, u=0;
int Nb=greenf.size();
int NX=g.get_NX();
int NY=g.get_NY();
xb=vektor(Nb);
yb=vektor(Nb);
a0=a;
b0=b;
for(j=0; j<Nb; j++)
{
greenf[j]=g;
greenf[j].reset();
}
for(i=1; i<NX; i++)
{
xb[u]=g.x[i];
yb[u]=g.y[NY-1];
u=u+1;
}
for(j=1; j<NY-1; j++)
{
xb[u]=g.x[NX-1];
yb[u]=g.y[j];
u=u+1;
}
for(i=1; i<NX-1; i++)
{
xb[u]=g.x[i];
yb[u]=g.y[1];
u=u+1;
}
for(j=2; j<NY-1; j++)
{
xb[u]=g.x[1];
yb[u]=g.y[j];
u=u+1;
}
for(int j=0; j<Nb; j++)
for (u=0; u<NX; u++)
for(v=0; v<NY; v++)
{
if (a0 == 0.0) greenf[j](u,v)=open_2D( g.x[u], xb[j], g.y[v], yb[j]);
else if (a0 > 0.0 && b0 == 0.0) greenf[j](u,v)=circle_2D( g.x[u], xb[j], g.y[v], yb[j]);
else greenf[j](u,v)=0.0;
}
}
/* inline */ vektor operator * ( const matrix& A, const vektor& u )
{
return vektor( A.m[0][0] * u.a[0] + A.m[0][1] * u.a[1] + A.m[0][2] * u.a[2],
A.m[1][0] * u.a[0] + A.m[1][1] * u.a[1] + A.m[1][2] * u.a[2],
A.m[2][0] * u.a[0] + A.m[2][1] * u.a[1] + A.m[2][2] * u.a[2]
);
}
sf::Shape CircularTextureSelect::RectFromIndex(int i,float delta_angle) {
sf::Shape Rectangles = sf::Shape();
Rectangles.AddPoint(_Circle.GetCenter()); //háromszög közepe
sf::Vector2<float> vektor(_Circle.GetCenter().x -
_radius * cos((90+i*delta_angle)*PI/180), //háromszög balcsúcs
_Circle.GetCenter().y -
_radius * sin((90+i*delta_angle)*PI/180));
// std::cout << _Circle.GetCenter().x << " " << vektor.x << " " << _Circle.GetCenter().y << " " << vektor.y << endl;
Rectangles.AddPoint(sf::Vector2<float>(_Circle.GetCenter().x -
_radius * cos((90+i*delta_angle)*PI/180), //háromszög balcsúcs
_Circle.GetCenter().y -
_radius * sin((90+i*delta_angle)*PI/180)));
Rectangles.AddPoint(sf::Vector2<float>(_Circle.GetCenter().x - //háromszög jobb csúcs
_radius * cos((90+(i+1)*delta_angle)*PI/180),
_Circle.GetCenter().y -
_radius * sin((90+(i+1)*delta_angle)*PI/180)));
Rectangles.EnableFill(false);
Rectangles.EnableOutline(true);
Rectangles.SetOutlineWidth(1);
return Rectangles;
}
void CBall::createRV()
{
sf::Vector2f vektor(0,0);
float x_tmp = sf::Randomizer::Random(-1.f, 1.f);
float y_tmp=-sqrt(1.f-pow(x_tmp,2.f));//muss beim Startvektor negativ sein, denn der Ball klebt auf dem Board und soll beim abfeuern nach oben fliegen
this->rv.x=x_tmp;
this->rv.y=y_tmp;
}
polynom& ordpoly(matrix const& A, vektor const& v, gaussinfo const& U,
polynom& o, vector<K>& f)
{
gaussinfo U2;
vektor lin_komb, //Vektor mit der Linear Kombination
// der A^i*v zum Nullvektor
v2 = v; // Kopie des Originalvektors v
bool lin_unabh = true;
// Kopie von gaussinfo
U2 = U;
int anz_basisU = U2.A.size();//Dimension von U
//Der Vektor v wird eingefügt in Gauss
lin_unabh = gauss(U2, v2, lin_komb);
if( !lin_unabh ) { //Falls der Gauss linear abhängig liefert, war v im Uterraum U, also
o.clear(); // 0 in V/U. Das Minimalpolynom ist dann 1 .
o.push_back(1);
f = lin_komb;
return o;
}
do { //Die Potenzen (A^i)*v werden eingefügt
v2 = A*v2; //bis (A^k)*v linear abhängig von den bisher eingefügten (A^i)*v
lin_unabh = gauss(U2, v2, lin_komb); // mit (i<k)
} while (lin_unabh);
//Der Anteil der linear Kombination, der in U liegt
//wird in f geschrieben und anschließend aus lin_komb gelöscht.
//Dies geschieht mit Hilfe von Iteratoren
f = vektor( lin_komb.begin(),
(lin_komb.begin() + anz_basisU ) );
lin_komb.erase(lin_komb.begin(),
(lin_komb.begin() + anz_basisU ) );
//Aus der verkürzten lin_komb wird das Ordnungspolynom
//erzeugt
o.assign(lin_komb.begin(), lin_komb.end() );
o = K(-1)*o;
o.push_back(1); // Die 1 steht für den letzten Vektor
return o;
}
vektor& mult(polynom const& p, matrix const& A, vektor const& v,
vektor& ret)
{
if( deg(p)<1 ) {
// Wenn das Nullpolynom vorliegt, wird der Nullvektor zurückgegeben.
if( p.size() == 0 ) {
ret = vektor( v.size(),0);
return ret;
}
ret = p[0]*v;
return ret;
}
ret = horner(A,v,p,0,ret);
return ret;
}
// Used to calculate random generation of points
vector<int> Assignment2::randomGenerate(int N, int M)//Flyodd Algo
{
vector<unsigned char> is_used(N, 0); /* flags */
int in, im;
vector<int> vektor(M);
im = 0;
for (in = N - M; in < N && im < M; ++in) {
int r = rand() % (in + 1); /* generate a random number 'r' */
if (is_used[r])
/* we already have 'r' */
r = in; /* use 'in' instead of the generated number */
assert(!is_used[r]);
vektor[im++] = r + 1; /* +1 since your range begins from 1 */
is_used[r] = 1;
}
assert(im == M);
return vektor;
}
/* inline */ vektor operator ^ ( const vektor &u, const vektor& v )
{
return vektor( u.a[1]*v.a[2]-u.a[2]*v.a[1],
u.a[2]*v.a[0]-u.a[0]*v.a[2],
u.a[0]*v.a[1]-u.a[1]*v.a[0] );
}
/* inline */ vektor operator - ( const vektor& u, const vektor& v )
{
return vektor( u.a[0] - v.a[0],
u.a[1] - v.a[1],
u.a[2] - v.a[2] );
}
/* inline */ vektor operator + ( const vektor& u, const vektor& v )
{
return vektor( u.a[0] + v.a[0],
u.a[1] + v.a[1],
u.a[2] + v.a[2] );
}
/* inline */ vektor operator / ( const vektor& u, double t )
{
return vektor( u.a[0] / t,
u.a[1] / t,
u.a[2] / t );
}
/* inline */ vektor operator * (double t, const vektor& u )
{
return vektor( t * u.a[0],
t * u.a[1],
t * u.a[2] );
}
/* inline */ vektor operator * ( const vektor& u, double t )
{
return vektor( u.a[0] * t,
u.a[1] * t,
u.a[2] * t );
}
/* inline */ vektor operator - ( const vektor& u )
{
return vektor( -u.a[0],
-u.a[1],
-u.a[2] );
}
