Changeset 692 for trunk

Show
Ignore:
Timestamp:
04/11/08 19:11:35 (9 months ago)
Author:
tom
Message:

Don't try and render text if the attribute containing the text does
not exist for the feature. Closes #89.

Location:
trunk
Files:
3 modified

Legend:

Unmodified
Added
Removed

  • trunk/include/mapnik/feature.hpp

    r547 r692  
    121121         } 
    122122           
     123         bool exists(const std::string &k) const 
     124         { 
     125            return props_.find(k) != props_.end(); 
     126         } 
     127 
    123128         std::string to_string() const 
    124129         { 

  • trunk/src/agg_renderer.cpp

    r658 r692  
    457457   { 
    458458      typedef  coord_transform2<CoordTransform,geometry2d> path_type; 
    459       UnicodeString text = feature[sym.get_name()].to_unicode(); 
    460       boost::shared_ptr<ImageData32> const& data = sym.get_image(); 
    461       if (text.length() > 0 && data) 
    462       { 
    463          face_ptr face = font_manager_.get_face(sym.get_face_name()); 
    464          if (face) 
    465          { 
    466             text_renderer<mapnik::Image32> ren(pixmap_,face); 
    467             ren.set_pixel_size(sym.get_text_size()); 
    468             ren.set_fill(sym.get_fill()); 
    469              
    470             string_info info(text); 
    471             face->get_string_info(info); 
    472              
    473             placement_finder<label_collision_detector4> finder(detector_); 
    474              
    475             unsigned num_geom = feature.num_geometries(); 
    476             for (unsigned i=0;i<num_geom;++i) 
     459      if (feature.exists(sym.get_name())) 
     460      { 
     461         UnicodeString text = feature[sym.get_name()].to_unicode(); 
     462         boost::shared_ptr<ImageData32> const& data = sym.get_image(); 
     463         if (text.length() > 0 && data) 
     464         { 
     465            face_ptr face = font_manager_.get_face(sym.get_face_name()); 
     466            if (face) 
    477467            { 
    478                geometry2d const& geom = feature.get_geometry(i); 
    479                if (geom.num_points() > 0) // don't bother with empty geometries  
    480                {     
    481                   path_type path(t_,geom,prj_trans); 
    482                   placement text_placement(info, sym); 
    483                   text_placement.avoid_edges = sym.get_avoid_edges(); 
    484                   finder.find_point_placements<path_type>(text_placement,path); 
     468               text_renderer<mapnik::Image32> ren(pixmap_,face); 
     469               ren.set_pixel_size(sym.get_text_size()); 
     470               ren.set_fill(sym.get_fill()); 
     471             
     472               string_info info(text); 
     473               face->get_string_info(info); 
     474             
     475               placement_finder<label_collision_detector4> finder(detector_); 
     476             
     477               unsigned num_geom = feature.num_geometries(); 
     478               for (unsigned i=0;i<num_geom;++i) 
     479               { 
     480                  geometry2d const& geom = feature.get_geometry(i); 
     481                  if (geom.num_points() > 0) // don't bother with empty geometries 
     482                  { 
     483                     path_type path(t_,geom,prj_trans); 
     484                     placement text_placement(info, sym); 
     485                     text_placement.avoid_edges = sym.get_avoid_edges(); 
     486                     finder.find_point_placements<path_type>(text_placement,path); 
    485487                   
    486                   for (unsigned int ii = 0; ii < text_placement.placements.size(); ++ ii) 
    487                   {  
    488                      int w = data->width(); 
    489                      int h = data->height(); 
     488                     for (unsigned int ii = 0; ii < text_placement.placements.size(); ++ ii) 
     489                     { 
     490                        int w = data->width(); 
     491                        int h = data->height(); 
    490492                      
    491                      double x = text_placement.placements[ii].starting_x; 
    492                      double y = text_placement.placements[ii].starting_y; 
     493                        double x = text_placement.placements[ii].starting_x; 
     494                        double y = text_placement.placements[ii].starting_y; 
    493495                      
    494                      int px=int(x - (w/2)); 
    495                      int py=int(y - (h/2)); 
     496                        int px=int(x - (w/2)); 
     497                        int py=int(y - (h/2)); 
    496498                      
    497                      pixmap_.set_rectangle_alpha(px,py,*data); 
     499                        pixmap_.set_rectangle_alpha(px,py,*data); 
    498500                      
    499                      Envelope<double> dim = ren.prepare_glyphs(&text_placement.placements[ii]); 
     501                        Envelope<double> dim = ren.prepare_glyphs(&text_placement.placements[ii]); 
    500502                         
    501                      ren.render(x,y); 
     503                        ren.render(x,y); 
     504                     } 
    502505                  } 
    503506               } 
    … …  
    666669   { 
    667670      typedef  coord_transform2<CoordTransform,geometry2d> path_type; 
    668        
    669       UnicodeString text = feature[sym.get_name()].to_unicode(); 
    670       if ( text.length() > 0 ) 
    671       { 
    672          Color const& fill  = sym.get_fill(); 
    673          face_ptr face = font_manager_.get_face(sym.get_face_name()); 
    674          if (face) 
    675          { 
    676             text_renderer<mapnik::Image32> ren(pixmap_,face); 
    677             ren.set_pixel_size(sym.get_text_size()); 
    678             ren.set_fill(fill); 
    679             ren.set_halo_fill(sym.get_halo_fill()); 
    680             ren.set_halo_radius(sym.get_halo_radius()); 
     671 
     672      if (feature.exists(sym.get_name())) 
     673      { 
     674         UnicodeString text = feature[sym.get_name()].to_unicode(); 
     675         if ( text.length() > 0 ) 
     676         { 
     677            Color const& fill  = sym.get_fill(); 
     678            face_ptr face = font_manager_.get_face(sym.get_face_name()); 
     679            if (face) 
     680            { 
     681               text_renderer<mapnik::Image32> ren(pixmap_,face); 
     682               ren.set_pixel_size(sym.get_text_size()); 
     683               ren.set_fill(fill); 
     684               ren.set_halo_fill(sym.get_halo_fill()); 
     685               ren.set_halo_radius(sym.get_halo_radius()); 
    681686            
    682             placement_finder<label_collision_detector4> finder(detector_); 
     687               placement_finder<label_collision_detector4> finder(detector_); 
    683688            
    684             string_info info(text); 
    685             face->get_string_info(info); 
    686             unsigned num_geom = feature.num_geometries(); 
    687             for (unsigned i=0;i<num_geom;++i) 
    688             { 
    689                geometry2d const& geom = feature.get_geometry(i); 
    690                if (geom.num_points() > 0) // don't bother with empty geometries  
     689               string_info info(text); 
     690               face->get_string_info(info); 
     691               unsigned num_geom = feature.num_geometries(); 
     692               for (unsigned i=0;i<num_geom;++i) 
    691693               { 
    692                   path_type path(t_,geom,prj_trans); 
    693                   placement text_placement(info,sym);   
    694                   if (sym.get_label_placement() == POINT_PLACEMENT)  
     694                  geometry2d const& geom = feature.get_geometry(i); 
     695                  if (geom.num_points() > 0) // don't bother with empty geometries 
    695696                  { 
    696                      double label_x, label_y, z=0.0; 
    697                      geom.label_position(&label_x, &label_y); 
    698                      prj_trans.backward(label_x,label_y, z); 
    699                      t_.forward(&label_x,&label_y); 
    700                      finder.find_point_placement(text_placement,label_x,label_y); 
    701                   } 
    702                   else //LINE_PLACEMENT 
    703                   { 
    704                      finder.find_line_placements<path_type>(text_placement,path); 
    705                   } 
     697                     path_type path(t_,geom,prj_trans); 
     698                     placement text_placement(info,sym); 
     699                     if (sym.get_label_placement() == POINT_PLACEMENT) 
     700                     { 
     701                        double label_x, label_y, z=0.0; 
     702                        geom.label_position(&label_x, &label_y); 
     703                        prj_trans.backward(label_x,label_y, z); 
     704                        t_.forward(&label_x,&label_y); 
     705                        finder.find_point_placement(text_placement,label_x,label_y); 
     706                     } 
     707                     else //LINE_PLACEMENT 
     708                     { 
     709                        finder.find_line_placements<path_type>(text_placement,path); 
     710                     } 
    706711                   
    707                   for (unsigned int ii = 0; ii < text_placement.placements.size(); ++ii) 
    708                   { 
    709                      double x = text_placement.placements[ii].starting_x; 
    710                      double y = text_placement.placements[ii].starting_y; 
    711                      Envelope<double> dim = ren.prepare_glyphs(&text_placement.placements[ii]); 
    712                      ren.render(x,y); 
     712                     for (unsigned int ii = 0; ii < text_placement.placements.size(); ++ii) 
     713                     { 
     714                        double x = text_placement.placements[ii].starting_x; 
     715                        double y = text_placement.placements[ii].starting_y; 
     716                        Envelope<double> dim = ren.prepare_glyphs(&text_placement.placements[ii]); 
     717                        ren.render(x,y); 
     718                     } 
    713719                  } 
    714720               } 
    715             }   
    716          } 
    717          else 
    718          { 
    719             throw config_error("Unable to find specified font face '" + sym.get_face_name() + "'"); 
     721            } 
     722            else 
     723            { 
     724               throw config_error("Unable to find specified font face '" + sym.get_face_name() + "'"); 
     725            } 
    720726         } 
    721727      } 

  • trunk/src/cairo_renderer.cpp

    r669 r692  
    751751      typedef coord_transform2<CoordTransform,geometry2d> path_type; 
    752752 
    753       UnicodeString text = feature[sym.get_name()].to_unicode(); 
    754       boost::shared_ptr<ImageData32> const& data = sym.get_image(); 
    755  
    756       if (text.length() > 0 && data) 
    757       { 
    758          cairo_face_ptr face = face_manager_.get_face(sym.get_face_name()); 
    759  
    760          if (face) 
    761          { 
    762             cairo_context context(context_); 
    763  
    764             context.set_font_face(face); 
    765  
    766             string_info info(text); 
    767  
    768             face->get_string_info(sym.get_text_size(), info); 
    769  
    770             placement_finder<label_collision_detector4> finder(detector_); 
    771  
    772             for (unsigned i = 0; i < feature.num_geometries(); ++i) 
    773             { 
    774                geometry2d const& geom = feature.get_geometry(i); 
    775  
    776                if (geom.num_points() > 0) // don't bother with empty geometries 
    777                { 
    778                   path_type path(t_, geom, prj_trans); 
    779                   placement text_placement(info, sym); 
    780  
    781                   text_placement.avoid_edges = sym.get_avoid_edges(); 
    782                   finder.find_point_placements<path_type>(text_placement, path); 
    783  
    784                   for (unsigned int ii = 0; ii < text_placement.placements.size(); ++ ii) 
     753      if (feature.exists(sym.get_name())) 
     754      { 
     755         UnicodeString text = feature[sym.get_name()].to_unicode(); 
     756         boost::shared_ptr<ImageData32> const& data = sym.get_image(); 
     757 
     758         if (text.length() > 0 && data) 
     759         { 
     760            cairo_face_ptr face = face_manager_.get_face(sym.get_face_name()); 
     761 
     762            if (face) 
     763            { 
     764               cairo_context context(context_); 
     765 
     766               context.set_font_face(face); 
     767 
     768               string_info info(text); 
     769 
     770               face->get_string_info(sym.get_text_size(), info); 
     771 
     772               placement_finder<label_collision_detector4> finder(detector_); 
     773 
     774               for (unsigned i = 0; i < feature.num_geometries(); ++i) 
     775               { 
     776                  geometry2d const& geom = feature.get_geometry(i); 
     777 
     778                  if (geom.num_points() > 0) // don't bother with empty geometries 
    785779                  { 
    786                      double shield_x = text_placement.placements[ii].starting_x - data->width() / 2; 
    787                      double shield_y = text_placement.placements[ii].starting_y - data->height() / 2; 
    788  
    789                      context.add_image(shield_x, shield_y, *data); 
    790                      context.add_text(sym, text_placement.placements[ii], face); 
     780                     path_type path(t_, geom, prj_trans); 
     781                     placement text_placement(info, sym); 
     782 
     783                     text_placement.avoid_edges = sym.get_avoid_edges(); 
     784                     finder.find_point_placements<path_type>(text_placement, path); 
     785 
     786                     for (unsigned int ii = 0; ii < text_placement.placements.size(); ++ ii) 
     787                     { 
     788                        double shield_x = text_placement.placements[ii].starting_x - data->width() / 2; 
     789                        double shield_y = text_placement.placements[ii].starting_y - data->height() / 2; 
     790 
     791                        context.add_image(shield_x, shield_y, *data); 
     792                        context.add_text(sym, text_placement.placements[ii], face); 
     793                     } 
    791794                  } 
    792795               } 
    … …  
    925928      typedef coord_transform2<CoordTransform,geometry2d> path_type; 
    926929 
    927       UnicodeString text = feature[sym.get_name()].to_unicode(); 
    928  
    929       if (text.length() > 0) 
    930       { 
    931          cairo_face_ptr face = face_manager_.get_face(sym.get_face_name()); 
    932  
    933          if (face) 
    934          { 
    935             cairo_context context(context_); 
    936  
    937             context.set_font_face(face); 
    938  
    939             string_info info(text); 
    940  
    941             face->get_string_info(sym.get_text_size(), info); 
    942  
    943             placement_finder<label_collision_detector4> finder(detector_); 
    944  
    945             for (unsigned i = 0; i < feature.num_geometries(); ++i) 
    946             { 
    947                geometry2d const& geom = feature.get_geometry(i); 
    948  
    949                if (geom.num_points() > 0) // don't bother with empty geometries 
    950                { 
    951                   path_type path(t_, geom, prj_trans); 
    952                   placement text_placement(info, sym); 
    953  
    954                   if (sym.get_label_placement() == POINT_PLACEMENT) 
     930      if (feature.exists(sym.get_name())) 
     931      { 
     932         UnicodeString text = feature[sym.get_name()].to_unicode(); 
     933 
     934         if (text.length() > 0) 
     935         { 
     936            cairo_face_ptr face = face_manager_.get_face(sym.get_face_name()); 
     937 
     938            if (face) 
     939            { 
     940               cairo_context context(context_); 
     941 
     942               context.set_font_face(face); 
     943 
     944               string_info info(text); 
     945 
     946               face->get_string_info(sym.get_text_size(), info); 
     947 
     948               placement_finder<label_collision_detector4> finder(detector_); 
     949 
     950               for (unsigned i = 0; i < feature.num_geometries(); ++i) 
     951               { 
     952                  geometry2d const& geom = feature.get_geometry(i); 
     953 
     954                  if (geom.num_points() > 0) // don't bother with empty geometries 
    955955                  { 
    956                      double label_x, label_y, z = 0.0; 
    957  
    958                      geom.label_position(&label_x, &label_y); 
    959                      prj_trans.backward(label_x, label_y, z); 
    960                      t_.forward(&label_x, &label_y); 
    961                      finder.find_point_placement(text_placement, label_x, label_y); 
     956                     path_type path(t_, geom, prj_trans); 
     957                     placement text_placement(info, sym); 
     958 
     959                     if (sym.get_label_placement() == POINT_PLACEMENT) 
     960                     { 
     961                        double label_x, label_y, z = 0.0; 
     962 
     963                        geom.label_position(&label_x, &label_y); 
     964                        prj_trans.backward(label_x, label_y, z); 
     965                        t_.forward(&label_x, &label_y); 
     966                        finder.find_point_placement(text_placement, label_x, label_y); 
     967                     } 
     968                     else //LINE_PLACEMENT 
     969                     { 
     970                        finder.find_line_placements<path_type>(text_placement, path); 
     971                     } 
     972 
     973                     for (unsigned int ii = 0; ii < text_placement.placements.size(); ++ii) 
     974                     { 
     975                        context.add_text(sym, text_placement.placements[ii], face); 
     976                     } 
    962977                  } 
    963                   else //LINE_PLACEMENT 
    964                   { 
    965                      finder.find_line_placements<path_type>(text_placement, path); 
    966                   } 
    967  
    968                   for (unsigned int ii = 0; ii < text_placement.placements.size(); ++ii) 
    969                   { 
    970                      context.add_text(sym, text_placement.placements[ii], face); 
    971                   } 
    972                } 
    973             } 
    974          } 
    975          else 
    976          { 
    977             throw config_error("Unable to find specified font face '" + sym.get_face_name() + "'"); 
     978               } 
     979            } 
     980            else 
     981            { 
     982               throw config_error("Unable to find specified font face '" + sym.get_face_name() + "'"); 
     983            } 
    978984         } 
    979985      }