MapPainter.h

Go to the documentation of this file.

#ifndef OSMSCOUT_MAP_MAPPAINTER_H
#define OSMSCOUT_MAP_MAPPAINTER_H

/*
  This source is part of the libosmscout-map library
  Copyright (C) 2009  Tim Teulings

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*/

#include <list>
#include <string>

#include <osmscout/MapImportExport.h>

#include <osmscout/ObjectRef.h>

#include <osmscout/TypeFeatures.h>

#include <osmscout/Node.h>
#include <osmscout/Area.h>
#include <osmscout/Way.h>

#include <osmscout/StyleConfig.h>

#include <osmscout/GroundTile.h>

#include <osmscout/MapData.h>

#include <osmscout/util/Breaker.h>
#include <osmscout/util/Geometry.h>
#include <osmscout/util/Projection.h>
#include <osmscout/util/Transformation.h>

#include <osmscout/system/Compiler.h>

#include <osmscout/LabelLayouter.h>
#include <osmscout/MapParameter.h>

namespace osmscout {

  enum RenderSteps : size_t
  {
    FirstStep             =  0,
    Initialize            =  0, 
    DumpStatistics        =  1, 
    PreprocessData        =  2, 
    Prerender             =  3, 
    DrawBaseMapTiles      =  4, 
    DrawGroundTiles       =  5, 
    DrawOSMTileGrids      =  6, 
    DrawAreas             =  7,
    DrawWays              =  8,
    DrawWayDecorations    =  9,
    DrawWayContourLabels  = 10,
    PrepareAreaLabels     = 11,
    DrawAreaBorderLabels  = 12,
    DrawAreaBorderSymbols = 13,
    PrepareNodeLabels     = 14,
    PrepareRouteLabels    = 15,
    DrawContourLines      = 16,
    DrawHillShading       = 17,
    DrawLabels            = 18,
    Postrender            = 19, 
    LastStep              = 19
  };

  class OSMSCOUT_MAP_API MapPainter
  {
  private:
    using StepMethod = void (MapPainter::*)(const Projection &, const MapParameter &, const MapData &);

  public:

    struct OSMSCOUT_MAP_API DataStatistic
    {
      TypeInfoRef type;        
      size_t      objectCount=0; 
      size_t      nodeCount=0;   
      size_t      wayCount=0;    
      size_t      areaCount=0;   
      size_t      coordCount=0;  
      size_t      labelCount=0;  
      size_t      iconCount=0;   

      DataStatistic() = default;
    };

    struct OSMSCOUT_MAP_API WayData
    {
      const FeatureValueBuffer *buffer;         
      int8_t                   layer;           
      LineStyleRef             lineStyle;       
      Color                    color;           
      size_t                   wayPriority;     
      CoordBufferRange         coordRange;      
      double                   lineWidth;       
      bool                     startIsClosed;   
      bool                     endIsClosed;     

      bool operator<(const WayData& other) const
      {
        if (layer!=other.layer)
        {
          return layer<other.layer;
        }

        if (lineStyle->GetZIndex()!=other.lineStyle->GetZIndex()) {
          return lineStyle->GetZIndex()<other.lineStyle->GetZIndex();
        }

        if (lineStyle->GetPriority()!=other.lineStyle->GetPriority()) {
          return lineStyle->GetPriority()<other.lineStyle->GetPriority();
        }

        return wayPriority>other.wayPriority;
      }
    };

    struct OSMSCOUT_MAP_API WayPathData
    {
      FileOffset               ref;
      const FeatureValueBuffer *buffer;         
      CoordBufferRange         coordRange;      
      double                   mainSlotWidth;   
    };

    struct OSMSCOUT_MAP_API PolyData
    {
      size_t                   transStart;      
      size_t                   transEnd;        
    };

    struct OSMSCOUT_MAP_API AreaData
    {
      ObjectFileRef            ref;
      TypeInfoRef              type;
      const FeatureValueBuffer *buffer;         
      FillStyleRef             fillStyle;       
      BorderStyleRef           borderStyle;     
      GeoBox                   boundingBox;     
      bool                     isOuter;         
      CoordBufferRange         coordRange;      
      std::list<PolyData>      clippings;       
    };

