layer.h

Go to the documentation of this file.

/*
 *   libpal - Automated Placement of Labels Library
 *
 *   Copyright (C) 2008 Maxence Laurent, MIS-TIC, HEIG-VD
 *                      University of Applied Sciences, Western Switzerland
 *                      http://www.hes-so.ch
 *
 *   Contact:
 *      maxence.laurent <at> heig-vd <dot> ch
 *    or
 *      eric.taillard <at> heig-vd <dot> ch
 *
 * This file is part of libpal.
 *
 * libpal is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * libpal 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with libpal.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifndef _LAYER_H_
#define _LAYER_H_

#include <fstream>

#include <pal/pal.h>
#include <pal/palgeometry.h>


namespace pal
{

  template <class Type> class LinkedList;
  template <class Type> class Cell;
  template <typename Data> class HashTable;

  template<class DATATYPE, class ELEMTYPE, int NUMDIMS, class ELEMTYPEREAL, int TMAXNODES, int TMINNODES> class RTree;

  class Feature;
  class FeaturePart;
  class Pal;
  class SimpleMutex;
  class LabelInfo;

  class CORE_EXPORT Layer
  {
      friend class Pal;
      friend class FeaturePart;

      friend class Problem;

      friend class LabelPosition;
      friend bool extractFeatCallback( FeaturePart *ft_ptr, void *ctx );
      friend void toSVGPath( int nbPoints, double *x, double *y, int dpi, Layer *layer, int type, char *uid, std::ostream &out, double scale, int xmin, int ymax, bool exportInfo, char *color );

    public:
      enum LabelMode { LabelPerFeature, LabelPerFeaturePart };
      enum UpsideDownLabels
      {
        Upright, // upside-down labels (90 <= angle < 270) are shown upright
        ShowDefined, // show upside down when rotation is layer- or data-defined
        ShowAll // show upside down for all labels, including dynamic ones
      };

      bool getDisplayAll() const { return displayAll; }

    protected:
      char *name; /* unique */

      LinkedList<FeaturePart*> *featureParts;

      LinkedList<Feature*> *features;

      Pal *pal;

      double defaultPriority;

      bool obstacle;
      bool active;
      bool toLabel;
      bool displayAll;
      bool centroidInside;

      Units label_unit;

      double min_scale;
      double max_scale;

      Arrangement arrangement;
      unsigned long arrangementFlags;
      LabelMode mode;
      bool mergeLines;

      UpsideDownLabels upsidedownLabels;

      // indexes (spatial and id)
      RTree<FeaturePart*, double, 2, double, 8, 4> *rtree;
      HashTable<Feature*> *hashtable;

      HashTable< LinkedList<FeaturePart*>* > * connectedHashtable;
      LinkedList< char* >* connectedTexts;

      SimpleMutex *modMutex;

      Layer( const char *lyrName, double min_scale, double max_scale, Arrangement arrangement, Units label_unit, double defaultPriority, bool obstacle, bool active, bool toLabel, Pal *pal, bool displayAll = false );

      virtual ~Layer();

      bool isScaleValid( double scale );

      void addFeaturePart( FeaturePart* fpart, const char* labelText = NULL );

    public:
      int getNbFeatures();

      const char * getName();


      Arrangement getArrangement();

      void setArrangement( Arrangement arrangement );

      unsigned long getArrangementFlags() const { return arrangementFlags; }
      void setArrangementFlags( unsigned long flags ) { arrangementFlags = flags; }

      Units getLabelUnit();

      void setLabelUnit( Units label_unit );

      void setActive( bool active );

      bool isActive();


      void setToLabel( bool toLabel );


      bool isToLabel();


      void setObstacle( bool obstacle );

      bool isObstacle();

      void setMinScale( double min_scale );

      double getMinScale();


      void setMaxScale( double max_scale );


      double getMaxScale();


      void setPriority( double priority );


      double getPriority();

      void setLabelMode( LabelMode m ) { mode = m; }
      LabelMode getLabelMode() const { return mode; }

      void setMergeConnectedLines( bool m ) { mergeLines = m; }
      bool getMergeConnectedLines() const { return mergeLines; }

      // void setRepeatDistance( double distance ) { repeatDistance = distance; }
      // double getRepeatDistance() const { return repeatDistance; }

      void setUpsidedownLabels( UpsideDownLabels ud ) { upsidedownLabels = ud; }
      UpsideDownLabels getUpsidedownLabels() const { return upsidedownLabels; }

      void setCentroidInside( bool forceInside ) { centroidInside = forceInside; }
      bool getCentroidInside() const { return centroidInside; }

      bool registerFeature( const char *geom_id, PalGeometry *userGeom, double label_x = -1, double label_y = -1,
                            const char* labelText = NULL, double labelPosX = 0.0, double labelPosY = 0.0,
                            bool fixedPos = false, double angle = 0.0, bool fixedAngle = false,
                            int xQuadOffset = 0, int yQuadOffset = 0, double xOffset = 0.0, double yOffset = 0.0,
                            bool alwaysShow = false, double repeatDistance = 0 );

      Feature* getFeature( const char* geom_id );

      void joinConnectedFeatures();

      void chopFeaturesAtRepeatDistance();

  };

} // end namespace pal

#endif