Changeset 1356 for applications

Timestamp:

05/04/11 18:21:26 (13 years ago)

Author:

sindj

Message:

Opravena chyba s mazanim udaju v polyhedronu pres ktery se nemerguje kvuli vyssi nasobnosti stredu. JS

Files:

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

applications/robust/robustlib.h

@@ -804 +804 @@
                                 bool is_first = (current_parent->message_counter == 1);
 
+                                bool out_of_the_game = true;
+
                                 if(shouldmerge)
                                 {
@@ -826 +828 @@
                                                 if(parent_state == 1)
                                                 {
-                                                        ((toprow*)current_parent)->condition_sum-=toremove->value;
-                                                        ((toprow*)current_parent)->condition_order--;
+                                                        ((toprow*)current_parent)->condition_sum-=toremove->value;                                                      
                                                 }
 
                                                 if(parent_state == -1)
                                                 {
-                                                        ((toprow*)current_parent)->condition_sum+=toremove->value;
-                                                        ((toprow*)current_parent)->condition_order--;
+                                                        ((toprow*)current_parent)->condition_sum+=toremove->value;                                                      
                                                 }
+
+                                                ((toprow*)current_parent)->condition_order--;
+                                                
                                                 
                                                 if(current_parent->mergechild != NULL)
                                                 {
+                                                        out_of_the_game = false;
+
                                                         if(current_parent->mergechild->get_multiplicity()==1)
                                                         {
@@ -849 +854 @@
                                                                         current_parent->mergechild->negativeparent = current_parent;                                                    
                                                                 }
-                                                        }                                                       
+                                                        }
+                                                        else
+                                                        {
+                                                                out_of_the_game = true;
+                                                        }
                                                 }                                               
-                                                else
+                                                
+                                                if(out_of_the_game)
                                                 {
                                                         //current_parent->set_state(0,MERGE);   
@@ -985 +995 @@
                                                         }
 
-                                                        if(current_parent->mergechild == NULL)
+                                                        if(out_of_the_game)
                                                         {
                                                                 current_parent->positivechildren.clear();
@@ -1076 +1086 @@
                                 // cout << "Stepped." << endl;
 
+                                if(marker==101)
+                                {
+                                        if(!(*horiz_ref).negativechildren.empty()||!(*horiz_ref).positivechildren.empty()||!(*horiz_ref).neutralchildren.empty()||!(*horiz_ref).kids_rel_addresses.empty()||!(*horiz_ref).mergechild==NULL||!(*horiz_ref).negativeneutralvertices.empty())
+                                        {
+                                                cout << "Cleaning error!" << endl;
+                                        }
+                                
+                                }
+
                                 for(set<simplex*>::iterator sim_ref = (*horiz_ref).triangulation.begin();sim_ref!=(*horiz_ref).triangulation.end();sim_ref++)
                                 {
@@ -1285 +1304 @@
                                         local_condition = appended_coords*toadd;
 
-                                        cout << "Vertex multiplicity: "<< current_vertex->get_multiplicity() << endl;
+                                        // cout << "Vertex multiplicity: "<< current_vertex->get_multiplicity() << endl;
 
                                         current_vertex->set_state(local_condition,SPLIT);
@@ -1339 +1358 @@
                 }
 
-                //step_me(1);
+                // step_me(1);
                 
                 if(should_remove)
@@ -1376 +1395 @@
                                                 {
                                                         (*merge_ref)->lower_multiplicity();
+                                                }       
+
+                                                if((*merge_ref)->get_state(SPLIT)!=0||(*merge_ref)->totally_neutral)
+                                                {
+                                                        (*merge_ref)->positivechildren.clear();
+                                                        (*merge_ref)->negativechildren.clear();
+                                                        (*merge_ref)->neutralchildren.clear();                                          
+                                                        (*merge_ref)->totallyneutralgrandchildren.clear();                                              
+                                                        (*merge_ref)->positiveneutralvertices.clear();
+                                                        (*merge_ref)->negativeneutralvertices.clear();
+                                                        (*merge_ref)->totally_neutral = NULL;
+                                                        (*merge_ref)->kids_rel_addresses.clear();
                                                 }
                                         }
@@ -1384 +1415 @@
                                                 toprow* current_positive = (toprow*)(*merge_ref)->positiveparent;
                                                 toprow* current_negative = (toprow*)(*merge_ref)->negativeparent;
+
+                                                if(current_positive->totally_neutral!=current_negative->totally_neutral)
+                                                {
+                                                        throw new exception("Both polyhedrons must be totally neutral if they should be merged!");
+                                                }
 
                                                 //current_positive->condition_sum -= toremove;
@@ -1439 +1475 @@
                                                         current_positive->set_state(0,SPLIT);
                                                         for_splitting[k].push_back(current_positive);
+
                                                         will_be_split = true;
                                                 }
@@ -1477 +1514 @@
                                                 }
                                                 else
