zone.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2019 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program 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 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef ZONE_H
#define ZONE_H
 
 
#include <atomic>
#include <mutex>
#include <vector>
#include <map>
#include <board_item.h>
#include <board_connected_item.h>
#include <layer_ids.h>
#include <lset.h>
#include <geometry/shape_poly_set.h>
#include <zone_settings.h>
#include <teardrop/teardrop_types.h>
 
 
class LINE_READER;
class PCB_EDIT_FRAME;
class BOARD;
class ZONE;
class MSG_PANEL_ITEM;
 

struct ISOLATED_ISLANDS
{
    std::vector<int> m_IsolatedOutlines;
    std::vector<int> m_SingleConnectionOutlines;
};
 

class ZONE : public BOARD_CONNECTED_ITEM
{
public:
    ZONE( BOARD_ITEM_CONTAINER* parent );
 
    ZONE( const ZONE& aZone );
    ZONE& operator=( const ZONE &aOther );
 
    ~ZONE();
 
    void CopyFrom( const BOARD_ITEM* aOther ) override;
 
    static inline bool ClassOf( const EDA_ITEM* aItem )
    {
        return aItem && aItem->Type() == PCB_ZONE_T;
    }
 
    void Serialize( google::protobuf::Any &aContainer ) const override;
    bool Deserialize( const google::protobuf::Any &aContainer ) override;

    bool IsConnected() const override
    {
        return !GetIsRuleArea();
    }

    void InitDataFromSrcInCopyCtor( const ZONE& aZone, PCB_LAYER_ID aLayer = UNDEFINED_LAYER );

    bool IsConflicting() const;

    VECTOR2I GetPosition() const override;
    void     SetPosition( const VECTOR2I& aPos ) override {}

    void SetAssignedPriority( unsigned aPriority ) { m_priority = aPriority; }

    unsigned GetAssignedPriority() const { return m_priority; }
 
    bool HigherPriority( const ZONE* aOther ) const;
 
    bool SameNet( const ZONE* aOther ) const;
 
