dep

-
1. preduvance

32(d)
Tz(x 3,

(ni , nj nk)
·
n ,

&

T (Jez) Tz(x2 Yuza),

Out

La

Implementaca

-
I
/
/
/
I/

reci
↓ kucne

pa
⑮

blok toy tipase

~
-

puta
S

vise
Italic
moze ponzuljati

re engine
· float medrosti
 #include "stdafx.h"
int main(int argc, char* argv[])
#include <windows.h> {

#include "mymath.h"//za rad sa Vektorima i Matricama

#include "project_config.h" vtkSphereSource* L1=vtkSphereSource::New();

L1->SetRadius(L.r);
#include "vtkActor.h"
#include "vtkConeSource.h"
L1->SetPhiResolution(10);
#include "vtkSphereSource.h" L1->SetThetaResolution(10);
#include "vtkCylinderSource.h"
#include "vtkInteractorStyleTrackballCamera.h"
#include "vtkPolyDataMapper.h"
#include "vtkRenderWindow.h" vtkPolyDataMapper* maper=vtkPolyDataMapper::New();
#include "vtkRenderWindowInteractor.h" maper->SetInput(L1->GetOutput());
#include "vtkRenderer.h"
#include "vtkCamera.h"
#include "vtkPolyData.h"
vtkActor* aL1=vtkActor::New();
#include "vtkCellArray.h" aL1->SetMapper(maper);
#include "vtkLightCollection.h" aL1->GetProperty()->SetColor(1.0,0,0);
#include "vtkLight.h"
#include "vtkProperty.h"
#include "vtkAxesActor.h"
#include "vtkCaptionActor2D.h" vtkTable* table =vtkTable::New();//pravi strukturu podataka
#include "vtkCubeSource.h" //pomocu FloatArray
#include "vtkTransform.h"
#include "vtkMatrix4x4.h"
//za kasnije crtanje grafika
#include "vtkTextProperty.h"
#include "vtkTextMapper.h"
#include "vtkActor2D.h" vtkFloatArray* arrayt = vtkFloatArray::New();//vreme
#include "string.h"
#include "vtk3DSImporter.h" arrayt->SetName("Vreme");
#include "vtkCubeSource.h" table->AddColumn(arrayt);
#include "vtkJPEGReader.h"
#include "vtkTexture.h"
#include "vtkTextureMapToSphere.h"
vtkFloatArray* arrayp = vtkFloatArray::New();//putanja
#include "vtkTransformTextureCoords.h" arrayp->SetName("Pozicija");
#include "vtkPlane.h" table->AddColumn(arrayp);
#include "vtkLine.h"
#include "vtkLightCollection.h"
#include "vtkLightActor.h" table->SetNumberOfRows(2001);//broj vrsta za tabelu
#include "vtkOBJReader.h"
#include "vtkDecimatePro.h"
#include "vtkSTLReader.h"
#include "vtkTriangleFilter.h"
vtkRenderer* ren=vtkRenderer::New();
#include "vtkQuadricDecimation.h"
#include "vtkPolyDataReader.h" ren->AddActor(aL1);//lopta
#include "vtkSmoothPolyDataFilter.h" ren->GetActiveCamera()->SetPosition(100,0,0);
#include "vtkPolyDataNormals.h"
#include "vtkTable.h"
#include "vtkFloatArray.h"
#include "vtkChartXY.h" ren->SetBackground(0.5,0.5,0.5);
#include "vtkPlot.h"
#include "vtkContextView.h"
vtkRenderWindow* rwin=vtkRenderWindow::New();
#include "vtkContextScene.h" rwin->SetSize(1000,800);
#include "vtkLinearSubdivisionFilter.h" rwin->AddRenderer(ren);
#include "vtkButterflySubdivisionFilter.h"
#include "vtkLineSource.h"
#include "vtkCommand.h" vtkRenderWindowInteractor* iren=vtkRenderWindowInteractor::New();
#include "vtkLineWidget.h"
#include <time.h> iren->SetRenderWindow(rwin);

table->SetValue(0, 0, t);//Prva vrsta, prva kolona, t

double t=0.0;//pocetno vreme table->SetValue(0,1,L.Pp.y);//Prva vrsta, druga kolona pozicija
double dt=0.005;//korak

class Loptica{
for(int i=1;i<=2000;i++){
public:
//za slobodan pad t=t+dt;
Vector Pp;//Pocetna pozicija
Vector G;//Ubrzanje zemljine teze table->SetValue(i, 0, t);
double r;//Poluprecnik loptice, za iscrtavanje same loptice
Loptica();//Konstruktor table->SetValue(i, 1, Pozicija().y);

//hitac nanize L1->SetCenter(0.0,Pozicija().y,0.0);//postavi da lopta bude na

Vector Vp;//Pocetna brzina navedenoj poziciji
//sustinski se menja samo y koordinata, jer pada vertikalno na dole
};
rwin->Render();
Loptica::Loptica(){ }
//Slobodan pad
G=Vector(0,-9.81,0); //Klasa za crtanje xy grafika
Pp=Vector(0,20,0); vtkChartXY* chart = vtkChartXY::New();
r=0.9;//zbog iscrtavanja loptice //kalsa za generisanje onog sto se vidi na grafiku
vtkContextView* view =vtkContextView::New();
//hitac nanize ili navise //u scenu dodatj xy grafik
Vp=Vector(0,40,0);//Pocetna brzina za navise view->GetScene()->AddItem(chart);

//Vp=Vector(0,-40,0);//Pocetna brzina za nanize, testirati i jedno i drugo //napokon i sam grafik, tj. iscrtavanje podatak iz table
//analizirati grafik vtkPlot *plot = chart->AddPlot(vtkChart::LINE);
//za sve tipove pogledati https://examples.vtk.org/site/Cxx/Plotting/
LinePlot/
} plot->SetInput(table, 0, 1);//iz tabele pokupi podata sa pozicije 0,1
plot->SetColor(0.0, 1.0,0.0);//iz tabele uzmi podatak sa pozicije 1,0
plot->SetWidth(3.0);

Loptica L;//globalni objekat nase klase

view->SetRenderWindow(rwin);
Vector Pozicija(){//predjeni put loptice, na osnovu toga dobijena trenutna pozicija
iren->SetRenderWindow(rwin);

Vector PozicijaSlobodanPad=L.G*t*t/2+L.Pp; iren->Initialize();

Vector PozicijaHitac=L.G*t*t/2+L.Pp+L.Vp*t; iren->Start();

return 0;
//return PozicijaSlobodanPad; }
return PozicijaHitac;

}
class Loptica{ void Loptica::RK()//Runge-Kute integracija
{
public: Vector k1, k2, k3, k4;
//za slobodan pad Vector l1, l2, l3, l4;
Vector Pp;//Pocetna pozicija
Vector G;//Ubrzanje zemljine teze k1 = dt * Vrk;
double r;//Poluprecnik loptice, za iscrtavanje same loptice l1 = dt * Ubrzanje(Prk, Vrk);
Loptica();//Konstruktor k2 = dt * (Vrk + l1/2);
l2 = dt * Ubrzanje(Prk + k1/2, Vrk + l1/2);
//hitac nanize k3 = dt * ( Vrk + l2/2);
Vector Vp;//Pocetna brzina l3 = dt * Ubrzanje(Prk + k2/2, Vrk + l2/2);
k4 = dt * (Vrk + l3);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// l4 = dt * Ubrzanje(Prk + k3, Vrk + l3);
//za 8.2
Vector F;//Sila Prk += k1/6 + k2/3 + k3/3 + k4/6;
double k;//koeficijent viskoznog trenja Vrk += l1/6 + l2/3 + l3/3 + l4/6;
Vector a;//Ubrzanje tela }
double m;//masa ////////////////////////////////////////////////////////////////////////////////////////////////////////
void Sila(Vector); /////////////////////////////
Vector Ubrzanje(Vector,Vector);//ubrzanje

Loptica L;//globalni objekat nase klase

//za integracije Vector Pozicija(){//predjeni put loptice, na osnovu toga dobijena trenutna
Vector Po;//Pozicija Euler pozicija
Vector Prk;//Pozicija RK
Vector Vo;//Brzina Euler
Vector Vrk;//Brzina RK Vector PozicijaSlobodanPad=L.G*t*t/2+L.Pp;
void Euler1();//implicitna Vector PozicijaHitac=L.G*t*t/2+L.Pp+L.Vp*t;
void Euler2();//polu-implicitna
void RK();//Runge-Kute
//return PozicijaSlobodanPad;
///////////////////////////////////////////////////////////////////////////////////////////////
}; ///////////////////////////////////////
return PozicijaHitac;//za 8.2 obavezno, zbog sile
//ako se za 8.2 vraca PozicijaSlobodanPad, neophodno staviti da je
pocetna brzina 0 (linija 114)

Loptica::Loptica(){ }
//Slobodan pad
G=Vector(0,-9.81,0);
Pp=Vector(0,20,0);
r=0.9;//zbog iscrtavanja loptice
int main(int argc, char* argv[])
//hitac nanize ili navise {
Vp=Vector(0,40,0);//Pocetna brzina za navise

//Vp=Vector(0,-40,0);//Pocetna brzina za nanize, testirati i jedno i drugo //Objekat za loptu

//analizirati grafik vtkSphereSource* L1=vtkSphereSource::New();
L1->SetRadius(L.r);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// L1->SetPhiResolution(10);
//za 8.2 L1->SetThetaResolution(10);
k=0.5;//Koeficijent viskozog trenja
m=0.05;
vtkPolyDataMapper* maper=vtkPolyDataMapper::New();
Po=Pp;//Podesi pocetne pozicije i brzine sa Ojler i RK integraciju maper->SetInput(L1->GetOutput());
Prk=Pp;
Vo=Vp; vtkActor* aL1=vtkActor::New();//Lopta za tačno rešenje
Vrk=Vp; aL1->SetMapper(maper);
aL1->GetProperty()->SetColor(1.0,0,0);
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// vtkTable* table =vtkTable::New();//pravi strukturu podataka

//za 8.2 //pomocu FloatArray
//za kasnije crtanje grafika
double dt=0.005;//Korak integracije
double t=0.0;//pocetno vreme
vtkFloatArray* arrayt = vtkFloatArray::New();//vreme
arrayt->SetName("Vreme");
void Loptica::Sila(Vector v){//Sile koje deluju na telo table->AddColumn(arrayt);

F=m*G;//Slobodan pad vtkFloatArray* arrayp = vtkFloatArray::New();//putanja

//F=m*G-k*m*v;//Slobodan pad sa otporom arrayp->SetName("Pozicija");
table->AddColumn(arrayp);
}

Vector Loptica::Ubrzanje(Vector p,Vector v){

Sila(v);
a=F/m;
return a; /////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
} //za 8.2
vtkFloatArray* arraypEuler = vtkFloatArray::New();//putanja
void Loptica::Euler1(){//Ojlerova integracija arraypEuler->SetName("PozicijaEuler");
Vector pnew = Po + Vo*dt; table->AddColumn(arraypEuler);
Vo += Ubrzanje(Po,Vo)*dt;
Po = pnew; vtkFloatArray* arraypRK = vtkFloatArray::New();//putanja
arraypRK->SetName("PozicijaRK");
} table->AddColumn(arraypRK);
/////////////////////////////////////////////////////////////////////////////////////////////
void Loptica::Euler2(){//Ojlerova polu-implicitna integracija //////////////////////////////

Vo += Ubrzanje(Po,Vo)*dt;
Vector pnew = Po + Vo*dt;
Po = pnew;

}
 table->SetNumberOfRows(2001);//broj vrsta za tabelu

vtkRenderer* ren=vtkRenderer::New();

ren->AddActor(aL1);//lopta
ren->GetActiveCamera()->SetPosition(100,0,0);

ren->SetBackground(0.5,0.5,0.5);
vtkRenderWindow* rwin=vtkRenderWindow::New();
rwin->SetSize(1000,800);
rwin->AddRenderer(ren);

vtkRenderWindowInteractor* iren=vtkRenderWindowInteractor::New();

iren->SetRenderWindow(rwin);

table->SetValue(0, 0, t);//Prva vrsta, prva kolona, t

table->SetValue(0,1,L.Pp.y);//Prva vrsta, druga kolona pozicija

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//za 8.2
table->SetValue(0,2,L.Po.y);
table->SetValue(0,3,L.Prk.y);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

for(int i=1;i<=2000;i++){

t=t+dt;

table->SetValue(i, 0, t);

table->SetValue(i, 1, Pozicija().y);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////
L.Euler1();
L.RK();
table->SetValue(i, 2, L.Po.y);
table->SetValue(i, 3, L.Prk.y);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///

L1->SetCenter(0.0,Pozicija().y,0.0);//postavi da lopta bude na navedenoj poziciji

//sustinski se menja samo y koordinata, jer pada vertikalno na dole

rwin->Render();
}

//Klasa za crtanje xy grafika

vtkChartXY* chart = vtkChartXY::New();
//kalsa za generisanje onog sto se vidi na grafiku
vtkContextView* view =vtkContextView::New();
//u scenu dodatj xy grafik
view->GetScene()->AddItem(chart);

//napokon i sam grafik, tj. iscrtavanje podatak iz table

vtkPlot *plot = chart->AddPlot(vtkChart::LINE);
//za sve tipove pogledati https://examples.vtk.org/site/Cxx/Plotting/LinePlot/
plot->SetInput(table, 0, 1);//iz tabele pokupi podata sa pozicije 0,1
plot->SetColor(0.0, 1.0,0.0);
plot->SetWidth(3.0);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//za 8.2
vtkPlot *plotEuler = chart->AddPlot(vtkChart::LINE);
plotEuler->SetInput(table, 0, 2);
plotEuler->SetColor(1.0, 0.0,0.0);
plotEuler->SetWidth(3.0);

vtkPlot *plotRK = chart->AddPlot(vtkChart::LINE);

plotRK->SetInput(table, 0, 3);
plotRK->SetColor(0.0, 0.0,1.0);
plotRK->SetWidth(3.0);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

view->SetRenderWindow(rwin);

iren->SetRenderWindow(rwin);

iren->Initialize();
iren->Start();

return 0;
}
double dt=0.005;//Korak integracije
double t=0.0;//pocetno vreme Vector Loptica::Ubrzanje(Vector p,Vector v){
Sila(v);
a=F/m;
class Loptica{ return a;

public: }
//za slobodan pad
Vector Pp;//Pocetna pozicija void Loptica::Euler1(){//Ojlerova integracija
Vector G;//Ubrzanje zemljine teze //////////////////////////////////////////////////////////////////////////////////////////////
double r;//Poluprecnik loptice, za iscrtavanje same loptice //vezba 9
Loptica();//Konstruktor PoP=Po;
Vector pnew = Po + Vo*dt;
//hitac nanize Vo += Ubrzanje(Po,Vo)*dt;
Vector Vp;//Pocetna brzina Po = pnew;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// }
//za 8.2
Vector F;//Sila void Loptica::Euler2(){//Ojlerova polu-implicitna integracija
double k;//koeficijent viskoznog trenja //////////////////////////////////////////////////////////////////////////////////////////////
Vector a;//Ubrzanje tela //vezba 9
double m;//masa PoP=Po;
void Sila(Vector); Vo += Ubrzanje(Po,Vo)*dt;
Vector Ubrzanje(Vector,Vector);//ubrzanje Vector pnew = Po + Vo*dt;
Po = pnew;

}
//za integracije
Vector Po;//Pozicija Euler
Vector Prk;//Pozicija RK const int br_ravni=1;
Vector Vo;//Brzina Euler const int br_loptica=1;
Vector Vrk;//Brzina RK Loptica L[br_loptica];
void Euler1();//integracija Loptica R[br_ravni];
void Euler2();//polu-implicitna

