Changeset 1212 for applications/robust

Timestamp:

10/06/10 18:13:42 (15 years ago)

Author:

sindj

Message:

Pokracovani split - nedokonceno. JS

Files:

• applications/robust/robustlib.h (modified) (5 diffs)

applications/robust/robustlib.h

@@ -264 +264 @@
 
 
-        void send_state_message(polyhedron* sender, bool shouldsplit, bool shouldmerge, int level)
+        void send_state_message(polyhedron* sender, vec toadd, vec toremove, int level)
         {                       
 
+                bool should_remove = (toremove.size() != 0);
+                bool should_add    = (toadd.size() != 0);
+                
                 if(shouldsplit||shouldmerge)
                 {
@@ -384 +387 @@
                                                                 {
                                                                         current_parent->set_state(-1, SPLIT);
+
+                                                                        ((toprow*)current_parent)->condition-=toadd;
                                                                 }
                                                                 else if(current_parent->positivechildren.size()>0)
                                                                 {
-                                                                current_parent->set_state(1, SPLIT);
+                                                                        current_parent->set_state(1, SPLIT);
+
+                                                                        ((toprow*)current_parent)->condition+=toadd;
                                                                 }
                                                                 else
@@ -422 +429 @@
                 create_statistic(number_of_parameters);
 
-                for(int i = 0;i<statistic.size();i++)
+                for(vector<vector<polyhedron*>::iterator local_iter = statistic.begin();local_iter<statistic.end();local_iter++)
                 {
                         vector<polyhedron*> empty_split;
@@ -519 +526 @@
                         {
                                 vec appended_vec = current_vertex->get_coordinates();
-                                appended_vec.ins(0,1.0);
+                                appended_vec.ins(0,-1.0);
 
                                 if(should_add)
@@ -548 +555 @@
                         }
 
-                        send_state_message(current_vertex, should_add, should_remove, 0);                       
-                }
-
-                for(vector<vector<polyhedron*>>::iterator vert_ref = for_splitting.begin();vert_ref<for_splitting.end();vert_ref++)
-                {
-                        int original_size = (*vert_ref).size();
-
-                        for(int split_counter = 0;split_counter<original_size;split_counter++)
-                        {
-                                polyhedron* current_polyhedron = (*vert_ref)[original_size-1-split_counter];
-
-                                
+                        send_state_message(current_vertex, toadd, toremove, 0);                 
+                }
+
+                if(should_add)
+                {
+                        for(vector<vector<polyhedron*>>::iterator vert_ref = for_splitting.begin();vert_ref<for_splitting.end();vert_ref++)
+                        {
+                                int original_size = (*vert_ref).size();
+
+                                for(int split_counter = 0;split_counter<original_size;split_counter++)
+                                {
+                                        polyhedron* current_polyhedron = (*vert_ref)[original_size-1-split_counter];
+
+                                        polyhedron* new_totally_neutral_child;
+                                        
+                                        if(vert_ref == for_splitting.begin())
+                                        {
+                                                vec coordinates1 = ((vertex*)current_polyhedron->children[0])->get_coordinates();                                               
+                                                vec coordinates2 = ((vertex*)current_polyhedron->children[1])->get_coordinates();
+                                                coordinates2.ins(0,-1.0);
+                                                
+                                                double t = (-toadd*coordinates2)/(toadd(1,toadd.size()-1)*coordinates1)+1;
+
+                                                vec new_coordinates = coordinates1*t+(coordinates2(1,coordinates2.size()-1)-coordinates1);                                      
+
+                                                vertex* neutral_vertex = new vertex(new_coordinates);
+
+                                                new_totally_neutral_child = neutral_vertex;
+                                        }
+                                        else
+                                        {
+                                                toprow* neutral_toprow = new toprow();
+
+                                                new_totally_neutral_child = neutral_toprow;
+                                        }
+                                        
+                                        new_totally_neutral_child->children.insert(new_totally_neutral_child->children.end(),
+                                                                                                                current_polyhedron->totallyneutralgrandchildren.begin(),
+                                                                                                                                current_polyhedron->totallyneutralgrandchildren.end());
+
+                                        toprow* positive_poly = new toprow(((toprow*)current_polyhedron)->condition+toadd);
+                                        toprow* negative_poly = new toprow(((toprow*)current_polyhedron)->condition-toadd);
+
+                                        positive_poly->children.push_back(new_totally_neutral_child);
+                                        negative_poly->children.push_back(new_totally_neutral_child);
+
+                                        positive_poly->parents.insert(positive_poly->parents.end(),
+                                                                                                current_polyhedron->parents.begin(),
+                                                                                                                current_polyhedron->parents.end());
+
+                                        negative_poly->parents.insert(negative_poly->parents.end(),
+                                                                                                current_polyhedron->parents.begin(),
+                                                                                                                current_polyhedron->parents.end());
+
+                                        positive_poly->children.insert(positive_poly->children.end(),
+                                                                                                current_polyhedron->positivechildren.begin(),
+                                                                                                                        current_polyhedron->positivechildren.end());
+
+                                        negative_poly->children.insert(negative_poly->children.end(),
+                                                                                                current_polyhedron->negativechildren.begin(),
+                                                                                                                        current_polyhedron->negativechildren.end());
+
+                                        
+                                        
+
+
+                                        
+                                }
                         }
                 }