Changeset 772 for trunk/include

Show
Ignore:
Timestamp:
11/21/08 08:12:27 (7 weeks ago)
Author:
artem
Message:

+ minor formatting

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • trunk/include/mapnik/label_collision_detector.hpp

    r771 r772  
    3939   struct label_collision_detector 
    4040   { 
    41          typedef std::vector<Envelope<double> > label_placements; 
    42  
    43          bool has_plasement(Envelope<double> const& box) 
    44          { 
    45             label_placements::const_iterator itr=labels_.begin(); 
    46             for( ; itr !=labels_.end();++itr) 
    47             { 
    48                if (itr->intersects(box)) 
    49                { 
    50                   return false; 
    51                } 
    52             } 
    53             labels_.push_back(box); 
    54             return true; 
    55          } 
    56          void clear() 
    57          { 
    58             labels_.clear(); 
    59          } 
    60            
    61       private: 
    62  
    63          label_placements labels_; 
     41      typedef std::vector<Envelope<double> > label_placements; 
     42 
     43      bool has_plasement(Envelope<double> const& box) 
     44      { 
     45         label_placements::const_iterator itr=labels_.begin(); 
     46         for( ; itr !=labels_.end();++itr) 
     47         { 
     48            if (itr->intersects(box)) 
     49            { 
     50               return false; 
     51            } 
     52         } 
     53         labels_.push_back(box); 
     54         return true; 
     55      } 
     56      void clear() 
     57      { 
     58         labels_.clear(); 
     59      } 
     60           
     61   private: 
     62 
     63      label_placements labels_; 
    6464   }; 
    6565 
    … …  
    6767   class label_collision_detector2 : boost::noncopyable 
    6868   { 
    69          typedef quad_tree<Envelope<double> > tree_t; 
    70          tree_t tree_; 
    71       public: 
    72           
    73          explicit label_collision_detector2(Envelope<double> const& extent) 
    74             : tree_(extent) {} 
    75          
    76          bool has_placement(Envelope<double> const& box) 
    77          { 
    78             tree_t::query_iterator itr = tree_.query_in_box(box); 
    79             tree_t::query_iterator end = tree_.query_end(); 
     69      typedef quad_tree<Envelope<double> > tree_t; 
     70      tree_t tree_; 
     71   public: 
     72          
     73      explicit label_collision_detector2(Envelope<double> const& extent) 
     74         : tree_(extent) {} 
     75         
     76      bool has_placement(Envelope<double> const& box) 
     77      { 
     78         tree_t::query_iterator itr = tree_.query_in_box(box); 
     79         tree_t::query_iterator end = tree_.query_end(); 
    8080             
    81             for ( ;itr != end; ++itr) 
    82             { 
    83                if (itr->intersects(box)) 
    84                { 
    85                   return false; 
    86                } 
    87             } 
     81         for ( ;itr != end; ++itr) 
     82         { 
     83            if (itr->intersects(box)) 
     84            { 
     85               return false; 
     86            } 
     87         } 
    8888             
    89             tree_.insert(box,box); 
    90             return true; 
    91          } 
    92           
    93          void clear() 
    94          { 
    95             tree_.clear(); 
    96          }  
     89         tree_.insert(box,box); 
     90         return true; 
     91      } 
     92          
     93      void clear() 
     94      { 
     95         tree_.clear(); 
     96      }  
    9797          
    9898   }; 
    … …  
    101101   class label_collision_detector3 : boost::noncopyable 
    102102   { 
    103          typedef quad_tree< Envelope<double> > tree_t; 
    104          tree_t tree_; 
    105       public: 
    106          
    107          explicit label_collision_detector3(Envelope<double> const& extent) 
    108             : tree_(extent) {} 
    109          
    110          bool has_placement(Envelope<double> const& box) 
    111          { 
    112             tree_t::query_iterator itr = tree_.query_in_box(box); 
    113             tree_t::query_iterator end = tree_.query_end(); 
    114            
    115             for ( ;itr != end; ++itr) 
    116             { 
    117                if (itr->intersects(box)) 
    118                { 
    119                   return false; 
    120                } 
    121             } 
    122            
    123             return true; 
    124          } 
    125  
    126          void insert(Envelope<double> const& box) 
    127          { 
    128             tree_.insert(box, box); 
    129          } 
    130           
    131          void clear() 
    132          { 
    133             tree_.clear(); 
    134          } 
     103      typedef quad_tree< Envelope<double> > tree_t; 
     104      tree_t tree_; 
     105   public: 
     106         
     107      explicit label_collision_detector3(Envelope<double> const& extent) 
     108         : tree_(extent) {} 
     109         
     110      bool has_placement(Envelope<double> const& box) 
     111      { 
     112         tree_t::query_iterator itr = tree_.query_in_box(box); 
     113         tree_t::query_iterator end = tree_.query_end(); 
     114           
     115         for ( ;itr != end; ++itr) 
     116         { 
     117            if (itr->intersects(box)) 
     118            { 
     119               return false; 
     120            } 
     121         } 
     122           
     123         return true; 
     124      } 
     125 
     126      void insert(Envelope<double> const& box) 
     127      { 
     128         tree_.insert(box, box); 
     129      } 
     130          
     131      void clear() 
     132      { 
     133         tree_.clear(); 
     134      } 
    135135   }; 
    136136 
    … …  
    139139   class label_collision_detector4 : boost::noncopyable 
    140140   { 
    141          struct label 
    142          { 
    143                label(Envelope<double> const& b) : box(b) {} 
    144                label(Envelope<double> const& b, UnicodeString const& t) : box(b), text(t) {} 
     141      struct label 
     142      { 
     143         label(Envelope<double> const& b) : box(b) {} 
     144         label(Envelope<double> const& b, UnicodeString const& t) : box(b), text(t) {} 
    145145                
    146                Envelope<double> box; 
    147                UnicodeString text; 
    148          }; 
    149           
    150          typedef quad_tree< label > tree_t; 
    151          Envelope<double> extent_; 
    152          tree_t tree_; 
    153           
    154     public: 
    155          
    156         explicit label_collision_detector4(Envelope<double> const& extent) 
    157            : extent_(extent), 
    158              tree_(extent) {} 
    159          
    160         bool has_placement(Envelope<double> const& box) 
    161         { 
    162             tree_t::query_iterator itr = tree_.query_in_box(box); 
    163             tree_t::query_iterator end = tree_.query_end(); 
    164            
    165             for ( ;itr != end; ++itr) 
    166             { 
    167                if (itr->box.intersects(box)) 
    168                { 
    169                   return false; 
    170                } 
    171             } 
    172            
    173             return true; 
    174         }        
    175  
    176         bool has_placement(Envelope<double> const& box, UnicodeString const& text, double distance) 
    177         { 
    178             Envelope<double> bigger_box(box.minx() - distance, box.miny() - distance, box.maxx() + distance, box.maxy() + distance); 
    179             tree_t::query_iterator itr = tree_.query_in_box(bigger_box); 
    180             tree_t::query_iterator end = tree_.query_end(); 
     146         Envelope<double> box; 
     147         UnicodeString text; 
     148      }; 
     149          
     150      typedef quad_tree< label > tree_t; 
     151      Envelope<double> extent_; 
     152      tree_t tree_; 
     153          
     154   public: 
     155         
     156      explicit label_collision_detector4(Envelope<double> const& extent) 
     157         : extent_(extent), 
     158           tree_(extent) {} 
     159         
     160      bool has_placement(Envelope<double> const& box) 
     161      { 
     162         tree_t::query_iterator itr = tree_.query_in_box(box); 
     163         tree_t::query_iterator end = tree_.query_end(); 
     164           
     165         for ( ;itr != end; ++itr) 
     166         { 
     167            if (itr->box.intersects(box)) 
     168            { 
     169               return false; 
     170            } 
     171         } 
     172           
     173         return true; 
     174      }  
     175 
     176      bool has_placement(Envelope<double> const& box, UnicodeString const& text, double distance) 
     177      { 
     178         Envelope<double> bigger_box(box.minx() - distance, box.miny() - distance, box.maxx() + distance, box.maxy() + distance); 
     179         tree_t::query_iterator itr = tree_.query_in_box(bigger_box); 
     180         tree_t::query_iterator end = tree_.query_end(); 
    181181         
    182             for ( ;itr != end; ++itr) 
    183             { 
    184                if (itr->box.intersects(box) || (text == itr->text && itr->box.intersects(bigger_box))) 
    185                 { 
    186                     return false; 
    187                 } 
    188             } 
     182         for ( ;itr != end; ++itr) 
     183         { 
     184            if (itr->box.intersects(box) || (text == itr->text && itr->box.intersects(bigger_box))) 
     185            { 
     186               return false; 
     187            } 
     188         } 
    189189             
    190             return true; 
    191         }        
     190         return true; 
     191      }  
    192192 
    193193      bool has_point_placement(Envelope<double> const& box, UnicodeString const& text, double distance) 
    … …  
    210210      void insert(Envelope<double> const& box) 
    211211      { 
    212             tree_.insert(label(box), box); 
    213          } 
    214           
    215          void insert(Envelope<double> const& box, UnicodeString const& text) 
    216          { 
    217             tree_.insert(label(box, text), box); 
    218          } 
    219           
    220          void clear() 
    221          { 
    222             tree_.clear(); 
    223          } 
    224          Envelope<double> const& extent() const 
    225          { 
    226             return extent_; 
    227          } 
    228     }; 
     212         tree_.insert(label(box), box); 
     213      } 
     214          
     215      void insert(Envelope<double> const& box, UnicodeString const& text) 
     216      { 
     217         tree_.insert(label(box, text), box); 
     218      } 
     219          
     220      void clear() 
     221      { 
     222         tree_.clear(); 
     223      } 
     224       
     225      Envelope<double> const& extent() const 
     226      { 
     227         return extent_; 
     228      } 
     229   }; 
    229230} 
    230231