KiCad PCB EDA Suite
Loading...
Searching...
No Matches
test_constraint_diagnostics.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 The KiCad Developers, see AUTHORS.txt for contributors.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <https://www.gnu.org/licenses/>.
18 */
19
20#include <algorithm>
21#include <vector>
22
24
25#include <board.h>
26#include <core/kicad_algo.h>
27#include <footprint.h>
28#include <pcb_shape.h>
31
33
34using namespace KI_TEST;
35
36
37BOOST_AUTO_TEST_SUITE( ConstraintSolverDiagnostics )
38
39
40// Each cluster on the board maps to the correct per-shape verdict, and unconstrained shapes
41// get no entry.
42BOOST_AUTO_TEST_CASE( PerClusterVerdicts )
43{
44 BOARD board;
45
46 // Cluster 1: a segment with both endpoints pinned -> well constrained (zero free DOF).
47 PCB_SHAPE* wellSeg = addSegment( board, { 0, 0 }, { 10 * MM, 0 } );
49 { { wellSeg->m_Uuid, CONSTRAINT_ANCHOR::START } } );
51 { { wellSeg->m_Uuid, CONSTRAINT_ANCHOR::END } } );
52
53 // Cluster 2: a segment with only a direction constraint -> under constrained.
54 PCB_SHAPE* underSeg = addSegment( board, { 0, 20 * MM }, { 10 * MM, 22 * MM } );
56 { { underSeg->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } } );
57
58 // An unconstrained segment.
59 PCB_SHAPE* loneSeg = addSegment( board, { 0, 40 * MM }, { 5 * MM, 40 * MM } );
60
62
63 BOOST_CHECK( diag.shapeStates[wellSeg->m_Uuid] == CONSTRAINT_STATE::WELL_CONSTRAINED );
64 BOOST_CHECK( diag.shapeStates[underSeg->m_Uuid] == CONSTRAINT_STATE::UNDER_CONSTRAINED );
65 BOOST_CHECK( diag.shapeStates.find( loneSeg->m_Uuid ) == diag.shapeStates.end() );
66
67 // The under-constrained cluster contributes free DOF to the board total.
68 BOOST_CHECK_GT( diag.totalFreeDof, 0 );
69}
70
71
72// Two contradictory fixed-length constraints on one segment are flagged over-constrained.
73BOOST_AUTO_TEST_CASE( ConflictingClusterIsOverConstrained )
74{
75 BOARD board;
76
77 PCB_SHAPE* seg = addSegment( board, { 0, 0 }, { 10 * MM, 0 } );
79 { { seg->m_Uuid, CONSTRAINT_ANCHOR::START } } );
81 { { seg->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } }, 10.0 * MM );
83 { { seg->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } }, 8.0 * MM );
84
86
87 // The contradiction is surfaced: the shape is not reported as cleanly well-constrained.
88 BOOST_CHECK( diag.shapeStates[seg->m_Uuid] == CONSTRAINT_STATE::OVER_CONSTRAINED );
89 BOOST_CHECK( !diag.conflicting.empty() );
90}
91
92
93// A constraint referencing a deleted item is reported as errored (Zulip 2026-06-18 error state).
94BOOST_AUTO_TEST_CASE( DanglingMemberIsErrored )
95{
96 BOARD board;
97
98 PCB_SHAPE* a = addSegment( board, { 0, 0 }, { 10 * MM, 0 } );
99
101 c->AddMember( a->m_Uuid, CONSTRAINT_ANCHOR::END );
102 c->AddMember( KIID(), CONSTRAINT_ANCHOR::START ); // references a non-existent item
103 board.Add( c );
104
105 KIID constraintId = c->m_Uuid;
106
108
109 BOOST_REQUIRE_EQUAL( diag.errored.size(), 1 );
110 BOOST_CHECK( diag.errored[0] == constraintId );
111}
112
113
114// A constraint whose member kind is incompatible with its type (a parallel referencing a circle,
115// e.g. after a shape was changed to a circle) must not disable the whole cluster: it is reported
116// errored while a valid constraint in the same cluster still takes effect.
117BOOST_AUTO_TEST_CASE( IncompatibleKindConstraintIsErroredAndClusterStillSolves )
118{
119 BOARD board;
120
121 PCB_SHAPE* seg = addSegment( board, { 0, 0 }, { 10 * MM, 2 * MM } );
122 PCB_SHAPE* circle = addCircle( board, { 0, 20 * MM }, 5 * MM );
123
124 // Malformed: a parallel cannot map a circle onto a line, so it is unmappable.
126 bad->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
127 bad->AddMember( circle->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
128 board.Add( bad );
129
130 // A valid constraint in the same cluster (shares seg) must still be honoured.
132 { { seg->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } } );
133
135
136 BOOST_CHECK( alg::contains( diag.errored, bad->m_Uuid ) );
137
138 // The cluster was not disabled by the bad constraint: its shapes still get a verdict.
139 BOOST_CHECK( diag.shapeStates.find( seg->m_Uuid ) != diag.shapeStates.end() );
140}
141
142
143// A circle has no endpoints, so a constraint anchored on a circle's START/END is unmappable and is
144// reported errored -- it must never silently alias the circle's centre (which shares that slot).
145BOOST_AUTO_TEST_CASE( CircleEndpointAnchorIsErrored )
146{
147 BOARD board;
148
149 PCB_SHAPE* circle = addCircle( board, { 0, 0 }, 5 * MM );
150 PCB_SHAPE* seg = addSegment( board, { 20 * MM, 0 }, { 30 * MM, 0 } );
151
153 c->AddMember( circle->m_Uuid, CONSTRAINT_ANCHOR::START ); // circles have no START
154 c->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::START );
155 board.Add( c );
156
158
159 BOOST_CHECK( alg::contains( diag.errored, c->m_Uuid ) );
160}
161
162
163// A footprint's own constraints are saved with it but resolved only in the footprint editor, so a
164// board places the footprint as authored and never diagnoses them.
165BOOST_AUTO_TEST_CASE( FootprintConstraintsResolveOnlyInFootprintEditor )
166{
167 BOARD board;
168
169 FOOTPRINT* fp = new FOOTPRINT( &board );
170 board.Add( fp );
171
172 PCB_SHAPE* seg = new PCB_SHAPE( fp, SHAPE_T::SEGMENT );
173 seg->SetStart( { 0, 0 } );
174 seg->SetEnd( { 10 * MM, 2 * MM } );
175 fp->Add( seg );
176
179 fp->Add( c );
180
181 BOOST_CHECK( !BoardHasConstraints( &board ) );
182 BOOST_CHECK( DiagnoseBoardConstraints( &board ).shapeStates.empty() );
183
185
187
188 // The footprint's segment is reported (under-constrained: only a direction is fixed).
189 BOOST_REQUIRE( diag.shapeStates.find( seg->m_Uuid ) != diag.shapeStates.end() );
191}
192
193
194// A reference (non-driving) value that drifted from the geometry it measures is annotation, not a
195// contradiction, so the residual pass must not paint it as conflicting.
196BOOST_AUTO_TEST_CASE( DriftedReferenceValueIsNotConflicting )
197{
198 BOARD board;
199
200 PCB_SHAPE* seg = addSegment( board, { 0, 0 }, { 10 * MM, 0 } );
201
203 { { seg->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } }, 5.0 * MM );
204 len->SetDriving( false );
205
207
208 BOOST_CHECK( !alg::contains( diag.conflicting, len->m_Uuid ) );
209}
210
211
212// A contradiction on one segment of a multi-shape cluster still flags the constraints incident on
213// that segment, and the diagnosis never moves the geometry.
214BOOST_AUTO_TEST_CASE( ContradictionInMultiShapeClusterIsFlagged )
215{
216 BOARD board;
217
218 PCB_SHAPE* doomed = addSegment( board, { 0, 0 }, { 10 * MM, 2 * MM } );
219 PCB_SHAPE* bystander = addSegment( board, { 0, 20 * MM }, { 10 * MM, 20 * MM } );
220
222 { { doomed->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } } );
224 { { doomed->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } } );
225
227 { { doomed->m_Uuid, CONSTRAINT_ANCHOR::WHOLE },
228 { bystander->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } } );
229
231
232 BOOST_CHECK( alg::contains( diag.conflicting, h->m_Uuid )
233 || alg::contains( diag.conflicting, v->m_Uuid ) );
234
235 BOOST_CHECK_EQUAL( doomed->GetStart(), VECTOR2I( 0, 0 ) );
236 BOOST_CHECK_EQUAL( doomed->GetEnd(), VECTOR2I( 10 * MM, 2 * MM ) );
237}
238
239
240// A plain (non-stabilize) solve satisfies horizontal+vertical by collapsing the segment with zero
241// residual, so only the collapse check can flag it. The flags must land on the constraints
242// incident on the collapsed segment; a satisfied constraint on a connected bystander and a
243// reference measurement stay clean.
244BOOST_AUTO_TEST_CASE( ConvergentCollapseFlagsOnlyIncidentConstraints )
245{
246 BOARD board;
247
248 PCB_SHAPE* doomed = addSegment( board, { 0, 0 }, { 10 * MM, 2 * MM } );
249 PCB_SHAPE* bystander = addSegment( board, { 0, 0 }, { 10 * MM, 0 } );
250
252 { { doomed->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } } );
254 { { doomed->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } } );
255
256 // Joins the cluster at a shared endpoint without constraining the doomed segment's length.
258 { { doomed->m_Uuid, CONSTRAINT_ANCHOR::START },
259 { bystander->m_Uuid, CONSTRAINT_ANCHOR::START } } );
260
262 { { bystander->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } } );
263
265 { { doomed->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } }, 5.0 * MM );
266 reference->SetDriving( false );
267
268 std::vector<PCB_CONSTRAINT*> constraints( board.Constraints().begin(), board.Constraints().end() );
269 std::vector<PCB_SHAPE*> shapes{ doomed, bystander };
270
272 BOOST_REQUIRE( adapter.Build( shapes, constraints ) );
273 BOOST_REQUIRE( adapter.Solve() );
274
275 CONSTRAINT_DIAGNOSIS diag = adapter.Diagnose();
276
277 BOOST_CHECK( alg::contains( diag.conflicting, h->m_Uuid )
278 || alg::contains( diag.conflicting, v->m_Uuid ) );
279
280 BOOST_CHECK( !alg::contains( diag.conflicting, bystanderOnly->m_Uuid ) );
281 BOOST_CHECK( !alg::contains( diag.conflicting, reference->m_Uuid ) );
282}
283
284
286
287
288BOOST_AUTO_TEST_SUITE( ConstraintDiagnoserIncremental )
289
290
291// Two independent clusters move a shape in one only that cluster re solves SolveCount up by one
292// other served from cache both verdicts stay correct
293BOOST_AUTO_TEST_CASE( MovingOneShapeReSolvesOnlyItsCluster )
294{
295 BOARD board;
296
297 // Cluster A only a direction constraint under constrained
298 PCB_SHAPE* segA = addSegment( board, { 0, 0 }, { 10 * MM, 2 * MM } );
300 { { segA->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } } );
301
302 // Cluster B both endpoints pinned well constrained disjoint from A
303 PCB_SHAPE* segB = addSegment( board, { 0, 40 * MM }, { 10 * MM, 40 * MM } );
305 { { segB->m_Uuid, CONSTRAINT_ANCHOR::START } } );
307 { { segB->m_Uuid, CONSTRAINT_ANCHOR::END } } );
308
310
311 BOARD_CONSTRAINT_DIAGNOSTICS first = diagnoser.Diagnose( &board );
312 BOOST_CHECK_EQUAL( diagnoser.SolveCount(), 2 );
315
316 // Edit cluster A only constraint set unchanged key survives only hash moves
317 segA->SetEnd( { 12 * MM, 5 * MM } );
318
319 BOARD_CONSTRAINT_DIAGNOSTICS second = diagnoser.Diagnose( &board );
320
321 // Exactly one more cluster was solved -- cluster B came from cache.
322 BOOST_CHECK_EQUAL( diagnoser.SolveCount(), 3 );
325
326 // Nothing changed re solves nothing
327 diagnoser.Diagnose( &board );
328 BOOST_CHECK_EQUAL( diagnoser.SolveCount(), 3 );
329}
330
331
332// Adding a constraint to one cluster changes only that cluster's key/hash, so only it re-solves.
333BOOST_AUTO_TEST_CASE( AddingConstraintReSolvesOnlyItsCluster )
334{
335 BOARD board;
336
337 // Already horizontal pinning both endpoints later stays consistent
338 PCB_SHAPE* segA = addSegment( board, { 0, 0 }, { 10 * MM, 0 } );
340 { { segA->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } } );
341
342 PCB_SHAPE* segB = addSegment( board, { 0, 40 * MM }, { 10 * MM, 40 * MM } );
344 { { segB->m_Uuid, CONSTRAINT_ANCHOR::START } } );
346 { { segB->m_Uuid, CONSTRAINT_ANCHOR::END } } );
347
349
350 diagnoser.Diagnose( &board );
351 BOOST_CHECK_EQUAL( diagnoser.SolveCount(), 2 );
352
353 // Pin A endpoints too well constrained now only A key changes
355 { { segA->m_Uuid, CONSTRAINT_ANCHOR::START } } );
357 { { segA->m_Uuid, CONSTRAINT_ANCHOR::END } } );
358
359 BOARD_CONSTRAINT_DIAGNOSTICS after = diagnoser.Diagnose( &board );
360
361 // Cluster A re-solved once (its key changed); cluster B stayed cached.
362 BOOST_CHECK_EQUAL( diagnoser.SolveCount(), 3 );
363 BOOST_CHECK( after.shapeStates[segA->m_Uuid] == CONSTRAINT_STATE::WELL_CONSTRAINED );
364 BOOST_CHECK( after.shapeStates[segB->m_Uuid] == CONSTRAINT_STATE::WELL_CONSTRAINED );
365}
366
367
368// Editing a driving value changes only its cluster's hash, so only that cluster re-solves.
369BOOST_AUTO_TEST_CASE( ChangingDrivingValueReSolvesOnlyItsCluster )
370{
371 BOARD board;
372
373 PCB_SHAPE* segA = addSegment( board, { 0, 0 }, { 10 * MM, 0 } );
375 { { segA->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } }, 10.0 * MM );
376 lenA->SetDriving( true );
377
378 PCB_SHAPE* segB = addSegment( board, { 0, 40 * MM }, { 10 * MM, 40 * MM } );
380 { { segB->m_Uuid, CONSTRAINT_ANCHOR::START } } );
382 { { segB->m_Uuid, CONSTRAINT_ANCHOR::END } } );
383
385
386 diagnoser.Diagnose( &board );
387 BOOST_CHECK_EQUAL( diagnoser.SolveCount(), 2 );
388
389 lenA->SetValue( 8.0 * MM );
390
391 diagnoser.Diagnose( &board );
392 BOOST_CHECK_EQUAL( diagnoser.SolveCount(), 3 );
393}
394
395
396// Incremental diagnoser matches free function board wide despite cluster caching
397BOOST_AUTO_TEST_CASE( DiagnoserMatchesFreeFunction )
398{
399 BOARD board;
400
401 // A well-constrained cluster.
402 PCB_SHAPE* pinned = addSegment( board, { 0, 0 }, { 10 * MM, 0 } );
404 { { pinned->m_Uuid, CONSTRAINT_ANCHOR::START } } );
406 { { pinned->m_Uuid, CONSTRAINT_ANCHOR::END } } );
407
408 // An under-constrained cluster.
409 PCB_SHAPE* loose = addSegment( board, { 0, 20 * MM }, { 10 * MM, 22 * MM } );
411 { { loose->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } } );
412
413 // An over-constrained cluster.
414 PCB_SHAPE* clash = addSegment( board, { 0, 40 * MM }, { 10 * MM, 40 * MM } );
416 { { clash->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } }, 10.0 * MM );
418 { { clash->m_Uuid, CONSTRAINT_ANCHOR::WHOLE } }, 8.0 * MM );
419
420 // Dangling member constraint for map scan errored path
422 dangling->AddMember( pinned->m_Uuid, CONSTRAINT_ANCHOR::START );
423 dangling->AddMember( KIID(), CONSTRAINT_ANCHOR::START );
424 board.Add( dangling );
425
427
429 BOARD_CONSTRAINT_DIAGNOSTICS incremental = diagnoser.Diagnose( &board );
430
431 auto sorted = []( std::vector<KIID> aVec )
432 {
433 std::sort( aVec.begin(), aVec.end() );
434 return aVec;
435 };
436
437 BOOST_CHECK_EQUAL( incremental.totalFreeDof, reference.totalFreeDof );
438 BOOST_CHECK( incremental.shapeStates == reference.shapeStates );
439 BOOST_CHECK( sorted( incremental.conflicting ) == sorted( reference.conflicting ) );
440 BOOST_CHECK( sorted( incremental.redundant ) == sorted( reference.redundant ) );
441 BOOST_CHECK( sorted( incremental.errored ) == sorted( reference.errored ) );
442
443 // A re-diagnose with no change re-solves nothing, and still matches.
444 std::size_t before = diagnoser.SolveCount();
445 BOARD_CONSTRAINT_DIAGNOSTICS again = diagnoser.Diagnose( &board );
446 BOOST_CHECK_EQUAL( diagnoser.SolveCount(), before );
447 BOOST_CHECK( again.shapeStates == reference.shapeStates );
448}
449
450
@ FPHOLDER
Definition board.h:403
bool BoardHasConstraints(BOARD *aBoard)
True if aBoard resolves at least one geometric constraint (see CollectResolvedConstraints()).
BOARD_CONSTRAINT_DIAGNOSTICS DiagnoseBoardConstraints(BOARD *aBoard)
Diagnose every constraint cluster on the board (validate only – geometry is not changed) and return t...
@ OVER_CONSTRAINED
In a cluster the solver reports as conflicting.
@ UNDER_CONSTRAINED
In a cluster with remaining free degrees of freedom.
@ WELL_CONSTRAINED
In a fully-determined cluster (zero free DOF).
Translates KiCad board geometry to and from the planegcs solver (issue #2329).
bool Solve(const CONSTRAINT_MEMBER &aDragged, const VECTOR2I &aCursor, bool aStabilize=false, const std::set< KIID > &aEdited={}, const std::optional< std::pair< CONSTRAINT_MEMBER, VECTOR2I > > &aCoDragged=std::nullopt, bool aHoldDraggedRigid=false)
Solve the system, pinning a dragged anchor to a cursor position.
bool Build(const std::vector< PCB_SHAPE * > &aShapes, const std::vector< PCB_CONSTRAINT * > &aConstraints, const std::set< KIID > *aFixedShapes=nullptr, const std::vector< PCB_DIMENSION_BASE * > &aDimensions={}, const std::vector< PAD * > &aPads={})
Translate a cluster into a planegcs system.
CONSTRAINT_DIAGNOSIS Diagnose()
Report degrees of freedom and conflicting/redundant constraints.
An incremental DiagnoseBoardConstraints for the interactive edit path.
std::size_t SolveCount() const
Clusters actually re-solved across this diagnoser lifetime for testing cache isolation.
BOARD_CONSTRAINT_DIAGNOSTICS Diagnose(BOARD *aBoard)
Diagnose every cluster reusing cached per-cluster results whose solve inputs are unchanged.
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:411
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Removes an item from the container.
Definition board.cpp:1548
void SetBoardUse(BOARD_USE aUse)
Set what the board is going to be used for.
Definition board.h:423
const CONSTRAINTS & Constraints() const
Geometric constraints (#2329) owned by this board.
Definition board.h:522
const KIID m_Uuid
Definition eda_item.h:599
const VECTOR2I & GetEnd() const
Return the ending point of the graphic.
Definition eda_shape.h:334
const VECTOR2I & GetStart() const
Return the starting point of the graphic.
Definition eda_shape.h:284
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Adds an item to the container.
Definition kiid.h:46
A geometric constraint between board items (issue #2329).
void AddMember(const KIID &aItem, CONSTRAINT_ANCHOR aAnchor=CONSTRAINT_ANCHOR::WHOLE, int aIndex=-1)
void SetDriving(bool aDriving)
void SetEnd(const VECTOR2I &aEnd) override
void SetStart(const VECTOR2I &aStart) override
@ SEGMENT
Definition eda_shape.h:57
Test utilities for timestamps.
PCB_SHAPE * addSegment(BOARD &aBoard, const VECTOR2I &aStart, const VECTOR2I &aEnd)
PCB_SHAPE * addCircle(BOARD &aBoard, const VECTOR2I &aCenter, int aRadius)
constexpr int MM
PCB_CONSTRAINT * addConstraint(BOARD &aBoard, PCB_CONSTRAINT_TYPE aType, const std::vector< CONSTRAINT_MEMBER > &aMembers, std::optional< double > aValue=std::nullopt)
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition kicad_algo.h:96
@ WHOLE
The item as a whole (a segment as a line, a circle).
@ START
First endpoint of a segment or arc.
@ END
Second endpoint of a segment or arc.
@ FIXED_POSITION
A point is locked at its current location.
@ VERTICAL
A segment (or two points) is vertical.
@ COINCIDENT
Two points are made to coincide.
@ HORIZONTAL
A segment (or two points) is horizontal.
@ FIXED_LENGTH
A segment has a driving length value.
@ PARALLEL
Two segments are parallel.
@ EQUAL_LENGTH
Two segments have equal length.
Board-wide diagnostics for the constraint overlay and info bar.
std::map< KIID, CONSTRAINT_STATE > shapeStates
std::vector< KIID > errored
Invalid constraints (member missing, deleted, or of a kind incompatible with the type).
The outcome of a constraint solve, in plain data so callers need not know planegcs.
std::vector< KIID > conflicting
Constraints the solver reports as over-constraining.
BOOST_AUTO_TEST_CASE(HorizontalAlignment)
BOOST_AUTO_TEST_SUITE(CadstarPartParser)
BOOST_AUTO_TEST_CASE(PerClusterVerdicts)
BOOST_CHECK(res.column_datatype(0)==SQL_NUMERIC||res.column_datatype(0)==SQL_DECIMAL)
BOOST_REQUIRE_EQUAL(rows.size(), 1)
BOOST_CHECK_EQUAL(std::any_cast< std::string >(rows[0].at("val")), "12345678901234567.89")
BOOST_REQUIRE(res.columns()==1)
BOOST_AUTO_TEST_SUITE_END()
SHAPE_CIRCLE circle(c.m_circle_center, c.m_circle_radius)
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:708