//vezba 9
Vector PoP;//prethodni/pocetni polozaj za Ojlera void ObjektiUsceni(){
bool sudar;//Da li se telo sudarilo
Vector n; R[0].n=Vector(0,1,0);//y je normalno nasu ravan, hocemo horizontalnu ravan
double offset; R[0].offset=0.0;
Vector Fsudara;

}; //Loptica
L[0].Vo=Vector(-4,-3,0);
L[0].G=Vector(0,-9.81,0);
Loptica::Loptica(){ L[0].Po=Vector(14.0, 4.0,-2.0);
//Slobodan pad L[0].r=0.4;
G=Vector(0,-9.81,0); L[0].m=0.3;
Pp=Vector(0,20,0);
r=0.9;//zbog iscrtavanja loptice
}
//hitac nanize ili navise
Vp=Vector(0,40,0);//Pocetna brzina za navise
void ProveriSudar(){//Funkcija za proveru sudara
//Vp=Vector(0,-40,0);//Pocetna brzina za nanize, testirati i jedno i drugo
//analizirati grafik Vector n;
Vector vr;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// double vrn;
//za 8.2
k=0.5;//Koeficijent viskozog trenja ////////////////////////////////////////////////////////////////////////////////////////////////////////
m=0.05; //Provera sudara, loptica-ravan
for(int k=0;k<br_loptica;k++){
Po=Pp;//Podesi pocetne pozicije i brzine sa Ojler i RK integraciju
Prk=Pp; L[k].Fsudara.x=0;
Vo=Vp; L[k].Fsudara.y=0;
Vrk=Vp; L[k].Fsudara.z=0;
L[k].sudar=false;
}
for(int i=0;i<br_ravni;i++){//Prvo za ravni!

if(L[k].Po*R[i].n<= L[k].r+R[i].offset) {//kontakt sa ravni

void Loptica::Sila(Vector v){
F.x=0.0; n=R[i].n;
F.y=0.0; n.Normalize();
F.z=0.0; vr = L[k].Vo;
vrn=vr*n;
if(sudar){//ako je doslo do sudara dodaj impulsnu silu koja nastaje kao rekacija na sudar
F+=Fsudara; if(vrn < 0.0) {
} double J = (vr*n) * (0.4 + 1) * L[k].m;//Impuls
else{//Nema sudara Vector Fi = -n;
//moze se sotaviti kao ranije samo slobodan pad, ali se moze dodati i utica vetra Fi *= J/dt;
Vector SmerVetra(1,0,0); L[k].Fsudara+= Fi;//dodaj impulsnu silu
double IntenzitetVetra=2;//Intenzitet vetra m/s
Vector Fvetra=SmerVetra*(0.5 * 1.23 * IntenzitetVetra*IntenzitetVetra*(3.14159 * r*r)*0.5); //Vrati nazad
double alf=acos(vr*n/vr.Magnitude());
F+=m*G;//slobodan pad, moze se dodati i uticaj vetra Fvetra double x=(L[k].PoP*R[i].n-(L[k].r+R[i].offset))/cos(alf);
//F=m*G-k*m*v;//Slobodan pad sa otporom sredine Vector nor;
} nor=-L[k].Vo;//Vektor suprotan brzini tela
} nor.Normalize();//Nadji jedinicni vektor
L[k].Po=L[k].PoP+nor*x;//Na poziciju dodaj nor*x

L[k].sudar = true;//Postoji sudar objekta sa ravni

}
}//Kraj preseka sa ravnima
}
}//Kraj provera loptica-ravan
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

}
vtkSphereSource* sphere[br_loptica];
vtkRenderWindow* rwin;