    using WayPathDataIt=std::list<WayPathData>::iterator;

    struct OSMSCOUT_MAP_API RouteLabelData
    {
      WayPathDataIt wayData;
      std::map<PathTextStyleRef,std::set<std::string>> labels;
    };

  protected:
    TransBuffer                  transBuffer;       
    CoordBuffer                  coordBuffer;       


    TextStyleRef                 debugLabel;

    FillStyleRef                 landFill;
    FillStyleRef                 seaFill;
    FeatureValueBuffer           coastlineSegmentAttributes;

  private:
    std::vector<StepMethod>      stepMethods;        
    double                       errorTolerancePixel;

    std::list<AreaData>          areaData;           
    std::list<WayData>           wayData;            
    std::list<WayPathData>       wayPathData;
    // std::list<RouteData>         routeData;
    std::list<RouteLabelData>    routeLabelData;

    std::vector<TextStyleRef>    textStyles;         
    std::vector<LineStyleRef>    lineStyles;         

    double                       standardFontSize;
    double                       areaMinDimension;

  protected:
    StyleConfigRef               styleConfig;        

    NameFeatureValueReader       nameReader;         
    NameAltFeatureValueReader    nameAltReader;      
    RefFeatureValueReader        refReader;          
    LayerFeatureValueReader      layerReader;        
    WidthFeatureValueReader      widthReader;        
    AddressFeatureValueReader    addressReader;      
    LanesFeatureValueReader      lanesReader;        
    AccessFeatureValueReader     accessReader;       
    ColorFeatureValueReader      colorReader;        


    std::vector<double>          emptyDash;          
    std::vector<double>          tunnelDash;         
    FillStyle                    areaMarkStyle;      
    double                       contourLabelOffset; 
    double                       contourLabelSpace;  
    double                       shieldGridSizeHoriz;
    double                       shieldGridSizeVert; 


  private:
    void DumpDataStatistics(const Projection& projection,
                            const MapParameter& parameter,
                            const MapData& data);

    void PrepareNode(const StyleConfig& styleConfig,
                     const Projection& projection,
                     const MapParameter& parameter,
                     const NodeRef& node);

    void PrepareNodes(const StyleConfig& styleConfig,
                      const Projection& projection,
                      const MapParameter& parameter,
                      const MapData& data);

    void TransformPathData(const Projection& projection,
                           const MapParameter& parameter,
                           const Way& way,
                           WayPathData &pathData);

    void CalculatePaths(const StyleConfig& styleConfig,
                        const Projection& projection,
                        const MapParameter& parameter,
                        const Way& way);

    void PrepareWays(const StyleConfig& styleConfig,
                     const Projection& projection,
                     const MapParameter& parameter,
                     const MapData& data);

    void PrepareRoutes(const StyleConfig& styleConfig,
                       const Projection& projection,
                       const MapParameter& parameter,
                       const MapData& data);

    void PrepareArea(const StyleConfig& styleConfig,
                     const Projection& projection,
                     const MapParameter& parameter,
                     const AreaRef &area);

    void PrepareAreaLabel(const StyleConfig& styleConfig,
                          const Projection& projection,
                          const MapParameter& parameter,
                          const AreaData& areaData);

    void PrepareAreas(const StyleConfig& styleConfig,
                      const Projection& projection,
                      const MapParameter& parameter,
                      const MapData& data);

    void RegisterPointWayLabel(const Projection& projection,
                               const MapParameter& parameter,
                               const PathShieldStyleRef& style,
                               const std::string& text,
                               const std::vector<Point>& nodes);

    void LayoutPointLabels(const Projection& projection,
                           const MapParameter& parameter,
                           const FeatureValueBuffer& buffer,
                           const IconStyleRef& iconStyle,
                           const std::vector<TextStyleRef>& textStyles,
                           double x, double y,
                           double objectWidth=0,
                           double objectHeight=0);

    bool DrawWayDecoration(const StyleConfig& styleConfig,
                           const Projection& projection,
                           const MapParameter& parameter,
                           const WayPathData& data);

