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 <optional>
 
#include <osmscoutmap/MapImportExport.h>
 
#include <osmscout/ObjectRef.h>
 
#include <osmscout/feature/AddressFeature.h>
#include <osmscout/feature/ColorFeature.h>
#include <osmscout/feature/LanesFeature.h>
#include <osmscout/feature/LayerFeature.h>
#include <osmscout/feature/NameFeature.h>
#include <osmscout/feature/NameAltFeature.h>
#include <osmscout/feature/RefFeature.h>
#include <osmscout/feature/WidthFeature.h>
 
#include <osmscout/Node.h>
#include <osmscout/Area.h>
#include <osmscout/Way.h>
 
#include <osmscoutmap/StyleConfig.h>
 
#include <osmscout/GroundTile.h>
 
#include <osmscoutmap/MapData.h>
 
#include <osmscout/projection/Projection.h>
 
#include <osmscout/async/Breaker.h>
#include <osmscout/util/Geometry.h>
#include <osmscout/util/Transformation.h>
 
#include <osmscout/system/Compiler.h>
 
#include <osmscoutmap/LabelLayouter.h>
#include <osmscoutmap/MapParameter.h>
 
namespace osmscout {
 
  enum RenderSteps : size_t
  {
    FirstStep             =  0,
    Initialize            =  0, 
    DumpStatistics        =  1, 
    CalculatePaths        =  2, 
    CalculateWayShields   =  3, 
    ProcessAreas          =  4, 
    ProcessRoutes         =  5, 
    AfterPreprocessing    =  6, 
    Prerender             =  7, 
    DrawBaseMapTiles      =  8, 
    DrawGroundTiles       =  9, 
    DrawOSMTileGrids      = 10, 
    DrawAreas             = 11,
    DrawWays              = 12,
    DrawWayDecorations    = 13,
    DrawWayContourLabels  = 14,
    PrepareAreaLabels     = 15,
    DrawAreaBorderLabels  = 16,
    DrawAreaBorderSymbols = 17,
    PrepareNodeLabels     = 18,
    PrepareRouteLabels    = 19,
    DrawContourLines      = 20,
    DrawHillShading       = 21,
    DrawLabels            = 22,
    Postrender            = 23, 
    LastStep              = 23
  };

  class OSMSCOUT_MAP_API MapPainter
  {
  private:
    using StepMethod = void (MapPainter::*)(const Projection &, const MapParameter &, const MapData &);
 
  public:
    class OSMSCOUT_MAP_API WayData
    {
    public:
      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 AreaData
    {
      ObjectFileRef               ref;
      TypeInfoRef                 type;
      const FeatureValueBuffer    *buffer;         
      FillStyleRef                fillStyle;       
      BorderStyleRef              borderStyle;     
      GeoBox                      boundingBox;     
      std::optional<GeoCoord>     center;          
      bool                        isOuter;         
      CoordBufferRange            coordRange;      
      std::list<CoordBufferRange> clippings;       
    };
 
    using WayPathDataIt=std::list<WayPathData>::iterator;

    struct OSMSCOUT_MAP_API RouteLabelData
    {
      WayPathDataIt wayData;
      std::map<PathTextStyleRef,std::set<std::string>> labels;
    };
 
    struct OSMSCOUT_MAP_API ContourSymbolData
    {
      double            symbolOffset; 
      double            symbolSpace;  
      CoordBufferRange  coordRange;   
      double            symbolScale;  
    };
 
  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<RouteLabelData>    routeLabelData;
 
    std::vector<TextStyleRef>    textStyles;         
    std::vector<LineStyleRef>    lineStyles;         
    std::vector<PathSymbolStyleRef> symbolStyles;    

    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 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);
 
    double CalculateLineWith(const Projection& projection,
                             const FeatureValueBuffer& buffer,
                             const LineStyle& lineStyle) const;
 
    double CalculateLineOffset(const Projection& projection,
                               const LineStyle& lineStyle,
                               double lineWidth) const;
 
    Color CalculateLineColor(const FeatureValueBuffer& buffer,
                             const LineStyle& lineStyle) const;
 
    int8_t CalculateLineLayer(const FeatureValueBuffer& buffer) const;
 
    void CalculateWayPaths(const StyleConfig& styleConfig,
                           const Projection& projection,
                           const MapParameter& parameter,
                           const Way& way);
 
    bool PrepareAreaRing(const StyleConfig& styleConfig,
                         const Projection& projection,
                         const MapParameter& parameter,
                         const std::vector<CoordBufferRange>& coordRanges,
                         const Area& area,
                         const Area::Ring& ring,
                         size_t i,
                         const TypeInfoRef& type);
 
    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 RegisterPointWayLabel(const Projection& projection,
                               const MapParameter& parameter,
                               const PathShieldStyleRef& style,
                               const std::string_view& text,
                               const std::vector<Point>& nodes);
 
    void LayoutPointLabels(const Projection& projection,
                           const MapParameter& parameter,
                           const ObjectFileRef& ref,
                           const FeatureValueBuffer& buffer,
                           const IconStyleRef& iconStyle,
                           const std::vector<TextStyleRef>& textStyles,
                           const Vertex2D& screenPos,
                           const ScreenBox& objectBox);
 
    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& way);
 
    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_view &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 CalculatePaths(const Projection& projection,
                        const MapParameter& parameter,
                        const MapData& data);
 
    void CalculateWayShields(const Projection& projection,
                             const MapParameter& parameter,
                             const MapData& data);
 
    void ProcessAreas(const Projection& projection,
                      const MapParameter& parameter,
                      const MapData& data);
 
    void ProcessRoutes(const Projection& projection,
                       const MapParameter& parameter,
                       const MapData& data);
 
    void AfterPreprocessing(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;
 
    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 ObjectFileRef& ref,
                                      const std::vector<LabelData> &labels,
                                      const Vertex2D &position,
                                      double objectWidth) = 0;

    virtual void RegisterContourLabel(const Projection &projection,
                                      const MapParameter &parameter,
                                      const ObjectFileRef& ref,
                                      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,
                          const Vertex2D& centerPos,
                          double width, double height) = 0;

    virtual void DrawSymbol(const Projection& projection,
                            const MapParameter& parameter,
                            const Symbol& symbol,
                            const Vertex2D& screenPos,
                            double scaleFactor=1.0) = 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,
                          const CoordBufferRange& coordRange) = 0;

    virtual void DrawContourSymbol(const Projection& projection,
                                   const MapParameter& parameter,
                                   const Symbol& symbol,
                                   const ContourSymbolData& data) = 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& feature) const;
 
  public:
    explicit 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);
  };

}
 
#endif