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 (C) 1992-2021 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, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */

#ifndef ZONE_H
#define ZONE_H


#include <mutex>
#include <vector>
#include <gr_basic.h>
#include <board_item.h>
#include <board_connected_item.h>
#include <layer_ids.h>
#include <geometry/shape_poly_set.h>
#include <zone_settings.h>


class EDA_RECT;
class LINE_READER;
class PCB_EDIT_FRAME;
class BOARD;
class ZONE;
class MSG_PANEL_ITEM;


class ZONE : public BOARD_CONNECTED_ITEM
{
public:

 ZONE( BOARD_ITEM_CONTAINER* parent, bool aInFP = false );

 ZONE( const ZONE& aZone );
 ZONE& operator=( const ZONE &aOther );

 ~ZONE();

 static inline bool ClassOf( const EDA_ITEM* aItem )
 {
 return aItem && aItem->Type() == PCB_ZONE_T;
 }

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

 NETCLASS* GetNetClass() const override
 {
 if( GetIsRuleArea() )
 return nullptr;

 return BOARD_CONNECTED_ITEM::GetNetClass();
 }

 wxString GetNetClassName() const override
 {
 if( GetIsRuleArea() )
 return "UNDEFINED";

 return BOARD_CONNECTED_ITEM::GetNetClassName();
 }

 void InitDataFromSrcInCopyCtor( const ZONE& aZone );

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

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

 unsigned GetPriority() const { return m_priority; }