-                                                {
-                                                        if(!current_positive->totally_neutral)
-                                                        {
-                                                                current_positive->positivechildren.clear();
-                                                                current_positive->negativechildren.clear();
-                                                                current_positive->neutralchildren.clear();
-                                                                // current_positive->totallyneutralchildren.clear();
-                                                                current_positive->totallyneutralgrandchildren.clear();                                                          
-                                                                current_positive->positiveneutralvertices.clear();
-                                                                current_positive->negativeneutralvertices.clear();
-                                                                current_positive->totally_neutral = NULL;
-                                                                current_positive->kids_rel_addresses.clear();                                                           
-                                                        }
-                                                
-                                                }
-
-                                                                                                
+                                                {                                                       
+                                                        current_positive->positivechildren.clear();
+                                                        current_positive->negativechildren.clear();
+                                                        current_positive->neutralchildren.clear();
+                                                        // current_positive->totallyneutralchildren.clear();
+                                                        current_positive->totallyneutralgrandchildren.clear();                                                          
+                                                        current_positive->positiveneutralvertices.clear();
+                                                        current_positive->negativeneutralvertices.clear();
+                                                        current_positive->totally_neutral = NULL;
+                                                        current_positive->kids_rel_addresses.clear();                                           
+                                                }                                                                                               
                                                 
                                                 current_positive->vertices.insert(current_negative->vertices.begin(),current_negative->vertices.end());
@@ -1504 +1535 @@
                                                                 current_positive->vertices.erase(*vert_ref);
                                                                 
-                                                                if((current_positive->get_state(SPLIT)==0&&!current_positive->totally_neutral)||(current_negative->get_state(SPLIT)==0&&!current_negative->totally_neutral))
+                                                                if(will_be_split)
                                                                 {
                                                                         current_positive->negativeneutralvertices.erase(*vert_ref);
@@ -1517 +1548 @@
                                                 }
 
-                                                if(current_positive->totally_neutral)
-                                                {
-                                                        if(!current_negative->totally_neutral)
-                                                        {
-                                                                for(set<polyhedron*>::iterator grand_ref = current_positive->grandparents.begin();grand_ref!=current_positive->grandparents.end();grand_ref++)
-                                                                {
-                                                                        (*grand_ref)->totallyneutralgrandchildren.erase(current_positive);
-                                                                }                                                               
-                                                        }
-                                                        else
-                                                        {
-                                                                for(set<polyhedron*>::iterator grand_ref = current_negative->grandparents.begin();grand_ref!=current_negative->grandparents.end();grand_ref++)
-                                                                {
-                                                                        (*grand_ref)->totallyneutralgrandchildren.erase(current_negative);
-                                                                        (*grand_ref)->totallyneutralgrandchildren.insert(current_positive);
-                                                                }                                                               
-                                                        }
-                                                }
-                                                else
-                                                {
-                                                        if(current_negative->totally_neutral)
-                                                        {
-                                                                for(set<polyhedron*>::iterator grand_ref = current_negative->grandparents.begin();grand_ref!=current_negative->grandparents.end();grand_ref++)
-                                                                {
-                                                                        (*grand_ref)->totallyneutralgrandchildren.erase(current_negative);                                                                      
-                                                                }
-                                                        }                                                       
-                                                }
-
-                                                current_positive->grandparents.clear();
-
                                                 
                                                 
-                                                current_positive->totally_neutral = (current_positive->totally_neutral && current_negative->totally_neutral);
-
+                                                if(current_positive->totally_neutral)
+                                                {
+                                                        for(set<polyhedron*>::iterator grand_ref = current_negative->grandparents.begin();grand_ref!=current_negative->grandparents.end();grand_ref++)
+                                                        {
+                                                                (*grand_ref)->totallyneutralgrandchildren.erase(current_negative);
+                                                                (*grand_ref)->totallyneutralgrandchildren.insert(current_positive);
+                                                        }                                                       
+                                                }                                       
+
+                                                current_positive->grandparents.clear();
+                                
                                                 normalization_factor += current_positive->triangulate(k==for_splitting.size()-1 && !will_be_split);
                                                 
@@ -1627 +1636 @@
                 
 
-                cout << endl;
-
-                if(this->statistic.row_size(2)==62)
-                {
-                        this->step_me(2);
-                }
+                cout << endl;           
 
                 if(should_add)
                 {
+                        cout << "Splitting." << endl;
+
                         int k = 1;
+                        int counter = 0;
 
                         vector<list<polyhedron*>>::iterator beginning_ref = ++for_splitting.begin();
@@ -1645 +1652 @@
                                 for(list<polyhedron*>::reverse_iterator split_ref = vert_ref->rbegin();split_ref != vert_ref->rend();split_ref++)
                                 {
+                                        counter++;
+                                        
                                         polyhedron* new_totally_neutral_child;
 
@@ -1775 +1784 @@
                                         normalization_factor += negative_poly->triangulate(k==for_splitting.size()-1);
                                         
-                                        statistic.append_polyhedron(k-1, new_totally_neutral_child);                                    
+                                        statistic.append_polyhedron(k-1, new_totally_neutral_child);    
+
+                                        
                                         
                                         statistic.insert_polyhedron(k, positive_poly, current_polyhedron);
@@ -1812 +1823 @@
                 */
 
-                // step_me(0);
+                step_me(101);
 
         }