int main()
{
vtkSmartPointer<vtkPolyDataMapper> mapper = pointGrid();
/* Assinging the mapper to an actor */
vtkSmartPointer<vtkActor> actor = vtkActor::New();
actor->SetMapper(mapper);
actor->GetProperty()->SetColor(1, 0, 0);
/* Adding the ray casting shader to the actor */
vtkSmartPointer<vtkOpenGLProperty> property =
vtkOpenGLProperty::New();
/* Enable shading in the property, otherwise shaders are not applied */
property->ShadingOn();
vtkSmartPointer<vtkShaderProgram2> program = createSphereShadingProgram();
property->SetPropProgram(program);
actor->SetProperty(property);
/* Creating the renderer and the render window */
vtkSmartPointer<vtkRenderer> renderer = vtkRenderer::New();
renderer->AddActor(actor);
renderer->SetBackground(0.2, 0.3, 0.4);
vtkSmartPointer<vtkRenderWindow> window = vtkRenderWindow::New();
window->SetSize(800, 800);
window->AddRenderer(renderer);
/* Creating the interactor that handles the window events and provides
the main rendering loop */
vtkSmartPointer<vtkRenderWindowInteractor> interactor =
vtkRenderWindowInteractor::New();
interactor->SetRenderWindow(window);
interactor->Initialize();
interactor->Start();
}
HashGrid3<Vector3> Docking::createHashGrid(){
float min_x = 1000;
float min_y = 1000;
float min_z = 1000;
float max_x = -1000;
float max_y = -1000;
float max_z = -1000;
//iterate over all atoms of protein A to calc dimesion (s. calcSASSurface)
for (vector<Vector3>::iterator a_it = positionsA.begin(); a_it != positionsA.end(); a_it++){
Vector3 vec = *a_it;
if (vec.x > max_x){
max_x = vec.x;
}
if (vec.x < min_x){
min_x = vec.x;
}
if (vec.y > max_y){
max_y = vec.y;
}
if (vec.y < min_y){
min_y = vec.y;
}
if (vec.z > max_z){
max_z = vec.z;
}
if (vec.z < min_z){
min_z = vec.z;
}
}
float x = max_x - min_x;
float y = max_y - min_y;
float z = max_z - min_z;
x = ceil(x);
y = ceil(y);
z = ceil(z);
Vector3 dim(x, y, z);
Vector3 origin(min_x, min_y, min_z);
HashGrid3<Vector3> pointGrid(origin,dim, 4.0);
Vector3 vec2;
for (vector<Vector3>::iterator A_it= positionsA.begin(); A_it != positionsA.end(); ++A_it){
vec2 = *A_it;
pointGrid.insert(vec2,vec2);
}
return pointGrid;
}
void Test::doubleHash(){
/*Triangle t1 = pair.first;
Triangle t2 = pair.second;
Vector3 normal2 = t2.getNormal();
Vector3 normal1 = t1.getNormal();
Angle flatten = normal2.getAngle(normal1);
cout<< "winkel vorher " << flatten.toDegree()<< endl;
//Berechnung Kreuzprodukt: Rotationsachse, um Dreiecke in selbe Ebene zu drehen
Vector3 rotationaxis = normal2%normal1;
//wir wissen nicht wieso 4x4 statt 3x3 aber wir vertrauen mal der CodeLibrary
Matrix4x4 matF;
matF.setRotation(flatten, rotationaxis);
//Verschiebung Dreieck2 in den Ursprung + Rotation, damit in paralleler Ebene zu Dreieck1
Vector3 toOrigin = t2.getCentroid().negate();
t2.shift(toOrigin);
t2.rotate(matF);
//Test ob die rotation richtig verlief...
//jetzt stellt sich die Frage wie soll das gehen wenn es ungenau sein kann-.-
// winkel verdoppeln sich--> d.h. dreht genau falsch rumm
// nach vertauschen im kreutprodukt von normale 1und normale 2 immer 00000 yeeeeees
Angle flattentest =(t2.getNormal()).getAngle(normal1);
cout<< "winkel nach ebenenrotation " << flattentest.toDegree()<< endl;
Vector3 shiftback = t1.getCentroid(); //Rückverschiebung für proteine merken
//Verschiebung Dreieck1 auf Origin
t1.shift(shiftback.negate());
//berechnung neuer schwerpunkte wegen Ungenauigkeiten liegen sie leider nicht exakt im Ursprung
Vector3 center2onOrigin = t2.getCentroid();
Vector3 center1onOrigin = t1.getCentroid();
//Berechnung Verbindungsvektor Schwerpunkt->Mitte kürzeste Seite von Dreieck1
Vector3 a1 = t1.getMinSide().getPoints().first;
Vector3 b1 = t1.getMinSide().getPoints().second;
Vector3 strecke1 = b1-a1;
Vector3 middle1 = a1 + (strecke1)*0.5; //MERKE: REIHENFOLGE BEI MULTIPLIKATION MIT VEKTOREN VERDAMMT WICHTIG -.-
Vector3 middle1TOcenter1 = middle1-center1onOrigin;
//Berechnung Verbindungsvektor Schwerpunkt->Mitte kürzeste Seite von Dreieck2
Vector3 a2 = t2.getMinSide().getPoints().first;
Vector3 b2 = t2.getMinSide().getPoints().second;
Vector3 strecke2 = b2-a2;
Vector3 middle2 = a2 + (strecke2) * 0.5;
Vector3 middle2TOcenter2 = middle2-center2onOrigin;
//Berechnung Winkel zw. den beiden Verbindungsvektoren
Angle congruent = middle2TOcenter2.getAngle(middle1TOcenter1);
Matrix4x4 matC;
//Dreieck2 wird verschoben, während Dreieck1 an seiner Position bleibt -> man braucht für Rotation
//wenn Dreieck2 bereits in der Ebene von Dreieck1 ist (aus Dreieck1 liegt) die Normale von Dreieck1 = a
matC.setRotation(congruent, normal1);
t2.rotate(matC);
float test = testcongruent(t1,t2);
if ( test < 2.0 ) {
cout << "richtige Winkel "<< test <<endl;
}
//Korrektur notwendig
else {
//Fall1 Winkel wurde kleiner
if(test< congruent.toDegree()){
cout << "Fall1 test<c" << endl;
cout << "congruent " << congruent.toDegree() << endl;
cout << "test " << test << endl;
Angle anglecorrect(test,false);
Matrix4x4 matnew;
matnew.setRotation(anglecorrect,normal1);
t2.rotate(matnew);
float end = congruent.toDegree()+test;
Angle newcongruent(end,false);
matC.setRotation(newcongruent,normal1);
float keinplanmehr = testcongruent(t1,t2);
if(keinplanmehr < 2.0){
cout<< "korrektur1 hat funktioniert " << keinplanmehr<< endl;
}
else {
cout<< "wenn ich hier lande ist alles schiefgelaufen1" << keinplanmehr<< endl;
//keine ahnung was man dann noch amchen kann deswegen würd ich sdagen wir werfen das paar weg
}
}
else {
cout<< "Fall2 test>c " << endl;
cout << "congruent " << congruent.toDegree() << endl;
cout << "test " << test << endl;
float correction = 360.0 - 2*(congruent.toDegree());
Angle anglecorrect( correction, false);
Matrix4x4 matnew;
matnew.setRotation(anglecorrect,normal1);
t2.rotate(matnew);
//kann man eine rotationsmatrix einfach überschreiben????
float end = 360.0 - congruent.toDegree();
Angle newcongruent(end,false);
matC.setRotation(newcongruent,normal1);
float keinplanmehr = testcongruent(t1,t2);
if(keinplanmehr < 2.0){
cout<< "korrektur2 hat funktioniert " << keinplanmehr<< endl;
}
else {
cout<< "wenn ich hier lande ist alles schiefgelaufen2" << keinplanmehr<< endl;
//keine ahnung was man dann noch amchen kann deswegen würd ich sdagen wir werfen das paar weg
}
}
}
//TODO: schlussüberprüfung ob Ebene richtig gedreht wurde
bool isok =testflatten(t1,t2);
if(!isok){
cout<< "Korrektur notwendig!" << endl;
Angle a180(180,false);
Matrix4x4 matcorrection;
matcorrection.setRotation(a180,rotationaxis);
t2.rotate(matcorrection);
//jetzt muss man eigentlich den ganzen quatsch von oben wiederholen>.<
bool test = testflatten(t1,t2);
if (test){
cout<< "lääuft" << endl;
matF = matF*matcorrection;
}
else cout << "probleeem" << endl;
}
Conformation fertig(make_pair(t1.getProtein(),t2.getProtein()),toOrigin,shiftback,matF,matC);
return fertig;*/
Vector3 origin(0,0,0);
vector<BALL::Vector3> vector;
HashGrid3<Vector3> pointGrid(origin,6,6,6, 1.0);
pointGrid.insert(points[0], points[0]);
pointGrid.insert(points[1], points[1]);
pointGrid.insert(points[2],points[2]);
pointGrid.insert(points[2],points[3]);
HashGrid3<Vector3>::BoxIterator box_it = pointGrid.beginBox();
HashGridBox3<Vector3>::DataIterator data_it;
int boxEmpty = 0;
for (; box_it != pointGrid.endBox(); ++box_it){
data_it = box_it->beginData();
if (box_it->getSize() > 0){
for (; data_it != box_it->endData(); ++data_it){
vector.push_back(*data_it);
cout << "Data: "<< *data_it << endl; ;
}
} else {
boxEmpty += 1;
}
}
cout << "Number of empty boxes: " << boxEmpty << endl;
cout << "Number of critical points: " << vector.size() << endl;
}