 void GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList ) override;

 void SetLayerSet( LSET aLayerSet ) override;
 virtual LSET GetLayerSet() const override;

 wxString GetZoneName() const { return m_zoneName; }
 void SetZoneName( const wxString& aName ) { m_zoneName = aName; }

 bool Matches( const wxFindReplaceData& aSearchData, void* aAuxData ) const override
 {
 return BOARD_ITEM::Matches( GetZoneName(), aSearchData );
 }

 const EDA_RECT GetBoundingBox() const override;

 const EDA_RECT GetCachedBoundingBox() const { return m_bboxCache; }
 void CacheBoundingBox() { m_bboxCache = GetBoundingBox(); }

 int GetLocalClearance( wxString* aSource ) const override;

 int GetLocalClearance() const { return GetLocalClearance( nullptr ); }
 void SetLocalClearance( int aClearance ) { m_ZoneClearance = aClearance; }

 bool IsOnCopperLayer() const override;

 bool CommonLayerExists( const LSET aLayerSet ) const;

 virtual void SetLayer( PCB_LAYER_ID aLayer ) override;

 virtual PCB_LAYER_ID GetLayer() const override;

 virtual bool IsOnLayer( PCB_LAYER_ID ) const override;

 virtual void ViewGetLayers( int aLayers[], int& aCount ) const override;

 double ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const override;

 void SetFillMode( ZONE_FILL_MODE aFillMode ) { m_fillMode = 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; }
 int GetThermalReliefSpokeWidth( PAD* aPad, wxString* aSource = nullptr ) const;

 double CalculateFilledArea();

 double GetFilledArea()
 {
 return m_area;
 }

 std::mutex& GetLock()
 {
 return m_lock;
 }

 int GetFillFlag( PCB_LAYER_ID aLayer )
 {
 return m_fillFlags.count( aLayer ) ? m_fillFlags[ aLayer ] : false;
 }

 void SetFillFlag( PCB_LAYER_ID aLayer, bool aFlag ) { m_fillFlags[ 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( PAD* aPad, wxString* aSource = nullptr ) const;
 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 )
 {
 if( m_ZoneMinThickness != aMinThickness )
 SetNeedRefill( true );

 m_ZoneMinThickness = aMinThickness;
 }

 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; }

 double GetHatchOrientation() const { return m_hatchOrientation; }
 void SetHatchOrientation( double 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; }

 int GetSelectedCorner() const
 {
 // Transform relative indices to global index
 int globalIndex = -1;

 if( m_CornerSelection )
 m_Poly->GetGlobalIndex( *m_CornerSelection, globalIndex );

 return globalIndex;
 }

 void SetSelectedCorner( int aCorner )
 {
 SHAPE_POLY_SET::VERTEX_INDEX selectedCorner;

 // If the global index of the corner is correct, assign it to m_CornerSelection
 if( m_Poly->GetRelativeIndices( aCorner, &selectedCorner ) )
 {
 if( m_CornerSelection == nullptr )
 m_CornerSelection = new SHAPE_POLY_SET::VERTEX_INDEX;

 *m_CornerSelection = selectedCorner;
 }
 else
 throw( std::out_of_range( "aCorner-th vertex does not exist" ) );
 }

 // Like HitTest but selects the current corner to be operated on
 void SetSelectedCorner( const wxPoint& aPosition, int aAccuracy );

 int GetLocalFlags() const { return m_localFlgs; }
 void SetLocalFlags( int aFlags ) { m_localFlgs = aFlags; }

 std::vector<SEG>& FillSegments( PCB_LAYER_ID aLayer )
 {
 wxASSERT( m_FillSegmList.count( aLayer ) );
 return m_FillSegmList.at( aLayer );
 }

 const std::vector<SEG>& FillSegments( PCB_LAYER_ID aLayer ) const
 {
 wxASSERT( m_FillSegmList.count( aLayer ) );
 return m_FillSegmList.at( aLayer );
 }

 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; }

 // @copydoc BOARD_ITEM::GetEffectiveShape
 virtual std::shared_ptr<SHAPE>
 GetEffectiveShape( PCB_LAYER_ID aLayer = UNDEFINED_LAYER ) const override;

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

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

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

 bool HitTestCutout( const wxPoint& aRefPos, int* aOutlineIdx = nullptr,
 int* aHoleIdx = nullptr ) const
 {
 return HitTestCutout( VECTOR2I( aRefPos.x, aRefPos.y ), aOutlineIdx, aHoleIdx );
 }

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

 void TransformSolidAreasShapesToPolygon( PCB_LAYER_ID aLayer, SHAPE_POLY_SET& aCornerBuffer,
 int aError = ARC_HIGH_DEF ) const;

 void TransformSmoothedOutlineToPolygon( SHAPE_POLY_SET& aCornerBuffer, int aClearance,
 SHAPE_POLY_SET* aBoardOutline ) const;

 void TransformShapeWithClearanceToPolygon( SHAPE_POLY_SET& aCornerBuffer,
 PCB_LAYER_ID aLayer, int aClearanceValue,
 int aError, ERROR_LOC aErrorLoc,
 bool ignoreLineWidth = false ) const override;

 bool HitTestForCorner( const wxPoint& refPos, int aAccuracy,
 SHAPE_POLY_SET::VERTEX_INDEX& aCornerHit ) const;

 bool HitTestForCorner( const wxPoint& refPos, int aAccuracy ) const;

 bool HitTestForEdge( const wxPoint& refPos, int aAccuracy,
 SHAPE_POLY_SET::VERTEX_INDEX& aCornerHit ) const;

 bool HitTestForEdge( const wxPoint& refPos, int aAccuracy ) const;

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

 bool UnFill();

 /* Geometric transformations: */

 void Move( const wxPoint& offset ) override;

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

 void Rotate( const wxPoint& aCentre, double aAngle ) override;

 virtual void Flip( const wxPoint& aCentre, bool aFlipLeftRight ) override;

 void Mirror( const wxPoint& aMirrorRef, bool aMirrorLeftRight );

 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 SetCornerPosition( int aCornerIndex, const wxPoint& new_pos )
 {
 SHAPE_POLY_SET::VERTEX_INDEX relativeIndices;

 // Convert global to relative indices
 if( m_Poly->GetRelativeIndices( aCornerIndex, &relativeIndices ) )
 {
 if( m_Poly->CVertex( relativeIndices ).x != new_pos.x
 || m_Poly->CVertex( relativeIndices ).y != new_pos.y )
 {
 SetNeedRefill( true );
 m_Poly->SetVertex( relativeIndices, new_pos );
 }
 }
 else
 {
 throw( std::out_of_range( "aCornerIndex-th vertex does not exist" ) );
 }
 }

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

 bool AppendCorner( wxPoint 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 IsSame( const ZONE &aZoneToCompare );

 bool HasFilledPolysForLayer( PCB_LAYER_ID aLayer ) const
 {
 return m_FilledPolysList.count( aLayer ) > 0;
 }

 const SHAPE_POLY_SET& GetFilledPolysList( PCB_LAYER_ID aLayer ) const
 {
 wxASSERT( m_FilledPolysList.count( aLayer ) );
 return m_FilledPolysList.at( aLayer );
 }

 void CacheTriangulation( PCB_LAYER_ID aLayer = UNDEFINED_LAYER );

 void SetFilledPolysList( PCB_LAYER_ID aLayer, const SHAPE_POLY_SET& aPolysList )
 {
 m_FilledPolysList[aLayer] = aPolysList;
 }

 void SetRawPolysList( PCB_LAYER_ID aLayer, const SHAPE_POLY_SET& aPolysList )
 {
 m_RawPolysList[aLayer] = 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; }

 bool GetFilledPolysUseThickness() const { return m_fillVersion == 5; }
 bool GetFilledPolysUseThickness( PCB_LAYER_ID aLayer ) const;

 int GetFillVersion() const { return m_fillVersion; }
 void SetFillVersion( int aVersion ) { m_fillVersion = aVersion; }

 void RemoveCutout( int aOutlineIdx, int aHoleIdx );

 void AddPolygon( std::vector< wxPoint >& aPolygon );

 void AddPolygon( const SHAPE_LINE_CHAIN& aPolygon );

 void SetFillSegments( PCB_LAYER_ID aLayer, const std::vector<SEG>& aSegments )
 {
 m_FillSegmList[aLayer] = aSegments;
 }

 SHAPE_POLY_SET& RawPolysList( PCB_LAYER_ID aLayer )
 {
 wxASSERT( m_RawPolysList.count( aLayer ) );
 return m_RawPolysList.at( aLayer );
 }

 wxString GetSelectMenuText( EDA_UNITS aUnits ) const override;

 BITMAPS GetMenuImage() const override;

 EDA_ITEM* Clone() const override;

 bool GetIsRuleArea() const { return m_isRuleArea; }
 bool GetDoNotAllowCopperPour() const { return m_doNotAllowCopperPour; }
 bool GetDoNotAllowVias() const { return m_doNotAllowVias; }
 bool GetDoNotAllowTracks() const { return m_doNotAllowTracks; }
 bool GetDoNotAllowPads() const { return m_doNotAllowPads; }
 bool GetDoNotAllowFootprints() const { return m_doNotAllowFootprints; }
 bool IsKeepout() const;
 bool KeepoutAll() const;

 void SetIsRuleArea( bool aEnable ) { m_isRuleArea = aEnable; }
 void SetDoNotAllowCopperPour( bool aEnable ) { m_doNotAllowCopperPour = 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; }

 const 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;

 static int GetDefaultHatchPitch();

 void SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE aHatchStyle, int aHatchPitch,
 bool aRebuildHatch );

 void SetHatchPitch( int aPitch );

 void UnHatchBorder();

 void HatchBorder();

 const std::vector<SEG>& GetHatchLines() const { return m_borderHatchLines; }

 bool GetHV45() const { return m_hv45; }
 void SetHV45( bool aConstrain ) { m_hv45 = aConstrain; }

 void BuildHashValue( PCB_LAYER_ID aLayer );

 MD5_HASH GetHashValue( PCB_LAYER_ID aLayer );