    void GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList ) override;
    wxString GetFriendlyName() const override;
 
    void SetLayerSet( const LSET& aLayerSet ) override;
 
    virtual LSET GetLayerSet() const override
    {
        std::lock_guard<std::mutex> lock( m_layerSetMutex );
        return m_layerSet;
    }

    void SetLayerSetAndRemoveUnusedFills( const LSET& aLayerSet );
 
    ZONE_LAYER_PROPERTIES& LayerProperties( PCB_LAYER_ID aLayer )
    {
        return m_layerProperties[aLayer];
    }
 
    std::map<PCB_LAYER_ID, ZONE_LAYER_PROPERTIES>& LayerProperties() { return m_layerProperties; }
 
    const std::map<PCB_LAYER_ID, ZONE_LAYER_PROPERTIES>& LayerProperties() const
    {
        return m_layerProperties;
    }
 
    void SetLayerProperties( const std::map<PCB_LAYER_ID, ZONE_LAYER_PROPERTIES>& aOther );
 
    const wxString& GetZoneName() const { return m_zoneName; }
    void SetZoneName( const wxString& aName ) { m_zoneName = aName; }
 
    bool Matches( const EDA_SEARCH_DATA& aSearchData, void* aAuxData ) const override
    {
        return BOARD_ITEM::Matches( GetZoneName(), aSearchData );
    }

    const BOX2I GetBoundingBox() const override;

    void CacheBoundingBox();

    std::optional<int> GetLocalClearance() const override;
    void SetLocalClearance( std::optional<int> aClearance ) { m_ZoneClearance = aClearance.value_or( 0 ); };

    std::optional<int> GetLocalClearance( wxString* aSource ) const override
    {
        if( m_isRuleArea )
            return std::optional<int>();
 
        if( aSource )
            *aSource = _( "zone" );
 
        return GetLocalClearance();
    }

    bool IsOnCopperLayer() const override;
 
    virtual void SetLayer( PCB_LAYER_ID aLayer ) override;

    bool SetNetCode( int aNetCode, bool aNoAssert ) override;
    using BOARD_CONNECTED_ITEM::SetNetCode;

    void SetNet( NETINFO_ITEM* aNetInfo ) override;
 
    virtual PCB_LAYER_ID GetLayer() const override;
 
    // Return the first layer in GUI sequence.
    PCB_LAYER_ID GetFirstLayer() const;
 
    virtual bool IsOnLayer( PCB_LAYER_ID ) const override;
 
    virtual std::vector<int> ViewGetLayers() const override;
 
    double ViewGetLOD( int aLayer, const KIGFX::VIEW* aView ) const override;
 
    void SetFillMode( ZONE_FILL_MODE aFillMode );
 
    ZONE_FILL_MODE GetFillMode() const { return m_fillMode; }
 
    void SetThermalReliefGap( int aThermalReliefGap )
    {
        if( m_thermalReliefGap != aThermalReliefGap )
            SetNeedRefill( true );
 
        m_thermalReliefGap = aThermalReliefGap;
    }
 
    int GetThermalReliefGap() const { return m_thermalReliefGap; }
    int GetThermalReliefGap( PAD* aPad, wxString* aSource = nullptr ) const;
 
    void SetThermalReliefSpokeWidth( int aThermalReliefSpokeWidth )
    {
        if( m_thermalReliefSpokeWidth != aThermalReliefSpokeWidth )
            SetNeedRefill( true );
 
        m_thermalReliefSpokeWidth = aThermalReliefSpokeWidth;
    }
 
    int GetThermalReliefSpokeWidth() const { return m_thermalReliefSpokeWidth; }

    double CalculateFilledArea();

    double CalculateOutlineArea();

    double GetFilledArea()
    {
        return m_area;
    }

    double GetOutlineArea()
    {
        return m_outlinearea;
    }
 
    int GetFillFlag( PCB_LAYER_ID aLayer )
    {
        std::lock_guard<std::mutex> lock( m_fillFlagsMutex );
        return m_fillFlags.test( aLayer );
    }
 
    void SetFillFlag( PCB_LAYER_ID aLayer, bool aFlag )
    {
        std::lock_guard<std::mutex> lock( m_fillFlagsMutex );
        m_fillFlags.set( aLayer, aFlag );
    }
 
    bool IsFilled() const { return m_isFilled; }
    void SetIsFilled( bool isFilled ) { m_isFilled = isFilled; }
 
    bool NeedRefill() const { return m_needRefill; }
    void SetNeedRefill( bool aNeedRefill ) { m_needRefill = aNeedRefill; }
 
    ZONE_CONNECTION GetPadConnection() const { return m_PadConnection; }
    void SetPadConnection( ZONE_CONNECTION aPadConnection ) { m_PadConnection = aPadConnection; }
 
    int GetMinThickness() const { return m_ZoneMinThickness; }
    void SetMinThickness( int aMinThickness )
    {
        m_ZoneMinThickness            = aMinThickness;
        m_hatchThickness              = std::max( m_hatchThickness, aMinThickness );
        m_hatchGap                    = std::max( m_hatchGap, aMinThickness );
        m_thievingSettings.line_width = std::max( m_thievingSettings.line_width, aMinThickness );
        SetNeedRefill( true );
    }
 
    int GetHatchThickness() const { return m_hatchThickness; }
    void SetHatchThickness( int aThickness ) { m_hatchThickness = aThickness; }
 
    int GetHatchGap() const { return m_hatchGap; }
    void SetHatchGap( int aStep ) { m_hatchGap = aStep; }
 
    EDA_ANGLE GetHatchOrientation() const { return m_hatchOrientation; }
    void SetHatchOrientation( const EDA_ANGLE& aStep ) { m_hatchOrientation = aStep; }
 
    int GetHatchSmoothingLevel() const { return m_hatchSmoothingLevel; }
    void SetHatchSmoothingLevel( int aLevel ) { m_hatchSmoothingLevel = aLevel; }
 
    double GetHatchSmoothingValue() const { return m_hatchSmoothingValue; }
    void SetHatchSmoothingValue( double aValue ) { m_hatchSmoothingValue = aValue; }
 
    double GetHatchHoleMinArea() const { return m_hatchHoleMinArea; }
    void SetHatchHoleMinArea( double aPct ) { m_hatchHoleMinArea = aPct; }
 
    int GetHatchBorderAlgorithm() const { return m_hatchBorderAlgorithm; }
    void SetHatchBorderAlgorithm( int aAlgo ) { m_hatchBorderAlgorithm = aAlgo; }

    bool IsCopperThieving() const { return m_fillMode == ZONE_FILL_MODE::COPPER_THIEVING; }
 
    const THIEVING_SETTINGS& GetThievingSettings() const { return m_thievingSettings; }
    void SetThievingSettings( const THIEVING_SETTINGS& aSettings )
    {
        if( m_thievingSettings != aSettings )
            SetNeedRefill( true );
 
        m_thievingSettings = aSettings;
    }
 
    THIEVING_PATTERN GetThievingPattern() const { return m_thievingSettings.pattern; }
    void SetThievingPattern( THIEVING_PATTERN aPattern )
    {
        if( m_thievingSettings.pattern != aPattern )
            SetNeedRefill( true );
 
        m_thievingSettings.pattern = aPattern;
    }
 
    int GetThievingElementSize() const { return m_thievingSettings.element_size; }
    void SetThievingElementSize( int aSize )
    {
        if( m_thievingSettings.element_size != aSize )
            SetNeedRefill( true );
 
        m_thievingSettings.element_size = aSize;
    }
 
    int GetThievingGap() const { return m_thievingSettings.gap; }
    void SetThievingGap( int aGap )
    {
        if( m_thievingSettings.gap != aGap )
            SetNeedRefill( true );
 
        m_thievingSettings.gap = aGap;
    }
 
    int GetThievingLineWidth() const { return m_thievingSettings.line_width; }
    void SetThievingLineWidth( int aWidth )
    {
        if( m_thievingSettings.line_width != aWidth )
            SetNeedRefill( true );
 
        m_thievingSettings.line_width = aWidth;
    }
 
    bool GetThievingStagger() const { return m_thievingSettings.stagger; }
    void SetThievingStagger( bool aStagger )
    {
        if( m_thievingSettings.stagger != aStagger )
            SetNeedRefill( true );
 
        m_thievingSettings.stagger = aStagger;
    }
 
    EDA_ANGLE GetThievingOrientation() const { return m_thievingSettings.orientation; }
    void SetThievingOrientation( const EDA_ANGLE& aOrientation )
    {
        if( m_thievingSettings.orientation != aOrientation )
            SetNeedRefill( true );
 
        m_thievingSettings.orientation = aOrientation;
    }

    int GetLocalFlags() const { return m_localFlgs; }
    void SetLocalFlags( int aFlags ) { m_localFlgs = aFlags; }
 
    SHAPE_POLY_SET* Outline() { return m_Poly; }
    const SHAPE_POLY_SET* Outline() const { return m_Poly; }
 
    void SetOutline( SHAPE_POLY_SET* aOutline ) { m_Poly = aOutline; }
 
    SHAPE_POLY_SET GetLibraryOutline() const;
 
    SHAPE_POLY_SET GetBoardOutline() const;
 
    // @copydoc BOARD_ITEM::GetEffectiveShape
    virtual std::shared_ptr<SHAPE>
    GetEffectiveShape( PCB_LAYER_ID aLayer = UNDEFINED_LAYER,
                       FLASHING aFlash = FLASHING::DEFAULT ) const override;

    bool HitTest( const VECTOR2I& aPosition, int aAccuracy = 0 ) const override;

    bool HitTestFilledArea( PCB_LAYER_ID aLayer, const VECTOR2I& aRefPos, int aAccuracy = 0 ) const;

    bool HitTestCutout( const VECTOR2I& aRefPos, int* aOutlineIdx = nullptr,
                        int* aHoleIdx = nullptr ) const;

    void GetInteractingZones( PCB_LAYER_ID aLayer, std::vector<ZONE*>* aSameNetCollidingZones,
                              std::vector<ZONE*>* aOtherNetIntersectingZones ) const;

    void TransformSolidAreasShapesToPolygon( PCB_LAYER_ID aLayer, SHAPE_POLY_SET& aBuffer ) const;

    void TransformSmoothedOutlineToPolygon( SHAPE_POLY_SET& aBuffer, int aClearance,
                                            int aError, ERROR_LOC aErrorLoc,
                                            SHAPE_POLY_SET* aBoardOutline ) const;

    void TransformShapeToPolygon( SHAPE_POLY_SET& aBuffer, PCB_LAYER_ID aLayer,
                                  int aClearance, int aError, ERROR_LOC aErrorLoc,
                                  bool ignoreLineWidth = false ) const override;

    bool HitTestForCorner( const VECTOR2I& refPos, int aAccuracy,
                           SHAPE_POLY_SET::VERTEX_INDEX* aCornerHit = nullptr ) const;

    bool HitTestForEdge( const VECTOR2I& refPos, int aAccuracy,
                         SHAPE_POLY_SET::VERTEX_INDEX* aCornerHit = nullptr ) const;

    bool HitTest( const BOX2I& aRect, bool aContained = true, int aAccuracy = 0 ) const override;

    bool HitTest( const SHAPE_LINE_CHAIN& aPoly, bool aContained ) const override;

    bool UnFill();
 
    /* Geometric transformations: */

    void Move( const VECTOR2I& offset ) override;

    void MoveEdge( const VECTOR2I& offset, int aEdge );

    void Rotate( const VECTOR2I& aCentre, const EDA_ANGLE& aAngle ) override;

    virtual void Flip( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection ) override;
 
    void OnFootprintRescaled( double aRatioX, double aRatioY, double aLinearFactor, const VECTOR2I& aAnchor,
                              const EDA_ANGLE& aParentRotate ) override;
 
    void OnFootprintTransformed() override
    {
        SetNeedRefill( true );
        UnFill();
    }

    void Mirror( const VECTOR2I& aMirrorRef, FLIP_DIRECTION aFlipDirection ) override;

    wxString GetClass() const override
    {
        return wxT( "ZONE" );
    }

    int GetNumCorners( void ) const
    {
        return m_Poly->TotalVertices();
    }

    SHAPE_POLY_SET::ITERATOR Iterate()
    {
        return m_Poly->Iterate();
    }

    SHAPE_POLY_SET::ITERATOR IterateWithHoles()
    {
        return m_Poly->IterateWithHoles();
    }

    SHAPE_POLY_SET::CONST_ITERATOR CIterateWithHoles() const
    {
        return m_Poly->CIterateWithHoles();
    }
 
    void RemoveAllContours( void )
    {
        m_Poly->RemoveAllContours();
    }
 
    const VECTOR2I& GetCornerPosition( int aCornerIndex ) const
    {
        SHAPE_POLY_SET::VERTEX_INDEX index;
 
        // Convert global to relative indices
        if( !m_Poly->GetRelativeIndices( aCornerIndex, &index ) )
            throw( std::out_of_range( "aCornerIndex-th vertex does not exist" ) );
 
        return m_Poly->CVertex( index );
    }

    void NewHole()
    {
        m_Poly->NewHole();
    }

    bool AppendCorner( VECTOR2I aPosition, int aHoleIdx, bool aAllowDuplication = false );
 
    ZONE_BORDER_DISPLAY_STYLE GetHatchStyle() const { return m_borderStyle; }
    void SetHatchStyle( ZONE_BORDER_DISPLAY_STYLE aStyle ) { m_borderStyle = aStyle; }
 
    bool HasFilledPolysForLayer( PCB_LAYER_ID aLayer ) const
    {
        std::lock_guard<std::mutex> lock( m_filledPolysListMutex );
        return m_FilledPolysList.count( aLayer ) > 0;
    }

    std::shared_ptr<SHAPE_POLY_SET> GetFilledPolysList( PCB_LAYER_ID aLayer ) const
    {
        std::lock_guard<std::mutex> lock( m_filledPolysListMutex );
        wxASSERT( m_FilledPolysList.count( aLayer ) );
        return m_FilledPolysList.at( aLayer );
    }
 
    SHAPE_POLY_SET* GetFill( PCB_LAYER_ID aLayer )
    {
        std::lock_guard<std::mutex> lock( m_filledPolysListMutex );
 
        auto it = m_FilledPolysList.find( aLayer );
 
        if( it == m_FilledPolysList.end() )
            return nullptr;
 
        return it->second.get();
    }

    void CacheTriangulation( PCB_LAYER_ID aLayer = UNDEFINED_LAYER,
                             const SHAPE_POLY_SET::TASK_SUBMITTER& aSubmitter = {} );

    void SetFilledPolysList( PCB_LAYER_ID aLayer, const SHAPE_POLY_SET& aPolysList )
    {
        std::lock_guard<std::mutex> lock( m_filledPolysListMutex );
        m_FilledPolysList[aLayer] = std::make_shared<SHAPE_POLY_SET>( aPolysList );
    }

    bool IsIsland( PCB_LAYER_ID aLayer, int aPolyIdx ) const;
 
    void SetIsIsland( PCB_LAYER_ID aLayer, int aPolyIdx )
    {
        m_insulatedIslands[aLayer].insert( aPolyIdx );
    }
 
    bool BuildSmoothedPoly( SHAPE_POLY_SET& aSmoothedPoly, PCB_LAYER_ID aLayer,
                            SHAPE_POLY_SET* aBoardOutline,
                            SHAPE_POLY_SET* aSmoothedPolyWithApron = nullptr ) const;
 
    void SetCornerSmoothingType( int aType ) { m_cornerSmoothingType = aType; };
 
    int  GetCornerSmoothingType() const { return m_cornerSmoothingType; }
 
    void SetCornerRadius( unsigned int aRadius );
 
    unsigned int GetCornerRadius() const { return m_cornerRadius; }

    void RemoveCutout( int aOutlineIdx, int aHoleIdx );

    void AddPolygon( std::vector<VECTOR2I>& aPolygon );
 
    void AddPolygon( const SHAPE_LINE_CHAIN& aPolygon );
 
    wxString GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const override;
 
    BITMAPS GetMenuImage() const override;
 
    EDA_ITEM* Clone() const override;
    ZONE* Clone( PCB_LAYER_ID aLayer ) const;

    bool IsTeardropArea() const { return m_teardropType != TEARDROP_TYPE::TD_NONE; }

    void SetTeardropAreaType( TEARDROP_TYPE aType ) { m_teardropType = aType; }

    TEARDROP_TYPE GetTeardropAreaType() const { return m_teardropType; }

    bool HasKeepoutParametersSet() const
    {
        return m_doNotAllowTracks || m_doNotAllowVias || m_doNotAllowPads || m_doNotAllowFootprints
               || m_doNotAllowZoneFills;
    }

    bool GetIsRuleArea() const                    { return m_isRuleArea; }
    void SetIsRuleArea( bool aEnable )            { m_isRuleArea = aEnable; }
    bool GetPlacementAreaEnabled() const          { return m_placementAreaEnabled; }
    void SetPlacementAreaEnabled( bool aEnabled ) { m_placementAreaEnabled = aEnabled; }
 
    wxString GetPlacementAreaSource() const                     { return m_placementAreaSource; }
    void SetPlacementAreaSource( const wxString& aSource )      { m_placementAreaSource = aSource; }
    PLACEMENT_SOURCE_T GetPlacementAreaSourceType() const       { return m_placementAreaSourceType; }
    void SetPlacementAreaSourceType( PLACEMENT_SOURCE_T aType ) { m_placementAreaSourceType = aType; }
 
    bool GetDoNotAllowZoneFills() const  { return m_doNotAllowZoneFills; }
    bool GetDoNotAllowVias() const       { return m_doNotAllowVias; }
    bool GetDoNotAllowTracks() const     { return m_doNotAllowTracks; }
    bool GetDoNotAllowPads() const       { return m_doNotAllowPads; }
    bool GetDoNotAllowFootprints() const { return m_doNotAllowFootprints; }
 
    void SetDoNotAllowZoneFills( bool aEnable )  { m_doNotAllowZoneFills = aEnable; }
    void SetDoNotAllowVias( bool aEnable )       { m_doNotAllowVias = aEnable; }
    void SetDoNotAllowTracks( bool aEnable )     { m_doNotAllowTracks = aEnable; }
    void SetDoNotAllowPads( bool aEnable )       { m_doNotAllowPads = aEnable; }
    void SetDoNotAllowFootprints( bool aEnable ) { m_doNotAllowFootprints = aEnable; }
 
    ISLAND_REMOVAL_MODE GetIslandRemovalMode() const   { return m_islandRemovalMode; }
    void SetIslandRemovalMode( ISLAND_REMOVAL_MODE aRemove ) { m_islandRemovalMode = aRemove; }
 
    long long int GetMinIslandArea() const       { return m_minIslandArea; }
    void SetMinIslandArea( long long int aArea ) { m_minIslandArea = aArea; }


    int GetBorderHatchPitch() const        { return m_borderHatchPitch; }
    void SetBorderHatchPitch( int aPitch ) { m_borderHatchPitch = aPitch; }

    static int GetDefaultHatchPitch();

    void SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE aBorderHatchStyle, int aBorderHatchPitch,
                                bool aRebuilBorderdHatch );

    void UnHatchBorder();

    void HatchBorder();
 
    std::vector<SEG> GetHatchLines() const;

    void BuildHashValue( PCB_LAYER_ID aLayer );

    HASH_128 GetHashValue( PCB_LAYER_ID aLayer );
 
    double Similarity( const BOARD_ITEM& aOther ) const override;
 
    bool operator==( const ZONE& aOther ) const;
    bool operator==( const BOARD_ITEM& aOther ) const override;
 