    bool CalculateWayShieldLabels(const StyleConfig& styleConfig,
                                  const Projection& projection,
                                  const MapParameter& parameter,
                                  const Way& data);

    bool DrawWayContourLabel(const StyleConfig& styleConfig,
                             const Projection& projection,
                             const MapParameter& parameter,
                             const WayPathData& data);

    bool DrawWayContourLabel(const Projection& projection,
                             const MapParameter& parameter,
                             const WayPathData& data,
                             const PathTextStyleRef &pathTextStyle,
                             const std::string &textLabel);

    bool DrawAreaBorderLabel(const StyleConfig& styleConfig,
                             const Projection& projection,
                             const MapParameter& parameter,
                             const AreaData& areaData);

    bool DrawAreaBorderSymbol(const StyleConfig& styleConfig,
                              const Projection& projection,
                              const MapParameter& parameter,
                              const AreaData& areaData);

    void DrawOSMTileGrid(const Projection& projection,
                         const MapParameter& parameter,
                         const Magnification& magnification,
                         const LineStyleRef& osmTileLine);

    void DrawGroundTiles(const Projection& projection,
                         const MapParameter& parameter,
                         const std::list<GroundTile> &groundTiles);


    void InitializeRender(const Projection& projection,
                          const MapParameter& parameter,
                          const MapData& data);

    void DumpStatistics(const Projection& projection,
                        const MapParameter& parameter,
                        const MapData& data);

    void PreprocessData(const Projection& projection,
                        const MapParameter& parameter,
                        const MapData& data);

    void Prerender(const Projection& projection,
                   const MapParameter& parameter,
                   const MapData& data);

    void DrawBaseMapTiles(const Projection& projection,
                          const MapParameter& parameter,
                          const MapData& data);

    void DrawGroundTiles(const Projection& projection,
                         const MapParameter& parameter,
                         const MapData& data);

    void DrawOSMTileGrids(const Projection& projection,
                          const MapParameter& parameter,
                          const MapData& data);

    void DrawAreas(const Projection& projection,
                   const MapParameter& parameter,
                   const MapData& data);

    void DrawWays(const Projection& projection,
                  const MapParameter& parameter,
                  const MapData& data);

    void DrawWayDecorations(const Projection& projection,
                            const MapParameter& parameter,
                            const MapData& data);

    void DrawWayContourLabels(const Projection& projection,
                              const MapParameter& parameter,
                              const MapData& data);

    void PrepareAreaLabels(const Projection& projection,
                           const MapParameter& parameter,
                           const MapData& data);

    void DrawAreaBorderLabels(const Projection& projection,
                              const MapParameter& parameter,
                              const MapData& data);

    void DrawAreaBorderSymbols(const Projection& projection,
                               const MapParameter& parameter,
                               const MapData& data);

    void PrepareNodeLabels(const Projection& projection,
                           const MapParameter& parameter,
                           const MapData& data);

    void PrepareRouteLabels(const Projection& projection,
                            const MapParameter& parameter,
                            const MapData& data);

    void Postrender(const Projection& projection,
                    const MapParameter& parameter,
                    const MapData& data);
    //@]

  protected:
    bool IsVisibleArea(const Projection& projection,
                       const GeoBox& boundingBox,
                       double pixelOffset) const;

    bool IsVisibleWay(const Projection& projection,
                      const GeoBox& boundingBox,
                      double pixelOffset) const;

    void Transform(const Projection& projection,
                   const MapParameter& parameter,
                   const GeoCoord& coord,
                   double& x,
                   double& y);

    double GetProjectedWidth(const Projection& projection,
                             double minPixel,
                             double width) const;

    double GetProjectedWidth(const Projection& projection,
                             double width) const
    {
      return width/projection.GetPixelSize();
    }

    const std::list<WayData>& GetWayData() const
    {
      return wayData;
    }

    const std::list<AreaData>& GetAreaData() const
    {
      return areaData;
    }


    virtual void AfterPreprocessing(const StyleConfig& styleConfig,
                                    const Projection& projection,
                                    const MapParameter& parameter,
                                    const MapData& data);
    virtual void BeforeDrawing(const StyleConfig& styleConfig,
                               const Projection& projection,
                               const MapParameter& parameter,
                               const MapData& data);
    virtual void AfterDrawing(const StyleConfig& styleConfig,
                              const Projection& projection,
                              const MapParameter& parameter,
                              const MapData& data);