#if defined(DEBUG)
 virtual void Show( int nestLevel, std::ostream& os ) const override { ShowDummy( os ); }
#endif

 virtual void SwapData( BOARD_ITEM* aImage ) override;

protected:
 SHAPE_POLY_SET* m_Poly; 
 int m_cornerSmoothingType;
 unsigned int m_cornerRadius;

 wxString m_zoneName;

 LSET m_layerSet;

 /* 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;

 /* For keepout zones only:
 * what is not allowed inside the keepout ( pads, tracks and vias )
 */
 bool m_doNotAllowCopperPour;
 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;

 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;
 int m_hatchThickness; // thickness of lines (if 0 -> solid shape)
 int m_hatchGap; // gap between lines (0 -> solid shape
 double m_hatchOrientation; // orientation in degrees 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

 SHAPE_POLY_SET::VERTEX_INDEX* m_CornerSelection;

 int m_localFlgs; // Variable used in polygon calculations.

 std::map<PCB_LAYER_ID, std::vector<SEG> > m_FillSegmList;

 /* 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
 */
 std::map<PCB_LAYER_ID, SHAPE_POLY_SET> m_FilledPolysList;
 std::map<PCB_LAYER_ID, SHAPE_POLY_SET> m_RawPolysList;

 EDA_RECT m_bboxCache;
 std::map<PCB_LAYER_ID, bool> m_fillFlags;

 std::map<PCB_LAYER_ID, MD5_HASH> 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;

 bool m_hv45; // constrain edges to horiz, vert or 45º

 double m_area; // The filled zone area

 std::mutex m_lock;
};


class FP_ZONE : public ZONE
{
public:
 FP_ZONE( BOARD_ITEM_CONTAINER* aParent );
 FP_ZONE( const FP_ZONE& aZone );
 FP_ZONE& operator=( const FP_ZONE &aOther );

 EDA_ITEM* Clone() const override;

 double ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const override;
};

#endif // ZONE_H