KiCad PCB EDA Suite
Loading...
Searching...
No Matches
pcb_reference_image.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2011 jean-pierre.charras
5 * Copyright (C) 2022 Mike Williams
6 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, you may find one here:
20 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
21 * or you may search the http://www.gnu.org website for the version 2 license,
22 * or you may write to the Free Software Foundation, Inc.,
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26#include "pcb_reference_image.h"
27
28#include <base_units.h>
29#include <bitmaps.h>
30#include <board.h>
31#include <common.h>
32#include <core/mirror.h>
33#include <eda_draw_frame.h>
34#include <pcb_draw_panel_gal.h>
35#include <pcb_painter.h>
36#include <plotters/plotter.h>
38#include <geometry/shape_rect.h>
40#include <trigo.h>
41
42#include <wx/mstream.h>
43
46
47
49 PCB_LAYER_ID aLayer ) :
51{
52 m_referenceImage.SetPosition( aPos );
53}
54
55
60
61
65
66
68{
69 wxCHECK_MSG( Type() == aItem.Type(), *this,
70 wxT( "Cannot assign object type " ) + aItem.GetClass() + wxT( " to type " )
71 + GetClass() );
72
73 if( &aItem != this )
74 {
75 BOARD_ITEM::operator=( aItem );
76 const PCB_REFERENCE_IMAGE& refImg = static_cast<const PCB_REFERENCE_IMAGE&>( aItem );
78 }
79
80 return *this;
81}
82
83
85{
86 wxCHECK( aOther && aOther->Type() == PCB_REFERENCE_IMAGE_T, /* void */ );
87 *this = *static_cast<const PCB_REFERENCE_IMAGE*>( aOther );
88}
89
90
92{
93 return new PCB_REFERENCE_IMAGE( *this );
94}
95
96
98{
99 wxCHECK_RET( aItem->Type() == PCB_REFERENCE_IMAGE_T,
100 wxString::Format( wxT( "% object cannot swap data with %s object." ),
101 GetClass(), aItem->GetClass() ) );
102
104 std::swap( m_layer, item->m_layer );
105 std::swap( m_isKnockout, item->m_isKnockout );
106 std::swap( m_isLocked, item->m_isLocked );
107 std::swap( m_flags, item->m_flags );
108 std::swap( m_parent, item->m_parent );
109 std::swap( m_forceVisible, item->m_forceVisible );
110 m_referenceImage.SwapData( item->m_referenceImage );
111}
112
113
114double PCB_REFERENCE_IMAGE::ViewGetLOD( int aLayer, const KIGFX::VIEW* aView ) const
115{
116 PCB_PAINTER* painter = static_cast<PCB_PAINTER*>( aView->GetPainter() );
117 PCB_RENDER_SETTINGS* renderSettings = painter->GetSettings();
118
119 // All bitmaps are drawn on LAYER_DRAW_BITMAPS, but their
120 // associated board layer controls their visibility.
121 if( !GetBoard()->IsLayerVisible( m_layer ) )
122 return LOD_HIDE;
123
124 if( renderSettings->GetHighContrast()
126 && !renderSettings->GetLayerIsHighContrast( m_layer ) )
127 {
128 return LOD_HIDE;
129 }
130
131 if( aView->IsLayerVisible( LAYER_DRAW_BITMAPS ) )
132 return LOD_SHOW;
133
134 return LOD_HIDE;
135}
136
137
139{
140 return m_referenceImage.GetBoundingBox();
141}
142
143
145 FLASHING aFlash ) const
146{
147 const BOX2I box = GetBoundingBox();
148 return std::make_shared<SHAPE_RECT>( box.GetPosition(), box.GetWidth(), box.GetHeight() );
149}
150
151
153{
154 return m_referenceImage.GetPosition();
155}
156
157
159{
160 m_referenceImage.SetPosition( aPos );
161}
162
163
164void PCB_REFERENCE_IMAGE::Move( const VECTOR2I& aMoveVector )
165{
166 // Defer to SetPosition to check the new position overflow
167 SetPosition( GetPosition() + aMoveVector );
168}
169
170
171void PCB_REFERENCE_IMAGE::Flip( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
172{
173 m_referenceImage.Flip( aCentre, aFlipDirection );
174}
175
176void PCB_REFERENCE_IMAGE::Rotate( const VECTOR2I& aCenter, const EDA_ANGLE& aAngle )
177{
178 m_referenceImage.Rotate( aCenter, aAngle );
179}
180
181
182#if defined( DEBUG )
183void PCB_REFERENCE_IMAGE::Show( int nestLevel, std::ostream& os ) const
184{
185 // XML output:
186 wxString s = GetClass();
187
188 NestedSpace( nestLevel, os ) << '<' << s.Lower().mb_str() << m_referenceImage.GetPosition()
189 << "/>\n";
190}
191#endif
192
193
194bool PCB_REFERENCE_IMAGE::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
195{
196 return KIGEOM::BoxHitTest( aPosition, GetBoundingBox(), aAccuracy );
197}
198
199
200bool PCB_REFERENCE_IMAGE::HitTest( const BOX2I& aRect, bool aContained, int aAccuracy ) const
201{
202 return KIGEOM::BoxHitTest( aRect, GetBoundingBox(), aContained, aAccuracy );
203}
204
205
206bool PCB_REFERENCE_IMAGE::HitTest( const SHAPE_LINE_CHAIN& aPoly, bool aContained ) const
207{
208 return KIGEOM::BoxHitTest( aPoly, GetBoundingBox(), aContained );
209}
210
211
216
217
219 std::vector<MSG_PANEL_ITEM>& aList )
220{
221 aList.emplace_back( _( "Reference Image" ), wxEmptyString );
222
223 aList.emplace_back( _( "PPI" ),
224 wxString::Format( wxT( "%d " ), m_referenceImage.GetImage().GetPPI() ) );
225 aList.emplace_back( _( "Scale" ),
226 wxString::Format( wxT( "%f " ), m_referenceImage.GetImageScale() ) );
227
228 aList.emplace_back( _( "Width" ),
229 aFrame->MessageTextFromValue( m_referenceImage.GetSize().x ) );
230 aList.emplace_back( _( "Height" ),
231 aFrame->MessageTextFromValue( m_referenceImage.GetSize().y ) );
232 aList.emplace_back( _( "Layer" ), LayerName( m_layer ) );
233}
234
235
237{
238 return { BITMAP_LAYER_FOR( m_layer ) };
239}
240
241
242bool PCB_REFERENCE_IMAGE::operator==( const BOARD_ITEM& aBoardItem ) const
243{
244 if( aBoardItem.Type() != Type() )
245 return false;
246
247 const PCB_REFERENCE_IMAGE& other = static_cast<const PCB_REFERENCE_IMAGE&>( aBoardItem );
248
249 return *this == other;
250}
251
252
254{
255 if( m_layer != aOther.m_layer )
256 return false;
257
258 if( m_referenceImage != aOther.m_referenceImage )
259 return false;
260
261 return true;
262}
263
264
265double PCB_REFERENCE_IMAGE::Similarity( const BOARD_ITEM& aOther ) const
266{
267 if( aOther.Type() != Type() )
268 return 0.0;
269
270 const PCB_REFERENCE_IMAGE& other = static_cast<const PCB_REFERENCE_IMAGE&>( aOther );
271
272 double similarity = 1.0;
273
274 if( m_layer != other.m_layer )
275 similarity *= 0.9;
276
277 similarity *= m_referenceImage.Similarity( other.m_referenceImage );
278
279 return similarity;
280}
281
282
284{
285 return m_referenceImage.GetTransformOriginOffset().x;
286}
287
288
290{
291 VECTOR2I offset = m_referenceImage.GetTransformOriginOffset();
292 offset.x = aX;
293 m_referenceImage.SetTransformOriginOffset( offset );
294}
295
296
298{
299 return m_referenceImage.GetTransformOriginOffset().y;
300}
301
302
304{
305 VECTOR2I offset = m_referenceImage.GetTransformOriginOffset();
306 offset.y = aY;
307 m_referenceImage.SetTransformOriginOffset( offset );
308}
309
310
312{
313 return m_referenceImage.GetImageScale();
314}
315
316
318{
319 m_referenceImage.SetImageScale( aScale );
320}
321
322
324{
325 return m_referenceImage.GetImage().GetSize().x;
326}
327
328
330{
331 m_referenceImage.SetWidth( aWidth );
332}
333
334
336{
337 return m_referenceImage.GetImage().GetSize().y;
338}
339
340
342{
343 m_referenceImage.SetHeight( aHeight );
344}
345
346
348{
350 {
354
355 propMgr.ReplaceProperty( TYPE_HASH( BOARD_ITEM ), _HKI( "Layer" ),
358
359 const wxString groupImage = _HKI( "Image Properties" );
360
364 groupImage );
365
366 propMgr.AddProperty( new PROPERTY<PCB_REFERENCE_IMAGE, int>( _HKI( "Transform Offset X" ),
370 groupImage );
371
372 propMgr.AddProperty( new PROPERTY<PCB_REFERENCE_IMAGE, int>( _HKI( "Transform Offset Y" ),
376 groupImage );
377
378 propMgr.AddProperty( new PROPERTY<PCB_REFERENCE_IMAGE, int>( _HKI( "Width" ),
381 groupImage );
382
383 propMgr.AddProperty( new PROPERTY<PCB_REFERENCE_IMAGE, int>( _HKI( "Height" ),
386 groupImage );
387
388 // For future use
389 const wxString greyscale = _HKI( "Greyscale" );
390 }
constexpr EDA_IU_SCALE pcbIUScale
Definition base_units.h:112
BITMAPS
A list of all bitmap identifiers.
@ HIDDEN
Inactive layers are hidden.
BOX2< VECTOR2I > BOX2I
Definition box2.h:922
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition board_item.h:79
BOARD_ITEM(BOARD_ITEM *aParent, KICAD_T idtype, PCB_LAYER_ID aLayer=F_Cu)
Definition board_item.h:81
virtual PCB_LAYER_ID GetLayer() const
Return the primary layer this item is on.
Definition board_item.h:232
bool m_isKnockout
Definition board_item.h:454
PCB_LAYER_ID m_layer
Definition board_item.h:453
bool m_isLocked
Definition board_item.h:456
virtual void SetLayer(PCB_LAYER_ID aLayer)
Set the layer this item is on.
Definition board_item.h:280
virtual const BOARD * GetBoard() const
Return the BOARD in which this BOARD_ITEM resides, or NULL if none.
constexpr const Vec & GetPosition() const
Definition box2.h:211
constexpr size_type GetWidth() const
Definition box2.h:214
constexpr size_type GetHeight() const
Definition box2.h:215
The base class for create windows for drawing purpose.
EDA_ITEM & operator=(const EDA_ITEM &aItem)
Assign the members of aItem to another object.
Definition eda_item.cpp:328
bool m_forceVisible
Definition eda_item.h:530
KICAD_T Type() const
Returns the type of object.
Definition eda_item.h:110
EDA_ITEM_FLAGS m_flags
Definition eda_item.h:527
EDA_ITEM * m_parent
Owner.
Definition eda_item.h:528
EDA_ITEM(EDA_ITEM *parent, KICAD_T idType, bool isSCH_ITEM=false, bool isBOARD_ITEM=false)
Definition eda_item.cpp:39
Contains methods for drawing PCB-specific items.
virtual PCB_RENDER_SETTINGS * GetSettings() override
Return a pointer to current settings that are going to be used when drawing items.
PCB specific render settings.
Definition pcb_painter.h:81
HIGH_CONTRAST_MODE m_ContrastModeDisplay
bool GetLayerIsHighContrast(int aLayerId) const
Return information whether the queried layer is marked as high-contrast.
virtual wxString GetClass() const =0
Return the class name.
static constexpr double LOD_HIDE
Return this constant from ViewGetLOD() to hide the item unconditionally.
Definition view_item.h:180
static constexpr double LOD_SHOW
Return this constant from ViewGetLOD() to show the item unconditionally.
Definition view_item.h:185
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition view.h:66
bool IsLayerVisible(int aLayer) const
Return information about visibility of a particular layer.
Definition view.h:422
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition view.h:220
Object to handle a bitmap image that can be inserted in a PCB.
void SetTransformOriginOffsetY(int aY)
void swapData(BOARD_ITEM *aItem) override
VECTOR2I GetPosition() const override
Get the position of the image (this is the center of the image).
double Similarity(const BOARD_ITEM &aBoardItem) const override
Return a measure of how likely the other object is to represent the same object.
void Move(const VECTOR2I &aMoveVector) override
Move this object.
virtual std::vector< int > ViewGetLayers() const override
bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const override
Test if aPosition is inside or on the boundary of this item.
void SetTransformOriginOffsetX(int aX)
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
EDA_ITEM * Clone() const override
Create a duplicate of this item with linked list members set to NULL.
bool operator==(const PCB_REFERENCE_IMAGE &aOther) const
void SetImageScale(double aScale)
double ViewGetLOD(int aLayer, const KIGFX::VIEW *aView) const override
Return the level of detail (LOD) of the item.
wxString GetClass() const override
Return the class name.
void Rotate(const VECTOR2I &aCenter, const EDA_ANGLE &aAngle) override
Rotate this object.
void SetPosition(const VECTOR2I &aPosition) override
Set the position of the image.
void Flip(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Flip this object, i.e.
BITMAPS GetMenuImage() const override
Return a pointer to an image to be used in menus.
std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=FLASHING::DEFAULT) const override
Some pad shapes can be complex (rounded/chamfered rectangle), even without considering custom shapes.
PCB_REFERENCE_IMAGE(BOARD_ITEM *aParent, const VECTOR2I &pos=VECTOR2I(0, 0), PCB_LAYER_ID aLayer=F_Cu)
void GetMsgPanelInfo(EDA_DRAW_FRAME *aFrame, std::vector< MSG_PANEL_ITEM > &aList) override
Populate aList of MSG_PANEL_ITEM objects with it's internal state for display purposes.
REFERENCE_IMAGE m_referenceImage
void SetHeight(int aHeight)
PCB_REFERENCE_IMAGE & operator=(const BOARD_ITEM &aItem)
void CopyFrom(const BOARD_ITEM *aOther) override
Provide class metadata.Helper macro to map type hashes to names.
void InheritsAfter(TYPE_ID aDerived, TYPE_ID aBase)
Declare an inheritance relationship between types.
static PROPERTY_MANAGER & Instance()
PROPERTY_BASE & AddProperty(PROPERTY_BASE *aProperty, const wxString &aGroup=wxEmptyString)
Register a property.
PROPERTY_BASE & ReplaceProperty(size_t aBase, const wxString &aName, PROPERTY_BASE *aNew, const wxString &aGroup=wxEmptyString)
Replace an existing property for a specific type.
VECTOR2I GetPosition() const
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
wxString MessageTextFromValue(double aValue, bool aAddUnitLabel=true, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE) const
A lower-precision version of StringFromValue().
The common library.
#define _(s)
a few functions useful in geometry calculations.
wxString LayerName(int aLayer)
Returns the default display name for a given layer.
Definition layer_id.cpp:31
#define BITMAP_LAYER_FOR(boardLayer)
Macros for getting the extra layers for a given board layer.
Definition layer_ids.h:366
FLASHING
Enum used during connectivity building to ensure we do not query connectivity while building the data...
Definition layer_ids.h:184
@ LAYER_DRAW_BITMAPS
Draw images.
Definition layer_ids.h:283
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:60
FLIP_DIRECTION
Definition mirror.h:27
bool BoxHitTest(const VECTOR2I &aHitPoint, const BOX2I &aHittee, int aAccuracy)
Perform a point-to-box hit test.
#define _HKI(x)
Definition page_info.cpp:44
static struct PCB_REFERENCE_IMAGE_DESC _PCB_REFERENCE_IMAGE_DESC
#define TYPE_HASH(x)
Definition property.h:73
@ PT_COORD
Coordinate expressed in distance units (mm/inch)
Definition property.h:64
#define REGISTER_TYPE(x)
@ PCB_REFERENCE_IMAGE_T
class PCB_REFERENCE_IMAGE, bitmap on a layer
Definition typeinfo.h:89
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:695