    virtual bool HasIcon(const StyleConfig& styleConfig,
                         const Projection& projection,
                         const MapParameter& parameter,
                         IconStyle& style)= 0;

    virtual double GetFontHeight(const Projection& projection,
                                 const MapParameter& parameter,
                                 double fontSize) = 0;

    virtual void DrawGround(const Projection& projection,
                            const MapParameter& parameter,
                            const FillStyle& style) = 0;

    virtual void RegisterRegularLabel(const Projection &projection,
                                      const MapParameter &parameter,
                                      const std::vector<LabelData> &labels,
                                      const Vertex2D &position,
                                      double objectWidth) = 0;

    virtual void RegisterContourLabel(const Projection &projection,
                                      const MapParameter &parameter,
                                      const PathLabelData &label,
                                      const LabelPath &labelPath) = 0;

    virtual void DrawLabels(const Projection& projection,
                            const MapParameter& parameter,
                            const MapData& data) = 0;

    virtual void DrawContourLines(const Projection& projection,
                                  const MapParameter& parameter,
                                  const MapData& data);

    virtual void DrawHillShading(const Projection& projection,
                                 const MapParameter& parameter,
                                 const MapData& data);

    virtual void DrawIcon(const IconStyle* style,
                          double centerX, double centerY,
                          double width, double height) = 0;

    virtual void DrawSymbol(const Projection& projection,
                            const MapParameter& parameter,
                            const Symbol& symbol,
                            double x, double y) = 0;

    virtual void DrawPath(const Projection& projection,
                          const MapParameter& parameter,
                          const Color& color,
                          double width,
                          const std::vector<double>& dash,
                          LineStyle::CapStyle startCap,
                          LineStyle::CapStyle endCap,
                          size_t transStart, size_t transEnd) = 0;

    virtual void DrawContourSymbol(const Projection& projection,
                                   const MapParameter& parameter,
                                   const Symbol& symbol,
                                   double space,
                                   size_t transStart, size_t transEnd) = 0;

    virtual void DrawArea(const Projection& projection,
                          const MapParameter& parameter,
                          const AreaData& area) = 0;

    virtual double GetProposedLabelWidth(const MapParameter& parameter,
                                         double averageCharWidth,
                                         double objectWidth,
                                         size_t stringLength);

    virtual void DrawWay(const StyleConfig& styleConfig,
                         const Projection& projection,
                         const MapParameter& parameter,
                         const WayData& data);


    std::vector<OffsetRel> ParseLaneTurns(const LanesFeatureValue&);

  public:
    MapPainter(const StyleConfigRef& styleConfig);
    virtual ~MapPainter();

    bool Draw(const Projection& projection,
              const MapParameter& parameter,
              const MapData& data,
              RenderSteps startStep,
              RenderSteps endStep);

    bool Draw(const Projection& projection,
              const MapParameter& parameter,
              const MapData& data);
  };

  template <class PainterType>
  class MapPainterBatch {
  protected:
    std::vector<MapDataRef> data;
    std::vector<PainterType> painters;

  protected:

    bool batchPaintInternal(const Projection& projection,
                            const MapParameter& parameter)
    {
      bool success=true;
      for (size_t step=osmscout::RenderSteps::FirstStep;
           step<=osmscout::RenderSteps::LastStep;
           step++){

        for (size_t i=0;i<data.size(); i++){
          const MapData &d=*(data[i]);
          success &= painters[i]->Draw(projection,
                                       parameter,
                                       d,
                                       (RenderSteps)step,
                                       (RenderSteps)step);
        }
      }
      return success;
    }

  public:
    explicit MapPainterBatch(size_t expectedCount)
    {
      data.reserve(expectedCount);
      painters.reserve(expectedCount);
    }

    virtual ~MapPainterBatch() = default;

    void addData(const MapDataRef &d, PainterType &painter)
    {
      data.push_back(d);
      painters.push_back(painter);
    }
  };

}

#endif