class vtkMojaFunkcija : public vtkCommand {

public: static vtkMojaFunkcija *New() { return new vtkMojaFunkcija;

virtual void Execute( vtkObject *caller, unsigned long, void*) {

vtkRenderWindowInteractor *iren = reinterpret_cast< vtkRenderWindowInteractor *> (caller);

if(!strcmp(iren->GetKeySym(),"k")){
ObjektiUsceni();
double t=0;
dt=0.001;
int korak=0;

while(t<=10){

t=t+dt;

ProveriSudar();

for(int k=0;k<br_loptica;k++){
sphere[k]->SetCenter(L[k].Po.x,L[k].Po.y,L[k].Po.z);

L[k].Euler2();//Integracija
}

korak++;
if(korak==5){//Iscrtavanje svakog 5-tog frejma
rwin->Render();
korak=0;
}
}
}
}
};
int main(int argc, char* argv[])
{
ObjektiUsceni();

//prikaz ravni o koju udara loptica

vtkCubeSource* cube=vtkCubeSource::New();
cube->SetBounds(0,10,-0.6,0,-5,0);
vtkPolyDataMapper* maperCube=vtkPolyDataMapper::New();
maperCube->SetInput(cube->GetOutput());

vtkActor* aCube=vtkActor::New();
aCube->SetMapper(maperCube);
aCube->GetProperty()->SetOpacity(0.2);

//prikaz loptice/a
vtkPolyDataMapper* maper[br_loptica];
vtkActor* aSphere[br_loptica];

for(int i=0;i<br_loptica;i++){//Za lopticu, for za kasnije kada bude bilo vise loptica
sphere[i]=vtkSphereSource::New();
sphere[i]->SetRadius(L[i].r);
sphere[i]->SetPhiResolution(20);
sphere[i]->SetThetaResolution(20);

maper[i]=vtkPolyDataMapper::New();
maper[i]->SetInput(sphere[i]->GetOutput());

aSphere[i]=vtkActor::New();
aSphere[i]->SetMapper(maper[i]);
}

aSphere[0]->GetProperty()->SetColor(0,1,0);

vtkRenderer* ren=vtkRenderer::New();
for(int i=0;i<br_loptica;i++){//Dodajemo lopticu u scenu, for ya kasnije kad bude bilo vise loptica
ren->AddActor(aSphere[i]);//Loptice
}

ren->AddActor(aCube);
//Prozor
rwin=vtkRenderWindow::New();
rwin->AddRenderer(ren);
rwin->SetSize(1000,800);

//Interaktor
vtkRenderWindowInteractor* iren=vtkRenderWindowInteractor::New();

iren->SetRenderWindow(rwin);

rwin->Render();

//Observer
vtkMojaFunkcija* cb =vtkMojaFunkcija::New();
iren->AddObserver(vtkCommand::KeyPressEvent, cb);

iren->SetRenderWindow(rwin);

iren->Initialize();
iren->Start();

return 0;

}
double dt=0.005;//Korak integracije
double t=0.0;//pocetno vreme
void Loptica::Euler1(){//Ojlerova integracija
/////////////////////////////////////////////////////////////////////////////////
class Loptica{ /////////////
//vezba 9
public: PoP=Po;
//za slobodan pad Vector pnew = Po + Vo*dt;
Vector Pp;//Pocetna pozicija Vo += Ubrzanje(Po,Vo)*dt;
Vector G;//Ubrzanje zemljine teze Po = pnew;
double r;//Poluprecnik loptice, za iscrtavanje same loptice
Loptica();//Konstruktor }

//hitac nanize void Loptica::Euler2(){//Ojlerova polu-implicitna integracija

Vector Vp;//Pocetna brzina /////////////////////////////////////////////////////////////////////////////////
/////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //vezba 9
//za 8.2 PoP=Po;
Vector F;//Sila Vo += Ubrzanje(Po,Vo)*dt;
double k;//koeficijent viskoznog trenja Vector pnew = Po + Vo*dt;
Vector a;//Ubrzanje tela Po = pnew;
double m;//masa
void Sila(Vector); }
Vector Ubrzanje(Vector,Vector);//ubrzanje
const int br_loptica=3;

//za integracije const int br_ravni_stepenice=2;

Vector Po;//Pozicija Euler
Vector Prk;//Pozicija RK Loptica L[br_loptica];
Vector Vo;//Brzina Euler Loptica ravni_stepenice[br_ravni_stepenice];
Vector Vrk;//Brzina RK
void Euler1();//integracija
void Euler2();//polu-implicitna void DefinisiObjekte_sa_Stepenicama(){

//vezba 9 ravni_stepenice[0].n=Vector(0,1,0);
Vector PoP;//prethodni/pocetni polozaj za Ojlera ravni_stepenice[0].offset=0.0;
bool sudar;//Da li se telo sudarilo
Vector n; ravni_stepenice[1].n=Vector(0,1,0);
double offset; ravni_stepenice[1].offset=3.0;
Vector Fsudara;

}; //Inicijalizacija loptica
L[0].Vo=Vector(-4,-3,0);
L[0].G=Vector(0,-9.81,0);
Loptica::Loptica(){ L[0].Po=Vector(14.0, 4.0,-2.0);
//Slobodan pad L[0].r=0.4;
G=Vector(0,-9.81,0); L[0].m=0.3;
Pp=Vector(0,20,0);
r=0.9;//zbog iscrtavanja loptice L[1].Vo=Vector(0,0,0);
L[1].G=Vector(0,-9.81,0);
//hitac nanize ili navise L[1].Po=Vector(2.0,0.4,-2.0);
Vp=Vector(0,40,0);//Pocetna brzina za navise L[1].r=0.4;
L[1].m=0.3;
//Vp=Vector(0,-40,0);//Pocetna brzina za nanize, testirati i jedno i drugo
//analizirati grafik L[2].Vo=Vector(0,0,0);
L[2].G=Vector(0.0,-9.81,0);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// L[2].Po=Vector(1.8,5.0,-2.01);
//za 8.2 L[2].r=0.5;
k=0.5;//Koeficijent viskozog trenja L[2].m=0.4;
m=0.05; //razmisliti sta treba postaviti od ovih parametara da bi bio
slobodan pad
Po=Pp;//Podesi pocetne pozicije i brzine sa Ojler i RK integraciju }
Prk=Pp;
Vo=Vp;
Vrk=Vp;

void Loptica::Sila(Vector v){

F.x=0.0;
F.y=0.0;
F.z=0.0;

if(sudar){//ako je doslo do sudara dodaj impulsnu silu koja nastaje kao rekacija na sudar

F+=Fsudara;

}
else{//Nema sudara
//moze se sotaviti kao ranije samo slobodan pad, ali se moze dodati i utica vetra
Vector SmerVetra(1,0,0);
double IntenzitetVetra=2;//Intenzitet vetra m/s
Vector Fvetra=SmerVetra*(0.5 * 1.23 * IntenzitetVetra*IntenzitetVetra*(3.14159 * r*r)*0.5);

F+=m*G;//slobodan pad, moze se dodati i uticaj vetra Fvetra

//F=m*G-k*m*v;//Slobodan pad sa otporom sredine
}

Vector Loptica::Ubrzanje(Vector p,Vector v){

Sila(v);
a=F/m;
return a;

}
void ProveriSudarStepenice(){//Funkcija za proveru sudara //Sada provera za medjusobne kontakte loptica

Vector n; for(int i=0;i<br_loptica;i++){

Vector vr;
double vrn; for(int j=i+1;j<br_loptica;j++)
{
//Prvo proveri sudare svih loptica sa statickim objektima! double r = L[i].r + L[j].r;
for(int k=0;k<br_loptica;k++){ Vector d = L[i].Po-L[j].Po;
double s = d.Magnitude()- r;
L[k].Fsudara.x=0;
L[k].Fsudara.y=0; if(s <= 0.0)
L[k].Fsudara.z=0; {
L[k].sudar=false; d.Normalize();
n = d;
if(L[k].Po.x < 10) Vector vr = L[i].Vo-L[j].Vo;
{ vrn = vr*n;
int i = 0; if(vrn < 0.0)
{
if(L[k].Po*ravni_stepenice[i].n<= L[k].r+ravni_stepenice[i].offset) double J = (vr*n) * (1.0+0.9 ) /(1/L[i].m+ 1/L[j].m);//Impuls
//kontakt sa ravni Vector Fi = -n;
{ Fi *= J/dt;
n=ravni_stepenice[i].n; L[i].Fsudara += Fi;//Sila prvog
n.Normalize();
vr = L[k].Vo; float s1,s2;
vrn=vr*n; s1=L[i].Vo*n;//Projekcije brzina na normalu
s2=L[j].Vo*n;
if(vrn < 0.0)
{ L[i].Po-= n*s*(s1/(abs(s1)+abs(s2)));//Vrati prvi objekat
double J = (vr*n) * (0.4 + 1) * L[k].m;//Impuls Predavanja 2 slajd 26
Vector Fi = -n; L[i].sudar = true;//Postoji sudar prvog
Fi *= J/dt;
L[k].Fsudara+= Fi;//dodaj ostalim silama usled sudara L[j].Fsudara+=-Fi;//Sila drugog suprotnog smera od prvog
L[j].sudar=true;//Postoji sudar drugog
//Sada vrati L[j].Po-= n*s*(s2/(abs(s1)+abs(s2)));//Vrati drugi objekat
double alf=acos(vr*n/vr.Magnitude());
double x=(L[k].PoP*ravni_stepenice[i].n-(L[k].r+ravni_stepenice[i].offset))/cos(alf); std::cout<<"Desio se sudar izmedju loptica"<<endl;
Vector nor;
nor=-L[k].Vo; //Vektor suprotan brzini tela }
nor.Normalize(); //Nadji jedinicni vektor }
L[k].Po=L[k].PoP+nor*x; //Na poziciju dodaj nor*x
}//j-brojac
L[k].sudar = true; //Postoji sudar objekta sa ravni }//i-brojac
}
}
} }
else
{
int i = 1; vtkSphereSource* sphere[br_loptica];//Globalni objekti pokretne loptice i nepokretna
vtkRenderWindow* rwin;//Prozor aplikacije
if(L[k].Po*ravni_stepenice[i].n<= L[k].r+ravni_stepenice[i].offset)
//kontakt sa ravni
{ class vtkMojaFunkcija : public vtkCommand {
n=ravni_stepenice[i].n;
n.Normalize(); public: static vtkMojaFunkcija *New() { return new vtkMojaFunkcija; }
vr = L[k].Vo;
vrn=vr*n;
virtual void Execute( vtkObject *caller, unsigned long, void*) {
if(vrn < 0.0)
{ vtkRenderWindowInteractor *iren = reinterpret_cast< vtkRenderWindowInteractor *> (caller);
double J = (vr*n) * (0.4 + 1) * L[k].m;//Impuls
Vector Fi = -n;
Fi *= J/dt; if(!strcmp(iren->GetKeySym(),"k")){
L[k].Fsudara+= Fi;//dodaj ostalim silama usled sudara DefinisiObjekte_sa_Stepenicama();
double t=0;
//Sada vrati dt=0.001;
double alf=acos(vr*n/vr.Magnitude()); int korak=0;
double x=(L[k].PoP*ravni_stepenice[i].n-(L[k].r+ravni_stepenice[i].offset))/cos(alf);
Vector nor; while(t<=10){
nor=-L[k].Vo; //Vektor suprotan brzini tela
nor.Normalize(); //Nadji jedinicni vektor
L[k].Po=L[k].PoP+nor*x; //Na poziciju dodaj nor*x t=t+dt;

L[k].sudar = true; //Postoji sudar objekta sa ravni ProveriSudarStepenice();

}
} for(int k=0;k<br_loptica;k++){
} sphere[k]->SetCenter(L[k].Po.x,L[k].Po.y,L[k].Po.z);

} L[k].Euler1();//Integracija
//Gotova provera za ravni objekte k-brojac }

korak++;
if(korak==5){//Crtaj svaki 5-ti frejm
rwin->Render();
korak=0;
}

};
int main(int argc, char* argv[])
{
DefinisiObjekte_sa_Stepenicama(); //definisanje dve ravni stepenice

//CubeSource za prikaz granica ravni

vtkCubeSource* cube1=vtkCubeSource::New(); //prikaz za ravan 0 preko cubeSourca
cube1->SetBounds(-5,10,-0.6,0,-5,0);
vtkPolyDataMapper* maperCube1=vtkPolyDataMapper::New();
maperCube1->SetInput(cube1->GetOutput());

vtkCubeSource* cube2=vtkCubeSource::New(); //prikaz za ravan 1 preko cubeSourca

cube2->SetBounds(10,20,2.6,3,-5,0);
vtkPolyDataMapper* maperCube2=vtkPolyDataMapper::New();
maperCube2->SetInput(cube2->GetOutput());

vtkActor* aC1=vtkActor::New();
aC1->SetMapper(maperCube1);
aC1->GetProperty()->SetOpacity(0.2);

vtkActor* aC2=vtkActor::New();
aC2->SetMapper(maperCube2);
aC2->GetProperty()->SetOpacity(0.2);

vtkPolyDataMapper* maper[br_loptica];
vtkActor* aL[br_loptica];

for(int i=0;i<br_loptica;i++){//Za loptice

sphere[i]=vtkSphereSource::New();
sphere[i]->SetRadius(L[i].r);
sphere[i]->SetPhiResolution(20);
sphere[i]->SetThetaResolution(20);

maper[i]=vtkPolyDataMapper::New();
maper[i]->SetInput(sphere[i]->GetOutput());

aL[i]=vtkActor::New();
aL[i]->SetMapper(maper[i]);
}

aL[0]->GetProperty()->SetColor(0,1,0);
aL[1]->GetProperty()->SetColor(0,0,1);
aL[2]->GetProperty()->SetColor(1,0,0);

vtkRenderer* ren=vtkRenderer::New();
for(int i=0;i<br_loptica;i++){//Dodajemo loptice u scenu
ren->AddActor(aL[i]);//Loptice
}

ren->AddActor(aC1);//ravan 0
ren->AddActor(aC2);//ravan 1

rwin=vtkRenderWindow::New();
rwin->AddRenderer(ren);
rwin->SetSize(1000,800);

vtkRenderWindowInteractor* iren=vtkRenderWindowInteractor::New();

iren->SetRenderWindow(rwin);

rwin->Render();

vtkMojaFunkcija* cb =vtkMojaFunkcija::New();//Klasa, pritisak tastera k

iren->AddObserver(vtkCommand::KeyPressEvent, cb);//Observer

iren->SetRenderWindow(rwin);

iren->Initialize();
iren->Start();

return 0;