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-2023 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>
#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();
 
 static inline bool ClassOf( const EDA_ITEM* aItem )
 {
 return aItem && aItem->Type() == PCB_ZONE_T;
 }
 
 bool IsConnected() const override
 {
 return !GetIsRuleArea();
 }
 
 void InitDataFromSrcInCopyCtor( const ZONE& aZone );
 
 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( LSET aLayerSet ) override;
 virtual LSET GetLayerSet() const override { return m_layerSet; }
 
 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();
 
 int GetLocalClearance( wxString* aSource ) const override;
 
 int GetLocalClearance() const { return GetLocalClearance( nullptr ); }
 void SetLocalClearance( int aClearance ) { m_ZoneClearance = aClearance; }
 
 bool IsOnCopperLayer() const override;
 
 virtual void SetLayer( PCB_LAYER_ID aLayer ) 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, bool aIncludeCourtyards = false ) 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; }
 
 double CalculateFilledArea();
 
 double CalculateOutlineArea();
 
 double GetFilledArea()
 {
 return m_area;
 }
 
 double GetOutlineArea()
 {
 return m_outlinearea;
 }
 
 std::mutex& GetLock()
 {
 return m_lock;
 }
 
 int GetFillFlag( PCB_LAYER_ID aLayer )
 {
 return m_fillFlags.test( aLayer );
 }
 
 void SetFillFlag( PCB_LAYER_ID aLayer, bool aFlag ) { 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 )
 {
 if( m_ZoneMinThickness != aMinThickness
 || ( m_fillMode == ZONE_FILL_MODE::HATCH_PATTERN
 && ( m_hatchThickness < aMinThickness || m_hatchGap < aMinThickness ) ) )
 {
 SetNeedRefill( true );
 }
 
 m_ZoneMinThickness = aMinThickness;
 m_hatchThickness = std::max( m_hatchThickness, aMinThickness );
 m_hatchGap = std::max( m_hatchGap, 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; }
 
 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; }
 
 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" ) );
 }
 
 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; }
 
 // @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 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, bool aFlipLeftRight ) override;
 
 void Mirror( const VECTOR2I& 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 VECTOR2I& 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( 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 IsSame( const ZONE &aZoneToCompare );
 
 bool HasFilledPolysForLayer( PCB_LAYER_ID aLayer ) const
 {
 return m_FilledPolysList.count( aLayer ) > 0;
 }
 
 const std::shared_ptr<SHAPE_POLY_SET>& GetFilledPolysList( PCB_LAYER_ID aLayer ) const
 {
 wxASSERT( m_FilledPolysList.count( aLayer ) );
 return m_FilledPolysList.at( aLayer );
 }
 
 SHAPE_POLY_SET* GetFill( PCB_LAYER_ID aLayer )
 {
 wxASSERT( m_FilledPolysList.count( aLayer ) );
 return m_FilledPolysList.at( aLayer ).get();
 }
 
 void CacheTriangulation( PCB_LAYER_ID aLayer = UNDEFINED_LAYER );
 
 void SetFilledPolysList( PCB_LAYER_ID aLayer, const SHAPE_POLY_SET& aPolysList )
 {
 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 ) const override;
 
 BITMAPS GetMenuImage() const override;
 
 EDA_ITEM* Clone() const override;
 
 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 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; }
 
 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; }
 
 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 aBorderHatchStyle, int aBorderHatchPitch,
 bool aRebuilBorderdHatch );
 
 void SetBorderHatchPitch( int aPitch );
 
 void UnHatchBorder();
 
 void HatchBorder();
 
 const std::vector<SEG>& GetHatchLines() const { return m_borderHatchLines; }
 
 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 ); }
 
 void SetFillPoly( PCB_LAYER_ID aLayer, SHAPE_POLY_SET* aPoly )
 {
 m_FilledPolysList[ aLayer ] = std::make_shared<SHAPE_POLY_SET>( *aPoly );
 SetFillFlag( aLayer, true );
 }
 
#endif
 
protected:
 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;
 
 /* 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_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
 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
 
 SHAPE_POLY_SET::VERTEX_INDEX* m_CornerSelection;
 
 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
 */
 std::map<PCB_LAYER_ID, std::shared_ptr<SHAPE_POLY_SET>> m_FilledPolysList;
 
 LSET 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;
 
 double m_area; // The filled zone area
 double m_outlinearea; // The outline zone area
 
 std::mutex m_lock;
};
 
 
#ifndef SWIG
DECLARE_ENUM_TO_WXANY( ZONE_CONNECTION )
DECLARE_ENUM_TO_WXANY( ZONE_FILL_MODE )
#endif
 
#endif // ZONE_H