#if defined(DEBUG)
    virtual void Show( int nestLevel, std::ostream& os ) const override { ShowDummy( os ); }
 
    void SetFillPoly( PCB_LAYER_ID aLayer, SHAPE_POLY_SET* aPoly )
    {
        {
            std::lock_guard<std::mutex> lock( m_filledPolysListMutex );
            m_FilledPolysList[ aLayer ] = std::make_shared<SHAPE_POLY_SET>( *aPoly );
        }
 
        SetFillFlag( aLayer, true );
    }
 
#endif
 
private:
    bool unFillLocked();
 
protected:
    virtual void swapData( BOARD_ITEM* aImage ) override;
 
protected:
    SHAPE_POLY_SET*       m_Poly;                
    int                   m_cornerSmoothingType;
    unsigned int          m_cornerRadius;

    wxString              m_zoneName;
 
    mutable std::mutex    m_layerSetMutex;
    LSET                  m_layerSet;
 
    std::map<PCB_LAYER_ID, ZONE_LAYER_PROPERTIES> m_layerProperties;
 
    /* Priority: when a zone outline is inside and other zone, if its priority is higher
     * the other zone priority, it will be created inside.
     * if priorities are equal, a DRC error is set
     */
    unsigned              m_priority;
 
    /* A zone outline can be a keepout zone.
     * It will be never filled, and DRC should test for pads, tracks and vias
     */
    bool m_isRuleArea;

    bool                  m_placementAreaEnabled;
    PLACEMENT_SOURCE_T    m_placementAreaSourceType;
    wxString              m_placementAreaSource;
 
    /* A zone outline can be a teardrop zone with different rules for priority
     * (always bigger priority than copper zones) and never removed from a
     * copper zone having the same netcode
     */
    TEARDROP_TYPE         m_teardropType;
 
    /* For keepout zones only:
     * what is not allowed inside the keepout ( pads, tracks and vias )
     */
    bool                  m_doNotAllowZoneFills;
    bool                  m_doNotAllowVias;
    bool                  m_doNotAllowTracks;
    bool                  m_doNotAllowPads;
    bool                  m_doNotAllowFootprints;
 
    ZONE_CONNECTION       m_PadConnection;
    int                   m_ZoneClearance;           // Clearance value in internal units.
    int                   m_ZoneMinThickness;        // Minimum thickness value in filled areas.
    int                   m_fillVersion;             // See BOARD_DESIGN_SETTINGS for version
                                                     // differences.
    ISLAND_REMOVAL_MODE   m_islandRemovalMode;

    long long int         m_minIslandArea;

    bool                  m_isFilled;

    std::atomic<bool> m_needRefill;
 
    int              m_thermalReliefGap;        // Width of the gap in thermal reliefs.
    int              m_thermalReliefSpokeWidth; // Width of the copper bridge in thermal reliefs.
 
    ZONE_FILL_MODE   m_fillMode;                // fill with POLYGONS vs HATCH_PATTERN
    int              m_hatchThickness;          // thickness of lines (if 0 -> solid shape)
    int              m_hatchGap;                // gap between lines (0 -> solid shape
    EDA_ANGLE        m_hatchOrientation;        // orientation of grid lines
    int              m_hatchSmoothingLevel;     // 0 = no smoothing
                                                // 1 = fillet
                                                // 2 = arc low def
                                                // 3 = arc high def
    double           m_hatchSmoothingValue;     // hole chamfer/fillet size (ratio of hole size)
    double           m_hatchHoleMinArea;        // min size before holes are dropped (ratio)
    int              m_hatchBorderAlgorithm;    // 0 = use min zone thickness
                                                // 1 = use hatch thickness
 
    THIEVING_SETTINGS m_thievingSettings;       // valid when m_fillMode == COPPER_THIEVING
 
    int              m_localFlgs;               // Variable used in polygon calculations.
 
    /* set of filled polygons used to draw a zone as a filled area.
     * from outlines (m_Poly) but unlike m_Poly these filled polygons have no hole
     * (they are all in one piece)  In very simple cases m_FilledPolysList is same
     * as m_Poly.  In less simple cases (when m_Poly has holes) m_FilledPolysList is
     * a polygon equivalent to m_Poly, without holes but with extra outline segment
     * connecting "holes" with external main outline.  In complex cases an outline
     * described by m_Poly can have many filled areas
     */
    mutable std::mutex                                      m_filledPolysListMutex;
    std::map<PCB_LAYER_ID, std::shared_ptr<SHAPE_POLY_SET>> m_FilledPolysList;

    mutable std::mutex                     m_fillFlagsMutex;
    LSET                                   m_fillFlags;

    std::map<PCB_LAYER_ID, HASH_128>       m_filledPolysHash;
 
    ZONE_BORDER_DISPLAY_STYLE m_borderStyle;       // border display style, see enum above
    int                       m_borderHatchPitch;  // for DIAGONAL_EDGE, distance between 2 lines
    std::vector<SEG>          m_borderHatchLines;  // hatch lines

    std::map<PCB_LAYER_ID, std::set<int>> m_insulatedIslands;
 
    double                    m_area;              // The filled zone area
    double                    m_outlinearea;       // The outline zone area
 
};
 
 
DECLARE_ENUM_TO_WXANY( ZONE_CONNECTION )
DECLARE_ENUM_TO_WXANY( ZONE_FILL_MODE )
DECLARE_ENUM_TO_WXANY( THIEVING_PATTERN )
DECLARE_ENUM_TO_WXANY( ISLAND_REMOVAL_MODE )
DECLARE_ENUM_TO_WXANY( PLACEMENT_SOURCE_T )
 
#endif  // ZONE_H